def tearDown(self):
decoder = FileDecoder(self.source)
encoder_cls = get_processor(self.encoder_id)
file_extension = '.' + encoder_cls.file_extension()
self.target = tmp_file_sink(prefix=self.__class__.__name__,
suffix=file_extension)
encoder = encoder_cls(self.target)
(decoder | encoder).run()
decoder_encoded = FileDecoder(self.target)
pipe = ProcessPipe(decoder_encoded)
pipe.run()
os.unlink(self.target)
#print decoder.channels(), decoder.samplerate(), written_frames
#print media_channels
if self.test_channels:
self.assertEqual(decoder.channels(), decoder_encoded.channels())
else:
self.assertEqual(2, decoder_encoded.channels()) # voaacenc bug ?
self.assertEqual(decoder.samplerate(),
decoder_encoded.samplerate())
if self.test_duration:
self.assertAlmostEqual(decoder.input_duration,
decoder_encoded.input_duration,
delta=0.2)
def test_Pipe(self):
"""Test process pipe (Quick and dirty)"""
# TODO clean up and complete
source = samples["sweep.wav"]
pipe = timeside.core.processor.ProcessPipe()
dec = FileDecoder(source)
pipe.append_processor(dec)
self.assertRaises(TypeError, pipe.append_processor, object())
dec2 = FileDecoder(source)
self.assertRaises(ValueError, pipe.append_processor, dec2)
odf = timeside.plugins.analyzer.odf.OnsetDetectionFunction()
odf2 = timeside.plugins.analyzer.odf.OnsetDetectionFunction()
spectro2 = timeside.plugins.analyzer.spectrogram.Spectrogram()
pipe2 = (dec | odf | spectro2 | odf2)
self.assertEqual(pipe2, odf.process_pipe)
self.assertEqual(pipe2, odf2.process_pipe)
self.assertEqual(pipe2, spectro2.process_pipe)
self.assertEqual(len(pipe2.processors), 4)
# Release temporary buffers in Spectrogram
for proc in pipe2.processors:
proc.release()
def tearDown(self):
decoder = FileDecoder(self.source)
encoder_cls = get_processor(self.encoder_id)
file_extension = '.' + encoder_cls.file_extension()
self.target_filesink = tmp_file_sink(prefix=self.__class__.__name__,
suffix=file_extension)
self.target_appsink = tmp_file_sink(prefix=self.__class__.__name__,
suffix=file_extension)
encoder = encoder_cls(self.target_filesink, streaming=True)
pipe = (decoder | encoder)
with open(self.target_appsink, 'w') as f:
for chunk in pipe.stream():
f.write(chunk)
decoder_encoded = FileDecoder(self.target_filesink)
pipe2 = ProcessPipe(decoder_encoded)
pipe2.run()
import os
filesink_size = os.path.getsize(self.target_filesink)
appsink_size = os.path.getsize(self.target_appsink)
os.unlink(self.target_filesink)
os.unlink(self.target_appsink)
#print decoder.channels(), decoder.samplerate(), written_frames
#print media_channels
if self.test_channels:
self.assertEqual(decoder.channels(), decoder_encoded.channels())
else:
self.assertEqual(2, decoder_encoded.channels()) # voaacenc bug ?
if not self.expected_sample_rate:
self.expected_sample_rate = decoder.samplerate()
self.assertEqual(self.expected_sample_rate,
decoder_encoded.samplerate())
if self.test_duration:
self.assertAlmostEqual(decoder.input_duration,
decoder_encoded.input_duration,
delta=0.2)
self.assertAlmostEqual(filesink_size,
appsink_size,
delta=self.filesize_delta)
def tearDown(self):
decoder = FileDecoder(self.source)
(decoder | self.analyzer).run()
self.assertAlmostEqual(
self.analyzer.results['vamp_tuning'].data_object.value,
440.0,
places=1)
def testResults(self):
"Test decoder stack: test frames content"
decoder = FileDecoder(uri=self.source,
start=self.start,
duration=self.duration,
stack=True)
level = Level()
pipe = (decoder | level)
pipe.run()
self.assertIsInstance(pipe.frames_stack, list)
results_on_file = level.results['level.rms'].data.copy()
# If the pipe is used for a second run, the processed frames stored
# in the stack are passed to the other processors
# without decoding the audio source again.
pipe.results = {} # to be sure the previous results are deleted
pipe.run()
# to assert that the frames passed to the two analyzers are the same,
# we check that the results of these analyzers are equivalent:
results_on_stack = level.results['level.rms'].data
self.assertEqual(results_on_stack, results_on_file)
def tearDown(self):
decoder = FileDecoder(self.source)
(decoder | self.analyzer).run()
results = self.analyzer.results
for result_id in self.expected.keys():
result = results[result_id]
self.assertEqual(result.data_object.value,
self.expected[result_id])
def tearDown(self):
decoder = FileDecoder(self.source)
(decoder | self.analyzer).run()
results = self.analyzer.results
#print results
results.to_yaml()
results.to_json()
results.to_xml()
def tearDown(self):
decoder = FileDecoder(self.source)
(decoder | self.fx | self.level).run()
results = self.level.results
for result_id in self.expected.keys():
result = results[result_id]
self.assertAlmostEquals(result.data_object.value,
self.expected[result_id],
places=2)
def testEmptyFile(self):
"Test decoding empty file"
import tempfile
self.tmpfile = tempfile.NamedTemporaryFile(delete=True)
self.source = self.tmpfile.name
with self.assertRaises(IOError):
FileDecoder(self.source)
self.tmpfile.close()
def tearDown(self):
decoder = FileDecoder(self.source)
(decoder | self.analyzer_dissonance
| self.analyzer_dissonance_value).run()
self.assertAlmostEqual(
self.analyzer_dissonance.results['essentia_dissonance'].
data_object.value.mean(),
0.003,
places=3)
self.assertAlmostEqual(
self.analyzer_dissonance_value.
results['essentia_dissonance_value'].data_object.value,
0.109,
places=2)
def _perform_test(self, analyzer_cls, source_file):
"""Internal function that test if there is NaN in the results
of a given analyzer"""
decoder = FileDecoder(source_file)
analyzer = analyzer_cls()
pipe = (decoder | analyzer)
pipe.run()
for result in analyzer.results.values():
if 'value' in result.data_object.keys():
# Test for NaN
self.assertFalse(np.any(np.isnan(result.data)),
'NaN in %s data value' % result.name)
# Test for Inf
self.assertFalse(np.any(np.isinf(result.data)),
'Inf in %s data value' % result.name)
# Try to serialize as hdf5
h5_file = tempfile.NamedTemporaryFile(suffix='.h5', delete=True)
analyzer.results.to_hdf5(h5_file.name)
def testProcess(self):
"Test decoder stack: test process"
decoder = FileDecoder(uri=self.source,
start=self.start,
duration=self.duration,
stack=True)
self.assertTrue(decoder.stack)
self.assertFalse(decoder.from_stack)
pipe = ProcessPipe(decoder)
pipe.run()
self.assertFalse(decoder.stack)
self.assertTrue(decoder.from_stack)
self.assertEqual(len(pipe.frames_stack), 44)
pipe.run()
def setUp(self):
source = samples["C4_scale.wav"]
self.decoder = FileDecoder(source)
def testDevNull(self):
"Test decoding dev null"
self.source = "/dev/null"
with self.assertRaises(IOError):
FileDecoder(self.source)
def tearDown(self):
decoder = FileDecoder(self.source)
(decoder | self.analyzer).run()
self.assertEqual(
self.analyzer.results['vamp_constantq'].data_object.value.shape[1],
48)
def testNoAudioStream(self):
"Test decoding file withouth audio stream"
self.source = __file__
with self.assertRaises(IOError):
FileDecoder(self.source)
def tearDown(self):
decoder = FileDecoder(uri=self.source,
start=self.start,
duration=self.duration)
decoder.setup(samplerate=self.samplerate,
channels=self.channels,
blocksize=self.blocksize)
totalframes = 0
while True:
frames, eod = decoder.process()
totalframes += frames.shape[0]
if eod or decoder.eod:
break
self.assertEqual(frames.shape[0], decoder.blocksize())
self.assertEqual(frames.shape[1], decoder.channels())
ratio = decoder.output_samplerate / decoder.input_samplerate
if 0:
print "input / output_samplerate:", decoder.input_samplerate, '/', decoder.output_samplerate,
print "ratio:", ratio
print "input / output_channels:", decoder.input_channels, decoder.output_channels
print "input_duration:", decoder.input_duration
print "input_totalframes:", decoder.input_totalframes
print "mime_type", decoder.mime_type()
if self.channels:
# when specified, check that the channels are the ones requested
self.assertEqual(self.channels, decoder.output_channels)
else:
# otherwise check that the channels are preserved, if not specified
self.assertEqual(decoder.input_channels, decoder.output_channels)
# and if we know the expected channels, check the output match
if self.expected_channels:
self.assertEqual(self.expected_channels,
decoder.output_channels)
# do the same with the sampling rate
if self.samplerate:
self.assertEqual(self.samplerate, decoder.output_samplerate)
else:
self.assertEqual(decoder.input_samplerate,
decoder.output_samplerate)
if self.expected_samplerate:
self.assertEqual(self.expected_samplerate,
decoder.output_samplerate)
self.assertEqual(decoder.mime_type(), self.expected_mime_type)
expected_totalframes = int(decoder.input_duration *
decoder.output_samplerate)
input_duration = decoder.input_totalframes / decoder.input_samplerate
output_duration = decoder.totalframes() / decoder.output_samplerate
if self.test_exact_duration:
self.assertEqual(input_duration, output_duration)
self.assertEqual(input_duration, decoder.uri_duration)
self.assertEqual(self.source_duration, decoder.uri_duration)
self.assertEqual(totalframes, expected_totalframes)
else:
self.assertAlmostEqual(input_duration, output_duration, places=1)
self.assertAlmostEqual(input_duration,
decoder.uri_duration,
places=1)
self.assertAlmostEqual(self.source_duration,
decoder.uri_duration,
places=1)
self.assertAlmostEqual(totalframes, expected_totalframes, delta=69)
def test_bad_duration_value(self):
"Test decoding segment with a too large duration value argument"
decoder = FileDecoder(self.source, duration=10)
pipe = ProcessPipe(decoder)
self.assertRaises(ValueError, pipe.run)
def tearDown(self):
decoder = FileDecoder(self.source)
(decoder | self.analyzer).run()
results = self.analyzer.results
def tearDown(self):
decoder = FileDecoder(self.source)
(decoder | self.analyzer).run()
self.assertEqual(self.analyzer.results['loudness_itu.block_loudness'].data_object.value.shape[0], 91)
self.assertAlmostEqual(self.analyzer.results['loudness_itu.block_loudness'].data_object.value.mean(), -64.06, places=1)
def tearDown(self):
decoder = FileDecoder(self.source)
(decoder | self.grapher).run()
self.grapher.render(self.image)
self.assertGreater(os.path.getsize(self.image.name), 0)
self.image.close()
def tearDown(self):
decoder = FileDecoder(self.source)
decoder.output_samplerate = self.samplerate
(decoder | self.analyzer).run()
results = self.analyzer.results
self.assertEquals(self.result_length, len(results))
def setUp(self):
self.source = samples['sweep.wav']
self.source_samplerate = 44100
self.decoder = FileDecoder(uri=self.source)
def test_bad_start_value(self):
"Test decoding segment with start value exceeding the media duration"
decoder = FileDecoder(self.source, start=10)
pipe = ProcessPipe(decoder)
self.assertRaises(ValueError, pipe.run)