X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Finterpolation.cc;h=20ab584885e7f19dd6bd348c2648b5d429c08c1b;hb=86d927b4ddbcedd1d6c120b1176aaef7352773cd;hp=a4a4b08872ff0506597d3c25bcae3c8c44ce0a73;hpb=f42f577bedbffcd2465341e033afac0a0326a491;p=ardour.git

diff --git a/libs/ardour/interpolation.cc b/libs/ardour/interpolation.cc
index a4a4b08872..20ab584885 100644
--- a/libs/ardour/interpolation.cc
+++ b/libs/ardour/interpolation.cc
@@ -1,76 +1,136 @@
 #include <stdint.h>
+#include <cstdio>
 
 #include "ardour/interpolation.h"
 
 using namespace ARDOUR;
 
-Interpolation::Interpolation()  : _speed (1.0L), state (0)
-{
-}
 
-Interpolation::~Interpolation() 
+framecnt_t
+LinearInterpolation::interpolate (int channel, framecnt_t nframes, Sample *input, Sample *output)
 {
-	state = src_delete (state);
-}
+	// index in the input buffers
+	framecnt_t   i = 0;
 
-void
-Interpolation::set_speed (double new_speed)
-{ 
-	_speed = new_speed; 
-	src_set_ratio (state, 1.0/_speed); 
-}
+	double acceleration;
+	double distance = 0.0;
 
-void
-Interpolation::reset_state ()
-{
-	if (state) {
-		src_reset (state);
+	if (_speed != _target_speed) {
+		acceleration = _target_speed - _speed;
 	} else {
-		state = src_new (SRC_LINEAR, 1, &error);
+		acceleration = 0.0;
 	}
-}
 
-void
-Interpolation::add_channel_to (int input_buffer_size, int output_buffer_size) 
-{
-	SRC_DATA newdata;
-	
-	/* Set up sample rate converter info. */
-	newdata.end_of_input = 0 ; 
-
-	newdata.input_frames  = input_buffer_size;
-	newdata.output_frames = output_buffer_size;
-
-	newdata.input_frames_used = 0 ;
-	newdata.output_frames_gen = 0 ;
-
-	newdata.src_ratio = 1.0/_speed;
-	
-	data.push_back (newdata);
-	
-	reset_state ();
+	distance = phase[channel];
+	for (framecnt_t outsample = 0; outsample < nframes; ++outsample) {
+		i = floor(distance);
+		Sample fractional_phase_part = distance - i;
+		if (fractional_phase_part >= 1.0) {
+			fractional_phase_part -= 1.0;
+			i++;
+		}
+
+		if (input && output) {
+		// Linearly interpolate into the output buffer
+			output[outsample] =
+				input[i] * (1.0f - fractional_phase_part) +
+				input[i+1] * fractional_phase_part;
+		}
+		distance += _speed + acceleration;
+	}
+
+	i = floor(distance);
+	phase[channel] = distance - floor(distance);
+
+	return i;
 }
 
-void
-Interpolation::remove_channel_from () 
+framecnt_t
+CubicInterpolation::interpolate (int channel, framecnt_t nframes, Sample *input, Sample *output)
 {
-	data.pop_back ();
-	reset_state ();
-}
+    // index in the input buffers
+    framecnt_t   i = 0;
 
-nframes_t
-Interpolation::interpolate (int channel, nframes_t nframes, Sample *input, Sample *output)
-{	
-	data[channel].data_in       = input;
-	data[channel].data_out      = output;
-	
-	data[channel].output_frames = nframes;
-	data[channel].src_ratio     = 1.0/_speed; 
-
-	if ((error = src_process (state, &data[channel]))) {	
-		printf ("\nError : %s\n\n", src_strerror (error));
-		exit (1);
-	}
+    double acceleration;
+    double distance = 0.0;
+
+    if (_speed != _target_speed) {
+        acceleration = _target_speed - _speed;
+    } else {
+	    acceleration = 0.0;
+    }
+
+    distance = phase[channel];
+
+    if (nframes < 3) {
+	    /* no interpolation possible */
+
+	    for (i = 0; i < nframes; ++i) {
+		    output[i] = input[i];
+	    }
+
+	    return nframes;
+    }
+
+    /* keep this condition out of the inner loop */
+
+    if (input && output) {
+
+	    Sample inm1;
+
+	    if (floor (distance) == 0.0) {
+		    /* best guess for the fake point we have to add to be able to interpolate at i == 0:
+		       .... maintain slope of first actual segment ...
+		    */
+		    inm1 = input[i] - (input[i+1] - input[i]);
+	    } else {
+		    inm1 = input[i-1];
+	    }
+
+	    for (framecnt_t outsample = 0; outsample < nframes; ++outsample) {
+
+		    float f = floor (distance);
+		    float fractional_phase_part = distance - f;
+
+		    /* get the index into the input we should start with */
+
+		    i = lrintf (f);
+
+		    /* fractional_phase_part only reaches 1.0 thanks to float imprecision. In theory
+		       it should always be < 1.0. If it ever >= 1.0, then bump the index we use
+		       and back it off. This is the point where we "skip" an entire sample in the
+		       input, because the phase part has accumulated so much error that we should
+		       really be closer to the next sample. or something like that ...
+		    */
+
+		    if (fractional_phase_part >= 1.0) {
+			    fractional_phase_part -= 1.0;
+			    ++i;
+		    }
+
+		    // Cubically interpolate into the output buffer: keep this inlined for speed and rely on compiler
+		    // optimization to take care of the rest
+		    // shamelessly ripped from Steve Harris' swh-plugins (ladspa-util.h)
+
+		    output[outsample] = input[i] + 0.5f * fractional_phase_part * (input[i+1] - inm1 +
+							  fractional_phase_part * (4.0f * input[i+1] + 2.0f * inm1 - 5.0f * input[i] - input[i+2] +
+								fractional_phase_part * (3.0f * (input[i] - input[i+1]) - inm1 + input[i+2])));
+
+		    distance += _speed + acceleration;
+		    inm1 = input[i];
+	    }
+
+    } else {
+
+	    /* not sure that this is ever utilized - it implies that one of the input/output buffers is missing */
+
+	    for (framecnt_t outsample = 0; outsample < nframes; ++outsample) {
+		    distance += _speed + acceleration;
+	    }
+    }
+
+    i = floor(distance);
+    phase[channel] = distance - floor(distance);
 
-	return data[channel].input_frames_used;
+    return i;
 }