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

package/cpp/zxing-core/core/src/pdf417/ZXNullable.h

@@ -0,0 +1,105 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cstddef>
+#include <stdexcept>
+#include <utility>
+
+namespace ZXing {
+
+template <typename T>
+class Nullable final
+{
+	bool m_hasValue = false;
+	T m_value;
+
+public:
+	Nullable() = default;
+	Nullable(const T &value) : m_hasValue(true), m_value(value) {}
+	Nullable(T &&value) noexcept : m_hasValue(true), m_value(std::move(value)) {}
+	Nullable(std::nullptr_t) {}
+	
+	Nullable<T> & operator=(const T &value) {
+		m_hasValue = true;
+		m_value = value;
+		return *this;
+	}
+
+	Nullable<T> & operator=(T &&value) noexcept {
+		m_hasValue = true;
+		m_value = std::move(value);
+		return *this;
+	}
+
+	Nullable<T> & operator=(std::nullptr_t) {
+		m_hasValue = false;
+		m_value = T();
+		return *this;
+	}
+
+	operator T() const {
+		if (!m_hasValue) {
+			throw std::logic_error("Access empty value");
+		}
+		return m_value;
+	}
+	
+	bool hasValue() const {
+		return m_hasValue;
+	}
+	
+	const T & value() const {
+		return m_value;
+	}
+	
+	T & value() {
+		return m_value;
+	}
+
+	friend inline bool operator==(const Nullable &a, const Nullable &b) {
+		return a.m_hasValue == b.m_hasValue && (!a.m_hasValue || a.m_value == b.m_value);
+	}
+	friend inline bool operator!=(const Nullable &a, const Nullable &b) {
+		return !(a == b);
+	}
+
+	friend inline bool operator==(const Nullable &a, const T &v) {
+		return a.m_hasValue && a.m_value == v;
+	}
+	friend inline bool operator!=(const Nullable &a, const T &v) {
+		return !(a == v);
+	}
+
+	friend inline bool operator==(const T &v, const Nullable &a) {
+		return a.m_hasValue && a.m_value == v;
+	}
+	friend inline bool operator!=(const T &v, const Nullable &a) {
+		return !(v == a);
+	}
+
+	friend inline bool operator==(const Nullable &a, std::nullptr_t) {
+		return !a.m_hasValue;
+	}
+	friend inline bool operator!=(const Nullable &a, std::nullptr_t) {
+		return a.m_hasValue;
+	}
+
+	friend inline bool operator==(std::nullptr_t, const Nullable &a) {
+		return !a.m_hasValue;
+	}
+	friend inline bool operator!=(std::nullptr_t, const Nullable &a) {
+		return a.m_hasValue;
+	}
+
+	friend inline void swap(Nullable &a, Nullable &b) noexcept {
+		using std::swap;
+		swap(a.m_value, b.m_value);
+		swap(a.m_hasValue, b.m_hasValue);
+	}
+};
+
+} // ZXing

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

@@ -0,0 +1,294 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2023 gitlost
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "QRBitMatrixParser.h"
+
+#include "BitArray.h"
+#include "BitMatrix.h"
+#include "ByteArray.h"
+#include "QRDataMask.h"
+#include "QRFormatInformation.h"
+#include "QRVersion.h"
+
+#include <utility>
+
+namespace ZXing::QRCode {
+
+static bool getBit(const BitMatrix& bitMatrix, int x, int y, bool mirrored = false)
+{
+	return mirrored ? bitMatrix.get(y, x) : bitMatrix.get(x, y);
+}
+
+const Version* ReadVersion(const BitMatrix& bitMatrix, Type type)
+{
+	assert(Version::HasValidSize(bitMatrix));
+
+	int number = Version::Number(bitMatrix);
+
+	switch (type) {
+	case Type::Micro: return Version::Micro(number);
+	case Type::rMQR: return Version::rMQR(number);
+	case Type::Model1: return Version::Model1(number);
+	case Type::Model2: return Version::Model2(number);
+	}
+
+	return nullptr;
+}
+
+FormatInformation ReadFormatInformation(const BitMatrix& bitMatrix)
+{
+	if (Version::HasValidSize(bitMatrix, Type::Micro)) {
+		// Read top-left format info bits
+		int formatInfoBits = 0;
+		for (int x = 1; x < 9; x++)
+			AppendBit(formatInfoBits, getBit(bitMatrix, x, 8));
+		for (int y = 7; y >= 1; y--)
+			AppendBit(formatInfoBits, getBit(bitMatrix, 8, y));
+
+		return FormatInformation::DecodeMQR(formatInfoBits);
+	}
+	if (Version::HasValidSize(bitMatrix, Type::rMQR)) {
+		// Read top-left format info bits
+		uint32_t formatInfoBits1 = 0;
+		for (int y = 3; y >= 1; y--)
+			AppendBit(formatInfoBits1, getBit(bitMatrix, 11, y));
+		for (int x = 10; x >= 8; x--)
+			for (int y = 5; y >= 1; y--)
+				AppendBit(formatInfoBits1, getBit(bitMatrix, x, y));
+
+		// Read bottom-right format info bits
+		uint32_t formatInfoBits2 = 0;
+		const int width = bitMatrix.width();
+		const int height = bitMatrix.height();
+		for (int x = 3; x <= 5; x++)
+			AppendBit(formatInfoBits2, getBit(bitMatrix, width - x, height - 6));
+		for (int x = 6; x <= 8; x++)
+			for (int y = 2; y <= 6; y++)
+				AppendBit(formatInfoBits2, getBit(bitMatrix, width - x, height - y));
+
+		return FormatInformation::DecodeRMQR(formatInfoBits1, formatInfoBits2);
+	}
+
+	// Read top-left format info bits
+	int formatInfoBits1 = 0;
+	for (int x = 0; x < 6; x++)
+		AppendBit(formatInfoBits1, getBit(bitMatrix, x, 8));
+	// .. and skip a bit in the timing pattern ...
+	AppendBit(formatInfoBits1, getBit(bitMatrix, 7, 8));
+	AppendBit(formatInfoBits1, getBit(bitMatrix, 8, 8));
+	AppendBit(formatInfoBits1, getBit(bitMatrix, 8, 7));
+	// .. and skip a bit in the timing pattern ...
+	for (int y = 5; y >= 0; y--)
+		AppendBit(formatInfoBits1, getBit(bitMatrix, 8, y));
+
+	// Read the top-right/bottom-left pattern including the 'Dark Module' from the bottom-left
+	// part that has to be considered separately when looking for mirrored symbols.
+	// See also FormatInformation::DecodeQR
+	int dimension = bitMatrix.height();
+	int formatInfoBits2 = 0;
+	for (int y = dimension - 1; y >= dimension - 8; y--)
+		AppendBit(formatInfoBits2, getBit(bitMatrix, 8, y));
+	for (int x = dimension - 8; x < dimension; x++)
+		AppendBit(formatInfoBits2, getBit(bitMatrix, x, 8));
+
+	return FormatInformation::DecodeQR(formatInfoBits1, formatInfoBits2);
+}
+
+static ByteArray ReadQRCodewords(const BitMatrix& bitMatrix, const Version& version, const FormatInformation& formatInfo)
+{
+	BitMatrix functionPattern = version.buildFunctionPattern();
+
+	ByteArray result;
+	result.reserve(version.totalCodewords());
+	uint8_t currentByte = 0;
+	bool readingUp = true;
+	int bitsRead = 0;
+	int dimension = bitMatrix.height();
+	// Read columns in pairs, from right to left
+	for (int x = dimension - 1; x > 0; x -= 2) {
+		// Skip whole column with vertical timing pattern.
+		if (x == 6)
+			x--;
+		// Read alternatingly from bottom to top then top to bottom
+		for (int row = 0; row < dimension; row++) {
+			int y = readingUp ? dimension - 1 - row : row;
+			for (int col = 0; col < 2; col++) {
+				int xx = x - col;
+				// Ignore bits covered by the function pattern
+				if (!functionPattern.get(xx, y)) {
+					// Read a bit
+					AppendBit(currentByte,
+							  GetDataMaskBit(formatInfo.dataMask, xx, y) != getBit(bitMatrix, xx, y, formatInfo.isMirrored));
+					// If we've made a whole byte, save it off
+					if (++bitsRead % 8 == 0)
+						result.push_back(std::exchange(currentByte, 0));
+				}
+			}
+		}
+		readingUp = !readingUp; // switch directions
+	}
+	if (Size(result) != version.totalCodewords())
+		return {};
+
+	return result;
+}
+
+static ByteArray ReadQRCodewordsModel1(const BitMatrix& bitMatrix, const Version& version, const FormatInformation& formatInfo)
+{
+	ByteArray result;
+	result.reserve(version.totalCodewords());
+	int dimension = bitMatrix.height();
+	int columns = dimension / 4 + 1 + 2;
+	for (int j = 0; j < columns; j++) {
+		if (j <= 1) { // vertical symbols on the right side
+			int rows = (dimension - 8) / 4;
+			for (int i = 0; i < rows; i++) {
+				if (j == 0 && i % 2 == 0 && i > 0 && i < rows - 1) // extension
+					continue;
+				int x = (dimension - 1) - (j * 2);
+				int y = (dimension - 1) - (i * 4);
+				uint8_t currentByte = 0;
+				for (int b = 0; b < 8; b++) {
+					AppendBit(currentByte, GetDataMaskBit(formatInfo.dataMask, x - b % 2, y - (b / 2))
+											   != getBit(bitMatrix, x - b % 2, y - (b / 2), formatInfo.isMirrored));
+				}
+				result.push_back(currentByte);
+			}
+		} else if (columns - j <= 4) { // vertical symbols on the left side
+			int rows = (dimension - 16) / 4;
+			for (int i = 0; i < rows; i++) {
+				int x = (columns - j - 1) * 2 + 1 + (columns - j == 4 ? 1 : 0); // timing
+				int y = (dimension - 1) - 8 - (i * 4);
+				uint8_t currentByte = 0;
+				for (int b = 0; b < 8; b++) {
+					AppendBit(currentByte, GetDataMaskBit(formatInfo.dataMask, x - b % 2, y - (b / 2))
+											   != getBit(bitMatrix, x - b % 2, y - (b / 2), formatInfo.isMirrored));
+				}
+				result.push_back(currentByte);
+			}
+		} else { // horizontal symbols
+			int rows = dimension / 2;
+			for (int i = 0; i < rows; i++) {
+				if (j == 2 && i >= rows - 4) // alignment & finder
+					continue;
+				if (i == 0 && j % 2 == 1 && j + 1 != columns - 4) // extension
+					continue;
+				int x = (dimension - 1) - (2 * 2) - (j - 2) * 4;
+				int y = (dimension - 1) - (i * 2) - (i >= rows - 3 ? 1 : 0); // timing
+				uint8_t currentByte = 0;
+				for (int b = 0; b < 8; b++) {
+					AppendBit(currentByte, GetDataMaskBit(formatInfo.dataMask, x - b % 4, y - (b / 4))
+											   != getBit(bitMatrix, x - b % 4, y - (b / 4), formatInfo.isMirrored));
+				}
+				result.push_back(currentByte);
+			}
+		}
+	}
+
+	result[0] &= 0xf; // ignore corner
+	if (Size(result) != version.totalCodewords())
+		return {};
+
+	return result;
+}
+
+static ByteArray ReadMQRCodewords(const BitMatrix& bitMatrix, const QRCode::Version& version, const FormatInformation& formatInfo)
+{
+	BitMatrix functionPattern = version.buildFunctionPattern();
+
+	// D3 in a Version M1 symbol, D11 in a Version M3-L symbol and D9
+	// in a Version M3-M symbol is a 2x2 square 4-module block.
+	// See ISO 18004:2006 6.7.3.
+	bool hasD4mBlock = version.versionNumber() % 2 == 1;
+	int d4mBlockIndex =
+		version.versionNumber() == 1 ? 3 : (formatInfo.ecLevel == QRCode::ErrorCorrectionLevel::Low ? 11 : 9);
+
+	ByteArray result;
+	result.reserve(version.totalCodewords());
+	uint8_t currentByte = 0;
+	bool readingUp = true;
+	int bitsRead = 0;
+	int dimension = bitMatrix.height();
+	// Read columns in pairs, from right to left
+	for (int x = dimension - 1; x > 0; x -= 2) {
+		// Read alternatingly from bottom to top then top to bottom
+		for (int row = 0; row < dimension; row++) {
+			int y = readingUp ? dimension - 1 - row : row;
+			for (int col = 0; col < 2; col++) {
+				int xx = x - col;
+				// Ignore bits covered by the function pattern
+				if (!functionPattern.get(xx, y)) {
+					// Read a bit
+					AppendBit(currentByte,
+							  GetDataMaskBit(formatInfo.dataMask, xx, y, true) != getBit(bitMatrix, xx, y, formatInfo.isMirrored));
+					++bitsRead;
+					// If we've made a whole byte, save it off; save early if 2x2 data block.
+					if (bitsRead == 8 || (bitsRead == 4 && hasD4mBlock && Size(result) == d4mBlockIndex - 1)) {
+						result.push_back(std::exchange(currentByte, 0));
+						bitsRead = 0;
+					}
+				}
+			}
+		}
+		readingUp = !readingUp; // switch directions
+	}
+	if (Size(result) != version.totalCodewords())
+		return {};
+
+	return result;
+}
+
+static ByteArray ReadRMQRCodewords(const BitMatrix& bitMatrix, const Version& version, const FormatInformation& formatInfo)
+{
+	BitMatrix functionPattern = version.buildFunctionPattern();
+
+	ByteArray result;
+	result.reserve(version.totalCodewords());
+	uint8_t currentByte = 0;
+	bool readingUp = true;
+	int bitsRead = 0;
+	const int width = bitMatrix.width();
+	const int height = bitMatrix.height();
+	// Read columns in pairs, from right to left
+	for (int x = width - 1 - 1; x > 0; x -= 2) { // Skip right edge alignment
+		// Read alternatingly from bottom to top then top to bottom
+		for (int row = 0; row < height; row++) {
+			int y = readingUp ? height - 1 - row : row;
+			for (int col = 0; col < 2; col++) {
+				int xx = x - col;
+				// Ignore bits covered by the function pattern
+				if (!functionPattern.get(xx, y)) {
+					// Read a bit
+					AppendBit(currentByte,
+							  GetDataMaskBit(formatInfo.dataMask, xx, y) != getBit(bitMatrix, xx, y, formatInfo.isMirrored));
+					// If we've made a whole byte, save it off
+					if (++bitsRead % 8 == 0)
+						result.push_back(std::exchange(currentByte, 0));
+				}
+			}
+		}
+		readingUp = !readingUp; // switch directions
+	}
+	if (Size(result) != version.totalCodewords())
+		return {};
+
+	return result;
+}
+
+ByteArray ReadCodewords(const BitMatrix& bitMatrix, const Version& version, const FormatInformation& formatInfo)
+{
+	switch (version.type()) {
+	case Type::Micro: return ReadMQRCodewords(bitMatrix, version, formatInfo);
+	case Type::rMQR: return ReadRMQRCodewords(bitMatrix, version, formatInfo);
+	case Type::Model1: return ReadQRCodewordsModel1(bitMatrix, version, formatInfo);
+	case Type::Model2: return ReadQRCodewords(bitMatrix, version, formatInfo);
+	}
+
+	return {};
+}
+
+} // namespace ZXing::QRCode

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

@@ -0,0 +1,41 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "QRErrorCorrectionLevel.h"
+
+namespace ZXing {
+
+class BitMatrix;
+class ByteArray;
+
+namespace QRCode {
+
+class Version;
+class FormatInformation;
+
+/**
+ * @brief Reads version information from the QR Code.
+ * @return {@link Version} encapsulating the QR Code's version, nullptr if neither location can be parsed
+ */
+const Version* ReadVersion(const BitMatrix& bitMatrix, Type type);
+
+/**
+ * @brief Reads format information from one of its two locations within the QR Code.
+ * @return {@link FormatInformation} encapsulating the QR Code's format info, result is invalid if both format
+ * information locations cannot be parsed as the valid encoding of format information
+ */
+FormatInformation ReadFormatInformation(const BitMatrix& bitMatrix);
+
+/**
+ * @brief Reads the codewords from the BitMatrix.
+ * @return bytes encoded within the QR Code or empty array if the exact number of bytes expected is not read
+ */
+ByteArray ReadCodewords(const BitMatrix& bitMatrix, const Version& version, const FormatInformation& formatInfo);
+
+} // QRCode
+} // ZXing

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

@@ -0,0 +1,95 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2023 gitlost
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "QRCodecMode.h"
+
+#include "Error.h"
+#include "QRVersion.h"
+#include "ZXAlgorithms.h"
+
+#include <array>
+
+namespace ZXing::QRCode {
+
+CodecMode CodecModeForBits(int bits, Type type)
+{
+	if (type == Type::Micro) {
+		constexpr CodecMode Bits2Mode[4] = {CodecMode::NUMERIC, CodecMode::ALPHANUMERIC, CodecMode::BYTE, CodecMode::KANJI};
+		if (bits < Size(Bits2Mode))
+			return Bits2Mode[bits];
+	} else if (type == Type::rMQR) {
+		constexpr CodecMode Bits2Mode[8] = {
+			CodecMode::TERMINATOR, CodecMode::NUMERIC, CodecMode::ALPHANUMERIC, CodecMode::BYTE,
+			CodecMode::KANJI, CodecMode::FNC1_FIRST_POSITION, CodecMode::FNC1_SECOND_POSITION, CodecMode::ECI
+		};
+		if (bits < Size(Bits2Mode))
+			return Bits2Mode[bits];
+	} else {
+		if ((bits >= 0x00 && bits <= 0x05) || (bits >= 0x07 && bits <= 0x09) || bits == 0x0d)
+			return static_cast<CodecMode>(bits);
+	}
+
+	throw FormatError("Invalid codec mode");
+}
+
+int CharacterCountBits(CodecMode mode, const Version& version)
+{
+	int number = version.versionNumber();
+	if (version.isMicro()) {
+		switch (mode) {
+		case CodecMode::NUMERIC:      return std::array{3, 4, 5, 6}[number - 1];
+		case CodecMode::ALPHANUMERIC: return std::array{3, 4, 5}[number - 2];
+		case CodecMode::BYTE:         return std::array{4, 5}[number - 3];
+		case CodecMode::KANJI:        [[fallthrough]];
+		case CodecMode::HANZI:        return std::array{3, 4}[number - 3];
+		default: return 0;
+		}
+	}
+	if (version.isRMQR()) {
+		// See ISO/IEC 23941:2022 7.4.1, Table 3 - Number of bits of character count indicator
+		constexpr char numeric[32]  = {4, 5, 6, 7, 7, 5, 6, 7, 7, 8, 4, 6, 7, 7, 8, 8, 5, 6, 7, 7, 8, 8, 7, 7, 8, 8, 9, 7, 8, 8, 8, 9};
+		constexpr char alphanum[32] = {3, 5, 5, 6, 6, 5, 5, 6, 6, 7, 4, 5, 6, 6, 7, 7, 5, 6, 6, 7, 7, 8, 6, 7, 7, 7, 8, 6, 7, 7, 8, 8};
+		constexpr char byte[32]     = {3, 4, 5, 5, 6, 4, 5, 5, 6, 6, 3, 5, 5, 6, 6, 7, 4, 5, 6, 6, 7, 7, 6, 6, 7, 7, 7, 6, 6, 7, 7, 8};
+		constexpr char kanji[32]    = {2, 3, 4, 5, 5, 3, 4, 5, 5, 6, 2, 4, 5, 5, 6, 6, 3, 5, 5, 6, 6, 7, 5, 5, 6, 6, 7, 5, 6, 6, 6, 7};
+		switch (mode) {
+		case CodecMode::NUMERIC: return numeric[number - 1];
+		case CodecMode::ALPHANUMERIC: return alphanum[number - 1];
+		case CodecMode::BYTE: return byte[number - 1];
+		case CodecMode::KANJI: return kanji[number - 1];
+		default: return 0;
+		}
+	}
+
+	int i;
+	if (number <= 9)
+		i = 0;
+	else if (number <= 26)
+		i = 1;
+	else
+		i = 2;
+
+	switch (mode) {
+	case CodecMode::NUMERIC:      return std::array{10, 12, 14}[i];
+	case CodecMode::ALPHANUMERIC: return std::array{9, 11, 13}[i];
+	case CodecMode::BYTE:         return std::array{8, 16, 16}[i];
+	case CodecMode::KANJI:        [[fallthrough]];
+	case CodecMode::HANZI:        return std::array{8, 10, 12}[i];
+	default:                      return 0;
+	}
+}
+
+int CodecModeBitsLength(const Version& version)
+{
+	return version.isMicro() ? version.versionNumber() - 1 : 4 - version.isRMQR();
+}
+
+int TerminatorBitsLength(const Version& version)
+{
+	return version.isMicro() ? version.versionNumber() * 2 + 1 : 4 - version.isRMQR();
+}
+
+} // namespace ZXing::QRCode

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

@@ -0,0 +1,59 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+namespace ZXing::QRCode {
+
+enum class Type;
+class Version;
+
+/**
+* <p>See ISO 18004:2006, 6.4.1, Tables 2 and 3. This enum encapsulates the various modes in which
+* data can be encoded to bits in the QR code standard.</p>
+*/
+enum class CodecMode
+{
+	TERMINATOR           = 0x00, // Not really a mode...
+	NUMERIC              = 0x01,
+	ALPHANUMERIC         = 0x02,
+	STRUCTURED_APPEND    = 0x03,
+	BYTE                 = 0x04,
+	FNC1_FIRST_POSITION  = 0x05,
+	ECI                  = 0x07, // character counts don't apply
+	KANJI                = 0x08,
+	FNC1_SECOND_POSITION = 0x09,
+	HANZI                = 0x0D, // See GBT 18284-2000; "Hanzi" is a transliteration of this mode name.
+};
+
+/**
+ * @param bits variable number of bits encoding a QR Code data mode
+ * @param type type of QR Code
+ * @return Mode encoded by these bits
+ * @throws FormatError if bits do not correspond to a known mode
+ */
+CodecMode CodecModeForBits(int bits, Type type);
+
+/**
+ * @param version version in question
+ * @return number of bits used, in this QR Code symbol {@link Version}, to encode the
+ *         count of characters that will follow encoded in this Mode
+ */
+int CharacterCountBits(CodecMode mode, const Version& version);
+
+/**
+ * @param version version in question
+ * @return number of bits used to encode a codec mode.
+ */
+int CodecModeBitsLength(const Version& version);
+
+/**
+ * @param version version in question
+ * @return number of bits in the Terminator code.
+ */
+int TerminatorBitsLength(const Version& version);
+
+} // namespace ZXing::QRCode

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

@@ -0,0 +1,93 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "QRDataBlock.h"
+
+#include "ByteArray.h"
+#include "QRErrorCorrectionLevel.h"
+#include "QRVersion.h"
+#include "ZXAlgorithms.h"
+
+namespace ZXing::QRCode {
+
+std::vector<DataBlock> DataBlock::GetDataBlocks(const ByteArray& rawCodewords, const Version& version, ErrorCorrectionLevel ecLevel)
+{
+	if (Size(rawCodewords) != version.totalCodewords())
+		return {};
+
+	// Figure out the number and size of data blocks used by this version and
+	// error correction level
+	auto& ecBlocks = version.ecBlocksForLevel(ecLevel);
+
+	// First count the total number of data blocks
+	int totalBlocks = ecBlocks.numBlocks();
+	if (totalBlocks == 0)
+		return {};
+
+	std::vector<DataBlock> result(totalBlocks);
+	// Now establish DataBlocks of the appropriate size and number of data codewords
+	int numResultBlocks = 0;
+	for (auto& ecBlock : ecBlocks.blockArray()) {
+		for (int i = 0; i < ecBlock.count; i++) {
+			auto& item = result[numResultBlocks++];
+			item._numDataCodewords = ecBlock.dataCodewords;
+			item._codewords.resize(ecBlocks.codewordsPerBlock + ecBlock.dataCodewords);
+		}
+	}
+
+	// All blocks have the same amount of data, except that the last n
+	// (where n may be 0) have 1 more byte. Figure out where these start.
+	int shorterBlocksTotalCodewords = Size(result[0]._codewords);
+	int longerBlocksStartAt = Size(result) - 1;
+	while (longerBlocksStartAt >= 0) {
+		int numCodewords = Size(result[longerBlocksStartAt]._codewords);
+		if (numCodewords == shorterBlocksTotalCodewords) {
+			break;
+		}
+		longerBlocksStartAt--;
+	}
+	longerBlocksStartAt++;
+
+	int shorterBlocksNumDataCodewords = shorterBlocksTotalCodewords - ecBlocks.codewordsPerBlock;
+	// The last elements of result may be 1 element longer;
+	// first fill out as many elements as all of them have
+	int rawCodewordsOffset = 0;
+	if (version.isModel1()) {
+		// in Model 1 symbols the data blocks are concatenated back to back
+		for (int j = 0; j < numResultBlocks; j++)
+			for (int i = 0; i < shorterBlocksNumDataCodewords; i++)
+				result[j]._codewords[i] = rawCodewords[rawCodewordsOffset++];
+	} else {
+		// in all others, the data blocks are interleaved
+		for (int i = 0; i < shorterBlocksNumDataCodewords; i++)
+			for (int j = 0; j < numResultBlocks; j++)
+				result[j]._codewords[i] = rawCodewords[rawCodewordsOffset++];
+	}
+	// Fill out the last data block in the longer ones
+	for (int j = longerBlocksStartAt; j < numResultBlocks; j++) {
+		result[j]._codewords[shorterBlocksNumDataCodewords] = rawCodewords[rawCodewordsOffset++];
+	}
+	// Now add in error correction blocks
+	int max = Size(result[0]._codewords);
+	if (version.isModel1()) {
+		for (int j = 0; j < numResultBlocks; j++) {
+			for (int i = shorterBlocksNumDataCodewords; i < max; i++) {
+				int iOffset = j < longerBlocksStartAt ? i : i + 1;
+				result[j]._codewords[iOffset] = rawCodewords[rawCodewordsOffset++];
+			}
+		}
+	} else {
+		for (int i = shorterBlocksNumDataCodewords; i < max; i++) {
+			for (int j = 0; j < numResultBlocks; j++) {
+				int iOffset = j < longerBlocksStartAt ? i : i + 1;
+				result[j]._codewords[iOffset] = rawCodewords[rawCodewordsOffset++];
+			}
+		}
+	}
+	return result;
+}
+
+} // namespace ZXing::QRCode