class BinData::IO::Read


readbits(6), readbits(5) #=> [543210, a9876]
In little endian format:
readbits(6), readbits(5) #=> [765432, 10fed]
In big endian format:
B B B B
S 76543210 S S fedcba98 S
M byte1 L M byte2 L
The IO can handle bitstreams in either big or little endian format.
wrapped in an StringIO object.
current stream position. If io is a string it will be automatically
#pos if reading the current stream position and #seek if setting the
Create a new IO Read wrapper around io. io must provide #read,

def accumulate_big_endian_bits 

def accumulate_big_endian_bits
  byte = read(1).unpack('C').at(0) & 0xff
  @rval = (@rval << 8) | byte
  @rnbits += 8
end

def accumulate_little_endian_bits 

def accumulate_little_endian_bits
  byte = read(1).unpack('C').at(0) & 0xff
  @rval = @rval | (byte << @rnbits)
  @rnbits += 8
end

def initialize(io) 

def initialize(io)
  super(io)
  # bits when reading
  @rnbits  = 0
  @rval    = 0
  @rendian = nil
end

def mask(nbits) 

def mask(nbits)
  (1 << nbits) - 1
end

def offset

up when reading bitfields.
Returns the current offset of the io stream. Offset will be rounded 
def offset
  offset_raw
end

def read(n = nil) 

def read(n = nil)
  str = read_raw(buffer_limited_n(n))
  if n
    raise EOFError, "End of file reached" if str.nil?
    raise IOError, "data truncated" if str.size < n
  end
  str
end

def read_all_bytes

Reads all remaining bytes from the stream. 
def read_all_bytes
  reset_read_bits
  read
end

def read_big_endian_bits(nbits) 

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 read_little_endian_bits(nbits) 

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 readbits(nbits, endian)

the bits are stored in +:big+ or +:little+ endian format.
Reads exactly +nbits+ bits from the stream. +endian+ specifies whether 
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

def readbytes(n)

If the data read is too short an IOError is raised.

If the data read is nil an EOFError is raised.

Reads exactly +n+ bytes from +io+. 
def readbytes(n)
  reset_read_bits
  read(n)
end

def reset_read_bits

next byte boundary.
Discards any read bits so the stream becomes aligned at the 
def reset_read_bits
  @rnbits = 0
  @rval   = 0
end

def seekbytes(n)

Seek +n+ bytes from the current position in the io stream. 
def seekbytes(n)
  reset_read_bits
  seek(n)
end

def with_buffer(n)

calls inside the +block+ will be contained within this buffer.
Sets a buffer of +n+ bytes on the io stream. Any reading or seeking 
def with_buffer(n)
  with_buffer_common(n) do
    yield
    read
  end
end