---

wav_reader.cpp

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
#include <vector>
#include <cmath>
#include "WAVReader.h"
#include "BitResConverter.h"
//----------------------------------------------------------------------------
namespace ac3 {
//----------------------------------------------------------------------------
using namespace std;
//----------------------------------------------------------------------------
// Error messages of CWAVReaderException error numbers
std::string CWAVReaderException::m_sUnknownError = "Unknown error";
std::string CWAVReaderException::m_sError[WAVREADER_ERROR_NUM] =
{
  "No error",
  "File could not be opened",
  "No file is opened",
  "Read error (file corrupt?)",
  "Invalid format (file corrupt?)",
  "Format not supported",
  "Chunk not found",
  "Sample does not exist",
  "Channel does not exist"
};
//----------------------------------------------------------------------------
// WAV-file format tags
#define WAV_FORMAT_PCM 1
//----------------------------------------------------------------------------
std::string CWAVReaderException::GetString() const
{
  if ((m_nReason >= 0) &&
      (m_nReason < WAVREADER_ERROR_NUM))
  {
    string message = m_sError[m_nReason];
    if (m_sHint.length() > 0)
    {
      message += " (";
      message += m_sHint;
      message += ")";
    }
    return message;
  }
  else
    return m_sUnknownError;
}
//----------------------------------------------------------------------------
CWAVReader::CWAVReader() : m_bFileOpen(false)
{
}
//----------------------------------------------------------------------------
CWAVReader::CWAVReader(const char* pszFilename) : m_bFileOpen(false)
{
  OpenFile(pszFilename);
}
//----------------------------------------------------------------------------
CWAVReader::CWAVReader(const std::string& sFilename) : m_bFileOpen(false)
{
  OpenFile(sFilename);
}
//----------------------------------------------------------------------------
CWAVReader::~CWAVReader()
{
  CloseFile();
}
//----------------------------------------------------------------------------
void CWAVReader::CloseFile()
{
  if (m_bFileOpen)
  {
    m_file.close();
    m_bFileOpen = false;
  }
}
//----------------------------------------------------------------------------
void CWAVReader::OpenFile(const std::string& sFilename)
{
  OpenFile(sFilename.c_str());
}
//----------------------------------------------------------------------------
void CWAVReader::OpenFile(const char* pszFilename)
{
  // open the file
  CloseFile();
  m_file.open(pszFilename, ios::in | ios::binary);
  if (!m_file.is_open())
    throw CWAVReaderException(WAVREADER_FILE_OPEN_ERROR, pszFilename);

  // get information upon the WAV-file
  ParseHeader();

  m_bFileOpen = true;
}
//----------------------------------------------------------------------------
void CWAVReader::GetSamplesAs8Bit(UINT32 nCount, UINT16 nChannel,
                                  UINT8* pnBuffer, UINT32 nStart)
{
  // read the samples into a temporary buffer and convert them
  // to the appropriate resolution
  switch (m_nBitsPerSample)
  {
    case 8:
    {
      vector<UINT8> data(nCount);
      Read8BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 8,
                                             pnBuffer, 8);
    }
    break;
    case 16:
    {
      vector<INT16> data(nCount);
      Read16BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 16,
                                             pnBuffer, 8);
    }
    break;
    case 24:
    {
      vector<INT32> data(nCount);
      Read24BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 24,
                                             pnBuffer, 8);
    }
    break;
    case 32:
    {
      vector<INT32> data(nCount);
      Read32BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 32,
                                             pnBuffer, 8);
    }
    break;
  }
}
//----------------------------------------------------------------------------
void CWAVReader::GetSamplesAs16Bit(UINT32 nCount, UINT16 nChannel,
                                   INT16* pnBuffer, UINT32 nStart)
{
  // read the samples into a temporary buffer and convert them
  // to the appropriate resolution
  switch (m_nBitsPerSample)
  {
    case 8:
    {
      vector<UINT8> data(nCount);
      Read8BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 8,
                                             pnBuffer, 16);
    }
    break;
    case 16:
    {
      vector<INT16> data(nCount);
      Read16BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 16,
                                             pnBuffer, 16);
    }
    break;
    case 24:
    {
      vector<INT32> data(nCount);
      Read24BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 24,
                                             pnBuffer, 16);
    }
    break;
    case 32:
    {
      vector<INT32> data(nCount);
      Read32BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 32,
                                             pnBuffer, 16);
    }
    break;
  }
}
//----------------------------------------------------------------------------
void CWAVReader::GetSamplesAs24Bit(UINT32 nCount, UINT16 nChannel,
                                   INT32* pnBuffer, UINT32 nStart)
{
  // read the samples into a temporary buffer and convert them
  // to the appropriate resolution
  switch (m_nBitsPerSample)
  {
    case 8:
    {
      vector<UINT8> data(nCount);
      Read8BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 8,
                                             pnBuffer, 24);
    }
    break;
    case 16:
    {
      vector<INT16> data(nCount);
      Read16BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 16,
                                             pnBuffer, 24);
    }
    break;
    case 24:
    {
      vector<INT32> data(nCount);
      Read24BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 24,
                                             pnBuffer, 24);
    }
    break;
    case 32:
    {
      vector<INT32> data(nCount);
      Read32BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 32,
                                             pnBuffer, 24);
    }
    break;
  }
}
//----------------------------------------------------------------------------
void CWAVReader::GetSamplesAs32Bit(UINT32 nCount, UINT16 nChannel,
                                   INT32* pnBuffer, UINT32 nStart)
{
  // read the samples into a temporary buffer and convert them
  // to the appropriate resolution
  switch (m_nBitsPerSample)
  {
    case 8:
    {
      vector<UINT8> data(nCount);
      Read8BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 8,
                                             pnBuffer, 32);
    }
    break;
    case 16:
    {
      vector<INT16> data(nCount);
      Read16BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 16,
                                             pnBuffer, 32);
    }
    break;
    case 24:
    {
      vector<INT32> data(nCount);
      Read24BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 24,
                                             pnBuffer, 32);
    }
    break;
    case 32:
    {
      vector<INT32> data(nCount);
      Read32BitSamples(nStart, nCount, nChannel, &data[0]);
      CBitResConverter::ConvertBitResolution(nCount, &data[0], 32,
                                             pnBuffer, 32);
    }
    break;
  }
}
//----------------------------------------------------------------------------
void CWAVReader::SetChannelPos(UINT16 nChannel, UINT32 nNewPos)
{
  // check if channel exists
  if (nChannel >= m_nChannels)
    throw CWAVReaderException(WAVREADER_CHANNEL_DOES_NOT_EXIST);

  // check if the position exists
  if (!SampleExists(nNewPos))
    throw CWAVReaderException(WAVREADER_SAMPLE_DOES_NOT_EXIST);

  m_channelPos[nChannel] = nNewPos;
}
//----------------------------------------------------------------------------
UINT32 CWAVReader::GetChannelPos(UINT16 nChannel)
{
  // check if channel exists
  if (nChannel >= m_nChannels)
    throw CWAVReaderException(WAVREADER_CHANNEL_DOES_NOT_EXIST);

  return m_channelPos[nChannel];
}
//----------------------------------------------------------------------------
UINT32 CWAVReader::GetSampleRate() const
{
  if (!m_bFileOpen)
    throw CWAVReaderException(WAVREADER_FILE_NOT_OPEN);
  return m_nSampleRate;
}
//----------------------------------------------------------------------------
UINT16 CWAVReader::GetChannelCount() const
{
  if (!m_bFileOpen)
    throw CWAVReaderException(WAVREADER_FILE_NOT_OPEN);
  return m_nChannels;
}
//----------------------------------------------------------------------------
UINT16 CWAVReader::GetBitsPerSample() const
{
  if (!m_bFileOpen)
    throw CWAVReaderException(WAVREADER_FILE_NOT_OPEN);
  return m_nBitsPerSample;
}
//----------------------------------------------------------------------------
UINT32 CWAVReader::GetSampleCount() const
{
  if (!m_bFileOpen)
    throw CWAVReaderException(WAVREADER_FILE_NOT_OPEN);
  return (m_nDataSize / (m_nChannels * (m_nBitsPerSample / 8)));
}
//----------------------------------------------------------------------------
UINT32 CWAVReader::TimeToSample(double dSec) const
{
  if (!m_bFileOpen)
    throw CWAVReaderException(WAVREADER_FILE_NOT_OPEN);
  return (UINT32)floor((double)m_nSampleRate * dSec);
}
//----------------------------------------------------------------------------
double CWAVReader::SampleToTime(UINT32 nSample) const
{
  if (!m_bFileOpen)
    throw CWAVReaderException(WAVREADER_FILE_NOT_OPEN);
  return (double)nSample / (double)m_nSampleRate;
}
//----------------------------------------------------------------------------
// Reads the header of a WAV-file. Throws a WAVREADER_INVALID_FORMAT
// exception if format is not supported.
void CWAVReader::ParseHeader()
{
  // parse RIFF chunk Header
  string sFOURCC = ReadFOURCC();
  if (sFOURCC != "RIFF")
    throw CWAVReaderException(WAVREADER_INVALID_FORMAT);
  m_nRiffChunkDataSize = ReadUINT32();
  sFOURCC = ReadFOURCC();
  if (sFOURCC != "WAVE")
    throw CWAVReaderException(WAVREADER_INVALID_FORMAT);

  // parse "fmt" subchunk
  UINT32 nFormatLength = SeekToSubchunk("fmt");
  // Currently only PCM-WAVE is supported. The chunk length is at least
  // 16 characters.
  if (nFormatLength < 16)
    throw CWAVReaderException(WAVREADER_INVALID_FORMAT);

  // Structure of format chunk is:
  // UINT16 nFormatTag;
  // UINT16 nChannels;
  // UINT32 nSampleRate;
  // UINT32 nAvgBytesPerSec;
  // UINT16 nBlockAlign;
  // UINT16 nBitsPerSample;
  
  // Currently only PCM WAV-files are supported
  UINT16 nFormatTag = ReadUINT16();
  if (nFormatTag != WAV_FORMAT_PCM)
    throw CWAVReaderException(WAVREADER_UNSUPPORTED_FORMAT);
  m_nChannels = ReadUINT16();
  m_nSampleRate = ReadUINT32();
  ReadUINT32();
  ReadUINT16();
  // only 8, 16, 24 and 32bit WAV-files are supported
  m_nBitsPerSample = ReadUINT16();
  if ((m_nBitsPerSample !=  8) &&
      (m_nBitsPerSample != 16) &&
      (m_nBitsPerSample != 24) &&
      (m_nBitsPerSample != 32))
    throw CWAVReaderException(WAVREADER_UNSUPPORTED_FORMAT);

  // Find beginning of the data and save the size and position
  m_nDataSize = SeekToSubchunk("data");
  m_dataPos = m_file.tellg();

  // set the channel positions to 0
  m_channelPos.resize(m_nChannels);
  fill(m_channelPos.begin(), m_channelPos.end(), 0);
}
//----------------------------------------------------------------------------
// Sets the file position to the start of a subchunk. Returns the length
// of the data in the subchunk.
UINT32 CWAVReader::SeekToSubchunk(const std::string& sSubchunk)
{
  // begin search at file position 12 (after the RIFF chunk header)
  m_file.seekg(12, ios::beg);
  UINT32 nBytesLeft = m_nRiffChunkDataSize - 4;
  
  while (nBytesLeft >= 8)
  {
    string sFOURCC = ReadFOURCC();
    UINT32 nSubchunkSize = ReadUINT32();
    if (sFOURCC == sSubchunk)
      return nSubchunkSize;
    nBytesLeft -= nSubchunkSize;
    if (nBytesLeft >= 8)
      m_file.seekg(nSubchunkSize, ios::cur);
  }
  throw CWAVReaderException(WAVREADER_CHUNK_NOT_FOUND, sSubchunk);
}
//----------------------------------------------------------------------------
void CWAVReader::SeekToSample(UINT32 nSample)
{
  m_file.seekg(m_dataPos);
  UINT32 nOffset = nSample * m_nChannels * (m_nBitsPerSample / 8);
  m_file.seekg(nOffset, ios::cur);
}
//----------------------------------------------------------------------------
bool CWAVReader::SampleExists(UINT32 nSample) const
{
  UINT32 nBytesPerSample = m_nChannels * (m_nBitsPerSample / 8);
  if (nSample*nBytesPerSample < m_nDataSize)
    return true;
  return false;
}
//----------------------------------------------------------------------------
void CWAVReader::Read8BitSamples(UINT32 nStart, UINT32 nCount,
                                 UINT16 nChannel, UINT8* pnBuffer)
{
  if (!m_bFileOpen)
    throw CWAVReaderException(WAVREADER_FILE_NOT_OPEN);
 
  // check if the range exists
  if (nStart == (UINT32)-1)
    nStart = m_channelPos[nChannel];
  else
    m_channelPos[nChannel] = nStart;
    
  if (!SampleExists(nStart) ||
      !SampleExists(nStart + nCount - 1))
    throw CWAVReaderException(WAVREADER_SAMPLE_DOES_NOT_EXIST);

  // check if channel exists
  if (nChannel >= m_nChannels)
    throw CWAVReaderException(WAVREADER_CHANNEL_DOES_NOT_EXIST);

  SeekToSample(nStart);
  for (UINT32 i = 0; i < nCount; ++i, ++pnBuffer)
  {
    int nActChannel = 0;
    while (nActChannel != nChannel)
    {
      ReadUINT8();
      ++nActChannel;
    }
    *pnBuffer = ReadUINT8();
    ++m_channelPos[nChannel];
    ++nActChannel;
    while (nActChannel < m_nChannels)
    {
      ReadUINT8();
      ++nActChannel;
    }
  }
}
//----------------------------------------------------------------------------
void CWAVReader::Read16BitSamples(UINT32 nStart, UINT32 nCount,
                                  UINT16 nChannel, INT16* pnBuffer)
{
  if (!m_bFileOpen)
    throw CWAVReaderException(WAVREADER_FILE_NOT_OPEN);
 
  // check if the range exists
  if (nStart == (UINT32)-1)
    nStart = m_channelPos[nChannel];
  else
    m_channelPos[nChannel] = nStart;
    
  if (!SampleExists(nStart) ||
      !SampleExists(nStart + nCount - 1))
    throw CWAVReaderException(WAVREADER_SAMPLE_DOES_NOT_EXIST);

  // check if channel exists
  if (nChannel >= m_nChannels)
    throw CWAVReaderException(WAVREADER_CHANNEL_DOES_NOT_EXIST);

  SeekToSample(nStart);
  for (UINT32 i = 0; i < nCount; ++i, ++pnBuffer)
  {
    int nActChannel = 0;
    while (nActChannel != nChannel)
    {
      ReadINT16();
      ++nActChannel;
    }
    *pnBuffer = ReadINT16();
    ++m_channelPos[nChannel];
    ++nActChannel;
    while (nActChannel < m_nChannels)
    {
      ReadINT16();
      ++nActChannel;
    }
  }
}
//----------------------------------------------------------------------------
void CWAVReader::Read24BitSamples(UINT32 nStart, UINT32 nCount,
                                  UINT16 nChannel, INT32* pnBuffer)
{
  if (!m_bFileOpen)
    throw CWAVReaderException(WAVREADER_FILE_NOT_OPEN);
 
  // check if the range exists
  if (nStart == (UINT32)-1)
    nStart = m_channelPos[nChannel];
  else
    m_channelPos[nChannel] = nStart;

  if (!SampleExists(nStart) ||
      !SampleExists(nStart + nCount - 1))
    throw CWAVReaderException(WAVREADER_SAMPLE_DOES_NOT_EXIST);

  // check if channel exists
  if (nChannel >= m_nChannels)
    throw CWAVReaderException(WAVREADER_CHANNEL_DOES_NOT_EXIST);
    
  SeekToSample(nStart);
  for (UINT32 i = 0; i < nCount; ++i, ++pnBuffer)
  {
    int nActChannel = 0;
    while (nActChannel != nChannel)
    {
      ReadINT24();
      ++nActChannel;
    }
    *pnBuffer = ReadINT24();
    ++m_channelPos[nChannel];
    ++nActChannel;
    while (nActChannel < m_nChannels)
    {
      ReadINT24();
      ++nActChannel;
    }
  }
}
//----------------------------------------------------------------------------
void CWAVReader::Read32BitSamples(UINT32 nStart, UINT32 nCount,
                                  UINT16 nChannel, INT32* pnBuffer)
{
  if (!m_bFileOpen)
    throw CWAVReaderException(WAVREADER_FILE_NOT_OPEN);
 
  // check if the range exists
  if (nStart == (UINT32)-1)
    nStart = m_channelPos[nChannel];
  else
    m_channelPos[nChannel] = nStart;

  if (!SampleExists(nStart) ||
      !SampleExists(nStart + nCount - 1))
    throw CWAVReaderException(WAVREADER_SAMPLE_DOES_NOT_EXIST);

  // check if channel exists
  if (nChannel >= m_nChannels)
    throw CWAVReaderException(WAVREADER_CHANNEL_DOES_NOT_EXIST);
    
  SeekToSample(nStart);
  for (UINT32 i = 0; i < nCount; ++i, ++pnBuffer)
  {
    int nActChannel = 0;
    while (nActChannel != nChannel)
    {
      ReadINT32();
      ++nActChannel;
    }
    *pnBuffer = ReadINT32();
    ++m_channelPos[nChannel];
    ++nActChannel;
    while (nActChannel < m_nChannels)
    {
      ReadINT32();
      ++nActChannel;
    }
  }
}
//----------------------------------------------------------------------------
// Reads a FOURCC code from the current position. That's a 4 character
// string. Ending spaces are removed so the length is 1 to 4 characters.
std::string CWAVReader::ReadFOURCC()
{
  // read 4 characters from file
  char szFOURCC[5] = {'\0','\0','\0','\0','\0'};
  if (!m_file.read(szFOURCC, 4))
    throw CWAVReaderException(WAVREADER_READ_ERROR);
  
  // remove ending spaces (' ')
  int nPos = 3;
  while ((nPos >= 0) && (szFOURCC[nPos] == ' '))
  {
    szFOURCC[nPos] = '\0';
    nPos--;
  }
  return string(szFOURCC);
}
//----------------------------------------------------------------------------
// Reads a signed 8 bit integer from the current file position.
INT8 CWAVReader::ReadINT8()
{
  return (INT8)ReadUINT8();
}
//----------------------------------------------------------------------------
// Reads an unsigned 8 bit integer from the current file position.
UINT8 CWAVReader::ReadUINT8()
{
  char cBuffer;
  if (!m_file.read(&cBuffer, 1))
    throw CWAVReaderException(WAVREADER_READ_ERROR);
  return (UINT8)cBuffer;
}
//----------------------------------------------------------------------------
// Reads a signed 16 bit integer from the current file position.
// Note that all values in WAV-files with sizes greater than one byte are
// stored in little-endian order. The byte order depends on the system
// (for example SUN uses big-endian order) so we can't just read two
// characters into an INT16 data type.
INT16 CWAVReader::ReadINT16()
{
  return (INT16)ReadUINT16();
}
//----------------------------------------------------------------------------
// Reads an unsigned 16 bit integer from the current file position.
// Note that all values in WAV-files with sizes greater than one byte are
// stored in little-endian order. The byte order depends on the system
// (for example SUN uses big-endian order) so we can't just read two
// characters into an UINT16 data type.
UINT16 CWAVReader::ReadUINT16()
{
  unsigned char szBuffer[2];
  if (!m_file.read((char*)szBuffer, 2))
    throw CWAVReaderException(WAVREADER_READ_ERROR);
  return ((UINT16)szBuffer[0]     ) |
         ((UINT16)szBuffer[1] << 8);
}
//----------------------------------------------------------------------------
// Reads a signed 24 bit integer from the current file position.
// Note that all values in WAV-files with sizes greater than one byte are
// stored in little-endian order. The byte order depends on the system
// (for example SUN uses big-endian order) so we can't just read four
// characters into an INT32 data type.
INT32 CWAVReader::ReadINT24()
{
  return (INT32)ReadUINT24();
}
//----------------------------------------------------------------------------
// Reads an unsigned 24 bit integer from the current file position.
// Note that all values in WAV-files with sizes greater than one byte are
// stored in little-endian order. The byte order depends on the system
// (for example SUN uses big-endian order) so we can't just read four
// characters into an UINT32 data type.
UINT32 CWAVReader::ReadUINT24()
{
  unsigned char szBuffer[3];
  if (!m_file.read((char*)szBuffer, 3))
    throw CWAVReaderException(WAVREADER_READ_ERROR);
  return ((UINT32)szBuffer[0]      ) |
         ((UINT32)szBuffer[1] <<  8) |
         ((UINT32)szBuffer[2] << 16);
}
//----------------------------------------------------------------------------
// Reads a signed 32 bit integer from the current file position.
// Note that all values in WAV-files with sizes greater than one byte are
// stored in little-endian order. The byte order depends on the system
// (for example SUN uses big-endian order) so we can't just read four
// characters into an INT32 data type.
INT32 CWAVReader::ReadINT32()
{
  return (INT32)ReadUINT32();
}
//----------------------------------------------------------------------------
// Reads an unsigned 16 bit integer from the current file position.
// Note that all values in WAV-files with sizes greater than one byte are
// stored in little-endian order. The byte order depends on the system
// (for example SUN uses big-endian order) so we can't just read four
// characters into an UINT32 data type.
UINT32 CWAVReader::ReadUINT32()
{
  unsigned char szBuffer[4];
  if (!m_file.read((char*)szBuffer, 4))
    throw CWAVReaderException(WAVREADER_READ_ERROR);
  return ((UINT32)szBuffer[0]      ) |
         ((UINT32)szBuffer[1] <<  8) |
         ((UINT32)szBuffer[2] << 16) |
         ((UINT32)szBuffer[3] << 24);
}
//----------------------------------------------------------------------------
} // namespace ac3
//----------------------------------------------------------------------------

---