bandoola 0.1.0

data/lib/bandoola/true_type_subset.rb

@@ -0,0 +1,302 @@
+module Bandoola
+  # Tree-shakes a TrueType font down to a set of glyphs. Given the glyph ids a
+  # document actually used (collected by EmbeddedFont), it rebuilds the font
+  # with only those glyphs — the glyf table is almost the whole file (>95% for
+  # a CJK font) — and drops the tables a CIDFontType2/Identity-H PDF font never
+  # reads (cmap, post, OS/2, GPOS, …).
+  #
+  # Two modes:
+  #
+  # * .sparse keeps the original glyph numbering, emptying the unused glyphs.
+  #   loca/hmtx stay full size (one entry per original glyph), but it needs no
+  #   remapping — the PDF's /W, content stream and ToUnicode are untouched.
+  #
+  # * .compact renumbers the kept glyphs (and their composite components) into
+  #   a dense range, so loca, hmtx and maxp shrink to the glyphs actually used.
+  #   This is the smaller, default mode; it requires the content stream to use
+  #   the new ids (EmbeddedFont assigns them) and composite component indices
+  #   to be rewritten.
+  class TrueTypeSubset
+    # Copied verbatim when present (the rest is rebuilt or dropped).
+    HINTING = ["cvt ", "fpgm", "prep", "gasp"].freeze
+
+    # Composite-glyph flags (a glyph can be built from other glyphs).
+    ARGS_ARE_WORDS = 0x0001
+    HAVE_SCALE = 0x0008
+    MORE_COMPONENTS = 0x0020
+    HAVE_XY_SCALE = 0x0040
+    HAVE_2X2 = 0x0080
+
+    def self.sparse(data, glyphs)
+      new(data).sparse(glyphs)
+    end
+
+    def self.compact(data, order)
+      new(data).compact(order)
+    end
+
+    def initialize(data)
+      @data = data
+      @directory = read_directory
+      raise Error, "not a glyf-based TrueType font" unless @directory.key?("glyf")
+
+      @num_glyphs = u16(table_start("maxp") + 4)
+      @long_loca = u16(table_start("head") + 50) == 1
+      @num_hmetrics = u16(table_start("hhea") + 34)
+    end
+
+    # Phase 1: keep glyph ids, empty the unused ones.
+    def sparse(glyphs)
+      kept = closure(glyphs)
+      glyf = String.new(encoding: Encoding::ASCII_8BIT)
+      offsets = [0]
+      (0...@num_glyphs).each do |glyph|
+        glyf << aligned(glyph_data(glyph)) if kept[glyph]
+        offsets << glyf.bytesize
+      end
+      tables = base_tables(glyf, offsets.pack("N*"))
+      ["hhea", "maxp", "hmtx", *HINTING].each { |tag| tables[tag] = table_bytes(tag) if @directory.key?(tag) }
+      assemble(tables)
+    end
+
+    # Phase 2: renumber the kept glyphs into a dense range. +order+ maps new
+    # glyph id (array index) to original glyph id; it begins with the ids the
+    # content stream already uses and is extended here with composite parts.
+    def compact(order)
+      list, index = extend_with_components(order)
+      glyf, loca = build_compact_glyf(list, index)
+      tables = base_tables(glyf, loca)
+      tables["hhea"] = resized("hhea", 34, list.size)
+      tables["maxp"] = resized("maxp", 4, list.size)
+      tables["hmtx"] = compact_hmtx(list)
+      HINTING.each { |tag| tables[tag] = table_bytes(tag) if @directory.key?(tag) }
+      assemble(tables)
+    end
+
+    private
+
+    def base_tables(glyf, loca)
+      { "glyf" => glyf, "loca" => loca, "head" => patched_head }
+    end
+
+    def read_directory
+      directory = {}
+      u16(4).times do |i|
+        entry = 12 + (i * 16)
+        directory[@data[entry, 4]] = [u32(entry + 8), u32(entry + 12)]
+      end
+      directory
+    end
+
+    def table_start(tag)
+      @directory.fetch(tag)[0]
+    end
+
+    def table_bytes(tag)
+      start, length = @directory.fetch(tag)
+      @data[start, length].b
+    end
+
+    # --- glyph closure / components ------------------------------------------
+
+    # Grow the requested glyph set to include glyph 0 (.notdef) and, for any
+    # composite glyph, the component glyphs it is assembled from.
+    def closure(glyphs)
+      kept = {}
+      pending = glyphs.to_a + [0]
+      until pending.empty?
+        glyph = pending.pop
+        next if glyph >= @num_glyphs || kept[glyph]
+
+        kept[glyph] = true
+        pending.concat(components(glyph))
+      end
+      kept
+    end
+
+    # Append composite components to the new-id ordering, so the final list
+    # covers every glyph the subset needs. Returns [list, original => new_id].
+    def extend_with_components(order)
+      list = order.dup
+      index = {}
+      list.each_with_index { |glyph, new_id| index[glyph] = new_id }
+      cursor = 0
+      while cursor < list.size
+        components(list[cursor]).each do |component|
+          next if index.key?(component)
+
+          index[component] = list.size
+          list << component
+        end
+        cursor += 1
+      end
+      [list, index]
+    end
+
+    def components(glyph)
+      return [] unless composite?(glyph)
+
+      read_components((table_start("glyf") + glyph_location(glyph)) + 10) # skip header + bbox
+    end
+
+    def composite?(glyph)
+      start = glyph_location(glyph)
+      return false if glyph_location(glyph + 1) <= start
+
+      i16(table_start("glyf") + start).negative? # numberOfContours < 0
+    end
+
+    def read_components(position)
+      found = []
+      loop do
+        flags = u16(position)
+        found << u16(position + 2)
+        position += 4 + (flags.nobits?(ARGS_ARE_WORDS) ? 2 : 4) + transform_size(flags)
+        break if flags.nobits?(MORE_COMPONENTS)
+      end
+      found
+    end
+
+    def transform_size(flags)
+      return 2 unless flags.nobits?(HAVE_SCALE)
+      return 4 unless flags.nobits?(HAVE_XY_SCALE)
+      return 8 unless flags.nobits?(HAVE_2X2)
+
+      0
+    end
+
+    # --- glyf / loca rebuilds ------------------------------------------------
+
+    def build_compact_glyf(list, index)
+      glyf = String.new(encoding: Encoding::ASCII_8BIT)
+      offsets = [0]
+      list.each do |original|
+        data = glyph_data(original)
+        data = remap_components(data, index) if composite?(original)
+        glyf << aligned(data)
+        offsets << glyf.bytesize
+      end
+      [glyf, offsets.pack("N*")]
+    end
+
+    # Rewrite each component's glyph id from the original to the new numbering.
+    def remap_components(data, index)
+      bytes = data.dup
+      position = 10
+      loop do
+        flags = (bytes.getbyte(position) << 8) | bytes.getbyte(position + 1)
+        original = (bytes.getbyte(position + 2) << 8) | bytes.getbyte(position + 3)
+        bytes[position + 2, 2] = [index.fetch(original)].pack("n")
+        position += 4 + (flags.nobits?(ARGS_ARE_WORDS) ? 2 : 4) + transform_size(flags)
+        break if flags.nobits?(MORE_COMPONENTS)
+      end
+      bytes
+    end
+
+    def glyph_data(glyph)
+      start = glyph_location(glyph)
+      stop = glyph_location(glyph + 1)
+      stop > start ? @data[table_start("glyf") + start, stop - start].b : "".b
+    end
+
+    def glyph_location(index)
+      if @long_loca
+        u32(table_start("loca") + (index * 4))
+      else
+        u16(table_start("loca") + (index * 2)) * 2
+      end
+    end
+
+    # --- metrics / head ------------------------------------------------------
+
+    def compact_hmtx(list)
+      hmtx = String.new(encoding: Encoding::ASCII_8BIT)
+      list.each { |glyph| hmtx << [advance(glyph), left_bearing(glyph) & 0xFFFF].pack("nn") }
+      hmtx
+    end
+
+    def advance(glyph)
+      index = glyph < @num_hmetrics ? glyph : @num_hmetrics - 1
+      u16(table_start("hmtx") + (index * 4))
+    end
+
+    def left_bearing(glyph)
+      if glyph < @num_hmetrics
+        i16(table_start("hmtx") + (glyph * 4) + 2)
+      else
+        i16(table_start("hmtx") + (@num_hmetrics * 4) + ((glyph - @num_hmetrics) * 2))
+      end
+    end
+
+    # A copy of +tag+ with its glyph-count field (at +offset+) set to +count+.
+    def resized(tag, offset, count)
+      bytes = table_bytes(tag)
+      bytes[offset, 2] = [count].pack("n")
+      bytes
+    end
+
+    # head, with checkSumAdjustment zeroed (set after assembly) and loca format
+    # switched to long, matching the rebuilt loca.
+    def patched_head
+      head = table_bytes("head")
+      head[8, 4] = "\x00\x00\x00\x00".b
+      head[50, 2] = "\x00\x01".b
+      head
+    end
+
+    # --- sfnt assembly -------------------------------------------------------
+
+    def assemble(tables)
+      ordered = tables.sort.to_h
+      directory = String.new(encoding: Encoding::ASCII_8BIT)
+      blob = String.new(encoding: Encoding::ASCII_8BIT)
+      position = 12 + (ordered.size * 16)
+      head_position = nil
+
+      ordered.each do |tag, body|
+        head_position = position if tag == "head"
+        directory << tag.b << [checksum(body), position, body.bytesize].pack("NNN")
+        chunk = aligned(body)
+        blob << chunk
+        position += chunk.bytesize
+      end
+
+      font = +@data[0, 4].b << sfnt_header(ordered.size) << directory << blob
+      adjust_head_checksum(font, head_position)
+      font
+    end
+
+    def sfnt_header(count)
+      exponent = 0
+      exponent += 1 while (1 << (exponent + 1)) <= count
+      max_power = (1 << exponent) * 16
+      [count, max_power, exponent, (count * 16) - max_power].pack("nnnn")
+    end
+
+    def adjust_head_checksum(font, head_position)
+      adjustment = (0xB1B0_AFBA - checksum(font)) & 0xFFFF_FFFF
+      font[head_position + 8, 4] = [adjustment].pack("N")
+    end
+
+    def aligned(bytes)
+      bytes.b + ("\x00".b * ((-bytes.bytesize) % 4))
+    end
+
+    def checksum(bytes)
+      aligned(bytes).unpack("N*").sum & 0xFFFF_FFFF
+    end
+
+    def u16(offset)
+      (@data.getbyte(offset) << 8) | @data.getbyte(offset + 1)
+    end
+
+    def i16(offset)
+      value = u16(offset)
+      value >= 0x8000 ? value - 0x10000 : value
+    end
+
+    def u32(offset)
+      (u16(offset) << 16) | u16(offset + 2)
+    end
+  end
+end

data/lib/bandoola/version.rb

@@ -0,0 +1,3 @@
+module Bandoola
+  VERSION = "0.1.0".freeze
+end