FFmpeg
cook.c
Go to the documentation of this file.
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 
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;
84  int subbands;
89  unsigned int channel_mask;
95  int numvector_size; // 1 << log2_numvector_size;
96 
97  float mono_previous_buffer1[1024];
98  float mono_previous_buffer2[1024];
99 
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 
135  /* stream data */
138  /* states */
141 
142  /* transform data */
145  float* mlt_window;
146 
147  /* VLC data */
149  VLC sqvh[7]; // scalar quantization
150 
151  /* generate tables and related variables */
153  float gain_table[31];
154 
155  /* data buffers */
156 
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];
166 } COOKContext;
167 
168 static float pow2tab[127];
169 static float rootpow2tab[127];
170 
171 /*************** init functions ***************/
172 
173 /* table generator */
174 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  float exp2_val = powf(2, -63);
180  float root_val = powf(2, -32);
181  for (i = -63; i < 64; i++) {
182  if (!(i & 1))
183  root_val *= 2;
184  pow2tab[63 + i] = exp2_val;
185  rootpow2tab[63 + i] = root_val * exp2_tab[i & 1];
186  exp2_val *= 2;
187  }
188 }
189 
190 /* table generator */
191 static av_cold void init_gain_table(COOKContext *q)
192 {
193  int i;
194  q->gain_size_factor = q->samples_per_channel / 8;
195  for (i = 0; i < 31; i++)
196  q->gain_table[i] = pow(pow2tab[i + 48],
197  (1.0 / (double) q->gain_size_factor));
198 }
199 
200 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  unsigned num = 0;
206 
207  for (int i = 0; i < 16; i++)
208  for (unsigned count = num + counts[i]; num < count; num++)
209  lens[num] = i + 1;
210 
211  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 static av_cold int init_cook_vlc_tables(COOKContext *q)
217 {
218  int i, result;
219 
220  result = 0;
221  for (i = 0; i < 13; i++) {
222  result |= build_vlc(&q->envelope_quant_index[i], QUANT_VLC_BITS,
224  envelope_quant_index_huffsyms[i], 1, -12, q->avctx);
225  }
226  av_log(q->avctx, AV_LOG_DEBUG, "sqvh VLC init\n");
227  for (i = 0; i < 7; i++) {
228  int sym_size = 1 + (i == 3);
229  result |= build_vlc(&q->sqvh[i], vhvlcsize_tab[i],
230  cvh_huffcounts[i],
231  cvh_huffsyms[i], sym_size, 0, q->avctx);
232  }
233 
234  for (i = 0; i < q->num_subpackets; i++) {
235  if (q->subpacket[i].joint_stereo == 1) {
236  result |= build_vlc(&q->subpacket[i].channel_coupling, COUPLING_VLC_BITS,
237  ccpl_huffcounts[q->subpacket[i].js_vlc_bits - 2],
238  ccpl_huffsyms[q->subpacket[i].js_vlc_bits - 2], 1,
239  0, q->avctx);
240  av_log(q->avctx, AV_LOG_DEBUG, "subpacket %i Joint-stereo VLC used.\n", i);
241  }
242  }
243 
244  av_log(q->avctx, AV_LOG_DEBUG, "VLC tables initialized.\n");
245  return result;
246 }
247 
248 static av_cold int init_cook_mlt(COOKContext *q)
249 {
250  int j, ret;
251  int mlt_size = q->samples_per_channel;
252  const float scale = 1.0 / 32768.0;
253 
254  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  ff_sine_window_init(q->mlt_window, mlt_size);
259  for (j = 0; j < mlt_size; j++)
260  q->mlt_window[j] *= sqrt(2.0 / q->samples_per_channel);
261 
262  /* Initialize the MDCT. */
263  ret = av_tx_init(&q->mdct_ctx, &q->mdct_fn, AV_TX_FLOAT_MDCT,
264  1, mlt_size, &scale, AV_TX_FULL_IMDCT);
265  if (ret < 0)
266  return ret;
267 
268  return 0;
269 }
270 
271 static av_cold void init_cplscales_table(COOKContext *q)
272 {
273  int i;
274  for (i = 0; i < 5; i++)
275  q->cplscales[i] = cplscales[i];
276 }
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 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  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  off = (intptr_t) inbuffer & 3;
320  buf = (const uint32_t *) (inbuffer - off);
321  c = tab[off];
322  bytes += 3 + off;
323  for (i = 0; i < bytes / 4; i++)
324  obuf[i] = c ^ buf[i];
325 
326  return off;
327 }
328 
330 {
331  int i;
332  COOKContext *q = avctx->priv_data;
333  av_log(avctx, AV_LOG_DEBUG, "Deallocating memory.\n");
334 
335  /* Free allocated memory buffers. */
336  av_freep(&q->mlt_window);
337  av_freep(&q->decoded_bytes_buffer);
338 
339  /* Free the transform. */
340  av_tx_uninit(&q->mdct_ctx);
341 
342  /* Free the VLC tables. */
343  for (i = 0; i < 13; i++)
344  ff_free_vlc(&q->envelope_quant_index[i]);
345  for (i = 0; i < 7; i++)
346  ff_free_vlc(&q->sqvh[i]);
347  for (i = 0; i < q->num_subpackets; i++)
348  ff_free_vlc(&q->subpacket[i].channel_coupling);
349 
350  av_log(avctx, AV_LOG_DEBUG, "Memory deallocated.\n");
351 
352  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 static void decode_gain_info(GetBitContext *gb, int *gaininfo)
362 {
363  int i, n;
364 
365  n = get_unary(gb, 0, get_bits_left(gb)); // amount of elements*2 to update
366 
367  i = 0;
368  while (n--) {
369  int index = get_bits(gb, 3);
370  int gain = get_bits1(gb) ? get_bits(gb, 4) - 7 : -1;
371 
372  while (i <= index)
373  gaininfo[i++] = gain;
374  }
375  while (i <= 8)
376  gaininfo[i++] = 0;
377 }
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 static int decode_envelope(COOKContext *q, COOKSubpacket *p,
386  int *quant_index_table)
387 {
388  int i, j, vlc_index;
389 
390  quant_index_table[0] = get_bits(&q->gb, 6) - 6; // This is used later in categorize
391 
392  for (i = 1; i < p->total_subbands; i++) {
393  vlc_index = i;
394  if (i >= p->js_subband_start * 2) {
395  vlc_index -= p->js_subband_start;
396  } else {
397  vlc_index /= 2;
398  if (vlc_index < 1)
399  vlc_index = 1;
400  }
401  if (vlc_index > 13)
402  vlc_index = 13; // the VLC tables >13 are identical to No. 13
403 
404  j = get_vlc2(&q->gb, q->envelope_quant_index[vlc_index - 1].table,
405  QUANT_VLC_BITS, 2);
406  quant_index_table[i] = quant_index_table[i - 1] + j; // differential encoding
407  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  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 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  int exp_index2[102] = { 0 };
431  int exp_index1[102] = { 0 };
432 
433  int tmp_categorize_array[128 * 2] = { 0 };
434  int tmp_categorize_array1_idx = p->numvector_size;
435  int tmp_categorize_array2_idx = p->numvector_size;
436 
437  bits_left = p->bits_per_subpacket - get_bits_count(&q->gb);
438 
439  if (bits_left > q->samples_per_channel)
440  bits_left = q->samples_per_channel +
441  ((bits_left - q->samples_per_channel) * 5) / 8;
442 
443  bias = -32;
444 
445  /* Estimate bias. */
446  for (i = 32; i > 0; i = i / 2) {
447  num_bits = 0;
448  index = 0;
449  for (j = p->total_subbands; j > 0; j--) {
450  exp_idx = av_clip_uintp2((i - quant_index_table[index] + bias) / 2, 3);
451  index++;
452  num_bits += expbits_tab[exp_idx];
453  }
454  if (num_bits >= bits_left - 32)
455  bias += i;
456  }
457 
458  /* Calculate total number of bits. */
459  num_bits = 0;
460  for (i = 0; i < p->total_subbands; i++) {
461  exp_idx = av_clip_uintp2((bias - quant_index_table[i]) / 2, 3);
462  num_bits += expbits_tab[exp_idx];
463  exp_index1[i] = exp_idx;
464  exp_index2[i] = exp_idx;
465  }
466  tmpbias1 = tmpbias2 = num_bits;
467 
468  for (j = 1; j < p->numvector_size; j++) {
469  if (tmpbias1 + tmpbias2 > 2 * bits_left) { /* ---> */
470  int max = -999999;
471  index = -1;
472  for (i = 0; i < p->total_subbands; i++) {
473  if (exp_index1[i] < 7) {
474  v = (-2 * exp_index1[i]) - quant_index_table[i] + bias;
475  if (v >= max) {
476  max = v;
477  index = i;
478  }
479  }
480  }
481  if (index == -1)
482  break;
483  tmp_categorize_array[tmp_categorize_array1_idx++] = index;
484  tmpbias1 -= expbits_tab[exp_index1[index]] -
485  expbits_tab[exp_index1[index] + 1];
486  ++exp_index1[index];
487  } else { /* <--- */
488  int min = 999999;
489  index = -1;
490  for (i = 0; i < p->total_subbands; i++) {
491  if (exp_index2[i] > 0) {
492  v = (-2 * exp_index2[i]) - quant_index_table[i] + bias;
493  if (v < min) {
494  min = v;
495  index = i;
496  }
497  }
498  }
499  if (index == -1)
500  break;
501  tmp_categorize_array[--tmp_categorize_array2_idx] = index;
502  tmpbias2 -= expbits_tab[exp_index2[index]] -
503  expbits_tab[exp_index2[index] - 1];
504  --exp_index2[index];
505  }
506  }
507 
508  for (i = 0; i < p->total_subbands; i++)
509  category[i] = exp_index2[i];
510 
511  for (i = 0; i < p->numvector_size - 1; i++)
512  category_index[i] = tmp_categorize_array[tmp_categorize_array2_idx++];
513 }
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 static inline void expand_category(COOKContext *q, int *category,
524  int *category_index)
525 {
526  int i;
527  for (i = 0; i < q->num_vectors; i++)
528  {
529  int idx = category_index[i];
530  if (++category[idx] >= FF_ARRAY_ELEMS(dither_tab))
531  --category[idx];
532  }
533 }
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 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  for (i = 0; i < SUBBAND_SIZE; i++) {
553  if (subband_coef_index[i]) {
554  f1 = quant_centroid_tab[index][subband_coef_index[i]];
555  if (subband_coef_sign[i])
556  f1 = -f1;
557  } else {
558  /* noise coding if subband_coef_index[i] == 0 */
559  f1 = dither_tab[index];
560  if (av_lfg_get(&q->random_state) < 0x80000000)
561  f1 = -f1;
562  }
563  mlt_p[i] = f1 * rootpow2tab[quant_index + 63];
564  }
565 }
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 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  vd = vd_tab[category];
581  result = 0;
582  for (i = 0; i < vpr_tab[category]; i++) {
583  vlc = get_vlc2(&q->gb, q->sqvh[category].table, q->sqvh[category].bits, 3);
584  if (p->bits_per_subpacket < get_bits_count(&q->gb)) {
585  vlc = 0;
586  result = 1;
587  }
588  for (j = vd - 1; j >= 0; j--) {
589  tmp = (vlc * invradix_tab[category]) / 0x100000;
590  subband_coef_index[vd * i + j] = vlc - tmp * (kmax_tab[category] + 1);
591  vlc = tmp;
592  }
593  for (j = 0; j < vd; j++) {
594  if (subband_coef_index[i * vd + j]) {
595  if (get_bits_count(&q->gb) < p->bits_per_subpacket) {
596  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  subband_coef_sign[i * vd + j] = 0;
603  }
604  }
605  }
606  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 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  int index = 0;
629 
630  for (band = 0; band < p->total_subbands; band++) {
631  index = category[band];
632  if (category[band] < 7) {
633  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  if (index >= 7) {
640  memset(subband_coef_index, 0, sizeof(subband_coef_index));
641  memset(subband_coef_sign, 0, sizeof(subband_coef_sign));
642  }
643  q->scalar_dequant(q, index, quant_index_table[band],
644  subband_coef_index, subband_coef_sign,
645  &mlt_buffer[band * SUBBAND_SIZE]);
646  }
647 
648  /* FIXME: should this be removed, or moved into loop above? */
649  if (p->total_subbands * SUBBAND_SIZE >= q->samples_per_channel)
650  return;
651 }
652 
653 
654 static int mono_decode(COOKContext *q, COOKSubpacket *p, float *mlt_buffer)
655 {
656  int category_index[128] = { 0 };
657  int category[128] = { 0 };
658  int quant_index_table[102];
659  int res, i;
660 
661  if ((res = decode_envelope(q, p, quant_index_table)) < 0)
662  return res;
663  q->num_vectors = get_bits(&q->gb, p->log2_numvector_size);
664  categorize(q, p, quant_index_table, category, category_index);
665  expand_category(q, category, category_index);
666  for (i=0; i<p->total_subbands; i++) {
667  if (category[i] > 7)
668  return AVERROR_INVALIDDATA;
669  }
670  decode_vectors(q, p, category, quant_index_table, mlt_buffer);
671 
672  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 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  fc1 = pow2tab[gain_index + 63];
690 
691  if (gain_index == gain_index_next) { // static gain
692  for (i = 0; i < q->gain_size_factor; i++)
693  buffer[i] *= fc1;
694  } else { // smooth gain
695  fc2 = q->gain_table[15 + (gain_index_next - gain_index)];
696  for (i = 0; i < q->gain_size_factor; i++) {
697  buffer[i] *= fc1;
698  fc1 *= fc2;
699  }
700  }
701 }
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 static void imlt_window_float(COOKContext *q, float *inbuffer,
712  cook_gains *gains_ptr, float *previous_buffer)
713 {
714  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  for (i = 0; i < q->samples_per_channel; i++)
724  inbuffer[i] = inbuffer[i] * fc * q->mlt_window[i] -
725  previous_buffer[i] * q->mlt_window[q->samples_per_channel - 1 - i];
726 }
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 static void imlt_gain(COOKContext *q, float *inbuffer,
740  cook_gains *gains_ptr, float *previous_buffer)
741 {
742  float *buffer0 = q->mono_mdct_output;
743  float *buffer1 = q->mono_mdct_output + q->samples_per_channel;
744  int i;
745 
746  /* Inverse modified discrete cosine transform */
747  q->mdct_fn(q->mdct_ctx, q->mono_mdct_output, inbuffer, sizeof(float));
748 
749  q->imlt_window(q, buffer1, gains_ptr, previous_buffer);
750 
751  /* Apply gain profile */
752  for (i = 0; i < 8; i++)
753  if (gains_ptr->now[i] || gains_ptr->now[i + 1])
754  q->interpolate(q, &buffer1[q->gain_size_factor * i],
755  gains_ptr->now[i], gains_ptr->now[i + 1]);
756 
757  /* Save away the current to be previous block. */
758  memcpy(previous_buffer, buffer0,
759  q->samples_per_channel * sizeof(*previous_buffer));
760 }
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 static int decouple_info(COOKContext *q, COOKSubpacket *p, int *decouple_tab)
770 {
771  int i;
772  int vlc = get_bits1(&q->gb);
773  int start = cplband[p->js_subband_start];
774  int end = cplband[p->subbands - 1];
775  int length = end - start + 1;
776 
777  if (start > end)
778  return 0;
779 
780  if (vlc)
781  for (i = 0; i < length; i++)
782  decouple_tab[start + i] = get_vlc2(&q->gb,
784  COUPLING_VLC_BITS, 3);
785  else
786  for (i = 0; i < length; i++) {
787  int v = get_bits(&q->gb, p->js_vlc_bits);
788  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  decouple_tab[start + i] = v;
793  }
794  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 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  for (j = 0; j < SUBBAND_SIZE; j++) {
817  tmp_idx = ((p->js_subband_start + subband) * SUBBAND_SIZE) + j;
818  mlt_buffer1[SUBBAND_SIZE * subband + j] = f1 * decode_buffer[tmp_idx];
819  mlt_buffer2[SUBBAND_SIZE * subband + j] = f2 * decode_buffer[tmp_idx];
820  }
821 }
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 static int joint_decode(COOKContext *q, COOKSubpacket *p,
831  float *mlt_buffer_left, float *mlt_buffer_right)
832 {
833  int i, j, res;
834  int decouple_tab[SUBBAND_SIZE] = { 0 };
835  float *decode_buffer = q->decode_buffer_0;
836  int idx, cpl_tmp;
837  float f1, f2;
838  const float *cplscale;
839 
840  memset(decode_buffer, 0, sizeof(q->decode_buffer_0));
841 
842  /* Make sure the buffers are zeroed out. */
843  memset(mlt_buffer_left, 0, 1024 * sizeof(*mlt_buffer_left));
844  memset(mlt_buffer_right, 0, 1024 * sizeof(*mlt_buffer_right));
845  if ((res = decouple_info(q, p, decouple_tab)) < 0)
846  return res;
847  if ((res = mono_decode(q, p, decode_buffer)) < 0)
848  return res;
849  /* The two channels are stored interleaved in decode_buffer. */
850  for (i = 0; i < p->js_subband_start; i++) {
851  for (j = 0; j < SUBBAND_SIZE; j++) {
852  mlt_buffer_left[i * 20 + j] = decode_buffer[i * 40 + j];
853  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  idx = (1 << p->js_vlc_bits) - 1;
860  for (i = p->js_subband_start; i < p->subbands; i++) {
861  cpl_tmp = cplband[i];
862  idx -= decouple_tab[cpl_tmp];
863  cplscale = q->cplscales[p->js_vlc_bits - 2]; // choose decoupler table
864  f1 = cplscale[decouple_tab[cpl_tmp] + 1];
865  f2 = cplscale[idx];
866  q->decouple(q, p, i, f1, f2, decode_buffer,
867  mlt_buffer_left, mlt_buffer_right);
868  idx = (1 << p->js_vlc_bits) - 1;
869  }
870 
871  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 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  offset = decode_bytes(inbuffer, q->decoded_bytes_buffer,
889  p->bits_per_subpacket / 8);
890  init_get_bits(&q->gb, q->decoded_bytes_buffer + offset,
891  p->bits_per_subpacket);
892  decode_gain_info(&q->gb, gains_ptr->now);
893 
894  /* Swap current and previous gains */
895  FFSWAP(int *, gains_ptr->now, gains_ptr->previous);
896 }
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 static void saturate_output_float(COOKContext *q, float *out)
905 {
906  q->adsp.vector_clipf(out, q->mono_mdct_output + q->samples_per_channel,
907  FFALIGN(q->samples_per_channel, 8), -1.0f, 1.0f);
908 }
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 static inline void mlt_compensate_output(COOKContext *q, float *decode_buffer,
923  cook_gains *gains_ptr, float *previous_buffer,
924  float *out)
925 {
926  imlt_gain(q, decode_buffer, gains_ptr, previous_buffer);
927  if (out)
928  q->saturate_output(q, out);
929 }
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 static int decode_subpacket(COOKContext *q, COOKSubpacket *p,
941  const uint8_t *inbuffer, float **outbuffer)
942 {
943  int sub_packet_size = p->size;
944  int res;
945 
946  memset(q->decode_buffer_1, 0, sizeof(q->decode_buffer_1));
947  decode_bytes_and_gain(q, p, inbuffer, &p->gains1);
948 
949  if (p->joint_stereo) {
950  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  mlt_compensate_output(q, q->decode_buffer_1, &p->gains1,
965  outbuffer ? outbuffer[p->ch_idx] : NULL);
966 
967  if (p->num_channels == 2) {
968  if (p->joint_stereo)
969  mlt_compensate_output(q, q->decode_buffer_2, &p->gains1,
971  outbuffer ? outbuffer[p->ch_idx + 1] : NULL);
972  else
973  mlt_compensate_output(q, q->decode_buffer_2, &p->gains2,
975  outbuffer ? outbuffer[p->ch_idx + 1] : NULL);
976  }
977 
978  return 0;
979 }
980 
981 
983  int *got_frame_ptr, AVPacket *avpkt)
984 {
985  const uint8_t *buf = avpkt->data;
986  int buf_size = avpkt->size;
987  COOKContext *q = avctx->priv_data;
988  float **samples = NULL;
989  int i, ret;
990  int offset = 0;
991  int chidx = 0;
992 
993  if (buf_size < avctx->block_align)
994  return buf_size;
995 
996  /* get output buffer */
997  if (q->discarded_packets >= 2) {
998  frame->nb_samples = q->samples_per_channel;
999  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1000  return ret;
1001  samples = (float **)frame->extended_data;
1002  }
1003 
1004  /* estimate subpacket sizes */
1005  q->subpacket[0].size = avctx->block_align;
1006 
1007  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) {
1012  "frame subpacket size total > avctx->block_align!\n");
1013  return AVERROR_INVALIDDATA;
1014  }
1015  }
1016 
1017  /* decode supbackets */
1018  for (i = 0; i < q->num_subpackets; i++) {
1019  q->subpacket[i].bits_per_subpacket = (q->subpacket[i].size * 8) >>
1020  q->subpacket[i].bits_per_subpdiv;
1021  q->subpacket[i].ch_idx = chidx;
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  if ((ret = decode_subpacket(q, &q->subpacket[i], buf + offset, samples)) < 0)
1028  return ret;
1029  offset += q->subpacket[i].size;
1030  chidx += q->subpacket[i].num_channels;
1031  av_log(avctx, AV_LOG_DEBUG, "subpacket[%i] %i %i\n",
1032  i, q->subpacket[i].size * 8, get_bits_count(&q->gb));
1033  }
1034 
1035  /* Discard the first two frames: no valid audio. */
1036  if (q->discarded_packets < 2) {
1037  q->discarded_packets++;
1038  *got_frame_ptr = 0;
1039  return avctx->block_align;
1040  }
1041 
1042  *got_frame_ptr = 1;
1043 
1044  return avctx->block_align;
1045 }
1046 
1047 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  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 }
1068 
1069 /**
1070  * Cook initialization
1071  *
1072  * @param avctx pointer to the AVCodecContext
1073  */
1075 {
1076  static AVOnce init_static_once = AV_ONCE_INIT;
1077  COOKContext *q = avctx->priv_data;
1079  int s = 0;
1080  unsigned int channel_mask = 0;
1081  int samples_per_frame = 0;
1082  int ret;
1084 
1085  q->avctx = avctx;
1086 
1087  /* Take care of the codec specific extradata. */
1088  if (avctx->extradata_size < 8) {
1089  av_log(avctx, AV_LOG_ERROR, "Necessary extradata missing!\n");
1090  return AVERROR_INVALIDDATA;
1091  }
1092  av_log(avctx, AV_LOG_DEBUG, "codecdata_length=%d\n", avctx->extradata_size);
1093 
1095 
1096  /* Take data from the AVCodecContext (RM container). */
1097  if (!channels) {
1098  av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
1099  return AVERROR_INVALIDDATA;
1100  }
1101 
1102  if (avctx->block_align >= INT_MAX / 8)
1103  return AVERROR(EINVAL);
1104 
1105  /* Initialize RNG. */
1106  av_lfg_init(&q->random_state, 0);
1107 
1108  ff_audiodsp_init(&q->adsp);
1109 
1110  while (bytestream2_get_bytes_left(&gb)) {
1111  if (s >= 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  q->subpacket[s].cookversion = bytestream2_get_be32(&gb);
1118  samples_per_frame = bytestream2_get_be16(&gb);
1119  q->subpacket[s].subbands = bytestream2_get_be16(&gb);
1120  bytestream2_get_be32(&gb); // Unknown unused
1121  q->subpacket[s].js_subband_start = bytestream2_get_be16(&gb);
1122  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  q->subpacket[s].js_vlc_bits = bytestream2_get_be16(&gb);
1127 
1128  /* Initialize extradata related variables. */
1129  q->subpacket[s].samples_per_channel = samples_per_frame / channels;
1130  q->subpacket[s].bits_per_subpacket = avctx->block_align * 8;
1131 
1132  /* Initialize default data states. */
1133  q->subpacket[s].log2_numvector_size = 5;
1134  q->subpacket[s].total_subbands = q->subpacket[s].subbands;
1135  q->subpacket[s].num_channels = 1;
1136 
1137  /* Initialize version-dependent variables */
1138 
1139  av_log(avctx, AV_LOG_DEBUG, "subpacket[%i].cookversion=%x\n", s,
1140  q->subpacket[s].cookversion);
1141  q->subpacket[s].joint_stereo = 0;
1142  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  case STEREO:
1151  if (channels != 1) {
1152  q->subpacket[s].bits_per_subpdiv = 1;
1153  q->subpacket[s].num_channels = 2;
1154  }
1155  av_log(avctx, AV_LOG_DEBUG, "STEREO\n");
1156  break;
1157  case JOINT_STEREO:
1158  if (channels != 2) {
1159  avpriv_request_sample(avctx, "Container channels != 2");
1160  return AVERROR_PATCHWELCOME;
1161  }
1162  av_log(avctx, AV_LOG_DEBUG, "JOINT_STEREO\n");
1163  if (avctx->extradata_size >= 16) {
1164  q->subpacket[s].total_subbands = q->subpacket[s].subbands +
1165  q->subpacket[s].js_subband_start;
1166  q->subpacket[s].joint_stereo = 1;
1167  q->subpacket[s].num_channels = 2;
1168  }
1169  if (q->subpacket[s].samples_per_channel > 256) {
1170  q->subpacket[s].log2_numvector_size = 6;
1171  }
1172  if (q->subpacket[s].samples_per_channel > 512) {
1173  q->subpacket[s].log2_numvector_size = 7;
1174  }
1175  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  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  q->samples_per_channel = q->subpacket[0].samples_per_channel;
1208 
1209 
1210  /* Initialize variable relations */
1211  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  if (q->subpacket[s].total_subbands > 53) {
1215  avpriv_request_sample(avctx, "total_subbands > 53");
1216  return AVERROR_PATCHWELCOME;
1217  }
1218 
1219  if ((q->subpacket[s].js_vlc_bits > 6) ||
1220  (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  if (q->subpacket[s].subbands > 50) {
1227  avpriv_request_sample(avctx, "subbands > 50");
1228  return AVERROR_PATCHWELCOME;
1229  }
1230  if (q->subpacket[s].subbands == 0) {
1231  avpriv_request_sample(avctx, "subbands = 0");
1232  return AVERROR_PATCHWELCOME;
1233  }
1234  q->subpacket[s].gains1.now = q->subpacket[s].gain_1;
1235  q->subpacket[s].gains1.previous = q->subpacket[s].gain_2;
1236  q->subpacket[s].gains2.now = q->subpacket[s].gain_3;
1237  q->subpacket[s].gains2.previous = q->subpacket[s].gain_4;
1238 
1239  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  q->num_subpackets++;
1245  s++;
1246  }
1247 
1248  /* Try to catch some obviously faulty streams, otherwise it might be exploitable */
1249  if (q->samples_per_channel != 256 && q->samples_per_channel != 512 &&
1250  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  ff_thread_once(&init_static_once, init_pow2table);
1258  init_gain_table(q);
1260 
1261  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  q->decoded_bytes_buffer =
1271  if (!q->decoded_bytes_buffer)
1272  return AVERROR(ENOMEM);
1273 
1274  /* Initialize transform. */
1275  if ((ret = init_cook_mlt(q)))
1276  return ret;
1277 
1278  /* Initialize COOK signal arithmetic handling */
1279  if (1) {
1280  q->scalar_dequant = scalar_dequant_float;
1281  q->decouple = decouple_float;
1282  q->imlt_window = imlt_window_float;
1283  q->interpolate = interpolate_float;
1284  q->saturate_output = saturate_output_float;
1285  }
1286 
1289  if (channel_mask)
1290  av_channel_layout_from_mask(&avctx->ch_layout, channel_mask);
1291  else
1293 
1294 
1295  dump_cook_context(q);
1296 
1297  return 0;
1298 }
1299 
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),
1307  .close = cook_decode_close,
1309  .p.capabilities = AV_CODEC_CAP_DR1,
1310  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1312  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1313 };
decode_vectors
static void decode_vectors(COOKContext *q, COOKSubpacket *p, int *category, int *quant_index_table, float *mlt_buffer)
Fill the mlt_buffer with mlt coefficients.
Definition: cook.c:618
mono_decode
static int mono_decode(COOKContext *q, COOKSubpacket *p, float *mlt_buffer)
Definition: cook.c:654
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
COOKSubpacket::log2_numvector_size
int log2_numvector_size
Definition: cook.c:88
mem_internal.h
cook::gb
GetBitContext gb
Definition: cook.c:134
out
FILE * out
Definition: movenc.c:54
cook::mdct_fn
av_tx_fn mdct_fn
Definition: cook.c:144
cook_decode_init
static av_cold int cook_decode_init(AVCodecContext *avctx)
Cook initialization.
Definition: cook.c:1074
av_lfg_init
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
GetByteContext
Definition: bytestream.h:33
av_popcount64
#define av_popcount64
Definition: common.h:152
thread.h
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:119
init_pow2table
static av_cold void init_pow2table(void)
Definition: cook.c:174
decode_gain_info
static void decode_gain_info(GetBitContext *gb, int *gaininfo)
Fill the gain array for the timedomain quantization.
Definition: cook.c:361
cook::interpolate
void(* interpolate)(struct cook *q, float *buffer, int gain_index, int gain_index_next)
Definition: cook.c:127
AVTXContext
Definition: tx_priv.h:225
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
unpack_SQVH
static int unpack_SQVH(COOKContext *q, COOKSubpacket *p, int category, int *subband_coef_index, int *subband_coef_sign)
Unpack the subband_coef_index and subband_coef_sign vectors.
Definition: cook.c:574
cook::gain_size_factor
int gain_size_factor
Definition: cook.c:152
cook::gain_table
float gain_table[31]
Definition: cook.c:153
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVPacket::data
uint8_t * data
Definition: packet.h:374
cook_gains
Definition: cook.c:74
scalar_dequant_float
static void scalar_dequant_float(COOKContext *q, int index, int quant_index, int *subband_coef_index, int *subband_coef_sign, float *mlt_p)
The real requantization of the mltcoefs.
Definition: cook.c:545
FFCodec
Definition: codec_internal.h:119
ff_audiodsp_init
av_cold void ff_audiodsp_init(AudioDSPContext *c)
Definition: audiodsp.c:106
category
category
Definition: openal-dec.c:248
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:551
COOKSubpacket::joint_stereo
int joint_stereo
Definition: cook.c:91
STEREO
#define STEREO
Definition: cook.c:64
max
#define max(a, b)
Definition: cuda_runtime.h:33
subbands
subbands
Definition: aptx.h:37
cook::scalar_dequant
void(* scalar_dequant)(struct cook *q, int index, int quant_index, int *subband_coef_index, int *subband_coef_sign, float *mlt_p)
Definition: cook.c:113
COUPLING_VLC_BITS
#define COUPLING_VLC_BITS
Definition: cook.c:72
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:311
cook_decode_close
static av_cold int cook_decode_close(AVCodecContext *avctx)
Definition: cook.c:329
COOKSubpacket::js_subband_start
int js_subband_start
Definition: cook.c:85
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:649
DECODE_BYTES_PAD1
#define DECODE_BYTES_PAD1(bytes)
Definition: cook.c:280
av_tx_init
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition: tx.c:883
init_cook_mlt
static av_cold int init_cook_mlt(COOKContext *q)
Definition: cook.c:248
cook
Definition: cook.c:108
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
JOINT_STEREO
#define JOINT_STEREO
Definition: cook.c:65
expbits_tab
static const int expbits_tab[8]
Definition: cookdata.h:35
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2059
GetBitContext
Definition: get_bits.h:61
cook::mdct_ctx
AVTXContext * mdct_ctx
Definition: cook.c:143
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
PRINT
#define PRINT(a, b)
decode_bytes
static int decode_bytes(const uint8_t *inbuffer, uint8_t *out, int bytes)
Cook indata decoding, every 32 bits are XORed with 0x37c511f2.
Definition: cook.c:303
COOKSubpacket::gain_3
int gain_3[9]
Definition: cook.c:104
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
decode_subpacket
static int decode_subpacket(COOKContext *q, COOKSubpacket *p, const uint8_t *inbuffer, float **outbuffer)
Cook subpacket decoding.
Definition: cook.c:940
dither_tab
static const float dither_tab[9]
Definition: cookdata.h:39
AV_BE2NE32C
#define AV_BE2NE32C(x)
Definition: bswap.h:105
COOKSubpacket::numvector_size
int numvector_size
Definition: cook.c:95
init_cplscales_table
static av_cold void init_cplscales_table(COOKContext *q)
Definition: cook.c:271
saturate_output_float
static void saturate_output_float(COOKContext *q, float *out)
Saturate the output signal and interleave.
Definition: cook.c:904
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:184
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
cook::num_subpackets
int num_subpackets
Definition: cook.c:164
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
av_tx_fn
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition: tx.h:127
quant_centroid_tab
static const float quant_centroid_tab[7][14]
Definition: cookdata.h:43
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:500
AV_TX_FLOAT_MDCT
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
Definition: tx.h:68
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
s
#define s(width, name)
Definition: cbs_vp9.c:256
cook::cplscales
const float * cplscales[5]
Definition: cook.c:163
init_cook_vlc_tables
static av_cold int init_cook_vlc_tables(COOKContext *q)
Definition: cook.c:216
av_lfg_get
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:53
vhvlcsize_tab
static const int vhvlcsize_tab[7]
Definition: cookdata.h:75
COOKSubpacket::samples_per_channel
int samples_per_channel
Definition: cook.c:87
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
av_channel_layout_from_mask
FF_ENABLE_DEPRECATION_WARNINGS int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
Definition: channel_layout.c:391
lfg.h
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
cook::decouple
void(* decouple)(struct cook *q, COOKSubpacket *p, int subband, float f1, float f2, float *decode_buffer, float *mlt_buffer1, float *mlt_buffer2)
Definition: cook.c:117
channels
channels
Definition: aptx.h:31
decode.h
get_bits.h
cook::decode_buffer_1
float decode_buffer_1[1024]
Definition: cook.c:159
COOKSubpacket::js_vlc_bits
int js_vlc_bits
Definition: cook.c:86
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
ff_cook_decoder
const FFCodec ff_cook_decoder
Definition: cook.c:1300
AV_TX_FULL_IMDCT
@ AV_TX_FULL_IMDCT
Performs a full inverse MDCT rather than leaving out samples that can be derived through symmetry.
Definition: tx.h:151
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:182
vd_tab
static const int vd_tab[7]
Definition: cookdata.h:61
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
bias
static int bias(int x, int c)
Definition: vqcdec.c:110
imlt_window_float
static void imlt_window_float(COOKContext *q, float *inbuffer, cook_gains *gains_ptr, float *previous_buffer)
Apply transform window, overlap buffers.
Definition: cook.c:711
COOKSubpacket::bits_per_subpacket
int bits_per_subpacket
Definition: cook.c:92
decouple_float
static void decouple_float(COOKContext *q, COOKSubpacket *p, int subband, float f1, float f2, float *decode_buffer, float *mlt_buffer1, float *mlt_buffer2)
function decouples a pair of signals from a single signal via multiplication.
Definition: cook.c:808
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
ff_init_vlc_from_lengths
int ff_init_vlc_from_lengths(VLC *vlc, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
Definition: vlc.c:328
dump_cook_context
static void dump_cook_context(COOKContext *q)
Definition: cook.c:1047
MC_COOK
#define MC_COOK
Definition: cook.c:66
COOKSubpacket::num_channels
int num_channels
Definition: cook.c:82
mlt_compensate_output
static void mlt_compensate_output(COOKContext *q, float *decode_buffer, cook_gains *gains_ptr, float *previous_buffer, float *out)
Final part of subpacket decoding: Apply modulated lapped transform, gain compensation,...
Definition: cook.c:922
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:787
AVOnce
#define AVOnce
Definition: thread.h:181
index
int index
Definition: gxfenc.c:89
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
vpr_tab
static const int vpr_tab[7]
Definition: cookdata.h:65
build_vlc
static av_cold int build_vlc(VLC *vlc, int nb_bits, const uint8_t counts[16], const void *syms, int symbol_size, int offset, void *logctx)
Definition: cook.c:200
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
cook::sqvh
VLC sqvh[7]
Definition: cook.c:149
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
cook::subpacket
COOKSubpacket subpacket[MAX_SUBPACKETS]
Definition: cook.c:165
cplscales
static const float *const cplscales[5]
Definition: cookdata.h:357
cvh_huffcounts
static const uint8_t cvh_huffcounts[7][16]
Definition: cookdata.h:125
AVLFG
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1450
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:375
powf
#define powf(x, y)
Definition: libm.h:50
cook::random_state
AVLFG random_state
Definition: cook.c:139
codec_internal.h
COOKSubpacket
Definition: cook.c:79
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1023
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
COOKSubpacket::gains1
cook_gains gains1
Definition: cook.c:100
COOKSubpacket::ch_idx
int ch_idx
Definition: cook.c:80
MAX_SUBPACKETS
#define MAX_SUBPACKETS
Definition: cook.c:69
imlt_gain
static void imlt_gain(COOKContext *q, float *inbuffer, cook_gains *gains_ptr, float *previous_buffer)
The modulated lapped transform, this takes transform coefficients and transforms them into timedomain...
Definition: cook.c:739
COOKSubpacket::cookversion
int cookversion
Definition: cook.c:83
sinewin.h
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
COOKSubpacket::size
int size
Definition: cook.c:81
unary.h
av_tx_uninit
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition: tx.c:294
COOKSubpacket::channel_mask
unsigned int channel_mask
Definition: cook.c:89
ff_sine_window_init
void ff_sine_window_init(float *window, int n)
Generate a sine window.
Definition: sinewin_tablegen.h:59
COOKSubpacket::gain_1
int gain_1[9]
Definition: cook.c:102
MAX_COOK_VLC_ENTRIES
#define MAX_COOK_VLC_ENTRIES
Definition: cookdata.h:73
av_channel_layout_default
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
Get the default channel layout for a given number of channels.
Definition: channel_layout.c:962
kmax_tab
static const int kmax_tab[7]
Definition: cookdata.h:57
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
cook::avctx
AVCodecContext * avctx
Definition: cook.c:132
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
COOKSubpacket::mono_previous_buffer1
float mono_previous_buffer1[1024]
Definition: cook.c:97
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:499
COOKSubpacket::subbands
int subbands
Definition: cook.c:84
QUANT_VLC_BITS
#define QUANT_VLC_BITS
Definition: cook.c:71
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
cook::samples_per_channel
int samples_per_channel
Definition: cook.c:137
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
decode_envelope
static int decode_envelope(COOKContext *q, COOKSubpacket *p, int *quant_index_table)
Create the quant index table needed for the envelope.
Definition: cook.c:385
cookdata.h
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: vlc.c:375
avcodec.h
MONO
#define MONO
Definition: cook.c:63
ret
ret
Definition: filter_design.txt:187
decouple_info
static int decouple_info(COOKContext *q, COOKSubpacket *p, int *decouple_tab)
function for getting the jointstereo coupling information
Definition: cook.c:769
pow2tab
static float pow2tab[127]
Definition: cook.c:168
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1052
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
interpolate_float
static void interpolate_float(COOKContext *q, float *buffer, int gain_index, int gain_index_next)
the actual requantization of the timedomain samples
Definition: cook.c:684
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AVCodecContext
main external API structure.
Definition: avcodec.h:398
cook::mlt_window
float * mlt_window
Definition: cook.c:145
channel_layout.h
rootpow2tab
static float rootpow2tab[127]
Definition: cook.c:169
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
cook::num_vectors
int num_vectors
Definition: cook.c:136
ccpl_huffsyms
static const uint8_t *const ccpl_huffsyms[5]
Definition: cookdata.h:278
VLC
Definition: vlc.h:31
COOKSubpacket::mono_previous_buffer2
float mono_previous_buffer2[1024]
Definition: cook.c:98
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:632
cook::decoded_bytes_buffer
uint8_t * decoded_bytes_buffer
Definition: cook.c:157
cook_decode_frame
static int cook_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: cook.c:982
cook_gains::previous
int * previous
Definition: cook.c:76
init_gain_table
static av_cold void init_gain_table(COOKContext *q)
Definition: cook.c:191
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
VLC::table
VLCElem * table
Definition: vlc.h:33
COOKSubpacket::gains2
cook_gains gains2
Definition: cook.c:101
joint_decode
static int joint_decode(COOKContext *q, COOKSubpacket *p, float *mlt_buffer_left, float *mlt_buffer_right)
function for decoding joint stereo data
Definition: cook.c:830
SUBBAND_SIZE
#define SUBBAND_SIZE
Definition: cook.c:68
envelope_quant_index_huffcounts
static const uint8_t envelope_quant_index_huffcounts[13][16]
Definition: cookdata.h:79
cook::envelope_quant_index
VLC envelope_quant_index[13]
Definition: cook.c:148
cook::imlt_window
void(* imlt_window)(struct cook *q, float *buffer1, cook_gains *gains_ptr, float *previous_buffer)
Definition: cook.c:124
audiodsp.h
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
M_SQRT2
#define M_SQRT2
Definition: mathematics.h:61
COOKSubpacket::gain_2
int gain_2[9]
Definition: cook.c:103
AudioDSPContext
Definition: audiodsp.h:24
cook_gains::now
int * now
Definition: cook.c:75
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
ccpl_huffcounts
static const uint8_t ccpl_huffcounts[5][16]
Definition: cookdata.h:270
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
cook::saturate_output
void(* saturate_output)(struct cook *q, float *out)
Definition: cook.c:130
COOKSubpacket::total_subbands
int total_subbands
Definition: cook.c:94
cvh_huffsyms
static const void *const cvh_huffsyms[7]
Definition: cookdata.h:241
cook::decode_buffer_0
float decode_buffer_0[1060]
Definition: cook.c:161
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
categorize
static void categorize(COOKContext *q, COOKSubpacket *p, const int *quant_index_table, int *category, int *category_index)
Calculate the category and category_index vector.
Definition: cook.c:426
cook::discarded_packets
int discarded_packets
Definition: cook.c:140
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_CODEC_ID_COOK
@ AV_CODEC_ID_COOK
Definition: codec_id.h:455
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
cplband
static const int cplband[51]
Definition: cookdata.h:285
COOKSubpacket::gain_4
int gain_4[9]
Definition: cook.c:105
cook::mono_mdct_output
float mono_mdct_output[2048]
Definition: cook.c:158
envelope_quant_index_huffsyms
static const uint8_t envelope_quant_index_huffsyms[13][24]
Definition: cookdata.h:95
cook::decode_buffer_2
float decode_buffer_2[1024]
Definition: cook.c:160
expand_category
static void expand_category(COOKContext *q, int *category, int *category_index)
Expand the category vector.
Definition: cook.c:523
tx.h
cook::adsp
AudioDSPContext adsp
Definition: cook.c:133
COOKSubpacket::bits_per_subpdiv
int bits_per_subpdiv
Definition: cook.c:93
invradix_tab
static const int invradix_tab[7]
Definition: cookdata.h:53
min
float min
Definition: vorbis_enc_data.h:429
COOKSubpacket::channel_coupling
VLC channel_coupling
Definition: cook.c:90
decode_bytes_and_gain
static void decode_bytes_and_gain(COOKContext *q, COOKSubpacket *p, const uint8_t *inbuffer, cook_gains *gains_ptr)
First part of subpacket decoding: decode raw stream bytes and read gain info.
Definition: cook.c:882