fontisan 0.1.0 → 0.2.0

data/lib/fontisan/tables/cvar.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../binary/base_record"
+
+module Fontisan
+  module Tables
+    # Parser for the 'cvar' (CVT Variations) table
+    #
+    # The cvar table provides variation data for the Control Value Table (CVT)
+    # in TrueType variable fonts with hinting. The CVT contains scalar values
+    # that are referenced by TrueType instructions for grid-fitting.
+    #
+    # Like gvar, this table uses a TupleVariationStore structure with packed
+    # delta values rather than ItemVariationStore.
+    #
+    # Reference: OpenType specification, cvar table
+    #
+    # @example Reading a cvar table
+    #   data = font.table_data("cvar")
+    #   cvar = Fontisan::Tables::Cvar.read(data)
+    #   cvt_deltas = cvar.cvt_variations
+    class Cvar < Binary::BaseRecord
+      uint16 :major_version
+      uint16 :minor_version
+      uint16 :tuple_variation_count
+      uint16 :data_offset
+
+      # Tuple variation header
+      class TupleVariationHeader < Binary::BaseRecord
+        uint16 :variation_data_size
+        uint16 :tuple_index
+
+        # Tuple index flags
+        EMBEDDED_PEAK_TUPLE = 0x8000
+        INTERMEDIATE_REGION = 0x4000
+        PRIVATE_POINT_NUMBERS = 0x2000
+        TUPLE_INDEX_MASK = 0x0FFF
+
+        # Check if tuple has embedded peak coordinates
+        #
+        # @return [Boolean] True if embedded
+        def embedded_peak_tuple?
+          (tuple_index & EMBEDDED_PEAK_TUPLE) != 0
+        end
+
+        # Check if tuple has intermediate region
+        #
+        # @return [Boolean] True if intermediate region
+        def intermediate_region?
+          (tuple_index & INTERMEDIATE_REGION) != 0
+        end
+
+        # Check if tuple has private point numbers
+        #
+        # @return [Boolean] True if private points
+        def private_point_numbers?
+          (tuple_index & PRIVATE_POINT_NUMBERS) != 0
+        end
+
+        # Get shared tuple index
+        #
+        # @return [Integer] Tuple index
+        def shared_tuple_index
+          tuple_index & TUPLE_INDEX_MASK
+        end
+      end
+
+      # Get version as a float
+      #
+      # @return [Float] Version number (e.g., 1.0)
+      def version
+        major_version + (minor_version / 10.0)
+      end
+
+      # Get tuple count
+      #
+      # @return [Integer] Number of tuple variations
+      def tuple_count
+        tuple_variation_count & 0x0FFF
+      end
+
+      # Check if using shared point numbers
+      #
+      # @return [Boolean] True if shared points
+      def shared_point_numbers?
+        (tuple_variation_count & 0x8000) != 0
+      end
+
+      # Get axis count from fvar table (needs to be provided externally)
+      # This is a placeholder that should be set by the caller
+      attr_accessor :axis_count
+
+      # Parse tuple variation headers
+      #
+      # @return [Array<Hash>] Array of tuple information
+      def tuple_variations
+        return @tuple_variations if @tuple_variations
+        return @tuple_variations = [] if tuple_count.zero?
+
+        data = raw_data
+        # Tuple records start after header (8 bytes)
+        offset = 8
+
+        count = tuple_count
+        tuples = []
+
+        count.times do |_i|
+          break if offset + 4 > data.bytesize
+
+          header_data = data.byteslice(offset, 4)
+          header = TupleVariationHeader.read(header_data)
+          offset += 4
+
+          tuple_info = {
+            data_size: header.variation_data_size,
+            embedded_peak: header.embedded_peak_tuple?,
+            intermediate: header.intermediate_region?,
+            private_points: header.private_point_numbers?,
+            shared_index: header.shared_tuple_index,
+          }
+
+          # Read peak tuple if embedded
+          if header.embedded_peak_tuple? && axis_count
+            peak = Array.new(axis_count) do
+              next nil if offset + 2 > data.bytesize
+
+              coord_data = data.byteslice(offset, 2)
+              offset += 2
+
+              value = coord_data.unpack1("n")
+              signed = value > 0x7FFF ? value - 0x10000 : value
+              signed / 16384.0
+            end.compact
+            tuple_info[:peak] = peak
+          end
+
+          # Read intermediate region if present
+          if header.intermediate_region? && axis_count
+            start_tuple = Array.new(axis_count) do
+              next nil if offset + 2 > data.bytesize
+
+              coord_data = data.byteslice(offset, 2)
+              offset += 2
+
+              value = coord_data.unpack1("n")
+              signed = value > 0x7FFF ? value - 0x10000 : value
+              signed / 16384.0
+            end.compact
+
+            end_tuple = Array.new(axis_count) do
+              next nil if offset + 2 > data.bytesize
+
+              coord_data = data.byteslice(offset, 2)
+              offset += 2
+
+              value = coord_data.unpack1("n")
+              signed = value > 0x7FFF ? value - 0x10000 : value
+              signed / 16384.0
+            end.compact
+
+            tuple_info[:start] = start_tuple
+            tuple_info[:end] = end_tuple
+          end
+
+          tuples << tuple_info
+        end
+
+        @tuple_variations = tuples
+      rescue StandardError => e
+        warn "Failed to parse cvar tuple variations: #{e.message}"
+        @tuple_variations = []
+      end
+
+      # Get variation data section
+      #
+      # @return [String, nil] Raw variation data
+      def variation_data
+        return @variation_data if defined?(@variation_data)
+
+        data = raw_data
+        offset = data_offset
+
+        return @variation_data = nil if offset >= data.bytesize
+
+        @variation_data = data.byteslice(offset..-1)
+      end
+
+      # Parse CVT deltas for a specific tuple
+      #
+      # This is a simplified parser that returns the raw delta data.
+      # Full delta unpacking would require knowing point counts and
+      # delta formats.
+      #
+      # @param tuple_index [Integer] Tuple index
+      # @return [Hash, nil] Tuple info with data offset
+      def tuple_variation_data(tuple_index)
+        return nil if tuple_index >= tuple_count
+
+        tuples = tuple_variations
+        return nil if tuple_index >= tuples.length
+
+        tuple = tuples[tuple_index]
+
+        # Calculate data offset for this tuple
+        # This is complex and requires walking through all previous tuples
+        # For now, return tuple metadata
+        {
+          tuple: tuple,
+          data_size: tuple[:data_size],
+        }
+      end
+
+      # Get summary of CVT variations
+      #
+      # @return [Hash] Summary information
+      def summary
+        {
+          version: version,
+          tuple_count: tuple_count,
+          shared_points: shared_point_numbers?,
+          data_offset: data_offset,
+          tuples: tuple_variations.map do |t|
+            {
+              embedded_peak: t[:embedded_peak],
+              intermediate: t[:intermediate],
+              private_points: t[:private_points],
+              peak: t[:peak],
+            }
+          end,
+        }
+      end
+
+      # Check if table is valid
+      #
+      # @return [Boolean] True if valid
+      def valid?
+        major_version == 1 && minor_version.zero?
+      end
+    end
+  end
+end

data/lib/fontisan/tables/fvar.rb

@@ -89,7 +89,7 @@ module Fontisan
         return @axes = [] if axis_count.zero?
 
         # Get the full data buffer as binary string
-        data = to_binary_s
+        data = raw_data
 
         @axes = Array.new(axis_count) do |i|
           offset = axes_array_offset + (i * axis_size)
@@ -106,7 +106,7 @@ module Fontisan
         return @instances = [] if instance_count.zero?
 
         # Get the full data buffer as binary string
-        data = to_binary_s
+        data = raw_data
 
         # Calculate instance data offset (after all axes)
         instance_offset = axes_array_offset + (axis_count * axis_size)