Struct UnifiedStreamingConfig 

pub struct UnifiedStreamingConfig {
    pub left_context_secs: f32,
    pub chunk_secs: f32,
    pub right_context_secs: f32,
}

Fields

left_context_secs: f32

chunk_secs: f32

right_context_secs: f32

Implementations

impl UnifiedStreamingConfig

pub fn validate(self) -> Result<Self>

pub fn left_context_frames(self) -> usize

pub fn chunk_frames(self) -> usize

pub fn right_context_frames(self) -> usize

pub fn total_window_frames(self) -> usize

pub fn left_context_samples(self) -> usize

pub fn chunk_samples(self) -> usize

Examples found in repository

examples/shared_model.rs (line 100)

fn run_unified(model_dir: &str, audio: &[f32]) -> Result<(), Box<dyn std::error::Error>> {
    let handle = ParakeetUnifiedHandle::load(model_dir, None)?;
    let mut a = ParakeetUnified::from_shared(&handle);
    let mut b = ParakeetUnified::from_shared(&handle);

    let chunk_size = a.streaming_config().chunk_samples();
    for chunk_data in audio.chunks(chunk_size) {
        a.transcribe_chunk(chunk_data)?;
        b.transcribe_chunk(chunk_data)?;
    }
    a.flush()?;
    b.flush()?;

    println!("A: {}", a.get_transcript());
    println!("B: {}", b.get_transcript());
    assert_eq!(
        a.get_transcript(),
        b.get_transcript(),
        "shared model must be deterministic"
    );
    println!("same");
    Ok(())
}

examples/unified.rs (line 66)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let start_time = Instant::now();
    let args: Vec<String> = env::args().collect();

    let audio_path = if args.len() > 1 {
        &args[1]
    } else {
        "6_speakers.wav"
    };

    let use_streaming = args.len() > 2 && args[2] == "streaming";

    // Load audio
    let mut reader = hound::WavReader::open(audio_path)?;
    let spec = reader.spec();

    if spec.sample_rate != 16000 {
        return Err(format!("Expected 16kHz, got {}Hz", spec.sample_rate).into());
    }

    let mut audio: Vec<f32> = match spec.sample_format {
        hound::SampleFormat::Float => reader.samples::<f32>().collect::<Result<Vec<_>, _>>()?,
        hound::SampleFormat::Int => reader
            .samples::<i16>()
            .map(|s| s.map(|s| s as f32 / 32768.0))
            .collect::<Result<Vec<_>, _>>()?,
    };

    if spec.channels > 1 {
        audio = audio
            .chunks(spec.channels as usize)
            .map(|c| c.iter().sum::<f32>() / spec.channels as f32)
            .collect();
    }

    let duration = audio.len() as f32 / 16000.0;
    println!("Audio: {:.1}s, {}Hz, {} ch", duration, spec.sample_rate, spec.channels);

    let mut model = ParakeetUnified::from_pretrained("./unified", None)?;
    let load_time = start_time.elapsed();
    println!("Model loaded in {:.2}s", load_time.as_secs_f32());

    if use_streaming {
        let config = model.streaming_config();
        let chunk_size = config.chunk_samples();
        println!("Streaming mode: {:.0}ms chunks", config.chunk_secs * 1000.0);

        let transcribe_start = Instant::now();
        print!("Streaming: ");

        for chunk in audio.chunks(chunk_size) {
            let text = model.transcribe_chunk(chunk)?;
            if !text.is_empty() {
                print!("{}", text);
                std::io::stdout().flush()?;
            }
        }

        let remaining = model.flush()?;
        if !remaining.is_empty() {
            print!("{}", remaining);
        }

        let result = model.get_timed_transcript(TimestampMode::Sentences);
        println!("\n\nFinal: {}", result.text);

        println!("\nSentences:");
        for segment in &result.tokens {
            println!("[{:.2}s - {:.2}s]: {}", segment.start, segment.end, segment.text);
        }

        let elapsed = transcribe_start.elapsed();
        println!(
            "Transcribed in {:.2}s (audio: {:.1}s, RTF: {:.2}x)",
            elapsed.as_secs_f32(),
            duration,
            duration / elapsed.as_secs_f32()
        );
    } else {
        println!("Offline mode (with word timestamps)");

        let transcribe_start = Instant::now();
        let result = model.transcribe_samples(
            audio,
            spec.sample_rate,
            spec.channels,
            Some(TimestampMode::Words),
        )?;
        let elapsed = transcribe_start.elapsed();

        println!("Result: {}", result.text);

        println!("\nWords (first 20):");
        for word in result.tokens.iter().take(20) {
            println!("[{:.2}s - {:.2}s]: {}", word.start, word.end, word.text);
        }

        println!(
            "Transcribed in {:.2}s (audio: {:.1}s, RTF: {:.2}x)",
            elapsed.as_secs_f32(),
            duration,
            duration / elapsed.as_secs_f32()
        );
    }

    Ok(())
}

pub fn right_context_samples(self) -> usize

pub fn total_window_samples(self) -> usize

pub fn chunk_encoder_frames(self) -> usize

pub fn left_context_encoder_frames(self) -> usize

Trait Implementations

impl Clone for UnifiedStreamingConfig

fn clone(&self) -> UnifiedStreamingConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UnifiedStreamingConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for UnifiedStreamingConfig

fn default() -> Self

Returns the “default value” for a type.

impl Copy for UnifiedStreamingConfig