#include <cstring></cstring>

#include "tsop.h"

#include "tsound_t.h"

// TRop::ResampleFilterType Tau_resample_filter = Hamming3;

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

typedef enum {

  FLT_NONE,

  FLT_TRIANGLE, /* triangle filter */

  FLT_MITCHELL, /* Mitchell-Netravali filter */

  FLT_CUBIC_5,  /* cubic convolution, a = .5 */

  FLT_CUBIC_75, /* cubic convolution, a = .75 */

  FLT_CUBIC_1,  /* cubic convolution, a = 1 */

  FLT_HANN2,    /* Hann window, rad = 2 */

  FLT_HANN3,    /* Hann window, rad = 3 */

  FLT_HAMMING2, /* Hamming window, rad = 2 */

  FLT_HAMMING3, /* Hamming window, rad = 3 */

  FLT_LANCZOS2, /* Lanczos window, rad = 2 */

  FLT_LANCZOS3, /* Lanczos window, rad = 3 */

  FLT_GAUSS,    /* Gaussian convolution */

  FLT_HOW_MANY

} FLT_TYPE;

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

typedef enum {

  RESORDER_NONE,

  RESORDER_BITS_RATE_CHANS,

  RESORDER_CHANS_RATE_BITS,

  RESORDER_RATE_BITS_CHANS,

  RESORDER_CHANS_BITS_RATE,

  RESORDER_BITS_RATE,

  RESORDER_RATE_BITS,

  RESORDER_CHANS_RATE,

  RESORDER_RATE_CHANS,

  RESORDER_RATE,

  RESORDER_SIGN,

  RESORDER_HOW_MANY

} RESORDER_TYPE;

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

typedef struct {

  int src_offset; /* of weight[0] relative to start of period */

  int n_weights;

  double *weight; /* [n_weights],  -1.0 <= weight <= 1.0 */

} WEIGHTSET;

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

typedef struct {

  int src_period; /* after a period src and dst are in step again */

  int dst_period;

  WEIGHTSET *weightset; /* [dst_period] */

} FILTER;

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

#define M_PIF float(M_PI)

#define SINC0(x, a) (sin((M_PI / (a)) * (x)) / ((M_PI / (a)) * (x)))

#define SINC0F(x, a) (sinf((M_PIF / (a)) * (x)) / ((M_PIF / (a)) * (x)))

#define SINC(x, a) ((x) == 0.0 ? 1.0 : SINC0(x, a))

#define SINCF(x, a) ((x) == 0.0F ? 1.0F : SINC0F(x, a))

#define FULL_INT_MUL_DIV(X, Y, Z) ((int)(((double)(X) * (Y) + ((Z)-1)) / (Z)))

// prototipi

void convert(TSoundTrackP &dst, const TSoundTrackP &src);

namespace {

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

void simplifyRatio(int *p_a, int *p_b) {

  int a = *p_a, b = *p_b;

  while (a != b)

    if (a > b)

      a -= b;

    else

      b -= a;

  if (a != 1) {

    *p_a /= a;

    *p_b /= a;

  }

}

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

int getFilterRadius(FLT_TYPE flt_type) {

  int result = 0;

  switch (flt_type) {

  case FLT_TRIANGLE:

    result = 1;

    break;

  case FLT_MITCHELL:

    result = 2;

    break;

  case FLT_CUBIC_5:

    result = 2;

    break;

  case FLT_CUBIC_75:

    result = 2;

    break;

  case FLT_CUBIC_1:

    result = 2;

    break;

  case FLT_HANN2:

    result = 2;

    break;

  case FLT_HANN3:

    result = 3;

    break;

  case FLT_HAMMING2:

    result = 2;

    break;

  case FLT_HAMMING3:

    result = 3;

    break;

  case FLT_LANCZOS2:

    result = 2;

    break;

  case FLT_LANCZOS3:

    result = 3;

    break;

  case FLT_GAUSS:

    result = 2;

    break;

  default:

    assert(!"bad filter type");

    break;

  }

  return result;

}

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

double filterValue(FLT_TYPE flt_type, double x) {

  if (!x) return 1.0;

  double result;

  switch (flt_type) {

  case FLT_TRIANGLE:

    if (x < -1.0)

      result = 0.0;

    else if (x < 0.0)

      result = 1.0 + x;

    else if (x < 1.0)

      result = 1.0 - x;

    else

      result = 0.0;

    break;

  case FLT_MITCHELL: {

    static double p0, p2, p3, q0, q1, q2, q3;

    if (!p0) {

      const double b = 1.0 / 3.0;

      const double c = 1.0 / 3.0;

      p0 = (6.0 - 2.0 * b) / 6.0;

      p2 = (-18.0 + 12.0 * b + 6.0 * c) / 6.0;

      p3 = (12.0 - 9.0 * b - 6.0 * c) / 6.0;

      q0 = (8.0 * b + 24.0 * c) / 6.0;

      q1 = (-12.0 * b - 48.0 * c) / 6.0;

      q2 = (6.0 * b + 30.0 * c) / 6.0;

      q3 = (-b - 6.0 * c) / 6.0;

    }

    if (x < -2.0)

      result = 0.0;

    else if (x < -1.0)

      result = (q0 - x * (q1 - x * (q2 - x * q3)));

    else if (x < 0.0)

      result = (p0 + x * x * (p2 - x * p3));

    else if (x < 1.0)

      result = (p0 + x * x * (p2 + x * p3));

    else if (x < 2.0)

      result = (q0 + x * (q1 + x * (q2 + x * q3)));

    break;

  }

  case FLT_CUBIC_5:

    if (x < 0.0)

      x = -x;

    else if (x < 1.0)

      result = 2.5 * x * x * x - 3.5 * x * x + 1;

    else if (x < 2.0)

      result = 0.5 * x * x * x - 2.5 * x * x + 4 * x - 2;

    break;

  case FLT_CUBIC_75:

    if (x < 0.0)

      x = -x;

    else if (x < 1.0)

      result = 2.75 * x * x * x - 3.75 * x * x + 1;

    else if (x < 2.0)

      result = 0.75 * x * x * x - 3.75 * x * x + 6 * x - 3;

    break;

  case FLT_CUBIC_1:

    if (x < 0.0)

      x = -x;

    else if (x < 1.0)

      result = 3 * x * x * x - 4 * x * x + 1;

    else if (x < 2.0)

      result = x * x * x - 5 * x * x + 8 * x - 4;

    break;

  case FLT_HANN2:

    if (x <= -2.0)

      result = 0.0;

    else if (x < 2.0)

      result = SINC0(x, 1) * (0.5 + 0.5 * cos(M_PI_2 * x));

    break;

  case FLT_HANN3:

    if (x <= -3.0)

      result = 0.0;

    else if (x < 3.0)

      result = SINC0(x, 1) * (0.5 + 0.5 * cos((M_PI / 3) * x));

    break;

  case FLT_HAMMING2:

    if (x <= -2.0)

      result = 0.0;

    else if (x < 2.0)

      result = SINC0(x, 1) * (0.54 + 0.46 * cos(M_PI_2 * x));

    break;

  case FLT_HAMMING3:

    if (x <= -3.0)

      result = 0.0;

    else if (x < 3.0)

      result = SINC0(x, 1) * (0.54 + 0.46 * cos((M_PI / 3) * x));

    break;

  case FLT_LANCZOS2:

    if (x <= -2.0)

      result = 0.0;

    else if (x < 2.0)

      result = SINC0(x, 1) * SINC0(x, 2);

    break;

  case FLT_LANCZOS3:

    if (x <= -3.0)

      result = 0.0;

    else if (x < 3.0)

      result = SINC0(x, 1) * SINC0(x, 3);

    break;

  case FLT_GAUSS:

    if (x <= -2.0)

      result = 0.0;

    else if (x < 2.0)

      result = exp((-M_PI) * x * x);

    /* exp(-M_PI*2*2)~=3.5*10^-6 */

    break;

  default:

    assert(!"bad filter type");

  }

  return result;

}

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

}  // namespace

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

template <class class="" t1,="" t2=""></class>

void convertSamplesT(TSoundTrackT<t1> &dst, const TSoundTrackT<t2> &src) {</t2></t1>

  const T2 *srcSample = src.samples();

  T1 *dstSample       = dst.samples();

  const T2 *srcEndSample =

      srcSample + std::min(src.getSampleCount(), dst.getSampleCount());

  while (srcSample < srcEndSample) {

    *dstSample = T1::from(*srcSample);

    ++dstSample;

    ++srcSample;

  }

}

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

template <class t=""></class>

T *resampleT(T &src, TINT32 sampleRate, FLT_TYPE flt_type) {

  typedef typename T::SampleType SampleType;

  typedef typename T::SampleType::ChannelValueType ChannelValueType;

  T *dst = new TSoundTrackT<sampletype>(</sampletype>

      sampleRate, src.getChannelCount(),

      (TINT32)(src.getSampleCount() *

               (sampleRate / (double)src.getSampleRate())));

  double src_rad, f, src_f0, src_to_f;

  double weight, weightsum;

  int iw, is, s0, ip, first, last;

  FILTER filter;

  filter.src_period = (int)src.getSampleRate();

  filter.dst_period = (int)dst->getSampleRate();

  simplifyRatio(&filter.src_period, &filter.dst_period);

  filter.weightset = new WEIGHTSET[filter.dst_period];

  if (!filter.weightset) return 0;

  int flt_rad       = getFilterRadius(flt_type);

  double dstRate    = (double)dst->getSampleRate();

  double srcRate    = (double)src.getSampleRate();

  double dst_to_src = srcRate / dstRate;

  if (srcRate > dstRate) {

    src_rad  = flt_rad * dst_to_src;

    src_to_f = dstRate / srcRate;

  } else {

    src_rad  = flt_rad;

    src_to_f = 1.0;

  }

  for (ip = 0; ip < filter.dst_period; ip++) {

    src_f0 = ip * dst_to_src;

    if (ip == 0 && srcRate < dstRate)

      first = last = 0;

    else {

      first = intGT(src_f0 - src_rad);

      last  = intLT(src_f0 + src_rad);

    }

    filter.weightset[ip].src_offset = first;

    filter.weightset[ip].n_weights  = last - first + 1;

    filter.weightset[ip].weight = new double[filter.weightset[ip].n_weights];

    if (!filter.weightset[ip].weight) return 0;

    weightsum = 0.0;

    for (is = first; is <= last; is++) {

      f                                       = (is - src_f0) * src_to_f;

      weight                                  = filterValue(flt_type, f);

      filter.weightset[ip].weight[is - first] = weight;

      weightsum += weight;

    }

    assert(weightsum);

    for (is = first; is <= last; is++)

      filter.weightset[ip].weight[is - first] /= weightsum;

  }

  ip = 0;

  s0 = 0;

  for (TINT32 id = 0; id < dst->getSampleCount(); id++) {

    SampleType dstSample;

    SampleType srcSample;

    is = s0 + filter.weightset[ip].src_offset;

    int iwFirst, iwLast;

    if (is > 0) {

      iwFirst = 0;

      iwLast  = std::min<int>(filter.weightset[ip].n_weights,</int>

                             src.getSampleCount() - is);

    } else {

      iwFirst = -is;

      is      = 0;

      iwLast =

          std::min<int>(filter.weightset[ip].n_weights, src.getSampleCount());</int>

    }

    double dstChannel[2];

    dstChannel[0] = 0;

    dstChannel[1] = 0;

    dstSample = SampleType();

    for (iw = iwFirst; iw < iwLast; iw++, is++) {

      weight = filter.weightset[ip].weight[iw];

      srcSample = *(src.samples() + is);

      /*

T::SampleType tmp = srcSample*weight;

dstSample += tmp;

*/

      for (int i = 0; i < src.getChannelCount(); i++)

        dstChannel[i] += (double)(srcSample.getValue(i) * weight);

      // assert(dstSample.getValue(0) == dstChannel[0]);

    }

    // Removed tround() since it was destroying 32-bits float data

    // for (int i = 0; i < src.getChannelCount(); i++)

    //  dstSample.setValue(i, (ChannelValueType)(tround(dstChannel[i])));

    for (int i = 0; i < src.getChannelCount(); i++)

      dstSample.setValue(i, (ChannelValueType)(dstChannel[i]));

    *(dst->samples() + id) = dstSample;

    ip++;

    if (ip == filter.dst_period) {

      ip = 0;

      s0 += filter.src_period;

    }

  }

  for (ip = 0; ip < filter.dst_period; ip++)

    delete[] filter.weightset[ip].weight;

  delete[] filter.weightset;

  return dst;

}

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

class TSoundTrackResample final : public TSoundTransform {

  TINT32 m_sampleRate;

  FLT_TYPE m_filterType;

public:

  TSoundTrackResample(TINT32 sampleRate, FLT_TYPE filterType)

      : TSoundTransform(), m_sampleRate(sampleRate), m_filterType(filterType) {}

  ~TSoundTrackResample(){};

  TSoundTrackP compute(const TSoundTrackMono8Signed &src) override {

    TSoundTrackMono8Signed *dst = resampleT(

        const_cast<tsoundtrackmono8signed &="">(src), m_sampleRate, m_filterType);</tsoundtrackmono8signed>

    return TSoundTrackP(dst);

  }

  TSoundTrackP compute(const TSoundTrackMono8Unsigned &src) override {

    TSoundTrackMono8Unsigned *dst =

        resampleT(const_cast<tsoundtrackmono8unsigned &="">(src), m_sampleRate,</tsoundtrackmono8unsigned>

                  m_filterType);

    return TSoundTrackP(dst);

  }

  TSoundTrackP compute(const TSoundTrackStereo8Signed &src) override {

    TSoundTrackStereo8Signed *dst =

        resampleT(const_cast<tsoundtrackstereo8signed &="">(src), m_sampleRate,</tsoundtrackstereo8signed>

                  m_filterType);

    return TSoundTrackP(dst);

  }

  TSoundTrackP compute(const TSoundTrackStereo8Unsigned &src) override {

    TSoundTrackStereo8Unsigned *dst =

        resampleT(const_cast<tsoundtrackstereo8unsigned &="">(src), m_sampleRate,</tsoundtrackstereo8unsigned>

                  m_filterType);

    return TSoundTrackP(dst);

  }

  TSoundTrackP compute(const TSoundTrackMono16 &src) override {

    TSoundTrackMono16 *dst = resampleT(const_cast<tsoundtrackmono16 &="">(src),</tsoundtrackmono16>

                                       m_sampleRate, m_filterType);

    return TSoundTrackP(dst);

  }

  TSoundTrackP compute(const TSoundTrackStereo16 &src) override {

    TSoundTrackStereo16 *dst = resampleT(const_cast<tsoundtrackstereo16 &="">(src),</tsoundtrackstereo16>

                                         m_sampleRate, m_filterType);

    return TSoundTrackP(dst);

  }

  TSoundTrackP compute(const TSoundTrackMono24 &src) override {

    TSoundTrackMono24 *dst = resampleT(const_cast<tsoundtrackmono24 &="">(src),</tsoundtrackmono24>

                                       m_sampleRate, m_filterType);

    return TSoundTrackP(dst);

  }

  TSoundTrackP compute(const TSoundTrackStereo24 &src) override {

    TSoundTrackStereo24 *dst = resampleT(const_cast<tsoundtrackstereo24 &="">(src),</tsoundtrackstereo24>

                                         m_sampleRate, m_filterType);

    return TSoundTrackP(dst);

  }

  TSoundTrackP compute(const TSoundTrackMono32Float &src) override {

    TSoundTrackMono32Float *dst = resampleT(

        const_cast<tsoundtrackmono32float &="">(src), m_sampleRate, m_filterType);</tsoundtrackmono32float>

    return TSoundTrackP(dst);

  }

  TSoundTrackP compute(const TSoundTrackStereo32Float &src) override {

    TSoundTrackStereo32Float *dst =

        resampleT(const_cast<tsoundtrackstereo32float &="">(src), m_sampleRate,</tsoundtrackstereo32float>

                  m_filterType);

    return TSoundTrackP(dst);

  }

};

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

TSoundTrackP TSop::resample(TSoundTrackP src, TINT32 sampleRate) {

  TSoundTrackResample *resample =

      new TSoundTrackResample(sampleRate, FLT_HAMMING3);

  TSoundTrackP dst = src->apply(resample);

  delete resample;

  return dst;

}

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

template <class src=""></class>

TSoundTrackP doConvertWithoutResamplingT(SRC *src,

                                         const TSoundTrackFormat &dstFormat) {

  TSoundTrackP dst = TSoundTrack::create(dstFormat, src->getSampleCount());

  if (!dst) return 0;

  TSoundTrackMono8Unsigned *dstM8U =

      dynamic_cast<tsoundtrackmono8unsigned *="">(dst.getPointer());</tsoundtrackmono8unsigned>

  if (dstM8U) {

    convertSamplesT(*dstM8U, *src);

    return dstM8U;

  }

  TSoundTrackMono8Signed *dstM8S =

      dynamic_cast<tsoundtrackmono8signed *="">(dst.getPointer());</tsoundtrackmono8signed>

  if (dstM8S) {

    convertSamplesT(*dstM8S, *src);

    return dstM8S;

  }

  TSoundTrackStereo8Signed *dstS8S =

      dynamic_cast<tsoundtrackstereo8signed *="">(dst.getPointer());</tsoundtrackstereo8signed>

  if (dstS8S) {

    convertSamplesT(*dstS8S, *src);

    return dstS8S;

  }

  TSoundTrackStereo8Unsigned *dstS8U =

      dynamic_cast<tsoundtrackstereo8unsigned *="">(dst.getPointer());</tsoundtrackstereo8unsigned>

  if (dstS8U) {

    convertSamplesT(*dstS8U, *src);

    return dstS8U;

  }

  TSoundTrackMono16 *dstM16 =

      dynamic_cast<tsoundtrackmono16 *="">(dst.getPointer());</tsoundtrackmono16>

  if (dstM16) {

    convertSamplesT(*dstM16, *src);

    return dstM16;

  }

  TSoundTrackStereo16 *dstS16 =

      dynamic_cast<tsoundtrackstereo16 *="">(dst.getPointer());</tsoundtrackstereo16>

  if (dstS16) {

    convertSamplesT(*dstS16, *src);

    return dstS16;

  }

  TSoundTrackMono24 *dstM24 =

      dynamic_cast<tsoundtrackmono24 *="">(dst.getPointer());</tsoundtrackmono24>

  if (dstM24) {

    convertSamplesT(*dstM24, *src);

    return dstM24;

  }

  TSoundTrackStereo24 *dstS24 =

      dynamic_cast<tsoundtrackstereo24 *="">(dst.getPointer());</tsoundtrackstereo24>

  if (dstS24) {

    convertSamplesT(*dstS24, *src);

    return dstS24;

  }

  TSoundTrackMono32Float *dstM32F =

      dynamic_cast<tsoundtrackmono32float *="">(dst.getPointer());</tsoundtrackmono32float>

  if (dstM32F) {

    convertSamplesT(*dstM32F, *src);

    return dstM32F;

  }

  TSoundTrackStereo32Float *dstS32F =

      dynamic_cast<tsoundtrackstereo32float *="">(dst.getPointer());</tsoundtrackstereo32float>

  if (dstS32F) {

    convertSamplesT(*dstS32F, *src);

    return dstS32F;

  }

  return 0;

}

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

class TSoundTrackConverterWithoutResampling final : public TSoundTransform {

  TSoundTrackFormat m_format;

public:

  TSoundTrackConverterWithoutResampling(const TSoundTrackFormat &format)

      : m_format(format) {}

  ~TSoundTrackConverterWithoutResampling(){};

  TSoundTrackP compute(const TSoundTrackMono8Signed &src) override {

    return doConvertWithoutResamplingT(&src, m_format);

  }

  TSoundTrackP compute(const TSoundTrackMono8Unsigned &src) override {

    return doConvertWithoutResamplingT(&src, m_format);

  }

  TSoundTrackP compute(const TSoundTrackStereo8Signed &src) override {

    return doConvertWithoutResamplingT(&src, m_format);

  }

  TSoundTrackP compute(const TSoundTrackStereo8Unsigned &src) override {

    return doConvertWithoutResamplingT(&src, m_format);

  }

  TSoundTrackP compute(const TSoundTrackMono16 &src) override {

    return doConvertWithoutResamplingT(&src, m_format);

  }

  TSoundTrackP compute(const TSoundTrackStereo16 &src) override {

    return doConvertWithoutResamplingT(&src, m_format);

  }

  TSoundTrackP compute(const TSoundTrackMono24 &src) override {

    return doConvertWithoutResamplingT(&src, m_format);

  }

  TSoundTrackP compute(const TSoundTrackStereo24 &src) override {

    return doConvertWithoutResamplingT(&src, m_format);

  }

  TSoundTrackP compute(const TSoundTrackMono32Float &src) override {

    return doConvertWithoutResamplingT(&src, m_format);

  }

  TSoundTrackP compute(const TSoundTrackStereo32Float &src) override {

    return doConvertWithoutResamplingT(&src, m_format);

  }

};

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

namespace {

void convertWithoutResampling(TSoundTrackP &dst, const TSoundTrackP &src) {

  TSoundTrackConverterWithoutResampling *converter;

  converter = new TSoundTrackConverterWithoutResampling(dst->getFormat());

  dst       = src->apply(converter);

  delete converter;

}

}  // namespace

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

TSoundTrackP TSop::convert(const TSoundTrackP &src,

                           const TSoundTrackFormat &dstFormat) {

  TINT32 dstSampleCount =

      (TINT32)(src->getSampleCount() *

               (dstFormat.m_sampleRate / (double)src->getSampleRate()));

  TSoundTrackP dst = TSoundTrack::create(dstFormat, dstSampleCount);

  TSop::convert(dst, src);

  return dst;

}

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

void TSop::convert(TSoundTrackP &dst, const TSoundTrackP &src) {

  int src_reslen, dst_reslen;

  int src_bits, dst_bits;

  int src_chans, dst_chans;

  TSoundTrackP tmp, tmq;

  RESORDER_TYPE order;

  assert(src->getSampleCount() >= 0 && dst->getSampleCount() >= 0);

  if (!dst->getSampleCount()) return;

  if (!src->getSampleCount()) {

    dst->blank(0L, (TINT32)(dst->getSampleCount() - 1));

    return;

  }

  if (src->getSampleRate() == dst->getSampleRate()) {

    src_reslen = dst->getSampleCount();

    notMoreThan((int)src->getSampleCount(), src_reslen);

    dst_reslen = src_reslen;

    convertWithoutResampling(dst, src);

  } else {

    src_reslen = FULL_INT_MUL_DIV(dst->getSampleCount(), src->getSampleRate(),

                                  dst->getSampleRate());

    if (src_reslen > src->getSampleCount()) {

      src_reslen = src->getSampleCount();

      dst_reslen = FULL_INT_MUL_DIV(src_reslen, dst->getSampleRate(),

                                    src->getSampleRate());

    } else

      dst_reslen = dst->getSampleCount();

    src_chans = src->getChannelCount();

    dst_chans = dst->getChannelCount();

    src_bits  = src->getBitPerSample();

    dst_bits  = dst->getBitPerSample();

    if (src_chans == dst_chans && src_bits == dst_bits)

      if (src->isSampleSigned() == dst->isSampleSigned())

        order = RESORDER_RATE;

      else

        order = RESORDER_SIGN;

    else if (src_chans < dst_chans) {

      if (src_bits < dst_bits)

        order = RESORDER_BITS_RATE_CHANS;

      else

        order = RESORDER_RATE_BITS_CHANS;

    } else if (src_chans > dst_chans) {

      if (src_bits > dst_bits)

        order = RESORDER_CHANS_RATE_BITS;

      else

        order = RESORDER_CHANS_BITS_RATE;

    } else {

      if (src_bits > dst_bits)

        order = RESORDER_RATE_BITS;

      else

        order = RESORDER_BITS_RATE;

    }

    switch (order) {

    case RESORDER_CHANS_RATE_BITS:

    case RESORDER_BITS_RATE_CHANS:

      int chans, bitPerSample;

      if (src->getChannelCount() <= dst->getChannelCount())

        chans = src->getChannelCount();

      else

        chans = dst->getChannelCount();

      if (src->getBitPerSample() >= dst->getBitPerSample())

        bitPerSample = src->getBitPerSample();

      else

        bitPerSample = dst->getBitPerSample();

      tmp = TSoundTrack::create((int)src->getSampleRate(), bitPerSample, chans,

                                src_reslen * src->getSampleSize(),

                                src->getSampleType());

      convertWithoutResampling(tmp, src);

      tmq = TSop::resample(tmp, (TINT32)dst->getSampleRate());

      convertWithoutResampling(dst, tmq);

      break;

    case RESORDER_RATE_BITS_CHANS:

    case RESORDER_RATE_BITS:

    case RESORDER_RATE_CHANS:

      tmp = TSop::resample(src, (TINT32)dst->getSampleRate());

      convertWithoutResampling(dst, tmp);

      break;

    case RESORDER_CHANS_BITS_RATE:

    case RESORDER_BITS_RATE:

    case RESORDER_CHANS_RATE:

    case RESORDER_SIGN:

      tmp = TSoundTrack::create((int)src->getSampleRate(),

                                dst->getBitPerSample(), dst->getChannelCount(),

                                src_reslen * dst->getSampleSize(),

                                dst->getSampleType());

      convertWithoutResampling(tmp, src);

      dst = TSop::resample(tmp, (TINT32)dst->getSampleRate());

      break;

    case RESORDER_RATE:

      dst = TSop::resample(src, (TINT32)dst->getSampleRate());

      break;

    default:

      assert(false);

      break;

    }

  }

  if (dst_reslen < dst->getSampleCount())

    dst->blank((TINT32)dst_reslen, (TINT32)(dst->getSampleCount() - 1));

}

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

template <class t=""></class>

TSoundTrackP doReverb(TSoundTrackT<t> *src, double delayTime,</t>

                      double decayFactor, double extendTime) {

  TINT32 dstSampleCount =

      src->getSampleCount() + (TINT32)(src->getSampleRate() * extendTime);

  TSoundTrackT<t> *dst = new TSoundTrackT<t>(</t></t>

      src->getSampleRate(), src->getChannelCount(), dstSampleCount);

  TINT32 sampleRate = (TINT32)src->getSampleRate();

  TINT32 k          = (TINT32)(sampleRate * delayTime);

  T *srcSample    = src->samples();

  T *dstSample    = dst->samples();

  T *endDstSample = dst->samples() + k;

  while (dstSample < endDstSample) *dstSample++ = *srcSample++;

  // la formula del reverb e'

  // out(i) = in(i) + decayFactor * out(i - k)

  //  int channelCount = src->getChannelCount();

  endDstSample =

      dst->samples() + std::min(dstSampleCount, (TINT32)src->getSampleCount());

  while (dstSample < endDstSample) {

    //*dstSample = *srcSample + *(dstSample - k)*decayFactor;

    *dstSample = T::mix(*srcSample, 1, *(dstSample - k), decayFactor);

    ++dstSample;

    ++srcSample;

  }

  endDstSample = dst->samples() + dstSampleCount;

  while (dstSample < endDstSample) {

    //*dstSample = *(dstSample - k)*decayFactor;

    *dstSample = T::mix(T(), 0, *(dstSample - k), decayFactor);

    ++dstSample;

  }

  return TSoundTrackP(dst);

}

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

class TSoundReverb final : public TSoundTransform {

  double m_delayTime;

  double m_decayFactor;

  double m_extendTime;

public:

  TSoundReverb(double delayTime, double decayFactor, double extendTime)

      : m_delayTime(delayTime)

      , m_decayFactor(decayFactor)

      , m_extendTime(extendTime) {}

  ~TSoundReverb() {}

  TSoundTrackP compute(const TSoundTrackMono8Signed &src) override {

    return doReverb(const_cast<tsoundtrackmono8signed *="">(&src), m_delayTime,</tsoundtrackmono8signed>

                    m_decayFactor, m_extendTime);

  }

  TSoundTrackP compute(const TSoundTrackMono8Unsigned &src) override {

    return doReverb(const_cast<tsoundtrackmono8unsigned *="">(&src), m_delayTime,</tsoundtrackmono8unsigned>

                    m_decayFactor, m_extendTime);

  }

  TSoundTrackP compute(const TSoundTrackStereo8Signed &src) override {

    return doReverb(const_cast<tsoundtrackstereo8signed *="">(&src), m_delayTime,</tsoundtrackstereo8signed>

                    m_decayFactor, m_extendTime);

  }

  TSoundTrackP compute(const TSoundTrackStereo8Unsigned &src) override {

    return doReverb(const_cast<tsoundtrackstereo8unsigned *="">(&src), m_delayTime,</tsoundtrackstereo8unsigned>

                    m_decayFactor, m_extendTime);

  }

  TSoundTrackP compute(const TSoundTrackMono16 &src) override {

    return doReverb(const_cast<tsoundtrackmono16 *="">(&src), m_delayTime,</tsoundtrackmono16>

                    m_decayFactor, m_extendTime);

  }

  TSoundTrackP compute(const TSoundTrackStereo16 &src) override {

    return doReverb(const_cast<tsoundtrackstereo16 *="">(&src), m_delayTime,</tsoundtrackstereo16>

                    m_decayFactor, m_extendTime);