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