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