diff options
Diffstat (limited to 'contrib/ffmpeg/libavcodec/cook.c')
| -rw-r--r-- | contrib/ffmpeg/libavcodec/cook.c | 713 |
1 files changed, 274 insertions, 439 deletions
diff --git a/contrib/ffmpeg/libavcodec/cook.c b/contrib/ffmpeg/libavcodec/cook.c index 47d9ce2c3..32b1081cc 100644 --- a/contrib/ffmpeg/libavcodec/cook.c +++ b/contrib/ffmpeg/libavcodec/cook.c @@ -50,12 +50,15 @@ #include "avcodec.h" #include "bitstream.h" #include "dsputil.h" +#include "common.h" +#include "bytestream.h" +#include "random.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 @@ -63,23 +66,9 @@ //#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 { GetBitContext gb; @@ -97,28 +86,22 @@ typedef struct { 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; + DECLARE_ALIGNED_16(FFTSample, mdct_tmp[1024]); /* temporary storage for imlt */ 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_current; - COOKgain gain_now; - COOKgain gain_previous; - COOKgain gain_channel1[2]; - COOKgain gain_channel2[2]; + 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; @@ -135,16 +118,11 @@ typedef struct { /* data buffers */ 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_buf_ptr2[2]; float decode_buffer_1[1024]; float decode_buffer_2[1024]; - float decode_buffer_3[1024]; - float decode_buffer_4[1024]; } COOKContext; /* debug functions */ @@ -242,34 +220,25 @@ 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 ; j<q->mlt_size ; j++) { - q->mlt_window[j] = sin((j + 512.0/(float)q->mlt_size) * alpha); - } - - /* pre/post twiddle factors */ - for (j=0 ; j<q->mlt_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 + alpha = M_PI / (2.0 * (float)mlt_size); + for(j=0 ; j<mlt_size ; j++) + q->mlt_window[j] = sin((j + 0.5) * alpha) * 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); - /* 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); - - return (int)(q->mlt_window && q->mlt_precos && q->mlt_presin && q->mlt_postcos); + return 0; } /*************** init functions end ***********/ @@ -277,16 +246,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/missalignment. + * 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(uint8_t* inbuffer, uint8_t* out, int bytes){ + int i, off; + uint32_t c; + 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 @@ -294,14 +277,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 = (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 ; i<bytes/4 ; i++){ -#ifdef WORDS_BIGENDIAN - obuf[i] = 0x37c511f2^buf[i]; -#else - obuf[i] = 0xf211c537^buf[i]; -#endif - } + return off; } /** @@ -312,17 +295,14 @@ static int cook_decode_close(AVCodecContext *avctx) { int i; COOKContext *q = avctx->priv_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->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++) { @@ -341,29 +321,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 indices */ -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 ; i<gaininfo->size ; 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; } /** @@ -397,22 +375,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. * * @param q pointer to the COOKContext @@ -559,46 +521,41 @@ 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(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 ; i<SUBBAND_SIZE ; i++) { if (subband_coef_index[i]) { - if (subband_coef_noise[i]) { - f1 = -quant_centroid_tab[index][subband_coef_index[i]]; - } else { - f1 = quant_centroid_tab[index][subband_coef_index[i]]; - } + f1 = quant_centroid_tab[index][subband_coef_index[i]]; + if (subband_coef_sign[i]) f1 = -f1; } else { - /* noise coding if subband_coef_noise[i] == 0 */ - q->random_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 * q->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; @@ -622,13 +579,13 @@ static int unpack_SQVH(COOKContext *q, int category, int* subband_coef_index, for(j=0 ; j<vd ; j++){ if (subband_coef_index[i*vd + j]) { if(get_bits_count(&q->gb) < 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; } } } @@ -641,41 +598,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 ; band<q->total_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 ; j<q->total_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); + scalar_dequant(q, index, quant_index_table[band], + subband_coef_index, subband_coef_sign, + &mlt_buffer[band * 20]); } if(q->total_subbands*SUBBAND_SIZE >= q->samples_per_channel){ return; - } + } /* FIXME: should this be removed, or moved into loop above? */ } @@ -690,69 +648,17 @@ static void decode_vectors(COOKContext* q, int* category, 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->log2_numvector_size); - dequant_envelope(q, quant_index_table, quant_value_table); 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 ; i<q->mlt_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 ; i<q->mlt_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 ; i<q->mlt_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); } @@ -786,81 +692,52 @@ static void interpolate(COOKContext *q, float* buffer, } } -/** - * timedomain requantization of the timedomain samples - * - * @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 - */ - -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]); - } -} - /** - * 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) +{ + const float fc = q->pow2tab[gains_ptr->previous[0] + 63]; + 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); + + /* Inverse modified discrete cosine transform */ + q->mdct_ctx.fft.imdct_calc(&q->mdct_ctx, q->mono_mdct_output, + inbuffer, q->mdct_tmp); + + /* 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]; } - /* Overlap with the previous block. */ - for(i=0 ; i<q->samples_per_channel ; i++) buffer[i]+=previous_buffer[i]; + /* Apply gain profile */ + for (i = 0; i < 8; i++) { + if (gains_ptr->now[i] || gains_ptr->now[i + 1]) + 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); } @@ -948,6 +825,63 @@ static void joint_decode(COOKContext *q, float* mlt_buffer1, } /** + * 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, 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); +} + +/** + * 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) +{ + float *output = q->mono_mdct_output + q->samples_per_channel; + int j; + + imlt_gain(q, decode_buffer, gains, previous_buffer); + + /* Clip and convert floats to 16 bits. + */ + for (j = 0; j < q->samples_per_channel; j++) { + out[chan + q->nb_channels * j] = + av_clip(lrintf(output[j]), -32768, 32767); + } +} + + +/** * Cook subpacket decoding. This function returns one decoded subpacket, * usually 1024 samples per channel. * @@ -960,142 +894,36 @@ static void joint_decode(COOKContext *q, float* mlt_buffer1, static int decode_subpacket(COOKContext *q, uint8_t *inbuffer, int sub_packet_size, int16_t *outbuffer) { - int i,j; - int value; - float* tmp_ptr; - /* 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(inbuffer, q->decoded_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); - - 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 ; i<q->nb_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 ; j<q->samples_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; - } - } - - 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_ptr2[0]); - - tmp_ptr = q->decode_buf_ptr2[0]; - q->decode_buf_ptr2[0] = q->decode_buf_ptr2[1]; - q->decode_buf_ptr2[1] = tmp_ptr; - - memcpy(&q->gain_channel1[0], &q->gain_current ,sizeof(COOKgain)); - q->gain_now_ptr = &q->gain_channel1[0]; - q->gain_previous_ptr = &q->gain_channel1[1]; - - cook_imlt(q, q->decode_buf_ptr2[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); - - memcpy(&q->gain_channel1[1], &q->gain_channel1[0],sizeof(COOKgain)); - - - for (j=0 ; j<q->samples_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); - - q->gain_now_ptr = &q->gain_channel2[0]; - q->gain_previous_ptr = &q->gain_channel2[1]; + decode_bytes_and_gain(q, inbuffer, &q->gains1); - decode_gain_info(&q->gb, &q->gain_channel2[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] = tmp_ptr; - - 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_buffer2); - - /* 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; + if (q->joint_stereo) { + joint_decode(q, q->decode_buffer_1, q->decode_buffer_2); + } else { + mono_decode(q, q->decode_buffer_1); - memcpy(&q->gain_channel2[1], &q->gain_channel2[0] ,sizeof(COOKgain)); + if (q->nb_channels == 2) { + decode_bytes_and_gain(q, inbuffer + sub_packet_size/2, &q->gains2); + mono_decode(q, q->decode_buffer_2); + } + } - for (j=0 ; j<q->samples_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; - } + 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 ; j<q->samples_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); } @@ -1117,19 +945,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); @@ -1139,7 +970,6 @@ 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("log2_numvector_size",q->log2_numvector_size); PRINT("numvector_size",q->numvector_size); @@ -1155,25 +985,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; + 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); } } @@ -1182,48 +1013,43 @@ 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_init_random(1, &q->random_state); /* 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->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; 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->log2_numvector_size = 6; @@ -1233,17 +1059,16 @@ static int cook_decode_init(AVCodecContext *avctx) } 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->log2_numvector_size); /* Generate tables */ @@ -1258,43 +1083,53 @@ static int cook_decode_init(AVCodecContext *avctx) if(avctx->block_align >= UINT_MAX/2) 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) + /* 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->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; - - q->decode_buf_ptr2[0] = q->decode_buffer_3; - q->decode_buf_ptr2[1] = q->decode_buffer_4; - - q->previous_buffer_ptr[0] = q->mono_previous_buffer1; - q->previous_buffer_ptr[1] = q->mono_previous_buffer2; + 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; /* Try to catch some obviously faulty streams, othervise it might be exploitable */ if (q->total_subbands > 53) { - av_log(NULL,AV_LOG_ERROR,"total_subbands > 53, report sample!\n"); + av_log(avctx,AV_LOG_ERROR,"total_subbands > 53, report sample!\n"); return -1; } if (q->subbands > 50) { - av_log(NULL,AV_LOG_ERROR,"subbands > 50, report sample!\n"); + 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(NULL,AV_LOG_ERROR,"unknown amount of samples_per_channel = %d, report sample!\n",q->samples_per_channel); + 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,e); + dump_cook_context(q); #endif return 0; } |