]>
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; | |
cd72fd8a | 403 | v_dk1[num_bands1 - 1] -= change; |
0e18270d KS |
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 | ]; |