-// lowlevel.hxx -- routines to handle lowlevel compressed binary IO of
+// lowlevel.cxx -- routines to handle lowlevel compressed binary IO of
// various datatypes
//
// Shamelessly adapted from plib (plib.sourceforge.net) January 2001
//
// Original version Copyright (C) 2000 the plib team
-// Local changes Copyright (C) 2000 Curtis L. Olson - curt@flightgear.org
+// Local changes Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
-// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
// $Id$
-//
+
+
+#ifdef HAVE_CONFIG_H
+# include <simgear_config.h>
+#endif
+
+#include <string.h> // for memcpy()
#include "lowlevel.hxx"
+
static int read_error = false ;
static int write_error = false ;
void sgReadChar ( gzFile fd, char *var )
{
- if ( gzread ( fd, var, sizeof(char) ) == sizeof(char) ) return ;
- read_error = true ;
+ if ( gzread ( fd, var, sizeof(char) ) != sizeof(char) ) {
+ read_error = true ;
+ }
}
void sgWriteChar ( gzFile fd, const char var )
{
- if ( gzwrite ( fd, (void *)(&var), sizeof(char) ) == sizeof(char) ) return ;
- write_error = true ;
+ if ( gzwrite ( fd, (void *)(&var), sizeof(char) ) != sizeof(char) ) {
+ write_error = true ;
+ }
}
void sgReadFloat ( gzFile fd, float *var )
{
- if ( gzread ( fd, var, sizeof(float) ) == sizeof(float) ) return ;
- read_error = true ;
+ union { float v; uint32_t u; } buf;
+ if ( gzread ( fd, &buf.u, sizeof(float) ) != sizeof(float) ) {
+ read_error = true ;
+ }
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( &buf.u );
+ }
+ *var = buf.v;
}
void sgWriteFloat ( gzFile fd, const float var )
{
- if ( gzwrite ( fd, (void *)(&var), sizeof(float) ) == sizeof(float) )
- return ;
- write_error = true ;
+ union { float v; uint32_t u; } buf;
+ buf.v = var;
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( &buf.u );
+ }
+ if ( gzwrite ( fd, (void *)(&buf.u), sizeof(float) ) != sizeof(float) ) {
+ write_error = true ;
+ }
}
void sgReadDouble ( gzFile fd, double *var )
{
- if ( gzread ( fd, var, sizeof(double) ) == sizeof(double) ) return ;
- read_error = true ;
+ union { double v; uint64_t u; } buf;
+ if ( gzread ( fd, &buf.u, sizeof(double) ) != sizeof(double) ) {
+ read_error = true ;
+ }
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( &buf.u );
+ }
+ *var = buf.v;
}
void sgWriteDouble ( gzFile fd, const double var )
{
- if ( gzwrite ( fd, (void *)(&var), sizeof(double) ) == sizeof(double) )
- return ;
- write_error = true ;
+ union { double v; uint64_t u; } buf;
+ buf.v = var;
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( &buf.u );
+ }
+ if ( gzwrite ( fd, (void *)(&buf.u), sizeof(double) ) != sizeof(double) ) {
+ write_error = true ;
+ }
}
void sgReadUInt ( gzFile fd, unsigned int *var )
{
- if ( gzread ( fd, var, sizeof(unsigned int) ) == sizeof(unsigned int) )
- return ;
- read_error = true ;
+ if ( gzread ( fd, var, sizeof(unsigned int) ) != sizeof(unsigned int) ) {
+ read_error = true ;
+ }
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( (uint32_t *)var);
+ }
}
void sgWriteUInt ( gzFile fd, const unsigned int var )
{
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( (uint32_t *)&var);
+ }
if ( gzwrite ( fd, (void *)(&var), sizeof(unsigned int) )
- == sizeof(unsigned int) )
- return ;
- write_error = true ;
+ != sizeof(unsigned int) )
+ {
+ write_error = true ;
+ }
}
void sgReadInt ( gzFile fd, int *var )
{
- if ( gzread ( fd, var, sizeof(int) ) == sizeof(int) ) return ;
- read_error = true ;
+ if ( gzread ( fd, var, sizeof(int) ) != sizeof(int) ) {
+ read_error = true ;
+ }
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( (uint32_t *)var);
+ }
}
void sgWriteInt ( gzFile fd, const int var )
{
- if ( gzwrite ( fd, (void *)(&var), sizeof(int) ) == sizeof(int) ) return ;
- write_error = true ;
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( (uint32_t *)&var);
+ }
+ if ( gzwrite ( fd, (void *)(&var), sizeof(int) ) != sizeof(int) ) {
+ write_error = true ;
+ }
}
-void sgReadLong ( gzFile fd, long int *var )
+void sgReadLong ( gzFile fd, int32_t *var )
{
- if ( gzread ( fd, var, sizeof(long int) ) == sizeof(long int) ) return ;
- read_error = true ;
+ if ( gzread ( fd, var, sizeof(int32_t) ) != sizeof(int32_t) ) {
+ read_error = true ;
+ }
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( (uint32_t *)var);
+ }
}
-void sgWriteLong ( gzFile fd, const long int var )
+void sgWriteLong ( gzFile fd, const int32_t var )
{
- if ( gzwrite ( fd, (void *)(&var), sizeof(long int) ) == sizeof(long int) )
- return ;
- write_error = true ;
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( (uint32_t *)&var);
+ }
+ if ( gzwrite ( fd, (void *)(&var), sizeof(int32_t) )
+ != sizeof(int32_t) )
+ {
+ write_error = true ;
+ }
+}
+
+
+void sgReadLongLong ( gzFile fd, int64_t *var )
+{
+ if ( gzread ( fd, var, sizeof(int64_t) ) != sizeof(int64_t) ) {
+ read_error = true ;
+ }
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( (uint64_t *)var);
+ }
+}
+
+
+void sgWriteLongLong ( gzFile fd, const int64_t var )
+{
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( (uint64_t *)&var);
+ }
+ if ( gzwrite ( fd, (void *)(&var), sizeof(int64_t) )
+ != sizeof(int64_t) )
+ {
+ write_error = true ;
+ }
}
void sgReadUShort ( gzFile fd, unsigned short *var )
{
- if ( gzread ( fd, var, sizeof(unsigned short) ) == sizeof(unsigned short) )
- return ;
- read_error = true ;
+ if ( gzread ( fd, var, sizeof(unsigned short) ) != sizeof(unsigned short) ){
+ read_error = true ;
+ }
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( (uint16_t *)var);
+ }
}
void sgWriteUShort ( gzFile fd, const unsigned short var )
{
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( (uint16_t *)&var);
+ }
if ( gzwrite ( fd, (void *)(&var), sizeof(unsigned short) )
- == sizeof(unsigned short) )
- return ;
- write_error = true ;
+ != sizeof(unsigned short) )
+ {
+ write_error = true ;
+ }
}
void sgReadShort ( gzFile fd, short *var )
{
- if ( gzread ( fd, var, sizeof(short) ) == sizeof(short) ) return ;
- read_error = true ;
+ if ( gzread ( fd, var, sizeof(short) ) != sizeof(short) ) {
+ read_error = true ;
+ }
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( (uint16_t *)var);
+ }
}
void sgWriteShort ( gzFile fd, const short var )
{
- if ( gzwrite ( fd, (void *)(&var), sizeof(short) ) == sizeof(short) ) return ;
- write_error = true ;
+ if ( sgIsBigEndian() ) {
+ sgEndianSwap( (uint16_t *)&var);
+ }
+ if ( gzwrite ( fd, (void *)(&var), sizeof(short) ) != sizeof(short) ) {
+ write_error = true ;
+ }
}
void sgReadFloat ( gzFile fd, const unsigned int n, float *var )
{
- if ( gzread ( fd, var, sizeof(float) * n ) == (int)(sizeof(float) * n) )
- return ;
- read_error = true ;
+ if ( gzread ( fd, var, sizeof(float) * n ) != (int)(sizeof(float) * n) ) {
+ read_error = true ;
+ }
+ if ( sgIsBigEndian() ) {
+ for ( unsigned int i = 0; i < n; ++i ) {
+ sgEndianSwap( (uint32_t *)var++);
+ }
+ }
}
void sgWriteFloat ( gzFile fd, const unsigned int n, const float *var )
{
+ if ( sgIsBigEndian() ) {
+ float *swab = new float[n];
+ float *ptr = swab;
+ memcpy( swab, var, sizeof(float) * n );
+ for ( unsigned int i = 0; i < n; ++i ) {
+ sgEndianSwap( (uint32_t *)ptr++);
+ }
+ var = swab;
+ }
if ( gzwrite ( fd, (void *)var, sizeof(float) * n )
- == (int)(sizeof(float) * n) )
- return ;
- write_error = true ;
+ != (int)(sizeof(float) * n) )
+ {
+ write_error = true ;
+ }
}
void sgReadDouble ( gzFile fd, const unsigned int n, double *var )
{
- if ( gzread ( fd, var, sizeof(double) * n ) == (int)(sizeof(double) * n) )
- return ;
- read_error = true ;
+ if ( gzread ( fd, var, sizeof(double) * n ) != (int)(sizeof(double) * n) ) {
+ read_error = true ;
+ }
+ if ( sgIsBigEndian() ) {
+ for ( unsigned int i = 0; i < n; ++i ) {
+ sgEndianSwap( (uint64_t *)var++);
+ }
+ }
}
void sgWriteDouble ( gzFile fd, const unsigned int n, const double *var )
{
+ if ( sgIsBigEndian() ) {
+ double *swab = new double[n];
+ double *ptr = swab;
+ memcpy( swab, var, sizeof(double) * n );
+ for ( unsigned int i = 0; i < n; ++i ) {
+ sgEndianSwap( (uint64_t *)ptr++);
+ }
+ var = swab;
+ }
if ( gzwrite ( fd, (void *)var, sizeof(double) * n )
- == (int)(sizeof(double) * n) ) return ;
- write_error = true ;
+ != (int)(sizeof(double) * n) )
+ {
+ write_error = true ;
+ }
}
void sgReadBytes ( gzFile fd, const unsigned int n, void *var )
{
- if ( n == 0)
- return;
- if ( gzread ( fd, var, n ) == (int)n )
- return ;
- read_error = true ;
+ if ( n == 0) return;
+ if ( gzread ( fd, var, n ) != (int)n ) {
+ read_error = true ;
+ }
}
void sgWriteBytes ( gzFile fd, const unsigned int n, const void *var )
{
- if ( n == 0)
- return;
- if ( gzwrite ( fd, (void *)var, n ) == (int)n )
- return ;
- write_error = true ;
+ if ( n == 0) return;
+ if ( gzwrite ( fd, (void *)var, n ) != (int)n ) {
+ write_error = true ;
+ }
}
void sgReadUShort ( gzFile fd, const unsigned int n, unsigned short *var )
{
if ( gzread ( fd, var, sizeof(unsigned short) * n )
- == (int)(sizeof(unsigned short) * n) )
- return ;
- read_error = true ;
+ != (int)(sizeof(unsigned short) * n) )
+ {
+ read_error = true ;
+ }
+ if ( sgIsBigEndian() ) {
+ for ( unsigned int i = 0; i < n; ++i ) {
+ sgEndianSwap( (uint16_t *)var++);
+ }
+ }
}
void sgWriteUShort ( gzFile fd, const unsigned int n, const unsigned short *var )
{
+ if ( sgIsBigEndian() ) {
+ unsigned short *swab = new unsigned short[n];
+ unsigned short *ptr = swab;
+ memcpy( swab, var, sizeof(unsigned short) * n );
+ for ( unsigned int i = 0; i < n; ++i ) {
+ sgEndianSwap( (uint16_t *)ptr++);
+ }
+ var = swab;
+ }
if ( gzwrite ( fd, (void *)var, sizeof(unsigned short) * n )
- == (int)(sizeof(unsigned short) * n) )
- return ;
- write_error = true ;
+ != (int)(sizeof(unsigned short) * n) )
+ {
+ write_error = true ;
+ }
}
void sgReadShort ( gzFile fd, const unsigned int n, short *var )
{
if ( gzread ( fd, var, sizeof(short) * n )
- == (int)(sizeof(short) * n) )
- return ;
- read_error = true ;
+ != (int)(sizeof(short) * n) )
+ {
+ read_error = true ;
+ }
+ if ( sgIsBigEndian() ) {
+ for ( unsigned int i = 0; i < n; ++i ) {
+ sgEndianSwap( (uint16_t *)var++);
+ }
+ }
}
void sgWriteShort ( gzFile fd, const unsigned int n, const short *var )
{
+ if ( sgIsBigEndian() ) {
+ short *swab = new short[n];
+ short *ptr = swab;
+ memcpy( swab, var, sizeof(short) * n );
+ for ( unsigned int i = 0; i < n; ++i ) {
+ sgEndianSwap( (uint16_t *)ptr++);
+ }
+ var = swab;
+ }
if ( gzwrite ( fd, (void *)var, sizeof(short) * n )
- == (int)(sizeof(short) * n) )
- return ;
- write_error = true ;
+ != (int)(sizeof(short) * n) )
+ {
+ write_error = true ;
+ }
}
void sgReadUInt ( gzFile fd, const unsigned int n, unsigned int *var )
{
if ( gzread ( fd, var, sizeof(unsigned int) * n )
- == (int)(sizeof(unsigned int) * n) )
- return ;
- read_error = true ;
+ != (int)(sizeof(unsigned int) * n) )
+ {
+ read_error = true ;
+ }
+ if ( sgIsBigEndian() ) {
+ for ( unsigned int i = 0; i < n; ++i ) {
+ sgEndianSwap( (uint32_t *)var++);
+ }
+ }
}
void sgWriteUInt ( gzFile fd, const unsigned int n, const unsigned int *var )
{
+ if ( sgIsBigEndian() ) {
+ unsigned int *swab = new unsigned int[n];
+ unsigned int *ptr = swab;
+ memcpy( swab, var, sizeof(unsigned int) * n );
+ for ( unsigned int i = 0; i < n; ++i ) {
+ sgEndianSwap( (uint32_t *)ptr++);
+ }
+ var = swab;
+ }
if ( gzwrite ( fd, (void *)var, sizeof(unsigned int) * n )
- == (int)(sizeof(unsigned int) * n) )
- return ;
- write_error = true ;
+ != (int)(sizeof(unsigned int) * n) )
+ {
+ write_error = true ;
+ }
}
void sgReadInt ( gzFile fd, const unsigned int n, int *var )
{
if ( gzread ( fd, var, sizeof(int) * n )
- == (int)(sizeof(int) * n) )
- return ;
- read_error = true ;
+ != (int)(sizeof(int) * n) )
+ {
+ read_error = true ;
+ }
+ if ( sgIsBigEndian() ) {
+ for ( unsigned int i = 0; i < n; ++i ) {
+ sgEndianSwap( (uint32_t *)var++);
+ }
+ }
}
void sgWriteInt ( gzFile fd, const unsigned int n, const int *var )
{
+ if ( sgIsBigEndian() ) {
+ int *swab = new int[n];
+ int *ptr = swab;
+ memcpy( swab, var, sizeof(int) * n );
+ for ( unsigned int i = 0; i < n; ++i ) {
+ sgEndianSwap( (uint32_t *)ptr++);
+ }
+ var = swab;
+ }
if ( gzwrite ( fd, (void *)var, sizeof(int) * n )
- == (int)(sizeof(int) * n) )
- return ;
- write_error = true ;
+ != (int)(sizeof(int) * n) )
+ {
+ write_error = true ;
+ }
}
}
-void sgReadVec2 ( gzFile fd, sgVec2 var ) { sgReadFloat ( fd, 2, var ) ; }
-void sgWriteVec2 ( gzFile fd, const sgVec2 var ) {
- sgWriteFloat ( fd, 2, var ) ;
-}
-
-void sgReadVec3 ( gzFile fd, sgVec3 var ) { sgReadFloat ( fd, 3, var ) ; }
-void sgWriteVec3 ( gzFile fd, const sgVec3 var ) {
- sgWriteFloat ( fd, 3, var ) ;
-}
-
-void sgReaddVec3 ( gzFile fd, sgdVec3 var ) { sgReadDouble ( fd, 3, var ) ; }
-void sgWritedVec3 ( gzFile fd, const sgdVec3 var ) {
- sgWriteDouble ( fd, 3, var ) ;
-}
-
-void sgReadVec4 ( gzFile fd, sgVec4 var ) { sgReadFloat ( fd, 4, var ) ; }
-void sgWriteVec4 ( gzFile fd, const sgVec4 var ) {
- sgWriteFloat ( fd, 4, var ) ;
-}
-
-void sgReadMat4 ( gzFile fd, sgMat4 var ) {
- sgReadFloat ( fd, 16, (float *)var ) ;
-}
-void sgWriteMat4 ( gzFile fd, const sgMat4 var ) {
- sgWriteFloat ( fd, 16, (float *)var ) ;
-}
projects / simgear.git / blobdiff