cook.c File Reference

#include <math.h>
#include <stddef.h>
#include <stdio.h>
#include "libavutil/random.h"
#include "avcodec.h"
#include "bitstream.h"
#include "dsputil.h"
#include "bytestream.h"
#include "cookdata.h"

Go to the source code of this file.

Data Structures
struct	cook_gains
struct	cook
Defines
#define	MONO   0x1000001
#define	STEREO   0x1000002
#define	JOINT_STEREO   0x1000003
#define	MC_COOK   0x2000000
#define	SUBBAND_SIZE   20
#define	DECODE_BYTES_PAD1(bytes)   (3 - ((bytes)+3) % 4)
#define	DECODE_BYTES_PAD2(bytes)   ((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes)))
Typedefs
typedef cook	COOKContext
Functions
static void	init_pow2table (void)
static void	init_gain_table (COOKContext *q)
static int	init_cook_vlc_tables (COOKContext *q)
static int	init_cook_mlt (COOKContext *q)
static const float *	maybe_reformat_buffer32 (COOKContext *q, const float *ptr, int n)
static void	init_cplscales_table (COOKContext *q)
static int	decode_bytes (const uint8_t *inbuffer, uint8_t *out, int bytes)
static int	cook_decode_close (AVCodecContext *avctx)
static void	decode_gain_info (GetBitContext *gb, int *gaininfo)
static void	decode_envelope (COOKContext *q, int *quant_index_table)
static void	categorize (COOKContext *q, int *quant_index_table, int *category, int *category_index)
static void	expand_category (COOKContext *q, int *category, int *category_index)
static void	scalar_dequant_float (COOKContext *q, int index, int quant_index, int *subband_coef_index, int *subband_coef_sign, float *mlt_p)
static int	unpack_SQVH (COOKContext *q, int category, int *subband_coef_index, int *subband_coef_sign)
static void	decode_vectors (COOKContext *q, int *category, int *quant_index_table, float *mlt_buffer)
static void	mono_decode (COOKContext *q, float *mlt_buffer)
static void	interpolate_float (COOKContext *q, float *buffer, int gain_index, int gain_index_next)
static void	imlt_window_float (COOKContext *q, float *buffer1, cook_gains *gains_ptr, float *previous_buffer)
static void	imlt_gain (COOKContext *q, float *inbuffer, cook_gains *gains_ptr, float *previous_buffer)
static void	decouple_info (COOKContext *q, int *decouple_tab)
static void	decouple_float (COOKContext *q, int subband, float f1, float f2, float *decode_buffer, float *mlt_buffer1, float *mlt_buffer2)
static void	joint_decode (COOKContext *q, float *mlt_buffer1, float *mlt_buffer2)
static void	decode_bytes_and_gain (COOKContext *q, const uint8_t *inbuffer, cook_gains *gains_ptr)
static void	saturate_output_float (COOKContext *q, int chan, int16_t *out)
static void	mlt_compensate_output (COOKContext *q, float *decode_buffer, cook_gains *gains, float *previous_buffer, int16_t *out, int chan)
static int	decode_subpacket (COOKContext *q, const uint8_t *inbuffer, int sub_packet_size, int16_t *outbuffer)
static int	cook_decode_frame (AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size)
static int	cook_decode_init (AVCodecContext *avctx)
Variables
static float	pow2tab [127]
static float	rootpow2tab [127]
AVCodec	cook_decoder

---

Detailed Description

Cook compatible decoder. Bastardization of the G.722.1 standard. 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.

Definition in file cook.c.

---

Define Documentation

#define DECODE_BYTES_PAD1

(

bytes

)

(3 - ((bytes)+3) % 4)

Cook indata decoding, every 32 bits are XORed with 0x37c511f2. Why? No idea, some checksum/error detection method maybe.

Out buffer size: extra bytes are needed to cope with padding/misalignment. 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

Nice way to waste CPU cycles.

Parameters:

	inbuffer	pointer to byte array of indata
	out	pointer to byte array of outdata
	bytes	number of bytes

Definition at line 290 of file cook.c.

Referenced by cook_decode_init().

#define DECODE_BYTES_PAD2

(

bytes

)

((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes)))

Definition at line 291 of file cook.c.

Referenced by cook_decode_init().

#define JOINT_STEREO   0x1000003

Definition at line 60 of file cook.c.

#define MC_COOK   0x2000000

Definition at line 61 of file cook.c.

Referenced by cook_decode_init().

#define MONO   0x1000001

Definition at line 58 of file cook.c.

Referenced by cook_decode_init().

#define STEREO   0x1000002

Definition at line 59 of file cook.c.

#define SUBBAND_SIZE   20

Definition at line 63 of file cook.c.

Referenced by decode_vectors(), decouple_float(), joint_decode(), and scalar_dequant_float().

---

Typedef Documentation

typedef struct cook COOKContext

---

Function Documentation

static void categorize	(	COOKContext *	q,
		int *	quant_index_table,
		int *	category,
		int *	category_index
	)			[static]

Calculate the category and category_index vector.

Parameters:

	q	pointer to the COOKContext
	quant_index_table	pointer to the array
	category	pointer to the category array
	category_index	pointer to the category_index array

Definition at line 408 of file cook.c.

References av_clip(), cook::bits_per_subpacket, expbits_tab, cook::gb, get_bits_count(), cook::numvector_size, cook::samples_per_channel, and cook::total_subbands.

Referenced by mono_decode().

                                                          {
    int exp_idx, bias, tmpbias1, tmpbias2, bits_left, num_bits, index, v, i, j;
    int exp_index2[102];
    int exp_index1[102];

    int tmp_categorize_array[128*2];
    int tmp_categorize_array1_idx=q->numvector_size;
    int tmp_categorize_array2_idx=q->numvector_size;

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

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

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

    bias=-32;

    /* Estimate bias. */
    for (i=32 ; i>0 ; i=i/2){
        num_bits = 0;
        index = 0;
        for (j=q->total_subbands ; j>0 ; j--){
            exp_idx = av_clip((i - quant_index_table[index] + bias) / 2, 0, 7);
            index++;
            num_bits+=expbits_tab[exp_idx];
        }
        if(num_bits >= bits_left - 32){
            bias+=i;
        }
    }

    /* Calculate total number of bits. */
    num_bits=0;
    for (i=0 ; i<q->total_subbands ; i++) {
        exp_idx = av_clip((bias - quant_index_table[i]) / 2, 0, 7);
        num_bits += expbits_tab[exp_idx];
        exp_index1[i] = exp_idx;
        exp_index2[i] = exp_idx;
    }
    tmpbias1 = tmpbias2 = num_bits;

    for (j = 1 ; j < q->numvector_size ; j++) {
        if (tmpbias1 + tmpbias2 > 2*bits_left) {  /* ---> */
            int max = -999999;
            index=-1;
            for (i=0 ; i<q->total_subbands ; i++){
                if (exp_index1[i] < 7) {
                    v = (-2*exp_index1[i]) - quant_index_table[i] + bias;
                    if ( v >= max) {
                        max = v;
                        index = i;
                    }
                }
            }
            if(index==-1)break;
            tmp_categorize_array[tmp_categorize_array1_idx++] = index;
            tmpbias1 -= expbits_tab[exp_index1[index]] -
                        expbits_tab[exp_index1[index]+1];
            ++exp_index1[index];
        } else {  /* <--- */
            int min = 999999;
            index=-1;
            for (i=0 ; i<q->total_subbands ; i++){
                if(exp_index2[i] > 0){
                    v = (-2*exp_index2[i])-quant_index_table[i]+bias;
                    if ( v < min) {
                        min = v;
                        index = i;
                    }
                }
            }
            if(index == -1)break;
            tmp_categorize_array[--tmp_categorize_array2_idx] = index;
            tmpbias2 -= expbits_tab[exp_index2[index]] -
                        expbits_tab[exp_index2[index]-1];
            --exp_index2[index];
        }
    }

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

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

}

static int cook_decode_close

(

AVCodecContext *

avctx

)

[static]

Cook uninit

Definition at line 318 of file cook.c.

References av_free(), av_log(), AV_LOG_DEBUG, cook::ccpl, cook::decoded_bytes_buffer, cook::envelope_quant_index, ff_mdct_end(), free_vlc(), cook::joint_stereo, cook::mdct_ctx, cook::mlt_window, cook::nb_channels, AVCodecContext::priv_data, and cook::sqvh.

{
    int i;
    COOKContext *q = avctx->priv_data;
    av_log(avctx,AV_LOG_DEBUG, "Deallocating memory.\n");

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

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

    /* 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]);
    }
    if(q->nb_channels==2 && q->joint_stereo==1 ){
        free_vlc(&q->ccpl);
    }

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

    return 0;
}

static int cook_decode_frame	(	AVCodecContext *	avctx,
		void *	data,
		int *	data_size,
		const uint8_t *	buf,
		int	buf_size
	)			[static]

Cook frame decoding

Parameters:

avctx

pointer to the AVCodecContext

Definition at line 979 of file cook.c.

References AVCodecContext::block_align, decode_subpacket(), AVCodecContext::frame_number, and AVCodecContext::priv_data.

                                              {
    COOKContext *q = avctx->priv_data;

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

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

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

    return avctx->block_align;
}

static int cook_decode_init

(

AVCodecContext *

avctx

)

[static]

Cook initialization

Parameters:

avctx

pointer to the AVCodecContext

Definition at line 1027 of file cook.c.

References av_init_random(), av_log(), AV_LOG_DEBUG, AV_LOG_ERROR, av_mallocz(), AVCodecContext::bit_rate, cook::bit_rate, cook::bits_per_subpacket, AVCodecContext::block_align, AVCodecContext::channels, cook::cookversion, DECODE_BYTES_PAD1, DECODE_BYTES_PAD2, cook::decoded_bytes_buffer, cook::decouple, decouple_float(), AVCodecContext::extradata, AVCodecContext::extradata_size, FF_INPUT_BUFFER_PADDING_SIZE, cook::gain_1, cook::gain_2, cook::gain_3, cook::gain_4, cook::gains1, cook::gains2, cook::imlt_window, imlt_window_float(), init_cook_mlt(), init_cook_vlc_tables(), init_cplscales_table(), init_gain_table(), init_pow2table(), cook::interpolate, interpolate_float(), JOINT_STEREO, cook::joint_stereo, cook::js_subband_start, cook::js_vlc_bits, cook::log2_numvector_size, MC_COOK, MONO, cook::nb_channels, cook_gains::now, NULL, cook::numvector_size, cook_gains::previous, AVCodecContext::priv_data, cook::random_state, AVCodecContext::sample_rate, cook::sample_rate, cook::samples_per_channel, cook::samples_per_frame, cook::saturate_output, saturate_output_float(), cook::scalar_dequant, scalar_dequant_float(), STEREO, cook::subbands, and cook::total_subbands.

{
    COOKContext *q = avctx->priv_data;
    const uint8_t *edata_ptr = avctx->extradata;

    /* Take care of the codec specific extradata. */
    if (avctx->extradata_size <= 0) {
        av_log(avctx,AV_LOG_ERROR,"Necessary extradata missing!\n");
        return -1;
    } else {
        /* 8 for mono, 16 for stereo, ? for multichannel
           Swap to right endianness so we don't need to care later on. */
        av_log(avctx,AV_LOG_DEBUG,"codecdata_length=%d\n",avctx->extradata_size);
        if (avctx->extradata_size >= 8){
            q->cookversion = bytestream_get_be32(&edata_ptr);
            q->samples_per_frame =  bytestream_get_be16(&edata_ptr);
            q->subbands = bytestream_get_be16(&edata_ptr);
        }
        if (avctx->extradata_size >= 16){
            bytestream_get_be32(&edata_ptr);    //Unknown unused
            q->js_subband_start = bytestream_get_be16(&edata_ptr);
            q->js_vlc_bits = bytestream_get_be16(&edata_ptr);
        }
    }

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

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

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

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

    /* Initialize version-dependent variables */
    av_log(NULL,AV_LOG_DEBUG,"q->cookversion=%x\n",q->cookversion);
    q->joint_stereo = 0;
    switch (q->cookversion) {
        case MONO:
            if (q->nb_channels != 1) {
                av_log(avctx,AV_LOG_ERROR,"Container channels != 1, report sample!\n");
                return -1;
            }
            av_log(avctx,AV_LOG_DEBUG,"MONO\n");
            break;
        case STEREO:
            if (q->nb_channels != 1) {
                q->bits_per_subpacket = q->bits_per_subpacket/2;
            }
            av_log(avctx,AV_LOG_DEBUG,"STEREO\n");
            break;
        case JOINT_STEREO:
            if (q->nb_channels != 2) {
                av_log(avctx,AV_LOG_ERROR,"Container channels != 2, report sample!\n");
                return -1;
            }
            av_log(avctx,AV_LOG_DEBUG,"JOINT_STEREO\n");
            if (avctx->extradata_size >= 16){
                q->total_subbands = q->subbands + q->js_subband_start;
                q->joint_stereo = 1;
            }
            if (q->samples_per_channel > 256) {
                q->log2_numvector_size  = 6;
            }
            if (q->samples_per_channel > 512) {
                q->log2_numvector_size  = 7;
            }
            break;
        case MC_COOK:
            av_log(avctx,AV_LOG_ERROR,"MC_COOK not supported!\n");
            return -1;
            break;
        default:
            av_log(avctx,AV_LOG_ERROR,"Unknown Cook version, report sample!\n");
            return -1;
            break;
    }

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

    /* Generate tables */
    init_pow2table();
    init_gain_table(q);
    init_cplscales_table(q);

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


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

    /* Pad the databuffer with:
       DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(),
       FF_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */
    if (q->nb_channels==2 && q->joint_stereo==0) {
        q->decoded_bytes_buffer =
          av_mallocz(avctx->block_align/2
                     + DECODE_BYTES_PAD2(avctx->block_align/2)
                     + FF_INPUT_BUFFER_PADDING_SIZE);
    } else {
        q->decoded_bytes_buffer =
          av_mallocz(avctx->block_align
                     + DECODE_BYTES_PAD1(avctx->block_align)
                     + FF_INPUT_BUFFER_PADDING_SIZE);
    }
    if (q->decoded_bytes_buffer == NULL)
        return -1;

    q->gains1.now      = q->gain_1;
    q->gains1.previous = q->gain_2;
    q->gains2.now      = q->gain_3;
    q->gains2.previous = q->gain_4;

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

    /* Initialize COOK signal arithmetic handling */
    if (1) {
        q->scalar_dequant  = scalar_dequant_float;
        q->decouple        = decouple_float;
        q->imlt_window     = imlt_window_float;
        q->interpolate     = interpolate_float;
        q->saturate_output = saturate_output_float;
    }

    /* Try to catch some obviously faulty streams, othervise it might be exploitable */
    if (q->total_subbands > 53) {
        av_log(avctx,AV_LOG_ERROR,"total_subbands > 53, report sample!\n");
        return -1;
    }
    if (q->subbands > 50) {
        av_log(avctx,AV_LOG_ERROR,"subbands > 50, report sample!\n");
        return -1;
    }
    if ((q->samples_per_channel == 256) || (q->samples_per_channel == 512) || (q->samples_per_channel == 1024)) {
    } else {
        av_log(avctx,AV_LOG_ERROR,"unknown amount of samples_per_channel = %d, report sample!\n",q->samples_per_channel);
        return -1;
    }
    if ((q->js_vlc_bits > 6) || (q->js_vlc_bits < 0)) {
        av_log(avctx,AV_LOG_ERROR,"q->js_vlc_bits = %d, only >= 0 and <= 6 allowed!\n",q->js_vlc_bits);
        return -1;
    }

#ifdef COOKDEBUG
    dump_cook_context(q);
#endif
    return 0;
}

static int decode_bytes	(	const uint8_t *	inbuffer,
		uint8_t *	out,
		int	bytes
	)			[inline, static]

Definition at line 293 of file cook.c.

References be2me_32, c, and off.

                                                                                {
    int i, off;
    uint32_t c;
    const uint32_t* buf;
    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++)
     *     (int64_t)out[i] = 0x37c511f237c511f2^be2me_64(int64_t)in[i]);
     * Buffer alignment needs to be checked. */

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

    return off;
}

static void decode_bytes_and_gain	(	COOKContext *	q,
		const uint8_t *	inbuffer,
		cook_gains *	gains_ptr
	)			[inline, static]

First part of subpacket decoding: decode raw stream bytes and read gain info.

Parameters:

	q	pointer to the COOKContext
	inbuffer	pointer to raw stream data
	gain_ptr	array of current/prev gain pointers

Definition at line 867 of file cook.c.

References cook::bits_per_subpacket, decode_bytes(), decode_gain_info(), cook::decoded_bytes_buffer, FFSWAP, cook::gb, init_get_bits(), cook_gains::now, offset, and cook_gains::previous.

Referenced by decode_subpacket().

{
    int offset;

    offset = decode_bytes(inbuffer, q->decoded_bytes_buffer,
                          q->bits_per_subpacket/8);
    init_get_bits(&q->gb, q->decoded_bytes_buffer + offset,
                  q->bits_per_subpacket);
    decode_gain_info(&q->gb, gains_ptr->now);

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

static void decode_envelope	(	COOKContext *	q,
		int *	quant_index_table
	)			[static]

Create the quant index table needed for the envelope.

Parameters:

	q	pointer to the COOKContext
	quant_index_table	pointer to the array

Definition at line 378 of file cook.c.

References VLC::bits, cook::envelope_quant_index, cook::gb, get_bits(), get_vlc2(), cook::js_subband_start, VLC::table, and cook::total_subbands.

Referenced by mono_decode().

                                                                    {
    int i,j, vlc_index;

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

    for (i=1 ; i < q->total_subbands ; i++){
        vlc_index=i;
        if (i >= q->js_subband_start * 2) {
            vlc_index-=q->js_subband_start;
        } 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
    }
}

static void decode_gain_info	(	GetBitContext *	gb,
		int *	gaininfo
	)			[static]

Fill the gain array for the timedomain quantization.

Parameters:

	q	pointer to the COOKContext
	gaininfo[9]	array of gain indexes

Definition at line 354 of file cook.c.

References cook::gb, get_bits(), get_bits1(), and get_bits_count().

Referenced by decode_bytes_and_gain().

{
    int i, n;

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

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

        while (i <= index) gaininfo[i++] = gain;
    }
    while (i <= 8) gaininfo[i++] = 0;
}

static int decode_subpacket	(	COOKContext *	q,
		const uint8_t *	inbuffer,
		int	sub_packet_size,
		int16_t *	outbuffer
	)			[static]

Cook subpacket decoding. This function returns one decoded subpacket, usually 1024 samples per channel.

Parameters:

	q	pointer to the COOKContext
	inbuffer	pointer to the inbuffer
	sub_packet_size	subpacket size
	outbuffer	pointer to the outbuffer

Definition at line 936 of file cook.c.

References cook::decode_buffer_1, cook::decode_buffer_2, decode_bytes_and_gain(), cook::gains1, cook::gains2, joint_decode(), cook::joint_stereo, mlt_compensate_output(), mono_decode(), cook::mono_previous_buffer1, cook::mono_previous_buffer2, cook::nb_channels, and cook::samples_per_frame.

Referenced by cook_decode_frame().

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

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

    if (q->joint_stereo) {
        joint_decode(q, q->decode_buffer_1, q->decode_buffer_2);
    } else {
        mono_decode(q, q->decode_buffer_1);

        if (q->nb_channels == 2) {
            decode_bytes_and_gain(q, inbuffer + sub_packet_size/2, &q->gains2);
            mono_decode(q, q->decode_buffer_2);
        }
    }

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

    if (q->nb_channels == 2) {
        if (q->joint_stereo) {
            mlt_compensate_output(q, q->decode_buffer_2, &q->gains1,
                                  q->mono_previous_buffer2, outbuffer, 1);
        } else {
            mlt_compensate_output(q, q->decode_buffer_2, &q->gains2,
                                  q->mono_previous_buffer2, outbuffer, 1);
        }
    }
    return q->samples_per_frame * sizeof(int16_t);
}

static void decode_vectors	(	COOKContext *	q,
		int *	category,
		int *	quant_index_table,
		float *	mlt_buffer
	)			[static]

Fill the mlt_buffer with mlt coefficients.

Parameters:

	q	pointer to the COOKContext
	category	pointer to the category array
	quant_index_table	pointer to the array
	mlt_buffer	pointer to mlt coefficients

Definition at line 602 of file cook.c.

References cook::samples_per_channel, cook::scalar_dequant, SUBBAND_SIZE, cook::total_subbands, and unpack_SQVH().

Referenced by mono_decode().

                                                                     {
    /* A zero in this table means that the subband coefficient is
       random noise coded. */
    int subband_coef_index[SUBBAND_SIZE];
    /* A zero in this table means that the subband coefficient is a
       positive multiplicator. */
    int subband_coef_sign[SUBBAND_SIZE];
    int band, j;
    int index=0;

    for(band=0 ; band<q->total_subbands ; band++){
        index = category[band];
        if(category[band] < 7){
            if(unpack_SQVH(q, category[band], subband_coef_index, subband_coef_sign)){
                index=7;
                for(j=0 ; j<q->total_subbands ; j++) category[band+j]=7;
            }
        }
        if(index==7) {
            memset(subband_coef_index, 0, sizeof(subband_coef_index));
            memset(subband_coef_sign, 0, sizeof(subband_coef_sign));
        }
        q->scalar_dequant(q, index, quant_index_table[band],
                          subband_coef_index, subband_coef_sign,
                          &mlt_buffer[band * SUBBAND_SIZE]);
    }

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

static void decouple_float	(	COOKContext *	q,
		int	subband,
		float	f1,
		float	f2,
		float *	decode_buffer,
		float *	mlt_buffer1,
		float *	mlt_buffer2
	)			[static]

Definition at line 795 of file cook.c.

References cook::js_subband_start, and SUBBAND_SIZE.

Referenced by cook_decode_init().

{
    int j, tmp_idx;
    for (j=0 ; j<SUBBAND_SIZE ; j++) {
        tmp_idx = ((q->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];
    }
}

static void decouple_info	(	COOKContext *	q,
		int *	decouple_tab
	)			[static]

function for getting the jointstereo coupling information

Parameters:

	q	pointer to the COOKContext
	decouple_tab	decoupling array

Definition at line 762 of file cook.c.

References VLC::bits, cook::ccpl, cplband, for(), cook::gb, get_bits(), get_bits1(), get_vlc2(), cook::js_subband_start, cook::js_vlc_bits, cook::subbands, and VLC::table.

Referenced by joint_decode().

                                                            {
    int length, i;

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

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

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

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

static void expand_category	(	COOKContext *	q,
		int *	category,
		int *	category_index
	)			[inline, static]

Expand the category vector.

Parameters:

	q	pointer to the COOKContext
	category	pointer to the category array
	category_index	pointer to the category_index array

Definition at line 511 of file cook.c.

References cook::num_vectors.

Referenced by mono_decode().

                                                       {
    int i;
    for(i=0 ; i<q->num_vectors ; i++){
        ++category[category_index[i]];
    }
}

static void imlt_gain	(	COOKContext *	q,
		float *	inbuffer,
		cook_gains *	gains_ptr,
		float *	previous_buffer
	)			[static]

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.

Parameters:

	q	pointer to the COOKContext
	inbuffer	pointer to the mltcoefficients
	gains_ptr	current and previous gains
	previous_buffer	pointer to the previous buffer to be used for overlapping

Definition at line 729 of file cook.c.

References MDCTContext::fft, cook::gain_size_factor, FFTContext::imdct_calc, cook::imlt_window, cook::interpolate, cook::mdct_ctx, cook_gains::now, and cook::samples_per_channel.

Referenced by mlt_compensate_output().

{
    float *buffer0 = q->mono_mdct_output;
    float *buffer1 = q->mono_mdct_output + q->samples_per_channel;
    int i;

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

    q->imlt_window (q, buffer1, gains_ptr, previous_buffer);

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

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

static void imlt_window_float	(	COOKContext *	q,
		float *	buffer1,
		cook_gains *	gains_ptr,
		float *	previous_buffer
	)			[static]

Apply transform window, overlap buffers.

Parameters:

	q	pointer to the COOKContext
	inbuffer	pointer to the mltcoefficients
	gains_ptr	current and previous gains
	previous_buffer	pointer to the previous buffer to be used for overlapping

Definition at line 699 of file cook.c.

References cook::mlt_window, pow2tab, cook_gains::previous, and cook::samples_per_channel.

Referenced by cook_decode_init().

{
    const float fc = pow2tab[gains_ptr->previous[0] + 63];
    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++){
        buffer1[i] = buffer1[i] * fc * q->mlt_window[i] -
          previous_buffer[i] * q->mlt_window[q->samples_per_channel - 1 - i];
    }
}

static int init_cook_mlt

(

COOKContext *

q

)

[static]

Definition at line 233 of file cook.c.

References av_free(), av_log(), av_log2(), AV_LOG_DEBUG, av_malloc(), ff_mdct_init(), ff_sine_window_init(), cook::mdct_ctx, cook::mlt_window, NULL, and cook::samples_per_channel.

Referenced by cook_decode_init().

                                         {
    int j;
    int mlt_size = q->samples_per_channel;

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

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

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

    return 0;
}

static int init_cook_vlc_tables

(

COOKContext *

q

)

[static]

Definition at line 206 of file cook.c.

References av_log(), AV_LOG_DEBUG, cook::ccpl, ccpl_huffbits, ccpl_huffcodes, cvh_huffbits, cvh_huffcodes, cook::envelope_quant_index, envelope_quant_index_huffbits, envelope_quant_index_huffcodes, init_vlc, cook::joint_stereo, cook::js_vlc_bits, cook::nb_channels, NULL, cook::sqvh, vhsize_tab, and vhvlcsize_tab.

Referenced by cook_decode_init().

                                                {
    int i, result;

    result = 0;
    for (i=0 ; i<13 ; i++) {
        result |= init_vlc (&q->envelope_quant_index[i], 9, 24,