Contents Functions Classes Topics User Forum CVS 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 ) // signed/unsigned warnings (TODO: revisit) # pragma warning (disable:4267) #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/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_WIN32) || 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. 50 MB enum {INITIAL_BUFFER_LENGTH = 50000000}; G3DEndian fileEndian; std::string filename; bool swapBytes; int bitPos; uint32 bitString; int beginEndBits; size_t alreadyRead; int length; int bufferLength; uint8* buffer; int pos; bool freeBuffer; void loadIntoMemory(int startPosition, int minLength = 0); inline void prepareToRead(size_t bytes) { debugAssertM((int)pos + (int)bytes + (int)alreadyRead <= (int)length, "Read past end of file."); if ((int)pos + (int)bytes > (int)bufferLength) { loadIntoMemory((int)pos + (int)alreadyRead, (int)bytes); } } // Not implemented on purpose, don't use BinaryInput(const BinaryInput&); BinaryInput& operator=(const BinaryInput&); bool operator==(const BinaryInput&); public: static const bool NO_COPY; BinaryInput( const std::string& filename, G3DEndian fileEndian, bool compressed = false); BinaryInput( const uint8* data, int dataLen, G3DEndian dataEndian, bool compressed = false, bool copyMemory = true); virtual ~BinaryInput(); std::string getFilename() const { return filename; } const uint8* getCArray() const { if (alreadyRead > 0) { throw "Cannot getCArray for a huge file"; } return buffer; } inline const uint8 operator[](int n) { setPosition(n); return readUInt8(); } inline int getLength() const { return length; } inline int size() const { return getLength(); } inline int getPosition() const { return (int)pos + (int)alreadyRead; } inline void setPosition(int p) { debugAssertM(p <= length, "Read past end of file"); pos = (int)p - (int)alreadyRead; if ((pos < 0) || (pos > bufferLength)) { loadIntoMemory((int)pos + (int)alreadyRead); } } inline void reset() { setPosition(0); } inline int8 readInt8() { prepareToRead(1); return buffer[pos++]; } inline bool readBool8() { return (readInt8() != 0); } inline uint8 readUInt8() { prepareToRead(1); return ((uint8*)buffer)[pos++]; } uint16 inline readUInt16() { prepareToRead(2); pos += 2; if (swapBytes) { uint8 out[2]; out[0] = buffer[pos - 1]; out[1] = buffer[pos - 2]; return *(uint16*)out; } else { #ifdef G3D_ALLOW_UNALIGNED_WRITES return *(uint16*)(&buffer[pos - 2]); #else uint8 out[2]; out[0] = buffer[pos - 2]; out[1] = buffer[pos - 1]; return *(uint16*)out; #endif } } inline int16 readInt16() { uint16 a = readUInt16(); return *(int16*)&a; } inline uint32 readUInt32() { prepareToRead(4); pos += 4; if (swapBytes) { uint8 out[4]; out[0] = buffer[pos - 1]; out[1] = buffer[pos - 2]; out[2] = buffer[pos - 3]; out[3] = buffer[pos - 4]; return *(uint32*)out; } else { #ifdef G3D_ALLOW_UNALIGNED_WRITES return *(uint32*)(&buffer[pos - 4]); #else uint8 out[4]; out[0] = buffer[pos - 4]; out[1] = buffer[pos - 3]; out[2] = buffer[pos - 2]; out[3] = buffer[pos - 1]; return *(uint32*)out; #endif } } inline int32 readInt32() { uint32 a = readUInt32(); return *(int32*)&a; } uint64 readUInt64(); inline int64 readInt64() { uint64 a = readUInt64(); return *(int64*)&a; } inline float32 readFloat32() { uint32 a = readUInt32(); return *(float32*)&a; } inline float64 readFloat64() { uint64 a = readUInt64(); return *(float64*)&a; } void readBytes(int n, void* bytes); inline void readBytes(void* bytes, int n) { readBytes(n, bytes); } std::string readString(int n); std::string readString(); std::string readStringEven(); std::string readString32(); Vector4 readVector4(); Vector3 readVector3(); Vector2 readVector2(); Color4 readColor4(); Color3 readColor3(); inline void skip(int n) { setPosition((int)pos + (int)alreadyRead + n); } inline bool hasMore() const { return (int)pos + (int)alreadyRead < (int)length; } void beginBits(); uint32 readBits(int numBits); void endBits(); # define DECLARE_READER(ucase, lcase)\ void read##ucase(lcase* out, int n);\ void read##ucase(std::vector<lcase>& out, int n);\ void read##ucase(Array<lcase>& out, int 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 }; } #endif #ifdef _MSC_VER # pragma warning(pop) #endif Hosted by