11 #[derive(Clone,Copy,PartialEq)]
18 const ATRAC3_FRAME_SIZE: usize = 1024;
29 gain_lev: [[usize; 8]; 4],
30 gain_loc: [[usize; 8]; 4],
37 gain_lev: [[0; 8]; 4],
38 gain_loc: [[0; 8]; 4],
41 fn read(&mut self, br: &mut BitReader, bands: usize) -> DecoderResult<()> {
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;
55 data: [f32; ATRAC3_FRAME_SIZE],
56 delay: [f32; ATRAC3_FRAME_SIZE],
57 qmf_delay: [f32; 64 * 3],
62 gain_data: [GainData; 2],
73 data: [0.0; ATRAC3_FRAME_SIZE],
74 delay: [0.0; ATRAC3_FRAME_SIZE],
75 qmf_delay: [0.0; 64 * 3],
80 gain_data: [GainData::new(), GainData::new()],
85 tones: [Tone {pos: 0, ncoeffs: 0, coeffs: [0.0; 8]}; 64],
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];
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;
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()?;
105 let nvals = br.read(3)? as usize;
106 let quant = br.read(3)? as usize;
107 validate!(quant > 1);
109 mode0 = br.read_bool()?;
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);
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)?;
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;
136 for i in 0..self.subbands {
137 if quants[i] == 0 { continue; }
138 scf[i] = br.read(6)? as usize;
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)?;
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];
158 fn synth(&mut self, dsp: &mut DSP) {
161 for (data, delay) in self.data.chunks_mut(256).zip(self.delay.chunks_mut(256)) {
165 let t1 = data[255 - i];
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]);
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();
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);
190 dsp.do_qmf_out(dst, &self.data, qmf2);
194 const ATRAC3_DEFAULT_DELAY: usize = 2190;
195 const ATRAC3_WEIGHTING_DELAYS: [u8; 6] = [ 0, 7, 0, 7, 0, 7 ];
197 fn read_coeffs(br: &mut BitReader, cb: &[Codebook<u8>; 7], dst: &mut [f32], quant: usize, scale: f32, mode0: bool) -> DecoderResult<()> {
199 read_coeffs_mode0(br, dst, quant, scale)
200 } else if quant == 1 {
201 read_coeffs_mode1(br, &cb[0], dst, scale)
203 read_coeffs_other(br, &cb[quant - 1], dst, scale)
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 ];
210 fn read_coeffs_mode0(br: &mut BitReader, dst: &mut [f32], quant: usize, scale: f32) -> DecoderResult<()> {
211 let bits = ATRAC3_MODE0_BITS[quant];
213 for i in 0..dst.len() {
214 let val = br.read_s(bits)? as f32;
215 dst[i] = val * scale;
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;
227 const ATRAC3_MODE1_CB: [f32; 9 * 2] = [
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;
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;
262 gain_tab2: [f32; 32],
263 tmp: [f32; ATRAC3_FRAME_SIZE + 64],
268 let mut gain_tab: [f32; 16] = [0.0; 16];
269 let mut gain_tab2: [f32; 32] = [0.0; 32];
272 gain_tab[i] = 2.0f32.powf(4.0 - (i as f32));
275 gain_tab2[i] = 2.0f32.powf(((i as f32) - 15.0) * -0.125);
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;
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]);
287 window[512 - 1 - i] = w;
291 imdct: IMDCT::new(FFTMode::SplitRadix, 512, false),
292 tmp: [0.0; ATRAC3_FRAME_SIZE + 64],
293 gain_tab, gain_tab2, window,
296 fn synth_band(&mut self, src: &[f32]) {
297 let dst = &mut self.tmp;
298 self.imdct.imdct(src, dst);
300 dst[i] *= self.window[i];
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]]
309 if prev_ngains == 0 {
311 dst[i] = self.tmp[i] * gain1 + delay[i];
316 gain_data[block_no ^ 1].gain_lev[band][prev_ngains] = 4;
317 gain_data[block_no ^ 1].gain_loc[band][prev_ngains] = 32;
320 for i in 0..prev_ngains {
321 let start = gain_data[block_no ^ 1].gain_loc[band][i] * 8;
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]];
329 dst[off] = (self.tmp[off] * gain1 + delay[off]) * gain2;
333 dst[off] = (self.tmp[off] * gain1 + delay[off]) * gain2;
339 dst[i] = self.tmp[i] * gain1 + delay[i];
342 fn qmf_prepare(&mut self, src: &[f32], delay: &[f32], size: usize, swap: bool) {
344 self.tmp[i] = delay[i];
346 let (s0, s1) = if !swap {
347 (&src[0..], &src[size/2..])
349 (&src[size/2..], &src[0..])
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];
358 fn qmf_synth(&mut self, dst: &mut [f32], size: usize) {
359 for i in (0..size).step_by(2) {
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];
367 dst[i + 0] = acc1 * consts::SQRT_2 / 256.0;
368 dst[i + 1] = acc0 * consts::SQRT_2 / 256.0;
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);
375 delay[i] = self.tmp[512 + i];
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);
382 delay[i] = self.tmp[1024 + i];
387 struct Atrac3Decoder {
388 info: Rc<NACodecInfo>,
395 codebooks: [Codebook<u8>; 7],
397 ch_data: [Channel; 2],
398 scalefactors: [f32; 64],
400 mci_prev: [usize; 4],
402 mci_next: [usize; 4],
404 weighting_delay: [u8; 6],
409 struct Atrac3CodebookReader {
411 codes: &'static [u8],
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() }
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);
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] };
435 info: NACodecInfo::new_dummy(),
436 chmap: NAChannelMap::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() ],
456 weighting_delay: ATRAC3_WEIGHTING_DELAYS,
457 pkt_buf: Vec::with_capacity(65536),
461 fn rev_matrix(&mut self) {
463 let c0 = self.mci_prev[i];
464 let c1 = self.mci_cur[i];
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];
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;
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;
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;
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;
510 fn weigh_channels(&mut self) {
511 if (self.weighting_delay[1] == 7) && (self.weighting_delay[3] == 7) { return; }
513 if self.weighting_delay[1] == 7 {
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 {
525 if self.weighting_delay[3] == 7 {
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 {
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);
544 self.ch_data[0].data[off + j] *= cw[0];
545 self.ch_data[1].data[off + j] *= cw[1];
551 fn interp(a: f32, b: f32, pos: usize) -> f32 {
552 a + ((pos as f32) / 8.0) * (b - a)
555 impl NADecoder for Atrac3Decoder {
556 fn init(&mut self, info: Rc<NACodecInfo>) -> 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);
562 let mut mr = MemoryReader::new_read(&edata);
563 let mut br = ByteReader::new(&mut mr);
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 {
576 0x12 => Mode::JointStereo,
577 _ => return Err(DecoderError::InvalidData),
579 self.channels = if self.mode == Mode::Mono { 1 } else { 2 };
580 self.scrambled = true;
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 };
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
593 _ => { return Err(DecoderError::InvalidData) }
595 validate!(self.samples == ATRAC3_FRAME_SIZE * self.channels);
596 if self.mode == Mode::Mono {
597 self.chmap.add_channel(NAChannelType::C);
599 self.chmap.add_channel(NAChannelType::L);
600 self.chmap.add_channel(NAChannelType::R);
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));
607 Err(DecoderError::InvalidData)
610 fn decode(&mut self, 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);
616 let frame_size = pktbuf.len();
617 self.pkt_buf.resize(frame_size, 0);
619 for (i, s) in pktbuf.iter().enumerate() {
620 self.pkt_buf[i] = s ^ ATRAC3_XOR_KEY[i & 3];
623 let dst = &mut self.pkt_buf[0..frame_size];
624 dst.copy_from_slice(pktbuf.as_slice());
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);
634 if self.channels == 2 {
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;
644 while (i < frame_size) && (self.pkt_buf[i] == 0xF8) { i += 1; }
645 validate!(frame_size - i > 4);
648 off = frame_size / 2;
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);
655 let id = br.read(6)?;
656 validate!(id == 0x28);
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];
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;
667 self.mci_next[i] = br.read(2)? as usize;
670 self.ch_data[1].decode_unit(&mut br, &self.codebooks, &self.scalefactors)?;
671 self.ch_data[1].synth(&mut self.dsp);
673 if self.mode == Mode::JointStereo {
675 self.weigh_channels();
678 let ainfo = self.info.get_properties().get_audio_info().unwrap();
680 let mut abuf = alloc_audio_buffer(ainfo, ATRAC3_FRAME_SIZE, self.chmap.clone())?;
681 let mut adata = abuf.get_abuf_f32().unwrap();
682 let mut output = adata.get_data_mut();
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]);
689 let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf);
690 frm.set_keyframe(true);
691 Ok(Rc::new(RefCell::new(frm)))
695 pub fn get_decoder() -> Box<NADecoder> {
696 Box::new(Atrac3Decoder::new())
701 use test::dec_video::*;
704 let file = "assets/RV/rv30_atrc_384x208_realproducer_plus_8.51.rm";
705 // let file = "assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm";
706 test_decode_audio("realmedia", file, Some(12000), "atrac3");
710 const ATRAC3_XOR_KEY: [u8; 4] = [ 0x53, 0x7F, 0x61, 0x03 ];
712 const ATRAC3_HUFF_CODES: [&[u8]; 7] = [
713 &[ 0x00, 0x04, 0x05, 0x0C, 0x0D, 0x1C, 0x1D, 0x1E, 0x1F ],
714 &[ 0x00, 0x04, 0x05, 0x06, 0x07 ],
715 &[ 0x00, 0x04, 0x05, 0x0C, 0x0D, 0x0E, 0x0F ],
716 &[ 0x00, 0x04, 0x05, 0x0C, 0x0D, 0x1C, 0x1D, 0x1E, 0x1F ], // same as 0
717 &[ 0x00, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B, 0x1C, 0x1D, 0x3C, 0x3D, 0x3E, 0x3F, 0x0C, 0x0D ],
718 &[ 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x14,
719 0x15, 0x16, 0x17, 0x18, 0x19, 0x34, 0x35, 0x36,
720 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x78, 0x79, 0x7A,
721 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x08, 0x09 ],
722 &[ 0x00, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
723 0x0F, 0x10, 0x11, 0x24, 0x25, 0x26, 0x27, 0x28,
724 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
725 0x31, 0x32, 0x33, 0x68, 0x69, 0x6A, 0x6B, 0x6C,
726 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74,
727 0x75, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2,
728 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA,
729 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x02, 0x03 ]
731 const ATRAC3_HUFF_BITS: [&[u8]; 7] = [
732 &[ 1, 3, 3, 4, 4, 5, 5, 5, 5 ],
734 &[ 1, 3, 3, 4, 4, 4, 4 ],
735 &[ 1, 3, 3, 4, 4, 5, 5, 5, 5 ],
736 &[ 2, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 4, 4 ],
737 &[ 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 ],
738 &[ 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,
739 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 ],
742 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 ];
744 const ATRAC3_SUBBANDS: [usize; 32 + 1] = [
745 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176,
746 192, 224, 256, 288, 320, 352, 384, 416, 448, 480, 512, 576, 640, 704, 768, 896,
750 const ATRAC3_MATRIX_COEFFS: [f32; 8] = [ 0.0, 2.0, 2.0, 2.0, 0.0, 0.0, 1.0, 1.0 ];
752 const ATRAC3_QMF_FILTER: [f32; 48] = [
753 -0.000029238139, -0.000184109580, -0.000112315138, 0.000602345390,
754 0.000484503806, -0.001705877949, -0.001041114796, 0.004068033770,
755 0.001566677820, -0.008430772461, -0.001512299757, 0.015680588782,
756 -0.000122339843, -0.026883240789, 0.004925364163, 0.043472178280,
757 -0.015603342094, -0.068180441856, 0.037618979812, 0.108652018011,
758 -0.087192758918, -0.198768734932, 0.264158189297, 0.928483188152,
759 0.928483188152, 0.264158189297, -0.198768734932, -0.087192758918,
760 0.108652018011, 0.037618979812, -0.068180441856, -0.015603342094,
761 0.043472178280, 0.004925364163, -0.026883240789, -0.000122339843,
762 0.015680588782, -0.001512299757, -0.008430772461, 0.001566677820,
763 0.004068033770, -0.001041114796, -0.001705877949, 0.000484503806,
764 0.000602345390, -0.000112315138, -0.000184109580, -0.000029238139