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