stt-cli 0.2.1

Speech to text Cli using Groq API and OpenAI API
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

// src/pipeline/chunking.rs
// --- Chunking Manager ---
// This module provides the ChunkingManager, which buffers incoming audio samples and yields fixed-size chunks.
// Used in the pipeline driver to ensure consistent chunk boundaries for downstream processing.

use std::time::Duration;

/// Manages buffering and chunking of raw audio samples into fixed-size chunks.
pub struct ChunkingManager {
    buffer: Vec<f32>,
    min_chunk_duration: Duration,
    sample_rate: u32,
    required_samples: usize,
}

impl ChunkingManager {
    /// Create a new ChunkingManager with the specified sample rate and minimum chunk duration.
    pub fn new(sample_rate: u32, min_chunk_duration: Duration) -> Self {
        let required_samples = (sample_rate as f32 * min_chunk_duration.as_secs_f32()) as usize;
        Self {
            buffer: Vec::with_capacity(required_samples * 2),
            min_chunk_duration,
            sample_rate,
            required_samples,
        }
    }

    /// Add samples to the buffer and return complete chunks.
    pub fn add_samples(&mut self, samples: &[f32]) -> Vec<Vec<f32>> {
        self.buffer.extend_from_slice(samples);

        let mut chunks = Vec::new();
        while self.buffer.len() >= self.required_samples {
            let chunk = self.buffer.drain(0..self.required_samples).collect();
            chunks.push(chunk);
        }
        chunks
    }

    /// Take any remaining samples that didn't fill a complete chunk.
    pub fn take_remaining(&mut self) -> Vec<f32> {
        self.buffer.drain(..).collect()
    }

    /// Get the current number of buffered samples.
    pub fn buffered_samples(&self) -> usize {
        self.buffer.len()
    }

    /// Get the required number of samples for a complete chunk.
    pub fn required_samples(&self) -> usize {
        self.required_samples
    }

    /// Get the current buffered duration in seconds.
    pub fn current_duration(&self) -> f32 {
        self.buffer.len() as f32 / self.sample_rate as f32
    }
}