Text-to-Speech

import { loadModel, textToSpeech, unloadModel, TTS_T3_TURBO_EN_CHATTERBOX_Q8_0, TTS_S3GEN_EN_CHATTERBOX } from '@qvac/sdk';
import { createWav, playAudio, int16ArrayToBuffer, createWavHeader } from './utils';
// Chatterbox TTS (GGML): voice cloning with optional reference audio.
// Uses registry model constants — downloads automatically from QVAC Registry.
// Usage: node chatterbox.ts [referenceAudioSrc]
const [referenceAudioSrc] = process.argv.slice(2);
const CHATTERBOX_SAMPLE_RATE = 24000;
try {
    const modelId = await loadModel({
        modelSrc: TTS_T3_TURBO_EN_CHATTERBOX_Q8_0,
        modelConfig: {
            ttsEngine: 'chatterbox',
            language: 'en',
            s3genModelSrc: TTS_S3GEN_EN_CHATTERBOX.src,
            streamChunkTokens: 25,
            streamFirstChunkTokens: 10,
            cfmSteps: 1,
            threads: 8,
            ...(referenceAudioSrc ? { referenceAudioSrc } : {})
        },
        onProgress: (p) => {
            const mb = (n) => (n / 1e6).toFixed(1);
            const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
            process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
            if (p.percentage >= 100)
                process.stderr.write('\n');
        }
    });
    console.log(`▸ Model loaded: ${modelId}`);
    console.log('▸ Testing Text-to-Speech...');
    const result = textToSpeech({
        modelId,
        text: `QVAC SDK is the canonical entry point to QVAC. Written in TypeScript, it provides all QVAC capabilities through a unified interface while also abstracting away the complexity of running your application in a JS environment other than Bare. Supported JS environments include Bare, Node.js, Expo and Bun.`,
        inputType: 'text',
        stream: false
    });
    const audioBuffer = await result.buffer;
    console.log(`▸ TTS complete. Total bytes: ${audioBuffer.length}`);
    console.log('▸ Saving audio to file...');
    createWav(audioBuffer, CHATTERBOX_SAMPLE_RATE, 'tts-output.wav');
    console.log('▸ Audio saved to tts-output.wav');
    console.log('▸ Playing audio...');
    const audioData = int16ArrayToBuffer(audioBuffer);
    const wavBuffer = Buffer.concat([
        createWavHeader(audioData.length, CHATTERBOX_SAMPLE_RATE),
        audioData
    ]);
    playAudio(wavBuffer);
    console.log('▸ Audio playback complete');
    await unloadModel({ modelId });
    console.log('▸ Model unloaded');
    process.exit(0);
}
catch (error) {
    console.error('✖', error);
    process.exit(1);
}

import { loadModel, textToSpeech, unloadModel, TTS_MULTILINGUAL_SUPERTONIC3_Q8_0 } from '@qvac/sdk';
import { createWav, playAudio, int16ArrayToBuffer, createWavHeader } from './utils';
// Supertonic 3 TTS (GGML): fast multilingual synthesis with baked-in voices.
// Uses registry model constants — downloads automatically from QVAC Registry.
const SUPERTONIC_SAMPLE_RATE = 44100;
try {
    const modelId = await loadModel({
        modelSrc: TTS_MULTILINGUAL_SUPERTONIC3_Q8_0,
        modelConfig: {
            ttsEngine: 'supertonic',
            language: 'en',
            voice: 'F1',
            ttsSpeed: 1.05,
            ttsNumInferenceSteps: 5
        },
        onProgress: (p) => {
            const mb = (n) => (n / 1e6).toFixed(1);
            const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
            process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
            if (p.percentage >= 100)
                process.stderr.write('\n');
        }
    });
    console.log(`▸ Model loaded: ${modelId}`);
    console.log('▸ Testing Text-to-Speech...');
    const result = textToSpeech({
        modelId,
        text: `QVAC SDK is the canonical entry point to QVAC. Written in TypeScript, it provides all QVAC capabilities through a unified interface while also abstracting away the complexity of running your application in a JS environment other than Bare. Supported JS environments include Bare, Node.js, Expo and Bun.`,
        inputType: 'text',
        stream: false
    });
    const audioBuffer = await result.buffer;
    console.log(`▸ TTS complete. Total samples: ${audioBuffer.length}`);
    console.log('▸ Saving audio to file...');
    createWav(audioBuffer, SUPERTONIC_SAMPLE_RATE, 'supertonic-output.wav');
    console.log('▸ Audio saved to supertonic-output.wav');
    console.log('▸ Playing audio...');
    const audioData = int16ArrayToBuffer(audioBuffer);
    const wavBuffer = Buffer.concat([
        createWavHeader(audioData.length, SUPERTONIC_SAMPLE_RATE),
        audioData
    ]);
    playAudio(wavBuffer);
    console.log('▸ Audio playback complete');
    await unloadModel({ modelId });
    console.log('▸ Model unloaded');
    process.exit(0);
}
catch (error) {
    console.error('✖', error);
    process.exit(1);
}

import { loadModel, textToSpeech, unloadModel, TTS_MINI_V1_EN_PARLER_TTS_Q8_0 } from '@qvac/sdk';
import { createWav, playAudio, int16ArrayToBuffer, createWavHeader } from './utils';
// Parler-TTS (GGML): description-conditioned speech with per-call voice controls.
// Uses the registry-hosted Mini v1 Q8_0 model and its native 44.1 kHz output.
const PARLER_SAMPLE_RATE = 44100;
try {
    const modelId = await loadModel({
        modelSrc: TTS_MINI_V1_EN_PARLER_TTS_Q8_0,
        modelConfig: {
            ttsEngine: 'parler',
            voice: 'Laura',
            seed: 42
        },
        onProgress: (p) => {
            const mb = (n) => (n / 1e6).toFixed(1);
            const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
            process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
            if (p.percentage >= 100)
                process.stderr.write('\n');
        }
    });
    console.log(`▸ Model loaded: ${modelId}`);
    console.log('▸ Testing Parler Text-to-Speech...');
    const result = textToSpeech({
        modelId,
        text: 'Hey, how are you doing today?',
        inputType: 'text',
        stream: false,
        emotion: 'happy'
    });
    const audioBuffer = await result.buffer;
    console.log(`▸ TTS complete. Total samples: ${audioBuffer.length}`);
    console.log('▸ Saving audio to file...');
    createWav(audioBuffer, PARLER_SAMPLE_RATE, 'parler-output.wav');
    console.log('▸ Audio saved to parler-output.wav');
    console.log('▸ Playing audio...');
    const audioData = int16ArrayToBuffer(audioBuffer);
    const wavBuffer = Buffer.concat([
        createWavHeader(audioData.length, PARLER_SAMPLE_RATE),
        audioData
    ]);
    playAudio(wavBuffer);
    console.log('▸ Audio playback complete');
    await unloadModel({ modelId });
    console.log('▸ Model unloaded');
    process.exit(0);
}
catch (error) {
    console.error('✖', error);
    process.exit(1);
}

import { loadModel, textToSpeech, unloadModel, TTS_COSYVOICE3_LLM_COSYVOICE_Q8_0 } from '@qvac/sdk';
import { createWav, playAudio, int16ArrayToBuffer, createWavHeader } from './utils';
// CosyVoice3 (GGML): zero-shot speech with one conditioning control per
// synthesis (emotion, pace, or instruct). The LLM GGUF's registry companion
// set downloads the flow/HiFT models, baked voice and tokenizer alongside it.
// Native output is 24 kHz.
const COSYVOICE3_SAMPLE_RATE = 24000;
try {
    const modelId = await loadModel({
        modelSrc: TTS_COSYVOICE3_LLM_COSYVOICE_Q8_0,
        modelConfig: {
            ttsEngine: 'cosyvoice3',
            seed: 42
        },
        onProgress: (p) => {
            const mb = (n) => (n / 1e6).toFixed(1);
            const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
            process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
            if (p.percentage >= 100)
                process.stderr.write('\n');
        }
    });
    console.log(`▸ Model loaded: ${modelId}`);
    console.log('▸ Testing CosyVoice3 Text-to-Speech...');
    const result = textToSpeech({
        modelId,
        text: 'Hey, how are you doing today?',
        inputType: 'text',
        stream: false,
        emotion: 'happy'
    });
    const audioBuffer = await result.buffer;
    console.log(`▸ TTS complete. Total samples: ${audioBuffer.length}`);
    console.log('▸ Saving audio to file...');
    createWav(audioBuffer, COSYVOICE3_SAMPLE_RATE, 'cosyvoice3-output.wav');
    console.log('▸ Audio saved to cosyvoice3-output.wav');
    console.log('▸ Playing audio...');
    const audioData = int16ArrayToBuffer(audioBuffer);
    const wavBuffer = Buffer.concat([
        createWavHeader(audioData.length, COSYVOICE3_SAMPLE_RATE),
        audioData
    ]);
    playAudio(wavBuffer);
    console.log('▸ Audio playback complete');
    await unloadModel({ modelId });
    console.log('▸ Model unloaded');
    process.exit(0);
}
catch (error) {
    console.error('✖', error);
    process.exit(1);
}

import { loadModel, textToSpeech, unloadModel, TTS_LM_MULTILINGUAL_AUDIO8_Q8_0, TTS_CODEC_DECODER_AUDIO8_Q8_0 } from '@qvac/sdk';
import { createWav, playAudio, int16ArrayToBuffer, createWavHeader } from './utils';
// Audio8 (GGML): DualAR LM + codec decoder, native 44.1 kHz output. The
// primary modelSrc is the LM GGUF; the codec decoder loads via modelConfig.
// For zero-shot voice cloning also pass audio8CodecEncoderModelSrc plus
// referenceAudioSrc/referenceText (a recording and its exact transcript).
const AUDIO8_SAMPLE_RATE = 44100;
try {
    const modelId = await loadModel({
        modelSrc: TTS_LM_MULTILINGUAL_AUDIO8_Q8_0,
        modelConfig: {
            ttsEngine: 'audio8',
            audio8CodecDecoderModelSrc: TTS_CODEC_DECODER_AUDIO8_Q8_0,
            temperature: 0.7,
            topP: 0.9,
            seed: 42
        },
        onProgress: (p) => {
            const mb = (n) => (n / 1e6).toFixed(1);
            const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
            process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
            if (p.percentage >= 100)
                process.stderr.write('\n');
        }
    });
    console.log(`▸ Model loaded: ${modelId}`);
    console.log('▸ Testing Audio8 Text-to-Speech...');
    const result = textToSpeech({
        modelId,
        text: 'Hey, how are you doing today?',
        inputType: 'text',
        stream: false
    });
    const audioBuffer = await result.buffer;
    console.log(`▸ TTS complete. Total samples: ${audioBuffer.length}`);
    console.log('▸ Saving audio to file...');
    createWav(audioBuffer, AUDIO8_SAMPLE_RATE, 'audio8-output.wav');
    console.log('▸ Audio saved to audio8-output.wav');
    console.log('▸ Playing audio...');
    const audioData = int16ArrayToBuffer(audioBuffer);
    const wavBuffer = Buffer.concat([
        createWavHeader(audioData.length, AUDIO8_SAMPLE_RATE),
        audioData
    ]);
    playAudio(wavBuffer);
    console.log('▸ Audio playback complete');
    await unloadModel({ modelId });
    console.log('▸ Model unloaded');
    process.exit(0);
}
catch (error) {
    console.error('✖', error);
    process.exit(1);
}

import { loadModel, textToSpeech, unloadModel, TTS_T3_TURBO_EN_CHATTERBOX_Q8_0, TTS_S3GEN_EN_CHATTERBOX, TTS_ENHANCER_LAVASR_FP16 } from '@qvac/sdk';
import { createWav, playAudio, int16ArrayToBuffer, createWavHeader } from './utils';
// Chatterbox TTS (GGML) with the LavaSR enhancer: synthesized audio is neurally
// bandwidth-extended to 48 kHz. Supplying the enhancer GGUF is what enables
// enhancement — there is no on/off flag — and it forces the output to 48 kHz.
// Usage: node chatterbox-enhanced.ts [referenceAudioSrc]
const [referenceAudioSrc] = process.argv.slice(2);
const ENHANCED_SAMPLE_RATE = 48000;
try {
    const modelId = await loadModel({
        modelSrc: TTS_T3_TURBO_EN_CHATTERBOX_Q8_0,
        modelConfig: {
            ttsEngine: 'chatterbox',
            language: 'en',
            s3genModelSrc: TTS_S3GEN_EN_CHATTERBOX.src,
            lavasrEnhancerModelSrc: TTS_ENHANCER_LAVASR_FP16.src,
            ...(referenceAudioSrc ? { referenceAudioSrc } : {})
        },
        onProgress: (p) => {
            const mb = (n) => (n / 1e6).toFixed(1);
            const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
            process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
            if (p.percentage >= 100)
                process.stderr.write('\n');
        }
    });
    console.log(`▸ Model loaded: ${modelId}`);
    console.log('▸ Testing Text-to-Speech (LavaSR enhancer)...');
    const result = textToSpeech({
        modelId,
        text: `QVAC SDK is the canonical entry point to QVAC. Written in TypeScript, it provides all QVAC capabilities through a unified interface while also abstracting away the complexity of running your application in a JS environment other than Bare. Supported JS environments include Bare, Node.js, Expo and Bun.`,
        inputType: 'text',
        stream: false
    });
    const audioBuffer = await result.buffer;
    console.log(`▸ TTS complete. Total samples: ${audioBuffer.length}`);
    console.log('▸ Saving audio to file...');
    createWav(audioBuffer, ENHANCED_SAMPLE_RATE, 'chatterbox-enhanced-output.wav');
    console.log('▸ Audio saved to chatterbox-enhanced-output.wav');
    console.log('▸ Playing audio...');
    const audioData = int16ArrayToBuffer(audioBuffer);
    const wavBuffer = Buffer.concat([
        createWavHeader(audioData.length, ENHANCED_SAMPLE_RATE),
        audioData
    ]);
    playAudio(wavBuffer);
    console.log('▸ Audio playback complete');
    await unloadModel({ modelId });
    console.log('▸ Model unloaded');
    process.exit(0);
}
catch (error) {
    console.error('✖', error);
    process.exit(1);
}

import { loadModel, textToSpeech, unloadModel, TTS_MULTILINGUAL_SUPERTONIC3_Q8_0, TTS_DENOISER_LAVASR_FP16, TTS_ENHANCER_LAVASR_FP16 } from '@qvac/sdk';
import { createWav, playAudio, int16ArrayToBuffer, createWavHeader } from './utils';
// Supertonic 3 TTS (GGML) with LavaSR post-processing: the denoiser cleans the
// synthesized signal first, then the enhancer bandwidth-extends it to 48 kHz.
// Supplying the enhancer GGUF is what enables enhancement — there is no on/off
// flag — and it forces the output to 48 kHz regardless of the engine's native
// rate.
const ENHANCED_SAMPLE_RATE = 48000;
try {
    const modelId = await loadModel({
        modelSrc: TTS_MULTILINGUAL_SUPERTONIC3_Q8_0,
        modelConfig: {
            ttsEngine: 'supertonic',
            language: 'en',
            voice: 'F1',
            // Denoiser runs first (rate-preserving)…
            lavasrDenoiserModelSrc: TTS_DENOISER_LAVASR_FP16.src,
            // …then the enhancer bandwidth-extends to 48 kHz.
            lavasrEnhancerModelSrc: TTS_ENHANCER_LAVASR_FP16.src
        },
        onProgress: (p) => {
            const mb = (n) => (n / 1e6).toFixed(1);
            const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
            process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
            if (p.percentage >= 100)
                process.stderr.write('\n');
        }
    });
    console.log(`▸ Model loaded: ${modelId}`);
    console.log('▸ Testing Text-to-Speech (LavaSR denoiser + enhancer)...');
    const result = textToSpeech({
        modelId,
        text: `QVAC SDK is the canonical entry point to QVAC. Written in TypeScript, it provides all QVAC capabilities through a unified interface while also abstracting away the complexity of running your application in a JS environment other than Bare. Supported JS environments include Bare, Node.js, Expo and Bun.`,
        inputType: 'text',
        stream: false
    });
    const audioBuffer = await result.buffer;
    console.log(`▸ TTS complete. Total samples: ${audioBuffer.length}`);
    console.log('▸ Saving audio to file...');
    createWav(audioBuffer, ENHANCED_SAMPLE_RATE, 'supertonic-enhanced-output.wav');
    console.log('▸ Audio saved to supertonic-enhanced-output.wav');
    console.log('▸ Playing audio...');
    const audioData = int16ArrayToBuffer(audioBuffer);
    const wavBuffer = Buffer.concat([
        createWavHeader(audioData.length, ENHANCED_SAMPLE_RATE),
        audioData
    ]);
    playAudio(wavBuffer);
    console.log('▸ Audio playback complete');
    await unloadModel({ modelId });
    console.log('▸ Model unloaded');
    process.exit(0);
}
catch (error) {
    console.error('✖', error);
    process.exit(1);
}

import { writeFileSync, unlinkSync } from 'fs';
import { spawn, spawnSync } from 'child_process';
import { platform, tmpdir } from 'os';
import { join } from 'path';
/**
 * Create WAV header for 16-bit PCM audio
 */
export function createWavHeader(dataLength, sampleRate) {
    const header = Buffer.alloc(44);
    // RIFF header
    header.write('RIFF', 0);
    header.writeUInt32LE(36 + dataLength, 4);
    header.write('WAVE', 8);
    // fmt chunk
    header.write('fmt ', 12);
    header.writeUInt32LE(16, 16); // fmt chunk size
    header.writeUInt16LE(1, 20); // PCM format
    header.writeUInt16LE(1, 22); // mono
    header.writeUInt32LE(sampleRate, 24);
    header.writeUInt32LE(sampleRate * 2, 28); // byte rate
    header.writeUInt16LE(2, 32); // block align
    header.writeUInt16LE(16, 34); // bits per sample
    // data chunk
    header.write('data', 36);
    header.writeUInt32LE(dataLength, 40);
    return header;
}
/**
 * Convert Int16Array to Buffer
 */
export function int16ArrayToBuffer(samples) {
    const buffer = Buffer.alloc(samples.length * 2);
    for (let i = 0; i < samples.length; i++) {
        const value = Math.max(-32768, Math.min(32767, Math.round(samples[i] ?? 0)));
        buffer.writeInt16LE(value, i * 2);
    }
    return buffer;
}
/**
 * Create and save WAV file
 */
export function createWav(audioBuffer, sampleRate, filename) {
    const audioData = int16ArrayToBuffer(audioBuffer);
    const wavHeader = createWavHeader(audioData.length, sampleRate);
    const wavFile = Buffer.concat([wavHeader, audioData]);
    writeFileSync(filename, wavFile);
    console.log(`▸ WAV file saved as: ${filename}`);
}
/**
 * Play a WAV buffer by streaming it into ffplay over stdin.
 *
 * ffplay ships with ffmpeg and is cross-platform (macOS/Linux/Windows), so
 * we avoid the old "write to /tmp then shell out to afplay/aplay/powershell"
 * dance — no temp files, no platform switch, no hardcoded /tmp path (which
 * doesn't exist on Windows). Requires ffplay on PATH.
 */
/**
 * Play one mono s16le PCM chunk (as a minimal WAV) and wait for the player to finish.
 * Chunks are played sequentially when awaited in order — suitable for streaming TTS output.
 */
export function playPcmInt16Chunk(samples, sampleRate) {
    if (samples.length === 0) {
        return Promise.resolve();
    }
    const audioData = int16ArrayToBuffer(samples);
    const wavHeader = createWavHeader(audioData.length, sampleRate);
    const wavFile = Buffer.concat([wavHeader, audioData]);
    // `os.tmpdir()` resolves to the OS-specific temp directory (e.g. `%TEMP%`
    // on Windows), so the Windows branch below no longer tries to read a
    // POSIX-only `/tmp/...` path.
    const tempFile = join(tmpdir(), `qvac-tts-chunk-${Date.now()}-${Math.random().toString(16).slice(2)}.wav`);
    writeFileSync(tempFile, wavFile);
    const currentPlatform = platform();
    let audioPlayer;
    let args;
    switch (currentPlatform) {
        case 'darwin':
            audioPlayer = 'afplay';
            args = [tempFile];
            break;
        case 'linux':
            audioPlayer = 'aplay';
            args = [tempFile];
            break;
        case 'win32':
            audioPlayer = 'powershell';
            args = [
                '-Command',
                `Add-Type -AssemblyName presentationCore; (New-Object Media.SoundPlayer).LoadStream([System.IO.File]::ReadAllBytes('${tempFile}')).PlaySync()`
            ];
            break;
        default:
            audioPlayer = 'aplay';
            args = [tempFile];
    }
    return new Promise(function (resolve, reject) {
        const proc = spawn(audioPlayer, args, { stdio: 'ignore' });
        proc.on('error', function (err) {
            try {
                unlinkSync(tempFile);
            }
            catch {
                // ignore
            }
            reject(err);
        });
        proc.on('close', function (code) {
            try {
                unlinkSync(tempFile);
            }
            catch {
                // ignore
            }
            if (code === 0) {
                resolve();
            }
            else {
                reject(new Error(`Audio player exited with code ${code}`));
            }
        });
    });
}
export function playAudio(audioBuffer) {
    const result = spawnSync('ffplay', ['-hide_banner', '-loglevel', 'error', '-autoexit', '-nodisp', '-i', 'pipe:0'], {
        input: audioBuffer,
        stdio: ['pipe', 'inherit', 'inherit']
    });
    if (result.error) {
        const code = result.error.code;
        if (code === 'ENOENT') {
            throw new Error('ffplay not found on PATH. Install ffmpeg (ffplay ships with it) and retry.');
        }
        throw new Error(`ffplay failed: ${result.error.message}`);
    }
    if (result.status !== 0) {
        throw new Error(`ffplay exited with code ${result.status}`);
    }
}