fontisan 0.4.22 → 0.4.23

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

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Glyf + Loca are emitted together because loca is just an offset
+      # index into glyf. This builder walks the subset's glyph mapping,
+      # extracts each glyph's bytes (remapping composite component refs),
+      # and produces the new glyf bytes, the new loca offsets, and the
+      # union bounding box over the subset's glyphs.
+      #
+      # Extracted as a collaborator so both the Glyf and Loca strategies
+      # can share a single build pass without coupling to each other or
+      # to TableSubsetter internals.
+      class GlyfLocaBuilder
+        # @param font [SfntFont]
+        # @param mapping [GlyphMapping]
+        def initialize(font:, mapping:)
+          @font = font
+          @mapping = mapping
+        end
+
+        # @return [String] new glyf bytes
+        attr_reader :glyf_data
+
+        # @return [Array<Integer>] loca offsets (one per glyph + 1)
+        attr_reader :loca_offsets
+
+        # @return [Array(Integer, Integer, Integer, Integer), nil] union
+        #   bbox as [x_min, y_min, x_max, y_max], or nil if all glyphs empty
+        attr_reader :bbox
+
+        # Build glyf + loca + bbox. Idempotent — re-calling is a no-op.
+        #
+        # @return [self]
+        def build
+          return self if @glyf_data
+
+          glyf = @font.table("glyf")
+          loca = @font.table("loca")
+          head = @font.table("head")
+
+          ensure_loca_parsed!(loca, head)
+
+          @glyf_data = String.new(encoding: Encoding::BINARY)
+          @loca_offsets = []
+          current_offset = 0
+
+          bbox_x_min = 1 << 30
+          bbox_y_min = 1 << 30
+          bbox_x_max = -(1 << 30)
+          bbox_y_max = -(1 << 30)
+
+          @mapping.old_ids.each do |old_id|
+            @loca_offsets << current_offset
+
+            offset = loca.offset_for(old_id)
+            size = loca.size_of(old_id)
+            next if size.nil? || size.zero?
+
+            glyph_data = glyf.raw_data[offset, size]
+
+            if glyph_data.bytesize >= 10
+              _n, gx_min, gy_min, gx_max, gy_max = glyph_data[0, 10].unpack("n5")
+              gx_min = to_signed_16(gx_min)
+              gy_min = to_signed_16(gy_min)
+              gx_max = to_signed_16(gx_max)
+              gy_max = to_signed_16(gy_max)
+              bbox_x_min = gx_min if gx_min < bbox_x_min
+              bbox_y_min = gy_min if gy_min < bbox_y_min
+              bbox_x_max = gx_max if gx_max > bbox_x_max
+              bbox_y_max = gy_max if gy_max > bbox_y_max
+            end
+
+            glyph_data = remap_compound!(glyph_data) if compound?(glyph_data)
+
+            @glyf_data << glyph_data
+            current_offset += glyph_data.bytesize
+          end
+
+          @loca_offsets << current_offset
+
+          return if bbox_x_min > bbox_x_max
+
+          @bbox = [bbox_x_min, bbox_y_min, bbox_x_max, bbox_y_max]
+          self
+        end
+
+        private
+
+        def ensure_loca_parsed!(loca, head)
+          return if loca.parsed?
+
+          maxp = @font.table("maxp")
+          loca.parse_with_context(head.index_to_loc_format, maxp.num_glyphs)
+        end
+
+        def compound?(data)
+          return false if data.length < 2
+
+          num_contours = to_signed_16(data[0, 2].unpack1("n"))
+          num_contours == -1
+        end
+
+        def remap_compound!(data)
+          new_data = data.dup
+          offset = 10 # skip 10-byte header
+
+          loop do
+            break if offset >= new_data.length - 4
+
+            flags = new_data[offset, 2].unpack1("n")
+            old_glyph_index = new_data[offset + 2, 2].unpack1("n")
+
+            new_glyph_index = @mapping.new_id(old_glyph_index)
+            unless new_glyph_index
+              raise Fontisan::SubsettingError,
+                    "Component glyph #{old_glyph_index} not in subset"
+            end
+
+            new_data[offset + 2, 2] = [new_glyph_index].pack("n")
+            offset += 4 # flags + glyph_index
+            offset += (flags & 0x0001).zero? ? 2 : 4 # args
+
+            if (flags & 0x0080) != 0
+              offset += 8 # 2x2 matrix
+            elsif (flags & 0x0040) != 0
+              offset += 4 # X and Y scale
+            elsif (flags & 0x0008) != 0
+              offset += 2 # uniform scale
+            end
+
+            break unless (flags & 0x0020) != 0 # MORE_COMPONENTS
+          end
+
+          new_data
+        end
+
+        def to_signed_16(value)
+          value > 0x7FFF ? value - 0x10000 : value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Head strategy: recompute xMin/yMin/xMax/yMax (offsets 36–43) from
+      # the subset's actual glyphs. The source TTC's bbox covers every
+      # donor font in the collection and is far larger than any per-block
+      # subset needs; an inflated bbox makes browsers render glyphs at
+      # the wrong visual size. The remaining head fields pass through
+      # unchanged — checksumAdjustment is rewritten by FontWriter.
+      class Head
+        # @param context [SubsetContext]
+        # @param tag [String] "head"
+        # @param table [Head] parsed head table (unused)
+        # @return [String] binary head bytes for the subset
+        def self.call(context:, tag:, table:)
+          ensure_glyf_built!(context)
+
+          data = context.font.table_data["head"].dup
+          bbox = context.state.subset_bbox
+          return data unless bbox
+
+          x_min, y_min, x_max, y_max = bbox
+          data[36, 8] = [x_min, y_min, x_max, y_max].pack("n4")
+          data
+        end
+
+        def self.ensure_glyf_built!(context)
+          return if context.state.glyf_data
+
+          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
+        end
+        private_class_method :ensure_glyf_built!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Hhea strategy: rewrite numberOfHMetrics (offset 34, uint16) and
+      # advanceWidthMax (offset 10, uint16). The source TTC's
+      # advanceWidthMax covers every donor font and can be far larger
+      # than any per-block subset needs; recomputing from the subset's
+      # actual hmtx keeps the value honest.
+      #
+      # Hhea runs alphabetically before Hmtx, so the Hmtx strategy's
+      # SharedState cache hasn't been populated yet — we walk the source
+      # hmtx directly to find the max.
+      class Hhea
+        # @param context [SubsetContext]
+        # @param tag [String] "hhea"
+        # @param table [Hhea] parsed hhea table
+        # @return [String] binary hhea bytes for the subset
+        def self.call(context:, tag:, table:)
+          data = table.to_binary_s.dup
+
+          new_num_h_metrics = calculate_number_of_h_metrics(context, table)
+          data[34, 2] = [new_num_h_metrics].pack("n")
+
+          new_max = compute_subset_max_advance(context)
+          data[10, 2] = [new_max].pack("n") if new_max.positive?
+
+          data
+        end
+
+        def self.calculate_number_of_h_metrics(context, _table)
+          hmtx = context.font.table("hmtx")
+          if hmtx&.parsed? && hmtx.h_metrics
+            hmtx.h_metrics.size
+          else
+            context.mapping.size
+          end
+        end
+
+        def self.compute_subset_max_advance(context)
+          hmtx = context.font.table("hmtx")
+          return 0 unless hmtx
+
+          unless hmtx.parsed?
+            hhea = context.font.table("hhea")
+            maxp = context.font.table("maxp")
+            hmtx.parse_with_context(hhea.number_of_h_metrics,
+                                    maxp.num_glyphs)
+          end
+
+          max_advance = 0
+          context.mapping.old_ids.each do |old_id|
+            metric = hmtx.metric_for(old_id)
+            next unless metric
+
+            advance = metric[:advance_width]
+            max_advance = advance if advance && advance > max_advance
+          end
+          max_advance
+        end
+        private_class_method :calculate_number_of_h_metrics,
+                             :compute_subset_max_advance
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Hmtx strategy: emit one LongHorMetric per glyph in the subset's
+      # glyph mapping, in the same order as the mapping. Also records
+      # the maximum advanceWidth into [SharedState] so Hhea (which is
+      # processed alphabetically before Hmtx) can read it.
+      #
+      # Tables are processed in profile order — Hhea comes before Hmtx
+      # alphabetically — so Hhea reads its max advance via a private
+      # helper that walks the source hmtx directly. Hmtx then stashes
+      # the value into SharedState for any later consumer.
+      class Hmtx
+        # @param context [SubsetContext]
+        # @param tag [String] "hmtx"
+        # @param table [Hmtx] parsed hmtx table
+        # @return [String] binary hmtx bytes for the subset
+        def self.call(context:, tag:, table:)
+          ensure_parsed!(context, table)
+
+          data = String.new(encoding: Encoding::BINARY)
+          max_advance = 0
+
+          context.mapping.old_ids.each do |old_id|
+            metric = table.metric_for(old_id)
+            next unless metric
+
+            advance = metric[:advance_width]
+            max_advance = advance if advance && advance > max_advance
+            data << [advance].pack("n")
+            data << [metric[:lsb]].pack("n")
+          end
+
+          context.state.subset_max_advance = max_advance
+          data
+        end
+
+        def self.ensure_parsed!(context, table)
+          return if table.parsed?
+
+          hhea = context.font.table("hhea")
+          maxp = context.font.table("maxp")
+          table.parse_with_context(hhea.number_of_h_metrics,
+                                   maxp.num_glyphs)
+        end
+        private_class_method :ensure_parsed!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Loca strategy: emit one entry per subset glyph + a final offset,
+      # using short or long format based on the source head.index_to_loc_format.
+      # Glyph offsets come from [SharedState], populated earlier by the
+      # Glyf strategy. If Glyf hasn't run yet (e.g. direct invocation
+      # from a spec), this strategy triggers the build lazily.
+      class Loca
+        # @param context [SubsetContext]
+        # @param tag [String] "loca"
+        # @param table [Loca] parsed loca table (unused)
+        # @return [String] binary loca bytes for the subset
+        def self.call(context:, tag:, table:)
+          offsets = context.state.loca_offsets
+          if offsets.nil?
+            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
+            offsets = builder.loca_offsets
+          end
+
+          head = context.font.table("head")
+          data = String.new(encoding: Encoding::BINARY)
+
+          if head.index_to_loc_format.zero?
+            offsets.each { |o| data << [o / 2].pack("n") }
+          else
+            offsets.each { |o| data << [o].pack("N") }
+          end
+
+          data
+        end
+      end
+    end
+  end
+end