flexaudio-core 0.5.2

Source-agnostic audio capture engine, types, and resampling/normalization core for flexaudio.
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
80

//! Stable optional-processor failure codes, independent of inference dependencies.

/// Typed cause of an isolated Whisper VAD failure.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum WhisperCode {
    /// A segmentation parameter is outside the supported domain.
    InvalidParameter,
    /// An inference probability is not finite or normalized.
    InvalidProbability,
    /// PCM is not finite or normalized.
    InvalidPcm,
    /// Checked arithmetic or storage capacity was exceeded.
    Overflow,
    /// Processing followed a completed session without reset.
    SessionFinished,
    /// Inference or model reset failed.
    Inference,
    /// The embedded model could not be constructed.
    ModelLoad,
    /// A previous failure requires a successful reset.
    FailedSession,
    /// Capture input did not contain complete stereo frames.
    InvalidStereoLength,
    /// A capture sample count exceeded the supported domain.
    CaptureSampleOverflow,
    /// The capture timestamp exceeded its supported domain.
    PtsOutOfRange,
    /// Conversion could not establish an exact sample-aligned clock.
    UnsupportedConversionClock,
    /// Capture conversion failed.
    Conversion,
    /// Processing followed stopped capture intake.
    Stopped,
}

impl WhisperCode {
    /// Stable code spelling shared by language bindings.
    pub fn as_str(self) -> &'static str {
        match self {
            Self::InvalidParameter => "InvalidParameter",
            Self::InvalidProbability => "InvalidProbability",
            Self::InvalidPcm => "InvalidPcm",
            Self::Overflow => "Overflow",
            Self::SessionFinished => "SessionFinished",
            Self::Inference => "Inference",
            Self::ModelLoad => "ModelLoad",
            Self::FailedSession => "FailedSession",
            Self::InvalidStereoLength => "InvalidStereoLength",
            Self::CaptureSampleOverflow => "CaptureSampleOverflow",
            Self::PtsOutOfRange => "PtsOutOfRange",
            Self::UnsupportedConversionClock => "UnsupportedConversionClock",
            Self::Conversion => "Conversion",
            Self::Stopped => "Stopped",
        }
    }

    /// Safe explanation of why this processor failed; contains no input or device details.
    pub fn explanation(self) -> &'static str {
        match self {
            Self::InvalidParameter => "a segmentation parameter is outside the supported domain",
            Self::InvalidProbability => "an inference probability is not finite or normalized",
            Self::InvalidPcm => "PCM contains a nonfinite or out-of-range sample",
            Self::Overflow => "checked arithmetic or storage exceeds the supported domain",
            Self::SessionFinished => {
                "the completed session requires a successful reset before processing"
            }
            Self::Inference => "model inference or reset could not complete",
            Self::ModelLoad => "the embedded model could not be constructed",
            Self::FailedSession => "a previous processor failure requires a successful reset",
            Self::InvalidStereoLength => "capture input does not contain complete stereo frames",
            Self::CaptureSampleOverflow => "the capture sample count exceeds the supported domain",
            Self::PtsOutOfRange => "the capture timestamp exceeds the supported domain",
            Self::UnsupportedConversionClock => {
                "conversion cannot establish an exact sample-aligned clock"
            }
            Self::Conversion => "capture conversion could not preserve the valid sample timeline",
            Self::Stopped => "capture intake has already stopped",
        }
    }
}