00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00045 #include <math.h>
00046 #include <stddef.h>
00047 #include <stdio.h>
00048
00049 #include "libavutil/lfg.h"
00050 #include "libavutil/random_seed.h"
00051 #include "avcodec.h"
00052 #include "get_bits.h"
00053 #include "dsputil.h"
00054 #include "bytestream.h"
00055 #include "fft.h"
00056 #include "libavutil/audioconvert.h"
00057
00058 #include "cookdata.h"
00059
00060
00061 #define MONO 0x1000001
00062 #define STEREO 0x1000002
00063 #define JOINT_STEREO 0x1000003
00064 #define MC_COOK 0x2000000 //multichannel Cook, not supported
00065
00066 #define SUBBAND_SIZE 20
00067 #define MAX_SUBPACKETS 5
00068
00069
00070 typedef struct {
00071 int *now;
00072 int *previous;
00073 } cook_gains;
00074
00075 typedef struct {
00076 int ch_idx;
00077 int size;
00078 int num_channels;
00079 int cookversion;
00080 int samples_per_frame;
00081 int subbands;
00082 int js_subband_start;
00083 int js_vlc_bits;
00084 int samples_per_channel;
00085 int log2_numvector_size;
00086 unsigned int channel_mask;
00087 VLC ccpl;
00088 int joint_stereo;
00089 int bits_per_subpacket;
00090 int bits_per_subpdiv;
00091 int total_subbands;
00092 int numvector_size;
00093
00094 float mono_previous_buffer1[1024];
00095 float mono_previous_buffer2[1024];
00097 cook_gains gains1;
00098 cook_gains gains2;
00099 int gain_1[9];
00100 int gain_2[9];
00101 int gain_3[9];
00102 int gain_4[9];
00103 } COOKSubpacket;
00104
00105 typedef struct cook {
00106
00107
00108
00109
00110 void (* scalar_dequant)(struct cook *q, int index, int quant_index,
00111 int* subband_coef_index, int* subband_coef_sign,
00112 float* mlt_p);
00113
00114 void (* decouple) (struct cook *q,
00115 COOKSubpacket *p,
00116 int subband,
00117 float f1, float f2,
00118 float *decode_buffer,
00119 float *mlt_buffer1, float *mlt_buffer2);
00120
00121 void (* imlt_window) (struct cook *q, float *buffer1,
00122 cook_gains *gains_ptr, float *previous_buffer);
00123
00124 void (* interpolate) (struct cook *q, float* buffer,
00125 int gain_index, int gain_index_next);
00126
00127 void (* saturate_output) (struct cook *q, int chan, int16_t *out);
00128
00129 AVCodecContext* avctx;
00130 GetBitContext gb;
00131
00132 int nb_channels;
00133 int bit_rate;
00134 int sample_rate;
00135 int num_vectors;
00136 int samples_per_channel;
00137
00138 AVLFG random_state;
00139
00140
00141 FFTContext mdct_ctx;
00142 float* mlt_window;
00143
00144
00145 VLC envelope_quant_index[13];
00146 VLC sqvh[7];
00147
00148
00149 int gain_size_factor;
00150 float gain_table[23];
00151
00152
00153
00154 uint8_t* decoded_bytes_buffer;
00155 DECLARE_ALIGNED(16, float,mono_mdct_output)[2048];
00156 float decode_buffer_1[1024];
00157 float decode_buffer_2[1024];
00158 float decode_buffer_0[1060];
00159
00160 const float *cplscales[5];
00161 int num_subpackets;
00162 COOKSubpacket subpacket[MAX_SUBPACKETS];
00163 } COOKContext;
00164
00165 static float pow2tab[127];
00166 static float rootpow2tab[127];
00167
00168
00169
00170 #ifdef COOKDEBUG
00171 static void dump_float_table(float* table, int size, int delimiter) {
00172 int i=0;
00173 av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
00174 for (i=0 ; i<size ; i++) {
00175 av_log(NULL, AV_LOG_ERROR, "%5.1f, ", table[i]);
00176 if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
00177 }
00178 }
00179
00180 static void dump_int_table(int* table, int size, int delimiter) {
00181 int i=0;
00182 av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
00183 for (i=0 ; i<size ; i++) {
00184 av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);
00185 if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
00186 }
00187 }
00188
00189 static void dump_short_table(short* table, int size, int delimiter) {
00190 int i=0;
00191 av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
00192 for (i=0 ; i<size ; i++) {
00193 av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);
00194 if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
00195 }
00196 }
00197
00198 #endif
00199
00200
00201
00202
00203 static av_cold void init_pow2table(void){
00204 int i;
00205 for (i=-63 ; i<64 ; i++){
00206 pow2tab[63+i]= pow(2, i);
00207 rootpow2tab[63+i]=sqrt(pow(2, i));
00208 }
00209 }
00210
00211
00212 static av_cold void init_gain_table(COOKContext *q) {
00213 int i;
00214 q->gain_size_factor = q->samples_per_channel/8;
00215 for (i=0 ; i<23 ; i++) {
00216 q->gain_table[i] = pow(pow2tab[i+52] ,
00217 (1.0/(double)q->gain_size_factor));
00218 }
00219 }
00220
00221
00222 static av_cold int init_cook_vlc_tables(COOKContext *q) {
00223 int i, result;
00224
00225 result = 0;
00226 for (i=0 ; i<13 ; i++) {
00227 result |= init_vlc (&q->envelope_quant_index[i], 9, 24,
00228 envelope_quant_index_huffbits[i], 1, 1,
00229 envelope_quant_index_huffcodes[i], 2, 2, 0);
00230 }
00231 av_log(q->avctx,AV_LOG_DEBUG,"sqvh VLC init\n");
00232 for (i=0 ; i<7 ; i++) {
00233 result |= init_vlc (&q->sqvh[i], vhvlcsize_tab[i], vhsize_tab[i],
00234 cvh_huffbits[i], 1, 1,
00235 cvh_huffcodes[i], 2, 2, 0);
00236 }
00237
00238 for(i=0;i<q->num_subpackets;i++){
00239 if (q->subpacket[i].joint_stereo==1){
00240 result |= init_vlc (&q->subpacket[i].ccpl, 6, (1<<q->subpacket[i].js_vlc_bits)-1,
00241 ccpl_huffbits[q->subpacket[i].js_vlc_bits-2], 1, 1,
00242 ccpl_huffcodes[q->subpacket[i].js_vlc_bits-2], 2, 2, 0);
00243 av_log(q->avctx,AV_LOG_DEBUG,"subpacket %i Joint-stereo VLC used.\n",i);
00244 }
00245 }
00246
00247 av_log(q->avctx,AV_LOG_DEBUG,"VLC tables initialized.\n");
00248 return result;
00249 }
00250
00251 static av_cold int init_cook_mlt(COOKContext *q) {
00252 int j;
00253 int mlt_size = q->samples_per_channel;
00254
00255 if ((q->mlt_window = av_malloc(sizeof(float)*mlt_size)) == 0)
00256 return -1;
00257
00258
00259 ff_sine_window_init(q->mlt_window, mlt_size);
00260 for(j=0 ; j<mlt_size ; j++)
00261 q->mlt_window[j] *= sqrt(2.0 / q->samples_per_channel);
00262
00263
00264 if (ff_mdct_init(&q->mdct_ctx, av_log2(mlt_size)+1, 1, 1.0)) {
00265 av_free(q->mlt_window);
00266 return -1;
00267 }
00268 av_log(q->avctx,AV_LOG_DEBUG,"MDCT initialized, order = %d.\n",
00269 av_log2(mlt_size)+1);
00270
00271 return 0;
00272 }
00273
00274 static const float *maybe_reformat_buffer32 (COOKContext *q, const float *ptr, int n)
00275 {
00276 if (1)
00277 return ptr;
00278 }
00279
00280 static av_cold void init_cplscales_table (COOKContext *q) {
00281 int i;
00282 for (i=0;i<5;i++)
00283 q->cplscales[i] = maybe_reformat_buffer32 (q, cplscales[i], (1<<(i+2))-1);
00284 }
00285
00286
00287
00288 #define DECODE_BYTES_PAD1(bytes) (3 - ((bytes)+3) % 4)
00289 #define DECODE_BYTES_PAD2(bytes) ((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes)))
00290
00312 static inline int decode_bytes(const uint8_t* inbuffer, uint8_t* out, int bytes){
00313 int i, off;
00314 uint32_t c;
00315 const uint32_t* buf;
00316 uint32_t* obuf = (uint32_t*) out;
00317
00318
00319
00320
00321
00322
00323 off = (intptr_t)inbuffer & 3;
00324 buf = (const uint32_t*) (inbuffer - off);
00325 c = av_be2ne32((0x37c511f2 >> (off*8)) | (0x37c511f2 << (32-(off*8))));
00326 bytes += 3 + off;
00327 for (i = 0; i < bytes/4; i++)
00328 obuf[i] = c ^ buf[i];
00329
00330 return off;
00331 }
00332
00337 static av_cold int cook_decode_close(AVCodecContext *avctx)
00338 {
00339 int i;
00340 COOKContext *q = avctx->priv_data;
00341 av_log(avctx,AV_LOG_DEBUG, "Deallocating memory.\n");
00342
00343
00344 av_free(q->mlt_window);
00345 av_free(q->decoded_bytes_buffer);
00346
00347
00348 ff_mdct_end(&q->mdct_ctx);
00349
00350
00351 for (i=0 ; i<13 ; i++) {
00352 free_vlc(&q->envelope_quant_index[i]);
00353 }
00354 for (i=0 ; i<7 ; i++) {
00355 free_vlc(&q->sqvh[i]);
00356 }
00357 for (i=0 ; i<q->num_subpackets ; i++) {
00358 free_vlc(&q->subpacket[i].ccpl);
00359 }
00360
00361 av_log(avctx,AV_LOG_DEBUG,"Memory deallocated.\n");
00362
00363 return 0;
00364 }
00365
00373 static void decode_gain_info(GetBitContext *gb, int *gaininfo)
00374 {
00375 int i, n;
00376
00377 while (get_bits1(gb)) {}
00378 n = get_bits_count(gb) - 1;
00379
00380 i = 0;
00381 while (n--) {
00382 int index = get_bits(gb, 3);
00383 int gain = get_bits1(gb) ? get_bits(gb, 4) - 7 : -1;
00384
00385 while (i <= index) gaininfo[i++] = gain;
00386 }
00387 while (i <= 8) gaininfo[i++] = 0;
00388 }
00389
00397 static void decode_envelope(COOKContext *q, COOKSubpacket *p, int* quant_index_table) {
00398 int i,j, vlc_index;
00399
00400 quant_index_table[0]= get_bits(&q->gb,6) - 6;
00401
00402 for (i=1 ; i < p->total_subbands ; i++){
00403 vlc_index=i;
00404 if (i >= p->js_subband_start * 2) {
00405 vlc_index-=p->js_subband_start;
00406 } else {
00407 vlc_index/=2;
00408 if(vlc_index < 1) vlc_index = 1;
00409 }
00410 if (vlc_index>13) vlc_index = 13;
00411
00412 j = get_vlc2(&q->gb, q->envelope_quant_index[vlc_index-1].table,
00413 q->envelope_quant_index[vlc_index-1].bits,2);
00414 quant_index_table[i] = quant_index_table[i-1] + j - 12;
00415 }
00416 }
00417
00427 static void categorize(COOKContext *q, COOKSubpacket *p, int* quant_index_table,
00428 int* category, int* category_index){
00429 int exp_idx, bias, tmpbias1, tmpbias2, bits_left, num_bits, index, v, i, j;
00430 int exp_index2[102];
00431 int exp_index1[102];
00432
00433 int tmp_categorize_array[128*2];
00434 int tmp_categorize_array1_idx=p->numvector_size;
00435 int tmp_categorize_array2_idx=p->numvector_size;
00436
00437 bits_left = p->bits_per_subpacket - get_bits_count(&q->gb);
00438
00439 if(bits_left > q->samples_per_channel) {
00440 bits_left = q->samples_per_channel +
00441 ((bits_left - q->samples_per_channel)*5)/8;
00442
00443 }
00444
00445 memset(&exp_index1,0,102*sizeof(int));
00446 memset(&exp_index2,0,102*sizeof(int));
00447 memset(&tmp_categorize_array,0,128*2*sizeof(int));
00448
00449 bias=-32;
00450
00451
00452 for (i=32 ; i>0 ; i=i/2){
00453 num_bits = 0;
00454 index = 0;
00455 for (j=p->total_subbands ; j>0 ; j--){
00456 exp_idx = av_clip((i - quant_index_table[index] + bias) / 2, 0, 7);
00457 index++;
00458 num_bits+=expbits_tab[exp_idx];
00459 }
00460 if(num_bits >= bits_left - 32){
00461 bias+=i;
00462 }
00463 }
00464
00465
00466 num_bits=0;
00467 for (i=0 ; i<p->total_subbands ; i++) {
00468 exp_idx = av_clip((bias - quant_index_table[i]) / 2, 0, 7);
00469 num_bits += expbits_tab[exp_idx];
00470 exp_index1[i] = exp_idx;
00471 exp_index2[i] = exp_idx;
00472 }
00473 tmpbias1 = tmpbias2 = num_bits;
00474
00475 for (j = 1 ; j < p->numvector_size ; j++) {
00476 if (tmpbias1 + tmpbias2 > 2*bits_left) {
00477 int max = -999999;
00478 index=-1;
00479 for (i=0 ; i<p->total_subbands ; i++){
00480 if (exp_index1[i] < 7) {
00481 v = (-2*exp_index1[i]) - quant_index_table[i] + bias;
00482 if ( v >= max) {
00483 max = v;
00484 index = i;
00485 }
00486 }
00487 }
00488 if(index==-1)break;
00489 tmp_categorize_array[tmp_categorize_array1_idx++] = index;
00490 tmpbias1 -= expbits_tab[exp_index1[index]] -
00491 expbits_tab[exp_index1[index]+1];
00492 ++exp_index1[index];
00493 } else {
00494 int min = 999999;
00495 index=-1;
00496 for (i=0 ; i<p->total_subbands ; i++){
00497 if(exp_index2[i] > 0){
00498 v = (-2*exp_index2[i])-quant_index_table[i]+bias;
00499 if ( v < min) {
00500 min = v;
00501 index = i;
00502 }
00503 }
00504 }
00505 if(index == -1)break;
00506 tmp_categorize_array[--tmp_categorize_array2_idx] = index;
00507 tmpbias2 -= expbits_tab[exp_index2[index]] -
00508 expbits_tab[exp_index2[index]-1];
00509 --exp_index2[index];
00510 }
00511 }
00512
00513 for(i=0 ; i<p->total_subbands ; i++)
00514 category[i] = exp_index2[i];
00515
00516 for(i=0 ; i<p->numvector_size-1 ; i++)
00517 category_index[i] = tmp_categorize_array[tmp_categorize_array2_idx++];
00518
00519 }
00520
00521
00530 static inline void expand_category(COOKContext *q, int* category,
00531 int* category_index){
00532 int i;
00533 for(i=0 ; i<q->num_vectors ; i++){
00534 ++category[category_index[i]];
00535 }
00536 }
00537
00549 static void scalar_dequant_float(COOKContext *q, int index, int quant_index,
00550 int* subband_coef_index, int* subband_coef_sign,
00551 float* mlt_p){
00552 int i;
00553 float f1;
00554
00555 for(i=0 ; i<SUBBAND_SIZE ; i++) {
00556 if (subband_coef_index[i]) {
00557 f1 = quant_centroid_tab[index][subband_coef_index[i]];
00558 if (subband_coef_sign[i]) f1 = -f1;
00559 } else {
00560
00561 f1 = dither_tab[index];
00562 if (av_lfg_get(&q->random_state) < 0x80000000) f1 = -f1;
00563 }
00564 mlt_p[i] = f1 * rootpow2tab[quant_index+63];
00565 }
00566 }
00576 static int unpack_SQVH(COOKContext *q, COOKSubpacket *p, int category, int* subband_coef_index,
00577 int* subband_coef_sign) {
00578 int i,j;
00579 int vlc, vd ,tmp, result;
00580
00581 vd = vd_tab[category];
00582 result = 0;
00583 for(i=0 ; i<vpr_tab[category] ; i++){
00584 vlc = get_vlc2(&q->gb, q->sqvh[category].table, q->sqvh[category].bits, 3);
00585 if (p->bits_per_subpacket < get_bits_count(&q->gb)){
00586 vlc = 0;
00587 result = 1;
00588 }
00589 for(j=vd-1 ; j>=0 ; j--){
00590 tmp = (vlc * invradix_tab[category])/0x100000;
00591 subband_coef_index[vd*i+j] = vlc - tmp * (kmax_tab[category]+1);
00592 vlc = tmp;
00593 }
00594 for(j=0 ; j<vd ; j++){
00595 if (subband_coef_index[i*vd + j]) {
00596 if(get_bits_count(&q->gb) < p->bits_per_subpacket){
00597 subband_coef_sign[i*vd+j] = get_bits1(&q->gb);
00598 } else {
00599 result=1;
00600 subband_coef_sign[i*vd+j]=0;
00601 }
00602 } else {
00603 subband_coef_sign[i*vd+j]=0;
00604 }
00605 }
00606 }
00607 return result;
00608 }
00609
00610
00621 static void decode_vectors(COOKContext* q, COOKSubpacket* p, int* category,
00622 int *quant_index_table, float* mlt_buffer){
00623
00624
00625 int subband_coef_index[SUBBAND_SIZE];
00626
00627
00628 int subband_coef_sign[SUBBAND_SIZE];
00629 int band, j;
00630 int index=0;
00631
00632 for(band=0 ; band<p->total_subbands ; band++){
00633 index = category[band];
00634 if(category[band] < 7){
00635 if(unpack_SQVH(q, p, category[band], subband_coef_index, subband_coef_sign)){
00636 index=7;
00637 for(j=0 ; j<p->total_subbands ; j++) category[band+j]=7;
00638 }
00639 }
00640 if(index>=7) {
00641 memset(subband_coef_index, 0, sizeof(subband_coef_index));
00642 memset(subband_coef_sign, 0, sizeof(subband_coef_sign));
00643 }
00644 q->scalar_dequant(q, index, quant_index_table[band],
00645 subband_coef_index, subband_coef_sign,
00646 &mlt_buffer[band * SUBBAND_SIZE]);
00647 }
00648
00649 if(p->total_subbands*SUBBAND_SIZE >= q->samples_per_channel){
00650 return;
00651 }
00652 }
00653
00654
00662 static void mono_decode(COOKContext *q, COOKSubpacket *p, float* mlt_buffer) {
00663
00664 int category_index[128];
00665 int quant_index_table[102];
00666 int category[128];
00667
00668 memset(&category, 0, 128*sizeof(int));
00669 memset(&category_index, 0, 128*sizeof(int));
00670
00671 decode_envelope(q, p, quant_index_table);
00672 q->num_vectors = get_bits(&q->gb,p->log2_numvector_size);
00673 categorize(q, p, quant_index_table, category, category_index);
00674 expand_category(q, category, category_index);
00675 decode_vectors(q, p, category, quant_index_table, mlt_buffer);
00676 }
00677
00678
00688 static void interpolate_float(COOKContext *q, float* buffer,
00689 int gain_index, int gain_index_next){
00690 int i;
00691 float fc1, fc2;
00692 fc1 = pow2tab[gain_index+63];
00693
00694 if(gain_index == gain_index_next){
00695 for(i=0 ; i<q->gain_size_factor ; i++){
00696 buffer[i]*=fc1;
00697 }
00698 return;
00699 } else {
00700 fc2 = q->gain_table[11 + (gain_index_next-gain_index)];
00701 for(i=0 ; i<q->gain_size_factor ; i++){
00702 buffer[i]*=fc1;
00703 fc1*=fc2;
00704 }
00705 return;
00706 }
00707 }
00708
00718 static void imlt_window_float (COOKContext *q, float *inbuffer,
00719 cook_gains *gains_ptr, float *previous_buffer)
00720 {
00721 const float fc = pow2tab[gains_ptr->previous[0] + 63];
00722 int i;
00723
00724
00725
00726
00727
00728
00729
00730 for(i = 0; i < q->samples_per_channel; i++){
00731 inbuffer[i] = inbuffer[i] * fc * q->mlt_window[i] -
00732 previous_buffer[i] * q->mlt_window[q->samples_per_channel - 1 - i];
00733 }
00734 }
00735
00748 static void imlt_gain(COOKContext *q, float *inbuffer,
00749 cook_gains *gains_ptr, float* previous_buffer)
00750 {
00751 float *buffer0 = q->mono_mdct_output;
00752 float *buffer1 = q->mono_mdct_output + q->samples_per_channel;
00753 int i;
00754
00755
00756 ff_imdct_calc(&q->mdct_ctx, q->mono_mdct_output, inbuffer);
00757
00758 q->imlt_window (q, buffer1, gains_ptr, previous_buffer);
00759
00760
00761 for (i = 0; i < 8; i++) {
00762 if (gains_ptr->now[i] || gains_ptr->now[i + 1])
00763 q->interpolate(q, &buffer1[q->gain_size_factor * i],
00764 gains_ptr->now[i], gains_ptr->now[i + 1]);
00765 }
00766
00767
00768 memcpy(previous_buffer, buffer0, sizeof(float)*q->samples_per_channel);
00769 }
00770
00771
00780 static void decouple_info(COOKContext *q, COOKSubpacket *p, int* decouple_tab){
00781 int length, i;
00782
00783 if(get_bits1(&q->gb)) {
00784 if(cplband[p->js_subband_start] > cplband[p->subbands-1]) return;
00785
00786 length = cplband[p->subbands-1] - cplband[p->js_subband_start] + 1;
00787 for (i=0 ; i<length ; i++) {
00788 decouple_tab[cplband[p->js_subband_start] + i] = get_vlc2(&q->gb, p->ccpl.table, p->ccpl.bits, 2);
00789 }
00790 return;
00791 }
00792
00793 if(cplband[p->js_subband_start] > cplband[p->subbands-1]) return;
00794
00795 length = cplband[p->subbands-1] - cplband[p->js_subband_start] + 1;
00796 for (i=0 ; i<length ; i++) {
00797 decouple_tab[cplband[p->js_subband_start] + i] = get_bits(&q->gb, p->js_vlc_bits);
00798 }
00799 return;
00800 }
00801
00802
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813 static void decouple_float (COOKContext *q,
00814 COOKSubpacket *p,
00815 int subband,
00816 float f1, float f2,
00817 float *decode_buffer,
00818 float *mlt_buffer1, float *mlt_buffer2)
00819 {
00820 int j, tmp_idx;
00821 for (j=0 ; j<SUBBAND_SIZE ; j++) {
00822 tmp_idx = ((p->js_subband_start + subband)*SUBBAND_SIZE)+j;
00823 mlt_buffer1[SUBBAND_SIZE*subband + j] = f1 * decode_buffer[tmp_idx];
00824 mlt_buffer2[SUBBAND_SIZE*subband + j] = f2 * decode_buffer[tmp_idx];
00825 }
00826 }
00827
00836 static void joint_decode(COOKContext *q, COOKSubpacket *p, float* mlt_buffer1,
00837 float* mlt_buffer2) {
00838 int i,j;
00839 int decouple_tab[SUBBAND_SIZE];
00840 float *decode_buffer = q->decode_buffer_0;
00841 int idx, cpl_tmp;
00842 float f1,f2;
00843 const float* cplscale;
00844
00845 memset(decouple_tab, 0, sizeof(decouple_tab));
00846 memset(decode_buffer, 0, sizeof(decode_buffer));
00847
00848
00849 memset(mlt_buffer1,0, 1024*sizeof(float));
00850 memset(mlt_buffer2,0, 1024*sizeof(float));
00851 decouple_info(q, p, decouple_tab);
00852 mono_decode(q, p, decode_buffer);
00853
00854
00855 for (i=0 ; i<p->js_subband_start ; i++) {
00856 for (j=0 ; j<SUBBAND_SIZE ; j++) {
00857 mlt_buffer1[i*20+j] = decode_buffer[i*40+j];
00858 mlt_buffer2[i*20+j] = decode_buffer[i*40+20+j];
00859 }
00860 }
00861
00862
00863
00864 idx = (1 << p->js_vlc_bits) - 1;
00865 for (i=p->js_subband_start ; i<p->subbands ; i++) {
00866 cpl_tmp = cplband[i];
00867 idx -=decouple_tab[cpl_tmp];
00868 cplscale = q->cplscales[p->js_vlc_bits-2];
00869 f1 = cplscale[decouple_tab[cpl_tmp]];
00870 f2 = cplscale[idx-1];
00871 q->decouple (q, p, i, f1, f2, decode_buffer, mlt_buffer1, mlt_buffer2);
00872 idx = (1 << p->js_vlc_bits) - 1;
00873 }
00874 }
00875
00885 static inline void
00886 decode_bytes_and_gain(COOKContext *q, COOKSubpacket *p, const uint8_t *inbuffer,
00887 cook_gains *gains_ptr)
00888 {
00889 int offset;
00890
00891 offset = decode_bytes(inbuffer, q->decoded_bytes_buffer,
00892 p->bits_per_subpacket/8);
00893 init_get_bits(&q->gb, q->decoded_bytes_buffer + offset,
00894 p->bits_per_subpacket);
00895 decode_gain_info(&q->gb, gains_ptr->now);
00896
00897
00898 FFSWAP(int *, gains_ptr->now, gains_ptr->previous);
00899 }
00900
00908 static void
00909 saturate_output_float (COOKContext *q, int chan, int16_t *out)
00910 {
00911 int j;
00912 float *output = q->mono_mdct_output + q->samples_per_channel;
00913
00914
00915 for (j = 0; j < q->samples_per_channel; j++) {
00916 out[chan + q->nb_channels * j] =
00917 av_clip_int16(lrintf(output[j]));
00918 }
00919 }
00920
00934 static inline void
00935 mlt_compensate_output(COOKContext *q, float *decode_buffer,
00936 cook_gains *gains_ptr, float *previous_buffer,
00937 int16_t *out, int chan)
00938 {
00939 imlt_gain(q, decode_buffer, gains_ptr, previous_buffer);
00940 q->saturate_output (q, chan, out);
00941 }
00942
00943
00952 static void decode_subpacket(COOKContext *q, COOKSubpacket* p, const uint8_t *inbuffer, int16_t *outbuffer) {
00953 int sub_packet_size = p->size;
00954
00955
00956
00957
00958
00959 memset(q->decode_buffer_1,0,sizeof(q->decode_buffer_1));
00960 decode_bytes_and_gain(q, p, inbuffer, &p->gains1);
00961
00962 if (p->joint_stereo) {
00963 joint_decode(q, p, q->decode_buffer_1, q->decode_buffer_2);
00964 } else {
00965 mono_decode(q, p, q->decode_buffer_1);
00966
00967 if (p->num_channels == 2) {
00968 decode_bytes_and_gain(q, p, inbuffer + sub_packet_size/2, &p->gains2);
00969 mono_decode(q, p, q->decode_buffer_2);
00970 }
00971 }
00972
00973 mlt_compensate_output(q, q->decode_buffer_1, &p->gains1,
00974 p->mono_previous_buffer1, outbuffer, p->ch_idx);
00975
00976 if (p->num_channels == 2) {
00977 if (p->joint_stereo) {
00978 mlt_compensate_output(q, q->decode_buffer_2, &p->gains1,
00979 p->mono_previous_buffer2, outbuffer, p->ch_idx + 1);
00980 } else {
00981 mlt_compensate_output(q, q->decode_buffer_2, &p->gains2,
00982 p->mono_previous_buffer2, outbuffer, p->ch_idx + 1);
00983 }
00984 }
00985
00986 }
00987
00988
00995 static int cook_decode_frame(AVCodecContext *avctx,
00996 void *data, int *data_size,
00997 AVPacket *avpkt) {
00998 const uint8_t *buf = avpkt->data;
00999 int buf_size = avpkt->size;
01000 COOKContext *q = avctx->priv_data;
01001 int i;
01002 int offset = 0;
01003 int chidx = 0;
01004
01005 if (buf_size < avctx->block_align)
01006 return buf_size;
01007
01008
01009 q->subpacket[0].size = avctx->block_align;
01010
01011 for(i=1;i<q->num_subpackets;i++){
01012 q->subpacket[i].size = 2 * buf[avctx->block_align - q->num_subpackets + i];
01013 q->subpacket[0].size -= q->subpacket[i].size + 1;
01014 if (q->subpacket[0].size < 0) {
01015 av_log(avctx,AV_LOG_DEBUG,"frame subpacket size total > avctx->block_align!\n");
01016 return -1;
01017 }
01018 }
01019
01020
01021 *data_size = 0;
01022 for(i=0;i<q->num_subpackets;i++){
01023 q->subpacket[i].bits_per_subpacket = (q->subpacket[i].size*8)>>q->subpacket[i].bits_per_subpdiv;
01024 q->subpacket[i].ch_idx = chidx;
01025 av_log(avctx,AV_LOG_DEBUG,"subpacket[%i] size %i js %i %i block_align %i\n",i,q->subpacket[i].size,q->subpacket[i].joint_stereo,offset,avctx->block_align);
01026 decode_subpacket(q, &q->subpacket[i], buf + offset, (int16_t*)data);
01027 offset += q->subpacket[i].size;
01028 chidx += q->subpacket[i].num_channels;
01029 av_log(avctx,AV_LOG_DEBUG,"subpacket[%i] %i %i\n",i,q->subpacket[i].size * 8,get_bits_count(&q->gb));
01030 }
01031 *data_size = sizeof(int16_t) * q->nb_channels * q->samples_per_channel;
01032
01033
01034 if (avctx->frame_number < 2) *data_size = 0;
01035
01036 return avctx->block_align;
01037 }
01038
01039 #ifdef COOKDEBUG
01040 static void dump_cook_context(COOKContext *q)
01041 {
01042
01043 #define PRINT(a,b) av_log(q->avctx,AV_LOG_ERROR," %s = %d\n", a, b);
01044 av_log(q->avctx,AV_LOG_ERROR,"COOKextradata\n");
01045 av_log(q->avctx,AV_LOG_ERROR,"cookversion=%x\n",q->subpacket[0].cookversion);
01046 if (q->subpacket[0].cookversion > STEREO) {
01047 PRINT("js_subband_start",q->subpacket[0].js_subband_start);
01048 PRINT("js_vlc_bits",q->subpacket[0].js_vlc_bits);
01049 }
01050 av_log(q->avctx,AV_LOG_ERROR,"COOKContext\n");
01051 PRINT("nb_channels",q->nb_channels);
01052 PRINT("bit_rate",q->bit_rate);
01053 PRINT("sample_rate",q->sample_rate);
01054 PRINT("samples_per_channel",q->subpacket[0].samples_per_channel);
01055 PRINT("samples_per_frame",q->subpacket[0].samples_per_frame);
01056 PRINT("subbands",q->subpacket[0].subbands);
01057 PRINT("random_state",q->random_state);
01058 PRINT("js_subband_start",q->subpacket[0].js_subband_start);
01059 PRINT("log2_numvector_size",q->subpacket[0].log2_numvector_size);
01060 PRINT("numvector_size",q->subpacket[0].numvector_size);
01061 PRINT("total_subbands",q->subpacket[0].total_subbands);
01062 }
01063 #endif
01064
01065 static av_cold int cook_count_channels(unsigned int mask){
01066 int i;
01067 int channels = 0;
01068 for(i = 0;i<32;i++){
01069 if(mask & (1<<i))
01070 ++channels;
01071 }
01072 return channels;
01073 }
01074
01081 static av_cold int cook_decode_init(AVCodecContext *avctx)
01082 {
01083 COOKContext *q = avctx->priv_data;
01084 const uint8_t *edata_ptr = avctx->extradata;
01085 const uint8_t *edata_ptr_end = edata_ptr + avctx->extradata_size;
01086 int extradata_size = avctx->extradata_size;
01087 int s = 0;
01088 unsigned int channel_mask = 0;
01089 q->avctx = avctx;
01090
01091
01092 if (extradata_size <= 0) {
01093 av_log(avctx,AV_LOG_ERROR,"Necessary extradata missing!\n");
01094 return -1;
01095 }
01096 av_log(avctx,AV_LOG_DEBUG,"codecdata_length=%d\n",avctx->extradata_size);
01097
01098
01099 q->sample_rate = avctx->sample_rate;
01100 q->nb_channels = avctx->channels;
01101 q->bit_rate = avctx->bit_rate;
01102
01103
01104 av_lfg_init(&q->random_state, 0);
01105
01106 while(edata_ptr < edata_ptr_end){
01107
01108
01109 if (extradata_size >= 8){
01110 q->subpacket[s].cookversion = bytestream_get_be32(&edata_ptr);
01111 q->subpacket[s].samples_per_frame = bytestream_get_be16(&edata_ptr);
01112 q->subpacket[s].subbands = bytestream_get_be16(&edata_ptr);
01113 extradata_size -= 8;
01114 }
01115 if (avctx->extradata_size >= 8){
01116 bytestream_get_be32(&edata_ptr);
01117 q->subpacket[s].js_subband_start = bytestream_get_be16(&edata_ptr);
01118 q->subpacket[s].js_vlc_bits = bytestream_get_be16(&edata_ptr);
01119 extradata_size -= 8;
01120 }
01121
01122
01123 q->subpacket[s].samples_per_channel = q->subpacket[s].samples_per_frame / q->nb_channels;
01124 q->subpacket[s].bits_per_subpacket = avctx->block_align * 8;
01125
01126
01127 q->subpacket[s].log2_numvector_size = 5;
01128 q->subpacket[s].total_subbands = q->subpacket[s].subbands;
01129 q->subpacket[s].num_channels = 1;
01130
01131
01132
01133 av_log(avctx,AV_LOG_DEBUG,"subpacket[%i].cookversion=%x\n",s,q->subpacket[s].cookversion);
01134 q->subpacket[s].joint_stereo = 0;
01135 switch (q->subpacket[s].cookversion) {
01136 case MONO:
01137 if (q->nb_channels != 1) {
01138 av_log(avctx,AV_LOG_ERROR,"Container channels != 1, report sample!\n");
01139 return -1;
01140 }
01141 av_log(avctx,AV_LOG_DEBUG,"MONO\n");
01142 break;
01143 case STEREO:
01144 if (q->nb_channels != 1) {
01145 q->subpacket[s].bits_per_subpdiv = 1;
01146 q->subpacket[s].num_channels = 2;
01147 }
01148 av_log(avctx,AV_LOG_DEBUG,"STEREO\n");
01149 break;
01150 case JOINT_STEREO:
01151 if (q->nb_channels != 2) {
01152 av_log(avctx,AV_LOG_ERROR,"Container channels != 2, report sample!\n");
01153 return -1;
01154 }
01155 av_log(avctx,AV_LOG_DEBUG,"JOINT_STEREO\n");
01156 if (avctx->extradata_size >= 16){
01157 q->subpacket[s].total_subbands = q->subpacket[s].subbands + q->subpacket[s].js_subband_start;
01158 q->subpacket[s].joint_stereo = 1;
01159 q->subpacket[s].num_channels = 2;
01160 }
01161 if (q->subpacket[s].samples_per_channel > 256) {
01162 q->subpacket[s].log2_numvector_size = 6;
01163 }
01164 if (q->subpacket[s].samples_per_channel > 512) {
01165 q->subpacket[s].log2_numvector_size = 7;
01166 }
01167 break;
01168 case MC_COOK:
01169 av_log(avctx,AV_LOG_DEBUG,"MULTI_CHANNEL\n");
01170 if(extradata_size >= 4)
01171 channel_mask |= q->subpacket[s].channel_mask = bytestream_get_be32(&edata_ptr);
01172
01173 if(cook_count_channels(q->subpacket[s].channel_mask) > 1){
01174 q->subpacket[s].total_subbands = q->subpacket[s].subbands + q->subpacket[s].js_subband_start;
01175 q->subpacket[s].joint_stereo = 1;
01176 q->subpacket[s].num_channels = 2;
01177 q->subpacket[s].samples_per_channel = q->subpacket[s].samples_per_frame >> 1;
01178
01179 if (q->subpacket[s].samples_per_channel > 256) {
01180 q->subpacket[s].log2_numvector_size = 6;
01181 }
01182 if (q->subpacket[s].samples_per_channel > 512) {
01183 q->subpacket[s].log2_numvector_size = 7;
01184 }
01185 }else
01186 q->subpacket[s].samples_per_channel = q->subpacket[s].samples_per_frame;
01187
01188 break;
01189 default:
01190 av_log(avctx,AV_LOG_ERROR,"Unknown Cook version, report sample!\n");
01191 return -1;
01192 break;
01193 }
01194
01195 if(s > 1 && q->subpacket[s].samples_per_channel != q->samples_per_channel) {
01196 av_log(avctx,AV_LOG_ERROR,"different number of samples per channel!\n");
01197 return -1;
01198 } else
01199 q->samples_per_channel = q->subpacket[0].samples_per_channel;
01200
01201
01202
01203 q->subpacket[s].numvector_size = (1 << q->subpacket[s].log2_numvector_size);
01204
01205
01206 if (q->subpacket[s].total_subbands > 53) {
01207 av_log(avctx,AV_LOG_ERROR,"total_subbands > 53, report sample!\n");
01208 return -1;
01209 }
01210
01211 if ((q->subpacket[s].js_vlc_bits > 6) || (q->subpacket[s].js_vlc_bits < 0)) {
01212 av_log(avctx,AV_LOG_ERROR,"js_vlc_bits = %d, only >= 0 and <= 6 allowed!\n",q->subpacket[s].js_vlc_bits);
01213 return -1;
01214 }
01215
01216 if (q->subpacket[s].subbands > 50) {
01217 av_log(avctx,AV_LOG_ERROR,"subbands > 50, report sample!\n");
01218 return -1;
01219 }
01220 q->subpacket[s].gains1.now = q->subpacket[s].gain_1;
01221 q->subpacket[s].gains1.previous = q->subpacket[s].gain_2;
01222 q->subpacket[s].gains2.now = q->subpacket[s].gain_3;
01223 q->subpacket[s].gains2.previous = q->subpacket[s].gain_4;
01224
01225 q->num_subpackets++;
01226 s++;
01227 if (s > MAX_SUBPACKETS) {
01228 av_log(avctx,AV_LOG_ERROR,"Too many subpackets > 5, report file!\n");
01229 return -1;
01230 }
01231 }
01232
01233 init_pow2table();
01234 init_gain_table(q);
01235 init_cplscales_table(q);
01236
01237 if (init_cook_vlc_tables(q) != 0)
01238 return -1;
01239
01240
01241 if(avctx->block_align >= UINT_MAX/2)
01242 return -1;
01243
01244
01245
01246
01247 q->decoded_bytes_buffer =
01248 av_mallocz(avctx->block_align
01249 + DECODE_BYTES_PAD1(avctx->block_align)
01250 + FF_INPUT_BUFFER_PADDING_SIZE);
01251 if (q->decoded_bytes_buffer == NULL)
01252 return -1;
01253
01254
01255 if ( init_cook_mlt(q) != 0 )
01256 return -1;
01257
01258
01259 if (1) {
01260 q->scalar_dequant = scalar_dequant_float;
01261 q->decouple = decouple_float;
01262 q->imlt_window = imlt_window_float;
01263 q->interpolate = interpolate_float;
01264 q->saturate_output = saturate_output_float;
01265 }
01266
01267
01268 if ((q->samples_per_channel == 256) || (q->samples_per_channel == 512) || (q->samples_per_channel == 1024)) {
01269 } else {
01270 av_log(avctx,AV_LOG_ERROR,"unknown amount of samples_per_channel = %d, report sample!\n",q->samples_per_channel);
01271 return -1;
01272 }
01273
01274 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
01275 if (channel_mask)
01276 avctx->channel_layout = channel_mask;
01277 else
01278 avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
01279
01280 #ifdef COOKDEBUG
01281 dump_cook_context(q);
01282 #endif
01283 return 0;
01284 }
01285
01286
01287 AVCodec ff_cook_decoder =
01288 {
01289 .name = "cook",
01290 .type = AVMEDIA_TYPE_AUDIO,
01291 .id = CODEC_ID_COOK,
01292 .priv_data_size = sizeof(COOKContext),
01293 .init = cook_decode_init,
01294 .close = cook_decode_close,
01295 .decode = cook_decode_frame,
01296 .long_name = NULL_IF_CONFIG_SMALL("COOK"),
01297 };