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