react-native-nitro-zxing 0.1.0-alpha.0

package/cpp/zxing-core/core/src/aztec/AZEncoder.cpp

@@ -0,0 +1,318 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "AZEncoder.h"
+
+#include "AZHighLevelEncoder.h"
+#include "BitArray.h"
+#include "ReedSolomon.h"
+#include "ZXTestSupport.h"
+
+#include <cstdlib>
+#include <stdexcept>
+#include <vector>
+
+namespace ZXing::Aztec {
+
+static const int MAX_NB_BITS = 32;
+static const int MAX_NB_BITS_COMPACT = 4;
+
+static const int WORD_SIZE[] = {4,  6,  6,  8,  8,  8,  8,  8,  8,  10, 10, 10, 10, 10, 10, 10, 10,
+								10, 10, 10, 10, 10, 10, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12};
+
+static void DrawBullsEye(BitMatrix& matrix, int center, int size)
+{
+	for (int i = 0; i < size; i += 2) {
+		for (int j = center - i; j <= center + i; j++) {
+			matrix.set(j, center - i);
+			matrix.set(j, center + i);
+			matrix.set(center - i, j);
+			matrix.set(center + i, j);
+		}
+	}
+	matrix.set(center - size, center - size);
+	matrix.set(center - size + 1, center - size);
+	matrix.set(center - size, center - size + 1);
+	matrix.set(center + size, center - size);
+	matrix.set(center + size, center - size + 1);
+	matrix.set(center + size, center + size - 1);
+}
+
+static void GenerateCheckWords(const BitArray& bitArray, int totalBits, int wordSize, BitArray& messageBits)
+{
+	// bitArray is guaranteed to be a multiple of the wordSize, so no padding needed
+	std::vector<int> messageWords = ToInts(bitArray, wordSize, totalBits / wordSize);
+	ReedSolomonEncode(GF2nAztec(wordSize), messageWords, (totalBits - bitArray.size()) / wordSize);
+	messageBits = BitArray();
+	if (int startPad = totalBits % wordSize)
+		messageBits.appendBits(0, startPad);
+	for (int messageWord : messageWords)
+		messageBits.appendBits(messageWord, wordSize);
+}
+
+ZXING_EXPORT_TEST_ONLY
+void GenerateModeMessage(bool compact, int layers, int messageSizeInWords, BitArray& modeMessage)
+{
+	modeMessage = BitArray();
+	if (compact) {
+		modeMessage.appendBits(layers - 1, 2);
+		modeMessage.appendBits(messageSizeInWords - 1, 6);
+		GenerateCheckWords(modeMessage, 28, 4, modeMessage);
+	}
+	else {
+		modeMessage.appendBits(layers - 1, 5);
+		modeMessage.appendBits(messageSizeInWords - 1, 11);
+		GenerateCheckWords(modeMessage, 40, 4, modeMessage);
+	}
+}
+
+ZXING_EXPORT_TEST_ONLY
+void GenerateRuneMessage(uint8_t word, BitArray& runeMessage)
+{
+	runeMessage = BitArray();
+	runeMessage.appendBits(word, 8);
+	GenerateCheckWords(runeMessage, 28, 4, runeMessage);
+	// Now flip every other bit
+
+	BitArray xorBits;
+	xorBits.appendBits(0xAAAAAAAA, 28);
+	runeMessage.bitwiseXOR(xorBits);
+}
+
+static void DrawModeMessage(BitMatrix& matrix, bool compact, int matrixSize, const BitArray& modeMessage)
+{
+	int center = matrixSize / 2;
+	if (compact) {
+		for (int i = 0; i < 7; i++) {
+			int offset = center - 3 + i;
+			if (modeMessage.get(i)) {
+				matrix.set(offset, center - 5);
+			}
+			if (modeMessage.get(i + 7)) {
+				matrix.set(center + 5, offset);
+			}
+			if (modeMessage.get(20 - i)) {
+				matrix.set(offset, center + 5);
+			}
+			if (modeMessage.get(27 - i)) {
+				matrix.set(center - 5, offset);
+			}
+		}
+	}
+	else {
+		for (int i = 0; i < 10; i++) {
+			int offset = center - 5 + i + i / 5;
+			if (modeMessage.get(i)) {
+				matrix.set(offset, center - 7);
+			}
+			if (modeMessage.get(i + 10)) {
+				matrix.set(center + 7, offset);
+			}
+			if (modeMessage.get(29 - i)) {
+				matrix.set(offset, center + 7);
+			}
+			if (modeMessage.get(39 - i)) {
+				matrix.set(center - 7, offset);
+			}
+		}
+	}
+}
+
+ZXING_EXPORT_TEST_ONLY
+void StuffBits(const BitArray& bits, int wordSize, BitArray& out)
+{
+	out = BitArray();
+	int n = bits.size();
+	int mask = (1 << wordSize) - 2;
+	for (int i = 0; i < n; i += wordSize) {
+		int word = 0;
+		for (int j = 0; j < wordSize; j++) {
+			if (i + j >= n || bits.get(i + j)) {
+				word |= 1 << (wordSize - 1 - j);
+			}
+		}
+		if ((word & mask) == mask) {
+			out.appendBits(word & mask, wordSize);
+			i--;
+		}
+		else if ((word & mask) == 0) {
+			out.appendBits(word | 1, wordSize);
+			i--;
+		}
+		else {
+			out.appendBits(word, wordSize);
+		}
+	}
+}
+
+static int TotalBitsInLayer(int layers, bool compact)
+{
+	return ((compact ? 88 : 112) + 16 * layers) * layers;
+}
+
+/**
+* Encodes the given binary content as an Aztec symbol
+*
+* @param data input data string
+* @param minECCPercent minimal percentage of error check words (According to ISO/IEC 24778:2008,
+*                      a minimum of 23% + 3 words is recommended)
+* @param userSpecifiedLayers if non-zero, a user-specified value for the number of layers
+* @return Aztec symbol matrix with metadata
+*/
+EncodeResult
+Encoder::Encode(const std::string& data, int minECCPercent, int userSpecifiedLayers)
+{
+	// High-level encode
+	BitArray bits = HighLevelEncoder::Encode(data);
+
+	// stuff bits and choose symbol size
+	int eccBits = bits.size() * minECCPercent / 100 + 11;
+	int totalSizeBits = bits.size() + eccBits;
+	bool compact;
+	int layers;
+	int totalBitsInLayer;
+	int wordSize;
+	BitArray stuffedBits;
+	if (userSpecifiedLayers == AZTEC_RUNE_LAYERS) {
+		compact = true;
+		layers = 0;
+		totalBitsInLayer = 0;
+		wordSize = 0;
+		stuffedBits = BitArray(0);
+	} else if (userSpecifiedLayers != DEFAULT_AZTEC_LAYERS) {
+		compact = userSpecifiedLayers < 0;
+		layers = std::abs(userSpecifiedLayers);
+		if (layers > (compact ? MAX_NB_BITS_COMPACT : MAX_NB_BITS)) {
+			throw std::invalid_argument("Illegal value for layers: " + std::to_string(userSpecifiedLayers));
+		}
+		totalBitsInLayer = TotalBitsInLayer(layers, compact);
+		wordSize = WORD_SIZE[layers];
+		int usableBitsInLayers = totalBitsInLayer - (totalBitsInLayer % wordSize);
+		StuffBits(bits, wordSize, stuffedBits);
+		if (stuffedBits.size() + eccBits > usableBitsInLayers) {
+			throw std::invalid_argument("Data to large for user specified layer");
+		}
+		if (compact && stuffedBits.size() > wordSize * 64) {
+			// Compact format only allows 64 data words, though C4 can hold more words than that
+			throw std::invalid_argument("Data to large for user specified layer");
+		}
+	}
+	else {
+		wordSize = 0;
+		// We look at the possible table sizes in the order Compact1, Compact2, Compact3,
+		// Compact4, Normal4,...  Normal(i) for i < 4 isn't typically used since Compact(i+1)
+		// is the same size, but has more data.
+		for (int i = 0; ; i++) {
+			if (i > MAX_NB_BITS) {
+				throw std::invalid_argument("Data too large for an Aztec code");
+			}
+			compact = i <= 3;
+			layers = compact ? i + 1 : i;
+			totalBitsInLayer = TotalBitsInLayer(layers, compact);
+			if (totalSizeBits > totalBitsInLayer) {
+				continue;
+			}
+			// [Re]stuff the bits if this is the first opportunity, or if the
+			// wordSize has changed
+			if (wordSize != WORD_SIZE[layers]) {
+				wordSize = WORD_SIZE[layers];
+				StuffBits(bits, wordSize, stuffedBits);
+			}
+			int usableBitsInLayers = totalBitsInLayer - (totalBitsInLayer % wordSize);
+			if (compact && stuffedBits.size() > wordSize * 64) {
+				// Compact format only allows 64 data words, though C4 can hold more words than that
+				continue;
+			}
+			if (stuffedBits.size() + eccBits <= usableBitsInLayers) {
+				break;
+			}
+		}
+	}
+
+	BitArray messageBits;
+	BitArray modeMessage;
+	int messageSizeInWords;
+
+	if (layers == 0) {
+		// This is a rune, and messageBits should be empty
+		messageBits = BitArray(0);
+		messageSizeInWords = 0;
+		GenerateRuneMessage(data[0], modeMessage);
+	} else {
+		GenerateCheckWords(stuffedBits, totalBitsInLayer, wordSize, messageBits);
+		messageSizeInWords = stuffedBits.size() / wordSize;
+		GenerateModeMessage(compact, layers, messageSizeInWords, modeMessage);
+	}
+
+	// allocate symbol
+	int baseMatrixSize = (compact ? 11 : 14) + layers * 4; // not including alignment lines
+	std::vector<int> alignmentMap(baseMatrixSize, 0);
+	int matrixSize;
+	if (compact) {
+		// no alignment marks in compact mode, alignmentMap is a no-op
+		matrixSize = baseMatrixSize;
+		std::iota(alignmentMap.begin(), alignmentMap.end(), 0);
+	}
+	else {
+		matrixSize = baseMatrixSize + 1 + 2 * ((baseMatrixSize / 2 - 1) / 15);
+		int origCenter = baseMatrixSize / 2;
+		int center = matrixSize / 2;
+		for (int i = 0; i < origCenter; i++) {
+			int newOffset = i + i / 15;
+			alignmentMap[origCenter - i - 1] = center - newOffset - 1;
+			alignmentMap[origCenter + i] = center + newOffset + 1;
+		}
+	}
+
+	EncodeResult output{compact, matrixSize, layers, messageSizeInWords, BitMatrix(matrixSize)};
+
+	BitMatrix& matrix = output.matrix;
+
+	// draw data bits
+	for (int i = 0, rowOffset = 0; i < layers; i++) {
+		int rowSize = (layers - i) * 4 + (compact ? 9 : 12);
+		for (int j = 0; j < rowSize; j++) {
+			int columnOffset = j * 2;
+			for (int k = 0; k < 2; k++) {
+				if (messageBits.get(rowOffset + columnOffset + k)) {
+					matrix.set(alignmentMap[i * 2 + k], alignmentMap[i * 2 + j]);
+				}
+				if (messageBits.get(rowOffset + rowSize * 2 + columnOffset + k)) {
+					matrix.set(alignmentMap[i * 2 + j], alignmentMap[baseMatrixSize - 1 - i * 2 - k]);
+				}
+				if (messageBits.get(rowOffset + rowSize * 4 + columnOffset + k)) {
+					matrix.set(alignmentMap[baseMatrixSize - 1 - i * 2 - k], alignmentMap[baseMatrixSize - 1 - i * 2 - j]);
+				}
+				if (messageBits.get(rowOffset + rowSize * 6 + columnOffset + k)) {
+					matrix.set(alignmentMap[baseMatrixSize - 1 - i * 2 - j], alignmentMap[i * 2 + k]);
+				}
+			}
+		}
+		rowOffset += rowSize * 8;
+	}
+
+	// draw mode message
+	DrawModeMessage(matrix, compact, matrixSize, modeMessage);
+
+	// draw alignment marks
+	if (compact) {
+		DrawBullsEye(matrix, matrixSize / 2, 5);
+	}
+	else {
+		DrawBullsEye(matrix, matrixSize / 2, 7);
+		for (int i = 0, j = 0; i < baseMatrixSize / 2 - 1; i += 15, j += 16) {
+			for (int k = (matrixSize / 2) & 1; k < matrixSize; k += 2) {
+				matrix.set(matrixSize / 2 - j, k);
+				matrix.set(matrixSize / 2 + j, k);
+				matrix.set(k, matrixSize / 2 - j);
+				matrix.set(k, matrixSize / 2 + j);
+			}
+		}
+	}
+	return output;
+}
+
+} // namespace ZXing::Aztec

package/cpp/zxing-core/core/src/aztec/AZEncoder.h

@@ -0,0 +1,44 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BitMatrix.h"
+
+#include <string>
+
+namespace ZXing::Aztec {
+
+/**
+* Aztec 2D code representation
+*
+* @author Rustam Abdullaev
+*/
+struct EncodeResult
+{
+	bool compact;
+	int size;
+	int layers;
+	int codeWords;
+	BitMatrix matrix;
+};
+
+/**
+* Generates Aztec 2D barcodes.
+*
+* @author Rustam Abdullaev
+*/
+class Encoder
+{
+public:
+	static const int DEFAULT_EC_PERCENT = 33; // default minimal percentage of error check words
+	static const int DEFAULT_AZTEC_LAYERS = 0;
+	static const int AZTEC_RUNE_LAYERS = 0xFF;
+
+	static EncodeResult Encode(const std::string& data, int minECCPercent, int userSpecifiedLayers);
+};
+
+} // namespace ZXing::Aztec

package/cpp/zxing-core/core/src/aztec/AZEncodingState.h

@@ -0,0 +1,40 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "AZToken.h"
+
+#include <vector>
+
+namespace ZXing::Aztec {
+
+class Token;
+
+/**
+* State represents all information about a sequence necessary to generate the current output.
+* Note that a state is immutable.
+*/
+class EncodingState
+{
+public:
+	// The list of tokens that we output.  If we are in Binary Shift mode, this
+	// token list does *not* yet included the token for those bytes
+	std::vector<Token> tokens;
+
+	// The current mode of the encoding (or the mode to which we'll return if
+	// we're in Binary Shift mode.
+	int mode = 0;
+	
+	// If non-zero, the number of most recent bytes that should be output
+	// in Binary Shift mode.
+	int binaryShiftByteCount = 0;
+	
+	// The total number of bits generated (including Binary Shift).
+	int bitCount = 0;
+};
+
+} // namespace ZXing::Aztec