FFmpeg coverage

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