Statistics
| Branch: | Revision:

ffmpeg / libavcodec / cook.c @ 5902bdd8

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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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
#include "avcodec.h"
49
#include "bitstream.h"
50
#include "dsputil.h"
51

    
52
#include "cookdata.h"
53

    
54
/* the different Cook versions */
55
#define MONO_COOK1      0x1000001
56
#define MONO_COOK2      0x1000002
57
#define JOINT_STEREO    0x1000003
58
#define MC_COOK         0x2000000   //multichannel Cook, not supported
59

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

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

    
69
typedef struct __attribute__((__packed__)){
70
    /* codec data start */
71
    uint32_t cookversion;               //in network order, bigendian
72
    uint16_t samples_per_frame;         //amount of samples per frame per channel, bigendian
73
    uint16_t subbands;                  //amount of bands used in the frequency domain, bigendian
74
    /* Mono extradata ends here. */
75
    uint32_t unused;
76
    uint16_t js_subband_start;          //bigendian
77
    uint16_t js_vlc_bits;               //bigendian
78
    /* Stereo extradata ends here. */
79
} COOKextradata;
80

    
81

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

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

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

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

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

    
133
    /* data buffers */
134

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

    
148
/* debug functions */
149

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

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

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

    
178
#endif
179

    
180
/*************** init functions ***************/
181

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

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

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

    
212

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

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

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

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

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

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

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

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

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

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

    
273
/*************** init functions end ***********/
274

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

    
285
static inline void decode_bytes(uint8_t* inbuffer, uint8_t* out, int bytes){
286
    int i;
287
    uint32_t* buf = (uint32_t*) inbuffer;
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

    
296
    for(i=0 ; i<bytes/4 ; i++){
297
#ifdef WORDS_BIGENDIAN
298
        obuf[i] = 0x37c511f2^buf[i];
299
#else
300
        obuf[i] = 0xf211c537^buf[i];
301
#endif
302
    }
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(NULL,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->qidx_table1[i] = get_bits(gb,3);
359
        if (get_bits1(gb)) {
360
            gaininfo->qidx_table2[i] = get_bits(gb,4) - 7;  //convert to signed
361
        } else {
362
            gaininfo->qidx_table2[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->qidx_table1[index-1]==i) {
806
            gain_index[i] = gain_previous->qidx_table2[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->qidx_table1[index-1]==i) {
822
            gain_index[i]= gain_now->qidx_table2[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
 * Cook subpacket decoding. This function returns one decoded subpacket,
950
 * usually 1024 samples per channel.
951
 *
952
 * @param q                 pointer to the COOKContext
953
 * @param inbuffer          pointer to the inbuffer
954
 * @param sub_packet_size   subpacket size
955
 * @param outbuffer         pointer to the outbuffer
956
 */
957

    
958

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

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

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

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

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

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

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

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

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

    
1010
        memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain));
1011
        memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain));
1012

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

    
1017
            tmp_ptr = q->decode_buf_ptr2[0];
1018
            q->decode_buf_ptr2[0] = q->decode_buf_ptr2[1];
1019
            q->decode_buf_ptr2[1] = tmp_ptr;
1020

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

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

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

    
1031

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

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

    
1043
            q->gain_now_ptr = &q->gain_channel2[0];
1044
            q->gain_previous_ptr = &q->gain_channel2[1];
1045

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

    
1049
            tmp_ptr = q->decode_buf_ptr[0];
1050
            q->decode_buf_ptr[0] = q->decode_buf_ptr[1];
1051
            q->decode_buf_ptr[1] = tmp_ptr;
1052

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

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

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

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

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

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

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

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

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

    
1101

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

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

    
1113
    if (buf_size < avctx->block_align)
1114
        return buf_size;
1115

    
1116
    *data_size = decode_subpacket(q, buf, avctx->block_align, data);
1117

    
1118
    return avctx->block_align;
1119
}
1120

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

    
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->log2_numvector_size = 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->log2_numvector_size  = 6;
1228
            }
1229
            if (q->samples_per_channel > 512) {
1230
                q->log2_numvector_size  = 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->log2_numvector_size);
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

    
1256
    if(avctx->block_align >= UINT_MAX/2)
1257
        return -1;
1258

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

    
1264
    q->decode_buf_ptr[0] = q->decode_buffer_1;
1265
    q->decode_buf_ptr[1] = q->decode_buffer_2;
1266
    q->decode_buf_ptr[2] = q->decode_buffer_3;
1267
    q->decode_buf_ptr[3] = q->decode_buffer_4;
1268

    
1269
    q->decode_buf_ptr2[0] = q->decode_buffer_3;
1270
    q->decode_buf_ptr2[1] = q->decode_buffer_4;
1271

    
1272
    q->previous_buffer_ptr[0] = q->mono_previous_buffer1;
1273
    q->previous_buffer_ptr[1] = q->mono_previous_buffer2;
1274

    
1275
    /* Initialize transform. */
1276
    if ( init_cook_mlt(q) == 0 )
1277
        return -1;
1278

    
1279
    /* Try to catch some obviously faulty streams, othervise it might be exploitable */
1280
    if (q->total_subbands > 53) {
1281
        av_log(NULL,AV_LOG_ERROR,"total_subbands > 53, 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
    if ((q->samples_per_channel == 256) || (q->samples_per_channel == 512) || (q->samples_per_channel == 1024)) {
1289
    } else {
1290
        av_log(NULL,AV_LOG_ERROR,"unknown amount of samples_per_channel = %d, report sample!\n",q->samples_per_channel);
1291
        return -1;
1292
    }
1293

    
1294
#ifdef COOKDEBUG
1295
    dump_cook_context(q,e);
1296
#endif
1297
    return 0;
1298
}
1299

    
1300

    
1301
AVCodec cook_decoder =
1302
{
1303
    .name = "cook",
1304
    .type = CODEC_TYPE_AUDIO,
1305
    .id = CODEC_ID_COOK,
1306
    .priv_data_size = sizeof(COOKContext),
1307
    .init = cook_decode_init,
1308
    .close = cook_decode_close,
1309
    .decode = cook_decode_frame,
1310
};