Share lossless voice prefixes across companion announcements
This commit is contained in:
1 parent
91a9190a71
commit
22360f4392
18 files changed
+2284
-2018
No files matched your search
+66
@@ -0,0 +1,66 @@
|
||||
#include <cassert>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <initializer_list>
|
||||
#define PIN_BUZZER 25
|
||||
#define MESH_BUTTON_AUDIO_HIL 1
|
||||
#if defined(MESH_GPS_VOICE_G726_BITRATE)
|
||||
#include <helpers/ui/G726VoiceData.h>
|
||||
#else
|
||||
#include <helpers/ui/ButtonVoiceData.h>
|
||||
#include <helpers/ui/GpsVoiceData.h>
|
||||
#endif
|
||||
#include <helpers/ui/nrf52/GpsVoicePlayer.h>
|
||||
uint32_t now_ms=0;
|
||||
int main() {
|
||||
using namespace mesh::audio;
|
||||
const VoiceClip clips[]={readyClip,notificationClearedClip,advertQueuedClip,
|
||||
advertFailedClip,soundOnClip,soundOffClip,actionFailedClip,usbSetupClip,
|
||||
shuttingDownClip,restartingClip,gpsOnClip,gpsOffClip,
|
||||
#ifdef HAS_DRV2605
|
||||
alertsSoundVibrationClip,alertsSoundOnlyClip,alertsVibrationOnlyClip,alertsSilentClip,
|
||||
#endif
|
||||
};
|
||||
for (auto clip:clips) {
|
||||
#ifdef PWM_OUTPUT
|
||||
GpsVoicePlayer player;
|
||||
assert(player.setGain(2));
|
||||
assert(player.start(clip));
|
||||
uint16_t first[2][128];
|
||||
for(unsigned i=0;i<2;++i)
|
||||
std::memcpy(first[i],reinterpret_cast<const void*>(registers.SEQ[i].PTR),sizeof(first[i]));
|
||||
unsigned sequence=0,events=0;
|
||||
while (player.playing()) {
|
||||
assert(++events<1000);
|
||||
const auto data=reinterpret_cast<const uint16_t*>(registers.SEQ[sequence].PTR);
|
||||
assert(std::fwrite(data,sizeof(*data),registers.SEQ[sequence].CNT,stdout)==registers.SEQ[sequence].CNT);
|
||||
registers.EVENTS_SEQEND[sequence]=1;player.interrupt();sequence^=1;
|
||||
}
|
||||
assert(player.played()==clip.samples);
|
||||
assert(player.completed()==1&&player.cancelled()==0);
|
||||
player.service();assert(!player.active()&&!HwPWM3.owned&&!irq_enabled);
|
||||
// Cancel before and after the GPS prefix seam, then restart. A tail must
|
||||
// never inherit another announcement's adaptive/interpolation state.
|
||||
for(unsigned fraction:{1u,3u}) {
|
||||
assert(player.start(clip));unsigned seq=0;
|
||||
while(player.playing()&&player.played()<clip.samples*fraction/4) {
|
||||
registers.EVENTS_SEQEND[seq]=1;player.interrupt();seq^=1;
|
||||
}
|
||||
assert(player.playing());player.stop();
|
||||
assert(!player.active()&&!HwPWM3.owned&&!irq_enabled);
|
||||
assert(player.start(clip));
|
||||
for(unsigned i=0;i<2;++i)
|
||||
assert(std::memcmp(first[i],reinterpret_cast<const void*>(registers.SEQ[i].PTR),sizeof(first[i]))==0);
|
||||
player.stop();
|
||||
}
|
||||
assert(player.started()==5&&player.completed()==1&&player.cancelled()==4);
|
||||
#else
|
||||
VoiceDecoder decoder;decoder.begin(clip);
|
||||
for(uint32_t sample=0;sample<clip.samples;++sample) {
|
||||
assert(!decoder.done());const int16_t value=decoder.next();
|
||||
assert(std::fwrite(&value,sizeof(value),1,stdout)==1);
|
||||
}
|
||||
assert(decoder.done()&&decoder.position()==clip.samples&&decoder.next()==0);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
@@ -59,8 +59,9 @@ int main(){
|
||||
for(const auto& entry:mappings){
|
||||
auto actual=buttonVoiceClip(entry.prompt);
|
||||
assert(actual.data==entry.clip.data&&actual.bytes==entry.clip.bytes);
|
||||
assert(actual.prefix==entry.clip.prefix&&actual.prefix_bytes==entry.clip.prefix_bytes);
|
||||
assert(actual.samples==entry.clip.samples&&actual.sample_rate==entry.clip.sample_rate);
|
||||
assert(actual.data&&actual.bytes==(actual.samples+1)/2);
|
||||
assert(actual.valid()&&actual.bytes+actual.prefix_bytes==(actual.samples+1)/2);
|
||||
assert(actual.sample_rate==8000||actual.sample_rate==16000);
|
||||
VoiceDecoder decoder;decoder.begin(actual);
|
||||
unsigned count=0,nonzero=0;
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
"""Validate the fixed prerecorded catalog without speech synthesis or hardware."""
|
||||
from pathlib import Path
|
||||
import hashlib
|
||||
import importlib.util
|
||||
import re
|
||||
import shutil
|
||||
import struct
|
||||
@@ -64,22 +65,69 @@ def write_wav(path, samples, *, rate=8000, channels=1, width=2):
|
||||
wav.writeframes(payload)
|
||||
|
||||
|
||||
def parse_header(source):
|
||||
arrays = {
|
||||
def select_vibration(source, enabled=True):
|
||||
"""Select the generated catalog's HAS_DRV2605 branches for asset tests."""
|
||||
lines = []
|
||||
stack = [True]
|
||||
for line in source.splitlines():
|
||||
if line == '#ifdef HAS_DRV2605':
|
||||
stack.append(stack[-1] and enabled)
|
||||
elif line == '#else' and len(stack) > 1:
|
||||
stack[-1] = stack[-2] and not stack[-1]
|
||||
elif line == '#endif // HAS_DRV2605':
|
||||
stack.pop()
|
||||
elif stack[-1]:
|
||||
lines.append(line)
|
||||
assert len(stack) == 1
|
||||
return '\n'.join(lines)
|
||||
|
||||
|
||||
def parse_header(source, has_drv2605=True):
|
||||
source = select_vibration(source, has_drv2605)
|
||||
spans = {
|
||||
name: bytes(int(value, 16) for value in re.findall(r"0x([0-9a-fA-F]{2})", body))
|
||||
for name, body in re.findall(
|
||||
r"static const uint8_t (\w+)Data\[\] = \{(.*?)\};", source, re.S)
|
||||
}
|
||||
clips = {
|
||||
name: (data, size, int(samples), int(rate))
|
||||
for name, data, size, samples, rate in re.findall(
|
||||
arrays, clips = {}, {}
|
||||
for name, data, size, samples, rate, prefix, prefix_size in re.findall(
|
||||
r"static constexpr VoiceClip (\w+)Clip = \{\s*"
|
||||
r"(\w+)Data, sizeof\((\w+)Data\), (\d+), (\d+)\s*\};", source)
|
||||
}
|
||||
r"(\w+)Data, sizeof\((\w+)Data\), (\d+), (\d+)"
|
||||
r"(?:, (\w+)Data, sizeof\((\w+)Data\))?\s*\};", source):
|
||||
assert data == size and prefix == prefix_size
|
||||
clips[name] = (data, size, int(samples), int(rate))
|
||||
arrays[name] = (spans[prefix] if prefix else b'') + spans[data]
|
||||
return arrays, clips
|
||||
|
||||
|
||||
class EncoderTests(unittest.TestCase):
|
||||
def test_profitable_prefix_groups_regenerate_exact_phrases_for_both_board_policies(self):
|
||||
with tempfile.TemporaryDirectory() as temporary:
|
||||
directory = Path(temporary)
|
||||
samples = self.fixtures(directory)
|
||||
common = [((i*997)%18001)-9000 for i in range(257)]
|
||||
for name, tail in (('advertQueued',[1000,-1000]), ('advertFailed',[-3000,3000]),
|
||||
('soundOff',[2000,-2000]), ('alertsSoundOnly',[-4000,4000])):
|
||||
samples[name] = common+tail*80
|
||||
write_wav(directory/(name+'.wav'), samples[name])
|
||||
source = directory/'shared.h'
|
||||
self.assertEqual(self.generate(directory,source).returncode,0)
|
||||
header = source.read_text()
|
||||
self.assertIn('advertPrefixData',header)
|
||||
self.assertIn('soundPrefixData',header)
|
||||
# Compare to the original independently encoded fixture bytes.
|
||||
spec = importlib.util.spec_from_file_location(
|
||||
'fixture_gps_encoder',ROOT/'scripts/generate_gps_voice.py')
|
||||
encoder = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(encoder)
|
||||
for vibration in (False,True):
|
||||
arrays, clips = parse_header(header,vibration)
|
||||
names = CATALOG if vibration else CATALOG[:10]
|
||||
for name,_ in names:
|
||||
self.assertEqual(arrays[name],encoder.encode(samples[name]))
|
||||
self.assertEqual(clips[name],(name,name,len(samples[name]),8000))
|
||||
self.assertEqual('soundPrefixData' in select_vibration(header,vibration),vibration)
|
||||
|
||||
def fixtures(self, directory):
|
||||
samples = {}
|
||||
for index, (name, _) in enumerate(CATALOG):
|
||||
@@ -175,12 +223,12 @@ class EncoderTests(unittest.TestCase):
|
||||
self.assertEqual(clips[name], (name, name, samples, 8000))
|
||||
|
||||
def assert_x1_only_recordings_are_guarded(self, source):
|
||||
start = source.index('#ifdef HAS_DRV2605')
|
||||
end = source.index('#endif', start)
|
||||
self.assertLess(source.index('restartingClip'), start)
|
||||
for name, _ in CATALOG[10:]:
|
||||
self.assertLess(start, source.index(name+'Data'))
|
||||
self.assertLess(source.index(name+'Clip'), end)
|
||||
arrays, clips = parse_header(source, has_drv2605=False)
|
||||
self.assertEqual(tuple(arrays), tuple(name for name, _ in CATALOG[:10]))
|
||||
self.assertEqual(tuple(clips), tuple(arrays))
|
||||
# The optional shared Sound prefix must not add storage on boards
|
||||
# which have no sound-only alert-mode announcement.
|
||||
self.assertNotIn('soundPrefixData', select_vibration(source, False))
|
||||
|
||||
def test_changed_source_wav_replaces_only_its_matching_clip(self):
|
||||
with tempfile.TemporaryDirectory() as temporary:
|
||||
|
||||
+34
-1
@@ -17,7 +17,8 @@ ROOT = Path(__file__).resolve().parents[1]
|
||||
CC = shutil.which('gcc')
|
||||
CXX = shutil.which('g++')
|
||||
DECODER = ROOT / 'src/helpers/ui/g726/g726_decoder.c'
|
||||
SANITIZERS = (['-fsanitize=address,undefined', '-fno-omit-frame-pointer']
|
||||
SANITIZERS = (['-fsanitize=address,undefined', '-fno-sanitize-recover=all',
|
||||
'-fno-omit-frame-pointer', '-fno-pie', '-no-pie']
|
||||
if os.environ.get('MESH_G726_TEST_SANITIZERS') == '1' else [])
|
||||
|
||||
# FFmpeg 7.1 g726 encoder/decoder, 8 kHz mono, continuous MSB-first packing.
|
||||
@@ -230,6 +231,38 @@ class Tests(unittest.TestCase):
|
||||
for bitrate in VECTORS:
|
||||
with self.subTest(bitrate=bitrate):self.build(self.fixture(PLAYER_MAIN,bitrate),bitrate)
|
||||
|
||||
def test_segmented_stream_preserves_cross_byte_codes_adaptive_state_and_bounds(self):
|
||||
source = DECODE_MAIN.split('int main(){', 1)[1].split(' assert(full.valid()', 1)[0]
|
||||
source = 'int main(){' + source + r'''
|
||||
for(size_t split=0;split<sizeof(data);++split){
|
||||
VoiceClip clip{data+split,sizeof(data)-split,count,8000,codec,data,split};
|
||||
assert(clip.valid());VoiceDecoder decoder;decoder.begin(clip);
|
||||
for(unsigned i=0;i<count;++i){assert(!decoder.done());assert(decoder.next()==expected[i]);}
|
||||
assert(decoder.done()&&decoder.position()==count);
|
||||
for(size_t tail=0;tail<sizeof(data)-split;++tail){
|
||||
std::vector<uint8_t> prefix(data,data+split),suffix(data+split,data+split+tail);
|
||||
// A non-null placeholder is legal when the suffix's declared length is
|
||||
// zero. ASan bounds the actual prefix/tail allocation independently.
|
||||
VoiceClip short_clip{tail?suffix.data():data,tail,count,8000,codec,
|
||||
split?prefix.data():nullptr,split};
|
||||
assert(!short_clip.valid());decoder.begin(short_clip);
|
||||
const unsigned available=static_cast<unsigned>((split+tail)*8/bits);
|
||||
for(unsigned i=0;i<available;++i){assert(!decoder.done());assert(decoder.next()==expected[i]);}
|
||||
assert(decoder.done()&&decoder.position()==available&&decoder.next()==0);
|
||||
}
|
||||
}
|
||||
VoiceClip missing_prefix{data,sizeof(data),count,8000,codec,nullptr,1};
|
||||
assert(!missing_prefix.valid());VoiceDecoder decoder;decoder.begin(missing_prefix);
|
||||
assert(decoder.done()&&decoder.next()==0);
|
||||
VoiceClip huge{data,std::numeric_limits<size_t>::max(),
|
||||
std::numeric_limits<uint32_t>::max(),8000,codec,data,1};
|
||||
assert(huge.valid()&&huge.hasBytes(std::numeric_limits<size_t>::max()));
|
||||
GpsVoicePlayer player;assert(!player.start(missing_prefix)&&!player.active());
|
||||
}
|
||||
'''
|
||||
for bitrate in VECTORS:
|
||||
with self.subTest(bitrate=bitrate):self.build(self.fixture(source,bitrate),bitrate)
|
||||
|
||||
def test_invalid_bitrates_or_missing_laboratory_gate_cannot_compile(self):
|
||||
for flags,error in (
|
||||
('#define MESH_GPS_VOICE_G726_BITRATE 16\n','opt-in MESH_BUTTON_AUDIO_HIL'),
|
||||
|
||||
@@ -12,7 +12,7 @@ from types import SimpleNamespace
|
||||
import unittest
|
||||
from unittest import mock
|
||||
|
||||
from test_button_voice_generator import CATALOG, ZIRA_RECORDINGS
|
||||
from test_button_voice_generator import CATALOG, ZIRA_RECORDINGS, select_vibration
|
||||
from test_gps_voice_generator import ZIRA_GPS_RECORDINGS
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
@@ -114,8 +114,9 @@ class CatalogTests(unittest.TestCase):
|
||||
for name in names:
|
||||
count=len(source_samples[name])
|
||||
self.assertIn(f'{name}Data, sizeof({name}Data), {count}, 8000, VoiceCodec::G726{bitrate}',body)
|
||||
self.assertEqual(body.count('#ifdef HAS_DRV2605'),4)
|
||||
self.assertEqual(body.count('#endif // HAS_DRV2605'),4)
|
||||
plain = select_vibration(body, False)
|
||||
for name in names:
|
||||
self.assertEqual(f'{name}Clip' in plain, not name.startswith('alerts'))
|
||||
|
||||
def test_invalid_source_lengths_preserve_existing_experimental_header(self):
|
||||
for count in (0,32001):
|
||||
@@ -143,30 +144,28 @@ class CatalogTests(unittest.TestCase):
|
||||
with self.subTest(bitrate=bitrate):
|
||||
body=source.split(f'#if MESH_GPS_VOICE_G726_BITRATE == {bitrate}\n',1)[1]
|
||||
body=body.split(f'#endif // {bitrate} kbps',1)[0]
|
||||
arrays={name:bytes(int(value,16) for value in re.findall(r'0x([0-9a-fA-F]{2})',data))
|
||||
for name,data in re.findall(r'static const uint8_t (\w+)Data\[\] = \{(.*?)\};',body,re.S)}
|
||||
clips={name:(data,size,int(count),int(rate),int(codec))
|
||||
for name,data,size,count,rate,codec in re.findall(
|
||||
selected = select_vibration(body)
|
||||
spans={name:bytes(int(value,16) for value in re.findall(r'0x([0-9a-fA-F]{2})',data))
|
||||
for name,data in re.findall(r'static const uint8_t (\w+)Data\[\] = \{(.*?)\};',selected,re.S)}
|
||||
arrays, clips = {}, {}
|
||||
for name,data,size,count,rate,codec,prefix,prefix_size in re.findall(
|
||||
r'static constexpr VoiceClip (\w+)Clip = \{\s*'
|
||||
r'(\w+)Data, sizeof\((\w+)Data\), (\d+), (\d+), VoiceCodec::G726(\d+)\s*\};',body)}
|
||||
r'(\w+)Data, sizeof\((\w+)Data\), (\d+), (\d+), VoiceCodec::G726(\d+)'
|
||||
r'(?:, (\w+)Data, sizeof\((\w+)Data\))?\s*\};',selected):
|
||||
self.assertEqual(data,size)
|
||||
self.assertEqual(prefix,prefix_size)
|
||||
arrays[name]=(spans[prefix] if prefix else b'')+spans[data]
|
||||
clips[name]=(data,size,int(count),int(rate),int(codec))
|
||||
self.assertEqual(tuple(arrays),names)
|
||||
self.assertEqual(tuple(clips),names)
|
||||
for name in names:
|
||||
self.assertEqual(clips[name],(name,name,samples[name],8000,bitrate))
|
||||
self.assertEqual(len(arrays[name]),(samples[name]*(bitrate//8)+7)//8)
|
||||
self.assertEqual(hashlib.sha256(arrays[name]).hexdigest(),GOLDENS[name][index],name)
|
||||
# Each optional mode must be inside a HAS_DRV2605 guard; the
|
||||
# common twelve clips must remain outside those guards.
|
||||
guarded=False
|
||||
for line in body.splitlines():
|
||||
if line=='#ifdef HAS_DRV2605':
|
||||
self.assertFalse(guarded);guarded=True
|
||||
elif line=='#endif // HAS_DRV2605':
|
||||
self.assertTrue(guarded);guarded=False
|
||||
else:
|
||||
match=re.match(r'static const uint8_t (\w+)Data',line)
|
||||
if match:self.assertEqual(guarded,match[1].startswith('alerts'),match[1])
|
||||
self.assertFalse(guarded)
|
||||
plain=select_vibration(body,False)
|
||||
self.assertNotIn('soundPrefixData',plain)
|
||||
for name in names:
|
||||
self.assertEqual(f'{name}Clip' in plain,not name.startswith('alerts'))
|
||||
|
||||
def test_cli_refuses_production_filenames_and_invalid_voice_without_touching_existing_files(self):
|
||||
with tempfile.TemporaryDirectory() as temporary:
|
||||
|
||||
@@ -451,7 +451,7 @@ class Tests(unittest.TestCase):
|
||||
self.build(PLAYER_PDM)
|
||||
source=PLAYER_PDM.replace('gpsOnClip', 'clip')
|
||||
source=source.replace('GpsVoicePlayer player;',
|
||||
'GpsVoicePlayer player; VoiceClip clip{gpsOnClip.data,gpsOnClip.bytes,gpsOnClip.samples,16000};')
|
||||
'GpsVoicePlayer player; auto clip=gpsOnClip; clip.sample_rate=16000;')
|
||||
source=source.replace('interpolator.begin();','interpolator.begin(clip.sample_rate);')
|
||||
source=source.replace('clip.samples*8','clip.samples*4')
|
||||
self.build(source)
|
||||
|
||||
@@ -7,6 +7,7 @@ import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
from test_button_voice_generator import parse_header, write_wav
|
||||
import importlib.util
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
POWERSHELL = shutil.which("pwsh") or shutil.which("powershell")
|
||||
@@ -33,6 +34,37 @@ ZIRA_GPS_RECORDINGS = {
|
||||
|
||||
|
||||
class AssetTests(unittest.TestCase):
|
||||
def test_generator_shares_only_profitable_exact_encoded_prefixes(self):
|
||||
spec = importlib.util.spec_from_file_location('gps_encoder', ROOT/'scripts/generate_gps_voice.py')
|
||||
encoder = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(encoder)
|
||||
for rate in (8000, 16000):
|
||||
with self.subTest(rate=rate), tempfile.TemporaryDirectory() as temporary:
|
||||
directory = Path(temporary)
|
||||
common = [((i*997)%18001)-9000 for i in range(257)]
|
||||
phrases = {'gpsOn': common+[1000,-1000]*80,
|
||||
'gpsOff': common+[-3000,3000]*77}
|
||||
for name, samples in phrases.items():
|
||||
write_wav(directory/(name+'.wav'), samples, rate=rate)
|
||||
output = directory/'shared.h'
|
||||
command = [sys.executable, str(ROOT/'scripts/generate_gps_voice.py'),
|
||||
'--on', str(directory/'gpsOn.wav'), '--off', str(directory/'gpsOff.wav'),
|
||||
'--rate', str(rate), '--output', str(output)]
|
||||
subprocess.run(command, check=True, capture_output=True, timeout=30)
|
||||
source = output.read_text()
|
||||
self.assertEqual(source.count('static const uint8_t '), 3)
|
||||
arrays, clips = parse_header(source)
|
||||
for name, samples in phrases.items():
|
||||
self.assertEqual(arrays[name], encoder.encode(samples))
|
||||
self.assertEqual(clips[name], (name,name,len(samples),rate))
|
||||
# A completely different second phrase must not add a useless
|
||||
# shared/empty blob merely to keep the nominal count at three.
|
||||
write_wav(directory/'gpsOff.wav', [3000,-3000]*80, rate=rate)
|
||||
subprocess.run(command, check=True, capture_output=True, timeout=30)
|
||||
source = output.read_text()
|
||||
self.assertEqual(source.count('static const uint8_t '), 2)
|
||||
self.assertNotIn('gpsData', source)
|
||||
|
||||
def test_production_gps_recordings_are_the_approved_zira_audio_and_metadata(self):
|
||||
source = (ROOT / 'src/helpers/ui/GpsVoiceData.h').read_text(encoding='utf-8')
|
||||
self.assertEqual([line for line in source.splitlines() if line.startswith('// Voice:')],
|
||||
|
||||
@@ -0,0 +1,145 @@
|
||||
"""Preserve original speech PCM/DMA output while sharing encoded flash spans."""
|
||||
from pathlib import Path
|
||||
import hashlib
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
import test_gps_voice_buttons as shared
|
||||
from test_button_voice_generator import select_vibration
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
CC, CXX = shutil.which('gcc'), shutil.which('g++')
|
||||
SANITIZERS = (['-fsanitize=address,undefined', '-fno-sanitize-recover=all',
|
||||
'-fno-omit-frame-pointer', '-fno-pie', '-no-pie']
|
||||
if os.environ.get('MESH_VOICE_TEST_SANITIZERS') == '1' else [])
|
||||
|
||||
# Pinned from the original contiguous approved catalogs and the original
|
||||
# decoder/player before any sharing changes. PCM is s16le; DMA words are u16le
|
||||
# at gain 2. These checks include every clip, final padding, IRQ refill and
|
||||
# interpolation tail, not hashes derived from the implementation under test.
|
||||
ORIGINAL_OUTPUT = {
|
||||
(0, False): ('481630ba68b1a29d5148fb1b552ca9bb78477ddc576bf9bad6d124d193dc994c',
|
||||
'7438e1cc35538956c8959adf9056aeffbd77c20e4fbd23b1204c3c17ab15a9c0'),
|
||||
(0, True): ('4e7ba541d3909bf8bbc4ae94c220f3a3d6a2304efaf53e3335a0844574475e87',
|
||||
'6b0419e83310946342b136661460eed5795fa92b23eb9da6f43056d840d0c025'),
|
||||
(16, False): ('f61a12157647ba21320ec65fb7a4bdcee260703ca593b57e5770af45076c7972',
|
||||
'f8bdd21166fe8606622abfb8cff27136612e65e61e9f18d02e95c41e62897196'),
|
||||
(16, True): ('86e13b896a20c5c77ca9dae9d71c52a1da78f7603a8c8e260a6c6c74d51567d6',
|
||||
'10fb34b5487048a738a75c2bd4388c4ff370cbaebb54ed3a52006738dd86f425'),
|
||||
(24, False): ('e37d6bbd0c7f9ddd0018c7f50d3929b1deef27b405a7432c492b2fb67c46e11b',
|
||||
'2a7815a6ea01302b0cfe2d2bb3d6a57adeeec155ba70ac8aa9e1e3965d8d54be'),
|
||||
(24, True): ('59167abf199c939cc62b3b03d9dbfcffd973c495104f89de29a6dd852100cdf2',
|
||||
'2915281db72ebe103e7599a797f0413eb7245346ba55879c4a0a9ca1f61be293'),
|
||||
}
|
||||
|
||||
|
||||
@unittest.skipUnless(CC and CXX, 'Native C/C++ compilers are required')
|
||||
class Tests(unittest.TestCase):
|
||||
def test_every_original_phrase_and_full_dma_stream_remains_bit_identical(self):
|
||||
with tempfile.TemporaryDirectory() as temporary:
|
||||
directory = Path(temporary)
|
||||
(directory/'Arduino.h').write_text(shared.ARDUINO)
|
||||
(directory/'HardwarePWM.h').write_text(shared.PWM)
|
||||
for (rate, vibration), fingerprints in ORIGINAL_OUTPUT.items():
|
||||
flags = ['-DMESH_BUTTON_AUDIO_HIL=1']
|
||||
if rate:
|
||||
flags.append(f'-DMESH_GPS_VOICE_G726_BITRATE={rate}')
|
||||
if vibration:
|
||||
flags.append('-DHAS_DRV2605=1')
|
||||
objects = []
|
||||
if rate:
|
||||
obj = directory/'g726.o'
|
||||
subprocess.run([CC, '-std=c99', '-Wall', '-Wextra', '-Werror',
|
||||
*SANITIZERS, *flags, '-I'+str(ROOT/'src'), '-c',
|
||||
str(ROOT/'src/helpers/ui/g726/g726_decoder.c'),
|
||||
'-o', str(obj)], check=True, timeout=30)
|
||||
objects.append(str(obj))
|
||||
for pwm, fingerprint in enumerate(fingerprints):
|
||||
with self.subTest(rate=rate, vibration=vibration, pwm=bool(pwm)):
|
||||
binary = directory/'catalog'
|
||||
subprocess.run([CXX, '-std=c++17', '-Wall', '-Wextra', '-Werror',
|
||||
*SANITIZERS, *flags,
|
||||
*(['-DPWM_OUTPUT=1'] if pwm else []),
|
||||
'-I'+str(directory), '-I'+str(ROOT/'src'),
|
||||
str(ROOT/'test/fixtures/voice_prefixes/catalog.cpp'),
|
||||
*objects, '-o', str(binary)], check=True, timeout=30)
|
||||
result = subprocess.run([str(binary)], check=True,
|
||||
capture_output=True, timeout=30)
|
||||
self.assertEqual(hashlib.sha256(result.stdout).hexdigest(), fingerprint)
|
||||
|
||||
def test_ima_seams_odd_lengths_truncation_and_invalid_metadata(self):
|
||||
source = r'''
|
||||
#include <cassert>
|
||||
#include <initializer_list>
|
||||
#include <limits>
|
||||
#include <vector>
|
||||
#include <helpers/ui/GpsVoice.h>
|
||||
int main(){
|
||||
using namespace mesh::audio;
|
||||
const uint8_t encoded[]={0x77,0x1f,0xca,0x26,0x84,0x92,0xbb};
|
||||
for(unsigned samples:{1u,2u,3u,7u,13u,14u}){
|
||||
VoiceDecoder original;original.begin({encoded,sizeof(encoded),samples});
|
||||
std::vector<int16_t> expected;
|
||||
while(!original.done())expected.push_back(original.next());
|
||||
for(size_t split=0;split<sizeof(encoded);++split){
|
||||
VoiceClip clip{encoded+split,sizeof(encoded)-split,samples,8000,encoded,split};
|
||||
assert(clip.valid());VoiceDecoder decoder;decoder.begin(clip);
|
||||
for(auto value:expected){assert(!decoder.done());assert(decoder.next()==value);}
|
||||
assert(decoder.done()&&decoder.position()==samples&&decoder.next()==0);
|
||||
for(size_t tail=0;tail<sizeof(encoded)-split;++tail){
|
||||
std::vector<uint8_t> prefix(encoded,encoded+split),suffix(encoded+split,encoded+split+tail);
|
||||
VoiceClip short_clip{tail?suffix.data():encoded,tail,samples,8000,
|
||||
split?prefix.data():nullptr,split};
|
||||
decoder.begin(short_clip);
|
||||
unsigned count=0;
|
||||
while(!decoder.done()){assert(decoder.next()==expected[count++]);}
|
||||
assert(count==((split+tail)*2<samples?(split+tail)*2:samples));
|
||||
assert(short_clip.valid()==(count==samples));
|
||||
}
|
||||
}
|
||||
}
|
||||
VoiceClip bad{encoded,sizeof(encoded),14,8000,nullptr,1};
|
||||
assert(!bad.valid());VoiceDecoder decoder;decoder.begin(bad);
|
||||
assert(decoder.done()&&decoder.next()==0);
|
||||
VoiceClip huge{encoded,std::numeric_limits<size_t>::max(),
|
||||
std::numeric_limits<uint32_t>::max(),8000,encoded,1};
|
||||
assert(huge.valid()&&huge.hasBytes(std::numeric_limits<size_t>::max()));
|
||||
}
|
||||
'''
|
||||
with tempfile.TemporaryDirectory() as temporary:
|
||||
directory = Path(temporary)
|
||||
path, binary = directory/'seams.cpp', directory/'seams'
|
||||
path.write_text(source)
|
||||
subprocess.run([CXX, '-std=c++17', '-Wall', '-Wextra', '-Werror',
|
||||
*SANITIZERS, '-I'+str(ROOT/'src'), str(path), '-o', str(binary)],
|
||||
check=True, timeout=30)
|
||||
subprocess.run([str(binary)], check=True, timeout=30)
|
||||
|
||||
def test_only_profitable_shared_spans_are_stored_and_optional_sound_is_gated(self):
|
||||
expected = {0: (3135, 746, 1090), 16: (1535, 268, 545), 24: (1967, 427, 817)}
|
||||
for rate, sizes in expected.items():
|
||||
if rate:
|
||||
source = (ROOT/'src/helpers/ui/G726VoiceData.h').read_text()
|
||||
source = source.split(f'#if MESH_GPS_VOICE_G726_BITRATE == {rate}\n')[1]
|
||||
source = source.split(f'#endif // {rate} kbps')[0]
|
||||
else:
|
||||
source = ((ROOT/'src/helpers/ui/GpsVoiceData.h').read_text() + '\n'
|
||||
+ (ROOT/'src/helpers/ui/ButtonVoiceData.h').read_text())
|
||||
for vibration in (False, True):
|
||||
body = select_vibration(source, vibration)
|
||||
arrays = {name:bytes.fromhex(' '.join(re.findall(r'0x([0-9a-f]{2})',data)))
|
||||
for name,data in re.findall(r'static const uint8_t (\w+)Data\[\] = \{(.*?)\};',body,re.S)}
|
||||
self.assertEqual(len(arrays['gps']), sizes[0])
|
||||
self.assertEqual(len(arrays['advertPrefix']), sizes[1])
|
||||
self.assertEqual('soundPrefix' in arrays, vibration)
|
||||
if vibration:
|
||||
self.assertEqual(len(arrays['soundPrefix']), sizes[2])
|
||||
self.assertEqual(sum(name.startswith('gps') for name in arrays), 3)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user