rustwav_lib/
decoders.rs

1#![allow(dead_code)]
2#![allow(non_snake_case)]
3
4use std::{fmt::Debug, cmp::min, io::SeekFrom};
5
6use crate::Reader;
7use crate::{SampleType, i24, u24};
8use crate::{AudioError, AudioReadError};
9use crate::adpcm;
10use crate::wavcore::{Spec, WaveSampleType, FmtChunk};
11use crate::xlaw::{XLaw, PcmXLawDecoder};
12
13#[cfg(feature = "mp3dec")]
14use mp3::Mp3Decoder;
15
16#[cfg(feature = "opus")]
17use opus::OpusDecoder;
18
19#[cfg(feature = "flac")]
20use flac::FlacDecoderWrap;
21
22// Decodes audio into samples of the caller-provided format `S`.
23pub trait Decoder<S>: Debug
24    where S: SampleType {
25
26    // These interfaces must be implemented
27    fn get_channels(&self) -> u16;
28    fn decode_frame(&mut self) -> Result<Option<Vec<S>>, AudioReadError>;
29    fn seek(&mut self, seek_from: SeekFrom) -> Result<(), AudioReadError>;
30    fn get_cur_frame_index(&mut self) -> Result<u64, AudioReadError>;
31
32    // Optional interface
33    fn decode_mono(&mut self) -> Result<Option<S>, AudioReadError> {
34        match self.get_channels() {
35            1 => Ok(self.decode_frame()?.map(|samples| samples[0])),
36            2 => Ok(self.decode_frame()?.map(|samples| S::average(samples[0], samples[1]))),
37            o => Err(AudioReadError::Unsupported(format!("Unsupported to merge {o} channels to 1 channels."))),
38        }
39    }
40
41    // Optional interface
42    fn decode_stereo(&mut self) -> Result<Option<(S, S)>, AudioReadError> {
43        match self.get_channels() {
44            1 => Ok(self.decode_frame()?.map(|samples| (samples[0], samples[0]))),
45            2 => Ok(self.decode_frame()?.map(|samples| (samples[0], samples[1]))),
46            o => Err(AudioReadError::Unsupported(format!("Unsupported to merge {o} channels to 2 channels."))),
47        }
48    }
49
50    // Optional interface
51    fn decode_frames(&mut self, num_frames: usize) -> Result<Vec<Vec<S>>, AudioReadError> {
52        let mut frames = Vec::<Option<Vec<S>>>::with_capacity(num_frames);
53        for _ in 0..num_frames {
54            frames.push(self.decode_frame()?);
55        }
56        Ok(frames.into_iter().flatten().collect())
57    }
58
59    // Optional interface
60    fn decode_monos(&mut self, num_monos: usize) -> Result<Vec<S>, AudioReadError> {
61        let mut monos = Vec::<Option<S>>::with_capacity(num_monos);
62        for _ in 0..num_monos {
63            monos.push(self.decode_mono()?);
64        }
65        Ok(monos.into_iter().flatten().collect())
66    }
67
68    // Optional interface
69    fn decode_stereos(&mut self, num_stereos: usize) -> Result<Vec<(S, S)>, AudioReadError> {
70        let mut stereos = Vec::<Option<(S, S)>>::with_capacity(num_stereos);
71        for _ in 0..num_stereos {
72            stereos.push(self.decode_stereo()?);
73        }
74        Ok(stereos.into_iter().flatten().collect())
75    }
76}
77
78impl<S> Decoder<S> for PcmDecoder<S>
79    where S: SampleType {
80    fn get_channels(&self) -> u16 { self.spec.channels }
81    fn get_cur_frame_index(&mut self) -> Result<u64, AudioReadError> { PcmDecoder::<S>::get_cur_frame_index(self) }
82    fn seek(&mut self, seek_from: SeekFrom) -> Result<(), AudioReadError> { self.seek(seek_from) }
83    fn decode_frame(&mut self) -> Result<Option<Vec<S>>, AudioReadError> { self.decode_frame() }
84    fn decode_stereo(&mut self) -> Result<Option<(S, S)>, AudioReadError> { self.decode_stereo() }
85    fn decode_mono(&mut self) -> Result<Option<S>, AudioReadError> { self.decode_mono() }
86}
87
88impl<S, D> Decoder<S> for AdpcmDecoderWrap<D>
89    where S: SampleType,
90          D: adpcm::AdpcmDecoder {
91    fn get_channels(&self) -> u16 { self.channels }
92    fn get_cur_frame_index(&mut self) -> Result<u64, AudioReadError> { Ok(AdpcmDecoderWrap::<D>::get_cur_frame_index(self)) }
93    fn seek(&mut self, seek_from: SeekFrom) -> Result<(), AudioReadError> { self.seek(seek_from) }
94    fn decode_frame(&mut self) -> Result<Option<Vec<S>>, AudioReadError> { self.decode_frame::<S>() }
95    fn decode_stereo(&mut self) -> Result<Option<(S, S)>, AudioReadError> { self.decode_stereo::<S>() }
96    fn decode_mono(&mut self) -> Result<Option<S>, AudioReadError> { self.decode_mono::<S>() }
97}
98
99impl<S> Decoder<S> for PcmXLawDecoderWrap
100    where S: SampleType {
101    fn get_channels(&self) -> u16 { self.channels }
102    fn get_cur_frame_index(&mut self) -> Result<u64, AudioReadError> { Ok(PcmXLawDecoderWrap::get_cur_frame_index(self)) }
103    fn seek(&mut self, seek_from: SeekFrom) -> Result<(), AudioReadError> { self.seek(seek_from) }
104    fn decode_frame(&mut self) -> Result<Option<Vec<S>>, AudioReadError> { self.decode_frame::<S>() }
105    fn decode_stereo(&mut self) -> Result<Option<(S, S)>, AudioReadError> { self.decode_stereo::<S>() }
106    fn decode_mono(&mut self) -> Result<Option<S>, AudioReadError> { self.decode_mono::<S>() }
107}
108
109#[cfg(feature = "mp3dec")]
110impl<S> Decoder<S> for Mp3Decoder
111    where S: SampleType {
112    fn get_channels(&self) -> u16 { Mp3Decoder::get_channels(self) }
113    fn get_cur_frame_index(&mut self) -> Result<u64, AudioReadError> { Ok(Mp3Decoder::get_cur_frame_index(self)) }
114    fn seek(&mut self, seek_from: SeekFrom) -> Result<(), AudioReadError> { Mp3Decoder::seek(self, seek_from) }
115    fn decode_frame(&mut self) -> Result<Option<Vec<S>>, AudioReadError> { self.decode_frame::<S>() }
116    fn decode_stereo(&mut self) -> Result<Option<(S, S)>, AudioReadError> { self.decode_stereo::<S>() }
117    fn decode_mono(&mut self) -> Result<Option<S>, AudioReadError> { self.decode_mono::<S>() }
118}
119
120#[cfg(feature = "opus")]
121impl<S> Decoder<S> for OpusDecoder
122    where S: SampleType {
123    fn get_channels(&self) -> u16 { OpusDecoder::get_channels(self) }
124    fn get_cur_frame_index(&mut self) -> Result<u64, AudioReadError> { Ok(OpusDecoder::get_cur_frame_index(self)) }
125    fn seek(&mut self, seek_from: SeekFrom) -> Result<(), AudioReadError> { self.seek(seek_from) }
126    fn decode_frame(&mut self) -> Result<Option<Vec<S>>, AudioReadError> { self.decode_frame::<S>() }
127    fn decode_stereo(&mut self) -> Result<Option<(S, S)>, AudioReadError> { self.decode_stereo::<S>() }
128    fn decode_mono(&mut self) -> Result<Option<S>, AudioReadError> { self.decode_mono::<S>() }
129}
130
131#[cfg(feature = "flac")]
132impl<'a, S> Decoder<S> for FlacDecoderWrap<'a>
133    where S: SampleType {
134    fn get_channels(&self) -> u16 { FlacDecoderWrap::get_channels(self) }
135    fn get_cur_frame_index(&mut self) -> Result<u64, AudioReadError> { Ok(FlacDecoderWrap::get_cur_frame_index(self)) }
136    fn seek(&mut self, seek_from: SeekFrom) -> Result<(), AudioReadError> { self.seek(seek_from) }
137    fn decode_frame(&mut self) -> Result<Option<Vec<S>>, AudioReadError> { self.decode_frame::<S>() }
138    fn decode_stereo(&mut self) -> Result<Option<(S, S)>, AudioReadError> { self.decode_stereo::<S>() }
139    fn decode_mono(&mut self) -> Result<Option<S>, AudioReadError> { self.decode_mono::<S>() }
140}
141
142fn get_rounded_up_fft_size(sample_rate: u32) -> usize {
143    let mut ret = 1usize;
144    while ret < (sample_rate as usize) {ret <<= 1;}
145    ret
146}
147
148#[derive(Debug)]
149pub struct PcmDecoder<S>
150where S: SampleType {
151    reader: Box<dyn Reader>,
152    data_offset: u64,
153    data_length: u64,
154    block_align: u16,
155    total_frames: u64,
156    spec: Spec,
157    sample_decoder: fn(&mut dyn Reader) -> Result<S, AudioReadError>,
158}
159
160impl<S> PcmDecoder<S>
161where S: SampleType {
162    pub fn new(reader: Box<dyn Reader>, data_offset: u64, data_length: u64, spec: &Spec, fmt: &FmtChunk) -> Result<Self, AudioError> {
163        match fmt.format_tag {
164            1 | 0xFFFE | 3 => (),
165            o => return Err(AudioError::InvalidArguments(format!("`PcmDecoder` can't handle format_tag 0x{:x}", o))),
166        }
167        let wave_sample_type = spec.get_sample_type();
168        Ok(Self {
169            reader,
170            data_offset,
171            data_length,
172            block_align: fmt.block_align,
173            total_frames: data_length / fmt.block_align as u64,
174            spec: *spec,
175            sample_decoder: Self::choose_sample_decoder(wave_sample_type)?,
176        })
177    }
178
179    fn is_end_of_data(&mut self) -> Result<bool, AudioReadError> {
180        Ok(self.reader.stream_position()? >= self.data_offset + self.data_length)
181    }
182
183    pub fn get_cur_frame_index(&mut self) -> Result<u64, AudioReadError> {
184        Ok((self.reader.stream_position()? - self.data_offset) / (self.block_align as u64))
185    } 
186
187    pub fn seek(&mut self, seek_from: SeekFrom) -> Result<(), AudioReadError> {
188        let frame_index = match seek_from{
189            SeekFrom::Start(fi) => fi,
190            SeekFrom::Current(cur) => {
191                (self.get_cur_frame_index()? as i64 + cur) as u64
192            },
193            SeekFrom::End(end) => {
194                (self.total_frames as i64 + end) as u64
195            }
196        };
197        if frame_index > self.total_frames {
198            self.reader.seek(SeekFrom::Start(self.data_offset + self.data_length))?;
199            Ok(())
200        } else {
201            self.reader.seek(SeekFrom::Start(self.data_offset + frame_index * self.block_align as u64))?;
202            Ok(())
203        }
204    }
205
206    fn decode_sample<T>(&mut self) -> Result<Option<S>, AudioReadError>
207    where T: SampleType {
208        if self.is_end_of_data()? {
209            Ok(None)
210        } else {
211            Ok(Some(S::from(T::read_le(&mut self.reader)?)))
212        }
213    }
214
215    fn decode_sample_to<T>(r: &mut dyn Reader) -> Result<S, AudioReadError>
216    where T: SampleType {
217        Ok(S::from(T::read_le(r)?))
218    }
219
220    fn decode_samples_to<T>(r: &mut dyn Reader, num_samples_to_read: usize) -> Result<Vec<S>, AudioReadError>
221    where T: SampleType {
222        let mut ret = Vec::<S>::with_capacity(num_samples_to_read);
223        for _ in 0..num_samples_to_read {
224            ret.push(Self::decode_sample_to::<T>(r)?);
225        }
226        Ok(ret)
227    }
228
229    // The decoder returned by this function has two exclusive responsibilities:
230    // 1. Read raw bytes from the input stream.
231    // 2. Convert them into samples of the target format `S`.
232    // It does NOT handle end-of-stream detection — the caller must implement 
233    // termination logic (e.g., check input.is_empty() or external duration tracking).
234    #[allow(clippy::type_complexity)]
235    fn choose_sample_decoder(wave_sample_type: WaveSampleType) -> Result<fn(&mut dyn Reader) -> Result<S, AudioReadError>, AudioError> {
236        use WaveSampleType::{Unknown, S8, S16, S24, S32, S64, U8, U16, U24, U32, U64, F32, F64};
237        match wave_sample_type {
238            S8 =>  Ok(Self::decode_sample_to::<i8 >),
239            S16 => Ok(Self::decode_sample_to::<i16>),
240            S24 => Ok(Self::decode_sample_to::<i24>),
241            S32 => Ok(Self::decode_sample_to::<i32>),
242            S64 => Ok(Self::decode_sample_to::<i64>),
243            U8 =>  Ok(Self::decode_sample_to::<u8 >),
244            U16 => Ok(Self::decode_sample_to::<u16>),
245            U24 => Ok(Self::decode_sample_to::<u24>),
246            U32 => Ok(Self::decode_sample_to::<u32>),
247            U64 => Ok(Self::decode_sample_to::<u64>),
248            F32 => Ok(Self::decode_sample_to::<f32>),
249            F64 => Ok(Self::decode_sample_to::<f64>),
250            Unknown => Err(AudioError::InvalidArguments(format!("unknown sample type \"{:?}\"", wave_sample_type))),
251        }
252    }
253
254    pub fn decode_frame(&mut self) -> Result<Option<Vec<S>>, AudioReadError> {
255        if self.is_end_of_data()? {
256            Ok(None)
257        } else {
258            let mut frame = Vec::<S>::with_capacity(self.spec.channels as usize);
259            for _ in 0..self.spec.channels {
260                frame.push((self.sample_decoder)(&mut self.reader)?);
261            }
262            Ok(Some(frame))
263        }
264    }
265
266    pub fn decode_stereo(&mut self) -> Result<Option<(S, S)>, AudioReadError> {
267        if self.is_end_of_data()? {
268            Ok(None)
269        } else {
270            match self.spec.channels {
271                1 => {
272                    let sample = (self.sample_decoder)(&mut self.reader)?;
273                    Ok(Some((sample, sample)))
274                },
275                2 => {
276                    let sample_l = (self.sample_decoder)(&mut self.reader)?;
277                    let sample_r = (self.sample_decoder)(&mut self.reader)?;
278                    Ok(Some((sample_l, sample_r)))
279                },
280                o => Err(AudioReadError::Unsupported(format!("Unsupported to merge {o} channels to 2 channels."))),
281            }
282        }
283    }
284
285    pub fn decode_mono(&mut self) -> Result<Option<S>, AudioReadError> {
286        if self.is_end_of_data()? {
287            Ok(None)
288        } else {
289            match self.get_channels() {
290                1 => {
291                    Ok(Some((self.sample_decoder)(&mut self.reader)?))
292                },
293                2 => {
294                    let sample_l = (self.sample_decoder)(&mut self.reader)?;
295                    let sample_r = (self.sample_decoder)(&mut self.reader)?;
296                    Ok(Some(sample_l / S::from(2) + sample_r / S::from(2)))
297                },
298                o => Err(AudioReadError::Unsupported(format!("Unsupported to merge {o} channels to 1 channels."))),
299            }
300        }
301    }
302}
303
304#[derive(Debug)]
305pub struct AdpcmDecoderWrap<D>
306where D: adpcm::AdpcmDecoder {
307    channels: u16,
308    reader: Box<dyn Reader>,
309    data_offset: u64,
310    data_length: u64,
311    block_align: u16,
312    frame_index: u64,
313    frames_decoded: u64,
314    total_frames: u64,
315    decoder: D,
316    samples: Vec<i16>,
317    first_frame_of_samples: u64,
318}
319
320impl<D> AdpcmDecoderWrap<D>
321where D: adpcm::AdpcmDecoder {
322    pub fn new(reader: Box<dyn Reader>, data_offset: u64, data_length: u64, fmt: &FmtChunk, total_samples: u64) -> Result<Self, AudioReadError> {
323        let decoder =  D::new(fmt)?;
324        let total_frames = if total_samples == 0 {
325            let frames_per_block = decoder.frames_per_block() as u64;
326            let total_blocks = data_length / fmt.block_align as u64;
327            total_blocks * frames_per_block
328        } else {
329            total_samples / fmt.channels as u64
330        };
331        Ok(Self {
332            channels: fmt.channels,
333            reader,
334            data_offset,
335            data_length,
336            block_align: fmt.block_align,
337            frame_index: 0,
338            frames_decoded: 0,
339            total_frames,
340            decoder,
341            samples: Vec::<i16>::new(),
342            first_frame_of_samples: 0,
343        })
344    }
345
346    fn is_end_of_data(&mut self) -> Result<bool, AudioReadError> {
347        let end_of_data = self.data_offset + self.data_length;
348        if self.reader.stream_position()? >= end_of_data { Ok(true) } else { Ok(false) }
349    }
350
351    pub fn get_cur_frame_index(&self) -> u64 {
352        self.frame_index
353    }
354
355    pub fn feed_until_output(&mut self, wanted_length: usize) -> Result<(), AudioReadError>{
356        let end_of_data = self.data_offset + self.data_length;
357        let mut sample_decoded = 0u64;
358        while self.samples.len() < wanted_length {
359            let cur_pos = self.reader.stream_position()?;
360            if cur_pos < end_of_data {
361                let remains = end_of_data - cur_pos;
362                let to_read = min(remains, self.block_align as u64);
363                let mut buf = vec![0u8; to_read as usize];
364                self.reader.read_exact(&mut buf)?;
365                let mut iter = buf.into_iter();
366                self.decoder.decode(|| -> Option<u8> {iter.next()},|sample: i16| {sample_decoded += 1; self.samples.push(sample)})?;
367            } else {
368                self.decoder.flush(|sample: i16| {sample_decoded += 1; self.samples.push(sample)})?;
369                break;
370            }
371        }
372        self.frames_decoded += sample_decoded / self.channels as u64;
373        Ok(())
374    }
375
376    pub fn seek(&mut self, seek_from: SeekFrom) -> Result<(), AudioReadError> {
377        let frames_per_block = self.decoder.frames_per_block() as u64;
378        let frame_index = match seek_from{
379            SeekFrom::Start(fi) => fi,
380            SeekFrom::Current(cur) => {
381                (self.frame_index as i64 + cur) as u64
382            },
383            SeekFrom::End(end) => {
384                (self.total_frames as i64 + end) as u64
385            }
386        };
387        let block_index = frame_index / frames_per_block;
388        self.samples.clear();
389        self.decoder.reset_states();
390        if frame_index >= self.total_frames {
391            let end_of_data = self.data_offset + self.data_length;
392            self.reader.seek(SeekFrom::Start(end_of_data))?;
393            self.first_frame_of_samples = self.total_frames;
394            self.frames_decoded = self.total_frames;
395            self.frame_index = frame_index;
396            Ok(())
397        } else {
398            let block_pos = self.data_offset + block_index * self.block_align as u64;
399            self.reader.seek(SeekFrom::Start(block_pos))?;
400            self.first_frame_of_samples = block_index * frames_per_block;
401            self.frames_decoded = self.first_frame_of_samples;
402            self.frame_index = frame_index;
403            Ok(())
404        }
405    }
406
407    pub fn decode_mono<S>(&mut self) -> Result<Option<S>, AudioReadError>
408    where S: SampleType {
409        match self.channels {
410            1 => {
411                // Force-decodes at least 1 sample to ensure data availability
412                if self.samples.is_empty() {
413                    self.feed_until_output(1)?;
414                }
415
416                // Empty after feeding indicates end-of-stream
417                if self.samples.is_empty() {
418                    Ok(None)
419                } else {
420                    // Internal status check
421                    if self.frame_index < self.first_frame_of_samples {
422                        panic!("Unknown error occured when decoding the ADPCM data: the sample cache was updated while the previous cache is needed: FI = {}, FF = {}", self.frame_index, self.first_frame_of_samples);
423                    } else if self.frame_index < self.frames_decoded {
424                        let ret = self.samples[(self.frame_index - self.first_frame_of_samples) as usize];
425                        self.frame_index += 1;
426                        Ok(Some(S::from(ret)))
427                    } else {
428                        // Need to decode the next block
429                        self.first_frame_of_samples += self.samples.len() as u64;
430                        self.samples.clear();
431                        self.decode_mono::<S>()
432                    }
433                }
434            },
435            2 => {
436                let ret = self.decode_stereo::<S>()?;
437                match ret {
438                    None => Ok(None),
439                    Some((l, r)) => {
440                        Ok(Some(S::average(l, r)))
441                    }
442                }
443            },
444            o => Err(AudioReadError::Unsupported(format!("Unsupported channels {o}"))),
445        }
446    }
447
448    pub fn decode_stereo<S>(&mut self) -> Result<Option<(S, S)>, AudioReadError>
449    where S: SampleType {
450        match self.channels {
451            1 => {
452                let ret = self.decode_mono::<S>()?;
453                match ret {
454                    None => Ok(None),
455                    Some(ret) => Ok(Some((ret, ret)))
456                }
457            },
458            2 => {
459                // Force-decodes at least 1 sample to ensure data availability
460                if self.samples.is_empty() {
461                    self.feed_until_output(2)?;
462                }
463
464                // Empty after feeding indicates end-of-stream
465                if self.samples.is_empty() {
466                    Ok(None)
467                } else {
468                    // Internal status check
469                    if self.frame_index < self.first_frame_of_samples {
470                        panic!("Unknown error occured when decoding the ADPCM data: the sample cache was updated while the previous cache is needed: FI = {}, FF = {}", self.frame_index, self.first_frame_of_samples);
471                    } else if self.frame_index < self.frames_decoded {
472                        let index = ((self.frame_index - self.first_frame_of_samples) * 2) as usize;
473                        self.frame_index += 1;
474                        let l = self.samples[index];
475                        let r = self.samples[index + 1];
476                        Ok(Some((S::from(l), S::from(r))))
477                    } else {
478                        // Need to decode the next block
479                        self.first_frame_of_samples += (self.samples.len() / 2) as u64;
480                        self.samples.clear();
481                        self.decode_stereo::<S>()
482                    }
483                }
484            },
485            o => Err(AudioReadError::Unsupported(format!("Unsupported channels {o}"))),
486        }
487    }
488
489    pub fn decode_frame<S>(&mut self) -> Result<Option<Vec<S>>, AudioReadError>
490    where S: SampleType {
491        match self.channels {
492            1 => {
493                match self.decode_mono::<S>()? {
494                    Some(sample) => Ok(Some(vec![sample])),
495                    None => Ok(None),
496                }
497            },
498            2 => {
499                match self.decode_stereo::<S>()? {
500                    Some((l, r)) => Ok(Some(vec![l, r])),
501                    None => Ok(None),
502                }
503            },
504            o => Err(AudioReadError::Unsupported(format!("Unsupported channels {o}"))),
505        }
506    }
507}
508
509#[derive(Debug)]
510pub struct PcmXLawDecoderWrap {
511    reader: Box<dyn Reader>,
512    channels: u16,
513    data_offset: u64,
514    data_length: u64,
515    total_frames: u64,
516    frame_index: u64,
517    dec: PcmXLawDecoder,
518}
519
520impl PcmXLawDecoderWrap {
521    pub fn new(reader: Box<dyn Reader>, which_law: XLaw, data_offset: u64, data_length: u64, fmt: &FmtChunk, total_samples: u64) -> Result<Self, AudioReadError> {
522        match fmt.channels {
523            1 => (),
524            2 => (),
525            o => return Err(AudioReadError::Unsupported(format!("Unsupported channels {o}"))),
526        }
527        Ok(Self {
528            reader,
529            channels: fmt.channels,
530            data_offset,
531            data_length,
532            total_frames: total_samples / fmt.channels as u64,
533            frame_index: 0,
534            dec: PcmXLawDecoder::new(which_law),
535        })
536    }
537
538    fn decode(&mut self) -> Result<i16, AudioReadError> {
539        Ok(self.dec.decode(u8::read_le(&mut self.reader)?))
540    }
541
542    pub fn get_cur_frame_index(&self) -> u64 {
543        self.frame_index
544    }
545
546    pub fn seek(&mut self, from: SeekFrom) -> Result<(), AudioReadError> {
547        let mut frame_index = match from {
548            SeekFrom::Start(fi) => fi,
549            SeekFrom::Current(cur) => (self.frame_index as i64 + cur) as u64,
550            SeekFrom::End(end) => (self.frame_index as i64 + end) as u64,
551        };
552        if frame_index > self.total_frames {
553            frame_index = self.total_frames;
554        }
555        self.frame_index = frame_index;
556        self.reader.seek(SeekFrom::Start(self.data_offset + self.frame_index * self.channels as u64))?;
557        Ok(())
558    }
559
560    fn is_end_of_data(&mut self) -> Result<bool, AudioReadError> {
561        let end_of_data = self.data_offset + self.data_length;
562        if self.reader.stream_position()? >= end_of_data { Ok(true) } else { Ok(false) }
563    }
564
565    pub fn decode_mono<S>(&mut self) -> Result<Option<S>, AudioReadError>
566    where S: SampleType {
567        if self.is_end_of_data()? {
568            Ok(None)
569        } else {
570            match self.channels {
571                1 => {
572                    let s = S::from(self.decode()?);
573                    self.frame_index += 1;
574                    Ok(Some(s))
575                },
576                2 => {
577                    let l = S::from(self.decode()?);
578                    let r = S::from(self.decode()?);
579                    self.frame_index += 1;
580                    Ok(Some(S::average(l, r)))
581                },
582                o => Err(AudioReadError::Unsupported(format!("Unsupported channels {o}"))),
583            }
584        }
585    }
586
587    pub fn decode_stereo<S>(&mut self) -> Result<Option<(S, S)>, AudioReadError>
588    where S: SampleType {
589        if self.is_end_of_data()? {
590            Ok(None)
591        } else {
592            match self.channels {
593                1 => {
594                    let s = S::from(self.decode()?);
595                    self.frame_index += 1;
596                    Ok(Some((s, s)))
597                },
598                2 => {
599                    let l = S::from(self.decode()?);
600                    let r = S::from(self.decode()?);
601                    self.frame_index += 1;
602                    Ok(Some((l, r)))
603                },
604                o => Err(AudioReadError::Unsupported(format!("Unsupported channels {o}"))),
605            }
606        }
607    }
608
609    pub fn decode_frame<S>(&mut self) -> Result<Option<Vec<S>>, AudioReadError>
610    where S: SampleType {
611        match self.channels {
612            1 => {
613                match self.decode_mono::<S>()? {
614                    Some(sample) => Ok(Some(vec![sample])),
615                    None => Ok(None),
616                }
617            },
618            2 => {
619                match self.decode_stereo::<S>()? {
620                    Some((l, r)) => Ok(Some(vec![l, r])),
621                    None => Ok(None),
622                }
623            },
624            o => Err(AudioReadError::Unsupported(format!("Unsupported channels {o}"))),
625        }
626    }
627}
628
629#[cfg(feature = "mp3dec")]
630pub mod mp3 {
631    use std::{io::{Read, SeekFrom}, fmt::{self, Debug, Formatter}, mem};
632
633    use super::get_rounded_up_fft_size;
634    use crate::AudioReadError;
635    use crate::Reader;
636    use crate::SampleType;
637    use crate::Resampler;
638    use crate::wavcore::FmtChunk;
639    use crate::utils;
640
641    use rmp3::{DecoderOwned, Frame};
642
643    pub struct Mp3Decoder {
644        target_sample_rate: u32,
645        target_channels: u16,
646        the_decoder: DecoderOwned<Vec<u8>>,
647        cur_frame: Option<Mp3AudioData>,
648        sample_pos: u64,
649        total_frames: u64,
650        resampler: Resampler,
651    }
652
653    impl Debug for Mp3Decoder{
654        fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
655            fmt.debug_struct("Mp3Decoder")
656                .field("target_sample_rate", &self.target_sample_rate)
657                .field("target_channels", &self.target_channels)
658                .field("the_decoder", &format_args!("DecoderOwned<Vec<u8>>"))
659                .field("cur_frame", &self.cur_frame)
660                .field("sample_pos", &self.sample_pos)
661                .field("total_frames", &self.total_frames)
662                .field("resampler", &self.resampler)
663                .finish()
664        }
665    }
666
667    #[derive(Clone)]
668    pub struct Mp3AudioData {
669        pub bitrate: u32,
670        pub channels: u16,
671        pub mpeg_layer: u8,
672        pub sample_rate: u32,
673        pub sample_count: usize,
674        pub samples: Vec<i16>,
675        pub buffer_index: usize,
676    }
677
678    impl Debug for Mp3AudioData{
679        fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
680            fmt.debug_struct("Mp3AudioData")
681                .field("bitrate", &self.bitrate)
682                .field("channels", &self.channels)
683                .field("mpeg_layer", &self.mpeg_layer)
684                .field("sample_rate", &self.sample_rate)
685                .field("sample_count", &self.sample_count)
686                .field("samples", &format_args!("[i16; {}]", self.samples.len()))
687                .field("buffer_index", &self.buffer_index)
688                .finish()
689        }
690    }
691
692    impl Mp3Decoder {
693        pub fn new(reader: Box<dyn Reader>, data_offset: u64, data_length: u64, fmt: &FmtChunk, total_samples: u64) -> Result<Self, AudioReadError> {
694            let mut reader = reader;
695            let mut mp3_raw_data = vec![0u8; data_length as usize];
696            reader.seek(SeekFrom::Start(data_offset))?;
697            reader.read_exact(&mut mp3_raw_data)?;
698            let the_decoder = rmp3::DecoderOwned::new(mp3_raw_data);
699            let mut ret = Self {
700                target_sample_rate: fmt.sample_rate,
701                target_channels: fmt.channels,
702                the_decoder,
703                cur_frame: None,
704                sample_pos: 0,
705                total_frames: total_samples,
706                resampler: Resampler::new(get_rounded_up_fft_size(fmt.sample_rate)),
707            };
708            ret.cur_frame = ret.get_next_frame();
709            if let Some(ref mp3frame) = ret.cur_frame {
710                ret.total_frames /= mp3frame.channels as u64;
711            }
712            Ok(ret)
713        }
714
715        fn reset(&mut self) {
716            self.the_decoder.set_position(0);
717            self.cur_frame = self.get_next_frame();
718            self.sample_pos = 0;
719        }
720
721        fn do_resample(&self, samples: &[i16], channels: u16, src_sample_rate: u32) -> Vec<i16> {
722            let process_size = self.resampler.get_process_size(self.resampler.get_fft_size(), src_sample_rate, self.target_sample_rate);
723            let mut monos = utils::interleaved_samples_to_monos(samples, channels).unwrap();
724            for mono in monos.iter_mut() {
725                let mut iter = mem::take(mono).into_iter();
726                loop {
727                    let block: Vec<i16> = iter.by_ref().take(process_size).collect();
728                    if block.is_empty() {
729                        break;
730                    }
731                    mono.extend(&utils::do_resample_mono(&self.resampler, &block, src_sample_rate, self.target_sample_rate));
732                }
733            }
734            utils::monos_to_interleaved_samples(&monos).unwrap()
735        }
736
737        fn get_next_frame(&mut self) -> Option<Mp3AudioData> {
738            while let Some(frame) = self.the_decoder.next() {
739                if let Frame::Audio(audio) = frame {
740                    if let Some(cur_frame) = &self.cur_frame {
741                        self.sample_pos += cur_frame.sample_count as u64;
742                    }
743
744                    let mut ret = Mp3AudioData{
745                        bitrate: audio.bitrate(),
746                        channels: audio.channels(),
747                        mpeg_layer: audio.mpeg_layer(),
748                        sample_rate: audio.sample_rate(),
749                        sample_count: audio.sample_count(),
750                        samples: audio.samples().to_vec(),
751                        buffer_index: 0,
752                    };
753
754                    // First, convert the source channels to the target channels
755                    match (ret.channels, self.target_channels) {
756                        (1, t) => {
757                            ret.samples = mem::take(&mut ret.samples).into_iter().flat_map(|s| -> Vec<i16> {vec![s; t as usize]}).collect();
758                            ret.channels = self.target_channels;
759                        },
760                        (t, 1) => {
761                            let mut iter = mem::take(&mut ret.samples).into_iter();
762                            loop {
763                                let frame: Vec<i32> = iter.by_ref().take(t as usize).map(|s|{s as i32}).collect();
764                                if frame.is_empty() {
765                                    break;
766                                }
767                                ret.samples.push((frame.iter().sum::<i32>() / frame.len() as i32) as i16);
768                            }
769                            ret.channels = self.target_channels;
770                        },
771                        (s, t) => {
772                            if s != t {
773                                eprintln!("Can't change {s} channels to {t} channels.");
774                            }
775                        },
776                    }
777
778                    // Second, change the sample rate to match the target sample rate
779                    ret.samples = self.do_resample(&ret.samples, ret.channels, ret.sample_rate);
780                    ret.sample_rate = self.target_sample_rate;
781                    ret.sample_count = ret.samples.len() / ret.channels as usize;
782
783                    return Some(ret);
784                }
785            }
786            None
787        }
788
789        pub fn get_cur_frame_index(&self) -> u64 {
790            if let Some(frame) = &self.cur_frame {
791                self.sample_pos + (frame.buffer_index as u64)
792            } else {
793                0u64
794            }
795        }
796
797        pub fn seek(&mut self, seek_from: SeekFrom) -> Result<(), AudioReadError> {
798            let frame_index = match seek_from{
799                SeekFrom::Start(fi) => fi,
800                SeekFrom::Current(cur) => {
801                    (self.get_cur_frame_index() as i64 + cur) as u64
802                },
803                SeekFrom::End(end) => {
804                    (self.total_frames as i64 + end) as u64
805                }
806            };
807            if self.sample_pos > frame_index {
808                self.reset();
809            }
810            loop {
811                if let Some(cur_frame) = &self.cur_frame {
812                    if self.sample_pos + (cur_frame.sample_count as u64) > frame_index {
813                        break;
814                    } else {
815                        self.cur_frame = self.get_next_frame();
816                    }
817                } else {
818                    return Ok(())
819                }
820            }
821            for _ in 0..(frame_index - self.sample_pos) {
822                let _ = self.decode_stereo_raw()?;
823            }
824            Ok(())
825        }
826
827        pub fn get_channels(&self) -> u16 {
828            self.target_channels
829        }
830
831        pub fn get_sample_rate(&self) -> u32 {
832            self.target_sample_rate
833        }
834
835        pub fn get_cur_frame(&self) -> &Option<Mp3AudioData> {
836            &self.cur_frame
837        }
838
839        pub fn decode_mono_raw(&mut self) -> Result<Option<i16>, AudioReadError> {
840            match self.cur_frame {
841                None => Ok(None),
842                Some(ref mut frame) => {
843                    match frame.channels {
844                        1 => {
845                            let sample = frame.samples[frame.buffer_index];
846                            frame.buffer_index += 1;
847                            if frame.buffer_index >= frame.sample_count {
848                                self.cur_frame = self.get_next_frame();
849                            }
850                            Ok(Some(sample))
851                        },
852                        2 => {
853                            let l = frame.samples[frame.buffer_index * 2];
854                            let r = frame.samples[frame.buffer_index * 2 + 1];
855                            frame.buffer_index += 1;
856                            if frame.buffer_index >= frame.sample_count {
857                                self.cur_frame = self.get_next_frame();
858                            }
859                            Ok(Some(((l as i32 +  r as i32) / 2i32) as i16))
860                        },
861                        o => Err(AudioReadError::DataCorrupted(format!("Unknown channel count {o}."))),
862                    }
863                }
864            }
865        }
866
867        pub fn decode_stereo_raw(&mut self) -> Result<Option<(i16, i16)>, AudioReadError> {
868            match self.cur_frame {
869                None => Ok(None),
870                Some(ref mut frame) => {
871                    match frame.channels {
872                        1 => {
873                            let sample = frame.samples[frame.buffer_index];
874                            frame.buffer_index += 1;
875                            if frame.buffer_index >= frame.sample_count {
876                                self.cur_frame = self.get_next_frame();
877                            }
878                            Ok(Some((sample, sample)))
879                        },
880                        2 => {
881                            let l = frame.samples[frame.buffer_index * 2];
882                            let r = frame.samples[frame.buffer_index * 2 + 1];
883                            frame.buffer_index += 1;
884                            if frame.buffer_index >= frame.sample_count {
885                                self.cur_frame = self.get_next_frame();
886                            }
887                            Ok(Some((l, r)))
888                        },
889                        o => Err(AudioReadError::DataCorrupted(format!("Unknown channel count {o}."))),
890                    }
891                }
892            }
893        }
894
895        pub fn decode_mono<S>(&mut self) -> Result<Option<S>, AudioReadError>
896        where S: SampleType {
897            match self.decode_mono_raw()? {
898                None => Ok(None),
899                Some(s) => {
900                    Ok(Some(S::from(s)))
901                },
902            }
903        }
904
905        pub fn decode_stereo<S>(&mut self) -> Result<Option<(S, S)>, AudioReadError>
906        where S: SampleType {
907            match self.decode_stereo_raw()? {
908                None => Ok(None),
909                Some((l, r)) => Ok(Some((S::from(l), S::from(r)))),
910            }
911        }
912
913        pub fn decode_frame<S>(&mut self) -> Result<Option<Vec<S>>, AudioReadError>
914        where S: SampleType {
915            let stereo = self.decode_stereo::<S>()?;
916            match stereo {
917                None => Ok(None),
918                Some((l, r)) => {
919                    match self.target_channels {
920                        1 => Ok(Some(vec![S::from(l)])),
921                        2 => Ok(Some(vec![S::from(l), S::from(r)])),
922                        o => Err(AudioReadError::DataCorrupted(format!("Unknown channel count {o}."))),
923                    }
924                },
925            }
926        }
927    }
928}
929
930#[cfg(feature = "opus")]
931pub mod opus {
932    use std::{io::SeekFrom, fmt::{self, Debug, Formatter}};
933
934    use crate::Reader;
935    use crate::AudioReadError;
936    use crate::SampleType;
937    use crate::wavcore::FmtChunk;
938
939    use opus::{Decoder, Channels};
940
941    pub struct OpusDecoder {
942        reader: Box<dyn Reader>,
943        decoder: Decoder,
944        channels: u16,
945        sample_rate: u32,
946        data_offset: u64,
947        data_length: u64,
948        total_frames: u64,
949        block_align: usize,
950        decoded_samples: Vec<f32>,
951        decoded_samples_index: usize,
952        frame_index: u64,
953    }
954
955    impl OpusDecoder {
956        pub fn new(mut reader: Box<dyn Reader>, data_offset: u64, data_length: u64, fmt: &FmtChunk, total_samples: u64) -> Result<Self, AudioReadError> {
957            let channels = fmt.channels;
958            let sample_rate = fmt.sample_rate;
959            let opus_channels = match channels {
960                1 => Channels::Mono,
961                2 => Channels::Stereo,
962                o => return Err(AudioReadError::InvalidArguments(format!("Bad channels: {o} for the opus decoder."))),
963            };
964            let decoder = Decoder::new(sample_rate, opus_channels)?;
965            reader.seek(SeekFrom::Start(data_offset))?;
966            Ok(Self{
967                reader,
968                decoder,
969                channels,
970                sample_rate,
971                data_offset,
972                data_length,
973                total_frames: total_samples / channels as u64,
974                block_align: fmt.block_align as usize,
975                decoded_samples: Vec::<f32>::new(),
976                decoded_samples_index: 0,
977                frame_index: 0,
978            })
979        }
980
981        pub fn get_channels(&self) -> u16 {
982            self.channels
983        }
984
985        pub fn get_sample_rate(&self) -> u32 {
986            self.sample_rate
987        }
988
989        pub fn get_cur_frame_index(&self) -> u64 {
990            self.frame_index
991        }
992
993        fn is_end_of_data(&mut self) -> Result<bool, AudioReadError> {
994            if self.reader.stream_position()? >= self.data_offset + self.data_length { Ok(true) } else { Ok(false) }
995        }
996
997        fn get_num_samples_in_ms(&self, ms_val: f32) -> usize {
998            (self.sample_rate as f32 * ms_val / 1000.0) as usize * self.channels as usize
999        }
1000
1001        fn clear_decoded_samples_buffer(&mut self) {
1002            self.decoded_samples.clear();
1003            self.decoded_samples_index = 0;
1004        }
1005
1006        fn get_samples_per_block(&self) -> usize {
1007            self.block_align as usize
1008        }
1009
1010        fn decode_block(&mut self) -> Result<(), AudioReadError> {
1011            if self.is_end_of_data()? {
1012                self.clear_decoded_samples_buffer();
1013                return Ok(());
1014            }
1015
1016            // Prepare the buffers
1017            let mut buf = vec![0u8; self.block_align];
1018            let samples_to_get = self.get_samples_per_block();
1019            self.reader.read_exact(&mut buf)?;
1020            self.decoded_samples = vec![0.0; samples_to_get];
1021
1022            // Reset the sample index
1023            self.decoded_samples_index = 0;
1024
1025            // Perform the decode call
1026            let frames = self.decoder.decode_float(&buf, &mut self.decoded_samples, /*fec*/ false)?;
1027
1028            // Check out the result
1029            let samples = frames * self.channels as usize;
1030            if samples != samples_to_get {
1031                Err(AudioReadError::IncompleteData(format!("Expected {samples_to_get} samples will be decoded, got {samples} samples.")))
1032            } else {
1033                Ok(())
1034            }
1035        }
1036
1037        pub fn seek(&mut self, seek_from: SeekFrom) -> Result<(), AudioReadError> {
1038            let frame_index = match seek_from{
1039                SeekFrom::Start(fi) => fi,
1040                SeekFrom::Current(cur) => {
1041                    (self.frame_index as i64 + cur) as u64
1042                },
1043                SeekFrom::End(end) => {
1044                    (self.total_frames as i64 + end) as u64
1045                }
1046            };
1047            self.frame_index = frame_index;
1048            let block_align = self.block_align as u64;
1049            let block_index = frame_index / block_align;
1050            let seek_to = self.data_offset + block_index * block_align;
1051            if seek_to < self.data_offset + self.data_length {
1052                self.reader.seek(SeekFrom::Start(seek_to))?;
1053                self.decode_block()?;
1054                self.decoded_samples_index = ((frame_index * self.channels as u64) - block_index * self.get_samples_per_block() as u64) as usize;
1055            }
1056            Ok(())
1057        }
1058
1059        fn decode_sample(&mut self) -> Result<Option<f32>, AudioReadError> {
1060            if self.decoded_samples.is_empty() {
1061                Ok(None)
1062            } else if self.decoded_samples_index >= self.decoded_samples.len() {
1063                self.decode_block()?;
1064                self.decode_sample()
1065            } else {
1066                let ret = self.decoded_samples[self.decoded_samples_index];
1067                self.decoded_samples_index += 1;
1068                Ok(Some(ret))
1069            }
1070        }
1071
1072        pub fn decode_mono<S>(&mut self) -> Result<Option<S>, AudioReadError>
1073        where S: SampleType {
1074            match self.channels {
1075                1 => {
1076                    let s = self.decode_sample()?;
1077                    if let Some(s) = s {self.frame_index += 1; Ok(Some(S::from(s)))} else {Ok(None)}
1078                },
1079                2 => {
1080                    let l = self.decode_sample()?;
1081                    let r = self.decode_sample()?;
1082                    let l = if let Some(l) = l {S::from(l)} else {return Ok(None);};
1083                    let r = if let Some(r) = r {S::from(r)} else {return Ok(None);};
1084                    self.frame_index += 1;
1085                    Ok(Some(S::average(l, r)))
1086                },
1087                o => Err(AudioReadError::DataCorrupted(format!("Bad channels: {o} for the opus decoder."))),
1088            }
1089        }
1090
1091        pub fn decode_stereo<S>(&mut self) -> Result<Option<(S, S)>, AudioReadError>
1092        where S: SampleType {
1093            match self.channels {
1094                1 => {
1095                    let s = self.decode_sample()?;
1096                    if let Some(s) = s {self.frame_index += 1; let s = S::from(s); Ok(Some((s, s)))} else {Ok(None)}
1097                }
1098                2 => {
1099                    let l = self.decode_sample()?;
1100                    let r = self.decode_sample()?;
1101                    let l = if let Some(l) = l {S::from(l)} else {return Ok(None);};
1102                    let r = if let Some(r) = r {S::from(r)} else {return Ok(None);};
1103                    self.frame_index += 1;
1104                    Ok(Some((l, r)))
1105                },
1106                o => Err(AudioReadError::DataCorrupted(format!("Bad channels: {o} for the opus decoder."))),
1107            }
1108        }
1109
1110        pub fn decode_frame<S>(&mut self) -> Result<Option<Vec<S>>, AudioReadError>
1111        where S: SampleType {
1112            let stereo = self.decode_stereo::<S>()?;
1113            match stereo {
1114                None => Ok(None),
1115                Some((l, r)) => {
1116                    match self.channels {
1117                        1 => Ok(Some(vec![S::from(l)])),
1118                        2 => Ok(Some(vec![S::from(l), S::from(r)])),
1119                        o => Err(AudioReadError::DataCorrupted(format!("Unknown channel count {o}."))),
1120                    }
1121                },
1122            }
1123        }
1124    }
1125
1126    impl Debug for OpusDecoder {
1127        fn fmt(&self, f: &mut Formatter) -> fmt::Result {
1128            f.debug_struct("OpusDecoder")
1129                .field("reader", &self.reader)
1130                .field("decoder", &self.decoder)
1131                .field("channels", &self.channels)
1132                .field("sample_rate", &self.sample_rate)
1133                .field("data_offset", &self.data_offset)
1134                .field("data_length", &self.data_length)
1135                .field("total_frames", &self.total_frames)
1136                .field("block_align", &self.block_align)
1137                .field("decoded_samples", &format_args!("[f32; {}]", self.decoded_samples.len()))
1138                .field("decoded_samples_index", &self.decoded_samples_index)
1139                .field("frame_index", &self.frame_index)
1140                .finish()
1141        }
1142    }
1143}
1144
1145#[cfg(feature = "flac")]
1146pub mod flac {
1147    use std::{io::{self, SeekFrom}, cmp::Ordering, fmt::{self, Debug, Formatter}, ptr};
1148
1149    use crate::Reader;
1150    use crate::SampleType;
1151    use crate::AudioReadError;
1152    use crate::wavcore::FmtChunk;
1153    use crate::flac::*;
1154    use crate::resampler::Resampler;
1155    use crate::utils::{sample_conv, sample_conv_batch, do_resample_frames};
1156    use super::get_rounded_up_fft_size;
1157
1158    pub struct FlacDecoderWrap<'a> {
1159        reader: Box<dyn Reader>,
1160        decoder: Box<FlacDecoderUnmovable<'a>>,
1161        resampler: Resampler,
1162        channels: u16,
1163        sample_rate: u32,
1164        data_offset: u64,
1165        data_length: u64,
1166        decoded_frames: Vec<Vec<i32>>,
1167        decoded_frames_index: usize,
1168        frame_index: u64,
1169        total_frames: u64,
1170        self_ptr: Box<*mut FlacDecoderWrap<'a>>
1171    }
1172
1173    impl<'a> FlacDecoderWrap<'a> {
1174        pub fn new(reader: Box<dyn Reader>, data_offset: u64, data_length: u64, fmt: &FmtChunk, total_samples: u64) -> Result<Self, AudioReadError> {
1175            // `self_ptr`: A boxed raw pointer points to the `FlacDecoderWrap`, before calling `decoder.decode()`, must set the pointer inside the box to `self`
1176            let mut self_ptr: Box<*mut FlacDecoderWrap> = Box::new(ptr::null_mut());
1177            let self_ptr_ptr = (/* Mutable */&mut /* Unbox */*self_ptr) as /* To the pointer of */*mut /* the pointer inside the box pointing the `self`*/*mut Self;
1178            let reader_ptr = Box::into_raw(reader); // On the fly reader
1179            let decoder = Box::new(FlacDecoderUnmovable::new(
1180                unsafe {&mut *reader_ptr},
1181                // on_read
1182                Box::new(move |reader: &mut dyn ReadSeek, buffer: &mut [u8]| -> (usize, FlacReadStatus) {
1183                    let to_read = buffer.len();
1184                    match reader.read(buffer) {
1185                        Ok(size) => {
1186                            match size.cmp(&to_read) {
1187                                Ordering::Equal => (size, FlacReadStatus::GoOn),
1188                                Ordering::Less => (size, FlacReadStatus::Eof),
1189                                Ordering::Greater => panic!("`reader.read()` returns a size greater than the desired size."),
1190                            }
1191                        },
1192                        Err(e) => {
1193                            eprintln!("on_read(): {:?}", e);
1194                            (0, FlacReadStatus::Abort)
1195                        }
1196                    }
1197                }),
1198                // on_seek
1199                Box::new(move |reader: &mut dyn ReadSeek, position: u64|-> Result<(), io::Error> {
1200                    reader.seek(SeekFrom::Start(data_offset + position))?;
1201                    Ok(())
1202                }),
1203                // on_tell
1204                Box::new(move |reader: &mut dyn ReadSeek| -> Result<u64, io::Error> {
1205                    Ok(reader.stream_position()? - data_offset)
1206                }),
1207                // on_length
1208                Box::new(move |_reader: &mut dyn ReadSeek| -> Result<u64, io::Error> {
1209                    Ok(data_length)
1210                }),
1211                // on_eof
1212                Box::new(move |reader: &mut dyn ReadSeek| -> bool {
1213                    reader.stream_position().unwrap() >= data_offset + data_length
1214                }),
1215                // on_write
1216                Box::new(move |frames: &[Vec<i32>], sample_info: &SamplesInfo| -> Result<(), io::Error> {
1217                    // Before `on_write()` was called, make sure `self_ptr` was updated to the `self` pointer of `FlacDecoderWrap`
1218                    let this = unsafe{&mut (**self_ptr_ptr) as &mut Self};
1219                    this.decoded_frames_index = 0;
1220                    if sample_info.sample_rate != this.sample_rate {
1221                        this.decoded_frames.clear();
1222                        let process_size = this.resampler.get_process_size(this.resampler.get_fft_size(), sample_info.sample_rate, this.sample_rate);
1223                        let mut iter = frames.iter();
1224                        loop {
1225                            let block: Vec<Vec<i32>> = iter.by_ref().take(process_size).cloned().collect();
1226                            if block.is_empty() {
1227                                break;
1228                            }
1229                            this.decoded_frames.extend(sample_conv_batch(&do_resample_frames(&this.resampler, &block, sample_info.sample_rate, this.sample_rate)).to_vec());
1230                        }
1231                        this.decoded_frames.shrink_to_fit();
1232                    } else {
1233                        this.decoded_frames = frames.to_vec();
1234                    }
1235
1236                    Ok(())
1237                }),
1238                // on_error
1239                Box::new(move |error: FlacInternalDecoderError| {
1240                    eprintln!("on_error({error})");
1241                }),
1242                true, // md5_checking
1243                true, // scale_to_i32_range
1244                FlacAudioForm::FrameArray,
1245            )?);
1246            let mut ret = Self{
1247                reader: unsafe {Box::from_raw(reader_ptr)},
1248                decoder,
1249                resampler: Resampler::new(get_rounded_up_fft_size(fmt.sample_rate)),
1250                channels: fmt.channels,
1251                sample_rate: fmt.sample_rate,
1252                data_offset,
1253                data_length,
1254                decoded_frames: Vec::<Vec<i32>>::new(),
1255                decoded_frames_index: 0,
1256                frame_index: 0,
1257                total_frames: total_samples / fmt.channels as u64,
1258                self_ptr,
1259            };
1260            *ret.self_ptr = &mut ret as *mut Self;
1261            ret.decoder.initialize()?;
1262            Ok(ret)
1263        }
1264
1265        fn is_end_of_data(&mut self) -> Result<bool, AudioReadError> {
1266            Ok(self.decoder.eof())
1267        }
1268
1269        fn clear_decoded_frames(&mut self) {
1270            self.decoded_frames.clear();
1271            self.decoded_frames_index = 0;
1272        }
1273
1274        fn decode_block(&mut self) -> Result<(), AudioReadError> {
1275            if self.is_end_of_data()? {
1276                self.clear_decoded_frames();
1277                Ok(())
1278            } else {
1279                // When to decode, the FLAC decoder will call our callback functions, then our closures will be called.
1280                // These closures captured the address of the boxed `self_ptr`, and will use the pointer to find `self`
1281                *self.self_ptr = self as *mut Self;
1282                self.decoder.decode()?;
1283                Ok(())
1284            }
1285        }
1286
1287        pub fn get_channels(&self) -> u16 {
1288            self.channels
1289        }
1290
1291        pub fn get_sample_rate(&self) -> u32 {
1292            self.sample_rate
1293        }
1294
1295        pub fn get_cur_frame_index(&self) -> u64 {
1296            self.frame_index
1297        }
1298
1299        pub fn seek(&mut self, seek_from: SeekFrom) -> Result<(), AudioReadError> {
1300            let frame_index = match seek_from{
1301                SeekFrom::Start(fi) => fi,
1302                SeekFrom::Current(cur) => {
1303                    (self.frame_index as i64 + cur) as u64
1304                },
1305                SeekFrom::End(end) => {
1306                    (self.total_frames as i64 + end) as u64
1307                }
1308            };
1309            self.clear_decoded_frames();
1310            self.frame_index = frame_index;
1311            self.decoder.seek(frame_index)?;
1312
1313            Ok(())
1314        }
1315
1316        pub fn decode_frame<S>(&mut self) -> Result<Option<Vec<S>>, AudioReadError>
1317        where S: SampleType {
1318            if self.is_end_of_data()? {
1319                Ok(None)
1320            } else if self.decoded_frames_index < self.decoded_frames.len() {
1321                let ret = sample_conv(&self.decoded_frames[self.decoded_frames_index]);
1322                self.decoded_frames_index += 1;
1323                self.frame_index += 1;
1324                Ok(Some(ret.to_vec()))
1325            } else {
1326                self.decode_block()?;
1327                self.decoded_frames_index = 0;
1328                self.decode_frame::<S>()
1329            }
1330        }
1331
1332        pub fn decode_stereo<S>(&mut self) -> Result<Option<(S, S)>, AudioReadError>
1333        where S: SampleType {
1334            if let Some(frame) = self.decode_frame::<S>()? {
1335                match frame.len() {
1336                    1 => Ok(Some((frame[0], frame[0]))),
1337                    2 => Ok(Some((frame[0], frame[1]))),
1338                    o => Err(AudioReadError::Unsupported(format!("Unsupported to merge {o} channels to 2 channels."))),
1339                }
1340            } else {
1341                Ok(None)
1342            }
1343        }
1344
1345        pub fn decode_mono<S>(&mut self) -> Result<Option<S>, AudioReadError>
1346        where S: SampleType {
1347            if let Some(frame) = self.decode_frame::<S>()? {
1348                Ok(Some(S::average_arr(&frame)))
1349            } else {
1350                Ok(None)
1351            }
1352        }
1353    }
1354
1355    impl Debug for FlacDecoderWrap<'_> {
1356        fn fmt(&self, f: &mut Formatter) -> fmt::Result {
1357            f.debug_struct("FlacDecoderWrap")
1358                .field("reader", &self.reader)
1359                .field("decoder", &self.decoder)
1360                .field("resampler", &self.resampler)
1361                .field("channels", &self.channels)
1362                .field("sample_rate", &self.sample_rate)
1363                .field("data_offset", &self.data_offset)
1364                .field("data_length", &self.data_length)
1365                .field("decoded_frames", &format_args!("[i32; {}]", self.decoded_frames.len()))
1366                .field("decoded_frames_index", &self.decoded_frames_index)
1367                .field("frame_index", &self.frame_index)
1368                .field("total_frames", &self.total_frames)
1369                .field("self_ptr", &self.self_ptr)
1370                .finish()
1371        }
1372    }
1373}
rustwav_lib/decoders.rs

rustwav_lib/
decoders.rs
