cook.c 42.3 KB
Newer Older
1 2 3 4 5
/*
 * COOK compatible decoder
 * Copyright (c) 2003 Sascha Sommer
 * Copyright (c) 2005 Benjamin Larsson
 *
6
 * This file is part of Libav.
7
 *
8
 * Libav is free software; you can redistribute it and/or
9 10
 * modify it under the terms of the GNU Lesser General Public
 * 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
 * Libav is distributed in the hope that it will be useful,
14 15 16 17 18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with Libav; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 22 23
 */

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

#include <math.h>
#include <stddef.h>
#include <stdio.h>

49 50
#include "libavutil/lfg.h"
#include "libavutil/random_seed.h"
51
#include "avcodec.h"
52
#include "get_bits.h"
53
#include "dsputil.h"
54
#include "bytestream.h"
55
#include "fft.h"
56
#include "libavutil/audioconvert.h"
57
#include "sinewin.h"
58 59 60 61

#include "cookdata.h"

/* the different Cook versions */
62 63
#define MONO            0x1000001
#define STEREO          0x1000002
64 65 66 67
#define JOINT_STEREO    0x1000003
#define MC_COOK         0x2000000   //multichannel Cook, not supported

#define SUBBAND_SIZE    20
68
#define MAX_SUBPACKETS   5
69 70

typedef struct {
71 72 73
    int *now;
    int *previous;
} cook_gains;
74

75 76
typedef struct {
    int                 ch_idx;
77
    int                 size;
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
    int                 num_channels;
    int                 cookversion;
    int                 samples_per_frame;
    int                 subbands;
    int                 js_subband_start;
    int                 js_vlc_bits;
    int                 samples_per_channel;
    int                 log2_numvector_size;
    unsigned int        channel_mask;
    VLC                 ccpl;                 ///< channel coupling
    int                 joint_stereo;
    int                 bits_per_subpacket;
    int                 bits_per_subpdiv;
    int                 total_subbands;
    int                 numvector_size;       ///< 1 << log2_numvector_size;

    float               mono_previous_buffer1[1024];
    float               mono_previous_buffer2[1024];
    /** gain buffers */
    cook_gains          gains1;
    cook_gains          gains2;
    int                 gain_1[9];
    int                 gain_2[9];
    int                 gain_3[9];
    int                 gain_4[9];
} COOKSubpacket;

105 106 107 108 109 110 111 112 113 114
typedef struct cook {
    /*
     * The following 5 functions provide the lowlevel arithmetic on
     * the internal audio buffers.
     */
    void (* scalar_dequant)(struct cook *q, int index, int quant_index,
                            int* subband_coef_index, int* subband_coef_sign,
                            float* mlt_p);

    void (* decouple) (struct cook *q,
115
                       COOKSubpacket *p,
116 117 118 119 120 121 122 123 124 125 126 127 128
                       int subband,
                       float f1, float f2,
                       float *decode_buffer,
                       float *mlt_buffer1, float *mlt_buffer2);

    void (* imlt_window) (struct cook *q, float *buffer1,
                          cook_gains *gains_ptr, float *previous_buffer);

    void (* interpolate) (struct cook *q, float* buffer,
                          int gain_index, int gain_index_next);

    void (* saturate_output) (struct cook *q, int chan, int16_t *out);

129
    AVCodecContext*     avctx;
130 131 132 133 134 135
    GetBitContext       gb;
    /* stream data */
    int                 nb_channels;
    int                 bit_rate;
    int                 sample_rate;
    int                 num_vectors;
136
    int                 samples_per_channel;
137
    /* states */
138
    AVLFG               random_state;
139 140

    /* transform data */
141
    FFTContext          mdct_ctx;
142 143 144 145 146 147 148 149 150 151 152 153 154
    float*              mlt_window;

    /* VLC data */
    VLC                 envelope_quant_index[13];
    VLC                 sqvh[7];          //scalar quantization

    /* generatable tables and related variables */
    int                 gain_size_factor;
    float               gain_table[23];

    /* data buffers */

    uint8_t*            decoded_bytes_buffer;
Vitor Sessak's avatar
Vitor Sessak committed
155
    DECLARE_ALIGNED(32, float, mono_mdct_output)[2048];
156 157
    float               decode_buffer_1[1024];
    float               decode_buffer_2[1024];
158
    float               decode_buffer_0[1060]; /* static allocation for joint decode */
159

160
    const float         *cplscales[5];
161 162
    int                 num_subpackets;
    COOKSubpacket       subpacket[MAX_SUBPACKETS];
163 164
} COOKContext;

165 166 167
static float     pow2tab[127];
static float rootpow2tab[127];

168 169 170
/*************** init functions ***************/

/* table generator */
171
static av_cold void init_pow2table(void){
172
    int i;
Michael Niedermayer's avatar
Michael Niedermayer committed
173
    for (i=-63 ; i<64 ; i++){
174 175
            pow2tab[63+i]=     pow(2, i);
        rootpow2tab[63+i]=sqrt(pow(2, i));
176 177 178 179
    }
}

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


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

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

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

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

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

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

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

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

239
    return 0;
240 241
}

242
static const float *maybe_reformat_buffer32 (COOKContext *q, const float *ptr, int n)
243 244 245 246 247
{
    if (1)
        return ptr;
}

248
static av_cold void init_cplscales_table (COOKContext *q) {
249 250 251 252 253
    int i;
    for (i=0;i<5;i++)
        q->cplscales[i] = maybe_reformat_buffer32 (q, cplscales[i], (1<<(i+2))-1);
}

254 255
/*************** init functions end ***********/

256 257 258
#define DECODE_BYTES_PAD1(bytes) (3 - ((bytes)+3) % 4)
#define DECODE_BYTES_PAD2(bytes) ((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes)))

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

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

291
    off = (intptr_t)inbuffer & 3;
Michael Niedermayer's avatar
const  
Michael Niedermayer committed
292
    buf = (const uint32_t*) (inbuffer - off);
293
    c = av_be2ne32((0x37c511f2 >> (off*8)) | (0x37c511f2 << (32-(off*8))));
294 295 296
    bytes += 3 + off;
    for (i = 0; i < bytes/4; i++)
        obuf[i] = c ^ buf[i];
297

298
    return off;
299 300 301 302 303 304
}

/**
 * Cook uninit
 */

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

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

    /* Free the transform. */
316
    ff_mdct_end(&q->mdct_ctx);
317 318 319 320 321 322 323 324

    /* Free the VLC tables. */
    for (i=0 ; i<13 ; i++) {
        free_vlc(&q->envelope_quant_index[i]);
    }
    for (i=0 ; i<7 ; i++) {
        free_vlc(&q->sqvh[i]);
    }
325 326
    for (i=0 ; i<q->num_subpackets ; i++) {
        free_vlc(&q->subpacket[i].ccpl);
327 328
    }

329
    av_log(avctx,AV_LOG_DEBUG,"Memory deallocated.\n");
330 331 332 333 334

    return 0;
}

/**
335
 * Fill the gain array for the timedomain quantization.
336
 *
337 338
 * @param gb          pointer to the GetBitContext
 * @param gaininfo[9] array of gain indexes
339 340
 */

341 342 343
static void decode_gain_info(GetBitContext *gb, int *gaininfo)
{
    int i, n;
344 345

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

348 349 350 351
    i = 0;
    while (n--) {
        int index = get_bits(gb, 3);
        int gain = get_bits1(gb) ? get_bits(gb, 4) - 7 : -1;
352

353
        while (i <= index) gaininfo[i++] = gain;
354
    }
355
    while (i <= 8) gaininfo[i++] = 0;
356 357 358 359 360 361 362 363 364
}

/**
 * Create the quant index table needed for the envelope.
 *
 * @param q                 pointer to the COOKContext
 * @param quant_index_table pointer to the array
 */

365
static void decode_envelope(COOKContext *q, COOKSubpacket *p, int* quant_index_table) {
366 367 368 369
    int i,j, vlc_index;

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

370
    for (i=1 ; i < p->total_subbands ; i++){
371
        vlc_index=i;
372 373
        if (i >= p->js_subband_start * 2) {
            vlc_index-=p->js_subband_start;
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
        } else {
            vlc_index/=2;
            if(vlc_index < 1) vlc_index = 1;
        }
        if (vlc_index>13) vlc_index = 13;           //the VLC tables >13 are identical to No. 13

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

/**
 * Calculate the category and category_index vector.
 *
 * @param q                     pointer to the COOKContext
 * @param quant_index_table     pointer to the array
 * @param category              pointer to the category array
 * @param category_index        pointer to the category_index array
 */

395
static void categorize(COOKContext *q, COOKSubpacket *p, int* quant_index_table,
396
                       int* category, int* category_index){
397
    int exp_idx, bias, tmpbias1, tmpbias2, bits_left, num_bits, index, v, i, j;
398 399 400
    int exp_index2[102];
    int exp_index1[102];

401
    int tmp_categorize_array[128*2];
402 403
    int tmp_categorize_array1_idx=p->numvector_size;
    int tmp_categorize_array2_idx=p->numvector_size;
404

405
    bits_left =  p->bits_per_subpacket - get_bits_count(&q->gb);
406 407 408 409

    if(bits_left > q->samples_per_channel) {
        bits_left = q->samples_per_channel +
                    ((bits_left - q->samples_per_channel)*5)/8;
410
        //av_log(q->avctx, AV_LOG_ERROR, "bits_left = %d\n",bits_left);
411 412 413 414
    }

    memset(&exp_index1,0,102*sizeof(int));
    memset(&exp_index2,0,102*sizeof(int));
415
    memset(&tmp_categorize_array,0,128*2*sizeof(int));
416 417 418 419 420 421 422

    bias=-32;

    /* Estimate bias. */
    for (i=32 ; i>0 ; i=i/2){
        num_bits = 0;
        index = 0;
423
        for (j=p->total_subbands ; j>0 ; j--){
424
            exp_idx = av_clip((i - quant_index_table[index] + bias) / 2, 0, 7);
425 426 427 428 429 430 431 432 433 434
            index++;
            num_bits+=expbits_tab[exp_idx];
        }
        if(num_bits >= bits_left - 32){
            bias+=i;
        }
    }

    /* Calculate total number of bits. */
    num_bits=0;
435
    for (i=0 ; i<p->total_subbands ; i++) {
436
        exp_idx = av_clip((bias - quant_index_table[i]) / 2, 0, 7);
437 438 439 440
        num_bits += expbits_tab[exp_idx];
        exp_index1[i] = exp_idx;
        exp_index2[i] = exp_idx;
    }
441
    tmpbias1 = tmpbias2 = num_bits;
442

443
    for (j = 1 ; j < p->numvector_size ; j++) {
444
        if (tmpbias1 + tmpbias2 > 2*bits_left) {  /* ---> */
445 446
            int max = -999999;
            index=-1;
447
            for (i=0 ; i<p->total_subbands ; i++){
448
                if (exp_index1[i] < 7) {
449
                    v = (-2*exp_index1[i]) - quant_index_table[i] + bias;
450 451 452 453 454 455 456
                    if ( v >= max) {
                        max = v;
                        index = i;
                    }
                }
            }
            if(index==-1)break;
457
            tmp_categorize_array[tmp_categorize_array1_idx++] = index;
458
            tmpbias1 -= expbits_tab[exp_index1[index]] -
Ramiro Polla's avatar
Ramiro Polla committed
459
                        expbits_tab[exp_index1[index]+1];
460 461 462 463
            ++exp_index1[index];
        } else {  /* <--- */
            int min = 999999;
            index=-1;
464
            for (i=0 ; i<p->total_subbands ; i++){
465
                if(exp_index2[i] > 0){
466
                    v = (-2*exp_index2[i])-quant_index_table[i]+bias;
467 468 469 470 471 472 473
                    if ( v < min) {
                        min = v;
                        index = i;
                    }
                }
            }
            if(index == -1)break;
474
            tmp_categorize_array[--tmp_categorize_array2_idx] = index;
475
            tmpbias2 -= expbits_tab[exp_index2[index]] -
Ramiro Polla's avatar
Ramiro Polla committed
476
                        expbits_tab[exp_index2[index]-1];
477 478 479 480
            --exp_index2[index];
        }
    }

481
    for(i=0 ; i<p->total_subbands ; i++)
482 483
        category[i] = exp_index2[i];

484
    for(i=0 ; i<p->numvector_size-1 ; i++)
485
        category_index[i] = tmp_categorize_array[tmp_categorize_array2_idx++];
486 487 488 489 490 491 492 493 494 495 496 497

}


/**
 * Expand the category vector.
 *
 * @param q                     pointer to the COOKContext
 * @param category              pointer to the category array
 * @param category_index        pointer to the category_index array
 */

498
static inline void expand_category(COOKContext *q, int* category,
499 500 501 502 503 504 505 506 507 508 509 510
                                   int* category_index){
    int i;
    for(i=0 ; i<q->num_vectors ; i++){
        ++category[category_index[i]];
    }
}

/**
 * The real requantization of the mltcoefs
 *
 * @param q                     pointer to the COOKContext
 * @param index                 index
511
 * @param quant_index           quantisation index
512
 * @param subband_coef_index    array of indexes to quant_centroid_tab
513
 * @param subband_coef_sign     signs of coefficients
514
 * @param mlt_p                 pointer into the mlt buffer
515 516
 */

517
static void scalar_dequant_float(COOKContext *q, int index, int quant_index,
518 519
                           int* subband_coef_index, int* subband_coef_sign,
                           float* mlt_p){
520 521 522 523 524
    int i;
    float f1;

    for(i=0 ; i<SUBBAND_SIZE ; i++) {
        if (subband_coef_index[i]) {
525 526
            f1 = quant_centroid_tab[index][subband_coef_index[i]];
            if (subband_coef_sign[i]) f1 = -f1;
527
        } else {
528
            /* noise coding if subband_coef_index[i] == 0 */
529
            f1 = dither_tab[index];
530
            if (av_lfg_get(&q->random_state) < 0x80000000) f1 = -f1;
531
        }
532
        mlt_p[i] = f1 * rootpow2tab[quant_index+63];
533 534 535
    }
}
/**
536
 * Unpack the subband_coef_index and subband_coef_sign vectors.
537 538 539 540
 *
 * @param q                     pointer to the COOKContext
 * @param category              pointer to the category array
 * @param subband_coef_index    array of indexes to quant_centroid_tab
541
 * @param subband_coef_sign     signs of coefficients
542 543
 */

544
static int unpack_SQVH(COOKContext *q, COOKSubpacket *p, int category, int* subband_coef_index,
545
                       int* subband_coef_sign) {
546 547 548 549 550 551 552
    int i,j;
    int vlc, vd ,tmp, result;

    vd = vd_tab[category];
    result = 0;
    for(i=0 ; i<vpr_tab[category] ; i++){
        vlc = get_vlc2(&q->gb, q->sqvh[category].table, q->sqvh[category].bits, 3);
553
        if (p->bits_per_subpacket < get_bits_count(&q->gb)){
554 555 556 557 558 559 560 561 562 563
            vlc = 0;
            result = 1;
        }
        for(j=vd-1 ; j>=0 ; j--){
            tmp = (vlc * invradix_tab[category])/0x100000;
            subband_coef_index[vd*i+j] = vlc - tmp * (kmax_tab[category]+1);
            vlc = tmp;
        }
        for(j=0 ; j<vd ; j++){
            if (subband_coef_index[i*vd + j]) {
564
                if(get_bits_count(&q->gb) < p->bits_per_subpacket){
565
                    subband_coef_sign[i*vd+j] = get_bits1(&q->gb);
566 567
                } else {
                    result=1;
568
                    subband_coef_sign[i*vd+j]=0;
569 570
                }
            } else {
571
                subband_coef_sign[i*vd+j]=0;
572 573 574 575 576 577 578 579 580 581 582 583
            }
        }
    }
    return result;
}


/**
 * Fill the mlt_buffer with mlt coefficients.
 *
 * @param q                 pointer to the COOKContext
 * @param category          pointer to the category array
584
 * @param quant_index_table pointer to the array
585 586 587 588
 * @param mlt_buffer        pointer to mlt coefficients
 */


589
static void decode_vectors(COOKContext* q, COOKSubpacket* p, int* category,
590
                           int *quant_index_table, float* mlt_buffer){
591 592
    /* A zero in this table means that the subband coefficient is
       random noise coded. */
593
    int subband_coef_index[SUBBAND_SIZE];
594 595
    /* A zero in this table means that the subband coefficient is a
       positive multiplicator. */
596
    int subband_coef_sign[SUBBAND_SIZE];
597 598 599
    int band, j;
    int index=0;

600
    for(band=0 ; band<p->total_subbands ; band++){
601 602
        index = category[band];
        if(category[band] < 7){
603
            if(unpack_SQVH(q, p, category[band], subband_coef_index, subband_coef_sign)){
604
                index=7;
605
                for(j=0 ; j<p->total_subbands ; j++) category[band+j]=7;
606 607
            }
        }
608
        if(index>=7) {
609
            memset(subband_coef_index, 0, sizeof(subband_coef_index));
610
            memset(subband_coef_sign, 0, sizeof(subband_coef_sign));
611
        }
612
        q->scalar_dequant(q, index, quant_index_table[band],
613 614
                          subband_coef_index, subband_coef_sign,
                          &mlt_buffer[band * SUBBAND_SIZE]);
615 616
    }

617
    if(p->total_subbands*SUBBAND_SIZE >= q->samples_per_channel){
618
        return;
619
    } /* FIXME: should this be removed, or moved into loop above? */
620 621 622 623 624 625 626
}


/**
 * function for decoding mono data
 *
 * @param q                 pointer to the COOKContext
627
 * @param mlt_buffer        pointer to mlt coefficients
628 629
 */

630
static void mono_decode(COOKContext *q, COOKSubpacket *p, float* mlt_buffer) {
631 632 633 634 635 636 637 638

    int category_index[128];
    int quant_index_table[102];
    int category[128];

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

639 640 641
    decode_envelope(q, p, quant_index_table);
    q->num_vectors = get_bits(&q->gb,p->log2_numvector_size);
    categorize(q, p, quant_index_table, category, category_index);
642
    expand_category(q, category, category_index);
643
    decode_vectors(q, p, category, quant_index_table, mlt_buffer);
644 645 646 647 648 649 650 651 652 653 654 655
}


/**
 * the actual requantization of the timedomain samples
 *
 * @param q                 pointer to the COOKContext
 * @param buffer            pointer to the timedomain buffer
 * @param gain_index        index for the block multiplier
 * @param gain_index_next   index for the next block multiplier
 */

656
static void interpolate_float(COOKContext *q, float* buffer,
657 658 659
                        int gain_index, int gain_index_next){
    int i;
    float fc1, fc2;
660
    fc1 = pow2tab[gain_index+63];
661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676

    if(gain_index == gain_index_next){              //static gain
        for(i=0 ; i<q->gain_size_factor ; i++){
            buffer[i]*=fc1;
        }
        return;
    } else {                                        //smooth gain
        fc2 = q->gain_table[11 + (gain_index_next-gain_index)];
        for(i=0 ; i<q->gain_size_factor ; i++){
            buffer[i]*=fc1;
            fc1*=fc2;
        }
        return;
    }
}

677 678 679 680
/**
 * Apply transform window, overlap buffers.
 *
 * @param q                 pointer to the COOKContext
681
 * @param inbuffer          pointer to the mltcoefficients
682 683 684 685
 * @param gains_ptr         current and previous gains
 * @param previous_buffer   pointer to the previous buffer to be used for overlapping
 */

686
static void imlt_window_float (COOKContext *q, float *inbuffer,
687 688
                               cook_gains *gains_ptr, float *previous_buffer)
{
689
    const float fc = pow2tab[gains_ptr->previous[0] + 63];
690 691 692 693 694 695 696 697 698
    int i;
    /* The weird thing here, is that the two halves of the time domain
     * buffer are swapped. Also, the newest data, that we save away for
     * next frame, has the wrong sign. Hence the subtraction below.
     * Almost sounds like a complex conjugate/reverse data/FFT effect.
     */

    /* Apply window and overlap */
    for(i = 0; i < q->samples_per_channel; i++){
699
        inbuffer[i] = inbuffer[i] * fc * q->mlt_window[i] -
700 701 702
          previous_buffer[i] * q->mlt_window[q->samples_per_channel - 1 - i];
    }
}
703 704

/**
705 706 707 708
 * The modulated lapped transform, this takes transform coefficients
 * and transforms them into timedomain samples.
 * Apply transform window, overlap buffers, apply gain profile
 * and buffer management.
709 710
 *
 * @param q                 pointer to the COOKContext
711
 * @param inbuffer          pointer to the mltcoefficients
712
 * @param gains_ptr         current and previous gains
713 714 715
 * @param previous_buffer   pointer to the previous buffer to be used for overlapping
 */

716 717
static void imlt_gain(COOKContext *q, float *inbuffer,
                      cook_gains *gains_ptr, float* previous_buffer)
718
{
719 720
    float *buffer0 = q->mono_mdct_output;
    float *buffer1 = q->mono_mdct_output + q->samples_per_channel;
721 722
    int i;

723
    /* Inverse modified discrete cosine transform */
724
    q->mdct_ctx.imdct_calc(&q->mdct_ctx, q->mono_mdct_output, inbuffer);
725

726
    q->imlt_window (q, buffer1, gains_ptr, previous_buffer);
727 728 729 730

    /* Apply gain profile */
    for (i = 0; i < 8; i++) {
        if (gains_ptr->now[i] || gains_ptr->now[i + 1])
731
            q->interpolate(q, &buffer1[q->gain_size_factor * i],
732
                           gains_ptr->now[i], gains_ptr->now[i + 1]);
733
    }
734 735

    /* Save away the current to be previous block. */
736
    memcpy(previous_buffer, buffer0, sizeof(float)*q->samples_per_channel);
737 738 739 740 741 742 743 744 745 746 747
}


/**
 * function for getting the jointstereo coupling information
 *
 * @param q                 pointer to the COOKContext
 * @param decouple_tab      decoupling array
 *
 */

748
static void decouple_info(COOKContext *q, COOKSubpacket *p, int* decouple_tab){
749 750 751
    int length, i;

    if(get_bits1(&q->gb)) {
752
        if(cplband[p->js_subband_start] > cplband[p->subbands-1]) return;
753

754
        length = cplband[p->subbands-1] - cplband[p->js_subband_start] + 1;
755
        for (i=0 ; i<length ; i++) {
756
            decouple_tab[cplband[p->js_subband_start] + i] = get_vlc2(&q->gb, p->ccpl.table, p->ccpl.bits, 2);
757 758 759 760
        }
        return;
    }

761
    if(cplband[p->js_subband_start] > cplband[p->subbands-1]) return;
762

763
    length = cplband[p->subbands-1] - cplband[p->js_subband_start] + 1;
764
    for (i=0 ; i<length ; i++) {
765
       decouple_tab[cplband[p->js_subband_start] + i] = get_bits(&q->gb, p->js_vlc_bits);
766 767 768 769
    }
    return;
}

770 771 772 773 774 775 776 777 778 779 780 781
/*
 * function decouples a pair of signals from a single signal via multiplication.
 *
 * @param q                 pointer to the COOKContext
 * @param subband           index of the current subband
 * @param f1                multiplier for channel 1 extraction
 * @param f2                multiplier for channel 2 extraction
 * @param decode_buffer     input buffer
 * @param mlt_buffer1       pointer to left channel mlt coefficients
 * @param mlt_buffer2       pointer to right channel mlt coefficients
 */
static void decouple_float (COOKContext *q,
782
                            COOKSubpacket *p,
783 784 785 786 787 788 789
                            int subband,
                            float f1, float f2,
                            float *decode_buffer,
                            float *mlt_buffer1, float *mlt_buffer2)
{
    int j, tmp_idx;
    for (j=0 ; j<SUBBAND_SIZE ; j++) {
790
        tmp_idx = ((p->js_subband_start + subband)*SUBBAND_SIZE)+j;
791 792 793 794
        mlt_buffer1[SUBBAND_SIZE*subband + j] = f1 * decode_buffer[tmp_idx];
        mlt_buffer2[SUBBAND_SIZE*subband + j] = f2 * decode_buffer[tmp_idx];
    }
}
795 796 797 798 799 800 801 802 803

/**
 * function for decoding joint stereo data
 *
 * @param q                 pointer to the COOKContext
 * @param mlt_buffer1       pointer to left channel mlt coefficients
 * @param mlt_buffer2       pointer to right channel mlt coefficients
 */

804
static void joint_decode(COOKContext *q, COOKSubpacket *p, float* mlt_buffer1,
805 806 807
                         float* mlt_buffer2) {
    int i,j;
    int decouple_tab[SUBBAND_SIZE];
808
    float *decode_buffer = q->decode_buffer_0;
Diego Biurrun's avatar
Diego Biurrun committed
809
    int idx, cpl_tmp;
810
    float f1,f2;
811
    const float* cplscale;
812 813 814 815 816 817 818

    memset(decouple_tab, 0, sizeof(decouple_tab));
    memset(decode_buffer, 0, sizeof(decode_buffer));

    /* Make sure the buffers are zeroed out. */
    memset(mlt_buffer1,0, 1024*sizeof(float));
    memset(mlt_buffer2,0, 1024*sizeof(float));
819 820
    decouple_info(q, p, decouple_tab);
    mono_decode(q, p, decode_buffer);
821 822

    /* The two channels are stored interleaved in decode_buffer. */
823
    for (i=0 ; i<p->js_subband_start ; i++) {
824 825 826 827 828 829 830 831
        for (j=0 ; j<SUBBAND_SIZE ; j++) {
            mlt_buffer1[i*20+j] = decode_buffer[i*40+j];
            mlt_buffer2[i*20+j] = decode_buffer[i*40+20+j];
        }
    }

    /* When we reach js_subband_start (the higher frequencies)
       the coefficients are stored in a coupling scheme. */
832 833
    idx = (1 << p->js_vlc_bits) - 1;
    for (i=p->js_subband_start ; i<p->subbands ; i++) {
834 835
        cpl_tmp = cplband[i];
        idx -=decouple_tab[cpl_tmp];
836
        cplscale = q->cplscales[p->js_vlc_bits-2];  //choose decoupler table
837 838
        f1 = cplscale[decouple_tab[cpl_tmp]];
        f2 = cplscale[idx-1];
839 840
        q->decouple (q, p, i, f1, f2, decode_buffer, mlt_buffer1, mlt_buffer2);
        idx = (1 << p->js_vlc_bits) - 1;
841 842 843
    }
}

844 845 846 847 848 849
/**
 * First part of subpacket decoding:
 *  decode raw stream bytes and read gain info.
 *
 * @param q                 pointer to the COOKContext
 * @param inbuffer          pointer to raw stream data
850
 * @param gains_ptr         array of current/prev gain pointers
851 852 853
 */

static inline void
854
decode_bytes_and_gain(COOKContext *q, COOKSubpacket *p, const uint8_t *inbuffer,
855
                      cook_gains *gains_ptr)
856 857 858 859
{
    int offset;

    offset = decode_bytes(inbuffer, q->decoded_bytes_buffer,
860
                          p->bits_per_subpacket/8);
861
    init_get_bits(&q->gb, q->decoded_bytes_buffer + offset,
862
                  p->bits_per_subpacket);
863
    decode_gain_info(&q->gb, gains_ptr->now);
864 865

    /* Swap current and previous gains */
866
    FFSWAP(int *, gains_ptr->now, gains_ptr->previous);
867 868
}

869 870 871 872 873 874 875 876 877 878 879
 /**
 * Saturate the output signal to signed 16bit integers.
 *
 * @param q                 pointer to the COOKContext
 * @param chan              channel to saturate
 * @param out               pointer to the output vector
 */
static void
saturate_output_float (COOKContext *q, int chan, int16_t *out)
{
    int j;
880
    float *output = q->mono_mdct_output + q->samples_per_channel;
881 882 883 884
    /* Clip and convert floats to 16 bits.
     */
    for (j = 0; j < q->samples_per_channel; j++) {
        out[chan + q->nb_channels * j] =
885
          av_clip_int16(lrintf(output[j]));
886 887 888
    }
}

889 890 891 892 893 894 895
/**
 * Final part of subpacket decoding:
 *  Apply modulated lapped transform, gain compensation,
 *  clip and convert to integer.
 *
 * @param q                 pointer to the COOKContext
 * @param decode_buffer     pointer to the mlt coefficients
896
 * @param gains_ptr         array of current/prev gain pointers
897 898 899 900 901 902 903
 * @param previous_buffer   pointer to the previous buffer to be used for overlapping
 * @param out               pointer to the output buffer
 * @param chan              0: left or single channel, 1: right channel
 */

static inline void
mlt_compensate_output(COOKContext *q, float *decode_buffer,
904
                      cook_gains *gains_ptr, float *previous_buffer,
905 906
                      int16_t *out, int chan)
{
907
    imlt_gain(q, decode_buffer, gains_ptr, previous_buffer);
908
    q->saturate_output (q, chan, out);
909 910 911
}