static b[] a(byte abyte0[], Version version, ErrorCorrectionLevel errorcorrectionlevel) { Version.ECBlocks ecblocks; b ab[]; int j1; int k1; int l1; if (abyte0.length != version.getTotalCodewords()) { throw new IllegalArgumentException(); } ecblocks = version.getECBlocksForLevel(errorcorrectionlevel); Version.ECB aecb[] = ecblocks.getECBlocks(); int i = aecb.length; int j = 0; int k = 0; for (; j < i; j++) { k += aecb[j].getCount(); } ab = new b[k]; int l = aecb.length; int i1 = 0; int k5; for (j1 = 0; i1 < l; j1 = k5) { Version.ECB ecb = aecb[i1]; k5 = j1; for (int l5 = 0; l5 < ecb.getCount();) { int i6 = ecb.getDataCodewords(); int j6 = i6 + ecblocks.getECCodewordsPerBlock(); int k6 = k5 + 1; ab[k5] = new b(i6, new byte[j6]); l5++; k5 = k6; } i1++; } k1 = ab[0].b.length; l1 = -1 + ab.length; _L6: if (l1 >= 0 && ab[l1].b.length != k1) goto _L2; else goto _L1
/** * When Data Matrix Codes use multiple data blocks, they actually interleave the bytes of each of * them. That is, the first byte of data block 1 to n is written, then the second bytes, and so * on. This method will separate the data into original blocks. * * @param rawCodewords bytes as read directly from the Data Matrix Code * @param version version of the Data Matrix Code * @return {@link DataBlock}s containing original bytes, "de-interleaved" from representation in * the Data Matrix Code */ static DataBlock[] getDataBlocks(byte[] rawCodewords, Version version) { // Figure out the number and size of data blocks used by this version Version.ECBlocks ecBlocks = version.getECBlocks(); // First count the total number of data blocks int totalBlocks = 0; Version.ECB[] ecBlockArray = ecBlocks.getECBlocks(); for (int i = 0; i < ecBlockArray.length; i++) { totalBlocks += ecBlockArray[i].getCount(); } // Now establish DataBlocks of the appropriate size and number of data // codewords DataBlock[] result = new DataBlock[totalBlocks]; int numResultBlocks = 0; for (int j = 0; j < ecBlockArray.length; j++) { Version.ECB ecBlock = ecBlockArray[j]; for (int i = 0; i < ecBlock.getCount(); i++) { int numDataCodewords = ecBlock.getDataCodewords(); int numBlockCodewords = ecBlocks.getECCodewords() + numDataCodewords; result[numResultBlocks++] = new DataBlock(numDataCodewords, new byte[numBlockCodewords]); } } // All blocks have the same amount of data, except that the last n // (where n may be 0) have 1 less byte. Figure out where these start. // (bbrown): There is only one case where there is a difference for // Data Matrix for size 144 int longerBlocksTotalCodewords = result[0].codewords.length; // int shorterBlocksTotalCodewords = longerBlocksTotalCodewords - 1; int longerBlocksNumDataCodewords = longerBlocksTotalCodewords - ecBlocks.getECCodewords(); int shorterBlocksNumDataCodewords = longerBlocksNumDataCodewords - 1; // The last elements of result may be 1 element shorter for 144 matrix // first fill out as many elements as all of them have minus 1 int rawCodewordsOffset = 0; for (int i = 0; i < shorterBlocksNumDataCodewords; i++) { for (int j = 0; j < numResultBlocks; j++) { result[j].codewords[i] = rawCodewords[rawCodewordsOffset++]; } } // Fill out the last data block in the longer ones boolean specialVersion = version.getVersionNumber() == 24; int numLongerBlocks = specialVersion ? 8 : numResultBlocks; for (int j = 0; j < numLongerBlocks; j++) { result[j].codewords[longerBlocksNumDataCodewords - 1] = rawCodewords[rawCodewordsOffset++]; } // Now add in error correction blocks int max = result[0].codewords.length; for (int i = longerBlocksNumDataCodewords; i < max; i++) { for (int j = 0; j < numResultBlocks; j++) { int iOffset = (specialVersion && j > 7) ? i - 1 : i; result[j].codewords[iOffset] = rawCodewords[rawCodewordsOffset++]; } } if (rawCodewordsOffset != rawCodewords.length) { throw new IllegalArgumentException(); } return result; }