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

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

@@ -0,0 +1,163 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODDataBarLimitedReader.h"
+
+#include "BarcodeFormat.h"
+#include "GTIN.h"
+#include "ODDataBarCommon.h"
+#include "BarcodeData.h"
+#include "SymbologyIdentifier.h"
+
+#include <ranges>
+
+//#define PRINT_DEBUG
+#ifndef PRINT_DEBUG
+#define printf(...){}
+#define printv(...){}
+#else
+#define printv(fmt, ...) \
+for (auto v : __VA_ARGS__) \
+	printf(fmt, v);
+#endif
+
+namespace ZXing::OneD {
+
+using namespace DataBar;
+
+constexpr int CHAR_LEN = 14;
+constexpr int SYMBOL_LEN = 1 + 3 * CHAR_LEN + 2;
+
+static Character ReadDataCharacter(const PatternView& view)
+{
+	constexpr int G_SUM[] = {0, 183064, 820064, 1000776, 1491021, 1979845, 1996939};
+	constexpr int T_EVEN[] = {28, 728, 6454, 203, 2408, 1, 16632};
+	constexpr int ODD_SUM[] = {17, 13, 9, 15, 11, 19, 7};
+	constexpr int ODD_WIDEST[] = {6, 5, 3, 5, 4, 8, 1};
+
+	auto pattern = NormalizedPatternFromE2E<CHAR_LEN>(view, 26);
+
+	int checksum = 0;
+	for (int v : std::ranges::reverse_view(pattern))
+		checksum = 3 * checksum + v;
+
+	using Array7I = std::array<int, 7>;
+	Array7I oddPattern = {}, evnPattern = {};
+	OddEven<Array7I&> res = {oddPattern, evnPattern};
+
+	for (int i = 0; i < Size(pattern); ++i)
+		res[i % 2][i / 2] = pattern[i];
+
+	printf(" o: ");
+	printv("%d ", oddPattern);
+	printf(" e: ");
+	printv("%d ", evnPattern);
+
+	int group = IndexOf(ODD_SUM, Reduce(oddPattern));
+	if (group == -1)
+		return {};
+
+	int oddWidest = ODD_WIDEST[group];
+	int evnWidest = 9 - oddWidest;
+	int vOdd = GetValue(oddPattern, oddWidest, false);
+	int vEvn = GetValue(evnPattern, evnWidest, true);
+	int tEvn = T_EVEN[group];
+	int gSum = G_SUM[group];
+
+	return {vOdd * tEvn + vEvn + gSum, checksum};
+}
+
+static std::string ConstructText(Character left, Character right)
+{
+	auto symVal = 2'013'571LL * left.value + right.value;
+
+	// Strip 2D linkage flag (GS1 Composite) if any (ISO/IEC 24724:2011 Section 6.2.3)
+	if (symVal >= 2'015'133'531'096LL) {
+		symVal -= 2'015'133'531'096LL;
+		assert(symVal <= 1'999'999'999'999LL); // 13 digits
+	}
+	auto txt = ToString(symVal, 13);
+	return "01" + txt + GTIN::ComputeCheckDigit(txt);
+}
+
+static inline bool Has26to18Ratio(int v26, int v18)
+{
+	return v26 + 1.5 * v26 / 26 > v18 / 18. * 26. && v26 - 1.5 * v26 / 26 < v18 / 18. * 26.;
+}
+
+std::array<int, 89> CheckChars = {
+	0b10'10101010'11100010, 0b10'10101010'01110010, 0b10'10101010'00111010, 0b10'10101001'01110010, 0b10'10101001'00111010,
+	0b10'10101000'10111010, 0b10'10100101'01110010, 0b10'10100101'00111010, 0b10'10100100'10111010, 0b10'10100010'10111010,
+	0b10'10010101'01110010, 0b10'10010101'00111010, 0b10'10010100'10111010, 0b10'10010010'10111010, 0b10'10001010'10111010,
+	0b10'01010101'01110010, 0b10'01010101'00111010, 0b10'01010100'10111010, 0b10'01010010'10111010, 0b10'01001010'10111010,
+	0b10'00101010'10111010, 0b10'10101011'01100010, 0b10'10101011'00110010, 0b10'10101011'00011010, 0b10'10101001'10110010,
+	0b10'10101001'10011010, 0b10'10101000'11011010, 0b10'10100101'10110010, 0b10'10100101'10011010, 0b10'10100100'11011010,
+	0b10'10100010'11011010, 0b10'10010101'10110010, 0b10'10010101'10011010, 0b10'10010100'11011010, 0b10'10010010'11011010,
+	0b10'10001010'11011010, 0b10'01010101'10110010, 0b10'01010101'10011010, 0b10'01010100'11011010, 0b10'01010010'11011010,
+	0b10'01001010'11011010, 0b10'00101010'11011010, 0b10'10101011'10100010, 0b10'10101011'10010010, 0b10'10101001'11010010,
+	0b10'10010101'11010010, 0b10'01010101'11010010, 0b10'10101101'01100010, 0b10'10101101'00110010, 0b10'10101101'00011010,
+	0b10'10101100'10110010, 0b10'10010110'10110010, 0b10'10010110'10011010, 0b10'10010110'01011010, 0b10'10010011'01011010,
+	0b10'10001011'01011010, 0b10'01010110'10110010, 0b10'01010110'10011010, 0b10'01001011'01011010, 0b10'10110101'01100010,
+	0b10'10110101'00110010, 0b10'10110101'00011010, 0b10'10110100'10110010, 0b10'10110100'10011010, 0b10'10110010'10110010,
+	0b10'01011010'10110010, 0b10'01011010'10011010, 0b10'01011010'01011010, 0b10'01011001'01011010, 0b10'01001101'01011010,
+	0b10'00101101'01011010, 0b10'11010101'01100010, 0b10'11010101'00110010, 0b10'11010101'00011010, 0b10'11010100'10110010,
+	0b10'11010100'10011010, 0b10'11010100'01011010, 0b10'11010010'10110010, 0b10'11010010'10011010, 0b10'11001010'10110010,
+	0b11'01010101'00110010, 0b11'01010101'00011010, 0b11'01010100'10110010, 0b11'01010100'10011010, 0b11'01010100'01011010,
+	0b11'01010010'10011010, 0b11'01010010'01011010, 0b11'01001010'10011010, 0b11'01010101'10010010,
+};
+
+BarcodeData DataBarLimitedReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<RowReader::DecodingState>&) const
+{
+	next = next.subView(-2, SYMBOL_LEN);
+	while (next.shift(2)) {
+		if (!IsGuard(next[27], next[43]))
+			continue;
+		auto spaceSize = (next[27] + next[43]) / 2;
+		if ((!next.isAtFirstBar() && next[-1] < spaceSize) || (!next.isAtLastBar() && next[SYMBOL_LEN] < 4 * spaceSize))
+			continue;
+		auto [mBar, MBar] = std::minmax({next[0], next[28], next[44]});
+		if (MBar > mBar * 4 / 3 + 1)
+			continue;
+
+		auto leftView = next.subView(1 + 0 * CHAR_LEN, CHAR_LEN);
+		auto checkView = next.subView(1 + 1 * CHAR_LEN, CHAR_LEN);
+		auto rightView = next.subView(1 + 2 * CHAR_LEN, CHAR_LEN);
+		auto leftWidth = leftView.sum();
+		auto checkWith = checkView.sum();
+		auto rightWidth = rightView.sum();
+		if (!Has26to18Ratio(leftWidth, checkWith) || !Has26to18Ratio(rightWidth, checkWith))
+			continue;
+
+		auto modSize = double(leftWidth + checkWith + rightWidth) / (26 + 18 + 26);
+		if ((!next.isAtFirstBar() && next[-1] < modSize) || (!next.isAtLastBar() && next[SYMBOL_LEN] < 5 * modSize))
+			continue;
+
+		auto checkCharPattern = ToInt(NormalizedPatternFromE2E<CHAR_LEN>(checkView, 18));
+		int checksum = IndexOf(CheckChars, checkCharPattern);
+		if (checksum == -1)
+			continue;
+
+		printf("%f - ", modSize);
+		printv("%d ", NormalizedPatternFromE2E<CHAR_LEN>(checkView, 18));
+
+		auto left = ReadDataCharacter(leftView);
+		auto right = ReadDataCharacter(rightView);
+
+		printf("- %d, %d, %d\n", checksum, left.value, right.value);
+
+		if (!left || !right || (left.checksum + 20 * right.checksum) % 89 != checksum)
+			continue;
+
+		return LinearBarcode(BarcodeFormat::DataBarLtd, ConstructText(left, right), rowNumber, next.pixelsInFront(),
+							 next.pixelsTillEnd(), {'e', '0', 0, AIFlag::GS1});
+	}
+
+	// guarantee progress (see loop in ODReader.cpp)
+	next = {};
+
+	return {};
+}
+
+} // namespace ZXing::OneD

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

@@ -0,0 +1,23 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ODRowReader.h"
+
+namespace ZXing::OneD {
+
+/**
+* Decodes DataBarLimited symbols. See ISO/IEC 24724:2011.
+*/
+class DataBarLimitedReader : public RowReader
+{
+public:
+	using RowReader::RowReader;
+
+	BarcodeData decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const override;
+};
+
+} // namespace ZXing::OneD

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

@@ -0,0 +1,240 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODDataBarReader.h"
+
+#include "BarcodeFormat.h"
+#include "DecoderResult.h"
+#include "DetectorResult.h"
+#include "GTIN.h"
+#include "ODDataBarCommon.h"
+#include "BarcodeData.h"
+
+#include <cmath>
+#include <ranges>
+#include <unordered_set>
+
+namespace ZXing::OneD {
+
+using namespace DataBar;
+
+static bool IsCharacterPair(PatternView v, int modsLeft, int modsRight)
+{
+	float modSizeRef = ModSizeFinder(v);
+	return IsCharacter(LeftChar(v), modsLeft, modSizeRef) && IsCharacter(RightChar(v), modsRight, modSizeRef);
+}
+
+static bool IsLeftPair(const PatternView& v)
+{
+	return IsFinder(v[8], v[9], v[10], v[11], v[12]) && IsGuard(v[-1], v[11]) && IsCharacterPair(v, 16, 15);
+}
+
+static bool IsRightPair(const PatternView& v)
+{
+	return IsFinder(v[12], v[11], v[10], v[9], v[8]) && IsGuard(v[9], v[21]) && IsCharacterPair(v, 15, 16);
+}
+
+static Character ReadDataCharacter(const PatternView& view, bool outsideChar, bool rightPair)
+{
+	constexpr int OUTSIDE_EVEN_TOTAL_SUBSET[] = {1, 10, 34, 70, 126};
+	constexpr int INSIDE_ODD_TOTAL_SUBSET[]   = {4, 20, 48, 81};
+	constexpr int OUTSIDE_GSUM[]              = {0, 161, 961, 2015, 2715};
+	constexpr int INSIDE_GSUM[]               = {0, 336, 1036, 1516};
+	constexpr int OUTSIDE_ODD_WIDEST[]        = {8, 6, 4, 3, 1};
+	constexpr int INSIDE_ODD_WIDEST[]         = {2, 4, 6, 8};
+
+	Array4I oddPattern = {}, evnPattern = {};
+	if (!ReadDataCharacterRaw(view, outsideChar ? 16 : 15, outsideChar == rightPair, oddPattern, evnPattern))
+		return {};
+
+	auto calcChecksumPortion = [](const Array4I& counts) {
+		int res = 0;
+		for (int count : std::ranges::reverse_view(counts))
+			res = 9 * res + count;
+		return res;
+	};
+
+	int checksumPortion = calcChecksumPortion(oddPattern) + 3 * calcChecksumPortion(evnPattern);
+
+	if (outsideChar) {
+		int oddSum = Reduce(oddPattern);
+		assert((oddSum & 1) == 0 && oddSum <= 12 && oddSum >= 4); // checked in ReadDataCharacterRaw
+		int group = (12 - oddSum) / 2;
+		int oddWidest = OUTSIDE_ODD_WIDEST[group];
+		int evnWidest = 9 - oddWidest;
+		int vOdd = GetValue(oddPattern, oddWidest, false);
+		int vEvn = GetValue(evnPattern, evnWidest, true);
+		int tEvn = OUTSIDE_EVEN_TOTAL_SUBSET[group];
+		int gSum = OUTSIDE_GSUM[group];
+		return {vOdd * tEvn + vEvn + gSum, checksumPortion};
+	} else {
+		int evnSum = Reduce(evnPattern);
+		assert((evnSum & 1) == 0 && evnSum <= 12 && evnSum >= 4); // checked in ReadDataCharacterRaw
+		int group = (10 - evnSum) / 2;
+		int oddWidest = INSIDE_ODD_WIDEST[group];
+		int evnWidest = 9 - oddWidest;
+		int vOdd = GetValue(oddPattern, oddWidest, true);
+		int vEvn = GetValue(evnPattern, evnWidest, false);
+		int tOdd = INSIDE_ODD_TOTAL_SUBSET[group];
+		int gSum = INSIDE_GSUM[group];
+		return {vEvn * tOdd + vOdd + gSum, checksumPortion};
+	}
+}
+
+int ParseFinderPattern(const PatternView& view, bool reversed)
+{
+	static constexpr std::array<Pattern<3>, 9> e2ePatterns = {{
+		{11, 10, 3 }, // {3, 8, 2, 1, 1}
+		{8 , 10, 6 }, // {3, 5, 5, 1, 1}
+		{6 , 10, 8 }, // {3, 3, 7, 1, 1}
+		{4 , 10, 10}, // {3, 1, 9, 1, 1}
+		{9 , 11, 5 }, // {2, 7, 4, 1, 1}
+		{7 , 11, 7 }, // {2, 5, 6, 1, 1}
+		{5 , 11, 9 }, // {2, 3, 8, 1, 1}
+		{6 , 11, 8 }, // {1, 5, 7, 1, 1}
+		{4 , 12, 10}, // {1, 3, 9, 1, 1}
+	}};
+
+	return ParseFinderPattern(view, reversed, e2ePatterns);
+}
+
+static Pair ReadPair(const PatternView& view, bool rightPair)
+{
+	if (int pattern = ParseFinderPattern(Finder(view), rightPair))
+		if (auto outside = ReadDataCharacter(rightPair ? RightChar(view) : LeftChar(view), true, rightPair))
+			if (auto inside = ReadDataCharacter(rightPair ? LeftChar(view) : RightChar(view), false, rightPair)) {
+				// include left and right guards
+				int xStart = view.pixelsInFront() - view[-1];
+				int xStop  = view.pixelsTillEnd() + 2 * view[FULL_PAIR_SIZE];
+				return {outside, inside, pattern, xStart, xStop};
+			}
+
+	return {};
+}
+
+static long long Value(Pair leftPair, Pair rightPair)
+{
+	auto value = [](Pair p) { return 1597 * p.left.value + p.right.value; };
+	auto res = 4537077LL * value(leftPair) + value(rightPair);
+	if (res >= 10000000000000LL) { // Strip 2D linkage flag (GS1 Composite) if any (ISO/IEC 24724:2011 Section 5.2.3)
+		res -= 10000000000000LL;
+	}
+	return res;
+}
+
+static bool ChecksumIsValid(Pair leftPair, Pair rightPair)
+{
+	auto checksum = [](Pair p) { return p.left.checksum + 4 * p.right.checksum; };
+	int a = (checksum(leftPair) + 16 * checksum(rightPair)) % 79;
+	int b = 9 * (std::abs(leftPair.finder) - 1) + (std::abs(rightPair.finder) - 1);
+	if (b > 72)
+		b--;
+	if (b > 8)
+		b--;
+	return a == b && Value(leftPair, rightPair) <= 9999999999999LL; // 13 digits
+}
+
+static bool PositionIsPlausible(const Pair& l, const Pair& r)
+{
+	int wl = l.xStop - l.xStart;
+	int wr = r.xStop - r.xStart;
+	int h = std::abs(l.y - r.y);
+	int dxl = std::abs(l.xStart - r.xStart);
+	int dxr = std::abs(l.xStop - r.xStart);
+
+	// - the pairs must be wider than the stack is high
+	// - the pairs must be roughly of the same width
+	// - the pairs x positions must be sufficiently aligned (i.e. the stack is not too slanted)
+	return h < wl && h < wr && wl > wr / 2 && wr > wl / 2 && (dxl < wl / 2 || dxr < wr / 2);
+}
+
+static std::string ConstructText(const Pair& leftPair, const Pair& rightPair)
+{
+	auto txt = ToString(Value(leftPair, rightPair), 13);
+	// see ISO/IEC 24724:2011 Section 9
+	return "01" + txt + GTIN::ComputeCheckDigit(txt);
+}
+
+struct State : public RowReader::DecodingState
+{
+	std::unordered_set<Pair, PairHash> leftPairs;
+	std::unordered_set<Pair, PairHash> rightPairs;
+};
+
+BarcodeData DataBarReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<RowReader::DecodingState>& state) const
+{
+	if (!state)
+		state = std::make_unique<State>();
+	auto* prevState = static_cast<State*>(state.get());
+
+	if (_opts.hasFormat(BarcodeFormat::DataBarOmni) && !_opts.hasFormat(BarcodeFormat::DataBar) && !_opts.tryHarder()) {
+		// non-stacked version
+		(void)state;
+		next = next.subView(-1, FULL_PAIR_SIZE + 1); // +1 reflects the guard pattern on the right, see IsRightPair());
+		// yes: the first view we test is at index 1 (black bar at 0 would be the guard pattern)
+		while (next.shift(2)) {
+			if (IsLeftPair(next)) {
+				if (auto leftPair = ReadPair(next, false); leftPair && next.shift(FULL_PAIR_SIZE) && IsRightPair(next)) {
+					if (auto rightPair = ReadPair(next, true); rightPair && ChecksumIsValid(leftPair, rightPair)) {
+						return LinearBarcode(BarcodeFormat::DataBarOmni, ConstructText(leftPair, rightPair), rowNumber, leftPair.xStart,
+											 rightPair.xStop, {'e', '0', 0, AIFlag::GS1});
+					}
+				}
+			}
+		}
+
+		goto out;
+	}
+
+	next = next.subView(0, FULL_PAIR_SIZE + 1); // +1 reflects the guard pattern on the right, see IsRightPair()
+	// yes: the first view we test is at index 1 (black bar at 0 would be the guard pattern)
+	while (next.shift(1)) {
+		if (IsLeftPair(next)) {
+			if (auto leftPair = ReadPair(next, false)) {
+				leftPair.y = rowNumber;
+				auto [it, inserted] = prevState->leftPairs.insert(leftPair);
+				if (!inserted)
+					const_cast<Pair&>(*it).count++;
+				next.shift(FULL_PAIR_SIZE - 1);
+			}
+		}
+
+		if (next.shift(1) && IsRightPair(next)) {
+			if (auto rightPair = ReadPair(next, true)) {
+				rightPair.y = rowNumber;
+				auto [it, inserted] = prevState->rightPairs.insert(rightPair);
+				if (!inserted)
+					const_cast<Pair&>(*it).count++;
+				next.shift(FULL_PAIR_SIZE + 2);
+			}
+		}
+	}
+
+	for (const auto& leftPair : prevState->leftPairs)
+		for (const auto& rightPair : prevState->rightPairs)
+			if (ChecksumIsValid(leftPair, rightPair) && PositionIsPlausible(leftPair, rightPair) && leftPair.count > 1
+				&& rightPair.count > 1) {
+				// Symbology identifier ISO/IEC 24724:2011 Section 9 and GS1 General Specifications 5.1.3 Figure 5.1.3-2
+				auto res = BarcodeData{.content = Content(ByteArray{ConstructText(leftPair, rightPair)}, {'e', '0', 0, AIFlag::GS1}),
+									   .position = EstimatePosition(leftPair, rightPair),
+									   .format = leftPair.center() < rightPair.xStart ? BarcodeFormat::DataBarOmni
+																					  : BarcodeFormat::DataBarStk,
+									   .lineCount = EstimateLineCount(leftPair, rightPair)};
+
+				prevState->leftPairs.erase(leftPair);
+				prevState->rightPairs.erase(rightPair);
+				return res;
+			}
+
+out:
+	// guarantee progress (see loop in ODReader.cpp)
+	next = {};
+
+	return {};
+}
+
+} // namespace ZXing::OneD

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

@@ -0,0 +1,25 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ODRowReader.h"
+
+namespace ZXing::OneD {
+
+/**
+* Decodes DataBar (formerly known as RSS) symbols, including truncated and stacked variants. See ISO/IEC 24724:2006.
+*/
+class DataBarReader : public RowReader
+{
+public:
+	using RowReader::RowReader;
+
+	BarcodeData decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const override;
+};
+
+} // namespace ZXing::OneD

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

@@ -0,0 +1,62 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODEAN13Writer.h"
+
+#include "ODUPCEANCommon.h"
+#include "ODWriterHelper.h"
+#include "Utf.h"
+
+#include <array>
+#include <vector>
+
+namespace ZXing::OneD {
+
+static const int FIRST_DIGIT_ENCODINGS[] = {
+	0x00, 0x0B, 0x0D, 0xE, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A
+};
+
+static const int CODE_WIDTH = 3 + // start guard
+                              (7 * 6) + // left bars
+                              5 + // middle guard
+                              (7 * 6) + // right bars
+                              3; // end guard
+
+BitMatrix
+EAN13Writer::encode(const std::wstring& contents, int width, int height) const
+{
+	auto digits = UPCEANCommon::DigitString2IntArray<13>(contents);
+
+	int parities = FIRST_DIGIT_ENCODINGS[digits[0]];
+	std::vector<bool> result(CODE_WIDTH, false);
+	int pos = 0;
+
+	pos += WriterHelper::AppendPattern(result, pos, UPCEANCommon::START_END_PATTERN, true);
+
+	// See {@link #EAN13Reader} for a description of how the first digit & left bars are encoded
+	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);
+	}
+
+	pos += WriterHelper::AppendPattern(result, pos, UPCEANCommon::MIDDLE_PATTERN, false);
+
+	for (int i = 7; i <= 12; i++) {
+		pos += WriterHelper::AppendPattern(result, pos, UPCEANCommon::L_PATTERNS[digits[i]], true);
+	}
+	WriterHelper::AppendPattern(result, pos, UPCEANCommon::START_END_PATTERN, true);
+	return WriterHelper::RenderResult(result, width, height, _sidesMargin >= 0 ? _sidesMargin : 9);
+}
+
+BitMatrix EAN13Writer::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/ODEAN13Writer.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 EAN8 code as a {@link BitMatrix}.
+*
+* @author aripollak@gmail.com (Ari Pollak)
+*/
+class EAN13Writer
+{
+public:
+	EAN13Writer& 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/ODEAN8Writer.cpp

@@ -0,0 +1,51 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODEAN8Writer.h"
+
+#include "ODUPCEANCommon.h"
+#include "ODWriterHelper.h"
+#include "Utf.h"
+
+#include <vector>
+
+namespace ZXing::OneD {
+
+static const int CODE_WIDTH = 3 + // start guard
+                              (7 * 4) + // left bars
+                              5 + // middle guard
+                              (7 * 4) + // right bars
+                              3; // end guard
+
+BitMatrix
+EAN8Writer::encode(const std::wstring& contents, int width, int height) const
+{
+	auto digits = UPCEANCommon::DigitString2IntArray<8>(contents);
+
+	std::vector<bool> result(CODE_WIDTH, false);
+	int pos = 0;
+
+	pos += WriterHelper::AppendPattern(result, pos, UPCEANCommon::START_END_PATTERN, true);
+
+	for (int i = 0; i <= 3; i++) {
+		pos += WriterHelper::AppendPattern(result, pos, UPCEANCommon::L_PATTERNS[digits[i]], false);
+	}
+
+	pos += WriterHelper::AppendPattern(result, pos, UPCEANCommon::MIDDLE_PATTERN, false);
+
+	for (int i = 4; i <= 7; i++) {
+		pos += WriterHelper::AppendPattern(result, pos, UPCEANCommon::L_PATTERNS[digits[i]], true);
+	}
+	WriterHelper::AppendPattern(result, pos, UPCEANCommon::START_END_PATTERN, true);
+	return WriterHelper::RenderResult(result, width, height, _sidesMargin >= 0 ? _sidesMargin : 9);
+}
+
+BitMatrix EAN8Writer::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/ODEAN8Writer.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 EAN8 code as a {@link BitMatrix}.
+*
+* @author aripollak@gmail.com (Ari Pollak)
+*/
+class EAN8Writer
+{
+public:
+	EAN8Writer& 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