nihav-commonfmt/src/codecs/atrac3.rs

   1 use nihav_core::formats::*;
   2 use nihav_core::frame::*;
   3 use nihav_core::codecs::*;
   4 use nihav_core::io::bitreader::*;
   5 use nihav_core::io::byteio::*;
   6 use nihav_core::io::codebook::*;
   7 use nihav_core::dsp::fft::FFTMode;
   8 use nihav_core::dsp::mdct::IMDCT;
   9 use std::f32::consts;
  10
  11 #[derive(Clone,Copy,PartialEq)]
  12 enum Mode {
  13     Mono,
  14     Stereo,
  15     JointStereo,
  16 }
  17
  18 const ATRAC3_FRAME_SIZE: usize = 1024;
  19
  20 #[derive(Clone,Copy)]
  21 struct Tone {
  22     pos:        usize,
  23     ncoeffs:    usize,
  24     coeffs:     [f32; 8],
  25 }
  26
  27 struct GainData {
  28     ngains:     [usize; 4],
  29     gain_lev:   [[usize; 8]; 4],
  30     gain_loc:   [[usize; 8]; 4],
  31 }
  32
  33 impl GainData {
  34     fn new() -> Self {
  35         Self {
  36             ngains:     [0; 4],
  37             gain_lev:   [[0; 8]; 4],
  38             gain_loc:   [[0; 8]; 4],
  39         }
  40     }
  41     fn read(&mut self, br: &mut BitReader, bands: usize) -> DecoderResult<()> {
  42         self.ngains = [0; 4];
  43         for band in 0..bands {
  44             self.ngains[band]                           = br.read(3)? as usize;
  45             for i in 0..self.ngains[band] {
  46                 self.gain_lev[band][i]                  = br.read(4)? as usize;
  47                 self.gain_loc[band][i]                  = br.read(5)? as usize;
  48             }
  49         }
  50         Ok(())
  51     }
  52 }
  53
  54 struct Channel {
  55     data:       [f32; ATRAC3_FRAME_SIZE],
  56     delay:      [f32; ATRAC3_FRAME_SIZE],
  57     qmf_delay:  [f32; 64 * 3],
  58
  59     bands:      usize,
  60     block_no:   usize,
  61
  62     gain_data:  [GainData; 2],
  63
  64     subbands:   usize,
  65     components: usize,
  66     ntones:     usize,
  67     tones:      [Tone; 64],
  68 }
  69
  70 impl Channel {
  71     fn new() -> Self {
  72         Self {
  73             data:       [0.0; ATRAC3_FRAME_SIZE],
  74             delay:      [0.0; ATRAC3_FRAME_SIZE],
  75             qmf_delay:  [0.0; 64 * 3],
  76
  77             bands:      0,
  78             block_no:   0,
  79
  80             gain_data:  [GainData::new(), GainData::new()],
  81
  82             subbands:   0,
  83             components: 0,
  84             ntones:     0,
  85             tones:      [Tone {pos: 0, ncoeffs: 0, coeffs: [0.0; 8]}; 64],
  86         }
  87     }
  88     fn decode_unit(&mut self, br: &mut BitReader, codebooks: &[Codebook<u8>; 7], scalefactors: &[f32; 64]) -> DecoderResult<()> {
  89         self.bands                                      = (br.read(2)? as usize) + 1;
  90         self.gain_data[self.block_no].read(br, self.bands)?;
  91         self.data = [0.0; ATRAC3_FRAME_SIZE];
  92
  93         self.ntones = 0;
  94         self.components                                 = br.read(5)? as usize;
  95         if self.components > 0 {
  96             let selector                                = br.read(2)?;
  97             validate!(selector != 2);
  98             let mut mode0 = (selector & 1) != 0;
  99
 100             for _ in 0..self.components {
 101                 let mut flags: [bool; 4] = [false; 4];
 102                 for band in 0..self.bands {
 103                     flags[band]                         = br.read_bool()?;
 104                 }
 105                 let nvals                               = br.read(3)? as usize;
 106                 let quant                               = br.read(3)? as usize;
 107                 validate!(quant > 1);
 108                 if selector == 3 {
 109                     mode0                               = br.read_bool()?;
 110                 }
 111                 for j in 0..self.bands*4 {
 112                     if !flags[j >> 2] { continue; }
 113                     let count                           = br.read(3)? as usize;
 114                     validate!(self.ntones + count < 64);
 115                     for _ in 0..count {
 116                         let scale_idx                   = br.read(6)? as usize;
 117                         let tone = &mut self.tones[self.ntones];
 118                         tone.pos                        = (br.read(6)? as usize) + j * 64;
 119                         tone.ncoeffs                    = (ATRAC3_FRAME_SIZE - tone.pos).min(nvals + 1);
 120                         let scale = scalefactors[scale_idx] * ATRAC3_MAX_QUANT[quant];
 121                         read_coeffs(br, codebooks, &mut tone.coeffs[..tone.ncoeffs], quant, scale, mode0)?;
 122                         self.ntones += 1;
 123                     }
 124                 }
 125             }
 126         }
 127
 128         // spectrum
 129         let mut quants: [usize; 32] = [0; 32];
 130         let mut scf:    [usize; 32] = [0; 32];
 131         self.subbands                                   = (br.read(5)? as usize) + 1;
 132         let mode0                                       = br.read_bool()?;
 133         for i in 0..self.subbands {
 134             quants[i]                                   = br.read(3)? as usize;
 135         }
 136         for i in 0..self.subbands {
 137             if quants[i] == 0 { continue; }
 138             scf[i]                                      = br.read(6)? as usize;
 139         }
 140
 141         self.data = [0.0; ATRAC3_FRAME_SIZE];
 142         for i in 0..self.subbands {
 143             if quants[i] == 0 { continue; }
 144             let start = ATRAC3_SUBBANDS[i];
 145             let end   = ATRAC3_SUBBANDS[i + 1];
 146             let scale = scalefactors[scf[i]] * ATRAC3_MAX_QUANT[quants[i]];
 147             read_coeffs(br, codebooks, &mut self.data[start..end], quants[i], scale, mode0)?;
 148         }
 149
 150         for i in 0..self.ntones {
 151             let tone = &self.tones[i];
 152             for j in 0..tone.ncoeffs {
 153                 self.data[tone.pos + j] += tone.coeffs[j];
 154             }
 155         }
 156         Ok(())
 157     }
 158     fn synth(&mut self, dsp: &mut DSP) {
 159         let mut flag = 0;
 160         let mut band = 0;
 161         for (data, delay) in self.data.chunks_mut(256).zip(self.delay.chunks_mut(256)) {
 162             if (flag & 1) != 0 {
 163                 for i in 0..128 {
 164                     let t0 = data[i];
 165                     let t1 = data[255 - i];
 166                     data[i]         = t1;
 167                     data[255 - i]   = t0;
 168                 }
 169             }
 170             dsp.synth_band(data);
 171             dsp.apply_gains(data, delay, &mut self.gain_data, self.block_no, band);
 172             delay.copy_from_slice(&dsp.tmp[256..512]);
 173             flag ^= 1;
 174             band += 1;
 175         }
 176         self.block_no ^= 1;
 177     }
 178     fn do_qmf(&mut self, dsp: &mut DSP, dst: &mut [f32]) {
 179         let mut qchunks = self.qmf_delay.chunks_mut(64);
 180         let qmf0 = qchunks.next().unwrap();
 181         let qmf1 = qchunks.next().unwrap();
 182         let qmf2 = qchunks.next().unwrap();
 183         {
 184             let mut tchunks = self.data.chunks_mut(512);
 185             let tmp0 = tchunks.next().unwrap();
 186             let tmp1 = tchunks.next().unwrap();
 187             dsp.do_qmf(tmp0, qmf0, false);
 188             dsp.do_qmf(tmp1, qmf1, true);
 189         }
 190         dsp.do_qmf_out(dst, &self.data, qmf2);
 191     }
 192 }
 193
 194 const ATRAC3_DEFAULT_DELAY: usize = 2190;
 195 const ATRAC3_WEIGHTING_DELAYS: [u8; 6] = [ 0, 7, 0, 7, 0, 7 ];
 196
 197 fn read_coeffs(br: &mut BitReader, cb: &[Codebook<u8>; 7], dst: &mut [f32], quant: usize, scale: f32, mode0: bool) -> DecoderResult<()> {
 198     if mode0 {
 199         read_coeffs_mode0(br, dst, quant, scale)
 200     } else if quant == 1 {
 201         read_coeffs_mode1(br, &cb[0], dst, scale)
 202     } else {
 203         read_coeffs_other(br, &cb[quant - 1], dst, scale)
 204     }
 205 }
 206
 207 const ATRAC3_MODE0_CB: [f32; 4] = [ 0.0, 1.0, -2.0, -1.0 ];
 208 const ATRAC3_MODE0_BITS: [u8; 8] = [ 0, 4, 3, 3, 4, 4, 5, 6 ];
 209
 210 fn read_coeffs_mode0(br: &mut BitReader, dst: &mut [f32], quant: usize, scale: f32) -> DecoderResult<()> {
 211     let bits = ATRAC3_MODE0_BITS[quant];
 212     if bits > 0 {
 213         for i in 0..dst.len() {
 214             let val                                     = br.read_s(bits)? as f32;
 215             dst[i] = val * scale;
 216         }
 217     } else {
 218         for i in (0..dst.len()).step_by(2) {
 219             let val                                     = br.read(4)? as usize;
 220             dst[i + 0] = ATRAC3_MODE0_CB[val >> 2] * scale;
 221             dst[i + 1] = ATRAC3_MODE0_CB[val &  3] * scale;
 222         }
 223     }
 224     Ok(())
 225 }
 226
 227 const ATRAC3_MODE1_CB: [f32; 9 * 2] = [
 228      0.0,  0.0,
 229      0.0,  1.0,
 230      0.0, -1.0,
 231      1.0,  0.0,
 232     -1.0,  0.0,
 233      1.0,  1.0,
 234      1.0, -1.0,
 235     -1.0,  1.0,
 236     -1.0, -1.0
 237 ];
 238
 239 fn read_coeffs_mode1(br: &mut BitReader, cb: &Codebook<u8>, dst: &mut [f32], scale: f32) -> DecoderResult<()> {
 240     for i in (0..dst.len()).step_by(2) {
 241         let val                                         = br.read_cb(cb)? as usize;
 242         dst[i + 0] = ATRAC3_MODE1_CB[val * 2 + 0] * scale;
 243         dst[i + 1] = ATRAC3_MODE1_CB[val * 2 + 1] * scale;
 244     }
 245     Ok(())
 246 }
 247
 248 fn read_coeffs_other(br: &mut BitReader, cb: &Codebook<u8>, dst: &mut [f32], scale: f32) -> DecoderResult<()> {
 249     for i in 0..dst.len() {
 250         let val                                         = (br.read_cb(cb)? as i8) + 1;
 251         let sign = (val & 1) != 0;
 252         let coef = (if sign { -(val >> 1) } else { val >> 1 }) as f32;
 253         dst[i] = coef * scale;
 254     }
 255     Ok(())
 256 }
 257
 258 struct DSP {
 259     imdct:          IMDCT,
 260     window:         [f32; 512],
 261     gain_tab:       [f32; 16],
 262     gain_tab2:      [f32; 32],
 263     tmp:            [f32; ATRAC3_FRAME_SIZE + 64],
 264 }
 265
 266 impl DSP {
 267     fn new() -> Self {
 268         let mut gain_tab: [f32; 16] = [0.0; 16];
 269         let mut gain_tab2: [f32; 32] = [0.0; 32];
 270
 271         for i in 0..16 {
 272             gain_tab[i] = 2.0f32.powf(4.0 - (i as f32));
 273         }
 274         for i in 0..32 {
 275             gain_tab2[i] = 2.0f32.powf(((i as f32) - 15.0) * -0.125);
 276         }
 277
 278         let mut tmpw: [f32; 256] = [0.0; 256];
 279         for i in 0..tmpw.len() {
 280             tmpw[i] = (((((i as f32) + 0.5) / 256.0 - 0.5) * consts::PI).sin() + 1.0) * 0.5;
 281         }
 282
 283         let mut window: [f32; 512] = [0.0; 512];
 284         for i in 0..tmpw.len() {
 285             let w = tmpw[i] / (tmpw[i] * tmpw[i] + tmpw[255 - i] * tmpw[255 - i]);
 286             window[i] = w;
 287             window[512 - 1 - i] = w;
 288         }
 289
 290         Self {
 291                 imdct:  IMDCT::new(FFTMode::SplitRadix, 512, false),
 292                 tmp:    [0.0; ATRAC3_FRAME_SIZE + 64],
 293                 gain_tab, gain_tab2, window,
 294             }
 295     }
 296     fn synth_band(&mut self, src: &[f32]) {
 297         let dst = &mut self.tmp;
 298         self.imdct.imdct(src, dst);
 299         for i in 0..512 {
 300             dst[i] *= self.window[i];
 301         }
 302     }
 303     fn apply_gains(&mut self, dst: &mut [f32], delay: &[f32], gain_data: &mut [GainData; 2], block_no: usize, band: usize) {
 304         let prev_ngains = gain_data[block_no ^ 1].ngains[band];
 305         let gain1 = if gain_data[block_no].ngains[band] > 0 {
 306                             self.gain_tab[gain_data[block_no].gain_lev[band][0]]
 307                     } else { 1.0 };
 308
 309         if prev_ngains == 0 {
 310             for i in 0..256 {
 311                 dst[i] = self.tmp[i] * gain1 + delay[i];
 312             }
 313             return;
 314         }
 315
 316         gain_data[block_no ^ 1].gain_lev[band][prev_ngains] = 4;
 317         gain_data[block_no ^ 1].gain_loc[band][prev_ngains] = 32;
 318
 319         let mut off = 0;
 320         for i in 0..prev_ngains {
 321             let start = gain_data[block_no ^ 1].gain_loc[band][i] * 8;
 322             let end = start + 8;
 323
 324             let mut gain2   = self.gain_tab [gain_data[block_no ^ 1].gain_lev[band][i]];
 325             let gain_inc    = self.gain_tab2[gain_data[block_no ^ 1].gain_lev[band][i + 1] + 15 -
 326                                              gain_data[block_no ^ 1].gain_lev[band][i]];
 327
 328             while off < start {
 329                 dst[off] = (self.tmp[off] * gain1 + delay[off]) * gain2;
 330                 off += 1;
 331             }
 332             while off < end {
 333                 dst[off] = (self.tmp[off] * gain1 + delay[off]) * gain2;
 334                 gain2 *= gain_inc;
 335                 off += 1;
 336             }
 337         }
 338         for i in off..256 {
 339             dst[i] = self.tmp[i] * gain1 + delay[i];
 340         }
 341     }
 342     fn qmf_prepare(&mut self, src: &[f32], delay: &[f32], size: usize, swap: bool) {
 343         for i in 0..46 {
 344             self.tmp[i] = delay[i];
 345         }
 346         let (s0, s1) = if !swap {
 347                 (&src[0..], &src[size/2..])
 348             } else {
 349                 (&src[size/2..], &src[0..])
 350             };
 351         for i in (0..size).step_by(4) {
 352             self.tmp[46 + i + 0] = s0[i / 2 + 0] + s1[i / 2 + 0];
 353             self.tmp[46 + i + 1] = s0[i / 2 + 0] - s1[i / 2 + 0];
 354             self.tmp[46 + i + 2] = s0[i / 2 + 1] + s1[i / 2 + 1];
 355             self.tmp[46 + i + 3] = s0[i / 2 + 1] - s1[i / 2 + 1];
 356         }
 357     }
 358     fn qmf_synth(&mut self, dst: &mut [f32], size: usize) {
 359         for i in (0..size).step_by(2) {
 360             let mut acc0 = 0.0;
 361             let mut acc1 = 0.0;
 362
 363             for j in (0..ATRAC3_QMF_FILTER.len()).step_by(2) {
 364                 acc0 += self.tmp[i + j + 0] * ATRAC3_QMF_FILTER[j + 0];
 365                 acc1 += self.tmp[i + j + 1] * ATRAC3_QMF_FILTER[j + 1];
 366             }
 367             dst[i + 0] = acc1 * consts::SQRT_2 / 256.0;
 368             dst[i + 1] = acc0 * consts::SQRT_2 / 256.0;
 369         }
 370     }
 371     fn do_qmf(&mut self, dst: &mut [f32], delay: &mut [f32], swap: bool) {
 372         self.qmf_prepare(dst, delay, 512, swap);
 373         self.qmf_synth(dst, 512);
 374         for i in 0..46 {
 375             delay[i] = self.tmp[512 + i];
 376         }
 377     }
 378     fn do_qmf_out(&mut self, dst: &mut [f32], src: &[f32], delay: &mut [f32]) {
 379         self.qmf_prepare(src, delay, 1024, false);
 380         self.qmf_synth(dst, 1024);
 381         for i in 0..46 {
 382             delay[i] = self.tmp[1024 + i];
 383         }
 384     }
 385 }
 386
 387 struct Atrac3Decoder {
 388     info:       NACodecInfoRef,
 389     channels:   usize,
 390     chmap:      NAChannelMap,
 391     samples:    usize,
 392     mode:       Mode,
 393     scrambled:  bool,
 394
 395     codebooks:  [Codebook<u8>; 7],
 396     dsp:        DSP,
 397     ch_data:    [Channel; 2],
 398     scalefactors:   [f32; 64],
 399
 400     mci_prev:   [usize; 4],
 401     mci_cur:    [usize; 4],
 402     mci_next:   [usize; 4],
 403
 404     weighting_delay:    [u8; 6],
 405
 406     pkt_buf:    Vec<u8>,
 407 }
 408
 409 struct Atrac3CodebookReader {
 410     bits:  &'static [u8],
 411     codes: &'static [u8],
 412 }
 413 impl CodebookDescReader<u8> for Atrac3CodebookReader {
 414     fn bits(&mut self, idx: usize) -> u8  { self.bits[idx] }
 415     fn code(&mut self, idx: usize) -> u32 { self.codes[idx] as u32 }
 416     fn sym (&mut self, idx: usize) -> u8 { idx as u8 }
 417     fn len(&mut self) -> usize { self.bits.len() }
 418 }
 419
 420 impl Atrac3Decoder {
 421     fn new() -> Self {
 422         let mut scalefactors: [f32; 64] = [0.0; 64];
 423         for i in 0..scalefactors.len() {
 424             scalefactors[i] = 2.0f32.powf(((i as f32) - 15.0) / 3.0);
 425         }
 426
 427         let mut cb0 = Atrac3CodebookReader { codes: ATRAC3_HUFF_CODES[0], bits: ATRAC3_HUFF_BITS[0] };
 428         let mut cb1 = Atrac3CodebookReader { codes: ATRAC3_HUFF_CODES[1], bits: ATRAC3_HUFF_BITS[1] };
 429         let mut cb2 = Atrac3CodebookReader { codes: ATRAC3_HUFF_CODES[2], bits: ATRAC3_HUFF_BITS[2] };
 430         let mut cb3 = Atrac3CodebookReader { codes: ATRAC3_HUFF_CODES[3], bits: ATRAC3_HUFF_BITS[3] };
 431         let mut cb4 = Atrac3CodebookReader { codes: ATRAC3_HUFF_CODES[4], bits: ATRAC3_HUFF_BITS[4] };
 432         let mut cb5 = Atrac3CodebookReader { codes: ATRAC3_HUFF_CODES[5], bits: ATRAC3_HUFF_BITS[5] };
 433         let mut cb6 = Atrac3CodebookReader { codes: ATRAC3_HUFF_CODES[6], bits: ATRAC3_HUFF_BITS[6] };
 434         Self {
 435             info:       NACodecInfo::new_dummy(),
 436             chmap:      NAChannelMap::new(),
 437             channels:   0,
 438             samples:    0,
 439             mode:       Mode::Mono,
 440             scrambled:  false,
 441
 442             dsp:        DSP::new(),
 443             ch_data:    [Channel::new(), Channel::new()],
 444             codebooks:  [Codebook::new(&mut cb0, CodebookMode::MSB).unwrap(),
 445                          Codebook::new(&mut cb1, CodebookMode::MSB).unwrap(),
 446                          Codebook::new(&mut cb2, CodebookMode::MSB).unwrap(),
 447                          Codebook::new(&mut cb3, CodebookMode::MSB).unwrap(),
 448                          Codebook::new(&mut cb4, CodebookMode::MSB).unwrap(),
 449                          Codebook::new(&mut cb5, CodebookMode::MSB).unwrap(),
 450                          Codebook::new(&mut cb6, CodebookMode::MSB).unwrap() ],
 451
 452             mci_prev:   [3; 4],
 453             mci_cur:    [3; 4],
 454             mci_next:   [3; 4],
 455
 456             weighting_delay: ATRAC3_WEIGHTING_DELAYS,
 457             pkt_buf:    Vec::with_capacity(65536),
 458             scalefactors,
 459         }
 460     }
 461     fn rev_matrix(&mut self) {
 462         for i in 0..4 {
 463             let c0 = self.mci_prev[i];
 464             let c1 = self.mci_cur[i];
 465             let off;
 466             if c0 != c1 {
 467                 let l0 = ATRAC3_MATRIX_COEFFS[c0 * 2 + 0];
 468                 let r0 = ATRAC3_MATRIX_COEFFS[c1 * 2 + 0];
 469                 let l1 = ATRAC3_MATRIX_COEFFS[c0 * 2 + 1];
 470                 let r1 = ATRAC3_MATRIX_COEFFS[c1 * 2 + 1];
 471                 for idx in 0..8 {
 472                     let t0 = self.ch_data[0].data[idx + i * 256];
 473                     let t1 = self.ch_data[1].data[idx + i * 256];
 474                     let n1 = t0 * interp(l0, r0, idx) + t1 * interp(l1, r1, idx);
 475                     self.ch_data[0].data[idx + i * 256] = n1;
 476                     self.ch_data[1].data[idx + i * 256] = t0 * 2.0 - n1;
 477                 }
 478                 off = i * 256 + 8;
 479             } else {
 480                 off = i * 256;
 481             }
 482             match c1 {
 483                 0 => {
 484                         for i in off..256 {
 485                             let t0 = self.ch_data[0].data[i];
 486                             let t1 = self.ch_data[1].data[i];
 487                             self.ch_data[0].data[i] =       t1  * 2.0;
 488                             self.ch_data[1].data[i] = (t0 - t1) * 2.0;
 489                         }
 490                     },
 491                 1 => {
 492                         for i in off..256 {
 493                             let t0 = self.ch_data[0].data[i];
 494                             let t1 = self.ch_data[1].data[i];
 495                             self.ch_data[0].data[i] = (t0 + t1) *  2.0;
 496                             self.ch_data[1].data[i] =       t1  * -2.0;
 497                         }
 498                     },
 499                 _ => {
 500                         for i in off..256 {
 501                             let t0 = self.ch_data[0].data[i];
 502                             let t1 = self.ch_data[1].data[i];
 503                             self.ch_data[0].data[i] = t0 + t1;
 504                             self.ch_data[1].data[i] = t0 - t1;
 505                         }
 506                     },
 507             };
 508         }
 509     }
 510     fn weigh_channels(&mut self) {
 511         if (self.weighting_delay[1] == 7) && (self.weighting_delay[3] == 7) { return; }
 512         let pw: [f32; 2];
 513         if self.weighting_delay[1] == 7 {
 514             pw = [1.0; 2];
 515         } else {
 516             let w = (self.weighting_delay[1] as f32) / 7.0;
 517             let iw = (2.0 - w * w).sqrt();
 518             if self.weighting_delay[0] == 0 {
 519                 pw = [w, iw];
 520             } else {
 521                 pw = [iw, w];
 522             }
 523         }
 524         let cw: [f32; 2];
 525         if self.weighting_delay[3] == 7 {
 526             cw = [1.0; 2];
 527         } else {
 528             let w = (self.weighting_delay[3] as f32) / 7.0;
 529             let iw = (2.0 - w * w).sqrt();
 530             if self.weighting_delay[2] == 0 {
 531                 cw = [w, iw];
 532             } else {
 533                 cw = [iw, w];
 534             }
 535         }
 536
 537         for i in 0..4 {
 538             let off = i * 256;
 539             for j in 0..8 {
 540                 self.ch_data[0].data[off + j] *= interp(pw[0], pw[1], j);
 541                 self.ch_data[1].data[off + j] *= interp(pw[0], pw[1], j);
 542             }
 543             for j in 8..256 {
 544                 self.ch_data[0].data[off + j] *= cw[0];
 545                 self.ch_data[1].data[off + j] *= cw[1];
 546             }
 547         }
 548     }
 549 }
 550
 551 fn interp(a: f32, b: f32, pos: usize) -> f32 {
 552     a + ((pos as f32) / 8.0) * (b - a)
 553 }
 554
 555 impl NADecoder for Atrac3Decoder {
 556     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
 557         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
 558             self.info = info.clone();
 559             let edata = info.get_extradata().unwrap();
 560             validate!(edata.len() >= 4);
 561
 562             let mut mr = MemoryReader::new_read(&edata);
 563             let mut br = ByteReader::new(&mut mr);
 564
 565             match edata.len() {
 566                 10 => {
 567                         let version                     = br.read_u32be()?;
 568                         validate!(version == 4);
 569                         self.samples                    = br.read_u16be()? as usize;
 570                         let delay                       = br.read_u16be()? as usize;
 571                         validate!(delay == ATRAC3_DEFAULT_DELAY);
 572                         let mode                        = br.read_u16be()?;
 573                         self.mode = match mode {
 574                                 0 => Mode::Mono,
 575                                 2 => Mode::Stereo,
 576                                 0x12 => Mode::JointStereo,
 577                                 _ => return Err(DecoderError::InvalidData),
 578                             };
 579                         self.channels = if self.mode == Mode::Mono { 1 } else { 2 };
 580                         self.scrambled = true;
 581                     },
 582                 14 | 16 => {
 583                         if edata.len() == 16 { br.read_skip(2)?; }
 584                         self.samples                    = br.read_u32be()? as usize;
 585                         let mode                        = br.read_u16be()?;
 586                         self.mode = if mode != 0 { Mode::JointStereo } else { Mode::Stereo };
 587                         self.channels = 2;
 588                                                           br.read_skip(2)?;
 589                         let ffactor                     = br.read_u16be()? as usize;
 590                         validate!((ffactor > 0) && (ffactor <= 16));
 591                         // calculate block_align / channels / ffactor, validate it's 96/152/192
 592                     },
 593                 _ => { return Err(DecoderError::InvalidData) }
 594             };
 595             validate!(self.samples == ATRAC3_FRAME_SIZE * self.channels);
 596             if self.mode == Mode::Mono {
 597                 self.chmap.add_channel(NAChannelType::C);
 598             } else {
 599                 self.chmap.add_channel(NAChannelType::L);
 600                 self.chmap.add_channel(NAChannelType::R);
 601             }
 602             let ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), self.channels as u8,
 603                                          SND_F32P_FORMAT, self.samples);
 604             self.info = info.replace_info(NACodecTypeInfo::Audio(ainfo));
 605             Ok(())
 606         } else {
 607             Err(DecoderError::InvalidData)
 608         }
 609     }
 610     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
 611         let info = pkt.get_stream().get_info();
 612         validate!(info.get_properties().is_audio());
 613         let pktbuf = pkt.get_buffer();
 614         validate!(pktbuf.len() > 5);
 615
 616         let frame_size = pktbuf.len();
 617         self.pkt_buf.resize(frame_size, 0);
 618         if self.scrambled {
 619             for (i, s) in pktbuf.iter().enumerate() {
 620                 self.pkt_buf[i] = s ^ ATRAC3_XOR_KEY[i & 3];
 621             }
 622         } else {
 623             let dst = &mut self.pkt_buf[0..frame_size];
 624             dst.copy_from_slice(pktbuf.as_slice());
 625         }
 626
 627         {
 628             let mut br = BitReader::new(self.pkt_buf.as_slice(), frame_size, BitReaderMode::BE);
 629             let id                                  = br.read(6)?;
 630             validate!(id == 0x28);
 631             self.ch_data[0].decode_unit(&mut br, &self.codebooks, &self.scalefactors)?;
 632             self.ch_data[0].synth(&mut self.dsp);
 633         }
 634         if self.channels == 2 {
 635             let off;
 636             if self.mode == Mode::JointStereo {
 637                 for i in 0..frame_size / 2 {
 638                     let b0 = self.pkt_buf[i];
 639                     let b1 = self.pkt_buf[frame_size - i - 1];
 640                     self.pkt_buf[i]                     = b1;
 641                     self.pkt_buf[frame_size - i - 1]    = b0;
 642                 }
 643                 let mut i = 0;
 644                 while (i < frame_size) && (self.pkt_buf[i] == 0xF8) { i += 1; }
 645                 validate!(frame_size - i > 4);
 646                 off = i;
 647             } else {
 648                 off = frame_size / 2;
 649             }
 650             let mut br = BitReader::new(&self.pkt_buf[off..], frame_size - off, BitReaderMode::BE);
 651             if self.mode == Mode::JointStereo {
 652                 let id                                  = br.read(2)?;
 653                 validate!(id == 0x3);
 654             } else {
 655                 let id                                  = br.read(6)?;
 656                 validate!(id == 0x28);
 657             }
 658             if self.mode == Mode::JointStereo {
 659                 for i in 0..self.weighting_delay.len() - 2 {
 660                     self.weighting_delay[i] = self.weighting_delay[i + 2];
 661                 }
 662                 self.weighting_delay[4]                 = br.read(1)? as u8;
 663                 self.weighting_delay[5]                 = br.read(3)? as u8;
 664                 self.mci_prev = self.mci_cur;
 665                 self.mci_cur  = self.mci_next;
 666                 for i in 0..4 {
 667                     self.mci_next[i]                    = br.read(2)? as usize;
 668                 }
 669             }
 670             self.ch_data[1].decode_unit(&mut br, &self.codebooks, &self.scalefactors)?;
 671             self.ch_data[1].synth(&mut self.dsp);
 672         }
 673         if self.mode == Mode::JointStereo {
 674             self.rev_matrix();
 675             self.weigh_channels();
 676         }
 677
 678         let ainfo = self.info.get_properties().get_audio_info().unwrap();
 679
 680         let abuf = alloc_audio_buffer(ainfo, ATRAC3_FRAME_SIZE, self.chmap.clone())?;
 681         let mut adata = abuf.get_abuf_f32().unwrap();
 682         let output = adata.get_data_mut().unwrap();
 683
 684         for ch in 0..self.channels {
 685             let dpos = abuf.get_offset(ch);
 686             self.ch_data[ch].do_qmf(&mut self.dsp, &mut output[dpos..][..ATRAC3_FRAME_SIZE]);
 687         }
 688
 689         let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf);
 690         frm.set_keyframe(true);
 691         Ok(frm.into_ref())
 692     }
 693 }
 694
 695 pub fn get_decoder() -> Box<NADecoder> {
 696     Box::new(Atrac3Decoder::new())
 697 }
 698
 699 #[cfg(test)]
 700 mod test {
 701     use nihav_core::codecs::RegisteredDecoders;
 702     use nihav_core::demuxers::RegisteredDemuxers;
 703     use nihav_core::test::dec_video::test_decode_audio;
 704     use crate::codecs::generic_register_all_codecs;
 705     use nihav_realmedia::demuxers::realmedia_register_all_demuxers;
 706     #[test]
 707     fn test_atrac3() {
 708         let mut dmx_reg = RegisteredDemuxers::new();
 709         realmedia_register_all_demuxers(&mut dmx_reg);
 710         let mut dec_reg = RegisteredDecoders::new();
 711         generic_register_all_codecs(&mut dec_reg);
 712
 713         let file = "assets/RV/rv30_atrc_384x208_realproducer_plus_8.51.rm";
 714 //        let file = "assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm";
 715         test_decode_audio("realmedia", file, Some(12000), "atrac3", &dmx_reg, &dec_reg);
 716     }
 717 }
 718
 719 const ATRAC3_XOR_KEY: [u8; 4] = [ 0x53, 0x7F, 0x61, 0x03 ];
 720
 721 const ATRAC3_HUFF_CODES: [&[u8]; 7] = [
 722     &[ 0x00, 0x04, 0x05, 0x0C, 0x0D, 0x1C, 0x1D, 0x1E, 0x1F ],
 723     &[ 0x00, 0x04, 0x05, 0x06, 0x07 ],
 724     &[ 0x00, 0x04, 0x05, 0x0C, 0x0D, 0x0E, 0x0F ],
 725     &[ 0x00, 0x04, 0x05, 0x0C, 0x0D, 0x1C, 0x1D, 0x1E, 0x1F ], // same as 0
 726     &[ 0x00, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B, 0x1C, 0x1D, 0x3C, 0x3D, 0x3E, 0x3F, 0x0C, 0x0D ],
 727     &[ 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x14,
 728        0x15, 0x16, 0x17, 0x18, 0x19, 0x34, 0x35, 0x36,
 729        0x37, 0x38, 0x39, 0x3A, 0x3B, 0x78, 0x79, 0x7A,
 730        0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x08, 0x09 ],
 731     &[ 0x00, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
 732        0x0F, 0x10, 0x11, 0x24, 0x25, 0x26, 0x27, 0x28,
 733        0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
 734        0x31, 0x32, 0x33, 0x68, 0x69, 0x6A, 0x6B, 0x6C,
 735        0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74,
 736        0x75, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2,
 737        0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA,
 738        0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x02, 0x03 ]
 739 ];
 740 const ATRAC3_HUFF_BITS: [&[u8]; 7] = [
 741     &[ 1, 3, 3, 4, 4, 5, 5, 5, 5 ],
 742     &[ 1, 3, 3, 3, 3 ],
 743     &[ 1, 3, 3, 4, 4, 4, 4 ],
 744     &[ 1, 3, 3, 4, 4, 5, 5, 5, 5 ],
 745     &[ 2, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 4, 4 ],
 746     &[ 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 4, 4 ],
 747     &[ 3, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7,
 748        7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4 ],
 749 ];
 750
 751 const ATRAC3_MAX_QUANT: [f32; 8] = [ 0.0, 1.0/1.5, 1.0/2.5, 1.0/3.5, 1.0/4.5, 1.0/7.5, 1.0/15.5, 1.0/31.5 ];
 752
 753 const ATRAC3_SUBBANDS: [usize; 32 + 1] = [
 754       0,   8,  16,  24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160, 176,
 755     192, 224, 256, 288, 320, 352, 384, 416, 448, 480, 512, 576, 640, 704, 768, 896,
 756    1024
 757 ];
 758
 759 const ATRAC3_MATRIX_COEFFS: [f32; 8] = [ 0.0, 2.0, 2.0, 2.0, 0.0, 0.0, 1.0, 1.0 ];
 760
 761 const ATRAC3_QMF_FILTER: [f32; 48] = [
 762     -0.000029238139, -0.000184109580, -0.000112315138,  0.000602345390,
 763      0.000484503806, -0.001705877949, -0.001041114796,  0.004068033770,
 764      0.001566677820, -0.008430772461, -0.001512299757,  0.015680588782,
 765     -0.000122339843, -0.026883240789,  0.004925364163,  0.043472178280,
 766     -0.015603342094, -0.068180441856,  0.037618979812,  0.108652018011,
 767     -0.087192758918, -0.198768734932,  0.264158189297,  0.928483188152,
 768      0.928483188152,  0.264158189297, -0.198768734932, -0.087192758918,
 769      0.108652018011,  0.037618979812, -0.068180441856, -0.015603342094,
 770      0.043472178280,  0.004925364163, -0.026883240789, -0.000122339843,
 771      0.015680588782, -0.001512299757, -0.008430772461,  0.001566677820,
 772      0.004068033770, -0.001041114796, -0.001705877949,  0.000484503806,
 773      0.000602345390, -0.000112315138, -0.000184109580, -0.000029238139
 774 ];