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 
49 #include "audiodsp.h"
50 #include "avcodec.h"
51 #include "get_bits.h"
52 #include "bytestream.h"
53 #include "fft.h"
54 #include "internal.h"
55 #include "sinewin.h"
56 #include "unary.h"
57 
58 #include "cookdata.h"
59 
60 /* the different Cook versions */
61 #define MONO 0x1000001
62 #define STEREO 0x1000002
63 #define JOINT_STEREO 0x1000003
64 #define MC_COOK 0x2000000
65 
66 #define SUBBAND_SIZE 20
67 #define MAX_SUBPACKETS 5
68 
69 #define QUANT_VLC_BITS 9
70 #define COUPLING_VLC_BITS 6
71 
72 typedef struct cook_gains {
73  int *now;
74  int *previous;
75 } cook_gains;
76 
77 typedef struct COOKSubpacket {
78  int ch_idx;
79  int size;
82  int subbands;
87  unsigned int channel_mask;
93  int numvector_size; // 1 << log2_numvector_size;
94 
95  float mono_previous_buffer1[1024];
96  float mono_previous_buffer2[1024];
97 
100  int gain_1[9];
101  int gain_2[9];
102  int gain_3[9];
103  int gain_4[9];
104 } COOKSubpacket;
105 
106 typedef struct cook {
107  /*
108  * The following 5 functions provide the lowlevel arithmetic on
109  * the internal audio buffers.
110  */
111  void (*scalar_dequant)(struct cook *q, int index, int quant_index,
112  int *subband_coef_index, int *subband_coef_sign,
113  float *mlt_p);
114 
115  void (*decouple)(struct cook *q,
116  COOKSubpacket *p,
117  int subband,
118  float f1, float f2,
119  float *decode_buffer,
120  float *mlt_buffer1, float *mlt_buffer2);
121 
122  void (*imlt_window)(struct cook *q, float *buffer1,
123  cook_gains *gains_ptr, float *previous_buffer);
124 
125  void (*interpolate)(struct cook *q, float *buffer,
126  int gain_index, int gain_index_next);
127 
128  void (*saturate_output)(struct cook *q, float *out);
129 
133  /* stream data */
136  /* states */
139 
140  /* transform data */
142  float* mlt_window;
143 
144  /* VLC data */
145  VLC envelope_quant_index[13];
146  VLC sqvh[7]; // scalar quantization
147 
148  /* generate tables and related variables */
150  float gain_table[31];
151 
152  /* data buffers */
153 
155  DECLARE_ALIGNED(32, float, mono_mdct_output)[2048];
156  float decode_buffer_1[1024];
157  float decode_buffer_2[1024];
158  float decode_buffer_0[1060]; /* static allocation for joint decode */
159 
160  const float *cplscales[5];
163 } COOKContext;
164 
165 static float pow2tab[127];
166 static float rootpow2tab[127];
167 
168 /*************** init functions ***************/
169 
170 /* table generator */
171 static av_cold void init_pow2table(void)
172 {
173  /* fast way of computing 2^i and 2^(0.5*i) for -63 <= i < 64 */
174  int i;
175  static const float exp2_tab[2] = {1, M_SQRT2};
176  float exp2_val = powf(2, -63);
177  float root_val = powf(2, -32);
178  for (i = -63; i < 64; i++) {
179  if (!(i & 1))
180  root_val *= 2;
181  pow2tab[63 + i] = exp2_val;
182  rootpow2tab[63 + i] = root_val * exp2_tab[i & 1];
183  exp2_val *= 2;
184  }
185 }
186 
187 /* table generator */
189 {
190  int i;
192  for (i = 0; i < 31; i++)
193  q->gain_table[i] = pow(pow2tab[i + 48],
194  (1.0 / (double) q->gain_size_factor));
195 }
196 
197 static av_cold int build_vlc(VLC *vlc, int nb_bits, const uint8_t counts[16],
198  const void *syms, int symbol_size, int offset,
199  void *logctx)
200 {
202  unsigned num = 0;
203 
204  for (int i = 0; i < 16; i++)
205  for (unsigned count = num + counts[i]; num < count; num++)
206  lens[num] = i + 1;
207 
208  return ff_init_vlc_from_lengths(vlc, nb_bits, num, lens, 1,
209  syms, symbol_size, symbol_size,
210  offset, 0, logctx);
211 }
212 
214 {
215  int i, result;
216 
217  result = 0;
218  for (i = 0; i < 13; i++) {
221  envelope_quant_index_huffsyms[i], 1, -12, q->avctx);
222  }
223  av_log(q->avctx, AV_LOG_DEBUG, "sqvh VLC init\n");
224  for (i = 0; i < 7; i++) {
225  int sym_size = 1 + (i == 3);
226  result |= build_vlc(&q->sqvh[i], vhvlcsize_tab[i],
227  cvh_huffcounts[i],
228  cvh_huffsyms[i], sym_size, 0, q->avctx);
229  }
230 
231  for (i = 0; i < q->num_subpackets; i++) {
232  if (q->subpacket[i].joint_stereo == 1) {
235  ccpl_huffsyms[q->subpacket[i].js_vlc_bits - 2], 1,
236  0, q->avctx);
237  av_log(q->avctx, AV_LOG_DEBUG, "subpacket %i Joint-stereo VLC used.\n", i);
238  }
239  }
240 
241  av_log(q->avctx, AV_LOG_DEBUG, "VLC tables initialized.\n");
242  return result;
243 }
244 
246 {
247  int j, ret;
248  int mlt_size = q->samples_per_channel;
249 
250  if ((q->mlt_window = av_malloc_array(mlt_size, sizeof(*q->mlt_window))) == 0)
251  return AVERROR(ENOMEM);
252 
253  /* Initialize the MLT window: simple sine window. */
254  ff_sine_window_init(q->mlt_window, mlt_size);
255  for (j = 0; j < mlt_size; j++)
256  q->mlt_window[j] *= sqrt(2.0 / q->samples_per_channel);
257 
258  /* Initialize the MDCT. */
259  if ((ret = ff_mdct_init(&q->mdct_ctx, av_log2(mlt_size) + 1, 1, 1.0 / 32768.0))) {
260  av_freep(&q->mlt_window);
261  return ret;
262  }
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 
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);
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++)
343  for (i = 0; i < 7; i++)
344  ff_free_vlc(&q->sqvh[i]);
345  for (i = 0; i < q->num_subpackets; i++)
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  */
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) {
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  */
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  */
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? */
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;
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  */
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  */
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  */
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 {
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  */
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 
963  outbuffer ? outbuffer[p->ch_idx] : NULL);
964 
965  if (p->num_channels == 2) {
966  if (p->joint_stereo)
969  outbuffer ? outbuffer[p->ch_idx + 1] : NULL);
970  else
973  outbuffer ? outbuffer[p->ch_idx + 1] : NULL);
974  }
975 
976  return 0;
977 }
978 
979 
980 static int cook_decode_frame(AVCodecContext *avctx, void *data,
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) {
1010  av_log(avctx, AV_LOG_DEBUG,
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) >>
1020  q->subpacket[i].ch_idx = chidx;
1021  av_log(avctx, AV_LOG_DEBUG,
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 
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  COOKContext *q = avctx->priv_data;
1076  GetByteContext gb;
1077  int s = 0;
1078  unsigned int channel_mask = 0;
1079  int samples_per_frame = 0;
1080  int ret;
1081  q->avctx = avctx;
1082 
1083  /* Take care of the codec specific extradata. */
1084  if (avctx->extradata_size < 8) {
1085  av_log(avctx, AV_LOG_ERROR, "Necessary extradata missing!\n");
1086  return AVERROR_INVALIDDATA;
1087  }
1088  av_log(avctx, AV_LOG_DEBUG, "codecdata_length=%d\n", avctx->extradata_size);
1089 
1090  bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
1091 
1092  /* Take data from the AVCodecContext (RM container). */
1093  if (!avctx->channels) {
1094  av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
1095  return AVERROR_INVALIDDATA;
1096  }
1097 
1098  if (avctx->block_align >= INT_MAX / 8)
1099  return AVERROR(EINVAL);
1100 
1101  /* Initialize RNG. */
1102  av_lfg_init(&q->random_state, 0);
1103 
1104  ff_audiodsp_init(&q->adsp);
1105 
1106  while (bytestream2_get_bytes_left(&gb)) {
1107  if (s >= FFMIN(MAX_SUBPACKETS, avctx->block_align)) {
1108  avpriv_request_sample(avctx, "subpackets > %d", FFMIN(MAX_SUBPACKETS, avctx->block_align));
1109  return AVERROR_PATCHWELCOME;
1110  }
1111  /* 8 for mono, 16 for stereo, ? for multichannel
1112  Swap to right endianness so we don't need to care later on. */
1113  q->subpacket[s].cookversion = bytestream2_get_be32(&gb);
1114  samples_per_frame = bytestream2_get_be16(&gb);
1115  q->subpacket[s].subbands = bytestream2_get_be16(&gb);
1116  bytestream2_get_be32(&gb); // Unknown unused
1117  q->subpacket[s].js_subband_start = bytestream2_get_be16(&gb);
1118  if (q->subpacket[s].js_subband_start >= 51) {
1119  av_log(avctx, AV_LOG_ERROR, "js_subband_start %d is too large\n", q->subpacket[s].js_subband_start);
1120  return AVERROR_INVALIDDATA;
1121  }
1122  q->subpacket[s].js_vlc_bits = bytestream2_get_be16(&gb);
1123 
1124  /* Initialize extradata related variables. */
1125  q->subpacket[s].samples_per_channel = samples_per_frame / avctx->channels;
1126  q->subpacket[s].bits_per_subpacket = avctx->block_align * 8;
1127 
1128  /* Initialize default data states. */
1131  q->subpacket[s].num_channels = 1;
1132 
1133  /* Initialize version-dependent variables */
1134 
1135  av_log(avctx, AV_LOG_DEBUG, "subpacket[%i].cookversion=%x\n", s,
1136  q->subpacket[s].cookversion);
1137  q->subpacket[s].joint_stereo = 0;
1138  switch (q->subpacket[s].cookversion) {
1139  case MONO:
1140  if (avctx->channels != 1) {
1141  avpriv_request_sample(avctx, "Container channels != 1");
1142  return AVERROR_PATCHWELCOME;
1143  }
1144  av_log(avctx, AV_LOG_DEBUG, "MONO\n");
1145  break;
1146  case STEREO:
1147  if (avctx->channels != 1) {
1148  q->subpacket[s].bits_per_subpdiv = 1;
1149  q->subpacket[s].num_channels = 2;
1150  }
1151  av_log(avctx, AV_LOG_DEBUG, "STEREO\n");
1152  break;
1153  case JOINT_STEREO:
1154  if (avctx->channels != 2) {
1155  avpriv_request_sample(avctx, "Container channels != 2");
1156  return AVERROR_PATCHWELCOME;
1157  }
1158  av_log(avctx, AV_LOG_DEBUG, "JOINT_STEREO\n");
1159  if (avctx->extradata_size >= 16) {
1162  q->subpacket[s].joint_stereo = 1;
1163  q->subpacket[s].num_channels = 2;
1164  }
1165  if (q->subpacket[s].samples_per_channel > 256) {
1167  }
1168  if (q->subpacket[s].samples_per_channel > 512) {
1170  }
1171  break;
1172  case MC_COOK:
1173  av_log(avctx, AV_LOG_DEBUG, "MULTI_CHANNEL\n");
1174  channel_mask |= q->subpacket[s].channel_mask = bytestream2_get_be32(&gb);
1175 
1179  q->subpacket[s].joint_stereo = 1;
1180  q->subpacket[s].num_channels = 2;
1181  q->subpacket[s].samples_per_channel = samples_per_frame >> 1;
1182 
1183  if (q->subpacket[s].samples_per_channel > 256) {
1185  }
1186  if (q->subpacket[s].samples_per_channel > 512) {
1188  }
1189  } else
1190  q->subpacket[s].samples_per_channel = samples_per_frame;
1191 
1192  break;
1193  default:
1194  avpriv_request_sample(avctx, "Cook version %d",
1195  q->subpacket[s].cookversion);
1196  return AVERROR_PATCHWELCOME;
1197  }
1198 
1199  if (s > 1 && q->subpacket[s].samples_per_channel != q->samples_per_channel) {
1200  av_log(avctx, AV_LOG_ERROR, "different number of samples per channel!\n");
1201  return AVERROR_INVALIDDATA;
1202  } else
1204 
1205 
1206  /* Initialize variable relations */
1208 
1209  /* Try to catch some obviously faulty streams, otherwise it might be exploitable */
1210  if (q->subpacket[s].total_subbands > 53) {
1211  avpriv_request_sample(avctx, "total_subbands > 53");
1212  return AVERROR_PATCHWELCOME;
1213  }
1214 
1215  if ((q->subpacket[s].js_vlc_bits > 6) ||
1216  (q->subpacket[s].js_vlc_bits < 2 * q->subpacket[s].joint_stereo)) {
1217  av_log(avctx, AV_LOG_ERROR, "js_vlc_bits = %d, only >= %d and <= 6 allowed!\n",
1218  q->subpacket[s].js_vlc_bits, 2 * q->subpacket[s].joint_stereo);
1219  return AVERROR_INVALIDDATA;
1220  }
1221 
1222  if (q->subpacket[s].subbands > 50) {
1223  avpriv_request_sample(avctx, "subbands > 50");
1224  return AVERROR_PATCHWELCOME;
1225  }
1226  if (q->subpacket[s].subbands == 0) {
1227  avpriv_request_sample(avctx, "subbands = 0");
1228  return AVERROR_PATCHWELCOME;
1229  }
1230  q->subpacket[s].gains1.now = q->subpacket[s].gain_1;
1232  q->subpacket[s].gains2.now = q->subpacket[s].gain_3;
1234 
1235  if (q->num_subpackets + q->subpacket[s].num_channels > q->avctx->channels) {
1236  av_log(avctx, AV_LOG_ERROR, "Too many subpackets %d for channels %d\n", q->num_subpackets, q->avctx->channels);
1237  return AVERROR_INVALIDDATA;
1238  }
1239 
1240  q->num_subpackets++;
1241  s++;
1242  }
1243 
1244  /* Try to catch some obviously faulty streams, otherwise it might be exploitable */
1245  if (q->samples_per_channel != 256 && q->samples_per_channel != 512 &&
1246  q->samples_per_channel != 1024) {
1247  avpriv_request_sample(avctx, "samples_per_channel = %d",
1248  q->samples_per_channel);
1249  return AVERROR_PATCHWELCOME;
1250  }
1251 
1252  /* Generate tables */
1253  init_pow2table();
1254  init_gain_table(q);
1256 
1257  if ((ret = init_cook_vlc_tables(q)))
1258  return ret;
1259 
1260  /* Pad the databuffer with:
1261  DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(),
1262  AV_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */
1264  av_mallocz(avctx->block_align
1265  + DECODE_BYTES_PAD1(avctx->block_align)
1267  if (!q->decoded_bytes_buffer)
1268  return AVERROR(ENOMEM);
1269 
1270  /* Initialize transform. */
1271  if ((ret = init_cook_mlt(q)))
1272  return ret;
1273 
1274  /* Initialize COOK signal arithmetic handling */
1275  if (1) {
1277  q->decouple = decouple_float;
1281  }
1282 
1283  avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1284  if (channel_mask)
1285  avctx->channel_layout = channel_mask;
1286  else
1287  avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
1288 
1289 
1290  dump_cook_context(q);
1291 
1292  return 0;
1293 }
1294 
1296  .name = "cook",
1297  .long_name = NULL_IF_CONFIG_SMALL("Cook / Cooker / Gecko (RealAudio G2)"),
1298  .type = AVMEDIA_TYPE_AUDIO,
1299  .id = AV_CODEC_ID_COOK,
1300  .priv_data_size = sizeof(COOKContext),
1302  .close = cook_decode_close,
1304  .capabilities = AV_CODEC_CAP_DR1,
1305  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1306  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1308 };
category
Definition: openal-dec.c:248
#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:48
int joint_stereo
Definition: cook.c:89
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, clip and convert to integer.
Definition: cook.c:920
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
static av_cold void init_cplscales_table(COOKContext *q)
Definition: cook.c:269
static const int cplband[51]
Definition: cookdata.h:285
float, planar
Definition: samplefmt.h:69
#define NULL
Definition: coverity.c:32
static const uint8_t ccpl_huffcounts[5][16]
Definition: cookdata.h:270
static const void *const cvh_huffsyms[7]
Definition: cookdata.h:241
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define av_clip_uintp2
Definition: common.h:146
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
VLC channel_coupling
Definition: cook.c:88
#define PRINT(a, b)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
int * previous
Definition: cook.c:74
float decode_buffer_1[1024]
Definition: cook.c:156
int64_t bit_rate
the average bitrate
Definition: avcodec.h:581
int gain_1[9]
Definition: cook.c:100
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define QUANT_VLC_BITS
Definition: cook.c:69
static const int kmax_tab[7]
Definition: cookdata.h:57
#define avpriv_request_sample(...)
static const int expbits_tab[8]
Definition: cookdata.h:35
int size
Definition: packet.h:364
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
static const float *const cplscales[5]
Definition: cookdata.h:357
int av_log2(unsigned v)
Definition: intmath.c:26
int subbands
Definition: cook.c:82
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
#define MAX_COOK_VLC_ENTRIES
Definition: cookdata.h:73
static av_cold void init_pow2table(void)
Definition: cook.c:171
#define FF_ARRAY_ELEMS(a)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
#define AV_CH_LAYOUT_STEREO
VLC envelope_quant_index[13]
Definition: cook.c:145
int num_vectors
Definition: cook.c:134
AVCodec.
Definition: codec.h:190
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:1228
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
int samples_per_channel
Definition: cook.c:85
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
static const float quant_centroid_tab[7][14]
Definition: cookdata.h:43
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
AVCodec ff_cook_decoder
Definition: cook.c:1295
static av_cold void init_gain_table(COOKContext *q)
Definition: cook.c:188
int numvector_size
Definition: cook.c:93
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1199
uint8_t
int total_subbands
Definition: cook.c:92
#define av_cold
Definition: attributes.h:88
int js_subband_start
Definition: cook.c:83
uint8_t * decoded_bytes_buffer
Definition: cook.c:154
static int decouple_info(COOKContext *q, COOKSubpacket *p, int *decouple_tab)
function for getting the jointstereo coupling information
Definition: cook.c:767
float mono_previous_buffer1[1024]
Definition: cook.c:95
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
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
av_cold void ff_audiodsp_init(AudioDSPContext *c)
Definition: audiodsp.c:106
static void expand_category(COOKContext *q, int *category, int *category_index)
Expand the category vector.
Definition: cook.c:521
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
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:632
void(* vector_clipf)(float *dst, const float *src, int len, float min, float max)
Definition: audiodsp.h:49
int bits_per_subpdiv
Definition: cook.c:91
static void interpolate(float *out, float v1, float v2, int size)
Definition: twinvq.c:84
cook_gains gains1
Definition: cook.c:98
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
uint8_t * data
Definition: packet.h:363
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
#define ff_dlog(a,...)
bitstream reader API header.
const float * cplscales[5]
Definition: cook.c:160
#define max(a, b)
Definition: cuda_runtime.h:33
#define FFALIGN(x, a)
Definition: macros.h:48
static int decode_subpacket(COOKContext *q, COOKSubpacket *p, const uint8_t *inbuffer, float **outbuffer)
Cook subpacket decoding.
Definition: cook.c:938
#define av_log(a,...)
static int cook_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: cook.c:980
AVLFG random_state
Definition: cook.c:137
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
#define DECODE_BYTES_PAD1(bytes)
Definition: cook.c:278
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
GetBitContext gb
Definition: cook.c:132
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:551
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static const int vd_tab[7]
Definition: cookdata.h:61
VLC sqvh[7]
Definition: cook.c:146
static const float dither_tab[9]
Definition: cookdata.h:39
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define JOINT_STEREO
Definition: cook.c:63
#define AV_BE2NE32C(x)
Definition: bswap.h:103
static const uint8_t envelope_quant_index_huffsyms[13][24]
Definition: cookdata.h:95
static const uint8_t cvh_huffcounts[7][16]
Definition: cookdata.h:125
GLsizei GLsizei * length
Definition: opengl_enc.c:114
float mono_previous_buffer2[1024]
Definition: cook.c:96
const char * name
Name of the codec implementation.
Definition: codec.h:197
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
void(* imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:102
#define ff_mdct_init
Definition: fft.h:161
GLsizei count
Definition: opengl_enc.c:108
int gain_2[9]
Definition: cook.c:101
Definition: vlc.h:26
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1242
static void saturate_output_float(COOKContext *q, float *out)
Saturate the output signal and interleave.
Definition: cook.c:902
#define powf(x, y)
Definition: libm.h:50
static const int vhvlcsize_tab[7]
Definition: cookdata.h:75
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:115
int gain_3[9]
Definition: cook.c:102
int discarded_packets
Definition: cook.c:138
int log2_numvector_size
Definition: cook.c:86
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
Definition: fft.h:83
static av_cold int init_cook_mlt(COOKContext *q)
Definition: cook.c:245
audio channel layout utility functions
#define FFMIN(a, b)
Definition: common.h:105
int gain_4[9]
Definition: cook.c:103
static int mono_decode(COOKContext *q, COOKSubpacket *p, float *mlt_buffer)
Definition: cook.c:652
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
subbands
Definition: aptx.h:39
static av_cold int cook_decode_init(AVCodecContext *avctx)
Cook initialization.
Definition: cook.c:1073
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
cook_gains gains2
Definition: cook.c:99
#define s(width, name)
Definition: cbs_vp9.c:257
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
int bits
Definition: vlc.h:27
void ff_sine_window_init(float *window, int n)
Generate a sine window.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
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
int num_subpackets
Definition: cook.c:161
Libavcodec external API header.
int samples_per_channel
Definition: cook.c:135
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
static av_cold int init_cook_vlc_tables(COOKContext *q)
Definition: cook.c:213
FFTContext mdct_ctx
Definition: cook.c:141
int sample_rate
samples per second
Definition: avcodec.h:1191
float gain_table[31]
Definition: cook.c:150
main external API structure.
Definition: avcodec.h:531
float mono_mdct_output[2048]
Definition: cook.c:155
float * mlt_window
Definition: cook.c:142
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1884
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:53
int * now
Definition: cook.c:73
int extradata_size
Definition: avcodec.h:633
static void dump_cook_context(COOKContext *q)
Definition: cook.c:1046
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
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
#define SUBBAND_SIZE
Definition: cook.c:66
static av_cold int cook_decode_close(AVCodecContext *avctx)
Definition: cook.c:327
int index
Definition: gxfenc.c:89
#define MONO
Definition: cook.c:61
static float pow2tab[127]
Definition: cook.c:165
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:381
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
float decode_buffer_0[1060]
Definition: cook.c:158
AudioDSPContext adsp
Definition: cook.c:131
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:197
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
COOKSubpacket subpacket[MAX_SUBPACKETS]
Definition: cook.c:162
float decode_buffer_2[1024]
Definition: cook.c:157
static const uint8_t envelope_quant_index_huffcounts[13][16]
Definition: cookdata.h:79
static const uint8_t *const ccpl_huffsyms[5]
Definition: cookdata.h:278
static float rootpow2tab[127]
Definition: cook.c:166
int ch_idx
Definition: cook.c:78
int bits_per_subpacket
Definition: cook.c:90
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
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:111
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
#define M_SQRT2
Definition: mathematics.h:61
int num_channels
Definition: cook.c:80
common internal api header.
#define STEREO
Definition: cook.c:62
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
#define ff_mdct_end
Definition: fft.h:162
AVCodecContext * avctx
Definition: cook.c:130
int gain_size_factor
Definition: cook.c:149
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
#define MAX_SUBPACKETS
Definition: cook.c:67
void * priv_data
Definition: avcodec.h:558
static const int invradix_tab[7]
Definition: cookdata.h:53
int channels
number of audio channels
Definition: avcodec.h:1192
#define MC_COOK
Definition: cook.c:64
int js_vlc_bits
Definition: cook.c:84
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
static const struct twinvq_data tab
and forward the result(frame or status change) to the corresponding input.If nothing is possible
void(* interpolate)(struct cook *q, float *buffer, int gain_index, int gain_index_next)
Definition: cook.c:125
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:940
FILE * out
Definition: movenc.c:54
Filter the word “frame” indicates either a video frame or a group of audio samples
#define av_freep(p)
static void decode_gain_info(GetBitContext *gb, int *gaininfo)
Fill the gain array for the timedomain quantization.
Definition: cook.c:359
#define COUPLING_VLC_BITS
Definition: cook.c:70
#define av_malloc_array(a, b)
#define FFSWAP(type, a, b)
Definition: common.h:108
void(* saturate_output)(struct cook *q, float *out)
Definition: cook.c:128
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
int cookversion
Definition: cook.c:81
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
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
static const int vpr_tab[7]
Definition: cookdata.h:65
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:361
#define AV_CH_LAYOUT_MONO
float min
This structure stores compressed data.
Definition: packet.h:340
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:431
int size
Definition: cook.c:79
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:380
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
int i
Definition: input.c:407
void(* imlt_window)(struct cook *q, float *buffer1, cook_gains *gains_ptr, float *previous_buffer)
Definition: cook.c:122
GLuint buffer
Definition: opengl_enc.c:101
unsigned int channel_mask
Definition: cook.c:87
Cook AKA RealAudio G2 compatible decoder data.
static uint8_t tmp[11]
Definition: aes_ctr.c:27