1 use nihav_core::frame::*;
2 use nihav_core::codecs::*;
3 use nihav_core::io::byteio::read_u16le;
4 use nihav_core::io::bitreader::*;
5 use nihav_core::io::codebook::*;
6 use nihav_core::io::intcode::*;
7 use nihav_core::dsp::fft::*;
8 use nihav_core::dsp::mdct::IMDCT;
10 use std::str::FromStr;
12 use super::on2avcdata::*;
14 const COEFFS: usize = 1024;
15 const MAX_BANDS: usize = 14 * 8;
16 const QTAB_SIZE: usize = 10000;
17 const SHORT_WIN_POINT0: usize = 512 - 64;
18 const SHORT_WIN_POINT1: usize = 512 + 64;
22 bands: &'static [usize],
26 fn get_tot_bands(&self) -> usize {
36 scale_cb: Codebook<i8>,
37 spec_cb: [Codebook<u16>; 15],
40 fn scale_map(idx: usize) -> i8 { (idx as i8) - 60 }
41 fn cb_map1(idx: usize) -> u16 { AVC_SPEC_CB1_SYMS[idx] }
42 fn cb_map2(idx: usize) -> u16 { AVC_SPEC_CB2_SYMS[idx] }
43 fn cb_map3(idx: usize) -> u16 { AVC_SPEC_CB3_SYMS[idx] }
44 fn cb_map4(idx: usize) -> u16 { AVC_SPEC_CB4_SYMS[idx] }
45 fn cb_map5(idx: usize) -> u16 { AVC_SPEC_CB5_SYMS[idx] }
46 fn cb_map6(idx: usize) -> u16 { AVC_SPEC_CB6_SYMS[idx] }
47 fn cb_map7(idx: usize) -> u16 { AVC_SPEC_CB7_SYMS[idx] }
48 fn cb_map8(idx: usize) -> u16 { AVC_SPEC_CB8_SYMS[idx] }
49 fn cb_map9(idx: usize) -> u16 { AVC_SPEC_CB9_SYMS[idx] }
50 fn cb_map10(idx: usize) -> u16 { AVC_SPEC_CB10_SYMS[idx] }
51 fn cb_map11(idx: usize) -> u16 { AVC_SPEC_CB11_SYMS[idx] }
52 fn cb_map12(idx: usize) -> u16 { AVC_SPEC_CB12_SYMS[idx] }
53 fn cb_map13(idx: usize) -> u16 { AVC_SPEC_CB13_SYMS[idx] }
54 fn cb_map14(idx: usize) -> u16 { AVC_SPEC_CB14_SYMS[idx] }
55 fn cb_map15(idx: usize) -> u16 { AVC_SPEC_CB15_SYMS[idx] }
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 }
101 synth_tmp: [FFTComplex; 512],
102 synth_out: [FFTComplex; 512],
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);
112 rdft512, rdft256, irdft128, irdft64,
113 synth_tmp: [FFTC_ZERO; 512],
114 synth_out: [FFTC_ZERO; 512],
122 info: NACodecInfoRef,
125 codebooks: Codebooks,
128 win_long: &'static [f32; 1024],
132 winfo: &'static WinInfo,
136 ms_info: [bool; MAX_BANDS],
137 cbs: [u8; MAX_BANDS],
138 scales: [u8; MAX_BANDS],
143 coeffs: [[f32; COEFFS]; 2],
144 delay: [[f32; COEFFS]; 2],
145 tmp: [f32; COEFFS * 2],
149 qtab: [f32; QTAB_SIZE],
150 scale_tab: [f32; 128],
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();
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);
163 *el = (pow * 16.0).ceil() / 32.0;
165 *el = (pow * 0.5).ceil();
171 chmap: NAChannelMap::new(),
172 ainfo: NAAudioInfo::new(0, 0, SND_F32P_FORMAT, 0),
173 info: NACodecInfo::new_dummy(),
174 dsp: SynthDSP::new(),
176 codebooks: Codebooks::new(),
179 win_long: AVC_WIN_LONG_32K,
183 winfo: &AVC_WINFO_LONG,
187 ms_info: [false; MAX_BANDS],
189 scales: [0; MAX_BANDS],
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],
204 fn decode_channel(&mut self, br: &mut BitReader, chno: usize) -> DecoderResult<()> {
205 let coeffs = &mut self.coeffs[chno];
207 decode_band_types(br, &mut self.cbs, self.winfo)?;
209 let bands = self.winfo.bands.len();
210 let mut cur_band = 0;
212 let mut first = true;
213 for wg in self.win_grp.iter().take(self.windows) {
216 if self.cbs[cur_band] == 0 {
217 self.scales[cur_band] = 0;
220 scale = br.read(7)? as i16;
223 scale += br.read_cb(&self.codebooks.scale_cb)? as i16;
224 validate!((scale >= 0) && (scale < 128));
226 self.scales[cur_band] = scale as u8;
232 self.scales[cur_band] = self.scales[cur_band - bands];
238 let mut cur_band = 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];
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];
251 decode_quads(br, cb, &self.qtab, scale, dst)?;
253 decode_pairs(br, cb, &self.qtab, scale, dst, cb_idx == 15)?;
257 band_start = *band_end;
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,
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()?;
283 self.ms_present = br.read_bool()?;
285 validate!(self.channels == 2);
286 let mut cur_band = 0;
287 for wg in self.win_grp.iter().take(self.windows) {
290 self.ms_info[cur_band] = br.read_bool()?;
295 self.ms_info[cur_band] = self.ms_info[cur_band - bands];
301 for ch in 0..self.channels {
302 self.decode_channel(br, ch)?;
305 if (self.channels == 2) && self.ms_present {
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;
322 band_start = *band_end;
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]);
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];
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];
348 self.imdct_long.imdct(coeffs, &mut self.tmp);
349 for i in 0..SHORT_WIN_POINT0 {
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 {
356 dst[i] = self.tmp[i - SHORT_WIN_POINT1 + 128];
358 delay.copy_from_slice(&self.tmp[COEFFS..]);
361 for (ain, aout) in coeffs.chunks(128).zip(self.tmp.chunks_mut(256)) {
362 self.imdct_short.imdct(ain, aout);
364 self.ew_buf = [0.0; 1152];
366 self.ew_buf[i] = self.tmp[i];
369 overlap(&mut self.ew_buf[(w + 1) * 128..][..128],
370 &self.tmp[(w + 1) * 256..][..128],
371 &self.tmp[w * 256 + 128..][..128],
375 self.ew_buf[1024 + i] = self.tmp[7 * 256 + 128 + i];
377 for i in 0..SHORT_WIN_POINT0 {
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];
386 for i in 0..SHORT_WIN_POINT1 {
387 delay[i] = self.ew_buf[SHORT_WIN_POINT1 + i];
389 for i in SHORT_WIN_POINT1..COEFFS {
394 for i in 0..SHORT_WIN_POINT0 {
397 if !self.use_generic {
398 synth1024(&mut self.dsp, coeffs, &mut self.ew_buf, &mut self.tmp, self.is_40khz);
400 synth_generic(coeffs, &mut self.ew_buf, &mut self.tmp, self.is_40khz, 1024);
402 overlap_half(&mut dst[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
404 &delay[SHORT_WIN_POINT0..SHORT_WIN_POINT1], AVC_WIN_SHORT);
405 for i in SHORT_WIN_POINT1..COEFFS {
406 dst[i] = self.ew_buf[i - SHORT_WIN_POINT1 + 64];
408 for i in 0..COEFFS/2 {
409 delay[i] = self.ew_buf[COEFFS/2 + i];
411 for i in COEFFS/2..COEFFS {
412 delay[i] = delay[COEFFS - 1 - i];
416 for i in 0..SHORT_WIN_POINT0 {
419 if !self.use_generic {
420 synth512(&mut self.dsp, coeffs, &mut self.ew_buf, &mut self.tmp, self.is_40khz);
422 synth_generic(coeffs, &mut self.ew_buf, &mut self.tmp, self.is_40khz, 512);
424 self.imdct_mid.imdct(&coeffs[512..], &mut self.ew_buf[512..]);
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];
431 *delay = [0.0; COEFFS];
432 for i in 0..SHORT_WIN_POINT1 {
433 delay[i] = self.ew_buf[i];
437 for i in 0..SHORT_WIN_POINT0 {
440 self.imdct_mid.imdct(coeffs, &mut self.ew_buf);
441 if !self.use_generic {
442 synth512(&mut self.dsp, &coeffs[512..], &mut self.ew_buf[512..], &mut self.tmp, self.is_40khz);
444 synth_generic(&coeffs[512..], &mut self.ew_buf[512..], &mut self.tmp, self.is_40khz, 512);
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];
452 *delay = [0.0; COEFFS];
453 for i in 0..SHORT_WIN_POINT1 {
454 delay[i] = self.ew_buf[i];
462 fn 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];
468 fn overlap_half(dst: &mut [f32], src: &[f32], delay: &[f32], win: &[f32]) {
472 let c = src [n/2 - 1 - i];
476 dst[i] = d * w1 - c * w0;
477 dst[ii] = d * w0 + c * w1;
481 #[derive(Clone,Copy)]
488 macro_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) {
493 dst[i] += ((src[j] as f64) * $tab[sp.idx][j][i]) as f32;
498 dst[$size - step + i] += ((src[sp.p0 + off + j] as f64) * $tab[sp.idx][sp.p0 + j][i]) as f32;
505 synth_step0_template!(synth_step0_10, AVC_SYNTH_TABS10, 10);
506 synth_step0_template!(synth_step0_20, AVC_SYNTH_TABS20, 20);
507 synth_step0_template!(synth_step0_40, AVC_SYNTH_TABS40, 40);
508 synth_step0_template!(synth_step0_84, AVC_SYNTH_TABS84, 84);
510 fn synth_step1(src: &[f32], dst: &mut [f32], size: usize, stride: usize, step: usize, off: usize, mut p0: usize, win: &[f64])
512 let mut pos = step - 1;
514 let scale = src[p0] as f64;
517 for i in 0..pos.min(step) {
518 dst[pos - i] += (scale * win[i]) as f32;
524 fn zero_some(buf: &mut [FFTComplex], p0: usize, p1: usize)
526 for el in buf.iter_mut().take(p0/2) {
530 buf[p0 / 2].re = 0.0;
533 let dst = &mut buf[len - p1/2..];
534 for el in dst.iter_mut() {
538 buf[len - p1/2 - 1].im = 0.0;
542 fn 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];
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] };
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];
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;
603 const SPARAMS10: [SynthParams; 2] = [
604 SynthParams { p0: 1, p1: 3, idx: 0 },
605 SynthParams { p0: 3, p1: 1, idx: 1 } ];
606 const SPARAMS20: [SynthParams; 2] = [
607 SynthParams { p0: 5, p1: 4, idx: 0 },
608 SynthParams { p0: 4, p1: 5, idx: 1 } ];
609 const SPARAMS40: [SynthParams; 2] = [
610 SynthParams { p0: 11, p1: 8, idx: 0 },
611 SynthParams { p0: 8, p1: 11, idx: 1 } ];
612 const 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 } ];
618 const 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
622 const 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
627 fn synth_filter(src: &[f32], dst: &mut [f32], len: usize, step: usize, bands: usize, idx: usize)
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],
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]);
647 synth_step0_84(src, dst, step, off, params);
648 synth_step1(src, dst, len, bands, step, off, params.p0, &AVC_TAB84[idx]);
652 fn 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;
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);
662 for el in tmp.iter_mut().take(size) { *el = 0.0; }
663 let step = if bands == 2 {
666 } else if sub_size <= 40 {
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);
678 (&mut dst[..size]).copy_from_slice(&tmp[..size]);
681 fn 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; }
689 fn synth1024(dsp: &mut SynthDSP, src: &[f32], dst: &mut [f32], tmpbuf: &mut [f32; COEFFS * 2], is_40khz: bool) {
690 for el in tmpbuf.iter_mut() {
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; }
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);
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);
726 for el in tmp.iter_mut().take(128) {
729 let (size, step, stride) = (256, 84, 4);
730 let off = (size - step) / stride + 1;
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]);
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]);
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 } ];
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]);
755 let (size, step, stride) = (256, 84, 4);
756 let off = (size - step) / stride + 1;
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]);
765 for (i, s) in tmp.chunks(2).take(768/2).enumerate() {
766 dsp.synth_tmp[i] = FFTComplex { re: s[0], im: s[1] };
768 for i in (768..1024).step_by(2) {
769 dsp.synth_tmp[i >> 1] = FFTComplex { re: src[i], im: src[i + 1] };
772 let dst = &mut tmp[768..1024];
773 dst.copy_from_slice(&src[768..1024]);
775 for (i, chunk) in dsp.synth_tmp.chunks_exact_mut(128).enumerate() {
776 zero_some(chunk, SPARAMS84[i].p0, SPARAMS84[i].p1);
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); }
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());
788 let (size, step, stride) = (1024, 84, 4);
789 let off = (size - step) / stride + 1;
791 let src = &tmp[256 * i..];
792 synth_step0_84(src, dst, step, off, &SPARAMS84[i]);
795 fn synth512(dsp: &mut SynthDSP, src: &[f32], dst: &mut [f32], tmpbuf: &mut [f32; COEFFS * 2], is_40khz: bool) {
796 for el in tmpbuf.iter_mut() {
799 let (tmp, tmp2) = tmpbuf.split_at_mut(COEFFS);
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);
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);
833 for el in tmp.iter_mut().take(64) {
836 let (size, step, stride) = (128, 84, 4);
837 let off = (size - step) / stride + 1;
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]);
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]);
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 } ];
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]);
862 let (size, step, stride) = (128, 84, 4);
863 let off = (size - step) / stride + 1;
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]);
872 for (i, s) in tmp.chunks(2).take(384/2).enumerate() {
873 dsp.synth_tmp[i] = FFTComplex { re: s[0], im: s[1] };
875 for i in (384..512).step_by(2) {
876 dsp.synth_tmp[i >> 1] = FFTComplex { re: src[i], im: src[i + 1] };
879 let dst = &mut tmp[384..512];
880 dst.copy_from_slice(&src[384..512]);
882 for (i, chunk) in dsp.synth_tmp.chunks_exact_mut(128).enumerate() {
883 zero_some(chunk, SPARAMS84[i].p0, SPARAMS84[i].p1);
885 for chunk in dsp.synth_tmp.chunks_exact_mut(64) {
886 dsp.irdft64.do_rdft_inplace(chunk);
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);
894 let (size, step, stride) = (512, 84, 4);
895 let off = (size - step) / stride + 1;
897 let src = &tmp[128 * i..];
898 synth_step0_84(src, dst, step, off, &SPARAMS84[i]);
902 fn 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();
907 let mut cur_band = 0;
908 while cur_band < tot_bands {
909 let codebook = br.read(4)? as u8;
912 let run_add = br.read(bits_per_sect)? as usize;
914 if run_add != esc_val { break; }
916 validate!(cur_band + run <= tot_bands);
918 cbs[cur_band] = codebook;
925 fn dequant(val: i16, qtab: &[f32; QTAB_SIZE], scale: f32) -> f32 {
927 qtab[val as usize] * scale
929 -qtab[val.abs() as usize] * scale
933 fn 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);
944 fn 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() {
951 (val as f32) * (val as f32).sqrt()
960 fn 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;
964 let idx1 = (idx << 8) >> 8;
965 if !is_esc || (idx0.abs() < 16) {
966 pair[0] = dequant(idx0, qtab, scale);
968 pair[0] = decode_esc_val(br, qtab, scale, idx0 < 0)?;
970 if !is_esc || (idx1.abs() < 16) {
971 pair[1] = dequant(idx1, qtab, scale);
973 pair[1] = decode_esc_val(br, qtab, scale, idx1 < 0)?;
979 impl 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); },
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;
994 self.win_long = if (srate > 24000) && ((srate > 32000) || (self.channels == 2)) {
1002 Err(DecoderError::InvalidData)
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();
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)?;
1018 let mut offsets: Vec<usize> = Vec::new();
1019 let mut sizes: Vec<usize> = Vec::new();
1021 let mut cur_off = 0;
1022 while cur_off + 2 < src.len() {
1023 let sz = read_u16le(&src[cur_off..])? as usize;
1025 validate!(cur_off + sz + 2 <= src.len());
1026 offsets.push(cur_off + 2);
1031 validate!(!sizes.is_empty());
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)?;
1043 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), abuf);
1044 frm.set_keyframe(true);
1047 fn flush(&mut self) {
1051 pub fn get_decoder_500() -> Box<dyn NADecoder + Send> {
1052 Box::new(AVCDecoder::new(500))
1055 pub fn get_decoder_501() -> Box<dyn NADecoder + Send> {
1056 Box::new(AVCDecoder::new(501))
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;
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);
1073 //let file = "assets/Duck/Cell-140.vp5";
1074 //let file = "assets/Duck/Chocolat-500.vp5";
1075 let file = "assets/Duck/potter-500.vp7";
1076 test_decode_audio("avi", file, Some(1500), None/*Some("avc")*/, &dmx_reg, &dec_reg);
1080 const AVC_WINFO_LONG: WinInfo = WinInfo {
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
1092 const AVC_WINFO_SHORT: WinInfo = WinInfo {
1094 bands: &[ 4, 8, 12, 16, 20, 24, 32, 40, 48, 56, 68, 80, 108, 128 ],
1097 const AVC_WINFO_40K_MODE4: WinInfo = WinInfo {
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
1113 const AVC_WINFO_40K_MODE5: WinInfo = WinInfo {
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
1128 const AVC_WINFO_40K_MODE6: WinInfo = WinInfo {
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
1144 const AVC_WINFO_44K_MODE4: WinInfo = WinInfo {
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
1159 const AVC_WINFO_44K_MODE5: WinInfo = WinInfo {
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,
1174 const AVC_WINFO_44K_MODE6: WinInfo = WinInfo {
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,