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 */
142  VLC sqvh[7]; // scalar quantization
143 
144  /* generate tables and related variables */
146  float gain_table[31];
147 
148  /* data buffers */
149 
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 */
184 static av_cold void init_gain_table(COOKContext *q)
185 {
186  int i;
187  q->gain_size_factor = q->samples_per_channel / 8;
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 
194 static av_cold int init_cook_vlc_tables(COOKContext *q)
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,
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 
225 static av_cold int init_cook_mlt(COOKContext *q)
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 
249 static av_cold void init_cplscales_table(COOKContext *q)
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);
315  av_freep(&q->decoded_bytes_buffer);
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++)
322  ff_free_vlc(&q->envelope_quant_index[i]);
323  for (i = 0; i < 7; i++)
324  ff_free_vlc(&q->sqvh[i]);
325  for (i = 0; i < q->num_subpackets; i++)
326  ff_free_vlc(&q->subpacket[i].channel_coupling);
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  */
363 static int decode_envelope(COOKContext *q, COOKSubpacket *p,
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) {
386  av_log(q->avctx, AV_LOG_ERROR,
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  */
552 static int unpack_SQVH(COOKContext *q, COOKSubpacket *p, int category,
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  */
596 static void decode_vectors(COOKContext *q, COOKSubpacket *p, int *category,
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? */
627  if (p->total_subbands * SUBBAND_SIZE >= q->samples_per_channel)
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;
641  q->num_vectors = get_bits(&q->gb, p->log2_numvector_size);
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, 3);
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  */
786 static void decouple_float(COOKContext *q,
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  */
808 static int joint_decode(COOKContext *q, COOKSubpacket *p,
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  */
860 static inline void decode_bytes_and_gain(COOKContext *q, COOKSubpacket *p,
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 {
884  q->adsp.vector_clipf(out, q->mono_mdct_output + q->samples_per_channel,
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  */
918 static int decode_subpacket(COOKContext *q, COOKSubpacket *p,
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 
941  mlt_compensate_output(q, q->decode_buffer_1, &p->gains1,
943  outbuffer ? outbuffer[p->ch_idx] : NULL);
944 
945  if (p->num_channels == 2) {
946  if (p->joint_stereo)
947  mlt_compensate_output(q, q->decode_buffer_2, &p->gains1,
949  outbuffer ? outbuffer[p->ch_idx + 1] : NULL);
950  else
951  mlt_compensate_output(q, q->decode_buffer_2, &p->gains2,
953  outbuffer ? outbuffer[p->ch_idx + 1] : NULL);
954  }
955 
956  return 0;
957 }
958 
959 
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) {
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) >>
999  q->subpacket[i].bits_per_subpdiv;
1000  q->subpacket[i].ch_idx = chidx;
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 
1026 static void dump_cook_context(COOKContext *q)
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;
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 
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  if (s >= FFMIN(MAX_SUBPACKETS, avctx->block_align)) {
1089  return AVERROR_PATCHWELCOME;
1090  }
1091  /* 8 for mono, 16 for stereo, ? for multichannel
1092  Swap to right endianness so we don't need to care later on. */
1093  q->subpacket[s].cookversion = bytestream2_get_be32(&gb);
1094  samples_per_frame = bytestream2_get_be16(&gb);
1095  q->subpacket[s].subbands = bytestream2_get_be16(&gb);
1096  bytestream2_get_be32(&gb); // Unknown unused
1097  q->subpacket[s].js_subband_start = bytestream2_get_be16(&gb);
1098  if (q->subpacket[s].js_subband_start >= 51) {
1099  av_log(avctx, AV_LOG_ERROR, "js_subband_start %d is too large\n", q->subpacket[s].js_subband_start);
1100  return AVERROR_INVALIDDATA;
1101  }
1102  q->subpacket[s].js_vlc_bits = bytestream2_get_be16(&gb);
1103 
1104  /* Initialize extradata related variables. */
1105  q->subpacket[s].samples_per_channel = samples_per_frame / avctx->channels;
1106  q->subpacket[s].bits_per_subpacket = avctx->block_align * 8;
1107 
1108  /* Initialize default data states. */
1109  q->subpacket[s].log2_numvector_size = 5;
1110  q->subpacket[s].total_subbands = q->subpacket[s].subbands;
1111  q->subpacket[s].num_channels = 1;
1112 
1113  /* Initialize version-dependent variables */
1114 
1115  av_log(avctx, AV_LOG_DEBUG, "subpacket[%i].cookversion=%x\n", s,
1116  q->subpacket[s].cookversion);
1117  q->subpacket[s].joint_stereo = 0;
1118  switch (q->subpacket[s].cookversion) {
1119  case MONO:
1120  if (avctx->channels != 1) {
1121  avpriv_request_sample(avctx, "Container channels != 1");
1122  return AVERROR_PATCHWELCOME;
1123  }
1124  av_log(avctx, AV_LOG_DEBUG, "MONO\n");
1125  break;
1126  case STEREO:
1127  if (avctx->channels != 1) {
1128  q->subpacket[s].bits_per_subpdiv = 1;
1129  q->subpacket[s].num_channels = 2;
1130  }
1131  av_log(avctx, AV_LOG_DEBUG, "STEREO\n");
1132  break;
1133  case JOINT_STEREO:
1134  if (avctx->channels != 2) {
1135  avpriv_request_sample(avctx, "Container channels != 2");
1136  return AVERROR_PATCHWELCOME;
1137  }
1138  av_log(avctx, AV_LOG_DEBUG, "JOINT_STEREO\n");
1139  if (avctx->extradata_size >= 16) {
1140  q->subpacket[s].total_subbands = q->subpacket[s].subbands +
1141  q->subpacket[s].js_subband_start;
1142  q->subpacket[s].joint_stereo = 1;
1143  q->subpacket[s].num_channels = 2;
1144  }
1145  if (q->subpacket[s].samples_per_channel > 256) {
1146  q->subpacket[s].log2_numvector_size = 6;
1147  }
1148  if (q->subpacket[s].samples_per_channel > 512) {
1149  q->subpacket[s].log2_numvector_size = 7;
1150  }
1151  break;
1152  case MC_COOK:
1153  av_log(avctx, AV_LOG_DEBUG, "MULTI_CHANNEL\n");
1154  channel_mask |= q->subpacket[s].channel_mask = bytestream2_get_be32(&gb);
1155 
1156  if (av_get_channel_layout_nb_channels(q->subpacket[s].channel_mask) > 1) {
1157  q->subpacket[s].total_subbands = q->subpacket[s].subbands +
1158  q->subpacket[s].js_subband_start;
1159  q->subpacket[s].joint_stereo = 1;
1160  q->subpacket[s].num_channels = 2;
1161  q->subpacket[s].samples_per_channel = samples_per_frame >> 1;
1162 
1163  if (q->subpacket[s].samples_per_channel > 256) {
1164  q->subpacket[s].log2_numvector_size = 6;
1165  }
1166  if (q->subpacket[s].samples_per_channel > 512) {
1167  q->subpacket[s].log2_numvector_size = 7;
1168  }
1169  } else
1170  q->subpacket[s].samples_per_channel = samples_per_frame;
1171 
1172  break;
1173  default:
1174  avpriv_request_sample(avctx, "Cook version %d",
1175  q->subpacket[s].cookversion);
1176  return AVERROR_PATCHWELCOME;
1177  }
1178 
1179  if (s > 1 && q->subpacket[s].samples_per_channel != q->samples_per_channel) {
1180  av_log(avctx, AV_LOG_ERROR, "different number of samples per channel!\n");
1181  return AVERROR_INVALIDDATA;
1182  } else
1183  q->samples_per_channel = q->subpacket[0].samples_per_channel;
1184 
1185 
1186  /* Initialize variable relations */
1187  q->subpacket[s].numvector_size = (1 << q->subpacket[s].log2_numvector_size);
1188 
1189  /* Try to catch some obviously faulty streams, otherwise it might be exploitable */
1190  if (q->subpacket[s].total_subbands > 53) {
1191  avpriv_request_sample(avctx, "total_subbands > 53");
1192  return AVERROR_PATCHWELCOME;
1193  }
1194 
1195  if ((q->subpacket[s].js_vlc_bits > 6) ||
1196  (q->subpacket[s].js_vlc_bits < 2 * q->subpacket[s].joint_stereo)) {
1197  av_log(avctx, AV_LOG_ERROR, "js_vlc_bits = %d, only >= %d and <= 6 allowed!\n",
1198  q->subpacket[s].js_vlc_bits, 2 * q->subpacket[s].joint_stereo);
1199  return AVERROR_INVALIDDATA;
1200  }
1201 
1202  if (q->subpacket[s].subbands > 50) {
1203  avpriv_request_sample(avctx, "subbands > 50");
1204  return AVERROR_PATCHWELCOME;
1205  }
1206  if (q->subpacket[s].subbands == 0) {
1207  avpriv_request_sample(avctx, "subbands = 0");
1208  return AVERROR_PATCHWELCOME;
1209  }
1210  q->subpacket[s].gains1.now = q->subpacket[s].gain_1;
1211  q->subpacket[s].gains1.previous = q->subpacket[s].gain_2;
1212  q->subpacket[s].gains2.now = q->subpacket[s].gain_3;
1213  q->subpacket[s].gains2.previous = q->subpacket[s].gain_4;
1214 
1215  if (q->num_subpackets + q->subpacket[s].num_channels > q->avctx->channels) {
1216  av_log(avctx, AV_LOG_ERROR, "Too many subpackets %d for channels %d\n", q->num_subpackets, q->avctx->channels);
1217  return AVERROR_INVALIDDATA;
1218  }
1219 
1220  q->num_subpackets++;
1221  s++;
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. */
1243  q->decoded_bytes_buffer =
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) {
1256  q->scalar_dequant = scalar_dequant_float;
1257  q->decouple = decouple_float;
1258  q->imlt_window = imlt_window_float;
1259  q->interpolate = interpolate_float;
1260  q->saturate_output = saturate_output_float;
1261  }
1262 
1264  if (channel_mask)
1265  avctx->channel_layout = channel_mask;
1266  else
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 };
decode_vectors
static void decode_vectors(COOKContext *q, COOKSubpacket *p, int *category, int *quant_index_table, float *mlt_buffer)
Fill the mlt_buffer with mlt coefficients.
Definition: cook.c:596
mono_decode
static int mono_decode(COOKContext *q, COOKSubpacket *p, float *mlt_buffer)
Definition: cook.c:632
AVCodec
AVCodec.
Definition: codec.h:190
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
cvh_huffcodes
static const uint16_t *const cvh_huffcodes[7]
Definition: cookdata.h:425
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
COOKSubpacket::log2_numvector_size
int log2_numvector_size
Definition: cook.c:82
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1237
cook::gb
GetBitContext gb
Definition: cook.c:128
out
FILE * out
Definition: movenc.c:54
cook_decode_init
static av_cold int cook_decode_init(AVCodecContext *avctx)
Cook initialization.
Definition: cook.c:1053
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
av_lfg_init
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
GetByteContext
Definition: bytestream.h:33
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:716
init_pow2table
static av_cold void init_pow2table(void)
Definition: cook.c:167
decode_gain_info
static void decode_gain_info(GetBitContext *gb, int *gaininfo)
Fill the gain array for the timedomain quantization.
Definition: cook.c:339
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:85
cook_decode_frame
static int cook_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: cook.c:960
cook::interpolate
void(* interpolate)(struct cook *q, float *buffer, int gain_index, int gain_index_next)
Definition: cook.c:121
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
unpack_SQVH
static int unpack_SQVH(COOKContext *q, COOKSubpacket *p, int category, int *subband_coef_index, int *subband_coef_sign)
Unpack the subband_coef_index and subband_coef_sign vectors.
Definition: cook.c:552
cook::gain_size_factor
int gain_size_factor
Definition: cook.c:145
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
cook::gain_table
float gain_table[31]
Definition: cook.c:146
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:355
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
cook_gains
Definition: cook.c:68
data
const char data[16]
Definition: mxf.c:91
scalar_dequant_float
static void scalar_dequant_float(COOKContext *q, int index, int quant_index, int *subband_coef_index, int *subband_coef_sign, float *mlt_p)
The real requantization of the mltcoefs.
Definition: cook.c:523
envelope_quant_index_huffcodes
static const uint16_t envelope_quant_index_huffcodes[13][24]
Definition: cookdata.h:97
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:169
ff_audiodsp_init
av_cold void ff_audiodsp_init(AudioDSPContext *c)
Definition: audiodsp.c:106
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
category
category
Definition: openal-dec.c:248
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:555
COOKSubpacket::joint_stereo
int joint_stereo
Definition: cook.c:85
STEREO
#define STEREO
Definition: cook.c:61
max
#define max(a, b)
Definition: cuda_runtime.h:33
subbands
subbands
Definition: aptx.h:39
cook::scalar_dequant
void(* scalar_dequant)(struct cook *q, int index, int quant_index, int *subband_coef_index, int *subband_coef_sign, float *mlt_p)
Definition: cook.c:107
cook_decode_close
static av_cold int cook_decode_close(AVCodecContext *avctx)
Definition: cook.c:307
COOKSubpacket::js_subband_start
int js_subband_start
Definition: cook.c:79
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
DECODE_BYTES_PAD1
#define DECODE_BYTES_PAD1(bytes)
Definition: cook.c:258
init_cook_mlt
static av_cold int init_cook_mlt(COOKContext *q)
Definition: cook.c:225
cook
Definition: cook.c:102
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
JOINT_STEREO
#define JOINT_STEREO
Definition: cook.c:62
expbits_tab
static const int expbits_tab[8]
Definition: cookdata.h:35
cvh_huffbits
static const uint8_t *const cvh_huffbits[7]
Definition: cookdata.h:430
GetBitContext
Definition: get_bits.h:61
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:11135
PRINT
#define PRINT(a, b)
decode_bytes
static int decode_bytes(const uint8_t *inbuffer, uint8_t *out, int bytes)
Cook indata decoding, every 32 bits are XORed with 0x37c511f2.
Definition: cook.c:281
COOKSubpacket::gain_3
int gain_3[9]
Definition: cook.c:98
decode_subpacket
static int decode_subpacket(COOKContext *q, COOKSubpacket *p, const uint8_t *inbuffer, float **outbuffer)
Cook subpacket decoding.
Definition: cook.c:918
dither_tab
static const float dither_tab[9]
Definition: cookdata.h:39
AV_BE2NE32C
#define AV_BE2NE32C(x)
Definition: bswap.h:103
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:86
COOKSubpacket::numvector_size
int numvector_size
Definition: cook.c:89
init_cplscales_table
static av_cold void init_cplscales_table(COOKContext *q)
Definition: cook.c:249
saturate_output_float
static void saturate_output_float(COOKContext *q, float *out)
Saturate the output signal and interleave.
Definition: cook.c:882
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
cook::num_subpackets
int num_subpackets
Definition: cook.c:157
av_cold
#define av_cold
Definition: attributes.h:90
quant_centroid_tab
static const float quant_centroid_tab[7][14]
Definition: cookdata.h:43
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:628
s
#define s(width, name)
Definition: cbs_vp9.c:257
cook::cplscales
const float * cplscales[5]
Definition: cook.c:156
init_cook_vlc_tables
static av_cold int init_cook_vlc_tables(COOKContext *q)
Definition: cook.c:194
av_lfg_get
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:53
vhvlcsize_tab
static const int vhvlcsize_tab[7]
Definition: cookdata.h:77
COOKSubpacket::samples_per_channel
int samples_per_channel
Definition: cook.c:81
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
lfg.h
ff_cook_decoder
AVCodec ff_cook_decoder
Definition: cook.c:1275
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
cook::decouple
void(* decouple)(struct cook *q, COOKSubpacket *p, int subband, float f1, float f2, float *decode_buffer, float *mlt_buffer1, float *mlt_buffer2)
Definition: cook.c:111
get_bits.h
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:359
cook::decode_buffer_1
float decode_buffer_1[1024]
Definition: cook.c:152
COOKSubpacket::js_vlc_bits
int js_vlc_bits
Definition: cook.c:80
vd_tab
static const int vd_tab[7]
Definition: cookdata.h:61
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
imlt_window_float
static void imlt_window_float(COOKContext *q, float *inbuffer, cook_gains *gains_ptr, float *previous_buffer)
Apply transform window, overlap buffers.
Definition: cook.c:689
COOKSubpacket::bits_per_subpacket
int bits_per_subpacket
Definition: cook.c:86
decouple_float
static void decouple_float(COOKContext *q, COOKSubpacket *p, int subband, float f1, float f2, float *decode_buffer, float *mlt_buffer1, float *mlt_buffer2)
function decouples a pair of signals from a single signal via multiplication.
Definition: cook.c:786
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
dump_cook_context
static void dump_cook_context(COOKContext *q)
Definition: cook.c:1026
MC_COOK
#define MC_COOK
Definition: cook.c:63
COOKSubpacket::num_channels
int num_channels
Definition: cook.c:76
mlt_compensate_output
static void mlt_compensate_output(COOKContext *q, float *decode_buffer, cook_gains *gains_ptr, float *previous_buffer, float *out)
Final part of subpacket decoding: Apply modulated lapped transform, gain compensation,...
Definition: cook.c:900
index
int index
Definition: gxfenc.c:89
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
vpr_tab
static const int vpr_tab[7]
Definition: cookdata.h:65
av_get_channel_layout_nb_channels
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
Definition: channel_layout.c:220
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
cook::sqvh
VLC sqvh[7]
Definition: cook.c:142
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
cook::subpacket
COOKSubpacket subpacket[MAX_SUBPACKETS]
Definition: cook.c:158
cplscales
static const float *const cplscales[5]
Definition: cookdata.h:577
AVLFG
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1854
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
AVPacket::size
int size
Definition: packet.h:356
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
powf
#define powf(x, y)
Definition: libm.h:50
cook::random_state
AVLFG random_state
Definition: cook.c:133
COOKSubpacket
Definition: cook.c:73
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1194
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
COOKSubpacket::gains1
cook_gains gains1
Definition: cook.c:94
COOKSubpacket::ch_idx
int ch_idx
Definition: cook.c:74
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:170
MAX_SUBPACKETS
#define MAX_SUBPACKETS
Definition: cook.c:66
imlt_gain
static void imlt_gain(COOKContext *q, float *inbuffer, cook_gains *gains_ptr, float *previous_buffer)
The modulated lapped transform, this takes transform coefficients and transforms them into timedomain...
Definition: cook.c:717
COOKSubpacket::cookversion
int cookversion
Definition: cook.c:77
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
sinewin.h
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
COOKSubpacket::size
int size
Definition: cook.c:75
unary.h
COOKSubpacket::channel_mask
unsigned int channel_mask
Definition: cook.c:83
COOKSubpacket::gain_1
int gain_1[9]
Definition: cook.c:96
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1187
kmax_tab
static const int kmax_tab[7]
Definition: cookdata.h:57
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:112
cook::avctx
AVCodecContext * avctx
Definition: cook.c:126
FFTContext
Definition: fft.h:88
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
COOKSubpacket::mono_previous_buffer1
float mono_previous_buffer1[1024]
Definition: cook.c:91
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
ff_sine_window_init
void AAC_RENAME() ff_sine_window_init(INTFLOAT *window, int n)
Generate a sine window.
Definition: sinewin_tablegen.h:70
COOKSubpacket::subbands
int subbands
Definition: cook.c:78
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
cook::samples_per_channel
int samples_per_channel
Definition: cook.c:131
uint8_t
uint8_t
Definition: audio_convert.c:194
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
vhsize_tab
static const int vhsize_tab[7]
Definition: cookdata.h:73
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
decode_envelope
static int decode_envelope(COOKContext *q, COOKSubpacket *p, int *quant_index_table)
Create the quant index table needed for the envelope.
Definition: cook.c:363
cookdata.h
avcodec.h
VLC::bits
int bits
Definition: vlc.h:27
MONO
#define MONO
Definition: cook.c:60
ret
ret
Definition: filter_design.txt:187
decouple_info
static int decouple_info(COOKContext *q, COOKSubpacket *p, int *decouple_tab)
function for getting the jointstereo coupling information
Definition: cook.c:747
pow2tab
static float pow2tab[127]
Definition: cook.c:161
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1223
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
ccpl_huffbits
static const uint8_t *const ccpl_huffbits[5]
Definition: cookdata.h:497
interpolate_float
static void interpolate_float(COOKContext *q, float *buffer, int gain_index, int gain_index_next)
the actual requantization of the timedomain samples
Definition: cook.c:662
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:215
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
fft.h
AVCodecContext
main external API structure.
Definition: avcodec.h:526
cook::mlt_window
float * mlt_window
Definition: cook.c:138
channel_layout.h
rootpow2tab
static float rootpow2tab[127]
Definition: cook.c:162
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
cook::num_vectors
int num_vectors
Definition: cook.c:130
VLC
Definition: vlc.h:26
COOKSubpacket::mono_previous_buffer2
float mono_previous_buffer2[1024]
Definition: cook.c:92
cook::decoded_bytes_buffer
uint8_t * decoded_bytes_buffer
Definition: cook.c:150
envelope_quant_index_huffbits
static const uint8_t envelope_quant_index_huffbits[13][24]
Definition: cookdata.h:81
cook_gains::previous
int * previous
Definition: cook.c:70
init_gain_table
static av_cold void init_gain_table(COOKContext *q)
Definition: cook.c:184
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
COOKSubpacket::gains2
cook_gains gains2
Definition: cook.c:95
joint_decode
static int joint_decode(COOKContext *q, COOKSubpacket *p, float *mlt_buffer_left, float *mlt_buffer_right)
function for decoding joint stereo data
Definition: cook.c:808
SUBBAND_SIZE
#define SUBBAND_SIZE
Definition: cook.c:65
cook::envelope_quant_index
VLC envelope_quant_index[13]
Definition: cook.c:141
cook::imlt_window
void(* imlt_window)(struct cook *q, float *buffer1, cook_gains *gains_ptr, float *previous_buffer)
Definition: cook.c:118
audiodsp.h
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
M_SQRT2
#define M_SQRT2
Definition: mathematics.h:61
COOKSubpacket::gain_2
int gain_2[9]
Definition: cook.c:97
AudioDSPContext
Definition: audiodsp.h:24
cook_gains::now
int * now
Definition: cook.c:69
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
cook::saturate_output
void(* saturate_output)(struct cook *q, float *out)
Definition: cook.c:124
COOKSubpacket::total_subbands
int total_subbands
Definition: cook.c:88
cook::decode_buffer_0
float decode_buffer_0[1060]
Definition: cook.c:154
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
categorize
static void categorize(COOKContext *q, COOKSubpacket *p, const int *quant_index_table, int *category, int *category_index)
Calculate the category and category_index vector.
Definition: cook.c:404
cook::discarded_packets
int discarded_packets
Definition: cook.c:134
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_CODEC_ID_COOK
@ AV_CODEC_ID_COOK
Definition: codec_id.h:430
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
ccpl_huffcodes
static const uint16_t *const ccpl_huffcodes[5]
Definition: cookdata.h:492
cplband
static const int cplband[51]
Definition: cookdata.h:505
COOKSubpacket::gain_4
int gain_4[9]
Definition: cook.c:99
cook::mono_mdct_output
float mono_mdct_output[2048]
Definition: cook.c:151
cook::decode_buffer_2
float decode_buffer_2[1024]
Definition: cook.c:153
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
expand_category
static void expand_category(COOKContext *q, int *category, int *category_index)
Expand the category vector.
Definition: cook.c:501
cook::mdct_ctx
FFTContext mdct_ctx
Definition: cook.c:137
cook::adsp
AudioDSPContext adsp
Definition: cook.c:127
COOKSubpacket::bits_per_subpdiv
int bits_per_subpdiv
Definition: cook.c:87
invradix_tab
static const int invradix_tab[7]
Definition: cookdata.h:53
min
float min
Definition: vorbis_enc_data.h:456
COOKSubpacket::channel_coupling
VLC channel_coupling
Definition: cook.c:84
decode_bytes_and_gain
static void decode_bytes_and_gain(COOKContext *q, COOKSubpacket *p, const uint8_t *inbuffer, cook_gains *gains_ptr)
First part of subpacket decoding: decode raw stream bytes and read gain info.
Definition: cook.c:860