wavfile.hh

#ifndef __SDR_WAVFILE_HH__
#define __SDR_WAVFILE_HH__

#include "node.hh"
#include <fstream>

namespace sdr {

template <class Scalar>
class WavSink: public Sink<Scalar>
{
public:
  WavSink(const std::string &filename)
    : Sink<Scalar>(), _file(filename.c_str(), std::ios_base::out|std::ios_base::binary),
      _frameCount(0), _sampleRate(0)
  {
    if (!_file.is_open()) {
      ConfigError err;
      err << "Can not open wav file for output: " << filename;
      throw err;
    }
    // Fill first 36+8 bytes with 0, the headers are written once close() gets called.
    for (size_t i=0; i<44; i++) { _file.write("\x00", 1); }

    // check format
    switch (Config::typeId<Scalar>()) {
    case Config::Type_u8:
    case Config::Type_s8:
      _bitsPerSample = 8;
      _numChanels = 1;
      break;
    case Config::Type_cu8:
    case Config::Type_cs8:
      _bitsPerSample = 8;
      _numChanels = 2;
      break;
    case Config::Type_u16:
    case Config::Type_s16:
      _bitsPerSample = 16;
      _numChanels = 1;
      break;
    case Config::Type_cu16:
    case Config::Type_cs16:
      _bitsPerSample = 16;
      _numChanels = 2;
      break;
    default:
      ConfigError err;
      err << "WAV format only allows (real) integer typed data.";
      throw err;
    }
  }

  virtual ~WavSink() {
    if (_file.is_open()) {
      this->close();
    }
  }

  virtual void config(const Config &src_cfg) {
    // Requires type, samplerate
    if (!src_cfg.hasType() || !src_cfg.hasSampleRate()) { return; }
    // Check if type matches
    if (Config::typeId<Scalar>() != src_cfg.type()) {
      ConfigError err;
      err << "Can not configure WavSink: Invalid buffer type " << src_cfg.type()
          << ", expected " << Config::typeId<Scalar>();
      throw err;
    }
    // Store sample rate
    _sampleRate = src_cfg.sampleRate();
  }

  void close() {
    if (! _file.is_open()) { return; }
    uint32_t val4;
    uint16_t val2;

    _file.seekp(0);
    _file.write("RIFF", 4);
    val4 = (uint32_t)(36u+2u*_frameCount); _file.write((char *)&val4, 4);
    _file.write("WAVE", 4);

    _file.write("fmt ", 4);
    val4 = 16; _file.write((char *)&val4, 4);  // sub header size = 16
    val2 = 1;  _file.write((char *)&val2, 2);  // format PCM = 1
    _file.write((char *)&_numChanels, 2);  // num chanels = 1
    _file.write((char *)&_sampleRate, 4);
    val4 = _numChanels*_sampleRate*(_bitsPerSample/8);
    _file.write((char *)&val4, 4); // byte rate
    val2 = _numChanels*(_bitsPerSample/8);
    _file.write((char *)&val2, 2);  // block align
    _file.write((char *)&_bitsPerSample, 2);  // bits per sample

    _file.write("data", 4);
    val4 = _numChanels*_frameCount*(_bitsPerSample/8); _file.write((char *)&val4, 4);
    _file.close();
  }

  virtual void process(const Buffer<Scalar> &buffer, bool allow_overwrite) {
    if (! _file.is_open()) { return; }
    _file.write(buffer.data(), buffer.size()*sizeof(Scalar));
    _frameCount += buffer.size();
  }


protected:
  std::fstream _file;
  uint16_t _bitsPerSample;
  uint32_t _frameCount;
  uint32_t _sampleRate;
  uint16_t _numChanels;
};



class WavSource: public Source
{
public:
  WavSource(size_t buffer_size=1024);
  WavSource(const std::string &filename, size_t buffer_size=1024);
  virtual ~WavSource();

  bool isOpen() const;
  void open(const std::string &filename);
  void close();

  bool isReal() const;

  void next();

protected:
  std::fstream _file;
  RawBuffer    _buffer;
  size_t _buffer_size;

  size_t _frame_count;
  Config::Type _type;
  double _sample_rate;
  size_t _frames_left;
};

}

#endif // __SDR_WAVFILE_HH__