projects / nihav.git / blob
? search:


7b543bf2774a34b4ff1709e2cdc7853e4c4f6244
[nihav.git] / nihav-commonfmt / src / codecs / atrac3.rs
1 use std::rc::Rc;
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;
11 use std::f32::consts;
12
13 #[derive(Clone,Copy,PartialEq)]
14 enum Mode {
15 Mono,
16 Stereo,
17 JointStereo,
18 }
19
20 const ATRAC3_FRAME_SIZE: usize = 1024;
21
22 #[derive(Clone,Copy)]
23 struct Tone {
24 pos: usize,
25 ncoeffs: usize,
26 coeffs: [f32; 8],
27 }
28
29 struct GainData {
30 ngains: [usize; 4],
31 gain_lev: [[usize; 8]; 4],
32 gain_loc: [[usize; 8]; 4],
33 }
34
35 impl GainData {
36 fn new() -> Self {
37 Self {
38 ngains: [0; 4],
39 gain_lev: [[0; 8]; 4],
40 gain_loc: [[0; 8]; 4],
41 }
42 }
43 fn read(&mut self, br: &mut BitReader, bands: usize) -> DecoderResult<()> {
44 self.ngains = [0; 4];
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;
50 }
51 }
52 Ok(())
53 }
54 }
55
56 struct Channel {
57 data: [f32; ATRAC3_FRAME_SIZE],
58 delay: [f32; ATRAC3_FRAME_SIZE],
59 qmf_delay: [f32; 64 * 3],
60
61 bands: usize,
62 block_no: usize,
63
64 gain_data: [GainData; 2],
65
66 subbands: usize,
67 components: usize,
68 ntones: usize,
69 tones: [Tone; 64],
70 }
71
72 impl Channel {
73 fn new() -> Self {
74 Self {
75 data: [0.0; ATRAC3_FRAME_SIZE],
76 delay: [0.0; ATRAC3_FRAME_SIZE],
77 qmf_delay: [0.0; 64 * 3],
78
79 bands: 0,
80 block_no: 0,
81
82 gain_data: [GainData::new(), GainData::new()],
83
84 subbands: 0,
85 components: 0,
86 ntones: 0,
87 tones: [Tone {pos: 0, ncoeffs: 0, coeffs: [0.0; 8]}; 64],
88 }
89 }
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];
94
95 self.ntones = 0;
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;
101
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()?;
106 }
107 let nvals = br.read(3)? as usize;
108 let quant = br.read(3)? as usize;
109 validate!(quant > 1);
110 if selector == 3 {
111 mode0 = br.read_bool()?;
112 }
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);
117 for _ in 0..count {
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)?;
124 self.ntones += 1;
125 }
126 }
127 }
128 }
129
130 // spectrum
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;
137 }
138 for i in 0..self.subbands {
139 if quants[i] == 0 { continue; }
140 scf[i] = br.read(6)? as usize;
141 }
142
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)?;
150 }
151
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];
156 }
157 }
158 Ok(())
159 }
160 fn synth(&mut self, dsp: &mut DSP) {
161 let mut flag = 0;
162 let mut band = 0;
163 for (data, delay) in self.data.chunks_mut(256).zip(self.delay.chunks_mut(256)) {
164 if (flag & 1) != 0 {
165 for i in 0..128 {
166 let t0 = data[i];
167 let t1 = data[255 - i];
168 data[i] = t1;
169 data[255 - i] = t0;
170 }
171 }
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]);
175 flag ^= 1;
176 band += 1;
177 }
178 self.block_no ^= 1;
179 }
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();
185 {
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);
191 }
192 dsp.do_qmf_out(dst, &self.data, qmf2);
193 }
194 }
195
196 const ATRAC3_DEFAULT_DELAY: usize = 2190;
197 const ATRAC3_WEIGHTING_DELAYS: [u8; 6] = [ 0, 7, 0, 7, 0, 7 ];
198
199 fn read_coeffs(br: &mut BitReader, cb: &[Codebook<u8>; 7], dst: &mut [f32], quant: usize, scale: f32, mode0: bool) -> DecoderResult<()> {
200 if mode0 {
201 read_coeffs_mode0(br, dst, quant, scale)
202 } else if quant == 1 {
203 read_coeffs_mode1(br, &cb[0], dst, scale)
204 } else {
205 read_coeffs_other(br, &cb[quant - 1], dst, scale)
206 }
207 }
208
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 ];
211
212 fn read_coeffs_mode0(br: &mut BitReader, dst: &mut [f32], quant: usize, scale: f32) -> DecoderResult<()> {
213 let bits = ATRAC3_MODE0_BITS[quant];
214 if bits > 0 {
215 for i in 0..dst.len() {
216 let val = br.read_s(bits)? as f32;
217 dst[i] = val * scale;
218 }
219 } else {
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;
224 }
225 }
226 Ok(())
227 }
228
229 const ATRAC3_MODE1_CB: [f32; 9 * 2] = [
230 0.0, 0.0,
231 0.0, 1.0,
232 0.0, -1.0,
233 1.0, 0.0,
234 -1.0, 0.0,
235 1.0, 1.0,
236 1.0, -1.0,
237 -1.0, 1.0,
238 -1.0, -1.0
239 ];
240
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;
246 }
247 Ok(())
248 }
249
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;
256 }
257 Ok(())
258 }
259
260 struct DSP {
261 imdct: IMDCT,
262 window: [f32; 512],
263 gain_tab: [f32; 16],
264 gain_tab2: [f32; 32],
265 tmp: [f32; ATRAC3_FRAME_SIZE + 64],
266 }
267
268 impl DSP {
269 fn new() -> Self {
270 let mut gain_tab: [f32; 16] = [0.0; 16];
271 let mut gain_tab2: [f32; 32] = [0.0; 32];
272
273 for i in 0..16 {
274 gain_tab[i] = 2.0f32.powf(4.0 - (i as f32));
275 }
276 for i in 0..32 {
277 gain_tab2[i] = 2.0f32.powf(((i as f32) - 15.0) * -0.125);
278 }
279
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;
283 }
284
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]);
288 window[i] = w;
289 window[512 - 1 - i] = w;
290 }
291
292 Self {
293 imdct: IMDCT::new(FFTMode::SplitRadix, 512, false),
294 tmp: [0.0; ATRAC3_FRAME_SIZE + 64],
295 gain_tab, gain_tab2, window,
296 }
297 }
298 fn synth_band(&mut self, src: &[f32]) {
299 let dst = &mut self.tmp;
300 self.imdct.imdct(src, dst);
301 for i in 0..512 {
302 dst[i] *= self.window[i];
303 }
304 }
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]]
309 } else { 1.0 };
310
311 if prev_ngains == 0 {
312 for i in 0..256 {
313 dst[i] = self.tmp[i] * gain1 + delay[i];
314 }
315 return;
316 }
317
318 gain_data[block_no ^ 1].gain_lev[band][prev_ngains] = 4;
319 gain_data[block_no ^ 1].gain_loc[band][prev_ngains] = 32;
320
321 let mut off = 0;
322 for i in 0..prev_ngains {
323 let start = gain_data[block_no ^ 1].gain_loc[band][i] * 8;
324 let end = start + 8;
325
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]];
329
330 while off < start {
331 dst[off] = (self.tmp[off] * gain1 + delay[off]) * gain2;
332 off += 1;
333 }
334 while off < end {
335 dst[off] = (self.tmp[off] * gain1 + delay[off]) * gain2;
336 gain2 *= gain_inc;
337 off += 1;
338 }
339 }
340 for i in off..256 {
341 dst[i] = self.tmp[i] * gain1 + delay[i];
342 }
343 }
344 fn qmf_prepare(&mut self, src: &[f32], delay: &[f32], size: usize, swap: bool) {
345 for i in 0..46 {
346 self.tmp[i] = delay[i];
347 }
348 let (s0, s1) = if !swap {
349 (&src[0..], &src[size/2..])
350 } else {
351 (&src[size/2..], &src[0..])
352 };
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];
358 }
359 }
360 fn qmf_synth(&mut self, dst: &mut [f32], size: usize) {
361 for i in (0..size).step_by(2) {
362 let mut acc0 = 0.0;
363 let mut acc1 = 0.0;
364
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];
368 }
369 dst[i + 0] = acc1 * consts::SQRT_2 / 256.0;
370 dst[i + 1] = acc0 * consts::SQRT_2 / 256.0;
371 }
372 }
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);
376 for i in 0..46 {
377 delay[i] = self.tmp[512 + i];
378 }
379 }
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);
383 for i in 0..46 {
384 delay[i] = self.tmp[1024 + i];
385 }
386 }
387 }
388
389 struct Atrac3Decoder {
390 info: Rc<NACodecInfo>,
391 channels: usize,
392 chmap: NAChannelMap,
393 samples: usize,
394 mode: Mode,
395 scrambled: bool,
396
397 codebooks: [Codebook<u8>; 7],
398 dsp: DSP,
399 ch_data: [Channel; 2],
400 scalefactors: [f32; 64],
401
402 mci_prev: [usize; 4],
403 mci_cur: [usize; 4],
404 mci_next: [usize; 4],
405
406 weighting_delay: [u8; 6],
407
408 pkt_buf: Vec<u8>,
409 }
410
411 struct Atrac3CodebookReader {
412 bits: &'static [u8],
413 codes: &'static [u8],
414 }
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() }
420 }
421
422 impl Atrac3Decoder {
423 fn new() -> Self {
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);
427 }
428
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] };
436 Self {
437 info: NACodecInfo::new_dummy(),
438 chmap: NAChannelMap::new(),
439 channels: 0,
440 samples: 0,
441 mode: Mode::Mono,
442 scrambled: false,
443
444 dsp: DSP::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() ],
453
454 mci_prev: [3; 4],
455 mci_cur: [3; 4],
456 mci_next: [3; 4],
457
458 weighting_delay: ATRAC3_WEIGHTING_DELAYS,
459 pkt_buf: Vec::with_capacity(65536),
460 scalefactors,
461 }
462 }
463 fn rev_matrix(&mut self) {
464 for i in 0..4 {
465 let c0 = self.mci_prev[i];
466 let c1 = self.mci_cur[i];
467 let off;
468 if c0 != c1 {
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];
473 for idx in 0..8 {
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;
479 }
480 off = i * 256 + 8;
481 } else {
482 off = i * 256;
483 }
484 match c1 {
485 0 => {
486 for i in off..256 {
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;
491 }
492 },
493 1 => {
494 for i in off..256 {
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;
499 }
500 },
501 _ => {
502 for i in off..256 {
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;
507 }
508 },
509 };
510 }
511 }
512 fn weigh_channels(&mut self) {
513 if (self.weighting_delay[1] == 7) && (self.weighting_delay[3] == 7) { return; }
514 let pw: [f32; 2];
515 if self.weighting_delay[1] == 7 {
516 pw = [1.0; 2];
517 } else {
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 {
521 pw = [w, iw];
522 } else {
523 pw = [iw, w];
524 }
525 }
526 let cw: [f32; 2];
527 if self.weighting_delay[3] == 7 {
528 cw = [1.0; 2];
529 } else {
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 {
533 cw = [w, iw];
534 } else {
535 cw = [iw, w];
536 }
537 }
538
539 for i in 0..4 {
540 let off = i * 256;
541 for j in 0..8 {
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);
544 }
545 for j in 8..256 {
546 self.ch_data[0].data[off + j] *= cw[0];
547 self.ch_data[1].data[off + j] *= cw[1];
548 }
549 }
550 }
551 }
552
553 fn interp(a: f32, b: f32, pos: usize) -> f32 {
554 a + ((pos as f32) / 8.0) * (b - a)
555 }
556
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);
563
564 let mut mr = MemoryReader::new_read(&edata);
565 let mut br = ByteReader::new(&mut mr);
566
567 match edata.len() {
568 10 => {
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 {
576 0 => Mode::Mono,
577 2 => Mode::Stereo,
578 0x12 => Mode::JointStereo,
579 _ => return Err(DecoderError::InvalidData),
580 };
581 self.channels = if self.mode == Mode::Mono { 1 } else { 2 };
582 self.scrambled = true;
583 },
584 14 | 16 => {
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 };
589 self.channels = 2;
590 br.read_skip(2)?;
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
594 },
595 _ => { return Err(DecoderError::InvalidData) }
596 };
597 validate!(self.samples == ATRAC3_FRAME_SIZE * self.channels);
598 if self.mode == Mode::Mono {
599 self.chmap.add_channel(NAChannelType::C);
600 } else {
601 self.chmap.add_channel(NAChannelType::L);
602 self.chmap.add_channel(NAChannelType::R);
603 }
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));
607 Ok(())
608 } else {
609 Err(DecoderError::InvalidData)
610 }
611 }
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);
617
618 let frame_size = pktbuf.len();
619 self.pkt_buf.resize(frame_size, 0);
620 if self.scrambled {
621 for (i, s) in pktbuf.iter().enumerate() {
622 self.pkt_buf[i] = s ^ ATRAC3_XOR_KEY[i & 3];
623 }
624 } else {
625 let dst = &mut self.pkt_buf[0..frame_size];
626 dst.copy_from_slice(pktbuf.as_slice());
627 }
628
629 {
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);
635 }
636 if self.channels == 2 {
637 let off;
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;
644 }
645 let mut i = 0;
646 while (i < frame_size) && (self.pkt_buf[i] == 0xF8) { i += 1; }
647 validate!(frame_size - i > 4);
648 off = i;
649 } else {
650 off = frame_size / 2;
651 }
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);
656 } else {
657 let id = br.read(6)?;
658 validate!(id == 0x28);
659 }
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];
663 }
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;
668 for i in 0..4 {
669 self.mci_next[i] = br.read(2)? as usize;
670 }
671 }
672 self.ch_data[1].decode_unit(&mut br, &self.codebooks, &self.scalefactors)?;
673 self.ch_data[1].synth(&mut self.dsp);
674 }
675 if self.mode == Mode::JointStereo {
676 self.rev_matrix();
677 self.weigh_channels();
678 }
679
680 let ainfo = self.info.get_properties().get_audio_info().unwrap();
681
682 let abuf = alloc_audio_buffer(ainfo, ATRAC3_FRAME_SIZE, self.chmap.clone())?;
683 let mut adata = abuf.get_abuf_f32().unwrap();
684 let output = adata.get_data_mut().unwrap();
685
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]);
689 }
690
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)))
694 }
695 }
696
697 pub fn get_decoder() -> Box<NADecoder> {
698 Box::new(Atrac3Decoder::new())
699 }
700
701 #[cfg(test)]
702 mod test {
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;
708 #[test]
709 fn test_atrac3() {
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);
714
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);
718 }
719 }
720
721 const ATRAC3_XOR_KEY: [u8; 4] = [ 0x53, 0x7F, 0x61, 0x03 ];
722
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 ]
741 ];
742 const ATRAC3_HUFF_BITS: [&[u8]; 7] = [
743 &[ 1, 3, 3, 4, 4, 5, 5, 5, 5 ],
744 &[ 1, 3, 3, 3, 3 ],
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 ],
751 ];
752
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 ];
754
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,
758 1024
759 ];
760
761 const ATRAC3_MATRIX_COEFFS: [f32; 8] = [ 0.0, 2.0, 2.0, 2.0, 0.0, 0.0, 1.0, 1.0 ];
762
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
776 ];
NihAV is a research multimedia framework