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

   1 use nihav_core::codecs::{DecoderResult, DecoderError};
   2 use nihav_core::io::bitreader::*;
   3 use std::f32::consts;
   4 use super::MAX_WINDOWS;
   5
   6 #[derive(Clone,Copy)]
   7 pub struct LTPData {
   8 }
   9
  10 impl LTPData {
  11     pub fn read(br: &mut BitReader) -> DecoderResult<Option<Self>> {
  12         let predictor_data_present                      = br.read_bool()?;
  13         if !predictor_data_present { return Ok(None); }
  14 unimplemented!("predictor data");
  15 /*
  16         if is_main {
  17             let predictor_reset                         = br.read_bool()?;
  18             if predictor_reset {
  19                 let predictor_reset_group_number        = br.read(5)?;
  20             }
  21             for sfb in 0..max_sfb.min(PRED_SFB_MAX) {
  22                 prediction_used[sfb]                    = br.read_bool()?;
  23             }
  24         } else {
  25             let ltp_data_present                        = br.read_bool()?;
  26             if ltp_data_present {
  27                 //ltp data
  28             }
  29             if common_window {
  30                 let ltp_data_present                    = br.read_bool()?;
  31                 if ltp_data_present {
  32                     //ltp data
  33                 }
  34             }
  35         }
  36         Ok(Some(Self { }))
  37 */
  38     }
  39 }
  40
  41 #[derive(Clone,Copy)]
  42 #[allow(dead_code)]
  43 pub struct PulseData {
  44     pub number_pulse:       usize,
  45     pub pulse_start_sfb:    usize,
  46     pub pulse_offset:       [u8; 4],
  47     pub pulse_amp:          [u8; 4],
  48 }
  49
  50 impl PulseData {
  51     pub fn read(br: &mut BitReader) -> DecoderResult<Option<Self>> {
  52         let pulse_data_present                          = br.read_bool()?;
  53         if !pulse_data_present { return Ok(None); }
  54
  55         let number_pulse                                = (br.read(2)? as usize) + 1;
  56         let pulse_start_sfb                             = br.read(6)? as usize;
  57         let mut pulse_offset: [u8; 4] = [0; 4];
  58         let mut pulse_amp: [u8; 4] = [0; 4];
  59         for i in 0..number_pulse {
  60             pulse_offset[i]                             = br.read(5)? as u8;
  61             pulse_amp[i]                                = br.read(4)? as u8;
  62         }
  63         Ok(Some(Self{ number_pulse, pulse_start_sfb, pulse_offset, pulse_amp }))
  64     }
  65 }
  66
  67 pub const TNS_MAX_ORDER: usize = 20;
  68 const TNS_MAX_LONG_BANDS: [usize; 12] = [ 31, 31, 34, 40, 42, 51, 46, 46, 42, 42, 42, 39 ];
  69 const TNS_MAX_SHORT_BANDS: [usize; 12] = [ 9, 9, 10, 14, 14, 14, 14, 14, 14, 14, 14, 14 ];
  70
  71 #[derive(Clone,Copy)]
  72 pub struct TNSCoeffs {
  73     pub length:     usize,
  74     pub order:      usize,
  75     pub direction:  bool,
  76     pub compress:   bool,
  77     pub coef:       [f32; TNS_MAX_ORDER + 1],
  78 }
  79
  80 impl TNSCoeffs {
  81     pub fn new() -> Self {
  82         Self {
  83             length: 0, order: 0, direction: false, compress: false, coef: [0.0; TNS_MAX_ORDER + 1],
  84         }
  85     }
  86     pub fn read(&mut self, br: &mut BitReader, long_win: bool, coef_res: bool, max_order: usize) -> DecoderResult<()> {
  87         self.length                                     = br.read(if long_win { 6 } else { 4 })? as usize;
  88         self.order                                      = br.read(if long_win { 5 } else { 3 })? as usize;
  89         validate!(self.order <= max_order);
  90         if self.order > 0 {
  91             self.direction                              = br.read_bool()?;
  92             self.compress                               = br.read_bool()?;
  93             let mut coef_bits = 3;
  94             if coef_res      { coef_bits += 1; }
  95             if self.compress { coef_bits -= 1; }
  96             let sign_mask = 1 << (coef_bits - 1);
  97             let neg_mask  = !(sign_mask * 2 - 1);
  98
  99             let fac_base = if coef_res { 1 << 3 } else { 1 << 2 } as f32;
 100             let iqfac   = (fac_base - 0.5) / (consts::PI / 2.0);
 101             let iqfac_m = (fac_base + 0.5) / (consts::PI / 2.0);
 102             let mut tmp: [f32; TNS_MAX_ORDER] = [0.0; TNS_MAX_ORDER];
 103             for el in tmp.iter_mut().take(self.order) {
 104                 let val                                 = br.read(coef_bits)? as i8;
 105                 let c = f32::from(if (val & sign_mask) != 0 { val | neg_mask } else { val });
 106                 *el = (if c >= 0.0 { c / iqfac } else { c / iqfac_m }).sin();
 107             }
 108             // convert to LPC coefficients
 109             let mut b: [f32; TNS_MAX_ORDER + 1] = [0.0; TNS_MAX_ORDER + 1];
 110             for m in 1..=self.order {
 111                 for i in 1..m {
 112                     b[i] = self.coef[i - 1] + tmp[m - 1] * self.coef[m - i - 1];
 113                 }
 114                 for i in 1..m {
 115                     self.coef[i - 1] = b[i];
 116                 }
 117                 self.coef[m - 1] = tmp[m - 1];
 118             }
 119         }
 120         Ok(())
 121     }
 122 }
 123
 124 #[derive(Clone,Copy)]
 125 #[allow(dead_code)]
 126 pub struct TNSData {
 127     pub n_filt: [usize; MAX_WINDOWS],
 128     coef_res:   [bool; MAX_WINDOWS],
 129     pub coeffs: [[TNSCoeffs; 4]; MAX_WINDOWS],
 130 }
 131
 132 impl TNSData {
 133     pub fn read(br: &mut BitReader, long_win: bool, num_windows: usize, max_order: usize) -> DecoderResult<Option<Self>> {
 134         let tns_data_present                            = br.read_bool()?;
 135         if !tns_data_present { return Ok(None); }
 136         let mut n_filt: [usize; MAX_WINDOWS] = [0; MAX_WINDOWS];
 137         let mut coef_res: [bool; MAX_WINDOWS] = [false; MAX_WINDOWS];
 138         let mut coeffs: [[TNSCoeffs; 4]; MAX_WINDOWS] = [[TNSCoeffs::new(); 4]; MAX_WINDOWS];
 139         for w in 0..num_windows {
 140             n_filt[w]                                   = br.read(if long_win { 2 } else { 1 })? as usize;
 141             if n_filt[w] != 0 {
 142                 coef_res[w]                             = br.read_bool()?;
 143             }
 144             for filt in 0..n_filt[w] {
 145                 coeffs[w][filt].read(br, long_win, coef_res[w], max_order)?;
 146             }
 147         }
 148         Ok(Some(Self { n_filt, coef_res, coeffs }))
 149     }
 150     pub fn apply(&self, coeffs: &mut [f32; 1024], w: usize, f: usize, start: usize, end: usize) {
 151         let order = self.coeffs[w][f].order;
 152         let lpc = &self.coeffs[w][f].coef;
 153         let mut state = [0.0f32; 64];
 154         let mut sidx = 32;
 155         if !self.coeffs[w][f].direction {
 156             for m in start..end {
 157                 for i in 0..order {
 158                     coeffs[m] -= state[(sidx + i) & 63] * lpc[i];
 159                 }
 160                 sidx = (sidx + 63) & 63;
 161                 state[sidx] = coeffs[m];
 162             }
 163         } else {
 164             for m in (start..end).rev() {
 165                 for i in 0..order {
 166                     coeffs[m] -= state[(sidx + i) & 63] * lpc[i];
 167                 }
 168                 sidx = (sidx + 63) & 63;
 169                 state[sidx] = coeffs[m];
 170             }
 171         }
 172     }
 173     pub fn get_max_bands(long_win: bool, srate_idx: usize) -> usize {
 174         if long_win {
 175             TNS_MAX_LONG_BANDS[srate_idx]
 176         } else {
 177             TNS_MAX_SHORT_BANDS[srate_idx]
 178         }
 179     }
 180 }
 181
 182 #[derive(Clone,Copy)]
 183 #[allow(dead_code)]
 184 pub struct GainControlData {
 185     max_band:       u8,
 186 }
 187
 188 impl GainControlData {
 189     pub fn read(br: &mut BitReader) -> DecoderResult<Option<Self>> {
 190         let gain_control_data_present                   = br.read_bool()?;
 191         if !gain_control_data_present { return Ok(None); }
 192 unimplemented!("gain control data");
 193 /*        self.max_band                                   = br.read(2)? as u8;
 194         if window_sequence == ONLY_LONG_SEQUENCE {
 195             for bd in 0..max_band
 196 ...
 197         }
 198         Ok(Some(Self { }))*/
 199     }
 200 }