[residual] Update residual so that it just requires

a frame of audio (calculates harmonic component
itself).

6 files changed, 62 insertions, 76 deletions

diff --git a/simpl/examples/residual.py b/simpl/examples/residual.py
index 6e7a0cb..bfaa412 100644
--- a/simpl/examples/residual.py
+++ b/simpl/examples/residual.py
@@ -9,24 +9,9 @@ audio_data = read(input_file)
 audio = np.asarray(audio_data[1]) / 32768.0
 sampling_rate = audio_data[0]
 hop_size = 512
-num_frames = len(audio) / hop_size
-num_samples = len(audio)
-max_peaks = 10
-max_partials = 10
 
-pd = simpl.SMSPeakDetection()
-pd.max_peaks = max_peaks
-pd.hop_size = hop_size
-peaks = pd.find_peaks(audio)
-pt = simpl.SMSPartialTracking()
-pt.max_partials = max_partials
-partials = pt.find_partials(peaks)
-synth = simpl.SMSSynthesis()
-synth.hop_size = hop_size
-synth.max_partials = max_partials
-synth_audio = synth.synth(partials)
 r = simpl.SMSResidual()
 r.hop_size = hop_size
-audio_out = r.synth(synth_audio, audio)
+audio_out = r.synth(audio)
 audio_out = np.asarray(audio_out * 32768, np.int16)
 write(output_file, 44100, audio_out)
diff --git a/simpl/residual.pxd b/simpl/residual.pxd
index 5980e33..e5e39a5 100644
--- a/simpl/residual.pxd
+++ b/simpl/residual.pxd
@@ -20,15 +20,12 @@ cdef extern from "../src/simpl/residual.h" namespace "simpl":
         void hop_size(int new_hop_size)
         int sampling_rate()
         void sampling_rate(int new_sampling_rate)
-        void residual_frame(int synth_size, double* synth,
-                            int original_size, double* original,
-                            int residual_size, double* residual)
+        void residual_frame(c_Frame* frame)
         void find_residual(int synth_size, double* synth,
                            int original_size, double* original,
                            int residual_size, double* residual)
         void synth_frame(c_Frame* frame)
-        vector[c_Frame*] synth(int synth_size, double* synth,
-                               int original_size, double* original)
+        vector[c_Frame*] synth(int original_size, double* original)
 
     cdef cppclass c_SMSResidual "simpl::SMSResidual"(c_Residual):
         c_SMSResidual()
diff --git a/simpl/residual.pyx b/simpl/residual.pyx
index 2d70ff5..4f27deb 100644
--- a/simpl/residual.pyx
+++ b/simpl/residual.pyx
@@ -33,13 +33,9 @@ cdef class Residual:
             print 'setting hop size...'
             self.thisptr.hop_size(i)
 
-    def residual_frame(self, np.ndarray[dtype_t, ndim=1] synth,
-                       np.ndarray[dtype_t, ndim=1] original):
-        cdef np.ndarray[dtype_t, ndim=1] residual = np.zeros(len(synth))
-        self.thisptr.residual_frame(len(synth), <double*> synth.data,
-                                    len(original), <double*> original.data,
-                                    len(residual), <double*> residual.data)
-        return residual
+    def residual_frame(self, Frame frame not None):
+        self.thisptr.residual_frame(frame.thisptr)
+        return frame.residual
 
     def find_residual(self, np.ndarray[dtype_t, ndim=1] synth,
                       np.ndarray[dtype_t, ndim=1] original):
@@ -53,10 +49,9 @@ cdef class Residual:
         self.thisptr.synth_frame(frame.thisptr)
         return frame.audio
 
-    def synth(self, np.ndarray[dtype_t, ndim=1] synth, np.ndarray[dtype_t, ndim=1] original):
+    def synth(self, np.ndarray[dtype_t, ndim=1] original):
         cdef int hop = self.thisptr.hop_size()
         cdef vector[c_Frame*] output_frames = self.thisptr.synth(
-            len(synth), <double*> synth.data,
             len(original), <double*> original.data
         )
 
diff --git a/src/simpl/residual.cpp b/src/simpl/residual.cpp
index 5b8b8be..6d2c4c7 100644
--- a/src/simpl/residual.cpp
+++ b/src/simpl/residual.cpp
@@ -37,18 +37,18 @@ void Residual::sampling_rate(int new_sampling_rate) {
     _sampling_rate = new_sampling_rate;
 }
 
-void Residual::residual_frame(int synth_size, sample* synth,
-                              int original_size, sample* original,
-                              int residual_size, sample* residual) {
+void Residual::residual_frame(Frame* frame) {
 }
 
 void Residual::find_residual(int synth_size, sample* synth,
                              int original_size, sample* original,
                              int residual_size, sample* residual) {
     for(int i = 0; i < synth_size; i += _hop_size) {
-        residual_frame(_hop_size, &synth[i],
-                       _hop_size, &original[i],
-                       _hop_size, &residual[i]);
+        Frame* f = new Frame(_hop_size);
+        f->audio(&original[i]);
+        f->synth(&synth[i]);
+        f->residual(&residual[i]);
+        residual_frame(f);
     }
 }
 
@@ -63,14 +63,12 @@ Frames Residual::synth(Frames& frames) {
     return frames;
 }
 
-Frames Residual::synth(int synth_size, sample* synth,
-                       int original_size, sample* original) {
+Frames Residual::synth(int original_size, sample* original) {
     Frames frames;
 
-    for(int i = 0; i < min(synth_size, original_size) - _hop_size; i += _hop_size) {
+    for(int i = 0; i <= original_size - _hop_size; i += _hop_size) {
         Frame* f = new Frame(_hop_size, true);
         f->audio(&original[i]);
-        f->synth(&synth[i]);
         synth_frame(f);
         frames.push_back(f);
     }
@@ -89,11 +87,23 @@ SMSResidual::SMSResidual() {
     sms_initResidualParams(&_residual_params);
     _residual_params.hopSize = _hop_size;
     sms_initResidual(&_residual_params);
+
+    _temp_synth = new sample[_hop_size];
+
+    _pd.hop_size(_hop_size);
+    _pd.realtime(1);
+    _synth.hop_size(_hop_size);
+    _synth.det_synthesis_type(SMS_STYPE_DET);
 }
 
 SMSResidual::~SMSResidual() {
     sms_freeResidual(&_residual_params);
     sms_free();
+
+    if(_temp_synth) {
+        delete[] _temp_synth;
+    }
+    _temp_synth = NULL;
 }
 
 void SMSResidual::hop_size(int new_hop_size) {
@@ -102,6 +112,11 @@ void SMSResidual::hop_size(int new_hop_size) {
     sms_freeResidual(&_residual_params);
     _residual_params.hopSize = _hop_size;
     sms_initResidual(&_residual_params);
+
+    if(_temp_synth) {
+        delete[] _temp_synth;
+    }
+    _temp_synth = new sample[_hop_size];
 }
 
 int SMSResidual::num_stochastic_coeffs() {
@@ -121,22 +136,24 @@ void SMSResidual::num_stochastic_coeffs(int new_num_stochastic_coeffs) {
 // void SMSResidual::stochastic_type(int new_stochastic_type) {
 // }
 
-void SMSResidual::residual_frame(int synth_size, sample* synth,
-                                 int original_size, sample* original,
-                                 int residual_size, sample* residual) {
+void SMSResidual::residual_frame(Frame* frame) {
+    frame->clear();
+    _pd.find_peaks_in_frame(frame);
+    _pt.update_partials(frame);
+    _synth.synth_frame(frame);
 
-    sms_findResidual(synth_size, synth, original_size, original, &_residual_params);
+    sms_findResidual(frame->size(), frame->synth(),
+                     frame->size(), frame->audio(),
+                     &_residual_params);
 
-    for(int i = 0; i < residual_size; i++) {
-        residual[i] = _residual_params.residual[i];
+    for(int i = 0; i < frame->size(); i++) {
+        frame->residual()[i] = _residual_params.residual[i];
     }
 }
 
 // Calculate and return one frame of the synthesised residual signal
 void SMSResidual::synth_frame(Frame* frame) {
-    residual_frame(_hop_size, frame->synth(),
-                   _hop_size, frame->audio(),
-                   _hop_size, frame->residual());
+    residual_frame(frame);
     sms_approxResidual(_hop_size, frame->residual(),
                        _hop_size, frame->synth_residual(),
                        &_residual_params);
diff --git a/src/simpl/residual.h b/src/simpl/residual.h
index 0125417..d3b7b59 100644
--- a/src/simpl/residual.h
+++ b/src/simpl/residual.h
@@ -2,6 +2,9 @@
 #define RESIDUAL_H
 
 #include "base.h"
+#include "peak_detection.h"
+#include "partial_tracking.h"
+#include "synthesis.h"
 
 extern "C" {
     #include "sms.h"
@@ -34,17 +37,14 @@ class Residual {
         int sampling_rate();
         void sampling_rate(int new_sampling_rate);
 
-        virtual void residual_frame(int synth_size, sample* synth,
-                                    int original_size, sample* original,
-                                    int residual_size, sample* residual);
+        virtual void residual_frame(Frame* frame);
         virtual void find_residual(int synth_size, sample* synth,
                                    int original_size, sample* original,
                                    int residual_size, sample* residual);
 
         virtual void synth_frame(Frame* frame);
         virtual Frames synth(Frames& frames);
-        virtual Frames synth(int synth_size, sample* synth,
-                             int original_size, sample* original);
+        virtual Frames synth(int original_size, sample* original);
 };
 
 
@@ -53,22 +53,28 @@ class Residual {
 // ---------------------------------------------------------------------------
 class SMSResidual : public Residual {
     private:
+        sample* _temp_synth;
         SMSResidualParams _residual_params;
 
+        SMSPeakDetection _pd;
+        SMSPartialTracking _pt;
+        SMSSynthesis _synth;
+
     public:
         SMSResidual();
         ~SMSResidual();
         void hop_size(int new_hop_size);
         int num_stochastic_coeffs();
         void num_stochastic_coeffs(int new_num_stochastic_coeffs);
+
         // int stochastic_type();
         // void stochastic_type(int new_stochastic_type);
-        void residual_frame(int synth_size, sample* synth,
-                            int original_size, sample* original,
-                            int residual_size, sample* residual);
+
+        void residual_frame(Frame* frame);
         void synth_frame(Frame* frame);
 };
 
+
 } // end of namespace Simpl
 
 #endif
diff --git a/tests/test_residual.py b/tests/test_residual.py
index e3992a8..006c77a 100644
--- a/tests/test_residual.py
+++ b/tests/test_residual.py
@@ -75,23 +75,9 @@ class TestSMSResidual(object):
         assert len(residual_audio)
 
     def test_residual_synthesis(self):
-        pd = SMSPeakDetection()
-        pd.max_peaks = max_peaks
-        pd.hop_size = hop_size
-        frames = pd.find_peaks(self.audio)
-
-        pt = SMSPartialTracking()
-        pt.max_partials = max_partials
-        frames = pt.find_partials(frames)
-
-        synth = SMSSynthesis()
-        synth.hop_size = hop_size
-        synth.max_partials = max_partials
-        simpl_harmonic = synth.synth(frames)
-
         res = SMSResidual()
         res.hop_size = hop_size
-        simpl_residual = res.synth(simpl_harmonic, self.audio)
+        simpl_residual = res.synth(self.audio)
 
         sms_residual, sampling_rate = simpl.read_wav(
             libsms_residual_synthesis_path
@@ -99,10 +85,10 @@ class TestSMSResidual(object):
 
         assert len(simpl_residual) == len(sms_residual)
 
-        # import matplotlib.pyplot as plt
-        # plt.plot(simpl_residual)
-        # plt.plot(sms_residual)
-        # plt.show()
+        import matplotlib.pyplot as plt
+        plt.plot(simpl_residual)
+        plt.plot(sms_residual)
+        plt.show()
 
         for i in range(len(simpl_residual)):
             assert_almost_equals(simpl_residual[i], sms_residual[i],