2 * COOK compatible decoder
3 * Copyright (c) 2003 Sascha Sommer
4 * Copyright (c) 2005 Benjamin Larsson
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 * Cook compatible decoder.
25 * This decoder handles RealNetworks, RealAudio G2 data.
26 * Cook is identified by the codec name cook in RM files.
28 * To use this decoder, a calling application must supply the extradata
29 * bytes provided from the RM container; 8+ bytes for mono streams and
30 * 16+ for stereo streams (maybe more).
32 * Codec technicalities (all this assume a buffer length of 1024):
33 * Cook works with several different techniques to achieve its compression.
34 * In the timedomain the buffer is divided into 8 pieces and quantized. If
35 * two neighboring pieces have different quantization index a smooth
36 * quantization curve is used to get a smooth overlap between the different
38 * To get to the transformdomain Cook uses a modulated lapped transform.
39 * The transform domain has 50 subbands with 20 elements each. This
40 * means only a maximum of 50*20=1000 coefficients are used out of the 1024
48 #define ALT_BITSTREAM_READER
50 #include "bitstream.h"
55 /* the different Cook versions */
56 #define MONO_COOK1 0x1000001
57 #define MONO_COOK2 0x1000002
58 #define JOINT_STEREO 0x1000003
59 #define MC_COOK 0x2000000 //multichannel Cook, not supported
61 #define SUBBAND_SIZE 20
70 typedef struct __attribute__((__packed__
)){
71 /* codec data start */
72 uint32_t cookversion
; //in network order, bigendian
73 uint16_t samples_per_frame
; //amount of samples per frame per channel, bigendian
74 uint16_t subbands
; //amount of bands used in the frequency domain, bigendian
75 /* Mono extradata ends here. */
77 uint16_t js_subband_start
; //bigendian
78 uint16_t js_vlc_bits
; //bigendian
79 /* Stereo extradata ends here. */
90 int samples_per_channel
;
91 int samples_per_frame
;
94 int numvector_size
; //1 << numvector_bits;
98 int bits_per_subpacket
;
104 FFTSample mlt_tmp
[1024] __attribute__((aligned(16))); /* temporary storage for imlt */
111 int mlt_size
; //modulated lapped transform size
114 COOKgain
* gain_now_ptr
;
115 COOKgain
* gain_previous_ptr
;
117 COOKgain gain_current
;
119 COOKgain gain_previous
;
123 VLC envelope_quant_index
[13];
124 VLC sqvh
[7]; //scalar quantization
125 VLC ccpl
; //channel coupling
127 /* generatable tables and related variables */
128 int gain_size_factor
;
129 float gain_table
[23];
131 float rootpow2tab
[127];
134 uint8_t* frame_reorder_buffer
;
135 int* frame_reorder_index
;
136 int frame_reorder_counter
;
137 int frame_reorder_complete
;
138 int frame_reorder_index_size
;
140 uint8_t* decoded_bytes_buffer
;
141 float mono_mdct_output
[2048] __attribute__((aligned(16)));
142 float* previous_buffer_ptr
[2];
143 float mono_previous_buffer1
[1024];
144 float mono_previous_buffer2
[1024];
145 float* decode_buf_ptr
[4];
146 float decode_buffer_1
[1024];
147 float decode_buffer_2
[1024];
148 float decode_buffer_3
[1024];
149 float decode_buffer_4
[1024];
152 /* debug functions */
155 static void dump_float_table(float* table
, int size
, int delimiter
) {
157 av_log(NULL
,AV_LOG_ERROR
,"\n[%d]: ",i
);
158 for (i
=0 ; i
<size
; i
++) {
159 av_log(NULL
, AV_LOG_ERROR
, "%5.1f, ", table
[i
]);
160 if ((i
+1)%delimiter
== 0) av_log(NULL
,AV_LOG_ERROR
,"\n[%d]: ",i
+1);
164 static void dump_int_table(int* table
, int size
, int delimiter
) {
166 av_log(NULL
,AV_LOG_ERROR
,"\n[%d]: ",i
);
167 for (i
=0 ; i
<size
; i
++) {
168 av_log(NULL
, AV_LOG_ERROR
, "%d, ", table
[i
]);
169 if ((i
+1)%delimiter
== 0) av_log(NULL
,AV_LOG_ERROR
,"\n[%d]: ",i
+1);
173 static void dump_short_table(short* table
, int size
, int delimiter
) {
175 av_log(NULL
,AV_LOG_ERROR
,"\n[%d]: ",i
);
176 for (i
=0 ; i
<size
; i
++) {
177 av_log(NULL
, AV_LOG_ERROR
, "%d, ", table
[i
]);
178 if ((i
+1)%delimiter
== 0) av_log(NULL
,AV_LOG_ERROR
,"\n[%d]: ",i
+1);
184 /*************** init functions ***************/
186 /* table generator */
187 static void init_pow2table(COOKContext
*q
){
189 q
->pow2tab
[63] = 1.0;
190 for (i
=1 ; i
<64 ; i
++){
191 q
->pow2tab
[63+i
]=(float)pow(2.0,(double)i
);
192 q
->pow2tab
[63-i
]=1.0/(float)pow(2.0,(double)i
);
196 /* table generator */
197 static void init_rootpow2table(COOKContext
*q
){
199 q
->rootpow2tab
[63] = 1.0;
200 for (i
=1 ; i
<64 ; i
++){
201 q
->rootpow2tab
[63+i
]=sqrt((float)powf(2.0,(float)i
));
202 q
->rootpow2tab
[63-i
]=sqrt(1.0/(float)powf(2.0,(float)i
));
206 /* table generator */
207 static void init_gain_table(COOKContext
*q
) {
209 q
->gain_size_factor
= q
->samples_per_channel
/8;
210 for (i
=0 ; i
<23 ; i
++) {
211 q
->gain_table
[i
] = pow((double)q
->pow2tab
[i
+52] ,
212 (1.0/(double)q
->gain_size_factor
));
214 memset(&q
->gain_copy
, 0, sizeof(COOKgain
));
215 memset(&q
->gain_current
, 0, sizeof(COOKgain
));
216 memset(&q
->gain_now
, 0, sizeof(COOKgain
));
217 memset(&q
->gain_previous
, 0, sizeof(COOKgain
));
221 static int init_cook_vlc_tables(COOKContext
*q
) {
225 for (i
=0 ; i
<13 ; i
++) {
226 result
&= init_vlc (&q
->envelope_quant_index
[i
], 9, 24,
227 envelope_quant_index_huffbits
[i
], 1, 1,
228 envelope_quant_index_huffcodes
[i
], 2, 2, 0);
230 av_log(NULL
,AV_LOG_DEBUG
,"sqvh VLC init\n");
231 for (i
=0 ; i
<7 ; i
++) {
232 result
&= init_vlc (&q
->sqvh
[i
], vhvlcsize_tab
[i
], vhsize_tab
[i
],
233 cvh_huffbits
[i
], 1, 1,
234 cvh_huffcodes
[i
], 2, 2, 0);
237 if (q
->nb_channels
==2 && q
->joint_stereo
==1){
238 result
&= init_vlc (&q
->ccpl
, 6, (1<<q
->js_vlc_bits
)-1,
239 ccpl_huffbits
[q
->js_vlc_bits
-2], 1, 1,
240 ccpl_huffcodes
[q
->js_vlc_bits
-2], 2, 2, 0);
241 av_log(NULL
,AV_LOG_DEBUG
,"Joint-stereo VLC used.\n");
244 av_log(NULL
,AV_LOG_DEBUG
,"VLC tables initialized.\n");
248 static int init_cook_mlt(COOKContext
*q
) {
252 /* Allocate the buffers, could be replaced with a static [512]
254 q
->mlt_size
= q
->samples_per_channel
;
255 q
->mlt_window
= av_malloc(sizeof(float)*q
->mlt_size
);
256 q
->mlt_precos
= av_malloc(sizeof(float)*q
->mlt_size
/2);
257 q
->mlt_presin
= av_malloc(sizeof(float)*q
->mlt_size
/2);
258 q
->mlt_postcos
= av_malloc(sizeof(float)*q
->mlt_size
/2);
260 /* Initialize the MLT window: simple sine window. */
261 alpha
= M_PI
/ (2.0 * (float)q
->mlt_size
);
262 for(j
=0 ; j
<q
->mlt_size
; j
++) {
263 q
->mlt_window
[j
] = sin((j
+ 512.0/(float)q
->mlt_size
) * alpha
);
266 /* pre/post twiddle factors */
267 for (j
=0 ; j
<q
->mlt_size
/2 ; j
++){
268 q
->mlt_precos
[j
] = cos( ((j
+0.25)*M_PI
)/q
->mlt_size
);
269 q
->mlt_presin
[j
] = sin( ((j
+0.25)*M_PI
)/q
->mlt_size
);
270 q
->mlt_postcos
[j
] = (float)sqrt(2.0/(float)q
->mlt_size
)*cos( ((float)j
*M_PI
) /q
->mlt_size
); //sqrt(2/MLT_size) = scalefactor
273 /* Initialize the FFT. */
274 ff_fft_init(&q
->fft_ctx
, av_log2(q
->mlt_size
)-1, 0);
275 av_log(NULL
,AV_LOG_DEBUG
,"FFT initialized, order = %d.\n",
276 av_log2(q
->samples_per_channel
)-1);
278 return (int)(q
->mlt_window
&& q
->mlt_precos
&& q
->mlt_presin
&& q
->mlt_postcos
);
281 /*************** init functions end ***********/
284 * Cook indata decoding, every 32 bits are XORed with 0x37c511f2.
285 * Why? No idea, some checksum/error detection method maybe.
286 * Nice way to waste CPU cycles.
288 * @param in pointer to 32bit array of indata
289 * @param bits amount of bits
290 * @param out pointer to 32bit array of outdata
293 static inline void decode_bytes(uint8_t* inbuffer
, uint8_t* out
, int bytes
){
295 uint32_t* buf
= (uint32_t*) inbuffer
;
296 uint32_t* obuf
= (uint32_t*) out
;
297 /* FIXME: 64 bit platforms would be able to do 64 bits at a time.
298 * I'm too lazy though, should be something like
299 * for(i=0 ; i<bitamount/64 ; i++)
300 * (int64_t)out[i] = 0x37c511f237c511f2^be2me_64(int64_t)in[i]);
301 * Buffer alignment needs to be checked. */
304 for(i
=0 ; i
<bytes
/4 ; i
++){
305 #ifdef WORDS_BIGENDIAN
306 obuf
[i
] = 0x37c511f2^buf
[i
];
308 obuf
[i
] = 0xf211c537^buf
[i
];
317 static int cook_decode_close(AVCodecContext
*avctx
)
320 COOKContext
*q
= avctx
->priv_data
;
321 av_log(NULL
,AV_LOG_DEBUG
, "Deallocating memory.\n");
323 /* Free allocated memory buffers. */
324 av_free(q
->mlt_window
);
325 av_free(q
->mlt_precos
);
326 av_free(q
->mlt_presin
);
327 av_free(q
->mlt_postcos
);
328 av_free(q
->frame_reorder_index
);
329 av_free(q
->frame_reorder_buffer
);
330 av_free(q
->decoded_bytes_buffer
);
332 /* Free the transform. */
333 ff_fft_end(&q
->fft_ctx
);
335 /* Free the VLC tables. */
336 for (i
=0 ; i
<13 ; i
++) {
337 free_vlc(&q
->envelope_quant_index
[i
]);
339 for (i
=0 ; i
<7 ; i
++) {
340 free_vlc(&q
->sqvh
[i
]);
342 if(q
->nb_channels
==2 && q
->joint_stereo
==1 ){
346 av_log(NULL
,AV_LOG_DEBUG
,"Memory deallocated.\n");
352 * Fill the COOKgain structure for the timedomain quantization.
354 * @param q pointer to the COOKContext
355 * @param gaininfo pointer to the COOKgain
358 static void decode_gain_info(GetBitContext
*gb
, COOKgain
* gaininfo
) {
361 while (get_bits1(gb
)) {}
363 gaininfo
->size
= get_bits_count(gb
) - 1; //amount of elements*2 to update
365 if (get_bits_count(gb
) - 1 <= 0) return;
367 for (i
=0 ; i
<gaininfo
->size
; i
++){
368 gaininfo
->qidx_table1
[i
] = get_bits(gb
,3);
370 gaininfo
->qidx_table2
[i
] = get_bits(gb
,4) - 7; //convert to signed
372 gaininfo
->qidx_table2
[i
] = -1;
378 * Create the quant index table needed for the envelope.
380 * @param q pointer to the COOKContext
381 * @param quant_index_table pointer to the array
384 static void decode_envelope(COOKContext
*q
, int* quant_index_table
) {
388 bitbias
= get_bits_count(&q
->gb
);
389 quant_index_table
[0]= get_bits(&q
->gb
,6) - 6; //This is used later in categorize
391 for (i
=1 ; i
< q
->total_subbands
; i
++){
393 if (i
>= q
->js_subband_start
* 2) {
394 vlc_index
-=q
->js_subband_start
;
397 if(vlc_index
< 1) vlc_index
= 1;
399 if (vlc_index
>13) vlc_index
= 13; //the VLC tables >13 are identical to No. 13
401 j
= get_vlc2(&q
->gb
, q
->envelope_quant_index
[vlc_index
-1].table
,
402 q
->envelope_quant_index
[vlc_index
-1].bits
,2);
403 quant_index_table
[i
] = quant_index_table
[i
-1] + j
- 12; //differential encoding
408 * Create the quant value table.
410 * @param q pointer to the COOKContext
411 * @param quant_value_table pointer to the array
414 static void inline dequant_envelope(COOKContext
*q
, int* quant_index_table
,
415 float* quant_value_table
){
418 for(i
=0 ; i
< q
->total_subbands
; i
++){
419 quant_value_table
[i
] = q
->rootpow2tab
[quant_index_table
[i
]+63];
424 * Calculate the category and category_index vector.
426 * @param q pointer to the COOKContext
427 * @param quant_index_table pointer to the array
428 * @param category pointer to the category array
429 * @param category_index pointer to the category_index array
432 static void categorize(COOKContext
*q
, int* quant_index_table
,
433 int* category
, int* category_index
){
434 int exp_idx
, bias
, tmpbias
, bits_left
, num_bits
, index
, v
, i
, j
;
438 int tmp_categorize_array1
[128];
439 int tmp_categorize_array1_idx
=0;
440 int tmp_categorize_array2
[128];
441 int tmp_categorize_array2_idx
=0;
442 int category_index_size
=0;
444 bits_left
= q
->bits_per_subpacket
- get_bits_count(&q
->gb
);
446 if(bits_left
> q
->samples_per_channel
) {
447 bits_left
= q
->samples_per_channel
+
448 ((bits_left
- q
->samples_per_channel
)*5)/8;
449 //av_log(NULL, AV_LOG_ERROR, "bits_left = %d\n",bits_left);
452 memset(&exp_index1
,0,102*sizeof(int));
453 memset(&exp_index2
,0,102*sizeof(int));
454 memset(&tmp_categorize_array1
,0,128*sizeof(int));
455 memset(&tmp_categorize_array2
,0,128*sizeof(int));
460 for (i
=32 ; i
>0 ; i
=i
/2){
463 for (j
=q
->total_subbands
; j
>0 ; j
--){
464 exp_idx
= (i
- quant_index_table
[index
] + bias
) / 2;
467 } else if(exp_idx
>7) {
471 num_bits
+=expbits_tab
[exp_idx
];
473 if(num_bits
>= bits_left
- 32){
478 /* Calculate total number of bits. */
480 for (i
=0 ; i
<q
->total_subbands
; i
++) {
481 exp_idx
= (bias
- quant_index_table
[i
]) / 2;
484 } else if(exp_idx
>7) {
487 num_bits
+= expbits_tab
[exp_idx
];
488 exp_index1
[i
] = exp_idx
;
489 exp_index2
[i
] = exp_idx
;
491 tmpbias
= bias
= num_bits
;
493 for (j
= 1 ; j
< q
->numvector_size
; j
++) {
494 if (tmpbias
+ bias
> 2*bits_left
) { /* ---> */
497 for (i
=0 ; i
<q
->total_subbands
; i
++){
498 if (exp_index1
[i
] < 7) {
499 v
= (-2*exp_index1
[i
]) - quant_index_table
[i
] - 32;
507 tmp_categorize_array1
[tmp_categorize_array1_idx
++] = index
;
508 tmpbias
-= expbits_tab
[exp_index1
[index
]] -
509 expbits_tab
[exp_index1
[index
]+1];
514 for (i
=0 ; i
<q
->total_subbands
; i
++){
515 if(exp_index2
[i
] > 0){
516 v
= (-2*exp_index2
[i
])-quant_index_table
[i
];
523 if(index
== -1)break;
524 tmp_categorize_array2
[tmp_categorize_array2_idx
++] = index
;
525 tmpbias
-= expbits_tab
[exp_index2
[index
]] -
526 expbits_tab
[exp_index2
[index
]-1];
531 for(i
=0 ; i
<q
->total_subbands
; i
++)
532 category
[i
] = exp_index2
[i
];
534 /* Concatenate the two arrays. */
535 for(i
=tmp_categorize_array2_idx
-1 ; i
>= 0; i
--)
536 category_index
[category_index_size
++] = tmp_categorize_array2
[i
];
538 for(i
=0;i
<tmp_categorize_array1_idx
;i
++)
539 category_index
[category_index_size
++ ] = tmp_categorize_array1
[i
];
541 /* FIXME: mc_sich_ra8_20.rm triggers this, not sure with what we
542 should fill the remaining bytes. */
543 for(i
=category_index_size
;i
<q
->numvector_size
;i
++)
550 * Expand the category vector.
552 * @param q pointer to the COOKContext
553 * @param category pointer to the category array
554 * @param category_index pointer to the category_index array
557 static void inline expand_category(COOKContext
*q
, int* category
,
558 int* category_index
){
560 for(i
=0 ; i
<q
->num_vectors
; i
++){
561 ++category
[category_index
[i
]];
566 * The real requantization of the mltcoefs
568 * @param q pointer to the COOKContext
570 * @param band current subband
571 * @param quant_value_table pointer to the array
572 * @param subband_coef_index array of indexes to quant_centroid_tab
573 * @param subband_coef_noise use random noise instead of predetermined value
574 * @param mlt_buffer pointer to the mlt buffer
578 static void scalar_dequant(COOKContext
*q
, int index
, int band
,
579 float* quant_value_table
, int* subband_coef_index
,
580 int* subband_coef_noise
, float* mlt_buffer
){
584 for(i
=0 ; i
<SUBBAND_SIZE
; i
++) {
585 if (subband_coef_index
[i
]) {
586 if (subband_coef_noise
[i
]) {
587 f1
= -quant_centroid_tab
[index
][subband_coef_index
[i
]];
589 f1
= quant_centroid_tab
[index
][subband_coef_index
[i
]];
592 /* noise coding if subband_coef_noise[i] == 0 */
593 q
->random_state
= q
->random_state
* 214013 + 2531011; //typical RNG numbers
594 f1
= randsign
[(q
->random_state
/0x1000000)&1] * dither_tab
[index
]; //>>31
596 mlt_buffer
[band
*20+ i
] = f1
* quant_value_table
[band
];
600 * Unpack the subband_coef_index and subband_coef_noise vectors.
602 * @param q pointer to the COOKContext
603 * @param category pointer to the category array
604 * @param subband_coef_index array of indexes to quant_centroid_tab
605 * @param subband_coef_noise use random noise instead of predetermined value
608 static int unpack_SQVH(COOKContext
*q
, int category
, int* subband_coef_index
,
609 int* subband_coef_noise
) {
611 int vlc
, vd
,tmp
, result
;
615 vd
= vd_tab
[category
];
617 for(i
=0 ; i
<vpr_tab
[category
] ; i
++){
618 ub
= get_bits_count(&q
->gb
);
619 vlc
= get_vlc2(&q
->gb
, q
->sqvh
[category
].table
, q
->sqvh
[category
].bits
, 3);
620 cb
= get_bits_count(&q
->gb
);
621 if (q
->bits_per_subpacket
< get_bits_count(&q
->gb
)){
625 for(j
=vd
-1 ; j
>=0 ; j
--){
626 tmp
= (vlc
* invradix_tab
[category
])/0x100000;
627 subband_coef_index
[vd
*i
+j
] = vlc
- tmp
* (kmax_tab
[category
]+1);
630 for(j
=0 ; j
<vd
; j
++){
631 if (subband_coef_index
[i
*vd
+ j
]) {
632 if(get_bits_count(&q
->gb
) < q
->bits_per_subpacket
){
633 subband_coef_noise
[i
*vd
+j
] = get_bits1(&q
->gb
);
636 subband_coef_noise
[i
*vd
+j
]=0;
639 subband_coef_noise
[i
*vd
+j
]=0;
648 * Fill the mlt_buffer with mlt coefficients.
650 * @param q pointer to the COOKContext
651 * @param category pointer to the category array
652 * @param quant_value_table pointer to the array
653 * @param mlt_buffer pointer to mlt coefficients
657 static void decode_vectors(COOKContext
* q
, int* category
,
658 float* quant_value_table
, float* mlt_buffer
){
659 /* A zero in this table means that the subband coefficient is
660 random noise coded. */
661 int subband_coef_noise
[SUBBAND_SIZE
];
662 /* A zero in this table means that the subband coefficient is a
663 positive multiplicator. */
664 int subband_coef_index
[SUBBAND_SIZE
];
668 for(band
=0 ; band
<q
->total_subbands
; band
++){
669 index
= category
[band
];
670 if(category
[band
] < 7){
671 if(unpack_SQVH(q
, category
[band
], subband_coef_index
, subband_coef_noise
)){
673 for(j
=0 ; j
<q
->total_subbands
; j
++) category
[band
+j
]=7;
677 memset(subband_coef_index
, 0, sizeof(subband_coef_index
));
678 memset(subband_coef_noise
, 0, sizeof(subband_coef_noise
));
680 scalar_dequant(q
, index
, band
, quant_value_table
, subband_coef_index
,
681 subband_coef_noise
, mlt_buffer
);
684 if(q
->total_subbands
*SUBBAND_SIZE
>= q
->samples_per_channel
){
691 * function for decoding mono data
693 * @param q pointer to the COOKContext
694 * @param mlt_buffer1 pointer to left channel mlt coefficients
695 * @param mlt_buffer2 pointer to right channel mlt coefficients
698 static void mono_decode(COOKContext
*q
, float* mlt_buffer
) {
700 int category_index
[128];
701 float quant_value_table
[102];
702 int quant_index_table
[102];
705 memset(&category
, 0, 128*sizeof(int));
706 memset(&quant_value_table
, 0, 102*sizeof(int));
707 memset(&category_index
, 0, 128*sizeof(int));
709 decode_envelope(q
, quant_index_table
);
710 q
->num_vectors
= get_bits(&q
->gb
,q
->numvector_bits
);
711 dequant_envelope(q
, quant_index_table
, quant_value_table
);
712 categorize(q
, quant_index_table
, category
, category_index
);
713 expand_category(q
, category
, category_index
);
714 decode_vectors(q
, category
, quant_value_table
, mlt_buffer
);
719 * The modulated lapped transform, this takes transform coefficients
720 * and transforms them into timedomain samples. This is done through
721 * an FFT-based algorithm with pre- and postrotation steps.
722 * A window and reorder step is also included.
724 * @param q pointer to the COOKContext
725 * @param inbuffer pointer to the mltcoefficients
726 * @param outbuffer pointer to the timedomain buffer
727 * @param mlt_tmp pointer to temporary storage space
730 static void cook_imlt(COOKContext
*q
, float* inbuffer
, float* outbuffer
,
735 for(i
=0 ; i
<q
->mlt_size
; i
+=2){
736 outbuffer
[i
] = (q
->mlt_presin
[i
/2] * inbuffer
[q
->mlt_size
-1-i
]) +
737 (q
->mlt_precos
[i
/2] * inbuffer
[i
]);
738 outbuffer
[i
+1] = (q
->mlt_precos
[i
/2] * inbuffer
[q
->mlt_size
-1-i
]) -
739 (q
->mlt_presin
[i
/2] * inbuffer
[i
]);
743 ff_fft_permute(&q
->fft_ctx
, (FFTComplex
*) outbuffer
);
744 ff_fft_calc (&q
->fft_ctx
, (FFTComplex
*) outbuffer
);
747 for(i
=0 ; i
<q
->mlt_size
; i
+=2){
748 mlt_tmp
[i
] = (q
->mlt_postcos
[(q
->mlt_size
-1-i
)/2] * outbuffer
[i
+1]) +
749 (q
->mlt_postcos
[i
/2] * outbuffer
[i
]);
750 mlt_tmp
[q
->mlt_size
-1-i
] = (q
->mlt_postcos
[(q
->mlt_size
-1-i
)/2] * outbuffer
[i
]) -
751 (q
->mlt_postcos
[i
/2] * outbuffer
[i
+1]);
754 /* window and reorder */
755 for(i
=0 ; i
<q
->mlt_size
/2 ; i
++){
756 outbuffer
[i
] = mlt_tmp
[q
->mlt_size
/2-1-i
] * q
->mlt_window
[i
];
757 outbuffer
[q
->mlt_size
-1-i
]= mlt_tmp
[q
->mlt_size
/2-1-i
] *
758 q
->mlt_window
[q
->mlt_size
-1-i
];
759 outbuffer
[q
->mlt_size
+i
]= mlt_tmp
[q
->mlt_size
/2+i
] *
760 q
->mlt_window
[q
->mlt_size
-1-i
];
761 outbuffer
[2*q
->mlt_size
-1-i
]= -(mlt_tmp
[q
->mlt_size
/2+i
] *
768 * the actual requantization of the timedomain samples
770 * @param q pointer to the COOKContext
771 * @param buffer pointer to the timedomain buffer
772 * @param gain_index index for the block multiplier
773 * @param gain_index_next index for the next block multiplier
776 static void interpolate(COOKContext
*q
, float* buffer
,
777 int gain_index
, int gain_index_next
){
780 fc1
= q
->pow2tab
[gain_index
+63];
782 if(gain_index
== gain_index_next
){ //static gain
783 for(i
=0 ; i
<q
->gain_size_factor
; i
++){
787 } else { //smooth gain
788 fc2
= q
->gain_table
[11 + (gain_index_next
-gain_index
)];
789 for(i
=0 ; i
<q
->gain_size_factor
; i
++){
798 * timedomain requantization of the timedomain samples
800 * @param q pointer to the COOKContext
801 * @param buffer pointer to the timedomain buffer
802 * @param gain_now current gain structure
803 * @param gain_previous previous gain structure
806 static void gain_window(COOKContext
*q
, float* buffer
, COOKgain
* gain_now
,
807 COOKgain
* gain_previous
){
813 index
= gain_previous
->size
;
814 for (i
=7 ; i
>=0 ; i
--) {
815 if(index
&& gain_previous
->qidx_table1
[index
-1]==i
) {
816 gain_index
[i
] = gain_previous
->qidx_table2
[index
-1];
819 gain_index
[i
]=gain_index
[i
+1];
822 /* This is applied to the to be previous data buffer. */
824 interpolate(q
, &buffer
[q
->samples_per_channel
+q
->gain_size_factor
*i
],
825 gain_index
[i
], gain_index
[i
+1]);
828 tmp_gain_index
= gain_index
[0];
829 index
= gain_now
->size
;
830 for (i
=7 ; i
>=0 ; i
--) {
831 if(index
&& gain_now
->qidx_table1
[index
-1]==i
) {
832 gain_index
[i
]= gain_now
->qidx_table2
[index
-1];
835 gain_index
[i
]=gain_index
[i
+1];
839 /* This is applied to the to be current block. */
841 interpolate(q
, &buffer
[i
*q
->gain_size_factor
],
842 tmp_gain_index
+gain_index
[i
],
843 tmp_gain_index
+gain_index
[i
+1]);
849 * mlt overlapping and buffer management
851 * @param q pointer to the COOKContext
852 * @param buffer pointer to the timedomain buffer
853 * @param gain_now current gain structure
854 * @param gain_previous previous gain structure
855 * @param previous_buffer pointer to the previous buffer to be used for overlapping
859 static void gain_compensate(COOKContext
*q
, float* buffer
, COOKgain
* gain_now
,
860 COOKgain
* gain_previous
, float* previous_buffer
) {
862 if((gain_now
->size
|| gain_previous
->size
)) {
863 gain_window(q
, buffer
, gain_now
, gain_previous
);
866 /* Overlap with the previous block. */
867 for(i
=0 ; i
<q
->samples_per_channel
; i
++) buffer
[i
]+=previous_buffer
[i
];
869 /* Save away the current to be previous block. */
870 memcpy(previous_buffer
, buffer
+q
->samples_per_channel
,
871 sizeof(float)*q
->samples_per_channel
);
876 * function for getting the jointstereo coupling information
878 * @param q pointer to the COOKContext
879 * @param decouple_tab decoupling array
883 static void decouple_info(COOKContext
*q
, int* decouple_tab
){
886 if(get_bits1(&q
->gb
)) {
887 if(cplband
[q
->js_subband_start
] > cplband
[q
->subbands
-1]) return;
889 length
= cplband
[q
->subbands
-1] - cplband
[q
->js_subband_start
] + 1;
890 for (i
=0 ; i
<length
; i
++) {
891 decouple_tab
[cplband
[q
->js_subband_start
] + i
] = get_vlc2(&q
->gb
, q
->ccpl
.table
, q
->ccpl
.bits
, 2);
896 if(cplband
[q
->js_subband_start
] > cplband
[q
->subbands
-1]) return;
898 length
= cplband
[q
->subbands
-1] - cplband
[q
->js_subband_start
] + 1;
899 for (i
=0 ; i
<length
; i
++) {
900 decouple_tab
[cplband
[q
->js_subband_start
] + i
] = get_bits(&q
->gb
, q
->js_vlc_bits
);
907 * function for decoding joint stereo data
909 * @param q pointer to the COOKContext
910 * @param mlt_buffer1 pointer to left channel mlt coefficients
911 * @param mlt_buffer2 pointer to right channel mlt coefficients
914 static void joint_decode(COOKContext
*q
, float* mlt_buffer1
,
915 float* mlt_buffer2
) {
917 int decouple_tab
[SUBBAND_SIZE
];
918 float decode_buffer
[2048]; //Only 1060 might be needed.
919 int idx
, cpl_tmp
,tmp_idx
;
923 memset(decouple_tab
, 0, sizeof(decouple_tab
));
924 memset(decode_buffer
, 0, sizeof(decode_buffer
));
926 /* Make sure the buffers are zeroed out. */
927 memset(mlt_buffer1
,0, 1024*sizeof(float));
928 memset(mlt_buffer2
,0, 1024*sizeof(float));
929 decouple_info(q
, decouple_tab
);
930 mono_decode(q
, decode_buffer
);
932 /* The two channels are stored interleaved in decode_buffer. */
933 for (i
=0 ; i
<q
->js_subband_start
; i
++) {
934 for (j
=0 ; j
<SUBBAND_SIZE
; j
++) {
935 mlt_buffer1
[i
*20+j
] = decode_buffer
[i
*40+j
];
936 mlt_buffer2
[i
*20+j
] = decode_buffer
[i
*40+20+j
];
940 /* When we reach js_subband_start (the higher frequencies)
941 the coefficients are stored in a coupling scheme. */
942 idx
= (1 << q
->js_vlc_bits
) - 1;
943 if (q
->js_subband_start
< q
->subbands
) {
944 for (i
=0 ; i
<q
->subbands
; i
++) {
945 cpl_tmp
= cplband
[i
+ q
->js_subband_start
];
946 idx
-=decouple_tab
[cpl_tmp
];
947 cplscale
= (float*)cplscales
[q
->js_vlc_bits
-2]; //choose decoupler table
948 f1
= cplscale
[decouple_tab
[cpl_tmp
]];
949 f2
= cplscale
[idx
-1];
950 for (j
=0 ; j
<SUBBAND_SIZE
; j
++) {
951 tmp_idx
= ((2*q
->js_subband_start
+ i
)*20)+j
;
952 mlt_buffer1
[20*(i
+q
->js_subband_start
) + j
] = f1
* decode_buffer
[tmp_idx
];
953 mlt_buffer2
[20*(i
+q
->js_subband_start
) + j
] = f2
* decode_buffer
[tmp_idx
];
955 idx
= (1 << q
->js_vlc_bits
) - 1;
961 * Cook subpacket decoding. This function returns one decoded subpacket,
962 * usually 1024 samples per channel.
964 * @param q pointer to the COOKContext
965 * @param inbuffer pointer to the inbuffer
966 * @param sub_packet_size subpacket size
967 * @param outbuffer pointer to the outbuffer
968 * @param pos the subpacket number in the frame
972 static int decode_subpacket(COOKContext
*q
, uint8_t *inbuffer
,
973 int sub_packet_size
, int16_t *outbuffer
) {
979 // for (i=0 ; i<sub_packet_size ; i++) {
980 // av_log(NULL, AV_LOG_ERROR, "%02x", inbuffer[i]);
982 // av_log(NULL, AV_LOG_ERROR, "\n");
984 decode_bytes(inbuffer
, q
->decoded_bytes_buffer
, sub_packet_size
);
985 init_get_bits(&q
->gb
, q
->decoded_bytes_buffer
, sub_packet_size
*8);
986 decode_gain_info(&q
->gb
, &q
->gain_current
);
987 memcpy(&q
->gain_copy
, &q
->gain_current
,sizeof(COOKgain
)); //This copy does not seem to be used. FIXME
989 if(q
->nb_channels
==2 && q
->joint_stereo
==1){
990 joint_decode(q
, q
->decode_buf_ptr
[0], q
->decode_buf_ptr
[2]);
992 /* Swap buffer pointers. */
993 tmp_ptr
= q
->decode_buf_ptr
[1];
994 q
->decode_buf_ptr
[1] = q
->decode_buf_ptr
[0];
995 q
->decode_buf_ptr
[0] = tmp_ptr
;
996 tmp_ptr
= q
->decode_buf_ptr
[3];
997 q
->decode_buf_ptr
[3] = q
->decode_buf_ptr
[2];
998 q
->decode_buf_ptr
[2] = tmp_ptr
;
1000 /* FIXME: Rethink the gainbuffer handling, maybe a rename?
1001 now/previous swap */
1002 q
->gain_now_ptr
= &q
->gain_now
;
1003 q
->gain_previous_ptr
= &q
->gain_previous
;
1004 for (i
=0 ; i
<q
->nb_channels
; i
++){
1006 cook_imlt(q
, q
->decode_buf_ptr
[i
*2], q
->mono_mdct_output
, q
->mlt_tmp
);
1007 gain_compensate(q
, q
->mono_mdct_output
, q
->gain_now_ptr
,
1008 q
->gain_previous_ptr
, q
->previous_buffer_ptr
[0]);
1010 /* Swap out the previous buffer. */
1011 tmp_ptr
= q
->previous_buffer_ptr
[0];
1012 q
->previous_buffer_ptr
[0] = q
->previous_buffer_ptr
[1];
1013 q
->previous_buffer_ptr
[1] = tmp_ptr
;
1015 /* Clip and convert the floats to 16 bits. */
1016 for (j
=0 ; j
<q
->samples_per_frame
; j
++){
1017 value
= lrintf(q
->mono_mdct_output
[j
]);
1018 if(value
< -32768) value
= -32768;
1019 else if(value
> 32767) value
= 32767;
1020 outbuffer
[2*j
+i
] = value
;
1024 memcpy(&q
->gain_now
, &q
->gain_previous
, sizeof(COOKgain
));
1025 memcpy(&q
->gain_previous
, &q
->gain_current
, sizeof(COOKgain
));
1027 } else if (q
->nb_channels
==2 && q
->joint_stereo
==0) {
1029 mono_decode(q
, q
->decode_buf_ptr
[0]);
1031 tmp_ptr
= q
->decode_buf_ptr
[0];
1032 q
->decode_buf_ptr
[0] = q
->decode_buf_ptr
[1];
1033 q
->decode_buf_ptr
[1] = q
->decode_buf_ptr
[2];
1034 q
->decode_buf_ptr
[2] = q
->decode_buf_ptr
[3];
1035 q
->decode_buf_ptr
[3] = tmp_ptr
;
1037 q
->gain_now_ptr
= &q
->gain_now
;
1038 q
->gain_previous_ptr
= &q
->gain_previous
;
1040 cook_imlt(q
, q
->decode_buf_ptr
[0], q
->mono_mdct_output
,q
->mlt_tmp
);
1041 gain_compensate(q
, q
->mono_mdct_output
, q
->gain_now_ptr
,
1042 q
->gain_previous_ptr
, q
->previous_buffer_ptr
[0]);
1043 /* Swap out the previous buffer. */
1044 tmp_ptr
= q
->previous_buffer_ptr
[0];
1045 q
->previous_buffer_ptr
[0] = q
->previous_buffer_ptr
[1];
1046 q
->previous_buffer_ptr
[1] = tmp_ptr
;
1048 for (j
=0 ; j
<q
->samples_per_frame
; j
++){
1049 value
= lrintf(q
->mono_mdct_output
[j
]);
1050 if(value
< -32768) value
= -32768;
1051 else if(value
> 32767) value
= 32767;
1052 outbuffer
[2*j
+1] = value
;
1056 //av_log(NULL,AV_LOG_ERROR,"bits = %d\n",get_bits_count(&q->gb));
1057 init_get_bits(&q
->gb
, q
->decoded_bytes_buffer
, sub_packet_size
*8+q
->bits_per_subpacket
);
1058 decode_gain_info(&q
->gb
, &q
->gain_current
);
1059 //memcpy(&q->gain_copy, &q->gain_current ,sizeof(COOKgain));
1060 mono_decode(q
, q
->decode_buf_ptr
[0]);
1061 tmp_ptr
= q
->decode_buf_ptr
[0];
1062 q
->decode_buf_ptr
[1] = q
->decode_buf_ptr
[2];
1063 q
->decode_buf_ptr
[2] = q
->decode_buf_ptr
[3];
1064 q
->decode_buf_ptr
[3] = tmp_ptr
;
1066 q
->gain_now_ptr
= &q
->gain_now
;
1067 q
->gain_previous_ptr
= &q
->gain_previous
;
1069 cook_imlt(q
, q
->decode_buf_ptr
[0], q
->mono_mdct_output
,q
->mlt_tmp
);
1070 gain_compensate(q
, q
->mono_mdct_output
, q
->gain_now_ptr
, q
->gain_previous_ptr
, q
->previous_buffer_ptr
[0]);
1072 /* Swap out the previous buffer. */
1073 tmp_ptr
= q
->previous_buffer_ptr
[0];
1074 q
->previous_buffer_ptr
[0] = q
->previous_buffer_ptr
[1];
1075 q
->previous_buffer_ptr
[1] = tmp_ptr
;
1077 for (j
=0 ; j
<q
->samples_per_frame
; j
++){
1078 value
= lrintf(q
->mono_mdct_output
[j
]);
1079 if(value
< -32768) value
= -32768;
1080 else if(value
> 32767) value
= 32767;
1081 outbuffer
[2*j
] = value
;
1085 /* Swap out the previous buffer. */
1086 memcpy(&q
->gain_now
, &q
->gain_previous
, sizeof(COOKgain
));
1087 memcpy(&q
->gain_previous
, &q
->gain_current
, sizeof(COOKgain
));
1090 mono_decode(q
, q
->decode_buf_ptr
[0]);
1092 /* Swap buffer pointers. */
1093 tmp_ptr
= q
->decode_buf_ptr
[1];
1094 q
->decode_buf_ptr
[1] = q
->decode_buf_ptr
[0];
1095 q
->decode_buf_ptr
[0] = tmp_ptr
;
1097 /* FIXME: Rethink the gainbuffer handling, maybe a rename?
1098 now/previous swap */
1099 q
->gain_now_ptr
= &q
->gain_now
;
1100 q
->gain_previous_ptr
= &q
->gain_previous
;
1102 cook_imlt(q
, q
->decode_buf_ptr
[0], q
->mono_mdct_output
,q
->mlt_tmp
);
1103 gain_compensate(q
, q
->mono_mdct_output
, q
->gain_now_ptr
,
1104 q
->gain_previous_ptr
, q
->mono_previous_buffer1
);
1106 /* Clip and convert the floats to 16 bits */
1107 for (j
=0 ; j
<q
->samples_per_frame
; j
++){
1108 value
= lrintf(q
->mono_mdct_output
[j
]);
1109 if(value
< -32768) value
= -32768;
1110 else if(value
> 32767) value
= 32767;
1111 outbuffer
[j
] = value
;
1113 memcpy(&q
->gain_now
, &q
->gain_previous
, sizeof(COOKgain
));
1114 memcpy(&q
->gain_previous
, &q
->gain_current
, sizeof(COOKgain
));
1116 return q
->samples_per_frame
* sizeof(int16_t);
1121 * Cook frame decoding
1123 * @param avctx pointer to the AVCodecContext
1126 static int cook_decode_frame(AVCodecContext
*avctx
,
1127 void *data
, int *data_size
,
1128 uint8_t *buf
, int buf_size
) {
1129 COOKContext
*q
= avctx
->priv_data
;
1131 if (buf_size
< avctx
->block_align
)
1134 *data_size
= decode_subpacket(q
, buf
, avctx
->block_align
, data
);
1136 return avctx
->block_align
;
1139 static void dump_cook_context(COOKContext
*q
, COOKextradata
*e
)
1142 #define PRINT(a,b) av_log(NULL,AV_LOG_ERROR," %s = %d\n", a, b);
1143 av_log(NULL
,AV_LOG_ERROR
,"COOKextradata\n");
1144 av_log(NULL
,AV_LOG_ERROR
,"cookversion=%x\n",e
->cookversion
);
1145 if (e
->cookversion
> MONO_COOK2
) {
1146 PRINT("js_subband_start",e
->js_subband_start
);
1147 PRINT("js_vlc_bits",e
->js_vlc_bits
);
1149 av_log(NULL
,AV_LOG_ERROR
,"COOKContext\n");
1150 PRINT("nb_channels",q
->nb_channels
);
1151 PRINT("bit_rate",q
->bit_rate
);
1152 PRINT("sample_rate",q
->sample_rate
);
1153 PRINT("samples_per_channel",q
->samples_per_channel
);
1154 PRINT("samples_per_frame",q
->samples_per_frame
);
1155 PRINT("subbands",q
->subbands
);
1156 PRINT("random_state",q
->random_state
);
1157 PRINT("mlt_size",q
->mlt_size
);
1158 PRINT("js_subband_start",q
->js_subband_start
);
1159 PRINT("numvector_bits",q
->numvector_bits
);
1160 PRINT("numvector_size",q
->numvector_size
);
1161 PRINT("total_subbands",q
->total_subbands
);
1162 PRINT("frame_reorder_counter",q
->frame_reorder_counter
);
1163 PRINT("frame_reorder_index_size",q
->frame_reorder_index_size
);
1167 * Cook initialization
1169 * @param avctx pointer to the AVCodecContext
1172 static int cook_decode_init(AVCodecContext
*avctx
)
1174 COOKextradata
*e
= avctx
->extradata
;
1175 COOKContext
*q
= avctx
->priv_data
;
1177 /* Take care of the codec specific extradata. */
1178 if (avctx
->extradata_size
<= 0) {
1179 av_log(NULL
,AV_LOG_ERROR
,"Necessary extradata missing!\n");
1182 /* 8 for mono, 16 for stereo, ? for multichannel
1183 Swap to right endianness so we don't need to care later on. */
1184 av_log(NULL
,AV_LOG_DEBUG
,"codecdata_length=%d\n",avctx
->extradata_size
);
1185 if (avctx
->extradata_size
>= 8){
1186 e
->cookversion
= be2me_32(e
->cookversion
);
1187 e
->samples_per_frame
= be2me_16(e
->samples_per_frame
);
1188 e
->subbands
= be2me_16(e
->subbands
);
1190 if (avctx
->extradata_size
>= 16){
1191 e
->js_subband_start
= be2me_16(e
->js_subband_start
);
1192 e
->js_vlc_bits
= be2me_16(e
->js_vlc_bits
);
1196 /* Take data from the AVCodecContext (RM container). */
1197 q
->sample_rate
= avctx
->sample_rate
;
1198 q
->nb_channels
= avctx
->channels
;
1199 q
->bit_rate
= avctx
->bit_rate
;
1201 /* Initialize state. */
1202 q
->random_state
= 1;
1204 /* Initialize extradata related variables. */
1205 q
->samples_per_channel
= e
->samples_per_frame
/ q
->nb_channels
;
1206 q
->samples_per_frame
= e
->samples_per_frame
;
1207 q
->subbands
= e
->subbands
;
1208 q
->bits_per_subpacket
= avctx
->block_align
* 8;
1210 /* Initialize default data states. */
1211 q
->js_subband_start
= 0;
1212 q
->numvector_bits
= 5;
1213 q
->total_subbands
= q
->subbands
;
1215 /* Initialize version-dependent variables */
1216 av_log(NULL
,AV_LOG_DEBUG
,"e->cookversion=%x\n",e
->cookversion
);
1217 switch (e
->cookversion
) {
1219 if (q
->nb_channels
!= 1) {
1220 av_log(NULL
,AV_LOG_ERROR
,"Container channels != 1, report sample!\n");
1223 av_log(NULL
,AV_LOG_DEBUG
,"MONO_COOK1\n");
1226 if (q
->nb_channels
!= 1) {
1227 q
->joint_stereo
= 0;
1228 av_log(NULL
,AV_LOG_ERROR
,"Non-joint-stereo files are decoded with wrong gain at the moment!\n");
1229 q
->bits_per_subpacket
= q
->bits_per_subpacket
/2;
1232 av_log(NULL
,AV_LOG_DEBUG
,"MONO_COOK2\n");
1235 if (q
->nb_channels
!= 2) {
1236 av_log(NULL
,AV_LOG_ERROR
,"Container channels != 2, report sample!\n");
1239 av_log(NULL
,AV_LOG_DEBUG
,"JOINT_STEREO\n");
1240 if (avctx
->extradata_size
>= 16){
1241 q
->total_subbands
= q
->subbands
+ e
->js_subband_start
;
1242 q
->js_subband_start
= e
->js_subband_start
;
1243 q
->joint_stereo
= 1;
1244 q
->js_vlc_bits
= e
->js_vlc_bits
;
1246 if (q
->samples_per_channel
> 256) {
1247 q
->numvector_bits
++; // q->numvector_bits = 6
1249 if (q
->samples_per_channel
> 512) {
1250 q
->numvector_bits
++; // q->numvector_bits = 7
1254 av_log(NULL
,AV_LOG_ERROR
,"MC_COOK not supported!\n");
1258 av_log(NULL
,AV_LOG_ERROR
,"Unknown Cook version, report sample!\n");
1263 /* Initialize variable relations */
1264 q
->mlt_size
= q
->samples_per_channel
;
1265 q
->numvector_size
= (1 << q
->numvector_bits
);
1267 /* Generate tables */
1268 init_rootpow2table(q
);
1272 if (init_cook_vlc_tables(q
) != 0)
1275 /* Pad the databuffer with FF_INPUT_BUFFER_PADDING_SIZE,
1276 this is for the bitstreamreader. */
1277 if ((q
->decoded_bytes_buffer
= av_mallocz((avctx
->block_align
+(4-avctx
->block_align
%4) + FF_INPUT_BUFFER_PADDING_SIZE
)*sizeof(uint8_t))) == NULL
)
1280 q
->decode_buf_ptr
[0] = q
->decode_buffer_1
;
1281 q
->decode_buf_ptr
[1] = q
->decode_buffer_2
;
1282 q
->decode_buf_ptr
[2] = q
->decode_buffer_3
;
1283 q
->decode_buf_ptr
[3] = q
->decode_buffer_4
;
1285 q
->previous_buffer_ptr
[0] = q
->mono_previous_buffer1
;
1286 q
->previous_buffer_ptr
[1] = q
->mono_previous_buffer2
;
1288 memset(q
->decode_buffer_1
,0,1024*sizeof(float));
1289 memset(q
->decode_buffer_2
,0,1024*sizeof(float));
1290 memset(q
->decode_buffer_3
,0,1024*sizeof(float));
1291 memset(q
->decode_buffer_4
,0,1024*sizeof(float));
1293 /* Initialize transform. */
1294 if ( init_cook_mlt(q
) == 0 )
1297 //dump_cook_context(q,e);
1302 AVCodec cook_decoder
=
1305 .type
= CODEC_TYPE_AUDIO
,
1306 .id
= CODEC_ID_COOK
,
1307 .priv_data_size
= sizeof(COOKContext
),
1308 .init
= cook_decode_init
,
1309 .close
= cook_decode_close
,
1310 .decode
= cook_decode_frame
,