fontisan 0.2.2 → 0.2.4

data/lib/fontisan/tables/cblc.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../binary/base_record"
+
+module Fontisan
+  module Tables
+    # CBLC (Color Bitmap Location) table parser
+    #
+    # The CBLC table contains location information for bitmap glyphs at various
+    # sizes (strikes). It works together with the CBDT table which contains the
+    # actual bitmap data.
+    #
+    # CBLC Table Structure:
+    # ```
+    # CBLC Table = Header (8 bytes)
+    #            + BitmapSize Records (48 bytes each)
+    # ```
+    #
+    # Header (8 bytes):
+    # - version (uint32): Table version (0x00020000 or 0x00030000)
+    # - numSizes (uint32): Number of BitmapSize records
+    #
+    # Each BitmapSize record (48 bytes) contains:
+    # - indexSubTableArrayOffset (uint32): Offset to index subtable array
+    # - indexTablesSize (uint32): Size of index subtables
+    # - numberOfIndexSubTables (uint32): Number of index subtables
+    # - colorRef (uint32): Not used, set to 0
+    # - hori (SbitLineMetrics, 12 bytes): Horizontal line metrics
+    # - vert (SbitLineMetrics, 12 bytes): Vertical line metrics
+    # - startGlyphIndex (uint16): First glyph ID in strike
+    # - endGlyphIndex (uint16): Last glyph ID in strike
+    # - ppemX (uint8): Horizontal pixels per em
+    # - ppemY (uint8): Vertical pixels per em
+    # - bitDepth (uint8): Bit depth (1, 2, 4, 8, 32)
+    # - flags (int8): Flags
+    #
+    # Reference: OpenType CBLC specification
+    # https://docs.microsoft.com/en-us/typography/opentype/spec/cblc
+    #
+    # @example Reading a CBLC table
+    #   data = font.table_data['CBLC']
+    #   cblc = Fontisan::Tables::Cblc.read(data)
+    #   strikes = cblc.strikes
+    #   puts "Font has #{strikes.length} bitmap strikes"
+    class Cblc < Binary::BaseRecord
+      # OpenType table tag for CBLC
+      TAG = "CBLC"
+
+      # Supported CBLC versions
+      VERSION_2_0 = 0x00020000
+      VERSION_3_0 = 0x00030000
+
+      # SbitLineMetrics structure (12 bytes)
+      #
+      # Contains metrics for horizontal or vertical layout
+      class SbitLineMetrics < Binary::BaseRecord
+        endian :big
+        int8 :ascender
+        int8 :descender
+        uint8 :width_max
+        int8 :caret_slope_numerator
+        int8 :caret_slope_denominator
+        int8 :caret_offset
+        int8 :min_origin_sb
+        int8 :min_advance_sb
+        int8 :max_before_bl
+        int8 :min_after_bl
+        int8 :pad1
+        int8 :pad2
+      end
+
+      # BitmapSize record structure (48 bytes)
+      #
+      # Describes a bitmap strike at a specific ppem size
+      class BitmapSize < Binary::BaseRecord
+        endian :big
+        uint32 :index_subtable_array_offset
+        uint32 :index_tables_size
+        uint32 :number_of_index_subtables
+        uint32 :color_ref
+
+        # Read the SbitLineMetrics structures manually
+        def self.read(io)
+          data = io.is_a?(String) ? io : io.read
+          size = new
+
+          io = StringIO.new(data)
+          size.instance_variable_set(:@index_subtable_array_offset, io.read(4).unpack1("N"))
+          size.instance_variable_set(:@index_tables_size, io.read(4).unpack1("N"))
+          size.instance_variable_set(:@number_of_index_subtables, io.read(4).unpack1("N"))
+          size.instance_variable_set(:@color_ref, io.read(4).unpack1("N"))
+
+          # Parse hori and vert metrics (12 bytes each)
+          hori_data = io.read(12)
+          vert_data = io.read(12)
+          size.instance_variable_set(:@hori, SbitLineMetrics.read(hori_data))
+          size.instance_variable_set(:@vert, SbitLineMetrics.read(vert_data))
+
+          # Parse remaining fields
+          size.instance_variable_set(:@start_glyph_index, io.read(2).unpack1("n"))
+          size.instance_variable_set(:@end_glyph_index, io.read(2).unpack1("n"))
+          size.instance_variable_set(:@ppem_x, io.read(1).unpack1("C"))
+          size.instance_variable_set(:@ppem_y, io.read(1).unpack1("C"))
+          size.instance_variable_set(:@bit_depth, io.read(1).unpack1("C"))
+          size.instance_variable_set(:@flags, io.read(1).unpack1("c"))
+
+          size
+        end
+
+        attr_reader :index_subtable_array_offset, :index_tables_size,
+                    :number_of_index_subtables, :color_ref, :hori, :vert,
+                    :start_glyph_index, :end_glyph_index, :ppem_x, :ppem_y,
+                    :bit_depth, :flags
+
+        # Get ppem size (assumes square pixels)
+        #
+        # @return [Integer] Pixels per em
+        def ppem
+          ppem_x
+        end
+
+        # Get glyph range for this strike
+        #
+        # @return [Range] Range of glyph IDs
+        def glyph_range
+          start_glyph_index..end_glyph_index
+        end
+
+        # Check if this strike includes a specific glyph ID
+        #
+        # @param glyph_id [Integer] Glyph ID to check
+        # @return [Boolean] True if glyph is in range
+        def includes_glyph?(glyph_id)
+          glyph_range.include?(glyph_id)
+        end
+      end
+
+      # @return [Integer] CBLC version
+      attr_reader :version
+
+      # @return [Integer] Number of bitmap size records
+      attr_reader :num_sizes
+
+      # @return [Array<BitmapSize>] Parsed bitmap size records
+      attr_reader :bitmap_sizes
+
+      # @return [String] Raw binary data for the entire CBLC table
+      attr_reader :raw_data
+
+      # Override read to parse CBLC structure
+      #
+      # @param io [IO, String] Binary data to read
+      # @return [Cblc] Parsed CBLC table
+      def self.read(io)
+        cblc = new
+        return cblc if io.nil?
+
+        data = io.is_a?(String) ? io : io.read
+        cblc.parse!(data)
+        cblc
+      end
+
+      # Parse the CBLC table structure
+      #
+      # @param data [String] Binary data for the CBLC table
+      # @raise [CorruptedTableError] If CBLC structure is invalid
+      def parse!(data)
+        @raw_data = data
+        io = StringIO.new(data)
+
+        # Parse CBLC header (8 bytes)
+        parse_header(io)
+        validate_header!
+
+        # Parse bitmap size records
+        parse_bitmap_sizes(io)
+      rescue StandardError => e
+        raise CorruptedTableError, "Failed to parse CBLC table: #{e.message}"
+      end
+
+      # Get bitmap strikes (sizes)
+      #
+      # @return [Array<BitmapSize>] Array of bitmap strikes
+      def strikes
+        bitmap_sizes || []
+      end
+
+      # Get strikes for specific ppem size
+      #
+      # @param ppem [Integer] Pixels per em
+      # @return [Array<BitmapSize>] Strikes matching ppem
+      def strikes_for_ppem(ppem)
+        strikes.select { |size| size.ppem == ppem }
+      end
+
+      # Check if glyph has bitmap at ppem size
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @param ppem [Integer] Pixels per em
+      # @return [Boolean] True if glyph has bitmap
+      def has_bitmap_for_glyph?(glyph_id, ppem)
+        strikes_for_ppem(ppem).any? do |strike|
+          strike.includes_glyph?(glyph_id)
+        end
+      end
+
+      # Get all available ppem sizes
+      #
+      # @return [Array<Integer>] Sorted array of ppem sizes
+      def ppem_sizes
+        strikes.map(&:ppem).uniq.sort
+      end
+
+      # Get all glyph IDs that have bitmaps across all strikes
+      #
+      # @return [Array<Integer>] Array of glyph IDs
+      def glyph_ids_with_bitmaps
+        strikes.flat_map { |strike| strike.glyph_range.to_a }.uniq.sort
+      end
+
+      # Get strikes that include a specific glyph ID
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Array<BitmapSize>] Strikes containing glyph
+      def strikes_for_glyph(glyph_id)
+        strikes.select { |strike| strike.includes_glyph?(glyph_id) }
+      end
+
+      # Get the number of bitmap strikes
+      #
+      # @return [Integer] Number of strikes
+      def num_strikes
+        num_sizes || 0
+      end
+
+      # Validate the CBLC table structure
+      #
+      # @return [Boolean] True if valid
+      def valid?
+        return false if version.nil?
+        return false unless [VERSION_2_0, VERSION_3_0].include?(version)
+        return false if num_sizes.nil? || num_sizes.negative?
+        return false unless bitmap_sizes
+
+        true
+      end
+
+      private
+
+      # Parse CBLC header (8 bytes)
+      #
+      # @param io [StringIO] Input stream
+      def parse_header(io)
+        @version = io.read(4).unpack1("N")
+        @num_sizes = io.read(4).unpack1("N")
+      end
+
+      # Validate header values
+      #
+      # @raise [CorruptedTableError] If validation fails
+      def validate_header!
+        unless [VERSION_2_0, VERSION_3_0].include?(version)
+          raise CorruptedTableError,
+                "Unsupported CBLC version: 0x#{version.to_s(16).upcase} " \
+                "(only versions 2.0 and 3.0 supported)"
+        end
+
+        if num_sizes.negative?
+          raise CorruptedTableError,
+                "Invalid numSizes: #{num_sizes}"
+        end
+      end
+
+      # Parse bitmap size records
+      #
+      # @param io [StringIO] Input stream
+      def parse_bitmap_sizes(io)
+        @bitmap_sizes = []
+        return if num_sizes.zero?
+
+        # Each BitmapSize record is 48 bytes
+        num_sizes.times do
+          size_data = io.read(48)
+          @bitmap_sizes << BitmapSize.read(size_data)
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cff.rb

@@ -268,8 +268,7 @@ module Fontisan
 
         PrivateDict.new(private_data)
       rescue StandardError => e
-        warn "Failed to parse Private DICT: #{e.message}"
-        nil
+        raise CorruptedTableError, "Failed to parse Private DICT: #{e.message}"
       end
 
       # Get the Local Subr INDEX for a specific font
@@ -300,8 +299,7 @@ module Fontisan
         io.seek(absolute_offset)
         Index.new(io, start_offset: absolute_offset)
       rescue StandardError => e
-        warn "Failed to parse Local Subr INDEX: #{e.message}"
-        nil
+        raise CorruptedTableError, "Failed to parse Local Subr INDEX: #{e.message}"
       end
 
       # Get the CharStrings INDEX for a specific font
@@ -322,8 +320,7 @@ module Fontisan
         io.seek(charstrings_offset)
         CharstringsIndex.new(io, start_offset: charstrings_offset)
       rescue StandardError => e
-        warn "Failed to parse CharStrings INDEX: #{e.message}"
-        nil
+        raise CorruptedTableError, "Failed to parse CharStrings INDEX: #{e.message}"
       end
 
       # Get a CharString for a specific glyph
@@ -358,8 +355,7 @@ module Fontisan
           local_subr_index,
         )
       rescue StandardError => e
-        warn "Failed to get CharString for glyph #{glyph_index}: #{e.message}"
-        nil
+        raise CorruptedTableError, "Failed to get CharString for glyph #{glyph_index}: #{e.message}"
       end
 
       # Get the number of glyphs in a font
@@ -437,8 +433,7 @@ module Fontisan
         num_glyphs = glyph_count(index)
         Charset.new(charset_data, num_glyphs, self)
       rescue StandardError => e
-        warn "Failed to parse Charset: #{e.message}"
-        nil
+        raise CorruptedTableError, "Failed to parse Charset: #{e.message}"
       end
 
       # Get the Encoding for a specific font
@@ -467,8 +462,7 @@ module Fontisan
         num_glyphs = glyph_count(index)
         Encoding.new(encoding_data, num_glyphs)
       rescue StandardError => e
-        warn "Failed to parse Encoding: #{e.message}"
-        nil
+        raise CorruptedTableError, "Failed to parse Encoding: #{e.message}"
       end
     end
 

data/lib/fontisan/tables/colr.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../binary/base_record"
+
+module Fontisan
+  module Tables
+    # COLR (Color) table parser
+    #
+    # The COLR table defines layered color glyphs where each layer references
+    # a glyph ID and a palette index from the CPAL table. This enables fonts
+    # to display multi-colored glyphs such as emoji or brand logos.
+    #
+    # COLR Table Structure:
+    # ```
+    # COLR Table = Header (14 bytes)
+    #            + Base Glyph Records (6 bytes each)
+    #            + Layer Records (4 bytes each)
+    # ```
+    #
+    # Version 0 Structure:
+    # - version (uint16): Table version (0)
+    # - numBaseGlyphRecords (uint16): Number of base glyphs
+    # - baseGlyphRecordsOffset (uint32): Offset to base glyph records array
+    # - layerRecordsOffset (uint32): Offset to layer records array
+    # - numLayerRecords (uint16): Number of layer records
+    #
+    # The COLR table must be used together with the CPAL (Color Palette) table
+    # which defines the actual RGB color values referenced by palette indices.
+    #
+    # Reference: OpenType COLR specification
+    # https://docs.microsoft.com/en-us/typography/opentype/spec/colr
+    #
+    # @example Reading a COLR table
+    #   data = font.table_data['COLR']
+    #   colr = Fontisan::Tables::Colr.read(data)
+    #   layers = colr.layers_for_glyph(42)
+    #   puts "Glyph 42 has #{layers.length} color layers"
+    class Colr < Binary::BaseRecord
+      # OpenType table tag for COLR
+      TAG = "COLR"
+
+      # Base Glyph Record structure for COLR table
+      #
+      # Each base glyph record associates a glyph ID with its color layers.
+      # Structure (6 bytes): glyph_id, first_layer_index, num_layers
+      class BaseGlyphRecord < Binary::BaseRecord
+        endian :big
+        uint16 :glyph_id
+        uint16 :first_layer_index
+        uint16 :num_layers
+
+        def has_layers?
+          num_layers.positive?
+        end
+      end
+
+      # Layer Record structure for COLR table
+      #
+      # Each layer record specifies a glyph and palette index.
+      # Structure (4 bytes): glyph_id, palette_index
+      class LayerRecord < Binary::BaseRecord
+        endian :big
+        FOREGROUND_COLOR = 0xFFFF
+
+        uint16 :glyph_id
+        uint16 :palette_index
+
+        def uses_foreground_color?
+          palette_index == FOREGROUND_COLOR
+        end
+
+        def uses_palette_color?
+          !uses_foreground_color?
+        end
+      end
+
+      # @return [Integer] COLR version (0 for version 0)
+      attr_reader :version
+
+      # @return [Integer] Number of base glyph records
+      attr_reader :num_base_glyph_records
+
+      # @return [Integer] Offset to base glyph records array
+      attr_reader :base_glyph_records_offset
+
+      # @return [Integer] Offset to layer records array
+      attr_reader :layer_records_offset
+
+      # @return [Integer] Number of layer records
+      attr_reader :num_layer_records
+
+      # @return [String] Raw binary data for the entire COLR table
+      attr_reader :raw_data
+
+      # @return [Array<BaseGlyphRecord>] Parsed base glyph records
+      attr_reader :base_glyph_records
+
+      # @return [Array<LayerRecord>] Parsed layer records
+      attr_reader :layer_records
+
+      # Override read to parse COLR structure
+      #
+      # @param io [IO, String] Binary data to read
+      # @return [Colr] Parsed COLR table
+      def self.read(io)
+        colr = new
+        return colr if io.nil?
+
+        data = io.is_a?(String) ? io : io.read
+        colr.parse!(data)
+        colr
+      end
+
+      # Parse the COLR table structure
+      #
+      # @param data [String] Binary data for the COLR table
+      # @raise [CorruptedTableError] If COLR structure is invalid
+      def parse!(data)
+        @raw_data = data
+        io = StringIO.new(data)
+
+        # Parse COLR header (14 bytes)
+        parse_header(io)
+        validate_header!
+
+        # Parse base glyph records
+        parse_base_glyph_records(io)
+
+        # Parse layer records
+        parse_layer_records(io)
+      rescue StandardError => e
+        raise CorruptedTableError, "Failed to parse COLR table: #{e.message}"
+      end
+
+      # Get color layers for a specific glyph ID
+      #
+      # Returns an array of LayerRecord objects for the specified glyph.
+      # Returns empty array if glyph has no color layers.
+      #
+      # @param glyph_id [Integer] Glyph ID to look up
+      # @return [Array<LayerRecord>] Array of layer records for this glyph
+      def layers_for_glyph(glyph_id)
+        # Find base glyph record for this glyph ID
+        base_record = find_base_glyph_record(glyph_id)
+        return [] unless base_record
+
+        # Extract layers for this glyph
+        first_index = base_record.first_layer_index
+        num_layers = base_record.num_layers
+
+        return [] if num_layers.zero?
+
+        # Return slice of layer records
+        layer_records[first_index, num_layers] || []
+      end
+
+      # Check if COLR table has color data for a specific glyph
+      #
+      # @param glyph_id [Integer] Glyph ID to check
+      # @return [Boolean] True if glyph has color layers
+      def has_color_glyph?(glyph_id)
+        !layers_for_glyph(glyph_id).empty?
+      end
+
+      # Get all glyph IDs that have color data
+      #
+      # @return [Array<Integer>] Array of glyph IDs with color layers
+      def color_glyph_ids
+        base_glyph_records.map(&:glyph_id)
+      end
+
+      # Get the number of color glyphs in this table
+      #
+      # @return [Integer] Number of base glyphs
+      def num_color_glyphs
+        num_base_glyph_records
+      end
+
+      # Validate the COLR table structure
+      #
+      # @return [Boolean] True if valid
+      def valid?
+        return false if version.nil?
+        return false if version != 0 # Only version 0 supported currently
+        return false if num_base_glyph_records.nil? || num_base_glyph_records.negative?
+        return false if num_layer_records.nil? || num_layer_records.negative?
+        return false unless base_glyph_records
+        return false unless layer_records
+
+        true
+      end
+
+      private
+
+      # Parse COLR header (14 bytes)
+      #
+      # @param io [StringIO] Input stream
+      def parse_header(io)
+        @version = io.read(2).unpack1("n")
+        @num_base_glyph_records = io.read(2).unpack1("n")
+        @base_glyph_records_offset = io.read(4).unpack1("N")
+        @layer_records_offset = io.read(4).unpack1("N")
+        @num_layer_records = io.read(2).unpack1("n")
+      end
+
+      # Validate header values
+      #
+      # @raise [CorruptedTableError] If validation fails
+      def validate_header!
+        unless version.zero?
+          raise CorruptedTableError,
+                "Unsupported COLR version: #{version} (only version 0 supported)"
+        end
+
+        if num_base_glyph_records.negative?
+          raise CorruptedTableError,
+                "Invalid numBaseGlyphRecords: #{num_base_glyph_records}"
+        end
+
+        if num_layer_records.negative?
+          raise CorruptedTableError,
+                "Invalid numLayerRecords: #{num_layer_records}"
+        end
+      end
+
+      # Parse base glyph records array
+      #
+      # @param io [StringIO] Input stream
+      def parse_base_glyph_records(io)
+        @base_glyph_records = []
+        return if num_base_glyph_records.zero?
+
+        # Seek to base glyph records
+        io.seek(base_glyph_records_offset)
+
+        # Parse each base glyph record (6 bytes each)
+        num_base_glyph_records.times do
+          record_data = io.read(6)
+          record = BaseGlyphRecord.read(record_data)
+          @base_glyph_records << record
+        end
+      end
+
+      # Parse layer records array
+      #
+      # @param io [StringIO] Input stream
+      def parse_layer_records(io)
+        @layer_records = []
+        return if num_layer_records.zero?
+
+        # Seek to layer records
+        io.seek(layer_records_offset)
+
+        # Parse each layer record (4 bytes each)
+        num_layer_records.times do
+          record_data = io.read(4)
+          record = LayerRecord.read(record_data)
+          @layer_records << record
+        end
+      end
+
+      # Find base glyph record for a specific glyph ID
+      #
+      # Uses binary search since base glyph records are sorted by glyph ID
+      #
+      # @param glyph_id [Integer] Glyph ID to find
+      # @return [BaseGlyphRecord, nil] Base glyph record or nil if not found
+      def find_base_glyph_record(glyph_id)
+        # Binary search through base glyph records
+        left = 0
+        right = base_glyph_records.length - 1
+
+        while left <= right
+          mid = (left + right) / 2
+          record = base_glyph_records[mid]
+
+          if record.glyph_id == glyph_id
+            return record
+          elsif record.glyph_id < glyph_id
+            left = mid + 1
+          else
+            right = mid - 1
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end