diff options
Diffstat (limited to 'tests')
| -rw-r--r-- | tests/Makefile | 19 | ||||
| -rw-r--r-- | tests/create_libsms_test_data.py | 345 | ||||
| -rw-r--r-- | tests/debug.py | 29 | ||||
| -rw-r--r-- | tests/signals.py | 16 | ||||
| -rw-r--r-- | tests/simpl.supp | 19 | ||||
| -rw-r--r-- | tests/test_base.cpp | 370 | ||||
| -rw-r--r-- | tests/test_base.py | 70 | ||||
| -rw-r--r-- | tests/test_lp.py | 22 | ||||
| -rw-r--r-- | tests/test_partial_tracking.py | 108 | ||||
| -rw-r--r-- | tests/test_peak_detection.py | 104 | ||||
| -rw-r--r-- | tests/test_peakdetection.py | 24 | ||||
| -rw-r--r-- | tests/test_residual.py | 95 | ||||
| -rw-r--r-- | tests/test_sms.py | 1266 | ||||
| -rw-r--r-- | tests/test_sms_old.py | 126 | ||||
| -rw-r--r-- | tests/test_sndobj.py | 19 | ||||
| -rw-r--r-- | tests/test_synthesis.py | 126 |
16 files changed, 1261 insertions, 1497 deletions
diff --git a/tests/Makefile b/tests/Makefile new file mode 100644 index 0000000..c5374f3 --- /dev/null +++ b/tests/Makefile @@ -0,0 +1,19 @@ +CC=g++ +CFLAGS=-Wall -c -g + +all: testbase + +testbase: testbase.o base.o exceptions.o + $(CC) testbase.o base.o exceptions.o -o testbase -lcppunit + +testbase.o: testbase.cpp + $(CC) $(CFLAGS) testbase.cpp + +base.o: ../src/simpl/base.cpp + $(CC) $(CFLAGS) ../src/simpl/base.cpp + +exceptions.o: ../src/simpl/exceptions.cpp + $(CC) $(CFLAGS) ../src/simpl/exceptions.cpp + +clean: + rm -rf *.o testbase diff --git a/tests/create_libsms_test_data.py b/tests/create_libsms_test_data.py new file mode 100644 index 0000000..05b8cee --- /dev/null +++ b/tests/create_libsms_test_data.py @@ -0,0 +1,345 @@ +import os +import json +import numpy as np +import scipy.io.wavfile as wav +import pysms +import simpl + +float_precision = 5 +frame_size = 512 +hop_size = 512 +max_peaks = 10 +max_partials = 10 +num_frames = 30 +num_samples = num_frames * hop_size +audio_path = os.path.join( + os.path.dirname(__file__), 'audio/flute.wav' +) + +audio, sampling_rate = simpl.read_wav(audio_path) + + +def _pysms_analysis_params(sampling_rate): + analysis_params = pysms.SMS_AnalParams() + pysms.sms_initAnalParams(analysis_params) + analysis_params.iSamplingRate = sampling_rate + analysis_params.iFrameRate = sampling_rate / hop_size + analysis_params.iWindowType = pysms.SMS_WIN_HAMMING + analysis_params.fHighestFreq = 20000 + analysis_params.iFormat = pysms.SMS_FORMAT_HP + analysis_params.nTracks = max_peaks + analysis_params.peakParams.iMaxPeaks = max_peaks + analysis_params.nGuides = max_peaks + analysis_params.iMaxDelayFrames = 4 + analysis_params.analDelay = 0 + analysis_params.minGoodFrames = 1 + analysis_params.iCleanTracks = 0 + analysis_params.iStochasticType = pysms.SMS_STOC_NONE + analysis_params.preEmphasis = 0 + return analysis_params + + +def _pysms_synthesis_params(sampling_rate): + synth_params = pysms.SMS_SynthParams() + pysms.sms_initSynthParams(synth_params) + synth_params.iSamplingRate = sampling_rate + synth_params.iSynthesisType = pysms.SMS_STYPE_DET + synth_params.iStochasticType = pysms.SMS_STOC_NONE + synth_params.sizeHop = hop_size + synth_params.nTracks = max_partials + synth_params.deEmphasis = 0 + return synth_params + + +def _size_next_read(): + pysms.sms_init() + snd_header = pysms.SMS_SndHeader() + + # Try to open the input file to fill snd_header + if(pysms.sms_openSF(audio_path, snd_header)): + raise NameError( + "error opening sound file: " + pysms.sms_errorString() + ) + + analysis_params = _pysms_analysis_params(sampling_rate) + analysis_params.iMaxDelayFrames = num_frames + 1 + if pysms.sms_initAnalysis(analysis_params, snd_header) != 0: + raise Exception("Error allocating memory for analysis_params") + analysis_params.nFrames = num_frames + sms_header = pysms.SMS_Header() + pysms.sms_fillHeader(sms_header, analysis_params, "pysms") + + sample_offset = 0 + pysms_size_new_data = 0 + current_frame = 0 + next_read_sizes = [] + + while current_frame < num_frames: + next_read_sizes.append(analysis_params.sizeNextRead) + sample_offset += pysms_size_new_data + pysms_size_new_data = analysis_params.sizeNextRead + + # convert frame to floats for libsms + frame = audio[sample_offset:sample_offset + pysms_size_new_data] + frame = np.array(frame, dtype=np.float32) + if len(frame) < pysms_size_new_data: + frame = np.hstack(( + frame, np.zeros(pysms_size_new_data - len(frame), + dtype=np.float32) + )) + + analysis_data = pysms.SMS_Data() + pysms.sms_allocFrameH(sms_header, analysis_data) + status = pysms.sms_analyze(frame, analysis_data, analysis_params) + # as the no. of frames of delay is > num_frames, sms_analyze should + # never get around to performing partial tracking, and so the + # return value should be 0 + assert status == 0 + pysms.sms_freeFrame(analysis_data) + current_frame += 1 + + pysms.sms_freeAnalysis(analysis_params) + pysms.sms_closeSF() + pysms.sms_free() + + return next_read_sizes + + +def _partial_tracking(): + pysms.sms_init() + snd_header = pysms.SMS_SndHeader() + + if(pysms.sms_openSF(audio_path, snd_header)): + raise NameError(pysms.sms_errorString()) + + analysis_params = _pysms_analysis_params(sampling_rate) + if pysms.sms_initAnalysis(analysis_params, snd_header) != 0: + raise Exception("Error allocating memory for analysis_params") + analysis_params.iSizeSound = num_samples + analysis_params.nFrames = num_frames + sms_header = pysms.SMS_Header() + pysms.sms_fillHeader(sms_header, analysis_params, "pysms") + + sample_offset = 0 + size_new_data = 0 + current_frame = 0 + sms_frames = [] + do_analysis = True + + while do_analysis and (current_frame < num_frames): + sample_offset += size_new_data + size_new_data = analysis_params.sizeNextRead + + frame_audio = audio[sample_offset:sample_offset + size_new_data] + frame_audio = np.array(frame_audio, dtype=np.float32) + if len(frame_audio) < size_new_data: + frame_audio = np.hstack(( + frame_audio, np.zeros(size_new_data - len(frame_audio), + dtype=np.float32) + )) + + analysis_data = pysms.SMS_Data() + pysms.sms_allocFrameH(sms_header, analysis_data) + num_partials = analysis_data.nTracks + status = pysms.sms_analyze(frame_audio, analysis_data, + analysis_params) + + sms_freqs = np.zeros(num_partials, dtype=np.float32) + sms_amps = np.zeros(num_partials, dtype=np.float32) + sms_phases = np.zeros(num_partials, dtype=np.float32) + + frame = {'status': status} + frame['partials'] = [] + + if status == 1: + analysis_data.getSinFreq(sms_freqs) + analysis_data.getSinAmp(sms_amps) + analysis_data.getSinPhase(sms_phases) + current_frame += 1 + + if status == -1: + do_analysis = False + + for i in range(num_partials): + frame['partials'].append({ + 'n': i, + 'amplitude': float(sms_amps[i]), + 'frequency': float(sms_freqs[i]), + 'phase': float(sms_phases[i]) + }) + + sms_frames.append(frame) + pysms.sms_freeFrame(analysis_data) + + pysms.sms_freeAnalysis(analysis_params) + pysms.sms_closeSF() + pysms.sms_free() + + return sms_frames + + +def _harmonic_synthesis(det_synth_type): + pysms.sms_init() + snd_header = pysms.SMS_SndHeader() + + if(pysms.sms_openSF(audio_path, snd_header)): + raise NameError(pysms.sms_errorString()) + + analysis_params = _pysms_analysis_params(sampling_rate) + if pysms.sms_initAnalysis(analysis_params, snd_header) != 0: + raise Exception("Error allocating memory for analysis_params") + analysis_params.iSizeSound = num_samples + analysis_params.nFrames = num_frames + sms_header = pysms.SMS_Header() + pysms.sms_fillHeader(sms_header, analysis_params, "pysms") + + sample_offset = 0 + size_new_data = 0 + current_frame = 0 + analysis_frames = [] + do_analysis = True + + while do_analysis and (current_frame < num_frames): + sample_offset += size_new_data + size_new_data = analysis_params.sizeNextRead + + frame_audio = audio[sample_offset:sample_offset + size_new_data] + frame_audio = np.array(frame_audio, dtype=np.float32) + if len(frame_audio) < size_new_data: + frame_audio = np.hstack(( + frame_audio, np.zeros(size_new_data - len(frame_audio), + dtype=np.float32) + )) + + analysis_data = pysms.SMS_Data() + pysms.sms_allocFrameH(sms_header, analysis_data) + status = pysms.sms_analyze(frame_audio, analysis_data, + analysis_params) + + analysis_frames.append(analysis_data) + current_frame += 1 + + if status == -1: + do_analysis = False + + synth_params = _pysms_synthesis_params(sampling_rate) + if det_synth_type == 'ifft': + synth_params.iDetSynthType = pysms.SMS_DET_IFFT + elif det_synth_type == 'sin': + synth_params.iDetSynthType = pysms.SMS_DET_SIN + else: + raise Exception("Invalid deterministic synthesis type") + + pysms.sms_initSynth(sms_header, synth_params) + + synth_frame = np.zeros(synth_params.sizeHop, dtype=np.float32) + synth_audio = np.array([], dtype=np.float32) + + for i in range(len(analysis_frames)): + pysms.sms_synthesize(analysis_frames[i], synth_frame, synth_params) + synth_audio = np.hstack((synth_audio, synth_frame)) + + synth_audio = np.asarray(synth_audio * 32768, np.int16) + + for frame in analysis_frames: + pysms.sms_freeFrame(frame) + pysms.sms_freeAnalysis(analysis_params) + pysms.sms_closeSF() + pysms.sms_freeSynth(synth_params) + pysms.sms_free() + + return synth_audio + + +def _residual_synthesis(): + pysms.sms_init() + snd_header = pysms.SMS_SndHeader() + + if(pysms.sms_openSF(audio_path, snd_header)): + raise NameError(pysms.sms_errorString()) + + analysis_params = _pysms_analysis_params(sampling_rate) + analysis_params.nStochasticCoeff = 128 + analysis_params.iStochasticType = pysms.SMS_STOC_APPROX + if pysms.sms_initAnalysis(analysis_params, snd_header) != 0: + raise Exception("Error allocating memory for analysis_params") + analysis_params.iSizeSound = num_samples + analysis_params.nFrames = num_frames + sms_header = pysms.SMS_Header() + pysms.sms_fillHeader(sms_header, analysis_params, "pysms") + + sample_offset = 0 + size_new_data = 0 + current_frame = 0 + analysis_frames = [] + do_analysis = True + + while do_analysis and (current_frame < num_frames): + sample_offset += size_new_data + size_new_data = analysis_params.sizeNextRead + + frame_audio = audio[sample_offset:sample_offset + size_new_data] + frame_audio = np.array(frame_audio, dtype=np.float32) + if len(frame_audio) < size_new_data: + frame_audio = np.hstack(( + frame_audio, np.zeros(size_new_data - len(frame_audio), + dtype=np.float32) + )) + + analysis_data = pysms.SMS_Data() + pysms.sms_allocFrameH(sms_header, analysis_data) + status = pysms.sms_analyze(frame_audio, analysis_data, + analysis_params) + + analysis_frames.append(analysis_data) + current_frame += 1 + + if status == -1: + do_analysis = False + + sms_header.nFrames = len(analysis_frames) + synth_params = _pysms_synthesis_params(sampling_rate) + synth_params.iStochasticType = pysms.SMS_STOC_APPROX + synth_params.iSynthesisType = pysms.SMS_STYPE_STOC + pysms.sms_initSynth(sms_header, synth_params) + + synth_frame = np.zeros(synth_params.sizeHop, dtype=np.float32) + synth_audio = np.array([], dtype=np.float32) + + for i in range(len(analysis_frames)): + pysms.sms_synthesize(analysis_frames[i], synth_frame, synth_params) + synth_audio = np.hstack((synth_audio, synth_frame)) + + synth_audio = np.asarray(synth_audio * 32768, np.int16) + + for frame in analysis_frames: + pysms.sms_freeFrame(frame) + pysms.sms_freeAnalysis(analysis_params) + pysms.sms_closeSF() + pysms.sms_freeSynth(synth_params) + pysms.sms_free() + + return synth_audio + + +if __name__ == '__main__': + size_next_read = _size_next_read() + partial_tracking = _partial_tracking() + harmonic_synthesis_ifft = _harmonic_synthesis('ifft') + harmonic_synthesis_sin = _harmonic_synthesis('sin') + residual_synthesis = _residual_synthesis() + + test_data = {'size_next_read': size_next_read, + 'peak_detection': partial_tracking, + 'partial_tracking': partial_tracking} + + test_data = json.dumps(test_data) + with open('libsms_test_data.json', 'w') as f: + f.write(test_data) + + wav.write('libsms_harmonic_synthesis_ifft.wav', sampling_rate, + harmonic_synthesis_ifft) + wav.write('libsms_harmonic_synthesis_sin.wav', sampling_rate, + harmonic_synthesis_sin) + wav.write('libsms_residual_synthesis.wav', sampling_rate, + residual_synthesis) diff --git a/tests/debug.py b/tests/debug.py deleted file mode 100644 index 084df72..0000000 --- a/tests/debug.py +++ /dev/null @@ -1,29 +0,0 @@ -# Copyright (c) 2010 John Glover, National University of Ireland, Maynooth -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program 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 General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - -def print_peaks(frames): - for n, f in enumerate(frames): - for p in f: - print str(n) + ":", p.frequency - -def print_partials(partials): - for partial_num, partial in enumerate(partials): - print partial_num, - print "(" + str(partial.starting_frame) + " to", - print str(partial.starting_frame + len(partial.peaks)) + "):", - for peak_number, peak in enumerate(partial.peaks): - print peak.frequency, - print diff --git a/tests/signals.py b/tests/signals.py index 5b04c03..8083f94 100644 --- a/tests/signals.py +++ b/tests/signals.py @@ -1,19 +1,3 @@ -# Copyright (c) 2010 John Glover, National University of Ireland, Maynooth -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program 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 General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - import simpl import numpy as np diff --git a/tests/simpl.supp b/tests/simpl.supp new file mode 100644 index 0000000..8f8239e --- /dev/null +++ b/tests/simpl.supp @@ -0,0 +1,19 @@ +# Valgrind suppression file for Simpl + +# On Mac OS X 10.6 Snow Leopard, throwing std::exceptions gives a memory leak +{ + simpl.exceptions + Memcheck:Leak + fun:malloc + fun:__cxa_get_globals + fun:__cxa_allocate_exception + fun:_ZN5Simpl4Peak7is_freeESs + fun:_ZN5Simpl8TestPeak29test_is_free_invalid_argumentEv + fun:_ZN7CppUnit10TestCallerIN5Simpl8TestPeakEE7runTestEv + fun:_ZNK7CppUnit21TestCaseMethodFunctorclEv + fun:_ZN7CppUnit16DefaultProtector7protectERKNS_7FunctorERKNS_16ProtectorContextE + fun:_ZNK7CppUnit14ProtectorChain14ProtectFunctorclEv + fun:_ZN7CppUnit14ProtectorChain7protectERKNS_7FunctorERKNS_16ProtectorContextE + fun:_ZN7CppUnit10TestResult7protectERKNS_7FunctorEPNS_4TestERKSs + fun:_ZN7CppUnit8TestCase3runEPNS_10TestResultE +} diff --git a/tests/test_base.cpp b/tests/test_base.cpp new file mode 100644 index 0000000..a37024f --- /dev/null +++ b/tests/test_base.cpp @@ -0,0 +1,370 @@ +#include <iostream> +#include <cppunit/ui/text/TextTestRunner.h> +#include <cppunit/TestResult.h> +#include <cppunit/TestResultCollector.h> +#include <cppunit/extensions/HelperMacros.h> +#include <cppunit/BriefTestProgressListener.h> +#include <cppunit/extensions/TestFactoryRegistry.h> + +#include "../src/simpl/base.h" +#include "../src/simpl/exceptions.h" + +namespace Simpl +{ + +// --------------------------------------------------------------------------- +// TestPeak +// --------------------------------------------------------------------------- +class TestPeak : public CPPUNIT_NS::TestCase +{ + CPPUNIT_TEST_SUITE(TestPeak); + CPPUNIT_TEST(test_constructor); + CPPUNIT_TEST(test_is_start_of_partial); + CPPUNIT_TEST(test_is_free); + CPPUNIT_TEST(test_is_free_invalid_argument); + CPPUNIT_TEST_SUITE_END(); + +protected: + static const double PRECISION = 0.001; + Peak* peak; + + void test_constructor() + { + CPPUNIT_ASSERT_DOUBLES_EQUAL(peak->amplitude, 0.0, PRECISION); + CPPUNIT_ASSERT_DOUBLES_EQUAL(peak->frequency, 0.0, PRECISION); + CPPUNIT_ASSERT_DOUBLES_EQUAL(peak->phase, 0.0, PRECISION); + CPPUNIT_ASSERT(peak->next_peak == NULL); + CPPUNIT_ASSERT(peak->previous_peak == NULL); + CPPUNIT_ASSERT(peak->partial_id == 0); + CPPUNIT_ASSERT(peak->partial_position == 0); + CPPUNIT_ASSERT(peak->frame_number == 0); + } + + void test_is_start_of_partial() + { + CPPUNIT_ASSERT(peak->is_start_of_partial()); + Peak* tmp = new Peak(); + peak->previous_peak = tmp; + CPPUNIT_ASSERT(!peak->is_start_of_partial()); + peak->previous_peak = NULL; + delete tmp; + } + + void test_is_free() + { + peak->amplitude = 0.0; + CPPUNIT_ASSERT(!peak->is_free()); + peak->amplitude = 1.0; + CPPUNIT_ASSERT(peak->is_free()); + + Peak* tmp = new Peak(); + + peak->next_peak = tmp; + CPPUNIT_ASSERT(!peak->is_free()); + CPPUNIT_ASSERT(!peak->is_free("forwards")); + CPPUNIT_ASSERT(peak->is_free("backwards")); + peak->next_peak = NULL; + + peak->previous_peak = tmp; + CPPUNIT_ASSERT(peak->is_free()); + CPPUNIT_ASSERT(peak->is_free("forwards")); + CPPUNIT_ASSERT(!peak->is_free("backwards")); + peak->previous_peak = NULL; + + delete tmp; + } + + void test_is_free_invalid_argument() + { + peak->amplitude = 1.0; + CPPUNIT_ASSERT_THROW(peak->is_free("random_text"), InvalidArgument); + peak->amplitude = 0.0; + } + +public: + void setUp() + { + peak = new Peak(); + } + + void tearDown() + { + delete peak; + } +}; + +// --------------------------------------------------------------------------- +// TestFrame +// --------------------------------------------------------------------------- +class TestFrame : public CPPUNIT_NS::TestCase +{ + CPPUNIT_TEST_SUITE(TestFrame); + CPPUNIT_TEST(test_constructor); + CPPUNIT_TEST(test_size); + CPPUNIT_TEST(test_max_peaks); + CPPUNIT_TEST(test_max_partials); + CPPUNIT_TEST(test_add_peak); + CPPUNIT_TEST(test_add_peaks); + CPPUNIT_TEST(test_peak_clear); + CPPUNIT_TEST(test_peak_iteration); + CPPUNIT_TEST_SUITE_END(); + +protected: + static const double PRECISION = 0.001; + Frame* frame; + + void test_constructor() + { + CPPUNIT_ASSERT(frame->size() == 512); + CPPUNIT_ASSERT(frame->max_peaks() == 100); + CPPUNIT_ASSERT(frame->num_peaks() == 0); + CPPUNIT_ASSERT(frame->max_partials() == 100); + CPPUNIT_ASSERT(frame->num_partials() == 0); + } + + void test_size() + { + frame->size(1024); + CPPUNIT_ASSERT(frame->size() == 1024); + frame->size(512); + } + + void test_max_peaks() + { + frame->max_peaks(200); + CPPUNIT_ASSERT(frame->max_peaks() == 200); + CPPUNIT_ASSERT(frame->num_peaks() == 0); + frame->max_peaks(100); + } + + void test_max_partials() + { + frame->max_partials(200); + CPPUNIT_ASSERT(frame->max_partials() == 200); + CPPUNIT_ASSERT(frame->num_partials() == 0); + frame->max_partials(100); + } + + void test_add_peak() + { + Peak p = Peak(); + p.amplitude = 1.5; + frame->add_peak(p); + CPPUNIT_ASSERT(frame->max_peaks() == 100); + CPPUNIT_ASSERT(frame->num_peaks() == 1); + CPPUNIT_ASSERT_DOUBLES_EQUAL(1.5, frame->peak(0).amplitude, PRECISION); + frame->clear_peaks(); + } + + void test_add_peaks() + { + Peaks* peaks = new Peaks(); + + Peak p1 = Peak(); + p1.amplitude = 1.0; + peaks->push_back(p1); + + Peak p2 = Peak(); + p2.amplitude = 2.0; + peaks->push_back(p2); + + frame->add_peaks(peaks); + CPPUNIT_ASSERT(frame->num_peaks() == 2); + + frame->clear_peaks(); + delete peaks; + } + + void test_peak_clear() + { + Peak p = Peak(); + p.amplitude = 1.5; + frame->add_peak(p); + CPPUNIT_ASSERT(frame->num_peaks() == 1); + frame->clear_peaks(); + CPPUNIT_ASSERT(frame->num_peaks() == 0); + } + + void test_peak_iteration() + { + Peak p1 = Peak(); + p1.amplitude = 1.0; + frame->add_peak(p1); + + Peak p2 = Peak(); + p2.amplitude = 2.0; + frame->add_peak(p2); + + CPPUNIT_ASSERT(frame->num_peaks() == 2); + + int peak_num = 0; + for(Peaks::iterator i = frame->peaks_begin(); i != frame->peaks_end(); i++) + { + if(peak_num == 0) + { + CPPUNIT_ASSERT_DOUBLES_EQUAL(1.0, i->amplitude, PRECISION); + } + else if(peak_num == 1) + { + CPPUNIT_ASSERT_DOUBLES_EQUAL(2.0, i->amplitude, PRECISION); + } + peak_num += 1; + } + frame->clear_peaks(); + } + +public: + void setUp() + { + frame = new Frame(); + } + + void tearDown() + { + delete frame; + } +}; + +// --------------------------------------------------------------------------- +// TestPeakDetection +// --------------------------------------------------------------------------- +class TestPeakDetection : public CPPUNIT_NS::TestCase +{ + CPPUNIT_TEST_SUITE(TestPeakDetection); + CPPUNIT_TEST(test_constructor); + CPPUNIT_TEST(test_frame_size); + CPPUNIT_TEST(test_static_frame_size); + CPPUNIT_TEST(test_next_frame_size); + CPPUNIT_TEST(test_hop_size); + CPPUNIT_TEST(test_max_peaks); + CPPUNIT_TEST(test_window_type); + CPPUNIT_TEST(test_window_size); + CPPUNIT_TEST(test_min_peak_separation); + CPPUNIT_TEST(test_find_peaks_in_frame); + CPPUNIT_TEST(test_find_peaks); + CPPUNIT_TEST_SUITE_END(); + +protected: + static const double PRECISION = 0.001; + PeakDetection* pd; + + void test_constructor() + { + CPPUNIT_ASSERT(pd->sampling_rate() == 44100); + CPPUNIT_ASSERT(pd->frame_size() == 2048); + CPPUNIT_ASSERT(pd->static_frame_size()); + CPPUNIT_ASSERT(pd->hop_size() == 512); + CPPUNIT_ASSERT(pd->max_peaks() == 100); + CPPUNIT_ASSERT(pd->window_type() == "hamming"); + CPPUNIT_ASSERT(pd->window_size() == 2048); + CPPUNIT_ASSERT_DOUBLES_EQUAL(1.0, pd->min_peak_separation(), 0.00001); + CPPUNIT_ASSERT(pd->frames()->size() == 0); + } + + void test_sampling_rate() + { + pd->sampling_rate(96000); + CPPUNIT_ASSERT(pd->sampling_rate() == 96000); + pd->sampling_rate(44100); + } + + void test_frame_size() + { + pd->frame_size(1024); + CPPUNIT_ASSERT(pd->frame_size() == 1024); + pd->frame_size(2048); + } + + void test_static_frame_size() + { + pd->static_frame_size(false); + CPPUNIT_ASSERT(!pd->static_frame_size()); + pd->static_frame_size(true); + } + + void test_next_frame_size() + { + CPPUNIT_ASSERT(pd->next_frame_size() == pd->frame_size()); + } + + void test_hop_size() + { + pd->hop_size(128); + CPPUNIT_ASSERT(pd->hop_size() == 128); + pd->hop_size(512); + } + + void test_max_peaks() + { + pd->max_peaks(20); + CPPUNIT_ASSERT(pd->max_peaks() == 20); + pd->max_peaks(100); + } + + void test_window_type() + { + pd->window_type("hanning"); + CPPUNIT_ASSERT(pd->window_type() == "hanning"); + pd->window_type("hamming"); + } + + void test_window_size() + { + pd->window_size(2048); + CPPUNIT_ASSERT(pd->window_size() == 2048); + pd->window_size(2048); + } + + void test_min_peak_separation() + { + pd->min_peak_separation(0.5); + CPPUNIT_ASSERT_DOUBLES_EQUAL(0.5, pd->min_peak_separation(), 0.00001); + pd->min_peak_separation(1.0); + } + + void test_find_peaks_in_frame() + { + Frame* f = new Frame(); + Peaks* p = pd->find_peaks_in_frame(*f); + CPPUNIT_ASSERT(p->size() == 0); + delete p; + delete f; + } + + void test_find_peaks() + { + const samples audio = samples(1024); + pd->frame_size(256); + pd->hop_size(256); + Frames* frames = pd->find_peaks(audio); + CPPUNIT_ASSERT(frames->size() == 4); + for(Frames::iterator i = frames->begin(); i != frames->end(); i++) + { + CPPUNIT_ASSERT(i->num_peaks() == 0); + } + } + +public: + void setUp() + { + pd = new PeakDetection(); + } + + void tearDown() + { + delete pd; + } +}; + +} // end of namespace Simpl + +CPPUNIT_TEST_SUITE_REGISTRATION(Simpl::TestPeak); +CPPUNIT_TEST_SUITE_REGISTRATION(Simpl::TestFrame); +CPPUNIT_TEST_SUITE_REGISTRATION(Simpl::TestPeakDetection); + +int main(int arg, char **argv) +{ + CppUnit::TextTestRunner runner; + runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest()); + return runner.run("", false); +} diff --git a/tests/test_base.py b/tests/test_base.py new file mode 100644 index 0000000..9d3173a --- /dev/null +++ b/tests/test_base.py @@ -0,0 +1,70 @@ +import os +import numpy as np +from nose.tools import assert_almost_equals +import simpl.base as base + +float_precision = 5 +frame_size = 512 +hop_size = 512 +audio_path = os.path.join( + os.path.dirname(__file__), 'audio/flute.wav' +) + + +class TestFrame(object): + def test_buffers(self): + N = 256 + f = base.Frame(N) + assert f.size == N + + a = np.random.rand(N) + f.audio = a + assert np.all(f.audio == a) + + a = np.random.rand(N) + f.synth = a + assert np.all(f.synth == a) + + a = np.random.rand(N) + f.residual = a + assert np.all(f.residual == a) + + a = np.random.rand(N) + f.synth_residual = a + assert np.all(f.synth_residual == a) + + def test_peaks(self): + p = base.Peak() + p.amplitude = 0.5 + p.frequency = 220.0 + p.phase = 0.0 + + f = base.Frame() + assert f.num_peaks == 0 + assert f.max_peaks > 0 + f.add_peak(p) + + assert f.num_peaks == 1 + assert_almost_equals(f.peak(0).amplitude, p.amplitude, + float_precision) + assert_almost_equals(f.peaks[0].amplitude, p.amplitude, + float_precision) + + f.clear() + assert f.num_peaks == 0 + + def test_partials(self): + N = 256 + f = base.Frame(N) + f.max_partials = 10 + + p = base.Peak() + p.amplitude = 0.5 + p.frequency = 220.0 + p.phase = 0.0 + + f.partial(0, p) + assert_almost_equals(f.partial(0).amplitude, p.amplitude, + float_precision) + assert_almost_equals(f.partial(0).frequency, p.frequency, + float_precision) diff --git a/tests/test_lp.py b/tests/test_lp.py index 8d80ba2..4537f46 100644 --- a/tests/test_lp.py +++ b/tests/test_lp.py @@ -1,28 +1,12 @@ -# Copyright (c) 2010 John Glover, National University of Ireland, Maynooth -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program 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 General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - from simpl import lp import numpy as np -class TestLP(object): +class TestLP(object): def test_predict(self): """test_predict""" - coefs = np.array([1,2,3,4,5]) + coefs = np.array([1, 2, 3, 4, 5]) test_signal = np.ones(5) predictions = lp.predict(test_signal, coefs, 2) assert predictions[0] == -sum(coefs) - assert predictions[1] == -sum(coefs[1:])-predictions[0] + assert predictions[1] == -sum(coefs[1:]) - predictions[0] diff --git a/tests/test_partial_tracking.py b/tests/test_partial_tracking.py new file mode 100644 index 0000000..32f2653 --- /dev/null +++ b/tests/test_partial_tracking.py @@ -0,0 +1,108 @@ +import os +import json +from nose.tools import assert_almost_equals +import simpl +import simpl.peak_detection as peak_detection +import simpl.partial_tracking as partial_tracking + +PeakDetection = peak_detection.PeakDetection +SMSPeakDetection = peak_detection.SMSPeakDetection +PartialTracking = partial_tracking.PartialTracking +SMSPartialTracking = partial_tracking.SMSPartialTracking + +float_precision = 2 +frame_size = 512 +hop_size = 512 +max_peaks = 10 +max_partials = 10 +num_frames = 30 +num_samples = num_frames * hop_size +audio_path = os.path.join( + os.path.dirname(__file__), 'audio/flute.wav' +) +libsms_test_data_path = os.path.join( + os.path.dirname(__file__), 'libsms_test_data.json' +) + + +def _load_libsms_test_data(): + test_data = None + with open(libsms_test_data_path, 'r') as f: + test_data = json.loads(f.read()) + return test_data + + +class TestPartialTracking(object): + @classmethod + def setup_class(cls): + cls.audio = simpl.read_wav(audio_path)[0] + cls.audio = cls.audio[0:num_samples] + + def test_basic(self): + pd = PeakDetection() + pd.hop_size = hop_size + frames = pd.find_peaks(self.audio) + + pt = PartialTracking() + frames = pt.find_partials(frames) + + print 'frames: %d (expected: %d)' %\ + (len(frames), len(self.audio) / hop_size) + assert len(frames) == len(self.audio) / hop_size + + assert len(frames[0].partials) == 0 + assert frames[0].max_partials == 100 + + +class TestSMSPartialTracking(object): + @classmethod + def setup_class(cls): + cls.audio = simpl.read_wav(audio_path)[0] + cls.audio = cls.audio[0:num_samples] + cls.test_data = _load_libsms_test_data() + + def test_basic(self): + pd = SMSPeakDetection() + pd.hop_size = hop_size + pd.max_peaks = max_peaks + pd.static_frame_size = True + frames = pd.find_peaks(self.audio) + + pt = SMSPartialTracking() + pt.max_partials = max_partials + frames = pt.find_partials(frames) + + print 'frames: %d (expected: %d)' %\ + (len(frames), len(self.audio) / hop_size) + assert len(frames) == len(self.audio) / hop_size + + assert frames[0].num_partials == max_partials + assert frames[0].max_partials == max_partials + + def test_partial_tracking(self): + pd = SMSPeakDetection() + pd.max_peaks = max_peaks + pd.hop_size = hop_size + peaks = pd.find_peaks(self.audio) + pt = SMSPartialTracking() + pt.max_partials = max_partials + frames = pt.find_partials(peaks) + + sms_frames = self.test_data['partial_tracking'] + sms_frames = sms_frames[0:len(sms_frames) - 3] + + assert len(sms_frames) == len(frames) + + for i in range(len(frames)): + assert len(frames[i].partials) == len(sms_frames[i]['partials']) + + for p in range(len(frames[i].partials)): + assert_almost_equals(frames[i].partials[p].amplitude, + sms_frames[i]['partials'][p]['amplitude'], + float_precision) + assert_almost_equals(frames[i].partials[p].frequency, + sms_frames[i]['partials'][p]['frequency'], + float_precision) + assert_almost_equals(frames[i].partials[p].phase, + sms_frames[i]['partials'][p]['phase'], + float_precision) diff --git a/tests/test_peak_detection.py b/tests/test_peak_detection.py new file mode 100644 index 0000000..f339818 --- /dev/null +++ b/tests/test_peak_detection.py @@ -0,0 +1,104 @@ +import os +import json +import simpl +import simpl.peak_detection as peak_detection + +PeakDetection = peak_detection.PeakDetection +SMSPeakDetection = peak_detection.SMSPeakDetection + +float_precision = 5 +frame_size = 512 +hop_size = 512 +max_peaks = 10 +max_partials = 10 +num_frames = 30 +num_samples = num_frames * hop_size +audio_path = os.path.join( + os.path.dirname(__file__), 'audio/flute.wav' +) +test_data_path = os.path.join( + os.path.dirname(__file__), 'libsms_test_data.json' +) + + +def _load_libsms_test_data(): + test_data = None + with open(test_data_path, 'r') as f: + test_data = json.loads(f.read()) + return test_data + + +class TestPeakDetection(object): + @classmethod + def setup_class(cls): + cls.audio = simpl.read_wav(audio_path)[0] + + def test_basic(self): + pd = PeakDetection() + pd.max_peaks = max_peaks + pd.find_peaks(self.audio) + + assert len(pd.frames) == len(self.audio) / hop_size + assert len(pd.frames[0].peaks) == 0 + assert pd.frames[0].max_peaks == max_peaks + + +class TestSMSPeakDetection(object): + @classmethod + def setup_class(cls): + cls.audio = simpl.read_wav(audio_path)[0] + cls.test_data = _load_libsms_test_data() + + def test_basic(self): + pd = SMSPeakDetection() + pd.hop_size = hop_size + pd.static_frame_size = True + pd.find_peaks(self.audio) + + assert len(pd.frames) == len(self.audio) / hop_size + assert len(pd.frames[0].peaks) + + def test_size_next_read(self): + """ + Make sure SMSPeakDetection is calculating the correct value for the + size of the next frame. + """ + audio, sampling_rate = simpl.read_wav(audio_path) + + pd = SMSPeakDetection() + pd.hop_size = hop_size + pd.max_peaks = max_peaks + current_frame = 0 + sample_offset = 0 + + next_read_sizes = self.test_data['size_next_read'] + + while current_frame < num_frames: + pd.frame_size = pd.next_frame_size() + assert next_read_sizes[current_frame] == pd.frame_size,\ + (next_read_sizes[current_frame], pd.frame_size) + frame = simpl.Frame() + frame.size = pd.frame_size + frame.audio = audio[sample_offset:sample_offset + pd.frame_size] + pd.find_peaks_in_frame(frame) + sample_offset += pd.frame_size + current_frame += 1 + + def test_peak_detection(self): + audio, sampling_rate = simpl.read_wav(audio_path) + + pd = SMSPeakDetection() + pd.max_peaks = max_peaks + pd.hop_size = hop_size + frames = pd.find_peaks(audio[0:num_samples]) + + sms_frames = self.test_data['peak_detection'] + sms_frames = [f for f in sms_frames if f['status'] != 0] + + print 'frames: %d (expected: %d)' % (len(frames), len(sms_frames)) + assert len(sms_frames) == len(frames) + + for frame in frames: + assert frame.num_peaks <= max_peaks, frame.num_peaks + max_amp = max([p.amplitude for p in frame.peaks]) + assert max_amp diff --git a/tests/test_peakdetection.py b/tests/test_peakdetection.py deleted file mode 100644 index 1257f02..0000000 --- a/tests/test_peakdetection.py +++ /dev/null @@ -1,24 +0,0 @@ -# Copyright (c) 2009 John Glover, National University of Ireland, Maynooth -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program 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 General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - -import simpl -import numpy as np -from scipy.io.wavfile import read - -class TestPeakDetection(object): - frame_size = 2048 - hop_size = 512 - max_peaks = 10 diff --git a/tests/test_residual.py b/tests/test_residual.py new file mode 100644 index 0000000..006c77a --- /dev/null +++ b/tests/test_residual.py @@ -0,0 +1,95 @@ +import os +import numpy as np +from nose.tools import assert_almost_equals +import simpl +import simpl.peak_detection as peak_detection +import simpl.partial_tracking as partial_tracking +import simpl.synthesis as synthesis +import simpl.residual as residual + +float_precision = 2 +frame_size = 512 +hop_size = 512 +max_peaks = 10 +max_partials = 10 +num_frames = 30 +num_samples = num_frames * hop_size +audio_path = os.path.join( + os.path.dirname(__file__), 'audio/flute.wav' +) +libsms_residual_synthesis_path = os.path.join( + os.path.dirname(__file__), 'libsms_residual_synthesis.wav' +) + +PeakDetection = peak_detection.PeakDetection +SMSPeakDetection = peak_detection.SMSPeakDetection +PartialTracking = partial_tracking.PartialTracking +SMSPartialTracking = partial_tracking.SMSPartialTracking +Synthesis = synthesis.Synthesis +SMSSynthesis = synthesis.SMSSynthesis +Residual = residual.Residual +SMSResidual = residual.SMSResidual + + +class TestResidual(object): + @classmethod + def setup_class(cls): + cls.audio = simpl.read_wav(audio_path)[0] + + def test_basic(self): + pd = PeakDetection() + frames = pd.find_peaks(self.audio) + + pt = PartialTracking() + frames = pt.find_partials(frames) + + synth = Synthesis() + synth_audio = synth.synth(frames) + + res = Residual() + residual_audio = res.find_residual(synth_audio, self.audio) + assert len(residual_audio) + + +class TestSMSResidual(object): + @classmethod + def setup_class(cls): + cls.audio = simpl.read_wav(audio_path)[0] + cls.audio = cls.audio[0:num_samples] + + def test_basic(self): + pd = SMSPeakDetection() + 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_audio = synth.synth(frames) + + res = SMSResidual() + residual_audio = res.find_residual(synth_audio, self.audio) + assert len(residual_audio) + + def test_residual_synthesis(self): + res = SMSResidual() + res.hop_size = hop_size + simpl_residual = res.synth(self.audio) + + sms_residual, sampling_rate = simpl.read_wav( + libsms_residual_synthesis_path + ) + + assert len(simpl_residual) == len(sms_residual) + + 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], + float_precision) diff --git a/tests/test_sms.py b/tests/test_sms.py deleted file mode 100644 index ca51f3f..0000000 --- a/tests/test_sms.py +++ /dev/null @@ -1,1266 +0,0 @@ -# Copyright (c) 2009 John Glover, National University of Ireland, Maynooth -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program 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 General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - -import simpl -from simpl import simplsms -import pysms -import numpy as np -from scipy.io.wavfile import read -from nose.tools import assert_almost_equals - -class TestSimplSMS(object): - FLOAT_PRECISION = 2 # number of decimal places to check for accuracy - input_file = 'audio/flute.wav' - hop_size = 512 - num_frames = 50 - num_samples = num_frames * hop_size - max_peaks = 10 - max_partials = 10 - - def get_audio(self): - audio_data = read(self.input_file) - audio = simpl.asarray(audio_data[1]) / 32768.0 - sampling_rate = audio_data[0] - return audio[0:self.num_samples], sampling_rate - - def pysms_analysis_params(self, sampling_rate): - analysis_params = pysms.SMS_AnalParams() - pysms.sms_initAnalParams(analysis_params) - analysis_params.iSamplingRate = sampling_rate - analysis_params.iFrameRate = sampling_rate / self.hop_size - analysis_params.iWindowType = pysms.SMS_WIN_HAMMING - analysis_params.fDefaultFundamental = 100 - analysis_params.fHighestFreq = 20000 - analysis_params.iFormat = pysms.SMS_FORMAT_HP - analysis_params.nTracks = self.max_peaks - analysis_params.peakParams.iMaxPeaks = self.max_peaks - analysis_params.nGuides = self.max_peaks - analysis_params.iMaxDelayFrames = 4 - analysis_params.analDelay = 0 - analysis_params.minGoodFrames = 1 - analysis_params.iCleanTracks = 0 - analysis_params.iStochasticType = pysms.SMS_STOC_NONE - analysis_params.preEmphasis = 0 - return analysis_params - - def simplsms_analysis_params(self, sampling_rate): - analysis_params = simplsms.SMS_AnalParams() - simplsms.sms_initAnalParams(analysis_params) - analysis_params.iSamplingRate = sampling_rate - analysis_params.iFrameRate = sampling_rate / self.hop_size - analysis_params.iWindowType = simplsms.SMS_WIN_HAMMING - analysis_params.fDefaultFundamental = 100 - analysis_params.fHighestFreq = 20000 - analysis_params.iFormat = simplsms.SMS_FORMAT_HP - analysis_params.nTracks = self.max_peaks - analysis_params.maxPeaks = self.max_peaks - analysis_params.nGuides = self.max_peaks - analysis_params.iMaxDelayFrames = 4 - analysis_params.analDelay = 0 - analysis_params.minGoodFrames = 1 - analysis_params.iCleanTracks = 0 - analysis_params.iStochasticType = simplsms.SMS_STOC_NONE - analysis_params.preEmphasis = 0 - return analysis_params - - def pysms_synthesis_params(self, sampling_rate): - synth_params = pysms.SMS_SynthParams() - pysms.sms_initSynthParams(synth_params) - synth_params.iSamplingRate = sampling_rate - synth_params.iSynthesisType = pysms.SMS_STYPE_DET - synth_params.iStochasticType = pysms.SMS_STOC_NONE - synth_params.sizeHop = self.hop_size - synth_params.nTracks = self.max_peaks - synth_params.deEmphasis = 0 - return synth_params - - def test_size_next_read(self): - """test_size_next_read - Make sure pysms PeakDetection is calculating - the correct value for the size of the next frame.""" - audio, sampling_rate = self.get_audio() - pysms.sms_init() - snd_header = pysms.SMS_SndHeader() - # Try to open the input file to fill snd_header - if(pysms.sms_openSF(self.input_file, snd_header)): - raise NameError("error opening sound file: " + pysms.sms_errorString()) - analysis_params = self.pysms_analysis_params(sampling_rate) - analysis_params.iMaxDelayFrames = self.num_frames + 1 - if pysms.sms_initAnalysis(analysis_params, snd_header) != 0: - raise Exception("Error allocating memory for analysis_params") - analysis_params.nFrames = self.num_frames - sms_header = pysms.SMS_Header() - pysms.sms_fillHeader(sms_header, analysis_params, "pysms") - - sample_offset = 0 - pysms_size_new_data = 0 - current_frame = 0 - sms_next_read_sizes = [] - - while current_frame < self.num_frames: - sms_next_read_sizes.append(analysis_params.sizeNextRead) - sample_offset += pysms_size_new_data - pysms_size_new_data = analysis_params.sizeNextRead - # convert frame to floats for libsms - frame = audio[sample_offset:sample_offset + pysms_size_new_data] - frame = np.array(frame, dtype=np.float32) - if len(frame) < pysms_size_new_data: - frame = np.hstack((frame, np.zeros(pysms_size_new_data - len(frame), - dtype=np.float32))) - analysis_data = pysms.SMS_Data() - pysms.sms_allocFrameH(sms_header, analysis_data) - status = pysms.sms_analyze(frame, analysis_data, analysis_params) - # as the no. of frames of delay is > num_frames, sms_analyze should - # never get around to performing partial tracking, and so the return - # value should be 0 - assert status == 0 - pysms.sms_freeFrame(analysis_data) - current_frame += 1 - - pysms.sms_freeAnalysis(analysis_params) - pysms.sms_closeSF() - pysms.sms_free() - - pd = simpl.SMSPeakDetection() - pd.hop_size = self.hop_size - pd.max_peaks = self.max_peaks - current_frame = 0 - sample_offset = 0 - - while current_frame < self.num_frames: - pd.frame_size = pd.get_next_frame_size() - #print current_frame, sms_next_read_sizes[current_frame], pd.frame_size - assert sms_next_read_sizes[current_frame] == pd.frame_size - frame = simpl.Frame() - frame.size = pd.frame_size - frame.audio = audio[sample_offset:sample_offset + pd.frame_size] - pd.find_peaks_in_frame(frame) - sample_offset += pd.frame_size - current_frame += 1 - - def test_sms_analyze(self): - """test_sms_analyze - Make sure that the simplsms.sms_analyze function does the same thing - as the sms_analyze function from libsms.""" - audio, sampling_rate = self.get_audio() - pysms.sms_init() - snd_header = pysms.SMS_SndHeader() - # Try to open the input file to fill snd_header - if(pysms.sms_openSF(self.input_file, snd_header)): - raise NameError("error opening sound file: " + pysms.sms_errorString()) - analysis_params = self.pysms_analysis_params(sampling_rate) - if pysms.sms_initAnalysis(analysis_params, snd_header) != 0: - raise Exception("Error allocating memory for analysis_params") - analysis_params.nFrames = self.num_frames - analysis_params.iSizeSound = self.num_samples - sms_header = pysms.SMS_Header() - pysms.sms_fillHeader(sms_header, analysis_params, "pysms") - - sample_offset = 0 - size_new_data = 0 - current_frame = 0 - sms_frames = [] - do_analysis = True - - while do_analysis and (current_frame < self.num_frames): - sample_offset += size_new_data - size_new_data = analysis_params.sizeNextRead - # convert frame to floats for libsms - frame = simpl.Frame() - frame.size = size_new_data - frame.audio = np.array(audio[sample_offset:sample_offset + size_new_data], - dtype=np.float32) - if len(frame.audio) < size_new_data: - frame.audio = np.hstack((frame.audio, np.zeros(size_new_data - len(frame.audio), - dtype=np.float32))) - analysis_data = pysms.SMS_Data() - pysms.sms_allocFrameH(sms_header, analysis_data) - status = pysms.sms_analyze(frame.audio, analysis_data, analysis_params) - num_partials = analysis_data.nTracks - peaks = [] - - if status == 1: - sms_amps = np.zeros(num_partials, dtype=np.float32) - sms_freqs = np.zeros(num_partials, dtype=np.float32) - sms_phases = np.zeros(num_partials, dtype=np.float32) - analysis_data.getSinFreq(sms_freqs) - analysis_data.getSinAmp(sms_amps) - analysis_data.getSinPhase(sms_phases) - for i in range(num_partials): - p = simpl.Peak() - p.amplitude = sms_amps[i] - p.frequency = sms_freqs[i] - p.phase = sms_phases[i] - peaks.append(p) - else: - for i in range(num_partials): - p = simpl.Peak() - p.amplitude = 0.0 - p.frequency = 0.0 - p.phase = 0.0 - peaks.append(p) - - if status == -1: - do_analysis = False - - frame.partials = peaks - sms_frames.append(frame) - pysms.sms_freeFrame(analysis_data) - current_frame += 1 - - pysms.sms_freeAnalysis(analysis_params) - pysms.sms_closeSF() - pysms.sms_free() - - audio, sampling_rate = self.get_audio() - simplsms.sms_init() - simpl_analysis_params = self.simplsms_analysis_params(sampling_rate) - if simplsms.sms_initAnalysis(simpl_analysis_params) != 0: - raise Exception("Error allocating memory for analysis_params") - simpl_analysis_params.nFrames = self.num_frames - simpl_analysis_params.iSizeSound = self.num_samples - simpl_sms_header = simplsms.SMS_Header() - simplsms.sms_fillHeader(simpl_sms_header, simpl_analysis_params, "simplsms") - - sample_offset = 0 - size_new_data = 0 - current_frame = 0 - simplsms_frames = [] - do_analysis = True - - while do_analysis and (current_frame < self.num_frames): - sample_offset += size_new_data - size_new_data = simpl_analysis_params.sizeNextRead - frame = simpl.Frame() - frame.size = size_new_data - frame.audio = audio[sample_offset:sample_offset + size_new_data] - if len(frame.audio) < size_new_data: - frame.audio = np.hstack((frame.audio, simpl.zeros(size_new_data - len(frame.audio)))) - analysis_data = simplsms.SMS_Data() - simplsms.sms_allocFrameH(simpl_sms_header, analysis_data) - status = simplsms.sms_analyze(frame.audio, analysis_data, simpl_analysis_params) - num_partials = analysis_data.nTracks - peaks = [] - - if status == 1: - freqs = simpl.zeros(num_partials) - amps = simpl.zeros(num_partials) - phases = simpl.zeros(num_partials) - analysis_data.getSinAmp(amps) - analysis_data.getSinFreq(freqs) - analysis_data.getSinPhase(phases) - for i in range(num_partials): - p = simpl.Peak() - p.amplitude = amps[i] - p.frequency = freqs[i] - p.phase = phases[i] - peaks.append(p) - else: - for i in range(num_partials): - p = simpl.Peak() - p.amplitude = 0.0 - p.frequency = 0.0 - p.phase = 0.0 - peaks.append(p) - - if status == -1: - do_analysis = False - - frame.partials = peaks - simplsms_frames.append(frame) - simplsms.sms_freeFrame(analysis_data) - current_frame += 1 - - simplsms.sms_freeAnalysis(simpl_analysis_params) - simplsms.sms_free() - - # make sure both have the same number of partials - assert len(sms_frames) == len(simplsms_frames) - - # make sure each partial is the same - for i in range(len(sms_frames)): - assert len(sms_frames[i].partials) == len(simplsms_frames[i].partials) - for p in range(len(sms_frames[i].partials)): - assert_almost_equals(sms_frames[i].partials[p].amplitude, - simplsms_frames[i].partials[p].amplitude, - self.FLOAT_PRECISION) - assert_almost_equals(sms_frames[i].partials[p].frequency, - simplsms_frames[i].partials[p].frequency, - self.FLOAT_PRECISION) - assert_almost_equals(sms_frames[i].partials[p].phase, - simplsms_frames[i].partials[p].phase, - self.FLOAT_PRECISION) - - def test_multi_sms_peak_detection(self): - """test_multi_sms_peak_detection - Test that running the same peak detection process twice in a row - produces the same results each time. This makes sure that results - are independent, and also helps to highlight any memory errors.""" - audio, sampling_rate = self.get_audio() - simplsms.sms_init() - analysis_params = self.simplsms_analysis_params(sampling_rate) - analysis_params.iMaxDelayFrames = self.num_frames + 1 - if simplsms.sms_initAnalysis(analysis_params) != 0: - raise Exception("Error allocating memory for analysis_params") - analysis_params.nFrames = self.num_frames - sms_header = simplsms.SMS_Header() - simplsms.sms_fillHeader(sms_header, analysis_params, "simplsms") - - sample_offset = 0 - size_new_data = 0 - current_frame = 0 - peaks1 = [] - - while current_frame < self.num_frames: - sample_offset += size_new_data - size_new_data = analysis_params.sizeNextRead - frame = audio[sample_offset:sample_offset + size_new_data] - analysis_data = simplsms.SMS_Data() - simplsms.sms_allocFrameH(sms_header, analysis_data) - status = simplsms.sms_analyze(frame, analysis_data, analysis_params) - # as the no. of frames of delay is > num_frames, sms_analyze should - # never get around to performing partial tracking, and so the return - # value should be 0 - assert status == 0 - num_peaks = analysis_data.nTracks - frame_peaks = [] - simplsms_freqs = simpl.zeros(num_peaks) - simplsms_amps = simpl.zeros(num_peaks) - simplsms_phases = simpl.zeros(num_peaks) - analysis_data.getSinFreq(simplsms_freqs) - analysis_data.getSinAmp(simplsms_amps) - analysis_data.getSinPhase(simplsms_phases) - for i in range(num_peaks): - if simplsms_amps[i]: - p = simpl.Peak() - # convert amplitude back to linear - p.amplitude = 10**(simplsms_amps[i]/20.0) - p.frequency = simplsms_freqs[i] - p.phase = simplsms_phases[i] - frame_peaks.append(p) - peaks1.append(frame_peaks) - pysms.sms_freeFrame(analysis_data) - current_frame += 1 - - simplsms.sms_freeAnalysis(analysis_params) - simplsms.sms_free() - - # Second run - audio, sampling_rate = self.get_audio() - simplsms.sms_init() - analysis_params = self.simplsms_analysis_params(sampling_rate) - analysis_params.iMaxDelayFrames = self.num_frames + 1 - if simplsms.sms_initAnalysis(analysis_params) != 0: - raise Exception("Error allocating memory for analysis_params") - analysis_params.nFrames = self.num_frames - sms_header = simplsms.SMS_Header() - simplsms.sms_fillHeader(sms_header, analysis_params, "simplsms") - - sample_offset = 0 - size_new_data = 0 - current_frame = 0 - peaks2 = [] - - while current_frame < self.num_frames: - sample_offset += size_new_data - size_new_data = analysis_params.sizeNextRead - frame = audio[sample_offset:sample_offset + size_new_data] - analysis_data = simplsms.SMS_Data() - simplsms.sms_allocFrameH(sms_header, analysis_data) - status = simplsms.sms_analyze(frame, analysis_data, analysis_params) - # as the no. of frames of delay is > num_frames, sms_analyze should - # never get around to performing partial tracking, and so the return - # value should be 0 - assert status == 0 - num_peaks = analysis_data.nTracks - frame_peaks = [] - simplsms_freqs = simpl.zeros(num_peaks) - simplsms_amps = simpl.zeros(num_peaks) - simplsms_phases = simpl.zeros(num_peaks) - analysis_data.getSinFreq(simplsms_freqs) - analysis_data.getSinAmp(simplsms_amps) - analysis_data.getSinPhase(simplsms_phases) - for i in range(num_peaks): - if simplsms_amps[i]: - p = simpl.Peak() - # convert amplitude back to linear - p.amplitude = 10**(simplsms_amps[i]/20.0) - p.frequency = simplsms_freqs[i] - p.phase = simplsms_phases[i] - frame_peaks.append(p) - peaks2.append(frame_peaks) - pysms.sms_freeFrame(analysis_data) - current_frame += 1 - - simplsms.sms_freeAnalysis(analysis_params) - simplsms.sms_free() - - # make sure we have the same number of frames in each run - assert len(peaks1) == len(peaks2) - for f in range(len(peaks1)): - # in each frame, make sure that we have the same number of peaks - assert len(peaks1[f]) == len(peaks2[f]) - # make sure that each peak has the same value - for p in range(len(peaks1[f])): - assert_almost_equals(peaks1[f][p].frequency, - peaks2[f][p].frequency, - self.FLOAT_PRECISION) - assert_almost_equals(peaks1[f][p].amplitude, - peaks2[f][p].amplitude, - self.FLOAT_PRECISION) - assert_almost_equals(peaks1[f][p].phase, - peaks2[f][p].phase, - self.FLOAT_PRECISION) - - def test_multi_simpl_peak_detection(self): - """test_multi_simpl_peak_detection - Test that running the simpl peak detection process twice in a row - produces the same results each time. This makes sure that results - are independent, and also helps to highlight any memory errors.""" - audio, sampling_rate = self.get_audio() - pd = simpl.SMSPeakDetection() - pd.max_peaks = self.max_peaks - pd.hop_size = self.hop_size - frames1 = pd.find_peaks(audio)[0:self.num_frames] - del pd - # second run - audio, sampling_rate = self.get_audio() - pd = simpl.SMSPeakDetection() - pd.max_peaks = self.max_peaks - pd.hop_size = self.hop_size - frames2 = pd.find_peaks(audio)[0:self.num_frames] - - # make sure we have the same number of frames in each run - assert len(frames1) == len(frames2) - for f in range(len(frames1)): - # in each frame, make sure that we have the same number of peaks - assert len(frames1[f].peaks) == len(frames2[f].peaks) - # make sure that each peak has the same value - for p in range(len(frames1[f].peaks)): - assert_almost_equals(frames1[f].peaks[p].frequency, - frames2[f].peaks[p].frequency, - self.FLOAT_PRECISION) - assert_almost_equals(frames1[f].peaks[p].amplitude, - frames2[f].peaks[p].amplitude, - self.FLOAT_PRECISION) - assert_almost_equals(frames1[f].peaks[p].phase, - frames2[f].peaks[p].phase, - self.FLOAT_PRECISION) - - def test_peak_detection(self): - """test_peak_detection - Compare simplsms Peaks with SMS peaks. Exact peak - information cannot be retrieved using libsms. Basic peak detection - is performed by sms_detectPeaks, but this is called multiple times - with different frame sizes by sms_analyze. This peak data cannot - be returned from sms_analyze without modifying it, so here - we compare the peaks to a slightly modified version of sms_analyze - from simplsms. The peak values should be the same as those found by - the simplsms find_peaks function. Analyses have to be performed - separately due to libsms implementation issues.""" - audio, sampling_rate = self.get_audio() - simplsms.sms_init() - analysis_params = self.simplsms_analysis_params(sampling_rate) - analysis_params.iMaxDelayFrames = self.num_frames + 1 - if simplsms.sms_initAnalysis(analysis_params) != 0: - raise Exception("Error allocating memory for analysis_params") - analysis_params.nFrames = self.num_frames - sms_header = simplsms.SMS_Header() - simplsms.sms_fillHeader(sms_header, analysis_params, "simplsms") - - sample_offset = 0 - size_new_data = 0 - current_frame = 0 - sms_peaks = [] - - while current_frame < self.num_frames: - sample_offset += size_new_data - size_new_data = analysis_params.sizeNextRead - frame = audio[sample_offset:sample_offset + size_new_data] - if len(frame) < size_new_data: - frame = np.hstack((frame, simpl.zeros(size_new_data - len(frame)))) - analysis_data = simplsms.SMS_Data() - simplsms.sms_allocFrameH(sms_header, analysis_data) - status = simplsms.sms_analyze(frame, analysis_data, analysis_params) - # as the no. of frames of delay is > num_frames, sms_analyze should - # never get around to performing partial tracking, and so the return - # value should be 0 - assert status == 0 - num_peaks = analysis_data.nTracks - frame_peaks = [] - simplsms_freqs = simpl.zeros(num_peaks) - simplsms_amps = simpl.zeros(num_peaks) - simplsms_phases = simpl.zeros(num_peaks) - analysis_data.getSinFreq(simplsms_freqs) - analysis_data.getSinAmp(simplsms_amps) - analysis_data.getSinPhase(simplsms_phases) - for i in range(num_peaks): - if simplsms_amps[i]: - p = simpl.Peak() - # convert amplitude back to linear - p.amplitude = simplsms_amps[i] - p.frequency = simplsms_freqs[i] - p.phase = simplsms_phases[i] - frame_peaks.append(p) - sms_peaks.append(frame_peaks) - pysms.sms_freeFrame(analysis_data) - current_frame += 1 - - simplsms.sms_freeAnalysis(analysis_params) - simplsms.sms_free() - - # get simpl peaks - pd = simpl.SMSPeakDetection() - pd.hop_size = self.hop_size - pd.max_peaks = self.max_peaks - current_frame = 0 - sample_offset = 0 - simpl_peaks = [] - - while current_frame < self.num_frames: - pd.frame_size = pd.get_next_frame_size() - frame = simpl.Frame() - frame.size = pd.frame_size - frame.audio = audio[sample_offset:sample_offset + pd.frame_size] - if len(frame.audio) < pd.frame_size: - frame.audio = np.hstack((frame.audio, simpl.zeros(pd.frame_size - len(frame.audio)))) - simpl_peaks.append(pd.find_peaks_in_frame(frame)) - sample_offset += pd.frame_size - current_frame += 1 - - # make sure we have the same number of frames - assert len(sms_peaks) == len(simpl_peaks) - - # compare data for each frame - for frame_number in range(len(sms_peaks)): - sms_frame = sms_peaks[frame_number] - simpl_frame = simpl_peaks[frame_number] - # make sure we have the same number of peaks in each frame - assert len(sms_frame) == len(simpl_frame) - # check peak values - for peak_number in range(len(sms_frame)): - sms_peak = sms_frame[peak_number] - simpl_peak = simpl_frame[peak_number] - assert_almost_equals(sms_peak.amplitude, simpl_peak.amplitude, - self.FLOAT_PRECISION) - assert_almost_equals(sms_peak.frequency, simpl_peak.frequency, - self.FLOAT_PRECISION) - assert_almost_equals(sms_peak.phase, simpl_peak.phase, - self.FLOAT_PRECISION) - - def test_multi_pysms_analyze(self): - """test_multi_pysms_analyze - Test that running the pysms sms_analyze function twice in a row - produces the same results each time. This makes sure that results - are independent, and also helps to highlight any memory errors.""" - audio, sampling_rate = self.get_audio() - pysms.sms_init() - snd_header = pysms.SMS_SndHeader() - # Try to open the input file to fill snd_header - if(pysms.sms_openSF(self.input_file, snd_header)): - raise NameError("error opening sound file: " + pysms.sms_errorString()) - analysis_params = self.pysms_analysis_params(sampling_rate) - if pysms.sms_initAnalysis(analysis_params, snd_header) != 0: - raise Exception("Error allocating memory for analysis_params") - analysis_params.iSizeSound = self.num_samples - sms_header = pysms.SMS_Header() - pysms.sms_fillHeader(sms_header, analysis_params, "pysms") - - sample_offset = 0 - size_new_data = 0 - current_frame = 0 - freqs1 = [] - amps1 = [] - phases1 = [] - do_analysis = True - - while do_analysis and (current_frame < self.num_frames): - sample_offset += size_new_data - size_new_data = analysis_params.sizeNextRead - # convert frame to floats for libsms - frame = audio[sample_offset:sample_offset + size_new_data] - frame = np.array(frame, dtype=np.float32) - analysis_data = pysms.SMS_Data() - pysms.sms_allocFrameH(sms_header, analysis_data) - status = pysms.sms_analyze(frame, analysis_data, analysis_params) - if status == 1: - num_partials = analysis_data.nTracks - freqs = np.zeros(num_partials, dtype=np.float32) - amps = np.zeros(num_partials, dtype=np.float32) - phases = np.zeros(num_partials, dtype=np.float32) - analysis_data.getSinFreq(freqs) - analysis_data.getSinAmp(amps) - analysis_data.getSinPhase(phases) - amps1.append(amps) - freqs1.append(freqs) - phases1.append(phases) - elif status == -1: - do_analysis = False - pysms.sms_freeFrame(analysis_data) - current_frame += 1 - - pysms.sms_freeAnalysis(analysis_params) - pysms.sms_closeSF() - pysms.sms_free() - - # second run - audio, sampling_rate = self.get_audio() - pysms.sms_init() - snd_header = pysms.SMS_SndHeader() - # Try to open the input file to fill snd_header - if(pysms.sms_openSF(self.input_file, snd_header)): - raise NameError("error opening sound file: " + pysms.sms_errorString()) - analysis_params = self.pysms_analysis_params(sampling_rate) - if pysms.sms_initAnalysis(analysis_params, snd_header) != 0: - raise Exception("Error allocating memory for analysis_params") - analysis_params.iSizeSound = self.num_samples - sms_header = pysms.SMS_Header() - pysms.sms_fillHeader(sms_header, analysis_params, "pysms") - - sample_offset = 0 - size_new_data = 0 - current_frame = 0 - freqs2 = [] - amps2 = [] - phases2 = [] - do_analysis = True - - while do_analysis and (current_frame < self.num_frames): - sample_offset += size_new_data - size_new_data = analysis_params.sizeNextRead - # convert frame to floats for libsms - frame = audio[sample_offset:sample_offset + size_new_data] - frame = np.array(frame, dtype=np.float32) - analysis_data = pysms.SMS_Data() - pysms.sms_allocFrameH(sms_header, analysis_data) - status = pysms.sms_analyze(frame, analysis_data, analysis_params) - if status == 1: - num_partials = analysis_data.nTracks - freqs = np.zeros(num_partials, dtype=np.float32) - amps = np.zeros(num_partials, dtype=np.float32) - phases = np.zeros(num_partials, dtype=np.float32) - analysis_data.getSinFreq(freqs) - analysis_data.getSinAmp(amps) - analysis_data.getSinPhase(phases) - amps2.append(amps) - freqs2.append(freqs) - phases2.append(phases) - elif status == -1: - do_analysis = False - pysms.sms_freeFrame(analysis_data) - current_frame += 1 - - pysms.sms_freeAnalysis(analysis_params) - pysms.sms_closeSF() - pysms.sms_free() - - # make sure we have the same number of results in each run - assert len(freqs1) == len(freqs2) - assert len(amps1) == len(amps2) - assert len(phases1) == len(phases2) - - for r in range(len(freqs1)): - # in each result, make sure that we have the same number amps, freqs and phases - assert len(freqs1[r]) == len(freqs2[r]) - assert len(amps1[r]) == len(amps2[r]) - assert len(phases1[r]) == len(phases2[r]) - # make sure that each partial has the same value - for p in range(len(freqs1[r])): - assert_almost_equals(freqs1[r][p], freqs2[r][p], self.FLOAT_PRECISION) - assert_almost_equals(amps1[r][p], amps2[r][p], self.FLOAT_PRECISION) - assert_almost_equals(phases1[r][p], phases2[r][p], self.FLOAT_PRECISION) - - def test_multi_simpl_partial_tracking(self): - """test_multi_simpl_partial_tracking - Test that running the simpl peak detection process twice in a row - produces the same results each time. This makes sure that results - are independent, and also helps to highlight any memory errors.""" - audio, sampling_rate = self.get_audio() - pd = simpl.SMSPeakDetection() - pd.max_peaks = self.max_peaks - pd.hop_size = self.hop_size - peaks = pd.find_peaks(audio)[0:self.num_frames] - pt = simpl.SMSPartialTracking() - pt.max_partials = self.max_peaks - frames1 = pt.find_partials(peaks) - del pd - del pt - # second run - audio, sampling_rate = self.get_audio() - pd = simpl.SMSPeakDetection() - pd.max_peaks = self.max_peaks - pd.hop_size = self.hop_size - peaks = pd.find_peaks(audio)[0:self.num_frames] - pt = simpl.SMSPartialTracking() - pt.max_partials = self.max_peaks - frames2 = pt.find_partials(peaks) - - # make sure we have the same number of partials in each run - assert len(frames1) == len(frames2) - for i in range(len(frames1)): - # make sure each partial is the same length - assert len(frames1[i].partials) == len(frames2[i].partials) - # make sure that the peaks in each partial have the same values - for p in range(len(frames1[i].partials)): - assert_almost_equals(frames1[i].partials[p].frequency, - frames2[i].partials[p].frequency, - self.FLOAT_PRECISION) - assert_almost_equals(frames1[i].partials[p].amplitude, - frames2[i].partials[p].amplitude, - self.FLOAT_PRECISION) - assert_almost_equals(frames1[i].partials[p].phase, - frames2[i].partials[p].phase, - self.FLOAT_PRECISION) - - def test_partial_tracking(self): - """test_partial_tracking - Compare pysms Partials with SMS partials.""" - audio, sampling_rate = self.get_audio() - pysms.sms_init() - snd_header = pysms.SMS_SndHeader() - # Try to open the input file to fill snd_header - if(pysms.sms_openSF(self.input_file, snd_header)): - raise NameError("error opening sound file: " + pysms.sms_errorString()) - analysis_params = self.pysms_analysis_params(sampling_rate) - if pysms.sms_initAnalysis(analysis_params, snd_header) != 0: - raise Exception("Error allocating memory for analysis_params") - analysis_params.iSizeSound = self.num_samples - analysis_params.nFrames = self.num_frames - sms_header = pysms.SMS_Header() - pysms.sms_fillHeader(sms_header, analysis_params, "pysms") - - sample_offset = 0 - size_new_data = 0 - current_frame = 0 - sms_frames = [] - do_analysis = True - - while do_analysis and (current_frame < self.num_frames): - sample_offset += size_new_data - size_new_data = analysis_params.sizeNextRead - # convert frame to floats for libsms - frame = simpl.Frame() - frame.size = size_new_data - frame.audio = np.array(audio[sample_offset:sample_offset + size_new_data], - dtype=np.float32) - analysis_data = pysms.SMS_Data() - pysms.sms_allocFrameH(sms_header, analysis_data) - num_partials = analysis_data.nTracks - peaks = [] - status = pysms.sms_analyze(frame.audio, analysis_data, analysis_params) - - if status == 1: - sms_freqs = np.zeros(num_partials, dtype=np.float32) - sms_amps = np.zeros(num_partials, dtype=np.float32) - sms_phases = np.zeros(num_partials, dtype=np.float32) - analysis_data.getSinFreq(sms_freqs) - analysis_data.getSinAmp(sms_amps) - analysis_data.getSinPhase(sms_phases) - for i in range(num_partials): - p = simpl.Peak() - p.amplitude = sms_amps[i] - p.frequency = sms_freqs[i] - p.phase = sms_phases[i] - peaks.append(p) - frame.partials = peaks - sms_frames.append(frame) - current_frame += 1 - - if status == -1: - do_analysis = False - - pysms.sms_freeFrame(analysis_data) - - # first frame is blank - sms_frames = sms_frames[1:] - - # free sms memory - pysms.sms_freeAnalysis(analysis_params) - pysms.sms_closeSF() - pysms.sms_free() - - pd = simpl.SMSPeakDetection() - pd.max_peaks = self.max_peaks - pd.hop_size = self.hop_size - peaks = pd.find_peaks(audio) - pt = simpl.SMSPartialTracking() - pt.max_partials = self.max_partials - simpl_frames = pt.find_partials(peaks) - - # make sure both have the same number of partials - assert len(sms_frames) == len(simpl_frames) - - # make sure each partial is the same - for i in range(len(sms_frames)): - assert len(sms_frames[i].partials) == len(simpl_frames[i].partials) - for p in range(len(sms_frames[i].partials)): - assert_almost_equals(sms_frames[i].partials[p].amplitude, - simpl_frames[i].partials[p].amplitude, - self.FLOAT_PRECISION) - assert_almost_equals(sms_frames[i].partials[p].frequency, - simpl_frames[i].partials[p].frequency, - self.FLOAT_PRECISION) - assert_almost_equals(sms_frames[i].partials[p].phase, - simpl_frames[i].partials[p].phase, - self.FLOAT_PRECISION) - - def test_sms_interpolate_frames(self): - """test_sms_interpolate_frames - Make sure that sms_interpolateFrames returns the expected values - with interpolation factors of 0 and 1.""" - audio, sampling_rate = self.get_audio() - pysms.sms_init() - snd_header = pysms.SMS_SndHeader() - # Try to open the input file to fill snd_header - if(pysms.sms_openSF(self.input_file, snd_header)): - raise NameError("error opening sound file: " + pysms.sms_errorString()) - analysis_params = self.pysms_analysis_params(sampling_rate) - analysis_params.nFrames = self.num_frames - if pysms.sms_initAnalysis(analysis_params, snd_header) != 0: - raise Exception("Error allocating memory for analysis_params") - analysis_params.iSizeSound = self.num_samples - sms_header = pysms.SMS_Header() - pysms.sms_fillHeader(sms_header, analysis_params, "pysms") - - interp_frame = pysms.SMS_Data() - pysms.sms_allocFrameH(sms_header, interp_frame) - - sample_offset = 0 - size_new_data = 0 - current_frame = 0 - analysis_frames = [] - do_analysis = True - - while do_analysis and (current_frame < self.num_frames): - sample_offset += size_new_data - size_new_data = analysis_params.sizeNextRead - frame = audio[sample_offset:sample_offset + size_new_data] - # convert frame to floats for libsms - frame = np.array(frame, dtype=np.float32) - analysis_data = pysms.SMS_Data() - pysms.sms_allocFrameH(sms_header, analysis_data) - status = pysms.sms_analyze(frame, analysis_data, analysis_params) - - if status == 1: - analysis_frames.append(analysis_data) - # test interpolateFrames on the last two analysis frames - if current_frame == self.num_frames - 1: - left_frame = analysis_frames[-2] - right_frame = analysis_frames[-1] - pysms.sms_interpolateFrames(left_frame, right_frame, interp_frame, 0) - # make sure that interp_frame == left_frame - # interpolateFrames doesn't interpolate phases so ignore - left_amps = np.zeros(self.max_partials, dtype=np.float32) - left_freqs = np.zeros(self.max_partials, dtype=np.float32) - left_frame.getSinAmp(left_amps) - left_frame.getSinFreq(left_freqs) - right_amps = np.zeros(self.max_partials, dtype=np.float32) - right_freqs = np.zeros(self.max_partials, dtype=np.float32) - right_frame.getSinAmp(right_amps) - right_frame.getSinFreq(right_freqs) - interp_amps = np.zeros(self.max_partials, dtype=np.float32) - interp_freqs = np.zeros(self.max_partials, dtype=np.float32) - interp_frame.getSinAmp(interp_amps) - interp_frame.getSinFreq(interp_freqs) - for i in range(self.max_partials): - assert_almost_equals(left_amps[i], interp_amps[i], - self.FLOAT_PRECISION) - if left_freqs[i] != 0: - assert_almost_equals(left_freqs[i], interp_freqs[i], - self.FLOAT_PRECISION) - else: - assert_almost_equals(right_freqs[i], interp_freqs[i], - self.FLOAT_PRECISION) - pysms.sms_interpolateFrames(left_frame, right_frame, interp_frame, 1) - interp_amps = np.zeros(self.max_partials, dtype=np.float32) - interp_freqs = np.zeros(self.max_partials, dtype=np.float32) - interp_frame.getSinAmp(interp_amps) - interp_frame.getSinFreq(interp_freqs) - for i in range(self.max_partials): - assert_almost_equals(right_amps[i], interp_amps[i], - self.FLOAT_PRECISION) - if right_freqs[i] != 0: - assert_almost_equals(right_freqs[i], interp_freqs[i], - self.FLOAT_PRECISION) - else: - assert_almost_equals(left_freqs[i], interp_freqs[i], - self.FLOAT_PRECISION) - elif status == -1: - raise Exception("AnalysisStoppedEarly") - else: - pysms.sms_freeFrame(analysis_data) - current_frame += 1 - - for frame in analysis_frames: - pysms.sms_freeFrame(frame) - pysms.sms_freeFrame(interp_frame) - pysms.sms_freeAnalysis(analysis_params) - pysms.sms_closeSF() - pysms.sms_free() - - def test_simplsms_interpolate_frames(self): - """test_simplsms_interpolate_frames - Make sure that sms_interpolateFrames returns the expected values - with interpolation factors of 0 and 1.""" - audio, sampling_rate = self.get_audio() - simplsms.sms_init() - analysis_params = self.simplsms_analysis_params(sampling_rate) - analysis_params.nFrames = self.num_frames - if simplsms.sms_initAnalysis(analysis_params) != 0: - raise Exception("Error allocating memory for analysis_params") - analysis_params.iSizeSound = self.num_samples - sms_header = simplsms.SMS_Header() - simplsms.sms_fillHeader(sms_header, analysis_params, "simplsms") - - interp_frame = simplsms.SMS_Data() - simplsms.sms_allocFrameH(sms_header, interp_frame) - - sample_offset = 0 - size_new_data = 0 - current_frame = 0 - analysis_frames = [] - do_analysis = True - - while do_analysis and (current_frame < self.num_frames): - sample_offset += size_new_data - size_new_data = analysis_params.sizeNextRead - frame = audio[sample_offset:sample_offset + size_new_data] - analysis_data = simplsms.SMS_Data() - simplsms.sms_allocFrameH(sms_header, analysis_data) - status = simplsms.sms_analyze(frame, analysis_data, analysis_params) - - if status == 1: - analysis_frames.append(analysis_data) - # test interpolateFrames on the last two analysis frames - if current_frame == self.num_frames - 1: - left_frame = analysis_frames[-2] - right_frame = analysis_frames[-1] - simplsms.sms_interpolateFrames(left_frame, right_frame, interp_frame, 0) - # make sure that interp_frame == left_frame - # interpolateFrames doesn't interpolate phases so ignore - left_amps = simpl.zeros(self.max_partials) - left_freqs = simpl.zeros(self.max_partials) - left_frame.getSinAmp(left_amps) - left_frame.getSinFreq(left_freqs) - right_amps = simpl.zeros(self.max_partials) - right_freqs = simpl.zeros(self.max_partials) - right_frame.getSinAmp(right_amps) - right_frame.getSinFreq(right_freqs) - interp_amps = simpl.zeros(self.max_partials) - interp_freqs = simpl.zeros(self.max_partials) - interp_frame.getSinAmp(interp_amps) - interp_frame.getSinFreq(interp_freqs) - for i in range(self.max_partials): - assert_almost_equals(left_amps[i], interp_amps[i], - self.FLOAT_PRECISION) - if left_freqs[i] != 0: - assert_almost_equals(left_freqs[i], interp_freqs[i], - self.FLOAT_PRECISION) - else: - assert_almost_equals(right_freqs[i], interp_freqs[i], - self.FLOAT_PRECISION) - simplsms.sms_interpolateFrames(left_frame, right_frame, interp_frame, 1) - interp_amps = simpl.zeros(self.max_partials) - interp_freqs = simpl.zeros(self.max_partials) - interp_frame.getSinAmp(interp_amps) - interp_frame.getSinFreq(interp_freqs) - for i in range(self.max_partials): - assert_almost_equals(right_amps[i], interp_amps[i], - self.FLOAT_PRECISION) - if right_freqs[i] != 0: - assert_almost_equals(right_freqs[i], interp_freqs[i], - self.FLOAT_PRECISION) - else: - assert_almost_equals(left_freqs[i], interp_freqs[i], - self.FLOAT_PRECISION) - elif status == -1: - raise Exception("AnalysisStoppedEarly") - else: - simplsms.sms_freeFrame(analysis_data) - current_frame += 1 - - for frame in analysis_frames: - simplsms.sms_freeFrame(frame) - simplsms.sms_freeFrame(interp_frame) - simplsms.sms_freeAnalysis(analysis_params) - simplsms.sms_free() - - def test_harmonic_synthesis(self): - """test_harmonic_synthesis - Compare pysms synthesised harmonic component with SMS synthesised - harmonic component.""" - audio, sampling_rate = self.get_audio() - pysms.sms_init() - snd_header = pysms.SMS_SndHeader() - # Try to open the input file to fill snd_header - if(pysms.sms_openSF(self.input_file, snd_header)): - raise NameError("error opening sound file: " + pysms.sms_errorString()) - analysis_params = self.pysms_analysis_params(sampling_rate) - analysis_params.nFrames = self.num_frames - if pysms.sms_initAnalysis(analysis_params, snd_header) != 0: - raise Exception("Error allocating memory for analysis_params") - analysis_params.iSizeSound = self.num_samples - sms_header = pysms.SMS_Header() - pysms.sms_fillHeader(sms_header, analysis_params, "pysms") - - sample_offset = 0 - size_new_data = 0 - current_frame = 0 - analysis_frames = [] - do_analysis = True - - while do_analysis and (current_frame < self.num_frames): - sample_offset += size_new_data - size_new_data = analysis_params.sizeNextRead - frame = audio[sample_offset:sample_offset + size_new_data] - # convert frame to floats for libsms - frame = np.array(frame, dtype=np.float32) - analysis_data = pysms.SMS_Data() - pysms.sms_allocFrameH(sms_header, analysis_data) - status = pysms.sms_analyze(frame, analysis_data, analysis_params) - if status == 1: - analysis_frames.append(analysis_data) - current_frame += 1 - elif status == 0: - pysms.sms_freeFrame(analysis_data) - elif status == -1: - do_analysis = False - pysms.sms_freeFrame(analysis_data) - - # remove the first frame, it's blank - blank_frame = analysis_frames[0] - analysis_frames = analysis_frames[1:] - pysms.sms_freeFrame(blank_frame) - - synth_params = self.pysms_synthesis_params(sampling_rate) - pysms.sms_initSynth(sms_header, synth_params) - - synth_samples = np.zeros(synth_params.sizeHop, dtype=np.float32) - sms_audio = np.array([], dtype=np.float32) - current_frame = 0 - - while current_frame < len(analysis_frames): - pysms.sms_synthesize(analysis_frames[current_frame], synth_samples, synth_params) - sms_audio = np.hstack((sms_audio, synth_samples)) - current_frame += 1 - - for frame in analysis_frames: - pysms.sms_freeFrame(frame) - pysms.sms_freeAnalysis(analysis_params) - pysms.sms_closeSF() - pysms.sms_freeSynth(synth_params) - pysms.sms_free() - - pd = simpl.SMSPeakDetection() - pd.max_peaks = self.max_peaks - pd.hop_size = self.hop_size - peaks = pd.find_peaks(audio) - pt = simpl.SMSPartialTracking() - pt.max_partials = self.max_partials - partials = pt.find_partials(peaks) - synth = simpl.SMSSynthesis() - synth.hop_size = self.hop_size - synth.max_partials = self.max_partials - synth.det_synthesis_type = simplsms.SMS_DET_IFFT - simpl_audio = synth.synth(partials) - - assert len(sms_audio) == len(simpl_audio) - for i in range(simpl_audio.size): - assert_almost_equals(sms_audio[i], simpl_audio[i], self.FLOAT_PRECISION) - - def test_harmonic_synthesis_sin(self): - """test_harmonic_synthesis_sin - Compare pysms synthesised harmonic component with SMS synthesised - harmonic component.""" - audio, sampling_rate = self.get_audio() - pysms.sms_init() - snd_header = pysms.SMS_SndHeader() - # Try to open the input file to fill snd_header - if(pysms.sms_openSF(self.input_file, snd_header)): - raise NameError("error opening sound file: " + pysms.sms_errorString()) - analysis_params = self.pysms_analysis_params(sampling_rate) - if pysms.sms_initAnalysis(analysis_params, snd_header) != 0: - raise Exception("Error allocating memory for analysis_params") - analysis_params.iSizeSound = self.num_samples - analysis_params.nFrames = self.num_frames - sms_header = pysms.SMS_Header() - pysms.sms_fillHeader(sms_header, analysis_params, "pysms") - - sample_offset = 0 - size_new_data = 0 - current_frame = 0 - analysis_frames = [] - do_analysis = True - - while do_analysis and (current_frame < self.num_frames): - sample_offset += size_new_data - size_new_data = analysis_params.sizeNextRead - frame = audio[sample_offset:sample_offset + size_new_data] - # convert frame to floats for libsms - frame = np.array(frame, dtype=np.float32) - if len(frame) < size_new_data: - frame = np.hstack((frame, np.zeros(size_new_data - len(frame), - dtype=np.float32))) - analysis_data = pysms.SMS_Data() - pysms.sms_allocFrameH(sms_header, analysis_data) - status = pysms.sms_analyze(frame, analysis_data, analysis_params) - if status == 1: - analysis_frames.append(analysis_data) - current_frame += 1 - elif status == 0: - pysms.sms_freeFrame(analysis_data) - elif status == -1: - do_analysis = False - pysms.sms_freeFrame(analysis_data) - - # remove the first frame, it's blank - blank_frame = analysis_frames[0] - analysis_frames = analysis_frames[1:] - pysms.sms_freeFrame(blank_frame) - - synth_params = self.pysms_synthesis_params(sampling_rate) - synth_params.iDetSynthType = pysms.SMS_DET_SIN - pysms.sms_initSynth(sms_header, synth_params) - - synth_samples = np.zeros(synth_params.sizeHop, dtype=np.float32) - sms_audio = np.array([], dtype=np.float32) - current_frame = 0 - - while current_frame < len(analysis_frames): - pysms.sms_synthesize(analysis_frames[current_frame], synth_samples, synth_params) - sms_audio = np.hstack((sms_audio, synth_samples)) - current_frame += 1 - - for frame in analysis_frames: - pysms.sms_freeFrame(frame) - pysms.sms_freeAnalysis(analysis_params) - pysms.sms_closeSF() - pysms.sms_freeSynth(synth_params) - pysms.sms_free() - - pd = simpl.SMSPeakDetection() - pd.max_peaks = self.max_peaks - pd.hop_size = self.hop_size - peaks = pd.find_peaks(audio) - pt = simpl.SMSPartialTracking() - pt.max_partials = self.max_partials - partials = pt.find_partials(peaks) - synth = simpl.SMSSynthesis() - synth.hop_size = self.hop_size - synth.max_partials = self.max_partials - synth.det_synthesis_type = simplsms.SMS_DET_SIN - simpl_audio = synth.synth(partials) - - assert len(sms_audio) == len(simpl_audio) - for i in range(simpl_audio.size): - assert_almost_equals(sms_audio[i], simpl_audio[i], self.FLOAT_PRECISION) - - def test_residual_synthesis(self): - """test_residual_synthesis - Compare pysms residual signal with SMS residual""" - - # ------------------------------------------- - # This test is not finished yet. Skip for now - from nose.plugins.skip import SkipTest - raise SkipTest - # ------------------------------------------- - - audio, sampling_rate = self.get_audio() - pysms.sms_init() - snd_header = pysms.SMS_SndHeader() - # Try to open the input file to fill snd_header - if(pysms.sms_openSF(self.input_file, snd_header)): - raise NameError("error opening sound file: " + pysms.sms_errorString()) - analysis_params = self.pysms_analysis_params(sampling_rate) - analysis_params.nFrames = self.num_frames - analysis_params.nStochasticCoeff = 128 - analysis_params.iStochasticType = pysms.SMS_STOC_APPROX - if pysms.sms_initAnalysis(analysis_params, snd_header) != 0: - raise Exception("Error allocating memory for analysis_params") - analysis_params.iSizeSound = self.num_samples - sms_header = pysms.SMS_Header() - pysms.sms_fillHeader(sms_header, analysis_params, "pysms") - - sample_offset = 0 - size_new_data = 0 - current_frame = 0 - analysis_frames = [] - do_analysis = True - - while do_analysis and (current_frame < self.num_frames): - sample_offset += size_new_data - size_new_data = analysis_params.sizeNextRead - # convert frame to floats for libsms - frame = audio[sample_offset:sample_offset + size_new_data] - frame = np.array(frame, dtype=np.float32) - analysis_data = pysms.SMS_Data() - pysms.sms_allocFrameH(sms_header, analysis_data) - status = pysms.sms_analyze(frame, analysis_data, analysis_params) - analysis_frames.append(analysis_data) - if status == -1: - do_analysis = False - current_frame += 1 - - sms_header.nFrames = len(analysis_frames) - synth_params = self.pysms_synthesis_params(sampling_rate) - synth_params.iStochasticType = pysms.SMS_STOC_APPROX - synth_params.iSynthesisType = pysms.SMS_STYPE_STOC - pysms.sms_initSynth(sms_header, synth_params) - synth_samples = np.zeros(synth_params.sizeHop, dtype=np.float32) - sms_residual = np.array([], dtype=np.float32) - current_frame = 0 - - while current_frame < len(analysis_frames): - pysms.sms_synthesize(analysis_frames[current_frame], synth_samples, synth_params) - sms_residual = np.hstack((sms_residual, synth_samples)) - current_frame += 1 - - for frame in analysis_frames: - pysms.sms_freeFrame(frame) - pysms.sms_freeAnalysis(analysis_params) - pysms.sms_closeSF() - pysms.sms_freeSynth(synth_params) - pysms.sms_free() - - pd = simpl.SMSPeakDetection() - pd.max_peaks = self.max_peaks - pd.hop_size = self.hop_size - peaks = pd.find_peaks(audio)[0:self.num_frames] - pt = simpl.SMSPartialTracking() - pt.max_partials = self.max_partials - partials = pt.find_partials(peaks) - synth = simpl.SMSSynthesis() - synth.hop_size = self.hop_size - synth.max_partials = self.max_partials - simpl_harmonic = synth.synth(partials) - res = simpl.SMSResidual() - simpl_residual = res.synth(simpl_harmonic, audio[0:simpl_harmonic.size]) - - assert len(simpl_residual) == len(sms_residual) - for i in range(len(simpl_residual)): - assert_almost_equals(simpl_residual[i], sms_residual[i], - self.FLOAT_PRECISION) - - -if __name__ == "__main__": - # run individual tests programatically - # useful for debugging, particularly with GDB - import nose - argv = [__file__, - "--nocapture", - #__file__ + ":TestSimplSMS.test_residual_synthesis"] - __file__ + ":TestSimplSMS.test_harmonic_synthesis_sin"] - nose.run(argv=argv) diff --git a/tests/test_sms_old.py b/tests/test_sms_old.py deleted file mode 100644 index 7ed8724..0000000 --- a/tests/test_sms_old.py +++ /dev/null @@ -1,126 +0,0 @@ -# Copyright (c) 2009 John Glover, National University of Ireland, Maynooth -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program 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 General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, M 02111-1307 USA - -import unittest -from pysms import SMS_Header, SMS_Data, SMS_SndHeader, SMS_AnalParams, \ - sms_openSF, sms_errorString, sms_getSound, \ - sms_fillHeader, sms_init, sms_initAnalysis, sms_allocFrameH, \ - sms_freeFrame, sms_freeAnalysis, sms_free -from scipy import zeros, sin, pi, asarray, int16 -from scipy.io.wavfile import read, write -import os -import random -from pylab import plot, show - -TEST_AUDIO_FILE = "Tests.wav" - -# Create a test audio file (1 second of a sine wave at 220 Hz) -test_audio = zeros(44100) -for sample_number in range(test_audio.size): - test_audio[sample_number] = sin(2 * pi * 220 * sample_number / 44100.0) -# convert to int values -test_audio *= 32767 -test_audio = asarray(test_audio, int16) - -def create_test_audio_file(): - "Create a test audio file in the current directory" - write(TEST_AUDIO_FILE, 44100, test_audio) - -def delete_test_audio_file(): - "Delete the test audio file created by the function create_test_audio_file" - os.remove(TEST_AUDIO_FILE) - -class TestSoundIO(unittest.TestCase): - def setUp(self): - self.snd_header = SMS_SndHeader() - - def test_sms_openSF_file_exists(self): - "sms_openSF returns True when trying to open an existing file" - create_test_audio_file() - self.assert_(sms_openSF(TEST_AUDIO_FILE, self.snd_header) == 0) - delete_test_audio_file() - - def test_sms_openSF_file_missing(self): - "sms_openSF returns False when trying to open a file that doesn't exist" - file_path = "" - max_file_names = 1000 - count = 0 - class MaxFilesReached(Exception): pass - # create a path to a non-existent file - while True: - file_path = str(random.randint(0, max_file_names)) + ".wav" - if not os.path.isfile(file_path): - break - if count > max_file_names: - raise MaxFilesReached - count += 1 - # call sms_openSF, should return an error - self.assertRaises(IndexError, sms_openSF, file_path, self.snd_header) - - def test_sms_getSound(self): - "sms_getSound" - create_test_audio_file() - self.assert_(sms_openSF(TEST_AUDIO_FILE, self.snd_header) == 0) - frame_size = 512 - frame = zeros(frame_size).astype('float32') - self.assert_(sms_getSound(self.snd_header, frame, 0) == 0) - # test that values read in are the same as those written (allowing for some rounding errors) - class SampleMismatch(Exception): pass - for sample_number in range(frame_size): - if abs((test_audio[sample_number] / 32768.0) - frame[sample_number] > 0.000001): - raise SampleMismatch - delete_test_audio_file() - -class TestInit(unittest.TestCase): - def setUp(self): - self.snd_header = SMS_SndHeader() - self.sms_header = SMS_Header() - self.data = SMS_Data() - self.analysis_params = SMS_AnalParams() - - def tearDown(self): - sms_freeFrame(self.data) - - def test_sms_fillHeader(self): - "sms_fillHeader copies data from an SMS_AnalParams to an SMS_Header" - data_fields = ["nFrames", "iFormat", "iFrameRate", "iStochasticType", \ - "nTracks", "iSamplingRate", "nStochasticCoeff"] - sms_fillHeader(self.sms_header, self.analysis_params, "") - for field in data_fields: - self.assert_(eval("self.sms_header."+field) == eval("self.analysis_params."+field)) - - def test_sms_init(self): - "sms_init" - self.assert_(sms_init() == 0) - - def test_sms_initAnalysis(self): - "sms_initAnalysis" - create_test_audio_file() - if(sms_openSF(TEST_AUDIO_FILE, self.snd_header)): - raise NameError("error opening sound file: " + sms_errorString()) - self.assert_(sms_initAnalysis(self.analysis_params, self.snd_header) == 0) - delete_test_audio_file() - - def test_sms_allocFrameH(self): - "sms_allocFrameH" - create_test_audio_file() - if(sms_openSF(TEST_AUDIO_FILE, self.snd_header)): - raise NameError("error opening sound file: " + sms_errorString()) - self.assert_(sms_allocFrameH(self.sms_header, self.data) == 0) - delete_test_audio_file() - -if __name__ == '__main__': - unittest.main() diff --git a/tests/test_sndobj.py b/tests/test_sndobj.py index 527a9d7..2a27930 100644 --- a/tests/test_sndobj.py +++ b/tests/test_sndobj.py @@ -1,19 +1,3 @@ -# Copyright (c) 2009 John Glover, National University of Ireland, Maynooth -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program 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 General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - import unittest import sndobj import simpl @@ -21,7 +5,8 @@ from simpl import pysndobj from scipy.io.wavfile import read import numpy as np -FLOAT_PRECISION = 2 # number of decimal places to check for accuracy +FLOAT_PRECISION = 2 # number of decimal places to check for accuracy + class TestSimplSndObj(unittest.TestCase): def setUp(self): diff --git a/tests/test_synthesis.py b/tests/test_synthesis.py new file mode 100644 index 0000000..2e620ea --- /dev/null +++ b/tests/test_synthesis.py @@ -0,0 +1,126 @@ +import os +from nose.tools import assert_almost_equals +import simpl +import simpl.peak_detection as peak_detection +import simpl.partial_tracking as partial_tracking +import simpl.synthesis as synthesis + +float_precision = 2 +frame_size = 512 +hop_size = 512 +max_peaks = 10 +max_partials = 10 +num_frames = 30 +num_samples = num_frames * hop_size +audio_path = os.path.join( + os.path.dirname(__file__), 'audio/flute.wav' +) +libsms_harmonic_synthesis_ifft_path = os.path.join( + os.path.dirname(__file__), 'libsms_harmonic_synthesis_ifft.wav' +) +libsms_harmonic_synthesis_sin_path = os.path.join( + os.path.dirname(__file__), 'libsms_harmonic_synthesis_sin.wav' +) + +PeakDetection = peak_detection.PeakDetection +SMSPeakDetection = peak_detection.SMSPeakDetection +PartialTracking = partial_tracking.PartialTracking +SMSPartialTracking = partial_tracking.SMSPartialTracking +Synthesis = synthesis.Synthesis +SMSSynthesis = synthesis.SMSSynthesis + + +class TestSynthesis(object): + @classmethod + def setup_class(cls): + cls.audio = simpl.read_wav(audio_path)[0] + cls.audio = cls.audio[0:num_samples] + + def test_basic(self): + pd = PeakDetection() + pd.hop_size = hop_size + frames = pd.find_peaks(self.audio) + + pt = PartialTracking() + pt.max_partials = max_partials + frames = pt.find_partials(frames) + + s = Synthesis() + s.hop_size = hop_size + synth_audio = s.synth(frames) + + assert len(synth_audio) == len(self.audio) + + +class TestSMSSynthesis(object): + @classmethod + def setup_class(cls): + cls.audio = simpl.read_wav(audio_path)[0] + cls.audio = cls.audio[0:num_samples] + + def test_basic(self): + pd = SMSPeakDetection() + pd.hop_size = hop_size + frames = pd.find_peaks(self.audio) + + pt = SMSPartialTracking() + pt.max_partials = max_partials + frames = pt.find_partials(frames) + + s = SMSSynthesis() + s.hop_size = hop_size + synth_audio = s.synth(frames) + + assert len(synth_audio) == len(self.audio) + + def test_harmonic_synthesis_ifft(self): + pd = SMSPeakDetection() + 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 + synth.det_synthesis_type = SMSSynthesis.SMS_DET_IFFT + synth_audio = synth.synth(frames) + + assert len(synth_audio) == len(self.audio) + + sms_audio, sampling_rate = simpl.read_wav( + libsms_harmonic_synthesis_ifft_path + ) + + assert len(synth_audio) == len(sms_audio) + + for i in range(len(synth_audio)): + assert_almost_equals(synth_audio[i], sms_audio[i], float_precision) + + def test_harmonic_synthesis_sin(self): + pd = SMSPeakDetection() + 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 + synth.det_synthesis_type = SMSSynthesis.SMS_DET_SIN + synth_audio = synth.synth(frames) + + assert len(synth_audio) == len(self.audio) + + sms_audio, sampling_rate = simpl.read_wav( + libsms_harmonic_synthesis_sin_path + ) + + assert len(synth_audio) == len(sms_audio) + + for i in range(len(synth_audio)): + assert_almost_equals(synth_audio[i], sms_audio[i], float_precision) |