fontisan 0.4.21 → 0.4.23

data/lib/fontisan/subset/shared_state.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    # Per-subsetting shared state.
+    #
+    # Several subset strategies depend on values computed by earlier
+    # strategies during the same subsetting run:
+    #
+    #   - `subset_max_advance` is computed by the Hmtx strategy and read
+    #     by Hhea (because hhea is processed alphabetically before hmtx).
+    #   - `glyf_data`, `loca_offsets`, and `subset_bbox` are computed by
+    #     the Glyf strategy and consumed by Loca and Head.
+    #
+    # Rather than giving each TableStrategy access to the entire
+    # TableSubsetter (which would couple them to internals), the
+    # cross-strategy state lives here. Each strategy receives a Context
+    # exposing [font], [mapping], [options], and this [SharedState].
+    class SharedState
+      # @return [String, nil] binary glyf data built by the Glyf strategy
+      attr_accessor :glyf_data
+
+      # @return [Array<Integer>, nil] loca offsets produced by the Glyf strategy
+      attr_accessor :loca_offsets
+
+      # @return [Array(Integer, Integer, Integer, Integer), nil] union
+      #   xMin/yMin/xMax/yMax over the subset's glyphs
+      attr_accessor :subset_bbox
+
+      # @return [Integer] largest advanceWidth seen while subsetting hmtx
+      attr_accessor :subset_max_advance
+
+      # @return [TableStrategy::ColorBitmapSubsetter, nil] cached paired
+      #   CBDT+CBLC subsetter so both strategies reuse the same pass
+      attr_accessor :color_bitmap_subsetter
+
+      def initialize
+        @subset_max_advance = 0
+      end
+    end
+  end
+end

data/lib/fontisan/subset/subset_context.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    # Value object handed to every TableStrategy. Encapsulates the inputs
+    # (font, mapping, options) plus the cross-strategy [SharedState] so
+    # strategies don't need a back-reference to the TableSubsetter.
+    #
+    # @!attribute font
+    #   @return [SfntFont]
+    # @!attribute mapping
+    #   @return [GlyphMapping]
+    # @!attribute options
+    #   @return [Options]
+    # @!attribute state
+    #   @return [SharedState]
+    SubsetContext = Struct.new(:font, :mapping, :options, :state,
+                               keyword_init: true)
+  end
+end

data/lib/fontisan/subset/table_strategy/cbdt.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # CBDT strategy: delegate to [ColorBitmapSubsetter], which produces
+      # both CBDT and CBLC bytes in a single pass. The Cblc strategy
+      # reads from the same collaborator so the two tables stay
+      # consistent.
+      class Cbdt
+        # @param context [SubsetContext]
+        # @param tag [String] "CBDT"
+        # @param table [Cbdt] parsed CBDT table (unused)
+        # @return [String] subset CBDT bytes
+        def self.call(context:, tag:, table:)
+          color_bitmap_subsetter(context).cbdt_bytes
+        end
+
+        # @param context [SubsetContext]
+        # @return [ColorBitmapSubsetter] cached on the shared state so the
+        #   Cblc strategy reuses the same pass
+        def self.color_bitmap_subsetter(context)
+          context.state.color_bitmap_subsetter ||= ColorBitmapSubsetter.new(font: context.font,
+                                                                            mapping: context.mapping).build
+        end
+        private_class_method :color_bitmap_subsetter
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/cblc.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # CBLC strategy: delegate to [ColorBitmapSubsetter] (the same
+      # collaborator used by the Cbdt strategy) so both tables stay
+      # consistent. The subsetter is built lazily on first access and
+      # cached on [SharedState].
+      class Cblc
+        # @param context [SubsetContext]
+        # @param tag [String] "CBLC"
+        # @param table [Cblc] parsed CBLC table (unused)
+        # @return [String] subset CBLC bytes
+        def self.call(context:, tag:, table:)
+          color_bitmap_subsetter(context).cblc_bytes
+        end
+
+        def self.color_bitmap_subsetter(context)
+          context.state.color_bitmap_subsetter ||= ColorBitmapSubsetter.new(font: context.font,
+                                                                            mapping: context.mapping).build
+        end
+        private_class_method :color_bitmap_subsetter
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/cmap.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Cmap strategy: rebuild cmap containing only the (codepoint →
+      # new GID) mappings for codepoints whose original GID is retained.
+      # Emits a format-4 subtable for BMP codepoints and a format-12
+      # subtable for supplementary-plane codepoints.
+      class Cmap
+        # @param context [SubsetContext]
+        # @param tag [String] "cmap"
+        # @param table [Cmap] parsed cmap table
+        # @return [String] binary cmap bytes for the subset
+        def self.call(context:, tag:, table:)
+          new_mappings = {}
+          table.unicode_mappings.each do |char_code, old_gid|
+            new_gid = context.mapping.new_id(old_gid)
+            new_mappings[char_code] = new_gid if new_gid
+          end
+          Builder.new(new_mappings).build
+        end
+
+        # Builds a minimal valid cmap table from a {codepoint => gid} map.
+        # Extracted as a sibling class so [Cmap] stays focused on
+        # subsetting dispatch while the binary arithmetic lives
+        # separately.
+        class Builder
+          def initialize(mappings)
+            @mappings = mappings
+          end
+
+          def build
+            @mappings = { 0 => 0 } if @mappings.empty?
+
+            bmp = @mappings.select { |cp, _| cp <= 0xFFFF }
+            supp = @mappings.select { |cp, _| cp > 0xFFFF }
+
+            subtables = []
+            records = []
+
+            unless bmp.empty?
+              subtables << build_format_4(bmp)
+              idx = subtables.size - 1
+              records << [3, 1, idx] # Windows BMP
+              records << [0, 3, idx] # Unicode BMP
+            end
+
+            unless supp.empty?
+              subtables << build_format_12(@mappings)
+              idx = subtables.size - 1
+              records << [3, 10, idx] # Windows UCS-4
+              records << [0, 4, idx]  # Unicode full
+            end
+
+            assemble(records, subtables)
+          end
+
+          private
+
+          def assemble(records, subtables)
+            num_tables = records.size
+            header = [0, num_tables].pack("nn")
+            subtable_base = 4 + (8 * num_tables)
+
+            offsets = []
+            running = subtable_base
+            subtables.each do |st|
+              offsets << running
+              running += st.bytesize
+            end
+
+            record_bytes = +""
+            records.each do |pid, eid, idx|
+              record_bytes << [pid, eid, offsets[idx]].pack("nnN")
+            end
+
+            header + record_bytes + subtables.join
+          end
+
+          def build_format_4(bmp_mappings)
+            segments = coalesce_segments(bmp_mappings)
+            segments << { start_cp: 0xFFFF, end_cp: 0xFFFF, start_gid: 0 }
+
+            seg_count = segments.size
+            seg_count_x2 = seg_count * 2
+            search_range = 2**Math.log2(seg_count).floor * 2
+            search_range = 2 if search_range < 2
+            entry_selector = Math.log2(search_range / 2).to_i
+            range_shift = seg_count_x2 - search_range
+
+            end_codes = segments.map { |s| s[:end_cp] }
+            start_codes = segments.map { |s| s[:start_cp] }
+            id_deltas = segments.map do |s|
+              (s[:start_gid] - s[:start_cp]) & 0xFFFF
+            end
+            id_range_offsets = [0] * seg_count
+
+            subtable = +""
+            subtable << [4, 0, 0, seg_count_x2,
+                         search_range, entry_selector, range_shift].pack("n*")
+            subtable << end_codes.pack("n*")
+            subtable << [0].pack("n") # reservedPad
+            subtable << start_codes.pack("n*")
+            subtable << id_deltas.pack("n*")
+            subtable << id_range_offsets.pack("n*")
+
+            subtable[2, 2] = [subtable.bytesize].pack("n")
+            subtable
+          end
+
+          def build_format_12(all_mappings)
+            groups = coalesce_segments(all_mappings)
+            num_groups = groups.size
+
+            subtable = +""
+            subtable << [12, 0, 0, 0, num_groups].pack("nnNNN")
+            groups.each do |g|
+              subtable << [g[:start_cp], g[:end_cp], g[:start_gid]].pack("NNN")
+            end
+
+            subtable[4, 4] = [subtable.bytesize].pack("N")
+            subtable
+          end
+
+          def coalesce_segments(mappings)
+            sorted = mappings.sort_by { |cp, _| cp }
+            segments = []
+            current = nil
+            sorted.each do |cp, gid|
+              if current && cp == current[:end_cp] + 1 &&
+                  gid == current[:start_gid] + (cp - current[:start_cp])
+                current[:end_cp] = cp
+              else
+                segments << current if current
+                current = { start_cp: cp, end_cp: cp, start_gid: gid }
+              end
+            end
+            segments << current if current
+            segments
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/color_bitmap_placement.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Per-survivor placement: where the source bitmap lives and where it
+# ends up in the subset CBDT.
+module Fontisan
+  module Subset
+    module TableStrategy
+      ColorBitmapPlacement = Struct.new(:source_gid, :new_gid,
+                                        :source_offset, :byte_length,
+                                        :image_format, :strike_ppem,
+                                        :new_offset,
+                                        keyword_init: true) do
+        def initialize(*)
+          super
+          self.new_offset ||= 0
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/color_bitmap_strike_plan.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Plan for one strike emitted by [ColorBitmapSubsetter]: the source
+      # BitmapSize plus the list of contiguous new-gid runs (each run
+      # becomes one IndexSubTable in the output CBLC).
+      class ColorBitmapStrikePlan
+        attr_reader :source_strike, :subtable_plans
+
+        def initialize(source_strike)
+          @source_strike = source_strike
+          @subtable_plans = []
+        end
+
+        # Add a placement, grouping into contiguous new-gid runs. A new
+        # run starts when the new gid skips, the ppem changes, or the
+        # image format changes.
+        def add(placement)
+          current = @subtable_plans.last
+
+          if current && placement.new_gid == current.last_new_gid + 1
+            current.add(placement)
+          else
+            sub = ColorBitmapSubtablePlan.new(
+              strike_ppem: placement.strike_ppem,
+              image_format: placement.image_format,
+            )
+            sub.add(placement)
+            @subtable_plans << sub
+          end
+        end
+
+        def empty?
+          @subtable_plans.empty?
+        end
+
+        def subtable_count
+          @subtable_plans.size
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/color_bitmap_subset_plan.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Plan for the subset of color bitmaps: which source strikes have
+      # any surviving glyph, and the per-strike runs of surviving new
+      # GIDs. Built once by [ColorBitmapSubsetter] from a CBLC + a
+      # GlyphMapping, then used to drive both CBDT and CBLC emission.
+      class ColorBitmapSubsetPlan
+        attr_reader :strikes, :strike_plans, :placements
+
+        def initialize(mapping)
+          @mapping = mapping
+          @strikes = []
+          @strike_plans = []
+          @placements = []
+        end
+
+        # Walk every (gid, strike) location in CBLC and capture the
+        # ones whose source gid is in the subset. Remaps the gid via
+        # the supplied mapping.
+        def collect!(cblc)
+          cblc.bitmap_sizes.each do |strike|
+            strike_plan = ColorBitmapStrikePlan.new(strike)
+
+            cblc.sub_tables_for(strike).each do |sub|
+              sub.locations.each do |loc|
+                new_gid = @mapping.new_id(loc.glyph_id)
+                next unless new_gid
+
+                placement = ColorBitmapPlacement.new(
+                  source_gid: loc.glyph_id,
+                  new_gid: new_gid,
+                  source_offset: loc.cbdt_offset,
+                  byte_length: loc.byte_length,
+                  image_format: loc.image_format,
+                  strike_ppem: strike.ppem,
+                )
+                @placements << placement
+                strike_plan.add(placement)
+              end
+            end
+
+            next if strike_plan.empty?
+
+            @strikes << strike
+            @strike_plans << strike_plan
+          end
+        end
+
+        def each_placement(&)
+          @placements.each(&)
+        end
+
+        def each_strike_plan(&)
+          @strike_plans.each(&)
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/color_bitmap_subsetter.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Paired CBDT + CBLC subsetter.
+      #
+      # CBDT (Color Bitmap Data) and CBLC (Color Bitmap Location) are
+      # tightly coupled: CBLC indexes glyph IDs to CBDT byte offsets,
+      # and CBDT is just a blob of bitmap blocks. Subsetting requires
+      # walking both at once — filtering to subset GIDs, copying the
+      # retained bitmap blocks into a fresh CBDT, and rewriting CBLC's
+      # IndexSubTable offsets to match.
+      #
+      # Both the Cbdt and Cblc strategies call into this collaborator,
+      # which performs the work once and caches both byte strings. This
+      # keeps the strategies themselves trivial and avoids forcing the
+      # TableSubsetter to know about CBDT/CBLC ordering.
+      #
+      # The output CBLC keeps the source BitmapSize records verbatim
+      # (ppem, metrics, glyph_range) and rewrites each IndexSubTable's
+      # `imageDataOffset` and offset array to point into the new CBDT.
+      # Glyph IDs are remapped via the supplied [GlyphMapping] so the
+      # subset's CBLC references subset GIDs, not source GIDs.
+      #
+      # Output IndexSubTables always use format 1 (uint32 offsets) —
+      # it has no alignment requirement, so arbitrary bitmap block
+      # sizes from the source work without padding.
+      #
+      # Reference: OpenType CBDT/CBLC specifications.
+      class ColorBitmapSubsetter
+        # @return [String] new CBDT bytes (header + retained blocks)
+        attr_reader :cbdt_bytes
+
+        # @return [String] new CBLC bytes (header + BitmapSize + ISTA + IST)
+        attr_reader :cblc_bytes
+
+        # @param font [SfntFont]
+        # @param mapping [GlyphMapping] old↔new GID map for the subset
+        def initialize(font:, mapping:)
+          @font = font
+          @mapping = mapping
+          @cbdt_bytes = +""
+          @cblc_bytes = +""
+        end
+
+        # Build the subset CBDT + CBLC bytes. Idempotent.
+        #
+        # @return [self]
+        def build
+          return self if @built
+
+          source_cblc = @font.table_data["CBLC"]
+          source_cbdt = @font.table_data["CBDT"]
+
+          if source_cblc.nil? || source_cbdt.nil?
+            @built = true
+            return self
+          end
+
+          cblc = Tables::Cblc.read(source_cblc)
+          cbdt = Tables::Cbdt.read(source_cbdt)
+
+          plan = ColorBitmapSubsetPlan.new(@mapping)
+          plan.collect!(cblc)
+
+          emit_cbdt(cbdt, plan)
+          emit_cblc(cblc, plan)
+
+          @built = true
+          self
+        end
+
+        private
+
+        # Emit CBDT: preserve the source 4-byte header, then concatenate
+        # every retained bitmap block in (strike, gid) order. The
+        # placement's new_offset is recorded so CBLC emission can
+        # reference it.
+        def emit_cbdt(cbdt, plan)
+          @cbdt_bytes = String.new(encoding: Encoding::BINARY)
+          @cbdt_bytes << cbdt.raw_data[0, 4] # majorVersion + minorVersion
+
+          plan.each_placement do |placement|
+            block = cbdt.bitmap_data_at(placement.source_offset,
+                                        placement.byte_length)
+            next unless block
+
+            placement.new_offset = @cbdt_bytes.bytesize
+            @cbdt_bytes << block
+          end
+        end
+
+        # Emit CBLC: header + BitmapSize section + IndexSubTableArray
+        # section + IndexSubTable records. The IndexSubTableArray entries
+        # are grouped per strike; IndexSubTable records are appended
+        # after all ISTA entries. Each IndexSubTable is format 1.
+        def emit_cblc(cblc, plan)
+          output = String.new(encoding: Encoding::BINARY)
+          output << [Integer(cblc.version), plan.strikes.size].pack("NN")
+
+          bitmap_size_section_end = output.bytesize + (plan.strikes.size * 48)
+          ista_offsets = build_ista_offsets(plan, bitmap_size_section_end)
+          ista_section_end = ista_offsets.last.to_i +
+            (plan.strike_plans.sum(&:subtable_count) * 8)
+
+          # BitmapSize records (patched array_offset + number_of_subtables).
+          plan.strike_plans.each_with_index do |strike_plan, idx|
+            output << patch_bitmap_size(strike_plan.source_strike,
+                                        ista_offsets[idx],
+                                        strike_plan.subtable_count)
+          end
+
+          # IndexSubTableArray entries (one per subtable plan).
+          ist_cursor = ista_section_end
+          plan.strike_plans.each_with_index do |strike_plan, idx|
+            strike_ista_offset = ista_offsets[idx]
+            strike_plan.subtable_plans.each do |sub|
+              additional = ist_cursor - strike_ista_offset
+              output << [sub.first_new_gid, sub.last_new_gid,
+                         additional].pack("nnN")
+              ist_cursor += sub.byte_length
+            end
+          end
+
+          # IndexSubTable records (format 1).
+          plan.each_strike_plan do |strike_plan|
+            strike_plan.subtable_plans.each do |sub|
+              output << build_index_sub_table(sub)
+            end
+          end
+
+          @cblc_bytes = output
+        end
+
+        # Absolute CBLC offset of each survivor strike's IndexSubTableArray.
+        # Each strike's ISTA is laid out right after the BitmapSize section
+        # and the previous strikes' ISTA entries (8 bytes × subtable count).
+        def build_ista_offsets(plan, bitmap_size_section_end)
+          offsets = []
+          cursor = bitmap_size_section_end
+          plan.strike_plans.each do |sp|
+            offsets << cursor
+            cursor += sp.subtable_count * 8
+          end
+          offsets
+        end
+
+        # Clone a BitmapSize with patched `index_subtable_array_offset`
+        # and `number_of_index_subtables`; everything else preserved
+        # from the source.
+        def patch_bitmap_size(source_strike, new_ista_offset, subtable_count)
+          clone = Tables::CblcBitmapSize.new
+          clone.index_subtable_array_offset = new_ista_offset
+          clone.index_tables_size = source_strike.index_tables_size
+          clone.number_of_index_subtables = subtable_count
+          clone.color_ref = source_strike.color_ref
+          clone.hori = source_strike.hori
+          clone.vert = source_strike.vert
+          clone.start_glyph_index = source_strike.start_glyph_index
+          clone.end_glyph_index = source_strike.end_glyph_index
+          clone.ppem_x = source_strike.ppem_x
+          clone.ppem_y = source_strike.ppem_y
+          clone.bit_depth = source_strike.bit_depth
+          clone.flags = source_strike.flags
+          clone.to_binary_s
+        end
+
+        # Format 1 IndexSubTable: 8-byte header + uint32 offsetArray[count+1].
+        # imageDataOffset = absolute new CBDT offset of the first glyph's
+        # bitmap. offsets[i] = relative offset from imageDataOffset for
+        # glyph i.
+        def build_index_sub_table(sub)
+          bytes = String.new(encoding: Encoding::BINARY)
+          bytes << [1, sub.image_format, sub.first_new_offset].pack("nnN")
+          bytes << sub.offset_array.pack("N*")
+          bytes
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/color_bitmap_subtable_plan.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Plan for one IndexSubTable emitted by [ColorBitmapSubsetter]:
+      # a contiguous run of new GIDs at a single strike, with the
+      # CBDT offsets and lengths needed to emit a format 1 IndexSubTable.
+      class ColorBitmapSubtablePlan
+        attr_reader :placements, :strike_ppem, :image_format
+
+        def initialize(strike_ppem:, image_format:)
+          @strike_ppem = strike_ppem
+          @image_format = image_format
+          @placements = []
+        end
+
+        def add(placement)
+          @placements << placement
+        end
+
+        def first_new_gid
+          @placements.first.new_gid
+        end
+
+        def last_new_gid
+          @placements.last.new_gid
+        end
+
+        # Absolute CBDT offset where this subtable's first glyph's
+        # bitmap begins. Assigned during CBDT emission.
+        #
+        # @return [Integer]
+        def first_new_offset
+          @placements.first.new_offset
+        end
+
+        # IndexSubTable format 1 offset array (relative to
+        # imageDataOffset). offsets[0] is 0 (first glyph starts at
+        # imageDataOffset); offsets[i+1] = offsets[i] + byte_length.
+        #
+        # @return [Array<Integer>]
+        def offset_array
+          arr = [0]
+          @placements.each do |p|
+            arr << (arr.last + p.byte_length)
+          end
+          arr
+        end
+
+        # Byte length of this IndexSubTable in the output CBLC:
+        # 8-byte header + (count + 1) × 4-byte offsets.
+        def byte_length
+          8 + (@placements.size + 1) * 4
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/glyf.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Glyf strategy: extract each subset glyph's bytes from the source
+      # glyf table (remapping composite component glyph IDs), build the
+      # corresponding loca offsets, and stash both into [SharedState] so
+      # the Loca strategy can read them. Also records the union bbox
+      # for the Head strategy.
+      class Glyf
+        # @param context [SubsetContext]
+        # @param tag [String] "glyf"
+        # @param table [Glyf] parsed glyf table (unused; builder reads
+        #   the table from `context.font` directly so it sees the same
+        #   instance)
+        # @return [String] binary glyf bytes for the subset
+        def self.call(context:, tag:, table:)
+          builder = GlyfLocaBuilder.new(font: context.font,
+                                        mapping: context.mapping).build
+          context.state.glyf_data = builder.glyf_data
+          context.state.loca_offsets = builder.loca_offsets
+          context.state.subset_bbox = builder.bbox
+          builder.glyf_data
+        end
+      end
+    end
+  end
+end