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

package/cpp/zxing-core/core/Version.h.in

@@ -0,0 +1,28 @@
+/*
+* Copyright 2019 Nu-book Inc.
+* Copyright 2023 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#cmakedefine ZXING_READERS
+#cmakedefine ZXING_WRITERS
+
+#cmakedefine01 ZXING_ENABLE_1D
+#cmakedefine01 ZXING_ENABLE_AZTEC
+#cmakedefine01 ZXING_ENABLE_DATAMATRIX
+#cmakedefine01 ZXING_ENABLE_MAXICODE
+#cmakedefine01 ZXING_ENABLE_PDF417
+#cmakedefine01 ZXING_ENABLE_QRCODE
+
+#cmakedefine ZXING_EXPERIMENTAL_API
+#cmakedefine ZXING_USE_ZINT
+
+// Version numbering
+#define ZXING_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
+#define ZXING_VERSION_MINOR @PROJECT_VERSION_MINOR@
+#define ZXING_VERSION_PATCH @PROJECT_VERSION_PATCH@
+#define ZXING_VERSION_SUFFIX "@ZXING_VERSION_SUFFIX@"
+
+#define ZXING_VERSION_STR "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@@ZXING_VERSION_SUFFIX@"

package/cpp/zxing-core/core/ZXingConfig.cmake.in

@@ -0,0 +1,9 @@
+@PACKAGE_INIT@
+include("${CMAKE_CURRENT_LIST_DIR}/ZXingTargets.cmake")
+
+# this does not work: add_library(ZXing::Core ALIAS ZXing::ZXing)
+# this is a workaround available since 3.11 :
+if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.11 AND NOT TARGET ZXing::Core)
+    add_library(ZXing::Core INTERFACE IMPORTED)
+    target_link_libraries(ZXing::Core INTERFACE ZXing::ZXing)
+endif()

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

@@ -0,0 +1,255 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "Barcode.h"
+
+#include "BarcodeData.h"
+#include "JSON.h"
+#include "ZXAlgorithms.h"
+
+#include "BitMatrix.h"
+
+#include <cmath>
+#include <list>
+#include <map>
+#include <numbers>
+#include <utility>
+
+#ifdef ZXING_USE_ZINT
+#include <zint.h>
+void zint_symbol_deleter::operator()(zint_symbol* p) const noexcept
+{
+	ZBarcode_Delete(p);
+}
+#endif
+
+namespace ZXing {
+
+Barcode::Barcode() : d(std::make_shared<Data>()) {}
+
+Barcode::Barcode(Data&& data) : d(std::make_shared<Data>(std::move(data))) {}
+
+bool Barcode::isValid() const
+{
+	return d->isValid();
+}
+
+const Error& Barcode::error() const
+{
+	return d->error;
+}
+
+BarcodeFormat Barcode::format() const
+{
+	return d->format;
+}
+
+const Position& Barcode::position() const
+{
+	return d->position;
+}
+
+const std::vector<uint8_t>& Barcode::bytes() const
+{
+	return d->content.bytes;
+}
+
+std::vector<uint8_t> Barcode::bytesECI() const
+{
+	return d->content.bytesECI();
+}
+
+std::string Barcode::text(TextMode mode) const
+{
+	return d->content.text(mode);
+}
+
+std::string Barcode::text() const
+{
+	return text(d->defaultTextMode);
+}
+
+ContentType Barcode::contentType() const
+{
+	return d->content.type();
+}
+
+bool Barcode::hasECI() const
+{
+	return d->content.hasECI;
+}
+
+int Barcode::orientation() const
+{
+	return narrow_cast<int>(std::lround(d->position.orientation() * 180 / std::numbers::pi));
+}
+
+bool Barcode::isMirrored() const
+{
+	return d->isMirrored;
+}
+
+bool Barcode::isInverted() const
+{
+	return d->isInverted;
+}
+
+std::string Barcode::symbologyIdentifier() const
+{
+	return d->content.symbology.toString();
+}
+
+int Barcode::sequenceSize() const
+{
+	return d->sai.count;
+}
+
+int Barcode::sequenceIndex() const
+{
+	return d->sai.index;
+}
+
+std::string Barcode::sequenceId() const
+{
+	return d->sai.id;
+}
+
+int Barcode::lineCount() const
+{
+	return d->lineCount;
+}
+
+Barcode& Barcode::setReaderOptions(const ReaderOptions& opts)
+{
+	if (opts.characterSet() != CharacterSet::Unknown)
+		d->content.defaultCharset = opts.characterSet();
+	d->defaultTextMode = opts.textMode();
+	return *this;
+}
+
+ImageView Barcode::symbol() const
+{
+	return !d->symbol.empty() ? ImageView{d->symbol.row(0).begin(), d->symbol.width(), d->symbol.height(), ImageFormat::Lum}
+							  : ImageView{};
+}
+
+#if defined(ZXING_USE_ZINT) && defined(ZXING_EXPERIMENTAL_API)
+zint_symbol* Barcode::zint() const
+{
+	return d->zint.get();
+}
+#endif
+
+std::string Barcode::extra(std::string_view key) const
+{
+	if (key == "ALL") {
+		if (format() == BarcodeFormat::None)
+			return {};
+		auto res =
+			StrCat("{", JsonProp("Text", text(TextMode::Plain)), JsonProp("HRI", text(TextMode::HRI)),
+				   JsonProp("TextECI", text(TextMode::ECI)), JsonProp("Bytes", text(TextMode::Hex)),
+				   JsonProp("Identifier", symbologyIdentifier()), JsonProp("Format", Name(format())),
+				   JsonProp("Symbology", Name(Symbology(format()))), JsonProp("ContentType", isValid() ? ToString(contentType()) : ""),
+				   JsonProp("Position", ToString(position())), JsonProp("HasECI", hasECI()), JsonProp("IsMirrored", isMirrored()),
+				   JsonProp("IsInverted", isInverted()), d->extra, JsonProp("Error", ToString(error())));
+		res.back() = '}';
+		return res;
+	}
+	return d->extra.empty() ? ""
+		   : key.empty()    ? StrCat("{", std::string_view(d->extra).substr(0, d->extra.size() - 1), "}") // remove trailing ','
+							: JsonGet<std::string>(d->extra, key).value_or(""); // make sure JsonUnescape() is called
+}
+
+bool Barcode::operator==(const Barcode& o) const
+{
+	return *d == *o.d;
+}
+
+bool BarcodeData::operator==(const BarcodeData& o) const
+{
+	if (format != o.format)
+		return false;
+
+	// handle MatrixCodes first
+	if (!(format & BarcodeFormat::AllLinear)) {
+		if (content.bytes != o.content.bytes)
+			return false;
+
+		// At this point both are valid with the same content or both are in error.
+		// Treat them as equal if their positions are about the same (center of one is inside the other).
+		return IsInside(Center(o.position), position);
+	}
+
+	if (content.bytes != o.content.bytes || error != o.error || orientation() != o.orientation())
+		return false;
+
+	if (lineCount > 1 && o.lineCount > 1)
+		return HaveIntersectingBoundingBoxes(o.position, position);
+
+	// the following code is only meant for this or other lineCount == 1
+	assert(lineCount == 1 || o.lineCount == 1);
+
+	// sl == single line, ml = multi line
+	const auto& sl = lineCount == 1 ? *this : o;
+	const auto& ml = lineCount == 1 ? o : *this;
+
+	// If one line is less than half the length of the other away from the
+	// latter, we consider it to belong to the same symbol.
+	// Additionally, both need to have roughly the same length (see #367).
+	auto dTop = maxAbsComponent(ml.position.topLeft() - sl.position.topLeft());
+	auto dBot = maxAbsComponent(ml.position.bottomLeft() - sl.position.topLeft());
+	auto slLength = maxAbsComponent(sl.position.topLeft() - sl.position.bottomRight());
+	bool isHorizontal = sl.position.topLeft().y == sl.position.bottomRight().y;
+	// Measure the multi line length in the same direction as the single line one (not diagonally)
+	// to make sure overly tall symbols don't get segmented (see #769).
+	auto mlLength = isHorizontal ? std::abs(ml.position.topLeft().x - ml.position.bottomRight().x)
+								 : std::abs(ml.position.topLeft().y - ml.position.bottomRight().y);
+
+	return std::min(dTop, dBot) < slLength / 2 && std::abs(slLength - mlLength) < slLength / 5;
+}
+
+Barcode MergeStructuredAppendSequence(const Barcodes& barcodes)
+{
+	if (barcodes.empty())
+		return {};
+
+	std::list<Barcode> allBarcodes(barcodes.begin(), barcodes.end());
+	allBarcodes.sort([](const Barcode& r1, const Barcode& r2) { return r1.sequenceIndex() < r2.sequenceIndex(); });
+
+	Barcode res = allBarcodes.front();
+	for (auto i = std::next(allBarcodes.begin()); i != allBarcodes.end(); ++i)
+		res.d->content.append(i->d->content);
+
+	res.d->position = {};
+	res.d->sai.index = -1;
+
+	if (allBarcodes.back().sequenceSize() != Size(allBarcodes) ||
+		!std::all_of(allBarcodes.begin(), allBarcodes.end(),
+					 [&](Barcode& it) { return it.sequenceId() == allBarcodes.front().sequenceId(); }))
+		res.d->error = FormatError("sequenceIDs not matching during structured append sequence merging");
+
+	return res;
+}
+
+Barcodes MergeStructuredAppendSequences(const Barcodes& barcodes)
+{
+	std::map<std::string, Barcodes> sas;
+	for (auto& barcode : barcodes) {
+		if (barcode.isPartOfSequence())
+			sas[barcode.sequenceId()].push_back(barcode);
+	}
+
+	Barcodes res;
+	for (auto& [id, seq] : sas) {
+		auto barcode = MergeStructuredAppendSequence(seq);
+		if (barcode.isValid())
+			res.push_back(std::move(barcode));
+	}
+
+	return res;
+}
+
+} // namespace ZXing

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

@@ -0,0 +1,191 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BarcodeFormat.h"
+#include "ContentType.h"
+#include "Error.h"
+#include "ImageView.h"
+#include "Quadrilateral.h"
+#include "ReaderOptions.h" // for TextMode
+#include "Version.h" // ZXING_... macros
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#ifdef ZXING_USE_ZINT
+extern "C" struct zint_symbol;
+#endif
+
+namespace ZXing {
+
+class CreatorOptions;
+class ReaderOptions;
+class WriterOptions;
+class Barcode;
+struct BarcodeData;
+
+using Position = QuadrilateralI;
+using Barcodes = std::vector<Barcode>;
+
+/**
+ * @brief String keys for the extra() metadata of Barcode. The values depend on the symbology and may not be present for all barcodes.
+ */
+namespace BarcodeExtra {
+	#define ZX_EXTRA(NAME) static constexpr auto NAME = #NAME
+	ZX_EXTRA(DataMask); ///< QRCodes
+	ZX_EXTRA(Version);  ///< QRCodes, DataMatrix, MaxiCode (e.g. "12x12" for DataMatrix)
+	ZX_EXTRA(EanAddOn); ///< The EAN/UPC add-on content if detected
+	ZX_EXTRA(ECLevel);  ///< Error correction level (e.g. "L", "M", "Q", "H" for QRCode)
+	ZX_EXTRA(UEC);      ///< Unused error correction margin in the range [0, 1]
+	ZX_EXTRA(UPCE);     ///< The original (non-normalized) UPC-E code if UPC-E is detected
+	ZX_EXTRA(ReaderInit);
+	#undef ZX_EXTRA
+} // namespace BarcodeExtra
+
+/**
+ * @brief The Barcode class encapsulates a decoded or created barcode symbol.
+ *
+ * Barcode represents a decoded or created barcode symbol, providing access to its content, format,
+ * position, and other metadata. It serves as the primary interface for working with barcodes in the library.
+ *
+ * Barcode objects are obtained from the ReadBarcodes function when scanning an image, or from the
+ * CreateBarcodeFrom... functions when generating a new barcode. To convert a Barcode to an image or SVG,
+ * use the WriteBarcodeTo... functions.
+ *
+ * @see ReadBarcodes, CreateBarcodeFromText, CreateBarcodeFromBytes, WriteBarcodeToImage, WriteBarcodeToSVG
+ */
+class Barcode
+{
+	using Data = BarcodeData;
+
+	std::shared_ptr<Data> d;
+
+	Barcode& setReaderOptions(const ReaderOptions& opts);
+
+	friend Barcode MergeStructuredAppendSequence(const Barcodes&);
+	friend Barcodes ReadBarcodes(const ImageView&, const ReaderOptions&);
+	friend Barcode CreateBarcode(const void*, int, int, const CreatorOptions&);
+	friend Image WriteBarcodeToImage(const Barcode&, const WriterOptions&);
+	friend std::string WriteBarcodeToSVG(const Barcode&, const WriterOptions&);
+
+public:
+	Barcode();
+	Barcode(Barcode::Data&& data);
+
+	/// Returns whether the barcode is valid, i.e. it contains a successfully decoded or created symbol.
+	bool isValid() const;
+
+	/// Returns the error associated with the barcode, if any.
+	const Error& error() const;
+
+	/// Returns the BarcodeFormat of the barcode.
+	BarcodeFormat format() const;
+
+	/// Returns the symbology of the barcode format (e.g. EAN/UPC for EAN13, EAN8, UPCA, etc.).
+	BarcodeFormat symbology() const { return Symbology(format()); }
+
+	/// Returns the raw / standard content without any modifications like character set conversions.
+	const std::vector<uint8_t>& bytes() const;
+
+	/// Returns the raw / standard content following the ECI protocol.
+	std::vector<uint8_t> bytesECI() const;
+
+	/// Returns the bytes() content rendered to unicode/utf8 text according to specified TextMode.
+	std::string text(TextMode mode) const;
+
+	/// Returns the bytes() content rendered to unicode/utf8 text according to the TextMode set in the ReaderOptions.
+	std::string text() const;
+
+	/// Returns the content type, giving a hint to the type of content found (Text/Binary/GS1/etc.).
+	ContentType contentType() const;
+
+	/// Returns whether or not an ECI tag was found.
+	bool hasECI() const;
+
+	/// Returns the position of the barcode in the image as a quadrilateral of 4 points (topLeft, topRight, bottomRight,
+	/// bottomLeft).
+	const Position& position() const;
+
+	/// Returns the orientation of the barcode in degrees, see also Position::orientation()
+	int orientation() const;
+
+	/// Returns whether the symbol is mirrored (currently only supported by QRCode and DataMatrix).
+	bool isMirrored() const;
+	/// Returns whether the symbol is inverted / has reversed reflectance (see ReaderOptions::tryInvert).
+	bool isInverted() const;
+
+	/// Returns the symbology identifier "]cm" where "c" is symbology code character, "m" the modifier.
+	std::string symbologyIdentifier() const;
+
+	/// @brief Returns the number of symbols in a structured append sequence.
+	///
+	/// If this is not part of a structured append sequence, the returned value is -1.
+	/// If it is a structured append symbol but the total number of symbols is unknown, the
+	/// returned value is 0 (see PDF417 if optional "Segment Count" not given).
+	int sequenceSize() const;
+
+	/// Returns the 0-based index of this symbol in a structured append sequence.
+	int sequenceIndex() const;
+
+	/// @brief Returns the sequenceId to check if a set of symbols belongs to the same structured append sequence.
+	///
+	/// If the symbology does not support this feature, the returned value is empty (see MaxiCode).
+	/// For QR Code, this is the parity integer converted to a string.
+	/// For PDF417 and DataMatrix, this is the "fileId".
+	std::string sequenceId() const;
+
+	/// Returns whether this symbol is the last in a structured append sequence.
+	bool isLastInSequence() const { return sequenceSize() == sequenceIndex() + 1; }
+
+	/// Returns whether this symbol is part of a structured append sequence.
+	bool isPartOfSequence() const { return sequenceSize() > -1 && sequenceIndex() > -1; }
+
+	/// Returns how many lines have been detected with this code (applies only to linear symbologies).
+	int lineCount() const;
+
+	/// Returns the bit matrix of the symbol as an ImageView.
+	ImageView symbol() const;
+
+	/// @brief Retrieve supplementary metadata associated with this barcode.
+	///
+	/// Returns a string containing additional and symbology specific information. In form of a JSON object
+	/// serialization. The optional parameter @p key can be used to retrieve a specific item only.
+	/// Key values are case insensitive. See BarcodeExtra namespace for valid keys.
+	/// If the key is not found or there is no info available, an empty string is returned.
+	std::string extra(std::string_view key = "") const;
+
+	/// @cond DEPRECATED
+	/// Returns the error correction level of the symbol (empty string if not applicable).
+	// [[deprecated ("use extra(BarcodeExtra::ECLevel) instead")]]
+	std::string ecLevel() const { return extra(BarcodeExtra::ECLevel); }
+
+	/// Returns whether the symbol is a Reader Initialisation/Programming symbol.
+	// [[deprecated ("use extra(BarcodeExtra::ReaderInit) instead")]]
+	bool readerInit() const { return !extra(BarcodeExtra::ReaderInit).empty(); }
+
+	/// Returns the version QRCode / DataMatrix / Aztec version or size.
+	// [[deprecated ("use extra(BarcodeExtra::Version) instead")]]
+	std::string version() const { return extra(BarcodeExtra::Version); }
+	/// @endcond
+
+#if defined(ZXING_USE_ZINT) && defined(ZXING_EXPERIMENTAL_API)
+	zint_symbol* zint() const;
+#endif
+
+	bool operator==(const Barcode& o) const;
+};
+
+/// Merge a list of Barcodes from one Structured Append sequence to a single barcode.
+Barcode MergeStructuredAppendSequence(const Barcodes& barcodes);
+
+/// Automatically merge all Structured Append sequences found in the given list of barcodes.
+Barcodes MergeStructuredAppendSequences(const Barcodes& barcodes);
+
+} // ZXing

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

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2026 Axel Waggershauser
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Barcode.h"
+#include "BitMatrix.h"
+#include "Content.h"
+#include "DecoderResult.h"
+#include "DetectorResult.h"
+#include "Error.h"
+#include "Quadrilateral.h"
+#include "ReaderOptions.h"
+#include "StructuredAppend.h"
+
+#include <memory>
+#include <mutex>
+#include <numbers>
+#include <string>
+#include <vector>
+
+#ifdef ZXING_USE_ZINT
+extern "C" struct zint_symbol;
+struct zint_symbol_deleter
+{
+	void operator()(zint_symbol* p) const noexcept;
+};
+using unique_zint_symbol = std::unique_ptr<zint_symbol, zint_symbol_deleter>;
+#else
+struct zint_symbol {};
+using unique_zint_symbol = std::unique_ptr<zint_symbol>;
+#endif
+
+namespace ZXing {
+
+struct BarcodeData
+{
+	Content content;
+	Error error = {};
+	Position position = {};
+	BarcodeFormat format = BarcodeFormat::None;
+	std::string extra = {};
+	StructuredAppendInfo sai = {};
+	BitMatrix symbol = {};
+#ifdef ZXING_USE_ZINT
+	unique_zint_symbol zint = {};
+	mutable std::unique_ptr<std::mutex> zintMutex = {};
+#endif
+	TextMode defaultTextMode = TextMode::HRI;
+	int lineCount = 0;
+	bool isMirrored = false;
+	bool isInverted = false;
+
+	bool operator==(const BarcodeData& other) const;
+
+	inline bool isValid() const { return format != BarcodeFormat::None && !content.bytes.empty() && !error; }
+
+	inline int orientation() const { return narrow_cast<int>(std::lround(position.orientation() * 180 / std::numbers::pi)); }
+};
+
+using BarcodesData = std::vector<BarcodeData>;
+
+inline BarcodeData LinearBarcode(BarcodeFormat format, const std::string& text, int y, int xStart, int xStop, SymbologyIdentifier si,
+                                 Error error = {}, std::string extra = {})
+{
+	return {.content = Content(ByteArray(text), si, CharacterSet::ISO8859_1),
+			.error = std::move(error),
+			.position = Line(y, xStart, xStop),
+			.format = format,
+			.extra = std::move(extra)};
+}
+
+inline BarcodeData MatrixBarcode(DecoderResult&& decodeResult, DetectorResult&& detectorResult, BarcodeFormat format)
+{
+	auto extra = std::move(decodeResult).json();
+	if (JsonFind(extra, BarcodeExtra::Version).empty() && decodeResult.versionNumber())
+		extra += JsonProp(BarcodeExtra::Version, std::to_string(decodeResult.versionNumber()));
+	if (JsonFind(extra, BarcodeExtra::ECLevel).empty() && !decodeResult.ecLevel().empty())
+		extra += JsonProp(BarcodeExtra::ECLevel, decodeResult.ecLevel());
+
+	extra += JsonProp(BarcodeExtra::ReaderInit, decodeResult.readerInit());
+
+	// the BitMatrix stores 'black'/foreground as 0xFF and 'white'/background as 0, but we
+	// want the ImageView returned by symbol() to be a standard luminance image (black == 0)
+	std::move(detectorResult).bits().flipAll();
+
+	return {.content = std::move(decodeResult).content(),
+			.error = std::move(decodeResult).error(),
+			.position = std::move(detectorResult).position(),
+			.format = format,
+			.extra = std::move(extra),
+			.sai = std::move(decodeResult).structuredAppend(),
+			.symbol = std::move(detectorResult).bits(),
+			.lineCount = decodeResult.lineCount(),
+			.isMirrored = decodeResult.isMirrored()};
+}
+
+} // namespace ZXing