zxing_ffi 0.1.0-x86_64-linux-gnu → 0.2.0-x86_64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fca126ce5bfcd5cacc39797bffa92d5324af1f85434ac357a9a9844de7f7243f
-  data.tar.gz: 5ce4ae0174c6fe83c24cc8f7abf9b82a0f1f0566053b7072aa97731546b4a03a
+  metadata.gz: d5e54739e8076eaa1e643e6ba3d419f720c028ad8ec026c54ea8ed3263cfceec
+  data.tar.gz: c48499d48a7f48c180b308d56d85e92abc4d37576459fbf8f806e17a58f10550
 SHA512:
-  metadata.gz: 8fd94ac067999ae90ab17346307ed4097cfd48e08d7c90ae0ce04d6c830b024d42be4ab3d6ab69f36b62a011bc562de6cd09b49b3c3fb3ebcbb19c11432ba4f3
-  data.tar.gz: 99f04a6996a1474ed98501c43ec040f5981cd217366fba76b69f38faf596689c69bba6cc59e0a96586dd0387ccded21241449110bbfb1c864ab243dc39d5e9e0
+  metadata.gz: 80f27a58a5646eef35917f8c5583c1a9ec84d6149ea507b590580ea55a34c3c27e2e51a2b1d3f14aaa123efa857a0855761de95485531912b6daf0f2f5f43a4d
+  data.tar.gz: 4a2725b55ad246777da0add216cf90a9fbe28554376340ac78a4cc6cd4ac359a8545d549d34842289ac21734fcedce3beac6fc64f63329046bbb0436bc4fcb1d

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.2.0 (2026-10-08)
+
+- **`oversize: :downscale`** (scan option and `config.oversize`): rasters over `max_pixels` are decoded smaller to fit
+  instead of raising `LimitExceeded`, by the libvips loader (JPEG and WebP shrink while decoding, other formats
+  stream), up to the new `max_source_pixels` (default 1 GP; larger ones still raise). Positions and page sizes stay
+  in the original's pixels and `PageResult#metadata[:downscaled]` records the scale. The default stays `:raise`.
+- **`high_res` pass**: rasters are upscaled with a centered bicubic (Catmull-Rom) filter instead of pixel
+  replication, which kept the aliasing of codes rasterized at 1–2 px per module. QR codes at ~1.5 px per module
+  that every pass missed are now found at `effort: :normal`. Both transformers' `resize` upscale this way at any
+  scale above 1.
+- **Tooling**: `rake release` publishes a release from `main`: it tags the commit, waits for the Platform gems
+  workflow, checks the seven gems that workflow built, pushes them to RubyGems (asking for the OTP) and creates the
+  GitHub release. It replaces Bundler's `rake release`, which pushes a locally built ruby gem only.
+
 ## 0.1.0 (2026-10-01)
 
 First release candidate of `zxing_ffi`, a replacement for the unmaintained `zbar` gem.

data/README.md

@@ -134,7 +134,8 @@ page in page order (or returns an Enumerator). Inputs can be a path (`String`/`P
 | `min_length` | `{}` | minimum text length per format, e.g. `{itf: 6}` |
 | `timeout` | — | per-page budget in seconds: caps renders (re-renders get what is left) and stops escalation (the first pass always runs) |
 | `instrument` | — | callable receiving `(event, payload)` for `:page_loaded`, `:pass_completed`, `:page_completed` |
-| `max_pixels`, `max_pages` | config | per-call limits |
+| `oversize` | `:raise` | rasters over `max_pixels`: `:raise` raises `LimitExceeded`; `:downscale` decodes them smaller to fit (libvips loader only: JPEG and WebP shrink while decoding, other formats stream), up to `max_source_pixels`. Positions and `PageResult#width`/`height` stay in the original's pixels and `PageResult#metadata[:downscaled]` holds the scale; codes left under ~2 px per module are lost |
+| `max_pixels`, `max_source_pixels`, `max_pages` | config | per-call limits |
 
 Every `ZXingFFI.read` option below is accepted too and applies to every pass.
 
@@ -145,7 +146,7 @@ Every `ZXingFFI.read` option below is accepted too and applies to every pass.
 | `base` | library defaults + your options | fast, normal, thorough |
 | `inverted` | decodes a pixel-inverted copy for white-on-black codes (zxing-cpp's `try_invert` only covers 2D codes, so with it on this pass handles the linear formats) | normal, thorough |
 | `global_binarizer` | global-histogram binarizer | normal, thorough |
-| `high_res` | PDF re-rendered at 2× DPI; small rasters upscaled 2× | normal, thorough |
+| `high_res` | PDF re-rendered at 2× DPI; rasters under 2000 px upscaled 2× (bicubic, so codes at 1–2 px per module resolve) | normal, thorough |
 | `tiles` | overlapping 1024–1536 px tiles, no downscaling (tiny codes on big pages) | thorough |
 | `rotated_45` | image rotated 45° for linear codes at odd angles (also covers 135°/225°/315°) | thorough |
 | `denoise` | `try_denoise: true` (libZXing built with `ZXING_EXPERIMENTAL_API` only) | thorough |
@@ -216,6 +217,8 @@ ZXingFFI.configure do |c|
   c.default_dpi    = 300
   c.max_dpi        = 600
   c.max_pixels     = 64_000_000
+  c.oversize       = :raise          # or :downscale (see the scan options)
+  c.max_source_pixels = 1_000_000_000 # with oversize: :downscale, larger rasters still raise
   c.max_pages      = nil
   c.render_timeout = 60
   c.subprocess_memory_limit = 2 * 1024**3
@@ -237,7 +240,9 @@ The gem is meant to process untrusted documents:
   limit (`subprocess_memory_limit`, enforced on Linux only — macOS ignores `RLIMIT_AS`). Passwords are only ever passed
   as the argument after `-upw`.
 - **Pixel cap**: every bitmap is checked against `max_pixels` before it is rendered or decoded. PDF pages that would
-  exceed it are rendered at a lower (possibly fractional) DPI; rasters raise `ZXingFFI::LimitExceeded`.
+  exceed it are rendered at a lower (possibly fractional) DPI; rasters raise `ZXingFFI::LimitExceeded`, unless
+  `oversize: :downscale` has libvips decode them smaller to fit (never holding them at full size), in which case the
+  header check holds them to `max_source_pixels` instead.
 - **No format confusion**: inputs are identified by magic bytes, never by extension. ImageMagick always reads with an
   explicit coder (`png:/path`), never sees PDF, PostScript, SVG, MVG, MSL or text, and gets special characters in
   paths neutralized. libvips is called with the loader for the sniffed type, and operations libvips flags as

data/lib/zxing_ffi/config.rb

@@ -34,6 +34,11 @@ module ZXingFFI
     attr_accessor :max_dpi
     # @return [Integer] maximum pixels per bitmap
     attr_accessor :max_pixels
+    # @return [Integer, nil] with +oversize: :downscale+, the most pixels a raster may have; larger ones still raise
+    attr_accessor :max_source_pixels
+    # @return [Symbol] rasters over +max_pixels+: +:raise+ ({LimitExceeded}) or +:downscale+ (the libvips loader decodes
+    #   them smaller to fit; positions stay in the original's pixels)
+    attr_accessor :oversize
     # @return [Integer, nil] maximum number of pages per document (nil = unlimited)
     attr_accessor :max_pages
     # @return [Numeric] seconds allowed per page render
@@ -53,6 +58,8 @@ module ZXingFFI
       @default_dpi = 300
       @max_dpi = 600
       @max_pixels = 64_000_000
+      @max_source_pixels = 1_000_000_000
+      @oversize = :raise
       @max_pages = nil
       @render_timeout = 60
       @subprocess_memory_limit = 2 * 1024**3
@@ -89,6 +96,8 @@ module ZXingFFI
         default_dpi: default_dpi,
         max_dpi: max_dpi,
         max_pixels: max_pixels,
+        max_source_pixels: max_source_pixels,
+        oversize: oversize,
         max_pages: max_pages,
         render_timeout: render_timeout,
         subprocess_memory_limit: subprocess_memory_limit,

data/lib/zxing_ffi/header_probe.rb

@@ -35,15 +35,17 @@ module ZXingFFI
       end
 
       # Raises when the header declares more than +max_pixels+ pixels.
+      # @param limit [Symbol] the setting +max_pixels+ comes from, for the error (+:max_source_pixels+ when the image
+      #   would be downscaled to fit)
       # @raise [LimitExceeded]
-      def check!(path, kind, max_pixels)
+      def check!(path, kind, max_pixels, limit: :max_pixels)
         return unless max_pixels
 
         width, height = dimensions(path, kind)
         return unless width && height && width * height > max_pixels
 
         raise LimitExceeded.new("#{File.basename(path)} declares #{width}x#{height} (#{width * height} pixels), " \
-          "exceeding max_pixels #{max_pixels}", limit: :max_pixels, value: width * height)
+          "exceeding #{limit} #{max_pixels}", limit: limit, value: width * height)
       end
 
       private

data/lib/zxing_ffi/loaders/base.rb

@@ -18,8 +18,10 @@ module ZXingFFI
     # @!attribute number [Integer] 1-based page/frame number
     # @!attribute image [Image] normalized 8-bit luminance image
     # @!attribute dpi [Integer, nil] render DPI (PDF) or nil for rasters
-    # @!attribute scale_to_base [Float] factor mapping this image's pixels to the page's base image (1.0 for the base)
-    # @!attribute metadata [Hash] what was applied, e.g. +orientation_applied:+, +aspect_corrected:+, +dpi_capped:+
+    # @!attribute scale_to_base [Float] factor mapping this image's pixels to the page's base image: 1.0, or above 1
+    #   for a raster decoded downscaled, whose positions are reported in the original's pixels
+    # @!attribute metadata [Hash] what was applied, e.g. +orientation_applied:+, +aspect_corrected:+, +dpi_capped:+,
+    #   +downscaled:+ (+{from: [width, height], scale:}+)
     Page = Data.define(:number, :image, :dpi, :scale_to_base, :metadata)
 
     # Base class for loaders. Subclasses implement the class-level capability checks and {#open}.
@@ -69,6 +71,13 @@ module ZXingFFI
           ""
         end
 
+        # Whether this loader decodes rasters over +max_pixels+ smaller to fit when +oversize+ is +:downscale+
+        # (the others raise {LimitExceeded} regardless).
+        # @return [Boolean]
+        def downscales?
+          false
+        end
+
         # Tool versions and capabilities, for {ZXingFFI.diagnostics}.
         # @return [Hash]
         def diagnostics

data/lib/zxing_ffi/loaders/vips.rb

@@ -11,6 +11,10 @@ module ZXingFFI
     # Consequently vips renders PDFs only after opting in with +vips_block_untrusted = false+ — and a crash in
     # libvips or poppler-glib then takes down the Ruby process.
     #
+    # With +oversize: :downscale+, rasters over +max_pixels+ (up to +max_source_pixels+) are decoded smaller to fit,
+    # without ever holding them at full size: JPEG decodes at 1/2, 1/4 or 1/8 and WebP at any scale directly, other
+    # formats stream through the resize.
+    #
     # Documents are safe to render concurrently (each render builds its own libvips pipeline).
     class VipsLoader < Base
       # Sniffed kind => libvips load operation.
@@ -40,6 +44,9 @@ module ZXingFFI
           "install libvips (brew install vips / apt install libvips-tools) and the ruby-vips gem"
         end
 
+        # (see Base.downscales?)
+        def downscales? = true
+
         # Whether this libvips can load +kind+ right now (operation present and, unless opted in, trusted).
         def supports?(kind)
           operation = OPERATIONS[kind.to_sym]
@@ -150,9 +157,15 @@ module ZXingFFI
           raise RenderError.new("libvips failed on #{source.name}: #{Pipeline.error_summary(e)}", stderr: e.message[0, 4096])
         end
 
-        # Flattens alpha onto white, converts to 8-bit single-band luminance and copies it into an Image.
+        # Converts to 8-bit single-band luminance and copies it into an Image.
         def to_image(vimage)
           check_pixels!(vimage.width, vimage.height)
+          vimage = gray(vimage)
+          Image.new(vimage.write_to_memory, width: vimage.width, height: vimage.height)
+        end
+
+        # Alpha flattened onto white, then 8-bit single-band luminance.
+        def gray(vimage)
           if vimage.has_alpha?
             white = %i[ushort short].include?(vimage.format) ? 65_535 : 255
             vimage = vimage.flatten(background: [white])
@@ -160,7 +173,7 @@ module ZXingFFI
           vimage = vimage.colourspace(:b_w) unless vimage.interpretation == :"b-w" && vimage.format == :uchar
           vimage = vimage.extract_band(0) if vimage.bands > 1
           vimage = vimage.cast(:uchar) unless vimage.format == :uchar
-          Image.new(vimage.write_to_memory, width: vimage.width, height: vimage.height)
+          vimage
         end
 
         def check_pixels!(width, height)
@@ -195,31 +208,81 @@ module ZXingFFI
         end
 
         # Applies the normalization contract: aspect correction (on the stored axes, because libvips'
-        # autorot does not swap xres/yres), EXIF orientation, alpha → white, 16-bit scaling, 8-bit gray.
+        # autorot does not swap xres/yres), EXIF orientation, alpha → white, 16-bit scaling, 8-bit gray. A frame over
+        # max_pixels raises, or with +oversize: :downscale+ is decoded smaller to fit.
         def render(number, dpi: nil, timeout: nil) # timeout: in-process, cannot be enforced
           check_page!(number)
           vips_call do
             vimage = load(number - 1)
-            vimage, aspect = correct_aspect(vimage)
+            width, height = corrected_size(vimage)
+            scale = fit_scale(width, height)
+            vimage, aspect, scale = (scale < 1) ? downscaled(number - 1, vimage, scale) : [*correct_aspect(vimage), 1.0]
             orientation = orientation_of(vimage)
             orientation = nil if orientation == 1 # "normal": nothing to apply
             vimage = vimage.autorot if orientation
-            image = to_image(vimage)
-            Page.new(number: number, image: image, dpi: nil, scale_to_base: 1.0, metadata: {
-              loader: :vips, orientation_applied: orientation, aspect_corrected: aspect
-            })
+            metadata = {loader: :vips, orientation_applied: orientation, aspect_corrected: aspect}
+            if scale < 1
+              width, height = height, width if [5, 6, 7, 8].include?(orientation)
+              metadata[:downscaled] = {from: [width, height], scale: scale}
+            end
+            Page.new(number: number, image: to_image(vimage), dpi: nil, scale_to_base: 1.0 / scale, metadata: metadata)
           end
         end
 
         private
 
-        def load(index)
+        def load(index, **options)
           vips_call do
-            options = PAGED.include?(@operation) ? {page: index} : {}
+            options[:page] = index if PAGED.include?(@operation)
             Pipeline.load_fresh(@operation, source.path, **options)
           end
         end
 
+        # 1.0 when a frame of +width+ x +height+ fits max_pixels. Otherwise it raises LimitExceeded, unless
+        # +oversize: :downscale+ lets it be decoded smaller (up to max_source_pixels): then the scale that fits.
+        def fit_scale(width, height)
+          pixels = width * height
+          return 1.0 unless @config.max_pixels && pixels > @config.max_pixels
+
+          check_pixels!(width, height) unless @config.oversize == :downscale
+          ceiling = @config.max_source_pixels
+          if ceiling && pixels > ceiling
+            raise LimitExceeded.new("#{width}x#{height} (#{pixels} pixels) exceeds max_source_pixels #{ceiling}",
+              limit: :max_source_pixels, value: pixels)
+          end
+          Math.sqrt(@config.max_pixels.to_f / pixels)
+        end
+
+        # Frame +index+ (+header+ is its lazily loaded image) decoded at about +scale+ and aspect-corrected, as gray
+        # in memory, without holding it at full size. Returns the image, the aspect correction applied and the exact
+        # scale, lowered until the rounded size fits max_pixels.
+        def downscaled(index, header, scale)
+          hscale, vscale = aspect_scale(header) || [1.0, 1.0]
+          loaded, options = shrink_on_load(scale * [hscale, vscale].max)
+          options[:access] = :sequential if [hscale, vscale].max * scale <= loaded # an axis to upsample needs random access
+          vimage = gray(load(index, **options))
+          scale *= 0.9999 while (vimage.width * hscale * scale / loaded).ceil * (vimage.height * vscale * scale / loaded).ceil > @config.max_pixels
+          x = hscale * scale / loaded
+          y = vscale * scale / loaded
+          vimage = vimage.resize(x, vscale: y) unless x == 1 && y == 1
+          aspect = resolutions(header).map { |r| r.round(1) } unless hscale == 1 && vscale == 1
+          [vimage.copy_memory, aspect, scale]
+        end
+
+        # Load options that make the decoder itself shrink by about +scale+, never below it: JPEG by 1/2, 1/4 or 1/8,
+        # WebP by any factor. Returns the factor they apply and the options.
+        def shrink_on_load(scale)
+          case @operation
+          when "jpegload"
+            shrink = [8, 4, 2].find { |factor| factor * scale <= 1 }
+            shrink ? [1.0 / shrink, {shrink: shrink}] : [1.0, {}]
+          when "webpload"
+            ::Vips::Introspect.get("webpload").optional_input.key?("scale") ? [scale, {scale: scale}] : [1.0, {}]
+          else
+            [1.0, {}]
+          end
+        end
+
         def build_info(number)
           vimage = load(number - 1)
           width, height = corrected_size(vimage)

data/lib/zxing_ffi/scanner.rb

@@ -6,8 +6,8 @@ module ZXingFFI
   # @!attribute page [Integer] 1-based
   # @!attribute barcodes [Array<Barcode>] ordered top-to-bottom, left-to-right
   # @!attribute dpi [Integer, nil] base render DPI (PDF) or nil
-  # @!attribute width [Integer, nil] base image width in pixels
-  # @!attribute height [Integer, nil] base image height in pixels
+  # @!attribute width [Integer, nil] base image width in pixels (the original's for a raster decoded downscaled)
+  # @!attribute height [Integer, nil] base image height in pixels (the original's for a raster decoded downscaled)
   # @!attribute passes_run [Array<Symbol>]
   # @!attribute skipped_passes [Hash{Symbol => String}] passes that could not run, with the reason
   # @!attribute duration [Float] seconds spent on the page
@@ -20,8 +20,8 @@ module ZXingFFI
   class Scanner
     # Options that only the scanner understands.
     SCAN_OPTIONS = %i[
-      effort passes stop dpi max_dpi max_pixels max_pages pages password threads on_page_error loader
-      min_length timeout instrument
+      effort passes stop dpi max_dpi max_pixels max_source_pixels oversize max_pages pages password threads
+      on_page_error loader min_length timeout instrument
     ].freeze
 
     # Every option +scan+/+scan_pages+ accept: the scanner's plus every {ZXingFFI.read} option.
@@ -30,6 +30,9 @@ module ZXingFFI
     # Accepted values of +on_page_error:+.
     ON_PAGE_ERROR = %i[raise skip].freeze
 
+    # Accepted values of +oversize:+.
+    OVERSIZE = %i[raise downscale].freeze
+
     # @param options [Hash] see {ZXingFFI.scan}
     # @raise [ArgumentError] for unknown or invalid options (before any input is opened)
     def initialize(**options)
@@ -51,6 +54,12 @@ module ZXingFFI
       raise ArgumentError, "instrument must respond to #call" if @instrument && !@instrument.respond_to?(:call)
 
       @config = effective_config(options)
+      raise ArgumentError, "oversize must be :raise or :downscale, got #{@config.oversize.inspect}" unless OVERSIZE.include?(@config.oversize)
+      source_pixels = @config.max_source_pixels
+      if source_pixels && !(source_pixels.is_a?(Integer) && source_pixels.positive?)
+        raise ArgumentError, "max_source_pixels must be a positive Integer or nil, got #{source_pixels.inspect}"
+      end
+
       @reader_options = Reader::Options.new(options.slice(*Reader::OPTION_KEYS))
       @min_length = validate_min_length(options.fetch(:min_length, {}))
       @notify_mutex = Mutex.new
@@ -102,7 +111,10 @@ module ZXingFFI
     private
 
     def scan_source(source, &block)
-      HeaderProbe.check!(source.path, source.kind, @config.max_pixels) unless source.kind == :pdf
+      unless source.kind == :pdf
+        pixels, limit = raster_limit(source.kind)
+        HeaderProbe.check!(source.path, source.kind, pixels, limit: limit)
+      end
       loader_class = Loaders::Registry.loader_for(source.kind, config: @config, loader: @loader)
       document = loader_class.new(@config).open(source, password: @password)
       begin
@@ -176,10 +188,11 @@ module ZXingFFI
       rerender = pdf ? ->(dpi) { document.render(number, dpi: dpi, timeout: deadline && [deadline - monotonic, 0.05].max) } : nil
       result = strategy.run(page, rerender: rerender, page_info: info, deadline: deadline,
         notify: ->(event, payload) { notify(event, page: number, **payload) })
-      barcodes = Scanner.order(result.barcodes.map { |barcode| finalize(barcode, number, page.dpi) })
+      barcodes = Scanner.order(result.barcodes.map { |barcode| finalize(barcode, number, page) })
       metadata = page.metadata.merge(choice ? {dpi_source: choice.source, dpi_capped: choice.capped} : {})
+      width, height = page.metadata.dig(:downscaled, :from) || [page.image.width, page.image.height]
       page_result = PageResult.new(
-        page: number, barcodes: barcodes, dpi: page.dpi, width: page.image.width, height: page.image.height,
+        page: number, barcodes: barcodes, dpi: page.dpi, width: width, height: height,
         passes_run: result.passes_run, skipped_passes: result.skipped_passes, duration: monotonic - started,
         error: nil, metadata: metadata
       )
@@ -206,10 +219,26 @@ module ZXingFFI
         default_dpi: @config.default_dpi, max_dpi: @config.max_dpi, max_pixels: @config.max_pixels)
     end
 
-    # Adds page metadata and PDF page coordinates (points from the top-left of the displayed page).
-    def finalize(barcode, number, dpi)
-      page_position = dpi && barcode.position.map { |p| Geometry::Point.new((p.x * 72.0 / dpi).round(2), (p.y * 72.0 / dpi).round(2)) }
-      barcode.with(page: number, dpi: dpi, page_position: page_position)
+    # Adds page metadata and PDF page coordinates (points from the top-left of the displayed page); positions in a
+    # raster decoded downscaled are scaled back to the original's pixels.
+    def finalize(barcode, number, page)
+      dpi = page.dpi
+      position = barcode.position.transform(Geometry::Affine.scale(page.scale_to_base)).round
+      page_position = dpi && position.map { |p| Geometry::Point.new((p.x * 72.0 / dpi).round(2), (p.y * 72.0 / dpi).round(2)) }
+      barcode.with(position: position, page: number, dpi: dpi, page_position: page_position)
+    end
+
+    # The pixels a raster may declare, with the limit's name: max_source_pixels when +oversize: :downscale+ and its
+    # loader can decode it smaller to fit, otherwise max_pixels.
+    def raster_limit(kind)
+      return [@config.max_pixels, :max_pixels] unless @config.oversize == :downscale
+
+      downscales = begin
+        Loaders::Registry.loader_for(kind, config: @config, loader: @loader).downscales?
+      rescue LoaderUnavailable
+        false
+      end
+      downscales ? [@config.max_source_pixels, :max_source_pixels] : [@config.max_pixels, :max_pixels]
     end
 
     def select_pages(count)
@@ -239,7 +268,7 @@ module ZXingFFI
     end
 
     def effective_config(options)
-      overrides = options.slice(:max_dpi, :max_pixels, :max_pages)
+      overrides = options.slice(:max_dpi, :max_pixels, :max_source_pixels, :oversize, :max_pages)
       if @timeout
         overrides[:render_timeout] = [ZXingFFI.config.render_timeout, @timeout].compact.min
       end

data/lib/zxing_ffi/transformers/base.rb

@@ -7,6 +7,9 @@ module ZXingFFI
     # Geometry contract (shared with {Geometry.rotation_canvas}): {#rotate} turns the image clockwise as
     # displayed (y axis down) about its center and expands the canvas to the rotated bounding box, filling
     # uncovered areas with +background+. {#resize} scales both axes by +scale+ (output side = round(side × scale)).
+    # Upscales are bicubic (Catmull-Rom) with pixel centers aligned: output pixel x samples the input at
+    # (x + 0.5) / f - 0.5, f being output side / input side. Replicating pixels would keep the aliasing of codes
+    # rasterized at 1-2 px per module, which the high_res upscale is there to resolve.
     class Base
       class << self
         # @return [Symbol] registry name

data/lib/zxing_ffi/transformers/image_magick.rb

@@ -5,8 +5,8 @@ module ZXingFFI
     # Resize and rotate by piping PGM through ImageMagick.
     #
     # +-rotate+ turns clockwise and expands the canvas (ImageMagick's canvas can be 1 px larger than
-    # {Geometry.rotation_canvas}; the strategy re-centers on the actual size). Integer upscales use +-sample+
-    # (pixel replication); other scales use +-resize+.
+    # {Geometry.rotation_canvas}; the strategy re-centers on the actual size). Upscales use +-resize+ with the
+    # Catmull-Rom filter (+Catrom+); downscales use +-resize+ with its default filter.
     class ImageMagickTransformer < Base
       class << self
         def transformer_name = :image_magick
@@ -36,8 +36,8 @@ module ZXingFFI
 
         width = [(image.width * scale).round, 1].max
         height = [(image.height * scale).round, 1].max
-        operation = (scale == scale.to_i && scale >= 1) ? "-sample" : "-resize"
-        pipe(image, [operation, "#{width}x#{height}!"], width, height)
+        filter = (scale > 1) ? %w[-filter Catrom] : []
+        pipe(image, [*filter, "-resize", "#{width}x#{height}!"], width, height)
       end
 
       def rotate(image, degrees, background: 255)

data/lib/zxing_ffi/transformers/vips.rb

@@ -6,8 +6,8 @@ module ZXingFFI
     #
     # Quarter turns use +rot+ (exact); other angles use libvips' +rotate+, which turns clockwise about the center
     # and expands the canvas like {Geometry.rotation_canvas} (canvas sizes may differ by 1 px because libvips rounds
-    # where the geometry rounds up; the strategy re-centers on the actual output size). Integer upscales replicate
-    # pixels (+zoom+), which keeps bar edges crisp; other scales use a linear kernel.
+    # where the geometry rounds up; the strategy re-centers on the actual output size). Upscales go through
+    # +affine+ with the bicubic interpolator; downscales use +resize+ with a linear kernel.
     class VipsTransformer < Base
       QUARTER_TURNS = {90 => :d90, 180 => :d180, 270 => :d270}.freeze
 
@@ -39,13 +39,7 @@ module ZXingFFI
         raise ArgumentError, "scale must be positive, got #{scale.inspect}" unless scale.is_a?(Numeric) && scale.positive?
 
         vimage = to_vips(image)
-        out =
-          if scale == scale.to_i && scale >= 1
-            vimage.zoom(scale.to_i, scale.to_i)
-          else
-            vimage.resize(scale, kernel: :linear)
-          end
-        to_image(out)
+        to_image((scale > 1) ? upscale(vimage, scale) : vimage.resize(scale, kernel: :linear))
       end
 
       def rotate(image, degrees, background: 255)
@@ -66,6 +60,17 @@ module ZXingFFI
 
       private
 
+      # Not +resize+: its upscales sample a quarter input pixel off center, so at 2x the pixel straddling each
+      # black/white edge comes out mid-gray, right at the binarizer's threshold (crisp EAN-13s in the corpus misread).
+      def upscale(vimage, scale)
+        width = (vimage.width * scale).round
+        height = (vimage.height * scale).round
+        fx = width.to_f / vimage.width
+        fy = height.to_f / vimage.height
+        vimage.affine([fx, 0, 0, fy], interpolate: ::Vips::Interpolate.new("bicubic"), oarea: [0, 0, width, height],
+          idx: 0.5 - 0.5 / fx, idy: 0.5 - 0.5 / fy, extend: :copy)
+      end
+
       def to_vips(image)
         raise ArgumentError, "expected a :lum image, got #{image.format.inspect}" unless image.format == :lum
 

data/lib/zxing_ffi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ZXingFFI
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/vendor/lib/NOTICE.txt

@@ -1,4 +1,4 @@
-Bundled libZXing: zxing_ffi 0.1.0 (x86_64-linux-gnu)
+Bundled libZXing: zxing_ffi 0.2.0 (x86_64-linux-gnu)
 
 libZXing.so in this directory is zxing-cpp 3.1.1 (https://github.com/zxing-cpp/zxing-cpp),
 compiled from the release asset zxing-cpp-3.1.1.tar.gz (SHA-256 c3c02c29c0b519de7bd4e25b376e606e87f0761befd1282815642a2246613d14)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zxing_ffi
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: x86_64-linux-gnu
 authors:
 - Will Hibbard