Statistics
| Branch: | Revision:

ffmpeg / libavcodec / cook.c @ 2029f312

History | View | Annotate | Download (35.3 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. Bastardization of the G.722.1 standard.
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 "bytestream.h"
54
#include "random.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 *now;
69
    int *previous;
70
} cook_gains;
71

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

    
92
    /* transform data */
93
    MDCTContext         mdct_ctx;
94
    DECLARE_ALIGNED_16(FFTSample, mdct_tmp[1024]);  /* temporary storage for imlt */
95
    float*              mlt_window;
96

    
97
    /* gain buffers */
98
    cook_gains          gains1;
99
    cook_gains          gains2;
100
    int                 gain_1[9];
101
    int                 gain_2[9];
102
    int                 gain_3[9];
103
    int                 gain_4[9];
104

    
105
    /* VLC data */
106
    int                 js_vlc_bits;
107
    VLC                 envelope_quant_index[13];
108
    VLC                 sqvh[7];          //scalar quantization
109
    VLC                 ccpl;             //channel coupling
110

    
111
    /* generatable tables and related variables */
112
    int                 gain_size_factor;
113
    float               gain_table[23];
114
    float               pow2tab[127];
115
    float               rootpow2tab[127];
116

    
117
    /* data buffers */
118

    
119
    uint8_t*            decoded_bytes_buffer;
120
    DECLARE_ALIGNED_16(float,mono_mdct_output[2048]);
121
    float               mono_previous_buffer1[1024];
122
    float               mono_previous_buffer2[1024];
123
    float               decode_buffer_1[1024];
124
    float               decode_buffer_2[1024];
125
} COOKContext;
126

    
127
/* debug functions */
128

    
129
#ifdef COOKDEBUG
130
static void dump_float_table(float* table, int size, int delimiter) {
131
    int i=0;
132
    av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
133
    for (i=0 ; i<size ; i++) {
134
        av_log(NULL, AV_LOG_ERROR, "%5.1f, ", table[i]);
135
        if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
136
    }
137
}
138

    
139
static void dump_int_table(int* table, int size, int delimiter) {
140
    int i=0;
141
    av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
142
    for (i=0 ; i<size ; i++) {
143
        av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);
144
        if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
145
    }
146
}
147

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

    
157
#endif
158

    
159
/*************** init functions ***************/
160

    
161
/* table generator */
162
static void init_pow2table(COOKContext *q){
163
    int i;
164
    q->pow2tab[63] = 1.0;
165
    for (i=1 ; i<64 ; i++){
166
        q->pow2tab[63+i]=(float)((uint64_t)1<<i);
167
        q->pow2tab[63-i]=1.0/(float)((uint64_t)1<<i);
168
    }
169
}
170

    
171
/* table generator */
172
static void init_rootpow2table(COOKContext *q){
173
    int i;
174
    q->rootpow2tab[63] = 1.0;
175
    for (i=1 ; i<64 ; i++){
176
        q->rootpow2tab[63+i]=sqrt((float)((uint64_t)1<<i));
177
        q->rootpow2tab[63-i]=sqrt(1.0/(float)((uint64_t)1<<i));
178
    }
179
}
180

    
181
/* table generator */
182
static void init_gain_table(COOKContext *q) {
183
    int i;
184
    q->gain_size_factor = q->samples_per_channel/8;
185
    for (i=0 ; i<23 ; i++) {
186
        q->gain_table[i] = pow((double)q->pow2tab[i+52] ,
187
                               (1.0/(double)q->gain_size_factor));
188
    }
189
}
190

    
191

    
192
static int init_cook_vlc_tables(COOKContext *q) {
193
    int i, result;
194

    
195
    result = 0;
196
    for (i=0 ; i<13 ; i++) {
197
        result |= init_vlc (&q->envelope_quant_index[i], 9, 24,
198
            envelope_quant_index_huffbits[i], 1, 1,
199
            envelope_quant_index_huffcodes[i], 2, 2, 0);
200
    }
201
    av_log(NULL,AV_LOG_DEBUG,"sqvh VLC init\n");
202
    for (i=0 ; i<7 ; i++) {
203
        result |= init_vlc (&q->sqvh[i], vhvlcsize_tab[i], vhsize_tab[i],
204
            cvh_huffbits[i], 1, 1,
205
            cvh_huffcodes[i], 2, 2, 0);
206
    }
207

    
208
    if (q->nb_channels==2 && q->joint_stereo==1){
209
        result |= init_vlc (&q->ccpl, 6, (1<<q->js_vlc_bits)-1,
210
            ccpl_huffbits[q->js_vlc_bits-2], 1, 1,
211
            ccpl_huffcodes[q->js_vlc_bits-2], 2, 2, 0);
212
        av_log(NULL,AV_LOG_DEBUG,"Joint-stereo VLC used.\n");
213
    }
214

    
215
    av_log(NULL,AV_LOG_DEBUG,"VLC tables initialized.\n");
216
    return result;
217
}
218

    
219
static int init_cook_mlt(COOKContext *q) {
220
    int j;
221
    float alpha;
222
    int mlt_size = q->samples_per_channel;
223

    
224
    if ((q->mlt_window = av_malloc(sizeof(float)*mlt_size)) == 0)
225
      return -1;
226

    
227
    /* Initialize the MLT window: simple sine window. */
228
    alpha = M_PI / (2.0 * (float)mlt_size);
229
    for(j=0 ; j<mlt_size ; j++)
230
        q->mlt_window[j] = sin((j + 0.5) * alpha) * sqrt(2.0 / q->samples_per_channel);
231

    
232
    /* Initialize the MDCT. */
233
    if (ff_mdct_init(&q->mdct_ctx, av_log2(mlt_size)+1, 1)) {
234
      av_free(q->mlt_window);
235
      return -1;
236
    }
237
    av_log(NULL,AV_LOG_DEBUG,"MDCT initialized, order = %d.\n",
238
           av_log2(mlt_size)+1);
239

    
240
    return 0;
241
}
242

    
243
/*************** init functions end ***********/
244

    
245
/**
246
 * Cook indata decoding, every 32 bits are XORed with 0x37c511f2.
247
 * Why? No idea, some checksum/error detection method maybe.
248
 *
249
 * Out buffer size: extra bytes are needed to cope with
250
 * padding/missalignment.
251
 * Subpackets passed to the decoder can contain two, consecutive
252
 * half-subpackets, of identical but arbitrary size.
253
 *          1234 1234 1234 1234  extraA extraB
254
 * Case 1:  AAAA BBBB              0      0
255
 * Case 2:  AAAA ABBB BB--         3      3
256
 * Case 3:  AAAA AABB BBBB         2      2
257
 * Case 4:  AAAA AAAB BBBB BB--    1      5
258
 *
259
 * Nice way to waste CPU cycles.
260
 *
261
 * @param inbuffer  pointer to byte array of indata
262
 * @param out       pointer to byte array of outdata
263
 * @param bytes     number of bytes
264
 */
265
#define DECODE_BYTES_PAD1(bytes) (3 - ((bytes)+3) % 4)
266
#define DECODE_BYTES_PAD2(bytes) ((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes)))
267

    
268
static inline int decode_bytes(uint8_t* inbuffer, uint8_t* out, int bytes){
269
    int i, off;
270
    uint32_t c;
271
    uint32_t* buf;
272
    uint32_t* obuf = (uint32_t*) out;
273
    /* FIXME: 64 bit platforms would be able to do 64 bits at a time.
274
     * I'm too lazy though, should be something like
275
     * for(i=0 ; i<bitamount/64 ; i++)
276
     *     (int64_t)out[i] = 0x37c511f237c511f2^be2me_64(int64_t)in[i]);
277
     * Buffer alignment needs to be checked. */
278

    
279
    off = (int)((long)inbuffer & 3);
280
    buf = (uint32_t*) (inbuffer - off);
281
    c = be2me_32((0x37c511f2 >> (off*8)) | (0x37c511f2 << (32-(off*8))));
282
    bytes += 3 + off;
283
    for (i = 0; i < bytes/4; i++)
284
        obuf[i] = c ^ buf[i];
285

    
286
    return off;
287
}
288

    
289
/**
290
 * Cook uninit
291
 */
292

    
293
static int cook_decode_close(AVCodecContext *avctx)
294
{
295
    int i;
296
    COOKContext *q = avctx->priv_data;
297
    av_log(avctx,AV_LOG_DEBUG, "Deallocating memory.\n");
298

    
299
    /* Free allocated memory buffers. */
300
    av_free(q->mlt_window);
301
    av_free(q->decoded_bytes_buffer);
302

    
303
    /* Free the transform. */
304
    ff_mdct_end(&q->mdct_ctx);
305

    
306
    /* Free the VLC tables. */
307
    for (i=0 ; i<13 ; i++) {
308
        free_vlc(&q->envelope_quant_index[i]);
309
    }
310
    for (i=0 ; i<7 ; i++) {
311
        free_vlc(&q->sqvh[i]);
312
    }
313
    if(q->nb_channels==2 && q->joint_stereo==1 ){
314
        free_vlc(&q->ccpl);
315
    }
316

    
317
    av_log(NULL,AV_LOG_DEBUG,"Memory deallocated.\n");
318

    
319
    return 0;
320
}
321

    
322
/**
323
 * Fill the gain array for the timedomain quantization.
324
 *
325
 * @param q                 pointer to the COOKContext
326
 * @param gaininfo[9]       array of gain indices
327
 */
328

    
329
static void decode_gain_info(GetBitContext *gb, int *gaininfo)
330
{
331
    int i, n;
332

    
333
    while (get_bits1(gb)) {}
334
    n = get_bits_count(gb) - 1;     //amount of elements*2 to update
335

    
336
    i = 0;
337
    while (n--) {
338
        int index = get_bits(gb, 3);
339
        int gain = get_bits1(gb) ? get_bits(gb, 4) - 7 : -1;
340

    
341
        while (i <= index) gaininfo[i++] = gain;
342
    }
343
    while (i <= 8) gaininfo[i++] = 0;
344
}
345

    
346
/**
347
 * Create the quant index table needed for the envelope.
348
 *
349
 * @param q                 pointer to the COOKContext
350
 * @param quant_index_table pointer to the array
351
 */
352

    
353
static void decode_envelope(COOKContext *q, int* quant_index_table) {
354
    int i,j, vlc_index;
355

    
356
    quant_index_table[0]= get_bits(&q->gb,6) - 6;       //This is used later in categorize
357

    
358
    for (i=1 ; i < q->total_subbands ; i++){
359
        vlc_index=i;
360
        if (i >= q->js_subband_start * 2) {
361
            vlc_index-=q->js_subband_start;
362
        } else {
363
            vlc_index/=2;
364
            if(vlc_index < 1) vlc_index = 1;
365
        }
366
        if (vlc_index>13) vlc_index = 13;           //the VLC tables >13 are identical to No. 13
367

    
368
        j = get_vlc2(&q->gb, q->envelope_quant_index[vlc_index-1].table,
369
                     q->envelope_quant_index[vlc_index-1].bits,2);
370
        quant_index_table[i] = quant_index_table[i-1] + j - 12;    //differential encoding
371
    }
372
}
373

    
374
/**
375
 * Calculate the category and category_index vector.
376
 *
377
 * @param q                     pointer to the COOKContext
378
 * @param quant_index_table     pointer to the array
379
 * @param category              pointer to the category array
380
 * @param category_index        pointer to the category_index array
381
 */
382

    
383
static void categorize(COOKContext *q, int* quant_index_table,
384
                       int* category, int* category_index){
385
    int exp_idx, bias, tmpbias1, tmpbias2, bits_left, num_bits, index, v, i, j;
386
    int exp_index2[102];
387
    int exp_index1[102];
388

    
389
    int tmp_categorize_array[128*2];
390
    int tmp_categorize_array1_idx=q->numvector_size;
391
    int tmp_categorize_array2_idx=q->numvector_size;
392

    
393
    bits_left =  q->bits_per_subpacket - get_bits_count(&q->gb);
394

    
395
    if(bits_left > q->samples_per_channel) {
396
        bits_left = q->samples_per_channel +
397
                    ((bits_left - q->samples_per_channel)*5)/8;
398
        //av_log(NULL, AV_LOG_ERROR, "bits_left = %d\n",bits_left);
399
    }
400

    
401
    memset(&exp_index1,0,102*sizeof(int));
402
    memset(&exp_index2,0,102*sizeof(int));
403
    memset(&tmp_categorize_array,0,128*2*sizeof(int));
404

    
405
    bias=-32;
406

    
407
    /* Estimate bias. */
408
    for (i=32 ; i>0 ; i=i/2){
409
        num_bits = 0;
410
        index = 0;
411
        for (j=q->total_subbands ; j>0 ; j--){
412
            exp_idx = av_clip((i - quant_index_table[index] + bias) / 2, 0, 7);
413
            index++;
414
            num_bits+=expbits_tab[exp_idx];
415
        }
416
        if(num_bits >= bits_left - 32){
417
            bias+=i;
418
        }
419
    }
420

    
421
    /* Calculate total number of bits. */
422
    num_bits=0;
423
    for (i=0 ; i<q->total_subbands ; i++) {
424
        exp_idx = av_clip((bias - quant_index_table[i]) / 2, 0, 7);
425
        num_bits += expbits_tab[exp_idx];
426
        exp_index1[i] = exp_idx;
427
        exp_index2[i] = exp_idx;
428
    }
429
    tmpbias1 = tmpbias2 = num_bits;
430

    
431
    for (j = 1 ; j < q->numvector_size ; j++) {
432
        if (tmpbias1 + tmpbias2 > 2*bits_left) {  /* ---> */
433
            int max = -999999;
434
            index=-1;
435
            for (i=0 ; i<q->total_subbands ; i++){
436
                if (exp_index1[i] < 7) {
437
                    v = (-2*exp_index1[i]) - quant_index_table[i] + bias;
438
                    if ( v >= max) {
439
                        max = v;
440
                        index = i;
441
                    }
442
                }
443
            }
444
            if(index==-1)break;
445
            tmp_categorize_array[tmp_categorize_array1_idx++] = index;
446
            tmpbias1 -= expbits_tab[exp_index1[index]] -
447
                        expbits_tab[exp_index1[index]+1];
448
            ++exp_index1[index];
449
        } else {  /* <--- */
450
            int min = 999999;
451
            index=-1;
452
            for (i=0 ; i<q->total_subbands ; i++){
453
                if(exp_index2[i] > 0){
454
                    v = (-2*exp_index2[i])-quant_index_table[i]+bias;
455
                    if ( v < min) {
456
                        min = v;
457
                        index = i;
458
                    }
459
                }
460
            }
461
            if(index == -1)break;
462
            tmp_categorize_array[--tmp_categorize_array2_idx] = index;
463
            tmpbias2 -= expbits_tab[exp_index2[index]] -
464
                        expbits_tab[exp_index2[index]-1];
465
            --exp_index2[index];
466
        }
467
    }
468

    
469
    for(i=0 ; i<q->total_subbands ; i++)
470
        category[i] = exp_index2[i];
471

    
472
    for(i=0 ; i<q->numvector_size-1 ; i++)
473
        category_index[i] = tmp_categorize_array[tmp_categorize_array2_idx++];
474

    
475
}
476

    
477

    
478
/**
479
 * Expand the category vector.
480
 *
481
 * @param q                     pointer to the COOKContext
482
 * @param category              pointer to the category array
483
 * @param category_index        pointer to the category_index array
484
 */
485

    
486
static inline void expand_category(COOKContext *q, int* category,
487
                                   int* category_index){
488
    int i;
489
    for(i=0 ; i<q->num_vectors ; i++){
490
        ++category[category_index[i]];
491
    }
492
}
493

    
494
/**
495
 * The real requantization of the mltcoefs
496
 *
497
 * @param q                     pointer to the COOKContext
498
 * @param index                 index
499
 * @param quant_index           quantisation index
500
 * @param subband_coef_index    array of indexes to quant_centroid_tab
501
 * @param subband_coef_sign     signs of coefficients
502
 * @param mlt_p                 pointer into the mlt buffer
503
 */
504

    
505
static void scalar_dequant(COOKContext *q, int index, int quant_index,
506
                           int* subband_coef_index, int* subband_coef_sign,
507
                           float* mlt_p){
508
    int i;
509
    float f1;
510

    
511
    for(i=0 ; i<SUBBAND_SIZE ; i++) {
512
        if (subband_coef_index[i]) {
513
            f1 = quant_centroid_tab[index][subband_coef_index[i]];
514
            if (subband_coef_sign[i]) f1 = -f1;
515
        } else {
516
            /* noise coding if subband_coef_index[i] == 0 */
517
            f1 = dither_tab[index];
518
            if (av_random(&q->random_state) < 0x80000000) f1 = -f1;
519
        }
520
        mlt_p[i] = f1 * q->rootpow2tab[quant_index+63];
521
    }
522
}
523
/**
524
 * Unpack the subband_coef_index and subband_coef_sign vectors.
525
 *
526
 * @param q                     pointer to the COOKContext
527
 * @param category              pointer to the category array
528
 * @param subband_coef_index    array of indexes to quant_centroid_tab
529
 * @param subband_coef_sign     signs of coefficients
530
 */
531

    
532
static int unpack_SQVH(COOKContext *q, int category, int* subband_coef_index,
533
                       int* subband_coef_sign) {
534
    int i,j;
535
    int vlc, vd ,tmp, result;
536

    
537
    vd = vd_tab[category];
538
    result = 0;
539
    for(i=0 ; i<vpr_tab[category] ; i++){
540
        vlc = get_vlc2(&q->gb, q->sqvh[category].table, q->sqvh[category].bits, 3);
541
        if (q->bits_per_subpacket < get_bits_count(&q->gb)){
542
            vlc = 0;
543
            result = 1;
544
        }
545
        for(j=vd-1 ; j>=0 ; j--){
546
            tmp = (vlc * invradix_tab[category])/0x100000;
547
            subband_coef_index[vd*i+j] = vlc - tmp * (kmax_tab[category]+1);
548
            vlc = tmp;
549
        }
550
        for(j=0 ; j<vd ; j++){
551
            if (subband_coef_index[i*vd + j]) {
552
                if(get_bits_count(&q->gb) < q->bits_per_subpacket){
553
                    subband_coef_sign[i*vd+j] = get_bits1(&q->gb);
554
                } else {
555
                    result=1;
556
                    subband_coef_sign[i*vd+j]=0;
557
                }
558
            } else {
559
                subband_coef_sign[i*vd+j]=0;
560
            }
561
        }
562
    }
563
    return result;
564
}
565

    
566

    
567
/**
568
 * Fill the mlt_buffer with mlt coefficients.
569
 *
570
 * @param q                 pointer to the COOKContext
571
 * @param category          pointer to the category array
572
 * @param quant_index_table pointer to the array
573
 * @param mlt_buffer        pointer to mlt coefficients
574
 */
575

    
576

    
577
static void decode_vectors(COOKContext* q, int* category,
578
                           int *quant_index_table, float* mlt_buffer){
579
    /* A zero in this table means that the subband coefficient is
580
       random noise coded. */
581
    int subband_coef_index[SUBBAND_SIZE];
582
    /* A zero in this table means that the subband coefficient is a
583
       positive multiplicator. */
584
    int subband_coef_sign[SUBBAND_SIZE];
585
    int band, j;
586
    int index=0;
587

    
588
    for(band=0 ; band<q->total_subbands ; band++){
589
        index = category[band];
590
        if(category[band] < 7){
591
            if(unpack_SQVH(q, category[band], subband_coef_index, subband_coef_sign)){
592
                index=7;
593
                for(j=0 ; j<q->total_subbands ; j++) category[band+j]=7;
594
            }
595
        }
596
        if(index==7) {
597
            memset(subband_coef_index, 0, sizeof(subband_coef_index));
598
            memset(subband_coef_sign, 0, sizeof(subband_coef_sign));
599
        }
600
        scalar_dequant(q, index, quant_index_table[band],
601
                       subband_coef_index, subband_coef_sign,
602
                       &mlt_buffer[band * 20]);
603
    }
604

    
605
    if(q->total_subbands*SUBBAND_SIZE >= q->samples_per_channel){
606
        return;
607
    } /* FIXME: should this be removed, or moved into loop above? */
608
}
609

    
610

    
611
/**
612
 * function for decoding mono data
613
 *
614
 * @param q                 pointer to the COOKContext
615
 * @param mlt_buffer        pointer to mlt coefficients
616
 */
617

    
618
static void mono_decode(COOKContext *q, float* mlt_buffer) {
619

    
620
    int category_index[128];
621
    int quant_index_table[102];
622
    int category[128];
623

    
624
    memset(&category, 0, 128*sizeof(int));
625
    memset(&category_index, 0, 128*sizeof(int));
626

    
627
    decode_envelope(q, quant_index_table);
628
    q->num_vectors = get_bits(&q->gb,q->log2_numvector_size);
629
    categorize(q, quant_index_table, category, category_index);
630
    expand_category(q, category, category_index);
631
    decode_vectors(q, category, quant_index_table, mlt_buffer);
632
}
633

    
634

    
635
/**
636
 * the actual requantization of the timedomain samples
637
 *
638
 * @param q                 pointer to the COOKContext
639
 * @param buffer            pointer to the timedomain buffer
640
 * @param gain_index        index for the block multiplier
641
 * @param gain_index_next   index for the next block multiplier
642
 */
643

    
644
static void interpolate(COOKContext *q, float* buffer,
645
                        int gain_index, int gain_index_next){
646
    int i;
647
    float fc1, fc2;
648
    fc1 = q->pow2tab[gain_index+63];
649

    
650
    if(gain_index == gain_index_next){              //static gain
651
        for(i=0 ; i<q->gain_size_factor ; i++){
652
            buffer[i]*=fc1;
653
        }
654
        return;
655
    } else {                                        //smooth gain
656
        fc2 = q->gain_table[11 + (gain_index_next-gain_index)];
657
        for(i=0 ; i<q->gain_size_factor ; i++){
658
            buffer[i]*=fc1;
659
            fc1*=fc2;
660
        }
661
        return;
662
    }
663
}
664

    
665

    
666
/**
667
 * The modulated lapped transform, this takes transform coefficients
668
 * and transforms them into timedomain samples.
669
 * Apply transform window, overlap buffers, apply gain profile
670
 * and buffer management.
671
 *
672
 * @param q                 pointer to the COOKContext
673
 * @param inbuffer          pointer to the mltcoefficients
674
 * @param gains_ptr         current and previous gains
675
 * @param previous_buffer   pointer to the previous buffer to be used for overlapping
676
 */
677

    
678
static void imlt_gain(COOKContext *q, float *inbuffer,
679
                      cook_gains *gains_ptr, float* previous_buffer)
680
{
681
    const float fc = q->pow2tab[gains_ptr->previous[0] + 63];
682
    float *buffer0 = q->mono_mdct_output;
683
    float *buffer1 = q->mono_mdct_output + q->samples_per_channel;
684
    int i;
685

    
686
    /* Inverse modified discrete cosine transform */
687
    q->mdct_ctx.fft.imdct_calc(&q->mdct_ctx, q->mono_mdct_output,
688
                               inbuffer, q->mdct_tmp);
689

    
690
    /* The weird thing here, is that the two halves of the time domain
691
     * buffer are swapped. Also, the newest data, that we save away for
692
     * next frame, has the wrong sign. Hence the subtraction below.
693
     * Almost sounds like a complex conjugate/reverse data/FFT effect.
694
     */
695

    
696
    /* Apply window and overlap */
697
    for(i = 0; i < q->samples_per_channel; i++){
698
        buffer1[i] = buffer1[i] * fc * q->mlt_window[i] -
699
          previous_buffer[i] * q->mlt_window[q->samples_per_channel - 1 - i];
700
    }
701

    
702
    /* Apply gain profile */
703
    for (i = 0; i < 8; i++) {
704
        if (gains_ptr->now[i] || gains_ptr->now[i + 1])
705
            interpolate(q, &buffer1[q->gain_size_factor * i],
706
                        gains_ptr->now[i], gains_ptr->now[i + 1]);
707
    }
708

    
709
    /* Save away the current to be previous block. */
710
    memcpy(previous_buffer, buffer0, sizeof(float)*q->samples_per_channel);
711
}
712

    
713

    
714
/**
715
 * function for getting the jointstereo coupling information
716
 *
717
 * @param q                 pointer to the COOKContext
718
 * @param decouple_tab      decoupling array
719
 *
720
 */
721

    
722
static void decouple_info(COOKContext *q, int* decouple_tab){
723
    int length, i;
724

    
725
    if(get_bits1(&q->gb)) {
726
        if(cplband[q->js_subband_start] > cplband[q->subbands-1]) return;
727

    
728
        length = cplband[q->subbands-1] - cplband[q->js_subband_start] + 1;
729
        for (i=0 ; i<length ; i++) {
730
            decouple_tab[cplband[q->js_subband_start] + i] = get_vlc2(&q->gb, q->ccpl.table, q->ccpl.bits, 2);
731
        }
732
        return;
733
    }
734

    
735
    if(cplband[q->js_subband_start] > cplband[q->subbands-1]) return;
736

    
737
    length = cplband[q->subbands-1] - cplband[q->js_subband_start] + 1;
738
    for (i=0 ; i<length ; i++) {
739
       decouple_tab[cplband[q->js_subband_start] + i] = get_bits(&q->gb, q->js_vlc_bits);
740
    }
741
    return;
742
}
743

    
744

    
745
/**
746
 * function for decoding joint stereo data
747
 *
748
 * @param q                 pointer to the COOKContext
749
 * @param mlt_buffer1       pointer to left channel mlt coefficients
750
 * @param mlt_buffer2       pointer to right channel mlt coefficients
751
 */
752

    
753
static void joint_decode(COOKContext *q, float* mlt_buffer1,
754
                         float* mlt_buffer2) {
755
    int i,j;
756
    int decouple_tab[SUBBAND_SIZE];
757
    float decode_buffer[1060];
758
    int idx, cpl_tmp,tmp_idx;
759
    float f1,f2;
760
    float* cplscale;
761

    
762
    memset(decouple_tab, 0, sizeof(decouple_tab));
763
    memset(decode_buffer, 0, sizeof(decode_buffer));
764

    
765
    /* Make sure the buffers are zeroed out. */
766
    memset(mlt_buffer1,0, 1024*sizeof(float));
767
    memset(mlt_buffer2,0, 1024*sizeof(float));
768
    decouple_info(q, decouple_tab);
769
    mono_decode(q, decode_buffer);
770

    
771
    /* The two channels are stored interleaved in decode_buffer. */
772
    for (i=0 ; i<q->js_subband_start ; i++) {
773
        for (j=0 ; j<SUBBAND_SIZE ; j++) {
774
            mlt_buffer1[i*20+j] = decode_buffer[i*40+j];
775
            mlt_buffer2[i*20+j] = decode_buffer[i*40+20+j];
776
        }
777
    }
778

    
779
    /* When we reach js_subband_start (the higher frequencies)
780
       the coefficients are stored in a coupling scheme. */
781
    idx = (1 << q->js_vlc_bits) - 1;
782
    for (i=q->js_subband_start ; i<q->subbands ; i++) {
783
        cpl_tmp = cplband[i];
784
        idx -=decouple_tab[cpl_tmp];
785
        cplscale = (float*)cplscales[q->js_vlc_bits-2];  //choose decoupler table
786
        f1 = cplscale[decouple_tab[cpl_tmp]];
787
        f2 = cplscale[idx-1];
788
        for (j=0 ; j<SUBBAND_SIZE ; j++) {
789
            tmp_idx = ((q->js_subband_start + i)*20)+j;
790
            mlt_buffer1[20*i + j] = f1 * decode_buffer[tmp_idx];
791
            mlt_buffer2[20*i + j] = f2 * decode_buffer[tmp_idx];
792
        }
793
        idx = (1 << q->js_vlc_bits) - 1;
794
    }
795
}
796

    
797
/**
798
 * First part of subpacket decoding:
799
 *  decode raw stream bytes and read gain info.
800
 *
801
 * @param q                 pointer to the COOKContext
802
 * @param inbuffer          pointer to raw stream data
803
 * @param gain_ptr          array of current/prev gain pointers
804
 */
805

    
806
static inline void
807
decode_bytes_and_gain(COOKContext *q, uint8_t *inbuffer,
808
                      cook_gains *gains_ptr)
809
{
810
    int offset;
811

    
812
    offset = decode_bytes(inbuffer, q->decoded_bytes_buffer,
813
                          q->bits_per_subpacket/8);
814
    init_get_bits(&q->gb, q->decoded_bytes_buffer + offset,
815
                  q->bits_per_subpacket);
816
    decode_gain_info(&q->gb, gains_ptr->now);
817

    
818
    /* Swap current and previous gains */
819
    FFSWAP(int *, gains_ptr->now, gains_ptr->previous);
820
}
821

    
822
/**
823
 * Final part of subpacket decoding:
824
 *  Apply modulated lapped transform, gain compensation,
825
 *  clip and convert to integer.
826
 *
827
 * @param q                 pointer to the COOKContext
828
 * @param decode_buffer     pointer to the mlt coefficients
829
 * @param gain_ptr          array of current/prev gain pointers
830
 * @param previous_buffer   pointer to the previous buffer to be used for overlapping
831
 * @param out               pointer to the output buffer
832
 * @param chan              0: left or single channel, 1: right channel
833
 */
834

    
835
static inline void
836
mlt_compensate_output(COOKContext *q, float *decode_buffer,
837
                      cook_gains *gains, float *previous_buffer,
838
                      int16_t *out, int chan)
839
{
840
    float *output = q->mono_mdct_output + q->samples_per_channel;
841
    int j;
842

    
843
    imlt_gain(q, decode_buffer, gains, previous_buffer);
844

    
845
    /* Clip and convert floats to 16 bits.
846
     */
847
    for (j = 0; j < q->samples_per_channel; j++) {
848
        out[chan + q->nb_channels * j] =
849
          av_clip(lrintf(output[j]), -32768, 32767);
850
    }
851
}
852

    
853

    
854
/**
855
 * Cook subpacket decoding. This function returns one decoded subpacket,
856
 * usually 1024 samples per channel.
857
 *
858
 * @param q                 pointer to the COOKContext
859
 * @param inbuffer          pointer to the inbuffer
860
 * @param sub_packet_size   subpacket size
861
 * @param outbuffer         pointer to the outbuffer
862
 */
863

    
864

    
865
static int decode_subpacket(COOKContext *q, uint8_t *inbuffer,
866
                            int sub_packet_size, int16_t *outbuffer) {
867
    /* packet dump */
868
//    for (i=0 ; i<sub_packet_size ; i++) {
869
//        av_log(NULL, AV_LOG_ERROR, "%02x", inbuffer[i]);
870
//    }
871
//    av_log(NULL, AV_LOG_ERROR, "\n");
872

    
873
    decode_bytes_and_gain(q, inbuffer, &q->gains1);
874

    
875
    if (q->joint_stereo) {
876
        joint_decode(q, q->decode_buffer_1, q->decode_buffer_2);
877
    } else {
878
        mono_decode(q, q->decode_buffer_1);
879

    
880
        if (q->nb_channels == 2) {
881
            decode_bytes_and_gain(q, inbuffer + sub_packet_size/2, &q->gains2);
882
            mono_decode(q, q->decode_buffer_2);
883
        }
884
    }
885

    
886
    mlt_compensate_output(q, q->decode_buffer_1, &q->gains1,
887
                          q->mono_previous_buffer1, outbuffer, 0);
888

    
889
    if (q->nb_channels == 2) {
890
        if (q->joint_stereo) {
891
            mlt_compensate_output(q, q->decode_buffer_2, &q->gains1,
892
                                  q->mono_previous_buffer2, outbuffer, 1);
893
        } else {
894
            mlt_compensate_output(q, q->decode_buffer_2, &q->gains2,
895
                                  q->mono_previous_buffer2, outbuffer, 1);
896
        }
897
    }
898
    return q->samples_per_frame * sizeof(int16_t);
899
}
900

    
901

    
902
/**
903
 * Cook frame decoding
904
 *
905
 * @param avctx     pointer to the AVCodecContext
906
 */
907

    
908
static int cook_decode_frame(AVCodecContext *avctx,
909
            void *data, int *data_size,
910
            uint8_t *buf, int buf_size) {
911
    COOKContext *q = avctx->priv_data;
912

    
913
    if (buf_size < avctx->block_align)
914
        return buf_size;
915

    
916
    *data_size = decode_subpacket(q, buf, avctx->block_align, data);
917

    
918
    /* Discard the first two frames: no valid audio. */
919
    if (avctx->frame_number < 2) *data_size = 0;
920

    
921
    return avctx->block_align;
922
}
923

    
924
#ifdef COOKDEBUG
925
static void dump_cook_context(COOKContext *q)
926
{
927
    //int i=0;
928
#define PRINT(a,b) av_log(NULL,AV_LOG_ERROR," %s = %d\n", a, b);
929
    av_log(NULL,AV_LOG_ERROR,"COOKextradata\n");
930
    av_log(NULL,AV_LOG_ERROR,"cookversion=%x\n",q->cookversion);
931
    if (q->cookversion > STEREO) {
932
        PRINT("js_subband_start",q->js_subband_start);
933
        PRINT("js_vlc_bits",q->js_vlc_bits);
934
    }
935
    av_log(NULL,AV_LOG_ERROR,"COOKContext\n");
936
    PRINT("nb_channels",q->nb_channels);
937
    PRINT("bit_rate",q->bit_rate);
938
    PRINT("sample_rate",q->sample_rate);
939
    PRINT("samples_per_channel",q->samples_per_channel);
940
    PRINT("samples_per_frame",q->samples_per_frame);
941
    PRINT("subbands",q->subbands);
942
    PRINT("random_state",q->random_state);
943
    PRINT("js_subband_start",q->js_subband_start);
944
    PRINT("log2_numvector_size",q->log2_numvector_size);
945
    PRINT("numvector_size",q->numvector_size);
946
    PRINT("total_subbands",q->total_subbands);
947
}
948
#endif
949

    
950
/**
951
 * Cook initialization
952
 *
953
 * @param avctx     pointer to the AVCodecContext
954
 */
955

    
956
static int cook_decode_init(AVCodecContext *avctx)
957
{
958
    COOKContext *q = avctx->priv_data;
959
    uint8_t *edata_ptr = avctx->extradata;
960

    
961
    /* Take care of the codec specific extradata. */
962
    if (avctx->extradata_size <= 0) {
963
        av_log(avctx,AV_LOG_ERROR,"Necessary extradata missing!\n");
964
        return -1;
965
    } else {
966
        /* 8 for mono, 16 for stereo, ? for multichannel
967
           Swap to right endianness so we don't need to care later on. */
968
        av_log(avctx,AV_LOG_DEBUG,"codecdata_length=%d\n",avctx->extradata_size);
969
        if (avctx->extradata_size >= 8){
970
            q->cookversion = bytestream_get_be32(&edata_ptr);
971
            q->samples_per_frame =  bytestream_get_be16(&edata_ptr);
972
            q->subbands = bytestream_get_be16(&edata_ptr);
973
        }
974
        if (avctx->extradata_size >= 16){
975
            bytestream_get_be32(&edata_ptr);    //Unknown unused
976
            q->js_subband_start = bytestream_get_be16(&edata_ptr);
977
            q->js_vlc_bits = bytestream_get_be16(&edata_ptr);
978
        }
979
    }
980

    
981
    /* Take data from the AVCodecContext (RM container). */
982
    q->sample_rate = avctx->sample_rate;
983
    q->nb_channels = avctx->channels;
984
    q->bit_rate = avctx->bit_rate;
985

    
986
    /* Initialize RNG. */
987
    av_init_random(1, &q->random_state);
988

    
989
    /* Initialize extradata related variables. */
990
    q->samples_per_channel = q->samples_per_frame / q->nb_channels;
991
    q->bits_per_subpacket = avctx->block_align * 8;
992

    
993
    /* Initialize default data states. */
994
    q->log2_numvector_size = 5;
995
    q->total_subbands = q->subbands;
996

    
997
    /* Initialize version-dependent variables */
998
    av_log(NULL,AV_LOG_DEBUG,"q->cookversion=%x\n",q->cookversion);
999
    q->joint_stereo = 0;
1000
    switch (q->cookversion) {
1001
        case MONO:
1002
            if (q->nb_channels != 1) {
1003
                av_log(avctx,AV_LOG_ERROR,"Container channels != 1, report sample!\n");
1004
                return -1;
1005
            }
1006
            av_log(avctx,AV_LOG_DEBUG,"MONO\n");
1007
            break;
1008
        case STEREO:
1009
            if (q->nb_channels != 1) {
1010
                q->bits_per_subpacket = q->bits_per_subpacket/2;
1011
            }
1012
            av_log(avctx,AV_LOG_DEBUG,"STEREO\n");
1013
            break;
1014
        case JOINT_STEREO:
1015
            if (q->nb_channels != 2) {
1016
                av_log(avctx,AV_LOG_ERROR,"Container channels != 2, report sample!\n");
1017
                return -1;
1018
            }
1019
            av_log(avctx,AV_LOG_DEBUG,"JOINT_STEREO\n");
1020
            if (avctx->extradata_size >= 16){
1021
                q->total_subbands = q->subbands + q->js_subband_start;
1022
                q->joint_stereo = 1;
1023
            }
1024
            if (q->samples_per_channel > 256) {
1025
                q->log2_numvector_size  = 6;
1026
            }
1027
            if (q->samples_per_channel > 512) {
1028
                q->log2_numvector_size  = 7;
1029
            }
1030
            break;
1031
        case MC_COOK:
1032
            av_log(avctx,AV_LOG_ERROR,"MC_COOK not supported!\n");
1033
            return -1;
1034
            break;
1035
        default:
1036
            av_log(avctx,AV_LOG_ERROR,"Unknown Cook version, report sample!\n");
1037
            return -1;
1038
            break;
1039
    }
1040

    
1041
    /* Initialize variable relations */
1042
    q->numvector_size = (1 << q->log2_numvector_size);
1043

    
1044
    /* Generate tables */
1045
    init_rootpow2table(q);
1046
    init_pow2table(q);
1047
    init_gain_table(q);
1048

    
1049
    if (init_cook_vlc_tables(q) != 0)
1050
        return -1;
1051

    
1052

    
1053
    if(avctx->block_align >= UINT_MAX/2)
1054
        return -1;
1055

    
1056
    /* Pad the databuffer with:
1057
       DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(),
1058
       FF_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */
1059
    if (q->nb_channels==2 && q->joint_stereo==0) {
1060
        q->decoded_bytes_buffer =
1061
          av_mallocz(avctx->block_align/2
1062
                     + DECODE_BYTES_PAD2(avctx->block_align/2)
1063
                     + FF_INPUT_BUFFER_PADDING_SIZE);
1064
    } else {
1065
        q->decoded_bytes_buffer =
1066
          av_mallocz(avctx->block_align
1067
                     + DECODE_BYTES_PAD1(avctx->block_align)
1068
                     + FF_INPUT_BUFFER_PADDING_SIZE);
1069
    }
1070
    if (q->decoded_bytes_buffer == NULL)
1071
        return -1;
1072

    
1073
    q->gains1.now      = q->gain_1;
1074
    q->gains1.previous = q->gain_2;
1075
    q->gains2.now      = q->gain_3;
1076
    q->gains2.previous = q->gain_4;
1077

    
1078
    /* Initialize transform. */
1079
    if ( init_cook_mlt(q) != 0 )
1080
        return -1;
1081

    
1082
    /* Try to catch some obviously faulty streams, othervise it might be exploitable */
1083
    if (q->total_subbands > 53) {
1084
        av_log(avctx,AV_LOG_ERROR,"total_subbands > 53, report sample!\n");
1085
        return -1;
1086
    }
1087
    if (q->subbands > 50) {
1088
        av_log(avctx,AV_LOG_ERROR,"subbands > 50, report sample!\n");
1089
        return -1;
1090
    }
1091
    if ((q->samples_per_channel == 256) || (q->samples_per_channel == 512) || (q->samples_per_channel == 1024)) {
1092
    } else {
1093
        av_log(avctx,AV_LOG_ERROR,"unknown amount of samples_per_channel = %d, report sample!\n",q->samples_per_channel);
1094
        return -1;
1095
    }
1096
    if ((q->js_vlc_bits > 6) || (q->js_vlc_bits < 0)) {
1097
        av_log(avctx,AV_LOG_ERROR,"q->js_vlc_bits = %d, only >= 0 and <= 6 allowed!\n",q->js_vlc_bits);
1098
        return -1;
1099
    }
1100

    
1101
#ifdef COOKDEBUG
1102
    dump_cook_context(q);
1103
#endif
1104
    return 0;
1105
}
1106

    
1107

    
1108
AVCodec cook_decoder =
1109
{
1110
    .name = "cook",
1111
    .type = CODEC_TYPE_AUDIO,
1112
    .id = CODEC_ID_COOK,
1113
    .priv_data_size = sizeof(COOKContext),
1114
    .init = cook_decode_init,
1115
    .close = cook_decode_close,
1116
    .decode = cook_decode_frame,
1117
};