#include <BinaryInput.h>

Public Member Functions
	BinaryInput (const std::string &filename, G3DEndian fileEndian, bool compressed=false)

	BinaryInput (const uint8 *data, int64 dataLen, G3DEndian dataEndian, bool compressed=false, bool copyMemory=true)

virtual	~BinaryInput ()

void	setEndian (G3DEndian endian)

G3DEndian	endian () const

std::string	getFilename () const

uint8	operator[] (int64 n)

int64	getLength () const

int64	size () const

int64	getPosition () const

const uint8 *	getCArray ()

void	setPosition (int64 p)

void	reset ()

void	readBytes (void *bytes, int64 n)

int8	readInt8 ()

bool	readBool8 ()

uint8	readUInt8 ()

unorm8	readUNorm8 ()

uint16	readUInt16 ()

int16	readInt16 ()

uint32	readUInt32 ()

int32	readInt32 ()

uint64	readUInt64 ()

int64	readInt64 ()

float32	readFloat32 ()

float64	readFloat64 ()

std::string	readString (int64 maxLength)

std::string	readString ()

std::string	readFixedLengthString (int numBytes)

std::string	readStringNewline ()

std::string	readStringEven ()

std::string	readString32 ()

Vector4	readVector4 ()

Vector3	readVector3 ()

Vector2	readVector2 ()

Color4	readColor4 ()

Color3	readColor3 ()

void	skip (int64 n)

bool	hasMore () const

void	beginBits ()

uint32	readBits (int numBits)

void	endBits ()

Static Public Attributes
static const bool	NO_COPY = false

Private Member Functions
void	loadIntoMemory (int64 startPosition, int64 minLength=0)

void	prepareToRead (int64 nbytes)

	BinaryInput (const BinaryInput &)

BinaryInput &	operator= (const BinaryInput &)

bool	operator== (const BinaryInput &)

void	decompress ()

Private Attributes
G3DEndian	m_fileEndian

std::string	m_filename

bool	m_swapBytes

int	m_bitPos

uint32	m_bitString

int	m_beginEndBits

int64	m_alreadyRead

int64	m_length

int64	m_bufferLength

uint8 *	m_buffer

int64	m_pos

bool	m_freeBuffer

Static Private Attributes
static const int64	INITIAL_BUFFER_LENGTH

Detailed Description

Sequential or random access byte-order independent binary file access. Files compressed with zlib and beginning with an unsigned 32-bit int size are transparently decompressed when the compressed = true flag is specified to the constructor.

For every readX method there are also versions that operate on a whole Array, std::vector, or C-array. e.g. readFloat32(Array<float32>& array, n) These methods resize the array or std::vector to the appropriate size before reading. For a C-array, they require the pointer to reference a memory block at least large enough to hold n elements.

Most classes define serialize/deserialize methods that use BinaryInput, BinaryOutput, TextInput, and TextOutput. There are text serializer functions for primitive types (e.g. int, std::string, float, double) but not binary serializers– you must call the BinaryInput::readInt32 or other appropriate function. This is because it would be very hard to debug the error sequence: serialize(1.0, bo); ... float f; deserialize(f, bi); in which a double is serialized and then deserialized as a float.

Constructor & Destructor Documentation

G3D::BinaryInput::BinaryInput ( const BinaryInput & )

private

G3D::BinaryInput::BinaryInput	(	const std::string &	filename,
		G3DEndian	fileEndian,
		bool	compressed = `false`
	)

If the file cannot be opened, a zero length buffer is presented. Automatically opens files that are inside zipfiles.

Parameters

compressed Set to true if and only if the file was compressed using BinaryOutput's zlib compression. This has nothing to do with whether the input is in a zipfile.

  :
  m_filename(filename),
  m_bitPos(0),
  m_bitString(0),
  m_beginEndBits(0),
  m_alreadyRead(0),
  m_length(0),
  m_bufferLength(0),
  m_buffer(NULL),
  m_pos(0),
  m_freeBuffer(true) {
 
  setEndian(fileEndian);
  
 #if _HAVE_ZIP /* G3DFIX: Use ZIP-library only if defined */
  std::string zipfile;
  if (FileSystem::inZipfile(m_filename, zipfile)) {
  // Load from zipfile
  FileSystem::markFileUsed(m_filename);
  FileSystem::markFileUsed(zipfile);
 
  // Zipfiles require Unix-style slashes
  std::string internalFile = FilePath::canonicalize(m_filename.substr(zipfile.length() + 1));
  struct zip* z = zip_open(zipfile.c_str(), ZIP_CHECKCONS, NULL);
  {
  struct zip_stat info;
  zip_stat_init( &info ); // TODO: Docs unclear if zip_stat_init is required.
  zip_stat(z, internalFile.c_str(), ZIP_FL_NOCASE, &info);
  m_bufferLength = m_length = info.size;
  // sets machines up to use MMX, if they want
  m_buffer = reinterpret_cast<uint8*>(System::alignedMalloc(m_length, 16));
  struct zip_file* zf = zip_fopen( z, internalFile.c_str(), ZIP_FL_NOCASE );
  if (zf == NULL) {
  throw std::string("\"") + internalFile + "\" inside \"" + zipfile + "\" could not be opened.";
  } else {
  const int64 bytesRead = zip_fread( zf, m_buffer, m_length );
  debugAssertM(bytesRead == m_length,
  internalFile + " was corrupt because it unzipped to the wrong size.");
  (void)bytesRead;
  zip_fclose( zf );
  }
  }
  zip_close( z );
 
  if (compressed) {
  decompress();
  }
 
  m_freeBuffer = true;
  return;
  }
 #endif
  // Figure out how big the file is and verify that it exists.
  m_length = FileSystem::size(m_filename);
 
  // Read the file into memory
  FILE* file = FileSystem::fopen(m_filename.c_str(), "rb");
 
  if (! file || (m_length == -1)) {
  throw format("File not found: \"%s\"", m_filename.c_str());
  return;
  }
 
  if (! compressed && (m_length > INITIAL_BUFFER_LENGTH)) {
  // Read only a subset of the file so we don't consume
  // all available memory.
  m_bufferLength = INITIAL_BUFFER_LENGTH;
  } else {
  // Either the length is fine or the file is compressed
  // and requires us to read the whole thing for zlib.
  m_bufferLength = m_length;
  }
 
  debugAssert(m_freeBuffer);
  m_buffer = (uint8*)System::alignedMalloc(m_bufferLength, 16);
  if (m_buffer == NULL) {
  if (compressed) {
  throw "Not enough memory to load compressed file. (1)";
  }
  
  // Try to allocate a small array; not much memory is available.
  // Give up if we can't allocate even 1k.
  while ((m_buffer == NULL) && (m_bufferLength > 1024)) {
  m_bufferLength /= 2;
  m_buffer = (uint8*)System::alignedMalloc(m_bufferLength, 16);
  }
  }
  debugAssert(m_buffer);
  
  (void)fread(m_buffer, m_bufferLength, sizeof(int8), file);
  FileSystem::fclose(file);
  file = NULL;
 
  if (compressed) {
  if (m_bufferLength != m_length) {
  throw "Not enough memory to load compressed file. (2)";
  }
 
  decompress();
  }
 }

Here is the call graph for this function:

G3D::BinaryInput::BinaryInput	(	const uint8 *	data,
		int64	dataLen,
		G3DEndian	dataEndian,
		bool	compressed = `false`,
		bool	copyMemory = `true`
	)

Creates input stream from an in memory source. Unless you specify copyMemory = false, the data is copied from the pointer, so you may deallocate it as soon as the object is constructed. It is an error to specify copyMemory = false and compressed = true.

To decompress part of a file, you can follow the following paradigm:

   BinaryInput master(...);

   // read from master to point where compressed data exists.

   BinaryInput subset(master.getCArray() + master.getPosition(), 
                      master.length() - master.getPosition(),
                      master.endian(), true, true);

   // Now read from subset (it is ok for master to go out of scope)

  :
  m_filename("<memory>"),
  m_bitPos(0),
  m_bitString(0),
  m_beginEndBits(0),
  m_alreadyRead(0),
  m_bufferLength(0),
  m_pos(0) {
 
  m_freeBuffer = copyMemory || compressed;
 
  setEndian(dataEndian);
 
  if (compressed) {
  // Read the decompressed size from the first 4 bytes
  m_length = readUInt32FromBuffer(data, m_swapBytes);
 
  debugAssert(m_freeBuffer);
  m_buffer = (uint8*)System::alignedMalloc(m_length, 16);
 
  unsigned long L = (unsigned long)m_length;
  // Decompress with zlib
  int64 result = uncompress(m_buffer, &L, data + 4, (uLong)dataLen - 4);
  m_length = L;
  m_bufferLength = L;
  debugAssert(result == Z_OK); (void)result;
 
  } else {
  m_length = dataLen;
  m_bufferLength = m_length;
  if (! copyMemory) {
  debugAssert(!m_freeBuffer);
  m_buffer = const_cast<uint8*>(data);
  } else {
  debugAssert(m_freeBuffer);
  m_buffer = (uint8*)System::alignedMalloc(m_length, 16);
  System::memcpy(m_buffer, data, dataLen);
  }
  }
 }

Here is the call graph for this function:

G3D::BinaryInput::~BinaryInput ( )

virtual

  {
 
  if (m_freeBuffer) {
  System::alignedFree(m_buffer);
  }
  m_buffer = NULL;
 }

Here is the call graph for this function:

Member Function Documentation

void G3D::BinaryInput::beginBits ( )

Prepares for bit reading via readBits. Only readBits can be called between beginBits and endBits without corrupting the data stream.

  {
  debugAssert(m_beginEndBits == 0);
  m_beginEndBits = 1;
  m_bitPos = 0;
 
  debugAssertM(hasMore(), "Can't call beginBits when at the end of a file");
  m_bitString = readUInt8();
 }

Here is the call graph for this function:

void G3D::BinaryInput::decompress ( )

private

Buffer is compressed; replace it with a decompressed version

  {
  // Decompress
  // Use the existing buffer as the source, allocate
  // a new buffer to use as the destination.
  
  int64 tempLength = m_length;
  m_length = readUInt32FromBuffer(m_buffer, m_swapBytes);
  
  // The file couldn't have better than 500:1 compression
  alwaysAssertM(m_length < m_bufferLength * 500, "Compressed file header is corrupted");
  
  uint8* tempBuffer = m_buffer;
  m_buffer = (uint8*)System::alignedMalloc(m_length, 16);
  
  debugAssert(m_buffer);
  debugAssert(isValidHeapPointer(tempBuffer));
  debugAssert(isValidHeapPointer(m_buffer));
  
  unsigned long L = (unsigned long)m_length;
  int64 result = (int64)uncompress(m_buffer, &L, tempBuffer + 4, (uLong)tempLength - 4);
  m_length = L;
  m_bufferLength = m_length;
  
  debugAssertM(result == Z_OK, "BinaryInput/zlib detected corruption in " + m_filename); 
  (void)result;
  
  System::alignedFree(tempBuffer);
 }

Here is the call graph for this function:

void G3D::BinaryInput::endBits ( )

Ends bit-reading.

  {
  debugAssert(m_beginEndBits == 1);
  if (m_bitPos == 0) {
  // Put back the last byte we read
  --m_pos;
  }
  m_beginEndBits = 0;
  m_bitPos = 0;
 }

G3DEndian G3D::BinaryInput::endian ( ) const

inline

  {
  return m_fileEndian;
  }

const uint8* G3D::BinaryInput::getCArray ( )

inline

Returns a pointer to the internal memory buffer. May throw an exception for huge files.

  {
  if (m_alreadyRead > 0 || m_bufferLength < m_length) {
  throw "Cannot getCArray for a huge file";
  }
  return m_buffer;
  }

Here is the caller graph for this function:

std::string G3D::BinaryInput::getFilename ( ) const

inline

  {
  return m_filename;
  }

int64 G3D::BinaryInput::getLength ( ) const

inline

Returns the length of the file in bytes.

  {
  return m_length;
  }

Here is the caller graph for this function:

int64 G3D::BinaryInput::getPosition ( ) const

inline

Returns the current byte position in the file, where 0 is the beginning and getLength() - 1 is the end.

  {
  return m_pos + m_alreadyRead;
  }

bool G3D::BinaryInput::hasMore ( ) const

inline

Returns true if the position is not at the end of the file

  {
  return m_pos + m_alreadyRead < m_length;
  }

Here is the caller graph for this function:

void G3D::BinaryInput::loadIntoMemory	(	int64	startPosition,
		int64	minLength = `0`
	)

private

Ensures that we are able to read at least minLength from startPosition (relative to start of file).

  {
  // Load the next section of the file
  debugAssertM(m_filename != "<memory>", "Read past end of file.");
 
  int64 absPos = m_alreadyRead + m_pos;
 
  if (m_bufferLength < minLength) {
  // The current buffer isn't big enough to hold the chunk we want to read.
  // This happens if there was little memory available during the initial constructor
  // read but more memory has since been freed.
  m_bufferLength = minLength;
  debugAssert(m_freeBuffer);
  m_buffer = (uint8*)System::realloc(m_buffer, m_bufferLength);
  if (m_buffer == NULL) {
  throw "Tried to read a larger memory chunk than could fit in memory. (2)";
  }
  }
 
  m_alreadyRead = startPosition;
 
 # ifdef G3D_WINDOWS
  FILE* file = fopen(m_filename.c_str(), "rb");
  debugAssert(file);
  size_t ret = fseek(file, (off_t)m_alreadyRead, SEEK_SET);
  debugAssert(ret == 0);
  size_t toRead = (size_t)G3D::min(m_bufferLength, m_length - m_alreadyRead);
  ret = fread(m_buffer, 1, toRead, file);
  debugAssert(ret == toRead);
  fclose(file);
  file = NULL;
  
 # else
  FILE* file = fopen(m_filename.c_str(), "rb");
  debugAssert(file);
  int ret = fseeko(file, (off_t)m_alreadyRead, SEEK_SET);
  debugAssert(ret == 0);
  size_t toRead = (size_t)G3D::min<int64>(m_bufferLength, m_length - m_alreadyRead);
  ret = fread(m_buffer, 1, toRead, file);
  debugAssert((size_t)ret == (size_t)toRead);
  fclose(file);
  file = NULL;
 # endif
 
  m_pos = absPos - m_alreadyRead;
  debugAssert(m_pos >= 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

BinaryInput& G3D::BinaryInput::operator= ( const BinaryInput & )

private

bool G3D::BinaryInput::operator== ( const BinaryInput & )

private

uint8 G3D::BinaryInput::operator[] ( int64 n )

inline

Performs bounds checks in debug mode. [] are relative to the start of the file, not the current position. Seeks to the new position before reading (and leaves that as the current position)

  {
  setPosition(n);
  return readUInt8();
  }

Here is the call graph for this function:

void G3D::BinaryInput::prepareToRead ( int64 nbytes )

private

Verifies that at least this number of bytes can be read.

  {
  debugAssertM(m_length > 0, m_filename + " not found or corrupt.");
  debugAssertM(m_pos + nbytes + m_alreadyRead <= m_length, "Read past end of file.");
 
  if (m_pos + nbytes > m_bufferLength) {
  loadIntoMemory(m_pos + m_alreadyRead, nbytes); 
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 G3D::BinaryInput::readBits ( int numBits )

Can only be called between beginBits and endBits

  {
  debugAssert(m_beginEndBits == 1);
 
  uint32 out = 0;
 
  const int total = numBits;
  while (numBits > 0) {
  if (m_bitPos > 7) {
  // Consume a new byte for reading. We do this at the beginning
  // of the loop so that we don't try to read past the end of the file.
  m_bitPos = 0;
  m_bitString = readUInt8();
  }
 
  // Slide the lowest bit of the bitString into
  // the correct position.
  out |= (m_bitString & 1) << (total - numBits);
 
  // Shift over to the next bit
  m_bitString = m_bitString >> 1;
  ++m_bitPos;
  --numBits;
  }
 
  return out;
 }

Here is the call graph for this function:

void G3D::BinaryInput::readBool8 ( )

inline

  {
  return (readInt8() != 0);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryInput::readBytes	(	void *	bytes,
		int64	n
	)

  {
  prepareToRead(n);
  debugAssert(isValidPointer(bytes));
 
  memcpy(bytes, m_buffer + m_pos, n);
  m_pos += n;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Color3 G3D::BinaryInput::readColor3 ( )

  {
  float r = readFloat32();
  float g = readFloat32();
  float b = readFloat32();
  return Color3(r, g, b);
 }

Here is the call graph for this function:

Color4 G3D::BinaryInput::readColor4 ( )

  {
  float r = readFloat32();
  float g = readFloat32();
  float b = readFloat32();
  float a = readFloat32();
  return Color4(r, g, b, a);
 }

Here is the call graph for this function:

std::string G3D::BinaryInput::readFixedLengthString ( int numBytes )

Read a string (which may contain NULLs) of exactly numBytes bytes, including the final terminator if there is one. If there is a NULL in the string before the end, then only the part up to the first NULL is returned although all bytes are read.

  {
  Array<char> str;
  str.resize(numBytes + 1);
 
  // Ensure NULL termination
  str.last() = '\0';
 
  readBytes(str.getCArray(), numBytes);
 
  // Copy up to the first NULL
  return std::string(str.getCArray());
 }

Here is the call graph for this function:

float32 G3D::BinaryInput::readFloat32 ( )

inline

  {
  union {
  uint32 a;
  float32 b;
  };
  a = readUInt32();
  return b;
  } 

Here is the call graph for this function:

Here is the caller graph for this function:

float64 G3D::BinaryInput::readFloat64 ( )

inline

  {
  union {
  uint64 a;
  float64 b;
  };
  a = readUInt64();
  return b;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

int16 G3D::BinaryInput::readInt16 ( )

inline

  {
  uint16 a = readUInt16();
  return *(int16*)&a;
  }

Here is the call graph for this function:

int32 G3D::BinaryInput::readInt32 ( )

inline

  {
  uint32 a = readUInt32();
  return *(int32*)&a;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

int64 G3D::BinaryInput::readInt64 ( )

inline

  {
  uint64 a = readUInt64();
  return *(int64*)&a;
  }

Here is the call graph for this function:

int8 G3D::BinaryInput::readInt8 ( )

inline

  {
  prepareToRead(1);
  return m_buffer[m_pos++];
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::BinaryInput::readString ( int64 maxLength )

Always consumes maxLength characters. Reads a string until NULL or maxLength characters. Does not require NULL termination.

  {
  prepareToRead(maxLength);
 
  int64 n = 0;
  while ((m_buffer[m_pos + n] != '\0') && (n != maxLength)) {
  ++n;
  }
 
  std::string s((char*)(m_buffer + m_pos), n);
 
  m_pos += maxLength;
 
  return s;
 }

Here is the call graph for this function:

std::string G3D::BinaryInput::readString ( )

Reads a string until NULL or end of file.

  {
  prepareToRead(1);
 
  int64 n = 0;
  bool hasNull = true;
 
  while(m_buffer[m_pos + n] != '\0') {
  ++n;
 
  if ((m_pos + m_alreadyRead + n) == m_length) {
  hasNull = false;
  break;
  }
 
  prepareToRead(n + 1);
  }
 
  std::string s((char*)(m_buffer + m_pos), n);
  m_pos += n;
 
  if (hasNull) {
  skip(1);
  }
  
  return s;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::BinaryInput::readString32 ( )

Reads a uint32 and then calls readString(maxLength) with that value as the length.

  {
  int len = readUInt32();
  return readString(len);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::BinaryInput::readStringEven ( )

Reads until NULL or the end of the file is encountered. If the string has odd length (including NULL), reads another byte. This is a common format for 16-bit alignment in files.

  {
  std::string x = readString();
  if (hasMore() && (G3D::isOdd((int)x.length() + 1))) {
  skip(1);
  }
  return x;
 }

Here is the call graph for this function:

std::string G3D::BinaryInput::readStringNewline ( )

Reads a string until NULL, newline ("\r", "\n", "\r\n", "\n\r") or the end of the file is encountered. Consumes the newline.

                                          {
     prepareToRead(1);
 
     int64 n = 0;
     bool hasNull = true;
     bool hasNewline = false;
 
     while(m_buffer[m_pos + n] != '\0') {
         if ((m_pos + m_alreadyRead + n + 1) == m_length) {
             hasNull = false;
             break;
         }
 
         if (isNewline(m_buffer[m_pos + n])) {
             hasNull = false;
             hasNewline = true;
             break;
         }
 
         ++n;
         prepareToRead(n + 1);
     }
 
     std::string s((char*)(m_buffer + m_pos), n);
     m_pos += n;
 
     if (hasNull) {
         skip(1);
     }
     
     if (hasNewline) {
         if ((m_pos + m_alreadyRead + 2) != m_length) {
             prepareToRead(2);
             if (m_buffer[m_pos] == '\r' && m_buffer[m_pos + 1] == '\n') {
                 skip(2);
             } else if (m_buffer[m_pos] == '\n' && m_buffer[m_pos + 1] == '\r') {
                 skip(2);
             } else {
                 skip(1);
             }
         } else {
             skip(1);
         }
     }
 
     return s;
 }

Here is the call graph for this function:

uint16 G3D::BinaryInput::readUInt16 ( )

inline

                         {
         prepareToRead(2);
 
         m_pos += 2;
         if (m_swapBytes) {
             uint8 out[2];
             out[0] = m_buffer[m_pos - 1];
             out[1] = m_buffer[m_pos - 2];
             return *(uint16*)out;
         } else {
             #ifdef G3D_ALLOW_UNALIGNED_WRITES
                 return *(uint16*)(&m_buffer[m_pos - 2]);
             #else
                 uint8 out[2];
                 out[0] = m_buffer[m_pos - 2];
                 out[1] = m_buffer[m_pos - 1];
                 return *(uint16*)out;
             #endif
         }
 
     }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 G3D::BinaryInput::readUInt32 ( )

inline

                        {
         prepareToRead(4);
 
         m_pos += 4;
         if (m_swapBytes) {
             uint8 out[4];
             out[0] = m_buffer[m_pos - 1];
             out[1] = m_buffer[m_pos - 2];
             out[2] = m_buffer[m_pos - 3];
             out[3] = m_buffer[m_pos - 4];
             return *(uint32*)out;
         } else {
             #ifdef G3D_ALLOW_UNALIGNED_WRITES
                 return *(uint32*)(&m_buffer[m_pos - 4]);
             #else
                 uint8 out[4];
                 out[0] = m_buffer[m_pos - 4];
                 out[1] = m_buffer[m_pos - 3];
                 out[2] = m_buffer[m_pos - 2];
                 out[3] = m_buffer[m_pos - 1];
                 return *(uint32*)out;
             #endif
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

uint64 G3D::BinaryInput::readUInt64 ( )

                                {
     prepareToRead(8);
     uint8 out[8];
 
     if (m_swapBytes) {
         out[0] = m_buffer[m_pos + 7];
         out[1] = m_buffer[m_pos + 6];
         out[2] = m_buffer[m_pos + 5];
         out[3] = m_buffer[m_pos + 4];
         out[4] = m_buffer[m_pos + 3];
         out[5] = m_buffer[m_pos + 2];
         out[6] = m_buffer[m_pos + 1];
         out[7] = m_buffer[m_pos + 0];
     } else {
         *(uint64*)out = *(uint64*)(m_buffer + m_pos);
     }
 
     m_pos += 8;
     return *(uint64*)out;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint8 G3D::BinaryInput::readUInt8 ( )

inline

                       {
         prepareToRead(1);
         return ((uint8*)m_buffer)[m_pos++];
     }

Here is the call graph for this function:

Here is the caller graph for this function:

unorm8 G3D::BinaryInput::readUNorm8 ( )

inline

                         {
         return unorm8::fromBits(readUInt8());
     }

Here is the call graph for this function:

Vector2 G3D::BinaryInput::readVector2 ( )

                                  {
     float x = readFloat32();
     float y = readFloat32();
     return Vector2(x, y);
 }

Here is the call graph for this function:

Vector3 G3D::BinaryInput::readVector3 ( )

                                  {
     float x = readFloat32();
     float y = readFloat32();
     float z = readFloat32();
     return Vector3(x, y, z);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector4 G3D::BinaryInput::readVector4 ( )

                                  {
     float x = readFloat32();
     float y = readFloat32();
     float z = readFloat32();
     float w = readFloat32();
     return Vector4(x, y, z, w);
 }

Here is the call graph for this function:

void G3D::BinaryInput::reset ( )

inline

Goes back to the beginning of the file.

                 {
         setPosition(0);
     }

Here is the call graph for this function:

void G3D::BinaryInput::setEndian ( G3DEndian endian )

Change the endian-ness of the file. This only changes the interpretation of the file for future read calls; the underlying data is unmodified.

                                        {
     m_fileEndian = e;
     m_swapBytes = (m_fileEndian != System::machineEndian());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryInput::setPosition ( int64 p )

inline

Sets the position. Cannot set past length. May throw a char* when seeking backwards more than 10 MB on a huge file.

                               {
         debugAssertM(p <= m_length, "Read past end of file");
         m_pos = p - m_alreadyRead;
         if ((m_pos < 0) || (m_pos > m_bufferLength)) {
             loadIntoMemory(m_pos + m_alreadyRead);
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

int64 G3D::BinaryInput::size ( ) const

inline

                       {
         return getLength();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BinaryInput::skip ( int64 n )

inline

Skips ahead n bytes.

                       {
         setPosition(m_pos + m_alreadyRead + n);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

const int64 G3D::BinaryInput::INITIAL_BUFFER_LENGTH

staticprivate

Initial value:

=
        750000000

int64 G3D::BinaryInput::m_alreadyRead

private

When operating on huge files, we cannot load the whole file into memory. This is the file position to which buffer[0] corresponds. Even 32-bit code can load 64-bit files in chunks, so this is not size_t

int G3D::BinaryInput::m_beginEndBits

private

1 when between beginBits and endBits, 0 otherwise.

int G3D::BinaryInput::m_bitPos

private

Next position to read from in bitString during readBits.

uint32 G3D::BinaryInput::m_bitString

private

Bits currently being read by readBits. Contains at most 8 (low) bits. Note that beginBits/readBits actually consumes one extra byte, which will be restored by writeBits.

uint8* G3D::BinaryInput::m_buffer

private

int64 G3D::BinaryInput::m_bufferLength

private

Length of the array referenced by buffer. May go past the end of the file!

G3DEndian G3D::BinaryInput::m_fileEndian

private

is the file big or little endian

std::string G3D::BinaryInput::m_filename

private

bool G3D::BinaryInput::m_freeBuffer

private

When true, the buffer is freed in the destructor.

int64 G3D::BinaryInput::m_length

private

Length of the entire file, in bytes. For the length of the buffer, see bufferLength

int64 G3D::BinaryInput::m_pos

private

Next byte in file, relative to buffer.

bool G3D::BinaryInput::m_swapBytes

private

const bool G3D::BinaryInput::NO_COPY = false

static

false, constant to use with the copyMemory option

The documentation for this class was generated from the following files:

dep/g3dlite/include/G3D/BinaryInput.h
dep/g3dlite/source/BinaryInput.cpp

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation