mp_file.c

LastWave

/*..........................................................................*/
/*                                                                          */
/*      L a s t W a v e    P a c k a g e 'mp' 2.1                           */
/*                                                                          */
/*      Copyright (C) 2000 Remi Gribonval, Emmanuel Bacry and Javier Abadia.*/
/*      Copyright (C) 2001-2003 Remi Gribonval                              */
/*      email  : [e-mail]                                    */
/*      email  : [e-mail]                             */
/*                                                                          */
/*..........................................................................*/
/*                                                                          */
/*      This program is a 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 for more details.                        */
/*                                                                          */
/*      You should have received a copy of the GNU General Public License   */
/*      along with this program (in a file named COPYRIGHT);                */
/*      if not, write to the Free Software Foundation, Inc.,                */
/*      59 Temple Place, Suite 330, Boston, MA  02111-1307  USA             */
/*                                                                          */
/*..........................................................................*/


#include "lastwave.h"
#include "mp_book.h"

/*
 * Write/Read a TFContent to/from a stream, either in binary or XML-like format.
 * When called with NULL tfContent in write mode, it writes an XML-like description of the format.
 * When called with NULL tfContent in read mode, it checks the presence of a XML-like description 
 * of the format compatible with this version. If not, an error is generated.
 */
static void ReadWriteStreamTFContent_2_0(ATFCONTENT tfContent,FILE *stream,char flagWrite,char flagBinary)
{
  int cnt;
  int  bufferSize = 63;
  char buffer[63];
  if(tfContent == NULL) {   // Checking or Writing Info
    if(flagWrite) {
      fprintf(stream,"<item> <id>tfcontent</id> <version>2.0</version> <content>\n");
      fprintf(stream,"<item> <id>x0</id> <type>float</type> </item>\n");
      fprintf(stream,"<item> <id>dx</id> <type>float</type> </item>\n");
      fprintf(stream,"<item> <id>signalSize</id> <type>unsigned long</type> </item>\n");
      fprintf(stream,"</content> </item>\n");
    } else {
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>tfcontent</id> <version>2.0</version> <content>\n")) Errorf("ReadWriteStreamTFContent : bad format beginning [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>x0</id> <type>float</type> </item>\n")) Errorf("ReadWriteStreamTFContent : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>dx</id> <type>float</type> </item>\n")) Errorf("ReadWriteStreamTFContent : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>signalSize</id> <type>unsigned long</type> </item>\n")) Errorf("ReadWriteStreamTFContent : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"</content> </item>\n")) Errorf("ReadWriteStreamTFContent : bad format ending [%s]",buffer);
    }
    return;
  }

  // TODO : Shall also read/write freqIdNyquist !!!
  if(flagBinary) {// Binary mode
    if(flagWrite) {  // Writing
      fwrite((char *)(&(tfContent->x0)),sizeof(LWFLOAT),1,stream);
      fwrite((char *)(&(tfContent->dx)),sizeof(LWFLOAT),1,stream);
      fwrite((char *)(&(tfContent->signalSize)),sizeof(unsigned long),1,stream);
    } else {         // Reading
      fread((char *)(&(tfContent->x0)),sizeof(LWFLOAT),1,stream);
      fread((char *)(&(tfContent->dx)),sizeof(LWFLOAT),1,stream);
      fread((char *)(&(tfContent->signalSize)),sizeof(unsigned long),1,stream);
    }
  } else {        // XML-like mode
    if(flagWrite) {  // Writing
#ifdef NUMDOUBLE	
      fprintf(stream,"<tfcontent> %.16g %.16g %ld</tfcontent>\n",tfContent->x0,tfContent->dx,tfContent->signalSize);
#else
      fprintf(stream,"<tfcontent> %.8g %.8g %ld</tfcontent>\n",tfContent->x0,tfContent->dx,tfContent->signalSize);
#endif
    } else {         // Reading
      fgets(buffer,bufferSize,stream);
#ifdef NUMDOUBLE
      cnt = sscanf(buffer,"<tfcontent> %lf %lf %ld</tfcontent>\n",&(tfContent->x0),&(tfContent->dx),&(tfContent->signalSize));
#else
      cnt = sscanf(buffer,"<tfcontent> %f %f %ld</tfcontent>\n",&(tfContent->x0),&(tfContent->dx),&(tfContent->signalSize));
#endif
      if(cnt != 3) Errorf("ReadWriteStreamTFContent : error while reading [%s]",buffer);
    }
  }

  if(!flagWrite) {
    CheckTFContent(tfContent);
  }
}

/*
 * Write/Read an Atom to/from a stream, either in binary or XML-like format.
 * When called with NULL atom in write mode, it writes an XML-like description of the format.
 * When called with NULL atom in read mode, it checks the presence of a XML-like description 
 * of the format compatible with this version. If not, an error is generated.
 */
static void ReadWriteStreamAtom_2_0(ATOM atom,FILE *stream,char flagWrite,char flagBinary)
{
  int cnt;

  int bufferSize = 255;
  char buffer[255];

  char windowShapeName[255];
  
  if(atom == NULL) {  // Checking or Writing Info
    if(flagWrite) {
      fprintf(stream,"<item> <id>atom</id> <version>2.0</version> <content>\n");
      fprintf(stream,"<item> <id>windowShape</id> <type>char</type> </item> \n");
      fprintf(stream,"<item> <id>windowSize</id> <type>unsigned long</type> </item>\n");
      fprintf(stream,"<item> <id>timeId</id> <type>float</type> </item>\n");
      fprintf(stream,"<item> <id>freqId</id> <type>float</type> </item>\n");
      fprintf(stream,"<item> <id>chirpId</id> <type>float</type> </item>\n");
      fprintf(stream,"<item> <id>coeffR</id> <type>float</type> </item>\n");
      fprintf(stream,"<item> <id>coeffI</id> <type>float</type> </item>\n");
      fprintf(stream,"<item> <id>realGG</id> <type>float</type> </item>\n");
      fprintf(stream,"<item> <id>imagGG</id> <type>float</type> </item>\n");
      fprintf(stream,"<item> <id>coeff2</id> <type>float</type> </item>\n");
      fprintf(stream,"<item> <id>cosPhase</id> <type>float</type> </item>\n");
      fprintf(stream,"<item> <id>sinPhase</id> <type>float</type> </item>\n");
      fprintf(stream,"</content> </item>\n");
    } else {
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>atom</id> <version>2.0</version> <content>\n")) Errorf("ReadWriteStreamAtom : bad format beginning [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>windowShape</id> <type>char</type> </item> \n")) Errorf("ReadWriteStreamAtom : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>windowSize</id> <type>unsigned long</type> </item>\n")) Errorf("ReadWriteStreamAtom : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>timeId</id> <type>float</type> </item>\n")) Errorf("ReadWriteStreamAtom : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>freqId</id> <type>float</type> </item>\n")) Errorf("ReadWriteStreamAtom : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>chirpId</id> <type>float</type> </item>\n")) Errorf("ReadWriteStreamAtom : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>coeffR</id> <type>float</type> </item>\n")) Errorf("ReadWriteStreamAtom : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>coeffI</id> <type>float</type> </item>\n")) Errorf("ReadWriteStreamAtom : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>realGG</id> <type>float</type> </item>\n")) Errorf("ReadWriteStreamAtom : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>imagGG</id> <type>float</type> </item>\n")) Errorf("ReadWriteStreamAtom : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>coeff2</id> <type>float</type> </item>\n")) Errorf("ReadWriteStreamAtom : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>cosPhase</id> <type>float</type> </item>\n")) Errorf("ReadWriteStreamAtom : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>sinPhase</id> <type>float</type> </item>\n")) Errorf("ReadWriteStreamAtom : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"</content> </item>\n")) Errorf("ReadWriteStreamAtom : bad format ending [%s]",buffer);
    }
    return;
  }

  if(flagBinary) {  // Binary mode
    if(flagWrite) {    // Writing
      fwrite((char *)(&(atom->windowShape)),sizeof(char),1,stream);
      fwrite((char *)(&(atom->windowSize)),sizeof(unsigned long),1,stream);
      fwrite((char *)(&(atom->timeId)),sizeof(LWFLOAT),1,stream);
      fwrite((char *)(&(atom->freqId)),sizeof(LWFLOAT),1,stream);
      fwrite((char *)(&(atom->chirpId)),sizeof(LWFLOAT),1,stream);
      fwrite((char *)(&(atom->coeffR)),sizeof(LWFLOAT),1,stream);
      fwrite((char *)(&(atom->coeffI)),sizeof(LWFLOAT),1,stream);
      fwrite((char *)(&(atom->realGG)),sizeof(LWFLOAT),1,stream);
      fwrite((char *)(&(atom->imagGG)),sizeof(LWFLOAT),1,stream);
      fwrite((char *)(&(atom->coeff2)),sizeof(LWFLOAT),1,stream);
      fwrite((char *)(&(atom->cosPhase)),sizeof(LWFLOAT),1,stream);
      fwrite((char *)(&(atom->sinPhase)),sizeof(LWFLOAT),1,stream);
    } else {           // Reading
      fread((char *)(&(atom->windowShape)),sizeof(char),1,stream);
      fread((char *)(&(atom->windowSize)),sizeof(unsigned long),1,stream);
      fread((char *)(&(atom->timeId)),sizeof(LWFLOAT),1,stream);
      fread((char *)(&(atom->freqId)),sizeof(LWFLOAT),1,stream);
      fread((char *)(&(atom->chirpId)),sizeof(LWFLOAT),1,stream);
      fread((char *)(&(atom->coeffR)),sizeof(LWFLOAT),1,stream);
      fread((char *)(&(atom->coeffI)),sizeof(LWFLOAT),1,stream);
      fread((char *)(&(atom->realGG)),sizeof(LWFLOAT),1,stream);
      fread((char *)(&(atom->imagGG)),sizeof(LWFLOAT),1,stream);
      fread((char *)(&(atom->coeff2)),sizeof(LWFLOAT),1,stream);
      fread((char *)(&(atom->cosPhase)),sizeof(LWFLOAT),1,stream);
      fread((char *)(&(atom->sinPhase)),sizeof(LWFLOAT),1,stream);
    }
  } else {         // XML-like mode
    if(flagWrite) {   // Writing
#ifdef NUMDOUBLE
      fprintf(stream,"<atom> %s %ld %.16g %.16g %.16g %.16g %.16g %.16g %.16g %.16g %.16g %.16g </atom>\n",
	      WindowShape2Name(atom->windowShape),atom->windowSize,atom->timeId,atom->freqId,atom->chirpId,
	      atom->coeffR,atom->coeffI,atom->realGG,atom->imagGG,atom->coeff2,atom->cosPhase,atom->sinPhase);
#else
      fprintf(stream,"<atom> %s %ld %.8g %.8g %.8g %.8g %.8g %.8g %.8g %.8g %.8g %.8g </atom>\n",
	      WindowShape2Name(atom->windowShape),atom->windowSize,atom->timeId,atom->freqId,atom->chirpId,
	      atom->coeffR,atom->coeffI,atom->realGG,atom->imagGG,atom->coeff2,atom->cosPhase,atom->sinPhase);
#endif
    } else {         // Reading
      fgets(buffer,bufferSize,stream);
#ifdef NUMDOUBLE
      cnt = sscanf(buffer,"<atom> %s %ld %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf </atom>\n",
	     windowShapeName,&(atom->windowSize),&(atom->timeId),&(atom->freqId),&(atom->chirpId),
	     &(atom->coeffR),&(atom->coeffI),&(atom->realGG),&(atom->imagGG),&(atom->coeff2),&(atom->cosPhase),&(atom->sinPhase));
#else
      cnt = sscanf(buffer,"<atom> %s %ld %f %f %f %f %f %f %f %f %f %f </atom>\n",
	     windowShapeName,&(atom->windowSize),&(atom->timeId),&(atom->freqId),&(atom->chirpId),
	     &(atom->coeffR),&(atom->coeffI),&(atom->realGG),&(atom->imagGG),&(atom->coeff2),&(atom->cosPhase),&(atom->sinPhase));
#endif
      if(cnt != 12) Errorf("ReadWriteStreamAtom : error while reading [%s]",buffer);
      atom->windowShape = Name2WindowShape(windowShapeName);
    }
  }

  if(!flagWrite) {
    atom->flagGGIsSet = YES;
    CheckAtom(atom);
  }
}

/*
 * Write/Read a Molecule to/from a stream, either in binary or XML-like format.
 * When reading, a non-NULL tfContent must be provided. When writing, it must be NULL.
 * When called with NULL molecule in write mode, it writes an XML-like description of the format.
 * When called with NULL molecule in read mode, it checks the presence of a XML-like description 
 * of the format compatible with this version. If not, an error is generated.
 */
static void ReadWriteStreamMolecule_2_0(MOLECULE molecule,FILE *stream,char flagWrite,char flagBinary,ATFCONTENT tfContent)
{
  int cnt;
  int bufferSize = 63;
  char buffer[63];

  static MOLECULE  tmpMolecule = NULL;

  unsigned short dim;
  unsigned short nChannels;

  unsigned short k;
  unsigned char  channel;
  ATOM atom;

  // Initialization (once only)
  if(tmpMolecule==NULL) tmpMolecule = NewMolecule();

  if(molecule == NULL) {  // Checking or Writing Info
    if(flagWrite) {
      fprintf(stream,"<item> <id>molecule</id> <version>2.0</version> <content>\n");
      fprintf(stream,"<item> <id>dim</id> <type>unsigned short</type> </item> \n");
      fprintf(stream,"<item> <id>nChannels</id> <type>unsigned char</type> </item>\n");
      ReadWriteStreamAtom_2_0(NULL,stream,YES,NO);
      fprintf(stream,"</content> </item>\n");
    } else {
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>molecule</id> <version>2.0</version> <content>\n")) Errorf("ReadWriteStreamMolecule : bad format beginning [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>dim</id> <type>unsigned short</type> </item> \n")) Errorf("ReadWriteStreamMolecule : bad format [%s]",buffer);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"<item> <id>nChannels</id> <type>unsigned char</type> </item>\n")) Errorf("ReadWriteStreamMolecule : bad format [%s]",buffer);
      ReadWriteStreamAtom_2_0(NULL,stream,NO,NO);
      fgets(buffer,bufferSize,stream);
      if(strcmp(buffer,"</content> </item>\n")) Errorf("ReadWriteStreamMolecule : bad format ending [%s]",buffer);
    }
    return;
  }

  // Checking
  if(flagWrite && (tfContent != NULL))  Errorf("ReadWriteStreamMolecule : tfContent must be NULL when writing");
  if(!flagWrite && (tfContent == NULL)) Errorf("ReadWriteStreamMolecule : tfContent must be non-NULL when reading");


  if(!flagWrite)  ClearMolecule(molecule);

  // Read or write the dimension and number of channels
  if(flagBinary) {// Binary mode
    if(flagWrite) {  // Writing
      fwrite((char *)(&(molecule->dim)),sizeof(unsigned short),1,stream);
      fwrite((char *)(&(molecule->nChannels)),sizeof(unsigned char),1,stream);
    } else {         // Reading
      fread((char *)(&dim),sizeof(unsigned short),1,stream);
      fread((char *)(&nChannels),sizeof(unsigned char),1,stream);
    }
  } else {        // XML-like mode