fontisan 0.1.0 → 0.2.1

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

@@ -0,0 +1,356 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  module Tables
+    class Cff
+      # Type 2 CharString builder/encoder
+      #
+      # [`CharStringBuilder`](lib/fontisan/tables/cff/charstring_builder.rb)
+      # encodes glyph outlines into Type 2 CharString binary format. It takes
+      # high-level outline commands and produces the stack-based CharString
+      # operators used in CFF fonts.
+      #
+      # Type 2 CharString encoding:
+      # - Numbers are encoded in various compact formats
+      # - Operators are single or two-byte commands
+      # - All coordinates are relative (dx, dy format)
+      # - Current point tracking for relative calculations
+      #
+      # Operator optimization:
+      # - Use specialized operators (hlineto, vlineto) when possible
+      # - Merge sequential operators of same type
+      # - Minimize operator bytes
+      #
+      # Reference: Adobe Type 2 CharString Format
+      # https://adobe-type-tools.github.io/font-tech-notes/pdfs/5177.Type2.pdf
+      #
+      # @example Building a CharString from outline
+      #   builder = Fontisan::Tables::Cff::CharStringBuilder.new
+      #   charstring_data = builder.build(outline, width: 500)
+      class CharStringBuilder
+        # Type 2 CharString operators (opposite of parser)
+        OPERATORS = {
+          hstem: 1,
+          vstem: 3,
+          vmoveto: 4,
+          rlineto: 5,
+          hlineto: 6,
+          vlineto: 7,
+          rrcurveto: 8,
+          callsubr: 10,
+          return: 11,
+          endchar: 14,
+          hstemhm: 18,
+          hintmask: 19,
+          cntrmask: 20,
+          rmoveto: 21,
+          hmoveto: 22,
+          vstemhm: 23,
+          rcurveline: 24,
+          rlinecurve: 25,
+          vvcurveto: 26,
+          hhcurveto: 27,
+          shortint: 28,
+          callgsubr: 29,
+          vhcurveto: 30,
+          hvcurveto: 31,
+        }.freeze
+
+        # Two-byte operators (12 prefix)
+        TWO_BYTE_OPERATORS = {
+          and: [12, 3],
+          or: [12, 4],
+          not: [12, 5],
+          abs: [12, 9],
+          add: [12, 10],
+          sub: [12, 11],
+          div: [12, 12],
+          neg: [12, 14],
+          eq: [12, 15],
+          drop: [12, 18],
+          put: [12, 20],
+          get: [12, 21],
+          ifelse: [12, 22],
+          random: [12, 23],
+          mul: [12, 24],
+          sqrt: [12, 26],
+          dup: [12, 27],
+          exch: [12, 28],
+          index: [12, 29],
+          roll: [12, 30],
+          hflex: [12, 34],
+          flex: [12, 35],
+          hflex1: [12, 36],
+          flex1: [12, 37],
+        }.freeze
+
+        # Build a CharString from an outline
+        #
+        # @param outline [Models::Outline] Universal outline object
+        # @param width [Integer, nil] Glyph width (optional)
+        # @return [String] Binary CharString data
+        def build(outline, width: nil)
+          @output = StringIO.new("".b)
+          @current_x = 0.0
+          @current_y = 0.0
+          @first_move = true
+
+          # Convert outline to CFF commands
+          commands = outline.to_cff_commands
+
+          # Encode width if provided (before first move)
+          if width && !commands.empty?
+            # Width is encoded as first operator before first move
+            # For now, we'll add it before the first moveto
+            encode_width(width)
+          end
+
+          # Encode each command
+          commands.each do |cmd|
+            encode_command(cmd)
+          end
+
+          # End character
+          write_operator(:endchar)
+
+          @output.string
+        end
+
+        # Build a CharString from operation list
+        #
+        # This method takes operations from CharStringParser and encodes them
+        # back to binary CharString format. Useful for CharString modification.
+        #
+        # @param operations [Array<Hash>] Array of operation hashes from parser
+        # @return [String] Binary CharString data
+        def self.build_from_operations(operations)
+          new.build_from_operations(operations)
+        end
+
+        # Instance method for building from operations
+        #
+        # @param operations [Array<Hash>] Array of operation hashes
+        # @return [String] Binary CharString data
+        def build_from_operations(operations)
+          @output = StringIO.new("".b)
+
+          operations.each do |op|
+            # Write operands
+            op[:operands].each { |operand| write_number(operand) }
+
+            # Write operator
+            write_operator(op[:name])
+
+            # Write hint data if present (for hintmask/cntrmask)
+            if op[:hint_data]
+              @output.write(op[:hint_data])
+            end
+          end
+
+          @output.string
+        end
+
+        # Build an empty CharString (for .notdef or empty glyphs)
+        #
+        # @param width [Integer, nil] Glyph width
+        # @return [String] Binary CharString data
+        def build_empty(width: nil)
+          @output = StringIO.new("".b)
+
+          # Encode width if provided
+          encode_width(width) if width
+
+          # Just endchar for empty glyph
+          write_operator(:endchar)
+
+          @output.string
+        end
+
+        private
+
+        # Encode a width value
+        #
+        # Width is encoded as a delta from nominal width
+        # For simplicity, we encode as-is (assuming nominal width is 0)
+        #
+        # @param width [Integer] Width value
+        def encode_width(width)
+          write_number(width)
+        end
+
+        # Encode a single command
+        #
+        # @param cmd [Hash] Command hash with :type and coordinates
+        def encode_command(cmd)
+          case cmd[:type]
+          when :move_to
+            encode_moveto(cmd)
+          when :line_to
+            encode_lineto(cmd)
+          when :curve_to
+            encode_curveto(cmd)
+          end
+        end
+
+        # Encode a moveto command
+        #
+        # Uses rmoveto (relative move) with dx, dy
+        # For first move, can optimize to hmoveto/vmoveto if one delta is 0
+        #
+        # @param cmd [Hash] Command with :x, :y
+        def encode_moveto(cmd)
+          dx = cmd[:x] - @current_x
+          dy = cmd[:y] - @current_y
+
+          if @first_move
+            # First move - can optimize
+            if dx.zero?
+              write_number(dy.round)
+              write_operator(:vmoveto)
+            elsif dy.zero?
+              write_number(dx.round)
+              write_operator(:hmoveto)
+            else
+              write_number(dx.round)
+              write_number(dy.round)
+              write_operator(:rmoveto)
+            end
+            @first_move = false
+          else
+            # Subsequent moves
+            write_number(dx.round)
+            write_number(dy.round)
+            write_operator(:rmoveto)
+          end
+
+          @current_x = cmd[:x]
+          @current_y = cmd[:y]
+        end
+
+        # Encode a lineto command
+        #
+        # Uses rlineto with dx, dy
+        # Could optimize with hlineto/vlineto for horizontal/vertical lines
+        #
+        # @param cmd [Hash] Command with :x, :y
+        def encode_lineto(cmd)
+          dx = cmd[:x] - @current_x
+          dy = cmd[:y] - @current_y
+
+          # Simple encoding - could optimize for h/v lines
+          write_number(dx.round)
+          write_number(dy.round)
+          write_operator(:rlineto)
+
+          @current_x = cmd[:x]
+          @current_y = cmd[:y]
+        end
+
+        # Encode a curveto command (cubic Bézier)
+        #
+        # Uses rrcurveto with 6 relative coordinates:
+        # dx1 dy1 dx2 dy2 dx3 dy3
+        #
+        # @param cmd [Hash] Command with :x1, :y1, :x2, :y2, :x, :y
+        def encode_curveto(cmd)
+          # Calculate relative coordinates for each control point
+          dx1 = cmd[:x1] - @current_x
+          dy1 = cmd[:y1] - @current_y
+
+          dx2 = cmd[:x2] - cmd[:x1]
+          dy2 = cmd[:y2] - cmd[:y1]
+
+          dx3 = cmd[:x] - cmd[:x2]
+          dy3 = cmd[:y] - cmd[:y2]
+
+          # Write operands
+          write_number(dx1.round)
+          write_number(dy1.round)
+          write_number(dx2.round)
+          write_number(dy2.round)
+          write_number(dx3.round)
+          write_number(dy3.round)
+
+          # Write operator
+          write_operator(:rrcurveto)
+
+          @current_x = cmd[:x]
+          @current_y = cmd[:y]
+        end
+
+        # Write a number to the CharString
+        #
+        # Numbers are encoded in various formats based on their range:
+        # - -107 to +107: Single byte (32-246)
+        # - -1131 to +1131: Two bytes (247-254 + byte)
+        # - -32768 to +32767: Three bytes (28 + 2 bytes)
+        # - Otherwise: Five bytes (255 + 4 bytes as 16.16 fixed)
+        #
+        # @param value [Integer, Float] Number to encode
+        def write_number(value)
+          # Convert float to integer if it's effectively an integer
+          value = value.round if value.is_a?(Float) && value == value.round
+
+          if value.is_a?(Float)
+            # Real number - use 5-byte format (16.16 fixed point)
+            write_real(value)
+          elsif value >= -107 && value <= 107
+            # Single byte format: 32-246 represents -107 to +107
+            @output.putc(value + 139)
+          elsif value >= 108 && value <= 1131
+            # Positive two-byte format: 247-250
+            adjusted = value - 108
+            b0 = 247 + (adjusted / 256)
+            b1 = adjusted % 256
+            @output.putc(b0)
+            @output.putc(b1)
+          elsif value >= -1131 && value <= -108
+            # Negative two-byte format: 251-254
+            adjusted = -value - 108
+            b0 = 251 + (adjusted / 256)
+            b1 = adjusted % 256
+            @output.putc(b0)
+            @output.putc(b1)
+          elsif value >= -32768 && value <= 32767
+            # Three-byte signed integer
+            @output.putc(28)
+            @output.write([value].pack("s>")) # Signed 16-bit big-endian
+          else
+            # Five-byte signed integer (stored as 16.16 fixed point)
+            write_real(value.to_f)
+          end
+        end
+
+        # Write a real number (5-byte format)
+        #
+        # @param value [Float] Real number
+        def write_real(value)
+          # Convert to 16.16 fixed point
+          fixed = (value * 65536.0).round
+
+          @output.putc(255)
+          @output.write([fixed].pack("l>")) # Signed 32-bit big-endian
+        end
+
+        # Write an operator to the CharString
+        #
+        # @param operator [Symbol] Operator name
+        def write_operator(operator)
+          if OPERATORS.key?(operator)
+            # Single-byte operator
+            @output.putc(OPERATORS[operator])
+          elsif TWO_BYTE_OPERATORS.key?(operator)
+            # Two-byte operator
+            bytes = TWO_BYTE_OPERATORS[operator]
+            @output.putc(bytes[0])
+            @output.putc(bytes[1])
+          else
+            raise ArgumentError, "Unknown operator: #{operator}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  module Tables
+    class Cff
+      # CharString parser that converts binary CharString data to operation list
+      #
+      # Unlike [`CharString`](lib/fontisan/tables/cff/charstring.rb) which
+      # interprets and executes CharStrings for rendering, CharStringParser
+      # parses CharStrings into a list of operations that can be modified and
+      # rebuilt. This enables CharString manipulation for hint injection,
+      # subroutine optimization, and other transformations.
+      #
+      # Operation Format:
+      # ```ruby
+      # {
+      #   type: :operator,
+      #   name: :rmoveto,
+      #   operands: [100, 200]
+      # }
+      # ```
+      #
+      # Reference: Adobe Type 2 CharString Format
+      # https://adobe-type-tools.github.io/font-tech-notes/pdfs/5177.Type2.pdf
+      #
+      # @example Parse a CharString
+      #   parser = CharStringParser.new(charstring_data)
+      #   operations = parser.parse
+      #   operations.each { |op| puts "#{op[:name]} #{op[:operands]}" }
+      class CharStringParser
+        # Type 2 CharString operators (from CharString class)
+        OPERATORS = {
+          # Path construction operators
+          1 => :hstem,
+          3 => :vstem,
+          4 => :vmoveto,
+          5 => :rlineto,
+          6 => :hlineto,
+          7 => :vlineto,
+          8 => :rrcurveto,
+          10 => :callsubr,
+          11 => :return,
+          14 => :endchar,
+          18 => :hstemhm,
+          19 => :hintmask,
+          20 => :cntrmask,
+          21 => :rmoveto,
+          22 => :hmoveto,
+          23 => :vstemhm,
+          24 => :rcurveline,
+          25 => :rlinecurve,
+          26 => :vvcurveto,
+          27 => :hhcurveto,
+          28 => :shortint,
+          29 => :callgsubr,
+          30 => :vhcurveto,
+          31 => :hvcurveto,
+          # 12 prefix for two-byte operators
+          [12, 3] => :and,
+          [12, 4] => :or,
+          [12, 5] => :not,
+          [12, 9] => :abs,
+          [12, 10] => :add,
+          [12, 11] => :sub,
+          [12, 12] => :div,
+          [12, 14] => :neg,
+          [12, 15] => :eq,
+          [12, 18] => :drop,
+          [12, 20] => :put,
+          [12, 21] => :get,
+          [12, 22] => :ifelse,
+          [12, 23] => :random,
+          [12, 24] => :mul,
+          [12, 26] => :sqrt,
+          [12, 27] => :dup,
+          [12, 28] => :exch,
+          [12, 29] => :index,
+          [12, 30] => :roll,
+          [12, 34] => :hflex,
+          [12, 35] => :flex,
+          [12, 36] => :hflex1,
+          [12, 37] => :flex1,
+        }.freeze
+
+        # Operators that require hint mask bytes
+        HINTMASK_OPERATORS = %i[hintmask cntrmask].freeze
+
+        # @return [String] Binary CharString data
+        attr_reader :data
+
+        # @return [Array<Hash>] Parsed operations
+        attr_reader :operations
+
+        # Initialize parser with CharString data
+        #
+        # @param data [String] Binary CharString data
+        # @param stem_count [Integer] Number of stem hints (for hintmask)
+        def initialize(data, stem_count: 0)
+          @data = data
+          @stem_count = stem_count
+          @operations = []
+        end
+
+        # Parse CharString to operation list
+        #
+        # @return [Array<Hash>] Array of operation hashes
+        def parse
+          @operations = []
+          io = StringIO.new(@data)
+          operand_stack = []
+
+          until io.eof?
+            byte = io.getbyte
+
+            if operator_byte?(byte)
+              # Operator byte - read operator and create operation
+              operator = read_operator(io, byte)
+
+              # Read hint mask data if needed
+              hint_data = nil
+              if HINTMASK_OPERATORS.include?(operator)
+                hint_bytes = (@stem_count + 7) / 8
+                hint_data = io.read(hint_bytes) if hint_bytes.positive?
+              end
+
+              # Create operation
+              @operations << {
+                type: :operator,
+                name: operator,
+                operands: operand_stack.dup,
+                hint_data: hint_data
+              }
+
+              # Clear operand stack
+              operand_stack.clear
+            else
+              # Operand byte - read number and push to stack
+              io.pos -= 1
+              number = read_number(io)
+              operand_stack << number
+            end
+          end
+
+          @operations
+        rescue StandardError => e
+          raise CorruptedTableError,
+                "Failed to parse CharString: #{e.message}"
+        end
+
+        # Update stem count (needed for hintmask operations)
+        #
+        # @param count [Integer] Number of stem hints
+        def stem_count=(count)
+          @stem_count = count
+        end
+
+        private
+
+        # Check if byte is an operator
+        #
+        # @param byte [Integer] Byte value
+        # @return [Boolean] True if operator byte
+        def operator_byte?(byte)
+          (byte <= 31 && byte != 28) # Operators are 0-31 except 28 (shortint)
+        end
+
+        # Read operator from CharString
+        #
+        # @param io [StringIO] Input stream
+        # @param first_byte [Integer] First operator byte
+        # @return [Symbol] Operator name
+        def read_operator(io, first_byte)
+          if first_byte == 12
+            # Two-byte operator
+            second_byte = io.getbyte
+            raise CorruptedTableError, "Unexpected end of CharString" if
+              second_byte.nil?
+
+            operator_key = [first_byte, second_byte]
+            OPERATORS[operator_key] || :unknown
+          else
+            # Single-byte operator
+            OPERATORS[first_byte] || :unknown
+          end
+        end
+
+        # Read a number (integer or real) from CharString
+        #
+        # @param io [StringIO] Input stream
+        # @return [Integer, Float] The number value
+        def read_number(io)
+          byte = io.getbyte
+          raise CorruptedTableError, "Unexpected end of CharString" if
+            byte.nil?
+
+          case byte
+          when 28
+            # 3-byte signed integer (16-bit)
+            b1 = io.getbyte
+            b2 = io.getbyte
+            raise CorruptedTableError, "Unexpected end of CharString reading shortint" if
+              b1.nil? || b2.nil?
+            value = (b1 << 8) | b2
+            value > 0x7FFF ? value - 0x10000 : value
+          when 32..246
+            # Small integer: -107 to +107
+            byte - 139
+          when 247..250
+            # Positive 2-byte integer: +108 to +1131
+            b2 = io.getbyte
+            raise CorruptedTableError, "Unexpected end of CharString reading positive integer" if
+              b2.nil?
+            (byte - 247) * 256 + b2 + 108
+          when 251..254
+            # Negative 2-byte integer: -108 to -1131
+            b2 = io.getbyte
+            raise CorruptedTableError, "Unexpected end of CharString reading negative integer" if
+              b2.nil?
+            -(byte - 251) * 256 - b2 - 108
+          when 255
+            # 5-byte signed integer (32-bit) as fixed-point 16.16
+            bytes = io.read(4)
+            raise CorruptedTableError, "Unexpected end of CharString reading fixed-point" if
+              bytes.nil? || bytes.length < 4
+            value = bytes.unpack1("l>") # Signed 32-bit big-endian
+            value / 65536.0 # Convert to float
+          else
+            raise CorruptedTableError,
+                  "Invalid CharString number byte: #{byte}"
+          end
+        end
+      end
+    end
+  end
+end