fontisan 0.4.15 → 0.4.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 422936ab5bbb785c6030c16efa61be31edd4c9e251828eabaa29e572a570bbb5
-  data.tar.gz: ad05bb618741fb0958e1be540af840debb9ffa4d92be469930f8e11f6ccd63fb
+  metadata.gz: 1d27d25052549a912eab7392f8f0b34e7917fad9e9344d178b853bfe5a9fb476
+  data.tar.gz: 7fe03e99020f0a628efa4bac17236c455143345dbe4aef1dd1df5a8890cf00ad
 SHA512:
-  metadata.gz: f9d938ed00f8bff70e0fe20b06751134faa1cb9c0f536467f1259866876d060f170ac94e0a89818a4f77662d873542c9a6bfb09d4da0de5577c3bda2a33f4efa
-  data.tar.gz: e6d7679235dab59a1a26bf5948f0651d147b12fec4218c000626ff0291fbec33593cef8ba0466e189d63c20f6cdc0d6c53b88626f47178656a272248e8e12872
+  metadata.gz: 5ddb0c714d55d9f0e3b6b2ae02322f210d2392391d604368628cf6a789e2c1633645b08d4ee1edca6e05c0dc87e7c6e6ec550bc412bcc79fe751cc21f1e55f62
+  data.tar.gz: f8a646128fbadfd95df57bffc933a17095b3fb228603c941471198186df112bc517d836d09c567c1456b5aa8caed3aec4c14f8c561ba4cc19a4561bf75124940

data/lib/fontisan/converters/woff2_encoder.rb

@@ -227,6 +227,12 @@ module Fontisan
       # are kept in `table_data` so its `origLength` is preserved; the
       # transformed bytes are passed to the entries builder separately.
       #
+      # glyf.origLength is computed by round-tripping the transformed glyf
+      # through the decoder — this guarantees the directory matches what
+      # any compliant decoder will produce, including padding and minor
+      # re-encoding differences (OFF section 5.3.3 allows multiple valid
+      # reconstructions of the same glyph data).
+      #
       # @return [Hash{Symbol => Object}, nil]
       def apply_glyf_loca_transform!(table_data, font)
         return nil unless font.respond_to?(:has_table?)
@@ -240,17 +246,32 @@ module Fontisan
         head = font.table("head")
         return nil unless maxp && head
 
+        index_format = head.index_to_loc_format
+
         transformed = Woff2::GlyfLocaTransform.new(
           glyf_data:,
           loca_data:,
           num_glyphs: maxp.num_glyphs,
-          index_format: head.index_to_loc_format,
+          index_format:,
         ).transform
 
-        loca_orig_length = loca_data.bytesize
+        # Round-trip through the decoder to get the exact reconstructed
+        # sizes the directory must advertise. fontTools re-compiles glyf
+        # during encoding, producing sizes that differ from the source by
+        # small amounts (encoding variations per OFF section 5.3.3). Using
+        # the source bytesize causes fontTools' decoder to reject the
+        # WOFF2 with "not enough 'glyf' table data".
+        reconstructed = Woff2::GlyfLocaReconstruct.new(
+          transformed_glyf: transformed,
+          num_glyphs: maxp.num_glyphs,
+          index_format:,
+        ).reconstruct
+
+        glyf_orig_length = reconstructed[:glyf].bytesize
+        loca_orig_length = reconstructed[:loca].bytesize
         table_data.delete("loca")
 
-        { transformed_glyf: transformed, loca_orig_length: }
+        { transformed_glyf: transformed, glyf_orig_length:, loca_orig_length: }
       end
 
       def get_table_data(font, tag)
@@ -277,7 +298,7 @@ module Fontisan
 
         table_data.keys.sort.each do |tag|
           if tag == "glyf" && glyf_transform
-            entries << build_glyf_entry(table_data["glyf"],
+            entries << build_glyf_entry(glyf_transform[:glyf_orig_length],
                                         glyf_transform[:transformed_glyf])
             entries << build_loca_entry(glyf_transform[:loca_orig_length])
             transformed_data["glyf"] = glyf_transform[:transformed_glyf]
@@ -314,13 +335,13 @@ module Fontisan
         entry
       end
 
-      # Build the glyf directory entry. origLength is the original (input)
-      # glyf size; transformLength is the size of the WOFF2-transformed
-      # glyf stream per spec section 5.1.
-      def build_glyf_entry(orig_data, transformed_data)
+      # Build the glyf directory entry. origLength is the reconstructed
+      # glyf size (what a decoder will produce); transformLength is the
+      # size of the WOFF2-transformed glyf stream per spec section 5.1.
+      def build_glyf_entry(glyf_orig_length, transformed_data)
         entry = Woff2::Directory::Entry.new
         entry.tag = "glyf"
-        entry.orig_length = orig_data.bytesize
+        entry.orig_length = glyf_orig_length
         entry.transform_length = transformed_data.bytesize
         entry.flags = entry.calculate_flags
         entry

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.4.15"
+  VERSION = "0.4.16"
 end

data/lib/fontisan/woff2/collection_decoder.rb

@@ -133,14 +133,14 @@ module Fontisan
         pos += 4
         raise InvalidFontError, "Unsupported CollectionHeader version 0x#{version.to_s(16)}" unless version == 0x00010000
 
-        num_fonts, pos = read_255_uint16(pos)
+        num_fonts, pos = UInt255.decode_at(@data, pos)
         font_entries = Array.new(num_fonts) do
-          num_tables_f, pos2 = read_255_uint16(pos)
+          num_tables_f, pos2 = UInt255.decode_at(@data, pos)
           pos = pos2
           flavor = @data[pos, 4].unpack1("N")
           pos += 4
           indices = Array.new(num_tables_f) do
-            idx, pos2 = read_255_uint16(pos)
+            idx, pos2 = UInt255.decode_at(@data, pos)
             pos = pos2
             idx
           end
@@ -201,26 +201,6 @@ module Fontisan
         end
         raise InvalidFontError, "UIntBase128 sequence exceeds 5 bytes"
       end
-
-      def read_255_uint16(pos)
-        code = @data.getbyte(pos)
-        pos += 1
-        case code
-        when 0..252 then [code, pos]
-        when 253
-          v = @data.getbyte(pos)
-          pos += 1
-          [253 + v, pos]
-        when 254
-          v = @data[pos, 2].unpack1("n")
-          pos += 2
-          [v, pos]
-        when 255
-          v = @data[pos, 2].unpack1("n")
-          pos += 2
-          [v + 506, pos]
-        end
-      end
     end
   end
 end

data/lib/fontisan/woff2/collection_encoder.rb

@@ -238,7 +238,7 @@ module Fontisan
       def write_collection_directory(io, fonts, font_to_ckeys, ckey_to_index)
         # CollectionHeader
         io.write([0x00010000].pack("N")) # version 1.0
-        io.write(encode_255_uint16(fonts.size))
+        io.write(UInt255.encode(fonts.size))
 
         # One CollectionFontEntry per font
         fonts.each_with_index do |font, fi|
@@ -254,12 +254,12 @@ module Fontisan
           ordered << "loca" if has_placeholder
           ordered = ordered.sort
 
-          io.write(encode_255_uint16(ordered.size))
+          io.write(UInt255.encode(ordered.size))
           io.write([font_flavor(font)].pack("N"))
           ordered.each do |tag|
             ckey = font_keys[tag] || placeholder_key
             index = ckey_to_index.fetch(ckey)
-            io.write(encode_255_uint16(index))
+            io.write(UInt255.encode(index))
           end
         end
       end
@@ -271,18 +271,6 @@ module Fontisan
           Constants::SFNT_VERSION_TRUETYPE
         end
       end
-
-      def encode_255_uint16(value)
-        if value < 253
-          [value].pack("C")
-        elsif value < 506
-          [253, value - 253].pack("CC")
-        elsif value < 65_536
-          [254].pack("C") + [value].pack("n")
-        else
-          [255].pack("C") + [value - 506].pack("n")
-        end
-      end
     end
   end
 end

data/lib/fontisan/woff2/directory.rb

@@ -235,48 +235,20 @@ module Fontisan
         raise Fontisan::Error, "Invalid UIntBase128 encoding"
       end
 
-      # Encode 255UInt16 value
-      #
-      # Used in transformed glyf table:
-      # - 0-252: value itself (1 byte)
-      # - 253: next byte + 253 (2 bytes)
-      # - 254: next 2 bytes as big-endian (3 bytes)
-      # - 255: next 2 bytes + 506 (3 bytes)
+      # Encode 255UInt16. Delegates to {UInt255} (single source of truth).
       #
       # @param value [Integer] Value to encode (0-65535)
       # @return [String] Binary encoded data
       def self.encode_255_uint16(value)
-        if value < 253
-          [value].pack("C")
-        elsif value < 506
-          [253, value - 253].pack("C*")
-        elsif value < 65536
-          [254].pack("C") + [value].pack("n")
-        else
-          [255].pack("C") + [value - 506].pack("n")
-        end
+        UInt255.encode(value)
       end
 
-      # Decode 255UInt16 from IO
+      # Decode 255UInt16 from IO. Delegates to {UInt255}.
       #
       # @param io [IO] Input stream
       # @return [Integer] Decoded value
       def self.decode_255_uint16(io)
-        first = io.read(1)&.unpack1("C")
-        return nil unless first
-
-        case first
-        when 0..252
-          first
-        when 253
-          second = io.read(1)&.unpack1("C")
-          253 + second
-        when 254
-          io.read(2)&.unpack1("n")
-        when 255
-          value = io.read(2)&.unpack1("n")
-          value + 506
-        end
+        UInt255.decode(io)
       end
     end
   end

data/lib/fontisan/woff2/encoder_rules.rb

@@ -52,12 +52,6 @@ module Fontisan
       # the 'flags' field of the head table ... to indicate that a recreated
       # font file was subjected to lossless modifying transform."
       #
-      # Also forces head.indexToLocFormat=0 when the glyf/loca tables are
-      # transformed, because Chrome's OTS only accepts WOFF2 glyf
-      # indexFormat=0 (see GlyfLocaTransform). For the reconstructed font
-      # to be self-consistent, head.indexToLocFormat must match the loca
-      # format that the decoder will produce (always short, format=0).
-      #
       # Uses the model-driven Head BinData record so the bits are set via a
       # named attribute on a typed object, not via raw byte slicing.
       def self.mark_lossless_modifying!(table_data)
@@ -65,7 +59,6 @@ module Fontisan
 
         head = Tables::Head.read(table_data["head"])
         head.flags |= Tables::Head::FLAG_LOSSLESS_MODIFYING
-        head.index_to_loc_format = 0
         table_data["head"] = head.to_binary_s
       end
     end

data/lib/fontisan/woff2/glyf_loca_reconstruct.rb

@@ -143,7 +143,7 @@ module Fontisan
         end_pts = []
         cumulative = -1
         num_contours.times do
-          pts_of_contour = read_255_uint16(streams[:n_points])
+          pts_of_contour = UInt255.decode(streams[:n_points])
           cumulative += pts_of_contour
           end_pts << cumulative
         end
@@ -169,7 +169,7 @@ module Fontisan
         end
 
         # Step 4-5: read instructionLength from glyphStream, bytes from instructionStream.
-        inst_len = read_255_uint16(streams[:glyph])
+        inst_len = UInt255.decode(streams[:glyph])
         instructions = streams[:instructions].read(inst_len)
 
         # Bbox: emit explicit bbox if bboxBitmap bit is set for this glyph,
@@ -209,7 +209,7 @@ module Fontisan
 
         instructions = String.new(encoding: Encoding::BINARY)
         if have_instructions
-          inst_len = read_255_uint16(streams[:glyph])
+          inst_len = UInt255.decode(streams[:glyph])
           instructions = streams[:instructions].read(inst_len)
         end
 
@@ -252,26 +252,6 @@ module Fontisan
         bytes ? bytes.bytes : Array.new(n_bytes, 0)
       end
 
-      def read_255_uint16(io)
-        return 0 if io.eof?
-
-        code = io.read(1)&.unpack1("C")
-        return 0 unless code
-
-        case code
-        when 0..252 then code
-        when 253
-          b = io.read(1)&.unpack1("C") || 0
-          253 + b
-        when 254
-          io.read(2)&.unpack1("n") || 0
-
-        when 255
-          v = io.read(2)&.unpack1("n") || 0
-          v + 506
-        end
-      end
-
       def read_uint16_io(io)
         io.read(2)&.unpack1("n") || 0
       end

data/lib/fontisan/woff2/glyf_loca_transform.rb

@@ -127,7 +127,7 @@ module Fontisan
         # nPoints stream: per-contour point counts (NOT endPtsOfContours).
         prev_end = -1
         end_pts.each do |ep|
-          s.n_points << encode_255_uint16(ep - prev_end)
+          s.n_points << UInt255.encode(ep - prev_end)
           prev_end = ep
         end
 
@@ -157,7 +157,7 @@ module Fontisan
         end
 
         # glyphStream carries per-glyph instructionLength; bytes go to instructionStream
-        s.glyph << encode_255_uint16(instructions.bytesize)
+        s.glyph << UInt255.encode(instructions.bytesize)
         s.instructions << instructions
 
         # Spec: simple glyphs omit bbox when it matches calculated bounds.
@@ -191,7 +191,7 @@ module Fontisan
         if have_instructions
           inst_len = io.read(2).unpack1("n")
           instructions = io.read(inst_len)
-          s.glyph << encode_255_uint16(instructions.bytesize)
+          s.glyph << UInt255.encode(instructions.bytesize)
           s.instructions << instructions
         end
 
@@ -255,10 +255,11 @@ module Fontisan
         out << [0].pack("S>")                                  # version
         out << [(s.has_overlap? ? 1 : 0)].pack("S>")           # optionFlags
         out << [@num_glyphs].pack("S>")
-        # Always emit indexFormat=0 per Chrome OTS requirement. WOFF2 spec
-        # section 5.1 allows the source's indexToLocFormat, but Chrome's
-        # OTS silently rejects any value other than 0.
-        out << [0].pack("S>")
+        # Emit the source's indexFormat. The earlier "always 0" override
+        # (commit 5f7e32d) was based on a misdiagnosis — Chrome's OTS
+        # accepts both 0 and 1, but short loca (0) can't address glyf
+        # offsets > 0x20000 bytes, so large fonts MUST use 1.
+        out << [@source_index_format].pack("S>")
         out << [s.n_contour.bytesize].pack("L>")
         out << [s.n_points.bytesize].pack("L>")
         out << [s.flags.bytesize].pack("L>")
@@ -313,18 +314,6 @@ module Fontisan
 
         [xs.min, ys.min, xs.max, ys.max]
       end
-
-      def encode_255_uint16(value)
-        if value < 253
-          [value].pack("C")
-        elsif value < 506
-          [253, value - 253].pack("CC")
-        elsif value < 65_536
-          [254].pack("C") + [value].pack("n")
-        else
-          [255].pack("C") + [value - 506].pack("n")
-        end
-      end
     end
   end
 end

data/lib/fontisan/woff2/hmtx_transformer.rb

@@ -46,7 +46,7 @@ glyf_lsbs = nil)
         if (flags & HMTX_FLAG_EXPLICIT_ADVANCE_WIDTHS).zero?
           # Proportional encoding - read deltas
           # First advance width is explicit
-          first_advance = read_255_uint16(io)
+          first_advance = UInt255.decode(io)
           advance_widths << first_advance
 
           # Remaining are deltas from previous
@@ -57,7 +57,7 @@ glyf_lsbs = nil)
         else
           # Explicit advance widths in transformed format
           num_h_metrics.times do
-            advance_widths << read_255_uint16(io)
+            advance_widths << UInt255.decode(io)
           end
         end
 
@@ -88,31 +88,6 @@ glyf_lsbs = nil)
         build_hmtx_table(advance_widths, lsbs, num_h_metrics, num_glyphs)
       end
 
-      # Read variable-length 255UInt16 integer
-      #
-      # Format from WOFF2 spec:
-      # - value < 253: one byte
-      # - value == 253: 253 + next uint16
-      # - value == 254: 253 * 2 + next uint16
-      # - value == 255: 253 * 3 + next uint16
-      #
-      # @param io [StringIO] Input stream
-      # @return [Integer] Decoded value
-      def self.read_255_uint16(io)
-        code = read_uint8(io)
-
-        case code
-        when 255
-          759 + read_uint16(io)  # 253 * 3 + value
-        when 254
-          506 + read_uint16(io)  # 253 * 2 + value
-        when 253
-          253 + read_uint16(io)
-        else
-          code
-        end
-      end
-
       # Build standard hmtx table format
       #
       # Standard hmtx format:

data/lib/fontisan/woff2/table_transformer.rb

@@ -401,7 +401,7 @@ num_glyphs)
 
         # Write advance widths using proportional encoding
         # First advance width is explicit
-        data << encode_255_uint16(advance_widths[0])
+        data << UInt255.encode(advance_widths[0])
 
         # Remaining advance widths as deltas
         (1...num_h_metrics).each do |i|
@@ -473,7 +473,7 @@ num_glyphs)
             prev_pt = -1
             glyph[:end_pts].each do |pt|
               delta = pt - prev_pt - 1
-              n_points_stream << encode_255_uint16(delta)
+              n_points_stream << UInt255.encode(delta)
               prev_pt = pt
             end
 
@@ -488,7 +488,7 @@ num_glyphs)
             glyph[:bbox].each { |v| bbox_stream << [v].pack("n") }
 
             # Write instructions
-            instruction_stream << encode_255_uint16(glyph[:instructions].bytesize)
+            instruction_stream << UInt255.encode(glyph[:instructions].bytesize)
             instruction_stream << glyph[:instructions] if glyph[:instructions].bytesize.positive?
 
           when :composite
@@ -569,22 +569,6 @@ num_glyphs)
         end
       end
 
-      # Encode 255UInt16 value
-      #
-      # @param value [Integer] Value to encode
-      # @return [String] Encoded bytes
-      def encode_255_uint16(value)
-        if value < 253
-          [value].pack("C")
-        elsif value < 506
-          [253, value - 253].pack("CC")
-        elsif value < 65536
-          [254].pack("C") + [value].pack("n")
-        else
-          [255].pack("C") + [value - 506].pack("n")
-        end
-      end
-
       # Read signed 16-bit integer
       #
       # @param io [StringIO] Input stream

data/lib/fontisan/woff2/uint255.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  module Woff2
+    # 255UInt16 variable-length encoding per WOFF2 spec section 3.1.
+    #
+    # Single source of truth for encoding and decoding this data type. All
+    # other WOFF2 code MUST delegate to this module — the previous inline
+    # copies had the code-byte mapping inverted for values ≥ 253.
+    #
+    # Encoding table (per W3C spec pseudocode):
+    #
+    #   value range     | encoding              | bytes
+    #   ----------------|-----------------------|------
+    #   0 .. 252        | literal              | 1
+    #   253 .. 505      | code 255 + (v - 253) | 2
+    #   506 .. 761      | code 254 + (v - 506) | 2
+    #   762 .. 65535    | code 253 + uint16    | 3
+    #
+    # Decoding (inverse):
+    #
+    #   code byte | meaning
+    #   ----------|--------------------------------
+    #   0 .. 252  | literal value
+    #   253       | read uint16 → value
+    #   254       | read 1 byte → value + 506
+    #   255       | read 1 byte → value + 253
+    module UInt255
+      WORD_CODE = 253
+      ONE_MORE_BYTE_CODE1 = 255 # adds 253
+      ONE_MORE_BYTE_CODE2 = 254 # adds 506
+
+      MAX_VALUE = 65_535
+
+      # Encode a value (0..65535) into a 1-3 byte binary string.
+      #
+      # @param value [Integer]
+      # @return [String] binary-encoded bytes
+      # @raise [ArgumentError] if value is out of range
+      def self.encode(value)
+        case value
+        when 0..252
+          [value].pack("C")
+        when 253..505
+          [ONE_MORE_BYTE_CODE1, value - 253].pack("C*")
+        when 506..761
+          [ONE_MORE_BYTE_CODE2, value - 506].pack("C*")
+        when 762..MAX_VALUE
+          [WORD_CODE].pack("C") + [value].pack("n")
+        else
+          raise ArgumentError,
+                "255UInt16 requires 0 <= value <= #{MAX_VALUE}, got #{value}"
+        end
+      end
+
+      # Decode a 255UInt16 value from an IO stream. Reads 1-3 bytes.
+      #
+      # @param io [IO, StringIO] input stream positioned at the code byte
+      # @return [Integer, nil] decoded value, or nil if the stream is empty
+      def self.decode(io)
+        code = io.read(1)&.unpack1("C")
+        return nil unless code
+
+        case code
+        when 0..252
+          code
+        when WORD_CODE
+          io.read(2)&.unpack1("n")
+        when ONE_MORE_BYTE_CODE2
+          506 + (io.read(1)&.unpack1("C") || 0)
+        when ONE_MORE_BYTE_CODE1
+          253 + (io.read(1)&.unpack1("C") || 0)
+        end
+      end
+
+      # Decode from a binary String at a given position. Returns the value
+      # and the new cursor position. Used by callers that index into a
+      # flat String rather than wrapping it in a StringIO.
+      #
+      # @param data [String] binary data
+      # @param pos [Integer] byte offset of the code byte
+      # @return [Array(Integer, Integer)] [value, new_pos]
+      def self.decode_at(data, pos)
+        code = data.getbyte(pos)
+        pos += 1
+        case code
+        when 0..252
+          [code, pos]
+        when WORD_CODE
+          [data[pos, 2].unpack1("n"), pos + 2]
+        when ONE_MORE_BYTE_CODE2
+          [506 + data.getbyte(pos), pos + 1]
+        when ONE_MORE_BYTE_CODE1
+          [253 + data.getbyte(pos), pos + 1]
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/woff2.rb

@@ -13,6 +13,7 @@ module Fontisan
     autoload :HmtxTransformer, "fontisan/woff2/hmtx_transformer"
     autoload :TableTransformer, "fontisan/woff2/table_transformer"
     autoload :TripletCodec, "fontisan/woff2/triplet_codec"
+    autoload :UInt255, "fontisan/woff2/uint255"
     autoload :Woff2Header, "fontisan/woff2/header"
   end
 end

data/lib/fontisan/woff2_font.rb

@@ -732,22 +732,6 @@ module Fontisan
       self.class.read_uint_base128_from_io(io)
     end
 
-    # Read 255UInt16 variable-length integer
-    def read_255_uint16(io)
-      code = io.read(1).unpack1("C")
-
-      case code
-      when 0..252
-        code
-      when 253
-        253 + io.read(1).unpack1("C")
-      when 254
-        io.read(2).unpack1("n")
-      when 255
-        io.read(2).unpack1("n") + 506
-      end
-    end
-
     # Calculate offset table fields
     def calculate_offset_table_fields(num_tables)
       entry_selector = (Math.log(num_tables) / Math.log(2)).floor

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.15
+  version: 0.4.16
 platform: ruby
 authors:
 - Ribose Inc.
@@ -729,6 +729,7 @@ files:
 - lib/fontisan/woff2/hmtx_transformer.rb
 - lib/fontisan/woff2/table_transformer.rb
 - lib/fontisan/woff2/triplet_codec.rb
+- lib/fontisan/woff2/uint255.rb
 - lib/fontisan/woff2_collection.rb
 - lib/fontisan/woff2_font.rb
 - lib/fontisan/woff_font.rb