ttfunk 1.5.1 → 1.6.0

data/lib/ttfunk/table/cff/charstrings_index.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      class CharstringsIndex < TTFunk::Table::Cff::Index
+        attr_reader :top_dict
+
+        def initialize(top_dict, *remaining_args)
+          super(*remaining_args)
+          @top_dict = top_dict
+        end
+
+        def [](index)
+          entry_cache[index] ||= TTFunk::Table::Cff::Charstring.new(
+            index, top_dict, font_dict_for(index), super
+          )
+        end
+
+        # gets passed a mapping of new => old glyph ids
+        def encode(mapping)
+          super() do |_entry, index|
+            self[mapping[index]].encode if mapping.include?(index)
+          end
+        end
+
+        private
+
+        def font_dict_for(index)
+          # only CID-keyed fonts contain an FD selector and font dicts
+          if top_dict.is_cid_font?
+            fd_index = top_dict.font_dict_selector[index]
+            top_dict.font_index[fd_index]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ttfunk/table/cff/dict.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      class Dict < TTFunk::SubTable
+        class InvalidOperandError < StandardError; end
+        class TooManyOperandsError < StandardError; end
+
+        # for regular single-byte operators
+        OPERATOR_BZERO = (0..21).freeze
+        OPERAND_BZERO = [28..30, 32..254].freeze
+
+        # for operators that are two bytes wide
+        WIDE_OPERATOR_BZERO = 12
+        WIDE_OPERATOR_ADJUSTMENT = 1200
+
+        # maximum number of operands allowed per operator
+        MAX_OPERANDS = 48
+
+        # used to validate operands expressed in scientific notation
+        VALID_SCI_SIGNIFICAND_RE = /\A-?(\.\d+|\d+|\d+\.\d+)\z/.freeze
+        VALID_SCI_EXPONENT_RE = /\A-?\d+\z/.freeze
+
+        include Enumerable
+
+        def [](operator)
+          @dict[operator]
+        end
+
+        def each(&block)
+          @dict.each(&block)
+        end
+
+        alias each_pair each
+
+        def encode
+          map do |(operator, operands)|
+            operands.map { |operand| encode_operand(operand) }.join +
+              encode_operator(operator)
+          end.join
+        end
+
+        private
+
+        def encode_operator(operator)
+          if operator >= WIDE_OPERATOR_ADJUSTMENT
+            [
+              WIDE_OPERATOR_BZERO,
+              operator - WIDE_OPERATOR_ADJUSTMENT
+            ].pack('C*')
+          else
+            [operator].pack('C')
+          end
+        end
+
+        def encode_operand(operand)
+          case operand
+          when Integer
+            encode_integer(operand)
+          when Float, BigDecimal
+            encode_float(operand)
+          when SciForm
+            encode_sci(operand)
+          end
+        end
+
+        def encode_integer(int)
+          case int
+          when -107..107
+            [int + 139].pack('C')
+
+          when 108..1131
+            int -= 108
+            [(int >> 8) + 247, int & 0xFF].pack('C*')
+
+          when -1131..-108
+            int = -int - 108
+            [(int >> 8) + 251, int & 0xFF].pack('C*')
+
+          when -32_768..32_767
+            [28, (int >> 8) & 0xFF, int & 0xFF].pack('C*')
+
+          else
+            encode_integer32(int)
+          end
+        end
+
+        def encode_integer32(int)
+          [29, int].pack('CN')
+        end
+
+        def encode_float(float)
+          pack_decimal_nibbles(encode_significand(float))
+        end
+
+        def encode_sci(sci)
+          sig_bytes = encode_significand(sci.significand)
+          exp_bytes = encode_exponent(sci.exponent)
+          pack_decimal_nibbles(sig_bytes + exp_bytes)
+        end
+
+        def encode_exponent(exp)
+          return [] if exp == 0
+
+          [exp > 0 ? 0xB : 0xC, *encode_significand(exp.abs)]
+        end
+
+        def encode_significand(sig)
+          sig.to_s.each_char.with_object([]) do |char, ret|
+            case char
+            when '0'..'9'
+              ret << char.to_i
+            when '.'
+              ret << 0xA
+            when '-'
+              ret << 0xE
+            else
+              break ret
+            end
+          end
+        end
+
+        def pack_decimal_nibbles(nibbles)
+          bytes = [30]
+
+          nibbles.each_slice(2).each do |(high_nb, low_nb)|
+            # low_nb can be nil if nibbles contains an odd number of elements
+            low_nb ||= 0xF
+            bytes << (high_nb << 4 | low_nb)
+          end
+
+          bytes << 0xFF if nibbles.size.even?
+          bytes.pack('C*')
+        end
+
+        def parse!
+          @dict = {}
+          operands = []
+
+          # @length must be set via the constructor
+          while io.pos < table_offset + length
+            case b_zero = read(1, 'C').first
+            when WIDE_OPERATOR_BZERO
+              operator = decode_wide_operator
+              @dict[operator] = operands
+              operands = []
+            when OPERATOR_BZERO
+              @dict[b_zero] = operands unless operands.empty?
+              operands = []
+            when *OPERAND_BZERO
+              operands << decode_operand(b_zero)
+
+              if operands.size > MAX_OPERANDS
+                raise TooManyOperandsError, 'found one too many operands at '\
+                  "position #{io.pos} in dict at position #{table_offset}"
+              end
+            else
+              raise "dict byte value #{b_zero} is reserved"
+            end
+          end
+        end
+
+        def decode_wide_operator
+          WIDE_OPERATOR_ADJUSTMENT + read(1, 'C').first
+        end
+
+        def decode_operand(b_zero)
+          case b_zero
+          when 30
+            decode_sci
+          else
+            decode_integer(b_zero)
+          end
+        end
+
+        def decode_sci
+          significand = ''.b
+          exponent = ''.b
+
+          loop do
+            current = read(1, 'C').first
+            break if current == 0xFF
+
+            high_nibble = current >> 4
+            low_nibble = current & 0x0F # 0b00001111
+
+            [high_nibble, low_nibble].each do |nibble|
+              case nibble
+              when 0..9
+                (exponent.empty? ? significand : exponent) << nibble.to_s
+              when 0xA
+                significand << '.'
+              when 0xB
+                # take advantage of Integer#to_i not caring about whitespace
+                exponent << ' '
+              when 0xC
+                exponent << '-'
+              when 0xE
+                significand << '-'
+              end
+            end
+
+            break if low_nibble == 0xF
+          end
+
+          validate_sci!(significand, exponent)
+
+          SciForm.new(significand.to_f, exponent.to_i)
+        end
+
+        def validate_sci!(significand, exponent)
+          unless valid_significand?(significand) && valid_exponent?(exponent)
+            raise InvalidOperandError,
+              'invalid scientific notation operand with significand '\
+              "'#{significand}' and exponent '#{exponent}' ending at "\
+              "position #{io.pos} in dict at position #{table_offset}"
+          end
+        end
+
+        def valid_significand?(significand)
+          !(significand.strip =~ VALID_SCI_SIGNIFICAND_RE).nil?
+        end
+
+        def valid_exponent?(exponent)
+          exponent = exponent.strip
+          return true if exponent.empty?
+
+          !(exponent.strip =~ VALID_SCI_EXPONENT_RE).nil?
+        end
+
+        def decode_integer(b_zero)
+          case b_zero
+          when 32..246
+            # 1 byte
+            b_zero - 139
+
+          when 247..250
+            # 2 bytes
+            b_one = read(1, 'C').first
+            (b_zero - 247) * 256 + b_one + 108
+
+          when 251..254
+            # 2 bytes
+            b_one = read(1, 'C').first
+            -(b_zero - 251) * 256 - b_one - 108
+
+          when 28
+            # 2 bytes in number (3 total)
+            b_one, b_two = read(2, 'C*')
+            BinUtils.twos_comp_to_int(b_one << 8 | b_two, bit_width: 16)
+
+          when 29
+            # 4 bytes in number (5 total)
+            b_one, b_two, b_three, b_four = read(4, 'C*')
+            BinUtils.twos_comp_to_int(
+              b_one << 24 | b_two << 16 | b_three << 8 | b_four, bit_width: 32
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ttfunk/table/cff/encoding.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      class Encoding < TTFunk::SubTable
+        include Enumerable
+
+        STANDARD_ENCODING_ID = 0
+        EXPERT_ENCODING_ID = 1
+
+        DEFAULT_ENCODING_ID = STANDARD_ENCODING_ID
+
+        class << self
+          def codes_for_encoding_id(encoding_id)
+            case encoding_id
+            when STANDARD_ENCODING_ID
+              Encodings::STANDARD
+            when EXPERT_ENCODING_ID
+              Encodings::EXPERT
+            end
+          end
+        end
+
+        attr_reader :top_dict, :format, :count, :offset_or_id
+
+        def initialize(top_dict, file, offset_or_id = nil, length = nil)
+          @top_dict = top_dict
+          @offset_or_id = offset_or_id || DEFAULT_ENCODING_ID
+
+          if offset
+            super(file, offset, length)
+          else
+            @count = self.class.codes_for_encoding_id(offset_or_id).size
+          end
+        end
+
+        def each
+          return to_enum(__method__) unless block_given?
+
+          # +1 adjusts for the implicit .notdef glyph
+          (count + 1).times { |i| yield self[i] }
+        end
+
+        def [](glyph_id)
+          return 0 if glyph_id == 0
+          return code_for(glyph_id) if offset
+
+          self.class.codes_for_encoding_id(offset_or_id)[glyph_id]
+        end
+
+        def offset
+          # Numbers from 0..1 mean encoding IDs instead of offsets. IDs are
+          # pre-defined, generic encodings that define the characters present
+          # in the font.
+          #
+          # In the case of an offset, add the CFF table's offset since the
+          # charset offset is relative to the start of the CFF table. Otherwise
+          # return nil (no offset).
+          if offset_or_id > 1
+            offset_or_id + top_dict.cff_offset
+          end
+        end
+
+        def encode(new_to_old, old_to_new)
+          # no offset means no encoding was specified (i.e. we're supposed to
+          # use a predefined encoding) so there's nothing to encode
+          return '' unless offset
+          return encode_supplemental(new_to_old, old_to_new) if supplemental?
+
+          codes = new_to_old.keys.sort.map do |new_gid|
+            code_for(new_to_old[new_gid])
+          end
+
+          ranges = TTFunk::BinUtils.rangify(codes)
+
+          # calculate whether storing the charset as a series of ranges is
+          # more efficient (i.e. takes up less space) vs storing it as an
+          # array of SID values
+          total_range_size = (2 * ranges.size) +
+            (element_width(:range_format) * ranges.size)
+
+          total_array_size = codes.size * element_width(:array_format)
+
+          if total_array_size <= total_range_size
+            ([format_int(:array_format), codes.size] + codes).pack('C*')
+          else
+            element_fmt = element_format(:range_format)
+            result = [format_int(:range_format), ranges.size].pack('CC')
+            ranges.each { |range| result << range.pack(element_fmt) }
+            result
+          end
+        end
+
+        def supplemental?
+          # high-order bit set to 1 indicates supplemental encoding
+          @format >> 7 == 1
+        end
+
+        private
+
+        def encode_supplemental(_new_to_old, old_to_new)
+          new_entries = @entries.each_with_object({}) do |(code, old_gid), ret|
+            if (new_gid = old_to_new[old_gid])
+              ret[code] = new_gid
+            end
+          end
+
+          result = [format_int(:supplemental), new_entries.size].pack('CC')
+          fmt = element_format(:supplemental)
+
+          new_entries.each do |code, new_gid|
+            result << [code, new_gid].pack(fmt)
+          end
+
+          result
+        end
+
+        def code_for(glyph_id)
+          return 0 if glyph_id == 0
+
+          # rather than validating the glyph as part of one of the predefined
+          # encodings, just pass it through
+          return glyph_id unless offset
+
+          case format_sym
+          when :array_format
+            @entries[glyph_id]
+
+          when :range_format
+            remaining = glyph_id
+
+            @entries.each do |range|
+              if range.size >= remaining
+                return (range.first + remaining) - 1
+              end
+
+              remaining -= range.size
+            end
+
+            0
+
+          when :supplemental
+            @entries[glyph_id]
+          end
+        end
+
+        def parse!
+          @format, entry_count = read(2, 'C*')
+          @length = entry_count * element_width
+
+          case format_sym
+          when :array_format
+            @count = entry_count
+            @entries = OneBasedArray.new(read(length, 'C*'))
+
+          when :range_format
+            @entries = []
+            @count = 0
+
+            entry_count.times do
+              code, num_left = read(element_width, element_format)
+              @entries << (code..(code + num_left))
+              @count += num_left + 1
+            end
+
+          when :supplemental
+            @entries = {}
+            @count = entry_count
+
+            entry_count.times do
+              code, glyph = read(element_width, element_format)
+              @entries[code] = glyph
+            end
+          end
+        end
+
+        def element_format(fmt = format_sym)
+          case fmt
+          when :array_format then 'C'
+          when :range_format then 'CC'
+          when :supplemental then 'Cn'
+          end
+        end
+
+        # @TODO: handle supplemental encoding (necessary?)
+        def element_width(fmt = format_sym)
+          case fmt
+          when :array_format then 1
+          when :range_format then 2
+          when :supplemental then 3
+          else
+            raise "'#{fmt}' is an unsupported encoding format"
+          end
+        end
+
+        def format_sym
+          return :supplemental if supplemental?
+
+          case @format
+          when 0 then :array_format
+          when 1 then :range_format
+          else
+            raise "unsupported charset format '#{fmt}'"
+          end
+        end
+
+        def format_int(sym = format_sym)
+          case sym
+          when :array_format then 0
+          when :range_format then 1
+          when :supplemental then 129
+          else
+            raise "unsupported charset format '#{sym}'"
+          end
+        end
+      end
+    end
+  end
+end