2 use std::cell::RefCell;
3 use nihav_core::formats::*;
4 use nihav_core::frame::*;
5 use nihav_core::codecs::*;
6 use nihav_core::io::bitreader::*;
7 use nihav_core::io::byteio::*;
8 use nihav_core::io::codebook::*;
9 use nihav_core::dsp::fft::FFTMode;
10 use nihav_core::dsp::mdct::IMDCT;
13 #[derive(Clone,Copy,PartialEq)]
20 const ATRAC3_FRAME_SIZE: usize = 1024;
31 gain_lev: [[usize; 8]; 4],
32 gain_loc: [[usize; 8]; 4],
39 gain_lev: [[0; 8]; 4],
40 gain_loc: [[0; 8]; 4],
43 fn read(&mut self, br: &mut BitReader, bands: usize) -> DecoderResult<()> {
45 for band in 0..bands {
46 self.ngains[band] = br.read(3)? as usize;
47 for i in 0..self.ngains[band] {
48 self.gain_lev[band][i] = br.read(4)? as usize;
49 self.gain_loc[band][i] = br.read(5)? as usize;
57 data: [f32; ATRAC3_FRAME_SIZE],
58 delay: [f32; ATRAC3_FRAME_SIZE],
59 qmf_delay: [f32; 64 * 3],
64 gain_data: [GainData; 2],
75 data: [0.0; ATRAC3_FRAME_SIZE],
76 delay: [0.0; ATRAC3_FRAME_SIZE],
77 qmf_delay: [0.0; 64 * 3],
82 gain_data: [GainData::new(), GainData::new()],
87 tones: [Tone {pos: 0, ncoeffs: 0, coeffs: [0.0; 8]}; 64],
90 fn decode_unit(&mut self, br: &mut BitReader, codebooks: &[Codebook<u8>; 7], scalefactors: &[f32; 64]) -> DecoderResult<()> {
91 self.bands = (br.read(2)? as usize) + 1;
92 self.gain_data[self.block_no].read(br, self.bands)?;
93 self.data = [0.0; ATRAC3_FRAME_SIZE];
96 self.components = br.read(5)? as usize;
97 if self.components > 0 {
98 let selector = br.read(2)?;
99 validate!(selector != 2);
100 let mut mode0 = (selector & 1) != 0;
102 for _ in 0..self.components {
103 let mut flags: [bool; 4] = [false; 4];
104 for band in 0..self.bands {
105 flags[band] = br.read_bool()?;
107 let nvals = br.read(3)? as usize;
108 let quant = br.read(3)? as usize;
109 validate!(quant > 1);
111 mode0 = br.read_bool()?;
113 for j in 0..self.bands*4 {
114 if !flags[j >> 2] { continue; }
115 let count = br.read(3)? as usize;
116 validate!(self.ntones + count < 64);
118 let scale_idx = br.read(6)? as usize;
119 let tone = &mut self.tones[self.ntones];
120 tone.pos = (br.read(6)? as usize) + j * 64;
121 tone.ncoeffs = (ATRAC3_FRAME_SIZE - tone.pos).min(nvals + 1);
122 let scale = scalefactors[scale_idx] * ATRAC3_MAX_QUANT[quant];
123 read_coeffs(br, codebooks, &mut tone.coeffs[..tone.ncoeffs], quant, scale, mode0)?;
131 let mut quants: [usize; 32] = [0; 32];
132 let mut scf: [usize; 32] = [0; 32];
133 self.subbands = (br.read(5)? as usize) + 1;
134 let mode0 = br.read_bool()?;
135 for i in 0..self.subbands {
136 quants[i] = br.read(3)? as usize;
138 for i in 0..self.subbands {
139 if quants[i] == 0 { continue; }
140 scf[i] = br.read(6)? as usize;
143 self.data = [0.0; ATRAC3_FRAME_SIZE];
144 for i in 0..self.subbands {
145 if quants[i] == 0 { continue; }
146 let start = ATRAC3_SUBBANDS[i];
147 let end = ATRAC3_SUBBANDS[i + 1];
148 let scale = scalefactors[scf[i]] * ATRAC3_MAX_QUANT[quants[i]];
149 read_coeffs(br, codebooks, &mut self.data[start..end], quants[i], scale, mode0)?;
152 for i in 0..self.ntones {
153 let tone = &self.tones[i];
154 for j in 0..tone.ncoeffs {
155 self.data[tone.pos + j] += tone.coeffs[j];
160 fn synth(&mut self, dsp: &mut DSP) {
163 for (data, delay) in self.data.chunks_mut(256).zip(self.delay.chunks_mut(256)) {
167 let t1 = data[255 - i];
172 dsp.synth_band(data);
173 dsp.apply_gains(data, delay, &mut self.gain_data, self.block_no, band);
174 delay.copy_from_slice(&dsp.tmp[256..512]);
180 fn do_qmf(&mut self, dsp: &mut DSP, dst: &mut [f32]) {
181 let mut qchunks = self.qmf_delay.chunks_mut(64);
182 let qmf0 = qchunks.next().unwrap();
183 let qmf1 = qchunks.next().unwrap();
184 let qmf2 = qchunks.next().unwrap();
186 let mut tchunks = self.data.chunks_mut(512);
187 let tmp0 = tchunks.next().unwrap();
188 let tmp1 = tchunks.next().unwrap();
189 dsp.do_qmf(tmp0, qmf0, false);
190 dsp.do_qmf(tmp1, qmf1, true);
192 dsp.do_qmf_out(dst, &self.data, qmf2);
196 const ATRAC3_DEFAULT_DELAY: usize = 2190;
197 const ATRAC3_WEIGHTING_DELAYS: [u8; 6] = [ 0, 7, 0, 7, 0, 7 ];
199 fn read_coeffs(br: &mut BitReader, cb: &[Codebook<u8>; 7], dst: &mut [f32], quant: usize, scale: f32, mode0: bool) -> DecoderResult<()> {
201 read_coeffs_mode0(br, dst, quant, scale)
202 } else if quant == 1 {
203 read_coeffs_mode1(br, &cb[0], dst, scale)
205 read_coeffs_other(br, &cb[quant - 1], dst, scale)
209 const ATRAC3_MODE0_CB: [f32; 4] = [ 0.0, 1.0, -2.0, -1.0 ];
210 const ATRAC3_MODE0_BITS: [u8; 8] = [ 0, 4, 3, 3, 4, 4, 5, 6 ];
212 fn read_coeffs_mode0(br: &mut BitReader, dst: &mut [f32], quant: usize, scale: f32) -> DecoderResult<()> {
213 let bits = ATRAC3_MODE0_BITS[quant];
215 for i in 0..dst.len() {
216 let val = br.read_s(bits)? as f32;
217 dst[i] = val * scale;
220 for i in (0..dst.len()).step_by(2) {
221 let val = br.read(4)? as usize;
222 dst[i + 0] = ATRAC3_MODE0_CB[val >> 2] * scale;
223 dst[i + 1] = ATRAC3_MODE0_CB[val & 3] * scale;
229 const ATRAC3_MODE1_CB: [f32; 9 * 2] = [
241 fn read_coeffs_mode1(br: &mut BitReader, cb: &Codebook<u8>, dst: &mut [f32], scale: f32) -> DecoderResult<()> {
242 for i in (0..dst.len()).step_by(2) {
243 let val = br.read_cb(cb)? as usize;
244 dst[i + 0] = ATRAC3_MODE1_CB[val * 2 + 0] * scale;
245 dst[i + 1] = ATRAC3_MODE1_CB[val * 2 + 1] * scale;
250 fn read_coeffs_other(br: &mut BitReader, cb: &Codebook<u8>, dst: &mut [f32], scale: f32) -> DecoderResult<()> {
251 for i in 0..dst.len() {
252 let val = (br.read_cb(cb)? as i8) + 1;
253 let sign = (val & 1) != 0;
254 let coef = (if sign { -(val >> 1) } else { val >> 1 }) as f32;
255 dst[i] = coef * scale;
264 gain_tab2: [f32; 32],
265 tmp: [f32; ATRAC3_FRAME_SIZE + 64],
270 let mut gain_tab: [f32; 16] = [0.0; 16];
271 let mut gain_tab2: [f32; 32] = [0.0; 32];
274 gain_tab[i] = 2.0f32.powf(4.0 - (i as f32));
277 gain_tab2[i] = 2.0f32.powf(((i as f32) - 15.0) * -0.125);
280 let mut tmpw: [f32; 256] = [0.0; 256];
281 for i in 0..tmpw.len() {
282 tmpw[i] = (((((i as f32) + 0.5) / 256.0 - 0.5) * consts::PI).sin() + 1.0) * 0.5;
285 let mut window: [f32; 512] = [0.0; 512];
286 for i in 0..tmpw.len() {
287 let w = tmpw[i] / (tmpw[i] * tmpw[i] + tmpw[255 - i] * tmpw[255 - i]);
289 window[512 - 1 - i] = w;
293 imdct: IMDCT::new(FFTMode::SplitRadix, 512, false),
294 tmp: [0.0; ATRAC3_FRAME_SIZE + 64],
295 gain_tab, gain_tab2, window,
298 fn synth_band(&mut self, src: &[f32]) {
299 let dst = &mut self.tmp;
300 self.imdct.imdct(src, dst);
302 dst[i] *= self.window[i];
305 fn apply_gains(&mut self, dst: &mut [f32], delay: &[f32], gain_data: &mut [GainData; 2], block_no: usize, band: usize) {
306 let prev_ngains = gain_data[block_no ^ 1].ngains[band];
307 let gain1 = if gain_data[block_no].ngains[band] > 0 {
308 self.gain_tab[gain_data[block_no].gain_lev[band][0]]
311 if prev_ngains == 0 {
313 dst[i] = self.tmp[i] * gain1 + delay[i];
318 gain_data[block_no ^ 1].gain_lev[band][prev_ngains] = 4;
319 gain_data[block_no ^ 1].gain_loc[band][prev_ngains] = 32;
322 for i in 0..prev_ngains {
323 let start = gain_data[block_no ^ 1].gain_loc[band][i] * 8;
326 let mut gain2 = self.gain_tab [gain_data[block_no ^ 1].gain_lev[band][i]];
327 let gain_inc = self.gain_tab2[gain_data[block_no ^ 1].gain_lev[band][i + 1] + 15 -
328 gain_data[block_no ^ 1].gain_lev[band][i]];
331 dst[off] = (self.tmp[off] * gain1 + delay[off]) * gain2;
335 dst[off] = (self.tmp[off] * gain1 + delay[off]) * gain2;
341 dst[i] = self.tmp[i] * gain1 + delay[i];
344 fn qmf_prepare(&mut self, src: &[f32], delay: &[f32], size: usize, swap: bool) {
346 self.tmp[i] = delay[i];
348 let (s0, s1) = if !swap {
349 (&src[0..], &src[size/2..])
351 (&src[size/2..], &src[0..])
353 for i in (0..size).step_by(4) {
354 self.tmp[46 + i + 0] = s0[i / 2 + 0] + s1[i / 2 + 0];
355 self.tmp[46 + i + 1] = s0[i / 2 + 0] - s1[i / 2 + 0];
356 self.tmp[46 + i + 2] = s0[i / 2 + 1] + s1[i / 2 + 1];
357 self.tmp[46 + i + 3] = s0[i / 2 + 1] - s1[i / 2 + 1];
360 fn qmf_synth(&mut self, dst: &mut [f32], size: usize) {
361 for i in (0..size).step_by(2) {
365 for j in (0..ATRAC3_QMF_FILTER.len()).step_by(2) {
366 acc0 += self.tmp[i + j + 0] * ATRAC3_QMF_FILTER[j + 0];
367 acc1 += self.tmp[i + j + 1] * ATRAC3_QMF_FILTER[j + 1];
369 dst[i + 0] = acc1 * consts::SQRT_2 / 256.0;
370 dst[i + 1] = acc0 * consts::SQRT_2 / 256.0;
373 fn do_qmf(&mut self, dst: &mut [f32], delay: &mut [f32], swap: bool) {
374 self.qmf_prepare(dst, delay, 512, swap);
375 self.qmf_synth(dst, 512);
377 delay[i] = self.tmp[512 + i];
380 fn do_qmf_out(&mut self, dst: &mut [f32], src: &[f32], delay: &mut [f32]) {
381 self.qmf_prepare(src, delay, 1024, false);
382 self.qmf_synth(dst, 1024);
384 delay[i] = self.tmp[1024 + i];
389 struct Atrac3Decoder {
390 info: Rc<NACodecInfo>,
397 codebooks: [Codebook<u8>; 7],
399 ch_data: [Channel; 2],
400 scalefactors: [f32; 64],
402 mci_prev: [usize; 4],
404 mci_next: [usize; 4],
406 weighting_delay: [u8; 6],
411 struct Atrac3CodebookReader {
413 codes: &'static [u8],
415 impl CodebookDescReader<u8> for Atrac3CodebookReader {
416 fn bits(&mut self, idx: usize) -> u8 { self.bits[idx] }
417 fn code(&mut self, idx: usize) -> u32 { self.codes[idx] as u32 }
418 fn sym (&mut self, idx: usize) -> u8 { idx as u8 }
419 fn len(&mut self) -> usize { self.bits.len() }
424 let mut scalefactors: [f32; 64] = [0.0; 64];
425 for i in 0..scalefactors.len() {
426 scalefactors[i] = 2.0f32.powf(((i as f32) - 15.0) / 3.0);
429 let mut cb0 = Atrac3CodebookReader { codes: ATRAC3_HUFF_CODES[0], bits: ATRAC3_HUFF_BITS[0] };
430 let mut cb1 = Atrac3CodebookReader { codes: ATRAC3_HUFF_CODES[1], bits: ATRAC3_HUFF_BITS[1] };
431 let mut cb2 = Atrac3CodebookReader { codes: ATRAC3_HUFF_CODES[2], bits: ATRAC3_HUFF_BITS[2] };
432 let mut cb3 = Atrac3CodebookReader { codes: ATRAC3_HUFF_CODES[3], bits: ATRAC3_HUFF_BITS[3] };
433 let mut cb4 = Atrac3CodebookReader { codes: ATRAC3_HUFF_CODES[4], bits: ATRAC3_HUFF_BITS[4] };
434 let mut cb5 = Atrac3CodebookReader { codes: ATRAC3_HUFF_CODES[5], bits: ATRAC3_HUFF_BITS[5] };
435 let mut cb6 = Atrac3CodebookReader { codes: ATRAC3_HUFF_CODES[6], bits: ATRAC3_HUFF_BITS[6] };
437 info: NACodecInfo::new_dummy(),
438 chmap: NAChannelMap::new(),
445 ch_data: [Channel::new(), Channel::new()],
446 codebooks: [Codebook::new(&mut cb0, CodebookMode::MSB).unwrap(),
447 Codebook::new(&mut cb1, CodebookMode::MSB).unwrap(),
448 Codebook::new(&mut cb2, CodebookMode::MSB).unwrap(),
449 Codebook::new(&mut cb3, CodebookMode::MSB).unwrap(),
450 Codebook::new(&mut cb4, CodebookMode::MSB).unwrap(),
451 Codebook::new(&mut cb5, CodebookMode::MSB).unwrap(),
452 Codebook::new(&mut cb6, CodebookMode::MSB).unwrap() ],
458 weighting_delay: ATRAC3_WEIGHTING_DELAYS,
459 pkt_buf: Vec::with_capacity(65536),
463 fn rev_matrix(&mut self) {
465 let c0 = self.mci_prev[i];
466 let c1 = self.mci_cur[i];
469 let l0 = ATRAC3_MATRIX_COEFFS[c0 * 2 + 0];
470 let r0 = ATRAC3_MATRIX_COEFFS[c1 * 2 + 0];
471 let l1 = ATRAC3_MATRIX_COEFFS[c0 * 2 + 1];
472 let r1 = ATRAC3_MATRIX_COEFFS[c1 * 2 + 1];
474 let t0 = self.ch_data[0].data[idx + i * 256];
475 let t1 = self.ch_data[1].data[idx + i * 256];
476 let n1 = t0 * interp(l0, r0, idx) + t1 * interp(l1, r1, idx);
477 self.ch_data[0].data[idx + i * 256] = n1;
478 self.ch_data[1].data[idx + i * 256] = t0 * 2.0 - n1;
487 let t0 = self.ch_data[0].data[i];
488 let t1 = self.ch_data[1].data[i];
489 self.ch_data[0].data[i] = t1 * 2.0;
490 self.ch_data[1].data[i] = (t0 - t1) * 2.0;
495 let t0 = self.ch_data[0].data[i];
496 let t1 = self.ch_data[1].data[i];
497 self.ch_data[0].data[i] = (t0 + t1) * 2.0;
498 self.ch_data[1].data[i] = t1 * -2.0;
503 let t0 = self.ch_data[0].data[i];
504 let t1 = self.ch_data[1].data[i];
505 self.ch_data[0].data[i] = t0 + t1;
506 self.ch_data[1].data[i] = t0 - t1;
512 fn weigh_channels(&mut self) {
513 if (self.weighting_delay[1] == 7) && (self.weighting_delay[3] == 7) { return; }
515 if self.weighting_delay[1] == 7 {
518 let w = (self.weighting_delay[1] as f32) / 7.0;
519 let iw = (2.0 - w * w).sqrt();
520 if self.weighting_delay[0] == 0 {
527 if self.weighting_delay[3] == 7 {
530 let w = (self.weighting_delay[3] as f32) / 7.0;
531 let iw = (2.0 - w * w).sqrt();
532 if self.weighting_delay[2] == 0 {
542 self.ch_data[0].data[off + j] *= interp(pw[0], pw[1], j);
543 self.ch_data[1].data[off + j] *= interp(pw[0], pw[1], j);
546 self.ch_data[0].data[off + j] *= cw[0];
547 self.ch_data[1].data[off + j] *= cw[1];
553 fn interp(a: f32, b: f32, pos: usize) -> f32 {
554 a + ((pos as f32) / 8.0) * (b - a)
557 impl NADecoder for Atrac3Decoder {
558 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
559 if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
560 self.info = info.clone();
561 let edata = info.get_extradata().unwrap();
562 validate!(edata.len() >= 4);
564 let mut mr = MemoryReader::new_read(&edata);
565 let mut br = ByteReader::new(&mut mr);
569 let version = br.read_u32be()?;
570 validate!(version == 4);
571 self.samples = br.read_u16be()? as usize;
572 let delay = br.read_u16be()? as usize;
573 validate!(delay == ATRAC3_DEFAULT_DELAY);
574 let mode = br.read_u16be()?;
575 self.mode = match mode {
578 0x12 => Mode::JointStereo,
579 _ => return Err(DecoderError::InvalidData),
581 self.channels = if self.mode == Mode::Mono { 1 } else { 2 };
582 self.scrambled = true;
585 if edata.len() == 16 { br.read_skip(2)?; }
586 self.samples = br.read_u32be()? as usize;
587 let mode = br.read_u16be()?;
588 self.mode = if mode != 0 { Mode::JointStereo } else { Mode::Stereo };
591 let ffactor = br.read_u16be()? as usize;
592 validate!((ffactor > 0) && (ffactor <= 16));
593 // calculate block_align / channels / ffactor, validate it's 96/152/192
595 _ => { return Err(DecoderError::InvalidData) }
597 validate!(self.samples == ATRAC3_FRAME_SIZE * self.channels);
598 if self.mode == Mode::Mono {
599 self.chmap.add_channel(NAChannelType::C);
601 self.chmap.add_channel(NAChannelType::L);
602 self.chmap.add_channel(NAChannelType::R);
604 let ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), self.channels as u8,
605 SND_F32P_FORMAT, self.samples);
606 self.info = info.replace_info(NACodecTypeInfo::Audio(ainfo));
609 Err(DecoderError::InvalidData)
612 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
613 let info = pkt.get_stream().get_info();
614 validate!(info.get_properties().is_audio());
615 let pktbuf = pkt.get_buffer();
616 validate!(pktbuf.len() > 5);
618 let frame_size = pktbuf.len();
619 self.pkt_buf.resize(frame_size, 0);
621 for (i, s) in pktbuf.iter().enumerate() {
622 self.pkt_buf[i] = s ^ ATRAC3_XOR_KEY[i & 3];
625 let dst = &mut self.pkt_buf[0..frame_size];
626 dst.copy_from_slice(pktbuf.as_slice());
630 let mut br = BitReader::new(self.pkt_buf.as_slice(), frame_size, BitReaderMode::BE);
631 let id = br.read(6)?;
632 validate!(id == 0x28);
633 self.ch_data[0].decode_unit(&mut br, &self.codebooks, &self.scalefactors)?;
634 self.ch_data[0].synth(&mut self.dsp);
636 if self.channels == 2 {
638 if self.mode == Mode::JointStereo {
639 for i in 0..frame_size / 2 {
640 let b0 = self.pkt_buf[i];
641 let b1 = self.pkt_buf[frame_size - i - 1];
642 self.pkt_buf[i] = b1;
643 self.pkt_buf[frame_size - i - 1] = b0;
646 while (i < frame_size) && (self.pkt_buf[i] == 0xF8) { i += 1; }
647 validate!(frame_size - i > 4);
650 off = frame_size / 2;
652 let mut br = BitReader::new(&self.pkt_buf[off..], frame_size - off, BitReaderMode::BE);
653 if self.mode == Mode::JointStereo {
654 let id = br.read(2)?;
655 validate!(id == 0x3);
657 let id = br.read(6)?;
658 validate!(id == 0x28);
660 if self.mode == Mode::JointStereo {
661 for i in 0..self.weighting_delay.len() - 2 {
662 self.weighting_delay[i] = self.weighting_delay[i + 2];
664 self.weighting_delay[4] = br.read(1)? as u8;
665 self.weighting_delay[5] = br.read(3)? as u8;
666 self.mci_prev = self.mci_cur;
667 self.mci_cur = self.mci_next;
669 self.mci_next[i] = br.read(2)? as usize;
672 self.ch_data[1].decode_unit(&mut br, &self.codebooks, &self.scalefactors)?;
673 self.ch_data[1].synth(&mut self.dsp);
675 if self.mode == Mode::JointStereo {
677 self.weigh_channels();
680 let ainfo = self.info.get_properties().get_audio_info().unwrap();
682 let mut abuf = alloc_audio_buffer(ainfo, ATRAC3_FRAME_SIZE, self.chmap.clone())?;
683 let mut adata = abuf.get_abuf_f32().unwrap();
684 let mut output = adata.get_data_mut();
686 for ch in 0..self.channels {
687 let dpos = abuf.get_offset(ch);
688 self.ch_data[ch].do_qmf(&mut self.dsp, &mut output[dpos..][..ATRAC3_FRAME_SIZE]);
691 let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf);
692 frm.set_keyframe(true);
693 Ok(Rc::new(RefCell::new(frm)))
697 pub fn get_decoder() -> Box<NADecoder> {
698 Box::new(Atrac3Decoder::new())
703 use nihav_core::codecs::RegisteredDecoders;
704 use nihav_core::demuxers::RegisteredDemuxers;
705 use nihav_core::test::dec_video::test_decode_audio;
706 use crate::codecs::generic_register_all_codecs;
707 use nihav_realmedia::demuxers::realmedia_register_all_demuxers;
710 let mut dmx_reg = RegisteredDemuxers::new();
711 realmedia_register_all_demuxers(&mut dmx_reg);
712 let mut dec_reg = RegisteredDecoders::new();
713 generic_register_all_codecs(&mut dec_reg);
715 let file = "assets/RV/rv30_atrc_384x208_realproducer_plus_8.51.rm";
716 // let file = "assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm";
717 test_decode_audio("realmedia", file, Some(12000), "atrac3", &dmx_reg, &dec_reg);
721 const ATRAC3_XOR_KEY: [u8; 4] = [ 0x53, 0x7F, 0x61, 0x03 ];
723 const ATRAC3_HUFF_CODES: [&[u8]; 7] = [
724 &[ 0x00, 0x04, 0x05, 0x0C, 0x0D, 0x1C, 0x1D, 0x1E, 0x1F ],
725 &[ 0x00, 0x04, 0x05, 0x06, 0x07 ],
726 &[ 0x00, 0x04, 0x05, 0x0C, 0x0D, 0x0E, 0x0F ],
727 &[ 0x00, 0x04, 0x05, 0x0C, 0x0D, 0x1C, 0x1D, 0x1E, 0x1F ], // same as 0
728 &[ 0x00, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B, 0x1C, 0x1D, 0x3C, 0x3D, 0x3E, 0x3F, 0x0C, 0x0D ],
729 &[ 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x14,
730 0x15, 0x16, 0x17, 0x18, 0x19, 0x34, 0x35, 0x36,
731 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x78, 0x79, 0x7A,
732 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x08, 0x09 ],
733 &[ 0x00, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
734 0x0F, 0x10, 0x11, 0x24, 0x25, 0x26, 0x27, 0x28,
735 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
736 0x31, 0x32, 0x33, 0x68, 0x69, 0x6A, 0x6B, 0x6C,
737 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74,
738 0x75, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2,
739 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA,
740 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x02, 0x03 ]
742 const ATRAC3_HUFF_BITS: [&[u8]; 7] = [
743 &[ 1, 3, 3, 4, 4, 5, 5, 5, 5 ],
745 &[ 1, 3, 3, 4, 4, 4, 4 ],
746 &[ 1, 3, 3, 4, 4, 5, 5, 5, 5 ],
747 &[ 2, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 4, 4 ],
748 &[ 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 ],
749 &[ 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,
750 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 ],
753 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 ];
755 const ATRAC3_SUBBANDS: [usize; 32 + 1] = [
756 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176,
757 192, 224, 256, 288, 320, 352, 384, 416, 448, 480, 512, 576, 640, 704, 768, 896,
761 const ATRAC3_MATRIX_COEFFS: [f32; 8] = [ 0.0, 2.0, 2.0, 2.0, 0.0, 0.0, 1.0, 1.0 ];
763 const ATRAC3_QMF_FILTER: [f32; 48] = [
764 -0.000029238139, -0.000184109580, -0.000112315138, 0.000602345390,
765 0.000484503806, -0.001705877949, -0.001041114796, 0.004068033770,
766 0.001566677820, -0.008430772461, -0.001512299757, 0.015680588782,
767 -0.000122339843, -0.026883240789, 0.004925364163, 0.043472178280,
768 -0.015603342094, -0.068180441856, 0.037618979812, 0.108652018011,
769 -0.087192758918, -0.198768734932, 0.264158189297, 0.928483188152,
770 0.928483188152, 0.264158189297, -0.198768734932, -0.087192758918,
771 0.108652018011, 0.037618979812, -0.068180441856, -0.015603342094,
772 0.043472178280, 0.004925364163, -0.026883240789, -0.000122339843,
773 0.015680588782, -0.001512299757, -0.008430772461, 0.001566677820,
774 0.004068033770, -0.001041114796, -0.001705877949, 0.000484503806,
775 0.000602345390, -0.000112315138, -0.000184109580, -0.000029238139