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

package/cpp/zxing-core/core/src/oned/ODTelepenReader.cpp

@@ -0,0 +1,199 @@
+/*
+ * Copyright 2026 Axel Waggershauser
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODTelepenReader.h"
+
+#include "BarcodeData.h"
+#include "SymbologyIdentifier.h"
+#include "ZXAlgorithms.h"
+
+#include <cstdint>
+#include <ranges>
+
+#ifndef PRINT_DEBUG
+#define printf(...){}
+#endif
+
+// This code is based on the AIM Europe USS Telepen (1991) specification and ISO/IEC 15424:2025.
+// See also https://advanova.co.uk/wp-content/uploads/2022/05/Barcode-Symbology-information-and-History.pdf
+
+namespace ZXing::OneD {
+
+static std::string DecodeNumeric(std::string_view encoded)
+{
+	std::string decoded;
+	decoded.reserve(encoded.size() * 2);
+
+	for (uint8_t codeword : encoded) {
+		if (codeword < 16 || codeword == 127)
+			decoded += codeword; // control characters
+		else if (17 <= codeword && codeword < 27)
+			(decoded += ToDigit(codeword - 17)) += 'X';
+		else if (27 <= codeword && codeword < 127)
+			decoded += ToString(codeword - 27, 2);
+		else // (codeword == 16): 16/DLE is the "shift to alpha" codeword and can't appear twice
+			return {};
+	}
+
+	return decoded;
+}
+
+BarcodeData TelepenReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<RowReader::DecodingState>&) const
+{
+	constexpr int minCharCount = 1; // TODO
+	constexpr int minQuietZone = 5; // spec requires 10
+	constexpr int minCharLength = 16 / 3;
+	constexpr FixedPattern<12, 16> startPatterns[3] = {
+		{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3}, // START 1: "Full ASCII" in AIM Spec
+		{1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 3}, // START 2: "Compressed Numeric (+ Full ASCII)" in AIM Spec
+		{1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 3}  // START 3: "Full ASCII + Compressed Numeric" in AIM Spec
+	};
+	constexpr FixedPattern<6, 6> prefixPattern = {1, 1, 1, 1, 1, 1};
+	constexpr FixedPattern<11, 15> endPatterns[3] = {
+		{3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1}, // STOP 1
+		{3, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1}, // STOP 2
+		{3, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1}  // STOP 3
+	};
+
+	// Note: In the real-world there are symbols with START 1 + STOP 1 patterns that may contain "Compressed Numeric (+ Full ASCII)"
+	// data, see guess-work below.
+
+#if 0 // use fast 1:1:1:1 start pattern plausibility check, then E2E check for the whole start pattern
+	next = FindLeftGuard<12>(next, 2 * 12 + minCharCount * minCharLength, [=](const PatternView& view, int spaceInPixel) {
+		// find min/max of 4 consecutive bars/spaces and make sure they are close together
+		auto mB = view[0], mS = view[1], MB = view[2], MS = view[3];
+		if (mB > MB)
+			std::swap(mB, MB);
+		if (mS > MS)
+			std::swap(mS, MS);
+		return MB <= mB * 4 / 3 + 1 && MS <= mS * 4 / 3 + 1 && MB < 2 * mS + 1 && MS < 2 * mB + 1
+			   && IsPattern<true>(view, startPattern, spaceInPixel, minQuietZone);
+	});
+#else
+	next = FindLeftGuard<true>(next, 2 * 12 + minCharCount * minCharLength, prefixPattern, minQuietZone);
+#endif
+	if (!next.isValid())
+		return {};
+
+	int startChar = 1;
+	for (; startChar < 4; ++startChar)
+		if (IsPattern<true>(next, startPatterns[startChar - 1], next.spaceInFront(), minQuietZone))
+			break;
+	if (startChar == 4 || (startChar > 1 && !readNumeric))
+		return {};
+
+	const auto &startPattern = startPatterns[startChar - 1];
+	const auto &endPattern = endPatterns[startChar - 1];
+
+	int xStart = next.pixelsInFront();
+	next = next.subView(0, startPattern.size());
+
+	// get threshold from start pattern
+	auto threshold = NarrowWideThreshold(next);
+	if (!threshold.isValid())
+		return {};
+
+	next = next.subView(startPattern.size(), endPattern.size());
+	std::string raw;
+	while (next.isValid() && !IsRightGuard<true>(next, endPattern, minQuietZone)) {
+		BitArray ba;
+		bool inBlock = false;
+		BarAndSpace<int> wSum, wNum, nSum, nNum;
+		while (next.isValid() && ba.size() < 8) {
+			if (next[0] > threshold[0] * 3 || next[1] > threshold[1] * 3)
+				return {};
+			BarAndSpace<bool> wide = {next[0] > threshold[0], next[1] > threshold[1]};
+			if (!wide.bar && !wide.space)     // narrow bar, narrow space
+				ba.appendBit(1);
+			else if (!wide.bar && wide.space) // narrow bar, wide space
+				// trailing 10 | leading 01
+				ba.appendBits(std::exchange(inBlock, !inBlock) ? 0b10 : 0b01, 2);
+			else if (wide.bar && !wide.space) // wide bar, narrow space
+				ba.appendBits(0b00, 2);
+			else if (wide.bar && wide.space)  // wide bar, wide space
+				ba.appendBits(0b010, 3);
+
+			for (int i = 0; i < 2; ++i) {
+				if (next[i] > threshold[i]) {
+					wSum[i] += next[i];
+					++wNum[i];
+				} else {
+					nSum[i] += next[i];
+					++nNum[i];
+				}
+			}
+
+			next.skipPair();
+		}
+		if (ba.size() != 8 || std::ranges::count(ba, false) % 2 != 0) // even parity check
+			return {};
+		ba.reverse();
+		raw += ToInt<char>(ba) & 0x7f; // drop the parity bit
+
+		printf("line: %d, threshold: %2d, %2d, wSum: %2d, %2d, wNum: %d, %d, nSum: %2d, %2d, nNum: %d, %d -> %c ends at: %d\n", rowNumber,
+			   threshold[0], threshold[1], wSum[0], wSum[1], wNum[0], wNum[1], nSum[0], nSum[1], nNum[0], nNum[1],
+			   raw.back(), next.pixelsInFront());
+
+		for (int i = 0; i < 2; ++i)
+			threshold[i] = wNum[i] && nNum[i] ? ((wSum[i] + wNum[i] / 2) / wNum[i] + (nSum[i] + nNum[i] / 2) / nNum[i]) / 2
+						   : nNum[i]          ? (2 * nSum[i] + nNum[i] / 2) / nNum[i]
+											  : threshold[i];
+	}
+
+	if (raw.size() < minCharCount + 1 || !IsRightGuard<true>(next, endPattern, minQuietZone))
+		return {};
+
+	auto txt = raw.substr(0, raw.size() - 1); // drop checksum character
+	auto checkSum = (127 - (Reduce(txt, 0) % 127)) % 127;
+	char modifier = 0;
+	Error error;
+
+	if (checkSum != raw.back()) {
+		error = Error::Checksum;
+	} else {
+		if (startChar == 1 && readNumeric) { // "Full ASCII" in AIM Spec or "Compressed Numeric (+ Full ASCII)" in "the wild"
+			// Apply guesswork to determine whether to treat as "Full ASCII" or "Compressed Numeric (+ Full ASCII)"
+			// Num+Alpha (startChar is 2) is likely if there is at most one DLE that is not the first character and there are
+			// non-printable ASCII characters but none that are not used in "Compressed Numeric" to encode digits.
+			if (!readAlpha
+				|| (std::ranges::count(txt, '\x10') <= 1 && txt.front() != '\x10'
+					&& std::ranges::any_of(txt, [](uint8_t c) { return c < 32; })
+					&& std::ranges::none_of(txt, [](uint8_t c) { return c < 16; })))
+				startChar = 2;
+		}
+
+		const auto dle = IndexOf(txt, '\x10'); // DLE (== 16) is the "shift" codeword for switching between alpha and numeric modes
+		// see ISO/IEC 15424:2025 4.4.3
+		if (startChar == 1) {
+			modifier = '0'; // Full ASCII mode
+		} else if (startChar == 2 && dle != 0) {
+			auto num = dle == -1 ? DecodeNumeric(txt) : DecodeNumeric(txt.substr(0, dle));
+			auto alpha = dle == -1 ? std::string() : txt.substr(dle + 1);
+			if (num.empty())
+				error = Error::Format; // invalid numeric encoding
+			else
+				txt = num + alpha;
+			modifier = dle == -1 ? '1' : '2'; // Double density numeric: only (1) / followed by full ASCII (2)
+		} else if (startChar == 3 && dle != 0) {
+			auto alpha = dle == -1 ? txt : txt.substr(0, dle);
+			auto num = dle == -1 ? std::string() : DecodeNumeric(txt.substr(dle + 1));
+			if (dle != -1 && num.empty())
+				error = Error::Format; // invalid numeric encoding
+			else
+				txt = alpha + num;
+			modifier = dle == -1 ? '0' : '4'; // Full ASCII: only (0) / followed by double density numeric (4)
+		} else
+			error = Error::Format; // DLE as first character is not allowed
+	}
+
+	int xStop = next.pixelsTillEnd();
+	SymbologyIdentifier symbologyIdentifier = {'B', modifier};
+	auto format = modifier == '1' ? BarcodeFormat::TelepenNumeric : BarcodeFormat::TelepenAlpha;
+	printf("line: %d, raw: %s, txt: %s, checksum: %d\n", rowNumber, raw.c_str(), txt.c_str(), checkSum);
+
+	return LinearBarcode(format, txt, rowNumber, xStart, xStop, symbologyIdentifier, error);
+}
+
+} // namespace ZXing::OneD

package/cpp/zxing-core/core/src/oned/ODTelepenReader.h

@@ -0,0 +1,25 @@
+/*
+* Copyright 2026 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ODRowReader.h"
+
+namespace ZXing::OneD {
+
+class TelepenReader : public RowReader
+{
+	bool readAlpha, readNumeric;
+public:
+	explicit TelepenReader(const ReaderOptions& opts)
+		: RowReader(opts),
+		  readAlpha(opts.hasFormat(BarcodeFormat::TelepenAlpha)),
+		  readNumeric(opts.hasFormat(BarcodeFormat::TelepenNumeric))
+	{}
+
+	BarcodeData decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
+};
+
+} // namespace ZXing::OneD

package/cpp/zxing-core/core/src/oned/ODUPCAWriter.cpp

@@ -0,0 +1,33 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODUPCAWriter.h"
+
+#include "BitMatrix.h"
+#include "ODEAN13Writer.h"
+#include "Utf.h"
+
+#include <stdexcept>
+
+namespace ZXing::OneD {
+
+BitMatrix
+UPCAWriter::encode(const std::wstring& contents, int width, int height) const
+{
+	// Transform a UPC-A code into the equivalent EAN-13 code, and add a check digit if it is not already present.
+	size_t length = contents.length();
+	if (length != 11 && length != 12) {
+		throw std::invalid_argument("Requested contents should be 11 or 12 digits long");
+	}
+	return EAN13Writer().setMargin(_sidesMargin).encode(L'0' + contents, width, height);
+}
+
+BitMatrix UPCAWriter::encode(const std::string& contents, int width, int height) const
+{
+	return encode(FromUtf8(contents), width, height);
+}
+
+} // namespace ZXing::OneD

package/cpp/zxing-core/core/src/oned/ODUPCAWriter.h

@@ -0,0 +1,34 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+
+namespace ZXing {
+
+class BitMatrix;
+
+namespace OneD {
+
+/**
+* This object renders a UPC-A code as a {@link BitMatrix}.
+*
+* @author qwandor@google.com (Andrew Walbran)
+*/
+class UPCAWriter
+{
+public:
+	UPCAWriter& setMargin(int sidesMargin) { _sidesMargin = sidesMargin; return *this; }
+	BitMatrix encode(const std::wstring& contents, int width, int height) const;
+	BitMatrix encode(const std::string& contents, int width, int height) const;
+
+private:
+	int _sidesMargin = -1;
+};
+
+} // OneD
+} // ZXing

package/cpp/zxing-core/core/src/oned/ODUPCEANCommon.cpp

@@ -0,0 +1,80 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODUPCEANCommon.h"
+
+namespace ZXing::OneD {
+
+const std::array<int, 3> UPCEANCommon::START_END_PATTERN = { 1, 1, 1 };
+const std::array<int, 5> UPCEANCommon::MIDDLE_PATTERN = { 1, 1, 1, 1, 1 };
+const std::array<int, 6> UPCEANCommon::UPCE_END_PATTERN = { 1, 1, 1, 1, 1, 1 };
+
+const std::array<std::array<int, 4>, 10> UPCEANCommon::L_PATTERNS = {
+	3, 2, 1, 1, // 0
+	2, 2, 2, 1, // 1
+	2, 1, 2, 2, // 2
+	1, 4, 1, 1, // 3
+	1, 1, 3, 2, // 4
+	1, 2, 3, 1, // 5
+	1, 1, 1, 4, // 6
+	1, 3, 1, 2, // 7
+	1, 2, 1, 3, // 8
+	3, 1, 1, 2, // 9
+};
+
+const std::array<std::array<int, 4>, 20> UPCEANCommon::L_AND_G_PATTERNS = {
+	3, 2, 1, 1, // 0
+	2, 2, 2, 1, // 1
+	2, 1, 2, 2, // 2
+	1, 4, 1, 1, // 3
+	1, 1, 3, 2, // 4
+	1, 2, 3, 1, // 5
+	1, 1, 1, 4, // 6
+	1, 3, 1, 2, // 7
+	1, 2, 1, 3, // 8
+	3, 1, 1, 2, // 9
+	// reversed
+	1, 1, 2, 3, // 10
+	1, 2, 2, 2, // 11
+	2, 2, 1, 2, // 12
+	1, 1, 4, 1, // 13
+	2, 3, 1, 1, // 14
+	1, 3, 2, 1, // 15
+	4, 1, 1, 1, // 16
+	2, 1, 3, 1, // 17
+	3, 1, 2, 1, // 18
+	2, 1, 1, 3, // 19
+};
+
+// For an UPC-E barcode, the final digit is represented by the parities used
+// to encode the middle six digits, according to the table below.
+//
+//                Parity of next 6 digits
+//    Digit   0     1     2     3     4     5
+//       0    Even   Even  Even Odd  Odd   Odd
+//       1    Even   Even  Odd  Even Odd   Odd
+//       2    Even   Even  Odd  Odd  Even  Odd
+//       3    Even   Even  Odd  Odd  Odd   Even
+//       4    Even   Odd   Even Even Odd   Odd
+//       5    Even   Odd   Odd  Even Even  Odd
+//       6    Even   Odd   Odd  Odd  Even  Even
+//       7    Even   Odd   Even Odd  Even  Odd
+//       8    Even   Odd   Even Odd  Odd   Even
+//       9    Even   Odd   Odd  Even Odd   Even
+//
+// The encoding is represented by the following array, which is a bit pattern
+// using Odd = 0 and Even = 1. For example, 5 is represented by:
+//
+//              Odd Even Even Odd Odd Even
+// in binary:
+//                0    1    1   0   0    1   == 0x19
+//
+const std::array<int, 20> UPCEANCommon::NUMSYS_AND_CHECK_DIGIT_PATTERNS = {
+	0x38, 0x34, 0x32, 0x31, 0x2C, 0x26, 0x23, 0x2A, 0x29, 0x25,
+	0x07, 0x0B, 0x0D, 0x0E, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A,
+};
+
+} // namespace ZXing::OneD

package/cpp/zxing-core/core/src/oned/ODUPCEANCommon.h

@@ -0,0 +1,129 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "GTIN.h"
+
+#include <array>
+#include <cstddef>
+#include <stdexcept>
+#include <string>
+
+namespace ZXing::OneD::UPCEANCommon {
+
+using Digit = std::array<int, 4>;
+
+/**
+ * Start/end guard pattern.
+ */
+extern const std::array<int, 3> START_END_PATTERN;
+
+/**
+ * "Odd", or "L" patterns used to encode UPC/EAN digits.
+ */
+extern const std::array<Digit, 10> L_PATTERNS;
+
+/**
+ * Pattern marking the middle of a UPC/EAN pattern, separating the two halves.
+ */
+extern const std::array<int, 5> MIDDLE_PATTERN;
+
+/**
+ * As above but also including the "even", or "G" patterns used to encode UPC/EAN digits.
+ */
+extern const std::array<Digit, 20> L_AND_G_PATTERNS;
+
+/**
+ * UPCE end guard pattern (== MIDDLE_PATTERN + single module black bar)
+ */
+extern const std::array<int, 6> UPCE_END_PATTERN;
+
+/**
+ * See {@link #L_AND_G_PATTERNS}; these values similarly represent patterns of
+ * even-odd parity encodings of digits that imply both the number system (0 or 1)
+ * used (index / 10), and the check digit (index % 10).
+ */
+extern const std::array<int, 20> NUMSYS_AND_CHECK_DIGIT_PATTERNS;
+
+template <size_t N, typename T>
+std::array<int, N> DigitString2IntArray(const std::basic_string<T>& in, int checkDigit = -1)
+{
+	static_assert(N == 8 || N == 13, "invalid UPC/EAN length");
+
+	if (in.size() != N && in.size() != N - 1)
+		throw std::invalid_argument("Invalid input string length");
+
+	std::array<int, N> out = {};
+	for (size_t i = 0; i < in.size(); ++i) {
+		out[i] = in[i] - '0';
+		if (out[i] < 0 || out[i] > 9)
+			throw std::invalid_argument("Contents must contain only digits: 0-9");
+	}
+
+	if (checkDigit == -1)
+		checkDigit = GTIN::ComputeCheckDigit(in, N == in.size());
+
+	if (in.size() == N - 1)
+		out.back() = checkDigit - '0';
+	else if (in.back() != checkDigit)
+		throw std::invalid_argument("Checksum error");
+
+	return out;
+}
+
+/**
+ * Expands a UPC-E value back into its full, equivalent UPC-A code value.
+ *
+ * @param upce UPC-E code as string of digits
+ * @return equivalent UPC-A code as string of digits
+ */
+template <typename StringT>
+StringT ConvertUPCEtoUPCA(const StringT& upce)
+{
+	if (upce.length() < 7)
+		return upce;
+
+	auto upceChars = upce.substr(1, 6);
+
+	StringT result;
+	result.reserve(12);
+	result += upce[0];
+	auto lastChar = upceChars[5];
+	switch (lastChar) {
+	case '0':
+	case '1':
+	case '2':
+		result += upceChars.substr(0, 2);
+		result += lastChar;
+		result += StringT(4, '0');
+		result += upceChars.substr(2, 3);
+		break;
+	case '3':
+		result += upceChars.substr(0, 3);
+		result += StringT(5, '0');
+		result += upceChars.substr(3, 2);
+		break;
+	case '4':
+		result += upceChars.substr(0, 4);
+		result += StringT(5, '0');
+		;
+		result += upceChars[4];
+		break;
+	default:
+		result += upceChars.substr(0, 5);
+		result += StringT(4, '0');
+		result += lastChar;
+		break;
+	}
+	// Only append check digit in conversion if supplied
+	if (upce.length() >= 8) {
+		result += upce[7];
+	}
+	return result;
+}
+
+} // namespace ZXing::OneD::UPCEANCommon

package/cpp/zxing-core/core/src/oned/ODUPCEWriter.cpp

@@ -0,0 +1,56 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODUPCEWriter.h"
+
+#include "ODUPCEANCommon.h"
+#include "ODWriterHelper.h"
+#include "Utf.h"
+
+#include <stdexcept>
+#include <vector>
+
+namespace ZXing::OneD {
+
+static const int CODE_WIDTH = 3 + // start guard
+                              (7 * 6) + // bars
+                              6; // end guard
+
+BitMatrix
+UPCEWriter::encode(const std::wstring& contents, int width, int height) const
+{
+	auto digits = UPCEANCommon::DigitString2IntArray<8>(
+		contents, GTIN::ComputeCheckDigit(UPCEANCommon::ConvertUPCEtoUPCA(contents), contents.size() == 8));
+
+	int firstDigit = digits[0];
+	if (firstDigit != 0 && firstDigit != 1) {
+		throw std::invalid_argument("Number system must be 0 or 1");
+	}
+
+	int parities = UPCEANCommon::NUMSYS_AND_CHECK_DIGIT_PATTERNS[firstDigit * 10 + digits[7]];
+	std::vector<bool> result(CODE_WIDTH, false);
+	int pos = 0;
+
+	pos += WriterHelper::AppendPattern(result, pos, UPCEANCommon::START_END_PATTERN, true);
+
+	for (int i = 1; i <= 6; i++) {
+		int digit = digits[i];
+		if ((parities >> (6 - i) & 1) == 1) {
+			digit += 10;
+		}
+		pos += WriterHelper::AppendPattern(result, pos, UPCEANCommon::L_AND_G_PATTERNS[digit], false);
+	}
+
+	WriterHelper::AppendPattern(result, pos, UPCEANCommon::UPCE_END_PATTERN, false);
+	return WriterHelper::RenderResult(result, width, height, _sidesMargin >= 0 ? _sidesMargin : 9);
+}
+
+BitMatrix UPCEWriter::encode(const std::string& contents, int width, int height) const
+{
+	return encode(FromUtf8(contents), width, height);
+}
+
+} // namespace ZXing::OneD

package/cpp/zxing-core/core/src/oned/ODUPCEWriter.h

@@ -0,0 +1,34 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+
+namespace ZXing {
+
+class BitMatrix;
+
+namespace OneD {
+
+/**
+* This object renders an UPC-E code as a {@link BitMatrix}.
+*
+* @author 0979097955s@gmail.com (RX)
+*/
+class UPCEWriter
+{
+public:
+	UPCEWriter& setMargin(int sidesMargin) { _sidesMargin = sidesMargin; return *this; }
+	BitMatrix encode(const std::wstring& contents, int width, int height) const;
+	BitMatrix encode(const std::string& contents, int width, int height) const;
+
+private:
+	int _sidesMargin = -1;
+};
+
+} // OneD
+} // ZXing

package/cpp/zxing-core/core/src/oned/ODWriterHelper.cpp

@@ -0,0 +1,39 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODWriterHelper.h"
+
+#include "BitMatrix.h"
+
+#include <algorithm>
+
+namespace ZXing::OneD {
+
+/**
+* @return a byte array of horizontal pixels (0 = white, 1 = black)
+*/
+BitMatrix
+WriterHelper::RenderResult(const std::vector<bool>& code, int width, int height, int sidesMargin)
+{
+	int inputWidth = Size(code);
+	// Add quiet zone on both sides.
+	int fullWidth = inputWidth + sidesMargin;
+	int outputWidth = std::max(width, fullWidth);
+	int outputHeight = std::max(1, height);
+
+	int multiple = outputWidth / fullWidth;
+	int leftPadding = (outputWidth - (inputWidth * multiple)) / 2;
+
+	BitMatrix result(outputWidth, outputHeight);
+	for (int inputX = 0, outputX = leftPadding; inputX < inputWidth; inputX++, outputX += multiple) {
+		if (code[inputX]) {
+			result.setRegion(outputX, 0, multiple, outputHeight);
+		}
+	}
+	return result;
+}
+
+} // namespace ZXing::OneD

package/cpp/zxing-core/core/src/oned/ODWriterHelper.h

@@ -0,0 +1,48 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BitMatrix.h"
+
+#include <cstddef>
+#include <vector>
+
+namespace ZXing::OneD {
+
+/**
+* <p>Encapsulates functionality and implementation that is common to one-dimensional barcodes.</p>
+*
+* @author dsbnatut@gmail.com (Kazuki Nishiura)
+*/
+class WriterHelper
+{
+public:
+	/**
+	* @return a byte array of horizontal pixels (0 = white, 1 = black)
+	*/
+	static BitMatrix RenderResult(const std::vector<bool>& code, int width, int height, int sidesMargin);
+
+	/**
+	* @param target encode black/white pattern into this array
+	* @param pos position to start encoding at in {@code target}
+	* @param pattern lengths of black/white runs to encode
+	* @param startColor starting color - false for white, true for black
+	* @return the number of elements added to target.
+	*/
+	template <typename Container>
+	static int AppendPattern(std::vector<bool>& target, int pos, const Container& pattern, bool startColor)
+	{
+		for (auto s : pattern) {
+			for (int j = 0; j < s; j++)
+				target[pos++] = startColor;
+			startColor = !startColor; // flip color after each segment
+		}
+		return Reduce(pattern);
+	}
+};
+
+} // namespace ZXing::OneD