ttfunk 1.5.1 → 1.6.0

data/lib/ttfunk/table/glyf/compound.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../reader'
 
 module TTFunk
@@ -13,18 +15,22 @@ module TTFunk
         WE_HAVE_A_TWO_BY_TWO     = 0x0080
         WE_HAVE_INSTRUCTIONS     = 0x0100
 
-        attr_reader :raw
+        attr_reader :id, :raw
+        attr_reader :number_of_contours
         attr_reader :x_min, :y_min, :x_max, :y_max
         attr_reader :glyph_ids
 
         Component = Struct.new(:flags, :glyph_index, :arg1, :arg2, :transform)
 
-        def initialize(raw, x_min, y_min, x_max, y_max)
+        def initialize(id, raw)
+          @id = id
           @raw = raw
-          @x_min = x_min
-          @y_min = y_min
-          @x_max = x_max
-          @y_max = y_max
+          io = StringIO.new(raw)
+
+          @number_of_contours, @x_min, @y_min, @x_max, @y_max =
+            io.read(10).unpack('n*').map do |i|
+              BinUtils.twos_comp_to_int(i, bit_width: 16)
+            end
 
           # Because TTFunk only cares about glyphs insofar as they (1) provide
           # a bounding box for each glyph, and (2) can be rewritten into a
@@ -45,6 +51,7 @@ module TTFunk
             @glyph_id_offsets << offset + 2
 
             break unless flags & MORE_COMPONENTS != 0
+
             offset += 4
 
             offset +=
@@ -69,7 +76,7 @@ module TTFunk
         end
 
         def recode(mapping)
-          result = @raw.dup
+          result = raw.dup
           new_ids = glyph_ids.map { |id| mapping[id] }
 
           new_ids.zip(@glyph_id_offsets).each do |new_id, offset|

data/lib/ttfunk/table/glyf/path_based.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Glyf
+      class PathBased
+        attr_reader :path, :horizontal_metrics
+        attr_reader :x_min, :y_min, :x_max, :y_max
+        attr_reader :left_side_bearing, :right_side_bearing
+
+        def initialize(path, horizontal_metrics)
+          @path = path
+          @horizontal_metrics = horizontal_metrics
+
+          @x_min = 0
+          @y_min = 0
+          @x_max = horizontal_metrics.advance_width
+          @y_max = 0
+
+          path.commands.each do |command|
+            cmd, x, y = command
+            next if cmd == :close
+
+            @x_min = x if x < @x_min
+            @x_max = x if x > @x_max
+            @y_min = y if y < @y_min
+            @y_max = y if y > @y_max
+          end
+
+          @left_side_bearing = horizontal_metrics.left_side_bearing
+          @right_side_bearing =
+            horizontal_metrics.advance_width -
+            @left_side_bearing -
+            (@x_max - @x_min)
+        end
+
+        def number_of_contours
+          path.number_of_contours
+        end
+
+        def compound?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/ttfunk/table/glyf/simple.rb

@@ -1,28 +1,30 @@
+# frozen_string_literal: true
+
 require_relative '../../reader'
 
 module TTFunk
   class Table
     class Glyf
       class Simple
-        attr_reader :raw
+        attr_reader :id, :raw
         attr_reader :number_of_contours
         attr_reader :x_min, :y_min, :x_max, :y_max
+        attr_reader :end_points_of_contours
+        attr_reader :instruction_length, :instructions
 
-        def initialize(raw, number_of_contours, x_min, y_min, x_max, y_max)
+        def initialize(id, raw)
+          @id = id
           @raw = raw
-          @number_of_contours = number_of_contours
-          @x_min = x_min
-          @y_min = y_min
-          @x_max = x_max
-          @y_max = y_max
-
-          # Because TTFunk is, at this time, a library for simply pulling
-          # metrics out of font files, or for writing font subsets, we don't
-          # really care what the contours are for simple glyphs. We just
-          # care that we've got an entire glyph's definition. Also, a
-          # bounding box could be nice to know. Since we've got all that
-          # at this point, we don't need to worry about parsing the full
-          # contents of the glyph.
+          io = StringIO.new(raw)
+
+          @number_of_contours, @x_min, @y_min, @x_max, @y_max =
+            io.read(10).unpack('n*').map do |i|
+              BinUtils.twos_comp_to_int(i, bit_width: 16)
+            end
+
+          @end_points_of_contours = io.read(number_of_contours * 2).unpack('n*')
+          @instruction_length = io.read(2).unpack1('n')
+          @instructions = io.read(instruction_length).unpack('C*')
         end
 
         def compound?
@@ -32,6 +34,10 @@ module TTFunk
         def recode(_mapping)
           raw
         end
+
+        def end_point_of_last_contour
+          end_points_of_contours.last + 1
+        end
       end
     end
   end

data/lib/ttfunk/table/head.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../table'
 
 module TTFunk
@@ -21,11 +23,47 @@ module TTFunk
       attr_reader :index_to_loc_format
       attr_reader :glyph_data_format
 
-      def self.encode(head, loca)
-        table = head.raw
-        table[8, 4] = "\0\0\0\0" # set checksum adjustment to 0 initially
-        table[-4, 2] = [loca[:type]].pack('n') # set index_to_loc_format
-        table
+      class << self
+        # mapping is new -> old glyph ids
+        def encode(head, loca, mapping)
+          EncodedString.new do |table|
+            table <<
+              [head.version, head.font_revision].pack('N2') <<
+              Placeholder.new(:checksum, length: 4) <<
+              [
+                head.magic_number,
+                head.flags, head.units_per_em,
+                head.created, head.modified,
+                *min_max_values_for(head, mapping),
+                head.mac_style, head.lowest_rec_ppem, head.font_direction_hint,
+                loca[:type] || 0, head.glyph_data_format
+              ].pack('Nn2q2n*')
+          end
+        end
+
+        private
+
+        def min_max_values_for(head, mapping)
+          x_min = Min.new
+          x_max = Max.new
+          y_min = Min.new
+          y_max = Max.new
+
+          mapping.each do |_, old_glyph_id|
+            glyph = head.file.find_glyph(old_glyph_id)
+            next unless glyph
+
+            x_min << glyph.x_min
+            x_max << glyph.x_max
+            y_min << glyph.y_min
+            y_max << glyph.y_max
+          end
+
+          [
+            x_min.value_or(0), y_min.value_or(0),
+            x_max.value_or(0), y_max.value_or(0)
+          ]
+        end
       end
 
       private

data/lib/ttfunk/table/hhea.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../table'
 
 module TTFunk
@@ -13,13 +15,54 @@ module TTFunk
       attr_reader :x_max_extent
       attr_reader :carot_slope_rise
       attr_reader :carot_slope_run
+      attr_reader :caret_offset
       attr_reader :metric_data_format
       attr_reader :number_of_metrics
 
-      def self.encode(hhea, hmtx)
-        raw = hhea.raw
-        raw[-2, 2] = [hmtx[:number_of_metrics]].pack('n')
-        raw
+      class << self
+        def encode(hhea, hmtx, original, mapping)
+          ''.b.tap do |table|
+            table << [hhea.version].pack('N')
+            table << [
+              hhea.ascent, hhea.descent, hhea.line_gap,
+              *min_max_values_for(original, mapping),
+              hhea.carot_slope_rise, hhea.carot_slope_run, hhea.caret_offset,
+              0, 0, 0, 0, hhea.metric_data_format, hmtx[:number_of_metrics]
+            ].pack('n*')
+          end
+        end
+
+        private
+
+        def min_max_values_for(original, mapping)
+          min_lsb = Min.new
+          min_rsb = Min.new
+          max_aw = Max.new
+          max_extent = Max.new
+
+          mapping.each do |_, old_glyph_id|
+            horiz_metrics = original.horizontal_metrics.for(old_glyph_id)
+            next unless horiz_metrics
+
+            min_lsb << horiz_metrics.left_side_bearing
+            max_aw << horiz_metrics.advance_width
+
+            glyph = original.find_glyph(old_glyph_id)
+            next unless glyph
+
+            x_delta = glyph.x_max - glyph.x_min
+
+            min_rsb << horiz_metrics.advance_width -
+              horiz_metrics.left_side_bearing - x_delta
+
+            max_extent << horiz_metrics.left_side_bearing + x_delta
+          end
+
+          [
+            max_aw.value_or(0), min_lsb.value_or(0),
+            min_rsb.value_or(0), max_extent.value_or(0)
+          ]
+        end
       end
 
       private

data/lib/ttfunk/table/hmtx.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../table'
 
 module TTFunk
@@ -23,14 +25,19 @@ module TTFunk
 
       def for(glyph_id)
         @metrics[glyph_id] ||
-          HorizontalMetric.new(
-            @metrics.last.advance_width,
-            @left_side_bearings[glyph_id - @metrics.length]
-          )
+          metrics_cache[glyph_id] ||=
+            HorizontalMetric.new(
+              @metrics.last.advance_width,
+              @left_side_bearings[glyph_id - @metrics.length]
+            )
       end
 
       private
 
+      def metrics_cache
+        @metrics_cache ||= {}
+      end
+
       def parse!
         @metrics = []
 

data/lib/ttfunk/table/kern.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../table'
 
 module TTFunk
@@ -8,6 +10,7 @@ module TTFunk
 
       def self.encode(kerning, mapping)
         return nil unless kerning.exists? && kerning.tables.any?
+
         tables = kerning.tables.map { |table| table.recode(mapping) }.compact
         return nil if tables.empty?
 

data/lib/ttfunk/table/kern/format0.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../reader'
 
 module TTFunk
@@ -18,6 +20,7 @@ module TTFunk
           num_pairs.times do |i|
             # sanity check, in case there's a bad length somewhere
             break if i * 3 + 2 > pairs.length
+
             left = pairs[i * 3]
             right = pairs[i * 3 + 1]
             value = to_signed(pairs[i * 3 + 2])

data/lib/ttfunk/table/loca.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../table'
 
 module TTFunk

data/lib/ttfunk/table/maxp.rb

@@ -1,8 +1,13 @@
+# frozen_string_literal: true
+
 require_relative '../table'
 
 module TTFunk
   class Table
     class Maxp < Table
+      DEFAULT_MAX_COMPONENT_DEPTH = 1
+      MAX_V1_TABLE_LENGTH = 34
+
       attr_reader :version
       attr_reader :num_glyphs
       attr_reader :max_points
@@ -19,21 +24,150 @@ module TTFunk
       attr_reader :max_component_elements
       attr_reader :max_component_depth
 
-      def self.encode(maxp, mapping)
-        num_glyphs = mapping.length
-        raw = maxp.raw
-        raw[4, 2] = [num_glyphs].pack('n')
-        raw
+      class << self
+        def encode(maxp, new2old_glyph)
+          ''.b.tap do |table|
+            num_glyphs = new2old_glyph.length
+            table << [maxp.version, num_glyphs].pack('Nn')
+
+            if maxp.version == 0x10000
+              stats = stats_for(
+                maxp, glyphs_from_ids(maxp, new2old_glyph.values)
+              )
+
+              table << [
+                stats[:max_points],
+                stats[:max_contours],
+                stats[:max_component_points],
+                stats[:max_component_contours],
+                # these all come from the fpgm and cvt tables, which
+                # we don't support at the moment
+                maxp.max_zones,
+                maxp.max_twilight_points,
+                maxp.max_storage,
+                maxp.max_function_defs,
+                maxp.max_instruction_defs,
+                maxp.max_stack_elements,
+                stats[:max_size_of_instructions],
+                stats[:max_component_elements],
+                stats[:max_component_depth]
+              ].pack('n*')
+            end
+          end
+        end
+
+        private
+
+        def glyphs_from_ids(maxp, glyph_ids)
+          glyph_ids.each_with_object([]) do |glyph_id, ret|
+            if (glyph = maxp.file.glyph_outlines.for(glyph_id))
+              ret << glyph
+            end
+          end
+        end
+
+        def stats_for(maxp, glyphs)
+          stats_for_simple(maxp, glyphs)
+            .merge(stats_for_compound(maxp, glyphs))
+            .each_with_object({}) do |(name, agg), ret|
+              ret[name] = agg.value_or(0)
+            end
+        end
+
+        def stats_for_simple(_maxp, glyphs)
+          max_component_elements = Max.new
+          max_points = Max.new
+          max_contours = Max.new
+          max_size_of_instructions = Max.new
+
+          glyphs.each do |glyph|
+            if glyph.compound?
+              max_component_elements << glyph.glyph_ids.size
+            else
+              max_points << glyph.end_point_of_last_contour
+              max_contours << glyph.number_of_contours
+              max_size_of_instructions << glyph.instruction_length
+            end
+          end
+
+          {
+            max_component_elements: max_component_elements,
+            max_points: max_points,
+            max_contours: max_contours,
+            max_size_of_instructions: max_size_of_instructions
+          }
+        end
+
+        def stats_for_compound(maxp, glyphs)
+          max_component_points = Max.new
+          max_component_depth = Max.new
+          max_component_contours = Max.new
+
+          glyphs.each do |glyph|
+            next unless glyph.compound?
+
+            stats = totals_for_compound(maxp, [glyph], 0)
+            max_component_points << stats[:total_points]
+            max_component_depth << stats[:max_depth]
+            max_component_contours << stats[:total_contours]
+          end
+
+          {
+            max_component_points: max_component_points,
+            max_component_depth: max_component_depth,
+            max_component_contours: max_component_contours
+          }
+        end
+
+        def totals_for_compound(maxp, glyphs, depth)
+          total_points = Sum.new
+          total_contours = Sum.new
+          max_depth = Max.new(depth)
+
+          glyphs.each do |glyph|
+            if glyph.compound?
+              stats = totals_for_compound(
+                maxp, glyphs_from_ids(maxp, glyph.glyph_ids), depth + 1
+              )
+
+              total_points << stats[:total_points]
+              total_contours << stats[:total_contours]
+              max_depth << stats[:max_depth]
+            else
+              stats = stats_for_simple(maxp, [glyph])
+              total_points << stats[:max_points]
+              total_contours << stats[:max_contours]
+            end
+          end
+
+          {
+            total_points: total_points,
+            total_contours: total_contours,
+            max_depth: max_depth
+          }
+        end
       end
 
       private
 
       def parse!
-        @version, @num_glyphs, @max_points, @max_contours,
-          @max_component_points, @max_component_contours, @max_zones,
-          @max_twilight_points, @max_storage, @max_function_defs,
-          @max_instruction_defs, @max_stack_elements, @max_size_of_instructions,
-          @max_component_elements, @max_component_depth = read(length, 'Nn*')
+        @version, @num_glyphs = read(6, 'Nn')
+
+        if @version == 0x10000
+          @max_points, @max_contours, @max_component_points,
+            @max_component_contours, @max_zones, @max_twilight_points,
+            @max_storage, @max_function_defs, @max_instruction_defs,
+            @max_stack_elements, @max_size_of_instructions,
+            @max_component_elements = read(26, 'Nn*')
+
+          # a number of fonts omit these last two bytes for some reason,
+          # so we have to supply a default here to prevent nils
+          @max_component_depth = if length == MAX_V1_TABLE_LENGTH
+                                   read(2, 'n').first
+                                 else
+                                   DEFAULT_MAX_COMPONENT_DEPTH
+                                 end
+        end
       end
     end
   end