| 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 | ]; |