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

package/cpp/HybridBarcodeScanner.cpp

@@ -0,0 +1,121 @@
+#include "HybridBarcodeScanner.hpp"
+
+#include "FrameImageView.hpp"
+#include "HybridBarcode.hpp"
+#include "ZXingDecoder.hpp"
+
+#include <NitroImage/PixelFormat.hpp>
+#include <NitroImage/RawPixelData.hpp>
+
+#include <algorithm>
+#include <cmath>
+#include <stdexcept>
+
+namespace margelo::nitro::camera::zxing {
+
+namespace {
+
+  using HybridBarcodes = std::vector<std::shared_ptr<HybridBarcodeSpec>>;
+
+  HybridBarcodes toHybridBarcodes(std::vector<DecodedBarcode>&& decoded) {
+    HybridBarcodes barcodes;
+    barcodes.reserve(decoded.size());
+    for (DecodedBarcode& barcode : decoded) {
+      barcodes.push_back(std::make_shared<HybridBarcode>(std::move(barcode)));
+    }
+    return barcodes;
+  }
+
+  ZXing::ImageFormat toZXingImageFormat(image::PixelFormat format) {
+    switch (format) {
+      case image::PixelFormat::ARGB:
+      case image::PixelFormat::XRGB:
+        return ZXing::ImageFormat::ARGB;
+      case image::PixelFormat::BGRA:
+      case image::PixelFormat::BGRX:
+        return ZXing::ImageFormat::BGRA;
+      case image::PixelFormat::ABGR:
+      case image::PixelFormat::XBGR:
+        return ZXing::ImageFormat::ABGR;
+      case image::PixelFormat::RGBA:
+      case image::PixelFormat::RGBX:
+        return ZXing::ImageFormat::RGBA;
+      case image::PixelFormat::RGB:
+        return ZXing::ImageFormat::RGB;
+      case image::PixelFormat::BGR:
+        return ZXing::ImageFormat::BGR;
+      case image::PixelFormat::UNKNOWN:
+        break;
+    }
+    throw std::runtime_error("The given Image has an unknown pixel format!");
+  }
+
+} // namespace
+
+HybridBarcodeScanner::HybridBarcodeScanner(const std::vector<TargetBarcodeFormat>& formats)
+    : HybridObject(TAG), _liveDecoder(formats, ZXingDecoder::Mode::Live), _imageDecoder(formats, ZXingDecoder::Mode::Still) {}
+
+HybridBarcodes HybridBarcodeScanner::scanCodes(const std::shared_ptr<camera::HybridFrameSpec>& frame) {
+  FrameImageView view(frame);
+  std::vector<DecodedBarcode> decoded = _liveDecoder.decode(view.imageView());
+  return toHybridBarcodes(std::move(decoded));
+}
+
+std::shared_ptr<Promise<HybridBarcodes>> HybridBarcodeScanner::scanCodesAsync(const std::shared_ptr<camera::HybridFrameSpec>& frame) {
+  // Building the view has to stay on the caller's thread: on Android the Frame is a JNI-backed
+  // HybridObject and the decode threads are not attached to the JVM, so reading it there aborts the
+  // process. The view holds the Frame (and its planes) alive, so the pixel memory stays owned by
+  // the Frame for the whole async decode - no copy needed.
+  std::shared_ptr<FrameImageView> view = std::make_shared<FrameImageView>(frame);
+  std::shared_ptr<HybridBarcodeScanner> self = shared_cast<HybridBarcodeScanner>();
+  return Promise<HybridBarcodes>::async([self, view]() -> HybridBarcodes {
+    std::vector<DecodedBarcode> decoded = self->_liveDecoder.decode(view->imageView());
+    return toHybridBarcodes(std::move(decoded));
+  });
+}
+
+std::shared_ptr<Promise<HybridBarcodes>> HybridBarcodeScanner::scanCodesInImageAsync(const std::shared_ptr<image::HybridImageSpec>& image) {
+  // A multi-megapixel still carries far more detail than a barcode needs, and scan cost grows
+  // with the pixel count, so shrink it first using the platform's own (optimized) scaler.
+  // Corner points are scaled back below, so callers still get coordinates in the image they passed.
+  const double longestEdge = std::max(image->getWidth(), image->getHeight());
+  std::shared_ptr<image::HybridImageSpec> source = image;
+  double cornerScale = 1.0;
+  if (longestEdge > ZXingDecoder::kStillWorkingEdge) {
+    const double ratio = ZXingDecoder::kStillWorkingEdge / longestEdge;
+    const double targetWidth = std::round(image->getWidth() * ratio);
+    const double targetHeight = std::round(image->getHeight() * ratio);
+    source = image->resize(targetWidth, targetHeight);
+    cornerScale = image->getWidth() / source->getWidth();
+  }
+
+  image::RawPixelData raw = source->toRawPixelData(false);
+  std::shared_ptr<ArrayBuffer> buffer = raw.buffer;
+  if (!buffer->isOwner()) {
+    // A non-owning ArrayBuffer only borrows its memory, and that memory is only guaranteed to be
+    // valid for this synchronous call. Take ownership before handing it to the decode thread.
+    buffer = ArrayBuffer::copy(buffer);
+  }
+  const int width = static_cast<int>(raw.width);
+  const int height = static_cast<int>(raw.height);
+  const ZXing::ImageFormat format = toZXingImageFormat(raw.pixelFormat);
+  // Resolve the address here: a platform-backed ArrayBuffer reaches its memory through the JVM,
+  // which is only available on this thread - the decode thread just reads the resolved pointer.
+  const uint8_t* data = buffer->data();
+  return Promise<HybridBarcodes>::async([buffer, data, width, height, format, cornerScale, decoder = _imageDecoder]() -> HybridBarcodes {
+    ZXing::ImageView view(data, width, height, format);
+    std::vector<DecodedBarcode> decoded = decoder.decode(view);
+    if (cornerScale != 1.0) {
+      for (DecodedBarcode& barcode : decoded) {
+        for (ZXing::PointI& corner : barcode.corners) {
+          const int x = static_cast<int>(std::lround(corner.x * cornerScale));
+          const int y = static_cast<int>(std::lround(corner.y * cornerScale));
+          corner = ZXing::PointI{x, y};
+        }
+      }
+    }
+    return toHybridBarcodes(std::move(decoded));
+  });
+}
+
+} // namespace margelo::nitro::camera::zxing

package/cpp/HybridBarcodeScanner.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "HybridBarcodeScannerSpec.hpp"
+#include "TargetBarcodeFormat.hpp"
+
+#include "ZXingDecoder.hpp"
+
+#include <vector>
+
+namespace margelo::nitro::camera::zxing {
+
+class HybridBarcodeScanner final : public HybridBarcodeScannerSpec {
+public:
+  explicit HybridBarcodeScanner(const std::vector<TargetBarcodeFormat>& formats);
+
+  std::vector<std::shared_ptr<HybridBarcodeSpec>> scanCodes(const std::shared_ptr<camera::HybridFrameSpec>& frame) override;
+  std::shared_ptr<Promise<std::vector<std::shared_ptr<HybridBarcodeSpec>>>> scanCodesAsync(const std::shared_ptr<camera::HybridFrameSpec>& frame) override;
+  std::shared_ptr<Promise<std::vector<std::shared_ptr<HybridBarcodeSpec>>>>
+  scanCodesInImageAsync(const std::shared_ptr<image::HybridImageSpec>& image) override;
+
+private:
+  ZXingDecoder _liveDecoder;
+  ZXingDecoder _imageDecoder;
+};
+
+} // namespace margelo::nitro::camera::zxing

package/cpp/HybridBarcodeScannerFactory.cpp

@@ -0,0 +1,11 @@
+#include "HybridBarcodeScannerFactory.hpp"
+
+#include "HybridBarcodeScanner.hpp"
+
+namespace margelo::nitro::camera::zxing {
+
+std::shared_ptr<HybridBarcodeScannerSpec> HybridBarcodeScannerFactory::createBarcodeScanner(const BarcodeScannerOptions& options) {
+  return std::make_shared<HybridBarcodeScanner>(options.barcodeFormats);
+}
+
+} // namespace margelo::nitro::camera::zxing

package/cpp/HybridBarcodeScannerFactory.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "HybridZXingBarcodeScannerFactorySpec.hpp"
+
+namespace margelo::nitro::camera::zxing {
+
+class HybridBarcodeScannerFactory final : public HybridZXingBarcodeScannerFactorySpec {
+public:
+  HybridBarcodeScannerFactory() : HybridObject(TAG) {}
+
+  std::shared_ptr<HybridBarcodeScannerSpec> createBarcodeScanner(const BarcodeScannerOptions& options) override;
+};
+
+} // namespace margelo::nitro::camera::zxing

package/cpp/ImageDownscaler.cpp

@@ -0,0 +1,34 @@
+#include "ImageDownscaler.hpp"
+
+namespace margelo::nitro::camera::zxing {
+
+std::vector<uint8_t> downscaleToLuminance(const ZXing::ImageView& image, int factor, ZXing::ImageView& outView) {
+  const int width = image.width() / factor;
+  const int height = image.height() / factor;
+  const int pixelStride = image.pixStride();
+  const int redIndex = ZXing::RedIndex(image.format());
+  const int greenIndex = ZXing::GreenIndex(image.format());
+  const int blueIndex = ZXing::BlueIndex(image.format());
+  const bool isLuminance = image.format() == ZXing::ImageFormat::Lum;
+  const unsigned samples = static_cast<unsigned>(factor) * static_cast<unsigned>(factor);
+
+  std::vector<uint8_t> pixels(static_cast<size_t>(width) * static_cast<size_t>(height));
+  for (int y = 0; y < height; y++) {
+    for (int x = 0; x < width; x++) {
+      unsigned sum = 0;
+      for (int blockY = 0; blockY < factor; blockY++) {
+        const uint8_t* row = image.data(x * factor, y * factor + blockY);
+        for (int blockX = 0; blockX < factor; blockX++) {
+          const uint8_t* pixel = row + blockX * pixelStride;
+          sum += isLuminance ? *pixel : ZXing::RGBToLum(pixel[redIndex], pixel[greenIndex], pixel[blueIndex]);
+        }
+      }
+      const size_t index = static_cast<size_t>(y) * static_cast<size_t>(width) + static_cast<size_t>(x);
+      pixels[index] = static_cast<uint8_t>(sum / samples);
+    }
+  }
+  outView = ZXing::ImageView(pixels.data(), width, height, ZXing::ImageFormat::Lum);
+  return pixels;
+}
+
+} // namespace margelo::nitro::camera::zxing

package/cpp/ImageDownscaler.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "ImageView.h"
+
+#include <cstdint>
+#include <vector>
+
+namespace margelo::nitro::camera::zxing {
+
+/**
+ * Box-averages `image` down by an integer `factor` into a compact luminance buffer,
+ * converting colour input to luminance in the same pass.
+ *
+ * Averaging (rather than dropping pixels) keeps barcode edges intact: plain subsampling
+ * aliases the fine bar/module pattern and can make a readable code undecodable.
+ *
+ * @returns the pixel data; `outView` is a view onto it and stays valid while it is alive.
+ */
+std::vector<uint8_t> downscaleToLuminance(const ZXing::ImageView& image, int factor, ZXing::ImageView& outView);
+
+} // namespace margelo::nitro::camera::zxing

package/cpp/ZXingDecoder.cpp

@@ -0,0 +1,189 @@
+#include "ZXingDecoder.hpp"
+
+#include "BarcodeValueTypeClassifier.hpp"
+#include "ImageDownscaler.hpp"
+
+#include "Barcode.h"
+#include "BarcodeFormat.h"
+#include "ReadBarcode.h"
+
+#include <algorithm>
+#include <stdexcept>
+
+namespace margelo::nitro::camera::zxing {
+
+namespace {
+
+  /// How often the rotation-aware fallback runs while scanning live frames.
+  constexpr uint64_t kLiveRotationPeriod = 4;
+
+  ZXing::BarcodeFormat toZXingFormat(TargetBarcodeFormat format) {
+    switch (format) {
+      case TargetBarcodeFormat::CODE_128:
+        return ZXing::BarcodeFormat::Code128;
+      case TargetBarcodeFormat::CODE_39:
+        return ZXing::BarcodeFormat::Code39;
+      case TargetBarcodeFormat::CODE_93:
+        return ZXing::BarcodeFormat::Code93;
+      case TargetBarcodeFormat::CODABAR:
+        return ZXing::BarcodeFormat::Codabar;
+      case TargetBarcodeFormat::DATA_MATRIX:
+        return ZXing::BarcodeFormat::DataMatrix;
+      case TargetBarcodeFormat::EAN_13:
+        return ZXing::BarcodeFormat::EAN13;
+      case TargetBarcodeFormat::EAN_8:
+        return ZXing::BarcodeFormat::EAN8;
+      case TargetBarcodeFormat::ITF:
+        return ZXing::BarcodeFormat::ITF;
+      case TargetBarcodeFormat::QR_CODE:
+        return ZXing::BarcodeFormat::QRCode;
+      case TargetBarcodeFormat::UPC_A:
+        return ZXing::BarcodeFormat::UPCA;
+      case TargetBarcodeFormat::UPC_E:
+        return ZXing::BarcodeFormat::UPCE;
+      case TargetBarcodeFormat::PDF_417:
+        return ZXing::BarcodeFormat::PDF417;
+      case TargetBarcodeFormat::AZTEC:
+        return ZXing::BarcodeFormat::Aztec;
+      case TargetBarcodeFormat::ALL_FORMATS:
+        break;
+    }
+    throw std::invalid_argument("Unknown TargetBarcodeFormat: " + std::to_string(static_cast<int>(format)));
+  }
+
+  constexpr std::array<TargetBarcodeFormat, 13> kAllFormats = {
+      TargetBarcodeFormat::CODE_128, TargetBarcodeFormat::CODE_39, TargetBarcodeFormat::CODE_93, TargetBarcodeFormat::CODABAR, TargetBarcodeFormat::DATA_MATRIX,
+      TargetBarcodeFormat::EAN_13,   TargetBarcodeFormat::EAN_8,   TargetBarcodeFormat::ITF,     TargetBarcodeFormat::QR_CODE, TargetBarcodeFormat::UPC_A,
+      TargetBarcodeFormat::UPC_E,    TargetBarcodeFormat::PDF_417, TargetBarcodeFormat::AZTEC,
+  };
+
+  BarcodeFormat toNitroFormat(const ZXing::Barcode& barcode) {
+    switch (barcode.symbology()) {
+      case ZXing::BarcodeFormat::Code128:
+        return BarcodeFormat::CODE_128;
+      case ZXing::BarcodeFormat::Code39:
+        return BarcodeFormat::CODE_39;
+      case ZXing::BarcodeFormat::Code93:
+        return BarcodeFormat::CODE_93;
+      case ZXing::BarcodeFormat::Codabar:
+        return BarcodeFormat::CODABAR;
+      case ZXing::BarcodeFormat::DataMatrix:
+        return BarcodeFormat::DATA_MATRIX;
+      case ZXing::BarcodeFormat::ITF:
+        return BarcodeFormat::ITF;
+      case ZXing::BarcodeFormat::QRCode:
+        return BarcodeFormat::QR_CODE;
+      case ZXing::BarcodeFormat::PDF417:
+        return BarcodeFormat::PDF_417;
+      case ZXing::BarcodeFormat::Aztec:
+        return BarcodeFormat::AZTEC;
+      case ZXing::BarcodeFormat::EANUPC:
+        switch (barcode.format()) {
+          case ZXing::BarcodeFormat::EAN8:
+            return BarcodeFormat::EAN_8;
+          case ZXing::BarcodeFormat::UPCA:
+            return BarcodeFormat::UPC_A;
+          case ZXing::BarcodeFormat::UPCE:
+            return BarcodeFormat::UPC_E;
+          default:
+            return BarcodeFormat::EAN_13;
+        }
+      default:
+        return BarcodeFormat::UNKNOWN;
+    }
+  }
+
+  ZXing::ReaderOptions makeOptions(const std::vector<ZXing::BarcodeFormat>& formats, bool tryHarder, bool tryRotate, bool tryDownscale) {
+    ZXing::BarcodeFormats barcodeFormats{std::vector<ZXing::BarcodeFormat>(formats)};
+    ZXing::ReaderOptions options;
+    options.setFormats(barcodeFormats);
+    options.setTryHarder(tryHarder);
+    options.setTryRotate(tryRotate);
+    options.setTryInvert(tryHarder);
+    options.setTryDownscale(tryDownscale);
+    return options;
+  }
+
+  DecodedBarcode toDecodedBarcode(const ZXing::Barcode& barcode, int scale) {
+    DecodedBarcode decoded;
+    decoded.format = toNitroFormat(barcode);
+    decoded.rawValue = barcode.text(ZXing::TextMode::Plain);
+    decoded.displayValue = barcode.text(ZXing::TextMode::HRI);
+    decoded.rawBytes = barcode.bytes();
+    const ZXing::Position& position = barcode.position();
+    for (size_t i = 0; i < 4; i++) {
+      // Map back to the coordinate system of the image the caller passed in.
+      decoded.corners[i] = scale * position[i];
+    }
+    decoded.valueType = classifyValueType(decoded.rawValue, decoded.format, barcode.contentType());
+    return decoded;
+  }
+
+} // namespace
+
+ZXingDecoder::ZXingDecoder(const std::vector<TargetBarcodeFormat>& formats, Mode mode) {
+  if (formats.empty()) {
+    throw std::invalid_argument("Target barcodeFormats cannot be empty!");
+  }
+  std::vector<ZXing::BarcodeFormat> zxingFormats;
+  for (TargetBarcodeFormat format : formats) {
+    if (format == TargetBarcodeFormat::ALL_FORMATS) {
+      for (TargetBarcodeFormat all : kAllFormats) {
+        zxingFormats.push_back(toZXingFormat(all));
+      }
+    } else {
+      zxingFormats.push_back(toZXingFormat(format));
+    }
+  }
+
+  if (mode == Mode::Live) {
+    // Most frames either contain a readable code or none at all, so start with the cheapest
+    // scan and only pay for rotation handling when that finds nothing.
+    _attempts.push_back({makeOptions(zxingFormats, false, false, false), 0, 1});
+    // Rotation handling costs several times a plain scan, so look for rotated codes periodically
+    // instead of on every frame that finds nothing.
+    _attempts.push_back({makeOptions(zxingFormats, false, true, false), 0, kLiveRotationPeriod});
+  } else {
+    // A still is usually many megapixels: scan a reduced copy first, then the full image, and
+    // only then the expensive heuristics that help with blurred or inverted captures.
+    _attempts.push_back({makeOptions(zxingFormats, false, false, true), kStillWorkingEdge, 1});
+    _attempts.push_back({makeOptions(zxingFormats, false, true, true), 0, 1});
+    _attempts.push_back({makeOptions(zxingFormats, true, true, true), 0, 1});
+  }
+}
+
+std::vector<DecodedBarcode> ZXingDecoder::decode(const ZXing::ImageView& image) const {
+  const uint64_t call = _calls->fetch_add(1, std::memory_order_relaxed);
+  for (const Attempt& attempt : _attempts) {
+    if (attempt.period > 1 && call % attempt.period != 0) {
+      continue;
+    }
+    const int longestEdge = std::max(image.width(), image.height());
+    const int factor = attempt.maxEdge > 0 ? longestEdge / attempt.maxEdge : 1;
+
+    ZXing::Barcodes barcodes;
+    int scale = 1;
+    if (factor > 1) {
+      ZXing::ImageView scaled;
+      // Keep the pixels alive for as long as the view is read.
+      std::vector<uint8_t> pixels = downscaleToLuminance(image, factor, scaled);
+      barcodes = ZXing::ReadBarcodes(scaled, attempt.options);
+      scale = factor;
+    } else {
+      barcodes = ZXing::ReadBarcodes(image, attempt.options);
+    }
+
+    std::vector<DecodedBarcode> decoded;
+    for (const ZXing::Barcode& barcode : barcodes) {
+      if (barcode.isValid()) {
+        decoded.push_back(toDecodedBarcode(barcode, scale));
+      }
+    }
+    if (!decoded.empty()) {
+      return decoded;
+    }
+  }
+  return {};
+}
+
+} // namespace margelo::nitro::camera::zxing

package/cpp/ZXingDecoder.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+#include "BarcodeFormat.hpp"
+#include "BarcodeValueType.hpp"
+#include "TargetBarcodeFormat.hpp"
+
+#include "ImageView.h"
+#include "Point.h"
+#include "ReaderOptions.h"
+
+#include <array>
+#include <atomic>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::camera::zxing {
+
+struct DecodedBarcode {
+  BarcodeFormat format = BarcodeFormat::UNKNOWN;
+  BarcodeValueType valueType = BarcodeValueType::UNKNOWN;
+  std::string rawValue;
+  std::string displayValue;
+  std::vector<uint8_t> rawBytes;
+  std::array<ZXing::PointI, 4> corners{};
+};
+
+/**
+ * Decodes barcodes with zxing-cpp.
+ *
+ * Decoding cost grows with the number of pixels scanned and with how many heuristics are
+ * enabled, so the decoder runs an escalating ladder of attempts: the cheapest configuration
+ * first, and a more expensive one only if the previous attempt found nothing. A frame that
+ * contains a readable code therefore pays only for the cheap attempt.
+ *
+ * While scanning live, most frames contain no readable code at all, so the expensive fallbacks
+ * are spread across frames rather than run on every miss: a code they can find is still picked
+ * up within a few frames, but the per-frame cost stays close to the cheap attempt.
+ */
+class ZXingDecoder final {
+public:
+  /**
+   * - Live: tuned for camera frames arriving continuously, where latency per frame matters.
+   * - Still: tuned for a single high-resolution capture, where a slower fallback is acceptable.
+   */
+  enum class Mode { Live, Still };
+
+  /**
+   * Longest edge a still image is scanned at. Larger captures are scaled down first: they cost
+   * proportionally more to scan while carrying more detail than a barcode needs.
+   */
+  static constexpr int kStillWorkingEdge = 1280;
+
+  explicit ZXingDecoder(const std::vector<TargetBarcodeFormat>& formats, Mode mode = Mode::Live);
+
+  std::vector<DecodedBarcode> decode(const ZXing::ImageView& image) const;
+
+private:
+  struct Attempt {
+    ZXing::ReaderOptions options;
+    /// Longest edge to scan at, or 0 to scan the image at its native size.
+    int maxEdge;
+    /// Run this attempt on every Nth call. 1 runs it whenever the previous attempts found nothing.
+    uint64_t period;
+  };
+  std::vector<Attempt> _attempts;
+  /// Shared by copies of this decoder so one scanner keeps a single cadence.
+  std::shared_ptr<std::atomic<uint64_t>> _calls = std::make_shared<std::atomic<uint64_t>>(0);
+};
+
+} // namespace margelo::nitro::camera::zxing