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_codec_support::dsp::fft::*;
8 use nihav_codec_support::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 0..self.windows {
214 if self.win_grp[wg] {
216 if self.cbs[cur_band] == 0 {
217 let mut all_zero = true;
218 let mut band2 = cur_band;
219 for wg2 in wg + 1..self.windows {
220 if self.win_grp[wg2] {
224 if self.cbs[band2] != 0 {
230 self.scales[cur_band] = 0;
236 scale = br.read(7)? as i16;
239 scale += i16::from(br.read_cb(&self.codebooks.scale_cb)?);
240 validate!((scale >= 0) && (scale < 128));
242 self.scales[cur_band] = scale as u8;
247 self.scales[cur_band] = self.scales[cur_band - bands];
253 let mut cur_band = 0;
255 *coeffs = [0.0; COEFFS];
256 for _ in 0..self.windows {
257 let mut band_start = 0;
258 for band_end in self.winfo.bands.iter() {
259 let band_size = *band_end - band_start;
260 let cb_idx = self.cbs[cur_band];
262 let cb = &self.codebooks.spec_cb[(cb_idx - 1) as usize];
263 let scale = self.scale_tab[self.scales[cur_band] as usize];
264 let dst = &mut coeffs[idx..][..band_size];
266 decode_quads(br, cb, &self.qtab, scale, dst)?;
268 decode_pairs(br, cb, &self.qtab, scale, dst, cb_idx == 15)?;
272 band_start = *band_end;
279 fn decode_frame(&mut self, br: &mut BitReader, adata: &mut NAAudioBuffer<f32>, offset: usize) -> DecoderResult<()> {
280 let enh_flag = br.read_bool()?;
281 validate!(!enh_flag);
282 self.prev_win = self.cur_win;
283 self.cur_win = br.read(3)? as u8;
284 self.winfo = match self.cur_win {
285 3 => &AVC_WINFO_SHORT,
286 4 => if self.is_40khz { &AVC_WINFO_40K_MODE4 } else { &AVC_WINFO_44K_MODE4 },
287 5 => if self.is_40khz { &AVC_WINFO_40K_MODE5 } else { &AVC_WINFO_44K_MODE5 },
288 6 => if self.is_40khz { &AVC_WINFO_40K_MODE6 } else { &AVC_WINFO_44K_MODE6 },
289 _ => &AVC_WINFO_LONG,
291 self.windows = if self.winfo.is_long { 1 } else { 8 };
292 let bands = self.winfo.bands.len();
293 self.win_grp[0] = true;
294 for el in self.win_grp.iter_mut().skip(1).take(self.windows - 1) {
295 *el = !br.read_bool()?;
298 self.ms_present = br.read_bool()?;
300 validate!(self.channels == 2);
301 let mut cur_band = 0;
302 for wg in self.win_grp.iter().take(self.windows) {
305 self.ms_info[cur_band] = br.read_bool()?;
310 self.ms_info[cur_band] = self.ms_info[cur_band - bands];
316 for ch in 0..self.channels {
317 self.decode_channel(br, ch)?;
320 if (self.channels == 2) && self.ms_present {
322 let mut cur_band = 0;
323 for _ in 0..self.windows {
324 let mut band_start = 0;
325 for band_end in self.winfo.bands.iter() {
326 let band_size = *band_end - band_start;
327 if self.ms_info[cur_band] {
328 for i in 0..band_size {
329 let l = self.coeffs[0][idx + i];
330 let r = self.coeffs[1][idx + i];
331 self.coeffs[0][idx + i] = l + r;
332 self.coeffs[1][idx + i] = l - r;
337 band_start = *band_end;
342 for ch in 0..self.channels {
343 let off = adata.get_offset(ch) + offset;
344 let output = adata.get_data_mut().unwrap();
345 self.synth_channel(ch, &mut output[off..][..COEFFS]);
349 #[allow(clippy::cyclomatic_complexity)]
350 fn synth_channel(&mut self, chno: usize, dst: &mut [f32]) {
351 let coeffs = &mut self.coeffs[chno];
352 let delay = &mut self.delay[chno];
356 self.imdct_long.imdct_half(coeffs, &mut self.tmp);
357 overlap_half(dst, &self.tmp, delay, self.win_long);
358 (&mut delay[0..COEFFS/2]).copy_from_slice(&self.tmp[COEFFS/2..COEFFS]);
359 for i in COEFFS/2..COEFFS {
360 delay[i] = delay[COEFFS - 1 - i];
364 self.imdct_long.imdct(coeffs, &mut self.tmp);
365 for i in 0..SHORT_WIN_POINT0 {
368 overlap(&mut dst[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
369 &self.tmp[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
370 &delay[SHORT_WIN_POINT0..SHORT_WIN_POINT1], AVC_WIN_SHORT);
371 for i in SHORT_WIN_POINT1..COEFFS {
372 dst[i] = self.tmp[i - SHORT_WIN_POINT1 + 128];
374 delay.copy_from_slice(&self.tmp[COEFFS..]);
377 for (ain, aout) in coeffs.chunks(128).zip(self.tmp.chunks_mut(256)) {
378 self.imdct_short.imdct(ain, aout);
380 self.ew_buf = [0.0; 1152];
382 self.ew_buf[i] = self.tmp[i];
385 overlap(&mut self.ew_buf[(w + 1) * 128..][..128],
386 &self.tmp[(w + 1) * 256..][..128],
387 &self.tmp[w * 256 + 128..][..128],
391 self.ew_buf[1024 + i] = self.tmp[7 * 256 + 128 + i];
393 for i in 0..SHORT_WIN_POINT0 {
396 overlap(&mut dst[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
397 &self.ew_buf[0..128],
398 &delay[SHORT_WIN_POINT0..SHORT_WIN_POINT1], AVC_WIN_SHORT);
399 for i in SHORT_WIN_POINT1..COEFFS {
400 dst[i] = self.ew_buf[i - SHORT_WIN_POINT1 + 128];
402 for i in 0..SHORT_WIN_POINT1 {
403 delay[i] = self.ew_buf[SHORT_WIN_POINT1 + i];
405 for i in SHORT_WIN_POINT1..COEFFS {
410 for i in 0..SHORT_WIN_POINT0 {
413 if !self.use_generic {
414 synth1024(&mut self.dsp, coeffs, &mut self.ew_buf, &mut self.tmp, self.is_40khz);
416 synth_generic(coeffs, &mut self.ew_buf, &mut self.tmp, self.is_40khz, 1024);
418 overlap_half(&mut dst[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
420 &delay[SHORT_WIN_POINT0..SHORT_WIN_POINT1], AVC_WIN_SHORT);
421 for i in SHORT_WIN_POINT1..COEFFS {
422 dst[i] = self.ew_buf[i - SHORT_WIN_POINT1 + 64];
424 for i in 0..COEFFS/2 {
425 delay[i] = self.ew_buf[COEFFS/2 + i];
427 for i in COEFFS/2..COEFFS {
428 delay[i] = delay[COEFFS - 1 - i];
432 for i in 0..SHORT_WIN_POINT0 {
435 if !self.use_generic {
436 synth512(&mut self.dsp, coeffs, &mut self.ew_buf, &mut self.tmp, self.is_40khz);
438 synth_generic(coeffs, &mut self.ew_buf, &mut self.tmp, self.is_40khz, 512);
440 self.imdct_mid.imdct(&coeffs[512..], &mut self.ew_buf[512..]);
441 overlap(&mut dst[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
442 &self.ew_buf[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
443 &delay[SHORT_WIN_POINT0..SHORT_WIN_POINT1], AVC_WIN_SHORT);
444 for i in SHORT_WIN_POINT1..COEFFS {
445 dst[i] = self.ew_buf[i];
447 *delay = [0.0; COEFFS];
448 for i in 0..SHORT_WIN_POINT1 {
449 delay[i] = self.ew_buf[i];
453 for i in 0..SHORT_WIN_POINT0 {
456 self.imdct_mid.imdct(coeffs, &mut self.ew_buf);
457 if !self.use_generic {
458 synth512(&mut self.dsp, &coeffs[512..], &mut self.ew_buf[512..], &mut self.tmp, self.is_40khz);
460 synth_generic(&coeffs[512..], &mut self.ew_buf[512..], &mut self.tmp, self.is_40khz, 512);
462 overlap(&mut dst[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
463 &self.ew_buf[SHORT_WIN_POINT0..SHORT_WIN_POINT1],
464 &delay[SHORT_WIN_POINT0..SHORT_WIN_POINT1], AVC_WIN_SHORT);
465 for i in SHORT_WIN_POINT1..COEFFS {
466 dst[i] = self.ew_buf[i];
468 *delay = [0.0; COEFFS];
469 for i in 0..SHORT_WIN_POINT1 {
470 delay[i] = self.ew_buf[i];
478 fn overlap(dst: &mut [f32], src: &[f32], delay: &[f32], win: &[f32]) {
479 for (i, ((out, s), d)) in dst.iter_mut().zip(src.iter()).zip(delay.iter()).enumerate() {
480 *out = *s * win[i] + *d * win[win.len() - 1 - i];
484 fn overlap_half(dst: &mut [f32], src: &[f32], delay: &[f32], win: &[f32]) {
488 let c = src [n/2 - 1 - i];
492 dst[i] = d * w1 - c * w0;
493 dst[ii] = d * w0 + c * w1;
497 #[derive(Clone,Copy)]
504 macro_rules! synth_step0_template {
505 ($name:ident, $tab: ident, $size: expr) => {
506 fn $name(src: &[f32], dst: &mut [f32], step: usize, off: usize, sp: &SynthParams) {
509 dst[i] += (f64::from(src[j]) * $tab[sp.idx][j][i]) as f32;
514 dst[$size - step + i] += (f64::from(src[sp.p0 + off + j]) * $tab[sp.idx][sp.p0 + j][i]) as f32;
521 synth_step0_template!(synth_step0_10, AVC_SYNTH_TABS10, 10);
522 synth_step0_template!(synth_step0_20, AVC_SYNTH_TABS20, 20);
523 synth_step0_template!(synth_step0_40, AVC_SYNTH_TABS40, 40);
524 synth_step0_template!(synth_step0_84, AVC_SYNTH_TABS84, 84);
526 fn synth_step1(src: &[f32], dst: &mut [f32], size: usize, stride: usize, step: usize, off: usize, mut p0: usize, win: &[f64])
528 let mut pos = step - 1;
530 let scale = f64::from(src[p0]);
533 for i in 0..pos.min(step) {
534 dst[pos - i] += (scale * win[i]) as f32;
540 fn zero_some(buf: &mut [FFTComplex], p0: usize, p1: usize)
542 for el in buf.iter_mut().take(p0/2) {
546 buf[p0 / 2].re = 0.0;
549 let dst = &mut buf[len - p1/2..];
550 for el in dst.iter_mut() {
554 buf[len - p1/2 - 1].im = 0.0;
558 fn merge_bands(src: &[FFTComplex], dst: &mut [FFTComplex], size: usize) {
559 let step = if size == 512 { 2 } else { 4 };
560 let (s01, s23) = src.split_at(size / 2);
561 let (src0, src1) = s01.split_at(size / 4);
562 let (src2, src3) = s23.split_at(size / 4);
563 let (t00, t01) = AVC_SYNTH_TAB0.split_at(512);
564 let (t10, t11) = AVC_SYNTH_TAB1.split_at(512);
565 let (t20, t21) = AVC_SYNTH_TAB2.split_at(512);
566 let (t30, t31) = AVC_SYNTH_TAB3.split_at(512);
567 let hsize = size / 2;
568 let qsize = size / 4;
569 let osize = size / 8;
570 dst[0].re = src0[0].re * t00[0] + src1[0].re * t10[0] + src2[0].re * t20[0] + src3[0].re * t30[0];
571 dst[0].im = src0[0].re * t00[1] + src1[0].re * t10[1] + src2[0].re * t20[1] + src3[0].re * t30[1];
572 dst[qsize].re = src0[0].im * t00[256] + src1[0].im * t10[256] +
573 src2[0].im * t20[256] + src3[0].im * t30[256];
574 dst[qsize].im = src0[0].im * t00[257] + src1[0].im * t10[257] +
575 src2[0].im * t20[257] + src3[0].im * t30[257];
581 let t0 = s0 * FFTComplex { re: t00[i * step + 0], im: t00[i * step + 1] } +
582 s1 * FFTComplex { re: t10[i * step + 0], im: t10[i * step + 1] } +
583 s2 * FFTComplex { re: t20[i * step + 0], im: t20[i * step + 1] } +
584 s3 * FFTComplex { re: t30[i * step + 0], im: t30[i * step + 1] };
585 let t1 = s0 * FFTComplex { re: t01[i * step + 0], im: t01[i * step + 1] } +
586 s1 * FFTComplex { re: t11[i * step + 0], im: t11[i * step + 1] } +
587 s2 * FFTComplex { re: t21[i * step + 0], im: t21[i * step + 1] } +
588 s3 * FFTComplex { re: t31[i * step + 0], im: t31[i * step + 1] };
593 dst[hsize].re = src0[0].im * t01[256] + src1[0].im * t11[256] +
594 src2[0].im * t21[256] + src3[0].im * t31[256];
595 dst[hsize].im = src0[0].im * t01[257] + src1[0].im * t11[257] +
596 src2[0].im * t21[257] + src3[0].im * t31[257];
597 dst[hsize + qsize].re = src0[0].re * t01[256] + src1[0].re * t11[256] +
598 src2[0].re * t21[256] + src3[0].re * t31[256];
599 dst[hsize + qsize].im = src0[0].re * t01[257] + src1[0].re * t11[257] +
600 src2[0].re * t21[257] + src3[0].re * t31[257];
602 let s0 = !src0[qsize - i];
603 let s1 = !src1[qsize - i];
604 let s2 = !src2[qsize - i];
605 let s3 = !src3[qsize - i];
606 let t0 = s0 * FFTComplex { re: t00[256 + i * step + 0], im: t00[256 + i * step + 1] } +
607 s1 * FFTComplex { re: t10[256 + i * step + 0], im: t10[256 + i * step + 1] } +
608 s2 * FFTComplex { re: t20[256 + i * step + 0], im: t20[256 + i * step + 1] } +
609 s3 * FFTComplex { re: t30[256 + i * step + 0], im: t30[256 + i * step + 1] };
610 let t1 = s0 * FFTComplex { re: t01[256 + i * step + 0], im: t01[256 + i * step + 1] } +
611 s1 * FFTComplex { re: t11[256 + i * step + 0], im: t11[256 + i * step + 1] } +
612 s2 * FFTComplex { re: t21[256 + i * step + 0], im: t21[256 + i * step + 1] } +
613 s3 * FFTComplex { re: t31[256 + i * step + 0], im: t31[256 + i * step + 1] };
614 dst[hsize + i] = !t0;
615 dst[hsize + qsize + i] = !t1;
619 const SPARAMS10: [SynthParams; 2] = [
620 SynthParams { p0: 1, p1: 3, idx: 0 },
621 SynthParams { p0: 3, p1: 1, idx: 1 } ];
622 const SPARAMS20: [SynthParams; 2] = [
623 SynthParams { p0: 5, p1: 4, idx: 0 },
624 SynthParams { p0: 4, p1: 5, idx: 1 } ];
625 const SPARAMS40: [SynthParams; 2] = [
626 SynthParams { p0: 11, p1: 8, idx: 0 },
627 SynthParams { p0: 8, p1: 11, idx: 1 } ];
628 const SPARAMS84: [SynthParams; 4] = [
629 SynthParams { p0: 16, p1: 4, idx: 0 },
630 SynthParams { p0: 16, p1: 4, idx: 1 },
631 SynthParams { p0: 13, p1: 7, idx: 2 },
632 SynthParams { p0: 15, p1: 5, idx: 3 } ];
634 const MERGE_ORDER_44K: &[u8] = &[
635 4, 4, 2, 2, 0, 0, 2, 0, 0, 2, 2, 0, 0, 2, 0, 0, 2, 0, 0,
636 2, 0, 0, 4, 0, 0, 0, 0, 2, 0, 0, 0
638 const MERGE_ORDER_40K: &[u8] = &[
639 4, 4, 2, 2, 0, 0, 2, 0, 0, 2, 2, 0, 0, 2, 0, 0, 2, 0, 0,
640 2, 0, 0, 4, 2, 0, 0, 2, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0
643 fn synth_filter(src: &[f32], dst: &mut [f32], len: usize, step: usize, bands: usize, idx: usize)
645 let off = (len - step) / bands + 1;
646 let params = match step {
647 10 => &SPARAMS10[idx],
648 20 => &SPARAMS20[idx],
649 40 => &SPARAMS40[idx],
650 _ => &SPARAMS84[idx],
654 synth_step0_10(src, dst, step, off, params);
655 synth_step1(src, dst, len, bands, step, off, params.p0, &AVC_TAB10[idx]);
656 } else if step == 20 {
657 synth_step0_20(src, dst, step, off, params);
658 synth_step1(src, dst, len, bands, step, off, params.p0, &AVC_TAB20[idx]);
659 } else if step == 40 {
660 synth_step0_40(src, dst, step, off, params);
661 synth_step1(src, dst, len, bands, step, off, params.p0, &AVC_TAB40[idx]);
663 synth_step0_84(src, dst, step, off, params);
664 synth_step1(src, dst, len, bands, step, off, params.p0, &AVC_TAB84[idx]);
668 fn synth_recursive(dst: &mut [f32], tmp: &mut [f32], size: usize, order: &[u8], order_idx: &mut usize, dir: bool) {
669 let bands = order[*order_idx] as usize;
671 if bands == 0 { return; }
672 let sub_size = size / bands;
673 let mut sub_dir = false;
674 for (dst, tmp) in dst.chunks_mut(sub_size).take(bands).zip(tmp.chunks_mut(sub_size)) {
675 synth_recursive(dst, tmp, sub_size, order, order_idx, sub_dir);
678 for el in tmp.iter_mut().take(size) { *el = 0.0; }
679 let step = if bands == 2 {
682 } else if sub_size <= 40 {
690 for (i, src) in dst.chunks_mut(sub_size).take(bands).enumerate() {
691 let idx = if !dir { i } else { bands - 1 - i };
692 synth_filter(src, tmp, size, step, bands, idx);
694 (&mut dst[..size]).copy_from_slice(&tmp[..size]);
697 fn synth_generic(src: &[f32], dst: &mut [f32], tmpbuf: &mut [f32; COEFFS * 2], is_40khz: bool, size: usize) {
698 let order = if is_40khz { MERGE_ORDER_40K } else { MERGE_ORDER_44K };
699 (&mut dst[..size]).copy_from_slice(&src[..size]);
700 let mut order_idx = 0;
701 synth_recursive(dst, tmpbuf, size, order, &mut order_idx, false);
702 for el in dst.iter_mut().take(COEFFS) { *el *= 0.125; }
705 fn synth1024(dsp: &mut SynthDSP, src: &[f32], dst: &mut [f32], tmpbuf: &mut [f32; COEFFS * 2], is_40khz: bool) {
706 for el in tmpbuf.iter_mut() {
709 let (tmp, tmp2) = tmpbuf.split_at_mut(COEFFS);
710 for el in dsp.synth_tmp.iter_mut() { *el = FFTC_ZERO; }
711 for el in dsp.synth_out.iter_mut() { *el = FFTC_ZERO; }
713 let (size, step, stride) = (32, 20, 2);
714 let off = (size - step) / stride + 1;
715 let mut sparam0 = SynthParams { p0: 5, p1: 4, idx: 0 };
716 let mut sparam1 = SynthParams { p0: 4, p1: 5, idx: 1 };
717 for (i, dst) in tmp.chunks_mut(size).take(8).enumerate() {
718 let coeffs = &src[i * 32..];
719 synth_step0_20(coeffs, dst, step, off, &sparam0);
720 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, &AVC_TAB20[sparam0.idx]);
721 let coeffs = &src[i * 32 + 16..];
722 synth_step0_20(coeffs, dst, step, off, &sparam1);
723 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, &AVC_TAB20[sparam1.idx]);
724 std::mem::swap(&mut sparam0, &mut sparam1);
727 let (size, step, stride) = (64, 40, 2);
728 let off = (size - step) / stride + 1;
729 let mut sparam0 = SynthParams { p0: 11, p1: 8, idx: 0 };
730 let mut sparam1 = SynthParams { p0: 8, p1: 11, idx: 1 };
731 let nchunks = if !is_40khz { 8 } else { 12 };
732 for (i, dst) in tmp2.chunks_mut(size).take(nchunks).enumerate() {
733 let coeffs = if i < 4 { &tmp[i * 64..] } else { &src[i * 64 + 32..] };
734 synth_step0_40(coeffs, dst, step, off, &sparam0);
735 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, &AVC_TAB40[sparam0.idx]);
736 let coeffs = if i < 4 { &tmp[i * 64 + 32..] } else { &src[i * 64 + 32..] };
737 synth_step0_40(coeffs, dst, step, off, &sparam1);
738 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, &AVC_TAB40[sparam1.idx]);
739 std::mem::swap(&mut sparam0, &mut sparam1);
742 for el in tmp.iter_mut().take(128) {
745 let (size, step, stride) = (256, 84, 4);
746 let off = (size - step) / stride + 1;
748 let coeffs = &tmp2[i * 64..];
749 synth_step0_84(coeffs, tmp, step, off, &SPARAMS84[i]);
750 synth_step1(coeffs, tmp, size, stride, step, off, SPARAMS84[i].p0, &AVC_TAB84[i]);
753 let coeffs = if i < 2 && is_40khz { &tmp2[256 + i * 64..] } else { &src[256 + i * 64..] };
754 let dst = &mut tmp[256..];
755 synth_step0_84(coeffs, dst, step, off, &SPARAMS84[3 - i]);
756 synth_step1(coeffs, dst, size, stride, step, off, SPARAMS84[3 - i].p0, &AVC_TAB84[3 - i]);
760 let (size, step, stride) = (256, 40, 2);
761 let off = (size - step) / stride + 1;
762 let sparams = [ SynthParams { p0: 11, p1: 8, idx: 0 },
763 SynthParams { p0: 8, p1: 11, idx: 1 } ];
765 let coeffs = &src[512 + i * 128..];
766 let dst = &mut tmp[512..];
767 synth_step0_40(coeffs, dst, step, off, &sparams[i]);
768 synth_step1(coeffs, dst, size, stride, step, off, sparams[i].p0, &AVC_TAB40[i]);
771 let (size, step, stride) = (256, 84, 4);
772 let off = (size - step) / stride + 1;
774 let coeffs = &src[512 + i * 64..];
775 let dst = &mut tmp[512..];
776 synth_step0_84(coeffs, dst, step, off, &SPARAMS84[i]);
777 synth_step1(coeffs, dst, size, stride, step, off, SPARAMS84[i].p0, &AVC_TAB84[i]);
781 for (i, s) in tmp.chunks(2).take(768/2).enumerate() {
782 dsp.synth_tmp[i] = FFTComplex { re: s[0], im: s[1] };
784 for i in (768..1024).step_by(2) {
785 dsp.synth_tmp[i >> 1] = FFTComplex { re: src[i], im: src[i + 1] };
788 let dst = &mut tmp[768..1024];
789 dst.copy_from_slice(&src[768..1024]);
791 for (i, chunk) in dsp.synth_tmp.chunks_exact_mut(128).enumerate() {
792 zero_some(chunk, SPARAMS84[i].p0, SPARAMS84[i].p1);
794 for chunk in dsp.synth_tmp.chunks_exact_mut(128) {
795 dsp.irdft128.do_rdft_inplace(chunk);
796 for el in chunk.iter_mut() { *el = el.scale(1.0/128.0f32); }
798 merge_bands(&dsp.synth_tmp, &mut dsp.synth_out, 512);
799 dsp.rdft512.do_rdft_inplace(&mut dsp.synth_out);
800 for (out, src) in dst.chunks_exact_mut(2).zip(dsp.synth_out.iter()) {
801 out[0] = src.re * (1.0 / 1024.0f32.sqrt());
802 out[1] = src.im * (1.0 / 1024.0f32.sqrt());
804 let (size, step, stride) = (1024, 84, 4);
805 let off = (size - step) / stride + 1;
807 let src = &tmp[256 * i..];
808 synth_step0_84(src, dst, step, off, &SPARAMS84[i]);
811 fn synth512(dsp: &mut SynthDSP, src: &[f32], dst: &mut [f32], tmpbuf: &mut [f32; COEFFS * 2], is_40khz: bool) {
812 for el in tmpbuf.iter_mut() {
815 let (tmp, tmp2) = tmpbuf.split_at_mut(COEFFS);
817 let (size, step, stride) = (16, 10, 2);
818 let off = (size - step) / stride + 1;
819 let mut sparam0 = SynthParams { p0: 1, p1: 3, idx: 0 };
820 let mut sparam1 = SynthParams { p0: 3, p1: 1, idx: 1 };
821 let mut tab_ptr0: &[f64] = AVC_TAB10_0;
822 let mut tab_ptr1: &[f64] = AVC_TAB10_1;
823 for (i, dst) in tmp.chunks_mut(size).take(8).enumerate() {
824 let coeffs = &src[i * 16..];
825 synth_step0_10(coeffs, dst, step, off, &sparam0);
826 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, tab_ptr0);
827 let coeffs = &src[i * 16 + 8..];
828 synth_step0_10(coeffs, dst, step, off, &sparam1);
829 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, tab_ptr1);
830 std::mem::swap(&mut sparam0, &mut sparam1);
831 std::mem::swap(&mut tab_ptr0, &mut tab_ptr1);
834 let (size, step, stride) = (32, 20, 2);
835 let off = (size - step) / stride + 1;
836 let mut sparam0 = SynthParams { p0: 5, p1: 4, idx: 0 };
837 let mut sparam1 = SynthParams { p0: 4, p1: 5, idx: 1 };
838 let nchunks = if !is_40khz { 8 } else { 12 };
839 for (i, dst) in tmp2.chunks_mut(size).take(nchunks).enumerate() {
840 let coeffs = if i < 4 { &tmp[i * 32..] } else { &src[i * 32..] };
841 synth_step0_20(coeffs, dst, step, off, &sparam0);
842 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, &AVC_TAB20[sparam0.idx]);
843 let coeffs = if i < 4 { &tmp[i * 32 + 16..] } else { &src[i * 32 + 16..] };
844 synth_step0_20(coeffs, dst, step, off, &sparam1);
845 synth_step1(coeffs, dst, size, stride, step, off, sparam0.p0, &AVC_TAB20[sparam1.idx]);
846 std::mem::swap(&mut sparam0, &mut sparam1);
849 for el in tmp.iter_mut().take(64) {
852 let (size, step, stride) = (128, 84, 4);
853 let off = (size - step) / stride + 1;
855 let coeffs = &tmp2[i * 32..];
856 synth_step0_84(coeffs, tmp, step, off, &SPARAMS84[i]);
857 synth_step1(coeffs, tmp, size, stride, step, off, SPARAMS84[i].p0, &AVC_TAB84[i]);
860 let coeffs = if i < 2 && is_40khz { &tmp2[128 + i * 32..] } else { &src[128 + i * 32..] };
861 let dst = &mut tmp[128..];
862 synth_step0_84(coeffs, dst, step, off, &SPARAMS84[3 - i]);
863 synth_step1(coeffs, dst, size, stride, step, off, SPARAMS84[3 - i].p0, &AVC_TAB84[3 - i]);
867 let (size, step, stride) = (128, 40, 2);
868 let off = (size - step) / stride + 1;
869 let sparams = [ SynthParams { p0: 11, p1: 8, idx: 0 },
870 SynthParams { p0: 8, p1: 11, idx: 1 } ];
872 let coeffs = &src[256 + i * 64..];
873 let dst = &mut tmp[256..];
874 synth_step0_40(coeffs, dst, step, off, &sparams[i]);
875 synth_step1(coeffs, dst, size, stride, step, off, sparams[i].p0, &AVC_TAB40[i]);
878 let (size, step, stride) = (128, 84, 4);
879 let off = (size - step) / stride + 1;
881 let coeffs = &src[256 + i * 32..];
882 let dst = &mut tmp[256..];
883 synth_step0_84(coeffs, dst, step, off, &SPARAMS84[i]);
884 synth_step1(coeffs, dst, size, stride, step, off, SPARAMS84[i].p0, &AVC_TAB84[i]);
888 for (i, s) in tmp.chunks(2).take(384/2).enumerate() {
889 dsp.synth_tmp[i] = FFTComplex { re: s[0], im: s[1] };
891 for i in (384..512).step_by(2) {
892 dsp.synth_tmp[i >> 1] = FFTComplex { re: src[i], im: src[i + 1] };
895 let dst = &mut tmp[384..512];
896 dst.copy_from_slice(&src[384..512]);
898 for (i, chunk) in dsp.synth_tmp.chunks_exact_mut(128).enumerate() {
899 zero_some(chunk, SPARAMS84[i].p0, SPARAMS84[i].p1);
901 for chunk in dsp.synth_tmp.chunks_exact_mut(64) {
902 dsp.irdft64.do_rdft_inplace(chunk);
904 merge_bands(&dsp.synth_tmp, &mut dsp.synth_out, 256);
905 dsp.rdft256.do_rdft_inplace(&mut dsp.synth_out);
906 for (out, src) in dst.chunks_exact_mut(2).zip(dsp.synth_out.iter()).take(256) {
907 out[0] = src.re * (1.0 / 512.0f32 / 1024.0f32);
908 out[1] = src.im * (1.0 / 512.0f32 / 1024.0f32);
910 let (size, step, stride) = (512, 84, 4);
911 let off = (size - step) / stride + 1;
913 let src = &tmp[128 * i..];
914 synth_step0_84(src, dst, step, off, &SPARAMS84[i]);
918 fn decode_band_types(br: &mut BitReader, cbs: &mut [u8; MAX_BANDS], winfo: &WinInfo) -> DecoderResult<()> {
919 let bits_per_sect = if winfo.is_long { 5 } else { 3 };
920 let esc_val = (1 << bits_per_sect) - 1;
921 let tot_bands = winfo.get_tot_bands();
923 let mut cur_band = 0;
924 while cur_band < tot_bands {
925 let codebook = br.read(4)? as u8;
928 let run_add = br.read(bits_per_sect)? as usize;
930 if run_add != esc_val { break; }
932 validate!(cur_band + run <= tot_bands);
934 cbs[cur_band] = codebook;
941 fn dequant(val: i16, qtab: &[f32; QTAB_SIZE], scale: f32) -> f32 {
943 qtab[val as usize] * scale
945 -qtab[val.abs() as usize] * scale
949 fn decode_quads(br: &mut BitReader, cb: &Codebook<u16>, qtab: &[f32; QTAB_SIZE], scale: f32, dst: &mut [f32]) -> DecoderResult<()> {
950 for quad in dst.chunks_exact_mut(4) {
951 let mut idx = br.read_cb(cb)? as i16;
952 for el in quad.iter_mut() {
953 *el = dequant(idx >> 12, qtab, scale);
960 fn decode_esc_val(br: &mut BitReader, qtab: &[f32; QTAB_SIZE], scale: f32, sign: bool) -> DecoderResult<f32> {
961 let pfx = br.read_code(UintCodeType::LimitedOnes(24))? + 4;
962 let add = br.read(pfx as u8)? as usize;
963 let val = (1 << pfx) + add;
964 let fval = scale * if val < qtab.len() {
967 (val as f32) * (val as f32).sqrt()
976 fn decode_pairs(br: &mut BitReader, cb: &Codebook<u16>, qtab: &[f32; QTAB_SIZE], scale: f32, dst: &mut [f32], is_esc: bool) -> DecoderResult<()> {
977 for pair in dst.chunks_exact_mut(2) {
978 let idx = br.read_cb(cb)? as i16;
980 let idx1 = (idx << 8) >> 8;
981 if !is_esc || (idx0.abs() < 16) {
982 pair[0] = dequant(idx0, qtab, scale);
984 pair[0] = decode_esc_val(br, qtab, scale, idx0 < 0)?;
986 if !is_esc || (idx1.abs() < 16) {
987 pair[1] = dequant(idx1, qtab, scale);
989 pair[1] = decode_esc_val(br, qtab, scale, idx1 < 0)?;
995 impl NADecoder for AVCDecoder {
996 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
997 if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
998 self.chmap = match ainfo.get_channels() {
999 1 => { NAChannelMap::from_str("C").unwrap() },
1000 2 => { NAChannelMap::from_str("L,R").unwrap() },
1001 _ => { return Err(DecoderError::InvalidData); },
1003 let srate = ainfo.get_sample_rate();
1004 self.ainfo = NAAudioInfo::new(srate, ainfo.get_channels(),
1005 SND_F32P_FORMAT, COEFFS);
1006 self.info = info.replace_info(NACodecTypeInfo::Audio(self.ainfo));
1007 self.channels = ainfo.get_channels() as usize;
1008 self.is_40khz = srate <= 40000;
1010 self.win_long = if (srate > 24000) && ((srate > 32000) || (self.channels == 2)) {
1018 Err(DecoderError::InvalidData)
1021 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1022 let info = pkt.get_stream().get_info();
1023 validate!(info.get_properties().is_audio());
1024 let src = pkt.get_buffer();
1028 if self.version == 500 {
1029 abuf = alloc_audio_buffer(self.ainfo, COEFFS, self.chmap.clone())?;
1030 let mut adata = abuf.get_abuf_f32().unwrap();
1031 let mut br = BitReader::new(src.as_slice(), BitReaderMode::BE);
1032 self.decode_frame(&mut br, &mut adata, 0)?;
1034 let mut offsets: Vec<usize> = Vec::new();
1035 let mut sizes: Vec<usize> = Vec::new();
1037 let mut cur_off = 0;
1038 while cur_off + 2 < src.len() {
1039 let sz = read_u16le(&src[cur_off..])? as usize;
1041 validate!(cur_off + sz + 2 <= src.len());
1042 offsets.push(cur_off + 2);
1047 validate!(!sizes.is_empty());
1049 abuf = alloc_audio_buffer(self.ainfo, COEFFS * sizes.len(), self.chmap.clone())?;
1050 let mut adata = abuf.get_abuf_f32().unwrap();
1051 let mut aoffset = 0;
1052 for (o, s) in offsets.iter().zip(sizes.iter()) {
1053 let mut br = BitReader::new(&src[*o..][..*s], BitReaderMode::BE);
1054 self.decode_frame(&mut br, &mut adata, aoffset)?;
1059 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), abuf);
1060 frm.set_keyframe(true);
1063 fn flush(&mut self) {
1067 impl NAOptionHandler for AVCDecoder {
1068 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
1069 fn set_options(&mut self, _options: &[NAOption]) { }
1070 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
1073 pub fn get_decoder_500() -> Box<dyn NADecoder + Send> {
1074 Box::new(AVCDecoder::new(500))
1077 pub fn get_decoder_501() -> Box<dyn NADecoder + Send> {
1078 Box::new(AVCDecoder::new(501))
1083 use nihav_core::codecs::RegisteredDecoders;
1084 use nihav_core::demuxers::RegisteredDemuxers;
1085 use nihav_codec_support::test::dec_video::*;
1086 use crate::duck_register_all_decoders;
1087 use nihav_commonfmt::generic_register_all_demuxers;
1090 let mut dmx_reg = RegisteredDemuxers::new();
1091 generic_register_all_demuxers(&mut dmx_reg);
1092 let mut dec_reg = RegisteredDecoders::new();
1093 duck_register_all_decoders(&mut dec_reg);
1095 //let file = "assets/Duck/Cell-140.vp5";
1096 //let file = "assets/Duck/Chocolat-500.vp5";
1097 let file = "assets/Duck/potter-500.vp7";
1098 test_decode_audio("avi", file, Some(1500), None/*Some("avc")*/, &dmx_reg, &dec_reg);
1102 const AVC_WINFO_LONG: WinInfo = WinInfo {
1105 4, 8, 12, 16, 20, 24, 28, 32,
1106 36, 40, 48, 56, 64, 72, 80, 88,
1107 96, 108, 120, 132, 144, 156, 172, 188,
1108 204, 224, 244, 264, 288, 312, 340, 368,
1109 400, 432, 464, 496, 528, 560, 592, 624,
1110 656, 688, 720, 752, 784, 816, 848, 880, 1024
1114 const AVC_WINFO_SHORT: WinInfo = WinInfo {
1116 bands: &[ 4, 8, 12, 16, 20, 24, 32, 40, 48, 56, 68, 80, 108, 128 ],
1119 const AVC_WINFO_40K_MODE4: WinInfo = WinInfo {
1122 8, 16, 24, 32, 40, 48, 56, 64,
1123 72, 80, 88, 96, 104, 112, 120, 128,
1124 144, 160, 176, 192, 208, 224, 240, 256,
1125 264, 272, 280, 288, 296, 304, 312, 320,
1126 328, 336, 344, 352, 360, 368, 376, 384,
1127 400, 416, 432, 448, 464, 480, 496, 512,
1128 520, 528, 536, 544, 552, 560, 568, 576,
1129 584, 592, 600, 608, 616, 624, 632, 640,
1130 648, 656, 664, 672, 680, 688, 696, 704,
1131 712, 720, 728, 736, 744, 752, 760, 768,
1132 800, 832, 864, 896, 928, 960, 992, 1024
1135 const AVC_WINFO_40K_MODE5: WinInfo = WinInfo {
1138 8, 16, 24, 32, 40, 48, 56, 64,
1139 80, 96, 112, 128, 136, 144, 152, 160,
1140 168, 176, 184, 192, 208, 224, 240, 256,
1141 264, 272, 280, 288, 296, 304, 312, 320,
1142 328, 336, 344, 352, 360, 368, 376, 384,
1143 416, 448, 480, 512, 516, 520, 524, 528,
1144 532, 536, 540, 548, 556, 568, 580, 592,
1145 608, 624, 640, 656, 672, 688, 704, 720,
1146 736, 752, 768, 784, 800, 816, 832, 848,
1147 864, 880, 896, 912, 928, 944, 1024
1150 const AVC_WINFO_40K_MODE6: WinInfo = WinInfo {
1153 4, 8, 12, 16, 20, 24, 28, 36,
1154 44, 56, 68, 80, 96, 112, 128, 144,
1155 160, 176, 192, 208, 224, 240, 256, 272,
1156 288, 304, 320, 336, 352, 368, 384, 400,
1157 416, 432, 512, 520, 528, 536, 544, 552,
1158 560, 568, 576, 592, 608, 624, 640, 648,
1159 656, 664, 672, 680, 688, 696, 704, 720,
1160 736, 752, 768, 776, 784, 792, 800, 808,
1161 816, 824, 832, 840, 848, 856, 864, 872,
1162 880, 888, 896, 928, 960, 992, 1024
1166 const AVC_WINFO_44K_MODE4: WinInfo = WinInfo {
1169 8, 16, 24, 32, 40, 48, 56, 64,
1170 72, 80, 88, 96, 104, 112, 120, 128,
1171 136, 144, 152, 160, 168, 176, 184, 192,
1172 200, 208, 216, 224, 232, 240, 248, 256,
1173 264, 272, 280, 288, 296, 304, 312, 320,
1174 328, 336, 344, 352, 360, 368, 376, 384,
1175 392, 400, 408, 416, 424, 432, 440, 448,
1176 456, 464, 472, 480, 488, 496, 504, 512,
1177 528, 544, 560, 576, 592, 608, 624, 640,
1178 672, 704, 736, 768, 832, 896, 960, 1024
1181 const AVC_WINFO_44K_MODE5: WinInfo = WinInfo {
1184 8, 16, 24, 32, 40, 48, 56, 64,
1185 72, 80, 88, 96, 104, 112, 120, 128,
1186 136, 144, 152, 160, 168, 176, 184, 192,
1187 200, 208, 216, 224, 232, 240, 248, 256,
1188 272, 288, 304, 320, 352, 384, 448, 512,
1189 516, 520, 524, 528, 532, 536, 540, 548,
1190 556, 568, 580, 592, 608, 624, 640, 656,
1191 672, 688, 704, 720, 736, 752, 768, 784,
1192 800, 816, 832, 848, 864, 880, 896, 912,
1196 const AVC_WINFO_44K_MODE6: WinInfo = WinInfo {
1199 4, 8, 12, 16, 20, 24, 28, 36,
1200 44, 56, 68, 80, 96, 112, 128, 144,
1201 160, 176, 192, 208, 224, 240, 256, 272,
1202 288, 304, 320, 336, 352, 368, 384, 400,
1203 416, 432, 512, 520, 528, 536, 544, 552,
1204 560, 568, 576, 584, 592, 600, 608, 616,
1205 624, 632, 640, 648, 656, 664, 672, 680,
1206 688, 696, 704, 712, 720, 728, 736, 744,
1207 752, 760, 768, 784, 800, 816, 832, 864,