narrator-ts 0.0.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gareth Davidson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,134 @@
 # narrator-ts
 
-Placeholder. npm cannot configure trusted publishing for a package that does
-not exist yet, so this version exists only to create the name.
+TypeScript reimplementation of the Amiga's speech pair: `translator.library`
+(English to phonemes) and `narrator.device` 33.2 (phoneme formant synthesis).
 
-The real thing is 0.1.0 and later — published from CI, with provenance.
+Output is Paula-native — 8-bit signed samples and the period they were written
+with. Verified against the real binaries running under a 68000 emulator:
+byte-exact translation on 15,405 phrases, sample-exact synthesis end to end.
+
+```sh
+npm install narrator-ts
+```
+
+```ts
+import { speak } from 'narrator-ts'
+import { translate } from 'narrator-ts/translator'
+import rules from 'narrator-ts/reference/nrl-table.json' with { type: 'json' }
+import voice from 'narrator-ts/reference/voice-free.json' with { type: 'json' }
+
+const { phonemes } = translate('hello world', rules)   // '/HEHLOW WERLD '
+const { pcm, sampleRate } = speak(Buffer.from(phonemes, 'latin1'), voice)
+// Int8Array(26112) at 22030 Hz
+```
+
+Both tables are the free ones, so that runs with nothing else installed. Swap
+either for an extracted Amiga table to get the authentic voice — see below.
+
+`pcm` is 8-bit signed. `speak` takes `narrator_rb`'s own parameters —
+`pitch`, `rate`, `sex`, `mode`, `sampfreq`, `mouths` — and returns one entry
+per sentence alongside the joined samples, because that is how the device
+produces them.
+
+## Voices
+
+A voice is ~12 KB of tables: formant frequencies and amplitudes per phoneme,
+durations, allophonic rewrite rules, the glottal waveform, fricative noise.
+They are a *parameter*, not built in.
+
+**The authentic Amiga voice** is Commodore and SoftVoice's, so it is not in
+this repository. Extract it from Workbench disk images you already own:
+
+```sh
+python3 tools/extract-devices.py /path/to/workbench-disks -o fixtures/amiga
+python3 tools/gen-voice.py   fixtures/amiga/narrator_device-33.2-*.bin     -o data
+python3 tools/gen-tables.py  fixtures/amiga/translator_library-33.2-1*.bin -o data
+```
+
+**The free voice** is `reference/voice-free.json`, built from published
+phonetics by `tools/gen-free-voice.py` and owing nothing to anyone. It is the
+default, so a fresh clone speaks. It is not the Amiga's voice and does not
+claim to be — `reference/README.md` says what is measured and what is still
+provisional.
+
+The letter-to-sound half has its free equivalent too, and is the default when
+no Amiga table has been extracted:
+
+```ts
+import nrl from 'narrator-ts/reference/nrl-table.json' with { type: 'json' }
+translate('hello world', nrl)   // '/HEHLOW WERLD '
+```
+
+That is the rule set of NRL Report 7948 (Elovitz et al., 1976 — a US
+Government work), rebuilt from the report alone. It is not byte-compatible
+with the Amiga and is not meant to be: 64.6% of distinct words match.
+`research/03-nrl-provenance.md` has the measurements.
+
+## Command line
+
+```sh
+npm run say -- 'hello world' -o hello.wav          # the free voice
+npm run say -- 'hello world' -o hello.wav -V 33.2  # an extracted Amiga one
+npm run say -- -p '/HEH4LOW WER4LD' -o hello.wav
+npm run say -- 'is this a question' --pitch 200 --rate 100
+```
+
+`--pitch --rate --sex --mode --sampfreq --mouths` are `narrator_rb`'s own
+fields. `npm run say` with no arguments prints them.
+
+Every tool under `tools/` takes `--help`.
+
+## AROS resource export
+
+Create the versioned IFF resource consumed by AROS `translator.library`,
+`narrator.device`, and `speech.device`:
+
+```sh
+npm run export:aros -- -o speech.iff
+npm run export:aros -- -o speech.iff \
+  --translator data/translator-33.2.json \
+  --voice data/narrator-33.2.json
+npm run export:aros -- -o speech-resource.c --format c
+```
+
+The first command uses the redistributable reference tables. The second uses
+locally extracted authentic tables; the resulting file has the same legal
+status as those inputs and should not be redistributed.
+The C form contains the identical IFF payload as a byte array for ROM builds.
+
+## Status
+
+| | |
+|---|---|
+| translator | byte-exact against all 6 shipped builds |
+| narrator 33.2 | byte-exact front half, sample-exact renderer, end to end |
+| free letter-to-sound table | built, divergence measured |
+| free voice | **speaks**; texture within a few percent of 33.2's, no allophonic rules yet |
+
+`narrator.device` 37.7 is a rewrite and is **out of scope** — one voice done
+properly. 1.6, 31.13, 33.2 and 36.9 are sample-identical over 4,865 phrases,
+so 33.2 covers four of the five shipped builds anyway.
+
+## Licence
+
+Code is MIT.
+
+The Amiga binaries and everything derived by running them are not
+redistributable and are gitignored: `fixtures/amiga/*.bin`,
+`fixtures/golden/`, `data/`. None has ever been committed.
+
+`reference/` is the opposite — material that can be redistributed, with its
+provenance recorded in `reference/README.md`.
+
+`narrator.device`'s copyright line reads *Mark Barton / Joseph Katz*. It was
+licensed in from SoftVoice, Inc.; Commodore never owned it.
+
+## Documentation
+
+| | |
+|---|---|
+| `docs/development.md` | building the oracle, regenerating fixtures, coverage |
+| `research/00-findings.md` | what the binaries turned out to be |
+| `research/01-translator.md` | the letter-to-sound engine |
+| `research/02-narrator.md` | the synthesizer, stage by stage |
+| `research/03-nrl-provenance.md` | which rules came from NRL and which SoftVoice added |

package/dist/aros-resource/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * AROS Narrator resource interchange.
+ *
+ * The file is an ordinary big-endian IFF FORM. `LTRS` holds the compact
+ * letter-to-sound table and `NVOI` the subset of a voice consumed by AROS's
+ * bounded narrator engine. Unknown chunks can be skipped by older readers.
+ */
+import type { VoiceData } from '../narrator/voice.js';
+import type { TranslatorTables } from '../translator/types.js';
+export declare const AROS_RESOURCE_FORM = "NARR";
+export declare const AROS_RESOURCE_VERSION = 1;
+declare const VOICE_COLUMNS: readonly ["f1", "f2", "f3", "a1", "a2", "a3", "voicing", "mouth"];
+declare const ALT_VOICE_COLUMNS: readonly ["f1", "f2", "f3"];
+export interface ArosResourceInput {
+    translator?: TranslatorTables;
+    voice?: VoiceData;
+}
+export interface ArosVoiceTables {
+    names: string[];
+    attrs: number[];
+    params: Record<(typeof VOICE_COLUMNS)[number], number[]>;
+    paramsAlt: Record<(typeof ALT_VOICE_COLUMNS)[number], number[]>;
+    stressed: number[];
+    unstressed: number[];
+    fricatives: number[][];
+}
+export interface DecodedArosResource {
+    version: number;
+    metadata: Record<string, unknown>;
+    translator?: TranslatorTables;
+    voice?: ArosVoiceTables;
+}
+/** Encode free or extracted tables as the AROS deployment resource. */
+export declare function encodeArosResource(input: ArosResourceInput): Uint8Array;
+/** Emit the same IFF bytes as a C array for ROM or built-in resource use. */
+export declare function emitArosCResource(input: ArosResourceInput, symbol?: string): string;
+/** Decode and validate an AROS resource, primarily for tools and tests. */
+export declare function decodeArosResource(bytes: Uint8Array): DecodedArosResource;
+export {};

package/dist/aros-resource/index.js

@@ -0,0 +1,282 @@
+/**
+ * AROS Narrator resource interchange.
+ *
+ * The file is an ordinary big-endian IFF FORM. `LTRS` holds the compact
+ * letter-to-sound table and `NVOI` the subset of a voice consumed by AROS's
+ * bounded narrator engine. Unknown chunks can be skipped by older readers.
+ */
+export const AROS_RESOURCE_FORM = 'NARR';
+export const AROS_RESOURCE_VERSION = 1;
+const VOICE_COLUMNS = [
+    'f1', 'f2', 'f3', 'a1', 'a2', 'a3', 'voicing', 'mouth',
+];
+const ALT_VOICE_COLUMNS = ['f1', 'f2', 'f3'];
+class Writer {
+    bytes = [];
+    u8(value) {
+        if (!Number.isInteger(value) || value < 0 || value > 0xff)
+            throw new RangeError(`not a byte: ${value}`);
+        this.bytes.push(value);
+    }
+    u16(value) {
+        if (!Number.isInteger(value) || value < 0 || value > 0xffff)
+            throw new RangeError(`not a u16: ${value}`);
+        this.bytes.push(value >>> 8, value & 0xff);
+    }
+    u32(value) {
+        if (!Number.isInteger(value) || value < 0 || value > 0xffffffff)
+            throw new RangeError(`not a u32: ${value}`);
+        this.bytes.push((value >>> 24) & 0xff, (value >>> 16) & 0xff, (value >>> 8) & 0xff, value & 0xff);
+    }
+    raw(values) {
+        for (let i = 0; i < values.length; i++)
+            this.u8(values[i]);
+    }
+    id(value) {
+        if (value.length !== 4)
+            throw new RangeError(`IFF ID must have four characters: ${value}`);
+        for (const c of value)
+            this.u8(c.charCodeAt(0));
+    }
+    latin8(value) {
+        if (value.length > 0xff)
+            throw new RangeError('string is too long');
+        this.u8(value.length);
+        for (const c of value) {
+            const code = c.charCodeAt(0);
+            if (code > 0xff)
+                throw new RangeError(`not Latin-1: ${JSON.stringify(c)}`);
+            this.u8(code);
+        }
+    }
+    finish() { return Uint8Array.from(this.bytes); }
+}
+class Reader {
+    bytes;
+    at = 0;
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    need(count) {
+        if (this.at + count > this.bytes.length)
+            throw new RangeError('truncated AROS speech resource');
+    }
+    u8() { this.need(1); return this.bytes[this.at++]; }
+    u16() { return (this.u8() << 8) | this.u8(); }
+    u32() { return ((this.u8() * 0x1000000) + (this.u8() << 16) + (this.u8() << 8) + this.u8()) >>> 0; }
+    latin8() {
+        const n = this.u8();
+        this.need(n);
+        let out = '';
+        for (let i = 0; i < n; i++)
+            out += String.fromCharCode(this.u8());
+        return out;
+    }
+    vector(count) {
+        this.need(count);
+        const out = Array.from(this.bytes.subarray(this.at, this.at + count));
+        this.at += count;
+        return out;
+    }
+    done() { return this.at === this.bytes.length; }
+}
+function concat(parts) {
+    const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+    let at = 0;
+    for (const part of parts) {
+        out.set(part, at);
+        at += part.length;
+    }
+    return out;
+}
+function chunk(id, payload) {
+    const w = new Writer();
+    w.id(id);
+    w.u32(payload.length);
+    w.raw(payload);
+    if (payload.length & 1)
+        w.u8(0);
+    return w.finish();
+}
+function translatorChunk(data) {
+    if (data.classes.length !== 128 || data.buckets.length !== 28)
+        throw new RangeError('invalid translator table shape');
+    const w = new Writer();
+    w.u16(data.classes.length);
+    for (const value of data.classes)
+        w.u16(value);
+    w.latin8(data.wildcards);
+    w.u8(data.vowels.length);
+    for (const vowel of data.vowels)
+        w.latin8(vowel);
+    w.u16(data.buckets.length);
+    for (const bucket of data.buckets) {
+        w.u16(bucket.length);
+        for (const [left, match, right, out, term] of bucket) {
+            w.latin8(left);
+            w.latin8(match);
+            w.latin8(right);
+            w.latin8(out);
+            if (term.length !== 1)
+                throw new RangeError('translator rule terminator must be one byte');
+            w.u8(term.charCodeAt(0));
+        }
+    }
+    return w.finish();
+}
+function padded(values, count) {
+    const out = new Array(count).fill(0);
+    if (values)
+        for (let i = 0; i < Math.min(values.length, count); i++)
+            out[i] = values[i];
+    return out;
+}
+function voiceChunk(data) {
+    const count = data.names.length;
+    if (count === 0 || count > 0xffff)
+        throw new RangeError('invalid voice name count');
+    const w = new Writer();
+    w.u16(count);
+    for (const name of data.names) {
+        if (name.length > 2)
+            throw new RangeError(`phoneme name is longer than two bytes: ${name}`);
+        w.u8(name.charCodeAt(0) || 0);
+        w.u8(name.charCodeAt(1) || 0);
+    }
+    for (const value of padded(data.attrs, count))
+        w.u32(value);
+    for (const name of VOICE_COLUMNS.slice(0, 3))
+        w.raw(padded(data.params[name], count));
+    for (const name of ALT_VOICE_COLUMNS)
+        w.raw(padded(data.paramsAlt[name], count));
+    for (const name of VOICE_COLUMNS.slice(3))
+        w.raw(padded(data.params[name], count));
+    w.raw(padded(data.stressed, count));
+    w.raw(padded(data.unstressed, count));
+    const fricativeLength = data.fricatives[0]?.length ?? 0;
+    w.u16(data.fricatives.length);
+    w.u16(fricativeLength);
+    for (const table of data.fricatives) {
+        if (table.length !== fricativeLength)
+            throw new RangeError('fricative tables have unequal lengths');
+        w.raw(table);
+    }
+    return w.finish();
+}
+/** Encode free or extracted tables as the AROS deployment resource. */
+export function encodeArosResource(input) {
+    if (!input.translator && !input.voice)
+        throw new RangeError('resource contains no tables');
+    const version = new Writer();
+    version.u32(AROS_RESOURCE_VERSION);
+    const meta = new TextEncoder().encode(JSON.stringify({
+        format: 'AROS Narrator Resource',
+        translator: input.translator && { version: input.translator.version, source: input.translator.source },
+        voice: input.voice && { version: input.voice.version, source: input.voice.source },
+    }));
+    const chunks = [chunk('VERS', version.finish()), chunk('META', meta)];
+    if (input.translator)
+        chunks.push(chunk('LTRS', translatorChunk(input.translator)));
+    if (input.voice)
+        chunks.push(chunk('NVOI', voiceChunk(input.voice)));
+    const body = concat(chunks);
+    const head = new Writer();
+    head.id('FORM');
+    head.u32(body.length + 4);
+    head.id(AROS_RESOURCE_FORM);
+    return concat([head.finish(), body]);
+}
+/** Emit the same IFF bytes as a C array for ROM or built-in resource use. */
+export function emitArosCResource(input, symbol = 'sc_speech_resource') {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(symbol))
+        throw new RangeError(`invalid C symbol: ${symbol}`);
+    const bytes = encodeArosResource(input);
+    const rows = [];
+    for (let at = 0; at < bytes.length; at += 12) {
+        rows.push(`    ${Array.from(bytes.subarray(at, at + 12), (b) => `0x${b.toString(16).padStart(2, '0')}`).join(', ')},`);
+    }
+    return [
+        '/* Generated by narrator-ts; do not edit. */',
+        '#include <stddef.h>',
+        '#include <stdint.h>',
+        '',
+        `const uint8_t ${symbol}[] = {`,
+        ...rows,
+        '};',
+        `const size_t ${symbol}_length = sizeof(${symbol});`,
+        '',
+    ].join('\n');
+}
+function chunksFrom(bytes) {
+    if (bytes.length < 12)
+        throw new RangeError('truncated IFF FORM');
+    const ascii = (at) => String.fromCharCode(...bytes.subarray(at, at + 4));
+    const u32 = (at) => new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(at);
+    if (ascii(0) !== 'FORM' || ascii(8) !== AROS_RESOURCE_FORM || u32(4) + 8 !== bytes.length)
+        throw new RangeError('not an AROS Narrator IFF resource');
+    const chunks = new Map();
+    for (let at = 12; at < bytes.length;) {
+        if (at + 8 > bytes.length)
+            throw new RangeError('truncated IFF chunk');
+        const id = ascii(at), size = u32(at + 4), start = at + 8, end = start + size;
+        if (end > bytes.length)
+            throw new RangeError('truncated IFF chunk payload');
+        chunks.set(id, bytes.subarray(start, end));
+        at = end + (size & 1);
+    }
+    return chunks;
+}
+function decodeTranslator(bytes) {
+    const r = new Reader(bytes);
+    const classes = Array.from({ length: r.u16() }, () => r.u16());
+    const wildcards = r.latin8();
+    const vowels = Array.from({ length: r.u8() }, () => r.latin8());
+    const buckets = [];
+    const bucketCount = r.u16();
+    for (let b = 0; b < bucketCount; b++) {
+        const rules = [];
+        const count = r.u16();
+        for (let i = 0; i < count; i++)
+            rules.push([r.latin8(), r.latin8(), r.latin8(), r.latin8(), String.fromCharCode(r.u8())]);
+        buckets.push(rules);
+    }
+    if (!r.done())
+        throw new RangeError('trailing translator data');
+    return { version: 'resource', source: 'IFF LTRS', classes, wildcards, vowels, buckets };
+}
+function decodeVoice(bytes) {
+    const r = new Reader(bytes), count = r.u16();
+    const names = Array.from({ length: count }, () => {
+        const a = r.u8(), b = r.u8();
+        return String.fromCharCode(a, b).replace(/\0+$/, '');
+    });
+    const attrs = Array.from({ length: count }, () => r.u32());
+    const params = {};
+    for (const name of VOICE_COLUMNS.slice(0, 3))
+        params[name] = r.vector(count);
+    const paramsAlt = {};
+    for (const name of ALT_VOICE_COLUMNS)
+        paramsAlt[name] = r.vector(count);
+    for (const name of VOICE_COLUMNS.slice(3))
+        params[name] = r.vector(count);
+    const stressed = r.vector(count), unstressed = r.vector(count);
+    const fricativeCount = r.u16(), fricativeLength = r.u16();
+    const fricatives = Array.from({ length: fricativeCount }, () => r.vector(fricativeLength));
+    if (!r.done())
+        throw new RangeError('trailing voice data');
+    return { names, attrs, params, paramsAlt, stressed, unstressed, fricatives };
+}
+/** Decode and validate an AROS resource, primarily for tools and tests. */
+export function decodeArosResource(bytes) {
+    const chunks = chunksFrom(bytes);
+    const versionBytes = chunks.get('VERS');
+    if (!versionBytes || versionBytes.length !== 4)
+        throw new RangeError('missing resource version');
+    const version = new DataView(versionBytes.buffer, versionBytes.byteOffset, 4).getUint32(0);
+    if (version !== AROS_RESOURCE_VERSION)
+        throw new RangeError(`unsupported resource version ${version}`);
+    const metadata = JSON.parse(new TextDecoder().decode(chunks.get('META') ?? new Uint8Array()));
+    const translator = chunks.has('LTRS') ? decodeTranslator(chunks.get('LTRS')) : undefined;
+    const voice = chunks.has('NVOI') ? decodeVoice(chunks.get('NVOI')) : undefined;
+    return { version, metadata, translator, voice };
+}

package/dist/narrator/contour.d.ts

@@ -0,0 +1,90 @@
+/**
+ * narrator.device's contour marker — hunk+0x19c4 of build 33.2.
+ *
+ * The last thing that happens to the stress array. Everything the spreader and
+ * the duration stage put in the low nibble is thrown away, and three flags go
+ * back in their place marking where the pitch contour has to be pinned:
+ *
+ * | | |
+ * |---|---|
+ * | 1 | a vowel, the syllable's pitch peak |
+ * | 2 | the phoneme just after it, where the fall begins |
+ * | 4 | the last voiced phoneme before the fall runs out |
+ *
+ * `hunk+0x1a8e` then writes a pitch value into the frame array at each of
+ * those, and the renderer's last stage interpolates between them — which is
+ * why a captured frame array has a pitch byte at a handful of frames and
+ * zeroes in between until `0x29d8` has run.
+ */
+import type { Attrs } from './rewrite.js';
+/** Flags this stage writes into the low nibble of the stress byte. */
+export declare const CONTOUR: {
+    /** The vowel. */
+    readonly PEAK: 1;
+    /** The phoneme after it. */
+    readonly FALL: 2;
+    /** The end of the voiced run. */
+    readonly END: 4;
+};
+export interface ContourState {
+    phonemes: Uint8Array;
+    stress: Uint8Array;
+}
+/** Mark where the pitch contour is pinned, in place. */
+export declare function markContour(state: ContourState, attrs: Attrs): void;
+/**
+ * The numerator of every pitch period this device computes — `hunk+0x1a9e`.
+ *
+ * 1,221,000 is exactly 11,100 x the default pitch of 110, and the whole
+ * routine below is `constant / pitch / contourValue`. It is a constant in the
+ * binary, so it assumes the default sample rate; changing `sampfreq` does not
+ * move it.
+ */
+export declare const PERIOD_NUMERATOR = 1221000;
+/**
+ * The four per-syllable arrays `hunk+0x2160` fills, one entry per vowel.
+ *
+ * `arr0`, `arr1` and `arr2` are the three points of one syllable's pitch, in
+ * the order the device reads them out — where it starts, how high it gets,
+ * where it ends. `peak` sits between the other two in memory, which is what
+ * makes the layout confusing; it is nonetheless the highest of the three, and
+ * `hunk+0x2642` builds the other two by subtracting distances from it.
+ *
+ * They are frequencies, so a larger number is a higher note. The frame array
+ * holds periods, and every value here is divided into a constant on its way in.
+ */
+export interface PitchArrays {
+    /** `arr0`: the pitch the syllable starts on. */
+    onset: Uint8Array;
+    /** `arr1`: the pitch it reaches. */
+    peak: Uint8Array;
+    /** `arr2`: the pitch it ends on — above the peak for a question. */
+    end: Uint8Array;
+    /** `arr3`: bits 4-6 are a rise added after the fall; zero means no third leg. */
+    tail: Uint8Array;
+}
+export interface PitchOptions {
+    /** `A5+0x1c` — the device's `pitch` parameter. */
+    pitch: number;
+    /** `A5+0x30` — 1 selects the monotone robot voice. */
+    mode: number;
+}
+/**
+ * narrator.device's pitch pass — hunk+0x1a8e of build 33.2.
+ *
+ * It writes a period into the pitch byte of a *handful* of frames — the ones
+ * the contour marker pinned — and leaves the rest at zero for the renderer's
+ * last stage to interpolate between. So a captured frame array at this point
+ * has three or four pitch values in it and nothing in between.
+ *
+ * Every value is `1221000 / pitch / v`, so a larger `v` in the arrays is a
+ * *lower* note: they hold frequencies and the frame holds a period.
+ *
+ * Per syllable it pins up to four points — the onset on the syllable's first
+ * frame, the end on the last frame before the fall, the peak at a position
+ * weighted by how far the pitch has to travel between them, and, when the
+ * fourth array is non-zero, a rise back up at the end of the voiced run.
+ */
+export declare function assignPitch(state: ContourState & {
+    flags: Uint8Array;
+}, arrays: PitchArrays, frames: Uint8Array, opts: PitchOptions): void;