X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fcook.c;h=cb95cd8d0d29d94b6c6400b65e5cfac77437432f;hb=bad5537e2c2caeb5deb1ff9d771ea01058b8010c;hp=516a1380c60949caf5938b4c744d343bd184e52d;hpb=b7c24ff668220eef34a6f3c1edc8fd9e32df364b;p=ffmpeg diff --git a/libavcodec/cook.c b/libavcodec/cook.c index 516a1380c60..cb95cd8d0d2 100644 --- a/libavcodec/cook.c +++ b/libavcodec/cook.c @@ -3,25 +3,26 @@ * Copyright (c) 2003 Sascha Sommer * Copyright (c) 2005 Benjamin Larsson * - * This library is free software; you can redistribute it and/or + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. + * version 2.1 of the License, or (at your option) any later version. * - * This library is distributed in the hope that it will be useful, + * FFmpeg is distributed in the hope that it will be useful, * 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 - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /** - * @file cook.c - * Cook compatible decoder. + * @file libavcodec/cook.c + * 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. * @@ -45,16 +46,17 @@ #include #include -#define ALT_BITSTREAM_READER +#include "libavutil/random.h" #include "avcodec.h" #include "bitstream.h" #include "dsputil.h" +#include "bytestream.h" #include "cookdata.h" /* the different Cook versions */ -#define MONO_COOK1 0x1000001 -#define MONO_COOK2 0x1000002 +#define MONO 0x1000001 +#define STEREO 0x1000002 #define JOINT_STEREO 0x1000003 #define MC_COOK 0x2000000 //multichannel Cook, not supported @@ -62,25 +64,33 @@ //#define COOKDEBUG typedef struct { - int size; - int qidx_table1[8]; - int qidx_table2[8]; -} COOKgain; - -typedef struct __attribute__((__packed__)){ - /* codec data start */ - uint32_t cookversion; //in network order, bigendian - uint16_t samples_per_frame; //amount of samples per frame per channel, bigendian - uint16_t subbands; //amount of bands used in the frequency domain, bigendian - /* Mono extradata ends here. */ - uint32_t unused; - uint16_t js_subband_start; //bigendian - uint16_t js_vlc_bits; //bigendian - /* Stereo extradata ends here. */ -} COOKextradata; + int *now; + int *previous; +} cook_gains; +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, + 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); -typedef struct { GetBitContext gb; /* stream data */ int nb_channels; @@ -90,33 +100,27 @@ typedef struct { int samples_per_channel; int samples_per_frame; int subbands; - int numvector_bits; - int numvector_size; //1 << numvector_bits; + int log2_numvector_size; + int numvector_size; //1 << log2_numvector_size; int js_subband_start; int total_subbands; int num_vectors; int bits_per_subpacket; + int cookversion; /* states */ - int random_state; + AVRandomState random_state; /* transform data */ - FFTContext fft_ctx; - FFTSample mlt_tmp[1024] __attribute__((aligned(16))); /* temporary storage for imlt */ + MDCTContext mdct_ctx; float* mlt_window; - float* mlt_precos; - float* mlt_presin; - float* mlt_postcos; - int fft_size; - int fft_order; - int mlt_size; //modulated lapped transform size /* gain buffers */ - COOKgain* gain_now_ptr; - COOKgain* gain_previous_ptr; - COOKgain gain_copy; - COOKgain gain_current; - COOKgain gain_now; - COOKgain gain_previous; + cook_gains gains1; + cook_gains gains2; + int gain_1[9]; + int gain_2[9]; + int gain_3[9]; + int gain_4[9]; /* VLC data */ int js_vlc_bits; @@ -127,28 +131,23 @@ typedef struct { /* generatable tables and related variables */ int gain_size_factor; float gain_table[23]; - float pow2tab[127]; - float rootpow2tab[127]; /* data buffers */ - uint8_t* frame_reorder_buffer; - int* frame_reorder_index; - int frame_reorder_counter; - int frame_reorder_complete; - int frame_reorder_index_size; uint8_t* decoded_bytes_buffer; - float mono_mdct_output[2048] __attribute__((aligned(16))); - float* previous_buffer_ptr[2]; + DECLARE_ALIGNED_16(float,mono_mdct_output[2048]); float mono_previous_buffer1[1024]; float mono_previous_buffer2[1024]; - float* decode_buf_ptr[4]; float decode_buffer_1[1024]; float decode_buffer_2[1024]; - float decode_buffer_3[1024]; - float decode_buffer_4[1024]; + float decode_buffer_0[1060]; /* static allocation for joint decode */ + + const float *cplscales[5]; } COOKContext; +static float pow2tab[127]; +static float rootpow2tab[127]; + /* debug functions */ #ifdef COOKDEBUG @@ -184,22 +183,11 @@ static void dump_short_table(short* table, int size, int delimiter) { /*************** init functions ***************/ /* table generator */ -static void init_pow2table(COOKContext *q){ - int i; - q->pow2tab[63] = 1.0; - for (i=1 ; i<64 ; i++){ - q->pow2tab[63+i]=(float)pow(2.0,(double)i); - q->pow2tab[63-i]=1.0/(float)pow(2.0,(double)i); - } -} - -/* table generator */ -static void init_rootpow2table(COOKContext *q){ +static void init_pow2table(void){ int i; - q->rootpow2tab[63] = 1.0; - for (i=1 ; i<64 ; i++){ - q->rootpow2tab[63+i]=sqrt((float)powf(2.0,(float)i)); - q->rootpow2tab[63-i]=sqrt(1.0/(float)powf(2.0,(float)i)); + for (i=-63 ; i<64 ; i++){ + pow2tab[63+i]= pow(2, i); + rootpow2tab[63+i]=sqrt(pow(2, i)); } } @@ -208,13 +196,9 @@ static void init_gain_table(COOKContext *q) { int i; q->gain_size_factor = q->samples_per_channel/8; for (i=0 ; i<23 ; i++) { - q->gain_table[i] = pow((double)q->pow2tab[i+52] , + q->gain_table[i] = pow(pow2tab[i+52] , (1.0/(double)q->gain_size_factor)); } - memset(&q->gain_copy, 0, sizeof(COOKgain)); - memset(&q->gain_current, 0, sizeof(COOKgain)); - memset(&q->gain_now, 0, sizeof(COOKgain)); - memset(&q->gain_previous, 0, sizeof(COOKgain)); } @@ -223,19 +207,19 @@ static int init_cook_vlc_tables(COOKContext *q) { result = 0; for (i=0 ; i<13 ; i++) { - result &= init_vlc (&q->envelope_quant_index[i], 9, 24, + 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); } av_log(NULL,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], + result |= init_vlc (&q->sqvh[i], vhvlcsize_tab[i], vhsize_tab[i], cvh_huffbits[i], 1, 1, cvh_huffcodes[i], 2, 2, 0); } if (q->nb_channels==2 && q->joint_stereo==1){ - result &= init_vlc (&q->ccpl, 6, (1<js_vlc_bits)-1, + result |= init_vlc (&q->ccpl, 6, (1<js_vlc_bits)-1, ccpl_huffbits[q->js_vlc_bits-2], 1, 1, ccpl_huffcodes[q->js_vlc_bits-2], 2, 2, 0); av_log(NULL,AV_LOG_DEBUG,"Joint-stereo VLC used.\n"); @@ -247,35 +231,37 @@ static int init_cook_vlc_tables(COOKContext *q) { static int init_cook_mlt(COOKContext *q) { int j; - float alpha; + int mlt_size = q->samples_per_channel; - /* Allocate the buffers, could be replaced with a static [512] - array if needed. */ - q->mlt_size = q->samples_per_channel; - q->mlt_window = av_malloc(sizeof(float)*q->mlt_size); - q->mlt_precos = av_malloc(sizeof(float)*q->mlt_size/2); - q->mlt_presin = av_malloc(sizeof(float)*q->mlt_size/2); - q->mlt_postcos = av_malloc(sizeof(float)*q->mlt_size/2); + if ((q->mlt_window = av_malloc(sizeof(float)*mlt_size)) == 0) + return -1; /* Initialize the MLT window: simple sine window. */ - alpha = M_PI / (2.0 * (float)q->mlt_size); - for(j=0 ; jmlt_size ; j++) { - q->mlt_window[j] = sin((j + 512.0/(float)q->mlt_size) * alpha); + ff_sine_window_init(q->mlt_window, mlt_size); + for(j=0 ; jmlt_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); - /* pre/post twiddle factors */ - for (j=0 ; jmlt_size/2 ; j++){ - q->mlt_precos[j] = cos( ((j+0.25)*M_PI)/q->mlt_size); - q->mlt_presin[j] = sin( ((j+0.25)*M_PI)/q->mlt_size); - q->mlt_postcos[j] = (float)sqrt(2.0/(float)q->mlt_size)*cos( ((float)j*M_PI) /q->mlt_size); //sqrt(2/MLT_size) = scalefactor - } + return 0; +} - /* Initialize the FFT. */ - ff_fft_init(&q->fft_ctx, av_log2(q->mlt_size)-1, 0); - av_log(NULL,AV_LOG_DEBUG,"FFT initialized, order = %d.\n", - av_log2(q->samples_per_channel)-1); +static const float *maybe_reformat_buffer32 (COOKContext *q, const float *ptr, int n) +{ + if (1) + return ptr; +} - return (int)(q->mlt_window && q->mlt_precos && q->mlt_presin && q->mlt_postcos); +static void init_cplscales_table (COOKContext *q) { + int i; + for (i=0;i<5;i++) + q->cplscales[i] = maybe_reformat_buffer32 (q, cplscales[i], (1<<(i+2))-1); } /*************** init functions end ***********/ @@ -283,16 +269,30 @@ static int init_cook_mlt(COOKContext *q) { /** * 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. * - * @param in pointer to 32bit array of indata - * @param bits amount of bits - * @param out pointer to 32bit array of outdata + * @param inbuffer pointer to byte array of indata + * @param out pointer to byte array of outdata + * @param bytes number of bytes */ +#define DECODE_BYTES_PAD1(bytes) (3 - ((bytes)+3) % 4) +#define DECODE_BYTES_PAD2(bytes) ((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes))) -static inline void decode_bytes(uint8_t* inbuffer, uint8_t* out, int bytes){ - int i; - uint32_t* buf = (uint32_t*) inbuffer; +static inline int decode_bytes(const uint8_t* inbuffer, uint8_t* out, int bytes){ + 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 @@ -300,14 +300,14 @@ static inline void decode_bytes(uint8_t* inbuffer, uint8_t* out, int bytes){ * (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]; - for(i=0 ; ipriv_data; - av_log(NULL,AV_LOG_DEBUG, "Deallocating memory.\n"); + av_log(avctx,AV_LOG_DEBUG, "Deallocating memory.\n"); /* Free allocated memory buffers. */ av_free(q->mlt_window); - av_free(q->mlt_precos); - av_free(q->mlt_presin); - av_free(q->mlt_postcos); - av_free(q->frame_reorder_index); - av_free(q->frame_reorder_buffer); av_free(q->decoded_bytes_buffer); /* Free the transform. */ - ff_fft_end(&q->fft_ctx); + ff_mdct_end(&q->mdct_ctx); /* Free the VLC tables. */ for (i=0 ; i<13 ; i++) { @@ -349,29 +344,27 @@ static int cook_decode_close(AVCodecContext *avctx) } /** - * Fill the COOKgain structure for the timedomain quantization. + * Fill the gain array for the timedomain quantization. * * @param q pointer to the COOKContext - * @param gaininfo pointer to the COOKgain + * @param gaininfo[9] array of gain indexes */ -static void decode_gain_info(GetBitContext *gb, COOKgain* gaininfo) { - int i; +static void decode_gain_info(GetBitContext *gb, int *gaininfo) +{ + int i, n; while (get_bits1(gb)) {} + n = get_bits_count(gb) - 1; //amount of elements*2 to update - gaininfo->size = get_bits_count(gb) - 1; //amount of elements*2 to update - - if (get_bits_count(gb) - 1 <= 0) return; + i = 0; + while (n--) { + int index = get_bits(gb, 3); + int gain = get_bits1(gb) ? get_bits(gb, 4) - 7 : -1; - for (i=0 ; isize ; i++){ - gaininfo->qidx_table1[i] = get_bits(gb,3); - if (get_bits1(gb)) { - gaininfo->qidx_table2[i] = get_bits(gb,4) - 7; //convert to signed - } else { - gaininfo->qidx_table2[i] = -1; - } + while (i <= index) gaininfo[i++] = gain; } + while (i <= 8) gaininfo[i++] = 0; } /** @@ -383,9 +376,7 @@ static void decode_gain_info(GetBitContext *gb, COOKgain* gaininfo) { static void decode_envelope(COOKContext *q, int* quant_index_table) { int i,j, vlc_index; - int bitbias; - bitbias = get_bits_count(&q->gb); quant_index_table[0]= get_bits(&q->gb,6) - 6; //This is used later in categorize for (i=1 ; i < q->total_subbands ; i++){ @@ -404,22 +395,6 @@ static void decode_envelope(COOKContext *q, int* quant_index_table) { } } -/** - * Create the quant value table. - * - * @param q pointer to the COOKContext - * @param quant_value_table pointer to the array - */ - -static void inline dequant_envelope(COOKContext *q, int* quant_index_table, - float* quant_value_table){ - - int i; - for(i=0 ; i < q->total_subbands ; i++){ - quant_value_table[i] = q->rootpow2tab[quant_index_table[i]+63]; - } -} - /** * Calculate the category and category_index vector. * @@ -431,15 +406,13 @@ static void inline dequant_envelope(COOKContext *q, int* quant_index_table, static void categorize(COOKContext *q, int* quant_index_table, int* category, int* category_index){ - int exp_idx, bias, tmpbias, bits_left, num_bits, index, v, i, j; + 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_array1[128]; - int tmp_categorize_array1_idx=0; - int tmp_categorize_array2[128]; - int tmp_categorize_array2_idx=0; - int category_index_size=0; + 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); @@ -451,8 +424,7 @@ static void categorize(COOKContext *q, int* quant_index_table, memset(&exp_index1,0,102*sizeof(int)); memset(&exp_index2,0,102*sizeof(int)); - memset(&tmp_categorize_array1,0,128*sizeof(int)); - memset(&tmp_categorize_array2,0,128*sizeof(int)); + memset(&tmp_categorize_array,0,128*2*sizeof(int)); bias=-32; @@ -461,12 +433,7 @@ static void categorize(COOKContext *q, int* quant_index_table, num_bits = 0; index = 0; for (j=q->total_subbands ; j>0 ; j--){ - exp_idx = (i - quant_index_table[index] + bias) / 2; - if (exp_idx<0){ - exp_idx=0; - } else if(exp_idx >7) { - exp_idx=7; - } + exp_idx = av_clip((i - quant_index_table[index] + bias) / 2, 0, 7); index++; num_bits+=expbits_tab[exp_idx]; } @@ -478,25 +445,20 @@ static void categorize(COOKContext *q, int* quant_index_table, /* Calculate total number of bits. */ num_bits=0; for (i=0 ; itotal_subbands ; i++) { - exp_idx = (bias - quant_index_table[i]) / 2; - if (exp_idx<0) { - exp_idx=0; - } else if(exp_idx >7) { - exp_idx=7; - } + 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; } - tmpbias = bias = num_bits; + tmpbias1 = tmpbias2 = num_bits; for (j = 1 ; j < q->numvector_size ; j++) { - if (tmpbias + bias > 2*bits_left) { /* ---> */ + if (tmpbias1 + tmpbias2 > 2*bits_left) { /* ---> */ int max = -999999; index=-1; for (i=0 ; itotal_subbands ; i++){ if (exp_index1[i] < 7) { - v = (-2*exp_index1[i]) - quant_index_table[i] - 32; + v = (-2*exp_index1[i]) - quant_index_table[i] + bias; if ( v >= max) { max = v; index = i; @@ -504,16 +466,16 @@ static void categorize(COOKContext *q, int* quant_index_table, } } if(index==-1)break; - tmp_categorize_array1[tmp_categorize_array1_idx++] = index; - tmpbias -= expbits_tab[exp_index1[index]] - - expbits_tab[exp_index1[index]+1]; + 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 ; itotal_subbands ; i++){ if(exp_index2[i] > 0){ - v = (-2*exp_index2[i])-quant_index_table[i]; + v = (-2*exp_index2[i])-quant_index_table[i]+bias; if ( v < min) { min = v; index = i; @@ -521,9 +483,9 @@ static void categorize(COOKContext *q, int* quant_index_table, } } if(index == -1)break; - tmp_categorize_array2[tmp_categorize_array2_idx++] = index; - tmpbias -= expbits_tab[exp_index2[index]] - - expbits_tab[exp_index2[index]-1]; + tmp_categorize_array[--tmp_categorize_array2_idx] = index; + tmpbias2 -= expbits_tab[exp_index2[index]] - + expbits_tab[exp_index2[index]-1]; --exp_index2[index]; } } @@ -531,17 +493,8 @@ static void categorize(COOKContext *q, int* quant_index_table, for(i=0 ; itotal_subbands ; i++) category[i] = exp_index2[i]; - /* Concatenate the two arrays. */ - for(i=tmp_categorize_array2_idx-1 ; i >= 0; i--) - category_index[category_index_size++] = tmp_categorize_array2[i]; - - for(i=0;inumvector_size;i++) - category_index[i]=0; + for(i=0 ; inumvector_size-1 ; i++) + category_index[i] = tmp_categorize_array[tmp_categorize_array2_idx++]; } @@ -554,7 +507,7 @@ static void categorize(COOKContext *q, int* quant_index_table, * @param category_index pointer to the category_index array */ -static void inline expand_category(COOKContext *q, int* category, +static inline void expand_category(COOKContext *q, int* category, int* category_index){ int i; for(i=0 ; inum_vectors ; i++){ @@ -567,57 +520,48 @@ static void inline expand_category(COOKContext *q, int* category, * * @param q pointer to the COOKContext * @param index index - * @param band current subband - * @param quant_value_table pointer to the array + * @param quant_index quantisation index * @param subband_coef_index array of indexes to quant_centroid_tab - * @param subband_coef_noise use random noise instead of predetermined value - * @param mlt_buffer pointer to the mlt buffer + * @param subband_coef_sign signs of coefficients + * @param mlt_p pointer into the mlt buffer */ - -static void scalar_dequant(COOKContext *q, int index, int band, - float* quant_value_table, int* subband_coef_index, - int* subband_coef_noise, float* mlt_buffer){ +static void scalar_dequant_float(COOKContext *q, int index, int quant_index, + int* subband_coef_index, int* subband_coef_sign, + float* mlt_p){ int i; float f1; for(i=0 ; irandom_state = q->random_state * 214013 + 2531011; //typical RNG numbers - f1 = randsign[(q->random_state/0x1000000)&1] * dither_tab[index]; //>>31 + /* noise coding if subband_coef_index[i] == 0 */ + f1 = dither_tab[index]; + if (av_random(&q->random_state) < 0x80000000) f1 = -f1; } - mlt_buffer[band*20+ i] = f1 * quant_value_table[band]; + mlt_p[i] = f1 * rootpow2tab[quant_index+63]; } } /** - * Unpack the subband_coef_index and subband_coef_noise vectors. + * Unpack the subband_coef_index and subband_coef_sign vectors. * * @param q pointer to the COOKContext * @param category pointer to the category array * @param subband_coef_index array of indexes to quant_centroid_tab - * @param subband_coef_noise use random noise instead of predetermined value + * @param subband_coef_sign signs of coefficients */ static int unpack_SQVH(COOKContext *q, int category, int* subband_coef_index, - int* subband_coef_noise) { + int* subband_coef_sign) { int i,j; int vlc, vd ,tmp, result; - int ub; - int cb; vd = vd_tab[category]; result = 0; for(i=0 ; igb); vlc = get_vlc2(&q->gb, q->sqvh[category].table, q->sqvh[category].bits, 3); - cb = get_bits_count(&q->gb); if (q->bits_per_subpacket < get_bits_count(&q->gb)){ vlc = 0; result = 1; @@ -630,13 +574,13 @@ static int unpack_SQVH(COOKContext *q, int category, int* subband_coef_index, for(j=0 ; jgb) < q->bits_per_subpacket){ - subband_coef_noise[i*vd+j] = get_bits1(&q->gb); + subband_coef_sign[i*vd+j] = get_bits1(&q->gb); } else { result=1; - subband_coef_noise[i*vd+j]=0; + subband_coef_sign[i*vd+j]=0; } } else { - subband_coef_noise[i*vd+j]=0; + subband_coef_sign[i*vd+j]=0; } } } @@ -649,41 +593,42 @@ static int unpack_SQVH(COOKContext *q, int category, int* subband_coef_index, * * @param q pointer to the COOKContext * @param category pointer to the category array - * @param quant_value_table pointer to the array + * @param quant_index_table pointer to the array * @param mlt_buffer pointer to mlt coefficients */ static void decode_vectors(COOKContext* q, int* category, - float* quant_value_table, float* mlt_buffer){ + int *quant_index_table, float* mlt_buffer){ /* A zero in this table means that the subband coefficient is random noise coded. */ - int subband_coef_noise[SUBBAND_SIZE]; + int subband_coef_index[SUBBAND_SIZE]; /* A zero in this table means that the subband coefficient is a positive multiplicator. */ - int subband_coef_index[SUBBAND_SIZE]; + int subband_coef_sign[SUBBAND_SIZE]; int band, j; int index=0; for(band=0 ; bandtotal_subbands ; band++){ index = category[band]; if(category[band] < 7){ - if(unpack_SQVH(q, category[band], subband_coef_index, subband_coef_noise)){ + if(unpack_SQVH(q, category[band], subband_coef_index, subband_coef_sign)){ index=7; for(j=0 ; jtotal_subbands ; j++) category[band+j]=7; } } if(index==7) { memset(subband_coef_index, 0, sizeof(subband_coef_index)); - memset(subband_coef_noise, 0, sizeof(subband_coef_noise)); + memset(subband_coef_sign, 0, sizeof(subband_coef_sign)); } - scalar_dequant(q, index, band, quant_value_table, subband_coef_index, - subband_coef_noise, mlt_buffer); + 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? */ } @@ -691,76 +636,23 @@ static void decode_vectors(COOKContext* q, int* category, * function for decoding mono 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 + * @param mlt_buffer pointer to mlt coefficients */ static void mono_decode(COOKContext *q, float* mlt_buffer) { int category_index[128]; - float quant_value_table[102]; int quant_index_table[102]; int category[128]; memset(&category, 0, 128*sizeof(int)); - memset(&quant_value_table, 0, 102*sizeof(int)); memset(&category_index, 0, 128*sizeof(int)); decode_envelope(q, quant_index_table); - q->num_vectors = get_bits(&q->gb,q->numvector_bits); - dequant_envelope(q, quant_index_table, quant_value_table); + q->num_vectors = get_bits(&q->gb,q->log2_numvector_size); categorize(q, quant_index_table, category, category_index); expand_category(q, category, category_index); - decode_vectors(q, category, quant_value_table, mlt_buffer); -} - - -/** - * The modulated lapped transform, this takes transform coefficients - * and transforms them into timedomain samples. This is done through - * an FFT-based algorithm with pre- and postrotation steps. - * A window and reorder step is also included. - * - * @param q pointer to the COOKContext - * @param inbuffer pointer to the mltcoefficients - * @param outbuffer pointer to the timedomain buffer - * @param mlt_tmp pointer to temporary storage space - */ - -static void cook_imlt(COOKContext *q, float* inbuffer, float* outbuffer, - float* mlt_tmp){ - int i; - - /* prerotation */ - for(i=0 ; imlt_size ; i+=2){ - outbuffer[i] = (q->mlt_presin[i/2] * inbuffer[q->mlt_size-1-i]) + - (q->mlt_precos[i/2] * inbuffer[i]); - outbuffer[i+1] = (q->mlt_precos[i/2] * inbuffer[q->mlt_size-1-i]) - - (q->mlt_presin[i/2] * inbuffer[i]); - } - - /* FFT */ - ff_fft_permute(&q->fft_ctx, (FFTComplex *) outbuffer); - ff_fft_calc (&q->fft_ctx, (FFTComplex *) outbuffer); - - /* postrotation */ - for(i=0 ; imlt_size ; i+=2){ - mlt_tmp[i] = (q->mlt_postcos[(q->mlt_size-1-i)/2] * outbuffer[i+1]) + - (q->mlt_postcos[i/2] * outbuffer[i]); - mlt_tmp[q->mlt_size-1-i] = (q->mlt_postcos[(q->mlt_size-1-i)/2] * outbuffer[i]) - - (q->mlt_postcos[i/2] * outbuffer[i+1]); - } - - /* window and reorder */ - for(i=0 ; imlt_size/2 ; i++){ - outbuffer[i] = mlt_tmp[q->mlt_size/2-1-i] * q->mlt_window[i]; - outbuffer[q->mlt_size-1-i]= mlt_tmp[q->mlt_size/2-1-i] * - q->mlt_window[q->mlt_size-1-i]; - outbuffer[q->mlt_size+i]= mlt_tmp[q->mlt_size/2+i] * - q->mlt_window[q->mlt_size-1-i]; - outbuffer[2*q->mlt_size-1-i]= -(mlt_tmp[q->mlt_size/2+i] * - q->mlt_window[i]); - } + decode_vectors(q, category, quant_index_table, mlt_buffer); } @@ -773,11 +665,11 @@ static void cook_imlt(COOKContext *q, float* inbuffer, float* outbuffer, * @param gain_index_next index for the next block multiplier */ -static void interpolate(COOKContext *q, float* buffer, +static void interpolate_float(COOKContext *q, float* buffer, int gain_index, int gain_index_next){ int i; float fc1, fc2; - fc1 = q->pow2tab[gain_index+63]; + fc1 = pow2tab[gain_index+63]; if(gain_index == gain_index_next){ //static gain for(i=0 ; igain_size_factor ; i++){ @@ -795,80 +687,65 @@ static void interpolate(COOKContext *q, float* buffer, } /** - * timedomain requantization of the timedomain samples + * Apply transform window, overlap buffers. * * @param q pointer to the COOKContext - * @param buffer pointer to the timedomain buffer - * @param gain_now current gain structure - * @param gain_previous previous gain structure + * @param inbuffer pointer to the mltcoefficients + * @param gains_ptr current and previous gains + * @param previous_buffer pointer to the previous buffer to be used for overlapping */ -static void gain_window(COOKContext *q, float* buffer, COOKgain* gain_now, - COOKgain* gain_previous){ - int i, index; - int gain_index[9]; - int tmp_gain_index; - - gain_index[8]=0; - index = gain_previous->size; - for (i=7 ; i>=0 ; i--) { - if(index && gain_previous->qidx_table1[index-1]==i) { - gain_index[i] = gain_previous->qidx_table2[index-1]; - index--; - } else { - gain_index[i]=gain_index[i+1]; - } - } - /* This is applied to the to be previous data buffer. */ - for(i=0;i<8;i++){ - interpolate(q, &buffer[q->samples_per_channel+q->gain_size_factor*i], - gain_index[i], gain_index[i+1]); - } - - tmp_gain_index = gain_index[0]; - index = gain_now->size; - for (i=7 ; i>=0 ; i--) { - if(index && gain_now->qidx_table1[index-1]==i) { - gain_index[i]= gain_now->qidx_table2[index-1]; - index--; - } else { - gain_index[i]=gain_index[i+1]; - } - } - - /* This is applied to the to be current block. */ - for(i=0;i<8;i++){ - interpolate(q, &buffer[i*q->gain_size_factor], - tmp_gain_index+gain_index[i], - tmp_gain_index+gain_index[i+1]); +static void imlt_window_float (COOKContext *q, float *buffer1, + cook_gains *gains_ptr, float *previous_buffer) +{ + 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]; } } - /** - * mlt overlapping and buffer management + * 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. * * @param q pointer to the COOKContext - * @param buffer pointer to the timedomain buffer - * @param gain_now current gain structure - * @param gain_previous previous gain structure + * @param inbuffer pointer to the mltcoefficients + * @param gains_ptr current and previous gains * @param previous_buffer pointer to the previous buffer to be used for overlapping - * */ -static void gain_compensate(COOKContext *q, float* buffer, COOKgain* gain_now, - COOKgain* gain_previous, float* previous_buffer) { +static void imlt_gain(COOKContext *q, float *inbuffer, + cook_gains *gains_ptr, float* previous_buffer) +{ + float *buffer0 = q->mono_mdct_output; + float *buffer1 = q->mono_mdct_output + q->samples_per_channel; int i; - if((gain_now->size || gain_previous->size)) { - gain_window(q, buffer, gain_now, gain_previous); - } - /* Overlap with the previous block. */ - for(i=0 ; isamples_per_channel ; i++) buffer[i]+=previous_buffer[i]; + /* Inverse modified discrete cosine transform */ + ff_imdct_calc(&q->mdct_ctx, q->mono_mdct_output, inbuffer); + + 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, buffer+q->samples_per_channel, - sizeof(float)*q->samples_per_channel); + memcpy(previous_buffer, buffer0, sizeof(float)*q->samples_per_channel); } @@ -902,6 +779,30 @@ static void decouple_info(COOKContext *q, int* decouple_tab){ return; } +/* + * 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, + int subband, + float f1, float f2, + float *decode_buffer, + float *mlt_buffer1, float *mlt_buffer2) +{ + int j, tmp_idx; + for (j=0 ; jjs_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]; + } +} /** * function for decoding joint stereo data @@ -915,10 +816,10 @@ static void joint_decode(COOKContext *q, float* mlt_buffer1, float* mlt_buffer2) { int i,j; int decouple_tab[SUBBAND_SIZE]; - float decode_buffer[2048]; //Only 1060 might be needed. - int idx, cpl_tmp,tmp_idx; + float *decode_buffer = q->decode_buffer_0; + int idx, cpl_tmp; float f1,f2; - float* cplscale; + const float* cplscale; memset(decouple_tab, 0, sizeof(decouple_tab)); memset(decode_buffer, 0, sizeof(decode_buffer)); @@ -940,23 +841,85 @@ static void joint_decode(COOKContext *q, float* mlt_buffer1, /* When we reach js_subband_start (the higher frequencies) the coefficients are stored in a coupling scheme. */ idx = (1 << q->js_vlc_bits) - 1; - if (q->js_subband_start < q->subbands) { - for (i=0 ; isubbands ; i++) { - cpl_tmp = cplband[i + q->js_subband_start]; - idx -=decouple_tab[cpl_tmp]; - cplscale = (float*)cplscales[q->js_vlc_bits-2]; //choose decoupler table - f1 = cplscale[decouple_tab[cpl_tmp]]; - f2 = cplscale[idx-1]; - for (j=0 ; jjs_subband_start + i)*20)+j; - mlt_buffer1[20*(i+q->js_subband_start) + j] = f1 * decode_buffer[tmp_idx]; - mlt_buffer2[20*(i+q->js_subband_start) + j] = f2 * decode_buffer[tmp_idx]; - } - idx = (1 << q->js_vlc_bits) - 1; - } + for (i=q->js_subband_start ; isubbands ; i++) { + cpl_tmp = cplband[i]; + idx -=decouple_tab[cpl_tmp]; + cplscale = q->cplscales[q->js_vlc_bits-2]; //choose decoupler table + f1 = cplscale[decouple_tab[cpl_tmp]]; + f2 = cplscale[idx-1]; + q->decouple (q, i, f1, f2, decode_buffer, mlt_buffer1, mlt_buffer2); + idx = (1 << q->js_vlc_bits) - 1; } } +/** + * 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 + * @param gain_ptr array of current/prev gain pointers + */ + +static inline void +decode_bytes_and_gain(COOKContext *q, const uint8_t *inbuffer, + cook_gains *gains_ptr) +{ + 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); +} + + /** + * 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; + float *output = q->mono_mdct_output + q->samples_per_channel; + /* Clip and convert floats to 16 bits. + */ + for (j = 0; j < q->samples_per_channel; j++) { + out[chan + q->nb_channels * j] = + av_clip_int16(lrintf(output[j])); + } +} + +/** + * 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 + * @param gain_ptr array of current/prev gain pointers + * @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, + cook_gains *gains, float *previous_buffer, + int16_t *out, int chan) +{ + imlt_gain(q, decode_buffer, gains, previous_buffer); + q->saturate_output (q, chan, out); +} + + /** * Cook subpacket decoding. This function returns one decoded subpacket, * usually 1024 samples per channel. @@ -965,153 +928,41 @@ static void joint_decode(COOKContext *q, float* mlt_buffer1, * @param inbuffer pointer to the inbuffer * @param sub_packet_size subpacket size * @param outbuffer pointer to the outbuffer - * @param pos the subpacket number in the frame */ -static int decode_subpacket(COOKContext *q, uint8_t *inbuffer, +static int decode_subpacket(COOKContext *q, const uint8_t *inbuffer, int sub_packet_size, int16_t *outbuffer) { - int i,j; - int value; - float* tmp_ptr; - /* packet dump */ // for (i=0 ; idecoded_bytes_buffer, sub_packet_size); - init_get_bits(&q->gb, q->decoded_bytes_buffer, sub_packet_size*8); - decode_gain_info(&q->gb, &q->gain_current); - memcpy(&q->gain_copy, &q->gain_current ,sizeof(COOKgain)); //This copy does not seem to be used. FIXME - - if(q->nb_channels==2 && q->joint_stereo==1){ - joint_decode(q, q->decode_buf_ptr[0], q->decode_buf_ptr[2]); - - /* Swap buffer pointers. */ - tmp_ptr = q->decode_buf_ptr[1]; - q->decode_buf_ptr[1] = q->decode_buf_ptr[0]; - q->decode_buf_ptr[0] = tmp_ptr; - tmp_ptr = q->decode_buf_ptr[3]; - q->decode_buf_ptr[3] = q->decode_buf_ptr[2]; - q->decode_buf_ptr[2] = tmp_ptr; - - /* FIXME: Rethink the gainbuffer handling, maybe a rename? - now/previous swap */ - q->gain_now_ptr = &q->gain_now; - q->gain_previous_ptr = &q->gain_previous; - for (i=0 ; inb_channels ; i++){ - - cook_imlt(q, q->decode_buf_ptr[i*2], q->mono_mdct_output, q->mlt_tmp); - gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr, - q->gain_previous_ptr, q->previous_buffer_ptr[0]); - - /* Swap out the previous buffer. */ - tmp_ptr = q->previous_buffer_ptr[0]; - q->previous_buffer_ptr[0] = q->previous_buffer_ptr[1]; - q->previous_buffer_ptr[1] = tmp_ptr; - - /* Clip and convert the floats to 16 bits. */ - for (j=0 ; jsamples_per_frame ; j++){ - value = lrintf(q->mono_mdct_output[j]); - if(value < -32768) value = -32768; - else if(value > 32767) value = 32767; - outbuffer[2*j+i] = value; - } - } + decode_bytes_and_gain(q, inbuffer, &q->gains1); - memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain)); - memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain)); - - } else if (q->nb_channels==2 && q->joint_stereo==0) { - /* channel 0 */ - mono_decode(q, q->decode_buf_ptr[0]); - - tmp_ptr = q->decode_buf_ptr[0]; - q->decode_buf_ptr[0] = q->decode_buf_ptr[1]; - q->decode_buf_ptr[1] = q->decode_buf_ptr[2]; - q->decode_buf_ptr[2] = q->decode_buf_ptr[3]; - q->decode_buf_ptr[3] = tmp_ptr; - - q->gain_now_ptr = &q->gain_now; - q->gain_previous_ptr = &q->gain_previous; - - cook_imlt(q, q->decode_buf_ptr[0], q->mono_mdct_output,q->mlt_tmp); - gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr, - q->gain_previous_ptr, q->previous_buffer_ptr[0]); - /* Swap out the previous buffer. */ - tmp_ptr = q->previous_buffer_ptr[0]; - q->previous_buffer_ptr[0] = q->previous_buffer_ptr[1]; - q->previous_buffer_ptr[1] = tmp_ptr; - - for (j=0 ; jsamples_per_frame ; j++){ - value = lrintf(q->mono_mdct_output[j]); - if(value < -32768) value = -32768; - else if(value > 32767) value = 32767; - outbuffer[2*j+1] = value; - } - - /* channel 1 */ - //av_log(NULL,AV_LOG_ERROR,"bits = %d\n",get_bits_count(&q->gb)); - init_get_bits(&q->gb, q->decoded_bytes_buffer, sub_packet_size*8+q->bits_per_subpacket); - decode_gain_info(&q->gb, &q->gain_current); - //memcpy(&q->gain_copy, &q->gain_current ,sizeof(COOKgain)); - mono_decode(q, q->decode_buf_ptr[0]); - tmp_ptr = q->decode_buf_ptr[0]; - q->decode_buf_ptr[1] = q->decode_buf_ptr[2]; - q->decode_buf_ptr[2] = q->decode_buf_ptr[3]; - q->decode_buf_ptr[3] = tmp_ptr; - - q->gain_now_ptr = &q->gain_now; - q->gain_previous_ptr = &q->gain_previous; - - cook_imlt(q, q->decode_buf_ptr[0], q->mono_mdct_output,q->mlt_tmp); - gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr, q->gain_previous_ptr, q->previous_buffer_ptr[0]); - - /* Swap out the previous buffer. */ - tmp_ptr = q->previous_buffer_ptr[0]; - q->previous_buffer_ptr[0] = q->previous_buffer_ptr[1]; - q->previous_buffer_ptr[1] = tmp_ptr; - - for (j=0 ; jsamples_per_frame ; j++){ - value = lrintf(q->mono_mdct_output[j]); - if(value < -32768) value = -32768; - else if(value > 32767) value = 32767; - outbuffer[2*j] = value; - } + 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); + } + } - /* Swap out the previous buffer. */ - memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain)); - memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain)); + mlt_compensate_output(q, q->decode_buffer_1, &q->gains1, + q->mono_previous_buffer1, outbuffer, 0); - } else { - mono_decode(q, q->decode_buf_ptr[0]); - - /* Swap buffer pointers. */ - tmp_ptr = q->decode_buf_ptr[1]; - q->decode_buf_ptr[1] = q->decode_buf_ptr[0]; - q->decode_buf_ptr[0] = tmp_ptr; - - /* FIXME: Rethink the gainbuffer handling, maybe a rename? - now/previous swap */ - q->gain_now_ptr = &q->gain_now; - q->gain_previous_ptr = &q->gain_previous; - - cook_imlt(q, q->decode_buf_ptr[0], q->mono_mdct_output,q->mlt_tmp); - gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr, - q->gain_previous_ptr, q->mono_previous_buffer1); - - /* Clip and convert the floats to 16 bits */ - for (j=0 ; jsamples_per_frame ; j++){ - value = lrintf(q->mono_mdct_output[j]); - if(value < -32768) value = -32768; - else if(value > 32767) value = 32767; - outbuffer[j] = value; + 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); } - memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain)); - memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain)); } return q->samples_per_frame * sizeof(int16_t); } @@ -1125,7 +976,7 @@ static int decode_subpacket(COOKContext *q, uint8_t *inbuffer, static int cook_decode_frame(AVCodecContext *avctx, void *data, int *data_size, - uint8_t *buf, int buf_size) { + const uint8_t *buf, int buf_size) { COOKContext *q = avctx->priv_data; if (buf_size < avctx->block_align) @@ -1133,18 +984,22 @@ static int cook_decode_frame(AVCodecContext *avctx, *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; } + #ifdef COOKDEBUG -static void dump_cook_context(COOKContext *q, COOKextradata *e) +static void dump_cook_context(COOKContext *q) { //int i=0; #define PRINT(a,b) av_log(NULL,AV_LOG_ERROR," %s = %d\n", a, b); av_log(NULL,AV_LOG_ERROR,"COOKextradata\n"); - av_log(NULL,AV_LOG_ERROR,"cookversion=%x\n",e->cookversion); - if (e->cookversion > MONO_COOK2) { - PRINT("js_subband_start",e->js_subband_start); - PRINT("js_vlc_bits",e->js_vlc_bits); + av_log(NULL,AV_LOG_ERROR,"cookversion=%x\n",q->cookversion); + if (q->cookversion > STEREO) { + PRINT("js_subband_start",q->js_subband_start); + PRINT("js_vlc_bits",q->js_vlc_bits); } av_log(NULL,AV_LOG_ERROR,"COOKContext\n"); PRINT("nb_channels",q->nb_channels); @@ -1154,15 +1009,13 @@ static void dump_cook_context(COOKContext *q, COOKextradata *e) PRINT("samples_per_frame",q->samples_per_frame); PRINT("subbands",q->subbands); PRINT("random_state",q->random_state); - PRINT("mlt_size",q->mlt_size); PRINT("js_subband_start",q->js_subband_start); - PRINT("numvector_bits",q->numvector_bits); + PRINT("log2_numvector_size",q->log2_numvector_size); PRINT("numvector_size",q->numvector_size); PRINT("total_subbands",q->total_subbands); - PRINT("frame_reorder_counter",q->frame_reorder_counter); - PRINT("frame_reorder_index_size",q->frame_reorder_index_size); } #endif + /** * Cook initialization * @@ -1171,25 +1024,26 @@ static void dump_cook_context(COOKContext *q, COOKextradata *e) static int cook_decode_init(AVCodecContext *avctx) { - COOKextradata *e = avctx->extradata; 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(NULL,AV_LOG_ERROR,"Necessary extradata missing!\n"); + 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(NULL,AV_LOG_DEBUG,"codecdata_length=%d\n",avctx->extradata_size); + av_log(avctx,AV_LOG_DEBUG,"codecdata_length=%d\n",avctx->extradata_size); if (avctx->extradata_size >= 8){ - e->cookversion = be2me_32(e->cookversion); - e->samples_per_frame = be2me_16(e->samples_per_frame); - e->subbands = be2me_16(e->subbands); + 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){ - e->js_subband_start = be2me_16(e->js_subband_start); - e->js_vlc_bits = be2me_16(e->js_vlc_bits); + 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); } } @@ -1198,103 +1052,136 @@ static int cook_decode_init(AVCodecContext *avctx) q->nb_channels = avctx->channels; q->bit_rate = avctx->bit_rate; - /* Initialize state. */ - q->random_state = 1; + /* Initialize RNG. */ + av_random_init(&q->random_state, 1); /* Initialize extradata related variables. */ - q->samples_per_channel = e->samples_per_frame / q->nb_channels; - q->samples_per_frame = e->samples_per_frame; - q->subbands = e->subbands; + q->samples_per_channel = q->samples_per_frame / q->nb_channels; q->bits_per_subpacket = avctx->block_align * 8; /* Initialize default data states. */ - q->js_subband_start = 0; - q->numvector_bits = 5; + q->log2_numvector_size = 5; q->total_subbands = q->subbands; /* Initialize version-dependent variables */ - av_log(NULL,AV_LOG_DEBUG,"e->cookversion=%x\n",e->cookversion); - switch (e->cookversion) { - case MONO_COOK1: + 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(NULL,AV_LOG_ERROR,"Container channels != 1, report sample!\n"); + av_log(avctx,AV_LOG_ERROR,"Container channels != 1, report sample!\n"); return -1; } - av_log(NULL,AV_LOG_DEBUG,"MONO_COOK1\n"); + av_log(avctx,AV_LOG_DEBUG,"MONO\n"); break; - case MONO_COOK2: + case STEREO: if (q->nb_channels != 1) { - q->joint_stereo = 0; - av_log(NULL,AV_LOG_ERROR,"Non-joint-stereo files are decoded with wrong gain at the moment!\n"); q->bits_per_subpacket = q->bits_per_subpacket/2; - } - av_log(NULL,AV_LOG_DEBUG,"MONO_COOK2\n"); + av_log(avctx,AV_LOG_DEBUG,"STEREO\n"); break; case JOINT_STEREO: if (q->nb_channels != 2) { - av_log(NULL,AV_LOG_ERROR,"Container channels != 2, report sample!\n"); + av_log(avctx,AV_LOG_ERROR,"Container channels != 2, report sample!\n"); return -1; } - av_log(NULL,AV_LOG_DEBUG,"JOINT_STEREO\n"); + av_log(avctx,AV_LOG_DEBUG,"JOINT_STEREO\n"); if (avctx->extradata_size >= 16){ - q->total_subbands = q->subbands + e->js_subband_start; - q->js_subband_start = e->js_subband_start; + q->total_subbands = q->subbands + q->js_subband_start; q->joint_stereo = 1; - q->js_vlc_bits = e->js_vlc_bits; } if (q->samples_per_channel > 256) { - q->numvector_bits++; // q->numvector_bits = 6 + q->log2_numvector_size = 6; } if (q->samples_per_channel > 512) { - q->numvector_bits++; // q->numvector_bits = 7 + q->log2_numvector_size = 7; } break; case MC_COOK: - av_log(NULL,AV_LOG_ERROR,"MC_COOK not supported!\n"); + av_log(avctx,AV_LOG_ERROR,"MC_COOK not supported!\n"); return -1; break; default: - av_log(NULL,AV_LOG_ERROR,"Unknown Cook version, report sample!\n"); + av_log(avctx,AV_LOG_ERROR,"Unknown Cook version, report sample!\n"); return -1; break; } /* Initialize variable relations */ - q->mlt_size = q->samples_per_channel; - q->numvector_size = (1 << q->numvector_bits); + q->numvector_size = (1 << q->log2_numvector_size); /* Generate tables */ - init_rootpow2table(q); - init_pow2table(q); + init_pow2table(); init_gain_table(q); + init_cplscales_table(q); if (init_cook_vlc_tables(q) != 0) return -1; - /* Pad the databuffer with FF_INPUT_BUFFER_PADDING_SIZE, - this is for the bitstreamreader. */ - if ((q->decoded_bytes_buffer = av_mallocz((avctx->block_align+(4-avctx->block_align%4) + FF_INPUT_BUFFER_PADDING_SIZE)*sizeof(uint8_t))) == NULL) - return -1; - q->decode_buf_ptr[0] = q->decode_buffer_1; - q->decode_buf_ptr[1] = q->decode_buffer_2; - q->decode_buf_ptr[2] = q->decode_buffer_3; - q->decode_buf_ptr[3] = q->decode_buffer_4; + if(avctx->block_align >= UINT_MAX/2) + return -1; - q->previous_buffer_ptr[0] = q->mono_previous_buffer1; - q->previous_buffer_ptr[1] = q->mono_previous_buffer2; + /* 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; - memset(q->decode_buffer_1,0,1024*sizeof(float)); - memset(q->decode_buffer_2,0,1024*sizeof(float)); - memset(q->decode_buffer_3,0,1024*sizeof(float)); - memset(q->decode_buffer_4,0,1024*sizeof(float)); + 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 ) + if ( init_cook_mlt(q) != 0 ) return -1; - //dump_cook_context(q,e); + /* 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; + } + + avctx->sample_fmt = SAMPLE_FMT_S16; + avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO; + +#ifdef COOKDEBUG + dump_cook_context(q); +#endif return 0; } @@ -1308,4 +1195,5 @@ AVCodec cook_decoder = .init = cook_decode_init, .close = cook_decode_close, .decode = cook_decode_frame, + .long_name = NULL_IF_CONFIG_SMALL("COOK"), };