gee_io.h

Go to the documentation of this file.

/* -*- C++ -*- */

/* COPYRIGHT
 *
 * This file is part of the Visual Effects Engine - VEE
 *
 * Read the "VEE-LICENSE" file for the license.
 *
 * Authors & Copyright:   
 *
 * Tommi Ilmonen, Tuukka Heikura, Marko Myllymaa and 
 * Janne Kontkanen 2001-2004
 *
 * Additional copyrights: Tekes 2003-2004
 *
 * firstname.lastname@hut.fi
 *
 */

#ifndef GEE_IO_H
#define GEE_IO_H

#include <di_io_defs.h>
#include <di_types.h>

#include <vee_vector2.h>
#include <vee_vector3.h>
#include <vee_vector4.h>

#include <vee_matrix2.h>
#include <vee_matrix3.h>
#include <vee_matrix4.h>

#include <vee_color.h>

#include <stdio.h>

#include <string>

class GEE_Io
{
public:
  GEE_Io() {}
  virtual ~GEE_Io() {}

  virtual long position() = 0;
  virtual bool seekPosition(long) = 0;
  
  virtual bool writev(const void *, int) = 0;
  virtual bool write1(char) = 0;
  virtual bool write2(short) = 0;
  virtual bool write4(int) = 0;
  virtual bool write4v(const int *, int) = 0;
  virtual bool write8(llong) = 0;
  virtual bool write8v(const llong *, int) = 0;
  virtual bool writeString(const char *) = 0;
  virtual bool writeNullTerminatedString(const char *) = 0;

  virtual void  readv(void *, int) = 0;
  virtual char  read1() = 0;
  virtual short read2() = 0;
  virtual int   read4() = 0;
  virtual void  read4v(int *, int) = 0;
  virtual llong read8() = 0;
  virtual void  read8v(llong *, int) = 0;
  virtual char *readString() = 0;
  virtual char *readNullTerminatedString() = 0;


  // Utility functions to simplify the usage:

  bool writeByte(char x)      { return write1(x); }
  bool writeInt16(short x)    { return write2(x); }
  bool writeInt32(int x)      { return write4(x); }
  bool writeInt64(llong x)    { return write8(x); }
  bool writeFloat32(float x)  { return write4(* (int *) (&x)); }
  bool writeFloat32v(const float *x, int n)  { return write4v((int *) x, n); }
  bool writeFloat64(double x) { return write8(* (llong *) (&x)); }
  bool writeFloat64v(const double *x, int n)  { return write8v((llong *) x, n); }

  bool writeVector2(const VEE_Vector2 &v) { return write4v((const int *) & v, 2); }
  bool writeVector3(const VEE_Vector3 &v) { return write4v((const int *) & v, 3); }
  bool writeVector4(const VEE_Vector4 &v) { return write4v((const int *) & v, 4); }

  bool writeMatrix2(const VEE_Matrix2 &v) { return write4v((const int *) & v, 4); }
  bool writeMatrix3(const VEE_Matrix3 &v) { return write4v((const int *) & v, 9); }
  bool writeMatrix4(const VEE_Matrix4 &v) { return write4v((const int *) & v, 16); }
  bool writeMatrix4d(const VEE_Matrix4d &v) { return write8v((const llong *) & v[0][0], 16); }

  bool writeRgba(const VEE_Rgba &color) { return write4v((const int *) & color, 5); }
  bool writeHsva(const VEE_Hsva &color) { return write4v((const int *) & color, 5); }

  bool writeStdString(std::string &str) { return writeString(str.c_str()); }

  char  readByte()  { return read1(); }
  short readInt16() { return read2(); }
  int   readInt32() { return read4(); }
  llong readInt64() { return read8(); }
  float readFloat32()  { int x = read4(); return * ((float *) & x); }
  void readFloat32v(float *x, int n)  { read4v((int *) x, n); }
  double readFloat64() { llong x = read8(); return * ((double *) & x); }
  void readFloat64v(double *x, int n)  { read8v((llong *) x, n); }

  VEE_Vector2 readVector2() { VEE_Vector2 v; read4v((int*)&v, 2); return v; }
  VEE_Vector3 readVector3() { VEE_Vector3 v; read4v((int*)&v, 3); return v; }
  VEE_Vector4 readVector4() { VEE_Vector4 v; read4v((int*)&v, 4); return v; }

  VEE_Matrix2 readMatrix2() { VEE_Matrix2 v; read4v((int*)&v, 4); return v; }
  VEE_Matrix3 readMatrix3() { VEE_Matrix3 v; read4v((int*)&v, 9); return v; }
  VEE_Matrix4 readMatrix4() { VEE_Matrix4 v; read4v((int*)&v, 16); return v; }
  VEE_Matrix4d readMatrix4d() { VEE_Matrix4d v; read8v((llong*) &v[0][0], 16); return v; }

  VEE_Rgba readRgba() { VEE_Rgba v; read4v((int*)&v, 5); return v; }
  VEE_Hsva readHsva() { VEE_Hsva v; read4v((int*)&v, 5); return v; }

  void readStdString(std::string &str);
  void readNullTerminatedStdString(std::string &str);
};


class GEE_File : public GEE_Io
{
public:
  GEE_File();
  virtual ~GEE_File();

  void setLittleEndian(bool littleEndian) { m_littleEndian = littleEndian; }
  
  bool open(const char *, DI_IoMode mode);
  bool close();

  virtual long position();
  virtual bool seekPosition(long);

  virtual bool writev(const void *, int);
  virtual bool write1(char);
  virtual bool write2(short);
  virtual bool write4(int);
  virtual bool write4v(const int *, int);
  virtual bool write8(llong);
  virtual bool write8v(const llong *, int);
  virtual bool writeString(const char *);
  virtual bool writeNullTerminatedString(const char *);

  virtual void  readv(void *, int);
  virtual char  read1();
  virtual short read2();
  virtual int   read4();
  virtual void  read4v(int *, int);
  virtual llong read8();
  virtual void  read8v(llong *, int);
  virtual char *readString();
  virtual char *readNullTerminatedString();

  static void test(bool littleEndian = true);

protected:

  FILE * m_file;
  bool   m_littleEndian;
};


class GEE_IoPackage
{
public:
  std::string m_directory;
  GEE_Io    * m_io;
  int         m_version;
};

#endif

---