fontisan 0.3.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0979321b74749068da214fbb4880701c1f78905cce2db2aa7a8a2263da669af3'
-  data.tar.gz: 3ccbb49464b62e831475fe601fecc9b7085c6dda5a16ec66d9b9c56c14ff0742
+  metadata.gz: 58c1e2768684af1fcdc55fdc2d5b3e47bbd89b0277794dc64ff627ef8d571c3d
+  data.tar.gz: 8d1da959f850b3872acb01e96deb098ea2cbb0d596a0923b5db4960edfd818bf
 SHA512:
-  metadata.gz: 87538383c69009f3610778a717ae6263accb950e07b8803914358927bfc1e7510c18c664d88267b17dcabbeaab4fa97d4ac72b3294ae492472d0659843dbe540
-  data.tar.gz: 459343281dd3b295141eed4c8091ccc3d9ce6228d49c293eb6a182d26676428eaf4cb571295b8f55ac4101ba88d879c7525b06f5ad1596a83ea544d2f88a8351
+  metadata.gz: 3e46507d14358098c09f5ee2a3584c601e3d28e6a762f506962007445fb9fcd4432db7f591601575fac87d9cad93ae7c57d2c464728888e33dd6b242387c5611
+  data.tar.gz: 1e2dc941fe06dc9769aad1477c970ac48e799d62f3340a08448c0528290562ce2f9ccfd0e021615ebc57a26bcdd19773fd51135d4d214ef31e2a927576c7d06f

data/README.adoc

@@ -2475,6 +2475,36 @@ fontisan stitch \
   --output stitched.ttf
 ----
 
+=== Color emoji (CBDT/CBLC passthrough)
+
+Sources with CBDT/CBLC tables (e.g. NotoColorEmoji) can be used as
+Stitcher sources. The bitmap data is propagated byte-for-byte from the
+source into the output. The Stitcher automatically detects the source's
+storage mode via `bitmap_mode`:
+
+[source,ruby]
+----
+stitcher = Fontisan::Stitcher.new
+stitcher.add_source(:text, Fontisan::FontLoader.load("NotoSans.ttf"))
+stitcher.add_source(:emoji, Fontisan::FontLoader.load("NotoColorEmoji.ttf"))
+
+# All emoji glyphs from the CBDT source are added; the CBLC table
+# is copied byte-for-byte and references the right GIDs.
+stitcher.include_range(0x41..0x5A, from: :text)
+stitcher.include_range(0x1F600..0x1F64F, from: :emoji)
+
+stitcher.write_to("out.ttf", format: :ttf)
+# → out.ttf has glyf + CBDT + CBLC, emoji renders correctly
+----
+
+**Constraints:**
+- Only ONE CBDT source per Stitcher (multiple raise
+  `Fontisan::MultipleCbdtSourcesError`)
+- The CBDT source is processed first (GIDs 0..N-1) so the CBLC's GID
+  references remain valid in the output
+- Multi-source CBDT merge is tracked as TODO (REVIEW
+  `TODO.full/ufo/23-cbdt-passthrough.md`)
+
 
 == Testing
 

data/lib/fontisan/error.rb

@@ -199,6 +199,13 @@ module Fontisan
     end
   end
 
+  # Multiple CBDT sources detected in Stitcher
+  #
+  # Raised when more than one CBDT/CBLC source is registered with the
+  # Stitcher. Only single-source CBDT passthrough is supported; merging
+  # CBDT/CBLC across multiple sources requires a dedicated rebuild.
+  class MultipleCbdtSourcesError < Error; end
+
   # Variation data corrupted (for use in data_extractor)
   #
   # Raised when extracted variation data appears corrupted.

data/lib/fontisan/stitcher/source.rb

@@ -6,16 +6,21 @@ module Fontisan
     # extraction API used by the selectors.
     #
     # For UFO sources, glyphs are accessed by name directly. For TTF
-    # or OTF sources, the source is lazily converted to a UFO::Font
-    # via Ufo::Convert::FromBinData on first glyph access, then cached.
-    # This is O(n) in donor glyph count but amortized across all
-    # codepoint extractions from that donor.
+    # or OTF sources, individual glyphs are extracted on demand from
+    # the BinData tables (glyf/loca/head for TTF, CFF for OTF). This
+    # is O(1) per glyph rather than the previous O(n) full-donor
+    # conversion.
+    #
+    # CBDT/CBLC sources (e.g. NotoColorEmoji) are detected via
+    # #bitmap_mode. When a source is :cbdt, the Stitcher propagates
+    # the raw CBDT/CBLC tables into the output instead of extracting
+    # outlines. The glyph data lives in the bitmap tables, not in glyf.
     class Source
       attr_reader :font
 
       def initialize(font)
         @font = font
-        @ufo_cache = nil
+        @bin_data_cache = nil
       end
 
       # @return [Symbol] :ufo, :ttf, :otf
@@ -28,6 +33,27 @@ module Fontisan
         end
       end
 
+      # Detect how this source stores glyph data.
+      #
+      # - :glyf — TrueType outlines (glyf table present)
+      # - :cbdt — Color bitmaps (CBDT + CBLC tables, no glyf)
+      # - :mixed — Both glyf and CBDT
+      # - :none  — UFO source or neither table present
+      #
+      # @return [Symbol]
+      def bitmap_mode
+        return :none if @font.is_a?(Fontisan::Ufo::Font)
+        return :none unless @font.respond_to?(:has_table?)
+
+        has_cbdt = @font.has_table?("CBDT") && @font.has_table?("CBLC")
+        has_glyf = @font.has_table?("glyf") || @font.has_table?("CFF ")
+        return :mixed if has_cbdt && has_glyf
+        return :cbdt if has_cbdt
+        return :glyf if has_glyf
+
+        :none
+      end
+
       # Find the gid for a Unicode codepoint in this source.
       # @param codepoint [Integer]
       # @return [Integer, nil]
@@ -39,15 +65,44 @@ module Fontisan
       end
 
       # Extract a glyph by gid.
+      #
+      # For TTF/OTF sources, this is O(1) per glyph: it parses just
+      # the requested glyph from glyf/CFF on demand, not the entire
+      # donor. The full-donor conversion is avoided entirely.
+      #
+      # For CBDT sources, returns a placeholder glyph (no contours)
+      # since the glyph data is in the bitmap tables, not outlines.
+      #
       # @param gid [Integer]
       # @return [Fontisan::Ufo::Glyph, nil]
       def glyph_for_gid(gid)
         case @font
         when Fontisan::Ufo::Font then ufo_glyph_at(gid)
-        else converted_ufo_glyph_at(gid)
+        else extract_single_glyph_from_bindata(gid)
         end
       end
 
+      # Raw table bytes from the loaded font (for passthrough).
+      # @param tag [String] 4-byte table tag (e.g. "CBDT", "CBLC")
+      # @return [String, nil] raw bytes or nil if table not present
+      def raw_table_bytes(tag)
+        sfnt_table = @font.table(tag)
+        return nil unless sfnt_table
+
+        sfnt_table.raw_data
+      rescue StandardError
+        nil
+      end
+
+      # Width of a specific glyph (extracted from hmtx).
+      # Falls back to 0 if hmtx is missing.
+      # @param gid [Integer]
+      # @return [Integer]
+      def glyph_width(gid)
+        widths = bin_data_widths
+        widths[gid] || 0
+      end
+
       private
 
       # ---------- UFO source ----------
@@ -67,7 +122,7 @@ module Fontisan
         @font.glyph(name)
       end
 
-      # ---------- TTF/OTF source ----------
+      # ---------- TTF/OTF source: O(1) per-glyph extraction ----------
 
       def bin_data_gid_for(codepoint)
         cmap = @font.table("cmap")
@@ -76,21 +131,111 @@ module Fontisan
         cmap.unicode_mappings[codepoint]
       end
 
-      # Lazily convert the loaded TTF/OTF to a UFO::Font, then
-      # extract glyphs from the cached UFO model.
-      def converted_ufo
-        return @ufo_cache if @ufo_cache
+      # Lazily parse the relevant BinData tables. Cached so we only
+      # pay the parse cost once per source.
+      def bin_data_cache
+        @bin_data_cache ||= parse_bin_data_tables
+      end
 
-        @ufo_cache = Fontisan::Ufo::Convert::FromBinData.convert(@font)
+      def parse_bin_data_tables
+        cache = { head: @font.table("head") }
+
+        if @font.has_table?("glyf")
+          cache[:loca] = @font.table("loca")
+          cache[:glyf] = @font.table("glyf")
+          # loca needs head's index_to_loc_format to size its offsets
+          if cache[:loca].respond_to?(:parse_with_context) && cache[:head]
+            cache[:loca].parse_with_context(
+              cache[:head].index_to_loc_format,
+              @font.table("maxp")&.num_glyphs || 0,
+            )
+          end
+        end
+
+        cache
       end
 
-      def converted_ufo_glyph_at(gid)
-        ufo = converted_ufo
-        names = ufo.glyphs.keys
-        name = names[gid]
-        return nil unless name
+      # Build {gid → advance_width} from hmtx (cached).
+      def bin_data_widths
+        @bin_data_widths ||= build_bin_data_widths
+      end
+
+      def build_bin_data_widths
+        widths = {}
+        hmtx = @font.table("hmtx")
+        return widths unless hmtx
+
+        hhea = @font.table("hhea")
+        maxp = @font.table("maxp")
+        num_h_metrics = hhea&.number_of_h_metrics || 1
+        num_glyphs = maxp&.num_glyphs || 0
 
-        ufo.glyph(name)
+        if hmtx.respond_to?(:parse_with_context)
+          hmtx.parse_with_context(num_h_metrics, num_glyphs)
+        end
+
+        num_glyphs.times do |gid|
+          metric = hmtx.respond_to?(:metric_for) ? hmtx.metric_for(gid) : nil
+          widths[gid] = metric ? metric[:advance_width] : 0
+        rescue StandardError
+          widths[gid] = 0
+        end
+        widths
+      end
+
+      # Extract a single glyph by gid, parsing just the relevant bytes.
+      # O(1) per call (after the first call's table-parsing overhead).
+      def extract_single_glyph_from_bindata(gid)
+        cache = bin_data_cache
+
+        if cache[:glyf] && cache[:loca] && cache[:head]
+          extract_truetype_glyph(gid, cache)
+        end
+      end
+
+      def extract_truetype_glyph(gid, cache)
+        simple = cache[:glyf].glyph_for(gid, cache[:loca], cache[:head])
+        return nil unless simple
+        return nil unless simple.respond_to?(:simple?) && simple.simple?
+
+        name = gid.zero? ? ".notdef" : "gid#{gid}"
+        glyph = Fontisan::Ufo::Glyph.new(name: name)
+        glyph.width = glyph_width(gid)
+        copy_simple_contours(simple, glyph)
+        add_cmap_unicodes(gid, glyph)
+        glyph
+      rescue StandardError
+        nil
+      end
+
+      # Copy a SimpleGlyph's contours + points into a Ufo::Glyph.
+      def copy_simple_contours(simple, ufo_glyph)
+        num_contours = simple.end_pts_of_contours&.size || 0
+        return if num_contours.zero?
+
+        num_contours.times do |ci|
+          points = simple.points_for_contour(ci)
+          next unless points && !points.empty?
+
+          ufo_points = points.map do |pt|
+            x = pt[:x] || pt["x"]
+            y = pt[:y] || pt["y"]
+            on_curve = pt[:on_curve].nil? || pt[:on_curve]
+            type = on_curve ? "line" : "offcurve"
+            Fontisan::Ufo::Point.new(x: x.to_f, y: y.to_f, type: type)
+          end
+          ufo_glyph.add_contour(Fontisan::Ufo::Contour.new(ufo_points))
+        end
+      end
+
+      # Add Unicode codepoints from the cmap that map to this gid.
+      def add_cmap_unicodes(gid, glyph)
+        cmap = @font.table("cmap")
+        return unless cmap
+
+        (cmap.unicode_mappings || {}).each do |cp, g|
+          glyph.add_unicode(cp) if g == gid
+        end
       end
     end
   end

data/lib/fontisan/stitcher.rb

@@ -70,12 +70,23 @@ module Fontisan
     end
 
     # Write the stitched font to disk.
+    #
+    # For CBDT/CBLC sources (e.g. NotoColorEmoji), the raw CBDT and
+    # CBLC tables are copied byte-for-byte into the output. This works
+    # because CBDT-mode glyphs are processed first (GIDs 0..N-1),
+    # matching the source's GID layout. Only one CBDT source is
+    # supported; multiple CBDT sources raise MultipleCbdtSourcesError.
+    #
     # @param path [String] output file path
     # @param format [Symbol] :ttf or :otf
     def write_to(path, format: :ttf)
       build_target_font
       compiler = compiler_for(format)
-      compiler.new(@target).compile(output_path: path)
+      compiler_instance = compiler.new(@target)
+      compiler_instance.compile(output_path: path)
+
+      propagate_cbdt_tables(path) if cbdt_source
+
       path
     end
 
@@ -96,6 +107,53 @@ module Fontisan
       end
     end
 
+    # Find the single CBDT source among registered sources, if any.
+    # Raises if more than one CBDT source is present (merge not supported).
+    # @return [Source, nil]
+    def cbdt_source
+      cbdts = @sources.values.select { |s| s.bitmap_mode == :cbdt }
+      if cbdts.size > 1
+        raise MultipleCbdtSourcesError,
+              "multiple CBDT sources not supported (found #{cbdts.size})"
+      end
+
+      cbdts.first
+    end
+
+    # Copy raw CBDT + CBLC table bytes from the CBDT source into the
+    # compiled output file. The GIDs must match (CBDT glyphs are at
+    # the same GIDs in both source and output because they were added
+    # first during build_target_font).
+    def propagate_cbdt_tables(path)
+      source = cbdt_source
+      return unless source
+
+      compiled = Fontisan::FontLoader.load(path)
+
+      tables = {}
+      compiled.table_names.each do |tag|
+        raw = extract_raw_table(compiled, tag)
+        tables[tag] = raw if raw
+      end
+
+      cbdt_bytes = source.raw_table_bytes("CBDT")
+      cblc_bytes = source.raw_table_bytes("CBLC")
+      tables["CBDT"] = cbdt_bytes if cbdt_bytes
+      tables["CBLC"] = cblc_bytes if cblc_bytes
+
+      sfnt = tables.key?("CFF ") ? 0x4F54544F : 0x00010000
+      Fontisan::FontWriter.write_to_file(tables, path, sfnt_version: sfnt)
+    end
+
+    def extract_raw_table(font, tag)
+      sfnt_table = font.table(tag)
+      return nil unless sfnt_table
+
+      sfnt_table.raw_data
+    rescue StandardError
+      nil
+    end
+
     def compiler_for(format)
       case format.to_sym
       when :ttf then Ufo::Compile::TtfCompiler
@@ -107,26 +165,28 @@ module Fontisan
 
     # Walk bindings in codepoint order, assign sequential new gids,
     # copy each glyph into the target font's default layer.
+    #
+    # When a CBDT source is present, its glyphs are added FIRST (in
+    # source GID order) so that the CBLC's GID references remain valid.
+    # Glyf-source bindings are processed AFTER, appending new glyphs.
     def assign_gids_and_copy_glyphs
-      # Always put .notdef at gid 0 first.
-      notdef_binding = @bindings.find { |b| b[:donor_gid].zero? }
-      if notdef_binding
-        copy_glyph_into(@target, name: ".notdef",
-                                 source: notdef_binding[:source],
-                                 donor_gid: 0)
+      cbdt = cbdt_source
+
+      if cbdt
+        add_all_cbdt_glyphs(cbdt)
       else
-        # Synthesize an empty .notdef
-        @target.layers.default_layer.add(Ufo::Glyph.new(name: ".notdef"))
+        add_notdef_from_bindings
       end
 
       sorted_bindings.each do |binding|
-        next if binding[:donor_gid].zero? # already handled
+        next if binding[:donor_gid].zero?
+
+        # Skip bindings from the CBDT source — its glyphs are already added.
+        next if cbdt && binding[:source].equal?(cbdt)
 
         glyph = binding[:source].glyph_for_gid(binding[:donor_gid])
         next unless glyph
 
-        # If multiple codepoints map to the same glyph, only the first
-        # binding creates the glyph; subsequent ones add unicode entries.
         if @target.glyphs.key?(glyph.name)
           add_extra_unicode(glyph.name, binding[:codepoint])
         else
@@ -159,6 +219,51 @@ module Fontisan
       glyph.add_unicode(codepoint) unless glyph.unicodes.include?(codepoint)
     end
 
+    # Add .notdef at GID 0 from the first binding that references gid 0.
+    # Falls back to a synthesized empty .notdef if none found.
+    def add_notdef_from_bindings
+      notdef_binding = @bindings.find { |b| b[:donor_gid].zero? }
+      if notdef_binding
+        copy_glyph_into(@target, name: ".notdef",
+                                 source: notdef_binding[:source],
+                                 donor_gid: 0)
+      else
+        @target.layers.default_layer.add(Ufo::Glyph.new(name: ".notdef"))
+      end
+    end
+
+    # Add ALL glyphs from a CBDT source in source GID order. This
+    # ensures the CBLC's GID references remain valid in the output
+    # without rewriting the table. Each glyph gets a placeholder
+    # (no contours) since the bitmap data is in CBDT, not glyf.
+    def add_all_cbdt_glyphs(source)
+      ufo = source.font.is_a?(Ufo::Font) ? source.font : nil
+      if ufo
+        ufo.glyphs.each_value { |g| @target.layers.default_layer.add(clone_glyph(g, name: g.name)) }
+        return
+      end
+
+      # For loaded TTF/OTF sources, iterate via cmap to get glyph names.
+      # CBDT fonts (like NotoColorEmoji) may have thousands of glyphs;
+      # we add them all as placeholders.
+      maxp = source.font.table("maxp")
+      num_glyphs = maxp&.num_glyphs || 0
+      cmap = source.font.table("cmap")
+      mappings = cmap&.unicode_mappings || {}
+
+      # Build gid → [codepoints] from cmap
+      gid_cps = Hash.new { |h, k| h[k] = [] }
+      mappings.each { |cp, gid| gid_cps[gid] << cp }
+
+      num_glyphs.times do |gid|
+        name = gid.zero? ? ".notdef" : "gid#{gid}"
+        glyph = Ufo::Glyph.new(name: name)
+        glyph.width = 0
+        gid_cps[gid].each { |cp| glyph.add_unicode(cp) }
+        @target.layers.default_layer.add(glyph)
+      end
+    end
+
     # Deep-copy a glyph with a new name. Used so multiple target
     # glyphs can share the same source outline without aliasing.
     def clone_glyph(original, name:)

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.3.1"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.1
 platform: ruby
 authors:
 - Ribose Inc.