/**
read spint array of size len from file and do optional data conversion.
*/
void readspintdata(file_t *fp, uint32_t magic, spint *out, long len) {
int size=0;
switch(magic & 0xFFFF) {
case M_INT64:
size=8;
break;
case M_INT32:
size=4;
break;
case M_DBL:/*saved by matlab. */
size=-8;
break;
default:
error("This is not a valid sparse spint file. magic=%x\n", magic);
}
if(sizeof(spint)==size) { /*Matched int. */
zfread(out, sizeof(spint), len, fp);
} else {
size=abs(size);
void *p=malloc(size*len);
zfread(p, size, len, fp);
switch(magic & 0xFFFF) {
case M_INT64: {
uint64_t *p2=p;
for(unsigned long j=0; j<len; j++) {
out[j]=(spint)p2[j];
}
}
break;
case M_INT32: {
uint32_t *p2=p;
for(unsigned long j=0; j<len; j++) {
out[j]=(spint)p2[j];
}
}
break;
case M_DBL: {
double *p2=p;
for(unsigned long j=0; j<len; j++) {
out[j]=(spint)p2[j];
}
}
break;
}
}
}
SDL_bool dr_load_section(unzFile *gz, SECTION s, Uint8 *current_buf) {
LIST *l;
for(l=s.item;l;l=l->next) {
SECTION_ITEM *item=l->data;
if (strcmp(item->filename,"-")!=0) {
/* nouveau fichier, on l'ouvre */
if (unzLocateFile(gz, item->filename, 2) == UNZ_END_OF_LIST_OF_FILE) {
unzClose(gz);
return SDL_FALSE;
}
if (unzOpenCurrentFile(gz) != UNZ_OK) {
unzClose(gz);
return SDL_FALSE;
}
}
create_progress_bar(item->filename);
if (item->type==LD_ALTERNATE)
zfread_alternate(gz, current_buf + item->begin, item->size, 2);
else
zfread(gz, current_buf + item->begin, item->size);
}
return SDL_TRUE;
}
/*
Obtain the current magic number, string header, and array size from a bin
format file. In file, the string header is located before the data magic.
*/
static int
read_bin_header(header_t *header, file_t *fp) {
uint32_t magic,magic2;
uint64_t nlen, nlen2;
if(fp->isfits) error("fits file is not supported\n");
while(1) {
/*read the magic number.*/
if(zfread_try(&magic, sizeof(uint32_t), 1, fp)) return -1;
/*If it is hstr, read or skip it.*/
if((magic&M_SKIP)==M_SKIP) {
continue;
} else if(magic==M_HEADER) {
zfread(&nlen, sizeof(uint64_t), 1, fp);
if(nlen>0) {
/*zfseek failed in cygwin (gzseek). so we always read in the hstr instead.*/
char hstr2[nlen];
zfread(hstr2, 1, nlen, fp);
hstr2[nlen-1]='\0'; /*make sure it is NULL terminated. */
if(header->str) {
header->str=realloc(header->str,((header->str)?strlen(header->str):0)+strlen(hstr2)+1);
strncat(header->str, hstr2, nlen);
} else {
header->str=strdup(hstr2);
}
}
zfread(&nlen2, sizeof(uint64_t),1,fp);
zfread(&magic2, sizeof(uint32_t),1,fp);
if(magic!=magic2 || nlen!=nlen2) {
info("magic=%u, magic2=%u, nlen=%lu, nlen2=%lu\n",
magic, magic2, (unsigned long)nlen, (unsigned long)nlen2);
error("Header string verification failed\n");
}
} else { //Finish
header->magic=magic;
zfread(&header->nx, sizeof(uint64_t), 1, fp);
zfread(&header->ny, sizeof(uint64_t), 1, fp);
return 0;
}
}/*while*/
return -1;
}
bool ZCharacterItem::Load(ZFile *file, int nReplayVersion)
{
enum MMatchCharItemParts_v0
{
MMCIP_HEAD_V0 = 0,
MMCIP_CHEST_V0 = 1,
MMCIP_HANDS_V0 = 2,
MMCIP_LEGS_V0 = 3,
MMCIP_FEET_V0 = 4,
MMCIP_FINGERL_V0 = 5,
MMCIP_FINGERR_V0 = 6,
MMCIP_MELEE_V0 = 7,
MMCIP_PRIMARY_V0 = 8,
MMCIP_SECONDARY_V0 = 9,
MMCIP_CUSTOM1_V0 = 10,
MMCIP_CUSTOM2_V0 = 11,
MMCIP_END_V0
};
struct Converter
{
static int v0_to_v6(int v0)
{
switch (v0)
{
case MMCIP_HEAD_V0: return MMCIP_HEAD;
case MMCIP_CHEST_V0: return MMCIP_CHEST;
case MMCIP_HANDS_V0: return MMCIP_HANDS;
case MMCIP_LEGS_V0: return MMCIP_LEGS;
case MMCIP_FEET_V0: return MMCIP_FEET;
case MMCIP_FINGERL_V0: return MMCIP_FINGERL;
case MMCIP_FINGERR_V0: return MMCIP_FINGERR;
case MMCIP_MELEE_V0: return MMCIP_MELEE;
case MMCIP_PRIMARY_V0: return MMCIP_PRIMARY;
case MMCIP_SECONDARY_V0: return MMCIP_SECONDARY;
case MMCIP_CUSTOM1_V0: return MMCIP_CUSTOM1;
case MMCIP_CUSTOM2_V0: return MMCIP_CUSTOM2;
}
return MMCIP_END;
}
static int convert(int old, int nReplayVersion)
{
int curr = old;
switch (nReplayVersion)
{
case 0:case 1:case 2:case 3:case 4:case 5:
curr = v0_to_v6(curr);
}
return curr;
}
};
int numCharItemParts = 0;
if (0 <= nReplayVersion && nReplayVersion <= 5)
numCharItemParts = MMCIP_END_V0;
else
numCharItemParts = MMCIP_END;
size_t n;
for(int i=0;i<numCharItemParts;i++)
{
int idxParts = Converter::convert(i, nReplayVersion);
ZItem *pItem=GetItem(MMatchCharItemParts(idxParts));
int nBullet;
n=zfread(&nBullet,sizeof(nBullet),1,file);
pItem->SetBulletSpare(nBullet);
if(n!=1) return false;
int nBulletCurrMagazine;
n=zfread(&nBulletCurrMagazine,sizeof(nBulletCurrMagazine),1,file);
pItem->SetBulletCurrMagazine(nBulletCurrMagazine);
if(n!=1) return false;
}
return true;
}
static mxArray *readdata(file_t *fp, mxArray **header, int start, int howmany){
/*
if start!=0 || howmany!=0 and data is cell, will only read cell from start to start+howmany
if data is not cell and start==-1, will skip the data.
Only the first call to readdata will possibly have howmany!=0
*/
if(fp->eof) return NULL;
header_t header2;
if(read_header2(&header2, fp)){
return NULL;
}
uint32_t magic=header2.magic & 0xFFFF;
if(magic==0){//end of file or empty file
fp->eof=1;
return NULL;
}
if(header){
if(header2.str)
*header=mxCreateString(header2.str);
else
*header=mxCreateString("");
}
free(header2.str); header2.str=NULL;
long nx=header2.nx;
long ny=header2.ny;
int start_save=start;
if(iscell(magic)){
if(start!=-1 && howmany==0){
if(start!=0){
error("Invalid use\n");
}
howmany=nx*ny-start;
}
}else if(fp->isfits){
if(howmany!=0){
/*first read of fits file. determine if we need it*/
if(start>0){
start=-1;//skip this block.
}
}
}else{
if((start!=0 && start!=-1) || howmany!=0){
error("invalid use");
}
}
int iscell=0;
if(fp->eof) return NULL;
mxArray *out=NULL;
switch(magic){
case MCC_ANY:
case MCC_DBL:
case MCC_CMP:
case MC_CSP:
case MC_SP:
case MC_DBL:
case MC_CMP:
case MC_INT32:
case MC_INT64:
{
iscell=1;
mwIndex ix;
if(fp->eof) return NULL;
if(nx*ny>1 && skip_unicell){
out=mxCreateCellMatrix(nx,ny);
}
mxArray *header0=mxCreateCellMatrix(nx*ny+1,1);
for(ix=0; ix<nx*ny; ix++){
int start2=0;
if(start==-1 || ix<start || ix>=start+howmany){
start2=-1;
}
mxArray *header3=NULL;
mxArray *tmp=readdata(fp, &header3, start2, 0);
if(fp->eof){
break;
}
if(tmp && tmp!=SKIPPED){
if(nx*ny==1 && skip_unicell){//only one entry
out=tmp;
}else{
mxSetCell(out, ix, tmp);
}
if(header3){
mxSetCell(header0, ix, header3);
}
}
}
if(header){
mxSetCell(header0, nx*ny, *header);
*header=header0;
}
}
break;
case M_SP64:
case M_SP32:
{
if(start==-1) error("Invalid use\n");
size_t size;
if(magic==M_SP32){
size=4;
}else if(magic==M_SP64){
size=8;
}else{
size=0;
error("Invalid magic\n");
}
uint64_t nzmax;
if(nx!=0 && ny!=0){
zfread(&nzmax,sizeof(uint64_t),1,fp);
}else{
nzmax=0;
}
if(fp->eof) return NULL;
out=mxCreateSparse(nx,ny,nzmax,mxREAL);
if(nx!=0 && ny!=0 && nzmax!=0){
if(sizeof(mwIndex)==size){/*Match*/
zfread(mxGetJc(out), size,ny+1,fp);
zfread(mxGetIr(out), size,nzmax, fp);
}else{
long i;
mwIndex *Jc0=mxGetJc(out);
mwIndex *Ir0=mxGetIr(out);
void *Jc=malloc(size*(ny+1));
void *Ir=malloc(size*nzmax);
zfread(Jc, size, ny+1, fp);
zfread(Ir, size, nzmax, fp);
if(size==4){
uint32_t* Jc2=Jc;
uint32_t* Ir2=Ir;
for(i=0; i<ny+1; i++){
Jc0[i]=Jc2[i];
}
for(i=0; i<nzmax; i++){
Ir0[i]=Ir2[i];
}
free(Jc);
free(Ir);
}else if(size==8){
uint64_t* Jc2=Jc;
uint64_t* Ir2=Ir;
for(i=0; i<ny+1; i++){
Jc0[i]=Jc2[i];
}
for(i=0; i<nzmax; i++){
Ir0[i]=Ir2[i];
}
free(Jc);
free(Ir);
}else{
mexErrMsgTxt("Invalid sparse format\n");
}
}
zfread(mxGetPr(out), sizeof(double), nzmax, fp);
}
}
break;
case M_CSP64:
case M_CSP32:/*complex sparse*/
{
if(start==-1) error("Invalid use\n");
size_t size;
switch(magic){
case M_CSP32:
size=4;break;
case M_CSP64:
size=8;break;
default:
size=0;
}
uint64_t nzmax;
if(nx!=0 && ny!=0){
zfread(&nzmax,sizeof(uint64_t),1,fp);
}else{
nzmax=0;
}
if(fp->eof) return NULL;
out=mxCreateSparse(nx,ny,nzmax,mxCOMPLEX);
if(nx!=0 && ny!=0){
long i;
if(sizeof(mwIndex)==size){
zfread(mxGetJc(out), size,ny+1,fp);
zfread(mxGetIr(out), size,nzmax, fp);
}else{
mwIndex *Jc0=mxGetJc(out);
mwIndex *Ir0=mxGetIr(out);
void *Jc=malloc(size*(ny+1));
void *Ir=malloc(size*nzmax);
zfread(Jc, size, ny+1, fp);
zfread(Ir, size, nzmax, fp);
if(size==4){
uint32_t* Jc2=Jc;
uint32_t* Ir2=Ir;
for(i=0; i<ny+1; i++){
Jc0[i]=Jc2[i];
}
for(i=0; i<nzmax; i++){
Ir0[i]=Ir2[i];
}
free(Jc);
free(Ir);
}else if(size==8){
uint64_t* Jc2=Jc;
uint64_t* Ir2=Ir;
for(i=0; i<ny+1; i++){
Jc0[i]=Jc2[i];
}
for(i=0; i<nzmax; i++){
Ir0[i]=Ir2[i];
}
free(Jc);
free(Ir);
}else{
info("size=%lu\n", size);
error("Invalid sparse format\n");
}
}
dcomplex *tmp=malloc(sizeof(dcomplex)*nzmax);
zfread(tmp, sizeof(dcomplex), nzmax, fp);
double *Pr=mxGetPr(out);
double *Pi=mxGetPi(out);
for(i=0; i<nzmax; i++){
Pr[i]=tmp[i].x;
Pi[i]=tmp[i].y;
}
free(tmp);
}
}
break;
case M_DBL:/*double array*/
if(start==-1){
if(zfseek(fp, sizeof(double)*nx*ny, SEEK_CUR)){
error("Seek failed\n");
}
out=SKIPPED;
}else{
out=mxCreateDoubleMatrix(nx,ny,mxREAL);
if(nx!=0 && ny!=0){
zfread(mxGetPr(out), sizeof(double),nx*ny,fp);
}
}
break;
case M_FLT:/*float array*/
if(start==-1){
if(zfseek(fp, sizeof(float)*nx*ny, SEEK_CUR)){
error("Seek failed\n");
}
out=SKIPPED;
}else{
mwSize nxy[2]={nx,ny};
out=mxCreateNumericArray(2, nxy,mxSINGLE_CLASS, mxREAL);
if(nx!=0 && ny!=0){
zfread((float*)mxGetPr(out), sizeof(float),nx*ny, fp);
}
}break;
case M_INT64:/*long array*/
case M_INT32:
case M_INT16:
case M_INT8:
{
int byte=0;
mxClassID id;
switch(magic){
case M_INT64: byte=8; id=mxINT64_CLASS; break;
case M_INT32: byte=4; id=mxINT32_CLASS; break;
case M_INT16: byte=2; id=mxINT16_CLASS; break;
case M_INT8: byte=1; id=mxINT8_CLASS; break;
default: id=0;
}
if(start==-1){
if(zfseek(fp, byte*nx*ny, SEEK_CUR)){
error("Seek failed\n");
}
out=SKIPPED;
}else{
out=mxCreateNumericMatrix(nx,ny,id,mxREAL);
if(nx!=0 && ny!=0){
/*Don't use sizeof(mxINT64_CLASS), it is just an integer,
not a valid C type.*/
zfread(mxGetPr(out), byte,nx*ny,fp);
}
}
}
break;
case M_CMP:/*double complex array*/
if(start==-1){
if(zfseek(fp, 16*nx*ny, SEEK_CUR)){
error("Seek failed\n");
}
out=SKIPPED;
}else{
out=mxCreateDoubleMatrix(nx,ny,mxCOMPLEX);
if(nx!=0 && ny!=0){
dcomplex*tmp=malloc(sizeof(dcomplex)*nx*ny);
zfread(tmp,sizeof(dcomplex),nx*ny,fp);
double *Pr=mxGetPr(out);
double *Pi=mxGetPi(out);
long i;
for(i=0; i<nx*ny; i++){
Pr[i]=tmp[i].x;
Pi[i]=tmp[i].y;
}
free(tmp);
}
}
break;
case M_ZMP:/*float complex array. convert to double*/
if(start==-1){
if(zfseek(fp, 8*nx*ny, SEEK_CUR)){
error("Seek failed\n");
}
out=SKIPPED;
}else{
mwSize nxy[2]={nx, ny};
out=mxCreateNumericArray(2, nxy,mxSINGLE_CLASS, mxCOMPLEX);
if(nx!=0 && ny!=0){
fcomplex*tmp=malloc(sizeof(fcomplex)*nx*ny);
zfread(tmp,sizeof(fcomplex),nx*ny,fp);
float *Pr=(float*)mxGetPr(out);
float *Pi=(float*)mxGetPi(out);
long i;
for(i=0; i<nx*ny; i++){
Pr[i]=tmp[i].x;
Pi[i]=tmp[i].y;
}
free(tmp);
}
}
break;
case M_HEADER:
break;
default:
fprintf(stderr,"magic=%x\n",magic);
warning("Unrecognized file. Please recompile the mex routines in the newest code\n");
out=NULL;
}
start=start_save;
if(!iscell && fp->isfits==1){/*fits file may contain extra extensions.*/
fp->isfits++;
int icell=0;
mxArray **outarr=NULL;
mxArray **headerarr=NULL;
while(out){
icell++;
outarr=realloc(outarr, sizeof(mxArray*)*icell);
headerarr=realloc(headerarr, sizeof(mxArray*)*icell);
if(out==SKIPPED) out=NULL;
outarr[icell-1]=out;
if(header) headerarr[icell-1]=*header;
int start2=0;
if(howmany!=0){//selective reading.
if(icell<start || icell+1>start+howmany){
start2=-1;//don't read next data.
}
}
out=readdata(fp, header, start2, 0);
}
if(icell>1){/*set output.*/
out=mxCreateCellMatrix(icell, 1);
if(header) *header=mxCreateCellMatrix(icell, 1);
int i;
for(i=0; i<icell; i++){
mxSetCell(out, i, outarr[i]);
if(header) mxSetCell(*header, i, headerarr[i]);
}
free(outarr);
free(headerarr);
}else{
out=outarr[0];
if(header) *header=headerarr[0];
}
}
if(!out){
out=mxCreateDoubleMatrix(0,0,mxREAL);
}
return out;
}
/*
Read fits header.
*/
static int
read_fits_header(header_t *header, file_t *fp) {
//, char **str, uint32_t *magic, uint64_t *nx, uint64_t *ny){
char line[82];//extra space for \n \0
int end=0;
int page=0;
int bitpix=0;
int naxis=0;
while(!end) {
int start=0;
if(page==0) {
if(zfread_try(line, 1, 80, fp)) return -1;
line[80]='\0';
if(strncmp(line, "SIMPLE", 6) && strncmp(line, "XTENSION= 'IMAGE", 16)) {
warning("Garbage in fits file %s\n", fp->fn);
return -1;
}
zfread(line, 1, 80, fp);
line[80]='\0';
if(sscanf(line+10, "%20d", &bitpix)!=1) error("Unable to determine bitpix\n");
zfread(line, 1, 80, fp);
line[80]='\0';
if(sscanf(line+10, "%20d", &naxis)!=1) error("Unable to determine naxis\n");
if(naxis>2) error("Data type not supported\n");
if(naxis>0) {
zfread(line, 1, 80, fp);
line[80]='\0';
if(sscanf(line+10, "%20lu", (unsigned long *)&header->nx)!=1) error("Unable to determine nx\n");
} else {
header->nx=0;
}
if(naxis>1) {
zfread(line, 1, 80, fp);
line[80]='\0';
if(sscanf(line+10, "%20lu", (unsigned long *)&header->ny)!=1) error("Unable to determine ny\n");
} else {
header->ny=0;
}
start=3+naxis;
}
for(int i=start; i<36; i++) {
zfread(line, 1, 80, fp);
line[80]='\0';
if(!strncmp(line, "END",3)) {
end=1;
} else {
char *hh=line;
int length=80;
int newline=1;
if(!strncmp(line, "COMMENT", 7)) {
hh=line+10;
length-=10;
newline=0;
}
//Remove trailing space.
for(int j=length-1; j>=0; j--) {
if(isspace((int)hh[j])) {
hh[j]='\0';
length--;
} else {
if(newline) {
hh[j+1]='\n';
hh[j+2]='\0';
}
break;
}
}
if(length>0) {
if(header->str) {
header->str=realloc(header->str, strlen(header->str)+length+1+newline);
} else {
header->str=malloc(length+1+newline);
(header->str)[0]='\0';
}
strcat(header->str, hh);
}
}
}
page++;
}
switch(bitpix) {
case -32:
header->magic=M_FLT;
break;
case -64:
header->magic=M_DBL;
break;
case 32:
header->magic=M_INT32;
break;
case 16:
header->magic=M_INT16;
break;
case 8:
header->magic=M_INT8;
break;
default:
error("Invalid\n");
}
return 0;
}
