qr_reader 0.0.1

data/lib/qr_reader/formats/png.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+require "zlib"
+require_relative "../kernels/png"
+
+module QrReader
+  module Formats
+    # PNG decoder: every colour type and bit depth (1/2/4/8/16), PLTE + tRNS,
+    # alpha composited over white, Adam7 interlacing, any number of IDAT chunks.
+    # Ancillary chunks (gamma, colour profiles, text, APNG frames, ...) are
+    # ignored, and chunk CRCs are not verified (like most lenient decoders).
+    #
+    # The image data is inflated as a stream and handed to the PNG kernel
+    # (QrReaderKernels.png_rows, kernels/png.rb) about a megabyte at a time:
+    # the kernel unfilters the rows and converts them to luminance in one
+    # pass, so the whole inflated image never exists at once. Palette and
+    # grayscale images of up to 8 bits come out of the kernel as unfiltered
+    # rows; 1 and 4-bit samples are spread to one character per sample with
+    # String#unpack1 ("B" / "H", C speed) and everything is mapped to
+    # luminance with a single String#tr at the end. 16-bit samples keep
+    # their high byte.
+    module PNG
+      SIGNATURE = "\x89PNG\r\n\x1A\n".b
+
+      # colour type => [channels, allowed bit depths]
+      COLOR_TYPES = {
+        0 => [1, [1, 2, 4, 8, 16]], # grayscale
+        2 => [3, [8, 16]],          # RGB
+        3 => [1, [1, 2, 4, 8]],     # palette
+        4 => [2, [8, 16]],          # grayscale + alpha
+        6 => [4, [8, 16]]           # RGBA
+      }.freeze
+
+      # Adam7 passes: [x0, y0, dx, dy].
+      ADAM7 = [[0, 0, 8, 8], [4, 0, 8, 8], [0, 4, 4, 8], [2, 0, 4, 4], [0, 2, 2, 4], [1, 0, 2, 2], [0, 1, 1, 2]].freeze
+
+      # Bytes standing for the sample values 0, 1, ... after String#unpack1
+      # spread 1-bit ("B") and 4-bit ("H") rows: the String#tr sources.
+      UNPACKED_CODES = { 1 => "01".bytes.freeze, 4 => "0123456789abcdef".bytes.freeze }.freeze
+
+      # Compressed bytes fed to zlib at a time (bounds the work done for
+      # zip bombs: the output of one slice is at most ~66 MB, streamed).
+      INFLATE_SLICE = 1 << 16
+      # Inflated bytes collected before a kernel call (bounds memory).
+      KERNEL_SLICE = 1 << 20
+
+      class << self
+        def decode(bytes)
+          Decoder.new(Support.binary(bytes)).decode
+        end
+
+        def dimensions(bytes)
+          Decoder.new(Support.binary(bytes), header_only: true).dimensions
+        end
+      end
+
+      # Parses the chunk structure and produces the luminance image.
+      class Decoder
+        def initialize(bytes, header_only: false)
+          @bytes = bytes
+          raise ImageError, "not a PNG file" unless bytes.start_with?(SIGNATURE)
+
+          read_chunks(header_only)
+        end
+
+        def dimensions
+          [@width, @height]
+        end
+
+        def decode
+          raise ImageError, "PNG has no image data (IDAT)" if @idat.empty?
+          raise ImageError, "palette PNG without PLTE chunk" if @color_type == 3 && @palette.nil?
+
+          setup_conversion
+          w = @width
+          h = @height
+          if @interlaced
+            raw = inflate_all(ADAM7.sum { |pass| pass_size(pass) })
+            out = QrReaderKernels.png_adam7(raw, w, h, @depth, @channels, @key)
+            codes = ALL_BYTES
+          else
+            out = decode_stream
+            codes = ALL_BYTES
+            out, codes = unpack_samples(out) if @depth < 8
+          end
+          Support.translate!(out, codes.first(@tr_to.size), @tr_to) if @tr_to
+          Image.new(w, h, out)
+        end
+
+        private
+
+        def read_chunks(header_only)
+          bytes = @bytes
+          size = bytes.bytesize
+          pos = 8
+          @idat = []
+          while pos + 8 <= size
+            length, type = bytes.unpack("Na4", offset: pos)
+            body_pos = pos + 8
+            if body_pos + length > size
+              # Once image data has started, keep what is there: the pixel
+              # data may be complete (decode raises if it is not).
+              raise ImageError, "truncated PNG chunk #{type.inspect}" if @idat.empty? && type != "IDAT"
+
+              @idat << [body_pos, size - body_pos] if type == "IDAT"
+              break
+            end
+
+            if pos == 8
+              raise UnsupportedImageError, "Apple-optimised (CgBI) PNGs are not supported" if type == "CgBI"
+              raise ImageError, "PNG does not start with IHDR" unless type == "IHDR"
+
+              read_header(bytes.byteslice(body_pos, length))
+              return if header_only
+            else
+              case type
+              when "IDAT" then @idat << [body_pos, length]
+              when "PLTE" then @palette ||= bytes.byteslice(body_pos, length - length % 3)
+              when "tRNS" then @trns ||= bytes.byteslice(body_pos, length)
+              when "IEND" then break
+              end
+            end
+            pos = body_pos + length + 4 # skip CRC
+          end
+          raise ImageError, "truncated PNG (no IHDR)" unless @width
+        end
+
+        def read_header(ihdr)
+          raise ImageError, "invalid PNG IHDR chunk" if ihdr.bytesize < 13
+
+          @width, @height, @depth, @color_type, compression, filter, interlace = ihdr.unpack("NNCCCCC")
+          @channels, depths = COLOR_TYPES[@color_type]
+          raise ImageError, "invalid PNG colour type #{@color_type}" unless @channels
+          unless depths.include?(@depth)
+            raise ImageError, "invalid PNG bit depth #{@depth} for colour type #{@color_type}"
+          end
+          raise ImageError, "unknown PNG compression/filter method" unless compression.zero? && filter.zero?
+          raise ImageError, "unknown PNG interlace method #{interlace}" if interlace > 1
+          raise ImageError, "PNG dimensions exceed 2^31 - 1" if @width > 0x7FFFFFFF || @height > 0x7FFFFFFF
+
+          Support.check_dimensions(@width, @height, "PNG")
+          @interlaced = interlace == 1
+        end
+
+        def row_bytes(width)
+          (width * @channels * @depth + 7) >> 3
+        end
+
+        # Raw (filtered) byte count of an Adam7 pass.
+        def pass_size((x0, y0, dx, dy))
+          pw = (@width - x0 + dx - 1) / dx
+          ph = (@height - y0 + dy - 1) / dy
+          pw <= 0 || ph <= 0 ? 0 : ph * (1 + row_bytes(pw))
+        end
+
+        # Chooses the colour key passed to the kernel and the final
+        # String#tr mapping of sample values (@tr_to[value] = luminance).
+        def setup_conversion
+          depth = @depth
+          trns = @trns
+          @key = "".b
+          case @color_type
+          when 0
+            key = trns.unpack1("n") if trns && trns.bytesize >= 2
+            max = (1 << depth) - 1
+            if depth == 16
+              @key = trns.byteslice(0, 2) if key
+            elsif depth == 8
+              if key && key <= 255
+                @tr_to = ALL_BYTES.dup
+                @tr_to[key] = 255
+              end
+            else
+              @tr_to = Array.new(max + 1) { |v| v * 255 / max }
+              @tr_to[key] = 255 if key && key <= max
+            end
+          when 2
+            if trns && trns.bytesize >= 6
+              rgb = trns.unpack("nnn")
+              # (an 8-bit image cannot contain a key beyond 255: no key)
+              @key = depth == 16 ? trns.byteslice(0, 6) : (rgb.max <= 255 ? rgb.pack("C3") : "".b)
+            end
+          when 3
+            @tr_to = Support.palette_lumas(@palette, alpha: trns).first(1 << depth)
+          end
+        end
+
+        # Packed 1, 2 and 4-bit rows -> one byte per sample, and the bytes
+        # that stand for the sample values 0, 1, ...
+        def unpack_samples(packed)
+          w = @width
+          depth = @depth
+          len = row_bytes(w)
+          if depth == 2
+            return [QrReaderKernels.png_unpack_rows(packed, @height, w, len, 2), ALL_BYTES]
+          end
+
+          format = depth == 1 ? "B" : "H"
+          if (w * depth) % 8 == 0
+            out = packed.unpack1("#{format}*")
+          else
+            out = Support.buffer(w * @height)
+            spec = "#{format}#{w}"
+            off = 0
+            while off < packed.bytesize
+              out << packed.unpack1(spec, offset: off)
+              off += len
+            end
+          end
+          [out.b, UNPACKED_CODES[depth]]
+        end
+
+        # Inflates the image data in slices and feeds complete rows to the
+        # kernel; returns the converted image (width * height bytes, or the
+        # unfiltered rows of gray/palette images of less than 8 bits).
+        def decode_stream
+          w = @width
+          rows_left = @height
+          len = row_bytes(w)
+          stride = len + 1
+          @row_out = @channels == 1 && @depth <= 8 ? len : w
+          batch = [KERNEL_SLICE / stride, 1].max * stride
+          out = Support.buffer([@row_out * @height, compressed_size * 1032 + 1024].min)
+          prev = "".b
+          pending = nil
+          each_inflated do |data|
+            next if @enough
+
+            if pending
+              pending << data
+            else
+              pending = +data
+            end
+            next if pending.bytesize < batch
+
+            n = [pending.bytesize / stride, rows_left].min
+            prev = convert_rows(pending, n, w, prev, out)
+            rows_left -= n
+            @enough = rows_left.zero?
+            pending = @enough ? nil : pending.byteslice(n * stride, pending.bytesize - n * stride)
+          end
+          if rows_left.positive?
+            n = pending ? pending.bytesize / stride : 0
+            truncated!(@height - rows_left + n, @height, "rows") if n < rows_left
+
+            convert_rows(pending, rows_left, w, prev, out)
+          end
+          out
+        end
+
+        def truncated!(got, expected, unit)
+          raise ImageError, "corrupt PNG image data (zlib: #{@zlib_error.message})" if @zlib_error
+
+          raise ImageError, "truncated PNG image data (#{got} of #{expected} #{unit})"
+        end
+
+        # Runs the kernel on +n+ rows at the start of +raw+, appends their
+        # output to +out+; returns the last unfiltered row.
+        def convert_rows(raw, n, w, prev, out)
+          res = QrReaderKernels.png_rows(raw, 0, n, w, @depth, @channels, prev, @key)
+          size = n * @row_out
+          out << res.byteslice(0, size)
+          res.byteslice(size, res.bytesize - size)
+        end
+
+        def compressed_size
+          @idat.sum { |_, length| length }
+        end
+
+        # Yields the inflated IDAT payload in pieces, until the consumer
+        # sets @enough.
+        def each_inflated(&block)
+          zstream = Zlib::Inflate.new
+          @idat.each do |pos, length|
+            stop = pos + length
+            while pos < stop
+              return if @enough
+
+              n = [stop - pos, INFLATE_SLICE].min
+              zstream.inflate(@bytes.byteslice(pos, n), &block)
+              pos += n
+            end
+          end
+        rescue Zlib::Error => e
+          # Data inflated before the error was used; what is missing is
+          # reported as truncation by the caller.
+          @zlib_error = e
+        ensure
+          if zstream
+            zstream.reset # an unfinished stream would warn on close
+            zstream.close
+          end
+        end
+
+        # Inflates the whole IDAT payload; returns at least +expected+ bytes.
+        def inflate_all(expected)
+          # Deflate expands at most 1032:1, so a few bytes of data that
+          # claim a huge image never reserve (and touch) the claimed size.
+          out = Support.buffer([expected, compressed_size * 1032 + 1024].min)
+          each_inflated do |data|
+            out << data unless @enough
+            @enough = out.bytesize >= expected
+          end
+          truncated!(out.bytesize, expected, "bytes") if out.bytesize < expected
+          out
+        end
+      end
+      private_constant :Decoder
+    end
+  end
+end

data/lib/qr_reader/formats/pnm.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+module QrReader
+  module Formats
+    # Netpbm decoder: PBM/PGM/PPM in plain (P1-P3) and raw (P4-P6) form with
+    # any maxval up to 65535 and comments anywhere in the header, and PAM (P7)
+    # with the BLACKANDWHITE, GRAYSCALE and RGB tuple types (and their _ALPHA
+    # variants, composited over white). Only the first image of a multi-image
+    # file is read. Samples are scaled to 8 bits with rounding, except that
+    # maxval 65535 keeps the high byte (like PNG).
+    module PNM
+      # Whitespace and comments (atomic, so a failed match cannot backtrack
+      # through them), then the next header token.
+      HEADER_INT = /\G(?>(?:\s|#[^\r\n]*)*)(\d+)/n
+      PAM_LINE = /\G(?>(?:\s|#[^\r\n]*)*)([A-Za-z_]+)[ \t]*([^\r\n]*)/n
+      COMMENT = /#[^\r\n]*/n
+      LINE_END = /[\r\n]/n
+      NOT_PLAIN_SAMPLE = /[^0-9 \t\n\v\f\r]/n
+      LEADING_INT = /\A\s*(\d+)/n
+      PBM_LUMA = "\xFF\x00".b # "0" white, "1" black
+      SEPARATORS = WHITESPACE.bytes.freeze
+
+      # PAM tuple type => channel count.
+      TUPLE_TYPES = {
+        "BLACKANDWHITE" => 1, "GRAYSCALE" => 1, "RGB" => 3,
+        "BLACKANDWHITE_ALPHA" => 2, "GRAYSCALE_ALPHA" => 2, "RGB_ALPHA" => 4
+      }.freeze
+
+      class << self
+        def decode(bytes)
+          Decoder.new(Support.binary(bytes)).decode
+        end
+
+        def dimensions(bytes)
+          Decoder.new(Support.binary(bytes)).dimensions
+        end
+      end
+
+      # Parses the header on creation; @pos then points at the raster.
+      class Decoder
+        def initialize(bytes)
+          raise ImageError, "not a PNM file" unless PNM_MAGIC.match?(bytes)
+
+          @bytes = bytes
+          @kind = bytes.getbyte(1) - 48
+          @pos = 2
+          if @kind == 7
+            raise UnsupportedImageError, "XV thumbnail images (P7 332) are not supported" if bytes.start_with?("P7 332")
+
+            read_pam_header
+          else
+            @width = read_int
+            @height = read_int
+            @maxval = @kind == 1 || @kind == 4 ? 1 : read_int
+            @channels = @kind == 3 || @kind == 6 ? 3 : 1
+          end
+          raise ImageError, "invalid PNM maxval #{@maxval}" unless @maxval.between?(1, 65_535)
+
+          Support.check_dimensions(@width, @height, "PNM")
+          skip_raster_separator if @kind >= 4 && @kind <= 6
+        end
+
+        def dimensions
+          [@width, @height]
+        end
+
+        def decode
+          gray =
+            case @kind
+            when 1 then plain_bits
+            when 2, 3 then luminance(plain_samples)
+            when 4 then packed_bits
+            else raw_luminance
+            end
+          Image.new(@width, @height, gray)
+        end
+
+        private
+
+        def read_int
+          m = HEADER_INT.match(@bytes, @pos) or raise ImageError, "invalid or truncated PNM header"
+          raise ImageError, "invalid PNM header value" if m[1].bytesize > 10
+
+          @pos = m.end(0)
+          m[1].to_i
+        end
+
+        # Exactly one whitespace byte separates the header from raw rasters.
+        # A comment may also follow the last header value directly; then the
+        # end of its line is the separator (as in libnetpbm and ImageMagick).
+        def skip_raster_separator
+          byte = @bytes.getbyte(@pos)
+          if byte == 35 # "#"
+            eol = @bytes.byteindex(LINE_END, @pos) or raise ImageError, "truncated PNM header"
+            @pos = eol + 1
+            return
+          end
+          raise ImageError, "truncated PNM header" unless SEPARATORS.include?(byte)
+
+          @pos += 1
+        end
+
+        def read_pam_header
+          fields = {}
+          tuple_type = []
+          loop do
+            m = PAM_LINE.match(@bytes, @pos) or raise ImageError, "invalid or truncated PAM header"
+            @pos = m.end(0)
+            key = m[1].upcase
+            case key
+            when "ENDHDR" then break
+            when "TUPLTYPE" then tuple_type << m[2].strip
+            when "WIDTH", "HEIGHT", "DEPTH", "MAXVAL"
+              value = LEADING_INT.match(m[2]) or raise ImageError, "invalid PAM #{key}"
+              raise ImageError, "invalid PAM #{key}" if value[1].bytesize > 10
+
+              fields[key] = value[1].to_i
+            end
+          end
+          @pos += 1 if @bytes.getbyte(@pos) == 13
+          @pos += 1 if @bytes.getbyte(@pos) == 10
+
+          missing = %w[WIDTH HEIGHT DEPTH MAXVAL] - fields.keys
+          raise ImageError, "PAM header lacks #{missing.join(', ')}" unless missing.empty?
+
+          @width, @height, @maxval = fields.values_at("WIDTH", "HEIGHT", "MAXVAL")
+          @channels = fields["DEPTH"]
+          check_tuple_type(tuple_type.join(" "))
+        end
+
+        # Unknown tuple types are inferred from the depth, except that four
+        # channels of unknown meaning are most likely CMYK.
+        def check_tuple_type(type)
+          raise ImageError, "invalid PAM depth 0" if @channels.zero?
+          raise UnsupportedImageError, "PAM depth #{@channels} is not supported" if @channels > 4
+
+          expected = TUPLE_TYPES[type]
+          if expected && expected != @channels
+            raise ImageError, "PAM tuple type #{type} does not have depth #{@channels}"
+          end
+          return unless !expected && @channels == 4 && !type.empty?
+
+          raise UnsupportedImageError, "PAM tuple type #{type.inspect} is not supported"
+        end
+
+        def sample_count
+          @width * @height * @channels
+        end
+
+        # Luminance of a raw (binary) raster. Samples of maxval 65535 are
+        # read in place (their high bytes); other maxvals are scaled first.
+        def raw_luminance
+          wide = @maxval > 255
+          size = sample_count * (wide ? 2 : 1)
+          raw = @bytes.byteslice(@pos, size)
+          raise ImageError, "truncated PNM pixel data" if raw.nil? || raw.bytesize < size
+
+          if !wide
+            luminance(@maxval == 255 ? raw : Support.translate!(raw, ALL_BYTES, scale_table(255)))
+          elsif @maxval == 65_535
+            luminance(raw, 2)
+          else
+            luminance(scale16(raw))
+          end
+        end
+
+        # Big-endian 16-bit samples (maxval 256..65534) scaled to 8 bits.
+        def scale16(raw)
+          max = @maxval
+          table = scale_table(max)
+          step = @width * @channels
+          out = Support.buffer(raw.bytesize / 2)
+          off = 0
+          @height.times do # row by row, so that YJIT compiles scale16_row
+            scale16_row(raw, off, step, table, max, out)
+            off += 2 * step
+          end
+          out
+        end
+
+        def scale16_row(raw, i, n, table, max, out)
+          stop = i + 2 * n
+          while i < stop
+            v = (raw.getbyte(i) << 8) | raw.getbyte(i + 1)
+            out << (v >= max ? 255 : table[v])
+            i += 2
+          end
+        end
+
+        # 8-bit samples of a plain (ASCII) raster. Digits and whitespace
+        # only (the usual case) are split at C speed, anything else is
+        # scanned for numbers.
+        def plain_samples
+          text = @bytes.byteslice(@pos, @bytes.bytesize - @pos).gsub(COMMENT, "")
+          values = NOT_PLAIN_SAMPLE.match?(text) ? text.scan(/\d+/) : text.split
+          n = sample_count
+          raise ImageError, "truncated PNM pixel data" if values.size < n
+
+          scale_values(values.first(n).map!(&:to_i))
+        end
+
+        # Sample value -> 8 bits; values above maxval saturate. Maxval 65535
+        # keeps the high byte, the same as raw rasters and 16-bit PNG.
+        def scale_table(top)
+          max = @maxval
+          return Array.new(top + 1) { |v| v >> 8 } if max == 65_535
+
+          Array.new(top + 1) { |v| v >= max ? 255 : (v * 255 + max / 2) / max }
+        end
+
+        def scale_values(values)
+          max = @maxval
+          table = scale_table(max)
+          n = values.size
+          out = Support.buffer(n)
+          step = @width * @channels
+          i = 0
+          while i < n # row by row, so that YJIT compiles scale_row
+            scale_row(values, i, [i + step, n].min, table, max, out)
+            i += step
+          end
+          out
+        end
+
+        def scale_row(values, i, stop, table, max, out)
+          while i < stop
+            v = values[i]
+            out << (v >= max ? 255 : table[v])
+            i += 1
+          end
+        end
+
+        # Gray, gray+alpha, RGB or RGBA samples -> luminance. +size+ is the
+        # sample size in bytes: of 16-bit samples only the high byte is read.
+        def luminance(samples, size = 1)
+          return samples if @channels == 1 && size == 1
+
+          w = @width
+          step = w * @channels * size
+          out = Support.buffer(w * @height)
+          table = Support.over_white_table if @channels.even?
+          off = 0
+          @height.times do
+            luminance_row(samples, off, size, table, out)
+            off += step
+          end
+          out
+        end
+
+        def luminance_row(samples, off, s, table, out)
+          w = @width
+          case @channels
+          when 1 then Rows.high_bytes(samples, off, w, out) # 16-bit only: 8-bit gray is returned as is
+          when 2 then Rows.gray_alpha(samples, off, w, out, table, s, 2 * s)
+          when 3 then Rows.rgb(samples, off, w, out, 0, s, 2 * s, 3 * s)
+          else Rows.rgba(samples, off, w, out, table, 0, s, 2 * s, 3 * s, 4 * s)
+          end
+        end
+
+        # P1: "1" is black; digits need not be separated.
+        def plain_bits
+          n = @width * @height
+          bits = @bytes.byteslice(@pos, @bytes.bytesize - @pos).gsub(COMMENT, "").delete(WHITESPACE).byteslice(0, n)
+          raise ImageError, "truncated PBM pixel data" if bits.bytesize < n || bits.count("01") < n
+
+          bits.tr!("01", PBM_LUMA)
+          bits
+        end
+
+        # P4: rows of MSB-first bits padded to whole bytes; 1 is black.
+        def packed_bits
+          w = @width
+          stride = (w + 7) >> 3
+          raise ImageError, "truncated PBM pixel data" if @pos + stride * @height > @bytes.bytesize
+
+          out = Support.buffer(w * @height)
+          format = "B#{w}"
+          @height.times { |y| out << @bytes.unpack1(format, offset: @pos + y * stride) }
+          out.tr!("01", PBM_LUMA)
+          out
+        end
+      end
+      private_constant :Decoder
+    end
+  end
+end