CLI संदर्भ

audio बाइनरी सभी स्पीच प्रोसेसिंग कार्यों के लिए मुख्य एंट्री पॉइंट है। make build से बिल्ड करें, फिर .build/release/audio से चलाएँ।

transcribe

ऑडियो फ़ाइलों को टेक्स्ट में ट्रांसक्राइब करें।

audio transcribe <file> [options]

विकल्प	डिफ़ॉल्ट	विवरण
`<file>`		ट्रांसक्राइब करने के लिए ऑडियो फ़ाइल (WAV, M4A, MP3, CAF)
`--engine`	`qwen3`	ASR इंजन: `qwen3`, `qwen3-coreml`, `parakeet`, या `omnilingual`
`--model, -m`	`0.6B`	मॉडल वैरिएंट: `0.6B`, `1.7B`, या पूर्ण HuggingFace मॉडल ID (केवल qwen3)
`--language`		भाषा संकेत (वैकल्पिक, omnilingual द्वारा अनदेखा)
`--window`	`10`	`[omnilingual]` CoreML विंडो आकार सेकंड में: `5` या `10`
`--backend`	`coreml`	`[omnilingual]` बैकएंड: `coreml` (Neural Engine) या `mlx` (Metal GPU)
`--variant`	`300M`	`[omnilingual mlx]` आकार: `300M`, `1B`, `3B`, या `7B`
`--bits`	`4`	`[omnilingual mlx]` क्वांटिज़ेशन बिट्स: `4` या `8`
`--stream`		VAD के साथ स्ट्रीमिंग ट्रांसक्रिप्शन सक्षम करें
`--max-segment`	`10`	अधिकतम सेगमेंट अवधि सेकंड में (स्ट्रीमिंग)
`--partial`		स्पीच के दौरान पार्शियल परिणाम जारी करें (स्ट्रीमिंग)

उदाहरण:

# बेसिक ट्रांसक्रिप्शन
audio transcribe recording.wav

# बड़े मॉडल का उपयोग करें
audio transcribe recording.wav --model 1.7B

# CoreML एनकोडर (Neural Engine + MLX डिकोडर)
audio transcribe recording.wav --engine qwen3-coreml

# Parakeet (CoreML) इंजन का उपयोग करें
audio transcribe recording.wav --engine parakeet

# Omnilingual (CoreML, 1,672 भाषाएँ)
audio transcribe recording.wav --engine omnilingual                              # 10 s विंडो
audio transcribe recording.wav --engine omnilingual --window 5                     # 5 s विंडो

# Omnilingual (MLX, 40 s तक कोई भी लंबाई)
audio transcribe recording.wav --engine omnilingual --backend mlx                              # 300M @ 4-bit
audio transcribe recording.wav --engine omnilingual --backend mlx --variant 1B                  # 1B @ 4-bit
audio transcribe recording.wav --engine omnilingual --backend mlx --variant 3B --bits 8         # 3B @ 8-bit
audio transcribe recording.wav --engine omnilingual --backend mlx --variant 7B                  # 7B @ 4-bit

# VAD के साथ स्ट्रीमिंग
audio transcribe recording.wav --stream --partial

align

शब्द-स्तरीय फ़ोर्स्ड अलाइनमेंट — हर शब्द के लिए सटीक टाइमस्टैम्प प्राप्त करें।

audio align <file> [options]

विकल्प	डिफ़ॉल्ट	विवरण
`<file>`		ऑडियो फ़ाइल
`--text, -t`		अलाइन करने के लिए टेक्स्ट (अगर नहीं दिया, तो पहले ट्रांसक्राइब करता है)
`--model, -m`	`0.6B`	ट्रांसक्रिप्शन के लिए ASR मॉडल: `0.6B`, `1.7B`, या पूर्ण ID
`--aligner-model`		फ़ोर्स्ड अलाइनर मॉडल ID
`--language`		भाषा संकेत

उदाहरण:

# ऑटो-ट्रांसक्राइब फिर अलाइन करें
audio align recording.wav

# ज्ञात टेक्स्ट के साथ अलाइन करें
audio align recording.wav --text "Can you guarantee that the replacement part will be shipped tomorrow?"

speak

टेक्स्ट-टू-स्पीच संश्लेषण।

audio speak "<text>" [options]

विकल्प	डिफ़ॉल्ट	विवरण
`<text>`		संश्लेषण करने के लिए टेक्स्ट (यदि `--batch-file` उपयोग कर रहे हैं तो वैकल्पिक)
`--engine`	`qwen3`	TTS इंजन: `qwen3` या `cosyvoice`
`--output, -o`	`output.wav`	आउटपुट WAV फ़ाइल पथ
`--language`	`english`	भाषा। जब `--speaker` सेट हो तो स्पीकर की मूल बोली का उपयोग करने के लिए छोड़ दें।
`--stream`		स्ट्रीमिंग संश्लेषण सक्षम करें
`--voice-sample`		वॉयस क्लोनिंग के लिए संदर्भ ऑडियो (`qwen3` और `cosyvoice` दोनों इंजनों के साथ काम करता है)
`--verbose`		विस्तृत समय जानकारी दिखाएँ

Qwen3-TTS विकल्प

विकल्प	डिफ़ॉल्ट	विवरण
`--model`	`base`	मॉडल वैरिएंट: `base`, `customVoice`, या पूर्ण HF मॉडल ID
`--speaker`		स्पीकर वॉयस (`--model customVoice` आवश्यक)
`--instruct`		स्टाइल निर्देश (CustomVoice मॉडल)
`--list-speakers`		उपलब्ध स्पीकर सूचीबद्ध करें और बाहर निकलें
`--temperature`	`0.3`	सैंपलिंग तापमान
`--top-k`	`50`	Top-k सैंपलिंग
`--max-tokens`	`500`	अधिकतम टोकन (500 = ~40s ऑडियो)
`--batch-file`		बैच संश्लेषण के लिए प्रति पंक्ति एक टेक्स्ट वाली फ़ाइल
`--batch-size`	`4`	समानांतर जनरेशन के लिए अधिकतम बैच आकार
`--first-chunk-frames`	`3`	पहले स्ट्रीम किए गए चंक में codec फ़्रेम
`--chunk-frames`	`25`	प्रति स्ट्रीम किए गए चंक codec फ़्रेम

CosyVoice3 विकल्प

विकल्प	डिफ़ॉल्ट	विवरण
`--speakers`		मल्टी-स्पीकर डायलॉग के लिए स्पीकर मैपिंग: `s1=alice.wav,s2=bob.wav`
`--cosy-instruct`		स्टाइल निर्देश (डिफ़ॉल्ट को ओवरराइड करता है)। CosyVoice3 के लिए वॉयस स्टाइल को नियंत्रित करता है।
`--turn-gap`	`0.2`	डायलॉग टर्न के बीच मौन अंतराल सेकंड में
`--crossfade`	`0.0`	टर्न के बीच क्रॉसफ़ेड ओवरलैप सेकंड में
`--model-id`		HuggingFace मॉडल ID

उदाहरण:

# बेसिक TTS
audio speak "Hello, world!" --output hello.wav

# वॉयस क्लोनिंग (Qwen3-TTS)
audio speak "Hello in your voice" --voice-sample reference.wav -o cloned.wav

# वॉयस क्लोनिंग (CosyVoice)
audio speak "Hello in your voice" --engine cosyvoice --voice-sample reference.wav -o cloned.wav

# CosyVoice बहुभाषी
audio speak "Hallo Welt" --engine cosyvoice --language german -o hallo.wav

# मल्टी-स्पीकर डायलॉग
audio speak "[S1] Hello there! [S2] Hey, how are you?" \
    --engine cosyvoice --speakers s1=alice.wav,s2=bob.wav -o dialogue.wav

# इनलाइन इमोशन/स्टाइल टैग
audio speak "(excited) Wow, amazing! (sad) But I have to go..." \
    --engine cosyvoice -o emotion.wav

# संयुक्त: डायलॉग + इमोशन + वॉयस क्लोनिंग
audio speak "[S1] (happy) Great news! [S2] (surprised) Really?" \
    --engine cosyvoice --speakers s1=alice.wav,s2=bob.wav -o combined.wav

# कस्टम स्टाइल निर्देश
audio speak "Hello world" --engine cosyvoice --cosy-instruct "Speak cheerfully" -o cheerful.wav

# स्ट्रीमिंग संश्लेषण
audio speak "Long text here..." --stream

# फ़ाइल से बैच संश्लेषण
audio speak --batch-file texts.txt --batch-size 4

kokoro

Neural Engine (CoreML) पर Kokoro-82M का उपयोग करके हल्का टेक्स्ट-टू-स्पीच। नॉन-ऑटोरिग्रेसिव — एकल फ़ॉरवर्ड पास, ~45ms लेटेंसी।

audio kokoro "<text>" [options]

विकल्प	डिफ़ॉल्ट	विवरण
`<text>`		संश्लेषण करने के लिए टेक्स्ट
`--voice`	`af_heart`	वॉयस प्रीसेट (10 भाषाओं में 50 उपलब्ध)
`--language`	`en`	भाषा कोड: en, es, fr, hi, it, ja, pt, zh, ko, de
`--output, -o`	`kokoro_output.wav`	आउटपुट WAV फ़ाइल पथ
`--list-voices`		सभी उपलब्ध वॉयस सूचीबद्ध करें और बाहर निकलें
`--model, -m`		HuggingFace मॉडल ID

उदाहरण:

# बेसिक Kokoro TTS
audio kokoro "Hello, world!" --voice af_heart -o hello.wav

# फ़्रेंच वॉयस
audio kokoro "Bonjour le monde" --voice ff_siwis --language fr -o bonjour.wav

# सभी 50 वॉयस सूचीबद्ध करें
audio kokoro --list-voices

respond

PersonaPlex 7B का उपयोग करके फुल-डुप्लेक्स स्पीच-टू-स्पीच डायलॉग।

audio respond [options]

विकल्प	डिफ़ॉल्ट	विवरण
`--input, -i`		इनपुट ऑडियो WAV फ़ाइल (24kHz मोनो) (आवश्यक)
`--output, -o`	`response.wav`	आउटपुट रिस्पॉन्स WAV फ़ाइल
`--voice`	`NATM0`	वॉयस प्रीसेट (जैसे NATM0, NATF1, VARF0)
`--system-prompt`	`assistant`	प्रीसेट: `assistant`, `focused`, `customer-service`, `teacher`
`--system-prompt-text`		कस्टम सिस्टम प्रॉम्प्ट टेक्स्ट (प्रीसेट को ओवरराइड करता है)
`--max-steps`	`200`	12.5Hz पर अधिकतम जनरेशन स्टेप्स (~16s)
`--stream`		जनरेशन के दौरान ऑडियो चंक्स जारी करें
`--compile`		संकलित ट्रांसफ़ॉर्मर सक्षम करें (warmup + kernel fusion)
`--list-voices`		उपलब्ध वॉयस प्रीसेट सूचीबद्ध करें
`--list-prompts`		उपलब्ध सिस्टम प्रॉम्प्ट प्रीसेट सूचीबद्ध करें
`--transcript`		मॉडल का इनर मोनोलॉग टेक्स्ट प्रिंट करें
`--json`		JSON के रूप में आउटपुट (ट्रांसक्रिप्ट, लेटेंसी, ऑडियो पथ)
`--verbose`		विस्तृत समय जानकारी दिखाएँ

सैंपलिंग ओवरराइड्स

विकल्प	डिफ़ॉल्ट	विवरण
`--audio-temp`	`0.8`	ऑडियो सैंपलिंग तापमान
`--text-temp`	`0.7`	टेक्स्ट सैंपलिंग तापमान
`--audio-top-k`	`250`	ऑडियो top-k उम्मीदवार
`--repetition-penalty`	`1.2`	ऑडियो पुनरावृत्ति दंड (1.0 = अक्षम)
`--text-repetition-penalty`	`1.2`	टेक्स्ट पुनरावृत्ति दंड (1.0 = अक्षम)
`--repetition-window`	`30`	फ़्रेमों में पुनरावृत्ति दंड विंडो
`--silence-early-stop`	`15`	जल्दी रुकने से पहले मौन फ़्रेम (0 = अक्षम)
`--entropy-threshold`	`0`	जल्दी रुकने के लिए टेक्स्ट एंट्रॉपी थ्रेशोल्ड (0 = अक्षम)
`--entropy-window`	`10`	जल्दी रुकने से पहले लगातार लो-एंट्रॉपी स्टेप्स

उदाहरण:

# बेसिक स्पीच-टू-स्पीच
audio respond --input question.wav

# संकलित ट्रांसफ़ॉर्मर के साथ महिला आवाज़ का उपयोग करें
audio respond -i question.wav --voice NATF1 --compile

# रिस्पॉन्स स्ट्रीम करें और ट्रांसक्रिप्ट दिखाएँ
audio respond -i question.wav --stream --transcript --verbose

vad

Pyannote सेगमेंटेशन का उपयोग करके ऑफ़लाइन वॉयस एक्टिविटी डिटेक्शन।

audio vad <file> [options]

विकल्प	विवरण
`<file>`	विश्लेषण करने के लिए ऑडियो फ़ाइल
`--model, -m`	HuggingFace मॉडल ID
`--onset`	Onset थ्रेशोल्ड (स्पीच प्रारंभ)
`--offset`	Offset थ्रेशोल्ड (स्पीच समाप्ति)
`--min-speech`	न्यूनतम स्पीच अवधि सेकंड में
`--min-silence`	न्यूनतम मौन अवधि सेकंड में
`--json`	JSON के रूप में आउटपुट

vad-stream

Silero VAD v5 का उपयोग करके स्ट्रीमिंग वॉयस एक्टिविटी डिटेक्शन। ऑडियो को 32ms चंक्स में प्रोसेस करता है।

audio vad-stream <file> [options]

विकल्प	विवरण
`<file>`	विश्लेषण करने के लिए ऑडियो फ़ाइल
`--engine`	VAD इंजन: `mlx` (डिफ़ॉल्ट) या `coreml`
`--model, -m`	HuggingFace मॉडल ID (इंजन द्वारा स्वतः चयनित)
`--onset`	Onset थ्रेशोल्ड
`--offset`	Offset थ्रेशोल्ड
`--min-speech`	न्यूनतम स्पीच अवधि सेकंड में
`--min-silence`	न्यूनतम मौन अवधि सेकंड में
`--json`	JSON के रूप में आउटपुट

diarize

स्पीकर डायराइज़ेशन — पहचानें कि कौन कब बोला।

audio diarize <file> [options]

विकल्प	डिफ़ॉल्ट	विवरण
`<file>`		विश्लेषण करने के लिए ऑडियो फ़ाइल
`--engine`	`pyannote`	डायराइज़ेशन इंजन: `pyannote` (सेगमेंटेशन + स्पीकर चेनिंग) या `sortformer` (एंड-टू-एंड CoreML)
`--target-speaker`		लक्ष्य स्पीकर निष्कर्षण के लिए एनरोलमेंट ऑडियो (केवल pyannote)
`--embedding-engine`	`mlx`	स्पीकर एम्बेडिंग इंजन: `mlx` या `coreml` (केवल pyannote)
`--vad-filter`		Silero VAD के साथ प्री-फ़िल्टर (केवल pyannote)
`--rttm`		RTTM फ़ॉर्मेट में आउटपुट
`--json`		JSON के रूप में आउटपुट
`--score-against`		DER गणना के लिए संदर्भ RTTM फ़ाइल

उदाहरण:

# बेसिक डायराइज़ेशन (pyannote, डिफ़ॉल्ट)
audio diarize meeting.wav

# एंड-टू-एंड Sortformer (CoreML, Neural Engine)
audio diarize meeting.wav --engine sortformer

# मूल्यांकन के लिए RTTM आउटपुट
audio diarize meeting.wav --rttm

# लक्ष्य स्पीकर निष्कर्षण (केवल pyannote)
audio diarize meeting.wav --target-speaker enrollment.wav

# संदर्भ के विरुद्ध स्कोर
audio diarize meeting.wav --score-against reference.rttm

embed-speaker

ऑडियो से एक स्पीकर एम्बेडिंग वेक्टर निकालें।

audio embed-speaker <file> [options]

विकल्प	विवरण
`<file>`	स्पीकर वॉयस युक्त ऑडियो फ़ाइल
`--engine`	इन्फ़रेंस इंजन: `mlx` (डिफ़ॉल्ट), `coreml` (WeSpeaker 256-dim), या `camplusplus` (CAM++ CoreML 192-dim)
`--json`	JSON के रूप में आउटपुट

denoise

Neural Engine पर DeepFilterNet3 का उपयोग करके बैकग्राउंड नॉइज़ हटाएँ।

audio denoise <file> [options]

विकल्प	डिफ़ॉल्ट	विवरण
`<file>`		इनपुट ऑडियो फ़ाइल
`--output, -o`	`input_clean.wav`	आउटपुट फ़ाइल पथ
`--model, -m`		HuggingFace मॉडल ID

उदाहरण:

audio denoise noisy-recording.wav -o clean.wav