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