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

use nihav_core::codecs::{DecoderResult, DecoderError};
use nihav_core::io::bitreader::*;

mod bs;
mod dsp;
mod synth;

pub use bs::{SBRCodebooks, sbr_read_sce, sbr_read_cpe};
pub use dsp::SBRDSP;
pub use synth::SBRChannel;

pub const NUM_ENVELOPES: usize = 8;
pub const NUM_PATCHES:   usize = 5;
pub const SBR_BANDS:     usize = 64;
pub const QMF_DELAY:     usize = 8;
pub const HF_ADJ:        usize = 2;
pub const MAX_SLOTS:     usize = 16;

#[derive(Clone, Copy, Debug)]
pub struct SBRHeader {
    pub amp_res:        bool,
        start_freq:     usize,
        stop_freq:      usize,
        xover_band:     usize,
        freq_scale:     u8,
        alter_scale:    bool,
        noise_bands:    u8,
        limiter_bands:  u8,
        limiter_gains:  u8,
        interpol_freq:  bool,
        smoothing_mode: bool,
}

impl SBRHeader {
    pub fn new() -> Self {
        let mut obj: Self = unsafe { std::mem::zeroed() };
        obj.reset();
        obj
    }
    fn reset(&mut self) {
        self.freq_scale     = 2;
        self.alter_scale    = true;
        self.noise_bands    = 2;
        self.limiter_bands  = 2;
        self.limiter_gains  = 2;
        self.interpol_freq  = true;
        self.smoothing_mode = true;
    }

    pub fn read(br: &mut BitReader) -> DecoderResult<Self> {
        let mut sbrh = Self::new();
        sbrh.reset();
        sbrh.amp_res            = br.read_bool()?;
        sbrh.start_freq         = br.read(4)? as usize;
        sbrh.stop_freq          = br.read(4)? as usize;
        sbrh.xover_band         = br.read(3)? as usize;
                                  br.skip(2)?;
        let header_extra_1      = br.read_bool()?;
        let header_extra_2      = br.read_bool()?;
        if header_extra_1 {
            sbrh.freq_scale     = br.read(2)? as u8;
            sbrh.alter_scale    = br.read_bool()?;
            sbrh.noise_bands    = br.read(2)? as u8;
        }
        if header_extra_2 {
            sbrh.limiter_bands  = br.read(2)? as u8;
            sbrh.limiter_gains  = br.read(2)? as u8;
            sbrh.interpol_freq  = br.read_bool()?;
            if !sbrh.interpol_freq {
                return Err(DecoderError::NotImplemented);
            }
            sbrh.smoothing_mode = br.read_bool()?;
        }
        Ok(sbrh)
    }

    pub fn differs_from(&self, rval: &Self) -> bool {
        self.start_freq  != rval.start_freq ||
        self.stop_freq   != rval.stop_freq ||
        self.xover_band  != rval.xover_band ||
        self.freq_scale  != rval.freq_scale ||
        self.alter_scale != rval.alter_scale ||
        self.noise_bands != rval.noise_bands
    }
}

#[derive(Clone)]
pub struct SBRState {
    num_env_bands:          [usize; 2],
    num_master:             usize,
    num_noise_bands:        usize,
    num_lim:                usize,
    k_x:                    usize,
    low_to_high_res:        [usize; SBR_BANDS],
    high_to_low_res:        [usize; SBR_BANDS],
    f:                      [usize; SBR_BANDS],
    f_low:                  [usize; SBR_BANDS],
    f_noise:                [usize; SBR_BANDS],
    f_lim:                  [usize; SBR_BANDS],
    patch_num_subbands:     [usize; SBR_BANDS],
    patch_start_subband:    [usize; SBR_BANDS],
    num_patches:            usize,
}

impl SBRState {
    pub fn new() -> Self {
        Self {
            num_env_bands:          [0; 2],
            num_master:             0,
            num_noise_bands:        0,
            num_lim:                0,
            k_x:                    0,
            low_to_high_res:        [0; SBR_BANDS],
            high_to_low_res:        [0; SBR_BANDS],
            f:                      [0; SBR_BANDS],
            f_low:                  [0; SBR_BANDS],
            f_noise:                [0; SBR_BANDS],
            f_lim:                  [0; SBR_BANDS],
            patch_num_subbands:     [0; SBR_BANDS],
            patch_start_subband:    [0; SBR_BANDS],
            num_patches:            0,
        }
    }
    pub fn init(&mut self, hdr: &SBRHeader, srate: u32) -> DecoderResult<()> {
        let offset_tab = match srate {
                    0..=16000 => &SBR_OFFSETS[0],
                16001..=22050 => &SBR_OFFSETS[1],
                22051..=24000 => &SBR_OFFSETS[2],
                24001..=32000 => &SBR_OFFSETS[3],
                32001..=64000 => &SBR_OFFSETS[4],
                            _ => &SBR_OFFSETS[5],
            };
        let smult = match srate {
                    0..=31999 => 3000,
                32000..=63999 => 4000,
                            _ => 5000,
            };
        let start_min = (128 * smult     + srate / 2) / srate;
        let stop_min  = (128 * smult * 2 + srate / 2) / srate;

        let k0 = ((start_min as i32) + i32::from(offset_tab[hdr.start_freq])).max(0) as usize;
        let k2 = (match hdr.stop_freq {
                14 => 2 * k0,
                15 => 3 * k0,
                 _ => {
                    let mut stop_dk = [0; 14];
                    generate_vdk(&mut stop_dk, stop_min as usize, SBR_BANDS, 13);
                    let dk_sum: usize = stop_dk[..hdr.stop_freq].iter().sum();
                    (stop_min as usize) + dk_sum
                },
            }).min(SBR_BANDS);

        let max_bands = match srate {
                    0..=32000 => 48,
                32001..=47999 => 35,
                            _ => 32,
            };
        validate!(k2 - k0 <= max_bands);

        self.num_master = calculate_master_frequencies(&mut self.f, k0, k2, hdr);
        let num_high = self.num_master - hdr.xover_band;
        let num_low = (num_high + 1) / 2; // INT(num_high / 2) + (num_high - 2 * INT(num_high / 2))

        self.num_env_bands = [num_low, num_high];

        let f_high = &self.f[hdr.xover_band..];
        let m = f_high[num_high] - f_high[0];
        let k_x = f_high[0];
        self.k_x = k_x;
        self.f_low = [0; SBR_BANDS];
        if (num_high & 1) == 0 {
            for k in 0..=num_low {
                self.f_low[k] = f_high[k * 2];
            }
        } else {
            self.f_low[0] = f_high[0];
            for k in 1..=num_low {
                self.f_low[k] = f_high[k * 2 - 1];
            }
        }

        let high_src = &f_high[..=num_high];
        let low_src = &self.f_low[..=num_low];
        for (dst, low) in self.high_to_low_res.iter_mut().zip(low_src.iter()) {
            if let Ok(idx) = high_src.binary_search(low) {
                *dst = idx;
            } else {
                return Err(DecoderError::Bug);
            }
        }
        for (dst, high) in self.low_to_high_res.iter_mut().zip(high_src.iter()) {
            match low_src.binary_search(high) {
                Ok(idx) | Err(idx) => *dst = idx,
            };
        }

        let num_q = (((hdr.noise_bands as f32) * ((k2 as f32) / (k_x as f32)).log2()).round() as usize).max(1);
        self.num_noise_bands = num_q;
        self.f_noise = [0; SBR_BANDS];
        let mut prev = 0;
        self.f_noise[0] = self.f_low[0];
        for k in 1..=num_q {
            let idx = prev + ((num_low - prev) / (num_q + 1 - k));
            self.f_noise[k] = self.f_low[idx];
            prev = idx;
        }

        let mut num_patches = 0;
        self.patch_num_subbands = [0; SBR_BANDS];
        self.patch_start_subband = [0; SBR_BANDS];
        let mut msb = k0;
        let mut usb = k_x;
        let goal_sb = ((2048000 + srate / 2) / srate) as usize;
        let last_band = k_x + m;
        let mut k = if goal_sb < last_band {
                let mut kk = 0;
                for i in 0..self.num_master {
                    if self.f[i] >= goal_sb {
                        break;
                    }
                    kk = i + 1;
                }
                kk
            } else {
                self.num_master
            };
        loop {
            let mut sb;
            let mut odd;
            let mut j = k;
            loop {
                sb = self.f[j];
                odd = (sb - 2 + k0) & 1;
                if sb <= k0 + msb - 1 - odd {
                    break;
                }
                j -= 1;
            }

            self.patch_num_subbands[num_patches] = sb.saturating_sub(usb);
            self.patch_start_subband[num_patches] = k0 - odd - self.patch_num_subbands[num_patches];

            if self.patch_num_subbands[num_patches] > 0 {
                usb = sb;
                msb = sb;
                num_patches += 1;
            } else {
                msb = k_x;
            }

            if self.f[k] < sb + 3 {
                k = self.num_master;
            }

            if sb == last_band {
                break;
            }
        }
        if (num_patches > 1) && (self.patch_num_subbands[num_patches - 1] < 3) {
            num_patches -= 1;
        }
        validate!(num_patches <= NUM_PATCHES);
        self.num_patches = num_patches;

        self.f_lim = [0; SBR_BANDS];
        let num_l = if hdr.limiter_bands == 0 {
                self.f_lim[0] = self.f_low[0];
                self.f_lim[1] = self.f_low[num_low];
                1
            } else {
                let lim_bands = match hdr.limiter_bands {
                        1 => 1.2f32,
                        2 => 2.0,
                        _ => 3.0,
                    };
                let mut patch_borders = [0; NUM_PATCHES + 1];
                patch_borders[0] = k_x;
                for k in 0..num_patches {
                    patch_borders[k + 1] = patch_borders[k] + self.patch_num_subbands[k];
                }
                self.f_lim = self.f_low;
                let f_lim_ptr = &mut self.f_lim[..num_low + num_patches];
                for &pborder in patch_borders[1..num_patches].iter() {
                    let mut i = 0;
                    for &el in f_lim_ptr.iter() {
                        if el > pborder {
                            break;
                        }
                        i += 1;
                    }
                    for j in (i..num_low + num_patches - 1).rev() {
                        f_lim_ptr[j + 1] = f_lim_ptr[j];
                    }
                    f_lim_ptr[i] = pborder;
                }
                let mut nr_lim = num_low + num_patches - 1;
                let mut k = 1;
                let pbord = &patch_borders[..=num_patches];
                while k <= nr_lim {
                    let n_octaves = ((self.f_lim[k] as f32) / (self.f_lim[k - 1] as f32)).log2();
                    if (n_octaves * lim_bands) < 0.49 {
                        if self.f_lim[k] == self.f_lim[k - 1] || !pbord.contains(&self.f_lim[k]) {
                            for l in k..nr_lim {
                                self.f_lim[l] = self.f_lim[l + 1];
                            }
                            nr_lim -= 1;
                        } else if !pbord.contains(&self.f_lim[k - 1]) {
                            for l in (k - 1)..nr_lim {
                                self.f_lim[l] = self.f_lim[l + 1];
                            }
                            nr_lim -= 1;
                        } else {
                            k += 1;
                        }
                    } else {
                        k += 1;
                    }
                }

                nr_lim
            };
        self.num_lim = num_l;

        Ok(())
    }
}

fn generate_vdk(v_dk: &mut [usize], k0: usize, k1: usize, num_bands: usize) {
    let mut last = k0;
    let k0 = k0 as f64;
    let factor = (k1 as f64) / k0;
    for k in 0..num_bands {
        let next = (k0 * factor.powf((k + 1) as f64 / (num_bands as f64))).round() as usize;
        let newval = next - last;
        last = next;
        let mut idx = k;
        for (j, &el) in v_dk[..k].iter().enumerate() {
            if newval < el {
                idx = j;
                break;
            }
        }
        for j in (idx..k).rev() {
            v_dk[j + 1] = v_dk[j];
        }
        v_dk[idx] = newval;
    }
}

fn calculate_master_frequencies(f: &mut [usize; SBR_BANDS], k0: usize, k2: usize, hdr: &SBRHeader) -> usize {
    if hdr.freq_scale == 0 {
        let (dk, num_bands) = if !hdr.alter_scale {
                (1, 2 * ((k2 - k0) / 2))
            } else {
                (2, 2 * ((k2 - k0 + 2) / (2 * 2)))
            };
        let k2_achieved = k0 + num_bands * dk;
        let mut k2_diff = (k2 as isize) - (k2_achieved as isize);
        let mut v_dk = [dk; SBR_BANDS];
        if k2_diff < 0 {
            let mut k = 0;
            while k2_diff != 0 {
                v_dk[k] -= 1;
                k += 1;
                k2_diff += 1;
            }
        } else if k2_diff > 0 {
            let mut k = num_bands - 1;
            while k2_diff != 0 {
                v_dk[k] += 1;
                k -= 1;
                k2_diff -= 1;
            }
        }
        f[0] = k0;
        for i in 0..num_bands {
            f[i + 1] = f[i] + v_dk[i];
        }

        num_bands
    } else {
        let bands = 14 - hdr.freq_scale * 2;
        let warp = if !hdr.alter_scale { 1.0f32 } else { 1.3f32 };
        let two_regions = (k2 as f32) / (k0 as f32) > 2.2449;
        let k1 = if two_regions { 2 * k0 } else { k2 };
        let num_bands0 = 2 * (((bands as f32) * ((k1 as f32) / (k0 as f32)).log2() / 2.0).round() as usize);
        let mut v_dk0 = [0; SBR_BANDS];
        generate_vdk(&mut v_dk0, k0, k1, num_bands0);
        let mut v_k0 = [0; SBR_BANDS];
        v_k0[0] = k0;
        for i in 0..num_bands0 {
            v_k0[i + 1] = v_k0[i] + v_dk0[i];
        }

        if two_regions {
            let num_bands1 = 2 * (((bands as f32) * ((k2 as f32) / (k1 as f32)).log2() / (2.0 * warp)).round() as usize);
            let mut v_dk1 = [0; SBR_BANDS];
            generate_vdk(&mut v_dk1, k1, k2, num_bands1);
            let max_vdk0 = v_dk0[num_bands0 - 1];
            if v_dk1[0] < max_vdk0 {
                let change = (max_vdk0 - v_dk1[0]).min((v_dk1[num_bands1 - 1] - v_dk1[0]) / 2);
                v_dk1[0] += change;
                v_dk1[num_bands1 - 1] -= change; 
            }
            let mut v_k1 = [0; SBR_BANDS];
            v_k1[0] = k1;
            for i in 0..num_bands1 {
                v_k1[i + 1] = v_k1[i] + v_dk1[i];
            }
            f[..=num_bands0].copy_from_slice(&v_k0[..=num_bands0]);
            f[num_bands0 + 1..][..=num_bands1].copy_from_slice(&v_k1[1..][..=num_bands1]);
            num_bands0 + num_bands1
        } else {
            f[..=num_bands0].copy_from_slice(&v_k0[..=num_bands0]);
            num_bands0
        }
    }
}

const SBR_OFFSETS: [[i8; 16]; 6] = [
    [ -8, -7, -6, -5, -4, -3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7 ], // 16kHz
    [ -5, -4, -3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  9, 11, 13 ], // 22kHz
    [ -5, -3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  9, 11, 13, 16 ], // 24kHz
    [ -6, -4, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  9, 11, 13, 16 ], // 32kHz
    [ -4, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  9, 11, 13, 16, 20 ], // 44kHz
    [ -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  9, 11, 13, 16, 20, 24 ]  // 64kHz
];
Commit	Line	Data
0e18270d KS	1	use nihav_core::codecs::{DecoderResult, DecoderError};
	2	use nihav_core::io::bitreader::*;
	3
	4	mod bs;
	5	mod dsp;
	6	mod synth;
	7
	8	pub use bs::{SBRCodebooks, sbr_read_sce, sbr_read_cpe};
	9	pub use dsp::SBRDSP;
	10	pub use synth::SBRChannel;
	11
	12	pub const NUM_ENVELOPES: usize = 8;
	13	pub const NUM_PATCHES: usize = 5;
	14	pub const SBR_BANDS: usize = 64;
	15	pub const QMF_DELAY: usize = 8;
	16	pub const HF_ADJ: usize = 2;
	17	pub const MAX_SLOTS: usize = 16;
	18
	19	#[derive(Clone, Copy, Debug)]
	20	pub struct SBRHeader {
	21	pub amp_res: bool,
	22	start_freq: usize,
	23	stop_freq: usize,
	24	xover_band: usize,
	25	freq_scale: u8,
	26	alter_scale: bool,
	27	noise_bands: u8,
	28	limiter_bands: u8,
	29	limiter_gains: u8,
	30	interpol_freq: bool,
	31	smoothing_mode: bool,
	32	}
	33
	34	impl SBRHeader {
	35	pub fn new() -> Self {
	36	let mut obj: Self = unsafe { std::mem::zeroed() };
	37	obj.reset();
	38	obj
	39	}
	40	fn reset(&mut self) {
	41	self.freq_scale = 2;
	42	self.alter_scale = true;
	43	self.noise_bands = 2;
	44	self.limiter_bands = 2;
	45	self.limiter_gains = 2;
	46	self.interpol_freq = true;
	47	self.smoothing_mode = true;
	48	}
	49
	50	pub fn read(br: &mut BitReader) -> DecoderResult<Self> {
	51	let mut sbrh = Self::new();
	52	sbrh.reset();
	53	sbrh.amp_res = br.read_bool()?;
	54	sbrh.start_freq = br.read(4)? as usize;
	55	sbrh.stop_freq = br.read(4)? as usize;
	56	sbrh.xover_band = br.read(3)? as usize;
	57	br.skip(2)?;
	58	let header_extra_1 = br.read_bool()?;
	59	let header_extra_2 = br.read_bool()?;
	60	if header_extra_1 {
	61	sbrh.freq_scale = br.read(2)? as u8;
	62	sbrh.alter_scale = br.read_bool()?;
	63	sbrh.noise_bands = br.read(2)? as u8;
	64	}
65	if header_extra_2 {
66	sbrh.limiter_bands = br.read(2)? as u8;
67	sbrh.limiter_gains = br.read(2)? as u8;
68	sbrh.interpol_freq = br.read_bool()?;
69	if !sbrh.interpol_freq {
70	return Err(DecoderError::NotImplemented);
71	}
72	sbrh.smoothing_mode = br.read_bool()?;
73	}
74	Ok(sbrh)
75	}
76
77	pub fn differs_from(&self, rval: &Self) -> bool {
78	self.start_freq != rval.start_freq \|\|
79	self.stop_freq != rval.stop_freq \|\|
80	self.xover_band != rval.xover_band \|\|
81	self.freq_scale != rval.freq_scale \|\|
82	self.alter_scale != rval.alter_scale \|\|
83	self.noise_bands != rval.noise_bands
84	}
85	}
86
87	#[derive(Clone)]
88	pub struct SBRState {
89	num_env_bands: [usize; 2],
90	num_master: usize,
91	num_noise_bands: usize,
92	num_lim: usize,
93	k_x: usize,
94	low_to_high_res: [usize; SBR_BANDS],
95	high_to_low_res: [usize; SBR_BANDS],
96	f: [usize; SBR_BANDS],
97	f_low: [usize; SBR_BANDS],
98	f_noise: [usize; SBR_BANDS],
99	f_lim: [usize; SBR_BANDS],
100	patch_num_subbands: [usize; SBR_BANDS],
101	patch_start_subband: [usize; SBR_BANDS],
102	num_patches: usize,
103	}
104
105	impl SBRState {
106	pub fn new() -> Self {
107	Self {
108	num_env_bands: [0; 2],
109	num_master: 0,
110	num_noise_bands: 0,
111	num_lim: 0,
112	k_x: 0,
113	low_to_high_res: [0; SBR_BANDS],
114	high_to_low_res: [0; SBR_BANDS],
115	f: [0; SBR_BANDS],
116	f_low: [0; SBR_BANDS],
117	f_noise: [0; SBR_BANDS],
118	f_lim: [0; SBR_BANDS],
119	patch_num_subbands: [0; SBR_BANDS],
120	patch_start_subband: [0; SBR_BANDS],
121	num_patches: 0,
122	}
123	}
124	pub fn init(&mut self, hdr: &SBRHeader, srate: u32) -> DecoderResult<()> {
125	let offset_tab = match srate {
126	0..=16000 => &SBR_OFFSETS[0],
127	16001..=22050 => &SBR_OFFSETS[1],
128	22051..=24000 => &SBR_OFFSETS[2],
129	24001..=32000 => &SBR_OFFSETS[3],
130	32001..=64000 => &SBR_OFFSETS[4],
131	_ => &SBR_OFFSETS[5],
132	};
133	let smult = match srate {
134	0..=31999 => 3000,
135	32000..=63999 => 4000,
136	_ => 5000,
137	};
138	let start_min = (128 * smult + srate / 2) / srate;
139	let stop_min = (128 * smult * 2 + srate / 2) / srate;
140
141	let k0 = ((start_min as i32) + i32::from(offset_tab[hdr.start_freq])).max(0) as usize;
142	let k2 = (match hdr.stop_freq {
143	14 => 2 * k0,
144	15 => 3 * k0,
145	_ => {
146	let mut stop_dk = [0; 14];
147	generate_vdk(&mut stop_dk, stop_min as usize, SBR_BANDS, 13);
148	let dk_sum: usize = stop_dk[..hdr.stop_freq].iter().sum();
149	(stop_min as usize) + dk_sum
150	},
151	}).min(SBR_BANDS);
152
153	let max_bands = match srate {
154	0..=32000 => 48,
155	32001..=47999 => 35,
156	_ => 32,
157	};
158	validate!(k2 - k0 <= max_bands);
159
160	self.num_master = calculate_master_frequencies(&mut self.f, k0, k2, hdr);
161	let num_high = self.num_master - hdr.xover_band;
162	let num_low = (num_high + 1) / 2; // INT(num_high / 2) + (num_high - 2 * INT(num_high / 2))
163
164	self.num_env_bands = [num_low, num_high];
165
166	let f_high = &self.f[hdr.xover_band..];
167	let m = f_high[num_high] - f_high[0];
168	let k_x = f_high[0];
169	self.k_x = k_x;
170	self.f_low = [0; SBR_BANDS];
171	if (num_high & 1) == 0 {
172	for k in 0..=num_low {
173	self.f_low[k] = f_high[k * 2];
174	}
175	} else {
176	self.f_low[0] = f_high[0];
177	for k in 1..=num_low {
178	self.f_low[k] = f_high[k * 2 - 1];
179	}
180	}
181
182	let high_src = &f_high[..=num_high];
183	let low_src = &self.f_low[..=num_low];
184	for (dst, low) in self.high_to_low_res.iter_mut().zip(low_src.iter()) {
185	if let Ok(idx) = high_src.binary_search(low) {
186	*dst = idx;
187	} else {
188	return Err(DecoderError::Bug);
189	}
190	}
191	for (dst, high) in self.low_to_high_res.iter_mut().zip(high_src.iter()) {
192	match low_src.binary_search(high) {
193	Ok(idx) \| Err(idx) => *dst = idx,
194	};
195	}
196
197	let num_q = (((hdr.noise_bands as f32) * ((k2 as f32) / (k_x as f32)).log2()).round() as usize).max(1);
198	self.num_noise_bands = num_q;
199	self.f_noise = [0; SBR_BANDS];
200	let mut prev = 0;
201	self.f_noise[0] = self.f_low[0];
202	for k in 1..=num_q {
203	let idx = prev + ((num_low - prev) / (num_q + 1 - k));
204	self.f_noise[k] = self.f_low[idx];
205	prev = idx;
206	}
207
208	let mut num_patches = 0;
209	self.patch_num_subbands = [0; SBR_BANDS];
210	self.patch_start_subband = [0; SBR_BANDS];
211	let mut msb = k0;
212	let mut usb = k_x;
213	let goal_sb = ((2048000 + srate / 2) / srate) as usize;
214	let last_band = k_x + m;
215	let mut k = if goal_sb < last_band {
216	let mut kk = 0;
217	for i in 0..self.num_master {
218	if self.f[i] >= goal_sb {
219	break;
220	}
221	kk = i + 1;
222	}
223	kk
224	} else {
225	self.num_master
226	};
227	loop {
228	let mut sb;
229	let mut odd;
230	let mut j = k;
231	loop {
232	sb = self.f[j];
233	odd = (sb - 2 + k0) & 1;
234	if sb <= k0 + msb - 1 - odd {
235	break;
236	}
237	j -= 1;
238	}
239
240	self.patch_num_subbands[num_patches] = sb.saturating_sub(usb);
241	self.patch_start_subband[num_patches] = k0 - odd - self.patch_num_subbands[num_patches];
242
243	if self.patch_num_subbands[num_patches] > 0 {
244	usb = sb;
245	msb = sb;
246	num_patches += 1;
247	} else {
248	msb = k_x;
249	}
250
251	if self.f[k] < sb + 3 {
252	k = self.num_master;
253	}
254
255	if sb == last_band {
256	break;
257	}
258	}
259	if (num_patches > 1) && (self.patch_num_subbands[num_patches - 1] < 3) {
260	num_patches -= 1;
261	}
262	validate!(num_patches <= NUM_PATCHES);
263	self.num_patches = num_patches;
264
265	self.f_lim = [0; SBR_BANDS];
266	let num_l = if hdr.limiter_bands == 0 {
267	self.f_lim[0] = self.f_low[0];
268	self.f_lim[1] = self.f_low[num_low];
269	1
270	} else {
271	let lim_bands = match hdr.limiter_bands {
272	1 => 1.2f32,
273	2 => 2.0,
274	_ => 3.0,
275	};
276	let mut patch_borders = [0; NUM_PATCHES + 1];
277	patch_borders[0] = k_x;
278	for k in 0..num_patches {
279	patch_borders[k + 1] = patch_borders[k] + self.patch_num_subbands[k];
280	}
281	self.f_lim = self.f_low;
282	let f_lim_ptr = &mut self.f_lim[..num_low + num_patches];
283	for &pborder in patch_borders[1..num_patches].iter() {
284	let mut i = 0;
285	for &el in f_lim_ptr.iter() {
286	if el > pborder {
287	break;
288	}
289	i += 1;
290	}
291	for j in (i..num_low + num_patches - 1).rev() {
292	f_lim_ptr[j + 1] = f_lim_ptr[j];
293	}
294	f_lim_ptr[i] = pborder;
295	}
296	let mut nr_lim = num_low + num_patches - 1;
297	let mut k = 1;
298	let pbord = &patch_borders[..=num_patches];
299	while k <= nr_lim {
300	let n_octaves = ((self.f_lim[k] as f32) / (self.f_lim[k - 1] as f32)).log2();
301	if (n_octaves * lim_bands) < 0.49 {
302	if self.f_lim[k] == self.f_lim[k - 1] \|\| !pbord.contains(&self.f_lim[k]) {
303	for l in k..nr_lim {
304	self.f_lim[l] = self.f_lim[l + 1];
305	}
306	nr_lim -= 1;
307	} else if !pbord.contains(&self.f_lim[k - 1]) {
308	for l in (k - 1)..nr_lim {
309	self.f_lim[l] = self.f_lim[l + 1];
310	}
311	nr_lim -= 1;
312	} else {
313	k += 1;
314	}
315	} else {
316	k += 1;
317	}
318	}
319
320	nr_lim
321	};
322	self.num_lim = num_l;
323
324	Ok(())
325	}
326	}
327
328	fn generate_vdk(v_dk: &mut [usize], k0: usize, k1: usize, num_bands: usize) {
329	let mut last = k0;
330	let k0 = k0 as f64;
331	let factor = (k1 as f64) / k0;
332	for k in 0..num_bands {
333	let next = (k0 * factor.powf((k + 1) as f64 / (num_bands as f64))).round() as usize;
334	let newval = next - last;
335	last = next;
336	let mut idx = k;
337	for (j, &el) in v_dk[..k].iter().enumerate() {
338	if newval < el {
339	idx = j;
340	break;
341	}
342	}
343	for j in (idx..k).rev() {
344	v_dk[j + 1] = v_dk[j];
345	}
346	v_dk[idx] = newval;
347	}
348	}
349
350	fn calculate_master_frequencies(f: &mut [usize; SBR_BANDS], k0: usize, k2: usize, hdr: &SBRHeader) -> usize {
351	if hdr.freq_scale == 0 {
352	let (dk, num_bands) = if !hdr.alter_scale {
353	(1, 2 * ((k2 - k0) / 2))
354	} else {
355	(2, 2 * ((k2 - k0 + 2) / (2 * 2)))
356	};
357	let k2_achieved = k0 + num_bands * dk;
358	let mut k2_diff = (k2 as isize) - (k2_achieved as isize);
359	let mut v_dk = [dk; SBR_BANDS];
360	if k2_diff < 0 {
361	let mut k = 0;
362	while k2_diff != 0 {
363	v_dk[k] -= 1;
364	k += 1;
365	k2_diff += 1;
366	}
367	} else if k2_diff > 0 {
368	let mut k = num_bands - 1;
369	while k2_diff != 0 {
370	v_dk[k] += 1;
371	k -= 1;
372	k2_diff -= 1;
373	}
374	}
375	f[0] = k0;
376	for i in 0..num_bands {
377	f[i + 1] = f[i] + v_dk[i];
378	}
379
380	num_bands
381	} else {
382	let bands = 14 - hdr.freq_scale * 2;
383	let warp = if !hdr.alter_scale { 1.0f32 } else { 1.3f32 };
384	let two_regions = (k2 as f32) / (k0 as f32) > 2.2449;
385	let k1 = if two_regions { 2 * k0 } else { k2 };
386	let num_bands0 = 2 * (((bands as f32) * ((k1 as f32) / (k0 as f32)).log2() / 2.0).round() as usize);
387	let mut v_dk0 = [0; SBR_BANDS];
388	generate_vdk(&mut v_dk0, k0, k1, num_bands0);
389	let mut v_k0 = [0; SBR_BANDS];
390	v_k0[0] = k0;
391	for i in 0..num_bands0 {
392	v_k0[i + 1] = v_k0[i] + v_dk0[i];
393	}
394
395	if two_regions {
396	let num_bands1 = 2 * (((bands as f32) * ((k2 as f32) / (k1 as f32)).log2() / (2.0 * warp)).round() as usize);
397	let mut v_dk1 = [0; SBR_BANDS];
398	generate_vdk(&mut v_dk1, k1, k2, num_bands1);
399	let max_vdk0 = v_dk0[num_bands0 - 1];
400	if v_dk1[0] < max_vdk0 {
401	let change = (max_vdk0 - v_dk1[0]).min((v_dk1[num_bands1 - 1] - v_dk1[0]) / 2);
402	v_dk1[0] += change;
403	v_dk1[num_bands1 - 1] -= change;
404	}
405	let mut v_k1 = [0; SBR_BANDS];
406	v_k1[0] = k1;
407	for i in 0..num_bands1 {
408	v_k1[i + 1] = v_k1[i] + v_dk1[i];
409	}
410	f[..=num_bands0].copy_from_slice(&v_k0[..=num_bands0]);
411	f[num_bands0 + 1..][..=num_bands1].copy_from_slice(&v_k1[1..][..=num_bands1]);
412	num_bands0 + num_bands1
413	} else {
414	f[..=num_bands0].copy_from_slice(&v_k0[..=num_bands0]);
415	num_bands0
416	}
417	}
418	}
419
420	const SBR_OFFSETS: [[i8; 16]; 6] = [
421	[ -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7 ], // 16kHz
422	[ -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13 ], // 22kHz
423	[ -5, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16 ], // 24kHz
424	[ -6, -4, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16 ], // 32kHz
425	[ -4, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 20 ], // 44kHz
426	[ -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 20, 24 ] // 64kHz
427	];