internal static void appendAlphanumericBytes(String content, BitVector bits)
{
int length = content.Length;
int i = 0;
while (i < length)
{
int code1 = getAlphanumericCode(content[i]);
if (code1 == - 1)
{
throw new WriterException();
}
if (i + 1 < length)
{
int code2 = getAlphanumericCode(content[i + 1]);
if (code2 == - 1)
{
throw new WriterException();
}
// Encode two alphanumeric letters in 11 bits.
bits.appendBits(code1*45 + code2, 11);
i += 2;
}
else
{
// Encode one alphanumeric letter in six bits.
bits.appendBits(code1, 6);
i++;
}
}
}
/// <summary> Append "bytes" in "mode" mode (encoding) into "bits". On success, store the result in "bits".</summary>
internal static void appendBytes(String content, Mode mode, BitVector bits, String encoding)
{
if (mode.Equals(Mode.NUMERIC))
{
appendNumericBytes(content, bits);
}
else if (mode.Equals(Mode.ALPHANUMERIC))
{
appendAlphanumericBytes(content, bits);
}
else if (mode.Equals(Mode.BYTE))
{
append8BitBytes(content, bits, encoding);
}
else if (mode.Equals(Mode.KANJI))
{
appendKanjiBytes(content, bits);
}
else
{
throw new WriterException("Invalid mode: " + mode);
}
}
internal static void appendNumericBytes(String content, BitVector bits)
{
int length = content.Length;
int i = 0;
while (i < length)
{
int num1 = content[i] - '0';
if (i + 2 < length)
{
// Encode three numeric letters in ten bits.
int num2 = content[i + 1] - '0';
int num3 = content[i + 2] - '0';
bits.appendBits(num1*100 + num2*10 + num3, 10);
i += 3;
}
else if (i + 1 < length)
{
// Encode two numeric letters in seven bits.
int num2 = content[i + 1] - '0';
bits.appendBits(num1*10 + num2, 7);
i += 2;
}
else
{
// Encode one numeric letter in four bits.
bits.appendBits(num1, 4);
i++;
}
}
}
/// <summary> Append mode info. On success, store the result in "bits".</summary>
internal static void appendModeInfo(Mode mode, BitVector bits)
{
bits.appendBits(mode.Bits, 4);
}
/// <summary> Append length info. On success, store the result in "bits".</summary>
internal static void appendLengthInfo(int numLetters, int version, Mode mode, BitVector bits)
{
int numBits = mode.getCharacterCountBits(Version.getVersionForNumber(version));
if (numLetters > ((1 << numBits) - 1))
{
throw new WriterException(numLetters + "is bigger than" + ((1 << numBits) - 1));
}
bits.appendBits(numLetters, numBits);
}
private static void appendECI(CharacterSetECI eci, BitVector bits)
{
bits.appendBits(Mode.ECI.Bits, 4);
// This is correct for values up to 127, which is all we need now.
bits.appendBits(eci.Value, 8);
}
// Modify the bit vector by XOR'ing with "other"
public void xor(BitVector other)
{
if (sizeInBits != other.size())
{
throw new ArgumentException("BitVector sizes don't match");
}
int sizeInBytes = (sizeInBits + 7) >> 3;
for (int i = 0; i < sizeInBytes; ++i)
{
// The last byte could be incomplete (i.e. not have 8 bits in
// it) but there is no problem since 0 XOR 0 == 0.
array[i] ^= other.array[i];
}
}
// Make bit vector of version information. On success, store the result in "bits" and return true.
// See 8.10 of JISX0510:2004 (p.45) for details.
public static void makeVersionInfoBits(int version, BitVector bits)
{
bits.appendBits(version, 6);
int bchCode = calculateBCHCode(version, VERSION_INFO_POLY);
bits.appendBits(bchCode, 12);
if (bits.size() != 18)
{
// Just in case.
throw new WriterException("should not happen but we got: " + bits.size());
}
}
private static int chooseMaskPattern(BitVector bits, ErrorCorrectionLevel ecLevel, int version,
ByteMatrix matrix)
{
int minPenalty = Int32.MaxValue; // Lower penalty is better.
int bestMaskPattern = - 1;
// We try all mask patterns to choose the best one.
for (int maskPattern = 0; maskPattern < QRCode.NUM_MASK_PATTERNS; maskPattern++)
{
MatrixUtil.buildMatrix(bits, ecLevel, version, maskPattern, matrix);
int penalty = calculateMaskPenalty(matrix);
if (penalty < minPenalty)
{
minPenalty = penalty;
bestMaskPattern = maskPattern;
}
}
return bestMaskPattern;
}
// 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)
{
// Skip the vertical timing pattern.
if (x == 6)
{
x -= 1;
}
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());
}
}
// 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.
public static void makeTypeInfoBits(ErrorCorrectionLevel ecLevel, int maskPattern, BitVector bits)
{
if (!QRCode.isValidMaskPattern(maskPattern))
{
throw new WriterException("Invalid mask pattern");
}
int typeInfo = (ecLevel.Bits << 3) | maskPattern;
bits.appendBits(typeInfo, 5);
int bchCode = calculateBCHCode(typeInfo, TYPE_INFO_POLY);
bits.appendBits(bchCode, 10);
var 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());
}
}
// Embed version information if need be. On success, modify the matrix and return true.
// See 8.10 of JISX0510:2004 (p.47) for how to embed version information.
public static void maybeEmbedVersionInfo(int version, ByteMatrix matrix)
{
if (version < 7)
{
// Version info is necessary if version >= 7.
return; // Don't need version info.
}
var versionInfoBits = new BitVector();
makeVersionInfoBits(version, versionInfoBits);
int bitIndex = 6*3 - 1; // It will decrease from 17 to 0.
for (int i = 0; i < 6; ++i)
{
for (int j = 0; j < 3; ++j)
{
// Place bits in LSB (least significant bit) to MSB order.
int bit = versionInfoBits.at(bitIndex);
bitIndex--;
// Left bottom corner.
matrix.set_Renamed(i, matrix.Height - 11 + j, bit);
// Right bottom corner.
matrix.set_Renamed(matrix.Height - 11 + j, i, bit);
}
}
}
// Embed type information. On success, modify the matrix.
public static void embedTypeInfo(ErrorCorrectionLevel ecLevel, int maskPattern, ByteMatrix matrix)
{
var typeInfoBits = new BitVector();
makeTypeInfoBits(ecLevel, 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);
if (i < 8)
{
// Right top corner.
int x2 = matrix.Width - i - 1;
int y2 = 8;
matrix.set_Renamed(x2, y2, bit);
}
else
{
// Left bottom corner.
int x2 = 8;
int y2 = matrix.Height - 7 + (i - 8);
matrix.set_Renamed(x2, y2, bit);
}
}
}
// Build 2D matrix of QR Code from "dataBits" with "ecLevel", "version" and "getMaskPattern". On
// success, store the result in "matrix" and return true.
public static void buildMatrix(BitVector dataBits, ErrorCorrectionLevel ecLevel, int version, int maskPattern,
ByteMatrix matrix)
{
clearMatrix(matrix);
embedBasicPatterns(version, matrix);
// Type information appear with any version.
embedTypeInfo(ecLevel, maskPattern, matrix);
// Version info appear if version >= 7.
maybeEmbedVersionInfo(version, matrix);
// Data should be embedded at end.
embedDataBits(dataBits, maskPattern, matrix);
}
internal static void append8BitBytes(String content, BitVector bits, String encoding)
{
sbyte[] bytes;
try
{
bytes = SupportClass.ToSByteArray(Encoding.GetEncoding(encoding).GetBytes(content));
}
catch (IOException uee)
{
throw new WriterException(uee.ToString());
}
for (int i = 0; i < bytes.Length; ++i)
{
bits.appendBits(bytes[i], 8);
}
}
/// <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 capacity = numDataBytes << 3;
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.
for (int i = 0; i < 4 && bits.size() < capacity; ++i)
{
bits.appendBit(0);
}
int numBitsInLastByte = bits.size()%8;
// If the last byte isn't 8-bit aligned, we'll add padding bits.
if (numBitsInLastByte > 0)
{
int numPaddingBits = 8 - numBitsInLastByte;
for (int i = 0; i < numPaddingBits; ++i)
{
bits.appendBit(0);
}
}
// Should be 8-bit aligned here.
if (bits.size()%8 != 0)
{
throw new WriterException("Number of bits is not a multiple of 8");
}
// 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();
for (int i = 0; i < numPaddingBytes; ++i)
{
if (i%2 == 0)
{
bits.appendBits(0xec, 8);
}
else
{
bits.appendBits(0x11, 8);
}
}
if (bits.size() != capacity)
{
throw new WriterException("Bits size does not equal capacity");
}
}
internal static void appendKanjiBytes(String content, BitVector bits)
{
sbyte[] bytes;
try
{
bytes = SupportClass.ToSByteArray(Encoding.GetEncoding("Shift_JIS").GetBytes(content));
}
catch (IOException uee)
{
throw new WriterException(uee.ToString());
}
int length = bytes.Length;
for (int i = 0; i < length; i += 2)
{
int byte1 = bytes[i] & 0xFF;
int byte2 = bytes[i + 1] & 0xFF;
int code = (byte1 << 8) | byte2;
int subtracted = - 1;
if (code >= 0x8140 && code <= 0x9ffc)
{
subtracted = code - 0x8140;
}
else if (code >= 0xe040 && code <= 0xebbf)
{
subtracted = code - 0xc140;
}
if (subtracted == - 1)
{
throw new WriterException("Invalid byte sequence");
}
int encoded = ((subtracted >> 8)*0xc0) + (subtracted & 0xff);
bits.appendBits(encoded, 13);
}
}
/// <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 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.
var blocks = new List<BlockPair>(numRSBlocks);
for (int i = 0; i < numRSBlocks; ++i)
{
var numDataBytesInBlock = new int[1];
var numEcBytesInBlock = new int[1];
getNumDataBytesAndNumECBytesForBlockID(numTotalBytes, numDataBytes, numRSBlocks, i, numDataBytesInBlock,
numEcBytesInBlock);
var dataBytes = new ByteArray();
dataBytes.set_Renamed(bits.Array, dataBytesOffset, numDataBytesInBlock[0]);
ByteArray ecBytes = generateECBytes(dataBytes, numEcBytesInBlock[0]);
blocks.Add(new BlockPair(dataBytes, ecBytes));
maxNumDataBytes = Math.Max(maxNumDataBytes, dataBytes.size());
maxNumEcBytes = Math.Max(maxNumEcBytes, ecBytes.size());
dataBytesOffset += numDataBytesInBlock[0];
}
if (numDataBytes != dataBytesOffset)
{
throw new WriterException("Data bytes does not match offset");
}
// First, place data blocks.
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())
{
result.appendBits(dataBytes.at(i), 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.");
}
}
public static void encode(String content, ErrorCorrectionLevel ecLevel, Dictionary<EncodeHintType, Object> hints,
QRCode qrCode)
{
String encoding = hints == null ? null : (String) hints[EncodeHintType.CHARACTER_SET];
if (encoding == null)
{
encoding = DEFAULT_BYTE_MODE_ENCODING;
}
// Step 1: Choose the mode (encoding).
Mode mode = chooseMode(content, encoding);
// Step 2: Append "bytes" into "dataBits" in appropriate encoding.
var dataBits = new BitVector();
appendBytes(content, mode, dataBits, encoding);
// Step 3: Initialize QR code that can contain "dataBits".
int numInputBytes = dataBits.sizeInBytes();
initQRCode(numInputBytes, ecLevel, mode, qrCode);
// Step 4: Build another bit vector that contains header and data.
var headerAndDataBits = new BitVector();
// Step 4.5: Append ECI message if applicable
if (mode == Mode.BYTE && !DEFAULT_BYTE_MODE_ENCODING.Equals(encoding))
{
CharacterSetECI eci = CharacterSetECI.getCharacterSetECIByName(encoding);
if (eci != null)
{
appendECI(eci, headerAndDataBits);
}
}
appendModeInfo(mode, headerAndDataBits);
int numLetters = mode.Equals(Mode.BYTE) ? dataBits.sizeInBytes() : content.Length;
appendLengthInfo(numLetters, qrCode.Version, mode, headerAndDataBits);
headerAndDataBits.appendBitVector(dataBits);
// Step 5: Terminate the bits properly.
terminateBits(qrCode.NumDataBytes, headerAndDataBits);
// Step 6: Interleave data bits with error correction code.
var finalBits = new BitVector();
interleaveWithECBytes(headerAndDataBits, qrCode.NumTotalBytes, qrCode.NumDataBytes, qrCode.NumRSBlocks,
finalBits);
// Step 7: Choose the mask pattern and set to "qrCode".
var matrix = new ByteMatrix(qrCode.MatrixWidth, qrCode.MatrixWidth);
qrCode.MaskPattern = chooseMaskPattern(finalBits, qrCode.ECLevel, qrCode.Version, matrix);
// Step 8. Build the matrix and set it to "qrCode".
MatrixUtil.buildMatrix(finalBits, qrCode.ECLevel, qrCode.Version, qrCode.MaskPattern, matrix);
qrCode.Matrix = matrix;
// Step 9. Make sure we have a valid QR Code.
if (!qrCode.Valid)
{
throw new WriterException("Invalid QR code: " + qrCode);
}
}
// Append "bits".
public void appendBitVector(BitVector bits)
{
int size = bits.size();
for (int i = 0; i < size; ++i)
{
appendBit(bits.at(i));
}
}