| import unittest |
| import wave |
| import os |
| from memory_profiler import memory_usage |
|
|
| from pocketsphinx import Vad |
|
|
| DATADIR = os.path.join(os.path.dirname(__file__), "../../test/data/vad") |
|
|
|
|
| class VadTests(unittest.TestCase): |
| @staticmethod |
| def _load_wave(file_name): |
| fp = wave.open(file_name, 'rb') |
| try: |
| assert fp.getnchannels() == 1, ( |
| '{0}: sound format is incorrect! Sound must be mono.'.format( |
| file_name)) |
| assert fp.getsampwidth() == 2, ( |
| '{0}: sound format is incorrect! ' |
| 'Sample width of sound must be 2 bytes.').format(file_name) |
| assert fp.getframerate() in (8000, 16000, 32000), ( |
| '{0}: sound format is incorrect! ' |
| 'Sampling frequency must be 8000 Hz, 16000 Hz or 32000 Hz.') |
| sampling_frequency = fp.getframerate() |
| sound_data = fp.readframes(fp.getnframes()) |
| finally: |
| fp.close() |
| del fp |
| return sound_data, sampling_frequency |
|
|
| def test_constructor(self): |
| _ = Vad() |
|
|
| def test_set_mode(self): |
| _ = Vad(0) |
| _ = Vad(1) |
| _ = Vad(2) |
| _ = Vad(3) |
| with self.assertRaises(ValueError): |
| _ = Vad(4) |
|
|
| def test_valid_rate_and_frame_length(self): |
| _ = Vad(sample_rate=8000, frame_length=0.01) |
| _ = Vad(sample_rate=16000, frame_length=0.02) |
| _ = Vad(sample_rate=32000, frame_length=0.01) |
| _ = Vad(sample_rate=48000, frame_length=0.03) |
| with self.assertRaises(ValueError): |
| _ = Vad(sample_rate=283423, frame_length=1e-5) |
|
|
| def test_process_zeroes(self): |
| frame_len = 160 |
| sample = b'\x00' * frame_len * 2 |
| vad = Vad(sample_rate=16000, frame_length=0.01) |
| self.assertFalse(vad.is_speech(sample)) |
|
|
| def test_process_file(self): |
| with open(os.path.join(DATADIR, 'test-audio.raw'), 'rb') as f: |
| data = f.read() |
| |
| n = int(8000 * 2 * 30 / 1000.0) |
| chunks = list(data[pos:pos + n] for pos in range(0, len(data), n)) |
| if len(chunks[-1]) != n: |
| chunks = chunks[:-1] |
| expecteds = [ |
| '011110111111111111111111111100', |
| '011110111111111111111111111100', |
| '000000111111111111111111110000', |
| '000000111111111111111100000000' |
| ] |
| for mode in (0, 1, 2, 3): |
| vad = Vad(mode=mode, sample_rate=8000, frame_length=0.03) |
| result = '' |
| for chunk in chunks: |
| voiced = vad.is_speech(chunk) |
| result += '1' if voiced else '0' |
| self.assertEqual(expecteds[mode], result) |
|
|
| def test_leak(self): |
| sound, fs = self._load_wave(os.path.join(DATADIR, 'leak-test.wav')) |
| frame_ms = 0.010 |
| frame_len = int(round(fs * frame_ms)) |
| n = int(len(sound) / (2 * frame_len)) |
| nrepeats = 1000 |
| vad = Vad(mode=3, sample_rate=fs, frame_length=frame_ms) |
| used_memory_before = memory_usage(-1)[0] |
| for counter in range(nrepeats): |
| find_voice = False |
| for frame_ind in range(n): |
| slice_start = (frame_ind * 2 * frame_len) |
| slice_end = ((frame_ind + 1) * 2 * frame_len) |
| if vad.is_speech(sound[slice_start:slice_end], fs): |
| find_voice = True |
| self.assertTrue(find_voice) |
| used_memory_after = memory_usage(-1)[0] |
| self.assertGreaterEqual( |
| used_memory_before / 5.0, |
| used_memory_after - used_memory_before) |
|
|
|
|
| if __name__ == '__main__': |
| unittest.main(verbosity=2) |
|
|
