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