blob: 53cb83852e3e23b93267add4471b252deaab9e63
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 02110-1301 USA |
21 | */ |
22 | |
23 | /** |
24 | * @file |
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 "libavutil/channel_layout.h" |
46 | #include "libavutil/lfg.h" |
47 | |
48 | #include "audiodsp.h" |
49 | #include "avcodec.h" |
50 | #include "get_bits.h" |
51 | #include "bytestream.h" |
52 | #include "fft.h" |
53 | #include "internal.h" |
54 | #include "sinewin.h" |
55 | #include "unary.h" |
56 | |
57 | #include "cookdata.h" |
58 | |
59 | /* the different Cook versions */ |
60 | #define MONO 0x1000001 |
61 | #define STEREO 0x1000002 |
62 | #define JOINT_STEREO 0x1000003 |
63 | #define MC_COOK 0x2000000 // multichannel Cook, not supported |
64 | |
65 | #define SUBBAND_SIZE 20 |
66 | #define MAX_SUBPACKETS 5 |
67 | |
68 | typedef struct cook_gains { |
69 | int *now; |
70 | int *previous; |
71 | } cook_gains; |
72 | |
73 | typedef struct COOKSubpacket { |
74 | int ch_idx; |
75 | int size; |
76 | int num_channels; |
77 | int cookversion; |
78 | int subbands; |
79 | int js_subband_start; |
80 | int js_vlc_bits; |
81 | int samples_per_channel; |
82 | int log2_numvector_size; |
83 | unsigned int channel_mask; |
84 | VLC channel_coupling; |
85 | int joint_stereo; |
86 | int bits_per_subpacket; |
87 | int bits_per_subpdiv; |
88 | int total_subbands; |
89 | int numvector_size; // 1 << log2_numvector_size; |
90 | |
91 | float mono_previous_buffer1[1024]; |
92 | float mono_previous_buffer2[1024]; |
93 | |
94 | cook_gains gains1; |
95 | cook_gains gains2; |
96 | int gain_1[9]; |
97 | int gain_2[9]; |
98 | int gain_3[9]; |
99 | int gain_4[9]; |
100 | } COOKSubpacket; |
101 | |
102 | typedef struct cook { |
103 | /* |
104 | * The following 5 functions provide the lowlevel arithmetic on |
105 | * the internal audio buffers. |
106 | */ |
107 | void (*scalar_dequant)(struct cook *q, int index, int quant_index, |
108 | int *subband_coef_index, int *subband_coef_sign, |
109 | float *mlt_p); |
110 | |
111 | void (*decouple)(struct cook *q, |
112 | COOKSubpacket *p, |
113 | int subband, |
114 | float f1, float f2, |
115 | float *decode_buffer, |
116 | float *mlt_buffer1, float *mlt_buffer2); |
117 | |
118 | void (*imlt_window)(struct cook *q, float *buffer1, |
119 | cook_gains *gains_ptr, float *previous_buffer); |
120 | |
121 | void (*interpolate)(struct cook *q, float *buffer, |
122 | int gain_index, int gain_index_next); |
123 | |
124 | void (*saturate_output)(struct cook *q, float *out); |
125 | |
126 | AVCodecContext* avctx; |
127 | AudioDSPContext adsp; |
128 | GetBitContext gb; |
129 | /* stream data */ |
130 | int num_vectors; |
131 | int samples_per_channel; |
132 | /* states */ |
133 | AVLFG random_state; |
134 | int discarded_packets; |
135 | |
136 | /* transform data */ |
137 | FFTContext mdct_ctx; |
138 | float* mlt_window; |
139 | |
140 | /* VLC data */ |
141 | VLC envelope_quant_index[13]; |
142 | VLC sqvh[7]; // scalar quantization |
143 | |
144 | /* generate tables and related variables */ |
145 | int gain_size_factor; |
146 | float gain_table[23]; |
147 | |
148 | /* data buffers */ |
149 | |
150 | uint8_t* decoded_bytes_buffer; |
151 | DECLARE_ALIGNED(32, float, mono_mdct_output)[2048]; |
152 | float decode_buffer_1[1024]; |
153 | float decode_buffer_2[1024]; |
154 | float decode_buffer_0[1060]; /* static allocation for joint decode */ |
155 | |
156 | const float *cplscales[5]; |
157 | int num_subpackets; |
158 | COOKSubpacket subpacket[MAX_SUBPACKETS]; |
159 | } COOKContext; |
160 | |
161 | static float pow2tab[127]; |
162 | static float rootpow2tab[127]; |
163 | |
164 | /*************** init functions ***************/ |
165 | |
166 | /* table generator */ |
167 | static av_cold void init_pow2table(void) |
168 | { |
169 | /* fast way of computing 2^i and 2^(0.5*i) for -63 <= i < 64 */ |
170 | int i; |
171 | static const float exp2_tab[2] = {1, M_SQRT2}; |
172 | float exp2_val = powf(2, -63); |
173 | float root_val = powf(2, -32); |
174 | for (i = -63; i < 64; i++) { |
175 | if (!(i & 1)) |
176 | root_val *= 2; |
177 | pow2tab[63 + i] = exp2_val; |
178 | rootpow2tab[63 + i] = root_val * exp2_tab[i & 1]; |
179 | exp2_val *= 2; |
180 | } |
181 | } |
182 | |
183 | /* table generator */ |
184 | static av_cold void init_gain_table(COOKContext *q) |
185 | { |
186 | int i; |
187 | q->gain_size_factor = q->samples_per_channel / 8; |
188 | for (i = 0; i < 23; i++) |
189 | q->gain_table[i] = pow(pow2tab[i + 52], |
190 | (1.0 / (double) q->gain_size_factor)); |
191 | } |
192 | |
193 | |
194 | static av_cold int init_cook_vlc_tables(COOKContext *q) |
195 | { |
196 | int i, result; |
197 | |
198 | result = 0; |
199 | for (i = 0; i < 13; i++) { |
200 | result |= init_vlc(&q->envelope_quant_index[i], 9, 24, |
201 | envelope_quant_index_huffbits[i], 1, 1, |
202 | envelope_quant_index_huffcodes[i], 2, 2, 0); |
203 | } |
204 | av_log(q->avctx, AV_LOG_DEBUG, "sqvh VLC init\n"); |
205 | for (i = 0; i < 7; i++) { |
206 | result |= init_vlc(&q->sqvh[i], vhvlcsize_tab[i], vhsize_tab[i], |
207 | cvh_huffbits[i], 1, 1, |
208 | cvh_huffcodes[i], 2, 2, 0); |
209 | } |
210 | |
211 | for (i = 0; i < q->num_subpackets; i++) { |
212 | if (q->subpacket[i].joint_stereo == 1) { |
213 | result |= init_vlc(&q->subpacket[i].channel_coupling, 6, |
214 | (1 << q->subpacket[i].js_vlc_bits) - 1, |
215 | ccpl_huffbits[q->subpacket[i].js_vlc_bits - 2], 1, 1, |
216 | ccpl_huffcodes[q->subpacket[i].js_vlc_bits - 2], 2, 2, 0); |
217 | av_log(q->avctx, AV_LOG_DEBUG, "subpacket %i Joint-stereo VLC used.\n", i); |
218 | } |
219 | } |
220 | |
221 | av_log(q->avctx, AV_LOG_DEBUG, "VLC tables initialized.\n"); |
222 | return result; |
223 | } |
224 | |
225 | static av_cold int init_cook_mlt(COOKContext *q) |
226 | { |
227 | int j, ret; |
228 | int mlt_size = q->samples_per_channel; |
229 | |
230 | if ((q->mlt_window = av_malloc_array(mlt_size, sizeof(*q->mlt_window))) == 0) |
231 | return AVERROR(ENOMEM); |
232 | |
233 | /* Initialize the MLT window: simple sine window. */ |
234 | ff_sine_window_init(q->mlt_window, mlt_size); |
235 | for (j = 0; j < mlt_size; j++) |
236 | q->mlt_window[j] *= sqrt(2.0 / q->samples_per_channel); |
237 | |
238 | /* Initialize the MDCT. */ |
239 | if ((ret = ff_mdct_init(&q->mdct_ctx, av_log2(mlt_size) + 1, 1, 1.0 / 32768.0))) { |
240 | av_freep(&q->mlt_window); |
241 | return ret; |
242 | } |
243 | av_log(q->avctx, AV_LOG_DEBUG, "MDCT initialized, order = %d.\n", |
244 | av_log2(mlt_size) + 1); |
245 | |
246 | return 0; |
247 | } |
248 | |
249 | static av_cold void init_cplscales_table(COOKContext *q) |
250 | { |
251 | int i; |
252 | for (i = 0; i < 5; i++) |
253 | q->cplscales[i] = cplscales[i]; |
254 | } |
255 | |
256 | /*************** init functions end ***********/ |
257 | |
258 | #define DECODE_BYTES_PAD1(bytes) (3 - ((bytes) + 3) % 4) |
259 | #define DECODE_BYTES_PAD2(bytes) ((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes))) |
260 | |
261 | /** |
262 | * Cook indata decoding, every 32 bits are XORed with 0x37c511f2. |
263 | * Why? No idea, some checksum/error detection method maybe. |
264 | * |
265 | * Out buffer size: extra bytes are needed to cope with |
266 | * padding/misalignment. |
267 | * Subpackets passed to the decoder can contain two, consecutive |
268 | * half-subpackets, of identical but arbitrary size. |
269 | * 1234 1234 1234 1234 extraA extraB |
270 | * Case 1: AAAA BBBB 0 0 |
271 | * Case 2: AAAA ABBB BB-- 3 3 |
272 | * Case 3: AAAA AABB BBBB 2 2 |
273 | * Case 4: AAAA AAAB BBBB BB-- 1 5 |
274 | * |
275 | * Nice way to waste CPU cycles. |
276 | * |
277 | * @param inbuffer pointer to byte array of indata |
278 | * @param out pointer to byte array of outdata |
279 | * @param bytes number of bytes |
280 | */ |
281 | static inline int decode_bytes(const uint8_t *inbuffer, uint8_t *out, int bytes) |
282 | { |
283 | static const uint32_t tab[4] = { |
284 | AV_BE2NE32C(0x37c511f2u), AV_BE2NE32C(0xf237c511u), |
285 | AV_BE2NE32C(0x11f237c5u), AV_BE2NE32C(0xc511f237u), |
286 | }; |
287 | int i, off; |
288 | uint32_t c; |
289 | const uint32_t *buf; |
290 | uint32_t *obuf = (uint32_t *) out; |
291 | /* FIXME: 64 bit platforms would be able to do 64 bits at a time. |
292 | * I'm too lazy though, should be something like |
293 | * for (i = 0; i < bitamount / 64; i++) |
294 | * (int64_t) out[i] = 0x37c511f237c511f2 ^ av_be2ne64(int64_t) in[i]); |
295 | * Buffer alignment needs to be checked. */ |
296 | |
297 | off = (intptr_t) inbuffer & 3; |
298 | buf = (const uint32_t *) (inbuffer - off); |
299 | c = tab[off]; |
300 | bytes += 3 + off; |
301 | for (i = 0; i < bytes / 4; i++) |
302 | obuf[i] = c ^ buf[i]; |
303 | |
304 | return off; |
305 | } |
306 | |
307 | static av_cold int cook_decode_close(AVCodecContext *avctx) |
308 | { |
309 | int i; |
310 | COOKContext *q = avctx->priv_data; |
311 | av_log(avctx, AV_LOG_DEBUG, "Deallocating memory.\n"); |
312 | |
313 | /* Free allocated memory buffers. */ |
314 | av_freep(&q->mlt_window); |
315 | av_freep(&q->decoded_bytes_buffer); |
316 | |
317 | /* Free the transform. */ |
318 | ff_mdct_end(&q->mdct_ctx); |
319 | |
320 | /* Free the VLC tables. */ |
321 | for (i = 0; i < 13; i++) |
322 | ff_free_vlc(&q->envelope_quant_index[i]); |
323 | for (i = 0; i < 7; i++) |
324 | ff_free_vlc(&q->sqvh[i]); |
325 | for (i = 0; i < q->num_subpackets; i++) |
326 | ff_free_vlc(&q->subpacket[i].channel_coupling); |
327 | |
328 | av_log(avctx, AV_LOG_DEBUG, "Memory deallocated.\n"); |
329 | |
330 | return 0; |
331 | } |
332 | |
333 | /** |
334 | * Fill the gain array for the timedomain quantization. |
335 | * |
336 | * @param gb pointer to the GetBitContext |
337 | * @param gaininfo array[9] of gain indexes |
338 | */ |
339 | static void decode_gain_info(GetBitContext *gb, int *gaininfo) |
340 | { |
341 | int i, n; |
342 | |
343 | n = get_unary(gb, 0, get_bits_left(gb)); // amount of elements*2 to update |
344 | |
345 | i = 0; |
346 | while (n--) { |
347 | int index = get_bits(gb, 3); |
348 | int gain = get_bits1(gb) ? get_bits(gb, 4) - 7 : -1; |
349 | |
350 | while (i <= index) |
351 | gaininfo[i++] = gain; |
352 | } |
353 | while (i <= 8) |
354 | gaininfo[i++] = 0; |
355 | } |
356 | |
357 | /** |
358 | * Create the quant index table needed for the envelope. |
359 | * |
360 | * @param q pointer to the COOKContext |
361 | * @param quant_index_table pointer to the array |
362 | */ |
363 | static int decode_envelope(COOKContext *q, COOKSubpacket *p, |
364 | int *quant_index_table) |
365 | { |
366 | int i, j, vlc_index; |
367 | |
368 | quant_index_table[0] = get_bits(&q->gb, 6) - 6; // This is used later in categorize |
369 | |
370 | for (i = 1; i < p->total_subbands; i++) { |
371 | vlc_index = i; |
372 | if (i >= p->js_subband_start * 2) { |
373 | vlc_index -= p->js_subband_start; |
374 | } else { |
375 | vlc_index /= 2; |
376 | if (vlc_index < 1) |
377 | vlc_index = 1; |
378 | } |
379 | if (vlc_index > 13) |
380 | vlc_index = 13; // the VLC tables >13 are identical to No. 13 |
381 | |
382 | j = get_vlc2(&q->gb, q->envelope_quant_index[vlc_index - 1].table, |
383 | q->envelope_quant_index[vlc_index - 1].bits, 2); |
384 | quant_index_table[i] = quant_index_table[i - 1] + j - 12; // differential encoding |
385 | if (quant_index_table[i] > 63 || quant_index_table[i] < -63) { |
386 | av_log(q->avctx, AV_LOG_ERROR, |
387 | "Invalid quantizer %d at position %d, outside [-63, 63] range\n", |
388 | quant_index_table[i], i); |
389 | return AVERROR_INVALIDDATA; |
390 | } |
391 | } |
392 | |
393 | return 0; |
394 | } |
395 | |
396 | /** |
397 | * Calculate the category and category_index vector. |
398 | * |
399 | * @param q pointer to the COOKContext |
400 | * @param quant_index_table pointer to the array |
401 | * @param category pointer to the category array |
402 | * @param category_index pointer to the category_index array |
403 | */ |
404 | static void categorize(COOKContext *q, COOKSubpacket *p, const int *quant_index_table, |
405 | int *category, int *category_index) |
406 | { |
407 | int exp_idx, bias, tmpbias1, tmpbias2, bits_left, num_bits, index, v, i, j; |
408 | int exp_index2[102] = { 0 }; |
409 | int exp_index1[102] = { 0 }; |
410 | |
411 | int tmp_categorize_array[128 * 2] = { 0 }; |
412 | int tmp_categorize_array1_idx = p->numvector_size; |
413 | int tmp_categorize_array2_idx = p->numvector_size; |
414 | |
415 | bits_left = p->bits_per_subpacket - get_bits_count(&q->gb); |
416 | |
417 | if (bits_left > q->samples_per_channel) |
418 | bits_left = q->samples_per_channel + |
419 | ((bits_left - q->samples_per_channel) * 5) / 8; |
420 | |
421 | bias = -32; |
422 | |
423 | /* Estimate bias. */ |
424 | for (i = 32; i > 0; i = i / 2) { |
425 | num_bits = 0; |
426 | index = 0; |
427 | for (j = p->total_subbands; j > 0; j--) { |
428 | exp_idx = av_clip_uintp2((i - quant_index_table[index] + bias) / 2, 3); |
429 | index++; |
430 | num_bits += expbits_tab[exp_idx]; |
431 | } |
432 | if (num_bits >= bits_left - 32) |
433 | bias += i; |
434 | } |
435 | |
436 | /* Calculate total number of bits. */ |
437 | num_bits = 0; |
438 | for (i = 0; i < p->total_subbands; i++) { |
439 | exp_idx = av_clip_uintp2((bias - quant_index_table[i]) / 2, 3); |
440 | num_bits += expbits_tab[exp_idx]; |
441 | exp_index1[i] = exp_idx; |
442 | exp_index2[i] = exp_idx; |
443 | } |
444 | tmpbias1 = tmpbias2 = num_bits; |
445 | |
446 | for (j = 1; j < p->numvector_size; j++) { |
447 | if (tmpbias1 + tmpbias2 > 2 * bits_left) { /* ---> */ |
448 | int max = -999999; |
449 | index = -1; |
450 | for (i = 0; i < p->total_subbands; i++) { |
451 | if (exp_index1[i] < 7) { |
452 | v = (-2 * exp_index1[i]) - quant_index_table[i] + bias; |
453 | if (v >= max) { |
454 | max = v; |
455 | index = i; |
456 | } |
457 | } |
458 | } |
459 | if (index == -1) |
460 | break; |
461 | tmp_categorize_array[tmp_categorize_array1_idx++] = index; |
462 | tmpbias1 -= expbits_tab[exp_index1[index]] - |
463 | expbits_tab[exp_index1[index] + 1]; |
464 | ++exp_index1[index]; |
465 | } else { /* <--- */ |
466 | int min = 999999; |
467 | index = -1; |
468 | for (i = 0; i < p->total_subbands; i++) { |
469 | if (exp_index2[i] > 0) { |
470 | v = (-2 * exp_index2[i]) - quant_index_table[i] + bias; |
471 | if (v < min) { |
472 | min = v; |
473 | index = i; |
474 | } |
475 | } |
476 | } |
477 | if (index == -1) |
478 | break; |
479 | tmp_categorize_array[--tmp_categorize_array2_idx] = index; |
480 | tmpbias2 -= expbits_tab[exp_index2[index]] - |
481 | expbits_tab[exp_index2[index] - 1]; |
482 | --exp_index2[index]; |
483 | } |
484 | } |
485 | |
486 | for (i = 0; i < p->total_subbands; i++) |
487 | category[i] = exp_index2[i]; |
488 | |
489 | for (i = 0; i < p->numvector_size - 1; i++) |
490 | category_index[i] = tmp_categorize_array[tmp_categorize_array2_idx++]; |
491 | } |
492 | |
493 | |
494 | /** |
495 | * Expand the category vector. |
496 | * |
497 | * @param q pointer to the COOKContext |
498 | * @param category pointer to the category array |
499 | * @param category_index pointer to the category_index array |
500 | */ |
501 | static inline void expand_category(COOKContext *q, int *category, |
502 | int *category_index) |
503 | { |
504 | int i; |
505 | for (i = 0; i < q->num_vectors; i++) |
506 | { |
507 | int idx = category_index[i]; |
508 | if (++category[idx] >= FF_ARRAY_ELEMS(dither_tab)) |
509 | --category[idx]; |
510 | } |
511 | } |
512 | |
513 | /** |
514 | * The real requantization of the mltcoefs |
515 | * |
516 | * @param q pointer to the COOKContext |
517 | * @param index index |
518 | * @param quant_index quantisation index |
519 | * @param subband_coef_index array of indexes to quant_centroid_tab |
520 | * @param subband_coef_sign signs of coefficients |
521 | * @param mlt_p pointer into the mlt buffer |
522 | */ |
523 | static void scalar_dequant_float(COOKContext *q, int index, int quant_index, |
524 | int *subband_coef_index, int *subband_coef_sign, |
525 | float *mlt_p) |
526 | { |
527 | int i; |
528 | float f1; |
529 | |
530 | for (i = 0; i < SUBBAND_SIZE; i++) { |
531 | if (subband_coef_index[i]) { |
532 | f1 = quant_centroid_tab[index][subband_coef_index[i]]; |
533 | if (subband_coef_sign[i]) |
534 | f1 = -f1; |
535 | } else { |
536 | /* noise coding if subband_coef_index[i] == 0 */ |
537 | f1 = dither_tab[index]; |
538 | if (av_lfg_get(&q->random_state) < 0x80000000) |
539 | f1 = -f1; |
540 | } |
541 | mlt_p[i] = f1 * rootpow2tab[quant_index + 63]; |
542 | } |
543 | } |
544 | /** |
545 | * Unpack the subband_coef_index and subband_coef_sign vectors. |
546 | * |
547 | * @param q pointer to the COOKContext |
548 | * @param category pointer to the category array |
549 | * @param subband_coef_index array of indexes to quant_centroid_tab |
550 | * @param subband_coef_sign signs of coefficients |
551 | */ |
552 | static int unpack_SQVH(COOKContext *q, COOKSubpacket *p, int category, |
553 | int *subband_coef_index, int *subband_coef_sign) |
554 | { |
555 | int i, j; |
556 | int vlc, vd, tmp, result; |
557 | |
558 | vd = vd_tab[category]; |
559 | result = 0; |
560 | for (i = 0; i < vpr_tab[category]; i++) { |
561 | vlc = get_vlc2(&q->gb, q->sqvh[category].table, q->sqvh[category].bits, 3); |
562 | if (p->bits_per_subpacket < get_bits_count(&q->gb)) { |
563 | vlc = 0; |
564 | result = 1; |
565 | } |
566 | for (j = vd - 1; j >= 0; j--) { |
567 | tmp = (vlc * invradix_tab[category]) / 0x100000; |
568 | subband_coef_index[vd * i + j] = vlc - tmp * (kmax_tab[category] + 1); |
569 | vlc = tmp; |
570 | } |
571 | for (j = 0; j < vd; j++) { |
572 | if (subband_coef_index[i * vd + j]) { |
573 | if (get_bits_count(&q->gb) < p->bits_per_subpacket) { |
574 | subband_coef_sign[i * vd + j] = get_bits1(&q->gb); |
575 | } else { |
576 | result = 1; |
577 | subband_coef_sign[i * vd + j] = 0; |
578 | } |
579 | } else { |
580 | subband_coef_sign[i * vd + j] = 0; |
581 | } |
582 | } |
583 | } |
584 | return result; |
585 | } |
586 | |
587 | |
588 | /** |
589 | * Fill the mlt_buffer with mlt coefficients. |
590 | * |
591 | * @param q pointer to the COOKContext |
592 | * @param category pointer to the category array |
593 | * @param quant_index_table pointer to the array |
594 | * @param mlt_buffer pointer to mlt coefficients |
595 | */ |
596 | static void decode_vectors(COOKContext *q, COOKSubpacket *p, int *category, |
597 | int *quant_index_table, float *mlt_buffer) |
598 | { |
599 | /* A zero in this table means that the subband coefficient is |
600 | random noise coded. */ |
601 | int subband_coef_index[SUBBAND_SIZE]; |
602 | /* A zero in this table means that the subband coefficient is a |
603 | positive multiplicator. */ |
604 | int subband_coef_sign[SUBBAND_SIZE]; |
605 | int band, j; |
606 | int index = 0; |
607 | |
608 | for (band = 0; band < p->total_subbands; band++) { |
609 | index = category[band]; |
610 | if (category[band] < 7) { |
611 | if (unpack_SQVH(q, p, category[band], subband_coef_index, subband_coef_sign)) { |
612 | index = 7; |
613 | for (j = 0; j < p->total_subbands; j++) |
614 | category[band + j] = 7; |
615 | } |
616 | } |
617 | if (index >= 7) { |
618 | memset(subband_coef_index, 0, sizeof(subband_coef_index)); |
619 | memset(subband_coef_sign, 0, sizeof(subband_coef_sign)); |
620 | } |
621 | q->scalar_dequant(q, index, quant_index_table[band], |
622 | subband_coef_index, subband_coef_sign, |
623 | &mlt_buffer[band * SUBBAND_SIZE]); |
624 | } |
625 | |
626 | /* FIXME: should this be removed, or moved into loop above? */ |
627 | if (p->total_subbands * SUBBAND_SIZE >= q->samples_per_channel) |
628 | return; |
629 | } |
630 | |
631 | |
632 | static int mono_decode(COOKContext *q, COOKSubpacket *p, float *mlt_buffer) |
633 | { |
634 | int category_index[128] = { 0 }; |
635 | int category[128] = { 0 }; |
636 | int quant_index_table[102]; |
637 | int res, i; |
638 | |
639 | if ((res = decode_envelope(q, p, quant_index_table)) < 0) |
640 | return res; |
641 | q->num_vectors = get_bits(&q->gb, p->log2_numvector_size); |
642 | categorize(q, p, quant_index_table, category, category_index); |
643 | expand_category(q, category, category_index); |
644 | for (i=0; i<p->total_subbands; i++) { |
645 | if (category[i] > 7) |
646 | return AVERROR_INVALIDDATA; |
647 | } |
648 | decode_vectors(q, p, category, quant_index_table, mlt_buffer); |
649 | |
650 | return 0; |
651 | } |
652 | |
653 | |
654 | /** |
655 | * the actual requantization of the timedomain samples |
656 | * |
657 | * @param q pointer to the COOKContext |
658 | * @param buffer pointer to the timedomain buffer |
659 | * @param gain_index index for the block multiplier |
660 | * @param gain_index_next index for the next block multiplier |
661 | */ |
662 | static void interpolate_float(COOKContext *q, float *buffer, |
663 | int gain_index, int gain_index_next) |
664 | { |
665 | int i; |
666 | float fc1, fc2; |
667 | fc1 = pow2tab[gain_index + 63]; |
668 | |
669 | if (gain_index == gain_index_next) { // static gain |
670 | for (i = 0; i < q->gain_size_factor; i++) |
671 | buffer[i] *= fc1; |
672 | } else { // smooth gain |
673 | fc2 = q->gain_table[11 + (gain_index_next - gain_index)]; |
674 | for (i = 0; i < q->gain_size_factor; i++) { |
675 | buffer[i] *= fc1; |
676 | fc1 *= fc2; |
677 | } |
678 | } |
679 | } |
680 | |
681 | /** |
682 | * Apply transform window, overlap buffers. |
683 | * |
684 | * @param q pointer to the COOKContext |
685 | * @param inbuffer pointer to the mltcoefficients |
686 | * @param gains_ptr current and previous gains |
687 | * @param previous_buffer pointer to the previous buffer to be used for overlapping |
688 | */ |
689 | static void imlt_window_float(COOKContext *q, float *inbuffer, |
690 | cook_gains *gains_ptr, float *previous_buffer) |
691 | { |
692 | const float fc = pow2tab[gains_ptr->previous[0] + 63]; |
693 | int i; |
694 | /* The weird thing here, is that the two halves of the time domain |
695 | * buffer are swapped. Also, the newest data, that we save away for |
696 | * next frame, has the wrong sign. Hence the subtraction below. |
697 | * Almost sounds like a complex conjugate/reverse data/FFT effect. |
698 | */ |
699 | |
700 | /* Apply window and overlap */ |
701 | for (i = 0; i < q->samples_per_channel; i++) |
702 | inbuffer[i] = inbuffer[i] * fc * q->mlt_window[i] - |
703 | previous_buffer[i] * q->mlt_window[q->samples_per_channel - 1 - i]; |
704 | } |
705 | |
706 | /** |
707 | * The modulated lapped transform, this takes transform coefficients |
708 | * and transforms them into timedomain samples. |
709 | * Apply transform window, overlap buffers, apply gain profile |
710 | * and buffer management. |
711 | * |
712 | * @param q pointer to the COOKContext |
713 | * @param inbuffer pointer to the mltcoefficients |
714 | * @param gains_ptr current and previous gains |
715 | * @param previous_buffer pointer to the previous buffer to be used for overlapping |
716 | */ |
717 | static void imlt_gain(COOKContext *q, float *inbuffer, |
718 | cook_gains *gains_ptr, float *previous_buffer) |
719 | { |
720 | float *buffer0 = q->mono_mdct_output; |
721 | float *buffer1 = q->mono_mdct_output + q->samples_per_channel; |
722 | int i; |
723 | |
724 | /* Inverse modified discrete cosine transform */ |
725 | q->mdct_ctx.imdct_calc(&q->mdct_ctx, q->mono_mdct_output, inbuffer); |
726 | |
727 | q->imlt_window(q, buffer1, gains_ptr, previous_buffer); |
728 | |
729 | /* Apply gain profile */ |
730 | for (i = 0; i < 8; i++) |
731 | if (gains_ptr->now[i] || gains_ptr->now[i + 1]) |
732 | q->interpolate(q, &buffer1[q->gain_size_factor * i], |
733 | gains_ptr->now[i], gains_ptr->now[i + 1]); |
734 | |
735 | /* Save away the current to be previous block. */ |
736 | memcpy(previous_buffer, buffer0, |
737 | q->samples_per_channel * sizeof(*previous_buffer)); |
738 | } |
739 | |
740 | |
741 | /** |
742 | * function for getting the jointstereo coupling information |
743 | * |
744 | * @param q pointer to the COOKContext |
745 | * @param decouple_tab decoupling array |
746 | */ |
747 | static int decouple_info(COOKContext *q, COOKSubpacket *p, int *decouple_tab) |
748 | { |
749 | int i; |
750 | int vlc = get_bits1(&q->gb); |
751 | int start = cplband[p->js_subband_start]; |
752 | int end = cplband[p->subbands - 1]; |
753 | int length = end - start + 1; |
754 | |
755 | if (start > end) |
756 | return 0; |
757 | |
758 | if (vlc) |
759 | for (i = 0; i < length; i++) |
760 | decouple_tab[start + i] = get_vlc2(&q->gb, |
761 | p->channel_coupling.table, |
762 | p->channel_coupling.bits, 2); |
763 | else |
764 | for (i = 0; i < length; i++) { |
765 | int v = get_bits(&q->gb, p->js_vlc_bits); |
766 | if (v == (1<<p->js_vlc_bits)-1) { |
767 | av_log(q->avctx, AV_LOG_ERROR, "decouple value too large\n"); |
768 | return AVERROR_INVALIDDATA; |
769 | } |
770 | decouple_tab[start + i] = v; |
771 | } |
772 | return 0; |
773 | } |
774 | |
775 | /** |
776 | * function decouples a pair of signals from a single signal via multiplication. |
777 | * |
778 | * @param q pointer to the COOKContext |
779 | * @param subband index of the current subband |
780 | * @param f1 multiplier for channel 1 extraction |
781 | * @param f2 multiplier for channel 2 extraction |
782 | * @param decode_buffer input buffer |
783 | * @param mlt_buffer1 pointer to left channel mlt coefficients |
784 | * @param mlt_buffer2 pointer to right channel mlt coefficients |
785 | */ |
786 | static void decouple_float(COOKContext *q, |
787 | COOKSubpacket *p, |
788 | int subband, |
789 | float f1, float f2, |
790 | float *decode_buffer, |
791 | float *mlt_buffer1, float *mlt_buffer2) |
792 | { |
793 | int j, tmp_idx; |
794 | for (j = 0; j < SUBBAND_SIZE; j++) { |
795 | tmp_idx = ((p->js_subband_start + subband) * SUBBAND_SIZE) + j; |
796 | mlt_buffer1[SUBBAND_SIZE * subband + j] = f1 * decode_buffer[tmp_idx]; |
797 | mlt_buffer2[SUBBAND_SIZE * subband + j] = f2 * decode_buffer[tmp_idx]; |
798 | } |
799 | } |
800 | |
801 | /** |
802 | * function for decoding joint stereo data |
803 | * |
804 | * @param q pointer to the COOKContext |
805 | * @param mlt_buffer1 pointer to left channel mlt coefficients |
806 | * @param mlt_buffer2 pointer to right channel mlt coefficients |
807 | */ |
808 | static int joint_decode(COOKContext *q, COOKSubpacket *p, |
809 | float *mlt_buffer_left, float *mlt_buffer_right) |
810 | { |
811 | int i, j, res; |
812 | int decouple_tab[SUBBAND_SIZE] = { 0 }; |
813 | float *decode_buffer = q->decode_buffer_0; |
814 | int idx, cpl_tmp; |
815 | float f1, f2; |
816 | const float *cplscale; |
817 | |
818 | memset(decode_buffer, 0, sizeof(q->decode_buffer_0)); |
819 | |
820 | /* Make sure the buffers are zeroed out. */ |
821 | memset(mlt_buffer_left, 0, 1024 * sizeof(*mlt_buffer_left)); |
822 | memset(mlt_buffer_right, 0, 1024 * sizeof(*mlt_buffer_right)); |
823 | if ((res = decouple_info(q, p, decouple_tab)) < 0) |
824 | return res; |
825 | if ((res = mono_decode(q, p, decode_buffer)) < 0) |
826 | return res; |
827 | /* The two channels are stored interleaved in decode_buffer. */ |
828 | for (i = 0; i < p->js_subband_start; i++) { |
829 | for (j = 0; j < SUBBAND_SIZE; j++) { |
830 | mlt_buffer_left[i * 20 + j] = decode_buffer[i * 40 + j]; |
831 | mlt_buffer_right[i * 20 + j] = decode_buffer[i * 40 + 20 + j]; |
832 | } |
833 | } |
834 | |
835 | /* When we reach js_subband_start (the higher frequencies) |
836 | the coefficients are stored in a coupling scheme. */ |
837 | idx = (1 << p->js_vlc_bits) - 1; |
838 | for (i = p->js_subband_start; i < p->subbands; i++) { |
839 | cpl_tmp = cplband[i]; |
840 | idx -= decouple_tab[cpl_tmp]; |
841 | cplscale = q->cplscales[p->js_vlc_bits - 2]; // choose decoupler table |
842 | f1 = cplscale[decouple_tab[cpl_tmp] + 1]; |
843 | f2 = cplscale[idx]; |
844 | q->decouple(q, p, i, f1, f2, decode_buffer, |
845 | mlt_buffer_left, mlt_buffer_right); |
846 | idx = (1 << p->js_vlc_bits) - 1; |
847 | } |
848 | |
849 | return 0; |
850 | } |
851 | |
852 | /** |
853 | * First part of subpacket decoding: |
854 | * decode raw stream bytes and read gain info. |
855 | * |
856 | * @param q pointer to the COOKContext |
857 | * @param inbuffer pointer to raw stream data |
858 | * @param gains_ptr array of current/prev gain pointers |
859 | */ |
860 | static inline void decode_bytes_and_gain(COOKContext *q, COOKSubpacket *p, |
861 | const uint8_t *inbuffer, |
862 | cook_gains *gains_ptr) |
863 | { |
864 | int offset; |
865 | |
866 | offset = decode_bytes(inbuffer, q->decoded_bytes_buffer, |
867 | p->bits_per_subpacket / 8); |
868 | init_get_bits(&q->gb, q->decoded_bytes_buffer + offset, |
869 | p->bits_per_subpacket); |
870 | decode_gain_info(&q->gb, gains_ptr->now); |
871 | |
872 | /* Swap current and previous gains */ |
873 | FFSWAP(int *, gains_ptr->now, gains_ptr->previous); |
874 | } |
875 | |
876 | /** |
877 | * Saturate the output signal and interleave. |
878 | * |
879 | * @param q pointer to the COOKContext |
880 | * @param out pointer to the output vector |
881 | */ |
882 | static void saturate_output_float(COOKContext *q, float *out) |
883 | { |
884 | q->adsp.vector_clipf(out, q->mono_mdct_output + q->samples_per_channel, |
885 | FFALIGN(q->samples_per_channel, 8), -1.0f, 1.0f); |
886 | } |
887 | |
888 | |
889 | /** |
890 | * Final part of subpacket decoding: |
891 | * Apply modulated lapped transform, gain compensation, |
892 | * clip and convert to integer. |
893 | * |
894 | * @param q pointer to the COOKContext |
895 | * @param decode_buffer pointer to the mlt coefficients |
896 | * @param gains_ptr array of current/prev gain pointers |
897 | * @param previous_buffer pointer to the previous buffer to be used for overlapping |
898 | * @param out pointer to the output buffer |
899 | */ |
900 | static inline void mlt_compensate_output(COOKContext *q, float *decode_buffer, |
901 | cook_gains *gains_ptr, float *previous_buffer, |
902 | float *out) |
903 | { |
904 | imlt_gain(q, decode_buffer, gains_ptr, previous_buffer); |
905 | if (out) |
906 | q->saturate_output(q, out); |
907 | } |
908 | |
909 | |
910 | /** |
911 | * Cook subpacket decoding. This function returns one decoded subpacket, |
912 | * usually 1024 samples per channel. |
913 | * |
914 | * @param q pointer to the COOKContext |
915 | * @param inbuffer pointer to the inbuffer |
916 | * @param outbuffer pointer to the outbuffer |
917 | */ |
918 | static int decode_subpacket(COOKContext *q, COOKSubpacket *p, |
919 | const uint8_t *inbuffer, float **outbuffer) |
920 | { |
921 | int sub_packet_size = p->size; |
922 | int res; |
923 | |
924 | memset(q->decode_buffer_1, 0, sizeof(q->decode_buffer_1)); |
925 | decode_bytes_and_gain(q, p, inbuffer, &p->gains1); |
926 | |
927 | if (p->joint_stereo) { |
928 | if ((res = joint_decode(q, p, q->decode_buffer_1, q->decode_buffer_2)) < 0) |
929 | return res; |
930 | } else { |
931 | if ((res = mono_decode(q, p, q->decode_buffer_1)) < 0) |
932 | return res; |
933 | |
934 | if (p->num_channels == 2) { |
935 | decode_bytes_and_gain(q, p, inbuffer + sub_packet_size / 2, &p->gains2); |
936 | if ((res = mono_decode(q, p, q->decode_buffer_2)) < 0) |
937 | return res; |
938 | } |
939 | } |
940 | |
941 | mlt_compensate_output(q, q->decode_buffer_1, &p->gains1, |
942 | p->mono_previous_buffer1, |
943 | outbuffer ? outbuffer[p->ch_idx] : NULL); |
944 | |
945 | if (p->num_channels == 2) { |
946 | if (p->joint_stereo) |
947 | mlt_compensate_output(q, q->decode_buffer_2, &p->gains1, |
948 | p->mono_previous_buffer2, |
949 | outbuffer ? outbuffer[p->ch_idx + 1] : NULL); |
950 | else |
951 | mlt_compensate_output(q, q->decode_buffer_2, &p->gains2, |
952 | p->mono_previous_buffer2, |
953 | outbuffer ? outbuffer[p->ch_idx + 1] : NULL); |
954 | } |
955 | |
956 | return 0; |
957 | } |
958 | |
959 | |
960 | static int cook_decode_frame(AVCodecContext *avctx, void *data, |
961 | int *got_frame_ptr, AVPacket *avpkt) |
962 | { |
963 | AVFrame *frame = data; |
964 | const uint8_t *buf = avpkt->data; |
965 | int buf_size = avpkt->size; |
966 | COOKContext *q = avctx->priv_data; |
967 | float **samples = NULL; |
968 | int i, ret; |
969 | int offset = 0; |
970 | int chidx = 0; |
971 | |
972 | if (buf_size < avctx->block_align) |
973 | return buf_size; |
974 | |
975 | /* get output buffer */ |
976 | if (q->discarded_packets >= 2) { |
977 | frame->nb_samples = q->samples_per_channel; |
978 | if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) |
979 | return ret; |
980 | samples = (float **)frame->extended_data; |
981 | } |
982 | |
983 | /* estimate subpacket sizes */ |
984 | q->subpacket[0].size = avctx->block_align; |
985 | |
986 | for (i = 1; i < q->num_subpackets; i++) { |
987 | q->subpacket[i].size = 2 * buf[avctx->block_align - q->num_subpackets + i]; |
988 | q->subpacket[0].size -= q->subpacket[i].size + 1; |
989 | if (q->subpacket[0].size < 0) { |
990 | av_log(avctx, AV_LOG_DEBUG, |
991 | "frame subpacket size total > avctx->block_align!\n"); |
992 | return AVERROR_INVALIDDATA; |
993 | } |
994 | } |
995 | |
996 | /* decode supbackets */ |
997 | for (i = 0; i < q->num_subpackets; i++) { |
998 | q->subpacket[i].bits_per_subpacket = (q->subpacket[i].size * 8) >> |
999 | q->subpacket[i].bits_per_subpdiv; |
1000 | q->subpacket[i].ch_idx = chidx; |
1001 | av_log(avctx, AV_LOG_DEBUG, |
1002 | "subpacket[%i] size %i js %i %i block_align %i\n", |
1003 | i, q->subpacket[i].size, q->subpacket[i].joint_stereo, offset, |
1004 | avctx->block_align); |
1005 | |
1006 | if ((ret = decode_subpacket(q, &q->subpacket[i], buf + offset, samples)) < 0) |
1007 | return ret; |
1008 | offset += q->subpacket[i].size; |
1009 | chidx += q->subpacket[i].num_channels; |
1010 | av_log(avctx, AV_LOG_DEBUG, "subpacket[%i] %i %i\n", |
1011 | i, q->subpacket[i].size * 8, get_bits_count(&q->gb)); |
1012 | } |
1013 | |
1014 | /* Discard the first two frames: no valid audio. */ |
1015 | if (q->discarded_packets < 2) { |
1016 | q->discarded_packets++; |
1017 | *got_frame_ptr = 0; |
1018 | return avctx->block_align; |
1019 | } |
1020 | |
1021 | *got_frame_ptr = 1; |
1022 | |
1023 | return avctx->block_align; |
1024 | } |
1025 | |
1026 | static void dump_cook_context(COOKContext *q) |
1027 | { |
1028 | //int i=0; |
1029 | #define PRINT(a, b) ff_dlog(q->avctx, " %s = %d\n", a, b); |
1030 | ff_dlog(q->avctx, "COOKextradata\n"); |
1031 | ff_dlog(q->avctx, "cookversion=%x\n", q->subpacket[0].cookversion); |
1032 | if (q->subpacket[0].cookversion > STEREO) { |
1033 | PRINT("js_subband_start", q->subpacket[0].js_subband_start); |
1034 | PRINT("js_vlc_bits", q->subpacket[0].js_vlc_bits); |
1035 | } |
1036 | ff_dlog(q->avctx, "COOKContext\n"); |
1037 | PRINT("nb_channels", q->avctx->channels); |
1038 | PRINT("bit_rate", (int)q->avctx->bit_rate); |
1039 | PRINT("sample_rate", q->avctx->sample_rate); |
1040 | PRINT("samples_per_channel", q->subpacket[0].samples_per_channel); |
1041 | PRINT("subbands", q->subpacket[0].subbands); |
1042 | PRINT("js_subband_start", q->subpacket[0].js_subband_start); |
1043 | PRINT("log2_numvector_size", q->subpacket[0].log2_numvector_size); |
1044 | PRINT("numvector_size", q->subpacket[0].numvector_size); |
1045 | PRINT("total_subbands", q->subpacket[0].total_subbands); |
1046 | } |
1047 | |
1048 | /** |
1049 | * Cook initialization |
1050 | * |
1051 | * @param avctx pointer to the AVCodecContext |
1052 | */ |
1053 | static av_cold int cook_decode_init(AVCodecContext *avctx) |
1054 | { |
1055 | COOKContext *q = avctx->priv_data; |
1056 | GetByteContext gb; |
1057 | int s = 0; |
1058 | unsigned int channel_mask = 0; |
1059 | int samples_per_frame = 0; |
1060 | int ret; |
1061 | q->avctx = avctx; |
1062 | |
1063 | /* Take care of the codec specific extradata. */ |
1064 | if (avctx->extradata_size < 8) { |
1065 | av_log(avctx, AV_LOG_ERROR, "Necessary extradata missing!\n"); |
1066 | return AVERROR_INVALIDDATA; |
1067 | } |
1068 | av_log(avctx, AV_LOG_DEBUG, "codecdata_length=%d\n", avctx->extradata_size); |
1069 | |
1070 | bytestream2_init(&gb, avctx->extradata, avctx->extradata_size); |
1071 | |
1072 | /* Take data from the AVCodecContext (RM container). */ |
1073 | if (!avctx->channels) { |
1074 | av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n"); |
1075 | return AVERROR_INVALIDDATA; |
1076 | } |
1077 | |
1078 | /* Initialize RNG. */ |
1079 | av_lfg_init(&q->random_state, 0); |
1080 | |
1081 | ff_audiodsp_init(&q->adsp); |
1082 | |
1083 | while (bytestream2_get_bytes_left(&gb)) { |
1084 | /* 8 for mono, 16 for stereo, ? for multichannel |
1085 | Swap to right endianness so we don't need to care later on. */ |
1086 | q->subpacket[s].cookversion = bytestream2_get_be32(&gb); |
1087 | samples_per_frame = bytestream2_get_be16(&gb); |
1088 | q->subpacket[s].subbands = bytestream2_get_be16(&gb); |
1089 | bytestream2_get_be32(&gb); // Unknown unused |
1090 | q->subpacket[s].js_subband_start = bytestream2_get_be16(&gb); |
1091 | if (q->subpacket[s].js_subband_start >= 51) { |
1092 | av_log(avctx, AV_LOG_ERROR, "js_subband_start %d is too large\n", q->subpacket[s].js_subband_start); |
1093 | return AVERROR_INVALIDDATA; |
1094 | } |
1095 | q->subpacket[s].js_vlc_bits = bytestream2_get_be16(&gb); |
1096 | |
1097 | /* Initialize extradata related variables. */ |
1098 | q->subpacket[s].samples_per_channel = samples_per_frame / avctx->channels; |
1099 | q->subpacket[s].bits_per_subpacket = avctx->block_align * 8; |
1100 | |
1101 | /* Initialize default data states. */ |
1102 | q->subpacket[s].log2_numvector_size = 5; |
1103 | q->subpacket[s].total_subbands = q->subpacket[s].subbands; |
1104 | q->subpacket[s].num_channels = 1; |
1105 | |
1106 | /* Initialize version-dependent variables */ |
1107 | |
1108 | av_log(avctx, AV_LOG_DEBUG, "subpacket[%i].cookversion=%x\n", s, |
1109 | q->subpacket[s].cookversion); |
1110 | q->subpacket[s].joint_stereo = 0; |
1111 | switch (q->subpacket[s].cookversion) { |
1112 | case MONO: |
1113 | if (avctx->channels != 1) { |
1114 | avpriv_request_sample(avctx, "Container channels != 1"); |
1115 | return AVERROR_PATCHWELCOME; |
1116 | } |
1117 | av_log(avctx, AV_LOG_DEBUG, "MONO\n"); |
1118 | break; |
1119 | case STEREO: |
1120 | if (avctx->channels != 1) { |
1121 | q->subpacket[s].bits_per_subpdiv = 1; |
1122 | q->subpacket[s].num_channels = 2; |
1123 | } |
1124 | av_log(avctx, AV_LOG_DEBUG, "STEREO\n"); |
1125 | break; |
1126 | case JOINT_STEREO: |
1127 | if (avctx->channels != 2) { |
1128 | avpriv_request_sample(avctx, "Container channels != 2"); |
1129 | return AVERROR_PATCHWELCOME; |
1130 | } |
1131 | av_log(avctx, AV_LOG_DEBUG, "JOINT_STEREO\n"); |
1132 | if (avctx->extradata_size >= 16) { |
1133 | q->subpacket[s].total_subbands = q->subpacket[s].subbands + |
1134 | q->subpacket[s].js_subband_start; |
1135 | q->subpacket[s].joint_stereo = 1; |
1136 | q->subpacket[s].num_channels = 2; |
1137 | } |
1138 | if (q->subpacket[s].samples_per_channel > 256) { |
1139 | q->subpacket[s].log2_numvector_size = 6; |
1140 | } |
1141 | if (q->subpacket[s].samples_per_channel > 512) { |
1142 | q->subpacket[s].log2_numvector_size = 7; |
1143 | } |
1144 | break; |
1145 | case MC_COOK: |
1146 | av_log(avctx, AV_LOG_DEBUG, "MULTI_CHANNEL\n"); |
1147 | channel_mask |= q->subpacket[s].channel_mask = bytestream2_get_be32(&gb); |
1148 | |
1149 | if (av_get_channel_layout_nb_channels(q->subpacket[s].channel_mask) > 1) { |
1150 | q->subpacket[s].total_subbands = q->subpacket[s].subbands + |
1151 | q->subpacket[s].js_subband_start; |
1152 | q->subpacket[s].joint_stereo = 1; |
1153 | q->subpacket[s].num_channels = 2; |
1154 | q->subpacket[s].samples_per_channel = samples_per_frame >> 1; |
1155 | |
1156 | if (q->subpacket[s].samples_per_channel > 256) { |
1157 | q->subpacket[s].log2_numvector_size = 6; |
1158 | } |
1159 | if (q->subpacket[s].samples_per_channel > 512) { |
1160 | q->subpacket[s].log2_numvector_size = 7; |
1161 | } |
1162 | } else |
1163 | q->subpacket[s].samples_per_channel = samples_per_frame; |
1164 | |
1165 | break; |
1166 | default: |
1167 | avpriv_request_sample(avctx, "Cook version %d", |
1168 | q->subpacket[s].cookversion); |
1169 | return AVERROR_PATCHWELCOME; |
1170 | } |
1171 | |
1172 | if (s > 1 && q->subpacket[s].samples_per_channel != q->samples_per_channel) { |
1173 | av_log(avctx, AV_LOG_ERROR, "different number of samples per channel!\n"); |
1174 | return AVERROR_INVALIDDATA; |
1175 | } else |
1176 | q->samples_per_channel = q->subpacket[0].samples_per_channel; |
1177 | |
1178 | |
1179 | /* Initialize variable relations */ |
1180 | q->subpacket[s].numvector_size = (1 << q->subpacket[s].log2_numvector_size); |
1181 | |
1182 | /* Try to catch some obviously faulty streams, otherwise it might be exploitable */ |
1183 | if (q->subpacket[s].total_subbands > 53) { |
1184 | avpriv_request_sample(avctx, "total_subbands > 53"); |
1185 | return AVERROR_PATCHWELCOME; |
1186 | } |
1187 | |
1188 | if ((q->subpacket[s].js_vlc_bits > 6) || |
1189 | (q->subpacket[s].js_vlc_bits < 2 * q->subpacket[s].joint_stereo)) { |
1190 | av_log(avctx, AV_LOG_ERROR, "js_vlc_bits = %d, only >= %d and <= 6 allowed!\n", |
1191 | q->subpacket[s].js_vlc_bits, 2 * q->subpacket[s].joint_stereo); |
1192 | return AVERROR_INVALIDDATA; |
1193 | } |
1194 | |
1195 | if (q->subpacket[s].subbands > 50) { |
1196 | avpriv_request_sample(avctx, "subbands > 50"); |
1197 | return AVERROR_PATCHWELCOME; |
1198 | } |
1199 | if (q->subpacket[s].subbands == 0) { |
1200 | avpriv_request_sample(avctx, "subbands = 0"); |
1201 | return AVERROR_PATCHWELCOME; |
1202 | } |
1203 | q->subpacket[s].gains1.now = q->subpacket[s].gain_1; |
1204 | q->subpacket[s].gains1.previous = q->subpacket[s].gain_2; |
1205 | q->subpacket[s].gains2.now = q->subpacket[s].gain_3; |
1206 | q->subpacket[s].gains2.previous = q->subpacket[s].gain_4; |
1207 | |
1208 | if (q->num_subpackets + q->subpacket[s].num_channels > q->avctx->channels) { |
1209 | av_log(avctx, AV_LOG_ERROR, "Too many subpackets %d for channels %d\n", q->num_subpackets, q->avctx->channels); |
1210 | return AVERROR_INVALIDDATA; |
1211 | } |
1212 | |
1213 | q->num_subpackets++; |
1214 | s++; |
1215 | if (s > FFMIN(MAX_SUBPACKETS, avctx->block_align)) { |
1216 | avpriv_request_sample(avctx, "subpackets > %d", FFMIN(MAX_SUBPACKETS, avctx->block_align)); |
1217 | return AVERROR_PATCHWELCOME; |
1218 | } |
1219 | } |
1220 | /* Generate tables */ |
1221 | init_pow2table(); |
1222 | init_gain_table(q); |
1223 | init_cplscales_table(q); |
1224 | |
1225 | if ((ret = init_cook_vlc_tables(q))) |
1226 | return ret; |
1227 | |
1228 | |
1229 | if (avctx->block_align >= UINT_MAX / 2) |
1230 | return AVERROR(EINVAL); |
1231 | |
1232 | /* Pad the databuffer with: |
1233 | DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(), |
1234 | AV_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */ |
1235 | q->decoded_bytes_buffer = |
1236 | av_mallocz(avctx->block_align |
1237 | + DECODE_BYTES_PAD1(avctx->block_align) |
1238 | + AV_INPUT_BUFFER_PADDING_SIZE); |
1239 | if (!q->decoded_bytes_buffer) |
1240 | return AVERROR(ENOMEM); |
1241 | |
1242 | /* Initialize transform. */ |
1243 | if ((ret = init_cook_mlt(q))) |
1244 | return ret; |
1245 | |
1246 | /* Initialize COOK signal arithmetic handling */ |
1247 | if (1) { |
1248 | q->scalar_dequant = scalar_dequant_float; |
1249 | q->decouple = decouple_float; |
1250 | q->imlt_window = imlt_window_float; |
1251 | q->interpolate = interpolate_float; |
1252 | q->saturate_output = saturate_output_float; |
1253 | } |
1254 | |
1255 | /* Try to catch some obviously faulty streams, otherwise it might be exploitable */ |
1256 | if (q->samples_per_channel != 256 && q->samples_per_channel != 512 && |
1257 | q->samples_per_channel != 1024) { |
1258 | avpriv_request_sample(avctx, "samples_per_channel = %d", |
1259 | q->samples_per_channel); |
1260 | return AVERROR_PATCHWELCOME; |
1261 | } |
1262 | |
1263 | avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; |
1264 | if (channel_mask) |
1265 | avctx->channel_layout = channel_mask; |
1266 | else |
1267 | avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO; |
1268 | |
1269 | |
1270 | dump_cook_context(q); |
1271 | |
1272 | return 0; |
1273 | } |
1274 | |
1275 | AVCodec ff_cook_decoder = { |
1276 | .name = "cook", |
1277 | .long_name = NULL_IF_CONFIG_SMALL("Cook / Cooker / Gecko (RealAudio G2)"), |
1278 | .type = AVMEDIA_TYPE_AUDIO, |
1279 | .id = AV_CODEC_ID_COOK, |
1280 | .priv_data_size = sizeof(COOKContext), |
1281 | .init = cook_decode_init, |
1282 | .close = cook_decode_close, |
1283 | .decode = cook_decode_frame, |
1284 | .capabilities = AV_CODEC_CAP_DR1, |
1285 | .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, |
1286 | AV_SAMPLE_FMT_NONE }, |
1287 | }; |
1288 |