---

main.cpp

//----------------------------------------------------------------------------
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <cmath>
#include "WAVReader.h"
#include "WAVWriter.h"
#include "Synth.h"
//----------------------------------------------------------------------------
using namespace std;
using namespace ac3;
//----------------------------------------------------------------------------
#define SAMPLERATE 44100
#define LENGTH 6
//----------------------------------------------------------------------------
int main()
{
  // Create a stereo demo sound, don't care about it
  cout << "Creating demo sound...";
  
  CSynthBuffer b[4];
  int i;
  for (i = 0; i < 4; ++i)
  {
    b[i].CreateBuffer(SAMPLERATE, LENGTH*SAMPLERATE);
    b[i].FillDB(0, LENGTH*SAMPLERATE, -6.0);
  }
  
  b[0].Sinus(0, LENGTH/3*SAMPLERATE, 78.0, 110.0, 0.0);
  b[0].Sinus(LENGTH/3*SAMPLERATE, 2*LENGTH/3*SAMPLERATE, 112.0, 112.0, 0.0);
  b[1].Sinus(0, LENGTH*SAMPLERATE, 218.0, 217.0, 0.0);
  b[2].Sinus(0, LENGTH*SAMPLERATE, 222.0, 223.0, 0.0);
  b[3].Sinus(0, LENGTH/3*SAMPLERATE, 311.0, 446.0, 0.0);
  b[3].Sinus(LENGTH/3*SAMPLERATE, 2*LENGTH/3*SAMPLERATE, 446.0, 446.0, 0.0);

  CSynthBuffer res1(b, 2);
  CSynthBuffer res2(&b[2], 2);
  res1.SinusSqr(0, LENGTH*SAMPLERATE, 20.0, 20.0, 0.0);
  res2.SinusSqr(0, LENGTH*SAMPLERATE, 20.0, 20.0, 0.0);

  cout << "ready" << endl;

  // We create one buffer for each channel and store the demo sound to them.
  // We will create a 32 bit stereo WAV-file in the first step
  vector<INT32> ch1_32bit(LENGTH*SAMPLERATE);
  vector<INT32> ch2_32bit(LENGTH*SAMPLERATE);
  
  // Now transfer the content of the demo sound to the buffers.
  for (i = 0; i < LENGTH*SAMPLERATE; ++i)
  {
    ch1_32bit[i] = (INT32)floor(res1.m_samples[i] * 0x7FFFFFFF + 0.5);
    ch2_32bit[i] = (INT32)floor(res2.m_samples[i] * 0x7FFFFFFF + 0.5);
  }

  // So now we can write the data to a file.
  try
  {
    cout << "Writing demo sound to a 32 bit stereo WAV-file...";
    CWAVWriter writer;
  
    // We create a file.
    writer.OpenFile("32bit_stereo.wav", SAMPLERATE, 2, 32);

    // Now we need an array containing pointers to the buffers
    // of each channel.
    INT32* pSources[2] = { &ch1_32bit[0], &ch2_32bit[0] };

    // We are ready to write the data
    writer.Write32BitSamples(pSources, LENGTH*SAMPLERATE);

    // Note, that it is possible to call the WritexxBitSamples functions
    // any number of time in any combination writing any amount data to
    // it.
    // Actually we don't have to do that because our WAV-file is very small.

    writer.CloseFile();
    cout << "ready" << endl;

    // At this point we will read our just created WAV-file.
    CWAVReader reader;
    reader.OpenFile("32bit_stereo.wav");

    // We assume that we don't know anything about the actual WAV-file.
    // In this step we will write every channel of the file to a
    // seperate 16 bit mono file.

    // We will use a 24 bit buffer with a size of 1024 samples to store
    // the data from the source. This is only to demonstrate that both
    // classes are able to do the bit rate conversion automatically.
    // So the 32 bit source samples are converted to 24 bit and when
    // written to the file they are converted to 16 bit.
    // However, 24 bit samples are stored in 32 bit integers, so our
    // buffer has INT32 as type.
    vector<INT32> buffer(1024, 0);
    for (i = 0; i < reader.GetChannelCount(); ++i)
    {
      cout << "Writing channel " << i << " of WAV-file...";
      
      ostringstream os;
      os << "ch" << i << "_16bit_mono.wav";
      string sFilename(os.str());
      writer.OpenFile(sFilename, SAMPLERATE, 1, 16);

      UINT32 nSampleCount = reader.GetSampleCount();
      while (nSampleCount > 0)
      {
        UINT32 nToRead = (nSampleCount > 1024)? 1024 : nSampleCount;
        reader.GetSamplesAs24Bit(nToRead, i, &buffer[0]);
        INT32* pSource[1] = { &buffer[0] };
        writer.Write24BitSamples(pSource, nToRead);
        nSampleCount -= nToRead;
      }
      writer.CloseFile();
      cout << "ready" << endl;
    }
  }
  catch (CWAVWriterException wwe)
  {
    // Here we will get if an WAV-writer error occurs
    cout << "Writer error: " << wwe.GetString() << endl;
    return -1;
  }
  catch (CWAVReaderException wre)
  {
    // Here we will get if an WAV-reader error occurs
    cout << "Reader error: " << wre.GetString() << endl;
    return -1;
  }

  return 0;
}
//----------------------------------------------------------------------------

---