flacx 0.11.0

Convert supported PCM containers to FLAC, decode FLAC back to PCM containers, and recompress existing FLAC streams.
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Progress reporting primitives used by `flacx` when the `progress` feature is enabled.
//!
//! The encoder and decoder both report the same [`ProgressSnapshot`] shape.
//! [`EncodeProgress`] and [`DecodeProgress`] are aliases of that snapshot type.

#[cfg(feature = "progress")]
use crate::error::Result;

#[cfg(feature = "progress")]
macro_rules! emit_progress {
    ($progress:expr, $snapshot:expr) => {{
        #[cfg(feature = "progress")]
        {
            $progress.on_frame($snapshot)
        }
        #[cfg(not(feature = "progress"))]
        {
            let _ = $progress;
            Ok::<(), crate::error::Error>(())
        }
    }};
}

#[cfg(feature = "progress")]
pub(crate) use emit_progress;

/// A monotonic snapshot of encode or decode progress.
#[cfg(feature = "progress")]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ProgressSnapshot {
    /// Samples processed so far.
    pub processed_samples: u64,
    /// Total samples expected for the current input.
    pub total_samples: u64,
    /// Frames completed so far.
    pub completed_frames: usize,
    /// Total frames planned for the current input.
    pub total_frames: usize,
    /// Input bytes read so far.
    pub input_bytes_read: u64,
    /// Output bytes written so far.
    pub output_bytes_written: u64,
}

#[cfg(feature = "progress")]
/// Progress snapshot reported by encoder callbacks.
pub type EncodeProgress = ProgressSnapshot;

#[cfg(feature = "progress")]
/// Progress snapshot reported by decoder callbacks.
pub type DecodeProgress = ProgressSnapshot;

#[cfg(feature = "progress")]
pub(crate) trait ProgressSink {
    fn on_frame(&mut self, progress: ProgressSnapshot) -> Result<()>;
}

#[cfg(not(feature = "progress"))]
pub(crate) trait ProgressSink {}

pub(crate) struct NoProgress;

#[cfg(feature = "progress")]
impl ProgressSink for NoProgress {
    fn on_frame(&mut self, _progress: ProgressSnapshot) -> Result<()> {
        Ok(())
    }
}

#[cfg(not(feature = "progress"))]
impl ProgressSink for NoProgress {}

#[cfg(feature = "progress")]
pub(crate) struct CallbackProgress<F> {
    callback: F,
}

#[cfg(feature = "progress")]
impl<F> CallbackProgress<F> {
    pub(crate) fn new(callback: F) -> Self {
        Self { callback }
    }
}

#[cfg(feature = "progress")]
impl<F> ProgressSink for CallbackProgress<F>
where
    F: FnMut(ProgressSnapshot) -> Result<()>,
{
    fn on_frame(&mut self, progress: ProgressSnapshot) -> Result<()> {
        (self.callback)(progress)
    }
}

#[cfg(test)]
mod tests {
    #[cfg(feature = "progress")]
    use super::ProgressSnapshot;

    #[cfg(feature = "progress")]
    #[test]
    fn progress_snapshot_carries_input_bytes_read_and_output_bytes_written() {
        let snapshot = ProgressSnapshot {
            processed_samples: 128,
            total_samples: 256,
            completed_frames: 2,
            total_frames: 4,
            input_bytes_read: 4_096,
            output_bytes_written: 1_024,
        };

        assert_eq!(snapshot.input_bytes_read, 4_096);
        assert_eq!(snapshot.output_bytes_written, 1_024);
    }

    #[cfg(not(feature = "progress"))]
    #[test]
    fn progress_types_are_not_reexported_without_progress_feature() {
        let _ = crate::Error::Encode("no progress".into());
    }
}