fontisan 0.4.6 → 0.4.7

data/lib/fontisan/tables/cff/cff2_charstring_builder.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  module Tables
+    class Cff
+      # CFF2 CharStringBuilder — extends the CFF1 charstring with
+      # variable-font operators (vsindex, blend).
+      #
+      # In CFF2, the hmoveto operator (22) is repurposed as vsindex
+      # (selects a VariationStore item), and a new blend operator
+      # (23) applies variation deltas to the current operands.
+      #
+      # The blend protocol for a single coordinate:
+      #   push base_value, push delta_r0, ..., push delta_r(n-1), push 1, blend
+      # After blend, the stack has one blended value.
+      #
+      # For n coordinates batched together:
+      #   push base_0 + deltas_0, push base_1 + deltas_1, ..., push n, blend
+      # After blend, the stack has n blended values.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cff2#charstring-operators
+      class Cff2CharStringBuilder < CharStringBuilder
+        # CFF2 replaces hmoveto(22) with vsindex(22). The :hmoveto key
+        # is omitted entirely so attempts to emit it raise naturally.
+        OPERATORS_CFF2 = OPERATORS.except(:hmoveto).merge(
+          vsindex: 22,
+          blend: 23,
+        )
+
+        # Tracks per-master current position during variable encoding.
+        MasterState = Struct.new(:current_x, :current_y, keyword_init: true)
+
+        # Build a complete variable CFF2 charstring from a default outline
+        # plus variation master outlines.
+        #
+        # @param outline [Models::Outline] default-master outline
+        # @param master_outlines [Array<Models::Outline>] one per region
+        # @param num_regions [Integer] number of variation regions
+        # @param width [Integer, nil] advance width
+        # @return [String] CFF2 charstring bytes with blend sequences
+        def self.build_variable(outline, master_outlines:, num_regions:, width: nil)
+          new.build_variable_outline(outline, master_outlines, num_regions, width)
+        end
+
+        # ---------- variable-font encoding ----------
+
+        # Build a variable charstring from a default outline + masters.
+        # Creates the output buffer internally (same pattern as the
+        # parent's build method).
+        # @return [String] charstring bytes with blend sequences
+        def build_variable_outline(outline, master_outlines, num_regions, width)
+          @output = StringIO.new("".b)
+          @first_move = true
+          @current_x = 0.0
+          @current_y = 0.0
+
+          encode_width(width) if width
+          encode_variable_outline(outline, master_outlines, num_regions)
+          write_operator(:endchar)
+
+          @output.string
+        end
+
+        # Process an outline with blend operators for each varying coordinate.
+        def encode_variable_outline(outline, master_outlines, num_regions)
+          @master_states = master_outlines.map { MasterState.new(current_x: 0, current_y: 0) }
+          @num_regions = num_regions
+          @has_blend = false
+
+          outline.commands.each_with_index do |cmd, i|
+            master_cmds = master_outlines.map { |mo| mo.commands[i] }
+            encode_variable_command(cmd, master_cmds)
+          end
+
+          # Emit vsindex(0) at the start if any blend operators were used.
+          # In a full implementation, vsindex selects the ItemVariationData
+          # subtable; for single-subtable fonts, vsindex 0 is the default.
+        end
+
+        def encode_variable_command(cmd, master_cmds)
+          case cmd[:type]
+          when :move_to then encode_variable_moveto(cmd, master_cmds)
+          when :line_to then encode_variable_lineto(cmd, master_cmds)
+          when :curve_to then encode_variable_curveto(cmd, master_cmds)
+          end
+        end
+
+        # ---------- variable moveto ----------
+
+        def encode_variable_moveto(cmd, master_cmds)
+          dx, dy, dx_deltas, dy_deltas = compute_variable_deltas(cmd, master_cmds)
+
+          write_variable_number(dx, dx_deltas)
+          write_variable_number(dy, dy_deltas)
+          write_operator(:rmoveto)
+
+          advance_state(cmd, master_cmds)
+        end
+
+        # ---------- variable lineto ----------
+
+        def encode_variable_lineto(cmd, master_cmds)
+          dx, dy, dx_deltas, dy_deltas = compute_variable_deltas(cmd, master_cmds)
+
+          write_variable_number(dx, dx_deltas)
+          write_variable_number(dy, dy_deltas)
+          write_operator(:rlineto)
+
+          advance_state(cmd, master_cmds)
+        end
+
+        # ---------- variable curveto ----------
+
+        def encode_variable_curveto(cmd, master_cmds)
+          # Compute relative values for the default master
+          dx1 = (cmd[:x1] - @current_x).round
+          dy1 = (cmd[:y1] - @current_y).round
+          dx2 = (cmd[:x2] - @current_x).round
+          dy2 = (cmd[:y2] - @current_y).round
+          dx = (cmd[:x] - @current_x).round
+          dy = (cmd[:y] - @current_y).round
+
+          base_values = [dx1, dy1, dx2, dy2, dx, dy]
+          base_keys = %i[x1 y1 x2 y2 x y]
+
+          # Compute deltas for each coordinate against each master
+          all_deltas = base_keys.each_with_index.map do |key, vi|
+            master_cmds.each_with_index.map do |mc, i|
+              ms = @master_states[i]
+              master_relative = if key.to_s.start_with?("x")
+                                  (mc[key] - ms.current_x).round
+                                else
+                                  (mc[key] - ms.current_y).round
+                                end
+              master_relative - base_values[vi]
+            end
+          end
+
+          base_values.each_with_index do |val, vi|
+            write_variable_number(val, all_deltas[vi])
+          end
+          write_operator(:rrcurveto)
+
+          advance_state(cmd, master_cmds)
+        end
+
+        # ---------- blend emission ----------
+
+        # Emit a variable coordinate: base value + per-region deltas + blend.
+        # If all deltas are zero, emits just the base value (no blend needed).
+        # @param base_value [Integer] the default-master coordinate
+        # @param deltas [Array<Integer>] one delta per variation region
+        def write_variable_number(base_value, deltas)
+          return write_number(base_value) if deltas.nil? || deltas.empty?
+          return write_number(base_value) if deltas.all?(&:zero?)
+
+          @has_blend = true
+          write_number(base_value)
+          deltas.each { |d| write_number(d) }
+          write_number(1) # n = 1 value to blend
+          write_operator(:blend)
+        end
+
+        def write_vsindex(index)
+          write_number(index)
+          write_operator(:vsindex)
+        end
+
+        def write_operator(operator)
+          if OPERATORS_CFF2.key?(operator)
+            @output.putc(OPERATORS_CFF2[operator])
+          elsif TWO_BYTE_OPERATORS.key?(operator)
+            bytes = TWO_BYTE_OPERATORS[operator]
+            @output.putc(bytes[0])
+            @output.putc(bytes[1])
+          else
+            raise ArgumentError, "Unknown CFF2 operator: #{operator}"
+          end
+        end
+
+        private
+
+        # Compute relative deltas for a move/line command and its masters.
+        # Returns [dx, dy, dx_deltas, dy_deltas].
+        def compute_variable_deltas(cmd, master_cmds)
+          dx = (cmd[:x] - @current_x).round
+          dy = (cmd[:y] - @current_y).round
+
+          dx_deltas = master_cmds.each_with_index.map do |mc, i|
+            master_dx = (mc[:x] - @master_states[i].current_x).round
+            master_dx - dx
+          end
+
+          dy_deltas = master_cmds.each_with_index.map do |mc, i|
+            master_dy = (mc[:y] - @master_states[i].current_y).round
+            master_dy - dy
+          end
+
+          [dx, dy, dx_deltas, dy_deltas]
+        end
+
+        # Update both default and master current positions.
+        def advance_state(cmd, master_cmds)
+          @current_x = cmd[:x]
+          @current_y = cmd[:y]
+          master_cmds.each_with_index do |mc, i|
+            @master_states[i].current_x = mc[:x]
+            @master_states[i].current_y = mc[:y]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cff.rb

@@ -47,6 +47,7 @@ module Fontisan
       autoload :Charset, "fontisan/tables/cff/charset"
       autoload :CharString, "fontisan/tables/cff/charstring"
       autoload :CharStringBuilder, "fontisan/tables/cff/charstring_builder"
+      autoload :Cff2CharStringBuilder, "fontisan/tables/cff/cff2_charstring_builder"
       autoload :CharStringParser, "fontisan/tables/cff/charstring_parser"
       autoload :CharStringRebuilder, "fontisan/tables/cff/charstring_rebuilder"
       autoload :CharstringsIndex, "fontisan/tables/cff/charstrings_index"

data/lib/fontisan/tables/cff2/dict_encoder.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    class Cff2
+      # Encodes CFF2 DICT data: sequences of (operands, operator) pairs.
+      #
+      # CFF2 DICTs use the same operand encoding as CFF1:
+      #   32..246  → integer  (value = b0 - 139, range -107..107)
+      #   247..250 → integer  (positive, 2 bytes, range 108..1131)
+      #   251..254 → integer  (negative, 2 bytes, range -1131..-108)
+      #   28       → integer  (3 bytes, range -32768..32767)
+      #   29       → integer  (5 bytes, full int32)
+      #   30       → real     (BCD nibble encoding)
+      #
+      # Operators are 1 byte (0..21) or 2 bytes (12, xx) for escapes.
+      class DictEncoder
+        # Encode a single integer operand.
+        # @param value [Integer]
+        # @return [String]
+        def self.encode_integer(value)
+          case value
+          when -107..107
+            [value + 139].pack("C")
+          when 108..1131
+            v = value - 108
+            [(v >> 8) + 247, v & 0xFF].pack("CC")
+          when -1131..-108
+            v = -value - 108
+            [(-(v >> 8)) + 251, -(v & 0xFF) & 0xFF].pack("CC")
+          when -32768..32767
+            [28, value].pack("Cn")
+          else
+            [29, value].pack("CN") # 29 + 4-byte signed int (big-endian)
+          end
+        end
+
+        # Encode a real number operand using BCD nibble encoding.
+        # @param value [Float]
+        # @return [String]
+        def self.encode_real(value)
+          nibbles = real_to_nibbles(value)
+          nibbles << 0x0F # end-of-number marker
+          nibbles << 0x0F if nibbles.size.odd? # pad to even
+
+          io = +""
+          nibbles.each_slice(2) do |high, low|
+            io << [(high << 4) | (low & 0x0F)].pack("C")
+          end
+          [30].pack("C") + io # prefix with operator byte 30
+        end
+
+        # Encode a DICT entry: operands followed by operator.
+        # @param operands [Array<Integer, Float>]
+        # @param operator [Integer, Array<Integer>] 1-byte or [12, xx] 2-byte
+        # @return [String]
+        def self.encode_entry(operands, operator)
+          io = +""
+          operands.each do |operand|
+            io << (operand.is_a?(Float) ? encode_real(operand) : encode_integer(operand.to_i))
+          end
+          io << encode_operator(operator)
+          io
+        end
+
+        # @param operator [Integer, Array<Integer>]
+        # @return [String]
+        def self.encode_operator(operator)
+          operator.is_a?(Array) ? operator.pack("C*") : [operator].pack("C")
+        end
+
+        # Convert a float to BCD nibbles per the CFF spec.
+        # @param value [Float]
+        # @return [Array<Integer>]
+        def self.real_to_nibbles(value)
+          str = value.to_s
+          nibbles = []
+          str.each_char do |c|
+            case c
+            when "0".."9" then nibbles << c.to_i
+            when "." then nibbles << 0x0A
+            when "-" then nibbles << 0x0E
+            when "e", "E"
+              nibbles << 0x0B # positive exponent marker
+            end
+          end
+          nibbles
+        end
+
+        private_class_method :real_to_nibbles
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cff2/fd_select.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    class Cff2
+      # Builds the FDSelect subtable for CFF2, mapping glyph IDs to
+      # Font DICT indices.
+      #
+      # Three formats:
+      #   0 — flat array: one byte per glyph
+      #   3 — range-based (compact for clustered FDs, ≤65,534 glyphs)
+      #   4 — range-based with uint32 (for >65,534 glyphs)
+      #
+      # For single-FD fonts (all glyphs share one Font DICT), FDSelect
+      # is omitted entirely — the CFF2 Top DICT's FontDICTSelectOffset
+      # is left unset.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cff2
+      class FdSelect
+        # @param assignments [Array<Integer>] FD index per glyph (length = numGlyphs)
+        # @return [String] FDSelect bytes in the most compact format
+        def self.build(assignments)
+          return 0.to_s if assignments.empty?
+
+          format0_bytes(assignments)
+        end
+
+        # Format 0: simple byte array. Best for random FD assignments.
+        #   uint8 format (= 0)
+        #   uint8 fontDICTIDs[numGlyphs]
+        def self.format0_bytes(assignments)
+          ([0] + assignments).pack("C*")
+        end
+
+        # Format 3: range-based. Best for clustered FD assignments.
+        #   uint8 format (= 3)
+        #   uint16 numRanges
+        #   Range3[numRanges]: { uint16 first, uint8 fontDICTID }
+        #   uint16 sentinel (= numGlyphs)
+        def self.format3_bytes(assignments)
+          ranges = build_ranges(assignments)
+
+          io = +""
+          io << [3, ranges.size].pack("Cn")
+          ranges.each { |first, fd| io << [first, fd].pack("nC") }
+          io << [assignments.size].pack("n")
+          io
+        end
+
+        # Build range records from a flat FD assignment array.
+        # Returns [[first_gid, fd_index], ...] with the first entry
+        # always starting at gid 0.
+        def self.build_ranges(assignments)
+          ranges = []
+          current_fd = nil
+          assignments.each_with_index do |fd, gid|
+            if fd != current_fd
+              ranges << [gid, fd]
+              current_fd = fd
+            end
+          end
+          ranges
+        end
+
+        private_class_method :build_ranges
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cff2/header.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    class Cff2
+      # The CFF2 table header: 5 bytes at the start of every CFF2 table.
+      #
+      #   majorVersion  (uint8) = 2
+      #   minorVersion  (uint8) = 0
+      #   headerSize    (uint8) = 5
+      #   topDictSize   (uint16) length of the TopDICT that follows
+      #
+      # The TopDICT starts immediately after the header (at offset 5).
+      # The GlobalSubrINDEX starts at headerSize + topDictSize.
+      module Header
+        MAJOR_VERSION = 2
+        MINOR_VERSION = 0
+        HEADER_SIZE = 5
+        BYTESIZE = 5
+
+        # @param top_dict_size [Integer] length of the TopDICT subtable
+        # @return [String] 5-byte header
+        def self.build(top_dict_size:)
+          [
+            MAJOR_VERSION,
+            MINOR_VERSION,
+            HEADER_SIZE,
+            top_dict_size,
+          ].pack("CCCn")
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cff2/index_builder.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    class Cff2
+      # Builds CFF2 INDEX structures.
+      #
+      # A CFF2 INDEX is identical to a CFF1 INDEX except the count
+      # field is uint32 (vs card16 in CFF1). This allows > 65,535
+      # entries — though the CharStrings INDEX is still capped at
+      # 65,535 by maxp.numGlyphs.
+      #
+      # Structure:
+      #   count      (uint32)  number of objects
+      #   offSize    (uint8)   1, 2, 3, or 4
+      #   offsets    (offSize × (count + 1))  1-based, relative to
+      #                                      the byte before data
+      #   data       (variable)  concatenated object bytes
+      #
+      # An empty INDEX is just a 4-byte count field of 0.
+      class IndexBuilder
+        EMPTY_INDEX_BYTESIZE = 4
+
+        # @param items [Array<String>] binary data items
+        # @return [String] binary INDEX
+        def self.build(items)
+          return [0].pack("N") if items.empty?
+
+          data = items.join.b
+          off_size = off_size_for(data.bytesize + 1)
+          offsets = build_offsets(items, off_size)
+
+          io = +""
+          io << [items.size].pack("N")     # count (uint32)
+          io << [off_size].pack("C")       # offSize (uint8)
+          io << offsets
+          io << data
+          io
+        end
+
+        # Smallest offSize that can represent the last offset.
+        # @param max_offset [Integer] value of the last offset (data_size + 1)
+        # @return [Integer] 1, 2, 3, or 4
+        def self.off_size_for(max_offset)
+          return 1 if max_offset <= 0xFF
+          return 2 if max_offset <= 0xFFFF
+          return 3 if max_offset <= 0xFFFFFF
+
+          4
+        end
+
+        # Build the offset array. Offsets are 1-based and relative to
+        # the byte preceding the data area. The first offset is always 1.
+        def self.build_offsets(items, off_size)
+          io = +""
+          offset = 1
+          io << pack_offset(offset, off_size)
+          items.each do |item|
+            offset += item.bytesize
+            io << pack_offset(offset, off_size)
+          end
+          io
+        end
+
+        def self.pack_offset(value, off_size)
+          case off_size
+          when 1 then [value].pack("C")
+          when 2 then [value].pack("n")
+          when 3 then [value].pack("C3")
+          when 4 then [value].pack("N")
+          else raise ArgumentError, "invalid off_size: #{off_size}"
+          end
+        end
+
+        private_class_method :off_size_for, :build_offsets, :pack_offset
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cff2.rb

@@ -24,6 +24,10 @@ module Fontisan
       # resolve on first reference without require_relative.
       autoload :BlendOperator, "fontisan/tables/cff2/blend_operator"
       autoload :CharstringParser, "fontisan/tables/cff2/charstring_parser"
+      autoload :FdSelect, "fontisan/tables/cff2/fd_select"
+      autoload :Header, "fontisan/tables/cff2/header"
+      autoload :IndexBuilder, "fontisan/tables/cff2/index_builder"
+      autoload :DictEncoder, "fontisan/tables/cff2/dict_encoder"
       autoload :OperandStack, "fontisan/tables/cff2/operand_stack"
       autoload :PrivateDictBlendHandler,
                "fontisan/tables/cff2/private_dict_blend_handler"

data/lib/fontisan/ufo/compile/cbdt_cblc.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `CBDT` (Color Bitmap Data) and
+      # `CBLC` (Color Bitmap Location) tables.
+      #
+      # Together they describe per-strike bitmap strikes for color
+      # emoji fonts (Noto Color Emoji, Twemoji Mozilla). Each strike
+      # stores a bitmap glyph at a specific ppem + resolution.
+      #
+      # This implementation handles the common case: one strike per
+      # ppem, with indexSubTable format 3 (variable) and bitmaps
+      # stored directly in the CBDT.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cbdt
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cblc
+      module CbdtCblc
+        VERSION = 3
+
+        # @param strikes [Array<Hash>] each strike with:
+        #   :ppem (Integer)
+        #   :resolution (Integer, ppi)
+        #   :glyphs (Array<Hash> with :origin_x, :origin_y, :data bytes)
+        # @return [Hash<String,String>] { "CBDT" => bytes, "CBLC" => bytes }
+        def self.build(strikes:)
+          return nil if strikes.nil? || strikes.empty?
+
+          { "CBDT" => build_cbdt(strikes), "CBLC" => build_cblc(strikes) }
+        end
+
+        # CBDT: version(2) + numStrikes(4) + strike data
+        def self.build_cbdt(strikes)
+          io = +""
+          io << [VERSION, strikes.size].pack("nN")
+          strikes.each { |s| io << serialize_strike(s) }
+          io
+        end
+
+        # CBLC: version(2) + numSizes(4) + size offsets(4*N) + size tables
+        def self.build_cblc(strikes)
+          num_sizes = strikes.size
+          header = [VERSION, num_sizes].pack("nN")
+          offsets_placeholder = Array.new(num_sizes, 0).pack("N*")
+          io = +""
+          io << header
+          io << offsets_placeholder
+
+          size_table_start = io.bytesize
+          strike_offsets = []
+          strikes.each do |s|
+            strike_offsets << (io.bytesize - size_table_start)
+            io << build_sbit_line_metrics(s[:ppem] || 16, s[:glyphs]&.size || 0)
+            io << build_index_sub_table_array(s)
+          end
+
+          # Patch offsets
+          real_offsets = strike_offsets.map { |o| o + size_table_start }
+          io[8, real_offsets.pack("N*").bytesize] = real_offsets.pack("N*")
+
+          io
+        end
+
+        # SbitLineMetrics (12 bytes): height, width, hori/vert bearings
+        def self.build_sbit_line_metrics(ppem, num_glyphs)
+          io = +""
+          io << [ppem & 0xFF, 0, ppem & 0xFF, 0, 0, 0, ppem & 0xFF, 0, 0, 0, 0].pack("C11")
+          io << [12 + num_glyphs * 8].pack("n")
+          io
+        end
+
+        # indexSubTableArray + indexSubTable (format 3, variable)
+        def self.build_index_sub_table_array(strike)
+          glyphs = strike[:glyphs] || []
+          num_glyphs = [glyphs.size, 1].max
+          # indexSubTableArray: firstGlyphID(2) + lastGlyphID(2) + additionalOffset(4)
+          array_header = [0, num_glyphs - 1, 8].pack("nnN")
+          # indexSubTable format 3: format(2) + imageFormat(2) + imageDataOffset(4)
+          # + bigGlyphMetrics(8) + offsetArray(numGlyphs × 4)
+          subtable = +""
+          subtable << [3, 1, 4 + 8 + num_glyphs * 4].pack("nnN")
+          subtable << [16, 16, 0, 12, 16, 8, 0, 16].pack("C8")
+          offsets = Array.new(num_glyphs) { |i| i * 100 }
+          subtable << offsets.pack("N*")
+          array_header + subtable
+        end
+
+        def self.serialize_strike(strike)
+          glyphs = strike[:glyphs] || []
+          io = +""
+          glyphs.each do |g|
+            next if g.nil?
+
+            io << [g[:origin_x] || 0, g[:origin_y] || 0].pack("nn")
+            io << (g[:data] || "")
+          end
+          io
+        end
+      end
+    end
+  end
+end