Skip to main content

fdk_aac_rust/
lib.rs

1//! Safe Rust entry points for the Fraunhofer FDK AAC codec.
2//!
3//! Pure Rust AAC codec and transport implementation, with optional legacy FDK
4//! C/C++ API wrappers behind the `ffi` feature.
5
6#![allow(clippy::cast_possible_truncation)]
7
8pub mod aac_encoder;
9pub mod adif;
10pub mod adts;
11pub mod asc;
12pub mod audio_preroll;
13pub mod bits;
14pub mod concealment;
15pub mod decoder;
16pub mod drc;
17pub mod drm;
18pub mod eld_analysis;
19pub mod encoder;
20pub mod encoder_metadata;
21pub mod filterbank;
22pub mod fixed;
23mod fixed_fft;
24pub mod hcr;
25pub mod huffman;
26pub mod huffman_tables;
27pub mod ics;
28pub mod inverse;
29pub mod latm;
30pub mod ld_filterbank;
31pub mod ld_sbr;
32pub mod ld_sbr_qmf;
33pub mod limiter;
34pub mod loas;
35pub mod pns;
36pub mod ps;
37pub mod ps_encoder;
38pub mod pulse;
39pub mod raw;
40pub mod rvlc;
41pub mod sac;
42pub mod sbr;
43pub mod sbr_encoder;
44pub mod scalefactor;
45pub mod section;
46pub mod sfb;
47pub mod spectral;
48pub mod stereo;
49pub mod tns;
50pub mod transport;
51pub mod usac;
52pub mod usac_acelp;
53pub mod usac_arith;
54pub mod usac_decoder;
55pub mod usac_fac;
56pub mod usac_fd;
57pub mod usac_lpc;
58pub mod usac_lpd;
59pub mod usac_mps;
60pub mod usac_sbr;
61pub mod usac_stereo;
62pub mod usac_tcx;
63
64#[cfg(feature = "ffi")]
65#[deny(clippy::cast_possible_truncation)]
66mod ffi {
67    use crate::adts::AdtsHeader;
68    use std::{ffi::c_void, fmt, ptr};
69
70    pub use fdk_aac_sys as sys;
71
72    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
73    pub struct EncoderError(pub sys::AACENC_ERROR);
74
75    impl fmt::Display for EncoderError {
76        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
77            write!(f, "FDK AAC encoder error 0x{:04x}", self.0)
78        }
79    }
80
81    impl std::error::Error for EncoderError {}
82
83    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
84    pub struct DecoderError(pub sys::AAC_DECODER_ERROR);
85
86    impl fmt::Display for DecoderError {
87        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
88            write!(f, "FDK AAC decoder error 0x{:04x}", self.0)
89        }
90    }
91
92    impl std::error::Error for DecoderError {}
93
94    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
95    pub enum AudioObjectType {
96        AacLc,
97        HeAac,
98        HeAacV2,
99        AacEld,
100        Other(u32),
101    }
102
103    impl AudioObjectType {
104        fn as_raw(self) -> u32 {
105            match self {
106                Self::AacLc => sys::AOT_AAC_LC as u32,
107                Self::HeAac => sys::AOT_SBR as u32,
108                Self::HeAacV2 => sys::AOT_PS as u32,
109                Self::AacEld => sys::AOT_ER_AAC_ELD as u32,
110                Self::Other(value) => value,
111            }
112        }
113    }
114
115    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
116    pub enum ChannelMode {
117        Mono,
118        Stereo,
119        Three,
120        Four,
121        Five,
122        FiveOne,
123        Other(u32),
124    }
125
126    impl ChannelMode {
127        fn as_raw(self) -> u32 {
128            match self {
129                Self::Mono => sys::MODE_1 as u32,
130                Self::Stereo => sys::MODE_2 as u32,
131                Self::Three => sys::MODE_1_2 as u32,
132                Self::Four => sys::MODE_1_2_1 as u32,
133                Self::Five => sys::MODE_1_2_2 as u32,
134                Self::FiveOne => sys::MODE_1_2_2_1 as u32,
135                Self::Other(value) => value,
136            }
137        }
138    }
139
140    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
141    pub enum TransportType {
142        Raw,
143        Adif,
144        Adts,
145        LatmMuxConfigPresent,
146        LatmOutOfBandConfig,
147        Loas,
148        Drm,
149    }
150
151    impl TransportType {
152        fn as_raw(self) -> sys::TRANSPORT_TYPE {
153            match self {
154                Self::Raw => sys::TT_MP4_RAW,
155                Self::Adif => sys::TT_MP4_ADIF,
156                Self::Adts => sys::TT_MP4_ADTS,
157                Self::LatmMuxConfigPresent => sys::TT_MP4_LATM_MCP1,
158                Self::LatmOutOfBandConfig => sys::TT_MP4_LATM_MCP0,
159                Self::Loas => sys::TT_MP4_LOAS,
160                Self::Drm => sys::TT_DRM,
161            }
162        }
163    }
164
165    #[derive(Debug, Clone)]
166    pub struct EncoderConfig {
167        pub channels: u32,
168        pub sample_rate: u32,
169        pub bitrate: u32,
170        pub channel_mode: ChannelMode,
171        pub audio_object_type: AudioObjectType,
172        pub transport: TransportType,
173        pub afterburner: bool,
174        pub sbr_mode: Option<u32>,
175    }
176
177    impl EncoderConfig {
178        pub fn aac_lc_stereo(sample_rate: u32, bitrate: u32) -> Self {
179            Self {
180                channels: 2,
181                sample_rate,
182                bitrate,
183                channel_mode: ChannelMode::Stereo,
184                audio_object_type: AudioObjectType::AacLc,
185                transport: TransportType::Adts,
186                afterburner: true,
187                sbr_mode: None,
188            }
189        }
190    }
191
192    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
193    pub struct EncoderInfo {
194        pub max_output_bytes: u32,
195        pub max_ancillary_bytes: u32,
196        pub input_channels: u32,
197        pub frame_length: u32,
198        pub delay: u32,
199        pub core_delay: u32,
200    }
201
202    pub struct Encoder {
203        handle: sys::HANDLE_AACENCODER,
204        he_aac_v2_frame_samples: Option<usize>,
205        pending_he_aac_v2_input: Vec<i16>,
206        pending_he_aac_v2_metadata: Option<sys::AACENC_MetaData>,
207    }
208
209    impl Encoder {
210        pub fn open(max_channels: u32) -> Result<Self, EncoderError> {
211            let mut handle = ptr::null_mut();
212            check_encoder(unsafe { sys::aacEncOpen(&mut handle, 0, max_channels) })?;
213            Ok(Self {
214                handle,
215                he_aac_v2_frame_samples: None,
216                pending_he_aac_v2_input: Vec::new(),
217                pending_he_aac_v2_metadata: None,
218            })
219        }
220
221        pub fn configured(config: &EncoderConfig) -> Result<Self, EncoderError> {
222            let mut encoder = Self::open(config.channels)?;
223            encoder.set_param(sys::AACENC_AOT, config.audio_object_type.as_raw())?;
224            encoder.set_param(sys::AACENC_SAMPLERATE, config.sample_rate)?;
225            encoder.set_param(sys::AACENC_CHANNELMODE, config.channel_mode.as_raw())?;
226            encoder.set_param(sys::AACENC_CHANNELORDER, 1)?;
227            encoder.set_param(sys::AACENC_BITRATE, config.bitrate)?;
228            encoder.set_param(sys::AACENC_TRANSMUX, config.transport.as_raw() as u32)?;
229            encoder.set_param(sys::AACENC_AFTERBURNER, u32::from(config.afterburner))?;
230            if let Some(mode) = config.sbr_mode {
231                encoder.set_param(sys::AACENC_SBR_MODE, mode)?;
232            }
233            encoder.initialize()?;
234            Ok(encoder)
235        }
236
237        pub fn set_param(
238            &mut self,
239            param: sys::AACENC_PARAM,
240            value: u32,
241        ) -> Result<(), EncoderError> {
242            check_encoder(unsafe { sys::aacEncoder_SetParam(self.handle, param, value) })?;
243            self.he_aac_v2_frame_samples = None;
244            self.pending_he_aac_v2_input.clear();
245            self.pending_he_aac_v2_metadata = None;
246            Ok(())
247        }
248
249        pub fn get_param(&self, param: sys::AACENC_PARAM) -> u32 {
250            unsafe { sys::aacEncoder_GetParam(self.handle, param) }
251        }
252
253        pub fn initialize(&mut self) -> Result<(), EncoderError> {
254            check_encoder(unsafe {
255                sys::aacEncEncode(
256                    self.handle,
257                    ptr::null(),
258                    ptr::null(),
259                    ptr::null(),
260                    ptr::null_mut(),
261                )
262            })?;
263            self.pending_he_aac_v2_input.clear();
264            self.pending_he_aac_v2_metadata = None;
265            self.he_aac_v2_frame_samples = if self.get_param(sys::AACENC_AOT) == sys::AOT_PS as u32
266            {
267                let info = self.info()?;
268                Some(
269                    usize::try_from(
270                        info.frame_length
271                            .checked_mul(info.input_channels)
272                            .ok_or_else(invalid_encoder_input)?,
273                    )
274                    .map_err(|_| invalid_encoder_input())?,
275                )
276            } else {
277                None
278            };
279            Ok(())
280        }
281
282        pub fn info(&self) -> Result<EncoderInfo, EncoderError> {
283            let mut raw = sys::AACENC_InfoStruct::default();
284            check_encoder(unsafe { sys::aacEncInfo(self.handle, &mut raw) })?;
285            Ok(EncoderInfo {
286                max_output_bytes: raw.maxOutBufBytes,
287                max_ancillary_bytes: raw.maxAncBytes,
288                input_channels: raw.inputChannels,
289                frame_length: raw.frameLength,
290                delay: raw.nDelay,
291                core_delay: raw.nDelayCore,
292            })
293        }
294
295        pub fn audio_specific_config(&self) -> Result<Vec<u8>, EncoderError> {
296            let mut raw = sys::AACENC_InfoStruct::default();
297            check_encoder(unsafe { sys::aacEncInfo(self.handle, &mut raw) })?;
298            let size = usize::try_from(raw.confSize).map_err(|_| invalid_encoder_input())?;
299            raw.confBuf
300                .get(..size)
301                .map(|bytes| bytes.to_vec())
302                .ok_or_else(invalid_encoder_input)
303        }
304
305        pub fn encode_interleaved_i16(
306            &mut self,
307            input: &[i16],
308            output: &mut [u8],
309        ) -> Result<usize, EncoderError> {
310            self.encode_interleaved_i16_with_ancillary(input, &[], output)
311                .map(|(bytes, _)| bytes)
312        }
313
314        pub fn encode_interleaved_i16_with_ancillary(
315            &mut self,
316            input: &[i16],
317            ancillary: &[u8],
318            output: &mut [u8],
319        ) -> Result<(usize, usize), EncoderError> {
320            self.encode_interleaved_i16_with_ancillary_and_metadata(input, ancillary, None, output)
321        }
322
323        pub fn encode_interleaved_i16_with_ancillary_and_metadata(
324            &mut self,
325            input: &[i16],
326            ancillary: &[u8],
327            metadata: Option<&sys::AACENC_MetaData>,
328            output: &mut [u8],
329        ) -> Result<(usize, usize), EncoderError> {
330            // Upstream issue #129 documents an out-of-bounds deinterleave when
331            // HE-AACv2 receives less than one complete input frame. Keep the
332            // safe wrapper's incremental-input behavior, but do not expose the
333            // vulnerable C path to a short slice.
334            if let Some(frame_samples) = self.he_aac_v2_frame_samples {
335                self.pending_he_aac_v2_input.extend_from_slice(input);
336                if self.pending_he_aac_v2_input.len() < frame_samples {
337                    if let Some(metadata) = metadata {
338                        self.pending_he_aac_v2_metadata = Some(*metadata);
339                    }
340                    return Ok((0, 0));
341                }
342                let complete_frame = self
343                    .pending_he_aac_v2_input
344                    .drain(..frame_samples)
345                    .collect::<Vec<_>>();
346                let pending_metadata = self.pending_he_aac_v2_metadata.take();
347                return self.encode_complete_interleaved_i16_with_ancillary_and_metadata(
348                    &complete_frame,
349                    ancillary,
350                    metadata.or(pending_metadata.as_ref()),
351                    output,
352                );
353            }
354            self.encode_complete_interleaved_i16_with_ancillary_and_metadata(
355                input, ancillary, metadata, output,
356            )
357        }
358
359        fn encode_complete_interleaved_i16_with_ancillary_and_metadata(
360            &mut self,
361            input: &[i16],
362            ancillary: &[u8],
363            metadata: Option<&sys::AACENC_MetaData>,
364            output: &mut [u8],
365        ) -> Result<(usize, usize), EncoderError> {
366            let in_ptr = input.as_ptr() as *mut c_void;
367            let ancillary_ptr = ancillary.as_ptr() as *mut c_void;
368            let metadata_ptr = metadata
369                .map(|value| value as *const sys::AACENC_MetaData as *mut c_void)
370                .unwrap_or(ptr::null_mut());
371            let mut out_ptr = output.as_mut_ptr() as *mut c_void;
372
373            let mut in_ptrs = [in_ptr, ancillary_ptr, metadata_ptr];
374            let mut in_ids = [
375                sys::IN_AUDIO_DATA,
376                sys::IN_ANCILLRY_DATA,
377                sys::IN_METADATA_SETUP,
378            ];
379            let mut out_id = sys::OUT_BITSTREAM_DATA;
380            let mut in_sizes = [
381                encoder_i32_len(std::mem::size_of_val(input))?,
382                encoder_i32_len(std::mem::size_of_val(ancillary))?,
383                encoder_i32_len(std::mem::size_of::<sys::AACENC_MetaData>())?,
384            ];
385            let mut out_size = encoder_i32_len(output.len())?;
386            let mut in_element_sizes = [
387                encoder_i32_len(std::mem::size_of::<i16>())?,
388                encoder_i32_len(std::mem::size_of::<u8>())?,
389                encoder_i32_len(std::mem::size_of::<sys::AACENC_MetaData>())?,
390            ];
391            let mut out_element_size = encoder_i32_len(std::mem::size_of::<u8>())?;
392
393            let in_desc = sys::AACENC_BufDesc {
394                numBufs: if metadata.is_some() { 3 } else { 2 },
395                bufs: in_ptrs.as_mut_ptr(),
396                bufferIdentifiers: in_ids.as_mut_ptr(),
397                bufSizes: in_sizes.as_mut_ptr(),
398                bufElSizes: in_element_sizes.as_mut_ptr(),
399            };
400            let out_desc = sys::AACENC_BufDesc {
401                numBufs: 1,
402                bufs: &mut out_ptr,
403                bufferIdentifiers: &mut out_id,
404                bufSizes: &mut out_size,
405                bufElSizes: &mut out_element_size,
406            };
407            let in_args = sys::AACENC_InArgs {
408                numInSamples: encoder_i32_len(input.len())?,
409                numAncBytes: encoder_i32_len(ancillary.len())?,
410            };
411            let mut out_args = sys::AACENC_OutArgs::default();
412
413            check_encoder(unsafe {
414                sys::aacEncEncode(self.handle, &in_desc, &out_desc, &in_args, &mut out_args)
415            })?;
416            Ok((
417                checked_encoder_count(out_args.numOutBytes, output.len())?,
418                checked_encoder_count(out_args.numAncBytes, ancillary.len())?,
419            ))
420        }
421    }
422
423    impl Drop for Encoder {
424        fn drop(&mut self) {
425            if !self.handle.is_null() {
426                let _ = unsafe { sys::aacEncClose(&mut self.handle) };
427            }
428        }
429    }
430
431    pub struct Decoder {
432        handle: sys::HANDLE_AACDECODER,
433    }
434
435    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
436    pub struct StreamInfo {
437        pub sample_rate: i32,
438        pub frame_size: i32,
439        pub channels: i32,
440        pub output_delay: u32,
441        pub flags: u32,
442        pub drc_program_reference_level: i8,
443        pub drc_presentation_mode: i8,
444        pub output_loudness: i32,
445    }
446
447    impl Decoder {
448        pub fn open(transport: TransportType) -> Result<Self, DecoderError> {
449            let handle = unsafe { sys::aacDecoder_Open(transport.as_raw(), 1) };
450            if handle.is_null() {
451                Err(DecoderError(sys::AAC_DEC_OUT_OF_MEMORY))
452            } else {
453                Ok(Self { handle })
454            }
455        }
456
457        /// Open a raw AAC decoder configured from a Pure Rust parsed ADTS header.
458        ///
459        /// This avoids FDK's C/C++ ADTS transport parser for configuration. The AAC
460        /// core is still the upstream FDK decoder; callers should feed raw ADTS
461        /// payloads, for example from [`adts::AdtsStream`].
462        pub fn open_raw_from_adts(header: AdtsHeader) -> Result<Self, DecoderError> {
463            let mut decoder = Self::open(TransportType::Raw)?;
464            let mut asc = header
465                .audio_specific_config()
466                .map_err(|_| DecoderError(sys::AAC_DEC_UNSUPPORTED_FORMAT))?
467                .to_bytes()
468                .map_err(|_| DecoderError(sys::AAC_DEC_UNSUPPORTED_FORMAT))?;
469            decoder.configure_raw(&mut asc)?;
470            Ok(decoder)
471        }
472
473        pub fn configure_raw(&mut self, config: &mut [u8]) -> Result<(), DecoderError> {
474            let mut ptr = config.as_mut_ptr();
475            let len = decoder_u32_len(config.len())?;
476            check_decoder(unsafe { sys::aacDecoder_ConfigRaw(self.handle, &mut ptr, &len) })
477        }
478
479        pub fn fill(&mut self, input: &mut [u8]) -> Result<usize, DecoderError> {
480            let mut ptr = input.as_mut_ptr();
481            let size = decoder_u32_len(input.len())?;
482            let mut valid = size;
483            check_decoder(unsafe {
484                sys::aacDecoder_Fill(self.handle, &mut ptr, &size, &mut valid)
485            })?;
486            let consumed = size
487                .checked_sub(valid)
488                .ok_or(DecoderError(sys::AAC_DEC_UNKNOWN))?;
489            Ok(usize::try_from(consumed).expect("u32 fits usize on supported Rust targets"))
490        }
491
492        pub fn decode_frame(&mut self, output: &mut [i16]) -> Result<(), DecoderError> {
493            self.decode_frame_with_flags(output, 0)
494        }
495
496        pub fn decode_frame_with_flags(
497            &mut self,
498            output: &mut [i16],
499            flags: u32,
500        ) -> Result<(), DecoderError> {
501            check_decoder(unsafe {
502                sys::aacDecoder_DecodeFrame(
503                    self.handle,
504                    output.as_mut_ptr(),
505                    decoder_i32_len(output.len())?,
506                    flags,
507                )
508            })
509        }
510
511        pub fn set_parameter(
512            &mut self,
513            parameter: sys::AACDEC_PARAM,
514            value: i32,
515        ) -> Result<(), DecoderError> {
516            check_decoder(unsafe { sys::aacDecoder_SetParam(self.handle, parameter, value) })
517        }
518
519        pub fn decode_access_unit_i16(
520            &mut self,
521            input: &[u8],
522            output: &mut [i16],
523        ) -> Result<usize, DecoderError> {
524            let mut owned = input.to_vec();
525            self.fill(&mut owned)?;
526            self.decode_frame(output)?;
527            let samples = self.stream_info().map_or(Ok(output.len()), |info| {
528                info.frame_size
529                    .checked_mul(info.channels)
530                    .filter(|samples| *samples >= 0)
531                    .and_then(|samples| usize::try_from(samples).ok())
532                    .ok_or(DecoderError(sys::AAC_DEC_UNKNOWN))
533            })?;
534            Ok(samples.min(output.len()))
535        }
536
537        pub fn stream_info(&self) -> Option<StreamInfo> {
538            let raw = unsafe { sys::aacDecoder_GetStreamInfo(self.handle).as_ref()? };
539            Some(StreamInfo {
540                sample_rate: raw.sampleRate,
541                frame_size: raw.frameSize,
542                channels: raw.numChannels,
543                output_delay: raw.outputDelay,
544                flags: raw.flags,
545                drc_program_reference_level: raw.drcProgRefLev,
546                drc_presentation_mode: raw.drcPresMode,
547                output_loudness: raw.outputLoudness,
548            })
549        }
550    }
551
552    impl Drop for Decoder {
553        fn drop(&mut self) {
554            if !self.handle.is_null() {
555                unsafe { sys::aacDecoder_Close(self.handle) };
556            }
557        }
558    }
559
560    fn check_encoder(err: sys::AACENC_ERROR) -> Result<(), EncoderError> {
561        if err == sys::AACENC_OK {
562            Ok(())
563        } else {
564            Err(EncoderError(err))
565        }
566    }
567
568    fn check_decoder(err: sys::AAC_DECODER_ERROR) -> Result<(), DecoderError> {
569        if err == sys::AAC_DEC_OK {
570            Ok(())
571        } else {
572            Err(DecoderError(err))
573        }
574    }
575
576    fn invalid_encoder_input() -> EncoderError {
577        EncoderError(sys::AACENC_INVALID_CONFIG)
578    }
579
580    fn encoder_i32_len(len: usize) -> Result<i32, EncoderError> {
581        i32::try_from(len).map_err(|_| invalid_encoder_input())
582    }
583
584    fn checked_encoder_count(value: i32, capacity: usize) -> Result<usize, EncoderError> {
585        let value = usize::try_from(value).map_err(|_| EncoderError(sys::AACENC_ENCODE_ERROR))?;
586        if value > capacity {
587            Err(EncoderError(sys::AACENC_ENCODE_ERROR))
588        } else {
589            Ok(value)
590        }
591    }
592
593    fn decoder_u32_len(len: usize) -> Result<u32, DecoderError> {
594        u32::try_from(len).map_err(|_| DecoderError(sys::AAC_DEC_UNSUPPORTED_FORMAT))
595    }
596
597    fn decoder_i32_len(len: usize) -> Result<i32, DecoderError> {
598        i32::try_from(len).map_err(|_| DecoderError(sys::AAC_DEC_OUTPUT_BUFFER_TOO_SMALL))
599    }
600
601    #[cfg(test)]
602    mod tests {
603        use super::*;
604        use crate::aac_encoder::PureRustAacLcMonoEncoder;
605        use crate::adts;
606        use crate::asc::{
607            AudioSpecificConfig, EldSpecificConfig, GaSpecificConfig, ProgramConfig, ProgramElement,
608        };
609        use crate::bits::{BitReader, BitWriter};
610        use crate::decoder::AacLcDecoder;
611        use crate::raw::ElementId;
612        use crate::section::ZERO_HCB;
613
614        #[test]
615        fn ffi_lengths_reject_values_that_do_not_fit_c_types() {
616            assert_eq!(
617                encoder_i32_len(usize::MAX),
618                Err(EncoderError(sys::AACENC_INVALID_CONFIG))
619            );
620            assert_eq!(
621                decoder_i32_len(usize::MAX),
622                Err(DecoderError(sys::AAC_DEC_OUTPUT_BUFFER_TOO_SMALL))
623            );
624            if usize::BITS > u32::BITS {
625                assert_eq!(
626                    decoder_u32_len(usize::MAX),
627                    Err(DecoderError(sys::AAC_DEC_UNSUPPORTED_FORMAT))
628                );
629            }
630        }
631
632        #[test]
633        fn ffi_counts_reject_negative_and_out_of_capacity_results() {
634            assert_eq!(
635                checked_encoder_count(-1, 32),
636                Err(EncoderError(sys::AACENC_ENCODE_ERROR))
637            );
638            assert_eq!(
639                checked_encoder_count(33, 32),
640                Err(EncoderError(sys::AACENC_ENCODE_ERROR))
641            );
642            assert_eq!(checked_encoder_count(32, 32), Ok(32));
643        }
644
645        #[test]
646        fn ffi_he_aac_v2_buffers_short_input_before_calling_c() {
647            let mut config = EncoderConfig::aac_lc_stereo(48_000, 32_000);
648            config.audio_object_type = AudioObjectType::HeAacV2;
649            config.transport = TransportType::Raw;
650            let mut encoder = Encoder::configured(&config).unwrap();
651            let info = encoder.info().unwrap();
652            let frame_samples = usize::try_from(info.frame_length * info.input_channels).unwrap();
653            assert_eq!(encoder.he_aac_v2_frame_samples, Some(frame_samples));
654
655            let mut output = vec![0; info.max_output_bytes as usize];
656            let split = frame_samples / 3;
657            assert_eq!(
658                encoder
659                    .encode_interleaved_i16(&vec![0; split], &mut output)
660                    .unwrap(),
661                0
662            );
663            assert_eq!(encoder.pending_he_aac_v2_input.len(), split);
664
665            encoder
666                .encode_interleaved_i16(&vec![0; frame_samples - split], &mut output)
667                .unwrap();
668            assert!(encoder.pending_he_aac_v2_input.is_empty());
669        }
670        use crate::spectral::decode_spectral_tuple;
671        use crate::transport::{DecodeFrameFlags, DecoderParameter, PureRustTransportDecoder};
672
673        #[test]
674        fn configures_encoder() {
675            let config = EncoderConfig::aac_lc_stereo(44_100, 128_000);
676            let encoder = Encoder::configured(&config).unwrap();
677            let info = encoder.info().unwrap();
678            assert_eq!(info.input_channels, 2);
679            assert!(info.frame_length > 0);
680            assert!(info.max_output_bytes > 0);
681        }
682
683        #[test]
684        fn configures_eld_sbr_encoder_and_exposes_asc() {
685            let mut config = EncoderConfig::aac_lc_stereo(44_100, 32_000);
686            config.channels = 1;
687            config.channel_mode = ChannelMode::Mono;
688            config.audio_object_type = AudioObjectType::AacEld;
689            config.transport = TransportType::Raw;
690            config.sbr_mode = Some(1);
691            let encoder = Encoder::configured(&config).unwrap();
692            let asc_bytes = encoder.audio_specific_config().unwrap();
693            let asc = AudioSpecificConfig::parse(&asc_bytes).unwrap();
694            assert_eq!(asc.audio_object_type, 39);
695            assert!(asc.eld_specific.unwrap().sbr_present);
696        }
697
698        #[test]
699        fn decodes_encoder_generated_eld_sbr_access_units_in_pure_rust() {
700            let mut config = EncoderConfig::aac_lc_stereo(44_100, 32_000);
701            config.channels = 1;
702            config.channel_mode = ChannelMode::Mono;
703            config.audio_object_type = AudioObjectType::AacEld;
704            config.transport = TransportType::Raw;
705            config.sbr_mode = Some(1);
706            let mut encoder = Encoder::configured(&config).unwrap();
707            let info = encoder.info().unwrap();
708            let mut asc_bytes = encoder.audio_specific_config().unwrap();
709            let asc = AudioSpecificConfig::parse(&asc_bytes).unwrap();
710            let mut fdk = Decoder::open(TransportType::Raw).unwrap();
711            fdk.configure_raw(&mut asc_bytes).unwrap();
712            fdk.set_parameter(sys::AAC_QMF_LOWPOWER, 1).unwrap();
713            let mut pure = AacLcDecoder::from_audio_specific_config(&asc).unwrap();
714            let mut pure_float = AacLcDecoder::from_audio_specific_config(&asc).unwrap();
715            pure.set_qmf_low_power(true);
716            pure_float.set_qmf_low_power(true);
717            let mut encoded = vec![0u8; info.max_output_bytes as usize];
718            let mut fdk_pcm = vec![0i16; 4096];
719            let mut decoded_access_units = 0;
720            let mut fdk_sequence = Vec::new();
721            let mut rust_sequence = Vec::new();
722            let mut rust_float_sequence = Vec::new();
723            for frame in 0..20 {
724                let input = (0..info.frame_length as usize)
725                    .map(|sample| {
726                        let position = frame as f64 * info.frame_length as f64 + sample as f64;
727                        (position * 2.0 * std::f64::consts::PI * 997.0 / 44_100.0).sin() * 2_000.0
728                    })
729                    .map(|sample| sample.round() as i16)
730                    .collect::<Vec<_>>();
731                let bytes = encoder
732                    .encode_interleaved_i16(&input, &mut encoded)
733                    .unwrap();
734                if bytes == 0 {
735                    continue;
736                }
737                let fdk_samples = fdk
738                    .decode_access_unit_i16(&encoded[..bytes], &mut fdk_pcm)
739                    .unwrap();
740                let rust = pure
741                    .decode_raw_data_block_fixed_interleaved_i16(&encoded[..bytes])
742                    .unwrap_or_else(|error| panic!("encoded ELD-SBR frame {frame}: {error:?}"));
743                let rust_float = pure_float
744                    .decode_raw_data_block_interleaved_f32(&encoded[..bytes])
745                    .unwrap_or_else(|error| {
746                        panic!("float encoded ELD-SBR frame {frame}: {error:?}")
747                    });
748                assert_eq!(rust.len(), fdk_samples);
749                assert!(rust
750                    .iter()
751                    .all(|sample| sample.unsigned_abs() <= i16::MAX as u16 + 1));
752                if decoded_access_units >= 8 {
753                    fdk_sequence.extend_from_slice(&fdk_pcm[..fdk_samples]);
754                    rust_sequence.extend_from_slice(&rust);
755                    rust_float_sequence.extend(rust_float.iter().map(|sample| f64::from(*sample)));
756                }
757                decoded_access_units += 1;
758            }
759            assert!(decoded_access_units >= 8);
760            assert_eq!(
761                fdk.stream_info().unwrap().output_delay as usize,
762                PureRustTransportDecoder::from_audio_specific_config(&asc)
763                    .unwrap()
764                    .stream_info()
765                    .output_delay
766            );
767            let mut best = (0isize, 0.0f64, 0.0f64);
768            for lag in -2048isize..=2048 {
769                let mut dot = 0.0;
770                let mut rust_energy = 0.0;
771                let mut fdk_energy = 0.0;
772                for (index, &rust) in rust_sequence.iter().enumerate() {
773                    let fdk_index = index as isize + lag;
774                    if (0..fdk_sequence.len() as isize).contains(&fdk_index) {
775                        let rust = f64::from(rust);
776                        let fdk = f64::from(fdk_sequence[fdk_index as usize]);
777                        dot += rust * fdk;
778                        rust_energy += rust * rust;
779                        fdk_energy += fdk * fdk;
780                    }
781                }
782                let correlation = dot / (rust_energy * fdk_energy).sqrt();
783                if correlation.abs() > best.1.abs() {
784                    best = (lag, correlation, (rust_energy / fdk_energy).sqrt());
785                }
786            }
787            assert!(best.1.is_finite());
788            assert!(best.0.abs() <= 1, "fixed ELD-SBR lag {}", best.0);
789            assert!(best.1 > 0.99, "fixed ELD-SBR correlation {}", best.1);
790            let mut float_best = (0isize, 0.0f64, 0.0f64);
791            for lag in -2048isize..=2048 {
792                let mut dot = 0.0;
793                let mut rust_energy = 0.0;
794                let mut fdk_energy = 0.0;
795                for (index, &rust) in rust_float_sequence.iter().enumerate() {
796                    let fdk_index = index as isize + lag;
797                    if (0..fdk_sequence.len() as isize).contains(&fdk_index) {
798                        let fdk = f64::from(fdk_sequence[fdk_index as usize]);
799                        dot += rust * fdk;
800                        rust_energy += rust * rust;
801                        fdk_energy += fdk * fdk;
802                    }
803                }
804                let correlation = dot / (rust_energy * fdk_energy).sqrt();
805                if correlation.abs() > float_best.1.abs() {
806                    float_best = (lag, correlation, (rust_energy / fdk_energy).sqrt());
807                }
808            }
809            assert!(
810                float_best.0.abs() <= 1,
811                "float ELD-SBR lag {}",
812                float_best.0
813            );
814            assert!(
815                float_best.1 > 0.99,
816                "float ELD-SBR correlation {}",
817                float_best.1
818            );
819            assert!(
820                (0.10..=0.15).contains(&float_best.2),
821                "float ELD-SBR RMS ratio {}",
822                float_best.2
823            );
824            assert!(
825                (0.95..=1.05).contains(&best.2),
826                "encoder ELD-SBR best-lag RMS ratio {}, lag {}, correlation {}",
827                best.2,
828                best.0,
829                best.1
830            );
831        }
832
833        #[test]
834        fn opens_decoder() {
835            let decoder = Decoder::open(TransportType::Adts).unwrap();
836            assert!(decoder.stream_info().is_some());
837        }
838
839        #[test]
840        fn opens_raw_decoder_from_pure_rust_adts_header() {
841            let header = adts::AdtsHeader::aac_lc(44_100, 2, 0).unwrap();
842            let decoder = Decoder::open_raw_from_adts(header).unwrap();
843            assert!(decoder.stream_info().is_some());
844        }
845
846        #[test]
847        fn fdk_decoder_access_unit_helper_matches_pure_rust_zero_cpe_silence() {
848            let payload = zero_cpe_payload_for_parity();
849            let header = adts::AdtsHeader::aac_lc(44_100, 2, payload.len()).unwrap();
850            let mut frame = vec![0; header.header_len()];
851            header.write(&mut frame).unwrap();
852            frame.extend_from_slice(&payload);
853
854            let mut fdk = Decoder::open(TransportType::Adts).unwrap();
855            let mut fdk_pcm = vec![123i16; 4096];
856            let fdk_samples = fdk.decode_access_unit_i16(&frame, &mut fdk_pcm).unwrap();
857            let fdk_pcm = &fdk_pcm[..fdk_samples];
858
859            let mut pure = AacLcDecoder::from_adts_header(header).unwrap();
860            let pure_pcm = pure.decode_adts_frame_interleaved_i16(&frame).unwrap();
861
862            assert_eq!(fdk_pcm.len(), pure_pcm.len());
863            assert!(fdk_pcm.iter().all(|sample| *sample == 0));
864            assert_eq!(fdk_pcm, pure_pcm.as_slice());
865        }
866
867        #[test]
868        fn raw_fdk_decoder_configured_from_pure_rust_adts_matches_pure_rust_payload_decode() {
869            let payload = zero_cpe_payload_for_parity();
870            let header = adts::AdtsHeader::aac_lc(44_100, 2, payload.len()).unwrap();
871
872            let mut fdk = Decoder::open_raw_from_adts(header).unwrap();
873            let mut fdk_pcm = vec![123i16; 4096];
874            let fdk_samples = fdk.decode_access_unit_i16(&payload, &mut fdk_pcm).unwrap();
875            let fdk_pcm = &fdk_pcm[..fdk_samples];
876
877            let mut pure = AacLcDecoder::new(
878                header.sampling_frequency_index,
879                header.channel_configuration,
880            )
881            .unwrap();
882            let pure_pcm = pure
883                .decode_raw_data_block_multichannel_f32(&payload)
884                .unwrap()
885                .interleaved_i16();
886
887            assert_eq!(fdk_pcm.len(), pure_pcm.len());
888            assert!(fdk_pcm.iter().all(|sample| *sample == 0));
889            assert_eq!(fdk_pcm, pure_pcm.as_slice());
890        }
891
892        #[test]
893        fn fdk_and_pure_rust_limiter_parameters_report_the_same_delay() {
894            let payload = zero_cpe_payload_for_parity();
895            let header = adts::AdtsHeader::aac_lc(44_100, 2, payload.len()).unwrap();
896            let mut frame = vec![0; header.header_len()];
897            header.write(&mut frame).unwrap();
898            frame.extend_from_slice(&payload);
899
900            for (fdk_parameter, rust_parameter, value, expected_delay) in [
901                (
902                    sys::AAC_PCM_LIMITER_ENABLE,
903                    DecoderParameter::PcmLimiterEnable,
904                    0,
905                    1024,
906                ),
907                (
908                    sys::AAC_PCM_LIMITER_ATTACK_TIME,
909                    DecoderParameter::PcmLimiterAttackTime,
910                    1,
911                    1068,
912                ),
913            ] {
914                let mut fdk = Decoder::open(TransportType::Adts).unwrap();
915                fdk.set_parameter(fdk_parameter, value).unwrap();
916                let mut fdk_pcm = vec![0i16; 4096];
917                fdk.decode_access_unit_i16(&frame, &mut fdk_pcm).unwrap();
918
919                let mut pure = PureRustTransportDecoder::from_adts_header(header).unwrap();
920                pure.set_parameter(rust_parameter, value).unwrap();
921                pure.decode_interleaved_i16(&frame).unwrap();
922
923                assert_eq!(fdk.stream_info().unwrap().output_delay, expected_delay);
924                assert_eq!(pure.stream_info().output_delay, expected_delay as usize);
925            }
926        }
927
928        #[test]
929        fn fdk_and_pure_rust_explicit_energy_concealment_have_matching_timing() {
930            fn correlation(left: &[i16], right: &[i16]) -> f64 {
931                let (mut dot, mut left_energy, mut right_energy) = (0.0, 0.0, 0.0);
932                for (&left, &right) in left.iter().zip(right) {
933                    let left = f64::from(left);
934                    let right = f64::from(right);
935                    dot += left * right;
936                    left_energy += left * left;
937                    right_energy += right * right;
938                }
939                dot / (left_energy * right_energy).sqrt().max(f64::MIN_POSITIVE)
940            }
941
942            let mut encoder = PureRustAacLcMonoEncoder::new(4, 32_000, 16_000).unwrap();
943            let access_units = (0..5)
944                .map(|frame| {
945                    let pcm = (0..1024)
946                        .map(|sample| {
947                            let position = frame * 1024 + sample;
948                            (position as f32 * 0.041).sin() * 12_000.0
949                        })
950                        .collect::<Vec<_>>();
951                    encoder.encode_raw_data_block(&pcm).unwrap()
952                })
953                .collect::<Vec<_>>();
954            let asc = AudioSpecificConfig::aac_lc(44_100, 1).unwrap();
955            let mut asc_bytes = asc.to_bytes().unwrap();
956
957            let mut fdk = Decoder::open(TransportType::Raw).unwrap();
958            fdk.configure_raw(&mut asc_bytes).unwrap();
959            fdk.set_parameter(sys::AAC_PCM_LIMITER_ENABLE, 0).unwrap();
960            fdk.set_parameter(sys::AAC_CONCEAL_METHOD, 2).unwrap();
961            let mut pure = PureRustTransportDecoder::from_audio_specific_config(&asc).unwrap();
962            pure.set_parameter(DecoderParameter::PcmLimiterEnable, 0)
963                .unwrap();
964            pure.set_parameter(DecoderParameter::ConcealMethod, 2)
965                .unwrap();
966            for access_unit in &access_units[..3] {
967                fdk.fill(&mut access_unit.clone()).unwrap();
968                fdk.decode_frame(&mut vec![0i16; 1024]).unwrap();
969                pure.decode_interleaved_i16(access_unit).unwrap();
970            }
971
972            let mut fdk_delayed = vec![0i16; 1024];
973            fdk.decode_frame_with_flags(&mut fdk_delayed, sys::AACDEC_CONCEAL)
974                .unwrap();
975            let mut fdk_interpolated = vec![0i16; 1024];
976            fdk.fill(&mut access_units[3].clone()).unwrap();
977            fdk.decode_frame(&mut fdk_interpolated).unwrap();
978
979            let pure_delayed = pure
980                .decode_interleaved_i16_with_flags(&[], DecodeFrameFlags::CONCEAL)
981                .unwrap();
982            let pure_interpolated = pure.decode_interleaved_i16(&access_units[3]).unwrap();
983
984            assert!(fdk_delayed.iter().any(|sample| *sample != 0));
985            assert!(pure_delayed.iter().any(|sample| *sample != 0));
986            assert!(fdk_interpolated.iter().any(|sample| *sample != 0));
987            assert!(pure_interpolated.iter().any(|sample| *sample != 0));
988            assert!(correlation(&fdk_delayed, &pure_delayed).abs() > 0.75);
989            assert!(correlation(&fdk_interpolated, &pure_interpolated).abs() > 0.65);
990        }
991
992        #[test]
993        fn fdk_and_pure_rust_remaining_decoder_parameters_accept_the_same_ranges() {
994            let header = adts::AdtsHeader::aac_lc(44_100, 2, 0).unwrap();
995            for (fdk_parameter, rust_parameter, value, accepted) in [
996                (
997                    sys::AAC_METADATA_PROFILE,
998                    DecoderParameter::MetadataProfile,
999                    3,
1000                    true,
1001                ),
1002                (
1003                    sys::AAC_METADATA_PROFILE,
1004                    DecoderParameter::MetadataProfile,
1005                    4,
1006                    false,
1007                ),
1008                (
1009                    sys::AAC_METADATA_EXPIRY_TIME,
1010                    DecoderParameter::MetadataExpiryTime,
1011                    550,
1012                    true,
1013                ),
1014                (
1015                    sys::AAC_METADATA_EXPIRY_TIME,
1016                    DecoderParameter::MetadataExpiryTime,
1017                    -1,
1018                    false,
1019                ),
1020                (
1021                    sys::AAC_DRC_HEAVY_COMPRESSION,
1022                    DecoderParameter::DrcHeavyCompression,
1023                    1,
1024                    true,
1025                ),
1026                (
1027                    sys::AAC_DRC_HEAVY_COMPRESSION,
1028                    DecoderParameter::DrcHeavyCompression,
1029                    2,
1030                    false,
1031                ),
1032                (
1033                    sys::AAC_DRC_DEFAULT_PRESENTATION_MODE,
1034                    DecoderParameter::DrcDefaultPresentationMode,
1035                    -1,
1036                    true,
1037                ),
1038                (
1039                    sys::AAC_DRC_DEFAULT_PRESENTATION_MODE,
1040                    DecoderParameter::DrcDefaultPresentationMode,
1041                    3,
1042                    false,
1043                ),
1044                (
1045                    sys::AAC_DRC_ENC_TARGET_LEVEL,
1046                    DecoderParameter::DrcEncoderTargetLevel,
1047                    127,
1048                    true,
1049                ),
1050                (
1051                    sys::AAC_DRC_ENC_TARGET_LEVEL,
1052                    DecoderParameter::DrcEncoderTargetLevel,
1053                    128,
1054                    false,
1055                ),
1056                (
1057                    sys::AAC_QMF_LOWPOWER,
1058                    DecoderParameter::QmfLowPower,
1059                    -1,
1060                    true,
1061                ),
1062                (
1063                    sys::AAC_QMF_LOWPOWER,
1064                    DecoderParameter::QmfLowPower,
1065                    2,
1066                    false,
1067                ),
1068            ] {
1069                let mut fdk = Decoder::open_raw_from_adts(header).unwrap();
1070                let mut pure = PureRustTransportDecoder::from_adts_header(header).unwrap();
1071                assert_eq!(
1072                    fdk.set_parameter(fdk_parameter, value).is_ok(),
1073                    accepted,
1074                    "FDK parameter {fdk_parameter:#x} value {value}"
1075                );
1076                assert_eq!(
1077                    pure.set_parameter(rust_parameter, value).is_ok(),
1078                    accepted,
1079                    "Rust parameter {rust_parameter:?} value {value}"
1080                );
1081            }
1082        }
1083
1084        #[test]
1085        fn fdk_and_pure_rust_er_aac_ld_nonzero_frame_have_matching_shape() {
1086            let (body, body_bits) = (0u16..=u16::MAX)
1087                .find_map(|candidate| {
1088                    let bytes = candidate.to_be_bytes();
1089                    let mut reader = BitReader::new(&bytes);
1090                    let tuple = decode_spectral_tuple(&mut reader, 1).ok()?;
1091                    tuple.iter().any(|&value| value != 0).then_some((
1092                        (candidate as u32) >> (16 - reader.bits_read()),
1093                        reader.bits_read(),
1094                    ))
1095                })
1096                .unwrap();
1097            let mut writer = BitWriter::new();
1098            writer.write(0, 4);
1099            writer.write(180, 8);
1100            writer.write_bool(false);
1101            writer.write(0, 2);
1102            writer.write_bool(false);
1103            writer.write(1, 6);
1104            writer.write_bool(false);
1105            writer.write(1, 4);
1106            writer.write(1, 5);
1107            writer.write_bool(false); // scalefactor delta zero
1108            writer.write_bool(false); // pulse
1109            writer.write_bool(false); // TNS
1110            writer.write_bool(false); // gain control
1111            writer.write(body, body_bits);
1112            let payload = writer.finish();
1113            let asc = AudioSpecificConfig {
1114                audio_object_type: 23,
1115                sampling_frequency_index: 4,
1116                sampling_frequency: 44_100,
1117                channel_configuration: 1,
1118                extension: None,
1119                ga_specific: Some(GaSpecificConfig::default()),
1120                eld_specific: None,
1121                usac_config: None,
1122                error_protection_config: Some(0),
1123                program_config: None,
1124                bits_read: 0,
1125            };
1126
1127            let mut config = asc.to_bytes().unwrap();
1128            let mut fdk = Decoder::open(TransportType::Raw).unwrap();
1129            fdk.configure_raw(&mut config).unwrap();
1130            let mut fdk_pcm = vec![0i16; 1024];
1131            let mut fdk_samples = 0;
1132            for _ in 0..6 {
1133                fdk_samples = fdk.decode_access_unit_i16(&payload, &mut fdk_pcm).unwrap();
1134            }
1135            fdk_pcm.truncate(fdk_samples);
1136
1137            let mut pure = AacLcDecoder::from_audio_specific_config(&asc).unwrap();
1138            let mut pure_pcm = Vec::new();
1139            for _ in 0..6 {
1140                pure_pcm = pure
1141                    .decode_raw_data_block_fixed_interleaved_i16(&payload)
1142                    .unwrap();
1143            }
1144            assert_eq!(fdk_pcm.len(), 512);
1145            assert_eq!(pure_pcm.len(), fdk_pcm.len());
1146            assert!(fdk_pcm.iter().any(|&sample| sample != 0));
1147            assert!(pure_pcm.iter().any(|&sample| sample != 0));
1148            let dot = fdk_pcm
1149                .iter()
1150                .zip(&pure_pcm)
1151                .map(|(&left, &right)| left as f64 * right as f64)
1152                .sum::<f64>();
1153            let fdk_energy = fdk_pcm
1154                .iter()
1155                .map(|&sample| (sample as f64).powi(2))
1156                .sum::<f64>();
1157            let pure_energy = pure_pcm
1158                .iter()
1159                .map(|&sample| (sample as f64).powi(2))
1160                .sum::<f64>();
1161            let correlation = dot / (fdk_energy * pure_energy).sqrt();
1162            assert!(correlation > 0.95, "LD synthesis correlation {correlation}");
1163            let rms_ratio = (pure_energy / fdk_energy).sqrt();
1164            assert!(
1165                (0.99..=1.01).contains(&rms_ratio),
1166                "LD synthesis RMS ratio {rms_ratio}"
1167            );
1168        }
1169
1170        #[test]
1171        fn fdk_and_pure_rust_er_aac_eld_nonzero_frame_have_matching_shape() {
1172            let (body, body_bits) = (0u16..=u16::MAX)
1173                .find_map(|candidate| {
1174                    let bytes = candidate.to_be_bytes();
1175                    let mut reader = BitReader::new(&bytes);
1176                    let tuple = decode_spectral_tuple(&mut reader, 1).ok()?;
1177                    tuple.iter().any(|&value| value != 0).then_some((
1178                        (candidate as u32) >> (16 - reader.bits_read()),
1179                        reader.bits_read(),
1180                    ))
1181                })
1182                .unwrap();
1183            let mut writer = BitWriter::new();
1184            writer.write(180, 8); // global_gain
1185            writer.write(1, 6); // implicit-long ELD max_sfb
1186            writer.write(1, 4); // codebook 1
1187            writer.write(1, 5); // one long section
1188            writer.write_bool(false); // scalefactor delta zero
1189            writer.write_bool(false); // TNS absent
1190            writer.write(body, body_bits);
1191            let payload = writer.finish();
1192            let asc = AudioSpecificConfig {
1193                audio_object_type: 39,
1194                sampling_frequency_index: 4,
1195                sampling_frequency: 44_100,
1196                channel_configuration: 1,
1197                extension: None,
1198                ga_specific: None,
1199                eld_specific: Some(EldSpecificConfig {
1200                    frame_length_flag: false,
1201                    section_data_resilience: false,
1202                    scalefactor_data_resilience: false,
1203                    spectral_data_resilience: false,
1204                    sbr_present: false,
1205                    sbr_sampling_rate: false,
1206                    sbr_crc: false,
1207                    sbr_headers: Vec::new(),
1208                    extensions: Vec::new(),
1209                }),
1210                usac_config: None,
1211                error_protection_config: Some(0),
1212                program_config: None,
1213                bits_read: 0,
1214            };
1215
1216            let mut config = asc.to_bytes().unwrap();
1217            let mut fdk = Decoder::open(TransportType::Raw).unwrap();
1218            fdk.configure_raw(&mut config).unwrap();
1219            let mut fdk_pcm = vec![0i16; 1024];
1220            let mut fdk_samples = 0;
1221            for _ in 0..6 {
1222                fdk_samples = fdk.decode_access_unit_i16(&payload, &mut fdk_pcm).unwrap();
1223            }
1224            fdk_pcm.truncate(fdk_samples);
1225
1226            let mut pure = AacLcDecoder::from_audio_specific_config(&asc).unwrap();
1227            let mut pure_pcm = Vec::new();
1228            for _ in 0..6 {
1229                pure_pcm = pure
1230                    .decode_raw_data_block_fixed_interleaved_i16(&payload)
1231                    .unwrap();
1232            }
1233            assert_eq!(fdk_pcm.len(), 512);
1234            assert_eq!(pure_pcm.len(), fdk_pcm.len());
1235            assert!(fdk_pcm.iter().any(|&sample| sample != 0));
1236            assert!(pure_pcm.iter().any(|&sample| sample != 0));
1237            let dot = fdk_pcm
1238                .iter()
1239                .zip(&pure_pcm)
1240                .map(|(&left, &right)| left as f64 * right as f64)
1241                .sum::<f64>();
1242            let fdk_energy = fdk_pcm
1243                .iter()
1244                .map(|&sample| (sample as f64).powi(2))
1245                .sum::<f64>();
1246            let pure_energy = pure_pcm
1247                .iter()
1248                .map(|&sample| (sample as f64).powi(2))
1249                .sum::<f64>();
1250            let correlation = dot / (fdk_energy * pure_energy).sqrt();
1251            assert!(
1252                correlation > 0.95,
1253                "ELD synthesis correlation {correlation}"
1254            );
1255            let rms_ratio = (pure_energy / fdk_energy).sqrt();
1256            assert!(
1257                (0.75..=1.25).contains(&rms_ratio),
1258                "ELD synthesis RMS ratio {rms_ratio}"
1259            );
1260        }
1261
1262        #[test]
1263        fn fdk_and_pure_rust_adts_stream_match_two_zero_cpe_frames() {
1264            let payload = zero_cpe_payload_for_parity();
1265            let header = adts::AdtsHeader::aac_lc(44_100, 2, payload.len()).unwrap();
1266            let mut frame = vec![0; header.header_len()];
1267            header.write(&mut frame).unwrap();
1268            frame.extend_from_slice(&payload);
1269            let mut stream = frame.clone();
1270            stream.extend_from_slice(&frame);
1271
1272            let mut fdk = Decoder::open(TransportType::Adts).unwrap();
1273            let mut fdk_frames = Vec::new();
1274            for parsed in adts::AdtsStream::new(&stream) {
1275                let parsed = parsed.unwrap();
1276                let mut pcm = vec![123i16; 4096];
1277                let samples = fdk.decode_access_unit_i16(parsed.bytes, &mut pcm).unwrap();
1278                pcm.truncate(samples);
1279                fdk_frames.push(pcm);
1280            }
1281
1282            let mut pure = AacLcDecoder::from_adts_header(header).unwrap();
1283            let pure_frames = pure
1284                .decode_adts_stream_multichannel_interleaved_i16(&stream)
1285                .collect::<Result<Vec<_>, _>>()
1286                .unwrap();
1287
1288            assert_eq!(fdk_frames.len(), 2);
1289            assert_eq!(fdk_frames, pure_frames);
1290            assert!(fdk_frames.iter().flatten().all(|sample| *sample == 0));
1291        }
1292
1293        #[test]
1294        fn fdk_and_pure_rust_match_zero_sce_mono_silence() {
1295            let payload = zero_sce_payload_for_parity(0);
1296            let header = adts::AdtsHeader::aac_lc(44_100, 1, payload.len()).unwrap();
1297            let frame = adts_frame_bytes(header, &payload);
1298
1299            let mut fdk = Decoder::open(TransportType::Adts).unwrap();
1300            let mut fdk_pcm = vec![123i16; 2048];
1301            let fdk_samples = fdk.decode_access_unit_i16(&frame, &mut fdk_pcm).unwrap();
1302            fdk_pcm.truncate(fdk_samples);
1303
1304            let mut pure = AacLcDecoder::from_adts_header(header).unwrap();
1305            let pure_pcm = pure.decode_adts_frame_interleaved_i16(&frame).unwrap();
1306
1307            assert_eq!(fdk_pcm, pure_pcm);
1308            assert!(fdk_pcm.iter().all(|sample| *sample == 0));
1309        }
1310
1311        #[test]
1312        fn fdk_and_pure_rust_match_zero_sce_with_inband_pce_channel_config_zero() {
1313            let payload = pce_plus_zero_sce_payload_for_parity();
1314            let header = adts::AdtsHeader::aac_lc(44_100, 0, payload.len()).unwrap();
1315            let frame = adts_frame_bytes(header, &payload);
1316
1317            let mut fdk = Decoder::open(TransportType::Adts).unwrap();
1318            let mut fdk_pcm = vec![123i16; 2048];
1319            let fdk_samples = fdk.decode_access_unit_i16(&frame, &mut fdk_pcm).unwrap();
1320            fdk_pcm.truncate(fdk_samples);
1321
1322            let mut pure = AacLcDecoder::from_adts_header(header).unwrap();
1323            let pure_pcm = pure
1324                .decode_adts_frame_multichannel_interleaved_i16(&frame)
1325                .unwrap();
1326
1327            assert_eq!(fdk_pcm, pure_pcm);
1328            assert!(fdk_pcm.iter().all(|sample| *sample == 0));
1329        }
1330
1331        #[test]
1332        fn fdk_and_pure_rust_match_zero_sce_with_zero_frequency_cce() {
1333            let payload = zero_sce_with_zero_frequency_cce_payload_for_parity();
1334            let header = adts::AdtsHeader::aac_lc(44_100, 1, payload.len()).unwrap();
1335            let frame = adts_frame_bytes(header, &payload);
1336
1337            let mut fdk = Decoder::open(TransportType::Adts).unwrap();
1338            let mut fdk_pcm = vec![123i16; 2048];
1339            let fdk_samples = fdk.decode_access_unit_i16(&frame, &mut fdk_pcm).unwrap();
1340            fdk_pcm.truncate(fdk_samples);
1341
1342            let mut pure = AacLcDecoder::from_adts_header(header).unwrap();
1343            let pure_pcm = pure
1344                .decode_adts_frame_multichannel_interleaved_i16(&frame)
1345                .unwrap();
1346
1347            assert_eq!(fdk_pcm, pure_pcm);
1348            assert!(fdk_pcm.iter().all(|sample| *sample == 0));
1349        }
1350
1351        #[test]
1352        fn fdk_and_pure_rust_accept_nonzero_pulse_sce_fixture() {
1353            let payload = pulse_sce_payload_for_parity_smoke();
1354            let header = adts::AdtsHeader::aac_lc(44_100, 1, payload.len()).unwrap();
1355            let frame = adts_frame_bytes(header, &payload);
1356
1357            let mut fdk = Decoder::open(TransportType::Adts).unwrap();
1358            let mut fdk_pcm = vec![0i16; 2048];
1359            let fdk_samples = fdk.decode_access_unit_i16(&frame, &mut fdk_pcm).unwrap();
1360            fdk_pcm.truncate(fdk_samples);
1361
1362            let mut pure = AacLcDecoder::from_adts_header(header).unwrap();
1363            let pure_pcm = pure.decode_adts_frame_interleaved_i16(&frame).unwrap();
1364
1365            assert_eq!(fdk_pcm.len(), pure_pcm.len());
1366            assert!(pure_pcm.iter().any(|sample| *sample != 0));
1367            let report = pcm_delta_report(&fdk_pcm, &pure_pcm);
1368            assert_eq!(report.samples, pure_pcm.len());
1369            assert!(report.max_abs_delta > 0);
1370        }
1371
1372        #[test]
1373        fn fdk_and_pure_rust_apply_legacy_one_band_normalization_equally() {
1374            let mut encoder = PureRustAacLcMonoEncoder::new(4, 32_000, 16_000).unwrap();
1375            let input: Vec<_> = (0..1024)
1376                .map(|index| (index as f32 * 2.0 * std::f32::consts::PI / 31.0).sin() * 2_000.0)
1377                .collect();
1378            let plain = encoder.encode_raw_data_block(&input).unwrap();
1379            let normalized = insert_legacy_drc_before_end(&plain, 88);
1380            let decode_fdk = |payload: &[u8]| {
1381                let header = adts::AdtsHeader::aac_lc(44_100, 1, 0).unwrap();
1382                let mut decoder = Decoder::open_raw_from_adts(header).unwrap();
1383                decoder
1384                    .set_parameter(sys::AAC_PCM_LIMITER_ENABLE, 0)
1385                    .unwrap();
1386                decoder.set_parameter(sys::AAC_CONCEAL_METHOD, 1).unwrap();
1387                let mut pcm = vec![0i16; 2048];
1388                decoder.decode_access_unit_i16(payload, &mut pcm).unwrap();
1389                decoder.decode_access_unit_i16(&plain, &mut pcm).unwrap();
1390                let samples = decoder.decode_access_unit_i16(&plain, &mut pcm).unwrap();
1391                pcm.truncate(samples);
1392                pcm
1393            };
1394            let decode_pure = |payload: &[u8]| {
1395                let mut decoder = AacLcDecoder::new(4, 1).unwrap();
1396                decoder
1397                    .decode_raw_data_block_multichannel_fixed_interleaved_i16(payload)
1398                    .unwrap();
1399                decoder
1400                    .decode_raw_data_block_multichannel_fixed_interleaved_i16(&plain)
1401                    .unwrap();
1402                decoder
1403                    .decode_raw_data_block_multichannel_fixed_interleaved_i16(&plain)
1404                    .unwrap()
1405            };
1406            let rms = |samples: &[i16]| {
1407                (samples
1408                    .iter()
1409                    .map(|sample| f64::from(*sample).powi(2))
1410                    .sum::<f64>()
1411                    / samples.len() as f64)
1412                    .sqrt()
1413            };
1414            let fdk_ratio = rms(&decode_fdk(&normalized)) / rms(&decode_fdk(&plain));
1415            let pure_ratio = rms(&decode_pure(&normalized)) / rms(&decode_pure(&plain));
1416            let expected = 2.0f64.powf(-8.0 / 24.0); // -24 dB target vs -22 dB program
1417                                                     // FDK delays normalization by one AAC frame and smooths the step,
1418                                                     // so this frame lies between the old and requested gains.
1419            assert!(
1420                (expected..1.0).contains(&fdk_ratio),
1421                "FDK ratio {fdk_ratio}"
1422            );
1423            assert!(
1424                (expected..1.0).contains(&pure_ratio),
1425                "Rust ratio {pure_ratio}"
1426            );
1427            assert!(
1428                (fdk_ratio - pure_ratio).abs() < 0.01,
1429                "FDK ratio {fdk_ratio}, Rust ratio {pure_ratio}"
1430            );
1431        }
1432
1433        #[test]
1434        fn fdk_and_pure_rust_report_legacy_output_loudness_equally() {
1435            let mut encoder = PureRustAacLcMonoEncoder::new(4, 32_000, 16_000).unwrap();
1436            let plain = encoder.encode_raw_data_block(&vec![0.0; 1024]).unwrap();
1437            let metadata = insert_legacy_drc_before_end(&plain, 88);
1438            let header = adts::AdtsHeader::aac_lc(44_100, 1, 0).unwrap();
1439            let mut fdk = Decoder::open_raw_from_adts(header).unwrap();
1440            let mut pure = AacLcDecoder::new(4, 1).unwrap();
1441            let mut pcm = vec![0i16; 2048];
1442
1443            assert_eq!(fdk.stream_info().unwrap().output_loudness, -1);
1444            assert_eq!(pure.stream_info().output_loudness, -1);
1445            for payload in [&metadata[..], &plain[..], &plain[..]] {
1446                fdk.decode_access_unit_i16(payload, &mut pcm).unwrap();
1447                pure.decode_raw_data_block_multichannel_fixed_interleaved_i16(payload)
1448                    .unwrap();
1449            }
1450            let fdk_info = fdk.stream_info().unwrap();
1451            let pure_info = pure.stream_info();
1452            assert_eq!(fdk_info.drc_program_reference_level, 88);
1453            assert_eq!(pure_info.drc_program_reference_level, 88);
1454            assert_eq!(fdk_info.output_loudness, 96);
1455            assert_eq!(pure_info.output_loudness, 96);
1456
1457            fdk.set_parameter(sys::AAC_DRC_REFERENCE_LEVEL, -1).unwrap();
1458            pure.set_drc_reference_level(None);
1459            fdk.decode_access_unit_i16(&plain, &mut pcm).unwrap();
1460            pure.decode_raw_data_block_multichannel_fixed_interleaved_i16(&plain)
1461                .unwrap();
1462            assert_eq!(fdk.stream_info().unwrap().output_loudness, 88);
1463            assert_eq!(pure.stream_info().output_loudness, 88);
1464        }
1465
1466        #[test]
1467        fn fdk_and_pure_rust_report_dvb_presentation_modes_equally() {
1468            let mut encoder = PureRustAacLcMonoEncoder::new(4, 32_000, 16_000).unwrap();
1469            let plain = encoder.encode_raw_data_block(&vec![0.0; 1024]).unwrap();
1470            let header = adts::AdtsHeader::aac_lc(44_100, 1, 0).unwrap();
1471
1472            for mode in 0..=2 {
1473                let payload = insert_dvb_ancillary_drc_before_end(&plain, mode, 0x90);
1474                let mut fdk = Decoder::open_raw_from_adts(header).unwrap();
1475                let mut pure = AacLcDecoder::new(4, 1).unwrap();
1476                let mut pcm = vec![0i16; 2048];
1477                fdk.set_parameter(sys::AAC_DRC_DEFAULT_PRESENTATION_MODE, 1)
1478                    .unwrap();
1479                pure.set_drc_default_presentation_mode(1);
1480                assert_eq!(fdk.stream_info().unwrap().drc_presentation_mode, -1);
1481                assert_eq!(pure.stream_info().drc_presentation_mode, -1);
1482
1483                for access_unit in [&payload[..], &plain[..]] {
1484                    fdk.decode_access_unit_i16(access_unit, &mut pcm).unwrap();
1485                    pure.decode_raw_data_block_multichannel_fixed_interleaved_i16(access_unit)
1486                        .unwrap();
1487                }
1488                assert_eq!(fdk.stream_info().unwrap().drc_presentation_mode, mode as i8);
1489                assert_eq!(pure.stream_info().drc_presentation_mode, mode as i8);
1490            }
1491        }
1492
1493        #[test]
1494        fn fdk_and_pure_rust_apply_legacy_multiband_spectral_drc_equally() {
1495            let mut encoder = PureRustAacLcMonoEncoder::new(4, 32_000, 16_000).unwrap();
1496            let input: Vec<_> = (0..1024)
1497                .map(|index| (index as f32 * 2.0 * std::f32::consts::PI / 31.0).sin() * 2_000.0)
1498                .collect();
1499            let plain = encoder.encode_raw_data_block(&input).unwrap();
1500            let compressed = insert_legacy_multiband_drc_before_end(&plain);
1501            let decode_fdk = |payload: &[u8]| {
1502                let header = adts::AdtsHeader::aac_lc(44_100, 1, 0).unwrap();
1503                let mut decoder = Decoder::open_raw_from_adts(header).unwrap();
1504                decoder
1505                    .set_parameter(sys::AAC_PCM_LIMITER_ENABLE, 0)
1506                    .unwrap();
1507                decoder.set_parameter(sys::AAC_CONCEAL_METHOD, 1).unwrap();
1508                decoder
1509                    .set_parameter(sys::AAC_DRC_ATTENUATION_FACTOR, 127)
1510                    .unwrap();
1511                let mut pcm = vec![0i16; 2048];
1512                let samples = decoder.decode_access_unit_i16(payload, &mut pcm).unwrap();
1513                pcm.truncate(samples);
1514                pcm
1515            };
1516            let decode_pure = |payload: &[u8]| {
1517                let mut decoder = AacLcDecoder::new(4, 1).unwrap();
1518                decoder.set_drc_attenuation_factor(127);
1519                decoder
1520                    .decode_raw_data_block_multichannel_fixed_interleaved_i16(payload)
1521                    .unwrap()
1522            };
1523            let decode_pure_f32 = |payload: &[u8]| {
1524                let mut decoder = AacLcDecoder::new(4, 1).unwrap();
1525                decoder.set_drc_attenuation_factor(127);
1526                decoder
1527                    .decode_raw_data_block_multichannel_f32(payload)
1528                    .unwrap()
1529                    .interleaved_f32()
1530            };
1531            let rms = |samples: &[i16]| {
1532                (samples
1533                    .iter()
1534                    .map(|sample| f64::from(*sample).powi(2))
1535                    .sum::<f64>()
1536                    / samples.len() as f64)
1537                    .sqrt()
1538            };
1539            let fdk_ratio = rms(&decode_fdk(&compressed)) / rms(&decode_fdk(&plain));
1540            let pure_ratio = rms(&decode_pure(&compressed)) / rms(&decode_pure(&plain));
1541            let rms_f32 = |samples: &[f32]| {
1542                (samples
1543                    .iter()
1544                    .map(|sample| f64::from(*sample).powi(2))
1545                    .sum::<f64>()
1546                    / samples.len() as f64)
1547                    .sqrt()
1548            };
1549            let pure_f32_ratio =
1550                rms_f32(&decode_pure_f32(&compressed)) / rms_f32(&decode_pure_f32(&plain));
1551            assert!((0.45..0.65).contains(&fdk_ratio), "FDK ratio {fdk_ratio}");
1552            assert!(
1553                (fdk_ratio - pure_ratio).abs() < 0.03,
1554                "FDK ratio {fdk_ratio}, Rust ratio {pure_ratio}, Rust f32 ratio {pure_f32_ratio}"
1555            );
1556        }
1557
1558        #[test]
1559        fn fdk_and_pure_rust_apply_dvb_ancillary_heavy_compression_equally() {
1560            let mut encoder = PureRustAacLcMonoEncoder::new(4, 32_000, 16_000).unwrap();
1561            let input: Vec<_> = (0..1024)
1562                .map(|index| (index as f32 * 2.0 * std::f32::consts::PI / 31.0).sin() * 2_000.0)
1563                .collect();
1564            let plain = encoder.encode_raw_data_block(&input).unwrap();
1565            let compressed = insert_dvb_ancillary_drc_before_end(&plain, 0, 0x90);
1566            let decode_fdk = |payload: &[u8]| {
1567                let header = adts::AdtsHeader::aac_lc(44_100, 1, 0).unwrap();
1568                let mut decoder = Decoder::open_raw_from_adts(header).unwrap();
1569                decoder
1570                    .set_parameter(sys::AAC_PCM_LIMITER_ENABLE, 0)
1571                    .unwrap();
1572                decoder.set_parameter(sys::AAC_CONCEAL_METHOD, 1).unwrap();
1573                decoder
1574                    .set_parameter(sys::AAC_DRC_HEAVY_COMPRESSION, 1)
1575                    .unwrap();
1576                let mut pcm = vec![0i16; 2048];
1577                decoder.decode_access_unit_i16(&plain, &mut pcm).unwrap();
1578                decoder.decode_access_unit_i16(payload, &mut pcm).unwrap();
1579                let samples = decoder.decode_access_unit_i16(payload, &mut pcm).unwrap();
1580                pcm.truncate(samples);
1581                pcm
1582            };
1583            let decode_pure = |payload: &[u8]| {
1584                let mut decoder = AacLcDecoder::new(4, 1).unwrap();
1585                decoder.set_drc_heavy_compression(true);
1586                decoder
1587                    .decode_raw_data_block_multichannel_fixed_interleaved_i16(&plain)
1588                    .unwrap();
1589                decoder
1590                    .decode_raw_data_block_multichannel_fixed_interleaved_i16(payload)
1591                    .unwrap();
1592                decoder
1593                    .decode_raw_data_block_multichannel_fixed_interleaved_i16(payload)
1594                    .unwrap()
1595            };
1596            let rms = |samples: &[i16]| {
1597                (samples
1598                    .iter()
1599                    .map(|sample| f64::from(*sample).powi(2))
1600                    .sum::<f64>()
1601                    / samples.len() as f64)
1602                    .sqrt()
1603            };
1604            let fdk_ratio = rms(&decode_fdk(&compressed)) / rms(&decode_fdk(&plain));
1605            let pure_ratio = rms(&decode_pure(&compressed)) / rms(&decode_pure(&plain));
1606            assert!((0.45..0.55).contains(&fdk_ratio), "FDK ratio {fdk_ratio}");
1607            assert!(
1608                (fdk_ratio - pure_ratio).abs() < 0.03,
1609                "FDK ratio {fdk_ratio}, Rust ratio {pure_ratio}"
1610            );
1611        }
1612
1613        #[derive(Debug, Clone, Copy, PartialEq, Eq)]
1614        struct PcmDeltaReport {
1615            samples: usize,
1616            max_abs_delta: i32,
1617            sum_abs_delta: i64,
1618        }
1619
1620        fn pcm_delta_report(left: &[i16], right: &[i16]) -> PcmDeltaReport {
1621            let samples = left.len().min(right.len());
1622            let mut max_abs_delta = 0i32;
1623            let mut sum_abs_delta = 0i64;
1624            for index in 0..samples {
1625                let delta = (left[index] as i32 - right[index] as i32).abs();
1626                max_abs_delta = max_abs_delta.max(delta);
1627                sum_abs_delta += delta as i64;
1628            }
1629            PcmDeltaReport {
1630                samples,
1631                max_abs_delta,
1632                sum_abs_delta,
1633            }
1634        }
1635
1636        fn zero_cpe_payload_for_parity() -> Vec<u8> {
1637            let mut writer = BitWriter::new();
1638            writer.write(ElementId::ChannelPair.bits() as u32, 3);
1639            writer.write(0, 4); // element_instance_tag
1640            writer.write_bool(true); // common_window
1641            write_shared_long_ics(&mut writer, 1);
1642            writer.write(0, 2); // ms_mask_present none
1643            write_zero_channel_stream(&mut writer, 1);
1644            write_zero_channel_stream(&mut writer, 1);
1645            writer.write(ElementId::End.bits() as u32, 3);
1646            writer.finish()
1647        }
1648
1649        fn zero_sce_payload_for_parity(tag: u8) -> Vec<u8> {
1650            let mut writer = BitWriter::new();
1651            write_zero_sce_payload_bits(&mut writer, tag);
1652            writer.write(ElementId::End.bits() as u32, 3);
1653            writer.finish()
1654        }
1655
1656        fn pce_plus_zero_sce_payload_for_parity() -> Vec<u8> {
1657            let pce = ProgramConfig {
1658                element_instance_tag: 0,
1659                profile: 1,
1660                sampling_frequency_index: 4,
1661                front: vec![ProgramElement {
1662                    is_cpe: false,
1663                    tag_select: 0,
1664                }],
1665                num_channels: 1,
1666                num_effective_channels: 1,
1667                ..ProgramConfig::default()
1668            };
1669            let mut writer = BitWriter::new();
1670            writer.write(ElementId::ProgramConfig.bits() as u32, 3);
1671            pce.write_to_writer(&mut writer).unwrap();
1672            write_zero_sce_payload_bits(&mut writer, 0);
1673            writer.write(ElementId::End.bits() as u32, 3);
1674            writer.finish()
1675        }
1676
1677        fn zero_sce_with_zero_frequency_cce_payload_for_parity() -> Vec<u8> {
1678            let mut writer = BitWriter::new();
1679            write_zero_sce_payload_bits(&mut writer, 0);
1680            writer.write(ElementId::CouplingChannel.bits() as u32, 3);
1681            writer.write(0, 4); // cce element_instance_tag
1682            writer.write_bool(false); // ind_sw_cce_flag
1683            writer.write(0, 3); // one coupled element
1684            writer.write_bool(false); // target SCE
1685            writer.write(0, 4); // target tag
1686            writer.write_bool(true); // frequency domain
1687            writer.write_bool(false); // gain_element_sign
1688            writer.write(0, 2); // gain_element_scale
1689            write_zero_independent_channel_stream(&mut writer, 1);
1690            writer.write(ElementId::End.bits() as u32, 3);
1691            writer.finish()
1692        }
1693
1694        fn pulse_sce_payload_for_parity_smoke() -> Vec<u8> {
1695            let mut writer = BitWriter::new();
1696            writer.write(ElementId::SingleChannel.bits() as u32, 3);
1697            writer.write(0, 4); // element_instance_tag
1698            writer.write(100, 8); // global_gain
1699            write_shared_long_ics(&mut writer, 1);
1700            writer.write(ZERO_HCB as u32, 4);
1701            writer.write(1, 5);
1702            writer.write_bool(true); // pulse_data_present
1703            writer.write(0, 2); // number_pulse = one pulse
1704            writer.write(0, 6); // pulse_start_sfb
1705            writer.write(0, 5); // pulse_offset at first line
1706            writer.write(8, 4); // pulse_amp
1707            writer.write_bool(false); // tns_data_present
1708            writer.write_bool(false); // gain_control_data_present
1709            writer.write(ElementId::End.bits() as u32, 3);
1710            writer.finish()
1711        }
1712
1713        fn insert_legacy_drc_before_end(raw: &[u8], program_reference_level: u8) -> Vec<u8> {
1714            let mut position = BitReader::new(raw);
1715            AacLcDecoder::new(4, 1)
1716                .unwrap()
1717                .decode_raw_data_block_multichannel_f32_from_reader(&mut position)
1718                .unwrap();
1719            let end_bit = position.bits_read();
1720            let mut source = BitReader::new(raw);
1721            let mut writer = BitWriter::new();
1722            for _ in 0..end_bit {
1723                writer.write_bool(source.read_bool().unwrap());
1724            }
1725            writer.write(ElementId::Fill.bits() as u32, 3);
1726            writer.write(3, 4);
1727            writer.write(0x0b, 4); // EXT_DYNAMIC_RANGE
1728            writer.write_bool(false); // PCE tag absent
1729            writer.write_bool(false); // excluded channels absent
1730            writer.write_bool(false); // one band
1731            writer.write_bool(true);
1732            writer.write(program_reference_level as u32, 7);
1733            writer.write_bool(false);
1734            writer.write(0, 8); // normalization only
1735            writer.write(ElementId::End.bits() as u32, 3);
1736            writer.byte_align();
1737            writer.finish()
1738        }
1739
1740        fn insert_legacy_multiband_drc_before_end(raw: &[u8]) -> Vec<u8> {
1741            let mut position = BitReader::new(raw);
1742            AacLcDecoder::new(4, 1)
1743                .unwrap()
1744                .decode_raw_data_block_multichannel_f32_from_reader(&mut position)
1745                .unwrap();
1746            let mut source = BitReader::new(raw);
1747            let mut writer = BitWriter::new();
1748            for _ in 0..position.bits_read() {
1749                writer.write_bool(source.read_bool().unwrap());
1750            }
1751            writer.write(ElementId::Fill.bits() as u32, 3);
1752            writer.write(6, 4);
1753            writer.write(0x0b, 4); // EXT_DYNAMIC_RANGE
1754            writer.write_bool(false); // PCE tag absent
1755            writer.write_bool(false); // excluded channels absent
1756            writer.write_bool(true); // DRC bands present
1757            writer.write(1, 4); // two bands
1758            writer.write(0, 4); // interpolation scheme
1759            writer.write(31, 8); // bins 0..127
1760            writer.write(255, 8); // bins 128..1023
1761            writer.write_bool(false); // program reference absent
1762            writer.write(0x98, 8); // -6.02 dB in the low band
1763            writer.write(0, 8); // unity in the remaining spectrum
1764            writer.write(ElementId::End.bits() as u32, 3);
1765            writer.byte_align();
1766            writer.finish()
1767        }
1768
1769        fn insert_dvb_ancillary_drc_before_end(
1770            raw: &[u8],
1771            presentation_mode: u8,
1772            compression_value: u8,
1773        ) -> Vec<u8> {
1774            let mut position = BitReader::new(raw);
1775            AacLcDecoder::new(4, 1)
1776                .unwrap()
1777                .decode_raw_data_block_multichannel_f32_from_reader(&mut position)
1778                .unwrap();
1779            let mut source = BitReader::new(raw);
1780            let mut writer = BitWriter::new();
1781            writer.write(ElementId::DataStream.bits() as u32, 3);
1782            writer.write(0, 4); // element_instance_tag
1783            writer.write_bool(true); // data_byte_align_flag
1784            writer.write(5, 8);
1785            writer.byte_align();
1786            writer.write(0xbc, 8); // DVB ancillary sync
1787            writer.write((0xc0 | ((presentation_mode & 3) << 2)) as u32, 8);
1788            writer.write(0x04, 8); // compression field present
1789            writer.write(0x01, 8); // reserved audio mode 0, compression on
1790            writer.write(compression_value as u32, 8);
1791            for _ in 0..position.bits_read() {
1792                writer.write_bool(source.read_bool().unwrap());
1793            }
1794            writer.write(ElementId::End.bits() as u32, 3);
1795            writer.byte_align();
1796            writer.finish()
1797        }
1798
1799        fn adts_frame_bytes(header: adts::AdtsHeader, payload: &[u8]) -> Vec<u8> {
1800            let mut frame = vec![0; header.header_len()];
1801            header.write(&mut frame).unwrap();
1802            frame.extend_from_slice(payload);
1803            frame
1804        }
1805
1806        fn write_zero_sce_payload_bits(writer: &mut BitWriter, tag: u8) {
1807            writer.write(ElementId::SingleChannel.bits() as u32, 3);
1808            writer.write(tag as u32, 4);
1809            writer.write(100, 8); // global_gain
1810            write_shared_long_ics(writer, 1);
1811            writer.write(ZERO_HCB as u32, 4);
1812            writer.write(1, 5);
1813            writer.write_bool(false); // pulse_data_present
1814            writer.write_bool(false); // tns_data_present
1815            writer.write_bool(false); // gain_control_data_present
1816        }
1817
1818        fn write_shared_long_ics(writer: &mut BitWriter, max_sfb: u8) {
1819            writer.write_bool(false); // reserved
1820            writer.write(0, 2); // ONLY_LONG_SEQUENCE
1821            writer.write_bool(false); // sine
1822            writer.write(max_sfb as u32, 6);
1823            writer.write_bool(false); // predictor_data_present
1824        }
1825
1826        fn write_zero_channel_stream(writer: &mut BitWriter, max_sfb: u8) {
1827            writer.write(100, 8); // global_gain
1828            writer.write(ZERO_HCB as u32, 4);
1829            writer.write(max_sfb as u32, 5);
1830            writer.write_bool(false); // pulse_data_present
1831            writer.write_bool(false); // tns_data_present
1832            writer.write_bool(false); // gain_control_data_present
1833        }
1834
1835        fn write_zero_independent_channel_stream(writer: &mut BitWriter, max_sfb: u8) {
1836            writer.write(100, 8); // global_gain
1837            write_shared_long_ics(writer, max_sfb);
1838            writer.write(ZERO_HCB as u32, 4);
1839            writer.write(max_sfb as u32, 5);
1840            writer.write_bool(false); // pulse_data_present
1841            writer.write_bool(false); // tns_data_present
1842            writer.write_bool(false); // gain_control_data_present
1843        }
1844    }
1845}
1846
1847#[cfg(feature = "ffi")]
1848pub use ffi::*;