fontisan 0.4.13 → 0.4.14

data/lib/fontisan/woff2/glyf_transformer.rb

@@ -1,716 +0,0 @@
-# frozen_string_literal: true
-
-require "stringio"
-
-module Fontisan
-  module Woff2
-    # Reconstructs glyf and loca tables from WOFF2 transformed format
-    #
-    # WOFF2 glyf table transformation splits glyph data into separate streams
-    # for better compression. This transformer reconstructs the standard
-    # `glyf` and `loca` table formats from the transformed data.
-    #
-    # Transformation format (Section 5 of WOFF2 spec):
-    # - Separate streams for nContour, nPoints, flags, x-coords, y-coords
-    # - Variable-length integer encoding (255UInt16)
-    # - Composite glyph components stored separately
-    #
-    # See: https://www.w3.org/TR/WOFF2/#glyf_table_format
-    #
-    # @example Reconstructing tables
-    #   result = GlyfTransformer.reconstruct(transformed_data, num_glyphs)
-    #   glyf_data = result[:glyf]
-    #   loca_data = result[:loca]
-    class GlyfTransformer
-      # Glyph flags
-      ON_CURVE_POINT = 0x01
-      X_SHORT_VECTOR = 0x02
-      Y_SHORT_VECTOR = 0x04
-      REPEAT_FLAG = 0x08
-      X_IS_SAME_OR_POSITIVE_X_SHORT_VECTOR = 0x10
-      Y_IS_SAME_OR_POSITIVE_Y_SHORT_VECTOR = 0x20
-
-      # Composite glyph flags
-      ARG_1_AND_2_ARE_WORDS = 0x0001
-      ARGS_ARE_XY_VALUES = 0x0002
-      ROUND_XY_TO_GRID = 0x0004
-      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
-      USE_MY_METRICS = 0x0200
-      OVERLAP_COMPOUND = 0x0400
-      HAVE_VARIATIONS = 0x1000 # Variable font variation data follows
-
-      # Reconstruct glyf and loca tables from transformed data
-      #
-      # @param transformed_data [String] The transformed glyf table data
-      # @param num_glyphs [Integer] Number of glyphs from maxp table
-      # @param variable_font [Boolean] Whether this is a variable font with variation data
-      # @return [Hash] { glyf: String, loca: String }
-      # @raise [InvalidFontError] If data is corrupted or invalid
-      def self.reconstruct(transformed_data, num_glyphs, variable_font: false)
-        io = StringIO.new(transformed_data)
-
-        # Check minimum size for header
-        if io.size < 8
-          raise InvalidFontError,
-                "Transformed glyf data too small: #{io.size} bytes"
-        end
-
-        # Read header
-        read_uint32(io)
-        num_glyphs_in_data = read_uint16(io)
-        index_format = read_uint16(io)
-
-        if num_glyphs_in_data != num_glyphs
-          raise InvalidFontError,
-                "Glyph count mismatch: expected #{num_glyphs}, got #{num_glyphs_in_data}"
-        end
-
-        # Read nContour stream
-        n_contour_data = read_stream_safely(io, "nContour",
-                                            variable_font: variable_font)
-
-        # Read nPoints stream
-        n_points_data = read_stream_safely(io, "nPoints",
-                                           variable_font: variable_font)
-
-        # Read flag stream
-        flag_data = read_stream_safely(io, "flag", variable_font: variable_font)
-
-        # Read glyph stream (coordinates, instructions, composite data)
-        glyph_data = read_stream_safely(io, "glyph",
-                                        variable_font: variable_font)
-
-        # Read composite stream
-        composite_data = read_stream_safely(io, "composite",
-                                            variable_font: variable_font)
-
-        # Read bbox stream
-        bbox_data = read_stream_safely(io, "bbox", variable_font: variable_font)
-
-        # Read instruction stream
-        instruction_data = read_stream_safely(io, "instruction",
-                                              variable_font: variable_font)
-
-        # Parse streams
-        n_contours = parse_n_contour_stream(StringIO.new(n_contour_data),
-                                            num_glyphs)
-
-        # Reconstruct glyphs
-        glyphs = reconstruct_glyphs(
-          n_contours,
-          StringIO.new(n_points_data),
-          StringIO.new(flag_data),
-          StringIO.new(glyph_data),
-          StringIO.new(composite_data),
-          StringIO.new(bbox_data),
-          StringIO.new(instruction_data),
-          variable_font: variable_font,
-        )
-
-        # Build glyf and loca tables
-        build_tables(glyphs, index_format)
-      end
-
-      # Safely read a stream with bounds checking
-      #
-      # @param io [StringIO] Input stream
-      # @param stream_name [String] Name of stream for error messages
-      # @param variable_font [Boolean] Whether this is a variable font (allows incomplete streams)
-      # @return [String] Stream data (empty if not available)
-      def self.read_stream_safely(io, _stream_name, variable_font: false)
-        remaining = io.size - io.pos
-        if remaining < 4
-          # Not enough data for stream size - return empty stream
-          return ""
-        end
-
-        # Read stream size safely
-        size_bytes = io.read(4)
-        return "" unless size_bytes && size_bytes.bytesize == 4
-
-        stream_size = size_bytes.unpack1("N")
-        remaining = io.size - io.pos
-
-        if remaining < stream_size
-          # Stream size extends beyond available data
-          # Read what we can
-          io.read(remaining) || ""
-          # For variable fonts, we may have incomplete streams - just return what we have
-
-        else
-          io.read(stream_size) || ""
-        end
-      end
-
-      # Read variable-length 255UInt16 integer
-      #
-      # Format from WOFF2 spec:
-      # - value < 253: one byte
-      # - value == 253: 253 + next uint16
-      # - value == 254: 253 * 2 + next uint16
-      # - value == 255: 253 * 3 + next uint16
-      #
-      # @param io [StringIO] Input stream
-      # @return [Integer] Decoded value, or 0 if not enough data
-      def self.read_255_uint16(io)
-        return 0 if io.eof? || (io.size - io.pos) < 1
-
-        code_byte = io.read(1)
-        return 0 unless code_byte && code_byte.bytesize == 1
-
-        code = code_byte.unpack1("C")
-
-        case code
-        when 255
-          return 0 if io.eof? || (io.size - io.pos) < 2
-
-          value_bytes = io.read(2)
-          return 0 unless value_bytes && value_bytes.bytesize == 2
-
-          759 + value_bytes.unpack1("n")  # 253 * 3 + value
-        when 254
-          return 0 if io.eof? || (io.size - io.pos) < 2
-
-          value_bytes = io.read(2)
-          return 0 unless value_bytes && value_bytes.bytesize == 2
-
-          506 + value_bytes.unpack1("n")  # 253 * 2 + value
-        when 253
-          return 0 if io.eof? || (io.size - io.pos) < 2
-
-          value_bytes = io.read(2)
-          return 0 unless value_bytes && value_bytes.bytesize == 2
-
-          253 + value_bytes.unpack1("n")
-        else
-          code
-        end
-      end
-
-      # Parse nContour stream
-      #
-      # @param io [StringIO] Input stream
-      # @param num_glyphs [Integer] Number of glyphs
-      # @return [Array<Integer>] Number of contours per glyph (-1 for composite)
-      def self.parse_n_contour_stream(io, num_glyphs)
-        n_contours = []
-        num_glyphs.times do
-          # For variable fonts, stream may be incomplete
-          break if io.eof? || (io.size - io.pos) < 2
-
-          value = read_int16(io)
-          n_contours << value
-        end
-
-        # Pad with zeros if we have fewer contours than glyphs
-        while n_contours.size < num_glyphs
-          n_contours << 0
-        end
-
-        n_contours
-      end
-
-      # Reconstruct all glyphs
-      #
-      # @param n_contours [Array<Integer>] Contour counts
-      # @param n_points_io [StringIO] Points stream
-      # @param flag_io [StringIO] Flag stream
-      # @param glyph_io [StringIO] Glyph data stream
-      # @param composite_io [StringIO] Composite glyph stream
-      # @param bbox_io [StringIO] Bounding box stream
-      # @param instruction_io [StringIO] Instruction stream
-      # @param variable_font [Boolean] Whether this is a variable font
-      # @return [Array<String>] Reconstructed glyph data
-      def self.reconstruct_glyphs(n_contours, n_points_io, flag_io, glyph_io,
-                                   composite_io, bbox_io, instruction_io, variable_font: false)
-        glyphs = []
-
-        n_contours.each do |num_contours|
-          if num_contours.zero?
-            # Empty glyph
-            glyphs << ""
-          elsif num_contours.positive?
-            # Simple glyph
-            glyphs << reconstruct_simple_glyph(
-              num_contours, n_points_io, flag_io,
-              glyph_io, bbox_io, instruction_io
-            )
-          elsif num_contours == -1
-            # Composite glyph
-            glyphs << reconstruct_composite_glyph(
-              composite_io, bbox_io, instruction_io, variable_font: variable_font
-            )
-          else
-            raise InvalidFontError, "Invalid nContours value: #{num_contours}"
-          end
-        end
-
-        glyphs
-      end
-
-      # Reconstruct a simple glyph
-      #
-      # @param num_contours [Integer] Number of contours
-      # @param n_points_io [StringIO] Points stream
-      # @param flag_io [StringIO] Flag stream
-      # @param glyph_io [StringIO] Glyph data stream
-      # @param bbox_io [StringIO] Bounding box stream
-      # @param instruction_io [StringIO] Instruction stream
-      # @return [String] Glyph data in standard format
-      def self.reconstruct_simple_glyph(num_contours, n_points_io, flag_io,
-                                        glyph_io, bbox_io, instruction_io)
-        # Read end points of contours
-        end_pts_of_contours = []
-        max_points_per_glyph = 100000 # Sanity limit
-
-        num_contours.times do
-          if end_pts_of_contours.empty?
-            val = read_255_uint16(n_points_io)
-            end_pts_of_contours << val
-          else
-            delta = read_255_uint16(n_points_io)
-            next_end_pt = end_pts_of_contours.last + delta + 1
-
-            # Sanity check to prevent explosion from corrupted data
-            if delta > 10000 || next_end_pt > max_points_per_glyph
-              # Data appears corrupted, stop reading
-              break
-            end
-
-            end_pts_of_contours << next_end_pt
-          end
-        end
-
-        # Handle case where stream was corrupted
-        if end_pts_of_contours.empty?
-          # Return minimal empty glyph
-          return ["\x00\x00"].pack("n") * 5 # Empty glyph: num_contours=0, bbox=0
-        end
-
-        total_points = [end_pts_of_contours.last + 1, max_points_per_glyph].min
-
-        # Read flags
-        flags = read_flags(flag_io, total_points)
-
-        # Read coordinates
-        x_coordinates = read_coordinates(glyph_io, flags, X_SHORT_VECTOR,
-                                         X_IS_SAME_OR_POSITIVE_X_SHORT_VECTOR)
-        y_coordinates = read_coordinates(glyph_io, flags, Y_SHORT_VECTOR,
-                                         Y_IS_SAME_OR_POSITIVE_Y_SHORT_VECTOR)
-
-        # Read bounding box safely
-        bbox_remaining = bbox_io.size - bbox_io.pos
-        if bbox_remaining < 8
-          # Not enough data, use default bounding box
-          x_min = y_min = x_max = y_max = 0
-        else
-          bbox_bytes = bbox_io.read(8)
-          if bbox_bytes && bbox_bytes.bytesize == 8
-            x_min, y_min, x_max, y_max = bbox_bytes.unpack("n4")
-            # Convert to signed
-            x_min = x_min > 0x7FFF ? x_min - 0x10000 : x_min
-            y_min = y_min > 0x7FFF ? y_min - 0x10000 : y_min
-            x_max = x_max > 0x7FFF ? x_max - 0x10000 : x_max
-            y_max = y_max > 0x7FFF ? y_max - 0x10000 : y_max
-          else
-            x_min = y_min = x_max = y_max = 0
-          end
-        end
-
-        # Read instructions safely
-        instruction_length = 0
-        instructions = ""
-
-        inst_remaining = instruction_io.size - instruction_io.pos
-        if inst_remaining >= 2
-          inst_length_data = read_255_uint16(instruction_io)
-          if inst_length_data
-            instruction_length = inst_length_data
-            if instruction_length.positive?
-              inst_remaining = instruction_io.size - instruction_io.pos
-              instructions = if inst_remaining >= instruction_length
-                               instruction_io.read(instruction_length) || ""
-                             else
-                               # Read what we can
-                               instruction_io.read(inst_remaining) || ""
-                             end
-            end
-          end
-        end
-
-        # Build glyph data in standard format
-        build_simple_glyph_data(num_contours, x_min, y_min, x_max, y_max,
-                                end_pts_of_contours, instructions, flags,
-                                x_coordinates, y_coordinates)
-      end
-
-      # Reconstruct a composite glyph
-      #
-      # @param composite_io [StringIO] Composite stream
-      # @param bbox_io [StringIO] Bounding box stream
-      # @param instruction_io [StringIO] Instruction stream
-      # @param variable_font [Boolean] Whether this is a variable font
-      # @return [String] Glyph data in standard format
-      def self.reconstruct_composite_glyph(composite_io, bbox_io,
-instruction_io, variable_font: false)
-        # Track available bytes to prevent EOF errors
-        composite_size = composite_io.size - composite_io.pos
-
-        # Validate minimum size (at least flags + glyph_index + args)
-        return "" if composite_size < 8
-
-        # Read bounding box safely
-        bbox_remaining = bbox_io.size - bbox_io.pos
-        if bbox_remaining < 8
-          # Not enough data for bounding box, return empty glyph
-          return ""
-        end
-
-        bbox_bytes = bbox_io.read(8)
-        unless bbox_bytes && bbox_bytes.bytesize == 8
-          return ""
-        end
-
-        x_min, y_min, x_max, y_max = bbox_bytes.unpack("n4")
-        # Convert to signed
-        x_min = x_min > 0x7FFF ? x_min - 0x10000 : x_min
-        y_min = y_min > 0x7FFF ? y_min - 0x10000 : y_min
-        x_max = x_max > 0x7FFF ? x_max - 0x10000 : x_max
-        y_max = y_max > 0x7FFF ? y_max - 0x10000 : y_max
-
-        # Read composite data
-        composite_data = +""
-        has_instructions = false
-        has_variations = false
-
-        loop do
-          # Check if we have enough bytes for flags and glyph_index
-          remaining = composite_io.size - composite_io.pos
-          break if composite_io.eof? || remaining < 4
-
-          # Read flags and glyph_index safely
-          component_header = composite_io.read(4)
-          break unless component_header && component_header.bytesize == 4
-
-          flags, glyph_index = component_header.unpack("n2")
-
-          # Write flags and index
-          composite_data << [flags].pack("n")
-          composite_data << [glyph_index].pack("n")
-
-          # Read arguments (depend on flags)
-          remaining = composite_io.size - composite_io.pos
-          if (flags & ARG_1_AND_2_ARE_WORDS).zero?
-            break if composite_io.eof? || remaining < 2
-
-            arg_bytes = composite_io.read(2)
-            break unless arg_bytes && arg_bytes.bytesize == 2
-
-            arg1, arg2 = arg_bytes.unpack("c2")
-            composite_data << [arg1, arg2].pack("c2")
-          else
-            break if composite_io.eof? || remaining < 4
-
-            arg_bytes = composite_io.read(4)
-            break unless arg_bytes && arg_bytes.bytesize == 4
-
-            arg1, arg2 = arg_bytes.unpack("n2")
-            # Convert to signed
-            arg1 = arg1 > 0x7FFF ? arg1 - 0x10000 : arg1
-            arg2 = arg2 > 0x7FFF ? arg2 - 0x10000 : arg2
-            composite_data << [arg1, arg2].pack("n2")
-          end
-
-          # Read transformation matrix (depends on flags) with bounds checking
-          if (flags & WE_HAVE_A_SCALE) != 0
-            remaining = composite_io.size - composite_io.pos
-            break if composite_io.eof? || remaining < 2
-
-            scale_bytes = composite_io.read(2)
-            break unless scale_bytes && scale_bytes.bytesize == 2
-
-            scale = scale_bytes.unpack1("n")
-            composite_data << [scale].pack("n")
-          elsif (flags & WE_HAVE_AN_X_AND_Y_SCALE) != 0
-            remaining = composite_io.size - composite_io.pos
-            break if composite_io.eof? || remaining < 4
-
-            scale_bytes = composite_io.read(4)
-            break unless scale_bytes && scale_bytes.bytesize == 4
-
-            x_scale, y_scale = scale_bytes.unpack("n2")
-            composite_data << [x_scale, y_scale].pack("n2")
-          elsif (flags & WE_HAVE_A_TWO_BY_TWO) != 0
-            remaining = composite_io.size - composite_io.pos
-            break if composite_io.eof? || remaining < 8
-
-            matrix_bytes = composite_io.read(8)
-            break unless matrix_bytes && matrix_bytes.bytesize == 8
-
-            x_scale, scale01, scale10, y_scale = matrix_bytes.unpack("n4")
-            composite_data << [x_scale, scale01, scale10, y_scale].pack("n4")
-          end
-
-          # Check for variable font variation data
-          # Only parse if this is a variable font and the flag is set
-          if variable_font && (flags & HAVE_VARIATIONS) != 0
-            has_variations = true
-            # Read tuple variation count and data
-            remaining = composite_io.size - composite_io.pos
-            if !composite_io.eof? && remaining >= 2
-              # Read tuple count safely
-              tuple_bytes = composite_io.read(2)
-              if tuple_bytes && tuple_bytes.bytesize == 2
-                tuple_count = tuple_bytes.unpack1("n")
-                composite_data << [tuple_count].pack("n")
-
-                # Each tuple has variation data - read and preserve it
-                tuple_count.times do
-                  remaining = composite_io.size - composite_io.pos
-                  break if composite_io.eof? || remaining < 4
-
-                  # Read variation data (2 int16 values per tuple)
-                  var_bytes = composite_io.read(4)
-                  break unless var_bytes && var_bytes.bytesize == 4
-
-                  var1, var2 = var_bytes.unpack("n2")
-                  # Convert to signed if needed
-                  var1 = var1 > 0x7FFF ? var1 - 0x10000 : var1
-                  var2 = var2 > 0x7FFF ? var2 - 0x10000 : var2
-                  composite_data << [var1, var2].pack("n2")
-                end
-              end
-            end
-          end
-
-          has_instructions = (flags & WE_HAVE_INSTRUCTIONS) != 0
-
-          break if (flags & MORE_COMPONENTS).zero?
-        end
-
-        # Add instructions if present
-        instructions = +""
-        if has_instructions
-          # Read instruction length safely
-          remaining = instruction_io.size - instruction_io.pos
-          if !instruction_io.eof? && remaining >= 2
-            length_bytes = instruction_io.read(2)
-            if length_bytes && length_bytes.bytesize == 2
-              instruction_length = length_bytes.unpack1("n")
-              if instruction_length.positive?
-                remaining = instruction_io.size - instruction_io.pos
-                instructions = if remaining >= instruction_length
-                                 instruction_io.read(instruction_length) || ""
-                               else
-                                 # Read what we can
-                                 instruction_io.read(remaining) || ""
-                               end
-              end
-            end
-          end
-        end
-
-        # Build composite glyph data
-        data = +""
-        data << [-1].pack("n") # numberOfContours = -1
-        data << [x_min, y_min, x_max, y_max].pack("n4")
-        data << composite_data
-        data << [instructions.bytesize].pack("n") if has_instructions
-        data << instructions if has_instructions
-
-        data
-      end
-
-      # Read flags with repeat handling
-      #
-      # @param io [StringIO] Flag stream
-      # @param count [Integer] Number of flags to read
-      # @return [Array<Integer>] Flag values
-      def self.read_flags(io, count)
-        flags = []
-
-        while flags.size < count
-          # Safety check to prevent infinite loops with corrupted streams
-          if flags.size > 200000
-            # Stream appears corrupted, pad with zeros
-            while flags.size < count
-              flags << 0
-            end
-            break
-          end
-
-          # EOF protection for variable fonts
-          break if io.eof? || (io.size - io.pos) < 1
-
-          flag = read_uint8(io)
-          flags << flag
-
-          if (flag & REPEAT_FLAG) != 0
-            break if io.eof? || (io.size - io.pos) < 1
-
-            repeat_count = read_uint8(io)
-            # Safety check on repeat count
-            repeat_count = [repeat_count, 100].min
-            repeat_count.times { flags << flag }
-          end
-        end
-
-        flags
-      end
-
-      # Read coordinates
-      #
-      # @param io [StringIO] Glyph stream
-      # @param flags [Array<Integer>] Flag values
-      # @param short_flag [Integer] Flag bit for short vector
-      # @param same_or_positive_flag [Integer] Flag bit for same/positive
-      # @return [Array<Integer>] Coordinate values
-      def self.read_coordinates(io, flags, short_flag, same_or_positive_flag)
-        coords = []
-        value = 0
-
-        flags.each do |flag|
-          # EOF protection
-          if (flag & short_flag) != 0
-            break if io.eof? || (io.size - io.pos) < 1
-
-            # Short vector (one byte)
-            delta = read_uint8(io)
-            delta = -delta if (flag & same_or_positive_flag).zero?
-          elsif (flag & same_or_positive_flag) != 0
-            # Same as previous (delta = 0)
-            delta = 0
-          else
-            break if io.eof? || (io.size - io.pos) < 2
-
-            # Long vector (two bytes, signed)
-            delta = read_int16(io)
-          end
-
-          value += delta
-          coords << value
-        end
-
-        # Pad with last value if needed
-        last_val = coords.last || 0
-        while coords.size < flags.size
-          coords << last_val
-        end
-
-        coords
-      end
-
-      # Build simple glyph data in standard format
-      #
-      # @return [String] Glyph data
-      def self.build_simple_glyph_data(num_contours, x_min, y_min, x_max, y_max,
-                                       end_pts, instructions, flags, x_coords, y_coords)
-        data = +""
-        data << [num_contours].pack("n")
-        data << [x_min, y_min, x_max, y_max].pack("n4")
-
-        end_pts.each { |pt| data << [pt].pack("n") }
-
-        data << [instructions.bytesize].pack("n")
-        data << instructions
-
-        flags.each { |flag| data << [flag].pack("C") }
-
-        # Write x-coordinates
-        prev_x = 0
-        x_coords.each do |x|
-          delta = x - prev_x
-          prev_x = x
-
-          data << if delta.abs <= 255
-                    [delta.abs].pack("C")
-                  else
-                    [delta].pack("n")
-                  end
-        end
-
-        # Write y-coordinates
-        prev_y = 0
-        y_coords.each do |y|
-          delta = y - prev_y
-          prev_y = y
-
-          data << if delta.abs <= 255
-                    [delta.abs].pack("C")
-                  else
-                    [delta].pack("n")
-                  end
-        end
-
-        data
-      end
-
-      # Build glyf and loca tables
-      #
-      # @param glyphs [Array<String>] Glyph data
-      # @param index_format [Integer] Loca format (0 = short, 1 = long)
-      # @return [Hash] { glyf: String, loca: String }
-      def self.build_tables(glyphs, index_format)
-        glyf_data = +""
-        loca_offsets = [0]
-
-        glyphs.each do |glyph|
-          glyf_data << glyph
-
-          # Add padding to 4-byte boundary
-          padding = (4 - (glyph.bytesize % 4)) % 4
-          glyf_data << ("\x00" * padding)
-
-          loca_offsets << glyf_data.bytesize
-        end
-
-        # Build loca table
-        loca_data = +""
-        if index_format.zero?
-          # Short format (divide offsets by 2)
-          loca_offsets.each do |offset|
-            loca_data << [offset / 2].pack("n")
-          end
-        else
-          # Long format
-          loca_offsets.each do |offset|
-            loca_data << [offset].pack("N")
-          end
-        end
-
-        { glyf: glyf_data, loca: loca_data }
-      end
-
-      # Helper methods for reading binary data
-
-      def self.read_uint8(io)
-        io.read(1)&.unpack1("C") || raise(EOFError, "Unexpected end of stream")
-      end
-
-      def self.read_int8(io)
-        io.read(1)&.unpack1("c") || raise(EOFError, "Unexpected end of stream")
-      end
-
-      def self.read_uint16(io)
-        io.read(2)&.unpack1("n") || raise(EOFError, "Unexpected end of stream")
-      end
-
-      def self.read_int16(io)
-        value = read_uint16(io)
-        value > 0x7FFF ? value - 0x10000 : value
-      end
-
-      def self.read_uint32(io)
-        io.read(4)&.unpack1("N") || raise(EOFError, "Unexpected end of stream")
-      end
-
-      def self.read_f2dot14(io)
-        read_uint16(io)
-      end
-    end
-  end
-end