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

package/cpp/zxing-core/core/src/ReedSolomon.cpp

@@ -0,0 +1,100 @@
+// Copyright 2026 Axel Waggershauser
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ReedSolomon.h"
+#include "Version.h"
+#include "ZXAlgorithms.h"
+
+#include "librscpp/encode.h"
+#include "librscpp/decode.h"
+
+#include <algorithm>
+#include <type_traits>
+#include <stdexcept>
+#include <utility>
+
+namespace ZXing {
+
+namespace rs = librscpp;
+
+using GF2nI = rs::GF2n<>;
+
+const GF2nI& GetGF2n(RSField field)
+{
+	static GF2nI gf2n_4_1(0x0013, 1);      // x^4 + x + 1
+	static GF2nI gf2n_6_1(0x0043, 1);      // x^6 + x + 1
+	static GF2nI gf2n_8_5_3_2(0x012D, 1);  // x^8 + x^5 + x^3 + x^2 + 1 : DataMatrix
+	static GF2nI gf2n_8_4_3_2(0x011D, 0);  // x^8 + x^4 + x^3 + x^2 + 1 : QRCode
+	static GF2nI gf2n_10_3(0x0409, 1);     // x^10 + x^3 + 1
+	static GF2nI gf2n_12_6_5_3(0x1069, 1); // x^12 + x^6 + x^5 + x^3 + 1
+
+	switch (field) {
+	case RSField::Aztec4: return gf2n_4_1;
+	case RSField::Aztec6: return gf2n_6_1;
+	case RSField::Aztec8: return gf2n_8_5_3_2;
+	case RSField::Aztec10: return gf2n_10_3;
+	case RSField::Aztec12: return gf2n_12_6_5_3;
+	case RSField::DataMatrix: return gf2n_8_5_3_2;
+	case RSField::MaxiCode: return gf2n_6_1;
+	case RSField::QRCode: return gf2n_8_4_3_2;
+	default: throw std::invalid_argument("Unsupported RSField");
+	}
+}
+
+const rs::GFp<>& GetGFPDF417()
+{
+	static rs::GFp<> gf929_3(929, 3, 1);
+	return gf929_3;
+}
+
+// See ISO/IEC 15415:2024 7.5.9
+static std::optional<double> UEC(std::optional<int> usedECC, int numECC)
+{
+	return usedECC ? std::optional(std::clamp(1.0 - static_cast<double>(*usedECC) / numECC, 0.0, 1.0)) : std::nullopt;
+}
+
+#ifdef ZXING_READERS
+std::optional<double> ReedSolomonDecode(RSField field, std::span<uint8_t> codeword, int numECC, std::span<const int> erasures)
+{
+	return UEC(rs::decode(GetGF2n(field), codeword, numECC, erasures), numECC);
+}
+
+std::optional<double> ReedSolomonDecode(RSField field, std::span<int> codeword, int numECC, std::span<const int> erasures)
+{
+	// The number of erasures may at most be numECC - 2 because leaving less than 2 parity symbols for error correction would make it
+	// impossible to correct or even detect any errors. See also ISO/IEC 24728-2006 5.7.2
+	if (Size(erasures) > numECC - 2)
+		return {};
+
+#if ZXING_ENABLE_PDF417
+	if (field == RSField::PDF417)
+		return UEC(rs::decode(GetGFPDF417(), codeword, numECC, erasures), numECC);
+	else
+#endif
+		return UEC(rs::decode(GetGF2n(field), codeword, numECC, erasures), numECC);
+}
+#endif
+
+#ifdef ZXING_WRITERS
+void ReedSolomonEncode(RSField field, std::span<const uint8_t> data, std::span<uint8_t> parity)
+{
+	rs::encode(GetGF2n(field), data, parity);
+}
+
+void ReedSolomonEncode(RSField field, std::span<uint8_t> codeword, int numECC)
+{
+	rs::encode_inplace(GetGF2n(field), codeword, numECC);
+}
+
+void ReedSolomonEncode(RSField field, std::span<int> codeword, int numECC)
+{
+#if ZXING_ENABLE_PDF417
+	if (field == RSField::PDF417)
+		return rs::encode_inplace(GetGFPDF417(), codeword, numECC);
+	else
+#endif
+		rs::encode_inplace(GetGF2n(field), codeword, numECC);
+}
+#endif
+
+} // namespace ZXing

package/cpp/zxing-core/core/src/ReedSolomon.h

@@ -0,0 +1,66 @@
+// Copyright 2026 Axel Waggershauser
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <span>
+#include <stdexcept>
+#include <string>
+
+namespace ZXing {
+
+enum class RSField
+{
+	Aztec4,
+	Aztec6,
+	Aztec8,
+	Aztec10,
+	Aztec12,
+	DataMatrix,
+	MaxiCode,
+	PDF417,
+	QRCode
+};
+
+inline RSField GF2nAztec(int wordSize)
+{
+	switch (wordSize) {
+	case 4: return RSField::Aztec4;
+	case 6: return RSField::Aztec6;
+	case 8: return RSField::Aztec8;
+	case 10: return RSField::Aztec10;
+	case 12: return RSField::Aztec12;
+	default: throw std::invalid_argument("Unsupported word size " + std::to_string(wordSize));
+	}
+}
+
+/**
+ * @brief ReedSolomonDecode fixes errors in a codeword containing both data and parity symbols.
+ *
+ * @param codeword data and error-correction/parity symbols; corrected in place on success
+ * @param numECC number of error-correction/parity symbols
+ * @param erasures positions of known erasures in the codeword
+ * @return optional unused error correction in the range [0, 1] if codeword errors could successfully be fixed (or there have not been
+ * any), std::nullopt otherwise
+ */
+std::optional<double> ReedSolomonDecode(RSField field, std::span<int> codeword, int numECC, std::span<const int> erasures = {});
+
+std::optional<double> ReedSolomonDecode(RSField field, std::span<uint8_t> codeword, int numECC,
+										std::span<const int> erasures = {});
+
+/**
+ * @brief ReedSolomonEncode generates error correction symbols for the given data symbols.
+ *
+ * @param field The Galois field to use for encoding.
+ * @param data The input data symbols.
+ * @param parity The output buffer for the generated error correction symbols.
+ */
+void ReedSolomonEncode(RSField field, std::span<const uint8_t> data, std::span<uint8_t> parity);
+
+/// @brief ReedSolomonEncode replaces the last numECC symbols in codeword with parity symbols
+void ReedSolomonEncode(RSField field, std::span<uint8_t> codeword, int numECC);
+void ReedSolomonEncode(RSField field, std::span<int> codeword, int numECC);
+
+} // ZXing

package/cpp/zxing-core/core/src/RegressionLine.h

@@ -0,0 +1,161 @@
+/*
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Point.h"
+#include "ZXAlgorithms.h"
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+
+#ifdef PRINT_DEBUG
+#include <cstdio>
+#endif
+
+namespace ZXing {
+
+class RegressionLine
+{
+protected:
+	std::vector<PointF> _points;
+	PointF _directionInward;
+	PointF::value_t a = NAN, b = NAN, c = NAN;
+
+	friend PointF intersect(const RegressionLine& l1, const RegressionLine& l2);
+
+	template<typename T> bool evaluate(const PointT<T>* begin, const PointT<T>* end)
+	{
+		auto mean = Reduce(begin, end, PointF()) / std::distance(begin, end);
+		PointF::value_t sumXX = 0, sumYY = 0, sumXY = 0;
+		for (auto p = begin; p != end; ++p) {
+			auto d = *p - mean;
+			sumXX += d.x * d.x;
+			sumYY += d.y * d.y;
+			sumXY += d.x * d.y;
+		}
+		if (sumYY >= sumXX) {
+			auto l = std::sqrt(sumYY * sumYY + sumXY * sumXY);
+			a = +sumYY / l;
+			b = -sumXY / l;
+		} else {
+			auto l = std::sqrt(sumXX * sumXX + sumXY * sumXY);
+			a = +sumXY / l;
+			b = -sumXX / l;
+		}
+		if (dot(_directionInward, normal()) < 0) {
+			a = -a;
+			b = -b;
+		}
+		c = dot(normal(), mean); // (a*mean.x + b*mean.y);
+		return dot(_directionInward, normal()) > 0.5f; // angle between original and new direction is at most 60 degree
+	}
+
+	template <typename T> bool evaluate(const std::vector<PointT<T>>& points) { return evaluate(&points.front(), &points.back() + 1); }
+
+	template <typename T> static auto distance(PointT<T> a, PointT<T> b) { return ZXing::distance(a, b); }
+
+public:
+	RegressionLine() { _points.reserve(16); } // arbitrary but plausible start size (tiny performance improvement)
+
+	template<typename T> RegressionLine(PointT<T> a, PointT<T> b)
+	{
+		evaluate(std::vector{a, b});
+	}
+
+	template<typename T> RegressionLine(const PointT<T>* b, const PointT<T>* e)
+	{
+		evaluate(b, e);
+	}
+
+	const auto& points() const { return _points; }
+	int length() const { return _points.size() >= 2 ? int(distance(_points.front(), _points.back())) : 0; }
+	bool isValid() const { return !std::isnan(a); }
+	PointF normal() const { return isValid() ? PointF(a, b) : _directionInward; }
+	auto signedDistance(PointF p) const { return dot(normal(), p) - c; }
+	template <typename T> auto distance(PointT<T> p) const { return std::abs(signedDistance(PointF(p))); }
+	PointF project(PointF p) const { return p - signedDistance(p) * normal(); }
+	PointF centroid() const { return Reduce(_points) / _points.size(); }
+
+	void reset()
+	{
+		_points.clear();
+		_directionInward = {};
+		a = b = c = NAN;
+	}
+
+	void add(PointF p) {
+		assert(_directionInward != PointF());
+		_points.push_back(p);
+		if (_points.size() == 1)
+			c = dot(normal(), p);
+	}
+
+	void pop_back() { _points.pop_back(); }
+	void pop_front()
+	{
+		std::rotate(_points.begin(), _points.begin() + 1, _points.end());
+		_points.pop_back();
+	}
+
+	void setDirectionInward(PointF d) { _directionInward = normalized(d); }
+
+	bool evaluate(double maxSignedDist = -1, bool updatePoints = false)
+	{
+		bool ret = evaluate(_points);
+		if (maxSignedDist > 0) {
+			auto points = _points;
+			while (true) {
+				auto old_points_size = points.size();
+				// remove points that are further 'inside' than maxSignedDist or further 'outside' than 2 x maxSignedDist
+				std::erase_if(points, [this, maxSignedDist](auto p) {
+					auto sd = this->signedDistance(p);
+					return sd > maxSignedDist || sd < -2 * maxSignedDist;
+				});
+				// if we threw away too many points, something is off with the line to begin with
+				if (points.size() < old_points_size / 2 || points.size() < 2)
+					return false;
+				if (old_points_size == points.size())
+					break;
+#ifdef PRINT_DEBUG
+				printf("removed %zu points -> %zu remaining\n", old_points_size - points.size(), points.size());
+				fflush(stdout);
+#endif
+				ret = evaluate(points);
+			}
+
+			if (updatePoints)
+				_points = std::move(points);
+		}
+		return ret;
+	}
+
+	bool isHighRes() const
+	{
+		PointF min = _points.front(), max = _points.front();
+		for (auto p : _points) {
+			UpdateMinMax(min.x, max.x, p.x);
+			UpdateMinMax(min.y, max.y, p.y);
+		}
+		auto diff  = max - min;
+		auto len   = maxAbsComponent(diff);
+		auto steps = std::min(std::abs(diff.x), std::abs(diff.y));
+		// due to aliasing we get bad extrapolations if the line is short and too close to vertical/horizontal
+		return steps > 2 || len > 50;
+	}
+};
+
+inline PointF intersect(const RegressionLine& l1, const RegressionLine& l2)
+{
+	assert(l1.isValid() && l2.isValid());
+	auto d = l1.a * l2.b - l1.b * l2.a;
+	auto x = (l1.c * l2.b - l1.b * l2.c) / d;
+	auto y = (l1.a * l2.c - l1.c * l2.a) / d;
+	return {x, y};
+}
+
+} // ZXing
+

package/cpp/zxing-core/core/src/ResultPoint.cpp

@@ -0,0 +1,20 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ResultPoint.h"
+
+#include <cmath>
+
+namespace ZXing {
+
+float ResultPoint::Distance(int aX, int aY, int bX, int bY)
+{
+	auto dx = static_cast<float>(aX - bX);
+	auto dy = static_cast<float>(aY - bY);
+	return std::sqrt(dx * dx + dy * dy);
+}
+
+} // ZXing

package/cpp/zxing-core/core/src/ResultPoint.h

@@ -0,0 +1,35 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Point.h"
+
+namespace ZXing {
+
+/**
+* <p>Encapsulates a point of interest in an image containing a barcode. Typically, this
+* would be the location of a finder pattern or the corner of the barcode, for example.</p>
+*
+* @author Sean Owen
+*/
+class ResultPoint : public PointF
+{
+public:
+	ResultPoint() = default;
+	ResultPoint(float x, float y) : PointF(x, y) {}
+	ResultPoint(int x, int y) : PointF(x, y) {}
+	template <typename T> ResultPoint(PointT<T> p) : PointF(p) {}
+
+	float x() const { return static_cast<float>(PointF::x); }
+	float y() const { return static_cast<float>(PointF::y); }
+
+	void set(float x, float y) { *this = PointF(x, y); }
+
+	static float Distance(int aX, int aY, int bX, int bY);
+};
+
+} // ZXing

package/cpp/zxing-core/core/src/StdGenerator.h

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2026 Axel Waggershauser
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <version>
+
+#if defined(__cpp_lib_generator)
+
+#include <generator>
+
+#else
+
+#include <concepts>
+#include <coroutine>
+#include <optional>
+#include <utility>
+#include <iterator>
+
+namespace std {
+
+template <std::movable T>
+class generator
+{
+public:
+	struct promise_type
+	{
+		std::optional<T> value_;
+
+		generator get_return_object() noexcept { return generator{handle_type::from_promise(*this)}; }
+
+		static std::suspend_always initial_suspend() noexcept { return {}; }
+		static std::suspend_always final_suspend() noexcept { return {}; }
+
+		std::suspend_always yield_value(T&& value) noexcept
+		{
+			value_ = std::move(value);
+			return {};
+		}
+
+		static void return_void() noexcept {}
+		// Disallow co_await in generator coroutines.
+		void await_transform() = delete;
+		[[noreturn]] static void unhandled_exception() { throw; }
+	};
+
+	using handle_type = std::coroutine_handle<promise_type>;
+
+	generator() noexcept = default;
+	explicit generator(handle_type h) noexcept : h_(h) {}
+	~generator()
+	{
+		if (h_)
+			h_.destroy();
+	}
+
+	generator(generator&& other) noexcept : h_(other.h_) { other.h_ = nullptr; }
+
+	generator& operator=(generator&& other) noexcept
+	{
+		if (this != &other) {
+			if (h_)
+				h_.destroy();
+			h_ = other.h_;
+			other.h_ = nullptr;
+		}
+		return *this;
+	}
+
+	generator(const generator&) = delete;
+	generator& operator=(const generator&) = delete;
+
+	class iterator
+	{
+	public:
+		void operator++() { h_.resume(); }
+		T&& operator*() const noexcept { return std::move(*h_.promise().value_); }
+		bool operator==(std::default_sentinel_t) const noexcept { return !h_ || h_.done(); }
+
+		explicit iterator(handle_type h) : h_(h) {}
+
+	private:
+		handle_type h_ = nullptr;
+	};
+
+	iterator begin()
+	{
+		if (h_)
+			h_.resume();
+		return iterator{h_};
+	}
+
+	std::default_sentinel_t end() noexcept { return {}; }
+
+private:
+	handle_type h_;
+};
+
+} // namespace std
+
+#endif // __cpp_lib_generator
+
+/*
+usage example:
+
+template <std::integral T>
+std::generator<T> range(T first, const T last)
+{
+	while (first < last)
+		co_yield first++;
+}
+
+int main()
+{
+	for (const char i : range(65, 91))
+		std::print("{} ", i);
+	std::println("");
+}
+*/

package/cpp/zxing-core/core/src/StdPrint.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2026 Axel Waggershauser
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <version>
+
+#if defined(__cpp_lib_print) && __cpp_lib_print >= 202207L
+
+#include <print>
+
+#else
+
+#include <format>
+#include <cstdio>
+#include <utility>
+
+namespace std {
+
+template <class... Args>
+inline void print(std::format_string<Args...> fmt, Args&&... args)
+{
+	auto s = std::format(fmt, std::forward<Args>(args)...);
+	std::fwrite(s.data(), 1, s.size(), stdout);
+}
+
+template <class... Args>
+inline void println(std::format_string<Args...> fmt, Args&&... args)
+{
+	std::print(fmt, std::forward<Args>(args)...);
+	std::fputc('\n', stdout);
+}
+
+} // namespace std
+
+#endif

package/cpp/zxing-core/core/src/StdScope.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2026 Axel Waggershauser
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+// idea from <experimental/scope> (library fundamentals TS v3)
+
+#include <type_traits>
+#include <utility>
+
+namespace std {
+
+template <class F>
+class scope_exit
+{
+public:
+	explicit scope_exit(F&& f) noexcept(std::is_nothrow_move_constructible_v<F>) : func_(std::forward<F>(f)), active_(true) {}
+
+	scope_exit(scope_exit&& other) noexcept(std::is_nothrow_move_constructible_v<F>)
+		: func_(std::move(other.func_)), active_(std::exchange(other.active_, false))
+	{}
+
+	scope_exit(const scope_exit&) = delete;
+	scope_exit& operator=(const scope_exit&) = delete;
+	scope_exit& operator=(scope_exit&&) = delete;
+
+	~scope_exit() noexcept(noexcept(std::declval<F&>()()))
+	{
+		if (active_)
+			func_();
+	}
+
+	void release() noexcept { active_ = false; }
+
+private:
+	F func_;
+	bool active_;
+};
+
+template <class F>
+scope_exit(F) -> scope_exit<F>;
+
+} // namespace std
+
+/**
+ * The SCOPE_EXIT macro is eliminating the need to give the object a name.
+ * Example usage:
+ *   SCOPE_EXIT([]{ printf("exiting scope"); });
+ */
+
+#define SCOPE_EXIT_CAT2(x, y) x##y
+#define SCOPE_EXIT_CAT(x, y) SCOPE_EXIT_CAT2(x, y)
+#define SCOPE_EXIT const auto SCOPE_EXIT_CAT(scopeExit_, __COUNTER__) = std::scope_exit

package/cpp/zxing-core/core/src/StructuredAppend.h

@@ -0,0 +1,19 @@
+/*
+* Copyright 2021 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+
+namespace ZXing {
+
+struct StructuredAppendInfo
+{
+	int index = -1;
+	int count = -1;
+	std::string id;
+};
+
+} // ZXing

package/cpp/zxing-core/core/src/SymbologyIdentifier.h

@@ -0,0 +1,29 @@
+/*
+* Copyright 2026 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ZXAlgorithms.h"
+
+#include <string>
+
+namespace ZXing {
+
+enum class AIFlag : char { None, GS1, AIM };
+
+struct SymbologyIdentifier
+{
+	char code = 0, modifier = 0;
+	signed char eciModifierOffset = 0;
+	AIFlag aiFlag = AIFlag::None;
+
+	std::string toString(bool hasECI = false) const
+	{
+		int modVal = (modifier >= 'A' ? modifier - 'A' + 10 : modifier - '0') + eciModifierOffset * hasECI;
+		return code ? StrCat(']', code, static_cast<char>((modVal >= 10 ? 'A' - 10 : '0') + modVal)) : std::string();
+	}
+};
+
+} // ZXing

package/cpp/zxing-core/core/src/TextDecoder.cpp

@@ -0,0 +1,59 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2022 gitlost
+* Copyright 2025 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "TextDecoder.h"
+
+#include "ZXAlgorithms.h"
+#include "libzueci/zueci.h"
+
+#include <cassert>
+#include <stdexcept>
+#include <cstdio>
+
+namespace ZXing {
+
+std::string BytesToUtf8(ByteView bytes, ECI eci)
+{
+#if 0
+	(void)eci;
+	return std::string(bytes.begin(), bytes.end());
+#else
+	constexpr unsigned int replacement = 0xFFFD;
+	constexpr unsigned int flags = ZUECI_FLAG_SB_STRAIGHT_THRU | ZUECI_FLAG_SJIS_STRAIGHT_THRU;
+	int utf8_len;
+
+	if (eci == ECI::Unknown)
+		eci = ECI::Binary;
+
+	int error_number = zueci_dest_len_utf8(ToInt(eci), bytes.data(), Size(bytes), replacement, flags, &utf8_len);
+	if (error_number >= ZUECI_ERROR) {
+#ifdef PRINT_DEBUG
+		fprintf(stderr, "zueci_dest_len_utf8 error: %d\n", error_number);
+#endif
+		// throw FormatError("Invalid UTF-8 data");
+		return {};
+	}
+
+	std::string utf8(utf8_len, 0);
+
+	error_number = zueci_eci_to_utf8(ToInt(eci), bytes.data(), Size(bytes), replacement, flags,
+									 reinterpret_cast<uint8_t*>(utf8.data()), &utf8_len);
+	if (error_number >= ZUECI_ERROR) {
+#ifdef PRINT_DEBUG
+		fprintf(stderr, "zueci_eci_to_utf8 error: %d\n", error_number);
+#endif
+		// throw FormatError("Invalid UTF-8 data");
+		return {};
+	}
+
+	assert(Size(utf8) == utf8_len);
+
+	return utf8;
+#endif
+}
+
+} // ZXing