src/tier1/SOUNDfile.cc

/*
    MPEG Maaate: An Australian MPEG audio analysis toolkit
    Copyright (C) 2000 Commonwealth Scientific and Industrial Research Organisation
    (CSIRO), Australia.

    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 for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#if HAVE_CONFIG_H
#include <config.h>
#endif

#include <float.h>
#include "SOUNDfile.H"

/*---- put here each library implementing a file format for AllFormat ----*/
// this one includes the main header file of libMaaateMPEG
#include "MPEGfile.H"


/*------------- constructor and destructor ---------------------------*/

// this constructor finds the type of the file,
// opens it and creates an instance of AllFormat of the right
// inherited class
CSAPI_TIER1
SOUNDfile::SOUNDfile(string filestr) {
  which_max    = -1;
  maxim        = 0.0;
  format       = 0;
  filetype     = NOFILE;

  //try for an MPEG file
  format = new MPEGfile(filestr);
  if (format != NULL && format->file_ok()) {
    // it`s an  MPEGfile!
    filetype = MPEG;
    return;
    //else it`s not!
  } else if (format != 0 && format != NULL) {
    delete (MPEGfile *) format;
  }


/*-----  do the same for others file types... ----*/

  format = 0;
  //this kind of file cannot be analysed by maaate
  cerr << "MaaateP: Sorry don't recognise the file format" << endl;

return;
}


// destructor
CSAPI_TIER1
SOUNDfile::~SOUNDfile() {

  //if necessary, destroy format
  if (format) {
    switch (filetype) {
    case MPEG:
      delete (MPEGfile *) format;
      break;

/*---- add here a case for each other file type supported ----*/

    default: break;
    }
  }
  format=0;
  return;
}

/*-------------- About the file -------------------*/
// returns the file's name
CSAPI_TIER1 string
SOUNDfile::file() {
  return format->get_filename();
}

// returns true if file was opened ok, false otherwise
CSAPI_TIER1 bool
SOUNDfile::file_ok() {
  return format->file_ok();
}

// returns the file's tye
CSAPI_TIER1 Format
SOUNDfile::file_type() {
  return filetype;
}

//is it a stereo file?
CSAPI_TIER1 bool
SOUNDfile::is_stereo() {
  return format->is_stereo();
}

//number of channel
CSAPI_TIER1 int
SOUNDfile::channels() {
  return format->channel();
}

//pcm sampling rate in KHz
CSAPI_TIER1 double
SOUNDfile::sampling_rate() {
  return format->sampling_rate();
}


/*--------------- time functions --------------------------*/
// give the actual time position in sec
CSAPI_TIER1 float
SOUNDfile::at_time() {
  return format->get_windowNo() * format->get_windowDuration();
}

//give the file duration in sec
CSAPI_TIER1 float
SOUNDfile::file_duration() {
  return format->get_fileDuration() * format->get_windowDuration();
}

//give the duration of one subband sample in sec
CSAPI_TIER1 float
SOUNDfile::sample_duration( Resolution res ) {
  return format->sample_duration( res );
}

//go to position corresponding to this time
CSAPI_TIER1 bool
SOUNDfile::seek_time( float t ) {
  return seek_window( time2window( t ) );
}

//give the duration of a window in sec
CSAPI_TIER1 float
SOUNDfile::window_duration() {
  return  format->get_windowDuration();
}


/*--------------- window functions ----------------------*/
//give the position in number of window
CSAPI_TIER1 long
SOUNDfile::at_window() {
  return format->get_windowNo();
}

//give the number of window in this file
CSAPI_TIER1 long
SOUNDfile::file_window_number() {
  return format->get_fileDuration();
}

//give the nuber of subband samples in one window
CSAPI_TIER1 unsigned int
SOUNDfile::timeticks( Resolution res ) {
  return format->timeticks( res );
}

//go to position corresponding to window number w_nb
CSAPI_TIER1 bool
SOUNDfile::seek_window( long w_nb ) {
  //set which_max as maxim do not contain a meaningful value
  which_max = -1;
  return format->seek_window( w_nb );
}


/*----------- matching functions --------------*/
//convert second into window number
CSAPI_TIER1 long
SOUNDfile::time2window( float t ) {
  return (long) ( t / format->get_windowDuration() );
}

//convert window number into second
CSAPI_TIER1 float
SOUNDfile::window2time( long w_nb ) {
  return format->get_windowDuration() * (float) w_nb;
}


/*-------------- extract and skip --------------*/
//go to next window and analyse it with res
CSAPI_TIER1 bool
SOUNDfile::next_window( Resolution res) {
  //set which_max as maxim do not contain a meaningful value
  which_max = -1;
  return format->next_window( res );
}

//go to next window whitout analysing it
CSAPI_TIER1 bool
SOUNDfile::skip_window() {
  //set which_max as maxim do not contain a meaningful value
  which_max = -1;
  return format->skip_window();
}


// check if there is any more data available for analysis
CSAPI_TIER1 bool
SOUNDfile::data_available() {
  return format->data_available();
}

/*--------------- access function ---------------*/
//give the value of the subband samples of the current window
CSAPI_TIER1 double
SOUNDfile::freq_value( unsigned int ch, unsigned int sb, unsigned int nb, Resolution res) {
  return format->freq_value(ch,sb,nb,res);
}

//give the number of subband at that resolution
CSAPI_TIER1 unsigned int
SOUNDfile::nb_subbands( Resolution res ) {
  return format->nb_subbands( res );
}

// return the pcm value number no of a channel ch
CSAPI_TIER1 short
SOUNDfile::pcm (unsigned int ch, unsigned int no) {
  return format->pcm(ch, no);
}


/*------------- Analyse functions ----------------------*/
//give the mean of samples nb in subband sb on both channels if available
CSAPI_TIER1 double
SOUNDfile::freqvalue_st_mean( unsigned int sb, unsigned int nb , Resolution res )
{

  if ( format->is_stereo() ) { // in case of a stereo file it is possible to compute the mean
    return (fabs(format->freq_value(0,sb,nb,res)) + fabs(format->freq_value(1,sb,nb,res)))/2.0;
  } else { //just return the value of channel 0
    return fabs(format->freq_value(0,sb,nb,res));
  }
}

//give the rms of samples nb in subband sb on both channels if available
CSAPI_TIER1 double
SOUNDfile::freqvalue_st_rms( unsigned int sb, unsigned int nb , Resolution res )
{

  if ( format->is_stereo() ) {  // in case of a stereo file it is possible to compute the rms
    return sqrt(( pow(format->freq_value(0,sb,nb,res), 2) + pow(format->freq_value(1,sb,nb,res), 2) ) / 2.0 );
  } else { //just return the vakue of channel 0
    return fabs(format->freq_value(0,sb,nb,res));
  }
}

//give the normalised subband energy samples
CSAPI_TIER1 double
SOUNDfile::normalised_sb_nrj( unsigned int sb, unsigned int nb , Resolution res )
{
  double resu;

  //find max value over all subbands for that sample number if necessary
  if (which_max != (int) nb) {
    int nb_SB = format->nb_subbands(res);
    maxim = 0.0;

    //go from one subband to another
    for (int i = 0; i < nb_SB; i++) {
      resu = freqvalue_st_mean (i,nb,res);
      //find max
      if ( resu > maxim) {
	maxim = resu;
      }
    }

    maxim = maxim * maxim;

    //set which_max as maxim is calculated
    which_max = nb;
  }

  //return the result
  if (maxim != 0.0) { //division possible
    resu = freqvalue_st_mean (sb,nb,res);
    resu = resu * resu;
    if ( resu == 0.0 ) { // unuseful to calculate anything, just set result as -infinity
      return - DBL_MAX;
    } else if ( resu >= maxim ) { //avoid problem of this calculation
      return 0.0;
    } else { // resu != 0.0 and resu != maxim
      return 10.0 * log10 ( resu / maxim); //calculation of subband energies
    }

  } else { // division impossible just set result as - infinity
    return - DBL_MAX;
  }
}


//give a coarse and quick idea of the value in that subband
CSAPI_TIER1 double
SOUNDfile::subband_scalefactor ( unsigned int sb, Resolution res )
{
  switch (filetype) {
  case MPEG:
    if (((MPEGfile *) format)->layer() != III) {
      return ((MPEGfile *) format)->scalefactor(0,sb);
      break;
    }// else go to default case!
  default: //find the max of freq_sample over the window in this subband
    double max = 0;
    double temp;
    int ch_max = is_stereo() ? channels() : 1;
    for (int ch = 0; ch < ch_max; ch++) {
      for (unsigned int nb = 0; nb < (format->timeticks(res)); nb++) {
	temp = fabs(format->freq_value(ch,sb,nb,res));
	if ( temp > max ) max = temp;
      }
    }
    return max;
  }

}


//give the mean of samples over the current window
CSAPI_TIER1 double
SOUNDfile::subband_mean( unsigned int sb, Resolution res )
{

  int num = format->timeticks(res);
  double sum = 0.0;

  //calculate the sum over the window
  for (int i=0;i<num;i++) {
    sum += freqvalue_st_mean (sb,i,res);
  }

  return (sum/((double) num));
}

//give the rms of samples over the current window
CSAPI_TIER1 double
SOUNDfile::subband_rms( unsigned int sb, Resolution res )
{

  int num = format->timeticks(res);
  double sum = 0.0;

  //calculate the sum of square values over the current window
  for (int i=0;i<num;i++) {
    sum += pow( freqvalue_st_mean (sb,i,res) , 2);
  }

  return sqrt(sum/((double) num));
}

//give the normalised subband energy over the current window
CSAPI_TIER1 double
SOUNDfile::subband_nrj( unsigned int sb, Resolution res )
{
  double resu;

  //find max value over all subbands for the current window if necessary
  if (which_max != -2) {
    int nb_SB = format->nb_subbands(res);
    maxim = 0.0;

    //go from one subband to another
    for (int i = 0; i < nb_SB; i++) {
      resu = subband_mean (i,res);
      //find max
      if ( resu > maxim) {
	maxim = resu;
      }
    }
    maxim = maxim * maxim;
    //set which_max as maxim is calculated for that window
    which_max = -2;
  }


  if (maxim != 0.0) { //division possible
    resu = subband_mean (sb,res);
    resu = resu * resu;
    if ( resu == 0.0) { //unuseful to calculate anything, just set result as -infinity
      return - DBL_MAX;
    } else if ( resu >= maxim ) { //due to a problem avoid this calculation
      return 0.0;
    } else { //resu != 0 and resu != maxim
      return 10.0 * log10 ( resu / maxim ); //calculation of subband energies
    }

  } else { // division impossible just set result as - infinity
    return - DBL_MAX;
  }
}


/*-------------- pcm decoder -------------------*/
//fill buffer with pcm samples corresponding to the "windows"
//windows following the current window.
//This moves the current position pointer while decoding
//and return the number of samples in buffer.

CSAPI_TIER1 long
SOUNDfile::decode (short * buffer, long windows, Channels ch) {
  return format->decode(buffer,windows,ch);
}