#include "tsound.h"

#include "tsound_t.h"

#include "tconvert.h"

#define TRK_M8 9

#define TRK_S8 10

#define TRK_M16 17

#define TRK_S16 18

#define TRK_M24 25

#define TRK_S24 26

#define TRK_M32 33

#define TRK_S32 34

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

DEFINE_CLASS_CODE(TSoundTrack, 12)

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

TSoundTrack::TSoundTrack()

    : TSmartObject(m_classCode)

    , m_parent(0)

    , m_buffer(0)

    , m_bufferOwner(false) {}

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

TSoundTrack::TSoundTrack(TUINT32 sampleRate, int bitPerSample, int channelCount,

                         int sampleSize, TINT32 sampleCount, int sampleType)

    : TSmartObject(m_classCode)

    , m_sampleRate(sampleRate)

    , m_sampleSize(sampleSize)

    , m_bitPerSample(bitPerSample)

    , m_sampleCount(sampleCount)

    , m_channelCount(channelCount)

    , m_parent(0)

    , m_bufferOwner(true)

    , m_sampleType(sampleType) {

  m_buffer = (UCHAR *)malloc(sampleCount * m_sampleSize);

  if (!m_buffer) return;

  // m_buffer = new UCHAR[sampleCount*m_sampleSize];

  if (sampleType != TSound::UINT)

    memset(m_buffer, 0, sampleCount * sampleSize);

  else

    memset(m_buffer, 127, sampleCount * sampleSize);

}

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

TSoundTrack::TSoundTrack(TUINT32 sampleRate, int bitPerSample, int channelCount,

                         int sampleSize, TINT32 sampleCount, int sampleType,

                         UCHAR *buffer, TSoundTrack *parent)

    : TSmartObject(m_classCode)

    , m_sampleRate(sampleRate)

    , m_sampleSize(sampleSize)

    , m_bitPerSample(bitPerSample)

    , m_sampleCount(sampleCount)

    , m_channelCount(channelCount)

    , m_sampleType(sampleType)

    , m_parent(parent)

    , m_buffer(buffer)

    , m_bufferOwner(false) {

  if (m_parent) m_parent->addRef();

}

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

TSoundTrack::~TSoundTrack() {

  if (m_parent) m_parent->release();

  // if (m_buffer && m_bufferOwner) delete [] m_buffer;

  if (m_buffer && m_bufferOwner) free(m_buffer);

}

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

TSoundTrackP TSoundTrack::create(TUINT32 sampleRate, int bitPerSample,

                                 int channelCount, TINT32 sampleCount,

                                 int sampleType) {

  TSoundTrackP st = 0;

  int type        = bitPerSample + channelCount;

  switch (type) {

  case TRK_M8:

    if (sampleType == TSound::INT)

      st = new TSoundTrackMono8Signed(sampleRate, channelCount, sampleCount);

    else if (sampleType == TSound::UINT)

      st = new TSoundTrackMono8Unsigned(sampleRate, channelCount, sampleCount);

    break;

  case TRK_S8:

    if (sampleType == TSound::INT)

      st = new TSoundTrackStereo8Signed(sampleRate, channelCount, sampleCount);

    else if (sampleType == TSound::UINT)

      st =

          new TSoundTrackStereo8Unsigned(sampleRate, channelCount, sampleCount);

    break;

  case TRK_M16:

    if (sampleType == TSound::INT)

      st = new TSoundTrackMono16(sampleRate, channelCount, sampleCount);

    break;

  case TRK_S16:

    if (sampleType == TSound::INT)

      st = new TSoundTrackStereo16(sampleRate, channelCount, sampleCount);

    break;

  case TRK_M24:

    if (sampleType == TSound::INT)

      st = new TSoundTrackMono24(sampleRate, channelCount, sampleCount);

    break;

  case TRK_S24:

    if (sampleType == TSound::INT)

      st = new TSoundTrackStereo24(sampleRate, channelCount, sampleCount);

    break;

  case TRK_M32:

    if (sampleType == TSound::FLOAT)

      st = new TSoundTrackMono32Float(sampleRate, channelCount, sampleCount);

    break;

  case TRK_S32:

    if (sampleType == TSound::FLOAT)

      st = new TSoundTrackStereo32Float(sampleRate, channelCount, sampleCount);

    break;

  }

  if (!st) {

    std::string s;

    s = "Type " + std::to_string(sampleRate) + " Hz " +

        std::to_string(bitPerSample) + " bits ";

    if (channelCount == 1)

      s += "mono: ";

    else

      s += "stereo: ";

    s += "Unsupported\n";

    throw TException(s);

  }

  if (!st->getRawData()) {

    return 0;

  }

  return st;

}

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

TSoundTrackP TSoundTrack::create(TUINT32 sampleRate, int bitPerSample,

                                 int channelCount, TINT32 sampleCount,

                                 int sampleType, void *buffer) {

  TSoundTrackP st;

  int type = bitPerSample + channelCount;

  switch (type) {

  case TRK_M8:

    if (sampleType == TSound::INT)

      st = new TSoundTrackMono8Signed(sampleRate, channelCount, sampleCount,

                                      (TMono8SignedSample *)buffer, 0);

    else if (sampleType == TSound::UINT)

      st = new TSoundTrackMono8Unsigned(sampleRate, channelCount, sampleCount,

                                        (TMono8UnsignedSample *)buffer, 0);

    break;

  case TRK_S8:

    if (sampleType == TSound::INT)

      st = new TSoundTrackStereo8Signed(sampleRate, channelCount, sampleCount,

                                        (TStereo8SignedSample *)buffer, 0);

    else

      st = new TSoundTrackStereo8Unsigned(sampleRate, channelCount, sampleCount,

                                          (TStereo8UnsignedSample *)buffer, 0);

    break;

  case TRK_M16:

    if (sampleType == TSound::INT)

      st = new TSoundTrackMono16(sampleRate, channelCount, sampleCount,

                                 (TMono16Sample *)buffer, 0);

    break;

  case TRK_S16:

    if (sampleType == TSound::INT)

      st = new TSoundTrackStereo16(sampleRate, channelCount, sampleCount,

                                   (TStereo16Sample *)buffer, 0);

    break;

  case TRK_M24:

    if (sampleType == TSound::INT)

      st = new TSoundTrackMono24(sampleRate, channelCount, sampleCount,

                                 (TMono24Sample *)buffer, 0);

    break;

  case TRK_S24:

    if (sampleType == TSound::INT)

      st = new TSoundTrackStereo24(sampleRate, channelCount, sampleCount,

                                   (TStereo24Sample *)buffer, 0);

    break;

  case TRK_M32:

    if (sampleType == TSound::FLOAT)

      st = new TSoundTrackMono32Float(sampleRate, channelCount, sampleCount,

                                      (TMono32FloatSample *)buffer, 0);

    break;

  case TRK_S32:

    if (sampleType == TSound::FLOAT)

      st = new TSoundTrackStereo32Float(sampleRate, channelCount, sampleCount,

                                        (TStereo32FloatSample *)buffer, 0);

    break;

  }

  if (!st) {

    std::string s;

    s = "Type " + std::to_string(sampleRate) + " Hz " +

        std::to_string(bitPerSample) + " bits ";

    if (channelCount == 1)

      s += "mono: ";

    else

      s += "stereo: ";

    s += "Unsupported\n";

    throw TException(s);

  }

  return st;

}

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

TSoundTrackP TSoundTrack::create(const TSoundTrackFormat &format,

                                 TINT32 sampleCount, void *buffer) {

  return TSoundTrack::create((int)format.m_sampleRate, format.m_bitPerSample,

                             format.m_channelCount, sampleCount,

                             format.m_sampleType, buffer);

}

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

TSoundTrackP TSoundTrack::create(const TSoundTrackFormat &format,

                                 TINT32 sampleCount) {

  return TSoundTrack::create((int)format.m_sampleRate, format.m_bitPerSample,

                             format.m_channelCount, sampleCount,

                             format.m_sampleType);

}

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

TINT32 TSoundTrack::secondsToSamples(double s) const {

  double dsamp = s * m_sampleRate;

  TINT32 lsamp = (TINT32)dsamp;

  if ((double)lsamp < dsamp - TConsts::epsilon) lsamp++;

  return lsamp;

}

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

double TSoundTrack::samplesToSeconds(TINT32 f) const {

  return f / (double)m_sampleRate;

}

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

bool TSoundTrackFormat::operator==(const TSoundTrackFormat &rhs) {

  return (m_sampleRate == rhs.m_sampleRate &&

          m_bitPerSample == rhs.m_bitPerSample &&

          m_channelCount == rhs.m_channelCount &&

          m_sampleType == rhs.m_sampleType);

}

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

bool TSoundTrackFormat::operator!=(const TSoundTrackFormat &rhs) {

  return !operator==(rhs);

}

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

double TSoundTrack::getDuration() const {

  return samplesToSeconds(m_sampleCount);

}

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

TSoundTrackFormat TSoundTrack::getFormat() const {

  return TSoundTrackFormat(getSampleRate(), getBitPerSample(),

                           getChannelCount(), getSampleType());

}

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

TSoundTrackP TSoundTrack::extract(double t0, double t1) {

  return extract(secondsToSamples(t0), secondsToSamples(t1));

}

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

void TSoundTrack::copy(const TSoundTrackP &src, double dst_t0) {

  copy(src, secondsToSamples(dst_t0));

}

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

void TSoundTrack::blank(double t0, double t1) {

  blank(secondsToSamples(t0), secondsToSamples(t1));

}

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

double TSoundTrack::getPressure(double second, TSound::Channel chan) const {

  return getPressure(secondsToSamples(second), chan);

}

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

void TSoundTrack::getMinMaxPressure(double t0, double t1, TSound::Channel chan,

                                    double &min, double &max) const {

  getMinMaxPressure(secondsToSamples(t0), secondsToSamples(t1), chan, min, max);

}

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

void TSoundTrack::getMinMaxPressure(TSound::Channel chan, double &min,

                                    double &max) const {

  getMinMaxPressure(0, (TINT32)(getSampleCount() - 1), chan, min, max);

}

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

double TSoundTrack::getMaxPressure(double t0, double t1,

                                   TSound::Channel chan) const {

  return getMaxPressure(secondsToSamples(t0), secondsToSamples(t1), chan);

}

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

double TSoundTrack::getMaxPressure(TSound::Channel chan) const {

  return getMaxPressure(0, (TINT32)(getSampleCount() - 1), chan);

}

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

double TSoundTrack::getMinPressure(double t0, double t1,

                                   TSound::Channel chan) const {

  return getMinPressure(secondsToSamples(t0), secondsToSamples(t1), chan);

}

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

double TSoundTrack::getMinPressure(TSound::Channel chan) const {

  return getMinPressure(0, (TINT32)(getSampleCount() - 1), chan);

}

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