rustwav_core/
encoders.rs

1#![allow(dead_code)]
2#![allow(non_snake_case)]
3
4use std::fmt::Debug;
5
6use xlaw::{PcmXLawEncoder, XLaw};
7use io_utils::Writer;
8use audioutils::{sample_conv, sample_conv_batch, stereo_conv, stereos_conv};
9use sampletypes::{SampleType, i24, u24};
10use crate::adpcm;
11use crate::errors::AudioWriteError;
12use crate::format_specs::format_tags::*;
13use crate::format_specs::guids::*;
14use crate::wavcore::{ExtensibleData, FmtChunk, FmtExtension};
15use crate::wavcore::{Spec, WaveSampleType};
16
17/// An encoder that accepts samples of type `S` and encodes them into the file's target format.
18/// Due to trait bounds prohibiting generic parameters, each function must be explicitly
19/// implemented for every supported type.
20pub trait EncoderToImpl: Debug {
21    fn get_channels(&self) -> u16;
22    fn get_max_channels(&self) -> u16;
23    fn get_bitrate(&self) -> u32;
24    fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError>;
25    fn update_fmt_chunk(&self, fmt: &mut FmtChunk) -> Result<(), AudioWriteError>;
26    fn begin_encoding(&mut self) -> Result<(), AudioWriteError>;
27    fn finish(&mut self) -> Result<(), AudioWriteError>;
28
29    // Write interleaved samples
30    fn write_interleaved_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError>;
31    fn write_interleaved_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError>;
32    fn write_interleaved_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError>;
33    fn write_interleaved_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError>;
34    fn write_interleaved_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError>;
35    fn write_interleaved_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError>;
36    fn write_interleaved_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError>;
37    fn write_interleaved_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError>;
38    fn write_interleaved_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError>;
39    fn write_interleaved_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError>;
40    fn write_interleaved_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError>;
41    fn write_interleaved_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError>;
42
43    // Convenience interfaces for writing audio frames. Each frame is an array of samples per channel. Default implementations are provided.
44    fn write_frame__i8(&mut self, frame: &[i8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples__i8(&audioutils::frames_to_interleaved_samples(&[frame.to_vec()])?)}
45    fn write_frame_i16(&mut self, frame: &[i16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i16(&audioutils::frames_to_interleaved_samples(&[frame.to_vec()])?)}
46    fn write_frame_i24(&mut self, frame: &[i24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i24(&audioutils::frames_to_interleaved_samples(&[frame.to_vec()])?)}
47    fn write_frame_i32(&mut self, frame: &[i32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i32(&audioutils::frames_to_interleaved_samples(&[frame.to_vec()])?)}
48    fn write_frame_i64(&mut self, frame: &[i64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i64(&audioutils::frames_to_interleaved_samples(&[frame.to_vec()])?)}
49    fn write_frame__u8(&mut self, frame: &[u8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples__u8(&audioutils::frames_to_interleaved_samples(&[frame.to_vec()])?)}
50    fn write_frame_u16(&mut self, frame: &[u16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u16(&audioutils::frames_to_interleaved_samples(&[frame.to_vec()])?)}
51    fn write_frame_u24(&mut self, frame: &[u24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u24(&audioutils::frames_to_interleaved_samples(&[frame.to_vec()])?)}
52    fn write_frame_u32(&mut self, frame: &[u32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u32(&audioutils::frames_to_interleaved_samples(&[frame.to_vec()])?)}
53    fn write_frame_u64(&mut self, frame: &[u64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u64(&audioutils::frames_to_interleaved_samples(&[frame.to_vec()])?)}
54    fn write_frame_f32(&mut self, frame: &[f32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&audioutils::frames_to_interleaved_samples(&[frame.to_vec()])?)}
55    fn write_frame_f64(&mut self, frame: &[f64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f64(&audioutils::frames_to_interleaved_samples(&[frame.to_vec()])?)}
56
57    // Convenience interfaces for writing multiple audio frames. Default implementations are provided.
58    fn write_frames__i8(&mut self, frames: &[Vec<i8 >]) -> Result<(), AudioWriteError> {self.write_interleaved_samples__i8(&audioutils::frames_to_interleaved_samples(frames)?)}
59    fn write_frames_i16(&mut self, frames: &[Vec<i16>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i16(&audioutils::frames_to_interleaved_samples(frames)?)}
60    fn write_frames_i24(&mut self, frames: &[Vec<i24>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i24(&audioutils::frames_to_interleaved_samples(frames)?)}
61    fn write_frames_i32(&mut self, frames: &[Vec<i32>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i32(&audioutils::frames_to_interleaved_samples(frames)?)}
62    fn write_frames_i64(&mut self, frames: &[Vec<i64>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i64(&audioutils::frames_to_interleaved_samples(frames)?)}
63    fn write_frames__u8(&mut self, frames: &[Vec<u8 >]) -> Result<(), AudioWriteError> {self.write_interleaved_samples__u8(&audioutils::frames_to_interleaved_samples(frames)?)}
64    fn write_frames_u16(&mut self, frames: &[Vec<u16>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u16(&audioutils::frames_to_interleaved_samples(frames)?)}
65    fn write_frames_u24(&mut self, frames: &[Vec<u24>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u24(&audioutils::frames_to_interleaved_samples(frames)?)}
66    fn write_frames_u32(&mut self, frames: &[Vec<u32>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u32(&audioutils::frames_to_interleaved_samples(frames)?)}
67    fn write_frames_u64(&mut self, frames: &[Vec<u64>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u64(&audioutils::frames_to_interleaved_samples(frames)?)}
68    fn write_frames_f32(&mut self, frames: &[Vec<f32>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&audioutils::frames_to_interleaved_samples(frames)?)}
69    fn write_frames_f64(&mut self, frames: &[Vec<f64>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f64(&audioutils::frames_to_interleaved_samples(frames)?)}
70
71    // Interfaces for writing mono audio frames (single-channel). Default implementations are provided.
72    fn write_mono__i8(&mut self, sample: i8 ) -> Result<(), AudioWriteError> {self.write_interleaved_samples__i8(&(0..self.get_channels()).map(|_|sample).collect::<Vec<i8 >>())}
73    fn write_mono_i16(&mut self, sample: i16) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i16(&(0..self.get_channels()).map(|_|sample).collect::<Vec<i16>>())}
74    fn write_mono_i24(&mut self, sample: i24) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i24(&(0..self.get_channels()).map(|_|sample).collect::<Vec<i24>>())}
75    fn write_mono_i32(&mut self, sample: i32) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i32(&(0..self.get_channels()).map(|_|sample).collect::<Vec<i32>>())}
76    fn write_mono_i64(&mut self, sample: i64) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i64(&(0..self.get_channels()).map(|_|sample).collect::<Vec<i64>>())}
77    fn write_mono__u8(&mut self, sample: u8 ) -> Result<(), AudioWriteError> {self.write_interleaved_samples__u8(&(0..self.get_channels()).map(|_|sample).collect::<Vec<u8 >>())}
78    fn write_mono_u16(&mut self, sample: u16) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u16(&(0..self.get_channels()).map(|_|sample).collect::<Vec<u16>>())}
79    fn write_mono_u24(&mut self, sample: u24) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u24(&(0..self.get_channels()).map(|_|sample).collect::<Vec<u24>>())}
80    fn write_mono_u32(&mut self, sample: u32) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u32(&(0..self.get_channels()).map(|_|sample).collect::<Vec<u32>>())}
81    fn write_mono_u64(&mut self, sample: u64) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u64(&(0..self.get_channels()).map(|_|sample).collect::<Vec<u64>>())}
82    fn write_mono_f32(&mut self, sample: f32) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&(0..self.get_channels()).map(|_|sample).collect::<Vec<f32>>())}
83    fn write_mono_f64(&mut self, sample: f64) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f64(&(0..self.get_channels()).map(|_|sample).collect::<Vec<f64>>())}
84
85    // Interfaces for writing batched mono audio frames. Default implementations are provided.
86    fn write_mono_channel__i8(&mut self, monos: &[i8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples__i8(&monos.iter().map(|mono|(0..self.get_channels()).map(|_|*mono).collect::<Vec<i8 >>()).collect::<Vec<Vec<i8 >>>().into_iter().flatten().collect::<Vec<i8 >>())}
87    fn write_mono_channel_i16(&mut self, monos: &[i16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i16(&monos.iter().map(|mono|(0..self.get_channels()).map(|_|*mono).collect::<Vec<i16>>()).collect::<Vec<Vec<i16>>>().into_iter().flatten().collect::<Vec<i16>>())}
88    fn write_mono_channel_i24(&mut self, monos: &[i24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i24(&monos.iter().map(|mono|(0..self.get_channels()).map(|_|*mono).collect::<Vec<i24>>()).collect::<Vec<Vec<i24>>>().into_iter().flatten().collect::<Vec<i24>>())}
89    fn write_mono_channel_i32(&mut self, monos: &[i32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i32(&monos.iter().map(|mono|(0..self.get_channels()).map(|_|*mono).collect::<Vec<i32>>()).collect::<Vec<Vec<i32>>>().into_iter().flatten().collect::<Vec<i32>>())}
90    fn write_mono_channel_i64(&mut self, monos: &[i64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i64(&monos.iter().map(|mono|(0..self.get_channels()).map(|_|*mono).collect::<Vec<i64>>()).collect::<Vec<Vec<i64>>>().into_iter().flatten().collect::<Vec<i64>>())}
91    fn write_mono_channel__u8(&mut self, monos: &[u8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples__u8(&monos.iter().map(|mono|(0..self.get_channels()).map(|_|*mono).collect::<Vec<u8 >>()).collect::<Vec<Vec<u8 >>>().into_iter().flatten().collect::<Vec<u8 >>())}
92    fn write_mono_channel_u16(&mut self, monos: &[u16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u16(&monos.iter().map(|mono|(0..self.get_channels()).map(|_|*mono).collect::<Vec<u16>>()).collect::<Vec<Vec<u16>>>().into_iter().flatten().collect::<Vec<u16>>())}
93    fn write_mono_channel_u24(&mut self, monos: &[u24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u24(&monos.iter().map(|mono|(0..self.get_channels()).map(|_|*mono).collect::<Vec<u24>>()).collect::<Vec<Vec<u24>>>().into_iter().flatten().collect::<Vec<u24>>())}
94    fn write_mono_channel_u32(&mut self, monos: &[u32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u32(&monos.iter().map(|mono|(0..self.get_channels()).map(|_|*mono).collect::<Vec<u32>>()).collect::<Vec<Vec<u32>>>().into_iter().flatten().collect::<Vec<u32>>())}
95    fn write_mono_channel_u64(&mut self, monos: &[u64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u64(&monos.iter().map(|mono|(0..self.get_channels()).map(|_|*mono).collect::<Vec<u64>>()).collect::<Vec<Vec<u64>>>().into_iter().flatten().collect::<Vec<u64>>())}
96    fn write_mono_channel_f32(&mut self, monos: &[f32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&monos.iter().map(|mono|(0..self.get_channels()).map(|_|*mono).collect::<Vec<f32>>()).collect::<Vec<Vec<f32>>>().into_iter().flatten().collect::<Vec<f32>>())}
97    fn write_mono_channel_f64(&mut self, monos: &[f64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f64(&monos.iter().map(|mono|(0..self.get_channels()).map(|_|*mono).collect::<Vec<f64>>()).collect::<Vec<Vec<f64>>>().into_iter().flatten().collect::<Vec<f64>>())}
98
99    // Interfaces for writing stereo audio (composed of two separate channel buffers). Default implementations are provided.
100    fn write_dual_sample__i8(&mut self, mono1: i8 , mono2: i8 ) -> Result<(), AudioWriteError> {self.write_interleaved_samples__i8(&[mono1, mono2])}
101    fn write_dual_sample_i16(&mut self, mono1: i16, mono2: i16) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i16(&[mono1, mono2])}
102    fn write_dual_sample_i24(&mut self, mono1: i24, mono2: i24) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i24(&[mono1, mono2])}
103    fn write_dual_sample_i32(&mut self, mono1: i32, mono2: i32) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i32(&[mono1, mono2])}
104    fn write_dual_sample_i64(&mut self, mono1: i64, mono2: i64) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i64(&[mono1, mono2])}
105    fn write_dual_sample__u8(&mut self, mono1: u8 , mono2: u8 ) -> Result<(), AudioWriteError> {self.write_interleaved_samples__u8(&[mono1, mono2])}
106    fn write_dual_sample_u16(&mut self, mono1: u16, mono2: u16) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u16(&[mono1, mono2])}
107    fn write_dual_sample_u24(&mut self, mono1: u24, mono2: u24) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u24(&[mono1, mono2])}
108    fn write_dual_sample_u32(&mut self, mono1: u32, mono2: u32) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u32(&[mono1, mono2])}
109    fn write_dual_sample_u64(&mut self, mono1: u64, mono2: u64) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u64(&[mono1, mono2])}
110    fn write_dual_sample_f32(&mut self, mono1: f32, mono2: f32) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&[mono1, mono2])}
111    fn write_dual_sample_f64(&mut self, mono1: f64, mono2: f64) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f64(&[mono1, mono2])}
112
113    // Interfaces for writing batched stereo audio (two separate channel buffers). Default implementations are provided.
114    fn write_dual_monos__i8(&mut self, mono1: &[i8 ], mono2: &[i8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples__i8(&audioutils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
115    fn write_dual_monos_i16(&mut self, mono1: &[i16], mono2: &[i16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i16(&audioutils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
116    fn write_dual_monos_i24(&mut self, mono1: &[i24], mono2: &[i24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i24(&audioutils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
117    fn write_dual_monos_i32(&mut self, mono1: &[i32], mono2: &[i32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i32(&audioutils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
118    fn write_dual_monos_i64(&mut self, mono1: &[i64], mono2: &[i64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i64(&audioutils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
119    fn write_dual_monos__u8(&mut self, mono1: &[u8 ], mono2: &[u8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples__u8(&audioutils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
120    fn write_dual_monos_u16(&mut self, mono1: &[u16], mono2: &[u16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u16(&audioutils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
121    fn write_dual_monos_u24(&mut self, mono1: &[u24], mono2: &[u24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u24(&audioutils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
122    fn write_dual_monos_u32(&mut self, mono1: &[u32], mono2: &[u32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u32(&audioutils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
123    fn write_dual_monos_u64(&mut self, mono1: &[u64], mono2: &[u64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u64(&audioutils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
124    fn write_dual_monos_f32(&mut self, mono1: &[f32], mono2: &[f32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&audioutils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
125    fn write_dual_monos_f64(&mut self, mono1: &[f64], mono2: &[f64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f64(&audioutils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
126
127    // Interfaces for writing batched stereo audio (two separate channel buffers). Default implementations are provided.
128    fn write_monos__i8(&mut self, monos_array: &[Vec<i8 >]) -> Result<(), AudioWriteError> {self.write_interleaved_samples__i8(&audioutils::monos_to_interleaved_samples(monos_array)?)}
129    fn write_monos_i16(&mut self, monos_array: &[Vec<i16>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i16(&audioutils::monos_to_interleaved_samples(monos_array)?)}
130    fn write_monos_i24(&mut self, monos_array: &[Vec<i24>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i24(&audioutils::monos_to_interleaved_samples(monos_array)?)}
131    fn write_monos_i32(&mut self, monos_array: &[Vec<i32>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i32(&audioutils::monos_to_interleaved_samples(monos_array)?)}
132    fn write_monos_i64(&mut self, monos_array: &[Vec<i64>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i64(&audioutils::monos_to_interleaved_samples(monos_array)?)}
133    fn write_monos__u8(&mut self, monos_array: &[Vec<u8 >]) -> Result<(), AudioWriteError> {self.write_interleaved_samples__u8(&audioutils::monos_to_interleaved_samples(monos_array)?)}
134    fn write_monos_u16(&mut self, monos_array: &[Vec<u16>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u16(&audioutils::monos_to_interleaved_samples(monos_array)?)}
135    fn write_monos_u24(&mut self, monos_array: &[Vec<u24>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u24(&audioutils::monos_to_interleaved_samples(monos_array)?)}
136    fn write_monos_u32(&mut self, monos_array: &[Vec<u32>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u32(&audioutils::monos_to_interleaved_samples(monos_array)?)}
137    fn write_monos_u64(&mut self, monos_array: &[Vec<u64>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u64(&audioutils::monos_to_interleaved_samples(monos_array)?)}
138    fn write_monos_f32(&mut self, monos_array: &[Vec<f32>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&audioutils::monos_to_interleaved_samples(monos_array)?)}
139    fn write_monos_f64(&mut self, monos_array: &[Vec<f64>]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f64(&audioutils::monos_to_interleaved_samples(monos_array)?)}
140
141    // Interfaces for writing stereo audio frames using tuples (L, R). Default implementations are provided.
142    fn write_stereo__i8(&mut self, stereo: (i8 , i8 )) -> Result<(), AudioWriteError> {self.write_interleaved_samples__i8(&[stereo.0, stereo.1])}
143    fn write_stereo_i16(&mut self, stereo: (i16, i16)) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i16(&[stereo.0, stereo.1])}
144    fn write_stereo_i24(&mut self, stereo: (i24, i24)) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i24(&[stereo.0, stereo.1])}
145    fn write_stereo_i32(&mut self, stereo: (i32, i32)) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i32(&[stereo.0, stereo.1])}
146    fn write_stereo_i64(&mut self, stereo: (i64, i64)) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i64(&[stereo.0, stereo.1])}
147    fn write_stereo__u8(&mut self, stereo: (u8 , u8 )) -> Result<(), AudioWriteError> {self.write_interleaved_samples__u8(&[stereo.0, stereo.1])}
148    fn write_stereo_u16(&mut self, stereo: (u16, u16)) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u16(&[stereo.0, stereo.1])}
149    fn write_stereo_u24(&mut self, stereo: (u24, u24)) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u24(&[stereo.0, stereo.1])}
150    fn write_stereo_u32(&mut self, stereo: (u32, u32)) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u32(&[stereo.0, stereo.1])}
151    fn write_stereo_u64(&mut self, stereo: (u64, u64)) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u64(&[stereo.0, stereo.1])}
152    fn write_stereo_f32(&mut self, stereo: (f32, f32)) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&[stereo.0, stereo.1])}
153    fn write_stereo_f64(&mut self, stereo: (f64, f64)) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f64(&[stereo.0, stereo.1])}
154
155    // Interfaces for writing stereo audio frames using arrays of tuples. Default implementations are provided.
156    fn write_stereos__i8(&mut self, stereos: &[(i8 , i8 )]) -> Result<(), AudioWriteError> {self.write_interleaved_samples__i8(&audioutils::stereos_to_interleaved_samples(stereos))}
157    fn write_stereos_i16(&mut self, stereos: &[(i16, i16)]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i16(&audioutils::stereos_to_interleaved_samples(stereos))}
158    fn write_stereos_i24(&mut self, stereos: &[(i24, i24)]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i24(&audioutils::stereos_to_interleaved_samples(stereos))}
159    fn write_stereos_i32(&mut self, stereos: &[(i32, i32)]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i32(&audioutils::stereos_to_interleaved_samples(stereos))}
160    fn write_stereos_i64(&mut self, stereos: &[(i64, i64)]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_i64(&audioutils::stereos_to_interleaved_samples(stereos))}
161    fn write_stereos__u8(&mut self, stereos: &[(u8 , u8 )]) -> Result<(), AudioWriteError> {self.write_interleaved_samples__u8(&audioutils::stereos_to_interleaved_samples(stereos))}
162    fn write_stereos_u16(&mut self, stereos: &[(u16, u16)]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u16(&audioutils::stereos_to_interleaved_samples(stereos))}
163    fn write_stereos_u24(&mut self, stereos: &[(u24, u24)]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u24(&audioutils::stereos_to_interleaved_samples(stereos))}
164    fn write_stereos_u32(&mut self, stereos: &[(u32, u32)]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u32(&audioutils::stereos_to_interleaved_samples(stereos))}
165    fn write_stereos_u64(&mut self, stereos: &[(u64, u64)]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_u64(&audioutils::stereos_to_interleaved_samples(stereos))}
166    fn write_stereos_f32(&mut self, stereos: &[(f32, f32)]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&audioutils::stereos_to_interleaved_samples(stereos))}
167    fn write_stereos_f64(&mut self, stereos: &[(f64, f64)]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f64(&audioutils::stereos_to_interleaved_samples(stereos))}
168}
169
170/// * The `DummyEncoder` is not for you to use, it allows me to implement `Default` for `Encoder<'a>`
171#[derive(Debug, Clone, Copy)]
172pub struct DummyEncoder;
173
174/// * Default implementations: all functions are `panic!`
175impl EncoderToImpl for DummyEncoder {
176    fn get_channels(&self) -> u16 {
177        panic!("Encoder creation failed.");
178    }
179
180    fn get_max_channels(&self) -> u16 {
181        panic!("Encoder creation failed.");
182    }
183
184    fn get_bitrate(&self) -> u32 {
185        panic!("Encoder creation failed.");
186    }
187
188    fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
189        panic!("Encoder creation failed.");
190    }
191
192    fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
193        panic!("Encoder creation failed.");
194    }
195
196    fn update_fmt_chunk(&self, _fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
197        panic!("Encoder creation failed.");
198    }
199
200    fn finish(&mut self) -> Result<(), AudioWriteError> {
201        panic!("Encoder creation failed.");
202    }
203
204    fn write_interleaved_samples_f32(&mut self, _samples: &[f32]) -> Result<(), AudioWriteError> {
205        panic!("Encoder creation failed.");
206    }
207
208    fn write_interleaved_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&sample_conv(samples))}
209    fn write_interleaved_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&sample_conv(samples))}
210    fn write_interleaved_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&sample_conv(samples))}
211    fn write_interleaved_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&sample_conv(samples))}
212    fn write_interleaved_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&sample_conv(samples))}
213    fn write_interleaved_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&sample_conv(samples))}
214    fn write_interleaved_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&sample_conv(samples))}
215    fn write_interleaved_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&sample_conv(samples))}
216    fn write_interleaved_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&sample_conv(samples))}
217    fn write_interleaved_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&sample_conv(samples))}
218    fn write_interleaved_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples_f32(&sample_conv(samples))}
219}
220
221/// * The `Encoder` struct contains all of the encoder types and provides convenient functions that have generic type parameters.
222/// * It just translates the API to the inner encoder API.
223#[derive(Debug)]
224pub struct Encoder<'a> {
225    encoder: Box<dyn EncoderToImpl + 'a>,
226}
227
228impl Default for Encoder<'_> {
229    fn default() -> Self {
230        Self::new(DummyEncoder)
231    }
232}
233
234impl<'a> Encoder<'a> {
235    pub fn new<T>(encoder: T) -> Self
236    where
237        T: EncoderToImpl + 'a,
238    {
239        Self {
240            encoder: Box::new(encoder),
241        }
242    }
243
244    pub fn get_channels(&self) -> u16 {
245        self.encoder.get_channels()
246    }
247
248    pub fn get_max_channels(&self) -> u16 {
249        self.encoder.get_max_channels()
250    }
251
252    pub fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
253        self.encoder.begin_encoding()
254    }
255
256    pub fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
257        self.encoder.new_fmt_chunk()
258    }
259
260    pub fn get_bitrate(&self) -> u32 {
261        self.encoder.get_bitrate()
262    }
263
264    pub fn update_fmt_chunk(&self, fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
265        self.encoder.update_fmt_chunk(fmt)
266    }
267
268    pub fn finish(&mut self) -> Result<(), AudioWriteError> {
269        self.encoder.finish()
270    }
271
272    /// * Write samples regardless of channels
273    pub fn write_interleaved_samples<S>(&mut self, samples: &[S]) -> Result<(), AudioWriteError>
274    where
275        S: SampleType,
276    {
277        match S::TYPE_NAME {
278            "i8"  => self.encoder.write_interleaved_samples__i8(&sample_conv(samples)),
279            "i16" => self.encoder.write_interleaved_samples_i16(&sample_conv(samples)),
280            "i24" => self.encoder.write_interleaved_samples_i24(&sample_conv(samples)),
281            "i32" => self.encoder.write_interleaved_samples_i32(&sample_conv(samples)),
282            "i64" => self.encoder.write_interleaved_samples_i64(&sample_conv(samples)),
283            "u8"  => self.encoder.write_interleaved_samples__u8(&sample_conv(samples)),
284            "u16" => self.encoder.write_interleaved_samples_u16(&sample_conv(samples)),
285            "u24" => self.encoder.write_interleaved_samples_u24(&sample_conv(samples)),
286            "u32" => self.encoder.write_interleaved_samples_u32(&sample_conv(samples)),
287            "u64" => self.encoder.write_interleaved_samples_u64(&sample_conv(samples)),
288            "f32" => self.encoder.write_interleaved_samples_f32(&sample_conv(samples)),
289            "f64" => self.encoder.write_interleaved_samples_f64(&sample_conv(samples)),
290            other => Err(AudioWriteError::InvalidArguments(format!(
291                "Bad sample type: {}",
292                other
293            ))),
294        }
295    }
296
297    /// * Write an audio frame, each frame contains one sample for all channels
298    pub fn write_frame<S>(&mut self, frame: &[S]) -> Result<(), AudioWriteError>
299    where
300        S: SampleType,
301    {
302        match S::TYPE_NAME {
303            "i8"  => self.encoder.write_frame__i8(&sample_conv(frame)),
304            "i16" => self.encoder.write_frame_i16(&sample_conv(frame)),
305            "i24" => self.encoder.write_frame_i24(&sample_conv(frame)),
306            "i32" => self.encoder.write_frame_i32(&sample_conv(frame)),
307            "i64" => self.encoder.write_frame_i64(&sample_conv(frame)),
308            "u8"  => self.encoder.write_frame__u8(&sample_conv(frame)),
309            "u16" => self.encoder.write_frame_u16(&sample_conv(frame)),
310            "u24" => self.encoder.write_frame_u24(&sample_conv(frame)),
311            "u32" => self.encoder.write_frame_u32(&sample_conv(frame)),
312            "u64" => self.encoder.write_frame_u64(&sample_conv(frame)),
313            "f32" => self.encoder.write_frame_f32(&sample_conv(frame)),
314            "f64" => self.encoder.write_frame_f64(&sample_conv(frame)),
315            other => Err(AudioWriteError::InvalidArguments(format!(
316                "Bad sample type: {}",
317                other
318            ))),
319        }
320    }
321
322    /// * Write audio frames, each frame contains one sample for all channels
323    pub fn write_frames<S>(&mut self, frames: &[Vec<S>]) -> Result<(), AudioWriteError>
324    where
325        S: SampleType,
326    {
327        match S::TYPE_NAME {
328            "i8"  => self.encoder.write_frames__i8(&sample_conv_batch(frames)),
329            "i16" => self.encoder.write_frames_i16(&sample_conv_batch(frames)),
330            "i24" => self.encoder.write_frames_i24(&sample_conv_batch(frames)),
331            "i32" => self.encoder.write_frames_i32(&sample_conv_batch(frames)),
332            "i64" => self.encoder.write_frames_i64(&sample_conv_batch(frames)),
333            "u8"  => self.encoder.write_frames__u8(&sample_conv_batch(frames)),
334            "u16" => self.encoder.write_frames_u16(&sample_conv_batch(frames)),
335            "u24" => self.encoder.write_frames_u24(&sample_conv_batch(frames)),
336            "u32" => self.encoder.write_frames_u32(&sample_conv_batch(frames)),
337            "u64" => self.encoder.write_frames_u64(&sample_conv_batch(frames)),
338            "f32" => self.encoder.write_frames_f32(&sample_conv_batch(frames)),
339            "f64" => self.encoder.write_frames_f64(&sample_conv_batch(frames)),
340            other => Err(AudioWriteError::InvalidArguments(format!(
341                "Bad sample type: {}",
342                other
343            ))),
344        }
345    }
346
347    /// * Write only one sample regardless of channels
348    pub fn write_sample<S>(&mut self, mono: S) -> Result<(), AudioWriteError>
349    where
350        S: SampleType,
351    {
352        match S::TYPE_NAME {
353            "i8"  => self.encoder.write_mono__i8(mono.to_i8 ()),
354            "i16" => self.encoder.write_mono_i16(mono.to_i16()),
355            "i24" => self.encoder.write_mono_i24(mono.to_i24()),
356            "i32" => self.encoder.write_mono_i32(mono.to_i32()),
357            "i64" => self.encoder.write_mono_i64(mono.to_i64()),
358            "u8"  => self.encoder.write_mono__u8(mono.to_u8 ()),
359            "u16" => self.encoder.write_mono_u16(mono.to_u16()),
360            "u24" => self.encoder.write_mono_u24(mono.to_u24()),
361            "u32" => self.encoder.write_mono_u32(mono.to_u32()),
362            "u64" => self.encoder.write_mono_u64(mono.to_u64()),
363            "f32" => self.encoder.write_mono_f32(mono.to_f32()),
364            "f64" => self.encoder.write_mono_f64(mono.to_f64()),
365            other => Err(AudioWriteError::InvalidArguments(format!(
366                "Bad sample type: {}",
367                other
368            ))),
369        }
370    }
371
372    /// * Write a single channel of audio to the encoder
373    pub fn write_mono<S>(&mut self, monos: S) -> Result<(), AudioWriteError>
374    where
375        S: SampleType,
376    {
377        match S::TYPE_NAME {
378            "i8"  => self.encoder.write_mono__i8(monos.as_i8 ()),
379            "i16" => self.encoder.write_mono_i16(monos.as_i16()),
380            "i24" => self.encoder.write_mono_i24(monos.as_i24()),
381            "i32" => self.encoder.write_mono_i32(monos.as_i32()),
382            "i64" => self.encoder.write_mono_i64(monos.as_i64()),
383            "u8"  => self.encoder.write_mono__u8(monos.as_u8 ()),
384            "u16" => self.encoder.write_mono_u16(monos.as_u16()),
385            "u24" => self.encoder.write_mono_u24(monos.as_u24()),
386            "u32" => self.encoder.write_mono_u32(monos.as_u32()),
387            "u64" => self.encoder.write_mono_u64(monos.as_u64()),
388            "f32" => self.encoder.write_mono_f32(monos.as_f32()),
389            "f64" => self.encoder.write_mono_f64(monos.as_f64()),
390            other => Err(AudioWriteError::InvalidArguments(format!(
391                "Bad sample type: {}",
392                other
393            ))),
394        }
395    }
396
397    /// * Write a single channel of audio to the encoder
398    pub fn write_mono_channel<S>(&mut self, monos: &[S]) -> Result<(), AudioWriteError>
399    where
400        S: SampleType,
401    {
402        match S::TYPE_NAME {
403            "i8"  => self.encoder.write_mono_channel__i8(&sample_conv(monos)),
404            "i16" => self.encoder.write_mono_channel_i16(&sample_conv(monos)),
405            "i24" => self.encoder.write_mono_channel_i24(&sample_conv(monos)),
406            "i32" => self.encoder.write_mono_channel_i32(&sample_conv(monos)),
407            "i64" => self.encoder.write_mono_channel_i64(&sample_conv(monos)),
408            "u8"  => self.encoder.write_mono_channel__u8(&sample_conv(monos)),
409            "u16" => self.encoder.write_mono_channel_u16(&sample_conv(monos)),
410            "u24" => self.encoder.write_mono_channel_u24(&sample_conv(monos)),
411            "u32" => self.encoder.write_mono_channel_u32(&sample_conv(monos)),
412            "u64" => self.encoder.write_mono_channel_u64(&sample_conv(monos)),
413            "f32" => self.encoder.write_mono_channel_f32(&sample_conv(monos)),
414            "f64" => self.encoder.write_mono_channel_f64(&sample_conv(monos)),
415            other => Err(AudioWriteError::InvalidArguments(format!(
416                "Bad sample type: {}",
417                other
418            ))),
419        }
420    }
421
422    /// * Write double samples of audio to the encoder
423    pub fn write_dual_mono<S>(&mut self, mono1: S, mono2: S) -> Result<(), AudioWriteError>
424    where
425        S: SampleType,
426    {
427        match S::TYPE_NAME {
428            "i8"  => self.encoder.write_dual_sample__i8(mono1.to_i8 (), mono2.to_i8 ()),
429            "i16" => self.encoder.write_dual_sample_i16(mono1.to_i16(), mono2.to_i16()),
430            "i24" => self.encoder.write_dual_sample_i24(mono1.to_i24(), mono2.to_i24()),
431            "i32" => self.encoder.write_dual_sample_i32(mono1.to_i32(), mono2.to_i32()),
432            "i64" => self.encoder.write_dual_sample_i64(mono1.to_i64(), mono2.to_i64()),
433            "u8"  => self.encoder.write_dual_sample__u8(mono1.to_u8 (), mono2.to_u8 ()),
434            "u16" => self.encoder.write_dual_sample_u16(mono1.to_u16(), mono2.to_u16()),
435            "u24" => self.encoder.write_dual_sample_u24(mono1.to_u24(), mono2.to_u24()),
436            "u32" => self.encoder.write_dual_sample_u32(mono1.to_u32(), mono2.to_u32()),
437            "u64" => self.encoder.write_dual_sample_u64(mono1.to_u64(), mono2.to_u64()),
438            "f32" => self.encoder.write_dual_sample_f32(mono1.to_f32(), mono2.to_f32()),
439            "f64" => self.encoder.write_dual_sample_f64(mono1.to_f64(), mono2.to_f64()),
440            other => Err(AudioWriteError::InvalidArguments(format!(
441                "Bad sample type: {}",
442                other
443            ))),
444        }
445    }
446
447    /// * Write double channels of audio to the encoder
448    pub fn write_dual_monos<S>(&mut self, mono1: &[S], mono2: &[S]) -> Result<(), AudioWriteError>
449    where
450        S: SampleType,
451    {
452        match S::TYPE_NAME {
453            "i8"  => self.encoder.write_dual_monos__i8(&sample_conv(mono1), &sample_conv(mono2)),
454            "i16" => self.encoder.write_dual_monos_i16(&sample_conv(mono1), &sample_conv(mono2)),
455            "i24" => self.encoder.write_dual_monos_i24(&sample_conv(mono1), &sample_conv(mono2)),
456            "i32" => self.encoder.write_dual_monos_i32(&sample_conv(mono1), &sample_conv(mono2)),
457            "i64" => self.encoder.write_dual_monos_i64(&sample_conv(mono1), &sample_conv(mono2)),
458            "u8"  => self.encoder.write_dual_monos__u8(&sample_conv(mono1), &sample_conv(mono2)),
459            "u16" => self.encoder.write_dual_monos_u16(&sample_conv(mono1), &sample_conv(mono2)),
460            "u24" => self.encoder.write_dual_monos_u24(&sample_conv(mono1), &sample_conv(mono2)),
461            "u32" => self.encoder.write_dual_monos_u32(&sample_conv(mono1), &sample_conv(mono2)),
462            "u64" => self.encoder.write_dual_monos_u64(&sample_conv(mono1), &sample_conv(mono2)),
463            "f32" => self.encoder.write_dual_monos_f32(&sample_conv(mono1), &sample_conv(mono2)),
464            "f64" => self.encoder.write_dual_monos_f64(&sample_conv(mono1), &sample_conv(mono2)),
465            other => Err(AudioWriteError::InvalidArguments(format!(
466                "Bad sample type: {}",
467                other
468            ))),
469        }
470    }
471
472    /// * Write multiple channels of audio to the encoder
473    pub fn write_monos<S>(&mut self, monos: &[Vec<S>]) -> Result<(), AudioWriteError>
474    where
475        S: SampleType,
476    {
477        match S::TYPE_NAME {
478            "i8"  => self.encoder.write_monos__i8(&sample_conv_batch(monos)),
479            "i16" => self.encoder.write_monos_i16(&sample_conv_batch(monos)),
480            "i24" => self.encoder.write_monos_i24(&sample_conv_batch(monos)),
481            "i32" => self.encoder.write_monos_i32(&sample_conv_batch(monos)),
482            "i64" => self.encoder.write_monos_i64(&sample_conv_batch(monos)),
483            "u8"  => self.encoder.write_monos__u8(&sample_conv_batch(monos)),
484            "u16" => self.encoder.write_monos_u16(&sample_conv_batch(monos)),
485            "u24" => self.encoder.write_monos_u24(&sample_conv_batch(monos)),
486            "u32" => self.encoder.write_monos_u32(&sample_conv_batch(monos)),
487            "u64" => self.encoder.write_monos_u64(&sample_conv_batch(monos)),
488            "f32" => self.encoder.write_monos_f32(&sample_conv_batch(monos)),
489            "f64" => self.encoder.write_monos_f64(&sample_conv_batch(monos)),
490            other => Err(AudioWriteError::InvalidArguments(format!(
491                "Bad sample type: {}",
492                other
493            ))),
494        }
495    }
496
497    /// * Write only one stereo sample to the encoder
498    pub fn write_stereo<S>(&mut self, stereo: (S, S)) -> Result<(), AudioWriteError>
499    where
500        S: SampleType,
501    {
502        match S::TYPE_NAME {
503            "i8"  => self.encoder.write_stereo__i8(stereo_conv(stereo)),
504            "i16" => self.encoder.write_stereo_i16(stereo_conv(stereo)),
505            "i24" => self.encoder.write_stereo_i24(stereo_conv(stereo)),
506            "i32" => self.encoder.write_stereo_i32(stereo_conv(stereo)),
507            "i64" => self.encoder.write_stereo_i64(stereo_conv(stereo)),
508            "u8"  => self.encoder.write_stereo__u8(stereo_conv(stereo)),
509            "u16" => self.encoder.write_stereo_u16(stereo_conv(stereo)),
510            "u24" => self.encoder.write_stereo_u24(stereo_conv(stereo)),
511            "u32" => self.encoder.write_stereo_u32(stereo_conv(stereo)),
512            "u64" => self.encoder.write_stereo_u64(stereo_conv(stereo)),
513            "f32" => self.encoder.write_stereo_f32(stereo_conv(stereo)),
514            "f64" => self.encoder.write_stereo_f64(stereo_conv(stereo)),
515            other => Err(AudioWriteError::InvalidArguments(format!(
516                "Bad sample type: {}",
517                other
518            ))),
519        }
520    }
521
522    /// * Write stereo samples to the encoder
523    pub fn write_stereos<S>(&mut self, stereos: &[(S, S)]) -> Result<(), AudioWriteError>
524    where
525        S: SampleType,
526    {
527        match S::TYPE_NAME {
528            "i8"  => self.encoder.write_stereos__i8(&stereos_conv(stereos)),
529            "i16" => self.encoder.write_stereos_i16(&stereos_conv(stereos)),
530            "i24" => self.encoder.write_stereos_i24(&stereos_conv(stereos)),
531            "i32" => self.encoder.write_stereos_i32(&stereos_conv(stereos)),
532            "i64" => self.encoder.write_stereos_i64(&stereos_conv(stereos)),
533            "u8"  => self.encoder.write_stereos__u8(&stereos_conv(stereos)),
534            "u16" => self.encoder.write_stereos_u16(&stereos_conv(stereos)),
535            "u24" => self.encoder.write_stereos_u24(&stereos_conv(stereos)),
536            "u32" => self.encoder.write_stereos_u32(&stereos_conv(stereos)),
537            "u64" => self.encoder.write_stereos_u64(&stereos_conv(stereos)),
538            "f32" => self.encoder.write_stereos_f32(&stereos_conv(stereos)),
539            "f64" => self.encoder.write_stereos_f64(&stereos_conv(stereos)),
540            other => Err(AudioWriteError::InvalidArguments(format!(
541                "Bad sample type: {}",
542                other
543            ))),
544        }
545    }
546}
547
548/// * `PcmEncoderFrom<S>`: Transcodes samples from type `S` into the target format.
549/// * This is a component for the `PcmEncoder`
550#[derive(Debug, Clone, Copy)]
551struct PcmEncoderFrom<S>
552where
553    S: SampleType,
554{
555    write_fn: fn(&mut dyn Writer, frame: &[S]) -> Result<(), AudioWriteError>,
556}
557
558impl<S> PcmEncoderFrom<S>
559where
560    S: SampleType,
561{
562    pub fn new(target_sample: WaveSampleType) -> Result<Self, AudioWriteError> {
563        use WaveSampleType::{F32, F64, S8, S16, S24, S32, S64, U8, U16, U24, U32, U64};
564        Ok(Self {
565            write_fn: match target_sample {
566                S8  => Self::write_sample_to::<i8 >,
567                S16 => Self::write_sample_to::<i16>,
568                S24 => Self::write_sample_to::<i24>,
569                S32 => Self::write_sample_to::<i32>,
570                S64 => Self::write_sample_to::<i64>,
571                U8  => Self::write_sample_to::<u8 >,
572                U16 => Self::write_sample_to::<u16>,
573                U24 => Self::write_sample_to::<u24>,
574                U32 => Self::write_sample_to::<u32>,
575                U64 => Self::write_sample_to::<u64>,
576                F32 => Self::write_sample_to::<f32>,
577                F64 => Self::write_sample_to::<f64>,
578                other => {
579                    return Err(AudioWriteError::InvalidArguments(format!(
580                        "Unknown target sample type: \"{:?}\"",
581                        other
582                    )));
583                }
584            },
585        })
586    }
587
588    /// S: The input format provided to us (external source).
589    /// T: The target format to be written into the WAV file.
590    fn write_sample_to<T>(writer: &mut dyn Writer, frame: &[S]) -> Result<(), AudioWriteError>
591    where
592        T: SampleType,
593    {
594        for sample in frame.iter() {
595            T::scale_from(*sample).write_le(writer)?;
596        }
597        Ok(())
598    }
599
600    pub fn write_frame(
601        &mut self,
602        writer: &mut dyn Writer,
603        frame: &[S],
604    ) -> Result<(), AudioWriteError> {
605        (self.write_fn)(writer, frame)
606    }
607
608    pub fn write_frames(
609        &mut self,
610        writer: &mut dyn Writer,
611        frames: &[Vec<S>],
612    ) -> Result<(), AudioWriteError> {
613        for frame in frames.iter() {
614            (self.write_fn)(writer, frame)?;
615        }
616        Ok(())
617    }
618
619    pub fn write_interleaved_samples(
620        &mut self,
621        writer: &mut dyn Writer,
622        samples: &[S],
623    ) -> Result<(), AudioWriteError> {
624        (self.write_fn)(writer, samples)
625    }
626}
627
628/// * `PcmEncoder`: convert various formats of PCM samples to the WAV file specific sample type
629#[derive(Debug)]
630pub struct PcmEncoder<'a> {
631    spec: Spec,
632    sample_type: WaveSampleType,
633    writer: &'a mut dyn Writer,
634    writer_from__i8: PcmEncoderFrom< i8>,
635    writer_from_i16: PcmEncoderFrom<i16>,
636    writer_from_i24: PcmEncoderFrom<i24>,
637    writer_from_i32: PcmEncoderFrom<i32>,
638    writer_from_i64: PcmEncoderFrom<i64>,
639    writer_from__u8: PcmEncoderFrom< u8>,
640    writer_from_u16: PcmEncoderFrom<u16>,
641    writer_from_u24: PcmEncoderFrom<u24>,
642    writer_from_u32: PcmEncoderFrom<u32>,
643    writer_from_u64: PcmEncoderFrom<u64>,
644    writer_from_f32: PcmEncoderFrom<f32>,
645    writer_from_f64: PcmEncoderFrom<f64>,
646}
647
648impl<'a> PcmEncoder<'a> {
649    /// * target_sample: The specific PCM format (e.g., bit depth, signedness) to encode into the WAV file.
650    pub fn new(writer: &'a mut dyn Writer, spec: Spec) -> Result<Self, AudioWriteError> {
651        if !spec.is_channel_mask_valid() {
652            return Err(AudioWriteError::InvalidArguments(format!(
653                "Number of bits of channel mask 0x{:08x} does not match {} channels",
654                spec.channel_mask, spec.channels
655            )));
656        }
657        let target_sample = spec.get_sample_type();
658        Ok(Self {
659            spec,
660            sample_type: target_sample,
661            writer,
662            writer_from__i8: PcmEncoderFrom::< i8>::new(target_sample)?,
663            writer_from_i16: PcmEncoderFrom::<i16>::new(target_sample)?,
664            writer_from_i24: PcmEncoderFrom::<i24>::new(target_sample)?,
665            writer_from_i32: PcmEncoderFrom::<i32>::new(target_sample)?,
666            writer_from_i64: PcmEncoderFrom::<i64>::new(target_sample)?,
667            writer_from__u8: PcmEncoderFrom::< u8>::new(target_sample)?,
668            writer_from_u16: PcmEncoderFrom::<u16>::new(target_sample)?,
669            writer_from_u24: PcmEncoderFrom::<u24>::new(target_sample)?,
670            writer_from_u32: PcmEncoderFrom::<u32>::new(target_sample)?,
671            writer_from_u64: PcmEncoderFrom::<u64>::new(target_sample)?,
672            writer_from_f32: PcmEncoderFrom::<f32>::new(target_sample)?,
673            writer_from_f64: PcmEncoderFrom::<f64>::new(target_sample)?,
674        })
675    }
676}
677
678impl EncoderToImpl for PcmEncoder<'_> {
679    fn get_channels(&self) -> u16 {
680        self.spec.channels
681    }
682
683    fn get_max_channels(&self) -> u16 {
684        18
685    }
686
687    fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
688        Ok(())
689    }
690
691    fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
692        use WaveSampleType::{F32, F64, S8, S16, S24, S32, S64, U8, U16, U24, U32, U64, Unknown};
693        let bytes_per_sample = self.spec.bits_per_sample / 8;
694        let byte_rate = self.spec.sample_rate * self.spec.channels as u32 * bytes_per_sample as u32;
695        let extensible = match self.spec.channel_mask {
696            0 => None,
697            channel_mask => Some(FmtExtension::new_extensible(ExtensibleData {
698                valid_bits_per_sample: self.spec.bits_per_sample,
699                channel_mask,
700                sub_format: match self.sample_type {
701                    U8 | S16 | S24 | S32 | S64 => GUID_PCM_FORMAT,
702                    F32 | F64 => GUID_IEEE_FLOAT_FORMAT,
703                    other => {
704                        return Err(AudioWriteError::Unsupported(format!(
705                            "\"{:?}\" was given for the extensible format PCM to specify the sample format",
706                            other
707                        )));
708                    }
709                },
710            })),
711        };
712        Ok(FmtChunk {
713            format_tag: if extensible.is_some() {
714                FORMAT_TAG_EXTENSIBLE
715            } else {
716                match self.sample_type {
717                    S8 | U16 | U24 | U32 | U64 => {
718                        return Err(AudioWriteError::Unsupported(format!(
719                            "PCM format does not support {} samples.",
720                            self.sample_type
721                        )));
722                    }
723                    U8 | S16 | S24 | S32 | S64 => FORMAT_TAG_PCM,
724                    F32 | F64 => FORMAT_TAG_PCM_IEEE,
725                    Unknown => panic!("Can't encode \"Unknown\" format to PCM."),
726                }
727            },
728            channels: self.spec.channels,
729            sample_rate: self.spec.sample_rate,
730            byte_rate,
731            block_align: bytes_per_sample * self.spec.channels,
732            bits_per_sample: self.spec.bits_per_sample,
733            extension: extensible,
734        })
735    }
736
737    fn get_bitrate(&self) -> u32 {
738        self.spec.channels as u32 * self.spec.sample_rate * self.sample_type.sizeof() as u32 * 8
739    }
740
741    fn update_fmt_chunk(&self, _fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
742        Ok(())
743    }
744
745    fn finish(&mut self) -> Result<(), AudioWriteError> {
746        Ok(self.writer.flush()?)
747    }
748
749    fn write_interleaved_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.writer_from__i8.write_interleaved_samples(self.writer, samples)}
750    fn write_interleaved_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.writer_from_i16.write_interleaved_samples(self.writer, samples)}
751    fn write_interleaved_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.writer_from_i24.write_interleaved_samples(self.writer, samples)}
752    fn write_interleaved_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.writer_from_i32.write_interleaved_samples(self.writer, samples)}
753    fn write_interleaved_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.writer_from_i64.write_interleaved_samples(self.writer, samples)}
754    fn write_interleaved_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.writer_from__u8.write_interleaved_samples(self.writer, samples)}
755    fn write_interleaved_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.writer_from_u16.write_interleaved_samples(self.writer, samples)}
756    fn write_interleaved_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.writer_from_u24.write_interleaved_samples(self.writer, samples)}
757    fn write_interleaved_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.writer_from_u32.write_interleaved_samples(self.writer, samples)}
758    fn write_interleaved_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.writer_from_u64.write_interleaved_samples(self.writer, samples)}
759    fn write_interleaved_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {self.writer_from_f32.write_interleaved_samples(self.writer, samples)}
760    fn write_interleaved_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.writer_from_f64.write_interleaved_samples(self.writer, samples)}
761}
762
763/// * `AdpcmEncoderWrap<E>`: encode `i16` audio samples to ADPCM nibbles
764#[derive(Debug)]
765pub struct AdpcmEncoderWrap<'a, E>
766where
767    E: adpcm::AdpcmEncoder,
768{
769    writer: &'a mut dyn Writer,
770    channels: u16,
771    sample_rate: u32,
772    bytes_written: u64,
773    encoder: E,
774    nibbles: Vec<u8>,
775}
776
777const MAX_BUFFER_USAGE: usize = 1024;
778
779impl<'a, E> AdpcmEncoderWrap<'a, E>
780where
781    E: adpcm::AdpcmEncoder,
782{
783    pub fn new(writer: &'a mut dyn Writer, spec: Spec) -> Result<Self, AudioWriteError> {
784        Ok(Self {
785            writer,
786            channels: spec.channels,
787            sample_rate: spec.sample_rate,
788            bytes_written: 0,
789            encoder: E::new(spec.channels)?,
790            nibbles: Vec::<u8>::with_capacity(MAX_BUFFER_USAGE),
791        })
792    }
793
794    fn flush_buffers(&mut self) -> Result<(), AudioWriteError> {
795        self.writer.write_all(&self.nibbles)?;
796
797        // Avoid using `clear()`. If a user writes a large batch of samples once,
798        // `clear()` retains the original capacity without shrinking it, leading to persistent memory usage.
799        self.nibbles = Vec::<u8>::with_capacity(MAX_BUFFER_USAGE);
800        Ok(())
801    }
802
803    pub fn write_interleaved_samples(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {
804        let mut iter = samples.iter().copied();
805        self.encoder.encode(
806            || -> Option<i16> { iter.next() },
807            |byte: u8| {
808                self.nibbles.push(byte);
809            },
810        )?;
811        if self.nibbles.len() >= MAX_BUFFER_USAGE {
812            self.flush_buffers()?;
813        }
814        Ok(())
815    }
816
817    pub fn write_stereos(&mut self, stereos: &[(i16, i16)]) -> Result<(), AudioWriteError> {
818        if self.channels != 2 {
819            return Err(AudioWriteError::Unsupported(format!(
820                "This encoder only accepts {} channel audio data",
821                self.channels
822            )));
823        }
824        let mut iter = audioutils::stereos_to_interleaved_samples(stereos).into_iter();
825        self.encoder.encode(
826            || -> Option<i16> { iter.next() },
827            |byte: u8| {
828                self.nibbles.push(byte);
829            },
830        )?;
831        if self.nibbles.len() >= MAX_BUFFER_USAGE {
832            self.flush_buffers()?;
833        }
834        Ok(())
835    }
836}
837
838impl<E> EncoderToImpl for AdpcmEncoderWrap<'_, E>
839where
840    E: adpcm::AdpcmEncoder,
841{
842    fn get_channels(&self) -> u16 {
843        self.channels
844    }
845
846    fn get_max_channels(&self) -> u16 {
847        2
848    }
849
850    fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
851        Ok(())
852    }
853
854    fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
855        Ok(self
856            .encoder
857            .new_fmt_chunk(self.channels, self.sample_rate, 4)?)
858    }
859
860    fn get_bitrate(&self) -> u32 {
861        self.sample_rate * self.channels as u32 * 4
862    }
863
864    fn update_fmt_chunk(&self, fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
865        Ok(self.encoder.modify_fmt_chunk(fmt)?)
866    }
867
868    fn finish(&mut self) -> Result<(), AudioWriteError> {
869        self.encoder.flush(|nibble: u8| {
870            self.nibbles.push(nibble);
871        })?;
872        self.flush_buffers()?;
873        Ok(self.writer.flush()?)
874    }
875
876    fn write_interleaved_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
877    fn write_interleaved_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
878    fn write_interleaved_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
879    fn write_interleaved_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
880    fn write_interleaved_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
881    fn write_interleaved_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
882    fn write_interleaved_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
883    fn write_interleaved_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
884    fn write_interleaved_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
885    fn write_interleaved_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
886    fn write_interleaved_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
887    fn write_interleaved_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
888
889    fn write_stereos__i8(&mut self, stereos: &[(i8 , i8 )]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
890    fn write_stereos_i16(&mut self, stereos: &[(i16, i16)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
891    fn write_stereos_i24(&mut self, stereos: &[(i24, i24)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
892    fn write_stereos_i32(&mut self, stereos: &[(i32, i32)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
893    fn write_stereos_i64(&mut self, stereos: &[(i64, i64)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
894    fn write_stereos__u8(&mut self, stereos: &[(u8 , u8 )]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
895    fn write_stereos_u16(&mut self, stereos: &[(u16, u16)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
896    fn write_stereos_u24(&mut self, stereos: &[(u24, u24)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
897    fn write_stereos_u32(&mut self, stereos: &[(u32, u32)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
898    fn write_stereos_u64(&mut self, stereos: &[(u64, u64)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
899    fn write_stereos_f32(&mut self, stereos: &[(f32, f32)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
900    fn write_stereos_f64(&mut self, stereos: &[(f64, f64)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
901}
902
903/// * `PcmXLawEncoderWrap`: encode `i16` audio samples to bytes
904#[derive(Debug)]
905pub struct PcmXLawEncoderWrap<'a> {
906    writer: &'a mut dyn Writer,
907    enc: PcmXLawEncoder,
908    channels: u16,
909    sample_rate: u32,
910}
911
912impl<'a> PcmXLawEncoderWrap<'a> {
913    pub fn new(writer: &'a mut dyn Writer, spec: Spec, which_law: XLaw) -> Self {
914        Self {
915            writer,
916            enc: PcmXLawEncoder::new(which_law),
917            channels: spec.channels,
918            sample_rate: spec.sample_rate,
919        }
920    }
921
922    pub fn write_interleaved_samples(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {
923        self.writer.write_all(
924            &samples
925                .iter()
926                .map(|sample| -> u8 { self.enc.encode(*sample) })
927                .collect::<Vec<u8>>(),
928        )?;
929        Ok(())
930    }
931}
932
933impl EncoderToImpl for PcmXLawEncoderWrap<'_> {
934    fn get_channels(&self) -> u16 {
935        self.channels
936    }
937
938    fn get_max_channels(&self) -> u16 {
939        2
940    }
941
942    fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
943        Ok(())
944    }
945
946    fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
947        let bits_per_sample = 8u16;
948        let block_align = self.channels;
949        Ok(FmtChunk {
950            format_tag: match self.enc.get_which_law() {
951                XLaw::ALaw => FORMAT_TAG_ALAW,
952                XLaw::MuLaw => FORMAT_TAG_MULAW,
953            },
954            channels: self.channels,
955            sample_rate: self.sample_rate,
956            byte_rate: self.sample_rate * bits_per_sample as u32 * self.channels as u32 / 8,
957            block_align,
958            bits_per_sample,
959            extension: None,
960        })
961    }
962
963    fn get_bitrate(&self) -> u32 {
964        self.sample_rate * self.channels as u32 * 8
965    }
966
967    fn update_fmt_chunk(&self, _fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
968        Ok(())
969    }
970
971    fn finish(&mut self) -> Result<(), AudioWriteError> {
972        Ok(self.writer.flush()?)
973    }
974
975    fn write_interleaved_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
976    fn write_interleaved_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
977    fn write_interleaved_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
978    fn write_interleaved_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
979    fn write_interleaved_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
980    fn write_interleaved_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
981    fn write_interleaved_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
982    fn write_interleaved_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
983    fn write_interleaved_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
984    fn write_interleaved_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
985    fn write_interleaved_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
986    fn write_interleaved_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
987}
988
989/// * The MP3 encoder for `WaveWriter`
990pub mod mp3 {
991    /// * MP3 supports two channels in multiple ways.
992    #[derive(Debug, Clone, Copy, PartialEq)]
993    #[repr(u8)]
994    pub enum Mp3Channels {
995        /// * Mono audio
996        Mono = 3,
997
998        /// * Stereo audio (not telling how it is)
999        Stereo = 0,
1000
1001        /// * Joint stereo (most commonly used, for better compression)
1002        JointStereo = 1,
1003
1004        /// * Dual channel stereo (for better audio quality)
1005        DualChannel = 2,
1006
1007        /// * Not set
1008        NotSet = 4,
1009    }
1010
1011    /// * MP3 quality. Affects the speed of encoding.
1012    #[derive(Debug, Clone, Copy, PartialEq)]
1013    #[repr(u8)]
1014    pub enum Mp3Quality {
1015        Best = 0,
1016        SecondBest = 1,
1017        NearBest = 2,
1018        VeryNice = 3,
1019        Nice = 4,
1020        Good = 5,
1021        Decent = 6,
1022        Ok = 7,
1023        SecondWorst = 8,
1024        Worst = 9,
1025    }
1026
1027    /// * The tier 1 factor for MP3 audio quality, bigger bitrate means better audio quality.
1028    /// * Most of the music website provides 128 kbps music for free, and 320 kbps music for the purchased subscribed members.
1029    #[derive(Debug, Clone, Copy, PartialEq)]
1030    #[repr(u16)]
1031    pub enum Mp3Bitrate {
1032        Kbps8 = 8,
1033        Kbps16 = 16,
1034        Kbps24 = 24,
1035        Kbps32 = 32,
1036        Kbps40 = 40,
1037        Kbps48 = 48,
1038
1039        /// * The bitrate for audio chatting.
1040        Kbps64 = 64,
1041        Kbps80 = 80,
1042        Kbps96 = 96,
1043        Kbps112 = 112,
1044
1045        /// * The bitrate for free users.
1046        Kbps128 = 128,
1047        Kbps160 = 160,
1048        Kbps192 = 192,
1049        Kbps224 = 224,
1050
1051        /// * Laboratories uses this bitrate.
1052        Kbps256 = 256,
1053
1054        /// * The bitrate for VIP users who pay for it.
1055        Kbps320 = 320,
1056    }
1057
1058    /// * The VBR mode for MP3. If you turn VBR on, the audio quality for MP3 will be a little bit worse.
1059    #[derive(Debug, Clone, Copy, PartialEq)]
1060    #[repr(u8)]
1061    pub enum Mp3VbrMode {
1062        /// * This option disables the VBR mode.
1063        Off = 0,
1064
1065        Mt = 1,
1066        Rh = 2,
1067        Abr = 3,
1068
1069        /// * This option is used most commonly.
1070        Mtrh = 4,
1071    }
1072
1073    const ID3_FIELD_LENGTH: usize = 250;
1074
1075    #[derive(Debug, Clone, PartialEq)]
1076    pub struct Mp3Id3Tag {
1077        pub title: [u8; ID3_FIELD_LENGTH],
1078        pub artist: [u8; ID3_FIELD_LENGTH],
1079        pub album: [u8; ID3_FIELD_LENGTH],
1080        pub album_art: [u8; ID3_FIELD_LENGTH],
1081        pub year: [u8; ID3_FIELD_LENGTH],
1082        pub comment: [u8; ID3_FIELD_LENGTH],
1083    }
1084
1085    /// * The encoder options for MP3
1086    #[derive(Debug, Clone, PartialEq)]
1087    pub struct Mp3EncoderOptions {
1088        /// * MP3 channels, not just mono and stereo. MP3 supports two channels in multiple ways.
1089        pub channels: Mp3Channels,
1090
1091        /// * MP3 quality. Affects the speed of encoding.
1092        pub quality: Mp3Quality,
1093
1094        /// * MP3 bitrate. Affects the audio quality and file size, bigger is better.
1095        pub bitrate: Mp3Bitrate,
1096
1097        /// * VBR mode for better compression, turn it off to get better audio quality.
1098        pub vbr_mode: Mp3VbrMode,
1099
1100        /// * ID3 tags, if you have, fill this field.
1101        pub id3tag: Option<Mp3Id3Tag>,
1102    }
1103
1104    impl Mp3EncoderOptions {
1105        pub fn new() -> Self {
1106            Self {
1107                channels: Mp3Channels::NotSet,
1108                quality: Mp3Quality::Best,
1109                bitrate: Mp3Bitrate::Kbps320,
1110                vbr_mode: Mp3VbrMode::Off,
1111                id3tag: None,
1112            }
1113        }
1114
1115        pub fn new_mono() -> Self {
1116            Self {
1117                channels: Mp3Channels::Mono,
1118                quality: Mp3Quality::Best,
1119                bitrate: Mp3Bitrate::Kbps320,
1120                vbr_mode: Mp3VbrMode::Off,
1121                id3tag: None,
1122            }
1123        }
1124
1125        pub fn new_stereo() -> Self {
1126            Self {
1127                channels: Mp3Channels::JointStereo,
1128                quality: Mp3Quality::Best,
1129                bitrate: Mp3Bitrate::Kbps320,
1130                vbr_mode: Mp3VbrMode::Off,
1131                id3tag: None,
1132            }
1133        }
1134
1135        pub fn get_channels(&self) -> u16 {
1136            match self.channels {
1137                Mp3Channels::Mono => 1,
1138                Mp3Channels::Stereo | Mp3Channels::DualChannel | Mp3Channels::JointStereo => 2,
1139                Mp3Channels::NotSet => 0,
1140            }
1141        }
1142
1143        pub fn get_bitrate(&self) -> u32 {
1144            self.bitrate as u32 * 1000
1145        }
1146    }
1147
1148    impl Default for Mp3EncoderOptions {
1149        fn default() -> Self {
1150            Self::new()
1151        }
1152    }
1153
1154    #[cfg(feature = "mp3enc")]
1155    use super::EncoderToImpl;
1156
1157    #[cfg(feature = "mp3enc")]
1158    pub mod impl_mp3 {
1159        use super::*;
1160        use crate::errors::AudioWriteError;
1161        use crate::io_utils::Writer;
1162        use crate::audioutils::{self, sample_conv, stereos_conv};
1163        use crate::wavcore::format_tags::*;
1164        use crate::wavcore::{FmtChunk, FmtExtension, Mp3Data, Spec};
1165        use crate::{SampleType, i24, u24};
1166        use std::{
1167            any::type_name,
1168            fmt::{self, Debug, Formatter},
1169            ops::DerefMut,
1170            sync::{Arc, Mutex},
1171        };
1172
1173        use mp3lame_encoder::{Bitrate, Id3Tag, Mode, Quality, VbrMode};
1174        use mp3lame_encoder::{Builder, DualPcm, Encoder, FlushNoGap, MonoPcm};
1175
1176        const MAX_SAMPLES_TO_ENCODE: usize = 1024;
1177
1178        #[derive(Clone)]
1179        pub struct SharedMp3Encoder(Arc<Mutex<Encoder>>);
1180
1181        impl SharedMp3Encoder {
1182            pub fn new(encoder: Encoder) -> Self {
1183                Self(Arc::new(Mutex::new(encoder)))
1184            }
1185
1186            pub fn escorted_encode<T, F, E>(&self, mut action: F) -> Result<T, E>
1187            where
1188                F: FnMut(&mut Encoder) -> Result<T, E>,
1189            {
1190                let mut guard = self.0.lock().unwrap();
1191                let encoder = guard.deref_mut();
1192                (action)(encoder)
1193            }
1194        }
1195
1196        impl Mp3Channels {
1197            pub fn to_lame_mode(&self) -> Mode {
1198                match self {
1199                    Self::Mono => Mode::Mono,
1200                    Self::Stereo => Mode::Stereo,
1201                    Self::JointStereo => Mode::JointStereo,
1202                    Self::DualChannel => Mode::DaulChannel,
1203                    Self::NotSet => Mode::NotSet,
1204                }
1205            }
1206        }
1207
1208        impl Mp3Quality {
1209            pub fn to_lame_quality(&self) -> Quality {
1210                match self {
1211                    Self::Best => Quality::Best,
1212                    Self::SecondBest => Quality::SecondBest,
1213                    Self::NearBest => Quality::NearBest,
1214                    Self::VeryNice => Quality::VeryNice,
1215                    Self::Nice => Quality::Nice,
1216                    Self::Good => Quality::Good,
1217                    Self::Decent => Quality::Decent,
1218                    Self::Ok => Quality::Ok,
1219                    Self::SecondWorst => Quality::SecondWorst,
1220                    Self::Worst => Quality::Worst,
1221                }
1222            }
1223        }
1224
1225        impl Mp3Bitrate {
1226            pub fn to_lame_bitrate(&self) -> Bitrate {
1227                match self {
1228                    Self::Kbps8 => Bitrate::Kbps8,
1229                    Self::Kbps16 => Bitrate::Kbps16,
1230                    Self::Kbps24 => Bitrate::Kbps24,
1231                    Self::Kbps32 => Bitrate::Kbps32,
1232                    Self::Kbps40 => Bitrate::Kbps40,
1233                    Self::Kbps48 => Bitrate::Kbps48,
1234                    Self::Kbps64 => Bitrate::Kbps64,
1235                    Self::Kbps80 => Bitrate::Kbps80,
1236                    Self::Kbps96 => Bitrate::Kbps96,
1237                    Self::Kbps112 => Bitrate::Kbps112,
1238                    Self::Kbps128 => Bitrate::Kbps128,
1239                    Self::Kbps160 => Bitrate::Kbps160,
1240                    Self::Kbps192 => Bitrate::Kbps192,
1241                    Self::Kbps224 => Bitrate::Kbps224,
1242                    Self::Kbps256 => Bitrate::Kbps256,
1243                    Self::Kbps320 => Bitrate::Kbps320,
1244                }
1245            }
1246        }
1247
1248        impl Mp3VbrMode {
1249            pub fn to_lame_vbr_mode(&self) -> VbrMode {
1250                match self {
1251                    Self::Off => VbrMode::Off,
1252                    Self::Mt => VbrMode::Mt,
1253                    Self::Rh => VbrMode::Rh,
1254                    Self::Abr => VbrMode::Abr,
1255                    Self::Mtrh => VbrMode::Mtrh,
1256                }
1257            }
1258        }
1259
1260        #[derive(Clone)]
1261        pub struct Mp3EncoderLameOptions {
1262            channels: Mode,
1263            quality: Quality,
1264            bitrate: Bitrate,
1265            vbr_mode: VbrMode,
1266            id3tag: Option<Mp3Id3Tag>,
1267        }
1268
1269        impl Mp3EncoderOptions {
1270            pub fn to_lame_options(&self) -> Mp3EncoderLameOptions {
1271                Mp3EncoderLameOptions {
1272                    channels: self.channels.to_lame_mode(),
1273                    quality: self.quality.to_lame_quality(),
1274                    bitrate: self.bitrate.to_lame_bitrate(),
1275                    vbr_mode: self.vbr_mode.to_lame_vbr_mode(),
1276                    id3tag: self.id3tag.clone(),
1277                }
1278            }
1279        }
1280
1281        #[derive(Debug)]
1282        pub struct Mp3Encoder<'a, S>
1283        where
1284            S: SampleType,
1285        {
1286            channels: u16,
1287            sample_rate: u32,
1288            bitrate: u32,
1289            encoder: SharedMp3Encoder,
1290            options: Mp3EncoderOptions,
1291            buffers: ChannelBuffers<'a, S>,
1292        }
1293
1294        impl<'a, S> Mp3Encoder<'a, S>
1295        where
1296            S: SampleType,
1297        {
1298            pub fn new(
1299                writer: &'a mut dyn Writer,
1300                spec: Spec,
1301                mp3_options: &Mp3EncoderOptions,
1302            ) -> Result<Self, AudioWriteError> {
1303                if spec.channels != mp3_options.get_channels() {
1304                    return Err(AudioWriteError::InvalidArguments(format!(
1305                        "The number of channels from `spec` is {}, but from `mp3_options` is {}",
1306                        spec.channels,
1307                        mp3_options.get_channels()
1308                    )));
1309                }
1310
1311                let mp3_builder = Builder::new();
1312                let mut mp3_builder = match mp3_builder {
1313                    Some(mp3_builder) => mp3_builder,
1314                    None => {
1315                        return Err(AudioWriteError::OtherReason(
1316                            "`lame_init()` somehow failed.".to_owned(),
1317                        ));
1318                    }
1319                };
1320                let options = mp3_options.to_lame_options();
1321
1322                mp3_builder.set_mode(options.channels)?;
1323                mp3_builder.set_sample_rate(spec.sample_rate)?;
1324                mp3_builder.set_brate(options.bitrate)?;
1325                mp3_builder.set_quality(options.quality)?;
1326                mp3_builder.set_vbr_mode(options.vbr_mode)?;
1327
1328                match options.vbr_mode {
1329                    VbrMode::Off => mp3_builder.set_to_write_vbr_tag(false)?,
1330                    _ => {
1331                        mp3_builder.set_to_write_vbr_tag(true)?;
1332                        mp3_builder.set_vbr_quality(options.quality)?;
1333                    }
1334                }
1335
1336                if let Some(id3tag) = options.id3tag {
1337                    mp3_builder.set_id3_tag(Id3Tag {
1338                        title: &id3tag.title,
1339                        artist: &id3tag.artist,
1340                        album: &id3tag.album,
1341                        album_art: &id3tag.album_art,
1342                        year: &id3tag.year,
1343                        comment: &id3tag.comment,
1344                    })?;
1345                }
1346
1347                let encoder = SharedMp3Encoder::new(mp3_builder.build()?);
1348
1349                let channels = mp3_options.get_channels();
1350                Ok(Self {
1351                    channels,
1352                    sample_rate: spec.sample_rate,
1353                    bitrate: mp3_options.get_bitrate(),
1354                    encoder: encoder.clone(),
1355                    options: mp3_options.clone(),
1356                    buffers: match channels {
1357                        1 | 2 => ChannelBuffers::<'a, S>::new(
1358                            writer,
1359                            encoder.clone(),
1360                            MAX_SAMPLES_TO_ENCODE,
1361                            channels,
1362                        )?,
1363                        o => {
1364                            return Err(AudioWriteError::Unsupported(format!(
1365                                "Bad channel number: {o}"
1366                            )));
1367                        }
1368                    },
1369                })
1370            }
1371
1372            pub fn write_interleaved_samples<T>(&mut self, samples: &[T]) -> Result<(), AudioWriteError>
1373            where
1374                T: SampleType,
1375            {
1376                if self.buffers.is_full() {
1377                    self.buffers.flush()?;
1378                }
1379                match self.channels {
1380                    1 => self.buffers.add_mono_channel(&sample_conv::<T, S>(samples)),
1381                    2 => self
1382                        .buffers
1383                        .add_stereos(&audioutils::interleaved_samples_to_stereos(
1384                            &sample_conv::<T, S>(samples),
1385                        )?),
1386                    o => Err(AudioWriteError::Unsupported(format!(
1387                        "Bad channels number: {o}"
1388                    ))),
1389                }
1390            }
1391
1392            pub fn write_stereos<T>(&mut self, stereos: &[(T, T)]) -> Result<(), AudioWriteError>
1393            where
1394                T: SampleType,
1395            {
1396                if self.buffers.is_full() {
1397                    self.buffers.flush()?;
1398                }
1399                match self.channels {
1400                    1 => self
1401                        .buffers
1402                        .add_mono_channel(&audioutils::stereos_to_mono_channel(&stereos_conv::<T, S>(stereos))),
1403                    2 => self.buffers.add_stereos(&stereos_conv::<T, S>(stereos)),
1404                    o => Err(AudioWriteError::InvalidArguments(format!(
1405                        "Bad channels number: {o}"
1406                    ))),
1407                }
1408            }
1409
1410            pub fn write_dual_monos<T>(
1411                &mut self,
1412                mono_l: &[T],
1413                mono_r: &[T],
1414            ) -> Result<(), AudioWriteError>
1415            where
1416                T: SampleType,
1417            {
1418                if self.buffers.is_full() {
1419                    self.buffers.flush()?;
1420                }
1421                match self.channels {
1422                    1 => self
1423                        .buffers
1424                        .add_mono_channel(&sample_conv::<T, S>(&audioutils::dual_monos_to_monos(&(
1425                            mono_l.to_vec(),
1426                            mono_r.to_vec(),
1427                        ))?)),
1428                    2 => self
1429                        .buffers
1430                        .add_dual_monos(&sample_conv::<T, S>(mono_l), &sample_conv::<T, S>(mono_r)),
1431                    o => Err(AudioWriteError::InvalidArguments(format!(
1432                        "Bad channels number: {o}"
1433                    ))),
1434                }
1435            }
1436
1437            pub fn finish(&mut self) -> Result<(), AudioWriteError> {
1438                self.buffers.finish()
1439            }
1440        }
1441
1442        #[derive(Debug, Clone)]
1443        enum Channels<S>
1444        where
1445            S: SampleType,
1446        {
1447            Mono(Vec<S>),
1448            Stereo((Vec<S>, Vec<S>)),
1449        }
1450
1451        struct ChannelBuffers<'a, S>
1452        where
1453            S: SampleType,
1454        {
1455            writer: &'a mut dyn Writer,
1456            encoder: SharedMp3Encoder,
1457            channels: Channels<S>,
1458            max_frames: usize,
1459        }
1460
1461        impl<S> Channels<S>
1462        where
1463            S: SampleType,
1464        {
1465            pub fn new_mono(max_frames: usize) -> Self {
1466                Self::Mono(Vec::<S>::with_capacity(max_frames))
1467            }
1468            pub fn new_stereo(max_frames: usize) -> Self {
1469                Self::Stereo((
1470                    Vec::<S>::with_capacity(max_frames),
1471                    Vec::<S>::with_capacity(max_frames),
1472                ))
1473            }
1474            pub fn add_mono(&mut self, frame: S) {
1475                match self {
1476                    Self::Mono(m) => m.push(frame),
1477                    Self::Stereo((l, r)) => {
1478                        l.push(frame);
1479                        r.push(frame);
1480                    }
1481                }
1482            }
1483            pub fn add_stereo(&mut self, frame: (S, S)) {
1484                match self {
1485                    Self::Mono(m) => m.push(S::average(frame.0, frame.1)),
1486                    Self::Stereo((l, r)) => {
1487                        l.push(frame.0);
1488                        r.push(frame.1);
1489                    }
1490                }
1491            }
1492            pub fn add_mono_channel(&mut self, frames: &[S]) {
1493                match self {
1494                    Self::Mono(m) => m.extend(frames),
1495                    Self::Stereo((l, r)) => {
1496                        l.extend(frames);
1497                        r.extend(frames);
1498                    }
1499                }
1500            }
1501            pub fn add_stereos(&mut self, frames: &[(S, S)]) {
1502                match self {
1503                    Self::Mono(m) => m.extend(audioutils::stereos_to_mono_channel(frames)),
1504                    Self::Stereo((l, r)) => {
1505                        let (il, ir) = audioutils::stereos_to_dual_monos(frames);
1506                        l.extend(il);
1507                        r.extend(ir);
1508                    }
1509                }
1510            }
1511            pub fn add_dual_monos(
1512                &mut self,
1513                monos_l: &[S],
1514                monos_r: &[S],
1515            ) -> Result<(), AudioWriteError> {
1516                match self {
1517                    Self::Mono(m) => m.extend(audioutils::dual_monos_to_monos(&(
1518                        monos_l.to_vec(),
1519                        monos_r.to_vec(),
1520                    ))?),
1521                    Self::Stereo((l, r)) => {
1522                        if monos_l.len() != monos_r.len() {
1523                            return Err(AudioWriteError::ChannelsNotInSameSize);
1524                        }
1525                        l.extend(monos_l);
1526                        r.extend(monos_r);
1527                    }
1528                }
1529                Ok(())
1530            }
1531            pub fn len(&self) -> usize {
1532                match self {
1533                    Self::Mono(m) => m.len(),
1534                    Self::Stereo((l, r)) => {
1535                        assert_eq!(l.len(), r.len());
1536                        l.len()
1537                    }
1538                }
1539            }
1540            pub fn is_empty(&self) -> bool {
1541                match self {
1542                    Self::Mono(m) => m.is_empty(),
1543                    Self::Stereo((l, r)) => l.is_empty() && r.is_empty(),
1544                }
1545            }
1546            pub fn get_channels(&self) -> u16 {
1547                match self {
1548                    Self::Mono(_) => 1,
1549                    Self::Stereo(_) => 2,
1550                }
1551            }
1552            pub fn clear(&mut self, max_frames: usize) {
1553                match self {
1554                    Self::Mono(m) => *m = Vec::<S>::with_capacity(max_frames),
1555                    Self::Stereo(s) => {
1556                        *s = (
1557                            Vec::<S>::with_capacity(max_frames),
1558                            Vec::<S>::with_capacity(max_frames),
1559                        )
1560                    }
1561                }
1562            }
1563        }
1564
1565        impl<'a, S> ChannelBuffers<'a, S>
1566        where
1567            S: SampleType,
1568        {
1569            pub fn new(
1570                writer: &'a mut dyn Writer,
1571                encoder: SharedMp3Encoder,
1572                max_frames: usize,
1573                channels: u16,
1574            ) -> Result<Self, AudioWriteError> {
1575                Ok(Self {
1576                    writer,
1577                    encoder,
1578                    channels: match channels {
1579                        1 => Channels::<S>::new_mono(max_frames),
1580                        2 => Channels::<S>::new_stereo(max_frames),
1581                        o => {
1582                            return Err(AudioWriteError::InvalidArguments(format!(
1583                                "Invalid channels: {o}. Only 1 and 2 are accepted."
1584                            )));
1585                        }
1586                    },
1587                    max_frames,
1588                })
1589            }
1590
1591            pub fn is_full(&self) -> bool {
1592                self.channels.len() >= self.max_frames
1593            }
1594
1595            pub fn add_mono_channel(&mut self, monos: &[S]) -> Result<(), AudioWriteError> {
1596                self.channels.add_mono_channel(monos);
1597                if self.is_full() {
1598                    self.flush()?;
1599                }
1600                Ok(())
1601            }
1602
1603            pub fn add_stereos(&mut self, stereos: &[(S, S)]) -> Result<(), AudioWriteError> {
1604                self.channels.add_stereos(stereos);
1605                if self.is_full() {
1606                    self.flush()?;
1607                }
1608                Ok(())
1609            }
1610
1611            pub fn add_dual_monos(
1612                &mut self,
1613                monos_l: &[S],
1614                monos_r: &[S],
1615            ) -> Result<(), AudioWriteError> {
1616                self.channels.add_dual_monos(monos_l, monos_r)?;
1617                if self.is_full() {
1618                    self.flush()?;
1619                }
1620                Ok(())
1621            }
1622
1623            fn channel_to_type<T>(mono: &[S]) -> Vec<T>
1624            where
1625                T: SampleType,
1626            {
1627                mono.iter().map(|s| T::scale_from(*s)).collect()
1628            }
1629
1630            fn encode_to_vec(
1631                &self,
1632                encoder: &mut Encoder,
1633                out_buf: &mut Vec<u8>,
1634            ) -> Result<usize, AudioWriteError> {
1635                // Explicitly converts all samples (even natively supported i16/u16/i32/f32/f64) for pipeline uniformity.
1636                match &self.channels {
1637                    Channels::Mono(pcm) => {
1638                        match std::any::type_name::<S>() {
1639                            "i16" => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<i16>(pcm)), out_buf)?),
1640                            "u16" => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<u16>(pcm)), out_buf)?),
1641                            "i32" => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<i32>(pcm)), out_buf)?),
1642                            "f32" => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<f32>(pcm)), out_buf)?),
1643                            "f64" => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<f64>(pcm)), out_buf)?),
1644                            "i8"  => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<i16>(pcm)), out_buf)?),
1645                            "u8"  => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<u16>(pcm)), out_buf)?),
1646                            "i24" | "u24" | "u32" => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<i32>(pcm)), out_buf)?),
1647                            other => Err(AudioWriteError::Unsupported(format!("\"{other}\""))),
1648                        }
1649                    },
1650                    Channels::Stereo(pcm) => {
1651                        match std::any::type_name::<S>() {
1652                            "i16" => Ok(encoder.encode_to_vec(DualPcm{left: &Self::channel_to_type::<i16>(&pcm.0), right: &Self::channel_to_type::<i16>(&pcm.1)}, out_buf)?),
1653                            "u16" => Ok(encoder.encode_to_vec(DualPcm{left: &Self::channel_to_type::<u16>(&pcm.0), right: &Self::channel_to_type::<u16>(&pcm.1)}, out_buf)?),
1654                            "i32" => Ok(encoder.encode_to_vec(DualPcm{left: &Self::channel_to_type::<i32>(&pcm.0), right: &Self::channel_to_type::<i32>(&pcm.1)}, out_buf)?),
1655                            "f32" => Ok(encoder.encode_to_vec(DualPcm{left: &Self::channel_to_type::<f32>(&pcm.0), right: &Self::channel_to_type::<f32>(&pcm.1)}, out_buf)?),
1656                            "f64" => Ok(encoder.encode_to_vec(DualPcm{left: &Self::channel_to_type::<f64>(&pcm.0), right: &Self::channel_to_type::<f64>(&pcm.1)}, out_buf)?),
1657                            "i8"  => Ok(encoder.encode_to_vec(DualPcm{left: &Self::channel_to_type::<i16>(&pcm.0), right: &Self::channel_to_type::<i16>(&pcm.1)}, out_buf)?),
1658                            "u8"  => Ok(encoder.encode_to_vec(DualPcm{left: &Self::channel_to_type::<u16>(&pcm.0), right: &Self::channel_to_type::<u16>(&pcm.1)}, out_buf)?),
1659                            "i24" | "u24" | "u32" => Ok(encoder.encode_to_vec(DualPcm{left: &Self::channel_to_type::<i32>(&pcm.0), right: &Self::channel_to_type::<i32>(&pcm.1)}, out_buf)?),
1660                            other => Err(AudioWriteError::Unsupported(format!("\"{other}\""))),
1661                        }
1662                    },
1663                }
1664            }
1665
1666            pub fn flush(&mut self) -> Result<(), AudioWriteError> {
1667                if self.channels.is_empty() {
1668                    return Ok(());
1669                }
1670                let to_save = self.encoder.escorted_encode(
1671                    |encoder| -> Result<Vec<u8>, AudioWriteError> {
1672                        let mut to_save = Vec::<u8>::with_capacity(
1673                            mp3lame_encoder::max_required_buffer_size(self.channels.len()),
1674                        );
1675                        self.encode_to_vec(encoder, &mut to_save)?;
1676                        Ok(to_save)
1677                    },
1678                )?;
1679                self.writer.write_all(&to_save)?;
1680                self.channels.clear(self.max_frames);
1681                Ok(())
1682            }
1683
1684            pub fn finish(&mut self) -> Result<(), AudioWriteError> {
1685                self.flush()?;
1686                self.encoder
1687                    .escorted_encode(|encoder| -> Result<(), AudioWriteError> {
1688                        let mut to_save = Vec::<u8>::with_capacity(
1689                            mp3lame_encoder::max_required_buffer_size(self.max_frames),
1690                        );
1691                        encoder.flush_to_vec::<FlushNoGap>(&mut to_save)?;
1692                        self.writer.write_all(&to_save)?;
1693                        Ok(())
1694                    })?;
1695                self.channels.clear(self.max_frames);
1696                Ok(())
1697            }
1698        }
1699
1700        impl<S> EncoderToImpl for Mp3Encoder<'_, S>
1701        where
1702            S: SampleType,
1703        {
1704            fn get_channels(&self) -> u16 {
1705                self.channels
1706            }
1707
1708            fn get_max_channels(&self) -> u16 {
1709                2
1710            }
1711
1712            fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
1713                Ok(())
1714            }
1715
1716            fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
1717                Ok(FmtChunk {
1718                    format_tag: FORMAT_TAG_MP3,
1719                    channels: self.channels,
1720                    sample_rate: self.sample_rate,
1721                    byte_rate: self.bitrate / 8,
1722                    block_align: if self.sample_rate <= 28000 {
1723                        576
1724                    } else {
1725                        576 * 2
1726                    },
1727                    bits_per_sample: 0,
1728                    extension: Some(FmtExtension::new_mp3(Mp3Data::new(
1729                        self.bitrate,
1730                        self.sample_rate,
1731                    ))),
1732                })
1733            }
1734
1735            fn get_bitrate(&self) -> u32 {
1736                self.bitrate * self.channels as u32
1737            }
1738
1739            fn update_fmt_chunk(&self, _fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
1740                Ok(())
1741            }
1742
1743            fn finish(&mut self) -> Result<(), AudioWriteError> {
1744                self.finish()
1745            }
1746
1747            fn write_interleaved_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(samples)}
1748            fn write_interleaved_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(samples)}
1749            fn write_interleaved_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(samples)}
1750            fn write_interleaved_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(samples)}
1751            fn write_interleaved_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(samples)}
1752            fn write_interleaved_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(samples)}
1753            fn write_interleaved_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(samples)}
1754            fn write_interleaved_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(samples)}
1755            fn write_interleaved_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(samples)}
1756            fn write_interleaved_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(samples)}
1757            fn write_interleaved_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(samples)}
1758            fn write_interleaved_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(samples)}
1759
1760            fn write_stereos__i8(&mut self, stereos: &[(i8 , i8 )]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1761            fn write_stereos_i16(&mut self, stereos: &[(i16, i16)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1762            fn write_stereos_i24(&mut self, stereos: &[(i24, i24)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1763            fn write_stereos_i32(&mut self, stereos: &[(i32, i32)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1764            fn write_stereos_i64(&mut self, stereos: &[(i64, i64)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1765            fn write_stereos__u8(&mut self, stereos: &[(u8 , u8 )]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1766            fn write_stereos_u16(&mut self, stereos: &[(u16, u16)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1767            fn write_stereos_u24(&mut self, stereos: &[(u24, u24)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1768            fn write_stereos_u32(&mut self, stereos: &[(u32, u32)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1769            fn write_stereos_u64(&mut self, stereos: &[(u64, u64)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1770            fn write_stereos_f32(&mut self, stereos: &[(f32, f32)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1771            fn write_stereos_f64(&mut self, stereos: &[(f64, f64)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1772
1773            fn write_dual_monos__i8(&mut self, mono1: &[i8 ], mono2: &[i8 ]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1774            fn write_dual_monos_i16(&mut self, mono1: &[i16], mono2: &[i16]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1775            fn write_dual_monos_i24(&mut self, mono1: &[i24], mono2: &[i24]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1776            fn write_dual_monos_i32(&mut self, mono1: &[i32], mono2: &[i32]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1777            fn write_dual_monos_i64(&mut self, mono1: &[i64], mono2: &[i64]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1778            fn write_dual_monos__u8(&mut self, mono1: &[u8 ], mono2: &[u8 ]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1779            fn write_dual_monos_u16(&mut self, mono1: &[u16], mono2: &[u16]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1780            fn write_dual_monos_u24(&mut self, mono1: &[u24], mono2: &[u24]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1781            fn write_dual_monos_u32(&mut self, mono1: &[u32], mono2: &[u32]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1782            fn write_dual_monos_u64(&mut self, mono1: &[u64], mono2: &[u64]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1783            fn write_dual_monos_f32(&mut self, mono1: &[f32], mono2: &[f32]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1784            fn write_dual_monos_f64(&mut self, mono1: &[f64], mono2: &[f64]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1785        }
1786
1787        impl Debug for SharedMp3Encoder {
1788            fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
1789                fmt.debug_struct("SharedMp3Encoder").finish_non_exhaustive()
1790            }
1791        }
1792
1793        impl<S> Debug for ChannelBuffers<'_, S>
1794        where
1795            S: SampleType,
1796        {
1797            fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
1798                fmt.debug_struct(&format!("ChannelBuffers<{}>", type_name::<S>()))
1799                    .field("encoder", &self.encoder)
1800                    .field(
1801                        "channels",
1802                        &format_args!(
1803                            "{}",
1804                            match self.channels {
1805                                Channels::Mono(_) => "Mono",
1806                                Channels::Stereo(_) => "Stereo",
1807                            }
1808                        ),
1809                    )
1810                    .field("max_frames", &self.max_frames)
1811                    .finish()
1812            }
1813        }
1814
1815        impl From<mp3lame_encoder::BuildError> for AudioWriteError {
1816            fn from(err: mp3lame_encoder::BuildError) -> Self {
1817                match err {
1818                    mp3lame_encoder::BuildError::Generic => Self::OtherReason("Generic error".to_owned()),
1819                    mp3lame_encoder::BuildError::NoMem => Self::OtherReason("No enough memory".to_owned()),
1820                    mp3lame_encoder::BuildError::BadBRate => Self::InvalidInput("Bad bit rate".to_owned()),
1821                    mp3lame_encoder::BuildError::BadSampleFreq => Self::InvalidInput("Bad sample rate".to_owned()),
1822                    mp3lame_encoder::BuildError::InternalError => Self::OtherReason("Internal error".to_owned()),
1823                    mp3lame_encoder::BuildError::Other(c_int) => Self::OtherReason(format!("Other lame error code: {c_int}")),
1824                }
1825            }
1826        }
1827
1828        impl From<mp3lame_encoder::Id3TagError> for AudioWriteError {
1829            fn from(err: mp3lame_encoder::Id3TagError) -> Self {
1830                match err {
1831                    mp3lame_encoder::Id3TagError::AlbumArtOverflow => {
1832                        Self::BufferIsFull("Specified Id3 tag buffer exceed limit of 128kb".to_owned())
1833                    }
1834                }
1835            }
1836        }
1837
1838        impl From<mp3lame_encoder::EncodeError> for AudioWriteError {
1839            fn from(err: mp3lame_encoder::EncodeError) -> Self {
1840                match err {
1841                    mp3lame_encoder::EncodeError::BufferTooSmall => Self::BufferIsFull("Buffer is too small".to_owned()),
1842                    mp3lame_encoder::EncodeError::NoMem => Self::OtherReason("No enough memory".to_owned()),
1843                    mp3lame_encoder::EncodeError::InvalidState => Self::OtherReason("Invalid state".to_owned()),
1844                    mp3lame_encoder::EncodeError::PsychoAcoustic => Self::OtherReason("Psycho acoustic problems".to_owned()),
1845                    mp3lame_encoder::EncodeError::Other(c_int) => Self::OtherReason(format!("Other lame error code: {c_int}")),
1846                }
1847            }
1848        }
1849    }
1850
1851    #[cfg(feature = "mp3enc")]
1852    pub use impl_mp3::*;
1853}
1854
1855pub use mp3::{Mp3Bitrate, Mp3Channels, Mp3EncoderOptions, Mp3Quality, Mp3VbrMode};
1856
1857/// * The Opus encoder for `WaveWriter`
1858pub mod opus {
1859    const OPUS_ALLOWED_SAMPLE_RATES: [u32; 5] = [8000, 12000, 16000, 24000, 48000];
1860    const OPUS_MIN_SAMPLE_RATE: u32 = 8000;
1861    const OPUS_MAX_SAMPLE_RATE: u32 = 48000;
1862
1863    /// * The opus encoder only eats these durations of the samples to encode.
1864    /// * Longer duration means better quality and compression.
1865    /// * If longer than or equal to 10ms, the compression algorithm could be able to use some advanced technology.
1866    #[derive(Debug, Clone, Copy, PartialEq)]
1867    #[repr(u32)]
1868    pub enum OpusEncoderSampleDuration {
1869        MilliSec2_5,
1870        MilliSec5,
1871        MilliSec10,
1872        MilliSec20,
1873        MilliSec40,
1874        MilliSec60,
1875    }
1876
1877    /// * The bitrate option for the Opus encoder, the higher the better for audio quality.
1878    #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
1879    pub enum OpusBitrate {
1880        Bits(i32),
1881        Max,
1882        Auto,
1883    }
1884
1885    impl OpusEncoderSampleDuration {
1886        pub fn get_num_samples(&self, channels: u16, sample_rate: u32) -> usize {
1887            let ms_m_10 = match self {
1888                Self::MilliSec2_5 => 25,
1889                Self::MilliSec5 => 50,
1890                Self::MilliSec10 => 100,
1891                Self::MilliSec20 => 200,
1892                Self::MilliSec40 => 400,
1893                Self::MilliSec60 => 600,
1894            };
1895            (sample_rate as usize * ms_m_10 as usize) * channels as usize / 10000
1896        }
1897    }
1898
1899    /// * The encoder options for Opus
1900    #[derive(Debug, Clone, Copy, PartialEq)]
1901    pub struct OpusEncoderOptions {
1902        /// * The tier 1 factor for Opus audio quality, bigger bitrate means better audio quality.
1903        pub bitrate: OpusBitrate,
1904
1905        /// * VBR mode for better compression, turn it off to get better audio quality.
1906        pub encode_vbr: bool,
1907
1908        /// * The opus encoder only eats these durations of the samples to encode.
1909        /// * Longer duration means better quality and compression.
1910        pub samples_cache_duration: OpusEncoderSampleDuration,
1911    }
1912
1913    impl OpusEncoderOptions {
1914        pub fn new() -> Self {
1915            Self {
1916                bitrate: OpusBitrate::Max,
1917                encode_vbr: false,
1918                samples_cache_duration: OpusEncoderSampleDuration::MilliSec60,
1919            }
1920        }
1921
1922        pub fn get_allowed_sample_rates(&self) -> [u32; OPUS_ALLOWED_SAMPLE_RATES.len()] {
1923            OPUS_ALLOWED_SAMPLE_RATES
1924        }
1925
1926        pub fn get_rounded_up_sample_rate(&self, sample_rate: u32) -> u32 {
1927            if sample_rate <= OPUS_MIN_SAMPLE_RATE {
1928                OPUS_MIN_SAMPLE_RATE
1929            } else if sample_rate >= OPUS_MAX_SAMPLE_RATE {
1930                OPUS_MAX_SAMPLE_RATE
1931            } else {
1932                for (l, h) in OPUS_ALLOWED_SAMPLE_RATES[..OPUS_ALLOWED_SAMPLE_RATES.len() - 1]
1933                    .iter()
1934                    .zip(OPUS_ALLOWED_SAMPLE_RATES[1..].iter())
1935                {
1936                    if sample_rate > *l && sample_rate <= *h {
1937                        return *h;
1938                    }
1939                }
1940                OPUS_MAX_SAMPLE_RATE
1941            }
1942        }
1943    }
1944
1945    impl Default for OpusEncoderOptions {
1946        fn default() -> Self {
1947            Self::new()
1948        }
1949    }
1950
1951    #[cfg(feature = "opus")]
1952    use super::EncoderToImpl;
1953
1954    #[cfg(feature = "opus")]
1955    pub mod impl_opus {
1956        use std::{
1957            fmt::{self, Debug, Formatter},
1958            mem,
1959        };
1960
1961        use super::*;
1962        use crate::errors::AudioWriteError;
1963        use crate::io_utils::Writer;
1964        use crate::audioutils::sample_conv;
1965        use crate::wavcore::format_tags::*;
1966        use crate::wavcore::{FmtChunk, Spec};
1967        use crate::{i24, u24};
1968
1969        use opus::{self, Application, Bitrate, Channels, Encoder, ErrorCode};
1970
1971        impl OpusBitrate {
1972            pub fn to_opus_bitrate(&self) -> Bitrate {
1973                match self {
1974                    Self::Bits(bitrate) => Bitrate::Bits(*bitrate),
1975                    Self::Max => Bitrate::Max,
1976                    Self::Auto => Bitrate::Auto,
1977                }
1978            }
1979        }
1980
1981        pub struct OpusEncoder<'a> {
1982            writer: &'a mut dyn Writer,
1983            encoder: Encoder,
1984            channels: u16,
1985            sample_rate: u32,
1986            cache_duration: OpusEncoderSampleDuration,
1987            num_samples_per_encode: usize,
1988            sample_cache: Vec<f32>,
1989            samples_written: u64,
1990            bytes_written: u64,
1991        }
1992
1993        impl<'a> OpusEncoder<'a> {
1994            pub fn new(
1995                writer: &'a mut dyn Writer,
1996                spec: Spec,
1997                options: &OpusEncoderOptions,
1998            ) -> Result<Self, AudioWriteError> {
1999                let mut opus_channels = Channels::Mono;
2000                unsafe { // See <https://github.com/SpaceManiac/opus-rs/blob/master/src/lib.rs#L52>
2001                    *(&mut opus_channels as *mut Channels as usize as *mut u8) = spec.channels as u8;
2002                };
2003                if !OPUS_ALLOWED_SAMPLE_RATES.contains(&spec.sample_rate) {
2004                    return Err(AudioWriteError::InvalidArguments(format!(
2005                        "Bad sample rate: {} for the opus encoder. The sample rate must be one of {}",
2006                        spec.sample_rate,
2007                        OPUS_ALLOWED_SAMPLE_RATES
2008                            .iter()
2009                            .map(|s| { format!("{s}") })
2010                            .collect::<Vec<String>>()
2011                            .join(", ")
2012                    )));
2013                }
2014                let mut encoder =
2015                    Encoder::new(spec.sample_rate, opus_channels, Application::Audio)?;
2016                encoder.set_bitrate(options.bitrate.to_opus_bitrate())?;
2017                encoder.set_vbr(options.encode_vbr)?;
2018                let num_samples_per_encode = options
2019                    .samples_cache_duration
2020                    .get_num_samples(spec.channels, spec.sample_rate);
2021                Ok(Self {
2022                    writer,
2023                    encoder,
2024                    channels: spec.channels,
2025                    sample_rate: spec.sample_rate,
2026                    cache_duration: options.samples_cache_duration,
2027                    num_samples_per_encode,
2028                    sample_cache: Vec::<f32>::new(),
2029                    samples_written: 0,
2030                    bytes_written: 0,
2031                })
2032            }
2033
2034            pub fn set_cache_duration(
2035                &mut self,
2036                samples_cache_duration: OpusEncoderSampleDuration,
2037            ) {
2038                self.cache_duration = samples_cache_duration;
2039                self.num_samples_per_encode =
2040                    samples_cache_duration.get_num_samples(self.channels, self.sample_rate);
2041            }
2042
2043            pub fn write_interleaved_samples(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {
2044                self.sample_cache.extend(samples);
2045                let mut cached_length = self.sample_cache.len();
2046                let mut iter = mem::take(&mut self.sample_cache).into_iter();
2047                while cached_length >= self.num_samples_per_encode {
2048                    // Extract `self.num_samples_per_encode` samples to encode
2049                    let samples_to_write: Vec<f32> =
2050                        iter.by_ref().take(self.num_samples_per_encode).collect();
2051                    if samples_to_write.is_empty() {
2052                        break;
2053                    }
2054
2055                    // Allocates a buffer of sufficient size, reserving one byte per sample.
2056                    let mut buf = vec![0u8; self.num_samples_per_encode];
2057
2058                    // Do encode. The output size should be the same as the input samples a.k.a. block size.
2059                    let size = self.encoder.encode_float(&samples_to_write, &mut buf)?;
2060                    assert_eq!(size, buf.len());
2061                    self.writer.write_all(&buf)?;
2062
2063                    // Update statistics
2064                    cached_length -= self.num_samples_per_encode;
2065                    self.samples_written += self.num_samples_per_encode as u64;
2066                    self.bytes_written += buf.len() as u64;
2067                }
2068                self.sample_cache = iter.collect();
2069                Ok(())
2070            }
2071
2072            pub fn flush(&mut self) -> Result<(), AudioWriteError> {
2073                if !self.sample_cache.is_empty() {
2074                    let pad = (self.num_samples_per_encode
2075                        - self.sample_cache.len() % self.num_samples_per_encode)
2076                        % self.num_samples_per_encode;
2077
2078                    // Pad to the block size to trigger it to write.
2079                    self.write_interleaved_samples(&vec![0.0f32; pad])?;
2080                }
2081                Ok(())
2082            }
2083        }
2084
2085        impl Debug for OpusEncoder<'_> {
2086            fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
2087                fmt.debug_struct("OpusEncoder")
2088                    .field("writer", &self.writer)
2089                    .field("encoder", &self.encoder)
2090                    .field("channels", &self.channels)
2091                    .field("sample_rate", &self.sample_rate)
2092                    .field("cache_duration", &self.cache_duration)
2093                    .field("num_samples_per_encode", &self.num_samples_per_encode)
2094                    .field(
2095                        "sample_cache",
2096                        &format_args!("[f32; {}]", self.sample_cache.len()),
2097                    )
2098                    .field("samples_written", &self.samples_written)
2099                    .field("bytes_written", &self.bytes_written)
2100                    .finish()
2101            }
2102        }
2103
2104        impl EncoderToImpl for OpusEncoder<'_> {
2105            fn get_channels(&self) -> u16 {
2106                self.channels
2107            }
2108
2109            fn get_max_channels(&self) -> u16 {
2110                255
2111            }
2112
2113            fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
2114                Ok(())
2115            }
2116
2117            fn get_bitrate(&self) -> u32 {
2118                if self.samples_written != 0 {
2119                    (self.sample_rate as u64 * self.bytes_written / self.samples_written
2120                        * self.channels as u64
2121                        * 8) as u32
2122                } else {
2123                    self.sample_rate * self.channels as u32 * 8 // Fake data
2124                }
2125            }
2126
2127            fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
2128                Ok(FmtChunk {
2129                    format_tag: FORMAT_TAG_OPUS,
2130                    channels: self.channels,
2131                    sample_rate: self.sample_rate,
2132                    byte_rate: self.get_bitrate() / 8,
2133                    block_align: self.num_samples_per_encode as u16,
2134                    bits_per_sample: 0,
2135                    extension: None,
2136                })
2137            }
2138
2139            fn update_fmt_chunk(&self, fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
2140                fmt.byte_rate = self.get_bitrate() / 8;
2141                fmt.block_align = self.num_samples_per_encode as u16;
2142                Ok(())
2143            }
2144
2145            fn finish(&mut self) -> Result<(), AudioWriteError> {
2146                self.flush()?;
2147                self.writer.flush()?;
2148                Ok(())
2149            }
2150
2151            fn write_interleaved_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2152            fn write_interleaved_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2153            fn write_interleaved_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2154            fn write_interleaved_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2155            fn write_interleaved_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2156            fn write_interleaved_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2157            fn write_interleaved_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2158            fn write_interleaved_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2159            fn write_interleaved_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2160            fn write_interleaved_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2161            fn write_interleaved_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2162            fn write_interleaved_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2163        }
2164
2165
2166        impl From<opus::Error> for AudioWriteError {
2167            fn from(err: opus::Error) -> Self {
2168                match err.code() {
2169                    ErrorCode::BadArg => Self::InvalidArguments(format!("On calling `{}`: {}", err.function(), err.description())),
2170                    ErrorCode::BufferTooSmall => Self::BufferIsFull(format!("On calling `{}`: {}", err.function(), err.description())),
2171                    ErrorCode::InternalError => Self::OtherReason(format!("On calling `{}`: {}", err.function(), err.description())),
2172                    ErrorCode::InvalidPacket => Self::InvalidData(format!("On calling `{}`: {}", err.function(), err.description())),
2173                    ErrorCode::Unimplemented => Self::Unimplemented(format!("On calling `{}`: {}", err.function(), err.description())),
2174                    ErrorCode::InvalidState => Self::OtherReason(format!("On calling `{}`: {}", err.function(), err.description())),
2175                    ErrorCode::AllocFail => Self::OtherReason(format!("On calling `{}`: {}", err.function(), err.description())),
2176                    ErrorCode::Unknown => Self::OtherReason(format!("On calling `{}`: {}", err.function(), err.description())),
2177                }
2178            }
2179        }
2180
2181    }
2182
2183    #[cfg(feature = "opus")]
2184    pub use impl_opus::*;
2185}
2186
2187pub use opus::{OpusBitrate, OpusEncoderOptions, OpusEncoderSampleDuration};
2188
2189/// * The FLAC encoder for `WaveWriter`
2190#[cfg(feature = "flac")]
2191pub mod flac_enc {
2192    use std::{
2193        borrow::Cow,
2194        io::{self, ErrorKind, Seek, SeekFrom, Write},
2195    };
2196
2197    use super::EncoderToImpl;
2198
2199    use crate::errors::{AudioWriteError, IOErrorInfo};
2200    use crate::io_utils::Writer;
2201    use crate::audioutils::{sample_conv, sample_conv_batch, stereos_conv};
2202    use crate::wavcore::format_tags::*;
2203    use crate::wavcore::{FmtChunk, ListChunk, get_listinfo_flacmeta};
2204    use crate::{i24, u24};
2205    use flac::{FlacEncoderParams, FlacEncoderUnmovable};
2206
2207    #[derive(Debug)]
2208    pub struct FlacEncoderWrap<'a> {
2209        encoder: Box<FlacEncoderUnmovable<'a, &'a mut dyn Writer>>,
2210        params: FlacEncoderParams,
2211        write_offset: u64,
2212        frames_written: u64,
2213        bytes_written: Box<u64>,
2214    }
2215
2216    impl<'a> FlacEncoderWrap<'a> {
2217        pub fn new(
2218            writer: &'a mut dyn Writer,
2219            params: &FlacEncoderParams,
2220        ) -> Result<Self, AudioWriteError> {
2221            let write_offset = writer.stream_position()?;
2222            let mut bytes_written = Box::new(0u64);
2223            let bytes_written_ptr = (&mut *bytes_written) as *mut u64;
2224            // Let the closures capture the pointer of the boxed variables, then use these pointers to update the variables.
2225            Ok(Self {
2226                encoder: Box::new(FlacEncoderUnmovable::new(
2227                    writer,
2228                    Box::new(
2229                        move |writer: &mut &'a mut dyn Writer, data: &[u8]| -> io::Result<()> {
2230                            unsafe { *bytes_written_ptr += data.len() as u64 };
2231                            writer.write_all(data)
2232                        },
2233                    ),
2234                    Box::new(
2235                        move |writer: &mut &'a mut dyn Writer, position: u64| -> io::Result<()> {
2236                            writer.seek(SeekFrom::Start(write_offset + position))?;
2237                            Ok(())
2238                        },
2239                    ),
2240                    Box::new(move |writer: &mut &'a mut dyn Writer| -> io::Result<u64> {
2241                        Ok(write_offset + writer.stream_position()?)
2242                    }),
2243                    params,
2244                )?),
2245                params: *params,
2246                write_offset,
2247                frames_written: 0,
2248                bytes_written,
2249            })
2250        }
2251
2252        // The input samples fill all the domains of the i32, so we should shrink the bits to `self.params.bits_per_sample` to achieve good compression.
2253        #[inline(always)]
2254        fn fit_32bit_to_bps(&self, sample: i32) -> i32 {
2255            sample >> (32 - self.params.bits_per_sample)
2256        }
2257
2258        // Batch shrink
2259        fn fit_samples_to_bps<'b>(&self, samples: &'b [i32]) -> Cow<'b, [i32]> {
2260            if self.params.bits_per_sample == 32 {
2261                Cow::Borrowed(samples)
2262            } else {
2263                Cow::Owned(
2264                    samples
2265                        .iter()
2266                        .map(|sample| self.fit_32bit_to_bps(*sample))
2267                        .collect(),
2268                )
2269            }
2270        }
2271
2272        // Shrink tuples
2273        fn fit_stereos_to_bps<'b>(&self, stereos: &'b [(i32, i32)]) -> Cow<'b, [(i32, i32)]> {
2274            if self.params.bits_per_sample == 32 {
2275                Cow::Borrowed(stereos)
2276            } else {
2277                Cow::Owned(
2278                    stereos
2279                        .iter()
2280                        .map(|(l, r)| (self.fit_32bit_to_bps(*l), self.fit_32bit_to_bps(*r)))
2281                        .collect::<Vec<(i32, i32)>>(),
2282                )
2283            }
2284        }
2285
2286        // Shrink frames or multiple mono channels
2287        fn fit_2d_to_bps<'b>(&self, two_d: &'b [Vec<i32>]) -> Cow<'b, [Vec<i32>]> {
2288            if self.params.bits_per_sample == 32 {
2289                Cow::Borrowed(two_d)
2290            } else {
2291                Cow::Owned(
2292                    two_d
2293                        .iter()
2294                        .map(|mono| self.fit_samples_to_bps(mono).to_vec())
2295                        .collect(),
2296                )
2297            }
2298        }
2299
2300        fn check_channels(&self, channels: u16) -> Result<(), AudioWriteError> {
2301            if channels != self.params.channels {
2302                Err(AudioWriteError::WrongChannels(format!(
2303                    "The encoder channels is {} but {channels} channels audio data are asked to be written.",
2304                    self.params.channels
2305                )))
2306            } else {
2307                Ok(())
2308            }
2309        }
2310
2311        #[inline(always)]
2312        pub fn get_channels(&self) -> u16 {
2313            self.params.channels
2314        }
2315
2316        #[inline(always)]
2317        pub fn get_sample_rate(&self) -> u32 {
2318            self.params.sample_rate
2319        }
2320
2321        #[cfg(feature = "id3")]
2322        pub fn inherit_metadata_from_id3(
2323            &mut self,
2324            id3_tag: &id3::Tag,
2325        ) -> Result<(), AudioWriteError> {
2326            Ok(self.encoder.inherit_metadata_from_id3(id3_tag)?)
2327        }
2328
2329        pub fn inherit_metadata_from_list(
2330            &mut self,
2331            list_chunk: &ListChunk,
2332        ) -> Result<(), AudioWriteError> {
2333            match list_chunk {
2334                ListChunk::Info(list) => {
2335                    for (list_key, flac_key) in get_listinfo_flacmeta().iter() {
2336                        if let Some(data) = list.get(list_key.to_owned()) {
2337                            self.encoder.insert_comments(flac_key, data).unwrap();
2338                        }
2339                    }
2340                }
2341                ListChunk::Adtl(_) => {
2342                    eprintln!("Don't have `INFO` data in the WAV file `LIST` chunk.");
2343                }
2344            }
2345
2346            Ok(())
2347        }
2348
2349        pub fn write_interleaved_samples(
2350            &mut self,
2351            samples: &[i32],
2352        ) -> Result<(), AudioWriteError> {
2353            match self
2354                .encoder
2355                .write_interleaved_samples(&self.fit_samples_to_bps(samples))
2356            {
2357                Ok(_) => {
2358                    self.frames_written += samples.len() as u64 / self.get_channels() as u64;
2359                    Ok(())
2360                }
2361                Err(e) => Err(AudioWriteError::from(e)),
2362            }
2363        }
2364
2365        pub fn write_mono_channel(&mut self, monos: &[i32]) -> Result<(), AudioWriteError> {
2366            match self
2367                .encoder
2368                .write_mono_channel(&self.fit_samples_to_bps(monos))
2369            {
2370                Ok(_) => {
2371                    self.frames_written += monos.len() as u64;
2372                    Ok(())
2373                }
2374                Err(e) => Err(AudioWriteError::from(e)),
2375            }
2376        }
2377
2378        pub fn write_stereos(&mut self, stereos: &[(i32, i32)]) -> Result<(), AudioWriteError> {
2379            match self
2380                .encoder
2381                .write_stereos(&self.fit_stereos_to_bps(stereos))
2382            {
2383                Ok(_) => {
2384                    self.frames_written += stereos.len() as u64;
2385                    Ok(())
2386                }
2387                Err(e) => Err(AudioWriteError::from(e)),
2388            }
2389        }
2390
2391        pub fn write_monos(&mut self, monos: &[Vec<i32>]) -> Result<(), AudioWriteError> {
2392            match self.encoder.write_monos(&self.fit_2d_to_bps(monos)) {
2393                Ok(_) => {
2394                    self.frames_written += monos[0].len() as u64;
2395                    Ok(())
2396                }
2397                Err(e) => Err(AudioWriteError::from(e)),
2398            }
2399        }
2400
2401        pub fn write_frames(&mut self, frames: &[Vec<i32>]) -> Result<(), AudioWriteError> {
2402            match self.encoder.write_frames(&self.fit_2d_to_bps(frames)) {
2403                Ok(_) => {
2404                    self.frames_written += frames.len() as u64;
2405                    Ok(())
2406                }
2407                Err(e) => Err(AudioWriteError::from(e)),
2408            }
2409        }
2410    }
2411
2412    impl EncoderToImpl for FlacEncoderWrap<'_> {
2413        fn get_channels(&self) -> u16 {
2414            self.params.channels
2415        }
2416
2417        fn get_max_channels(&self) -> u16 {
2418            8
2419        }
2420
2421        fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
2422            self.encoder.initialize()?;
2423            Ok(())
2424        }
2425
2426        fn get_bitrate(&self) -> u32 {
2427            if self.frames_written != 0 {
2428                (*self.bytes_written * self.get_sample_rate() as u64 * 8 / self.frames_written)
2429                    as u32
2430            } else {
2431                self.get_sample_rate() * self.get_channels() as u32 * 8 // Fake data
2432            }
2433        }
2434
2435        fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
2436            Ok(FmtChunk {
2437                format_tag: FORMAT_TAG_FLAC,
2438                channels: self.get_channels(),
2439                sample_rate: self.get_sample_rate(),
2440                byte_rate: self.get_bitrate() / 8,
2441                block_align: 1,
2442                bits_per_sample: 0,
2443                extension: None,
2444            })
2445        }
2446
2447        fn update_fmt_chunk(&self, fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
2448            fmt.byte_rate = self.get_bitrate() / 8;
2449            Ok(())
2450        }
2451
2452        fn finish(&mut self) -> Result<(), AudioWriteError> {
2453            Ok(self.encoder.finish()?)
2454        }
2455
2456        fn write_interleaved_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2457        fn write_interleaved_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2458        fn write_interleaved_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2459        fn write_interleaved_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2460        fn write_interleaved_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2461        fn write_interleaved_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2462        fn write_interleaved_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2463        fn write_interleaved_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2464        fn write_interleaved_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2465        fn write_interleaved_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2466        fn write_interleaved_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2467        fn write_interleaved_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
2468
2469        fn write_mono_channel__i8(&mut self, monos: &[i8 ]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
2470        fn write_mono_channel_i16(&mut self, monos: &[i16]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
2471        fn write_mono_channel_i24(&mut self, monos: &[i24]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
2472        fn write_mono_channel_i32(&mut self, monos: &[i32]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
2473        fn write_mono_channel_i64(&mut self, monos: &[i64]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
2474        fn write_mono_channel__u8(&mut self, monos: &[u8 ]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
2475        fn write_mono_channel_u16(&mut self, monos: &[u16]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
2476        fn write_mono_channel_u24(&mut self, monos: &[u24]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
2477        fn write_mono_channel_u32(&mut self, monos: &[u32]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
2478        fn write_mono_channel_u64(&mut self, monos: &[u64]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
2479        fn write_mono_channel_f32(&mut self, monos: &[f32]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
2480        fn write_mono_channel_f64(&mut self, monos: &[f64]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
2481
2482        fn write_stereos__i8(&mut self, stereos: &[(i8 , i8 )]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
2483        fn write_stereos_i16(&mut self, stereos: &[(i16, i16)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
2484        fn write_stereos_i24(&mut self, stereos: &[(i24, i24)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
2485        fn write_stereos_i32(&mut self, stereos: &[(i32, i32)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
2486        fn write_stereos_i64(&mut self, stereos: &[(i64, i64)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
2487        fn write_stereos__u8(&mut self, stereos: &[(u8 , u8 )]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
2488        fn write_stereos_u16(&mut self, stereos: &[(u16, u16)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
2489        fn write_stereos_u24(&mut self, stereos: &[(u24, u24)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
2490        fn write_stereos_u32(&mut self, stereos: &[(u32, u32)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
2491        fn write_stereos_u64(&mut self, stereos: &[(u64, u64)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
2492        fn write_stereos_f32(&mut self, stereos: &[(f32, f32)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
2493        fn write_stereos_f64(&mut self, stereos: &[(f64, f64)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
2494
2495        fn write_monos__i8(&mut self, monos_array: &[Vec<i8 >]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
2496        fn write_monos_i16(&mut self, monos_array: &[Vec<i16>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
2497        fn write_monos_i24(&mut self, monos_array: &[Vec<i24>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
2498        fn write_monos_i32(&mut self, monos_array: &[Vec<i32>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
2499        fn write_monos_i64(&mut self, monos_array: &[Vec<i64>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
2500        fn write_monos__u8(&mut self, monos_array: &[Vec<u8 >]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
2501        fn write_monos_u16(&mut self, monos_array: &[Vec<u16>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
2502        fn write_monos_u24(&mut self, monos_array: &[Vec<u24>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
2503        fn write_monos_u32(&mut self, monos_array: &[Vec<u32>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
2504        fn write_monos_u64(&mut self, monos_array: &[Vec<u64>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
2505        fn write_monos_f32(&mut self, monos_array: &[Vec<f32>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
2506        fn write_monos_f64(&mut self, monos_array: &[Vec<f64>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
2507
2508        fn write_frames__i8(&mut self, frames: &[Vec<i8 >]) -> Result<(), AudioWriteError> {self.write_frames(&sample_conv_batch(frames))}
2509        fn write_frames_i16(&mut self, frames: &[Vec<i16>]) -> Result<(), AudioWriteError> {self.write_frames(&sample_conv_batch(frames))}
2510        fn write_frames_i24(&mut self, frames: &[Vec<i24>]) -> Result<(), AudioWriteError> {self.write_frames(&sample_conv_batch(frames))}
2511        fn write_frames_i32(&mut self, frames: &[Vec<i32>]) -> Result<(), AudioWriteError> {self.write_frames(&sample_conv_batch(frames))}
2512        fn write_frames_i64(&mut self, frames: &[Vec<i64>]) -> Result<(), AudioWriteError> {self.write_frames(&sample_conv_batch(frames))}
2513        fn write_frames__u8(&mut self, frames: &[Vec<u8 >]) -> Result<(), AudioWriteError> {self.write_frames(&sample_conv_batch(frames))}
2514        fn write_frames_u16(&mut self, frames: &[Vec<u16>]) -> Result<(), AudioWriteError> {self.write_frames(&sample_conv_batch(frames))}
2515        fn write_frames_u24(&mut self, frames: &[Vec<u24>]) -> Result<(), AudioWriteError> {self.write_frames(&sample_conv_batch(frames))}
2516        fn write_frames_u32(&mut self, frames: &[Vec<u32>]) -> Result<(), AudioWriteError> {self.write_frames(&sample_conv_batch(frames))}
2517        fn write_frames_u64(&mut self, frames: &[Vec<u64>]) -> Result<(), AudioWriteError> {self.write_frames(&sample_conv_batch(frames))}
2518        fn write_frames_f32(&mut self, frames: &[Vec<f32>]) -> Result<(), AudioWriteError> {self.write_frames(&sample_conv_batch(frames))}
2519        fn write_frames_f64(&mut self, frames: &[Vec<f64>]) -> Result<(), AudioWriteError> {self.write_frames(&sample_conv_batch(frames))}
2520    }
2521
2522    impl From<flac::FlacEncoderError> for AudioWriteError {
2523        fn from(err: flac::FlacEncoderError) -> Self {
2524            let err_code = err.code;
2525            let err_func = err.function;
2526            let err_desc = err.message;
2527            use flac::FlacEncoderErrorCode::*;
2528            let err_code = flac::FlacEncoderErrorCode::from(err_code);
2529            let err_string = format!("On function `{err_func}`: {err_desc}: {err_code}");
2530            match err_code {
2531                StreamEncoderOk => Self::OtherReason(err_string),
2532                StreamEncoderUninitialized => Self::OtherReason(err_string),
2533                StreamEncoderOggError => Self::OtherReason(err_string),
2534                StreamEncoderVerifyDecoderError => Self::OtherReason(err_string),
2535                StreamEncoderVerifyMismatchInAudioData => Self::OtherReason(err_string),
2536                StreamEncoderClientError => Self::OtherReason(err_string),
2537                StreamEncoderIOError => Self::IOError(IOErrorInfo::new(ErrorKind::Other, err_string)),
2538                StreamEncoderFramingError => Self::InvalidInput(err_string),
2539                StreamEncoderMemoryAllocationError => Self::OtherReason(err_string),
2540            }
2541        }
2542    }
2543
2544    impl From<flac::FlacEncoderInitError> for AudioWriteError {
2545        fn from(err: flac::FlacEncoderInitError) -> Self {
2546            let err_code = err.code;
2547            let err_func = err.function;
2548            let err_desc = err.message;
2549            use flac::FlacEncoderInitErrorCode::*;
2550            let err_code = flac::FlacEncoderInitErrorCode::from(err_code);
2551            let err_string = format!("On function `{err_func}`: {err_desc}: {err_code}");
2552            match err_code {
2553                StreamEncoderInitStatusOk => Self::OtherReason(err_string),
2554                StreamEncoderInitStatusEncoderError => Self::OtherReason(err_string),
2555                StreamEncoderInitStatusUnsupportedContainer => Self::OtherReason(err_string),
2556                StreamEncoderInitStatusInvalidCallbacks => Self::InvalidArguments(err_string),
2557                StreamEncoderInitStatusInvalidNumberOfChannels => Self::InvalidArguments(err_string),
2558                StreamEncoderInitStatusInvalidBitsPerSample => Self::InvalidArguments(err_string),
2559                StreamEncoderInitStatusInvalidSampleRate => Self::InvalidArguments(err_string),
2560                StreamEncoderInitStatusInvalidBlockSize => Self::InvalidArguments(err_string),
2561                StreamEncoderInitStatusInvalidMaxLpcOrder => Self::InvalidArguments(err_string),
2562                StreamEncoderInitStatusInvalidQlpCoeffPrecision => Self::InvalidArguments(err_string),
2563                StreamEncoderInitStatusBlockSizeTooSmallForLpcOrder => Self::BufferIsFull(err_string),
2564                StreamEncoderInitStatusNotStreamable => Self::OtherReason(err_string),
2565                StreamEncoderInitStatusInvalidMetadata => Self::InvalidInput(err_string),
2566                StreamEncoderInitStatusAlreadyInitialized => Self::InvalidArguments(err_string),
2567            }
2568        }
2569    }
2570
2571    impl From<flac::FlacDecoderError> for AudioWriteError {
2572        fn from(err: flac::FlacDecoderError) -> Self {
2573            let err_code = err.code;
2574            let err_func = err.function;
2575            let err_desc = err.message;
2576            use flac::FlacDecoderErrorCode::*;
2577            let err_code = flac::FlacDecoderErrorCode::from(err_code);
2578            let err_string = format!("On function `{err_func}`: {err_desc}: {err_code}");
2579            match err_code {
2580                StreamDecoderSearchForMetadata => Self::OtherReason(err_string),
2581                StreamDecoderReadMetadata => Self::OtherReason(err_string),
2582                StreamDecoderSearchForFrameSync => Self::OtherReason(err_string),
2583                StreamDecoderReadFrame => Self::OtherReason(err_string),
2584                StreamDecoderEndOfStream => Self::OtherReason(err_string),
2585                StreamDecoderOggError => Self::OtherReason(err_string),
2586                StreamDecoderSeekError => Self::OtherReason(err_string),
2587                StreamDecoderAborted => Self::OtherReason(err_string),
2588                StreamDecoderMemoryAllocationError => Self::OtherReason(err_string),
2589                StreamDecoderUninitialized => Self::InvalidArguments(err_string),
2590            }
2591        }
2592    }
2593
2594    impl From<flac::FlacDecoderInitError> for AudioWriteError {
2595        fn from(err: flac::FlacDecoderInitError) -> Self {
2596            let err_code = err.code;
2597            let err_func = err.function;
2598            let err_desc = err.message;
2599            use flac::FlacDecoderInitErrorCode::*;
2600            let err_code = flac::FlacDecoderInitErrorCode::from(err_code);
2601            let err_string = format!("On function `{err_func}`: {err_desc}: {err_code}");
2602            match err_code {
2603                StreamDecoderInitStatusOk => Self::OtherReason(err_string),
2604                StreamDecoderInitStatusUnsupportedContainer => Self::Unsupported(err_string),
2605                StreamDecoderInitStatusInvalidCallbacks => Self::InvalidArguments(err_string),
2606                StreamDecoderInitStatusMemoryAllocationError => Self::OtherReason(err_string),
2607                StreamDecoderInitStatusErrorOpeningFile => {
2608                    Self::IOError(IOErrorInfo::new(ErrorKind::Other, err_string))
2609                }
2610                StreamDecoderInitStatusAlreadyInitialized => Self::InvalidArguments(err_string),
2611            }
2612        }
2613    }
2614
2615    impl From<&dyn flac::FlacError> for AudioWriteError {
2616        fn from(err: &dyn flac::FlacError) -> Self {
2617            let err_code = err.get_code();
2618            let err_func = err.get_function();
2619            let err_desc = err.get_message();
2620            if let Some(encoder_err) = err.as_any().downcast_ref::<flac::FlacEncoderError>() {
2621                AudioWriteError::from(*encoder_err)
2622            } else if let Some(encoder_err) = err.as_any().downcast_ref::<flac::FlacEncoderInitError>()
2623            {
2624                AudioWriteError::from(*encoder_err)
2625            } else if let Some(decoder_err) = err.as_any().downcast_ref::<flac::FlacDecoderError>() {
2626                AudioWriteError::from(*decoder_err)
2627            } else if let Some(decoder_err) = err.as_any().downcast_ref::<flac::FlacDecoderInitError>()
2628            {
2629                AudioWriteError::from(*decoder_err)
2630            } else {
2631                Self::OtherReason(format!(
2632                    "Unknown error type from `flac::FlacError`: `{err_func}`: {err_code}: {err_desc}"
2633                ))
2634            }
2635        }
2636    }
2637}
2638
2639/// * The OggVorbis encoder
2640/// * Microsoft says this should be supported: see <https://github.com/tpn/winsdk-10/blob/master/Include/10.0.14393.0/shared/mmreg.h#L2321>
2641/// * FFmpeg does not support this format: see <https://git.ffmpeg.org/gitweb/ffmpeg.git/blob/refs/heads/release/7.1:/libavformat/riff.c>
2642pub mod oggvorbis_enc {
2643    /// * OggVorbis encoder mode
2644    #[derive(Debug, Clone, Copy, Default, PartialEq)]
2645    pub enum OggVorbisMode {
2646        /// * Please use this mode, it works well because it just uses the WAV `data` chunk to encapsulate the whole Ogg Vorbis audio stream.
2647        #[default]
2648        OriginalStreamCompatible = 1,
2649
2650        /// * This mode works on some players. It separates the Ogg Vorbis header into the `fmt ` chunk extension data.
2651        /// * Some players with the Ogg Vorbis decoder for the WAV file may fail because the header is separated.
2652        HaveIndependentHeader = 2,
2653
2654        /// * Please don't use this mode. The encoder strips the Ogg Vorbis header in this mode, and to decode it, the decoder should use another encoder to create an Ogg Vorbis header for the audio stream to be decoded.
2655        /// * What if the decoder has a different version of `libvorbis`, the header info is misaligned to the audio body, then BAM, it's unable to play.
2656        /// * I'm still wondering why the Japanese developer invented this mode. to reduce the audio file size? Or to use the `fmt ` chunk info to create the header?
2657        /// * The result is that you can't control the bitrate, thus the file would be very large at full bitrate settings by default.
2658        HaveNoCodebookHeader = 3,
2659
2660        /// * Another mode that exists but doesn't work.
2661        /// * The naked Vorbis audio without Ogg encapsulation, invented by the author of FFmpeg? I guess.
2662        /// * Without the Ogg packet header `granule position` field, `libvorbis` is unable to decode it correctly.
2663        /// * The decoder will try to fake the Ogg encapsulation, and if you are lucky enough, it still has some chance to decode correctly.
2664        /// * BTW. FFmpeg can encode audio into this format, but can't decode it correctly.
2665        NakedVorbis = 4
2666    }
2667
2668    /// * OggVorbis encoder parameters, NOTE: Most of the comments or documents were copied from `vorbis_rs`
2669    #[derive(Debug, Clone, Copy, Default, PartialEq)]
2670    pub struct OggVorbisEncoderParams {
2671        /// OggVorbis encoder mode
2672        pub mode: OggVorbisMode,
2673
2674        /// Num channels
2675        pub channels: u16,
2676
2677        /// Sample rate
2678        pub sample_rate: u32,
2679
2680        /// The serials for the generated OggVorbis streams will be randomly generated, as dictated by the Ogg specification. If this behavior is not desirable, set this field to `Some(your_serial_number)`.
2681        pub stream_serial: Option<i32>,
2682
2683        /// OggVorbis bitrate strategy represents a bitrate management strategy that a OggVorbis encoder can use.
2684        pub bitrate: Option<OggVorbisBitrateStrategy>,
2685
2686        /// * Specifies the minimum size of OggVorbis stream data to put into each Ogg page, except for some header pages,
2687        /// * which have to be cut short to conform to the OggVorbis specification.
2688        /// * This value controls the tradeoff between Ogg encapsulation overhead and ease of seeking and packet loss concealment.
2689        /// * By default, it is set to None, which lets the encoder decide.
2690        pub minimum_page_data_size: Option<u16>,
2691    }
2692
2693    /// * OggVorbis bitrate strategy represents a bitrate management strategy that a OggVorbis encoder can use.
2694    #[derive(Debug, Clone, Copy, PartialEq)]
2695    pub enum OggVorbisBitrateStrategy {
2696        /// * Pure VBR quality mode, selected by a target bitrate (in bit/s).
2697        /// * The bitrate management engine is not enabled.
2698        /// * The average bitrate will usually be close to the target, but there are no guarantees.
2699        /// * Easier or harder than expected to encode audio may be encoded at a significantly different bitrate.
2700        Vbr(u32),
2701
2702        /// * Similar to `Vbr`, this encoding strategy fixes the output subjective quality level,
2703        /// * but lets OggVorbis vary the target bitrate depending on the qualities of the input signal.
2704        /// * An upside of this approach is that OggVorbis can automatically increase or decrease the target bitrate according to how difficult the signal is to encode,
2705        /// * which guarantees perceptually-consistent results while using an optimal bitrate.
2706        /// * Another upside is that there always is some mode to encode audio at a given quality level.
2707        /// * The downside is that the output bitrate is harder to predict across different types of audio signals.
2708        QualityVbr(f32),
2709
2710        /// * ABR mode, selected by an average bitrate (in bit/s).
2711        /// * The bitrate management engine is enabled to ensure that the instantaneous bitrate does not divert significantly from the specified average over time,
2712        /// * but no hard bitrate limits are imposed. Any bitrate fluctuations are guaranteed to be minor and short.
2713        Abr(u32),
2714
2715        /// * Constrained ABR mode, selected by a hard maximum bitrate (in bit/s).
2716        /// * The bitrate management engine is enabled to ensure that the instantaneous bitrate never exceeds the specified maximum bitrate,
2717        /// * which is a hard limit. Internally, the encoder will target an average bitrate that  s slightly lower than the specified maximum bitrate.
2718        /// * The stream is guaranteed to never go above the specified bitrate, at the cost of a lower bitrate,
2719        /// * and thus lower audio quality, on average.
2720        ConstrainedAbr(u32),
2721    }
2722
2723    #[cfg(any(feature = "vorbis", feature = "oggvorbis"))]
2724    use super::EncoderToImpl;
2725
2726    #[cfg(any(feature = "vorbis", feature = "oggvorbis"))]
2727    mod impl_vorbis {
2728        use std::{
2729            collections::BTreeMap,
2730            fmt::{self, Debug, Formatter},
2731            io::{Seek, Write, ErrorKind},
2732            num::NonZero,
2733        };
2734
2735        use super::*;
2736        use ogg::OggPacket;
2737        use vorbis_rs::*;
2738
2739        use crate::errors::{AudioWriteError, IOErrorInfo};
2740        use crate::io_utils::{Reader, Writer, ReadWrite, CursorVecU8, SharedMultistreamIO, StreamType};
2741        use crate::audioutils::{self, sample_conv, sample_conv_batch};
2742        use crate::chunks::{FmtChunk, ext::{FmtExtension, VorbisHeaderData, OggVorbisData, OggVorbisWithHeaderData}};
2743        use crate::format_specs::format_tags::*;
2744        use crate::{i24, u24};
2745
2746        type SharedAlterIO<'a> = SharedMultistreamIO<Box<dyn Reader>, &'a mut dyn Writer, &'a mut dyn ReadWrite>;
2747        type SharedIO<'a> = StreamType<Box<dyn Reader>, &'a mut dyn Writer, &'a mut dyn ReadWrite>;
2748
2749        impl OggVorbisBitrateStrategy {
2750            fn is_vbr(&self) -> bool {
2751                match self {
2752                    Self::Vbr(_) => true,
2753                    Self::QualityVbr(_) => true,
2754                    Self::Abr(_) => false,
2755                    Self::ConstrainedAbr(_) => false,
2756                }
2757            }
2758
2759            fn get_bitrate(&self, channels: u16, sample_rate: u32) -> Result<u32, AudioWriteError> {
2760                match self {
2761                    Self::Vbr(bitrate) => Ok(*bitrate),
2762                    Self::QualityVbr(quality) => {
2763                        let quality = ((quality * 10.0) as i32).clamp(0, 10);
2764                        match sample_rate {
2765                            48000 => {
2766                                Ok([
2767                                    [64000, 80000, 96000, 112000, 128000, 160000, 192000, 240000, 256000, 350000, 450000],
2768                                    [48000, 64000, 72000,  80000,  88000,  96000, 112000, 128000, 144000, 192000, 256000],
2769                                ][channels as usize][quality as usize])
2770                            }
2771                            44100 => {
2772                                Ok([
2773                                    [64000, 80000, 96000, 112000, 128000, 160000, 192000, 240000, 256000, 350000, 450000],
2774                                    [48000, 64000, 72000,  80000,  88000,  96000, 112000, 128000, 144000, 192000, 256000],
2775                                ][channels as usize][quality as usize])
2776                            }
2777                            22050 => {
2778                                Ok([
2779                                    [56000, 72000, 80000,  88000,  96000, 112000, 144000, 176000, 192000, 256000, 320000],
2780                                    [36000, 42000, 48000,  52000,  56000,  64000,  80000,  88000,  96000, 128000, 168000],
2781                                ][channels as usize][quality as usize])
2782                            }
2783                            11025 => {
2784                                Ok([
2785                                    [36000, 44000, 50000,  52000,  56000,  64000,  80000,  96000, 112000, 144000, 168000],
2786                                    [22000, 26000, 28000,  30000,  32000,  34000,  40000,  48000,  56000,  72000,  88000],
2787                                ][channels as usize][quality as usize])
2788                            }
2789                            o => Err(AudioWriteError::InvalidArguments(format!("Invalid sample rate {o}. For Vorbis encoding, sample rate must be 48000, 44100, 22050, 11025."))),
2790                        }
2791                    },
2792                    Self::Abr(bitrate) => Ok(*bitrate),
2793                    Self::ConstrainedAbr(bitrate) => Ok(*bitrate),
2794                }
2795            }
2796        }
2797
2798        impl From<OggVorbisBitrateStrategy> for VorbisBitrateManagementStrategy {
2799            /// * Convert to the `VorbisBitrateManagementStrategy` from `vorbis_rs` crate
2800            fn from(val: OggVorbisBitrateStrategy) -> Self {
2801                match val {
2802                    OggVorbisBitrateStrategy::Vbr(bitrate) => VorbisBitrateManagementStrategy::Vbr {
2803                        target_bitrate: NonZero::new(bitrate).unwrap(),
2804                    },
2805                    OggVorbisBitrateStrategy::QualityVbr(quality) => VorbisBitrateManagementStrategy::QualityVbr {
2806                        target_quality: quality,
2807                    },
2808                    OggVorbisBitrateStrategy::Abr(bitrate) => VorbisBitrateManagementStrategy::Abr {
2809                        average_bitrate: NonZero::new(bitrate).unwrap(),
2810                    },
2811                    OggVorbisBitrateStrategy::ConstrainedAbr(bitrate) => VorbisBitrateManagementStrategy::ConstrainedAbr {
2812                        maximum_bitrate: NonZero::new(bitrate).unwrap(),
2813                    },
2814                }
2815            }
2816        }
2817
2818        impl From<VorbisBitrateManagementStrategy> for OggVorbisBitrateStrategy {
2819            /// * Convert from `VorbisBitrateManagementStrategy` from `vorbis_rs` crate
2820            fn from(vbms: VorbisBitrateManagementStrategy) -> Self {
2821                match vbms {
2822                    VorbisBitrateManagementStrategy::Vbr{target_bitrate} => Self::Vbr(target_bitrate.into()),
2823                    VorbisBitrateManagementStrategy::QualityVbr{target_quality} => Self::QualityVbr(target_quality),
2824                    VorbisBitrateManagementStrategy::Abr{average_bitrate} => Self::Abr(average_bitrate.into()),
2825                    VorbisBitrateManagementStrategy::ConstrainedAbr{maximum_bitrate} => Self::ConstrainedAbr(maximum_bitrate.into()),
2826                }
2827            }
2828        }
2829
2830        impl Default for OggVorbisBitrateStrategy {
2831            fn default() -> Self {
2832                Self::QualityVbr(1.0)
2833            }
2834        }
2835
2836        /// * The OggVorbis encoder or builder enum, the builder one has metadata to put in the builder.
2837        pub enum OggVorbisEncoderOrBuilder<'a> {
2838            /// The OggVorbis encoder builder
2839            Builder {
2840                /// The builder that has our shared writer.
2841                builder: VorbisEncoderBuilder<SharedAlterIO<'a>>,
2842
2843                /// The metadata to be added to the OggVorbis file. Before the encoder was built, add all of the comments here.
2844                metadata: BTreeMap<String, String>,
2845            },
2846
2847            /// The built encoder. It has our shared writer. Use this to encode PCM waveform to OggVorbis format.
2848            Encoder(VorbisEncoder<SharedAlterIO<'a>>),
2849
2850            /// When the encoding has finished, set this enum to `Finished`
2851            Finished,
2852        }
2853
2854        impl Debug for OggVorbisEncoderOrBuilder<'_> {
2855            fn fmt(&self, f: &mut Formatter) -> fmt::Result {
2856                match self {
2857                    Self::Builder {
2858                        builder: _,
2859                        metadata,
2860                    } => write!(
2861                        f,
2862                        "Builder(builder: VorbisEncoderBuilder<WriteBridge>, metadata: {:?})",
2863                        metadata
2864                    ),
2865                    Self::Encoder(_encoder) => write!(f, "Encoder(VorbisEncoder<WriteBridge>)"),
2866                    Self::Finished => write!(f, "Finished"),
2867                }
2868            }
2869        }
2870
2871        impl OggVorbisEncoderParams {
2872            pub fn create_vorbis_builder<W>(&self, writer: W) -> Result<VorbisEncoderBuilder<W>, AudioWriteError>
2873            where
2874                W: Write {
2875                let sample_rate = NonZero::new(self.sample_rate).unwrap();
2876                let channels = NonZero::new(self.channels as u8).unwrap();
2877
2878                let mut builder = VorbisEncoderBuilder::new(sample_rate, channels, writer)?;
2879
2880                match self.mode {
2881                    OggVorbisMode::HaveNoCodebookHeader => (),
2882                    _ => {
2883                        if let Some(serial) = self.stream_serial {
2884                            builder.stream_serial(serial);
2885                        }
2886                        if let Some(bitrate) = self.bitrate {
2887                            builder.bitrate_management_strategy(bitrate.into());
2888                        }
2889                    }
2890                }
2891
2892                builder.minimum_page_data_size(self.minimum_page_data_size);
2893                Ok(builder)
2894            }
2895
2896            pub fn get_bitrate(&self) -> u32 {
2897                self.bitrate.unwrap_or_default().get_bitrate(self.channels, self.sample_rate).unwrap()
2898            }
2899        }
2900
2901        /// * OggVorbis encoder wrap for `WaveWriter`
2902        pub struct OggVorbisEncoderWrap<'a> {
2903            /// * The writer for the encoder. Since the encoder only asks for a `Write` trait, we can control where should it write data to by using `seek()`.
2904            /// * This `SharedWriterWithCursor` can switch to `cursor_mode` or `writer_mode`, on `cursor_mode`, call `write()` on it will write data into the `Cursor`
2905            writer: SharedAlterIO<'a>,
2906
2907            /// * The parameters for the encoder
2908            params: OggVorbisEncoderParams,
2909
2910            /// * The OggVorbis encoder builder or the built encoder.
2911            encoder: OggVorbisEncoderOrBuilder<'a>,
2912
2913            /// * The data offset. The OggVorbis data should be written after here.
2914            data_offset: u64,
2915
2916            /// * How many bytes were written. This field is for calculating the bitrate of the Ogg stream.
2917            bytes_written: u64,
2918
2919            /// * How many audio frames were written. This field is for calculating the bitrate of the Ogg stream.
2920            frames_written: u64,
2921
2922            /// * The header data that should be written in the `fmt ` chunk extension.
2923            vorbis_header: Vec<u8>,
2924        }
2925
2926        impl Debug for OggVorbisEncoderWrap<'_> {
2927            fn fmt(&self, f: &mut Formatter) -> fmt::Result {
2928                f.debug_struct("OggVorbisEncoderWrap")
2929                .field("writer", &self.writer)
2930                .field("params", &self.params)
2931                .field("encoder", &self.encoder)
2932                .field("data_offset", &self.data_offset)
2933                .field("bytes_written", &self.bytes_written)
2934                .field("frames_written", &self.frames_written)
2935                .field("vorbis_header", &format_args!("[u8, {}]", self.vorbis_header.len()))
2936                .finish()
2937            }
2938        }
2939
2940        impl<'a> OggVorbisEncoderWrap<'a> {
2941            pub fn new(
2942                writer: &'a mut dyn Writer,
2943                params: &OggVorbisEncoderParams,
2944            ) -> Result<Self, AudioWriteError> {
2945                let mut shared_writer = SharedAlterIO::default();
2946                shared_writer.push_stream(SharedIO::Writer(writer));
2947                shared_writer.push_stream(SharedIO::CursorU8(CursorVecU8::default()));
2948                let data_offset = shared_writer.stream_position()?;
2949
2950                let mut ret = Self {
2951                    writer: shared_writer.clone(),
2952                    params: *params,
2953                    encoder: OggVorbisEncoderOrBuilder::Builder {
2954                        builder: params.create_vorbis_builder(shared_writer.clone())?,
2955                        metadata: BTreeMap::new(),
2956                    },
2957                    data_offset,
2958                    bytes_written: 0,
2959                    frames_written: 0,
2960                    vorbis_header: Vec::new(),
2961                };
2962                if ret.params.bitrate.is_none() {
2963                    ret.params.bitrate = Some(VorbisBitrateManagementStrategy::default().into());
2964                }
2965                if let OggVorbisEncoderOrBuilder::Builder{builder: _, ref mut metadata} = ret.encoder {
2966                    metadata.insert("ENCODER".to_string(), "rustwav".to_string());
2967                }
2968                Ok(ret)
2969            }
2970
2971            /// Get num channels from the params
2972            pub fn get_channels(&self) -> u16 {
2973                self.params.channels
2974            }
2975
2976            /// Get the sample rate from the params
2977            pub fn get_sample_rate(&self) -> u32 {
2978                self.params.sample_rate
2979            }
2980
2981            /// Insert a comment to the metadata. NOTE: When the decoder was built, you can not add comments anymore.
2982            pub fn insert_comment(
2983                &mut self,
2984                key: String,
2985                value: String,
2986            ) -> Result<(), AudioWriteError> {
2987                match self.encoder {
2988                    OggVorbisEncoderOrBuilder::Builder{builder: _, ref mut metadata} => {
2989                        metadata.insert(key, value);
2990                        Ok(())
2991                    },
2992                    _ => Err(AudioWriteError::InvalidArguments("The encoder has already entered encoding mode, why are you just starting to add metadata to it?".to_string())),
2993                }
2994            }
2995
2996            /// * When you call this method, the builder will build the encoder, and the enum `self.encoder` will be changed to the encoder.
2997            /// * After this point, you can not add metadata anymore, and then the encoding starts.
2998            pub fn begin_to_encode(&mut self) -> Result<(), AudioWriteError> {
2999                match self.encoder {
3000                    OggVorbisEncoderOrBuilder::Builder {
3001                        ref mut builder,
3002                        ref metadata,
3003                    } => {
3004                        for (tag, value) in metadata.iter() {
3005                            match builder.comment_tag(tag, value) {
3006                                Ok(_) => (),
3007                                Err(e) => {
3008                                    eprintln!("Set comment tag failed: {tag}: {value}: {:?}", e)
3009                                }
3010                            }
3011                        }
3012                        self.encoder = OggVorbisEncoderOrBuilder::Encoder(builder.build()?);
3013                        Ok(())
3014                    }
3015                    OggVorbisEncoderOrBuilder::Encoder(_) => Ok(()),
3016                    OggVorbisEncoderOrBuilder::Finished => Err(AudioWriteError::AlreadyFinished(
3017                        "The OggVorbis encoder has been sealed. No more encoding accepted."
3018                            .to_string(),
3019                    )),
3020                }
3021            }
3022
3023            /// Peel off the Ogg skin from the `Cursor` data, and write the naked data to the `Writer`
3024            fn peel_ogg(&mut self) -> Result<(), AudioWriteError> {
3025                let mut cursor = 0usize;
3026                let mut packet_length = 0usize;
3027                let data = self.writer.get_stream_mut(1).as_cursor().get_ref().clone();
3028                while cursor < data.len() {
3029                    match OggPacket::from_bytes(&data[cursor..], &mut packet_length) {
3030                        Ok(oggpacket) => {
3031                            self.writer.set_stream(0);
3032                            self.writer.write_all(&oggpacket.get_inner_data())?;
3033                            self.writer.set_stream(1);
3034                            cursor += packet_length;
3035                        }
3036                        Err(ioerr) => {
3037                            match ioerr.kind() {
3038                                ErrorKind::UnexpectedEof => {
3039                                    let remains = data[cursor..].to_vec();
3040                                    let _data = self.writer.get_stream_mut(1).take_cursor_data();
3041                                    self.writer.write_all(&remains)?;
3042                                    break;
3043                                }
3044                                _ => return Err(ioerr.into()),
3045                            }
3046                        }
3047                    }
3048                }
3049                Ok(())
3050            }
3051
3052            /// * Write the interleaved samples to the encoder. The interleaved samples were interleaved by channels.
3053            /// * The encoder actually takes the waveform array. Conversion performed during this function.
3054            pub fn write_interleaved_samples(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {
3055                let channels = self.get_channels();
3056                match self.encoder {
3057                    OggVorbisEncoderOrBuilder::Builder {
3058                        builder: _,
3059                        metadata: _,
3060                    } => Err(AudioWriteError::InvalidArguments(
3061                        "Must call `begin_to_encode()` before encoding.".to_string(),
3062                    )),
3063                    OggVorbisEncoderOrBuilder::Encoder(ref mut encoder) => {
3064                        let frames = audioutils::interleaved_samples_to_monos(samples, channels)?;
3065                        encoder.encode_audio_block(&frames)?;
3066                        if self.params.mode == OggVorbisMode::NakedVorbis {
3067                            self.peel_ogg()?;
3068                        }
3069                        self.bytes_written = self.writer.stream_position()? - self.data_offset;
3070                        self.frames_written += frames[0].len() as u64;
3071                        Ok(())
3072                    }
3073                    OggVorbisEncoderOrBuilder::Finished => Err(AudioWriteError::AlreadyFinished(
3074                        "The OggVorbis encoder has been sealed. No more encoding accepted."
3075                            .to_string(),
3076                    )),
3077                }
3078            }
3079
3080            /// Write multiple mono waveforms to the encoder.
3081            pub fn write_monos(&mut self, monos: &[Vec<f32>]) -> Result<(), AudioWriteError> {
3082                match self.encoder {
3083                    OggVorbisEncoderOrBuilder::Builder {
3084                        builder: _,
3085                        metadata: _,
3086                    } => Err(AudioWriteError::InvalidArguments(
3087                        "Must call `begin_to_encode()` before encoding.".to_string(),
3088                    )),
3089                    OggVorbisEncoderOrBuilder::Encoder(ref mut encoder) => {
3090                        encoder.encode_audio_block(monos)?;
3091                        if self.params.mode == OggVorbisMode::NakedVorbis {
3092                            self.peel_ogg()?;
3093                        }
3094                        self.bytes_written = self.writer.stream_position()? - self.data_offset;
3095                        self.frames_written += monos.len() as u64;
3096                        Ok(())
3097                    }
3098                    OggVorbisEncoderOrBuilder::Finished => Err(AudioWriteError::AlreadyFinished(
3099                        "The OggVorbis encoder has been sealed. No more encoding accepted."
3100                            .to_string(),
3101                    )),
3102                }
3103            }
3104
3105            /// Finish encoding audio.
3106            pub fn finish(&mut self) -> Result<(), AudioWriteError> {
3107                match self.encoder {
3108                    OggVorbisEncoderOrBuilder::Builder {
3109                        builder: _,
3110                        metadata: _,
3111                    } => Err(AudioWriteError::InvalidArguments(
3112                        "Must call `begin_to_encode()` before encoding.".to_string(),
3113                    )),
3114                    OggVorbisEncoderOrBuilder::Encoder(ref mut _encoder) => {
3115                        self.encoder = OggVorbisEncoderOrBuilder::Finished;
3116                        Ok(())
3117                    }
3118                    OggVorbisEncoderOrBuilder::Finished => Ok(()),
3119                }
3120            }
3121        }
3122
3123        impl EncoderToImpl for OggVorbisEncoderWrap<'_> {
3124            fn get_channels(&self) -> u16 {
3125                self.params.channels
3126            }
3127
3128            fn get_max_channels(&self) -> u16 {
3129                255
3130            }
3131
3132            fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
3133                match self.params.mode {
3134                    OggVorbisMode::OriginalStreamCompatible => self.begin_to_encode(),
3135                    OggVorbisMode::HaveIndependentHeader => Ok(()),
3136                    OggVorbisMode::HaveNoCodebookHeader => {
3137                        let _header = self.writer.get_stream_mut(1).take_cursor_data();
3138                        Ok(())
3139                    }
3140                    OggVorbisMode::NakedVorbis => Ok(())
3141                }
3142            }
3143
3144            fn get_bitrate(&self) -> u32 {
3145                if self.frames_written != 0 {
3146                    (self.bytes_written * 8 * self.get_sample_rate() as u64 / self.frames_written)
3147                        as u32
3148                } else {
3149                    self.params.get_bitrate()
3150                }
3151            }
3152
3153            fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
3154                match self.params.mode {
3155                    OggVorbisMode::OriginalStreamCompatible => (),
3156                    OggVorbisMode::HaveIndependentHeader => {
3157                        // Save the header to `fmt ` chunk
3158                        self.writer.set_stream(1);
3159                        self.begin_to_encode()?;
3160                        self.vorbis_header = self.writer.get_cur_stream_mut().take_cursor_data();
3161                        self.writer.set_stream(0);
3162                    }
3163                    OggVorbisMode::HaveNoCodebookHeader => {
3164                        self.writer.set_stream(1);
3165                        self.begin_to_encode()?;
3166                        // Discard the header. When to decode, the decoder generates the header by using an encoder.
3167                        let _header = self.writer.get_cur_stream_mut().take_cursor_data();
3168                        self.writer.set_stream(0);
3169                    }
3170                    OggVorbisMode::NakedVorbis => {
3171                        // Save the header to `fmt ` chunk
3172                        use revorbis::get_vorbis_headers_from_ogg_packet_bytes;
3173                        self.writer.set_stream(1);
3174                        self.begin_to_encode()?;
3175                        let header = self.writer.get_cur_stream_mut().take_cursor_data();
3176                        let mut _stream_id = 0u32;
3177                        let (identification_header, comments_header, setup_header) = get_vorbis_headers_from_ogg_packet_bytes(&header, &mut _stream_id)?;
3178                        self.vorbis_header.clear();
3179                        self.vorbis_header.push(2); // Two field of the header size
3180                        self.vorbis_header.push(identification_header.len() as u8);
3181                        self.vorbis_header.push(comments_header.len() as u8);
3182                        self.vorbis_header.extend(identification_header);
3183                        self.vorbis_header.extend(comments_header);
3184                        self.vorbis_header.extend(setup_header);
3185                    }
3186                }
3187                Ok(FmtChunk {
3188                    format_tag: match self.params.mode {
3189                        OggVorbisMode::OriginalStreamCompatible => {
3190                            if self.params.bitrate.unwrap().is_vbr() {
3191                                FORMAT_TAG_OGG_VORBIS1
3192                            } else {
3193                                FORMAT_TAG_OGG_VORBIS1P
3194                            }
3195                        }
3196                        OggVorbisMode::HaveIndependentHeader => {
3197                            if self.params.bitrate.unwrap().is_vbr() {
3198                                FORMAT_TAG_OGG_VORBIS2
3199                            } else {
3200                                FORMAT_TAG_OGG_VORBIS2P
3201                            }
3202                        }
3203                        OggVorbisMode::HaveNoCodebookHeader => {
3204                            if self.params.bitrate.unwrap().is_vbr() {
3205                                FORMAT_TAG_OGG_VORBIS3
3206                            } else {
3207                                FORMAT_TAG_OGG_VORBIS3P
3208                            }
3209                        }
3210                        OggVorbisMode::NakedVorbis => FORMAT_TAG_VORBIS,
3211                    },
3212                    channels: self.get_channels(),
3213                    sample_rate: self.get_sample_rate(),
3214                    byte_rate: self.params.get_bitrate() / 8,
3215                    block_align: 4,
3216                    bits_per_sample: 16,
3217                    extension: Some(if self.vorbis_header.is_empty() {
3218                        FmtExtension::new_oggvorbis(OggVorbisData::new())
3219                    } else if self.params.mode != OggVorbisMode::NakedVorbis {
3220                        FmtExtension::new_oggvorbis_with_header(OggVorbisWithHeaderData::new(&self.vorbis_header))
3221                    } else {
3222                        FmtExtension::new_vorbis(VorbisHeaderData::new(&self.vorbis_header))
3223                    }),
3224                })
3225            }
3226
3227            fn update_fmt_chunk(&self, fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
3228                fmt.byte_rate = self.get_bitrate() / 8;
3229                Ok(())
3230            }
3231
3232            fn finish(&mut self) -> Result<(), AudioWriteError> {
3233                self.finish()?;
3234                Ok(())
3235            }
3236
3237            fn write_interleaved_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
3238            fn write_interleaved_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
3239            fn write_interleaved_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
3240            fn write_interleaved_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
3241            fn write_interleaved_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
3242            fn write_interleaved_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
3243            fn write_interleaved_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
3244            fn write_interleaved_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
3245            fn write_interleaved_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
3246            fn write_interleaved_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
3247            fn write_interleaved_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
3248            fn write_interleaved_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
3249
3250            fn write_monos__i8(&mut self, monos_array: &[Vec<i8 >]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
3251            fn write_monos_i16(&mut self, monos_array: &[Vec<i16>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
3252            fn write_monos_i24(&mut self, monos_array: &[Vec<i24>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
3253            fn write_monos_i32(&mut self, monos_array: &[Vec<i32>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
3254            fn write_monos_i64(&mut self, monos_array: &[Vec<i64>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
3255            fn write_monos__u8(&mut self, monos_array: &[Vec<u8 >]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
3256            fn write_monos_u16(&mut self, monos_array: &[Vec<u16>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
3257            fn write_monos_u24(&mut self, monos_array: &[Vec<u24>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
3258            fn write_monos_u32(&mut self, monos_array: &[Vec<u32>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
3259            fn write_monos_u64(&mut self, monos_array: &[Vec<u64>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
3260            fn write_monos_f32(&mut self, monos_array: &[Vec<f32>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
3261            fn write_monos_f64(&mut self, monos_array: &[Vec<f64>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
3262        }
3263
3264        impl From<vorbis_rs::VorbisError> for AudioWriteError {
3265            fn from(err: vorbis_rs::VorbisError) -> Self {
3266                use vorbis_rs::VorbisError::*;
3267                match err {
3268                    LibraryError(liberr) => {
3269                        let lib = liberr.library();
3270                        let func = liberr.function();
3271                        let kind = liberr.kind();
3272                        let message =
3273                            format!("OggVorbis library error: lib: {lib}, function: {func}, kind: {kind}");
3274                        use vorbis_rs::VorbisLibraryErrorKind::*;
3275                        match kind {
3276                            False | Hole | InternalFault | NotVorbis | BadHeader | BadVorbisVersion
3277                            | NotAudio | BadPacket | BadLink => Self::OtherReason(message),
3278                            Eof => Self::IOError(IOErrorInfo::new(ErrorKind::UnexpectedEof, message)),
3279                            Io => Self::IOError(IOErrorInfo::new(ErrorKind::Other, message)),
3280                            NotImplemented => Self::Unimplemented(message),
3281                            InvalidValue => Self::InvalidInput(message),
3282                            NotSeekable => Self::IOError(IOErrorInfo::new(ErrorKind::NotSeekable, message)),
3283                            Other { result_code: code } => Self::OtherReason(format!(
3284                                "OggVorbis library error: lib: {lib}, function: {func}, kind: {kind}, code: {code}"
3285                            )),
3286                            o => Self::OtherReason(format!(
3287                                "OggVorbis library error: lib: {lib}, function: {func}, kind: {kind}, error: {o}"
3288                            )),
3289                        }
3290                    }
3291                    InvalidAudioBlockChannelCount { expected, actual } => Self::WrongChannels(format!(
3292                        "Channel error: expected: {expected}, actual: {actual}"
3293                    )),
3294                    InvalidAudioBlockSampleCount { expected, actual } => Self::InvalidData(format!(
3295                        "Invalid audio block sample count: expected: {expected}, actual: {actual}"
3296                    )),
3297                    UnsupportedStreamChaining => {
3298                        Self::Unsupported("Unsupported stream chaining".to_string())
3299                    }
3300                    InvalidCommentString(err_char) => {
3301                        Self::InvalidInput(format!("Invalid comment string char {err_char}"))
3302                    }
3303                    RangeExceeded(try_error) => {
3304                        Self::InvalidInput(format!("Invalid parameters range exceeded: {try_error}"))
3305                    }
3306                    Io(ioerr) => Self::IOError(IOErrorInfo::new(ioerr.kind(), format!("{:?}", ioerr))),
3307                    Rng(rngerr) => Self::OtherReason(format!("Random number generator error: {rngerr}")),
3308                    ConsumedEncoderBuilderSink => {
3309                        Self::InvalidArguments("The `writer` was already consumed".to_string())
3310                    }
3311                    o => Self::OtherReason(format!("Unknown error: {o}")),
3312                }
3313            }
3314        }
3315
3316    }
3317
3318    #[cfg(any(feature = "vorbis", feature = "oggvorbis"))]
3319    pub use impl_vorbis::*;
3320}
3321
3322pub use oggvorbis_enc::{OggVorbisBitrateStrategy, OggVorbisEncoderParams, OggVorbisMode};
rustwav_core/encoders.rs

rustwav_core/
encoders.rs
