Transcription Pipeline

Audio Input → VAD Segmentation → ASR Model → Speaker ID → Events
     ↓              ↓                ↓           ↓          ↓
  16kHz PCM    Speech/Silence   Tokens→Text  Embeddings  Listeners

transcriber.add_audio(
    audio_data,    # List[float] or array of PCM samples
    sample_rate    # int, e.g., 44100, 16000, 48000
)

def add_audio(self, audio_data: List[float], sample_rate: int = 16000):
    """Add audio data to the stream."""
    audio_array = (ctypes.c_float * len(audio_data))(*audio_data)
    error = self._lib.moonshine_transcribe_add_audio_to_stream(
        self._transcriber._handle,
        self._handle,
        audio_array,
        len(audio_data),
        sample_rate,
        0,
    )
    check_error(error)
    self._stream_time += len(audio_data) / sample_rate
    if self._stream_time - self._last_update_time >= self._update_interval:
        self.update_transcription(0)
        self._last_update_time = self._stream_time

transcriber = Transcriber(
    model_path=model_path,
    model_arch=ModelArch.BASE,
    options={
        "vad_threshold": "0.5",          # Sensitivity (0.0-1.0)
        "vad_window_duration": "0.5",    # Averaging window in seconds
        "vad_look_behind_sample_count": "8192",  # Samples to prepend
        "vad_max_segment_duration": "15.0",     # Max line length
    }
)

#define MOONSHINE_MODEL_ARCH_TINY (0)
#define MOONSHINE_MODEL_ARCH_BASE (1)
#define MOONSHINE_MODEL_ARCH_TINY_STREAMING (2)
#define MOONSHINE_MODEL_ARCH_BASE_STREAMING (3)
#define MOONSHINE_MODEL_ARCH_SMALL_STREAMING (4)
#define MOONSHINE_MODEL_ARCH_MEDIUM_STREAMING (5)

transcript = transcriber.transcribe_without_streaming(
    audio_data=audio_samples,
    sample_rate=16000,
    flags=0
)

for line in transcript.lines:
    print(f"[{line.start_time:.2f}s] {line.text}")

transcriber.start()

# Feed audio in chunks as it arrives
for chunk in audio_chunks:
    transcriber.add_audio(chunk, sample_rate)
    # Transcription happens automatically at update_interval

transcript = transcriber.stop()

options = {
    "max_tokens_per_second": "13.0"  # For Korean, Japanese, etc.
}

/* The speaker ID is another 64-bit randomly-generated number, used to identify
   the calculated speaker of the line, for diarization purposes. This is not
   available until the line has accumulated enough audio data to be confident
   in the speaker identification, or if the line is complete. */

options = {
    "identify_speakers": "true"  # Enable (default)
    # or
    "identify_speakers": "false"  # Disable for performance
}

line = TranscriptLine(
    text="Hello world",               # UTF-8 transcribed text
    start_time=1.5,                    # Start offset in seconds
    duration=2.3,                      # Segment length in seconds
    line_id=0x1234567890ABCDEF,        # Unique 64-bit ID
    is_complete=True,                  # Speech ended?
    is_updated=True,                   # Changed since last update?
    is_new=False,                      # Just added?
    has_text_changed=True,             # Text changed?
    has_speaker_id=True,               # Speaker identified?
    speaker_id=0xFEDCBA0987654321,    # Speaker's unique ID
    speaker_index=0,                   # Speaker #1
    audio_data=[...],                  # Raw 16kHz PCM audio
    last_transcription_latency_ms=87   # Processing time
)

transcript = Transcript(
    lines=[line1, line2, line3, ...]  # Time-ordered list
)

# Force immediate update
transcript = stream.update_transcription(
    flags=Transcriber.MOONSHINE_FLAG_FORCE_UPDATE
)

options = {"skip_transcription": "true"}
transcriber = Transcriber(model_path, model_arch, options=options)

# Lines will have audio_data but empty text
for line in transcript.lines:
    process_audio_segment(line.audio_data)

options = {"return_audio_data": "false"}
# line.audio_data will be None

options = {"save_input_wav_path": "."}
transcriber = Transcriber(model_path, model_arch, options=options)
# Saves input_1.wav, input_2.wav, etc. for each stream

options = {"log_api_calls": "true"}
# Prints all C API calls to console

options = {"log_output_text": "true"}
# Prints transcription results to console

from moonshine_voice import Transcriber, ModelArch, load_wav_file

# Load audio
audio_data, sample_rate = load_wav_file("speech.wav")

# Create transcriber
transcriber = Transcriber(
    model_path="/path/to/models",
    model_arch=ModelArch.BASE,
    update_interval=0.5,
    options={
        "vad_threshold": "0.5",
        "identify_speakers": "true"
    }
)

transcriber.start()

# Simulate streaming by chunking
chunk_size = int(0.1 * sample_rate)  # 100ms chunks
for i in range(0, len(audio_data), chunk_size):
    chunk = audio_data[i:i + chunk_size]
    transcriber.add_audio(chunk, sample_rate)

transcript = transcriber.stop()

# Print results
for line in transcript.lines:
    speaker = f"Speaker {line.speaker_index + 1}: " if line.has_speaker_id else ""
    print(f"[{line.start_time:.1f}s] {speaker}{line.text}")

transcriber.close()