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;
}
