Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
6147 | serge | 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 | /* 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_uintp2((i - quant_index_table[index] + bias) / 2, 3); |
||
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_uintp2((bias - quant_index_table[i]) / 2, 3); |
||
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 |
||
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< |
||
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 | static void dump_cook_context(COOKContext *q) |
||
1020 | { |
||
1021 | //int i=0; |
||
1022 | #define PRINT(a, b) ff_dlog(q->avctx, " %s = %d\n", a, b); |
||
1023 | ff_dlog(q->avctx, "COOKextradata\n"); |
||
1024 | ff_dlog(q->avctx, "cookversion=%x\n", q->subpacket[0].cookversion); |
||
1025 | if (q->subpacket[0].cookversion > STEREO) { |
||
1026 | PRINT("js_subband_start", q->subpacket[0].js_subband_start); |
||
1027 | PRINT("js_vlc_bits", q->subpacket[0].js_vlc_bits); |
||
1028 | } |
||
1029 | ff_dlog(q->avctx, "COOKContext\n"); |
||
1030 | PRINT("nb_channels", q->avctx->channels); |
||
1031 | PRINT("bit_rate", q->avctx->bit_rate); |
||
1032 | PRINT("sample_rate", q->avctx->sample_rate); |
||
1033 | PRINT("samples_per_channel", q->subpacket[0].samples_per_channel); |
||
1034 | PRINT("subbands", q->subpacket[0].subbands); |
||
1035 | PRINT("js_subband_start", q->subpacket[0].js_subband_start); |
||
1036 | PRINT("log2_numvector_size", q->subpacket[0].log2_numvector_size); |
||
1037 | PRINT("numvector_size", q->subpacket[0].numvector_size); |
||
1038 | PRINT("total_subbands", q->subpacket[0].total_subbands); |
||
1039 | } |
||
1040 | |||
1041 | /** |
||
1042 | * Cook initialization |
||
1043 | * |
||
1044 | * @param avctx pointer to the AVCodecContext |
||
1045 | */ |
||
1046 | static av_cold int cook_decode_init(AVCodecContext *avctx) |
||
1047 | { |
||
1048 | COOKContext *q = avctx->priv_data; |
||
1049 | const uint8_t *edata_ptr = avctx->extradata; |
||
1050 | const uint8_t *edata_ptr_end = edata_ptr + avctx->extradata_size; |
||
1051 | int extradata_size = avctx->extradata_size; |
||
1052 | int s = 0; |
||
1053 | unsigned int channel_mask = 0; |
||
1054 | int samples_per_frame = 0; |
||
1055 | int ret; |
||
1056 | q->avctx = avctx; |
||
1057 | |||
1058 | /* Take care of the codec specific extradata. */ |
||
1059 | if (extradata_size < 8) { |
||
1060 | av_log(avctx, AV_LOG_ERROR, "Necessary extradata missing!\n"); |
||
1061 | return AVERROR_INVALIDDATA; |
||
1062 | } |
||
1063 | av_log(avctx, AV_LOG_DEBUG, "codecdata_length=%d\n", avctx->extradata_size); |
||
1064 | |||
1065 | /* Take data from the AVCodecContext (RM container). */ |
||
1066 | if (!avctx->channels) { |
||
1067 | av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n"); |
||
1068 | return AVERROR_INVALIDDATA; |
||
1069 | } |
||
1070 | |||
1071 | /* Initialize RNG. */ |
||
1072 | av_lfg_init(&q->random_state, 0); |
||
1073 | |||
1074 | ff_audiodsp_init(&q->adsp); |
||
1075 | |||
1076 | while (edata_ptr < edata_ptr_end) { |
||
1077 | /* 8 for mono, 16 for stereo, ? for multichannel |
||
1078 | Swap to right endianness so we don't need to care later on. */ |
||
1079 | if (extradata_size >= 8) { |
||
1080 | q->subpacket[s].cookversion = bytestream_get_be32(&edata_ptr); |
||
1081 | samples_per_frame = bytestream_get_be16(&edata_ptr); |
||
1082 | q->subpacket[s].subbands = bytestream_get_be16(&edata_ptr); |
||
1083 | extradata_size -= 8; |
||
1084 | } |
||
1085 | if (extradata_size >= 8) { |
||
1086 | bytestream_get_be32(&edata_ptr); // Unknown unused |
||
1087 | q->subpacket[s].js_subband_start = bytestream_get_be16(&edata_ptr); |
||
1088 | if (q->subpacket[s].js_subband_start >= 51) { |
||
1089 | av_log(avctx, AV_LOG_ERROR, "js_subband_start %d is too large\n", q->subpacket[s].js_subband_start); |
||
1090 | return AVERROR_INVALIDDATA; |
||
1091 | } |
||
1092 | |||
1093 | q->subpacket[s].js_vlc_bits = bytestream_get_be16(&edata_ptr); |
||
1094 | extradata_size -= 8; |
||
1095 | } |
||
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 | if (extradata_size >= 4) |
||
1148 | channel_mask |= q->subpacket[s].channel_mask = bytestream_get_be32(&edata_ptr); |
||
1149 | |||
1150 | if (av_get_channel_layout_nb_channels(q->subpacket[s].channel_mask) > 1) { |
||
1151 | q->subpacket[s].total_subbands = q->subpacket[s].subbands + |
||
1152 | q->subpacket[s].js_subband_start; |
||
1153 | q->subpacket[s].joint_stereo = 1; |
||
1154 | q->subpacket[s].num_channels = 2; |
||
1155 | q->subpacket[s].samples_per_channel = samples_per_frame >> 1; |
||
1156 | |||
1157 | if (q->subpacket[s].samples_per_channel > 256) { |
||
1158 | q->subpacket[s].log2_numvector_size = 6; |
||
1159 | } |
||
1160 | if (q->subpacket[s].samples_per_channel > 512) { |
||
1161 | q->subpacket[s].log2_numvector_size = 7; |
||
1162 | } |
||
1163 | } else |
||
1164 | q->subpacket[s].samples_per_channel = samples_per_frame; |
||
1165 | |||
1166 | break; |
||
1167 | default: |
||
1168 | avpriv_request_sample(avctx, "Cook version %d", |
||
1169 | q->subpacket[s].cookversion); |
||
1170 | return AVERROR_PATCHWELCOME; |
||
1171 | } |
||
1172 | |||
1173 | if (s > 1 && q->subpacket[s].samples_per_channel != q->samples_per_channel) { |
||
1174 | av_log(avctx, AV_LOG_ERROR, "different number of samples per channel!\n"); |
||
1175 | return AVERROR_INVALIDDATA; |
||
1176 | } else |
||
1177 | q->samples_per_channel = q->subpacket[0].samples_per_channel; |
||
1178 | |||
1179 | |||
1180 | /* Initialize variable relations */ |
||
1181 | q->subpacket[s].numvector_size = (1 << q->subpacket[s].log2_numvector_size); |
||
1182 | |||
1183 | /* Try to catch some obviously faulty streams, othervise it might be exploitable */ |
||
1184 | if (q->subpacket[s].total_subbands > 53) { |
||
1185 | avpriv_request_sample(avctx, "total_subbands > 53"); |
||
1186 | return AVERROR_PATCHWELCOME; |
||
1187 | } |
||
1188 | |||
1189 | if ((q->subpacket[s].js_vlc_bits > 6) || |
||
1190 | (q->subpacket[s].js_vlc_bits < 2 * q->subpacket[s].joint_stereo)) { |
||
1191 | av_log(avctx, AV_LOG_ERROR, "js_vlc_bits = %d, only >= %d and <= 6 allowed!\n", |
||
1192 | q->subpacket[s].js_vlc_bits, 2 * q->subpacket[s].joint_stereo); |
||
1193 | return AVERROR_INVALIDDATA; |
||
1194 | } |
||
1195 | |||
1196 | if (q->subpacket[s].subbands > 50) { |
||
1197 | avpriv_request_sample(avctx, "subbands > 50"); |
||
1198 | return AVERROR_PATCHWELCOME; |
||
1199 | } |
||
1200 | if (q->subpacket[s].subbands == 0) { |
||
1201 | avpriv_request_sample(avctx, "subbands = 0"); |
||
1202 | return AVERROR_PATCHWELCOME; |
||
1203 | } |
||
1204 | q->subpacket[s].gains1.now = q->subpacket[s].gain_1; |
||
1205 | q->subpacket[s].gains1.previous = q->subpacket[s].gain_2; |
||
1206 | q->subpacket[s].gains2.now = q->subpacket[s].gain_3; |
||
1207 | q->subpacket[s].gains2.previous = q->subpacket[s].gain_4; |
||
1208 | |||
1209 | if (q->num_subpackets + q->subpacket[s].num_channels > q->avctx->channels) { |
||
1210 | av_log(avctx, AV_LOG_ERROR, "Too many subpackets %d for channels %d\n", q->num_subpackets, q->avctx->channels); |
||
1211 | return AVERROR_INVALIDDATA; |
||
1212 | } |
||
1213 | |||
1214 | q->num_subpackets++; |
||
1215 | s++; |
||
1216 | if (s > FFMIN(MAX_SUBPACKETS, avctx->block_align)) { |
||
1217 | avpriv_request_sample(avctx, "subpackets > %d", FFMIN(MAX_SUBPACKETS, avctx->block_align)); |
||
1218 | return AVERROR_PATCHWELCOME; |
||
1219 | } |
||
1220 | } |
||
1221 | /* Generate tables */ |
||
1222 | init_pow2table(); |
||
1223 | init_gain_table(q); |
||
1224 | init_cplscales_table(q); |
||
1225 | |||
1226 | if ((ret = init_cook_vlc_tables(q))) |
||
1227 | return ret; |
||
1228 | |||
1229 | |||
1230 | if (avctx->block_align >= UINT_MAX / 2) |
||
1231 | return AVERROR(EINVAL); |
||
1232 | |||
1233 | /* Pad the databuffer with: |
||
1234 | DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(), |
||
1235 | AV_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */ |
||
1236 | q->decoded_bytes_buffer = |
||
1237 | av_mallocz(avctx->block_align |
||
1238 | + DECODE_BYTES_PAD1(avctx->block_align) |
||
1239 | + AV_INPUT_BUFFER_PADDING_SIZE); |
||
1240 | if (!q->decoded_bytes_buffer) |
||
1241 | return AVERROR(ENOMEM); |
||
1242 | |||
1243 | /* Initialize transform. */ |
||
1244 | if ((ret = init_cook_mlt(q))) |
||
1245 | return ret; |
||
1246 | |||
1247 | /* Initialize COOK signal arithmetic handling */ |
||
1248 | if (1) { |
||
1249 | q->scalar_dequant = scalar_dequant_float; |
||
1250 | q->decouple = decouple_float; |
||
1251 | q->imlt_window = imlt_window_float; |
||
1252 | q->interpolate = interpolate_float; |
||
1253 | q->saturate_output = saturate_output_float; |
||
1254 | } |
||
1255 | |||
1256 | /* Try to catch some obviously faulty streams, othervise it might be exploitable */ |
||
1257 | if (q->samples_per_channel != 256 && q->samples_per_channel != 512 && |
||
1258 | q->samples_per_channel != 1024) { |
||
1259 | avpriv_request_sample(avctx, "samples_per_channel = %d", |
||
1260 | q->samples_per_channel); |
||
1261 | return AVERROR_PATCHWELCOME; |
||
1262 | } |
||
1263 | |||
1264 | avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; |
||
1265 | if (channel_mask) |
||
1266 | avctx->channel_layout = channel_mask; |
||
1267 | else |
||
1268 | avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO; |
||
1269 | |||
1270 | |||
1271 | dump_cook_context(q); |
||
1272 | |||
1273 | return 0; |
||
1274 | } |
||
1275 | |||
1276 | AVCodec ff_cook_decoder = { |
||
1277 | .name = "cook", |
||
1278 | .long_name = NULL_IF_CONFIG_SMALL("Cook / Cooker / Gecko (RealAudio G2)"), |
||
1279 | .type = AVMEDIA_TYPE_AUDIO, |
||
1280 | .id = AV_CODEC_ID_COOK, |
||
1281 | .priv_data_size = sizeof(COOKContext), |
||
1282 | .init = cook_decode_init, |
||
1283 | .close = cook_decode_close, |
||
1284 | .decode = cook_decode_frame, |
||
1285 | .capabilities = AV_CODEC_CAP_DR1, |
||
1286 | .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, |
||
1287 | AV_SAMPLE_FMT_NONE }, |
||
1288 | };=>>><>>>>>>>>>>>>>><>>><>>>>>> |