Publish the reproducible Sound Lab and FPGA Colour Lab sources

This commit is contained in:
bholman committed 2026-11-18 12:28:31 -07:00
commit 88254d7e24
27 files changed
+4574

No files matched your search

+115
View File
@@ -0,0 +1,115 @@
# Sound Lab packet contract
The generator authors new diagnostic packets. It does not copy a manual's BASIC
listings, include ROM bytes, call an emulator-private interface, or alter the SDK.
Run it with the standard Python library:
```sh
python3 examples/sound-lab/vectors/generate.py --output .build/sound-lab/generated
python3 -m unittest discover -s examples/sound-lab/tests -p test_vectors.py -v
```
`vectors.json` records exact command-port bytes, byte counts, SHA-256 and
CRC-16/CCITT-FALSE for each stable case ID. `vector_set_crc16` covers those bytes
concatenated in manifest order. Its checksum is an identity, not a claim that a
cartridge produced the intended sound. The manifest SHA covers canonical sorted
JSON before its own `manifest_sha256` property is appended.
`vectors.h` is generated into the requested output folder. Each `SoundVector`
has `id`, `title`, `prompt`, `tx`, `length`, `crc16`, `wait_mask`, `hold_ticks`,
and `group`. Group bits are 1 showcase, 2 short guided lab, 4 engineering sweep.
The titles and prompts fit the guest's 32-column presentation with wrapping.
The `wait_mask` conventions are current SDK/model observations: 40 speech idle,
20 sound idle, 60 both. They must be logged as observations and never used to
infer physical cartridge presence. `hold_ticks` adds a bounded observation time
before the runner sends a safety stop. An NTSC60Hz tick assumption belongs in
the report; a PAL machine must be identified separately.
Before each TX byte, including terminators, poll ready80 at FF7E with a bounded
timeout. The runner owns reset, machine/sound routing preservation, timeout
recovery, report I/O, manual sound checks and the safety stop after every case.
The runner must record any timer/reset/control prelude and cleanup separately
from these vector bytes so their receipt does not silently disagree with actual
bus traffic. Use the same prelude, TX bytes and cleanup on all three platforms.
Reset/control operations are not inferred from the text of a listening prompt.
## Source qualification
The primary publication is Tandy's1984 owner's manual. `sources.json` identifies
the retrieved54-page2004 Tim Lindner OCR/typeset reproduction by URL, SHA-256 and
byte count. This is a reproduction of the primary publication, **not a photographic
scan**. The command-table, direct-register and event-grammar page pixels were
rendered and inspected. Original-paper/photographic comparison remains pending;
that limitation must remain visible in the build's qualification notes.
The Archive's old filename no longer downloads. Its currently downloadable
`Speech-Sound Cartridge Manual (Tandy).pdf` is a newer57-page re-typeset edition.
It is retained only as discovery evidence and is not silently substituted for
the edition/page numbering cited here. No PDF is tracked or included on disk.
The primary source contains inconsistencies. Printed24 says register1–13 in
introductory prose but its table, note and printed25 example use register0.
Appendix B describes R8–R10 bit4 for envelope amplitude although the compact
printed24 table only lists fixed amplitudes0–15. Printed19 contains contradictory
parenthetical wording about noise replacement; the explicit Byte2 bit7 paragraph
defines retain-previous-amplitude behavior. We preserve these qualifications
rather than inventing undocumented commands.
## Source-qualified packet grammar
All numbers below are hexadecimal. Sources are printed pages in the54-page
edition, with1-based PDF page equal to the printed page.
| Operation | Bytes | Primary source |
| --- | --- | --- |
| Immediate text | printable uppercase ASCII, space,0D | pp9–11; space is Sound Lab's explicit flush policy |
| Stored text slot n | 90+n, text, space,0D; execute D0+n | Appendix A pp26–28 |
| Allophone slot n | B0+n, codes00–3F, final pause00–04,FF; execute F0+n | pp13–14, Appendix A pp27–29 |
| Sound slot n | 98+n, complete events,FF; execute D8+n | pp15–20, Appendix A pp26–29 |
| Register-string slot n | B8+n, register/value pairs,FF; execute F8+n | Appendix A pp28–30 |
| Direct AY register writes | AF, register,value pairs,FF | pp24–25, Appendix A p27 |
| Timer base | 8F,value00–FF | Appendix A p26 |
| Speech stop | C7 | Appendix A p28 |
| Sound stop | CF | Appendix A p28 |
| Stop both, retain buffers | 00 | Appendix A p30 |
Slots n range0–7. Text/allophone representations use the same eight speech
slots. Sound events/register strings use the same eight sound slots. Consecutive
multi-buffer operations exist but are deliberately outside this initial
single-slot packet validator. Its conservative maximum64-byte body includes
the terminator. It rejects overflow instead of relying on firmware truncation.
Tone event: channel00/20/40 OR amplitude00–0F (or envelope bit10), coarse00–0F,
fine00–FF,duration00–FF. Noise event:80/A0/C0 OR amplitude, period00–1F with
optional retain-amplitude bit80,duration. Envelope event:60 OR shape00–0F,
coarse00–FF,fine00–FF,duration. The manual also permits bit7 set on the envelope
operation; Sound Lab uses the simpler60 family.
An FF at a sound-event boundary ends the stream. FF consumed as a tone fine
period, duration or envelope operand is data. In direct/register strings, FF is
an end marker only where a register number is expected; a register's value may
be FF when its field width permits it. It is not correct to split all packets
at the first FF byte.
Event duration is the interval before the next event; it does **not** turn off
the final note. Finite vectors include explicit amplitude-zero events. REG01,
REG02 and MIX01 deliberately hold an audible output, then depend on the runner's
bounded stop. TIM01 intentionally changes the timer base; the runner resets or
restores a declared baseline between cases. Absolute milliseconds, ready-poll
counts, intonation, analog waveform fidelity and comparative envelope shape are
`MEASURE_BASELINE`, never an invented source pass.
## Existing SDK conventions kept separate
The source of the current SDK helpers is useful integration evidence, not a
substitute for the publication. Its text62-character cap and appended space are
conservative API rules. Its cold one-shot envelope prime/retrigger sequence is
an implementation workaround: these vectors instead issue the documented
envelope-enabled tone immediately followed by its envelope event. Allophone
mnemonics are labels only; an observed or heard sound still needs a HUMAN result.
The generator's eight stored speech and eight stored sound cases exercise slot
addressing independently. The64 allophone cases include five explicit silent
pause cases. The16 envelope cases request each shape without asserting that
the current emulator or future FPGA is already physically accurate. No audible
or real-hardware validation is claimed by successful Python tests.
+264
View File
@@ -0,0 +1,264 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-3.0-or-later
"""Authored Sound Lab vectors; no emulator, ROM or third-party Python required."""
import argparse
import hashlib
import json
from pathlib import Path
ROOT = Path(__file__).resolve().parent
def crc16(data):
"""CRC-16/CCITT-FALSE: poly1021, initFFFF, refin=false, xorout0000."""
crc = 0xFFFF
for byte in data:
crc ^= byte << 8
for _ in range(8):
crc = ((crc << 1) ^ (0x1021 if crc & 0x8000 else 0)) & 0xFFFF
return crc
def sound_events(data):
"""Parse event boundaries; FF is legal inside operands, not at a boundary."""
pos = 0
events = []
while pos < len(data):
op = data[pos]
if op == 0xFF:
if pos != len(data) - 1:
raise ValueError('bytes after sound terminator')
return events
width = 4 if op & 0x60 == 0x60 or not op & 0x80 else 3
if pos + width >= len(data):
raise ValueError('incomplete sound event or missing terminator')
if width == 4 and op & 0x60 != 0x60 and data[pos + 1] > 15:
raise ValueError('tone coarse period outside 12-bit range')
if width == 3 and data[pos + 1] & 0x60:
raise ValueError('noise reserved period bits set')
events.append(data[pos:pos + width])
pos += width
raise ValueError('missing sound terminator')
def register_pairs(data):
pos = 0
while pos < len(data):
reg = data[pos]
if reg == 0xFF:
if pos != len(data) - 1:
raise ValueError('bytes after register terminator')
return
if reg > 13 or pos + 1 >= len(data):
raise ValueError('invalid or incomplete register pair')
maximum = (15 if reg in (1, 3, 5, 13) else
31 if reg in (6, 8, 9, 10) else 63 if reg == 7 else 255)
if data[pos + 1] > maximum:
raise ValueError('register value outside documented field width')
pos += 2
raise ValueError('missing register terminator')
def validate_tx(data):
"""Validate the deliberately bounded, single-slot command subset used here."""
if not data or any(type(b) is not int or not 0 <= b <= 255 for b in data):
raise ValueError('TX must contain bytes')
pos = 0
while pos < len(data):
cmd = data[pos]
pos += 1
if cmd in (0, 0xC7, 0xCF) or 0xD0 <= cmd <= 0xDF or 0xF0 <= cmd <= 0xFF:
continue
if cmd == 0x8F:
if pos == len(data):
raise ValueError('timer lacks operand')
pos += 1
continue
if 0x20 <= cmd < 0x80 or 0x90 <= cmd <= 0x97:
start = pos - 1 if cmd < 0x80 else pos
try:
end = data.index(13, start)
except ValueError:
raise ValueError('text lacks CR') from None
payload = data[start:end]
if not payload or any(not 32 <= b <= 126 for b in payload):
raise ValueError('non-printable text')
if len(payload) + 1 > 64:
raise ValueError('single text buffer exceeds 64 bytes')
pos = end + 1
continue
if 0x98 <= cmd <= 0x9F:
start = pos
while pos < len(data):
op = data[pos]
if op == 255:
pos += 1
break
pos += 4 if op & 0x60 == 0x60 or not op & 0x80 else 3
body = data[start:pos]
sound_events(body)
elif 0xB0 <= cmd <= 0xB7:
start = pos
while pos < len(data) and data[pos] != 255:
if data[pos] > 63:
raise ValueError('allophone outside AL2 range')
pos += 1
if pos == len(data) or pos == start or data[pos - 1] > 4:
raise ValueError('allophones need final pause and FF')
pos += 1
body = data[start:pos]
elif cmd == 0xAF or 0xB8 <= cmd <= 0xBF:
start = pos
while pos < len(data) and data[pos] != 255:
pos += 2
if pos == len(data):
raise ValueError('register packet lacks boundary terminator')
pos += 1
body = data[start:pos]
register_pairs(body)
else:
raise ValueError(f'unsupported command {cmd:02X}')
if cmd != 0xAF and len(body) > 64:
raise ValueError('single buffer exceeds 64 bytes')
return True
def tone(channel, period, volume=10, ticks=15):
if not 0 <= channel <= 2 or not 0 <= period <= 4095 or not 0 <= volume <= 31:
raise ValueError('invalid tone fields')
return [channel * 32 + volume, period >> 8, period & 255, ticks]
def noise(channel, period, volume=8, ticks=15):
return [0x80 + channel * 32 + volume, period, ticks]
def stored_sound(events, slot=0):
return [0x98 + slot] + events + [255, 0xD8 + slot]
def authored_vectors():
out = []
def add(identity, title, prompt, tx, wait=0x20, hold=0, group=2,
source='TANDY-SOUND', expectation='MEASURE_BASELINE'):
validate_tx(tx)
out.append(dict(id=identity, title=title, prompt=prompt, tx=tx,
wait_mask=wait, hold_ticks=hold, group=group,
source_claims=[source], expectation=expectation))
def text(s):
return list((s + ' \r').encode('ascii'))
add('TXT01', 'MEET YOUR ROBOT', 'HEAR THE GREETING?',
text('HELLO BRIAN. WELCOME TO THE SOUND LAB.'), 0x40, group=3,
source='TANDY-TEXT')
add('TXT02-READ', 'WORDS AND NUMBERS', 'WORDS CLEAR? NOTE PRONUNCIATION.',
text('READY PLAYER ONE. LEVEL TWO. SCORE ONE HUNDRED.'), 0x40,
source='TANDY-TEXT')
add('TXT03-LONG', 'SHORT THEN LONG', 'COMPARE WITH THE FIRST GREETING.',
text('THE ROBOT CAN SPEAK A LONGER SENTENCE.'), 0x40,
source='TANDY-TEXT')
for channel in range(3):
add('TON01-' + 'ABC'[channel], 'TONE ' + 'ABC'[channel],
'ONE CLEAR PITCH; THEN SILENCE.',
stored_sound(tone(channel, 254) + tone(channel, 254, 0, 0)),
group=3 if channel == 0 else 2)
add('TON04', 'RISING STEPS', 'DO THE THREE NOTES RISE?',
stored_sound(sum((tone(0, p, 10, 12) for p in (428, 339, 254)), []) + tone(0, 254, 0, 0)), group=3)
add('TON05', 'THREE VOICE CHORD', 'THREE NOTES TOGETHER, THEN OFF.',
stored_sound(tone(0, 428, 8, 0) + tone(1, 339, 8, 0) + tone(2, 285, 8, 24)
+ tone(0, 428, 0, 0) + tone(1, 339, 0, 0) + tone(2, 285, 0, 0)), group=3)
add('AMP01', 'SOFT TO LOUD', 'DO THE FOUR STEPS GET LOUDER?',
stored_sound(sum((tone(0, 254, v, 10) for v in (2, 5, 9, 13)), []) + tone(0, 254, 0, 0)))
add('NOI01', 'NOISE COLORS', 'NOISE CHANGES FROM HISS TO RUMBLE.',
stored_sound(sum((noise(0, p, 7, 12) for p in (1, 8, 31)), []) + noise(0, 31, 0, 0)), group=3)
add('NOI02', 'NOISE CONTINUE', 'TWO NOISE EVENTS; SAME VOLUME.',
stored_sound(noise(0, 8, 7, 15) + noise(0, 0x80 | 16, 0, 15) + noise(0, 16, 0, 0)), group=4)
# AF writes an audible fixed tone. Parent waits hold_ticks, sends00 and confirms silence.
add('REG01', 'DIRECT AY REGISTERS', 'STEADY TONE; PANIC MUST SILENCE.',
[0xAF, 0, 254, 1, 0, 7, 62, 8, 9, 255], 0, 40, 2, 'TANDY-REGISTERS')
add('REG02', 'FF IS REGISTER DATA', 'STEADY TONE; FF DATA IS NOT END.',
[0xAF, 0, 255, 1, 0, 7, 62, 8, 8, 255], 0, 40, 4, 'TANDY-REGISTERS')
add('CMD01', 'STOP AND CONTROL', 'NO SOUND AFTER ALL THREE STOPS.',
[0xC7, 0xCF, 0], 0x60, group=4, source='TANDY-COMMANDS', expectation='DOCUMENTED_CONTROL')
add('TIM01', 'BASE TIMER', 'RECORD DURATION; NO FIXED MS CLAIM.',
[0x8F, 16] + stored_sound(tone(0, 254, 8, 4) + tone(0, 254, 0, 0)), group=4,
source='TANDY-TIMER')
add('TIM02', 'FF IS DURATION DATA', 'LONG EVENT, THEN SILENCE.',
stored_sound(tone(0, 254, 8, 255) + tone(0, 254, 0, 0)), group=4)
add('FUN01-TUNE', 'ORIGINAL SHORT TUNE', 'HEAR A SMALL RISING AND FALLING TUNE.',
stored_sound(sum((tone(0, p, 9, 9) for p in (428, 339, 285, 254, 285, 339, 428)), [])
+ tone(0, 428, 0, 0)), group=3)
# Shared speech slots and independent sound slots; each case executes only its own slot.
for slot in range(8):
add(f'BUF01-SP{slot}', f'SPEECH SLOT {slot}', 'HEAR THE CORRECT SLOT NUMBER?',
[0x90 + slot] + text('BUFFER ' + ('ZERO','ONE','TWO','THREE','FOUR','FIVE','SIX','SEVEN')[slot])
+ [0xD0 + slot], 0x40, group=4, source='TANDY-COMMANDS')
add(f'BUF02-SN{slot}', f'SOUND SLOT {slot}', 'MATCH SLOT AND SHORT TONE.',
stored_sound(tone(0, 428 - 24 * slot, 8, 8) + tone(0, 254, 0, 0), slot),
group=4, source='TANDY-COMMANDS')
names = ('PA1 PA2 PA3 PA4 PA5 OY AY EH KK3 PP JH NN1 IH TT2 RR1 AX MM TT1 DH1 IY EY DD1 UW1 AO AA YY2 AE HH1 BB1 TH UH UW2 AW DD2 GG3 VV GG1 SH ZH RR2 FF KK2 KK1 ZZ NG LL WW XR WH YY1 CH ER1 ER2 OW DH2 SS NN2 HH2 OR AR YR GG2 EL BB2').split()
for code, name in enumerate(names):
add(f'ALP01-{code:02d}', f'ALLOPHONE {code:02d} {name}',
'PAUSE: EXPECT NO VOICE.' if code < 5 else 'RECORD WHAT YOU HEAR.',
[0xB0, code, 0, 255, 0xF0], 0x40, group=4, source='TANDY-ALLOPHONES')
for shape in range(16):
# Documented grammar: envelope-enabled tone immediately followed by envelope event.
events = tone(0, 254, 16, 0) + [0x60 | shape, 3, 0, 35] + tone(0, 254, 0, 0)
add(f'ENV01-{shape:02d}', f'ENVELOPE {shape:02X}', 'COMPARE SHAPE AND END SILENCE.',
stored_sound(events), group=2 if shape == 10 else 4, source='TANDY-ENVELOPE')
add('MIX01', 'ROBOT SPACEPORT', 'VOICE OVER AN AMBIENT TONE.',
stored_sound(tone(0, 339, 5, 0)) + text('WELCOME TO THE SPACE PORT.'),
0x40, 20, 3, 'TANDY-COMMANDS')
return out
def build_manifest():
vectors = authored_vectors()
for case in vectors:
raw = bytes(case['tx'])
case.update(case_id=case['id'], crc16=f'{crc16(raw):04X}',
tx_hex=raw.hex(' ').upper(), byte_count=len(raw),
crc16_ccitt_false=f'{crc16(raw):04X}', sha256=hashlib.sha256(raw).hexdigest())
identities = [v['id'] for v in vectors]
if len(set(identities)) != len(identities):
raise ValueError('duplicate vector ID')
body = dict(schema='vccplus.sound-lab.vectors.v1', vector_version='1.0',
vector_set_crc16=f"{crc16(bytes(b for case in vectors for b in case['tx'])):04X}",
authored=True, crc='CRC-16/CCITT-FALSE',
result_policy='HUMAN listening is never an AUTO pass; timings are MEASURE_BASELINE.',
source_catalog=json.loads((ROOT / 'sources.json').read_text()), vectors=vectors)
canonical = json.dumps(body, sort_keys=True, separators=(',', ':')).encode()
body['manifest_sha256'] = hashlib.sha256(canonical).hexdigest()
return body
def emit(output):
manifest = build_manifest()
output.mkdir(parents=True, exist_ok=True)
(output / 'vectors.json').write_text(json.dumps(manifest, indent=2) + '\n')
lines = ['/* Generated by vectors/generate.py; do not edit. */', '#ifndef SOUND_LAB_VECTORS_H',
'#define SOUND_LAB_VECTORS_H',
'typedef struct { const char *id; const char *title; const char *prompt;',
'const unsigned char *tx; unsigned length; unsigned crc16;',
'unsigned char wait_mask; unsigned char hold_ticks; unsigned char group; } SoundVector;']
for i, case in enumerate(manifest['vectors']):
lines.append('static const unsigned char sound_tx_%u[] = {%s};' %
(i, ','.join('0x%02X' % b for b in case['tx'])))
lines.append('static const SoundVector sound_vectors[] = {')
for i, case in enumerate(manifest['vectors']):
lines.append('{%s,%s,%s,sound_tx_%u,%u,0x%s,0x%02X,%u,%u},' %
(json.dumps(case['id']), json.dumps(case['title']), json.dumps(case['prompt']),
i, case['byte_count'], case['crc16_ccitt_false'], case['wait_mask'],
case['hold_ticks'], case['group']))
lines += ['};', '#define SOUND_VECTOR_COUNT %u' % len(manifest['vectors']),
'#define SOUND_VECTOR_VERSION "1.0"',
'#define SOUND_MANIFEST_SHA256 "%s"' % manifest['manifest_sha256'], '#endif', '']
(output / 'vectors.h').write_text('\n'.join(lines))
return manifest
if __name__ == '__main__':
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--output', type=Path, required=True)
args = parser.parse_args()
result = emit(args.output)
print(f"{len(result['vectors'])} vectors; manifest {result['manifest_sha256']}")
+74
View File
@@ -0,0 +1,74 @@
{
"schema": "vccplus.sound-lab.sources.v1",
"sources": [
{
"id": "TANDY-OWNER-1984",
"title": "Color Computer Speech/Sound Cartridge Owner's Manual",
"publisher": "Tandy Corporation",
"year": 1984,
"url": "https://colorcomputerarchive.com/repo/Documents/Manuals/Hardware/Speech-Sound%20Cartridge%20%28Tandy%29.pdf",
"sha256": "80aa645aa57da31121f7741d7373f21c5e5c69825f5a5eff8a86ad899055c92a",
"qualification": "Primary Tandy publication reproduced/OCR-typeset by Tim Lindner; 54-page2004 PDF retrieved2026-11-17. Page pixels24,26,28 inspected for AF/register0-13, timer8F, single slots and C7/CF controls. This is not a photographic original scan: original-paper comparison remains pending. Archive old filename404s; current alternate Manual filename is a newer57-page reproduction, retained separately and not used as the cited edition.",
"page_numbering": "Printed page =1-based PDF page in the54-page cited edition.",
"claims": [
{
"id": "TANDY-TEXT",
"pages": "9-11",
"section": "Speaking of the S/SC",
"fact": "Printable text is sent at FF7E with ready polling; CR completes input. The diagnostic appends a space to flush a final word as its explicit conservative authoring policy."
},
{
"id": "TANDY-COMMANDS",
"pages": "12-14,26-30",
"section": "Straight Talk; Appendix A",
"fact": "Eight speech slots support text or allophones; eight sound slots support events or register strings. Single-slot load and execute commands are used. 00 stops speech and sound without clearing stored buffers; C7 stops speech; CF stops sound."
},
{
"id": "TANDY-SOUND",
"pages": "15-20",
"section": "Sound Advice; Dial Tone; As Plain as the Noise",
"fact": "Tone events consume4 bytes, noise3; event-boundary FF terminates, operand FF is data. Final amplitude-zero events silence sustained output. Duration is between events, not an automatic noteoff."
},
{
"id": "TANDY-TIMER",
"pages": "18,20,23,26",
"section": "Event duration; Appendix A8F",
"fact": "8F accepts one0-255 base-time operand. Larger values increase event duration. No absolute event timing is asserted here."
},
{
"id": "TANDY-ENVELOPE",
"pages": "21-23,33-34",
"section": "The Envelope, Please; Appendix B",
"fact": "Envelope event is4 bytes: operation60+shape, coarse period, fine period, duration. All channels share one envelope generator. Envelope-enabled tone/noise is immediately followed by envelope group."
},
{
"id": "TANDY-REGISTERS",
"pages": "24-25,27,31-34",
"section": "Scaling the Sound Registers; Appendices A/B",
"fact": "AF enters direct register/value access; FF at a register boundary exits. Table and example explicitly include register0 despite the introductory prose saying1-13. Register operands may equalFF. R8-R10 bit4 envelope mode is documented in Appendix B though compact table lists only fixed0-15."
},
{
"id": "TANDY-ALLOPHONES",
"pages": "13-14,35-36",
"section": "Straight Talk; Appendix C",
"fact": "AL2 addresses0-63;0-4 are pauses. Allophone strings end with a pause then FF. Code order and mnemonic labels follow Appendix C; sound fidelity and duration remain measurements."
}
],
"retrieved_url": "https://tlindner.macmess.org/wp-content/uploads/2006/09/sscmanual.pdf",
"byte_count": 211234,
"alternate_reproduction": {
"url": "https://colorcomputerarchive.com/repo/Documents/Manuals/Hardware/Speech-Sound%20Cartridge%20Manual%20(Tandy).pdf",
"sha256": "7170a1c33164d654f2d92af8c708bc38bac14dbd53f3fa142da1cd724201f1de",
"pages": 57,
"role": "Discovery evidence only, not cited for command grammar."
}
}
],
"non_assertions": [
"No physical cartridge, FPGA, human listening or analog fidelity pass is claimed by this manifest.",
"Speech standby40 and sound idle20 are current SDK/model observation conventions, not source-qualified hardware acceptance assertions in this manifest.",
"No automatic controller or cartridge presence detection is inferred from a floating status byte.",
"The SDK's priming/retrigger workaround for cold one-shot envelopes is not substituted for documented packet grammar.",
"Single-slot sound/register payloads include the terminator within64 bytes. Allophone and text slots share storage; this is not16 independent speech buffers."
]
}