ffmpeg / libavcodec / cook.c @ df3a80b5
History  View  Annotate  Download (38.7 KB)
1 
/*


2 
* COOK compatible decoder

3 
* Copyright (c) 2003 Sascha Sommer

4 
* Copyright (c) 2005 Benjamin Larsson

5 
*

6 
* This file is part of FFmpeg.

7 
*

8 
* FFmpeg is free software; you can redistribute it and/or

9 
* modify it under the terms of the GNU Lesser General Public

10 
* License as published by the Free Software Foundation; either

11 
* version 2.1 of the License, or (at your option) any later version.

12 
*

13 
* FFmpeg is distributed in the hope that it will be useful,

14 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

15 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 
* Lesser General Public License for more details.

17 
*

18 
* You should have received a copy of the GNU Lesser General Public

19 
* License along with FFmpeg; if not, write to the Free Software

20 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

21 
*/

22  
23 
/**

24 
* @file cook.c

25 
* Cook compatible decoder. Bastardization of the G.722.1 standard.

26 
* This decoder handles RealNetworks, RealAudio G2 data.

27 
* Cook is identified by the codec name cook in RM files.

28 
*

29 
* To use this decoder, a calling application must supply the extradata

30 
* bytes provided from the RM container; 8+ bytes for mono streams and

31 
* 16+ for stereo streams (maybe more).

32 
*

33 
* Codec technicalities (all this assume a buffer length of 1024):

34 
* Cook works with several different techniques to achieve its compression.

35 
* In the timedomain the buffer is divided into 8 pieces and quantized. If

36 
* two neighboring pieces have different quantization index a smooth

37 
* quantization curve is used to get a smooth overlap between the different

38 
* pieces.

39 
* To get to the transformdomain Cook uses a modulated lapped transform.

40 
* The transform domain has 50 subbands with 20 elements each. This

41 
* means only a maximum of 50*20=1000 coefficients are used out of the 1024

42 
* available.

43 
*/

44  
45 
#include <math.h> 
46 
#include <stddef.h> 
47 
#include <stdio.h> 
48  
49 
#include "avcodec.h" 
50 
#include "bitstream.h" 
51 
#include "dsputil.h" 
52 
#include "bytestream.h" 
53 
#include "random.h" 
54  
55 
#include "cookdata.h" 
56  
57 
/* the different Cook versions */

58 
#define MONO 0x1000001 
59 
#define STEREO 0x1000002 
60 
#define JOINT_STEREO 0x1000003 
61 
#define MC_COOK 0x2000000 //multichannel Cook, not supported 
62  
63 
#define SUBBAND_SIZE 20 
64 
//#define COOKDEBUG

65  
66 
typedef struct { 
67 
int *now;

68 
int *previous;

69 
} cook_gains; 
70  
71 
typedef struct cook { 
72 
/*

73 
* The following 5 functions provide the lowlevel arithmetic on

74 
* the internal audio buffers.

75 
*/

76 
void (* scalar_dequant)(struct cook *q, int index, int quant_index, 
77 
int* subband_coef_index, int* subband_coef_sign, 
78 
float* mlt_p);

79  
80 
void (* decouple) (struct cook *q, 
81 
int subband,

82 
float f1, float f2, 
83 
float *decode_buffer,

84 
float *mlt_buffer1, float *mlt_buffer2); 
85  
86 
void (* imlt_window) (struct cook *q, float *buffer1, 
87 
cook_gains *gains_ptr, float *previous_buffer);

88  
89 
void (* interpolate) (struct cook *q, float* buffer, 
90 
int gain_index, int gain_index_next); 
91  
92 
void (* saturate_output) (struct cook *q, int chan, int16_t *out); 
93  
94 
GetBitContext gb; 
95 
/* stream data */

96 
int nb_channels;

97 
int joint_stereo;

98 
int bit_rate;

99 
int sample_rate;

100 
int samples_per_channel;

101 
int samples_per_frame;

102 
int subbands;

103 
int log2_numvector_size;

104 
int numvector_size; //1 << log2_numvector_size; 
105 
int js_subband_start;

106 
int total_subbands;

107 
int num_vectors;

108 
int bits_per_subpacket;

109 
int cookversion;

110 
/* states */

111 
AVRandomState random_state; 
112  
113 
/* transform data */

114 
MDCTContext mdct_ctx; 
115 
DECLARE_ALIGNED_16(FFTSample, mdct_tmp[1024]); /* temporary storage for imlt */ 
116 
float* mlt_window;

117  
118 
/* gain buffers */

119 
cook_gains gains1; 
120 
cook_gains gains2; 
121 
int gain_1[9]; 
122 
int gain_2[9]; 
123 
int gain_3[9]; 
124 
int gain_4[9]; 
125  
126 
/* VLC data */

127 
int js_vlc_bits;

128 
VLC envelope_quant_index[13];

129 
VLC sqvh[7]; //scalar quantization 
130 
VLC ccpl; //channel coupling

131  
132 
/* generatable tables and related variables */

133 
int gain_size_factor;

134 
float gain_table[23]; 
135 
float pow2tab[127]; 
136 
float rootpow2tab[127]; 
137  
138 
/* data buffers */

139  
140 
uint8_t* decoded_bytes_buffer; 
141 
DECLARE_ALIGNED_16(float,mono_mdct_output[2048]); 
142 
float mono_previous_buffer1[1024]; 
143 
float mono_previous_buffer2[1024]; 
144 
float decode_buffer_1[1024]; 
145 
float decode_buffer_2[1024]; 
146 
float decode_buffer_0[1060]; /* static allocation for joint decode */ 
147  
148 
float *cplscales[5]; 
149 
} COOKContext; 
150  
151 
/* debug functions */

152  
153 
#ifdef COOKDEBUG

154 
static void dump_float_table(float* table, int size, int delimiter) { 
155 
int i=0; 
156 
av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i); 
157 
for (i=0 ; i<size ; i++) { 
158 
av_log(NULL, AV_LOG_ERROR, "%5.1f, ", table[i]); 
159 
if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1); 
160 
} 
161 
} 
162  
163 
static void dump_int_table(int* table, int size, int delimiter) { 
164 
int i=0; 
165 
av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i); 
166 
for (i=0 ; i<size ; i++) { 
167 
av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]); 
168 
if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1); 
169 
} 
170 
} 
171  
172 
static void dump_short_table(short* table, int size, int delimiter) { 
173 
int i=0; 
174 
av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i); 
175 
for (i=0 ; i<size ; i++) { 
176 
av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]); 
177 
if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1); 
178 
} 
179 
} 
180  
181 
#endif

182  
183 
/*************** init functions ***************/

184  
185 
/* table generator */

186 
static void init_pow2table(COOKContext *q){ 
187 
int i;

188 
q>pow2tab[63] = 1.0; 
189 
for (i=1 ; i<64 ; i++){ 
190 
q>pow2tab[63+i]=(float)((uint64_t)1<<i); 
191 
q>pow2tab[63i]=1.0/(float)((uint64_t)1<<i); 
192 
} 
193 
} 
194  
195 
/* table generator */

196 
static void init_rootpow2table(COOKContext *q){ 
197 
int i;

198 
q>rootpow2tab[63] = 1.0; 
199 
for (i=1 ; i<64 ; i++){ 
200 
q>rootpow2tab[63+i]=sqrt((float)((uint64_t)1<<i)); 
201 
q>rootpow2tab[63i]=sqrt(1.0/(float)((uint64_t)1<<i)); 
202 
} 
203 
} 
204  
205 
/* table generator */

206 
static void init_gain_table(COOKContext *q) { 
207 
int i;

208 
q>gain_size_factor = q>samples_per_channel/8;

209 
for (i=0 ; i<23 ; i++) { 
210 
q>gain_table[i] = pow((double)q>pow2tab[i+52] , 
211 
(1.0/(double)q>gain_size_factor)); 
212 
} 
213 
} 
214  
215  
216 
static int init_cook_vlc_tables(COOKContext *q) { 
217 
int i, result;

218  
219 
result = 0;

220 
for (i=0 ; i<13 ; i++) { 
221 
result = init_vlc (&q>envelope_quant_index[i], 9, 24, 
222 
envelope_quant_index_huffbits[i], 1, 1, 
223 
envelope_quant_index_huffcodes[i], 2, 2, 0); 
224 
} 
225 
av_log(NULL,AV_LOG_DEBUG,"sqvh VLC init\n"); 
226 
for (i=0 ; i<7 ; i++) { 
227 
result = init_vlc (&q>sqvh[i], vhvlcsize_tab[i], vhsize_tab[i], 
228 
cvh_huffbits[i], 1, 1, 
229 
cvh_huffcodes[i], 2, 2, 0); 
230 
} 
231  
232 
if (q>nb_channels==2 && q>joint_stereo==1){ 
233 
result = init_vlc (&q>ccpl, 6, (1<<q>js_vlc_bits)1, 
234 
ccpl_huffbits[q>js_vlc_bits2], 1, 1, 
235 
ccpl_huffcodes[q>js_vlc_bits2], 2, 2, 0); 
236 
av_log(NULL,AV_LOG_DEBUG,"Jointstereo VLC used.\n"); 
237 
} 
238  
239 
av_log(NULL,AV_LOG_DEBUG,"VLC tables initialized.\n"); 
240 
return result;

241 
} 
242  
243 
static int init_cook_mlt(COOKContext *q) { 
244 
int j;

245 
float alpha;

246 
int mlt_size = q>samples_per_channel;

247  
248 
if ((q>mlt_window = av_malloc(sizeof(float)*mlt_size)) == 0) 
249 
return 1; 
250  
251 
/* Initialize the MLT window: simple sine window. */

252 
alpha = M_PI / (2.0 * (float)mlt_size); 
253 
for(j=0 ; j<mlt_size ; j++) 
254 
q>mlt_window[j] = sin((j + 0.5) * alpha) * sqrt(2.0 / q>samples_per_channel); 
255  
256 
/* Initialize the MDCT. */

257 
if (ff_mdct_init(&q>mdct_ctx, av_log2(mlt_size)+1, 1)) { 
258 
av_free(q>mlt_window); 
259 
return 1; 
260 
} 
261 
av_log(NULL,AV_LOG_DEBUG,"MDCT initialized, order = %d.\n", 
262 
av_log2(mlt_size)+1);

263  
264 
return 0; 
265 
} 
266  
267 
static float *maybe_reformat_buffer32 (COOKContext *q, float *ptr, int n) 
268 
{ 
269 
if (1) 
270 
return ptr;

271 
} 
272  
273 
static int init_cplscales_table (COOKContext *q) { 
274 
int i;

275 
for (i=0;i<5;i++) 
276 
q>cplscales[i] = maybe_reformat_buffer32 (q, cplscales[i], (1<<(i+2))1); 
277 
} 
278  
279 
/*************** init functions end ***********/

280  
281 
/**

282 
* Cook indata decoding, every 32 bits are XORed with 0x37c511f2.

283 
* Why? No idea, some checksum/error detection method maybe.

284 
*

285 
* Out buffer size: extra bytes are needed to cope with

286 
* padding/misalignment.

287 
* Subpackets passed to the decoder can contain two, consecutive

288 
* halfsubpackets, of identical but arbitrary size.

289 
* 1234 1234 1234 1234 extraA extraB

290 
* Case 1: AAAA BBBB 0 0

291 
* Case 2: AAAA ABBB BB 3 3

292 
* Case 3: AAAA AABB BBBB 2 2

293 
* Case 4: AAAA AAAB BBBB BB 1 5

294 
*

295 
* Nice way to waste CPU cycles.

296 
*

297 
* @param inbuffer pointer to byte array of indata

298 
* @param out pointer to byte array of outdata

299 
* @param bytes number of bytes

300 
*/

301 
#define DECODE_BYTES_PAD1(bytes) (3  ((bytes)+3) % 4) 
302 
#define DECODE_BYTES_PAD2(bytes) ((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes))) 
303  
304 
static inline int decode_bytes(uint8_t* inbuffer, uint8_t* out, int bytes){ 
305 
int i, off;

306 
uint32_t c; 
307 
uint32_t* buf; 
308 
uint32_t* obuf = (uint32_t*) out; 
309 
/* FIXME: 64 bit platforms would be able to do 64 bits at a time.

310 
* I'm too lazy though, should be something like

311 
* for(i=0 ; i<bitamount/64 ; i++)

312 
* (int64_t)out[i] = 0x37c511f237c511f2^be2me_64(int64_t)in[i]);

313 
* Buffer alignment needs to be checked. */

314  
315 
off = (int)((long)inbuffer & 3); 
316 
buf = (uint32_t*) (inbuffer  off); 
317 
c = be2me_32((0x37c511f2 >> (off*8))  (0x37c511f2 << (32(off*8)))); 
318 
bytes += 3 + off;

319 
for (i = 0; i < bytes/4; i++) 
320 
obuf[i] = c ^ buf[i]; 
321  
322 
return off;

323 
} 
324  
325 
/**

326 
* Cook uninit

327 
*/

328  
329 
static int cook_decode_close(AVCodecContext *avctx) 
330 
{ 
331 
int i;

332 
COOKContext *q = avctx>priv_data; 
333 
av_log(avctx,AV_LOG_DEBUG, "Deallocating memory.\n");

334  
335 
/* Free allocated memory buffers. */

336 
av_free(q>mlt_window); 
337 
av_free(q>decoded_bytes_buffer); 
338  
339 
/* Free the transform. */

340 
ff_mdct_end(&q>mdct_ctx); 
341  
342 
/* Free the VLC tables. */

343 
for (i=0 ; i<13 ; i++) { 
344 
free_vlc(&q>envelope_quant_index[i]); 
345 
} 
346 
for (i=0 ; i<7 ; i++) { 
347 
free_vlc(&q>sqvh[i]); 
348 
} 
349 
if(q>nb_channels==2 && q>joint_stereo==1 ){ 
350 
free_vlc(&q>ccpl); 
351 
} 
352  
353 
av_log(NULL,AV_LOG_DEBUG,"Memory deallocated.\n"); 
354  
355 
return 0; 
356 
} 
357  
358 
/**

359 
* Fill the gain array for the timedomain quantization.

360 
*

361 
* @param q pointer to the COOKContext

362 
* @param gaininfo[9] array of gain indices

363 
*/

364  
365 
static void decode_gain_info(GetBitContext *gb, int *gaininfo) 
366 
{ 
367 
int i, n;

368  
369 
while (get_bits1(gb)) {}

370 
n = get_bits_count(gb)  1; //amount of elements*2 to update 
371  
372 
i = 0;

373 
while (n) {

374 
int index = get_bits(gb, 3); 
375 
int gain = get_bits1(gb) ? get_bits(gb, 4)  7 : 1; 
376  
377 
while (i <= index) gaininfo[i++] = gain;

378 
} 
379 
while (i <= 8) gaininfo[i++] = 0; 
380 
} 
381  
382 
/**

383 
* Create the quant index table needed for the envelope.

384 
*

385 
* @param q pointer to the COOKContext

386 
* @param quant_index_table pointer to the array

387 
*/

388  
389 
static void decode_envelope(COOKContext *q, int* quant_index_table) { 
390 
int i,j, vlc_index;

391  
392 
quant_index_table[0]= get_bits(&q>gb,6)  6; //This is used later in categorize 
393  
394 
for (i=1 ; i < q>total_subbands ; i++){ 
395 
vlc_index=i; 
396 
if (i >= q>js_subband_start * 2) { 
397 
vlc_index=q>js_subband_start; 
398 
} else {

399 
vlc_index/=2;

400 
if(vlc_index < 1) vlc_index = 1; 
401 
} 
402 
if (vlc_index>13) vlc_index = 13; //the VLC tables >13 are identical to No. 13 
403  
404 
j = get_vlc2(&q>gb, q>envelope_quant_index[vlc_index1].table,

405 
q>envelope_quant_index[vlc_index1].bits,2); 
406 
quant_index_table[i] = quant_index_table[i1] + j  12; //differential encoding 
407 
} 
408 
} 
409  
410 
/**

411 
* Calculate the category and category_index vector.

412 
*

413 
* @param q pointer to the COOKContext

414 
* @param quant_index_table pointer to the array

415 
* @param category pointer to the category array

416 
* @param category_index pointer to the category_index array

417 
*/

418  
419 
static void categorize(COOKContext *q, int* quant_index_table, 
420 
int* category, int* category_index){ 
421 
int exp_idx, bias, tmpbias1, tmpbias2, bits_left, num_bits, index, v, i, j;

422 
int exp_index2[102]; 
423 
int exp_index1[102]; 
424  
425 
int tmp_categorize_array[128*2]; 
426 
int tmp_categorize_array1_idx=q>numvector_size;

427 
int tmp_categorize_array2_idx=q>numvector_size;

428  
429 
bits_left = q>bits_per_subpacket  get_bits_count(&q>gb); 
430  
431 
if(bits_left > q>samples_per_channel) {

432 
bits_left = q>samples_per_channel + 
433 
((bits_left  q>samples_per_channel)*5)/8; 
434 
//av_log(NULL, AV_LOG_ERROR, "bits_left = %d\n",bits_left);

435 
} 
436  
437 
memset(&exp_index1,0,102*sizeof(int)); 
438 
memset(&exp_index2,0,102*sizeof(int)); 
439 
memset(&tmp_categorize_array,0,128*2*sizeof(int)); 
440  
441 
bias=32;

442  
443 
/* Estimate bias. */

444 
for (i=32 ; i>0 ; i=i/2){ 
445 
num_bits = 0;

446 
index = 0;

447 
for (j=q>total_subbands ; j>0 ; j){ 
448 
exp_idx = av_clip((i  quant_index_table[index] + bias) / 2, 0, 7); 
449 
index++; 
450 
num_bits+=expbits_tab[exp_idx]; 
451 
} 
452 
if(num_bits >= bits_left  32){ 
453 
bias+=i; 
454 
} 
455 
} 
456  
457 
/* Calculate total number of bits. */

458 
num_bits=0;

459 
for (i=0 ; i<q>total_subbands ; i++) { 
460 
exp_idx = av_clip((bias  quant_index_table[i]) / 2, 0, 7); 
461 
num_bits += expbits_tab[exp_idx]; 
462 
exp_index1[i] = exp_idx; 
463 
exp_index2[i] = exp_idx; 
464 
} 
465 
tmpbias1 = tmpbias2 = num_bits; 
466  
467 
for (j = 1 ; j < q>numvector_size ; j++) { 
468 
if (tmpbias1 + tmpbias2 > 2*bits_left) { /* > */ 
469 
int max = 999999; 
470 
index=1;

471 
for (i=0 ; i<q>total_subbands ; i++){ 
472 
if (exp_index1[i] < 7) { 
473 
v = (2*exp_index1[i])  quant_index_table[i] + bias;

474 
if ( v >= max) {

475 
max = v; 
476 
index = i; 
477 
} 
478 
} 
479 
} 
480 
if(index==1)break; 
481 
tmp_categorize_array[tmp_categorize_array1_idx++] = index; 
482 
tmpbias1 = expbits_tab[exp_index1[index]]  
483 
expbits_tab[exp_index1[index]+1];

484 
++exp_index1[index]; 
485 
} else { /* < */ 
486 
int min = 999999; 
487 
index=1;

488 
for (i=0 ; i<q>total_subbands ; i++){ 
489 
if(exp_index2[i] > 0){ 
490 
v = (2*exp_index2[i])quant_index_table[i]+bias;

491 
if ( v < min) {

492 
min = v; 
493 
index = i; 
494 
} 
495 
} 
496 
} 
497 
if(index == 1)break; 
498 
tmp_categorize_array[tmp_categorize_array2_idx] = index; 
499 
tmpbias2 = expbits_tab[exp_index2[index]]  
500 
expbits_tab[exp_index2[index]1];

501 
exp_index2[index]; 
502 
} 
503 
} 
504  
505 
for(i=0 ; i<q>total_subbands ; i++) 
506 
category[i] = exp_index2[i]; 
507  
508 
for(i=0 ; i<q>numvector_size1 ; i++) 
509 
category_index[i] = tmp_categorize_array[tmp_categorize_array2_idx++]; 
510  
511 
} 
512  
513  
514 
/**

515 
* Expand the category vector.

516 
*

517 
* @param q pointer to the COOKContext

518 
* @param category pointer to the category array

519 
* @param category_index pointer to the category_index array

520 
*/

521  
522 
static inline void expand_category(COOKContext *q, int* category, 
523 
int* category_index){

524 
int i;

525 
for(i=0 ; i<q>num_vectors ; i++){ 
526 
++category[category_index[i]]; 
527 
} 
528 
} 
529  
530 
/**

531 
* The real requantization of the mltcoefs

532 
*

533 
* @param q pointer to the COOKContext

534 
* @param index index

535 
* @param quant_index quantisation index

536 
* @param subband_coef_index array of indexes to quant_centroid_tab

537 
* @param subband_coef_sign signs of coefficients

538 
* @param mlt_p pointer into the mlt buffer

539 
*/

540  
541 
static void scalar_dequant_float(COOKContext *q, int index, int quant_index, 
542 
int* subband_coef_index, int* subband_coef_sign, 
543 
float* mlt_p){

544 
int i;

545 
float f1;

546  
547 
for(i=0 ; i<SUBBAND_SIZE ; i++) { 
548 
if (subband_coef_index[i]) {

549 
f1 = quant_centroid_tab[index][subband_coef_index[i]]; 
550 
if (subband_coef_sign[i]) f1 = f1;

551 
} else {

552 
/* noise coding if subband_coef_index[i] == 0 */

553 
f1 = dither_tab[index]; 
554 
if (av_random(&q>random_state) < 0x80000000) f1 = f1; 
555 
} 
556 
mlt_p[i] = f1 * q>rootpow2tab[quant_index+63];

557 
} 
558 
} 
559 
/**

560 
* Unpack the subband_coef_index and subband_coef_sign vectors.

561 
*

562 
* @param q pointer to the COOKContext

563 
* @param category pointer to the category array

564 
* @param subband_coef_index array of indexes to quant_centroid_tab

565 
* @param subband_coef_sign signs of coefficients

566 
*/

567  
568 
static int unpack_SQVH(COOKContext *q, int category, int* subband_coef_index, 
569 
int* subband_coef_sign) {

570 
int i,j;

571 
int vlc, vd ,tmp, result;

572  
573 
vd = vd_tab[category]; 
574 
result = 0;

575 
for(i=0 ; i<vpr_tab[category] ; i++){ 
576 
vlc = get_vlc2(&q>gb, q>sqvh[category].table, q>sqvh[category].bits, 3);

577 
if (q>bits_per_subpacket < get_bits_count(&q>gb)){

578 
vlc = 0;

579 
result = 1;

580 
} 
581 
for(j=vd1 ; j>=0 ; j){ 
582 
tmp = (vlc * invradix_tab[category])/0x100000;

583 
subband_coef_index[vd*i+j] = vlc  tmp * (kmax_tab[category]+1);

584 
vlc = tmp; 
585 
} 
586 
for(j=0 ; j<vd ; j++){ 
587 
if (subband_coef_index[i*vd + j]) {

588 
if(get_bits_count(&q>gb) < q>bits_per_subpacket){

589 
subband_coef_sign[i*vd+j] = get_bits1(&q>gb); 
590 
} else {

591 
result=1;

592 
subband_coef_sign[i*vd+j]=0;

593 
} 
594 
} else {

595 
subband_coef_sign[i*vd+j]=0;

596 
} 
597 
} 
598 
} 
599 
return result;

600 
} 
601  
602  
603 
/**

604 
* Fill the mlt_buffer with mlt coefficients.

605 
*

606 
* @param q pointer to the COOKContext

607 
* @param category pointer to the category array

608 
* @param quant_index_table pointer to the array

609 
* @param mlt_buffer pointer to mlt coefficients

610 
*/

611  
612  
613 
static void decode_vectors(COOKContext* q, int* category, 
614 
int *quant_index_table, float* mlt_buffer){ 
615 
/* A zero in this table means that the subband coefficient is

616 
random noise coded. */

617 
int subband_coef_index[SUBBAND_SIZE];

618 
/* A zero in this table means that the subband coefficient is a

619 
positive multiplicator. */

620 
int subband_coef_sign[SUBBAND_SIZE];

621 
int band, j;

622 
int index=0; 
623  
624 
for(band=0 ; band<q>total_subbands ; band++){ 
625 
index = category[band]; 
626 
if(category[band] < 7){ 
627 
if(unpack_SQVH(q, category[band], subband_coef_index, subband_coef_sign)){

628 
index=7;

629 
for(j=0 ; j<q>total_subbands ; j++) category[band+j]=7; 
630 
} 
631 
} 
632 
if(index==7) { 
633 
memset(subband_coef_index, 0, sizeof(subband_coef_index)); 
634 
memset(subband_coef_sign, 0, sizeof(subband_coef_sign)); 
635 
} 
636 
q>scalar_dequant(q, index, quant_index_table[band], 
637 
subband_coef_index, subband_coef_sign, 
638 
&mlt_buffer[band * SUBBAND_SIZE]); 
639 
} 
640  
641 
if(q>total_subbands*SUBBAND_SIZE >= q>samples_per_channel){

642 
return;

643 
} /* FIXME: should this be removed, or moved into loop above? */

644 
} 
645  
646  
647 
/**

648 
* function for decoding mono data

649 
*

650 
* @param q pointer to the COOKContext

651 
* @param mlt_buffer pointer to mlt coefficients

652 
*/

653  
654 
static void mono_decode(COOKContext *q, float* mlt_buffer) { 
655  
656 
int category_index[128]; 
657 
int quant_index_table[102]; 
658 
int category[128]; 
659  
660 
memset(&category, 0, 128*sizeof(int)); 
661 
memset(&category_index, 0, 128*sizeof(int)); 
662  
663 
decode_envelope(q, quant_index_table); 
664 
q>num_vectors = get_bits(&q>gb,q>log2_numvector_size); 
665 
categorize(q, quant_index_table, category, category_index); 
666 
expand_category(q, category, category_index); 
667 
decode_vectors(q, category, quant_index_table, mlt_buffer); 
668 
} 
669  
670  
671 
/**

672 
* the actual requantization of the timedomain samples

673 
*

674 
* @param q pointer to the COOKContext

675 
* @param buffer pointer to the timedomain buffer

676 
* @param gain_index index for the block multiplier

677 
* @param gain_index_next index for the next block multiplier

678 
*/

679  
680 
static void interpolate_float(COOKContext *q, float* buffer, 
681 
int gain_index, int gain_index_next){ 
682 
int i;

683 
float fc1, fc2;

684 
fc1 = q>pow2tab[gain_index+63];

685  
686 
if(gain_index == gain_index_next){ //static gain 
687 
for(i=0 ; i<q>gain_size_factor ; i++){ 
688 
buffer[i]*=fc1; 
689 
} 
690 
return;

691 
} else { //smooth gain 
692 
fc2 = q>gain_table[11 + (gain_index_nextgain_index)];

693 
for(i=0 ; i<q>gain_size_factor ; i++){ 
694 
buffer[i]*=fc1; 
695 
fc1*=fc2; 
696 
} 
697 
return;

698 
} 
699 
} 
700  
701 
/**

702 
* Apply transform window, overlap buffers.

703 
*

704 
* @param q pointer to the COOKContext

705 
* @param inbuffer pointer to the mltcoefficients

706 
* @param gains_ptr current and previous gains

707 
* @param previous_buffer pointer to the previous buffer to be used for overlapping

708 
*/

709  
710 
static void imlt_window_float (COOKContext *q, float *buffer1, 
711 
cook_gains *gains_ptr, float *previous_buffer)

712 
{ 
713 
const float fc = q>pow2tab[gains_ptr>previous[0] + 63]; 
714 
int i;

715 
/* The weird thing here, is that the two halves of the time domain

716 
* buffer are swapped. Also, the newest data, that we save away for

717 
* next frame, has the wrong sign. Hence the subtraction below.

718 
* Almost sounds like a complex conjugate/reverse data/FFT effect.

719 
*/

720  
721 
/* Apply window and overlap */

722 
for(i = 0; i < q>samples_per_channel; i++){ 
723 
buffer1[i] = buffer1[i] * fc * q>mlt_window[i]  
724 
previous_buffer[i] * q>mlt_window[q>samples_per_channel  1  i];

725 
} 
726 
} 
727  
728 
/**

729 
* The modulated lapped transform, this takes transform coefficients

730 
* and transforms them into timedomain samples.

731 
* Apply transform window, overlap buffers, apply gain profile

732 
* and buffer management.

733 
*

734 
* @param q pointer to the COOKContext

735 
* @param inbuffer pointer to the mltcoefficients

736 
* @param gains_ptr current and previous gains

737 
* @param previous_buffer pointer to the previous buffer to be used for overlapping

738 
*/

739  
740 
static void imlt_gain(COOKContext *q, float *inbuffer, 
741 
cook_gains *gains_ptr, float* previous_buffer)

742 
{ 
743 
float *buffer0 = q>mono_mdct_output;

744 
float *buffer1 = q>mono_mdct_output + q>samples_per_channel;

745 
int i;

746  
747 
/* Inverse modified discrete cosine transform */

748 
q>mdct_ctx.fft.imdct_calc(&q>mdct_ctx, q>mono_mdct_output, 
749 
inbuffer, q>mdct_tmp); 
750  
751 
q>imlt_window (q, buffer1, gains_ptr, previous_buffer); 
752  
753 
/* Apply gain profile */

754 
for (i = 0; i < 8; i++) { 
755 
if (gains_ptr>now[i]  gains_ptr>now[i + 1]) 
756 
q>interpolate(q, &buffer1[q>gain_size_factor * i], 
757 
gains_ptr>now[i], gains_ptr>now[i + 1]);

758 
} 
759  
760 
/* Save away the current to be previous block. */

761 
memcpy(previous_buffer, buffer0, sizeof(float)*q>samples_per_channel); 
762 
} 
763  
764  
765 
/**

766 
* function for getting the jointstereo coupling information

767 
*

768 
* @param q pointer to the COOKContext

769 
* @param decouple_tab decoupling array

770 
*

771 
*/

772  
773 
static void decouple_info(COOKContext *q, int* decouple_tab){ 
774 
int length, i;

775  
776 
if(get_bits1(&q>gb)) {

777 
if(cplband[q>js_subband_start] > cplband[q>subbands1]) return; 
778  
779 
length = cplband[q>subbands1]  cplband[q>js_subband_start] + 1; 
780 
for (i=0 ; i<length ; i++) { 
781 
decouple_tab[cplband[q>js_subband_start] + i] = get_vlc2(&q>gb, q>ccpl.table, q>ccpl.bits, 2);

782 
} 
783 
return;

784 
} 
785  
786 
if(cplband[q>js_subband_start] > cplband[q>subbands1]) return; 
787  
788 
length = cplband[q>subbands1]  cplband[q>js_subband_start] + 1; 
789 
for (i=0 ; i<length ; i++) { 
790 
decouple_tab[cplband[q>js_subband_start] + i] = get_bits(&q>gb, q>js_vlc_bits); 
791 
} 
792 
return;

793 
} 
794  
795 
/*

796 
* function decouples a pair of signals from a single signal via multiplication.

797 
*

798 
* @param q pointer to the COOKContext

799 
* @param subband index of the current subband

800 
* @param f1 multiplier for channel 1 extraction

801 
* @param f2 multiplier for channel 2 extraction

802 
* @param decode_buffer input buffer

803 
* @param mlt_buffer1 pointer to left channel mlt coefficients

804 
* @param mlt_buffer2 pointer to right channel mlt coefficients

805 
*/

806 
static void decouple_float (COOKContext *q, 
807 
int subband,

808 
float f1, float f2, 
809 
float *decode_buffer,

810 
float *mlt_buffer1, float *mlt_buffer2) 
811 
{ 
812 
int j, tmp_idx;

813 
for (j=0 ; j<SUBBAND_SIZE ; j++) { 
814 
tmp_idx = ((q>js_subband_start + subband)*SUBBAND_SIZE)+j; 
815 
mlt_buffer1[SUBBAND_SIZE*subband + j] = f1 * decode_buffer[tmp_idx]; 
816 
mlt_buffer2[SUBBAND_SIZE*subband + j] = f2 * decode_buffer[tmp_idx]; 
817 
} 
818 
} 
819  
820 
/**

821 
* function for decoding joint stereo data

822 
*

823 
* @param q pointer to the COOKContext

824 
* @param mlt_buffer1 pointer to left channel mlt coefficients

825 
* @param mlt_buffer2 pointer to right channel mlt coefficients

826 
*/

827  
828 
static void joint_decode(COOKContext *q, float* mlt_buffer1, 
829 
float* mlt_buffer2) {

830 
int i,j;

831 
int decouple_tab[SUBBAND_SIZE];

832 
float *decode_buffer = q>decode_buffer_0;

833 
int idx, cpl_tmp,tmp_idx;

834 
float f1,f2;

835 
float* cplscale;

836  
837 
memset(decouple_tab, 0, sizeof(decouple_tab)); 
838 
memset(decode_buffer, 0, sizeof(decode_buffer)); 
839  
840 
/* Make sure the buffers are zeroed out. */

841 
memset(mlt_buffer1,0, 1024*sizeof(float)); 
842 
memset(mlt_buffer2,0, 1024*sizeof(float)); 
843 
decouple_info(q, decouple_tab); 
844 
mono_decode(q, decode_buffer); 
845  
846 
/* The two channels are stored interleaved in decode_buffer. */

847 
for (i=0 ; i<q>js_subband_start ; i++) { 
848 
for (j=0 ; j<SUBBAND_SIZE ; j++) { 
849 
mlt_buffer1[i*20+j] = decode_buffer[i*40+j]; 
850 
mlt_buffer2[i*20+j] = decode_buffer[i*40+20+j]; 
851 
} 
852 
} 
853  
854 
/* When we reach js_subband_start (the higher frequencies)

855 
the coefficients are stored in a coupling scheme. */

856 
idx = (1 << q>js_vlc_bits)  1; 
857 
for (i=q>js_subband_start ; i<q>subbands ; i++) {

858 
cpl_tmp = cplband[i]; 
859 
idx =decouple_tab[cpl_tmp]; 
860 
cplscale = q>cplscales[q>js_vlc_bits2]; //choose decoupler table 
861 
f1 = cplscale[decouple_tab[cpl_tmp]]; 
862 
f2 = cplscale[idx1];

863 
q>decouple (q, i, f1, f2, decode_buffer, mlt_buffer1, mlt_buffer2); 
864 
idx = (1 << q>js_vlc_bits)  1; 
865 
} 
866 
} 
867  
868 
/**

869 
* First part of subpacket decoding:

870 
* decode raw stream bytes and read gain info.

871 
*

872 
* @param q pointer to the COOKContext

873 
* @param inbuffer pointer to raw stream data

874 
* @param gain_ptr array of current/prev gain pointers

875 
*/

876  
877 
static inline void 
878 
decode_bytes_and_gain(COOKContext *q, uint8_t *inbuffer, 
879 
cook_gains *gains_ptr) 
880 
{ 
881 
int offset;

882  
883 
offset = decode_bytes(inbuffer, q>decoded_bytes_buffer, 
884 
q>bits_per_subpacket/8);

885 
init_get_bits(&q>gb, q>decoded_bytes_buffer + offset, 
886 
q>bits_per_subpacket); 
887 
decode_gain_info(&q>gb, gains_ptr>now); 
888  
889 
/* Swap current and previous gains */

890 
FFSWAP(int *, gains_ptr>now, gains_ptr>previous);

891 
} 
892  
893 
/**

894 
* Saturate the output signal to signed 16bit integers.

895 
*

896 
* @param q pointer to the COOKContext

897 
* @param chan channel to saturate

898 
* @param out pointer to the output vector

899 
*/

900 
static void 
901 
saturate_output_float (COOKContext *q, int chan, int16_t *out)

902 
{ 
903 
int j;

904 
float *output = q>mono_mdct_output + q>samples_per_channel;

905 
/* Clip and convert floats to 16 bits.

906 
*/

907 
for (j = 0; j < q>samples_per_channel; j++) { 
908 
out[chan + q>nb_channels * j] = 
909 
av_clip(lrintf(output[j]), 32768, 32767); 
910 
} 
911 
} 
912  
913 
/**

914 
* Final part of subpacket decoding:

915 
* Apply modulated lapped transform, gain compensation,

916 
* clip and convert to integer.

917 
*

918 
* @param q pointer to the COOKContext

919 
* @param decode_buffer pointer to the mlt coefficients

920 
* @param gain_ptr array of current/prev gain pointers

921 
* @param previous_buffer pointer to the previous buffer to be used for overlapping

922 
* @param out pointer to the output buffer

923 
* @param chan 0: left or single channel, 1: right channel

924 
*/

925  
926 
static inline void 
927 
mlt_compensate_output(COOKContext *q, float *decode_buffer,

928 
cook_gains *gains, float *previous_buffer,

929 
int16_t *out, int chan)

930 
{ 
931 
imlt_gain(q, decode_buffer, gains, previous_buffer); 
932 
q>saturate_output (q, chan, out); 
933 
} 
934  
935  
936 
/**

937 
* Cook subpacket decoding. This function returns one decoded subpacket,

938 
* usually 1024 samples per channel.

939 
*

940 
* @param q pointer to the COOKContext

941 
* @param inbuffer pointer to the inbuffer

942 
* @param sub_packet_size subpacket size

943 
* @param outbuffer pointer to the outbuffer

944 
*/

945  
946  
947 
static int decode_subpacket(COOKContext *q, uint8_t *inbuffer, 
948 
int sub_packet_size, int16_t *outbuffer) {

949 
/* packet dump */

950 
// for (i=0 ; i<sub_packet_size ; i++) {

951 
// av_log(NULL, AV_LOG_ERROR, "%02x", inbuffer[i]);

952 
// }

953 
// av_log(NULL, AV_LOG_ERROR, "\n");

954  
955 
decode_bytes_and_gain(q, inbuffer, &q>gains1); 
956  
957 
if (q>joint_stereo) {

958 
joint_decode(q, q>decode_buffer_1, q>decode_buffer_2); 
959 
} else {

960 
mono_decode(q, q>decode_buffer_1); 
961  
962 
if (q>nb_channels == 2) { 
963 
decode_bytes_and_gain(q, inbuffer + sub_packet_size/2, &q>gains2);

964 
mono_decode(q, q>decode_buffer_2); 
965 
} 
966 
} 
967  
968 
mlt_compensate_output(q, q>decode_buffer_1, &q>gains1, 
969 
q>mono_previous_buffer1, outbuffer, 0);

970  
971 
if (q>nb_channels == 2) { 
972 
if (q>joint_stereo) {

973 
mlt_compensate_output(q, q>decode_buffer_2, &q>gains1, 
974 
q>mono_previous_buffer2, outbuffer, 1);

975 
} else {

976 
mlt_compensate_output(q, q>decode_buffer_2, &q>gains2, 
977 
q>mono_previous_buffer2, outbuffer, 1);

978 
} 
979 
} 
980 
return q>samples_per_frame * sizeof(int16_t); 
981 
} 
982  
983  
984 
/**

985 
* Cook frame decoding

986 
*

987 
* @param avctx pointer to the AVCodecContext

988 
*/

989  
990 
static int cook_decode_frame(AVCodecContext *avctx, 
991 
void *data, int *data_size, 
992 
uint8_t *buf, int buf_size) {

993 
COOKContext *q = avctx>priv_data; 
994  
995 
if (buf_size < avctx>block_align)

996 
return buf_size;

997  
998 
*data_size = decode_subpacket(q, buf, avctx>block_align, data); 
999  
1000 
/* Discard the first two frames: no valid audio. */

1001 
if (avctx>frame_number < 2) *data_size = 0; 
1002  
1003 
return avctx>block_align;

1004 
} 
1005  
1006 
#ifdef COOKDEBUG

1007 
static void dump_cook_context(COOKContext *q) 
1008 
{ 
1009 
//int i=0;

1010 
#define PRINT(a,b) av_log(NULL,AV_LOG_ERROR," %s = %d\n", a, b); 
1011 
av_log(NULL,AV_LOG_ERROR,"COOKextradata\n"); 
1012 
av_log(NULL,AV_LOG_ERROR,"cookversion=%x\n",q>cookversion); 
1013 
if (q>cookversion > STEREO) {

1014 
PRINT("js_subband_start",q>js_subband_start);

1015 
PRINT("js_vlc_bits",q>js_vlc_bits);

1016 
} 
1017 
av_log(NULL,AV_LOG_ERROR,"COOKContext\n"); 
1018 
PRINT("nb_channels",q>nb_channels);

1019 
PRINT("bit_rate",q>bit_rate);

1020 
PRINT("sample_rate",q>sample_rate);

1021 
PRINT("samples_per_channel",q>samples_per_channel);

1022 
PRINT("samples_per_frame",q>samples_per_frame);

1023 
PRINT("subbands",q>subbands);

1024 
PRINT("random_state",q>random_state);

1025 
PRINT("js_subband_start",q>js_subband_start);

1026 
PRINT("log2_numvector_size",q>log2_numvector_size);

1027 
PRINT("numvector_size",q>numvector_size);

1028 
PRINT("total_subbands",q>total_subbands);

1029 
} 
1030 
#endif

1031  
1032 
/**

1033 
* Cook initialization

1034 
*

1035 
* @param avctx pointer to the AVCodecContext

1036 
*/

1037  
1038 
static int cook_decode_init(AVCodecContext *avctx) 
1039 
{ 
1040 
COOKContext *q = avctx>priv_data; 
1041 
uint8_t *edata_ptr = avctx>extradata; 
1042  
1043 
/* Take care of the codec specific extradata. */

1044 
if (avctx>extradata_size <= 0) { 
1045 
av_log(avctx,AV_LOG_ERROR,"Necessary extradata missing!\n");

1046 
return 1; 
1047 
} else {

1048 
/* 8 for mono, 16 for stereo, ? for multichannel

1049 
Swap to right endianness so we don't need to care later on. */

1050 
av_log(avctx,AV_LOG_DEBUG,"codecdata_length=%d\n",avctx>extradata_size);

1051 
if (avctx>extradata_size >= 8){ 
1052 
q>cookversion = bytestream_get_be32(&edata_ptr); 
1053 
q>samples_per_frame = bytestream_get_be16(&edata_ptr); 
1054 
q>subbands = bytestream_get_be16(&edata_ptr); 
1055 
} 
1056 
if (avctx>extradata_size >= 16){ 
1057 
bytestream_get_be32(&edata_ptr); //Unknown unused

1058 
q>js_subband_start = bytestream_get_be16(&edata_ptr); 
1059 
q>js_vlc_bits = bytestream_get_be16(&edata_ptr); 
1060 
} 
1061 
} 
1062  
1063 
/* Take data from the AVCodecContext (RM container). */

1064 
q>sample_rate = avctx>sample_rate; 
1065 
q>nb_channels = avctx>channels; 
1066 
q>bit_rate = avctx>bit_rate; 
1067  
1068 
/* Initialize RNG. */

1069 
av_init_random(1, &q>random_state);

1070  
1071 
/* Initialize extradata related variables. */

1072 
q>samples_per_channel = q>samples_per_frame / q>nb_channels; 
1073 
q>bits_per_subpacket = avctx>block_align * 8;

1074  
1075 
/* Initialize default data states. */

1076 
q>log2_numvector_size = 5;

1077 
q>total_subbands = q>subbands; 
1078  
1079 
/* Initialize versiondependent variables */

1080 
av_log(NULL,AV_LOG_DEBUG,"q>cookversion=%x\n",q>cookversion); 
1081 
q>joint_stereo = 0;

1082 
switch (q>cookversion) {

1083 
case MONO:

1084 
if (q>nb_channels != 1) { 
1085 
av_log(avctx,AV_LOG_ERROR,"Container channels != 1, report sample!\n");

1086 
return 1; 
1087 
} 
1088 
av_log(avctx,AV_LOG_DEBUG,"MONO\n");

1089 
break;

1090 
case STEREO:

1091 
if (q>nb_channels != 1) { 
1092 
q>bits_per_subpacket = q>bits_per_subpacket/2;

1093 
} 
1094 
av_log(avctx,AV_LOG_DEBUG,"STEREO\n");

1095 
break;

1096 
case JOINT_STEREO:

1097 
if (q>nb_channels != 2) { 
1098 
av_log(avctx,AV_LOG_ERROR,"Container channels != 2, report sample!\n");

1099 
return 1; 
1100 
} 
1101 
av_log(avctx,AV_LOG_DEBUG,"JOINT_STEREO\n");

1102 
if (avctx>extradata_size >= 16){ 
1103 
q>total_subbands = q>subbands + q>js_subband_start; 
1104 
q>joint_stereo = 1;

1105 
} 
1106 
if (q>samples_per_channel > 256) { 
1107 
q>log2_numvector_size = 6;

1108 
} 
1109 
if (q>samples_per_channel > 512) { 
1110 
q>log2_numvector_size = 7;

1111 
} 
1112 
break;

1113 
case MC_COOK:

1114 
av_log(avctx,AV_LOG_ERROR,"MC_COOK not supported!\n");

1115 
return 1; 
1116 
break;

1117 
default:

1118 
av_log(avctx,AV_LOG_ERROR,"Unknown Cook version, report sample!\n");

1119 
return 1; 
1120 
break;

1121 
} 
1122  
1123 
/* Initialize variable relations */

1124 
q>numvector_size = (1 << q>log2_numvector_size);

1125  
1126 
/* Generate tables */

1127 
init_rootpow2table(q); 
1128 
init_pow2table(q); 
1129 
init_gain_table(q); 
1130 
init_cplscales_table(q); 
1131  
1132 
if (init_cook_vlc_tables(q) != 0) 
1133 
return 1; 
1134  
1135  
1136 
if(avctx>block_align >= UINT_MAX/2) 
1137 
return 1; 
1138  
1139 
/* Pad the databuffer with:

1140 
DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(),

1141 
FF_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */

1142 
if (q>nb_channels==2 && q>joint_stereo==0) { 
1143 
q>decoded_bytes_buffer = 
1144 
av_mallocz(avctx>block_align/2

1145 
+ DECODE_BYTES_PAD2(avctx>block_align/2)

1146 
+ FF_INPUT_BUFFER_PADDING_SIZE); 
1147 
} else {

1148 
q>decoded_bytes_buffer = 
1149 
av_mallocz(avctx>block_align 
1150 
+ DECODE_BYTES_PAD1(avctx>block_align) 
1151 
+ FF_INPUT_BUFFER_PADDING_SIZE); 
1152 
} 
1153 
if (q>decoded_bytes_buffer == NULL) 
1154 
return 1; 
1155  
1156 
q>gains1.now = q>gain_1; 
1157 
q>gains1.previous = q>gain_2; 
1158 
q>gains2.now = q>gain_3; 
1159 
q>gains2.previous = q>gain_4; 
1160  
1161 
/* Initialize transform. */

1162 
if ( init_cook_mlt(q) != 0 ) 
1163 
return 1; 
1164  
1165 
/* Initialize COOK signal arithmetic handling */

1166 
if (1) { 
1167 
q>scalar_dequant = scalar_dequant_float; 
1168 
q>decouple = decouple_float; 
1169 
q>imlt_window = imlt_window_float; 
1170 
q>interpolate = interpolate_float; 
1171 
q>saturate_output = saturate_output_float; 
1172 
} 
1173  
1174 
/* Try to catch some obviously faulty streams, othervise it might be exploitable */

1175 
if (q>total_subbands > 53) { 
1176 
av_log(avctx,AV_LOG_ERROR,"total_subbands > 53, report sample!\n");

1177 
return 1; 
1178 
} 
1179 
if (q>subbands > 50) { 
1180 
av_log(avctx,AV_LOG_ERROR,"subbands > 50, report sample!\n");

1181 
return 1; 
1182 
} 
1183 
if ((q>samples_per_channel == 256)  (q>samples_per_channel == 512)  (q>samples_per_channel == 1024)) { 
1184 
} else {

1185 
av_log(avctx,AV_LOG_ERROR,"unknown amount of samples_per_channel = %d, report sample!\n",q>samples_per_channel);

1186 
return 1; 
1187 
} 
1188 
if ((q>js_vlc_bits > 6)  (q>js_vlc_bits < 0)) { 
1189 
av_log(avctx,AV_LOG_ERROR,"q>js_vlc_bits = %d, only >= 0 and <= 6 allowed!\n",q>js_vlc_bits);

1190 
return 1; 
1191 
} 
1192  
1193 
#ifdef COOKDEBUG

1194 
dump_cook_context(q); 
1195 
#endif

1196 
return 0; 
1197 
} 
1198  
1199  
1200 
AVCodec cook_decoder = 
1201 
{ 
1202 
.name = "cook",

1203 
.type = CODEC_TYPE_AUDIO, 
1204 
.id = CODEC_ID_COOK, 
1205 
.priv_data_size = sizeof(COOKContext),

1206 
.init = cook_decode_init, 
1207 
.close = cook_decode_close, 
1208 
.decode = cook_decode_frame, 
1209 
}; 