projects / nihav.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
introduce option handling for decoders
[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::*;
b4d5b851
KS		 7use nihav_codec_support::dsp::fft::*;
8use nihav_codec_support::dsp::mdct::IMDCT;
6a494288
KS		 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();
fa90ccfb 1015 let mut br = BitReader::new(src.as_slice(), BitReaderMode::BE);
6a494288
KS		 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()) {
fa90ccfb 1037 let mut br = BitReader::new(&src[*o..][..*s], BitReaderMode::BE);
6a494288
KS		 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
7d57ae2f
KS		 1051impl NAOptionHandler for AVCDecoder {
1052 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
1053 fn set_options(&mut self, _options: &[NAOption]) { }
1054 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
1055}
1056
08a1fab7 1057pub fn get_decoder_500() -> Box<dyn NADecoder + Send> {
6a494288
KS		 1058 Box::new(AVCDecoder::new(500))
1059}
1060
08a1fab7 1061pub fn get_decoder_501() -> Box<dyn NADecoder + Send> {
6a494288
KS		 1062 Box::new(AVCDecoder::new(501))
1063}
1064
1065#[cfg(test)]
1066mod test {
1067 use nihav_core::codecs::RegisteredDecoders;
1068 use nihav_core::demuxers::RegisteredDemuxers;
ce742854 1069 use nihav_codec_support::test::dec_video::*;
e64739f8
KS		 1070 use crate::duck_register_all_codecs;
1071 use nihav_commonfmt::generic_register_all_demuxers;
6a494288
KS		 1072 #[test]
1073 fn test_avc() {
1074 let mut dmx_reg = RegisteredDemuxers::new();
1075 generic_register_all_demuxers(&mut dmx_reg);
1076 let mut dec_reg = RegisteredDecoders::new();
1077 duck_register_all_codecs(&mut dec_reg);
1078
1079 //let file = "assets/Duck/Cell-140.vp5";
1080 //let file = "assets/Duck/Chocolat-500.vp5";
1081 let file = "assets/Duck/potter-500.vp7";
5580b11b 1082 test_decode_audio("avi", file, Some(1500), None/*Some("avc")*/, &dmx_reg, &dec_reg);
6a494288
KS		 1083 }
1084}
1085
1086const AVC_WINFO_LONG: WinInfo = WinInfo {
1087 is_long: true,
1088 bands: &[
1089 4, 8, 12, 16, 20, 24, 28, 32,
1090 36, 40, 48, 56, 64, 72, 80, 88,
1091 96, 108, 120, 132, 144, 156, 172, 188,
1092 204, 224, 244, 264, 288, 312, 340, 368,
1093 400, 432, 464, 496, 528, 560, 592, 624,
1094 656, 688, 720, 752, 784, 816, 848, 880, 1024
1095 ],
1096};
1097
1098const AVC_WINFO_SHORT: WinInfo = WinInfo {
1099 is_long: false,
1100 bands: &[ 4, 8, 12, 16, 20, 24, 32, 40, 48, 56, 68, 80, 108, 128 ],
1101};
1102
1103const AVC_WINFO_40K_MODE4: WinInfo = WinInfo {
1104 is_long: true,
1105 bands: &[
1106 8, 16, 24, 32, 40, 48, 56, 64,
1107 72, 80, 88, 96, 104, 112, 120, 128,
1108 144, 160, 176, 192, 208, 224, 240, 256,
1109 264, 272, 280, 288, 296, 304, 312, 320,
1110 328, 336, 344, 352, 360, 368, 376, 384,
1111 400, 416, 432, 448, 464, 480, 496, 512,
1112 520, 528, 536, 544, 552, 560, 568, 576,
1113 584, 592, 600, 608, 616, 624, 632, 640,
1114 648, 656, 664, 672, 680, 688, 696, 704,
1115 712, 720, 728, 736, 744, 752, 760, 768,
1116 800, 832, 864, 896, 928, 960, 992, 1024
1117 ],
1118};
1119const AVC_WINFO_40K_MODE5: WinInfo = WinInfo {
1120 is_long: true,
1121 bands: &[
1122 8, 16, 24, 32, 40, 48, 56, 64,
1123 80, 96, 112, 128, 136, 144, 152, 160,
1124 168, 176, 184, 192, 208, 224, 240, 256,
1125 264, 272, 280, 288, 296, 304, 312, 320,
1126 328, 336, 344, 352, 360, 368, 376, 384,
1127 416, 448, 480, 512, 516, 520, 524, 528,
1128 532, 536, 540, 548, 556, 568, 580, 592,
1129 608, 624, 640, 656, 672, 688, 704, 720,
1130 736, 752, 768, 784, 800, 816, 832, 848,
1131 864, 880, 896, 912, 928, 944, 1024
1132 ],
1133};
1134const AVC_WINFO_40K_MODE6: WinInfo = WinInfo {
1135 is_long: true,
1136 bands: &[
1137 4, 8, 12, 16, 20, 24, 28, 36,
1138 44, 56, 68, 80, 96, 112, 128, 144,
1139 160, 176, 192, 208, 224, 240, 256, 272,
1140 288, 304, 320, 336, 352, 368, 384, 400,
1141 416, 432, 512, 520, 528, 536, 544, 552,
1142 560, 568, 576, 592, 608, 624, 640, 648,
1143 656, 664, 672, 680, 688, 696, 704, 720,
1144 736, 752, 768, 776, 784, 792, 800, 808,
1145 816, 824, 832, 840, 848, 856, 864, 872,
1146 880, 888, 896, 928, 960, 992, 1024
1147 ],
1148};
1149
1150const AVC_WINFO_44K_MODE4: WinInfo = WinInfo {
1151 is_long: true,
1152 bands: &[
1153 8, 16, 24, 32, 40, 48, 56, 64,
1154 72, 80, 88, 96, 104, 112, 120, 128,
1155 136, 144, 152, 160, 168, 176, 184, 192,
1156 200, 208, 216, 224, 232, 240, 248, 256,
1157 264, 272, 280, 288, 296, 304, 312, 320,
1158 328, 336, 344, 352, 360, 368, 376, 384,
1159 392, 400, 408, 416, 424, 432, 440, 448,
1160 456, 464, 472, 480, 488, 496, 504, 512,
1161 528, 544, 560, 576, 592, 608, 624, 640,
1162 672, 704, 736, 768, 832, 896, 960, 1024
1163 ],
1164};
1165const AVC_WINFO_44K_MODE5: WinInfo = WinInfo {
1166 is_long: true,
1167 bands: &[
1168 8, 16, 24, 32, 40, 48, 56, 64,
1169 72, 80, 88, 96, 104, 112, 120, 128,
1170 136, 144, 152, 160, 168, 176, 184, 192,
1171 200, 208, 216, 224, 232, 240, 248, 256,
1172 272, 288, 304, 320, 352, 384, 448, 512,
1173 516, 520, 524, 528, 532, 536, 540, 548,
1174 556, 568, 580, 592, 608, 624, 640, 656,
1175 672, 688, 704, 720, 736, 752, 768, 784,
1176 800, 816, 832, 848, 864, 880, 896, 912,
1177 928, 944, 1024
1178 ],
1179};
1180const AVC_WINFO_44K_MODE6: WinInfo = WinInfo {
1181 is_long: true,
1182 bands: &[
1183 4, 8, 12, 16, 20, 24, 28, 36,
1184 44, 56, 68, 80, 96, 112, 128, 144,
1185 160, 176, 192, 208, 224, 240, 256, 272,
1186 288, 304, 320, 336, 352, 368, 384, 400,
1187 416, 432, 512, 520, 528, 536, 544, 552,
1188 560, 568, 576, 584, 592, 600, 608, 616,
1189 624, 632, 640, 648, 656, 664, 672, 680,
1190 688, 696, 704, 712, 720, 728, 736, 744,
1191 752, 760, 768, 784, 800, 816, 832, 864,
1192 896, 960, 1024
1193 ],
1194};
NihAV is a research multimedia framework