fontisan 0.4.22 → 0.4.24

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

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

@@ -0,0 +1,146 @@
+# 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