allow to customize variable i/o plugin inputs

[ardour.git] / libs / ardour / mix.cc

diff --git a/libs/ardour/mix.cc b/libs/ardour/mix.cc
index a32c274b7c93fd159c354b828bd8607db3d3e357..96ae62448703a9d0406cc8e7eee91939a353782a 100644 (file)
--- a/libs/ardour/mix.cc
+++ b/libs/ardour/mix.cc
@@ -18,43 +18,48 @@
 */
 
 #include <cmath>
-#include <ardour/types.h>
-#include <ardour/utils.h>
-#include <ardour/mix.h>
+#include "ardour/types.h"
+#include "ardour/utils.h"
+#include "ardour/mix.h"
+#include "ardour/runtime_functions.h"
 #include <stdint.h>
 
+using std::min;
+using std::max;
+using namespace ARDOUR;
+
 #if defined (ARCH_X86) && defined (BUILD_SSE_OPTIMIZATIONS)
 // Debug wrappers
 
 float
-debug_compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current) 
+debug_compute_peak (const ARDOUR::Sample *buf, pframes_t nsamples, float current)
 {
        if ( ((intptr_t)buf % 16) != 0) {
-               cerr << "compute_peak(): buffer unaligned!" << endl;
+               std::cerr << "compute_peak(): buffer unaligned!" << std::endl;
        }
 
        return x86_sse_compute_peak(buf, nsamples, current);
 }
 
 void
-debug_apply_gain_to_buffer (ARDOUR::Sample *buf, nframes_t nframes, float gain)
+debug_apply_gain_to_buffer (ARDOUR::Sample *buf, pframes_t nframes, float gain)
 {
        if ( ((intptr_t)buf % 16) != 0) {
-               cerr << "apply_gain_to_buffer(): buffer unaligned!" << endl;
+               std::cerr << "apply_gain_to_buffer(): buffer unaligned!" << std::endl;
        }
 
        x86_sse_apply_gain_to_buffer(buf, nframes, gain);
 }
 
 void
-debug_mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain)
+debug_mix_buffers_with_gain (ARDOUR::Sample *dst, const ARDOUR::Sample *src, pframes_t nframes, float gain)
 {
        if ( ((intptr_t)dst & 15) != 0) {
-               cerr << "mix_buffers_with_gain(): dst unaligned!" << endl;
+               std::cerr << "mix_buffers_with_gain(): dst unaligned!" << std::endl;
        }
 
        if ( ((intptr_t)dst & 15) != ((intptr_t)src & 15) ) {
-               cerr << "mix_buffers_with_gain(): dst & src don't have the same alignment!" << endl;
+               std::cerr << "mix_buffers_with_gain(): dst & src don't have the same alignment!" << std::endl;
                mix_buffers_with_gain(dst, src, nframes, gain);
        } else {
                x86_sse_mix_buffers_with_gain(dst, src, nframes, gain);
@@ -62,14 +67,14 @@ debug_mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t
 }
 
 void
-debug_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes)
+debug_mix_buffers_no_gain (ARDOUR::Sample *dst, const ARDOUR::Sample *src, pframes_t nframes)
 {
        if ( ((intptr_t)dst & 15) != 0) {
-               cerr << "mix_buffers_no_gain(): dst unaligned!" << endl;
+               std::cerr << "mix_buffers_no_gain(): dst unaligned!" << std::endl;
        }
 
        if ( ((intptr_t)dst & 15) != ((intptr_t)src & 15) ) {
-               cerr << "mix_buffers_no_gain(): dst & src don't have the same alignment!" << endl;
+               std::cerr << "mix_buffers_no_gain(): dst & src don't have the same alignment!" << std::endl;
                mix_buffers_no_gain(dst, src, nframes);
        } else {
                x86_sse_mix_buffers_no_gain(dst, src, nframes);
@@ -80,95 +85,101 @@ debug_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t n
 
 
 float
-compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current) 
+default_compute_peak (const ARDOUR::Sample * buf, pframes_t nsamples, float current)
 {
-       for (nframes_t i = 0; i < nsamples; ++i) {
+       for (pframes_t i = 0; i < nsamples; ++i) {
                current = f_max (current, fabsf (buf[i]));
        }
 
        return current;
-}      
+}
 
 void
-find_peaks (ARDOUR::Sample *buf, nframes_t nframes, float *min, float *max)
+default_find_peaks (const ARDOUR::Sample * buf, pframes_t nframes, float *minf, float *maxf)
 {
-       long i;
+       pframes_t i;
        float a, b;
 
-       a = *max;
-       b = *min;
+       a = *maxf;
+       b = *minf;
 
-       for (i = 0; i < nframes; i++) 
+       for (i = 0; i < nframes; i++)
        {
-               a = fmax (buf[i], a);
-               b = fmin (buf[i], b);
+               a = max (buf[i], a);
+               b = min (buf[i], b);
        }
 
-       *max = a;
-       *min = b;
+       *maxf = a;
+       *minf = b;
 }
 
 void
-apply_gain_to_buffer (ARDOUR::Sample *buf, nframes_t nframes, float gain)
-{              
-       for (nframes_t i=0; i<nframes; i++)
+default_apply_gain_to_buffer (ARDOUR::Sample * buf, pframes_t nframes, float gain)
+{
+       for (pframes_t i=0; i<nframes; i++)
                buf[i] *= gain;
 }
 
 void
-mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain)
+default_mix_buffers_with_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, pframes_t nframes, float gain)
 {
-       for (nframes_t i = 0; i < nframes; i++) {
+       for (pframes_t i = 0; i < nframes; i++) {
                dst[i] += src[i] * gain;
        }
 }
 
 void
-mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes)
+default_mix_buffers_no_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, pframes_t nframes)
 {
-       for (nframes_t i=0; i < nframes; i++) {
+       for (pframes_t i=0; i < nframes; i++) {
                dst[i] += src[i];
        }
 }
 
+void
+default_copy_vector (ARDOUR::Sample * dst, const ARDOUR::Sample * src, pframes_t nframes)
+{
+       memcpy(dst, src, nframes*sizeof(ARDOUR::Sample));
+}
+
 #if defined (__APPLE__) && defined (BUILD_VECLIB_OPTIMIZATIONS)
 #include <Accelerate/Accelerate.h>
 
 float
-veclib_compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current)
+veclib_compute_peak (const ARDOUR::Sample * buf, pframes_t nsamples, float current)
 {
        float tmpmax = 0.0f;
-        vDSP_maxmgv(buf, 1, &tmpmax, nsamples);
-        return f_max(current, tmpmax);
+       vDSP_maxmgv(buf, 1, &tmpmax, nsamples);
+       return f_max(current, tmpmax);
 }
 
 void
-veclib_find_peaks (ARDOUR::Sample *buf, nframes_t nframes, float *min, float *max)
+veclib_find_peaks (const ARDOUR::Sample * buf, pframes_t nframes, float *min, float *max)
 {
-       vDSP_maxv (buf, 1, max, nframes);
-       vDSP_minv (buf, 1, min, nframes);
+       vDSP_maxv (const_cast<ARDOUR::Sample*>(buf), 1, max, nframes);
+       vDSP_minv (const_cast<ARDOUR::Sample*>(buf), 1, min, nframes);
 }
 
 void
-veclib_apply_gain_to_buffer (ARDOUR::Sample *buf, nframes_t nframes, float gain)
+veclib_apply_gain_to_buffer (ARDOUR::Sample * buf, pframes_t nframes, float gain)
 {
-        vDSP_vsmul(buf, 1, &gain, buf, 1, nframes);
+       vDSP_vsmul(buf, 1, &gain, buf, 1, nframes);
 }
 
 void
-veclib_mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain)
+veclib_mix_buffers_with_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, pframes_t nframes, float gain)
 {
-        vDSP_vsma(src, 1, &gain, dst, 1, dst, 1, nframes);
+       vDSP_vsma(src, 1, &gain, dst, 1, dst, 1, nframes);
 }
 
 void
-veclib_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes)
+veclib_mix_buffers_no_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, pframes_t nframes)
 {
-        // It seems that a vector mult only operation does not exist...
-        float gain = 1.0f;
-        vDSP_vsma(src, 1, &gain, dst, 1, dst, 1, nframes);
+       // It seems that a vector mult only operation does not exist...
+       float gain = 1.0f;
+       vDSP_vsma(src, 1, &gain, dst, 1, dst, 1, nframes);
 }
 
 #endif
-               
+