93 lines
3.8 KiB
Python
93 lines
3.8 KiB
Python
"""Run with the pinned driver venv: python check_driver_audio.py PRIVATE_DRIVER."""
|
|
|
|
import hashlib
|
|
import importlib.util
|
|
import pathlib
|
|
import sys
|
|
import time
|
|
import unittest
|
|
from types import SimpleNamespace
|
|
|
|
import numpy as np
|
|
|
|
ROOT = pathlib.Path(sys.argv.pop(1)).resolve()
|
|
sys.path.insert(0, str(ROOT))
|
|
spec = importlib.util.spec_from_file_location('driver_webrtc', ROOT / 'server/webrtc.py')
|
|
driver = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(driver)
|
|
PendingAudio = driver.PendingAudio
|
|
|
|
|
|
class QueueChecks(unittest.TestCase):
|
|
def test_idle_is_bounded_speech_and_events_are_lossless(self):
|
|
pending = PendingAudio()
|
|
expected = []
|
|
for i in range(2000):
|
|
if i % 100 == 0:
|
|
# Real zero PCM and custom audio are not synthetic silence.
|
|
item = (i, {'event': i} if i % 200 else {}, 0 if i % 200 else 2)
|
|
expected.append(item)
|
|
else:
|
|
item = (i, None, 1)
|
|
pending.put(item)
|
|
actual = list(pending.queue)
|
|
self.assertEqual([x for x in actual if x[2] != 1], expected)
|
|
self.assertEqual(sum(x[2] == 1 for x in actual), 3)
|
|
self.assertLessEqual(pending.high_water, len(expected) + 3)
|
|
self.assertGreater(pending.dropped_silence, 1900)
|
|
marker = ('event', {'end': True}, 1)
|
|
pending.put(marker)
|
|
for i in range(50):
|
|
pending.put((i, None, 1))
|
|
self.assertIn(marker, list(pending.queue))
|
|
|
|
def test_real_audio_has_bounded_backpressure(self):
|
|
pending = PendingAudio()
|
|
for i in range(100):
|
|
pending.put((i, None, 0))
|
|
import queue
|
|
with self.assertRaises(queue.Full):
|
|
pending.put((101, None, 0), block=False)
|
|
self.assertEqual([x[0] for x in pending.queue], list(range(100)))
|
|
|
|
def test_warmup_drains_all_context(self):
|
|
from avatars.audio_features.base_asr import BaseASR
|
|
asr = BaseASR(SimpleNamespace(fps=25, batch_size=8, l=10, r=10))
|
|
asr.warm_up()
|
|
self.assertEqual(len(asr.frames), 20)
|
|
self.assertTrue(asr.output_queue.empty())
|
|
first = np.arange(320, dtype=np.float32)
|
|
asr.put_audio_frame(first, {'first': True})
|
|
frame = asr.get_audio_frame()
|
|
np.testing.assert_array_equal(frame.data, first)
|
|
self.assertEqual(frame.type, 0)
|
|
self.assertEqual(frame.userdata, {'first': True})
|
|
|
|
|
|
class ClockChecks(unittest.IsolatedAsyncioTestCase):
|
|
async def test_starvation_preserves_cadence_and_first_pcm(self):
|
|
player = SimpleNamespace(_start=lambda _: None, _stop=lambda _: None, notify=lambda _: None)
|
|
track = driver.PlayerStreamTrack(player, 'audio')
|
|
frame = driver.AudioFrame.from_ndarray(np.ones((1, 320), np.int16), format='s16', layout='mono')
|
|
frame.sample_rate = 16000
|
|
track._queue.put((frame, None, 0))
|
|
start = time.monotonic()
|
|
frames = [await track.recv() for _ in range(15)]
|
|
self.assertEqual([f.pts for f in frames], list(range(0, 15 * 320, 320)))
|
|
self.assertGreater(time.monotonic() - start, 0.25)
|
|
self.assertLess(time.monotonic() - start, 0.5)
|
|
self.assertTrue(all(not f.to_ndarray().any() for f in frames[1:]))
|
|
# Resume with exact first speech PCM, without trimming any syllable.
|
|
pcm = np.arange(320, dtype=np.int16).reshape(1, -1)
|
|
voice = driver.AudioFrame.from_ndarray(pcm, format='s16', layout='mono')
|
|
voice.sample_rate = 16000
|
|
track._queue.put((voice, {'start': True}, 0))
|
|
out = await track.recv()
|
|
self.assertEqual(out.pts, 15 * 320)
|
|
self.assertEqual(hashlib.sha256(out.to_ndarray().tobytes()).digest(), hashlib.sha256(pcm.tobytes()).digest())
|
|
track.stop()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main(verbosity=2)
|