#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;
}