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

package/cpp/zxing-core/core/src/qrcode/QREncoder.h

@@ -0,0 +1,21 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "CharacterSet.h"
+
+#include <string>
+
+namespace ZXing::QRCode {
+
+enum class ErrorCorrectionLevel;
+class EncodeResult;
+
+EncodeResult Encode(const std::wstring& content, ErrorCorrectionLevel ecLevel, CharacterSet charset, int versionNumber,
+					bool useGs1Format, int maskPattern = -1);
+
+} // namespace ZXing::QRCode

package/cpp/zxing-core/core/src/qrcode/QRErrorCorrectionLevel.cpp

@@ -0,0 +1,51 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "QRErrorCorrectionLevel.h"
+
+#include <cassert>
+
+namespace ZXing::QRCode {
+
+const char* ToString(ErrorCorrectionLevel l)
+{
+	assert(l != ErrorCorrectionLevel::Invalid);
+	static const char* const LEVEL_STR[] = {"L", "M", "Q", "H", nullptr};
+	return LEVEL_STR[static_cast<int>(l)];
+}
+
+ErrorCorrectionLevel ECLevelFromString(const char* str)
+{
+	switch (str[0]) {
+	case 'L': return ErrorCorrectionLevel::Low;
+	case 'M': return ErrorCorrectionLevel::Medium;
+	case 'Q': return ErrorCorrectionLevel::Quality;
+	case 'H': return ErrorCorrectionLevel::High;
+	default:  return ErrorCorrectionLevel::Invalid;
+	}
+}
+
+ErrorCorrectionLevel ECLevelFromBits(int bits, const bool isMicro)
+{
+	if (isMicro) {
+		constexpr ErrorCorrectionLevel LEVEL_FOR_BITS[] = {
+			ErrorCorrectionLevel::Low,    ErrorCorrectionLevel::Low, ErrorCorrectionLevel::Medium, ErrorCorrectionLevel::Low,
+			ErrorCorrectionLevel::Medium, ErrorCorrectionLevel::Low, ErrorCorrectionLevel::Medium, ErrorCorrectionLevel::Quality};
+		return LEVEL_FOR_BITS[bits & 0x07];
+	}
+	constexpr ErrorCorrectionLevel LEVEL_FOR_BITS[] = {ErrorCorrectionLevel::Medium, ErrorCorrectionLevel::Low,
+													   ErrorCorrectionLevel::High, ErrorCorrectionLevel::Quality};
+	return LEVEL_FOR_BITS[bits & 0x3];
+}
+
+int BitsFromECLevel(ErrorCorrectionLevel l)
+{
+	assert(l != ErrorCorrectionLevel::Invalid);
+	static const int BITS[] = {1, 0, 3, 2, -1};
+	return BITS[(int)l];
+}
+
+} // namespace ZXing::QRCode

package/cpp/zxing-core/core/src/qrcode/QRErrorCorrectionLevel.h

@@ -0,0 +1,39 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+namespace ZXing::QRCode {
+
+/**
+* <p>See ISO 18004:2006, 6.5.1. This enum encapsulates the four error correction levels
+* defined by the QR code standard.</p>
+*
+* @author Sean Owen
+*/
+enum class ErrorCorrectionLevel
+{
+	Low,     // L = ~7 % correction
+	Medium,  // M = ~15% correction
+	Quality, // Q = ~25% correction
+	High,    // H = ~30% correction
+	Invalid, // denotes in invalid/unknown value
+};
+
+const char* ToString(ErrorCorrectionLevel l);
+ErrorCorrectionLevel ECLevelFromString(const char* str);
+ErrorCorrectionLevel ECLevelFromBits(int bits, bool isMicro = false);
+int BitsFromECLevel(ErrorCorrectionLevel l);
+
+enum class Type
+{
+	Model1,
+	Model2,
+	Micro,
+	rMQR,
+};
+
+} // namespace ZXing::QRCode

package/cpp/zxing-core/core/src/qrcode/QRFormatInformation.cpp

@@ -0,0 +1,160 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2023 Axel Waggershauser
+* Copyright 2023 gitlost
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "QRFormatInformation.h"
+
+#include "ZXAlgorithms.h"
+
+#include <bit>
+
+namespace ZXing::QRCode {
+
+static uint32_t MirrorBits(uint32_t bits)
+{
+	return ReverseBits32(bits) >> 17;
+}
+
+static FormatInformation FindBestFormatInfo(const std::vector<uint32_t>& masks, const std::vector<uint32_t>& bits)
+{
+	// See ISO 18004:2015, Annex C, Table C.1
+	constexpr uint32_t MODEL2_MASKED_PATTERNS[] = {
+		0x5412, 0x5125, 0x5E7C, 0x5B4B, 0x45F9, 0x40CE, 0x4F97, 0x4AA0, 0x77C4, 0x72F3, 0x7DAA, 0x789D, 0x662F, 0x6318, 0x6C41, 0x6976,
+		0x1689, 0x13BE, 0x1CE7, 0x19D0, 0x0762, 0x0255, 0x0D0C, 0x083B, 0x355F, 0x3068, 0x3F31, 0x3A06, 0x24B4, 0x2183, 0x2EDA, 0x2BED,
+	};
+
+	FormatInformation fi;
+
+	for (auto mask : masks)
+		for (int bitsIndex = 0; bitsIndex < Size(bits); ++bitsIndex)
+			for (uint32_t pattern : MODEL2_MASKED_PATTERNS) {
+				// 'unmask' the pattern first to get the original 5-data bits + 10-ec bits back
+				pattern ^= FORMAT_INFO_MASK_MODEL2;
+				// Find the pattern with fewest bits differing
+				if (int hammingDist = std::popcount((bits[bitsIndex] ^ mask) ^ pattern);
+					hammingDist < fi.hammingDistance) {
+					fi.mask = mask; // store the used mask to discriminate between types/models
+					fi.data = pattern >> 10; // drop the 10 BCH error correction bits
+					fi.hammingDistance = hammingDist;
+					fi.bitsIndex = bitsIndex;
+				}
+			}
+
+	return fi;
+}
+
+static FormatInformation FindBestFormatInfoRMQR(const std::vector<uint32_t>& bits, const std::vector<uint32_t>& subbits)
+{
+	// See ISO/IEC 23941:2022, Annex C, Table C.1 - Valid format information sequences
+	constexpr uint32_t MASKED_PATTERNS[64] = { // Finder pattern side
+		0x1FAB2, 0x1E597, 0x1DBDD, 0x1C4F8, 0x1B86C, 0x1A749, 0x19903, 0x18626,
+		0x17F0E, 0x1602B, 0x15E61, 0x14144, 0x13DD0, 0x122F5, 0x11CBF, 0x1039A,
+		0x0F1CA, 0x0EEEF, 0x0D0A5, 0x0CF80, 0x0B314, 0x0AC31, 0x0927B, 0x08D5E,
+		0x07476, 0x06B53, 0x05519, 0x04A3C, 0x036A8, 0x0298D, 0x017C7, 0x008E2,
+		0x3F367, 0x3EC42, 0x3D208, 0x3CD2D, 0x3B1B9, 0x3AE9C, 0x390D6, 0x38FF3,
+		0x376DB, 0x369FE, 0x357B4, 0x34891, 0x33405, 0x32B20, 0x3156A, 0x30A4F,
+		0x2F81F, 0x2E73A, 0x2D970, 0x2C655, 0x2BAC1, 0x2A5E4, 0x29BAE, 0x2848B,
+		0x27DA3, 0x26286, 0x25CCC, 0x243E9, 0x23F7D, 0x22058, 0x21E12, 0x20137,
+	};
+	constexpr uint32_t MASKED_PATTERNS_SUB[64] = { // Finder sub pattern side
+		0x20A7B, 0x2155E, 0x22B14, 0x23431, 0x248A5, 0x25780, 0x269CA, 0x276EF,
+		0x28FC7, 0x290E2, 0x2AEA8, 0x2B18D, 0x2CD19, 0x2D23C, 0x2EC76, 0x2F353,
+		0x30103, 0x31E26, 0x3206C, 0x33F49, 0x343DD, 0x35CF8, 0x362B2, 0x37D97,
+		0x384BF, 0x39B9A, 0x3A5D0, 0x3BAF5, 0x3C661, 0x3D944, 0x3E70E, 0x3F82B,
+		0x003AE, 0x01C8B, 0x022C1, 0x03DE4, 0x04170, 0x05E55, 0x0601F, 0x07F3A,
+		0x08612, 0x09937, 0x0A77D, 0x0B858, 0x0C4CC, 0x0DBE9, 0x0E5A3, 0x0FA86,
+		0x108D6, 0x117F3, 0x129B9, 0x1369C, 0x14A08, 0x1552D, 0x16B67, 0x17442,
+		0x18D6A, 0x1924F, 0x1AC05, 0x1B320, 0x1CFB4, 0x1D091, 0x1EEDB, 0x1F1FE,
+	};
+
+	FormatInformation fi;
+
+	auto best = [&fi](const std::vector<uint32_t>& bits, const uint32_t (&patterns)[64], uint32_t mask)
+	{
+		for (int bitsIndex = 0; bitsIndex < Size(bits); ++bitsIndex)
+			for (uint32_t pattern : patterns) {
+				// 'unmask' the pattern first to get the original 6-data bits + 12-ec bits back
+				pattern ^= mask;
+				// Find the pattern with fewest bits differing
+				if (int hammingDist = std::popcount((bits[bitsIndex] ^ mask) ^ pattern);
+					hammingDist < fi.hammingDistance) {
+					fi.mask = mask; // store the used mask to discriminate between types/models
+					fi.data = pattern >> 12; // drop the 12 BCH error correction bits
+					fi.hammingDistance = hammingDist;
+					fi.bitsIndex = bitsIndex;
+				}
+			}
+	};
+
+	best(bits, MASKED_PATTERNS, FORMAT_INFO_MASK_RMQR);
+	if (Size(subbits)) // TODO probably remove if `sampleRMQR()` done properly
+		best(subbits, MASKED_PATTERNS_SUB, FORMAT_INFO_MASK_RMQR_SUB);
+
+	return fi;
+}
+
+/**
+* @param formatInfoBits1 format info indicator, with mask still applied
+* @param formatInfoBits2 second copy of same info; both are checked at the same time to establish best match
+*/
+FormatInformation FormatInformation::DecodeQR(uint32_t formatInfoBits1, uint32_t formatInfoBits2)
+{
+	// marks out the 'Dark Module' for mirrored and non-mirrored case (see Figure 25 in ISO/IEC 18004:2015)
+	uint32_t mirroredFormatInfoBits2 = MirrorBits(((formatInfoBits2 >> 1) & 0b111111110000000) | (formatInfoBits2 & 0b1111111));
+	formatInfoBits2 = ((formatInfoBits2 >> 1) & 0b111111100000000) | (formatInfoBits2 & 0b11111111);
+	// Some (Model2) QR codes apparently do not apply the XOR mask. Try with (standard) and without (quirk) masking.
+	auto fi = FindBestFormatInfo({FORMAT_INFO_MASK_MODEL2, 0, FORMAT_INFO_MASK_MODEL1},
+								 {formatInfoBits1, formatInfoBits2, MirrorBits(formatInfoBits1), mirroredFormatInfoBits2});
+
+	// Use bits 3/4 for error correction, and 0-2 for mask.
+	fi.ecLevel = ECLevelFromBits((fi.data >> 3) & 0x03);
+	fi.dataMask = static_cast<uint8_t>(fi.data & 0x07);
+	fi.isMirrored = fi.bitsIndex > 1;
+
+	return fi;
+}
+
+/**
+ * @param formatInfoBits format info indicator, with mask still applied
+ */
+FormatInformation FormatInformation::DecodeMQR(uint32_t formatInfoBits)
+{
+	auto fi = FindBestFormatInfo({FORMAT_INFO_MASK_MICRO}, {formatInfoBits, MirrorBits(formatInfoBits)});
+
+	constexpr uint8_t BITS_TO_VERSION[] = {1, 2, 2, 3, 3, 4, 4, 4};
+
+	// Bits 2/3/4 contain both error correction level and version, 0/1 contain mask.
+	fi.ecLevel = ECLevelFromBits((fi.data >> 2) & 0x07, true);
+	fi.dataMask = static_cast<uint8_t>(fi.data & 0x03);
+	fi.microVersion = BITS_TO_VERSION[(fi.data >> 2) & 0x07];
+	fi.isMirrored = fi.bitsIndex == 1;
+
+	return fi;
+}
+
+/**
+* @param formatInfoBits1 format info indicator, with mask still applied
+* @param formatInfoBits2 second copy of same info; both are checked at the same time to establish best match
+*/
+FormatInformation FormatInformation::DecodeRMQR(uint32_t formatInfoBits1, uint32_t formatInfoBits2)
+{
+	FormatInformation fi;
+	if (formatInfoBits2)
+		fi = FindBestFormatInfoRMQR({formatInfoBits1}, {formatInfoBits2});
+	else // TODO probably remove if `sampleRMQR()` done properly
+		fi = FindBestFormatInfoRMQR({formatInfoBits1}, {});
+
+	// Bit 6 is error correction (M/H), and bits 0-5 version.
+	fi.ecLevel = ECLevelFromBits(((fi.data >> 5) & 1) << 1); // Shift to match QRCode M/H
+	fi.dataMask = 4; // ((y / 2) + (x / 3)) % 2 == 0
+	fi.microVersion = (fi.data & 0x1F) + 1;
+	fi.isMirrored = false; // TODO: implement mirrored format bit reading
+
+	return fi;
+}
+
+} // namespace ZXing::QRCode

package/cpp/zxing-core/core/src/qrcode/QRFormatInformation.h

@@ -0,0 +1,61 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2023 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "QRErrorCorrectionLevel.h"
+
+#include <cstdint>
+
+namespace ZXing::QRCode {
+
+static constexpr uint32_t FORMAT_INFO_MASK_MODEL2 = 0x5412;
+static constexpr uint32_t FORMAT_INFO_MASK_MODEL1 = 0x2825;
+static constexpr uint32_t FORMAT_INFO_MASK_MICRO = 0x4445;
+static constexpr uint32_t FORMAT_INFO_MASK_RMQR = 0x1FAB2; // Finder pattern side
+static constexpr uint32_t FORMAT_INFO_MASK_RMQR_SUB = 0x20A7B; // Finder sub pattern side
+
+class FormatInformation
+{
+public:
+	uint32_t mask = 0;
+	uint8_t data = 255;
+	uint8_t hammingDistance = 255;
+	uint8_t bitsIndex = 255;
+
+	bool isMirrored = false;
+	uint8_t dataMask = 255;
+	uint8_t microVersion = 0;
+	ErrorCorrectionLevel ecLevel = ErrorCorrectionLevel::Invalid;
+
+	FormatInformation() = default;
+
+	static FormatInformation DecodeQR(uint32_t formatInfoBits1, uint32_t formatInfoBits2);
+	static FormatInformation DecodeMQR(uint32_t formatInfoBits);
+	static FormatInformation DecodeRMQR(uint32_t formatInfoBits1, uint32_t formatInfoBits2);
+
+	// Hamming distance of the 32 masked codes is 7 (64 and 8 for rMQR), by construction, so <= 3 bits differing means we found a match
+	bool isValid() const { return hammingDistance <= 3; }
+
+	Type type() const
+	{
+		switch (mask) {
+		case FORMAT_INFO_MASK_MODEL1: return Type::Model1;
+		case FORMAT_INFO_MASK_MICRO: return Type::Micro;
+		case FORMAT_INFO_MASK_RMQR: [[fallthrough]];
+		case FORMAT_INFO_MASK_RMQR_SUB: return Type::rMQR;
+		default: return Type::Model2;
+		}
+	}
+
+	bool operator==(const FormatInformation& other) const
+	{
+		return dataMask == other.dataMask && ecLevel == other.ecLevel && type() == other.type();
+	}
+};
+
+} // namespace ZXing::QRCode

package/cpp/zxing-core/core/src/qrcode/QRMaskUtil.cpp

@@ -0,0 +1,156 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "QRMaskUtil.h"
+
+#include "ZXAlgorithms.h"
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstdlib>
+#include <utility>
+
+namespace ZXing::QRCode::MaskUtil {
+
+// Penalty weights from section 6.8.2.1
+static const int N1 = 3;
+static const int N2 = 3;
+static const int N3 = 40;
+static const int N4 = 10;
+
+/**
+* Helper function for applyMaskPenaltyRule1. We need this for doing this calculation in both
+* vertical and horizontal orders respectively.
+*/
+static int ApplyMaskPenaltyRule1Internal(const TritMatrix& matrix, bool isHorizontal)
+{
+	int penalty = 0;
+	int width = matrix.width();
+	int height = matrix.height();
+	int iLimit = isHorizontal ? height : width;
+	int jLimit = isHorizontal ? width : height;
+	for (int i = 0; i < iLimit; i++) {
+		int numSameBitCells = 0;
+		int prevBit = -1;
+		for (int j = 0; j < jLimit; j++) {
+			int bit = isHorizontal ? matrix.get(j, i) : matrix.get(i, j);
+			if (bit == prevBit) {
+				numSameBitCells++;
+			}
+			else {
+				if (numSameBitCells >= 5) {
+					penalty += N1 + (numSameBitCells - 5);
+				}
+				numSameBitCells = 1;  // Include the cell itself.
+				prevBit = bit;
+			}
+		}
+		if (numSameBitCells >= 5) {
+			penalty += N1 + (numSameBitCells - 5);
+		}
+	}
+	return penalty;
+}
+
+/**
+* Apply mask penalty rule 1 and return the penalty. Find repetitive cells with the same color and
+* give penalty to them. Example: 00000 or 11111.
+*/
+static int ApplyMaskPenaltyRule1(const TritMatrix& matrix)
+{
+	return ApplyMaskPenaltyRule1Internal(matrix, true) + ApplyMaskPenaltyRule1Internal(matrix, false);
+}
+
+/**
+* Apply mask penalty rule 2 and return the penalty. Find 2x2 blocks with the same color and give
+* penalty to them. This is actually equivalent to the spec's rule, which is to find MxN blocks and give a
+* penalty proportional to (M-1)x(N-1), because this is the number of 2x2 blocks inside such a block.
+*/
+static int ApplyMaskPenaltyRule2(const TritMatrix& matrix)
+{
+	int penalty = 0;
+	for (int y = 0; y < matrix.height() - 1; y++) {
+		for (int x = 0; x < matrix.width() - 1; x++) {
+			auto value = matrix.get(x, y);
+			if (value == matrix.get(x+1, y) && value == matrix.get(x, y+1) && value == matrix.get(x+1, y+1)) {
+				penalty++;
+			}
+		}
+	}
+	return N2 * penalty;
+}
+
+template <size_t N>
+static bool HasPatternAt(const std::array<bool, N>& pattern, const Trit* begin, int count, int stride)
+{
+	assert(std::abs(count) <= (int)N);
+	auto end = begin + count * stride;
+	if (count < 0)
+		std::swap(begin, end);
+	auto a = begin;
+	for (auto b = pattern.begin(); a < end && b != pattern.end(); a += stride, ++b)
+		if (*a != *b)
+			return false;
+	return true;
+}
+
+/**
+* Apply mask penalty rule 3 and return the penalty. Find consecutive runs of 1:1:3:1:1:4
+* starting with black, or 4:1:1:3:1:1 starting with white, and give penalty to them.  If we
+* find patterns like 000010111010000, we give penalty once.
+*/
+static int ApplyMaskPenaltyRule3(const TritMatrix& matrix)
+{
+	const std::array<bool, 4> white = {0, 0, 0, 0};
+	const std::array<bool, 7> finder = {1, 0, 1, 1, 1, 0, 1};
+	const int whiteSize = Size(white);
+	const int finderSize = Size(finder);
+
+	int numPenalties = 0;
+	int width = matrix.width();
+	int height = matrix.height();
+	for (int y = 0; y < height; y++) {
+		for (int x = 0; x < width; x++) {
+			auto i = &matrix.get(x, y);
+			if (x <= width - finderSize && HasPatternAt(finder, i, finderSize, 1)
+				&& (HasPatternAt(white, i, -std::min(x, whiteSize), 1)
+					|| HasPatternAt(white, i + finderSize, std::min(width - x - finderSize, whiteSize), 1))) {
+				numPenalties++;
+			}
+			if (y <= height - finderSize && HasPatternAt(finder, i, finderSize, width)
+				&& (HasPatternAt(white, i, -std::min(y, whiteSize), width)
+					|| HasPatternAt(white, i + finderSize * width, std::min(height - y - finderSize, whiteSize), width))) {
+				numPenalties++;
+			}
+		}
+	}
+	return numPenalties * N3;
+}
+
+/**
+* Apply mask penalty rule 4 and return the penalty. Calculate the ratio of dark cells and give
+* penalty if the ratio is far from 50%. It gives 10 penalty for 5% distance.
+*/
+static int ApplyMaskPenaltyRule4(const TritMatrix& matrix)
+{
+	auto numDarkCells = std::count_if(matrix.begin(), matrix.end(), [](Trit cell) { return cell; });
+	auto numTotalCells = matrix.size();
+	auto fivePercentVariances = std::abs(numDarkCells * 2 - numTotalCells) * 10 / numTotalCells;
+	return narrow_cast<int>(fivePercentVariances * N4);
+}
+
+// The mask penalty calculation is complicated.  See Table 21 of JISX0510:2004 (p.45) for details.
+// Basically it applies four rules and summate all penalties.
+int CalculateMaskPenalty(const TritMatrix& matrix)
+{
+	return MaskUtil::ApplyMaskPenaltyRule1(matrix)
+		   + MaskUtil::ApplyMaskPenaltyRule2(matrix)
+		   + MaskUtil::ApplyMaskPenaltyRule3(matrix)
+		   + MaskUtil::ApplyMaskPenaltyRule4(matrix);
+}
+
+} // namespace ZXing::QRCode::MaskUtil

package/cpp/zxing-core/core/src/qrcode/QRMaskUtil.h

@@ -0,0 +1,15 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "TritMatrix.h"
+
+namespace ZXing::QRCode::MaskUtil {
+
+int CalculateMaskPenalty(const TritMatrix& matrix);
+
+} // namespace ZXing::QRCode::MaskUtil