fontisan 0.2.3 → 0.2.5

data/lib/fontisan/tables/sbix.rb

@@ -0,0 +1,379 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../binary/base_record"
+
+module Fontisan
+  module Tables
+    # sbix (Standard Bitmap Graphics) table parser
+    #
+    # The sbix table contains embedded bitmap graphics (PNG, JPEG, TIFF)
+    # organized by strike sizes. This is Apple's format for color emoji.
+    #
+    # sbix Table Structure:
+    # ```
+    # sbix Table = Header (8 bytes)
+    #            + Strike Offsets Array (4 bytes × numStrikes)
+    #            + Strike Data (variable)
+    # ```
+    #
+    # Header (8 bytes):
+    # - version (uint16): Table version (1)
+    # - flags (uint16): Flags (0)
+    # - numStrikes (uint32): Number of bitmap strikes
+    #
+    # Each Strike contains:
+    # - ppem (uint16): Pixels per em
+    # - ppi (uint16): Pixels per inch (usually 72)
+    # - glyphDataOffsets (uint32 × numGlyphs+1): Array of glyph data offsets
+    # - glyph data records (variable)
+    #
+    # Glyph Data Record:
+    # - originOffsetX (int16): X offset
+    # - originOffsetY (int16): Y offset
+    # - graphicType (uint32): 'png ', 'jpg ', 'tiff', 'dupe', 'mask'
+    # - data (variable): Image data
+    #
+    # Reference: https://docs.microsoft.com/en-us/typography/opentype/spec/sbix
+    #
+    # @example Reading an sbix table
+    #   data = font.table_data['sbix']
+    #   sbix = Fontisan::Tables::Sbix.read(data)
+    #   strikes = sbix.strikes
+    #   png_data = sbix.glyph_data(42, 64)  # Get glyph 42 at 64 ppem
+    class Sbix < Binary::BaseRecord
+      # OpenType table tag for sbix
+      TAG = "sbix"
+
+      # Supported sbix version
+      VERSION_1 = 1
+
+      # Graphic type constants (4-byte ASCII codes)
+      GRAPHIC_TYPE_PNG = 0x706E6720   # 'png '
+      GRAPHIC_TYPE_JPG = 0x6A706720   # 'jpg '
+      GRAPHIC_TYPE_TIFF = 0x74696666  # 'tiff'
+      GRAPHIC_TYPE_DUPE = 0x64757065  # 'dupe'
+      GRAPHIC_TYPE_MASK = 0x6D61736B  # 'mask'
+
+      # Graphic type names
+      GRAPHIC_TYPE_NAMES = {
+        GRAPHIC_TYPE_PNG => "PNG",
+        GRAPHIC_TYPE_JPG => "JPEG",
+        GRAPHIC_TYPE_TIFF => "TIFF",
+        GRAPHIC_TYPE_DUPE => "dupe",
+        GRAPHIC_TYPE_MASK => "mask",
+      }.freeze
+
+      # @return [Integer] sbix version (should be 1)
+      attr_reader :version
+
+      # @return [Integer] Flags (reserved, should be 0)
+      attr_reader :flags
+
+      # @return [Integer] Number of bitmap strikes
+      attr_reader :num_strikes
+
+      # @return [Array<Integer>] Offsets to strike data from start of table
+      attr_reader :strike_offsets
+
+      # @return [Array<Hash>] Parsed strike records
+      attr_reader :strikes
+
+      # @return [String] Raw binary data for the entire sbix table
+      attr_reader :raw_data
+
+      # Override read to parse sbix structure
+      #
+      # @param io [IO, String] Binary data to read
+      # @return [Sbix] Parsed sbix table
+      def self.read(io)
+        sbix = new
+        return sbix if io.nil?
+
+        data = io.is_a?(String) ? io : io.read
+        sbix.parse!(data)
+        sbix
+      end
+
+      # Parse the sbix table structure
+      #
+      # @param data [String] Binary data for the sbix table
+      # @raise [CorruptedTableError] If sbix structure is invalid
+      def parse!(data)
+        @raw_data = data
+        io = StringIO.new(data)
+
+        # Parse sbix header (8 bytes)
+        parse_header(io)
+        validate_header!
+
+        # Parse strike offsets
+        parse_strike_offsets(io)
+
+        # Parse strike records
+        parse_strikes
+      rescue StandardError => e
+        raise CorruptedTableError, "Failed to parse sbix table: #{e.message}"
+      end
+
+      # Get glyph data at specific ppem
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @param ppem [Integer] Pixels per em
+      # @return [Hash, nil] Glyph data hash with keys: :origin_x, :origin_y, :graphic_type, :data
+      def glyph_data(glyph_id, ppem)
+        strike = strike_for_ppem(ppem)
+        return nil unless strike
+
+        extract_glyph_data(strike, glyph_id)
+      end
+
+      # Get strike for specific ppem
+      #
+      # @param ppem [Integer] Pixels per em
+      # @return [Hash, nil] Strike record or nil
+      def strike_for_ppem(ppem)
+        strikes&.find { |s| s[:ppem] == ppem }
+      end
+
+      # Get all ppem sizes
+      #
+      # @return [Array<Integer>] Sorted array of ppem sizes
+      def ppem_sizes
+        return [] unless strikes
+
+        strikes.map { |s| s[:ppem] }.uniq.sort
+      end
+
+      # Check if glyph has bitmap at ppem
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @param ppem [Integer] Pixels per em
+      # @return [Boolean] True if glyph has bitmap
+      def has_glyph_at_ppem?(glyph_id, ppem)
+        data = glyph_data(glyph_id, ppem)
+        !data.nil? && data[:data] && !data[:data].empty?
+      end
+
+      # Get supported graphic formats across all strikes
+      #
+      # @return [Array<String>] Array of format names (e.g., ["PNG", "JPEG"])
+      def supported_formats
+        return [] unless strikes
+
+        formats = []
+        strikes.each do |strike|
+          # Sample first few glyphs to detect formats
+          strike[:graphic_types]&.each do |type|
+            format_name = GRAPHIC_TYPE_NAMES[type]
+            formats << format_name if format_name && !["dupe", "mask"].include?(format_name)
+          end
+        end
+        formats.uniq.compact
+      end
+
+      # Validate the sbix table structure
+      #
+      # @return [Boolean] True if valid
+      def valid?
+        return false if version.nil?
+        return false if version != VERSION_1
+        return false if num_strikes.nil? || num_strikes.negative?
+        return false unless strikes
+
+        true
+      end
+
+      private
+
+      # Parse sbix header (8 bytes)
+      #
+      # @param io [StringIO] Input stream
+      def parse_header(io)
+        @version = io.read(2).unpack1("n")
+        @flags = io.read(2).unpack1("n")
+        @num_strikes = io.read(4).unpack1("N")
+      end
+
+      # Validate header values
+      #
+      # @raise [CorruptedTableError] If validation fails
+      def validate_header!
+        unless version == VERSION_1
+          raise CorruptedTableError,
+                "Unsupported sbix version: #{version} (only version 1 supported)"
+        end
+
+        if num_strikes.negative?
+          raise CorruptedTableError,
+                "Invalid numStrikes: #{num_strikes}"
+        end
+      end
+
+      # Parse strike offsets array
+      #
+      # @param io [StringIO] Input stream
+      def parse_strike_offsets(io)
+        @strike_offsets = []
+        return if num_strikes.zero?
+
+        num_strikes.times do
+          @strike_offsets << io.read(4).unpack1("N")
+        end
+      end
+
+      # Parse all strike records
+      #
+      # The number of glyphs is calculated from offset differences
+      def parse_strikes
+        @strikes = []
+        return if num_strikes.zero?
+
+        strike_offsets.each_with_index do |offset, index|
+          # Calculate strike size from offset difference
+          next_offset = if index < num_strikes - 1
+                          strike_offsets[index + 1]
+                        else
+                          raw_data.length
+                        end
+
+          strike = parse_strike(offset, next_offset - offset)
+          @strikes << strike
+        end
+      end
+
+      # Parse a single strike record
+      #
+      # @param offset [Integer] Offset from start of table
+      # @param size [Integer] Size of strike data
+      # @return [Hash] Strike record
+      def parse_strike(offset, size)
+        io = StringIO.new(raw_data)
+        io.seek(offset)
+
+        ppem = io.read(2).unpack1("n")
+        ppi = io.read(2).unpack1("n")
+
+        # Read glyph data offsets - they're relative to the start of the strike
+        # The array is numGlyphs+1 long, with the last offset marking the end
+        glyph_offsets = []
+
+        # Keep reading offsets until we find the pattern
+        # Offsets are relative to strike start, so they should be monotonically increasing
+        loop do
+          current_pos = io.pos
+          break if current_pos >= offset + size
+
+          offset_value = io.read(4)&.unpack1("N")
+          break unless offset_value
+
+          # If offset is beyond the strike size or smaller than previous, we've hit glyph data
+          if glyph_offsets.any? && offset_value < glyph_offsets.last
+            # Rewind - we read part of glyph data
+            io.seek(current_pos)
+            break
+          end
+
+          glyph_offsets << offset_value
+        end
+
+        num_glyphs = [glyph_offsets.length - 1, 0].max
+
+        # Sample graphic types from first few glyphs
+        graphic_types = sample_graphic_types(offset, glyph_offsets, size)
+
+        {
+          ppem: ppem,
+          ppi: ppi,
+          num_glyphs: num_glyphs,
+          base_offset: offset,
+          glyph_offsets: glyph_offsets,
+          graphic_types: graphic_types,
+        }
+      end
+
+      # Sample graphic types from first few glyphs
+      #
+      # @param strike_offset [Integer] Strike offset from table start
+      # @param glyph_offsets [Array<Integer>] Glyph data offsets (relative to strike start)
+      # @param strike_size [Integer] Total strike size
+      # @return [Array<Integer>] Unique graphic type codes found
+      def sample_graphic_types(strike_offset, glyph_offsets, strike_size)
+        types = []
+        return types if glyph_offsets.length < 2
+
+        # Sample first 5 glyphs or all glyphs if fewer
+        sample_count = [5, glyph_offsets.length - 1].min
+
+        sample_count.times do |i|
+          # Offsets are relative to strike start
+          glyph_offset = glyph_offsets[i]
+          next_glyph_offset = glyph_offsets[i + 1]
+
+          # Check if offsets are valid
+          next if glyph_offset >= strike_size || next_glyph_offset > strike_size
+          next if next_glyph_offset <= glyph_offset  # Empty glyph
+
+          # Calculate absolute offset in table
+          # glyph_offset is relative to strike start, so add strike_offset
+          absolute_offset = strike_offset + glyph_offset
+          next if absolute_offset + 8 > raw_data.length  # Need at least header
+
+          # Read graphic type (skip originOffsetX and originOffsetY = 4 bytes)
+          io = StringIO.new(raw_data)
+          io.seek(absolute_offset + 4)
+          graphic_type = io.read(4)&.unpack1("N")
+          types << graphic_type if graphic_type
+        end
+
+        types.compact.uniq
+      end
+
+      # Extract glyph data from strike
+      #
+      # @param strike [Hash] Strike record
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Hash, nil] Glyph data or nil
+      def extract_glyph_data(strike, glyph_id)
+        return nil unless strike
+        return nil if glyph_id >= strike[:num_glyphs]
+        return nil unless strike[:glyph_offsets]
+        return nil if glyph_id >= strike[:glyph_offsets].length - 1
+
+        # Offsets are relative to strike start
+        offset = strike[:glyph_offsets][glyph_id]
+        next_offset = strike[:glyph_offsets][glyph_id + 1]
+
+        return nil unless offset && next_offset
+        return nil if next_offset <= offset  # Empty glyph
+
+        # Calculate absolute position in table
+        absolute_offset = strike[:base_offset] + offset
+        data_length = next_offset - offset
+
+        # Need at least 8 bytes for glyph record header
+        return nil if data_length < 8
+        return nil if absolute_offset + data_length > raw_data.length
+
+        # Parse glyph data record
+        io = StringIO.new(raw_data)
+        io.seek(absolute_offset)
+
+        origin_x = io.read(2).unpack1("s>")  # int16 big-endian
+        origin_y = io.read(2).unpack1("s>")  # int16 big-endian
+        graphic_type = io.read(4).unpack1("N")
+
+        # Remaining bytes are the actual image data
+        image_data = io.read(data_length - 8)
+
+        {
+          origin_x: origin_x,
+          origin_y: origin_y,
+          graphic_type: graphic_type,
+          graphic_type_name: GRAPHIC_TYPE_NAMES[graphic_type] || "unknown",
+          data: image_data,
+        }
+      end
+    end
+  end
+end

data/lib/fontisan/tables/svg.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "zlib"
+require_relative "../binary/base_record"
+
+module Fontisan
+  module Tables
+    # SVG (Scalable Vector Graphics) table parser
+    #
+    # The SVG table contains embedded SVG documents for glyphs, typically used
+    # for color emoji or graphic elements. Each document can cover a range of
+    # glyph IDs and may be compressed with gzip.
+    #
+    # SVG Table Structure:
+    # ```
+    # SVG Table = Header (10 bytes)
+    #           + Document Index
+    #           + SVG Documents
+    # ```
+    #
+    # Header (10 bytes):
+    # - version (uint16): Table version (0)
+    # - svgDocumentListOffset (uint32): Offset to SVG Document Index
+    # - reserved (uint32): Reserved, set to 0
+    #
+    # Document Index:
+    # - numEntries (uint16): Number of SVG Document Index Entries
+    # - entries[numEntries]: Array of SVG Document Index Entries
+    #
+    # SVG Document Index Entry (12 bytes):
+    # - startGlyphID (uint16): First glyph ID
+    # - endGlyphID (uint16): Last glyph ID (inclusive)
+    # - svgDocOffset (uint32): Offset to SVG document
+    # - svgDocLength (uint32): Length of SVG document
+    #
+    # SVG documents may be compressed with gzip (identified by magic bytes 0x1f 0x8b).
+    #
+    # Reference: OpenType SVG specification
+    # https://docs.microsoft.com/en-us/typography/opentype/spec/svg
+    #
+    # @example Reading an SVG table
+    #   data = font.table_data['SVG ']
+    #   svg = Fontisan::Tables::Svg.read(data)
+    #   svg_content = svg.svg_for_glyph(42)
+    #   puts "Glyph 42 SVG: #{svg_content}"
+    class Svg < Binary::BaseRecord
+      # OpenType table tag for SVG (note: includes trailing space)
+      TAG = "SVG "
+
+      # SVG Document Index Entry structure
+      #
+      # Each entry associates a glyph range with an SVG document.
+      # Structure (12 bytes): start_glyph_id, end_glyph_id, svg_doc_offset, svg_doc_length
+      class SvgDocumentRecord < Binary::BaseRecord
+        endian :big
+        uint16 :start_glyph_id
+        uint16 :end_glyph_id
+        uint32 :svg_doc_offset
+        uint32 :svg_doc_length
+
+        # Check if this record 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_id >= start_glyph_id && glyph_id <= end_glyph_id
+        end
+
+        # Get the glyph range for this record
+        #
+        # @return [Range] Range of glyph IDs
+        def glyph_range
+          start_glyph_id..end_glyph_id
+        end
+      end
+
+      # @return [Integer] SVG table version (0)
+      attr_reader :version
+
+      # @return [Integer] Offset to SVG Document Index
+      attr_reader :svg_document_list_offset
+
+      # @return [Integer] Number of SVG document entries
+      attr_reader :num_entries
+
+      # @return [Array<SvgDocumentRecord>] Parsed document records
+      attr_reader :document_records
+
+      # @return [String] Raw binary data for the entire SVG table
+      attr_reader :raw_data
+
+      # Override read to parse SVG structure
+      #
+      # @param io [IO, String] Binary data to read
+      # @return [Svg] Parsed SVG table
+      def self.read(io)
+        svg = new
+        return svg if io.nil?
+
+        data = io.is_a?(String) ? io : io.read
+        svg.parse!(data)
+        svg
+      end
+
+      # Parse the SVG table structure
+      #
+      # @param data [String] Binary data for the SVG table
+      # @raise [CorruptedTableError] If SVG structure is invalid
+      def parse!(data)
+        @raw_data = data
+        io = StringIO.new(data)
+
+        # Parse SVG header (10 bytes)
+        parse_header(io)
+        validate_header!
+
+        # Parse document index
+        parse_document_index(io)
+      rescue StandardError => e
+        raise CorruptedTableError, "Failed to parse SVG table: #{e.message}"
+      end
+
+      # Get SVG document for a specific glyph ID
+      #
+      # Returns the SVG XML content for the specified glyph.
+      # Automatically decompresses gzipped content.
+      # Returns nil if glyph has no SVG data.
+      #
+      # @param glyph_id [Integer] Glyph ID to look up
+      # @return [String, nil] SVG XML content or nil
+      def svg_for_glyph(glyph_id)
+        record = find_document_record(glyph_id)
+        return nil unless record
+
+        extract_svg_document(record)
+      end
+
+      # Check if glyph has SVG data
+      #
+      # @param glyph_id [Integer] Glyph ID to check
+      # @return [Boolean] True if glyph has SVG
+      def has_svg_for_glyph?(glyph_id)
+        !find_document_record(glyph_id).nil?
+      end
+
+      # Get all glyph IDs that have SVG data
+      #
+      # @return [Array<Integer>] Array of glyph IDs with SVG
+      def glyph_ids_with_svg
+        document_records.flat_map do |record|
+          record.glyph_range.to_a
+        end
+      end
+
+      # Get the number of SVG documents in this table
+      #
+      # @return [Integer] Number of SVG documents
+      def num_svg_documents
+        num_entries
+      end
+
+      # Validate the SVG table structure
+      #
+      # @return [Boolean] True if valid
+      def valid?
+        return false if version.nil?
+        return false if version != 0 # Only version 0 supported
+        return false if num_entries.nil? || num_entries.negative?
+        return false unless document_records
+
+        true
+      end
+
+      private
+
+      # Parse SVG header (10 bytes)
+      #
+      # @param io [StringIO] Input stream
+      def parse_header(io)
+        @version = io.read(2).unpack1("n")
+        @svg_document_list_offset = io.read(4).unpack1("N")
+        @reserved = io.read(4).unpack1("N")
+      end
+
+      # Validate header values
+      #
+      # @raise [CorruptedTableError] If validation fails
+      def validate_header!
+        unless version.zero?
+          raise CorruptedTableError,
+                "Unsupported SVG version: #{version} (only version 0 supported)"
+        end
+
+        if svg_document_list_offset > raw_data.length
+          raise CorruptedTableError,
+                "Invalid svgDocumentListOffset: #{svg_document_list_offset}"
+        end
+      end
+
+      # Parse document index
+      #
+      # @param io [StringIO] Input stream
+      def parse_document_index(io)
+        # Seek to document index
+        io.seek(svg_document_list_offset)
+
+        # Check if there's enough data to read num_entries
+        return if io.eof?
+
+        # Parse number of entries
+        num_entries_data = io.read(2)
+        return if num_entries_data.nil? || num_entries_data.length < 2
+
+        @num_entries = num_entries_data.unpack1("n")
+        @document_records = []
+
+        return if num_entries.zero?
+
+        # Parse each document record (12 bytes each)
+        num_entries.times do
+          record_data = io.read(12)
+          record = SvgDocumentRecord.read(record_data)
+          @document_records << record
+        end
+      end
+
+      # Find document record for a specific glyph ID
+      #
+      # Uses binary search since document records should be sorted by glyph ID.
+      #
+      # @param glyph_id [Integer] Glyph ID to find
+      # @return [SvgDocumentRecord, nil] Document record or nil if not found
+      def find_document_record(glyph_id)
+        # Binary search through document records
+        left = 0
+        right = document_records.length - 1
+
+        while left <= right
+          mid = (left + right) / 2
+          record = document_records[mid]
+
+          if record.includes_glyph?(glyph_id)
+            return record
+          elsif glyph_id < record.start_glyph_id
+            right = mid - 1
+          else
+            left = mid + 1
+          end
+        end
+
+        nil
+      end
+
+      # Extract SVG document from record
+      #
+      # Calculates absolute offset and extracts SVG data.
+      # Automatically decompresses gzipped content.
+      #
+      # @param record [SvgDocumentRecord] Document record
+      # @return [String] SVG XML content
+      def extract_svg_document(record)
+        # Calculate absolute offset
+        # Offset is relative to start of SVG Document List
+        # Document List = numEntries (2 bytes) + entries array + documents
+        documents_offset = svg_document_list_offset + 2 + (num_entries * 12)
+        absolute_offset = documents_offset + record.svg_doc_offset
+
+        # Extract SVG data
+        svg_data = raw_data[absolute_offset, record.svg_doc_length]
+
+        # Check if compressed (gzip magic bytes: 0x1f 0x8b)
+        if gzipped?(svg_data)
+          decompress_gzip(svg_data)
+        else
+          svg_data
+        end
+      end
+
+      # Check if data is gzipped
+      #
+      # @param data [String] Binary data
+      # @return [Boolean] True if gzipped
+      def gzipped?(data)
+        return false if data.nil? || data.length < 2
+
+        data[0..1].unpack("C*") == [0x1f, 0x8b]
+      end
+
+      # Decompress gzipped data
+      #
+      # @param data [String] Gzipped binary data
+      # @return [String] Decompressed data
+      def decompress_gzip(data)
+        Zlib::GzipReader.new(StringIO.new(data)).read
+      rescue Zlib::Error => e
+        raise CorruptedTableError, "Failed to decompress SVG data: #{e.message}"
+      end
+    end
+  end
+end

data/lib/fontisan/true_type_font.rb

@@ -532,6 +532,12 @@ module Fontisan
         Constants::GPOS_TAG => Tables::Gpos,
         Constants::GLYF_TAG => Tables::Glyf,
         Constants::LOCA_TAG => Tables::Loca,
+        "SVG " => Tables::Svg,
+        "COLR" => Tables::Colr,
+        "CPAL" => Tables::Cpal,
+        "CBDT" => Tables::Cbdt,
+        "CBLC" => Tables::Cblc,
+        "sbix" => Tables::Sbix,
       }[tag]
     end