/// <exception cref="iText.Barcodes.Qrcode.WriterException"/>
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++;
}
}
}
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>Terminate bits as described in 8.4.8 and 8.4.9 of JISX0510:2004 (p.24).</summary>
/// <exception cref="iText.Barcodes.Qrcode.WriterException"/>
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.
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_1 = 0; i_1 < numPaddingBits; ++i_1)
{
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_2 = 0; i_2 < numPaddingBytes; ++i_2)
{
if (i_2 % 2 == 0)
{
bits.AppendBits(0xec, 8);
}
else
{
bits.AppendBits(0x11, 8);
}
}
if (bits.Size() != capacity)
{
throw new WriterException("Bits size does not equal capacity");
}
}
/// <summary>Append length info.</summary>
/// <remarks>Append length info. On success, store the result in "bits".</remarks>
/// <exception cref="iText.Barcodes.Qrcode.WriterException"/>
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);
}
/// <exception cref="iText.Barcodes.Qrcode.WriterException"/>
internal static void Append8BitBytes(String content, BitVector bits, String encoding)
{
byte[] bytes;
try {
bytes = content.GetBytes(encoding);
}
catch (ArgumentException uee) {
throw new WriterException(uee.ToString());
}
for (int i = 0; i < bytes.Length; ++i)
{
bits.AppendBits(bytes[i], 8);
}
}
/// <exception cref="iText.Barcodes.Qrcode.WriterException"/>
internal static void AppendKanjiBytes(String content, BitVector bits)
{
byte[] bytes;
try {
bytes = content.GetBytes("Shift_JIS");
}
catch (ArgumentException 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);
}
}
private static void AppendECI(CharacterSetECI eci, BitVector bits)
{
bits.AppendBits(Mode.ECI.GetBits(), 4);
// This is correct for values up to 127, which is all we need now.
bits.AppendBits(eci.GetValue(), 8);
}
/// <summary>Append mode info.</summary>
/// <remarks>Append mode info. On success, store the result in "bits".</remarks>
internal static void AppendModeInfo(Mode mode, BitVector bits)
{
bits.AppendBits(mode.GetBits(), 4);
}
/// <summary>Interleave "bits" with corresponding error correction bytes.</summary>
/// <remarks>
/// 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.
/// </remarks>
/// <exception cref="iText.Barcodes.Qrcode.WriterException"/>
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.
IList <BlockPair> blocks = new List <BlockPair>(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(bits.GetArray(), 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_1 = 0; i_1 < maxNumDataBytes; ++i_1)
{
for (int j = 0; j < blocks.Count; ++j)
{
ByteArray dataBytes = blocks[j].GetDataBytes();
if (i_1 < dataBytes.Size())
{
result.AppendBits(dataBytes.At(i_1), 8);
}
}
}
// Then, place error correction blocks.
for (int i_2 = 0; i_2 < maxNumEcBytes; ++i_2)
{
for (int j = 0; j < blocks.Count; ++j)
{
ByteArray ecBytes = blocks[j].GetErrorCorrectionBytes();
if (i_2 < ecBytes.Size())
{
result.AppendBits(ecBytes.At(i_2), 8);
}
}
}
if (numTotalBytes != result.SizeInBytes())
{
// Should be same.
throw new WriterException("Interleaving error: " + numTotalBytes + " and " + result.SizeInBytes() + " differ."
);
}
}
