BinaryOutput.h

Go to the documentation of this file.

#ifndef G3D_BinaryOutput_h
#define G3D_BinaryOutput_h

#include "G3D/platform.h"
#include <assert.h>
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdio.h>
#include "G3D/unorm8.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/BinaryInput.h"
#include "G3D/System.h"

#ifdef _MSC_VER
# pragma warning (push)
// Conditional is constant (wrong in inline)
# pragma warning (disable : 4127)
#endif
namespace G3D {

class BinaryOutput {
private:
 std::string m_filename;

 bool m_committed;

 int m_beginEndBits;

 int8 m_bitString;

 int m_bitPos;

 // True if the file endianess does not match the machine endian
 bool m_swapBytes;

 G3DEndian m_fileEndian;

 uint8* m_buffer;
 
 size_t m_bufferLen;

 size_t m_maxBufferLen;

 int64 m_pos;

 bool m_init;

 int64 m_alreadyWritten; 

 bool m_ok;

 void reserveBytesWhenOutOfMemory(size_t bytes);

 void reallocBuffer(size_t bytes, size_t oldBufferLen);

 inline void reserveBytes(size_t bytes) {
 debugAssert(bytes > 0);
 size_t oldBufferLen = m_bufferLen;

 m_bufferLen = max(m_bufferLen, (size_t)(m_pos + bytes));
 if (m_bufferLen > m_maxBufferLen) {
 reallocBuffer(bytes, oldBufferLen);
 }
 }

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

public:

 BinaryOutput();

 BinaryOutput(
 const std::string& filename,
 G3DEndian fileEndian);

 ~BinaryOutput();
 
 void compress(int level = 9);

 bool ok() const;

 inline const uint8* getCArray() const {
 return m_buffer;
 }

 void setEndian(G3DEndian fileEndian);

 G3DEndian endian() const {
 return m_fileEndian;
 }

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

 void commit(bool flush = true);

 void commit(uint8*);

 void reset();


 inline int64 length() const {
 return m_bufferLen + m_alreadyWritten;
 }

 inline int64 size() const {
 return length();
 }

 inline void setLength(int64 n) {
 n = n - m_alreadyWritten;

 if (n < 0) {
 throw "Cannot resize huge files to be shorter.";
 }

 if (n < (int64)m_bufferLen) {
 m_pos = n;
 }
 if (n > (int64)m_bufferLen) {
 reserveBytes((size_t)(n - m_bufferLen));
 }
 }

 inline int64 position() const {
 return m_pos + m_alreadyWritten;
 }


 inline void setPosition(int64 p) {
 p = p - m_alreadyWritten;

 if (p > (int64)m_bufferLen) {
 setLength((int)(p + (int64)m_alreadyWritten));
 }

 if (p < 0) {
 throw "Cannot seek more than 10 MB backwards on huge files.";
 }

 m_pos = (int)p;
 }


 void writeBytes
 (const void* b,
 size_t count) {

 reserveBytes(count);
 debugAssert(m_pos >= 0);
 debugAssert(m_bufferLen >= count);
 System::memcpy(m_buffer + m_pos, b, count);
 m_pos += count;
 }

 inline void writeInt8(int8 i) {
 reserveBytes(1);
 m_buffer[m_pos] = *(uint8*)&i;
 ++m_pos;
 }

 inline void writeBool8(bool b) {
 writeInt8(b ? 1 : 0);
 }

 inline void writeUInt8(uint8 i) {
 reserveBytes(1);
 m_buffer[m_pos] = i;
 ++m_pos;
 }

 inline void writeUNorm8(unorm8 i) {
 writeUInt8(i.bits());
 }

 void writeUInt16(uint16 u);

 inline void writeInt16(int16 i) {
 writeUInt16(*(uint16*)&i);
 }

 void writeUInt32(uint32 u);

 inline void writeInt32(int32 i) {
 debugAssert(m_beginEndBits == 0);
 writeUInt32(*(uint32*)&i);
 }

 void writeUInt64(uint64 u);

 inline void writeInt64(int64 i) {
 writeUInt64(*(uint64*)&i);
 }

 inline void writeFloat32(float32 f) {
 debugAssert(m_beginEndBits == 0);
 union {
 float32 a;
 uint32 b;
 };
 a = f;
 writeUInt32(b);
 }

 inline void writeFloat64(float64 f) {
 union {
 float64 a;
 uint64 b;
 };
 a = f;
 writeUInt64(b);
 }

 inline void writeString(const std::string& s) {
 writeString(s.c_str());
 }

 inline void writeString(const std::string& s, int len) {
 const int pad = len - ((int)s.length() + 1);
 if (pad >= 0) {
 writeString(s.c_str());
 for (int i = 0; i < pad; ++i) {
 writeUInt8(0);
 }
 } else {
 // Truncate
 writeBytes(s.c_str(), len);
 }
 }

 void writeString(const char* s);

 void writeStringEven(const std::string& s) {
 writeStringEven(s.c_str());
 }

 void writeStringEven(const char* s);

 void writeString32(const char* s);

 void writeString32(const std::string& s) {
 writeString32(s.c_str());
 }

 void writeVector4(const Vector4& v);

 void writeVector3(const Vector3& v);

 void writeVector2(const Vector2& v);

 void writeColor4(const Color4& v);

 void writeColor3(const Color3& v);

 inline void skip(int n) {
 if (m_pos + n > (int64)m_bufferLen) {
 setLength(m_pos + m_alreadyWritten + n);
 }
 m_pos += n;
 }

 void beginBits();

 void writeBits(uint32 bitString, int numBits);

 void endBits();


# define DECLARE_WRITER(ucase, lcase)\
 void write##ucase(const lcase* out, int n);\
 void write##ucase(const std::vector<lcase>& out, int n);\
 void write##ucase(const Array<lcase>& out, int n);

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

};

}

#ifdef _MSC_VER
# pragma warning (pop)
#endif

#endif