package cn.besteam.modules.system.util;
|
|
import uk.org.okapibarcode.backend.OkapiException;
|
import uk.org.okapibarcode.backend.ReedSolomon;
|
import uk.org.okapibarcode.backend.Symbol;
|
import uk.org.okapibarcode.util.Arrays;
|
import uk.org.okapibarcode.util.EciMode;
|
|
import java.nio.CharBuffer;
|
import java.nio.charset.Charset;
|
|
public class MyQrCode extends Symbol {
|
|
private static final char[] RHODIUM = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', ' ', '$', '%', '*', '+', '-', '.', '/', ':'};
|
|
private static final int[] QR_DATA_CODEWORDS_L = new int[]{19, 34, 55, 80, 108, 136, 156, 194, 232, 274, 324, 370, 428, 461, 523, 589, 647, 721, 795, 861, 932, 1006, 1094, 1174, 1276, 1370, 1468, 1531, 1631, 1735, 1843, 1955, 2071, 2191, 2306, 2434, 2566, 2702, 2812, 2956};
|
|
private static final int[] QR_DATA_CODEWORDS_M = new int[]{16, 28, 44, 64, 86, 108, 124, 154, 182, 216, 254, 290, 334, 365, 415, 453, 507, 563, 627, 669, 714, 782, 860, 914, 1000, 1062, 1128, 1193, 1267, 1373, 1455, 1541, 1631, 1725, 1812, 1914, 1992, 2102, 2216, 2334};
|
|
private static final int[] QR_DATA_CODEWORDS_Q = new int[]{13, 22, 34, 48, 62, 76, 88, 110, 132, 154, 180, 206, 244, 261, 295, 325, 367, 397, 445, 485, 512, 568, 614, 664, 718, 754, 808, 871, 911, 985, 1033, 1115, 1171, 1231, 1286, 1354, 1426, 1502, 1582, 1666};
|
|
private static final int[] QR_DATA_CODEWORDS_H = new int[]{9, 16, 26, 36, 46, 60, 66, 86, 100, 122, 140, 158, 180, 197, 223, 253, 283, 313, 341, 385, 406, 442, 464, 514, 538, 596, 628, 661, 701, 745, 793, 845, 901, 961, 986, 1054, 1096, 1142, 1222, 1276};
|
|
private static final int[] QR_BLOCKS_L = new int[]{1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25};
|
|
private static final int[] QR_BLOCKS_M = new int[]{1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49};
|
|
private static final int[] QR_BLOCKS_Q = new int[]{1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68};
|
|
private static final int[] QR_BLOCKS_H = new int[]{1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81};
|
|
private static final int[] QR_TOTAL_CODEWORDS = new int[]{26, 44, 70, 100, 134, 172, 196, 242, 292, 346, 404, 466, 532, 581, 655, 733, 815, 901, 991, 1085, 1156, 1258, 1364, 1474, 1588, 1706, 1828, 1921, 2051, 2185, 2323, 2465, 2611, 2761, 2876, 3034, 3196, 3362, 3532, 3706};
|
|
private static final int[] QR_SIZES = new int[]{21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 129, 133, 137, 141, 145, 149, 153, 157, 161, 165, 169, 173, 177};
|
|
private static final int[] QR_ALIGN_LOOPSIZE = new int[]{0, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7};
|
|
private static final int[] QR_TABLE_E1 = new int[]{6, 18, 0, 0, 0, 0, 0, 6, 22, 0, 0, 0, 0, 0, 6, 26, 0, 0, 0, 0, 0, 6, 30, 0, 0, 0, 0, 0, 6, 34, 0, 0, 0, 0, 0, 6, 22, 38, 0, 0, 0, 0, 6, 24, 42, 0, 0, 0, 0, 6, 26, 46, 0, 0, 0, 0, 6, 28, 50, 0, 0, 0, 0, 6, 30, 54, 0, 0, 0, 0, 6, 32, 58, 0, 0, 0, 0, 6, 34, 62, 0, 0, 0, 0, 6, 26, 46, 66, 0, 0, 0, 6, 26, 48, 70, 0, 0, 0, 6, 26, 50, 74, 0, 0, 0, 6, 30, 54, 78, 0, 0, 0, 6, 30, 56, 82, 0, 0, 0, 6, 30, 58, 86, 0, 0, 0, 6, 34, 62, 90, 0, 0, 0, 6, 28, 50, 72, 94, 0, 0, 6, 26, 50, 74, 98, 0, 0, 6, 30, 54, 78, 102, 0, 0, 6, 28, 54, 80, 106, 0, 0, 6, 32, 58, 84, 110, 0, 0, 6, 30, 58, 86, 114, 0, 0, 6, 34, 62, 90, 118, 0, 0, 6, 26, 50, 74, 98, 122, 0, 6, 30, 54, 78, 102, 126, 0, 6, 26, 52, 78, 104, 130, 0, 6, 30, 56, 82, 108, 134, 0, 6, 34, 60, 86, 112, 138, 0, 6, 30, 58, 86, 114, 142, 0, 6, 34, 62, 90, 118, 146, 0, 6, 30, 54, 78, 102, 126, 150, 6, 24, 50, 76, 102, 128, 154, 6, 28, 54, 80, 106, 132, 158, 6, 32, 58, 84, 110, 136, 162, 6, 26, 54, 82, 110, 138, 166, 6, 30, 58, 86, 114, 142, 170};
|
|
private static final int[] QR_ANNEX_C = new int[]{21522, 20773, 24188, 23371, 17913, 16590, 20375, 19104, 30660, 29427, 32170, 30877, 26159, 25368, 27713, 26998, 5769, 5054, 7399, 6608, 1890, 597, 3340, 2107, 13663, 12392, 16177, 14854, 9396, 8579, 11994, 11245};
|
|
private static final long[] QR_ANNEX_D = new long[]{31892L, 34236L, 39577L, 42195L, 48118L, 51042L, 55367L, 58893L, 63784L, 68472L, 70749L, 76311L, 79154L, 84390L, 87683L, 92361L, 96236L, 102084L, 102881L, 110507L, 110734L, 117786L, 119615L, 126325L, 127568L, 133589L, 136944L, 141498L, 145311L, 150283L, 152622L, 158308L, 161089L, 167017L};
|
|
private int preferredVersion;
|
|
private MyQrCode.EccLevel preferredEccLevel;
|
|
public MyQrCode() {
|
|
this.preferredEccLevel = MyQrCode.EccLevel.L;
|
}
|
|
public void setPreferredVersion(int version) {
|
|
this.preferredVersion = version;
|
}
|
|
public int getPreferredVersion() {
|
|
return this.preferredVersion;
|
}
|
|
public void setPreferredEccLevel(MyQrCode.EccLevel preferredEccLevel) {
|
|
this.preferredEccLevel = preferredEccLevel;
|
}
|
|
public MyQrCode.EccLevel getPreferredEccLevel() {
|
|
return this.preferredEccLevel;
|
}
|
|
protected boolean gs1Supported() {
|
|
return true;
|
}
|
|
@Override
|
protected void encode() {
|
|
boolean gs1 = this.inputDataType == DataType.GS1;
|
EciMode eci = EciMode.of(this.content, "ISO8859_1", 3).or(this.content, "ISO8859_2", 4).or(this.content, "ISO8859_3", 5).or(this.content, "ISO8859_4", 6).or(this.content, "ISO8859_5", 7).or(this.content, "ISO8859_6", 8).or(this.content, "ISO8859_7", 9).or(this.content, "ISO8859_8", 10).or(this.content, "ISO8859_9", 11).or(this.content, "ISO8859_10", 12).or(this.content, "ISO8859_11", 13).or(this.content, "ISO8859_13", 15).or(this.content, "ISO8859_14", 16).or(this.content, "ISO8859_15", 17).or(this.content, "ISO8859_16", 18).or(this.content, "Windows_1250", 21).or(this.content, "Windows_1251", 22).or(this.content, "Windows_1252", 23).or(this.content, "Windows_1256", 24).or(this.content, "UTF8", 26);
|
if (EciMode.NONE.equals(eci)) {
|
throw new OkapiException("Unable to determine ECI mode.");
|
} else {
|
this.eciMode = eci.mode;
|
this.inputData = toBytes(this.content, eci.charset);
|
this.encodeInfo = this.encodeInfo + "ECI Mode: " + eci.mode + "\n";
|
this.encodeInfo = this.encodeInfo + "ECI Charset: " + eci.charset.name() + "\n";
|
}
|
int i;
|
int proposedBinLen;
|
if (this.eciMode == 20) {
|
Charset c = Charset.forName("Shift_JIS");
|
this.inputData = new int[this.content.length()];
|
for (i = 0; i < this.inputData.length; ++i) {
|
CharBuffer buffer = CharBuffer.wrap(this.content, i, i + 1);
|
byte[] bytes = c.encode(buffer).array();
|
proposedBinLen = bytes.length == 2 ? (bytes[0] & 255) << 8 | bytes[1] & 255 : bytes[0];
|
this.inputData[i] = proposedBinLen;
|
}
|
}
|
MyQrCode.QrMode[] inputMode = new MyQrCode.QrMode[this.inputData.length];
|
defineMode(inputMode, this.inputData);
|
int est_binlen = getBinaryLength(40, inputMode, this.inputData, gs1, this.eciMode);
|
MyQrCode.EccLevel ecc_level = this.preferredEccLevel;
|
short max_cw;
|
switch (this.preferredEccLevel) {
|
case L:
|
default:
|
max_cw = 2956;
|
break;
|
case M:
|
max_cw = 2334;
|
break;
|
case Q:
|
max_cw = 1666;
|
break;
|
case H:
|
max_cw = 1276;
|
}
|
if (est_binlen > 8 * max_cw) {
|
throw new OkapiException("Input too long for selected error correction level");
|
} else {
|
int version = 40;
|
int[] datastream;
|
for (i = 39; i >= 0; --i) {
|
switch (ecc_level) {
|
case L:
|
default:
|
datastream = QR_DATA_CODEWORDS_L;
|
break;
|
case M:
|
datastream = QR_DATA_CODEWORDS_M;
|
break;
|
case Q:
|
datastream = QR_DATA_CODEWORDS_Q;
|
break;
|
case H:
|
datastream = QR_DATA_CODEWORDS_H;
|
}
|
int proposedVersion = i + 1;
|
proposedBinLen = getBinaryLength(proposedVersion, inputMode, this.inputData, gs1, this.eciMode);
|
if (8 * datastream[i] >= proposedBinLen) {
|
version = proposedVersion;
|
est_binlen = proposedBinLen;
|
}
|
}
|
inputMode = applyOptimisation(version, inputMode);
|
if (this.preferredVersion >= 1 && this.preferredVersion <= 40) {
|
if (this.preferredVersion > version) {
|
version = this.preferredVersion;
|
est_binlen = getBinaryLength(this.preferredVersion, inputMode, this.inputData, gs1, this.eciMode);
|
inputMode = applyOptimisation(version, inputMode);
|
}
|
if (this.preferredVersion < version) {
|
throw new OkapiException("Input too long for selected symbol size");
|
}
|
}
|
if (est_binlen <= QR_DATA_CODEWORDS_M[version - 1] * 8) {
|
ecc_level = MyQrCode.EccLevel.M;
|
}
|
if (est_binlen <= QR_DATA_CODEWORDS_Q[version - 1] * 8) {
|
ecc_level = MyQrCode.EccLevel.Q;
|
}
|
if (est_binlen <= QR_DATA_CODEWORDS_H[version - 1] * 8) {
|
ecc_level = MyQrCode.EccLevel.H;
|
}
|
int targetCwCount = QR_DATA_CODEWORDS_L[version - 1];
|
int blocks = QR_BLOCKS_L[version - 1];
|
switch (ecc_level) {
|
case M:
|
targetCwCount = QR_DATA_CODEWORDS_M[version - 1];
|
blocks = QR_BLOCKS_M[version - 1];
|
break;
|
case Q:
|
targetCwCount = QR_DATA_CODEWORDS_Q[version - 1];
|
blocks = QR_BLOCKS_Q[version - 1];
|
break;
|
case H:
|
targetCwCount = QR_DATA_CODEWORDS_H[version - 1];
|
blocks = QR_BLOCKS_H[version - 1];
|
}
|
datastream = new int[targetCwCount + 1];
|
int[] fullstream = new int[QR_TOTAL_CODEWORDS[version - 1] + 1];
|
this.qrBinary(datastream, version, targetCwCount, inputMode, this.inputData, gs1, this.eciMode, est_binlen);
|
addEcc(fullstream, datastream, version, targetCwCount, blocks);
|
int size = QR_SIZES[version - 1];
|
byte[] grid = new byte[size * size];
|
this.encodeInfo = this.encodeInfo + "Version: " + version + "\n";
|
this.encodeInfo = this.encodeInfo + "ECC Level: " + ecc_level.name() + "\n";
|
setupGrid(grid, size, version);
|
populateGrid(grid, size, fullstream, QR_TOTAL_CODEWORDS[version - 1]);
|
if (version >= 7) {
|
addVersionInfo(grid, size, version);
|
}
|
int bitmask = applyBitmask(grid, size, ecc_level);
|
this.encodeInfo = this.encodeInfo + "Mask Pattern: " + Integer.toBinaryString(bitmask) + "\n";
|
addFormatInfo(grid, size, ecc_level, bitmask);
|
this.readable = "";
|
this.pattern = new String[size];
|
this.row_count = size;
|
this.row_height = new int[size];
|
for (i = 0; i < size; ++i) {
|
StringBuilder bin = new StringBuilder(size);
|
for (int j = 0; j < size; ++j) {
|
if ((grid[i * size + j] & 1) != 0) {
|
bin.append('1');
|
} else {
|
bin.append('0');
|
}
|
}
|
this.pattern[i] = bin2pat(bin.toString());
|
this.row_height[i] = 1;
|
}
|
}
|
}
|
|
private static void defineMode(MyQrCode.QrMode[] inputMode, int[] inputData) {
|
|
for (int i = 0; i < inputData.length; ++i) {
|
if (inputData[i] > 255) {
|
inputMode[i] = MyQrCode.QrMode.KANJI;
|
} else {
|
inputMode[i] = MyQrCode.QrMode.BINARY;
|
if (isAlpha(inputData[i])) {
|
inputMode[i] = MyQrCode.QrMode.ALPHANUM;
|
}
|
if (inputData[i] == -1) {
|
inputMode[i] = MyQrCode.QrMode.ALPHANUM;
|
}
|
if (isNumeric(inputData[i])) {
|
inputMode[i] = MyQrCode.QrMode.NUMERIC;
|
}
|
}
|
}
|
}
|
|
private static int getBinaryLength(int version, MyQrCode.QrMode[] inputModeUnoptimized, int[] inputData, boolean gs1, int eciMode) {
|
|
int inputLength = inputModeUnoptimized.length;
|
int count = 0;
|
int percent = 0;
|
MyQrCode.QrMode[] inputMode = applyOptimisation(version, inputModeUnoptimized);
|
MyQrCode.QrMode currentMode = MyQrCode.QrMode.NULL;
|
if (gs1) {
|
count += 4;
|
}
|
if (eciMode != 3) {
|
count += 12;
|
}
|
for (int i = 0; i < inputLength; ++i) {
|
if (inputMode[i] != currentMode) {
|
count += 4;
|
int j;
|
label67:
|
switch (inputMode[i]) {
|
case KANJI:
|
count += tribus(version, 8, 10, 12);
|
count += blockLength(i, inputMode) * 13;
|
break;
|
case BINARY:
|
count += tribus(version, 8, 16, 16);
|
j = i;
|
while (true) {
|
if (j >= i + blockLength(i, inputMode)) {
|
break label67;
|
}
|
if (inputData[j] > 255) {
|
count += 16;
|
} else {
|
count += 8;
|
}
|
++j;
|
}
|
case ALPHANUM:
|
count += tribus(version, 9, 11, 13);
|
int alphaLength = blockLength(i, inputMode);
|
if (gs1) {
|
for (j = i; j < i + alphaLength; ++j) {
|
if (inputData[j] == 37) {
|
++percent;
|
}
|
}
|
}
|
alphaLength += percent;
|
switch (alphaLength % 2) {
|
case 0:
|
count += alphaLength / 2 * 11;
|
break label67;
|
case 1:
|
count += (alphaLength - 1) / 2 * 11;
|
count += 6;
|
default:
|
break label67;
|
}
|
case NUMERIC:
|
count += tribus(version, 10, 12, 14);
|
switch (blockLength(i, inputMode) % 3) {
|
case 0:
|
count += blockLength(i, inputMode) / 3 * 10;
|
break;
|
case 1:
|
count += (blockLength(i, inputMode) - 1) / 3 * 10;
|
count += 4;
|
break;
|
case 2:
|
count += (blockLength(i, inputMode) - 2) / 3 * 10;
|
count += 7;
|
}
|
}
|
currentMode = inputMode[i];
|
}
|
}
|
return count;
|
}
|
|
private static MyQrCode.QrMode[] applyOptimisation(int version, MyQrCode.QrMode[] inputMode) {
|
|
int inputLength = inputMode.length;
|
int blockCount = 0;
|
MyQrCode.QrMode currentMode = MyQrCode.QrMode.NULL;
|
int i;
|
for (i = 0; i < inputLength; ++i) {
|
if (inputMode[i] != currentMode) {
|
currentMode = inputMode[i];
|
++blockCount;
|
}
|
}
|
int[] blockLength = new int[blockCount];
|
MyQrCode.QrMode[] blockMode = new MyQrCode.QrMode[blockCount];
|
int j = -1;
|
currentMode = MyQrCode.QrMode.NULL;
|
for (i = 0; i < inputLength; ++i) {
|
if (inputMode[i] != currentMode) {
|
++j;
|
blockLength[j] = 1;
|
blockMode[j] = inputMode[i];
|
currentMode = inputMode[i];
|
} else {
|
int var10002 = blockLength[j]++;
|
}
|
}
|
if (blockCount > 1) {
|
for (i = 0; i <= blockCount - 2; ++i) {
|
if (blockMode[i] == MyQrCode.QrMode.BINARY) {
|
switch (blockMode[i + 1]) {
|
case KANJI:
|
if (blockLength[i + 1] < tribus(version, 4, 5, 6)) {
|
blockMode[i + 1] = MyQrCode.QrMode.BINARY;
|
}
|
case BINARY:
|
default:
|
break;
|
case ALPHANUM:
|
if (blockLength[i + 1] < tribus(version, 7, 8, 9)) {
|
blockMode[i + 1] = MyQrCode.QrMode.BINARY;
|
}
|
break;
|
case NUMERIC:
|
if (blockLength[i + 1] < tribus(version, 3, 4, 5)) {
|
blockMode[i + 1] = MyQrCode.QrMode.BINARY;
|
}
|
}
|
}
|
if (blockMode[i] == MyQrCode.QrMode.ALPHANUM && blockMode[i + 1] == MyQrCode.QrMode.NUMERIC && blockLength[i + 1] < tribus(version, 6, 8, 10)) {
|
blockMode[i + 1] = MyQrCode.QrMode.ALPHANUM;
|
}
|
}
|
for (i = blockCount - 1; i > 0; --i) {
|
if (blockMode[i] == MyQrCode.QrMode.BINARY) {
|
switch (blockMode[i - 1]) {
|
case KANJI:
|
if (blockLength[i - 1] < tribus(version, 4, 5, 6)) {
|
blockMode[i - 1] = MyQrCode.QrMode.BINARY;
|
}
|
case BINARY:
|
default:
|
break;
|
case ALPHANUM:
|
if (blockLength[i - 1] < tribus(version, 7, 8, 9)) {
|
blockMode[i - 1] = MyQrCode.QrMode.BINARY;
|
}
|
break;
|
case NUMERIC:
|
if (blockLength[i - 1] < tribus(version, 3, 4, 5)) {
|
blockMode[i - 1] = MyQrCode.QrMode.BINARY;
|
}
|
}
|
}
|
if (blockMode[i] == MyQrCode.QrMode.ALPHANUM && blockMode[i - 1] == MyQrCode.QrMode.NUMERIC && blockLength[i - 1] < tribus(version, 6, 8, 10)) {
|
blockMode[i - 1] = MyQrCode.QrMode.ALPHANUM;
|
}
|
}
|
}
|
MyQrCode.QrMode[] optimized = new MyQrCode.QrMode[inputMode.length];
|
j = 0;
|
for (int block = 0; block < blockCount; ++block) {
|
currentMode = blockMode[block];
|
for (i = 0; i < blockLength[block]; ++i) {
|
optimized[j] = currentMode;
|
++j;
|
}
|
}
|
return optimized;
|
}
|
|
private static int blockLength(int start, MyQrCode.QrMode[] inputMode) {
|
|
MyQrCode.QrMode mode = inputMode[start];
|
int count = 0;
|
int i = start;
|
do {
|
++count;
|
} while (i + count < inputMode.length && inputMode[i + count] == mode);
|
return count;
|
}
|
|
private static int tribus(int version, int a, int b, int c) {
|
|
if (version < 10) {
|
return a;
|
} else {
|
return version >= 10 && version <= 26 ? b : c;
|
}
|
}
|
|
private static boolean isAlpha(int c) {
|
|
return c >= 48 && c <= 57 || c >= 65 && c <= 90 || c == 32 || c == 36 || c == 37 || c == 42 || c == 43 || c == 45 || c == 46 || c == 47 || c == 58;
|
}
|
|
private static boolean isNumeric(int c) {
|
|
return c >= 48 && c <= 57;
|
}
|
|
private void qrBinary(int[] datastream, int version, int target_binlen, MyQrCode.QrMode[] inputMode, int[] inputData, boolean gs1, int eciMode, int est_binlen) {
|
|
int position = 0;
|
StringBuilder binary = new StringBuilder(est_binlen + 12);
|
if (gs1) {
|
binary.append("0101");
|
}
|
if (eciMode != 3) {
|
binary.append("0111");
|
if (eciMode <= 127) {
|
binaryAppend(eciMode, 8, binary);
|
} else if (eciMode <= 16383) {
|
binaryAppend('耀' + eciMode, 16, binary);
|
} else {
|
binaryAppend(12582912 + eciMode, 24, binary);
|
}
|
}
|
this.encodeInfo = this.encodeInfo + "Encoding: ";
|
int i;
|
int p;
|
do {
|
MyQrCode.QrMode data_block = inputMode[position];
|
int short_data_block_length = 0;
|
do {
|
++short_data_block_length;
|
} while (short_data_block_length + position < inputMode.length && inputMode[position + short_data_block_length] == data_block);
|
int first;
|
int prod;
|
label170:
|
switch (data_block) {
|
case KANJI:
|
binary.append("1000");
|
binaryAppend(short_data_block_length, tribus(version, 8, 10, 12), binary);
|
this.encodeInfo = this.encodeInfo + "KNJI ";
|
for (i = 0; i < short_data_block_length; ++i) {
|
p = inputData[position + i];
|
if (p >= 33088 && p <= 40956) {
|
p -= 33088;
|
} else if (p >= 57408 && p <= 60351) {
|
p -= 49472;
|
}
|
prod = (p >> 8) * 192 + (p & 255);
|
binaryAppend(prod, 13, binary);
|
this.encodeInfo = this.encodeInfo + Integer.toString(prod) + " ";
|
}
|
break;
|
case BINARY:
|
binary.append("0100");
|
binaryAppend(short_data_block_length, tribus(version, 8, 16, 16), binary);
|
this.encodeInfo = this.encodeInfo + "BYTE ";
|
i = 0;
|
while (true) {
|
if (i >= short_data_block_length) {
|
break label170;
|
}
|
p = inputData[position + i];
|
if (p == -1) {
|
p = 29;
|
}
|
binaryAppend(p, 8, binary);
|
this.encodeInfo = this.encodeInfo + Integer.toString(p) + " ";
|
++i;
|
}
|
case ALPHANUM:
|
binary.append("0010");
|
p = 0;
|
if (gs1) {
|
for (i = 0; i < short_data_block_length; ++i) {
|
if (inputData[position + i] == 37) {
|
++p;
|
}
|
}
|
}
|
int[] inputExpanded = new int[short_data_block_length + p];
|
p = 0;
|
for (i = 0; i < short_data_block_length; ++i) {
|
first = inputData[position + i];
|
if (first == -1) {
|
inputExpanded[i + p] = 37;
|
} else {
|
inputExpanded[i + p] = first;
|
if (gs1 && first == 37) {
|
++p;
|
inputExpanded[i + p] = first;
|
}
|
}
|
}
|
binaryAppend(inputExpanded.length, tribus(version, 9, 11, 13), binary);
|
this.encodeInfo = this.encodeInfo + "ALPH ";
|
for (i = 0; i + 1 < inputExpanded.length; i += 2) {
|
first = Arrays.positionOf((char) inputExpanded[i], RHODIUM);
|
int second = Arrays.positionOf((char) inputExpanded[i + 1], RHODIUM);
|
prod = first * 45 + second;
|
int count = 2;
|
binaryAppend(prod, 1 + 5 * count, binary);
|
this.encodeInfo = this.encodeInfo + Integer.toString(prod) + " ";
|
}
|
if (inputExpanded.length % 2 != 0) {
|
first = Arrays.positionOf((char) inputExpanded[inputExpanded.length - 1], RHODIUM);
|
int count = 1;
|
binaryAppend(first, 1 + 5 * count, binary);
|
this.encodeInfo = this.encodeInfo + Integer.toString(first) + " ";
|
}
|
break;
|
case NUMERIC:
|
binary.append("0001");
|
binaryAppend(short_data_block_length, tribus(version, 10, 12, 14), binary);
|
this.encodeInfo = this.encodeInfo + "NUMB ";
|
byte count;
|
for (i = 0; i < short_data_block_length; i += count) {
|
first = Character.getNumericValue(inputData[position + i]);
|
count = 1;
|
prod = first;
|
if (i + 1 < short_data_block_length) {
|
int second = Character.getNumericValue(inputData[position + i + 1]);
|
count = 2;
|
prod = first * 10 + second;
|
if (i + 2 < short_data_block_length) {
|
int third = Character.getNumericValue(inputData[position + i + 2]);
|
count = 3;
|
prod = prod * 10 + third;
|
}
|
}
|
binaryAppend(prod, 1 + 3 * count, binary);
|
this.encodeInfo = this.encodeInfo + Integer.toString(prod) + " ";
|
}
|
}
|
position += short_data_block_length;
|
} while (position < inputMode.length);
|
this.encodeInfo = this.encodeInfo + "\n";
|
binary.append("0000");
|
int current_binlen = binary.length();
|
int padbits = 8 - current_binlen % 8;
|
if (padbits == 8) {
|
padbits = 0;
|
}
|
int current_bytes = (current_binlen + padbits) / 8;
|
for (i = 0; i < padbits; ++i) {
|
binary.append('0');
|
}
|
for (i = 0; i < current_bytes; ++i) {
|
datastream[i] = 0;
|
for (p = 0; p < 8; ++p) {
|
if (binary.charAt(i * 8 + p) == '1') {
|
datastream[i] += 128 >> p;
|
}
|
}
|
}
|
boolean toggle = false;
|
for (i = current_bytes; i < target_binlen; ++i) {
|
if (!toggle) {
|
datastream[i] = 236;
|
toggle = true;
|
} else {
|
datastream[i] = 17;
|
toggle = false;
|
}
|
}
|
this.encodeInfo = this.encodeInfo + "Codewords: ";
|
for (i = 0; i < target_binlen; ++i) {
|
this.encodeInfo = this.encodeInfo + Integer.toString(datastream[i]) + " ";
|
}
|
this.encodeInfo = this.encodeInfo + "\n";
|
}
|
|
private static void binaryAppend(int value, int length, StringBuilder binary) {
|
|
int start = 1 << length - 1;
|
for (int i = 0; i < length; ++i) {
|
if ((value & start >> i) != 0) {
|
binary.append('1');
|
} else {
|
binary.append('0');
|
}
|
}
|
}
|
|
private static void addEcc(int[] fullstream, int[] datastream, int version, int data_cw, int blocks) {
|
|
int ecc_cw = QR_TOTAL_CODEWORDS[version - 1] - data_cw;
|
int short_data_block_length = data_cw / blocks;
|
int qty_long_blocks = data_cw % blocks;
|
int qty_short_blocks = blocks - qty_long_blocks;
|
int ecc_block_length = ecc_cw / blocks;
|
int[] data_block = new int[short_data_block_length + 2];
|
int[] ecc_block = new int[ecc_block_length + 2];
|
int[] interleaved_data = new int[data_cw + 2];
|
int[] interleaved_ecc = new int[ecc_cw + 2];
|
int posn = 0;
|
int j;
|
for (int i = 0; i < blocks; ++i) {
|
int length_this_block;
|
if (i < qty_short_blocks) {
|
length_this_block = short_data_block_length;
|
} else {
|
length_this_block = short_data_block_length + 1;
|
}
|
for (j = 0; j < ecc_block_length; ++j) {
|
ecc_block[j] = 0;
|
}
|
for (j = 0; j < length_this_block; ++j) {
|
data_block[j] = datastream[posn + j];
|
}
|
ReedSolomon rs = new ReedSolomon();
|
rs.init_gf(285);
|
rs.init_code(ecc_block_length, 0);
|
rs.encode(length_this_block, data_block);
|
for (j = 0; j < ecc_block_length; ++j) {
|
ecc_block[j] = rs.getResult(j);
|
}
|
for (j = 0; j < short_data_block_length; ++j) {
|
interleaved_data[j * blocks + i] = data_block[j];
|
}
|
if (i >= qty_short_blocks) {
|
interleaved_data[short_data_block_length * blocks + (i - qty_short_blocks)] = data_block[short_data_block_length];
|
}
|
for (j = 0; j < ecc_block_length; ++j) {
|
interleaved_ecc[j * blocks + i] = ecc_block[ecc_block_length - j - 1];
|
}
|
posn += length_this_block;
|
}
|
for (j = 0; j < data_cw; ++j) {
|
fullstream[j] = interleaved_data[j];
|
}
|
for (j = 0; j < ecc_cw; ++j) {
|
fullstream[j + data_cw] = interleaved_ecc[j];
|
}
|
}
|
|
private static void setupGrid(byte[] grid, int size, int version) {
|
|
boolean toggle = true;
|
int i;
|
for (i = 0; i < size; ++i) {
|
if (toggle) {
|
grid[6 * size + i] = 33;
|
grid[i * size + 6] = 33;
|
toggle = false;
|
} else {
|
grid[6 * size + i] = 32;
|
grid[i * size + 6] = 32;
|
toggle = true;
|
}
|
}
|
placeFinder(grid, size, 0, 0);
|
placeFinder(grid, size, 0, size - 7);
|
placeFinder(grid, size, size - 7, 0);
|
for (i = 0; i < 7; ++i) {
|
grid[7 * size + i] = 16;
|
grid[i * size + 7] = 16;
|
grid[7 * size + (size - 1 - i)] = 16;
|
grid[i * size + (size - 8)] = 16;
|
grid[(size - 8) * size + i] = 16;
|
grid[(size - 1 - i) * size + 7] = 16;
|
}
|
grid[7 * size + 7] = 16;
|
grid[7 * size + (size - 8)] = 16;
|
grid[(size - 8) * size + 7] = 16;
|
if (version != 1) {
|
int loopsize = QR_ALIGN_LOOPSIZE[version - 1];
|
for (int x = 0; x < loopsize; ++x) {
|
for (int y = 0; y < loopsize; ++y) {
|
int xcoord = QR_TABLE_E1[(version - 2) * 7 + x];
|
int ycoord = QR_TABLE_E1[(version - 2) * 7 + y];
|
if ((grid[ycoord * size + xcoord] & 16) == 0) {
|
placeAlign(grid, size, xcoord, ycoord);
|
}
|
}
|
}
|
}
|
for (i = 0; i < 8; ++i) {
|
grid[8 * size + i] = (byte) (grid[8 * size + i] + 32);
|
grid[i * size + 8] = (byte) (grid[i * size + 8] + 32);
|
grid[8 * size + (size - 1 - i)] = 32;
|
grid[(size - 1 - i) * size + 8] = 32;
|
}
|
grid[8 * size + 8] = (byte) (grid[8 * size + 8] + 32);
|
grid[(size - 1 - 7) * size + 8] = 33;
|
if (version >= 7) {
|
for (i = 0; i < 6; ++i) {
|
grid[(size - 9) * size + i] = 32;
|
grid[(size - 10) * size + i] = 32;
|
grid[(size - 11) * size + i] = 32;
|
grid[i * size + (size - 9)] = 32;
|
grid[i * size + (size - 10)] = 32;
|
grid[i * size + (size - 11)] = 32;
|
}
|
}
|
}
|
|
private static void placeFinder(byte[] grid, int size, int x, int y) {
|
|
int[] finder = new int[]{1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1};
|
for (int xp = 0; xp < 7; ++xp) {
|
for (int yp = 0; yp < 7; ++yp) {
|
if (finder[xp + 7 * yp] == 1) {
|
grid[(yp + y) * size + xp + x] = 17;
|
} else {
|
grid[(yp + y) * size + xp + x] = 16;
|
}
|
}
|
}
|
}
|
|
private static void placeAlign(byte[] grid, int size, int x, int y) {
|
|
int[] alignment = new int[]{1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1};
|
x -= 2;
|
y -= 2;
|
for (int xp = 0; xp < 5; ++xp) {
|
for (int yp = 0; yp < 5; ++yp) {
|
if (alignment[xp + 5 * yp] == 1) {
|
grid[(yp + y) * size + xp + x] = 17;
|
} else {
|
grid[(yp + y) * size + xp + x] = 16;
|
}
|
}
|
}
|
}
|
|
private static void populateGrid(byte[] grid, int size, int[] fullstream, int cw) {
|
|
boolean goingUp = true;
|
int row = 0;
|
int n = cw * 8;
|
int y = size - 1;
|
int i = 0;
|
do {
|
int x = size - 2 - row * 2;
|
if (x < 6) {
|
--x;
|
}
|
if ((grid[y * size + x + 1] & 240) == 0) {
|
if (cwbit(fullstream, i)) {
|
grid[y * size + x + 1] = 1;
|
} else {
|
grid[y * size + x + 1] = 0;
|
}
|
++i;
|
}
|
if (i < n && (grid[y * size + x] & 240) == 0) {
|
if (cwbit(fullstream, i)) {
|
grid[y * size + x] = 1;
|
} else {
|
grid[y * size + x] = 0;
|
}
|
++i;
|
}
|
if (goingUp) {
|
--y;
|
} else {
|
++y;
|
}
|
if (y == -1) {
|
++row;
|
y = 0;
|
goingUp = false;
|
}
|
if (y == size) {
|
++row;
|
y = size - 1;
|
goingUp = true;
|
}
|
} while (i < n);
|
}
|
|
private static boolean cwbit(int[] fullstream, int i) {
|
|
return (fullstream[i / 8] & 128 >> i % 8) != 0;
|
}
|
|
private static int applyBitmask(byte[] grid, int size, MyQrCode.EccLevel ecc_level) {
|
|
int[] penalty = new int[8];
|
byte[] mask = new byte[size * size];
|
byte[] eval = new byte[size * size];
|
int x;
|
int y;
|
for (x = 0; x < size; ++x) {
|
for (y = 0; y < size; ++y) {
|
mask[y * size + x] = 0;
|
if ((grid[y * size + x] & 240) == 0) {
|
if ((y + x & 1) == 0) {
|
++mask[y * size + x];
|
}
|
if ((y & 1) == 0) {
|
mask[y * size + x] = (byte) (mask[y * size + x] + 2);
|
}
|
if (x % 3 == 0) {
|
mask[y * size + x] = (byte) (mask[y * size + x] + 4);
|
}
|
if ((y + x) % 3 == 0) {
|
mask[y * size + x] = (byte) (mask[y * size + x] + 8);
|
}
|
if ((y / 2 + x / 3 & 1) == 0) {
|
mask[y * size + x] = (byte) (mask[y * size + x] + 16);
|
}
|
if ((y * x & 1) + y * x % 3 == 0) {
|
mask[y * size + x] = (byte) (mask[y * size + x] + 32);
|
}
|
if (((y * x & 1) + y * x % 3 & 1) == 0) {
|
mask[y * size + x] = (byte) (mask[y * size + x] + 64);
|
}
|
if (((y + x & 1) + y * x % 3 & 1) == 0) {
|
mask[y * size + x] = (byte) (mask[y * size + x] + 128);
|
}
|
}
|
}
|
}
|
for (x = 0; x < size; ++x) {
|
for (y = 0; y < size; ++y) {
|
short p;
|
if ((grid[y * size + x] & 1) != 0) {
|
p = 255;
|
} else {
|
p = 0;
|
}
|
eval[y * size + x] = (byte) (mask[y * size + x] ^ p);
|
}
|
}
|
int pattern;
|
for (pattern = 0; pattern < 8; ++pattern) {
|
addFormatInfoEval(eval, size, ecc_level, pattern);
|
penalty[pattern] = evaluate(eval, size, pattern);
|
}
|
int best_pattern = 0;
|
int best_val = penalty[0];
|
for (pattern = 1; pattern < 8; ++pattern) {
|
if (penalty[pattern] < best_val) {
|
best_pattern = pattern;
|
best_val = penalty[pattern];
|
}
|
}
|
for (x = 0; x < size; ++x) {
|
for (y = 0; y < size; ++y) {
|
if ((mask[y * size + x] & 1 << best_pattern) != 0) {
|
if ((grid[y * size + x] & 1) != 0) {
|
grid[y * size + x] = 0;
|
} else {
|
grid[y * size + x] = 1;
|
}
|
}
|
}
|
}
|
return best_pattern;
|
}
|
|
private static void addFormatInfoEval(byte[] eval, int size, MyQrCode.EccLevel ecc_level, int pattern) {
|
|
int format = pattern;
|
switch (ecc_level) {
|
case L:
|
format = pattern + 8;
|
case M:
|
default:
|
break;
|
case Q:
|
format = pattern + 24;
|
break;
|
case H:
|
format = pattern + 16;
|
}
|
int seq = QR_ANNEX_C[format];
|
int i;
|
for (i = 0; i < 6; ++i) {
|
eval[i * size + 8] = (byte) ((seq >> i & 1) != 0 ? 1 >> pattern : 0);
|
}
|
for (i = 0; i < 8; ++i) {
|
eval[8 * size + (size - i - 1)] = (byte) ((seq >> i & 1) != 0 ? 1 >> pattern : 0);
|
}
|
for (i = 0; i < 6; ++i) {
|
eval[8 * size + (5 - i)] = (byte) ((seq >> i + 9 & 1) != 0 ? 1 >> pattern : 0);
|
}
|
for (i = 0; i < 7; ++i) {
|
eval[(size - 7 + i) * size + 8] = (byte) ((seq >> i + 8 & 1) != 0 ? 1 >> pattern : 0);
|
}
|
eval[7 * size + 8] = (byte) ((seq >> 6 & 1) != 0 ? 1 >> pattern : 0);
|
eval[8 * size + 8] = (byte) ((seq >> 7 & 1) != 0 ? 1 >> pattern : 0);
|
eval[8 * size + 7] = (byte) ((seq >> 8 & 1) != 0 ? 1 >> pattern : 0);
|
}
|
|
private static int evaluate(byte[] eval, int size, int pattern) {
|
|
int result = 0;
|
byte[] local = new byte[size * size];
|
int x;
|
int y;
|
for (x = 0; x < size; ++x) {
|
for (y = 0; y < size; ++y) {
|
if ((eval[y * size + x] & 1 << pattern) != 0) {
|
local[y * size + x] = 49;
|
} else {
|
local[y * size + x] = 48;
|
}
|
}
|
}
|
int block;
|
byte state;
|
for (x = 0; x < size; ++x) {
|
state = local[x];
|
block = 0;
|
for (y = 0; y < size; ++y) {
|
if (local[y * size + x] == state) {
|
++block;
|
} else {
|
if (block > 5) {
|
result += 3 + (block - 5);
|
}
|
block = 0;
|
state = local[y * size + x];
|
}
|
}
|
if (block > 5) {
|
result += 3 + (block - 5);
|
}
|
}
|
for (y = 0; y < size; ++y) {
|
state = local[y * size];
|
block = 0;
|
for (x = 0; x < size; ++x) {
|
if (local[y * size + x] == state) {
|
++block;
|
} else {
|
if (block > 5) {
|
result += 3 + (block - 5);
|
}
|
block = 0;
|
state = local[y * size + x];
|
}
|
}
|
if (block > 5) {
|
result += 3 + (block - 5);
|
}
|
}
|
for (x = 0; x < size - 1; ++x) {
|
for (y = 0; y < size - 1; ++y) {
|
if (local[y * size + x] == local[(y + 1) * size + x] && local[y * size + x] == local[y * size + x + 1] && local[y * size + x] == local[(y + 1) * size + x + 1]) {
|
result += 3;
|
}
|
}
|
}
|
int weight;
|
int p;
|
int a;
|
int b;
|
int afterCount;
|
int beforeCount;
|
for (x = 0; x < size; ++x) {
|
for (y = 0; y < size - 7; ++y) {
|
p = 0;
|
for (weight = 0; weight < 7; ++weight) {
|
if (local[(y + weight) * size + x] == 49) {
|
p += 64 >> weight;
|
}
|
}
|
if (p == 93) {
|
beforeCount = 0;
|
for (b = y - 4; b < y; ++b) {
|
if (b < 0) {
|
++beforeCount;
|
} else if (local[b * size + x] == 48) {
|
++beforeCount;
|
} else {
|
beforeCount = 0;
|
}
|
}
|
afterCount = 0;
|
for (a = y + 7; a <= y + 10; ++a) {
|
if (a >= size) {
|
++afterCount;
|
} else if (local[a * size + x] == 48) {
|
++afterCount;
|
} else {
|
afterCount = 0;
|
}
|
}
|
if (beforeCount == 4 || afterCount == 4) {
|
result += 40;
|
}
|
}
|
}
|
}
|
for (y = 0; y < size; ++y) {
|
for (x = 0; x < size - 7; ++x) {
|
p = 0;
|
for (weight = 0; weight < 7; ++weight) {
|
if (local[y * size + x + weight] == 49) {
|
p += 64 >> weight;
|
}
|
}
|
if (p == 93) {
|
beforeCount = 0;
|
for (b = x - 4; b < x; ++b) {
|
if (b < 0) {
|
++beforeCount;
|
} else if (local[y * size + b] == 48) {
|
++beforeCount;
|
} else {
|
beforeCount = 0;
|
}
|
}
|
afterCount = 0;
|
for (a = x + 7; a <= x + 10; ++a) {
|
if (a >= size) {
|
++afterCount;
|
} else if (local[y * size + a] == 48) {
|
++afterCount;
|
} else {
|
afterCount = 0;
|
}
|
}
|
if (beforeCount == 4 || afterCount == 4) {
|
result += 40;
|
}
|
}
|
}
|
}
|
int dark_mods = 0;
|
for (x = 0; x < size; ++x) {
|
for (y = 0; y < size; ++y) {
|
if (local[y * size + x] == 49) {
|
++dark_mods;
|
}
|
}
|
}
|
int percentage = 100 * (dark_mods / (size * size));
|
int k;
|
if (percentage <= 50) {
|
k = (100 - percentage - 50) / 5;
|
} else {
|
k = (percentage - 50) / 5;
|
}
|
result += 10 * k;
|
return result;
|
}
|
|
private static void addFormatInfo(byte[] grid, int size, MyQrCode.EccLevel ecc_level, int pattern) {
|
|
int format = pattern;
|
switch (ecc_level) {
|
case L:
|
format = pattern + 8;
|
case M:
|
default:
|
break;
|
case Q:
|
format = pattern + 24;
|
break;
|
case H:
|
format = pattern + 16;
|
}
|
int seq = QR_ANNEX_C[format];
|
int i;
|
for (i = 0; i < 6; ++i) {
|
grid[i * size + 8] = (byte) (grid[i * size + 8] + (seq >> i & 1));
|
}
|
for (i = 0; i < 8; ++i) {
|
grid[8 * size + (size - i - 1)] = (byte) (grid[8 * size + (size - i - 1)] + (seq >> i & 1));
|
}
|
for (i = 0; i < 6; ++i) {
|
grid[8 * size + (5 - i)] = (byte) (grid[8 * size + (5 - i)] + (seq >> i + 9 & 1));
|
}
|
for (i = 0; i < 7; ++i) {
|
grid[(size - 7 + i) * size + 8] = (byte) (grid[(size - 7 + i) * size + 8] + (seq >> i + 8 & 1));
|
}
|
grid[7 * size + 8] = (byte) (grid[7 * size + 8] + (seq >> 6 & 1));
|
grid[8 * size + 8] = (byte) (grid[8 * size + 8] + (seq >> 7 & 1));
|
grid[8 * size + 7] = (byte) (grid[8 * size + 7] + (seq >> 8 & 1));
|
}
|
|
private static void addVersionInfo(byte[] grid, int size, int version) {
|
|
long version_data = QR_ANNEX_D[version - 7];
|
for (int i = 0; i < 6; ++i) {
|
grid[(size - 11) * size + i] = (byte) ((int) ((long) grid[(size - 11) * size + i] + (version_data >> i * 3 & 1L)));
|
grid[(size - 10) * size + i] = (byte) ((int) ((long) grid[(size - 10) * size + i] + (version_data >> i * 3 + 1 & 1L)));
|
grid[(size - 9) * size + i] = (byte) ((int) ((long) grid[(size - 9) * size + i] + (version_data >> i * 3 + 2 & 1L)));
|
grid[i * size + (size - 11)] = (byte) ((int) ((long) grid[i * size + (size - 11)] + (version_data >> i * 3 & 1L)));
|
grid[i * size + (size - 10)] = (byte) ((int) ((long) grid[i * size + (size - 10)] + (version_data >> i * 3 + 1 & 1L)));
|
grid[i * size + (size - 9)] = (byte) ((int) ((long) grid[i * size + (size - 9)] + (version_data >> i * 3 + 2 & 1L)));
|
}
|
}
|
|
private static enum QrMode {
|
NULL, KANJI, BINARY, ALPHANUM, NUMERIC;
|
|
private QrMode() {
|
|
}
|
}
|
|
public static enum EccLevel {
|
L, M, Q, H;
|
|
private EccLevel() {
|
|
}
|
|
}
|
|
}
|
