Audio refactor

Externals/FreeSurround/include/FreeSurround/FreeSurroundDecoder.h

@@ -15,6 +15,10 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 // USA.
 
+// Dolphin: taken from https://hydrogenaud.io/index.php?topic=52235.0 but heavily modified
+// A more up to date version is available here:
+// https://github.com/kodi-adsp/adsp.freesurround
+
 #ifndef FREESURROUND_DECODER_H
 #define FREESURROUND_DECODER_H
 #include "KissFFTR.h"
@@ -27,25 +31,26 @@ typedef std::complex<double> cplx;
 // right). The ordering here also determines the ordering of interleaved
 // samples in the output signal.
 
+// Dolphin: channels mapping modified to be the same as most audio backends
 typedef enum channel_id {
   ci_none = 0,
   ci_front_left = 1 << 1,
-  ci_front_center_left = 1 << 2,
-  ci_front_center = 1 << 3,
-  ci_front_center_right = 1 << 4,
-  ci_front_right = 1 << 5,
+  ci_front_right = 1 << 2,
+  ci_front_center_left = 1 << 3,
+  ci_front_center = 1 << 4,
+  ci_front_center_right = 1 << 5,
   ci_side_front_left = 1 << 6,
   ci_side_front_right = 1 << 7,
   ci_side_center_left = 1 << 8,
   ci_side_center_right = 1 << 9,
   ci_side_back_left = 1 << 10,
   ci_side_back_right = 1 << 11,
-  ci_back_left = 1 << 12,
-  ci_back_center_left = 1 << 13,
-  ci_back_center = 1 << 14,
-  ci_back_center_right = 1 << 15,
-  ci_back_right = 1 << 16,
-  ci_lfe = 1 << 31
+  ci_lfe = 1 << 12,
+  ci_back_left = 1 << 13,
+  ci_back_center_left = 1 << 14,
+  ci_back_center = 1 << 15,
+  ci_back_center_right = 1 << 16,
+  ci_back_right = 1 << 31
 } channel_id;
 
 // The supported output channel setups. A channel setup is defined by the set
@@ -68,10 +73,11 @@ class DPL2FSDecoder {
   // @param setup The output channel setup -- determines the number of output
   // channels and their place in the sound field.
   // @param blocksize Granularity at which data is processed by the decode()
-  // function. Must be a power of two and should correspond to ca. 10ms worth
-  // of single-channel samples (default is 4096 for 44.1Khz data). Do not make
-  // it shorter or longer than 5ms to 20ms since the granularity at which
-  // locations are decoded changes with this.
+  // function. Must be a multiple of two (better if power of) and should
+  // correspond to ca. 10ms worth of single-channel samples
+  // (default is 4096 at 44.1Khz data (Dolphin: ???)).
+  // Do not make it shorter or longer than 5ms to 20ms since the granularity
+  // at which locations are decoded changes with this (Dolphin: not true, 40+).
   DPL2FSDecoder();
   ~DPL2FSDecoder();
 
@@ -86,7 +92,9 @@ class DPL2FSDecoder {
   // @return A pointer to an internal buffer of exactly blocksize (multiplexed)
   // multichannel samples. The actual number of values depends on the number of
   // output channels in the chosen channel setup.
-  float *decode(float *input);
+  // Modified by Dolphin to take a ring buffer in 2 parts
+  float* decode(const float* input_part_1, const float* input_part_2,
+    unsigned int part_1_num);
 
   // Flush the internal buffer.
   void flush();
@@ -105,7 +113,8 @@ class DPL2FSDecoder {
   void set_bass_redirection(bool v);
 
   // number of samples currently held in the buffer
-  unsigned int buffered();
+  unsigned int buffered() const;
+  float* input_buffer();
 
 private:
   // constants
@@ -157,7 +166,9 @@ class DPL2FSDecoder {
   std::vector<cplx> lf, rf;
 
   // FFT buffers
-  kiss_fftr_cfg forward, inverse;
+  // they used to be kiss_fftr_cfg but due to unsafe deletion Dolphin changed them to a char*
+  char* forward;
+  char* inverse;
 
   // buffers
   // whether the buffer is currently empty or dirty

Externals/FreeSurround/include/FreeSurround/KissFFTR.h

@@ -17,7 +17,7 @@ extern "C" {
 
 typedef struct kiss_fftr_state *kiss_fftr_cfg;
 
-kiss_fftr_cfg kiss_fftr_alloc(int nfft, int inverse_fft, void *mem,
+char* kiss_fftr_alloc(int nfft, int inverse_fft, void *mem,
                               size_t *lenmem);
 /*
  nfft must be even

Externals/FreeSurround/source/FreeSurroundDecoder.cpp

@@ -28,70 +28,110 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 DPL2FSDecoder::DPL2FSDecoder() {
   initialized = false;
   buffer_empty = true;
+  forward = nullptr;
+  inverse = nullptr;
 }
 
 DPL2FSDecoder::~DPL2FSDecoder() {
-#pragma warning(suppress : 4150)
-  delete forward;
-#pragma warning(suppress : 4150)
-  delete inverse;
+    delete[] forward;
+    delete[] inverse;
 }
 
 void DPL2FSDecoder::Init(channel_setup chsetup, unsigned int blsize,
                          unsigned int sample_rate) {
-  if (!initialized) {
-    setup = chsetup;
-    N = blsize;
-    samplerate = sample_rate;
+  int prev_N = N;
+  setup = chsetup;
+  N = blsize;
+  bool N_changed = !initialized || C != prev_N;
+  samplerate = sample_rate;
 
-    // Initialize the parameters
-    wnd = std::vector<double>(N);
+  // Initialize the parameters
+  int prev_C = C;
+  C = static_cast<unsigned int>(chn_alloc[setup].size());
+  bool C_changed = !initialized || C != prev_C;
+  wnd = std::vector<double>(N);
+  if (N_changed)
+  {
     inbuf = std::vector<float>(3 * N);
-    lt = std::vector<double>(N);
-    rt = std::vector<double>(N);
-    dst = std::vector<double>(N);
-    lf = std::vector<cplx>(N / 2 + 1);
-    rf = std::vector<cplx>(N / 2 + 1);
-    forward = kiss_fftr_alloc(N, 0, 0, 0);
-    inverse = kiss_fftr_alloc(N, 1, 0, 0);
-    C = static_cast<unsigned int>(chn_alloc[setup].size());
+  }
+  else
+  {
+    size_t prev_size = inbuf.size();
+    inbuf.resize(3 * N);
+    // Pad the data in the first third of the input buffer
+    if (prev_size > 0 && prev_size < inbuf.size())
+    {
+      //To finish
+      for (size_t i = prev_size; i < inbuf.size(); i += 2)
+        memcpy(&inbuf[i], &inbuf[prev_N - 2], sizeof(float) * 2);
+    }
+  }
+  lt = std::vector<double>(N);
+  rt = std::vector<double>(N);
+  dst = std::vector<double>(N);
+  lf = std::vector<cplx>(N / 2 + 1);
+  rf = std::vector<cplx>(N / 2 + 1);
+  delete[] forward;
+  delete[] inverse;
+  forward = kiss_fftr_alloc(N, 0, 0, 0);
+  inverse = kiss_fftr_alloc(N, 1, 0, 0);
 
-    // Allocate per-channel buffers
+  // Allocate per-channel buffers (pad if we already have data)
+  if (C_changed)
+  {
+    outbuf = std::vector<float>((N + N / 2) * C);
+  }
+  else
+  {
+    size_t prev_size = outbuf.size();
     outbuf.resize((N + N / 2) * C);
-    signal.resize(C, std::vector<cplx>(N));
+    if (prev_size > 0)
+    {
+      //To review, probably not needed, the new output is never based on the old one, it's just to shift the memory quicker
+      for (size_t i = prev_size; i < outbuf.size(); i += C)
+        memcpy(&outbuf[i], &outbuf[prev_size - C], sizeof(float) * C);
+    }
+  }
+  for (unsigned int k = 0; k < std::min(C, static_cast<unsigned int>(signal.size())); k++)
+    signal[k].resize(N);
+  signal.resize(C, std::vector<cplx>(N));
 
-    // Init the window function
-    for (unsigned int k = 0; k < N; k++)
-      wnd[k] = sqrt(0.5 * (1 - cos(2 * pi * k / N)) / N);
+  // Init the window function
+  for (unsigned int k = 0; k < N; k++)
+    wnd[k] = sqrt(0.5 * (1 - cos(2 * pi * k / N)) / N);
 
-    // set default parameters
-    set_circular_wrap(90);
-    set_shift(0);
-    set_depth(1);
-    set_focus(0);
-    set_center_image(1);
-    set_front_separation(1);
-    set_rear_separation(1);
-    set_low_cutoff(40.0f / samplerate * 2);
-    set_high_cutoff(90.0f / samplerate * 2);
-    set_bass_redirection(false);
+  // set default parameters
+  set_circular_wrap(90);
+  set_shift(0);
+  set_depth(1);
+  set_focus(0);
+  set_center_image(1);
+  set_front_separation(1);
+  set_rear_separation(1);
+  set_low_cutoff(40.0f);
+  set_high_cutoff(90.0f);
+  set_bass_redirection(false);
 
-    initialized = true;
-  }
+  initialized = true;
 }
 
 // decode a stereo chunk, produces a multichannel chunk of the same size
 // (lagged)
-float *DPL2FSDecoder::decode(float *input) {
+float* DPL2FSDecoder::decode(const float* input_part_1,
+  const float* input_part_2, unsigned int part_1_num) {
   if (initialized) {
+    part_1_num = min(part_1_num, N);
     // append incoming data to the end of the input buffer
-    memcpy(&inbuf[N], &input[0], 8 * N);
+    memcpy(&inbuf[N], &input_part_1[0], sizeof(float) * 2 * part_1_num);
+    if (part_1_num < N)
+      memcpy(&inbuf[N + part_1_num * 2], &input_part_2[0], sizeof(float) * 2
+        * (N - part_1_num));
     // process first and second half, overlapped
     buffered_decode(&inbuf[0]);
     buffered_decode(&inbuf[N]);
-    // shift last half of the input to the beginning (for overlapping with a
-    // future block)
-    memcpy(&inbuf[0], &inbuf[2 * N], 4 * N);
+    // shift the third part of the input to the beginning (for overlapping with
+    // a future block)
+    memcpy(&inbuf[0], &inbuf[2 * N], sizeof(float) * N);
     buffer_empty = false;
     return &outbuf[0];
   }
@@ -100,13 +140,15 @@ float *DPL2FSDecoder::decode(float *input) {
 
 // flush the internal buffers
 void DPL2FSDecoder::flush() {
-  memset(&outbuf[0], 0, outbuf.size() * 4);
-  memset(&inbuf[0], 0, inbuf.size() * 4);
+  memset(&outbuf[0], 0, outbuf.size() * sizeof(float));
+  memset(&inbuf[0], 0, inbuf.size() * sizeof(float));
   buffer_empty = true;
 }
 
 // number of samples currently held in the buffer
-unsigned int DPL2FSDecoder::buffered() { return buffer_empty ? 0 : N / 2; }
+unsigned int DPL2FSDecoder::buffered() const { return buffer_empty ? 0 : N / 2; }
+
+float* DPL2FSDecoder::input_buffer() { return &inbuf[0]; }
 
 // set soundfield & rendering parameters
 void DPL2FSDecoder::set_circular_wrap(float v) { circular_wrap = v; }
@@ -116,8 +158,12 @@ void DPL2FSDecoder::set_focus(float v) { focus = v; }
 void DPL2FSDecoder::set_center_image(float v) { center_image = v; }
 void DPL2FSDecoder::set_front_separation(float v) { front_separation = v; }
 void DPL2FSDecoder::set_rear_separation(float v) { rear_separation = v; }
-void DPL2FSDecoder::set_low_cutoff(float v) { lo_cut = v * (N / 2); }
-void DPL2FSDecoder::set_high_cutoff(float v) { hi_cut = v * (N / 2); }
+void DPL2FSDecoder::set_low_cutoff(float v) {
+  lo_cut = (v / (samplerate / 2.f)) * (N / 2);
+}
+void DPL2FSDecoder::set_high_cutoff(float v) {
+  hi_cut = (v / (samplerate / 2.f)) * (N / 2);
+}
 void DPL2FSDecoder::set_bass_redirection(bool v) { use_lfe = v; }
 
 // helper functions
@@ -163,8 +209,8 @@ void DPL2FSDecoder::buffered_decode(float *input) {
   }
 
   // map into spectral domain
-  kiss_fftr(forward, &lt[0], (kiss_fft_cpx *)&lf[0]);
-  kiss_fftr(forward, &rt[0], (kiss_fft_cpx *)&rf[0]);
+  kiss_fftr((kiss_fftr_cfg)forward, &lt[0], (kiss_fft_cpx *)&lf[0]);
+  kiss_fftr((kiss_fftr_cfg)forward, &rt[0], (kiss_fft_cpx *)&rf[0]);
 
   // compute multichannel output signal in the spectral domain
   for (unsigned int f = 1; f < N / 2; f++) {
@@ -228,14 +274,14 @@ void DPL2FSDecoder::buffered_decode(float *input) {
     }
   }
 
-  // shift the last 2/3 to the first 2/3 of the output buffer
-  memcpy(&outbuf[0], &outbuf[C * N / 2], N * C * 4);
+  // shift the last 2/3 (a block) to the first 2/3 of the output buffer
+  memcpy(&outbuf[0], &outbuf[C * N / 2], N * C * sizeof(float));
   // and clear the rest
-  memset(&outbuf[C * N], 0, C * 4 * N / 2);
+  memset(&outbuf[C * N], 0, C * sizeof(float) * N / 2);
   // backtransform each channel and overlap-add
   for (unsigned int c = 0; c < C; c++) {
     // back-transform into time domain
-    kiss_fftri(inverse, (kiss_fft_cpx *)&signal[c][0], &dst[0]);
+    kiss_fftri((kiss_fftr_cfg)inverse, (kiss_fft_cpx *)&signal[c][0], &dst[0]);
     // add the result to the last 2/3 of the output buffer, windowed (and
     // remultiplex)
     for (unsigned int k = 0; k < N; k++)

Externals/FreeSurround/source/KissFFT.cpp

@@ -43,6 +43,8 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  functions.
  */
 
+#include <cassert>
+
 static void kf_bfly2(kiss_fft_cpx *Fout, const size_t fstride,
                      const kiss_fft_cfg st, int m) {
   kiss_fft_cpx *Fout2;
@@ -379,6 +381,7 @@ kiss_fft_cfg kiss_fft_alloc(int nfft, int inverse_fft, void *mem,
                      sizeof(kiss_fft_cpx) * (nfft - 1); /* twiddle factors*/
 
   if (lenmem == NULL) {
+    assert(false); // Support removed by Dolphin (unsafe)
     st = (kiss_fft_cfg) new char[memneeded];
   } else {
     if (mem != NULL && *lenmem >= memneeded)

Externals/FreeSurround/source/KissFFTR.cpp

@@ -39,6 +39,8 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FreeSurround/KissFFTR.h"
 #include "FreeSurround/_KissFFTGuts.h"
 
+#include <cassert>
+
 struct kiss_fftr_state {
   kiss_fft_cfg substate;
   kiss_fft_cpx *tmpbuf;
@@ -48,10 +50,11 @@ struct kiss_fftr_state {
 #endif
 };
 
-kiss_fftr_cfg kiss_fftr_alloc(int nfft, int inverse_fft, void *mem,
+char* kiss_fftr_alloc(int nfft, int inverse_fft, void *mem,
                               size_t *lenmem) {
   int i;
   kiss_fftr_cfg st = NULL;
+  char* char_st = NULL;
   size_t subsize = 65536 * 4, memneeded = 0;
 
   if (nfft & 1) {
@@ -65,10 +68,16 @@ kiss_fftr_cfg kiss_fftr_alloc(int nfft, int inverse_fft, void *mem,
               sizeof(kiss_fft_cpx) * (nfft * 3 / 2);
 
   if (lenmem == NULL) {
-    st = (kiss_fftr_cfg) new char[memneeded];
+    assert(memneeded >= sizeof(kiss_fftr_state));
+    char_st = new char[memneeded];
+    st = (kiss_fftr_cfg)char_st;
   } else {
     if (*lenmem >= memneeded)
+    {
+      assert(false); // Support removed by Dolphin
       st = (kiss_fftr_cfg)mem;
+      char_st = (char*)st;
+    }
     *lenmem = memneeded;
   }
   if (!st)
@@ -86,7 +95,7 @@ kiss_fftr_cfg kiss_fftr_alloc(int nfft, int inverse_fft, void *mem,
       phase *= -1;
     kf_cexp(st->super_twiddles + i, phase);
   }
-  return st;
+  return char_st;
 }
 
 void kiss_fftr(kiss_fftr_cfg st, const kiss_fft_scalar *timedata,