zk-audio 0.1.0

Audio processing library for voice recording and enhancement
Documentation 
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

use crate::core::{
    ActiveRecording, AudioFrame, AudioProfile, AudioResult, AudioSpec, CaptureDiagnostics,
    DelayEffectConfig, InputDeviceInfo, NativeCaptureConfig, ProcessorOverrideMode,
};
use crate::types::{AudioBlock, ProcessContext, ProcessorInfo};
use std::collections::BTreeMap;

#[allow(dead_code)]
pub trait AudioProcessor: Send {
    fn name(&self) -> &'static str;
    fn prepare(&mut self, spec: AudioSpec) -> AudioResult<()>;
    fn process(&mut self, frame: &mut AudioFrame) -> AudioResult<()>;

    fn prepare_with_context(&mut self, ctx: &ProcessContext) -> AudioResult<ProcessorInfo> {
        self.prepare(ctx.spec)?;
        Ok(ProcessorInfo {
            latency_samples: self.latency_samples(),
        })
    }

    fn process_block(&mut self, block: &mut AudioBlock, _ctx: &ProcessContext) -> AudioResult<()> {
        let mut frame = AudioFrame {
            samples: std::mem::take(&mut block.samples),
            spec: block.spec,
        };
        self.process(&mut frame)?;
        block.samples = frame.samples;
        Ok(())
    }

    fn reset(&mut self) {}

    fn latency_samples(&self) -> usize {
        0
    }

    fn diagnostics_notes(&self) -> Vec<String> {
        Vec::new()
    }
}

pub trait AudioSink: Send {
    fn write_frame(&mut self, frame: &AudioFrame) -> AudioResult<()>;
    fn finalize(&mut self) -> AudioResult<()>;
}

pub trait MetricsCollector: Send {
    fn observe(&mut self, frame: &AudioFrame);
    fn apply(&self, diagnostics: &mut CaptureDiagnostics);
}

pub trait CaptureBackend: Send + Sync {
    fn start(&self, config: NativeCaptureConfig) -> AudioResult<Box<dyn ActiveRecording>>;
}

#[derive(Debug, Clone)]
pub struct ProcessorBuildRequest {
    pub profile: AudioProfile,
    pub gain_db: f32,
    pub limiter_threshold: f32,
    pub high_pass_hz: f32,
    pub noise_suppression_amount: f32,
    pub noise_calibration_ms: u32,
    pub delay_effect: Option<DelayEffectConfig>,
    pub stage_overrides: BTreeMap<String, ProcessorOverrideMode>,
}

pub trait ProcessorFactory: Send + Sync {
    fn build_processors(
        &self,
        request: ProcessorBuildRequest,
    ) -> AudioResult<Vec<Box<dyn AudioProcessor>>>;
}

#[allow(dead_code)]
pub trait DeviceEnumerator: Send + Sync {
    fn list_input_devices(&self) -> AudioResult<Vec<InputDeviceInfo>>;
    fn set_default_input_device(&self, device_id: &str) -> AudioResult<()>;
}