[nihav.git] / nihav-mpeg / src / codecs / aac / tools.rs

use nihav_core::codecs::{DecoderResult, DecoderError};
use nihav_core::io::bitreader::*;
use std::f32::consts;
use super::MAX_WINDOWS;

#[derive(Clone,Copy)]
pub struct LTPData {
}

impl LTPData {
    pub fn read(br: &mut BitReader) -> DecoderResult<Option<Self>> {
        let predictor_data_present                      = br.read_bool()?;
        if !predictor_data_present { return Ok(None); }
unimplemented!("predictor data");
/*
        if is_main {
            let predictor_reset                         = br.read_bool()?;
            if predictor_reset {
                let predictor_reset_group_number        = br.read(5)?;
            }
            for sfb in 0..max_sfb.min(PRED_SFB_MAX) {
                prediction_used[sfb]                    = br.read_bool()?;
            }
        } else {
            let ltp_data_present                        = br.read_bool()?;
            if ltp_data_present {
                //ltp data
            }
            if common_window {
                let ltp_data_present                    = br.read_bool()?;
                if ltp_data_present {
                    //ltp data
                }
            }
        }
        Ok(Some(Self { }))
*/
    }
}

#[derive(Clone,Copy)]
#[allow(dead_code)]
pub struct PulseData {
    pub number_pulse:       usize,
    pub pulse_start_sfb:    usize,
    pub pulse_offset:       [u8; 4],
    pub pulse_amp:          [u8; 4],
}

impl PulseData {
    pub fn read(br: &mut BitReader) -> DecoderResult<Option<Self>> {
        let pulse_data_present                          = br.read_bool()?;
        if !pulse_data_present { return Ok(None); }

        let number_pulse                                = (br.read(2)? as usize) + 1;
        let pulse_start_sfb                             = br.read(6)? as usize;
        let mut pulse_offset: [u8; 4] = [0; 4];
        let mut pulse_amp: [u8; 4] = [0; 4];
        for i in 0..number_pulse {
            pulse_offset[i]                             = br.read(5)? as u8;
            pulse_amp[i]                                = br.read(4)? as u8;
        }
        Ok(Some(Self{ number_pulse, pulse_start_sfb, pulse_offset, pulse_amp }))
    }
}

pub const TNS_MAX_ORDER: usize = 20;
const TNS_MAX_LONG_BANDS: [usize; 12] = [ 31, 31, 34, 40, 42, 51, 46, 46, 42, 42, 42, 39 ];
const TNS_MAX_SHORT_BANDS: [usize; 12] = [ 9, 9, 10, 14, 14, 14, 14, 14, 14, 14, 14, 14 ];

#[derive(Clone,Copy)]
pub struct TNSCoeffs {
    pub length:     usize,
    pub order:      usize,
    pub direction:  bool,
    pub compress:   bool,
    pub coef:       [f32; TNS_MAX_ORDER + 1],
}

impl TNSCoeffs {
    pub fn new() -> Self {
        Self {
            length: 0, order: 0, direction: false, compress: false, coef: [0.0; TNS_MAX_ORDER + 1],
        }
    }
    pub fn read(&mut self, br: &mut BitReader, long_win: bool, coef_res: bool, max_order: usize) -> DecoderResult<()> {
        self.length                                     = br.read(if long_win { 6 } else { 4 })? as usize;
        self.order                                      = br.read(if long_win { 5 } else { 3 })? as usize;
        validate!(self.order <= max_order);
        if self.order > 0 {
            self.direction                              = br.read_bool()?;
            self.compress                               = br.read_bool()?;
            let mut coef_bits = 3;
            if coef_res      { coef_bits += 1; }
            if self.compress { coef_bits -= 1; }
            let sign_mask = 1 << (coef_bits - 1);
            let neg_mask  = !(sign_mask * 2 - 1);

            let fac_base = if coef_res { 1 << 3 } else { 1 << 2 } as f32;
            let iqfac   = (fac_base - 0.5) / (consts::PI / 2.0);
            let iqfac_m = (fac_base + 0.5) / (consts::PI / 2.0);
            let mut tmp: [f32; TNS_MAX_ORDER] = [0.0; TNS_MAX_ORDER];
            for el in tmp.iter_mut().take(self.order) {
                let val                                 = br.read(coef_bits)? as i8;
                let c = f32::from(if (val & sign_mask) != 0 { val | neg_mask } else { val });
                *el = (if c >= 0.0 { c / iqfac } else { c / iqfac_m }).sin();
            }
            // convert to LPC coefficients
            let mut b: [f32; TNS_MAX_ORDER + 1] = [0.0; TNS_MAX_ORDER + 1];
            for m in 1..=self.order {
                for i in 1..m {
                    b[i] = self.coef[i - 1] + tmp[m - 1] * self.coef[m - i - 1];
                }
                for i in 1..m {
                    self.coef[i - 1] = b[i];
                }
                self.coef[m - 1] = tmp[m - 1];
            }
        }
        Ok(())
    }
}

#[derive(Clone,Copy)]
#[allow(dead_code)]
pub struct TNSData {
    pub n_filt: [usize; MAX_WINDOWS],
    coef_res:   [bool; MAX_WINDOWS],
    pub coeffs: [[TNSCoeffs; 4]; MAX_WINDOWS],
}

impl TNSData {
    pub fn read(br: &mut BitReader, long_win: bool, num_windows: usize, max_order: usize) -> DecoderResult<Option<Self>> {
        let tns_data_present                            = br.read_bool()?;
        if !tns_data_present { return Ok(None); }
        let mut n_filt: [usize; MAX_WINDOWS] = [0; MAX_WINDOWS];
        let mut coef_res: [bool; MAX_WINDOWS] = [false; MAX_WINDOWS];
        let mut coeffs: [[TNSCoeffs; 4]; MAX_WINDOWS] = [[TNSCoeffs::new(); 4]; MAX_WINDOWS];
        for w in 0..num_windows {
            n_filt[w]                                   = br.read(if long_win { 2 } else { 1 })? as usize;
            if n_filt[w] != 0 {
                coef_res[w]                             = br.read_bool()?;
            }
            for filt in 0..n_filt[w] {
                coeffs[w][filt].read(br, long_win, coef_res[w], max_order)?;
            }
        }
        Ok(Some(Self { n_filt, coef_res, coeffs }))
    }
    pub fn apply(&self, coeffs: &mut [f32; 1024], w: usize, f: usize, start: usize, end: usize) {
        let order = self.coeffs[w][f].order;
        let lpc = &self.coeffs[w][f].coef;
        let mut state = [0.0f32; 64];
        let mut sidx = 32;
        if !self.coeffs[w][f].direction {
            for m in start..end {
                for i in 0..order {
                    coeffs[m] -= state[(sidx + i) & 63] * lpc[i];
                }
                sidx = (sidx + 63) & 63;
                state[sidx] = coeffs[m];
            }
        } else {
            for m in (start..end).rev() {
                for i in 0..order {
                    coeffs[m] -= state[(sidx + i) & 63] * lpc[i];
                }
                sidx = (sidx + 63) & 63;
                state[sidx] = coeffs[m];
            }
        }
    }
    pub fn get_max_bands(long_win: bool, srate_idx: usize) -> usize {
        if long_win {
            TNS_MAX_LONG_BANDS[srate_idx]
        } else {
            TNS_MAX_SHORT_BANDS[srate_idx]
        }
    }
}

#[derive(Clone,Copy)]
#[allow(dead_code)]
pub struct GainControlData {
    max_band:       u8,
}

impl GainControlData {
    pub fn read(br: &mut BitReader) -> DecoderResult<Option<Self>> {
        let gain_control_data_present                   = br.read_bool()?;
        if !gain_control_data_present { return Ok(None); }
unimplemented!("gain control data");
/*        self.max_band                                   = br.read(2)? as u8;
        if window_sequence == ONLY_LONG_SEQUENCE {
            for bd in 0..max_band
...
        }
        Ok(Some(Self { }))*/
    }
}
Commit	Line	Data
999c25f7 KS	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	}