2 * COOK compatible decoder
3 * Copyright (c) 2003 Sascha Sommer
4 * Copyright (c) 2005 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 * Cook compatible decoder. Bastardization of the G.722.1 standard.
26 * This decoder handles RealNetworks, RealAudio G2 data.
27 * Cook is identified by the codec name cook in RM files.
29 * To use this decoder, a calling application must supply the extradata
30 * bytes provided from the RM container; 8+ bytes for mono streams and
31 * 16+ for stereo streams (maybe more).
33 * Codec technicalities (all this assume a buffer length of 1024):
34 * Cook works with several different techniques to achieve its compression.
35 * In the timedomain the buffer is divided into 8 pieces and quantized. If
36 * two neighboring pieces have different quantization index a smooth
37 * quantization curve is used to get a smooth overlap between the different
39 * To get to the transformdomain Cook uses a modulated lapped transform.
40 * The transform domain has 50 subbands with 20 elements each. This
41 * means only a maximum of 50*20=1000 coefficients are used out of the 1024
49 #include "libavutil/random.h"
51 #include "bitstream.h"
53 #include "bytestream.h"
57 /* the different Cook versions */
58 #define MONO 0x1000001
59 #define STEREO 0x1000002
60 #define JOINT_STEREO 0x1000003
61 #define MC_COOK 0x2000000 //multichannel Cook, not supported
63 #define SUBBAND_SIZE 20
73 * The following 5 functions provide the lowlevel arithmetic on
74 * the internal audio buffers.
76 void (* scalar_dequant
)(struct cook
*q
, int index
, int quant_index
,
77 int* subband_coef_index
, int* subband_coef_sign
,
80 void (* decouple
) (struct cook
*q
,
84 float *mlt_buffer1
, float *mlt_buffer2
);
86 void (* imlt_window
) (struct cook
*q
, float *buffer1
,
87 cook_gains
*gains_ptr
, float *previous_buffer
);
89 void (* interpolate
) (struct cook
*q
, float* buffer
,
90 int gain_index
, int gain_index_next
);
92 void (* saturate_output
) (struct cook
*q
, int chan
, int16_t *out
);
100 int samples_per_channel
;
101 int samples_per_frame
;
103 int log2_numvector_size
;
104 int numvector_size
; //1 << log2_numvector_size;
105 int js_subband_start
;
108 int bits_per_subpacket
;
111 AVRandomState random_state
;
114 MDCTContext mdct_ctx
;
115 DECLARE_ALIGNED_16(FFTSample
, mdct_tmp
[1024]); /* temporary storage for imlt */
128 VLC envelope_quant_index
[13];
129 VLC sqvh
[7]; //scalar quantization
130 VLC ccpl
; //channel coupling
132 /* generatable tables and related variables */
133 int gain_size_factor
;
134 float gain_table
[23];
136 float rootpow2tab
[127];
140 uint8_t* decoded_bytes_buffer
;
141 DECLARE_ALIGNED_16(float,mono_mdct_output
[2048]);
142 float mono_previous_buffer1
[1024];
143 float mono_previous_buffer2
[1024];
144 float decode_buffer_1
[1024];
145 float decode_buffer_2
[1024];
146 float decode_buffer_0
[1060]; /* static allocation for joint decode */
148 const float *cplscales
[5];
151 /* debug functions */
154 static void dump_float_table(float* table
, int size
, int delimiter
) {
156 av_log(NULL
,AV_LOG_ERROR
,"\n[%d]: ",i
);
157 for (i
=0 ; i
<size
; i
++) {
158 av_log(NULL
, AV_LOG_ERROR
, "%5.1f, ", table
[i
]);
159 if ((i
+1)%delimiter
== 0) av_log(NULL
,AV_LOG_ERROR
,"\n[%d]: ",i
+1);
163 static void dump_int_table(int* table
, int size
, int delimiter
) {
165 av_log(NULL
,AV_LOG_ERROR
,"\n[%d]: ",i
);
166 for (i
=0 ; i
<size
; i
++) {
167 av_log(NULL
, AV_LOG_ERROR
, "%d, ", table
[i
]);
168 if ((i
+1)%delimiter
== 0) av_log(NULL
,AV_LOG_ERROR
,"\n[%d]: ",i
+1);
172 static void dump_short_table(short* table
, int size
, int delimiter
) {
174 av_log(NULL
,AV_LOG_ERROR
,"\n[%d]: ",i
);
175 for (i
=0 ; i
<size
; i
++) {
176 av_log(NULL
, AV_LOG_ERROR
, "%d, ", table
[i
]);
177 if ((i
+1)%delimiter
== 0) av_log(NULL
,AV_LOG_ERROR
,"\n[%d]: ",i
+1);
183 /*************** init functions ***************/
185 /* table generator */
186 static void init_pow2table(COOKContext
*q
){
188 q
->pow2tab
[63] = 1.0;
189 for (i
=1 ; i
<64 ; i
++){
190 q
->pow2tab
[63+i
]=(float)((uint64_t)1<<i
);
191 q
->pow2tab
[63-i
]=1.0/(float)((uint64_t)1<<i
);
195 /* table generator */
196 static void init_rootpow2table(COOKContext
*q
){
198 q
->rootpow2tab
[63] = 1.0;
199 for (i
=1 ; i
<64 ; i
++){
200 q
->rootpow2tab
[63+i
]=sqrt((float)((uint64_t)1<<i
));
201 q
->rootpow2tab
[63-i
]=sqrt(1.0/(float)((uint64_t)1<<i
));
205 /* table generator */
206 static void init_gain_table(COOKContext
*q
) {
208 q
->gain_size_factor
= q
->samples_per_channel
/8;
209 for (i
=0 ; i
<23 ; i
++) {
210 q
->gain_table
[i
] = pow((double)q
->pow2tab
[i
+52] ,
211 (1.0/(double)q
->gain_size_factor
));
216 static int init_cook_vlc_tables(COOKContext
*q
) {
220 for (i
=0 ; i
<13 ; i
++) {
221 result
|= init_vlc (&q
->envelope_quant_index
[i
], 9, 24,
222 envelope_quant_index_huffbits
[i
], 1, 1,
223 envelope_quant_index_huffcodes
[i
], 2, 2, 0);
225 av_log(NULL
,AV_LOG_DEBUG
,"sqvh VLC init\n");
226 for (i
=0 ; i
<7 ; i
++) {
227 result
|= init_vlc (&q
->sqvh
[i
], vhvlcsize_tab
[i
], vhsize_tab
[i
],
228 cvh_huffbits
[i
], 1, 1,
229 cvh_huffcodes
[i
], 2, 2, 0);
232 if (q
->nb_channels
==2 && q
->joint_stereo
==1){
233 result
|= init_vlc (&q
->ccpl
, 6, (1<<q
->js_vlc_bits
)-1,
234 ccpl_huffbits
[q
->js_vlc_bits
-2], 1, 1,
235 ccpl_huffcodes
[q
->js_vlc_bits
-2], 2, 2, 0);
236 av_log(NULL
,AV_LOG_DEBUG
,"Joint-stereo VLC used.\n");
239 av_log(NULL
,AV_LOG_DEBUG
,"VLC tables initialized.\n");
243 static int init_cook_mlt(COOKContext
*q
) {
246 int mlt_size
= q
->samples_per_channel
;
248 if ((q
->mlt_window
= av_malloc(sizeof(float)*mlt_size
)) == 0)
251 /* Initialize the MLT window: simple sine window. */
252 alpha
= M_PI
/ (2.0 * (float)mlt_size
);
253 for(j
=0 ; j
<mlt_size
; j
++)
254 q
->mlt_window
[j
] = sin((j
+ 0.5) * alpha
) * sqrt(2.0 / q
->samples_per_channel
);
256 /* Initialize the MDCT. */
257 if (ff_mdct_init(&q
->mdct_ctx
, av_log2(mlt_size
)+1, 1)) {
258 av_free(q
->mlt_window
);
261 av_log(NULL
,AV_LOG_DEBUG
,"MDCT initialized, order = %d.\n",
262 av_log2(mlt_size
)+1);
267 static const float *maybe_reformat_buffer32 (COOKContext
*q
, const float *ptr
, int n
)
273 static void init_cplscales_table (COOKContext
*q
) {
276 q
->cplscales
[i
] = maybe_reformat_buffer32 (q
, cplscales
[i
], (1<<(i
+2))-1);
279 /*************** init functions end ***********/
282 * Cook indata decoding, every 32 bits are XORed with 0x37c511f2.
283 * Why? No idea, some checksum/error detection method maybe.
285 * Out buffer size: extra bytes are needed to cope with
286 * padding/misalignment.
287 * Subpackets passed to the decoder can contain two, consecutive
288 * half-subpackets, of identical but arbitrary size.
289 * 1234 1234 1234 1234 extraA extraB
290 * Case 1: AAAA BBBB 0 0
291 * Case 2: AAAA ABBB BB-- 3 3
292 * Case 3: AAAA AABB BBBB 2 2
293 * Case 4: AAAA AAAB BBBB BB-- 1 5
295 * Nice way to waste CPU cycles.
297 * @param inbuffer pointer to byte array of indata
298 * @param out pointer to byte array of outdata
299 * @param bytes number of bytes
301 #define DECODE_BYTES_PAD1(bytes) (3 - ((bytes)+3) % 4)
302 #define DECODE_BYTES_PAD2(bytes) ((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes)))
304 static inline int decode_bytes(const uint8_t* inbuffer
, uint8_t* out
, int bytes
){
308 uint32_t* obuf
= (uint32_t*) out
;
309 /* FIXME: 64 bit platforms would be able to do 64 bits at a time.
310 * I'm too lazy though, should be something like
311 * for(i=0 ; i<bitamount/64 ; i++)
312 * (int64_t)out[i] = 0x37c511f237c511f2^be2me_64(int64_t)in[i]);
313 * Buffer alignment needs to be checked. */
315 off
= (int)((long)inbuffer
& 3);
316 buf
= (const uint32_t*) (inbuffer
- off
);
317 c
= be2me_32((0x37c511f2 >> (off
*8)) | (0x37c511f2 << (32-(off
*8))));
319 for (i
= 0; i
< bytes
/4; i
++)
320 obuf
[i
] = c
^ buf
[i
];
329 static int cook_decode_close(AVCodecContext
*avctx
)
332 COOKContext
*q
= avctx
->priv_data
;
333 av_log(avctx
,AV_LOG_DEBUG
, "Deallocating memory.\n");
335 /* Free allocated memory buffers. */
336 av_free(q
->mlt_window
);
337 av_free(q
->decoded_bytes_buffer
);
339 /* Free the transform. */
340 ff_mdct_end(&q
->mdct_ctx
);
342 /* Free the VLC tables. */
343 for (i
=0 ; i
<13 ; i
++) {
344 free_vlc(&q
->envelope_quant_index
[i
]);
346 for (i
=0 ; i
<7 ; i
++) {
347 free_vlc(&q
->sqvh
[i
]);
349 if(q
->nb_channels
==2 && q
->joint_stereo
==1 ){
353 av_log(NULL
,AV_LOG_DEBUG
,"Memory deallocated.\n");
359 * Fill the gain array for the timedomain quantization.
361 * @param q pointer to the COOKContext
362 * @param gaininfo[9] array of gain indices
365 static void decode_gain_info(GetBitContext
*gb
, int *gaininfo
)
369 while (get_bits1(gb
)) {}
370 n
= get_bits_count(gb
) - 1; //amount of elements*2 to update
374 int index
= get_bits(gb
, 3);
375 int gain
= get_bits1(gb
) ? get_bits(gb
, 4) - 7 : -1;
377 while (i
<= index
) gaininfo
[i
++] = gain
;
379 while (i
<= 8) gaininfo
[i
++] = 0;
383 * Create the quant index table needed for the envelope.
385 * @param q pointer to the COOKContext
386 * @param quant_index_table pointer to the array
389 static void decode_envelope(COOKContext
*q
, int* quant_index_table
) {
392 quant_index_table
[0]= get_bits(&q
->gb
,6) - 6; //This is used later in categorize
394 for (i
=1 ; i
< q
->total_subbands
; i
++){
396 if (i
>= q
->js_subband_start
* 2) {
397 vlc_index
-=q
->js_subband_start
;
400 if(vlc_index
< 1) vlc_index
= 1;
402 if (vlc_index
>13) vlc_index
= 13; //the VLC tables >13 are identical to No. 13
404 j
= get_vlc2(&q
->gb
, q
->envelope_quant_index
[vlc_index
-1].table
,
405 q
->envelope_quant_index
[vlc_index
-1].bits
,2);
406 quant_index_table
[i
] = quant_index_table
[i
-1] + j
- 12; //differential encoding
411 * Calculate the category and category_index vector.
413 * @param q pointer to the COOKContext
414 * @param quant_index_table pointer to the array
415 * @param category pointer to the category array
416 * @param category_index pointer to the category_index array
419 static void categorize(COOKContext
*q
, int* quant_index_table
,
420 int* category
, int* category_index
){
421 int exp_idx
, bias
, tmpbias1
, tmpbias2
, bits_left
, num_bits
, index
, v
, i
, j
;
425 int tmp_categorize_array
[128*2];
426 int tmp_categorize_array1_idx
=q
->numvector_size
;
427 int tmp_categorize_array2_idx
=q
->numvector_size
;
429 bits_left
= q
->bits_per_subpacket
- get_bits_count(&q
->gb
);
431 if(bits_left
> q
->samples_per_channel
) {
432 bits_left
= q
->samples_per_channel
+
433 ((bits_left
- q
->samples_per_channel
)*5)/8;
434 //av_log(NULL, AV_LOG_ERROR, "bits_left = %d\n",bits_left);
437 memset(&exp_index1
,0,102*sizeof(int));
438 memset(&exp_index2
,0,102*sizeof(int));
439 memset(&tmp_categorize_array
,0,128*2*sizeof(int));
444 for (i
=32 ; i
>0 ; i
=i
/2){
447 for (j
=q
->total_subbands
; j
>0 ; j
--){
448 exp_idx
= av_clip((i
- quant_index_table
[index
] + bias
) / 2, 0, 7);
450 num_bits
+=expbits_tab
[exp_idx
];
452 if(num_bits
>= bits_left
- 32){
457 /* Calculate total number of bits. */
459 for (i
=0 ; i
<q
->total_subbands
; i
++) {
460 exp_idx
= av_clip((bias
- quant_index_table
[i
]) / 2, 0, 7);
461 num_bits
+= expbits_tab
[exp_idx
];
462 exp_index1
[i
] = exp_idx
;
463 exp_index2
[i
] = exp_idx
;
465 tmpbias1
= tmpbias2
= num_bits
;
467 for (j
= 1 ; j
< q
->numvector_size
; j
++) {
468 if (tmpbias1
+ tmpbias2
> 2*bits_left
) { /* ---> */
471 for (i
=0 ; i
<q
->total_subbands
; i
++){
472 if (exp_index1
[i
] < 7) {
473 v
= (-2*exp_index1
[i
]) - quant_index_table
[i
] + bias
;
481 tmp_categorize_array
[tmp_categorize_array1_idx
++] = index
;
482 tmpbias1
-= expbits_tab
[exp_index1
[index
]] -
483 expbits_tab
[exp_index1
[index
]+1];
488 for (i
=0 ; i
<q
->total_subbands
; i
++){
489 if(exp_index2
[i
] > 0){
490 v
= (-2*exp_index2
[i
])-quant_index_table
[i
]+bias
;
497 if(index
== -1)break;
498 tmp_categorize_array
[--tmp_categorize_array2_idx
] = index
;
499 tmpbias2
-= expbits_tab
[exp_index2
[index
]] -
500 expbits_tab
[exp_index2
[index
]-1];
505 for(i
=0 ; i
<q
->total_subbands
; i
++)
506 category
[i
] = exp_index2
[i
];
508 for(i
=0 ; i
<q
->numvector_size
-1 ; i
++)
509 category_index
[i
] = tmp_categorize_array
[tmp_categorize_array2_idx
++];
515 * Expand the category vector.
517 * @param q pointer to the COOKContext
518 * @param category pointer to the category array
519 * @param category_index pointer to the category_index array
522 static inline void expand_category(COOKContext
*q
, int* category
,
523 int* category_index
){
525 for(i
=0 ; i
<q
->num_vectors
; i
++){
526 ++category
[category_index
[i
]];
531 * The real requantization of the mltcoefs
533 * @param q pointer to the COOKContext
535 * @param quant_index quantisation index
536 * @param subband_coef_index array of indexes to quant_centroid_tab
537 * @param subband_coef_sign signs of coefficients
538 * @param mlt_p pointer into the mlt buffer
541 static void scalar_dequant_float(COOKContext
*q
, int index
, int quant_index
,
542 int* subband_coef_index
, int* subband_coef_sign
,
547 for(i
=0 ; i
<SUBBAND_SIZE
; i
++) {
548 if (subband_coef_index
[i
]) {
549 f1
= quant_centroid_tab
[index
][subband_coef_index
[i
]];
550 if (subband_coef_sign
[i
]) f1
= -f1
;
552 /* noise coding if subband_coef_index[i] == 0 */
553 f1
= dither_tab
[index
];
554 if (av_random(&q
->random_state
) < 0x80000000) f1
= -f1
;
556 mlt_p
[i
] = f1
* q
->rootpow2tab
[quant_index
+63];
560 * Unpack the subband_coef_index and subband_coef_sign vectors.
562 * @param q pointer to the COOKContext
563 * @param category pointer to the category array
564 * @param subband_coef_index array of indexes to quant_centroid_tab
565 * @param subband_coef_sign signs of coefficients
568 static int unpack_SQVH(COOKContext
*q
, int category
, int* subband_coef_index
,
569 int* subband_coef_sign
) {
571 int vlc
, vd
,tmp
, result
;
573 vd
= vd_tab
[category
];
575 for(i
=0 ; i
<vpr_tab
[category
] ; i
++){
576 vlc
= get_vlc2(&q
->gb
, q
->sqvh
[category
].table
, q
->sqvh
[category
].bits
, 3);
577 if (q
->bits_per_subpacket
< get_bits_count(&q
->gb
)){
581 for(j
=vd
-1 ; j
>=0 ; j
--){
582 tmp
= (vlc
* invradix_tab
[category
])/0x100000;
583 subband_coef_index
[vd
*i
+j
] = vlc
- tmp
* (kmax_tab
[category
]+1);
586 for(j
=0 ; j
<vd
; j
++){
587 if (subband_coef_index
[i
*vd
+ j
]) {
588 if(get_bits_count(&q
->gb
) < q
->bits_per_subpacket
){
589 subband_coef_sign
[i
*vd
+j
] = get_bits1(&q
->gb
);
592 subband_coef_sign
[i
*vd
+j
]=0;
595 subband_coef_sign
[i
*vd
+j
]=0;
604 * Fill the mlt_buffer with mlt coefficients.
606 * @param q pointer to the COOKContext
607 * @param category pointer to the category array
608 * @param quant_index_table pointer to the array
609 * @param mlt_buffer pointer to mlt coefficients
613 static void decode_vectors(COOKContext
* q
, int* category
,
614 int *quant_index_table
, float* mlt_buffer
){
615 /* A zero in this table means that the subband coefficient is
616 random noise coded. */
617 int subband_coef_index
[SUBBAND_SIZE
];
618 /* A zero in this table means that the subband coefficient is a
619 positive multiplicator. */
620 int subband_coef_sign
[SUBBAND_SIZE
];
624 for(band
=0 ; band
<q
->total_subbands
; band
++){
625 index
= category
[band
];
626 if(category
[band
] < 7){
627 if(unpack_SQVH(q
, category
[band
], subband_coef_index
, subband_coef_sign
)){
629 for(j
=0 ; j
<q
->total_subbands
; j
++) category
[band
+j
]=7;
633 memset(subband_coef_index
, 0, sizeof(subband_coef_index
));
634 memset(subband_coef_sign
, 0, sizeof(subband_coef_sign
));
636 q
->scalar_dequant(q
, index
, quant_index_table
[band
],
637 subband_coef_index
, subband_coef_sign
,
638 &mlt_buffer
[band
* SUBBAND_SIZE
]);
641 if(q
->total_subbands
*SUBBAND_SIZE
>= q
->samples_per_channel
){
643 } /* FIXME: should this be removed, or moved into loop above? */
648 * function for decoding mono data
650 * @param q pointer to the COOKContext
651 * @param mlt_buffer pointer to mlt coefficients
654 static void mono_decode(COOKContext
*q
, float* mlt_buffer
) {
656 int category_index
[128];
657 int quant_index_table
[102];
660 memset(&category
, 0, 128*sizeof(int));
661 memset(&category_index
, 0, 128*sizeof(int));
663 decode_envelope(q
, quant_index_table
);
664 q
->num_vectors
= get_bits(&q
->gb
,q
->log2_numvector_size
);
665 categorize(q
, quant_index_table
, category
, category_index
);
666 expand_category(q
, category
, category_index
);
667 decode_vectors(q
, category
, quant_index_table
, mlt_buffer
);
672 * the actual requantization of the timedomain samples
674 * @param q pointer to the COOKContext
675 * @param buffer pointer to the timedomain buffer
676 * @param gain_index index for the block multiplier
677 * @param gain_index_next index for the next block multiplier
680 static void interpolate_float(COOKContext
*q
, float* buffer
,
681 int gain_index
, int gain_index_next
){
684 fc1
= q
->pow2tab
[gain_index
+63];
686 if(gain_index
== gain_index_next
){ //static gain
687 for(i
=0 ; i
<q
->gain_size_factor
; i
++){
691 } else { //smooth gain
692 fc2
= q
->gain_table
[11 + (gain_index_next
-gain_index
)];
693 for(i
=0 ; i
<q
->gain_size_factor
; i
++){
702 * Apply transform window, overlap buffers.
704 * @param q pointer to the COOKContext
705 * @param inbuffer pointer to the mltcoefficients
706 * @param gains_ptr current and previous gains
707 * @param previous_buffer pointer to the previous buffer to be used for overlapping
710 static void imlt_window_float (COOKContext
*q
, float *buffer1
,
711 cook_gains
*gains_ptr
, float *previous_buffer
)
713 const float fc
= q
->pow2tab
[gains_ptr
->previous
[0] + 63];
715 /* The weird thing here, is that the two halves of the time domain
716 * buffer are swapped. Also, the newest data, that we save away for
717 * next frame, has the wrong sign. Hence the subtraction below.
718 * Almost sounds like a complex conjugate/reverse data/FFT effect.
721 /* Apply window and overlap */
722 for(i
= 0; i
< q
->samples_per_channel
; i
++){
723 buffer1
[i
] = buffer1
[i
] * fc
* q
->mlt_window
[i
] -
724 previous_buffer
[i
] * q
->mlt_window
[q
->samples_per_channel
- 1 - i
];
729 * The modulated lapped transform, this takes transform coefficients
730 * and transforms them into timedomain samples.
731 * Apply transform window, overlap buffers, apply gain profile
732 * and buffer management.
734 * @param q pointer to the COOKContext
735 * @param inbuffer pointer to the mltcoefficients
736 * @param gains_ptr current and previous gains
737 * @param previous_buffer pointer to the previous buffer to be used for overlapping
740 static void imlt_gain(COOKContext
*q
, float *inbuffer
,
741 cook_gains
*gains_ptr
, float* previous_buffer
)
743 float *buffer0
= q
->mono_mdct_output
;
744 float *buffer1
= q
->mono_mdct_output
+ q
->samples_per_channel
;
747 /* Inverse modified discrete cosine transform */
748 q
->mdct_ctx
.fft
.imdct_calc(&q
->mdct_ctx
, q
->mono_mdct_output
,
749 inbuffer
, q
->mdct_tmp
);
751 q
->imlt_window (q
, buffer1
, gains_ptr
, previous_buffer
);
753 /* Apply gain profile */
754 for (i
= 0; i
< 8; i
++) {
755 if (gains_ptr
->now
[i
] || gains_ptr
->now
[i
+ 1])
756 q
->interpolate(q
, &buffer1
[q
->gain_size_factor
* i
],
757 gains_ptr
->now
[i
], gains_ptr
->now
[i
+ 1]);
760 /* Save away the current to be previous block. */
761 memcpy(previous_buffer
, buffer0
, sizeof(float)*q
->samples_per_channel
);
766 * function for getting the jointstereo coupling information
768 * @param q pointer to the COOKContext
769 * @param decouple_tab decoupling array
773 static void decouple_info(COOKContext
*q
, int* decouple_tab
){
776 if(get_bits1(&q
->gb
)) {
777 if(cplband
[q
->js_subband_start
] > cplband
[q
->subbands
-1]) return;
779 length
= cplband
[q
->subbands
-1] - cplband
[q
->js_subband_start
] + 1;
780 for (i
=0 ; i
<length
; i
++) {
781 decouple_tab
[cplband
[q
->js_subband_start
] + i
] = get_vlc2(&q
->gb
, q
->ccpl
.table
, q
->ccpl
.bits
, 2);
786 if(cplband
[q
->js_subband_start
] > cplband
[q
->subbands
-1]) return;
788 length
= cplband
[q
->subbands
-1] - cplband
[q
->js_subband_start
] + 1;
789 for (i
=0 ; i
<length
; i
++) {
790 decouple_tab
[cplband
[q
->js_subband_start
] + i
] = get_bits(&q
->gb
, q
->js_vlc_bits
);
796 * function decouples a pair of signals from a single signal via multiplication.
798 * @param q pointer to the COOKContext
799 * @param subband index of the current subband
800 * @param f1 multiplier for channel 1 extraction
801 * @param f2 multiplier for channel 2 extraction
802 * @param decode_buffer input buffer
803 * @param mlt_buffer1 pointer to left channel mlt coefficients
804 * @param mlt_buffer2 pointer to right channel mlt coefficients
806 static void decouple_float (COOKContext
*q
,
809 float *decode_buffer
,
810 float *mlt_buffer1
, float *mlt_buffer2
)
813 for (j
=0 ; j
<SUBBAND_SIZE
; j
++) {
814 tmp_idx
= ((q
->js_subband_start
+ subband
)*SUBBAND_SIZE
)+j
;
815 mlt_buffer1
[SUBBAND_SIZE
*subband
+ j
] = f1
* decode_buffer
[tmp_idx
];
816 mlt_buffer2
[SUBBAND_SIZE
*subband
+ j
] = f2
* decode_buffer
[tmp_idx
];
821 * function for decoding joint stereo data
823 * @param q pointer to the COOKContext
824 * @param mlt_buffer1 pointer to left channel mlt coefficients
825 * @param mlt_buffer2 pointer to right channel mlt coefficients
828 static void joint_decode(COOKContext
*q
, float* mlt_buffer1
,
829 float* mlt_buffer2
) {
831 int decouple_tab
[SUBBAND_SIZE
];
832 float *decode_buffer
= q
->decode_buffer_0
;
835 const float* cplscale
;
837 memset(decouple_tab
, 0, sizeof(decouple_tab
));
838 memset(decode_buffer
, 0, sizeof(decode_buffer
));
840 /* Make sure the buffers are zeroed out. */
841 memset(mlt_buffer1
,0, 1024*sizeof(float));
842 memset(mlt_buffer2
,0, 1024*sizeof(float));
843 decouple_info(q
, decouple_tab
);
844 mono_decode(q
, decode_buffer
);
846 /* The two channels are stored interleaved in decode_buffer. */
847 for (i
=0 ; i
<q
->js_subband_start
; i
++) {
848 for (j
=0 ; j
<SUBBAND_SIZE
; j
++) {
849 mlt_buffer1
[i
*20+j
] = decode_buffer
[i
*40+j
];
850 mlt_buffer2
[i
*20+j
] = decode_buffer
[i
*40+20+j
];
854 /* When we reach js_subband_start (the higher frequencies)
855 the coefficients are stored in a coupling scheme. */
856 idx
= (1 << q
->js_vlc_bits
) - 1;
857 for (i
=q
->js_subband_start
; i
<q
->subbands
; i
++) {
858 cpl_tmp
= cplband
[i
];
859 idx
-=decouple_tab
[cpl_tmp
];
860 cplscale
= q
->cplscales
[q
->js_vlc_bits
-2]; //choose decoupler table
861 f1
= cplscale
[decouple_tab
[cpl_tmp
]];
862 f2
= cplscale
[idx
-1];
863 q
->decouple (q
, i
, f1
, f2
, decode_buffer
, mlt_buffer1
, mlt_buffer2
);
864 idx
= (1 << q
->js_vlc_bits
) - 1;
869 * First part of subpacket decoding:
870 * decode raw stream bytes and read gain info.
872 * @param q pointer to the COOKContext
873 * @param inbuffer pointer to raw stream data
874 * @param gain_ptr array of current/prev gain pointers
878 decode_bytes_and_gain(COOKContext
*q
, const uint8_t *inbuffer
,
879 cook_gains
*gains_ptr
)
883 offset
= decode_bytes(inbuffer
, q
->decoded_bytes_buffer
,
884 q
->bits_per_subpacket
/8);
885 init_get_bits(&q
->gb
, q
->decoded_bytes_buffer
+ offset
,
886 q
->bits_per_subpacket
);
887 decode_gain_info(&q
->gb
, gains_ptr
->now
);
889 /* Swap current and previous gains */
890 FFSWAP(int *, gains_ptr
->now
, gains_ptr
->previous
);
894 * Saturate the output signal to signed 16bit integers.
896 * @param q pointer to the COOKContext
897 * @param chan channel to saturate
898 * @param out pointer to the output vector
901 saturate_output_float (COOKContext
*q
, int chan
, int16_t *out
)
904 float *output
= q
->mono_mdct_output
+ q
->samples_per_channel
;
905 /* Clip and convert floats to 16 bits.
907 for (j
= 0; j
< q
->samples_per_channel
; j
++) {
908 out
[chan
+ q
->nb_channels
* j
] =
909 av_clip_int16(lrintf(output
[j
]));
914 * Final part of subpacket decoding:
915 * Apply modulated lapped transform, gain compensation,
916 * clip and convert to integer.
918 * @param q pointer to the COOKContext
919 * @param decode_buffer pointer to the mlt coefficients
920 * @param gain_ptr array of current/prev gain pointers
921 * @param previous_buffer pointer to the previous buffer to be used for overlapping
922 * @param out pointer to the output buffer
923 * @param chan 0: left or single channel, 1: right channel
927 mlt_compensate_output(COOKContext
*q
, float *decode_buffer
,
928 cook_gains
*gains
, float *previous_buffer
,
929 int16_t *out
, int chan
)
931 imlt_gain(q
, decode_buffer
, gains
, previous_buffer
);
932 q
->saturate_output (q
, chan
, out
);
937 * Cook subpacket decoding. This function returns one decoded subpacket,
938 * usually 1024 samples per channel.
940 * @param q pointer to the COOKContext
941 * @param inbuffer pointer to the inbuffer
942 * @param sub_packet_size subpacket size
943 * @param outbuffer pointer to the outbuffer
947 static int decode_subpacket(COOKContext
*q
, const uint8_t *inbuffer
,
948 int sub_packet_size
, int16_t *outbuffer
) {
950 // for (i=0 ; i<sub_packet_size ; i++) {
951 // av_log(NULL, AV_LOG_ERROR, "%02x", inbuffer[i]);
953 // av_log(NULL, AV_LOG_ERROR, "\n");
955 decode_bytes_and_gain(q
, inbuffer
, &q
->gains1
);
957 if (q
->joint_stereo
) {
958 joint_decode(q
, q
->decode_buffer_1
, q
->decode_buffer_2
);
960 mono_decode(q
, q
->decode_buffer_1
);
962 if (q
->nb_channels
== 2) {
963 decode_bytes_and_gain(q
, inbuffer
+ sub_packet_size
/2, &q
->gains2
);
964 mono_decode(q
, q
->decode_buffer_2
);
968 mlt_compensate_output(q
, q
->decode_buffer_1
, &q
->gains1
,
969 q
->mono_previous_buffer1
, outbuffer
, 0);
971 if (q
->nb_channels
== 2) {
972 if (q
->joint_stereo
) {
973 mlt_compensate_output(q
, q
->decode_buffer_2
, &q
->gains1
,
974 q
->mono_previous_buffer2
, outbuffer
, 1);
976 mlt_compensate_output(q
, q
->decode_buffer_2
, &q
->gains2
,
977 q
->mono_previous_buffer2
, outbuffer
, 1);
980 return q
->samples_per_frame
* sizeof(int16_t);
985 * Cook frame decoding
987 * @param avctx pointer to the AVCodecContext
990 static int cook_decode_frame(AVCodecContext
*avctx
,
991 void *data
, int *data_size
,
992 const uint8_t *buf
, int buf_size
) {
993 COOKContext
*q
= avctx
->priv_data
;
995 if (buf_size
< avctx
->block_align
)
998 *data_size
= decode_subpacket(q
, buf
, avctx
->block_align
, data
);
1000 /* Discard the first two frames: no valid audio. */
1001 if (avctx
->frame_number
< 2) *data_size
= 0;
1003 return avctx
->block_align
;
1007 static void dump_cook_context(COOKContext
*q
)
1010 #define PRINT(a,b) av_log(NULL,AV_LOG_ERROR," %s = %d\n", a, b);
1011 av_log(NULL
,AV_LOG_ERROR
,"COOKextradata\n");
1012 av_log(NULL
,AV_LOG_ERROR
,"cookversion=%x\n",q
->cookversion
);
1013 if (q
->cookversion
> STEREO
) {
1014 PRINT("js_subband_start",q
->js_subband_start
);
1015 PRINT("js_vlc_bits",q
->js_vlc_bits
);
1017 av_log(NULL
,AV_LOG_ERROR
,"COOKContext\n");
1018 PRINT("nb_channels",q
->nb_channels
);
1019 PRINT("bit_rate",q
->bit_rate
);
1020 PRINT("sample_rate",q
->sample_rate
);
1021 PRINT("samples_per_channel",q
->samples_per_channel
);
1022 PRINT("samples_per_frame",q
->samples_per_frame
);
1023 PRINT("subbands",q
->subbands
);
1024 PRINT("random_state",q
->random_state
);
1025 PRINT("js_subband_start",q
->js_subband_start
);
1026 PRINT("log2_numvector_size",q
->log2_numvector_size
);
1027 PRINT("numvector_size",q
->numvector_size
);
1028 PRINT("total_subbands",q
->total_subbands
);
1033 * Cook initialization
1035 * @param avctx pointer to the AVCodecContext
1038 static int cook_decode_init(AVCodecContext
*avctx
)
1040 COOKContext
*q
= avctx
->priv_data
;
1041 const uint8_t *edata_ptr
= avctx
->extradata
;
1043 /* Take care of the codec specific extradata. */
1044 if (avctx
->extradata_size
<= 0) {
1045 av_log(avctx
,AV_LOG_ERROR
,"Necessary extradata missing!\n");
1048 /* 8 for mono, 16 for stereo, ? for multichannel
1049 Swap to right endianness so we don't need to care later on. */
1050 av_log(avctx
,AV_LOG_DEBUG
,"codecdata_length=%d\n",avctx
->extradata_size
);
1051 if (avctx
->extradata_size
>= 8){
1052 q
->cookversion
= bytestream_get_be32(&edata_ptr
);
1053 q
->samples_per_frame
= bytestream_get_be16(&edata_ptr
);
1054 q
->subbands
= bytestream_get_be16(&edata_ptr
);
1056 if (avctx
->extradata_size
>= 16){
1057 bytestream_get_be32(&edata_ptr
); //Unknown unused
1058 q
->js_subband_start
= bytestream_get_be16(&edata_ptr
);
1059 q
->js_vlc_bits
= bytestream_get_be16(&edata_ptr
);
1063 /* Take data from the AVCodecContext (RM container). */
1064 q
->sample_rate
= avctx
->sample_rate
;
1065 q
->nb_channels
= avctx
->channels
;
1066 q
->bit_rate
= avctx
->bit_rate
;
1068 /* Initialize RNG. */
1069 av_init_random(1, &q
->random_state
);
1071 /* Initialize extradata related variables. */
1072 q
->samples_per_channel
= q
->samples_per_frame
/ q
->nb_channels
;
1073 q
->bits_per_subpacket
= avctx
->block_align
* 8;
1075 /* Initialize default data states. */
1076 q
->log2_numvector_size
= 5;
1077 q
->total_subbands
= q
->subbands
;
1079 /* Initialize version-dependent variables */
1080 av_log(NULL
,AV_LOG_DEBUG
,"q->cookversion=%x\n",q
->cookversion
);
1081 q
->joint_stereo
= 0;
1082 switch (q
->cookversion
) {
1084 if (q
->nb_channels
!= 1) {
1085 av_log(avctx
,AV_LOG_ERROR
,"Container channels != 1, report sample!\n");
1088 av_log(avctx
,AV_LOG_DEBUG
,"MONO\n");
1091 if (q
->nb_channels
!= 1) {
1092 q
->bits_per_subpacket
= q
->bits_per_subpacket
/2;
1094 av_log(avctx
,AV_LOG_DEBUG
,"STEREO\n");
1097 if (q
->nb_channels
!= 2) {
1098 av_log(avctx
,AV_LOG_ERROR
,"Container channels != 2, report sample!\n");
1101 av_log(avctx
,AV_LOG_DEBUG
,"JOINT_STEREO\n");
1102 if (avctx
->extradata_size
>= 16){
1103 q
->total_subbands
= q
->subbands
+ q
->js_subband_start
;
1104 q
->joint_stereo
= 1;
1106 if (q
->samples_per_channel
> 256) {
1107 q
->log2_numvector_size
= 6;
1109 if (q
->samples_per_channel
> 512) {
1110 q
->log2_numvector_size
= 7;
1114 av_log(avctx
,AV_LOG_ERROR
,"MC_COOK not supported!\n");
1118 av_log(avctx
,AV_LOG_ERROR
,"Unknown Cook version, report sample!\n");
1123 /* Initialize variable relations */
1124 q
->numvector_size
= (1 << q
->log2_numvector_size
);
1126 /* Generate tables */
1127 init_rootpow2table(q
);
1130 init_cplscales_table(q
);
1132 if (init_cook_vlc_tables(q
) != 0)
1136 if(avctx
->block_align
>= UINT_MAX
/2)
1139 /* Pad the databuffer with:
1140 DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(),
1141 FF_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */
1142 if (q
->nb_channels
==2 && q
->joint_stereo
==0) {
1143 q
->decoded_bytes_buffer
=
1144 av_mallocz(avctx
->block_align
/2
1145 + DECODE_BYTES_PAD2(avctx
->block_align
/2)
1146 + FF_INPUT_BUFFER_PADDING_SIZE
);
1148 q
->decoded_bytes_buffer
=
1149 av_mallocz(avctx
->block_align
1150 + DECODE_BYTES_PAD1(avctx
->block_align
)
1151 + FF_INPUT_BUFFER_PADDING_SIZE
);
1153 if (q
->decoded_bytes_buffer
== NULL
)
1156 q
->gains1
.now
= q
->gain_1
;
1157 q
->gains1
.previous
= q
->gain_2
;
1158 q
->gains2
.now
= q
->gain_3
;
1159 q
->gains2
.previous
= q
->gain_4
;
1161 /* Initialize transform. */
1162 if ( init_cook_mlt(q
) != 0 )
1165 /* Initialize COOK signal arithmetic handling */
1167 q
->scalar_dequant
= scalar_dequant_float
;
1168 q
->decouple
= decouple_float
;
1169 q
->imlt_window
= imlt_window_float
;
1170 q
->interpolate
= interpolate_float
;
1171 q
->saturate_output
= saturate_output_float
;
1174 /* Try to catch some obviously faulty streams, othervise it might be exploitable */
1175 if (q
->total_subbands
> 53) {
1176 av_log(avctx
,AV_LOG_ERROR
,"total_subbands > 53, report sample!\n");
1179 if (q
->subbands
> 50) {
1180 av_log(avctx
,AV_LOG_ERROR
,"subbands > 50, report sample!\n");
1183 if ((q
->samples_per_channel
== 256) || (q
->samples_per_channel
== 512) || (q
->samples_per_channel
== 1024)) {
1185 av_log(avctx
,AV_LOG_ERROR
,"unknown amount of samples_per_channel = %d, report sample!\n",q
->samples_per_channel
);
1188 if ((q
->js_vlc_bits
> 6) || (q
->js_vlc_bits
< 0)) {
1189 av_log(avctx
,AV_LOG_ERROR
,"q->js_vlc_bits = %d, only >= 0 and <= 6 allowed!\n",q
->js_vlc_bits
);
1194 dump_cook_context(q
);
1200 AVCodec cook_decoder
=
1203 .type
= CODEC_TYPE_AUDIO
,
1204 .id
= CODEC_ID_COOK
,
1205 .priv_data_size
= sizeof(COOKContext
),
1206 .init
= cook_decode_init
,
1207 .close
= cook_decode_close
,
1208 .decode
= cook_decode_frame
,
1209 .long_name
= "COOK",