libavcodec/cook.c

   1 /*
   2  * COOK compatible decoder
   3  * Copyright (c) 2003 Sascha Sommer
   4  * Copyright (c) 2005 Benjamin Larsson
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  *
  22  */
  23
  24 /**
  25  * @file cook.c
  26  * Cook compatible decoder.
  27  * This decoder handles RealNetworks, RealAudio G2 data.
  28  * Cook is identified by the codec name cook in RM files.
  29  *
  30  * To use this decoder, a calling application must supply the extradata
  31  * bytes provided from the RM container; 8+ bytes for mono streams and
  32  * 16+ for stereo streams (maybe more).
  33  *
  34  * Codec technicalities (all this assume a buffer length of 1024):
  35  * Cook works with several different techniques to achieve its compression.
  36  * In the timedomain the buffer is divided into 8 pieces and quantized. If
  37  * two neighboring pieces have different quantization index a smooth
  38  * quantization curve is used to get a smooth overlap between the different
  39  * pieces.
  40  * To get to the transformdomain Cook uses a modulated lapped transform.
  41  * The transform domain has 50 subbands with 20 elements each. This
  42  * means only a maximum of 50*20=1000 coefficients are used out of the 1024
  43  * available.
  44  */
  45
  46 #include <math.h>
  47 #include <stddef.h>
  48 #include <stdio.h>
  49
  50 #include "avcodec.h"
  51 #include "bitstream.h"
  52 #include "dsputil.h"
  53
  54 #include "cookdata.h"
  55
  56 /* the different Cook versions */
  57 #define MONO            0x1000001
  58 #define STEREO          0x1000002
  59 #define JOINT_STEREO    0x1000003
  60 #define MC_COOK         0x2000000   //multichannel Cook, not supported
  61
  62 #define SUBBAND_SIZE    20
  63 //#define COOKDEBUG
  64
  65 typedef struct {
  66     int     size;
  67     int     qidx_table1[8];
  68     int     qidx_table2[8];
  69 } COOKgain;
  70
  71 typedef struct __attribute__((__packed__)){
  72     /* codec data start */
  73     uint32_t cookversion;               //in network order, bigendian
  74     uint16_t samples_per_frame;         //amount of samples per frame per channel, bigendian
  75     uint16_t subbands;                  //amount of bands used in the frequency domain, bigendian
  76     /* Mono extradata ends here. */
  77     uint32_t unused;
  78     uint16_t js_subband_start;          //bigendian
  79     uint16_t js_vlc_bits;               //bigendian
  80     /* Stereo extradata ends here. */
  81 } COOKextradata;
  82
  83
  84 typedef struct {
  85     GetBitContext       gb;
  86     /* stream data */
  87     int                 nb_channels;
  88     int                 joint_stereo;
  89     int                 bit_rate;
  90     int                 sample_rate;
  91     int                 samples_per_channel;
  92     int                 samples_per_frame;
  93     int                 subbands;
  94     int                 log2_numvector_size;
  95     int                 numvector_size;                //1 << log2_numvector_size;
  96     int                 js_subband_start;
  97     int                 total_subbands;
  98     int                 num_vectors;
  99     int                 bits_per_subpacket;
 100     /* states */
 101     int                 random_state;
 102
 103     /* transform data */
 104     FFTContext          fft_ctx;
 105     FFTSample           mlt_tmp[1024] __attribute__((aligned(16))); /* temporary storage for imlt */
 106     float*              mlt_window;
 107     float*              mlt_precos;
 108     float*              mlt_presin;
 109     float*              mlt_postcos;
 110     int                 fft_size;
 111     int                 fft_order;
 112     int                 mlt_size;       //modulated lapped transform size
 113
 114     /* gain buffers */
 115     COOKgain*           gain_now_ptr;
 116     COOKgain*           gain_previous_ptr;
 117     COOKgain            gain_current;
 118     COOKgain            gain_now;
 119     COOKgain            gain_previous;
 120     COOKgain            gain_channel1[2];
 121     COOKgain            gain_channel2[2];
 122
 123     /* VLC data */
 124     int                 js_vlc_bits;
 125     VLC                 envelope_quant_index[13];
 126     VLC                 sqvh[7];          //scalar quantization
 127     VLC                 ccpl;             //channel coupling
 128
 129     /* generatable tables and related variables */
 130     int                 gain_size_factor;
 131     float               gain_table[23];
 132     float               pow2tab[127];
 133     float               rootpow2tab[127];
 134
 135     /* data buffers */
 136
 137     uint8_t*            decoded_bytes_buffer;
 138     float               mono_mdct_output[2048] __attribute__((aligned(16)));
 139     float*              previous_buffer_ptr[2];
 140     float               mono_previous_buffer1[1024];
 141     float               mono_previous_buffer2[1024];
 142     float*              decode_buf_ptr[4];
 143     float*              decode_buf_ptr2[2];
 144     float               decode_buffer_1[1024];
 145     float               decode_buffer_2[1024];
 146     float               decode_buffer_3[1024];
 147     float               decode_buffer_4[1024];
 148 } COOKContext;
 149
 150 /* debug functions */
 151
 152 #ifdef COOKDEBUG
 153 static void dump_float_table(float* table, int size, int delimiter) {
 154     int i=0;
 155     av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
 156     for (i=0 ; i<size ; i++) {
 157         av_log(NULL, AV_LOG_ERROR, "%5.1f, ", table[i]);
 158         if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
 159     }
 160 }
 161
 162 static void dump_int_table(int* table, int size, int delimiter) {
 163     int i=0;
 164     av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
 165     for (i=0 ; i<size ; i++) {
 166         av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);
 167         if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
 168     }
 169 }
 170
 171 static void dump_short_table(short* table, int size, int delimiter) {
 172     int i=0;
 173     av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
 174     for (i=0 ; i<size ; i++) {
 175         av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);
 176         if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
 177     }
 178 }
 179
 180 #endif
 181
 182 /*************** init functions ***************/
 183
 184 /* table generator */
 185 static void init_pow2table(COOKContext *q){
 186     int i;
 187     q->pow2tab[63] = 1.0;
 188     for (i=1 ; i<64 ; i++){
 189         q->pow2tab[63+i]=(float)((uint64_t)1<<i);
 190         q->pow2tab[63-i]=1.0/(float)((uint64_t)1<<i);
 191     }
 192 }
 193
 194 /* table generator */
 195 static void init_rootpow2table(COOKContext *q){
 196     int i;
 197     q->rootpow2tab[63] = 1.0;
 198     for (i=1 ; i<64 ; i++){
 199         q->rootpow2tab[63+i]=sqrt((float)((uint64_t)1<<i));
 200         q->rootpow2tab[63-i]=sqrt(1.0/(float)((uint64_t)1<<i));
 201     }
 202 }
 203
 204 /* table generator */
 205 static void init_gain_table(COOKContext *q) {
 206     int i;
 207     q->gain_size_factor = q->samples_per_channel/8;
 208     for (i=0 ; i<23 ; i++) {
 209         q->gain_table[i] = pow((double)q->pow2tab[i+52] ,
 210                                (1.0/(double)q->gain_size_factor));
 211     }
 212 }
 213
 214
 215 static int init_cook_vlc_tables(COOKContext *q) {
 216     int i, result;
 217
 218     result = 0;
 219     for (i=0 ; i<13 ; i++) {
 220         result &= init_vlc (&q->envelope_quant_index[i], 9, 24,
 221             envelope_quant_index_huffbits[i], 1, 1,
 222             envelope_quant_index_huffcodes[i], 2, 2, 0);
 223     }
 224     av_log(NULL,AV_LOG_DEBUG,"sqvh VLC init\n");
 225     for (i=0 ; i<7 ; i++) {
 226         result &= init_vlc (&q->sqvh[i], vhvlcsize_tab[i], vhsize_tab[i],
 227             cvh_huffbits[i], 1, 1,
 228             cvh_huffcodes[i], 2, 2, 0);
 229     }
 230
 231     if (q->nb_channels==2 && q->joint_stereo==1){
 232         result &= init_vlc (&q->ccpl, 6, (1<<q->js_vlc_bits)-1,
 233             ccpl_huffbits[q->js_vlc_bits-2], 1, 1,
 234             ccpl_huffcodes[q->js_vlc_bits-2], 2, 2, 0);
 235         av_log(NULL,AV_LOG_DEBUG,"Joint-stereo VLC used.\n");
 236     }
 237
 238     av_log(NULL,AV_LOG_DEBUG,"VLC tables initialized.\n");
 239     return result;
 240 }
 241
 242 static int init_cook_mlt(COOKContext *q) {
 243     int j;
 244     float alpha;
 245
 246     /* Allocate the buffers, could be replaced with a static [512]
 247        array if needed. */
 248     q->mlt_size = q->samples_per_channel;
 249     q->mlt_window = av_malloc(sizeof(float)*q->mlt_size);
 250     q->mlt_precos = av_malloc(sizeof(float)*q->mlt_size/2);
 251     q->mlt_presin = av_malloc(sizeof(float)*q->mlt_size/2);
 252     q->mlt_postcos = av_malloc(sizeof(float)*q->mlt_size/2);
 253
 254     /* Initialize the MLT window: simple sine window. */
 255     alpha = M_PI / (2.0 * (float)q->mlt_size);
 256     for(j=0 ; j<q->mlt_size ; j++) {
 257         q->mlt_window[j] = sin((j + 512.0/(float)q->mlt_size) * alpha);
 258     }
 259
 260     /* pre/post twiddle factors */
 261     for (j=0 ; j<q->mlt_size/2 ; j++){
 262         q->mlt_precos[j] = cos( ((j+0.25)*M_PI)/q->mlt_size);
 263         q->mlt_presin[j] = sin( ((j+0.25)*M_PI)/q->mlt_size);
 264         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
 265     }
 266
 267     /* Initialize the FFT. */
 268     ff_fft_init(&q->fft_ctx, av_log2(q->mlt_size)-1, 0);
 269     av_log(NULL,AV_LOG_DEBUG,"FFT initialized, order = %d.\n",
 270            av_log2(q->samples_per_channel)-1);
 271
 272     return (int)(q->mlt_window && q->mlt_precos && q->mlt_presin && q->mlt_postcos);
 273 }
 274
 275 /*************** init functions end ***********/
 276
 277 /**
 278  * Cook indata decoding, every 32 bits are XORed with 0x37c511f2.
 279  * Why? No idea, some checksum/error detection method maybe.
 280  *
 281  * Out buffer size: extra bytes are needed to cope with
 282  * padding/missalignment.
 283  * Subpackets passed to the decoder can contain two, consecutive
 284  * half-subpackets, of identical but arbitrary size.
 285  *          1234 1234 1234 1234  extraA extraB
 286  * Case 1:  AAAA BBBB              0      0
 287  * Case 2:  AAAA ABBB BB--         3      3
 288  * Case 3:  AAAA AABB BBBB         2      2
 289  * Case 4:  AAAA AAAB BBBB BB--    1      5
 290  *
 291  * Nice way to waste CPU cycles.
 292  *
 293  * @param inbuffer  pointer to byte array of indata
 294  * @param out       pointer to byte array of outdata
 295  * @param bytes     number of bytes
 296  */
 297 #define DECODE_BYTES_PAD1(bytes) (3 - ((bytes)+3) % 4)
 298 #define DECODE_BYTES_PAD2(bytes) ((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes)))
 299
 300 static inline int decode_bytes(uint8_t* inbuffer, uint8_t* out, int bytes){
 301     int i, off;
 302     uint32_t c;
 303     uint32_t* buf;
 304     uint32_t* obuf = (uint32_t*) out;
 305     /* FIXME: 64 bit platforms would be able to do 64 bits at a time.
 306      * I'm too lazy though, should be something like
 307      * for(i=0 ; i<bitamount/64 ; i++)
 308      *     (int64_t)out[i] = 0x37c511f237c511f2^be2me_64(int64_t)in[i]);
 309      * Buffer alignment needs to be checked. */
 310
 311     off = (uint32_t)inbuffer % 4;
 312     buf = (uint32_t*) (inbuffer - off);
 313     c = be2me_32((0x37c511f2 >> (off*8)) | (0x37c511f2 << (32-(off*8))));
 314     bytes += 3 + off;
 315     for (i = 0; i < bytes/4; i++)
 316         obuf[i] = c ^ buf[i];
 317
 318     return off;
 319 }
 320
 321 /**
 322  * Cook uninit
 323  */
 324
 325 static int cook_decode_close(AVCodecContext *avctx)
 326 {
 327     int i;
 328     COOKContext *q = avctx->priv_data;
 329     av_log(avctx,AV_LOG_DEBUG, "Deallocating memory.\n");
 330
 331     /* Free allocated memory buffers. */
 332     av_free(q->mlt_window);
 333     av_free(q->mlt_precos);
 334     av_free(q->mlt_presin);
 335     av_free(q->mlt_postcos);
 336     av_free(q->decoded_bytes_buffer);
 337
 338     /* Free the transform. */
 339     ff_fft_end(&q->fft_ctx);
 340
 341     /* Free the VLC tables. */
 342     for (i=0 ; i<13 ; i++) {
 343         free_vlc(&q->envelope_quant_index[i]);
 344     }
 345     for (i=0 ; i<7 ; i++) {
 346         free_vlc(&q->sqvh[i]);
 347     }
 348     if(q->nb_channels==2 && q->joint_stereo==1 ){
 349         free_vlc(&q->ccpl);
 350     }
 351
 352     av_log(NULL,AV_LOG_DEBUG,"Memory deallocated.\n");
 353
 354     return 0;
 355 }
 356
 357 /**
 358  * Fill the COOKgain structure for the timedomain quantization.
 359  *
 360  * @param q                 pointer to the COOKContext
 361  * @param gaininfo          pointer to the COOKgain
 362  */
 363
 364 static void decode_gain_info(GetBitContext *gb, COOKgain* gaininfo) {
 365     int i;
 366
 367     while (get_bits1(gb)) {}
 368
 369     gaininfo->size = get_bits_count(gb) - 1;     //amount of elements*2 to update
 370
 371     if (get_bits_count(gb) - 1 <= 0) return;
 372
 373     for (i=0 ; i<gaininfo->size ; i++){
 374         gaininfo->qidx_table1[i] = get_bits(gb,3);
 375         if (get_bits1(gb)) {
 376             gaininfo->qidx_table2[i] = get_bits(gb,4) - 7;  //convert to signed
 377         } else {
 378             gaininfo->qidx_table2[i] = -1;
 379         }
 380     }
 381 }
 382
 383 /**
 384  * Create the quant index table needed for the envelope.
 385  *
 386  * @param q                 pointer to the COOKContext
 387  * @param quant_index_table pointer to the array
 388  */
 389
 390 static void decode_envelope(COOKContext *q, int* quant_index_table) {
 391     int i,j, vlc_index;
 392     int bitbias;
 393
 394     bitbias = get_bits_count(&q->gb);
 395     quant_index_table[0]= get_bits(&q->gb,6) - 6;       //This is used later in categorize
 396
 397     for (i=1 ; i < q->total_subbands ; i++){
 398         vlc_index=i;
 399         if (i >= q->js_subband_start * 2) {
 400             vlc_index-=q->js_subband_start;
 401         } else {
 402             vlc_index/=2;
 403             if(vlc_index < 1) vlc_index = 1;
 404         }
 405         if (vlc_index>13) vlc_index = 13;           //the VLC tables >13 are identical to No. 13
 406
 407         j = get_vlc2(&q->gb, q->envelope_quant_index[vlc_index-1].table,
 408                      q->envelope_quant_index[vlc_index-1].bits,2);
 409         quant_index_table[i] = quant_index_table[i-1] + j - 12;    //differential encoding
 410     }
 411 }
 412
 413 /**
 414  * Create the quant value table.
 415  *
 416  * @param q                 pointer to the COOKContext
 417  * @param quant_value_table pointer to the array
 418  */
 419
 420 static void inline dequant_envelope(COOKContext *q, int* quant_index_table,
 421                                     float* quant_value_table){
 422
 423     int i;
 424     for(i=0 ; i < q->total_subbands ; i++){
 425         quant_value_table[i] = q->rootpow2tab[quant_index_table[i]+63];
 426     }
 427 }
 428
 429 /**
 430  * Calculate the category and category_index vector.
 431  *
 432  * @param q                     pointer to the COOKContext
 433  * @param quant_index_table     pointer to the array
 434  * @param category              pointer to the category array
 435  * @param category_index        pointer to the category_index array
 436  */
 437
 438 static void categorize(COOKContext *q, int* quant_index_table,
 439                        int* category, int* category_index){
 440     int exp_idx, bias, tmpbias, bits_left, num_bits, index, v, i, j;
 441     int exp_index2[102];
 442     int exp_index1[102];
 443
 444     int tmp_categorize_array1[128];
 445     int tmp_categorize_array1_idx=0;
 446     int tmp_categorize_array2[128];
 447     int tmp_categorize_array2_idx=0;
 448     int category_index_size=0;
 449
 450     bits_left =  q->bits_per_subpacket - get_bits_count(&q->gb);
 451
 452     if(bits_left > q->samples_per_channel) {
 453         bits_left = q->samples_per_channel +
 454                     ((bits_left - q->samples_per_channel)*5)/8;
 455         //av_log(NULL, AV_LOG_ERROR, "bits_left = %d\n",bits_left);
 456     }
 457
 458     memset(&exp_index1,0,102*sizeof(int));
 459     memset(&exp_index2,0,102*sizeof(int));
 460     memset(&tmp_categorize_array1,0,128*sizeof(int));
 461     memset(&tmp_categorize_array2,0,128*sizeof(int));
 462
 463     bias=-32;
 464
 465     /* Estimate bias. */
 466     for (i=32 ; i>0 ; i=i/2){
 467         num_bits = 0;
 468         index = 0;
 469         for (j=q->total_subbands ; j>0 ; j--){
 470             exp_idx = (i - quant_index_table[index] + bias) / 2;
 471             if (exp_idx<0){
 472                 exp_idx=0;
 473             } else if(exp_idx >7) {
 474                 exp_idx=7;
 475             }
 476             index++;
 477             num_bits+=expbits_tab[exp_idx];
 478         }
 479         if(num_bits >= bits_left - 32){
 480             bias+=i;
 481         }
 482     }
 483
 484     /* Calculate total number of bits. */
 485     num_bits=0;
 486     for (i=0 ; i<q->total_subbands ; i++) {
 487         exp_idx = (bias - quant_index_table[i]) / 2;
 488         if (exp_idx<0) {
 489             exp_idx=0;
 490         } else if(exp_idx >7) {
 491             exp_idx=7;
 492         }
 493         num_bits += expbits_tab[exp_idx];
 494         exp_index1[i] = exp_idx;
 495         exp_index2[i] = exp_idx;
 496     }
 497     tmpbias = bias = num_bits;
 498
 499     for (j = 1 ; j < q->numvector_size ; j++) {
 500         if (tmpbias + bias > 2*bits_left) {  /* ---> */
 501             int max = -999999;
 502             index=-1;
 503             for (i=0 ; i<q->total_subbands ; i++){
 504                 if (exp_index1[i] < 7) {
 505                     v = (-2*exp_index1[i]) - quant_index_table[i] - 32;
 506                     if ( v >= max) {
 507                         max = v;
 508                         index = i;
 509                     }
 510                 }
 511             }
 512             if(index==-1)break;
 513             tmp_categorize_array1[tmp_categorize_array1_idx++] = index;
 514             tmpbias -= expbits_tab[exp_index1[index]] -
 515                        expbits_tab[exp_index1[index]+1];
 516             ++exp_index1[index];
 517         } else {  /* <--- */
 518             int min = 999999;
 519             index=-1;
 520             for (i=0 ; i<q->total_subbands ; i++){
 521                 if(exp_index2[i] > 0){
 522                     v = (-2*exp_index2[i])-quant_index_table[i];
 523                     if ( v < min) {
 524                         min = v;
 525                         index = i;
 526                     }
 527                 }
 528             }
 529             if(index == -1)break;
 530             tmp_categorize_array2[tmp_categorize_array2_idx++] = index;
 531             tmpbias -= expbits_tab[exp_index2[index]] -
 532                        expbits_tab[exp_index2[index]-1];
 533             --exp_index2[index];
 534         }
 535     }
 536
 537     for(i=0 ; i<q->total_subbands ; i++)
 538         category[i] = exp_index2[i];
 539
 540     /* Concatenate the two arrays. */
 541     for(i=tmp_categorize_array2_idx-1 ; i >= 0; i--)
 542         category_index[category_index_size++] =  tmp_categorize_array2[i];
 543
 544     for(i=0;i<tmp_categorize_array1_idx;i++)
 545         category_index[category_index_size++ ] =  tmp_categorize_array1[i];
 546
 547     /* FIXME: mc_sich_ra8_20.rm triggers this, not sure with what we
 548        should fill the remaining bytes. */
 549     for(i=category_index_size;i<q->numvector_size;i++)
 550         category_index[i]=0;
 551
 552 }
 553
 554
 555 /**
 556  * Expand the category vector.
 557  *
 558  * @param q                     pointer to the COOKContext
 559  * @param category              pointer to the category array
 560  * @param category_index        pointer to the category_index array
 561  */
 562
 563 static void inline expand_category(COOKContext *q, int* category,
 564                                    int* category_index){
 565     int i;
 566     for(i=0 ; i<q->num_vectors ; i++){
 567         ++category[category_index[i]];
 568     }
 569 }
 570
 571 /**
 572  * The real requantization of the mltcoefs
 573  *
 574  * @param q                     pointer to the COOKContext
 575  * @param index                 index
 576  * @param band                  current subband
 577  * @param quant_value_table     pointer to the array
 578  * @param subband_coef_index    array of indexes to quant_centroid_tab
 579  * @param subband_coef_noise    use random noise instead of predetermined value
 580  * @param mlt_buffer            pointer to the mlt buffer
 581  */
 582
 583
 584 static void scalar_dequant(COOKContext *q, int index, int band,
 585                            float* quant_value_table, int* subband_coef_index,
 586                            int* subband_coef_noise, float* mlt_buffer){
 587     int i;
 588     float f1;
 589
 590     for(i=0 ; i<SUBBAND_SIZE ; i++) {
 591         if (subband_coef_index[i]) {
 592             if (subband_coef_noise[i]) {
 593                 f1 = -quant_centroid_tab[index][subband_coef_index[i]];
 594             } else {
 595                 f1 = quant_centroid_tab[index][subband_coef_index[i]];
 596             }
 597         } else {
 598             /* noise coding if subband_coef_noise[i] == 0 */
 599             q->random_state = q->random_state * 214013 + 2531011;    //typical RNG numbers
 600             f1 = randsign[(q->random_state/0x1000000)&1] * dither_tab[index]; //>>31
 601         }
 602         mlt_buffer[band*20+ i] = f1 * quant_value_table[band];
 603     }
 604 }
 605 /**
 606  * Unpack the subband_coef_index and subband_coef_noise vectors.
 607  *
 608  * @param q                     pointer to the COOKContext
 609  * @param category              pointer to the category array
 610  * @param subband_coef_index    array of indexes to quant_centroid_tab
 611  * @param subband_coef_noise    use random noise instead of predetermined value
 612  */
 613
 614 static int unpack_SQVH(COOKContext *q, int category, int* subband_coef_index,
 615                        int* subband_coef_noise) {
 616     int i,j;
 617     int vlc, vd ,tmp, result;
 618     int ub;
 619     int cb;
 620
 621     vd = vd_tab[category];
 622     result = 0;
 623     for(i=0 ; i<vpr_tab[category] ; i++){
 624         ub = get_bits_count(&q->gb);
 625         vlc = get_vlc2(&q->gb, q->sqvh[category].table, q->sqvh[category].bits, 3);
 626         cb = get_bits_count(&q->gb);
 627         if (q->bits_per_subpacket < get_bits_count(&q->gb)){
 628             vlc = 0;
 629             result = 1;
 630         }
 631         for(j=vd-1 ; j>=0 ; j--){
 632             tmp = (vlc * invradix_tab[category])/0x100000;
 633             subband_coef_index[vd*i+j] = vlc - tmp * (kmax_tab[category]+1);
 634             vlc = tmp;
 635         }
 636         for(j=0 ; j<vd ; j++){
 637             if (subband_coef_index[i*vd + j]) {
 638                 if(get_bits_count(&q->gb) < q->bits_per_subpacket){
 639                     subband_coef_noise[i*vd+j] = get_bits1(&q->gb);
 640                 } else {
 641                     result=1;
 642                     subband_coef_noise[i*vd+j]=0;
 643                 }
 644             } else {
 645                 subband_coef_noise[i*vd+j]=0;
 646             }
 647         }
 648     }
 649     return result;
 650 }
 651
 652
 653 /**
 654  * Fill the mlt_buffer with mlt coefficients.
 655  *
 656  * @param q                 pointer to the COOKContext
 657  * @param category          pointer to the category array
 658  * @param quant_value_table pointer to the array
 659  * @param mlt_buffer        pointer to mlt coefficients
 660  */
 661
 662
 663 static void decode_vectors(COOKContext* q, int* category,
 664                            float* quant_value_table, float* mlt_buffer){
 665     /* A zero in this table means that the subband coefficient is
 666        random noise coded. */
 667     int subband_coef_noise[SUBBAND_SIZE];
 668     /* A zero in this table means that the subband coefficient is a
 669        positive multiplicator. */
 670     int subband_coef_index[SUBBAND_SIZE];
 671     int band, j;
 672     int index=0;
 673
 674     for(band=0 ; band<q->total_subbands ; band++){
 675         index = category[band];
 676         if(category[band] < 7){
 677             if(unpack_SQVH(q, category[band], subband_coef_index, subband_coef_noise)){
 678                 index=7;
 679                 for(j=0 ; j<q->total_subbands ; j++) category[band+j]=7;
 680             }
 681         }
 682         if(index==7) {
 683             memset(subband_coef_index, 0, sizeof(subband_coef_index));
 684             memset(subband_coef_noise, 0, sizeof(subband_coef_noise));
 685         }
 686         scalar_dequant(q, index, band, quant_value_table, subband_coef_index,
 687                        subband_coef_noise, mlt_buffer);
 688     }
 689
 690     if(q->total_subbands*SUBBAND_SIZE >= q->samples_per_channel){
 691         return;
 692     }
 693 }
 694
 695
 696 /**
 697  * function for decoding mono data
 698  *
 699  * @param q                 pointer to the COOKContext
 700  * @param mlt_buffer1       pointer to left channel mlt coefficients
 701  * @param mlt_buffer2       pointer to right channel mlt coefficients
 702  */
 703
 704 static void mono_decode(COOKContext *q, float* mlt_buffer) {
 705
 706     int category_index[128];
 707     float quant_value_table[102];
 708     int quant_index_table[102];
 709     int category[128];
 710
 711     memset(&category, 0, 128*sizeof(int));
 712     memset(&quant_value_table, 0, 102*sizeof(int));
 713     memset(&category_index, 0, 128*sizeof(int));
 714
 715     decode_envelope(q, quant_index_table);
 716     q->num_vectors = get_bits(&q->gb,q->log2_numvector_size);
 717     dequant_envelope(q, quant_index_table, quant_value_table);
 718     categorize(q, quant_index_table, category, category_index);
 719     expand_category(q, category, category_index);
 720     decode_vectors(q, category, quant_value_table, mlt_buffer);
 721 }
 722
 723
 724 /**
 725  * The modulated lapped transform, this takes transform coefficients
 726  * and transforms them into timedomain samples. This is done through
 727  * an FFT-based algorithm with pre- and postrotation steps.
 728  * A window and reorder step is also included.
 729  *
 730  * @param q                 pointer to the COOKContext
 731  * @param inbuffer          pointer to the mltcoefficients
 732  * @param outbuffer         pointer to the timedomain buffer
 733  * @param mlt_tmp           pointer to temporary storage space
 734  */
 735
 736 static void cook_imlt(COOKContext *q, float* inbuffer, float* outbuffer,
 737                       float* mlt_tmp){
 738     int i;
 739
 740     /* prerotation */
 741     for(i=0 ; i<q->mlt_size ; i+=2){
 742         outbuffer[i] = (q->mlt_presin[i/2] * inbuffer[q->mlt_size-1-i]) +
 743                        (q->mlt_precos[i/2] * inbuffer[i]);
 744         outbuffer[i+1] = (q->mlt_precos[i/2] * inbuffer[q->mlt_size-1-i]) -
 745                          (q->mlt_presin[i/2] * inbuffer[i]);
 746     }
 747
 748     /* FFT */
 749     ff_fft_permute(&q->fft_ctx, (FFTComplex *) outbuffer);
 750     ff_fft_calc (&q->fft_ctx, (FFTComplex *) outbuffer);
 751
 752     /* postrotation */
 753     for(i=0 ; i<q->mlt_size ; i+=2){
 754         mlt_tmp[i] =               (q->mlt_postcos[(q->mlt_size-1-i)/2] * outbuffer[i+1]) +
 755                                    (q->mlt_postcos[i/2] * outbuffer[i]);
 756         mlt_tmp[q->mlt_size-1-i] = (q->mlt_postcos[(q->mlt_size-1-i)/2] * outbuffer[i]) -
 757                                    (q->mlt_postcos[i/2] * outbuffer[i+1]);
 758     }
 759
 760     /* window and reorder */
 761     for(i=0 ; i<q->mlt_size/2 ; i++){
 762         outbuffer[i] = mlt_tmp[q->mlt_size/2-1-i] * q->mlt_window[i];
 763         outbuffer[q->mlt_size-1-i]= mlt_tmp[q->mlt_size/2-1-i] *
 764                                     q->mlt_window[q->mlt_size-1-i];
 765         outbuffer[q->mlt_size+i]= mlt_tmp[q->mlt_size/2+i] *
 766                                   q->mlt_window[q->mlt_size-1-i];
 767         outbuffer[2*q->mlt_size-1-i]= -(mlt_tmp[q->mlt_size/2+i] *
 768                                       q->mlt_window[i]);
 769     }
 770 }
 771
 772
 773 /**
 774  * the actual requantization of the timedomain samples
 775  *
 776  * @param q                 pointer to the COOKContext
 777  * @param buffer            pointer to the timedomain buffer
 778  * @param gain_index        index for the block multiplier
 779  * @param gain_index_next   index for the next block multiplier
 780  */
 781
 782 static void interpolate(COOKContext *q, float* buffer,
 783                         int gain_index, int gain_index_next){
 784     int i;
 785     float fc1, fc2;
 786     fc1 = q->pow2tab[gain_index+63];
 787
 788     if(gain_index == gain_index_next){              //static gain
 789         for(i=0 ; i<q->gain_size_factor ; i++){
 790             buffer[i]*=fc1;
 791         }
 792         return;
 793     } else {                                        //smooth gain
 794         fc2 = q->gain_table[11 + (gain_index_next-gain_index)];
 795         for(i=0 ; i<q->gain_size_factor ; i++){
 796             buffer[i]*=fc1;
 797             fc1*=fc2;
 798         }
 799         return;
 800     }
 801 }
 802
 803 /**
 804  * timedomain requantization of the timedomain samples
 805  *
 806  * @param q                 pointer to the COOKContext
 807  * @param buffer            pointer to the timedomain buffer
 808  * @param gain_now          current gain structure
 809  * @param gain_previous     previous gain structure
 810  */
 811
 812 static void gain_window(COOKContext *q, float* buffer, COOKgain* gain_now,
 813                         COOKgain* gain_previous){
 814     int i, index;
 815     int gain_index[9];
 816     int tmp_gain_index;
 817
 818     gain_index[8]=0;
 819     index = gain_previous->size;
 820     for (i=7 ; i>=0 ; i--) {
 821         if(index && gain_previous->qidx_table1[index-1]==i) {
 822             gain_index[i] = gain_previous->qidx_table2[index-1];
 823             index--;
 824         } else {
 825             gain_index[i]=gain_index[i+1];
 826         }
 827     }
 828     /* This is applied to the to be previous data buffer. */
 829     for(i=0;i<8;i++){
 830         interpolate(q, &buffer[q->samples_per_channel+q->gain_size_factor*i],
 831                     gain_index[i], gain_index[i+1]);
 832     }
 833
 834     tmp_gain_index = gain_index[0];
 835     index = gain_now->size;
 836     for (i=7 ; i>=0 ; i--) {
 837         if(index && gain_now->qidx_table1[index-1]==i) {
 838             gain_index[i]= gain_now->qidx_table2[index-1];
 839             index--;
 840         } else {
 841             gain_index[i]=gain_index[i+1];
 842         }
 843     }
 844
 845     /* This is applied to the to be current block. */
 846     for(i=0;i<8;i++){
 847         interpolate(q, &buffer[i*q->gain_size_factor],
 848                     tmp_gain_index+gain_index[i],
 849                     tmp_gain_index+gain_index[i+1]);
 850     }
 851 }
 852
 853
 854 /**
 855  * mlt overlapping and buffer management
 856  *
 857  * @param q                 pointer to the COOKContext
 858  * @param buffer            pointer to the timedomain buffer
 859  * @param gain_now          current gain structure
 860  * @param gain_previous     previous gain structure
 861  * @param previous_buffer   pointer to the previous buffer to be used for overlapping
 862  *
 863  */
 864
 865 static void gain_compensate(COOKContext *q, float* buffer, COOKgain* gain_now,
 866                             COOKgain* gain_previous, float* previous_buffer) {
 867     int i;
 868     if((gain_now->size  || gain_previous->size)) {
 869         gain_window(q, buffer, gain_now, gain_previous);
 870     }
 871
 872     /* Overlap with the previous block. */
 873     for(i=0 ; i<q->samples_per_channel ; i++) buffer[i]+=previous_buffer[i];
 874
 875     /* Save away the current to be previous block. */
 876     memcpy(previous_buffer, buffer+q->samples_per_channel,
 877            sizeof(float)*q->samples_per_channel);
 878 }
 879
 880
 881 /**
 882  * function for getting the jointstereo coupling information
 883  *
 884  * @param q                 pointer to the COOKContext
 885  * @param decouple_tab      decoupling array
 886  *
 887  */
 888
 889 static void decouple_info(COOKContext *q, int* decouple_tab){
 890     int length, i;
 891
 892     if(get_bits1(&q->gb)) {
 893         if(cplband[q->js_subband_start] > cplband[q->subbands-1]) return;
 894
 895         length = cplband[q->subbands-1] - cplband[q->js_subband_start] + 1;
 896         for (i=0 ; i<length ; i++) {
 897             decouple_tab[cplband[q->js_subband_start] + i] = get_vlc2(&q->gb, q->ccpl.table, q->ccpl.bits, 2);
 898         }
 899         return;
 900     }
 901
 902     if(cplband[q->js_subband_start] > cplband[q->subbands-1]) return;
 903
 904     length = cplband[q->subbands-1] - cplband[q->js_subband_start] + 1;
 905     for (i=0 ; i<length ; i++) {
 906        decouple_tab[cplband[q->js_subband_start] + i] = get_bits(&q->gb, q->js_vlc_bits);
 907     }
 908     return;
 909 }
 910
 911
 912 /**
 913  * function for decoding joint stereo data
 914  *
 915  * @param q                 pointer to the COOKContext
 916  * @param mlt_buffer1       pointer to left channel mlt coefficients
 917  * @param mlt_buffer2       pointer to right channel mlt coefficients
 918  */
 919
 920 static void joint_decode(COOKContext *q, float* mlt_buffer1,
 921                          float* mlt_buffer2) {
 922     int i,j;
 923     int decouple_tab[SUBBAND_SIZE];
 924     float decode_buffer[1060];
 925     int idx, cpl_tmp,tmp_idx;
 926     float f1,f2;
 927     float* cplscale;
 928
 929     memset(decouple_tab, 0, sizeof(decouple_tab));
 930     memset(decode_buffer, 0, sizeof(decode_buffer));
 931
 932     /* Make sure the buffers are zeroed out. */
 933     memset(mlt_buffer1,0, 1024*sizeof(float));
 934     memset(mlt_buffer2,0, 1024*sizeof(float));
 935     decouple_info(q, decouple_tab);
 936     mono_decode(q, decode_buffer);
 937
 938     /* The two channels are stored interleaved in decode_buffer. */
 939     for (i=0 ; i<q->js_subband_start ; i++) {
 940         for (j=0 ; j<SUBBAND_SIZE ; j++) {
 941             mlt_buffer1[i*20+j] = decode_buffer[i*40+j];
 942             mlt_buffer2[i*20+j] = decode_buffer[i*40+20+j];
 943         }
 944     }
 945
 946     /* When we reach js_subband_start (the higher frequencies)
 947        the coefficients are stored in a coupling scheme. */
 948     idx = (1 << q->js_vlc_bits) - 1;
 949     for (i=q->js_subband_start ; i<q->subbands ; i++) {
 950         cpl_tmp = cplband[i];
 951         idx -=decouple_tab[cpl_tmp];
 952         cplscale = (float*)cplscales[q->js_vlc_bits-2];  //choose decoupler table
 953         f1 = cplscale[decouple_tab[cpl_tmp]];
 954         f2 = cplscale[idx-1];
 955         for (j=0 ; j<SUBBAND_SIZE ; j++) {
 956             tmp_idx = ((q->js_subband_start + i)*20)+j;
 957             mlt_buffer1[20*i + j] = f1 * decode_buffer[tmp_idx];
 958             mlt_buffer2[20*i + j] = f2 * decode_buffer[tmp_idx];
 959         }
 960         idx = (1 << q->js_vlc_bits) - 1;
 961     }
 962 }
 963
 964 /**
 965  * First part of subpacket decoding:
 966  *  decode raw stream bytes and read gain info.
 967  *
 968  * @param q                 pointer to the COOKContext
 969  * @param inbuffer          pointer to raw stream data
 970  * @param gain_ptr          array of current/prev gain pointers
 971  */
 972
 973 static inline void
 974 decode_bytes_and_gain(COOKContext *q, uint8_t *inbuffer, COOKgain *gain_ptr)
 975 {
 976     int offset;
 977
 978     offset = decode_bytes(inbuffer, q->decoded_bytes_buffer,
 979                           q->bits_per_subpacket/8);
 980     init_get_bits(&q->gb, q->decoded_bytes_buffer + offset,
 981                   q->bits_per_subpacket);
 982     decode_gain_info(&q->gb, gain_ptr);
 983 }
 984
 985
 986 /**
 987  * Cook subpacket decoding. This function returns one decoded subpacket,
 988  * usually 1024 samples per channel.
 989  *
 990  * @param q                 pointer to the COOKContext
 991  * @param inbuffer          pointer to the inbuffer
 992  * @param sub_packet_size   subpacket size
 993  * @param outbuffer         pointer to the outbuffer
 994  */
 995
 996
 997 static int decode_subpacket(COOKContext *q, uint8_t *inbuffer,
 998                             int sub_packet_size, int16_t *outbuffer) {
 999     int i,j;
1000     int value;
1001     float* tmp_ptr;
1002
1003     /* packet dump */
1004 //    for (i=0 ; i<sub_packet_size ; i++) {
1005 //        av_log(NULL, AV_LOG_ERROR, "%02x", inbuffer[i]);
1006 //    }
1007 //    av_log(NULL, AV_LOG_ERROR, "\n");
1008
1009     if(q->nb_channels==2 && q->joint_stereo==1){
1010         decode_bytes_and_gain(q, inbuffer, &q->gain_current);
1011
1012         joint_decode(q, q->decode_buf_ptr[0], q->decode_buf_ptr[2]);
1013
1014         /* Swap buffer pointers. */
1015         tmp_ptr = q->decode_buf_ptr[1];
1016         q->decode_buf_ptr[1] = q->decode_buf_ptr[0];
1017         q->decode_buf_ptr[0] = tmp_ptr;
1018         tmp_ptr = q->decode_buf_ptr[3];
1019         q->decode_buf_ptr[3] = q->decode_buf_ptr[2];
1020         q->decode_buf_ptr[2] = tmp_ptr;
1021
1022         /* FIXME: Rethink the gainbuffer handling, maybe a rename?
1023            now/previous swap */
1024         q->gain_now_ptr = &q->gain_now;
1025         q->gain_previous_ptr = &q->gain_previous;
1026         for (i=0 ; i<q->nb_channels ; i++){
1027
1028             cook_imlt(q, q->decode_buf_ptr[i*2], q->mono_mdct_output, q->mlt_tmp);
1029             gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
1030                             q->gain_previous_ptr, q->previous_buffer_ptr[0]);
1031
1032             /* Swap out the previous buffer. */
1033             tmp_ptr = q->previous_buffer_ptr[0];
1034             q->previous_buffer_ptr[0] = q->previous_buffer_ptr[1];
1035             q->previous_buffer_ptr[1] = tmp_ptr;
1036
1037             /* Clip and convert the floats to 16 bits. */
1038             for (j=0 ; j<q->samples_per_frame ; j++){
1039                 value = lrintf(q->mono_mdct_output[j]);
1040                 if(value < -32768) value = -32768;
1041                 else if(value > 32767) value = 32767;
1042                 outbuffer[2*j+i] = value;
1043             }
1044         }
1045
1046         memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain));
1047         memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain));
1048
1049     } else if (q->nb_channels==2 && q->joint_stereo==0) {
1050             /* channel 0 */
1051             decode_bytes_and_gain(q, inbuffer, &q->gain_current);
1052
1053             mono_decode(q, q->decode_buf_ptr2[0]);
1054
1055             tmp_ptr = q->decode_buf_ptr2[0];
1056             q->decode_buf_ptr2[0] = q->decode_buf_ptr2[1];
1057             q->decode_buf_ptr2[1] = tmp_ptr;
1058
1059             memcpy(&q->gain_channel1[0], &q->gain_current ,sizeof(COOKgain));
1060             q->gain_now_ptr = &q->gain_channel1[0];
1061             q->gain_previous_ptr = &q->gain_channel1[1];
1062
1063             cook_imlt(q, q->decode_buf_ptr2[0], q->mono_mdct_output,q->mlt_tmp);
1064             gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
1065                             q->gain_previous_ptr, q->mono_previous_buffer1);
1066
1067             memcpy(&q->gain_channel1[1], &q->gain_channel1[0],sizeof(COOKgain));
1068
1069
1070             for (j=0 ; j<q->samples_per_frame ; j++){
1071                 value = lrintf(q->mono_mdct_output[j]);
1072                 if(value < -32768) value = -32768;
1073                 else if(value > 32767) value = 32767;
1074                 outbuffer[2*j] = value;
1075             }
1076
1077             /* channel 1 */
1078             //av_log(NULL,AV_LOG_ERROR,"bits = %d\n",get_bits_count(&q->gb));
1079             decode_bytes_and_gain(q, inbuffer + sub_packet_size/2,
1080                                   &q->gain_channel2[0]);
1081
1082             q->gain_now_ptr = &q->gain_channel2[0];
1083             q->gain_previous_ptr = &q->gain_channel2[1];
1084
1085             mono_decode(q, q->decode_buf_ptr[0]);
1086
1087             tmp_ptr = q->decode_buf_ptr[0];
1088             q->decode_buf_ptr[0] = q->decode_buf_ptr[1];
1089             q->decode_buf_ptr[1] = tmp_ptr;
1090
1091             cook_imlt(q, q->decode_buf_ptr[0], q->mono_mdct_output,q->mlt_tmp);
1092             gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
1093                             q->gain_previous_ptr, q->mono_previous_buffer2);
1094
1095             /* Swap out the previous buffer. */
1096             tmp_ptr = q->previous_buffer_ptr[0];
1097             q->previous_buffer_ptr[0] = q->previous_buffer_ptr[1];
1098             q->previous_buffer_ptr[1] = tmp_ptr;
1099
1100             memcpy(&q->gain_channel2[1], &q->gain_channel2[0] ,sizeof(COOKgain));
1101
1102             for (j=0 ; j<q->samples_per_frame ; j++){
1103                 value = lrintf(q->mono_mdct_output[j]);
1104                 if(value < -32768) value = -32768;
1105                 else if(value > 32767) value = 32767;
1106                 outbuffer[2*j+1] = value;
1107             }
1108
1109     } else {
1110         decode_bytes_and_gain(q, inbuffer, &q->gain_current);
1111
1112         mono_decode(q, q->decode_buf_ptr[0]);
1113
1114         /* Swap buffer pointers. */
1115         tmp_ptr = q->decode_buf_ptr[1];
1116         q->decode_buf_ptr[1] = q->decode_buf_ptr[0];
1117         q->decode_buf_ptr[0] = tmp_ptr;
1118
1119         /* FIXME: Rethink the gainbuffer handling, maybe a rename?
1120            now/previous swap */
1121         q->gain_now_ptr = &q->gain_now;
1122         q->gain_previous_ptr = &q->gain_previous;
1123
1124         cook_imlt(q, q->decode_buf_ptr[0], q->mono_mdct_output,q->mlt_tmp);
1125         gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
1126                         q->gain_previous_ptr, q->mono_previous_buffer1);
1127
1128         /* Clip and convert the floats to 16 bits */
1129         for (j=0 ; j<q->samples_per_frame ; j++){
1130             value = lrintf(q->mono_mdct_output[j]);
1131             if(value < -32768) value = -32768;
1132             else if(value > 32767) value = 32767;
1133             outbuffer[j] = value;
1134         }
1135         memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain));
1136         memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain));
1137     }
1138     return q->samples_per_frame * sizeof(int16_t);
1139 }
1140
1141
1142 /**
1143  * Cook frame decoding
1144  *
1145  * @param avctx     pointer to the AVCodecContext
1146  */
1147
1148 static int cook_decode_frame(AVCodecContext *avctx,
1149             void *data, int *data_size,
1150             uint8_t *buf, int buf_size) {
1151     COOKContext *q = avctx->priv_data;
1152
1153     if (buf_size < avctx->block_align)
1154         return buf_size;
1155
1156     *data_size = decode_subpacket(q, buf, avctx->block_align, data);
1157
1158     return avctx->block_align;
1159 }
1160
1161 #ifdef COOKDEBUG
1162 static void dump_cook_context(COOKContext *q, COOKextradata *e)
1163 {
1164     //int i=0;
1165 #define PRINT(a,b) av_log(NULL,AV_LOG_ERROR," %s = %d\n", a, b);
1166     av_log(NULL,AV_LOG_ERROR,"COOKextradata\n");
1167     av_log(NULL,AV_LOG_ERROR,"cookversion=%x\n",e->cookversion);
1168     if (e->cookversion > STEREO) {
1169         PRINT("js_subband_start",e->js_subband_start);
1170         PRINT("js_vlc_bits",e->js_vlc_bits);
1171     }
1172     av_log(NULL,AV_LOG_ERROR,"COOKContext\n");
1173     PRINT("nb_channels",q->nb_channels);
1174     PRINT("bit_rate",q->bit_rate);
1175     PRINT("sample_rate",q->sample_rate);
1176     PRINT("samples_per_channel",q->samples_per_channel);
1177     PRINT("samples_per_frame",q->samples_per_frame);
1178     PRINT("subbands",q->subbands);
1179     PRINT("random_state",q->random_state);
1180     PRINT("mlt_size",q->mlt_size);
1181     PRINT("js_subband_start",q->js_subband_start);
1182     PRINT("log2_numvector_size",q->log2_numvector_size);
1183     PRINT("numvector_size",q->numvector_size);
1184     PRINT("total_subbands",q->total_subbands);
1185 }
1186 #endif
1187
1188 /**
1189  * Cook initialization
1190  *
1191  * @param avctx     pointer to the AVCodecContext
1192  */
1193
1194 static int cook_decode_init(AVCodecContext *avctx)
1195 {
1196     COOKextradata *e = (COOKextradata *)avctx->extradata;
1197     COOKContext *q = avctx->priv_data;
1198
1199     /* Take care of the codec specific extradata. */
1200     if (avctx->extradata_size <= 0) {
1201         av_log(avctx,AV_LOG_ERROR,"Necessary extradata missing!\n");
1202         return -1;
1203     } else {
1204         /* 8 for mono, 16 for stereo, ? for multichannel
1205            Swap to right endianness so we don't need to care later on. */
1206         av_log(avctx,AV_LOG_DEBUG,"codecdata_length=%d\n",avctx->extradata_size);
1207         if (avctx->extradata_size >= 8){
1208             e->cookversion = be2me_32(e->cookversion);
1209             e->samples_per_frame = be2me_16(e->samples_per_frame);
1210             e->subbands = be2me_16(e->subbands);
1211         }
1212         if (avctx->extradata_size >= 16){
1213             e->js_subband_start = be2me_16(e->js_subband_start);
1214             e->js_vlc_bits = be2me_16(e->js_vlc_bits);
1215         }
1216     }
1217
1218     /* Take data from the AVCodecContext (RM container). */
1219     q->sample_rate = avctx->sample_rate;
1220     q->nb_channels = avctx->channels;
1221     q->bit_rate = avctx->bit_rate;
1222
1223     /* Initialize state. */
1224     q->random_state = 1;
1225
1226     /* Initialize extradata related variables. */
1227     q->samples_per_channel = e->samples_per_frame / q->nb_channels;
1228     q->samples_per_frame = e->samples_per_frame;
1229     q->subbands = e->subbands;
1230     q->bits_per_subpacket = avctx->block_align * 8;
1231
1232     /* Initialize default data states. */
1233     q->js_subband_start = 0;
1234     q->log2_numvector_size = 5;
1235     q->total_subbands = q->subbands;
1236
1237     /* Initialize version-dependent variables */
1238     av_log(NULL,AV_LOG_DEBUG,"e->cookversion=%x\n",e->cookversion);
1239     switch (e->cookversion) {
1240         case MONO:
1241             if (q->nb_channels != 1) {
1242                 av_log(avctx,AV_LOG_ERROR,"Container channels != 1, report sample!\n");
1243                 return -1;
1244             }
1245             av_log(avctx,AV_LOG_DEBUG,"MONO\n");
1246             break;
1247         case STEREO:
1248             if (q->nb_channels != 1) {
1249                 q->joint_stereo = 0;
1250                 q->bits_per_subpacket = q->bits_per_subpacket/2;
1251             }
1252             av_log(avctx,AV_LOG_DEBUG,"STEREO\n");
1253             break;
1254         case JOINT_STEREO:
1255             if (q->nb_channels != 2) {
1256                 av_log(avctx,AV_LOG_ERROR,"Container channels != 2, report sample!\n");
1257                 return -1;
1258             }
1259             av_log(avctx,AV_LOG_DEBUG,"JOINT_STEREO\n");
1260             if (avctx->extradata_size >= 16){
1261                 q->total_subbands = q->subbands + e->js_subband_start;
1262                 q->js_subband_start = e->js_subband_start;
1263                 q->joint_stereo = 1;
1264                 q->js_vlc_bits = e->js_vlc_bits;
1265             }
1266             if (q->samples_per_channel > 256) {
1267                 q->log2_numvector_size  = 6;
1268             }
1269             if (q->samples_per_channel > 512) {
1270                 q->log2_numvector_size  = 7;
1271             }
1272             break;
1273         case MC_COOK:
1274             av_log(avctx,AV_LOG_ERROR,"MC_COOK not supported!\n");
1275             return -1;
1276             break;
1277         default:
1278             av_log(avctx,AV_LOG_ERROR,"Unknown Cook version, report sample!\n");
1279             return -1;
1280             break;
1281     }
1282
1283     /* Initialize variable relations */
1284     q->mlt_size = q->samples_per_channel;
1285     q->numvector_size = (1 << q->log2_numvector_size);
1286
1287     /* Generate tables */
1288     init_rootpow2table(q);
1289     init_pow2table(q);
1290     init_gain_table(q);
1291
1292     if (init_cook_vlc_tables(q) != 0)
1293         return -1;
1294
1295
1296     if(avctx->block_align >= UINT_MAX/2)
1297         return -1;
1298
1299     /* Pad the databuffer with:
1300        DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(),
1301        FF_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */
1302     if (q->nb_channels==2 && q->joint_stereo==0) {
1303         q->decoded_bytes_buffer =
1304           av_mallocz(avctx->block_align/2
1305                      + DECODE_BYTES_PAD2(avctx->block_align/2)
1306                      + FF_INPUT_BUFFER_PADDING_SIZE);
1307     } else {
1308         q->decoded_bytes_buffer =
1309           av_mallocz(avctx->block_align
1310                      + DECODE_BYTES_PAD1(avctx->block_align)
1311                      + FF_INPUT_BUFFER_PADDING_SIZE);
1312     }
1313     if (q->decoded_bytes_buffer == NULL)
1314         return -1;
1315
1316     q->decode_buf_ptr[0] = q->decode_buffer_1;
1317     q->decode_buf_ptr[1] = q->decode_buffer_2;
1318     q->decode_buf_ptr[2] = q->decode_buffer_3;
1319     q->decode_buf_ptr[3] = q->decode_buffer_4;
1320
1321     q->decode_buf_ptr2[0] = q->decode_buffer_3;
1322     q->decode_buf_ptr2[1] = q->decode_buffer_4;
1323
1324     q->previous_buffer_ptr[0] = q->mono_previous_buffer1;
1325     q->previous_buffer_ptr[1] = q->mono_previous_buffer2;
1326
1327     /* Initialize transform. */
1328     if ( init_cook_mlt(q) == 0 )
1329         return -1;
1330
1331     /* Try to catch some obviously faulty streams, othervise it might be exploitable */
1332     if (q->total_subbands > 53) {
1333         av_log(avctx,AV_LOG_ERROR,"total_subbands > 53, report sample!\n");
1334         return -1;
1335     }
1336     if (q->subbands > 50) {
1337         av_log(avctx,AV_LOG_ERROR,"subbands > 50, report sample!\n");
1338         return -1;
1339     }
1340     if ((q->samples_per_channel == 256) || (q->samples_per_channel == 512) || (q->samples_per_channel == 1024)) {
1341     } else {
1342         av_log(avctx,AV_LOG_ERROR,"unknown amount of samples_per_channel = %d, report sample!\n",q->samples_per_channel);
1343         return -1;
1344     }
1345
1346 #ifdef COOKDEBUG
1347     dump_cook_context(q,e);
1348 #endif
1349     return 0;
1350 }
1351
1352
1353 AVCodec cook_decoder =
1354 {
1355     .name = "cook",
1356     .type = CODEC_TYPE_AUDIO,
1357     .id = CODEC_ID_COOK,
1358     .priv_data_size = sizeof(COOKContext),
1359     .init = cook_decode_init,
1360     .close = cook_decode_close,
1361     .decode = cook_decode_frame,
1362 };