qr_reader 0.0.1

data/lib/qr_reader/kernels/lzw.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+# LZW kernel shared by TIFF (compression 5) and PDF (LZWDecode). Kernel
+# files are plain Ruby in the subset that Spinel compiles (see DESIGN.md,
+# "Kernels").
+#
+# The code table holds no Strings: every entry is a stretch of the output
+# decoded so far (the previous code's output plus the first byte of the
+# output that followed it), so an entry is an offset and a length, and
+# decoding a code copies that stretch.
+module QrReaderKernels
+  # Codes decoded per lzw_batch call (YJIT compiles methods, not loops).
+  LZW_BATCH = 4096
+  # Entries up to this length are copied byte by byte, longer ones with
+  # byteslice (cheaper than allocating a slice for a few bytes).
+  LZW_SHORT = 3
+
+  # Decodes LZW data (codes of 9 to 12 bits, Clear 256, EOI 257) into at
+  # most +limit+ bytes. +early_change+ is 1 when the code width grows one
+  # code early (TIFF, PDF's default EarlyChange 1) or 0; +lsb_first+ reads
+  # codes least significant bit first (the old TIFF variant). Decoding
+  # stops at EOI, at the end of the data, at +limit+ bytes and at the
+  # first invalid code, keeping what was decoded before.
+  # spinel-sample: QrReaderKernels.lzw_decode("\x80\x0b\x60\x50\x22\x0c\x0c\x85\x01".b, 100, 1, false)
+  def self.lzw_decode(data, limit, early_change, lsb_first)
+    out = lzw_buffer
+    return out if limit <= 0
+
+    src = data + "\0\0\0\0"
+    offsets = Array.new(4096, 0)
+    lengths = Array.new(4096, 0)
+    # [bit position, next byte, bit buffer, bits in the buffer, code
+    # width, next code, previous output's offset and length (0: no
+    # previous code), 1 when done]
+    state = [0, 0, 0, 0, 9, 258, 0, 0, 0]
+    nbits = data.bytesize * 8
+    while state[8] == 0 && out.bytesize < limit
+      out << lzw_batch(src, nbits, out, offsets, lengths, state, early_change, lsb_first, limit - out.bytesize)
+    end
+    out.bytesize > limit ? out.byteslice(0, limit) : out
+  end
+
+  # An empty binary String (a helper: YJIT side-exits on the keyword call).
+  def self.lzw_buffer
+    String.new(capacity: 256, encoding: Encoding::BINARY)
+  end
+
+  # Decodes up to LZW_BATCH codes and returns their output. +out+ is the
+  # output so far (read only: table entries point into it), +state+ is
+  # updated in place.
+  def self.lzw_batch(src, nbits, out, offsets, lengths, state, early, lsb_first, room)
+    chunk = lzw_buffer
+    base = out.bytesize
+    pos = state[0]
+    i = state[1]
+    bits = state[2]
+    nb = state[3]
+    width = state[4]
+    nxt = state[5]
+    prev_off = state[6]
+    prev_len = state[7]
+    mask = (1 << width) - 1
+    done = 0
+    n = LZW_BATCH
+    while n > 0
+      if pos + width > nbits || chunk.bytesize >= room
+        done = 1
+        break
+      end
+      if lsb_first
+        while nb < width
+          bits |= src.getbyte(i) << nb
+          i += 1
+          nb += 8
+        end
+        code = bits & mask
+        bits >>= width
+      else
+        while nb < width
+          bits = ((bits << 8) | src.getbyte(i)) & 0xFFFFFF
+          i += 1
+          nb += 8
+        end
+        code = (bits >> (nb - width)) & mask
+      end
+      nb -= width
+      pos += width
+      if code == 256
+        nxt = 258
+        width = 9
+        mask = 511
+        prev_len = 0
+      elsif code == 257
+        done = 1
+        break
+      else
+        start = base + chunk.bytesize
+        if code < 256
+          chunk << code
+        else
+          if prev_len == 0 || code > nxt
+            # A code that is not in the table (yet).
+            done = 1
+            break
+          end
+          if code < nxt
+            off = offsets[code]
+            len = lengths[code]
+            extra = -1
+          else
+            # The code being defined: the previous output plus its first byte.
+            off = prev_off
+            len = prev_len
+            extra = off >= base ? chunk.getbyte(off - base) : out.getbyte(off)
+          end
+          # Copy the entry's stretch of output: +out+, then +chunk+ from
+          # offset +base+ on.
+          if off >= base
+            j = off - base
+            if len <= LZW_SHORT
+              stop = j + len
+              while j < stop
+                chunk << chunk.getbyte(j)
+                j += 1
+              end
+            else
+              # (A slice reaching the end of a String that grows later
+              # shares its buffer, and the next append copies it all.)
+              chunk << chunk.byteslice(j, len - 1) << chunk.getbyte(j + len - 1)
+            end
+          elsif off + len <= base
+            if len <= LZW_SHORT
+              stop = off + len
+              while off < stop
+                chunk << out.getbyte(off)
+                off += 1
+              end
+            else
+              chunk << out.byteslice(off, len - 1) << out.getbyte(off + len - 1)
+            end
+          else
+            head = base - off
+            chunk << out.byteslice(off, head - 1) << out.getbyte(base - 1)
+            chunk << chunk.byteslice(0, len - head - 1) << chunk.getbyte(len - head - 1)
+          end
+          chunk << extra if extra >= 0
+        end
+        if prev_len > 0 && nxt < 4096
+          offsets[nxt] = prev_off
+          lengths[nxt] = prev_len + 1
+          nxt += 1
+        end
+        prev_off = start
+        prev_len = base + chunk.bytesize - start
+        if width < 12 && nxt + early > mask
+          width += 1
+          mask = (1 << width) - 1
+        end
+      end
+      n -= 1
+    end
+    state[0] = pos
+    state[1] = i
+    state[2] = bits
+    state[3] = nb
+    state[4] = width
+    state[5] = nxt
+    state[6] = prev_off
+    state[7] = prev_len
+    state[8] = done
+    chunk
+  end
+end

data/lib/qr_reader/kernels/pixels.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+# Pixel conversion kernels: interleaved 8-bit samples to luminance, with
+# alpha composited over white. Plain Ruby in the subset Spinel compiles (see
+# DESIGN.md, "Kernels"); the per-row helpers are shared by the image
+# decoders' kernels (kernels/png.rb).
+#
+# Luminance is Rec. 601 with 10-bit fixed point weights (Image.luma):
+#   (306 * r + 601 * g + 117 * b + 0x200) >> 10
+# and a sample v with alpha a over white is
+#   (v * a + 255 * (255 - a) + 127) / 255 == ((v - 255) * a + 65_152) / 255
+# computed as (((v - 255) * a + 65_152) * 0x8081) >> 23: x / 255 equals
+# (x * 0x8081) >> 23 for every 0 <= x < 65_536, and the numerator is
+# 127..65_152 (a multiplication instead of a division call under YJIT).
+#
+# The row helpers reference no constants and allocate through px_buf (see
+# kernels/png.rb for why that matters to YJIT).
+module QrReaderKernels
+  # Luminance of +height+ rows of +width+ pixels of +stride+ bytes each.
+  # Row y starts at byte +offset+ + y * +pitch+ of +data+ (a negative pitch
+  # walks bottom-up rows; padding between rows is skipped). Channel byte
+  # offsets within a pixel: red +ro+, green +go+, blue +bo+, alpha +ao+;
+  # +go+ < 0 means a single gray sample at +ro+, +ao+ < 0 means opaque.
+  # Returns width * height luminance bytes.
+  # spinel-sample: QrReaderKernels.pixels_luma("\x01\x02\x03\x04".b, 0, 4, 1, 1, 4, 0, 1, 2, 3)
+  def self.pixels_luma(data, offset, pitch, width, height, stride, ro, go, bo, ao)
+    last = offset + (height - 1) * pitch
+    first = last < offset ? last : offset
+    if width < 1 || height < 1 || stride < 1 || first < 0 || (last > offset ? last : offset) + width * stride > data.bytesize
+      raise QrReader::ImageError, "pixel data too short"
+    end
+
+    out = px_buf(width * height)
+    off = offset
+    y = 0
+    while y < height
+      out << px_row(data, off, width, stride, ro, go, bo, ao)
+      off += pitch
+      y += 1
+    end
+    out
+  end
+
+  # An empty binary String with room for +size+ bytes.
+  def self.px_buf(size)
+    String.new(capacity: size)
+  end
+
+  # One row of pixels_luma (dispatch only: the loops live in helpers that
+  # YJIT compiles separately).
+  def self.px_row(src, off, n, stride, ro, go, bo, ao)
+    if go < 0
+      if ao < 0
+        stride == 1 ? (src.byteslice(off + ro, n) || "") : px_gray_row(src, off, n, ro, stride)
+      else
+        px_gray_alpha_row(src, off, n, ro, ao, stride)
+      end
+    elsif ao < 0
+      px_rgb_row(src, off, n, ro, go, bo, stride)
+    else
+      px_rgba_row(src, off, n, ro, go, bo, ao, stride)
+    end
+  end
+
+  # Every +stride+-th byte starting at +off+ + +vo+ (e.g. the high bytes of
+  # 16-bit samples).
+  def self.px_gray_row(src, off, n, vo, stride)
+    row = px_buf(n)
+    i = off + vo
+    stop = i + n * stride
+    while i < stop
+      row << src.getbyte(i)
+      i += stride
+    end
+    row
+  end
+
+  def self.px_gray_alpha_row(src, off, n, vo, ao, stride)
+    row = px_buf(n)
+    i = off
+    stop = off + n * stride
+    while i < stop
+      a = src.getbyte(i + ao)
+      v = src.getbyte(i + vo)
+      row << (a == 255 ? v : (((v - 255) * a + 65_152) * 0x8081) >> 23)
+      i += stride
+    end
+    row
+  end
+
+  def self.px_rgb_row(src, off, n, ro, go, bo, stride)
+    row = px_buf(n)
+    i = off
+    stop = off + n * stride
+    while i < stop
+      row << ((306 * src.getbyte(i + ro) + 601 * src.getbyte(i + go) + 117 * src.getbyte(i + bo) + 0x200) >> 10)
+      i += stride
+    end
+    row
+  end
+
+  def self.px_rgba_row(src, off, n, ro, go, bo, ao, stride)
+    row = px_buf(n)
+    i = off
+    stop = off + n * stride
+    while i < stop
+      v = (306 * src.getbyte(i + ro) + 601 * src.getbyte(i + go) + 117 * src.getbyte(i + bo) + 0x200) >> 10
+      a = src.getbyte(i + ao)
+      row << (a == 255 ? v : (((v - 255) * a + 65_152) * 0x8081) >> 23)
+      i += stride
+    end
+    row
+  end
+end