#include "tsio_raw.h"

#include "tsound_t.h"

#include "tsystem.h"

#include "tfilepath_io.h"

using namespace std;

//==============================================================================

TSoundTrackReaderRaw::TSoundTrackReaderRaw(const TFilePath &fp)

    : TSoundTrackReader(fp) {}

//------------------------------------------------------------------------------

TSoundTrackP TSoundTrackReaderRaw::load() {

  Tifstream is(m_path);

  if (!is)

    throw TException(L"Unable to load the RAW file " + m_path.getWideString() +

                     L" : doesn't exist");

  is.seekg(0, ios_base::end);

  long sampleCount = is.tellg() / 2;

  is.seekg(0, ios_base::beg);

  TSoundTrack *track = new TSoundTrackMono16(22050, 1, sampleCount);

  is.read((char *)track->getRawData(), sampleCount * 2);

  return track;

}

//==============================================================================

TSoundTrackWriterRaw::TSoundTrackWriterRaw(const TFilePath &fp)

    : TSoundTrackWriter(fp) {}

//------------------------------------------------------------------------------

bool TSoundTrackWriterRaw::save(const TSoundTrackP &track) {

  TFileStatus fs(m_path);

  if (fs.doesExist() && !fs.isWritable())

    throw TException(L"Unable to save the soundtrack: " +

                     m_path.getWideString() + L" is read-only");

  Tofstream os(m_path);

  // inserisco i dati nell'output stream

  // os << (ULONG) (track->getSampleCount()) << " ";

  int sampleCount = track->getSampleCount();

  int i;

  switch (track->getChannelCount()) {

  case 1:  // mono

    switch (track->getSampleSize()) {

    case 1:  // un byte per campione

    {

      const char *srcCharSamples = (char *)track->getRawData();

      for (i = 0; i < sampleCount; i++) {

        short sample = *(srcCharSamples + i);

        os.write((char *)&sample, sizeof(short));

      }

      break;

    }

    case 2:  // due byte per campione

    {

      const short *srcShortSamples = (short *)track->getRawData();

      for (i = 0; i < sampleCount; i++)

        os.write((char *)(srcShortSamples + i), sizeof(short));

      break;

    }

    }

    break;

  case 2:  // stereo

    switch (track->getSampleSize()) {

    case 2:  // due byte per campione, un byte per canale

    {

      // considera solo il canale sinistro

      const char *srcCharSamples = (char *)track->getRawData();

      for (i = 0; i < sampleCount; i += 2) {

        short sample = *(srcCharSamples + i);

        os.write((char *)&sample, sizeof(short));

      }

      break;

    }

    case 4:  // quattro byte per campione, due byte per canale

    {

      // considera solo il canale sinistro

      const short *srcShortSamples = (short *)track->getRawData();

      for (i = 0; i < sampleCount; i += 2)

        os.write((char *)(srcShortSamples + i), sizeof(short));

      break;

    }

    }

    break;

  default:

    break;

  }

  return true;

}