]> git.nihav.org Git - nihav.git/blame - nihav-duck/src/codecs/on2avc.rs
make audio decoder tests write .wav files only by request
[nihav.git] / nihav-duck / src / codecs / on2avc.rs
CommitLineData
6a494288
KS
1use nihav_core::frame::*;
2use nihav_core::codecs::*;
3use nihav_core::io::byteio::read_u16le;
4use nihav_core::io::bitreader::*;
5use nihav_core::io::codebook::*;
6use nihav_core::io::intcode::*;
7use nihav_core::dsp::fft::*;
8use nihav_core::dsp::mdct::IMDCT;
9
10use std::str::FromStr;
11
12use super::on2avcdata::*;
13
14const COEFFS: usize = 1024;
15const MAX_BANDS: usize = 14 * 8;
16const QTAB_SIZE: usize = 10000;
17const SHORT_WIN_POINT0: usize = 512 - 64;
18const SHORT_WIN_POINT1: usize = 512 + 64;
19
20struct WinInfo {
21 is_long: bool,
22 bands: &'static [usize],
23}
24
25impl WinInfo {
26 fn get_tot_bands(&self) -> usize {
27 if self.is_long {
28 self.bands.len()
29 } else {
30 self.bands.len() * 8
31 }
32 }
33}
34
35struct Codebooks {
36 scale_cb: Codebook<i8>,
37 spec_cb: [Codebook<u16>; 15],
38}
39
40fn scale_map(idx: usize) -> i8 { (idx as i8) - 60 }
41fn cb_map1(idx: usize) -> u16 { AVC_SPEC_CB1_SYMS[idx] }
42fn cb_map2(idx: usize) -> u16 { AVC_SPEC_CB2_SYMS[idx] }
43fn cb_map3(idx: usize) -> u16 { AVC_SPEC_CB3_SYMS[idx] }
44fn cb_map4(idx: usize) -> u16 { AVC_SPEC_CB4_SYMS[idx] }
45fn cb_map5(idx: usize) -> u16 { AVC_SPEC_CB5_SYMS[idx] }
46fn cb_map6(idx: usize) -> u16 { AVC_SPEC_CB6_SYMS[idx] }
47fn cb_map7(idx: usize) -> u16 { AVC_SPEC_CB7_SYMS[idx] }
48fn cb_map8(idx: usize) -> u16 { AVC_SPEC_CB8_SYMS[idx] }
49fn cb_map9(idx: usize) -> u16 { AVC_SPEC_CB9_SYMS[idx] }
50fn cb_map10(idx: usize) -> u16 { AVC_SPEC_CB10_SYMS[idx] }
51fn cb_map11(idx: usize) -> u16 { AVC_SPEC_CB11_SYMS[idx] }
52fn cb_map12(idx: usize) -> u16 { AVC_SPEC_CB12_SYMS[idx] }
53fn cb_map13(idx: usize) -> u16 { AVC_SPEC_CB13_SYMS[idx] }
54fn cb_map14(idx: usize) -> u16 { AVC_SPEC_CB14_SYMS[idx] }
55fn cb_map15(idx: usize) -> u16 { AVC_SPEC_CB15_SYMS[idx] }
56
57impl Codebooks {
58 fn new() -> Self {
59 let mut coderead = TableCodebookDescReader::new(AVC_SCF_CODEBOOK_CODES, AVC_SCF_CODEBOOK_BITS, scale_map);
60 let scale_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
61 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB1_CODES, AVC_SPEC_CB1_BITS, cb_map1);
62 let cb1 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
63 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB2_CODES, AVC_SPEC_CB2_BITS, cb_map2);
64 let cb2 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
65 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB3_CODES, AVC_SPEC_CB3_BITS, cb_map3);
66 let cb3 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
67 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB4_CODES, AVC_SPEC_CB4_BITS, cb_map4);
68 let cb4 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
69 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB5_CODES, AVC_SPEC_CB5_BITS, cb_map5);
70 let cb5 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
71 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB6_CODES, AVC_SPEC_CB6_BITS, cb_map6);
72 let cb6 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
73 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB7_CODES, AVC_SPEC_CB7_BITS, cb_map7);
74 let cb7 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
75 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB8_CODES, AVC_SPEC_CB8_BITS, cb_map8);
76 let cb8 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
77 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB9_CODES, AVC_SPEC_CB9_BITS, cb_map9);
78 let cb9 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
79 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB10_CODES, AVC_SPEC_CB10_BITS, cb_map10);
80 let cb10 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
81 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB11_CODES, AVC_SPEC_CB11_BITS, cb_map11);
82 let cb11 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
83 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB12_CODES, AVC_SPEC_CB12_BITS, cb_map12);
84 let cb12 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
85 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB13_CODES, AVC_SPEC_CB13_BITS, cb_map13);
86 let cb13 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
87 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB14_CODES, AVC_SPEC_CB14_BITS, cb_map14);
88 let cb14 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
89 let mut coderead = TableCodebookDescReader::new(AVC_SPEC_CB15_CODES, AVC_SPEC_CB15_BITS, cb_map15);
90 let cb15 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
91 let spec_cb = [cb1, cb2, cb3, cb4, cb5, cb6, cb7, cb8, cb9, cb10, cb11, cb12, cb13, cb14, cb15];
92 Self { scale_cb, spec_cb }
93 }
94}
95
96struct SynthDSP {
97 rdft512: RDFT,
98 rdft256: RDFT,
99 irdft128: RDFT,
100 irdft64: RDFT,
101 synth_tmp: [FFTComplex; 512],
102 synth_out: [FFTComplex; 512],
103}
104
105impl SynthDSP {
106 fn new() -> Self {
107 let rdft512 = RDFTBuilder::new_rdft(512, true, true);
108 let rdft256 = RDFTBuilder::new_rdft(256, true, true);
109 let irdft128 = RDFTBuilder::new_rdft(128, false, false);
110 let irdft64 = RDFTBuilder::new_rdft(64, false, false);
111 Self {
112 rdft512, rdft256, irdft128, irdft64,
113 synth_tmp: [FFTC_ZERO; 512],
114 synth_out: [FFTC_ZERO; 512],
115 }
116 }
117}
118
119struct AVCDecoder {
120 chmap: NAChannelMap,
121 ainfo: NAAudioInfo,
122 info: NACodecInfoRef,
123 dsp: SynthDSP,
124 version: i32,
125 codebooks: Codebooks,
126 channels: usize,
127 is_40khz: bool,
128 win_long: &'static [f32; 1024],
129
130 prev_win: u8,
131 cur_win: u8,
132 winfo: &'static WinInfo,
133 windows: usize,
134 win_grp: [bool; 8],
135 ms_present: bool,
136 ms_info: [bool; MAX_BANDS],
137 cbs: [u8; MAX_BANDS],
138 scales: [u8; MAX_BANDS],
139
140 imdct_long: IMDCT,
141 imdct_mid: IMDCT,
142 imdct_short: IMDCT,
143 coeffs: [[f32; COEFFS]; 2],
144 delay: [[f32; COEFFS]; 2],
145 tmp: [f32; COEFFS * 2],
146 ew_buf: [f32; 1152],
80aaa7ef 147 use_generic: bool,
6a494288
KS
148
149 qtab: [f32; QTAB_SIZE],
150 scale_tab: [f32; 128],
151}
152
153impl AVCDecoder {
154 fn new(version: i32) -> Self {
155 let mut qtab = [0.0f32; QTAB_SIZE];
156 for (i, el) in qtab.iter_mut().enumerate() {
157 *el = (i as f32) * (i as f32).sqrt();
158 }
159 let mut scale_tab = [0.0f32; 128];
160 for (i, el) in scale_tab.iter_mut().enumerate() {
161 let pow = 10.0f32.powf((i as f32) * 0.1);
162 if i < 20 {
163 *el = (pow * 16.0).ceil() / 32.0;
164 } else {
165 *el = (pow * 0.5).ceil();
166 }
167 *el /= 32768.0;
168 }
169
170 AVCDecoder {
171 chmap: NAChannelMap::new(),
172 ainfo: NAAudioInfo::new(0, 0, SND_F32P_FORMAT, 0),
173 info: NACodecInfo::new_dummy(),
174 dsp: SynthDSP::new(),
175 version,
176 codebooks: Codebooks::new(),
177 channels: 0,
178 is_40khz: false,
179 win_long: AVC_WIN_LONG_32K,
180
181 prev_win: 0,
182 cur_win: 0,
183 winfo: &AVC_WINFO_LONG,
184 windows: 0,
185 win_grp: [false; 8],
186 ms_present: false,
187 ms_info: [false; MAX_BANDS],
188 cbs: [0; MAX_BANDS],
189 scales: [0; MAX_BANDS],
190
191 imdct_long: IMDCT::new(1024 * 2, true),
192 imdct_mid: IMDCT::new(512 * 2, true),
193 imdct_short: IMDCT::new(128 * 2, true),
194 coeffs: [[0.0; COEFFS]; 2],
195 delay: [[0.0; COEFFS]; 2],
196 tmp: [0.0; COEFFS * 2],
197 ew_buf: [0.0; 1152],
80aaa7ef 198 use_generic: true,
6a494288
KS
199
200 qtab,
201 scale_tab,
202 }
203 }
204 fn decode_channel(&mut self, br: &mut BitReader, chno: usize) -> DecoderResult<()> {
205 let coeffs = &mut self.coeffs[chno];
206
207 decode_band_types(br, &mut self.cbs, self.winfo)?;
208 // band scales
209 let bands = self.winfo.bands.len();
210 let mut cur_band = 0;
211 let mut scale = 0;
212 let mut first = true;
213 for wg in self.win_grp.iter().take(self.windows) {
214 if *wg {
215 for _ in 0..bands {
216 if self.cbs[cur_band] == 0 {
217 self.scales[cur_band] = 0;
218 } else {
219 if first {
220 scale = br.read(7)? as i16;
221 first = false
222 } else {
223 scale += br.read_cb(&self.codebooks.scale_cb)? as i16;
224 validate!((scale >= 0) && (scale < 128));
225 }
226 self.scales[cur_band] = scale as u8;
227 }
228 cur_band += 1;
229 }
230 } else {
231 for _ in 0..bands {
232 self.scales[cur_band] = self.scales[cur_band - bands];
233 cur_band += 1;
234 }
235 }
236 }
237 // coefficients
238 let mut cur_band = 0;
239 let mut idx = 0;
240 *coeffs = [0.0; COEFFS];
241 for _ in 0..self.windows {
242 let mut band_start = 0;
243 for band_end in self.winfo.bands.iter() {
244 let band_size = *band_end - band_start;
245 let cb_idx = self.cbs[cur_band];
246 if cb_idx > 0 {
247 let cb = &self.codebooks.spec_cb[(cb_idx - 1) as usize];
248 let scale = self.scale_tab[self.scales[cur_band] as usize];
249 let dst = &mut coeffs[idx..][..band_size];
250 if cb_idx < 9 {
251 decode_quads(br, cb, &self.qtab, scale, dst)?;
252 } else {
253 decode_pairs(br, cb, &self.qtab, scale, dst, cb_idx == 15)?;
254 }
255 }
256
257 band_start = *band_end;
258 idx += band_size;
259 cur_band += 1;
260 }
261 }
262 Ok(())
263 }
264 fn decode_frame(&mut self, br: &mut BitReader, adata: &mut NAAudioBuffer<f32>, offset: usize) -> DecoderResult<()> {
265 let enh_flag = br.read_bool()?;
266 validate!(!enh_flag);
267 self.prev_win = self.cur_win;
268 self.cur_win = br.read(3)? as u8;
269 self.winfo = match self.cur_win {
270 3 => &AVC_WINFO_SHORT,
271 4 => if self.is_40khz { &AVC_WINFO_40K_MODE4 } else { &AVC_WINFO_44K_MODE4 },
272 5 => if self.is_40khz { &AVC_WINFO_40K_MODE5 } else { &AVC_WINFO_44K_MODE5 },
273 6 => if self.is_40khz { &AVC_WINFO_40K_MODE6 } else { &AVC_WINFO_44K_MODE6 },
274 _ => &AVC_WINFO_LONG,
275 };
276 self.windows = if self.winfo.is_long { 1 } else { 8 };
277 let bands = self.winfo.bands.len();
278 self.win_grp[0] = true;
279 for el in self.win_grp.iter_mut().skip(1).take(self.windows - 1) {
280 *el = !br.read_bool()?;
281 }
282
283 self.ms_present = br.read_bool()?;
284 if self.ms_present {
285 validate!(self.channels == 2);
286 let mut cur_band = 0;
287 for wg in self.win_grp.iter().take(self.windows) {
288 if *wg {
289 for _ in 0..bands {
290 self.ms_info[cur_band] = br.read_bool()?;
291 cur_band += 1;
292 }
293 } else {
294 for _ in 0..bands {
295 self.ms_info[cur_band] = self.ms_info[cur_band - bands];
296 cur_band += 1;
297 }
298 }
299 }
300 }
301 for ch in 0..self.channels {
302 self.decode_channel(br, ch)?;
303 }
304
305 if (self.channels == 2) && self.ms_present {
306 let mut idx = 0;
307 let mut cur_band = 0;
308 for _ in 0..self.windows {
309 let mut band_start = 0;
310 for band_end in self.winfo.bands.iter() {
311 let band_size = *band_end - band_start;
312 if self.ms_info[cur_band] {
313 for i in 0..band_size {
314 let l = self.coeffs[0][idx + i];
315 let r = self.coeffs[1][idx + i];
316 self.coeffs[0][idx + i] = l + r;
317 self.coeffs[1][idx + i] = l - r;
318 }
319 }
320 cur_band += 1;
321 idx += band_size;
322 band_start = *band_end;
323 }
324 }
325 }
326
327 for ch in 0..self.channels {
328 let off = adata.get_offset(ch) + offset;
329 let output = adata.get_data_mut().unwrap();
330 self.synth_channel(ch, &mut output[off..][..COEFFS]);
331 }
332 Ok(())
333 }
334 fn synth_channel(&mut self, chno: usize, dst: &mut [f32]) {
335 let coeffs = &mut self.coeffs[chno];
336 let delay = &mut self.delay[chno];
337
338 match self.cur_win {
339 0 | 1 => {
80aaa7ef
KS
340 self.imdct_long.imdct_half(coeffs, &mut self.tmp);
341 overlap_half(dst, &self.tmp, delay, self.win_long);
342 (&mut delay[0..COEFFS/2]).copy_from_slice(&self.tmp[COEFFS/2..COEFFS]);
343 for i in COEFFS/2..COEFFS {
344 delay[i] = delay[COEFFS - 1 - i];
345 }
6a494288 346 },
80aaa7ef 347 2 | 7 => {
6a494288
KS
348 self.imdct_long.imdct(coeffs, &mut self.tmp);
349 for i in 0..SHORT_WIN_POINT0 {
350 dst[i] = delay[i];
351 }
352 overlap(&mut dst[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
353 &self.tmp[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
354 &delay[SHORT_WIN_POINT0..SHORT_WIN_POINT1], AVC_WIN_SHORT);
355 for i in SHORT_WIN_POINT1..COEFFS {
80aaa7ef 356 dst[i] = self.tmp[i - SHORT_WIN_POINT1 + 128];
6a494288
KS
357 }
358 delay.copy_from_slice(&self.tmp[COEFFS..]);
359 },
360 3 => {
361 for (ain, aout) in coeffs.chunks(128).zip(self.tmp.chunks_mut(256)) {
362 self.imdct_short.imdct(ain, aout);
363 }
364 self.ew_buf = [0.0; 1152];
365 for i in 0..128 {
366 self.ew_buf[i] = self.tmp[i];
367 }
368 for w in 0..7 {
369 overlap(&mut self.ew_buf[(w + 1) * 128..][..128],
370 &self.tmp[(w + 1) * 256..][..128],
371 &self.tmp[w * 256 + 128..][..128],
372 AVC_WIN_SHORT);
373 }
374 for i in 0..128 {
375 self.ew_buf[1024 + i] = self.tmp[7 * 256 + 128 + i];
376 }
377 for i in 0..SHORT_WIN_POINT0 {
378 dst[i] = delay[i];
379 }
380 overlap(&mut dst[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
381 &self.ew_buf[0..128],
382 &delay[SHORT_WIN_POINT0..SHORT_WIN_POINT1], AVC_WIN_SHORT);
383 for i in SHORT_WIN_POINT1..COEFFS {
384 dst[i] = self.ew_buf[i - SHORT_WIN_POINT1 + 128];
385 }
386 for i in 0..SHORT_WIN_POINT1 {
387 delay[i] = self.ew_buf[SHORT_WIN_POINT1 + i];
388 }
389 for i in SHORT_WIN_POINT1..COEFFS {
390 delay[i] = 0.0;
391 }
392 },
393 4 => {
394 for i in 0..SHORT_WIN_POINT0 {
395 dst[i] = delay[i];
396 }
80aaa7ef
KS
397 if !self.use_generic {
398 synth1024(&mut self.dsp, coeffs, &mut self.ew_buf, &mut self.tmp, self.is_40khz);
399 } else {
400 synth_generic(coeffs, &mut self.ew_buf, &mut self.tmp, self.is_40khz, 1024);
401 }
402 overlap_half(&mut dst[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
403 &self.ew_buf[0..64],
404 &delay[SHORT_WIN_POINT0..SHORT_WIN_POINT1], AVC_WIN_SHORT);
6a494288 405 for i in SHORT_WIN_POINT1..COEFFS {
80aaa7ef 406 dst[i] = self.ew_buf[i - SHORT_WIN_POINT1 + 64];
6a494288 407 }
80aaa7ef
KS
408 for i in 0..COEFFS/2 {
409 delay[i] = self.ew_buf[COEFFS/2 + i];
410 }
411 for i in COEFFS/2..COEFFS {
412 delay[i] = delay[COEFFS - 1 - i];
6a494288
KS
413 }
414 },
415 5 => {
416 for i in 0..SHORT_WIN_POINT0 {
417 dst[i] = delay[i];
418 }
80aaa7ef
KS
419 if !self.use_generic {
420 synth512(&mut self.dsp, coeffs, &mut self.ew_buf, &mut self.tmp, self.is_40khz);
421 } else {
422 synth_generic(coeffs, &mut self.ew_buf, &mut self.tmp, self.is_40khz, 512);
423 }
6a494288 424 self.imdct_mid.imdct(&coeffs[512..], &mut self.ew_buf[512..]);
6a494288
KS
425 overlap(&mut dst[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
426 &self.ew_buf[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
427 &delay[SHORT_WIN_POINT0..SHORT_WIN_POINT1], AVC_WIN_SHORT);
428 for i in SHORT_WIN_POINT1..COEFFS {
429 dst[i] = self.ew_buf[i];
430 }
431 *delay = [0.0; COEFFS];
432 for i in 0..SHORT_WIN_POINT1 {
433 delay[i] = self.ew_buf[i];
434 }
435 },
436 6 => {
437 for i in 0..SHORT_WIN_POINT0 {
438 dst[i] = delay[i];
439 }
440 self.imdct_mid.imdct(coeffs, &mut self.ew_buf);
80aaa7ef
KS
441 if !self.use_generic {
442 synth512(&mut self.dsp, &coeffs[512..], &mut self.ew_buf[512..], &mut self.tmp, self.is_40khz);
443 } else {
444 synth_generic(&coeffs[512..], &mut self.ew_buf[512..], &mut self.tmp, self.is_40khz, 512);
445 }
6a494288
KS
446 overlap(&mut dst[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
447 &self.ew_buf[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
448 &delay[SHORT_WIN_POINT0..SHORT_WIN_POINT1], AVC_WIN_SHORT);
449 for i in SHORT_WIN_POINT1..COEFFS {
450 dst[i] = self.ew_buf[i];
451 }
452 *delay = [0.0; COEFFS];
453 for i in 0..SHORT_WIN_POINT1 {
454 delay[i] = self.ew_buf[i];
455 }
456 },
6a494288
KS
457 _ => unreachable!(),
458 };
459 }
460}
461
462fn overlap(dst: &mut [f32], src: &[f32], delay: &[f32], win: &[f32]) {
463 for (i, ((out, s), d)) in dst.iter_mut().zip(src.iter()).zip(delay.iter()).enumerate() {
464 *out = *s * win[i] + *d * win[win.len() - 1 - i];
465 }
466}
467
80aaa7ef
KS
468fn overlap_half(dst: &mut [f32], src: &[f32], delay: &[f32], win: &[f32]) {
469 let n = win.len();
470 for i in 0..n/2 {
471 let ii = n - 1 - i;
472 let c = src [n/2 - 1 - i];
473 let d = delay[i];
474 let w0 = win[i];
475 let w1 = win[ii];
476 dst[i] = d * w1 - c * w0;
477 dst[ii] = d * w0 + c * w1;
478 }
479}
480
6a494288
KS
481#[derive(Clone,Copy)]
482struct SynthParams {
483 p0: usize,
484 p1: usize,
485 idx: usize
486}
487
488macro_rules! synth_step0_template {
489 ($name:ident, $tab: ident, $size: expr) => {
490 fn $name(src: &[f32], dst: &mut [f32], step: usize, off: usize, sp: &SynthParams) {
491 for i in 0..step {
492 for j in 0..sp.p0 {
493 dst[i] += ((src[j] as f64) * $tab[sp.idx][j][i]) as f32;
494 }
495 }
496 for i in 0..step {
497 for j in 0..sp.p1 {
498 dst[$size - step + i] += ((src[sp.p0 + off + j] as f64) * $tab[sp.idx][sp.p0 + j][i]) as f32;
499 }
500 }
501 }
502 }
503}
504
505synth_step0_template!(synth_step0_10, AVC_SYNTH_TABS10, 10);
506synth_step0_template!(synth_step0_20, AVC_SYNTH_TABS20, 20);
507synth_step0_template!(synth_step0_40, AVC_SYNTH_TABS40, 40);
508synth_step0_template!(synth_step0_84, AVC_SYNTH_TABS84, 84);
509
510fn synth_step1(src: &[f32], dst: &mut [f32], size: usize, stride: usize, step: usize, off: usize, mut p0: usize, win: &[f64])
511{
512 let mut pos = step - 1;
513 for _ in 0..off {
514 let scale = src[p0] as f64;
515 p0 += 1;
516 pos &= size - 1;
517 for i in 0..pos.min(step) {
518 dst[pos - i] += (scale * win[i]) as f32;
519 }
520 pos += stride;
521 }
522}
523
524fn zero_some(buf: &mut [FFTComplex], p0: usize, p1: usize)
525{
526 for el in buf.iter_mut().take(p0/2) {
527 *el = FFTC_ZERO;
528 }
529 if (p0 & 1) != 0 {
530 buf[p0 / 2].re = 0.0;
531 }
532 let len = buf.len();
533 let dst = &mut buf[len - p1/2..];
534 for el in dst.iter_mut() {
535 *el = FFTC_ZERO;
536 }
537 if (p1 & 1) != 0 {
538 buf[len - p1/2 - 1].im = 0.0;
539 }
540}
541
542fn merge_bands(src: &[FFTComplex], dst: &mut [FFTComplex], size: usize) {
543 let step = if size == 512 { 2 } else { 4 };
544 let (s01, s23) = src.split_at(size / 2);
545 let (src0, src1) = s01.split_at(size / 4);
546 let (src2, src3) = s23.split_at(size / 4);
547 let (t00, t01) = AVC_SYNTH_TAB0.split_at(512);
548 let (t10, t11) = AVC_SYNTH_TAB1.split_at(512);
549 let (t20, t21) = AVC_SYNTH_TAB2.split_at(512);
550 let (t30, t31) = AVC_SYNTH_TAB3.split_at(512);
551 let hsize = size / 2;
552 let qsize = size / 4;
553 let osize = size / 8;
554 dst[0].re = src0[0].re * t00[0] + src1[0].re * t10[0] + src2[0].re * t20[0] + src3[0].re * t30[0];
555 dst[0].im = src0[0].re * t00[1] + src1[0].re * t10[1] + src2[0].re * t20[1] + src3[0].re * t30[1];
556 dst[qsize].re = src0[0].im * t00[256] + src1[0].im * t10[256] +
557 src2[0].im * t20[256] + src3[0].im * t30[256];
558 dst[qsize].im = src0[0].im * t00[257] + src1[0].im * t10[257] +
559 src2[0].im * t20[257] + src3[0].im * t30[257];
560 for i in 1..qsize {
561 let s0 = src0[i];
562 let s1 = src1[i];
563 let s2 = src2[i];
564 let s3 = src3[i];
565 let t0 = s0 * FFTComplex { re: t00[i * step + 0], im: t00[i * step + 1] } +
566 s1 * FFTComplex { re: t10[i * step + 0], im: t10[i * step + 1] } +
567 s2 * FFTComplex { re: t20[i * step + 0], im: t20[i * step + 1] } +
568 s3 * FFTComplex { re: t30[i * step + 0], im: t30[i * step + 1] };
569 let t1 = s0 * FFTComplex { re: t01[i * step + 0], im: t01[i * step + 1] } +
570 s1 * FFTComplex { re: t11[i * step + 0], im: t11[i * step + 1] } +
571 s2 * FFTComplex { re: t21[i * step + 0], im: t21[i * step + 1] } +
572 s3 * FFTComplex { re: t31[i * step + 0], im: t31[i * step + 1] };
573 dst[i] = t0;
574 dst[qsize + i] = t1;
575 }
576
577 dst[hsize].re = src0[0].im * t01[256] + src1[0].im * t11[256] +
578 src2[0].im * t21[256] + src3[0].im * t31[256];
579 dst[hsize].im = src0[0].im * t01[257] + src1[0].im * t11[257] +
580 src2[0].im * t21[257] + src3[0].im * t31[257];
581 dst[hsize + qsize].re = src0[0].re * t01[256] + src1[0].re * t11[256] +
582 src2[0].re * t21[256] + src3[0].re * t31[256];
583 dst[hsize + qsize].im = src0[0].re * t01[257] + src1[0].re * t11[257] +
584 src2[0].re * t21[257] + src3[0].re * t31[257];
585 for i in 1..osize {
586 let s0 = !src0[qsize - i];
587 let s1 = !src1[qsize - i];
588 let s2 = !src2[qsize - i];
589 let s3 = !src3[qsize - i];
590 let t0 = s0 * FFTComplex { re: t00[256 + i * step + 0], im: t00[256 + i * step + 1] } +
591 s1 * FFTComplex { re: t10[256 + i * step + 0], im: t10[256 + i * step + 1] } +
592 s2 * FFTComplex { re: t20[256 + i * step + 0], im: t20[256 + i * step + 1] } +
593 s3 * FFTComplex { re: t30[256 + i * step + 0], im: t30[256 + i * step + 1] };
594 let t1 = s0 * FFTComplex { re: t01[256 + i * step + 0], im: t01[256 + i * step + 1] } +
595 s1 * FFTComplex { re: t11[256 + i * step + 0], im: t11[256 + i * step + 1] } +
596 s2 * FFTComplex { re: t21[256 + i * step + 0], im: t21[256 + i * step + 1] } +
597 s3 * FFTComplex { re: t31[256 + i * step + 0], im: t31[256 + i * step + 1] };
598 dst[hsize + i] = !t0;
599 dst[hsize + qsize + i] = !t1;
600 }
601}
602
80aaa7ef
KS
603const SPARAMS10: [SynthParams; 2] = [
604 SynthParams { p0: 1, p1: 3, idx: 0 },
605 SynthParams { p0: 3, p1: 1, idx: 1 } ];
606const SPARAMS20: [SynthParams; 2] = [
607 SynthParams { p0: 5, p1: 4, idx: 0 },
608 SynthParams { p0: 4, p1: 5, idx: 1 } ];
609const SPARAMS40: [SynthParams; 2] = [
610 SynthParams { p0: 11, p1: 8, idx: 0 },
611 SynthParams { p0: 8, p1: 11, idx: 1 } ];
6a494288
KS
612const SPARAMS84: [SynthParams; 4] = [
613 SynthParams { p0: 16, p1: 4, idx: 0 },
614 SynthParams { p0: 16, p1: 4, idx: 1 },
615 SynthParams { p0: 13, p1: 7, idx: 2 },
616 SynthParams { p0: 15, p1: 5, idx: 3 } ];
617
80aaa7ef
KS
618const MERGE_ORDER_44K: &[u8] = &[
619 4, 4, 2, 2, 0, 0, 2, 0, 0, 2, 2, 0, 0, 2, 0, 0, 2, 0, 0,
620 2, 0, 0, 4, 0, 0, 0, 0, 2, 0, 0, 0
621];
622const MERGE_ORDER_40K: &[u8] = &[
623 4, 4, 2, 2, 0, 0, 2, 0, 0, 2, 2, 0, 0, 2, 0, 0, 2, 0, 0,
624 2, 0, 0, 4, 2, 0, 0, 2, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0
625];
626
627fn synth_filter(src: &[f32], dst: &mut [f32], len: usize, step: usize, bands: usize, idx: usize)
628{
629 let off = (len - step) / bands + 1;
630 let params = match step {
631 10 => &SPARAMS10[idx],
632 20 => &SPARAMS20[idx],
633 40 => &SPARAMS40[idx],
634 _ => &SPARAMS84[idx],
635 };
636
637 if step == 10 {
638 synth_step0_10(src, dst, step, off, params);
639 synth_step1(src, dst, len, bands, step, off, params.p0, &AVC_TAB10[idx]);
640 } else if step == 20 {
641 synth_step0_20(src, dst, step, off, params);
642 synth_step1(src, dst, len, bands, step, off, params.p0, &AVC_TAB20[idx]);
643 } else if step == 40 {
644 synth_step0_40(src, dst, step, off, params);
645 synth_step1(src, dst, len, bands, step, off, params.p0, &AVC_TAB40[idx]);
646 } else {
647 synth_step0_84(src, dst, step, off, params);
648 synth_step1(src, dst, len, bands, step, off, params.p0, &AVC_TAB84[idx]);
649 }
650}
651
652fn synth_recursive(dst: &mut [f32], tmp: &mut [f32], size: usize, order: &[u8], order_idx: &mut usize, dir: bool) {
653 let bands = order[*order_idx] as usize;
654 *order_idx += 1;
655 if bands == 0 { return; }
656 let sub_size = size / bands;
657 let mut sub_dir = false;
658 for (dst, tmp) in dst.chunks_mut(sub_size).take(bands).zip(tmp.chunks_mut(sub_size)) {
659 synth_recursive(dst, tmp, sub_size, order, order_idx, sub_dir);
660 sub_dir = !sub_dir;
661 }
662 for el in tmp.iter_mut().take(size) { *el = 0.0; }
663 let step = if bands == 2 {
664 if sub_size <= 20 {
665 10
666 } else if sub_size <= 40 {
667 20
668 } else {
669 40
670 }
671 } else {
672 84
673 };
674 for (i, src) in dst.chunks_mut(sub_size).take(bands).enumerate() {
675 let idx = if !dir { i } else { bands - 1 - i };
676 synth_filter(src, tmp, size, step, bands, idx);
677 }
678 (&mut dst[..size]).copy_from_slice(&tmp[..size]);
679}
680
681fn synth_generic(src: &[f32], dst: &mut [f32], tmpbuf: &mut [f32; COEFFS * 2], is_40khz: bool, size: usize) {
682 let order = if is_40khz { MERGE_ORDER_40K } else { MERGE_ORDER_44K };
683 (&mut dst[..size]).copy_from_slice(&src[..size]);
684 let mut order_idx = 0;
685 synth_recursive(dst, tmpbuf, size, order, &mut order_idx, false);
686 for i in 0..COEFFS { dst[i] *= 0.125; }
687}
688
6a494288
KS
689fn synth1024(dsp: &mut SynthDSP, src: &[f32], dst: &mut [f32], tmpbuf: &mut [f32; COEFFS * 2], is_40khz: bool) {
690 for el in tmpbuf.iter_mut() {
691 *el = 0.0;
692 }
693 let (tmp, tmp2) = tmpbuf.split_at_mut(COEFFS);
694 for el in dsp.synth_tmp.iter_mut() { *el = FFTC_ZERO; }
695 for el in dsp.synth_out.iter_mut() { *el = FFTC_ZERO; }
696
697 let (size, step, stride) = (32, 20, 2);
698 let off = (size - step) / stride + 1;
699 let mut sparam0 = SynthParams { p0: 5, p1: 4, idx: 0 };
700 let mut sparam1 = SynthParams { p0: 4, p1: 5, idx: 1 };
701 for (i, dst) in tmp.chunks_mut(size).take(8).enumerate() {
702 let coeffs = &src[i * 32..];
703 synth_step0_20(coeffs, dst, step, off, &sparam0);
704 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, &AVC_TAB20[sparam0.idx]);
705 let coeffs = &src[i * 32 + 16..];
706 synth_step0_20(coeffs, dst, step, off, &sparam1);
707 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, &AVC_TAB20[sparam1.idx]);
708 std::mem::swap(&mut sparam0, &mut sparam1);
709 }
710
711 let (size, step, stride) = (64, 40, 2);
712 let off = (size - step) / stride + 1;
713 let mut sparam0 = SynthParams { p0: 11, p1: 8, idx: 0 };
714 let mut sparam1 = SynthParams { p0: 8, p1: 11, idx: 1 };
715 let nchunks = if !is_40khz { 8 } else { 12 };
716 for (i, dst) in tmp2.chunks_mut(size).take(nchunks).enumerate() {
717 let coeffs = if i < 4 { &tmp[i * 64..] } else { &src[i * 64 + 32..] };
718 synth_step0_40(coeffs, dst, step, off, &sparam0);
719 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, &AVC_TAB40[sparam0.idx]);
720 let coeffs = if i < 4 { &tmp[i * 64 + 32..] } else { &src[i * 64 + 32..] };
721 synth_step0_40(coeffs, dst, step, off, &sparam1);
722 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, &AVC_TAB40[sparam1.idx]);
723 std::mem::swap(&mut sparam0, &mut sparam1);
724 }
725
726 for el in tmp.iter_mut().take(128) {
727 *el = 0.0;
728 }
729 let (size, step, stride) = (256, 84, 4);
730 let off = (size - step) / stride + 1;
731 for i in 0..4 {
732 let coeffs = &tmp2[i * 64..];
733 synth_step0_84(coeffs, tmp, step, off, &SPARAMS84[i]);
734 synth_step1(coeffs, tmp, size, stride, step, off, SPARAMS84[i].p0, &AVC_TAB84[i]);
735 }
736 for i in 0..4 {
737 let coeffs = if i < 2 && is_40khz { &tmp2[256 + i * 64..] } else { &src[256 + i * 64..] };
738 let dst = &mut tmp[256..];
739 synth_step0_84(coeffs, dst, step, off, &SPARAMS84[3 - i]);
740 synth_step1(coeffs, dst, size, stride, step, off, SPARAMS84[3 - i].p0, &AVC_TAB84[3 - i]);
741 }
742
743 if !is_40khz {
744 let (size, step, stride) = (256, 40, 2);
745 let off = (size - step) / stride + 1;
746 let sparams = [ SynthParams { p0: 11, p1: 8, idx: 0 },
747 SynthParams { p0: 8, p1: 11, idx: 1 } ];
748 for i in 0..2 {
749 let coeffs = &src[512 + i * 128..];
750 let dst = &mut tmp[512..];
751 synth_step0_40(coeffs, dst, step, off, &sparams[i]);
752 synth_step1(coeffs, dst, size, stride, step, off, sparams[i].p0, &AVC_TAB40[i]);
753 }
754 } else {
755 let (size, step, stride) = (256, 84, 4);
756 let off = (size - step) / stride + 1;
757 for i in 0..4 {
758 let coeffs = &src[512 + i * 64..];
759 let dst = &mut tmp[512..];
760 synth_step0_84(coeffs, dst, step, off, &SPARAMS84[i]);
761 synth_step1(coeffs, dst, size, stride, step, off, SPARAMS84[i].p0, &AVC_TAB84[i]);
762 }
763 }
764
765 for (i, s) in tmp.chunks(2).take(768/2).enumerate() {
766 dsp.synth_tmp[i] = FFTComplex { re: s[0], im: s[1] };
767 }
768 for i in (768..1024).step_by(2) {
769 dsp.synth_tmp[i >> 1] = FFTComplex { re: src[i], im: src[i + 1] };
770 }
771 {
772 let dst = &mut tmp[768..1024];
773 dst.copy_from_slice(&src[768..1024]);
774 }
775 for (i, chunk) in dsp.synth_tmp.chunks_exact_mut(128).enumerate() {
776 zero_some(chunk, SPARAMS84[i].p0, SPARAMS84[i].p1);
777 }
778 for chunk in dsp.synth_tmp.chunks_exact_mut(128) {
779 dsp.irdft128.do_rdft_inplace(chunk);
780 for el in chunk.iter_mut() { *el = el.scale(1.0/128.0f32); }
781 }
782 merge_bands(&dsp.synth_tmp, &mut dsp.synth_out, 512);
783 dsp.rdft512.do_rdft_inplace(&mut dsp.synth_out);
784 for (out, src) in dst.chunks_exact_mut(2).zip(dsp.synth_out.iter()) {
785 out[0] = src.re * (1.0 / 1024.0f32.sqrt());
786 out[1] = src.im * (1.0 / 1024.0f32.sqrt());
787 }
788 let (size, step, stride) = (1024, 84, 4);
789 let off = (size - step) / stride + 1;
790 for i in 0..4 {
791 let src = &tmp[256 * i..];
792 synth_step0_84(src, dst, step, off, &SPARAMS84[i]);
793 }
794}
795fn synth512(dsp: &mut SynthDSP, src: &[f32], dst: &mut [f32], tmpbuf: &mut [f32; COEFFS * 2], is_40khz: bool) {
796 for el in tmpbuf.iter_mut() {
797 *el = 0.0;
798 }
799 let (tmp, tmp2) = tmpbuf.split_at_mut(COEFFS);
800
801 let (size, step, stride) = (16, 10, 2);
802 let off = (size - step) / stride + 1;
803 let mut sparam0 = SynthParams { p0: 1, p1: 3, idx: 0 };
804 let mut sparam1 = SynthParams { p0: 3, p1: 1, idx: 1 };
805 let mut tab_ptr0: &[f64] = AVC_TAB10_0;
806 let mut tab_ptr1: &[f64] = AVC_TAB10_1;
807 for (i, dst) in tmp.chunks_mut(size).take(8).enumerate() {
808 let coeffs = &src[i * 16..];
809 synth_step0_10(coeffs, dst, step, off, &sparam0);
810 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, tab_ptr0);
811 let coeffs = &src[i * 16 + 8..];
812 synth_step0_10(coeffs, dst, step, off, &sparam1);
813 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, tab_ptr1);
814 std::mem::swap(&mut sparam0, &mut sparam1);
815 std::mem::swap(&mut tab_ptr0, &mut tab_ptr1);
816 }
817
818 let (size, step, stride) = (32, 20, 2);
819 let off = (size - step) / stride + 1;
820 let mut sparam0 = SynthParams { p0: 5, p1: 4, idx: 0 };
821 let mut sparam1 = SynthParams { p0: 4, p1: 5, idx: 1 };
822 let nchunks = if !is_40khz { 8 } else { 12 };
823 for (i, dst) in tmp2.chunks_mut(size).take(nchunks).enumerate() {
824 let coeffs = if i < 4 { &tmp[i * 32..] } else { &src[i * 32..] };
825 synth_step0_20(coeffs, dst, step, off, &sparam0);
826 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, &AVC_TAB20[sparam0.idx]);
827 let coeffs = if i < 4 { &tmp[i * 32 + 16..] } else { &src[i * 32 + 16..] };
828 synth_step0_20(coeffs, dst, step, off, &sparam1);
829 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, &AVC_TAB20[sparam1.idx]);
830 std::mem::swap(&mut sparam0, &mut sparam1);
831 }
832
833 for el in tmp.iter_mut().take(64) {
834 *el = 0.0;
835 }
836 let (size, step, stride) = (128, 84, 4);
837 let off = (size - step) / stride + 1;
838 for i in 0..4 {
839 let coeffs = &tmp2[i * 32..];
840 synth_step0_84(coeffs, tmp, step, off, &SPARAMS84[i]);
841 synth_step1(coeffs, tmp, size, stride, step, off, SPARAMS84[i].p0, &AVC_TAB84[i]);
842 }
843 for i in 0..4 {
844 let coeffs = if i < 2 && is_40khz { &tmp2[128 + i * 32..] } else { &src[128 + i * 32..] };
845 let dst = &mut tmp[128..];
846 synth_step0_84(coeffs, dst, step, off, &SPARAMS84[3 - i]);
847 synth_step1(coeffs, dst, size, stride, step, off, SPARAMS84[3 - i].p0, &AVC_TAB84[3 - i]);
848 }
849
850 if !is_40khz {
851 let (size, step, stride) = (128, 40, 2);
852 let off = (size - step) / stride + 1;
853 let sparams = [ SynthParams { p0: 11, p1: 8, idx: 0 },
854 SynthParams { p0: 8, p1: 11, idx: 1 } ];
855 for i in 0..2 {
856 let coeffs = &src[256 + i * 64..];
857 let dst = &mut tmp[256..];
858 synth_step0_40(coeffs, dst, step, off, &sparams[i]);
859 synth_step1(coeffs, dst, size, stride, step, off, sparams[i].p0, &AVC_TAB40[i]);
860 }
861 } else {
862 let (size, step, stride) = (128, 84, 4);
863 let off = (size - step) / stride + 1;
864 for i in 0..4 {
865 let coeffs = &src[256 + i * 32..];
866 let dst = &mut tmp[256..];
867 synth_step0_84(coeffs, dst, step, off, &SPARAMS84[i]);
868 synth_step1(coeffs, dst, size, stride, step, off, SPARAMS84[i].p0, &AVC_TAB84[i]);
869 }
870 }
871
872 for (i, s) in tmp.chunks(2).take(384/2).enumerate() {
873 dsp.synth_tmp[i] = FFTComplex { re: s[0], im: s[1] };
874 }
875 for i in (384..512).step_by(2) {
876 dsp.synth_tmp[i >> 1] = FFTComplex { re: src[i], im: src[i + 1] };
877 }
878 {
879 let dst = &mut tmp[384..512];
880 dst.copy_from_slice(&src[384..512]);
881 }
882 for (i, chunk) in dsp.synth_tmp.chunks_exact_mut(128).enumerate() {
883 zero_some(chunk, SPARAMS84[i].p0, SPARAMS84[i].p1);
884 }
885 for chunk in dsp.synth_tmp.chunks_exact_mut(64) {
886 dsp.irdft64.do_rdft_inplace(chunk);
887 }
888 merge_bands(&dsp.synth_tmp, &mut dsp.synth_out, 256);
889 dsp.rdft256.do_rdft_inplace(&mut dsp.synth_out);
890 for (out, src) in dst.chunks_exact_mut(2).zip(dsp.synth_out.iter()).take(256) {
891 out[0] = src.re * (1.0 / 512.0f32 / 1024.0f32);
892 out[1] = src.im * (1.0 / 512.0f32 / 1024.0f32);
893 }
894 let (size, step, stride) = (512, 84, 4);
895 let off = (size - step) / stride + 1;
896 for i in 0..4 {
897 let src = &tmp[128 * i..];
898 synth_step0_84(src, dst, step, off, &SPARAMS84[i]);
899 }
900}
901
902fn decode_band_types(br: &mut BitReader, cbs: &mut [u8; MAX_BANDS], winfo: &WinInfo) -> DecoderResult<()> {
903 let bits_per_sect = if winfo.is_long { 5 } else { 3 };
904 let esc_val = (1 << bits_per_sect) - 1;
905 let tot_bands = winfo.get_tot_bands();
906
907 let mut cur_band = 0;
908 while cur_band < tot_bands {
909 let codebook = br.read(4)? as u8;
910 let mut run = 1;
911 loop {
912 let run_add = br.read(bits_per_sect)? as usize;
913 run += run_add;
914 if run_add != esc_val { break; }
915 }
916 validate!(cur_band + run <= tot_bands);
917 for _ in 0..run {
918 cbs[cur_band] = codebook;
919 cur_band += 1;
920 }
921 }
922 Ok(())
923}
924
925fn dequant(val: i16, qtab: &[f32; QTAB_SIZE], scale: f32) -> f32 {
926 if val >= 0 {
927 qtab[val as usize] * scale
928 } else {
929 -qtab[val.abs() as usize] * scale
930 }
931}
932
933fn decode_quads(br: &mut BitReader, cb: &Codebook<u16>, qtab: &[f32; QTAB_SIZE], scale: f32, dst: &mut [f32]) -> DecoderResult<()> {
934 for quad in dst.chunks_exact_mut(4) {
935 let mut idx = br.read_cb(cb)? as i16;
936 for el in quad.iter_mut() {
937 *el = dequant(idx >> 12, qtab, scale);
938 idx <<= 4;
939 }
940 }
941 Ok(())
942}
943
944fn decode_esc_val(br: &mut BitReader, qtab: &[f32; QTAB_SIZE], scale: f32, sign: bool) -> DecoderResult<f32> {
945 let pfx = br.read_code(UintCodeType::LimitedOnes(24))? + 4;
946 let add = br.read(pfx as u8)? as usize;
947 let val = (1 << pfx) + add;
948 let fval = scale * if val < qtab.len() {
949 qtab[val]
950 } else {
951 (val as f32) * (val as f32).sqrt()
952 };
953 if !sign {
954 Ok(fval)
955 } else {
956 Ok(-fval)
957 }
958}
959
960fn decode_pairs(br: &mut BitReader, cb: &Codebook<u16>, qtab: &[f32; QTAB_SIZE], scale: f32, dst: &mut [f32], is_esc: bool) -> DecoderResult<()> {
961 for pair in dst.chunks_exact_mut(2) {
962 let idx = br.read_cb(cb)? as i16;
963 let idx0 = idx >> 8;
964 let idx1 = (idx << 8) >> 8;
965 if !is_esc || (idx0.abs() < 16) {
966 pair[0] = dequant(idx0, qtab, scale);
967 } else {
968 pair[0] = decode_esc_val(br, qtab, scale, idx0 < 0)?;
969 }
970 if !is_esc || (idx1.abs() < 16) {
971 pair[1] = dequant(idx1, qtab, scale);
972 } else {
973 pair[1] = decode_esc_val(br, qtab, scale, idx1 < 0)?;
974 }
975 }
976 Ok(())
977}
978
979impl NADecoder for AVCDecoder {
980 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
981 if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
982 self.chmap = match ainfo.get_channels() {
983 1 => { NAChannelMap::from_str("C").unwrap() },
984 2 => { NAChannelMap::from_str("L,R").unwrap() },
985 _ => { return Err(DecoderError::InvalidData); },
986 };
987 let srate = ainfo.get_sample_rate();
988 self.ainfo = NAAudioInfo::new(srate, ainfo.get_channels(),
989 SND_F32P_FORMAT, COEFFS);
990 self.info = info.replace_info(NACodecTypeInfo::Audio(self.ainfo));
991 self.channels = ainfo.get_channels() as usize;
992 self.is_40khz = srate <= 40000;
993
994 self.win_long = if (srate > 24000) && ((srate > 32000) || (self.channels == 2)) {
995 AVC_WIN_LONG_32K
996 } else {
997 AVC_WIN_LONG_24K
998 };
999
1000 Ok(())
1001 } else {
1002 Err(DecoderError::InvalidData)
1003 }
1004 }
1005 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1006 let info = pkt.get_stream().get_info();
1007 validate!(info.get_properties().is_audio());
1008 let src = pkt.get_buffer();
1009
1010 let abuf;
1011
1012 if self.version == 500 {
1013 abuf = alloc_audio_buffer(self.ainfo, COEFFS, self.chmap.clone())?;
1014 let mut adata = abuf.get_abuf_f32().unwrap();
1015 let mut br = BitReader::new(src.as_slice(), src.len(), BitReaderMode::BE);
1016 self.decode_frame(&mut br, &mut adata, 0)?;
1017 } else {
1018 let mut offsets: Vec<usize> = Vec::new();
1019 let mut sizes: Vec<usize> = Vec::new();
1020
1021 let mut cur_off = 0;
1022 while cur_off + 2 < src.len() {
1023 let sz = read_u16le(&src[cur_off..])? as usize;
1024 validate!(sz > 0);
1025 validate!(cur_off + sz + 2 <= src.len());
1026 offsets.push(cur_off + 2);
1027 sizes.push(sz);
1028 cur_off += sz + 2;
1029 }
1030
1031 validate!(!sizes.is_empty());
1032
1033 abuf = alloc_audio_buffer(self.ainfo, COEFFS * sizes.len(), self.chmap.clone())?;
1034 let mut adata = abuf.get_abuf_f32().unwrap();
1035 let mut aoffset = 0;
1036 for (o, s) in offsets.iter().zip(sizes.iter()) {
1037 let mut br = BitReader::new(&src[*o..], *s, BitReaderMode::BE);
1038 self.decode_frame(&mut br, &mut adata, aoffset)?;
1039 aoffset += COEFFS;
1040 }
1041 }
1042
1043 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), abuf);
1044 frm.set_keyframe(true);
1045 Ok(frm.into_ref())
1046 }
f9be4e75
KS
1047 fn flush(&mut self) {
1048 }
6a494288
KS
1049}
1050
1051pub fn get_decoder_500() -> Box<dyn NADecoder> {
1052 Box::new(AVCDecoder::new(500))
1053}
1054
1055pub fn get_decoder_501() -> Box<dyn NADecoder> {
1056 Box::new(AVCDecoder::new(501))
1057}
1058
1059#[cfg(test)]
1060mod test {
1061 use nihav_core::codecs::RegisteredDecoders;
1062 use nihav_core::demuxers::RegisteredDemuxers;
1063 use nihav_core::test::dec_video::*;
1064 use crate::codecs::duck_register_all_codecs;
1065 use nihav_commonfmt::demuxers::generic_register_all_demuxers;
1066 #[test]
1067 fn test_avc() {
1068 let mut dmx_reg = RegisteredDemuxers::new();
1069 generic_register_all_demuxers(&mut dmx_reg);
1070 let mut dec_reg = RegisteredDecoders::new();
1071 duck_register_all_codecs(&mut dec_reg);
1072
1073 //let file = "assets/Duck/Cell-140.vp5";
1074 //let file = "assets/Duck/Chocolat-500.vp5";
1075 let file = "assets/Duck/potter-500.vp7";
5580b11b 1076 test_decode_audio("avi", file, Some(1500), None/*Some("avc")*/, &dmx_reg, &dec_reg);
6a494288
KS
1077 }
1078}
1079
1080const AVC_WINFO_LONG: WinInfo = WinInfo {
1081 is_long: true,
1082 bands: &[
1083 4, 8, 12, 16, 20, 24, 28, 32,
1084 36, 40, 48, 56, 64, 72, 80, 88,
1085 96, 108, 120, 132, 144, 156, 172, 188,
1086 204, 224, 244, 264, 288, 312, 340, 368,
1087 400, 432, 464, 496, 528, 560, 592, 624,
1088 656, 688, 720, 752, 784, 816, 848, 880, 1024
1089 ],
1090};
1091
1092const AVC_WINFO_SHORT: WinInfo = WinInfo {
1093 is_long: false,
1094 bands: &[ 4, 8, 12, 16, 20, 24, 32, 40, 48, 56, 68, 80, 108, 128 ],
1095};
1096
1097const AVC_WINFO_40K_MODE4: WinInfo = WinInfo {
1098 is_long: true,
1099 bands: &[
1100 8, 16, 24, 32, 40, 48, 56, 64,
1101 72, 80, 88, 96, 104, 112, 120, 128,
1102 144, 160, 176, 192, 208, 224, 240, 256,
1103 264, 272, 280, 288, 296, 304, 312, 320,
1104 328, 336, 344, 352, 360, 368, 376, 384,
1105 400, 416, 432, 448, 464, 480, 496, 512,
1106 520, 528, 536, 544, 552, 560, 568, 576,
1107 584, 592, 600, 608, 616, 624, 632, 640,
1108 648, 656, 664, 672, 680, 688, 696, 704,
1109 712, 720, 728, 736, 744, 752, 760, 768,
1110 800, 832, 864, 896, 928, 960, 992, 1024
1111 ],
1112};
1113const AVC_WINFO_40K_MODE5: WinInfo = WinInfo {
1114 is_long: true,
1115 bands: &[
1116 8, 16, 24, 32, 40, 48, 56, 64,
1117 80, 96, 112, 128, 136, 144, 152, 160,
1118 168, 176, 184, 192, 208, 224, 240, 256,
1119 264, 272, 280, 288, 296, 304, 312, 320,
1120 328, 336, 344, 352, 360, 368, 376, 384,
1121 416, 448, 480, 512, 516, 520, 524, 528,
1122 532, 536, 540, 548, 556, 568, 580, 592,
1123 608, 624, 640, 656, 672, 688, 704, 720,
1124 736, 752, 768, 784, 800, 816, 832, 848,
1125 864, 880, 896, 912, 928, 944, 1024
1126 ],
1127};
1128const AVC_WINFO_40K_MODE6: WinInfo = WinInfo {
1129 is_long: true,
1130 bands: &[
1131 4, 8, 12, 16, 20, 24, 28, 36,
1132 44, 56, 68, 80, 96, 112, 128, 144,
1133 160, 176, 192, 208, 224, 240, 256, 272,
1134 288, 304, 320, 336, 352, 368, 384, 400,
1135 416, 432, 512, 520, 528, 536, 544, 552,
1136 560, 568, 576, 592, 608, 624, 640, 648,
1137 656, 664, 672, 680, 688, 696, 704, 720,
1138 736, 752, 768, 776, 784, 792, 800, 808,
1139 816, 824, 832, 840, 848, 856, 864, 872,
1140 880, 888, 896, 928, 960, 992, 1024
1141 ],
1142};
1143
1144const AVC_WINFO_44K_MODE4: WinInfo = WinInfo {
1145 is_long: true,
1146 bands: &[
1147 8, 16, 24, 32, 40, 48, 56, 64,
1148 72, 80, 88, 96, 104, 112, 120, 128,
1149 136, 144, 152, 160, 168, 176, 184, 192,
1150 200, 208, 216, 224, 232, 240, 248, 256,
1151 264, 272, 280, 288, 296, 304, 312, 320,
1152 328, 336, 344, 352, 360, 368, 376, 384,
1153 392, 400, 408, 416, 424, 432, 440, 448,
1154 456, 464, 472, 480, 488, 496, 504, 512,
1155 528, 544, 560, 576, 592, 608, 624, 640,
1156 672, 704, 736, 768, 832, 896, 960, 1024
1157 ],
1158};
1159const AVC_WINFO_44K_MODE5: WinInfo = WinInfo {
1160 is_long: true,
1161 bands: &[
1162 8, 16, 24, 32, 40, 48, 56, 64,
1163 72, 80, 88, 96, 104, 112, 120, 128,
1164 136, 144, 152, 160, 168, 176, 184, 192,
1165 200, 208, 216, 224, 232, 240, 248, 256,
1166 272, 288, 304, 320, 352, 384, 448, 512,
1167 516, 520, 524, 528, 532, 536, 540, 548,
1168 556, 568, 580, 592, 608, 624, 640, 656,
1169 672, 688, 704, 720, 736, 752, 768, 784,
1170 800, 816, 832, 848, 864, 880, 896, 912,
1171 928, 944, 1024
1172 ],
1173};
1174const AVC_WINFO_44K_MODE6: WinInfo = WinInfo {
1175 is_long: true,
1176 bands: &[
1177 4, 8, 12, 16, 20, 24, 28, 36,
1178 44, 56, 68, 80, 96, 112, 128, 144,
1179 160, 176, 192, 208, 224, 240, 256, 272,
1180 288, 304, 320, 336, 352, 368, 384, 400,
1181 416, 432, 512, 520, 528, 536, 544, 552,
1182 560, 568, 576, 584, 592, 600, 608, 616,
1183 624, 632, 640, 648, 656, 664, 672, 680,
1184 688, 696, 704, 712, 720, 728, 736, 744,
1185 752, 760, 768, 784, 800, 816, 832, 864,
1186 896, 960, 1024
1187 ],
1188};