Revision e0f7e329

View differences:

libavcodec/Makefile
32 32
ifeq ($(CONFIG_CINEPAK_DECODER),yes)
33 33
    OBJS+= cinepak.o
34 34
endif
35
ifeq ($(CONFIG_COOK_DECODER),yes)
36
    OBJS+= cook.o
37
endif
35 38
ifneq ($(CONFIG_CLJR_DECODER)$(CONFIG_CLJR_ENCODER),)
36 39
    OBJS+= cljr.o
37 40
endif
libavcodec/allcodecs.c
491 491
#ifdef CONFIG_QDM2_DECODER
492 492
    register_avcodec(&qdm2_decoder);
493 493
#endif //CONFIG_QDM2_DECODER
494
#ifdef CONFIG_COOK_DECODER
495
    register_avcodec(&cook_decoder);
496
#endif //CONFIG_COOK_DECODER
494 497
#ifdef CONFIG_RAWVIDEO_DECODER
495 498
    register_avcodec(&rawvideo_decoder);
496 499
#endif //CONFIG_RAWVIDEO_DECODER
libavcodec/avcodec.h
21 21
#define AV_STRINGIFY(s)	AV_TOSTRING(s)
22 22
#define AV_TOSTRING(s) #s
23 23

  
24
#define LIBAVCODEC_VERSION_INT ((50<<16)+(1<<8)+0)
25
#define LIBAVCODEC_VERSION     50.1.0
24
#define LIBAVCODEC_VERSION_INT ((51<<16)+(0<<8)+0)
25
#define LIBAVCODEC_VERSION     51.0.0
26 26
#define LIBAVCODEC_BUILD       LIBAVCODEC_VERSION_INT
27 27

  
28 28
#define LIBAVCODEC_IDENT       "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION)
......
187 187
    CODEC_ID_WESTWOOD_SND1,
188 188
    CODEC_ID_GSM,    
189 189
    CODEC_ID_QDM2,
190
    CODEC_ID_COOK,
190 191
    
191 192
    CODEC_ID_OGGTHEORA= 0x16000, 
192 193

  
......
2004 2005
extern AVCodec mp3adu_decoder;
2005 2006
extern AVCodec mp3on4_decoder;
2006 2007
extern AVCodec qdm2_decoder;
2008
extern AVCodec cook_decoder;
2007 2009
extern AVCodec mace3_decoder;
2008 2010
extern AVCodec mace6_decoder;
2009 2011
extern AVCodec huffyuv_decoder;
libavcodec/cook.c
1
/*
2
 * COOK compatible decoder
3
 * Copyright (c) 2003 Sascha Sommer
4
 * Copyright (c) 2005 Benjamin Larsson
5
 *
6
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 *
20
 */
21

  
22
/**
23
 * @file cook.c
24
 * Cook compatible decoder.
25
 * This decoder handles RealNetworks, RealAudio G2 data.
26
 * Cook is identified by the codec name cook in RM files.
27
 *
28
 * To use this decoder, a calling application must supply the extradata
29
 * bytes provided from the RM container; 8+ bytes for mono streams and
30
 * 16+ for stereo streams (maybe more).
31
 *
32
 * Codec technicalities (all this assume a buffer length of 1024):
33
 * Cook works with several different techniques to achieve its compression.
34
 * In the timedomain the buffer is divided into 8 pieces and quantized. If
35
 * two neighboring pieces have different quantization index a smooth
36
 * quantization curve is used to get a smooth overlap between the different
37
 * pieces.
38
 * To get to the transformdomain Cook uses a modulated lapped transform.
39
 * The transform domain has 50 subbands with 20 elements each. This
40
 * means only a maximum of 50*20=1000 coefficients are used out of the 1024
41
 * available.
42
 */
43

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

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

  
53
#include "cookdata.h"
54

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

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

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

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

  
82

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

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

  
113
    /* gain buffers */
114
    COOKgain*           gain_now_ptr;
115
    COOKgain*           gain_previous_ptr;
116
    COOKgain            gain_copy;
117
    COOKgain            gain_current;
118
    COOKgain            gain_now;
119
    COOKgain            gain_previous;
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
    uint8_t*            frame_reorder_buffer;
135
    int*                frame_reorder_index;
136
    int                 frame_reorder_counter;
137
    int                 frame_reorder_complete;
138
    int                 frame_reorder_index_size;
139

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

  
152
/* debug functions */
153

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

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

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

  
182
#endif
183

  
184
/*************** init functions ***************/
185

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

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

  
206
/* table generator */
207
static void init_gain_table(COOKContext *q) {
208
    int i;
209
    q->gain_size_factor = q->samples_per_channel/8;
210
    for (i=0 ; i<23 ; i++) {
211
        q->gain_table[i] = pow((double)q->pow2tab[i+52] ,
212
                               (1.0/(double)q->gain_size_factor));
213
    }
214
    memset(&q->gain_copy, 0, sizeof(COOKgain));
215
    memset(&q->gain_current, 0, sizeof(COOKgain));
216
    memset(&q->gain_now, 0, sizeof(COOKgain));
217
    memset(&q->gain_previous, 0, sizeof(COOKgain));
218
}
219

  
220

  
221
static int init_cook_vlc_tables(COOKContext *q) {
222
    int i, result;
223

  
224
    result = 0;
225
    for (i=0 ; i<13 ; i++) {
226
        result &= init_vlc (&q->envelope_quant_index[i], 9, 24,
227
            envelope_quant_index_huffbits[i], 1, 1,
228
            envelope_quant_index_huffcodes[i], 2, 2, 0);
229
    }
230
    av_log(NULL,AV_LOG_DEBUG,"sqvh VLC init\n");
231
    for (i=0 ; i<7 ; i++) {
232
        result &= init_vlc (&q->sqvh[i], vhvlcsize_tab[i], vhsize_tab[i],
233
            cvh_huffbits[i], 1, 1,
234
            cvh_huffcodes[i], 2, 2, 0);
235
    }
236

  
237
    if (q->nb_channels==2 && q->joint_stereo==1){
238
        result &= init_vlc (&q->ccpl, 6, (1<<q->js_vlc_bits)-1,
239
            ccpl_huffbits[q->js_vlc_bits-2], 1, 1,
240
            ccpl_huffcodes[q->js_vlc_bits-2], 2, 2, 0);
241
        av_log(NULL,AV_LOG_DEBUG,"Joint-stereo VLC used.\n");
242
    }
243

  
244
    av_log(NULL,AV_LOG_DEBUG,"VLC tables initialized.\n");
245
    return result;
246
}
247

  
248
static int init_cook_mlt(COOKContext *q) {
249
    int j;
250
    float alpha;
251

  
252
    /* Allocate the buffers, could be replaced with a static [512]
253
       array if needed. */
254
    q->mlt_size = q->samples_per_channel;
255
    q->mlt_window = av_malloc(sizeof(float)*q->mlt_size);
256
    q->mlt_precos = av_malloc(sizeof(float)*q->mlt_size/2);
257
    q->mlt_presin = av_malloc(sizeof(float)*q->mlt_size/2);
258
    q->mlt_postcos = av_malloc(sizeof(float)*q->mlt_size/2);
259

  
260
    /* Initialize the MLT window: simple sine window. */
261
    alpha = M_PI / (2.0 * (float)q->mlt_size);
262
    for(j=0 ; j<q->mlt_size ; j++) {
263
        q->mlt_window[j] = sin((j + 512.0/(float)q->mlt_size) * alpha);
264
    }
265

  
266
    /* pre/post twiddle factors */
267
    for (j=0 ; j<q->mlt_size/2 ; j++){
268
        q->mlt_precos[j] = cos( ((j+0.25)*M_PI)/q->mlt_size);
269
        q->mlt_presin[j] = sin( ((j+0.25)*M_PI)/q->mlt_size);
270
        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
271
    }
272

  
273
    /* Initialize the FFT. */
274
    ff_fft_init(&q->fft_ctx, av_log2(q->mlt_size)-1, 0);
275
    av_log(NULL,AV_LOG_DEBUG,"FFT initialized, order = %d.\n",
276
           av_log2(q->samples_per_channel)-1);
277

  
278
    return (int)(q->mlt_window && q->mlt_precos && q->mlt_presin && q->mlt_postcos);
279
}
280

  
281
/*************** init functions end ***********/
282

  
283
/**
284
 * Cook indata decoding, every 32 bits are XORed with 0x37c511f2.
285
 * Why? No idea, some checksum/error detection method maybe.
286
 * Nice way to waste CPU cycles.
287
 *
288
 * @param in        pointer to 32bit array of indata
289
 * @param bits      amount of bits
290
 * @param out       pointer to 32bit array of outdata
291
 */
292

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

  
303

  
304
    for(i=0 ; i<bytes/4 ; i++){
305
#ifdef WORDS_BIGENDIAN
306
        obuf[i] = 0x37c511f2^buf[i];
307
#else
308
        obuf[i] = 0xf211c537^buf[i];
309
#endif
310
    }
311
}
312

  
313
/**
314
 * Cook uninit
315
 */
316

  
317
static int cook_decode_close(AVCodecContext *avctx)
318
{
319
    int i;
320
    COOKContext *q = avctx->priv_data;
321
    av_log(NULL,AV_LOG_DEBUG, "Deallocating memory.\n");
322

  
323
    /* Free allocated memory buffers. */
324
    av_free(q->mlt_window);
325
    av_free(q->mlt_precos);
326
    av_free(q->mlt_presin);
327
    av_free(q->mlt_postcos);
328
    av_free(q->frame_reorder_index);
329
    av_free(q->frame_reorder_buffer);
330
    av_free(q->decoded_bytes_buffer);
331

  
332
    /* Free the transform. */
333
    ff_fft_end(&q->fft_ctx);
334

  
335
    /* Free the VLC tables. */
336
    for (i=0 ; i<13 ; i++) {
337
        free_vlc(&q->envelope_quant_index[i]);
338
    }
339
    for (i=0 ; i<7 ; i++) {
340
        free_vlc(&q->sqvh[i]);
341
    }
342
    if(q->nb_channels==2 && q->joint_stereo==1 ){
343
        free_vlc(&q->ccpl);
344
    }
345

  
346
    av_log(NULL,AV_LOG_DEBUG,"Memory deallocated.\n");
347

  
348
    return 0;
349
}
350

  
351
/**
352
 * Fill the COOKgain structure for the timedomain quantization.
353
 *
354
 * @param q                 pointer to the COOKContext
355
 * @param gaininfo          pointer to the COOKgain
356
 */
357

  
358
static void decode_gain_info(GetBitContext *gb, COOKgain* gaininfo) {
359
    int i;
360

  
361
    while (get_bits1(gb)) {}
362

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

  
365
    if (get_bits_count(gb) - 1 <= 0) return;
366

  
367
    for (i=0 ; i<gaininfo->size ; i++){
368
        gaininfo->qidx_table1[i] = get_bits(gb,3);
369
        if (get_bits1(gb)) {
370
            gaininfo->qidx_table2[i] = get_bits(gb,4) - 7;  //convert to signed
371
        } else {
372
            gaininfo->qidx_table2[i] = -1;
373
        }
374
    }
375
}
376

  
377
/**
378
 * Create the quant index table needed for the envelope.
379
 *
380
 * @param q                 pointer to the COOKContext
381
 * @param quant_index_table pointer to the array
382
 */
383

  
384
static void decode_envelope(COOKContext *q, int* quant_index_table) {
385
    int i,j, vlc_index;
386
    int bitbias;
387

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

  
391
    for (i=1 ; i < q->total_subbands ; i++){
392
        vlc_index=i;
393
        if (i >= q->js_subband_start * 2) {
394
            vlc_index-=q->js_subband_start;
395
        } else {
396
            vlc_index/=2;
397
            if(vlc_index < 1) vlc_index = 1;
398
        }
399
        if (vlc_index>13) vlc_index = 13;           //the VLC tables >13 are identical to No. 13
400

  
401
        j = get_vlc2(&q->gb, q->envelope_quant_index[vlc_index-1].table,
402
                     q->envelope_quant_index[vlc_index-1].bits,2);
403
        quant_index_table[i] = quant_index_table[i-1] + j - 12;    //differential encoding
404
    }
405
}
406

  
407
/**
408
 * Create the quant value table.
409
 *
410
 * @param q                 pointer to the COOKContext
411
 * @param quant_value_table pointer to the array
412
 */
413

  
414
static void inline dequant_envelope(COOKContext *q, int* quant_index_table,
415
                                    float* quant_value_table){
416

  
417
    int i;
418
    for(i=0 ; i < q->total_subbands ; i++){
419
        quant_value_table[i] = q->rootpow2tab[quant_index_table[i]+63];
420
    }
421
}
422

  
423
/**
424
 * Calculate the category and category_index vector.
425
 *
426
 * @param q                     pointer to the COOKContext
427
 * @param quant_index_table     pointer to the array
428
 * @param category              pointer to the category array
429
 * @param category_index        pointer to the category_index array
430
 */
431

  
432
static void categorize(COOKContext *q, int* quant_index_table,
433
                       int* category, int* category_index){
434
    int exp_idx, bias, tmpbias, bits_left, num_bits, index, v, i, j;
435
    int exp_index2[102];
436
    int exp_index1[102];
437

  
438
    int tmp_categorize_array1[128];
439
    int tmp_categorize_array1_idx=0;
440
    int tmp_categorize_array2[128];
441
    int tmp_categorize_array2_idx=0;
442
    int category_index_size=0;
443

  
444
    bits_left =  q->bits_per_subpacket - get_bits_count(&q->gb);
445

  
446
    if(bits_left > q->samples_per_channel) {
447
        bits_left = q->samples_per_channel +
448
                    ((bits_left - q->samples_per_channel)*5)/8;
449
        //av_log(NULL, AV_LOG_ERROR, "bits_left = %d\n",bits_left);
450
    }
451

  
452
    memset(&exp_index1,0,102*sizeof(int));
453
    memset(&exp_index2,0,102*sizeof(int));
454
    memset(&tmp_categorize_array1,0,128*sizeof(int));
455
    memset(&tmp_categorize_array2,0,128*sizeof(int));
456

  
457
    bias=-32;
458

  
459
    /* Estimate bias. */
460
    for (i=32 ; i>0 ; i=i/2){
461
        num_bits = 0;
462
        index = 0;
463
        for (j=q->total_subbands ; j>0 ; j--){
464
            exp_idx = (i - quant_index_table[index] + bias) / 2;
465
            if (exp_idx<0){
466
                exp_idx=0;
467
            } else if(exp_idx >7) {
468
                exp_idx=7;
469
            }
470
            index++;
471
            num_bits+=expbits_tab[exp_idx];
472
        }
473
        if(num_bits >= bits_left - 32){
474
            bias+=i;
475
        }
476
    }
477

  
478
    /* Calculate total number of bits. */
479
    num_bits=0;
480
    for (i=0 ; i<q->total_subbands ; i++) {
481
        exp_idx = (bias - quant_index_table[i]) / 2;
482
        if (exp_idx<0) {
483
            exp_idx=0;
484
        } else if(exp_idx >7) {
485
            exp_idx=7;
486
        }
487
        num_bits += expbits_tab[exp_idx];
488
        exp_index1[i] = exp_idx;
489
        exp_index2[i] = exp_idx;
490
    }
491
    tmpbias = bias = num_bits;
492

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

  
531
    for(i=0 ; i<q->total_subbands ; i++)
532
        category[i] = exp_index2[i];
533

  
534
    /* Concatenate the two arrays. */
535
    for(i=tmp_categorize_array2_idx-1 ; i >= 0; i--)
536
        category_index[category_index_size++] =  tmp_categorize_array2[i];
537

  
538
    for(i=0;i<tmp_categorize_array1_idx;i++)
539
        category_index[category_index_size++ ] =  tmp_categorize_array1[i];
540

  
541
    /* FIXME: mc_sich_ra8_20.rm triggers this, not sure with what we
542
       should fill the remaining bytes. */
543
    for(i=category_index_size;i<q->numvector_size;i++)
544
        category_index[i]=0;
545

  
546
}
547

  
548

  
549
/**
550
 * Expand the category vector.
551
 *
552
 * @param q                     pointer to the COOKContext
553
 * @param category              pointer to the category array
554
 * @param category_index        pointer to the category_index array
555
 */
556

  
557
static void inline expand_category(COOKContext *q, int* category,
558
                                   int* category_index){
559
    int i;
560
    for(i=0 ; i<q->num_vectors ; i++){
561
        ++category[category_index[i]];
562
    }
563
}
564

  
565
/**
566
 * The real requantization of the mltcoefs
567
 *
568
 * @param q                     pointer to the COOKContext
569
 * @param index                 index
570
 * @param band                  current subband
571
 * @param quant_value_table     pointer to the array
572
 * @param subband_coef_index    array of indexes to quant_centroid_tab
573
 * @param subband_coef_noise    use random noise instead of predetermined value
574
 * @param mlt_buffer            pointer to the mlt buffer
575
 */
576

  
577

  
578
static void scalar_dequant(COOKContext *q, int index, int band,
579
                           float* quant_value_table, int* subband_coef_index,
580
                           int* subband_coef_noise, float* mlt_buffer){
581
    int i;
582
    float f1;
583

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

  
608
static int unpack_SQVH(COOKContext *q, int category, int* subband_coef_index,
609
                       int* subband_coef_noise) {
610
    int i,j;
611
    int vlc, vd ,tmp, result;
612
    int ub;
613
    int cb;
614

  
615
    vd = vd_tab[category];
616
    result = 0;
617
    for(i=0 ; i<vpr_tab[category] ; i++){
618
        ub = get_bits_count(&q->gb);
619
        vlc = get_vlc2(&q->gb, q->sqvh[category].table, q->sqvh[category].bits, 3);
620
        cb = get_bits_count(&q->gb);
621
        if (q->bits_per_subpacket < get_bits_count(&q->gb)){
622
            vlc = 0;
623
            result = 1;
624
        }
625
        for(j=vd-1 ; j>=0 ; j--){
626
            tmp = (vlc * invradix_tab[category])/0x100000;
627
            subband_coef_index[vd*i+j] = vlc - tmp * (kmax_tab[category]+1);
628
            vlc = tmp;
629
        }
630
        for(j=0 ; j<vd ; j++){
631
            if (subband_coef_index[i*vd + j]) {
632
                if(get_bits_count(&q->gb) < q->bits_per_subpacket){
633
                    subband_coef_noise[i*vd+j] = get_bits1(&q->gb);
634
                } else {
635
                    result=1;
636
                    subband_coef_noise[i*vd+j]=0;
637
                }
638
            } else {
639
                subband_coef_noise[i*vd+j]=0;
640
            }
641
        }
642
    }
643
    return result;
644
}
645

  
646

  
647
/**
648
 * Fill the mlt_buffer with mlt coefficients.
649
 *
650
 * @param q                 pointer to the COOKContext
651
 * @param category          pointer to the category array
652
 * @param quant_value_table pointer to the array
653
 * @param mlt_buffer        pointer to mlt coefficients
654
 */
655

  
656

  
657
static void decode_vectors(COOKContext* q, int* category,
658
                           float* quant_value_table, float* mlt_buffer){
659
    /* A zero in this table means that the subband coefficient is
660
       random noise coded. */
661
    int subband_coef_noise[SUBBAND_SIZE];
662
    /* A zero in this table means that the subband coefficient is a
663
       positive multiplicator. */
664
    int subband_coef_index[SUBBAND_SIZE];
665
    int band, j;
666
    int index=0;
667

  
668
    for(band=0 ; band<q->total_subbands ; band++){
669
        index = category[band];
670
        if(category[band] < 7){
671
            if(unpack_SQVH(q, category[band], subband_coef_index, subband_coef_noise)){
672
                index=7;
673
                for(j=0 ; j<q->total_subbands ; j++) category[band+j]=7;
674
            }
675
        }
676
        if(index==7) {
677
            memset(subband_coef_index, 0, sizeof(subband_coef_index));
678
            memset(subband_coef_noise, 0, sizeof(subband_coef_noise));
679
        }
680
        scalar_dequant(q, index, band, quant_value_table, subband_coef_index,
681
                       subband_coef_noise, mlt_buffer);
682
    }
683

  
684
    if(q->total_subbands*SUBBAND_SIZE >= q->samples_per_channel){
685
        return;
686
    }
687
}
688

  
689

  
690
/**
691
 * function for decoding mono data
692
 *
693
 * @param q                 pointer to the COOKContext
694
 * @param mlt_buffer1       pointer to left channel mlt coefficients
695
 * @param mlt_buffer2       pointer to right channel mlt coefficients
696
 */
697

  
698
static void mono_decode(COOKContext *q, float* mlt_buffer) {
699

  
700
    int category_index[128];
701
    float quant_value_table[102];
702
    int quant_index_table[102];
703
    int category[128];
704

  
705
    memset(&category, 0, 128*sizeof(int));
706
    memset(&quant_value_table, 0, 102*sizeof(int));
707
    memset(&category_index, 0, 128*sizeof(int));
708

  
709
    decode_envelope(q, quant_index_table);
710
    q->num_vectors = get_bits(&q->gb,q->numvector_bits);
711
    dequant_envelope(q, quant_index_table, quant_value_table);
712
    categorize(q, quant_index_table, category, category_index);
713
    expand_category(q, category, category_index);
714
    decode_vectors(q, category, quant_value_table, mlt_buffer);
715
}
716

  
717

  
718
/**
719
 * The modulated lapped transform, this takes transform coefficients
720
 * and transforms them into timedomain samples. This is done through
721
 * an FFT-based algorithm with pre- and postrotation steps.
722
 * A window and reorder step is also included.
723
 *
724
 * @param q                 pointer to the COOKContext
725
 * @param inbuffer          pointer to the mltcoefficients
726
 * @param outbuffer         pointer to the timedomain buffer
727
 * @param mlt_tmp           pointer to temporary storage space
728
 */
729

  
730
static void cook_imlt(COOKContext *q, float* inbuffer, float* outbuffer,
731
                      float* mlt_tmp){
732
    int i;
733

  
734
    /* prerotation */
735
    for(i=0 ; i<q->mlt_size ; i+=2){
736
        outbuffer[i] = (q->mlt_presin[i/2] * inbuffer[q->mlt_size-1-i]) +
737
                       (q->mlt_precos[i/2] * inbuffer[i]);
738
        outbuffer[i+1] = (q->mlt_precos[i/2] * inbuffer[q->mlt_size-1-i]) -
739
                         (q->mlt_presin[i/2] * inbuffer[i]);
740
    }
741

  
742
    /* FFT */
743
    ff_fft_permute(&q->fft_ctx, (FFTComplex *) outbuffer);
744
    ff_fft_calc (&q->fft_ctx, (FFTComplex *) outbuffer);
745

  
746
    /* postrotation */
747
    for(i=0 ; i<q->mlt_size ; i+=2){
748
        mlt_tmp[i] =               (q->mlt_postcos[(q->mlt_size-1-i)/2] * outbuffer[i+1]) +
749
                                   (q->mlt_postcos[i/2] * outbuffer[i]);
750
        mlt_tmp[q->mlt_size-1-i] = (q->mlt_postcos[(q->mlt_size-1-i)/2] * outbuffer[i]) -
751
                                   (q->mlt_postcos[i/2] * outbuffer[i+1]);
752
    }
753

  
754
    /* window and reorder */
755
    for(i=0 ; i<q->mlt_size/2 ; i++){
756
        outbuffer[i] = mlt_tmp[q->mlt_size/2-1-i] * q->mlt_window[i];
757
        outbuffer[q->mlt_size-1-i]= mlt_tmp[q->mlt_size/2-1-i] *
758
                                    q->mlt_window[q->mlt_size-1-i];
759
        outbuffer[q->mlt_size+i]= mlt_tmp[q->mlt_size/2+i] *
760
                                  q->mlt_window[q->mlt_size-1-i];
761
        outbuffer[2*q->mlt_size-1-i]= -(mlt_tmp[q->mlt_size/2+i] *
762
                                      q->mlt_window[i]);
763
    }
764
}
765

  
766

  
767
/**
768
 * the actual requantization of the timedomain samples
769
 *
770
 * @param q                 pointer to the COOKContext
771
 * @param buffer            pointer to the timedomain buffer
772
 * @param gain_index        index for the block multiplier
773
 * @param gain_index_next   index for the next block multiplier
774
 */
775

  
776
static void interpolate(COOKContext *q, float* buffer,
777
                        int gain_index, int gain_index_next){
778
    int i;
779
    float fc1, fc2;
780
    fc1 = q->pow2tab[gain_index+63];
781

  
782
    if(gain_index == gain_index_next){              //static gain
783
        for(i=0 ; i<q->gain_size_factor ; i++){
784
            buffer[i]*=fc1;
785
        }
786
        return;
787
    } else {                                        //smooth gain
788
        fc2 = q->gain_table[11 + (gain_index_next-gain_index)];
789
        for(i=0 ; i<q->gain_size_factor ; i++){
790
            buffer[i]*=fc1;
791
            fc1*=fc2;
792
        }
793
        return;
794
    }
795
}
796

  
797
/**
798
 * timedomain requantization of the timedomain samples
799
 *
800
 * @param q                 pointer to the COOKContext
801
 * @param buffer            pointer to the timedomain buffer
802
 * @param gain_now          current gain structure
803
 * @param gain_previous     previous gain structure
804
 */
805

  
806
static void gain_window(COOKContext *q, float* buffer, COOKgain* gain_now,
807
                        COOKgain* gain_previous){
808
    int i, index;
809
    int gain_index[9];
810
    int tmp_gain_index;
811

  
812
    gain_index[8]=0;
813
    index = gain_previous->size;
814
    for (i=7 ; i>=0 ; i--) {
815
        if(index && gain_previous->qidx_table1[index-1]==i) {
816
            gain_index[i] = gain_previous->qidx_table2[index-1];
817
            index--;
818
        } else {
819
            gain_index[i]=gain_index[i+1];
820
        }
821
    }
822
    /* This is applied to the to be previous data buffer. */
823
    for(i=0;i<8;i++){
824
        interpolate(q, &buffer[q->samples_per_channel+q->gain_size_factor*i],
825
                    gain_index[i], gain_index[i+1]);
826
    }
827

  
828
    tmp_gain_index = gain_index[0];
829
    index = gain_now->size;
830
    for (i=7 ; i>=0 ; i--) {
831
        if(index && gain_now->qidx_table1[index-1]==i) {
832
            gain_index[i]= gain_now->qidx_table2[index-1];
833
            index--;
834
        } else {
835
            gain_index[i]=gain_index[i+1];
836
        }
837
    }
838

  
839
    /* This is applied to the to be current block. */
840
    for(i=0;i<8;i++){
841
        interpolate(q, &buffer[i*q->gain_size_factor],
842
                    tmp_gain_index+gain_index[i],
843
                    tmp_gain_index+gain_index[i+1]);
844
    }
845
}
846

  
847

  
848
/**
849
 * mlt overlapping and buffer management
850
 *
851
 * @param q                 pointer to the COOKContext
852
 * @param buffer            pointer to the timedomain buffer
853
 * @param gain_now          current gain structure
854
 * @param gain_previous     previous gain structure
855
 * @param previous_buffer   pointer to the previous buffer to be used for overlapping
856
 *
857
 */
858

  
859
static void gain_compensate(COOKContext *q, float* buffer, COOKgain* gain_now,
860
                            COOKgain* gain_previous, float* previous_buffer) {
861
    int i;
862
    if((gain_now->size  || gain_previous->size)) {
863
        gain_window(q, buffer, gain_now, gain_previous);
864
    }
865

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

  
869
    /* Save away the current to be previous block. */
870
    memcpy(previous_buffer, buffer+q->samples_per_channel,
871
           sizeof(float)*q->samples_per_channel);
872
}
873

  
874

  
875
/**
876
 * function for getting the jointstereo coupling information
877
 *
878
 * @param q                 pointer to the COOKContext
879
 * @param decouple_tab      decoupling array
880
 *
881
 */
882

  
883
static void decouple_info(COOKContext *q, int* decouple_tab){
884
    int length, i;
885

  
886
    if(get_bits1(&q->gb)) {
887
        if(cplband[q->js_subband_start] > cplband[q->subbands-1]) return;
888

  
889
        length = cplband[q->subbands-1] - cplband[q->js_subband_start] + 1;
890
        for (i=0 ; i<length ; i++) {
891
            decouple_tab[cplband[q->js_subband_start] + i] = get_vlc2(&q->gb, q->ccpl.table, q->ccpl.bits, 2);
892
        }
893
        return;
894
    }
895

  
896
    if(cplband[q->js_subband_start] > cplband[q->subbands-1]) return;
897

  
898
    length = cplband[q->subbands-1] - cplband[q->js_subband_start] + 1;
899
    for (i=0 ; i<length ; i++) {
900
       decouple_tab[cplband[q->js_subband_start] + i] = get_bits(&q->gb, q->js_vlc_bits);
901
    }
902
    return;
903
}
904

  
905

  
906
/**
907
 * function for decoding joint stereo data
908
 *
909
 * @param q                 pointer to the COOKContext
910
 * @param mlt_buffer1       pointer to left channel mlt coefficients
911
 * @param mlt_buffer2       pointer to right channel mlt coefficients
912
 */
913

  
914
static void joint_decode(COOKContext *q, float* mlt_buffer1,
915
                         float* mlt_buffer2) {
916
    int i,j;
917
    int decouple_tab[SUBBAND_SIZE];
918
    float decode_buffer[2048];  //Only 1060 might be needed.
919
    int idx, cpl_tmp,tmp_idx;
920
    float f1,f2;
921
    float* cplscale;
922

  
923
    memset(decouple_tab, 0, sizeof(decouple_tab));
924
    memset(decode_buffer, 0, sizeof(decode_buffer));
925

  
926
    /* Make sure the buffers are zeroed out. */
927
    memset(mlt_buffer1,0, 1024*sizeof(float));
928
    memset(mlt_buffer2,0, 1024*sizeof(float));
929
    decouple_info(q, decouple_tab);
930
    mono_decode(q, decode_buffer);
931

  
932
    /* The two channels are stored interleaved in decode_buffer. */
933
    for (i=0 ; i<q->js_subband_start ; i++) {
934
        for (j=0 ; j<SUBBAND_SIZE ; j++) {
935
            mlt_buffer1[i*20+j] = decode_buffer[i*40+j];
936
            mlt_buffer2[i*20+j] = decode_buffer[i*40+20+j];
937
        }
938
    }
939

  
940
    /* When we reach js_subband_start (the higher frequencies)
941
       the coefficients are stored in a coupling scheme. */
942
    idx = (1 << q->js_vlc_bits) - 1;
943
    if (q->js_subband_start < q->subbands) {
944
        for (i=0 ; i<q->subbands ; i++) {
945
            cpl_tmp = cplband[i + q->js_subband_start];
946
            idx -=decouple_tab[cpl_tmp];
947
            cplscale = (float*)cplscales[q->js_vlc_bits-2];  //choose decoupler table
948
            f1 = cplscale[decouple_tab[cpl_tmp]];
949
            f2 = cplscale[idx-1];
950
            for (j=0 ; j<SUBBAND_SIZE ; j++) {
951
                tmp_idx = ((2*q->js_subband_start + i)*20)+j;
952
                mlt_buffer1[20*(i+q->js_subband_start) + j] = f1 * decode_buffer[tmp_idx];
953
                mlt_buffer2[20*(i+q->js_subband_start) + j] = f2 * decode_buffer[tmp_idx];
954
            }
955
            idx = (1 << q->js_vlc_bits) - 1;
956
        }
957
    }
958
}
959

  
960
/**
961
 * Cook subpacket decoding. This function returns one decoded subpacket,
962
 * usually 1024 samples per channel.
963
 *
964
 * @param q                 pointer to the COOKContext
965
 * @param inbuffer          pointer to the inbuffer
966
 * @param sub_packet_size   subpacket size
967
 * @param outbuffer         pointer to the outbuffer
968
 * @param pos               the subpacket number in the frame
969
 */
970

  
971

  
972
static int decode_subpacket(COOKContext *q, uint8_t *inbuffer,
973
                            int sub_packet_size, int16_t *outbuffer) {
974
    int i,j;
975
    int value;
976
    float* tmp_ptr;
977

  
978
    /* packet dump */
979
//    for (i=0 ; i<sub_packet_size ; i++) {
980
//        av_log(NULL, AV_LOG_ERROR, "%02x", inbuffer[i]);
981
//    }
982
//    av_log(NULL, AV_LOG_ERROR, "\n");
983

  
984
    decode_bytes(inbuffer, q->decoded_bytes_buffer, sub_packet_size);
985
    init_get_bits(&q->gb, q->decoded_bytes_buffer, sub_packet_size*8);
986
    decode_gain_info(&q->gb, &q->gain_current);
987
    memcpy(&q->gain_copy, &q->gain_current ,sizeof(COOKgain));  //This copy does not seem to be used. FIXME
988
    //fprintf(stdout,"cu bits ds = %d\n",get_bits_count(&q->gb));
989
    if(q->nb_channels==2 && q->joint_stereo==1){
990
        joint_decode(q, q->decode_buf_ptr[0], q->decode_buf_ptr[2]);
991

  
992
        /* Swap buffer pointers. */
993
        tmp_ptr = q->decode_buf_ptr[1];
994
        q->decode_buf_ptr[1] = q->decode_buf_ptr[0];
995
        q->decode_buf_ptr[0] = tmp_ptr;
996
        tmp_ptr = q->decode_buf_ptr[3];
997
        q->decode_buf_ptr[3] = q->decode_buf_ptr[2];
998
        q->decode_buf_ptr[2] = tmp_ptr;
999

  
1000
        /* FIXME: Rethink the gainbuffer handling, maybe a rename?
1001
           now/previous swap */
1002
        q->gain_now_ptr = &q->gain_now;
1003
        q->gain_previous_ptr = &q->gain_previous;
1004
        for (i=0 ; i<q->nb_channels ; i++){
1005

  
1006
            cook_imlt(q, q->decode_buf_ptr[i*2], q->mono_mdct_output, q->mlt_tmp);
1007
            gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
1008
                            q->gain_previous_ptr, q->previous_buffer_ptr[0]);
1009

  
1010
            /* Swap out the previous buffer. */
1011
            tmp_ptr = q->previous_buffer_ptr[0];
1012
            q->previous_buffer_ptr[0] = q->previous_buffer_ptr[1];
1013
            q->previous_buffer_ptr[1] = tmp_ptr;
1014

  
1015
            /* Clip and convert the floats to 16 bits. */
1016
            for (j=0 ; j<q->samples_per_frame ; j++){
1017
                value = lrintf(q->mono_mdct_output[j]);
1018
                if(value < -32768) value = -32768;
1019
                else if(value > 32767) value = 32767;
1020
                outbuffer[2*j+i] = value;
1021
            }
1022
        }
1023

  
1024
        memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain));
1025
        memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain));
1026

  
1027
    } else if (q->nb_channels==2 && q->joint_stereo==0) {
1028
        for (i=0 ; i<q->nb_channels ; i++){
1029
            mono_decode(q, q->decode_buf_ptr[0]);
1030

  
1031
            av_log(NULL,AV_LOG_ERROR,"Non-joint-stereo files are not supported at the moment, do not report as a bug!\n");
1032
            tmp_ptr = q->decode_buf_ptr[0];
1033
            q->decode_buf_ptr[0] = q->decode_buf_ptr[1];
1034
            q->decode_buf_ptr[1] = q->decode_buf_ptr[2];
1035
            q->decode_buf_ptr[2] = q->decode_buf_ptr[3];
1036
            q->decode_buf_ptr[3] = tmp_ptr;
1037

  
1038
            q->gain_now_ptr = &q->gain_now;
1039
            q->gain_previous_ptr = &q->gain_previous;
1040

  
1041
            cook_imlt(q, q->decode_buf_ptr[0], q->mono_mdct_output,q->mlt_tmp);
1042
            gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
1043
                            q->gain_previous_ptr, q->previous_buffer_ptr[0]);
1044
            /* Swap out the previous buffer. */
1045
            tmp_ptr = q->previous_buffer_ptr[0];
1046
            q->previous_buffer_ptr[0] = q->previous_buffer_ptr[1];
1047
            q->previous_buffer_ptr[1] = tmp_ptr;
1048

  
1049
            for (j=0 ; j<q->samples_per_frame ; j++){
1050
                value = lrintf(q->mono_mdct_output[j]);
1051
                if(value < -32768) value = -32768;
1052
                else if(value > 32767) value = 32767;
1053
                outbuffer[2*j+i] = value;
1054
            }
1055
            memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain));
1056
            memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain));
1057
        }
1058
    } else {
1059
        mono_decode(q, q->decode_buf_ptr[0]);
1060

  
1061
        /* Swap buffer pointers. */
1062
        tmp_ptr = q->decode_buf_ptr[1];
1063
        q->decode_buf_ptr[1] = q->decode_buf_ptr[0];
1064
        q->decode_buf_ptr[0] = tmp_ptr;
1065

  
1066
        /* FIXME: Rethink the gainbuffer handling, maybe a rename?
1067
           now/previous swap */
1068
        q->gain_now_ptr = &q->gain_now;
1069
        q->gain_previous_ptr = &q->gain_previous;
1070

  
1071
        cook_imlt(q, q->decode_buf_ptr[0], q->mono_mdct_output,q->mlt_tmp);
1072
        gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
1073
                        q->gain_previous_ptr, q->mono_previous_buffer1);
1074

  
1075
        /* Clip and convert the floats to 16 bits */
1076
        for (j=0 ; j<q->samples_per_frame ; j++){
1077
            value = lrintf(q->mono_mdct_output[j]);
1078
            if(value < -32768) value = -32768;
1079
            else if(value > 32767) value = 32767;
1080
            outbuffer[j] = value;
1081
        }
1082
        memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain));
1083
        memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain));
1084
    }
1085
    /* FIXME: Shouldn't the total number of bytes be returned? */
1086
    return /*q->nb_channels*/ q->samples_per_frame * sizeof(int16_t);
1087
}
1088

  
1089

  
1090
/**
1091
 * Cook frame decoding
1092
 *
1093
 * @param avctx     pointer to the AVCodecContext
1094
 */
1095

  
1096
static int cook_decode_frame(AVCodecContext *avctx,
1097
            void *data, int *data_size,
1098
            uint8_t *buf, int buf_size) {
1099
    /* This stuff is quite messy, the Cook packets are sent unordered
1100
     * and need to be ordered before they are sent to the rest of the
1101
     * decoder. The order can be found in the q->frame_reorder_index.
1102
     * Currently decoding of the last packets is not handled at
1103
     * all. FIXME */
1104

  
1105
    COOKContext *q = avctx->priv_data;
1106

  
1107
    if (buf_size < avctx->block_align)
1108
        return buf_size;
1109

  
1110
    *data_size = decode_subpacket(q, buf, avctx->block_align, data);
1111

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

  
1148
static int cook_decode_init(AVCodecContext *avctx)
1149
{
1150
    COOKextradata *e = avctx->extradata;
1151
    COOKContext *q = avctx->priv_data;
1152

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

  
1172
    /* Take data from the AVCodecContext (RM container). */
1173
    q->sample_rate = avctx->sample_rate;
1174
    q->nb_channels = avctx->channels;
1175
    q->bit_rate = avctx->bit_rate;
1176

  
1177
    /* Initialize state. */
1178
    q->random_state = 1;
1179

  
1180
    /* Initialize extradata related variables. */
1181
    q->samples_per_channel = e->samples_per_frame / q->nb_channels;
1182
    q->samples_per_frame = e->samples_per_frame;
1183
    q->subbands = e->subbands;
1184
    q->bits_per_subpacket = avctx->block_align * 8;
1185

  
1186
    /* Initialize default data states. */
1187
    q->js_subband_start = 0;
1188
    q->numvector_bits = 5;
1189
    q->total_subbands = q->subbands;
1190

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

  
1238
    /* Initialize variable relations */
1239
    q->mlt_size = q->samples_per_channel;
1240
    q->numvector_size = (1 << q->numvector_bits);
1241

  
1242
    /* Generate tables */
1243
    init_rootpow2table(q);
1244
    init_pow2table(q);
1245
    init_gain_table(q);
1246

  
1247
    if (init_cook_vlc_tables(q) != 0)
1248
        return -1;
1249

  
1250
    /* Pad the databuffer with FF_INPUT_BUFFER_PADDING_SIZE,
1251
       this is for the bitstreamreader. */
1252
    if ((q->decoded_bytes_buffer = av_mallocz((avctx->block_align+(4-avctx->block_align%4) + FF_INPUT_BUFFER_PADDING_SIZE)*sizeof(uint8_t)))  == NULL)
1253
        return -1;
1254

  
1255
    q->decode_buf_ptr[0] = q->decode_buffer_1;
1256
    q->decode_buf_ptr[1] = q->decode_buffer_2;
1257
    q->decode_buf_ptr[2] = q->decode_buffer_3;
1258
    q->decode_buf_ptr[3] = q->decode_buffer_4;
1259

  
1260
    q->previous_buffer_ptr[0] = q->mono_previous_buffer1;
1261
    q->previous_buffer_ptr[1] = q->mono_previous_buffer2;
1262

  
1263
    memset(q->decode_buffer_1,0,1024*sizeof(float));
1264
    memset(q->decode_buffer_2,0,1024*sizeof(float));
1265
    memset(q->decode_buffer_3,0,1024*sizeof(float));
1266
    memset(q->decode_buffer_4,0,1024*sizeof(float));
1267

  
1268
    /* Initialize transform. */
1269
    if ( init_cook_mlt(q) == 0 )
1270
        return -1;
1271

  
1272
    //dump_cook_context(q,e);
1273
    return 0;
1274
}
1275

  
1276

  
1277
AVCodec cook_decoder =
1278
{
1279
    .name = "cook",
1280
    .type = CODEC_TYPE_AUDIO,
1281
    .id = CODEC_ID_COOK,
1282
    .priv_data_size = sizeof(COOKContext),
1283
    .init = cook_decode_init,
1284
    .close = cook_decode_close,
1285
    .decode = cook_decode_frame,
1286
};
libavcodec/cookdata.h
1
/*
2
 * COOK compatible decoder data
3
 * Copyright (c) 2003 Sascha Sommer
4
 * Copyright (c) 2005 Benjamin Larsson
5
 *
6
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 *
20
 */
21

  
22
/**
23
 * @file cookdata.h
24
 * Cook AKA RealAudio G2 compatible decoderdata
25
 */
26

  
27
/* various data tables */
28

  
29
static const int expbits_tab[8] = {
30
    52,47,43,37,29,22,16,0,
31
};
32

  
33
static const float dither_tab[8] = {
34
  0.0, 0.0, 0.0, 0.0, 0.0, 0.176777, 0.25, 0.707107,
35
};
36

  
37
static const float randsign[2] = {1.0, -1.0};
38

  
39
static const float quant_centroid_tab[7][14] = {
40
  { 0.000, 0.392, 0.761, 1.120, 1.477, 1.832, 2.183, 2.541, 2.893, 3.245, 3.598, 3.942, 4.288, 4.724 },
41
  { 0.000, 0.544, 1.060, 1.563, 2.068, 2.571, 3.072, 3.562, 4.070, 4.620, 0.000, 0.000, 0.000, 0.000 },
42
  { 0.000, 0.746, 1.464, 2.180, 2.882, 3.584, 4.316, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000 },
43
  { 0.000, 1.006, 2.000, 2.993, 3.985, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000 },
44
  { 0.000, 1.321, 2.703, 3.983, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000 },
45
  { 0.000, 1.657, 3.491, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000 },
46
  { 0.000, 1.964, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000 }
47
};
48

  
49
static const int invradix_tab[7] = {
50
    74899, 104858, 149797, 209716, 262144, 349526, 524288,
51
};
52

  
53
static const int kmax_tab[7] = {
54
    13, 9, 6, 4, 3, 2, 1,
55
};
56

  
57
static const int vd_tab[7] = {
58
    2, 2, 2, 4, 4, 5, 5,
59
};
60

  
61
static const int vpr_tab[7] = {
62
    10, 10, 10, 5, 5, 4, 4,
63
};
64

  
65

  
66

  
67
/* VLC data */
68

  
69
static const int vhsize_tab[7] = {
70
    191, 97, 48, 607, 246, 230, 32,
71
};
72

  
73
static const int vhvlcsize_tab[7] = {
74
    8, 7, 7, 10, 9, 9, 6,
75
};
76

  
77
static const uint8_t envelope_quant_index_huffbits[13][24] = {
78
    {  4,  6,  5,  5,  4, 4, 4, 4, 4, 4, 3, 3, 3, 4, 5, 7,  8,  9, 11, 11, 12, 12, 12, 12 },
79
    { 10,  8,  6,  5,  5, 4, 3, 3, 3, 3, 3, 3, 4, 5, 7, 9, 11, 12, 13, 15, 15, 15, 16, 16 },
80
    { 12, 10,  8,  6,  5, 4, 4, 4, 4, 4, 4, 3, 3, 3, 4, 4,  5,  5,  7,  9, 11, 13, 14, 14 },
81
    { 13, 10,  9,  9,  7, 7, 5, 5, 4, 3, 3, 3, 3, 3, 4, 4,  4,  5,  7,  9, 11, 13, 13, 13 },
82
    { 12, 13, 10,  8,  6, 6, 5, 5, 4, 4, 3, 3, 3, 3, 3, 4,  5,  5,  6,  7,  9, 11, 14, 14 },
83
    { 12, 11,  9,  8,  8, 7, 5, 4, 4, 3, 3, 3, 3, 3, 4, 4,  5,  5,  7,  8, 10, 13, 14, 14 },
84
    { 15, 16, 15, 12, 10, 8, 6, 5, 4, 3, 3, 3, 2, 3, 4, 5,  5,  7,  9, 11, 13, 16, 16, 16 },
85
    { 14, 14, 11, 10,  9, 7, 7, 5, 5, 4, 3, 3, 2, 3, 3, 4,  5,  7,  9,  9, 12, 14, 15, 15 },
86
    {  9,  9,  9,  8,  7, 6, 5, 4, 3, 3, 3, 3, 3, 3, 4, 5,  6,  7,  8, 10, 11, 12, 13, 13 },
87
    { 14, 12, 10,  8,  6, 6, 5, 4, 3, 3, 3, 3, 3, 3, 4, 5,  6,  8,  8,  9, 11, 14, 14, 14 },
88
    { 13, 10,  9,  8,  6, 6, 5, 4, 4, 4, 3, 3, 2, 3, 4, 5,  6,  8,  9,  9, 11, 12, 14, 14 },
89
    { 16, 13, 12, 11,  9, 6, 5, 5, 4, 4, 4, 3, 2, 3, 3, 4,  5,  7,  8, 10, 14, 16, 16, 16 },
90
    { 13, 14, 14, 14, 10, 8, 7, 7, 5, 4, 3, 3, 2, 3, 3, 4,  5,  5,  7,  9, 11, 14, 14, 14 },
91
};
92

  
93
static const uint16_t envelope_quant_index_huffcodes[13][24] = {
94
    {0x0006, 0x003e, 0x001c, 0x001d, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x0000, 0x0001,
95
     0x0002, 0x000d, 0x001e, 0x007e, 0x00fe, 0x01fe, 0x07fc, 0x07fd, 0x0ffc, 0x0ffd, 0x0ffe, 0x0fff},
96
    {0x03fe, 0x00fe, 0x003e, 0x001c, 0x001d, 0x000c, 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005,
97
     0x000d, 0x001e, 0x007e, 0x01fe, 0x07fe, 0x0ffe, 0x1ffe, 0x7ffc, 0x7ffd, 0x7ffe, 0xfffe, 0xffff},
98
    {0x0ffe, 0x03fe, 0x00fe, 0x003e, 0x001c, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x0000,
99
     0x0001, 0x0002, 0x000c, 0x000d, 0x001d, 0x001e, 0x007e, 0x01fe, 0x07fe, 0x1ffe, 0x3ffe, 0x3fff},
100
    {0x1ffc, 0x03fe, 0x01fc, 0x01fd, 0x007c, 0x007d, 0x001c, 0x001d, 0x000a, 0x0000, 0x0001, 0x0002,
101
     0x0003, 0x0004, 0x000b, 0x000c, 0x000d, 0x001e, 0x007e, 0x01fe, 0x07fe, 0x1ffd, 0x1ffe, 0x1fff},
102
    {0x0ffe, 0x1ffe, 0x03fe, 0x00fe, 0x003c, 0x003d, 0x001a, 0x001b, 0x000a, 0x000b, 0x0000, 0x0001,
103
     0x0002, 0x0003, 0x0004, 0x000c, 0x001c, 0x001d, 0x003e, 0x007e, 0x01fe, 0x07fe, 0x3ffe, 0x3fff},
104
    {0x0ffe, 0x07fe, 0x01fe, 0x00fc, 0x00fd, 0x007c, 0x001c, 0x000a, 0x000b, 0x0000, 0x0001, 0x0002,
105
     0x0003, 0x0004, 0x000c, 0x000d, 0x001d, 0x001e, 0x007d, 0x00fe, 0x03fe, 0x1ffe, 0x3ffe, 0x3fff},
106
    {0x7ffc, 0xfffc, 0x7ffd, 0x0ffe, 0x03fe, 0x00fe, 0x003e, 0x001c, 0x000c, 0x0002, 0x0003, 0x0004,
107
     0x0000, 0x0005, 0x000d, 0x001d, 0x001e, 0x007e, 0x01fe, 0x07fe, 0x1ffe, 0xfffd, 0xfffe, 0xffff},
108
    {0x3ffc, 0x3ffd, 0x07fe, 0x03fe, 0x01fc, 0x007c, 0x007d, 0x001c, 0x001d, 0x000c, 0x0002, 0x0003,
109
     0x0000, 0x0004, 0x0005, 0x000d, 0x001e, 0x007e, 0x01fd, 0x01fe, 0x0ffe, 0x3ffe, 0x7ffe, 0x7fff},
110
    {0x01fc, 0x01fd, 0x01fe, 0x00fc, 0x007c, 0x003c, 0x001c, 0x000c, 0x0000, 0x0001, 0x0002, 0x0003,
111
     0x0004, 0x0005, 0x000d, 0x001d, 0x003d, 0x007d, 0x00fd, 0x03fe, 0x07fe, 0x0ffe, 0x1ffe, 0x1fff},
112
    {0x3ffc, 0x0ffe, 0x03fe, 0x00fc, 0x003c, 0x003d, 0x001c, 0x000c, 0x0000, 0x0001, 0x0002, 0x0003,
113
     0x0004, 0x0005, 0x000d, 0x001d, 0x003e, 0x00fd, 0x00fe, 0x01fe, 0x07fe, 0x3ffd, 0x3ffe, 0x3fff},
114
    {0x1ffe, 0x03fe, 0x01fc, 0x00fc, 0x003c, 0x003d, 0x001c, 0x000a, 0x000b, 0x000c, 0x0002, 0x0003,
115
     0x0000, 0x0004, 0x000d, 0x001d, 0x003e, 0x00fd, 0x01fd, 0x01fe, 0x07fe, 0x0ffe, 0x3ffe, 0x3fff},
116
    {0xfffc, 0x1ffe, 0x0ffe, 0x07fe, 0x01fe, 0x003e, 0x001c, 0x001d, 0x000a, 0x000b, 0x000c, 0x0002,
117
     0x0000, 0x0003, 0x0004, 0x000d, 0x001e, 0x007e, 0x00fe, 0x03fe, 0x3ffe, 0xfffd, 0xfffe, 0xffff},
118
    {0x1ffc, 0x3ffa, 0x3ffb, 0x3ffc, 0x03fe, 0x00fe, 0x007c, 0x007d, 0x001c, 0x000c, 0x0002, 0x0003,
119
     0x0000, 0x0004, 0x0005, 0x000d, 0x001d, 0x001e, 0x007e, 0x01fe, 0x07fe, 0x3ffd, 0x3ffe, 0x3fff},
120
};
121

  
122

  
123
static const uint8_t cvh_huffbits0[191] = {
124
    1, 4, 6, 6, 7, 7, 8, 8, 8, 9, 9, 10,
125
    11, 11, 4, 5, 6, 7, 7, 8, 8, 9, 9, 9,
126
    9, 10, 11, 11, 5, 6, 7, 8, 8, 9, 9, 9,
127
    9, 10, 10, 10, 11, 12, 6, 7, 8, 9, 9, 9,
128
    9, 10, 10, 10, 10, 11, 12, 13, 7, 7, 8, 9,
129
    9, 9, 10, 10, 10, 10, 11, 11, 12, 13, 8, 8,
130
    9, 9, 9, 10, 10, 10, 10, 11, 11, 12, 13, 14,
131
    8, 8, 9, 9, 10, 10, 11, 11, 11, 12, 12, 13,
132
    13, 15, 8, 8, 9, 9, 10, 10, 11, 11, 11, 12,
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff