]>
Commit | Line | Data |
---|---|---|
1 | use formats::*; | |
2 | use frame::*; | |
3 | use super::*; | |
4 | use io::bitreader::*; | |
5 | use io::byteio::*; | |
6 | use io::codebook::*; | |
7 | use dsp::fft::FFTMode; | |
8 | use 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: Rc<NACodecInfo>, | |
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, 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); | |
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, 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 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(); | |
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(Rc::new(RefCell::new(frm))) | |
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 test::dec_video::*; | |
702 | #[test] | |
703 | fn test_atrac3() { | |
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"); | |
707 | } | |
708 | } | |
709 | ||
710 | const ATRAC3_XOR_KEY: [u8; 4] = [ 0x53, 0x7F, 0x61, 0x03 ]; | |
711 | ||
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 ] | |
730 | ]; | |
731 | const ATRAC3_HUFF_BITS: [&[u8]; 7] = [ | |
732 | &[ 1, 3, 3, 4, 4, 5, 5, 5, 5 ], | |
733 | &[ 1, 3, 3, 3, 3 ], | |
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 ], | |
740 | ]; | |
741 | ||
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 ]; | |
743 | ||
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, | |
747 | 1024 | |
748 | ]; | |
749 | ||
750 | const ATRAC3_MATRIX_COEFFS: [f32; 8] = [ 0.0, 2.0, 2.0, 2.0, 0.0, 0.0, 1.0, 1.0 ]; | |
751 | ||
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 | |
765 | ]; |