jbangert-bindata 1.5.0

data/lib/bindata/float.rb

@@ -0,0 +1,80 @@
+require 'bindata/base_primitive'
+
+module BinData
+  # Defines a number of classes that contain a floating point number.
+  # The float is defined by precision and endian.
+
+  module FloatingPoint #:nodoc: all
+    class << self
+      def define_methods(float_class, precision, endian)
+        float_class.module_eval <<-END
+          def do_num_bytes
+            #{create_num_bytes_code(precision)}
+          end
+
+          #---------------
+          private
+
+          def sensible_default
+            0.0
+          end
+
+          def value_to_binary_string(val)
+            #{create_to_binary_s_code(precision, endian)}
+          end
+
+          def read_and_return_value(io)
+            #{create_read_code(precision, endian)}
+          end
+        END
+      end
+
+      def create_num_bytes_code(precision)
+        (precision == :single) ? 4 : 8
+      end
+
+      def create_read_code(precision, endian)
+        if precision == :single
+          unpack = (endian == :little) ? 'e' : 'g'
+          nbytes = 4
+        else # double_precision
+          unpack = (endian == :little) ? 'E' : 'G'
+          nbytes = 8
+        end
+
+        "io.readbytes(#{nbytes}).unpack('#{unpack}').at(0)"
+      end
+
+      def create_to_binary_s_code(precision, endian)
+        if precision == :single
+          pack = (endian == :little) ? 'e' : 'g'
+        else # double_precision
+          pack = (endian == :little) ? 'E' : 'G'
+        end
+
+        "[val].pack('#{pack}')"
+      end
+    end
+  end
+
+
+  # Single precision floating point number in little endian format
+  class FloatLe < BinData::BasePrimitive
+    FloatingPoint.define_methods(self, :single, :little)
+  end
+
+  # Single precision floating point number in big endian format
+  class FloatBe < BinData::BasePrimitive
+    FloatingPoint.define_methods(self, :single, :big)
+  end
+
+  # Double precision floating point number in little endian format
+  class DoubleLe < BinData::BasePrimitive
+    FloatingPoint.define_methods(self, :double, :little)
+  end
+
+  # Double precision floating point number in big endian format
+  class DoubleBe < BinData::BasePrimitive
+    FloatingPoint.define_methods(self, :double, :big)
+  end
+end

data/lib/bindata/int.rb

@@ -0,0 +1,184 @@
+require 'bindata/base_primitive'
+
+module BinData
+  # Defines a number of classes that contain an integer.  The integer
+  # is defined by endian, signedness and number of bytes.
+
+  module Int #:nodoc: all
+    class << self
+      def define_class(nbits, endian, signed)
+        name = class_name(nbits, endian, signed)
+        unless BinData.const_defined?(name)
+          BinData.module_eval <<-END
+            class #{name} < BinData::BasePrimitive
+              Int.define_methods(self, #{nbits}, :#{endian}, :#{signed})
+            end
+          END
+        end
+
+        BinData.const_get(name)
+      end
+
+      def class_name(nbits, endian, signed)
+        endian_str = (endian == :big) ? "be" : "le"
+        base = (signed == :signed) ? "Int" : "Uint"
+
+        "#{base}#{nbits}#{endian_str}"
+      end
+
+      def define_methods(int_class, nbits, endian, signed)
+        raise "nbits must be divisible by 8" unless (nbits % 8).zero?
+
+        int_class.module_eval <<-END
+          def assign(val)
+            #{create_clamp_code(nbits, signed)}
+            super(val)
+          end
+
+          def do_num_bytes
+            #{nbits / 8}
+          end
+
+          #---------------
+          private
+
+          def sensible_default
+            0
+          end
+
+          def value_to_binary_string(val)
+            #{create_clamp_code(nbits, signed)}
+            #{create_int2uint_code(nbits) if signed == :signed}
+            #{create_to_binary_s_code(nbits, endian)}
+          end
+
+          def read_and_return_value(io)
+            val = #{create_read_code(nbits, endian)}
+            #{create_uint2int_code(nbits) if signed == :signed}
+            val
+          end
+        END
+      end
+
+      #-------------
+      private
+
+      def create_clamp_code(nbits, signed)
+        if signed == :signed
+          max = (1 << (nbits - 1)) - 1
+          min = -(max + 1)
+        else
+          min = 0
+          max = (1 << nbits) - 1
+        end
+
+        "val = (val < #{min}) ? #{min} : (val > #{max}) ? #{max} : val"
+      end
+
+      def create_int2uint_code(nbits)
+        "val = val & #{(1 << nbits) - 1}"
+      end
+
+      def create_uint2int_code(nbits)
+        "val = val - #{1 << nbits} if (val >= #{1 << (nbits - 1)})"
+      end
+
+      def create_read_code(nbits, endian)
+        bits_per_word = bytes_per_word(nbits) * 8
+        nwords        = nbits / bits_per_word
+        nbytes        = nbits / 8
+
+        idx = (0 ... nwords).to_a
+        idx.reverse! if (endian == :big)
+
+        parts = (0 ... nwords).collect do |i|
+                  if i.zero?
+                    "a.at(#{idx[i]})"
+                  else
+                    "(a.at(#{idx[i]}) << #{bits_per_word * i})"
+                  end
+                end
+
+        unpack_str = "a = io.readbytes(#{nbytes}).unpack('#{pack_directive(nbits, endian)}')"
+        assemble_str = parts.join(" + ")
+
+        "(#{unpack_str}; #{assemble_str})"
+      end
+
+      def create_to_binary_s_code(nbits, endian)
+        # special case 8bit integers for speed
+        return "val.chr" if nbits == 8
+
+        bits_per_word = bytes_per_word(nbits) * 8
+        nwords        = nbits / bits_per_word
+        mask          = (1 << bits_per_word) - 1
+
+        vals = (0 ... nwords).collect do |i|
+                 i.zero? ? "val" : "(val >> #{bits_per_word * i})"
+               end
+        vals.reverse! if (endian == :big)
+
+        parts = (0 ... nwords).collect { |i| "#{vals[i]} & #{mask}" }
+        array_str = "[" + parts.join(", ") + "]"
+
+        "#{array_str}.pack('#{pack_directive(nbits, endian)}')"
+      end
+
+      def bytes_per_word(nbits)
+        (nbits % 32).zero? ? 4 : (nbits % 16).zero? ? 2 : 1
+      end
+
+      def pack_directive(nbits, endian)
+        bits_per_word = bytes_per_word(nbits) * 8
+        nwords        = nbits / bits_per_word
+
+        if (nbits % 32).zero?
+          d = (endian == :big) ? 'N' : 'V'
+        elsif (nbits % 16).zero?
+          d = (endian == :big) ? 'n' : 'v'
+        else
+          d = 'C'
+        end
+
+        d * nwords
+      end
+    end
+  end
+
+
+  # Unsigned 1 byte integer.
+  class Uint8 < BinData::BasePrimitive
+    Int.define_methods(self, 8, :little, :unsigned)
+  end
+
+  # Signed 1 byte integer.
+  class Int8 < BinData::BasePrimitive
+    Int.define_methods(self, 8, :little, :signed)
+  end
+
+  # Create classes on demand
+  class << self
+    alias_method :const_missing_without_int, :const_missing
+    def const_missing_with_int(name)
+      name = name.to_s
+      mappings = {
+        /^Uint(\d+)be$/ => [:big, :unsigned],
+        /^Uint(\d+)le$/ => [:little, :unsigned],
+        /^Int(\d+)be$/ => [:big, :signed],
+        /^Int(\d+)le$/ => [:little, :signed],
+      }
+
+      mappings.each_pair do |regex, args|
+        if regex =~ name
+          nbits = $1.to_i
+          if (nbits % 8).zero?
+            return Int.define_class(nbits, *args)
+          end
+        end
+      end
+
+      const_missing_without_int(name)
+    end
+    alias_method :const_missing, :const_missing_with_int
+  end
+end

data/lib/bindata/io.rb

@@ -0,0 +1,274 @@
+require 'stringio'
+
+module BinData
+  # A wrapper around an IO object.  The wrapper provides a consistent
+  # interface for BinData objects to use when accessing the IO.
+  class IO
+
+    # The underlying IO is unseekable
+    class Unseekable < StandardError; end
+
+    # Creates a StringIO around +str+.
+    def self.create_string_io(str = "")
+      if str.respond_to?(:force_encoding)
+        str = str.dup.force_encoding(Encoding::BINARY)
+      end
+      StringIO.new(str)
+    end
+
+    # Create a new IO wrapper around +io+.  +io+ must support #read if used
+    # for reading, #write if used for writing, #pos if reading the current
+    # stream position and #seek if setting the current stream position.  If
+    # +io+ is a string it will be automatically wrapped in an StringIO object.
+    #
+    # The IO can handle bitstreams in either big or little endian format.
+    #
+    #      M  byte1   L      M  byte2   L
+    #      S 76543210 S      S fedcba98 S
+    #      B          B      B          B
+    #
+    # In big endian format:
+    #   readbits(6), readbits(5) #=> [765432, 10fed]
+    #
+    # In little endian format:
+    #   readbits(6), readbits(5) #=> [543210, a9876]
+    #
+    def initialize(io)
+      raise ArgumentError, "io must not be a BinData::IO" if BinData::IO === io
+
+      # wrap strings in a StringIO
+      if io.respond_to?(:to_str)
+        io = BinData::IO.create_string_io(io.to_str)
+      end
+
+      @raw_io = io
+
+      # initial stream position if stream supports positioning
+      @initial_pos = current_position rescue 0
+
+      # bits when reading
+      @rnbits  = 0
+      @rval    = 0
+      @rendian = nil
+
+      # bits when writing
+      @wnbits  = 0
+      @wval    = 0
+      @wendian = nil
+    end
+
+    # Access to the underlying raw io.
+    attr_reader :raw_io
+
+    # Returns the current offset of the io stream.  The exact value of
+    # the offset when reading bitfields is not defined.
+    def offset
+      current_position - @initial_pos
+    rescue Unseekable
+      0
+    end
+
+    # The number of bytes remaining in the input stream.
+    def num_bytes_remaining
+      pos = current_position
+      @raw_io.seek(0, ::IO::SEEK_END)
+      bytes_remaining = current_position - pos
+      @raw_io.seek(pos, ::IO::SEEK_SET)
+
+      bytes_remaining
+    rescue Unseekable
+      0
+    end
+
+    # Seek +n+ bytes from the current position in the io stream.
+    def seekbytes(n)
+      reset_read_bits
+      @raw_io.seek(n, ::IO::SEEK_CUR)
+    rescue NoMethodError, Errno::ESPIPE, Errno::EPIPE
+      skipbytes(n)
+    end
+
+    # Reads exactly +n+ bytes from +io+.
+    #
+    # If the data read is nil an EOFError is raised.
+    #
+    # If the data read is too short an IOError is raised.
+    def readbytes(n)
+      reset_read_bits
+
+      str = @raw_io.read(n)
+      raise EOFError, "End of file reached" if str.nil?
+      raise IOError, "data truncated" if str.size < n
+      str
+    end
+
+    # Reads all remaining bytes from the stream.
+    def read_all_bytes
+      reset_read_bits
+      @raw_io.read
+    end
+
+    # Reads exactly +nbits+ bits from the stream. +endian+ specifies whether
+    # the bits are stored in +:big+ or +:little+ endian format.
+    def readbits(nbits, endian)
+      if @rendian != endian
+        # don't mix bits of differing endian
+        reset_read_bits
+        @rendian = endian
+      end
+
+      if endian == :big
+        read_big_endian_bits(nbits)
+      else
+        read_little_endian_bits(nbits)
+      end
+    end
+
+    # Discards any read bits so the stream becomes aligned at the
+    # next byte boundary.
+    def reset_read_bits
+      @rnbits = 0
+      @rval   = 0
+    end
+
+    # Writes the given string of bytes to the io stream.
+    def writebytes(str)
+      flushbits
+      @raw_io.write(str)
+    end
+
+    # Writes +nbits+ bits from +val+ to the stream. +endian+ specifies whether
+    # the bits are to be stored in +:big+ or +:little+ endian format.
+    def writebits(val, nbits, endian)
+      if @wendian != endian
+        # don't mix bits of differing endian
+        flushbits
+        @wendian = endian
+      end
+
+      clamped_val = val & mask(nbits)
+
+      if endian == :big
+        write_big_endian_bits(clamped_val, nbits)
+      else
+        write_little_endian_bits(clamped_val, nbits)
+      end
+    end
+
+    # To be called after all +writebits+ have been applied.
+    def flushbits
+      raise "Internal state error nbits = #{@wnbits}" if @wnbits >= 8
+
+      if @wnbits > 0
+        writebits(0, 8 - @wnbits, @wendian)
+      end
+    end
+    alias_method :flush, :flushbits
+
+    #---------------
+    private
+
+    def current_position
+      @raw_io.pos
+    rescue NoMethodError, Errno::ESPIPE
+      raise Unseekable
+    end
+
+    def skipbytes(n)
+      # skip over data in 8k blocks
+      while n > 0
+        bytes_to_read = [n, 8192].min
+        @raw_io.read(bytes_to_read)
+        n -= bytes_to_read
+      end
+    end
+
+    def read_big_endian_bits(nbits)
+      while @rnbits < nbits
+        accumulate_big_endian_bits
+      end
+
+      val     = (@rval >> (@rnbits - nbits)) & mask(nbits)
+      @rnbits -= nbits
+      @rval   &= mask(@rnbits)
+
+      val
+    end
+
+    def accumulate_big_endian_bits
+      byte = @raw_io.read(1)
+      raise EOFError, "End of file reached" if byte.nil?
+      byte = byte.unpack('C').at(0) & 0xff
+
+      @rval = (@rval << 8) | byte
+      @rnbits += 8
+    end
+
+    def read_little_endian_bits(nbits)
+      while @rnbits < nbits
+        accumulate_little_endian_bits
+      end
+
+      val     = @rval & mask(nbits)
+      @rnbits -= nbits
+      @rval   >>= nbits
+
+      val
+    end
+
+    def accumulate_little_endian_bits
+      byte = @raw_io.read(1)
+      raise EOFError, "End of file reached" if byte.nil?
+      byte = byte.unpack('C').at(0) & 0xff
+
+      @rval = @rval | (byte << @rnbits)
+      @rnbits += 8
+    end
+
+    def write_big_endian_bits(val, nbits)
+      while nbits > 0
+        bits_req = 8 - @wnbits
+        if nbits >= bits_req
+          msb_bits = (val >> (nbits - bits_req)) & mask(bits_req)
+          nbits -= bits_req
+          val &= mask(nbits)
+
+          @wval   = (@wval << bits_req) | msb_bits
+          @raw_io.write(@wval.chr)
+
+          @wval   = 0
+          @wnbits = 0
+        else
+          @wval = (@wval << nbits) | val
+          @wnbits += nbits
+          nbits = 0
+        end
+      end
+    end
+
+    def write_little_endian_bits(val, nbits)
+      while nbits > 0
+        bits_req = 8 - @wnbits
+        if nbits >= bits_req
+          lsb_bits = val & mask(bits_req)
+          nbits -= bits_req
+          val >>= bits_req
+
+          @wval   = @wval | (lsb_bits << @wnbits)
+          @raw_io.write(@wval.chr)
+
+          @wval   = 0
+          @wnbits = 0
+        else
+          @wval   = @wval | (val << @wnbits)
+          @wnbits += nbits
+          nbits = 0
+        end
+      end
+    end
+
+    def mask(nbits)
+      (1 << nbits) - 1
+    end
+  end
+end