---

wav_writer.cpp

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
#include "WAVWriter.h"
#include "BitResConverter.h"
//----------------------------------------------------------------------------
namespace ac3 {
//----------------------------------------------------------------------------
using namespace std;
//----------------------------------------------------------------------------
// Error messages of CWAVWriterException error numbers
std::string CWAVWriterException::m_sUnknownError = "Unknown error";
std::string CWAVWriterException::m_sError[WAVWRITER_ERROR_NUM] =
{
  "No error",
  "File could not be created",
  "No file was openend",
  "Could not write to file",
  "Invalid format",
  "Format not supported"
};
//----------------------------------------------------------------------------
// WAV-file format tags
#define WAV_FORMAT_PCM 1
//----------------------------------------------------------------------------
std::string CWAVWriterException::GetString() const
{
  if ((m_nReason >= 0) &&
      (m_nReason < WAVWRITER_ERROR_NUM))
  {
    string message = m_sError[m_nReason];
    if (m_sHint.length() > 0)
    {
      message += " (";
      message += m_sHint;
      message += ")";
    }
    return message;
  }
  else
    return m_sUnknownError;
}
//----------------------------------------------------------------------------
CWAVWriter::CWAVWriter() : m_bFileOpen(false)
{
}
//----------------------------------------------------------------------------
CWAVWriter::CWAVWriter(const char* pszFilename, UINT32 nSampleRate,
                       UINT16 nChannelNum, UINT16 nBitResolution)
                        : m_bFileOpen(false)
{
  OpenFile(pszFilename, nSampleRate, nChannelNum, nBitResolution);
}
//----------------------------------------------------------------------------
CWAVWriter::CWAVWriter(const std::string& sFilename, UINT32 nSampleRate,
                       UINT16 nChannelNum, UINT16 nBitResolution)
                        : m_bFileOpen(false)
{
  OpenFile(sFilename, nSampleRate, nChannelNum, nBitResolution);
}
//----------------------------------------------------------------------------
CWAVWriter::~CWAVWriter()
{
  CloseFile();
}
//----------------------------------------------------------------------------
void CWAVWriter::OpenFile(const std::string& sFilename, UINT32 nSampleRate,
                          UINT16 nChannelNum, UINT16 nBitResolution)
{
  OpenFile(sFilename.c_str(), nSampleRate, nChannelNum, nBitResolution);
}
//----------------------------------------------------------------------------
void CWAVWriter::OpenFile(const char* pszFilename, UINT32 nSampleRate,
                          UINT16 nChannelNum, UINT16 nBitResolution)
{
  // close file if opened
  CloseFile();

  if ((nSampleRate == 0) ||
      (nChannelNum == 0) ||
      ((nBitResolution !=  8) && (nBitResolution != 16) &&
       (nBitResolution != 24) && (nBitResolution != 32)))
    throw CWAVWriterException(WAVWRITER_INVALID_FORMAT);

  // create file for writing
  m_file.open(pszFilename, ios::out | ios::binary);
  if (!m_file.is_open())
    throw CWAVWriterException(WAVWRITER_COULD_NOT_CREATE_FILE, pszFilename);

  m_nSampleRate = nSampleRate;
  m_nChannels = nChannelNum;
  m_nBitsPerSample = nBitResolution;
  m_nAllSize = 0;
  m_nDataSize = 0;
  WriteHeader();  
  
  m_bFileOpen = true;  
}
//----------------------------------------------------------------------------
void CWAVWriter::CloseFile()
{
  if (m_bFileOpen)
  {
    // finish writing the file by writing the appropriate sizes
    // write all size
    m_file.seekp(m_allSizePos);
    WriteUINT32(m_nAllSize);
    // write data size
    m_file.seekp(m_dataSizePos);
    WriteUINT32(m_nDataSize);
    m_file.close();
    m_bFileOpen = false;
  }
  else if (m_file.is_open())
  {
    // well, something went wrong, but we have to close the file
    m_file.close();
  }
}
//----------------------------------------------------------------------------
void CWAVWriter::Write8BitSamples(UINT8** ppSource, UINT32 nCount)
{
  switch (m_nBitsPerSample)
  {
    case 8:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteUINT8(ppSource[nChannel][nSample]);
            ++m_nDataSize;
            ++m_nAllSize;
        }
    }
    break;
    case 16:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteINT16(CBitResConverter::UINT8ToINT16(
                       ppSource[nChannel][nSample]));
          m_nDataSize += 2;
          m_nAllSize += 2;
        }
    }
    break;
    case 24:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteINT24(CBitResConverter::UINT8ToINT24(
                       ppSource[nChannel][nSample]));
          m_nDataSize += 3;
          m_nAllSize += 3;
        }
    }
    break;
    case 32:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteINT32(CBitResConverter::UINT8ToINT32(
                       ppSource[nChannel][nSample]));
          m_nDataSize += 4;
          m_nAllSize += 4;
        }
    }
    break;
  }
}
//----------------------------------------------------------------------------
void CWAVWriter::Write16BitSamples(INT16** ppSource, UINT32 nCount)
{
  switch (m_nBitsPerSample)
  {
    case 8:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteUINT8(CBitResConverter::INT16ToUINT8(
                       ppSource[nChannel][nSample]));
            ++m_nDataSize;
            ++m_nAllSize;
        }
    }
    break;
    case 16:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteINT16(ppSource[nChannel][nSample]);
          m_nDataSize += 2;
          m_nAllSize += 2;
        }
    }
    break;
    case 24:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteINT24(CBitResConverter::INT16ToINT24(
                       ppSource[nChannel][nSample]));
          m_nDataSize += 3;
          m_nAllSize += 3;
        }
    }
    break;
    case 32:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteINT32(CBitResConverter::INT16ToINT32(
                       ppSource[nChannel][nSample]));
          m_nDataSize += 4;
          m_nAllSize += 4;
        }
    }
    break;
  }
}
//----------------------------------------------------------------------------
void CWAVWriter::Write24BitSamples(INT32** ppSource, UINT32 nCount)
{
  switch (m_nBitsPerSample)
  {
    case 8:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteUINT8(CBitResConverter::INT24ToUINT8(
                       ppSource[nChannel][nSample]));
            ++m_nDataSize;
            ++m_nAllSize;
        }
    }
    break;
    case 16:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteINT16(CBitResConverter::INT24ToINT16(
                       ppSource[nChannel][nSample]));
          m_nDataSize += 2;
          m_nAllSize += 2;
        }
    }
    break;
    case 24:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteINT24(ppSource[nChannel][nSample]);
          m_nDataSize += 3;
          m_nAllSize += 3;
        }
    }
    break;
    case 32:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteINT32(CBitResConverter::INT24ToINT32(
                       ppSource[nChannel][nSample]));
          m_nDataSize += 4;
          m_nAllSize += 4;
        }
    }
    break;
  }
}
//----------------------------------------------------------------------------
void CWAVWriter::Write32BitSamples(INT32** ppSource, UINT32 nCount)
{
  switch (m_nBitsPerSample)
  {
    case 8:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteUINT8(CBitResConverter::INT32ToUINT8(
                       ppSource[nChannel][nSample]));
            ++m_nDataSize;
            ++m_nAllSize;
        }
    }
    break;
    case 16:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteINT16(CBitResConverter::INT32ToINT16(
                       ppSource[nChannel][nSample]));
          m_nDataSize += 2;
          m_nAllSize += 2;
        }
    }
    break;
    case 24:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteINT24(CBitResConverter::INT32ToINT24(
                       ppSource[nChannel][nSample]));
          m_nDataSize += 3;
          m_nAllSize += 3;
        }
    }
    break;
    case 32:
    {
      for (UINT32 nSample = 0; nSample < nCount; ++nSample)
        for (UINT16 nChannel = 0; nChannel < m_nChannels; ++nChannel)
        {
          WriteINT32(ppSource[nChannel][nSample]);
          m_nDataSize += 4;
          m_nAllSize += 4;
        }
    }
    break;
  }
}
//----------------------------------------------------------------------------
// Writes the header of a WAV-file.
void CWAVWriter::WriteHeader()
{
  // write RIFF chunk Header
  WriteFOURCC("RIFF");
  // save actual position for writing size of file later.
  m_allSizePos = m_file.tellp();
  WriteUINT32(0);
  WriteFOURCC("WAVE");
  m_nAllSize += 4;

  // write "fmt" subschunk
  WriteFOURCC("fmt");
  // Currently only PCM-WAVE is supported. The chunk length is
  // 16 characters.
  WriteUINT32(16);
  m_nAllSize += 8;
  
  // Structure of format chunk is:
  // UINT16 nFormatTag;
  // UINT16 nChannels;
  // UINT32 nSampleRate;
  // UINT32 nAvgBytesPerSec;
  // UINT16 nBlockAlign;
  // UINT16 nBitsPerSample;
  WriteUINT16(WAV_FORMAT_PCM);
  WriteUINT16(m_nChannels);
  WriteUINT32(m_nSampleRate);
  WriteUINT32(m_nSampleRate * (UINT32)m_nChannels * 
              (UINT32)(m_nBitsPerSample/8));
  WriteUINT16(m_nChannels * (m_nBitsPerSample/8));
  WriteUINT16(m_nBitsPerSample);
  m_nAllSize += 16;

  // write start of "data" chunk
  WriteFOURCC("data");
  // save actual position for writing data size later.
  m_dataSizePos = m_file.tellp();
  WriteUINT32(0);
  m_nAllSize += 8;
}
//----------------------------------------------------------------------------
// Writes a FOURCC code to the current position. That's a 4 character
// string. If length of string is less than 4 space characters are written.
void CWAVWriter::WriteFOURCC(std::string sFOURCC)
{
  while (sFOURCC.length() < 4)
    sFOURCC += ' ';
  if (!m_file.write(sFOURCC.c_str(), 4))
    throw CWAVWriterException(WAVWRITER_WRITE_ERROR);
}
//----------------------------------------------------------------------------
// Writes an usigned 8 bit integer to the current file position.
void CWAVWriter::WriteUINT8(UINT8 nValue)
{
  if (!m_file.write((char*)&nValue, 1))
    throw CWAVWriterException(WAVWRITER_WRITE_ERROR);
}
//----------------------------------------------------------------------------
// Writes a signed 8 bit integer to the current file position.
void CWAVWriter::WriteINT8(INT8 nValue)
{
  WriteUINT8((UINT8)nValue);
}
//----------------------------------------------------------------------------
// Writes an usigned 16 bit integer to the current file position.
void CWAVWriter::WriteUINT16(UINT16 nValue)
{
  char szBuffer[2];
  szBuffer[0] = (char)(nValue & 0xFF);
  szBuffer[1] = (char)(nValue >> 8);
  if (!m_file.write(szBuffer, 2))
    throw CWAVWriterException(WAVWRITER_WRITE_ERROR);
}
//----------------------------------------------------------------------------
// Writes a signed 16 bit integer to the current file position.
void CWAVWriter::WriteINT16(INT16 nValue)
{
  WriteUINT16((UINT16)nValue);
}
//----------------------------------------------------------------------------
// Writes an usigned 24 bit integer to the current file position.
void CWAVWriter::WriteUINT24(UINT32 nValue)
{
  char szBuffer[3];
  szBuffer[0] = (char)(nValue & 0xFF);
  nValue >>= 8;
  szBuffer[1] = (char)(nValue & 0xFF);
  szBuffer[2] = (char)(nValue >> 8);
  if (!m_file.write(szBuffer, 3))
    throw CWAVWriterException(WAVWRITER_WRITE_ERROR);
}
//----------------------------------------------------------------------------
// Writes a signed 24 bit integer to the current file position.
void CWAVWriter::WriteINT24(INT32 nValue)
{
  WriteUINT24((UINT32)nValue);
}
//----------------------------------------------------------------------------
// Writes an usigned 32 bit integer to the current file position.
void CWAVWriter::WriteUINT32(UINT32 nValue)
{
  char szBuffer[4];
  szBuffer[0] = (char)(nValue & 0xFF);
  nValue >>= 8;
  szBuffer[1] = (char)(nValue & 0xFF);
  nValue >>= 8;
  szBuffer[2] = (char)(nValue & 0xFF);
  szBuffer[3] = (char)(nValue >> 8);
  if (!m_file.write(szBuffer, 4))
    throw CWAVWriterException(WAVWRITER_WRITE_ERROR);
}
//----------------------------------------------------------------------------
// Writes a signed 32 bit integer to the current file position.
void CWAVWriter::WriteINT32(INT32 nValue)
{
  WriteUINT32((UINT32)nValue);
}
//----------------------------------------------------------------------------
} // namespace ac3
//----------------------------------------------------------------------------

---