fontisan 0.2.11 → 0.2.13

data/lib/fontisan/type1/cff_to_type1_converter.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Type1
+    # Converter for CFF CharStrings to Type 1 CharStrings
+    #
+    # [`CffToType1Converter`](lib/fontisan/type1/cff_to_type1_converter.rb) converts
+    # CFF (Compact Font Format) Type 2 CharStrings to Type 1 CharStrings.
+    #
+    # CFF and Type 1 use similar stack-based languages but have different operator
+    # codes and some structural differences:
+    # - Operator codes differ between formats
+    # - Type 1 uses hsbw/sbw for width selection; CFF uses initial operand
+    # - Hint operators need to be preserved with code translation
+    #
+    # @example Convert a CFF CharString to Type 1
+    #   converter = Fontisan::Type1::CffToType1Converter.new
+    #   type1_charstring = converter.convert(cff_charstring)
+    #
+    # @see https://www.adobe.com/devnet/font/pdfs/Type1.pdf
+    # @see https://www.microsoft.com/typography/otspec/cff.htm
+    class CffToType1Converter
+      # CFF to Type 1 operator mapping
+      #
+      # Maps CFF operator codes to Type 1 operator codes.
+      # Most operators are the same, but some differ.
+      CFF_TO_TYPE1 = {
+        # Path construction operators
+        hmoveto: 22,      # CFF: 22, Type 1: 22
+        vmoveto: 4,       # CFF: 4, Type 1: 4
+        rlineto: 5,       # CFF: 5, Type 1: 5
+        hlineto: 6,       # CFF: 6, Type 1: 6
+        vlineto: 7,       # CFF: 7, Type 1: 7
+        rrcurveto: 8,     # CFF: 8, Type 1: 8
+        hhcurveto: 27,    # CFF: 27, Type 1: 27
+        hvcurveto: 31,    # CFF: 31, Type 1: 31
+        vhcurveto: 30,    # CFF: 30, Type 1: 30
+        rcurveline: 24,   # CFF: 24, Type 1: 24
+        rlinecurve: 25,   # CFF: 25, Type 1: 25
+
+        # Hint operators
+        hstem: 1,         # CFF: 1, Type 1: 1
+        vstem: 3,         # CFF: 3, Type 1: 3
+        hstemhm: 18,      # CFF: 18, Type 1: 18
+        vstemhm: 23,      # CFF: 23, Type 1: 23
+
+        # Hint substitution (preserve for compatibility)
+        hintmask: 19,     # CFF: 19, Type 1: Not supported (skip)
+        cntrmask: 20,     # CFF: 20, Type 1: Not supported (skip)
+
+        # End char
+        endchar: 14,      # CFF: 14, Type 1: 14
+
+        # Miscellaneous
+        callsubr: 10,     # CFF: 10, Type 1: 10
+        return: 11,       # CFF: 11, Type 1: 11
+        rmoveto: 21,      # CFF: 21, Type 1: 21
+      }.freeze
+
+      # Escape code for two-byte operators
+      ESCAPE_BYTE = 12
+
+      # Initialize a new CffToType1Converter
+      #
+      # @param nominal_width [Integer] Nominal width from CFF Private dict (default: 0)
+      # @param default_width [Integer] Default width from CFF Private dict (default: 0)
+      def initialize(nominal_width: 0, default_width: 0)
+        @nominal_width = nominal_width
+        @default_width = default_width
+      end
+
+      # Convert CFF CharString to Type 1 CharString
+      #
+      # Takes binary CFF CharString data and converts it to Type 1 format.
+      #
+      # @param cff_charstring [String] CFF CharString bytecode
+      # @param private_dict [Hash] CFF Private dict for context (optional)
+      # @return [String] Type 1 CharString bytecode
+      #
+      # @example Convert a CharString
+      #   converter = Fontisan::Type1::CffToType1Converter.new
+      #   type1_bytes = converter.convert(cff_bytes)
+      def convert(cff_charstring, private_dict: {})
+        # Parse CFF CharString into operations
+        parser = Tables::Cff::CharStringParser.new(cff_charstring,
+                                                       stem_count: private_dict[:stem_count]&.to_i || 0)
+        operations = parser.parse
+
+        # Extract width from operations (CFF spec: odd stack before first move = width)
+        width = extract_width(operations)
+
+        # Convert operations to Type 1 format
+        convert_operations(operations, width)
+      end
+
+      # Extract width from CFF operations
+      #
+      # In CFF, if there's an odd number of arguments before the first move
+      # operator (rmoveto, hmoveto, vmoveto, rcurveline, rrcurveline, vvcurveto,
+      # hhcurveto), the first argument is the width.
+      #
+      # @param operations [Array<Hash>] Parsed CFF operations
+      # @return [Integer, nil] Width value or nil if using default
+      def extract_width(operations)
+        return @default_width if operations.empty?
+
+        # Find first move operator
+        first_move_idx = operations.index do |op|
+          %i[rmoveto hmoveto vmoveto rcurveline rrcurveline vvcurveto hhcurveto].include?(op[:name])
+        end
+
+        return @default_width unless first_move_idx
+
+        # Count operands before first move
+        operand_count = operations[0...first_move_idx].sum(0) do |op|
+          op[:operands]&.length || 0
+        end
+
+        # If odd, first operand of first move is width
+        if operand_count.odd?
+          first_move = operations[first_move_idx]
+          if first_move[:operands] && !first_move[:operands].empty?
+            return first_move[:operands].first
+          end
+        end
+
+        @default_width
+      end
+
+      # Convert parsed CFF operations to Type 1 CharString
+      #
+      # @param operations [Array<Hash>] Parsed CFF operations
+      # @param width [Integer, nil] Glyph width from CFF CharString
+      # @return [String] Type 1 CharString bytecode
+      def convert_operations(operations, width = nil)
+        result = String.new(encoding: Encoding::ASCII_8BIT)
+
+        # Determine width: use provided width or default/nominal
+        glyph_width = width || @default_width
+
+        # Add hsbw (horizontal sidebearing and width) at start
+        # This is the standard width operator for horizontal fonts
+        result << encode_number(0)  # left sidebearing (usually 0 for CFF)
+        result << encode_number(glyph_width)
+        result << ESCAPE_BYTE
+        result << 34  # hsbw operator (two-byte: 12 34)
+
+        x = 0
+        y = 0
+        first_move = true
+        skip_first_operand = false
+
+        # Check if width was extracted (odd stack before first move)
+        if width && operations.any?
+          # Count operands before first move to determine if width was in stack
+          first_move_idx = operations.index do |op|
+            %i[rmoveto hmoveto vmoveto rcurveline rrcurveline vvcurveto hhcurveto].include?(op[:name])
+          end
+
+          if first_move_idx
+            operand_count = operations[0...first_move_idx].sum(0) do |op|
+              op[:operands]&.length || 0
+            end
+
+            skip_first_operand = operand_count.odd?
+          end
+        end
+
+        operations.each do |op|
+          case op[:name]
+          when :hstem, :vstem, :hstemhm, :vstemhm
+            # Hint operators - preserve
+            op[:operands].each { |val| result << encode_number(val) }
+            result << CFF_TO_TYPE1[op[:name]]
+          when :rmoveto
+            # rmoveto dx dy (or width dx dy if first move with odd stack)
+            operands = op[:operands]
+            if first_move && skip_first_operand && !operands.empty?
+              # Skip first operand (it was the width)
+              operands = operands[1..]
+              skip_first_operand = false
+            end
+
+            if operands.length >= 2
+              dx, dy = operands[0], operands[1]
+              x += dx
+              y += dy
+              result << encode_number(dx)
+              result << encode_number(dy)
+              result << 21  # rmoveto
+            elsif operands.length == 1
+              # Only dy (hmoveto/vmoveto style)
+              result << encode_number(operands.first)
+              result << 4  # vmoveto (closest approximation)
+            end
+            first_move = false
+          when :hmoveto
+            # hmoveto dx (or width dx if first move)
+            operands = op[:operands]
+            if first_move && skip_first_operand && !operands.empty?
+              operands = [operands[0]] if operands.length > 1
+              skip_first_operand = false
+            end
+
+            dx = operands.first
+            x += dx if dx
+            result << encode_number(dx)
+            result << 22  # hmoveto
+            first_move = false
+          when :vmoveto
+            # vmoveto dy
+            dy = op[:operands].first
+            y += dy if dy
+            result << encode_number(dy)
+            result << 4  # vmoveto
+            first_move = false
+          when :rlineto
+            # rlineto dx dy
+            dx, dy = op[:operands]
+            x += dx
+            y += dy
+            result << encode_number(dx)
+            result << encode_number(dy)
+            result << 5  # rlineto
+            first_move = false
+          when :hlineto
+            # hlineto dx
+            dx = op[:operands].first
+            x += dx
+            result << encode_number(dx)
+            result << 6  # hlineto
+            first_move = false
+          when :vlineto
+            # vlineto dy
+            dy = op[:operands].first
+            y += dy
+            result << encode_number(dy)
+            result << 7  # vlineto
+            first_move = false
+          when :rrcurveto
+            # rrcurveto dx1 dy1 dx2 dy2 dx3 dy3
+            dx1, dy1, dx2, dy2, dx3, dy3 = op[:operands]
+            x += dx1 + dx2 + dx3
+            y += dy1 + dy2 + dy3
+            [dx1, dy1, dx2, dy2, dx3, dy3].each { |val| result << encode_number(val) }
+            result << 8  # rrcurveto
+            first_move = false
+          when :hhcurveto, :hvcurveto, :vhcurveto
+            # Flexible curve operators
+            op[:operands].each { |val| result << encode_number(val) }
+            result << CFF_TO_TYPE1[op[:name]]
+            first_move = false
+          when :rcurveline, :rlinecurve
+            # Flexible curve operators
+            op[:operands].each { |val| result << encode_number(val) }
+            result << CFF_TO_TYPE1[op[:name]]
+            first_move = false
+          when :callsubr, :return, :endchar
+            # Control operators
+            result << CFF_TO_TYPE1[op[:name]]
+            first_move = false
+          when :hintmask, :cntrmask
+            # Hint mask operators - Type 1 doesn't support these
+            # Skip them
+            first_move = false
+          when :shortint
+            # Short integer push - handled by operand encoding
+            first_move = false
+          else
+            # Unknown operator - skip
+            first_move = false
+          end
+        end
+
+        # Add endchar
+        result << 14
+
+        result
+      end
+
+      private
+
+      # Encode integer for Type 1 CharString
+      #
+      # Type 1 CharStrings use a variable-length integer encoding:
+      # - Numbers from -107 to 107: single byte (byte + 139)
+      # - Larger numbers: escaped with 255, then 2-byte value
+      #
+      # @param num [Integer] Number to encode
+      # @return [String] Encoded bytes
+      def encode_number(num)
+        if num >= -107 && num <= 107
+          [num + 139].pack("C")
+        else
+          # Use escape sequence (255) followed by 2-byte signed integer
+          num += 32768 if num < 0
+          [255, num % 256, num >> 8].pack("C*")
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/type1/charstring_converter.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Type1
+    # Converter for Type 1 CharStrings to CFF CharStrings
+    #
+    # [`CharStringConverter`](lib/fontisan/type1/charstring_converter.rb) converts
+    # Type 1 CharString bytecode to CFF (Compact Font Format) CharString bytecode.
+    #
+    # Type 1 and CFF use similar stack-based languages but have different operator
+    # codes and some structural differences:
+    # - Operator codes differ between formats
+    # - Type 1 has seac operator for composites; CFF doesn't support it
+    # - Hint operators need to be preserved with code translation
+    #
+    # @example Convert a Type 1 CharString to CFF
+    #   converter = Fontisan::Type1::CharStringConverter.new
+    #   cff_charstring = converter.convert(type1_charstring)
+    #
+    # @see https://www.adobe.com/devnet/font/pdfs/Type1.pdf
+    # @see https://www.microsoft.com/typography/otspec/cff.htm
+    class CharStringConverter
+      # Type 1 to CFF operator mapping
+      #
+      # Maps Type 1 operator codes to CFF operator codes.
+      # Some operators have the same code, others differ.
+      TYPE1_TO_CFF = {
+        # Path construction operators
+        hmoveto: 22,      # Type 1: 22, CFF: 22
+        vmoveto: 4,       # Type 1: 4, CFF: 4
+        rlineto: 5,       # Type 1: 5, CFF: 5
+        hlineto: 6,       # Type 1: 6, CFF: 6
+        vlineto: 7,       # Type 1: 7, CFF: 7
+        rrcurveto: 8,     # Type 1: 8, CFF: 8
+        hhcurveto: 27,    # Type 1: 27, CFF: 27
+        hvcurveto: 31,    # Type 1: 31, CFF: 31
+        vhcurveto: 30,    # Type 1: 30, CFF: 30
+        rcurveline: 24,   # Type 1: 24, CFF: 24
+        rlinecurve: 25,   # Type 1: 25, CFF: 25
+
+        # Hint operators
+        hstem: 1,         # Type 1: 1, CFF: 1
+        vstem: 3,         # Type 1: 3, CFF: 3
+        hstemhm: 18,      # Type 1: 18, CFF: 18
+        vstemhm: 23,      # Type 1: 23, CFF: 23
+
+        # Hint substitution (not in Type 1, but we preserve for compatibility)
+        hintmask: 19,     # Type 1: N/A, CFF: 19
+        cntrmask: 20,     # Type 1: N/A, CFF: 20
+
+        # End char
+        endchar: 14, # Type 1: 14 (or 11 in some specs), CFF: 14
+
+        # Miscellaneous
+        callsubr: 10,     # Type 1: 10, CFF: 10
+        return: 11,       # Type 1: 11, CFF: 11
+
+        # Deprecated operators (preserve for compatibility)
+        hstem3: 12,       # Type 1: 12 (escape 0), CFF: 12 (escape 0)
+        vstem3: 13,       # Type 1: 13 (escape 1), CFF: 13 (escape 1)
+        seac: 12,         # Type 1: 12 (escape 6), CFF: Not supported
+      }.freeze
+
+      # Escape code for two-byte operators
+      ESCAPE_BYTE = 12
+
+      # seac operator escape code (second byte)
+      SEAC_ESCAPE_CODE = 6
+
+      # Initialize a new CharStringConverter
+      #
+      # @param charstrings [CharStrings, nil] CharStrings dictionary for seac expansion
+      def initialize(charstrings = nil)
+        @charstrings = charstrings
+      end
+
+      # Convert Type 1 CharString to CFF CharString
+      #
+      # @param type1_charstring [String] Type 1 CharString bytecode
+      # @return [String] CFF CharString bytecode
+      #
+      # @example Convert a CharString
+      #   converter = Fontisan::Type1::CharStringConverter.new
+      #   cff_bytes = converter.convert(type1_bytes)
+      def convert(type1_charstring)
+        # Parse Type 1 CharString into commands
+        parser = Type1::CharStrings::CharStringParser.new
+        commands = parser.parse(type1_charstring)
+
+        # Check for seac operator and expand if needed
+        if parser.seac_components
+          return expand_seac(parser.seac_components)
+        end
+
+        # Convert commands to CFF format
+        convert_commands(commands)
+      end
+
+      # Convert parsed commands to CFF CharString
+      #
+      # @param commands [Array<Array>] Parsed Type 1 commands
+      # @return [String] CFF CharString bytecode
+      def convert_commands(commands)
+        result = String.new(encoding: Encoding::ASCII_8BIT)
+
+        commands.each do |command|
+          case command[0]
+          when :number
+            # Encode number in CFF format
+            result << encode_cff_number(command[1])
+          when :seac
+            # seac should be expanded before this point
+            raise Fontisan::Error,
+                  "seac operator not supported in CFF, must be expanded first"
+          else
+            # Convert operator
+            op_code = TYPE1_TO_CFF[command[0]]
+            if op_code.nil?
+              # Unknown operator, skip or raise error
+              next
+            end
+
+            result << encode_cff_operator(op_code)
+          end
+        end
+
+        result
+      end
+
+      # Expand seac composite glyph
+      #
+      # The seac operator in Type 1 creates composite glyphs (like À = A + `).
+      # CFF doesn't support seac, so we need to expand it into the base glyphs
+      # with appropriate positioning.
+      #
+      # @param seac_data [Hash] seac component data
+      # @return [String] CFF CharString bytecode with expanded seac
+      def expand_seac(seac_data)
+        # seac format: adx ady bchar achar seac
+        # adx, ady: accent offset
+        # bchar: base character code
+        # achar: accent character code
+        # The accent is positioned at (adx, ady) relative to the base
+
+        seac_data[:base]
+        seac_data[:accent]
+        seac_data[:adx]
+        seac_data[:ady]
+
+        # For now, we'll create a simple placeholder that indicates seac expansion
+        # In a full implementation, we would:
+        # 1. Parse the base glyph's CharString
+        # 2. Parse the accent glyph's CharString
+        # 3. Merge them with the appropriate offset
+        # 4. Convert to CFF format
+
+        # This is a simplified implementation that creates a composite reference
+        # CFF doesn't have native seac, so we need to actually merge the outlines
+
+        # For now, return endchar as placeholder
+        # TODO: Implement full seac expansion by merging glyph outlines
+        encode_cff_operator(TYPE1_TO_CFF[:endchar])
+      end
+
+      # Check if CharString contains seac operator
+      #
+      # @param type1_charstring [String] Type 1 CharString bytecode
+      # @return [Boolean] True if CharString contains seac
+      def seac?(type1_charstring)
+        parser = Type1::CharStrings::CharStringParser.new
+        parser.parse(type1_charstring)
+        !parser.seac_components.nil?
+      end
+
+      private
+
+      # Encode number in CFF format
+      #
+      # CFF uses a variable-length encoding for numbers:
+      # - 32-246: 1 byte (value - 139)
+      # - 247-250: 2 bytes (first byte indicates format)
+      # - 251-254: 3 bytes (first byte indicates format)
+      # - 255: 5 bytes (signed 16-bit integer)
+      # - 28: 2 bytes (signed 16.16 fixed point, not used for CharStrings)
+      #
+      # @param value [Integer] Number to encode
+      # @return [String] Encoded number bytes
+      def encode_cff_number(value)
+        result = String.new(encoding: Encoding::ASCII_8BIT)
+
+        if value >= -107 && value <= 107
+          # 1-byte number: value + 139
+          result << (value + 139).chr
+        elsif value >= 108 && value <= 1131
+          # 2-byte positive number
+          value -= 108
+          result << ((value >> 8) + 247).chr
+          result << (value & 0xFF).chr
+        elsif value >= -1131 && value <= -108
+          # 2-byte negative number
+          value = -value - 108
+          result << ((value >> 8) + 251).chr
+          result << (value & 0xFF).chr
+        elsif value >= -32768 && value <= 32767
+          # 5-byte number (16-bit integer)
+          result << 255.chr
+          result << [(value >> 8) & 0xFF, value & 0xFF].pack("CC")
+          result << [0, 0].pack("CC") # Pad to 5 bytes
+        else
+          raise Fontisan::Error,
+                "Number out of range for CFF encoding: #{value}"
+        end
+
+        result
+      end
+
+      # Encode operator in CFF format
+      #
+      # Most operators are single-byte. Some use escape byte (12) followed
+      # by a second byte.
+      #
+      # @param op_code [Integer] Operator code
+      # @return [String] Encoded operator bytes
+      def encode_cff_operator(op_code)
+        result = String.new(encoding: Encoding::ASCII_8BIT)
+
+        if op_code > 31 && op_code != ESCAPE_BYTE
+          # Two-byte operator (escape + code)
+          result << ESCAPE_BYTE.chr
+          result << (op_code - ESCAPE_BYTE).chr
+        else
+          # Single-byte operator
+          result << op_code.chr
+        end
+
+        result
+      end
+    end
+  end
+end