pdfrb 0.1.0

data/lib/pdfrb/font/type1.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module Type1
+      autoload :FontMetrics, "pdfrb/font/type1/font_metrics"
+    end
+  end
+end

data/lib/pdfrb/font.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  # Font machinery: encoding tables, CMap parser, TrueType file parser,
+  # AFM metrics, font loaders. Consumed by +Document::Fonts+.
+  module Font
+    autoload :Encoding, "pdfrb/font/encoding"
+    autoload :GlyphList, "pdfrb/font/glyph_list"
+    autoload :AFMParser, "pdfrb/font/afm_parser"
+    autoload :CMap, "pdfrb/font/cmap"
+    autoload :TrueType, "pdfrb/font/true_type"
+    autoload :Type1, "pdfrb/font/type1"
+  end
+
+  # Top-level font loader registry. Extends what +Document::Fonts+
+  # already supports by adding TrueType and Type1 loaders.
+  autoload :FontLoader, "pdfrb/font_loader"
+end

data/lib/pdfrb/font_loader/true_type.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module FontLoader
+    # TrueType font loader. Reads a .ttf file, builds the PDF font
+    # dict + descriptor, and embeds the font file (optionally
+    # subsetted).
+    module TrueType
+      module_function
+
+      def call(document, name_or_io, embedded: true, **_opts)
+        return nil unless name_or_io.is_a?(::String) && File.exist?(name_or_io)
+        return nil unless name_or_io.end_with?(".ttf", ".otf")
+
+        font_data = File.binread(name_or_io)
+        ttf = Pdfrb::Font::TrueType::File.new(font_data)
+
+        base_font = File.basename(name_or_io, ".*")
+        font_dict = document.add(
+          {
+            Type: :Font,
+            Subtype: :TrueType,
+            BaseFont: base_font.to_sym,
+            FirstChar: 0,
+            LastChar: 255
+          },
+          type: Pdfrb::Model::Type::FontTrueType
+        )
+
+        if embedded
+          font_stream = document.add(
+            { Length1: font_data.bytesize },
+            type: Pdfrb::Model::Cos::Stream
+          )
+          font_stream.stream = font_data
+
+          descriptor = document.add(
+            {
+              Type: :FontDescriptor,
+              FontName: base_font.to_sym,
+              Flags: 32,
+              FontBBox: [0, 0, 1000, 1000],
+              ItalicAngle: 0,
+              Ascent: 800,
+              Descent: -200,
+              CapHeight: 700,
+              StemV: 80,
+              FontFile2: Pdfrb::Model::Reference.new(font_stream.oid, 0)
+            },
+            type: Pdfrb::Model::Type::FontDescriptor
+          )
+          font_dict.value[:FontDescriptor] =
+            Pdfrb::Model::Reference.new(descriptor.oid, 0)
+        end
+
+        font_dict
+      end
+    end
+  end
+end
+
+Pdfrb::Document::Fonts.register_loader(Pdfrb::FontLoader::TrueType)

data/lib/pdfrb/font_loader/type1.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module FontLoader
+    # Type1 font loader. For the 14 standard fonts, no embedding
+    # is needed. For custom Type1 fonts, parses the AFM and embeds
+    # the PFB via /FontFile.
+    module Type1
+      module_function
+
+      def call(document, name_or_io, **_opts)
+        case name_or_io
+        when ::String
+          if Pdfrb::Document::Fonts::STANDARDS.include?(name_or_io)
+            return document.add(
+              { Type: :Font, Subtype: :Type1, BaseFont: name_or_io.to_sym },
+              type: Pdfrb::Model::Type::FontType1
+            )
+          end
+          nil
+        end
+      end
+    end
+  end
+end
+
+Pdfrb::Document::Fonts.register_loader(Pdfrb::FontLoader::Type1)

data/lib/pdfrb/font_loader.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  # Font loader registry. Extends the 14-standard-font loader in
+  # +Document::Fonts+ with TrueType and Type1 font file loaders.
+  module FontLoader
+    autoload :TrueType, "pdfrb/font_loader/true_type"
+    autoload :Type1, "pdfrb/font_loader/type1"
+  end
+end

data/lib/pdfrb/image_loader/jpeg.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+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)
+
+        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
+          },
+          type: Pdfrb::Model::Type::XObjectImage
+        )
+        image.stream = bytes.b
+        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)
+          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
+          end
+        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)
+        {
+          precision: precision,
+          width: width,
+          height: height,
+          components: components,
+          color_space: color_space_for(components)
+        }
+      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/pdf.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module ImageLoader
+    # PDF image loader. Imports a page from another PDF document as
+    # a Form XObject, suitable for embedding via the +Do+ operator
+    # or the canvas +image+ method (TODO 95 enhancement).
+    module PDF
+      module_function
+
+      def call(document, io, page: 0, **_opts)
+        source_doc = io.is_a?(Pdfrb::Document) ? io : Pdfrb::Document.open(io)
+        source_page = source_doc.pages[page]
+        return nil unless source_page
+
+        importer = Pdfrb::Importer.new(document)
+        imported_value = importer.import(source_page.value, source_doc)
+        imported_value.delete(:Parent)
+        imported_value[:Type] = :XObject
+        imported_value[:Subtype] = :Form
+        imported_value[:BBox] ||= imported_value[:MediaBox] || [0, 0, 612, 792]
+
+        form = document.add(imported_value, type: Pdfrb::Model::Type::XObjectForm)
+        form
+      end
+    end
+  end
+end

data/lib/pdfrb/image_loader/png.rb

@@ -0,0 +1,282 @@
+# 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 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,
+          Filter: :FlateDecode,
+          DecodeParms: predictor_parms
+        }
+        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)
+
+        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
+      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)
+      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)
+          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
+        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
+
+        out = bytes.bytes
+        prev = prev_row.bytes
+        (0...out.length).each { |i| out[i] = (out[i] + prev[i]) & 0xFF }
+        out.pack("C*")
+      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
+      end
+      private_class_method :paeth
+    end
+  end
+end

data/lib/pdfrb/image_loader.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  # Image loaders: build a +Type::XObjectImage+ (or +Type::XObjectForm+
+  # for PDF) from a JPEG, PNG, or PDF source. Each loader is a module
+  # under +ImageLoader::*+ with a +call(document, io, **opts)+
+  # class method that returns an image object or nil if it can't
+  # handle the format.
+  module ImageLoader
+    autoload :JPEG, "pdfrb/image_loader/jpeg"
+    autoload :PNG, "pdfrb/image_loader/png"
+    autoload :PDF, "pdfrb/image_loader/pdf"
+
+    @loaders = []
+
+    class << self
+      attr_reader :loaders
+
+      # Register a loader. Loaders are tried in registration order;
+      # first non-nil return wins.
+      def register(loader)
+        @loaders << loader
+      end
+
+      # Build an image XObject from +io+ (IO, file path, or bytes).
+      # Iterates registered loaders until one matches.
+      def load(document, io, **opts)
+        bytes = read_bytes(io)
+        @loaders.each do |loader|
+          result = loader.call(document, bytes, **opts)
+          return result if result
+        end
+        raise Pdfrb::Error,
+              "no image loader matched (unknown or unrecognised format)"
+      end
+
+      def reset!
+        @loaders.clear
+      end
+
+      private
+
+      def read_bytes(io)
+        case io
+        when IO, StringIO then io.read
+        when ::String
+          looks_like_path?(io) ? File.binread(io) : io.b
+        else
+          io.to_s.b
+        end
+      end
+
+      def looks_like_path?(s)
+        return false if s.bytesize > 4096 || s.encoding == Encoding::BINARY
+        return false if s.bytes.any? { |b| b == 0 || b < 9 || (b > 13 && b < 32) }
+
+        File.exist?(s)
+      end
+    end
+
+    register JPEG
+    register PNG
+  end
+end

data/lib/pdfrb/importer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  # Cross-document object importer. Deep-copies a value (and any
+  # references it transitively reaches) from a source document into
+  # this document, allocating fresh oids and rewriting references.
+  #
+  # Cycle-safe: a "currently being imported" set guards against
+  # infinite recursion when objects reference each other.
+  class Importer
+    attr_reader :target, :mappings
+
+    def initialize(target_document)
+      @target = target_document
+      @mappings = {}        # source_oid -> target Pdfrb::Model::Object
+      @in_progress = {}     # source_oid -> half-built target obj
+    end
+
+    # Import +source_value+ (resolved against +source_document+) into
+    # the target. Returns the imported value (NOT wrapped in an
+    # Object; the caller decides oid assignment via Document#add).
+    def import(source_value, source_document)
+      case source_value
+      when Pdfrb::Model::Reference
+        import_reference(source_value, source_document)
+      when ::Hash
+        import_hash(source_value, source_document)
+      when ::Array
+        source_value.map { |v| import(v, source_document) }
+      when Pdfrb::Model::Object
+        import(source_value.value, source_document)
+      else
+        source_value
+      end
+    end
+
+    private
+
+    def import_reference(ref, source_doc)
+      cached = @mappings[ref.oid]
+      return Pdfrb::Model::Reference.new(cached.oid, cached.gen) if cached
+
+      in_progress = @in_progress[ref.oid]
+      return Pdfrb::Model::Reference.new(in_progress.oid, in_progress.gen) if in_progress
+
+      source_obj = source_doc.object(ref)
+      return nil unless source_obj
+
+      # Reserve the oid up-front so cycles resolve to this stub.
+      stub = target.add({}, type: Pdfrb::Model::Cos::Dictionary)
+      @in_progress[ref.oid] = stub
+
+      imported_value = import(source_obj.value, source_doc)
+      stub.value.replace(imported_value)
+      # Streams: copy the raw bytes if source was a Stream.
+      if source_obj.is_a?(Pdfrb::Model::Cos::Stream)
+        stub_stream!(stub, source_obj)
+      end
+      @mappings[ref.oid] = stub
+      @in_progress.delete(ref.oid)
+      Pdfrb::Model::Reference.new(stub.oid, stub.gen)
+    end
+
+    def import_hash(hash, source_doc)
+      hash.transform_values { |v| import(v, source_doc) }
+    end
+
+    def stub_stream!(stub, source)
+      # Re-wrap the stub Dictionary as a real Stream carrying the
+      # source's bytes; register the new object under the same oid.
+      stream_bytes = source.stream.dup
+      new_stream = target.wrap(stub.value, type: Pdfrb::Model::Cos::Stream,
+                                          oid: stub.oid, gen: stub.gen)
+      new_stream.stream = stream_bytes
+      target.register_override(new_stream)
+    end
+  end
+end