Mercurial > libavcodec.hg
annotate atrac3.c @ 11352:6e0af2cfdcfe libavcodec
Do MC and IDCT in coding (hilbert) order
This increases the slice size to 64 pixels, due to having to decode an
entire chroma superblock row per slice.
This can be up to 6% slower depending on clip and CPU, but is necessary
for future optimizations that gain significantly more than was lost.
author | conrad |
---|---|
date | Wed, 03 Mar 2010 23:27:40 +0000 |
parents | 34a65026fa06 |
children | 98970e51365a |
rev | line source |
---|---|
4856 | 1 /* |
2 * Atrac 3 compatible decoder | |
6844 | 3 * Copyright (c) 2006-2008 Maxim Poliakovski |
4 * Copyright (c) 2006-2008 Benjamin Larsson | |
4856 | 5 * |
6 * This file is part of FFmpeg. | |
7 * | |
8 * FFmpeg is free software; you can redistribute it and/or | |
9 * modify it under the terms of the GNU Lesser General Public | |
10 * License as published by the Free Software Foundation; either | |
11 * version 2.1 of the License, or (at your option) any later version. | |
12 * | |
13 * FFmpeg is distributed in the hope that it will be useful, | |
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 * Lesser General Public License for more details. | |
17 * | |
18 * You should have received a copy of the GNU Lesser General Public | |
19 * License along with FFmpeg; if not, write to the Free Software | |
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
21 */ | |
22 | |
23 /** | |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
7987
diff
changeset
|
24 * @file libavcodec/atrac3.c |
4856 | 25 * Atrac 3 compatible decoder. |
6844 | 26 * This decoder handles Sony's ATRAC3 data. |
27 * | |
28 * Container formats used to store atrac 3 data: | |
29 * RealMedia (.rm), RIFF WAV (.wav, .at3), Sony OpenMG (.oma, .aa3). | |
4856 | 30 * |
31 * To use this decoder, a calling application must supply the extradata | |
6844 | 32 * bytes provided in the containers above. |
4856 | 33 */ |
34 | |
35 #include <math.h> | |
36 #include <stddef.h> | |
37 #include <stdio.h> | |
38 | |
39 #include "avcodec.h" | |
9428 | 40 #include "get_bits.h" |
4856 | 41 #include "dsputil.h" |
42 #include "bytestream.h" | |
43 | |
10150
29cedcc646fe
Split out common routines needed in the atrac1 decoder from atrac3.c to atrac.c.
banan
parents:
9667
diff
changeset
|
44 #include "atrac.h" |
4856 | 45 #include "atrac3data.h" |
46 | |
47 #define JOINT_STEREO 0x12 | |
48 #define STEREO 0x2 | |
49 | |
50 | |
51 /* These structures are needed to store the parsed gain control data. */ | |
52 typedef struct { | |
53 int num_gain_data; | |
54 int levcode[8]; | |
55 int loccode[8]; | |
56 } gain_info; | |
57 | |
58 typedef struct { | |
59 gain_info gBlock[4]; | |
60 } gain_block; | |
61 | |
62 typedef struct { | |
63 int pos; | |
64 int numCoefs; | |
65 float coef[8]; | |
66 } tonal_component; | |
67 | |
68 typedef struct { | |
69 int bandsCoded; | |
70 int numComponents; | |
71 tonal_component components[64]; | |
72 float prevFrame[1024]; | |
73 int gcBlkSwitch; | |
74 gain_block gainBlock[2]; | |
75 | |
10961
34a65026fa06
Move array specifiers outside DECLARE_ALIGNED() invocations
mru
parents:
10200
diff
changeset
|
76 DECLARE_ALIGNED_16(float, spectrum)[1024]; |
34a65026fa06
Move array specifiers outside DECLARE_ALIGNED() invocations
mru
parents:
10200
diff
changeset
|
77 DECLARE_ALIGNED_16(float, IMDCT_buf)[1024]; |
4856 | 78 |
79 float delayBuf1[46]; ///<qmf delay buffers | |
80 float delayBuf2[46]; | |
81 float delayBuf3[46]; | |
82 } channel_unit; | |
83 | |
84 typedef struct { | |
85 GetBitContext gb; | |
86 //@{ | |
87 /** stream data */ | |
88 int channels; | |
89 int codingMode; | |
90 int bit_rate; | |
91 int sample_rate; | |
92 int samples_per_channel; | |
93 int samples_per_frame; | |
94 | |
95 int bits_per_frame; | |
96 int bytes_per_frame; | |
97 int pBs; | |
98 channel_unit* pUnits; | |
99 //@} | |
100 //@{ | |
101 /** joint-stereo related variables */ | |
102 int matrix_coeff_index_prev[4]; | |
103 int matrix_coeff_index_now[4]; | |
104 int matrix_coeff_index_next[4]; | |
105 int weighting_delay[6]; | |
106 //@} | |
107 //@{ | |
108 /** data buffers */ | |
109 float outSamples[2048]; | |
110 uint8_t* decoded_bytes_buffer; | |
111 float tempBuf[1070]; | |
112 //@} | |
113 //@{ | |
114 /** extradata */ | |
115 int atrac3version; | |
116 int delay; | |
117 int scrambled_stream; | |
118 int frame_factor; | |
119 //@} | |
120 } ATRAC3Context; | |
121 | |
10961
34a65026fa06
Move array specifiers outside DECLARE_ALIGNED() invocations
mru
parents:
10200
diff
changeset
|
122 static DECLARE_ALIGNED_16(float,mdct_window)[512]; |
4856 | 123 static VLC spectral_coeff_tab[7]; |
124 static float gain_tab1[16]; | |
125 static float gain_tab2[31]; | |
10199 | 126 static FFTContext mdct_ctx; |
4856 | 127 static DSPContext dsp; |
128 | |
129 | |
130 /** | |
131 * Regular 512 points IMDCT without overlapping, with the exception of the swapping of odd bands | |
132 * caused by the reverse spectra of the QMF. | |
133 * | |
134 * @param pInput float input | |
135 * @param pOutput float output | |
136 * @param odd_band 1 if the band is an odd band | |
137 */ | |
138 | |
7546 | 139 static void IMLT(float *pInput, float *pOutput, int odd_band) |
4856 | 140 { |
141 int i; | |
142 | |
143 if (odd_band) { | |
144 /** | |
145 * Reverse the odd bands before IMDCT, this is an effect of the QMF transform | |
146 * or it gives better compression to do it this way. | |
147 * FIXME: It should be possible to handle this in ff_imdct_calc | |
148 * for that to happen a modification of the prerotation step of | |
149 * all SIMD code and C code is needed. | |
150 * Or fix the functions before so they generate a pre reversed spectrum. | |
151 */ | |
152 | |
153 for (i=0; i<128; i++) | |
154 FFSWAP(float, pInput[i], pInput[255-i]); | |
155 } | |
156 | |
7547 | 157 ff_imdct_calc(&mdct_ctx,pOutput,pInput); |
4856 | 158 |
159 /* Perform windowing on the output. */ | |
160 dsp.vector_fmul(pOutput,mdct_window,512); | |
161 | |
162 } | |
163 | |
164 | |
165 /** | |
166 * Atrac 3 indata descrambling, only used for data coming from the rm container | |
167 * | |
168 * @param in pointer to 8 bit array of indata | |
169 * @param bits amount of bits | |
170 * @param out pointer to 8 bit array of outdata | |
171 */ | |
172 | |
6228 | 173 static int decode_bytes(const uint8_t* inbuffer, uint8_t* out, int bytes){ |
4856 | 174 int i, off; |
175 uint32_t c; | |
6228 | 176 const uint32_t* buf; |
4856 | 177 uint32_t* obuf = (uint32_t*) out; |
178 | |
9183
7b62479a31ec
use intptr_t to cast pointers to int in codecs maintained by benjamin larsson
ramiro
parents:
9007
diff
changeset
|
179 off = (intptr_t)inbuffer & 3; |
6228 | 180 buf = (const uint32_t*) (inbuffer - off); |
4856 | 181 c = be2me_32((0x537F6103 >> (off*8)) | (0x537F6103 << (32-(off*8)))); |
182 bytes += 3 + off; | |
183 for (i = 0; i < bytes/4; i++) | |
184 obuf[i] = c ^ buf[i]; | |
185 | |
186 if (off) | |
187 av_log(NULL,AV_LOG_DEBUG,"Offset of %d not handled, post sample on ffmpeg-dev.\n",off); | |
188 | |
189 return off; | |
190 } | |
191 | |
192 | |
9007
043574c5c153
Add missing av_cold in static init/close functions.
stefano
parents:
8718
diff
changeset
|
193 static av_cold void init_atrac3_transforms(ATRAC3Context *q) { |
4856 | 194 float enc_window[256]; |
195 int i; | |
196 | |
197 /* Generate the mdct window, for details see | |
198 * http://wiki.multimedia.cx/index.php?title=RealAudio_atrc#Windows */ | |
199 for (i=0 ; i<256; i++) | |
200 enc_window[i] = (sin(((i + 0.5) / 256.0 - 0.5) * M_PI) + 1.0) * 0.5; | |
201 | |
202 if (!mdct_window[0]) | |
203 for (i=0 ; i<256; i++) { | |
204 mdct_window[i] = enc_window[i]/(enc_window[i]*enc_window[i] + enc_window[255-i]*enc_window[255-i]); | |
205 mdct_window[511-i] = mdct_window[i]; | |
206 } | |
207 | |
208 /* Initialize the MDCT transform. */ | |
9658
67a20f0eb42c
Support for getting (i)MDCT output multiplied by a constant scaling factor.
serge
parents:
9428
diff
changeset
|
209 ff_mdct_init(&mdct_ctx, 9, 1, 1.0); |
4856 | 210 } |
211 | |
212 /** | |
213 * Atrac3 uninit, free all allocated memory | |
214 */ | |
215 | |
9007
043574c5c153
Add missing av_cold in static init/close functions.
stefano
parents:
8718
diff
changeset
|
216 static av_cold int atrac3_decode_close(AVCodecContext *avctx) |
4856 | 217 { |
218 ATRAC3Context *q = avctx->priv_data; | |
219 | |
220 av_free(q->pUnits); | |
221 av_free(q->decoded_bytes_buffer); | |
222 | |
223 return 0; | |
224 } | |
225 | |
226 /** | |
227 / * Mantissa decoding | |
228 * | |
229 * @param gb the GetBit context | |
230 * @param selector what table is the output values coded with | |
231 * @param codingFlag constant length coding or variable length coding | |
232 * @param mantissas mantissa output table | |
233 * @param numCodes amount of values to get | |
234 */ | |
235 | |
236 static void readQuantSpectralCoeffs (GetBitContext *gb, int selector, int codingFlag, int* mantissas, int numCodes) | |
237 { | |
238 int numBits, cnt, code, huffSymb; | |
239 | |
240 if (selector == 1) | |
241 numCodes /= 2; | |
242 | |
243 if (codingFlag != 0) { | |
244 /* constant length coding (CLC) */ | |
245 numBits = CLCLengthTab[selector]; | |
246 | |
247 if (selector > 1) { | |
248 for (cnt = 0; cnt < numCodes; cnt++) { | |
249 if (numBits) | |
250 code = get_sbits(gb, numBits); | |
251 else | |
252 code = 0; | |
253 mantissas[cnt] = code; | |
254 } | |
255 } else { | |
256 for (cnt = 0; cnt < numCodes; cnt++) { | |
257 if (numBits) | |
258 code = get_bits(gb, numBits); //numBits is always 4 in this case | |
259 else | |
260 code = 0; | |
261 mantissas[cnt*2] = seTab_0[code >> 2]; | |
262 mantissas[cnt*2+1] = seTab_0[code & 3]; | |
263 } | |
264 } | |
265 } else { | |
266 /* variable length coding (VLC) */ | |
267 if (selector != 1) { | |
268 for (cnt = 0; cnt < numCodes; cnt++) { | |
269 huffSymb = get_vlc2(gb, spectral_coeff_tab[selector-1].table, spectral_coeff_tab[selector-1].bits, 3); | |
270 huffSymb += 1; | |
271 code = huffSymb >> 1; | |
272 if (huffSymb & 1) | |
273 code = -code; | |
274 mantissas[cnt] = code; | |
275 } | |
276 } else { | |
277 for (cnt = 0; cnt < numCodes; cnt++) { | |
278 huffSymb = get_vlc2(gb, spectral_coeff_tab[selector-1].table, spectral_coeff_tab[selector-1].bits, 3); | |
279 mantissas[cnt*2] = decTable1[huffSymb*2]; | |
280 mantissas[cnt*2+1] = decTable1[huffSymb*2+1]; | |
281 } | |
282 } | |
283 } | |
284 } | |
285 | |
286 /** | |
287 * Restore the quantized band spectrum coefficients | |
288 * | |
289 * @param gb the GetBit context | |
290 * @param pOut decoded band spectrum | |
291 * @return outSubbands subband counter, fix for broken specification/files | |
292 */ | |
293 | |
294 static int decodeSpectrum (GetBitContext *gb, float *pOut) | |
295 { | |
296 int numSubbands, codingMode, cnt, first, last, subbWidth, *pIn; | |
297 int subband_vlc_index[32], SF_idxs[32]; | |
298 int mantissas[128]; | |
299 float SF; | |
300 | |
301 numSubbands = get_bits(gb, 5); // number of coded subbands | |
5513 | 302 codingMode = get_bits1(gb); // coding Mode: 0 - VLC/ 1-CLC |
4856 | 303 |
304 /* Get the VLC selector table for the subbands, 0 means not coded. */ | |
305 for (cnt = 0; cnt <= numSubbands; cnt++) | |
306 subband_vlc_index[cnt] = get_bits(gb, 3); | |
307 | |
308 /* Read the scale factor indexes from the stream. */ | |
309 for (cnt = 0; cnt <= numSubbands; cnt++) { | |
310 if (subband_vlc_index[cnt] != 0) | |
311 SF_idxs[cnt] = get_bits(gb, 6); | |
312 } | |
313 | |
314 for (cnt = 0; cnt <= numSubbands; cnt++) { | |
315 first = subbandTab[cnt]; | |
316 last = subbandTab[cnt+1]; | |
317 | |
318 subbWidth = last - first; | |
319 | |
320 if (subband_vlc_index[cnt] != 0) { | |
321 /* Decode spectral coefficients for this subband. */ | |
322 /* TODO: This can be done faster is several blocks share the | |
323 * same VLC selector (subband_vlc_index) */ | |
324 readQuantSpectralCoeffs (gb, subband_vlc_index[cnt], codingMode, mantissas, subbWidth); | |
325 | |
326 /* Decode the scale factor for this subband. */ | |
10150
29cedcc646fe
Split out common routines needed in the atrac1 decoder from atrac3.c to atrac.c.
banan
parents:
9667
diff
changeset
|
327 SF = sf_table[SF_idxs[cnt]] * iMaxQuant[subband_vlc_index[cnt]]; |
4856 | 328 |
329 /* Inverse quantize the coefficients. */ | |
330 for (pIn=mantissas ; first<last; first++, pIn++) | |
331 pOut[first] = *pIn * SF; | |
332 } else { | |
333 /* This subband was not coded, so zero the entire subband. */ | |
334 memset(pOut+first, 0, subbWidth*sizeof(float)); | |
335 } | |
336 } | |
337 | |
338 /* Clear the subbands that were not coded. */ | |
339 first = subbandTab[cnt]; | |
340 memset(pOut+first, 0, (1024 - first) * sizeof(float)); | |
341 return numSubbands; | |
342 } | |
343 | |
344 /** | |
345 * Restore the quantized tonal components | |
346 * | |
347 * @param gb the GetBit context | |
348 * @param pComponent tone component | |
349 * @param numBands amount of coded bands | |
350 */ | |
351 | |
4865 | 352 static int decodeTonalComponents (GetBitContext *gb, tonal_component *pComponent, int numBands) |
4856 | 353 { |
354 int i,j,k,cnt; | |
4865 | 355 int components, coding_mode_selector, coding_mode, coded_values_per_component; |
4856 | 356 int sfIndx, coded_values, max_coded_values, quant_step_index, coded_components; |
357 int band_flags[4], mantissa[8]; | |
358 float *pCoef; | |
359 float scalefactor; | |
4865 | 360 int component_count = 0; |
4856 | 361 |
362 components = get_bits(gb,5); | |
363 | |
364 /* no tonal components */ | |
365 if (components == 0) | |
366 return 0; | |
367 | |
368 coding_mode_selector = get_bits(gb,2); | |
369 if (coding_mode_selector == 2) | |
370 return -1; | |
371 | |
372 coding_mode = coding_mode_selector & 1; | |
373 | |
374 for (i = 0; i < components; i++) { | |
375 for (cnt = 0; cnt <= numBands; cnt++) | |
376 band_flags[cnt] = get_bits1(gb); | |
377 | |
378 coded_values_per_component = get_bits(gb,3); | |
379 | |
380 quant_step_index = get_bits(gb,3); | |
381 if (quant_step_index <= 1) | |
382 return -1; | |
383 | |
384 if (coding_mode_selector == 3) | |
385 coding_mode = get_bits1(gb); | |
386 | |
387 for (j = 0; j < (numBands + 1) * 4; j++) { | |
388 if (band_flags[j >> 2] == 0) | |
389 continue; | |
390 | |
391 coded_components = get_bits(gb,3); | |
392 | |
393 for (k=0; k<coded_components; k++) { | |
394 sfIndx = get_bits(gb,6); | |
395 pComponent[component_count].pos = j * 64 + (get_bits(gb,6)); | |
396 max_coded_values = 1024 - pComponent[component_count].pos; | |
397 coded_values = coded_values_per_component + 1; | |
398 coded_values = FFMIN(max_coded_values,coded_values); | |
399 | |
10150
29cedcc646fe
Split out common routines needed in the atrac1 decoder from atrac3.c to atrac.c.
banan
parents:
9667
diff
changeset
|
400 scalefactor = sf_table[sfIndx] * iMaxQuant[quant_step_index]; |
4856 | 401 |
402 readQuantSpectralCoeffs(gb, quant_step_index, coding_mode, mantissa, coded_values); | |
403 | |
404 pComponent[component_count].numCoefs = coded_values; | |
405 | |
406 /* inverse quant */ | |
6843
bc8faf4f8b7d
Fix decoding of 01-Untitled(1).oma, patch by Maxim Poliakovski
banan
parents:
6716
diff
changeset
|
407 pCoef = pComponent[component_count].coef; |
4856 | 408 for (cnt = 0; cnt < coded_values; cnt++) |
409 pCoef[cnt] = mantissa[cnt] * scalefactor; | |
410 | |
411 component_count++; | |
412 } | |
413 } | |
414 } | |
415 | |
4865 | 416 return component_count; |
4856 | 417 } |
418 | |
419 /** | |
420 * Decode gain parameters for the coded bands | |
421 * | |
422 * @param gb the GetBit context | |
423 * @param pGb the gainblock for the current band | |
424 * @param numBands amount of coded bands | |
425 */ | |
426 | |
427 static int decodeGainControl (GetBitContext *gb, gain_block *pGb, int numBands) | |
428 { | |
429 int i, cf, numData; | |
430 int *pLevel, *pLoc; | |
431 | |
432 gain_info *pGain = pGb->gBlock; | |
433 | |
434 for (i=0 ; i<=numBands; i++) | |
435 { | |
436 numData = get_bits(gb,3); | |
437 pGain[i].num_gain_data = numData; | |
438 pLevel = pGain[i].levcode; | |
439 pLoc = pGain[i].loccode; | |
440 | |
441 for (cf = 0; cf < numData; cf++){ | |
442 pLevel[cf]= get_bits(gb,4); | |
443 pLoc [cf]= get_bits(gb,5); | |
444 if(cf && pLoc[cf] <= pLoc[cf-1]) | |
445 return -1; | |
446 } | |
447 } | |
448 | |
449 /* Clear the unused blocks. */ | |
450 for (; i<4 ; i++) | |
451 pGain[i].num_gain_data = 0; | |
452 | |
453 return 0; | |
454 } | |
455 | |
456 /** | |
457 * Apply gain parameters and perform the MDCT overlapping part | |
458 * | |
459 * @param pIn input float buffer | |
460 * @param pPrev previous float buffer to perform overlap against | |
461 * @param pOut output float buffer | |
462 * @param pGain1 current band gain info | |
463 * @param pGain2 next band gain info | |
464 */ | |
465 | |
466 static void gainCompensateAndOverlap (float *pIn, float *pPrev, float *pOut, gain_info *pGain1, gain_info *pGain2) | |
467 { | |
468 /* gain compensation function */ | |
469 float gain1, gain2, gain_inc; | |
470 int cnt, numdata, nsample, startLoc, endLoc; | |
471 | |
472 | |
473 if (pGain2->num_gain_data == 0) | |
474 gain1 = 1.0; | |
475 else | |
476 gain1 = gain_tab1[pGain2->levcode[0]]; | |
477 | |
478 if (pGain1->num_gain_data == 0) { | |
479 for (cnt = 0; cnt < 256; cnt++) | |
480 pOut[cnt] = pIn[cnt] * gain1 + pPrev[cnt]; | |
481 } else { | |
482 numdata = pGain1->num_gain_data; | |
483 pGain1->loccode[numdata] = 32; | |
484 pGain1->levcode[numdata] = 4; | |
485 | |
486 nsample = 0; // current sample = 0 | |
487 | |
488 for (cnt = 0; cnt < numdata; cnt++) { | |
489 startLoc = pGain1->loccode[cnt] * 8; | |
490 endLoc = startLoc + 8; | |
491 | |
492 gain2 = gain_tab1[pGain1->levcode[cnt]]; | |
493 gain_inc = gain_tab2[(pGain1->levcode[cnt+1] - pGain1->levcode[cnt])+15]; | |
494 | |
495 /* interpolate */ | |
496 for (; nsample < startLoc; nsample++) | |
497 pOut[nsample] = (pIn[nsample] * gain1 + pPrev[nsample]) * gain2; | |
498 | |
499 /* interpolation is done over eight samples */ | |
500 for (; nsample < endLoc; nsample++) { | |
501 pOut[nsample] = (pIn[nsample] * gain1 + pPrev[nsample]) * gain2; | |
502 gain2 *= gain_inc; | |
503 } | |
504 } | |
505 | |
506 for (; nsample < 256; nsample++) | |
507 pOut[nsample] = (pIn[nsample] * gain1) + pPrev[nsample]; | |
508 } | |
509 | |
510 /* Delay for the overlapping part. */ | |
511 memcpy(pPrev, &pIn[256], 256*sizeof(float)); | |
512 } | |
513 | |
514 /** | |
515 * Combine the tonal band spectrum and regular band spectrum | |
6843
bc8faf4f8b7d
Fix decoding of 01-Untitled(1).oma, patch by Maxim Poliakovski
banan
parents:
6716
diff
changeset
|
516 * Return position of the last tonal coefficient |
4856 | 517 * |
518 * @param pSpectrum output spectrum buffer | |
519 * @param numComponents amount of tonal components | |
520 * @param pComponent tonal components for this band | |
521 */ | |
522 | |
6843
bc8faf4f8b7d
Fix decoding of 01-Untitled(1).oma, patch by Maxim Poliakovski
banan
parents:
6716
diff
changeset
|
523 static int addTonalComponents (float *pSpectrum, int numComponents, tonal_component *pComponent) |
4856 | 524 { |
6843
bc8faf4f8b7d
Fix decoding of 01-Untitled(1).oma, patch by Maxim Poliakovski
banan
parents:
6716
diff
changeset
|
525 int cnt, i, lastPos = -1; |
4856 | 526 float *pIn, *pOut; |
527 | |
528 for (cnt = 0; cnt < numComponents; cnt++){ | |
6843
bc8faf4f8b7d
Fix decoding of 01-Untitled(1).oma, patch by Maxim Poliakovski
banan
parents:
6716
diff
changeset
|
529 lastPos = FFMAX(pComponent[cnt].pos + pComponent[cnt].numCoefs, lastPos); |
4856 | 530 pIn = pComponent[cnt].coef; |
531 pOut = &(pSpectrum[pComponent[cnt].pos]); | |
532 | |
533 for (i=0 ; i<pComponent[cnt].numCoefs ; i++) | |
534 pOut[i] += pIn[i]; | |
535 } | |
6843
bc8faf4f8b7d
Fix decoding of 01-Untitled(1).oma, patch by Maxim Poliakovski
banan
parents:
6716
diff
changeset
|
536 |
bc8faf4f8b7d
Fix decoding of 01-Untitled(1).oma, patch by Maxim Poliakovski
banan
parents:
6716
diff
changeset
|
537 return lastPos; |
4856 | 538 } |
539 | |
540 | |
541 #define INTERPOLATE(old,new,nsample) ((old) + (nsample)*0.125*((new)-(old))) | |
542 | |
543 static void reverseMatrixing(float *su1, float *su2, int *pPrevCode, int *pCurrCode) | |
544 { | |
545 int i, band, nsample, s1, s2; | |
546 float c1, c2; | |
547 float mc1_l, mc1_r, mc2_l, mc2_r; | |
548 | |
549 for (i=0,band = 0; band < 4*256; band+=256,i++) { | |
550 s1 = pPrevCode[i]; | |
551 s2 = pCurrCode[i]; | |
552 nsample = 0; | |
553 | |
554 if (s1 != s2) { | |
555 /* Selector value changed, interpolation needed. */ | |
556 mc1_l = matrixCoeffs[s1*2]; | |
557 mc1_r = matrixCoeffs[s1*2+1]; | |
558 mc2_l = matrixCoeffs[s2*2]; | |
559 mc2_r = matrixCoeffs[s2*2+1]; | |
560 | |
561 /* Interpolation is done over the first eight samples. */ | |
562 for(; nsample < 8; nsample++) { | |
563 c1 = su1[band+nsample]; | |
564 c2 = su2[band+nsample]; | |
565 c2 = c1 * INTERPOLATE(mc1_l,mc2_l,nsample) + c2 * INTERPOLATE(mc1_r,mc2_r,nsample); | |
566 su1[band+nsample] = c2; | |
567 su2[band+nsample] = c1 * 2.0 - c2; | |
568 } | |
569 } | |
570 | |
571 /* Apply the matrix without interpolation. */ | |
572 switch (s2) { | |
573 case 0: /* M/S decoding */ | |
574 for (; nsample < 256; nsample++) { | |
575 c1 = su1[band+nsample]; | |
576 c2 = su2[band+nsample]; | |
577 su1[band+nsample] = c2 * 2.0; | |
578 su2[band+nsample] = (c1 - c2) * 2.0; | |
579 } | |
580 break; | |
581 | |
582 case 1: | |
583 for (; nsample < 256; nsample++) { | |
584 c1 = su1[band+nsample]; | |
585 c2 = su2[band+nsample]; | |
586 su1[band+nsample] = (c1 + c2) * 2.0; | |
587 su2[band+nsample] = c2 * -2.0; | |
588 } | |
589 break; | |
590 case 2: | |
591 case 3: | |
592 for (; nsample < 256; nsample++) { | |
593 c1 = su1[band+nsample]; | |
594 c2 = su2[band+nsample]; | |
595 su1[band+nsample] = c1 + c2; | |
596 su2[band+nsample] = c1 - c2; | |
597 } | |
598 break; | |
599 default: | |
600 assert(0); | |
601 } | |
602 } | |
603 } | |
604 | |
605 static void getChannelWeights (int indx, int flag, float ch[2]){ | |
606 | |
607 if (indx == 7) { | |
608 ch[0] = 1.0; | |
609 ch[1] = 1.0; | |
610 } else { | |
611 ch[0] = (float)(indx & 7) / 7.0; | |
612 ch[1] = sqrt(2 - ch[0]*ch[0]); | |
613 if(flag) | |
614 FFSWAP(float, ch[0], ch[1]); | |
615 } | |
616 } | |
617 | |
618 static void channelWeighting (float *su1, float *su2, int *p3) | |
619 { | |
620 int band, nsample; | |
621 /* w[x][y] y=0 is left y=1 is right */ | |
622 float w[2][2]; | |
623 | |
624 if (p3[1] != 7 || p3[3] != 7){ | |
625 getChannelWeights(p3[1], p3[0], w[0]); | |
626 getChannelWeights(p3[3], p3[2], w[1]); | |
627 | |
628 for(band = 1; band < 4; band++) { | |
629 /* scale the channels by the weights */ | |
630 for(nsample = 0; nsample < 8; nsample++) { | |
631 su1[band*256+nsample] *= INTERPOLATE(w[0][0], w[0][1], nsample); | |
632 su2[band*256+nsample] *= INTERPOLATE(w[1][0], w[1][1], nsample); | |
633 } | |
634 | |
635 for(; nsample < 256; nsample++) { | |
636 su1[band*256+nsample] *= w[1][0]; | |
637 su2[band*256+nsample] *= w[1][1]; | |
638 } | |
639 } | |
640 } | |
641 } | |
642 | |
643 | |
644 /** | |
645 * Decode a Sound Unit | |
646 * | |
647 * @param gb the GetBit context | |
648 * @param pSnd the channel unit to be used | |
649 * @param pOut the decoded samples before IQMF in float representation | |
650 * @param channelNum channel number | |
651 * @param codingMode the coding mode (JOINT_STEREO or regular stereo/mono) | |
652 */ | |
653 | |
654 | |
655 static int decodeChannelSoundUnit (ATRAC3Context *q, GetBitContext *gb, channel_unit *pSnd, float *pOut, int channelNum, int codingMode) | |
656 { | |
6843
bc8faf4f8b7d
Fix decoding of 01-Untitled(1).oma, patch by Maxim Poliakovski
banan
parents:
6716
diff
changeset
|
657 int band, result=0, numSubbands, lastTonal, numBands; |
4856 | 658 |
659 if (codingMode == JOINT_STEREO && channelNum == 1) { | |
660 if (get_bits(gb,2) != 3) { | |
661 av_log(NULL,AV_LOG_ERROR,"JS mono Sound Unit id != 3.\n"); | |
662 return -1; | |
663 } | |
664 } else { | |
665 if (get_bits(gb,6) != 0x28) { | |
666 av_log(NULL,AV_LOG_ERROR,"Sound Unit id != 0x28.\n"); | |
667 return -1; | |
668 } | |
669 } | |
670 | |
671 /* number of coded QMF bands */ | |
672 pSnd->bandsCoded = get_bits(gb,2); | |
673 | |
674 result = decodeGainControl (gb, &(pSnd->gainBlock[pSnd->gcBlkSwitch]), pSnd->bandsCoded); | |
675 if (result) return result; | |
676 | |
4865 | 677 pSnd->numComponents = decodeTonalComponents (gb, pSnd->components, pSnd->bandsCoded); |
678 if (pSnd->numComponents == -1) return -1; | |
4856 | 679 |
680 numSubbands = decodeSpectrum (gb, pSnd->spectrum); | |
681 | |
682 /* Merge the decoded spectrum and tonal components. */ | |
6843
bc8faf4f8b7d
Fix decoding of 01-Untitled(1).oma, patch by Maxim Poliakovski
banan
parents:
6716
diff
changeset
|
683 lastTonal = addTonalComponents (pSnd->spectrum, pSnd->numComponents, pSnd->components); |
4856 | 684 |
685 | |
6843
bc8faf4f8b7d
Fix decoding of 01-Untitled(1).oma, patch by Maxim Poliakovski
banan
parents:
6716
diff
changeset
|
686 /* calculate number of used MLT/QMF bands according to the amount of coded spectral lines */ |
4856 | 687 numBands = (subbandTab[numSubbands] - 1) >> 8; |
6843
bc8faf4f8b7d
Fix decoding of 01-Untitled(1).oma, patch by Maxim Poliakovski
banan
parents:
6716
diff
changeset
|
688 if (lastTonal >= 0) |
bc8faf4f8b7d
Fix decoding of 01-Untitled(1).oma, patch by Maxim Poliakovski
banan
parents:
6716
diff
changeset
|
689 numBands = FFMAX((lastTonal + 256) >> 8, numBands); |
4856 | 690 |
691 | |
692 /* Reconstruct time domain samples. */ | |
693 for (band=0; band<4; band++) { | |
694 /* Perform the IMDCT step without overlapping. */ | |
695 if (band <= numBands) { | |
7546 | 696 IMLT(&(pSnd->spectrum[band*256]), pSnd->IMDCT_buf, band&1); |
4856 | 697 } else |
698 memset(pSnd->IMDCT_buf, 0, 512 * sizeof(float)); | |
699 | |
700 /* gain compensation and overlapping */ | |
701 gainCompensateAndOverlap (pSnd->IMDCT_buf, &(pSnd->prevFrame[band*256]), &(pOut[band*256]), | |
702 &((pSnd->gainBlock[1 - (pSnd->gcBlkSwitch)]).gBlock[band]), | |
703 &((pSnd->gainBlock[pSnd->gcBlkSwitch]).gBlock[band])); | |
704 } | |
705 | |
706 /* Swap the gain control buffers for the next frame. */ | |
707 pSnd->gcBlkSwitch ^= 1; | |
708 | |
709 return 0; | |
710 } | |
711 | |
712 /** | |
713 * Frame handling | |
714 * | |
715 * @param q Atrac3 private context | |
716 * @param databuf the input data | |
717 */ | |
718 | |
7939
cd8602533b62
atrac3: ensure input frame is not overwritten (it is const)
aurel
parents:
7547
diff
changeset
|
719 static int decodeFrame(ATRAC3Context *q, const uint8_t* databuf) |
4856 | 720 { |
721 int result, i; | |
722 float *p1, *p2, *p3, *p4; | |
7939
cd8602533b62
atrac3: ensure input frame is not overwritten (it is const)
aurel
parents:
7547
diff
changeset
|
723 uint8_t *ptr1; |
4856 | 724 |
725 if (q->codingMode == JOINT_STEREO) { | |
726 | |
727 /* channel coupling mode */ | |
728 /* decode Sound Unit 1 */ | |
729 init_get_bits(&q->gb,databuf,q->bits_per_frame); | |
730 | |
731 result = decodeChannelSoundUnit(q,&q->gb, q->pUnits, q->outSamples, 0, JOINT_STEREO); | |
732 if (result != 0) | |
733 return (result); | |
734 | |
735 /* Framedata of the su2 in the joint-stereo mode is encoded in | |
736 * reverse byte order so we need to swap it first. */ | |
7939
cd8602533b62
atrac3: ensure input frame is not overwritten (it is const)
aurel
parents:
7547
diff
changeset
|
737 if (databuf == q->decoded_bytes_buffer) { |
cd8602533b62
atrac3: ensure input frame is not overwritten (it is const)
aurel
parents:
7547
diff
changeset
|
738 uint8_t *ptr2 = q->decoded_bytes_buffer+q->bytes_per_frame-1; |
cd8602533b62
atrac3: ensure input frame is not overwritten (it is const)
aurel
parents:
7547
diff
changeset
|
739 ptr1 = q->decoded_bytes_buffer; |
7987 | 740 for (i = 0; i < (q->bytes_per_frame/2); i++, ptr1++, ptr2--) { |
741 FFSWAP(uint8_t,*ptr1,*ptr2); | |
742 } | |
7939
cd8602533b62
atrac3: ensure input frame is not overwritten (it is const)
aurel
parents:
7547
diff
changeset
|
743 } else { |
cd8602533b62
atrac3: ensure input frame is not overwritten (it is const)
aurel
parents:
7547
diff
changeset
|
744 const uint8_t *ptr2 = databuf+q->bytes_per_frame-1; |
cd8602533b62
atrac3: ensure input frame is not overwritten (it is const)
aurel
parents:
7547
diff
changeset
|
745 for (i = 0; i < q->bytes_per_frame; i++) |
cd8602533b62
atrac3: ensure input frame is not overwritten (it is const)
aurel
parents:
7547
diff
changeset
|
746 q->decoded_bytes_buffer[i] = *ptr2--; |
cd8602533b62
atrac3: ensure input frame is not overwritten (it is const)
aurel
parents:
7547
diff
changeset
|
747 } |
4856 | 748 |
749 /* Skip the sync codes (0xF8). */ | |
7939
cd8602533b62
atrac3: ensure input frame is not overwritten (it is const)
aurel
parents:
7547
diff
changeset
|
750 ptr1 = q->decoded_bytes_buffer; |
4856 | 751 for (i = 4; *ptr1 == 0xF8; i++, ptr1++) { |
752 if (i >= q->bytes_per_frame) | |
753 return -1; | |
754 } | |
755 | |
756 | |
757 /* set the bitstream reader at the start of the second Sound Unit*/ | |
758 init_get_bits(&q->gb,ptr1,q->bits_per_frame); | |
759 | |
760 /* Fill the Weighting coeffs delay buffer */ | |
761 memmove(q->weighting_delay,&(q->weighting_delay[2]),4*sizeof(int)); | |
5513 | 762 q->weighting_delay[4] = get_bits1(&q->gb); |
4856 | 763 q->weighting_delay[5] = get_bits(&q->gb,3); |
764 | |
765 for (i = 0; i < 4; i++) { | |
766 q->matrix_coeff_index_prev[i] = q->matrix_coeff_index_now[i]; | |
767 q->matrix_coeff_index_now[i] = q->matrix_coeff_index_next[i]; | |
768 q->matrix_coeff_index_next[i] = get_bits(&q->gb,2); | |
769 } | |
770 | |
771 /* Decode Sound Unit 2. */ | |
772 result = decodeChannelSoundUnit(q,&q->gb, &q->pUnits[1], &q->outSamples[1024], 1, JOINT_STEREO); | |
773 if (result != 0) | |
774 return (result); | |
775 | |
776 /* Reconstruct the channel coefficients. */ | |
777 reverseMatrixing(q->outSamples, &q->outSamples[1024], q->matrix_coeff_index_prev, q->matrix_coeff_index_now); | |
778 | |
779 channelWeighting(q->outSamples, &q->outSamples[1024], q->weighting_delay); | |
780 | |
781 } else { | |
782 /* normal stereo mode or mono */ | |
783 /* Decode the channel sound units. */ | |
784 for (i=0 ; i<q->channels ; i++) { | |
785 | |
786 /* Set the bitstream reader at the start of a channel sound unit. */ | |
787 init_get_bits(&q->gb, databuf+((i*q->bytes_per_frame)/q->channels), (q->bits_per_frame)/q->channels); | |
788 | |
789 result = decodeChannelSoundUnit(q,&q->gb, &q->pUnits[i], &q->outSamples[i*1024], i, q->codingMode); | |
790 if (result != 0) | |
791 return (result); | |
792 } | |
793 } | |
794 | |
795 /* Apply the iQMF synthesis filter. */ | |
796 p1= q->outSamples; | |
797 for (i=0 ; i<q->channels ; i++) { | |
798 p2= p1+256; | |
799 p3= p2+256; | |
800 p4= p3+256; | |
10150
29cedcc646fe
Split out common routines needed in the atrac1 decoder from atrac3.c to atrac.c.
banan
parents:
9667
diff
changeset
|
801 atrac_iqmf (p1, p2, 256, p1, q->pUnits[i].delayBuf1, q->tempBuf); |
29cedcc646fe
Split out common routines needed in the atrac1 decoder from atrac3.c to atrac.c.
banan
parents:
9667
diff
changeset
|
802 atrac_iqmf (p4, p3, 256, p3, q->pUnits[i].delayBuf2, q->tempBuf); |
29cedcc646fe
Split out common routines needed in the atrac1 decoder from atrac3.c to atrac.c.
banan
parents:
9667
diff
changeset
|
803 atrac_iqmf (p1, p3, 512, p1, q->pUnits[i].delayBuf3, q->tempBuf); |
4856 | 804 p1 +=1024; |
805 } | |
806 | |
807 return 0; | |
808 } | |
809 | |
810 | |
811 /** | |
812 * Atrac frame decoding | |
813 * | |
814 * @param avctx pointer to the AVCodecContext | |
815 */ | |
816 | |
817 static int atrac3_decode_frame(AVCodecContext *avctx, | |
818 void *data, int *data_size, | |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9183
diff
changeset
|
819 AVPacket *avpkt) { |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9183
diff
changeset
|
820 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9183
diff
changeset
|
821 int buf_size = avpkt->size; |
4856 | 822 ATRAC3Context *q = avctx->priv_data; |
823 int result = 0, i; | |
7939
cd8602533b62
atrac3: ensure input frame is not overwritten (it is const)
aurel
parents:
7547
diff
changeset
|
824 const uint8_t* databuf; |
4856 | 825 int16_t* samples = data; |
826 | |
827 if (buf_size < avctx->block_align) | |
828 return buf_size; | |
829 | |
830 /* Check if we need to descramble and what buffer to pass on. */ | |
831 if (q->scrambled_stream) { | |
832 decode_bytes(buf, q->decoded_bytes_buffer, avctx->block_align); | |
833 databuf = q->decoded_bytes_buffer; | |
834 } else { | |
835 databuf = buf; | |
836 } | |
837 | |
838 result = decodeFrame(q, databuf); | |
839 | |
840 if (result != 0) { | |
841 av_log(NULL,AV_LOG_ERROR,"Frame decoding error!\n"); | |
842 return -1; | |
843 } | |
844 | |
845 if (q->channels == 1) { | |
846 /* mono */ | |
847 for (i = 0; i<1024; i++) | |
5523 | 848 samples[i] = av_clip_int16(round(q->outSamples[i])); |
4856 | 849 *data_size = 1024 * sizeof(int16_t); |
850 } else { | |
851 /* stereo */ | |
852 for (i = 0; i < 1024; i++) { | |
5523 | 853 samples[i*2] = av_clip_int16(round(q->outSamples[i])); |
854 samples[i*2+1] = av_clip_int16(round(q->outSamples[1024+i])); | |
4856 | 855 } |
856 *data_size = 2048 * sizeof(int16_t); | |
857 } | |
858 | |
859 return avctx->block_align; | |
860 } | |
861 | |
862 | |
863 /** | |
864 * Atrac3 initialization | |
865 * | |
866 * @param avctx pointer to the AVCodecContext | |
867 */ | |
868 | |
9007
043574c5c153
Add missing av_cold in static init/close functions.
stefano
parents:
8718
diff
changeset
|
869 static av_cold int atrac3_decode_init(AVCodecContext *avctx) |
4856 | 870 { |
871 int i; | |
6228 | 872 const uint8_t *edata_ptr = avctx->extradata; |
4856 | 873 ATRAC3Context *q = avctx->priv_data; |
9666
c80df3181479
Change from INIT_VLC_USE_STATIC to INIT_VLC_USE_NEW_STATIC in atrac3
banan
parents:
9658
diff
changeset
|
874 static VLC_TYPE atrac3_vlc_table[4096][2]; |
c80df3181479
Change from INIT_VLC_USE_STATIC to INIT_VLC_USE_NEW_STATIC in atrac3
banan
parents:
9658
diff
changeset
|
875 static int vlcs_initialized = 0; |
4856 | 876 |
877 /* Take data from the AVCodecContext (RM container). */ | |
878 q->sample_rate = avctx->sample_rate; | |
879 q->channels = avctx->channels; | |
880 q->bit_rate = avctx->bit_rate; | |
881 q->bits_per_frame = avctx->block_align * 8; | |
882 q->bytes_per_frame = avctx->block_align; | |
883 | |
884 /* Take care of the codec-specific extradata. */ | |
885 if (avctx->extradata_size == 14) { | |
886 /* Parse the extradata, WAV format */ | |
887 av_log(avctx,AV_LOG_DEBUG,"[0-1] %d\n",bytestream_get_le16(&edata_ptr)); //Unknown value always 1 | |
888 q->samples_per_channel = bytestream_get_le32(&edata_ptr); | |
889 q->codingMode = bytestream_get_le16(&edata_ptr); | |
890 av_log(avctx,AV_LOG_DEBUG,"[8-9] %d\n",bytestream_get_le16(&edata_ptr)); //Dupe of coding mode | |
891 q->frame_factor = bytestream_get_le16(&edata_ptr); //Unknown always 1 | |
892 av_log(avctx,AV_LOG_DEBUG,"[12-13] %d\n",bytestream_get_le16(&edata_ptr)); //Unknown always 0 | |
893 | |
894 /* setup */ | |
895 q->samples_per_frame = 1024 * q->channels; | |
896 q->atrac3version = 4; | |
897 q->delay = 0x88E; | |
898 if (q->codingMode) | |
899 q->codingMode = JOINT_STEREO; | |
900 else | |
901 q->codingMode = STEREO; | |
902 | |
903 q->scrambled_stream = 0; | |
904 | |
905 if ((q->bytes_per_frame == 96*q->channels*q->frame_factor) || (q->bytes_per_frame == 152*q->channels*q->frame_factor) || (q->bytes_per_frame == 192*q->channels*q->frame_factor)) { | |
906 } else { | |
907 av_log(avctx,AV_LOG_ERROR,"Unknown frame/channel/frame_factor configuration %d/%d/%d\n", q->bytes_per_frame, q->channels, q->frame_factor); | |
908 return -1; | |
909 } | |
910 | |
911 } else if (avctx->extradata_size == 10) { | |
912 /* Parse the extradata, RM format. */ | |
913 q->atrac3version = bytestream_get_be32(&edata_ptr); | |
914 q->samples_per_frame = bytestream_get_be16(&edata_ptr); | |
915 q->delay = bytestream_get_be16(&edata_ptr); | |
916 q->codingMode = bytestream_get_be16(&edata_ptr); | |
917 | |
918 q->samples_per_channel = q->samples_per_frame / q->channels; | |
919 q->scrambled_stream = 1; | |
920 | |
921 } else { | |
922 av_log(NULL,AV_LOG_ERROR,"Unknown extradata size %d.\n",avctx->extradata_size); | |
923 } | |
924 /* Check the extradata. */ | |
925 | |
926 if (q->atrac3version != 4) { | |
927 av_log(avctx,AV_LOG_ERROR,"Version %d != 4.\n",q->atrac3version); | |
928 return -1; | |
929 } | |
930 | |
931 if (q->samples_per_frame != 1024 && q->samples_per_frame != 2048) { | |
932 av_log(avctx,AV_LOG_ERROR,"Unknown amount of samples per frame %d.\n",q->samples_per_frame); | |
933 return -1; | |
934 } | |
935 | |
936 if (q->delay != 0x88E) { | |
937 av_log(avctx,AV_LOG_ERROR,"Unknown amount of delay %x != 0x88E.\n",q->delay); | |
938 return -1; | |
939 } | |
940 | |
941 if (q->codingMode == STEREO) { | |
942 av_log(avctx,AV_LOG_DEBUG,"Normal stereo detected.\n"); | |
943 } else if (q->codingMode == JOINT_STEREO) { | |
944 av_log(avctx,AV_LOG_DEBUG,"Joint stereo detected.\n"); | |
945 } else { | |
946 av_log(avctx,AV_LOG_ERROR,"Unknown channel coding mode %x!\n",q->codingMode); | |
947 return -1; | |
948 } | |
949 | |
950 if (avctx->channels <= 0 || avctx->channels > 2 /*|| ((avctx->channels * 1024) != q->samples_per_frame)*/) { | |
951 av_log(avctx,AV_LOG_ERROR,"Channel configuration error!\n"); | |
952 return -1; | |
953 } | |
954 | |
955 | |
956 if(avctx->block_align >= UINT_MAX/2) | |
957 return -1; | |
958 | |
959 /* Pad the data buffer with FF_INPUT_BUFFER_PADDING_SIZE, | |
960 * this is for the bitstream reader. */ | |
961 if ((q->decoded_bytes_buffer = av_mallocz((avctx->block_align+(4-avctx->block_align%4) + FF_INPUT_BUFFER_PADDING_SIZE))) == NULL) | |
5407 | 962 return AVERROR(ENOMEM); |
4856 | 963 |
964 | |
965 /* Initialize the VLC tables. */ | |
9666
c80df3181479
Change from INIT_VLC_USE_STATIC to INIT_VLC_USE_NEW_STATIC in atrac3
banan
parents:
9658
diff
changeset
|
966 if (!vlcs_initialized) { |
9667 | 967 for (i=0 ; i<7 ; i++) { |
968 spectral_coeff_tab[i].table = &atrac3_vlc_table[atrac3_vlc_offs[i]]; | |
969 spectral_coeff_tab[i].table_allocated = atrac3_vlc_offs[i + 1] - atrac3_vlc_offs[i]; | |
970 init_vlc (&spectral_coeff_tab[i], 9, huff_tab_sizes[i], | |
971 huff_bits[i], 1, 1, | |
972 huff_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC); | |
973 } | |
9666
c80df3181479
Change from INIT_VLC_USE_STATIC to INIT_VLC_USE_NEW_STATIC in atrac3
banan
parents:
9658
diff
changeset
|
974 vlcs_initialized = 1; |
4856 | 975 } |
976 | |
977 init_atrac3_transforms(q); | |
978 | |
10150
29cedcc646fe
Split out common routines needed in the atrac1 decoder from atrac3.c to atrac.c.
banan
parents:
9667
diff
changeset
|
979 atrac_generate_tables(); |
4856 | 980 |
981 /* Generate gain tables. */ | |
982 for (i=0 ; i<16 ; i++) | |
983 gain_tab1[i] = powf (2.0, (4 - i)); | |
984 | |
985 for (i=-15 ; i<16 ; i++) | |
986 gain_tab2[i+15] = powf (2.0, i * -0.125); | |
987 | |
988 /* init the joint-stereo decoding data */ | |
989 q->weighting_delay[0] = 0; | |
990 q->weighting_delay[1] = 7; | |
991 q->weighting_delay[2] = 0; | |
992 q->weighting_delay[3] = 7; | |
993 q->weighting_delay[4] = 0; | |
994 q->weighting_delay[5] = 7; | |
995 | |
996 for (i=0; i<4; i++) { | |
997 q->matrix_coeff_index_prev[i] = 3; | |
998 q->matrix_coeff_index_now[i] = 3; | |
999 q->matrix_coeff_index_next[i] = 3; | |
1000 } | |
1001 | |
1002 dsputil_init(&dsp, avctx); | |
1003 | |
1004 q->pUnits = av_mallocz(sizeof(channel_unit)*q->channels); | |
5423 | 1005 if (!q->pUnits) { |
1006 av_free(q->decoded_bytes_buffer); | |
1007 return AVERROR(ENOMEM); | |
1008 } | |
4856 | 1009 |
7451
85ab7655ad4d
Modify all codecs to report their supported input and output sample format(s).
pross
parents:
7040
diff
changeset
|
1010 avctx->sample_fmt = SAMPLE_FMT_S16; |
4856 | 1011 return 0; |
1012 } | |
1013 | |
1014 | |
1015 AVCodec atrac3_decoder = | |
1016 { | |
6716 | 1017 .name = "atrac3", |
4856 | 1018 .type = CODEC_TYPE_AUDIO, |
1019 .id = CODEC_ID_ATRAC3, | |
1020 .priv_data_size = sizeof(ATRAC3Context), | |
1021 .init = atrac3_decode_init, | |
1022 .close = atrac3_decode_close, | |
1023 .decode = atrac3_decode_frame, | |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6997
diff
changeset
|
1024 .long_name = NULL_IF_CONFIG_SMALL("Atrac 3 (Adaptive TRansform Acoustic Coding 3)"), |
4856 | 1025 }; |