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