@mcptoolshop/voice-engine-dsp 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 MCP Voice Engine Contributors
+
+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

@@ -0,0 +1,78 @@
+<div align="center">
+  <img src="https://raw.githubusercontent.com/mcp-tool-shop-org/mcp-voice-engine/master/assets/logo.jpg" alt="MCP Voice Engine Logo" width="100%">
+</div>
+
+# MCP Voice Engine
+
+Deterministic, streaming-first prosody engine for expressive voice synthesis, pitch control, and real-time voice transformation.
+
+<!-- Badges --> 
+<!-- ![Build Status](https://img.shields.io/github/actions/workflow/status/mcp-tool-shop-org/mcp-voice-engine/ci.yml) ![License](https://img.shields.io/github/license/mcp-tool-shop-org/mcp-voice-engine) -->
+
+## Why this exists
+
+Most voice DSP systems fail in two places: **stability** (warble, jitter, note flutter) and **reproducibility** (“it only happens sometimes”). MCP Voice Engine is built to be musical, causal, and deterministic—so it behaves like software, not folklore.
+
+## What you can build with it
+
+*   **Real-time voice stylization** for games and interactive apps (stable targets, expressive controls)
+*   **Streaming voice pipelines** (servers, bots, live processing)
+*   **DAW / toolchain integration** (deterministic pitch targets, consistent render behavior)
+*   **Web Audio demos** (AudioWorklet-ready architecture)
+
+## Quickstart
+
+```bash
+npm i
+npm run build
+npm test
+```
+
+## Core capabilities
+
+### Deterministic output
+Same input + config (and chunking policy) produces the same output, with regression protection via hash-based tests.
+
+### Streaming-first runtime
+Stateful, causal processing designed for low latency. No retroactive edits. Snapshot/restore supported for persistence and resumability.
+
+### Expressive prosody controls
+Event-driven accents and boundary tones let you shape cadence and intonation intentionally—without destabilizing pitch targets.
+
+### Meaning tests (semantic guardrails)
+The test suite enforces communicative behavior, including:
+*   **accent locality** (no “smear”)
+*   **question vs statement boundaries** (rise vs fall)
+*   **post-focus compression** (focus has consequences)
+*   **deterministic event ordering**
+*   **style monotonicity** (expressive > neutral > flat without increasing instability)
+
+## Documentation
+
+Primary docs live in [packages/voice-engine-dsp/docs/](packages/voice-engine-dsp/docs/).
+
+### Key documents
+
+*   [Streaming Architecture](packages/voice-engine-dsp/docs/STREAMING_ARCHITECTURE.md)
+*   [Meaning Contract](packages/voice-engine-dsp/docs/MEANING_CONTRACT.md)
+*   [Debugging Guide](packages/voice-engine-dsp/docs/DEBUGGING.md)
+*   [Reference Handbook](Reference_Handbook.md)
+
+### Repository structure
+
+`packages/voice-engine-dsp/` — core DSP + streaming prosody engine, tests, and benchmarks
+
+## Running the test suites
+
+```bash
+npm test
+```
+
+Or run specific suites:
+
+```bash
+npm run test:meaning
+npm run test:determinism
+npm run bench:rtf
+npm run smoke
+```

package/dist/src/adapters/AudioWorkletProcessor.d.ts

@@ -0,0 +1,31 @@
+/**
+ * AutotuneProcessor
+ *
+ * This class implements the processing logic for an AudioWorkletProcessor.
+ * It does not extend AudioWorkletProcessor directly to avoid issues in non-browser environments (like Node.js tests),
+ * but it matches the interface required by the Web Audio API.
+ *
+ * Usage in a real AudioWorklet:
+ * 1. Bundle this file and its dependencies (e.g. using Vite, Webpack, or Rollup).
+ * 2. In your worklet entry file:
+ *
+ *    import { AutotuneProcessor } from './AutotuneProcessor';
+ *
+ *    class RealAutotuneProcessor extends AudioWorkletProcessor {
+ *        constructor(options) {
+ *            super();
+ *            this.impl = new AutotuneProcessor(options, this.port);
+ *        }
+ *        process(inputs, outputs, parameters) {
+ *            return this.impl.process(inputs, outputs, parameters);
+ *        }
+ *    }
+ *    registerProcessor('autotune-processor', RealAutotuneProcessor);
+ */
+export declare class AutotuneProcessor {
+    private engine;
+    private port;
+    constructor(options: any, port?: MessagePort);
+    process(inputs: Float32Array[][], outputs: Float32Array[][], parameters: Record<string, Float32Array>): boolean;
+}
+//# sourceMappingURL=AudioWorkletProcessor.d.ts.map

package/dist/src/adapters/AudioWorkletProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioWorkletProcessor.d.ts","sourceRoot":"","sources":["../../../src/adapters/AudioWorkletProcessor.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,IAAI,CAAqB;gBAErB,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,WAAW;IAmB5C,OAAO,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,OAAO;CA+BlH"}

package/dist/src/adapters/AudioWorkletProcessor.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutotuneProcessor = void 0;
+const StreamingAutotuneEngine_1 = require("../tuning/StreamingAutotuneEngine");
+/**
+ * AutotuneProcessor
+ *
+ * This class implements the processing logic for an AudioWorkletProcessor.
+ * It does not extend AudioWorkletProcessor directly to avoid issues in non-browser environments (like Node.js tests),
+ * but it matches the interface required by the Web Audio API.
+ *
+ * Usage in a real AudioWorklet:
+ * 1. Bundle this file and its dependencies (e.g. using Vite, Webpack, or Rollup).
+ * 2. In your worklet entry file:
+ *
+ *    import { AutotuneProcessor } from './AutotuneProcessor';
+ *
+ *    class RealAutotuneProcessor extends AudioWorkletProcessor {
+ *        constructor(options) {
+ *            super();
+ *            this.impl = new AutotuneProcessor(options, this.port);
+ *        }
+ *        process(inputs, outputs, parameters) {
+ *            return this.impl.process(inputs, outputs, parameters);
+ *        }
+ *    }
+ *    registerProcessor('autotune-processor', RealAutotuneProcessor);
+ */
+class AutotuneProcessor {
+    engine;
+    port;
+    constructor(options, port) {
+        const config = options.processorOptions?.config || {};
+        const preset = options.processorOptions?.preset || {};
+        this.engine = new StreamingAutotuneEngine_1.StreamingAutotuneEngine(config, preset);
+        this.port = port || null;
+        if (this.port) {
+            this.port.onmessage = (event) => {
+                const { type, data } = event.data;
+                if (type === 'enqueueEvents') {
+                    this.engine.enqueueEvents(data);
+                }
+                else if (type === 'updateConfig') {
+                    // potentially update config
+                }
+            };
+        }
+    }
+    process(inputs, outputs, parameters) {
+        // inputs[inputIndex][channelIndex]
+        const input = inputs[0];
+        const output = outputs[0];
+        // If no input or empty implementation, return true to keep alive
+        if (!input || input.length === 0)
+            return true;
+        const inputChannel0 = input[0];
+        const outputChannel0 = output[0];
+        // Process Mono (Channel 0)
+        // Note: StreamingAutotuneEngine expects a Float32Array block.
+        // AudioWorklet usually provides 128 frames.
+        if (inputChannel0 && outputChannel0) {
+            // Check if input size matches block size or create sub-blocks?
+            // Usually AudioWorklet input is fixed size (128).
+            // StreamingAutotuneEngine handles any size block (it iterates internally).
+            const result = this.engine.process(inputChannel0);
+            outputChannel0.set(result.audio);
+            // Copy to other channels if output has more than one
+            for (let c = 1; c < output.length; c++) {
+                if (output[c]) {
+                    output[c].set(result.audio);
+                }
+            }
+        }
+        return true;
+    }
+}
+exports.AutotuneProcessor = AutotuneProcessor;

package/dist/src/adapters/NodeStreamAutotune.d.ts

@@ -0,0 +1,28 @@
+import { Transform, TransformCallback, TransformOptions } from 'stream';
+import { StreamingAutotuneEngine } from '../tuning/StreamingAutotuneEngine';
+export interface NodeStreamAutotuneOptions extends TransformOptions {
+    engine: StreamingAutotuneEngine;
+    blockSize?: number;
+}
+/**
+ * A Node.js Transform stream wrapper for StreamingAutotuneEngine.
+ * Handles buffering of incoming audio chunks to match the engine's required block size.
+ * Assumes input is Float32Array (object mode) or Buffer (raw float32 LE bytes).
+ */
+export declare class NodeStreamAutotune extends Transform {
+    private engine;
+    private blockSize;
+    private _buffer;
+    private _bufferedSamples;
+    constructor(options: NodeStreamAutotuneOptions);
+    /**
+     * Delegate method to enqueue control events to the engine.
+     * @param events Array of control events (notes, params, etc.)
+     */
+    enqueueEvents(events: any[]): void;
+    _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+    private _appendToBuffer;
+    private _processBufferedData;
+}
+//# sourceMappingURL=NodeStreamAutotune.d.ts.map

package/dist/src/adapters/NodeStreamAutotune.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeStreamAutotune.d.ts","sourceRoot":"","sources":["../../../src/adapters/NodeStreamAutotune.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AAE5E,MAAM,WAAW,yBAA0B,SAAQ,gBAAgB;IAC/D,MAAM,EAAE,uBAAuB,CAAC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,SAAS;IAC7C,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,gBAAgB,CAAS;gBAErB,OAAO,EAAE,yBAAyB;IAY9C;;;OAGG;IACI,aAAa,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI;IAIzC,UAAU,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,cAAc,EAAE,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAuBnF,MAAM,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAgBzC,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,oBAAoB;CA2B/B"}

package/dist/src/adapters/NodeStreamAutotune.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeStreamAutotune = void 0;
+const stream_1 = require("stream");
+/**
+ * A Node.js Transform stream wrapper for StreamingAutotuneEngine.
+ * Handles buffering of incoming audio chunks to match the engine's required block size.
+ * Assumes input is Float32Array (object mode) or Buffer (raw float32 LE bytes).
+ */
+class NodeStreamAutotune extends stream_1.Transform {
+    engine;
+    blockSize;
+    _buffer;
+    _bufferedSamples;
+    constructor(options) {
+        // Enforce objectMode if not specified, as we want to output Float32Array by default
+        // or Buffer if the downstream expects it.
+        // For now, let's stick to standard Buffer input/output if not in objectMode.
+        super(options);
+        this.engine = options.engine;
+        this.blockSize = options.blockSize || 128; // Default block size
+        this._buffer = new Float32Array(this.blockSize * 2); // Start with double capacity
+        this._bufferedSamples = 0;
+    }
+    /**
+     * Delegate method to enqueue control events to the engine.
+     * @param events Array of control events (notes, params, etc.)
+     */
+    enqueueEvents(events) {
+        this.engine.enqueueEvents(events);
+    }
+    _transform(chunk, encoding, callback) {
+        let inputFloats;
+        // 1. Convert chunk to Float32Array
+        if (Buffer.isBuffer(chunk)) {
+            // Assume raw float32 LE bytes
+            const numSamples = chunk.length / 4;
+            inputFloats = new Float32Array(chunk.buffer, chunk.byteOffset, numSamples);
+        }
+        else if (chunk instanceof Float32Array) {
+            inputFloats = chunk;
+        }
+        else {
+            return callback(new Error('NodeStreamAutotune expects Buffer or Float32Array chunks.'));
+        }
+        // 2. Append to internal buffer
+        this._appendToBuffer(inputFloats);
+        // 3. Process as many blocks as possible
+        this._processBufferedData();
+        callback();
+    }
+    _flush(callback) {
+        // Build remaining samples
+        // If there are leftover samples, we could pad with zeros or just process them?
+        // The engine might expect full blocks (128).
+        // Let's pad with silence to complete the last block if necessary.
+        if (this._bufferedSamples > 0) {
+            const needed = this.blockSize - this._bufferedSamples;
+            if (needed > 0) {
+                const padding = new Float32Array(needed).fill(0);
+                this._appendToBuffer(padding);
+            }
+            this._processBufferedData();
+        }
+        callback();
+    }
+    _appendToBuffer(newData) {
+        const requiredCapacity = this._bufferedSamples + newData.length;
+        if (requiredCapacity > this._buffer.length) {
+            // Resize buffer
+            const newCapacity = Math.max(requiredCapacity, this._buffer.length * 2);
+            const newBuffer = new Float32Array(newCapacity);
+            newBuffer.set(this._buffer.subarray(0, this._bufferedSamples));
+            this._buffer = newBuffer;
+        }
+        this._buffer.set(newData, this._bufferedSamples);
+        this._bufferedSamples += newData.length;
+    }
+    _processBufferedData() {
+        let offset = 0;
+        while (this._bufferedSamples >= this.blockSize) {
+            // Extract one block
+            const block = this._buffer.subarray(offset, offset + this.blockSize);
+            // Process (engine expects Float32Array of size blockSize usually)
+            const result = this.engine.process(block);
+            // Output
+            if (this.writableObjectMode || this.readableObjectMode) {
+                this.push(result.audio); // Push Float32Array directly
+            }
+            else {
+                // Convert back to Buffer (raw bytes)
+                this.push(Buffer.from(result.audio.buffer, result.audio.byteOffset, result.audio.byteLength));
+            }
+            offset += this.blockSize;
+            this._bufferedSamples -= this.blockSize;
+        }
+        // Shift remaining data to start of buffer
+        if (this._bufferedSamples > 0 && offset > 0) {
+            this._buffer.copyWithin(0, offset, offset + this._bufferedSamples);
+        }
+    }
+}
+exports.NodeStreamAutotune = NodeStreamAutotune;

package/dist/src/analysis/PitchTrackerRefV1.d.ts

@@ -0,0 +1,13 @@
+import { AudioBufferV1, F0TrackV1 } from "@mcptoolshop/voice-engine-core";
+export interface PitchTrackerConfig {
+    windowMs: number;
+    hopMs: number;
+    f0Min: number;
+    f0Max: number;
+}
+export declare class PitchTrackerRefV1 {
+    private config;
+    constructor(config: PitchTrackerConfig);
+    analyze(buffer: AudioBufferV1): F0TrackV1;
+}
+//# sourceMappingURL=PitchTrackerRefV1.d.ts.map

package/dist/src/analysis/PitchTrackerRefV1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PitchTrackerRefV1.d.ts","sourceRoot":"","sources":["../../../src/analysis/PitchTrackerRefV1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAG1E,MAAM,WAAW,kBAAkB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,iBAAiB;IACd,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,kBAAkB;IAEvC,OAAO,CAAC,MAAM,EAAE,aAAa,GAAG,SAAS;CA2InD"}

package/dist/src/analysis/PitchTrackerRefV1.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PitchTrackerRefV1 = void 0;
+const AudioBufferUtils_1 = require("../utils/AudioBufferUtils");
+class PitchTrackerRefV1 {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    analyze(buffer) {
+        const audio = (0, AudioBufferUtils_1.monoDownmix)(buffer);
+        const sr = buffer.sampleRate;
+        const windowSamples = Math.floor(this.config.windowMs * sr / 1000);
+        const hopSamples = Math.floor(this.config.hopMs * sr / 1000);
+        // Ensure lags are within search range
+        const minLag = Math.floor(sr / this.config.f0Max);
+        const maxLag = Math.floor(sr / this.config.f0Min);
+        // Calculate number of frames
+        // We need audio up to start + windowSamples + maxLag
+        // Last frame i: i * hopSamples + windowSamples + maxLag <= audio.length
+        // i * hopSamples <= audio.length - windowSamples - maxLag
+        let numFrames = 0;
+        if (audio.length >= windowSamples + maxLag) {
+            numFrames = Math.floor((audio.length - windowSamples - maxLag) / hopSamples) + 1;
+        }
+        const f0MhzQ = new Int32Array(numFrames);
+        const confQ = new Int16Array(numFrames);
+        const t0Samples = 0;
+        if (numFrames <= 0) {
+            return {
+                sampleRateHz: sr,
+                frameHz: sr / hopSamples,
+                hopSamples,
+                t0Samples,
+                f0MhzQ,
+                confQ
+            };
+        }
+        const difference = new Float32Array(maxLag + 2);
+        const cmndf = new Float32Array(maxLag + 2);
+        for (let i = 0; i < numFrames; i++) {
+            const start = i * hopSamples;
+            // 1. Difference function
+            // d(tau) = sum_{j=0}^{W-1} (x[start+j] - x[start+j+tau])^2
+            for (let tau = 1; tau <= maxLag; tau++) {
+                let sum = 0;
+                for (let j = 0; j < windowSamples; j++) {
+                    const delta = audio[start + j] - audio[start + j + tau];
+                    sum += delta * delta;
+                }
+                difference[tau] = sum;
+            }
+            difference[0] = 0;
+            // 2. CMNDF
+            cmndf[0] = 1;
+            let runningSum = 0;
+            for (let tau = 1; tau <= maxLag; tau++) {
+                runningSum += difference[tau];
+                if (runningSum === 0) {
+                    cmndf[tau] = 1;
+                }
+                else {
+                    cmndf[tau] = difference[tau] * tau / runningSum;
+                }
+            }
+            // 3. Absolute Threshold
+            let bestTau = -1;
+            const threshold = 0.1;
+            let found = false;
+            // Only search in valid pitch range
+            for (let tau = minLag; tau <= maxLag; tau++) {
+                if (cmndf[tau] < threshold) {
+                    // Start of a dip. Find local minimum in this dip.
+                    let localTau = tau;
+                    while (localTau + 1 <= maxLag && cmndf[localTau + 1] < cmndf[localTau]) {
+                        localTau++;
+                    }
+                    bestTau = localTau;
+                    found = true;
+                    break;
+                }
+            }
+            // If not found, use global minimum in range
+            if (!found) {
+                let minVal = Number.MAX_VALUE;
+                for (let tau = minLag; tau <= maxLag; tau++) {
+                    if (cmndf[tau] < minVal) {
+                        minVal = cmndf[tau];
+                        bestTau = tau;
+                    }
+                }
+            }
+            // 4. Parabolic Interpolation
+            let refinedTau = bestTau;
+            let currentF0 = 0;
+            let confidence = 0;
+            if (bestTau >= minLag && bestTau <= maxLag) {
+                // Ensure we have neighbors
+                if (bestTau > 0 && bestTau < maxLag + 1) { // bounds check within cmndf array size
+                    // Note: cmndf size is maxLag + 2, valid indices 0..maxLag+1.
+                    // bestTau is in [minLag, maxLag]. so bestTau >= 1.
+                    const y1 = cmndf[bestTau - 1];
+                    const y2 = cmndf[bestTau];
+                    const y3 = cmndf[bestTau + 1];
+                    // Peak fitting (minimum)
+                    const denom = (y1 - 2 * y2 + y3);
+                    if (Math.abs(denom) > 1e-9) { // Avoid division by zero
+                        const delta = (y1 - y3) / (2 * denom);
+                        refinedTau = bestTau - delta;
+                    }
+                }
+                if (refinedTau > 0) {
+                    currentF0 = sr / refinedTau;
+                }
+                // Confidence: 1 - min_cmndf
+                let minCmndf = cmndf[bestTau];
+                if (minCmndf > 1)
+                    minCmndf = 1;
+                if (minCmndf < 0)
+                    minCmndf = 0;
+                confidence = 1.0 - minCmndf;
+            }
+            f0MhzQ[i] = Math.round(currentF0 * 1000);
+            confQ[i] = Math.round(confidence * 10000);
+        }
+        return {
+            sampleRateHz: sr,
+            frameHz: sr / hopSamples,
+            hopSamples: hopSamples,
+            t0Samples: 0,
+            f0MhzQ,
+            confQ
+        };
+    }
+}
+exports.PitchTrackerRefV1 = PitchTrackerRefV1;

package/dist/src/analysis/VoicingDetectorRefV1.d.ts

@@ -0,0 +1,13 @@
+import { AudioBufferV1, VoicingMaskV1, F0TrackV1 } from "@mcptoolshop/voice-engine-core";
+export interface VoicingConfig {
+    silenceThreshold: number;
+    voicingThreshold: number;
+    windowMs: number;
+}
+export declare class VoicingDetectorRefV1 {
+    private config;
+    constructor(config: VoicingConfig);
+    analyze(buffer: AudioBufferV1, f0Track: F0TrackV1): VoicingMaskV1;
+    private hangoverSmoothing;
+}
+//# sourceMappingURL=VoicingDetectorRefV1.d.ts.map

package/dist/src/analysis/VoicingDetectorRefV1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VoicingDetectorRefV1.d.ts","sourceRoot":"","sources":["../../../src/analysis/VoicingDetectorRefV1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,SAAS,EAAoB,MAAM,gCAAgC,CAAC;AAG3G,MAAM,WAAW,aAAa;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,oBAAoB;IACjB,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAElC,OAAO,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,SAAS,GAAG,aAAa;IAiExE,OAAO,CAAC,iBAAiB;CAe5B"}

package/dist/src/analysis/VoicingDetectorRefV1.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoicingDetectorRefV1 = void 0;
+const AudioBufferUtils_1 = require("../utils/AudioBufferUtils");
+class VoicingDetectorRefV1 {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    analyze(buffer, f0Track) {
+        const audio = (0, AudioBufferUtils_1.monoDownmix)(buffer);
+        const numFrames = f0Track.f0MhzQ.length;
+        const hopSamples = f0Track.hopSamples;
+        const windowSamples = Math.floor(this.config.windowMs * buffer.sampleRate / 1000);
+        const voicedQ = new Uint8Array(numFrames);
+        const voicingProbQ = new Int16Array(numFrames);
+        const zcrThreshold = 0.4;
+        const zcrThreshQ = zcrThreshold * 10000;
+        const silenceThreshQ = this.config.silenceThreshold * 10000;
+        const voicingThreshQ = this.config.voicingThreshold * 10000;
+        for (let i = 0; i < numFrames; i++) {
+            const start = i * hopSamples;
+            if (start + windowSamples > audio.length) {
+                break;
+            }
+            let zeroCrossings = 0;
+            let sumSq = 0;
+            for (let j = 0; j < windowSamples; j++) {
+                const samp = audio[start + j];
+                sumSq += samp * samp;
+                if (j > 0) {
+                    const prev = audio[start + j - 1];
+                    if ((prev >= 0 && samp < 0) || (prev < 0 && samp >= 0)) {
+                        zeroCrossings++;
+                    }
+                }
+            }
+            const rms = Math.sqrt(sumSq / windowSamples);
+            const zcr = zeroCrossings / windowSamples;
+            const rmsQ = Math.min(10000, Math.round(rms * 10000));
+            const zcrQ = Math.min(10000, Math.round(zcr * 10000));
+            const confQ = f0Track.confQ[i];
+            let isVoiced = 0;
+            if (rmsQ > silenceThreshQ && confQ > voicingThreshQ && zcrQ < zcrThreshQ) {
+                isVoiced = 1;
+            }
+            voicedQ[i] = isVoiced;
+            voicingProbQ[i] = confQ;
+        }
+        // Apply smoothing
+        this.hangoverSmoothing(voicedQ, 2);
+        return {
+            sampleRateHz: f0Track.sampleRateHz,
+            frameHz: f0Track.frameHz,
+            hopSamples: f0Track.hopSamples,
+            t0Samples: f0Track.t0Samples,
+            voicedQ,
+            voicingProbQ
+        };
+    }
+    hangoverSmoothing(mask, frames) {
+        const len = mask.length;
+        let hangoverCounter = 0;
+        for (let i = 0; i < len; i++) {
+            if (mask[i] === 1) {
+                hangoverCounter = frames;
+            }
+            else {
+                if (hangoverCounter > 0) {
+                    mask[i] = 1;
+                    hangoverCounter--;
+                }
+            }
+        }
+    }
+}
+exports.VoicingDetectorRefV1 = VoicingDetectorRefV1;

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from './tuning/StreamingAutotuneEngine';
+export * from './version';
+export { ProsodyRuntimeStateV1 } from '../../voice-engine-core/src/prosody/StreamingProsodyTypes';
+export * from './adapters/NodeStreamAutotune';
+export * from './adapters/AudioWorkletProcessor';
+export * from './prosody/SafetyRails';
+export * from './prosody/Presets';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,WAAW,CAAC;AAE1B,OAAO,EAAE,qBAAqB,EAAE,MAAM,2DAA2D,CAAC;AAClG,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./tuning/StreamingAutotuneEngine"), exports);
+__exportStar(require("./version"), exports);
+__exportStar(require("./adapters/NodeStreamAutotune"), exports);
+__exportStar(require("./adapters/AudioWorkletProcessor"), exports);
+__exportStar(require("./prosody/SafetyRails"), exports);
+__exportStar(require("./prosody/Presets"), exports);

package/dist/src/prosody/AccentRenderer.d.ts

@@ -0,0 +1,15 @@
+import { ProsodyEventV1, ProsodyStyleV1 } from "../../../voice-engine-core/src/prosody/ProsodyV1.js";
+export declare class AccentRenderer {
+    /**
+     * Renders prosodic accents into a per-frame control curve.
+     * Uses a raised cosine window for smooth parameter modulation.
+     *
+     * @param events List of prosody events to render
+     * @param totalFrames Total number of frames in the output buffer
+     * @param style Prosody style configuration
+     * @param frameRateHz Frame rate for time conversions (default 100)
+     * @returns Float32Array of rendered values (additive relative cents)
+     */
+    static render(events: ProsodyEventV1[], totalFrames: number, style: ProsodyStyleV1, frameRateHz?: number): Float32Array;
+}
+//# sourceMappingURL=AccentRenderer.d.ts.map

package/dist/src/prosody/AccentRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccentRenderer.d.ts","sourceRoot":"","sources":["../../../src/prosody/AccentRenderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,qDAAqD,CAAC;AAErG,qBAAa,cAAc;IACvB;;;;;;;;;OASG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,WAAW,GAAE,MAAY,GAAG,YAAY;CA6D/H"}