audiofile.h

Go to the documentation of this file.

#ifndef AUDIOFILE_H
#define AUDIOFILE_H

#include <string>
#include <algorithm>
#include <itpp/base/vec.h>
#include <itpp/base/mat.h>
#include <itpp/base/binfile.h>
#include <itpp/srccode/audiosample.h>
#include <itpp/itexports.h>


namespace itpp
{


class Audio_Stream_Description
{
public:
  Audio_Stream_Description():_encoding(enc_unknown), _sampling_rate(0), _num_channels(0){}
  Audio_Stream_Description(Audio_Encoding e, int sr, int nc = 1):
  _encoding(e), _sampling_rate(sr), _num_channels(nc){}
  Audio_Stream_Description& set_encoding(Audio_Encoding e) {_encoding = e; return *this;}
  Audio_Stream_Description& set_sampling_rate(int sr) {_sampling_rate = sr; return *this;}
  Audio_Stream_Description& set_num_channels(int nc) {_num_channels = nc; return *this;}
  Audio_Stream_Description& set_description(const std::string& d) {_description = d; return *this;}
  Audio_Encoding get_encoding() const {return _encoding;}
  int get_sampling_rate() const {return _sampling_rate;}
  int get_num_channels() const {return _num_channels;}
  const std::string& get_description() const {return _description;}
private:
  Audio_Encoding _encoding;
  int _sampling_rate;
  int _num_channels;
  std::string _description;
};

inline bool is_valid(const Audio_Stream_Description& d)
{
  if(!encoded_sample_size(d.get_encoding())) return false;
  if(!d.get_num_channels()) return false;
  return true;
}

namespace audiofile_details{

  //abstract interfaces to read and write audio samples to streams

  class Audio_Samples_Reader_If
  {
  public:
    virtual bool read_sample(double& s, int ch) = 0;
    virtual vec read_channel(int n, int ch) = 0;
    virtual mat read(int n) = 0;
    virtual std::streamoff tell() const = 0;
    virtual bool seek(std::streamoff n) = 0;
    virtual std::streamoff num_samples() = 0;
    virtual ~Audio_Samples_Reader_If() {}
  };


  class Audio_Samples_Writer_If
  {
  public:
    virtual bool write_sample(const double& s, int ch) = 0;
    virtual bool write_channel(const vec& s, int ch) = 0;
    //Write n samples to audio channel ch
    virtual bool write(const mat& s) = 0;
    virtual std::streamoff tell() const = 0;
    virtual bool seek(std::streamoff n) = 0;
    virtual std::streamoff num_samples() = 0;
    virtual ~Audio_Samples_Writer_If() {}
  };
}

class ITPP_EXPORT SND_In_File
{
public:
  SND_In_File();
  SND_In_File(const char* fname);
  ~SND_In_File();
  bool open(const char* fname);
  void close();
  Audio_Stream_Description get_description() const {return *_description;}
  bool seek_read(std::streamoff pos)
  {
    if((pos > _num_samples) || (pos < 0))
      return false;

    if(_samples_reader)
      return _samples_reader->seek(pos);
    else
      return false;
  }
  std::streamoff tell_read()
  {
    if(_samples_reader)
      return _samples_reader->tell();
    else
      return -1;
  }
  std::streamoff num_samples() const {return _num_samples;}
  bool read_sample(double& s, int ch = 0)
  {
    if(_samples_reader)
      return _samples_reader->read_sample(s,ch);
    else
      return false;
  }
  vec read_channel(int n, int ch = 0)
  {
    if(_samples_reader)
      return _samples_reader->read_channel(n,ch);
    else
      return vec();
  }
  mat read(int n)
  {
    if(_samples_reader)
      return _samples_reader->read(n);
    else
      return mat();
  }
private:
  bifstream _str;
  std::streamoff _num_samples;
  audiofile_details::Audio_Samples_Reader_If* _samples_reader;
  Audio_Stream_Description* _description;
};

class ITPP_EXPORT SND_Out_File
{
public:
  SND_Out_File();
  SND_Out_File(const char *fname, const Audio_Stream_Description& d);
  ~SND_Out_File();
  bool open(const char *fname, const Audio_Stream_Description& d);
  void close();
  Audio_Stream_Description get_description() const {return *_description;}
  bool seek_write(std::streamoff pos)
  {
    if((pos > _num_samples) || (pos < 0))
      return false;

    if(_samples_writer)
      return _samples_writer->seek(pos);
    else
      return false;
  }
  std::streamoff tell_write()
  {
    if(_samples_writer)
      return _samples_writer->tell();
    else
      return -1;
  }
  std::streamoff num_samples() const {return _num_samples;}
  bool write_sample(const double &s, int ch = 0)
  {
    if(_samples_writer){
      bool ret = _samples_writer->write_sample(s,ch);
      if(ret){
        _num_samples = std::max(_num_samples, _samples_writer->tell());
      }
      return ret;
    }
    else
      return false;
  }
  bool write_channel(const vec &v, int ch = 0)
  {
    if(_samples_writer){
      bool ret = _samples_writer->write_channel(v,ch);
      if(ret){
        _num_samples = std::max(_num_samples, _samples_writer->tell());
      }
      return ret;
    }
    else
      return false;
  }
  bool write(const mat &m)
  {
    if(_samples_writer){
      bool ret = _samples_writer->write(m);
      if(ret){
        _num_samples = std::max(_num_samples, _samples_writer->tell());
      }
      return ret;
    }
    else
      return false;
  }
private:
  bofstream _str;
  std::streamoff _num_samples;
  audiofile_details::Audio_Samples_Writer_If* _samples_writer;
  Audio_Stream_Description* _description;
};

class ITPP_EXPORT SND_IO_File
{
public:
  SND_IO_File();
  SND_IO_File(const char *fname);
  SND_IO_File(const char *fname, const Audio_Stream_Description& d);
  ~SND_IO_File();
  bool open(const char *fname);
  bool open(const char *fname, const Audio_Stream_Description& d);
  void close();
  Audio_Stream_Description get_description() const {return *_description;}
  bool seek_read(std::streamoff pos)
  {
    if((pos > _num_samples) || (pos < 0))
      return false;

    if(_samples_reader)
      return _samples_reader->seek(pos);
    else
      return false;
  }
  std::streamoff tell_read()
  {
    if(_samples_reader)
      return _samples_reader->tell();
    else
      return -1;
  }
  bool seek_write(std::streamoff pos)
  {
    if((pos > _num_samples) || (pos < 0))
      return false;

    if(_samples_writer)
      return _samples_writer->seek(pos);
    else
      return false;
  }
  std::streamoff tell_write()
  {
    if(_samples_writer)
      return _samples_writer->tell();
    else
      return -1;
  }
  std::streamoff num_samples() const {return _num_samples;}
  bool read_sample(double& s, int ch = 0)
  {
    if(_samples_reader)
      return _samples_reader->read_sample(s,ch);
    else
      return false;
  }
  vec read_channel(int n, int ch = 0)
  {
    if(_samples_reader)
      return _samples_reader->read_channel(n,ch);
    else
      return vec();
  }
  mat read(int n)
  {
    if(_samples_reader)
      return _samples_reader->read(n);
    else
      return mat();
  }

  bool write_sample(const double &s, int ch = 0)
  {
    if(_samples_writer){
      bool ret = _samples_writer->write_sample(s,ch);
      if(ret){
        _num_samples = std::max(_num_samples, _samples_writer->tell());
      }
      return ret;
    }
    else
      return false;
  }
  bool write_channel(const vec &v, int ch = 0)
  {
    if(_samples_writer){
      bool ret = _samples_writer->write_channel(v,ch);
      if(ret){
        _num_samples = std::max(_num_samples, _samples_writer->tell());
      }
      return ret;
    }
    else
      return false;
  }
  bool write(const mat &m)
  {
    if(_samples_writer){
      bool ret = _samples_writer->write(m);
      if(ret){
        _num_samples = std::max(_num_samples, _samples_writer->tell());
      }
      return ret;
    }
    else
      return false;
  }
private:
  bfstream _str;
  std::streamoff _num_samples;
  audiofile_details::Audio_Samples_Reader_If* _samples_reader;
  audiofile_details::Audio_Samples_Writer_If* _samples_writer;
  Audio_Stream_Description* _description;
};

/*
   \brief SAP audio file input class
   \ingroup audio

   ADD DETAILED DOCUMENTATION FOR THIS CLASS!!!!!!!!!!!
*/
/*
  class SAP_In_File : virtual public Audio_File {
  public:
  // Constructor
  SAP_In_File();
  // Open the file {\em fname}.
  SAP_In_File(const char *fname);
  // Destructor
  virtual ~SAP_In_File() { close(); }

  // Open the file {\em fname}.
  virtual bool open(const char *fname);
  // Close the file.
  virtual void close();

  // ADD DOCUMENTATION FOR THIS MEMBER!!!!!!!!!!!
  virtual bool seek_read(int pos);
  // ADD DOCUMENTATION FOR THIS MEMBER!!!!!!!!!!!
  virtual int tell_read();

  // ADD DOCUMENTATION FOR THIS MEMBER!!!!!!!!!!!
  bool read(vec &v);
  // ADD DOCUMENTATION FOR THIS MEMBER!!!!!!!!!!!
  bool read(vec &v, int n);

  // ADD DOCUMENTATION FOR THIS MEMBER!!!!!!!!!!!
  const char *get_header() { return header; }

  protected:
  char header[SAP_HEADER_SIZE];
  };
*/

/*
  \brief SAP audio file output class
  \ingroup audio

  ADD DETAILED DOCUMENTATION FOR THIS CLASS!!!!!!!!!!!
*/
/*
  class SAP_Out_File : virtual public Audio_File {
  public:
  // Constructor
  SAP_Out_File();
  // ADD DOCUMENTATION FOR THIS MEMBER!!!!!!!!!!!
  SAP_Out_File(const char *fname, const char *hdr);
  // Destructor
  virtual ~SAP_Out_File() { close(); }

  // ADD DOCUMENTATION FOR THIS MEMBER!!!!!!!!!!!
  bool open(const char *fname, const char *hdr);

  // Old def. Removed since Sun CC gave warning.
  //virtual bool open(const char *fname, const char *hdr);

  // Close the file
  virtual void close();

  // ADD DOCUMENTATION FOR THIS MEMBER!!!!!!!!!!!
  bool seek_write(int pos);
  // ADD DOCUMENTATION FOR THIS MEMBER!!!!!!!!!!!
  int tell_write();

  // ADD DOCUMENTATION FOR THIS MEMBER!!!!!!!!!!!
  virtual bool write(const vec &v);
  };
*/

/*
  \brief SAP audio file input and output class
  \ingroup audio

  ADD DETAILED DOCUMENTATION FOR THIS CLASS!!!!!!!!!!!
*/
/*
  class SAP_IO_File : public SAP_In_File, public SAP_Out_File {
  public:
  // Constructor
  SAP_IO_File() { }
  // Open the file {\em fname}.
  SAP_IO_File(const char *fname) { open(fname); }
  // Destructor
  virtual ~SAP_IO_File() { close(); }

  // Open the file {\em fname}.
  virtual bool open(const char *fname);
  // Close the file
  virtual void close();
  };
*/





inline vec snd_read_channel(const char *fname, int ch = 0)
{
  SND_In_File f(fname);
  int ns = (int)std::min(f.num_samples(), (std::streamoff)std::numeric_limits<int>::max());
  return f.read_channel(ns,ch);
}
inline vec snd_read_channel(const char *fname, int ch, int len, std::streamoff beg = 0)
{
  vec ret; SND_In_File f(fname);
  if(f.seek_read(beg)) ret = f.read_channel(len,ch);
  return ret;
}

inline mat snd_read(const char *fname)
{
  SND_In_File f(fname);
  int ns = (int)std::min(f.num_samples(), (std::streamoff)std::numeric_limits<int>::max());
  return f.read(ns);
}
inline mat snd_read(const char *fname, int len, std::streamoff beg = 0)
{
  mat ret; SND_In_File f(fname);
  if(f.seek_read(beg)) ret = f.read(len);
  return ret;
}


inline bool snd_write_channel(const char *fname, const Audio_Stream_Description& descr, const vec& s, int ch = 0)
{
  SND_Out_File f(fname,descr);
  return f.write_channel(s,ch);
}

inline bool snd_write(const char *fname, const Audio_Stream_Description& descr, const mat& s)
{
  SND_Out_File f(fname,descr);
  return f.write(s);
}


/*
// Read SAP audio data
bool sap_read(const char *fname, vec &v);
// Read SAP audio data
bool sap_read(const char *fname, vec &v, int beg, int len);
// Write SAP audio data
bool sap_write(const char *fname, const vec &v, const char *hdr);
*/

} // namespace itpp

#endif // #ifndef AUDIOFILE_H