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