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