// Embed "dataBits" using "getMaskPattern". On success, modify the matrix and return true.
// For debugging purposes, it skips masking process if "getMaskPattern" is -1.
// See 8.7 of JISX0510:2004 (p.38) for how to embed data bits.
public static void embedDataBits(BitVector dataBits, int maskPattern, ByteMatrix matrix)
{
int bitIndex = 0;
int direction = -1;
// Start from the right bottom cell.
int x = matrix.Width - 1;
int y = matrix.Height - 1;
while (x > 0)
{
while (y >= 0 && y < matrix.Height)
{
for (int i = 0; i < 2; ++i)
{
int xx = x - i;
// Skip the cell if it's not empty.
if (!isEmpty(matrix.get_Renamed(xx, y)))
{
continue;
}
int bit;
if (bitIndex < dataBits.size())
{
bit = dataBits.at(bitIndex);
++bitIndex;
}
else
{
// Padding bit. If there is no bit left, we'll fill the left cells with 0, as described
// in 8.4.9 of JISX0510:2004 (p. 24).
bit = 0;
}
// Skip masking if mask_pattern is -1.
if (maskPattern != -1)
{
if (MaskUtil.getDataMaskBit(maskPattern, xx, y))
{
bit ^= 0x1;
}
}
matrix.set_Renamed(xx, y, bit);
}
y += direction;
}
direction = -direction; // Reverse the direction.
y += direction;
x -= 2; // Move to the left.
}
// All bits should be consumed.
if (bitIndex != dataBits.size())
{
throw new WriterException("Not all bits consumed: " + bitIndex + '/' + dataBits.size());
}
}
// Embed type information. On success, modify the matrix.
public static void embedTypeInfo(ErrorCorrectionLevel ecLevel, int version, int maskPattern, ByteMatrix matrix)
{
BitVector typeInfoBits = new BitVector();
makeTypeInfoBits(ecLevel, version, maskPattern, typeInfoBits);
for (int i = 0; i < typeInfoBits.size(); ++i)
{
// Place bits in LSB to MSB order. LSB (least significant bit) is the last value in
// "typeInfoBits".
int bit = typeInfoBits.at(typeInfoBits.size() - 1 - i);
// Type info bits at the left top corner. See 8.9 of JISX0510:2004 (p.46).
int x1 = TYPE_INFO_COORDINATES[i][0];
int y1 = TYPE_INFO_COORDINATES[i][1];
matrix.set_Renamed(x1, y1, bit);
}
}
/// <summary>
/// Make bit vector of type information. On success, store the result in "bits" and return true.
/// Encode error correction level and mask pattern. See 8.9 of
/// JISX0510:2004 (p.45) for details.
/// </summary>
/// <param name="ecLevel"></param>
/// <param name="maskPattern"></param>
/// <param name="bits"></param>
/// <remarks>
/// ISO/IEC 18004:2006(E) 6.9 Format information
/// </remarks>
public static void makeTypeInfoBits(ErrorCorrectionLevel ecLevel, int version, int maskPattern, BitVector bits)
{
if (!MicroQRCode.isValidMaskPattern(maskPattern))
{
throw new WriterException("Invalid mask pattern");
}
//ISO/IEC 18004:2006(E) 6.9 Format information
//Symbol number 0: 000
//Data mask pattern reference: 11
//Data bits (symbol number, data mask pattern reference): 00011
//BCH bits: 1101011001
//Unmasked bit sequence: 000111101011001
//Mask pattern for XOR operation: 100010001000101
//Format information module pattern: 100101100011100
int typeInfo = SYMBOL_NUMBERS_INFO[version - 1][ecLevel.ordinal()];
if (typeInfo == -1)
{
throw new WriterException("Invalid Version&Level info");
}
typeInfo = (typeInfo << 2) | maskPattern;
bits.appendBits(typeInfo, 5);
int bchCode = calculateBCHCode(typeInfo, TYPE_INFO_POLY);
bits.appendBits(bchCode, 10);
BitVector maskBits = new BitVector();
maskBits.appendBits(TYPE_INFO_MASK_PATTERN, 15);
bits.xor(maskBits);
if (bits.size() != 15)
{
// Just in case.
throw new WriterException("should not happen but we got: " + bits.size());
}
}
/// <summary> Interleave "bits" with corresponding error correction bytes. On success, store the result in
/// "result". The interleave rule is complicated. See 8.6 of JISX0510:2004 (p.37) for details.
/// </summary>
internal static void interleaveWithECBytes(BitVector bits, int versionNum, int numTotalBytes, int numDataBytes, int numRSBlocks, BitVector result)
{
// "bits" must have "getNumDataBytes" bytes of data.
if (bits.sizeInBytes() != numDataBytes)
{
throw new WriterException("Number of bits and data bytes does not match");
}
// Step 1. Divide data bytes into blocks and generate error correction bytes for them. We'll
// store the divided data bytes blocks and error correction bytes blocks into "blocks".
int dataBytesOffset = 0;
int maxNumDataBytes = 0;
int maxNumEcBytes = 0;
// Since, we know the number of reedsolmon blocks, we can initialize the vector with the number.
System.Collections.ArrayList blocks = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(numRSBlocks));
for (int i = 0; i < numRSBlocks; ++i)
{
int[] numDataBytesInBlock = new int[1];
int[] numEcBytesInBlock = new int[1];
getNumDataBytesAndNumECBytesForBlockID(numTotalBytes, numDataBytes, numRSBlocks, i, numDataBytesInBlock, numEcBytesInBlock);
ByteArray dataBytes = new ByteArray();
dataBytes.set_Renamed(bits.Array, dataBytesOffset, numDataBytesInBlock[0]);
ByteArray ecBytes = generateECBytes(dataBytes, numEcBytesInBlock[0]);
blocks.Add(new BlockPair(dataBytes, ecBytes));
maxNumDataBytes = System.Math.Max(maxNumDataBytes, dataBytes.size());
maxNumEcBytes = System.Math.Max(maxNumEcBytes, ecBytes.size());
dataBytesOffset += numDataBytesInBlock[0];
}
if (numDataBytes != dataBytesOffset)
{
throw new WriterException("Data bytes does not match offset");
}
// First, place data blocks.
var bitLen = bits.size();
for (int i = 0; i < maxNumDataBytes; ++i)
{
for (int j = 0; j < blocks.Count; ++j)
{
ByteArray dataBytes = ((BlockPair)blocks[j]).DataBytes;
if (i < dataBytes.size())
{
if (bitLen == 4)
{
result.appendBits(dataBytes.at(i) >> 4, 4);
}
else
{
result.appendBits(dataBytes.at(i), 8);
}
}
}
bitLen -= 8;
}
// Then, place error correction blocks.
for (int i = 0; i < maxNumEcBytes; ++i)
{
for (int j = 0; j < blocks.Count; ++j)
{
ByteArray ecBytes = ((BlockPair)blocks[j]).ErrorCorrectionBytes;
if (i < ecBytes.size())
{
result.appendBits(ecBytes.at(i), 8);
}
}
}
if (numTotalBytes != result.sizeInBytes())
{
// Should be same.
throw new WriterException("Interleaving error: " + numTotalBytes + " and " + result.sizeInBytes() + " differ.");
}
}
/// <summary> Terminate bits as described in 8.4.8 and 8.4.9 of JISX0510:2004 (p.24).</summary>
internal static void terminateBits(int numDataBytes, BitVector bits, int versionNum)
{
int capacity = numDataBytes << 3;
//ISO/IEC 18004:2006(E) 6.4.10 Bit stream to codeword conversion
//All codewords are 8 bits in length, except for the final data symbol character in Micro
//QR Code versions M1 and M3 symbols, which is 4 bits in length
int bitLen = (versionNum == 1 || versionNum == 3) ? 4 : 8;
if (bitLen == 4)
{
capacity -= 4;
}
if (bits.size() > capacity)
{
throw new WriterException("data bits cannot fit in the QR Code" + bits.size() + " > " + capacity);
}
// Append termination bits. See 8.4.8 of JISX0510:2004 (p.24) for details.
// TODO: srowen says we can remove this for loop, since the 4 terminator bits are optional if
// the last byte has less than 4 bits left. So it amounts to padding the last byte with zeroes
// either way.
var terminatorMode = Mode.TERMINATOR;
var ctLen = terminatorMode.getBitsLength(versionNum);
for (int i = 0; i < ctLen && bits.size() < capacity; ++i)
{
bits.appendBit(0);
}
int numBitsInLastByte = bits.size() % bitLen;
// If the last byte isn't 8-bit aligned, we'll add padding bits.
if (numBitsInLastByte > 0)
{
int numPaddingBits = bitLen - numBitsInLastByte;
for (int i = 0; i < numPaddingBits; ++i)
{
bits.appendBit(0);
}
}
// Should be 8-bit aligned here.
if (bits.size() % bitLen != 0)
{
throw new WriterException("Number of bits is not a multiple of 8");
}
//ISO/IEC 18004:2006(E) 6.4.10 Bit stream to codeword conversion
//The message bit stream shall then be
//extended to fill the data capacity of the symbol corresponding to the Version and Error Correction Level, as
//defined in Table 8, by adding the Pad Codewords 11101100 and 00010001 alternately.
// If we have more space, we'll fill the space with padding patterns defined in 8.4.9 (p.24).
int numPaddingBytes = numDataBytes - bits.sizeInBytes();
while (numPaddingBytes * 8 > (capacity - bits.size()) && numPaddingBytes > 0)
{
numPaddingBytes--;
}
for (int i = 0; i < numPaddingBytes; ++i)
{
if (i % 2 == 0)
{
bits.appendBits(0xec, 8); //11101100
}
else
{
bits.appendBits(0x11, 8);//00010001
}
}
//For Micro QR Code versions M1 and M3 symbols, the final data codeword is 4 bits long. The Pad Codeword used in the final data
//symbol character position in Micro QR Code versions M1 and M3 symbols shall be represented as 0000.
if (bitLen == 4 && bits.size() < capacity)
{
bits.appendBits(0x0, 4);//0000
}
if (bits.size() != capacity)
{
throw new WriterException("Bits size does not equal capacity");
}
}
