fontisan 0.4.46 → 0.4.47

data/lib/fontisan/variation/instancing/axis_space.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Variation
+    module Instancing
+      # The design space of a variable font: fvar axes plus avar mapping.
+      # Validates user coordinates and normalizes them to -1..1.
+      class AxisSpace
+        Axis = Struct.new(:tag, :minimum, :default, :maximum, :name_id)
+
+        attr_reader :axes
+
+        # @param fvar [String] raw fvar table
+        # @param avar [String, nil] raw avar table
+        def initialize(fvar, avar = nil)
+          @axes = parse_fvar(fvar)
+          @segments = avar ? parse_avar(avar) : {}
+        end
+
+        def tags
+          @axes.map(&:tag)
+        end
+
+        # Named instances: [{ name_id:, coordinates: { tag => value } }]
+        def self.named_instances(fvar)
+          offset, axis_count, axis_size, inst_count, inst_size = header(fvar)
+          base = offset + (axis_count * axis_size)
+          Array.new(inst_count) do |i|
+            pos = base + (i * inst_size)
+            name_id = fvar[pos, 2].unpack1("n")
+            coords = Array.new(axis_count) do |a|
+              fixed(fvar, pos + 4 + (a * 4))
+            end
+            { name_id: name_id, values: coords }
+          end
+        end
+
+        def self.header(fvar)
+          offset, _res, axis_count, axis_size, inst_count, inst_size =
+            fvar[4, 12].unpack("nnnnnn")
+          [offset, axis_count, axis_size, inst_count, inst_size]
+        end
+
+        def self.fixed(data, pos)
+          data[pos, 4].unpack1("l>") / 65536.0
+        end
+
+        # @param requested [Hash{String=>Numeric}] user coordinates
+        # @return [Hash{String=>Float}] full user location (defaults filled)
+        # @raise [InvalidCoordinatesError, InvalidAxisError]
+        def validate(requested)
+          known = tags
+          requested.each_key do |tag|
+            next if known.include?(tag.to_s)
+
+            raise InvalidAxisError.new(
+              axis: tag.to_s,
+              reason: "font has axes #{known.join(', ')}",
+            )
+          end
+          @axes.to_h do |axis|
+            value = requested.transform_keys(&:to_s)[axis.tag]
+            value = axis.default if value.nil?
+            value = Float(value)
+            unless value.between?(axis.minimum, axis.maximum)
+              raise InvalidCoordinatesError.new(
+                axis: axis.tag, value: value, range: [axis.minimum, axis.maximum],
+              )
+            end
+            [axis.tag, value]
+          end
+        end
+
+        # @return [Array<Float>] normalized (avar-mapped) coordinates, fvar order
+        def normalize(location)
+          @axes.map do |axis|
+            value = location.fetch(axis.tag)
+            n = if value < axis.default
+                  (value - axis.default) / (axis.default - axis.minimum)
+                elsif value > axis.default
+                  (value - axis.default) / (axis.maximum - axis.default)
+                else
+                  0.0
+                end
+            map_segment(axis.tag, n.clamp(-1.0, 1.0))
+          end
+        end
+
+        private
+
+        def parse_fvar(fvar)
+          offset, axis_count, axis_size, = self.class.header(fvar)
+          Array.new(axis_count) do |i|
+            pos = offset + (i * axis_size)
+            Axis.new(fvar[pos, 4], self.class.fixed(fvar, pos + 4),
+                     self.class.fixed(fvar, pos + 8),
+                     self.class.fixed(fvar, pos + 12),
+                     fvar[pos + 18, 2].unpack1("n"))
+          end
+        end
+
+        # avar v1: per axis, array of [from, to] pairs (F2Dot14)
+        def parse_avar(avar)
+          axis_count = avar[6, 2].unpack1("n")
+          pos = 8
+          segments = {}
+          axis_count.times do |i|
+            count = avar[pos, 2].unpack1("n")
+            pos += 2
+            pairs = Array.new(count) do |j|
+              from, to = avar[pos + (j * 4), 4].unpack("s>s>")
+              [from / 16384.0, to / 16384.0]
+            end
+            pos += count * 4
+            segments[@axes[i].tag] = pairs if @axes[i]
+          end
+          segments
+        end
+
+        def map_segment(tag, value)
+          pairs = @segments[tag]
+          return value if pairs.nil? || pairs.empty?
+
+          exact = pairs.find { |from, _| from == value }
+          return exact[1] if exact
+
+          idx = pairs.index { |from, _| from > value }
+          return value if idx.nil? || idx.zero?
+
+          (f0, t0), (f1, t1) = pairs[idx - 1], pairs[idx]
+          t0 + ((t1 - t0) * (value - f0) / (f1 - f0))
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/variation/instancing/glyph_outline.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Variation
+    module Instancing
+      # A parsed glyf entry that can be moved by deltas and re-serialized.
+      # Points are the simple-glyph points, or for composites one point per
+      # component (its x/y offset), matching gvar's point numbering.
+      class GlyphOutline
+        ON_CURVE = 0x01
+        X_SHORT = 0x02
+        Y_SHORT = 0x04
+        REPEAT = 0x08
+        X_SAME = 0x10
+        Y_SAME = 0x20
+
+        ARGS_ARE_WORDS = 0x0001
+        ARGS_ARE_XY = 0x0002
+        HAVE_SCALE = 0x0008
+        MORE_COMPONENTS = 0x0020
+        HAVE_XY_SCALE = 0x0040
+        HAVE_TWO_BY_TWO = 0x0080
+
+        Component = Struct.new(:flags, :gid, :arg1, :arg2, :transform)
+
+        attr_reader :end_pts, :on_curve, :overlap, :instructions, :components,
+                    :trailer, :header_contours
+
+        def self.parse(bytes)
+          new(bytes)
+        end
+
+        def initialize(bytes)
+          @header_contours = 0
+          @end_pts = []
+          @on_curve = []
+          @components = []
+          @points = []
+          return if bytes.nil? || bytes.empty?
+
+          @header_contours = bytes[0, 2].unpack1("s>")
+          if @header_contours >= 0
+            parse_simple(bytes)
+          else
+            parse_composite(bytes)
+          end
+        end
+
+        def empty?
+          @header_contours.zero? && @points.empty?
+        end
+
+        def composite?
+          @header_contours.negative?
+        end
+
+        # @return [Array<Array<Float>>] [[x, y], ...]
+        def points
+          @points.map(&:dup)
+        end
+
+        def point_count
+          @points.size
+        end
+
+        def bounds_of(points)
+          return nil if points.empty?
+
+          xs = points.map(&:first)
+          ys = points.map(&:last)
+          [xs.min, ys.min, xs.max, ys.max]
+        end
+
+        # Serialize with the given (already rounded) points. +bbox+ is the
+        # [xMin, yMin, xMax, yMax] to record in the header.
+        def serialize(new_points, bbox)
+          return "".b if empty?
+
+          composite? ? serialize_composite(new_points, bbox) : serialize_simple(new_points, bbox)
+        end
+
+        private
+
+        def parse_simple(bytes)
+          n = @header_contours
+          @end_pts = bytes[10, n * 2].unpack("n*")
+          pos = 10 + (n * 2)
+          ilen = bytes[pos, 2].unpack1("n")
+          @instructions = bytes[pos + 2, ilen]
+          pos += 2 + ilen
+          count = n.zero? ? 0 : @end_pts.last + 1
+          flags = []
+          while flags.size < count
+            f = bytes.getbyte(pos)
+            pos += 1
+            flags << f
+            if f.anybits?(REPEAT)
+              bytes.getbyte(pos).times { flags << f }
+              pos += 1
+            end
+          end
+          xs = read_coords(bytes, pos, flags, X_SHORT, X_SAME)
+          pos = xs.pop
+          ys = read_coords(bytes, pos, flags, Y_SHORT, Y_SAME)
+          ys.pop
+          @on_curve = flags.map { |f| f.anybits?(ON_CURVE) }
+          @overlap = flags.first&.anybits?(0x40) || false
+          @points = xs.zip(ys)
+        end
+
+        def read_coords(bytes, pos, flags, short, same)
+          val = 0
+          out = flags.map do |f|
+            if f.anybits?(short)
+              d = bytes.getbyte(pos)
+              pos += 1
+              val += f.anybits?(same) ? d : -d
+            elsif !f.anybits?(same)
+              val += bytes[pos, 2].unpack1("s>")
+              pos += 2
+            end
+            val
+          end
+          out << pos
+        end
+
+        def parse_composite(bytes)
+          pos = 10
+          loop do
+            flags, gid = bytes[pos, 4].unpack("nn")
+            pos += 4
+            if flags.anybits?(ARGS_ARE_WORDS)
+              fmt = flags.anybits?(ARGS_ARE_XY) ? "s>s>" : "nn"
+              a1, a2 = bytes[pos, 4].unpack(fmt)
+              pos += 4
+            else
+              fmt = flags.anybits?(ARGS_ARE_XY) ? "cc" : "CC"
+              a1, a2 = bytes[pos, 2].unpack(fmt)
+              pos += 2
+            end
+            tlen = if flags.anybits?(HAVE_SCALE) then 2
+                   elsif flags.anybits?(HAVE_XY_SCALE) then 4
+                   elsif flags.anybits?(HAVE_TWO_BY_TWO) then 8
+                   else 0
+                   end
+            @components << Component.new(flags, gid, a1, a2, bytes[pos, tlen])
+            pos += tlen
+            break unless flags.anybits?(MORE_COMPONENTS)
+          end
+          @trailer = bytes[pos..] || "".b
+          @points = @components.map do |c|
+            c.flags.anybits?(ARGS_ARE_XY) ? [c.arg1.to_f, c.arg2.to_f] : [0.0, 0.0]
+          end
+        end
+
+        def serialize_simple(pts, bbox)
+          out = [@header_contours, *bbox].pack("s>5")
+          out << @end_pts.pack("n*")
+          out << [@instructions.bytesize].pack("n") << @instructions
+          flags = +"".b
+          xs = +"".b
+          ys = +"".b
+          px = py = 0
+          pts.each_with_index do |(x, y), i|
+            f = @on_curve[i] ? ON_CURVE : 0
+            f |= 0x40 if i.zero? && @overlap
+            dx = x - px
+            dy = y - py
+            if dx.zero? then f |= X_SAME
+            else xs << [dx].pack("s>")
+            end
+            if dy.zero? then f |= Y_SAME
+            else ys << [dy].pack("s>")
+            end
+            flags << f.chr
+            px = x
+            py = y
+          end
+          out << flags << xs << ys
+        end
+
+        def serialize_composite(pts, bbox)
+          out = [@header_contours, *bbox].pack("s>5")
+          @components.each_with_index do |c, i|
+            flags = c.flags
+            a1 = c.arg1
+            a2 = c.arg2
+            if flags.anybits?(ARGS_ARE_XY)
+              a1, a2 = pts[i]
+              flags |= ARGS_ARE_WORDS
+              out << [flags, c.gid, a1, a2].pack("nns>s>")
+            elsif flags.anybits?(ARGS_ARE_WORDS)
+              out << [flags, c.gid, a1, a2].pack("nnnn")
+            else
+              out << [flags, c.gid, a1, a2].pack("nnCC")
+            end
+            out << c.transform
+          end
+          out << @trailer
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/variation/instancing/gvar_reader.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Variation
+    module Instancing
+      # Reads per-glyph tuple variations from a gvar table.
+      class GvarReader
+        SHARED_POINTS = 0x8000
+        EMBEDDED_PEAK = 0x8000
+        INTERMEDIATE = 0x4000
+        PRIVATE_POINTS = 0x2000
+        INDEX_MASK = 0x0FFF
+
+        # points == nil means "every point of the glyph, phantoms included"
+        Tuple = Struct.new(:peak, :start, :end, :points, :dx, :dy) do
+          def intermediate?
+            !start.nil?
+          end
+        end
+
+        def initialize(data)
+          @data = data
+          _major, _minor, @axis_count, shared_count, shared_offset,
+            @glyph_count, flags, @array_offset = data[0, 20].unpack("nnnnNnnN")
+          @long_offsets = flags.anybits?(1)
+          @shared = Array.new(shared_count) do |i|
+            read_tuple(shared_offset + (i * @axis_count * 2))
+          end
+        end
+
+        # @param gid [Integer]
+        # @param point_count [Integer] glyph points including 4 phantoms
+        # @return [Array<Tuple>]
+        def tuples_for(gid, point_count)
+          return [] if gid >= @glyph_count
+
+          first, last = glyph_range(gid)
+          return [] if last <= first
+
+          parse_glyph(@data[@array_offset + first, last - first], point_count)
+        end
+
+        private
+
+        def read_tuple(pos)
+          @data[pos, @axis_count * 2].unpack("s>*").map { |v| v / 16384.0 }
+        end
+
+        def glyph_range(gid)
+          if @long_offsets
+            @data[20 + (gid * 4), 8].unpack("NN")
+          else
+            @data[20 + (gid * 2), 4].unpack("nn").map { |v| v * 2 }
+          end
+        end
+
+        def parse_glyph(glyph_data, point_count)
+          count_field, data_offset = glyph_data[0, 4].unpack("nn")
+          count = count_field & INDEX_MASK
+          headers = []
+          pos = 4
+          count.times do
+            size, index = glyph_data[pos, 4].unpack("nn")
+            pos += 4
+            peak = start = finish = nil
+            if index.anybits?(EMBEDDED_PEAK)
+              peak = glyph_data[pos, @axis_count * 2].unpack("s>*").map { |v| v / 16384.0 }
+              pos += @axis_count * 2
+            else
+              peak = @shared.fetch(index & INDEX_MASK)
+            end
+            if index.anybits?(INTERMEDIATE)
+              start = glyph_data[pos, @axis_count * 2].unpack("s>*").map { |v| v / 16384.0 }
+              finish = glyph_data[pos + (@axis_count * 2), @axis_count * 2]
+                .unpack("s>*").map { |v| v / 16384.0 }
+              pos += @axis_count * 4
+            end
+            headers << [size, index, peak, start, finish]
+          end
+
+          dpos = data_offset
+          shared_points = nil
+          if count_field.anybits?(SHARED_POINTS)
+            shared_points, dpos = read_points(glyph_data, dpos)
+          end
+          headers.map do |size, index, peak, start, finish|
+            tuple_end = dpos + size
+            points = shared_points
+            points, dpos = read_points(glyph_data, dpos) if index.anybits?(PRIVATE_POINTS)
+            n = points ? points.size : point_count
+            dx, dpos = read_deltas(glyph_data, dpos, n)
+            dy, = read_deltas(glyph_data, dpos, n)
+            dpos = tuple_end
+            Tuple.new(peak, start, finish, points, dx, dy)
+          end
+        end
+
+        def read_points(data, pos)
+          count = data.getbyte(pos)
+          pos += 1
+          if count.anybits?(0x80)
+            count = ((count & 0x7F) << 8) | data.getbyte(pos)
+            pos += 1
+          end
+          return [nil, pos] if count.zero?
+
+          points = []
+          last = 0
+          while points.size < count
+            ctl = data.getbyte(pos)
+            pos += 1
+            run = (ctl & 0x7F) + 1
+            if ctl.anybits?(0x80)
+              vals = data[pos, run * 2].unpack("n*")
+              pos += run * 2
+            else
+              vals = data[pos, run].unpack("C*")
+              pos += run
+            end
+            vals.each { |v| points << (last += v) }
+          end
+          [points, pos]
+        end
+
+        def read_deltas(data, pos, count)
+          out = []
+          while out.size < count
+            ctl = data.getbyte(pos)
+            pos += 1
+            run = (ctl & 0x3F) + 1
+            if ctl.anybits?(0x80)
+              out.concat(Array.new(run, 0))
+            elsif ctl.anybits?(0x40)
+              out.concat(data[pos, run * 2].unpack("s>*"))
+              pos += run * 2
+            else
+              out.concat(data[pos, run].unpack("c*"))
+              pos += run
+            end
+          end
+          [out.first(count), pos]
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/variation/instancing/item_variation_store.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Variation
+    module Instancing
+      # Evaluates HVAR advance-width deltas (ItemVariationStore plus the
+      # optional DeltaSetIndexMap) at a normalized location.
+      class ItemVariationStore
+        # @param hvar [String] raw HVAR table
+        def initialize(hvar)
+          @hvar = hvar
+          store_offset, @advance_map_offset = hvar[4, 8].unpack("NN")
+          @store = hvar.byteslice(store_offset..)
+          region_list_offset, data_count = @store[2, 6].unpack("Nn")
+          @regions = parse_regions(region_list_offset)
+          @data_offsets = @store[8, data_count * 4].unpack("N*")
+        end
+
+        # @return [Float] advance-width delta for +gid+
+        def advance_delta(gid, coords)
+          outer, inner = delta_index(gid)
+          delta(outer, inner, coords)
+        end
+
+        private
+
+        def parse_regions(offset)
+          axis_count, region_count = @store[offset, 4].unpack("nn")
+          Array.new(region_count) do |r|
+            pos = offset + 4 + (r * axis_count * 6)
+            @store[pos, axis_count * 6].unpack("s>*").map { |v| v / 16384.0 }
+              .each_slice(3).to_a
+          end
+        end
+
+        def delta_index(gid)
+          return [0, gid] if @advance_map_offset.zero?
+
+          format, entry_format = @hvar[@advance_map_offset, 2].unpack("CC")
+          if format.zero?
+            count = @hvar[@advance_map_offset + 2, 2].unpack1("n")
+            pos = @advance_map_offset + 4
+          else
+            count = @hvar[@advance_map_offset + 2, 4].unpack1("N")
+            pos = @advance_map_offset + 6
+          end
+          inner_bits = (entry_format & 0x0F) + 1
+          size = ((entry_format & 0x30) >> 4) + 1
+          entry_gid = [gid, count - 1].min
+          entry = @hvar[pos + (entry_gid * size), size].bytes.inject(0) { |a, b| (a << 8) | b }
+          [entry >> inner_bits, entry & ((1 << inner_bits) - 1)]
+        end
+
+        def delta(outer, inner, coords)
+          offset = @data_offsets[outer]
+          return 0.0 unless offset
+
+          item_count, word_field, region_count = @store[offset, 6].unpack("nnn")
+          return 0.0 if inner >= item_count
+
+          long = word_field.anybits?(0x8000)
+          word_count = word_field & 0x7FFF
+          indexes = @store[offset + 6, region_count * 2].unpack("n*")
+          big = long ? 4 : 2
+          small = long ? 2 : 1
+          row_size = (word_count * big) + ((region_count - word_count) * small)
+          pos = offset + 6 + (region_count * 2) + (inner * row_size)
+          words = @store[pos, word_count * big].unpack(long ? "l>*" : "s>*")
+          rest = @store[pos + (word_count * big), (region_count - word_count) * small]
+            .unpack(long ? "s>*" : "c*")
+          (words + rest).each_with_index.sum do |d, i|
+            d * region_scalar(@regions[indexes[i]], coords)
+          end
+        end
+
+        def region_scalar(region, coords)
+          scalar = 1.0
+          region.each_with_index do |(lower, peak, upper), i|
+            v = coords[i]
+            next if peak.zero? || lower > peak || peak > upper
+            next if lower.negative? && upper.positive?
+            next if v == peak
+            return 0.0 if v <= lower || upper <= v
+
+            scalar *= v < peak ? (v - lower) / (peak - lower) : (upper - v) / (upper - peak)
+          end
+          scalar
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/variation/instancing/name_rewriter.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Variation
+    module Instancing
+      # Rewrites a name table so it describes one instance of a family.
+      class NameRewriter
+        Record = Struct.new(:platform, :encoding, :language, :name_id, :text)
+
+        # @param name_data [String] raw name table
+        def initialize(name_data)
+          @records = parse(name_data)
+        end
+
+        def lookup(name_id)
+          same = @records.select { |r| r.name_id == name_id }
+          rec = same.find { |r| r.platform == 3 && r.language == 0x409 } ||
+            same.find { |r| r.platform == 3 } || same.first
+          rec&.text
+        end
+
+        # Names the instance +label+ (e.g. "Light") of the family.
+        def rename(label)
+          family = lookup(16) || lookup(1) || "Font"
+          legacy = ["Regular", "Bold", "Italic", "Bold Italic"].include?(label)
+          full = "#{family} #{label}".strip
+          ps = "#{family}-#{label}".delete(" ")
+          set(1, legacy ? family : full)
+          set(2, legacy ? label : "Regular")
+          set(3, "#{lookup(5) || ''};#{ps}".delete_prefix(";"))
+          set(4, full)
+          set(6, ps)
+          set(16, family)
+          set(17, label)
+          @records.reject! { |r| r.name_id == 25 }
+          self
+        end
+
+        def to_binary
+          recs = @records.sort_by { |r| [r.platform, r.encoding, r.language, r.name_id] }
+          strings = +"".b
+          entries = recs.map do |r|
+            bin = encode(r)
+            off = strings.bytesize
+            strings << bin
+            [r.platform, r.encoding, r.language, r.name_id, bin.bytesize, off]
+          end
+          header = [0, recs.size, 6 + (recs.size * 12)].pack("nnn")
+          header + entries.map { |e| e.pack("n6") }.join + strings
+        end
+
+        private
+
+        def set(name_id, text)
+          same = @records.select { |r| r.name_id == name_id }
+          same.each { |r| r.text = text }
+          return if same.any? { |r| r.platform == 3 }
+
+          @records << Record.new(3, 1, 0x409, name_id, text)
+        end
+
+        def parse(data)
+          count, str_off = data[2, 4].unpack("nn")
+          recs = Array.new(count) do |i|
+            plat, enc, lang, nid, len, off = data[6 + (i * 12), 12].unpack("n6")
+            raw = data[str_off + off, len]
+            Record.new(plat, enc, lang, nid, decode(plat, raw))
+          end
+          recs.reject { |r| r.language >= 0x8000 }
+        end
+
+        def decode(platform, raw)
+          if [0, 3].include?(platform)
+            raw.dup.force_encoding("UTF-16BE").encode("UTF-8", invalid: :replace)
+          else
+            raw.dup.force_encoding("ISO-8859-1").encode("UTF-8")
+          end
+        end
+
+        def encode(rec)
+          if [0, 3].include?(rec.platform)
+            rec.text.encode("UTF-16BE").b
+          else
+            rec.text.encode("ISO-8859-1", invalid: :replace, undef: :replace).b
+          end
+        end
+      end
+    end
+  end
+end