From fd6b906bda1c235a982aab6379f2d50f126b6cca Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Sun, 26 Jul 2026 18:31:09 +0200
Subject: [PATCH 01/34] outsource cubic interp to lambda

---
 src/rvoice/fluid_rvoice_dsp.cpp | 53 +++++++++++++++++----------------
 1 file changed, 28 insertions(+), 25 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index d1a9729a1..9b9e2035d 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -340,6 +340,15 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         end_point2 = end_point1;
     }
 
+    /* Lambda for cubic interpolation with parameterized samples */
+    auto interp_cubic = [&](fluid_real_t s0, fluid_real_t s1, fluid_real_t s2, fluid_real_t s3) {
+        coeffs = &interp_coeff[fluid_phase_fract_to_tablerow(dsp_phase) * CUBIC_INTERP_ORDER];
+        return (coeffs[0] * s0
+               + coeffs[1] * s1
+               + coeffs[2] * s2
+               + coeffs[3] * s3);
+    };
+
     while(1)
     {
         dsp_phase_index = fluid_phase_index(dsp_phase);
@@ -348,13 +357,11 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         for(; dsp_phase_index == start_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
         {
             fluid_real_t sample;
-            coeffs = &interp_coeff[fluid_phase_fract_to_tablerow(dsp_phase) * CUBIC_INTERP_ORDER];
+            sample = interp_cubic(start_point,
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2));
 
-            sample =  (coeffs[0] * start_point
-                     + coeffs[1] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index)
-                     + coeffs[2] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1)
-                     + coeffs[3] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2));
-                        
             dsp_buf[dsp_i] = sample;
 
             /* increment phase and amplitude */
@@ -366,12 +373,11 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         for(; dsp_i < FLUID_BUFSIZE && dsp_phase_index <= end_index; dsp_i++)
         {
             fluid_real_t sample;
-            coeffs = &interp_coeff[fluid_phase_fract_to_tablerow(dsp_phase) * CUBIC_INTERP_ORDER];
-
-            sample =  (coeffs[0] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1)
-                     + coeffs[1] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index)
-                     + coeffs[2] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1)
-                     + coeffs[3] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2));
+            sample = interp_cubic(
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2));
 
             dsp_buf[dsp_i] = sample;
 
@@ -392,12 +398,11 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         for(; dsp_phase_index <= end_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
         {
             fluid_real_t sample;
-            coeffs = &interp_coeff[fluid_phase_fract_to_tablerow(dsp_phase) * CUBIC_INTERP_ORDER];
-
-            sample =  (coeffs[0] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1)
-                     + coeffs[1] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index)
-                     + coeffs[2] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1)
-                     + coeffs[3] * end_point1);
+            sample = interp_cubic(
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
+                end_point1);
 
             dsp_buf[dsp_i] = sample;
 
@@ -412,13 +417,11 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         for(; dsp_phase_index <= end_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
         {
             fluid_real_t sample;
-            coeffs = &interp_coeff[fluid_phase_fract_to_tablerow(dsp_phase) * CUBIC_INTERP_ORDER];
-
-            
-            sample =  (coeffs[0] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1)
-                     + coeffs[1] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index)
-                     + coeffs[2] * end_point1
-                     + coeffs[3] * end_point2);
+            sample = interp_cubic(
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                end_point1,
+                end_point2);
 
             dsp_buf[dsp_i] = sample;
 

From 9b6047f75a3f46ee9dd147b7cb40a92aed4e8048 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Sun, 26 Jul 2026 20:02:02 +0200
Subject: [PATCH 02/34] 'lambdafication'

---
 src/rvoice/fluid_rvoice_dsp.cpp | 185 ++++++++++++++++----------------
 1 file changed, 90 insertions(+), 95 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index 9b9e2035d..bf1500d15 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -204,7 +204,6 @@ fluid_rvoice_dsp_interpolate_linear_local(fluid_rvoice_t *rvoice, fluid_real_t *
     unsigned int dsp_phase_index;
     unsigned int end_index;
     fluid_real_t point;
-    const fluid_real_t *FLUID_RESTRICT coeffs;
 
     /* Convert playback "speed" floating point value to phase index/fract */
     fluid_phase_set_float(dsp_phase_incr, voice->phase_incr);
@@ -222,6 +221,12 @@ fluid_rvoice_dsp_interpolate_linear_local(fluid_rvoice_t *rvoice, fluid_real_t *
         point = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->end);    /* duplicate end for samples no longer looping */
     }
 
+    auto interp_linear = [&](fluid_real_t s0, fluid_real_t s1)
+    {
+        const fluid_real_t* FLUID_RESTRICT coeffs = &interp_coeff_linear[fluid_phase_fract_to_tablerow(dsp_phase) * LINEAR_INTERP_ORDER];
+        return (coeffs[0] * s0 + coeffs[1] * s1);
+    };
+
     while(1)
     {
         dsp_phase_index = fluid_phase_index(dsp_phase);
@@ -229,12 +234,10 @@ fluid_rvoice_dsp_interpolate_linear_local(fluid_rvoice_t *rvoice, fluid_real_t *
         /* interpolate the sequence of sample points */
         for(; dsp_i < FLUID_BUFSIZE && dsp_phase_index <= end_index; dsp_i++)
         {
-            fluid_real_t sample;
-            coeffs = &interp_coeff_linear[fluid_phase_fract_to_tablerow(dsp_phase) * LINEAR_INTERP_ORDER];
-            
-            sample =  (coeffs[0] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index)
-                     + coeffs[1] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1));
-                        
+            fluid_real_t sample = interp_linear(
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1));
+
             dsp_buf[dsp_i] = sample;
 
             /* increment phase and amplitude */
@@ -253,11 +256,9 @@ fluid_rvoice_dsp_interpolate_linear_local(fluid_rvoice_t *rvoice, fluid_real_t *
         /* interpolate within last point */
         for(; dsp_phase_index <= end_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
         {
-            fluid_real_t sample;
-            coeffs = &interp_coeff_linear[fluid_phase_fract_to_tablerow(dsp_phase) * LINEAR_INTERP_ORDER];
-            
-            sample =  (coeffs[0] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index)
-                     + coeffs[1] * point);
+            fluid_real_t sample = interp_linear(
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                point);
 
             dsp_buf[dsp_i] = sample;
 
@@ -309,7 +310,6 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
     unsigned int dsp_phase_index;
     unsigned int start_index, end_index;
     fluid_real_t start_point, end_point1, end_point2;
-    const fluid_real_t *FLUID_RESTRICT coeffs;
 
     /* Convert playback "speed" floating point value to phase index/fract */
     fluid_phase_set_float(dsp_phase_incr, voice->phase_incr);
@@ -342,8 +342,8 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
 
     /* Lambda for cubic interpolation with parameterized samples */
     auto interp_cubic = [&](fluid_real_t s0, fluid_real_t s1, fluid_real_t s2, fluid_real_t s3) {
-        coeffs = &interp_coeff[fluid_phase_fract_to_tablerow(dsp_phase) * CUBIC_INTERP_ORDER];
-        return (coeffs[0] * s0
+        const fluid_real_t* FLUID_RESTRICT coeffs = &interp_coeff[fluid_phase_fract_to_tablerow(dsp_phase) * CUBIC_INTERP_ORDER];
+        return  (coeffs[0] * s0
                + coeffs[1] * s1
                + coeffs[2] * s2
                + coeffs[3] * s3);
@@ -356,8 +356,8 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         /* interpolate first sample point (start or loop start) if needed */
         for(; dsp_phase_index == start_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
         {
-            fluid_real_t sample;
-            sample = interp_cubic(start_point,
+            fluid_real_t sample = interp_cubic(
+                start_point,
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2));
@@ -372,8 +372,7 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         /* interpolate the sequence of sample points */
         for(; dsp_i < FLUID_BUFSIZE && dsp_phase_index <= end_index; dsp_i++)
         {
-            fluid_real_t sample;
-            sample = interp_cubic(
+            fluid_real_t sample = interp_cubic(
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
@@ -397,8 +396,7 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         /* interpolate within 2nd to last point */
         for(; dsp_phase_index <= end_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
         {
-            fluid_real_t sample;
-            sample = interp_cubic(
+            fluid_real_t sample = interp_cubic(
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
@@ -416,8 +414,7 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         /* interpolate within the last point */
         for(; dsp_phase_index <= end_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
         {
-            fluid_real_t sample;
-            sample = interp_cubic(
+            fluid_real_t sample = interp_cubic(
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
                 end_point1,
@@ -479,7 +476,6 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
     unsigned int dsp_phase_index;
     unsigned int start_index, end_index;
     fluid_real_t start_points[3], end_points[3];
-    const fluid_real_t *FLUID_RESTRICT coeffs;
 
     /* Convert playback "speed" floating point value to phase index/fract */
     fluid_phase_set_float(dsp_phase_incr, voice->phase_incr);
@@ -520,6 +516,20 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         end_points[2] = end_points[0];
     }
 
+    /* Lambda for cubic interpolation with parameterized samples */
+    auto interp_sinc = [&](fluid_real_t s[FLUID_INTERP_7THORDER])
+    {
+        const fluid_real_t* FLUID_RESTRICT coeffs = &sinc_table7[fluid_phase_fract_to_tablerow(dsp_phase) * SINC_INTERP_ORDER];
+
+        return
+              coeffs[0] * s[0]
+            + coeffs[1] * s[1]
+            + coeffs[2] * s[2]
+            + coeffs[3] * s[3]
+            + coeffs[4] * s[4]
+            + coeffs[5] * s[5]
+            + coeffs[6] * s[6];
+    };
     while(1)
     {
         dsp_phase_index = fluid_phase_index(dsp_phase);
@@ -527,16 +537,14 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         /* interpolate first sample point (start or loop start) if needed */
         for(; dsp_phase_index == start_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
         {
-            fluid_real_t sample;
-            coeffs = &sinc_table7[fluid_phase_fract_to_tablerow(dsp_phase) * SINC_INTERP_ORDER];
-
-            sample =  (coeffs[0] * start_points[2]
-                     + coeffs[1] * start_points[1]
-                     + coeffs[2] * start_points[0]
-                     + coeffs[3] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index)
-                     + coeffs[4] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1)
-                     + coeffs[5] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2)
-                     + coeffs[6] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 3));
+            fluid_real_t sample = interp_sinc({
+                start_points[2],
+                start_points[1],
+                start_points[0],
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 3)});
 
             dsp_buf[dsp_i] = sample;
 
@@ -550,16 +558,14 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         /* interpolate 2nd to first sample point (start or loop start) if needed */
         for(; dsp_phase_index == start_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
         {
-            fluid_real_t sample;
-            coeffs = &sinc_table7[fluid_phase_fract_to_tablerow(dsp_phase) * SINC_INTERP_ORDER];
-
-            sample =  (coeffs[0] * start_points[1]
-                     + coeffs[1] * start_points[0]
-                     + coeffs[2] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1)
-                     + coeffs[3] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index)
-                     + coeffs[4] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1)
-                     + coeffs[5] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2)
-                     + coeffs[6] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 3));
+            fluid_real_t sample = interp_sinc({
+                start_points[1],
+                start_points[0],
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 3)});
 
             dsp_buf[dsp_i] = sample;
 
@@ -573,16 +579,14 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         /* interpolate 3rd to first sample point (start or loop start) if needed */
         for(; dsp_phase_index == start_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
         {
-            fluid_real_t sample;
-            coeffs = &sinc_table7[fluid_phase_fract_to_tablerow(dsp_phase) * SINC_INTERP_ORDER];
-
-            sample =  (coeffs[0] * start_points[0]
-                     + coeffs[1] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2)
-                     + coeffs[2] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1)
-                     + coeffs[3] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index)
-                     + coeffs[4] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1)
-                     + coeffs[5] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2)
-                     + coeffs[6] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 3));
+            fluid_real_t sample = interp_sinc({
+                start_points[0],
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 3)});
 
             dsp_buf[dsp_i] = sample;
 
@@ -593,20 +597,17 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
 
         start_index -= 2;	/* set back to original start index */
 
-
         /* interpolate the sequence of sample points */
         for(; dsp_i < FLUID_BUFSIZE && dsp_phase_index <= end_index; dsp_i++)
         {
-            fluid_real_t sample;
-            coeffs = &sinc_table7[fluid_phase_fract_to_tablerow(dsp_phase) * SINC_INTERP_ORDER];
-
-            sample =  (coeffs[0] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3)
-                     + coeffs[1] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2)
-                     + coeffs[2] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1)
-                     + coeffs[3] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index)
-                     + coeffs[4] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1)
-                     + coeffs[5] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2)
-                     + coeffs[6] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 3));
+            fluid_real_t sample = interp_sinc({
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 3)});
 
             dsp_buf[dsp_i] = sample;
 
@@ -626,16 +627,14 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         /* interpolate within 3rd to last point */
         for(; dsp_phase_index <= end_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
         {
-            fluid_real_t sample;
-            coeffs = &sinc_table7[fluid_phase_fract_to_tablerow(dsp_phase) * SINC_INTERP_ORDER];
-
-            sample =  (coeffs[0] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3)
-                     + coeffs[1] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2)
-                     + coeffs[2] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1)
-                     + coeffs[3] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index)
-                     + coeffs[4] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1)
-                     + coeffs[5] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2)
-                     + coeffs[6] * end_points[0]);
+            fluid_real_t sample = interp_sinc({
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2),
+                end_points[0]});
 
             dsp_buf[dsp_i] = sample;
 
@@ -649,16 +648,14 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         /* interpolate within 2nd to last point */
         for(; dsp_phase_index <= end_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
         {
-            fluid_real_t sample;
-            coeffs = &sinc_table7[fluid_phase_fract_to_tablerow(dsp_phase) * SINC_INTERP_ORDER];
-
-            sample =  (coeffs[0] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3)
-                     + coeffs[1] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2)
-                     + coeffs[2] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1)
-                     + coeffs[3] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index)
-                     + coeffs[4] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1)
-                     + coeffs[5] * end_points[0]
-                     + coeffs[6] * end_points[1]);
+            fluid_real_t sample = interp_sinc({
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
+                end_points[0],
+                end_points[1]});
 
             dsp_buf[dsp_i] = sample;
 
@@ -672,16 +669,14 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         /* interpolate within last point */
         for(; dsp_phase_index <= end_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
         {
-            fluid_real_t sample;
-            coeffs = &sinc_table7[fluid_phase_fract_to_tablerow(dsp_phase) * SINC_INTERP_ORDER];
-
-            sample =  (coeffs[0] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3)
-                     + coeffs[1] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2)
-                     + coeffs[2] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1)
-                     + coeffs[3] * fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index)
-                     + coeffs[4] * end_points[0]
-                     + coeffs[5] * end_points[1]
-                     + coeffs[6] * end_points[2]);
+            fluid_real_t sample = interp_sinc({
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
+                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                end_points[0],
+                end_points[1],
+                end_points[2]});
 
             dsp_buf[dsp_i] = sample;
 

From 2388eeebd7daef6dbea515131215688e48eefa6d Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Sun, 26 Jul 2026 21:42:46 +0200
Subject: [PATCH 03/34] precompute loop iteration

---
 src/rvoice/fluid_rvoice_dsp.cpp | 59 ++++++++++++++++++++++++---------
 1 file changed, 44 insertions(+), 15 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index bf1500d15..932d7ac70 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -17,11 +17,14 @@
  * <https://www.gnu.org/licenses/>.
  */
 
+#define NOMINMAX
 #include "fluid_sys.h"
 #include "fluid_phase.h"
 #include "fluid_rvoice.h"
 #include "fluid_rvoice_dsp_tables.h"
 
+#include <algorithm>
+
 /* Purpose:
  *
  * Interpolates audio data (obtains values between the samples of the original
@@ -67,6 +70,17 @@ fluid_rvoice_get_float_sample(const short int *FLUID_RESTRICT dsp_msb, const cha
     return (fluid_real_t)sample;
 }
 
+static FLUID_INLINE unsigned short
+compute_interpolation_steps(fluid_phase_t dsp_phase, fluid_phase_t dsp_phase_incr, unsigned int dsp_end_index, unsigned short dsp_i)
+{
+    // How many steps until phase_index > limit?
+    fluid_phase_t boundary;
+	fluid_phase_set_int(boundary, dsp_end_index + 1);
+    fluid_phase_t steps = ((boundary - dsp_phase + dsp_phase_incr - 1) / dsp_phase_incr);
+    unsigned short iters = static_cast<unsigned short>(std::min<fluid_phase_t>(steps, (FLUID_BUFSIZE - dsp_i)));
+    return iters;
+}
+
 /* Special case of interpolate_none for rendering silent voices, i.e. in delay phase or zero volume */
 template<bool LOOPING>
 static int fluid_rvoice_dsp_silence_local(fluid_rvoice_t *rvoice, fluid_real_t *FLUID_RESTRICT dsp_buf)
@@ -88,7 +102,8 @@ static int fluid_rvoice_dsp_silence_local(fluid_rvoice_t *rvoice, fluid_real_t *
         dsp_phase_index = fluid_phase_index_round(dsp_phase); /* round to nearest point */
 
         /* interpolate sequence of sample points */
-        for (; dsp_i < FLUID_BUFSIZE && dsp_phase_index <= end_index; dsp_i++)
+		auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = 0;
             dsp_buf[dsp_i] = sample;
@@ -151,7 +166,8 @@ fluid_rvoice_dsp_interpolate_none_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
         dsp_phase_index = fluid_phase_index_round(dsp_phase);	/* round to nearest point */
 
         /* interpolate sequence of sample points */
-        for(; dsp_i < FLUID_BUFSIZE && dsp_phase_index <= end_index; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index);
             
@@ -232,7 +248,8 @@ fluid_rvoice_dsp_interpolate_linear_local(fluid_rvoice_t *rvoice, fluid_real_t *
         dsp_phase_index = fluid_phase_index(dsp_phase);
 
         /* interpolate the sequence of sample points */
-        for(; dsp_i < FLUID_BUFSIZE && dsp_phase_index <= end_index; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_linear(
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
@@ -254,7 +271,8 @@ fluid_rvoice_dsp_interpolate_linear_local(fluid_rvoice_t *rvoice, fluid_real_t *
         end_index++;	/* we're now interpolating the last point */
 
         /* interpolate within last point */
-        for(; dsp_phase_index <= end_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_linear(
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
@@ -354,7 +372,8 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         dsp_phase_index = fluid_phase_index(dsp_phase);
 
         /* interpolate first sample point (start or loop start) if needed */
-        for(; dsp_phase_index == start_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, start_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_cubic(
                 start_point,
@@ -370,7 +389,8 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         }
 
         /* interpolate the sequence of sample points */
-        for(; dsp_i < FLUID_BUFSIZE && dsp_phase_index <= end_index; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_cubic(
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
@@ -394,7 +414,8 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         end_index++;	/* we're now interpolating the 2nd to last point */
 
         /* interpolate within 2nd to last point */
-        for(; dsp_phase_index <= end_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_cubic(
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
@@ -412,7 +433,8 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         end_index++;	/* we're now interpolating the last point */
 
         /* interpolate within the last point */
-        for(; dsp_phase_index <= end_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_cubic(
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
@@ -535,7 +557,8 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         dsp_phase_index = fluid_phase_index(dsp_phase);
 
         /* interpolate first sample point (start or loop start) if needed */
-        for(; dsp_phase_index == start_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, start_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_sinc({
                 start_points[2],
@@ -556,7 +579,8 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         start_index++;
 
         /* interpolate 2nd to first sample point (start or loop start) if needed */
-        for(; dsp_phase_index == start_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, start_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_sinc({
                 start_points[1],
@@ -577,7 +601,8 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         start_index++;
 
         /* interpolate 3rd to first sample point (start or loop start) if needed */
-        for(; dsp_phase_index == start_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, start_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_sinc({
                 start_points[0],
@@ -598,7 +623,8 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         start_index -= 2;	/* set back to original start index */
 
         /* interpolate the sequence of sample points */
-        for(; dsp_i < FLUID_BUFSIZE && dsp_phase_index <= end_index; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_sinc({
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3),
@@ -625,7 +651,8 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         end_index++;	/* we're now interpolating the 3rd to last point */
 
         /* interpolate within 3rd to last point */
-        for(; dsp_phase_index <= end_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_sinc({
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3),
@@ -646,7 +673,8 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         end_index++;	/* we're now interpolating the 2nd to last point */
 
         /* interpolate within 2nd to last point */
-        for(; dsp_phase_index <= end_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_sinc({
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3),
@@ -667,7 +695,8 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         end_index++;	/* we're now interpolating the last point */
 
         /* interpolate within last point */
-        for(; dsp_phase_index <= end_index && dsp_i < FLUID_BUFSIZE; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_sinc({
                 fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3),

From ff2eb9c3fbe60101c94bc231e87c2b35a888f7d6 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Sun, 26 Jul 2026 23:00:43 +0200
Subject: [PATCH 04/34] restrict

---
 src/rvoice/fluid_iir_filter_impl.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rvoice/fluid_iir_filter_impl.cpp b/src/rvoice/fluid_iir_filter_impl.cpp
index 4110005d4..281782ea7 100644
--- a/src/rvoice/fluid_iir_filter_impl.cpp
+++ b/src/rvoice/fluid_iir_filter_impl.cpp
@@ -156,7 +156,7 @@ static inline void fluid_iir_filter_calculate_coefficients(R fres,
  */
 template<bool GAIN_NORM, bool AMPLIFY, enum fluid_iir_filter_type TYPE>
 static void
-fluid_iir_filter_apply_local(fluid_iir_filter_t *iir_filter, fluid_real_t *dsp_buf, unsigned int count)
+fluid_iir_filter_apply_local(fluid_iir_filter_t *iir_filter, fluid_real_t *FLUID_RESTRICT dsp_buf, unsigned int count)
 {
     // FLUID_IIR_Q_LINEAR may switch the filter off by setting Q==0
     // Due to the linear smoothing, last_q may not exactly become zero.

From a0e9bc5916b12ed2bd99340619318a3e66e77df4 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Sun, 26 Jul 2026 23:01:14 +0200
Subject: [PATCH 05/34] fix build

---
 src/rvoice/fluid_rvoice_dsp.cpp | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index 932d7ac70..9406570fc 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -24,6 +24,7 @@
 #include "fluid_rvoice_dsp_tables.h"
 
 #include <algorithm>
+#include <array>
 
 /* Purpose:
  *
@@ -271,7 +272,7 @@ fluid_rvoice_dsp_interpolate_linear_local(fluid_rvoice_t *rvoice, fluid_real_t *
         end_index++;	/* we're now interpolating the last point */
 
         /* interpolate within last point */
-        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
         for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_linear(
@@ -389,7 +390,7 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         }
 
         /* interpolate the sequence of sample points */
-        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
         for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_cubic(
@@ -414,7 +415,7 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         end_index++;	/* we're now interpolating the 2nd to last point */
 
         /* interpolate within 2nd to last point */
-        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
         for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_cubic(
@@ -433,7 +434,7 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         end_index++;	/* we're now interpolating the last point */
 
         /* interpolate within the last point */
-        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
         for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_cubic(
@@ -539,7 +540,7 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
     }
 
     /* Lambda for cubic interpolation with parameterized samples */
-    auto interp_sinc = [&](fluid_real_t s[FLUID_INTERP_7THORDER])
+    auto interp_sinc = [&](std::array<fluid_real_t, FLUID_INTERP_7THORDER> s)
     {
         const fluid_real_t* FLUID_RESTRICT coeffs = &sinc_table7[fluid_phase_fract_to_tablerow(dsp_phase) * SINC_INTERP_ORDER];
 
@@ -579,7 +580,7 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         start_index++;
 
         /* interpolate 2nd to first sample point (start or loop start) if needed */
-        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, start_index, dsp_i);
+        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, start_index, dsp_i);
         for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_sinc({
@@ -601,7 +602,7 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         start_index++;
 
         /* interpolate 3rd to first sample point (start or loop start) if needed */
-        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, start_index, dsp_i);
+        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, start_index, dsp_i);
         for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_sinc({
@@ -623,7 +624,7 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         start_index -= 2;	/* set back to original start index */
 
         /* interpolate the sequence of sample points */
-        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
         for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_sinc({
@@ -651,7 +652,7 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         end_index++;	/* we're now interpolating the 3rd to last point */
 
         /* interpolate within 3rd to last point */
-        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
         for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_sinc({
@@ -673,7 +674,7 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         end_index++;	/* we're now interpolating the 2nd to last point */
 
         /* interpolate within 2nd to last point */
-        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
         for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_sinc({
@@ -695,7 +696,7 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         end_index++;	/* we're now interpolating the last point */
 
         /* interpolate within last point */
-        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
         for (; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_sinc({

From 3bd08ef2a4a75af47ca5d237abcdc545144373e1 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Tue, 28 Jul 2026 22:29:16 +0200
Subject: [PATCH 06/34] fix underflow

---
 src/rvoice/fluid_rvoice_dsp.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index 9406570fc..fa1e14925 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -77,7 +77,7 @@ compute_interpolation_steps(fluid_phase_t dsp_phase, fluid_phase_t dsp_phase_inc
     // How many steps until phase_index > limit?
     fluid_phase_t boundary;
 	fluid_phase_set_int(boundary, dsp_end_index + 1);
-    fluid_phase_t steps = ((boundary - dsp_phase + dsp_phase_incr - 1) / dsp_phase_incr);
+    fluid_phase_t steps = dsp_phase > boundary ? 0 : ((boundary - dsp_phase + dsp_phase_incr - 1) / dsp_phase_incr);
     unsigned short iters = static_cast<unsigned short>(std::min<fluid_phase_t>(steps, (FLUID_BUFSIZE - dsp_i)));
     return iters;
 }

From 089cbc399217baab970026c2f3bc3bf974aa8480 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Thu, 30 Jul 2026 18:34:57 +0200
Subject: [PATCH 07/34] minor cleanup of cmake option enable-profiling

---
 CMakeLists.txt | 18 ++++--------------
 1 file changed, 4 insertions(+), 14 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 244fc0812..c54dead50 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -464,28 +464,18 @@ endif ( enable-floats )
 unset ( WITH_PROFILING CACHE )
 if ( enable-profiling )
     set ( WITH_PROFILING 1 )
-    if ( CMAKE_C_COMPILER_ID STREQUAL "Clang" )
+    if ( CMAKE_C_COMPILER_ID MATCHES "Clang" )
       set ( OPT_FLAGS "-Rpass=loop-vectorize -Rpass-analysis=loop-vectorize" )
-      find_program( CLANG_TIDY
-                    NAMES "clang-tidy"
-                    DOC "Path to clang-tidy executable" )
-
-      if ( CLANG_TIDY )
-        message ( STATUS "Found clang-tidy at ${CLANG_TIDY}" )
-        execute_process ( COMMAND ${CLANG_TIDY} "--version" )
-        set ( CMAKE_C_CLANG_TIDY ${CLANG_TIDY} )
-      endif ( CLANG_TIDY )
-    elseif ( CMAKE_C_COMPILER_ID STREQUAL "Intel" )
+    elseif ( CMAKE_C_COMPILER_ID MATCHES "Intel" )
       set ( OPT_FLAGS "-qopt-report=3" )
-    elseif ( CMAKE_C_COMPILER_ID STREQUAL "GNU" )
+    elseif ( CMAKE_C_COMPILER_ID MATCHES "GNU" )
       set ( OPT_FLAGS "-fopt-info -fopt-info-vec-missed" )
-	elseif ( CMAKE_C_COMPILER_ID STREQUAL "MSVC" )
+    elseif ( CMAKE_C_COMPILER_ID MATCHES "MSVC" )
 	  set ( OPT_FLAGS "/Qvec-report:2" )
     endif ( )
 
     set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OPT_FLAGS}" )
     set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OPT_FLAGS}" )
-
 endif ( enable-profiling )
 
 unset ( ENABLE_TRAPONFPE CACHE )

From 41508b7bf93f61073ee970c61f09bb7c70ecd017 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Sun, 2 Aug 2026 11:36:54 +0200
Subject: [PATCH 08/34] on the fly sinc computation

---
 src/rvoice/fluid_rvoice_dsp.cpp | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index fa1e14925..fdf61c2a3 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -25,6 +25,7 @@
 
 #include <algorithm>
 #include <array>
+#include <cmath>
 
 /* Purpose:
  *
@@ -542,7 +543,28 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
     /* Lambda for cubic interpolation with parameterized samples */
     auto interp_sinc = [&](std::array<fluid_real_t, FLUID_INTERP_7THORDER> s)
     {
-        const fluid_real_t* FLUID_RESTRICT coeffs = &sinc_table7[fluid_phase_fract_to_tablerow(dsp_phase) * SINC_INTERP_ORDER];
+        const fluid_real_t* FLUID_RESTRICT coeffs_ = &sinc_table7[fluid_phase_fract_to_tablerow(dsp_phase) * SINC_INTERP_ORDER];
+
+        auto x = fluid_phase_fract(dsp_phase) * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
+        std::array<fluid_real_t, SINC_INTERP_ORDER> coeffs;
+        for (int i = 0; i < SINC_INTERP_ORDER; i++)
+        {
+            double v, i_shifted = (double)i - (double)(SINC_INTERP_ORDER / 2.0) + (1 - x);
+
+            if (std::fabs(i_shifted) > 1e-6f)
+            {
+                auto arg = FLUID_M_PI * i_shifted;
+                v = std::sin(arg) / arg;
+                /* Hanning window */
+                v *= 0.5 * (1.0 + std::cos(2.0 * arg / (double)SINC_INTERP_ORDER));
+            }
+            else
+            {
+                v = 1.0;
+            }
+
+            coeffs[i] = v;
+        }
 
         return
               coeffs[0] * s[0]

From 2d0356b71e580e3f30185a7acda680f81a8ce917 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Sun, 2 Aug 2026 11:56:18 +0200
Subject: [PATCH 09/34] better constant folding

---
 src/rvoice/fluid_rvoice_dsp.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index fdf61c2a3..ffa7489c1 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -543,20 +543,18 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
     /* Lambda for cubic interpolation with parameterized samples */
     auto interp_sinc = [&](std::array<fluid_real_t, FLUID_INTERP_7THORDER> s)
     {
-        const fluid_real_t* FLUID_RESTRICT coeffs_ = &sinc_table7[fluid_phase_fract_to_tablerow(dsp_phase) * SINC_INTERP_ORDER];
-
         auto x = fluid_phase_fract(dsp_phase) * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
         std::array<fluid_real_t, SINC_INTERP_ORDER> coeffs;
         for (int i = 0; i < SINC_INTERP_ORDER; i++)
         {
-            double v, i_shifted = (double)i - (double)(SINC_INTERP_ORDER / 2.0) + (1 - x);
+            fluid_real_t v, i_shifted = ((fluid_real_t)i - (fluid_real_t)(SINC_INTERP_ORDER / 2.0 - 1.0)) - x;
 
             if (std::fabs(i_shifted) > 1e-6f)
             {
                 auto arg = FLUID_M_PI * i_shifted;
                 v = std::sin(arg) / arg;
                 /* Hanning window */
-                v *= 0.5 * (1.0 + std::cos(2.0 * arg / (double)SINC_INTERP_ORDER));
+                v *= 0.5f * (1.0f + std::cos(arg * (2.0f / (fluid_real_t)SINC_INTERP_ORDER)));
             }
             else
             {

From af093681c38c01b3361bc146f4c273a5c3dd5802 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Sun, 2 Aug 2026 13:40:03 +0200
Subject: [PATCH 10/34] Promote sinc to arbitrary order interpolation

---
 src/rvoice/fluid_rvoice_dsp.cpp | 296 ++++++++++++--------------------
 1 file changed, 107 insertions(+), 189 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index ffa7489c1..a43daef03 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -483,14 +483,22 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
     return (dsp_i);
 }
 
-/* 7th order interpolation.
+/* Nth order sinc interpolation (N = SINC_ORDER).
  * Returns number of samples processed (usually FLUID_BUFSIZE but could be
  * smaller if end of sample occurs).
+ *
+ * The filter kernel has:
+ *   half        = SINC_ORDER / 2  samples to the left of center
+ *   right_guard = SINC_ORDER - half - 1  samples to the right of center
+ * Guard arrays (start_points / end_points) supply the out-of-range samples
+ * needed at the beginning and end of the waveform / loop region.
  */
-template<bool IS_24BIT, bool LOOPING>
+template<bool IS_24BIT, bool LOOPING, int SINC_ORDER>
 static int
-fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_t *FLUID_RESTRICT dsp_buf)
+fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FLUID_RESTRICT dsp_buf)
 {
+    static_assert(SINC_ORDER >= 1, "SINC_ORDER must be at least 1");
+
     fluid_rvoice_dsp_t *voice = &rvoice->dsp;
     fluid_phase_t dsp_phase = voice->phase;
     fluid_phase_t dsp_phase_incr;
@@ -499,62 +507,65 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
     unsigned short dsp_i = 0;
     unsigned int dsp_phase_index;
     unsigned int start_index, end_index;
-    fluid_real_t start_points[3], end_points[3];
+
+    constexpr int half = SINC_ORDER / 2;
+    constexpr int right_guard = SINC_ORDER - half - 1;
+    /* Guard sample storage — sized to at least 1 to avoid zero-length arrays */
+    fluid_real_t start_points[half > 0 ? half : 1];
+    fluid_real_t end_points[right_guard > 0 ? right_guard : 1];
 
     /* Convert playback "speed" floating point value to phase index/fract */
     fluid_phase_set_float(dsp_phase_incr, voice->phase_incr);
 
-    /* add 1/2 sample to dsp_phase since 7th order interpolation is centered on
-     * the 4th sample point */
+    /* add 1/2 sample to dsp_phase since sinc interpolation is centered on
+     * the (half+1)-th sample point */
     fluid_phase_incr(dsp_phase, (fluid_phase_t)0x80000000);
 
-    /* last index before 7th interpolation point must be specially handled */
-    end_index = (LOOPING ? voice->loopend - 1 : voice->end) - 3;
+    /* last index before the right guard region must be specially handled */
+    end_index = (LOOPING ? voice->loopend - 1 : voice->end) - right_guard;
 
-    if(voice->has_looped)	/* set start_index and start point if looped or not */
+    if(voice->has_looped)   /* set start_index and start points if looped or not */
     {
         start_index = voice->loopstart;
-        start_points[0] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopend - 1);
-        start_points[1] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopend - 2);
-        start_points[2] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopend - 3);
+        for(int j = 0; j < half; j++)
+            start_points[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopend - 1 - j);
     }
     else
     {
         start_index = voice->start;
-        start_points[0] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->start);	/* just duplicate the start point */
-        start_points[1] = start_points[0];
-        start_points[2] = start_points[0];
+        /* duplicate the start point for all left guard positions */
+        for(int j = 0; j < half; j++)
+            start_points[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->start);
     }
 
-    /* get the 3 points off the end (loop start if looping, duplicate point if end) */
+    /* get the guard points off the end (loop start if looping, duplicate if end) */
     if(LOOPING)
     {
-        end_points[0] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopstart);
-        end_points[1] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopstart + 1);
-        end_points[2] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopstart + 2);
+        for(int j = 0; j < right_guard; j++)
+            end_points[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopstart + j);
     }
     else
     {
-        end_points[0] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->end);
-        end_points[1] = end_points[0];
-        end_points[2] = end_points[0];
+        for(int j = 0; j < right_guard; j++)
+            end_points[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->end);
     }
 
-    /* Lambda for cubic interpolation with parameterized samples */
-    auto interp_sinc = [&](std::array<fluid_real_t, FLUID_INTERP_7THORDER> s)
+    /* Compute windowed sinc interpolation coefficients and apply to sample array.
+     * The center tap is at position half in the array (s[half] == sample at dsp_phase_index). */
+    auto interp_sinc = [&](std::array<fluid_real_t, SINC_ORDER> s)
     {
         auto x = fluid_phase_fract(dsp_phase) * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
-        std::array<fluid_real_t, SINC_INTERP_ORDER> coeffs;
-        for (int i = 0; i < SINC_INTERP_ORDER; i++)
+        std::array<fluid_real_t, SINC_ORDER> coeffs;
+        for(int i = 0; i < SINC_ORDER; i++)
         {
-            fluid_real_t v, i_shifted = ((fluid_real_t)i - (fluid_real_t)(SINC_INTERP_ORDER / 2.0 - 1.0)) - x;
+            fluid_real_t v, i_shifted = ((fluid_real_t)i - (fluid_real_t)(SINC_ORDER / 2.0 - 1)) - x;
 
-            if (std::fabs(i_shifted) > 1e-6f)
+            if(std::fabs(i_shifted) > 1e-6f)
             {
                 auto arg = FLUID_M_PI * i_shifted;
                 v = std::sin(arg) / arg;
                 /* Hanning window */
-                v *= 0.5f * (1.0f + std::cos(arg * (2.0f / (fluid_real_t)SINC_INTERP_ORDER)));
+                v *= 0.5f * (1.0f + std::cos(arg * (2.0f / (fluid_real_t)SINC_ORDER)));
             }
             else
             {
@@ -564,103 +575,56 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
             coeffs[i] = v;
         }
 
-        return
-              coeffs[0] * s[0]
-            + coeffs[1] * s[1]
-            + coeffs[2] * s[2]
-            + coeffs[3] * s[3]
-            + coeffs[4] * s[4]
-            + coeffs[5] * s[5]
-            + coeffs[6] * s[6];
+        /* Normalize so coefficients always sum to 1.0, preventing amplitude
+         * modulation artifacts (harmonic distortion) as fractional phase varies */
+        fluid_real_t sum = 0;
+        for(int i = 0; i < SINC_ORDER; i++) sum += coeffs[i];
+        for(int i = 0; i < SINC_ORDER; i++) coeffs[i] /= sum;
+
+        fluid_real_t result = 0;
+        for(int i = 0; i < SINC_ORDER; i++) result += coeffs[i] * s[i];
+        return result;
     };
+
     while(1)
     {
         dsp_phase_index = fluid_phase_index(dsp_phase);
 
-        /* interpolate first sample point (start or loop start) if needed */
-        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, start_index, dsp_i);
-        for (; safe_count--; dsp_i++)
+        /* Interpolate the left guard region.
+         * For border step i (0-based), the leftmost (half-i) taps are drawn from
+         * start_points; the remaining taps read live sample data at offsets (j-half)
+         * relative to dsp_phase_index. start_index+i is the phase-index boundary. */
+        for(int i = 0; i < half; i++)
         {
-            fluid_real_t sample = interp_sinc({
-                start_points[2],
-                start_points[1],
-                start_points[0],
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 3)});
-
-            dsp_buf[dsp_i] = sample;
-
-            /* increment phase and amplitude */
-            fluid_phase_incr(dsp_phase, dsp_phase_incr);
-            dsp_phase_index = fluid_phase_index(dsp_phase);
-        }
-
-        start_index++;
-
-        /* interpolate 2nd to first sample point (start or loop start) if needed */
-        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, start_index, dsp_i);
-        for (; safe_count--; dsp_i++)
-        {
-            fluid_real_t sample = interp_sinc({
-                start_points[1],
-                start_points[0],
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 3)});
-
-            dsp_buf[dsp_i] = sample;
-
-            /* increment phase and amplitude */
-            fluid_phase_incr(dsp_phase, dsp_phase_incr);
-            dsp_phase_index = fluid_phase_index(dsp_phase);
-        }
-
-        start_index++;
-
-        /* interpolate 3rd to first sample point (start or loop start) if needed */
-        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, start_index, dsp_i);
-        for (; safe_count--; dsp_i++)
-        {
-            fluid_real_t sample = interp_sinc({
-                start_points[0],
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 3)});
-
-            dsp_buf[dsp_i] = sample;
-
-            /* increment phase and amplitude */
-            fluid_phase_incr(dsp_phase, dsp_phase_incr);
-            dsp_phase_index = fluid_phase_index(dsp_phase);
+            auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, start_index + i, dsp_i);
+            for(; safe_count--; dsp_i++)
+            {
+                std::array<fluid_real_t, SINC_ORDER> s;
+                for(int j = 0; j < SINC_ORDER; j++)
+                {
+                    if(j < half - i)
+                        s[j] = start_points[half - i - 1 - j];
+                    else
+                        s[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + (j - half));
+                }
+                dsp_buf[dsp_i] = interp_sinc(s);
+                fluid_phase_incr(dsp_phase, dsp_phase_incr);
+                dsp_phase_index = fluid_phase_index(dsp_phase);
+            }
         }
 
-        start_index -= 2;	/* set back to original start index */
-
-        /* interpolate the sequence of sample points */
-        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
-        for (; safe_count--; dsp_i++)
+        /* Interpolate the main body — all taps read from live sample data */
         {
-            fluid_real_t sample = interp_sinc({
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 3)});
-
-            dsp_buf[dsp_i] = sample;
-
-            /* increment phase and amplitude */
-            fluid_phase_incr(dsp_phase, dsp_phase_incr);
-            dsp_phase_index = fluid_phase_index(dsp_phase);
+            auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+            for(; safe_count--; dsp_i++)
+            {
+                std::array<fluid_real_t, SINC_ORDER> s;
+                for(int j = 0; j < SINC_ORDER; j++)
+                    s[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + (j - half));
+                dsp_buf[dsp_i] = interp_sinc(s);
+                fluid_phase_incr(dsp_phase, dsp_phase_incr);
+                dsp_phase_index = fluid_phase_index(dsp_phase);
+            }
         }
 
         /* break out if buffer filled */
@@ -669,70 +633,27 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
             break;
         }
 
-        end_index++;	/* we're now interpolating the 3rd to last point */
-
-        /* interpolate within 3rd to last point */
-        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
-        for (; safe_count--; dsp_i++)
-        {
-            fluid_real_t sample = interp_sinc({
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2),
-                end_points[0]});
-
-            dsp_buf[dsp_i] = sample;
-
-            /* increment phase and amplitude */
-            fluid_phase_incr(dsp_phase, dsp_phase_incr);
-            dsp_phase_index = fluid_phase_index(dsp_phase);
-        }
-
-        end_index++;	/* we're now interpolating the 2nd to last point */
-
-        /* interpolate within 2nd to last point */
-        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
-        for (; safe_count--; dsp_i++)
-        {
-            fluid_real_t sample = interp_sinc({
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
-                end_points[0],
-                end_points[1]});
-
-            dsp_buf[dsp_i] = sample;
-
-            /* increment phase and amplitude */
-            fluid_phase_incr(dsp_phase, dsp_phase_incr);
-            dsp_phase_index = fluid_phase_index(dsp_phase);
-        }
-
-        end_index++;	/* we're now interpolating the last point */
-
-        /* interpolate within last point */
-        safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
-        for (; safe_count--; dsp_i++)
+        /* Interpolate the right guard region.
+         * For border step e (0-based), the rightmost (e+1) taps are drawn from
+         * end_points; the remaining taps read live data at offsets (j-half)
+         * relative to dsp_phase_index. end_index+1+e is the phase-index boundary. */
+        for(int e = 0; e < right_guard; e++)
         {
-            fluid_real_t sample = interp_sinc({
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 3),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 2),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
-                end_points[0],
-                end_points[1],
-                end_points[2]});
-
-            dsp_buf[dsp_i] = sample;
-
-            /* increment phase and amplitude */
-            fluid_phase_incr(dsp_phase, dsp_phase_incr);
-            dsp_phase_index = fluid_phase_index(dsp_phase);
+            auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index + 1 + e, dsp_i);
+            for(; safe_count--; dsp_i++)
+            {
+                std::array<fluid_real_t, SINC_ORDER> s;
+                for(int j = 0; j < SINC_ORDER; j++)
+                {
+                    if(j < SINC_ORDER - e - 1)
+                        s[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + (j - half));
+                    else
+                        s[j] = end_points[j - (SINC_ORDER - e - 1)];
+                }
+                dsp_buf[dsp_i] = interp_sinc(s);
+                fluid_phase_incr(dsp_phase, dsp_phase_incr);
+                dsp_phase_index = fluid_phase_index(dsp_phase);
+            }
         }
 
         if(!LOOPING)
@@ -741,7 +662,7 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         }
 
         /* go back to loop start */
-        if(dsp_phase_index > end_index)
+        if(dsp_phase_index > end_index + right_guard)
         {
             fluid_phase_sub_int(dsp_phase, voice->loopend - voice->loopstart);
 
@@ -749,9 +670,8 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
             {
                 voice->has_looped = 1;
                 start_index = voice->loopstart;
-                start_points[0] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopend - 1);
-                start_points[1] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopend - 2);
-                start_points[2] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopend - 3);
+                for(int j = 0; j < half; j++)
+                    start_points[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopend - 1 - j);
             }
         }
 
@@ -760,12 +680,10 @@ fluid_rvoice_dsp_interpolate_7th_order_local(fluid_rvoice_t *rvoice, fluid_real_
         {
             break;
         }
-
-        end_index -= 3;	/* set end back to 4th to last sample point */
     }
 
-    /* sub 1/2 sample from dsp_phase since 7th order interpolation is centered on
-     * the 4th sample point (correct back to real value) */
+    /* sub 1/2 sample from dsp_phase since sinc interpolation is centered on
+     * the (half+1)-th sample point (correct back to real value) */
     fluid_phase_decr(dsp_phase, (fluid_phase_t)0x80000000);
 
     voice->phase = dsp_phase;
@@ -814,7 +732,7 @@ struct Interpolate7thOrder
     template<bool IS_24BIT, bool LOOPING>
     int operator()(fluid_rvoice_t *rvoice, fluid_real_t *FLUID_RESTRICT dsp_buf) const
     {
-        return fluid_rvoice_dsp_interpolate_7th_order_local<IS_24BIT, LOOPING>(rvoice, dsp_buf);
+        return fluid_rvoice_dsp_interpolate_sinc_local<IS_24BIT, LOOPING, 7>(rvoice, dsp_buf);
     }
 };
 

From 101ce84203ec87978dadeedf9dc0321f74abb422 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Sun, 2 Aug 2026 14:02:11 +0200
Subject: [PATCH 11/34] factor out sum

---
 src/rvoice/fluid_rvoice_dsp.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index a43daef03..3ae559c6e 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -556,6 +556,7 @@ fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
     {
         auto x = fluid_phase_fract(dsp_phase) * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
         std::array<fluid_real_t, SINC_ORDER> coeffs;
+        fluid_real_t sum = 0;
         for(int i = 0; i < SINC_ORDER; i++)
         {
             fluid_real_t v, i_shifted = ((fluid_real_t)i - (fluid_real_t)(SINC_ORDER / 2.0 - 1)) - x;
@@ -573,12 +574,11 @@ fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
             }
 
             coeffs[i] = v;
+            sum += v;
         }
 
-        /* Normalize so coefficients always sum to 1.0, preventing amplitude
+        /* Normalize, so coefficients always sum to 1.0, preventing amplitude
          * modulation artifacts (harmonic distortion) as fractional phase varies */
-        fluid_real_t sum = 0;
-        for(int i = 0; i < SINC_ORDER; i++) sum += coeffs[i];
         for(int i = 0; i < SINC_ORDER; i++) coeffs[i] /= sum;
 
         fluid_real_t result = 0;

From 4a3be22cdfbf23a3a1b8edc6b0c3998828b406a5 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Mon, 3 Aug 2026 12:47:18 +0200
Subject: [PATCH 12/34] Output interpolation test at 48khz and 24bit

---
 test/CMakeLists.txt | 2 +-
 test/manual         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 841171c4f..8ed5c8d0e 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -369,7 +369,7 @@ if(NOT CMAKE_GENERATOR MATCHES "Visual Studio")
     endforeach()
 
     add_custom_target(renderdspInterp
-        COMMAND ${MANUAL_TEST_FLUIDSYNTH} -R 0 -C 0 -g 0.6 -F "${DSPINTERP_RENDER_DIR}/sample interpolation test.${FEXT}" "sample interpolation test.mid" "sample interpolation test.sf2"
+        COMMAND ${MANUAL_TEST_FLUIDSYNTH} -R 0 -C 0 -g 0.6 -o audio.file.format=s24 -o audio.file.type=flac -r 48000 -F "${DSPINTERP_RENDER_DIR}/sample interpolation test.flac" "sample interpolation test.mid" "sample interpolation test.sf2"
         COMMENT "Rendering Interpolation examples"
         DEPENDS ${MANUAL_TEST_DEPENDS} create_out_dir
         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/manual/dsp_interp/
diff --git a/test/manual b/test/manual
index b491dccc5..46d865887 160000
--- a/test/manual
+++ b/test/manual
@@ -1 +1 @@
-Subproject commit b491dccc55aaeb23a9016a79b5583fd27d01857b
+Subproject commit 46d8658875b3fbe755df67c3307ad56619419287

From c24b0888424612d3c06b33d6e4d1910c6d8c340c Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Mon, 3 Aug 2026 13:06:39 +0200
Subject: [PATCH 13/34] Use Chris' upstream interpolation test

---
 test/CMakeLists.txt | 2 +-
 test/manual         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 8ed5c8d0e..377532d99 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -372,7 +372,7 @@ if(NOT CMAKE_GENERATOR MATCHES "Visual Studio")
         COMMAND ${MANUAL_TEST_FLUIDSYNTH} -R 0 -C 0 -g 0.6 -o audio.file.format=s24 -o audio.file.type=flac -r 48000 -F "${DSPINTERP_RENDER_DIR}/sample interpolation test.flac" "sample interpolation test.mid" "sample interpolation test.sf2"
         COMMENT "Rendering Interpolation examples"
         DEPENDS ${MANUAL_TEST_DEPENDS} create_out_dir
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/manual/dsp_interp/
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/manual/SoundFont-Spec-Test/sample interpolation test/"
         VERBATIM
     )
 
diff --git a/test/manual b/test/manual
index 46d865887..6ad367ad9 160000
--- a/test/manual
+++ b/test/manual
@@ -1 +1 @@
-Subproject commit 46d8658875b3fbe755df67c3307ad56619419287
+Subproject commit 6ad367ad9f80e1b2981a373c3fc1683390961373

From 05431b0c136062e3b6da30e96f7150d74c0a3491 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Mon, 3 Aug 2026 16:50:36 +0200
Subject: [PATCH 14/34] make odd orders sound better

---
 src/rvoice/fluid_rvoice_dsp.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index 3ae559c6e..29858dff1 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -554,12 +554,13 @@ fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
      * The center tap is at position half in the array (s[half] == sample at dsp_phase_index). */
     auto interp_sinc = [&](std::array<fluid_real_t, SINC_ORDER> s)
     {
-        auto x = fluid_phase_fract(dsp_phase) * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
+        const auto x = fluid_phase_fract(dsp_phase) * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
+        const auto center = (fluid_real_t)half - 0.5f + x; // == half + (x - 0.5)
         std::array<fluid_real_t, SINC_ORDER> coeffs;
         fluid_real_t sum = 0;
         for(int i = 0; i < SINC_ORDER; i++)
         {
-            fluid_real_t v, i_shifted = ((fluid_real_t)i - (fluid_real_t)(SINC_ORDER / 2.0 - 1)) - x;
+            fluid_real_t v, i_shifted = (fluid_real_t)i - center;
 
             if(std::fabs(i_shifted) > 1e-6f)
             {

From edd2d9c7f56987affa7ad74733725f42967c69e0 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Mon, 3 Aug 2026 17:01:07 +0200
Subject: [PATCH 15/34] Revert "make odd orders sound better"

This reverts commit 05431b0c136062e3b6da30e96f7150d74c0a3491.
---
 src/rvoice/fluid_rvoice_dsp.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index 29858dff1..3ae559c6e 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -554,13 +554,12 @@ fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
      * The center tap is at position half in the array (s[half] == sample at dsp_phase_index). */
     auto interp_sinc = [&](std::array<fluid_real_t, SINC_ORDER> s)
     {
-        const auto x = fluid_phase_fract(dsp_phase) * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
-        const auto center = (fluid_real_t)half - 0.5f + x; // == half + (x - 0.5)
+        auto x = fluid_phase_fract(dsp_phase) * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
         std::array<fluid_real_t, SINC_ORDER> coeffs;
         fluid_real_t sum = 0;
         for(int i = 0; i < SINC_ORDER; i++)
         {
-            fluid_real_t v, i_shifted = (fluid_real_t)i - center;
+            fluid_real_t v, i_shifted = ((fluid_real_t)i - (fluid_real_t)(SINC_ORDER / 2.0 - 1)) - x;
 
             if(std::fabs(i_shifted) > 1e-6f)
             {

From ae3eb97018d1a63cbbc32f887238a2419c399ed7 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Mon, 3 Aug 2026 20:20:04 +0200
Subject: [PATCH 16/34] fix sinc interpolation of odd orders being worse than
 even orders

---
 src/rvoice/fluid_rvoice_dsp.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index 3ae559c6e..fb9d4c108 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -554,12 +554,16 @@ fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
      * The center tap is at position half in the array (s[half] == sample at dsp_phase_index). */
     auto interp_sinc = [&](std::array<fluid_real_t, SINC_ORDER> s)
     {
-        auto x = fluid_phase_fract(dsp_phase) * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
+        const auto x = fluid_phase_fract(dsp_phase) * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
+        const auto center = (SINC_ORDER % 2 == 0)
+        ? (fluid_real_t)(half - 1) + x // == half + (x - 1)
+        : (fluid_real_t)half - 0.5f + x; // == half + (x - 0.5f)
+
         std::array<fluid_real_t, SINC_ORDER> coeffs;
         fluid_real_t sum = 0;
         for(int i = 0; i < SINC_ORDER; i++)
         {
-            fluid_real_t v, i_shifted = ((fluid_real_t)i - (fluid_real_t)(SINC_ORDER / 2.0 - 1)) - x;
+            fluid_real_t v, i_shifted = (fluid_real_t)i - center;
 
             if(std::fabs(i_shifted) > 1e-6f)
             {

From 998dbbd8d75f1bddaf3386e7638febfd8dbf66ad Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Mon, 3 Aug 2026 22:23:05 +0200
Subject: [PATCH 17/34] Less expensive hanning window

---
 src/rvoice/fluid_rvoice_dsp.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index fb9d4c108..8dfaa730a 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -570,7 +570,9 @@ fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
                 auto arg = FLUID_M_PI * i_shifted;
                 v = std::sin(arg) / arg;
                 /* Hanning window */
-                v *= 0.5f * (1.0f + std::cos(arg * (2.0f / (fluid_real_t)SINC_ORDER)));
+                // 0.5f * (1.0f + std::cos(arg * (fluid_real_t)(2.0 / SINC_ORDER)));
+                auto wnd = std::cos(arg / SINC_ORDER);
+                v *= wnd * wnd;
             }
             else
             {

From ad0e139f18835b49c92e2e6930120d120801f251 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Mon, 3 Aug 2026 23:09:45 +0200
Subject: [PATCH 18/34] Unit test for finally getting center position right

---
 src/rvoice/fluid_rvoice_dsp.cpp      |  37 +------
 src/rvoice/fluid_rvoice_dsp_sinc.hpp |  95 ++++++++++++++++++
 test/test_rvoice_dsp_interpolate.cpp | 140 +++++++++++++++++++++++++++
 3 files changed, 237 insertions(+), 35 deletions(-)
 create mode 100644 src/rvoice/fluid_rvoice_dsp_sinc.hpp

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index 8dfaa730a..717b471d5 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -26,6 +26,7 @@
 #include <algorithm>
 #include <array>
 #include <cmath>
+#include "fluid_rvoice_dsp_sinc.hpp"
 
 /* Purpose:
  *
@@ -555,41 +556,7 @@ fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
     auto interp_sinc = [&](std::array<fluid_real_t, SINC_ORDER> s)
     {
         const auto x = fluid_phase_fract(dsp_phase) * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
-        const auto center = (SINC_ORDER % 2 == 0)
-        ? (fluid_real_t)(half - 1) + x // == half + (x - 1)
-        : (fluid_real_t)half - 0.5f + x; // == half + (x - 0.5f)
-
-        std::array<fluid_real_t, SINC_ORDER> coeffs;
-        fluid_real_t sum = 0;
-        for(int i = 0; i < SINC_ORDER; i++)
-        {
-            fluid_real_t v, i_shifted = (fluid_real_t)i - center;
-
-            if(std::fabs(i_shifted) > 1e-6f)
-            {
-                auto arg = FLUID_M_PI * i_shifted;
-                v = std::sin(arg) / arg;
-                /* Hanning window */
-                // 0.5f * (1.0f + std::cos(arg * (fluid_real_t)(2.0 / SINC_ORDER)));
-                auto wnd = std::cos(arg / SINC_ORDER);
-                v *= wnd * wnd;
-            }
-            else
-            {
-                v = 1.0;
-            }
-
-            coeffs[i] = v;
-            sum += v;
-        }
-
-        /* Normalize, so coefficients always sum to 1.0, preventing amplitude
-         * modulation artifacts (harmonic distortion) as fractional phase varies */
-        for(int i = 0; i < SINC_ORDER; i++) coeffs[i] /= sum;
-
-        fluid_real_t result = 0;
-        for(int i = 0; i < SINC_ORDER; i++) result += coeffs[i] * s[i];
-        return result;
+        return fluid_interp_sinc_kernel<SINC_ORDER>(s, x);
     };
 
     while(1)
diff --git a/src/rvoice/fluid_rvoice_dsp_sinc.hpp b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
new file mode 100644
index 000000000..ad8686c46
--- /dev/null
+++ b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
@@ -0,0 +1,95 @@
+/* FluidSynth - A Software Synthesizer
+ *
+ * Copyright (C) 2003  Peter Hanappe and others.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see
+ * <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "fluid_sys.h"
+#include <array>
+#include <cmath>
+
+/**
+ * Normalized windowed-sinc interpolation kernel of order SINC_ORDER.
+ *
+ * The caller fills an array s[] of SINC_ORDER samples where:
+ *   s[j] == waveform[ dsp_phase_index + (j - half) ]
+ *   half == SINC_ORDER / 2
+ *
+ * @param s  Input sample array of length SINC_ORDER.
+ * @param x  Fractional phase in [0, 1).  This is the raw fractional part of
+ *           dsp_phase *after* the +0.5-sample advance applied by
+ *           fluid_rvoice_dsp_interpolate_sinc_local().  The true playback
+ *           position within s[] is therefore:
+ *
+ *               center = half + (x - 0.5)  =  half - 0.5 + x
+ *
+ *           When x == 0.5 the center falls exactly on s[half], so
+ *           fluid_interp_sinc_kernel returns s[half] unmodified (sinc(0) = 1,
+ *           sinc(n*pi) = 0 for all non-zero integers n).
+ *
+ * This formula is correct for both odd and even SINC_ORDER.  For odd order
+ * (e.g. N=7, half=3) the center moves across the half-open range [half-0.5,
+ * half+0.5), i.e. it is always within 0.5 taps of s[half].  For even order
+ * (e.g. N=8, half=4) exactly the same arithmetic applies — there is no
+ * reason to shift the center by an additional -0.5 tap.
+ */
+template<int SINC_ORDER>
+static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_t, SINC_ORDER>& s, fluid_real_t x)
+{
+    static_assert(SINC_ORDER >= 1 && SINC_ORDER != 2, "SINC_ORDER must be at least 1 and not equal to 2");
+
+    constexpr int half = SINC_ORDER / 2;
+
+    /* The +0.5-sample phase advance means the true position within s[] is
+     * half + (x - 0.5) = half - 0.5 + x for all orders (odd and even). */
+    const auto center = (fluid_real_t)(half - 0.5f) + x; // == half + (x - 0.5f)
+
+    std::array<fluid_real_t, SINC_ORDER> coeffs;
+    fluid_real_t sum = 0.0f;
+
+    for(int i = 0; i < SINC_ORDER; i++)
+    {
+        fluid_real_t v;
+        const fluid_real_t i_shifted = (fluid_real_t)i - center;
+
+        if(std::fabs(i_shifted) > 1e-6f)
+        {
+            const fluid_real_t arg = FLUID_M_PI * i_shifted;
+            v = std::sin(arg) / arg;
+            /* Hanning window: */
+            // 0.5f * (1.0f + std::cos(arg * (fluid_real_t)(2.0 / SINC_ORDER))) == cos²(arg / SINC_ORDER)
+            const fluid_real_t wnd = std::cos(arg / SINC_ORDER);
+            v *= wnd * wnd;
+        }
+        else
+        {
+            v = 1.0f;
+        }
+
+        coeffs[i] = v;
+        sum += v;
+    }
+
+    /* Normalize so coefficients always sum to 1.0, preventing amplitude
+     * modulation artifacts (harmonic distortion) as fractional phase varies. */
+    for(int i = 0; i < SINC_ORDER; i++) coeffs[i] /= sum;
+
+    fluid_real_t result = 0.0f;
+    for(int i = 0; i < SINC_ORDER; i++) result += coeffs[i] * s[i];
+    return result;
+}
diff --git a/test/test_rvoice_dsp_interpolate.cpp b/test/test_rvoice_dsp_interpolate.cpp
index 367bb0c62..c91dc5f0b 100644
--- a/test/test_rvoice_dsp_interpolate.cpp
+++ b/test/test_rvoice_dsp_interpolate.cpp
@@ -20,6 +20,7 @@
 #include "test.h"
 #include "rvoice/fluid_rvoice.h"
 #include "rvoice/fluid_rvoice_dsp_tables.h"
+#include "rvoice/fluid_rvoice_dsp_sinc.hpp"
 #include "sfloader/fluid_sfont.h"
 
 #include <cstring>
@@ -866,6 +867,142 @@ static void test_K_end_of_sample(void)
     }
 }
 
+/* =========================================================================
+ * Test L – Sinc kernel centering
+ *
+ * Directly exercises fluid_interp_sinc_kernel<N>() to verify that the center
+ * position is computed correctly for both odd and even SINC_ORDERs.
+ *
+ * Core property exploited:
+ *   After the +0.5 phase advance in the DSP loop, x = fract(phase) = 0.5
+ *   means the true playback position falls exactly on s[half].  For a unit
+ *   impulse at s[half] the kernel must therefore return exactly 1.0:
+ *     sinc(0) = 1,  sinc(n*pi) = 0  for all non-zero integers n.
+ *
+ *   Any systematic half-sample shift in the center formula places the kernel
+ *   peak between e.g. s[half-1] and s[half], breaks this property.
+ *
+ * Sub-tests per order:
+ *   L1 – Unit impulse at s[half], x=0.5  →  result == 1.0
+ *   L2 – Unit impulse, x=0.0              →  result < 1.0  (sanity: non-trivial)
+ *   L3 – Constant (DC) input              →  result == DC for any x  (unity gain)
+ *   L4 – Impulse at s[half], sweep x      →  peak is at x=0.5, not elsewhere
+ * ========================================================================= */
+template<int N>
+static void test_L_order()
+{
+    constexpr int half = N / 2;
+
+    /* L1: unit impulse at s[half], x=0.5 must give 1.0 */
+    {
+        std::array<fluid_real_t, N> s;
+        s.fill(0.0f);
+        s[half] = 1.0f;
+        fluid_real_t result = fluid_interp_sinc_kernel<N>(s, 0.5f);
+        fluid_real_t diff = std::fabs(result - 1.0f);
+        if(diff > (fluid_real_t)1e-5)
+        {
+            fprintf(stderr, "FAIL L1 (order=%d): impulse@s[%d] x=0.5 -> %.8f (expected 1.0, diff=%.2e)\n",
+                    N, half, (double)result, (double)diff);
+            TEST_ASSERT(0);
+        }
+        printf("    L1 (order=%d) impulse@s[half] x=0.5: PASS (result=%.8f)\n", N, (double)result);
+    }
+
+    /* L2: same impulse at x=0.0 must give something < 1.0 (non-trivial kernel) */
+    if(N > 1)
+    {
+        std::array<fluid_real_t, N> s;
+        s.fill(0.0f);
+        s[half] = 1.0f;
+        fluid_real_t result = fluid_interp_sinc_kernel<N>(s, 0.0f);
+        if(result >= 1.0f - (fluid_real_t)1e-5)
+        {
+            fprintf(stderr, "FAIL L2 (order=%d): kernel appears trivial at x=0.0 (result=%.8f)\n",
+                    N, (double)result);
+            TEST_ASSERT(0);
+        }
+        printf("    L2 (order=%d) impulse@s[half] x=0.0: PASS (result=%.8f, confirms non-trivial)\n",
+               N, (double)result);
+    }
+
+    /* L3: constant (DC) input must reproduce the constant for all x */
+    {
+        const fluid_real_t DC = 12345.0f;
+        std::array<fluid_real_t, N> s;
+        s.fill(DC);
+        const float x_vals[] = { 0.0f, 0.1f, 0.25f, 0.5f, 0.75f, 0.9f, 0.999f };
+        for(float xv : x_vals)
+        {
+            fluid_real_t result = fluid_interp_sinc_kernel<N>(s, (fluid_real_t)xv);
+            fluid_real_t diff = std::fabs(result - DC);
+            if(diff > (fluid_real_t)1e-2 * DC)
+            {
+                fprintf(stderr, "FAIL L3 (order=%d): DC x=%.3f -> %.1f (expected %.1f, diff=%.2e)\n",
+                        N, (double)xv, (double)result, (double)DC, (double)diff);
+                TEST_ASSERT(0);
+            }
+        }
+        printf("    L3 (order=%d) DC gain: PASS\n", N);
+    }
+
+    /* L4: sweep x in [0, 1) — the peak response to an impulse at s[half]
+     * must occur at x=0.5, not at any other tabulated position. */
+    {
+        std::array<fluid_real_t, N> s;
+        s.fill(0.0f);
+        s[half] = 1.0f;
+
+        const fluid_real_t peak = fluid_interp_sinc_kernel<N>(s, 0.5f);
+        bool found_higher = false;
+        for(int step = 0; step <= 100; step++)
+        {
+            float xv = step / 100.0f;
+            if(xv >= 1.0f) xv = 0.999f;
+            fluid_real_t v = fluid_interp_sinc_kernel<N>(s, (fluid_real_t)xv);
+            if(v > peak + (fluid_real_t)1e-5)
+            {
+                fprintf(stderr, "FAIL L4 (order=%d): peak not at x=0.5 "
+                        "(x=%.3f gives %.8f > peak %.8f)\n",
+                        N, (double)xv, (double)v, (double)peak);
+                found_higher = true;
+            }
+        }
+        TEST_ASSERT(!found_higher);
+        printf("    L4 (order=%d) peak at x=0.5: PASS\n", N);
+    }
+}
+
+static void test_L_sinc_kernel_centering(void)
+{
+    printf("Test L: Sinc kernel centering\n");
+    printf("  Odd orders:\n");
+    test_L_order<1>();
+    test_L_order<3>();
+    test_L_order<5>();
+    test_L_order<7>();
+    test_L_order<9>();
+    test_L_order<11>();
+    test_L_order<13>();
+    test_L_order<15>();
+    test_L_order<17>();
+    test_L_order<19>();
+    printf("  Even orders:\n");
+    /* N=2 is omitted: with only 2 taps the windowed-sinc degenerates into a
+     * near-linear extrapolator whose normalized coefficients overshoot for
+     * x > 0.5.  This is a property of the kernel shape (not a centering
+     * bug) and N=2 is not a realistic interpolation order. */
+    test_L_order<4>();
+    test_L_order<6>();
+    test_L_order<8>();
+    test_L_order<10>();
+    test_L_order<12>();
+    test_L_order<14>();
+    test_L_order<16>();
+    test_L_order<18>();
+    test_L_order<20>();
+}
+
 /* ========================================================================= */
 
 int main(void)
@@ -906,6 +1043,9 @@ int main(void)
     test_K_end_of_sample();
     printf("\n");
 
+    test_L_sinc_kernel_centering();
+    printf("\n");
+
     printf("========================================\n");
     printf("All tests PASSED\n");
 

From 057cdf8fd2a1bf64aacb91e703fb3bec95c50a2e Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Tue, 4 Aug 2026 09:32:09 +0200
Subject: [PATCH 19/34] Use phase when calculating sample shift for sinc kernel

---
 src/rvoice/fluid_rvoice_dsp.cpp      |  3 +--
 src/rvoice/fluid_rvoice_dsp_sinc.hpp | 37 +++++++++++++++++++++++-----
 2 files changed, 32 insertions(+), 8 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index 717b471d5..497deda8a 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -555,8 +555,7 @@ fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
      * The center tap is at position half in the array (s[half] == sample at dsp_phase_index). */
     auto interp_sinc = [&](std::array<fluid_real_t, SINC_ORDER> s)
     {
-        const auto x = fluid_phase_fract(dsp_phase) * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
-        return fluid_interp_sinc_kernel<SINC_ORDER>(s, x);
+        return fluid_interp_sinc_kernel<SINC_ORDER>(s, fluid_phase_fract(dsp_phase));
     };
 
     while(1)
diff --git a/src/rvoice/fluid_rvoice_dsp_sinc.hpp b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
index ad8686c46..6aee9bcf7 100644
--- a/src/rvoice/fluid_rvoice_dsp_sinc.hpp
+++ b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
@@ -49,15 +49,26 @@
  * reason to shift the center by an additional -0.5 tap.
  */
 template<int SINC_ORDER>
-static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_t, SINC_ORDER>& s, fluid_real_t x)
+static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_t, SINC_ORDER>& s, uint32_t phase_fract)
 {
     static_assert(SINC_ORDER >= 1 && SINC_ORDER != 2, "SINC_ORDER must be at least 1 and not equal to 2");
 
     constexpr int half = SINC_ORDER / 2;
 
     /* The +0.5-sample phase advance means the true position within s[] is
-     * half + (x - 0.5) = half - 0.5 + x for all orders (odd and even). */
-    const auto center = (fluid_real_t)(half - 0.5f) + x; // == half + (x - 0.5f)
+     * half + (x - 0.5) = half - 0.5 + x for all orders (odd and even).
+     * The subtraction (phase_fract - 0x80000000) is intentionally done as a
+     * SIGNED 32-bit difference and then sign-extended to 64-bit: when
+     * phase_fract < 0x80000000 (original frac >= 0.5) the
+     * result is negative, which lowers center's integer part by 1 and places
+     * the kernel correctly between the tap *before* dsp_phase_index and
+     * dsp_phase_index itself.  Using plain uint32 subtraction would wrap to a
+     * large positive value and shift the center 1 sample too far right.
+     * Note that the sign extension i.e. from uint32 difference to int32
+     * technically invokes implementation defined behavior - only since C++20
+     * it's well defined to be performed in twos-complement.
+     */
+    const auto center = fluid_phase_from_index_fract(half, (int64_t)(int32_t)(phase_fract - (uint32_t)0x80000000u)); // == half + (x - 0.5f)
 
     std::array<fluid_real_t, SINC_ORDER> coeffs;
     fluid_real_t sum = 0.0f;
@@ -65,11 +76,16 @@ static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_
     for(int i = 0; i < SINC_ORDER; i++)
     {
         fluid_real_t v;
-        const fluid_real_t i_shifted = (fluid_real_t)i - center;
+        fluid_phase_t i_shifted;
+        fluid_phase_set_int(i_shifted, i);
 
-        if(std::fabs(i_shifted) > 1e-6f)
+        // if i_shifted < center, the result will be negative
+        fluid_phase_decr(i_shifted, center);
+        // sacrifize the upper 2^31 values (we will never get there even close) by interpreting i_shifted as signed integer to correctly account for negative values
+        fluid_real_t i_shifted_f = (int64_t)i_shifted * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
+        if(std::fabs(i_shifted_f) > 1e-6f)
         {
-            const fluid_real_t arg = FLUID_M_PI * i_shifted;
+            const fluid_real_t arg = FLUID_M_PI * i_shifted_f;
             v = std::sin(arg) / arg;
             /* Hanning window: */
             // 0.5f * (1.0f + std::cos(arg * (fluid_real_t)(2.0 / SINC_ORDER))) == cos²(arg / SINC_ORDER)
@@ -93,3 +109,12 @@ static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_
     for(int i = 0; i < SINC_ORDER; i++) result += coeffs[i] * s[i];
     return result;
 }
+
+
+template<int SINC_ORDER>
+static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_t, SINC_ORDER>& s, fluid_real_t x)
+{
+    fluid_phase_t dsp_phase;
+    fluid_phase_set_float(dsp_phase, x);
+    return fluid_interp_sinc_kernel(s, fluid_phase_fract(dsp_phase));
+}
\ No newline at end of file

From 6f96e796c21a70c530cf7e8eb5414e55fe7f4f49 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Tue, 4 Aug 2026 16:54:54 +0200
Subject: [PATCH 20/34] Add a sine interpolation test

---
 test/test_rvoice_dsp_interpolate.cpp | 190 +++++++++++++++++++++++++++
 1 file changed, 190 insertions(+)

diff --git a/test/test_rvoice_dsp_interpolate.cpp b/test/test_rvoice_dsp_interpolate.cpp
index c91dc5f0b..f7e352d6b 100644
--- a/test/test_rvoice_dsp_interpolate.cpp
+++ b/test/test_rvoice_dsp_interpolate.cpp
@@ -18,6 +18,7 @@
 #define NOMINMAX
 
 #include "test.h"
+#include "Wave_Sine_093.h"
 #include "rvoice/fluid_rvoice.h"
 #include "rvoice/fluid_rvoice_dsp_tables.h"
 #include "rvoice/fluid_rvoice_dsp_sinc.hpp"
@@ -1003,6 +1004,192 @@ static void test_L_sinc_kernel_centering(void)
     test_L_order<20>();
 }
 
+/**
+ * Fit  y(p) = A * sin(2π·p/loop_len + φ)  to samples[loop_start .. loop_start+loop_len-1].
+ *
+ * Uses the DFT identity for a single frequency:
+ *   B = (2/N) Σ y[p] sin(ω·p),  C = (2/N) Σ y[p] cos(ω·p)
+ *   A = √(B²+C²),  φ = atan2(C, B)
+ *
+ * This is an exact LSQ fit when the data contains exactly one period.
+ */
+static void sine_fit_loop(const short* samples, int loop_start, int loop_len,
+                          double* out_A, double* out_phi)
+{
+    const double omega = 2.0 * M_PI / loop_len;
+    double B = 0.0, C = 0.0;
+    for (int p = 0; p < loop_len; p++)
+    {
+        double s = (double)samples[loop_start + p];
+        B += s * std::sin(omega * p);
+        C += s * std::cos(omega * p);
+    }
+    B *= 2.0 / loop_len;
+    C *= 2.0 / loop_len;
+    *out_A   = std::sqrt(B * B + C * C);
+    *out_phi = std::atan2(C, B);
+}
+
+/* =========================================================================
+ * Test M – Sine wave interpolation (Wave_Sine_093.h)
+ *
+ * The sample data is a real 44 kHz, 16-bit sine wave with a forward loop
+ * spanning samples 38–62 inclusive (25 samples = one period).
+ *
+ * M1: Constant phase_incr = 1.0 (1:1 playback) across 3 buffer calls.
+ *     At every integer phase position the DSP output must equal the stored
+ *     sample value, exercising loop wrap-around across all four modes.
+ *
+ * M2: Phase ramp (pitch sweep) — phase_incr steps from 1.0 to 2.0 in 11
+ *     calls of 0.1 each, simulating a one-octave upward glide.  Each output
+ *     sample is compared against a procedurally computed sine whose
+ *     amplitude and phase are determined by a least-squares fit to the loop
+ *     region.
+ * ========================================================================= */
+static void test_M_sine_wave_interpolation(void)
+{
+    printf("Test M: Sine wave interpolation (Wave_Sine_093)\n");
+
+    /* Audio data from Wave_Sine_093.h (wave_sine_093[71]).
+     * Copy to a short[] buffer accepted by the DSP helpers. */
+    constexpr int SINE_N        = 71;
+    constexpr int SINE_LS       = (int)AUDIO_SAMPLES_LOOP0_START;      /* 38, inclusive */
+    constexpr int SINE_LE       = (int)AUDIO_SAMPLES_LOOP0_END + 1;    /* 63, exclusive */
+    constexpr int SINE_LOOP_LEN = SINE_LE - SINE_LS;                   /* 25            */
+
+    std::array<short, SINE_N> data;
+    for (int i = 0; i < SINE_N; i++)
+        data[i] = (short)wave_sine_093[i];
+
+    /* Least-squares sine fit to the loop region (used by M2). */
+    double sine_A, sine_phi;
+    sine_fit_loop(wave_sine_093, SINE_LS, SINE_LOOP_LEN, &sine_A, &sine_phi);
+    const double sine_omega = 2.0 * M_PI / SINE_LOOP_LEN;
+    printf("  Fitted sine: A=%.1f  phi=%.4f rad\n", sine_A, sine_phi);
+
+    /* ---- M1: Constant phase_incr = 1.0 --------------------------------- */
+    printf("  M1: Constant phase_incr=1.0, 3 buffer iterations (all modes)\n");
+    {
+        constexpr const std::array<fluid_interp, 4> modes = { FLUID_INTERP_NONE,
+                                       FLUID_INTERP_LINEAR,
+                                       FLUID_INTERP_4THORDER,
+                                       FLUID_INTERP_7THORDER };
+
+        for (size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
+        {
+            fluid_rvoice_t rvoice;
+            fluid_sample_t samp;
+
+            /* Loop starts at index 38.  The widest stencil (7th-order) needs
+             * data[n-3] .. data[n+4].  At n=38 that is data[35..42], all
+             * within the 71-element array, so we can start all modes at
+             * loop_start without any additional offset. */
+            const double start = (double)SINE_LS;
+
+            setup_rvoice(&rvoice, &samp, data.data(), /*data24=*/nullptr,
+                start, /*phase_incr=*/1.0,
+                /*start=*/0, /*end=*/SINE_N - 1,
+                SINE_LS, SINE_LE,
+                /*has_looped=*/1, modes[m]);
+
+            /* At integer-only positions the tolerance for 7th-order is the
+             * tighter "integer phase" value; other modes use TOL_POLY. */
+            const fluid_real_t tol = get_tolerance(modes[m], /*fractional=*/false);
+
+            double shadow = start;   /* mirrors the DSP phase (integer positions only) */
+            int total = 0;
+
+            for (int iter = 0; iter < 3; iter++)
+            {
+                std::array<fluid_real_t, FLUID_BUFSIZE> buf;
+                buf.fill(0);
+
+                int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), /*is_looping=*/1);
+                TEST_ASSERT(count == FLUID_BUFSIZE);
+
+                for (int i = 0; i < count; i++)
+                {
+                    /* shadow is always an integer value; map it into the loop. */
+                    int idx = (int)shadow;
+                    while (idx >= SINE_LE) idx -= SINE_LOOP_LEN;
+
+                    test_sample_eq(buf[i], (fluid_real_t)data[idx], tol, total + i);
+
+                    shadow += 1.0;
+                    if (shadow >= SINE_LE) shadow -= SINE_LOOP_LEN;
+                }
+                total += count;
+            }
+            printf("    %s: PASS (%d samples verified)\n", interp_name(modes[m]), total);
+        }
+    }
+
+    /* ---- M2: Phase ramp — pitch sweep 1.0x -> 2.0x --------------------- */
+    printf("  M2: Phase ramp (phase_incr 1.0 -> 2.0 in 11 buffer calls)\n");
+    {
+        /* Tolerance budget (in original sample units, before DSP scaling):
+         *
+         *   Fit residuals    (data != perfect sine) : ≈  100 counts
+         *   LINEAR error     A·(1-cos(ω/2))        : ≈  244 counts  → total 400
+         *   4TH ORDER error  (very small)           : <   10 counts  → total 200
+         *   7TH ORDER error  (incl. table quant.)   : <   20 counts  → total 200
+         *
+         * All modes get a little extra headroom to keep the test robust. */
+        struct { fluid_interp mode; fluid_real_t tol; } tests[] = {
+            { FLUID_INTERP_LINEAR,    (fluid_real_t)400.0 },
+            { FLUID_INTERP_4THORDER,  (fluid_real_t)200.0 },
+            { FLUID_INTERP_7THORDER,  (fluid_real_t)200.0 },
+        };
+
+        for (size_t m = 0; m < FLUID_N_ELEMENTS(tests); m++)
+        {
+            fluid_rvoice_t rvoice;
+            fluid_sample_t samp;
+
+            const double start = (double)SINE_LS;
+
+            setup_rvoice(&rvoice, &samp, data.data(), /*data24=*/nullptr,
+                start, /*phase_incr=*/1.0,
+                /*start=*/0, /*end=*/SINE_N - 1,
+                SINE_LS, SINE_LE,
+                /*has_looped=*/1, tests[m].mode);
+
+            /* shadow tracks the exact fractional loop position consumed by
+             * each output sample, mirroring the DSP phase accumulator. */
+            double shadow = start;
+            int total = 0;
+
+            for (int step = 0; step <= 10; step++)
+            {
+                const double incr = 1.0 + step * 0.1;
+                rvoice.dsp.phase_incr = (fluid_real_t)incr;
+
+                std::array<fluid_real_t, FLUID_BUFSIZE> buf;
+                buf.fill(0);
+
+                int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), /*is_looping=*/1);
+                TEST_ASSERT(count == FLUID_BUFSIZE);
+
+                for (int i = 0; i < count; i++)
+                {
+                    /* Fractional position within the loop (0-based). */
+                    const double loop_pos = shadow - SINE_LS;
+                    const double expected = sine_A * std::sin(sine_omega * loop_pos + sine_phi);
+
+                    test_sample_eq(buf[i], (fluid_real_t)expected, tests[m].tol, total + i);
+
+                    /* Advance and wrap shadow to match DSP behaviour. */
+                    shadow += incr;
+                    if (shadow >= SINE_LE) shadow -= SINE_LOOP_LEN;
+                }
+                total += count;
+            }
+            printf("    %s: PASS (%d samples verified)\n",
+                   interp_name(tests[m].mode), total);
+        }
+    }
+}
+
 /* ========================================================================= */
 
 int main(void)
@@ -1046,6 +1233,9 @@ int main(void)
     test_L_sinc_kernel_centering();
     printf("\n");
 
+    test_M_sine_wave_interpolation();
+    printf("\n");
+
     printf("========================================\n");
     printf("All tests PASSED\n");
 

From 0d3a7b0b16eca730350c7b6039527c1a8c30444a Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Tue, 4 Aug 2026 17:48:21 +0200
Subject: [PATCH 21/34] guard against arg

---
 src/rvoice/fluid_rvoice_dsp_sinc.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp_sinc.hpp b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
index 6aee9bcf7..90ce41deb 100644
--- a/src/rvoice/fluid_rvoice_dsp_sinc.hpp
+++ b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
@@ -82,10 +82,10 @@ static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_
         // if i_shifted < center, the result will be negative
         fluid_phase_decr(i_shifted, center);
         // sacrifize the upper 2^31 values (we will never get there even close) by interpreting i_shifted as signed integer to correctly account for negative values
-        fluid_real_t i_shifted_f = (int64_t)i_shifted * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
-        if(std::fabs(i_shifted_f) > 1e-6f)
+        const fluid_real_t i_shifted_f = (int64_t)i_shifted * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
+        const fluid_real_t arg = FLUID_M_PI * i_shifted_f;
+        if(std::fabs(arg) > 1e-6f)
         {
-            const fluid_real_t arg = FLUID_M_PI * i_shifted_f;
             v = std::sin(arg) / arg;
             /* Hanning window: */
             // 0.5f * (1.0f + std::cos(arg * (fluid_real_t)(2.0 / SINC_ORDER))) == cos²(arg / SINC_ORDER)

From 982404cefea64b0c8d74409b3a6ac5fa73bfd463 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Tue, 4 Aug 2026 18:39:04 +0200
Subject: [PATCH 22/34] add missing file

---
 test/Wave_Sine_093.h | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 test/Wave_Sine_093.h

diff --git a/test/Wave_Sine_093.h b/test/Wave_Sine_093.h
new file mode 100644
index 000000000..d36b8e393
--- /dev/null
+++ b/test/Wave_Sine_093.h
@@ -0,0 +1,23 @@
+// Auto-generated from : Wave_Sine_093.wav
+// Sample rate         : 44000 Hz
+// Bit depth           : 16 bit
+// Samples             : 71
+//
+// Loop points
+//   [0] type=forward  start=38  end=62  play_count=0
+
+#include <stdint.h>
+
+#define AUDIO_SAMPLES_LOOP0_START       38U
+#define AUDIO_SAMPLES_LOOP0_END         62U // inclusive!
+#define AUDIO_SAMPLES_LOOP0_TYPE        0U  /* forward */
+#define AUDIO_SAMPLES_LOOP0_PLAY_COUNT  0U  /* 0 = infinite */
+
+const int16_t wave_sine_093[71] = {
+      12427,  19085,  24533,  28457,  30572,  30783,  29056,  25488,  20352,  13893,   6605,  -1131,
+      -8781, -15874, -21993, -26714, -29782, -30933, -30183, -27509, -23099, -17264, -10324,  -2764,
+       4998,  12428,  19077,  24546,  28443,  30581,  30783,  29046,  25504,  20336,  13902,   6606,
+      -1142,  -8764, -15893, -21976, -26728, -29772, -30939, -30182, -27505, -23109, -17249, -10343,
+      -2744,   4981,  12437,  19078,  24536,  28459,  30564,  30797,  29038,  25507,  20336,  13904,
+       6600,  -1131,  -8777, -15882, -21981, -26730, -29763, -30953, -30166, -27520, -23097,
+};

From 1890539e741ad69914328379c5ef21b021d5c79b Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Tue, 4 Aug 2026 18:08:00 +0200
Subject: [PATCH 23/34] Revert "Use phase when calculating sample shift for
 sinc kernel"

This reverts commit 057cdf8fd2a1bf64aacb91e703fb3bec95c50a2e. It just
sounds as good as before.
---
 src/rvoice/fluid_rvoice_dsp.cpp      |  3 ++-
 src/rvoice/fluid_rvoice_dsp_sinc.hpp | 36 ++++------------------------
 2 files changed, 7 insertions(+), 32 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index 497deda8a..717b471d5 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -555,7 +555,8 @@ fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
      * The center tap is at position half in the array (s[half] == sample at dsp_phase_index). */
     auto interp_sinc = [&](std::array<fluid_real_t, SINC_ORDER> s)
     {
-        return fluid_interp_sinc_kernel<SINC_ORDER>(s, fluid_phase_fract(dsp_phase));
+        const auto x = fluid_phase_fract(dsp_phase) * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
+        return fluid_interp_sinc_kernel<SINC_ORDER>(s, x);
     };
 
     while(1)
diff --git a/src/rvoice/fluid_rvoice_dsp_sinc.hpp b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
index 90ce41deb..115db0b41 100644
--- a/src/rvoice/fluid_rvoice_dsp_sinc.hpp
+++ b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
@@ -49,26 +49,15 @@
  * reason to shift the center by an additional -0.5 tap.
  */
 template<int SINC_ORDER>
-static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_t, SINC_ORDER>& s, uint32_t phase_fract)
+static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_t, SINC_ORDER>& s, fluid_real_t x)
 {
     static_assert(SINC_ORDER >= 1 && SINC_ORDER != 2, "SINC_ORDER must be at least 1 and not equal to 2");
 
     constexpr int half = SINC_ORDER / 2;
 
     /* The +0.5-sample phase advance means the true position within s[] is
-     * half + (x - 0.5) = half - 0.5 + x for all orders (odd and even).
-     * The subtraction (phase_fract - 0x80000000) is intentionally done as a
-     * SIGNED 32-bit difference and then sign-extended to 64-bit: when
-     * phase_fract < 0x80000000 (original frac >= 0.5) the
-     * result is negative, which lowers center's integer part by 1 and places
-     * the kernel correctly between the tap *before* dsp_phase_index and
-     * dsp_phase_index itself.  Using plain uint32 subtraction would wrap to a
-     * large positive value and shift the center 1 sample too far right.
-     * Note that the sign extension i.e. from uint32 difference to int32
-     * technically invokes implementation defined behavior - only since C++20
-     * it's well defined to be performed in twos-complement.
-     */
-    const auto center = fluid_phase_from_index_fract(half, (int64_t)(int32_t)(phase_fract - (uint32_t)0x80000000u)); // == half + (x - 0.5f)
+     * half + (x - 0.5) = half - 0.5 + x for all orders (odd and even). */
+    const auto center = (fluid_real_t)(half - 0.5f) + x; // == half + (x - 0.5f)
 
     std::array<fluid_real_t, SINC_ORDER> coeffs;
     fluid_real_t sum = 0.0f;
@@ -76,14 +65,8 @@ static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_
     for(int i = 0; i < SINC_ORDER; i++)
     {
         fluid_real_t v;
-        fluid_phase_t i_shifted;
-        fluid_phase_set_int(i_shifted, i);
-
-        // if i_shifted < center, the result will be negative
-        fluid_phase_decr(i_shifted, center);
-        // sacrifize the upper 2^31 values (we will never get there even close) by interpreting i_shifted as signed integer to correctly account for negative values
-        const fluid_real_t i_shifted_f = (int64_t)i_shifted * (fluid_real_t)(1.0 / FLUID_FRACT_MAX);
-        const fluid_real_t arg = FLUID_M_PI * i_shifted_f;
+        const fluid_real_t i_shifted = (fluid_real_t)i - center;
+        const fluid_real_t arg = FLUID_M_PI * i_shifted;
         if(std::fabs(arg) > 1e-6f)
         {
             v = std::sin(arg) / arg;
@@ -109,12 +92,3 @@ static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_
     for(int i = 0; i < SINC_ORDER; i++) result += coeffs[i] * s[i];
     return result;
 }
-
-
-template<int SINC_ORDER>
-static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_t, SINC_ORDER>& s, fluid_real_t x)
-{
-    fluid_phase_t dsp_phase;
-    fluid_phase_set_float(dsp_phase, x);
-    return fluid_interp_sinc_kernel(s, fluid_phase_fract(dsp_phase));
-}
\ No newline at end of file

From 40c512828a23b594334df4ae7fad2ec40fdb0703 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Tue, 4 Aug 2026 22:02:01 +0200
Subject: [PATCH 24/34] Compensate for kernel asymmetry for even sinc orders

---
 src/rvoice/fluid_rvoice_dsp_sinc.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp_sinc.hpp b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
index 115db0b41..34be3a938 100644
--- a/src/rvoice/fluid_rvoice_dsp_sinc.hpp
+++ b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
@@ -55,9 +55,10 @@ static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_
 
     constexpr int half = SINC_ORDER / 2;
 
-    /* The +0.5-sample phase advance means the true position within s[] is
-     * half + (x - 0.5) = half - 0.5 + x for all orders (odd and even). */
-    const auto center = (fluid_real_t)(half - 0.5f) + x; // == half + (x - 0.5f)
+    const auto center = (SINC_ORDER % 2 == 0)
+        ? (fluid_real_t)(half - 1) + x // == half + (x - 1)
+        : (fluid_real_t)half - 0.5f + x; // == half + (x - 0.5f)
+
 
     std::array<fluid_real_t, SINC_ORDER> coeffs;
     fluid_real_t sum = 0.0f;

From b43d2891a690dac49d3aa1f13f640b51ee62083b Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Wed, 5 Aug 2026 14:56:56 +0200
Subject: [PATCH 25/34] Fix TEST L, comment out failing test E due to lookup
 table usage

---
 src/rvoice/fluid_rvoice_dsp_sinc.hpp | 10 ++--------
 test/test_rvoice_dsp_interpolate.cpp | 22 +++++++++++++++++++---
 2 files changed, 21 insertions(+), 11 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp_sinc.hpp b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
index 34be3a938..46bb8e70b 100644
--- a/src/rvoice/fluid_rvoice_dsp_sinc.hpp
+++ b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
@@ -31,22 +31,16 @@
  *   half == SINC_ORDER / 2
  *
  * @param s  Input sample array of length SINC_ORDER.
- * @param x  Fractional phase in [0, 1).  This is the raw fractional part of
+ * @param x  Fractional phase in [0, 1].  This is the raw fractional part of
  *           dsp_phase *after* the +0.5-sample advance applied by
  *           fluid_rvoice_dsp_interpolate_sinc_local().  The true playback
  *           position within s[] is therefore:
  *
  *               center = half + (x - 0.5)  =  half - 0.5 + x
  *
- *           When x == 0.5 the center falls exactly on s[half], so
+ *           When x == 0.5 the center falls exactly on s[half] (for odd orders only), so
  *           fluid_interp_sinc_kernel returns s[half] unmodified (sinc(0) = 1,
  *           sinc(n*pi) = 0 for all non-zero integers n).
- *
- * This formula is correct for both odd and even SINC_ORDER.  For odd order
- * (e.g. N=7, half=3) the center moves across the half-open range [half-0.5,
- * half+0.5), i.e. it is always within 0.5 taps of s[half].  For even order
- * (e.g. N=8, half=4) exactly the same arithmetic applies — there is no
- * reason to shift the center by an additional -0.5 tap.
  */
 template<int SINC_ORDER>
 static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_t, SINC_ORDER>& s, fluid_real_t x)
diff --git a/test/test_rvoice_dsp_interpolate.cpp b/test/test_rvoice_dsp_interpolate.cpp
index f7e352d6b..1510adb99 100644
--- a/test/test_rvoice_dsp_interpolate.cpp
+++ b/test/test_rvoice_dsp_interpolate.cpp
@@ -429,7 +429,7 @@ static void test_E_loop_boundary_ramp_wrap(void)
 
     constexpr const std::array<fluid_interp, 4> modes = { FLUID_INTERP_LINEAR,
                                    FLUID_INTERP_4THORDER,FLUID_INTERP_NONE,
-                                   FLUID_INTERP_7THORDER };
+                                   /*FLUID_INTERP_7THORDER*/};
 
     for (size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
     {
@@ -893,13 +893,29 @@ template<int N>
 static void test_L_order()
 {
     constexpr int half = N / 2;
+    auto get_center = []()
+        {
+            // A dsp_phase of 0 can be seen as interpolating for the center sample
+            double center = 0;
+            if (N % 2 == 0)
+            {
+                // For even orders, there is no true "center" sample, because the center falls in between two samples.
+                // The kernel compensates for that by subtracting an additional 0.5 in this case, hence we add 0.5
+                // to the center
+                center += 0.5;
+            }
+
+            // The sinc interpolator adds an unconditional 1/2 sample shift, which we have to account for here as well.
+            center += 0.5;
+            return (fluid_real_t)center;
+        };
 
     /* L1: unit impulse at s[half], x=0.5 must give 1.0 */
     {
         std::array<fluid_real_t, N> s;
         s.fill(0.0f);
         s[half] = 1.0f;
-        fluid_real_t result = fluid_interp_sinc_kernel<N>(s, 0.5f);
+        fluid_real_t result = fluid_interp_sinc_kernel<N>(s, get_center());
         fluid_real_t diff = std::fabs(result - 1.0f);
         if(diff > (fluid_real_t)1e-5)
         {
@@ -954,7 +970,7 @@ static void test_L_order()
         s.fill(0.0f);
         s[half] = 1.0f;
 
-        const fluid_real_t peak = fluid_interp_sinc_kernel<N>(s, 0.5f);
+        const fluid_real_t peak = fluid_interp_sinc_kernel<N>(s, get_center());
         bool found_higher = false;
         for(int step = 0; step <= 100; step++)
         {

From dadf58196ad5c6c35f5245f09f47982dfe81d451 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Wed, 5 Aug 2026 16:02:08 +0200
Subject: [PATCH 26/34] try a kaiser windowed sinc

---
 src/rvoice/fluid_rvoice_dsp_sinc.hpp | 69 +++++++++++++++++++++++++++-
 1 file changed, 67 insertions(+), 2 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp_sinc.hpp b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
index 46bb8e70b..9ebf93539 100644
--- a/src/rvoice/fluid_rvoice_dsp_sinc.hpp
+++ b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
@@ -23,6 +23,69 @@
 #include <array>
 #include <cmath>
 
+/* Kaiser window helper: zeroth-order modified Bessel function I0(x). */
+constexpr inline fluid_real_t fluid_bessel_i0(fluid_real_t x)
+{
+    /* Series expansion: I0(x) = sum_{k>=0} ((x/2)^k / k!)^2
+     * Converges quickly for the arguments we use (|x| well under ~20). */
+    fluid_real_t sum = 1.0;
+    fluid_real_t term = 1.0;
+    fluid_real_t half_x = x * (fluid_real_t)0.5;
+    for (int k = 1; k < 32; k++)
+    {
+        term *= (half_x / (fluid_real_t)k);   /* term now = (x/2)^k / k!            */
+        fluid_real_t t2 = term * term;        /* squared, per the I0 series         */
+        sum += t2;
+        //if (t2 < sum * (fluid_real_t)1e-12)     /* early out once contribution is tiny */
+        //    break;
+    }
+    return sum;
+}
+
+// Code borrowed from sfizz: https://github.com/sfztools/sfizz/blob/f5c6e29f23b8057867c08e88f5f6ac6738baa30b/src/sfizz/Interpolators.hpp#L146-L157
+constexpr inline fluid_real_t get_beta(int sinc_order)
+{
+    constexpr size_t PointsMin = 7;
+    constexpr size_t PointsMax = 72;
+
+    /* Kaiser shape parameter. beta ~5.658 targets ~60 dB stopband attenuation,
+     * a good compromise for short kernels: deeper stopbands can't be realized
+     * with few taps and only widen the transition band (dulling the passband). */
+    constexpr double BetaMin = 5.658;
+    constexpr double BetaMax = 10.0;
+
+    sinc_order = sinc_order < PointsMin ? PointsMin : sinc_order;
+
+    return BetaMin + (BetaMax - BetaMin) *
+            (double(sinc_order - PointsMin) / double(PointsMax - PointsMin));
+}
+
+template<int SINC_ORDER>
+static inline fluid_real_t kaiser(fluid_real_t i_shifted)
+{
+    constexpr fluid_real_t beta = get_beta(SINC_ORDER);
+
+    /* Precompute 1 / I0(beta) once per call (normalizes the Kaiser window peak to 1). */
+    constexpr fluid_real_t inv_i0_beta = (fluid_real_t)1.0 / fluid_bessel_i0(beta);
+
+    /* Half-width of the window in "tap" units. The kernel spans SINC_ORDER taps,
+     * so the window runs from -N/2 .. +N/2 around the reconstruction point. */
+    constexpr fluid_real_t halfD = (fluid_real_t)(SINC_ORDER / 2.0);
+
+    /* Kaiser window, centered on the reconstruction point.
+     * w(t) = I0(beta * sqrt(1 - (t/halfN)^2)) / I0(beta),  for |t| <= halfN.
+     * ratio can slightly exceed 1 for the outermost tap at some fractional
+     * phases; clamp the radicand to zero so we never take sqrt of a negative.
+     */
+    fluid_real_t ratio = i_shifted / halfD;
+    fluid_real_t rad = (fluid_real_t)1.0 - ratio * ratio;
+    fluid_real_t w = (rad > 0.0)
+        ? fluid_bessel_i0(beta * std::sqrt(rad)) * inv_i0_beta
+        : (fluid_real_t)0.0;
+
+    return w;
+}
+
 /**
  * Normalized windowed-sinc interpolation kernel of order SINC_ORDER.
  *
@@ -67,13 +130,15 @@ static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_
             v = std::sin(arg) / arg;
             /* Hanning window: */
             // 0.5f * (1.0f + std::cos(arg * (fluid_real_t)(2.0 / SINC_ORDER))) == cos²(arg / SINC_ORDER)
-            const fluid_real_t wnd = std::cos(arg / SINC_ORDER);
-            v *= wnd * wnd;
+            const fluid_real_t hann = std::cos(arg / SINC_ORDER);
+            //v *= hann * hann;
         }
         else
         {
             v = 1.0f;
         }
+        const fluid_real_t k = kaiser<SINC_ORDER>(i_shifted);
+        v *= k;
 
         coeffs[i] = v;
         sum += v;

From 23126cc70eac8614f365fd914315b83c57915271 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Thu, 6 Aug 2026 16:33:44 +0200
Subject: [PATCH 27/34] optimize normalzation

---
 src/rvoice/fluid_rvoice_dsp_sinc.hpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp_sinc.hpp b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
index 9ebf93539..205bf89ed 100644
--- a/src/rvoice/fluid_rvoice_dsp_sinc.hpp
+++ b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
@@ -141,14 +141,15 @@ static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_
         v *= k;
 
         coeffs[i] = v;
-        sum += v;
     }
 
+    fluid_real_t result = 0.0f;
+    for(int i = 0; i < SINC_ORDER; i++)
+    {
+        result += coeffs[i] * s[i];
+        sum += coeffs[i];
+    }
     /* Normalize so coefficients always sum to 1.0, preventing amplitude
      * modulation artifacts (harmonic distortion) as fractional phase varies. */
-    for(int i = 0; i < SINC_ORDER; i++) coeffs[i] /= sum;
-
-    fluid_real_t result = 0.0f;
-    for(int i = 0; i < SINC_ORDER; i++) result += coeffs[i] * s[i];
-    return result;
+    return result / sum;
 }

From d4fbc9b5b766d557f1f4b13fd76660535c2c317f Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Thu, 6 Aug 2026 17:31:39 +0200
Subject: [PATCH 28/34] use std::cyl_bessel_i

---
 src/rvoice/fluid_rvoice_dsp_sinc.hpp | 28 +++++-----------------------
 1 file changed, 5 insertions(+), 23 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp_sinc.hpp b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
index 205bf89ed..6b29aaf35 100644
--- a/src/rvoice/fluid_rvoice_dsp_sinc.hpp
+++ b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
@@ -19,29 +19,11 @@
 
 #pragma once
 
+#define __STDCPP_WANT_MATH_SPEC_FUNCS__
 #include "fluid_sys.h"
 #include <array>
 #include <cmath>
 
-/* Kaiser window helper: zeroth-order modified Bessel function I0(x). */
-constexpr inline fluid_real_t fluid_bessel_i0(fluid_real_t x)
-{
-    /* Series expansion: I0(x) = sum_{k>=0} ((x/2)^k / k!)^2
-     * Converges quickly for the arguments we use (|x| well under ~20). */
-    fluid_real_t sum = 1.0;
-    fluid_real_t term = 1.0;
-    fluid_real_t half_x = x * (fluid_real_t)0.5;
-    for (int k = 1; k < 32; k++)
-    {
-        term *= (half_x / (fluid_real_t)k);   /* term now = (x/2)^k / k!            */
-        fluid_real_t t2 = term * term;        /* squared, per the I0 series         */
-        sum += t2;
-        //if (t2 < sum * (fluid_real_t)1e-12)     /* early out once contribution is tiny */
-        //    break;
-    }
-    return sum;
-}
-
 // Code borrowed from sfizz: https://github.com/sfztools/sfizz/blob/f5c6e29f23b8057867c08e88f5f6ac6738baa30b/src/sfizz/Interpolators.hpp#L146-L157
 constexpr inline fluid_real_t get_beta(int sinc_order)
 {
@@ -66,7 +48,7 @@ static inline fluid_real_t kaiser(fluid_real_t i_shifted)
     constexpr fluid_real_t beta = get_beta(SINC_ORDER);
 
     /* Precompute 1 / I0(beta) once per call (normalizes the Kaiser window peak to 1). */
-    constexpr fluid_real_t inv_i0_beta = (fluid_real_t)1.0 / fluid_bessel_i0(beta);
+    static const fluid_real_t inv_i0_beta = (fluid_real_t)1.0 / std::cyl_bessel_i(0.f, beta);
 
     /* Half-width of the window in "tap" units. The kernel spans SINC_ORDER taps,
      * so the window runs from -N/2 .. +N/2 around the reconstruction point. */
@@ -80,7 +62,7 @@ static inline fluid_real_t kaiser(fluid_real_t i_shifted)
     fluid_real_t ratio = i_shifted / halfD;
     fluid_real_t rad = (fluid_real_t)1.0 - ratio * ratio;
     fluid_real_t w = (rad > 0.0)
-        ? fluid_bessel_i0(beta * std::sqrt(rad)) * inv_i0_beta
+        ? std::cyl_bessel_i(0.f, beta * std::sqrt(rad)) * inv_i0_beta
         : (fluid_real_t)0.0;
 
     return w;
@@ -132,13 +114,13 @@ static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_
             // 0.5f * (1.0f + std::cos(arg * (fluid_real_t)(2.0 / SINC_ORDER))) == cos²(arg / SINC_ORDER)
             const fluid_real_t hann = std::cos(arg / SINC_ORDER);
             //v *= hann * hann;
+            const fluid_real_t k = kaiser<SINC_ORDER>(i_shifted);
+            v *= k;
         }
         else
         {
             v = 1.0f;
         }
-        const fluid_real_t k = kaiser<SINC_ORDER>(i_shifted);
-        v *= k;
 
         coeffs[i] = v;
     }

From a1d40145737d3956ca8da98368f71b64065b6bc4 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Thu, 6 Aug 2026 18:27:14 +0200
Subject: [PATCH 29/34] no inline for constexpr

---
 src/rvoice/fluid_rvoice_dsp_sinc.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp_sinc.hpp b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
index 6b29aaf35..e5d1780aa 100644
--- a/src/rvoice/fluid_rvoice_dsp_sinc.hpp
+++ b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
@@ -25,7 +25,7 @@
 #include <cmath>
 
 // Code borrowed from sfizz: https://github.com/sfztools/sfizz/blob/f5c6e29f23b8057867c08e88f5f6ac6738baa30b/src/sfizz/Interpolators.hpp#L146-L157
-constexpr inline fluid_real_t get_beta(int sinc_order)
+constexpr fluid_real_t get_beta(int sinc_order)
 {
     constexpr size_t PointsMin = 7;
     constexpr size_t PointsMax = 72;
@@ -38,8 +38,7 @@ constexpr inline fluid_real_t get_beta(int sinc_order)
 
     sinc_order = sinc_order < PointsMin ? PointsMin : sinc_order;
 
-    return BetaMin + (BetaMax - BetaMin) *
-            (double(sinc_order - PointsMin) / double(PointsMax - PointsMin));
+    return BetaMin + (BetaMax - BetaMin) * (double(sinc_order - PointsMin) / double(PointsMax - PointsMin));
 }
 
 template<int SINC_ORDER>

From 8b88fe723427aa9279db71c3b47658aac23d2d15 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Thu, 6 Aug 2026 20:15:38 +0200
Subject: [PATCH 30/34] fix interpolation test E

---
 test/test_rvoice_dsp_interpolate.cpp | 42 +++++++++++++++++++++-------
 1 file changed, 32 insertions(+), 10 deletions(-)

diff --git a/test/test_rvoice_dsp_interpolate.cpp b/test/test_rvoice_dsp_interpolate.cpp
index 1510adb99..51571bbb1 100644
--- a/test/test_rvoice_dsp_interpolate.cpp
+++ b/test/test_rvoice_dsp_interpolate.cpp
@@ -56,8 +56,8 @@ static_assert(VAL_24BIT_MSB <= std::numeric_limits<short>::max(), "24-bit MSB ov
 /* ----- tolerances (in original sample units, before DSP scaling) -------- */
 
 /* Polynomial interpolators (NONE, LINEAR, 4TH ORDER) are exact for their
- * respective polynomial degrees. Tolerance covers table quantization. */
-static const fluid_real_t TOL_POLY = (fluid_real_t)0.001;
+ * respective polynomial degrees. */
+static const fluid_real_t TOL_POLY = (fluid_real_t)0.01;
 
 /* 7th-order sinc has energy smearing at fractional positions.
  * At integer positions it's more accurate, but fractional positions
@@ -429,7 +429,7 @@ static void test_E_loop_boundary_ramp_wrap(void)
 
     constexpr const std::array<fluid_interp, 4> modes = { FLUID_INTERP_LINEAR,
                                    FLUID_INTERP_4THORDER,FLUID_INTERP_NONE,
-                                   /*FLUID_INTERP_7THORDER*/};
+                                   FLUID_INTERP_7THORDER};
 
     for (size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
     {
@@ -472,7 +472,7 @@ static void test_E_loop_boundary_ramp_wrap(void)
                     return (fluid_real_t)data[k];
             };
 
-            fluid_real_t expected;
+            fluid_real_t expected = 0;
             switch (modes[m])
             {
             case FLUID_INTERP_NONE:
@@ -498,6 +498,7 @@ static void test_E_loop_boundary_ramp_wrap(void)
                 break;
 			case FLUID_INTERP_7THORDER:
 			{
+#if 0
 				/* Use precomputed sinc table for 7th-order interpolation */
 				const auto table_row = (int)(frac * FLUID_INTERP_MAX);
 				const fluid_real_t* coeffs = &sinc_table7[table_row * SINC_INTERP_ORDER];
@@ -509,6 +510,29 @@ static void test_E_loop_boundary_ramp_wrap(void)
 					coeffs[4] * s(1) +
 					coeffs[5] * s(2) +
 					coeffs[6] * s(3);
+#else
+                double sum = 0;
+                for (int j = 0; j < SINC_INTERP_ORDER; j++)
+                {
+                    double v, j_shifted = (double)j - ((double)(SINC_INTERP_ORDER / 2) - 0.5 + frac);
+
+                    if (fabs(j_shifted) > 0.000001)
+                    {
+                        double arg = M_PI * j_shifted;
+                        v = sin(arg) / arg;
+                        /* Hanning window */
+                        v *= 0.5 * (1.0 + cos(2.0 * arg / (double)SINC_INTERP_ORDER));
+                    }
+                    else
+                    {
+                        v = 1.0;
+                    }
+
+                    expected += v * s(j - (SINC_INTERP_ORDER / 2));
+                    sum += v;
+                }
+                expected /= sum;
+#endif
 			}
 			break;
             }
@@ -876,15 +900,12 @@ static void test_K_end_of_sample(void)
  *
  * Core property exploited:
  *   After the +0.5 phase advance in the DSP loop, x = fract(phase) = 0.5
- *   means the true playback position falls exactly on s[half].  For a unit
- *   impulse at s[half] the kernel must therefore return exactly 1.0:
+ *   means the true playback position falls exactly on s[half]... at least for odd orders.
+ *   For a unit impulse at s[half] the kernel must therefore return exactly 1.0:
  *     sinc(0) = 1,  sinc(n*pi) = 0  for all non-zero integers n.
  *
- *   Any systematic half-sample shift in the center formula places the kernel
- *   peak between e.g. s[half-1] and s[half], breaks this property.
- *
  * Sub-tests per order:
- *   L1 – Unit impulse at s[half], x=0.5  →  result == 1.0
+ *   L1 – Unit impulse at s[half], x=0.5   →  result == 1.0
  *   L2 – Unit impulse, x=0.0              →  result < 1.0  (sanity: non-trivial)
  *   L3 – Constant (DC) input              →  result == DC for any x  (unity gain)
  *   L4 – Impulse at s[half], sweep x      →  peak is at x=0.5, not elsewhere
@@ -1004,6 +1025,7 @@ static void test_L_sinc_kernel_centering(void)
     test_L_order<15>();
     test_L_order<17>();
     test_L_order<19>();
+
     printf("  Even orders:\n");
     /* N=2 is omitted: with only 2 taps the windowed-sinc degenerates into a
      * near-linear extrapolator whose normalized coefficients overshoot for

From 5cbad281da6f2e2ddef45ab20fa06643fbba7c25 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Thu, 6 Aug 2026 20:28:18 +0200
Subject: [PATCH 31/34] adjust tolerances

---
 test/test_rvoice_dsp_interpolate.cpp | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/test/test_rvoice_dsp_interpolate.cpp b/test/test_rvoice_dsp_interpolate.cpp
index 51571bbb1..6eea9bb01 100644
--- a/test/test_rvoice_dsp_interpolate.cpp
+++ b/test/test_rvoice_dsp_interpolate.cpp
@@ -1165,18 +1165,12 @@ static void test_M_sine_wave_interpolation(void)
     /* ---- M2: Phase ramp — pitch sweep 1.0x -> 2.0x --------------------- */
     printf("  M2: Phase ramp (phase_incr 1.0 -> 2.0 in 11 buffer calls)\n");
     {
-        /* Tolerance budget (in original sample units, before DSP scaling):
-         *
-         *   Fit residuals    (data != perfect sine) : ≈  100 counts
-         *   LINEAR error     A·(1-cos(ω/2))        : ≈  244 counts  → total 400
-         *   4TH ORDER error  (very small)           : <   10 counts  → total 200
-         *   7TH ORDER error  (incl. table quant.)   : <   20 counts  → total 200
-         *
+        /* Tolerance budget (in original sample units, before DSP scaling).
          * All modes get a little extra headroom to keep the test robust. */
         struct { fluid_interp mode; fluid_real_t tol; } tests[] = {
-            { FLUID_INTERP_LINEAR,    (fluid_real_t)400.0 },
-            { FLUID_INTERP_4THORDER,  (fluid_real_t)200.0 },
-            { FLUID_INTERP_7THORDER,  (fluid_real_t)200.0 },
+            { FLUID_INTERP_LINEAR,    (fluid_real_t)300.0 },
+            { FLUID_INTERP_4THORDER,  (fluid_real_t)50.0 },
+            { FLUID_INTERP_7THORDER,  (fluid_real_t)100.0 },
         };
 
         for (size_t m = 0; m < FLUID_N_ELEMENTS(tests); m++)

From 1f24507d73a92fd341432c6f2daa956817376ec0 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Thu, 6 Aug 2026 20:40:14 +0200
Subject: [PATCH 32/34] replace with enum

---
 test/Wave_Sine_093.h | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/test/Wave_Sine_093.h b/test/Wave_Sine_093.h
index d36b8e393..184f81359 100644
--- a/test/Wave_Sine_093.h
+++ b/test/Wave_Sine_093.h
@@ -8,10 +8,13 @@
 
 #include <stdint.h>
 
-#define AUDIO_SAMPLES_LOOP0_START       38U
-#define AUDIO_SAMPLES_LOOP0_END         62U // inclusive!
-#define AUDIO_SAMPLES_LOOP0_TYPE        0U  /* forward */
-#define AUDIO_SAMPLES_LOOP0_PLAY_COUNT  0U  /* 0 = infinite */
+enum
+{
+    AUDIO_SAMPLES_LOOP0_START       = 38U,
+    AUDIO_SAMPLES_LOOP0_END         = 62U, // inclusive!
+    AUDIO_SAMPLES_LOOP0_TYPE        = 0U,  /* forward */
+    AUDIO_SAMPLES_LOOP0_PLAY_COUNT  = 0U   /* 0 = infinite */
+};
 
 const int16_t wave_sine_093[71] = {
       12427,  19085,  24533,  28457,  30572,  30783,  29056,  25488,  20352,  13893,   6605,  -1131,

From 43f48d28a69343ea8d3acabbfaccf85e4c8d4b95 Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Thu, 6 Aug 2026 20:42:09 +0200
Subject: [PATCH 33/34] cleanly ifdef out kaiser window

---
 src/rvoice/fluid_rvoice_dsp_sinc.hpp | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp_sinc.hpp b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
index e5d1780aa..4bf406ec1 100644
--- a/src/rvoice/fluid_rvoice_dsp_sinc.hpp
+++ b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
@@ -24,6 +24,9 @@
 #include <array>
 #include <cmath>
 
+#define USE_KAISER_WINDOW 0
+
+#if USE_KAISER_WINDOW
 // Code borrowed from sfizz: https://github.com/sfztools/sfizz/blob/f5c6e29f23b8057867c08e88f5f6ac6738baa30b/src/sfizz/Interpolators.hpp#L146-L157
 constexpr fluid_real_t get_beta(int sinc_order)
 {
@@ -66,6 +69,7 @@ static inline fluid_real_t kaiser(fluid_real_t i_shifted)
 
     return w;
 }
+#endif // USE_KAISER_WINDOW
 
 /**
  * Normalized windowed-sinc interpolation kernel of order SINC_ORDER.
@@ -109,12 +113,15 @@ static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_
         if(std::fabs(arg) > 1e-6f)
         {
             v = std::sin(arg) / arg;
+#if USE_KAISER_WINDOW
+            const fluid_real_t k = kaiser<SINC_ORDER>(i_shifted);
+            v *= k;
+#else
             /* Hanning window: */
             // 0.5f * (1.0f + std::cos(arg * (fluid_real_t)(2.0 / SINC_ORDER))) == cos²(arg / SINC_ORDER)
             const fluid_real_t hann = std::cos(arg / SINC_ORDER);
-            //v *= hann * hann;
-            const fluid_real_t k = kaiser<SINC_ORDER>(i_shifted);
-            v *= k;
+            v *= hann * hann;
+#endif
         }
         else
         {

From b0845f69b629458fe904e88cc6e059e59a3f7ecb Mon Sep 17 00:00:00 2001
From: derselbst <tom.mbrt@googlemail.com>
Date: Thu, 6 Aug 2026 21:12:08 +0200
Subject: [PATCH 34/34] format

---
 src/rvoice/fluid_rvoice_dsp.cpp      | 157 +++++---
 src/rvoice/fluid_rvoice_dsp_sinc.hpp |  13 +-
 test/Wave_Sine_093.h                 |  15 +-
 test/test_rvoice_dsp_interpolate.cpp | 581 ++++++++++++++++-----------
 4 files changed, 470 insertions(+), 296 deletions(-)

diff --git a/src/rvoice/fluid_rvoice_dsp.cpp b/src/rvoice/fluid_rvoice_dsp.cpp
index 717b471d5..ece4d3145 100644
--- a/src/rvoice/fluid_rvoice_dsp.cpp
+++ b/src/rvoice/fluid_rvoice_dsp.cpp
@@ -61,7 +61,8 @@ static FLUID_INLINE fluid_real_t
 fluid_rvoice_get_float_sample(const short int *FLUID_RESTRICT dsp_msb, const char *FLUID_RESTRICT dsp_lsb, unsigned int idx)
 {
     int32_t sample;
-    if (IS_24BIT)
+
+    if(IS_24BIT)
     {
         sample = fluid_rvoice_get_sample24(dsp_msb, dsp_lsb, idx);
     }
@@ -69,7 +70,7 @@ fluid_rvoice_get_float_sample(const short int *FLUID_RESTRICT dsp_msb, const cha
     {
         sample = fluid_rvoice_get_sample16(dsp_msb, idx);
     }
-    
+
     return (fluid_real_t)sample;
 }
 
@@ -78,7 +79,7 @@ compute_interpolation_steps(fluid_phase_t dsp_phase, fluid_phase_t dsp_phase_inc
 {
     // How many steps until phase_index > limit?
     fluid_phase_t boundary;
-	fluid_phase_set_int(boundary, dsp_end_index + 1);
+    fluid_phase_set_int(boundary, dsp_end_index + 1);
     fluid_phase_t steps = dsp_phase > boundary ? 0 : ((boundary - dsp_phase + dsp_phase_incr - 1) / dsp_phase_incr);
     unsigned short iters = static_cast<unsigned short>(std::min<fluid_phase_t>(steps, (FLUID_BUFSIZE - dsp_i)));
     return iters;
@@ -100,13 +101,14 @@ static int fluid_rvoice_dsp_silence_local(fluid_rvoice_t *rvoice, fluid_real_t *
 
     end_index = LOOPING ? voice->loopend - 1 : voice->end;
 
-    while (1)
+    while(1)
     {
         dsp_phase_index = fluid_phase_index_round(dsp_phase); /* round to nearest point */
 
         /* interpolate sequence of sample points */
-		auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
-        for (; safe_count--; dsp_i++)
+        auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+
+        for(; safe_count--; dsp_i++)
         {
             fluid_real_t sample = 0;
             dsp_buf[dsp_i] = sample;
@@ -116,21 +118,22 @@ static int fluid_rvoice_dsp_silence_local(fluid_rvoice_t *rvoice, fluid_real_t *
         }
 
         /* break out if not looping (buffer may not be full) */
-        if (!LOOPING)
+        if(!LOOPING)
         {
             break;
         }
 
         dsp_phase_index = fluid_phase_index_round(dsp_phase); /* round to nearest point */
+
         /* go back to loop start */
-        if (dsp_phase_index > end_index)
+        if(dsp_phase_index > end_index)
         {
             fluid_phase_sub_int(dsp_phase, voice->loopend - voice->loopstart);
             voice->has_looped = 1;
         }
 
         /* break out if filled buffer */
-        if (dsp_i >= FLUID_BUFSIZE)
+        if(dsp_i >= FLUID_BUFSIZE)
         {
             break;
         }
@@ -170,10 +173,11 @@ fluid_rvoice_dsp_interpolate_none_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
 
         /* interpolate sequence of sample points */
         auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
-        for (; safe_count--; dsp_i++)
+
+        for(; safe_count--; dsp_i++)
         {
             fluid_real_t sample = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index);
-            
+
             dsp_buf[dsp_i] = sample;
 
             /* increment phase and amplitude */
@@ -242,7 +246,7 @@ fluid_rvoice_dsp_interpolate_linear_local(fluid_rvoice_t *rvoice, fluid_real_t *
 
     auto interp_linear = [&](fluid_real_t s0, fluid_real_t s1)
     {
-        const fluid_real_t* FLUID_RESTRICT coeffs = &interp_coeff_linear[fluid_phase_fract_to_tablerow(dsp_phase) * LINEAR_INTERP_ORDER];
+        const fluid_real_t *FLUID_RESTRICT coeffs = &interp_coeff_linear[fluid_phase_fract_to_tablerow(dsp_phase) * LINEAR_INTERP_ORDER];
         return (coeffs[0] * s0 + coeffs[1] * s1);
     };
 
@@ -252,11 +256,12 @@ fluid_rvoice_dsp_interpolate_linear_local(fluid_rvoice_t *rvoice, fluid_real_t *
 
         /* interpolate the sequence of sample points */
         auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
-        for (; safe_count--; dsp_i++)
+
+        for(; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_linear(
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1));
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1));
 
             dsp_buf[dsp_i] = sample;
 
@@ -275,11 +280,12 @@ fluid_rvoice_dsp_interpolate_linear_local(fluid_rvoice_t *rvoice, fluid_real_t *
 
         /* interpolate within last point */
         safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
-        for (; safe_count--; dsp_i++)
+
+        for(; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_linear(
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
-                point);
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                                      point);
 
             dsp_buf[dsp_i] = sample;
 
@@ -362,12 +368,13 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
     }
 
     /* Lambda for cubic interpolation with parameterized samples */
-    auto interp_cubic = [&](fluid_real_t s0, fluid_real_t s1, fluid_real_t s2, fluid_real_t s3) {
-        const fluid_real_t* FLUID_RESTRICT coeffs = &interp_coeff[fluid_phase_fract_to_tablerow(dsp_phase) * CUBIC_INTERP_ORDER];
-        return  (coeffs[0] * s0
-               + coeffs[1] * s1
-               + coeffs[2] * s2
-               + coeffs[3] * s3);
+    auto interp_cubic = [&](fluid_real_t s0, fluid_real_t s1, fluid_real_t s2, fluid_real_t s3)
+    {
+        const fluid_real_t *FLUID_RESTRICT coeffs = &interp_coeff[fluid_phase_fract_to_tablerow(dsp_phase) * CUBIC_INTERP_ORDER];
+        return (coeffs[0] * s0
+                + coeffs[1] * s1
+                + coeffs[2] * s2
+                + coeffs[3] * s3);
     };
 
     while(1)
@@ -376,13 +383,14 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
 
         /* interpolate first sample point (start or loop start) if needed */
         auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, start_index, dsp_i);
-        for (; safe_count--; dsp_i++)
+
+        for(; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_cubic(
-                start_point,
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2));
+                                      start_point,
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2));
 
             dsp_buf[dsp_i] = sample;
 
@@ -393,13 +401,14 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
 
         /* interpolate the sequence of sample points */
         safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
-        for (; safe_count--; dsp_i++)
+
+        for(; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_cubic(
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2));
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 2));
 
             dsp_buf[dsp_i] = sample;
 
@@ -418,13 +427,14 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
 
         /* interpolate within 2nd to last point */
         safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
-        for (; safe_count--; dsp_i++)
+
+        for(; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_cubic(
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
-                end_point1);
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + 1),
+                                      end_point1);
 
             dsp_buf[dsp_i] = sample;
 
@@ -437,13 +447,14 @@ fluid_rvoice_dsp_interpolate_4th_order_local(fluid_rvoice_t *rvoice, fluid_real_
 
         /* interpolate within the last point */
         safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
-        for (; safe_count--; dsp_i++)
+
+        for(; safe_count--; dsp_i++)
         {
             fluid_real_t sample = interp_cubic(
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
-                fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
-                end_point1,
-                end_point2);
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index - 1),
+                                      fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index),
+                                      end_point1,
+                                      end_point2);
 
             dsp_buf[dsp_i] = sample;
 
@@ -528,27 +539,37 @@ fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
     if(voice->has_looped)   /* set start_index and start points if looped or not */
     {
         start_index = voice->loopstart;
+
         for(int j = 0; j < half; j++)
+        {
             start_points[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopend - 1 - j);
+        }
     }
     else
     {
         start_index = voice->start;
+
         /* duplicate the start point for all left guard positions */
         for(int j = 0; j < half; j++)
+        {
             start_points[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->start);
+        }
     }
 
     /* get the guard points off the end (loop start if looping, duplicate if end) */
     if(LOOPING)
     {
         for(int j = 0; j < right_guard; j++)
+        {
             end_points[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopstart + j);
+        }
     }
     else
     {
         for(int j = 0; j < right_guard; j++)
+        {
             end_points[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->end);
+        }
     }
 
     /* Compute windowed sinc interpolation coefficients and apply to sample array.
@@ -570,16 +591,23 @@ fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
         for(int i = 0; i < half; i++)
         {
             auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, start_index + i, dsp_i);
+
             for(; safe_count--; dsp_i++)
             {
                 std::array<fluid_real_t, SINC_ORDER> s;
+
                 for(int j = 0; j < SINC_ORDER; j++)
                 {
                     if(j < half - i)
+                    {
                         s[j] = start_points[half - i - 1 - j];
+                    }
                     else
+                    {
                         s[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + (j - half));
+                    }
                 }
+
                 dsp_buf[dsp_i] = interp_sinc(s);
                 fluid_phase_incr(dsp_phase, dsp_phase_incr);
                 dsp_phase_index = fluid_phase_index(dsp_phase);
@@ -589,11 +617,16 @@ fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
         /* Interpolate the main body — all taps read from live sample data */
         {
             auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index, dsp_i);
+
             for(; safe_count--; dsp_i++)
             {
                 std::array<fluid_real_t, SINC_ORDER> s;
+
                 for(int j = 0; j < SINC_ORDER; j++)
+                {
                     s[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + (j - half));
+                }
+
                 dsp_buf[dsp_i] = interp_sinc(s);
                 fluid_phase_incr(dsp_phase, dsp_phase_incr);
                 dsp_phase_index = fluid_phase_index(dsp_phase);
@@ -613,16 +646,23 @@ fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
         for(int e = 0; e < right_guard; e++)
         {
             auto safe_count = compute_interpolation_steps(dsp_phase, dsp_phase_incr, end_index + 1 + e, dsp_i);
+
             for(; safe_count--; dsp_i++)
             {
                 std::array<fluid_real_t, SINC_ORDER> s;
+
                 for(int j = 0; j < SINC_ORDER; j++)
                 {
                     if(j < SINC_ORDER - e - 1)
+                    {
                         s[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, dsp_phase_index + (j - half));
+                    }
                     else
+                    {
                         s[j] = end_points[j - (SINC_ORDER - e - 1)];
+                    }
                 }
+
                 dsp_buf[dsp_i] = interp_sinc(s);
                 fluid_phase_incr(dsp_phase, dsp_phase_incr);
                 dsp_phase_index = fluid_phase_index(dsp_phase);
@@ -643,8 +683,11 @@ fluid_rvoice_dsp_interpolate_sinc_local(fluid_rvoice_t *rvoice, fluid_real_t *FL
             {
                 voice->has_looped = 1;
                 start_index = voice->loopstart;
+
                 for(int j = 0; j < half; j++)
+                {
                     start_points[j] = fluid_rvoice_get_float_sample<IS_24BIT>(dsp_data, dsp_data24, voice->loopend - 1 - j);
+                }
             }
         }
 
@@ -715,9 +758,9 @@ int dsp_invoker(fluid_rvoice_t *rvoice, fluid_real_t *FLUID_RESTRICT dsp_buf, in
     T func;
     bool is_24bit = rvoice->dsp.sample->data24 != NULL;
 
-    if (is_24bit)
+    if(is_24bit)
     {
-        if (looping)
+        if(looping)
         {
             return func.template operator()<true, true>(rvoice, dsp_buf);
         }
@@ -729,7 +772,7 @@ int dsp_invoker(fluid_rvoice_t *rvoice, fluid_real_t *FLUID_RESTRICT dsp_buf, in
     else
     {
         // This case is most common, thanks to templating it will also become the fastest one
-        if (looping)
+        if(looping)
         {
             return func.template operator()<false, true>(rvoice, dsp_buf);
         }
@@ -749,19 +792,19 @@ fluid_rvoice_dsp_silence(fluid_rvoice_t *rvoice, fluid_real_t *FLUID_RESTRICT ds
 extern "C" int
 fluid_rvoice_dsp_interpolate(fluid_rvoice_t *rvoice, fluid_real_t *FLUID_RESTRICT dsp_buf, int looping)
 {
-    switch (rvoice->dsp.interp_method)
+    switch(rvoice->dsp.interp_method)
     {
-        case FLUID_INTERP_NONE:
-            return dsp_invoker<InterpolateNone>(rvoice, dsp_buf, looping);
+    case FLUID_INTERP_NONE:
+        return dsp_invoker<InterpolateNone>(rvoice, dsp_buf, looping);
 
-        case FLUID_INTERP_LINEAR:
-            return dsp_invoker<InterpolateLinear>(rvoice, dsp_buf, looping);
+    case FLUID_INTERP_LINEAR:
+        return dsp_invoker<InterpolateLinear>(rvoice, dsp_buf, looping);
 
-        case FLUID_INTERP_4THORDER:
-        default:
-            return dsp_invoker<Interpolate4thOrder>(rvoice, dsp_buf, looping);
+    case FLUID_INTERP_4THORDER:
+    default:
+        return dsp_invoker<Interpolate4thOrder>(rvoice, dsp_buf, looping);
 
-        case FLUID_INTERP_7THORDER:
-            return dsp_invoker<Interpolate7thOrder>(rvoice, dsp_buf, looping);
+    case FLUID_INTERP_7THORDER:
+        return dsp_invoker<Interpolate7thOrder>(rvoice, dsp_buf, looping);
     }
 }
\ No newline at end of file
diff --git a/src/rvoice/fluid_rvoice_dsp_sinc.hpp b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
index 4bf406ec1..d01871eb3 100644
--- a/src/rvoice/fluid_rvoice_dsp_sinc.hpp
+++ b/src/rvoice/fluid_rvoice_dsp_sinc.hpp
@@ -64,8 +64,8 @@ static inline fluid_real_t kaiser(fluid_real_t i_shifted)
     fluid_real_t ratio = i_shifted / halfD;
     fluid_real_t rad = (fluid_real_t)1.0 - ratio * ratio;
     fluid_real_t w = (rad > 0.0)
-        ? std::cyl_bessel_i(0.f, beta * std::sqrt(rad)) * inv_i0_beta
-        : (fluid_real_t)0.0;
+                     ? std::cyl_bessel_i(0.f, beta * std::sqrt(rad)) * inv_i0_beta
+                     : (fluid_real_t)0.0;
 
     return w;
 }
@@ -91,15 +91,15 @@ static inline fluid_real_t kaiser(fluid_real_t i_shifted)
  *           sinc(n*pi) = 0 for all non-zero integers n).
  */
 template<int SINC_ORDER>
-static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_t, SINC_ORDER>& s, fluid_real_t x)
+static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_t, SINC_ORDER> &s, fluid_real_t x)
 {
     static_assert(SINC_ORDER >= 1 && SINC_ORDER != 2, "SINC_ORDER must be at least 1 and not equal to 2");
 
     constexpr int half = SINC_ORDER / 2;
 
     const auto center = (SINC_ORDER % 2 == 0)
-        ? (fluid_real_t)(half - 1) + x // == half + (x - 1)
-        : (fluid_real_t)half - 0.5f + x; // == half + (x - 0.5f)
+                        ? (fluid_real_t)(half - 1) + x // == half + (x - 1)
+                        : (fluid_real_t)half - 0.5f + x; // == half + (x - 0.5f)
 
 
     std::array<fluid_real_t, SINC_ORDER> coeffs;
@@ -110,6 +110,7 @@ static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_
         fluid_real_t v;
         const fluid_real_t i_shifted = (fluid_real_t)i - center;
         const fluid_real_t arg = FLUID_M_PI * i_shifted;
+
         if(std::fabs(arg) > 1e-6f)
         {
             v = std::sin(arg) / arg;
@@ -132,11 +133,13 @@ static inline fluid_real_t fluid_interp_sinc_kernel(const std::array<fluid_real_
     }
 
     fluid_real_t result = 0.0f;
+
     for(int i = 0; i < SINC_ORDER; i++)
     {
         result += coeffs[i] * s[i];
         sum += coeffs[i];
     }
+
     /* Normalize so coefficients always sum to 1.0, preventing amplitude
      * modulation artifacts (harmonic distortion) as fractional phase varies. */
     return result / sum;
diff --git a/test/Wave_Sine_093.h b/test/Wave_Sine_093.h
index 184f81359..65d439200 100644
--- a/test/Wave_Sine_093.h
+++ b/test/Wave_Sine_093.h
@@ -16,11 +16,12 @@ enum
     AUDIO_SAMPLES_LOOP0_PLAY_COUNT  = 0U   /* 0 = infinite */
 };
 
-const int16_t wave_sine_093[71] = {
-      12427,  19085,  24533,  28457,  30572,  30783,  29056,  25488,  20352,  13893,   6605,  -1131,
-      -8781, -15874, -21993, -26714, -29782, -30933, -30183, -27509, -23099, -17264, -10324,  -2764,
-       4998,  12428,  19077,  24546,  28443,  30581,  30783,  29046,  25504,  20336,  13902,   6606,
-      -1142,  -8764, -15893, -21976, -26728, -29772, -30939, -30182, -27505, -23109, -17249, -10343,
-      -2744,   4981,  12437,  19078,  24536,  28459,  30564,  30797,  29038,  25507,  20336,  13904,
-       6600,  -1131,  -8777, -15882, -21981, -26730, -29763, -30953, -30166, -27520, -23097,
+const int16_t wave_sine_093[71] =
+{
+    12427,  19085,  24533,  28457,  30572,  30783,  29056,  25488,  20352,  13893,   6605,  -1131,
+    -8781, -15874, -21993, -26714, -29782, -30933, -30183, -27509, -23099, -17264, -10324,  -2764,
+     4998,  12428,  19077,  24546,  28443,  30581,  30783,  29046,  25504,  20336,  13902,   6606,
+    -1142,  -8764, -15893, -21976, -26728, -29772, -30939, -30182, -27505, -23109, -17249, -10343,
+    -2744,   4981,  12437,  19078,  24536,  28459,  30564,  30797,  29038,  25507,  20336,  13904,
+     6600,  -1131,  -8777, -15882, -21981, -26730, -29763, -30953, -30166, -27520, -23097,
 };
diff --git a/test/test_rvoice_dsp_interpolate.cpp b/test/test_rvoice_dsp_interpolate.cpp
index 6eea9bb01..2c0bbadee 100644
--- a/test/test_rvoice_dsp_interpolate.cpp
+++ b/test/test_rvoice_dsp_interpolate.cpp
@@ -31,7 +31,7 @@
 #include <limits>
 #include <array>
 
- /* ----- constants -------------------------------------------------------- */
+/* ----- constants -------------------------------------------------------- */
 
 static const int SAMPLE_SIZE = 64;
 static const int LOOP_START = 8;
@@ -68,17 +68,17 @@ static const fluid_real_t TOL_SINC_FRAC = (fluid_real_t)13.0;  /* fractional pha
 /* ----- helpers ---------------------------------------------------------- */
 
 static void setup_rvoice(fluid_rvoice_t* rvoice,
-    fluid_sample_t* sample,
-    short* data,
-    char* data24,
-    double           phase_float,
-    double           phase_incr,
-    int              start,
-    int              end,
-    int              loop_start,
-    int              loop_end,
-    int              has_looped,
-    fluid_interp     interp_method)
+                         fluid_sample_t *sample,
+                         short *data,
+                         char *data24,
+                         double           phase_float,
+                         double           phase_incr,
+                         int              start,
+                         int              end,
+                         int              loop_start,
+                         int              loop_end,
+                         int              has_looped,
+                         fluid_interp     interp_method)
 {
     memset(rvoice, 0, sizeof(*rvoice));
     memset(sample, 0, sizeof(*sample));
@@ -100,20 +100,20 @@ static void setup_rvoice(fluid_rvoice_t* rvoice,
 
 /* Simplified setup for common 16-bit case */
 static void setup_rvoice_16bit(fluid_rvoice_t* rvoice,
-    fluid_sample_t* sample,
-    short* data,
-    double           phase_float,
-    double           phase_incr,
-    int              loop_start,
-    int              loop_end,
-    int              has_looped,
-    fluid_interp     interp_method)
+                               fluid_sample_t *sample,
+                               short *data,
+                               double           phase_float,
+                               double           phase_incr,
+                               int              loop_start,
+                               int              loop_end,
+                               int              has_looped,
+                               fluid_interp     interp_method)
 {
     setup_rvoice(rvoice, sample, data, nullptr,
-        phase_float, phase_incr,
-        0, SAMPLE_SIZE - 1,
-        loop_start, loop_end,
-        has_looped, interp_method);
+                 phase_float, phase_incr,
+                 0, SAMPLE_SIZE - 1,
+                 loop_start, loop_end,
+                 has_looped, interp_method);
 }
 
 /**
@@ -121,41 +121,58 @@ static void setup_rvoice_16bit(fluid_rvoice_t* rvoice,
  * DSP output is scaled by 256 (left-shifted by 8 bits).
  */
 static void test_sample_eq(fluid_real_t dsp_output,
-    fluid_real_t expected,
-    fluid_real_t tol,
-    int index = -1)
+                           fluid_real_t expected,
+                           fluid_real_t tol,
+                           int index = -1)
 {
     fluid_real_t actual = dsp_output / DSP_SCALE;
     fluid_real_t diff = std::abs(actual - expected);
 
-    if (diff > tol)
+    if(diff > tol)
     {
-        if (index >= 0)
+        if(index >= 0)
+        {
             fprintf(stderr, "FAIL at index %d: ", index);
+        }
         else
+        {
             fprintf(stderr, "FAIL: ");
+        }
+
         fprintf(stderr, "dsp_output=%.1f, actual=%.1f, expected=%.1f, diff=%.1f, tol=%.1f\n",
-            (double)dsp_output, (double)actual, (double)expected, (double)diff, (double)tol);
+                (double)dsp_output, (double)actual, (double)expected, (double)diff, (double)tol);
         TEST_ASSERT(0);
     }
 }
 
-static const char* interp_name(fluid_interp mode)
+static const char *interp_name(fluid_interp mode)
 {
-    switch (mode)
+    switch(mode)
     {
-    case FLUID_INTERP_NONE:     return "NONE";
-    case FLUID_INTERP_LINEAR:   return "LINEAR";
-    case FLUID_INTERP_4THORDER: return "4TH_ORDER";
-    case FLUID_INTERP_7THORDER: return "7TH_ORDER";
-    default: throw std::logic_error("Unknown interpolation mode");
+    case FLUID_INTERP_NONE:
+        return "NONE";
+
+    case FLUID_INTERP_LINEAR:
+        return "LINEAR";
+
+    case FLUID_INTERP_4THORDER:
+        return "4TH_ORDER";
+
+    case FLUID_INTERP_7THORDER:
+        return "7TH_ORDER";
+
+    default:
+        throw std::logic_error("Unknown interpolation mode");
     }
 }
 
 static fluid_real_t get_tolerance(fluid_interp mode, bool fractional_phase = false)
 {
-    if (mode == FLUID_INTERP_7THORDER)
+    if(mode == FLUID_INTERP_7THORDER)
+    {
         return fractional_phase ? TOL_SINC_FRAC : TOL_SINC_INT;
+    }
+
     return TOL_POLY;
 }
 
@@ -164,8 +181,10 @@ static fluid_real_t get_tolerance(fluid_interp mode, bool fractional_phase = fal
  */
 static int safe_verify_count(fluid_interp mode, int sample_end, double phase_start, double phase_incr)
 {
-    if (phase_start > sample_end)
-		throw std::runtime_error("Phase start exceeds safe limit for verification");
+    if(phase_start > sample_end)
+    {
+        throw std::runtime_error("Phase start exceeds safe limit for verification");
+    }
 
     int count = (int)((sample_end - phase_start) / phase_incr) + 1;
     fluid_clip(count, 0, FLUID_BUFSIZE);
@@ -185,16 +204,20 @@ static void test_A_integer_phase_passthrough(void)
 
     /* Use small values to avoid overflow: max value = 63 * RAMP_STEP_SMALL = 31500 */
     std::array<short, SAMPLE_SIZE> data;
-    for (int i = 0; i < SAMPLE_SIZE; i++)
+
+    for(int i = 0; i < SAMPLE_SIZE; i++)
+    {
         data[i] = (short)(i * RAMP_STEP_SMALL);
+    }
 
     /* Test all interpolation modes */
     constexpr const std::array<fluid_interp, 4> modes = { FLUID_INTERP_NONE,
-                                   FLUID_INTERP_LINEAR,
-                                   FLUID_INTERP_4THORDER,
-                                   FLUID_INTERP_7THORDER };
+                                                          FLUID_INTERP_LINEAR,
+                                                          FLUID_INTERP_4THORDER,
+                                                          FLUID_INTERP_7THORDER
+                                                        };
 
-    for (size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
+    for(size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
     {
         fluid_rvoice_t  rvoice;
         fluid_sample_t  samp;
@@ -206,9 +229,9 @@ static void test_A_integer_phase_passthrough(void)
                        (modes[m] == FLUID_INTERP_4THORDER) ? 1.0 : 0.0;
 
         setup_rvoice_16bit(&rvoice, &samp, data.data(),
-            start, 1.0,
-            0, SAMPLE_SIZE,
-            0, modes[m]);
+                           start, 1.0,
+                           0, SAMPLE_SIZE,
+                           0, modes[m]);
 
         int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), 0);
         TEST_ASSERT(count > 0);
@@ -217,10 +240,12 @@ static void test_A_integer_phase_passthrough(void)
         TEST_ASSERT(count == verify_count);
 
         fluid_real_t tol = get_tolerance(modes[m], false);
-        for (int i = 0; i < verify_count; i++)  
+
+        for(int i = 0; i < verify_count; i++)
         {
             test_sample_eq(buf[i], (fluid_real_t)data[(int)start + i], tol, i);
         }
+
         printf("  %s: PASS (%d samples verified)\n", interp_name(modes[m]), verify_count);
     }
 }
@@ -241,8 +266,11 @@ static void test_B_fractional_linear_ramp(void)
     /* Use step of RAMP_STEP_SMALL to stay well within short range: max = 63 * RAMP_STEP_SMALL = 31500 */
     const int ramp_step = RAMP_STEP_SMALL;
     std::array<short, SAMPLE_SIZE> data;
-    for (int i = 0; i < SAMPLE_SIZE; i++)
+
+    for(int i = 0; i < SAMPLE_SIZE; i++)
+    {
         data[i] = (short)(i * ramp_step);
+    }
 
     const double phase_start = 5.0;
     const double phase_incr = 0.5;
@@ -255,9 +283,9 @@ static void test_B_fractional_linear_ramp(void)
         buf.fill(0);
 
         setup_rvoice_16bit(&rvoice, &samp, data.data(),
-            phase_start, phase_incr,
-            0, SAMPLE_SIZE,
-            0, FLUID_INTERP_NONE);
+                           phase_start, phase_incr,
+                           0, SAMPLE_SIZE,
+                           0, FLUID_INTERP_NONE);
 
         int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), 0);
         TEST_ASSERT(count > 0);
@@ -265,20 +293,21 @@ static void test_B_fractional_linear_ramp(void)
         int verify_count = safe_verify_count(FLUID_INTERP_NONE, SAMPLE_SIZE - 1, phase_start, phase_incr);
         TEST_ASSERT(count == verify_count);
 
-        for (int i = 0; i < verify_count; i++)
+        for(int i = 0; i < verify_count; i++)
         {
             double phase = phase_start + i * phase_incr;
             int nearest = (int)(phase + 0.5);
 
             test_sample_eq(buf[i], (fluid_real_t)data[nearest], TOL_POLY, i);
         }
+
         printf("  NONE (nearest): PASS (%d samples verified)\n", verify_count);
     }
 
     /* B2: LINEAR and 4TH ORDER - exact linear reproduction */
     constexpr const std::array<fluid_interp, 2> poly_modes = { FLUID_INTERP_LINEAR, FLUID_INTERP_4THORDER };
 
-    for (size_t m = 0; m < FLUID_N_ELEMENTS(poly_modes); m++)
+    for(size_t m = 0; m < FLUID_N_ELEMENTS(poly_modes); m++)
     {
         fluid_rvoice_t  rvoice;
         fluid_sample_t  samp;
@@ -286,9 +315,9 @@ static void test_B_fractional_linear_ramp(void)
         buf.fill(0);
 
         setup_rvoice_16bit(&rvoice, &samp, data.data(),
-            phase_start, phase_incr,
-            0, SAMPLE_SIZE,
-            0, poly_modes[m]);
+                           phase_start, phase_incr,
+                           0, SAMPLE_SIZE,
+                           0, poly_modes[m]);
 
         int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), 0);
         TEST_ASSERT(count > 0);
@@ -296,12 +325,13 @@ static void test_B_fractional_linear_ramp(void)
         int verify_count = safe_verify_count(poly_modes[m], SAMPLE_SIZE - 1, phase_start, phase_incr);
         TEST_ASSERT(count == verify_count);
 
-        for (int i = 0; i < verify_count; i++)
+        for(int i = 0; i < verify_count; i++)
         {
             double phase = phase_start + i * phase_incr;
             auto expected = (fluid_real_t)(phase * ramp_step);
             test_sample_eq(buf[i], expected, TOL_POLY, i);
         }
+
         printf("  %s: PASS (%d samples verified)\n", interp_name(poly_modes[m]), verify_count);
     }
 }
@@ -319,13 +349,15 @@ static void test_C_constant_sample(void)
     data.fill(CONST_VAL);
 
     constexpr const std::array<fluid_interp, 4> modes = { FLUID_INTERP_NONE,
-                                   FLUID_INTERP_LINEAR,
-                                   FLUID_INTERP_4THORDER,
-                                   FLUID_INTERP_7THORDER };
+                                                          FLUID_INTERP_LINEAR,
+                                                          FLUID_INTERP_4THORDER,
+                                                          FLUID_INTERP_7THORDER
+                                                        };
 
     /* Fractional phase */
     printf("  Fractional phase\n");
-    for (size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
+
+    for(size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
     {
         fluid_rvoice_t  rvoice;
         fluid_sample_t  samp;
@@ -334,9 +366,9 @@ static void test_C_constant_sample(void)
 
         /* Start well into interior for all modes */
         setup_rvoice_16bit(&rvoice, &samp, data.data(),
-            10.0, 0.7,
-            0, SAMPLE_SIZE,
-            0, modes[m]);
+                           10.0, 0.7,
+                           0, SAMPLE_SIZE,
+                           0, modes[m]);
 
         int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), 0);
         TEST_ASSERT(count > 0);
@@ -345,10 +377,12 @@ static void test_C_constant_sample(void)
         TEST_ASSERT(count == verify_count);
 
         fluid_real_t tol = get_tolerance(modes[m], true);
-        for (int i = 0; i < verify_count; i++)
+
+        for(int i = 0; i < verify_count; i++)
         {
             test_sample_eq(buf[i], (fluid_real_t)CONST_VAL, tol, i);
         }
+
         printf("    %s: PASS (%d samples verified)\n", interp_name(modes[m]), verify_count);
     }
 }
@@ -371,13 +405,14 @@ static void test_D_loop_boundary_constant_sample(void)
     const double phase_incr = 0.6;
 
     constexpr const std::array<fluid_interp, 4> modes = { FLUID_INTERP_NONE,
-                                   FLUID_INTERP_LINEAR,
-                                   FLUID_INTERP_4THORDER,
-                                   FLUID_INTERP_7THORDER };
+                                                          FLUID_INTERP_LINEAR,
+                                                          FLUID_INTERP_4THORDER,
+                                                          FLUID_INTERP_7THORDER
+                                                        };
 
     printf("  D1: first loop crossing (has_looped=0)\n");
 
-    for (size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
+    for(size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
     {
         fluid_rvoice_t  rvoice;
         fluid_sample_t  samp;
@@ -385,16 +420,16 @@ static void test_D_loop_boundary_constant_sample(void)
         buf.fill(0);
 
         setup_rvoice_16bit(&rvoice, &samp, data.data(),
-            phase_start, phase_incr,
-            LOOP_START, LOOP_END,
-            0, modes[m]);
+                           phase_start, phase_incr,
+                           LOOP_START, LOOP_END,
+                           0, modes[m]);
 
         int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), /*looping=*/1);
         TEST_ASSERT(count == FLUID_BUFSIZE);
 
         fluid_real_t tol = get_tolerance(modes[m], true);
 
-        for (int i = 0; i < count; i++)
+        for(int i = 0; i < count; i++)
         {
             test_sample_eq(buf[i], (fluid_real_t)CONST_VAL, tol, i);
         }
@@ -409,7 +444,7 @@ static void test_D_loop_boundary_constant_sample(void)
  *
  * Verify that wrap-around samples come from the correct loop positions.
  * ========================================================================= */
-extern "C" const fluid_real_t* const sinc_table7;
+extern "C" const fluid_real_t *const sinc_table7;
 static void test_E_loop_boundary_ramp_wrap(void)
 {
     printf("Test E: Loop boundary wrap (periodic ramp)\n");
@@ -418,7 +453,8 @@ static void test_E_loop_boundary_ramp_wrap(void)
     const int ramp_step = RAMP_STEP_LOOP;  /* Safe: max = 15 * RAMP_STEP_LOOP = 30000 < 32767 */
 
     std::array<short, SAMPLE_SIZE> data;
-    for (int i = 0; i < SAMPLE_SIZE; i++)
+
+    for(int i = 0; i < SAMPLE_SIZE; i++)
     {
         int rel = ((i - LOOP_START) % loop_len + loop_len) % loop_len;
         data[i] = (short)(rel * ramp_step);
@@ -428,10 +464,11 @@ static void test_E_loop_boundary_ramp_wrap(void)
     const double phase_incr = 0.25;
 
     constexpr const std::array<fluid_interp, 4> modes = { FLUID_INTERP_LINEAR,
-                                   FLUID_INTERP_4THORDER,FLUID_INTERP_NONE,
-                                   FLUID_INTERP_7THORDER};
+                                                          FLUID_INTERP_4THORDER, FLUID_INTERP_NONE,
+                                                          FLUID_INTERP_7THORDER
+                                                        };
 
-    for (size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
+    for(size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
     {
         fluid_rvoice_t  rvoice;
         fluid_sample_t  samp;
@@ -439,15 +476,16 @@ static void test_E_loop_boundary_ramp_wrap(void)
         buf.fill(0);
 
         setup_rvoice_16bit(&rvoice, &samp, data.data(),
-            phase_start, phase_incr,
-            LOOP_START, LOOP_END,
-            1, modes[m]);
+                           phase_start, phase_incr,
+                           LOOP_START, LOOP_END,
+                           1, modes[m]);
 
         int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), /*looping=*/1);
         TEST_ASSERT(count == FLUID_BUFSIZE);
 
-		fluid_real_t sample_ring_buffer[FLUID_INTERP_HIGHEST + 1];
+        fluid_real_t sample_ring_buffer[FLUID_INTERP_HIGHEST + 1];
         double phase_d = phase_start;
+
         if(modes[m] == FLUID_INTERP_7THORDER)
         {
             /* The 7th-order DSP adds 0.5 to the phase before computing the
@@ -456,67 +494,90 @@ static void test_E_loop_boundary_ramp_wrap(void)
              * Mirror that here so we use the same index, samples, and table row. */
             phase_d += 0.5f;
         }
-        for (int i = 0; i < count; i++)
+
+        for(int i = 0; i < count; i++)
         {
             int idx = (int)phase_d;
             double frac = phase_d - idx;
 
-            while (idx >= LOOP_END)  idx -= loop_len;
-            while (idx < LOOP_START) idx += loop_len;
+            while(idx >= LOOP_END)
+            {
+                idx -= loop_len;
+            }
+
+            while(idx < LOOP_START)
+            {
+                idx += loop_len;
+            }
 
             /* Helper: get a sample at position idx + k, loop-wrapped */
-            auto s = [&](int k) -> fluid_real_t {
-                    k += idx;
-                    while (k >= LOOP_END)  k -= loop_len;
-                    while (k < LOOP_START) k += loop_len;
-                    return (fluid_real_t)data[k];
+            auto s = [&](int k) -> fluid_real_t
+            {
+                k += idx;
+
+                while(k >= LOOP_END)
+                {
+                    k -= loop_len;
+                }
+
+                while(k < LOOP_START)
+                {
+                    k += loop_len;
+                }
+
+                return (fluid_real_t)data[k];
             };
 
             fluid_real_t expected = 0;
-            switch (modes[m])
+
+            switch(modes[m])
             {
             case FLUID_INTERP_NONE:
-				expected = (frac < 0.5) ? s(0) : s(1);
-				break;
+                expected = (frac < 0.5) ? s(0) : s(1);
+                break;
+
             case FLUID_INTERP_LINEAR:
                 expected = s(0) + (fluid_real_t)frac * (s(1) - s(0));
                 break;
+
             case FLUID_INTERP_4THORDER:
-                {
-                    /* Compute Catmull-Rom spline coefficients, aka cubic interpolation */
-                    const fluid_real_t x = frac;
-                    const fluid_real_t x2 = x * x;
-                    const fluid_real_t x3 = x2 * x;
-                    const fluid_real_t halfx = 0.5f * x;
-
-                    expected =
-                          (-halfx + x2 - 0.5f * x3) * s(-1)
-                        + (1.0f - 2.5f * x2 + 1.5f * x3) * s(0)
-                        + (halfx + 2.0f * x2 - 1.5f * x3) * s(1)
-                        + (-0.5f * x2 + 0.5f * x3) * s(2);
-                }
-                break;
-			case FLUID_INTERP_7THORDER:
-			{
+            {
+                /* Compute Catmull-Rom spline coefficients, aka cubic interpolation */
+                const fluid_real_t x = frac;
+                const fluid_real_t x2 = x * x;
+                const fluid_real_t x3 = x2 * x;
+                const fluid_real_t halfx = 0.5f * x;
+
+                expected =
+                    (-halfx + x2 - 0.5f * x3) * s(-1)
+                    + (1.0f - 2.5f * x2 + 1.5f * x3) * s(0)
+                    + (halfx + 2.0f * x2 - 1.5f * x3) * s(1)
+                    + (-0.5f * x2 + 0.5f * x3) * s(2);
+            }
+            break;
+
+            case FLUID_INTERP_7THORDER:
+            {
 #if 0
-				/* Use precomputed sinc table for 7th-order interpolation */
-				const auto table_row = (int)(frac * FLUID_INTERP_MAX);
-				const fluid_real_t* coeffs = &sinc_table7[table_row * SINC_INTERP_ORDER];
-				expected =
-					coeffs[0] * s(-3) +
-					coeffs[1] * s(-2) +
-					coeffs[2] * s(-1) +
-					coeffs[3] * s(0) +
-					coeffs[4] * s(1) +
-					coeffs[5] * s(2) +
-					coeffs[6] * s(3);
+                /* Use precomputed sinc table for 7th-order interpolation */
+                const auto table_row = (int)(frac * FLUID_INTERP_MAX);
+                const fluid_real_t *coeffs = &sinc_table7[table_row * SINC_INTERP_ORDER];
+                expected =
+                    coeffs[0] * s(-3) +
+                    coeffs[1] * s(-2) +
+                    coeffs[2] * s(-1) +
+                    coeffs[3] * s(0) +
+                    coeffs[4] * s(1) +
+                    coeffs[5] * s(2) +
+                    coeffs[6] * s(3);
 #else
                 double sum = 0;
-                for (int j = 0; j < SINC_INTERP_ORDER; j++)
+
+                for(int j = 0; j < SINC_INTERP_ORDER; j++)
                 {
                     double v, j_shifted = (double)j - ((double)(SINC_INTERP_ORDER / 2) - 0.5 + frac);
 
-                    if (fabs(j_shifted) > 0.000001)
+                    if(fabs(j_shifted) > 0.000001)
                     {
                         double arg = M_PI * j_shifted;
                         v = sin(arg) / arg;
@@ -531,17 +592,23 @@ static void test_E_loop_boundary_ramp_wrap(void)
                     expected += v * s(j - (SINC_INTERP_ORDER / 2));
                     sum += v;
                 }
+
                 expected /= sum;
 #endif
-			}
-			break;
+            }
+            break;
             }
 
             test_sample_eq(buf[i], expected, TOL_POLY, i);
 
             phase_d += phase_incr;
-            while (phase_d >= (double)LOOP_END) phase_d -= loop_len;
+
+            while(phase_d >= (double)LOOP_END)
+            {
+                phase_d -= loop_len;
+            }
         }
+
         printf("  %s: PASS (%d samples)\n", interp_name(modes[m]), count);
     }
 }
@@ -570,11 +637,12 @@ static void test_F_24bit_samples(void)
     constexpr const auto expected_24bit = (fluid_real_t)0x123456;
 
     constexpr const std::array<fluid_interp, 4> modes = { FLUID_INTERP_NONE,
-                                   FLUID_INTERP_LINEAR,
-                                   FLUID_INTERP_4THORDER,
-                                   FLUID_INTERP_7THORDER };
+                                                          FLUID_INTERP_LINEAR,
+                                                          FLUID_INTERP_4THORDER,
+                                                          FLUID_INTERP_7THORDER
+                                                        };
 
-    for (size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
+    for(size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
     {
         fluid_rvoice_t  rvoice;
         fluid_sample_t  samp;
@@ -582,13 +650,13 @@ static void test_F_24bit_samples(void)
         buf.fill(0);
 
         double start = (modes[m] == FLUID_INTERP_7THORDER) ? 5.0 :
-            (modes[m] == FLUID_INTERP_4THORDER) ? 2.0 : 1.0;
+                       (modes[m] == FLUID_INTERP_4THORDER) ? 2.0 : 1.0;
 
         setup_rvoice(&rvoice, &samp, data16.data(), data24.data(),
-            start, 1.0,
-            0, SAMPLE_SIZE - 1,
-            0, SAMPLE_SIZE,
-            0, modes[m]);
+                     start, 1.0,
+                     0, SAMPLE_SIZE - 1,
+                     0, SAMPLE_SIZE,
+                     0, modes[m]);
 
         int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), 0);
         TEST_ASSERT(count > 0);
@@ -596,22 +664,24 @@ static void test_F_24bit_samples(void)
         /* For 24-bit, the output is the assembled 24-bit value (no additional scaling
          * beyond what's already in get_sample24 which just assembles the bits) */
         fluid_real_t tol = (modes[m] == FLUID_INTERP_7THORDER) ?
-            (fluid_real_t)5000.0 : (fluid_real_t)1.0;
+                           (fluid_real_t)5000.0 : (fluid_real_t)1.0;
 
         int verify_count = safe_verify_count(modes[m], SAMPLE_SIZE - 1, start, 1.0);
         TEST_ASSERT(count == verify_count);
 
-        for (int i = 0; i < verify_count; i++)
+        for(int i = 0; i < verify_count; i++)
         {
             /* 24-bit output is NOT divided by DSP_SCALE - compare directly */
             fluid_real_t diff = std::abs(buf[i] - expected_24bit);
-            if (diff > tol)
+
+            if(diff > tol)
             {
                 fprintf(stderr, "FAIL at index %d: dsp_output=%.1f, expected=%.1f, diff=%.1f, tol=%.1f\n",
-                    i, (double)buf[i], (double)expected_24bit, (double)diff, (double)tol);
+                        i, (double)buf[i], (double)expected_24bit, (double)diff, (double)tol);
                 TEST_ASSERT(0);
             }
         }
+
         printf("  %s: PASS (%d samples verified)\n", interp_name(modes[m]), verify_count);
     }
 }
@@ -626,20 +696,22 @@ static void test_G_high_playback_rate(void)
     std::array<short, SAMPLE_SIZE> data;
     data.fill(CONST_VAL);
 
-    constexpr const std::array<double,6> rates = { 2.0, 3.0, 4.0, 16.0, 128.0, 8192.0 };
+    constexpr const std::array<double, 6> rates = { 2.0, 3.0, 4.0, 16.0, 128.0, 8192.0 };
 
     constexpr const std::array<fluid_interp, 4> modes = { FLUID_INTERP_NONE,
-                                   FLUID_INTERP_LINEAR,
-                                   FLUID_INTERP_4THORDER,
-                                   FLUID_INTERP_7THORDER };
+                                                          FLUID_INTERP_LINEAR,
+                                                          FLUID_INTERP_4THORDER,
+                                                          FLUID_INTERP_7THORDER
+                                                        };
 
     /* G1: Non-looping */
     printf("  G1: Non-looping\n");
-    for (size_t r = 0; r < FLUID_N_ELEMENTS(rates); r++)
+
+    for(size_t r = 0; r < FLUID_N_ELEMENTS(rates); r++)
     {
         printf("    Rate %.1fx:\n", rates[r]);
 
-        for (size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
+        for(size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
         {
             fluid_rvoice_t  rvoice;
             fluid_sample_t  samp;
@@ -647,12 +719,12 @@ static void test_G_high_playback_rate(void)
             buf.fill(0);
 
             double start = (modes[m] == FLUID_INTERP_7THORDER) ? 3.0 :
-                (modes[m] == FLUID_INTERP_4THORDER) ? 1.0 : 0.0;
+                           (modes[m] == FLUID_INTERP_4THORDER) ? 1.0 : 0.0;
 
             setup_rvoice_16bit(&rvoice, &samp, data.data(),
-                start, rates[r],
-                0, SAMPLE_SIZE,
-                0, modes[m]);
+                               start, rates[r],
+                               0, SAMPLE_SIZE,
+                               0, modes[m]);
 
             int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), 0);
             TEST_ASSERT(count > 0);
@@ -662,10 +734,12 @@ static void test_G_high_playback_rate(void)
             TEST_ASSERT(count == verify_count);
 
             fluid_real_t tol = get_tolerance(modes[m], false);
-            for (int i = 0; i < verify_count; i++)
+
+            for(int i = 0; i < verify_count; i++)
             {
                 test_sample_eq(buf[i], (fluid_real_t)CONST_VAL, tol, i);
             }
+
             printf("      %s: PASS (%d samples verified)\n", interp_name(modes[m]), count);
         }
     }
@@ -674,11 +748,12 @@ static void test_G_high_playback_rate(void)
      * All data is CONST_VAL so the output must be CONST_VAL regardless of how many
      * times the phase wraps around the loop per output sample. */
     printf("  G2: Looping\n");
-    for (size_t r = 0; r < FLUID_N_ELEMENTS(rates); r++)
+
+    for(size_t r = 0; r < FLUID_N_ELEMENTS(rates); r++)
     {
         printf("    Rate %.1fx:\n", rates[r]);
 
-        for (size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
+        for(size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
         {
             fluid_rvoice_t  rvoice;
             fluid_sample_t  samp;
@@ -686,18 +761,20 @@ static void test_G_high_playback_rate(void)
             buf.fill(0);
 
             setup_rvoice_16bit(&rvoice, &samp, data.data(),
-                (double)LOOP_START, rates[r],
-                LOOP_START, LOOP_END,
-                1, modes[m]);
+                               (double)LOOP_START, rates[r],
+                               LOOP_START, LOOP_END,
+                               1, modes[m]);
 
             int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), /*looping=*/1);
             TEST_ASSERT(count == FLUID_BUFSIZE);
 
             fluid_real_t tol = get_tolerance(modes[m], false);
-            for (int i = 0; i < count; i++)
+
+            for(int i = 0; i < count; i++)
             {
                 test_sample_eq(buf[i], (fluid_real_t)CONST_VAL, tol, i);
             }
+
             printf("      %s: PASS (%d samples verified)\n", interp_name(modes[m]), count);
         }
     }
@@ -713,17 +790,19 @@ static void test_H_short_loops(void)
     std::array<short, SAMPLE_SIZE> data;
     data.fill(CONST_VAL);
 
-    struct {
+    struct
+    {
         fluid_interp mode;
         int min_loop_len;
-    } tests[] = {
+    } tests[] =
+    {
         { FLUID_INTERP_NONE,     2 },
         { FLUID_INTERP_LINEAR,   3 },
         { FLUID_INTERP_4THORDER, 5 },
         { FLUID_INTERP_7THORDER, 8 },
     };
 
-    for (size_t t = 0; t < FLUID_N_ELEMENTS(tests); t++)
+    for(size_t t = 0; t < FLUID_N_ELEMENTS(tests); t++)
     {
         int loop_start = 10;
         int loop_end = loop_start + tests[t].min_loop_len;
@@ -734,22 +813,22 @@ static void test_H_short_loops(void)
         buf.fill(0);
 
         setup_rvoice_16bit(&rvoice, &samp, data.data(),
-            (double)loop_start, 0.5,
-            loop_start, loop_end,
-            1, tests[t].mode);
+                           (double)loop_start, 0.5,
+                           loop_start, loop_end,
+                           1, tests[t].mode);
 
         int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), /*looping=*/1);
         TEST_ASSERT(count == FLUID_BUFSIZE);
 
         fluid_real_t tol = get_tolerance(tests[t].mode, true);
 
-        for (int i = 0; i < count; i++)
+        for(int i = 0; i < count; i++)
         {
             test_sample_eq(buf[i], (fluid_real_t)CONST_VAL, tol, i);
         }
 
         printf("  %s (loop_len=%d): PASS\n",
-            interp_name(tests[t].mode), tests[t].min_loop_len);
+               interp_name(tests[t].mode), tests[t].min_loop_len);
     }
 }
 
@@ -761,8 +840,11 @@ static void test_I_silence_rendering(void)
     printf("Test I: Silence rendering\n");
 
     std::array<short, SAMPLE_SIZE> data;
-    for (int i = 0; i < SAMPLE_SIZE; i++)
+
+    for(int i = 0; i < SAMPLE_SIZE; i++)
+    {
         data[i] = (short)(i * RAMP_STEP_SMALL);
+    }
 
     /* I1: Non-looping */
     {
@@ -772,17 +854,18 @@ static void test_I_silence_rendering(void)
         buf.fill(12345.0f);
 
         setup_rvoice_16bit(&rvoice, &samp, data.data(),
-            0.0, 1.0,
-            0, SAMPLE_SIZE,
-            0, FLUID_INTERP_NONE);
+                           0.0, 1.0,
+                           0, SAMPLE_SIZE,
+                           0, FLUID_INTERP_NONE);
 
         int count = fluid_rvoice_dsp_silence(&rvoice, buf.data(), /*looping=*/0);
         TEST_ASSERT(count == SAMPLE_SIZE);
 
-        for (int i = 0; i < count; i++)
+        for(int i = 0; i < count; i++)
         {
             TEST_ASSERT(buf[i] == 0.0f);
         }
+
         printf("  Non-looping: PASS (%d samples verified)\n", count);
     }
 
@@ -794,14 +877,14 @@ static void test_I_silence_rendering(void)
         buf.fill(12345.0f);
 
         setup_rvoice_16bit(&rvoice, &samp, data.data(),
-            (double)(LOOP_END - 2), 0.5,
-            LOOP_START, LOOP_END,
-            0, FLUID_INTERP_NONE);
+                           (double)(LOOP_END - 2), 0.5,
+                           LOOP_START, LOOP_END,
+                           0, FLUID_INTERP_NONE);
 
         int count = fluid_rvoice_dsp_silence(&rvoice, buf.data(), /*looping=*/1);
         TEST_ASSERT(count == FLUID_BUFSIZE);
 
-        for (int i = 0; i < count; i++)
+        for(int i = 0; i < count; i++)
         {
             TEST_ASSERT(buf[i] == 0.0f);
         }
@@ -827,11 +910,11 @@ static void test_J_phase_accumulation(void)
     fluid_sample_t  samp;
 
     setup_rvoice_16bit(&rvoice, &samp, data.data(),
-        (double)LOOP_START, phase_incr,
-        LOOP_START, LOOP_END,
-        1, FLUID_INTERP_LINEAR);
+                       (double)LOOP_START, phase_incr,
+                       LOOP_START, LOOP_END,
+                       1, FLUID_INTERP_LINEAR);
 
-    for (int iter = 0; iter < 100; iter++)
+    for(int iter = 0; iter < 100; iter++)
     {
         std::array<fluid_real_t, FLUID_BUFSIZE> buf;
         buf.fill(0);
@@ -839,7 +922,7 @@ static void test_J_phase_accumulation(void)
         int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), /*looping=*/1);
         TEST_ASSERT(count == FLUID_BUFSIZE);
 
-        for (int i = 0; i < count; i++)
+        for(int i = 0; i < count; i++)
         {
             test_sample_eq(buf[i], (fluid_real_t)CONST_VAL, TOL_POLY, i);
         }
@@ -865,9 +948,10 @@ static void test_K_end_of_sample(void)
     const fluid_interp modes[] = { FLUID_INTERP_NONE,
                                    FLUID_INTERP_LINEAR,
                                    FLUID_INTERP_4THORDER,
-                                   FLUID_INTERP_7THORDER };
+                                   FLUID_INTERP_7THORDER
+                                 };
 
-    for (size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
+    for(size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
     {
         fluid_rvoice_t  rvoice;
         fluid_sample_t  samp;
@@ -877,9 +961,9 @@ static void test_K_end_of_sample(void)
         double start = SAMPLE_SIZE - 10.0;
 
         setup_rvoice_16bit(&rvoice, &samp, data.data(),
-            start, 1.0,
-            0, SAMPLE_SIZE,
-            0, modes[m]);
+                           start, 1.0,
+                           0, SAMPLE_SIZE,
+                           0, modes[m]);
 
         int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), /*looping=*/0);
 
@@ -888,7 +972,7 @@ static void test_K_end_of_sample(void)
         TEST_ASSERT(count <= 12);
 
         printf("  %s: PASS (returned %d samples from position %.0f)\n",
-            interp_name(modes[m]), count, start);
+               interp_name(modes[m]), count, start);
     }
 }
 
@@ -915,21 +999,22 @@ static void test_L_order()
 {
     constexpr int half = N / 2;
     auto get_center = []()
-        {
-            // A dsp_phase of 0 can be seen as interpolating for the center sample
-            double center = 0;
-            if (N % 2 == 0)
-            {
-                // For even orders, there is no true "center" sample, because the center falls in between two samples.
-                // The kernel compensates for that by subtracting an additional 0.5 in this case, hence we add 0.5
-                // to the center
-                center += 0.5;
-            }
+    {
+        // A dsp_phase of 0 can be seen as interpolating for the center sample
+        double center = 0;
 
-            // The sinc interpolator adds an unconditional 1/2 sample shift, which we have to account for here as well.
+        if(N % 2 == 0)
+        {
+            // For even orders, there is no true "center" sample, because the center falls in between two samples.
+            // The kernel compensates for that by subtracting an additional 0.5 in this case, hence we add 0.5
+            // to the center
             center += 0.5;
-            return (fluid_real_t)center;
-        };
+        }
+
+        // The sinc interpolator adds an unconditional 1/2 sample shift, which we have to account for here as well.
+        center += 0.5;
+        return (fluid_real_t)center;
+    };
 
     /* L1: unit impulse at s[half], x=0.5 must give 1.0 */
     {
@@ -938,12 +1023,14 @@ static void test_L_order()
         s[half] = 1.0f;
         fluid_real_t result = fluid_interp_sinc_kernel<N>(s, get_center());
         fluid_real_t diff = std::fabs(result - 1.0f);
+
         if(diff > (fluid_real_t)1e-5)
         {
             fprintf(stderr, "FAIL L1 (order=%d): impulse@s[%d] x=0.5 -> %.8f (expected 1.0, diff=%.2e)\n",
                     N, half, (double)result, (double)diff);
             TEST_ASSERT(0);
         }
+
         printf("    L1 (order=%d) impulse@s[half] x=0.5: PASS (result=%.8f)\n", N, (double)result);
     }
 
@@ -954,12 +1041,14 @@ static void test_L_order()
         s.fill(0.0f);
         s[half] = 1.0f;
         fluid_real_t result = fluid_interp_sinc_kernel<N>(s, 0.0f);
+
         if(result >= 1.0f - (fluid_real_t)1e-5)
         {
             fprintf(stderr, "FAIL L2 (order=%d): kernel appears trivial at x=0.0 (result=%.8f)\n",
                     N, (double)result);
             TEST_ASSERT(0);
         }
+
         printf("    L2 (order=%d) impulse@s[half] x=0.0: PASS (result=%.8f, confirms non-trivial)\n",
                N, (double)result);
     }
@@ -970,10 +1059,12 @@ static void test_L_order()
         std::array<fluid_real_t, N> s;
         s.fill(DC);
         const float x_vals[] = { 0.0f, 0.1f, 0.25f, 0.5f, 0.75f, 0.9f, 0.999f };
+
         for(float xv : x_vals)
         {
             fluid_real_t result = fluid_interp_sinc_kernel<N>(s, (fluid_real_t)xv);
             fluid_real_t diff = std::fabs(result - DC);
+
             if(diff > (fluid_real_t)1e-2 * DC)
             {
                 fprintf(stderr, "FAIL L3 (order=%d): DC x=%.3f -> %.1f (expected %.1f, diff=%.2e)\n",
@@ -981,6 +1072,7 @@ static void test_L_order()
                 TEST_ASSERT(0);
             }
         }
+
         printf("    L3 (order=%d) DC gain: PASS\n", N);
     }
 
@@ -993,19 +1085,27 @@ static void test_L_order()
 
         const fluid_real_t peak = fluid_interp_sinc_kernel<N>(s, get_center());
         bool found_higher = false;
+
         for(int step = 0; step <= 100; step++)
         {
             float xv = step / 100.0f;
-            if(xv >= 1.0f) xv = 0.999f;
+
+            if(xv >= 1.0f)
+            {
+                xv = 0.999f;
+            }
+
             fluid_real_t v = fluid_interp_sinc_kernel<N>(s, (fluid_real_t)xv);
+
             if(v > peak + (fluid_real_t)1e-5)
             {
                 fprintf(stderr, "FAIL L4 (order=%d): peak not at x=0.5 "
-                        "(x=%.3f gives %.8f > peak %.8f)\n",
+                                "(x=%.3f gives %.8f > peak %.8f)\n",
                         N, (double)xv, (double)v, (double)peak);
                 found_higher = true;
             }
         }
+
         TEST_ASSERT(!found_higher);
         printf("    L4 (order=%d) peak at x=0.5: PASS\n", N);
     }
@@ -1052,16 +1152,18 @@ static void test_L_sinc_kernel_centering(void)
  * This is an exact LSQ fit when the data contains exactly one period.
  */
 static void sine_fit_loop(const short* samples, int loop_start, int loop_len,
-                          double* out_A, double* out_phi)
+                          double *out_A, double *out_phi)
 {
     const double omega = 2.0 * M_PI / loop_len;
     double B = 0.0, C = 0.0;
-    for (int p = 0; p < loop_len; p++)
+
+    for(int p = 0; p < loop_len; p++)
     {
         double s = (double)samples[loop_start + p];
         B += s * std::sin(omega * p);
         C += s * std::cos(omega * p);
     }
+
     B *= 2.0 / loop_len;
     C *= 2.0 / loop_len;
     *out_A   = std::sqrt(B * B + C * C);
@@ -1096,8 +1198,11 @@ static void test_M_sine_wave_interpolation(void)
     constexpr int SINE_LOOP_LEN = SINE_LE - SINE_LS;                   /* 25            */
 
     std::array<short, SINE_N> data;
-    for (int i = 0; i < SINE_N; i++)
+
+    for(int i = 0; i < SINE_N; i++)
+    {
         data[i] = (short)wave_sine_093[i];
+    }
 
     /* Least-squares sine fit to the loop region (used by M2). */
     double sine_A, sine_phi;
@@ -1109,11 +1214,12 @@ static void test_M_sine_wave_interpolation(void)
     printf("  M1: Constant phase_incr=1.0, 3 buffer iterations (all modes)\n");
     {
         constexpr const std::array<fluid_interp, 4> modes = { FLUID_INTERP_NONE,
-                                       FLUID_INTERP_LINEAR,
-                                       FLUID_INTERP_4THORDER,
-                                       FLUID_INTERP_7THORDER };
+                                                              FLUID_INTERP_LINEAR,
+                                                              FLUID_INTERP_4THORDER,
+                                                              FLUID_INTERP_7THORDER
+                                                            };
 
-        for (size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
+        for(size_t m = 0; m < FLUID_N_ELEMENTS(modes); m++)
         {
             fluid_rvoice_t rvoice;
             fluid_sample_t samp;
@@ -1125,10 +1231,10 @@ static void test_M_sine_wave_interpolation(void)
             const double start = (double)SINE_LS;
 
             setup_rvoice(&rvoice, &samp, data.data(), /*data24=*/nullptr,
-                start, /*phase_incr=*/1.0,
-                /*start=*/0, /*end=*/SINE_N - 1,
-                SINE_LS, SINE_LE,
-                /*has_looped=*/1, modes[m]);
+                         start, /*phase_incr=*/1.0,
+                         /*start=*/0, /*end=*/SINE_N - 1,
+                         SINE_LS, SINE_LE,
+                         /*has_looped=*/1, modes[m]);
 
             /* At integer-only positions the tolerance for 7th-order is the
              * tighter "integer phase" value; other modes use TOL_POLY. */
@@ -1137,7 +1243,7 @@ static void test_M_sine_wave_interpolation(void)
             double shadow = start;   /* mirrors the DSP phase (integer positions only) */
             int total = 0;
 
-            for (int iter = 0; iter < 3; iter++)
+            for(int iter = 0; iter < 3; iter++)
             {
                 std::array<fluid_real_t, FLUID_BUFSIZE> buf;
                 buf.fill(0);
@@ -1145,19 +1251,29 @@ static void test_M_sine_wave_interpolation(void)
                 int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), /*is_looping=*/1);
                 TEST_ASSERT(count == FLUID_BUFSIZE);
 
-                for (int i = 0; i < count; i++)
+                for(int i = 0; i < count; i++)
                 {
                     /* shadow is always an integer value; map it into the loop. */
                     int idx = (int)shadow;
-                    while (idx >= SINE_LE) idx -= SINE_LOOP_LEN;
+
+                    while(idx >= SINE_LE)
+                    {
+                        idx -= SINE_LOOP_LEN;
+                    }
 
                     test_sample_eq(buf[i], (fluid_real_t)data[idx], tol, total + i);
 
                     shadow += 1.0;
-                    if (shadow >= SINE_LE) shadow -= SINE_LOOP_LEN;
+
+                    if(shadow >= SINE_LE)
+                    {
+                        shadow -= SINE_LOOP_LEN;
+                    }
                 }
+
                 total += count;
             }
+
             printf("    %s: PASS (%d samples verified)\n", interp_name(modes[m]), total);
         }
     }
@@ -1167,13 +1283,18 @@ static void test_M_sine_wave_interpolation(void)
     {
         /* Tolerance budget (in original sample units, before DSP scaling).
          * All modes get a little extra headroom to keep the test robust. */
-        struct { fluid_interp mode; fluid_real_t tol; } tests[] = {
-            { FLUID_INTERP_LINEAR,    (fluid_real_t)300.0 },
-            { FLUID_INTERP_4THORDER,  (fluid_real_t)50.0 },
-            { FLUID_INTERP_7THORDER,  (fluid_real_t)100.0 },
+        struct
+        {
+            fluid_interp mode;
+            fluid_real_t tol;
+        } tests[] =
+        {
+            { FLUID_INTERP_LINEAR, (fluid_real_t)300.0 },
+            { FLUID_INTERP_4THORDER, (fluid_real_t)50.0 },
+            { FLUID_INTERP_7THORDER, (fluid_real_t)100.0 },
         };
 
-        for (size_t m = 0; m < FLUID_N_ELEMENTS(tests); m++)
+        for(size_t m = 0; m < FLUID_N_ELEMENTS(tests); m++)
         {
             fluid_rvoice_t rvoice;
             fluid_sample_t samp;
@@ -1181,17 +1302,17 @@ static void test_M_sine_wave_interpolation(void)
             const double start = (double)SINE_LS;
 
             setup_rvoice(&rvoice, &samp, data.data(), /*data24=*/nullptr,
-                start, /*phase_incr=*/1.0,
-                /*start=*/0, /*end=*/SINE_N - 1,
-                SINE_LS, SINE_LE,
-                /*has_looped=*/1, tests[m].mode);
+                         start, /*phase_incr=*/1.0,
+                         /*start=*/0, /*end=*/SINE_N - 1,
+                         SINE_LS, SINE_LE,
+                         /*has_looped=*/1, tests[m].mode);
 
             /* shadow tracks the exact fractional loop position consumed by
              * each output sample, mirroring the DSP phase accumulator. */
             double shadow = start;
             int total = 0;
 
-            for (int step = 0; step <= 10; step++)
+            for(int step = 0; step <= 10; step++)
             {
                 const double incr = 1.0 + step * 0.1;
                 rvoice.dsp.phase_incr = (fluid_real_t)incr;
@@ -1202,7 +1323,7 @@ static void test_M_sine_wave_interpolation(void)
                 int count = fluid_rvoice_dsp_interpolate(&rvoice, buf.data(), /*is_looping=*/1);
                 TEST_ASSERT(count == FLUID_BUFSIZE);
 
-                for (int i = 0; i < count; i++)
+                for(int i = 0; i < count; i++)
                 {
                     /* Fractional position within the loop (0-based). */
                     const double loop_pos = shadow - SINE_LS;
@@ -1212,10 +1333,16 @@ static void test_M_sine_wave_interpolation(void)
 
                     /* Advance and wrap shadow to match DSP behaviour. */
                     shadow += incr;
-                    if (shadow >= SINE_LE) shadow -= SINE_LOOP_LEN;
+
+                    if(shadow >= SINE_LE)
+                    {
+                        shadow -= SINE_LOOP_LEN;
+                    }
                 }
+
                 total += count;
             }
+
             printf("    %s: PASS (%d samples verified)\n",
                    interp_name(tests[m].mode), total);
         }