mp_file.c

LastWave

#ifdef NUMDOUBLE
  cnt += fscanf(stream,"Book energy      %lf ",&energy);
  cnt += fscanf(stream,"Book size        %d ",&size);
  cnt += fscanf(stream,"Book threshold   %lf ",&threshold);
#else
  cnt += fscanf(stream,"Book energy      %f ",&energy);
  cnt += fscanf(stream,"Book size        %d ",&size);
  cnt += fscanf(stream,"Book threshold   %f ",&threshold);
#endif
  cnt += fscanf(stream,"%[^\n\r] ",str);
  if(!strcmp(str,"BINARY"))     flagBinary = YES;
  else if(!strcmp(str,"ASCII")) flagBinary = NO;
  else  Errorf("Unknown book file type %s",str);
  cnt += fscanf(stream,"%[^\n\r] ",str);
  if(strcmp(str,"End of Header"))   Errorf("Error at the end of book header");
  
  /* Setting the TFContent */
  tfContent.signalSize = signalSize;
  tfContent.dx         = dx;
  tfContent.x0         = 0;
  CopyFieldsTFContent(&tfContent,book);

  // Initializing the 'residualEnergy'
  SizeSignal(residualEnergy,size+1,YSIG);
  ZeroSig(residualEnergy);
  residualEnergy->size = 0;

  residualEnergy->Y[0] = signalEnergy;
  residualEnergy->size++;
  
  
  if(flagBinary == NO) {
    /* Skipping two lines */
    cnt += fscanf(stream,"%[^\n\r] ",str);
    if(!strcmp(str,"ATOMS : octave timeId freqId innerProdR innerProdI phase g2Cos2 energy coeff2")) flagChirp=NO;
    else if(!strcmp(str,"ATOMS : octave timeId freqId chirpId innerProdR innerProdI phase g2Cos2 realGG imagGG energy coeff2")) flagChirp=YES;
    else Errorf("ReadBookOld : WRONG ATOMS format : %s",str);

    cnt += fscanf(stream,"%[^\n\r] ",str);
    if(!strcmp(str,"WORDS : dim energy resEnergy coeff2 status")) flagHarmo=YES;
    else Errorf("ReadBookOld : WRONG MOLECULE format : %s",str);
  }
  
  for(i = 0; i < size; i++) {
    molecule = ReadMoleculeOld(book,flagBinary,windowShape,forceMaxFreqId,flagChirp,flagHarmo,stream,&resEnergy);
    AddMolecule2Book(book,molecule);
    residualEnergy->Y[residualEnergy->size-1]=resEnergy;
    residualEnergy->size++;
  }
}

MOLECULE ReadMoleculeOld(BOOK book,char flagBinary,char windowShape,unsigned long forceMaxFreqId,char flagChirp,char flagHarmo,FILE * stream,LWFLOAT *pResEnergy)
{
  MOLECULE molecule;
  ATOM atom;
  int dim;
  int i;
  LWFLOAT energy;
  LWFLOAT resEnergy;
  LWFLOAT coeff2;
  int status;
  /* */
  int cnt;
  
  /* Checking argument */
  if(!WindowShapeIsOK(windowShape))  Errorf("ReadMoleculeOld : bad windowShape %d",windowShape);
  if(pResEnergy==NULL)               Errorf("ReadMoleculeOld : NULL pResEnergy");
  cnt = 0;
if(flagHarmo==NO) Errorf("ReadMoleculeOld : harmo=NO not implemented!");

  if(flagBinary==YES) { /* binary reading */
    cnt+= fread( (char *)(&dim), sizeof(int), 1, stream);
    cnt+= fread( (char *)(&energy), sizeof(LWFLOAT), 1, stream);
    cnt+= fread( (char *)(&resEnergy), sizeof(LWFLOAT), 1, stream);
    cnt+= fread( (char *)(&coeff2), sizeof(LWFLOAT), 1, stream);
    cnt+= fread( (char *)(&status), sizeof(int), 1, stream);
  }
  else {
#ifdef NUMDOUBLE
    cnt += fscanf(stream,"%d %lf %lf %lf %d\n",&dim,&energy,&resEnergy,&coeff2,&status);
#else
    cnt += fscanf(stream,"%d %lf %lf %lf %d\n",&dim,&energy,&resEnergy,&coeff2,&status);
#endif
  }
  
  if (cnt == EOF)   Errorf("End of file encountered in ReadMolecule");
  if (cnt != 5)     Errorf("Reading error in ReadMolecule");
  
  /* Reading atoms */
  molecule = NewMolecule();
  SizeMolecule(molecule,dim);
  for(i = 0; i < dim; i++) {
    atom = ReadAtomOld(book,flagBinary,windowShape,forceMaxFreqId,flagChirp,stream);
    if(atom==NULL) continue;
    AddAtom2Molecule(molecule,atom);
  }
  *pResEnergy= resEnergy;
  return(molecule);
}


ATOM ReadAtomOld(BOOK book,char flagBinary,char windowShape,unsigned long forceMaxFreqId,char flagChirp,FILE * stream)
{
  ATOM atom;
  int   octave;
  LWFLOAT timeId;
  LWFLOAT freqId;
  LWFLOAT chirpId = 0.0;
  
  LWFLOAT coeffR;
  LWFLOAT coeffI;
  LWFLOAT phase;
  
  LWFLOAT g2Cos2;
  LWFLOAT realGG = 0.0;
  LWFLOAT imagGG = 0.0;
  
  LWFLOAT energy;
  LWFLOAT coeff2;
  
  /* */
  int cnt;
  
  /* Checking arguments */
  if(book == NULL)                   Errorf("ReadAtomOld : NULL book");
  if(!WindowShapeIsOK(windowShape))  Errorf("ReadAtomOld : bad windowShape %d",windowShape);
  
  cnt = 0;
  /* binary version */
  if(flagBinary==YES) { 
    cnt+= fread( (char *)(&octave), sizeof(int), 1, stream);
    cnt+= fread( (char *)(&timeId), sizeof(LWFLOAT), 1, stream);
    cnt+= fread( (char *)(&freqId), sizeof(LWFLOAT), 1, stream);
    if(flagChirp)
    cnt+= fread( (char *)(&chirpId), sizeof(LWFLOAT), 1, stream);
    cnt+= fread( (char *)(&coeffR), sizeof(LWFLOAT), 1, stream);
    cnt+= fread( (char *)(&coeffI), sizeof(LWFLOAT), 1, stream);
    
    cnt+= fread( (char *)(&phase), sizeof(LWFLOAT), 1, stream);
    
    cnt+= fread( (char *)(&g2Cos2), sizeof(LWFLOAT), 1, stream);
    
    cnt+= fread( (char *)(&energy), sizeof(LWFLOAT), 1, stream);
    cnt+= fread( (char *)(&coeff2), sizeof(LWFLOAT), 1, stream);
  }
  else {
#ifdef NUMDOUBLE
    if(flagChirp==NO) {
      cnt += fscanf(stream,"%d %lf %lf %lf %lf %lf %lf %lf %lf\n",&octave,&timeId,&freqId,&coeffR,&coeffI,&phase,&g2Cos2,&energy,&coeff2);
    } else {
      cnt += fscanf(stream,"%d %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf\n",&octave,&timeId,&freqId,&chirpId,&coeffR,&coeffI,&phase,&g2Cos2,&realGG,&imagGG,&energy,&coeff2);
    }
#else
    if(flagChirp==NO) {
      cnt += fscanf(stream,"%d %f %f %f %f %f %f %f %f\n",&octave,&timeId,&freqId,&coeffR,&coeffI,&phase,&g2Cos2,&energy,&coeff2);
    } else {
      cnt += fscanf(stream,"%d %f %f %f %f %f %f %f %f %f %f %f\n",&octave,&timeId,&freqId,&chirpId,&coeffR,&coeffI,&phase,&g2Cos2,&realGG,&imagGG,&energy,&coeff2);
    }
#endif
  }
  
  if (cnt == EOF)   Errorf("End of file encountered in ReadAtomOld");
  if(flagChirp==NO) {
    if (cnt != 9)     Errorf("Reading error in ReadAtomOld");
  } else {
    if (cnt != 12)    Errorf("Reading error in ReadAtomOld");
  }
  // Case of NULL atoms
  if(octave==0) return(NULL);

  atom 	 = NewAtom();
  CopyFieldsTFContent(book,atom);
  atom->windowShape = windowShape;
  // Everything but Diracs
  if(octave >= 2) {
    atom->windowSize = 1<<octave;
    atom->timeId = timeId;
    // Converts freqId/chirpId from range [0,forceMaxFreqId/2] to range [0,GABOR_MAX_FREQID/2]
    if(!INRANGE(0,freqId,forceMaxFreqId/2)) 
      Warningf("ReadAtomOld : freqId %g > forceMaxFreqId/2 %d means that you probably under-estimated the true maxFreqId of the old book",
	       freqId,forceMaxFreqId/2);
    freqId = freqId*(GABOR_MAX_FREQID)/forceMaxFreqId;
    atom->freqId = freqId;
    if(fabsf(chirpId)>((LWFLOAT)forceMaxFreqId)/4) 
      Warningf("ReadAtomOld : |chirpId|= %g > forceMaxFreqId/4 %g means that you probably under-estimated the true maxFreqId of the old book",
	       chirpId,((LWFLOAT)forceMaxFreqId)/4);
    chirpId = chirpId*(GABOR_MAX_FREQID)/forceMaxFreqId;
    atom->chirpId = chirpId;
    
    atom->coeffR = coeffR;
    atom->coeffI = coeffI;
    atom->coeff2 = coeff2;    
    atom->cosPhase = cos(2*M_PI*(phase-(int)phase));
    atom->sinPhase = sin(2*M_PI*(phase-(int)phase));
    atom->realGG 	= realGG;
    atom->imagGG 	= imagGG;
    atom->flagGGIsSet = YES;
  }
  // Case of Dirac
  else {
    // One can check that a Dirac is exactly a 4-point Gabor atom 
    // at frequency 0.25 : w[n-timeId]cos(2*pi*(n-timeId)/4) because
    // for n<=timeId-2 and n>=timeId+2, w[n-timeId] = 0 
    // for n =timeId-1 and n =timeId+1, cos(2*pi*(n-timeId)/4)=0
    atom->windowSize = 4;
    atom->timeId     = timeId;
    atom->freqId     = GABOR_NYQUIST_FREQID/2;
    atom->chirpId    = 0.0;
    atom->coeffR     = coeffR;
    atom->coeffI     = coeffI;
    CastAtomReal(atom);
  }
  return(atom);
}


/* COMMAND */
void C_Book(char **argv)
{
  char *action;
  BOOK book = NULL;
  char *filename;
  FILE *stream;
  char opt;
  char flagBinary = NO; 

  SIGNAL decaySignal;
  unsigned long forceMaxFreqId;
 
 /* For I/O */
  
  /* Parsing command */
  argv = ParseArgv(argv,tWORD,&action,-1);
  // Write a book to a file, either in binary or in ascii
  if(!strcmp(action,"write")) {
    argv = ParseArgv(argv,tBOOK_,NULL,&book,tSTR,&filename,-1);
    if(book == NULL) book = GetBookCur();
    CheckBookNotEmpty(book);
    if ((stream = FOpen(filename, "w")) == NULL)  
      Errorf("Can't open file '%s' for writing book\n", filename);
    while( (opt = ParseOption(&argv)) ) {
      if(opt=='b') flagBinary = YES; /* for binary writing */
      else ErrorOption(opt);
    }
    NoMoreArgs(argv);
    
    ReadWriteBook(book,stream,YES,flagBinary);
    FClose(stream);	
    return;
  }
  // Read a book from a file, the binary/ascii format is determined from the header
  if(!strcmp(action,"read")) {
    argv = ParseArgv(argv,tBOOK_,NULL,&book,tSTR,&filename,0);
    if(book == NULL) book = GetBookCur();
    if ((stream = FOpen(filename, "r")) == NULL)  
      Errorf("Can't open file '%s' for reading book\n", filename);
    ReadWriteBook(book,stream,NO,flagBinary);
    FClose(stream);	
    return;
  }

  // Read a book from a file, the binary/ascii format is determined from the header
  if(!strcmp(action,"readold")) {
    argv = ParseArgv(argv,tBOOK_,NULL,&book,tSTR,&filename,tINT,&forceMaxFreqId,tSIGNAL,&decaySignal,-1);
    if(book == NULL) book = GetBookCur();
    NoMoreArgs(argv);
    
    if ((stream = FOpen(filename, "r")) == NULL) 
      Errorf("Cannot open file '%s' for reading book\n", filename);
    ReadBookOld(book,stream,forceMaxFreqId,decaySignal);
    FClose(stream);
    return;
  }
  
  Printf("Unknown action '%s'\n",action);
  ErrorUsage();
}



/* EOF */