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

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

@@ -0,0 +1,296 @@
+/*
+* Copyright 2023 siiky
+* Copyright 2023 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef _ZXING_C_H
+#define _ZXING_C_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+
+#include "ZXingCpp.h"
+
+typedef ZXing::Barcode ZXing_Barcode;
+typedef ZXing::Barcodes ZXing_Barcodes;
+typedef ZXing::ImageView ZXing_ImageView;
+typedef ZXing::Image ZXing_Image;
+typedef ZXing::ReaderOptions ZXing_ReaderOptions;
+typedef ZXing::CreatorOptions ZXing_CreatorOptions;
+typedef ZXing::WriterOptions ZXing_WriterOptions;
+
+extern "C"
+{
+#else
+
+typedef struct ZXing_Barcode ZXing_Barcode;
+typedef struct ZXing_Barcodes ZXing_Barcodes;
+typedef struct ZXing_ImageView ZXing_ImageView;
+typedef struct ZXing_Image ZXing_Image;
+typedef struct ZXing_ReaderOptions ZXing_ReaderOptions;
+typedef struct ZXing_CreatorOptions ZXing_CreatorOptions;
+typedef struct ZXing_WriterOptions ZXing_WriterOptions;
+
+#include "BarcodeFormat.h"
+
+#endif
+
+/*
+ * Memory management: All functions that return a non-const pointer (e.g. ZXing_Barcode_text(), ZXing_ImageView_new() or
+ * ZXing_ReadBarcodes()) transfer the memory ownership to the caller, who is responsible for freeing it.
+ * If the returned type is some ZXing_<X>* pointer and a corresponding ZXing_<X>_delete() function is available (e.g.
+ * ZXing_Barcode_delete() for ZXing_Barcode*), that function must be used to free the memory. For all other types (e.g. cha* or
+ * uint8_t*), ZXing_free() must be used. For functions that return a const pointer (e.g. ZXing_Barcodes_at()), the caller must not
+ * attempt to free the returned pointer, as it is static memory or the memory is owned by the parent object.
+ */
+
+/*
+ * MARK: - ImageView.h
+ */
+
+typedef enum {
+	ZXing_ImageFormat_None = 0,
+	ZXing_ImageFormat_Lum = 0x01000000,
+	ZXing_ImageFormat_LumA = 0x02000000,
+	ZXing_ImageFormat_RGB = 0x03000102,
+	ZXing_ImageFormat_BGR = 0x03020100,
+	ZXing_ImageFormat_RGBA = 0x04000102,
+	ZXing_ImageFormat_ARGB = 0x04010203,
+	ZXing_ImageFormat_BGRA = 0x04020100,
+	ZXing_ImageFormat_ABGR = 0x04030201,
+} ZXing_ImageFormat;
+
+ZXing_ImageView* ZXing_ImageView_new(const uint8_t* data, int width, int height, ZXing_ImageFormat format, int rowStride,
+									 int pixStride);
+ZXing_ImageView* ZXing_ImageView_new_checked(const uint8_t* data, int size, int width, int height, ZXing_ImageFormat format,
+											 int rowStride, int pixStride);
+void ZXing_ImageView_delete(ZXing_ImageView* iv);
+
+void ZXing_ImageView_crop(ZXing_ImageView* iv, int left, int top, int width, int height);
+void ZXing_ImageView_rotate(ZXing_ImageView* iv, int degree);
+
+void ZXing_Image_delete(ZXing_Image* img);
+
+const uint8_t* ZXing_Image_data(const ZXing_Image* img);
+int ZXing_Image_width(const ZXing_Image* img);
+int ZXing_Image_height(const ZXing_Image* img);
+ZXing_ImageFormat ZXing_Image_format(const ZXing_Image* img);
+
+/*
+ * MARK: - BarcodeFormat.h
+ */
+
+typedef enum
+{
+	ZXing_BarcodeFormat_Invalid = ZX_BCF_ID(0xff, 0xff), /* return value when BarcodeFormatsFromString() throws */
+#define X(NAME, SYM, VAR, FLAGS, ZINT, ENABLED, HRI) ZXing_BarcodeFormat_##NAME = ZX_BCF_ID(SYM, VAR),
+	ZX_BCF_LIST(X)
+#undef X
+} ZXing_BarcodeFormat;
+
+ZXing_BarcodeFormat ZXing_BarcodeFormatSymbology(ZXing_BarcodeFormat format);
+ZXing_BarcodeFormat ZXing_BarcodeFormatFromString(const char* str);
+char* ZXing_BarcodeFormatToString(ZXing_BarcodeFormat format);
+
+ZXing_BarcodeFormat* ZXing_BarcodeFormatsList(ZXing_BarcodeFormat filter, int* outCount);
+ZXing_BarcodeFormat* ZXing_BarcodeFormatsFromString(const char* str, int* outCount);
+char* ZXing_BarcodeFormatsToString(const ZXing_BarcodeFormat* formats, int count);
+
+
+/*
+ * MARK: - Barcode.h
+ */
+
+typedef enum
+{
+	ZXing_ContentType_Text,
+	ZXing_ContentType_Binary,
+	ZXing_ContentType_Mixed,
+	ZXing_ContentType_GS1,
+	ZXing_ContentType_ISO15434,
+	ZXing_ContentType_UnknownECI
+} ZXing_ContentType;
+
+typedef enum
+{
+	ZXing_ErrorType_None,
+	ZXing_ErrorType_Format,
+	ZXing_ErrorType_Checksum,
+	ZXing_ErrorType_Unsupported
+} ZXing_ErrorType;
+
+char* ZXing_ContentTypeToString(ZXing_ContentType type);
+
+typedef struct ZXing_PointI
+{
+	int x, y;
+} ZXing_PointI;
+
+typedef struct ZXing_Position
+{
+	ZXing_PointI topLeft, topRight, bottomRight, bottomLeft;
+} ZXing_Position;
+
+char* ZXing_PositionToString(ZXing_Position position);
+
+bool ZXing_Barcode_isValid(const ZXing_Barcode* barcode);
+ZXing_ErrorType ZXing_Barcode_errorType(const ZXing_Barcode* barcode);
+char* ZXing_Barcode_errorMsg(const ZXing_Barcode* barcode);
+ZXing_BarcodeFormat ZXing_Barcode_format(const ZXing_Barcode* barcode);
+ZXing_BarcodeFormat ZXing_Barcode_symbology(const ZXing_Barcode* barcode);
+ZXing_ContentType ZXing_Barcode_contentType(const ZXing_Barcode* barcode);
+uint8_t* ZXing_Barcode_bytes(const ZXing_Barcode* barcode, int* len);
+uint8_t* ZXing_Barcode_bytesECI(const ZXing_Barcode* barcode, int* len);
+char* ZXing_Barcode_text(const ZXing_Barcode* barcode);
+char* ZXing_Barcode_symbologyIdentifier(const ZXing_Barcode* barcode);
+ZXing_Position ZXing_Barcode_position(const ZXing_Barcode* barcode);
+int ZXing_Barcode_orientation(const ZXing_Barcode* barcode);
+bool ZXing_Barcode_hasECI(const ZXing_Barcode* barcode);
+bool ZXing_Barcode_isInverted(const ZXing_Barcode* barcode);
+bool ZXing_Barcode_isMirrored(const ZXing_Barcode* barcode);
+int ZXing_Barcode_lineCount(const ZXing_Barcode* barcode);
+int ZXing_Barcode_sequenceIndex(const ZXing_Barcode* barcode);
+int ZXing_Barcode_sequenceSize(const ZXing_Barcode* barcode);
+char* ZXing_Barcode_sequenceId(const ZXing_Barcode* barcode);
+char* ZXing_Barcode_extra(const ZXing_Barcode* barcode, const char* key); /* key can be NULL */
+
+void ZXing_Barcode_delete(ZXing_Barcode* barcode);
+void ZXing_Barcodes_delete(ZXing_Barcodes* barcodes);
+
+int ZXing_Barcodes_size(const ZXing_Barcodes* barcodes);
+const ZXing_Barcode* ZXing_Barcodes_at(const ZXing_Barcodes* barcodes, int i);
+ZXing_Barcode* ZXing_Barcodes_move(ZXing_Barcodes* barcodes, int i);
+
+/*
+ * MARK: - ReaderOptions.h
+ */
+
+typedef enum
+{
+	ZXing_Binarizer_LocalAverage,
+	ZXing_Binarizer_GlobalHistogram,
+	ZXing_Binarizer_FixedThreshold,
+	ZXing_Binarizer_BoolCast,
+} ZXing_Binarizer;
+
+typedef enum
+{
+	ZXing_EanAddOnSymbol_Ignore,
+	ZXing_EanAddOnSymbol_Read,
+	ZXing_EanAddOnSymbol_Require,
+} ZXing_EanAddOnSymbol;
+
+typedef enum
+{
+	ZXing_TextMode_Plain,
+	ZXing_TextMode_ECI,
+	ZXing_TextMode_HRI,
+	ZXing_TextMode_Escaped,
+	ZXing_TextMode_Hex,
+	ZXing_TextMode_HexECI,
+} ZXing_TextMode;
+
+ZXing_ReaderOptions* ZXing_ReaderOptions_new();
+void ZXing_ReaderOptions_delete(ZXing_ReaderOptions* opts);
+
+void ZXing_ReaderOptions_setTryHarder(ZXing_ReaderOptions* opts, bool tryHarder);
+void ZXing_ReaderOptions_setTryRotate(ZXing_ReaderOptions* opts, bool tryRotate);
+void ZXing_ReaderOptions_setTryInvert(ZXing_ReaderOptions* opts, bool tryInvert);
+void ZXing_ReaderOptions_setTryDownscale(ZXing_ReaderOptions* opts, bool tryDownscale);
+#ifdef ZXING_EXPERIMENTAL_API
+	void ZXing_ReaderOptions_setTryDenoise(ZXing_ReaderOptions* opts, bool tryDenoise);
+#endif
+void ZXing_ReaderOptions_setIsPure(ZXing_ReaderOptions* opts, bool isPure);
+void ZXing_ReaderOptions_setValidateOptionalChecksum(ZXing_ReaderOptions* opts, bool validateOptionalChecksum);
+void ZXing_ReaderOptions_setReturnErrors(ZXing_ReaderOptions* opts, bool returnErrors);
+void ZXing_ReaderOptions_setFormats(ZXing_ReaderOptions* opts, const ZXing_BarcodeFormat* formats, int count);
+void ZXing_ReaderOptions_setBinarizer(ZXing_ReaderOptions* opts, ZXing_Binarizer binarizer);
+void ZXing_ReaderOptions_setEanAddOnSymbol(ZXing_ReaderOptions* opts, ZXing_EanAddOnSymbol eanAddOnSymbol);
+void ZXing_ReaderOptions_setTextMode(ZXing_ReaderOptions* opts, ZXing_TextMode textMode);
+void ZXing_ReaderOptions_setMinLineCount(ZXing_ReaderOptions* opts, int n);
+void ZXing_ReaderOptions_setMaxNumberOfSymbols(ZXing_ReaderOptions* opts, int n);
+
+bool ZXing_ReaderOptions_getTryHarder(const ZXing_ReaderOptions* opts);
+bool ZXing_ReaderOptions_getTryRotate(const ZXing_ReaderOptions* opts);
+bool ZXing_ReaderOptions_getTryInvert(const ZXing_ReaderOptions* opts);
+bool ZXing_ReaderOptions_getTryDownscale(const ZXing_ReaderOptions* opts);
+#ifdef ZXING_EXPERIMENTAL_API
+	bool ZXing_ReaderOptions_getTryDenoise(const ZXing_ReaderOptions* opts);
+#endif
+bool ZXing_ReaderOptions_getIsPure(const ZXing_ReaderOptions* opts);
+bool ZXing_ReaderOptions_getValidateOptionalChecksum(const ZXing_ReaderOptions* opts);
+bool ZXing_ReaderOptions_getReturnErrors(const ZXing_ReaderOptions* opts);
+ZXing_BarcodeFormat* ZXing_ReaderOptions_getFormats(const ZXing_ReaderOptions* opts, int* outCount);
+ZXing_Binarizer ZXing_ReaderOptions_getBinarizer(const ZXing_ReaderOptions* opts);
+ZXing_EanAddOnSymbol ZXing_ReaderOptions_getEanAddOnSymbol(const ZXing_ReaderOptions* opts);
+ZXing_TextMode ZXing_ReaderOptions_getTextMode(const ZXing_ReaderOptions* opts);
+int ZXing_ReaderOptions_getMinLineCount(const ZXing_ReaderOptions* opts);
+int ZXing_ReaderOptions_getMaxNumberOfSymbols(const ZXing_ReaderOptions* opts);
+
+/*
+ * MARK: - ReadBarcode.h
+ */
+
+/**
+ * Note: opts is optional, i.e. it can be NULL, which will imply default settings.
+ * @return NULL in case of an error (e.g. invalid image or out of memory), otherwise a pointer to a ZXing_Barcodes object, which may
+ * contain zero or more barcodes. Freeing the empty ZXing_Barcodes object is optional.
+ */
+ZXing_Barcodes* ZXing_ReadBarcodes(const ZXing_ImageView* iv, const ZXing_ReaderOptions* opts);
+
+
+/*
+ * MARK: - CreateBarcode.h
+ */
+
+ZXing_CreatorOptions* ZXing_CreatorOptions_new(ZXing_BarcodeFormat format);
+void ZXing_CreatorOptions_delete(ZXing_CreatorOptions* opts);
+
+void ZXing_CreatorOptions_setFormat(ZXing_CreatorOptions* opts, ZXing_BarcodeFormat format);
+ZXing_BarcodeFormat ZXing_CreatorOptions_getFormat(const ZXing_CreatorOptions* opts);
+void ZXing_CreatorOptions_setOptions(ZXing_CreatorOptions* opts, const char* options);
+char* ZXing_CreatorOptions_getOptions(const ZXing_CreatorOptions* opts);
+
+ZXing_Barcode* ZXing_CreateBarcodeFromText(const char* data, int size, const ZXing_CreatorOptions* opts);
+ZXing_Barcode* ZXing_CreateBarcodeFromBytes(const void* data, int size, const ZXing_CreatorOptions* opts);
+
+/*
+ * MARK: - WriteBarcode.h
+ */
+
+ZXing_WriterOptions* ZXing_WriterOptions_new();
+void ZXing_WriterOptions_delete(ZXing_WriterOptions* opts);
+
+void ZXing_WriterOptions_setScale(ZXing_WriterOptions* opts, int scale);
+int ZXing_WriterOptions_getScale(const ZXing_WriterOptions* opts);
+
+void ZXing_WriterOptions_setRotate(ZXing_WriterOptions* opts, int rotate);
+int ZXing_WriterOptions_getRotate(const ZXing_WriterOptions* opts);
+
+void ZXing_WriterOptions_setAddHRT(ZXing_WriterOptions* opts, bool addHRT);
+bool ZXing_WriterOptions_getAddHRT(const ZXing_WriterOptions* opts);
+
+void ZXing_WriterOptions_setAddQuietZones(ZXing_WriterOptions* opts, bool addQuietZones);
+bool ZXing_WriterOptions_getAddQuietZones(const ZXing_WriterOptions* opts);
+
+
+/** Note: opts is optional, i.e. it can be NULL, which will imply default settings. */
+char* ZXing_WriteBarcodeToSVG(const ZXing_Barcode* barcode, const ZXing_WriterOptions* opts);
+ZXing_Image* ZXing_WriteBarcodeToImage(const ZXing_Barcode* barcode, const ZXing_WriterOptions* opts);
+
+
+/* ZXing_LastErrorMsg() returns NULL in case there is no last error and a copy of the string otherwise. */
+char* ZXing_LastErrorMsg();
+
+const char* ZXing_Version();
+
+void ZXing_free(void* ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ZXING_C_H */

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

@@ -0,0 +1,18 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ZXingCpp.h"
+
+#include "Version.h"
+
+namespace ZXing {
+
+const std::string& Version()
+{
+	static std::string res = ZXING_VERSION_STR;
+	return res;
+}
+
+} // namespace ZXing

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

@@ -0,0 +1,76 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BarcodeFormat.h"
+#include "CreateBarcode.h"
+#include "ReadBarcode.h"
+#include "WriteBarcode.h"
+#include "Version.h"
+
+namespace ZXing {
+
+const std::string& Version();
+
+} // namespace ZXing
+
+/**
+ \mainpage Introduction
+
+ZXing-C++ ("zebra crossing") is an open-source, multi-format linear/matrix barcode image processing library implemented in C++.
+
+The central class in the library is ZXing::Barcode, which 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.
+
+ \section reader_sec Reading barcodes
+
+1. Load your image into memory (3rd-party library required).
+2. Call ZXing::ReadBarcodes(), the simplest API to get a list of ZXing::Barcode objects.
+
+A very simple example looks like this:
+```c++
+#include "ZXing/ZXingCpp.h"
+#include <iostream>
+
+int main(int argc, char** argv)
+{
+	int width, height;
+	unsigned char* data;
+	// load your image data from somewhere. ImageFormat::Lum assumes grey scale image data.
+
+	auto image = ZXing::ImageView(data, width, height, ZXing::ImageFormat::Lum);
+	auto options = ZXing::ReaderOptions().formats(ZXing::BarcodeFormat::QRCode);
+	auto barcodes = ZXing::ReadBarcodes(image, options);
+
+	for (const auto& b : barcodes)
+		std::cout << ZXing::ToString(b.format()) << ": " << b.text() << "\n";
+
+	return 0;
+}
+```
+
+ \section writer_sec Writing barcodes
+
+1. Create a ZXing::Barcode object using either ZXing::CreateBarcodeFromText() or ZXing::CreateBarcodeFromBytes().
+2. Call ZXing::WriteBarcodeToImage() or ZXing::WriteBarcodeToSVG() to get the output.
+
+A very simple example looks like this:
+```c++
+#include "ZXing/ZXingCpp.h"
+#include <iostream>
+
+int main()
+{
+	auto barcode = ZXing::CreateBarcodeFromText("Hello, World!", ZXing::BarcodeFormat::QRCode);
+	auto options = ZXing::WriterOptions().scale(4).addQuietZones(false);
+	auto svg = ZXing::WriteBarcodeToSVG(barcode, options);
+
+    std::cout << svg << std::endl;
+
+	return 0;
+}
+```
+*/