2004-03-03 16:00:51 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* VCGLib o o *
|
|
|
|
* Visual and Computer Graphics Library o o *
|
|
|
|
* _ O _ *
|
|
|
|
* Copyright(C) 2004 \/)\/ *
|
|
|
|
* Visual Computing Lab /\/| *
|
|
|
|
* ISTI - Italian National Research Council | *
|
|
|
|
* \ *
|
|
|
|
* All rights reserved. *
|
|
|
|
* *
|
|
|
|
* 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 *
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
|
|
* (at your option) any later version. *
|
|
|
|
* *
|
|
|
|
* This program is distributed in the hope that it will be useful, *
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
|
|
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
|
|
|
|
* for more details. *
|
|
|
|
* *
|
|
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
|
|
Acknowlegments
|
|
|
|
Portions of this file were based on the original code of the Ply library
|
|
|
|
of Greg Turk and on the work of Claudio Rocchini
|
|
|
|
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
History
|
|
|
|
|
|
|
|
$Log: not supported by cvs2svn $
|
2007-05-11 10:21:45 +02:00
|
|
|
Revision 1.12 2006/01/27 09:09:10 corsini
|
|
|
|
Fix signed/unsigned mismatch
|
|
|
|
|
2006-01-27 10:09:10 +01:00
|
|
|
Revision 1.11 2005/12/02 00:00:53 cignoni
|
|
|
|
Moved and corrected interpret_texture_name from plystuff.h to plylib.cpp
|
|
|
|
|
2005-12-02 01:00:53 +01:00
|
|
|
Revision 1.10 2005/11/26 00:22:46 cignoni
|
|
|
|
added untested code of interpret_texture
|
|
|
|
|
2005-11-26 01:22:46 +01:00
|
|
|
Revision 1.9 2005/11/12 07:07:47 cignoni
|
|
|
|
Changed Offset types to remove warnings
|
|
|
|
|
2005-11-12 08:07:47 +01:00
|
|
|
Revision 1.8 2005/03/15 11:46:52 cignoni
|
|
|
|
Cleaning of the automatic bbox caching support for ply files. First working version.
|
|
|
|
|
2005-03-15 12:46:52 +01:00
|
|
|
Revision 1.7 2005/01/03 10:35:59 cignoni
|
|
|
|
Improved the compatibility for ply format for faces having the list size (e.g. number of vertexes of a face) as a char instead of a uchar.
|
|
|
|
Added a couple of new face descriptors, corrected a bug in error reporting function (and restructured) and translated a few comments.
|
|
|
|
Thanks to Patrick Min for the careful bug reporting
|
|
|
|
|
2005-01-03 11:35:59 +01:00
|
|
|
Revision 1.6 2004/06/23 15:36:57 cignoni
|
|
|
|
Restructured management of error, now the standard open for any mesh type return the error code, the default success value is zero
|
|
|
|
Any import class has a method ErrorMsg that give a verbal description of an error code.
|
|
|
|
|
2004-06-23 17:36:57 +02:00
|
|
|
Revision 1.5 2004/06/23 00:06:45 ponchio
|
|
|
|
Moved #define LITTLE_MACHINE outside of #ifdef WIN32 (linux on PC is little too).
|
|
|
|
|
2004-06-23 02:06:45 +02:00
|
|
|
Revision 1.4 2004/05/12 17:21:08 ganovelli
|
|
|
|
inclusion of io.h removed (unnecessary)
|
|
|
|
|
2004-05-12 19:21:08 +02:00
|
|
|
Revision 1.3 2004/05/12 10:13:29 ganovelli
|
|
|
|
direct.h was included also without WIN32 definition
|
|
|
|
|
2004-05-12 12:13:29 +02:00
|
|
|
Revision 1.2 2004/04/06 21:48:50 cignoni
|
|
|
|
Commented out unused parameter names
|
|
|
|
|
2004-04-06 23:48:50 +02:00
|
|
|
Revision 1.1 2004/03/03 15:00:51 cignoni
|
|
|
|
Initial commit
|
|
|
|
|
2004-03-03 16:00:51 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
|
2007-05-11 10:21:45 +02:00
|
|
|
// Note that on ppc mac (the only bigendian machine around)
|
|
|
|
// the preprocessor def __BIG_ENDIAN__ is always defined.
|
|
|
|
// Otherwise we should be on a little endian machine (intel/amd based)
|
|
|
|
#ifndef __BIG_ENDIAN__
|
2004-03-03 16:00:51 +01:00
|
|
|
#define LITTLE_MACHINE
|
2007-05-11 10:21:45 +02:00
|
|
|
#endif
|
2004-06-23 02:06:45 +02:00
|
|
|
|
|
|
|
#ifdef WIN32
|
2004-03-03 16:00:51 +01:00
|
|
|
#define assert ASSERT
|
|
|
|
#else
|
|
|
|
#include <assert.h>
|
|
|
|
#endif
|
2009-03-30 22:58:18 +02:00
|
|
|
#ifdef _MSC_VER
|
|
|
|
#pragma warning( disable : 4267 )
|
|
|
|
#endif
|
2004-03-03 16:00:51 +01:00
|
|
|
|
|
|
|
#ifdef WIN32
|
|
|
|
#include <direct.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <math.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <assert.h>
|
|
|
|
|
|
|
|
#include <vector>
|
|
|
|
#include <algorithm>
|
|
|
|
|
|
|
|
#include "plylib.h"
|
|
|
|
using namespace std;
|
|
|
|
namespace vcg{
|
|
|
|
namespace ply{
|
|
|
|
typedef unsigned short ushort;
|
|
|
|
typedef unsigned long ulong;
|
|
|
|
typedef unsigned char uchar;
|
|
|
|
typedef unsigned int uint;
|
|
|
|
|
|
|
|
//#ifdef USE_ZLIB
|
|
|
|
//#include <zlib.h>
|
|
|
|
//#define XFILE void
|
|
|
|
//#define pb_fclose gzclose
|
|
|
|
//#define pb_fopen gzopen
|
|
|
|
//#define pb_fgets(s,n,f) gzgets(f,s,n)
|
|
|
|
//#define pb_fread(b,s,n,f) gzread(f,b,(s)*(n))
|
|
|
|
//#else
|
|
|
|
#define XFILE FILE
|
|
|
|
#define pb_fclose fclose
|
|
|
|
#define pb_fopen fopen
|
|
|
|
#define pb_fgets(s,n,f) fgets(s,n,f)
|
|
|
|
#define pb_fread(b,s,n,f) fread(b,s,n,f)
|
|
|
|
//#endif
|
|
|
|
|
|
|
|
//#ifdef WIN32
|
|
|
|
|
|
|
|
#define pb_mkdir(n) _mkdir(n)
|
|
|
|
#define pb_access _access
|
|
|
|
#define pb_stat _stat
|
|
|
|
#define pb_open _open
|
|
|
|
#define pb_close _close
|
|
|
|
|
|
|
|
/*
|
|
|
|
#else
|
|
|
|
|
|
|
|
#define pb_mkdir(n) mkdir(n,0)
|
|
|
|
#define pb_access access
|
|
|
|
#define pb_stat stat
|
|
|
|
#define pb_open open
|
|
|
|
#define pb_close close
|
|
|
|
|
|
|
|
#endif
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
// Funzioni statiche per la lettura di un elemento
|
|
|
|
int ReadBin ( XFILE * fp, const PlyProperty * pr, void * mem, int fmt );
|
|
|
|
int ReadAscii( XFILE * fp, const PlyProperty * pr, void * mem, int fmt );
|
|
|
|
|
|
|
|
|
|
|
|
const char * ::vcg::ply::PlyFile::typenames[9]=
|
|
|
|
{
|
|
|
|
"none",
|
|
|
|
"char",
|
|
|
|
"short",
|
|
|
|
"int",
|
|
|
|
"uchar",
|
|
|
|
"ushort",
|
|
|
|
"uint",
|
|
|
|
"float",
|
|
|
|
"double"
|
|
|
|
};
|
|
|
|
const char * PlyFile::newtypenames[9]=
|
|
|
|
{
|
|
|
|
"none",
|
|
|
|
"int8",
|
|
|
|
"int16",
|
|
|
|
"int32",
|
|
|
|
"uint8",
|
|
|
|
"uint16",
|
|
|
|
"uint32",
|
|
|
|
"float32",
|
|
|
|
"float64"
|
|
|
|
};
|
|
|
|
|
|
|
|
static int TypeSize[] = {
|
|
|
|
0, 1, 2, 4, 1, 2, 4, 4, 8
|
|
|
|
};
|
|
|
|
|
|
|
|
size_t PropDescriptor::memtypesize() const {return TypeSize[memtype1];}
|
|
|
|
size_t PropDescriptor::stotypesize() const {return TypeSize[stotype1];}
|
|
|
|
const char *PropDescriptor::memtypename() const {return PlyFile::typenames[memtype1];}
|
|
|
|
const char *PropDescriptor::stotypename() const {return PlyFile::typenames[stotype1];}
|
|
|
|
|
|
|
|
static char CrossType[9][9]=
|
|
|
|
{
|
|
|
|
{0,0,0,0,0,0,0,0,0},
|
|
|
|
{0,1,1,1,1,1,1,0,0},
|
|
|
|
{0,0,1,1,0,1,1,0,0},
|
|
|
|
{0,0,0,1,0,0,1,0,0},
|
|
|
|
{0,1,1,1,1,1,1,0,0},
|
|
|
|
{0,0,1,1,0,1,1,0,0},
|
|
|
|
{0,0,0,1,0,0,1,0,0},
|
|
|
|
{0,0,0,0,0,0,0,1,1},
|
|
|
|
{0,0,0,0,0,0,0,1,1}
|
|
|
|
};
|
|
|
|
|
|
|
|
// ******************************************************
|
|
|
|
// Funzioni di supporto per la lettura/scrittura dei dati
|
|
|
|
// ******************************************************
|
|
|
|
|
|
|
|
// Big-little endian
|
|
|
|
|
|
|
|
static inline void SwapShort( ushort * s )
|
|
|
|
{
|
|
|
|
assert(s);
|
|
|
|
*s = ushort( (int(*s)>>8) | (int(*s)<<8) );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline void SwapInt( uint * x )
|
|
|
|
{
|
|
|
|
assert(x);
|
|
|
|
*x =
|
|
|
|
( ((*x)>>24) & 0x000000FF ) |
|
|
|
|
( ((*x)>> 8) & 0x0000FF00 ) |
|
|
|
|
( ((*x)<< 8) & 0x00FF0000 ) |
|
|
|
|
( ((*x)<<24) & 0xFF000000 ) ;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline void SwapDouble( double * /*d*/ )
|
|
|
|
{
|
|
|
|
// Come si fa?
|
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Lettura tipi binari
|
|
|
|
|
|
|
|
static inline int ReadCharB( XFILE * fp, char * c, int /*format*/ )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(c);
|
|
|
|
|
|
|
|
return pb_fread(c,1,1,fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int ReadShortB( XFILE * fp, short * s, int format )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
int r;
|
|
|
|
r = pb_fread(s,sizeof(short),1,fp);
|
|
|
|
|
|
|
|
#ifdef LITTLE_MACHINE
|
|
|
|
if(format==F_BINBIG)
|
|
|
|
#else
|
|
|
|
if(format==F_BINLITTLE)
|
|
|
|
#endif
|
|
|
|
SwapShort((ushort *)s);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int ReadIntB( XFILE * fp, int * i, int format )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(i);
|
|
|
|
|
|
|
|
int r;
|
|
|
|
r = pb_fread(i,sizeof(int),1,fp);
|
|
|
|
|
|
|
|
#ifdef LITTLE_MACHINE
|
|
|
|
if(format==F_BINBIG)
|
|
|
|
#else
|
|
|
|
if(format==F_BINLITTLE)
|
|
|
|
#endif
|
|
|
|
SwapInt((uint *)i);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int ReadUCharB( XFILE * fp, uchar * uc, int /*format*/ )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(uc);
|
|
|
|
|
|
|
|
return pb_fread(uc,1,1,fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int ReadUShortB( XFILE * fp, ushort * us, int format )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(us);
|
|
|
|
|
|
|
|
int r;
|
|
|
|
r = pb_fread(us,sizeof(ushort),1,fp);
|
|
|
|
|
|
|
|
#ifdef LITTLE_MACHINE
|
|
|
|
if(format==F_BINBIG)
|
|
|
|
#else
|
|
|
|
if(format==F_BINLITTLE)
|
|
|
|
#endif
|
|
|
|
SwapShort(us);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int ReadUIntB( XFILE * fp, uint * ui, int format )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(ui);
|
|
|
|
|
|
|
|
int r;
|
|
|
|
r = pb_fread(ui,sizeof(uint),1,fp);
|
|
|
|
|
|
|
|
#ifdef LITTLE_MACHINE
|
|
|
|
if(format==F_BINBIG)
|
|
|
|
#else
|
|
|
|
if(format==F_BINLITTLE)
|
|
|
|
#endif
|
|
|
|
SwapInt(ui);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int ReadFloatB( XFILE * fp, float * f, int format )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(f);
|
|
|
|
|
|
|
|
int r;
|
|
|
|
r = pb_fread(f,sizeof(float),1,fp);
|
|
|
|
|
|
|
|
#ifdef LITTLE_MACHINE
|
|
|
|
if(format==F_BINBIG)
|
|
|
|
#else
|
|
|
|
if(format==F_BINLITTLE)
|
|
|
|
#endif
|
|
|
|
SwapInt((uint *)f);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int ReadDoubleB( XFILE * fp, double * d, int format )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(d);
|
|
|
|
|
|
|
|
int r;
|
|
|
|
r = pb_fread(d,sizeof(double),1,fp);
|
|
|
|
|
|
|
|
#ifdef LITTLE_MACHINE
|
|
|
|
if(format==F_BINBIG)
|
|
|
|
#else
|
|
|
|
if(format==F_BINLITTLE)
|
|
|
|
#endif
|
|
|
|
SwapDouble(d);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
// --- simulazione di scanf ------
|
|
|
|
|
|
|
|
//static bool sbuffer_ok = false;
|
|
|
|
//static const int SBUFFERSIZE = 4096;
|
|
|
|
//static char sbuffer[SBUFFERSIZE];
|
|
|
|
//static const char * separators = " \t,\n\r\f";
|
|
|
|
|
|
|
|
static void InitSBuffer()
|
|
|
|
{
|
|
|
|
//sbuffer_ok = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ReadInt( XFILE * fp, int & t )
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
char * p;
|
|
|
|
|
|
|
|
if(!sbuffer_ok)
|
|
|
|
{
|
|
|
|
pb_fgets(sbuffer,SBUFFERSIZE,fp);
|
|
|
|
p = strtok(sbuffer,separators);
|
|
|
|
sbuffer_ok = true;
|
|
|
|
}
|
|
|
|
else p = strtok(0,separators);
|
|
|
|
|
|
|
|
if(p==0)
|
|
|
|
{
|
|
|
|
pb_fgets(sbuffer,SBUFFERSIZE,fp);
|
|
|
|
p = strtok(sbuffer,separators);
|
|
|
|
}
|
|
|
|
|
|
|
|
t = atoi(p);
|
|
|
|
return 1;
|
|
|
|
*/
|
|
|
|
int r = fscanf(fp,"%d",&t);
|
|
|
|
if(r==EOF) r = 0;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int ReadUInt( XFILE * fp, unsigned int & t )
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
char * p;
|
|
|
|
|
|
|
|
if(!sbuffer_ok)
|
|
|
|
{
|
|
|
|
pb_fgets(sbuffer,SBUFFERSIZE,fp);
|
|
|
|
p = strtok(sbuffer,separators);
|
|
|
|
sbuffer_ok = true;
|
|
|
|
}
|
|
|
|
else p = strtok(0,separators);
|
|
|
|
|
|
|
|
if(p==0)
|
|
|
|
{
|
|
|
|
pb_fgets(sbuffer,SBUFFERSIZE,fp);
|
|
|
|
p = strtok(sbuffer,separators);
|
|
|
|
}
|
|
|
|
|
|
|
|
t = atoi(p);
|
|
|
|
return 1;
|
|
|
|
*/
|
|
|
|
int r = fscanf(fp,"%u",&t);
|
|
|
|
if(r==EOF) r = 0;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int ReadFloat( XFILE * fp, float & f )
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
char * p;
|
|
|
|
|
|
|
|
if(!sbuffer_ok)
|
|
|
|
{
|
|
|
|
pb_fgets(sbuffer,SBUFFERSIZE,fp);
|
|
|
|
p = strtok(sbuffer,separators);
|
|
|
|
sbuffer_ok = true;
|
|
|
|
}
|
|
|
|
else p = strtok(0,separators);
|
|
|
|
|
|
|
|
if(p==0)
|
|
|
|
{
|
|
|
|
pb_fgets(sbuffer,SBUFFERSIZE,fp);
|
|
|
|
p = strtok(sbuffer,separators);
|
|
|
|
}
|
|
|
|
|
|
|
|
f = atof(p);
|
|
|
|
return 1;
|
|
|
|
*/
|
|
|
|
int r = fscanf(fp,"%f",&f);
|
|
|
|
if(r==EOF) r = 0;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ReadDouble( XFILE * fp, double & d )
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
char * p;
|
|
|
|
|
|
|
|
if(!sbuffer_ok)
|
|
|
|
{
|
|
|
|
pb_fgets(sbuffer,SBUFFERSIZE,fp);
|
|
|
|
p = strtok(sbuffer,separators);
|
|
|
|
sbuffer_ok = true;
|
|
|
|
}
|
|
|
|
else p = strtok(0,separators);
|
|
|
|
|
|
|
|
if(p==0)
|
|
|
|
{
|
|
|
|
pb_fgets(sbuffer,SBUFFERSIZE,fp);
|
|
|
|
p = strtok(sbuffer,separators);
|
|
|
|
}
|
|
|
|
|
|
|
|
d = atof(p);
|
|
|
|
return 1;
|
|
|
|
*/
|
|
|
|
int r = fscanf(fp,"%lf",&d);
|
|
|
|
if(r==EOF) r = 0;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Lettura tipi ascii
|
|
|
|
|
|
|
|
static inline int ReadCharA( XFILE * fp, char * c )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(c);
|
|
|
|
|
|
|
|
int r,t;
|
|
|
|
r = ReadInt(fp,t);
|
|
|
|
*c = (char)t;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int ReadShortA( XFILE * fp, short * s )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
int r,t;
|
|
|
|
r = ReadInt(fp,t);
|
|
|
|
*s = (short)t;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int ReadIntA( XFILE * fp, int * i )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(i);
|
|
|
|
|
|
|
|
return ReadInt(fp,*i);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ReadUCharA( XFILE * fp, uchar * uc )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(uc);
|
|
|
|
|
|
|
|
int r;
|
|
|
|
uint t;
|
|
|
|
r = ReadUInt(fp,t);
|
|
|
|
*uc = (uchar)t;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int ReadUShortA( XFILE * fp, ushort * us )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(us);
|
|
|
|
|
|
|
|
int r;
|
|
|
|
uint t;
|
|
|
|
r = ReadUInt(fp,t);
|
|
|
|
*us = (ushort)t;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int ReadUIntA( XFILE * fp, uint * ui )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(ui);
|
|
|
|
|
|
|
|
return ReadUInt(fp,*ui);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ReadFloatA( XFILE * fp, float * f )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(f);
|
|
|
|
|
|
|
|
return ReadFloat(fp,*f);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int ReadDoubleA( XFILE * fp, double * d )
|
|
|
|
{
|
|
|
|
assert(fp);
|
|
|
|
assert(d);
|
|
|
|
|
|
|
|
return ReadDouble(fp,*d);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Memorizza il valore val nella variabile mem di tipo tm
|
|
|
|
|
|
|
|
static inline void StoreInt( void * mem, const int tm, const int val )
|
|
|
|
{
|
|
|
|
assert(mem);
|
|
|
|
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_CHAR: *(char *)mem = (char )val; break;
|
|
|
|
case T_SHORT: *(short *)mem = (short )val; break;
|
|
|
|
case T_INT: *(int *)mem = (int )val; break;
|
|
|
|
case T_UCHAR: *(uchar *)mem = (uchar )val; break;
|
|
|
|
case T_USHORT: *(ushort *)mem = (ushort)val; break;
|
|
|
|
case T_UINT: *(uint *)mem = (uint )val; break;
|
|
|
|
case T_FLOAT: *(float *)mem = (float )val; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = (double)val; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Salta un valore nel file
|
|
|
|
|
|
|
|
static inline int SkipScalarA( XFILE * fp, const int tf )
|
|
|
|
{
|
|
|
|
int t;
|
|
|
|
float f;
|
|
|
|
|
|
|
|
assert(fp);
|
|
|
|
|
|
|
|
switch(tf)
|
|
|
|
{
|
|
|
|
case T_CHAR:
|
|
|
|
case T_SHORT:
|
|
|
|
case T_INT:
|
|
|
|
case T_UCHAR:
|
|
|
|
case T_USHORT:
|
|
|
|
case T_UINT:
|
|
|
|
return ReadInt(fp,t);
|
|
|
|
case T_FLOAT:
|
|
|
|
case T_DOUBLE:
|
|
|
|
return ReadFloat(fp,f);
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static inline int SkipScalarB( XFILE * fp, const int tf)
|
|
|
|
{
|
|
|
|
static char dummy[8];
|
|
|
|
|
|
|
|
assert(fp);
|
|
|
|
return pb_fread(dummy,1,TypeSize[tf],fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ReadScalarB( XFILE * fp, void * mem, const int tf, const int tm, int fmt )
|
|
|
|
{
|
|
|
|
static char ch;
|
|
|
|
static short sh;
|
|
|
|
static int in;
|
|
|
|
static uchar uc;
|
|
|
|
static ushort us;
|
|
|
|
static uint ui;
|
|
|
|
static float fl;
|
|
|
|
static double dd;
|
|
|
|
|
|
|
|
int r = 0;
|
|
|
|
|
|
|
|
switch(tf)
|
|
|
|
{
|
|
|
|
case T_CHAR: //================== Lettura char
|
|
|
|
r = ReadCharB(fp,&ch,fmt);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_CHAR: *(char *)mem = (char )ch; break;
|
|
|
|
case T_SHORT: *(short *)mem = (short )ch; break;
|
|
|
|
case T_INT: *(int *)mem = (int )ch; break;
|
|
|
|
case T_UCHAR: *(uchar *)mem = (uchar )ch; break;
|
|
|
|
case T_USHORT: *(ushort *)mem = (ushort)ch; break;
|
|
|
|
case T_UINT: *(uint *)mem = (uint )ch; break;
|
|
|
|
case T_FLOAT: *(float *)mem = (float )ch; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = (double)ch; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_SHORT: //================== Lettura short
|
|
|
|
r = ReadShortB(fp,&sh,fmt);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_CHAR: *(char *)mem = (char )sh; break;
|
|
|
|
case T_SHORT: *(short *)mem = (short )sh; break;
|
|
|
|
case T_INT: *(int *)mem = (int )sh; break;
|
|
|
|
case T_UCHAR: *(uchar *)mem = (uchar )sh; break;
|
|
|
|
case T_USHORT: *(ushort *)mem = (ushort)sh; break;
|
|
|
|
case T_UINT: *(uint *)mem = (uint )sh; break;
|
|
|
|
case T_FLOAT: *(float *)mem = (float )sh; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = (double)sh; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_INT: //================== Lettura int
|
|
|
|
r = ReadIntB(fp,&in,fmt);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_CHAR: *(char *)mem = (char )in; break;
|
|
|
|
case T_SHORT: *(short *)mem = (short )in; break;
|
|
|
|
case T_INT: *(int *)mem = (int )in; break;
|
|
|
|
case T_UCHAR: *(uchar *)mem = (uchar )in; break;
|
|
|
|
case T_USHORT: *(ushort *)mem = (ushort)in; break;
|
|
|
|
case T_UINT: *(uint *)mem = (uint )in; break;
|
|
|
|
case T_FLOAT: *(float *)mem = (float )in; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = (double)in; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_UCHAR: //================== Lettura uchar
|
|
|
|
r = ReadUCharB(fp,&uc,fmt);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_CHAR: *(char *)mem = (char )uc; break;
|
|
|
|
case T_SHORT: *(short *)mem = (short )uc; break;
|
|
|
|
case T_INT: *(int *)mem = (int )uc; break;
|
|
|
|
case T_UCHAR: *(uchar *)mem = (uchar )uc; break;
|
|
|
|
case T_USHORT: *(ushort *)mem = (ushort)uc; break;
|
|
|
|
case T_UINT: *(uint *)mem = (uint )uc; break;
|
|
|
|
case T_FLOAT: *(float *)mem = (float )uc; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = (double)uc; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_USHORT: //================== Lettura ushort
|
|
|
|
r = ReadUShortB(fp,&us,fmt);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_CHAR: *(char *)mem = (char )us; break;
|
|
|
|
case T_SHORT: *(short *)mem = (short )us; break;
|
|
|
|
case T_INT: *(int *)mem = (int )us; break;
|
|
|
|
case T_UCHAR: *(uchar *)mem = (uchar )us; break;
|
|
|
|
case T_USHORT: *(ushort *)mem = (ushort)us; break;
|
|
|
|
case T_UINT: *(uint *)mem = (uint )us; break;
|
|
|
|
case T_FLOAT: *(float *)mem = (float )us; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = (double)us; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_UINT: //================== Lettura uint
|
|
|
|
r = ReadUIntB(fp,&ui,fmt);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_CHAR: *(char *)mem = (char )ui; break;
|
|
|
|
case T_SHORT: *(short *)mem = (short )ui; break;
|
|
|
|
case T_INT: *(int *)mem = (int )ui; break;
|
|
|
|
case T_UCHAR: *(uchar *)mem = (uchar )ui; break;
|
|
|
|
case T_USHORT: *(ushort *)mem = (ushort)ui; break;
|
|
|
|
case T_UINT: *(uint *)mem = (uint )ui; break;
|
|
|
|
case T_FLOAT: *(float *)mem = (float )ui; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = (double)ui; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_FLOAT: //================== Lettura float
|
|
|
|
r = ReadFloatB(fp,&fl,fmt);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_FLOAT: *(float *)mem = fl; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = fl; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_DOUBLE: //================== Lettura double
|
|
|
|
r = ReadDoubleB(fp,&dd,fmt);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_FLOAT: *(float *)mem = (float)dd; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = dd; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Legge un valore di tipo tf e lo memorizza col tipo tm
|
|
|
|
|
|
|
|
static int ReadScalarA( XFILE * fp, void * mem, const int tf, const int tm )
|
|
|
|
{
|
|
|
|
static char ch;
|
|
|
|
static short sh;
|
|
|
|
static int in;
|
|
|
|
static uchar uc;
|
|
|
|
static ushort us;
|
|
|
|
static uint ui;
|
|
|
|
static float fl;
|
|
|
|
static double dd;
|
|
|
|
|
|
|
|
int r = 0;
|
|
|
|
|
|
|
|
switch(tf)
|
|
|
|
{
|
|
|
|
case T_CHAR: //================== Lettura char
|
|
|
|
r = ReadCharA(fp,&ch);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_CHAR: *(char *)mem = (char )ch; break;
|
|
|
|
case T_SHORT: *(short *)mem = (short )ch; break;
|
|
|
|
case T_INT: *(int *)mem = (int )ch; break;
|
|
|
|
case T_UCHAR: *(uchar *)mem = (uchar )ch; break;
|
|
|
|
case T_USHORT: *(ushort *)mem = (ushort)ch; break;
|
|
|
|
case T_UINT: *(uint *)mem = (uint )ch; break;
|
|
|
|
case T_FLOAT: *(float *)mem = (float )ch; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = (double)ch; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_SHORT: //================== Lettura short
|
|
|
|
r = ReadShortA(fp,&sh);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_CHAR: *(char *)mem = (char )sh; break;
|
|
|
|
case T_SHORT: *(short *)mem = (short )sh; break;
|
|
|
|
case T_INT: *(int *)mem = (int )sh; break;
|
|
|
|
case T_UCHAR: *(uchar *)mem = (uchar )sh; break;
|
|
|
|
case T_USHORT: *(ushort *)mem = (ushort)sh; break;
|
|
|
|
case T_UINT: *(uint *)mem = (uint )sh; break;
|
|
|
|
case T_FLOAT: *(float *)mem = (float )sh; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = (double)sh; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_INT: //================== Lettura int
|
|
|
|
r = ReadIntA(fp,&in);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_CHAR: *(char *)mem = (char )in; break;
|
|
|
|
case T_SHORT: *(short *)mem = (short )in; break;
|
|
|
|
case T_INT: *(int *)mem = (int )in; break;
|
|
|
|
case T_UCHAR: *(uchar *)mem = (uchar )in; break;
|
|
|
|
case T_USHORT: *(ushort *)mem = (ushort)in; break;
|
|
|
|
case T_UINT: *(uint *)mem = (uint )in; break;
|
|
|
|
case T_FLOAT: *(float *)mem = (float )in; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = (double)in; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_UCHAR: //================== Lettura uchar
|
|
|
|
r = ReadUCharA(fp,&uc);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_CHAR: *(char *)mem = (char )uc; break;
|
|
|
|
case T_SHORT: *(short *)mem = (short )uc; break;
|
|
|
|
case T_INT: *(int *)mem = (int )uc; break;
|
|
|
|
case T_UCHAR: *(uchar *)mem = (uchar )uc; break;
|
|
|
|
case T_USHORT: *(ushort *)mem = (ushort)uc; break;
|
|
|
|
case T_UINT: *(uint *)mem = (uint )uc; break;
|
|
|
|
case T_FLOAT: *(float *)mem = (float )uc; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = (double)uc; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_USHORT: //================== Lettura ushort
|
|
|
|
r = ReadUShortA(fp,&us);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_CHAR: *(char *)mem = (char )us; break;
|
|
|
|
case T_SHORT: *(short *)mem = (short )us; break;
|
|
|
|
case T_INT: *(int *)mem = (int )us; break;
|
|
|
|
case T_UCHAR: *(uchar *)mem = (uchar )us; break;
|
|
|
|
case T_USHORT: *(ushort *)mem = (ushort)us; break;
|
|
|
|
case T_UINT: *(uint *)mem = (uint )us; break;
|
|
|
|
case T_FLOAT: *(float *)mem = (float )us; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = (double)us; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_UINT: //================== Lettura uint
|
|
|
|
r = ReadUIntA(fp,&ui);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_CHAR: *(char *)mem = (char )ui; break;
|
|
|
|
case T_SHORT: *(short *)mem = (short )ui; break;
|
|
|
|
case T_INT: *(int *)mem = (int )ui; break;
|
|
|
|
case T_UCHAR: *(uchar *)mem = (uchar )ui; break;
|
|
|
|
case T_USHORT: *(ushort *)mem = (ushort)ui; break;
|
|
|
|
case T_UINT: *(uint *)mem = (uint )ui; break;
|
|
|
|
case T_FLOAT: *(float *)mem = (float )ui; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = (double)ui; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_FLOAT: //================== Lettura float
|
|
|
|
r = ReadFloatA(fp,&fl);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_FLOAT: *(float *)mem = fl; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = fl; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_DOUBLE: //================== Lettura double
|
|
|
|
r = ReadDoubleA(fp,&dd);
|
|
|
|
switch(tm)
|
|
|
|
{
|
|
|
|
case T_FLOAT: *(float *)mem = (float)dd; break;
|
|
|
|
case T_DOUBLE: *(double *)mem = dd; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
//####################### Classe PlyElement
|
|
|
|
|
|
|
|
|
|
|
|
void PlyElement::AddProp( const char * na, int ti, int isl, int t2 )
|
|
|
|
{
|
|
|
|
assert(na);
|
|
|
|
assert(ti>0);
|
|
|
|
assert(ti<T_MAXTYPE);
|
|
|
|
assert( t2>0 || (t2==0 && isl==0));
|
|
|
|
assert(t2<T_MAXTYPE);
|
|
|
|
|
|
|
|
props.push_back( PlyProperty (na,ti,isl,t2) );
|
|
|
|
}
|
|
|
|
|
|
|
|
PlyProperty * PlyElement::FindProp( const char * na )
|
|
|
|
{
|
|
|
|
assert(na);
|
|
|
|
vector<PlyProperty>::iterator i;
|
|
|
|
|
|
|
|
for(i=props.begin();i!=props.end();++i)
|
|
|
|
if( i->name == na )
|
|
|
|
return &*i;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int PlyElement::AddToRead(
|
|
|
|
const char * propname,
|
|
|
|
int stotype1,
|
|
|
|
int memtype1,
|
2005-11-12 08:07:47 +01:00
|
|
|
size_t offset1,
|
2004-03-03 16:00:51 +01:00
|
|
|
int islist,
|
|
|
|
int alloclist,
|
|
|
|
int stotype2,
|
|
|
|
int memtype2,
|
2005-11-12 08:07:47 +01:00
|
|
|
size_t offset2
|
2004-03-03 16:00:51 +01:00
|
|
|
) // Vedi struttura PropDescriptor
|
|
|
|
{
|
|
|
|
assert(propname);
|
|
|
|
|
|
|
|
PlyProperty * p = FindProp(propname);
|
|
|
|
if(p==0)
|
|
|
|
{
|
|
|
|
return E_PROPNOTFOUND;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( stotype1<1 || stotype1>=T_MAXTYPE ||
|
|
|
|
memtype1<1 || memtype1>=T_MAXTYPE )
|
|
|
|
{
|
|
|
|
return E_BADTYPE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( islist && (stotype2<1 || stotype2>=T_MAXTYPE ||
|
|
|
|
memtype2<1 || memtype2>=T_MAXTYPE ) )
|
|
|
|
{
|
|
|
|
return E_BADTYPE;
|
|
|
|
}
|
|
|
|
|
2005-01-03 11:35:59 +01:00
|
|
|
if( islist!= p->islist || stotype1 != p->tipo ||
|
2004-03-03 16:00:51 +01:00
|
|
|
( islist && stotype2!=p->tipoindex) )
|
|
|
|
{
|
|
|
|
return E_INCOMPATIBLETYPE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( !CrossType[p->tipo][stotype1] ||
|
|
|
|
(islist && !CrossType[p->tipoindex][stotype2] ) )
|
|
|
|
{
|
|
|
|
return E_BADCAST;
|
|
|
|
}
|
|
|
|
|
|
|
|
p->bestored = 1;
|
|
|
|
|
|
|
|
p->desc.stotype1 = stotype1;
|
|
|
|
p->desc.memtype1 = memtype1;
|
|
|
|
p->desc.offset1 = offset1;
|
|
|
|
p->desc.islist = islist;
|
|
|
|
p->desc.alloclist = alloclist;
|
|
|
|
p->desc.stotype2 = stotype2;
|
|
|
|
p->desc.memtype2 = memtype2;
|
|
|
|
p->desc.offset2 = offset2;
|
|
|
|
|
|
|
|
|
|
|
|
return E_NOERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//####################### Classe PlyFile
|
|
|
|
|
|
|
|
PlyFile::PlyFile( void )
|
|
|
|
{
|
|
|
|
gzfp = 0;
|
|
|
|
version = 0.0f;
|
|
|
|
error = E_NOERROR;
|
|
|
|
format = F_UNSPECIFIED;
|
|
|
|
cure = 0;
|
|
|
|
ReadCB = 0;
|
|
|
|
InitSBuffer();
|
|
|
|
}
|
|
|
|
|
|
|
|
PlyFile::~PlyFile( void )
|
|
|
|
{
|
|
|
|
Destroy();
|
|
|
|
}
|
|
|
|
|
|
|
|
int PlyFile::Open( const char * filename, int mode )
|
|
|
|
{
|
|
|
|
if(filename==0 || (mode!=MODE_READ && mode!=MODE_WRITE) )
|
|
|
|
{
|
|
|
|
error = E_CANTOPEN;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if(mode==MODE_READ)
|
|
|
|
return OpenRead(filename);
|
|
|
|
else
|
|
|
|
return OpenWrite(filename);
|
|
|
|
}
|
|
|
|
|
|
|
|
void PlyFile::Destroy( void )
|
|
|
|
{
|
|
|
|
if(gzfp!=0)
|
|
|
|
{
|
|
|
|
pb_fclose(gzfp);
|
|
|
|
gzfp = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ReadCB = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int PlyFile::OpenRead( const char * filename )
|
|
|
|
{
|
|
|
|
// Tokens dell'intestazione
|
|
|
|
|
|
|
|
static const char * SEP = " \t\n\r";
|
|
|
|
static const char * HEADER = "ply";
|
|
|
|
static const char * FORMAT = "format";
|
|
|
|
static const char * TASCII = "ascii";
|
|
|
|
static const char * TBINBIG = "binary_big_endian";
|
|
|
|
static const char * TBINLITTLE = "binary_little_endian";
|
|
|
|
static const char * COMMENT = "comment";
|
|
|
|
static const char * OBJ_INFO = "obj_info";
|
|
|
|
static const char * ELEMENT = "element";
|
|
|
|
static const char * PROPERTY = "property";
|
|
|
|
static const char * ENDHEADER = "end_header";
|
|
|
|
static const char * LIST = "list";
|
|
|
|
|
|
|
|
const int MAXB = 512;
|
|
|
|
char buf[MAXB];
|
|
|
|
char * token;
|
|
|
|
PlyElement * curelement;
|
|
|
|
|
|
|
|
// Predistruzione
|
|
|
|
|
|
|
|
Destroy();
|
|
|
|
|
|
|
|
// Apertura file
|
|
|
|
|
|
|
|
gzfp = pb_fopen(filename,"rb");
|
|
|
|
if(gzfp==0)
|
|
|
|
{
|
|
|
|
error = E_CANTOPEN;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2011-02-21 12:04:55 +01:00
|
|
|
header.clear();
|
|
|
|
header.reserve(1536);
|
2004-03-03 16:00:51 +01:00
|
|
|
|
|
|
|
// ********* Parsing header ***********
|
|
|
|
|
|
|
|
// Controllo header
|
|
|
|
if( pb_fgets(buf,MAXB-1,gzfp)==0 )
|
|
|
|
{
|
|
|
|
error = E_UNESPECTEDEOF;
|
|
|
|
goto error;
|
|
|
|
}
|
2011-02-21 12:04:55 +01:00
|
|
|
header.append(buf);
|
|
|
|
|
2004-03-03 16:00:51 +01:00
|
|
|
if( strncmp(buf,HEADER,strlen(HEADER)) )
|
|
|
|
{
|
|
|
|
error = E_NOTHEADER;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Lettura tipo e versione
|
|
|
|
|
|
|
|
if( pb_fgets(buf,MAXB-1,gzfp)==0 )
|
|
|
|
{
|
|
|
|
error = E_UNESPECTEDEOF;
|
|
|
|
goto error;
|
|
|
|
}
|
2011-02-21 12:04:55 +01:00
|
|
|
header.append(buf);
|
|
|
|
|
2004-03-03 16:00:51 +01:00
|
|
|
token = strtok(buf,SEP);
|
|
|
|
if(token==0)
|
|
|
|
{
|
|
|
|
error = E_UNESPECTEDEOF;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if( strcmp(token,FORMAT) )
|
|
|
|
{
|
|
|
|
error = E_NOFORMAT;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
token = strtok(0,SEP);
|
|
|
|
if(token==0)
|
|
|
|
{
|
|
|
|
error = E_UNESPECTEDEOF;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if( !strcmp(token,TASCII) )
|
|
|
|
format = F_ASCII;
|
|
|
|
else if( !strcmp(token,TBINBIG) )
|
|
|
|
format = F_BINBIG;
|
|
|
|
else if( !strcmp(token,TBINLITTLE) )
|
|
|
|
format = F_BINLITTLE;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
error = E_NOFORMAT;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
token = strtok(0,SEP);
|
|
|
|
if(token==0)
|
|
|
|
{
|
|
|
|
error = E_UNESPECTEDEOF;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
version = float(atof(token));
|
|
|
|
|
|
|
|
//************* Ciclo lettura elementi ****************
|
|
|
|
|
|
|
|
curelement = 0;
|
|
|
|
for(;;)
|
|
|
|
{
|
|
|
|
if( pb_fgets(buf,MAXB-1,gzfp)==0 )
|
|
|
|
{
|
|
|
|
error = E_UNESPECTEDEOF;
|
|
|
|
goto error;
|
|
|
|
}
|
2011-02-21 12:04:55 +01:00
|
|
|
header.append(buf);
|
2004-03-03 16:00:51 +01:00
|
|
|
|
|
|
|
token = strtok(buf,SEP);
|
|
|
|
if(token==0)
|
|
|
|
{
|
|
|
|
error = E_UNESPECTEDEOF;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( !strcmp(token,COMMENT) )
|
|
|
|
{
|
|
|
|
comments.push_back( string(token+strlen(token)+1) );
|
|
|
|
//AddComment( token+strlen(token)+1 );
|
|
|
|
}
|
|
|
|
else if( !strcmp(token,OBJ_INFO) )
|
|
|
|
{
|
|
|
|
comments.push_back( string(token+strlen(token)+1) );
|
|
|
|
//AddComment( token+strlen(token)+1 );
|
|
|
|
}
|
|
|
|
else if( !strcmp(token,ENDHEADER) )
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if( !strcmp(token,ELEMENT) )
|
|
|
|
{
|
|
|
|
// Lettura nome elemento
|
|
|
|
char * name = strtok(0,SEP);
|
|
|
|
if(name==0)
|
|
|
|
{
|
|
|
|
error = E_SYNTAX;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
// Lettura numero di elementi
|
|
|
|
token = strtok(0,SEP);
|
|
|
|
if(name==0)
|
|
|
|
{
|
|
|
|
error = E_SYNTAX;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
int number = atoi(token);
|
|
|
|
|
|
|
|
PlyElement t(name,number);
|
|
|
|
elements.push_back(t);
|
|
|
|
curelement = &(elements.back());
|
|
|
|
}
|
|
|
|
else if( !strcmp(token,PROPERTY) )
|
|
|
|
{
|
|
|
|
if(curelement==0)
|
|
|
|
{
|
|
|
|
error = E_PROPOUTOFELEMENT;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
token = strtok(0,SEP);
|
|
|
|
if(token==0)
|
|
|
|
{
|
|
|
|
error = E_SYNTAX;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if( !strcmp(token,LIST) )
|
|
|
|
{
|
|
|
|
token = strtok(0,SEP);
|
|
|
|
if(token==0)
|
|
|
|
{
|
|
|
|
error = E_SYNTAX;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
int t2 = FindType(token);
|
|
|
|
if(t2==-1)
|
|
|
|
{
|
|
|
|
error = E_BADTYPENAME;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
token = strtok(0,SEP);
|
|
|
|
if(token==0)
|
|
|
|
{
|
|
|
|
error = E_SYNTAX;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
int t1 = FindType(token);
|
|
|
|
if(t1==-1)
|
|
|
|
{
|
|
|
|
error = E_BADTYPENAME;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
token = strtok(0,SEP);
|
|
|
|
if(token==0)
|
|
|
|
{
|
|
|
|
error = E_SYNTAX;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
//curelement->AddProp(token,t1,1,t2); prima del 5/9/03 era cosi' ma swappava i due tipi.
|
|
|
|
curelement->AddProp(token,t1,1,t2);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int t1 = FindType(token);
|
|
|
|
if(t1==-1)
|
|
|
|
{
|
|
|
|
error = E_BADTYPENAME;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
token = strtok(0,SEP);
|
|
|
|
if(token==0)
|
|
|
|
{
|
|
|
|
error = E_SYNTAX;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
curelement->AddProp(token,t1,0,T_NOTYPE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
error = E_SYNTAX;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if(format==F_ASCII)
|
|
|
|
ReadCB = ReadAscii;
|
|
|
|
else
|
|
|
|
ReadCB = ReadBin;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
Destroy();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int PlyFile::OpenWrite( const char * /*filename*/ )
|
|
|
|
{
|
|
|
|
// Per ora non implementato
|
|
|
|
assert(0);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//################# Funzioni di supporto
|
|
|
|
|
|
|
|
int PlyFile::FindType( const char * name ) const
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
assert(name);
|
|
|
|
|
|
|
|
for(i=1;i<9;++i)
|
|
|
|
if( !strcmp(name,typenames[i]) || !strcmp(name,newtypenames[i]))
|
|
|
|
return i;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
PlyElement * PlyFile::FindElement( const char * na )
|
|
|
|
{
|
|
|
|
assert(na);
|
|
|
|
vector<PlyElement>::iterator i;
|
|
|
|
|
|
|
|
for(i=elements.begin();i!=elements.end();++i)
|
|
|
|
if( i->name == na )
|
|
|
|
return &*i;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int PlyFile::AddToRead(
|
|
|
|
const char * elemname,
|
|
|
|
const char * propname,
|
|
|
|
int stotype1,
|
|
|
|
int memtype1,
|
2005-11-12 08:07:47 +01:00
|
|
|
size_t offset1,
|
2004-03-03 16:00:51 +01:00
|
|
|
int islist,
|
|
|
|
int alloclist,
|
|
|
|
int stotype2,
|
|
|
|
int memtype2,
|
2005-11-12 08:07:47 +01:00
|
|
|
size_t offset2
|
2004-03-03 16:00:51 +01:00
|
|
|
) // Vedi struttura PropDescriptor
|
|
|
|
{
|
|
|
|
assert(elemname);
|
|
|
|
PlyElement * e = FindElement(elemname);
|
|
|
|
if(e==0)
|
|
|
|
{
|
|
|
|
error = E_ELEMNOTFOUND;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int r = e->AddToRead(propname,stotype1,memtype1,offset1,islist,
|
|
|
|
alloclist,stotype2,memtype2,offset2 );
|
|
|
|
|
|
|
|
if(r==E_NOERROR)
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
error = r;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const char * PlyFile::ElemName( int i )
|
|
|
|
{
|
|
|
|
if(i<0 || i>=int(elements.size()))
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return elements[i].name.c_str();
|
|
|
|
}
|
|
|
|
|
|
|
|
int PlyFile::ElemNumber( int i ) const
|
|
|
|
{
|
|
|
|
if(i<0 || i>=int(elements.size()))
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return elements[i].number;
|
|
|
|
}
|
|
|
|
|
|
|
|
// *** callbacks ***
|
|
|
|
|
|
|
|
static bool cb_skip_bin1( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
|
|
|
|
{
|
|
|
|
static char dummy[1];
|
|
|
|
|
|
|
|
assert(fp);
|
|
|
|
return pb_fread(dummy,1,1,fp)!=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_skip_bin2( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
|
|
|
|
{
|
|
|
|
static char dummy[2];
|
|
|
|
|
|
|
|
assert(fp);
|
|
|
|
return pb_fread(dummy,1,2,fp)!=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_skip_bin4( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
|
|
|
|
{
|
|
|
|
static char dummy[4];
|
|
|
|
|
|
|
|
assert(fp);
|
|
|
|
return pb_fread(dummy,1,4,fp)!=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_skip_bin8( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
|
|
|
|
{
|
|
|
|
static char dummy[8];
|
|
|
|
|
|
|
|
assert(fp);
|
|
|
|
return pb_fread(dummy,1,8,fp)!=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_skip_float_ascii( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
|
|
|
|
{
|
|
|
|
static float dummy;
|
|
|
|
|
|
|
|
assert(fp);
|
|
|
|
return fscanf(fp,"%f",&dummy)!=EOF;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_skip_int_ascii( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
|
|
|
|
{
|
|
|
|
static int dummy;
|
|
|
|
|
|
|
|
assert(fp);
|
|
|
|
return fscanf(fp,"%d",&dummy)!=EOF;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool cb_read_chch( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
return pb_fread( ((char *)mem)+d->offset1,1,1,fp)!=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_chsh( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
if( pb_fread(&c,1,1,fp)==0) return false;
|
|
|
|
return true;
|
|
|
|
|
|
|
|
*(short *)(((char *)mem)+d->offset1) = short(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_chin( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
if( pb_fread(&c,1,1,fp)==0) return false;
|
|
|
|
return true;
|
|
|
|
|
|
|
|
*(int *)(((char *)mem)+d->offset1) = int(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_chuc( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
if( pb_fread(&c,1,1,fp)==0) return false;
|
|
|
|
return true;
|
|
|
|
|
|
|
|
*(uchar *)(((char *)mem)+d->offset1) = uchar(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_chus( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
if( pb_fread(&c,1,1,fp)==0) return false;
|
|
|
|
return true;
|
|
|
|
|
|
|
|
*(ushort *)(((char *)mem)+d->offset1) = ushort(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_chui( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
if( pb_fread(&c,1,1,fp)==0) return false;
|
|
|
|
return true;
|
|
|
|
|
|
|
|
*(uint *)(((char *)mem)+d->offset1) = uint(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_chfl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
if( pb_fread(&c,1,1,fp)==0) return false;
|
|
|
|
return true;
|
|
|
|
|
|
|
|
*(float *)(((char *)mem)+d->offset1) = float(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_chdo( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
if( pb_fread(&c,1,1,fp)==0) return false;
|
|
|
|
return true;
|
|
|
|
|
|
|
|
*(double *)(((char *)mem)+d->offset1) = double(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static bool cb_read_shch( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(char *)(((char *)mem)+d->offset1) = char(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_shsh( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(short *)(((char *)mem)+d->offset1) = short(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_shin( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(int *)(((char *)mem)+d->offset1) = int(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_shuc( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(uchar *)(((char *)mem)+d->offset1) = uchar(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_shus( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(ushort *)(((char *)mem)+d->offset1) = ushort(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_shui( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(uint *)(((char *)mem)+d->offset1) = uint(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_shfl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(float *)(((char *)mem)+d->offset1) = float(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_shdo( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(double *)(((char *)mem)+d->offset1) = double(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static bool cb_read_inch( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(char *)(((char *)mem)+d->offset1) = char(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_insh( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(short *)(((char *)mem)+d->offset1) = short(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_inin( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(int *)(((char *)mem)+d->offset1) = int(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_inuc( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(uchar *)(((char *)mem)+d->offset1) = uchar(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_inus( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(ushort *)(((char *)mem)+d->offset1) = ushort(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_inui( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(uint *)(((char *)mem)+d->offset1) = uint(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_infl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(float *)(((char *)mem)+d->offset1) = float(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_indo( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(double *)(((char *)mem)+d->offset1) = double(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static bool cb_read_ucch( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
|
|
|
|
*(char *)(((char *)mem)+d->offset1) = char(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_ucsh( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
|
|
|
|
*(short *)(((char *)mem)+d->offset1) = short(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_ucin( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
|
|
|
|
*(int *)(((char *)mem)+d->offset1) = int(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_ucuc( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
|
|
|
|
*(uchar *)(((char *)mem)+d->offset1) = uchar(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_ucus( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
|
|
|
|
*(ushort *)(((char *)mem)+d->offset1) = ushort(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_ucui( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
|
|
|
|
*(uint *)(((char *)mem)+d->offset1) = uint(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_ucfl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
|
|
|
|
*(float *)(((char *)mem)+d->offset1) = float(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_ucdo( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
|
|
|
|
*(double *)(((char *)mem)+d->offset1) = double(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static bool cb_read_usch( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(char *)(((char *)mem)+d->offset1) = char(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_ussh( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(short *)(((char *)mem)+d->offset1) = short(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_usin( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(int *)(((char *)mem)+d->offset1) = int(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_usuc( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(uchar *)(((char *)mem)+d->offset1) = uchar(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_usus( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(ushort *)(((char *)mem)+d->offset1) = ushort(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_usui( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(uint *)(((char *)mem)+d->offset1) = uint(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_usfl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(float *)(((char *)mem)+d->offset1) = float(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_usdo( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
|
|
|
|
*(double *)(((char *)mem)+d->offset1) = double(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static bool cb_read_uich( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(char *)(((char *)mem)+d->offset1) = char(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_uish( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(short *)(((char *)mem)+d->offset1) = short(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_uiin( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(int *)(((char *)mem)+d->offset1) = int(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_uiuc( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(uchar *)(((char *)mem)+d->offset1) = uchar(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_uius( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(ushort *)(((char *)mem)+d->offset1) = ushort(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_uiui( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(uint *)(((char *)mem)+d->offset1) = uint(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_uifl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(float *)(((char *)mem)+d->offset1) = float(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_uido( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(double *)(((char *)mem)+d->offset1) = double(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static bool cb_read_flfl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
float c; if( ReadFloatB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(float *)(((char *)mem)+d->offset1) = float(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_fldo( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
float c; if( ReadFloatB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(double *)(((char *)mem)+d->offset1) = double(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_dofl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
double c; if( ReadDoubleB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(float *)(((char *)mem)+d->offset1) = float(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_dodo( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
double c; if( ReadDoubleB(fp,&c,d->format)==0 ) return false;
|
|
|
|
|
|
|
|
*(double *)(((char *)mem)+d->offset1) = double(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// NON OTTIMIZZATO!!
|
|
|
|
static bool cb_read_ascii( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
return ReadScalarA(fp, ((char *)mem)+d->offset1, d->stotype1, d->memtype1)!=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const int SKIP_MAX_BUF = 512;
|
|
|
|
static char skip_buf[SKIP_MAX_BUF];
|
|
|
|
|
2004-04-06 23:48:50 +02:00
|
|
|
static bool cb_skip_list_bin1( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
|
2004-03-03 16:00:51 +01:00
|
|
|
{
|
|
|
|
uchar n;
|
|
|
|
// Solo indici uchar
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
|
|
|
|
if( pb_fread(skip_buf,1,n,fp)==0) return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2004-04-06 23:48:50 +02:00
|
|
|
static bool cb_skip_list_bin2( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
|
2004-03-03 16:00:51 +01:00
|
|
|
{
|
|
|
|
uchar n;
|
|
|
|
// Solo indici uchar
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
|
|
|
|
if( pb_fread(skip_buf,2,n,fp)==0) return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2004-04-06 23:48:50 +02:00
|
|
|
static bool cb_skip_list_bin4( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
|
2004-03-03 16:00:51 +01:00
|
|
|
{
|
|
|
|
uchar n;
|
|
|
|
// Solo indici uchar
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
|
|
|
|
if( pb_fread(skip_buf,4,n,fp)==0) return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2004-04-06 23:48:50 +02:00
|
|
|
static bool cb_skip_list_bin8( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
|
2004-03-03 16:00:51 +01:00
|
|
|
{
|
|
|
|
uchar n;
|
|
|
|
// Solo indici uchar
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
|
|
|
|
if( pb_fread(skip_buf,8,n,fp)==0) return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2004-04-06 23:48:50 +02:00
|
|
|
static bool cb_skip_list_ascii ( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
|
2004-03-03 16:00:51 +01:00
|
|
|
{
|
|
|
|
int i,n;
|
|
|
|
|
|
|
|
if( !ReadScalarA(fp,&n,T_INT, T_INT) )return false;
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
//if( !SkipScalarA(fp,T_INT) ) // Cambiato come segue il 12/2/03 altrimenti se trova un float lo salta. Invece se si chiede un float va sempre bene
|
|
|
|
if( !SkipScalarA(fp,T_FLOAT) )
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// NON OTTIMIZZATA
|
|
|
|
static bool cb_read_list_ascii( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
int i,n;
|
|
|
|
|
|
|
|
if( ReadIntA(fp,&n)==0) return false;
|
|
|
|
|
|
|
|
// Lettura con memorizzazione
|
|
|
|
char * store;
|
|
|
|
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, n);
|
|
|
|
// Determinazione memoria vettore
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,TypeSize[d->memtype1]);
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
if( !ReadScalarA(
|
|
|
|
fp,
|
|
|
|
store+i*TypeSize[d->memtype1],
|
|
|
|
d->stotype1,
|
|
|
|
d->memtype1
|
|
|
|
) )
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
static bool cb_read_list_chch( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(char));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
if( pb_fread( store+i*sizeof(char),1,1,fp)==0 ) return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_chsh( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(short));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
if( pb_fread(&c,1,1,fp)==0) return false;
|
|
|
|
*(short *)(store+i*sizeof(short)) = short(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_chin( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(int));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
if( pb_fread(&c,1,1,fp)==0) return false;
|
|
|
|
*(int *)(store+i*sizeof(int)) = int(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_chuc( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(uchar));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
if( pb_fread(&c,1,1,fp)==0) return false;
|
|
|
|
*(uchar *)(store+i*sizeof(uchar)) = uchar(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_chus( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(ushort));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
if( pb_fread(&c,1,1,fp)==0) return false;
|
|
|
|
*(ushort *)(store+i*sizeof(ushort)) = ushort(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_chui( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(uint));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
if( pb_fread(&c,1,1,fp)==0) return false;
|
|
|
|
*(uint *)(store+i*sizeof(uint)) = uint(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_chfl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(float));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
if( pb_fread(&c,1,1,fp)==0) return false;
|
|
|
|
*(float *)(store+i*sizeof(float)) = float(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_chdo( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(double));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
if( pb_fread(&c,1,1,fp)==0) return false;
|
|
|
|
*(double *)(store+i*sizeof(float)) = double(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static bool cb_read_list_shch( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(char));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(char *)(store+i*sizeof(char)) = char(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_shsh( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(short));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(short *)(store+i*sizeof(short)) = short(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_shin( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(int));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(int *)(store+i*sizeof(int)) = int(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_shuc( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(uchar));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(uchar *)(store+i*sizeof(uchar)) = uchar(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_shus( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(ushort));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(ushort *)(store+i*sizeof(ushort)) = ushort(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_shui( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(uint));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(uint *)(store+i*sizeof(uint)) = uint(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_shfl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(float));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(float *)(store+i*sizeof(float)) = float(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_shdo( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(double));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
short c; if( ReadShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(double *)(store+i*sizeof(double)) = double(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static bool cb_read_list_inch( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(char));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(char *)(store+i*sizeof(char)) = char(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_insh( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(short));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(short *)(store+i*sizeof(short)) = short(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_inin( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
// uchar n,i; prima del 5/9/03 era cosi'
|
|
|
|
// if( pb_fread(&n,1,1,fp)==0 ) return false;
|
2009-06-30 21:02:47 +02:00
|
|
|
int n=0,i;
|
2004-03-03 16:00:51 +01:00
|
|
|
switch(d->stotype2)
|
|
|
|
{
|
|
|
|
case T_CHAR : { char val; if( ReadCharB(fp,&val,d->format)==0 ) return false; n=val; } break;
|
|
|
|
case T_UCHAR : { uchar val; if( ReadUCharB(fp,&val,d->format)==0 ) return false; n=val; } break;
|
|
|
|
case T_SHORT : { short val; if( ReadShortB(fp,&val,d->format)==0 ) return false; n=val; } break;
|
|
|
|
case T_UINT : { uint val; if( ReadUIntB(fp,&val,d->format)==0 ) return false; n=val; } break;
|
|
|
|
case T_INT : { int val; if( ReadIntB(fp,&val,d->format)==0 ) return false; n=val; } break;
|
2009-06-30 21:02:47 +02:00
|
|
|
default: assert(0); break;
|
2004-03-03 16:00:51 +01:00
|
|
|
}
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(int));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
if( ReadIntB(fp,(int *)(store+i*sizeof(int)),d->format)==0 ) return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_inuc( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(uchar));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(uchar *)(store+i*sizeof(uchar)) = uchar(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_inus( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(ushort));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(ushort *)(store+i*sizeof(ushort)) = ushort(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_inui( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(uint));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(uint *)(store+i*sizeof(uint)) = uint(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_infl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(float));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(float *)(store+i*sizeof(float)) = float(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_indo( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(double));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
int c; if( ReadIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(double *)(store+i*sizeof(double)) = double(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static bool cb_read_list_ucch( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(char));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
*(char *)(store+i*sizeof(char)) = char(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_ucsh( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(short));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
*(short *)(store+i*sizeof(short)) = short(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_ucin( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(int));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
*(int *)(store+i*sizeof(int)) = int(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_ucuc( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(uchar));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
*(uchar *)(store+i*sizeof(uchar)) = uchar(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_ucus( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(ushort));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
*(ushort *)(store+i*sizeof(ushort)) = ushort(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_ucui( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(uint));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
*(uint *)(store+i*sizeof(uint)) = uint(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_ucfl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(float));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
*(float *)(store+i*sizeof(float)) = float(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_ucdo( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(double));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
|
|
|
|
*(double *)(store+i*sizeof(double)) = double(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static bool cb_read_list_usch( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(char));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(char *)(store+i*sizeof(char)) = char(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_ussh( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(short));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(short *)(store+i*sizeof(short)) = short(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_usin( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(int));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(int *)(store+i*sizeof(int)) = int(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_usuc( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(uchar));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(uchar *)(store+i*sizeof(uchar)) = uchar(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_usus( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(ushort));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(ushort *)(store+i*sizeof(ushort)) = ushort(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_usui( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(uint));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(uint *)(store+i*sizeof(uint)) = uint(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_usfl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(float));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(float *)(store+i*sizeof(float)) = float(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_usdo( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(double));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false;
|
|
|
|
*(double *)(store+i*sizeof(double)) = double(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static bool cb_read_list_uich( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(char));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(char *)(store+i*sizeof(char)) = char(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_uish( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(short));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(short *)(store+i*sizeof(short)) = short(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_uiin( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(int));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(int *)(store+i*sizeof(int)) = int(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_uiuc( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(uchar));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(uchar *)(store+i*sizeof(uchar)) = uchar(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_uius( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(ushort));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(ushort *)(store+i*sizeof(ushort)) = ushort(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_uiui( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(uint));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(uint *)(store+i*sizeof(uint)) = uint(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_uifl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(float));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(float *)(store+i*sizeof(float)) = float(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_uido( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(double));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(double *)(store+i*sizeof(double)) = double(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static bool cb_read_list_flfl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(float));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
float c; if( ReadFloatB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(float *)(store+i*sizeof(float)) = float(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_fldo( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(double));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
float c; if( ReadFloatB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(double *)(store+i*sizeof(double)) = double(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_dofl( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(float));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
double c; if( ReadDoubleB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(float *)(store+i*sizeof(float)) = float(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool cb_read_list_dodo( GZFILE fp, void * mem, PropDescriptor * d )
|
|
|
|
{
|
|
|
|
uchar n,i;
|
|
|
|
if( pb_fread(&n,1,1,fp)==0 ) return false;
|
|
|
|
char * store;
|
|
|
|
StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n));
|
|
|
|
if(d->alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,sizeof(double));
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+d->offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
store = ((char *)mem)+d->offset1;
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
double c; if( ReadDoubleB(fp,&c,d->format)==0 ) return false;
|
|
|
|
*(double *)(store+i*sizeof(double)) = double(c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void PlyFile::compile( PlyProperty * p )
|
|
|
|
{
|
|
|
|
p->desc.format = format; // copiatura formato
|
|
|
|
|
|
|
|
if(format==F_ASCII)
|
|
|
|
{
|
2005-01-03 11:35:59 +01:00
|
|
|
if(p->islist)
|
2004-03-03 16:00:51 +01:00
|
|
|
{
|
|
|
|
if(p->bestored)
|
|
|
|
p->cb = cb_read_list_ascii;
|
|
|
|
else
|
|
|
|
p->cb = cb_skip_list_ascii;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if(p->bestored)
|
|
|
|
{
|
|
|
|
p->cb = cb_read_ascii;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
switch(p->tipo)
|
|
|
|
{
|
|
|
|
case T_CHAR:
|
|
|
|
case T_SHORT:
|
|
|
|
case T_INT:
|
|
|
|
case T_UCHAR:
|
|
|
|
case T_USHORT:
|
|
|
|
case T_UINT:
|
|
|
|
p->cb = cb_skip_int_ascii;
|
|
|
|
break;
|
|
|
|
case T_FLOAT:
|
|
|
|
case T_DOUBLE:
|
|
|
|
p->cb = cb_skip_float_ascii;
|
|
|
|
break;
|
|
|
|
default: p->cb = 0; assert(0); break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2005-01-03 11:35:59 +01:00
|
|
|
if(p->islist)
|
2004-03-03 16:00:51 +01:00
|
|
|
{
|
|
|
|
if(p->bestored)
|
|
|
|
{
|
|
|
|
switch(p->desc.stotype1)
|
|
|
|
{
|
|
|
|
case T_CHAR: //================== Lettura char
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_CHAR: p->cb = cb_read_list_chch; break;
|
|
|
|
case T_SHORT: p->cb = cb_read_list_chsh; break;
|
|
|
|
case T_INT: p->cb = cb_read_list_chin; break;
|
|
|
|
case T_UCHAR: p->cb = cb_read_list_chuc; break;
|
|
|
|
case T_USHORT: p->cb = cb_read_list_chus; break;
|
|
|
|
case T_UINT: p->cb = cb_read_list_chui; break;
|
|
|
|
case T_FLOAT: p->cb = cb_read_list_chfl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_list_chdo; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_SHORT: //================== Lettura short
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_CHAR: p->cb = cb_read_list_shch; break;
|
|
|
|
case T_SHORT: p->cb = cb_read_list_shsh; break;
|
|
|
|
case T_INT: p->cb = cb_read_list_shin; break;
|
|
|
|
case T_UCHAR: p->cb = cb_read_list_shuc; break;
|
|
|
|
case T_USHORT: p->cb = cb_read_list_shus; break;
|
|
|
|
case T_UINT: p->cb = cb_read_list_shui; break;
|
|
|
|
case T_FLOAT: p->cb = cb_read_list_shfl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_list_shdo; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_INT: //================== Lettura int
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_CHAR: p->cb = cb_read_list_inch; break;
|
|
|
|
case T_SHORT: p->cb = cb_read_list_insh; break;
|
|
|
|
case T_INT: p->cb = cb_read_list_inin; break;
|
|
|
|
case T_UCHAR: p->cb = cb_read_list_inuc; break;
|
|
|
|
case T_USHORT: p->cb = cb_read_list_inus; break;
|
|
|
|
case T_UINT: p->cb = cb_read_list_inui; break;
|
|
|
|
case T_FLOAT: p->cb = cb_read_list_infl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_list_indo; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_UCHAR: //================== Lettura uchar
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_CHAR: p->cb = cb_read_list_ucch; break;
|
|
|
|
case T_SHORT: p->cb = cb_read_list_ucsh; break;
|
|
|
|
case T_INT: p->cb = cb_read_list_ucin; break;
|
|
|
|
case T_UCHAR: p->cb = cb_read_list_ucuc; break;
|
|
|
|
case T_USHORT: p->cb = cb_read_list_ucus; break;
|
|
|
|
case T_UINT: p->cb = cb_read_list_ucui; break;
|
|
|
|
case T_FLOAT: p->cb = cb_read_list_ucfl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_list_ucdo; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_USHORT: //================== Lettura ushort
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_CHAR: p->cb = cb_read_list_usch; break;
|
|
|
|
case T_SHORT: p->cb = cb_read_list_ussh; break;
|
|
|
|
case T_INT: p->cb = cb_read_list_usin; break;
|
|
|
|
case T_UCHAR: p->cb = cb_read_list_usuc; break;
|
|
|
|
case T_USHORT: p->cb = cb_read_list_usus; break;
|
|
|
|
case T_UINT: p->cb = cb_read_list_usui; break;
|
|
|
|
case T_FLOAT: p->cb = cb_read_list_usfl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_list_usdo; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_UINT: //================== Lettura uint
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_CHAR: p->cb = cb_read_list_uich; break;
|
|
|
|
case T_SHORT: p->cb = cb_read_list_uish; break;
|
|
|
|
case T_INT: p->cb = cb_read_list_uiin; break;
|
|
|
|
case T_UCHAR: p->cb = cb_read_list_uiuc; break;
|
|
|
|
case T_USHORT: p->cb = cb_read_list_uius; break;
|
|
|
|
case T_UINT: p->cb = cb_read_list_uiui; break;
|
|
|
|
case T_FLOAT: p->cb = cb_read_list_uifl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_list_uido; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_FLOAT: //================== Lettura float
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_FLOAT: p->cb = cb_read_list_flfl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_list_fldo; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_DOUBLE: //================== Lettura double
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_FLOAT: p->cb = cb_read_list_dofl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_list_dodo; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
switch(TypeSize[p->tipo])
|
|
|
|
{
|
|
|
|
case 1: p->cb = cb_skip_list_bin1; break;
|
|
|
|
case 2: p->cb = cb_skip_list_bin2; break;
|
|
|
|
case 4: p->cb = cb_skip_list_bin4; break;
|
2008-06-30 00:32:09 +02:00
|
|
|
case 8: p->cb = cb_skip_list_bin8; break; // before 29/6/08 was p->cb = cb_skip_list_bin4 but by simmetry...
|
2004-03-03 16:00:51 +01:00
|
|
|
default:p->cb = 0; assert(0); break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if(p->bestored)
|
|
|
|
{
|
|
|
|
switch(p->desc.stotype1)
|
|
|
|
{
|
|
|
|
case T_CHAR: //================== Lettura char
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_CHAR: p->cb = cb_read_chch; break;
|
|
|
|
case T_SHORT: p->cb = cb_read_chsh; break;
|
|
|
|
case T_INT: p->cb = cb_read_chin; break;
|
|
|
|
case T_UCHAR: p->cb = cb_read_chuc; break;
|
|
|
|
case T_USHORT: p->cb = cb_read_chus; break;
|
|
|
|
case T_UINT: p->cb = cb_read_chui; break;
|
|
|
|
case T_FLOAT: p->cb = cb_read_chfl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_chdo; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_SHORT: //================== Lettura short
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_CHAR: p->cb = cb_read_shch; break;
|
|
|
|
case T_SHORT: p->cb = cb_read_shsh; break;
|
|
|
|
case T_INT: p->cb = cb_read_shin; break;
|
|
|
|
case T_UCHAR: p->cb = cb_read_shuc; break;
|
|
|
|
case T_USHORT: p->cb = cb_read_shus; break;
|
|
|
|
case T_UINT: p->cb = cb_read_shui; break;
|
|
|
|
case T_FLOAT: p->cb = cb_read_shfl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_shdo; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_INT: //================== Lettura int
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_CHAR: p->cb = cb_read_inch; break;
|
|
|
|
case T_SHORT: p->cb = cb_read_insh; break;
|
|
|
|
case T_INT: p->cb = cb_read_inin; break;
|
|
|
|
case T_UCHAR: p->cb = cb_read_inuc; break;
|
|
|
|
case T_USHORT: p->cb = cb_read_inus; break;
|
|
|
|
case T_UINT: p->cb = cb_read_inui; break;
|
|
|
|
case T_FLOAT: p->cb = cb_read_infl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_indo; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_UCHAR: //================== Lettura uchar
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_CHAR: p->cb = cb_read_ucch; break;
|
|
|
|
case T_SHORT: p->cb = cb_read_ucsh; break;
|
|
|
|
case T_INT: p->cb = cb_read_ucin; break;
|
|
|
|
case T_UCHAR: p->cb = cb_read_ucuc; break;
|
|
|
|
case T_USHORT: p->cb = cb_read_ucus; break;
|
|
|
|
case T_UINT: p->cb = cb_read_ucui; break;
|
|
|
|
case T_FLOAT: p->cb = cb_read_ucfl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_ucdo; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_USHORT: //================== Lettura ushort
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_CHAR: p->cb = cb_read_usch; break;
|
|
|
|
case T_SHORT: p->cb = cb_read_ussh; break;
|
|
|
|
case T_INT: p->cb = cb_read_usin; break;
|
|
|
|
case T_UCHAR: p->cb = cb_read_usuc; break;
|
|
|
|
case T_USHORT: p->cb = cb_read_usus; break;
|
|
|
|
case T_UINT: p->cb = cb_read_usui; break;
|
|
|
|
case T_FLOAT: p->cb = cb_read_usfl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_usdo; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_UINT: //================== Lettura uint
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_CHAR: p->cb = cb_read_uich; break;
|
|
|
|
case T_SHORT: p->cb = cb_read_uish; break;
|
|
|
|
case T_INT: p->cb = cb_read_uiin; break;
|
|
|
|
case T_UCHAR: p->cb = cb_read_uiuc; break;
|
|
|
|
case T_USHORT: p->cb = cb_read_uius; break;
|
|
|
|
case T_UINT: p->cb = cb_read_uiui; break;
|
|
|
|
case T_FLOAT: p->cb = cb_read_uifl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_uido; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_FLOAT: //================== Lettura float
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_FLOAT: p->cb = cb_read_flfl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_fldo; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case T_DOUBLE: //================== Lettura double
|
|
|
|
switch(p->desc.memtype1)
|
|
|
|
{
|
|
|
|
case T_FLOAT: p->cb = cb_read_dofl; break;
|
|
|
|
case T_DOUBLE: p->cb = cb_read_dodo; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
switch(TypeSize[p->tipo])
|
|
|
|
{
|
|
|
|
case 1: p->cb = cb_skip_bin1; break;
|
|
|
|
case 2: p->cb = cb_skip_bin2; break;
|
|
|
|
case 4: p->cb = cb_skip_bin4; break;
|
|
|
|
case 8: p->cb = cb_skip_bin8; break;
|
|
|
|
default:p->cb = 0; assert(0); break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void PlyFile::compile( PlyElement * e )
|
|
|
|
{
|
|
|
|
vector<PlyProperty>::iterator i;
|
|
|
|
for(i=e->props.begin();i!=e->props.end();++i)
|
|
|
|
compile(&*i);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Funzioni statiche per la lettura di un elemento
|
|
|
|
int ReadBin ( XFILE * fp, const PlyProperty * pr, void * mem, int fmt )
|
|
|
|
{
|
|
|
|
assert(pr);
|
|
|
|
|
|
|
|
// Lettura di una lista
|
2005-01-03 11:35:59 +01:00
|
|
|
if(pr->islist)
|
2004-03-03 16:00:51 +01:00
|
|
|
{
|
|
|
|
int i,n;
|
|
|
|
|
|
|
|
if( !ReadScalarB(fp,&n,pr->tipoindex, T_INT, fmt) )
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
assert(n<12); // Valore abbastanza aleatorio
|
|
|
|
|
|
|
|
// Lettura con memorizzazione
|
|
|
|
if(pr->bestored)
|
|
|
|
{
|
|
|
|
char * store;
|
|
|
|
|
|
|
|
StoreInt( ((char *)mem)+pr->desc.offset2, pr->desc.memtype2, n);
|
|
|
|
// Determinazione memoria vettore
|
|
|
|
if(pr->desc.alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,TypeSize[pr->desc.memtype1]);
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+pr->desc.offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
store = ((char *)mem)+pr->desc.offset1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
if( !ReadScalarB(
|
|
|
|
fp,
|
|
|
|
store+i*TypeSize[pr->desc.memtype1],
|
|
|
|
pr->desc.stotype1,
|
|
|
|
pr->desc.memtype1,
|
|
|
|
fmt
|
|
|
|
) )
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Lettura senza memorizzazione
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for(i=0;i<n;i++)
|
|
|
|
if( !SkipScalarB(fp,pr->tipo) )
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Lettura di uno scalare
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Lettura con memorizzazione
|
|
|
|
if(pr->bestored)
|
|
|
|
return ReadScalarB(
|
|
|
|
fp,
|
|
|
|
((char *)mem)+pr->desc.offset1,
|
|
|
|
pr->desc.stotype1, pr->desc.memtype1,
|
|
|
|
fmt
|
|
|
|
);
|
|
|
|
// Lettura senza memorizzazione
|
|
|
|
else
|
|
|
|
return SkipScalarB(fp,pr->tipo);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int ReadAscii( XFILE * fp, const PlyProperty * pr, void * mem, int /*fmt*/ )
|
|
|
|
{
|
|
|
|
assert(pr);
|
|
|
|
assert(mem);
|
|
|
|
|
|
|
|
|
|
|
|
// Lettura di una lista
|
2005-01-03 11:35:59 +01:00
|
|
|
if(pr->islist)
|
2004-03-03 16:00:51 +01:00
|
|
|
{
|
|
|
|
int i,n;
|
|
|
|
|
|
|
|
if( !ReadScalarA(fp,&n,pr->tipoindex, T_INT) )
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
assert(n<12); // Valore abbastanza aleatorio
|
|
|
|
|
|
|
|
// Lettura con memorizzazione
|
|
|
|
if(pr->bestored)
|
|
|
|
{
|
|
|
|
char * store;
|
|
|
|
|
|
|
|
StoreInt( ((char *)mem)+pr->desc.offset2, pr->desc.memtype2, n);
|
|
|
|
// Determinazione memoria vettore
|
|
|
|
if(pr->desc.alloclist)
|
|
|
|
{
|
|
|
|
store = (char *)calloc(n,TypeSize[pr->desc.memtype1]);
|
|
|
|
assert(store);
|
|
|
|
*(char **)(((char *)mem)+pr->desc.offset1) = store;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
store = ((char *)mem)+pr->desc.offset1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
{
|
|
|
|
if( !ReadScalarA(
|
|
|
|
fp,
|
|
|
|
store+i*TypeSize[pr->desc.memtype1],
|
|
|
|
pr->desc.stotype1,
|
|
|
|
pr->desc.memtype1
|
|
|
|
) )
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Lettura senza memorizzazione
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for(i=0;i<n;++i)
|
|
|
|
if( !SkipScalarA(fp,pr->tipo) )
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Lettura scalare
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Lettura con memorizzazione
|
|
|
|
if(pr->bestored)
|
|
|
|
return ReadScalarA(
|
|
|
|
fp,
|
|
|
|
((char *)mem)+pr->desc.offset1,
|
|
|
|
pr->desc.stotype1, pr->desc.memtype1
|
|
|
|
);
|
|
|
|
// Lettura senza memorizzazione
|
|
|
|
else
|
|
|
|
return SkipScalarA(fp,pr->tipo);
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Finally! the main function
|
|
|
|
|
|
|
|
int PlyFile::Read( void * mem )
|
|
|
|
{
|
|
|
|
assert(cure);
|
|
|
|
assert(ReadCB);
|
|
|
|
|
|
|
|
vector<PlyProperty>::iterator i;
|
|
|
|
|
|
|
|
for(i=cure->props.begin();i!=cure->props.end();++i)
|
|
|
|
{
|
|
|
|
if( ! i->cb(gzfp,mem,&(i->desc)) ) return -1;
|
|
|
|
/*
|
|
|
|
int r = ReadCB(gzfp,i,mem,format);
|
|
|
|
if(!r)
|
|
|
|
return -1;
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-12-02 01:00:53 +01:00
|
|
|
void interpret_texture_name(const char*a, const char*fn, char*output){
|
2005-11-26 01:22:46 +01:00
|
|
|
int ia=0,io=0;
|
|
|
|
output[0]=0;
|
|
|
|
while (a[ia]!=0){
|
|
|
|
if (a[ia]=='<') {
|
2006-01-27 10:09:10 +01:00
|
|
|
if (static_cast<int>(strlen(a)) > ia+5) {
|
2005-11-26 01:22:46 +01:00
|
|
|
if ( ( (a[ia+1]=='t') || (a[ia+1]=='T') ) &&
|
|
|
|
( (a[ia+2]=='h') || (a[ia+2]=='H') ) &&
|
|
|
|
( (a[ia+3]=='i') || (a[ia+3]=='I') ) &&
|
|
|
|
( (a[ia+4]=='s') || (a[ia+4]=='S') ) &&
|
|
|
|
( a[ia+5]=='>' ) )
|
|
|
|
{
|
|
|
|
// substitute "<this>" with filename:
|
|
|
|
// 1) remove path from filename
|
|
|
|
int lastbar=0;
|
|
|
|
int ifn=0;
|
|
|
|
while (fn[ifn]!=0) { if ((fn[ifn]=='/') || (fn[ifn]=='\\')) lastbar=ifn+1; ifn++;}
|
|
|
|
ifn=lastbar;
|
|
|
|
char fn2[255];
|
|
|
|
while (fn[ifn]!=0) { fn2[ifn-lastbar]=fn[ifn]; ifn++;}
|
|
|
|
fn2[ifn-lastbar]=0;
|
|
|
|
|
|
|
|
// 2) remove ".ply" extention from filename
|
|
|
|
int l=ifn-lastbar;
|
|
|
|
if ((fn2[l-4]=='.')
|
|
|
|
&& ((fn2[l-3]=='P') || (fn2[l-3]=='p'))
|
|
|
|
&& ((fn2[l-2]=='L') || (fn2[l-2]=='l'))
|
|
|
|
&& ((fn2[l-1]=='Y') || (fn2[l-1]=='y')) )
|
|
|
|
fn2[l-4]=0;
|
|
|
|
|
|
|
|
// 3) append
|
|
|
|
output[io]=0;
|
|
|
|
sprintf(output,"%s%s",output,fn2);
|
|
|
|
io=strlen(output);
|
|
|
|
ia+=6; //skip the "<this>"
|
|
|
|
continue;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
output[io++]=a[ia++];
|
|
|
|
};
|
|
|
|
output[io]=0;
|
|
|
|
};
|
2004-03-03 16:00:51 +01:00
|
|
|
}
|
|
|
|
}
|