Statistics
| Branch: | Revision:

ffmpeg / libavcodec / cook.c @ 560b10a6

History | View | Annotate | Download (43 KB)

1
/*
2
 * COOK compatible decoder
3
 * Copyright (c) 2003 Sascha Sommer
4
 * Copyright (c) 2005 Benjamin Larsson
5
 *
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.
10
 *
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.
15
 *
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
19
 *
20
 */
21

    
22
/**
23
 * @file cook.c
24
 * Cook compatible decoder.
25
 * This decoder handles RealNetworks, RealAudio G2 data.
26
 * Cook is identified by the codec name cook in RM files.
27
 *
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).
31
 *
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
37
 * pieces.
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
41
 * available.
42
 */
43

    
44
#include <math.h>
45
#include <stddef.h>
46
#include <stdio.h>
47

    
48
#define ALT_BITSTREAM_READER
49
#include "avcodec.h"
50
#include "bitstream.h"
51
#include "dsputil.h"
52

    
53
#include "cookdata.h"
54

    
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
60

    
61
#define SUBBAND_SIZE    20
62
//#define COOKDEBUG
63

    
64
typedef struct {
65
    int     size;
66
    int     qidx_table1[8];
67
    int     qidx_table2[8];
68
} COOKgain;
69

    
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. */
76
    uint32_t unused;
77
    uint16_t js_subband_start;          //bigendian
78
    uint16_t js_vlc_bits;               //bigendian
79
    /* Stereo extradata ends here. */
80
} COOKextradata;
81

    
82

    
83
typedef struct {
84
    GetBitContext       gb;
85
    /* stream data */
86
    int                 nb_channels;
87
    int                 joint_stereo;
88
    int                 bit_rate;
89
    int                 sample_rate;
90
    int                 samples_per_channel;
91
    int                 samples_per_frame;
92
    int                 subbands;
93
    int                 numvector_bits;
94
    int                 numvector_size;                //1 << numvector_bits;
95
    int                 js_subband_start;
96
    int                 total_subbands;
97
    int                 num_vectors;
98
    int                 bits_per_subpacket;
99
    /* states */
100
    int                 random_state;
101

    
102
    /* transform data */
103
    FFTContext          fft_ctx;
104
    FFTSample           mlt_tmp[1024] __attribute__((aligned(16))); /* temporary storage for imlt */
105
    float*              mlt_window;
106
    float*              mlt_precos;
107
    float*              mlt_presin;
108
    float*              mlt_postcos;
109
    int                 fft_size;
110
    int                 fft_order;
111
    int                 mlt_size;       //modulated lapped transform size
112

    
113
    /* gain buffers */
114
    COOKgain*           gain_now_ptr;
115
    COOKgain*           gain_previous_ptr;
116
    COOKgain            gain_current;
117
    COOKgain            gain_now;
118
    COOKgain            gain_previous;
119
    COOKgain            gain_channel1[2];
120
    COOKgain            gain_channel2[2];
121

    
122
    /* VLC data */
123
    int                 js_vlc_bits;
124
    VLC                 envelope_quant_index[13];
125
    VLC                 sqvh[7];          //scalar quantization
126
    VLC                 ccpl;             //channel coupling
127

    
128
    /* generatable tables and related variables */
129
    int                 gain_size_factor;
130
    float               gain_table[23];
131
    float               pow2tab[127];
132
    float               rootpow2tab[127];
133

    
134
    /* data buffers */
135

    
136
    uint8_t*            decoded_bytes_buffer;
137
    float               mono_mdct_output[2048] __attribute__((aligned(16)));
138
    float*              previous_buffer_ptr[2];
139
    float               mono_previous_buffer1[1024];
140
    float               mono_previous_buffer2[1024];
141
    float*              decode_buf_ptr[4];
142
    float*              decode_buf_ptr2[2];
143
    float               decode_buffer_1[1024];
144
    float               decode_buffer_2[1024];
145
    float               decode_buffer_3[1024];
146
    float               decode_buffer_4[1024];
147
} COOKContext;
148

    
149
/* debug functions */
150

    
151
#ifdef COOKDEBUG
152
static void dump_float_table(float* table, int size, int delimiter) {
153
    int i=0;
154
    av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
155
    for (i=0 ; i<size ; i++) {
156
        av_log(NULL, AV_LOG_ERROR, "%5.1f, ", table[i]);
157
        if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
158
    }
159
}
160

    
161
static void dump_int_table(int* table, int size, int delimiter) {
162
    int i=0;
163
    av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
164
    for (i=0 ; i<size ; i++) {
165
        av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);
166
        if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
167
    }
168
}
169

    
170
static void dump_short_table(short* table, int size, int delimiter) {
171
    int i=0;
172
    av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
173
    for (i=0 ; i<size ; i++) {
174
        av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);
175
        if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
176
    }
177
}
178

    
179
#endif
180

    
181
/*************** init functions ***************/
182

    
183
/* table generator */
184
static void init_pow2table(COOKContext *q){
185
    int i;
186
    q->pow2tab[63] = 1.0;
187
    for (i=1 ; i<64 ; i++){
188
        q->pow2tab[63+i]=(float)pow(2.0,(double)i);
189
        q->pow2tab[63-i]=1.0/(float)pow(2.0,(double)i);
190
    }
191
}
192

    
193
/* table generator */
194
static void init_rootpow2table(COOKContext *q){
195
    int i;
196
    q->rootpow2tab[63] = 1.0;
197
    for (i=1 ; i<64 ; i++){
198
        q->rootpow2tab[63+i]=sqrt((float)powf(2.0,(float)i));
199
        q->rootpow2tab[63-i]=sqrt(1.0/(float)powf(2.0,(float)i));
200
    }
201
}
202

    
203
/* table generator */
204
static void init_gain_table(COOKContext *q) {
205
    int i;
206
    q->gain_size_factor = q->samples_per_channel/8;
207
    for (i=0 ; i<23 ; i++) {
208
        q->gain_table[i] = pow((double)q->pow2tab[i+52] ,
209
                               (1.0/(double)q->gain_size_factor));
210
    }
211
}
212

    
213

    
214
static int init_cook_vlc_tables(COOKContext *q) {
215
    int i, result;
216

    
217
    result = 0;
218
    for (i=0 ; i<13 ; i++) {
219
        result &= init_vlc (&q->envelope_quant_index[i], 9, 24,
220
            envelope_quant_index_huffbits[i], 1, 1,
221
            envelope_quant_index_huffcodes[i], 2, 2, 0);
222
    }
223
    av_log(NULL,AV_LOG_DEBUG,"sqvh VLC init\n");
224
    for (i=0 ; i<7 ; i++) {
225
        result &= init_vlc (&q->sqvh[i], vhvlcsize_tab[i], vhsize_tab[i],
226
            cvh_huffbits[i], 1, 1,
227
            cvh_huffcodes[i], 2, 2, 0);
228
    }
229

    
230
    if (q->nb_channels==2 && q->joint_stereo==1){
231
        result &= init_vlc (&q->ccpl, 6, (1<<q->js_vlc_bits)-1,
232
            ccpl_huffbits[q->js_vlc_bits-2], 1, 1,
233
            ccpl_huffcodes[q->js_vlc_bits-2], 2, 2, 0);
234
        av_log(NULL,AV_LOG_DEBUG,"Joint-stereo VLC used.\n");
235
    }
236

    
237
    av_log(NULL,AV_LOG_DEBUG,"VLC tables initialized.\n");
238
    return result;
239
}
240

    
241
static int init_cook_mlt(COOKContext *q) {
242
    int j;
243
    float alpha;
244

    
245
    /* Allocate the buffers, could be replaced with a static [512]
246
       array if needed. */
247
    q->mlt_size = q->samples_per_channel;
248
    q->mlt_window = av_malloc(sizeof(float)*q->mlt_size);
249
    q->mlt_precos = av_malloc(sizeof(float)*q->mlt_size/2);
250
    q->mlt_presin = av_malloc(sizeof(float)*q->mlt_size/2);
251
    q->mlt_postcos = av_malloc(sizeof(float)*q->mlt_size/2);
252

    
253
    /* Initialize the MLT window: simple sine window. */
254
    alpha = M_PI / (2.0 * (float)q->mlt_size);
255
    for(j=0 ; j<q->mlt_size ; j++) {
256
        q->mlt_window[j] = sin((j + 512.0/(float)q->mlt_size) * alpha);
257
    }
258

    
259
    /* pre/post twiddle factors */
260
    for (j=0 ; j<q->mlt_size/2 ; j++){
261
        q->mlt_precos[j] = cos( ((j+0.25)*M_PI)/q->mlt_size);
262
        q->mlt_presin[j] = sin( ((j+0.25)*M_PI)/q->mlt_size);
263
        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
264
    }
265

    
266
    /* Initialize the FFT. */
267
    ff_fft_init(&q->fft_ctx, av_log2(q->mlt_size)-1, 0);
268
    av_log(NULL,AV_LOG_DEBUG,"FFT initialized, order = %d.\n",
269
           av_log2(q->samples_per_channel)-1);
270

    
271
    return (int)(q->mlt_window && q->mlt_precos && q->mlt_presin && q->mlt_postcos);
272
}
273

    
274
/*************** init functions end ***********/
275

    
276
/**
277
 * Cook indata decoding, every 32 bits are XORed with 0x37c511f2.
278
 * Why? No idea, some checksum/error detection method maybe.
279
 * Nice way to waste CPU cycles.
280
 *
281
 * @param in        pointer to 32bit array of indata
282
 * @param bits      amount of bits
283
 * @param out       pointer to 32bit array of outdata
284
 */
285

    
286
static inline void decode_bytes(uint8_t* inbuffer, uint8_t* out, int bytes){
287
    int i;
288
    uint32_t* buf = (uint32_t*) inbuffer;
289
    uint32_t* obuf = (uint32_t*) out;
290
    /* FIXME: 64 bit platforms would be able to do 64 bits at a time.
291
     * I'm too lazy though, should be something like
292
     * for(i=0 ; i<bitamount/64 ; i++)
293
     *     (int64_t)out[i] = 0x37c511f237c511f2^be2me_64(int64_t)in[i]);
294
     * Buffer alignment needs to be checked. */
295

    
296

    
297
    for(i=0 ; i<bytes/4 ; i++){
298
#ifdef WORDS_BIGENDIAN
299
        obuf[i] = 0x37c511f2^buf[i];
300
#else
301
        obuf[i] = 0xf211c537^buf[i];
302
#endif
303
    }
304
}
305

    
306
/**
307
 * Cook uninit
308
 */
309

    
310
static int cook_decode_close(AVCodecContext *avctx)
311
{
312
    int i;
313
    COOKContext *q = avctx->priv_data;
314
    av_log(NULL,AV_LOG_DEBUG, "Deallocating memory.\n");
315

    
316
    /* Free allocated memory buffers. */
317
    av_free(q->mlt_window);
318
    av_free(q->mlt_precos);
319
    av_free(q->mlt_presin);
320
    av_free(q->mlt_postcos);
321
    av_free(q->decoded_bytes_buffer);
322

    
323
    /* Free the transform. */
324
    ff_fft_end(&q->fft_ctx);
325

    
326
    /* Free the VLC tables. */
327
    for (i=0 ; i<13 ; i++) {
328
        free_vlc(&q->envelope_quant_index[i]);
329
    }
330
    for (i=0 ; i<7 ; i++) {
331
        free_vlc(&q->sqvh[i]);
332
    }
333
    if(q->nb_channels==2 && q->joint_stereo==1 ){
334
        free_vlc(&q->ccpl);
335
    }
336

    
337
    av_log(NULL,AV_LOG_DEBUG,"Memory deallocated.\n");
338

    
339
    return 0;
340
}
341

    
342
/**
343
 * Fill the COOKgain structure for the timedomain quantization.
344
 *
345
 * @param q                 pointer to the COOKContext
346
 * @param gaininfo          pointer to the COOKgain
347
 */
348

    
349
static void decode_gain_info(GetBitContext *gb, COOKgain* gaininfo) {
350
    int i;
351

    
352
    while (get_bits1(gb)) {}
353

    
354
    gaininfo->size = get_bits_count(gb) - 1;     //amount of elements*2 to update
355

    
356
    if (get_bits_count(gb) - 1 <= 0) return;
357

    
358
    for (i=0 ; i<gaininfo->size ; i++){
359
        gaininfo->qidx_table1[i] = get_bits(gb,3);
360
        if (get_bits1(gb)) {
361
            gaininfo->qidx_table2[i] = get_bits(gb,4) - 7;  //convert to signed
362
        } else {
363
            gaininfo->qidx_table2[i] = -1;
364
        }
365
    }
366
}
367

    
368
/**
369
 * Create the quant index table needed for the envelope.
370
 *
371
 * @param q                 pointer to the COOKContext
372
 * @param quant_index_table pointer to the array
373
 */
374

    
375
static void decode_envelope(COOKContext *q, int* quant_index_table) {
376
    int i,j, vlc_index;
377
    int bitbias;
378

    
379
    bitbias = get_bits_count(&q->gb);
380
    quant_index_table[0]= get_bits(&q->gb,6) - 6;       //This is used later in categorize
381

    
382
    for (i=1 ; i < q->total_subbands ; i++){
383
        vlc_index=i;
384
        if (i >= q->js_subband_start * 2) {
385
            vlc_index-=q->js_subband_start;
386
        } else {
387
            vlc_index/=2;
388
            if(vlc_index < 1) vlc_index = 1;
389
        }
390
        if (vlc_index>13) vlc_index = 13;           //the VLC tables >13 are identical to No. 13
391

    
392
        j = get_vlc2(&q->gb, q->envelope_quant_index[vlc_index-1].table,
393
                     q->envelope_quant_index[vlc_index-1].bits,2);
394
        quant_index_table[i] = quant_index_table[i-1] + j - 12;    //differential encoding
395
    }
396
}
397

    
398
/**
399
 * Create the quant value table.
400
 *
401
 * @param q                 pointer to the COOKContext
402
 * @param quant_value_table pointer to the array
403
 */
404

    
405
static void inline dequant_envelope(COOKContext *q, int* quant_index_table,
406
                                    float* quant_value_table){
407

    
408
    int i;
409
    for(i=0 ; i < q->total_subbands ; i++){
410
        quant_value_table[i] = q->rootpow2tab[quant_index_table[i]+63];
411
    }
412
}
413

    
414
/**
415
 * Calculate the category and category_index vector.
416
 *
417
 * @param q                     pointer to the COOKContext
418
 * @param quant_index_table     pointer to the array
419
 * @param category              pointer to the category array
420
 * @param category_index        pointer to the category_index array
421
 */
422

    
423
static void categorize(COOKContext *q, int* quant_index_table,
424
                       int* category, int* category_index){
425
    int exp_idx, bias, tmpbias, bits_left, num_bits, index, v, i, j;
426
    int exp_index2[102];
427
    int exp_index1[102];
428

    
429
    int tmp_categorize_array1[128];
430
    int tmp_categorize_array1_idx=0;
431
    int tmp_categorize_array2[128];
432
    int tmp_categorize_array2_idx=0;
433
    int category_index_size=0;
434

    
435
    bits_left =  q->bits_per_subpacket - get_bits_count(&q->gb);
436

    
437
    if(bits_left > q->samples_per_channel) {
438
        bits_left = q->samples_per_channel +
439
                    ((bits_left - q->samples_per_channel)*5)/8;
440
        //av_log(NULL, AV_LOG_ERROR, "bits_left = %d\n",bits_left);
441
    }
442

    
443
    memset(&exp_index1,0,102*sizeof(int));
444
    memset(&exp_index2,0,102*sizeof(int));
445
    memset(&tmp_categorize_array1,0,128*sizeof(int));
446
    memset(&tmp_categorize_array2,0,128*sizeof(int));
447

    
448
    bias=-32;
449

    
450
    /* Estimate bias. */
451
    for (i=32 ; i>0 ; i=i/2){
452
        num_bits = 0;
453
        index = 0;
454
        for (j=q->total_subbands ; j>0 ; j--){
455
            exp_idx = (i - quant_index_table[index] + bias) / 2;
456
            if (exp_idx<0){
457
                exp_idx=0;
458
            } else if(exp_idx >7) {
459
                exp_idx=7;
460
            }
461
            index++;
462
            num_bits+=expbits_tab[exp_idx];
463
        }
464
        if(num_bits >= bits_left - 32){
465
            bias+=i;
466
        }
467
    }
468

    
469
    /* Calculate total number of bits. */
470
    num_bits=0;
471
    for (i=0 ; i<q->total_subbands ; i++) {
472
        exp_idx = (bias - quant_index_table[i]) / 2;
473
        if (exp_idx<0) {
474
            exp_idx=0;
475
        } else if(exp_idx >7) {
476
            exp_idx=7;
477
        }
478
        num_bits += expbits_tab[exp_idx];
479
        exp_index1[i] = exp_idx;
480
        exp_index2[i] = exp_idx;
481
    }
482
    tmpbias = bias = num_bits;
483

    
484
    for (j = 1 ; j < q->numvector_size ; j++) {
485
        if (tmpbias + bias > 2*bits_left) {  /* ---> */
486
            int max = -999999;
487
            index=-1;
488
            for (i=0 ; i<q->total_subbands ; i++){
489
                if (exp_index1[i] < 7) {
490
                    v = (-2*exp_index1[i]) - quant_index_table[i] - 32;
491
                    if ( v >= max) {
492
                        max = v;
493
                        index = i;
494
                    }
495
                }
496
            }
497
            if(index==-1)break;
498
            tmp_categorize_array1[tmp_categorize_array1_idx++] = index;
499
            tmpbias -= expbits_tab[exp_index1[index]] -
500
                       expbits_tab[exp_index1[index]+1];
501
            ++exp_index1[index];
502
        } else {  /* <--- */
503
            int min = 999999;
504
            index=-1;
505
            for (i=0 ; i<q->total_subbands ; i++){
506
                if(exp_index2[i] > 0){
507
                    v = (-2*exp_index2[i])-quant_index_table[i];
508
                    if ( v < min) {
509
                        min = v;
510
                        index = i;
511
                    }
512
                }
513
            }
514
            if(index == -1)break;
515
            tmp_categorize_array2[tmp_categorize_array2_idx++] = index;
516
            tmpbias -= expbits_tab[exp_index2[index]] -
517
                       expbits_tab[exp_index2[index]-1];
518
            --exp_index2[index];
519
        }
520
    }
521

    
522
    for(i=0 ; i<q->total_subbands ; i++)
523
        category[i] = exp_index2[i];
524

    
525
    /* Concatenate the two arrays. */
526
    for(i=tmp_categorize_array2_idx-1 ; i >= 0; i--)
527
        category_index[category_index_size++] =  tmp_categorize_array2[i];
528

    
529
    for(i=0;i<tmp_categorize_array1_idx;i++)
530
        category_index[category_index_size++ ] =  tmp_categorize_array1[i];
531

    
532
    /* FIXME: mc_sich_ra8_20.rm triggers this, not sure with what we
533
       should fill the remaining bytes. */
534
    for(i=category_index_size;i<q->numvector_size;i++)
535
        category_index[i]=0;
536

    
537
}
538

    
539

    
540
/**
541
 * Expand the category vector.
542
 *
543
 * @param q                     pointer to the COOKContext
544
 * @param category              pointer to the category array
545
 * @param category_index        pointer to the category_index array
546
 */
547

    
548
static void inline expand_category(COOKContext *q, int* category,
549
                                   int* category_index){
550
    int i;
551
    for(i=0 ; i<q->num_vectors ; i++){
552
        ++category[category_index[i]];
553
    }
554
}
555

    
556
/**
557
 * The real requantization of the mltcoefs
558
 *
559
 * @param q                     pointer to the COOKContext
560
 * @param index                 index
561
 * @param band                  current subband
562
 * @param quant_value_table     pointer to the array
563
 * @param subband_coef_index    array of indexes to quant_centroid_tab
564
 * @param subband_coef_noise    use random noise instead of predetermined value
565
 * @param mlt_buffer            pointer to the mlt buffer
566
 */
567

    
568

    
569
static void scalar_dequant(COOKContext *q, int index, int band,
570
                           float* quant_value_table, int* subband_coef_index,
571
                           int* subband_coef_noise, float* mlt_buffer){
572
    int i;
573
    float f1;
574

    
575
    for(i=0 ; i<SUBBAND_SIZE ; i++) {
576
        if (subband_coef_index[i]) {
577
            if (subband_coef_noise[i]) {
578
                f1 = -quant_centroid_tab[index][subband_coef_index[i]];
579
            } else {
580
                f1 = quant_centroid_tab[index][subband_coef_index[i]];
581
            }
582
        } else {
583
            /* noise coding if subband_coef_noise[i] == 0 */
584
            q->random_state = q->random_state * 214013 + 2531011;    //typical RNG numbers
585
            f1 = randsign[(q->random_state/0x1000000)&1] * dither_tab[index]; //>>31
586
        }
587
        mlt_buffer[band*20+ i] = f1 * quant_value_table[band];
588
    }
589
}
590
/**
591
 * Unpack the subband_coef_index and subband_coef_noise vectors.
592
 *
593
 * @param q                     pointer to the COOKContext
594
 * @param category              pointer to the category array
595
 * @param subband_coef_index    array of indexes to quant_centroid_tab
596
 * @param subband_coef_noise    use random noise instead of predetermined value
597
 */
598

    
599
static int unpack_SQVH(COOKContext *q, int category, int* subband_coef_index,
600
                       int* subband_coef_noise) {
601
    int i,j;
602
    int vlc, vd ,tmp, result;
603
    int ub;
604
    int cb;
605

    
606
    vd = vd_tab[category];
607
    result = 0;
608
    for(i=0 ; i<vpr_tab[category] ; i++){
609
        ub = get_bits_count(&q->gb);
610
        vlc = get_vlc2(&q->gb, q->sqvh[category].table, q->sqvh[category].bits, 3);
611
        cb = get_bits_count(&q->gb);
612
        if (q->bits_per_subpacket < get_bits_count(&q->gb)){
613
            vlc = 0;
614
            result = 1;
615
        }
616
        for(j=vd-1 ; j>=0 ; j--){
617
            tmp = (vlc * invradix_tab[category])/0x100000;
618
            subband_coef_index[vd*i+j] = vlc - tmp * (kmax_tab[category]+1);
619
            vlc = tmp;
620
        }
621
        for(j=0 ; j<vd ; j++){
622
            if (subband_coef_index[i*vd + j]) {
623
                if(get_bits_count(&q->gb) < q->bits_per_subpacket){
624
                    subband_coef_noise[i*vd+j] = get_bits1(&q->gb);
625
                } else {
626
                    result=1;
627
                    subband_coef_noise[i*vd+j]=0;
628
                }
629
            } else {
630
                subband_coef_noise[i*vd+j]=0;
631
            }
632
        }
633
    }
634
    return result;
635
}
636

    
637

    
638
/**
639
 * Fill the mlt_buffer with mlt coefficients.
640
 *
641
 * @param q                 pointer to the COOKContext
642
 * @param category          pointer to the category array
643
 * @param quant_value_table pointer to the array
644
 * @param mlt_buffer        pointer to mlt coefficients
645
 */
646

    
647

    
648
static void decode_vectors(COOKContext* q, int* category,
649
                           float* quant_value_table, float* mlt_buffer){
650
    /* A zero in this table means that the subband coefficient is
651
       random noise coded. */
652
    int subband_coef_noise[SUBBAND_SIZE];
653
    /* A zero in this table means that the subband coefficient is a
654
       positive multiplicator. */
655
    int subband_coef_index[SUBBAND_SIZE];
656
    int band, j;
657
    int index=0;
658

    
659
    for(band=0 ; band<q->total_subbands ; band++){
660
        index = category[band];
661
        if(category[band] < 7){
662
            if(unpack_SQVH(q, category[band], subband_coef_index, subband_coef_noise)){
663
                index=7;
664
                for(j=0 ; j<q->total_subbands ; j++) category[band+j]=7;
665
            }
666
        }
667
        if(index==7) {
668
            memset(subband_coef_index, 0, sizeof(subband_coef_index));
669
            memset(subband_coef_noise, 0, sizeof(subband_coef_noise));
670
        }
671
        scalar_dequant(q, index, band, quant_value_table, subband_coef_index,
672
                       subband_coef_noise, mlt_buffer);
673
    }
674

    
675
    if(q->total_subbands*SUBBAND_SIZE >= q->samples_per_channel){
676
        return;
677
    }
678
}
679

    
680

    
681
/**
682
 * function for decoding mono data
683
 *
684
 * @param q                 pointer to the COOKContext
685
 * @param mlt_buffer1       pointer to left channel mlt coefficients
686
 * @param mlt_buffer2       pointer to right channel mlt coefficients
687
 */
688

    
689
static void mono_decode(COOKContext *q, float* mlt_buffer) {
690

    
691
    int category_index[128];
692
    float quant_value_table[102];
693
    int quant_index_table[102];
694
    int category[128];
695

    
696
    memset(&category, 0, 128*sizeof(int));
697
    memset(&quant_value_table, 0, 102*sizeof(int));
698
    memset(&category_index, 0, 128*sizeof(int));
699

    
700
    decode_envelope(q, quant_index_table);
701
    q->num_vectors = get_bits(&q->gb,q->numvector_bits);
702
    dequant_envelope(q, quant_index_table, quant_value_table);
703
    categorize(q, quant_index_table, category, category_index);
704
    expand_category(q, category, category_index);
705
    decode_vectors(q, category, quant_value_table, mlt_buffer);
706
}
707

    
708

    
709
/**
710
 * The modulated lapped transform, this takes transform coefficients
711
 * and transforms them into timedomain samples. This is done through
712
 * an FFT-based algorithm with pre- and postrotation steps.
713
 * A window and reorder step is also included.
714
 *
715
 * @param q                 pointer to the COOKContext
716
 * @param inbuffer          pointer to the mltcoefficients
717
 * @param outbuffer         pointer to the timedomain buffer
718
 * @param mlt_tmp           pointer to temporary storage space
719
 */
720

    
721
static void cook_imlt(COOKContext *q, float* inbuffer, float* outbuffer,
722
                      float* mlt_tmp){
723
    int i;
724

    
725
    /* prerotation */
726
    for(i=0 ; i<q->mlt_size ; i+=2){
727
        outbuffer[i] = (q->mlt_presin[i/2] * inbuffer[q->mlt_size-1-i]) +
728
                       (q->mlt_precos[i/2] * inbuffer[i]);
729
        outbuffer[i+1] = (q->mlt_precos[i/2] * inbuffer[q->mlt_size-1-i]) -
730
                         (q->mlt_presin[i/2] * inbuffer[i]);
731
    }
732

    
733
    /* FFT */
734
    ff_fft_permute(&q->fft_ctx, (FFTComplex *) outbuffer);
735
    ff_fft_calc (&q->fft_ctx, (FFTComplex *) outbuffer);
736

    
737
    /* postrotation */
738
    for(i=0 ; i<q->mlt_size ; i+=2){
739
        mlt_tmp[i] =               (q->mlt_postcos[(q->mlt_size-1-i)/2] * outbuffer[i+1]) +
740
                                   (q->mlt_postcos[i/2] * outbuffer[i]);
741
        mlt_tmp[q->mlt_size-1-i] = (q->mlt_postcos[(q->mlt_size-1-i)/2] * outbuffer[i]) -
742
                                   (q->mlt_postcos[i/2] * outbuffer[i+1]);
743
    }
744

    
745
    /* window and reorder */
746
    for(i=0 ; i<q->mlt_size/2 ; i++){
747
        outbuffer[i] = mlt_tmp[q->mlt_size/2-1-i] * q->mlt_window[i];
748
        outbuffer[q->mlt_size-1-i]= mlt_tmp[q->mlt_size/2-1-i] *
749
                                    q->mlt_window[q->mlt_size-1-i];
750
        outbuffer[q->mlt_size+i]= mlt_tmp[q->mlt_size/2+i] *
751
                                  q->mlt_window[q->mlt_size-1-i];
752
        outbuffer[2*q->mlt_size-1-i]= -(mlt_tmp[q->mlt_size/2+i] *
753
                                      q->mlt_window[i]);
754
    }
755
}
756

    
757

    
758
/**
759
 * the actual requantization of the timedomain samples
760
 *
761
 * @param q                 pointer to the COOKContext
762
 * @param buffer            pointer to the timedomain buffer
763
 * @param gain_index        index for the block multiplier
764
 * @param gain_index_next   index for the next block multiplier
765
 */
766

    
767
static void interpolate(COOKContext *q, float* buffer,
768
                        int gain_index, int gain_index_next){
769
    int i;
770
    float fc1, fc2;
771
    fc1 = q->pow2tab[gain_index+63];
772

    
773
    if(gain_index == gain_index_next){              //static gain
774
        for(i=0 ; i<q->gain_size_factor ; i++){
775
            buffer[i]*=fc1;
776
        }
777
        return;
778
    } else {                                        //smooth gain
779
        fc2 = q->gain_table[11 + (gain_index_next-gain_index)];
780
        for(i=0 ; i<q->gain_size_factor ; i++){
781
            buffer[i]*=fc1;
782
            fc1*=fc2;
783
        }
784
        return;
785
    }
786
}
787

    
788
/**
789
 * timedomain requantization of the timedomain samples
790
 *
791
 * @param q                 pointer to the COOKContext
792
 * @param buffer            pointer to the timedomain buffer
793
 * @param gain_now          current gain structure
794
 * @param gain_previous     previous gain structure
795
 */
796

    
797
static void gain_window(COOKContext *q, float* buffer, COOKgain* gain_now,
798
                        COOKgain* gain_previous){
799
    int i, index;
800
    int gain_index[9];
801
    int tmp_gain_index;
802

    
803
    gain_index[8]=0;
804
    index = gain_previous->size;
805
    for (i=7 ; i>=0 ; i--) {
806
        if(index && gain_previous->qidx_table1[index-1]==i) {
807
            gain_index[i] = gain_previous->qidx_table2[index-1];
808
            index--;
809
        } else {
810
            gain_index[i]=gain_index[i+1];
811
        }
812
    }
813
    /* This is applied to the to be previous data buffer. */
814
    for(i=0;i<8;i++){
815
        interpolate(q, &buffer[q->samples_per_channel+q->gain_size_factor*i],
816
                    gain_index[i], gain_index[i+1]);
817
    }
818

    
819
    tmp_gain_index = gain_index[0];
820
    index = gain_now->size;
821
    for (i=7 ; i>=0 ; i--) {
822
        if(index && gain_now->qidx_table1[index-1]==i) {
823
            gain_index[i]= gain_now->qidx_table2[index-1];
824
            index--;
825
        } else {
826
            gain_index[i]=gain_index[i+1];
827
        }
828
    }
829

    
830
    /* This is applied to the to be current block. */
831
    for(i=0;i<8;i++){
832
        interpolate(q, &buffer[i*q->gain_size_factor],
833
                    tmp_gain_index+gain_index[i],
834
                    tmp_gain_index+gain_index[i+1]);
835
    }
836
}
837

    
838

    
839
/**
840
 * mlt overlapping and buffer management
841
 *
842
 * @param q                 pointer to the COOKContext
843
 * @param buffer            pointer to the timedomain buffer
844
 * @param gain_now          current gain structure
845
 * @param gain_previous     previous gain structure
846
 * @param previous_buffer   pointer to the previous buffer to be used for overlapping
847
 *
848
 */
849

    
850
static void gain_compensate(COOKContext *q, float* buffer, COOKgain* gain_now,
851
                            COOKgain* gain_previous, float* previous_buffer) {
852
    int i;
853
    if((gain_now->size  || gain_previous->size)) {
854
        gain_window(q, buffer, gain_now, gain_previous);
855
    }
856

    
857
    /* Overlap with the previous block. */
858
    for(i=0 ; i<q->samples_per_channel ; i++) buffer[i]+=previous_buffer[i];
859

    
860
    /* Save away the current to be previous block. */
861
    memcpy(previous_buffer, buffer+q->samples_per_channel,
862
           sizeof(float)*q->samples_per_channel);
863
}
864

    
865

    
866
/**
867
 * function for getting the jointstereo coupling information
868
 *
869
 * @param q                 pointer to the COOKContext
870
 * @param decouple_tab      decoupling array
871
 *
872
 */
873

    
874
static void decouple_info(COOKContext *q, int* decouple_tab){
875
    int length, i;
876

    
877
    if(get_bits1(&q->gb)) {
878
        if(cplband[q->js_subband_start] > cplband[q->subbands-1]) return;
879

    
880
        length = cplband[q->subbands-1] - cplband[q->js_subband_start] + 1;
881
        for (i=0 ; i<length ; i++) {
882
            decouple_tab[cplband[q->js_subband_start] + i] = get_vlc2(&q->gb, q->ccpl.table, q->ccpl.bits, 2);
883
        }
884
        return;
885
    }
886

    
887
    if(cplband[q->js_subband_start] > cplband[q->subbands-1]) return;
888

    
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_bits(&q->gb, q->js_vlc_bits);
892
    }
893
    return;
894
}
895

    
896

    
897
/**
898
 * function for decoding joint stereo data
899
 *
900
 * @param q                 pointer to the COOKContext
901
 * @param mlt_buffer1       pointer to left channel mlt coefficients
902
 * @param mlt_buffer2       pointer to right channel mlt coefficients
903
 */
904

    
905
static void joint_decode(COOKContext *q, float* mlt_buffer1,
906
                         float* mlt_buffer2) {
907
    int i,j;
908
    int decouple_tab[SUBBAND_SIZE];
909
    float decode_buffer[1060];
910
    int idx, cpl_tmp,tmp_idx;
911
    float f1,f2;
912
    float* cplscale;
913

    
914
    memset(decouple_tab, 0, sizeof(decouple_tab));
915
    memset(decode_buffer, 0, sizeof(decode_buffer));
916

    
917
    /* Make sure the buffers are zeroed out. */
918
    memset(mlt_buffer1,0, 1024*sizeof(float));
919
    memset(mlt_buffer2,0, 1024*sizeof(float));
920
    decouple_info(q, decouple_tab);
921
    mono_decode(q, decode_buffer);
922

    
923
    /* The two channels are stored interleaved in decode_buffer. */
924
    for (i=0 ; i<q->js_subband_start ; i++) {
925
        for (j=0 ; j<SUBBAND_SIZE ; j++) {
926
            mlt_buffer1[i*20+j] = decode_buffer[i*40+j];
927
            mlt_buffer2[i*20+j] = decode_buffer[i*40+20+j];
928
        }
929
    }
930

    
931
    /* When we reach js_subband_start (the higher frequencies)
932
       the coefficients are stored in a coupling scheme. */
933
    idx = (1 << q->js_vlc_bits) - 1;
934
    for (i=q->js_subband_start ; i<q->subbands ; i++) {
935
        cpl_tmp = cplband[i];
936
        idx -=decouple_tab[cpl_tmp];
937
        cplscale = (float*)cplscales[q->js_vlc_bits-2];  //choose decoupler table
938
        f1 = cplscale[decouple_tab[cpl_tmp]];
939
        f2 = cplscale[idx-1];
940
        for (j=0 ; j<SUBBAND_SIZE ; j++) {
941
            tmp_idx = ((q->js_subband_start + i)*20)+j;
942
            mlt_buffer1[20*i + j] = f1 * decode_buffer[tmp_idx];
943
            mlt_buffer2[20*i + j] = f2 * decode_buffer[tmp_idx];
944
        }
945
        idx = (1 << q->js_vlc_bits) - 1;
946
    }
947
}
948

    
949
/**
950
 * Cook subpacket decoding. This function returns one decoded subpacket,
951
 * usually 1024 samples per channel.
952
 *
953
 * @param q                 pointer to the COOKContext
954
 * @param inbuffer          pointer to the inbuffer
955
 * @param sub_packet_size   subpacket size
956
 * @param outbuffer         pointer to the outbuffer
957
 * @param pos               the subpacket number in the frame
958
 */
959

    
960

    
961
static int decode_subpacket(COOKContext *q, uint8_t *inbuffer,
962
                            int sub_packet_size, int16_t *outbuffer) {
963
    int i,j;
964
    int value;
965
    float* tmp_ptr;
966

    
967
    /* packet dump */
968
//    for (i=0 ; i<sub_packet_size ; i++) {
969
//        av_log(NULL, AV_LOG_ERROR, "%02x", inbuffer[i]);
970
//    }
971
//    av_log(NULL, AV_LOG_ERROR, "\n");
972

    
973
    decode_bytes(inbuffer, q->decoded_bytes_buffer, sub_packet_size);
974
    init_get_bits(&q->gb, q->decoded_bytes_buffer, sub_packet_size*8);
975
    decode_gain_info(&q->gb, &q->gain_current);
976

    
977
    if(q->nb_channels==2 && q->joint_stereo==1){
978
        joint_decode(q, q->decode_buf_ptr[0], q->decode_buf_ptr[2]);
979

    
980
        /* Swap buffer pointers. */
981
        tmp_ptr = q->decode_buf_ptr[1];
982
        q->decode_buf_ptr[1] = q->decode_buf_ptr[0];
983
        q->decode_buf_ptr[0] = tmp_ptr;
984
        tmp_ptr = q->decode_buf_ptr[3];
985
        q->decode_buf_ptr[3] = q->decode_buf_ptr[2];
986
        q->decode_buf_ptr[2] = tmp_ptr;
987

    
988
        /* FIXME: Rethink the gainbuffer handling, maybe a rename?
989
           now/previous swap */
990
        q->gain_now_ptr = &q->gain_now;
991
        q->gain_previous_ptr = &q->gain_previous;
992
        for (i=0 ; i<q->nb_channels ; i++){
993

    
994
            cook_imlt(q, q->decode_buf_ptr[i*2], q->mono_mdct_output, q->mlt_tmp);
995
            gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
996
                            q->gain_previous_ptr, q->previous_buffer_ptr[0]);
997

    
998
            /* Swap out the previous buffer. */
999
            tmp_ptr = q->previous_buffer_ptr[0];
1000
            q->previous_buffer_ptr[0] = q->previous_buffer_ptr[1];
1001
            q->previous_buffer_ptr[1] = tmp_ptr;
1002

    
1003
            /* Clip and convert the floats to 16 bits. */
1004
            for (j=0 ; j<q->samples_per_frame ; j++){
1005
                value = lrintf(q->mono_mdct_output[j]);
1006
                if(value < -32768) value = -32768;
1007
                else if(value > 32767) value = 32767;
1008
                outbuffer[2*j+i] = value;
1009
            }
1010
        }
1011

    
1012
        memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain));
1013
        memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain));
1014

    
1015
    } else if (q->nb_channels==2 && q->joint_stereo==0) {
1016
            /* channel 0 */
1017
            mono_decode(q, q->decode_buf_ptr2[0]);
1018

    
1019
            tmp_ptr = q->decode_buf_ptr2[0];
1020
            q->decode_buf_ptr2[0] = q->decode_buf_ptr2[1];
1021
            q->decode_buf_ptr2[1] = tmp_ptr;
1022

    
1023
            memcpy(&q->gain_channel1[0], &q->gain_current ,sizeof(COOKgain));
1024
            q->gain_now_ptr = &q->gain_channel1[0];
1025
            q->gain_previous_ptr = &q->gain_channel1[1];
1026

    
1027
            cook_imlt(q, q->decode_buf_ptr2[0], q->mono_mdct_output,q->mlt_tmp);
1028
            gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
1029
                            q->gain_previous_ptr, q->mono_previous_buffer1);
1030

    
1031
            memcpy(&q->gain_channel1[1], &q->gain_channel1[0],sizeof(COOKgain));
1032

    
1033

    
1034
            for (j=0 ; j<q->samples_per_frame ; j++){
1035
                value = lrintf(q->mono_mdct_output[j]);
1036
                if(value < -32768) value = -32768;
1037
                else if(value > 32767) value = 32767;
1038
                outbuffer[2*j+1] = value;
1039
            }
1040

    
1041
            /* channel 1 */
1042
            //av_log(NULL,AV_LOG_ERROR,"bits = %d\n",get_bits_count(&q->gb));
1043
            init_get_bits(&q->gb, q->decoded_bytes_buffer, sub_packet_size*8+q->bits_per_subpacket);
1044

    
1045
            q->gain_now_ptr = &q->gain_channel2[0];
1046
            q->gain_previous_ptr = &q->gain_channel2[1];
1047

    
1048
            decode_gain_info(&q->gb, &q->gain_channel2[0]);
1049
            mono_decode(q, q->decode_buf_ptr[0]);
1050

    
1051
            tmp_ptr = q->decode_buf_ptr[0];
1052
            q->decode_buf_ptr[0] = q->decode_buf_ptr[1];
1053
            q->decode_buf_ptr[1] = tmp_ptr;
1054

    
1055
            cook_imlt(q, q->decode_buf_ptr[0], q->mono_mdct_output,q->mlt_tmp);
1056
            gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
1057
                            q->gain_previous_ptr, q->mono_previous_buffer2);
1058

    
1059
            /* Swap out the previous buffer. */
1060
            tmp_ptr = q->previous_buffer_ptr[0];
1061
            q->previous_buffer_ptr[0] = q->previous_buffer_ptr[1];
1062
            q->previous_buffer_ptr[1] = tmp_ptr;
1063

    
1064
            memcpy(&q->gain_channel2[1], &q->gain_channel2[0] ,sizeof(COOKgain));
1065

    
1066
            for (j=0 ; j<q->samples_per_frame ; j++){
1067
                value = lrintf(q->mono_mdct_output[j]);
1068
                if(value < -32768) value = -32768;
1069
                else if(value > 32767) value = 32767;
1070
                outbuffer[2*j] = value;
1071
            }
1072

    
1073
    } else {
1074
        mono_decode(q, q->decode_buf_ptr[0]);
1075

    
1076
        /* Swap buffer pointers. */
1077
        tmp_ptr = q->decode_buf_ptr[1];
1078
        q->decode_buf_ptr[1] = q->decode_buf_ptr[0];
1079
        q->decode_buf_ptr[0] = tmp_ptr;
1080

    
1081
        /* FIXME: Rethink the gainbuffer handling, maybe a rename?
1082
           now/previous swap */
1083
        q->gain_now_ptr = &q->gain_now;
1084
        q->gain_previous_ptr = &q->gain_previous;
1085

    
1086
        cook_imlt(q, q->decode_buf_ptr[0], q->mono_mdct_output,q->mlt_tmp);
1087
        gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
1088
                        q->gain_previous_ptr, q->mono_previous_buffer1);
1089

    
1090
        /* Clip and convert the floats to 16 bits */
1091
        for (j=0 ; j<q->samples_per_frame ; j++){
1092
            value = lrintf(q->mono_mdct_output[j]);
1093
            if(value < -32768) value = -32768;
1094
            else if(value > 32767) value = 32767;
1095
            outbuffer[j] = value;
1096
        }
1097
        memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain));
1098
        memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain));
1099
    }
1100
    return q->samples_per_frame * sizeof(int16_t);
1101
}
1102

    
1103

    
1104
/**
1105
 * Cook frame decoding
1106
 *
1107
 * @param avctx     pointer to the AVCodecContext
1108
 */
1109

    
1110
static int cook_decode_frame(AVCodecContext *avctx,
1111
            void *data, int *data_size,
1112
            uint8_t *buf, int buf_size) {
1113
    COOKContext *q = avctx->priv_data;
1114

    
1115
    if (buf_size < avctx->block_align)
1116
        return buf_size;
1117

    
1118
    *data_size = decode_subpacket(q, buf, avctx->block_align, data);
1119

    
1120
    return avctx->block_align;
1121
}
1122
#ifdef COOKDEBUG
1123
static void dump_cook_context(COOKContext *q, COOKextradata *e)
1124
{
1125
    //int i=0;
1126
#define PRINT(a,b) av_log(NULL,AV_LOG_ERROR," %s = %d\n", a, b);
1127
    av_log(NULL,AV_LOG_ERROR,"COOKextradata\n");
1128
    av_log(NULL,AV_LOG_ERROR,"cookversion=%x\n",e->cookversion);
1129
    if (e->cookversion > MONO_COOK2) {
1130
        PRINT("js_subband_start",e->js_subband_start);
1131
        PRINT("js_vlc_bits",e->js_vlc_bits);
1132
    }
1133
    av_log(NULL,AV_LOG_ERROR,"COOKContext\n");
1134
    PRINT("nb_channels",q->nb_channels);
1135
    PRINT("bit_rate",q->bit_rate);
1136
    PRINT("sample_rate",q->sample_rate);
1137
    PRINT("samples_per_channel",q->samples_per_channel);
1138
    PRINT("samples_per_frame",q->samples_per_frame);
1139
    PRINT("subbands",q->subbands);
1140
    PRINT("random_state",q->random_state);
1141
    PRINT("mlt_size",q->mlt_size);
1142
    PRINT("js_subband_start",q->js_subband_start);
1143
    PRINT("numvector_bits",q->numvector_bits);
1144
    PRINT("numvector_size",q->numvector_size);
1145
    PRINT("total_subbands",q->total_subbands);
1146
}
1147
#endif
1148
/**
1149
 * Cook initialization
1150
 *
1151
 * @param avctx     pointer to the AVCodecContext
1152
 */
1153

    
1154
static int cook_decode_init(AVCodecContext *avctx)
1155
{
1156
    COOKextradata *e = avctx->extradata;
1157
    COOKContext *q = avctx->priv_data;
1158

    
1159
    /* Take care of the codec specific extradata. */
1160
    if (avctx->extradata_size <= 0) {
1161
        av_log(NULL,AV_LOG_ERROR,"Necessary extradata missing!\n");
1162
        return -1;
1163
    } else {
1164
        /* 8 for mono, 16 for stereo, ? for multichannel
1165
           Swap to right endianness so we don't need to care later on. */
1166
        av_log(NULL,AV_LOG_DEBUG,"codecdata_length=%d\n",avctx->extradata_size);
1167
        if (avctx->extradata_size >= 8){
1168
            e->cookversion = be2me_32(e->cookversion);
1169
            e->samples_per_frame = be2me_16(e->samples_per_frame);
1170
            e->subbands = be2me_16(e->subbands);
1171
        }
1172
        if (avctx->extradata_size >= 16){
1173
            e->js_subband_start = be2me_16(e->js_subband_start);
1174
            e->js_vlc_bits = be2me_16(e->js_vlc_bits);
1175
        }
1176
    }
1177

    
1178
    /* Take data from the AVCodecContext (RM container). */
1179
    q->sample_rate = avctx->sample_rate;
1180
    q->nb_channels = avctx->channels;
1181
    q->bit_rate = avctx->bit_rate;
1182

    
1183
    /* Initialize state. */
1184
    q->random_state = 1;
1185

    
1186
    /* Initialize extradata related variables. */
1187
    q->samples_per_channel = e->samples_per_frame / q->nb_channels;
1188
    q->samples_per_frame = e->samples_per_frame;
1189
    q->subbands = e->subbands;
1190
    q->bits_per_subpacket = avctx->block_align * 8;
1191

    
1192
    /* Initialize default data states. */
1193
    q->js_subband_start = 0;
1194
    q->numvector_bits = 5;
1195
    q->total_subbands = q->subbands;
1196

    
1197
    /* Initialize version-dependent variables */
1198
    av_log(NULL,AV_LOG_DEBUG,"e->cookversion=%x\n",e->cookversion);
1199
    switch (e->cookversion) {
1200
        case MONO_COOK1:
1201
            if (q->nb_channels != 1) {
1202
                av_log(NULL,AV_LOG_ERROR,"Container channels != 1, report sample!\n");
1203
                return -1;
1204
            }
1205
            av_log(NULL,AV_LOG_DEBUG,"MONO_COOK1\n");
1206
            break;
1207
        case MONO_COOK2:
1208
            if (q->nb_channels != 1) {
1209
                q->joint_stereo = 0;
1210
                q->bits_per_subpacket = q->bits_per_subpacket/2;
1211
            }
1212
            av_log(NULL,AV_LOG_DEBUG,"MONO_COOK2\n");
1213
            break;
1214
        case JOINT_STEREO:
1215
            if (q->nb_channels != 2) {
1216
                av_log(NULL,AV_LOG_ERROR,"Container channels != 2, report sample!\n");
1217
                return -1;
1218
            }
1219
            av_log(NULL,AV_LOG_DEBUG,"JOINT_STEREO\n");
1220
            if (avctx->extradata_size >= 16){
1221
                q->total_subbands = q->subbands + e->js_subband_start;
1222
                q->js_subband_start = e->js_subband_start;
1223
                q->joint_stereo = 1;
1224
                q->js_vlc_bits = e->js_vlc_bits;
1225
            }
1226
            if (q->samples_per_channel > 256) {
1227
                q->numvector_bits++;   // q->numvector_bits  = 6
1228
            }
1229
            if (q->samples_per_channel > 512) {
1230
                q->numvector_bits++;   // q->numvector_bits  = 7
1231
            }
1232
            break;
1233
        case MC_COOK:
1234
            av_log(NULL,AV_LOG_ERROR,"MC_COOK not supported!\n");
1235
            return -1;
1236
            break;
1237
        default:
1238
            av_log(NULL,AV_LOG_ERROR,"Unknown Cook version, report sample!\n");
1239
            return -1;
1240
            break;
1241
    }
1242

    
1243
    /* Initialize variable relations */
1244
    q->mlt_size = q->samples_per_channel;
1245
    q->numvector_size = (1 << q->numvector_bits);
1246

    
1247
    /* Generate tables */
1248
    init_rootpow2table(q);
1249
    init_pow2table(q);
1250
    init_gain_table(q);
1251

    
1252
    if (init_cook_vlc_tables(q) != 0)
1253
        return -1;
1254

    
1255
    /* Pad the databuffer with FF_INPUT_BUFFER_PADDING_SIZE,
1256
       this is for the bitstreamreader. */
1257
    if ((q->decoded_bytes_buffer = av_mallocz((avctx->block_align+(4-avctx->block_align%4) + FF_INPUT_BUFFER_PADDING_SIZE)*sizeof(uint8_t)))  == NULL)
1258
        return -1;
1259

    
1260
    q->decode_buf_ptr[0] = q->decode_buffer_1;
1261
    q->decode_buf_ptr[1] = q->decode_buffer_2;
1262
    q->decode_buf_ptr[2] = q->decode_buffer_3;
1263
    q->decode_buf_ptr[3] = q->decode_buffer_4;
1264

    
1265
    q->decode_buf_ptr2[0] = q->decode_buffer_3;
1266
    q->decode_buf_ptr2[1] = q->decode_buffer_4;
1267

    
1268
    q->previous_buffer_ptr[0] = q->mono_previous_buffer1;
1269
    q->previous_buffer_ptr[1] = q->mono_previous_buffer2;
1270

    
1271
    /* Initialize transform. */
1272
    if ( init_cook_mlt(q) == 0 )
1273
        return -1;
1274

    
1275
    /* Try to catch some obviously faulty streams, othervise it might be exploitable */
1276
    if (q->total_subbands > 53) {
1277
        av_log(NULL,AV_LOG_ERROR,"total_subbands > 53, report sample!\n");
1278
        return -1;
1279
    }
1280
    if (((q->subbands > 34) || (q->js_subband_start > 19)) && (q->joint_stereo)) {
1281
        av_log(NULL,AV_LOG_ERROR,"subbands > 34 or js_subband_start > 19, report sample!\n");
1282
        return -1;
1283
    }
1284
    if (q->subbands > 50) {
1285
        av_log(NULL,AV_LOG_ERROR,"subbands > 50, report sample!\n");
1286
        return -1;
1287
    }
1288

    
1289
#ifdef COOKDEBUG
1290
    dump_cook_context(q,e);
1291
#endif
1292
    return 0;
1293
}
1294

    
1295

    
1296
AVCodec cook_decoder =
1297
{
1298
    .name = "cook",
1299
    .type = CODEC_TYPE_AUDIO,
1300
    .id = CODEC_ID_COOK,
1301
    .priv_data_size = sizeof(COOKContext),
1302
    .init = cook_decode_init,
1303
    .close = cook_decode_close,
1304
    .decode = cook_decode_frame,
1305
};