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