2 * Atrac 3 compatible decoder
3 * Copyright (c) 2006-2007 Maxim Poliakovski
4 * Copyright (c) 2006-2007 Benjamin Larsson
6 * This file is part of FFmpeg.
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.
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.
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
25 * Atrac 3 compatible decoder.
26 * This decoder handles RealNetworks, RealAudio atrc data.
27 * Atrac 3 is identified by the codec name atrc in RealMedia files.
29 * To use this decoder, a calling application must supply the extradata
30 * bytes provided from the RealMedia container: 10 bytes or 14 bytes
31 * from the WAV container.
39 #include "bitstream.h"
41 #include "bytestream.h"
43 #include "atrac3data.h"
45 #define JOINT_STEREO 0x12
49 /* These structures are needed to store the parsed gain control data. */
69 tonal_component components
[64];
70 float prevFrame
[1024];
72 gain_block gainBlock
[2];
74 DECLARE_ALIGNED_16(float, spectrum
[1024]);
75 DECLARE_ALIGNED_16(float, IMDCT_buf
[1024]);
77 float delayBuf1
[46]; ///<qmf delay buffers
90 int samples_per_channel
;
91 int samples_per_frame
;
99 /** joint-stereo related variables */
100 int matrix_coeff_index_prev
[4];
101 int matrix_coeff_index_now
[4];
102 int matrix_coeff_index_next
[4];
103 int weighting_delay
[6];
107 float outSamples
[2048];
108 uint8_t* decoded_bytes_buffer
;
110 DECLARE_ALIGNED_16(float,mdct_tmp
[512]);
116 int scrambled_stream
;
121 static DECLARE_ALIGNED_16(float,mdct_window
[512]);
122 static float qmf_window
[48];
123 static VLC spectral_coeff_tab
[7];
124 static float SFTable
[64];
125 static float gain_tab1
[16];
126 static float gain_tab2
[31];
127 static MDCTContext mdct_ctx
;
128 static DSPContext dsp
;
131 /* quadrature mirror synthesis filter */
134 * Quadrature mirror synthesis filter.
136 * @param inlo lower part of spectrum
137 * @param inhi higher part of spectrum
138 * @param nIn size of spectrum buffer
139 * @param pOut out buffer
140 * @param delayBuf delayBuf buffer
141 * @param temp temp buffer
145 static void iqmf (float *inlo
, float *inhi
, unsigned int nIn
, float *pOut
, float *delayBuf
, float *temp
)
150 memcpy(temp
, delayBuf
, 46*sizeof(float));
155 for(i
=0; i
<nIn
; i
+=2){
156 p3
[2*i
+0] = inlo
[i
] + inhi
[i
];
157 p3
[2*i
+1] = inlo
[i
] - inhi
[i
];
158 p3
[2*i
+2] = inlo
[i
+1] + inhi
[i
+1];
159 p3
[2*i
+3] = inlo
[i
+1] - inhi
[i
+1];
164 for (j
= nIn
; j
!= 0; j
--) {
168 for (i
= 0; i
< 48; i
+= 2) {
169 s1
+= p1
[i
] * qmf_window
[i
];
170 s2
+= p1
[i
+1] * qmf_window
[i
+1];
180 /* Update the delay buffer. */
181 memcpy(delayBuf
, temp
+ nIn
*2, 46*sizeof(float));
185 * Regular 512 points IMDCT without overlapping, with the exception of the swapping of odd bands
186 * caused by the reverse spectra of the QMF.
188 * @param pInput float input
189 * @param pOutput float output
190 * @param odd_band 1 if the band is an odd band
191 * @param mdct_tmp aligned temporary buffer for the mdct
194 static void IMLT(float *pInput
, float *pOutput
, int odd_band
, float* mdct_tmp
)
200 * Reverse the odd bands before IMDCT, this is an effect of the QMF transform
201 * or it gives better compression to do it this way.
202 * FIXME: It should be possible to handle this in ff_imdct_calc
203 * for that to happen a modification of the prerotation step of
204 * all SIMD code and C code is needed.
205 * Or fix the functions before so they generate a pre reversed spectrum.
208 for (i
=0; i
<128; i
++)
209 FFSWAP(float, pInput
[i
], pInput
[255-i
]);
212 mdct_ctx
.fft
.imdct_calc(&mdct_ctx
,pOutput
,pInput
,mdct_tmp
);
214 /* Perform windowing on the output. */
215 dsp
.vector_fmul(pOutput
,mdct_window
,512);
221 * Atrac 3 indata descrambling, only used for data coming from the rm container
223 * @param in pointer to 8 bit array of indata
224 * @param bits amount of bits
225 * @param out pointer to 8 bit array of outdata
228 static int decode_bytes(uint8_t* inbuffer
, uint8_t* out
, int bytes
){
232 uint32_t* obuf
= (uint32_t*) out
;
234 off
= (int)((long)inbuffer
& 3);
235 buf
= (uint32_t*) (inbuffer
- off
);
236 c
= be2me_32((0x537F6103 >> (off
*8)) | (0x537F6103 << (32-(off
*8))));
238 for (i
= 0; i
< bytes
/4; i
++)
239 obuf
[i
] = c
^ buf
[i
];
242 av_log(NULL
,AV_LOG_DEBUG
,"Offset of %d not handled, post sample on ffmpeg-dev.\n",off
);
248 static void init_atrac3_transforms(ATRAC3Context
*q
) {
249 float enc_window
[256];
253 /* Generate the mdct window, for details see
254 * http://wiki.multimedia.cx/index.php?title=RealAudio_atrc#Windows */
255 for (i
=0 ; i
<256; i
++)
256 enc_window
[i
] = (sin(((i
+ 0.5) / 256.0 - 0.5) * M_PI
) + 1.0) * 0.5;
259 for (i
=0 ; i
<256; i
++) {
260 mdct_window
[i
] = enc_window
[i
]/(enc_window
[i
]*enc_window
[i
] + enc_window
[255-i
]*enc_window
[255-i
]);
261 mdct_window
[511-i
] = mdct_window
[i
];
264 /* Generate the QMF window. */
265 for (i
=0 ; i
<24; i
++) {
266 s
= qmf_48tap_half
[i
] * 2.0;
268 qmf_window
[47 - i
] = s
;
271 /* Initialize the MDCT transform. */
272 ff_mdct_init(&mdct_ctx
, 9, 1);
276 * Atrac3 uninit, free all allocated memory
279 static int atrac3_decode_close(AVCodecContext
*avctx
)
281 ATRAC3Context
*q
= avctx
->priv_data
;
284 av_free(q
->decoded_bytes_buffer
);
290 / * Mantissa decoding
292 * @param gb the GetBit context
293 * @param selector what table is the output values coded with
294 * @param codingFlag constant length coding or variable length coding
295 * @param mantissas mantissa output table
296 * @param numCodes amount of values to get
299 static void readQuantSpectralCoeffs (GetBitContext
*gb
, int selector
, int codingFlag
, int* mantissas
, int numCodes
)
301 int numBits
, cnt
, code
, huffSymb
;
306 if (codingFlag
!= 0) {
307 /* constant length coding (CLC) */
308 //FIXME we don't have any samples coded in CLC mode
309 numBits
= CLCLengthTab
[selector
];
312 for (cnt
= 0; cnt
< numCodes
; cnt
++) {
314 code
= get_sbits(gb
, numBits
);
317 mantissas
[cnt
] = code
;
320 for (cnt
= 0; cnt
< numCodes
; cnt
++) {
322 code
= get_bits(gb
, numBits
); //numBits is always 4 in this case
325 mantissas
[cnt
*2] = seTab_0
[code
>> 2];
326 mantissas
[cnt
*2+1] = seTab_0
[code
& 3];
330 /* variable length coding (VLC) */
332 for (cnt
= 0; cnt
< numCodes
; cnt
++) {
333 huffSymb
= get_vlc2(gb
, spectral_coeff_tab
[selector
-1].table
, spectral_coeff_tab
[selector
-1].bits
, 3);
335 code
= huffSymb
>> 1;
338 mantissas
[cnt
] = code
;
341 for (cnt
= 0; cnt
< numCodes
; cnt
++) {
342 huffSymb
= get_vlc2(gb
, spectral_coeff_tab
[selector
-1].table
, spectral_coeff_tab
[selector
-1].bits
, 3);
343 mantissas
[cnt
*2] = decTable1
[huffSymb
*2];
344 mantissas
[cnt
*2+1] = decTable1
[huffSymb
*2+1];
351 * Restore the quantized band spectrum coefficients
353 * @param gb the GetBit context
354 * @param pOut decoded band spectrum
355 * @return outSubbands subband counter, fix for broken specification/files
358 static int decodeSpectrum (GetBitContext
*gb
, float *pOut
)
360 int numSubbands
, codingMode
, cnt
, first
, last
, subbWidth
, *pIn
;
361 int subband_vlc_index
[32], SF_idxs
[32];
365 numSubbands
= get_bits(gb
, 5); // number of coded subbands
366 codingMode
= get_bits1(gb
); // coding Mode: 0 - VLC/ 1-CLC
368 /* Get the VLC selector table for the subbands, 0 means not coded. */
369 for (cnt
= 0; cnt
<= numSubbands
; cnt
++)
370 subband_vlc_index
[cnt
] = get_bits(gb
, 3);
372 /* Read the scale factor indexes from the stream. */
373 for (cnt
= 0; cnt
<= numSubbands
; cnt
++) {
374 if (subband_vlc_index
[cnt
] != 0)
375 SF_idxs
[cnt
] = get_bits(gb
, 6);
378 for (cnt
= 0; cnt
<= numSubbands
; cnt
++) {
379 first
= subbandTab
[cnt
];
380 last
= subbandTab
[cnt
+1];
382 subbWidth
= last
- first
;
384 if (subband_vlc_index
[cnt
] != 0) {
385 /* Decode spectral coefficients for this subband. */
386 /* TODO: This can be done faster is several blocks share the
387 * same VLC selector (subband_vlc_index) */
388 readQuantSpectralCoeffs (gb
, subband_vlc_index
[cnt
], codingMode
, mantissas
, subbWidth
);
390 /* Decode the scale factor for this subband. */
391 SF
= SFTable
[SF_idxs
[cnt
]] * iMaxQuant
[subband_vlc_index
[cnt
]];
393 /* Inverse quantize the coefficients. */
394 for (pIn
=mantissas
; first
<last
; first
++, pIn
++)
395 pOut
[first
] = *pIn
* SF
;
397 /* This subband was not coded, so zero the entire subband. */
398 memset(pOut
+first
, 0, subbWidth
*sizeof(float));
402 /* Clear the subbands that were not coded. */
403 first
= subbandTab
[cnt
];
404 memset(pOut
+first
, 0, (1024 - first
) * sizeof(float));
409 * Restore the quantized tonal components
411 * @param gb the GetBit context
412 * @param pComponent tone component
413 * @param numBands amount of coded bands
416 static int decodeTonalComponents (GetBitContext
*gb
, tonal_component
*pComponent
, int numBands
)
419 int components
, coding_mode_selector
, coding_mode
, coded_values_per_component
;
420 int sfIndx
, coded_values
, max_coded_values
, quant_step_index
, coded_components
;
421 int band_flags
[4], mantissa
[8];
424 int component_count
= 0;
426 components
= get_bits(gb
,5);
428 /* no tonal components */
432 coding_mode_selector
= get_bits(gb
,2);
433 if (coding_mode_selector
== 2)
436 coding_mode
= coding_mode_selector
& 1;
438 for (i
= 0; i
< components
; i
++) {
439 for (cnt
= 0; cnt
<= numBands
; cnt
++)
440 band_flags
[cnt
] = get_bits1(gb
);
442 coded_values_per_component
= get_bits(gb
,3);
444 quant_step_index
= get_bits(gb
,3);
445 if (quant_step_index
<= 1)
448 if (coding_mode_selector
== 3)
449 coding_mode
= get_bits1(gb
);
451 for (j
= 0; j
< (numBands
+ 1) * 4; j
++) {
452 if (band_flags
[j
>> 2] == 0)
455 coded_components
= get_bits(gb
,3);
457 for (k
=0; k
<coded_components
; k
++) {
458 sfIndx
= get_bits(gb
,6);
459 pComponent
[component_count
].pos
= j
* 64 + (get_bits(gb
,6));
460 max_coded_values
= 1024 - pComponent
[component_count
].pos
;
461 coded_values
= coded_values_per_component
+ 1;
462 coded_values
= FFMIN(max_coded_values
,coded_values
);
464 scalefactor
= SFTable
[sfIndx
] * iMaxQuant
[quant_step_index
];
466 readQuantSpectralCoeffs(gb
, quant_step_index
, coding_mode
, mantissa
, coded_values
);
468 pComponent
[component_count
].numCoefs
= coded_values
;
471 pCoef
= pComponent
[k
].coef
;
472 for (cnt
= 0; cnt
< coded_values
; cnt
++)
473 pCoef
[cnt
] = mantissa
[cnt
] * scalefactor
;
480 return component_count
;
484 * Decode gain parameters for the coded bands
486 * @param gb the GetBit context
487 * @param pGb the gainblock for the current band
488 * @param numBands amount of coded bands
491 static int decodeGainControl (GetBitContext
*gb
, gain_block
*pGb
, int numBands
)
496 gain_info
*pGain
= pGb
->gBlock
;
498 for (i
=0 ; i
<=numBands
; i
++)
500 numData
= get_bits(gb
,3);
501 pGain
[i
].num_gain_data
= numData
;
502 pLevel
= pGain
[i
].levcode
;
503 pLoc
= pGain
[i
].loccode
;
505 for (cf
= 0; cf
< numData
; cf
++){
506 pLevel
[cf
]= get_bits(gb
,4);
507 pLoc
[cf
]= get_bits(gb
,5);
508 if(cf
&& pLoc
[cf
] <= pLoc
[cf
-1])
513 /* Clear the unused blocks. */
515 pGain
[i
].num_gain_data
= 0;
521 * Apply gain parameters and perform the MDCT overlapping part
523 * @param pIn input float buffer
524 * @param pPrev previous float buffer to perform overlap against
525 * @param pOut output float buffer
526 * @param pGain1 current band gain info
527 * @param pGain2 next band gain info
530 static void gainCompensateAndOverlap (float *pIn
, float *pPrev
, float *pOut
, gain_info
*pGain1
, gain_info
*pGain2
)
532 /* gain compensation function */
533 float gain1
, gain2
, gain_inc
;
534 int cnt
, numdata
, nsample
, startLoc
, endLoc
;
537 if (pGain2
->num_gain_data
== 0)
540 gain1
= gain_tab1
[pGain2
->levcode
[0]];
542 if (pGain1
->num_gain_data
== 0) {
543 for (cnt
= 0; cnt
< 256; cnt
++)
544 pOut
[cnt
] = pIn
[cnt
] * gain1
+ pPrev
[cnt
];
546 numdata
= pGain1
->num_gain_data
;
547 pGain1
->loccode
[numdata
] = 32;
548 pGain1
->levcode
[numdata
] = 4;
550 nsample
= 0; // current sample = 0
552 for (cnt
= 0; cnt
< numdata
; cnt
++) {
553 startLoc
= pGain1
->loccode
[cnt
] * 8;
554 endLoc
= startLoc
+ 8;
556 gain2
= gain_tab1
[pGain1
->levcode
[cnt
]];
557 gain_inc
= gain_tab2
[(pGain1
->levcode
[cnt
+1] - pGain1
->levcode
[cnt
])+15];
560 for (; nsample
< startLoc
; nsample
++)
561 pOut
[nsample
] = (pIn
[nsample
] * gain1
+ pPrev
[nsample
]) * gain2
;
563 /* interpolation is done over eight samples */
564 for (; nsample
< endLoc
; nsample
++) {
565 pOut
[nsample
] = (pIn
[nsample
] * gain1
+ pPrev
[nsample
]) * gain2
;
570 for (; nsample
< 256; nsample
++)
571 pOut
[nsample
] = (pIn
[nsample
] * gain1
) + pPrev
[nsample
];
574 /* Delay for the overlapping part. */
575 memcpy(pPrev
, &pIn
[256], 256*sizeof(float));
579 * Combine the tonal band spectrum and regular band spectrum
581 * @param pSpectrum output spectrum buffer
582 * @param numComponents amount of tonal components
583 * @param pComponent tonal components for this band
586 static void addTonalComponents (float *pSpectrum
, int numComponents
, tonal_component
*pComponent
)
591 for (cnt
= 0; cnt
< numComponents
; cnt
++){
592 pIn
= pComponent
[cnt
].coef
;
593 pOut
= &(pSpectrum
[pComponent
[cnt
].pos
]);
595 for (i
=0 ; i
<pComponent
[cnt
].numCoefs
; i
++)
601 #define INTERPOLATE(old,new,nsample) ((old) + (nsample)*0.125*((new)-(old)))
603 static void reverseMatrixing(float *su1
, float *su2
, int *pPrevCode
, int *pCurrCode
)
605 int i
, band
, nsample
, s1
, s2
;
607 float mc1_l
, mc1_r
, mc2_l
, mc2_r
;
609 for (i
=0,band
= 0; band
< 4*256; band
+=256,i
++) {
615 /* Selector value changed, interpolation needed. */
616 mc1_l
= matrixCoeffs
[s1
*2];
617 mc1_r
= matrixCoeffs
[s1
*2+1];
618 mc2_l
= matrixCoeffs
[s2
*2];
619 mc2_r
= matrixCoeffs
[s2
*2+1];
621 /* Interpolation is done over the first eight samples. */
622 for(; nsample
< 8; nsample
++) {
623 c1
= su1
[band
+nsample
];
624 c2
= su2
[band
+nsample
];
625 c2
= c1
* INTERPOLATE(mc1_l
,mc2_l
,nsample
) + c2
* INTERPOLATE(mc1_r
,mc2_r
,nsample
);
626 su1
[band
+nsample
] = c2
;
627 su2
[band
+nsample
] = c1
* 2.0 - c2
;
631 /* Apply the matrix without interpolation. */
633 case 0: /* M/S decoding */
634 for (; nsample
< 256; nsample
++) {
635 c1
= su1
[band
+nsample
];
636 c2
= su2
[band
+nsample
];
637 su1
[band
+nsample
] = c2
* 2.0;
638 su2
[band
+nsample
] = (c1
- c2
) * 2.0;
643 for (; nsample
< 256; nsample
++) {
644 c1
= su1
[band
+nsample
];
645 c2
= su2
[band
+nsample
];
646 su1
[band
+nsample
] = (c1
+ c2
) * 2.0;
647 su2
[band
+nsample
] = c2
* -2.0;
652 for (; nsample
< 256; nsample
++) {
653 c1
= su1
[band
+nsample
];
654 c2
= su2
[band
+nsample
];
655 su1
[band
+nsample
] = c1
+ c2
;
656 su2
[band
+nsample
] = c1
- c2
;
665 static void getChannelWeights (int indx
, int flag
, float ch
[2]){
671 ch
[0] = (float)(indx
& 7) / 7.0;
672 ch
[1] = sqrt(2 - ch
[0]*ch
[0]);
674 FFSWAP(float, ch
[0], ch
[1]);
678 static void channelWeighting (float *su1
, float *su2
, int *p3
)
681 /* w[x][y] y=0 is left y=1 is right */
684 if (p3
[1] != 7 || p3
[3] != 7){
685 getChannelWeights(p3
[1], p3
[0], w
[0]);
686 getChannelWeights(p3
[3], p3
[2], w
[1]);
688 for(band
= 1; band
< 4; band
++) {
689 /* scale the channels by the weights */
690 for(nsample
= 0; nsample
< 8; nsample
++) {
691 su1
[band
*256+nsample
] *= INTERPOLATE(w
[0][0], w
[0][1], nsample
);
692 su2
[band
*256+nsample
] *= INTERPOLATE(w
[1][0], w
[1][1], nsample
);
695 for(; nsample
< 256; nsample
++) {
696 su1
[band
*256+nsample
] *= w
[1][0];
697 su2
[band
*256+nsample
] *= w
[1][1];
705 * Decode a Sound Unit
707 * @param gb the GetBit context
708 * @param pSnd the channel unit to be used
709 * @param pOut the decoded samples before IQMF in float representation
710 * @param channelNum channel number
711 * @param codingMode the coding mode (JOINT_STEREO or regular stereo/mono)
715 static int decodeChannelSoundUnit (ATRAC3Context
*q
, GetBitContext
*gb
, channel_unit
*pSnd
, float *pOut
, int channelNum
, int codingMode
)
717 int band
, result
=0, numSubbands
, numBands
;
719 if (codingMode
== JOINT_STEREO
&& channelNum
== 1) {
720 if (get_bits(gb
,2) != 3) {
721 av_log(NULL
,AV_LOG_ERROR
,"JS mono Sound Unit id != 3.\n");
725 if (get_bits(gb
,6) != 0x28) {
726 av_log(NULL
,AV_LOG_ERROR
,"Sound Unit id != 0x28.\n");
731 /* number of coded QMF bands */
732 pSnd
->bandsCoded
= get_bits(gb
,2);
734 result
= decodeGainControl (gb
, &(pSnd
->gainBlock
[pSnd
->gcBlkSwitch
]), pSnd
->bandsCoded
);
735 if (result
) return result
;
737 pSnd
->numComponents
= decodeTonalComponents (gb
, pSnd
->components
, pSnd
->bandsCoded
);
738 if (pSnd
->numComponents
== -1) return -1;
740 numSubbands
= decodeSpectrum (gb
, pSnd
->spectrum
);
742 /* Merge the decoded spectrum and tonal components. */
743 addTonalComponents (pSnd
->spectrum
, pSnd
->numComponents
, pSnd
->components
);
746 /* Convert number of subbands into number of MLT/QMF bands */
747 numBands
= (subbandTab
[numSubbands
] - 1) >> 8;
750 /* Reconstruct time domain samples. */
751 for (band
=0; band
<4; band
++) {
752 /* Perform the IMDCT step without overlapping. */
753 if (band
<= numBands
) {
754 IMLT(&(pSnd
->spectrum
[band
*256]), pSnd
->IMDCT_buf
, band
&1,q
->mdct_tmp
);
756 memset(pSnd
->IMDCT_buf
, 0, 512 * sizeof(float));
758 /* gain compensation and overlapping */
759 gainCompensateAndOverlap (pSnd
->IMDCT_buf
, &(pSnd
->prevFrame
[band
*256]), &(pOut
[band
*256]),
760 &((pSnd
->gainBlock
[1 - (pSnd
->gcBlkSwitch
)]).gBlock
[band
]),
761 &((pSnd
->gainBlock
[pSnd
->gcBlkSwitch
]).gBlock
[band
]));
764 /* Swap the gain control buffers for the next frame. */
765 pSnd
->gcBlkSwitch
^= 1;
773 * @param q Atrac3 private context
774 * @param databuf the input data
777 static int decodeFrame(ATRAC3Context
*q
, uint8_t* databuf
)
780 float *p1
, *p2
, *p3
, *p4
;
781 uint8_t *ptr1
, *ptr2
;
783 if (q
->codingMode
== JOINT_STEREO
) {
785 /* channel coupling mode */
786 /* decode Sound Unit 1 */
787 init_get_bits(&q
->gb
,databuf
,q
->bits_per_frame
);
789 result
= decodeChannelSoundUnit(q
,&q
->gb
, q
->pUnits
, q
->outSamples
, 0, JOINT_STEREO
);
793 /* Framedata of the su2 in the joint-stereo mode is encoded in
794 * reverse byte order so we need to swap it first. */
796 ptr2
= databuf
+q
->bytes_per_frame
-1;
797 for (i
= 0; i
< (q
->bytes_per_frame
/2); i
++, ptr1
++, ptr2
--) {
798 FFSWAP(uint8_t,*ptr1
,*ptr2
);
801 /* Skip the sync codes (0xF8). */
803 for (i
= 4; *ptr1
== 0xF8; i
++, ptr1
++) {
804 if (i
>= q
->bytes_per_frame
)
809 /* set the bitstream reader at the start of the second Sound Unit*/
810 init_get_bits(&q
->gb
,ptr1
,q
->bits_per_frame
);
812 /* Fill the Weighting coeffs delay buffer */
813 memmove(q
->weighting_delay
,&(q
->weighting_delay
[2]),4*sizeof(int));
814 q
->weighting_delay
[4] = get_bits1(&q
->gb
);
815 q
->weighting_delay
[5] = get_bits(&q
->gb
,3);
817 for (i
= 0; i
< 4; i
++) {
818 q
->matrix_coeff_index_prev
[i
] = q
->matrix_coeff_index_now
[i
];
819 q
->matrix_coeff_index_now
[i
] = q
->matrix_coeff_index_next
[i
];
820 q
->matrix_coeff_index_next
[i
] = get_bits(&q
->gb
,2);
823 /* Decode Sound Unit 2. */
824 result
= decodeChannelSoundUnit(q
,&q
->gb
, &q
->pUnits
[1], &q
->outSamples
[1024], 1, JOINT_STEREO
);
828 /* Reconstruct the channel coefficients. */
829 reverseMatrixing(q
->outSamples
, &q
->outSamples
[1024], q
->matrix_coeff_index_prev
, q
->matrix_coeff_index_now
);
831 channelWeighting(q
->outSamples
, &q
->outSamples
[1024], q
->weighting_delay
);
834 /* normal stereo mode or mono */
835 /* Decode the channel sound units. */
836 for (i
=0 ; i
<q
->channels
; i
++) {
838 /* Set the bitstream reader at the start of a channel sound unit. */
839 init_get_bits(&q
->gb
, databuf
+((i
*q
->bytes_per_frame
)/q
->channels
), (q
->bits_per_frame
)/q
->channels
);
841 result
= decodeChannelSoundUnit(q
,&q
->gb
, &q
->pUnits
[i
], &q
->outSamples
[i
*1024], i
, q
->codingMode
);
847 /* Apply the iQMF synthesis filter. */
849 for (i
=0 ; i
<q
->channels
; i
++) {
853 iqmf (p1
, p2
, 256, p1
, q
->pUnits
[i
].delayBuf1
, q
->tempBuf
);
854 iqmf (p4
, p3
, 256, p3
, q
->pUnits
[i
].delayBuf2
, q
->tempBuf
);
855 iqmf (p1
, p3
, 512, p1
, q
->pUnits
[i
].delayBuf3
, q
->tempBuf
);
864 * Atrac frame decoding
866 * @param avctx pointer to the AVCodecContext
869 static int atrac3_decode_frame(AVCodecContext
*avctx
,
870 void *data
, int *data_size
,
871 uint8_t *buf
, int buf_size
) {
872 ATRAC3Context
*q
= avctx
->priv_data
;
875 int16_t* samples
= data
;
877 if (buf_size
< avctx
->block_align
)
880 /* Check if we need to descramble and what buffer to pass on. */
881 if (q
->scrambled_stream
) {
882 decode_bytes(buf
, q
->decoded_bytes_buffer
, avctx
->block_align
);
883 databuf
= q
->decoded_bytes_buffer
;
888 result
= decodeFrame(q
, databuf
);
891 av_log(NULL
,AV_LOG_ERROR
,"Frame decoding error!\n");
895 if (q
->channels
== 1) {
897 for (i
= 0; i
<1024; i
++)
898 samples
[i
] = av_clip_int16(round(q
->outSamples
[i
]));
899 *data_size
= 1024 * sizeof(int16_t);
902 for (i
= 0; i
< 1024; i
++) {
903 samples
[i
*2] = av_clip_int16(round(q
->outSamples
[i
]));
904 samples
[i
*2+1] = av_clip_int16(round(q
->outSamples
[1024+i
]));
906 *data_size
= 2048 * sizeof(int16_t);
909 return avctx
->block_align
;
914 * Atrac3 initialization
916 * @param avctx pointer to the AVCodecContext
919 static int atrac3_decode_init(AVCodecContext
*avctx
)
922 uint8_t *edata_ptr
= avctx
->extradata
;
923 ATRAC3Context
*q
= avctx
->priv_data
;
925 /* Take data from the AVCodecContext (RM container). */
926 q
->sample_rate
= avctx
->sample_rate
;
927 q
->channels
= avctx
->channels
;
928 q
->bit_rate
= avctx
->bit_rate
;
929 q
->bits_per_frame
= avctx
->block_align
* 8;
930 q
->bytes_per_frame
= avctx
->block_align
;
932 /* Take care of the codec-specific extradata. */
933 if (avctx
->extradata_size
== 14) {
934 /* Parse the extradata, WAV format */
935 av_log(avctx
,AV_LOG_DEBUG
,"[0-1] %d\n",bytestream_get_le16(&edata_ptr
)); //Unknown value always 1
936 q
->samples_per_channel
= bytestream_get_le32(&edata_ptr
);
937 q
->codingMode
= bytestream_get_le16(&edata_ptr
);
938 av_log(avctx
,AV_LOG_DEBUG
,"[8-9] %d\n",bytestream_get_le16(&edata_ptr
)); //Dupe of coding mode
939 q
->frame_factor
= bytestream_get_le16(&edata_ptr
); //Unknown always 1
940 av_log(avctx
,AV_LOG_DEBUG
,"[12-13] %d\n",bytestream_get_le16(&edata_ptr
)); //Unknown always 0
943 q
->samples_per_frame
= 1024 * q
->channels
;
944 q
->atrac3version
= 4;
947 q
->codingMode
= JOINT_STEREO
;
949 q
->codingMode
= STEREO
;
951 q
->scrambled_stream
= 0;
953 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
)) {
955 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
);
959 } else if (avctx
->extradata_size
== 10) {
960 /* Parse the extradata, RM format. */
961 q
->atrac3version
= bytestream_get_be32(&edata_ptr
);
962 q
->samples_per_frame
= bytestream_get_be16(&edata_ptr
);
963 q
->delay
= bytestream_get_be16(&edata_ptr
);
964 q
->codingMode
= bytestream_get_be16(&edata_ptr
);
966 q
->samples_per_channel
= q
->samples_per_frame
/ q
->channels
;
967 q
->scrambled_stream
= 1;
970 av_log(NULL
,AV_LOG_ERROR
,"Unknown extradata size %d.\n",avctx
->extradata_size
);
972 /* Check the extradata. */
974 if (q
->atrac3version
!= 4) {
975 av_log(avctx
,AV_LOG_ERROR
,"Version %d != 4.\n",q
->atrac3version
);
979 if (q
->samples_per_frame
!= 1024 && q
->samples_per_frame
!= 2048) {
980 av_log(avctx
,AV_LOG_ERROR
,"Unknown amount of samples per frame %d.\n",q
->samples_per_frame
);
984 if (q
->delay
!= 0x88E) {
985 av_log(avctx
,AV_LOG_ERROR
,"Unknown amount of delay %x != 0x88E.\n",q
->delay
);
989 if (q
->codingMode
== STEREO
) {
990 av_log(avctx
,AV_LOG_DEBUG
,"Normal stereo detected.\n");
991 } else if (q
->codingMode
== JOINT_STEREO
) {
992 av_log(avctx
,AV_LOG_DEBUG
,"Joint stereo detected.\n");
994 av_log(avctx
,AV_LOG_ERROR
,"Unknown channel coding mode %x!\n",q
->codingMode
);
998 if (avctx
->channels
<= 0 || avctx
->channels
> 2 /*|| ((avctx->channels * 1024) != q->samples_per_frame)*/) {
999 av_log(avctx
,AV_LOG_ERROR
,"Channel configuration error!\n");
1004 if(avctx
->block_align
>= UINT_MAX
/2)
1007 /* Pad the data buffer with FF_INPUT_BUFFER_PADDING_SIZE,
1008 * this is for the bitstream reader. */
1009 if ((q
->decoded_bytes_buffer
= av_mallocz((avctx
->block_align
+(4-avctx
->block_align
%4) + FF_INPUT_BUFFER_PADDING_SIZE
))) == NULL
)
1010 return AVERROR(ENOMEM
);
1013 /* Initialize the VLC tables. */
1014 for (i
=0 ; i
<7 ; i
++) {
1015 init_vlc (&spectral_coeff_tab
[i
], 9, huff_tab_sizes
[i
],
1017 huff_codes
[i
], 1, 1, INIT_VLC_USE_STATIC
);
1020 init_atrac3_transforms(q
);
1022 /* Generate the scale factors. */
1023 for (i
=0 ; i
<64 ; i
++)
1024 SFTable
[i
] = pow(2.0, (i
- 15) / 3.0);
1026 /* Generate gain tables. */
1027 for (i
=0 ; i
<16 ; i
++)
1028 gain_tab1
[i
] = powf (2.0, (4 - i
));
1030 for (i
=-15 ; i
<16 ; i
++)
1031 gain_tab2
[i
+15] = powf (2.0, i
* -0.125);
1033 /* init the joint-stereo decoding data */
1034 q
->weighting_delay
[0] = 0;
1035 q
->weighting_delay
[1] = 7;
1036 q
->weighting_delay
[2] = 0;
1037 q
->weighting_delay
[3] = 7;
1038 q
->weighting_delay
[4] = 0;
1039 q
->weighting_delay
[5] = 7;
1041 for (i
=0; i
<4; i
++) {
1042 q
->matrix_coeff_index_prev
[i
] = 3;
1043 q
->matrix_coeff_index_now
[i
] = 3;
1044 q
->matrix_coeff_index_next
[i
] = 3;
1047 dsputil_init(&dsp
, avctx
);
1049 q
->pUnits
= av_mallocz(sizeof(channel_unit
)*q
->channels
);
1051 av_free(q
->decoded_bytes_buffer
);
1052 return AVERROR(ENOMEM
);
1059 AVCodec atrac3_decoder
=
1062 .type
= CODEC_TYPE_AUDIO
,
1063 .id
= CODEC_ID_ATRAC3
,
1064 .priv_data_size
= sizeof(ATRAC3Context
),
1065 .init
= atrac3_decode_init
,
1066 .close
= atrac3_decode_close
,
1067 .decode
= atrac3_decode_frame
,