nihav-duck/src/codecs/on2avc.rs

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