]>
Commit | Line | Data |
---|---|---|
38953fb5 KS |
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; | |
aab478c1 KS |
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 | } | |
1a151e53 | 291 | |
aab478c1 | 292 | Self { |
8cb5b63b | 293 | imdct: IMDCT::new(FFTMode::SplitRadix, 512, false), |
aab478c1 KS |
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 | ||
b70cc006 | 682 | let abuf = alloc_audio_buffer(ainfo, ATRAC3_FRAME_SIZE, self.chmap.clone())?; |
aab478c1 KS |
683 | let mut adata = abuf.get_abuf_f32().unwrap(); |
684 | let mut output = adata.get_data_mut(); | |
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 { | |
4f6124ac KS |
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; | |
aab478c1 KS |
708 | #[test] |
709 | fn test_atrac3() { | |
4f6124ac KS |
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 | ||
aab478c1 KS |
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"; | |
4f6124ac | 717 | test_decode_audio("realmedia", file, Some(12000), "atrac3", &dmx_reg, &dec_reg); |
aab478c1 KS |
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 | ]; |