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