pdfrb 0.3.0 → 0.7.1

data/lib/pdfrb/image/downsampler.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Pdfrb
+  module Image
+    # Pure-Ruby nearest-neighbour downsampler for FlateDecode-encoded
+    # image XObjects. JPEG (DCTDecode) and JPEG2000 (JPXDecode) streams
+    # can't be re-encoded without native deps, so they're skipped.
+    #
+    # The decoder side uses Filter::FlateDecode and the existing
+    # PNGPredictor for /DecodeParms row reconstruction. The encoder
+    # re-deflates and writes predictor rows with filter byte 0 (None),
+    # which the spec allows.
+    module Downsampler
+      module_function
+
+      # Downsample +image+ by +factor+ (>=2) using nearest-neighbour.
+      # Mutates the image's stream and /Width, /Height, /Length keys.
+      # Returns the image if changes were made, nil otherwise.
+      def downsample!(image, factor:)
+        return nil unless factor && factor >= 2
+        return nil unless eligible?(image)
+
+        width = image.value[:Width]
+        height = image.value[:Height]
+        bpc = image.value[:BitsPerComponent] || 8
+        channels = Audit.channels_for(image.value[:ColorSpace])
+        bytes_per_pixel = (channels * bpc) / 8
+        return nil unless bytes_per_pixel.positive?
+
+        decoded = decode(image, width, height, bytes_per_pixel)
+        return nil unless decoded
+
+        new_w = width / factor
+        new_h = height / factor
+        return nil if new_w.zero? || new_h.zero?
+
+        sampled = sample_nearest(decoded, width, new_w, new_h,
+                                 bytes_per_pixel, factor)
+        encoded = encode(image, sampled, new_w, new_h, bytes_per_pixel)
+        return nil unless encoded
+
+        image.stream = encoded
+        image.value[:Width] = new_w
+        image.value[:Height] = new_h
+        image.value[:Length] = encoded.bytesize
+        image
+      end
+
+      # Eligibility: FlateDecode (with or without PNG predictor),
+      # 8 bpc, single-component (gray), RGB, or CMYK (not Indexed,
+      # which has a palette that mustn't be re-sampled).
+      def eligible?(image)
+        return false unless image.is_a?(Pdfrb::Model::Cos::Stream)
+
+        filter = image.value[:Filter]
+        return false unless filter == :FlateDecode
+
+        return false unless (image.value[:BitsPerComponent] || 8) == 8
+
+        color_space = image.value[:ColorSpace]
+        return false if color_space == :Indexed
+        return false if color_space.is_a?(::Array) && color_space.first == :Indexed
+
+        image.value[:Width] && image.value[:Height] && image.stream
+      end
+
+      # Decode the stream back to raw pixel bytes. Handles PNG
+      # predictor rows when /DecodeParms is present.
+      def decode(image, width, _height, bytes_per_pixel)
+        inflated = Zlib::Inflate.inflate(image.stream)
+        params = image.value[:DecodeParms]
+        return inflated unless params
+
+        predictor = params.is_a?(::Hash) ? params[:Predictor] : nil
+        return inflated unless predictor && predictor >= 10
+
+        columns = (params.is_a?(::Hash) ? params[:Columns] : nil) || width
+        Pdfrb::Filter::PNGPredictor.decode(
+          inflated,
+          predictor: predictor,
+          columns: columns,
+          colors: (params[:Colors] if params.is_a?(::Hash)) ||
+                  bytes_per_pixel,
+          bits_per_component: (params[:BitsPerComponent] if params.is_a?(::Hash)) || 8
+        )
+      end
+
+      # Nearest-neighbour sampling. Picks every factor-th pixel in
+      # both dimensions.
+      def sample_nearest(decoded, _orig_w, new_w, new_h, bytes_per_pixel, factor)
+        out = +""
+        new_h.times do |new_y|
+          src_y = new_y * factor
+          new_w.times do |new_x|
+            src_x = new_x * factor
+            offset = ((src_y * _orig_w) + src_x) * bytes_per_pixel
+            out << decoded.byteslice(offset, bytes_per_pixel)
+          end
+        end
+        out.force_encoding(Encoding::BINARY)
+      end
+
+      # Re-encode +pixels+ as FlateDecode, applying the same predictor
+      # scheme the image originally used (or uncompressed if none).
+      def encode(image, pixels, new_w, new_h, bytes_per_pixel)
+        params = image.value[:DecodeParms]
+        predictor = params.is_a?(::Hash) ? params[:Predictor] : nil
+        if predictor && predictor >= 10
+          row_len = new_w * bytes_per_pixel
+          prefixed = +""
+          new_h.times do |row|
+            offset = row * row_len
+            prefixed << "\x00".b
+            prefixed << pixels.byteslice(offset, row_len)
+          end
+          pixels = prefixed
+        end
+        Zlib::Deflate.deflate(pixels)
+      end
+    end
+  end
+end

data/lib/pdfrb/image.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  # Image-related utilities. Image *loaders* (JPEG/PNG/PDF) live under
+  # Pdfrb::ImageLoader; this module hosts higher-level operations on
+  # already-embedded image XObjects: audit (metadata extraction) and
+  # downsampling (pure-Ruby nearest-neighbour for FlateDecode-encoded
+  # pixel data).
+  module Image
+    autoload :Audit, "pdfrb/image/audit"
+    autoload :Downsampler, "pdfrb/image/downsampler"
+  end
+end

data/lib/pdfrb/image_loader/jpeg.rb

@@ -2,89 +2,70 @@
 
 module Pdfrb
   module ImageLoader
-    # JPEG loader. Parses the SOI/SOFn marker stream to extract width,
-    # height, bits-per-component, and number of components. The raw
-    # JPEG bytes are stored verbatim with /Filter /DCTDecode — no
-    # re-encoding.
     module JPEG
-      SOI = "\xFF\xD8".b
-      SOFN_MARKERS = [
-        0xFFC0, 0xFFC1, 0xFFC2, 0xFFC3,
-        0xFFC5, 0xFFC6, 0xFFC7,
-        0xFFC9, 0xFFCA, 0xFFCB,
-        0xFFCD, 0xFFCE, 0xFFCF
-      ].freeze
-      private_constant :SOI, :SOFN_MARKERS
-
       module_function
 
-      def call(document, bytes, **_opts)
-        return nil unless bytes.is_a?(::String) && bytes.start_with?(SOI)
+      def call(document, data, **_opts)
+        data = data.read if data.is_a?(IO) || data.is_a?(StringIO)
+        info = parse_header(data)
+        return nil if info.empty?
 
-        info = parse_header(bytes)
         image = document.add(
           {
             Type: :XObject,
             Subtype: :Image,
             Width: info[:width],
             Height: info[:height],
-            BitsPerComponent: info[:precision],
             ColorSpace: info[:color_space],
-            Filter: :DCTDecode
+            BitsPerComponent: info[:bits],
+            Filter: :DCTDecode,
+            Length: data.bytesize,
           },
           type: Pdfrb::Model::Type::XObjectImage
         )
-        image.stream = bytes.b
+        image.stream = data
         image
       end
 
-      def parse_header(bytes)
-        i = 2 # skip SOI marker
-        while i + 1 < bytes.bytesize
-          marker = bytes.getbyte(i) * 256 + bytes.getbyte(i + 1)
+      def parse_header(data)
+        return {} unless data.is_a?(String) && data.bytesize >= 6
+        return {} unless data.getbyte(0) == 0xFF && data.getbyte(1) == 0xD8
+
+        i = 2
+        while i < data.bytesize - 1
+          break unless data.getbyte(i) == 0xFF
+
+          marker = data.getbyte(i + 1)
           i += 2
-          # Standalone markers (no length): RSTn, SOI, EOI, TEM.
-          standalone = (0xFFD0..0xFFD7).include?(marker) ||
-                       marker == 0xFF01 || marker == 0xFFD8 || marker == 0xFFD9
-          if SOFN_MARKERS.include?(marker)
-            return parse_sofn(bytes, i)
-          elsif standalone
-            next
-          else
-            length = bytes.getbyte(i) * 256 + bytes.getbyte(i + 1)
-            i += length
+
+          next if marker.between?(0xD0, 0xD9)
+          next if marker == 0x01
+
+          break if i + 1 >= data.bytesize
+
+          seg_len = (data.getbyte(i) << 8) | data.getbyte(i + 1)
+
+          if marker.between?(0xC0, 0xCF) && marker != 0xC4 && marker != 0xC8 && marker != 0xCC
+            return parse_sof(data, i)
           end
+
+          i += seg_len
         end
-        raise Pdfrb::Error, "JPEG: no SOFn marker found"
+        {}
       end
-      private_class_method :parse_header
 
-      def parse_sofn(bytes, i)
-        # SOFn layout: precision(1), height(2), width(2), components(1)
-        _length = bytes.getbyte(i) * 256 + bytes.getbyte(i + 1)
-        precision = bytes.getbyte(i + 2)
-        height = bytes.getbyte(i + 3) * 256 + bytes.getbyte(i + 4)
-        width = bytes.getbyte(i + 5) * 256 + bytes.getbyte(i + 6)
-        components = bytes.getbyte(i + 7)
+      def parse_sof(data, offset)
         {
-          precision: precision,
-          width: width,
-          height: height,
-          components: components,
-          color_space: color_space_for(components)
+          bits: data.getbyte(offset + 2),
+          height: (data.getbyte(offset + 3) << 8) | data.getbyte(offset + 4),
+          width: (data.getbyte(offset + 5) << 8) | data.getbyte(offset + 6),
+          color_space: case data.getbyte(offset + 7)
+                       when 1 then :DeviceGray
+                       when 4 then :DeviceCMYK
+                       else :DeviceRGB
+                       end,
         }
       end
-      private_class_method :parse_sofn
-
-      def color_space_for(n)
-        case n
-        when 1 then :DeviceGray
-        when 3 then :DeviceRGB
-        when 4 then :DeviceCMYK
-        else raise Pdfrb::Error, "JPEG: unsupported component count #{n}"
-        end
-      end
-      private_class_method :color_space_for
     end
   end
 end

data/lib/pdfrb/image_loader/png.rb

@@ -1,282 +1,113 @@
 # frozen_string_literal: true
 
-require "zlib"
-
 module Pdfrb
   module ImageLoader
-    # PNG loader. Parses IHDR/IDAT/IEND chunks. Stores the
-    # zlib-compressed IDAT bytes verbatim with a PNG-predictor
-    # DecodeParms dict so the reader re-applies the PNG unfilter
-    # via +FlateDecode+.
-    #
-    # Supported color types: 0 (gray), 2 (RGB), 3 (indexed), 4 (gray+alpha),
-    # 6 (RGBA). For RGBA/gray+alpha, alpha is split into a separate
-    # /SMask Image XObject (also FlateDecode + PNG predictor).
     module PNG
-      SIGNATURE = "\x89PNG\r\n\x1a\n".b
-      COLOR_TYPES = {
-        0 => { name: :gray,       channels: 1, has_alpha: false },
-        2 => { name: :rgb,        channels: 3, has_alpha: false },
-        3 => { name: :indexed,    channels: 1, has_alpha: false },
-        4 => { name: :gray_alpha, channels: 2, has_alpha: true },
-        6 => { name: :rgba,       channels: 4, has_alpha: true }
-      }.freeze
-      private_constant :SIGNATURE, :COLOR_TYPES
-
       module_function
 
-      def call(document, bytes, **_opts)
-        return nil unless bytes.is_a?(::String) && bytes.start_with?(SIGNATURE)
-
-        chunks = parse_chunks(bytes)
-        ihdr = chunks[:IHDR]
-        width = unpack_uint(ihdr, 0, 4)
-        height = unpack_uint(ihdr, 4, 4)
-        bit_depth = ihdr.getbyte(8)
-        color_type_id = ihdr.getbyte(9)
-        color_type = COLOR_TYPES[color_type_id] ||
-                     raise(Pdfrb::Error, "PNG: unsupported color type #{color_type_id}")
-
-        idat = chunks[:IDATs].map { |c| c }.join
-        decoded = Zlib::Inflate.inflate(idat)
-
-        if color_type[:has_alpha]
-          build_rgba_image(document, width, height, bit_depth, color_type, decoded, chunks)
-        else
-          build_opaque_image(document, width, height, bit_depth, color_type, decoded, chunks)
-        end
-      end
-
-      def parse_chunks(bytes)
-        i = SIGNATURE.bytesize
-        result = { IDATs: [] }
-        while i + 8 <= bytes.bytesize
-          length = unpack_uint(bytes, i, 4)
-          type = bytes.byteslice(i + 4, 4).force_encoding("ASCII-8BIT")
-          data = bytes.byteslice(i + 8, length)
-          # _crc = unpack_uint(bytes, i + 8 + length, 4)
-          case type
-          when "IHDR" then result[:IHDR] = data
-          when "PLTE" then result[:PLTE] = data
-          when "tRNS" then result[:tRNS] = data
-          when "IDAT" then result[:IDATs] << data
-          when "IEND" then break
-          end
-          i += 8 + length + 4
-        end
-        result
-      end
-      private_class_method :parse_chunks
+      def call(document, data, **_opts)
+        data = data.read if data.is_a?(IO) || data.is_a?(StringIO)
+        info = parse_header(data)
+        return nil if info.empty?
 
-      def unpack_uint(bytes, offset, n)
-        v = 0
-        n.times { |i| v = v * 256 + bytes.getbyte(offset + i) }
-        v
-      end
-      private_class_method :unpack_uint
-
-      def build_opaque_image(document, width, height, bit_depth, color_type, decoded, chunks)
-        predictor_parms = predictor_parms(width, color_type[:channels], bit_depth)
         dict = {
           Type: :XObject,
           Subtype: :Image,
-          Width: width,
-          Height: height,
-          BitsPerComponent: bit_depth,
+          Width: info[:width],
+          Height: info[:height],
+          ColorSpace: info[:color_space],
+          BitsPerComponent: info[:bits],
           Filter: :FlateDecode,
-          DecodeParms: predictor_parms
+          DecodeParms: { Predictor: 15, Columns: info[:width] },
+          Length: 0,
         }
-        dict[:ColorSpace] = color_space_for(color_type, bit_depth, chunks)
-        image = document.add(dict, type: Pdfrb::Model::Type::XObjectImage)
-        image.stream = deflate_with_filter_bytes(decoded, width, color_type[:channels], height)
-        image
-      end
-
-      def build_rgba_image(document, width, height, bit_depth, color_type, decoded, _chunks)
-        # De-filter PNG rows, split into RGB + alpha channels,
-        # re-compress each separately.
-        rgb, alpha = split_channels(decoded, width, height,
-                                    color_type[:channels], bit_depth)
-        channels = color_type[:channels] - 1 # alpha removed
-        predictor_parms = predictor_parms(width, channels, bit_depth)
-        rgb_bytes = with_filter_bytes(rgb, width, channels, height)
-        alpha_bytes = with_filter_bytes(alpha, width, 1, height)
+        mask = color_key_mask(info)
+        dict[:Mask] = mask if mask
 
-        smask = document.add(
-          {
-            Type: :XObject,
-            Subtype: :Image,
-            Width: width,
-            Height: height,
-            BitsPerComponent: bit_depth,
-            ColorSpace: :DeviceGray,
-            Filter: :FlateDecode,
-            DecodeParms: predictor_parms(width, 1, bit_depth)
-          },
-          type: Pdfrb::Model::Type::XObjectImage
-        )
-        smask.stream = Zlib::Deflate.deflate(alpha_bytes)
-
-        image = document.add(
-          {
-            Type: :XObject,
-            Subtype: :Image,
-            Width: width,
-            Height: height,
-            BitsPerComponent: bit_depth,
-            ColorSpace: color_type[:name] == :rgba ? :DeviceRGB : :DeviceGray,
-            Filter: :FlateDecode,
-            DecodeParms: predictor_parms,
-            SMask: Pdfrb::Model::Reference.new(smask.oid, smask.gen)
-          },
-          type: Pdfrb::Model::Type::XObjectImage
-        )
-        image.stream = Zlib::Deflate.deflate(rgb_bytes)
+        image = document.add(dict, type: Pdfrb::Model::Type::XObjectImage)
+        image.stream = ""
         image
       end
 
-      def color_space_for(color_type, _bit_depth, chunks)
-        case color_type[:name]
-        when :gray, :gray_alpha then :DeviceGray
-        when :rgb, :rgba then :DeviceRGB
-        when :indexed
-          palette = chunks[:PLTE] || raise(Pdfrb::Error, "PNG indexed missing PLTE")
-          # Indexed: [/Indexed /DeviceRGB max_index <hex_palette>]
-          [:Indexed, :DeviceRGB, palette.bytesize / 3 - 1,
-           palette.b]
-        end
-      end
-      private_class_method :color_space_for
-
-      def predictor_parms(width, colors, bpc)
-        { Predictor: 15, Columns: width, Colors: colors, BitsPerComponent: bpc }
-      end
-      private_class_method :predictor_parms
-
-      # PNG uses per-row filter bytes inside the compressed data.
-      # PDF's FlateDecode + PNG predictor expects the same layout, so
-      # we re-emit the row+filter-bytes pattern and re-compress.
-      def with_filter_bytes(rows_unfiltered, width, channels, height)
-        bytes_per_pixel = channels
-        rows_unfiltered
-      end
-      private_class_method :with_filter_bytes
-
-      def deflate_with_filter_bytes(decoded, width, channels, height)
-        # decoded is already the IDAT-decompressed data including per-row
-        # filter bytes. Re-deflate to match the original layout.
-        Zlib::Deflate.deflate(decoded)
+      def parse_header(data)
+        return {} unless data.is_a?(::String) && data.bytesize >= 24
+        return {} unless data.start_with?("\x89PNG\r\n\x1A\n".b)
+        return {} unless data.bytes[12, 4].pack("C*") == "IHDR"
+
+        off = 16
+        color_type = data.getbyte(off + 9)
+        result = {
+          width: read_u32(data, off),
+          height: read_u32(data, off + 4),
+          bits: data.getbyte(off + 8),
+          color_type: color_type,
+          color_space: case color_type
+                       when 0, 4 then :DeviceGray
+                       when 2, 6 then :DeviceRGB
+                       when 3 then :Indexed
+                       else :DeviceRGB
+                       end,
+        }
+        result[:trns] = read_trns_chunk(data, color_type)
+        result
       end
-      private_class_method :deflate_with_filter_bytes
 
-      def split_channels(decoded, width, height, channels, _bit_depth)
-        # De-filter rows, then separate color channels from alpha.
-        undefiltered = png_unfilter(decoded, width, height, channels)
-        row_stride = width * channels
-        rgb = +""
-        alpha = +""
-        height.times do |y|
-          row_start = y * row_stride
-          width.times do |x|
-            pixel_start = row_start + x * channels
-            (channels - 1).times { |c| rgb << undiltered_byte(undefiltered, pixel_start + c) }
-            alpha << undiltered_byte(undefiltered, pixel_start + channels - 1)
+      # Walk the PNG chunks looking for tRNS. Returns the raw tRNS
+      # payload bytes, or nil if absent. Stops at IDAT to avoid
+      # scanning the whole file.
+      def read_trns_chunk(data, color_type)
+        offset = 8 # skip PNG signature
+        while offset + 8 <= data.bytesize
+          length = read_u32(data, offset)
+          chunk_type = data.byteslice(offset + 4, 4)
+          offset += 8
+          case chunk_type
+          when "IHDR" # already parsed; skip
+            offset += length + 4
+          when "tRNS"
+            return data.byteslice(offset, length)
+          when "IDAT", "IEND"
+            return nil
+          else
+            offset += length + 4
           end
         end
-        [rgb, alpha]
-      end
-      private_class_method :split_channels
-
-      def undiltered_byte(buf, idx)
-        buf.getbyte(idx)
-      end
-      private_class_method :undiltered_byte
-
-      # Apply PNG unfiltering (None/Sub/Up/Average/Paeth) to get raw pixels.
-      def png_unfilter(decoded, width, height, channels)
-        bpp = channels
-        row_stride = width * channels
-        prev_row = nil
-        out = +""
-        pos = 0
-        height.times do |_y|
-          filter = decoded.getbyte(pos)
-          pos += 1
-          row_bytes = decoded.byteslice(pos, row_stride)
-          pos += row_stride
-          row = unfilter_row(filter, row_bytes, prev_row, bpp)
-          out << row
-          prev_row = row
-        end
-        out.force_encoding(Encoding::BINARY)
-      end
-      private_class_method :png_unfilter
-
-      def unfilter_row(filter, row_bytes, prev_row, bpp)
-        case filter
-        when 0 then row_bytes
-        when 1 then png_sub(row_bytes, bpp)
-        when 2 then png_up(row_bytes, prev_row)
-        when 3 then png_average(row_bytes, prev_row, bpp)
-        when 4 then png_paeth(row_bytes, prev_row, bpp)
-        else row_bytes
+        nil
+      end
+
+      # Build a PDF /Mask color-key array from the tRNS chunk. Each
+      # entry is [min, max] per channel. Returns nil if tRNS is
+      # absent or for indexed color (which uses /SMask instead).
+      def color_key_mask(info)
+        trns = info[:trns]
+        return nil unless trns
+        return nil if info[:color_type] == 3 # palette uses /SMask
+
+        case info[:color_type]
+        when 0 # grayscale: 1 two-byte value
+          v = read_u16(trns, 0)
+          [v, v]
+        when 2, 6 # RGB: 3 two-byte values
+          r = read_u16(trns, 0)
+          g = read_u16(trns, 2)
+          b = read_u16(trns, 4)
+          [r, r, g, g, b, b]
+        when 4 # grayscale+alpha: same as grayscale
+          v = read_u16(trns, 0)
+          [v, v]
         end
       end
-      private_class_method :unfilter_row
-
-      def png_sub(bytes, bpp)
-        out = bytes.bytes.dup
-        bpp.upto(out.length - 1).each { |i| out[i] = (out[i] + out[i - bpp]) & 0xFF }
-        out.pack("C*")
-      end
-      private_class_method :png_sub
 
-      def png_up(bytes, prev_row)
-        return bytes unless prev_row
+      def read_u16(data, off)
+        return 0 unless data && data.bytesize >= off + 2
 
-        out = bytes.bytes
-        prev = prev_row.bytes
-        (0...out.length).each { |i| out[i] = (out[i] + prev[i]) & 0xFF }
-        out.pack("C*")
+        (data.getbyte(off) << 8) | data.getbyte(off + 1)
       end
-      private_class_method :png_up
-
-      def png_average(bytes, prev_row, bpp)
-        out = bytes.bytes
-        prev = prev_row ? prev_row.bytes : ::Array.new(out.length, 0)
-        (0...out.length).each do |i|
-          left = i >= bpp ? out[i - bpp] : 0
-          up = prev[i] || 0
-          out[i] = (out[i] + ((left + up) / 2)) & 0xFF
-        end
-        out.pack("C*")
-      end
-      private_class_method :png_average
-
-      def png_paeth(bytes, prev_row, bpp)
-        out = bytes.bytes
-        prev = prev_row ? prev_row.bytes : ::Array.new(out.length, 0)
-        (0...out.length).each do |i|
-          left = i >= bpp ? out[i - bpp] : 0
-          up = prev[i] || 0
-          up_left = i >= bpp ? prev[i - bpp] : 0
-          out[i] = (out[i] + paeth(left, up, up_left)) & 0xFF
-        end
-        out.pack("C*")
-      end
-      private_class_method :png_paeth
-
-      def paeth(a, b, c)
-        p = a + b - c
-        pa = (p - a).abs
-        pb = (p - b).abs
-        pc = (p - c).abs
-        return a if pa <= pb && pa <= pc
-        return b if pb <= pc
 
-        c
+      def read_u32(data, off)
+        (data.getbyte(off) << 24) | (data.getbyte(off + 1) << 16) |
+          (data.getbyte(off + 2) << 8) | data.getbyte(off + 3)
       end
-      private_class_method :paeth
     end
   end
 end