Statistics
| Branch: | Revision:

ffmpeg / libavcodec / cook.c @ f66e4f5f

History | View | Annotate | Download (40.6 KB)

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
#include "common.h"
54
#include "bytestream.h"
55

    
56
#include "cookdata.h"
57

    
58
/* the different Cook versions */
59
#define MONO            0x1000001
60
#define STEREO          0x1000002
61
#define JOINT_STEREO    0x1000003
62
#define MC_COOK         0x2000000   //multichannel Cook, not supported
63

    
64
#define SUBBAND_SIZE    20
65
//#define COOKDEBUG
66

    
67
typedef struct {
68
    int     size;
69
    int     loccode[8];
70
    int     levcode[8];
71
} COOKgain;
72

    
73
typedef struct {
74
    GetBitContext       gb;
75
    /* stream data */
76
    int                 nb_channels;
77
    int                 joint_stereo;
78
    int                 bit_rate;
79
    int                 sample_rate;
80
    int                 samples_per_channel;
81
    int                 samples_per_frame;
82
    int                 subbands;
83
    int                 log2_numvector_size;
84
    int                 numvector_size;                //1 << log2_numvector_size;
85
    int                 js_subband_start;
86
    int                 total_subbands;
87
    int                 num_vectors;
88
    int                 bits_per_subpacket;
89
    int                 cookversion;
90
    /* states */
91
    int                 random_state;
92

    
93
    /* transform data */
94
    FFTContext          fft_ctx;
95
    DECLARE_ALIGNED_16(FFTSample, mlt_tmp[1024]);  /* temporary storage for imlt */
96
    float*              mlt_window;
97
    float*              mlt_precos;
98
    float*              mlt_presin;
99
    float*              mlt_postcos;
100
    int                 fft_size;
101
    int                 fft_order;
102
    int                 mlt_size;       //modulated lapped transform size
103

    
104
    /* gain buffers */
105
    COOKgain            *gain_ptr1[2];
106
    COOKgain            *gain_ptr2[2];
107
    COOKgain            gain_1;
108
    COOKgain            gain_2;
109
    COOKgain            gain_3;
110
    COOKgain            gain_4;
111

    
112
    /* VLC data */
113
    int                 js_vlc_bits;
114
    VLC                 envelope_quant_index[13];
115
    VLC                 sqvh[7];          //scalar quantization
116
    VLC                 ccpl;             //channel coupling
117

    
118
    /* generatable tables and related variables */
119
    int                 gain_size_factor;
120
    float               gain_table[23];
121
    float               pow2tab[127];
122
    float               rootpow2tab[127];
123

    
124
    /* data buffers */
125

    
126
    uint8_t*            decoded_bytes_buffer;
127
    DECLARE_ALIGNED_16(float,mono_mdct_output[2048]);
128
    float               mono_previous_buffer1[1024];
129
    float               mono_previous_buffer2[1024];
130
    float               decode_buffer_1[1024];
131
    float               decode_buffer_2[1024];
132
} COOKContext;
133

    
134
/* debug functions */
135

    
136
#ifdef COOKDEBUG
137
static void dump_float_table(float* table, int size, int delimiter) {
138
    int i=0;
139
    av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
140
    for (i=0 ; i<size ; i++) {
141
        av_log(NULL, AV_LOG_ERROR, "%5.1f, ", table[i]);
142
        if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
143
    }
144
}
145

    
146
static void dump_int_table(int* table, int size, int delimiter) {
147
    int i=0;
148
    av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
149
    for (i=0 ; i<size ; i++) {
150
        av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);
151
        if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
152
    }
153
}
154

    
155
static void dump_short_table(short* table, int size, int delimiter) {
156
    int i=0;
157
    av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
158
    for (i=0 ; i<size ; i++) {
159
        av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);
160
        if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
161
    }
162
}
163

    
164
#endif
165

    
166
/*************** init functions ***************/
167

    
168
/* table generator */
169
static void init_pow2table(COOKContext *q){
170
    int i;
171
    q->pow2tab[63] = 1.0;
172
    for (i=1 ; i<64 ; i++){
173
        q->pow2tab[63+i]=(float)((uint64_t)1<<i);
174
        q->pow2tab[63-i]=1.0/(float)((uint64_t)1<<i);
175
    }
176
}
177

    
178
/* table generator */
179
static void init_rootpow2table(COOKContext *q){
180
    int i;
181
    q->rootpow2tab[63] = 1.0;
182
    for (i=1 ; i<64 ; i++){
183
        q->rootpow2tab[63+i]=sqrt((float)((uint64_t)1<<i));
184
        q->rootpow2tab[63-i]=sqrt(1.0/(float)((uint64_t)1<<i));
185
    }
186
}
187

    
188
/* table generator */
189
static void init_gain_table(COOKContext *q) {
190
    int i;
191
    q->gain_size_factor = q->samples_per_channel/8;
192
    for (i=0 ; i<23 ; i++) {
193
        q->gain_table[i] = pow((double)q->pow2tab[i+52] ,
194
                               (1.0/(double)q->gain_size_factor));
195
    }
196
}
197

    
198

    
199
static int init_cook_vlc_tables(COOKContext *q) {
200
    int i, result;
201

    
202
    result = 0;
203
    for (i=0 ; i<13 ; i++) {
204
        result &= init_vlc (&q->envelope_quant_index[i], 9, 24,
205
            envelope_quant_index_huffbits[i], 1, 1,
206
            envelope_quant_index_huffcodes[i], 2, 2, 0);
207
    }
208
    av_log(NULL,AV_LOG_DEBUG,"sqvh VLC init\n");
209
    for (i=0 ; i<7 ; i++) {
210
        result &= init_vlc (&q->sqvh[i], vhvlcsize_tab[i], vhsize_tab[i],
211
            cvh_huffbits[i], 1, 1,
212
            cvh_huffcodes[i], 2, 2, 0);
213
    }
214

    
215
    if (q->nb_channels==2 && q->joint_stereo==1){
216
        result &= init_vlc (&q->ccpl, 6, (1<<q->js_vlc_bits)-1,
217
            ccpl_huffbits[q->js_vlc_bits-2], 1, 1,
218
            ccpl_huffcodes[q->js_vlc_bits-2], 2, 2, 0);
219
        av_log(NULL,AV_LOG_DEBUG,"Joint-stereo VLC used.\n");
220
    }
221

    
222
    av_log(NULL,AV_LOG_DEBUG,"VLC tables initialized.\n");
223
    return result;
224
}
225

    
226
static int init_cook_mlt(COOKContext *q) {
227
    int j;
228
    float alpha;
229

    
230
    /* Allocate the buffers, could be replaced with a static [512]
231
       array if needed. */
232
    q->mlt_size = q->samples_per_channel;
233
    q->mlt_window = av_malloc(sizeof(float)*q->mlt_size);
234
    q->mlt_precos = av_malloc(sizeof(float)*q->mlt_size/2);
235
    q->mlt_presin = av_malloc(sizeof(float)*q->mlt_size/2);
236
    q->mlt_postcos = av_malloc(sizeof(float)*q->mlt_size/2);
237

    
238
    /* Initialize the MLT window: simple sine window. */
239
    alpha = M_PI / (2.0 * (float)q->mlt_size);
240
    for(j=0 ; j<q->mlt_size ; j++) {
241
        q->mlt_window[j] = sin((j + 512.0/(float)q->mlt_size) * alpha);
242
    }
243

    
244
    /* pre/post twiddle factors */
245
    for (j=0 ; j<q->mlt_size/2 ; j++){
246
        q->mlt_precos[j] = cos( ((j+0.25)*M_PI)/q->mlt_size);
247
        q->mlt_presin[j] = sin( ((j+0.25)*M_PI)/q->mlt_size);
248
        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
249
    }
250

    
251
    /* Initialize the FFT. */
252
    ff_fft_init(&q->fft_ctx, av_log2(q->mlt_size)-1, 0);
253
    av_log(NULL,AV_LOG_DEBUG,"FFT initialized, order = %d.\n",
254
           av_log2(q->samples_per_channel)-1);
255

    
256
    return (int)(q->mlt_window && q->mlt_precos && q->mlt_presin && q->mlt_postcos);
257
}
258

    
259
/*************** init functions end ***********/
260

    
261
/**
262
 * Cook indata decoding, every 32 bits are XORed with 0x37c511f2.
263
 * Why? No idea, some checksum/error detection method maybe.
264
 *
265
 * Out buffer size: extra bytes are needed to cope with
266
 * padding/missalignment.
267
 * Subpackets passed to the decoder can contain two, consecutive
268
 * half-subpackets, of identical but arbitrary size.
269
 *          1234 1234 1234 1234  extraA extraB
270
 * Case 1:  AAAA BBBB              0      0
271
 * Case 2:  AAAA ABBB BB--         3      3
272
 * Case 3:  AAAA AABB BBBB         2      2
273
 * Case 4:  AAAA AAAB BBBB BB--    1      5
274
 *
275
 * Nice way to waste CPU cycles.
276
 *
277
 * @param inbuffer  pointer to byte array of indata
278
 * @param out       pointer to byte array of outdata
279
 * @param bytes     number of bytes
280
 */
281
#define DECODE_BYTES_PAD1(bytes) (3 - ((bytes)+3) % 4)
282
#define DECODE_BYTES_PAD2(bytes) ((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes)))
283

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

    
295
    off = (int)((long)inbuffer & 3);
296
    buf = (uint32_t*) (inbuffer - off);
297
    c = be2me_32((0x37c511f2 >> (off*8)) | (0x37c511f2 << (32-(off*8))));
298
    bytes += 3 + off;
299
    for (i = 0; i < bytes/4; i++)
300
        obuf[i] = c ^ buf[i];
301

    
302
    return off;
303
}
304

    
305
/**
306
 * Cook uninit
307
 */
308

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

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

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

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

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

    
338
    return 0;
339
}
340

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

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

    
351
    while (get_bits1(gb)) {}
352

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
447
    bias=-32;
448

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

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

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

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

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

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

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

    
536
}
537

    
538

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

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

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

    
567

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

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

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

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

    
636

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

    
646

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

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

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

    
679

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

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

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

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

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

    
707

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

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

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

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

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

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

    
756

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

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

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

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

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

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

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

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

    
837

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

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

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

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

    
864

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

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

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

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

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

    
888
    length = cplband[q->subbands-1] - cplband[q->js_subband_start] + 1;
889
    for (i=0 ; i<length ; i++) {
890
       decouple_tab[cplband[q->js_subband_start] + i] = get_bits(&q->gb, q->js_vlc_bits);
891
    }
892
    return;
893
}
894

    
895

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

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

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

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

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

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

    
948
/**
949
 * First part of subpacket decoding:
950
 *  decode raw stream bytes and read gain info.
951
 *
952
 * @param q                 pointer to the COOKContext
953
 * @param inbuffer          pointer to raw stream data
954
 * @param gain_ptr          array of current/prev gain pointers
955
 */
956

    
957
static inline void
958
decode_bytes_and_gain(COOKContext *q, uint8_t *inbuffer,
959
                      COOKgain *gain_ptr[])
960
{
961
    int offset;
962

    
963
    offset = decode_bytes(inbuffer, q->decoded_bytes_buffer,
964
                          q->bits_per_subpacket/8);
965
    init_get_bits(&q->gb, q->decoded_bytes_buffer + offset,
966
                  q->bits_per_subpacket);
967
    decode_gain_info(&q->gb, gain_ptr[0]);
968

    
969
    /* Swap current and previous gains */
970
    FFSWAP(COOKgain *, gain_ptr[0], gain_ptr[1]);
971
}
972

    
973
/**
974
 * Final part of subpacket decoding:
975
 *  Apply modulated lapped transform, gain compensation,
976
 *  clip and convert to integer.
977
 *
978
 * @param q                 pointer to the COOKContext
979
 * @param decode_buffer     pointer to the mlt coefficients
980
 * @param gain_ptr          array of current/prev gain pointers
981
 * @param previous_buffer   pointer to the previous buffer to be used for overlapping
982
 * @param out               pointer to the output buffer
983
 * @param chan              0: left or single channel, 1: right channel
984
 */
985

    
986
static inline void
987
mlt_compensate_output(COOKContext *q, float *decode_buffer,
988
                      COOKgain *gain_ptr[], float *previous_buffer,
989
                      int16_t *out, int chan)
990
{
991
    int j;
992

    
993
    cook_imlt(q, decode_buffer, q->mono_mdct_output, q->mlt_tmp);
994
    gain_compensate(q, q->mono_mdct_output, gain_ptr[0],
995
                    gain_ptr[1], previous_buffer);
996

    
997
    /* Clip and convert floats to 16 bits.
998
     */
999
    for (j = 0; j < q->samples_per_channel; j++) {
1000
        out[chan + q->nb_channels * j] =
1001
          av_clip(lrintf(q->mono_mdct_output[j]), -32768, 32767);
1002
    }
1003
}
1004

    
1005

    
1006
/**
1007
 * Cook subpacket decoding. This function returns one decoded subpacket,
1008
 * usually 1024 samples per channel.
1009
 *
1010
 * @param q                 pointer to the COOKContext
1011
 * @param inbuffer          pointer to the inbuffer
1012
 * @param sub_packet_size   subpacket size
1013
 * @param outbuffer         pointer to the outbuffer
1014
 */
1015

    
1016

    
1017
static int decode_subpacket(COOKContext *q, uint8_t *inbuffer,
1018
                            int sub_packet_size, int16_t *outbuffer) {
1019
    /* packet dump */
1020
//    for (i=0 ; i<sub_packet_size ; i++) {
1021
//        av_log(NULL, AV_LOG_ERROR, "%02x", inbuffer[i]);
1022
//    }
1023
//    av_log(NULL, AV_LOG_ERROR, "\n");
1024

    
1025
    decode_bytes_and_gain(q, inbuffer, q->gain_ptr1);
1026

    
1027
    if (q->joint_stereo) {
1028
        joint_decode(q, q->decode_buffer_1, q->decode_buffer_2);
1029
    } else {
1030
        mono_decode(q, q->decode_buffer_1);
1031

    
1032
        if (q->nb_channels == 2) {
1033
            decode_bytes_and_gain(q, inbuffer + sub_packet_size/2,
1034
                                  q->gain_ptr2);
1035
            mono_decode(q, q->decode_buffer_2);
1036
        }
1037
    }
1038

    
1039
    mlt_compensate_output(q, q->decode_buffer_1, q->gain_ptr1,
1040
                          q->mono_previous_buffer1, outbuffer, 0);
1041

    
1042
    if (q->nb_channels == 2) {
1043
        if (q->joint_stereo) {
1044
            mlt_compensate_output(q, q->decode_buffer_2, q->gain_ptr1,
1045
                                  q->mono_previous_buffer2, outbuffer, 1);
1046
        } else {
1047
            mlt_compensate_output(q, q->decode_buffer_2, q->gain_ptr2,
1048
                                  q->mono_previous_buffer2, outbuffer, 1);
1049
        }
1050
    }
1051
    return q->samples_per_frame * sizeof(int16_t);
1052
}
1053

    
1054

    
1055
/**
1056
 * Cook frame decoding
1057
 *
1058
 * @param avctx     pointer to the AVCodecContext
1059
 */
1060

    
1061
static int cook_decode_frame(AVCodecContext *avctx,
1062
            void *data, int *data_size,
1063
            uint8_t *buf, int buf_size) {
1064
    COOKContext *q = avctx->priv_data;
1065

    
1066
    if (buf_size < avctx->block_align)
1067
        return buf_size;
1068

    
1069
    *data_size = decode_subpacket(q, buf, avctx->block_align, data);
1070

    
1071
    return avctx->block_align;
1072
}
1073

    
1074
#ifdef COOKDEBUG
1075
static void dump_cook_context(COOKContext *q)
1076
{
1077
    //int i=0;
1078
#define PRINT(a,b) av_log(NULL,AV_LOG_ERROR," %s = %d\n", a, b);
1079
    av_log(NULL,AV_LOG_ERROR,"COOKextradata\n");
1080
    av_log(NULL,AV_LOG_ERROR,"cookversion=%x\n",q->cookversion);
1081
    if (q->cookversion > STEREO) {
1082
        PRINT("js_subband_start",q->js_subband_start);
1083
        PRINT("js_vlc_bits",q->js_vlc_bits);
1084
    }
1085
    av_log(NULL,AV_LOG_ERROR,"COOKContext\n");
1086
    PRINT("nb_channels",q->nb_channels);
1087
    PRINT("bit_rate",q->bit_rate);
1088
    PRINT("sample_rate",q->sample_rate);
1089
    PRINT("samples_per_channel",q->samples_per_channel);
1090
    PRINT("samples_per_frame",q->samples_per_frame);
1091
    PRINT("subbands",q->subbands);
1092
    PRINT("random_state",q->random_state);
1093
    PRINT("mlt_size",q->mlt_size);
1094
    PRINT("js_subband_start",q->js_subband_start);
1095
    PRINT("log2_numvector_size",q->log2_numvector_size);
1096
    PRINT("numvector_size",q->numvector_size);
1097
    PRINT("total_subbands",q->total_subbands);
1098
}
1099
#endif
1100

    
1101
/**
1102
 * Cook initialization
1103
 *
1104
 * @param avctx     pointer to the AVCodecContext
1105
 */
1106

    
1107
static int cook_decode_init(AVCodecContext *avctx)
1108
{
1109
    COOKContext *q = avctx->priv_data;
1110
    uint8_t *edata_ptr = avctx->extradata;
1111

    
1112
    /* Take care of the codec specific extradata. */
1113
    if (avctx->extradata_size <= 0) {
1114
        av_log(avctx,AV_LOG_ERROR,"Necessary extradata missing!\n");
1115
        return -1;
1116
    } else {
1117
        /* 8 for mono, 16 for stereo, ? for multichannel
1118
           Swap to right endianness so we don't need to care later on. */
1119
        av_log(avctx,AV_LOG_DEBUG,"codecdata_length=%d\n",avctx->extradata_size);
1120
        if (avctx->extradata_size >= 8){
1121
            q->cookversion = bytestream_get_be32(&edata_ptr);
1122
            q->samples_per_frame =  bytestream_get_be16(&edata_ptr);
1123
            q->subbands = bytestream_get_be16(&edata_ptr);
1124
        }
1125
        if (avctx->extradata_size >= 16){
1126
            bytestream_get_be32(&edata_ptr);    //Unknown unused
1127
            q->js_subband_start = bytestream_get_be16(&edata_ptr);
1128
            q->js_vlc_bits = bytestream_get_be16(&edata_ptr);
1129
        }
1130
    }
1131

    
1132
    /* Take data from the AVCodecContext (RM container). */
1133
    q->sample_rate = avctx->sample_rate;
1134
    q->nb_channels = avctx->channels;
1135
    q->bit_rate = avctx->bit_rate;
1136

    
1137
    /* Initialize state. */
1138
    q->random_state = 1;
1139

    
1140
    /* Initialize extradata related variables. */
1141
    q->samples_per_channel = q->samples_per_frame / q->nb_channels;
1142
    q->bits_per_subpacket = avctx->block_align * 8;
1143

    
1144
    /* Initialize default data states. */
1145
    q->log2_numvector_size = 5;
1146
    q->total_subbands = q->subbands;
1147

    
1148
    /* Initialize version-dependent variables */
1149
    av_log(NULL,AV_LOG_DEBUG,"q->cookversion=%x\n",q->cookversion);
1150
    q->joint_stereo = 0;
1151
    switch (q->cookversion) {
1152
        case MONO:
1153
            if (q->nb_channels != 1) {
1154
                av_log(avctx,AV_LOG_ERROR,"Container channels != 1, report sample!\n");
1155
                return -1;
1156
            }
1157
            av_log(avctx,AV_LOG_DEBUG,"MONO\n");
1158
            break;
1159
        case STEREO:
1160
            if (q->nb_channels != 1) {
1161
                q->bits_per_subpacket = q->bits_per_subpacket/2;
1162
            }
1163
            av_log(avctx,AV_LOG_DEBUG,"STEREO\n");
1164
            break;
1165
        case JOINT_STEREO:
1166
            if (q->nb_channels != 2) {
1167
                av_log(avctx,AV_LOG_ERROR,"Container channels != 2, report sample!\n");
1168
                return -1;
1169
            }
1170
            av_log(avctx,AV_LOG_DEBUG,"JOINT_STEREO\n");
1171
            if (avctx->extradata_size >= 16){
1172
                q->total_subbands = q->subbands + q->js_subband_start;
1173
                q->joint_stereo = 1;
1174
            }
1175
            if (q->samples_per_channel > 256) {
1176
                q->log2_numvector_size  = 6;
1177
            }
1178
            if (q->samples_per_channel > 512) {
1179
                q->log2_numvector_size  = 7;
1180
            }
1181
            break;
1182
        case MC_COOK:
1183
            av_log(avctx,AV_LOG_ERROR,"MC_COOK not supported!\n");
1184
            return -1;
1185
            break;
1186
        default:
1187
            av_log(avctx,AV_LOG_ERROR,"Unknown Cook version, report sample!\n");
1188
            return -1;
1189
            break;
1190
    }
1191

    
1192
    /* Initialize variable relations */
1193
    q->mlt_size = q->samples_per_channel;
1194
    q->numvector_size = (1 << q->log2_numvector_size);
1195

    
1196
    /* Generate tables */
1197
    init_rootpow2table(q);
1198
    init_pow2table(q);
1199
    init_gain_table(q);
1200

    
1201
    if (init_cook_vlc_tables(q) != 0)
1202
        return -1;
1203

    
1204

    
1205
    if(avctx->block_align >= UINT_MAX/2)
1206
        return -1;
1207

    
1208
    /* Pad the databuffer with:
1209
       DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(),
1210
       FF_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */
1211
    if (q->nb_channels==2 && q->joint_stereo==0) {
1212
        q->decoded_bytes_buffer =
1213
          av_mallocz(avctx->block_align/2
1214
                     + DECODE_BYTES_PAD2(avctx->block_align/2)
1215
                     + FF_INPUT_BUFFER_PADDING_SIZE);
1216
    } else {
1217
        q->decoded_bytes_buffer =
1218
          av_mallocz(avctx->block_align
1219
                     + DECODE_BYTES_PAD1(avctx->block_align)
1220
                     + FF_INPUT_BUFFER_PADDING_SIZE);
1221
    }
1222
    if (q->decoded_bytes_buffer == NULL)
1223
        return -1;
1224

    
1225
    q->gain_ptr1[0] = &q->gain_1;
1226
    q->gain_ptr1[1] = &q->gain_2;
1227
    q->gain_ptr2[0] = &q->gain_3;
1228
    q->gain_ptr2[1] = &q->gain_4;
1229

    
1230
    /* Initialize transform. */
1231
    if ( init_cook_mlt(q) == 0 )
1232
        return -1;
1233

    
1234
    /* Try to catch some obviously faulty streams, othervise it might be exploitable */
1235
    if (q->total_subbands > 53) {
1236
        av_log(avctx,AV_LOG_ERROR,"total_subbands > 53, report sample!\n");
1237
        return -1;
1238
    }
1239
    if (q->subbands > 50) {
1240
        av_log(avctx,AV_LOG_ERROR,"subbands > 50, report sample!\n");
1241
        return -1;
1242
    }
1243
    if ((q->samples_per_channel == 256) || (q->samples_per_channel == 512) || (q->samples_per_channel == 1024)) {
1244
    } else {
1245
        av_log(avctx,AV_LOG_ERROR,"unknown amount of samples_per_channel = %d, report sample!\n",q->samples_per_channel);
1246
        return -1;
1247
    }
1248
    if ((q->js_vlc_bits > 6) || (q->js_vlc_bits < 0)) {
1249
        av_log(avctx,AV_LOG_ERROR,"q->js_vlc_bits = %d, only >= 0 and <= 6 allowed!\n",q->js_vlc_bits);
1250
        return -1;
1251
    }
1252

    
1253
#ifdef COOKDEBUG
1254
    dump_cook_context(q);
1255
#endif
1256
    return 0;
1257
}
1258

    
1259

    
1260
AVCodec cook_decoder =
1261
{
1262
    .name = "cook",
1263
    .type = CODEC_TYPE_AUDIO,
1264
    .id = CODEC_ID_COOK,
1265
    .priv_data_size = sizeof(COOKContext),
1266
    .init = cook_decode_init,
1267
    .close = cook_decode_close,
1268
    .decode = cook_decode_frame,
1269
};