BinaryInput.h

Go to the documentation of this file.

#ifndef G3D_BinaryInput_h
#define G3D_BinaryInput_h

#ifdef _MSC_VER
// Disable conditional expression is constant, which occurs incorrectly on inlined functions
# pragma warning(push)
# pragma warning( disable : 4127 )
#endif

#include <assert.h>
#include <string>
#include <vector>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdio.h>
#include "G3D/platform.h"
#include "G3D/unorm8.h"
#include "G3D/Array.h"
#include "G3D/Color4.h"
#include "G3D/Color3.h"
#include "G3D/Vector4.h"
#include "G3D/Vector3.h"
#include "G3D/Vector2.h"
#include "G3D/g3dmath.h"
#include "G3D/debug.h"
#include "G3D/System.h"


namespace G3D {

#if defined(G3D_WINDOWS) || defined(G3D_LINUX)
 // Allow writing of integers to non-word aligned locations.
 // This is legal on x86, but not on other platforms.
 #define G3D_ALLOW_UNALIGNED_WRITES
#endif

class BinaryInput {
private:

 // The initial buffer will be no larger than this, but 
 // may grow if a large memory read occurs. 750 MB
 static const int64
 INITIAL_BUFFER_LENGTH =
#ifdef G3D_64BIT
 5000000000L // 5 GB
#else
 750000000 // 750 MB
#endif
 ;

 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;

 void loadIntoMemory(int64 startPosition, int64 minLength = 0);

 void prepareToRead(int64 nbytes);


 // Not implemented on purpose, don't use
 BinaryInput(const BinaryInput&);
 BinaryInput& operator=(const BinaryInput&);
 bool operator==(const BinaryInput&);

 void decompress();
public:

 static const bool NO_COPY;

 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 {
 return m_fileEndian;
 }

 std::string getFilename() const {
 return m_filename;
 }

 uint8 operator[](int64 n) {
 setPosition(n);
 return readUInt8();
 }

 int64 getLength() const {
 return m_length;
 }

 int64 size() const {
 return getLength();
 }

 int64 getPosition() const {
 return m_pos + m_alreadyRead;
 }

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

 void setPosition(int64 p) {
 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);
 }
 }

 void reset() {
 setPosition(0);
 }

 void readBytes(void* bytes, int64 n);

 int8 readInt8() {
 prepareToRead(1);
 return m_buffer[m_pos++];
 }
 
 bool readBool8() {
 return (readInt8() != 0);
 }
 
 uint8 readUInt8() {
 prepareToRead(1);
 return ((uint8*)m_buffer)[m_pos++];
 }
 
 unorm8 readUNorm8() {
 return unorm8::fromBits(readUInt8());
 }

 uint16 readUInt16() {
 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
 }

 }

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

 uint32 readUInt32() {
 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
 }
 }


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

 uint64 readUInt64();

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

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

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

 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) {
 setPosition(m_pos + m_alreadyRead + n);
 }

 bool hasMore() const {
 return m_pos + m_alreadyRead < m_length;
 }

 void beginBits();

 uint32 readBits(int numBits);

 void endBits();

# define DECLARE_READER(ucase, lcase)\
 void read##ucase(lcase* out, int64 n);\
 void read##ucase(std::vector<lcase>& out, int64 n);\
 void read##ucase(Array<lcase>& out, int64 n);

 DECLARE_READER(Bool8, bool)
 DECLARE_READER(UInt8, uint8)
 DECLARE_READER(Int8, int8)
 DECLARE_READER(UInt16, uint16)
 DECLARE_READER(Int16, int16)
 DECLARE_READER(UInt32, uint32)
 DECLARE_READER(Int32, int32)
 DECLARE_READER(UInt64, uint64)
 DECLARE_READER(Int64, int64)
 DECLARE_READER(Float32, float32)
 DECLARE_READER(Float64, float64) 
# undef DECLARE_READER
};


}

#ifdef _MSC_VER
# pragma warning(pop)
#endif

#endif