narrator-ts 0.0.0 → 0.1.1

package/dist/narrator/parse.js

@@ -0,0 +1,184 @@
+/**
+ * narrator.device's phoneme parser — the front of the front half.
+ *
+ * Ported from hunk+0xf68 of build 33.2. It turns the input string into three
+ * parallel byte arrays, and every later stage works from those rather than
+ * from the text, so getting this exactly right is a precondition for getting
+ * durations or frames right. See research/02-narrator.md.
+ *
+ * The arrays start at index 4, not 0. Slots 0-3 are a lead-in the later
+ * stages look backwards into, with slot 2 seeded to QX; a port that starts at
+ * zero will produce plausible phonemes and wrong everything else.
+ */
+/** Attribute bits this stage tests. Others are used further down. */
+export const ATTR = {
+    /** Bit 0 (0x100a): a stress digit may follow this phoneme. */
+    STRESSABLE: 1 << 0,
+    /** Bit 25 (0x10de): this phoneme already ends an utterance. */
+    TERMINAL: 1 << 25,
+    /** Bit 26 (0x103a): a pause — space, `.`, `?`, `,` or `-`. */
+    PAUSE: 1 << 26,
+    /** Bit 27 (0x1032): rejected wherever it appears. */
+    ILLEGAL: 1 << 27,
+};
+/** Phoneme indices the parser names directly. */
+const P = { SPACE: 0, PERIOD: 1, QUERY: 2, DASH: 4, OPEN: 5, CLOSE: 6, QX: 0x15 };
+/** Where the real phonemes start; 0-3 are the lead-in. */
+export const LEAD_IN = 4;
+/** The arrays are 0x200 bytes, which is also the phoneme limit. */
+export const MAX_PHONEMES = 0x200;
+/** Written into all three arrays after the last phoneme. */
+export const TERMINATOR = 0xff;
+/**
+ * Parse a phoneme string the way the device does.
+ *
+ * `input` is bytes rather than a string because the device works in Latin-1
+ * and scans two characters at a time, including the byte past the end.
+ */
+export function parse(input, table, length = input.length) {
+    const phonemes = new Uint8Array(MAX_PHONEMES + 2);
+    const stress = new Uint8Array(MAX_PHONEMES + 2);
+    const flags = new Uint8Array(MAX_PHONEMES + 2);
+    // 0x100a and friends index the attribute table by phoneme. The digits sit
+    // past its end and are peeled off as stress before any lookup, so anything
+    // out of range here would be a bug rather than a value.
+    const attrOf = (p) => table.attrs[p] ?? 0;
+    // 0xf8a-0xf96: the lead-in. Only slot 2 is non-zero.
+    phonemes[2] = P.QX;
+    // 0xf68: an empty request produces nothing at all, not an empty utterance.
+    if (length <= 0)
+        return { phonemes, stress, flags, count: 0, consumed: 0 };
+    let at = 0; // A0, the read position
+    let n = LEAD_IN; // D3, the write position
+    stress[n] = 0; // 0xfa8, the loop's entry clear
+    flags[n] = 0;
+    const byte = (i) => (i < input.length ? input[i] : 0);
+    for (;;) {
+        const c0 = byte(at);
+        // 0xfb2/0xfba: NUL or '#' ends the input regardless of io_Length.
+        if (c0 === 0 || c0 === 0x23)
+            break;
+        // 0xfbe-0xfe2: match two characters, then fall back to one. The table is
+        // words, so a one-character name is that character followed by NUL — and
+        // the retry masks the low byte off rather than re-reading.
+        let word = (c0 << 8) | byte(at + 1);
+        let taken = 2;
+        let idx = table.names.findIndex((_, i) => wordAt(table, i) === word);
+        if (idx < 0) {
+            if (taken === 1)
+                return fail(at);
+            word &= 0xff00;
+            taken = 1;
+            idx = table.names.findIndex((_, i) => wordAt(table, i) === word);
+            if (idx < 0)
+                return fail(at);
+        }
+        // 0xfea-0x1022: a stress digit. It attaches to the phoneme *already*
+        // written, not to the next one.
+        if (word >= 0x3000 && word <= 0x3900) {
+            at += taken;
+            // 0x3000 is a bare '0', which is the default and simply disappears.
+            if (word !== 0x3000) {
+                if (!(attrOf(phonemes[n - 1]) & ATTR.STRESSABLE))
+                    return fail(at - taken);
+                stress[n - 1] = 0x30 | ((word >> 8) & 0x0f);
+            }
+            if (!more())
+                break;
+            continue;
+        }
+        at += taken;
+        const attr = attrOf(idx);
+        // 0x1032, and note the position: A0 is advanced at 0x1026, *before* this
+        // test, so the offset reported points past the phoneme rather than at it.
+        // The digit and no-match rejections above report the character itself.
+        if (attr & ATTR.ILLEGAL)
+            return fail(at);
+        if (attr & ATTR.PAUSE) {
+            // 0x103a-0x1062: pauses collapse. A run of them keeps the *last*, so
+            // "a . b" and "a. b" agree — except that a plain space after any pause
+            // is dropped instead of replacing it.
+            if (attrOf(phonemes[n - 1]) & ATTR.PAUSE) {
+                if (n <= LEAD_IN || idx === P.SPACE) {
+                    if (!more())
+                        break;
+                    continue;
+                }
+                // Overwrite the previous pause. Note its stress and flag bytes are
+                // *not* re-cleared — the loop only clears the slot after the one it
+                // just wrote — so they survive into the replacement.
+                n--;
+            }
+        }
+        else if (idx === P.OPEN) {
+            // 0x106a: emphasis brackets set a bit and store no phoneme. Neither
+            // path takes the io_Length check at the bottom of the loop.
+            flags[n] |= 0x20;
+            continue;
+        }
+        else if (idx === P.CLOSE) {
+            flags[n - 1] |= 0x10;
+            continue;
+        }
+        // 0x1084: store.
+        phonemes[n] = idx;
+        n++;
+        // 0x108a: '.' and '?' end the utterance even mid-string.
+        if (idx === P.PERIOD || idx === P.QUERY)
+            break;
+        if (n >= MAX_PHONEMES)
+            return fail(at);
+        if (!more())
+            break;
+        stress[n] = 0;
+        flags[n] = 0;
+    }
+    // 0x10cc. A trailing space is dropped, and then the result is *still*
+    // considered for a '-' — the device falls through from one to the other
+    // rather than choosing between them, so "AA4 " ends up a phoneme longer
+    // than it started rather than a phoneme shorter.
+    //
+    // Note there is no lower bound on the decrement. With nothing but a pause
+    // for input the write index walks back into the lead-in, and the length
+    // test at the end then rejects the whole utterance — which is why a lone
+    // "." produces silence rather than a pause.
+    let dash = true;
+    if (phonemes[n - 1] === P.SPACE)
+        n--;
+    else if (attrOf(phonemes[n - 1]) & ATTR.TERMINAL)
+        dash = false;
+    // 0x10e4: `ble` against 3, not against the lead-in.
+    if (dash && n > 3) {
+        phonemes[n] = P.DASH;
+        stress[n] = 0;
+        flags[n] = 0;
+        n++;
+    }
+    phonemes[n] = TERMINATOR;
+    stress[n] = TERMINATOR;
+    flags[n] = TERMINATOR;
+    n++;
+    // 0x110e: how far the scan got, which is what the driver advances by.
+    const consumed = at;
+    // 0x1118: four or fewer means the lead-in and nothing else.
+    if (n <= LEAD_IN)
+        return { phonemes, stress, flags, count: 0, consumed };
+    return { phonemes, stress, flags, count: n, consumed };
+    /** 0x10aa: stop once io_Length is consumed, whatever the buffer holds. */
+    function more() {
+        if (at >= length)
+            return false;
+        stress[n] = 0;
+        flags[n] = 0;
+        return true;
+    }
+    /** 0x10c2: the device reports a 1-based character offset, not a code. */
+    function fail(pos) {
+        return { phonemes, stress, flags, count: 0, consumed: at, error: pos + 1 };
+    }
+}
+/** The table as the scan sees it: two bytes, NUL-padded, big-endian. */
+function wordAt(table, i) {
+    const s = table.names[i] ?? '';
+    return ((s.charCodeAt(0) || 0) << 8) | (s.charCodeAt(1) || 0);
+}

package/dist/narrator/prosody.d.ts

@@ -0,0 +1,355 @@
+/**
+ * narrator.device's prosody pass — hunk+0x1ee0 of build 33.2, and the five
+ * routines it calls.
+ *
+ * This is the last stage of the front half to be read, and it is what decides
+ * the *tune*. Everything before it works phoneme by phoneme; this works
+ * syllable by syllable, one phrase at a time, and it is called round a loop —
+ * `hunk+0x832` runs it, then `hunk+0x2160`, until it reports no phrase left.
+ *
+ * The five build up three arrays indexed by syllable:
+ *
+ * | | | |
+ * |---|---|---|
+ * | `0x1f02` | {@link scanPhrase} | `arr4`: how stressed each syllable is |
+ * | `0x1fd8` | {@link markBoundaries} | `arr3`: where the phrase breaks are |
+ * | `0x20bc` | {@link markVoiced} | `arr5`: seed every syllable with 1 |
+ * | `0x20d0` | {@link markPunctuation} | `arr5`: `.` is 4, `?` is 8 |
+ * | `0x210a` | {@link markCadence} | `arr3`: the final fall, or the rise |
+ *
+ * They are five separate `bsr`s that **share `D4`**, the syllable count, in a
+ * register — none of the last four sets it up. So they are one routine split
+ * five ways rather than five routines, and the count is threaded here.
+ */
+import type { Attrs } from './rewrite.js';
+/** Values written into `arr4`, the per-syllable descriptor. */
+export declare const SYLLABLE: {
+    /** Bits 0-3: the scaled stress digit. */
+    readonly LEVEL: 15;
+    /** 0x20: a primary stress. */
+    readonly PRIMARY: 32;
+    /** 0x40: the last syllable of the utterance. */
+    readonly LAST: 64;
+    /** 0x80: a pause follows this syllable. */
+    readonly PAUSE: 128;
+};
+/** `hunk+0x1f02` gives up at this many syllables — `arr4` is 0x80 bytes. */
+export declare const MAX_SYLLABLES = 128;
+/** The workspace scalars this stage keeps, by their `A5` offsets. */
+export interface ProsodyCounters {
+    /** `A5+0x88`: which pass round the loop this is. */
+    pass: number;
+    /** `A5+0x8a`: primary stresses in this phrase. */
+    stresses: number;
+    /** `A5+0x8c`: syllables in this phrase. */
+    syllables: number;
+    /** `A5+0x8e`: the first primary stress, or the syllable count if none. */
+    first: number;
+    /** `A5+0x90`: boundaries seen. */
+    boundaries: number;
+    /** `A5+0x9e`: the last primary stress. */
+    last: number;
+    /** `A5+0xa0`: syllables across the whole utterance. */
+    total: number;
+}
+export interface ProsodyState {
+    phonemes: Uint8Array;
+    stress: Uint8Array;
+    flags: Uint8Array;
+    /** `A5+0x7c`, `+0x84` and `+0x80` — cursors, which each pass moves on. */
+    atPhoneme: number;
+    atStress: number;
+    atFlag: number;
+    /** The eight `0x80`-byte arrays at `A5+0x6e8`. */
+    arr: Uint8Array[];
+    /**
+     * `A5+0x5c`..`+0x78` hold a cursor into each of the eight, and they all
+     * advance together — `hunk+0x2160` moves them past each phrase once it has
+     * consumed it. So a routine here indexes from this rather than from zero,
+     * and phrase two of an utterance writes where phrase one left off.
+     */
+    arrAt: number;
+    counters: ProsodyCounters;
+}
+/**
+ * hunk+0x1f02. Walk the next phrase and write one descriptor per syllable.
+ *
+ * A syllable here is a phoneme the stress spreader marked. Its level comes
+ * from the stress digit the writer typed, scaled by 199/128 — so a `4` becomes
+ * 6 — and a further 2 if the phoneme is inside a spread. Anything above 4
+ * counts as a primary stress and is remembered as such.
+ *
+ * That scaling is the one place the digits 0-9 stop being a rank and become a
+ * number the synthesizer does arithmetic with.
+ *
+ * Returns the syllable count, which the four routines after this one read out
+ * of `D4` rather than recomputing, or `null` if the array overflowed.
+ */
+export declare function scanPhrase(state: ProsodyState, attrs: Attrs): number | null;
+/**
+ * hunk+0x1fd8. Walk the same phrase again and record where it breaks, then
+ * move the cursors past it.
+ *
+ * `arr3` gets `0x90` at a dash, and that is all it gets in this build.
+ *
+ * The other two markers, `2` and `0x0e`, come from bits 4 and 5 of the flag
+ * byte, and **nothing in 33.2 ever sets them**. The parser zeroes the array,
+ * the rewrite engine zeroes what it inserts, and the stress spreader writes
+ * only `0x80` and `0x40`; every flag byte reaching here across the whole
+ * corpus is one of 0, 0x40, 0x80 or 0xc0. So the marker-shuffling pass at the
+ * end of this routine — which walks to the nearest primary stress and moves a
+ * marker onto it, backwards for `0x0e` and forwards for `2` — can never run.
+ *
+ * It is ported anyway. It is real code with a clear meaning, it is what the
+ * routine says, and 37.7 is a rewrite that may well feed it.
+ */
+export declare function markBoundaries(state: ProsodyState, attrs: Attrs): number;
+/**
+ * hunk+0x20bc. Set bit 0 on every syllable of the phrase.
+ *
+ * `D4` is not loaded here — it is still the count `scanPhrase` left behind.
+ */
+export declare function markVoiced(state: ProsodyState, syllables: number): void;
+/**
+ * hunk+0x20d0. Record what the phrase ended with — `.` is 4, `?` is 8 —
+ * backwards from the end until a syllable that a pause follows.
+ *
+ * A comma is neither, so it leaves nothing; the difference between a statement
+ * and a question is decided here and read by {@link markCadence}.
+ */
+export declare function markPunctuation(state: ProsodyState, syllables: number): void;
+/**
+ * hunk+0x210a. Give the phrase its cadence: `0xb0` normally, `0x30` after a
+ * question, and a `4` on the last primary stress.
+ *
+ * It does nothing at all when the phrase ended on the punctuation itself —
+ * the cursors are past it by then, so `(-1,A0)` is the `.` or `?` and this
+ * returns. Only a phrase that ran out some other way gets a cadence.
+ *
+ * Which means **this** rise never fires. It is chosen by `arr5[n - 1] == 8`,
+ * and 8 is what {@link markPunctuation} writes for a `?`; but a phrase that
+ * ended in `?` has already returned two lines above, and in any case
+ * {@link markVoiced} has put bit 0 into every entry first, so the value is 9
+ * and never 8. Two independent reasons, either enough on its own.
+ *
+ * That is not to say 33.2 cannot ask a question. It does — in
+ * {@link linkSyllables}, which reads the same `arr5` byte and inverts the
+ * final fall into a rise, and which the corpus drives. This particular rise is
+ * the dead one. Ported as written rather than "fixed".
+ */
+export declare function markCadence(state: ProsodyState, syllables: number): void;
+/**
+ * hunk+0x1ee0. One pass round the driver's loop: find the next phrase and
+ * describe it, or report that there is none left.
+ *
+ * The driver at `hunk+0x832` calls this, then `hunk+0x2160` to turn the
+ * description into pitch values, and goes round again until this returns
+ * false. `false` is the device's `Z` exit and comes straight from the
+ * `move.w D4,(A5+0x8c)` that ends {@link scanPhrase} — a syllable count of
+ * zero sets it, which is why the routine ends by storing the count rather
+ * than by testing anything.
+ *
+ * Note the count the last three routines see is {@link markBoundaries}'s, not
+ * {@link scanPhrase}'s. Both count phonemes the spreader marked, but the scan
+ * can walk past some of them looking for a stress digit, so they are not
+ * guaranteed to agree, and the device leaves whichever ran last in `D4`.
+ */
+export declare function nextPhrase(state: ProsodyState, attrs: Attrs): boolean;
+/**
+ * hunk+0x21b8. The pitch the phrase's first stressed syllable starts on.
+ *
+ * This is **declination**: the value falls as the utterance goes on. It is
+ * built from how many phrases have been spoken (`pass`) and how many
+ * boundaries have been crossed, not from anything about the syllable itself,
+ * so the sixth phrase of a paragraph starts lower than the first — which is
+ * what a speaker running out of breath actually does.
+ *
+ * The result is clamped to 125..165, and returned because `hunk+0x220c` picks
+ * it up out of `D0` rather than reading it back.
+ */
+export declare function phrasePitch(state: ProsodyState): number;
+/**
+ * hunk+0x220c. Give every stressed syllable of the phrase its peak pitch.
+ *
+ * {@link phrasePitch} has put a value on the first one; this walks the rest and
+ * steps down from it, landing on 110 at the last — 115 if the phrase ended in
+ * a question mark, which is the only effect a `?` has on this build's contour
+ * and the only place the question survives at all.
+ *
+ * Three passes, in one routine:
+ *
+ * 1. **0x224c** — share the whole fall out over the phrase's primary stresses,
+ *    but give the first and the last 19/128 of a step extra and take it back
+ *    evenly from the ones in between. So the pitch drops fastest at each end
+ *    of the phrase and coasts through the middle, which is what declination
+ *    actually looks like. Below four stresses there is no middle to take it
+ *    from and every step is equal.
+ * 2. **0x2274** — backwards, pulling each stressed syllable 51/128 of the way
+ *    towards a neighbour. Dead in 33.2: the neighbour is chosen by the low two
+ *    bits of `arr5`, {@link markVoiced} puts a 1 in every entry of it before
+ *    this runs, and 1 is the "leave it alone" case.
+ * 3. **0x22d6** — scale by how stressed each syllable is. A level above 8 is
+ *    pushed further above 110 and one below 8 pulled back towards it, in
+ *    proportion to how far above 110 it already sits, so the contrast between
+ *    a strong and a weak stress opens up at the top of the phrase and closes
+ *    at the bottom.
+ *
+ * `pitch` is {@link phrasePitch}'s result, which the device leaves in `D0`.
+ */
+export declare function syllablePitch(state: ProsodyState, pitch: number): void;
+/**
+ * hunk+0x230c. How far each stressed syllable climbs to the peak
+ * {@link syllablePitch} gave it, and how far it drops away again.
+ *
+ * `arr6` is the climb and `arr7` the drop, both as distances *below* the peak,
+ * and `hunk+0x2642` finally subtracts them to get the syllable's onset and its
+ * end. Both are proportional to how far the peak sits above 110, so a syllable
+ * that has already fallen to the floor of the phrase gets no contour at all
+ * and the utterance flattens out as it ends.
+ *
+ * The shape is set by the low nibble of the cadence byte, read as a *signed*
+ * nibble: the climb is `(26·cadence + 128)/128` of that distance and the drop
+ * is `(cadence − 1)·26/128` of it. A cadence of 4 — what {@link markCadence}
+ * puts on the last primary stress of a phrase — makes the climb nearly twice
+ * the default and the drop three times it, which is the sentence-final fall.
+ *
+ * A negative nibble would invert the climb, and none is reachable: the only
+ * values anything puts in that nibble are 0 and the 4 {@link markCadence}
+ * writes, the 2 and the 0x0e of {@link markBoundaries} both coming from flag
+ * bits nothing in 33.2 sets.
+ *
+ * The drop is clipped at zero rather than allowed to go negative here, so at
+ * this stage a syllable can end level with its peak but never above it. Only
+ * {@link linkSyllables} lifts it above, and only for a question.
+ */
+export declare function syllableRange(state: ProsodyState): void;
+/**
+ * hunk+0x23ce. Reconcile each stressed syllable with the next one, and give
+ * the phrase its final punctuation.
+ *
+ * Two halves. The first walks the primary stresses backwards in pairs and
+ * adjusts both by how far apart they are:
+ *
+ * - **Back to back** (0x23f8) — both contours shrink to 77/128, the earlier
+ *   peak drops 26/128 of its height and the later one rises by the same, and
+ *   then whatever gap is left between where the earlier syllable ends and the
+ *   later one starts is closed outright. Two stresses in a row have no room
+ *   for two full contours, so they are flattened and butted together.
+ * - **Anything further apart** (0x2496) — both contours *grow*, by 19, 32 or
+ *   38 parts in 128 as the gap is one, two or more syllables, and the peaks
+ *   move apart rather than together. With room between them each stress gets
+ *   its own excursion, and the more room the bigger.
+ *
+ * The second half (0x2574) is the punctuation, on any stressed syllable a
+ * pause follows:
+ *
+ * - **A full stop** ends the syllable a flat 75 below its peak.
+ * - **A question** shortens the climb by 102/128 of the drop and then rebuilds
+ *   the drop from the *highest* peak anywhere earlier in the phrase, times
+ *   154/128. That is larger than this syllable's own peak, so the drop comes
+ *   out negative and the syllable ends *above* where it peaked.
+ *
+ * So 33.2 does speak a question differently — here, in arithmetic, rather than
+ * through the rise flag in {@link markCadence} that no input can select.
+ */
+export declare function linkSyllables(state: ProsodyState): void;
+/**
+ * hunk+0x25f8. Deepen the drop at a phrase boundary.
+ *
+ * The high nibble of the cadence byte is what {@link markCadence} and
+ * {@link markBoundaries} put there: `0xb0` on the phrase's last syllable and
+ * `0x90` on the one before a dash. Either adds 38/128 to that syllable's drop,
+ * so the pitch falls half again as far at the end of a phrase as it does
+ * inside one. That, and not the cadence flag, is what a comma sounds like.
+ *
+ * The other arm takes 102/128 *off* the drop instead, and is unreachable: it
+ * wants the high nibble non-zero with bit 7 clear, and the only two values
+ * that can put anything in that nibble both set bit 7. Its two possible
+ * sources — the `2` and the `0x0e` of {@link markBoundaries} — need flag bits
+ * nothing in 33.2 sets.
+ */
+export declare function boundaryFall(state: ProsodyState): void;
+/**
+ * hunk+0x2642. Turn the peaks and their two distances into three real pitches
+ * per syllable, and fill in every syllable that has not got one.
+ *
+ * Up to here only the primary stresses have been touched, and each is held as
+ * a peak with a climb and a drop hanging off it. This is where that becomes
+ * `arr0`, `arr1`, `arr2` — an onset, a peak and an end — for *every* syllable
+ * of the phrase, which is what `hunk+0x1a8e` needs.
+ *
+ * Four passes:
+ *
+ * 1. **0x265e** — subtract: onset is peak minus climb, end is peak minus drop.
+ * 2. **0x2680** — take the stresses in pairs and fill the gap between them.
+ *    If the earlier syllable ends below where the later one starts, the two
+ *    are moved half the distance towards each other first, so the line never
+ *    has to climb backwards. Then the run between them glides down through
+ *    {@link GLIDE}.
+ * 3. **0x277e** — everything *before* the phrase's first stress sits flat at
+ *    110, with its peak lifted by twice its own stress level. An unstressed
+ *    lead-in is spoken at the bottom of the range.
+ * 4. **0x27a8** — everything *after* the last stress. Here the step is not
+ *    from a table: it is the whole remaining distance down to 110, divided
+ *    evenly by however many syllables are left, so the tail always lands on
+ *    the floor whatever its length. A full stop aims 35 lower still and ends
+ *    on 75; a comma or nothing ends on 110; a question does something else
+ *    entirely and ends on 154/128 of the phrase's highest peak.
+ */
+export declare function fillContours(state: ProsodyState): void;
+/**
+ * hunk+0x2864. Squeeze each stressed syllable's contour by the consonants
+ * around it — the last thing the pitch loop does.
+ *
+ * This is **consonantal F0 perturbation**, and it is the most linguistically
+ * literate thing in the device after {@link intrinsicPitch}. A consonant
+ * disturbs the pitch of the vowel next to it, and how much depends on whether
+ * it is voiced: a voiceless one perturbs far more, because the larynx has to
+ * stop and restart. Both ends of the syllable are treated separately.
+ *
+ * At the **onset** (0x28a0), only if the syllable begins with a consonant: the
+ * start of the contour is moved up towards the peak by 26/128 of the climb
+ * after a voiced consonant and 102/128 after a voiceless one — so a syllable
+ * beginning `p` or `t` has almost no room to rise and one beginning `m` or `b`
+ * keeps nearly all of it. A voiceless onset also lifts the whole contour by
+ * 26/128 of its height first, which is the well-attested raising of F0 after a
+ * voiceless stop.
+ *
+ * At the **end** (0x291a), by what the syllable runs into. The device walks
+ * forward past the stress digit to the first phoneme that settles it:
+ *
+ * | | |
+ * |---|---|
+ * | 26/128 | a vowel or the glottal stop — the fall carries on into it |
+ * | 86/128 | a voiceless phoneme first — most of the fall is eaten |
+ * | 64/128 | a pause follows, or the next syllable is stressed too |
+ *
+ * Voiced consonants in between are stepped over, since they do not interrupt
+ * the pitch. And a phrase whose last syllable is stressed is left alone, there
+ * being nothing after it to run into.
+ *
+ * Each adjustment moves the endpoint and shrinks the distance by the same
+ * amount, so the peak never moves and the three stay consistent.
+ */
+export declare function coarticulatePitch(state: ProsodyState, attrs: Attrs): void;
+/**
+ * hunk+0x2160. One phrase's worth of pitch, and then move the cursors past it.
+ *
+ * The driver at `hunk+0x832` alternates {@link nextPhrase} with this until
+ * there is no phrase left, so between them they are the whole of the tune.
+ *
+ * Two things are skipped rather than guarded inside the routines themselves.
+ * `mode` — the monotone robot voice — skips all seven, since
+ * {@link assignPitch} is going to write one flat period over everything
+ * anyway; and a phrase with no primary stress in it skips the first four,
+ * which are the ones that need somewhere to hang a contour, leaving the last
+ * three to fill it in flat.
+ *
+ * The seven pass registers between them and the device never reloads what one
+ * of them clobbers, so they have to run in this order. `phrasePitch` is the
+ * only one whose result is threaded by hand, in `D0`.
+ *
+ * Ends by adding the syllable count to all eight array cursors at once, which
+ * is what makes the next phrase write where this one stopped.
+ */
+export declare function pitchLoopBody(state: ProsodyState, attrs: Attrs, mode: number): void;