ttfunk 1.0.1

data/lib/ttfunk/subset/unicode_8bit.rb

@@ -0,0 +1,63 @@
+require 'set'
+require 'ttfunk/subset/base'
+
+module TTFunk
+  module Subset
+    class Unicode8Bit < Base
+      def initialize(original)
+        super
+        @subset = { 0x20 => 0x20 }
+        @unicodes = { 0x20 => 0x20 }
+        @next = 0x21 # apparently, PDF's don't like to use chars between 0-31
+      end
+
+      def unicode?
+        true
+      end
+
+      def to_unicode_map
+        @subset.dup
+      end
+
+      def use(character)
+        if !@unicodes.key?(character)
+          @subset[@next] = character
+          @unicodes[character] = @next
+          @next += 1
+        end
+      end
+
+      def covers?(character)
+        @unicodes.key?(character) || @next < 256
+      end
+
+      def includes?(character)
+        @unicodes.key?(character)
+      end
+
+      def from_unicode(character)
+        @unicodes[character]
+      end
+
+      protected
+
+        def new_cmap_table(options)
+          mapping = @subset.inject({}) do |map, (code,unicode)|
+            map[code] = unicode_cmap[unicode]
+            map
+          end
+
+          # since we're mapping a subset of the unicode glyphs into an
+          # arbitrary 256-character space, the actual encoding we're
+          # using is irrelevant. We choose MacRoman because it's a 256-character
+          # encoding that happens to be well-supported in both TTF and
+          # PDF formats.
+          TTFunk::Table::Cmap.encode(mapping, :mac_roman)
+        end
+
+        def original_glyph_ids
+          ([0] + @unicodes.keys.map { |unicode| unicode_cmap[unicode] }).uniq.sort
+        end
+    end
+  end
+end

data/lib/ttfunk/subset/windows_1252.rb

@@ -0,0 +1,55 @@
+require 'set'
+require 'ttfunk/subset/base'
+require 'ttfunk/encoding/windows_1252'
+
+module TTFunk
+  module Subset
+    class Windows1252 < Base
+      def initialize(original)
+        super
+        @subset = Array.new(256)
+      end
+
+      def to_unicode_map
+        Encoding::Windows1252::TO_UNICODE
+      end
+
+      def use(character)
+        @subset[Encoding::Windows1252::FROM_UNICODE[character]] = character
+      end
+
+      def covers?(character)
+        Encoding::Windows1252.covers?(character)
+      end
+
+      def includes?(character)
+        code = Encoding::Windows1252::FROM_UNICODE[character]
+        code && @subset[code]
+      end
+
+      def from_unicode(character)
+        Encoding::Windows1252::FROM_UNICODE[character]
+      end
+
+      protected
+
+        def new_cmap_table(options)
+          mapping = {}
+          @subset.each_with_index do |unicode, cp1252|
+            mapping[cp1252] = unicode_cmap[unicode] if cp1252
+          end
+
+          # yes, I really mean "mac roman". TTF has no cp1252 encoding, and the
+          # alternative would be to encode it using a format 4 unicode table, which
+          # is overkill. for our purposes, mac-roman suffices. (If we were building
+          # a _real_ font, instead of a PDF-embeddable subset, things would probably
+          # be different.)
+          TTFunk::Table::Cmap.encode(mapping, :mac_roman)
+        end
+
+        def original_glyph_ids
+          ([0] + @subset.map { |unicode| unicode && unicode_cmap[unicode] }).compact.uniq.sort
+        end
+    end
+  end
+end

data/lib/ttfunk/subset.rb

@@ -0,0 +1,18 @@
+require 'ttfunk/subset/unicode'
+require 'ttfunk/subset/unicode_8bit'
+require 'ttfunk/subset/mac_roman'
+require 'ttfunk/subset/windows_1252'
+
+module TTFunk
+  module Subset
+    def self.for(original, encoding)
+      case encoding.to_sym
+        when :unicode      then Unicode.new(original)
+        when :unicode_8bit then Unicode8Bit.new(original)
+        when :mac_roman    then MacRoman.new(original)
+        when :windows_1252 then Windows1252.new(original)
+        else raise NotImplementedError, "encoding #{encoding} is not supported"
+      end
+    end
+  end
+end

data/lib/ttfunk/subset_collection.rb

@@ -0,0 +1,72 @@
+require 'ttfunk/subset'
+
+module TTFunk
+  class SubsetCollection
+    def initialize(original)
+      @original = original
+      @subsets = [Subset.for(@original, :mac_roman)]
+    end
+
+    def [](subset)
+      @subsets[subset]
+    end
+
+    # +characters+ should be an array of UTF-16 characters
+    def use(characters)
+      characters.each do |char|
+        covered = false
+        @subsets.each_with_index do |subset, i|
+          if subset.covers?(char)
+            subset.use(char)
+            covered = true
+            break
+          end
+        end
+
+        if !covered
+          @subsets << Subset.for(@original, :unicode_8bit)
+          @subsets.last.use(char)
+        end
+      end
+    end
+
+    # +characters+ should be an array of UTF-16 characters. Returns
+    # an array of subset chunks, where each chunk is another array of
+    # two elements. The first element is the subset number, and the
+    # second element is the string of characters to render with that
+    # font subset. The strings will be encoded for their subset font,
+    # and so may not look (in the raw) like what was passed in, but
+    # they will render correctly with the indicated subset font.
+    def encode(characters)
+      return [] if characters.empty?
+
+      # TODO: probably would be more optimal to nix the #use method,
+      # and merge it into this one, so it can be done in a single
+      # pass instead of two passes.
+      use(characters)
+
+      parts = []
+      current_subset = 0
+      current_char = 0
+      char = characters[current_char]
+
+      loop do
+        while @subsets[current_subset].includes?(char)
+          char = @subsets[current_subset].from_unicode(char)
+
+          if parts.empty? || parts.last[0] != current_subset
+            parts << [current_subset, char.chr]
+          else
+            parts.last[1] << char
+          end
+
+          current_char += 1
+          return parts if current_char >= characters.length
+          char = characters[current_char]
+        end
+
+        current_subset = (current_subset + 1) % @subsets.length
+      end
+    end
+  end
+end

data/lib/ttfunk/table/cmap/format00.rb

@@ -0,0 +1,54 @@
+require 'ttfunk/encoding/mac_roman'
+require 'ttfunk/encoding/windows_1252'
+
+module TTFunk
+  class Table
+    class Cmap
+
+      module Format00
+        attr_reader :language
+        attr_reader :code_map
+
+        # Expects a hash mapping character codes to glyph ids (where the
+        # glyph ids are from the original font). Returns a hash including
+        # a new map (:charmap) that maps the characters in charmap to a
+        # another hash containing both the old (:old) and new (:new) glyph
+        # ids. The returned hash also includes a :subtable key, which contains
+        # the encoded subtable for the given charmap.
+        def self.encode(charmap)
+          next_id = 0 
+          glyph_indexes = Array.new(256, 0)
+          glyph_map = { 0 => 0 }
+
+          new_map = charmap.keys.sort.inject({}) do |map, code|
+            glyph_map[charmap[code]] ||= next_id += 1
+            map[code] = { :old => charmap[code], :new => glyph_map[charmap[code]] }
+            glyph_indexes[code] = glyph_map[charmap[code]]
+            map
+          end
+
+          # format, length, language, indices
+          subtable = [0, 262, 0, *glyph_indexes].pack("nnnC*")
+
+          { :charmap => new_map, :subtable => subtable, :max_glyph_id => next_id+1 }
+        end
+
+        def [](code)
+          @code_map[code] || 0
+        end
+
+        def supported?
+          true
+        end
+
+        private
+
+          def parse_cmap!
+            length, @language = read(4, "nn")
+            @code_map = read(256, "C*")
+          end
+      end
+
+    end
+  end
+end

data/lib/ttfunk/table/cmap/format04.rb

@@ -0,0 +1,126 @@
+module TTFunk
+  class Table
+    class Cmap
+
+      module Format04
+        attr_reader :language
+        attr_reader :code_map
+
+        # Expects a hash mapping character codes to glyph ids (where the
+        # glyph ids are from the original font). Returns a hash including
+        # a new map (:charmap) that maps the characters in charmap to a
+        # another hash containing both the old (:old) and new (:new) glyph
+        # ids. The returned hash also includes a :subtable key, which contains
+        # the encoded subtable for the given charmap.
+        def self.encode(charmap)
+          end_codes = []
+          start_codes = []
+          next_id = 0
+          last = difference = nil
+
+          glyph_map = { 0 => 0 }
+          new_map = charmap.keys.sort.inject({}) do |map, code|
+            old = charmap[code]
+            glyph_map[old] ||= next_id += 1
+            map[code] = { :old => old, :new => glyph_map[old] }
+
+            delta = glyph_map[old] - code
+            if last.nil? || delta != difference
+              end_codes << last if last
+              start_codes << code
+              difference = delta
+            end
+            last = code
+
+            map
+          end
+
+          end_codes << last if last
+          end_codes << 0xFFFF
+          start_codes << 0xFFFF
+          segcount = start_codes.length
+
+          # build the conversion tables
+          deltas = []
+          range_offsets = []
+          glyph_indices = []
+
+          offset = 0
+          start_codes.zip(end_codes).each_with_index do |(a, b), segment|
+            if a == 0xFFFF
+              deltas << 0
+              range_offsets << 0
+              break
+            end
+
+            start_glyph_id = new_map[a][:new]
+            if a - start_glyph_id >= 0x8000
+              deltas << 0
+              range_offsets << 2 * (glyph_indices.length + segcount - segment)
+              a.upto(b) { |code| glyph_indices << new_map[code][:new] }
+            else
+              deltas << -a + start_glyph_id
+              range_offsets << 0
+            end
+            offset += 2
+          end
+
+          # format, length, language
+          subtable = [4, 16 + 8 * segcount + 2 * glyph_indices.length, 0].pack("nnn")
+
+          search_range = 2 * 2 ** (Math.log(segcount) / Math.log(2)).to_i
+          entry_selector = (Math.log(search_range / 2) / Math.log(2)).to_i
+          range_shift = (2 * segcount) - search_range
+          subtable << [segcount * 2, search_range, entry_selector, range_shift].pack("nnnn")
+
+          subtable << end_codes.pack("n*") << "\0\0" << start_codes.pack("n*")
+          subtable << deltas.pack("n*") << range_offsets.pack("n*") << glyph_indices.pack("n*")
+
+          { :charmap => new_map, :subtable => subtable, :max_glyph_id => next_id+1 }
+        end
+
+        def [](code)
+          @code_map[code] || 0
+        end
+
+        def supported?
+          true
+        end
+
+        private
+
+          def parse_cmap!
+            length, @language, segcount_x2 = read(6, "nnn")
+            segcount = segcount_x2 / 2
+
+            io.read(6) # skip searching hints
+
+            end_code = read(segcount_x2, "n*")
+            io.read(2) # skip reserved value
+            start_code = read(segcount_x2, "n*")
+            id_delta = read_signed(segcount)
+            id_range_offset = read(segcount_x2, "n*")
+
+            glyph_ids = read(length - io.pos + @offset, "n*")
+
+            @code_map = {}
+
+            end_code.each_with_index do |tail, i|
+              start_code[i].upto(tail) do |code|
+                if id_range_offset[i].zero?
+                  glyph_id = code + id_delta[i]
+                else
+                  index = id_range_offset[i] / 2 + (code - start_code[i]) - (segcount - i)
+                  glyph_id = glyph_ids[index] || 0 # because some TTF fonts are broken
+                  glyph_id += id_delta[i] if glyph_id != 0
+                end
+
+                @code_map[code] = glyph_id & 0xFFFF
+              end
+            end
+          end
+      end
+
+    end
+  end
+end

data/lib/ttfunk/table/cmap/subtable.rb

@@ -0,0 +1,79 @@
+require 'ttfunk/reader'
+
+module TTFunk
+  class Table
+    class Cmap
+      class Subtable
+        include Reader
+
+        attr_reader :platform_id
+        attr_reader :encoding_id
+        attr_reader :format
+
+        ENCODING_MAPPINGS = {
+          :mac_roman    => { :platform_id => 1, :encoding_id => 0 },
+          # use microsoft unicode, instead of generic unicode, for optimal windows support
+          :unicode      => { :platform_id => 3, :encoding_id => 1 }
+        }
+
+        def self.encode(charmap, encoding)
+          case encoding
+          when :mac_roman
+            result = Format00.encode(charmap)
+          when :unicode
+            result = Format04.encode(charmap)
+          else
+            raise NotImplementedError, "encoding #{encoding.inspect} is not supported"
+          end
+
+          mapping = ENCODING_MAPPINGS[encoding]
+
+          # platform-id, encoding-id, offset
+          result[:subtable] = [mapping[:platform_id], mapping[:encoding_id],
+            12, result[:subtable]].pack("nnNA*")
+
+          return result
+        end
+
+        def initialize(file, table_start)
+          @file = file
+          @platform_id, @encoding_id, @offset = read(8, "nnN")
+          @offset += table_start
+
+          parse_from(@offset) do
+            @format = read(2, "n").first
+
+            case @format
+              when 0 then extend(TTFunk::Table::Cmap::Format00)
+              when 4 then extend(TTFunk::Table::Cmap::Format04)
+            end
+
+            parse_cmap!
+          end
+        end
+
+        def unicode?
+          platform_id == 3 && encoding_id == 1 && format == 4 ||
+          platform_id == 0 && format == 4
+        end
+
+        def supported?
+          false
+        end
+
+        def [](code)
+          raise NotImplementedError, "cmap format #{@format} is not supported"
+        end
+
+        private
+
+          def parse_cmap!
+            # do nothing...
+          end
+      end
+    end
+  end
+end
+
+require 'ttfunk/table/cmap/format00'
+require 'ttfunk/table/cmap/format04'

data/lib/ttfunk/table/cmap.rb

@@ -0,0 +1,34 @@
+module TTFunk  
+  class Table
+    class Cmap < Table
+      attr_reader :version
+      attr_reader :tables
+
+      def self.encode(charmap, encoding)
+        result = Cmap::Subtable.encode(charmap, encoding)
+
+        # pack 'version' and 'table-count'
+        result[:table] = [0, 1, result.delete(:subtable)].pack("nnA*")
+        return result
+      end
+
+      def unicode
+        @unicode ||= @tables.select { |table| table.unicode? }
+      end
+
+      private
+
+        def parse!
+          @version, table_count = read(4, "nn")
+          @tables = []
+
+          table_count.times do
+            @tables << Cmap::Subtable.new(file, offset)
+          end
+        end
+    end
+    
+  end
+end
+
+require 'ttfunk/table/cmap/subtable'

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

@@ -0,0 +1,81 @@
+require 'ttfunk/reader'
+
+module TTFunk
+  class Table
+    class Glyf
+      class Compound
+        include Reader
+
+        ARG_1_AND_2_ARE_WORDS    = 0x0001
+        WE_HAVE_A_SCALE          = 0x0008
+        MORE_COMPONENTS          = 0x0020
+        WE_HAVE_AN_X_AND_Y_SCALE = 0x0040
+        WE_HAVE_A_TWO_BY_TWO     = 0x0080
+        WE_HAVE_INSTRUCTIONS     = 0x0100
+
+        attr_reader :raw
+        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)
+          @raw = raw
+          @x_min, @y_min, @x_max, @y_max = x_min, y_min, x_max, y_max
+
+          # Because TTFunk only cares about glyphs insofar as they (1) provide
+          # a bounding box for each glyph, and (2) can be rewritten into a
+          # font subset, we don't really care about the rest of the glyph data
+          # except as a whole. Thus, we don't actually decompose the glyph
+          # into it's parts--all we really care about are the locations within
+          # the raw string where the component glyph ids are stored, so that
+          # when we rewrite this glyph into a subset we can rewrite the
+          # component glyph-ids so they are correct for the subset.
+
+          @glyph_ids = []
+          @glyph_id_offsets = []
+          offset = 10 # 2 bytes for each of num-contours, min x/y, max x/y
+
+          loop do
+            flags, glyph_id = @raw[offset, 4].unpack("n*")
+            @glyph_ids << glyph_id
+            @glyph_id_offsets << offset + 2
+
+            break unless flags & MORE_COMPONENTS != 0
+            offset += 4
+
+            if flags & ARG_1_AND_2_ARE_WORDS != 0
+              offset += 4
+            else
+              offset += 2
+            end
+
+            if flags & WE_HAVE_A_TWO_BY_TWO != 0
+              offset += 8
+            elsif flags & WE_HAVE_AN_X_AND_Y_SCALE != 0
+              offset += 4
+            elsif flags & WE_HAVE_A_SCALE != 0
+              offset += 2
+            end
+          end
+        end
+
+        def compound?
+          true
+        end
+
+        def recode(mapping)
+          result = @raw.dup
+          new_ids = glyph_ids.map { |id| mapping[id] }
+
+          new_ids.zip(@glyph_id_offsets).each do |new_id, offset|
+            result[offset, 2] = [new_id].pack("n")
+          end
+
+          return result
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,37 @@
+require 'ttfunk/reader'
+
+module TTFunk
+  class Table
+    class Glyf
+      class Simple
+        attr_reader :raw
+        attr_reader :number_of_contours
+        attr_reader :x_min, :y_min, :x_max, :y_max
+
+        def initialize(raw, number_of_contours, x_min, y_min, x_max, y_max)
+          @raw = raw
+          @number_of_contours = number_of_contours
+          @x_min, @y_min = x_min, y_min
+          @x_max, @y_max = x_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.
+        end
+
+        def compound?
+          false
+        end
+
+        def recode(mapping)
+          raw
+        end
+      end
+    end
+  end
+end
+

data/lib/ttfunk/table/glyf.rb

@@ -0,0 +1,64 @@
+require 'ttfunk/table'
+
+module TTFunk
+  class Table
+    class Glyf < Table
+      # Accepts a hash mapping (old) glyph-ids to glyph objects, and a hash
+      # mapping old glyph-ids to new glyph-ids.
+      #
+      # Returns a hash containing:
+      # 
+      # * :table - a string representing the encoded 'glyf' table containing
+      #   the given glyphs.
+      # * :offsets - an array of offsets for each glyph
+      def self.encode(glyphs, new2old, old2new)
+        result = { :table => "", :offsets => [] }
+
+        new2old.keys.sort.each do |new_id|
+          glyph = glyphs[new2old[new_id]]
+          result[:offsets] << result[:table].length
+          result[:table] << glyph.recode(old2new) if glyph
+        end
+
+        # include an offset at the end of the table, for use in computing the
+        # size of the last glyph
+        result[:offsets] << result[:table].length
+        return result
+      end
+
+      def for(glyph_id)
+        return @cache[glyph_id] if @cache.key?(glyph_id)
+
+        index = file.glyph_locations.index_of(glyph_id)
+        size  = file.glyph_locations.size_of(glyph_id)
+
+        if size.zero? # blank glyph, e.g. space character
+          @cache[glyph_id] = nil
+          return nil
+        end
+
+        parse_from(offset + index) do
+          raw = io.read(size)
+          number_of_contours, x_min, y_min, x_max, y_max = raw.unpack("n5").map { |i| to_signed(i) }
+
+          @cache[glyph_id] = if number_of_contours == -1
+              Compound.new(raw, x_min, y_min, x_max, y_max)
+            else
+              Simple.new(raw, number_of_contours, x_min, y_min, x_max, y_max)
+            end
+        end
+      end
+
+      private
+
+        def parse!
+          # because the glyf table is rather complex to parse, we defer
+          # the parse until we need a specific glyf, and then cache it.
+          @cache = {}
+        end
+    end
+  end
+end
+
+require 'ttfunk/table/glyf/compound'
+require 'ttfunk/table/glyf/simple'