cook.c 43.9 KB
Newer Older
1 2 3 4 5
/*
 * COOK compatible decoder
 * Copyright (c) 2003 Sascha Sommer
 * Copyright (c) 2005 Benjamin Larsson
 *
6 7 8
 * This file is part of FFmpeg.
 *
 * FFmpeg 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
 * FFmpeg 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 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
 * @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
 * 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.
 */

45
#include "libavutil/lfg.h"
46
#include "avcodec.h"
47
#include "get_bits.h"
48
#include "dsputil.h"
49
#include "bytestream.h"
50
#include "fft.h"
51
#include "libavutil/audioconvert.h"
52
#include "sinewin.h"
53 54 55 56

#include "cookdata.h"

/* the different Cook versions */
57 58
#define MONO            0x1000001
#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 MAX_SUBPACKETS   5
64 65

typedef struct {
66 67 68
    int *now;
    int *previous;
} cook_gains;
69

70 71
typedef struct {
    int                 ch_idx;
72
    int                 size;
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
    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;

100 101 102 103 104
typedef struct cook {
    /*
     * The following 5 functions provide the lowlevel arithmetic on
     * the internal audio buffers.
     */
105 106 107
    void (*scalar_dequant)(struct cook *q, int index, int quant_index,
                           int *subband_coef_index, int *subband_coef_sign,
                           float *mlt_p);
108

109 110 111 112 113 114
    void (*decouple)(struct cook *q,
                     COOKSubpacket *p,
                     int subband,
                     float f1, float f2,
                     float *decode_buffer,
                     float *mlt_buffer1, float *mlt_buffer2);
115

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

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

122
    void (*saturate_output)(struct cook *q, int chan, float *out);
123

124
    AVCodecContext*     avctx;
125
    AVFrame             frame;
126 127 128 129 130 131
    GetBitContext       gb;
    /* stream data */
    int                 nb_channels;
    int                 bit_rate;
    int                 sample_rate;
    int                 num_vectors;
132
    int                 samples_per_channel;
133
    /* states */
134
    AVLFG               random_state;
135
    int                 discarded_packets;
136 137

    /* transform data */
138
    FFTContext          mdct_ctx;
139 140 141 142
    float*              mlt_window;

    /* VLC data */
    VLC                 envelope_quant_index[13];
143
    VLC                 sqvh[7];          // scalar quantization
144 145 146 147 148 149 150 151

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

    /* data buffers */

    uint8_t*            decoded_bytes_buffer;
152
    DECLARE_ALIGNED(32, float, mono_mdct_output)[2048];
153 154
    float               decode_buffer_1[1024];
    float               decode_buffer_2[1024];
155
    float               decode_buffer_0[1060]; /* static allocation for joint decode */
156

157
    const float         *cplscales[5];
158 159
    int                 num_subpackets;
    COOKSubpacket       subpacket[MAX_SUBPACKETS];
160 161
} COOKContext;

162 163 164
static float     pow2tab[127];
static float rootpow2tab[127];

165 166 167
/*************** init functions ***************/

/* table generator */
168 169
static av_cold void init_pow2table(void)
{
170
    int i;
171 172 173
    for (i = -63; i < 64; i++) {
        pow2tab[63 + i] = pow(2, i);
        rootpow2tab[63 + i] = sqrt(pow(2, i));
174 175 176 177
    }
}

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


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

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

205 206 207 208 209 210
    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);
211
        }
212 213
    }

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

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

223
    if ((q->mlt_window = av_malloc(mlt_size * sizeof(*q->mlt_window))) == 0)
224
        return AVERROR(ENOMEM);
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 ((ret = ff_mdct_init(&q->mdct_ctx, av_log2(mlt_size) + 1, 1, 1.0 / 32768.0))) {
233 234
        av_free(q->mlt_window);
        return ret;
235
    }
236 237
    av_log(q->avctx, AV_LOG_DEBUG, "MDCT initialized, order = %d.\n",
           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 249
static av_cold void init_cplscales_table(COOKContext *q)
{
250
    int i;
251 252
    for (i = 0; i < 5; i++)
        q->cplscales[i] = maybe_reformat_buffer32(q, cplscales[i], (1 << (i + 2)) - 1);
253 254
}

255 256
/*************** init functions end ***********/

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

260 261 262
/**
 * Cook indata decoding, every 32 bits are XORed with 0x37c511f2.
 * Why? No idea, some checksum/error detection method maybe.
263 264
 *
 * Out buffer size: extra bytes are needed to cope with
265
 * padding/misalignment.
266 267 268 269 270 271 272 273
 * 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
 *
274 275
 * Nice way to waste CPU cycles.
 *
276 277 278
 * @param inbuffer  pointer to byte array of indata
 * @param out       pointer to byte array of outdata
 * @param bytes     number of bytes
279
 */
280 281
static inline int decode_bytes(const uint8_t *inbuffer, uint8_t *out, int bytes)
{
282 283 284 285
    static const uint32_t tab[4] = {
        AV_BE2NE32C(0x37c511f2), AV_BE2NE32C(0xf237c511),
        AV_BE2NE32C(0x11f237c5), AV_BE2NE32C(0xc511f237),
    };
286 287
    int i, off;
    uint32_t c;
288 289
    const uint32_t *buf;
    uint32_t *obuf = (uint32_t *) out;
290 291
    /* FIXME: 64 bit platforms would be able to do 64 bits at a time.
     * I'm too lazy though, should be something like
292 293
     * for (i = 0; i < bitamount / 64; i++)
     *     (int64_t) out[i] = 0x37c511f237c511f2 ^ av_be2ne64(int64_t) in[i]);
294 295
     * Buffer alignment needs to be checked. */

296 297
    off = (intptr_t) inbuffer & 3;
    buf = (const uint32_t *) (inbuffer - off);
298
    c = tab[off];
299
    bytes += 3 + off;
300
    for (i = 0; i < bytes / 4; i++)
301
        obuf[i] = c ^ buf[i];
302

303
    return off;
304 305 306 307 308
}

/**
 * Cook uninit
 */
309
static av_cold int cook_decode_close(AVCodecContext *avctx)
310 311 312
{
    int i;
    COOKContext *q = avctx->priv_data;
313
    av_log(avctx, AV_LOG_DEBUG, "Deallocating memory.\n");
314 315 316 317 318 319

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

    /* Free the transform. */
320
    ff_mdct_end(&q->mdct_ctx);
321 322

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

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

    return 0;
}

/**
336
 * Fill the gain array for the timedomain quantization.
337
 *
338
 * @param gb          pointer to the GetBitContext
339
 * @param gaininfo    array[9] of gain indexes
340
 */
341 342 343
static void decode_gain_info(GetBitContext *gb, int *gaininfo)
{
    int i, n;
344

345 346 347 348 349
    while (get_bits1(gb)) {
        /* NOTHING */
    }

    n = get_bits_count(gb) - 1;     // amount of elements*2 to update
350

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

356 357
        while (i <= index)
            gaininfo[i++] = gain;
358
    }
359 360
    while (i <= 8)
        gaininfo[i++] = 0;
361 362 363 364 365 366 367 368
}

/**
 * Create the quant index table needed for the envelope.
 *
 * @param q                 pointer to the COOKContext
 * @param quant_index_table pointer to the array
 */
369 370 371 372
static void decode_envelope(COOKContext *q, COOKSubpacket *p,
                            int *quant_index_table)
{
    int i, j, vlc_index;
373

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

376 377
    for (i = 1; i < p->total_subbands; i++) {
        vlc_index = i;
378
        if (i >= p->js_subband_start * 2) {
379
            vlc_index -= p->js_subband_start;
380
        } else {
381 382 383
            vlc_index /= 2;
            if (vlc_index < 1)
                vlc_index = 1;
384
        }
385 386
        if (vlc_index > 13)
            vlc_index = 13; // the VLC tables >13 are identical to No. 13
387

388 389 390
        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
391 392 393 394 395 396 397 398 399 400 401
    }
}

/**
 * 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
 */
402 403 404
static void categorize(COOKContext *q, COOKSubpacket *p, int *quant_index_table,
                       int *category, int *category_index)
{
405
    int exp_idx, bias, tmpbias1, tmpbias2, bits_left, num_bits, index, v, i, j;
406 407 408
    int exp_index2[102];
    int exp_index1[102];

409 410 411
    int tmp_categorize_array[128 * 2];
    int tmp_categorize_array1_idx = p->numvector_size;
    int tmp_categorize_array2_idx = p->numvector_size;
412

413
    bits_left = p->bits_per_subpacket - get_bits_count(&q->gb);
414

415
    if (bits_left > q->samples_per_channel) {
416
        bits_left = q->samples_per_channel +
417
                    ((bits_left - q->samples_per_channel) * 5) / 8;
418
        //av_log(q->avctx, AV_LOG_ERROR, "bits_left = %d\n",bits_left);
419 420
    }

421 422 423
    memset(&exp_index1,           0, sizeof(exp_index1));
    memset(&exp_index2,           0, sizeof(exp_index2));
    memset(&tmp_categorize_array, 0, sizeof(tmp_categorize_array));
424

425
    bias = -32;
426 427

    /* Estimate bias. */
428
    for (i = 32; i > 0; i = i / 2) {
429
        num_bits = 0;
430 431
        index    = 0;
        for (j = p->total_subbands; j > 0; j--) {
432
            exp_idx = av_clip((i - quant_index_table[index] + bias) / 2, 0, 7);
433
            index++;
434
            num_bits += expbits_tab[exp_idx];
435
        }
436 437
        if (num_bits >= bits_left - 32)
            bias += i;
438 439 440
    }

    /* Calculate total number of bits. */
441 442
    num_bits = 0;
    for (i = 0; i < p->total_subbands; i++) {
443
        exp_idx = av_clip((bias - quant_index_table[i]) / 2, 0, 7);
444 445 446 447
        num_bits += expbits_tab[exp_idx];
        exp_index1[i] = exp_idx;
        exp_index2[i] = exp_idx;
    }
448
    tmpbias1 = tmpbias2 = num_bits;
449

450 451
    for (j = 1; j < p->numvector_size; j++) {
        if (tmpbias1 + tmpbias2 > 2 * bits_left) {  /* ---> */
452
            int max = -999999;
453 454
            index = -1;
            for (i = 0; i < p->total_subbands; i++) {
455
                if (exp_index1[i] < 7) {
456 457 458
                    v = (-2 * exp_index1[i]) - quant_index_table[i] + bias;
                    if (v >= max) {
                        max   = v;
459 460 461 462
                        index = i;
                    }
                }
            }
463 464
            if (index == -1)
                break;
465
            tmp_categorize_array[tmp_categorize_array1_idx++] = index;
466
            tmpbias1 -= expbits_tab[exp_index1[index]] -
467
                        expbits_tab[exp_index1[index] + 1];
468 469 470
            ++exp_index1[index];
        } else {  /* <--- */
            int min = 999999;
471 472 473 474 475 476
            index = -1;
            for (i = 0; i < p->total_subbands; i++) {
                if (exp_index2[i] > 0) {
                    v = (-2 * exp_index2[i]) - quant_index_table[i] + bias;
                    if (v < min) {
                        min   = v;
477 478 479 480
                        index = i;
                    }
                }
            }
481 482
            if (index == -1)
                break;
483
            tmp_categorize_array[--tmp_categorize_array2_idx] = index;
484
            tmpbias2 -= expbits_tab[exp_index2[index]] -
485
                        expbits_tab[exp_index2[index] - 1];
486 487 488 489
            --exp_index2[index];
        }
    }

490
    for (i = 0; i < p->total_subbands; i++)
491 492
        category[i] = exp_index2[i];

493
    for (i = 0; i < p->numvector_size - 1; i++)
494
        category_index[i] = tmp_categorize_array[tmp_categorize_array2_idx++];
495 496 497 498 499 500 501 502 503 504
}


/**
 * 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
 */
505 506 507
static inline void expand_category(COOKContext *q, int *category,
                                   int *category_index)
{
508
    int i;
509
    for (i = 0; i < q->num_vectors; i++)
510 511 512 513 514 515 516 517
        ++category[category_index[i]];
}

/**
 * The real requantization of the mltcoefs
 *
 * @param q                     pointer to the COOKContext
 * @param index                 index
518
 * @param quant_index           quantisation index
519
 * @param subband_coef_index    array of indexes to quant_centroid_tab
520
 * @param subband_coef_sign     signs of coefficients
521
 * @param mlt_p                 pointer into the mlt buffer
522
 */
523
static void scalar_dequant_float(COOKContext *q, int index, int quant_index,
524 525 526
                                 int *subband_coef_index, int *subband_coef_sign,
                                 float *mlt_p)
{
527 528 529
    int i;
    float f1;

530
    for (i = 0; i < SUBBAND_SIZE; i++) {
531
        if (subband_coef_index[i]) {
532
            f1 = quant_centroid_tab[index][subband_coef_index[i]];
533 534
            if (subband_coef_sign[i])
                f1 = -f1;
535
        } else {
536
            /* noise coding if subband_coef_index[i] == 0 */
537
            f1 = dither_tab[index];
538 539
            if (av_lfg_get(&q->random_state) < 0x80000000)
                f1 = -f1;
540
        }
541
        mlt_p[i] = f1 * rootpow2tab[quant_index + 63];
542 543 544
    }
}
/**
545
 * Unpack the subband_coef_index and subband_coef_sign vectors.
546 547 548 549
 *
 * @param q                     pointer to the COOKContext
 * @param category              pointer to the category array
 * @param subband_coef_index    array of indexes to quant_centroid_tab
550
 * @param subband_coef_sign     signs of coefficients
551
 */
552 553 554 555 556
static int unpack_SQVH(COOKContext *q, COOKSubpacket *p, int category,
                       int *subband_coef_index, int *subband_coef_sign)
{
    int i, j;
    int vlc, vd, tmp, result;
557 558 559

    vd = vd_tab[category];
    result = 0;
560
    for (i = 0; i < vpr_tab[category]; i++) {
561
        vlc = get_vlc2(&q->gb, q->sqvh[category].table, q->sqvh[category].bits, 3);
562
        if (p->bits_per_subpacket < get_bits_count(&q->gb)) {
563 564 565
            vlc = 0;
            result = 1;
        }
566 567 568
        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);
569 570
            vlc = tmp;
        }
571 572 573 574
        for (j = 0; j < vd; j++) {
            if (subband_coef_index[i * vd + j]) {
                if (get_bits_count(&q->gb) < p->bits_per_subpacket) {
                    subband_coef_sign[i * vd + j] = get_bits1(&q->gb);
575
                } else {
576 577
                    result = 1;
                    subband_coef_sign[i * vd + j] = 0;
578 579
                }
            } else {
580
                subband_coef_sign[i * vd + j] = 0;
581 582 583 584 585 586 587 588 589 590 591 592
            }
        }
    }
    return result;
}


/**
 * Fill the mlt_buffer with mlt coefficients.
 *
 * @param q                 pointer to the COOKContext
 * @param category          pointer to the category array
593
 * @param quant_index_table pointer to the array
594 595
 * @param mlt_buffer        pointer to mlt coefficients
 */
596 597 598
static void decode_vectors(COOKContext *q, COOKSubpacket *p, int *category,
                           int *quant_index_table, float *mlt_buffer)
{
599 600
    /* A zero in this table means that the subband coefficient is
       random noise coded. */
601
    int subband_coef_index[SUBBAND_SIZE];
602 603
    /* A zero in this table means that the subband coefficient is a
       positive multiplicator. */
604
    int subband_coef_sign[SUBBAND_SIZE];
605
    int band, j;
606
    int index = 0;
607

608
    for (band = 0; band < p->total_subbands; band++) {
609
        index = category[band];
610 611 612 613 614
        if (category[band] < 7) {
            if (unpack_SQVH(q, p, category[band], subband_coef_index, subband_coef_sign)) {
                index = 7;
                for (j = 0; j < p->total_subbands; j++)
                    category[band + j] = 7;
615 616
            }
        }
617
        if (index >= 7) {
618
            memset(subband_coef_index, 0, sizeof(subband_coef_index));
619
            memset(subband_coef_sign,  0, sizeof(subband_coef_sign));
620
        }
621
        q->scalar_dequant(q, index, quant_index_table[band],
622 623
                          subband_coef_index, subband_coef_sign,
                          &mlt_buffer[band * SUBBAND_SIZE]);
624 625
    }

626 627
    /* FIXME: should this be removed, or moved into loop above? */
    if (p->total_subbands * SUBBAND_SIZE >= q->samples_per_channel)
628 629 630 631 632 633 634 635
        return;
}


/**
 * function for decoding mono data
 *
 * @param q                 pointer to the COOKContext
636
 * @param mlt_buffer        pointer to mlt coefficients
637
 */
638 639
static void mono_decode(COOKContext *q, COOKSubpacket *p, float *mlt_buffer)
{
640 641 642 643
    int category_index[128];
    int quant_index_table[102];
    int category[128];

644 645
    memset(&category,       0, sizeof(category));
    memset(&category_index, 0, sizeof(category_index));
646

647
    decode_envelope(q, p, quant_index_table);
648
    q->num_vectors = get_bits(&q->gb, p->log2_numvector_size);
649
    categorize(q, p, quant_index_table, category, category_index);
650
    expand_category(q, category, category_index);
651
    decode_vectors(q, p, category, quant_index_table, mlt_buffer);
652 653 654 655 656 657 658 659 660 661 662
}


/**
 * 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
 */
663 664 665
static void interpolate_float(COOKContext *q, float *buffer,
                              int gain_index, int gain_index_next)
{
666 667
    int i;
    float fc1, fc2;
668 669 670 671 672 673 674 675 676 677
    fc1 = pow2tab[gain_index + 63];

    if (gain_index == gain_index_next) {             // static gain
        for (i = 0; i < q->gain_size_factor; i++)
            buffer[i] *= fc1;
    } 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;
678 679 680 681
        }
    }
}

682 683 684 685
/**
 * Apply transform window, overlap buffers.
 *
 * @param q                 pointer to the COOKContext
686
 * @param inbuffer          pointer to the mltcoefficients
687 688 689
 * @param gains_ptr         current and previous gains
 * @param previous_buffer   pointer to the previous buffer to be used for overlapping
 */
690 691
static void imlt_window_float(COOKContext *q, float *inbuffer,
                              cook_gains *gains_ptr, float *previous_buffer)
692
{
693
    const float fc = pow2tab[gains_ptr->previous[0] + 63];
694 695 696 697 698 699 700 701
    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 */
702
    for (i = 0; i < q->samples_per_channel; i++)
703
        inbuffer[i] = inbuffer[i] * fc * q->mlt_window[i] -
704
                      previous_buffer[i] * q->mlt_window[q->samples_per_channel - 1 - i];
705
}
706 707

/**
708 709 710 711
 * 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.
712 713
 *
 * @param q                 pointer to the COOKContext
714
 * @param inbuffer          pointer to the mltcoefficients
715
 * @param gains_ptr         current and previous gains
716 717
 * @param previous_buffer   pointer to the previous buffer to be used for overlapping
 */
718
static void imlt_gain(COOKContext *q, float *inbuffer,
719
                      cook_gains *gains_ptr, float *previous_buffer)
720
{
721 722
    float *buffer0 = q->mono_mdct_output;
    float *buffer1 = q->mono_mdct_output + q->samples_per_channel;
723 724
    int i;

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

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

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

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


/**
 * function for getting the jointstereo coupling information
 *
 * @param q                 pointer to the COOKContext
 * @param decouple_tab      decoupling array
 *
 */
749 750 751 752 753
static void decouple_info(COOKContext *q, COOKSubpacket *p, int *decouple_tab)
{
    int i;
    int vlc    = get_bits1(&q->gb);
    int start  = cplband[p->js_subband_start];
754
    int end    = cplband[p->subbands - 1];
755
    int length = end - start + 1;
756

757
    if (start > end)
758 759
        return;

760
    if (vlc)
761 762
        for (i = 0; i < length; i++)
            decouple_tab[start + i] = get_vlc2(&q->gb, p->ccpl.table, p->ccpl.bits, 2);
763
    else
764 765
        for (i = 0; i < length; i++)
            decouple_tab[start + i] = get_bits(&q->gb, p->js_vlc_bits);
766 767
}

768 769 770 771 772 773 774 775 776 777 778
/*
 * 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
 */
779 780 781 782 783 784
static void decouple_float(COOKContext *q,
                           COOKSubpacket *p,
                           int subband,
                           float f1, float f2,
                           float *decode_buffer,
                           float *mlt_buffer1, float *mlt_buffer2)
785 786
{
    int j, tmp_idx;
787 788 789 790
    for (j = 0; j < SUBBAND_SIZE; j++) {
        tmp_idx = ((p->js_subband_start + subband) * SUBBAND_SIZE) + j;
        mlt_buffer1[SUBBAND_SIZE * subband + j] = f1 * decode_buffer[tmp_idx];
        mlt_buffer2[SUBBAND_SIZE * subband + j] = f2 * decode_buffer[tmp_idx];
791 792
    }
}
793 794 795 796 797 798 799 800

/**
 * 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
 */
801 802 803 804
static void joint_decode(COOKContext *q, COOKSubpacket *p, float *mlt_buffer1,
                         float *mlt_buffer2)
{
    int i, j;
805
    int decouple_tab[SUBBAND_SIZE];
806
    float *decode_buffer = q->decode_buffer_0;
Diego Biurrun's avatar
Diego Biurrun committed
807
    int idx, cpl_tmp;
808 809
    float f1, f2;
    const float *cplscale;
810 811

    memset(decouple_tab, 0, sizeof(decouple_tab));
812
    memset(decode_buffer, 0, sizeof(q->decode_buffer_0));
813 814

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

    /* The two channels are stored interleaved in decode_buffer. */
821 822 823 824
    for (i = 0; i < p->js_subband_start; i++) {
        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];
825 826 827 828 829
        }
    }

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

842 843 844 845 846 847
/**
 * 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
848
 * @param gains_ptr         array of current/prev gain pointers
849
 */
850 851 852
static inline void decode_bytes_and_gain(COOKContext *q, COOKSubpacket *p,
                                         const uint8_t *inbuffer,
                                         cook_gains *gains_ptr)
853 854 855 856
{
    int offset;

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

    /* Swap current and previous gains */
863
    FFSWAP(int *, gains_ptr->now, gains_ptr->previous);
864 865
}

866
/**
867
 * Saturate the output signal and interleave.
868 869 870 871 872
 *
 * @param q                 pointer to the COOKContext
 * @param chan              channel to saturate
 * @param out               pointer to the output vector
 */
873
static void saturate_output_float(COOKContext *q, int chan, float *out)
874 875
{
    int j;
876
    float *output = q->mono_mdct_output + q->samples_per_channel;
877
    for (j = 0; j < q->samples_per_channel; j++) {
878
        out[chan + q->nb_channels * j] = av_clipf(output[j], -1.0, 1.0);
879 880 881
    }
}

882 883 884 885 886 887 888
/**
 * 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
889
 * @param gains_ptr         array of current/prev gain pointers
890 891 892 893
 * @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
 */
894 895 896
static inline void mlt_compensate_output(COOKContext *q, float *decode_buffer,
                                         cook_gains *gains_ptr, float *previous_buffer,
                                         float *out, int chan)
897
{
898
    imlt_gain(q, decode_buffer, gains_ptr, previous_buffer);
899 900
    if (out)
        q->saturate_output(q, chan, out);
901 902 903
}


904 905 906 907 908 909 910 911
/**
 * Cook subpacket decoding. This function returns one decoded subpacket,
 * usually 1024 samples per channel.
 *
 * @param q                 pointer to the COOKContext
 * @param inbuffer          pointer to the inbuffer
 * @param outbuffer         pointer to the outbuffer
 */
912 913 914
static void decode_subpacket(COOKContext *q, COOKSubpacket *p,
                             const uint8_t *inbuffer, float *outbuffer)
{
915
    int sub_packet_size = p->size;
916
    /* packet dump */
917 918 919 920
    // for (i = 0; i < sub_packet_size ; i++)
    //     av_log(q->avctx, AV_LOG_ERROR, "%02x", inbuffer[i]);
    // av_log(q->avctx, AV_LOG_ERROR, "\n");
    memset(q->decode_buffer_1, 0, sizeof(q->decode_buffer_1));
921
    decode_bytes_and_gain(q, p, inbuffer, &p->gains1);
922

923 924
    if (p->joint_stereo) {
        joint_decode(q, p, q->decode_buffer_1, q->decode_buffer_2);
925
    } else {
926
        mono_decode(q, p, q->decode_buffer_1);
927

928
        if (p->num_channels == 2) {
929
            decode_bytes_and_gain(q, p, inbuffer + sub_packet_size / 2, &p->gains2);
930
            mono_decode(q, p, q->decode_buffer_2);
931 932
        }
    }
933

934 935 936
    mlt_compensate_output(q, q->decode_buffer_1, &p->gains1,
                          p->mono_previous_buffer1, outbuffer, p->ch_idx);

937 938
    if (p->num_channels == 2)
        if (p->joint_stereo)
939 940
            mlt_compensate_output(q, q->decode_buffer_2, &p->gains1,
                                  p->mono_previous_buffer2, outbuffer, p->ch_idx + 1);
941
        else
942 943
            mlt_compensate_output(q, q->decode_buffer_2, &p->gains2,
                                  p->mono_previous_buffer2, outbuffer, p->ch_idx + 1);
944 945 946 947 948 949 950 951
}


/**
 * Cook frame decoding
 *
 * @param avctx     pointer to the AVCodecContext
 */
952 953 954
static int cook_decode_frame(AVCodecContext *avctx, void *data,
                             int *got_frame_ptr, AVPacket *avpkt)
{
955 956
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
957
    COOKContext *q = avctx->priv_data;
958 959
    float *samples = NULL;
    int i, ret;
960 961
    int offset = 0;
    int chidx = 0;
962 963 964 965

    if (buf_size < avctx->block_align)
        return buf_size;

966 967 968 969 970 971 972
    /* get output buffer */
    if (q->discarded_packets >= 2) {
        q->frame.nb_samples = q->samples_per_channel;
        if ((ret = avctx->get_buffer(avctx, &q->frame)) < 0) {
            av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
            return ret;
        }
973
        samples = (float *) q->frame.data[0];
974 975
    }

976 977 978
    /* estimate subpacket sizes */
    q->subpacket[0].size = avctx->block_align;

979
    for (i = 1; i < q->num_subpackets; i++) {
Benjamin Larsson's avatar
Benjamin Larsson committed
980
        q->subpacket[i].size = 2 * buf[avctx->block_align - q->num_subpackets + i];
Benjamin Larsson's avatar
Benjamin Larsson committed
981
        q->subpacket[0].size -= q->subpacket[i].size + 1;
982
        if (q->subpacket[0].size < 0) {
983 984
            av_log(avctx, AV_LOG_DEBUG,
                   "frame subpacket size total > avctx->block_align!\n");
985
            return AVERROR_INVALIDDATA;
986
        }
Benjamin Larsson's avatar
Benjamin Larsson committed
987
    }
988

989
    /* decode supbackets */
990 991 992
    for (i = 0; i < q->num_subpackets; i++) {
        q->subpacket[i].bits_per_subpacket = (q->subpacket[i].size * 8) >>
                                              q->subpacket[i].bits_per_subpdiv;
993
        q->subpacket[i].ch_idx = chidx;
994 995 996 997 998
        av_log(avctx, AV_LOG_DEBUG,
               "subpacket[%i] size %i js %i %i block_align %i\n",
               i, q->subpacket[i].size, q->subpacket[i].joint_stereo, offset,
               avctx->block_align);

999
        decode_subpacket(q, &q->subpacket[i], buf + offset, samples);
1000 1001
        offset += q->subpacket[i].size;
        chidx += q->subpacket[i].num_channels;
1002 1003
        av_log(avctx, AV_LOG_DEBUG, "subpacket[%i] %i %i\n",
               i, q->subpacket[i].size * 8, get_bits_count(&q->gb));
1004
    }
1005

1006
    /* Discard the first two frames: no valid audio. */
1007 1008 1009 1010 1011 1012
    if (q->discarded_packets < 2) {
        q->discarded_packets++;
        *got_frame_ptr = 0;
        return avctx->block_align;
    }

1013 1014
    *got_frame_ptr    = 1;
    *(AVFrame *) data = q->frame;
1015

1016 1017
    return avctx->block_align;
}
1018

1019
#ifdef DEBUG
1020
static void dump_cook_context(COOKContext *q)
1021 1022
{
    //int i=0;
1023 1024 1025
#define PRINT(a, b) av_log(q->avctx, AV_LOG_ERROR, " %s = %d\n", a, b);
    av_log(q->avctx, AV_LOG_ERROR, "COOKextradata\n");
    av_log(q->avctx, AV_LOG_ERROR, "cookversion=%x\n", q->subpacket[0].cookversion);
1026
    if (q->subpacket[0].cookversion > STEREO) {
1027 1028
        PRINT("js_subband_start", q->subpacket[0].js_subband_start);
        PRINT("js_vlc_bits", q->subpacket[0].js_vlc_bits);
1029
    }
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
    av_log(q->avctx, AV_LOG_ERROR, "COOKContext\n");
    PRINT("nb_channels", q->nb_channels);
    PRINT("bit_rate", q->bit_rate);
    PRINT("sample_rate", q->sample_rate);
    PRINT("samples_per_channel", q->subpacket[0].samples_per_channel);
    PRINT("samples_per_frame", q->subpacket[0].samples_per_frame);
    PRINT("subbands", q->subpacket[0].subbands);
    PRINT("js_subband_start", q->subpacket[0].js_subband_start);
    PRINT("log2_numvector_size", q->subpacket[0].log2_numvector_size);
    PRINT("numvector_size", q->subpacket[0].numvector_size);
    PRINT("total_subbands", q->subpacket[0].total_subbands);
1041 1042
}
#endif
1043

1044 1045
static av_cold int cook_count_channels(unsigned int mask)
{
1046 1047
    int i;
    int channels = 0;
1048 1049
    for (i = 0; i < 32; i++)
        if (mask & (1 << i))
1050 1051 1052 1053
            ++channels;
    return channels;
}

1054 1055 1056 1057 1058
/**
 * Cook initialization
 *
 * @param avctx     pointer to the AVCodecContext
 */
1059
static av_cold int cook_decode_init(AVCodecContext *avctx)
1060 1061
{
    COOKContext *q = avctx->priv_data;
Michael Niedermayer's avatar
Michael Niedermayer committed
1062
    const uint8_t *edata_ptr = avctx->extradata;
1063 1064 1065
    const uint8_t *edata_ptr_end = edata_ptr + avctx->extradata_size;
    int extradata_size = avctx->extradata_size;
    int s = 0;
1066
    unsigned int channel_mask = 0;
1067
    int ret;
1068
    q->avctx = avctx;
1069 1070

    /* Take care of the codec specific extradata. */
1071
    if (extradata_size <= 0) {
1072
        av_log(avctx, AV_LOG_ERROR, "Necessary extradata missing!\n");
1073
        return AVERROR_INVALIDDATA;
1074
    }
1075
    av_log(avctx, AV_LOG_DEBUG, "codecdata_length=%d\n", avctx->extradata_size);
1076 1077 1078 1079 1080 1081

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

1082
    /* Initialize RNG. */
1083
    av_lfg_init(&q->random_state, 0);
1084

1085
    while (edata_ptr < edata_ptr_end) {
1086 1087
        /* 8 for mono, 16 for stereo, ? for multichannel
           Swap to right endianness so we don't need to care later on. */
1088
        if (extradata_size >= 8) {
1089
            q->subpacket[s].cookversion = bytestream_get_be32(&edata_ptr);
1090
            q->subpacket[s].samples_per_frame = bytestream_get_be16(&edata_ptr);
1091 1092 1093
            q->subpacket[s].subbands = bytestream_get_be16(&edata_ptr);
            extradata_size -= 8;
        }
1094
        if (extradata_size >= 8) {
1095
            bytestream_get_be32(&edata_ptr);    // Unknown unused
1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111
            q->subpacket[s].js_subband_start = bytestream_get_be16(&edata_ptr);
            q->subpacket[s].js_vlc_bits = bytestream_get_be16(&edata_ptr);
            extradata_size -= 8;
        }

        /* Initialize extradata related variables. */
        q->subpacket[s].samples_per_channel = q->subpacket[s].samples_per_frame / q->nb_channels;
        q->subpacket[s].bits_per_subpacket = avctx->block_align * 8;

        /* Initialize default data states. */
        q->subpacket[s].log2_numvector_size = 5;
        q->subpacket[s].total_subbands = q->subpacket[s].subbands;
        q->subpacket[s].num_channels = 1;

        /* Initialize version-dependent variables */

1112 1113
        av_log(avctx, AV_LOG_DEBUG, "subpacket[%i].cookversion=%x\n", s,
               q->subpacket[s].cookversion);
1114 1115
        q->subpacket[s].joint_stereo = 0;
        switch (q->subpacket[s].cookversion) {
1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160
        case MONO:
            if (q->nb_channels != 1) {
                av_log_ask_for_sample(avctx, "Container channels != 1.\n");
                return AVERROR_PATCHWELCOME;
            }
            av_log(avctx, AV_LOG_DEBUG, "MONO\n");
            break;
        case STEREO:
            if (q->nb_channels != 1) {
                q->subpacket[s].bits_per_subpdiv = 1;
                q->subpacket[s].num_channels = 2;
            }
            av_log(avctx, AV_LOG_DEBUG, "STEREO\n");
            break;
        case JOINT_STEREO:
            if (q->nb_channels != 2) {
                av_log_ask_for_sample(avctx, "Container channels != 2.\n");
                return AVERROR_PATCHWELCOME;
            }
            av_log(avctx, AV_LOG_DEBUG, "JOINT_STEREO\n");
            if (avctx->extradata_size >= 16) {
                q->subpacket[s].total_subbands = q->subpacket[s].subbands +
                                                 q->subpacket[s].js_subband_start;
                q->subpacket[s].joint_stereo = 1;
                q->subpacket[s].num_channels = 2;
            }
            if (q->subpacket[s].samples_per_channel > 256) {
                q->subpacket[s].log2_numvector_size = 6;
            }
            if (q->subpacket[s].samples_per_channel > 512) {
                q->subpacket[s].log2_numvector_size = 7;
            }
            break;
        case MC_COOK:
            av_log(avctx, AV_LOG_DEBUG, "MULTI_CHANNEL\n");
            if (extradata_size >= 4)
                channel_mask |= q->subpacket[s].channel_mask = bytestream_get_be32(&edata_ptr);

            if (cook_count_channels(q->subpacket[s].channel_mask) > 1) {
                q->subpacket[s].total_subbands = q->subpacket[s].subbands +
                                                 q->subpacket[s].js_subband_start;
                q->subpacket[s].joint_stereo = 1;
                q->subpacket[s].num_channels = 2;
                q->subpacket[s].samples_per_channel = q->subpacket[s].samples_per_frame >> 1;

1161
                if (q->subpacket[s].samples_per_channel > 256) {
1162
                    q->subpacket[s].log2_numvector_size = 6;
1163 1164
                }
                if (q->subpacket[s].samples_per_channel > 512) {
1165
                    q->subpacket[s].log2_numvector_size = 7;
1166
                }
1167 1168
            } else
                q->subpacket[s].samples_per_channel = q->subpacket[s].samples_per_frame;
1169

1170 1171 1172 1173
            break;
        default:
            av_log_ask_for_sample(avctx, "Unknown Cook version.\n");
            return AVERROR_PATCHWELCOME;
1174 1175
        }

1176 1177
        if (s > 1 && q->subpacket[s].samples_per_channel != q->samples_per_channel) {
            av_log(avctx, AV_LOG_ERROR, "different number of samples per channel!\n");
1178
            return AVERROR_INVALIDDATA;
1179 1180 1181 1182 1183 1184 1185 1186 1187
        } else
            q->samples_per_channel = q->subpacket[0].samples_per_channel;


        /* Initialize variable relations */
        q->subpacket[s].numvector_size = (1 << q->subpacket[s].log2_numvector_size);

        /* Try to catch some obviously faulty streams, othervise it might be exploitable */
        if (q->subpacket[s].total_subbands > 53) {
1188
            av_log_ask_for_sample(avctx, "total_subbands > 53\n");
1189
            return AVERROR_PATCHWELCOME;
1190 1191
        }

1192 1193 1194 1195
        if ((q->subpacket[s].js_vlc_bits > 6) ||
            (q->subpacket[s].js_vlc_bits < 2 * q->subpacket[s].joint_stereo)) {
            av_log(avctx, AV_LOG_ERROR, "js_vlc_bits = %d, only >= %d and <= 6 allowed!\n",
                   q->subpacket[s].js_vlc_bits, 2 * q->subpacket[s].joint_stereo);
1196
            return AVERROR_INVALIDDATA;
1197
        }
1198

1199
        if (q->subpacket[s].subbands > 50) {
1200
            av_log_ask_for_sample(avctx, "subbands > 50\n");
1201
            return AVERROR_PATCHWELCOME;
1202 1203 1204 1205 1206
        }
        q->subpacket[s].gains1.now      = q->subpacket[s].gain_1;
        q->subpacket[s].gains1.previous = q->subpacket[s].gain_2;
        q->subpacket[s].gains2.now      = q->subpacket[s].gain_3;
        q->subpacket[s].gains2.previous = q->subpacket[s].gain_4;
1207

1208 1209
        q->num_subpackets++;
        s++;
1210
        if (s > MAX_SUBPACKETS) {
1211
            av_log_ask_for_sample(avctx, "Too many subpackets > 5\n");
1212
            return AVERROR_PATCHWELCOME;
1213
        }
1214
    }
1215
    /* Generate tables */
1216
    init_pow2table();
1217
    init_gain_table(q);
1218
    init_cplscales_table(q);
1219

1220 1221
    if ((ret = init_cook_vlc_tables(q)))
        return ret;
1222

1223

1224
    if (avctx->block_align >= UINT_MAX / 2)
1225
        return AVERROR(EINVAL);
1226

1227 1228 1229
    /* Pad the databuffer with:
       DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(),
       FF_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */
1230 1231 1232 1233
    q->decoded_bytes_buffer =
        av_mallocz(avctx->block_align
                   + DECODE_BYTES_PAD1(avctx->block_align)
                   + FF_INPUT_BUFFER_PADDING_SIZE);
1234
    if (q->decoded_bytes_buffer == NULL)
1235
        return AVERROR(ENOMEM);
1236 1237

    /* Initialize transform. */
1238 1239
    if ((ret = init_cook_mlt(q)))
        return ret;
1240

1241 1242
    /* Initialize COOK signal arithmetic handling */
    if (1) {
1243
        q->scalar_dequant  = scalar_dequant_float;
1244 1245
        q->decouple        = decouple_float;
        q->imlt_window     = imlt_window_float;
1246
        q->interpolate     = interpolate_float;
1247 1248 1249
        q->saturate_output = saturate_output_float;
    }

1250
    /* Try to catch some obviously faulty streams, othervise it might be exploitable */
1251 1252
    if ((q->samples_per_channel == 256) || (q->samples_per_channel == 512)
                || (q->samples_per_channel == 1024)) {
1253
    } else {
1254 1255 1256
        av_log_ask_for_sample(avctx,
                              "unknown amount of samples_per_channel = %d\n",
                              q->samples_per_channel);
1257
        return AVERROR_PATCHWELCOME;
1258
    }
1259

1260
    avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1261 1262 1263
    if (channel_mask)
        avctx->channel_layout = channel_mask;
    else
1264
        avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
1265

1266 1267 1268
    avcodec_get_frame_defaults(&q->frame);
    avctx->coded_frame = &q->frame;

1269
#ifdef DEBUG
1270
    dump_cook_context(q);
1271
#endif
1272 1273 1274
    return 0;
}

1275 1276 1277 1278
AVCodec ff_cook_decoder = {
    .name           = "cook",
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = CODEC_ID_COOK,
1279
    .priv_data_size = sizeof(COOKContext),
1280 1281 1282 1283 1284
    .init           = cook_decode_init,
    .close          = cook_decode_close,
    .decode         = cook_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
    .long_name      = NULL_IF_CONFIG_SMALL("COOK"),
1285
};