FFmpeg
imc.c
Go to the documentation of this file.
1 /*
2  * IMC compatible decoder
3  * Copyright (c) 2002-2004 Maxim Poliakovski
4  * Copyright (c) 2006 Benjamin Larsson
5  * Copyright (c) 2006 Konstantin Shishkov
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 /**
25  * @file
26  * IMC - Intel Music Coder
27  * A mdct based codec using a 256 points large transform
28  * divided into 32 bands with some mix of scale factors.
29  * Only mono is supported.
30  */
31 
32 
33 #include <math.h>
34 #include <stddef.h>
35 #include <stdio.h>
36 
38 #include "libavutil/ffmath.h"
39 #include "libavutil/float_dsp.h"
40 #include "libavutil/internal.h"
41 #include "libavutil/mem_internal.h"
42 #include "libavutil/thread.h"
43 
44 #include "avcodec.h"
45 #include "bswapdsp.h"
46 #include "get_bits.h"
47 #include "fft.h"
48 #include "internal.h"
49 #include "sinewin.h"
50 
51 #include "imcdata.h"
52 
53 #define IMC_BLOCK_SIZE 64
54 #define IMC_FRAME_ID 0x21
55 #define BANDS 32
56 #define COEFFS 256
57 
58 typedef struct IMCChannel {
59  float old_floor[BANDS];
60  float flcoeffs1[BANDS];
61  float flcoeffs2[BANDS];
62  float flcoeffs3[BANDS];
63  float flcoeffs4[BANDS];
64  float flcoeffs5[BANDS];
65  float flcoeffs6[BANDS];
66  float CWdecoded[COEFFS];
67 
68  int bandWidthT[BANDS]; ///< codewords per band
69  int bitsBandT[BANDS]; ///< how many bits per codeword in band
70  int CWlengthT[COEFFS]; ///< how many bits in each codeword
72  int bandFlagsBuf[BANDS]; ///< flags for each band
73  int sumLenArr[BANDS]; ///< bits for all coeffs in band
74  int skipFlagRaw[BANDS]; ///< skip flags are stored in raw form or not
75  int skipFlagBits[BANDS]; ///< bits used to code skip flags
76  int skipFlagCount[BANDS]; ///< skipped coefficients per band
77  int skipFlags[COEFFS]; ///< skip coefficient decoding or not
78  int codewords[COEFFS]; ///< raw codewords read from bitstream
79 
81 
83 } IMCChannel;
84 
85 typedef struct IMCContext {
86  IMCChannel chctx[2];
87 
88  /** MDCT tables */
89  //@{
90  float mdct_sine_window[COEFFS];
91  float post_cos[COEFFS];
92  float post_sin[COEFFS];
93  float pre_coef1[COEFFS];
94  float pre_coef2[COEFFS];
95  //@}
96 
97  float sqrt_tab[30];
99 
101  void (*butterflies_float)(float *av_restrict v1, float *av_restrict v2, int len);
104  float *out_samples;
105 
107 
108  int8_t cyclTab[32], cyclTab2[32];
109  float weights1[31], weights2[31];
110 
112 } IMCContext;
113 
114 static VLC huffman_vlc[4][4];
115 
116 #define IMC_VLC_BITS 9
117 #define VLC_TABLES_SIZE 9512
118 
120 
121 static inline double freq2bark(double freq)
122 {
123  return 3.5 * atan((freq / 7500.0) * (freq / 7500.0)) + 13.0 * atan(freq * 0.00076);
124 }
125 
126 static av_cold void iac_generate_tabs(IMCContext *q, int sampling_rate)
127 {
128  double freqmin[32], freqmid[32], freqmax[32];
129  double scale = sampling_rate / (256.0 * 2.0 * 2.0);
130  double nyquist_freq = sampling_rate * 0.5;
131  double freq, bark, prev_bark = 0, tf, tb;
132  int i, j;
133 
134  for (i = 0; i < 32; i++) {
135  freq = (band_tab[i] + band_tab[i + 1] - 1) * scale;
136  bark = freq2bark(freq);
137 
138  if (i > 0) {
139  tb = bark - prev_bark;
140  q->weights1[i - 1] = ff_exp10(-1.0 * tb);
141  q->weights2[i - 1] = ff_exp10(-2.7 * tb);
142  }
143  prev_bark = bark;
144 
145  freqmid[i] = freq;
146 
147  tf = freq;
148  while (tf < nyquist_freq) {
149  tf += 0.5;
150  tb = freq2bark(tf);
151  if (tb > bark + 0.5)
152  break;
153  }
154  freqmax[i] = tf;
155 
156  tf = freq;
157  while (tf > 0.0) {
158  tf -= 0.5;
159  tb = freq2bark(tf);
160  if (tb <= bark - 0.5)
161  break;
162  }
163  freqmin[i] = tf;
164  }
165 
166  for (i = 0; i < 32; i++) {
167  freq = freqmax[i];
168  for (j = 31; j > 0 && freq <= freqmid[j]; j--);
169  q->cyclTab[i] = j + 1;
170 
171  freq = freqmin[i];
172  for (j = 0; j < 32 && freq >= freqmid[j]; j++);
173  q->cyclTab2[i] = j - 1;
174  }
175 }
176 
177 static av_cold void imc_init_static(void)
178 {
179  /* initialize the VLC tables */
180  for (int i = 0, offset = 0; i < 4 ; i++) {
181  for (int j = 0; j < 4; j++) {
182  huffman_vlc[i][j].table = &vlc_tables[offset];
183  huffman_vlc[i][j].table_allocated = VLC_TABLES_SIZE - offset;;
185  imc_huffman_lens[i][j], 1,
186  imc_huffman_syms[i][j], 1, 1,
188  offset += huffman_vlc[i][j].table_size;
189  }
190  }
191 }
192 
194 {
195  int i, j, ret;
196  IMCContext *q = avctx->priv_data;
197  static AVOnce init_static_once = AV_ONCE_INIT;
198  AVFloatDSPContext *fdsp;
199  double r1, r2;
200 
201  if (avctx->codec_id == AV_CODEC_ID_IAC && avctx->sample_rate > 96000) {
202  av_log(avctx, AV_LOG_ERROR,
203  "Strange sample rate of %i, file likely corrupt or "
204  "needing a new table derivation method.\n",
205  avctx->sample_rate);
206  return AVERROR_PATCHWELCOME;
207  }
208 
209  if (avctx->codec_id == AV_CODEC_ID_IMC)
210  avctx->channels = 1;
211 
212  if (avctx->channels > 2) {
213  avpriv_request_sample(avctx, "Number of channels > 2");
214  return AVERROR_PATCHWELCOME;
215  }
216 
217  for (j = 0; j < avctx->channels; j++) {
218  q->chctx[j].decoder_reset = 1;
219 
220  for (i = 0; i < BANDS; i++)
221  q->chctx[j].old_floor[i] = 1.0;
222 
223  for (i = 0; i < COEFFS / 2; i++)
224  q->chctx[j].last_fft_im[i] = 0;
225  }
226 
227  /* Build mdct window, a simple sine window normalized with sqrt(2) */
229  for (i = 0; i < COEFFS; i++)
230  q->mdct_sine_window[i] *= sqrt(2.0);
231  for (i = 0; i < COEFFS / 2; i++) {
232  q->post_cos[i] = (1.0f / 32768) * cos(i / 256.0 * M_PI);
233  q->post_sin[i] = (1.0f / 32768) * sin(i / 256.0 * M_PI);
234 
235  r1 = sin((i * 4.0 + 1.0) / 1024.0 * M_PI);
236  r2 = cos((i * 4.0 + 1.0) / 1024.0 * M_PI);
237 
238  if (i & 0x1) {
239  q->pre_coef1[i] = (r1 + r2) * sqrt(2.0);
240  q->pre_coef2[i] = -(r1 - r2) * sqrt(2.0);
241  } else {
242  q->pre_coef1[i] = -(r1 + r2) * sqrt(2.0);
243  q->pre_coef2[i] = (r1 - r2) * sqrt(2.0);
244  }
245  }
246 
247  /* Generate a square root table */
248 
249  for (i = 0; i < 30; i++)
250  q->sqrt_tab[i] = sqrt(i);
251 
252  if (avctx->codec_id == AV_CODEC_ID_IAC) {
253  iac_generate_tabs(q, avctx->sample_rate);
254  } else {
255  memcpy(q->cyclTab, cyclTab, sizeof(cyclTab));
256  memcpy(q->cyclTab2, cyclTab2, sizeof(cyclTab2));
257  memcpy(q->weights1, imc_weights1, sizeof(imc_weights1));
258  memcpy(q->weights2, imc_weights2, sizeof(imc_weights2));
259  }
260 
262  if (!fdsp)
263  return AVERROR(ENOMEM);
265  av_free(fdsp);
266  if ((ret = ff_fft_init(&q->fft, 7, 1))) {
267  av_log(avctx, AV_LOG_INFO, "FFT init failed\n");
268  return ret;
269  }
270  ff_bswapdsp_init(&q->bdsp);
271 
273  avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO
275 
276  ff_thread_once(&init_static_once, imc_init_static);
277 
278  return 0;
279 }
280 
282  float *flcoeffs2, int *bandWidthT,
283  float *flcoeffs3, float *flcoeffs5)
284 {
285  float workT1[BANDS];
286  float workT2[BANDS];
287  float workT3[BANDS];
288  float snr_limit = 1.e-30;
289  float accum = 0.0;
290  int i, cnt2;
291 
292  for (i = 0; i < BANDS; i++) {
293  flcoeffs5[i] = workT2[i] = 0.0;
294  if (bandWidthT[i]) {
295  workT1[i] = flcoeffs1[i] * flcoeffs1[i];
296  flcoeffs3[i] = 2.0 * flcoeffs2[i];
297  } else {
298  workT1[i] = 0.0;
299  flcoeffs3[i] = -30000.0;
300  }
301  workT3[i] = bandWidthT[i] * workT1[i] * 0.01;
302  if (workT3[i] <= snr_limit)
303  workT3[i] = 0.0;
304  }
305 
306  for (i = 0; i < BANDS; i++) {
307  for (cnt2 = i; cnt2 < q->cyclTab[i]; cnt2++)
308  flcoeffs5[cnt2] = flcoeffs5[cnt2] + workT3[i];
309  workT2[cnt2 - 1] = workT2[cnt2 - 1] + workT3[i];
310  }
311 
312  for (i = 1; i < BANDS; i++) {
313  accum = (workT2[i - 1] + accum) * q->weights1[i - 1];
314  flcoeffs5[i] += accum;
315  }
316 
317  for (i = 0; i < BANDS; i++)
318  workT2[i] = 0.0;
319 
320  for (i = 0; i < BANDS; i++) {
321  for (cnt2 = i - 1; cnt2 > q->cyclTab2[i]; cnt2--)
322  flcoeffs5[cnt2] += workT3[i];
323  workT2[cnt2+1] += workT3[i];
324  }
325 
326  accum = 0.0;
327 
328  for (i = BANDS-2; i >= 0; i--) {
329  accum = (workT2[i+1] + accum) * q->weights2[i];
330  flcoeffs5[i] += accum;
331  // there is missing code here, but it seems to never be triggered
332  }
333 }
334 
335 
336 static void imc_read_level_coeffs(IMCContext *q, int stream_format_code,
337  int *levlCoeffs)
338 {
339  int i;
340  VLC *hufftab[4];
341  int start = 0;
342  const uint8_t *cb_sel;
343  int s;
344 
345  s = stream_format_code >> 1;
346  hufftab[0] = &huffman_vlc[s][0];
347  hufftab[1] = &huffman_vlc[s][1];
348  hufftab[2] = &huffman_vlc[s][2];
349  hufftab[3] = &huffman_vlc[s][3];
350  cb_sel = imc_cb_select[s];
351 
352  if (stream_format_code & 4)
353  start = 1;
354  if (start)
355  levlCoeffs[0] = get_bits(&q->gb, 7);
356  for (i = start; i < BANDS; i++) {
357  levlCoeffs[i] = get_vlc2(&q->gb, hufftab[cb_sel[i]]->table,
358  IMC_VLC_BITS, 2);
359  if (levlCoeffs[i] == 17)
360  levlCoeffs[i] += get_bits(&q->gb, 4);
361  }
362 }
363 
364 static void imc_read_level_coeffs_raw(IMCContext *q, int stream_format_code,
365  int *levlCoeffs)
366 {
367  int i;
368 
369  q->coef0_pos = get_bits(&q->gb, 5);
370  levlCoeffs[0] = get_bits(&q->gb, 7);
371  for (i = 1; i < BANDS; i++)
372  levlCoeffs[i] = get_bits(&q->gb, 4);
373 }
374 
376  float *flcoeffs1, float *flcoeffs2)
377 {
378  int i, level;
379  float tmp, tmp2;
380  // maybe some frequency division thingy
381 
382  flcoeffs1[0] = 20000.0 / exp2 (levlCoeffBuf[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
383  flcoeffs2[0] = log2f(flcoeffs1[0]);
384  tmp = flcoeffs1[0];
385  tmp2 = flcoeffs2[0];
386 
387  for (i = 1; i < BANDS; i++) {
388  level = levlCoeffBuf[i];
389  if (level == 16) {
390  flcoeffs1[i] = 1.0;
391  flcoeffs2[i] = 0.0;
392  } else {
393  if (level < 17)
394  level -= 7;
395  else if (level <= 24)
396  level -= 32;
397  else
398  level -= 16;
399 
400  tmp *= imc_exp_tab[15 + level];
401  tmp2 += 0.83048 * level; // 0.83048 = log2(10) * 0.25
402  flcoeffs1[i] = tmp;
403  flcoeffs2[i] = tmp2;
404  }
405  }
406 }
407 
408 
410  float *old_floor, float *flcoeffs1,
411  float *flcoeffs2)
412 {
413  int i;
414  /* FIXME maybe flag_buf = noise coding and flcoeffs1 = new scale factors
415  * and flcoeffs2 old scale factors
416  * might be incomplete due to a missing table that is in the binary code
417  */
418  for (i = 0; i < BANDS; i++) {
419  flcoeffs1[i] = 0;
420  if (levlCoeffBuf[i] < 16) {
421  flcoeffs1[i] = imc_exp_tab2[levlCoeffBuf[i]] * old_floor[i];
422  flcoeffs2[i] = (levlCoeffBuf[i] - 7) * 0.83048 + flcoeffs2[i]; // 0.83048 = log2(10) * 0.25
423  } else {
424  flcoeffs1[i] = old_floor[i];
425  }
426  }
427 }
428 
430  float *flcoeffs1, float *flcoeffs2)
431 {
432  int i, level, pos;
433  float tmp, tmp2;
434 
435  pos = q->coef0_pos;
436  flcoeffs1[pos] = 20000.0 / pow (2, levlCoeffBuf[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
437  flcoeffs2[pos] = log2f(flcoeffs1[pos]);
438  tmp = flcoeffs1[pos];
439  tmp2 = flcoeffs2[pos];
440 
441  levlCoeffBuf++;
442  for (i = 0; i < BANDS; i++) {
443  if (i == pos)
444  continue;
445  level = *levlCoeffBuf++;
446  flcoeffs1[i] = tmp * powf(10.0, -level * 0.4375); //todo tab
447  flcoeffs2[i] = tmp2 - 1.4533435415 * level; // 1.4533435415 = log2(10) * 0.4375
448  }
449 }
450 
451 /**
452  * Perform bit allocation depending on bits available
453  */
454 static int bit_allocation(IMCContext *q, IMCChannel *chctx,
455  int stream_format_code, int freebits, int flag)
456 {
457  int i, j;
458  const float limit = -1.e20;
459  float highest = 0.0;
460  int indx;
461  int t1 = 0;
462  int t2 = 1;
463  float summa = 0.0;
464  int iacc = 0;
465  int summer = 0;
466  int rres, cwlen;
467  float lowest = 1.e10;
468  int low_indx = 0;
469  float workT[32];
470  int flg;
471  int found_indx = 0;
472 
473  for (i = 0; i < BANDS; i++)
474  highest = FFMAX(highest, chctx->flcoeffs1[i]);
475 
476  for (i = 0; i < BANDS - 1; i++) {
477  if (chctx->flcoeffs5[i] <= 0) {
478  av_log(q->avctx, AV_LOG_ERROR, "flcoeffs5 %f invalid\n", chctx->flcoeffs5[i]);
479  return AVERROR_INVALIDDATA;
480  }
481  chctx->flcoeffs4[i] = chctx->flcoeffs3[i] - log2f(chctx->flcoeffs5[i]);
482  }
483  chctx->flcoeffs4[BANDS - 1] = limit;
484 
485  highest = highest * 0.25;
486 
487  for (i = 0; i < BANDS; i++) {
488  indx = -1;
489  if ((band_tab[i + 1] - band_tab[i]) == chctx->bandWidthT[i])
490  indx = 0;
491 
492  if ((band_tab[i + 1] - band_tab[i]) > chctx->bandWidthT[i])
493  indx = 1;
494 
495  if (((band_tab[i + 1] - band_tab[i]) / 2) >= chctx->bandWidthT[i])
496  indx = 2;
497 
498  if (indx == -1)
499  return AVERROR_INVALIDDATA;
500 
501  chctx->flcoeffs4[i] += xTab[(indx * 2 + (chctx->flcoeffs1[i] < highest)) * 2 + flag];
502  }
503 
504  if (stream_format_code & 0x2) {
505  chctx->flcoeffs4[0] = limit;
506  chctx->flcoeffs4[1] = limit;
507  chctx->flcoeffs4[2] = limit;
508  chctx->flcoeffs4[3] = limit;
509  }
510 
511  for (i = (stream_format_code & 0x2) ? 4 : 0; i < BANDS - 1; i++) {
512  iacc += chctx->bandWidthT[i];
513  summa += chctx->bandWidthT[i] * chctx->flcoeffs4[i];
514  }
515 
516  if (!iacc)
517  return AVERROR_INVALIDDATA;
518 
519  chctx->bandWidthT[BANDS - 1] = 0;
520  summa = (summa * 0.5 - freebits) / iacc;
521 
522 
523  for (i = 0; i < BANDS / 2; i++) {
524  rres = summer - freebits;
525  if ((rres >= -8) && (rres <= 8))
526  break;
527 
528  summer = 0;
529  iacc = 0;
530 
531  for (j = (stream_format_code & 0x2) ? 4 : 0; j < BANDS; j++) {
532  cwlen = av_clipf(((chctx->flcoeffs4[j] * 0.5) - summa + 0.5), 0, 6);
533 
534  chctx->bitsBandT[j] = cwlen;
535  summer += chctx->bandWidthT[j] * cwlen;
536 
537  if (cwlen > 0)
538  iacc += chctx->bandWidthT[j];
539  }
540 
541  flg = t2;
542  t2 = 1;
543  if (freebits < summer)
544  t2 = -1;
545  if (i == 0)
546  flg = t2;
547  if (flg != t2)
548  t1++;
549 
550  summa = (float)(summer - freebits) / ((t1 + 1) * iacc) + summa;
551  }
552 
553  for (i = (stream_format_code & 0x2) ? 4 : 0; i < BANDS; i++) {
554  for (j = band_tab[i]; j < band_tab[i + 1]; j++)
555  chctx->CWlengthT[j] = chctx->bitsBandT[i];
556  }
557 
558  if (freebits > summer) {
559  for (i = 0; i < BANDS; i++) {
560  workT[i] = (chctx->bitsBandT[i] == 6) ? -1.e20
561  : (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] - 0.415);
562  }
563 
564  highest = 0.0;
565 
566  do {
567  if (highest <= -1.e20)
568  break;
569 
570  found_indx = 0;
571  highest = -1.e20;
572 
573  for (i = 0; i < BANDS; i++) {
574  if (workT[i] > highest) {
575  highest = workT[i];
576  found_indx = i;
577  }
578  }
579 
580  if (highest > -1.e20) {
581  workT[found_indx] -= 2.0;
582  if (++chctx->bitsBandT[found_indx] == 6)
583  workT[found_indx] = -1.e20;
584 
585  for (j = band_tab[found_indx]; j < band_tab[found_indx + 1] && (freebits > summer); j++) {
586  chctx->CWlengthT[j]++;
587  summer++;
588  }
589  }
590  } while (freebits > summer);
591  }
592  if (freebits < summer) {
593  for (i = 0; i < BANDS; i++) {
594  workT[i] = chctx->bitsBandT[i] ? (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] + 1.585)
595  : 1.e20;
596  }
597  if (stream_format_code & 0x2) {
598  workT[0] = 1.e20;
599  workT[1] = 1.e20;
600  workT[2] = 1.e20;
601  workT[3] = 1.e20;
602  }
603  while (freebits < summer) {
604  lowest = 1.e10;
605  low_indx = 0;
606  for (i = 0; i < BANDS; i++) {
607  if (workT[i] < lowest) {
608  lowest = workT[i];
609  low_indx = i;
610  }
611  }
612  // if (lowest >= 1.e10)
613  // break;
614  workT[low_indx] = lowest + 2.0;
615 
616  if (!--chctx->bitsBandT[low_indx])
617  workT[low_indx] = 1.e20;
618 
619  for (j = band_tab[low_indx]; j < band_tab[low_indx+1] && (freebits < summer); j++) {
620  if (chctx->CWlengthT[j] > 0) {
621  chctx->CWlengthT[j]--;
622  summer--;
623  }
624  }
625  }
626  }
627  return 0;
628 }
629 
630 static void imc_get_skip_coeff(IMCContext *q, IMCChannel *chctx)
631 {
632  int i, j;
633 
634  memset(chctx->skipFlagBits, 0, sizeof(chctx->skipFlagBits));
635  memset(chctx->skipFlagCount, 0, sizeof(chctx->skipFlagCount));
636  for (i = 0; i < BANDS; i++) {
637  if (!chctx->bandFlagsBuf[i] || !chctx->bandWidthT[i])
638  continue;
639 
640  if (!chctx->skipFlagRaw[i]) {
641  chctx->skipFlagBits[i] = band_tab[i + 1] - band_tab[i];
642 
643  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
644  chctx->skipFlags[j] = get_bits1(&q->gb);
645  if (chctx->skipFlags[j])
646  chctx->skipFlagCount[i]++;
647  }
648  } else {
649  for (j = band_tab[i]; j < band_tab[i + 1] - 1; j += 2) {
650  if (!get_bits1(&q->gb)) { // 0
651  chctx->skipFlagBits[i]++;
652  chctx->skipFlags[j] = 1;
653  chctx->skipFlags[j + 1] = 1;
654  chctx->skipFlagCount[i] += 2;
655  } else {
656  if (get_bits1(&q->gb)) { // 11
657  chctx->skipFlagBits[i] += 2;
658  chctx->skipFlags[j] = 0;
659  chctx->skipFlags[j + 1] = 1;
660  chctx->skipFlagCount[i]++;
661  } else {
662  chctx->skipFlagBits[i] += 3;
663  chctx->skipFlags[j + 1] = 0;
664  if (!get_bits1(&q->gb)) { // 100
665  chctx->skipFlags[j] = 1;
666  chctx->skipFlagCount[i]++;
667  } else { // 101
668  chctx->skipFlags[j] = 0;
669  }
670  }
671  }
672  }
673 
674  if (j < band_tab[i + 1]) {
675  chctx->skipFlagBits[i]++;
676  if ((chctx->skipFlags[j] = get_bits1(&q->gb)))
677  chctx->skipFlagCount[i]++;
678  }
679  }
680  }
681 }
682 
683 /**
684  * Increase highest' band coefficient sizes as some bits won't be used
685  */
687  int summer)
688 {
689  float workT[32];
690  int corrected = 0;
691  int i, j;
692  float highest = 0;
693  int found_indx = 0;
694 
695  for (i = 0; i < BANDS; i++) {
696  workT[i] = (chctx->bitsBandT[i] == 6) ? -1.e20
697  : (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] - 0.415);
698  }
699 
700  while (corrected < summer) {
701  if (highest <= -1.e20)
702  break;
703 
704  highest = -1.e20;
705 
706  for (i = 0; i < BANDS; i++) {
707  if (workT[i] > highest) {
708  highest = workT[i];
709  found_indx = i;
710  }
711  }
712 
713  if (highest > -1.e20) {
714  workT[found_indx] -= 2.0;
715  if (++(chctx->bitsBandT[found_indx]) == 6)
716  workT[found_indx] = -1.e20;
717 
718  for (j = band_tab[found_indx]; j < band_tab[found_indx+1] && (corrected < summer); j++) {
719  if (!chctx->skipFlags[j] && (chctx->CWlengthT[j] < 6)) {
720  chctx->CWlengthT[j]++;
721  corrected++;
722  }
723  }
724  }
725  }
726 }
727 
728 static void imc_imdct256(IMCContext *q, IMCChannel *chctx, int channels)
729 {
730  int i;
731  float re, im;
732  float *dst1 = q->out_samples;
733  float *dst2 = q->out_samples + (COEFFS - 1);
734 
735  /* prerotation */
736  for (i = 0; i < COEFFS / 2; i++) {
737  q->samples[i].re = -(q->pre_coef1[i] * chctx->CWdecoded[COEFFS - 1 - i * 2]) -
738  (q->pre_coef2[i] * chctx->CWdecoded[i * 2]);
739  q->samples[i].im = (q->pre_coef2[i] * chctx->CWdecoded[COEFFS - 1 - i * 2]) -
740  (q->pre_coef1[i] * chctx->CWdecoded[i * 2]);
741  }
742 
743  /* FFT */
744  q->fft.fft_permute(&q->fft, q->samples);
745  q->fft.fft_calc(&q->fft, q->samples);
746 
747  /* postrotation, window and reorder */
748  for (i = 0; i < COEFFS / 2; i++) {
749  re = ( q->samples[i].re * q->post_cos[i]) + (-q->samples[i].im * q->post_sin[i]);
750  im = (-q->samples[i].im * q->post_cos[i]) - ( q->samples[i].re * q->post_sin[i]);
751  *dst1 = (q->mdct_sine_window[COEFFS - 1 - i * 2] * chctx->last_fft_im[i])
752  + (q->mdct_sine_window[i * 2] * re);
753  *dst2 = (q->mdct_sine_window[i * 2] * chctx->last_fft_im[i])
754  - (q->mdct_sine_window[COEFFS - 1 - i * 2] * re);
755  dst1 += 2;
756  dst2 -= 2;
757  chctx->last_fft_im[i] = im;
758  }
759 }
760 
762  int stream_format_code)
763 {
764  int i, j;
765  int middle_value, cw_len, max_size;
766  const float *quantizer;
767 
768  for (i = 0; i < BANDS; i++) {
769  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
770  chctx->CWdecoded[j] = 0;
771  cw_len = chctx->CWlengthT[j];
772 
773  if (cw_len <= 0 || chctx->skipFlags[j])
774  continue;
775 
776  max_size = 1 << cw_len;
777  middle_value = max_size >> 1;
778 
779  if (chctx->codewords[j] >= max_size || chctx->codewords[j] < 0)
780  return AVERROR_INVALIDDATA;
781 
782  if (cw_len >= 4) {
783  quantizer = imc_quantizer2[(stream_format_code & 2) >> 1];
784  if (chctx->codewords[j] >= middle_value)
785  chctx->CWdecoded[j] = quantizer[chctx->codewords[j] - 8] * chctx->flcoeffs6[i];
786  else
787  chctx->CWdecoded[j] = -quantizer[max_size - chctx->codewords[j] - 8 - 1] * chctx->flcoeffs6[i];
788  }else{
789  quantizer = imc_quantizer1[((stream_format_code & 2) >> 1) | (chctx->bandFlagsBuf[i] << 1)];
790  if (chctx->codewords[j] >= middle_value)
791  chctx->CWdecoded[j] = quantizer[chctx->codewords[j] - 1] * chctx->flcoeffs6[i];
792  else
793  chctx->CWdecoded[j] = -quantizer[max_size - 2 - chctx->codewords[j]] * chctx->flcoeffs6[i];
794  }
795  }
796  }
797  return 0;
798 }
799 
800 
801 static void imc_get_coeffs(AVCodecContext *avctx,
802  IMCContext *q, IMCChannel *chctx)
803 {
804  int i, j, cw_len, cw;
805 
806  for (i = 0; i < BANDS; i++) {
807  if (!chctx->sumLenArr[i])
808  continue;
809  if (chctx->bandFlagsBuf[i] || chctx->bandWidthT[i]) {
810  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
811  cw_len = chctx->CWlengthT[j];
812  cw = 0;
813 
814  if (cw_len && (!chctx->bandFlagsBuf[i] || !chctx->skipFlags[j])) {
815  if (get_bits_count(&q->gb) + cw_len > 512) {
816  av_log(avctx, AV_LOG_WARNING,
817  "Potential problem on band %i, coefficient %i"
818  ": cw_len=%i\n", i, j, cw_len);
819  } else
820  cw = get_bits(&q->gb, cw_len);
821  }
822 
823  chctx->codewords[j] = cw;
824  }
825  }
826  }
827 }
828 
830 {
831  int i, j;
832  int bits, summer;
833 
834  for (i = 0; i < BANDS; i++) {
835  chctx->sumLenArr[i] = 0;
836  chctx->skipFlagRaw[i] = 0;
837  for (j = band_tab[i]; j < band_tab[i + 1]; j++)
838  chctx->sumLenArr[i] += chctx->CWlengthT[j];
839  if (chctx->bandFlagsBuf[i])
840  if (((int)((band_tab[i + 1] - band_tab[i]) * 1.5) > chctx->sumLenArr[i]) && (chctx->sumLenArr[i] > 0))
841  chctx->skipFlagRaw[i] = 1;
842  }
843 
844  imc_get_skip_coeff(q, chctx);
845 
846  for (i = 0; i < BANDS; i++) {
847  chctx->flcoeffs6[i] = chctx->flcoeffs1[i];
848  /* band has flag set and at least one coded coefficient */
849  if (chctx->bandFlagsBuf[i] && (band_tab[i + 1] - band_tab[i]) != chctx->skipFlagCount[i]) {
850  chctx->flcoeffs6[i] *= q->sqrt_tab[ band_tab[i + 1] - band_tab[i]] /
851  q->sqrt_tab[(band_tab[i + 1] - band_tab[i] - chctx->skipFlagCount[i])];
852  }
853  }
854 
855  /* calculate bits left, bits needed and adjust bit allocation */
856  bits = summer = 0;
857 
858  for (i = 0; i < BANDS; i++) {
859  if (chctx->bandFlagsBuf[i]) {
860  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
861  if (chctx->skipFlags[j]) {
862  summer += chctx->CWlengthT[j];
863  chctx->CWlengthT[j] = 0;
864  }
865  }
866  bits += chctx->skipFlagBits[i];
867  summer -= chctx->skipFlagBits[i];
868  }
869  }
870  imc_adjust_bit_allocation(q, chctx, summer);
871 }
872 
873 static int imc_decode_block(AVCodecContext *avctx, IMCContext *q, int ch)
874 {
875  int stream_format_code;
876  int imc_hdr, i, j, ret;
877  int flag;
878  int bits;
879  int counter, bitscount;
880  IMCChannel *chctx = q->chctx + ch;
881 
882 
883  /* Check the frame header */
884  imc_hdr = get_bits(&q->gb, 9);
885  if (imc_hdr & 0x18) {
886  av_log(avctx, AV_LOG_ERROR, "frame header check failed!\n");
887  av_log(avctx, AV_LOG_ERROR, "got %X.\n", imc_hdr);
888  return AVERROR_INVALIDDATA;
889  }
890  stream_format_code = get_bits(&q->gb, 3);
891 
892  if (stream_format_code & 0x04)
893  chctx->decoder_reset = 1;
894 
895  if (chctx->decoder_reset) {
896  for (i = 0; i < BANDS; i++)
897  chctx->old_floor[i] = 1.0;
898  for (i = 0; i < COEFFS; i++)
899  chctx->CWdecoded[i] = 0;
900  chctx->decoder_reset = 0;
901  }
902 
903  flag = get_bits1(&q->gb);
904  if (stream_format_code & 0x1)
905  imc_read_level_coeffs_raw(q, stream_format_code, chctx->levlCoeffBuf);
906  else
907  imc_read_level_coeffs(q, stream_format_code, chctx->levlCoeffBuf);
908 
909  if (stream_format_code & 0x1)
911  chctx->flcoeffs1, chctx->flcoeffs2);
912  else if (stream_format_code & 0x4)
914  chctx->flcoeffs1, chctx->flcoeffs2);
915  else
917  chctx->flcoeffs1, chctx->flcoeffs2);
918 
919  for(i=0; i<BANDS; i++) {
920  if(chctx->flcoeffs1[i] > INT_MAX) {
921  av_log(avctx, AV_LOG_ERROR, "scalefactor out of range\n");
922  return AVERROR_INVALIDDATA;
923  }
924  }
925 
926  memcpy(chctx->old_floor, chctx->flcoeffs1, 32 * sizeof(float));
927 
928  counter = 0;
929  if (stream_format_code & 0x1) {
930  for (i = 0; i < BANDS; i++) {
931  chctx->bandWidthT[i] = band_tab[i + 1] - band_tab[i];
932  chctx->bandFlagsBuf[i] = 0;
933  chctx->flcoeffs3[i] = chctx->flcoeffs2[i] * 2;
934  chctx->flcoeffs5[i] = 1.0;
935  }
936  } else {
937  for (i = 0; i < BANDS; i++) {
938  if (chctx->levlCoeffBuf[i] == 16) {
939  chctx->bandWidthT[i] = 0;
940  counter++;
941  } else
942  chctx->bandWidthT[i] = band_tab[i + 1] - band_tab[i];
943  }
944 
945  memset(chctx->bandFlagsBuf, 0, BANDS * sizeof(int));
946  for (i = 0; i < BANDS - 1; i++)
947  if (chctx->bandWidthT[i])
948  chctx->bandFlagsBuf[i] = get_bits1(&q->gb);
949 
950  imc_calculate_coeffs(q, chctx->flcoeffs1, chctx->flcoeffs2,
951  chctx->bandWidthT, chctx->flcoeffs3,
952  chctx->flcoeffs5);
953  }
954 
955  bitscount = 0;
956  /* first 4 bands will be assigned 5 bits per coefficient */
957  if (stream_format_code & 0x2) {
958  bitscount += 15;
959 
960  chctx->bitsBandT[0] = 5;
961  chctx->CWlengthT[0] = 5;
962  chctx->CWlengthT[1] = 5;
963  chctx->CWlengthT[2] = 5;
964  for (i = 1; i < 4; i++) {
965  if (stream_format_code & 0x1)
966  bits = 5;
967  else
968  bits = (chctx->levlCoeffBuf[i] == 16) ? 0 : 5;
969  chctx->bitsBandT[i] = bits;
970  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
971  chctx->CWlengthT[j] = bits;
972  bitscount += bits;
973  }
974  }
975  }
976  if (avctx->codec_id == AV_CODEC_ID_IAC) {
977  bitscount += !!chctx->bandWidthT[BANDS - 1];
978  if (!(stream_format_code & 0x2))
979  bitscount += 16;
980  }
981 
982  if ((ret = bit_allocation(q, chctx, stream_format_code,
983  512 - bitscount - get_bits_count(&q->gb),
984  flag)) < 0) {
985  av_log(avctx, AV_LOG_ERROR, "Bit allocations failed\n");
986  chctx->decoder_reset = 1;
987  return ret;
988  }
989 
990  if (stream_format_code & 0x1) {
991  for (i = 0; i < BANDS; i++)
992  chctx->skipFlags[i] = 0;
993  } else {
994  imc_refine_bit_allocation(q, chctx);
995  }
996 
997  for (i = 0; i < BANDS; i++) {
998  chctx->sumLenArr[i] = 0;
999 
1000  for (j = band_tab[i]; j < band_tab[i + 1]; j++)
1001  if (!chctx->skipFlags[j])
1002  chctx->sumLenArr[i] += chctx->CWlengthT[j];
1003  }
1004 
1005  memset(chctx->codewords, 0, sizeof(chctx->codewords));
1006 
1007  imc_get_coeffs(avctx, q, chctx);
1008 
1009  if (inverse_quant_coeff(q, chctx, stream_format_code) < 0) {
1010  av_log(avctx, AV_LOG_ERROR, "Inverse quantization of coefficients failed\n");
1011  chctx->decoder_reset = 1;
1012  return AVERROR_INVALIDDATA;
1013  }
1014 
1015  memset(chctx->skipFlags, 0, sizeof(chctx->skipFlags));
1016 
1017  imc_imdct256(q, chctx, avctx->channels);
1018 
1019  return 0;
1020 }
1021 
1022 static int imc_decode_frame(AVCodecContext *avctx, void *data,
1023  int *got_frame_ptr, AVPacket *avpkt)
1024 {
1025  AVFrame *frame = data;
1026  const uint8_t *buf = avpkt->data;
1027  int buf_size = avpkt->size;
1028  int ret, i;
1029 
1030  IMCContext *q = avctx->priv_data;
1031 
1032  LOCAL_ALIGNED_16(uint16_t, buf16, [(IMC_BLOCK_SIZE + AV_INPUT_BUFFER_PADDING_SIZE) / 2]);
1033 
1034  q->avctx = avctx;
1035 
1036  if (buf_size < IMC_BLOCK_SIZE * avctx->channels) {
1037  av_log(avctx, AV_LOG_ERROR, "frame too small!\n");
1038  return AVERROR_INVALIDDATA;
1039  }
1040 
1041  /* get output buffer */
1042  frame->nb_samples = COEFFS;
1043  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1044  return ret;
1045 
1046  for (i = 0; i < avctx->channels; i++) {
1047  q->out_samples = (float *)frame->extended_data[i];
1048 
1049  q->bdsp.bswap16_buf(buf16, (const uint16_t *) buf, IMC_BLOCK_SIZE / 2);
1050 
1051  init_get_bits(&q->gb, (const uint8_t*)buf16, IMC_BLOCK_SIZE * 8);
1052 
1053  buf += IMC_BLOCK_SIZE;
1054 
1055  if ((ret = imc_decode_block(avctx, q, i)) < 0)
1056  return ret;
1057  }
1058 
1059  if (avctx->channels == 2) {
1060  q->butterflies_float((float *)frame->extended_data[0],
1061  (float *)frame->extended_data[1], COEFFS);
1062  }
1063 
1064  *got_frame_ptr = 1;
1065 
1066  return IMC_BLOCK_SIZE * avctx->channels;
1067 }
1068 
1070 {
1071  IMCContext *q = avctx->priv_data;
1072 
1073  ff_fft_end(&q->fft);
1074 
1075  return 0;
1076 }
1077 
1078 static av_cold void flush(AVCodecContext *avctx)
1079 {
1080  IMCContext *q = avctx->priv_data;
1081 
1082  q->chctx[0].decoder_reset =
1083  q->chctx[1].decoder_reset = 1;
1084 }
1085 
1086 #if CONFIG_IMC_DECODER
1088  .name = "imc",
1089  .long_name = NULL_IF_CONFIG_SMALL("IMC (Intel Music Coder)"),
1090  .type = AVMEDIA_TYPE_AUDIO,
1091  .id = AV_CODEC_ID_IMC,
1092  .priv_data_size = sizeof(IMCContext),
1093  .init = imc_decode_init,
1094  .close = imc_decode_close,
1096  .flush = flush,
1097  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1098  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1100  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1101 };
1102 #endif
1103 #if CONFIG_IAC_DECODER
1105  .name = "iac",
1106  .long_name = NULL_IF_CONFIG_SMALL("IAC (Indeo Audio Coder)"),
1107  .type = AVMEDIA_TYPE_AUDIO,
1108  .id = AV_CODEC_ID_IAC,
1109  .priv_data_size = sizeof(IMCContext),
1110  .init = imc_decode_init,
1111  .close = imc_decode_close,
1113  .flush = flush,
1114  .capabilities = AV_CODEC_CAP_DR1,
1115  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1117  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1118 };
1119 #endif
int skipFlags[COEFFS]
skip coefficient decoding or not
Definition: imc.c:77
float flcoeffs3[BANDS]
Definition: imc.c:62
float, planar
Definition: samplefmt.h:69
#define NULL
Definition: coverity.c:32
int table_size
Definition: vlc.h:29
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
float flcoeffs1[BANDS]
Definition: imc.c:60
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
int codewords[COEFFS]
raw codewords read from bitstream
Definition: imc.c:78
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
Definition: bswapdsp.h:26
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
float post_sin[COEFFS]
Definition: imc.c:92
float re
Definition: fft.c:82
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int skipFlagRaw[BANDS]
skip flags are stored in raw form or not
Definition: imc.c:74
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define avpriv_request_sample(...)
int size
Definition: packet.h:364
float mdct_sine_window[COEFFS]
MDCT tables.
Definition: imc.c:90
static const uint8_t imc_huffman_lens[4][4][18]
Definition: imcdata.h:115
int skipFlagCount[BANDS]
skipped coefficients per band
Definition: imc.c:76
static const float imc_weights2[31]
Definition: imcdata.h:53
FFTSample re
Definition: avfft.h:38
int8_t cyclTab2[32]
Definition: imc.c:108
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:102
#define AV_CH_LAYOUT_STEREO
static void imc_read_level_coeffs(IMCContext *q, int stream_format_code, int *levlCoeffs)
Definition: imc.c:336
float flcoeffs4[BANDS]
Definition: imc.c:63
AVCodec.
Definition: codec.h:190
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
float sqrt_tab[30]
Definition: imc.c:97
#define tf
Definition: regdef.h:73
static av_cold void imc_init_static(void)
Definition: imc.c:177
float old_floor[BANDS]
Definition: imc.c:59
#define LOCAL_ALIGNED_16(t, v,...)
Definition: mem_internal.h:130
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1199
uint8_t
#define av_cold
Definition: attributes.h:88
float pre_coef1[COEFFS]
Definition: imc.c:93
float CWdecoded[COEFFS]
Definition: imc.c:66
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
int bandFlagsBuf[BANDS]
flags for each band
Definition: imc.c:72
int coef0_pos
Definition: imc.c:106
static av_cold int imc_decode_close(AVCodecContext *avctx)
Definition: imc.c:1069
static const int8_t cyclTab[32]
Definition: imcdata.h:36
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
uint8_t * data
Definition: packet.h:363
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
static const float imc_weights1[31]
Definition: imcdata.h:47
bitstream reader API header.
float weights2[31]
Definition: imc.c:109
static void imc_get_skip_coeff(IMCContext *q, IMCChannel *chctx)
Definition: imc.c:630
channels
Definition: aptx.h:33
#define AVOnce
Definition: thread.h:172
#define av_log(a,...)
static void imc_refine_bit_allocation(IMCContext *q, IMCChannel *chctx)
Definition: imc.c:829
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
float pre_coef2[COEFFS]
Definition: imc.c:94
void(* fft_permute)(struct FFTContext *s, FFTComplex *z)
Do the permutation needed BEFORE calling fft_calc().
Definition: fft.h:96
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
static const float *const imc_exp_tab2
Definition: imcdata.h:97
static void imc_decode_level_coefficients_raw(IMCContext *q, int *levlCoeffBuf, float *flcoeffs1, float *flcoeffs2)
Definition: imc.c:429
float weights1[31]
Definition: imc.c:109
#define VLC_TABLES_SIZE
Definition: imc.c:117
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
unsigned int pos
Definition: spdifenc.c:410
static void imc_imdct256(IMCContext *q, IMCChannel *chctx, int channels)
Definition: imc.c:728
#define t1
Definition: regdef.h:29
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:611
static void imc_calculate_coeffs(IMCContext *q, float *flcoeffs1, float *flcoeffs2, int *bandWidthT, float *flcoeffs3, float *flcoeffs5)
Definition: imc.c:281
const char * name
Name of the codec implementation.
Definition: codec.h:197
uint8_t bits
Definition: vp3data.h:141
#define FFMAX(a, b)
Definition: common.h:94
GetBitContext gb
Definition: imc.c:98
Definition: vlc.h:26
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1242
#define IMC_BLOCK_SIZE
Definition: imc.c:53
IMCChannel chctx[2]
Definition: imc.c:86
#define powf(x, y)
Definition: libm.h:50
static const int8_t cyclTab2[32]
Definition: imcdata.h:42
static int imc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: imc.c:1022
static void imc_decode_level_coefficients2(IMCContext *q, int *levlCoeffBuf, float *old_floor, float *flcoeffs1, float *flcoeffs2)
Definition: imc.c:409
common internal API header
#define COEFFS
Definition: imc.c:56
Definition: fft.h:83
audio channel layout utility functions
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
static const uint16_t band_tab[33]
Definition: imcdata.h:29
AVCodec ff_imc_decoder
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
FFTContext fft
Definition: imc.c:102
#define ff_fft_init
Definition: fft.h:143
float flcoeffs5[BANDS]
Definition: imc.c:64
int bitsBandT[BANDS]
how many bits per codeword in band
Definition: imc.c:69
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
#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
Definition: imc.c:85
float last_fft_im[COEFFS]
Definition: imc.c:80
float post_cos[COEFFS]
Definition: imc.c:91
if(ret)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int table_allocated
Definition: vlc.h:29
static const uint8_t imc_huffman_syms[4][4][18]
Definition: imcdata.h:142
void(* butterflies_float)(float *av_restrict v1, float *av_restrict v2, int len)
Definition: imc.c:101
AVCodec ff_iac_decoder
static void imc_get_coeffs(AVCodecContext *avctx, IMCContext *q, IMCChannel *chctx)
Definition: imc.c:801
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
float flcoeffs6[BANDS]
Definition: imc.c:65
#define AV_ONCE_INIT
Definition: thread.h:173
static const float xTab[14]
Definition: imcdata.h:84
FFTComplex samples[COEFFS/2]
Definition: imc.c:103
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int8_t cyclTab[32]
Definition: imc.c:108
enum AVCodecID codec_id
Definition: avcodec.h:541
static int inverse_quant_coeff(IMCContext *q, IMCChannel *chctx, int stream_format_code)
Definition: imc.c:761
int sample_rate
samples per second
Definition: avcodec.h:1191
void AAC_RENAME() ff_sine_window_init(INTFLOAT *window, int n)
Generate a sine window.
Definition: imc.c:58
main external API structure.
Definition: avcodec.h:531
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1876
void(* butterflies_float)(float *av_restrict v1, float *av_restrict v2, int len)
Calculate the sum and difference of two vectors of floats.
Definition: float_dsp.h:164
static double freq2bark(double freq)
Definition: imc.c:121
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
int bandWidthT[BANDS]
codewords per band
Definition: imc.c:68
float * out_samples
Definition: imc.c:104
static av_cold void flush(AVCodecContext *avctx)
Definition: imc.c:1078
int ff_init_vlc_from_lengths(VLC *vlc_arg, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
Definition: bitstream.c:381
float im
Definition: fft.c:82
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
static VLC huffman_vlc[4][4]
Definition: imc.c:114
static VLC_TYPE vlc_tables[VLC_TABLES_SIZE][2]
Definition: imc.c:119
static const float imc_quantizer1[4][8]
Definition: imcdata.h:59
#define IMC_VLC_BITS
Definition: imc.c:116
#define BANDS
Definition: imc.c:55
uint8_t level
Definition: svq3.c:206
static av_cold void iac_generate_tabs(IMCContext *q, int sampling_rate)
Definition: imc.c:126
int levlCoeffBuf[BANDS]
Definition: imc.c:71
internal math functions header
int decoder_reset
Definition: imc.c:82
common internal api header.
FFTSample im
Definition: avfft.h:38
static int imc_decode_block(AVCodecContext *avctx, IMCContext *q, int ch)
Definition: imc.c:873
#define exp2(x)
Definition: libm.h:288
#define log2f(x)
Definition: libm.h:409
#define flag(name)
Definition: cbs_av1.c:553
BswapDSPContext bdsp
Definition: imc.c:100
#define ff_fft_end
Definition: fft.h:144
void(* fft_calc)(struct FFTContext *s, FFTComplex *z)
Do a complex FFT with the parameters defined in ff_fft_init().
Definition: fft.h:101
static int bit_allocation(IMCContext *q, IMCChannel *chctx, int stream_format_code, int freebits, int flag)
Perform bit allocation depending on bits available.
Definition: imc.c:454
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
static const uint8_t imc_cb_select[4][32]
Definition: imcdata.h:100
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:558
#define av_free(p)
int len
int channels
number of audio channels
Definition: avcodec.h:1192
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
AVCodecContext * avctx
Definition: imc.c:111
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:940
Filter the word “frame” indicates either a video frame or a group of audio samples
static void imc_adjust_bit_allocation(IMCContext *q, IMCChannel *chctx, int summer)
Increase highest&#39; band coefficient sizes as some bits won&#39;t be used.
Definition: imc.c:686
#define M_PI
Definition: mathematics.h:52
#define VLC_TYPE
Definition: vlc.h:24
static const float imc_quantizer2[2][56]
Definition: imcdata.h:66
int sumLenArr[BANDS]
bits for all coeffs in band
Definition: imc.c:73
static const uint8_t imc_huffman_sizes[4]
Definition: imcdata.h:111
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
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:361
#define AV_CH_LAYOUT_MONO
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:96
static void imc_read_level_coeffs_raw(IMCContext *q, int stream_format_code, int *levlCoeffs)
Definition: imc.c:364
This structure stores compressed data.
Definition: packet.h:340
static void imc_decode_level_coefficients(IMCContext *q, int *levlCoeffBuf, float *flcoeffs1, float *flcoeffs2)
Definition: imc.c:375
int skipFlagBits[BANDS]
bits used to code skip flags
Definition: imc.c:75
static av_cold int imc_decode_init(AVCodecContext *avctx)
Definition: imc.c:193
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:380
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
static const float imc_exp_tab[32]
Definition: imcdata.h:87
float flcoeffs2[BANDS]
Definition: imc.c:61
for(j=16;j >0;--j)
#define t2
Definition: regdef.h:30
int i
Definition: input.c:407
#define tb
Definition: regdef.h:68
int CWlengthT[COEFFS]
how many bits in each codeword
Definition: imc.c:70
static uint8_t tmp[11]
Definition: aes_ctr.c:27