1 use nihav_core::formats::*;
2 use nihav_core::frame::*;
3 use nihav_core::codecs::*;
4 use nihav_codec_support::dsp::mdct::IMDCT;
5 use nihav_codec_support::dsp::window::*;
6 use nihav_core::io::bitreader::*;
7 use nihav_core::io::byteio::*;
14 #[allow(clippy::excessive_precision)]
20 const MAX_WINDOWS: usize = 8;
21 const MAX_SFBS: usize = 64;
26 prev_window_sequence: u8,
28 prev_window_shape: bool,
29 scale_factor_grouping: [bool; MAX_WINDOWS],
30 group_start: [usize; MAX_WINDOWS],
34 predictor_data: Option<LTPData>,
38 const ONLY_LONG_SEQUENCE: u8 = 0;
39 const LONG_START_SEQUENCE: u8 = 1;
40 const EIGHT_SHORT_SEQUENCE: u8 = 2;
41 const LONG_STOP_SEQUENCE: u8 = 3;
47 prev_window_sequence: 0,
49 prev_window_shape: false,
50 scale_factor_grouping: [false; MAX_WINDOWS],
51 group_start: [0; MAX_WINDOWS],
59 fn decode_ics_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
60 self.prev_window_sequence = self.window_sequence;
61 self.prev_window_shape = self.window_shape;
62 let ics_reserved_bit = br.read(1)?;
63 validate!(ics_reserved_bit == 0);
64 self.window_sequence = br.read(2)? as u8;
65 match self.prev_window_sequence {
66 ONLY_LONG_SEQUENCE | LONG_STOP_SEQUENCE => {
67 if (self.window_sequence != ONLY_LONG_SEQUENCE) &&
68 (self.window_sequence != LONG_START_SEQUENCE) {
69 println!("incorrect previous window");
72 LONG_START_SEQUENCE | EIGHT_SHORT_SEQUENCE => {
73 if (self.window_sequence != EIGHT_SHORT_SEQUENCE) &&
74 (self.window_sequence != LONG_STOP_SEQUENCE) {
75 println!("incorrect previous window");
80 self.window_shape = br.read_bool()?;
81 self.window_groups = 1;
82 if self.window_sequence == EIGHT_SHORT_SEQUENCE {
83 self.long_win = false;
85 self.max_sfb = br.read(4)? as usize;
86 for i in 0..MAX_WINDOWS-1 {
87 self.scale_factor_grouping[i] = br.read_bool()?;
88 if !self.scale_factor_grouping[i] {
89 self.group_start[self.window_groups] = i + 1;
90 self.window_groups += 1;
96 self.max_sfb = br.read(6)? as usize;
97 self.predictor_data = LTPData::read(br)?;
101 fn get_group_start(&self, g: usize) -> usize {
104 } else if g >= self.window_groups {
105 if self.long_win { 1 } else { 8 }
116 pulse_data: Option<PulseData>,
117 tns_data: Option<TNSData>,
118 gain_control: Option<GainControlData>,
119 sect_cb: [[u8; MAX_SFBS]; MAX_WINDOWS],
120 sect_len: [[usize; MAX_SFBS]; MAX_WINDOWS],
121 sfb_cb: [[u8; MAX_SFBS]; MAX_WINDOWS],
122 num_sec: [usize; MAX_WINDOWS],
123 scales: [[u8; MAX_SFBS]; MAX_WINDOWS],
124 sbinfo: GASubbandInfo,
129 const INTENSITY_SCALE_MIN: i16 = -155;
131 fn new(sbinfo: GASubbandInfo) -> Self {
134 info: ICSInfo::new(),
138 sect_cb: [[0; MAX_SFBS]; MAX_WINDOWS],
139 sect_len: [[0; MAX_SFBS]; MAX_WINDOWS],
140 sfb_cb: [[0; MAX_SFBS]; MAX_WINDOWS],
141 scales: [[0; MAX_SFBS]; MAX_WINDOWS],
142 num_sec: [0; MAX_WINDOWS],
148 fn decode_section_data(&mut self, br: &mut BitReader, may_have_intensity: bool) -> DecoderResult<()> {
149 let sect_bits = if self.info.long_win { 5 } else { 3 };
150 let sect_esc_val = (1 << sect_bits) - 1;
152 for g in 0..self.info.window_groups {
155 while k < self.info.max_sfb {
156 self.sect_cb[g][l] = br.read(4)? as u8;
157 self.sect_len[g][l] = 0;
158 validate!(self.sect_cb[g][l] != RESERVED_HCB);
159 if ((self.sect_cb[g][l] == INTENSITY_HCB) || (self.sect_cb[g][l] == INTENSITY_HCB2)) && !may_have_intensity {
160 return Err(DecoderError::InvalidData);
163 let sect_len_incr = br.read(sect_bits)? as usize;
164 self.sect_len[g][l] += sect_len_incr;
165 if sect_len_incr < sect_esc_val { break; }
167 validate!(k + self.sect_len[g][l] <= self.info.max_sfb);
168 for _ in 0..self.sect_len[g][l] {
169 self.sfb_cb[g][k] = self.sect_cb[g][l];
178 fn is_intensity(&self, g: usize, sfb: usize) -> bool {
179 (self.sfb_cb[g][sfb] == INTENSITY_HCB) || (self.sfb_cb[g][sfb] == INTENSITY_HCB2)
181 fn get_intensity_dir(&self, g: usize, sfb: usize) -> bool {
182 self.sfb_cb[g][sfb] == INTENSITY_HCB
184 fn decode_scale_factor_data(&mut self, br: &mut BitReader, codebooks: &Codebooks) -> DecoderResult<()> {
185 decode_scale_factor_data(br, &mut self.scales, self.global_gain, &self.info, &self.sfb_cb, codebooks)
187 fn get_band_start(&self, swb: usize) -> usize {
188 if self.info.long_win {
189 self.sbinfo.long_bands[swb]
191 self.sbinfo.short_bands[swb]
194 fn get_num_bands(&self) -> usize {
195 if self.info.long_win {
196 self.sbinfo.long_bands.len() - 1
198 self.sbinfo.short_bands.len() - 1
201 fn decode_spectrum(&mut self, br: &mut BitReader, codebooks: &Codebooks) -> DecoderResult<()> {
202 self.coeffs = [0.0; 1024];
203 decode_spectrum(br, &mut self.coeffs, &self.scales, &self.info, &self.sbinfo, &self.sfb_cb, codebooks)
205 fn iquant(val: f32) -> f32 {
207 -((-val).powf(4.0 / 3.0))
212 fn place_pulses(&mut self) {
213 if let Some(ref pdata) = self.pulse_data {
214 if pdata.pulse_start_sfb >= self.sbinfo.long_bands.len() - 1 { return; }
215 let mut k = self.get_band_start(pdata.pulse_start_sfb);
216 let mut band = pdata.pulse_start_sfb;
217 for pno in 0..pdata.number_pulse {
218 k += pdata.pulse_offset[pno] as usize;
219 if k >= 1024 { return; }
220 while self.get_band_start(band + 1) <= k { band += 1; }
221 let scale = get_scale(self.scales[0][band]);
222 let mut base = self.coeffs[k];
224 base = requant(self.coeffs[k], scale);
227 base += f32::from(pdata.pulse_amp[pno]);
229 base -= f32::from(pdata.pulse_amp[pno]);
231 self.coeffs[k] = Self::iquant(base) * scale;
235 fn decode_ics(&mut self, br: &mut BitReader, codebooks: &Codebooks, m4atype: M4AType, common_window: bool, may_have_intensity: bool) -> DecoderResult<()> {
236 self.global_gain = br.read(8)? as u8;
238 self.info.decode_ics_info(br)?;
240 self.decode_section_data(br, may_have_intensity)?;
241 self.decode_scale_factor_data(br, codebooks)?;
242 self.pulse_data = PulseData::read(br)?;
243 validate!(self.pulse_data.is_none() || self.info.long_win);
245 if !self.info.long_win {
247 } else if m4atype == M4AType::LC {
250 tns_max_order = TNS_MAX_ORDER;
252 self.tns_data = TNSData::read(br, self.info.long_win, self.info.num_windows, tns_max_order)?;
253 if m4atype == M4AType::SSR {
254 self.gain_control = GainControlData::read(br)?;
256 let gain_control_data_present = br.read_bool()?;
257 validate!(!gain_control_data_present);
259 self.decode_spectrum(br, codebooks)?;
262 fn synth_channel(&mut self, dsp: &mut DSP, dst: &mut [f32], srate_idx: usize) {
264 if let Some(ref tns_data) = self.tns_data {
265 let tns_max_bands = TNSData::get_max_bands(self.info.long_win, srate_idx).min(self.info.max_sfb);
266 for w in 0..self.info.num_windows {
267 let mut bottom = self.get_num_bands();
268 for f in 0..tns_data.n_filt[w] {
270 bottom = if top >= tns_data.coeffs[w][f].length { top - tns_data.coeffs[w][f].length } else { 0 };
271 let order = tns_data.coeffs[w][f].order;
272 if order == 0 { continue; }
273 let start = w * 128 + self.get_band_start(tns_max_bands.min(bottom));
274 let end = w * 128 + self.get_band_start(tns_max_bands.min(top));
275 tns_data.apply(&mut self.coeffs, w, f, start, end);
279 dsp.synth(&self.coeffs, &mut self.delay, self.info.window_sequence, self.info.window_shape, self.info.prev_window_shape, dst);
289 ms_used: [[bool; MAX_SFBS]; MAX_WINDOWS],
294 fn new(pair: bool, channel: usize, sbinfo: GASubbandInfo) -> Self {
297 common_window: false,
299 ms_used: [[false; MAX_SFBS]; MAX_WINDOWS],
300 ics: [ICS::new(sbinfo), ICS::new(sbinfo)],
303 fn decode_ga_sce(&mut self, br: &mut BitReader, codebooks: &Codebooks, m4atype: M4AType) -> DecoderResult<()> {
304 self.ics[0].decode_ics(br, codebooks, m4atype, false, false)?;
307 fn decode_ga_cpe(&mut self, br: &mut BitReader, codebooks: &Codebooks, m4atype: M4AType) -> DecoderResult<()> {
308 let common_window = br.read_bool()?;
309 self.common_window = common_window;
311 self.ics[0].info.decode_ics_info(br)?;
312 self.ms_mask_present = br.read(2)? as u8;
313 validate!(self.ms_mask_present != 3);
314 if self.ms_mask_present == 1 {
315 for g in 0..self.ics[0].info.window_groups {
316 for sfb in 0..self.ics[0].info.max_sfb {
317 self.ms_used[g][sfb] = br.read_bool()?;
321 self.ics[1].info = self.ics[0].info;
323 self.ics[0].decode_ics(br, codebooks, m4atype, common_window, true)?;
324 self.ics[1].decode_ics(br, codebooks, m4atype, common_window, true)?;
325 if common_window && self.ms_mask_present != 0 {
327 for w in 0..self.ics[0].info.num_windows {
328 if w > 0 && !self.ics[0].info.scale_factor_grouping[w - 1] {
331 for sfb in 0..self.ics[0].info.max_sfb {
332 let start = w * 128 + self.ics[0].get_band_start(sfb);
333 let end = w * 128 + self.ics[0].get_band_start(sfb + 1);
334 if self.ics[0].is_intensity(g, sfb) {
335 let invert = (self.ms_mask_present == 1) && self.ms_used[g][sfb];
336 let dir = self.ics[0].get_intensity_dir(g, sfb) ^ invert;
337 let scale = 0.5f32.powf(0.25 * (f32::from(self.ics[0].scales[g][sfb]) + f32::from(INTENSITY_SCALE_MIN)));
339 for i in start..end {
340 self.ics[1].coeffs[i] = scale * self.ics[0].coeffs[i];
343 for i in start..end {
344 self.ics[1].coeffs[i] = -scale * self.ics[0].coeffs[i];
347 } else if (self.ms_mask_present == 2) || self.ms_used[g][sfb] {
348 for i in start..end {
349 let tmp = self.ics[0].coeffs[i] - self.ics[1].coeffs[i];
350 self.ics[0].coeffs[i] += self.ics[1].coeffs[i];
351 self.ics[1].coeffs[i] = tmp;
359 fn synth_audio(&mut self, dsp: &mut DSP, abuf: &mut NABufferType, srate_idx: usize) {
360 let mut adata = abuf.get_abuf_f32().unwrap();
361 let output = adata.get_data_mut().unwrap();
362 let off0 = abuf.get_offset(self.channel);
363 let off1 = abuf.get_offset(self.channel + 1);
364 self.ics[0].synth_channel(dsp, &mut output[off0..], srate_idx);
366 self.ics[1].synth_channel(dsp, &mut output[off1..], srate_idx);
372 kbd_long_win: [f32; 1024],
373 kbd_short_win: [f32; 128],
374 sine_long_win: [f32; 1024],
375 sine_short_win: [f32; 128],
382 const SHORT_WIN_POINT0: usize = 512 - 64;
383 const SHORT_WIN_POINT1: usize = 512 + 64;
387 let mut kbd_long_win: [f32; 1024] = [0.0; 1024];
388 let mut kbd_short_win: [f32; 128] = [0.0; 128];
389 generate_window(WindowType::KaiserBessel(4.0), 1.0, 1024, true, &mut kbd_long_win);
390 generate_window(WindowType::KaiserBessel(6.0), 1.0, 128, true, &mut kbd_short_win);
391 let mut sine_long_win: [f32; 1024] = [0.0; 1024];
392 let mut sine_short_win: [f32; 128] = [0.0; 128];
393 generate_window(WindowType::Sine, 1.0, 1024, true, &mut sine_long_win);
394 generate_window(WindowType::Sine, 1.0, 128, true, &mut sine_short_win);
396 kbd_long_win, kbd_short_win,
397 sine_long_win, sine_short_win,
398 imdct_long: IMDCT::new(1024 * 2, true),
399 imdct_short: IMDCT::new(128 * 2, true),
400 tmp: [0.0; 2048], ew_buf: [0.0; 1152],
403 #[allow(clippy::cognitive_complexity)]
404 fn synth(&mut self, coeffs: &[f32; 1024], delay: &mut [f32; 1024], seq: u8, window_shape: bool, prev_window_shape: bool, dst: &mut [f32]) {
405 let long_win = if window_shape { &self.kbd_long_win } else { &self.sine_long_win };
406 let short_win = if window_shape { &self.kbd_short_win } else { &self.sine_short_win };
407 let left_long_win = if prev_window_shape { &self.kbd_long_win } else { &self.sine_long_win };
408 let left_short_win = if prev_window_shape { &self.kbd_short_win } else { &self.sine_short_win };
409 if seq != EIGHT_SHORT_SEQUENCE {
410 self.imdct_long.imdct(coeffs, &mut self.tmp);
412 for (ain, aout) in coeffs.chunks(128).zip(self.tmp.chunks_mut(256)) {
413 self.imdct_short.imdct(ain, aout);
415 self.ew_buf = [0.0; 1152];
416 for (w, src) in self.tmp.chunks(256).enumerate() {
419 self.ew_buf[w * 128 + i] += src[i] * short_win[i];
421 } else { // to be left-windowed
423 self.ew_buf[i] = src[i];
427 self.ew_buf[w * 128 + i + 128] += src[i + 128] * short_win[127 - i];
431 if seq == ONLY_LONG_SEQUENCE { // should be the most common case
433 dst[i] = delay[i] + self.tmp[i] * left_long_win[i];
434 delay[i] = self.tmp[i + 1024] * long_win[1023 - i];
440 ONLY_LONG_SEQUENCE | LONG_START_SEQUENCE => {
442 dst[i] = self.tmp[i] * left_long_win[i] + delay[i];
445 EIGHT_SHORT_SEQUENCE => {
446 for i in 0..SHORT_WIN_POINT0 {
449 for i in SHORT_WIN_POINT0..SHORT_WIN_POINT1 {
450 let j = i - SHORT_WIN_POINT0;
451 dst[i] = delay[i] + self.ew_buf[j] * left_short_win[j];
453 for i in SHORT_WIN_POINT1..1024 {
454 let j = i - SHORT_WIN_POINT0;
455 dst[i] = self.ew_buf[j];
458 LONG_STOP_SEQUENCE => {
459 for i in 0..SHORT_WIN_POINT0 {
462 for i in SHORT_WIN_POINT0..SHORT_WIN_POINT1 {
463 dst[i] = delay[i] + self.tmp[i] * left_short_win[i - SHORT_WIN_POINT0];
465 for i in SHORT_WIN_POINT1..1024 {
466 dst[i] = self.tmp[i];
469 _ => unreachable!(""),
473 ONLY_LONG_SEQUENCE | LONG_STOP_SEQUENCE => {
475 delay[i] = self.tmp[i + 1024] * long_win[1023 - i];
478 EIGHT_SHORT_SEQUENCE => {
479 for i in 0..SHORT_WIN_POINT1 { // last part is already windowed
480 delay[i] = self.ew_buf[i + 512+64];
482 for i in SHORT_WIN_POINT1..1024 {
486 LONG_START_SEQUENCE => {
487 for i in 0..SHORT_WIN_POINT0 {
488 delay[i] = self.tmp[i + 1024];
490 for i in SHORT_WIN_POINT0..SHORT_WIN_POINT1 {
491 delay[i] = self.tmp[i + 1024] * short_win[127 - (i - SHORT_WIN_POINT0)];
493 for i in SHORT_WIN_POINT1..1024 {
497 _ => unreachable!(""),
503 info: NACodecInfoRef,
506 pairs: Vec<ChannelPair>,
507 codebooks: Codebooks,
509 sbinfo: GASubbandInfo,
515 info: NACodecInfo::new_dummy(),
516 chmap: NAChannelMap::new(),
517 m4ainfo: M4AInfo::new(),
519 codebooks: Codebooks::new(),
521 sbinfo: AAC_SUBBAND_INFO[0],
524 fn set_pair(&mut self, pair_no: usize, channel: usize, pair: bool) -> DecoderResult<()> {
525 if self.pairs.len() <= pair_no {
526 self.pairs.push(ChannelPair::new(pair, channel, self.sbinfo));
528 validate!(self.pairs[pair_no].channel == channel);
529 validate!(self.pairs[pair_no].pair == pair);
531 validate!(if pair { channel + 1 } else { channel } < self.m4ainfo.channels);
534 fn decode_ga(&mut self, br: &mut BitReader, abuf: &mut NABufferType) -> DecoderResult<()> {
535 let mut cur_pair = 0;
537 while br.left() > 3 {
538 let id = br.read(3)?;
541 let _tag = br.read(4)?;
542 self.set_pair(cur_pair, cur_ch, false)?;
543 self.pairs[cur_pair].decode_ga_sce(br, &self.codebooks, self.m4ainfo.otype)?;
548 let _tag = br.read(4)?;
549 self.set_pair(cur_pair, cur_ch, true)?;
550 self.pairs[cur_pair].decode_ga_cpe(br, &self.codebooks, self.m4ainfo.otype)?;
555 unimplemented!("coupling channel element");
558 let _tag = br.read(4)?;
559 self.set_pair(cur_pair, cur_ch, false)?;
560 self.pairs[cur_pair].decode_ga_sce(br, &self.codebooks, self.m4ainfo.otype)?;
565 let _id = br.read(4)?;
566 let align = br.read_bool()?;
567 let mut count = br.read(8)? as u32;
568 if count == 255 { count += br.read(8)? as u32; }
569 if align { br.align(); }
570 br.skip(count * 8)?; // no SBR payload or such
573 unimplemented!("program config");
576 let mut count = br.read(4)? as usize;
578 count += br.read(8)? as usize;
589 _ => { unreachable!(); },
592 let srate_idx = GASubbandInfo::find_idx(self.m4ainfo.srate);
593 for pair in 0..cur_pair {
594 self.pairs[pair].synth_audio(&mut self.dsp, abuf, srate_idx);
600 impl NADecoder for AACDecoder {
601 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
602 if let NACodecTypeInfo::Audio(_) = info.get_properties() {
603 let edata = info.get_extradata().unwrap();
604 validate!(edata.len() >= 2);
606 //print!("edata:"); for s in edata.iter() { print!(" {:02X}", *s);}println!("");
607 if (edata.len() > 12) && (&edata[4..8] == b"esds") {
608 let mut mr = MemoryReader::new_read(edata.as_slice());
609 let mut br = ByteReader::new(&mut mr);
610 let esds_size = br.read_u32be()? as usize;
611 validate!(esds_size <= edata.len());
613 let mut info_start = 0;
614 let mut info_size = 0;
615 while br.tell() < (esds_size as u64) {
616 let tag = br.read_byte()?;
619 let b = br.read_byte()?;
620 size = (size << 7) | u64::from(b & 0x7F);
621 validate!(br.tell() + size <= (esds_size as u64));
629 let flags = br.read_byte()?;
630 if (flags & 0x80) != 0 {
633 if (flags & 0x40) != 0 {
634 let len = br.read_byte()?;
635 br.read_skip(len as usize)?;
637 if (flags & 0x20) != 0 {
642 let _otype = br.read_byte()?;
643 let _stype = br.read_byte()?;
644 let _flags = br.read_u24be()?;
645 let _max_br = br.read_u32be()?;
646 let _min_br = br.read_u32be()?;
649 info_start = br.tell() as usize;
650 info_size = size as usize;
653 _ => br.read_skip(size as usize)?,
656 validate!(info_start > 0 && info_size > 0);
657 self.m4ainfo.read(&edata[info_start..][..info_size])?;
659 self.m4ainfo.read(&edata)?;
662 //println!("{}", self.m4ainfo);
663 if (self.m4ainfo.otype != M4AType::LC) || (self.m4ainfo.channels > 2) || (self.m4ainfo.samples != 1024) {
664 return Err(DecoderError::NotImplemented);
666 self.sbinfo = GASubbandInfo::find(self.m4ainfo.srate);
668 let ainfo = NAAudioInfo::new(self.m4ainfo.srate, self.m4ainfo.channels as u8,
669 SND_F32P_FORMAT, self.m4ainfo.samples);
670 self.info = info.replace_info(NACodecTypeInfo::Audio(ainfo));
672 if self.m4ainfo.channels >= DEFAULT_CHANNEL_MAP.len() {
673 return Err(DecoderError::NotImplemented);
675 let chmap_str = DEFAULT_CHANNEL_MAP[self.m4ainfo.channels];
676 if chmap_str.is_empty() { return Err(DecoderError::NotImplemented); }
677 self.chmap = NAChannelMap::from_str(chmap_str).unwrap();
681 Err(DecoderError::InvalidData)
684 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
685 let info = pkt.get_stream().get_info();
686 validate!(info.get_properties().is_audio());
687 let pktbuf = pkt.get_buffer();
689 let ainfo = self.info.get_properties().get_audio_info().unwrap();
690 let mut abuf = alloc_audio_buffer(ainfo, self.m4ainfo.samples, self.chmap.clone())?;
692 let mut br = BitReader::new(&pktbuf, BitReaderMode::BE);
693 match self.m4ainfo.otype {
695 self.decode_ga(&mut br, &mut abuf)?;
697 _ => { unimplemented!(""); }
700 let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf);
701 frm.set_keyframe(true);
704 fn flush(&mut self) {
705 for pair in self.pairs.iter_mut() {
706 pair.ics[0].delay = [0.0; 1024];
707 pair.ics[1].delay = [0.0; 1024];
712 impl NAOptionHandler for AACDecoder {
713 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
714 fn set_options(&mut self, _options: &[NAOption]) { }
715 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
718 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
719 Box::new(AACDecoder::new())
724 use nihav_core::codecs::RegisteredDecoders;
725 use nihav_core::demuxers::RegisteredDemuxers;
726 use nihav_codec_support::test::dec_video::test_decode_audio;
727 use crate::mpeg_register_all_decoders;
728 use nihav_realmedia::realmedia_register_all_demuxers;
731 let mut dmx_reg = RegisteredDemuxers::new();
732 realmedia_register_all_demuxers(&mut dmx_reg);
733 let mut dec_reg = RegisteredDecoders::new();
734 mpeg_register_all_decoders(&mut dec_reg);
736 // let file = "assets/RV/rv40_weighted_mc.rmvb";
737 let file = "assets/RV/rv40_weighted_mc_2.rmvb";
738 test_decode_audio("realmedia", file, Some(12000), None/*Some("aac")*/, &dmx_reg, &dec_reg);
742 const DEFAULT_CHANNEL_MAP: [&str; 9] = [
751 "C,L,R,Ls,Rs,Lss,Rss,LFE",