if curdir == '': curdir = '.'
files = os.listdir(curdir)
modfiles = filter (lambda y: y.endswith('.py'), files)
- modfiles = filter (lambda f: f.startswith('test'), modfiles)
+ modfiles = filter (lambda f: f.startswith('test_'), modfiles)
# get module names
modnames = map (lambda x: os.path.splitext(x)[0], modfiles)
# import them
--- /dev/null
+from timeside.decoder import *
+from timeside.analyzer import *
+from unit_timeside import *
+
+import os.path
+
+__all__ = ['TestAnalyzing']
+
+class TestAnalyzing(TestCase):
+ "Test all analyzers"
+
+ def setUp(self):
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
+
+ def testDC(self):
+ "Test mean DC shift"
+ self.analyzer = MeanDCShift()
+ self.value = -0
+
+ def testMeanLevel(self):
+ "Test mean level"
+ self.analyzer = MeanLevel()
+ self.value = -9.856
+
+ def testMaxLevel(self):
+ "Test max level"
+ self.analyzer = MaxLevel()
+ self.value = -6.0209999999999999
+
+ def tearDown(self):
+ decoder = FileDecoder(self.source)
+ (decoder | self.analyzer).run()
+ self.assertEquals(self.analyzer.result(), self.value)
+
+
+if __name__ == '__main__':
+ unittest.main(testRunner=TestRunner())
+
--- /dev/null
+from timeside.component import *
+from unit_timeside import *
+
+__all__ = ['TestComponentArchitecture']
+
+class TestComponentArchitecture(TestCase):
+ "Test the component and interface system"
+
+ def testOneInterface(self):
+ "Test a component implementing one interface"
+ self.assertSameList(implementations(I1), [C1])
+
+ def testTwoInterfaces(self):
+ "Test a component implementing two interfaces"
+ self.assertSameList(implementations(I2), [C2])
+ self.assertSameList(implementations(I3), [C2])
+
+ def testTwoImplementations(self):
+ "Test an interface implemented by two components"
+ self.assertSameList(implementations(I4), [C3, C4])
+
+ def testInterfaceInheritance(self):
+ "Test whether a component implements an interface's parent"
+ self.assertSameList(implementations(I5), [C5])
+
+ def testImplementationInheritance(self):
+ "Test that a component doesn't implement the interface implemented by its parent"
+ self.assertSameList(implementations(I7), [C6])
+
+ def testImplementationRedundancy(self):
+ "Test implementation redundancy across inheritance"
+ self.assertSameList(implementations(I8), [C8, C9])
+
+ def testAbstractImplementation(self):
+ "Test abstract implementation"
+ self.assertSameList(implementations(I11), [])
+ self.assertSameList(implementations(I11, abstract=True), [C11])
+
+ def testInterfaceDoc(self):
+ "Test @interfacedoc decorator"
+ self.assertEquals(C10.test.__doc__, "testdoc")
+
+ def testInterfaceDocStatic(self):
+ "Test @interfacedoc decorator on static method"
+ self.assertEquals(C10.teststatic.__doc__, "teststaticdoc")
+
+ def testIntefaceDocReversed(self):
+ "Test @interfacedoc on static method (decorators reversed)"
+
+ try:
+
+ class BogusDoc1(Component):
+ implements(I10)
+
+ @interfacedoc
+ @staticmethod
+ def teststatic(self):
+ pass
+
+ self.fail("No error raised with reversed decorators")
+
+ except ComponentError:
+ pass
+
+ def testInterfaceDocBadMethod(self):
+ "Test @interfacedoc with unexistant method in interface"
+
+ try:
+ class BogusDoc2(Component):
+ implements(I10)
+
+ @interfacedoc
+ def nosuchmethod(self):
+ pass
+
+ self.fail("No error raised when decorating an unexistant method")
+
+ except ComponentError:
+ pass
+
+class I1(Interface):
+ pass
+
+class I2(Interface):
+ pass
+
+class I3(Interface):
+ pass
+
+class I4(Interface):
+ pass
+
+class I5(Interface):
+ pass
+
+class I6(I5):
+ pass
+
+class I7(Interface):
+ pass
+
+class I8(Interface):
+ pass
+
+class I9(I8):
+ pass
+
+class I10(Interface):
+ def test(self):
+ """testdoc"""
+
+ @staticmethod
+ def teststatic(self):
+ """teststaticdoc"""
+
+class I11(Interface):
+ pass
+
+class C1(Component):
+ implements(I1)
+
+class C2(Component):
+ implements(I2, I3)
+
+class C3(Component):
+ implements(I4)
+
+class C4(Component):
+ implements(I4)
+
+class C5(Component):
+ implements(I6)
+
+class C6(Component):
+ implements(I7)
+
+class C7(C6):
+ pass
+
+class C8(Component):
+ implements(I8)
+
+class C9(Component):
+ implements(I8, I9)
+
+class C10(Component):
+ implements(I10)
+
+ @interfacedoc
+ def test(self):
+ pass
+
+ @staticmethod
+ @interfacedoc
+ def teststatic(self):
+ pass
+
+class C11(Component):
+ abstract()
+ implements(I11)
+
+if __name__ == '__main__':
+ unittest.main(testRunner=TestRunner())
+
--- /dev/null
+#! /usr/bin/env python
+
+from timeside.decoder.core import FileDecoder
+from unit_timeside import *
+
+import os.path
+
+class TestDecoding(TestCase):
+ "Test decoding features"
+
+ def setUp(self):
+ self.samplerate, self.channels, self.blocksize = None, None, None
+
+ def testWav(self):
+ "Test wav decoding"
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
+
+ self.expected_channels = 2
+ self.expected_samplerate = 44100
+
+ def testWavMono(self):
+ "Test mono wav decoding"
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_mono.wav")
+
+ self.expected_channels = 1
+ self.expected_samplerate = 44100
+
+ def testWav32k(self):
+ "Test 32kHz wav decoding"
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_32000.wav")
+
+ self.expected_channels = 2
+ self.expected_samplerate = 32000
+
+ def testFlac(self):
+ "Test flac decoding"
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac")
+
+ self.expected_channels = 2
+ self.expected_samplerate = 44100
+
+ def testOgg(self):
+ "Test ogg decoding"
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg")
+
+ self.expected_channels = 2
+ self.expected_samplerate = 44100
+
+ def testMp3(self):
+ "Test mp3 decoding"
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3")
+
+ self.expected_channels = 2
+ self.expected_samplerate = 44100
+
+ def tearDown(self):
+ decoder = FileDecoder(self.source)
+
+ 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.assertEquals(frames.shape[0], decoder.blocksize() )
+ self.assertEquals(frames.shape[1], decoder.channels() )
+
+ ratio = decoder.output_samplerate / float(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
+
+ if self.channels:
+ # when specified, check that the channels are the ones requested
+ self.assertEquals(self.channels, decoder.output_channels)
+ else:
+ # otherwise check that the channels are preserved, if not specified
+ self.assertEquals(decoder.input_channels, decoder.output_channels)
+ # and if we know the expected channels, check the output match
+ if self.expected_channels:
+ self.assertEquals(self.expected_channels, decoder.output_channels)
+ # do the same with the sampling rate
+ if self.samplerate:
+ self.assertEquals(self.samplerate, decoder.output_samplerate)
+ else:
+ self.assertEquals(decoder.input_samplerate, decoder.output_samplerate)
+ if self.expected_samplerate:
+ self.assertEquals(self.expected_samplerate, decoder.output_samplerate)
+
+ # FIXME compute actual number of frames from file
+ if ratio == 1:
+ if os.path.splitext(self.source)[-1].lower() == '.mp3':
+ self.assertEquals(totalframes, 353664)
+ elif os.path.splitext(self.source)[-1].lower() == '.ogg':
+ self.assertEquals(totalframes, 352832)
+ else:
+ if '_32000.wav' in self.source:
+ self.assertEquals(totalframes, 256000)
+ else:
+ self.assertEquals(totalframes, 352800)
+
+class TestDecodingStereo(TestDecoding):
+
+ def setUp(self):
+ self.samplerate, self.channels, self.blocksize = None, 2, None
+
+class TestDecodingMonoUpsampling(TestDecoding):
+
+ def setUp(self):
+ self.samplerate, self.channels, self.blocksize = 48000, None, None
+
+class TestDecodingMonoDownsampling(TestDecoding):
+
+ def setUp(self):
+ self.samplerate, self.channels, self.blocksize = 16000, None, None
+
+class TestDecodingStereoDownsampling(TestDecoding):
+
+ def setUp(self):
+ self.samplerate, self.channels, self.blocksize = 32000, 2, None
+
+class TestDecodingStereoUpsampling(TestDecoding):
+
+ def setUp(self):
+ self.samplerate, self.channels, self.blocksize = 96000, 2, None
+
+class TestDecodingShortBlock(TestDecoding):
+
+ def setUp(self):
+ self.samplerate, self.channels, self.blocksize = None, None, 256
+
+class TestDecodingLongBlock(TestDecoding):
+
+ def setUp(self):
+ self.samplerate, self.channels, self.blocksize = None, None, 1024*8*2
+
+class TestDecodingWrongFiles(TestCase):
+ "Test decoding features"
+
+ def testMissingFile(self):
+ "Test decoding missing file"
+ self.source = os.path.join (os.path.dirname(__file__), "a_missing_file_blahblah.wav")
+ self.assertRaises(IOError, FileDecoder, self.source)
+
+ def testDevNull(self):
+ "Test decoding dev null"
+ self.source = "/dev/null"
+ decoder = FileDecoder(self.source)
+ self.assertRaises(IOError, FileDecoder.setup, decoder)
+
+ def testNoAudioStream(self):
+ "Test decoding file withouth audio stream"
+ self.source = __file__
+ decoder = FileDecoder(self.source)
+ self.assertRaises(IOError, FileDecoder.setup, decoder)
+
+ def testEmptyFile(self):
+ "Test decoding empty file"
+ import tempfile
+ self.tmpfile = tempfile.NamedTemporaryFile(delete=True)
+ self.source = self.tmpfile.name
+ decoder = FileDecoder(self.source)
+ self.assertRaises(IOError, FileDecoder.setup, decoder)
+ self.tmpfile.close()
+
+if __name__ == '__main__':
+ unittest.main(testRunner=TestRunner())
--- /dev/null
+from math import pi
+from numpy import arange, sin, zeros
+from unit_timeside import *
+
+import os.path
+from os import unlink
+
+class TestEncoding(TestCase):
+ "Test encoding features"
+
+ def setUp(self):
+ self.samplerate, self.channels, self.blocksize = 44100, 1, 1024
+ import tempfile
+ self.tmpfile = tempfile.NamedTemporaryFile(delete=True)
+ self.sink = self.tmpfile.name
+ self.tmpfile.close()
+
+ def testWav(self):
+ "Test wav encoding"
+ from timeside.encoder.wav import WavEncoder
+ self.encoder = WavEncoder(self.sink)
+
+ def testVorbis(self):
+ "Test vorbis encoding"
+ from timeside.encoder.ogg import VorbisEncoder
+ self.encoder = VorbisEncoder(self.sink)
+
+ def testMp3(self):
+ "Test mp3 encoding"
+ from timeside.encoder.mp3 import Mp3Encoder
+ self.encoder = Mp3Encoder(self.sink)
+
+ # def testAac(self):
+ # "Test aac encoding"
+ # from timeside.encoder.m4a import AacEncoder
+ # self.encoder = AacEncoder(self.sink)
+
+ def testFlac(self):
+ "Test flac encoding"
+ from timeside.encoder.flac import FlacEncoder
+ self.encoder = FlacEncoder(self.sink)
+
+ # def testWebm(self):
+ # "Test webm encoding"
+ # from timeside.encoder.webm import WebMEncoder
+ # self.encoder = WebMEncoder(self.sink)
+
+ def tearDown(self):
+
+ self.encoder.setup(channels = self.channels, samplerate = self.samplerate)
+
+ written_frames, eod = 0, False
+ total_frames = 3. * self.samplerate
+ block_size = self.blocksize
+ f0 = 800.
+ omega = 2. * pi * f0 / float(self.samplerate)
+
+ while True:
+ remaining = total_frames - written_frames
+ if remaining >= block_size:
+ write_length = block_size
+ else:
+ write_length = remaining
+ eod = True
+ # build a sinusoid
+ frames = .75 * sin( omega * (arange(write_length) + written_frames) )
+ # process encoder, writing to file
+ self.encoder.process(frames, eod)
+ written_frames += frames.shape[0]
+ if eod:
+ self.assertEquals(self.encoder.eod, True)
+ break
+
+ self.encoder.release()
+
+ if 0:
+ import commands
+ print commands.getoutput('sndfile-info ' + self.sink)
+
+ self.assertEquals(written_frames, total_frames)
+
+ if hasattr(self, 'tmpfile'): unlink(self.sink)
+
+class TestEncodingLongBlock(TestEncoding):
+ "Test encoding features with longer blocksize"
+
+ def setUp(self):
+ super(TestEncodingLongBlock, self).setUp()
+ self.blocksize *= 8
+
+class TestEncodingShortBlock(TestEncoding):
+ "Test encoding features with short blocksize"
+
+ def setUp(self):
+ super(TestEncodingShortBlock, self).setUp()
+ self.blocksize = 64
+
+class TestEncodingLowSamplerate(TestEncoding):
+ "Test encoding features with low samplerate"
+
+ def setUp(self):
+ super(TestEncodingLowSamplerate, self).setUp()
+ self.samplerate = 8000
+
+class TestEncodingHighSamplerate(TestEncoding):
+ "Test encoding features with high samplerate"
+
+ def setUp(self):
+ super(TestEncodingHighSamplerate, self).setUp()
+ self.samplerate = 48000
+
+ def testMp3(self):
+ "Test mp3 encoding"
+ from timeside.encoder.mp3 import Mp3Encoder
+ self.encoder = Mp3Encoder(self.sink)
+
+
+# class TestEncodingTooManyChannels(TestEncoding):
+# "Test encoding features with high samplerate"
+
+# def setUp(self):
+# super(TestEncodingTooManyChannels, self).setUp()
+# self.samplerate = 192000 * 2
+# self.channels = 128
+
+# def tearDown(self):
+# self.encoder.setup(channels = self.channels, samplerate = self.samplerate)
+# self.assertRaises(IOError, self.encoder.release)
+# unlink(self.sink)
+
+class TestEncodingStereo(TestEncoding):
+ "Test encoding features with stereo"
+
+ def setUp(self):
+ super(TestEncodingStereo, self).setUp()
+ self.channels = 2
+
+class TestEncodingToDevNull(TestEncoding):
+ "Test encoding features with /dev/null"
+
+ def setUp(self):
+ self.samplerate, self.channels, self.blocksize = 44100, 1, 1024
+ self.sink = '/dev/null'
+
+class TestEncodingToDirectory(TestEncoding):
+ "Test encoding features to a directory"
+
+ def setUp(self):
+ self.samplerate, self.channels, self.blocksize = 44100, 1, 1024
+ import tempfile
+ self.sink = tempfile.mkdtemp()
+
+ def testWav(self):
+ "Test wav encoding"
+ from timeside.encoder.wav import WavEncoder
+ self.assertRaises(IOError,WavEncoder,self.sink)
+
+ def testVorbis(self):
+ "Test vorbis encoding"
+ from timeside.encoder.ogg import VorbisEncoder
+ self.assertRaises(IOError,VorbisEncoder,self.sink)
+
+ def testMp3(self):
+ "Test mp3 encoding"
+ from timeside.encoder.mp3 import Mp3Encoder
+ self.assertRaises(IOError,Mp3Encoder,self.sink)
+
+ # def testAac(self):
+ # "Test aac encoding"
+ # from timeside.encoder.m4a import AacEncoder
+ # self.assertRaises(IOError,AacEncoder,self.sink)
+
+ def testFlac(self):
+ "Test flac encoding"
+ from timeside.encoder.flac import FlacEncoder
+ self.assertRaises(IOError,FlacEncoder,self.sink)
+
+ # def testWebm(self):
+ # "Test webm encoding"
+ # from timeside.encoder.webm import WebMEncoder
+ # self.assertRaises(IOError,WebMEncoder,self.sink)
+
+ def tearDown(self):
+ from os import rmdir
+ rmdir(self.sink)
+
+class TestEncodingOverwriteFails(TestCase):
+ "Test encoding features"
+
+ def setUp(self):
+ self.samplerate, self.channels, self.blocksize = 44100, 1, 1024
+ import tempfile
+ self.tmpfile = tempfile.NamedTemporaryFile(delete=True)
+ self.sink = self.tmpfile.name
+
+ def testWav(self):
+ "Test wav encoding"
+ from timeside.encoder.wav import WavEncoder
+ self.assertRaises(IOError,WavEncoder,self.sink)
+
+ def testVorbis(self):
+ "Test vorbis encoding"
+ from timeside.encoder.ogg import VorbisEncoder
+ self.assertRaises(IOError,VorbisEncoder,self.sink)
+
+ def testMp3(self):
+ "Test mp3 encoding"
+ from timeside.encoder.mp3 import Mp3Encoder
+ self.assertRaises(IOError,Mp3Encoder,self.sink)
+
+ # def testAac(self):
+ # "Test aac encoding"
+ # from timeside.encoder.m4a import AacEncoder
+ # self.assertRaises(IOError,AacEncoder,self.sink)
+
+ def testFlac(self):
+ "Test flac encoding"
+ from timeside.encoder.flac import FlacEncoder
+ self.assertRaises(IOError,FlacEncoder,self.sink)
+
+ def testWebm(self):
+ "Test webm encoding"
+ from timeside.encoder.webm import WebMEncoder
+ self.assertRaises(IOError,WebMEncoder,self.sink)
+
+class TestEncodingOverwriteForced(TestCase):
+ "Test encoding features"
+
+ def setUp(self):
+ self.samplerate, self.channels, self.blocksize = 44100, 1, 1024
+ import tempfile
+ self.tmpfile = tempfile.NamedTemporaryFile(delete=True)
+ self.sink = self.tmpfile.name
+
+ def testWav(self):
+ "Test wav encoding"
+ from timeside.encoder.wav import WavEncoder
+ self.encoder = WavEncoder(self.sink, overwrite = True)
+
+ def testVorbis(self):
+ "Test vorbis encoding"
+ from timeside.encoder.ogg import VorbisEncoder
+ self.encoder = VorbisEncoder(self.sink, overwrite = True)
+
+ def testMp3(self):
+ "Test mp3 encoding"
+ from timeside.encoder.mp3 import Mp3Encoder
+ self.encoder = Mp3Encoder(self.sink, overwrite = True)
+
+ # def testAac(self):
+ # "Test aac encoding"
+ # from timeside.encoder.m4a import AacEncoder
+ # self.encoder = AacEncoder(self.sink, overwrite = True)
+
+ def testFlac(self):
+ "Test flac encoding"
+ from timeside.encoder.flac import FlacEncoder
+ self.encoder = FlacEncoder(self.sink, overwrite = True)
+
+ # def testWebm(self):
+ # "Test webm encoding"
+ # from timeside.encoder.webm import WebMEncoder
+ # self.encoder = WebMEncoder(self.sink, overwrite = True)
+
+ def tearDown(self):
+ super(TestEncodingOverwriteForced, self).tearDown()
+ self.tmpfile.close()
+
+if __name__ == '__main__':
+ unittest.main(testRunner=TestRunner())
--- /dev/null
+from timeside.decoder.core import FileDecoder
+from unit_timeside import *
+
+import os.path
+
+__all__ = ['TestGraphing']
+
+class TestGraphing(TestCase):
+ "Test all graphers with various input media formats"
+
+ def setUp(self):
+ pass
+
+ # WAVEFORMS
+ def testWav2Waveform(self):
+ "Test WAV to Waveform"
+ from timeside.grapher.waveform import Waveform
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
+ self.image = "/tmp/test_waveform_sweep_wav.png"
+ self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ def testFlac2Waveform(self):
+ "Test FLAC to Waveform"
+ from timeside.grapher.waveform import Waveform
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac")
+ self.image = "/tmp/test_waveform_sweep_flac.png"
+ self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ def testMp32Waveform(self):
+ "Test MP3 to Waveform"
+ from timeside.grapher.waveform import Waveform
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3")
+ self.image = "/tmp/test_waveform_sweep_mp3.png"
+ self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ def testOgg2Waveform(self):
+ "Test OGG to Waveform"
+ from timeside.grapher.waveform import Waveform
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg")
+ self.image = "/tmp/test_waveform_sweep_ogg.png"
+ self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ # WAVEFORM SIMPLE
+ def testWav2WaveformSimple(self):
+ "Test WAV to WaveformSimple"
+ from timeside.grapher.waveform_simple import WaveformSimple
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
+ self.image = "/tmp/test_waveform_simple_sweep_wav.png"
+ self.grapher = WaveformSimple(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ # WAVEFORMS CONTOUR BLACK
+ def testWav2WaveformContourBlack(self):
+ "Test WAV to WaveformContourBlack"
+ from timeside.grapher.waveform_contour_bk import WaveformContourBlack
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
+ self.image = "/tmp/test_waveform_contour_bk_sweep_wav.png"
+ self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ def testFlac2WaveformContourBlack(self):
+ "Test FLAC to WaveformContourBlack"
+ from timeside.grapher.waveform_contour_bk import WaveformContourBlack
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac")
+ self.image = "/tmp/test_waveform_contour_bk_sweep_flac.png"
+ self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ def testMp32WaveformContourBlack(self):
+ "Test MP3 to WaveformContourBlack"
+ from timeside.grapher.waveform_contour_bk import WaveformContourBlack
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3")
+ self.image = "/tmp/test_waveform_contour_bk_sweep_mp3.png"
+ self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ def testOgg2WaveformContourBlack(self):
+ "Test OGG to WaveformContourBlack"
+ from timeside.grapher.waveform_contour_bk import WaveformContourBlack
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg")
+ self.image = "/tmp/test_waveform_contour_bk_sweep_ogg.png"
+ self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ # WAVEFORMS CONTOUR WHITE
+ def testWav2WaveformContourWhite(self):
+ "Test WAV to WaveformContourWhite"
+ from timeside.grapher.waveform_contour_wh import WaveformContourWhite
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
+ self.image = "/tmp/test_waveform_contour_wh_sweep_wav.png"
+ self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ def testFlac2WaveformContourWhite(self):
+ "Test FLAC to WaveformContourWhite"
+ from timeside.grapher.waveform_contour_wh import WaveformContourWhite
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac")
+ self.image = "/tmp/test_waveform_contour_wh_sweep_flac.png"
+ self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ def testMp32WaveformContourWhite(self):
+ "Test MP3 to WaveformContourWhite"
+ from timeside.grapher.waveform_contour_wh import WaveformContourWhite
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3")
+ self.image = "/tmp/test_waveform_contour_wh_sweep_mp3.png"
+ self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ def testOggWaveformContourWhite(self):
+ "Test OGG to WaveformContourWhite"
+ from timeside.grapher.waveform_contour_wh import WaveformContourWhite
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg")
+ self.image = "/tmp/test_waveform_contour_wh_sweep_ogg.png"
+ self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+
+ # SPECTROGRAMS
+ def testWav2Spectrogram(self):
+ "Test WAV to Spectrogram"
+ from timeside.grapher.spectrogram import Spectrogram
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
+ self.image = "/tmp/test_spectrogram_sweep_wav.png"
+ self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ def testMp32Spectrogram(self):
+ "Test MP3 to Spectrogram"
+ from timeside.grapher.spectrogram import Spectrogram
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3")
+ self.image = "/tmp/test_spectrogram_sweep_mp3.png"
+ self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ def testFlac2Spectrogram(self):
+ "Test FLAC to Spectrogram"
+ from timeside.grapher.spectrogram import Spectrogram
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac")
+ self.image = "/tmp/test_spectrogram_sweep_flac.png"
+ self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ def testOgg2Spectrogram(self):
+ "Test OGG to Spectrogram"
+ from timeside.grapher.spectrogram import Spectrogram
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg")
+ self.image = "/tmp/test_spectrogram_sweep_ogg.png"
+ self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
+
+ def tearDown(self):
+ decoder = FileDecoder(self.source)
+ (decoder | self.grapher).run()
+ self.grapher.render(self.image)
+
+if __name__ == '__main__':
+ unittest.main(testRunner=TestRunner())
+
--- /dev/null
+from timeside.core import FixedSizeInputAdapter
+from unit_timeside import *
+import numpy
+
+class TestFixedSizeInputAdapter(TestCase):
+ "Test the fixed-sized input adapter"
+
+ def assertIOEquals(self, adapter, input, input_eod, output, output_eod=None):
+ output = output[:]
+ output.reverse()
+ _eod = None
+ for buffer, _eod in adapter.process(input, input_eod):
+ a = output.pop()
+ if not numpy.array_equiv(buffer, a):
+ self.fail("\n-- Actual --\n%s\n -- Expected -- \n%s\n" % (str(buffer), str(a)))
+
+ if _eod != output_eod:
+ self.fail("eod do not match: %s != %s", (str(_eod), str(output_eod)))
+
+ if output:
+ self.fail("trailing expected data: %s" % output)
+
+ def setUp(self):
+ self.data = numpy.arange(44).reshape(2,22).transpose()
+
+ def testTwoChannels(self):
+ "Test simple stream with two channels"
+ adapter = FixedSizeInputAdapter(4, 2)
+
+ self.assertEquals(len(self.data), adapter.blocksize(len(self.data)))
+
+ self.assertIOEquals(adapter, self.data[0:1], False, [])
+ self.assertIOEquals(adapter, self.data[1:5], False, [self.data[0:4]], False)
+ self.assertIOEquals(adapter, self.data[5:12], False, [self.data[4:8], self.data[8:12]], False)
+ self.assertIOEquals(adapter, self.data[12:13], False, [])
+ self.assertIOEquals(adapter, self.data[13:14], False, [])
+ self.assertIOEquals(adapter, self.data[14:18], False, [self.data[12:16]], False)
+ self.assertIOEquals(adapter, self.data[18:20], False, [self.data[16:20]], False)
+ self.assertIOEquals(adapter, self.data[20:21], False, [])
+ self.assertIOEquals(adapter, self.data[21:22], True, [self.data[20:22]], True)
+
+ def testPadding(self):
+ "Test automatic padding support"
+ adapter = FixedSizeInputAdapter(4, 2, pad=True)
+
+ self.assertEquals(len(self.data) + 2, adapter.blocksize(len(self.data)))
+
+ self.assertIOEquals(adapter, self.data[0:21], False,
+ [self.data[0:4], self.data[4:8], self.data[8:12], self.data[12:16], self.data[16:20]],
+ False)
+
+ self.assertIOEquals(adapter, self.data[21:22], True, [[
+ [20, 42],
+ [21, 43],
+ [0, 0],
+ [0, 0]
+ ]], True)
+
+ def testSizeMultiple(self):
+ "Test a stream which contain a multiple number of buffers"
+ adapter = FixedSizeInputAdapter(4, 2)
+
+ self.assertIOEquals(adapter, self.data[0:20], True,
+ [self.data[0:4], self.data[4:8], self.data[8:12], self.data[12:16], self.data[16:20]],
+ True)
+
+
+if __name__ == '__main__':
+ unittest.main(testRunner=TestRunner())
+
--- /dev/null
+from timeside.core import *
+from timeside.decoder import *
+from timeside.analyzer import *
+from timeside.encoder import *
+from timeside.api import *
+from timeside.component import *
+
+from unit_timeside import *
+
+import os.path
+
+class TestTranscodingFromWav(TestCase):
+ "Test transcoding from wav"
+
+ def tmpTarget(self):
+ import tempfile
+ self.tmpfile = tempfile.NamedTemporaryFile(delete=True)
+ self.target = self.tmpfile.name
+ self.tmpfile.close()
+
+ def setUp(self):
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
+
+ def testToWav(self):
+ "Test conversion to wav"
+ self.tmpTarget()
+ self.encoder = WavEncoder(self.target)
+
+ def testToMp3(self):
+ "Test conversion to mp3"
+ self.tmpTarget()
+ self.encoder = Mp3Encoder(self.target)
+
+ def testToOgg(self):
+ "Test conversion to ogg"
+ self.tmpTarget()
+ self.encoder = VorbisEncoder(self.target)
+
+ # def testToWebM(self):
+ # "Test conversion to webm"
+ # self.tmpTarget()
+ # self.encoder = WebMEncoder(self.target)
+
+ # def testToM4a(self):
+ # "Test conversion to m4a"
+ # self.tmpTarget()
+ # self.encoder = AacEncoder(self.target)
+
+ def setUpDecoder(self):
+ self.decoder = FileDecoder(self.source)
+ self.decoder.setup()
+ self.channels = self.decoder.channels()
+ self.samplerate = self.decoder.samplerate()
+
+ def setUpEncoder(self):
+ self.encoder.setup(channels = self.channels, samplerate = self.samplerate)
+
+ def tearDown(self):
+ self.setUpDecoder()
+ self.setUpEncoder()
+
+ totalframes = 0
+ while True:
+ frames, eod = self.decoder.process()
+ self.encoder.process(frames, eod)
+ totalframes += frames.shape[0]
+ if eod or self.encoder.eod: break
+
+
+ #print self.channels, self.samplerate, totalframes
+
+ self.encoder.release()
+
+ decoder = FileDecoder(self.target)
+ decoder.setup()
+ written_frames = 0
+ while True:
+ frames, eod = decoder.process()
+ written_frames += frames.shape[0]
+ if eod: break
+
+ #print decoder.channels(), decoder.samplerate(), written_frames
+
+ self.assertEquals(self.channels, decoder.channels())
+ self.assertEquals(self.samplerate, decoder.samplerate())
+ self.assertTrue(written_frames - totalframes >= 0)
+
+ import os
+ os.unlink(self.target)
+
+class TestTranscodingFromAnotherWav(TestTranscodingFromWav):
+ "Test transcoding from another wav"
+
+ def setUp(self):
+ self.source = os.path.join (os.path.dirname(__file__), "samples/guitar.wav")
+
+class TestTranscodingFromMp3(TestTranscodingFromWav):
+ "Test transcoding from mp3"
+
+ def setUp(self):
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3")
+
+class TestTranscodingFromFlac(TestTranscodingFromWav):
+ "Test transcoding from flac"
+
+ def setUp(self):
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac")
+
+class TestTranscodingFromOgg(TestTranscodingFromWav):
+ "Test transcoding from ogg"
+
+ def setUp(self):
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg")
+
+class TestTranscodingFromMonoWav(TestTranscodingFromWav):
+ "Test transcoding from a mono wav"
+
+ def setUp(self):
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_mono.wav")
+
+class TestTranscodingFrom32kHzWav(TestTranscodingFromWav):
+ "Test transcoding from a 32kHz wav"
+
+ def setUp(self):
+ self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_32000.wav")
+
+class TestTranscodingFromMissingFile(TestTranscodingFromWav):
+ "Test transcoding from a missing file"
+
+ def setUp(self):
+ self.source = os.path.join (os.path.dirname(__file__), "samples/unexisting.wav")
+
+ def tearDown(self):
+ self.assertRaises(IOError, self.setUpDecoder)
+
+if __name__ == '__main__':
+ unittest.main(testRunner=TestRunner())
+++ /dev/null
-from timeside.decoder import *
-from timeside.analyzer import *
-from unit_timeside import *
-
-import os.path
-
-__all__ = ['TestAnalyzing']
-
-class TestAnalyzing(TestCase):
- "Test all analyzers"
-
- def setUp(self):
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
-
- def testDC(self):
- "Test mean DC shift"
- self.analyzer = MeanDCShift()
- self.value = -0
-
- def testMeanLevel(self):
- "Test mean level"
- self.analyzer = MeanLevel()
- self.value = -9.856
-
- def testMaxLevel(self):
- "Test max level"
- self.analyzer = MaxLevel()
- self.value = -6.0209999999999999
-
- def tearDown(self):
- decoder = FileDecoder(self.source)
- (decoder | self.analyzer).run()
- self.assertEquals(self.analyzer.result(), self.value)
-
-
-if __name__ == '__main__':
- unittest.main(testRunner=TestRunner())
-
+++ /dev/null
-from timeside.component import *
-from unit_timeside import *
-
-__all__ = ['TestComponentArchitecture']
-
-class TestComponentArchitecture(TestCase):
- "Test the component and interface system"
-
- def testOneInterface(self):
- "Test a component implementing one interface"
- self.assertSameList(implementations(I1), [C1])
-
- def testTwoInterfaces(self):
- "Test a component implementing two interfaces"
- self.assertSameList(implementations(I2), [C2])
- self.assertSameList(implementations(I3), [C2])
-
- def testTwoImplementations(self):
- "Test an interface implemented by two components"
- self.assertSameList(implementations(I4), [C3, C4])
-
- def testInterfaceInheritance(self):
- "Test whether a component implements an interface's parent"
- self.assertSameList(implementations(I5), [C5])
-
- def testImplementationInheritance(self):
- "Test that a component doesn't implement the interface implemented by its parent"
- self.assertSameList(implementations(I7), [C6])
-
- def testImplementationRedundancy(self):
- "Test implementation redundancy across inheritance"
- self.assertSameList(implementations(I8), [C8, C9])
-
- def testAbstractImplementation(self):
- "Test abstract implementation"
- self.assertSameList(implementations(I11), [])
- self.assertSameList(implementations(I11, abstract=True), [C11])
-
- def testInterfaceDoc(self):
- "Test @interfacedoc decorator"
- self.assertEquals(C10.test.__doc__, "testdoc")
-
- def testInterfaceDocStatic(self):
- "Test @interfacedoc decorator on static method"
- self.assertEquals(C10.teststatic.__doc__, "teststaticdoc")
-
- def testIntefaceDocReversed(self):
- "Test @interfacedoc on static method (decorators reversed)"
-
- try:
-
- class BogusDoc1(Component):
- implements(I10)
-
- @interfacedoc
- @staticmethod
- def teststatic(self):
- pass
-
- self.fail("No error raised with reversed decorators")
-
- except ComponentError:
- pass
-
- def testInterfaceDocBadMethod(self):
- "Test @interfacedoc with unexistant method in interface"
-
- try:
- class BogusDoc2(Component):
- implements(I10)
-
- @interfacedoc
- def nosuchmethod(self):
- pass
-
- self.fail("No error raised when decorating an unexistant method")
-
- except ComponentError:
- pass
-
-class I1(Interface):
- pass
-
-class I2(Interface):
- pass
-
-class I3(Interface):
- pass
-
-class I4(Interface):
- pass
-
-class I5(Interface):
- pass
-
-class I6(I5):
- pass
-
-class I7(Interface):
- pass
-
-class I8(Interface):
- pass
-
-class I9(I8):
- pass
-
-class I10(Interface):
- def test(self):
- """testdoc"""
-
- @staticmethod
- def teststatic(self):
- """teststaticdoc"""
-
-class I11(Interface):
- pass
-
-class C1(Component):
- implements(I1)
-
-class C2(Component):
- implements(I2, I3)
-
-class C3(Component):
- implements(I4)
-
-class C4(Component):
- implements(I4)
-
-class C5(Component):
- implements(I6)
-
-class C6(Component):
- implements(I7)
-
-class C7(C6):
- pass
-
-class C8(Component):
- implements(I8)
-
-class C9(Component):
- implements(I8, I9)
-
-class C10(Component):
- implements(I10)
-
- @interfacedoc
- def test(self):
- pass
-
- @staticmethod
- @interfacedoc
- def teststatic(self):
- pass
-
-class C11(Component):
- abstract()
- implements(I11)
-
-if __name__ == '__main__':
- unittest.main(testRunner=TestRunner())
-
+++ /dev/null
-from timeside.decoder.core import FileDecoder
-from unit_timeside import *
-
-import os.path
-
-class TestDecoding(TestCase):
- "Test decoding features"
-
- def setUp(self):
- self.samplerate, self.channels, self.blocksize = None, None, None
-
- def testWav(self):
- "Test wav decoding"
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
-
- self.expected_channels = 2
- self.expected_samplerate = 44100
-
- def testWavMono(self):
- "Test mono wav decoding"
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_mono.wav")
-
- self.expected_channels = 1
- self.expected_samplerate = 44100
-
- def testWav32k(self):
- "Test 32kHz wav decoding"
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_32000.wav")
-
- self.expected_channels = 2
- self.expected_samplerate = 32000
-
- def testFlac(self):
- "Test flac decoding"
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac")
-
- self.expected_channels = 2
- self.expected_samplerate = 44100
-
- def testOgg(self):
- "Test ogg decoding"
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg")
-
- self.expected_channels = 2
- self.expected_samplerate = 44100
-
- def testMp3(self):
- "Test mp3 decoding"
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3")
-
- self.expected_channels = 2
- self.expected_samplerate = 44100
-
- def tearDown(self):
- decoder = FileDecoder(self.source)
-
- 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.assertEquals(frames.shape[0], decoder.blocksize() )
- self.assertEquals(frames.shape[1], decoder.channels() )
-
- ratio = decoder.output_samplerate / float(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
-
- if self.channels:
- # when specified, check that the channels are the ones requested
- self.assertEquals(self.channels, decoder.output_channels)
- else:
- # otherwise check that the channels are preserved, if not specified
- self.assertEquals(decoder.input_channels, decoder.output_channels)
- # and if we know the expected channels, check the output match
- if self.expected_channels:
- self.assertEquals(self.expected_channels, decoder.output_channels)
- # do the same with the sampling rate
- if self.samplerate:
- self.assertEquals(self.samplerate, decoder.output_samplerate)
- else:
- self.assertEquals(decoder.input_samplerate, decoder.output_samplerate)
- if self.expected_samplerate:
- self.assertEquals(self.expected_samplerate, decoder.output_samplerate)
-
- # FIXME compute actual number of frames from file
- if ratio == 1:
- if os.path.splitext(self.source)[-1].lower() == '.mp3':
- self.assertEquals(totalframes, 353664)
- elif os.path.splitext(self.source)[-1].lower() == '.ogg':
- self.assertEquals(totalframes, 352832)
- else:
- if '_32000.wav' in self.source:
- self.assertEquals(totalframes, 256000)
- else:
- self.assertEquals(totalframes, 352800)
-
-class TestDecodingStereo(TestDecoding):
-
- def setUp(self):
- self.samplerate, self.channels, self.blocksize = None, 2, None
-
-class TestDecodingMonoUpsampling(TestDecoding):
-
- def setUp(self):
- self.samplerate, self.channels, self.blocksize = 48000, None, None
-
-class TestDecodingMonoDownsampling(TestDecoding):
-
- def setUp(self):
- self.samplerate, self.channels, self.blocksize = 16000, None, None
-
-class TestDecodingStereoDownsampling(TestDecoding):
-
- def setUp(self):
- self.samplerate, self.channels, self.blocksize = 32000, 2, None
-
-class TestDecodingStereoUpsampling(TestDecoding):
-
- def setUp(self):
- self.samplerate, self.channels, self.blocksize = 96000, 2, None
-
-class TestDecodingShortBlock(TestDecoding):
-
- def setUp(self):
- self.samplerate, self.channels, self.blocksize = None, None, 256
-
-class TestDecodingLongBlock(TestDecoding):
-
- def setUp(self):
- self.samplerate, self.channels, self.blocksize = None, None, 1024*8*2
-
-class TestDecodingWrongFiles(TestCase):
- "Test decoding features"
-
- def testMissingFile(self):
- "Test decoding missing file"
- self.source = os.path.join (os.path.dirname(__file__), "a_missing_file_blahblah.wav")
- self.assertRaises(IOError, FileDecoder, self.source)
-
- def testDevNull(self):
- "Test decoding dev null"
- self.source = "/dev/null"
- decoder = FileDecoder(self.source)
- self.assertRaises(IOError, FileDecoder.setup, decoder)
-
- def testNoAudioStream(self):
- "Test decoding file withouth audio stream"
- self.source = __file__
- decoder = FileDecoder(self.source)
- self.assertRaises(IOError, FileDecoder.setup, decoder)
-
- def testEmptyFile(self):
- "Test decoding empty file"
- import tempfile
- self.tmpfile = tempfile.NamedTemporaryFile(delete=True)
- self.source = self.tmpfile.name
- decoder = FileDecoder(self.source)
- self.assertRaises(IOError, FileDecoder.setup, decoder)
- self.tmpfile.close()
-
-if __name__ == '__main__':
- unittest.main(testRunner=TestRunner())
+++ /dev/null
-from math import pi
-from numpy import arange, sin, zeros
-from unit_timeside import *
-
-import os.path
-from os import unlink
-
-class TestEncoding(TestCase):
- "Test encoding features"
-
- def setUp(self):
- self.samplerate, self.channels, self.blocksize = 44100, 1, 1024
- import tempfile
- self.tmpfile = tempfile.NamedTemporaryFile(delete=True)
- self.sink = self.tmpfile.name
- self.tmpfile.close()
-
- def testWav(self):
- "Test wav encoding"
- from timeside.encoder.wav import WavEncoder
- self.encoder = WavEncoder(self.sink)
-
- def testVorbis(self):
- "Test vorbis encoding"
- from timeside.encoder.ogg import VorbisEncoder
- self.encoder = VorbisEncoder(self.sink)
-
- def testMp3(self):
- "Test mp3 encoding"
- from timeside.encoder.mp3 import Mp3Encoder
- self.encoder = Mp3Encoder(self.sink)
-
- # def testAac(self):
- # "Test aac encoding"
- # from timeside.encoder.m4a import AacEncoder
- # self.encoder = AacEncoder(self.sink)
-
- def testFlac(self):
- "Test flac encoding"
- from timeside.encoder.flac import FlacEncoder
- self.encoder = FlacEncoder(self.sink)
-
- # def testWebm(self):
- # "Test webm encoding"
- # from timeside.encoder.webm import WebMEncoder
- # self.encoder = WebMEncoder(self.sink)
-
- def tearDown(self):
-
- self.encoder.setup(channels = self.channels, samplerate = self.samplerate)
-
- written_frames, eod = 0, False
- total_frames = 3. * self.samplerate
- block_size = self.blocksize
- f0 = 800.
- omega = 2. * pi * f0 / float(self.samplerate)
-
- while True:
- remaining = total_frames - written_frames
- if remaining >= block_size:
- write_length = block_size
- else:
- write_length = remaining
- eod = True
- # build a sinusoid
- frames = .75 * sin( omega * (arange(write_length) + written_frames) )
- # process encoder, writing to file
- self.encoder.process(frames, eod)
- written_frames += frames.shape[0]
- if eod:
- self.assertEquals(self.encoder.eod, True)
- break
-
- self.encoder.release()
-
- if 0:
- import commands
- print commands.getoutput('sndfile-info ' + self.sink)
-
- self.assertEquals(written_frames, total_frames)
-
- if hasattr(self, 'tmpfile'): unlink(self.sink)
-
-class TestEncodingLongBlock(TestEncoding):
- "Test encoding features with longer blocksize"
-
- def setUp(self):
- super(TestEncodingLongBlock, self).setUp()
- self.blocksize *= 8
-
-class TestEncodingShortBlock(TestEncoding):
- "Test encoding features with short blocksize"
-
- def setUp(self):
- super(TestEncodingShortBlock, self).setUp()
- self.blocksize = 64
-
-class TestEncodingLowSamplerate(TestEncoding):
- "Test encoding features with low samplerate"
-
- def setUp(self):
- super(TestEncodingLowSamplerate, self).setUp()
- self.samplerate = 8000
-
-class TestEncodingHighSamplerate(TestEncoding):
- "Test encoding features with high samplerate"
-
- def setUp(self):
- super(TestEncodingHighSamplerate, self).setUp()
- self.samplerate = 48000
-
- def testMp3(self):
- "Test mp3 encoding"
- from timeside.encoder.mp3 import Mp3Encoder
- self.encoder = Mp3Encoder(self.sink)
-
-
-# class TestEncodingTooManyChannels(TestEncoding):
-# "Test encoding features with high samplerate"
-
-# def setUp(self):
-# super(TestEncodingTooManyChannels, self).setUp()
-# self.samplerate = 192000 * 2
-# self.channels = 128
-
-# def tearDown(self):
-# self.encoder.setup(channels = self.channels, samplerate = self.samplerate)
-# self.assertRaises(IOError, self.encoder.release)
-# unlink(self.sink)
-
-class TestEncodingStereo(TestEncoding):
- "Test encoding features with stereo"
-
- def setUp(self):
- super(TestEncodingStereo, self).setUp()
- self.channels = 2
-
-class TestEncodingToDevNull(TestEncoding):
- "Test encoding features with /dev/null"
-
- def setUp(self):
- self.samplerate, self.channels, self.blocksize = 44100, 1, 1024
- self.sink = '/dev/null'
-
-class TestEncodingToDirectory(TestEncoding):
- "Test encoding features to a directory"
-
- def setUp(self):
- self.samplerate, self.channels, self.blocksize = 44100, 1, 1024
- import tempfile
- self.sink = tempfile.mkdtemp()
-
- def testWav(self):
- "Test wav encoding"
- from timeside.encoder.wav import WavEncoder
- self.assertRaises(IOError,WavEncoder,self.sink)
-
- def testVorbis(self):
- "Test vorbis encoding"
- from timeside.encoder.ogg import VorbisEncoder
- self.assertRaises(IOError,VorbisEncoder,self.sink)
-
- def testMp3(self):
- "Test mp3 encoding"
- from timeside.encoder.mp3 import Mp3Encoder
- self.assertRaises(IOError,Mp3Encoder,self.sink)
-
- # def testAac(self):
- # "Test aac encoding"
- # from timeside.encoder.m4a import AacEncoder
- # self.assertRaises(IOError,AacEncoder,self.sink)
-
- def testFlac(self):
- "Test flac encoding"
- from timeside.encoder.flac import FlacEncoder
- self.assertRaises(IOError,FlacEncoder,self.sink)
-
- # def testWebm(self):
- # "Test webm encoding"
- # from timeside.encoder.webm import WebMEncoder
- # self.assertRaises(IOError,WebMEncoder,self.sink)
-
- def tearDown(self):
- from os import rmdir
- rmdir(self.sink)
-
-class TestEncodingOverwriteFails(TestCase):
- "Test encoding features"
-
- def setUp(self):
- self.samplerate, self.channels, self.blocksize = 44100, 1, 1024
- import tempfile
- self.tmpfile = tempfile.NamedTemporaryFile(delete=True)
- self.sink = self.tmpfile.name
-
- def testWav(self):
- "Test wav encoding"
- from timeside.encoder.wav import WavEncoder
- self.assertRaises(IOError,WavEncoder,self.sink)
-
- def testVorbis(self):
- "Test vorbis encoding"
- from timeside.encoder.ogg import VorbisEncoder
- self.assertRaises(IOError,VorbisEncoder,self.sink)
-
- def testMp3(self):
- "Test mp3 encoding"
- from timeside.encoder.mp3 import Mp3Encoder
- self.assertRaises(IOError,Mp3Encoder,self.sink)
-
- # def testAac(self):
- # "Test aac encoding"
- # from timeside.encoder.m4a import AacEncoder
- # self.assertRaises(IOError,AacEncoder,self.sink)
-
- def testFlac(self):
- "Test flac encoding"
- from timeside.encoder.flac import FlacEncoder
- self.assertRaises(IOError,FlacEncoder,self.sink)
-
- def testWebm(self):
- "Test webm encoding"
- from timeside.encoder.webm import WebMEncoder
- self.assertRaises(IOError,WebMEncoder,self.sink)
-
-class TestEncodingOverwriteForced(TestCase):
- "Test encoding features"
-
- def setUp(self):
- self.samplerate, self.channels, self.blocksize = 44100, 1, 1024
- import tempfile
- self.tmpfile = tempfile.NamedTemporaryFile(delete=True)
- self.sink = self.tmpfile.name
-
- def testWav(self):
- "Test wav encoding"
- from timeside.encoder.wav import WavEncoder
- self.encoder = WavEncoder(self.sink, overwrite = True)
-
- def testVorbis(self):
- "Test vorbis encoding"
- from timeside.encoder.ogg import VorbisEncoder
- self.encoder = VorbisEncoder(self.sink, overwrite = True)
-
- def testMp3(self):
- "Test mp3 encoding"
- from timeside.encoder.mp3 import Mp3Encoder
- self.encoder = Mp3Encoder(self.sink, overwrite = True)
-
- # def testAac(self):
- # "Test aac encoding"
- # from timeside.encoder.m4a import AacEncoder
- # self.encoder = AacEncoder(self.sink, overwrite = True)
-
- def testFlac(self):
- "Test flac encoding"
- from timeside.encoder.flac import FlacEncoder
- self.encoder = FlacEncoder(self.sink, overwrite = True)
-
- # def testWebm(self):
- # "Test webm encoding"
- # from timeside.encoder.webm import WebMEncoder
- # self.encoder = WebMEncoder(self.sink, overwrite = True)
-
- def tearDown(self):
- super(TestEncodingOverwriteForced, self).tearDown()
- self.tmpfile.close()
-
-if __name__ == '__main__':
- unittest.main(testRunner=TestRunner())
+++ /dev/null
-from timeside.decoder.core import FileDecoder
-from unit_timeside import *
-
-import os.path
-
-__all__ = ['TestGraphing']
-
-class TestGraphing(TestCase):
- "Test all graphers with various input media formats"
-
- def setUp(self):
- pass
-
- # WAVEFORMS
- def testWav2Waveform(self):
- "Test WAV to Waveform"
- from timeside.grapher.waveform import Waveform
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
- self.image = "/tmp/test_waveform_sweep_wav.png"
- self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- def testFlac2Waveform(self):
- "Test FLAC to Waveform"
- from timeside.grapher.waveform import Waveform
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac")
- self.image = "/tmp/test_waveform_sweep_flac.png"
- self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- def testMp32Waveform(self):
- "Test MP3 to Waveform"
- from timeside.grapher.waveform import Waveform
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3")
- self.image = "/tmp/test_waveform_sweep_mp3.png"
- self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- def testOgg2Waveform(self):
- "Test OGG to Waveform"
- from timeside.grapher.waveform import Waveform
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg")
- self.image = "/tmp/test_waveform_sweep_ogg.png"
- self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- # WAVEFORM SIMPLE
- def testWav2WaveformSimple(self):
- "Test WAV to WaveformSimple"
- from timeside.grapher.waveform_simple import WaveformSimple
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
- self.image = "/tmp/test_waveform_simple_sweep_wav.png"
- self.grapher = WaveformSimple(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- # WAVEFORMS CONTOUR BLACK
- def testWav2WaveformContourBlack(self):
- "Test WAV to WaveformContourBlack"
- from timeside.grapher.waveform_contour_bk import WaveformContourBlack
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
- self.image = "/tmp/test_waveform_contour_bk_sweep_wav.png"
- self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- def testFlac2WaveformContourBlack(self):
- "Test FLAC to WaveformContourBlack"
- from timeside.grapher.waveform_contour_bk import WaveformContourBlack
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac")
- self.image = "/tmp/test_waveform_contour_bk_sweep_flac.png"
- self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- def testMp32WaveformContourBlack(self):
- "Test MP3 to WaveformContourBlack"
- from timeside.grapher.waveform_contour_bk import WaveformContourBlack
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3")
- self.image = "/tmp/test_waveform_contour_bk_sweep_mp3.png"
- self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- def testOgg2WaveformContourBlack(self):
- "Test OGG to WaveformContourBlack"
- from timeside.grapher.waveform_contour_bk import WaveformContourBlack
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg")
- self.image = "/tmp/test_waveform_contour_bk_sweep_ogg.png"
- self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- # WAVEFORMS CONTOUR WHITE
- def testWav2WaveformContourWhite(self):
- "Test WAV to WaveformContourWhite"
- from timeside.grapher.waveform_contour_wh import WaveformContourWhite
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
- self.image = "/tmp/test_waveform_contour_wh_sweep_wav.png"
- self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- def testFlac2WaveformContourWhite(self):
- "Test FLAC to WaveformContourWhite"
- from timeside.grapher.waveform_contour_wh import WaveformContourWhite
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac")
- self.image = "/tmp/test_waveform_contour_wh_sweep_flac.png"
- self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- def testMp32WaveformContourWhite(self):
- "Test MP3 to WaveformContourWhite"
- from timeside.grapher.waveform_contour_wh import WaveformContourWhite
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3")
- self.image = "/tmp/test_waveform_contour_wh_sweep_mp3.png"
- self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- def testOggWaveformContourWhite(self):
- "Test OGG to WaveformContourWhite"
- from timeside.grapher.waveform_contour_wh import WaveformContourWhite
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg")
- self.image = "/tmp/test_waveform_contour_wh_sweep_ogg.png"
- self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
-
- # SPECTROGRAMS
- def testWav2Spectrogram(self):
- "Test WAV to Spectrogram"
- from timeside.grapher.spectrogram import Spectrogram
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
- self.image = "/tmp/test_spectrogram_sweep_wav.png"
- self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- def testMp32Spectrogram(self):
- "Test MP3 to Spectrogram"
- from timeside.grapher.spectrogram import Spectrogram
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3")
- self.image = "/tmp/test_spectrogram_sweep_mp3.png"
- self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- def testFlac2Spectrogram(self):
- "Test FLAC to Spectrogram"
- from timeside.grapher.spectrogram import Spectrogram
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac")
- self.image = "/tmp/test_spectrogram_sweep_flac.png"
- self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- def testOgg2Spectrogram(self):
- "Test OGG to Spectrogram"
- from timeside.grapher.spectrogram import Spectrogram
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg")
- self.image = "/tmp/test_spectrogram_sweep_ogg.png"
- self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default')
-
- def tearDown(self):
- decoder = FileDecoder(self.source)
- (decoder | self.grapher).run()
- self.grapher.render(self.image)
-
-if __name__ == '__main__':
- unittest.main(testRunner=TestRunner())
-
+++ /dev/null
-from timeside.core import FixedSizeInputAdapter
-from unit_timeside import *
-import numpy
-
-class TestFixedSizeInputAdapter(TestCase):
- "Test the fixed-sized input adapter"
-
- def assertIOEquals(self, adapter, input, input_eod, output, output_eod=None):
- output = output[:]
- output.reverse()
- _eod = None
- for buffer, _eod in adapter.process(input, input_eod):
- a = output.pop()
- if not numpy.array_equiv(buffer, a):
- self.fail("\n-- Actual --\n%s\n -- Expected -- \n%s\n" % (str(buffer), str(a)))
-
- if _eod != output_eod:
- self.fail("eod do not match: %s != %s", (str(_eod), str(output_eod)))
-
- if output:
- self.fail("trailing expected data: %s" % output)
-
- def setUp(self):
- self.data = numpy.arange(44).reshape(2,22).transpose()
-
- def testTwoChannels(self):
- "Test simple stream with two channels"
- adapter = FixedSizeInputAdapter(4, 2)
-
- self.assertEquals(len(self.data), adapter.blocksize(len(self.data)))
-
- self.assertIOEquals(adapter, self.data[0:1], False, [])
- self.assertIOEquals(adapter, self.data[1:5], False, [self.data[0:4]], False)
- self.assertIOEquals(adapter, self.data[5:12], False, [self.data[4:8], self.data[8:12]], False)
- self.assertIOEquals(adapter, self.data[12:13], False, [])
- self.assertIOEquals(adapter, self.data[13:14], False, [])
- self.assertIOEquals(adapter, self.data[14:18], False, [self.data[12:16]], False)
- self.assertIOEquals(adapter, self.data[18:20], False, [self.data[16:20]], False)
- self.assertIOEquals(adapter, self.data[20:21], False, [])
- self.assertIOEquals(adapter, self.data[21:22], True, [self.data[20:22]], True)
-
- def testPadding(self):
- "Test automatic padding support"
- adapter = FixedSizeInputAdapter(4, 2, pad=True)
-
- self.assertEquals(len(self.data) + 2, adapter.blocksize(len(self.data)))
-
- self.assertIOEquals(adapter, self.data[0:21], False,
- [self.data[0:4], self.data[4:8], self.data[8:12], self.data[12:16], self.data[16:20]],
- False)
-
- self.assertIOEquals(adapter, self.data[21:22], True, [[
- [20, 42],
- [21, 43],
- [0, 0],
- [0, 0]
- ]], True)
-
- def testSizeMultiple(self):
- "Test a stream which contain a multiple number of buffers"
- adapter = FixedSizeInputAdapter(4, 2)
-
- self.assertIOEquals(adapter, self.data[0:20], True,
- [self.data[0:4], self.data[4:8], self.data[8:12], self.data[12:16], self.data[16:20]],
- True)
-
-
-if __name__ == '__main__':
- unittest.main(testRunner=TestRunner())
-
+++ /dev/null
-from timeside.core import *
-from timeside.decoder import *
-from timeside.analyzer import *
-from timeside.encoder import *
-from timeside.api import *
-from timeside.component import *
-
-from unit_timeside import *
-
-import os.path
-
-class TestTranscodingFromWav(TestCase):
- "Test transcoding from wav"
-
- def tmpTarget(self):
- import tempfile
- self.tmpfile = tempfile.NamedTemporaryFile(delete=True)
- self.target = self.tmpfile.name
- self.tmpfile.close()
-
- def setUp(self):
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav")
-
- def testToWav(self):
- "Test conversion to wav"
- self.tmpTarget()
- self.encoder = WavEncoder(self.target)
-
- def testToMp3(self):
- "Test conversion to mp3"
- self.tmpTarget()
- self.encoder = Mp3Encoder(self.target)
-
- def testToOgg(self):
- "Test conversion to ogg"
- self.tmpTarget()
- self.encoder = VorbisEncoder(self.target)
-
- # def testToWebM(self):
- # "Test conversion to webm"
- # self.tmpTarget()
- # self.encoder = WebMEncoder(self.target)
-
- # def testToM4a(self):
- # "Test conversion to m4a"
- # self.tmpTarget()
- # self.encoder = AacEncoder(self.target)
-
- def setUpDecoder(self):
- self.decoder = FileDecoder(self.source)
- self.decoder.setup()
- self.channels = self.decoder.channels()
- self.samplerate = self.decoder.samplerate()
-
- def setUpEncoder(self):
- self.encoder.setup(channels = self.channels, samplerate = self.samplerate)
-
- def tearDown(self):
- self.setUpDecoder()
- self.setUpEncoder()
-
- totalframes = 0
- while True:
- frames, eod = self.decoder.process()
- self.encoder.process(frames, eod)
- totalframes += frames.shape[0]
- if eod or self.encoder.eod: break
-
-
- #print self.channels, self.samplerate, totalframes
-
- self.encoder.release()
-
- decoder = FileDecoder(self.target)
- decoder.setup()
- written_frames = 0
- while True:
- frames, eod = decoder.process()
- written_frames += frames.shape[0]
- if eod: break
-
- #print decoder.channels(), decoder.samplerate(), written_frames
-
- self.assertEquals(self.channels, decoder.channels())
- self.assertEquals(self.samplerate, decoder.samplerate())
- self.assertTrue(written_frames - totalframes >= 0)
-
- import os
- os.unlink(self.target)
-
-class TestTranscodingFromAnotherWav(TestTranscodingFromWav):
- "Test transcoding from another wav"
-
- def setUp(self):
- self.source = os.path.join (os.path.dirname(__file__), "samples/guitar.wav")
-
-class TestTranscodingFromMp3(TestTranscodingFromWav):
- "Test transcoding from mp3"
-
- def setUp(self):
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3")
-
-class TestTranscodingFromFlac(TestTranscodingFromWav):
- "Test transcoding from flac"
-
- def setUp(self):
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac")
-
-class TestTranscodingFromOgg(TestTranscodingFromWav):
- "Test transcoding from ogg"
-
- def setUp(self):
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg")
-
-class TestTranscodingFromMonoWav(TestTranscodingFromWav):
- "Test transcoding from a mono wav"
-
- def setUp(self):
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_mono.wav")
-
-class TestTranscodingFrom32kHzWav(TestTranscodingFromWav):
- "Test transcoding from a 32kHz wav"
-
- def setUp(self):
- self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_32000.wav")
-
-class TestTranscodingFromMissingFile(TestTranscodingFromWav):
- "Test transcoding from a missing file"
-
- def setUp(self):
- self.source = os.path.join (os.path.dirname(__file__), "samples/unexisting.wav")
-
- def tearDown(self):
- self.assertRaises(IOError, self.setUpDecoder)
-
-if __name__ == '__main__':
- unittest.main(testRunner=TestRunner())
projects / timeside.git / commitdiff