1#![allow(dead_code)]
2#![allow(non_snake_case)]
3
4use std::fmt::Debug;
5
6use crate::Writer;
7use crate::{SampleType, i24, u24};
8use crate::AudioWriteError;
9use crate::adpcm;
10use crate::wavcore::{Spec, WaveSampleType};
11use crate::wavcore::{FmtChunk, FmtExtension, ExtensibleData, GUID_PCM_FORMAT, GUID_IEEE_FLOAT_FORMAT};
12use crate::utils::{self, sample_conv, stereo_conv, stereos_conv, sample_conv_batch};
13use crate::xlaw::{XLaw, PcmXLawEncoder};
14
15pub trait EncoderToImpl: Debug {
19 fn get_bitrate(&self) -> u32;
20 fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError>;
21 fn update_fmt_chunk(&self, fmt: &mut FmtChunk) -> Result<(), AudioWriteError>;
22 fn begin_encoding(&mut self) -> Result<(), AudioWriteError>;
23 fn finish(&mut self) -> Result<(), AudioWriteError>;
24
25 fn write_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError>;
27 fn write_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError>;
28 fn write_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError>;
29 fn write_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError>;
30 fn write_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError>;
31 fn write_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError>;
32 fn write_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError>;
33 fn write_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError>;
34 fn write_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError>;
35 fn write_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError>;
36 fn write_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError>;
37 fn write_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError>;
38
39 fn write_frame__i8(&mut self, frame: &[i8 ]) -> Result<(), AudioWriteError> {self.write_samples__i8(frame)}
41 fn write_frame_i16(&mut self, frame: &[i16]) -> Result<(), AudioWriteError> {self.write_samples_i16(frame)}
42 fn write_frame_i24(&mut self, frame: &[i24]) -> Result<(), AudioWriteError> {self.write_samples_i24(frame)}
43 fn write_frame_i32(&mut self, frame: &[i32]) -> Result<(), AudioWriteError> {self.write_samples_i32(frame)}
44 fn write_frame_i64(&mut self, frame: &[i64]) -> Result<(), AudioWriteError> {self.write_samples_i64(frame)}
45 fn write_frame__u8(&mut self, frame: &[u8 ]) -> Result<(), AudioWriteError> {self.write_samples__u8(frame)}
46 fn write_frame_u16(&mut self, frame: &[u16]) -> Result<(), AudioWriteError> {self.write_samples_u16(frame)}
47 fn write_frame_u24(&mut self, frame: &[u24]) -> Result<(), AudioWriteError> {self.write_samples_u24(frame)}
48 fn write_frame_u32(&mut self, frame: &[u32]) -> Result<(), AudioWriteError> {self.write_samples_u32(frame)}
49 fn write_frame_u64(&mut self, frame: &[u64]) -> Result<(), AudioWriteError> {self.write_samples_u64(frame)}
50 fn write_frame_f32(&mut self, frame: &[f32]) -> Result<(), AudioWriteError> {self.write_samples_f32(frame)}
51 fn write_frame_f64(&mut self, frame: &[f64]) -> Result<(), AudioWriteError> {self.write_samples_f64(frame)}
52
53 fn write_frames__i8(&mut self, frames: &[Vec<i8 >], channels: u16) -> Result<(), AudioWriteError> {self.write_samples__i8(&utils::frames_to_interleaved_samples(frames, Some(channels))?)}
55 fn write_frames_i16(&mut self, frames: &[Vec<i16>], channels: u16) -> Result<(), AudioWriteError> {self.write_samples_i16(&utils::frames_to_interleaved_samples(frames, Some(channels))?)}
56 fn write_frames_i24(&mut self, frames: &[Vec<i24>], channels: u16) -> Result<(), AudioWriteError> {self.write_samples_i24(&utils::frames_to_interleaved_samples(frames, Some(channels))?)}
57 fn write_frames_i32(&mut self, frames: &[Vec<i32>], channels: u16) -> Result<(), AudioWriteError> {self.write_samples_i32(&utils::frames_to_interleaved_samples(frames, Some(channels))?)}
58 fn write_frames_i64(&mut self, frames: &[Vec<i64>], channels: u16) -> Result<(), AudioWriteError> {self.write_samples_i64(&utils::frames_to_interleaved_samples(frames, Some(channels))?)}
59 fn write_frames__u8(&mut self, frames: &[Vec<u8 >], channels: u16) -> Result<(), AudioWriteError> {self.write_samples__u8(&utils::frames_to_interleaved_samples(frames, Some(channels))?)}
60 fn write_frames_u16(&mut self, frames: &[Vec<u16>], channels: u16) -> Result<(), AudioWriteError> {self.write_samples_u16(&utils::frames_to_interleaved_samples(frames, Some(channels))?)}
61 fn write_frames_u24(&mut self, frames: &[Vec<u24>], channels: u16) -> Result<(), AudioWriteError> {self.write_samples_u24(&utils::frames_to_interleaved_samples(frames, Some(channels))?)}
62 fn write_frames_u32(&mut self, frames: &[Vec<u32>], channels: u16) -> Result<(), AudioWriteError> {self.write_samples_u32(&utils::frames_to_interleaved_samples(frames, Some(channels))?)}
63 fn write_frames_u64(&mut self, frames: &[Vec<u64>], channels: u16) -> Result<(), AudioWriteError> {self.write_samples_u64(&utils::frames_to_interleaved_samples(frames, Some(channels))?)}
64 fn write_frames_f32(&mut self, frames: &[Vec<f32>], channels: u16) -> Result<(), AudioWriteError> {self.write_samples_f32(&utils::frames_to_interleaved_samples(frames, Some(channels))?)}
65 fn write_frames_f64(&mut self, frames: &[Vec<f64>], channels: u16) -> Result<(), AudioWriteError> {self.write_samples_f64(&utils::frames_to_interleaved_samples(frames, Some(channels))?)}
66
67 fn write_sample__i8(&mut self, sample: i8 ) -> Result<(), AudioWriteError> {self.write_samples__i8(&[sample])}
69 fn write_sample_i16(&mut self, sample: i16) -> Result<(), AudioWriteError> {self.write_samples_i16(&[sample])}
70 fn write_sample_i24(&mut self, sample: i24) -> Result<(), AudioWriteError> {self.write_samples_i24(&[sample])}
71 fn write_sample_i32(&mut self, sample: i32) -> Result<(), AudioWriteError> {self.write_samples_i32(&[sample])}
72 fn write_sample_i64(&mut self, sample: i64) -> Result<(), AudioWriteError> {self.write_samples_i64(&[sample])}
73 fn write_sample__u8(&mut self, sample: u8 ) -> Result<(), AudioWriteError> {self.write_samples__u8(&[sample])}
74 fn write_sample_u16(&mut self, sample: u16) -> Result<(), AudioWriteError> {self.write_samples_u16(&[sample])}
75 fn write_sample_u24(&mut self, sample: u24) -> Result<(), AudioWriteError> {self.write_samples_u24(&[sample])}
76 fn write_sample_u32(&mut self, sample: u32) -> Result<(), AudioWriteError> {self.write_samples_u32(&[sample])}
77 fn write_sample_u64(&mut self, sample: u64) -> Result<(), AudioWriteError> {self.write_samples_u64(&[sample])}
78 fn write_sample_f32(&mut self, sample: f32) -> Result<(), AudioWriteError> {self.write_samples_f32(&[sample])}
79 fn write_sample_f64(&mut self, sample: f64) -> Result<(), AudioWriteError> {self.write_samples_f64(&[sample])}
80
81 fn write_mono_channel__i8(&mut self, monos: &[i8 ]) -> Result<(), AudioWriteError> {self.write_samples__i8(monos)}
83 fn write_mono_channel_i16(&mut self, monos: &[i16]) -> Result<(), AudioWriteError> {self.write_samples_i16(monos)}
84 fn write_mono_channel_i24(&mut self, monos: &[i24]) -> Result<(), AudioWriteError> {self.write_samples_i24(monos)}
85 fn write_mono_channel_i32(&mut self, monos: &[i32]) -> Result<(), AudioWriteError> {self.write_samples_i32(monos)}
86 fn write_mono_channel_i64(&mut self, monos: &[i64]) -> Result<(), AudioWriteError> {self.write_samples_i64(monos)}
87 fn write_mono_channel__u8(&mut self, monos: &[u8 ]) -> Result<(), AudioWriteError> {self.write_samples__u8(monos)}
88 fn write_mono_channel_u16(&mut self, monos: &[u16]) -> Result<(), AudioWriteError> {self.write_samples_u16(monos)}
89 fn write_mono_channel_u24(&mut self, monos: &[u24]) -> Result<(), AudioWriteError> {self.write_samples_u24(monos)}
90 fn write_mono_channel_u32(&mut self, monos: &[u32]) -> Result<(), AudioWriteError> {self.write_samples_u32(monos)}
91 fn write_mono_channel_u64(&mut self, monos: &[u64]) -> Result<(), AudioWriteError> {self.write_samples_u64(monos)}
92 fn write_mono_channel_f32(&mut self, monos: &[f32]) -> Result<(), AudioWriteError> {self.write_samples_f32(monos)}
93 fn write_mono_channel_f64(&mut self, monos: &[f64]) -> Result<(), AudioWriteError> {self.write_samples_f64(monos)}
94
95 fn write_dual_sample__i8(&mut self, mono1: i8 , mono2: i8 ) -> Result<(), AudioWriteError> {self.write_samples__i8(&[mono1, mono2])}
97 fn write_dual_sample_i16(&mut self, mono1: i16, mono2: i16) -> Result<(), AudioWriteError> {self.write_samples_i16(&[mono1, mono2])}
98 fn write_dual_sample_i24(&mut self, mono1: i24, mono2: i24) -> Result<(), AudioWriteError> {self.write_samples_i24(&[mono1, mono2])}
99 fn write_dual_sample_i32(&mut self, mono1: i32, mono2: i32) -> Result<(), AudioWriteError> {self.write_samples_i32(&[mono1, mono2])}
100 fn write_dual_sample_i64(&mut self, mono1: i64, mono2: i64) -> Result<(), AudioWriteError> {self.write_samples_i64(&[mono1, mono2])}
101 fn write_dual_sample__u8(&mut self, mono1: u8 , mono2: u8 ) -> Result<(), AudioWriteError> {self.write_samples__u8(&[mono1, mono2])}
102 fn write_dual_sample_u16(&mut self, mono1: u16, mono2: u16) -> Result<(), AudioWriteError> {self.write_samples_u16(&[mono1, mono2])}
103 fn write_dual_sample_u24(&mut self, mono1: u24, mono2: u24) -> Result<(), AudioWriteError> {self.write_samples_u24(&[mono1, mono2])}
104 fn write_dual_sample_u32(&mut self, mono1: u32, mono2: u32) -> Result<(), AudioWriteError> {self.write_samples_u32(&[mono1, mono2])}
105 fn write_dual_sample_u64(&mut self, mono1: u64, mono2: u64) -> Result<(), AudioWriteError> {self.write_samples_u64(&[mono1, mono2])}
106 fn write_dual_sample_f32(&mut self, mono1: f32, mono2: f32) -> Result<(), AudioWriteError> {self.write_samples_f32(&[mono1, mono2])}
107 fn write_dual_sample_f64(&mut self, mono1: f64, mono2: f64) -> Result<(), AudioWriteError> {self.write_samples_f64(&[mono1, mono2])}
108
109 fn write_dual_monos__i8(&mut self, mono1: &[i8 ], mono2: &[i8 ]) -> Result<(), AudioWriteError> {self.write_samples__i8(&utils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
111 fn write_dual_monos_i16(&mut self, mono1: &[i16], mono2: &[i16]) -> Result<(), AudioWriteError> {self.write_samples_i16(&utils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
112 fn write_dual_monos_i24(&mut self, mono1: &[i24], mono2: &[i24]) -> Result<(), AudioWriteError> {self.write_samples_i24(&utils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
113 fn write_dual_monos_i32(&mut self, mono1: &[i32], mono2: &[i32]) -> Result<(), AudioWriteError> {self.write_samples_i32(&utils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
114 fn write_dual_monos_i64(&mut self, mono1: &[i64], mono2: &[i64]) -> Result<(), AudioWriteError> {self.write_samples_i64(&utils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
115 fn write_dual_monos__u8(&mut self, mono1: &[u8 ], mono2: &[u8 ]) -> Result<(), AudioWriteError> {self.write_samples__u8(&utils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
116 fn write_dual_monos_u16(&mut self, mono1: &[u16], mono2: &[u16]) -> Result<(), AudioWriteError> {self.write_samples_u16(&utils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
117 fn write_dual_monos_u24(&mut self, mono1: &[u24], mono2: &[u24]) -> Result<(), AudioWriteError> {self.write_samples_u24(&utils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
118 fn write_dual_monos_u32(&mut self, mono1: &[u32], mono2: &[u32]) -> Result<(), AudioWriteError> {self.write_samples_u32(&utils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
119 fn write_dual_monos_u64(&mut self, mono1: &[u64], mono2: &[u64]) -> Result<(), AudioWriteError> {self.write_samples_u64(&utils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
120 fn write_dual_monos_f32(&mut self, mono1: &[f32], mono2: &[f32]) -> Result<(), AudioWriteError> {self.write_samples_f32(&utils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
121 fn write_dual_monos_f64(&mut self, mono1: &[f64], mono2: &[f64]) -> Result<(), AudioWriteError> {self.write_samples_f64(&utils::monos_to_interleaved_samples(&[mono1.to_vec(), mono2.to_vec()])?)}
122
123 fn write_monos__i8(&mut self, monos_array: &[Vec<i8 >]) -> Result<(), AudioWriteError> {self.write_samples__i8(&utils::monos_to_interleaved_samples(monos_array)?)}
125 fn write_monos_i16(&mut self, monos_array: &[Vec<i16>]) -> Result<(), AudioWriteError> {self.write_samples_i16(&utils::monos_to_interleaved_samples(monos_array)?)}
126 fn write_monos_i24(&mut self, monos_array: &[Vec<i24>]) -> Result<(), AudioWriteError> {self.write_samples_i24(&utils::monos_to_interleaved_samples(monos_array)?)}
127 fn write_monos_i32(&mut self, monos_array: &[Vec<i32>]) -> Result<(), AudioWriteError> {self.write_samples_i32(&utils::monos_to_interleaved_samples(monos_array)?)}
128 fn write_monos_i64(&mut self, monos_array: &[Vec<i64>]) -> Result<(), AudioWriteError> {self.write_samples_i64(&utils::monos_to_interleaved_samples(monos_array)?)}
129 fn write_monos__u8(&mut self, monos_array: &[Vec<u8 >]) -> Result<(), AudioWriteError> {self.write_samples__u8(&utils::monos_to_interleaved_samples(monos_array)?)}
130 fn write_monos_u16(&mut self, monos_array: &[Vec<u16>]) -> Result<(), AudioWriteError> {self.write_samples_u16(&utils::monos_to_interleaved_samples(monos_array)?)}
131 fn write_monos_u24(&mut self, monos_array: &[Vec<u24>]) -> Result<(), AudioWriteError> {self.write_samples_u24(&utils::monos_to_interleaved_samples(monos_array)?)}
132 fn write_monos_u32(&mut self, monos_array: &[Vec<u32>]) -> Result<(), AudioWriteError> {self.write_samples_u32(&utils::monos_to_interleaved_samples(monos_array)?)}
133 fn write_monos_u64(&mut self, monos_array: &[Vec<u64>]) -> Result<(), AudioWriteError> {self.write_samples_u64(&utils::monos_to_interleaved_samples(monos_array)?)}
134 fn write_monos_f32(&mut self, monos_array: &[Vec<f32>]) -> Result<(), AudioWriteError> {self.write_samples_f32(&utils::monos_to_interleaved_samples(monos_array)?)}
135 fn write_monos_f64(&mut self, monos_array: &[Vec<f64>]) -> Result<(), AudioWriteError> {self.write_samples_f64(&utils::monos_to_interleaved_samples(monos_array)?)}
136
137 fn write_stereo__i8(&mut self, stereo: (i8 , i8 )) -> Result<(), AudioWriteError> {self.write_samples__i8(&[stereo.0, stereo.1])}
139 fn write_stereo_i16(&mut self, stereo: (i16, i16)) -> Result<(), AudioWriteError> {self.write_samples_i16(&[stereo.0, stereo.1])}
140 fn write_stereo_i24(&mut self, stereo: (i24, i24)) -> Result<(), AudioWriteError> {self.write_samples_i24(&[stereo.0, stereo.1])}
141 fn write_stereo_i32(&mut self, stereo: (i32, i32)) -> Result<(), AudioWriteError> {self.write_samples_i32(&[stereo.0, stereo.1])}
142 fn write_stereo_i64(&mut self, stereo: (i64, i64)) -> Result<(), AudioWriteError> {self.write_samples_i64(&[stereo.0, stereo.1])}
143 fn write_stereo__u8(&mut self, stereo: (u8 , u8 )) -> Result<(), AudioWriteError> {self.write_samples__u8(&[stereo.0, stereo.1])}
144 fn write_stereo_u16(&mut self, stereo: (u16, u16)) -> Result<(), AudioWriteError> {self.write_samples_u16(&[stereo.0, stereo.1])}
145 fn write_stereo_u24(&mut self, stereo: (u24, u24)) -> Result<(), AudioWriteError> {self.write_samples_u24(&[stereo.0, stereo.1])}
146 fn write_stereo_u32(&mut self, stereo: (u32, u32)) -> Result<(), AudioWriteError> {self.write_samples_u32(&[stereo.0, stereo.1])}
147 fn write_stereo_u64(&mut self, stereo: (u64, u64)) -> Result<(), AudioWriteError> {self.write_samples_u64(&[stereo.0, stereo.1])}
148 fn write_stereo_f32(&mut self, stereo: (f32, f32)) -> Result<(), AudioWriteError> {self.write_samples_f32(&[stereo.0, stereo.1])}
149 fn write_stereo_f64(&mut self, stereo: (f64, f64)) -> Result<(), AudioWriteError> {self.write_samples_f64(&[stereo.0, stereo.1])}
150
151 fn write_stereos__i8(&mut self, stereos: &[(i8 , i8 )]) -> Result<(), AudioWriteError> {self.write_samples__i8(&utils::stereos_to_interleaved_samples(stereos))}
153 fn write_stereos_i16(&mut self, stereos: &[(i16, i16)]) -> Result<(), AudioWriteError> {self.write_samples_i16(&utils::stereos_to_interleaved_samples(stereos))}
154 fn write_stereos_i24(&mut self, stereos: &[(i24, i24)]) -> Result<(), AudioWriteError> {self.write_samples_i24(&utils::stereos_to_interleaved_samples(stereos))}
155 fn write_stereos_i32(&mut self, stereos: &[(i32, i32)]) -> Result<(), AudioWriteError> {self.write_samples_i32(&utils::stereos_to_interleaved_samples(stereos))}
156 fn write_stereos_i64(&mut self, stereos: &[(i64, i64)]) -> Result<(), AudioWriteError> {self.write_samples_i64(&utils::stereos_to_interleaved_samples(stereos))}
157 fn write_stereos__u8(&mut self, stereos: &[(u8 , u8 )]) -> Result<(), AudioWriteError> {self.write_samples__u8(&utils::stereos_to_interleaved_samples(stereos))}
158 fn write_stereos_u16(&mut self, stereos: &[(u16, u16)]) -> Result<(), AudioWriteError> {self.write_samples_u16(&utils::stereos_to_interleaved_samples(stereos))}
159 fn write_stereos_u24(&mut self, stereos: &[(u24, u24)]) -> Result<(), AudioWriteError> {self.write_samples_u24(&utils::stereos_to_interleaved_samples(stereos))}
160 fn write_stereos_u32(&mut self, stereos: &[(u32, u32)]) -> Result<(), AudioWriteError> {self.write_samples_u32(&utils::stereos_to_interleaved_samples(stereos))}
161 fn write_stereos_u64(&mut self, stereos: &[(u64, u64)]) -> Result<(), AudioWriteError> {self.write_samples_u64(&utils::stereos_to_interleaved_samples(stereos))}
162 fn write_stereos_f32(&mut self, stereos: &[(f32, f32)]) -> Result<(), AudioWriteError> {self.write_samples_f32(&utils::stereos_to_interleaved_samples(stereos))}
163 fn write_stereos_f64(&mut self, stereos: &[(f64, f64)]) -> Result<(), AudioWriteError> {self.write_samples_f64(&utils::stereos_to_interleaved_samples(stereos))}
164}
165
166#[derive(Debug, Clone, Copy)]
167pub struct DummyEncoder;
168
169impl EncoderToImpl for DummyEncoder {
171 fn get_bitrate(&self) -> u32 {
172 panic!("Must implement `get_bitrate()` for your encoder.");
173 }
174
175 fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
176 panic!("Must implement `begin_encoding()` for your encoder.");
177 }
178
179 fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
180 panic!("Must implement `new_fmt_chunk()` for your encoder.");
181 }
182
183 fn update_fmt_chunk(&self, _fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
184 panic!("Must implement `update_fmt_chunk()` for your encoder.");
185 }
186
187 fn finish(&mut self) -> Result<(), AudioWriteError> {
188 panic!("Must implement `finish()` for your encoder to flush the data.");
189 }
190
191 fn write_samples_f32(&mut self, _samples: &[f32]) -> Result<(), AudioWriteError> {
192 panic!("Must at lease implement `write_samples_f32()` for your encoder to get samples.");
193 }
194
195 fn write_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.write_samples_f32(&sample_conv(samples))}
196 fn write_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.write_samples_f32(&sample_conv(samples))}
197 fn write_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.write_samples_f32(&sample_conv(samples))}
198 fn write_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.write_samples_f32(&sample_conv(samples))}
199 fn write_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.write_samples_f32(&sample_conv(samples))}
200 fn write_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.write_samples_f32(&sample_conv(samples))}
201 fn write_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.write_samples_f32(&sample_conv(samples))}
202 fn write_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.write_samples_f32(&sample_conv(samples))}
203 fn write_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.write_samples_f32(&sample_conv(samples))}
204 fn write_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.write_samples_f32(&sample_conv(samples))}
205 fn write_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.write_samples_f32(&sample_conv(samples))}
206}
207
208#[derive(Debug)]
209pub struct Encoder<'a> {
210 encoder: Box<dyn EncoderToImpl + 'a>,
211}
212
213impl<'a> Default for Encoder<'_> {
214 fn default() -> Self {
215 Self::new(DummyEncoder{})
216 }
217}
218
219impl<'a> Encoder<'a> {
220 pub fn new<T>(encoder: T) -> Self
221 where T: EncoderToImpl + 'a {
222 Self {
223 encoder: Box::new(encoder),
224 }
225 }
226
227 pub fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
228 self.encoder.begin_encoding()
229 }
230
231 pub fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
232 self.encoder.new_fmt_chunk()
233 }
234
235 pub fn get_bitrate(&self) -> u32 {
236 self.encoder.get_bitrate()
237 }
238
239 pub fn update_fmt_chunk(&self, fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
240 self.encoder.update_fmt_chunk(fmt)
241 }
242
243 pub fn finish(&mut self) -> Result<(), AudioWriteError> {
244 self.encoder.finish()
245 }
246
247 pub fn write_samples<S>(&mut self, samples: &[S]) -> Result<(), AudioWriteError>
248 where S: SampleType {
249 match std::any::type_name::<S>() {
250 "i8" => self.encoder.write_samples__i8(&sample_conv(samples)),
251 "i16" => self.encoder.write_samples_i16(&sample_conv(samples)),
252 "i24" => self.encoder.write_samples_i24(&sample_conv(samples)),
253 "i32" => self.encoder.write_samples_i32(&sample_conv(samples)),
254 "i64" => self.encoder.write_samples_i64(&sample_conv(samples)),
255 "u8" => self.encoder.write_samples__u8(&sample_conv(samples)),
256 "u16" => self.encoder.write_samples_u16(&sample_conv(samples)),
257 "u24" => self.encoder.write_samples_u24(&sample_conv(samples)),
258 "u32" => self.encoder.write_samples_u32(&sample_conv(samples)),
259 "u64" => self.encoder.write_samples_u64(&sample_conv(samples)),
260 "f32" => self.encoder.write_samples_f32(&sample_conv(samples)),
261 "f64" => self.encoder.write_samples_f64(&sample_conv(samples)),
262 other => Err(AudioWriteError::InvalidArguments(format!("Bad sample type: {}", other))),
263 }
264 }
265
266 pub fn write_frame<S>(&mut self, frame: &[S]) -> Result<(), AudioWriteError>
267 where S: SampleType {
268 match std::any::type_name::<S>() {
269 "i8" => self.encoder.write_frame__i8(&sample_conv(frame)),
270 "i16" => self.encoder.write_frame_i16(&sample_conv(frame)),
271 "i24" => self.encoder.write_frame_i24(&sample_conv(frame)),
272 "i32" => self.encoder.write_frame_i32(&sample_conv(frame)),
273 "i64" => self.encoder.write_frame_i64(&sample_conv(frame)),
274 "u8" => self.encoder.write_frame__u8(&sample_conv(frame)),
275 "u16" => self.encoder.write_frame_u16(&sample_conv(frame)),
276 "u24" => self.encoder.write_frame_u24(&sample_conv(frame)),
277 "u32" => self.encoder.write_frame_u32(&sample_conv(frame)),
278 "u64" => self.encoder.write_frame_u64(&sample_conv(frame)),
279 "f32" => self.encoder.write_frame_f32(&sample_conv(frame)),
280 "f64" => self.encoder.write_frame_f64(&sample_conv(frame)),
281 other => Err(AudioWriteError::InvalidArguments(format!("Bad sample type: {}", other))),
282 }
283 }
284
285 pub fn write_frames<S>(&mut self, frames: &[Vec<S>], channels: u16) -> Result<(), AudioWriteError>
286 where S: SampleType {
287 match std::any::type_name::<S>() { "i8" => self.encoder.write_frames__i8(&sample_conv_batch(frames), channels),
289 "i16" => self.encoder.write_frames_i16(&sample_conv_batch(frames), channels),
290 "i24" => self.encoder.write_frames_i24(&sample_conv_batch(frames), channels),
291 "i32" => self.encoder.write_frames_i32(&sample_conv_batch(frames), channels),
292 "i64" => self.encoder.write_frames_i64(&sample_conv_batch(frames), channels),
293 "u8" => self.encoder.write_frames__u8(&sample_conv_batch(frames), channels),
294 "u16" => self.encoder.write_frames_u16(&sample_conv_batch(frames), channels),
295 "u24" => self.encoder.write_frames_u24(&sample_conv_batch(frames), channels),
296 "u32" => self.encoder.write_frames_u32(&sample_conv_batch(frames), channels),
297 "u64" => self.encoder.write_frames_u64(&sample_conv_batch(frames), channels),
298 "f32" => self.encoder.write_frames_f32(&sample_conv_batch(frames), channels),
299 "f64" => self.encoder.write_frames_f64(&sample_conv_batch(frames), channels),
300 other => Err(AudioWriteError::InvalidArguments(format!("Bad sample type: {}", other))),
301 }
302 }
303
304 pub fn write_sample<S>(&mut self, mono: S) -> Result<(), AudioWriteError>
305 where S: SampleType {
306 match std::any::type_name::<S>() {
307 "i8" => self.encoder.write_sample__i8(mono.to_i8() ),
308 "i16" => self.encoder.write_sample_i16(mono.to_i16()),
309 "i24" => self.encoder.write_sample_i24(mono.to_i24()),
310 "i32" => self.encoder.write_sample_i32(mono.to_i32()),
311 "i64" => self.encoder.write_sample_i64(mono.to_i64()),
312 "u8" => self.encoder.write_sample__u8(mono.to_u8() ),
313 "u16" => self.encoder.write_sample_u16(mono.to_u16()),
314 "u24" => self.encoder.write_sample_u24(mono.to_u24()),
315 "u32" => self.encoder.write_sample_u32(mono.to_u32()),
316 "u64" => self.encoder.write_sample_u64(mono.to_u64()),
317 "f32" => self.encoder.write_sample_f32(mono.to_f32()),
318 "f64" => self.encoder.write_sample_f64(mono.to_f64()),
319 other => Err(AudioWriteError::InvalidArguments(format!("Bad sample type: {}", other))),
320 }
321 }
322
323 pub fn write_mono_channel<S>(&mut self, monos: &[S]) -> Result<(), AudioWriteError>
324 where S: SampleType {
325 match std::any::type_name::<S>() {
326 "i8" => self.encoder.write_samples__i8(&sample_conv(monos)),
327 "i16" => self.encoder.write_samples_i16(&sample_conv(monos)),
328 "i24" => self.encoder.write_samples_i24(&sample_conv(monos)),
329 "i32" => self.encoder.write_samples_i32(&sample_conv(monos)),
330 "i64" => self.encoder.write_samples_i64(&sample_conv(monos)),
331 "u8" => self.encoder.write_samples__u8(&sample_conv(monos)),
332 "u16" => self.encoder.write_samples_u16(&sample_conv(monos)),
333 "u24" => self.encoder.write_samples_u24(&sample_conv(monos)),
334 "u32" => self.encoder.write_samples_u32(&sample_conv(monos)),
335 "u64" => self.encoder.write_samples_u64(&sample_conv(monos)),
336 "f32" => self.encoder.write_samples_f32(&sample_conv(monos)),
337 "f64" => self.encoder.write_samples_f64(&sample_conv(monos)),
338 other => Err(AudioWriteError::InvalidArguments(format!("Bad sample type: {}", other))),
339 }
340 }
341
342 pub fn write_dual_mono<S>(&mut self, mono1: S, mono2: S) -> Result<(), AudioWriteError>
343 where S: SampleType {
344 match std::any::type_name::<S>() {
345 "i8" => self.encoder.write_dual_sample__i8(mono1.to_i8() , mono2.to_i8() ),
346 "i16" => self.encoder.write_dual_sample_i16(mono1.to_i16(), mono2.to_i16()),
347 "i24" => self.encoder.write_dual_sample_i24(mono1.to_i24(), mono2.to_i24()),
348 "i32" => self.encoder.write_dual_sample_i32(mono1.to_i32(), mono2.to_i32()),
349 "i64" => self.encoder.write_dual_sample_i64(mono1.to_i64(), mono2.to_i64()),
350 "u8" => self.encoder.write_dual_sample__u8(mono1.to_u8() , mono2.to_u8() ),
351 "u16" => self.encoder.write_dual_sample_u16(mono1.to_u16(), mono2.to_u16()),
352 "u24" => self.encoder.write_dual_sample_u24(mono1.to_u24(), mono2.to_u24()),
353 "u32" => self.encoder.write_dual_sample_u32(mono1.to_u32(), mono2.to_u32()),
354 "u64" => self.encoder.write_dual_sample_u64(mono1.to_u64(), mono2.to_u64()),
355 "f32" => self.encoder.write_dual_sample_f32(mono1.to_f32(), mono2.to_f32()),
356 "f64" => self.encoder.write_dual_sample_f64(mono1.to_f64(), mono2.to_f64()),
357 other => Err(AudioWriteError::InvalidArguments(format!("Bad sample type: {}", other))),
358 }
359 }
360
361 pub fn write_dual_monos<S>(&mut self, mono1: &[S], mono2: &[S]) -> Result<(), AudioWriteError>
362 where S: SampleType {
363 match std::any::type_name::<S>() {
364 "i8" => self.encoder.write_dual_monos__i8(&sample_conv(mono1), &sample_conv(mono2)),
365 "i16" => self.encoder.write_dual_monos_i16(&sample_conv(mono1), &sample_conv(mono2)),
366 "i24" => self.encoder.write_dual_monos_i24(&sample_conv(mono1), &sample_conv(mono2)),
367 "i32" => self.encoder.write_dual_monos_i32(&sample_conv(mono1), &sample_conv(mono2)),
368 "i64" => self.encoder.write_dual_monos_i64(&sample_conv(mono1), &sample_conv(mono2)),
369 "u8" => self.encoder.write_dual_monos__u8(&sample_conv(mono1), &sample_conv(mono2)),
370 "u16" => self.encoder.write_dual_monos_u16(&sample_conv(mono1), &sample_conv(mono2)),
371 "u24" => self.encoder.write_dual_monos_u24(&sample_conv(mono1), &sample_conv(mono2)),
372 "u32" => self.encoder.write_dual_monos_u32(&sample_conv(mono1), &sample_conv(mono2)),
373 "u64" => self.encoder.write_dual_monos_u64(&sample_conv(mono1), &sample_conv(mono2)),
374 "f32" => self.encoder.write_dual_monos_f32(&sample_conv(mono1), &sample_conv(mono2)),
375 "f64" => self.encoder.write_dual_monos_f64(&sample_conv(mono1), &sample_conv(mono2)),
376 other => Err(AudioWriteError::InvalidArguments(format!("Bad sample type: {}", other))),
377 }
378 }
379
380 pub fn write_monos<S>(&mut self, monos: &[Vec<S>]) -> Result<(), AudioWriteError>
381 where S: SampleType {
382 match std::any::type_name::<S>() {
383 "i8" => self.encoder.write_monos__i8(&sample_conv_batch(monos)),
384 "i16" => self.encoder.write_monos_i16(&sample_conv_batch(monos)),
385 "i24" => self.encoder.write_monos_i24(&sample_conv_batch(monos)),
386 "i32" => self.encoder.write_monos_i32(&sample_conv_batch(monos)),
387 "i64" => self.encoder.write_monos_i64(&sample_conv_batch(monos)),
388 "u8" => self.encoder.write_monos__u8(&sample_conv_batch(monos)),
389 "u16" => self.encoder.write_monos_u16(&sample_conv_batch(monos)),
390 "u24" => self.encoder.write_monos_u24(&sample_conv_batch(monos)),
391 "u32" => self.encoder.write_monos_u32(&sample_conv_batch(monos)),
392 "u64" => self.encoder.write_monos_u64(&sample_conv_batch(monos)),
393 "f32" => self.encoder.write_monos_f32(&sample_conv_batch(monos)),
394 "f64" => self.encoder.write_monos_f64(&sample_conv_batch(monos)),
395 other => Err(AudioWriteError::InvalidArguments(format!("Bad sample type: {}", other))),
396 }
397 }
398
399 pub fn write_stereo<S>(&mut self, stereo: (S, S)) -> Result<(), AudioWriteError>
400 where S: SampleType {
401 match std::any::type_name::<S>() {
402 "i8" => self.encoder.write_stereo__i8(stereo_conv(stereo)),
403 "i16" => self.encoder.write_stereo_i16(stereo_conv(stereo)),
404 "i24" => self.encoder.write_stereo_i24(stereo_conv(stereo)),
405 "i32" => self.encoder.write_stereo_i32(stereo_conv(stereo)),
406 "i64" => self.encoder.write_stereo_i64(stereo_conv(stereo)),
407 "u8" => self.encoder.write_stereo__u8(stereo_conv(stereo)),
408 "u16" => self.encoder.write_stereo_u16(stereo_conv(stereo)),
409 "u24" => self.encoder.write_stereo_u24(stereo_conv(stereo)),
410 "u32" => self.encoder.write_stereo_u32(stereo_conv(stereo)),
411 "u64" => self.encoder.write_stereo_u64(stereo_conv(stereo)),
412 "f32" => self.encoder.write_stereo_f32(stereo_conv(stereo)),
413 "f64" => self.encoder.write_stereo_f64(stereo_conv(stereo)),
414 other => Err(AudioWriteError::InvalidArguments(format!("Bad sample type: {}", other))),
415 }
416 }
417
418 pub fn write_stereos<S>(&mut self, stereos: &[(S, S)]) -> Result<(), AudioWriteError>
419 where S: SampleType {
420 match std::any::type_name::<S>() {
421 "i8" => self.encoder.write_stereos__i8(&stereos_conv(stereos)),
422 "i16" => self.encoder.write_stereos_i16(&stereos_conv(stereos)),
423 "i24" => self.encoder.write_stereos_i24(&stereos_conv(stereos)),
424 "i32" => self.encoder.write_stereos_i32(&stereos_conv(stereos)),
425 "i64" => self.encoder.write_stereos_i64(&stereos_conv(stereos)),
426 "u8" => self.encoder.write_stereos__u8(&stereos_conv(stereos)),
427 "u16" => self.encoder.write_stereos_u16(&stereos_conv(stereos)),
428 "u24" => self.encoder.write_stereos_u24(&stereos_conv(stereos)),
429 "u32" => self.encoder.write_stereos_u32(&stereos_conv(stereos)),
430 "u64" => self.encoder.write_stereos_u64(&stereos_conv(stereos)),
431 "f32" => self.encoder.write_stereos_f32(&stereos_conv(stereos)),
432 "f64" => self.encoder.write_stereos_f64(&stereos_conv(stereos)),
433 other => Err(AudioWriteError::InvalidArguments(format!("Bad sample type: {}", other))),
434 }
435 }
436}
437
438#[derive(Debug, Clone, Copy)]
440struct PcmEncoderFrom<S>
441where S: SampleType {
442 write_fn: fn(&mut dyn Writer, frame: &[S]) -> Result<(), AudioWriteError>,
443}
444
445impl<S> PcmEncoderFrom<S>
446where S: SampleType {
447 pub fn new(target_sample: WaveSampleType) -> Result<Self, AudioWriteError> {
448 use WaveSampleType::{S8, S16, S24, S32, S64, U8, U16, U24, U32, U64, F32, F64};
449 Ok(Self {
450 write_fn: match target_sample{
451 S8 => Self::write_sample_to::<i8 >,
452 S16 => Self::write_sample_to::<i16>,
453 S24 => Self::write_sample_to::<i24>,
454 S32 => Self::write_sample_to::<i32>,
455 S64 => Self::write_sample_to::<i64>,
456 U8 => Self::write_sample_to::<u8 >,
457 U16 => Self::write_sample_to::<u16>,
458 U24 => Self::write_sample_to::<u24>,
459 U32 => Self::write_sample_to::<u32>,
460 U64 => Self::write_sample_to::<u64>,
461 F32 => Self::write_sample_to::<f32>,
462 F64 => Self::write_sample_to::<f64>,
463 other => return Err(AudioWriteError::InvalidArguments(format!("Unknown target sample type: \"{:?}\"", other))),
464 },
465 })
466 }
467
468 fn write_sample_to<T>(writer: &mut dyn Writer, frame: &[S]) -> Result<(), AudioWriteError>
471 where T: SampleType {
472 for sample in frame.iter() {
473 T::from(*sample).write_le(writer)?;
474 }
475 Ok(())
476 }
477
478 pub fn write_frame(&mut self, writer: &mut dyn Writer, frame: &[S]) -> Result<(), AudioWriteError> {
479 (self.write_fn)(writer, frame)
480 }
481
482 pub fn write_frames(&mut self, writer: &mut dyn Writer, frames: &[Vec<S>]) -> Result<(), AudioWriteError> {
483 for frame in frames.iter() {
484 (self.write_fn)(writer, frame)?;
485 }
486 Ok(())
487 }
488
489 pub fn write_samples(&mut self, writer: &mut dyn Writer, samples: &[S]) -> Result<(), AudioWriteError> {
490 (self.write_fn)(writer, samples)
491 }
492}
493
494#[derive(Debug)]
495pub struct PcmEncoder<'a> {
496 spec: Spec,
497 sample_type: WaveSampleType,
498 writer: &'a mut dyn Writer,
499 writer_from__i8: PcmEncoderFrom< i8>,
500 writer_from_i16: PcmEncoderFrom<i16>,
501 writer_from_i24: PcmEncoderFrom<i24>,
502 writer_from_i32: PcmEncoderFrom<i32>,
503 writer_from_i64: PcmEncoderFrom<i64>,
504 writer_from__u8: PcmEncoderFrom< u8>,
505 writer_from_u16: PcmEncoderFrom<u16>,
506 writer_from_u24: PcmEncoderFrom<u24>,
507 writer_from_u32: PcmEncoderFrom<u32>,
508 writer_from_u64: PcmEncoderFrom<u64>,
509 writer_from_f32: PcmEncoderFrom<f32>,
510 writer_from_f64: PcmEncoderFrom<f64>,
511}
512
513impl<'a> PcmEncoder<'a> {
514 pub fn new(writer: &'a mut dyn Writer, spec: Spec) -> Result<Self, AudioWriteError> {
516 if spec.is_channel_mask_valid() == false {
517 return Err(AudioWriteError::InvalidArguments(format!("Number of bits of channel mask 0x{:08x} does not match {} channels", spec.channel_mask, spec.channels)));
518 }
519 let target_sample = spec.get_sample_type();
520 Ok(Self {
521 spec,
522 sample_type: target_sample,
523 writer,
524 writer_from__i8: PcmEncoderFrom::< i8>::new(target_sample)?,
525 writer_from_i16: PcmEncoderFrom::<i16>::new(target_sample)?,
526 writer_from_i24: PcmEncoderFrom::<i24>::new(target_sample)?,
527 writer_from_i32: PcmEncoderFrom::<i32>::new(target_sample)?,
528 writer_from_i64: PcmEncoderFrom::<i64>::new(target_sample)?,
529 writer_from__u8: PcmEncoderFrom::< u8>::new(target_sample)?,
530 writer_from_u16: PcmEncoderFrom::<u16>::new(target_sample)?,
531 writer_from_u24: PcmEncoderFrom::<u24>::new(target_sample)?,
532 writer_from_u32: PcmEncoderFrom::<u32>::new(target_sample)?,
533 writer_from_u64: PcmEncoderFrom::<u64>::new(target_sample)?,
534 writer_from_f32: PcmEncoderFrom::<f32>::new(target_sample)?,
535 writer_from_f64: PcmEncoderFrom::<f64>::new(target_sample)?,
536 })
537 }
538}
539
540impl<'a> EncoderToImpl for PcmEncoder<'_> {
541 fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
542 Ok(())
543 }
544 fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
545 use WaveSampleType::{S8, S16, S24, S32, S64, U8, U16, U24, U32, U64, F32, F64, Unknown};
546 let bytes_per_sample = self.spec.bits_per_sample / 8;
547 let byte_rate = self.spec.sample_rate * self.spec.channels as u32 * bytes_per_sample as u32;
548 let extensible = match self.spec.channel_mask {
549 0 => None,
550 channel_mask => Some(FmtExtension::new_extensible(ExtensibleData {
551 valid_bits_per_sample: self.spec.bits_per_sample,
552 channel_mask,
553 sub_format: match self.sample_type {
554 U8 | S16 | S24 | S32 | S64 => GUID_PCM_FORMAT,
555 F32 | F64 => GUID_IEEE_FLOAT_FORMAT,
556 other => return Err(AudioWriteError::Unsupported(format!("\"{:?}\" was given for the extensible format PCM to specify the sample format", other))),
557 },
558 })),
559 };
560 Ok(FmtChunk {
561 format_tag: if extensible.is_some() {
562 0xFFFE
563 } else {
564 match self.sample_type {
565 S8 | U16 | U24 | U32 | U64 => return Err(AudioWriteError::Unsupported(format!("PCM format does not support {} samples.", self.sample_type))),
566 U8 | S16 | S24 | S32 | S64 => 1,
567 F32 | F64 => 3,
568 Unknown => panic!("Can't encode \"Unknown\" format to PCM."),
569 }
570 },
571 channels: self.spec.channels,
572 sample_rate: self.spec.sample_rate,
573 byte_rate,
574 block_align: bytes_per_sample * self.spec.channels,
575 bits_per_sample: self.spec.bits_per_sample,
576 extension: extensible,
577 })
578 }
579
580 fn get_bitrate(&self) -> u32 {
581 self.spec.channels as u32 * self.spec.sample_rate * self.sample_type.sizeof() as u32 * 8
582 }
583
584 fn update_fmt_chunk(&self, _fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
585 Ok(())
586 }
587
588 fn finish(&mut self, ) -> Result<(), AudioWriteError> {
589 Ok(self.writer.flush()?)
590 }
591
592 fn write_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.writer_from__i8.write_samples(self.writer, samples)}
593 fn write_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.writer_from_i16.write_samples(self.writer, samples)}
594 fn write_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.writer_from_i24.write_samples(self.writer, samples)}
595 fn write_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.writer_from_i32.write_samples(self.writer, samples)}
596 fn write_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.writer_from_i64.write_samples(self.writer, samples)}
597 fn write_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.writer_from__u8.write_samples(self.writer, samples)}
598 fn write_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.writer_from_u16.write_samples(self.writer, samples)}
599 fn write_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.writer_from_u24.write_samples(self.writer, samples)}
600 fn write_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.writer_from_u32.write_samples(self.writer, samples)}
601 fn write_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.writer_from_u64.write_samples(self.writer, samples)}
602 fn write_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {self.writer_from_f32.write_samples(self.writer, samples)}
603 fn write_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.writer_from_f64.write_samples(self.writer, samples)}
604}
605
606#[derive(Debug)]
607pub struct AdpcmEncoderWrap<'a, E>
608where E: adpcm::AdpcmEncoder {
609 writer: &'a mut dyn Writer,
610 channels: u16,
611 sample_rate: u32,
612 bytes_written: u64,
613 encoder: E,
614 nibbles: Vec<u8>,
615}
616
617const MAX_BUFFER_USAGE: usize = 1024;
618
619impl<'a, E> AdpcmEncoderWrap<'a, E>
620where E: adpcm::AdpcmEncoder {
621 pub fn new(writer: &'a mut dyn Writer, spec: Spec) -> Result<Self, AudioWriteError> {
622 Ok(Self {
623 writer,
624 channels: spec.channels,
625 sample_rate: spec.sample_rate,
626 bytes_written: 0,
627 encoder: E::new(spec.channels)?,
628 nibbles: Vec::<u8>::with_capacity(MAX_BUFFER_USAGE),
629 })
630 }
631
632 fn flush_buffers(&mut self) -> Result<(), AudioWriteError> {
633 self.writer.write_all(&self.nibbles)?;
634
635 self.nibbles = Vec::<u8>::with_capacity(MAX_BUFFER_USAGE);
638 Ok(())
639 }
640
641 pub fn write_samples(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {
642 let mut iter = samples.iter().copied();
643 self.encoder.encode(|| -> Option<i16> { iter.next()}, |byte: u8|{ self.nibbles.push(byte); })?;
644 if self.nibbles.len() >= MAX_BUFFER_USAGE {
645 self.flush_buffers()?;
646 }
647 Ok(())
648 }
649
650 pub fn write_stereos(&mut self, stereos: &[(i16, i16)]) -> Result<(), AudioWriteError> {
651 if self.channels != 2 {
652 return Err(AudioWriteError::Unsupported(format!("This encoder only accepts {} channel audio data", self.channels)));
653 }
654 let mut iter = utils::stereos_to_interleaved_samples(stereos).into_iter();
655 self.encoder.encode(|| -> Option<i16> {iter.next()}, |byte: u8|{ self.nibbles.push(byte);})?;
656 if self.nibbles.len() >= MAX_BUFFER_USAGE {
657 self.flush_buffers()?;
658 }
659 Ok(())
660 }
661}
662
663impl<'a, E> EncoderToImpl for AdpcmEncoderWrap<'_, E>
664where E: adpcm::AdpcmEncoder {
665 fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
666 Ok(())
667 }
668
669 fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
670 Ok(self.encoder.new_fmt_chunk(self.channels, self.sample_rate, 4)?)
671 }
672
673 fn get_bitrate(&self) -> u32 {
674 self.sample_rate * self.channels as u32 * 4
675 }
676
677 fn update_fmt_chunk(&self, fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
678 Ok(self.encoder.modify_fmt_chunk(fmt)?)
679 }
680
681 fn finish(&mut self) -> Result<(), AudioWriteError> {
682 self.encoder.flush(|nibble: u8|{ self.nibbles.push(nibble);})?;
683 self.flush_buffers()?;
684 Ok(self.writer.flush()?)
685 }
686
687 fn write_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
688 fn write_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
689 fn write_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
690 fn write_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
691 fn write_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
692 fn write_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
693 fn write_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
694 fn write_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
695 fn write_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
696 fn write_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
697 fn write_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
698 fn write_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
699
700 fn write_stereos__i8(&mut self, stereos: &[(i8 , i8 )]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
701 fn write_stereos_i16(&mut self, stereos: &[(i16, i16)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
702 fn write_stereos_i24(&mut self, stereos: &[(i24, i24)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
703 fn write_stereos_i32(&mut self, stereos: &[(i32, i32)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
704 fn write_stereos_i64(&mut self, stereos: &[(i64, i64)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
705 fn write_stereos__u8(&mut self, stereos: &[(u8 , u8 )]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
706 fn write_stereos_u16(&mut self, stereos: &[(u16, u16)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
707 fn write_stereos_u24(&mut self, stereos: &[(u24, u24)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
708 fn write_stereos_u32(&mut self, stereos: &[(u32, u32)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
709 fn write_stereos_u64(&mut self, stereos: &[(u64, u64)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
710 fn write_stereos_f32(&mut self, stereos: &[(f32, f32)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
711 fn write_stereos_f64(&mut self, stereos: &[(f64, f64)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
712}
713
714#[derive(Debug)]
715pub struct PcmXLawEncoderWrap<'a> {
716 writer: &'a mut dyn Writer,
717 enc: PcmXLawEncoder,
718 channels: u16,
719 sample_rate: u32,
720}
721
722impl<'a> PcmXLawEncoderWrap<'a> {
723 pub fn new(writer: &'a mut dyn Writer, spec: Spec, which_law: XLaw) -> Self {
724 Self {
725 writer,
726 enc: PcmXLawEncoder::new(which_law),
727 channels: spec.channels,
728 sample_rate: spec.sample_rate,
729 }
730 }
731
732 pub fn write_samples(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {
733 self.writer.write_all(&samples.iter().map(|sample| -> u8 {self.enc.encode(*sample)}).collect::<Vec<u8>>())?;
734 Ok(())
735 }
736}
737
738impl<'a> EncoderToImpl for PcmXLawEncoderWrap<'_> {
739 fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
740 Ok(())
741 }
742
743 fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
744 let bits_per_sample = 8u16;
745 let block_align = self.channels;
746 Ok(FmtChunk {
747 format_tag: match self.enc.get_which_law() {
748 XLaw::ALaw => 0x0006,
749 XLaw::MuLaw => 0x0007,
750 },
751 channels: self.channels,
752 sample_rate: self.sample_rate,
753 byte_rate: self.sample_rate * bits_per_sample as u32 * self.channels as u32 / 8,
754 block_align,
755 bits_per_sample,
756 extension: None,
757 })
758 }
759
760 fn get_bitrate(&self) -> u32 {
761 self.sample_rate * self.channels as u32 * 8
762 }
763
764 fn update_fmt_chunk(&self, _fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
765 Ok(())
766 }
767
768 fn finish(&mut self) -> Result<(), AudioWriteError> {
769 Ok(self.writer.flush()?)
770 }
771
772 fn write_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
773 fn write_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
774 fn write_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
775 fn write_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
776 fn write_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
777 fn write_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
778 fn write_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
779 fn write_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
780 fn write_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
781 fn write_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
782 fn write_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
783 fn write_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
784}
785
786pub mod mp3 {
787 #[derive(Debug, Clone, Copy, PartialEq)]
788 #[repr(u8)]
789 pub enum Mp3Channels {
790 Mono = 3,
791 Stereo = 0,
792 JointStereo = 1,
793 DualChannel = 2,
794 NotSet = 4,
795 }
796
797 #[derive(Debug, Clone, Copy, PartialEq)]
798 #[repr(u8)]
799 pub enum Mp3Quality {
800 Best = 0,
801 SecondBest = 1,
802 NearBest = 2,
803 VeryNice = 3,
804 Nice = 4,
805 Good = 5,
806 Decent = 6,
807 Ok = 7,
808 SecondWorst = 8,
809 Worst = 9,
810 }
811
812 #[derive(Debug, Clone, Copy, PartialEq)]
813 #[repr(u16)]
814 pub enum Mp3Bitrate {
815 Kbps8 = 8,
816 Kbps16 = 16,
817 Kbps24 = 24,
818 Kbps32 = 32,
819 Kbps40 = 40,
820 Kbps48 = 48,
821 Kbps64 = 64,
822 Kbps80 = 80,
823 Kbps96 = 96,
824 Kbps112 = 112,
825 Kbps128 = 128,
826 Kbps160 = 160,
827 Kbps192 = 192,
828 Kbps224 = 224,
829 Kbps256 = 256,
830 Kbps320 = 320,
831 }
832
833 #[derive(Debug, Clone, Copy, PartialEq)]
834 #[repr(u8)]
835 pub enum Mp3VbrMode {
836 Off = 0,
837 Mt = 1,
838 Rh = 2,
839 Abr = 3,
840 Mtrh = 4,
841 }
842
843 const ID3_FIELD_LENGTH: usize = 250;
844
845 #[derive(Debug, Clone, Copy, PartialEq)]
846 pub struct Mp3Id3Tag {
847 pub title: [u8; ID3_FIELD_LENGTH],
848 pub artist: [u8; ID3_FIELD_LENGTH],
849 pub album: [u8; ID3_FIELD_LENGTH],
850 pub album_art: [u8; ID3_FIELD_LENGTH],
851 pub year: [u8; ID3_FIELD_LENGTH],
852 pub comment: [u8; ID3_FIELD_LENGTH],
853 }
854
855 #[derive(Debug, Clone, Copy, PartialEq)]
856 pub struct Mp3EncoderOptions {
857 pub channels: Mp3Channels,
858 pub quality: Mp3Quality,
859 pub bitrate: Mp3Bitrate,
860 pub vbr_mode: Mp3VbrMode,
861 pub id3tag: Option<Mp3Id3Tag>,
862 }
863
864 impl Mp3EncoderOptions {
865 pub fn new() -> Self {
866 Self {
867 channels: Mp3Channels::NotSet,
868 quality: Mp3Quality::Best,
869 bitrate: Mp3Bitrate::Kbps320,
870 vbr_mode: Mp3VbrMode::Off,
871 id3tag: None,
872 }
873 }
874
875 pub fn new_mono() -> Self {
876 Self {
877 channels: Mp3Channels::Mono,
878 quality: Mp3Quality::Best,
879 bitrate: Mp3Bitrate::Kbps320,
880 vbr_mode: Mp3VbrMode::Off,
881 id3tag: None,
882 }
883 }
884
885 pub fn new_stereo() -> Self {
886 Self {
887 channels: Mp3Channels::JointStereo,
888 quality: Mp3Quality::Best,
889 bitrate: Mp3Bitrate::Kbps320,
890 vbr_mode: Mp3VbrMode::Off,
891 id3tag: None,
892 }
893 }
894
895 pub fn get_channels(&self) -> u16 {
896 match self.channels {
897 Mp3Channels::Mono => 1,
898 Mp3Channels::Stereo | Mp3Channels::DualChannel | Mp3Channels::JointStereo => 2,
899 Mp3Channels::NotSet => 0,
900 }
901 }
902
903 pub fn get_bitrate(&self) -> u32 {
904 self.bitrate as u32 * 1000
905 }
906 }
907
908 impl Default for Mp3EncoderOptions {
909 fn default() -> Self {
910 Self::new()
911 }
912 }
913
914 #[cfg(feature = "mp3enc")]
915 use super::EncoderToImpl;
916
917 #[cfg(feature = "mp3enc")]
918 pub mod impl_mp3 {
919 use std::{any::type_name, fmt::{self, Debug, Formatter}, sync::{Arc, Mutex}, ops::DerefMut};
920 use super::*;
921 use crate::Writer;
922 use crate::AudioWriteError;
923 use crate::{SampleType, i24, u24};
924 use crate::wavcore::{Spec, FmtChunk, FmtExtension, Mp3Data};
925 use crate::utils::{self, sample_conv, stereos_conv};
926
927 use mp3lame_encoder::{Builder, Encoder, MonoPcm, DualPcm, FlushNoGap};
928 use mp3lame_encoder::{Mode, Quality, Bitrate, VbrMode, Id3Tag};
929
930 const MAX_SAMPLES_TO_ENCODE: usize = 1024;
931
932 #[derive(Clone)]
933 pub struct SharedMp3Encoder(Arc<Mutex<Encoder>>);
934
935 impl SharedMp3Encoder{
936 pub fn new(encoder: Encoder) -> Self {
937 Self(Arc::new(Mutex::new(encoder)))
938 }
939
940 pub fn escorted_encode<T, F, E>(&self, mut action: F) -> Result<T, E>
941 where F: FnMut(&mut Encoder) -> Result<T, E> {
942 let mut guard = self.0.lock().unwrap();
943 let encoder = guard.deref_mut();
944 (action)(encoder)
945 }
946 }
947
948 impl Mp3Channels {
949 pub fn to_lame_mode(&self) -> Mode {
950 match self {
951 Self::Mono => Mode::Mono,
952 Self::Stereo => Mode::Stereo,
953 Self::JointStereo => Mode::JointStereo,
954 Self::DualChannel => Mode::DaulChannel,
955 Self::NotSet => Mode::NotSet,
956 }
957 }
958 }
959
960 impl Mp3Quality {
961 pub fn to_lame_quality(&self) -> Quality {
962 match self {
963 Self::Best => Quality::Best,
964 Self::SecondBest => Quality::SecondBest,
965 Self::NearBest => Quality::NearBest,
966 Self::VeryNice => Quality::VeryNice,
967 Self::Nice => Quality::Nice,
968 Self::Good => Quality::Good,
969 Self::Decent => Quality::Decent,
970 Self::Ok => Quality::Ok,
971 Self::SecondWorst => Quality::SecondWorst,
972 Self::Worst => Quality::Worst,
973 }
974 }
975 }
976
977 impl Mp3Bitrate {
978 pub fn to_lame_bitrate(&self) -> Bitrate {
979 match self {
980 Self::Kbps8 => Bitrate::Kbps8,
981 Self::Kbps16 => Bitrate::Kbps16,
982 Self::Kbps24 => Bitrate::Kbps24,
983 Self::Kbps32 => Bitrate::Kbps32,
984 Self::Kbps40 => Bitrate::Kbps40,
985 Self::Kbps48 => Bitrate::Kbps48,
986 Self::Kbps64 => Bitrate::Kbps64,
987 Self::Kbps80 => Bitrate::Kbps80,
988 Self::Kbps96 => Bitrate::Kbps96,
989 Self::Kbps112 => Bitrate::Kbps112,
990 Self::Kbps128 => Bitrate::Kbps128,
991 Self::Kbps160 => Bitrate::Kbps160,
992 Self::Kbps192 => Bitrate::Kbps192,
993 Self::Kbps224 => Bitrate::Kbps224,
994 Self::Kbps256 => Bitrate::Kbps256,
995 Self::Kbps320 => Bitrate::Kbps320,
996 }
997 }
998 }
999
1000 impl Mp3VbrMode {
1001 pub fn to_lame_vbr_mode(&self) -> VbrMode {
1002 match self {
1003 Self::Off => VbrMode::Off,
1004 Self::Mt => VbrMode::Mt,
1005 Self::Rh => VbrMode::Rh,
1006 Self::Abr => VbrMode::Abr,
1007 Self::Mtrh => VbrMode::Mtrh,
1008 }
1009 }
1010 }
1011
1012 #[derive(Clone)]
1013 pub struct Mp3EncoderLameOptions {
1014 channels: Mode,
1015 quality: Quality,
1016 bitrate: Bitrate,
1017 vbr_mode: VbrMode,
1018 id3tag: Option<Mp3Id3Tag>,
1019 }
1020
1021 impl Mp3EncoderOptions {
1022 pub fn to_lame_options(&self) -> Mp3EncoderLameOptions{
1023 Mp3EncoderLameOptions {
1024 channels: self.channels.to_lame_mode(),
1025 quality: self.quality.to_lame_quality(),
1026 bitrate: self.bitrate.to_lame_bitrate(),
1027 vbr_mode: self.vbr_mode.to_lame_vbr_mode(),
1028 id3tag: self.id3tag,
1029 }
1030 }
1031 }
1032
1033 #[derive(Debug)]
1034 pub struct Mp3Encoder<'a, S>
1035 where S: SampleType {
1036 channels: u16,
1037 sample_rate: u32,
1038 bitrate: u32,
1039 encoder: SharedMp3Encoder,
1040 encoder_options: Mp3EncoderOptions,
1041 buffers: ChannelBuffers<'a, S>,
1042 }
1043
1044 impl<'a, S> Mp3Encoder<'a, S>
1045 where S: SampleType {
1046 pub fn new(writer: &'a mut dyn Writer, spec: Spec, mp3_options: &Mp3EncoderOptions) -> Result<Self, AudioWriteError> {
1047 if spec.channels != mp3_options.get_channels() {
1048 return Err(AudioWriteError::InvalidArguments(format!("The number of channels from `spec` is {}, but from `mp3_options` is {}", spec.channels, mp3_options.get_channels())));
1049 }
1050
1051 let mp3_builder = Builder::new();
1052 let mut mp3_builder = match mp3_builder {
1053 Some(mp3_builder) => mp3_builder,
1054 None => return Err(AudioWriteError::OtherReason("`lame_init()` somehow failed.".to_owned())),
1055 };
1056 let options = mp3_options.to_lame_options();
1057
1058 mp3_builder.set_mode(options.channels)?;
1059 mp3_builder.set_sample_rate(spec.sample_rate)?;
1060 mp3_builder.set_brate(options.bitrate)?;
1061 mp3_builder.set_quality(options.quality)?;
1062 mp3_builder.set_vbr_mode(options.vbr_mode)?;
1063
1064 match options.vbr_mode {
1065 VbrMode::Off => mp3_builder.set_to_write_vbr_tag(false)?,
1066 _ => {
1067 mp3_builder.set_to_write_vbr_tag(true)?;
1068 mp3_builder.set_vbr_quality(options.quality)?;
1069 }
1070 }
1071
1072 if let Some(id3tag) = options.id3tag {
1073 mp3_builder.set_id3_tag(Id3Tag{
1074 title: &id3tag.title,
1075 artist: &id3tag.artist,
1076 album: &id3tag.album,
1077 album_art: &id3tag.album_art,
1078 year: &id3tag.year,
1079 comment: &id3tag.comment,
1080 })?;
1081 }
1082
1083 let encoder = SharedMp3Encoder::new(mp3_builder.build()?);
1084
1085 let channels = mp3_options.get_channels();
1086 Ok(Self {
1087 channels,
1088 sample_rate: spec.sample_rate,
1089 bitrate: mp3_options.get_bitrate(),
1090 encoder: encoder.clone(),
1091 encoder_options: *mp3_options,
1092 buffers: match channels {
1093 1 | 2 => ChannelBuffers::<'a, S>::new(writer, encoder.clone(), MAX_SAMPLES_TO_ENCODE, channels)?,
1094 o => return Err(AudioWriteError::Unsupported(format!("Bad channel number: {o}"))),
1095 },
1096 })
1097 }
1098
1099 pub fn write_samples<T>(&mut self, samples: &[T]) -> Result<(), AudioWriteError>
1100 where T: SampleType {
1101 if self.buffers.is_full() {
1102 self.buffers.flush()?;
1103 }
1104 match self.channels {
1105 1 => self.buffers.add_monos(&sample_conv::<T, S>(samples)),
1106 2 => self.buffers.add_stereos(&utils::interleaved_samples_to_stereos(&sample_conv::<T, S>(samples))?),
1107 o => Err(AudioWriteError::Unsupported(format!("Bad channels number: {o}"))),
1108 }
1109 }
1110
1111 pub fn write_stereos<T>(&mut self, stereos: &[(T, T)]) -> Result<(), AudioWriteError>
1112 where T: SampleType {
1113 if self.buffers.is_full() {
1114 self.buffers.flush()?;
1115 }
1116 match self.channels{
1117 1 => self.buffers.add_monos(&utils::stereos_to_monos(&stereos_conv::<T, S>(stereos))),
1118 2 => self.buffers.add_stereos(&stereos_conv::<T, S>(stereos)),
1119 o => Err(AudioWriteError::InvalidArguments(format!("Bad channels number: {o}"))),
1120 }
1121 }
1122
1123 pub fn write_dual_monos<T>(&mut self, mono_l: &[T], mono_r: &[T]) -> Result<(), AudioWriteError>
1124 where T: SampleType {
1125 if self.buffers.is_full() {
1126 self.buffers.flush()?;
1127 }
1128 match self.channels{
1129 1 => self.buffers.add_monos(&sample_conv::<T, S>(&utils::dual_monos_to_monos(&(mono_l.to_vec(), mono_r.to_vec()))?)),
1130 2 => self.buffers.add_dual_monos(&sample_conv::<T, S>(mono_l), &sample_conv::<T, S>(mono_r)),
1131 o => Err(AudioWriteError::InvalidArguments(format!("Bad channels number: {o}"))),
1132 }
1133 }
1134
1135 pub fn finish(&mut self) -> Result<(), AudioWriteError> {
1136 self.buffers.finish()
1137 }
1138 }
1139
1140 #[derive(Debug, Clone)]
1141 enum Channels<S>
1142 where S: SampleType {
1143 Mono(Vec<S>),
1144 Stereo((Vec<S>, Vec<S>)),
1145 }
1146
1147 struct ChannelBuffers<'a, S>
1148 where S: SampleType {
1149 writer: &'a mut dyn Writer,
1150 encoder: SharedMp3Encoder,
1151 channels: Channels<S>,
1152 max_frames: usize,
1153 }
1154
1155 impl<S> Channels<S>
1156 where S: SampleType {
1157 pub fn new_mono(max_frames: usize) -> Self {
1158 Self::Mono(Vec::<S>::with_capacity(max_frames))
1159 }
1160 pub fn new_stereo(max_frames: usize) -> Self {
1161 Self::Stereo((Vec::<S>::with_capacity(max_frames), Vec::<S>::with_capacity(max_frames)))
1162 }
1163 pub fn add_mono(&mut self, frame: S) {
1164 match self {
1165 Self::Mono(m) => m.push(frame),
1166 Self::Stereo((l, r)) => {
1167 l.push(frame);
1168 r.push(frame);
1169 },
1170 }
1171 }
1172 pub fn add_stereo(&mut self, frame: (S, S)) {
1173 match self {
1174 Self::Mono(m) => m.push(S::average(frame.0, frame.1)),
1175 Self::Stereo((l, r)) => {
1176 l.push(frame.0);
1177 r.push(frame.1);
1178 },
1179 }
1180 }
1181 pub fn add_monos(&mut self, frames: &[S]) {
1182 match self {
1183 Self::Mono(m) => m.extend(frames),
1184 Self::Stereo((l, r)) => {
1185 l.extend(frames);
1186 r.extend(frames);
1187 },
1188 }
1189 }
1190 pub fn add_stereos(&mut self, frames: &[(S, S)]) {
1191 match self {
1192 Self::Mono(m) => m.extend(utils::stereos_to_monos(frames)),
1193 Self::Stereo((l, r)) => {
1194 let (il, ir) = utils::stereos_to_dual_monos(frames);
1195 l.extend(il);
1196 r.extend(ir);
1197 },
1198 }
1199 }
1200 pub fn add_dual_monos(&mut self, monos_l: &[S], monos_r: &[S]) -> Result<(), AudioWriteError> {
1201 match self {
1202 Self::Mono(m) => m.extend(utils::dual_monos_to_monos(&(monos_l.to_vec(), monos_r.to_vec()))?),
1203 Self::Stereo((l, r)) => {
1204 if monos_l.len() != monos_r.len() {
1205 return Err(AudioWriteError::MultipleMonosAreNotSameSize);
1206 }
1207 l.extend(monos_l);
1208 r.extend(monos_r);
1209 },
1210 }
1211 Ok(())
1212 }
1213 pub fn len(&self) -> usize {
1214 match self {
1215 Self::Mono(m) => m.len(),
1216 Self::Stereo((l, r)) => {
1217 assert_eq!(l.len(), r.len());
1218 l.len()
1219 },
1220 }
1221 }
1222 pub fn is_empty(&self) -> bool {
1223 match self {
1224 Self::Mono(m) => m.is_empty(),
1225 Self::Stereo((l, r)) => l.is_empty() && r.is_empty(),
1226 }
1227 }
1228 pub fn get_channels(&self) -> u16 {
1229 match self {
1230 Self::Mono(_) => 1,
1231 Self::Stereo(_) => 2,
1232 }
1233 }
1234 pub fn clear(&mut self, max_frames: usize) {
1235 match self {
1236 Self::Mono(ref mut m) => *m = Vec::<S>::with_capacity(max_frames),
1237 Self::Stereo(ref mut s) => *s = (Vec::<S>::with_capacity(max_frames), Vec::<S>::with_capacity(max_frames)),
1238 }
1239 }
1240 }
1241
1242 impl<'a, S> ChannelBuffers<'a, S>
1243 where S: SampleType{
1244 pub fn new(writer: &'a mut dyn Writer, encoder: SharedMp3Encoder, max_frames: usize, channels: u16) -> Result<Self, AudioWriteError> {
1245 Ok(Self {
1246 writer,
1247 encoder,
1248 channels: match channels {
1249 1 => Channels::<S>::new_mono(max_frames),
1250 2 => Channels::<S>::new_stereo(max_frames),
1251 o => return Err(AudioWriteError::InvalidArguments(format!("Invalid channels: {o}. Only 1 and 2 are accepted."))),
1252 },
1253 max_frames,
1254 })
1255 }
1256
1257 pub fn is_full(&self) -> bool {
1258 self.channels.len() >= self.max_frames
1259 }
1260
1261 pub fn add_monos(&mut self, monos: &[S]) -> Result<(), AudioWriteError> {
1262 self.channels.add_monos(monos);
1263 if self.is_full() {
1264 self.flush()?;
1265 }
1266 Ok(())
1267 }
1268
1269 pub fn add_stereos(&mut self, stereos: &[(S, S)]) -> Result<(), AudioWriteError> {
1270 self.channels.add_stereos(stereos);
1271 if self.is_full() {
1272 self.flush()?;
1273 }
1274 Ok(())
1275 }
1276
1277 pub fn add_dual_monos(&mut self, monos_l: &[S], monos_r: &[S]) -> Result<(), AudioWriteError> {
1278 self.channels.add_dual_monos(monos_l, monos_r)?;
1279 if self.is_full() {
1280 self.flush()?;
1281 }
1282 Ok(())
1283 }
1284
1285 fn channel_to_type<T>(mono: &[S]) -> Vec<T>
1286 where T: SampleType {
1287 mono.iter().map(|s|{T::from(*s)}).collect()
1288 }
1289
1290 fn encode_to_vec(&self, encoder: &mut Encoder, out_buf :&mut Vec<u8>) -> Result<usize, AudioWriteError> {
1291 match &self.channels {
1293 Channels::Mono(pcm) => {
1294 match std::any::type_name::<S>() {
1295 "i16" => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<i16>(pcm)), out_buf)?),
1296 "u16" => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<u16>(pcm)), out_buf)?),
1297 "i32" => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<i32>(pcm)), out_buf)?),
1298 "f32" => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<f32>(pcm)), out_buf)?),
1299 "f64" => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<f64>(pcm)), out_buf)?),
1300 "i8" => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<i16>(pcm)), out_buf)?),
1301 "u8" => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<u16>(pcm)), out_buf)?),
1302 "i24" | "u24" | "u32" => Ok(encoder.encode_to_vec(MonoPcm(&Self::channel_to_type::<i32>(pcm)), out_buf)?),
1303 other => Err(AudioWriteError::Unsupported(format!("\"{other}\""))),
1304 }
1305 },
1306 Channels::Stereo(pcm) => {
1307 match std::any::type_name::<S>() {
1308 "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)?),
1309 "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)?),
1310 "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)?),
1311 "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)?),
1312 "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)?),
1313 "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)?),
1314 "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)?),
1315 "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)?),
1316 other => Err(AudioWriteError::Unsupported(format!("\"{other}\""))),
1317 }
1318 },
1319 }
1320 }
1321
1322 pub fn flush(&mut self) -> Result<(), AudioWriteError> {
1323 if self.channels.is_empty() {
1324 return Ok(())
1325 }
1326 let to_save = self.encoder.escorted_encode(|encoder| -> Result<Vec<u8>, AudioWriteError> {
1327 let mut to_save = Vec::<u8>::with_capacity(mp3lame_encoder::max_required_buffer_size(self.channels.len()));
1328 self.encode_to_vec(encoder, &mut to_save)?;
1329 Ok(to_save)
1330 })?;
1331 self.writer.write_all(&to_save)?;
1332 self.channels.clear(self.max_frames);
1333 Ok(())
1334 }
1335
1336 pub fn finish(&mut self) -> Result<(), AudioWriteError> {
1337 self.flush()?;
1338 self.encoder.escorted_encode(|encoder| -> Result<(), AudioWriteError> {
1339 let mut to_save = Vec::<u8>::with_capacity(mp3lame_encoder::max_required_buffer_size(self.max_frames));
1340 encoder.flush_to_vec::<FlushNoGap>(&mut to_save)?;
1341 self.writer.write_all(&to_save)?;
1342 Ok(())
1343 })?;
1344 self.channels.clear(self.max_frames);
1345 Ok(())
1346 }
1347 }
1348
1349 impl<'a, S> EncoderToImpl for Mp3Encoder<'_, S>
1350 where S: SampleType {
1351 fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
1352 Ok(())
1353 }
1354
1355 fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
1356 Ok(FmtChunk{
1357 format_tag: 0x0055,
1358 channels: self.channels,
1359 sample_rate: self.sample_rate,
1360 byte_rate: self.bitrate / 8,
1361 block_align: 1,
1362 bits_per_sample: 0,
1363 extension: Some(FmtExtension::new_mp3(Mp3Data::new(self.bitrate, self.sample_rate))),
1364 })
1365 }
1366
1367 fn get_bitrate(&self) -> u32 {
1368 self.bitrate * self.channels as u32
1369 }
1370
1371 fn update_fmt_chunk(&self, _fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
1372 Ok(())
1373 }
1374
1375 fn finish(&mut self) -> Result<(), AudioWriteError> {
1376 self.finish()
1377 }
1378
1379 fn write_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.write_samples(samples)}
1380 fn write_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.write_samples(samples)}
1381 fn write_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.write_samples(samples)}
1382 fn write_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.write_samples(samples)}
1383 fn write_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.write_samples(samples)}
1384 fn write_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.write_samples(samples)}
1385 fn write_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.write_samples(samples)}
1386 fn write_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.write_samples(samples)}
1387 fn write_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.write_samples(samples)}
1388 fn write_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.write_samples(samples)}
1389 fn write_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {self.write_samples(samples)}
1390 fn write_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.write_samples(samples)}
1391
1392 fn write_stereos__i8(&mut self, stereos: &[(i8 , i8 )]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1393 fn write_stereos_i16(&mut self, stereos: &[(i16, i16)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1394 fn write_stereos_i24(&mut self, stereos: &[(i24, i24)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1395 fn write_stereos_i32(&mut self, stereos: &[(i32, i32)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1396 fn write_stereos_i64(&mut self, stereos: &[(i64, i64)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1397 fn write_stereos__u8(&mut self, stereos: &[(u8 , u8 )]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1398 fn write_stereos_u16(&mut self, stereos: &[(u16, u16)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1399 fn write_stereos_u24(&mut self, stereos: &[(u24, u24)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1400 fn write_stereos_u32(&mut self, stereos: &[(u32, u32)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1401 fn write_stereos_u64(&mut self, stereos: &[(u64, u64)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1402 fn write_stereos_f32(&mut self, stereos: &[(f32, f32)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1403 fn write_stereos_f64(&mut self, stereos: &[(f64, f64)]) -> Result<(), AudioWriteError> {self.write_stereos(stereos)}
1404
1405 fn write_dual_monos__i8(&mut self, mono1: &[i8 ], mono2: &[i8 ]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1406 fn write_dual_monos_i16(&mut self, mono1: &[i16], mono2: &[i16]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1407 fn write_dual_monos_i24(&mut self, mono1: &[i24], mono2: &[i24]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1408 fn write_dual_monos_i32(&mut self, mono1: &[i32], mono2: &[i32]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1409 fn write_dual_monos_i64(&mut self, mono1: &[i64], mono2: &[i64]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1410 fn write_dual_monos__u8(&mut self, mono1: &[u8 ], mono2: &[u8 ]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1411 fn write_dual_monos_u16(&mut self, mono1: &[u16], mono2: &[u16]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1412 fn write_dual_monos_u24(&mut self, mono1: &[u24], mono2: &[u24]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1413 fn write_dual_monos_u32(&mut self, mono1: &[u32], mono2: &[u32]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1414 fn write_dual_monos_u64(&mut self, mono1: &[u64], mono2: &[u64]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1415 fn write_dual_monos_f32(&mut self, mono1: &[f32], mono2: &[f32]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1416 fn write_dual_monos_f64(&mut self, mono1: &[f64], mono2: &[f64]) -> Result<(), AudioWriteError> {self.write_dual_monos(mono1, mono2)}
1417 }
1418
1419 impl Debug for SharedMp3Encoder {
1420 fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
1421 fmt.debug_struct("SharedMp3Encoder")
1422 .finish_non_exhaustive()
1423 }
1424 }
1425
1426 impl<'a, S> Debug for ChannelBuffers<'_, S>
1427 where S: SampleType {
1428 fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
1429 fmt.debug_struct(&format!("ChannelBuffers<{}>", type_name::<S>()))
1430 .field("encoder", &self.encoder)
1431 .field("channels", &format_args!("{}", match self.channels {
1432 Channels::Mono(_) => "Mono",
1433 Channels::Stereo(_) => "Stereo",
1434 }))
1435 .field("max_frames", &self.max_frames)
1436 .finish()
1437 }
1438 }
1439 }
1440
1441 #[cfg(feature = "mp3enc")]
1442 pub use impl_mp3::*;
1443}
1444
1445pub mod opus {
1446 const OPUS_ALLOWED_SAMPLE_RATES: [u32; 5] = [8000, 12000, 16000, 24000, 48000];
1447 const OPUS_MIN_SAMPLE_RATE: u32 = 8000;
1448 const OPUS_MAX_SAMPLE_RATE: u32 = 48000;
1449
1450 #[derive(Debug, Clone, Copy, PartialEq)]
1451 #[repr(u32)]
1452 pub enum OpusEncoderSampleDuration {
1453 MilliSec2_5 = 25,
1454 MilliSec5 = 50,
1455 MilliSec10 = 100,
1456 MilliSec20 = 200,
1457 MilliSec40 = 400,
1458 MilliSec60 = 600,
1459 }
1460
1461 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
1462 pub enum OpusBitrate {
1463 Bits(i32),
1464 Max,
1465 Auto,
1466 }
1467
1468 impl OpusEncoderSampleDuration {
1469 pub fn get_num_samples(&self, channels: u16, sample_rate: u32) -> usize {
1470 let ms_m_10 = match self {
1471 Self::MilliSec2_5 => 25,
1472 Self::MilliSec5 => 50,
1473 Self::MilliSec10 => 100,
1474 Self::MilliSec20 => 200,
1475 Self::MilliSec40 => 400,
1476 Self::MilliSec60 => 600,
1477 };
1478 (sample_rate as usize * ms_m_10 as usize) * channels as usize / 10000
1479 }
1480 }
1481
1482 #[derive(Debug, Clone, Copy, PartialEq)]
1483 pub struct OpusEncoderOptions {
1484 pub bitrate: OpusBitrate,
1485 pub encode_vbr: bool,
1486 pub samples_cache_duration: OpusEncoderSampleDuration,
1487 }
1488
1489 impl OpusEncoderOptions {
1490 pub fn new() -> Self {
1491 Self {
1492 bitrate: OpusBitrate::Max,
1493 encode_vbr: false,
1494 samples_cache_duration: OpusEncoderSampleDuration::MilliSec60,
1495 }
1496 }
1497
1498 pub fn get_allowed_sample_rates(&self) -> [u32; OPUS_ALLOWED_SAMPLE_RATES.len()] {
1499 OPUS_ALLOWED_SAMPLE_RATES
1500 }
1501
1502 pub fn get_rounded_up_sample_rate(&self, sample_rate: u32) -> u32 {
1503 if sample_rate <= OPUS_MIN_SAMPLE_RATE {
1504 OPUS_MIN_SAMPLE_RATE
1505 } else if sample_rate >= OPUS_MAX_SAMPLE_RATE {
1506 OPUS_MAX_SAMPLE_RATE
1507 } else {
1508 for (l, h) in OPUS_ALLOWED_SAMPLE_RATES[..OPUS_ALLOWED_SAMPLE_RATES.len() - 1].iter().zip(OPUS_ALLOWED_SAMPLE_RATES[1..].iter()) {
1509 if sample_rate > *l && sample_rate <= *h {
1510 return *h;
1511 }
1512 }
1513 OPUS_MAX_SAMPLE_RATE
1514 }
1515 }
1516 }
1517
1518 impl Default for OpusEncoderOptions {
1519 fn default() -> Self {
1520 Self::new()
1521 }
1522 }
1523
1524 #[cfg(feature = "opus")]
1525 use super::EncoderToImpl;
1526
1527 #[cfg(feature = "opus")]
1528 pub mod impl_opus {
1529 use std::{mem, fmt::{self, Debug, Formatter}};
1530
1531 use super::*;
1532 use crate::Writer;
1533 use crate::wavcore::{Spec, FmtChunk};
1534 use crate::AudioWriteError;
1535 use crate::{i24, u24};
1536 use crate::utils::sample_conv;
1537
1538 use opus::{Encoder, Application, Channels, Bitrate};
1539
1540 impl OpusBitrate {
1541 pub fn to_opus_bitrate(&self) -> Bitrate {
1542 match self {
1543 Self::Bits(bitrate) => Bitrate::Bits(*bitrate),
1544 Self::Max => Bitrate::Max,
1545 Self::Auto => Bitrate::Auto,
1546 }
1547 }
1548 }
1549
1550 pub struct OpusEncoder<'a> {
1551 writer: &'a mut dyn Writer,
1552 encoder: Encoder,
1553 channels: u16,
1554 sample_rate: u32,
1555 cache_duration: OpusEncoderSampleDuration,
1556 num_samples_per_encode: usize,
1557 sample_cache: Vec<f32>,
1558 samples_written: u64,
1559 bytes_written: u64,
1560 }
1561
1562 impl<'a> OpusEncoder<'a> {
1563 pub fn new(writer: &'a mut dyn Writer, spec: Spec, options: &OpusEncoderOptions) -> Result<Self, AudioWriteError> {
1564 let opus_channels = match spec.channels {
1565 1 => Channels::Mono,
1566 2 => Channels::Stereo,
1567 o => return Err(AudioWriteError::InvalidArguments(format!("Bad channels: {o} for the opus encoder."))),
1568 };
1569 if !OPUS_ALLOWED_SAMPLE_RATES.contains(&spec.sample_rate) {
1570 return Err(AudioWriteError::InvalidArguments(format!("Bad sample rate: {} for the opus encoder. The sample rate must be one of {}",
1571 spec.sample_rate, OPUS_ALLOWED_SAMPLE_RATES.iter().map(|s|{format!("{s}")}).collect::<Vec<String>>().join(", ")
1572 )));
1573 }
1574 let mut encoder = Encoder::new(spec.sample_rate, opus_channels, Application::Audio)?;
1575 encoder.set_bitrate(options.bitrate.to_opus_bitrate())?;
1576 encoder.set_vbr(options.encode_vbr)?;
1577 let num_samples_per_encode = options.samples_cache_duration.get_num_samples(spec.channels, spec.sample_rate);
1578 Ok(Self {
1579 writer,
1580 encoder,
1581 channels: spec.channels,
1582 sample_rate: spec.sample_rate,
1583 cache_duration: options.samples_cache_duration,
1584 num_samples_per_encode,
1585 sample_cache: Vec::<f32>::new(),
1586 samples_written: 0,
1587 bytes_written: 0,
1588 })
1589 }
1590
1591 pub fn set_cache_duration(&mut self, samples_cache_duration: OpusEncoderSampleDuration) {
1592 self.cache_duration = samples_cache_duration;
1593 self.num_samples_per_encode = samples_cache_duration.get_num_samples(self.channels, self.sample_rate);
1594 }
1595
1596 pub fn write_samples(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {
1597 self.sample_cache.extend(samples);
1598 let mut cached_length = self.sample_cache.len();
1599 let mut iter = mem::take(&mut self.sample_cache).into_iter();
1600 while cached_length >= self.num_samples_per_encode {
1601
1602 let samples_to_write: Vec<f32> = iter.by_ref().take(self.num_samples_per_encode).collect();
1604 if samples_to_write.is_empty() {break;}
1605
1606 let mut buf = vec![0u8; self.num_samples_per_encode];
1608
1609 let size = self.encoder.encode_float(&samples_to_write, &mut buf)?;
1611 assert_eq!(size, buf.len());
1612 self.writer.write_all(&buf)?;
1613
1614 cached_length -= self.num_samples_per_encode;
1616 self.samples_written += self.num_samples_per_encode as u64;
1617 self.bytes_written += buf.len() as u64;
1618 }
1619 self.sample_cache = iter.collect();
1620 Ok(())
1621 }
1622
1623 pub fn flush(&mut self) -> Result<(), AudioWriteError> {
1624 if !self.sample_cache.is_empty() {
1625 let pad = (self.num_samples_per_encode - self.sample_cache.len() % self.num_samples_per_encode) % self.num_samples_per_encode;
1626
1627 self.write_samples(&vec![0.0f32; pad])?;
1629 }
1630 Ok(())
1631 }
1632 }
1633
1634 impl<'a> Debug for OpusEncoder<'_> {
1635 fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
1636 fmt.debug_struct("OpusEncoder")
1637 .field("writer", &self.writer)
1638 .field("encoder", &self.encoder)
1639 .field("channels", &self.channels)
1640 .field("sample_rate", &self.sample_rate)
1641 .field("cache_duration", &self.cache_duration)
1642 .field("num_samples_per_encode", &self.num_samples_per_encode)
1643 .field("sample_cache", &format_args!("[f32; {}]", self.sample_cache.len()))
1644 .field("samples_written", &self.samples_written)
1645 .field("bytes_written", &self.bytes_written)
1646 .finish()
1647 }
1648 }
1649
1650 impl<'a> EncoderToImpl for OpusEncoder<'_> {
1651 fn get_bitrate(&self) -> u32 {
1652 if self.samples_written != 0 {
1653 (self.sample_rate as u64 * self.bytes_written / self.samples_written * self.channels as u64 * 8) as u32
1654 } else {
1655 self.sample_rate * self.channels as u32 * 8 }
1657 }
1658 fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
1659 Ok(())
1660 }
1661
1662 fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
1663 Ok(FmtChunk{
1664 format_tag: 0x704F,
1665 channels: self.channels,
1666 sample_rate: self.sample_rate,
1667 byte_rate: self.get_bitrate() / 8,
1668 block_align: self.num_samples_per_encode as u16,
1669 bits_per_sample: 0,
1670 extension: None,
1671 })
1672 }
1673 fn update_fmt_chunk(&self, fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
1674 fmt.byte_rate = self.get_bitrate() / 8;
1675 fmt.block_align = self.num_samples_per_encode as u16;
1676 Ok(())
1677 }
1678 fn finish(&mut self) -> Result<(), AudioWriteError> {
1679 self.flush()?;
1680 self.writer.flush()?;
1681 Ok(())
1682 }
1683
1684 fn write_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
1685 fn write_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
1686 fn write_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
1687 fn write_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
1688 fn write_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
1689 fn write_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
1690 fn write_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
1691 fn write_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
1692 fn write_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
1693 fn write_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
1694 fn write_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
1695 fn write_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.write_samples(&sample_conv(samples))}
1696 }
1697 }
1698
1699 #[cfg(feature = "opus")]
1700 pub use impl_opus::*;
1701}
1702
1703#[cfg(feature = "flac")]
1704pub mod flac {
1705 use std::{io::{self, SeekFrom}, borrow::Cow};
1706
1707 use super::EncoderToImpl;
1708
1709 use crate::{i24, u24};
1710 use crate::AudioWriteError;
1711 use crate::wavcore::FmtChunk;
1712 use crate::flac::*;
1713 use crate::utils::{sample_conv, stereos_conv, sample_conv_batch};
1714
1715 #[derive(Debug)]
1716 pub struct FlacEncoderWrap<'a> {
1717 encoder: Box<FlacEncoderUnmovable<'a>>,
1718 params: FlacEncoderParams,
1719 write_offset: u64,
1720 frames_written: u64,
1721 bytes_written: Box<u64>,
1722 }
1723
1724 impl<'a> FlacEncoderWrap<'a> {
1725 pub fn new(writer: &'a mut dyn WriteSeek, params: &FlacEncoderParams) -> Result<Self, AudioWriteError> {
1726 let write_offset = writer.stream_position()?;
1727 let mut bytes_written = Box::new(0u64);
1728 let bytes_written_ptr = (&mut *bytes_written) as *mut u64;
1729 Ok(Self{
1730 encoder: Box::new(FlacEncoderUnmovable::new(
1732 writer,
1733 Box::new(move |writer: &mut dyn WriteSeek, data: &[u8]| -> Result<(), io::Error> {
1734 unsafe{*bytes_written_ptr += data.len() as u64};
1735 writer.write_all(data)
1736 }),
1737 Box::new(move |writer: &mut dyn WriteSeek, position: u64| -> Result<(), io::Error> {
1738 writer.seek(SeekFrom::Start(write_offset + position))?;
1739 Ok(())
1740 }),
1741 Box::new(move |writer: &mut dyn WriteSeek| -> Result<u64, io::Error> {
1742 Ok(write_offset + writer.stream_position()?)
1743 }),
1744 params
1745 )?),
1746 params: *params,
1747 write_offset,
1748 frames_written: 0,
1749 bytes_written,
1750 })
1751 }
1752
1753 #[inline(always)]
1755 fn fit_32bit_to_bps(&self, sample: i32) -> i32 {
1756 sample >> (32 - self.params.bits_per_sample)
1757 }
1758
1759 fn fit_samples_to_bps<'b>(&self, samples: &'b [i32]) -> Cow<'b, [i32]> {
1761 if self.params.bits_per_sample == 32 {
1762 Cow::Borrowed(samples)
1763 } else {
1764 Cow::Owned(samples.iter().map(|sample|{self.fit_32bit_to_bps(*sample)}).collect())
1765 }
1766 }
1767
1768 fn fit_stereos_to_bps<'b>(&self, stereos: &'b [(i32, i32)]) -> Cow<'b, [(i32, i32)]> {
1770 if self.params.bits_per_sample == 32 {
1771 Cow::Borrowed(stereos)
1772 } else {
1773 Cow::Owned(stereos.iter().map(|(l,r)|{(self.fit_32bit_to_bps(*l), self.fit_32bit_to_bps(*r))}).collect::<Vec<(i32, i32)>>())
1774 }
1775 }
1776
1777 fn fit_2d_to_bps<'b>(&self, two_d: &'b [Vec<i32>]) -> Cow<'b, [Vec<i32>]> {
1779 if self.params.bits_per_sample == 32 {
1780 Cow::Borrowed(two_d)
1781 } else {
1782 Cow::Owned(two_d.iter().map(|mono|{self.fit_samples_to_bps(mono).to_vec()}).collect())
1783 }
1784 }
1785
1786 fn check_channels(&self, channels: u16) -> Result<(), AudioWriteError> {
1787 if channels != self.params.channels {
1788 Err(AudioWriteError::WrongChannels(format!("The encoder channels is {} but {channels} channels audio data are asked to be written.", self.params.channels)))
1789 } else {
1790 Ok(())
1791 }
1792 }
1793
1794 #[inline(always)]
1795 pub fn get_channels(&self) -> u16 {
1796 self.params.channels
1797 }
1798
1799 #[inline(always)]
1800 pub fn get_sample_rate(&self) -> u32 {
1801 self.params.sample_rate
1802 }
1803
1804 pub fn write_interleaved_samples(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {
1805 match self.encoder.write_interleaved_samples(&self.fit_samples_to_bps(samples)) {
1806 Ok(_) => Ok(self.frames_written += samples.len() as u64 / self.get_channels() as u64),
1807 Err(e) => Err(AudioWriteError::from(e)),
1808 }
1809 }
1810
1811 pub fn write_mono_channel(&mut self, monos: &[i32]) -> Result<(), AudioWriteError> {
1812 match self.encoder.write_mono_channel(&self.fit_samples_to_bps(monos)) {
1813 Ok(_) => Ok(self.frames_written += monos.len() as u64),
1814 Err(e) => Err(AudioWriteError::from(e)),
1815 }
1816 }
1817
1818 pub fn write_stereos(&mut self, stereos: &[(i32, i32)]) -> Result<(), AudioWriteError> {
1819 match self.encoder.write_stereos(&self.fit_stereos_to_bps(stereos)) {
1820 Ok(_) => Ok(self.frames_written += stereos.len() as u64),
1821 Err(e) => Err(AudioWriteError::from(e)),
1822 }
1823 }
1824
1825 pub fn write_monos(&mut self, monos: &[Vec<i32>]) -> Result<(), AudioWriteError> {
1826 match self.encoder.write_monos(&self.fit_2d_to_bps(monos)) {
1827 Ok(_) => Ok(self.frames_written += monos[0].len() as u64),
1828 Err(e) => Err(AudioWriteError::from(e)),
1829 }
1830 }
1831
1832 pub fn write_frames(&mut self, frames: &[Vec<i32>]) -> Result<(), AudioWriteError> {
1833 match self.encoder.write_frames(&self.fit_2d_to_bps(frames)) {
1834 Ok(_) => Ok(self.frames_written += frames.len() as u64),
1835 Err(e) => Err(AudioWriteError::from(e)),
1836 }
1837 }
1838 }
1839
1840 impl<'a> EncoderToImpl for FlacEncoderWrap<'_> {
1841 fn get_bitrate(&self) -> u32 {
1842 if self.frames_written != 0 {
1843 (*self.bytes_written * self.get_sample_rate() as u64 * 8 / self.frames_written) as u32
1844 } else {
1845 self.get_sample_rate() as u32 * self.get_channels() as u32 * 8 }
1847 }
1848
1849 fn begin_encoding(&mut self) -> Result<(), AudioWriteError> {
1850 self.encoder.initialize()?;
1851 Ok(())
1852 }
1853
1854 fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError> {
1855 Ok(FmtChunk{
1856 format_tag: 0xF1AC,
1857 channels: self.get_channels(),
1858 sample_rate: self.get_sample_rate(),
1859 byte_rate: self.get_bitrate() / 8,
1860 block_align: 1,
1861 bits_per_sample: 0,
1862 extension: None,
1863 })
1864 }
1865
1866 fn update_fmt_chunk(&self, fmt: &mut FmtChunk) -> Result<(), AudioWriteError> {
1867 fmt.byte_rate = self.get_bitrate() / 8;
1868 Ok(())
1869 }
1870
1871 fn finish(&mut self) -> Result<(), AudioWriteError> {
1872 Ok(self.encoder.finish()?)
1873 }
1874
1875 fn write_samples__i8(&mut self, samples: &[i8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
1876 fn write_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
1877 fn write_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
1878 fn write_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
1879 fn write_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
1880 fn write_samples__u8(&mut self, samples: &[u8 ]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
1881 fn write_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
1882 fn write_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
1883 fn write_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
1884 fn write_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
1885 fn write_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
1886 fn write_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError> {self.write_interleaved_samples(&sample_conv(samples))}
1887
1888 fn write_mono_channel__i8(&mut self, monos: &[i8 ]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
1889 fn write_mono_channel_i16(&mut self, monos: &[i16]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
1890 fn write_mono_channel_i24(&mut self, monos: &[i24]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
1891 fn write_mono_channel_i32(&mut self, monos: &[i32]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
1892 fn write_mono_channel_i64(&mut self, monos: &[i64]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
1893 fn write_mono_channel__u8(&mut self, monos: &[u8 ]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
1894 fn write_mono_channel_u16(&mut self, monos: &[u16]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
1895 fn write_mono_channel_u24(&mut self, monos: &[u24]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
1896 fn write_mono_channel_u32(&mut self, monos: &[u32]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
1897 fn write_mono_channel_u64(&mut self, monos: &[u64]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
1898 fn write_mono_channel_f32(&mut self, monos: &[f32]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
1899 fn write_mono_channel_f64(&mut self, monos: &[f64]) -> Result<(), AudioWriteError> {self.write_mono_channel(&sample_conv(monos))}
1900
1901 fn write_stereos__i8(&mut self, stereos: &[(i8 , i8 )]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
1902 fn write_stereos_i16(&mut self, stereos: &[(i16, i16)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
1903 fn write_stereos_i24(&mut self, stereos: &[(i24, i24)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
1904 fn write_stereos_i32(&mut self, stereos: &[(i32, i32)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
1905 fn write_stereos_i64(&mut self, stereos: &[(i64, i64)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
1906 fn write_stereos__u8(&mut self, stereos: &[(u8 , u8 )]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
1907 fn write_stereos_u16(&mut self, stereos: &[(u16, u16)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
1908 fn write_stereos_u24(&mut self, stereos: &[(u24, u24)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
1909 fn write_stereos_u32(&mut self, stereos: &[(u32, u32)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
1910 fn write_stereos_u64(&mut self, stereos: &[(u64, u64)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
1911 fn write_stereos_f32(&mut self, stereos: &[(f32, f32)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
1912 fn write_stereos_f64(&mut self, stereos: &[(f64, f64)]) -> Result<(), AudioWriteError> {self.write_stereos(&stereos_conv(stereos))}
1913
1914 fn write_monos__i8(&mut self, monos_array: &[Vec<i8 >]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
1915 fn write_monos_i16(&mut self, monos_array: &[Vec<i16>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
1916 fn write_monos_i24(&mut self, monos_array: &[Vec<i24>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
1917 fn write_monos_i32(&mut self, monos_array: &[Vec<i32>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
1918 fn write_monos_i64(&mut self, monos_array: &[Vec<i64>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
1919 fn write_monos__u8(&mut self, monos_array: &[Vec<u8 >]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
1920 fn write_monos_u16(&mut self, monos_array: &[Vec<u16>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
1921 fn write_monos_u24(&mut self, monos_array: &[Vec<u24>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
1922 fn write_monos_u32(&mut self, monos_array: &[Vec<u32>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
1923 fn write_monos_u64(&mut self, monos_array: &[Vec<u64>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
1924 fn write_monos_f32(&mut self, monos_array: &[Vec<f32>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
1925 fn write_monos_f64(&mut self, monos_array: &[Vec<f64>]) -> Result<(), AudioWriteError> {self.write_monos(&sample_conv_batch(monos_array))}
1926
1927 fn write_frames__i8(&mut self, frames: &[Vec<i8 >], channels: u16) -> Result<(), AudioWriteError> {self.check_channels(channels)?; self.write_frames(&sample_conv_batch(frames))}
1928 fn write_frames_i16(&mut self, frames: &[Vec<i16>], channels: u16) -> Result<(), AudioWriteError> {self.check_channels(channels)?; self.write_frames(&sample_conv_batch(frames))}
1929 fn write_frames_i24(&mut self, frames: &[Vec<i24>], channels: u16) -> Result<(), AudioWriteError> {self.check_channels(channels)?; self.write_frames(&sample_conv_batch(frames))}
1930 fn write_frames_i32(&mut self, frames: &[Vec<i32>], channels: u16) -> Result<(), AudioWriteError> {self.check_channels(channels)?; self.write_frames(&sample_conv_batch(frames))}
1931 fn write_frames_i64(&mut self, frames: &[Vec<i64>], channels: u16) -> Result<(), AudioWriteError> {self.check_channels(channels)?; self.write_frames(&sample_conv_batch(frames))}
1932 fn write_frames__u8(&mut self, frames: &[Vec<u8 >], channels: u16) -> Result<(), AudioWriteError> {self.check_channels(channels)?; self.write_frames(&sample_conv_batch(frames))}
1933 fn write_frames_u16(&mut self, frames: &[Vec<u16>], channels: u16) -> Result<(), AudioWriteError> {self.check_channels(channels)?; self.write_frames(&sample_conv_batch(frames))}
1934 fn write_frames_u24(&mut self, frames: &[Vec<u24>], channels: u16) -> Result<(), AudioWriteError> {self.check_channels(channels)?; self.write_frames(&sample_conv_batch(frames))}
1935 fn write_frames_u32(&mut self, frames: &[Vec<u32>], channels: u16) -> Result<(), AudioWriteError> {self.check_channels(channels)?; self.write_frames(&sample_conv_batch(frames))}
1936 fn write_frames_u64(&mut self, frames: &[Vec<u64>], channels: u16) -> Result<(), AudioWriteError> {self.check_channels(channels)?; self.write_frames(&sample_conv_batch(frames))}
1937 fn write_frames_f32(&mut self, frames: &[Vec<f32>], channels: u16) -> Result<(), AudioWriteError> {self.check_channels(channels)?; self.write_frames(&sample_conv_batch(frames))}
1938 fn write_frames_f64(&mut self, frames: &[Vec<f64>], channels: u16) -> Result<(), AudioWriteError> {self.check_channels(channels)?; self.write_frames(&sample_conv_batch(frames))}
1939 }
1940}
1941