a5bd0a26ae96aeb2854d5aa7654eb1917a26042c
[ffmpeg.git] / libavcodec / cook.c
1 /*
2  * COOK compatible decoder
3  * Copyright (c) 2003 Sascha Sommer
4  * Copyright (c) 2005 Benjamin Larsson
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  *
22  */
23
24 /**
25  * @file cook.c
26  * Cook compatible decoder.
27  * This decoder handles RealNetworks, RealAudio G2 data.
28  * Cook is identified by the codec name cook in RM files.
29  *
30  * To use this decoder, a calling application must supply the extradata
31  * bytes provided from the RM container; 8+ bytes for mono streams and
32  * 16+ for stereo streams (maybe more).
33  *
34  * Codec technicalities (all this assume a buffer length of 1024):
35  * Cook works with several different techniques to achieve its compression.
36  * In the timedomain the buffer is divided into 8 pieces and quantized. If
37  * two neighboring pieces have different quantization index a smooth
38  * quantization curve is used to get a smooth overlap between the different
39  * pieces.
40  * To get to the transformdomain Cook uses a modulated lapped transform.
41  * The transform domain has 50 subbands with 20 elements each. This
42  * means only a maximum of 50*20=1000 coefficients are used out of the 1024
43  * available.
44  */
45
46 #include <math.h>
47 #include <stddef.h>
48 #include <stdio.h>
49
50 #include "avcodec.h"
51 #include "bitstream.h"
52 #include "dsputil.h"
53
54 #include "cookdata.h"
55
56 /* the different Cook versions */
57 #define MONO            0x1000001
58 #define STEREO          0x1000002
59 #define JOINT_STEREO    0x1000003
60 #define MC_COOK         0x2000000   //multichannel Cook, not supported
61
62 #define SUBBAND_SIZE    20
63 //#define COOKDEBUG
64
65 typedef struct {
66     int     size;
67     int     qidx_table1[8];
68     int     qidx_table2[8];
69 } COOKgain;
70
71 typedef struct __attribute__((__packed__)){
72     /* codec data start */
73     uint32_t cookversion;               //in network order, bigendian
74     uint16_t samples_per_frame;         //amount of samples per frame per channel, bigendian
75     uint16_t subbands;                  //amount of bands used in the frequency domain, bigendian
76     /* Mono extradata ends here. */
77     uint32_t unused;
78     uint16_t js_subband_start;          //bigendian
79     uint16_t js_vlc_bits;               //bigendian
80     /* Stereo extradata ends here. */
81 } COOKextradata;
82
83
84 typedef struct {
85     GetBitContext       gb;
86     /* stream data */
87     int                 nb_channels;
88     int                 joint_stereo;
89     int                 bit_rate;
90     int                 sample_rate;
91     int                 samples_per_channel;
92     int                 samples_per_frame;
93     int                 subbands;
94     int                 log2_numvector_size;
95     int                 numvector_size;                //1 << log2_numvector_size;
96     int                 js_subband_start;
97     int                 total_subbands;
98     int                 num_vectors;
99     int                 bits_per_subpacket;
100     /* states */
101     int                 random_state;
102
103     /* transform data */
104     FFTContext          fft_ctx;
105     FFTSample           mlt_tmp[1024] __attribute__((aligned(16))); /* temporary storage for imlt */
106     float*              mlt_window;
107     float*              mlt_precos;
108     float*              mlt_presin;
109     float*              mlt_postcos;
110     int                 fft_size;
111     int                 fft_order;
112     int                 mlt_size;       //modulated lapped transform size
113
114     /* gain buffers */
115     COOKgain*           gain_now_ptr;
116     COOKgain*           gain_previous_ptr;
117     COOKgain            gain_current;
118     COOKgain            gain_now;
119     COOKgain            gain_previous;
120     COOKgain            gain_channel1[2];
121     COOKgain            gain_channel2[2];
122
123     /* VLC data */
124     int                 js_vlc_bits;
125     VLC                 envelope_quant_index[13];
126     VLC                 sqvh[7];          //scalar quantization
127     VLC                 ccpl;             //channel coupling
128
129     /* generatable tables and related variables */
130     int                 gain_size_factor;
131     float               gain_table[23];
132     float               pow2tab[127];
133     float               rootpow2tab[127];
134
135     /* data buffers */
136
137     uint8_t*            decoded_bytes_buffer;
138     float               mono_mdct_output[2048] __attribute__((aligned(16)));
139     float*              previous_buffer_ptr[2];
140     float               mono_previous_buffer1[1024];
141     float               mono_previous_buffer2[1024];
142     float*              decode_buf_ptr[4];
143     float*              decode_buf_ptr2[2];
144     float               decode_buffer_1[1024];
145     float               decode_buffer_2[1024];
146     float               decode_buffer_3[1024];
147     float               decode_buffer_4[1024];
148 } COOKContext;
149
150 /* debug functions */
151
152 #ifdef COOKDEBUG
153 static void dump_float_table(float* table, int size, int delimiter) {
154     int i=0;
155     av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
156     for (i=0 ; i<size ; i++) {
157         av_log(NULL, AV_LOG_ERROR, "%5.1f, ", table[i]);
158         if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
159     }
160 }
161
162 static void dump_int_table(int* table, int size, int delimiter) {
163     int i=0;
164     av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
165     for (i=0 ; i<size ; i++) {
166         av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);
167         if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
168     }
169 }
170
171 static void dump_short_table(short* table, int size, int delimiter) {
172     int i=0;
173     av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
174     for (i=0 ; i<size ; i++) {
175         av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);
176         if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
177     }
178 }
179
180 #endif
181
182 /*************** init functions ***************/
183
184 /* table generator */
185 static void init_pow2table(COOKContext *q){
186     int i;
187     q->pow2tab[63] = 1.0;
188     for (i=1 ; i<64 ; i++){
189         q->pow2tab[63+i]=(float)((uint64_t)1<<i);
190         q->pow2tab[63-i]=1.0/(float)((uint64_t)1<<i);
191     }
192 }
193
194 /* table generator */
195 static void init_rootpow2table(COOKContext *q){
196     int i;
197     q->rootpow2tab[63] = 1.0;
198     for (i=1 ; i<64 ; i++){
199         q->rootpow2tab[63+i]=sqrt((float)((uint64_t)1<<i));
200         q->rootpow2tab[63-i]=sqrt(1.0/(float)((uint64_t)1<<i));
201     }
202 }
203
204 /* table generator */
205 static void init_gain_table(COOKContext *q) {
206     int i;
207     q->gain_size_factor = q->samples_per_channel/8;
208     for (i=0 ; i<23 ; i++) {
209         q->gain_table[i] = pow((double)q->pow2tab[i+52] ,
210                                (1.0/(double)q->gain_size_factor));
211     }
212 }
213
214
215 static int init_cook_vlc_tables(COOKContext *q) {
216     int i, result;
217
218     result = 0;
219     for (i=0 ; i<13 ; i++) {
220         result &= init_vlc (&q->envelope_quant_index[i], 9, 24,
221             envelope_quant_index_huffbits[i], 1, 1,
222             envelope_quant_index_huffcodes[i], 2, 2, 0);
223     }
224     av_log(NULL,AV_LOG_DEBUG,"sqvh VLC init\n");
225     for (i=0 ; i<7 ; i++) {
226         result &= init_vlc (&q->sqvh[i], vhvlcsize_tab[i], vhsize_tab[i],
227             cvh_huffbits[i], 1, 1,
228             cvh_huffcodes[i], 2, 2, 0);
229     }
230
231     if (q->nb_channels==2 && q->joint_stereo==1){
232         result &= init_vlc (&q->ccpl, 6, (1<<q->js_vlc_bits)-1,
233             ccpl_huffbits[q->js_vlc_bits-2], 1, 1,
234             ccpl_huffcodes[q->js_vlc_bits-2], 2, 2, 0);
235         av_log(NULL,AV_LOG_DEBUG,"Joint-stereo VLC used.\n");
236     }
237
238     av_log(NULL,AV_LOG_DEBUG,"VLC tables initialized.\n");
239     return result;
240 }
241
242 static int init_cook_mlt(COOKContext *q) {
243     int j;
244     float alpha;
245
246     /* Allocate the buffers, could be replaced with a static [512]
247        array if needed. */
248     q->mlt_size = q->samples_per_channel;
249     q->mlt_window = av_malloc(sizeof(float)*q->mlt_size);
250     q->mlt_precos = av_malloc(sizeof(float)*q->mlt_size/2);
251     q->mlt_presin = av_malloc(sizeof(float)*q->mlt_size/2);
252     q->mlt_postcos = av_malloc(sizeof(float)*q->mlt_size/2);
253
254     /* Initialize the MLT window: simple sine window. */
255     alpha = M_PI / (2.0 * (float)q->mlt_size);
256     for(j=0 ; j<q->mlt_size ; j++) {
257         q->mlt_window[j] = sin((j + 512.0/(float)q->mlt_size) * alpha);
258     }
259
260     /* pre/post twiddle factors */
261     for (j=0 ; j<q->mlt_size/2 ; j++){
262         q->mlt_precos[j] = cos( ((j+0.25)*M_PI)/q->mlt_size);
263         q->mlt_presin[j] = sin( ((j+0.25)*M_PI)/q->mlt_size);
264         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
265     }
266
267     /* Initialize the FFT. */
268     ff_fft_init(&q->fft_ctx, av_log2(q->mlt_size)-1, 0);
269     av_log(NULL,AV_LOG_DEBUG,"FFT initialized, order = %d.\n",
270            av_log2(q->samples_per_channel)-1);
271
272     return (int)(q->mlt_window && q->mlt_precos && q->mlt_presin && q->mlt_postcos);
273 }
274
275 /*************** init functions end ***********/
276
277 /**
278  * Cook indata decoding, every 32 bits are XORed with 0x37c511f2.
279  * Why? No idea, some checksum/error detection method maybe.
280  *
281  * Out buffer size: extra bytes are needed to cope with
282  * padding/missalignment.
283  * Subpackets passed to the decoder can contain two, consecutive
284  * half-subpackets, of identical but arbitrary size.
285  *          1234 1234 1234 1234  extraA extraB
286  * Case 1:  AAAA BBBB              0      0
287  * Case 2:  AAAA ABBB BB--         3      3
288  * Case 3:  AAAA AABB BBBB         2      2
289  * Case 4:  AAAA AAAB BBBB BB--    1      5
290  *
291  * Nice way to waste CPU cycles.
292  *
293  * @param inbuffer  pointer to byte array of indata
294  * @param out       pointer to byte array of outdata
295  * @param bytes     number of bytes
296  */
297 #define DECODE_BYTES_PAD1(bytes) (3 - ((bytes)+3) % 4)
298 #define DECODE_BYTES_PAD2(bytes) ((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes)))
299
300 static inline int decode_bytes(uint8_t* inbuffer, uint8_t* out, int bytes){
301     int i, off;
302     uint32_t c;
303     uint32_t* buf;
304     uint32_t* obuf = (uint32_t*) out;
305     /* FIXME: 64 bit platforms would be able to do 64 bits at a time.
306      * I'm too lazy though, should be something like
307      * for(i=0 ; i<bitamount/64 ; i++)
308      *     (int64_t)out[i] = 0x37c511f237c511f2^be2me_64(int64_t)in[i]);
309      * Buffer alignment needs to be checked. */
310
311     off = (uint32_t)inbuffer % 4;
312     buf = (uint32_t*) (inbuffer - off);
313     c = be2me_32((0x37c511f2 >> (off*8)) | (0x37c511f2 << (32-(off*8))));
314     bytes += 3 + off;
315     for (i = 0; i < bytes/4; i++)
316         obuf[i] = c ^ buf[i];
317
318     return off;
319 }
320
321 /**
322  * Cook uninit
323  */
324
325 static int cook_decode_close(AVCodecContext *avctx)
326 {
327     int i;
328     COOKContext *q = avctx->priv_data;
329     av_log(avctx,AV_LOG_DEBUG, "Deallocating memory.\n");
330
331     /* Free allocated memory buffers. */
332     av_free(q->mlt_window);
333     av_free(q->mlt_precos);
334     av_free(q->mlt_presin);
335     av_free(q->mlt_postcos);
336     av_free(q->decoded_bytes_buffer);
337
338     /* Free the transform. */
339     ff_fft_end(&q->fft_ctx);
340
341     /* Free the VLC tables. */
342     for (i=0 ; i<13 ; i++) {
343         free_vlc(&q->envelope_quant_index[i]);
344     }
345     for (i=0 ; i<7 ; i++) {
346         free_vlc(&q->sqvh[i]);
347     }
348     if(q->nb_channels==2 && q->joint_stereo==1 ){
349         free_vlc(&q->ccpl);
350     }
351
352     av_log(NULL,AV_LOG_DEBUG,"Memory deallocated.\n");
353
354     return 0;
355 }
356
357 /**
358  * Fill the COOKgain structure for the timedomain quantization.
359  *
360  * @param q                 pointer to the COOKContext
361  * @param gaininfo          pointer to the COOKgain
362  */
363
364 static void decode_gain_info(GetBitContext *gb, COOKgain* gaininfo) {
365     int i;
366
367     while (get_bits1(gb)) {}
368
369     gaininfo->size = get_bits_count(gb) - 1;     //amount of elements*2 to update
370
371     if (get_bits_count(gb) - 1 <= 0) return;
372
373     for (i=0 ; i<gaininfo->size ; i++){
374         gaininfo->qidx_table1[i] = get_bits(gb,3);
375         if (get_bits1(gb)) {
376             gaininfo->qidx_table2[i] = get_bits(gb,4) - 7;  //convert to signed
377         } else {
378             gaininfo->qidx_table2[i] = -1;
379         }
380     }
381 }
382
383 /**
384  * Create the quant index table needed for the envelope.
385  *
386  * @param q                 pointer to the COOKContext
387  * @param quant_index_table pointer to the array
388  */
389
390 static void decode_envelope(COOKContext *q, int* quant_index_table) {
391     int i,j, vlc_index;
392     int bitbias;
393
394     bitbias = get_bits_count(&q->gb);
395     quant_index_table[0]= get_bits(&q->gb,6) - 6;       //This is used later in categorize
396
397     for (i=1 ; i < q->total_subbands ; i++){
398         vlc_index=i;
399         if (i >= q->js_subband_start * 2) {
400             vlc_index-=q->js_subband_start;
401         } else {
402             vlc_index/=2;
403             if(vlc_index < 1) vlc_index = 1;
404         }
405         if (vlc_index>13) vlc_index = 13;           //the VLC tables >13 are identical to No. 13
406
407         j = get_vlc2(&q->gb, q->envelope_quant_index[vlc_index-1].table,
408                      q->envelope_quant_index[vlc_index-1].bits,2);
409         quant_index_table[i] = quant_index_table[i-1] + j - 12;    //differential encoding
410     }
411 }
412
413 /**
414  * Create the quant value table.
415  *
416  * @param q                 pointer to the COOKContext
417  * @param quant_value_table pointer to the array
418  */
419
420 static void inline dequant_envelope(COOKContext *q, int* quant_index_table,
421                                     float* quant_value_table){
422
423     int i;
424     for(i=0 ; i < q->total_subbands ; i++){
425         quant_value_table[i] = q->rootpow2tab[quant_index_table[i]+63];
426     }
427 }
428
429 /**
430  * Calculate the category and category_index vector.
431  *
432  * @param q                     pointer to the COOKContext
433  * @param quant_index_table     pointer to the array
434  * @param category              pointer to the category array
435  * @param category_index        pointer to the category_index array
436  */
437
438 static void categorize(COOKContext *q, int* quant_index_table,
439                        int* category, int* category_index){
440     int exp_idx, bias, tmpbias, bits_left, num_bits, index, v, i, j;
441     int exp_index2[102];
442     int exp_index1[102];
443
444     int tmp_categorize_array1[128];
445     int tmp_categorize_array1_idx=0;
446     int tmp_categorize_array2[128];
447     int tmp_categorize_array2_idx=0;
448     int category_index_size=0;
449
450     bits_left =  q->bits_per_subpacket - get_bits_count(&q->gb);
451
452     if(bits_left > q->samples_per_channel) {
453         bits_left = q->samples_per_channel +
454                     ((bits_left - q->samples_per_channel)*5)/8;
455         //av_log(NULL, AV_LOG_ERROR, "bits_left = %d\n",bits_left);
456     }
457
458     memset(&exp_index1,0,102*sizeof(int));
459     memset(&exp_index2,0,102*sizeof(int));
460     memset(&tmp_categorize_array1,0,128*sizeof(int));
461     memset(&tmp_categorize_array2,0,128*sizeof(int));
462
463     bias=-32;
464
465     /* Estimate bias. */
466     for (i=32 ; i>0 ; i=i/2){
467         num_bits = 0;
468         index = 0;
469         for (j=q->total_subbands ; j>0 ; j--){
470             exp_idx = (i - quant_index_table[index] + bias) / 2;
471             if (exp_idx<0){
472                 exp_idx=0;
473             } else if(exp_idx >7) {
474                 exp_idx=7;
475             }
476             index++;
477             num_bits+=expbits_tab[exp_idx];
478         }
479         if(num_bits >= bits_left - 32){
480             bias+=i;
481         }
482     }
483
484     /* Calculate total number of bits. */
485     num_bits=0;
486     for (i=0 ; i<q->total_subbands ; i++) {
487         exp_idx = (bias - quant_index_table[i]) / 2;
488         if (exp_idx<0) {
489             exp_idx=0;
490         } else if(exp_idx >7) {
491             exp_idx=7;
492         }
493         num_bits += expbits_tab[exp_idx];
494         exp_index1[i] = exp_idx;
495         exp_index2[i] = exp_idx;
496     }
497     tmpbias = bias = num_bits;
498
499     for (j = 1 ; j < q->numvector_size ; j++) {
500         if (tmpbias + bias > 2*bits_left) {  /* ---> */
501             int max = -999999;
502             index=-1;
503             for (i=0 ; i<q->total_subbands ; i++){
504                 if (exp_index1[i] < 7) {
505                     v = (-2*exp_index1[i]) - quant_index_table[i] - 32;
506                     if ( v >= max) {
507                         max = v;
508                         index = i;
509                     }
510                 }
511             }
512             if(index==-1)break;
513             tmp_categorize_array1[tmp_categorize_array1_idx++] = index;
514             tmpbias -= expbits_tab[exp_index1[index]] -
515                        expbits_tab[exp_index1[index]+1];
516             ++exp_index1[index];
517         } else {  /* <--- */
518             int min = 999999;
519             index=-1;
520             for (i=0 ; i<q->total_subbands ; i++){
521                 if(exp_index2[i] > 0){
522                     v = (-2*exp_index2[i])-quant_index_table[i];
523                     if ( v < min) {
524                         min = v;
525                         index = i;
526                     }
527                 }
528             }
529             if(index == -1)break;
530             tmp_categorize_array2[tmp_categorize_array2_idx++] = index;
531             tmpbias -= expbits_tab[exp_index2[index]] -
532                        expbits_tab[exp_index2[index]-1];
533             --exp_index2[index];
534         }
535     }
536
537     for(i=0 ; i<q->total_subbands ; i++)
538         category[i] = exp_index2[i];
539
540     /* Concatenate the two arrays. */
541     for(i=tmp_categorize_array2_idx-1 ; i >= 0; i--)
542         category_index[category_index_size++] =  tmp_categorize_array2[i];
543
544     for(i=0;i<tmp_categorize_array1_idx;i++)
545         category_index[category_index_size++ ] =  tmp_categorize_array1[i];
546
547     /* FIXME: mc_sich_ra8_20.rm triggers this, not sure with what we
548        should fill the remaining bytes. */
549     for(i=category_index_size;i<q->numvector_size;i++)
550         category_index[i]=0;
551
552 }
553
554
555 /**
556  * Expand the category vector.
557  *
558  * @param q                     pointer to the COOKContext
559  * @param category              pointer to the category array
560  * @param category_index        pointer to the category_index array
561  */
562
563 static void inline expand_category(COOKContext *q, int* category,
564                                    int* category_index){
565     int i;
566     for(i=0 ; i<q->num_vectors ; i++){
567         ++category[category_index[i]];
568     }
569 }
570
571 /**
572  * The real requantization of the mltcoefs
573  *
574  * @param q                     pointer to the COOKContext
575  * @param index                 index
576  * @param band                  current subband
577  * @param quant_value_table     pointer to the array
578  * @param subband_coef_index    array of indexes to quant_centroid_tab
579  * @param subband_coef_noise    use random noise instead of predetermined value
580  * @param mlt_buffer            pointer to the mlt buffer
581  */
582
583
584 static void scalar_dequant(COOKContext *q, int index, int band,
585                            float* quant_value_table, int* subband_coef_index,
586                            int* subband_coef_noise, float* mlt_buffer){
587     int i;
588     float f1;
589
590     for(i=0 ; i<SUBBAND_SIZE ; i++) {
591         if (subband_coef_index[i]) {
592             if (subband_coef_noise[i]) {
593                 f1 = -quant_centroid_tab[index][subband_coef_index[i]];
594             } else {
595                 f1 = quant_centroid_tab[index][subband_coef_index[i]];
596             }
597         } else {
598             /* noise coding if subband_coef_noise[i] == 0 */
599             q->random_state = q->random_state * 214013 + 2531011;    //typical RNG numbers
600             f1 = randsign[(q->random_state/0x1000000)&1] * dither_tab[index]; //>>31
601         }
602         mlt_buffer[band*20+ i] = f1 * quant_value_table[band];
603     }
604 }
605 /**
606  * Unpack the subband_coef_index and subband_coef_noise vectors.
607  *
608  * @param q                     pointer to the COOKContext
609  * @param category              pointer to the category array
610  * @param subband_coef_index    array of indexes to quant_centroid_tab
611  * @param subband_coef_noise    use random noise instead of predetermined value
612  */
613
614 static int unpack_SQVH(COOKContext *q, int category, int* subband_coef_index,
615                        int* subband_coef_noise) {
616     int i,j;
617     int vlc, vd ,tmp, result;
618     int ub;
619     int cb;
620
621     vd = vd_tab[category];
622     result = 0;
623     for(i=0 ; i<vpr_tab[category] ; i++){
624         ub = get_bits_count(&q->gb);
625         vlc = get_vlc2(&q->gb, q->sqvh[category].table, q->sqvh[category].bits, 3);
626         cb = get_bits_count(&q->gb);
627         if (q->bits_per_subpacket < get_bits_count(&q->gb)){
628             vlc = 0;
629             result = 1;
630         }
631         for(j=vd-1 ; j>=0 ; j--){
632             tmp = (vlc * invradix_tab[category])/0x100000;
633             subband_coef_index[vd*i+j] = vlc - tmp * (kmax_tab[category]+1);
634             vlc = tmp;
635         }
636         for(j=0 ; j<vd ; j++){
637             if (subband_coef_index[i*vd + j]) {
638                 if(get_bits_count(&q->gb) < q->bits_per_subpacket){
639                     subband_coef_noise[i*vd+j] = get_bits1(&q->gb);
640                 } else {
641                     result=1;
642                     subband_coef_noise[i*vd+j]=0;
643                 }
644             } else {
645                 subband_coef_noise[i*vd+j]=0;
646             }
647         }
648     }
649     return result;
650 }
651
652
653 /**
654  * Fill the mlt_buffer with mlt coefficients.
655  *
656  * @param q                 pointer to the COOKContext
657  * @param category          pointer to the category array
658  * @param quant_value_table pointer to the array
659  * @param mlt_buffer        pointer to mlt coefficients
660  */
661
662
663 static void decode_vectors(COOKContext* q, int* category,
664                            float* quant_value_table, float* mlt_buffer){
665     /* A zero in this table means that the subband coefficient is
666        random noise coded. */
667     int subband_coef_noise[SUBBAND_SIZE];
668     /* A zero in this table means that the subband coefficient is a
669        positive multiplicator. */
670     int subband_coef_index[SUBBAND_SIZE];
671     int band, j;
672     int index=0;
673
674     for(band=0 ; band<q->total_subbands ; band++){
675         index = category[band];
676         if(category[band] < 7){
677             if(unpack_SQVH(q, category[band], subband_coef_index, subband_coef_noise)){
678                 index=7;
679                 for(j=0 ; j<q->total_subbands ; j++) category[band+j]=7;
680             }
681         }
682         if(index==7) {
683             memset(subband_coef_index, 0, sizeof(subband_coef_index));
684             memset(subband_coef_noise, 0, sizeof(subband_coef_noise));
685         }
686         scalar_dequant(q, index, band, quant_value_table, subband_coef_index,
687                        subband_coef_noise, mlt_buffer);
688     }
689
690     if(q->total_subbands*SUBBAND_SIZE >= q->samples_per_channel){
691         return;
692     }
693 }
694
695
696 /**
697  * function for decoding mono data
698  *
699  * @param q                 pointer to the COOKContext
700  * @param mlt_buffer1       pointer to left channel mlt coefficients
701  * @param mlt_buffer2       pointer to right channel mlt coefficients
702  */
703
704 static void mono_decode(COOKContext *q, float* mlt_buffer) {
705
706     int category_index[128];
707     float quant_value_table[102];
708     int quant_index_table[102];
709     int category[128];
710
711     memset(&category, 0, 128*sizeof(int));
712     memset(&quant_value_table, 0, 102*sizeof(int));
713     memset(&category_index, 0, 128*sizeof(int));
714
715     decode_envelope(q, quant_index_table);
716     q->num_vectors = get_bits(&q->gb,q->log2_numvector_size);
717     dequant_envelope(q, quant_index_table, quant_value_table);
718     categorize(q, quant_index_table, category, category_index);
719     expand_category(q, category, category_index);
720     decode_vectors(q, category, quant_value_table, mlt_buffer);
721 }
722
723
724 /**
725  * The modulated lapped transform, this takes transform coefficients
726  * and transforms them into timedomain samples. This is done through
727  * an FFT-based algorithm with pre- and postrotation steps.
728  * A window and reorder step is also included.
729  *
730  * @param q                 pointer to the COOKContext
731  * @param inbuffer          pointer to the mltcoefficients
732  * @param outbuffer         pointer to the timedomain buffer
733  * @param mlt_tmp           pointer to temporary storage space
734  */
735
736 static void cook_imlt(COOKContext *q, float* inbuffer, float* outbuffer,
737                       float* mlt_tmp){
738     int i;
739
740     /* prerotation */
741     for(i=0 ; i<q->mlt_size ; i+=2){
742         outbuffer[i] = (q->mlt_presin[i/2] * inbuffer[q->mlt_size-1-i]) +
743                        (q->mlt_precos[i/2] * inbuffer[i]);
744         outbuffer[i+1] = (q->mlt_precos[i/2] * inbuffer[q->mlt_size-1-i]) -
745                          (q->mlt_presin[i/2] * inbuffer[i]);
746     }
747
748     /* FFT */
749     ff_fft_permute(&q->fft_ctx, (FFTComplex *) outbuffer);
750     ff_fft_calc (&q->fft_ctx, (FFTComplex *) outbuffer);
751
752     /* postrotation */
753     for(i=0 ; i<q->mlt_size ; i+=2){
754         mlt_tmp[i] =               (q->mlt_postcos[(q->mlt_size-1-i)/2] * outbuffer[i+1]) +
755                                    (q->mlt_postcos[i/2] * outbuffer[i]);
756         mlt_tmp[q->mlt_size-1-i] = (q->mlt_postcos[(q->mlt_size-1-i)/2] * outbuffer[i]) -
757                                    (q->mlt_postcos[i/2] * outbuffer[i+1]);
758     }
759
760     /* window and reorder */
761     for(i=0 ; i<q->mlt_size/2 ; i++){
762         outbuffer[i] = mlt_tmp[q->mlt_size/2-1-i] * q->mlt_window[i];
763         outbuffer[q->mlt_size-1-i]= mlt_tmp[q->mlt_size/2-1-i] *
764                                     q->mlt_window[q->mlt_size-1-i];
765         outbuffer[q->mlt_size+i]= mlt_tmp[q->mlt_size/2+i] *
766                                   q->mlt_window[q->mlt_size-1-i];
767         outbuffer[2*q->mlt_size-1-i]= -(mlt_tmp[q->mlt_size/2+i] *
768                                       q->mlt_window[i]);
769     }
770 }
771
772
773 /**
774  * the actual requantization of the timedomain samples
775  *
776  * @param q                 pointer to the COOKContext
777  * @param buffer            pointer to the timedomain buffer
778  * @param gain_index        index for the block multiplier
779  * @param gain_index_next   index for the next block multiplier
780  */
781
782 static void interpolate(COOKContext *q, float* buffer,
783                         int gain_index, int gain_index_next){
784     int i;
785     float fc1, fc2;
786     fc1 = q->pow2tab[gain_index+63];
787
788     if(gain_index == gain_index_next){              //static gain
789         for(i=0 ; i<q->gain_size_factor ; i++){
790             buffer[i]*=fc1;
791         }
792         return;
793     } else {                                        //smooth gain
794         fc2 = q->gain_table[11 + (gain_index_next-gain_index)];
795         for(i=0 ; i<q->gain_size_factor ; i++){
796             buffer[i]*=fc1;
797             fc1*=fc2;
798         }
799         return;
800     }
801 }
802
803 /**
804  * timedomain requantization of the timedomain samples
805  *
806  * @param q                 pointer to the COOKContext
807  * @param buffer            pointer to the timedomain buffer
808  * @param gain_now          current gain structure
809  * @param gain_previous     previous gain structure
810  */
811
812 static void gain_window(COOKContext *q, float* buffer, COOKgain* gain_now,
813                         COOKgain* gain_previous){
814     int i, index;
815     int gain_index[9];
816     int tmp_gain_index;
817
818     gain_index[8]=0;
819     index = gain_previous->size;
820     for (i=7 ; i>=0 ; i--) {
821         if(index && gain_previous->qidx_table1[index-1]==i) {
822             gain_index[i] = gain_previous->qidx_table2[index-1];
823             index--;
824         } else {
825             gain_index[i]=gain_index[i+1];
826         }
827     }
828     /* This is applied to the to be previous data buffer. */
829     for(i=0;i<8;i++){
830         interpolate(q, &buffer[q->samples_per_channel+q->gain_size_factor*i],
831                     gain_index[i], gain_index[i+1]);
832     }
833
834     tmp_gain_index = gain_index[0];
835     index = gain_now->size;
836     for (i=7 ; i>=0 ; i--) {
837         if(index && gain_now->qidx_table1[index-1]==i) {
838             gain_index[i]= gain_now->qidx_table2[index-1];
839             index--;
840         } else {
841             gain_index[i]=gain_index[i+1];
842         }
843     }
844
845     /* This is applied to the to be current block. */
846     for(i=0;i<8;i++){
847         interpolate(q, &buffer[i*q->gain_size_factor],
848                     tmp_gain_index+gain_index[i],
849                     tmp_gain_index+gain_index[i+1]);
850     }
851 }
852
853
854 /**
855  * mlt overlapping and buffer management
856  *
857  * @param q                 pointer to the COOKContext
858  * @param buffer            pointer to the timedomain buffer
859  * @param gain_now          current gain structure
860  * @param gain_previous     previous gain structure
861  * @param previous_buffer   pointer to the previous buffer to be used for overlapping
862  *
863  */
864
865 static void gain_compensate(COOKContext *q, float* buffer, COOKgain* gain_now,
866                             COOKgain* gain_previous, float* previous_buffer) {
867     int i;
868     if((gain_now->size  || gain_previous->size)) {
869         gain_window(q, buffer, gain_now, gain_previous);
870     }
871
872     /* Overlap with the previous block. */
873     for(i=0 ; i<q->samples_per_channel ; i++) buffer[i]+=previous_buffer[i];
874
875     /* Save away the current to be previous block. */
876     memcpy(previous_buffer, buffer+q->samples_per_channel,
877            sizeof(float)*q->samples_per_channel);
878 }
879
880
881 /**
882  * function for getting the jointstereo coupling information
883  *
884  * @param q                 pointer to the COOKContext
885  * @param decouple_tab      decoupling array
886  *
887  */
888
889 static void decouple_info(COOKContext *q, int* decouple_tab){
890     int length, i;
891
892     if(get_bits1(&q->gb)) {
893         if(cplband[q->js_subband_start] > cplband[q->subbands-1]) return;
894
895         length = cplband[q->subbands-1] - cplband[q->js_subband_start] + 1;
896         for (i=0 ; i<length ; i++) {
897             decouple_tab[cplband[q->js_subband_start] + i] = get_vlc2(&q->gb, q->ccpl.table, q->ccpl.bits, 2);
898         }
899         return;
900     }
901
902     if(cplband[q->js_subband_start] > cplband[q->subbands-1]) return;
903
904     length = cplband[q->subbands-1] - cplband[q->js_subband_start] + 1;
905     for (i=0 ; i<length ; i++) {
906        decouple_tab[cplband[q->js_subband_start] + i] = get_bits(&q->gb, q->js_vlc_bits);
907     }
908     return;
909 }
910
911
912 /**
913  * function for decoding joint stereo data
914  *
915  * @param q                 pointer to the COOKContext
916  * @param mlt_buffer1       pointer to left channel mlt coefficients
917  * @param mlt_buffer2       pointer to right channel mlt coefficients
918  */
919
920 static void joint_decode(COOKContext *q, float* mlt_buffer1,
921                          float* mlt_buffer2) {
922     int i,j;
923     int decouple_tab[SUBBAND_SIZE];
924     float decode_buffer[1060];
925     int idx, cpl_tmp,tmp_idx;
926     float f1,f2;
927     float* cplscale;
928
929     memset(decouple_tab, 0, sizeof(decouple_tab));
930     memset(decode_buffer, 0, sizeof(decode_buffer));
931
932     /* Make sure the buffers are zeroed out. */
933     memset(mlt_buffer1,0, 1024*sizeof(float));
934     memset(mlt_buffer2,0, 1024*sizeof(float));
935     decouple_info(q, decouple_tab);
936     mono_decode(q, decode_buffer);
937
938     /* The two channels are stored interleaved in decode_buffer. */
939     for (i=0 ; i<q->js_subband_start ; i++) {
940         for (j=0 ; j<SUBBAND_SIZE ; j++) {
941             mlt_buffer1[i*20+j] = decode_buffer[i*40+j];
942             mlt_buffer2[i*20+j] = decode_buffer[i*40+20+j];
943         }
944     }
945
946     /* When we reach js_subband_start (the higher frequencies)
947        the coefficients are stored in a coupling scheme. */
948     idx = (1 << q->js_vlc_bits) - 1;
949     for (i=q->js_subband_start ; i<q->subbands ; i++) {
950         cpl_tmp = cplband[i];
951         idx -=decouple_tab[cpl_tmp];
952         cplscale = (float*)cplscales[q->js_vlc_bits-2];  //choose decoupler table
953         f1 = cplscale[decouple_tab[cpl_tmp]];
954         f2 = cplscale[idx-1];
955         for (j=0 ; j<SUBBAND_SIZE ; j++) {
956             tmp_idx = ((q->js_subband_start + i)*20)+j;
957             mlt_buffer1[20*i + j] = f1 * decode_buffer[tmp_idx];
958             mlt_buffer2[20*i + j] = f2 * decode_buffer[tmp_idx];
959         }
960         idx = (1 << q->js_vlc_bits) - 1;
961     }
962 }
963
964 /**
965  * First part of subpacket decoding:
966  *  decode raw stream bytes and read gain info.
967  *
968  * @param q                 pointer to the COOKContext
969  * @param inbuffer          pointer to raw stream data
970  * @param gain_ptr          array of current/prev gain pointers
971  */
972
973 static inline void
974 decode_bytes_and_gain(COOKContext *q, uint8_t *inbuffer, COOKgain *gain_ptr)
975 {
976     int offset;
977
978     offset = decode_bytes(inbuffer, q->decoded_bytes_buffer,
979                           q->bits_per_subpacket/8);
980     init_get_bits(&q->gb, q->decoded_bytes_buffer + offset,
981                   q->bits_per_subpacket);
982     decode_gain_info(&q->gb, gain_ptr);
983 }
984
985
986 /**
987  * Cook subpacket decoding. This function returns one decoded subpacket,
988  * usually 1024 samples per channel.
989  *
990  * @param q                 pointer to the COOKContext
991  * @param inbuffer          pointer to the inbuffer
992  * @param sub_packet_size   subpacket size
993  * @param outbuffer         pointer to the outbuffer
994  */
995
996
997 static int decode_subpacket(COOKContext *q, uint8_t *inbuffer,
998                             int sub_packet_size, int16_t *outbuffer) {
999     int i,j;
1000     int value;
1001     float* tmp_ptr;
1002
1003     /* packet dump */
1004 //    for (i=0 ; i<sub_packet_size ; i++) {
1005 //        av_log(NULL, AV_LOG_ERROR, "%02x", inbuffer[i]);
1006 //    }
1007 //    av_log(NULL, AV_LOG_ERROR, "\n");
1008
1009     if(q->nb_channels==2 && q->joint_stereo==1){
1010         decode_bytes_and_gain(q, inbuffer, &q->gain_current);
1011
1012         joint_decode(q, q->decode_buf_ptr[0], q->decode_buf_ptr[2]);
1013
1014         /* Swap buffer pointers. */
1015         tmp_ptr = q->decode_buf_ptr[1];
1016         q->decode_buf_ptr[1] = q->decode_buf_ptr[0];
1017         q->decode_buf_ptr[0] = tmp_ptr;
1018         tmp_ptr = q->decode_buf_ptr[3];
1019         q->decode_buf_ptr[3] = q->decode_buf_ptr[2];
1020         q->decode_buf_ptr[2] = tmp_ptr;
1021
1022         /* FIXME: Rethink the gainbuffer handling, maybe a rename?
1023            now/previous swap */
1024         q->gain_now_ptr = &q->gain_now;
1025         q->gain_previous_ptr = &q->gain_previous;
1026         for (i=0 ; i<q->nb_channels ; i++){
1027
1028             cook_imlt(q, q->decode_buf_ptr[i*2], q->mono_mdct_output, q->mlt_tmp);
1029             gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
1030                             q->gain_previous_ptr, q->previous_buffer_ptr[0]);
1031
1032             /* Swap out the previous buffer. */
1033             tmp_ptr = q->previous_buffer_ptr[0];
1034             q->previous_buffer_ptr[0] = q->previous_buffer_ptr[1];
1035             q->previous_buffer_ptr[1] = tmp_ptr;
1036
1037             /* Clip and convert the floats to 16 bits. */
1038             for (j=0 ; j<q->samples_per_frame ; j++){
1039                 value = lrintf(q->mono_mdct_output[j]);
1040                 if(value < -32768) value = -32768;
1041                 else if(value > 32767) value = 32767;
1042                 outbuffer[2*j+i] = value;
1043             }
1044         }
1045
1046         memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain));
1047         memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain));
1048
1049     } else if (q->nb_channels==2 && q->joint_stereo==0) {
1050             /* channel 0 */
1051             decode_bytes_and_gain(q, inbuffer, &q->gain_current);
1052
1053             mono_decode(q, q->decode_buf_ptr2[0]);
1054
1055             tmp_ptr = q->decode_buf_ptr2[0];
1056             q->decode_buf_ptr2[0] = q->decode_buf_ptr2[1];
1057             q->decode_buf_ptr2[1] = tmp_ptr;
1058
1059             memcpy(&q->gain_channel1[0], &q->gain_current ,sizeof(COOKgain));
1060             q->gain_now_ptr = &q->gain_channel1[0];
1061             q->gain_previous_ptr = &q->gain_channel1[1];
1062
1063             cook_imlt(q, q->decode_buf_ptr2[0], q->mono_mdct_output,q->mlt_tmp);
1064             gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
1065                             q->gain_previous_ptr, q->mono_previous_buffer1);
1066
1067             memcpy(&q->gain_channel1[1], &q->gain_channel1[0],sizeof(COOKgain));
1068
1069
1070             for (j=0 ; j<q->samples_per_frame ; j++){
1071                 value = lrintf(q->mono_mdct_output[j]);
1072                 if(value < -32768) value = -32768;
1073                 else if(value > 32767) value = 32767;
1074                 outbuffer[2*j] = value;
1075             }
1076
1077             /* channel 1 */
1078             //av_log(NULL,AV_LOG_ERROR,"bits = %d\n",get_bits_count(&q->gb));
1079             decode_bytes_and_gain(q, inbuffer + sub_packet_size/2,
1080                                   &q->gain_channel2[0]);
1081
1082             q->gain_now_ptr = &q->gain_channel2[0];
1083             q->gain_previous_ptr = &q->gain_channel2[1];
1084
1085             mono_decode(q, q->decode_buf_ptr[0]);
1086
1087             tmp_ptr = q->decode_buf_ptr[0];
1088             q->decode_buf_ptr[0] = q->decode_buf_ptr[1];
1089             q->decode_buf_ptr[1] = tmp_ptr;
1090
1091             cook_imlt(q, q->decode_buf_ptr[0], q->mono_mdct_output,q->mlt_tmp);
1092             gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
1093                             q->gain_previous_ptr, q->mono_previous_buffer2);
1094
1095             /* Swap out the previous buffer. */
1096             tmp_ptr = q->previous_buffer_ptr[0];
1097             q->previous_buffer_ptr[0] = q->previous_buffer_ptr[1];
1098             q->previous_buffer_ptr[1] = tmp_ptr;
1099
1100             memcpy(&q->gain_channel2[1], &q->gain_channel2[0] ,sizeof(COOKgain));
1101
1102             for (j=0 ; j<q->samples_per_frame ; j++){
1103                 value = lrintf(q->mono_mdct_output[j]);
1104                 if(value < -32768) value = -32768;
1105                 else if(value > 32767) value = 32767;
1106                 outbuffer[2*j+1] = value;
1107             }
1108
1109     } else {
1110         decode_bytes_and_gain(q, inbuffer, &q->gain_current);
1111
1112         mono_decode(q, q->decode_buf_ptr[0]);
1113
1114         /* Swap buffer pointers. */
1115         tmp_ptr = q->decode_buf_ptr[1];
1116         q->decode_buf_ptr[1] = q->decode_buf_ptr[0];
1117         q->decode_buf_ptr[0] = tmp_ptr;
1118
1119         /* FIXME: Rethink the gainbuffer handling, maybe a rename?
1120            now/previous swap */
1121         q->gain_now_ptr = &q->gain_now;
1122         q->gain_previous_ptr = &q->gain_previous;
1123
1124         cook_imlt(q, q->decode_buf_ptr[0], q->mono_mdct_output,q->mlt_tmp);
1125         gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
1126                         q->gain_previous_ptr, q->mono_previous_buffer1);
1127
1128         /* Clip and convert the floats to 16 bits */
1129         for (j=0 ; j<q->samples_per_frame ; j++){
1130             value = lrintf(q->mono_mdct_output[j]);
1131             if(value < -32768) value = -32768;
1132             else if(value > 32767) value = 32767;
1133             outbuffer[j] = value;
1134         }
1135         memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain));
1136         memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain));
1137     }
1138     return q->samples_per_frame * sizeof(int16_t);
1139 }
1140
1141
1142 /**
1143  * Cook frame decoding
1144  *
1145  * @param avctx     pointer to the AVCodecContext
1146  */
1147
1148 static int cook_decode_frame(AVCodecContext *avctx,
1149             void *data, int *data_size,
1150             uint8_t *buf, int buf_size) {
1151     COOKContext *q = avctx->priv_data;
1152
1153     if (buf_size < avctx->block_align)
1154         return buf_size;
1155
1156     *data_size = decode_subpacket(q, buf, avctx->block_align, data);
1157
1158     return avctx->block_align;
1159 }
1160
1161 #ifdef COOKDEBUG
1162 static void dump_cook_context(COOKContext *q, COOKextradata *e)
1163 {
1164     //int i=0;
1165 #define PRINT(a,b) av_log(NULL,AV_LOG_ERROR," %s = %d\n", a, b);
1166     av_log(NULL,AV_LOG_ERROR,"COOKextradata\n");
1167     av_log(NULL,AV_LOG_ERROR,"cookversion=%x\n",e->cookversion);
1168     if (e->cookversion > STEREO) {
1169         PRINT("js_subband_start",e->js_subband_start);
1170         PRINT("js_vlc_bits",e->js_vlc_bits);
1171     }
1172     av_log(NULL,AV_LOG_ERROR,"COOKContext\n");
1173     PRINT("nb_channels",q->nb_channels);
1174     PRINT("bit_rate",q->bit_rate);
1175     PRINT("sample_rate",q->sample_rate);
1176     PRINT("samples_per_channel",q->samples_per_channel);
1177     PRINT("samples_per_frame",q->samples_per_frame);
1178     PRINT("subbands",q->subbands);
1179     PRINT("random_state",q->random_state);
1180     PRINT("mlt_size",q->mlt_size);
1181     PRINT("js_subband_start",q->js_subband_start);
1182     PRINT("log2_numvector_size",q->log2_numvector_size);
1183     PRINT("numvector_size",q->numvector_size);
1184     PRINT("total_subbands",q->total_subbands);
1185 }
1186 #endif
1187
1188 /**
1189  * Cook initialization
1190  *
1191  * @param avctx     pointer to the AVCodecContext
1192  */
1193
1194 static int cook_decode_init(AVCodecContext *avctx)
1195 {
1196     COOKextradata *e = (COOKextradata *)avctx->extradata;
1197     COOKContext *q = avctx->priv_data;
1198
1199     /* Take care of the codec specific extradata. */
1200     if (avctx->extradata_size <= 0) {
1201         av_log(avctx,AV_LOG_ERROR,"Necessary extradata missing!\n");
1202         return -1;
1203     } else {
1204         /* 8 for mono, 16 for stereo, ? for multichannel
1205            Swap to right endianness so we don't need to care later on. */
1206         av_log(avctx,AV_LOG_DEBUG,"codecdata_length=%d\n",avctx->extradata_size);
1207         if (avctx->extradata_size >= 8){
1208             e->cookversion = be2me_32(e->cookversion);
1209             e->samples_per_frame = be2me_16(e->samples_per_frame);
1210             e->subbands = be2me_16(e->subbands);
1211         }
1212         if (avctx->extradata_size >= 16){
1213             e->js_subband_start = be2me_16(e->js_subband_start);
1214             e->js_vlc_bits = be2me_16(e->js_vlc_bits);
1215         }
1216     }
1217
1218     /* Take data from the AVCodecContext (RM container). */
1219     q->sample_rate = avctx->sample_rate;
1220     q->nb_channels = avctx->channels;
1221     q->bit_rate = avctx->bit_rate;
1222
1223     /* Initialize state. */
1224     q->random_state = 1;
1225
1226     /* Initialize extradata related variables. */
1227     q->samples_per_channel = e->samples_per_frame / q->nb_channels;
1228     q->samples_per_frame = e->samples_per_frame;
1229     q->subbands = e->subbands;
1230     q->bits_per_subpacket = avctx->block_align * 8;
1231
1232     /* Initialize default data states. */
1233     q->js_subband_start = 0;
1234     q->log2_numvector_size = 5;
1235     q->total_subbands = q->subbands;
1236
1237     /* Initialize version-dependent variables */
1238     av_log(NULL,AV_LOG_DEBUG,"e->cookversion=%x\n",e->cookversion);
1239     switch (e->cookversion) {
1240         case MONO:
1241             if (q->nb_channels != 1) {
1242                 av_log(avctx,AV_LOG_ERROR,"Container channels != 1, report sample!\n");
1243                 return -1;
1244             }
1245             av_log(avctx,AV_LOG_DEBUG,"MONO\n");
1246             break;
1247         case STEREO:
1248             if (q->nb_channels != 1) {
1249                 q->joint_stereo = 0;
1250                 q->bits_per_subpacket = q->bits_per_subpacket/2;
1251             }
1252             av_log(avctx,AV_LOG_DEBUG,"STEREO\n");
1253             break;
1254         case JOINT_STEREO:
1255             if (q->nb_channels != 2) {
1256                 av_log(avctx,AV_LOG_ERROR,"Container channels != 2, report sample!\n");
1257                 return -1;
1258             }
1259             av_log(avctx,AV_LOG_DEBUG,"JOINT_STEREO\n");
1260             if (avctx->extradata_size >= 16){
1261                 q->total_subbands = q->subbands + e->js_subband_start;
1262                 q->js_subband_start = e->js_subband_start;
1263                 q->joint_stereo = 1;
1264                 q->js_vlc_bits = e->js_vlc_bits;
1265             }
1266             if (q->samples_per_channel > 256) {
1267                 q->log2_numvector_size  = 6;
1268             }
1269             if (q->samples_per_channel > 512) {
1270                 q->log2_numvector_size  = 7;
1271             }
1272             break;
1273         case MC_COOK:
1274             av_log(avctx,AV_LOG_ERROR,"MC_COOK not supported!\n");
1275             return -1;
1276             break;
1277         default:
1278             av_log(avctx,AV_LOG_ERROR,"Unknown Cook version, report sample!\n");
1279             return -1;
1280             break;
1281     }
1282
1283     /* Initialize variable relations */
1284     q->mlt_size = q->samples_per_channel;
1285     q->numvector_size = (1 << q->log2_numvector_size);
1286
1287     /* Generate tables */
1288     init_rootpow2table(q);
1289     init_pow2table(q);
1290     init_gain_table(q);
1291
1292     if (init_cook_vlc_tables(q) != 0)
1293         return -1;
1294
1295
1296     if(avctx->block_align >= UINT_MAX/2)
1297         return -1;
1298
1299     /* Pad the databuffer with:
1300        DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(),
1301        FF_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */
1302     if (q->nb_channels==2 && q->joint_stereo==0) {
1303         q->decoded_bytes_buffer =
1304           av_mallocz(avctx->block_align/2
1305                      + DECODE_BYTES_PAD2(avctx->block_align/2)
1306                      + FF_INPUT_BUFFER_PADDING_SIZE);
1307     } else {
1308         q->decoded_bytes_buffer =
1309           av_mallocz(avctx->block_align
1310                      + DECODE_BYTES_PAD1(avctx->block_align)
1311                      + FF_INPUT_BUFFER_PADDING_SIZE);
1312     }
1313     if (q->decoded_bytes_buffer == NULL)
1314         return -1;
1315
1316     q->decode_buf_ptr[0] = q->decode_buffer_1;
1317     q->decode_buf_ptr[1] = q->decode_buffer_2;
1318     q->decode_buf_ptr[2] = q->decode_buffer_3;
1319     q->decode_buf_ptr[3] = q->decode_buffer_4;
1320
1321     q->decode_buf_ptr2[0] = q->decode_buffer_3;
1322     q->decode_buf_ptr2[1] = q->decode_buffer_4;
1323
1324     q->previous_buffer_ptr[0] = q->mono_previous_buffer1;
1325     q->previous_buffer_ptr[1] = q->mono_previous_buffer2;
1326
1327     /* Initialize transform. */
1328     if ( init_cook_mlt(q) == 0 )
1329         return -1;
1330
1331     /* Try to catch some obviously faulty streams, othervise it might be exploitable */
1332     if (q->total_subbands > 53) {
1333         av_log(avctx,AV_LOG_ERROR,"total_subbands > 53, report sample!\n");
1334         return -1;
1335     }
1336     if (q->subbands > 50) {
1337         av_log(avctx,AV_LOG_ERROR,"subbands > 50, report sample!\n");
1338         return -1;
1339     }
1340     if ((q->samples_per_channel == 256) || (q->samples_per_channel == 512) || (q->samples_per_channel == 1024)) {
1341     } else {
1342         av_log(avctx,AV_LOG_ERROR,"unknown amount of samples_per_channel = %d, report sample!\n",q->samples_per_channel);
1343         return -1;
1344     }
1345
1346 #ifdef COOKDEBUG
1347     dump_cook_context(q,e);
1348 #endif
1349     return 0;
1350 }
1351
1352
1353 AVCodec cook_decoder =
1354 {
1355     .name = "cook",
1356     .type = CODEC_TYPE_AUDIO,
1357     .id = CODEC_ID_COOK,
1358     .priv_data_size = sizeof(COOKContext),
1359     .init = cook_decode_init,
1360     .close = cook_decode_close,
1361     .decode = cook_decode_frame,
1362 };