manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
vcglib/wrap/ply/plylib.cpp

3622 lines
79 KiB
C++
Raw Normal View History

Initial commit
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 $
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
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
Initial commit
2004-03-03 16:00:51 +01:00
****************************************************************************/
#ifdef WIN32
#define LITTLE_MACHINE
#define assert ASSERT
#pragma warning( disable : 4267 )
#else
#include <assert.h>
#endif
#ifdef WIN32
#include <direct.h>
#endif
#include <io.h>
#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
*/
// Stringhe per la cache
const char * cachedir = "vcg_cache";
const char * bboxcacheext = ".bbox_cache";
const char * bboxheader = "BBOXCACH";
const char * ply_error_msg[] =
{
"No errors",
"Can't open file",
"Header not found",
"Eof in header",
"Format not found",
"Syntax error on header",
"Property without element",
"Bad type name",
"Element not found",
"Property not found",
"Bad type on addtoread",
"Incompatible type",
"Bad cast",
"No vertex field found",
"No face field found",
"Unespected eof",
"Face with more than 3 vertices",
"Bad vertex index in face",
"Face with no 6 texture coordinates",
"Number of color differ from vertices"
};
// 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,
int offset1,
int islist,
int alloclist,
int stotype2,
int memtype2,
int offset2
) // 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;
}
if( islist!= p->islista || stotype1 != p->tipo ||
( 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;
}
header[0] = 0;
// ********* Parsing header ***********
// Controllo header
if( pb_fgets(buf,MAXB-1,gzfp)==0 )
{
error = E_UNESPECTEDEOF;
goto error;
}
strcat(header,buf);
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;
}
strcat(header,buf);
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;
}
strcat(header,buf);
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,
int offset1,
int islist,
int alloclist,
int stotype2,
int memtype2,
int offset2
) // 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];
Commented out unused parameter names
2004-04-06 23:48:50 +02:00
static bool cb_skip_list_bin1( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
Initial commit
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;
}
Commented out unused parameter names
2004-04-06 23:48:50 +02:00
static bool cb_skip_list_bin2( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
Initial commit
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;
}
Commented out unused parameter names
2004-04-06 23:48:50 +02:00
static bool cb_skip_list_bin4( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
Initial commit
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;
}
Commented out unused parameter names
2004-04-06 23:48:50 +02:00
static bool cb_skip_list_bin8( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
Initial commit
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;
}
Commented out unused parameter names
2004-04-06 23:48:50 +02:00
static bool cb_skip_list_ascii ( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ )
Initial commit
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;
int n,i;
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;
default: assert(0);
}
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)
{
if(p->islista)
{
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
{
if(p->islista)
{
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;
case 8: p->cb = cb_skip_list_bin4; break;
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
if(pr->islista)
{
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
if(pr->islista)
{
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;
}
}
}