nihav-mpeg/src/codecs/aac/mod.rs

   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::*;
   8 use std::str::FromStr;
   9
  10 mod coeff_read;
  11 use coeff_read::*;
  12 mod info;
  13 use info::*;
  14 #[allow(clippy::needless_range_loop)]
  15 mod sbr;
  16 use sbr::{SBRHeader, SBRCodebooks, SBRState, SBRChannel, SBRDSP, sbr_read_sce, sbr_read_cpe};
  17 #[allow(clippy::excessive_precision)]
  18 mod tables;
  19 use tables::*;
  20 mod tools;
  21 use tools::*;
  22
  23 mod packetiser;
  24 pub use packetiser::get_packetiser_adts;
  25
  26 const MAX_WINDOWS:  usize = 8;
  27 const MAX_SFBS:     usize = 64;
  28
  29 #[derive(Clone,Copy)]
  30 pub struct ICSInfo {
  31     window_sequence:        u8,
  32     prev_window_sequence:   u8,
  33     window_shape:           bool,
  34     prev_window_shape:      bool,
  35     scale_factor_grouping:  [bool; MAX_WINDOWS],
  36     group_start:            [usize; MAX_WINDOWS],
  37     window_groups:          usize,
  38     num_windows:            usize,
  39     max_sfb:                usize,
  40     predictor_data:         Option<LTPData>,
  41     long_win:               bool,
  42 }
  43
  44 const ONLY_LONG_SEQUENCE:   u8 = 0;
  45 const LONG_START_SEQUENCE:  u8 = 1;
  46 const EIGHT_SHORT_SEQUENCE: u8 = 2;
  47 const LONG_STOP_SEQUENCE:   u8 = 3;
  48
  49 impl ICSInfo {
  50     fn new() -> Self {
  51         Self {
  52             window_sequence:        0,
  53             prev_window_sequence:   0,
  54             window_shape:           false,
  55             prev_window_shape:      false,
  56             scale_factor_grouping:  [false; MAX_WINDOWS],
  57             group_start:            [0; MAX_WINDOWS],
  58             num_windows:            0,
  59             window_groups:          0,
  60             max_sfb:                0,
  61             predictor_data:         None,
  62             long_win:               true,
  63         }
  64     }
  65     fn decode_ics_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
  66         self.prev_window_sequence = self.window_sequence;
  67         self.prev_window_shape    = self.window_shape;
  68         let ics_reserved_bit                            = br.read(1)?;
  69         validate!(ics_reserved_bit == 0);
  70         self.window_sequence                            = br.read(2)? as u8;
  71         /*match self.prev_window_sequence {
  72             ONLY_LONG_SEQUENCE | LONG_STOP_SEQUENCE => {
  73                     if (self.window_sequence != ONLY_LONG_SEQUENCE) &&
  74                        (self.window_sequence != LONG_START_SEQUENCE) {
  75                         println!("incorrect previous window");
  76                     }
  77                 },
  78             LONG_START_SEQUENCE | EIGHT_SHORT_SEQUENCE => {
  79                     if (self.window_sequence != EIGHT_SHORT_SEQUENCE) &&
  80                        (self.window_sequence != LONG_STOP_SEQUENCE) {
  81                         println!("incorrect previous window");
  82                     }
  83                 },
  84             _ => {},
  85         };*/
  86         self.window_shape                               = br.read_bool()?;
  87         self.window_groups = 1;
  88         if self.window_sequence == EIGHT_SHORT_SEQUENCE {
  89             self.long_win = false;
  90             self.num_windows = 8;
  91             self.max_sfb                                = br.read(4)? as usize;
  92             for i in 0..MAX_WINDOWS-1 {
  93                 self.scale_factor_grouping[i]           = br.read_bool()?;
  94                 if !self.scale_factor_grouping[i] {
  95                     self.group_start[self.window_groups] = i + 1;
  96                     self.window_groups += 1;
  97                 }
  98             }
  99         } else {
 100             self.long_win = true;
 101             self.num_windows = 1;
 102             self.max_sfb                                = br.read(6)? as usize;
 103             self.predictor_data = LTPData::read(br)?;
 104         }
 105         Ok(())
 106     }
 107     fn get_group_start(&self, g: usize) -> usize {
 108         if g == 0 {
 109             0
 110         } else if g >= self.window_groups {
 111             if self.long_win { 1 } else { 8 }
 112         } else {
 113             self.group_start[g]
 114         }
 115     }
 116 }
 117
 118 #[derive(Clone)]
 119 struct ICS {
 120     global_gain:    u8,
 121     info:           ICSInfo,
 122     pulse_data:     Option<PulseData>,
 123     tns_data:       Option<TNSData>,
 124     gain_control:   Option<GainControlData>,
 125     sect_cb:        [[u8; MAX_SFBS]; MAX_WINDOWS],
 126     sect_len:       [[usize; MAX_SFBS]; MAX_WINDOWS],
 127     sfb_cb:         [[u8; MAX_SFBS]; MAX_WINDOWS],
 128     num_sec:        [usize; MAX_WINDOWS],
 129     scales:         [[u8; MAX_SFBS]; MAX_WINDOWS],
 130     sbinfo:         GASubbandInfo,
 131     coeffs:         [f32; 1024],
 132     delay:          [f32; 1024],
 133 }
 134
 135 const INTENSITY_SCALE_MIN:  i16 = -155;
 136 impl ICS {
 137     fn new(sbinfo: GASubbandInfo) -> Self {
 138         Self {
 139             global_gain:    0,
 140             info:           ICSInfo::new(),
 141             pulse_data:     None,
 142             tns_data:       None,
 143             gain_control:   None,
 144             sect_cb:        [[0; MAX_SFBS]; MAX_WINDOWS],
 145             sect_len:       [[0; MAX_SFBS]; MAX_WINDOWS],
 146             sfb_cb:         [[0; MAX_SFBS]; MAX_WINDOWS],
 147             scales:         [[0; MAX_SFBS]; MAX_WINDOWS],
 148             num_sec:        [0; MAX_WINDOWS],
 149             sbinfo,
 150             coeffs:         [0.0; 1024],
 151             delay:          [0.0; 1024],
 152         }
 153     }
 154     fn decode_section_data(&mut self, br: &mut BitReader, may_have_intensity: bool) -> DecoderResult<()> {
 155         let sect_bits = if self.info.long_win { 5 } else { 3 };
 156         let sect_esc_val = (1 << sect_bits) - 1;
 157
 158         for g in 0..self.info.window_groups {
 159             let mut k = 0;
 160             let mut l = 0;
 161             while k < self.info.max_sfb {
 162                 self.sect_cb[g][l]                      = br.read(4)? as u8;
 163                 self.sect_len[g][l] = 0;
 164                 validate!(self.sect_cb[g][l] != RESERVED_HCB);
 165                 if ((self.sect_cb[g][l] == INTENSITY_HCB) || (self.sect_cb[g][l] == INTENSITY_HCB2)) && !may_have_intensity {
 166                     return Err(DecoderError::InvalidData);
 167                 }
 168                 loop {
 169                     let sect_len_incr                   = br.read(sect_bits)? as usize;
 170                     self.sect_len[g][l] += sect_len_incr;
 171                     if sect_len_incr < sect_esc_val { break; }
 172                 }
 173                 validate!(k + self.sect_len[g][l] <= self.info.max_sfb);
 174                 for _ in 0..self.sect_len[g][l] {
 175                     self.sfb_cb[g][k] = self.sect_cb[g][l];
 176                     k += 1;
 177                 }
 178                 l += 1;
 179             }
 180             self.num_sec[g] = l;
 181         }
 182         Ok(())
 183     }
 184     fn is_intensity(&self, g: usize, sfb: usize) -> bool {
 185         (self.sfb_cb[g][sfb] == INTENSITY_HCB) || (self.sfb_cb[g][sfb] == INTENSITY_HCB2)
 186     }
 187     fn get_intensity_dir(&self, g: usize, sfb: usize) -> bool {
 188         self.sfb_cb[g][sfb] == INTENSITY_HCB
 189     }
 190     fn is_noise(&self, g: usize, sfb: usize) -> bool {
 191         self.sfb_cb[g][sfb] == NOISE_HCB
 192     }
 193     fn decode_scale_factor_data(&mut self, br: &mut BitReader, codebooks: &Codebooks) -> DecoderResult<()> {
 194         decode_scale_factor_data(br, &mut self.scales, self.global_gain, &self.info, &self.sfb_cb, codebooks)
 195     }
 196     fn get_band_start(&self, swb: usize) -> usize {
 197         if self.info.long_win {
 198             self.sbinfo.long_bands[swb]
 199         } else {
 200             self.sbinfo.short_bands[swb]
 201         }
 202     }
 203     fn get_num_bands(&self) -> usize {
 204         if self.info.long_win {
 205             self.sbinfo.long_bands.len() - 1
 206         } else {
 207             self.sbinfo.short_bands.len() - 1
 208         }
 209     }
 210     fn decode_spectrum(&mut self, br: &mut BitReader, codebooks: &Codebooks) -> DecoderResult<()> {
 211         self.coeffs = [0.0; 1024];
 212         decode_spectrum(br, &mut self.coeffs, &self.scales, &self.info, &self.sbinfo, &self.sfb_cb, codebooks)
 213     }
 214     fn iquant(val: f32) -> f32 {
 215         if val < 0.0 {
 216             -((-val).powf(4.0 / 3.0))
 217         } else {
 218             val.powf(4.0 / 3.0)
 219         }
 220     }
 221     fn place_pulses(&mut self) {
 222         if let Some(ref pdata) = self.pulse_data {
 223             if pdata.pulse_start_sfb >= self.sbinfo.long_bands.len() - 1 { return; }
 224             let mut k = self.get_band_start(pdata.pulse_start_sfb);
 225             let mut band = pdata.pulse_start_sfb;
 226             for pno in 0..pdata.number_pulse {
 227                 k += pdata.pulse_offset[pno] as usize;
 228                 if k >= 1024 { return; }
 229                 while self.get_band_start(band + 1) <= k { band += 1; }
 230                 let scale = get_scale(self.scales[0][band]);
 231                 let mut base = self.coeffs[k];
 232                 if base != 0.0 {
 233                     base = requant(self.coeffs[k], scale);
 234                 }
 235                 if base > 0.0 {
 236                     base += f32::from(pdata.pulse_amp[pno]);
 237                 } else {
 238                     base -= f32::from(pdata.pulse_amp[pno]);
 239                 }
 240                 self.coeffs[k] = Self::iquant(base) * scale;
 241             }
 242         }
 243     }
 244     fn decode_ics(&mut self, br: &mut BitReader, codebooks: &Codebooks, m4atype: M4AType, common_window: bool, may_have_intensity: bool) -> DecoderResult<()> {
 245         self.global_gain                                = br.read(8)? as u8;
 246         if !common_window {
 247             self.info.decode_ics_info(br)?;
 248         }
 249         self.decode_section_data(br, may_have_intensity)?;
 250         self.decode_scale_factor_data(br, codebooks)?;
 251         self.pulse_data = PulseData::read(br)?;
 252         validate!(self.pulse_data.is_none() || self.info.long_win);
 253         let tns_max_order;
 254         if !self.info.long_win {
 255             tns_max_order = 7;
 256         } else if m4atype == M4AType::LC {
 257             tns_max_order = 12;
 258         } else {
 259             tns_max_order = TNS_MAX_ORDER;
 260         }
 261         self.tns_data = TNSData::read(br, self.info.long_win, self.info.num_windows, tns_max_order)?;
 262         if m4atype == M4AType::SSR {
 263             self.gain_control = GainControlData::read(br)?;
 264         } else {
 265             let gain_control_data_present               = br.read_bool()?;
 266             validate!(!gain_control_data_present);
 267         }
 268         self.decode_spectrum(br, codebooks)?;
 269         Ok(())
 270     }
 271     fn synth_channel(&mut self, dsp: &mut DSP, dst: &mut [f32], srate_idx: usize) {
 272         self.place_pulses();
 273         if let Some(ref tns_data) = self.tns_data {
 274             let tns_max_bands = TNSData::get_max_bands(self.info.long_win, srate_idx).min(self.info.max_sfb);
 275             for w in 0..self.info.num_windows {
 276                 let mut bottom = self.get_num_bands();
 277                 for f in 0..tns_data.n_filt[w] {
 278                     let top = bottom;
 279                     bottom = if top >= tns_data.coeffs[w][f].length { top - tns_data.coeffs[w][f].length } else { 0 };
 280                     let order = tns_data.coeffs[w][f].order;
 281                     if order == 0 { continue; }
 282                     let start = w * 128 + self.get_band_start(tns_max_bands.min(bottom));
 283                     let end   = w * 128 + self.get_band_start(tns_max_bands.min(top));
 284                     tns_data.apply(&mut self.coeffs, w, f, start, end);
 285                 }
 286             }
 287         }
 288         dsp.synth(&self.coeffs, &mut self.delay, self.info.window_sequence, self.info.window_shape, self.info.prev_window_shape, dst);
 289     }
 290 }
 291
 292 #[derive(Clone)]
 293 struct ChannelPair {
 294     pair:               bool,
 295     channel:            usize,
 296     common_window:      bool,
 297     ms_mask_present:    u8,
 298     ms_used:            [[bool; MAX_SFBS]; MAX_WINDOWS],
 299     ics:                [ICS; 2],
 300     sbr_hdr:            SBRHeader,
 301     sbr_state:          SBRState,
 302     sbr_ch:             [SBRChannel; 2],
 303     do_sbr:             bool,
 304 }
 305
 306 impl ChannelPair {
 307     fn new(pair: bool, channel: usize, sbinfo: GASubbandInfo) -> Self {
 308         Self {
 309             pair, channel,
 310             common_window:      false,
 311             ms_mask_present:    0,
 312             ms_used:            [[false; MAX_SFBS]; MAX_WINDOWS],
 313             ics:                [ICS::new(sbinfo), ICS::new(sbinfo)],
 314             sbr_hdr:            SBRHeader::new(),
 315             sbr_state:          SBRState::new(),
 316             sbr_ch:             [SBRChannel::new(), SBRChannel::new()],
 317             do_sbr:             false,
 318         }
 319     }
 320     fn decode_ga_sce(&mut self, br: &mut BitReader, codebooks: &Codebooks, m4atype: M4AType) -> DecoderResult<()> {
 321         self.ics[0].decode_ics(br, codebooks, m4atype, false, false)?;
 322         Ok(())
 323     }
 324     fn decode_ga_cpe(&mut self, br: &mut BitReader, codebooks: &Codebooks, m4atype: M4AType) -> DecoderResult<()> {
 325         let common_window                               = br.read_bool()?;
 326         self.common_window = common_window;
 327         if common_window {
 328             self.ics[0].info.decode_ics_info(br)?;
 329             self.ms_mask_present                        = br.read(2)? as u8;
 330             validate!(self.ms_mask_present != 3);
 331             if self.ms_mask_present == 1 {
 332                 for g in 0..self.ics[0].info.window_groups {
 333                     for sfb in 0..self.ics[0].info.max_sfb {
 334                         self.ms_used[g][sfb]            = br.read_bool()?;
 335                     }
 336                 }
 337             } else {
 338                 self.ms_used = [[false; MAX_SFBS]; MAX_WINDOWS];
 339             }
 340             self.ics[1].info = self.ics[0].info;
 341         }
 342         self.ics[0].decode_ics(br, codebooks, m4atype, common_window, true)?;
 343         self.ics[1].decode_ics(br, codebooks, m4atype, common_window, true)?;
 344         if common_window {
 345             let mut g = 0;
 346             for w in 0..self.ics[0].info.num_windows {
 347                 if w > 0 && !self.ics[0].info.scale_factor_grouping[w - 1] {
 348                     g += 1;
 349                 }
 350                 for sfb in 0..self.ics[0].info.max_sfb {
 351                     let start = w * 128 + self.ics[0].get_band_start(sfb);
 352                     let end   = w * 128 + self.ics[0].get_band_start(sfb + 1);
 353                     if self.ics[1].is_intensity(g, sfb) {
 354                         let invert = (self.ms_mask_present == 1) && self.ms_used[g][sfb];
 355                         let dir = self.ics[1].get_intensity_dir(g, sfb) ^ invert;
 356                         let scale = 0.5f32.powf(0.25 * (f32::from(self.ics[1].scales[g][sfb]) + f32::from(INTENSITY_SCALE_MIN)));
 357                         if dir {
 358                             for i in start..end {
 359                                 self.ics[1].coeffs[i] = scale * self.ics[0].coeffs[i];
 360                             }
 361                         } else {
 362                             for i in start..end {
 363                                 self.ics[1].coeffs[i] = -scale * self.ics[0].coeffs[i];
 364                             }
 365                         }
 366                     } else if ((self.ms_mask_present == 2) || self.ms_used[g][sfb]) && !self.ics[0].is_noise(g, sfb) {
 367                         for i in start..end {
 368                             let tmp = self.ics[0].coeffs[i] - self.ics[1].coeffs[i];
 369                             self.ics[0].coeffs[i] += self.ics[1].coeffs[i];
 370                             self.ics[1].coeffs[i] = tmp;
 371                         }
 372                     }
 373                 }
 374             }
 375         }
 376         Ok(())
 377     }
 378     fn decode_sbr(&mut self, buf: &[u8], has_crc: bool, cbs: &SBRCodebooks, srate: u32) -> DecoderResult<()> {
 379         let mut br = BitReader::new(buf, BitReaderMode::BE);
 380         if has_crc {
 381             let _bs_sbr_crc_bits        = br.read(10)?;
 382         }
 383         if br.read_bool()? {
 384             if let Ok(hdr) = SBRHeader::read(&mut br) {
 385                 if self.sbr_hdr.differs_from(&hdr) {
 386                     self.do_sbr = self.sbr_state.init(&hdr, srate).is_ok();
 387                     self.sbr_ch[0].reset();
 388                     self.sbr_ch[1].reset();
 389                 }
 390                 self.sbr_hdr = hdr;
 391             } else {
 392                 self.do_sbr = false;
 393             }
 394         }
 395         if self.do_sbr {
 396             if !self.pair {
 397                 sbr_read_sce(&mut br, self.sbr_hdr.amp_res, &self.sbr_state, cbs, &mut self.sbr_ch[0])?;
 398             } else {
 399                 sbr_read_cpe(&mut br, self.sbr_hdr.amp_res, &self.sbr_state, cbs, &mut self.sbr_ch)?;
 400             }
 401         }
 402
 403         Ok(())
 404     }
 405     fn synth_audio(&mut self, dsp: &mut DSP, abuf: &mut NABufferType, srate_idx: usize, upsample: bool) {
 406         let mut adata = abuf.get_abuf_f32().unwrap();
 407         let output = adata.get_data_mut().unwrap();
 408         let off0 = abuf.get_offset(self.channel);
 409         let off1 = abuf.get_offset(self.channel + 1);
 410         if !upsample {
 411             self.ics[0].synth_channel(dsp, &mut output[off0..], srate_idx);
 412             if self.pair {
 413                 self.ics[1].synth_channel(dsp, &mut output[off1..], srate_idx);
 414             }
 415         } else {
 416             let mut tmp = [0.0; 1024];
 417             let nchannels = if self.pair { 2 } else { 1 };
 418             for ch in 0..nchannels {
 419                 let off = if ch == 0 { off0 } else { off1 };
 420                 self.ics[ch].synth_channel(dsp, &mut tmp, srate_idx);
 421                 self.sbr_ch[ch].analysis(&mut dsp.sbr_dsp, &tmp);
 422                 if self.do_sbr {
 423                     self.sbr_ch[ch].hf_generate(&self.sbr_state);
 424                     self.sbr_ch[ch].hf_adjust(&self.sbr_state, &self.sbr_hdr);
 425                 } else {
 426                     self.sbr_ch[ch].bypass();
 427                 }
 428                 self.sbr_ch[ch].synthesis(&mut dsp.sbr_dsp, &mut output[off..][..2048]);
 429                 self.sbr_ch[ch].update_frame();
 430             }
 431         }
 432     }
 433 }
 434
 435 struct DSP {
 436     kbd_long_win:   [f32; 1024],
 437     kbd_short_win:  [f32; 128],
 438     sine_long_win:  [f32; 1024],
 439     sine_short_win: [f32; 128],
 440     imdct_long:     IMDCT,
 441     imdct_short:    IMDCT,
 442     tmp:            [f32; 2048],
 443     ew_buf:         [f32; 1152],
 444     sbr_dsp:        SBRDSP,
 445 }
 446
 447 const SHORT_WIN_POINT0: usize = 512 - 64;
 448 const SHORT_WIN_POINT1: usize = 512 + 64;
 449
 450 impl DSP {
 451     fn new() -> Self {
 452         let mut kbd_long_win: [f32; 1024] = [0.0; 1024];
 453         let mut kbd_short_win: [f32; 128] = [0.0; 128];
 454         generate_window(WindowType::KaiserBessel(4.0), 1.0, 1024, true, &mut kbd_long_win);
 455         generate_window(WindowType::KaiserBessel(6.0), 1.0,  128, true, &mut kbd_short_win);
 456         let mut sine_long_win: [f32; 1024] = [0.0; 1024];
 457         let mut sine_short_win: [f32; 128] = [0.0; 128];
 458         generate_window(WindowType::Sine, 1.0, 1024, true, &mut sine_long_win);
 459         generate_window(WindowType::Sine, 1.0,  128, true, &mut sine_short_win);
 460         Self {
 461             kbd_long_win, kbd_short_win,
 462             sine_long_win, sine_short_win,
 463             imdct_long: IMDCT::new(1024 * 2, true),
 464             imdct_short: IMDCT::new(128 * 2, true),
 465             tmp: [0.0; 2048], ew_buf: [0.0; 1152],
 466             sbr_dsp: SBRDSP::new(),
 467         }
 468     }
 469     #[allow(clippy::cognitive_complexity)]
 470     fn synth(&mut self, coeffs: &[f32; 1024], delay: &mut [f32; 1024], seq: u8, window_shape: bool, prev_window_shape: bool, dst: &mut [f32]) {
 471         let long_win  = if window_shape { &self.kbd_long_win  } else { &self.sine_long_win };
 472         let short_win = if window_shape { &self.kbd_short_win } else { &self.sine_short_win };
 473         let left_long_win  = if prev_window_shape { &self.kbd_long_win  } else { &self.sine_long_win };
 474         let left_short_win = if prev_window_shape { &self.kbd_short_win } else { &self.sine_short_win };
 475         if seq != EIGHT_SHORT_SEQUENCE {
 476             self.imdct_long.imdct(coeffs, &mut self.tmp);
 477         } else {
 478             for (ain, aout) in coeffs.chunks(128).zip(self.tmp.chunks_mut(256)) {
 479                 self.imdct_short.imdct(ain, aout);
 480             }
 481             self.ew_buf = [0.0; 1152];
 482             for (w, src) in self.tmp.chunks(256).enumerate() {
 483                 if w > 0 {
 484                     for i in 0..128 {
 485                         self.ew_buf[w * 128 + i] += src[i] * short_win[i];
 486                     }
 487                 } else { // to be left-windowed
 488                     self.ew_buf[..128].copy_from_slice(&src[..128]);
 489                 }
 490                 for i in 0..128 {
 491                     self.ew_buf[w * 128 + i + 128] += src[i + 128] * short_win[127 - i];
 492                 }
 493             }
 494         }
 495         if seq == ONLY_LONG_SEQUENCE { // should be the most common case
 496             for i in 0..1024 {
 497                 dst[i] = delay[i] + self.tmp[i] * left_long_win[i];
 498                 delay[i] = self.tmp[i + 1024] * long_win[1023 - i];
 499             }
 500             return;
 501         }
 502         // output new data
 503         match seq {
 504             ONLY_LONG_SEQUENCE | LONG_START_SEQUENCE => {
 505                     for i in 0..1024 {
 506                         dst[i] = self.tmp[i] * left_long_win[i] + delay[i];
 507                     }
 508                 },
 509             EIGHT_SHORT_SEQUENCE => {
 510                     dst[..SHORT_WIN_POINT0].copy_from_slice(&delay[..SHORT_WIN_POINT0]);
 511                     for i in SHORT_WIN_POINT0..SHORT_WIN_POINT1 {
 512                         let j = i - SHORT_WIN_POINT0;
 513                         dst[i] = delay[i] + self.ew_buf[j] * left_short_win[j];
 514                     }
 515                     dst[SHORT_WIN_POINT1..1024].copy_from_slice(
 516                         &self.ew_buf[SHORT_WIN_POINT1-SHORT_WIN_POINT0..1024-SHORT_WIN_POINT0]);
 517                 },
 518             LONG_STOP_SEQUENCE => {
 519                     dst[..SHORT_WIN_POINT0].copy_from_slice(&delay[..SHORT_WIN_POINT0]);
 520                     for i in SHORT_WIN_POINT0..SHORT_WIN_POINT1 {
 521                         dst[i] = delay[i] + self.tmp[i] * left_short_win[i - SHORT_WIN_POINT0];
 522                     }
 523                     dst[SHORT_WIN_POINT1..1024].copy_from_slice(&self.tmp[SHORT_WIN_POINT1..1024]);
 524                 },
 525             _ => unreachable!(""),
 526         };
 527         // save delay
 528         match seq {
 529             ONLY_LONG_SEQUENCE | LONG_STOP_SEQUENCE => {
 530                     for (dst, (&src, &win)) in delay.iter_mut()
 531                             .zip(self.tmp[1024..].iter().zip(long_win.iter().rev())) {
 532                         *dst = src * win;
 533                     }
 534                 },
 535             EIGHT_SHORT_SEQUENCE => {
 536                     // last part is already windowed
 537                     delay[..SHORT_WIN_POINT1].copy_from_slice(&self.ew_buf[512+64..][..SHORT_WIN_POINT1]);
 538                     for el in delay[SHORT_WIN_POINT1..].iter_mut() {
 539                         *el = 0.0;
 540                     }
 541                 },
 542             LONG_START_SEQUENCE   => {
 543                     delay[..SHORT_WIN_POINT0].copy_from_slice(&self.tmp[1024..][..SHORT_WIN_POINT0]);
 544                     for i in SHORT_WIN_POINT0..SHORT_WIN_POINT1 {
 545                         delay[i] = self.tmp[i + 1024] * short_win[127 - (i - SHORT_WIN_POINT0)];
 546                     }
 547                     for el in delay[SHORT_WIN_POINT1..].iter_mut() {
 548                         *el = 0.0;
 549                     }
 550                 },
 551             _ => unreachable!(""),
 552         };
 553     }
 554 }
 555
 556 struct AACDecoder {
 557     info:       NACodecInfoRef,
 558     chmap:      NAChannelMap,
 559     m4ainfo:    M4AInfo,
 560     pairs:      Vec<ChannelPair>,
 561     codebooks:  Codebooks,
 562     dsp:        DSP,
 563     sbinfo:     GASubbandInfo,
 564     sbr_cbs:    SBRCodebooks,
 565     upsample:   bool,
 566 }
 567
 568 impl AACDecoder {
 569     fn new() -> Self {
 570         AACDecoder {
 571             info:       NACodecInfo::new_dummy(),
 572             chmap:      NAChannelMap::new(),
 573             m4ainfo:    M4AInfo::new(),
 574             pairs:      Vec::new(),
 575             codebooks:  Codebooks::new(),
 576             dsp:        DSP::new(),
 577             sbinfo:     AAC_SUBBAND_INFO[0],
 578             sbr_cbs:    SBRCodebooks::new(),
 579             upsample:   false,
 580         }
 581     }
 582     fn set_pair(&mut self, pair_no: usize, channel: usize, pair: bool) -> DecoderResult<()> {
 583         if self.pairs.len() <= pair_no {
 584             self.pairs.push(ChannelPair::new(pair, channel, self.sbinfo));
 585         } else {
 586             validate!(self.pairs[pair_no].channel == channel);
 587             validate!(self.pairs[pair_no].pair    == pair);
 588         }
 589         validate!(if pair { channel + 1 } else { channel } < self.m4ainfo.channels);
 590         Ok(())
 591     }
 592     fn decode_ga(&mut self, br: &mut BitReader, abuf: &mut NABufferType) -> DecoderResult<()> {
 593         let mut cur_pair = 0;
 594         let mut cur_ch   = 0;
 595         while br.left() > 3 {
 596             let id                                      = br.read(3)?;
 597             match id {
 598                 0 => { // ID_SCE
 599                         let _tag                        = br.read(4)?;
 600                         self.set_pair(cur_pair, cur_ch, false)?;
 601                         self.pairs[cur_pair].decode_ga_sce(br, &self.codebooks, self.m4ainfo.otype)?;
 602                         cur_pair += 1;
 603                         cur_ch   += 1;
 604                     },
 605                 1 => { // ID_CPE
 606                         let _tag                        = br.read(4)?;
 607                         self.set_pair(cur_pair, cur_ch, true)?;
 608                         self.pairs[cur_pair].decode_ga_cpe(br, &self.codebooks, self.m4ainfo.otype)?;
 609                         cur_pair += 1;
 610                         cur_ch   += 2;
 611                     },
 612                 2 => { // ID_CCE
 613                         unimplemented!("coupling channel element");
 614                     },
 615                 3 => { // ID_LFE
 616                         let _tag                        = br.read(4)?;
 617                         self.set_pair(cur_pair, cur_ch, false)?;
 618                         self.pairs[cur_pair].decode_ga_sce(br, &self.codebooks, self.m4ainfo.otype)?;
 619                         cur_pair += 1;
 620                         cur_ch   += 1;
 621                     },
 622                 4 => { // ID_DSE
 623                         let _id                         = br.read(4)?;
 624                         let align                       = br.read_bool()?;
 625                         let mut count                   = br.read(8)?;
 626                         if count == 255 { count        += br.read(8)?; }
 627                         if align {                        br.align(); }
 628                                                           br.skip(count * 8)?; // no SBR payload or such
 629                     },
 630                 5 => { // ID_PCE
 631                         skimp_through_program_config_element(br)?;
 632                     },
 633                 6 => { // ID_FIL
 634                         let mut count                   = br.read(4)? as usize;
 635                         if count == 15 {
 636                             count                      += br.read(8)? as usize;
 637                             count -= 1;
 638                         }
 639                         if count > 0 {
 640                             let extension_type          = br.read(4)?;
 641                             match extension_type {
 642                                 0xD | 0xE => { // SBR data without or with CRC
 643                                     let has_crc = extension_type == 0xE;
 644
 645                                     let mut buf = [0; 256 + 16];
 646                                     for el in buf[..count - 1].iter_mut() {
 647                                         *el             = br.read(8)? as u8;
 648                                     }
 649                                     buf[count - 1]      = br.read(4)? as u8;
 650                                     if cur_pair > 0 {
 651                                         self.pairs[cur_pair - 1].decode_sbr(&buf[..count], has_crc, &self.sbr_cbs, self.m4ainfo.srate * 2)?;
 652                                     }
 653                                 },
 654                                 _ => {
 655                                     for _ in 0..count-1 {
 656                                                           br.skip(8)?;
 657                                     }
 658                                                           br.skip(4)?;
 659                                 },
 660                             };
 661                         }
 662                     },
 663                 7 => { // ID_TERM
 664                         break;
 665                     },
 666                 _ => { unreachable!(); },
 667             };
 668         }
 669         let srate_idx = GASubbandInfo::find_idx(self.m4ainfo.srate);
 670         for pair in 0..cur_pair {
 671             self.pairs[pair].synth_audio(&mut self.dsp, abuf, srate_idx, self.upsample);
 672         }
 673         Ok(())
 674     }
 675 }
 676
 677 impl NADecoder for AACDecoder {
 678     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
 679         if let NACodecTypeInfo::Audio(_) = info.get_properties() {
 680             let edata = info.get_extradata().unwrap();
 681             validate!(edata.len() >= 2);
 682
 683             if (edata.len() > 12) && (&edata[4..8] == b"esds") {
 684                 let mut mr = MemoryReader::new_read(edata.as_slice());
 685                 let mut br = ByteReader::new(&mut mr);
 686                 let esds_size           = br.read_u32be()? as usize;
 687                 validate!(esds_size <= edata.len());
 688                                           br.read_skip(8)?;
 689                 let mut info_start = 0;
 690                 let mut info_size = 0;
 691                 while br.tell() < (esds_size as u64) {
 692                     let tag             = br.read_byte()?;
 693                     let mut size = 0;
 694                     loop {
 695                         let b           = br.read_byte()?;
 696                         size = (size << 7) | u64::from(b & 0x7F);
 697                         validate!(br.tell() + size <= (esds_size as u64));
 698                         if (b & 0x80) == 0 {
 699                             break;
 700                         }
 701                     }
 702                     match tag {
 703                         3 => {
 704                                           br.read_u16be()?;
 705                             let flags   = br.read_byte()?;
 706                             if (flags & 0x80) != 0 {
 707                                           br.read_u16be()?;
 708                             }
 709                             if (flags & 0x40) != 0 {
 710                                 let len = br.read_byte()?;
 711                                           br.read_skip(len as usize)?;
 712                             }
 713                             if (flags & 0x20) != 0 {
 714                                           br.read_u16be()?;
 715                             }
 716                         },
 717                         4 => {
 718                             let _otype  = br.read_byte()?;
 719                             let _stype  = br.read_byte()?;
 720                             let _flags  = br.read_u24be()?;
 721                             let _max_br = br.read_u32be()?;
 722                             let _min_br = br.read_u32be()?;
 723                         },
 724                         5 => {
 725                             info_start = br.tell() as usize;
 726                             info_size = size as usize;
 727                             break;
 728                         },
 729                         _ => br.read_skip(size as usize)?,
 730                     }
 731                 }
 732                 validate!(info_start > 0 && info_size > 0);
 733                 self.m4ainfo.read(&edata[info_start..][..info_size])?;
 734             } else {
 735                 self.m4ainfo.read(&edata)?;
 736             }
 737
 738             //println!("{}", self.m4ainfo);
 739             if (self.m4ainfo.otype != M4AType::LC) || (self.m4ainfo.channels > 2) || (self.m4ainfo.samples != 1024) {
 740                 return Err(DecoderError::NotImplemented);
 741             }
 742             self.sbinfo = GASubbandInfo::find(self.m4ainfo.srate);
 743
 744             self.upsample = self.m4ainfo.srate < 32000;
 745             let (srate, samples) = if !self.upsample {
 746                     (self.m4ainfo.srate, self.m4ainfo.samples)
 747                 } else {
 748                     (self.m4ainfo.srate * 2, self.m4ainfo.samples * 2)
 749                 };
 750
 751             let ainfo = NAAudioInfo::new(srate, self.m4ainfo.channels as u8,
 752                                          SND_F32P_FORMAT, samples);
 753             self.info = info.replace_info(NACodecTypeInfo::Audio(ainfo));
 754
 755             if self.m4ainfo.channels >= DEFAULT_CHANNEL_MAP.len() {
 756                 return Err(DecoderError::NotImplemented);
 757             }
 758             let chmap_str = DEFAULT_CHANNEL_MAP[self.m4ainfo.channels];
 759             if chmap_str.is_empty() { return Err(DecoderError::NotImplemented); }
 760             self.chmap = NAChannelMap::from_str(chmap_str).unwrap();
 761
 762             Ok(())
 763         } else {
 764             Err(DecoderError::InvalidData)
 765         }
 766     }
 767     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
 768         let info = pkt.get_stream().get_info();
 769         validate!(info.get_properties().is_audio());
 770         let pktbuf = pkt.get_buffer();
 771
 772         let ainfo = self.info.get_properties().get_audio_info().unwrap();
 773         let samples = if !self.upsample { self.m4ainfo.samples } else { self.m4ainfo.samples * 2 };
 774         let mut abuf = alloc_audio_buffer(ainfo, samples, self.chmap.clone())?;
 775
 776         let mut br = BitReader::new(&pktbuf, BitReaderMode::BE);
 777         match self.m4ainfo.otype {
 778             M4AType::LC => {
 779                     self.decode_ga(&mut br, &mut abuf)?;
 780                 },
 781             _ => { unimplemented!(""); }
 782         }
 783
 784         let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf);
 785         frm.set_keyframe(true);
 786         Ok(frm.into_ref())
 787     }
 788     fn flush(&mut self) {
 789         for pair in self.pairs.iter_mut() {
 790             pair.ics[0].delay = [0.0; 1024];
 791             pair.ics[1].delay = [0.0; 1024];
 792         }
 793     }
 794 }
 795
 796 impl NAOptionHandler for AACDecoder {
 797     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
 798     fn set_options(&mut self, _options: &[NAOption]) { }
 799     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 800 }
 801
 802 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
 803     Box::new(AACDecoder::new())
 804 }
 805
 806 #[cfg(test)]
 807 mod test {
 808     use nihav_core::codecs::RegisteredDecoders;
 809     use nihav_core::demuxers::RegisteredDemuxers;
 810     use nihav_codec_support::test::dec_video::test_decode_audio;
 811     use crate::mpeg_register_all_decoders;
 812     use nihav_realmedia::realmedia_register_all_demuxers;
 813     use std::io::Read;
 814
 815     #[test]
 816     fn test_aac() {
 817         let mut dmx_reg = RegisteredDemuxers::new();
 818         realmedia_register_all_demuxers(&mut dmx_reg);
 819         let mut dec_reg = RegisteredDecoders::new();
 820         mpeg_register_all_decoders(&mut dec_reg);
 821
 822 //        let file = "assets/RV/rv40_weighted_mc.rmvb";
 823         let file = "assets/RV/rv40_weighted_mc_2.rmvb";
 824         test_decode_audio("realmedia", file, Some(12000), None/*Some("aac")*/, &dmx_reg, &dec_reg);
 825     }
 826     #[test]
 827     fn test_aac_sbr() {
 828         let mut dmx_reg = RegisteredDemuxers::new();
 829         nihav_commonfmt::generic_register_all_demuxers(&mut dmx_reg);
 830         let mut dec_reg = RegisteredDecoders::new();
 831         mpeg_register_all_decoders(&mut dec_reg);
 832
 833         let file = "assets/MPEG/SBRtestStereoAot29Sig0.mp4";
 834         test_decode_audio("mov", file, Some(400), None/*Some("aacsbr")*/, &dmx_reg, &dec_reg);
 835     }
 836     #[test]
 837     fn test_adts_packetiser() {
 838         let mut buf = [0; 4096];
 839         // sample obtained with yt-dlp -f 234
 840         let mut file = std::fs::File::open("assets/MPEG/Vf9Lvifxwk4.adts").unwrap();
 841
 842         let mut pkts = super::get_packetiser_adts();
 843         file.read_exact(&mut buf).unwrap();
 844         pkts.add_data(&buf);
 845         let stream = pkts.parse_stream(0).unwrap();
 846         let mut frame_sizes = Vec::with_capacity(15);
 847         while let Some(pkt) = pkts.get_packet(stream.clone()).unwrap() {
 848             let frame_size = pkt.get_buffer().len();
 849             println!("pkt size {}", frame_size);
 850             frame_sizes.push(frame_size);
 851         }
 852         assert_eq!(&frame_sizes, &[371, 372, 394, 402, 474, 400, 407, 399, 385]);
 853     }
 854 }
 855
 856 const DEFAULT_CHANNEL_MAP: [&str; 9] = [
 857     "",
 858     "C",
 859     "L,R",
 860     "C,L,R",
 861     "C,L,R,Cs",
 862     "C,L,R,Ls,Rs",
 863     "C,L,R,Ls,Rs,LFE",
 864     "",
 865     "C,L,R,Ls,Rs,Lss,Rss,LFE",
 866 ];