1#![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 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 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); writer.write_bool(false); writer.write_bool(false); writer.write_bool(false); 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); writer.write(1, 6); writer.write(1, 4); writer.write(1, 5); writer.write_bool(false); writer.write_bool(false); 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); 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); writer.write_bool(true); write_shared_long_ics(&mut writer, 1);
1642 writer.write(0, 2); 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); writer.write_bool(false); writer.write(0, 3); writer.write_bool(false); writer.write(0, 4); writer.write_bool(true); writer.write_bool(false); writer.write(0, 2); 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); writer.write(100, 8); 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); writer.write(0, 2); writer.write(0, 6); writer.write(0, 5); writer.write(8, 4); writer.write_bool(false); writer.write_bool(false); 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); writer.write_bool(false); writer.write_bool(false); writer.write_bool(false); writer.write_bool(true);
1732 writer.write(program_reference_level as u32, 7);
1733 writer.write_bool(false);
1734 writer.write(0, 8); 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); writer.write_bool(false); writer.write_bool(false); writer.write_bool(true); writer.write(1, 4); writer.write(0, 4); writer.write(31, 8); writer.write(255, 8); writer.write_bool(false); writer.write(0x98, 8); writer.write(0, 8); 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); writer.write_bool(true); writer.write(5, 8);
1785 writer.byte_align();
1786 writer.write(0xbc, 8); writer.write((0xc0 | ((presentation_mode & 3) << 2)) as u32, 8);
1788 writer.write(0x04, 8); writer.write(0x01, 8); 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); write_shared_long_ics(writer, 1);
1811 writer.write(ZERO_HCB as u32, 4);
1812 writer.write(1, 5);
1813 writer.write_bool(false); writer.write_bool(false); writer.write_bool(false); }
1817
1818 fn write_shared_long_ics(writer: &mut BitWriter, max_sfb: u8) {
1819 writer.write_bool(false); writer.write(0, 2); writer.write_bool(false); writer.write(max_sfb as u32, 6);
1823 writer.write_bool(false); }
1825
1826 fn write_zero_channel_stream(writer: &mut BitWriter, max_sfb: u8) {
1827 writer.write(100, 8); writer.write(ZERO_HCB as u32, 4);
1829 writer.write(max_sfb as u32, 5);
1830 writer.write_bool(false); writer.write_bool(false); writer.write_bool(false); }
1834
1835 fn write_zero_independent_channel_stream(writer: &mut BitWriter, max_sfb: u8) {
1836 writer.write(100, 8); 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); writer.write_bool(false); writer.write_bool(false); }
1844 }
1845}
1846
1847#[cfg(feature = "ffi")]
1848pub use ffi::*;