#include <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 T1, class T2>
void convertSamplesT(TSoundTrackT<T1> &dst, const TSoundTrackT<T2> &src) {
  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>
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>(
      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,
                             src.getSampleCount() - is);
    } else {
      iwFirst = -is;
      is      = 0;
      iwLast =
          std::min<int>(filter.weightset[ip].n_weights, src.getSampleCount());
    }

    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]);
    }

    for (int i = 0; i < src.getChannelCount(); i++)
      dstSample.setValue(i, (ChannelValueType)(tround(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);

    return TSoundTrackP(dst);
  }

  TSoundTrackP compute(const TSoundTrackMono8Unsigned &src) override {
    TSoundTrackMono8Unsigned *dst =
        resampleT(const_cast<TSoundTrackMono8Unsigned &>(src), m_sampleRate,
                  m_filterType);

    return TSoundTrackP(dst);
  }

  TSoundTrackP compute(const TSoundTrackStereo8Signed &src) override {
    TSoundTrackStereo8Signed *dst =
        resampleT(const_cast<TSoundTrackStereo8Signed &>(src), m_sampleRate,
                  m_filterType);

    return TSoundTrackP(dst);
  }

  TSoundTrackP compute(const TSoundTrackStereo8Unsigned &src) override {
    TSoundTrackStereo8Unsigned *dst =
        resampleT(const_cast<TSoundTrackStereo8Unsigned &>(src), m_sampleRate,
                  m_filterType);

    return TSoundTrackP(dst);
  }

  TSoundTrackP compute(const TSoundTrackMono16 &src) override {
    TSoundTrackMono16 *dst = resampleT(const_cast<TSoundTrackMono16 &>(src),
                                       m_sampleRate, m_filterType);

    return TSoundTrackP(dst);
  }

  TSoundTrackP compute(const TSoundTrackStereo16 &src) override {
    TSoundTrackStereo16 *dst = resampleT(const_cast<TSoundTrackStereo16 &>(src),
                                         m_sampleRate, m_filterType);

    return TSoundTrackP(dst);
  }

  TSoundTrackP compute(const TSoundTrackMono24 &src) override {
    TSoundTrackMono24 *dst = resampleT(const_cast<TSoundTrackMono24 &>(src),
                                       m_sampleRate, m_filterType);

    return TSoundTrackP(dst);
  }

  TSoundTrackP compute(const TSoundTrackStereo24 &src) override {
    TSoundTrackStereo24 *dst = resampleT(const_cast<TSoundTrackStereo24 &>(src),
                                         m_sampleRate, 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>
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());
  if (dstM8U) {
    convertSamplesT(*dstM8U, *src);
    return dstM8U;
  }

  TSoundTrackMono8Signed *dstM8S =
      dynamic_cast<TSoundTrackMono8Signed *>(dst.getPointer());
  if (dstM8S) {
    convertSamplesT(*dstM8S, *src);
    return dstM8S;
  }

  TSoundTrackStereo8Signed *dstS8S =
      dynamic_cast<TSoundTrackStereo8Signed *>(dst.getPointer());
  if (dstS8S) {
    convertSamplesT(*dstS8S, *src);
    return dstS8S;
  }

  TSoundTrackStereo8Unsigned *dstS8U =
      dynamic_cast<TSoundTrackStereo8Unsigned *>(dst.getPointer());
  if (dstS8U) {
    convertSamplesT(*dstS8U, *src);
    return dstS8U;
  }

  TSoundTrackMono16 *dstM16 =
      dynamic_cast<TSoundTrackMono16 *>(dst.getPointer());
  if (dstM16) {
    convertSamplesT(*dstM16, *src);
    return dstM16;
  }

  TSoundTrackStereo16 *dstS16 =
      dynamic_cast<TSoundTrackStereo16 *>(dst.getPointer());
  if (dstS16) {
    convertSamplesT(*dstS16, *src);
    return dstS16;
  }

  TSoundTrackMono24 *dstM24 =
      dynamic_cast<TSoundTrackMono24 *>(dst.getPointer());
  if (dstM24) {
    convertSamplesT(*dstM24, *src);
    return dstM24;
  }

  TSoundTrackStereo24 *dstS24 =
      dynamic_cast<TSoundTrackStereo24 *>(dst.getPointer());
  if (dstS24) {
    convertSamplesT(*dstS24, *src);
    return dstS24;
  }

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

//-----------------------------------------------------------------------------
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());

      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->isSampleSigned());

      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>
TSoundTrackP doReverb(TSoundTrackT<T> *src, double delayTime,
                      double decayFactor, double extendTime) {
  TINT32 dstSampleCount =
      src->getSampleCount() + (TINT32)(src->getSampleRate() * extendTime);

  TSoundTrackT<T> *dst = new TSoundTrackT<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,
                    m_decayFactor, m_extendTime);
  }

  TSoundTrackP compute(const TSoundTrackMono8Unsigned &src) override {
    return doReverb(const_cast<TSoundTrackMono8Unsigned *>(&src), m_delayTime,
                    m_decayFactor, m_extendTime);
  }

  TSoundTrackP compute(const TSoundTrackStereo8Signed &src) override {
    return doReverb(const_cast<TSoundTrackStereo8Signed *>(&src), m_delayTime,
                    m_decayFactor, m_extendTime);
  }

  TSoundTrackP compute(const TSoundTrackStereo8Unsigned &src) override {
    return doReverb(const_cast<TSoundTrackStereo8Unsigned *>(&src), m_delayTime,
                    m_decayFactor, m_extendTime);
  }

  TSoundTrackP compute(const TSoundTrackMono16 &src) override {
    return doReverb(const_cast<TSoundTrackMono16 *>(&src), m_delayTime,
                    m_decayFactor, m_extendTime);
  }

  TSoundTrackP compute(const TSoundTrackStereo16 &src) override {
    return doReverb(const_cast<TSoundTrackStereo16 *>(&src), m_delayTime,
                    m_decayFactor, m_extendTime);
  }

  TSoundTrackP compute(const TSoundTrackMono24 &src) override {
    return doReverb(const_cast<TSoundTrackMono24 *>(&src), m_delayTime,
                    m_decayFactor, m_extendTime);
  }

  TSoundTrackP compute(const TSoundTrackStereo24 &src) override {
    return doReverb(const_cast<TSoundTrackStereo24 *>(&src), m_delayTime,
                    m_decayFactor, m_extendTime);
  }
};

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

TSoundTrackP TSop::reverb(TSoundTrackP src, double delayTime,
                          double decayFactor, double extendTime) {
  TSoundReverb *reverb = new TSoundReverb(delayTime, decayFactor, extendTime);
  assert(reverb);
  if (!reverb) return TSoundTrackP();
  TSoundTrackP dst = src->apply(reverb);
  delete reverb;
  return dst;
}

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

template <class T>
TSoundTrackP doGate(TSoundTrackT<T> *src, double threshold, double holdTime,
                    double /*releaseTime*/) {
  TSoundTrackT<T> *dst = new TSoundTrackT<T>(
      src->getSampleRate(), src->getChannelCount(), src->getSampleCount());

  double sampleExcursion_inv =
      1.0 / (double)(src->getMaxPressure(0, src->getSampleCount() - 1, 0) -
                     src->getMinPressure(0, src->getSampleCount() - 1, 0));

  TINT32 holdTimeSamples = src->secondsToSamples(holdTime);
  TINT32 time            = 0;

  const T *srcSample    = src->samples();
  const T *srcEndSample = srcSample + src->getSampleCount();
  T *dstSample          = dst->samples();

  while (srcSample < srcEndSample) {
    if (fabs(srcSample->getValue(0) * sampleExcursion_inv) < threshold) {
      if (time >= holdTimeSamples)
        *dstSample = T();
      else
        *dstSample = *srcSample;

      ++time;
    } else {
      time       = 0;
      *dstSample = *srcSample;
    }

    ++srcSample;
    ++dstSample;
  }

  return dst;
}

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

class TSoundGate final : public TSoundTransform {
  double m_threshold;
  double m_holdTime;
  double m_releaseTime;

public:
  TSoundGate(double threshold, double holdTime, double releaseTime)
      : m_threshold(threshold)
      , m_holdTime(holdTime)
      , m_releaseTime(releaseTime) {}

  ~TSoundGate() {}

  TSoundTrackP compute(const TSoundTrackMono8Signed &src) override {
    return doGate(const_cast<TSoundTrackMono8Signed *>(&src), m_threshold,
                  m_holdTime, m_releaseTime);
  }

  TSoundTrackP compute(const TSoundTrackMono8Unsigned &src) override {
    return doGate(const_cast<TSoundTrackMono8Unsigned *>(&src), m_threshold,
                  m_holdTime, m_releaseTime);
  }

  TSoundTrackP compute(const TSoundTrackStereo8Signed &src) override {
    return doGate(const_cast<TSoundTrackStereo8Signed *>(&src), m_threshold,
                  m_holdTime, m_releaseTime);
  }

  TSoundTrackP compute(const TSoundTrackStereo8Unsigned &src) override {
    return doGate(const_cast<TSoundTrackStereo8Unsigned *>(&src), m_threshold,
                  m_holdTime, m_releaseTime);
  }

  TSoundTrackP compute(const TSoundTrackMono16 &src) override {
    return doGate(const_cast<TSoundTrackMono16 *>(&src), m_threshold,
                  m_holdTime, m_releaseTime);
  }

  TSoundTrackP compute(const TSoundTrackStereo16 &src) override {
    return doGate(const_cast<TSoundTrackStereo16 *>(&src), m_threshold,
                  m_holdTime, m_releaseTime);
  }

  TSoundTrackP compute(const TSoundTrackMono24 &src) override {
    return doGate(const_cast<TSoundTrackMono24 *>(&src), m_threshold,
                  m_holdTime, m_releaseTime);
  }

  TSoundTrackP compute(const TSoundTrackStereo24 &src) override {
    return doGate(const_cast<TSoundTrackStereo24 *>(&src), m_threshold,
                  m_holdTime, m_releaseTime);
  }
};

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

TSoundTrackP TSop::gate(TSoundTrackP src, double threshold, double holdTime,
                        double releaseTime) {
  TSoundGate *gate = new TSoundGate(threshold, holdTime, releaseTime);
  assert(gate);
  if (!gate) return TSoundTrackP();
  TSoundTrackP dst = src->apply(gate);
  delete gate;
  return dst;
}

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

TSoundTrackP TSop::timeStrech(TSoundTrackP src, double ratio) {
  TINT32 sampleRate = (TINT32)(src->getSampleRate() * ratio);

  if (sampleRate > 100000) sampleRate = 100000;

  TSoundTrackP st;

  if (sampleRate > 0) {
    TSoundTrackResample *resample =
        new TSoundTrackResample(sampleRate, FLT_TRIANGLE);
    st = src->apply(resample);
    delete resample;
    st->setSampleRate(src->getSampleRate());
  }

  return st;
}

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

template <class T>
TSoundTrackP doEcho(TSoundTrackT<T> *src, double delayTime, double decayFactor,
                    double extendTime) {
  typedef typename T::ChannelValueType ChannelValueType;

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

  TSoundTrackT<T> *dst = new TSoundTrackT<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 dell'echo e'
  // out(i) = in(i) + decayFactor * in(i - k)

  bool chans = src->getChannelCount() == 2;
  endDstSample =
      dst->samples() + std::min(dstSampleCount, (TINT32)src->getSampleCount());
  while (dstSample < endDstSample) {
    //*dstSample = *srcSample + *(srcSample - k)*decayFactor;
    ChannelValueType val = (ChannelValueType)(
        (srcSample - k)->getValue(TSound::MONO) * decayFactor);
    dstSample->setValue(TSound::MONO, srcSample->getValue(TSound::MONO) + val);
    if (chans) {
      ChannelValueType val = (ChannelValueType)(
          (srcSample - k)->getValue(TSound::RIGHT) * decayFactor);
      dstSample->setValue(TSound::RIGHT,
                          srcSample->getValue(TSound::RIGHT) + val);
    }
    ++dstSample;
    ++srcSample;
  }

  endDstSample = dstSample + k;
  while (dstSample < endDstSample) {
    //*dstSample = *(srcSample - k)*decayFactor;
    ChannelValueType val = (ChannelValueType)(
        (srcSample - k)->getValue(TSound::MONO) * decayFactor);
    dstSample->setValue(TSound::MONO, val);
    if (chans) {
      ChannelValueType val = (ChannelValueType)(
          (srcSample - k)->getValue(TSound::RIGHT) * decayFactor);
      dstSample->setValue(TSound::RIGHT, val);
    }
    ++dstSample;
    ++srcSample;
  }

  srcSample    = src->samples() + src->getSampleCount() - 1;
  endDstSample = dst->samples() + dstSampleCount;
  while (dstSample < endDstSample) {
    //*dstSample = *(srcSample)*decayFactor;
    ChannelValueType val =
        (ChannelValueType)(srcSample->getValue(TSound::MONO) * decayFactor);
    dstSample->setValue(TSound::MONO, val);
    if (chans) {
      ChannelValueType val =
          (ChannelValueType)(srcSample->getValue(TSound::RIGHT) * decayFactor);
      dstSample->setValue(TSound::RIGHT, val);
    }
    ++dstSample;
  }

  return TSoundTrackP(dst);
}

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

void TSop::echo(TSoundTrackP &dst, const TSoundTrackP &src, double delayTime,
                double decayFactor, double extendTime) {
  TSoundTrackMono8Signed *srcM8S;
  srcM8S = dynamic_cast<TSoundTrackMono8Signed *>(src.getPointer());
  if (srcM8S)
    dst = doEcho(srcM8S, delayTime, decayFactor, extendTime);
  else {
    TSoundTrackMono8Unsigned *srcM8U;
    srcM8U = dynamic_cast<TSoundTrackMono8Unsigned *>(src.getPointer());
    if (srcM8U)
      dst = doEcho(srcM8U, delayTime, decayFactor, extendTime);
    else {
      TSoundTrackStereo8Signed *srcS8S;
      srcS8S = dynamic_cast<TSoundTrackStereo8Signed *>(src.getPointer());
      if (srcS8S)
        dst = doEcho(srcS8S, delayTime, decayFactor, extendTime);
      else {
        TSoundTrackStereo8Unsigned *srcS8U;
        srcS8U = dynamic_cast<TSoundTrackStereo8Unsigned *>(src.getPointer());
        if (srcS8U)
          dst = doEcho(srcS8U, delayTime, decayFactor, extendTime);
        else {
          TSoundTrackMono16 *srcM16;
          srcM16 = dynamic_cast<TSoundTrackMono16 *>(src.getPointer());
          if (srcM16)
            dst = doEcho(srcM16, delayTime, decayFactor, extendTime);
          else {
            TSoundTrackStereo16 *srcS16;
            srcS16 = dynamic_cast<TSoundTrackStereo16 *>(src.getPointer());
            if (srcS16)
              dst = doEcho(srcS16, delayTime, decayFactor, extendTime);
            else {
              TSoundTrackMono24 *srcM24;
              srcM24 = dynamic_cast<TSoundTrackMono24 *>(src.getPointer());
              if (srcM24)
                dst = doEcho(srcM24, delayTime, decayFactor, extendTime);
              else {
                TSoundTrackStereo24 *srcS24;
                srcS24 = dynamic_cast<TSoundTrackStereo24 *>(src.getPointer());
                if (srcS24)
                  dst = doEcho(srcS24, delayTime, decayFactor, extendTime);
              }
            }
          }
        }
      }
    }
  }
}

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

TSoundTrackP TSop::insertBlank(TSoundTrackP src, TINT32 s0, TINT32 len) {
  assert(len >= 0);
  if (len == 0) return src;

  TINT32 ss0 = tcrop<TINT32>(s0, 0, src->getSampleCount());

  TSoundTrackFormat format = src->getFormat();
  TSoundTrackP dst = TSoundTrack::create(format, (src->getSampleCount() + len));

  UCHAR *dstRawData = (UCHAR *)dst->getRawData();
  UCHAR *srcRawData = (UCHAR *)src->getRawData();

  int bytePerSample = dst->getSampleSize();
  memcpy(dstRawData, srcRawData, ss0 * bytePerSample);
  if (format.m_signedSample)
    memset(dstRawData + ss0 * bytePerSample, 0, len * bytePerSample);
  else
    memset(dstRawData + ss0 * bytePerSample, 127, len * bytePerSample);
  memcpy(dstRawData + (ss0 + len) * bytePerSample,
         srcRawData + ss0 * bytePerSample,
         (src->getSampleCount() - ss0) * bytePerSample);

  return dst;
}

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

TSoundTrackP TSop::insertBlank(TSoundTrackP src, double t0, double len) {
  return insertBlank(src, src->secondsToSamples(t0),
                     src->secondsToSamples(len));
}

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

TSoundTrackP TSop::remove(TSoundTrackP src, TINT32 s0, TINT32 s1,
                          TSoundTrackP &paste) {
  TINT32 ss0, ss1;

  ss0 = std::max<TINT32>((TINT32)0, s0);
  ss1 = std::min(s1, (TINT32)(src->getSampleCount() - 1));
  TSoundTrackP soundTrackSlice;
  if (ss0 <= ss1) soundTrackSlice = src->extract(ss0, ss1);
  if (!soundTrackSlice) {
    paste = TSoundTrackP();
    return src;
  }
  paste = soundTrackSlice->clone();

  TSoundTrackFormat format = src->getFormat();
  TSoundTrackP dst =
      TSoundTrack::create(format, (src->getSampleCount() - (ss1 - ss0 + 1)));

  TINT32 dstSampleSize = dst->getSampleSize();
  UCHAR *newRowData    = (UCHAR *)dst->getRawData();
  UCHAR *srcRowData    = (UCHAR *)src->getRawData();

  memcpy(newRowData, srcRowData, ss0 * dstSampleSize);
  memcpy(newRowData + (ss0 * dstSampleSize),
         srcRowData + (ss1 + 1) * dstSampleSize,
         (src->getSampleCount() - ss1 - 1) * dst->getSampleSize());

  return dst;
}

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

TSoundTrackP TSop::remove(TSoundTrackP src, double t0, double t1,
                          TSoundTrackP &paste) {
  return remove(src, src->secondsToSamples(t0), src->secondsToSamples(t1),
                paste);
}

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

template <class T>
TSoundTrackP mixT(TSoundTrackT<T> *st1, double a1, TSoundTrackT<T> *st2,
                  double a2) {
  TINT32 sampleCount = std::max(st1->getSampleCount(), st2->getSampleCount());

  TSoundTrackT<T> *dst = new TSoundTrackT<T>(
      st1->getSampleRate(), st1->getChannelCount(), sampleCount);

  T *dstSample = dst->samples();
  T *endDstSample =
      dstSample + std::min(st1->getSampleCount(), st2->getSampleCount());

  T *st1Sample = st1->samples();
  T *st2Sample = st2->samples();

  while (dstSample < endDstSample) {
    *dstSample++ = T::mix(*st1Sample, a1, *st2Sample, a2);
    ++st1Sample;
    ++st2Sample;
  }

  T *srcSample =
      st1->getSampleCount() > st2->getSampleCount() ? st1Sample : st2Sample;
  endDstSample                                  = dst->samples() + sampleCount;
  while (dstSample < endDstSample) *dstSample++ = *srcSample++;

  return TSoundTrackP(dst);
}

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

class TSoundTrackMixer final : public TSoundTransform {
  double m_alpha1, m_alpha2;
  TSoundTrackP m_sndtrack;

public:
  TSoundTrackMixer(double a1, double a2, const TSoundTrackP &st2)
      : TSoundTransform(), m_alpha1(a1), m_alpha2(a2), m_sndtrack(st2) {}

  ~TSoundTrackMixer(){};

  TSoundTrackP compute(const TSoundTrackMono8Signed &src) override {
    assert(src.getFormat() == m_sndtrack->getFormat());

    return (
        mixT(const_cast<TSoundTrackMono8Signed *>(&src), m_alpha1,
             dynamic_cast<TSoundTrackMono8Signed *>(m_sndtrack.getPointer()),
             m_alpha2));
  }

  TSoundTrackP compute(const TSoundTrackMono8Unsigned &src) override {
    assert(src.getFormat() == m_sndtrack->getFormat());

    return (
        mixT(const_cast<TSoundTrackMono8Unsigned *>(&src), m_alpha1,
             dynamic_cast<TSoundTrackMono8Unsigned *>(m_sndtrack.getPointer()),
             m_alpha2));
  }

  TSoundTrackP compute(const TSoundTrackStereo8Signed &src) override {
    assert(src.getFormat() == m_sndtrack->getFormat());

    return (
        mixT(const_cast<TSoundTrackStereo8Signed *>(&src), m_alpha1,
             dynamic_cast<TSoundTrackStereo8Signed *>(m_sndtrack.getPointer()),
             m_alpha2));
  }

  TSoundTrackP compute(const TSoundTrackStereo8Unsigned &src) override {
    assert(src.getFormat() == m_sndtrack->getFormat());

    return (mixT(
        const_cast<TSoundTrackStereo8Unsigned *>(&src), m_alpha1,
        dynamic_cast<TSoundTrackStereo8Unsigned *>(m_sndtrack.getPointer()),
        m_alpha2));
  }

  TSoundTrackP compute(const TSoundTrackMono16 &src) override {
    assert(src.getFormat() == m_sndtrack->getFormat());

    return (mixT(const_cast<TSoundTrackMono16 *>(&src), m_alpha1,
                 dynamic_cast<TSoundTrackMono16 *>(m_sndtrack.getPointer()),
                 m_alpha2));
  }

  TSoundTrackP compute(const TSoundTrackStereo16 &src) override {
    assert(src.getFormat() == m_sndtrack->getFormat());

    return (mixT(const_cast<TSoundTrackStereo16 *>(&src), m_alpha1,
                 dynamic_cast<TSoundTrackStereo16 *>(m_sndtrack.getPointer()),
                 m_alpha2));
  }

  TSoundTrackP compute(const TSoundTrackMono24 &src) override {
    assert(src.getFormat() == m_sndtrack->getFormat());

    return (mixT(const_cast<TSoundTrackMono24 *>(&src), m_alpha1,
                 dynamic_cast<TSoundTrackMono24 *>(m_sndtrack.getPointer()),
                 m_alpha2));
  }

  TSoundTrackP compute(const TSoundTrackStereo24 &src) override {
    assert(src.getFormat() == m_sndtrack->getFormat());

    return (mixT(const_cast<TSoundTrackStereo24 *>(&src), m_alpha1,
                 dynamic_cast<TSoundTrackStereo24 *>(m_sndtrack.getPointer()),
                 m_alpha2));
  }
};

TSoundTrackP TSop::mix(const TSoundTrackP &st1, const TSoundTrackP &st2,
                       double a1, double a2) {
  TSoundTrackMixer *converter;
  a1               = tcrop<double>(a1, 0.0, 1.0);
  a2               = tcrop<double>(a2, 0.0, 1.0);
  converter        = new TSoundTrackMixer(a1, a2, st2);
  TSoundTrackP snd = st1->apply(converter);
  delete converter;
  return (snd);
}

//==============================================================================
//
// TSop::FadeIn
//
//==============================================================================

template <class T>
TSoundTrackP doFadeIn(const TSoundTrackT<T> &track, double riseFactor) {
  typedef typename T::ChannelValueType ChannelValueType;
  int sampleCount = (int)((double)track.getSampleCount() * riseFactor);
  if (!sampleCount) sampleCount = 1;
  assert(sampleCount);
  int channelCount = track.getChannelCount();

  TSoundTrackT<T> *out =
      new TSoundTrackT<T>(track.getSampleRate(), channelCount, sampleCount);

  double val[2], step[2];

  ChannelValueType chan[2];
  const T *firstSample = track.samples();
  for (int k = 0; k < channelCount; ++k) {
    chan[k] = firstSample->getValue(k);
    if (firstSample->isSampleSigned()) {
      val[k]  = 0;
      step[k] = (double)chan[k] / (double)sampleCount;
    } else {
      val[k]  = 127;
      step[k] = (double)(chan[k] - 128) / (double)sampleCount;
    }
  }

  T *psample = out->samples();
  T *end     = psample + out->getSampleCount();

  while (psample < end) {
    T sample;
    for (int k = 0; k < channelCount; ++k) {
      sample.setValue(k, (ChannelValueType)val[k]);
      val[k] += step[k];
    }
    *psample = sample;
    ++psample;
  }

  return out;
}

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

class TSoundTrackFaderIn final : public TSoundTransform {
public:
  TSoundTrackFaderIn(double riseFactor)
      : TSoundTransform(), m_riseFactor(riseFactor) {}

  TSoundTrackP compute(const TSoundTrackMono8Signed &) override;
  TSoundTrackP compute(const TSoundTrackStereo8Signed &) override;
  TSoundTrackP compute(const TSoundTrackMono8Unsigned &) override;
  TSoundTrackP compute(const TSoundTrackStereo8Unsigned &) override;
  TSoundTrackP compute(const TSoundTrackMono16 &) override;
  TSoundTrackP compute(const TSoundTrackStereo16 &) override;
  TSoundTrackP compute(const TSoundTrackMono24 &) override;
  TSoundTrackP compute(const TSoundTrackStereo24 &) override;

  double m_riseFactor;
};

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

TSoundTrackP TSoundTrackFaderIn::compute(const TSoundTrackMono8Signed &track) {
  return doFadeIn(track, m_riseFactor);
}

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

TSoundTrackP TSoundTrackFaderIn::compute(
    const TSoundTrackStereo8Signed &track) {
  return doFadeIn(track, m_riseFactor);
}

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

TSoundTrackP TSoundTrackFaderIn::compute(
    const TSoundTrackMono8Unsigned &track) {
  return doFadeIn(track, m_riseFactor);
}

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

TSoundTrackP TSoundTrackFaderIn::compute(
    const TSoundTrackStereo8Unsigned &track) {
  return doFadeIn(track, m_riseFactor);
}

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

TSoundTrackP TSoundTrackFaderIn::compute(const TSoundTrackMono16 &track) {
  return doFadeIn(track, m_riseFactor);
}

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

TSoundTrackP TSoundTrackFaderIn::compute(const TSoundTrackStereo16 &track) {
  return doFadeIn(track, m_riseFactor);
}
//------------------------------------------------------------------------------

TSoundTrackP TSoundTrackFaderIn::compute(const TSoundTrackMono24 &track) {
  return doFadeIn(track, m_riseFactor);
}
//------------------------------------------------------------------------------

TSoundTrackP TSoundTrackFaderIn::compute(const TSoundTrackStereo24 &track) {
  return doFadeIn(track, m_riseFactor);
}

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

TSoundTrackP TSop::fadeIn(const TSoundTrackP src, double riseFactor) {
  TSoundTrackFaderIn *fader = new TSoundTrackFaderIn(riseFactor);
  TSoundTrackP out          = src->apply(fader);
  delete fader;
  return out;
}

//==============================================================================
//
// TSop::FadeOut
//
//==============================================================================

template <class T>
TSoundTrackP doFadeOut(const TSoundTrackT<T> &track, double decayFactor) {
  typedef typename T::ChannelValueType ChannelValueType;
  int sampleCount = (int)((double)track.getSampleCount() * decayFactor);
  if (!sampleCount) sampleCount = 1;
  assert(sampleCount);
  int channelCount = track.getChannelCount();

  TSoundTrackT<T> *out =
      new TSoundTrackT<T>(track.getSampleRate(), channelCount, sampleCount);

  double val[2], step[2];
  ChannelValueType chan[2];
  const T *lastSample = (track.samples() + track.getSampleCount() - 1);
  for (int k = 0; k < channelCount; ++k) {
    chan[k] = lastSample->getValue(k);
    val[k]  = (double)chan[k];
    if (lastSample->isSampleSigned())
      step[k] = (double)chan[k] / (double)sampleCount;
    else
      step[k] = (double)(chan[k] - 128) / (double)sampleCount;
  }

  T *psample = out->samples();
  T *end     = psample + out->getSampleCount();

  while (psample < end) {
    T sample;
    for (int k = 0; k < channelCount; ++k) {
      sample.setValue(k, (ChannelValueType)val[k]);
      val[k] -= step[k];
    }
    *psample = sample;
    ++psample;
  }

  return out;
}

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

class TSoundTrackFaderOut final : public TSoundTransform {
public:
  TSoundTrackFaderOut(double decayFactor)
      : TSoundTransform(), m_decayFactor(decayFactor) {}

  TSoundTrackP compute(const TSoundTrackMono8Signed &) override;
  TSoundTrackP compute(const TSoundTrackStereo8Signed &) override;
  TSoundTrackP compute(const TSoundTrackMono8Unsigned &) override;
  TSoundTrackP compute(const TSoundTrackStereo8Unsigned &) override;
  TSoundTrackP compute(const TSoundTrackMono16 &) override;
  TSoundTrackP compute(const TSoundTrackStereo16 &) override;
  TSoundTrackP compute(const TSoundTrackMono24 &) override;
  TSoundTrackP compute(const TSoundTrackStereo24 &) override;

  double m_decayFactor;
};

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

TSoundTrackP TSoundTrackFaderOut::compute(const TSoundTrackMono8Signed &track) {
  return doFadeOut(track, m_decayFactor);
}

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

TSoundTrackP TSoundTrackFaderOut::compute(
    const TSoundTrackStereo8Signed &track) {
  return doFadeOut(track, m_decayFactor);
}

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

TSoundTrackP TSoundTrackFaderOut::compute(
    const TSoundTrackMono8Unsigned &track) {
  return doFadeOut(track, m_decayFactor);
}

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

TSoundTrackP TSoundTrackFaderOut::compute(
    const TSoundTrackStereo8Unsigned &track) {
  return doFadeOut(track, m_decayFactor);
}

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

TSoundTrackP TSoundTrackFaderOut::compute(const TSoundTrackMono16 &track) {
  return doFadeOut(track, m_decayFactor);
}

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

TSoundTrackP TSoundTrackFaderOut::compute(const TSoundTrackStereo16 &track) {
  return doFadeOut(track, m_decayFactor);
}
//------------------------------------------------------------------------------

TSoundTrackP TSoundTrackFaderOut::compute(const TSoundTrackMono24 &track) {
  return doFadeOut(track, m_decayFactor);
}
//------------------------------------------------------------------------------

TSoundTrackP TSoundTrackFaderOut::compute(const TSoundTrackStereo24 &track) {
  return doFadeOut(track, m_decayFactor);
}

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

TSoundTrackP TSop::fadeOut(const TSoundTrackP src, double decayFactor) {
  TSoundTrackFaderOut *fader = new TSoundTrackFaderOut(decayFactor);
  TSoundTrackP out           = src->apply(fader);
  delete fader;
  return out;
}

//==============================================================================
//
// TSop::CrossFade
//
//==============================================================================

template <class T>
TSoundTrackP doCrossFade(const TSoundTrackT<T> &track1, TSoundTrackT<T> *track2,
                         double crossFactor) {
  typedef typename T::ChannelValueType ChannelValueType;
  int channelCount = track2->getChannelCount();
  int sampleCount  = (int)((double)track2->getSampleCount() * crossFactor);
  if (!sampleCount) sampleCount = 1;
  assert(sampleCount);

  // ultimo campione di track1
  ChannelValueType chanTrack1[2];
  const T *lastSample = (track1.samples() + track1.getSampleCount() - 1);
  int k;
  for (k = 0; k < channelCount; ++k) chanTrack1[k] = lastSample->getValue(k);

  double val[2], step[2];

  // primo campione di track2
  ChannelValueType chanTrack2[2];
  const T *firstSample = track2->samples();
  for (k = 0; k < channelCount; ++k) {
    chanTrack2[k] = firstSample->getValue(k);
    val[k]        = chanTrack1[k] - chanTrack2[k];
    step[k]       = val[k] / (double)sampleCount;
  }

  TSoundTrackT<T> *out =
      new TSoundTrackT<T>(track2->getSampleRate(), channelCount, sampleCount);

  T *psample = out->samples();
  T *end     = psample + out->getSampleCount();

  while (psample < end) {
    T sample;
    for (int k = 0; k < channelCount; ++k) {
      double tot             = (double)firstSample->getValue(k) + val[k];
      ChannelValueType value = (ChannelValueType)tot;

      sample.setValue(k, value);
      val[k] -= step[k];
    }
    *psample = sample;
    ++psample;
    //++firstSample;
  }

  return out;
}

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

class TSoundTrackCrossFader final : public TSoundTransform {
public:
  TSoundTrackCrossFader(TSoundTrackP src, double crossFactor)
      : TSoundTransform(), m_st(src), m_crossFactor(crossFactor) {}

  TSoundTrackP compute(const TSoundTrackMono8Signed &) override;
  TSoundTrackP compute(const TSoundTrackStereo8Signed &) override;
  TSoundTrackP compute(const TSoundTrackMono8Unsigned &) override;
  TSoundTrackP compute(const TSoundTrackStereo8Unsigned &) override;
  TSoundTrackP compute(const TSoundTrackMono16 &) override;
  TSoundTrackP compute(const TSoundTrackStereo16 &) override;
  TSoundTrackP compute(const TSoundTrackMono24 &) override;
  TSoundTrackP compute(const TSoundTrackStereo24 &) override;

  TSoundTrackP m_st;
  double m_crossFactor;
};

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

TSoundTrackP TSoundTrackCrossFader::compute(const TSoundTrackMono8Signed &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFade(src,
                     dynamic_cast<TSoundTrackMono8Signed *>(m_st.getPointer()),
                     m_crossFactor);
}

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

TSoundTrackP TSoundTrackCrossFader::compute(
    const TSoundTrackStereo8Signed &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFade(
      src, dynamic_cast<TSoundTrackStereo8Signed *>(m_st.getPointer()),
      m_crossFactor);
}

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

TSoundTrackP TSoundTrackCrossFader::compute(
    const TSoundTrackMono8Unsigned &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFade(
      src, dynamic_cast<TSoundTrackMono8Unsigned *>(m_st.getPointer()),
      m_crossFactor);
}

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

TSoundTrackP TSoundTrackCrossFader::compute(
    const TSoundTrackStereo8Unsigned &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFade(
      src, dynamic_cast<TSoundTrackStereo8Unsigned *>(m_st.getPointer()),
      m_crossFactor);
}

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

TSoundTrackP TSoundTrackCrossFader::compute(const TSoundTrackMono16 &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFade(src, dynamic_cast<TSoundTrackMono16 *>(m_st.getPointer()),
                     m_crossFactor);
}

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

TSoundTrackP TSoundTrackCrossFader::compute(const TSoundTrackStereo16 &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFade(src,
                     dynamic_cast<TSoundTrackStereo16 *>(m_st.getPointer()),
                     m_crossFactor);
}

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

TSoundTrackP TSoundTrackCrossFader::compute(const TSoundTrackMono24 &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFade(src, dynamic_cast<TSoundTrackMono24 *>(m_st.getPointer()),
                     m_crossFactor);
}

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

TSoundTrackP TSoundTrackCrossFader::compute(const TSoundTrackStereo24 &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFade(src,
                     dynamic_cast<TSoundTrackStereo24 *>(m_st.getPointer()),
                     m_crossFactor);
}

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

TSoundTrackP TSop::crossFade(const TSoundTrackP src1, const TSoundTrackP src2,
                             double crossFactor) {
  TSoundTrackCrossFader *fader = new TSoundTrackCrossFader(src2, crossFactor);
  TSoundTrackP out             = src1->apply(fader);
  delete fader;
  return out;
}

//
//
//
//
//==============================================================================
//
// TSop::CrossFadeOverWrite
//
//==============================================================================

template <class T>
TSoundTrackP doCrossFadeOverWrite(const TSoundTrackT<T> &track1,
                                  TSoundTrackT<T> *track2, double crossFactor) {
  typedef typename T::ChannelValueType ChannelValueType;
  int channelCount  = track2->getChannelCount();
  int sampleCount   = (int)((double)track2->getSampleCount() * crossFactor);
  int sampleCountT2 = track2->getSampleCount();

  if (sampleCount == 0 && sampleCountT2 == 1) return track2;
  if (sampleCount == 0) sampleCount = 1;
  assert(sampleCount);

  // ultimo campione di track1
  ChannelValueType chanTrack1[2];
  const T *lastSample = (track1.samples() + track1.getSampleCount() - 1);
  int k;
  for (k = 0; k < channelCount; ++k) chanTrack1[k] = lastSample->getValue(k);

  double val[2], step[2];

  // primo campione di track2
  ChannelValueType chanTrack2[2];
  const T *firstSample = track2->samples() + sampleCount;
  for (k = 0; k < channelCount; ++k) {
    chanTrack2[k] = firstSample->getValue(k);
    val[k]        = chanTrack1[k] - chanTrack2[k];
    step[k]       = val[k] / (double)sampleCount;
  }

  TSoundTrackT<T> *out =
      new TSoundTrackT<T>(track2->getSampleRate(), channelCount, sampleCountT2);

  T *psample = out->samples();
  T *end     = psample + sampleCount;

  while (psample < end) {
    T sample;
    for (int k = 0; k < channelCount; ++k) {
      double tot             = (double)firstSample->getValue(k) + val[k];
      ChannelValueType value = (ChannelValueType)tot;

      sample.setValue(k, value);
      val[k] -= step[k];
    }
    *psample = sample;
    ++psample;
  }

  out->copy(track2->extract(sampleCount, sampleCountT2 - 1), sampleCount);

  return out;
}

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

class TSoundTrackCrossFaderOverWrite final : public TSoundTransform {
public:
  TSoundTrackCrossFaderOverWrite(TSoundTrackP src, double crossFactor)
      : TSoundTransform(), m_st(src), m_crossFactor(crossFactor) {}

  TSoundTrackP compute(const TSoundTrackMono8Signed &) override;
  TSoundTrackP compute(const TSoundTrackStereo8Signed &) override;
  TSoundTrackP compute(const TSoundTrackMono8Unsigned &) override;
  TSoundTrackP compute(const TSoundTrackStereo8Unsigned &) override;
  TSoundTrackP compute(const TSoundTrackMono16 &) override;
  TSoundTrackP compute(const TSoundTrackStereo16 &) override;
  TSoundTrackP compute(const TSoundTrackMono24 &) override;
  TSoundTrackP compute(const TSoundTrackStereo24 &) override;

  TSoundTrackP m_st;
  double m_crossFactor;
};

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

TSoundTrackP TSoundTrackCrossFaderOverWrite::compute(
    const TSoundTrackMono8Signed &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFadeOverWrite(
      src, dynamic_cast<TSoundTrackMono8Signed *>(m_st.getPointer()),
      m_crossFactor);
}

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

TSoundTrackP TSoundTrackCrossFaderOverWrite::compute(
    const TSoundTrackStereo8Signed &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFadeOverWrite(
      src, dynamic_cast<TSoundTrackStereo8Signed *>(m_st.getPointer()),
      m_crossFactor);
}

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

TSoundTrackP TSoundTrackCrossFaderOverWrite::compute(
    const TSoundTrackMono8Unsigned &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFadeOverWrite(
      src, dynamic_cast<TSoundTrackMono8Unsigned *>(m_st.getPointer()),
      m_crossFactor);
}

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

TSoundTrackP TSoundTrackCrossFaderOverWrite::compute(
    const TSoundTrackStereo8Unsigned &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFadeOverWrite(
      src, dynamic_cast<TSoundTrackStereo8Unsigned *>(m_st.getPointer()),
      m_crossFactor);
}

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

TSoundTrackP TSoundTrackCrossFaderOverWrite::compute(
    const TSoundTrackMono16 &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFadeOverWrite(
      src, dynamic_cast<TSoundTrackMono16 *>(m_st.getPointer()), m_crossFactor);
}

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

TSoundTrackP TSoundTrackCrossFaderOverWrite::compute(
    const TSoundTrackStereo16 &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFadeOverWrite(
      src, dynamic_cast<TSoundTrackStereo16 *>(m_st.getPointer()),
      m_crossFactor);
}

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

TSoundTrackP TSoundTrackCrossFaderOverWrite::compute(
    const TSoundTrackMono24 &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFadeOverWrite(
      src, dynamic_cast<TSoundTrackMono24 *>(m_st.getPointer()), m_crossFactor);
}

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

TSoundTrackP TSoundTrackCrossFaderOverWrite::compute(
    const TSoundTrackStereo24 &src) {
  assert(src.getFormat() == m_st->getFormat());
  return doCrossFadeOverWrite(
      src, dynamic_cast<TSoundTrackStereo24 *>(m_st.getPointer()),
      m_crossFactor);
}

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

TSoundTrackP TSop::crossFade(double crossFactor, const TSoundTrackP src1,
                             const TSoundTrackP src2) {
  TSoundTrackCrossFaderOverWrite *fader =
      new TSoundTrackCrossFaderOverWrite(src2, crossFactor);
  TSoundTrackP out = src1->apply(fader);
  delete fader;
  return out;
}