Libav
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 Libav.
8  *
9  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
33 #include <math.h>
34 #include <stddef.h>
35 #include <stdio.h>
36 
38 #include "libavutil/float_dsp.h"
39 #include "libavutil/internal.h"
40 #include "avcodec.h"
41 #include "bswapdsp.h"
42 #include "get_bits.h"
43 #include "fft.h"
44 #include "internal.h"
45 #include "sinewin.h"
46 
47 #include "imcdata.h"
48 
49 #define IMC_BLOCK_SIZE 64
50 #define IMC_FRAME_ID 0x21
51 #define BANDS 32
52 #define COEFFS 256
53 
54 typedef struct IMCChannel {
55  float old_floor[BANDS];
56  float flcoeffs1[BANDS];
57  float flcoeffs2[BANDS];
58  float flcoeffs3[BANDS];
59  float flcoeffs4[BANDS];
60  float flcoeffs5[BANDS];
61  float flcoeffs6[BANDS];
62  float CWdecoded[COEFFS];
63 
75 
77 
79 } IMCChannel;
80 
81 typedef struct IMCContext {
82  IMCChannel chctx[2];
83 
86  float mdct_sine_window[COEFFS];
87  float post_cos[COEFFS];
88  float post_sin[COEFFS];
89  float pre_coef1[COEFFS];
90  float pre_coef2[COEFFS];
92 
93  float sqrt_tab[30];
95 
99  DECLARE_ALIGNED(32, FFTComplex, samples)[COEFFS / 2];
100  float *out_samples;
101 
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_bswapdsp_init(&q->bdsp);
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 
340 static void imc_read_level_coeffs_raw(IMCContext *q, int stream_format_code,
341  int *levlCoeffs)
342 {
343  int i;
344 
345  q->coef0_pos = get_bits(&q->gb, 5);
346  levlCoeffs[0] = get_bits(&q->gb, 7);
347  for (i = 1; i < BANDS; i++)
348  levlCoeffs[i] = get_bits(&q->gb, 4);
349 }
350 
352  float *flcoeffs1, float *flcoeffs2)
353 {
354  int i, level;
355  float tmp, tmp2;
356  // maybe some frequency division thingy
357 
358  flcoeffs1[0] = 20000.0 / pow (2, levlCoeffBuf[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
359  flcoeffs2[0] = log2f(flcoeffs1[0]);
360  tmp = flcoeffs1[0];
361  tmp2 = flcoeffs2[0];
362 
363  for (i = 1; i < BANDS; i++) {
364  level = levlCoeffBuf[i];
365  if (level == 16) {
366  flcoeffs1[i] = 1.0;
367  flcoeffs2[i] = 0.0;
368  } else {
369  if (level < 17)
370  level -= 7;
371  else if (level <= 24)
372  level -= 32;
373  else
374  level -= 16;
375 
376  tmp *= imc_exp_tab[15 + level];
377  tmp2 += 0.83048 * level; // 0.83048 = log2(10) * 0.25
378  flcoeffs1[i] = tmp;
379  flcoeffs2[i] = tmp2;
380  }
381  }
382 }
383 
384 
386  float *old_floor, float *flcoeffs1,
387  float *flcoeffs2)
388 {
389  int i;
390  /* FIXME maybe flag_buf = noise coding and flcoeffs1 = new scale factors
391  * and flcoeffs2 old scale factors
392  * might be incomplete due to a missing table that is in the binary code
393  */
394  for (i = 0; i < BANDS; i++) {
395  flcoeffs1[i] = 0;
396  if (levlCoeffBuf[i] < 16) {
397  flcoeffs1[i] = imc_exp_tab2[levlCoeffBuf[i]] * old_floor[i];
398  flcoeffs2[i] = (levlCoeffBuf[i] - 7) * 0.83048 + flcoeffs2[i]; // 0.83048 = log2(10) * 0.25
399  } else {
400  flcoeffs1[i] = old_floor[i];
401  }
402  }
403 }
404 
406  float *flcoeffs1, float *flcoeffs2)
407 {
408  int i, level, pos;
409  float tmp, tmp2;
410 
411  pos = q->coef0_pos;
412  flcoeffs1[pos] = 20000.0 / pow (2, levlCoeffBuf[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
413  flcoeffs2[pos] = log2f(flcoeffs1[pos]);
414  tmp = flcoeffs1[pos];
415  tmp2 = flcoeffs2[pos];
416 
417  levlCoeffBuf++;
418  for (i = 0; i < BANDS; i++) {
419  if (i == pos)
420  continue;
421  level = *levlCoeffBuf++;
422  flcoeffs1[i] = tmp * powf(10.0, -level * 0.4375); //todo tab
423  flcoeffs2[i] = tmp2 - 1.4533435415 * level; // 1.4533435415 = log2(10) * 0.4375
424  }
425 }
426 
430 static int bit_allocation(IMCContext *q, IMCChannel *chctx,
431  int stream_format_code, int freebits, int flag)
432 {
433  int i, j;
434  const float limit = -1.e20;
435  float highest = 0.0;
436  int indx;
437  int t1 = 0;
438  int t2 = 1;
439  float summa = 0.0;
440  int iacc = 0;
441  int summer = 0;
442  int rres, cwlen;
443  float lowest = 1.e10;
444  int low_indx = 0;
445  float workT[32];
446  int flg;
447  int found_indx = 0;
448 
449  for (i = 0; i < BANDS; i++)
450  highest = FFMAX(highest, chctx->flcoeffs1[i]);
451 
452  for (i = 0; i < BANDS - 1; i++)
453  chctx->flcoeffs4[i] = chctx->flcoeffs3[i] - log2f(chctx->flcoeffs5[i]);
454  chctx->flcoeffs4[BANDS - 1] = limit;
455 
456  highest = highest * 0.25;
457 
458  for (i = 0; i < BANDS; i++) {
459  indx = -1;
460  if ((band_tab[i + 1] - band_tab[i]) == chctx->bandWidthT[i])
461  indx = 0;
462 
463  if ((band_tab[i + 1] - band_tab[i]) > chctx->bandWidthT[i])
464  indx = 1;
465 
466  if (((band_tab[i + 1] - band_tab[i]) / 2) >= chctx->bandWidthT[i])
467  indx = 2;
468 
469  if (indx == -1)
470  return AVERROR_INVALIDDATA;
471 
472  chctx->flcoeffs4[i] += xTab[(indx * 2 + (chctx->flcoeffs1[i] < highest)) * 2 + flag];
473  }
474 
475  if (stream_format_code & 0x2) {
476  chctx->flcoeffs4[0] = limit;
477  chctx->flcoeffs4[1] = limit;
478  chctx->flcoeffs4[2] = limit;
479  chctx->flcoeffs4[3] = limit;
480  }
481 
482  for (i = (stream_format_code & 0x2) ? 4 : 0; i < BANDS - 1; i++) {
483  iacc += chctx->bandWidthT[i];
484  summa += chctx->bandWidthT[i] * chctx->flcoeffs4[i];
485  }
486 
487  if (!iacc)
488  return AVERROR_INVALIDDATA;
489 
490  chctx->bandWidthT[BANDS - 1] = 0;
491  summa = (summa * 0.5 - freebits) / iacc;
492 
493 
494  for (i = 0; i < BANDS / 2; i++) {
495  rres = summer - freebits;
496  if ((rres >= -8) && (rres <= 8))
497  break;
498 
499  summer = 0;
500  iacc = 0;
501 
502  for (j = (stream_format_code & 0x2) ? 4 : 0; j < BANDS; j++) {
503  cwlen = av_clipf(((chctx->flcoeffs4[j] * 0.5) - summa + 0.5), 0, 6);
504 
505  chctx->bitsBandT[j] = cwlen;
506  summer += chctx->bandWidthT[j] * cwlen;
507 
508  if (cwlen > 0)
509  iacc += chctx->bandWidthT[j];
510  }
511 
512  flg = t2;
513  t2 = 1;
514  if (freebits < summer)
515  t2 = -1;
516  if (i == 0)
517  flg = t2;
518  if (flg != t2)
519  t1++;
520 
521  summa = (float)(summer - freebits) / ((t1 + 1) * iacc) + summa;
522  }
523 
524  for (i = (stream_format_code & 0x2) ? 4 : 0; i < BANDS; i++) {
525  for (j = band_tab[i]; j < band_tab[i + 1]; j++)
526  chctx->CWlengthT[j] = chctx->bitsBandT[i];
527  }
528 
529  if (freebits > summer) {
530  for (i = 0; i < BANDS; i++) {
531  workT[i] = (chctx->bitsBandT[i] == 6) ? -1.e20
532  : (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] - 0.415);
533  }
534 
535  highest = 0.0;
536 
537  do {
538  if (highest <= -1.e20)
539  break;
540 
541  found_indx = 0;
542  highest = -1.e20;
543 
544  for (i = 0; i < BANDS; i++) {
545  if (workT[i] > highest) {
546  highest = workT[i];
547  found_indx = i;
548  }
549  }
550 
551  if (highest > -1.e20) {
552  workT[found_indx] -= 2.0;
553  if (++chctx->bitsBandT[found_indx] == 6)
554  workT[found_indx] = -1.e20;
555 
556  for (j = band_tab[found_indx]; j < band_tab[found_indx + 1] && (freebits > summer); j++) {
557  chctx->CWlengthT[j]++;
558  summer++;
559  }
560  }
561  } while (freebits > summer);
562  }
563  if (freebits < summer) {
564  for (i = 0; i < BANDS; i++) {
565  workT[i] = chctx->bitsBandT[i] ? (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] + 1.585)
566  : 1.e20;
567  }
568  if (stream_format_code & 0x2) {
569  workT[0] = 1.e20;
570  workT[1] = 1.e20;
571  workT[2] = 1.e20;
572  workT[3] = 1.e20;
573  }
574  while (freebits < summer) {
575  lowest = 1.e10;
576  low_indx = 0;
577  for (i = 0; i < BANDS; i++) {
578  if (workT[i] < lowest) {
579  lowest = workT[i];
580  low_indx = i;
581  }
582  }
583  // if (lowest >= 1.e10)
584  // break;
585  workT[low_indx] = lowest + 2.0;
586 
587  if (!--chctx->bitsBandT[low_indx])
588  workT[low_indx] = 1.e20;
589 
590  for (j = band_tab[low_indx]; j < band_tab[low_indx+1] && (freebits < summer); j++) {
591  if (chctx->CWlengthT[j] > 0) {
592  chctx->CWlengthT[j]--;
593  summer--;
594  }
595  }
596  }
597  }
598  return 0;
599 }
600 
601 static void imc_get_skip_coeff(IMCContext *q, IMCChannel *chctx)
602 {
603  int i, j;
604 
605  memset(chctx->skipFlagBits, 0, sizeof(chctx->skipFlagBits));
606  memset(chctx->skipFlagCount, 0, sizeof(chctx->skipFlagCount));
607  for (i = 0; i < BANDS; i++) {
608  if (!chctx->bandFlagsBuf[i] || !chctx->bandWidthT[i])
609  continue;
610 
611  if (!chctx->skipFlagRaw[i]) {
612  chctx->skipFlagBits[i] = band_tab[i + 1] - band_tab[i];
613 
614  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
615  chctx->skipFlags[j] = get_bits1(&q->gb);
616  if (chctx->skipFlags[j])
617  chctx->skipFlagCount[i]++;
618  }
619  } else {
620  for (j = band_tab[i]; j < band_tab[i + 1] - 1; j += 2) {
621  if (!get_bits1(&q->gb)) { // 0
622  chctx->skipFlagBits[i]++;
623  chctx->skipFlags[j] = 1;
624  chctx->skipFlags[j + 1] = 1;
625  chctx->skipFlagCount[i] += 2;
626  } else {
627  if (get_bits1(&q->gb)) { // 11
628  chctx->skipFlagBits[i] += 2;
629  chctx->skipFlags[j] = 0;
630  chctx->skipFlags[j + 1] = 1;
631  chctx->skipFlagCount[i]++;
632  } else {
633  chctx->skipFlagBits[i] += 3;
634  chctx->skipFlags[j + 1] = 0;
635  if (!get_bits1(&q->gb)) { // 100
636  chctx->skipFlags[j] = 1;
637  chctx->skipFlagCount[i]++;
638  } else { // 101
639  chctx->skipFlags[j] = 0;
640  }
641  }
642  }
643  }
644 
645  if (j < band_tab[i + 1]) {
646  chctx->skipFlagBits[i]++;
647  if ((chctx->skipFlags[j] = get_bits1(&q->gb)))
648  chctx->skipFlagCount[i]++;
649  }
650  }
651  }
652 }
653 
658  int summer)
659 {
660  float workT[32];
661  int corrected = 0;
662  int i, j;
663  float highest = 0;
664  int found_indx = 0;
665 
666  for (i = 0; i < BANDS; i++) {
667  workT[i] = (chctx->bitsBandT[i] == 6) ? -1.e20
668  : (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] - 0.415);
669  }
670 
671  while (corrected < summer) {
672  if (highest <= -1.e20)
673  break;
674 
675  highest = -1.e20;
676 
677  for (i = 0; i < BANDS; i++) {
678  if (workT[i] > highest) {
679  highest = workT[i];
680  found_indx = i;
681  }
682  }
683 
684  if (highest > -1.e20) {
685  workT[found_indx] -= 2.0;
686  if (++(chctx->bitsBandT[found_indx]) == 6)
687  workT[found_indx] = -1.e20;
688 
689  for (j = band_tab[found_indx]; j < band_tab[found_indx+1] && (corrected < summer); j++) {
690  if (!chctx->skipFlags[j] && (chctx->CWlengthT[j] < 6)) {
691  chctx->CWlengthT[j]++;
692  corrected++;
693  }
694  }
695  }
696  }
697 }
698 
699 static void imc_imdct256(IMCContext *q, IMCChannel *chctx, int channels)
700 {
701  int i;
702  float re, im;
703  float *dst1 = q->out_samples;
704  float *dst2 = q->out_samples + (COEFFS - 1);
705 
706  /* prerotation */
707  for (i = 0; i < COEFFS / 2; i++) {
708  q->samples[i].re = -(q->pre_coef1[i] * chctx->CWdecoded[COEFFS - 1 - i * 2]) -
709  (q->pre_coef2[i] * chctx->CWdecoded[i * 2]);
710  q->samples[i].im = (q->pre_coef2[i] * chctx->CWdecoded[COEFFS - 1 - i * 2]) -
711  (q->pre_coef1[i] * chctx->CWdecoded[i * 2]);
712  }
713 
714  /* FFT */
715  q->fft.fft_permute(&q->fft, q->samples);
716  q->fft.fft_calc(&q->fft, q->samples);
717 
718  /* postrotation, window and reorder */
719  for (i = 0; i < COEFFS / 2; i++) {
720  re = ( q->samples[i].re * q->post_cos[i]) + (-q->samples[i].im * q->post_sin[i]);
721  im = (-q->samples[i].im * q->post_cos[i]) - ( q->samples[i].re * q->post_sin[i]);
722  *dst1 = (q->mdct_sine_window[COEFFS - 1 - i * 2] * chctx->last_fft_im[i])
723  + (q->mdct_sine_window[i * 2] * re);
724  *dst2 = (q->mdct_sine_window[i * 2] * chctx->last_fft_im[i])
725  - (q->mdct_sine_window[COEFFS - 1 - i * 2] * re);
726  dst1 += 2;
727  dst2 -= 2;
728  chctx->last_fft_im[i] = im;
729  }
730 }
731 
733  int stream_format_code)
734 {
735  int i, j;
736  int middle_value, cw_len, max_size;
737  const float *quantizer;
738 
739  for (i = 0; i < BANDS; i++) {
740  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
741  chctx->CWdecoded[j] = 0;
742  cw_len = chctx->CWlengthT[j];
743 
744  if (cw_len <= 0 || chctx->skipFlags[j])
745  continue;
746 
747  max_size = 1 << cw_len;
748  middle_value = max_size >> 1;
749 
750  if (chctx->codewords[j] >= max_size || chctx->codewords[j] < 0)
751  return AVERROR_INVALIDDATA;
752 
753  if (cw_len >= 4) {
754  quantizer = imc_quantizer2[(stream_format_code & 2) >> 1];
755  if (chctx->codewords[j] >= middle_value)
756  chctx->CWdecoded[j] = quantizer[chctx->codewords[j] - 8] * chctx->flcoeffs6[i];
757  else
758  chctx->CWdecoded[j] = -quantizer[max_size - chctx->codewords[j] - 8 - 1] * chctx->flcoeffs6[i];
759  }else{
760  quantizer = imc_quantizer1[((stream_format_code & 2) >> 1) | (chctx->bandFlagsBuf[i] << 1)];
761  if (chctx->codewords[j] >= middle_value)
762  chctx->CWdecoded[j] = quantizer[chctx->codewords[j] - 1] * chctx->flcoeffs6[i];
763  else
764  chctx->CWdecoded[j] = -quantizer[max_size - 2 - chctx->codewords[j]] * chctx->flcoeffs6[i];
765  }
766  }
767  }
768  return 0;
769 }
770 
771 
772 static int imc_get_coeffs(IMCContext *q, IMCChannel *chctx)
773 {
774  int i, j, cw_len, cw;
775 
776  for (i = 0; i < BANDS; i++) {
777  if (!chctx->sumLenArr[i])
778  continue;
779  if (chctx->bandFlagsBuf[i] || chctx->bandWidthT[i]) {
780  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
781  cw_len = chctx->CWlengthT[j];
782  cw = 0;
783 
784  if (get_bits_count(&q->gb) + cw_len > 512) {
785  ff_dlog(NULL, "Band %i coeff %i cw_len %i\n", i, j, cw_len);
786  return AVERROR_INVALIDDATA;
787  }
788 
789  if (cw_len && (!chctx->bandFlagsBuf[i] || !chctx->skipFlags[j]))
790  cw = get_bits(&q->gb, cw_len);
791 
792  chctx->codewords[j] = cw;
793  }
794  }
795  }
796  return 0;
797 }
798 
800 {
801  int i, j;
802  int bits, summer;
803 
804  for (i = 0; i < BANDS; i++) {
805  chctx->sumLenArr[i] = 0;
806  chctx->skipFlagRaw[i] = 0;
807  for (j = band_tab[i]; j < band_tab[i + 1]; j++)
808  chctx->sumLenArr[i] += chctx->CWlengthT[j];
809  if (chctx->bandFlagsBuf[i])
810  if ((((band_tab[i + 1] - band_tab[i]) * 1.5) > chctx->sumLenArr[i]) && (chctx->sumLenArr[i] > 0))
811  chctx->skipFlagRaw[i] = 1;
812  }
813 
814  imc_get_skip_coeff(q, chctx);
815 
816  for (i = 0; i < BANDS; i++) {
817  chctx->flcoeffs6[i] = chctx->flcoeffs1[i];
818  /* band has flag set and at least one coded coefficient */
819  if (chctx->bandFlagsBuf[i] && (band_tab[i + 1] - band_tab[i]) != chctx->skipFlagCount[i]) {
820  chctx->flcoeffs6[i] *= q->sqrt_tab[ band_tab[i + 1] - band_tab[i]] /
821  q->sqrt_tab[(band_tab[i + 1] - band_tab[i] - chctx->skipFlagCount[i])];
822  }
823  }
824 
825  /* calculate bits left, bits needed and adjust bit allocation */
826  bits = summer = 0;
827 
828  for (i = 0; i < BANDS; i++) {
829  if (chctx->bandFlagsBuf[i]) {
830  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
831  if (chctx->skipFlags[j]) {
832  summer += chctx->CWlengthT[j];
833  chctx->CWlengthT[j] = 0;
834  }
835  }
836  bits += chctx->skipFlagBits[i];
837  summer -= chctx->skipFlagBits[i];
838  }
839  }
840  imc_adjust_bit_allocation(q, chctx, summer);
841 }
842 
843 static int imc_decode_block(AVCodecContext *avctx, IMCContext *q, int ch)
844 {
845  int stream_format_code;
846  int imc_hdr, i, j, ret;
847  int flag;
848  int bits;
849  int counter, bitscount;
850  IMCChannel *chctx = q->chctx + ch;
851 
852 
853  /* Check the frame header */
854  imc_hdr = get_bits(&q->gb, 9);
855  if (imc_hdr & 0x18) {
856  av_log(avctx, AV_LOG_ERROR, "frame header check failed!\n");
857  av_log(avctx, AV_LOG_ERROR, "got %X.\n", imc_hdr);
858  return AVERROR_INVALIDDATA;
859  }
860  stream_format_code = get_bits(&q->gb, 3);
861 
862  if (stream_format_code & 0x04)
863  chctx->decoder_reset = 1;
864 
865  if (chctx->decoder_reset) {
866  for (i = 0; i < BANDS; i++)
867  chctx->old_floor[i] = 1.0;
868  for (i = 0; i < COEFFS; i++)
869  chctx->CWdecoded[i] = 0;
870  chctx->decoder_reset = 0;
871  }
872 
873  flag = get_bits1(&q->gb);
874  if (stream_format_code & 0x1)
875  imc_read_level_coeffs_raw(q, stream_format_code, chctx->levlCoeffBuf);
876  else
877  imc_read_level_coeffs(q, stream_format_code, chctx->levlCoeffBuf);
878 
879  if (stream_format_code & 0x1)
881  chctx->flcoeffs1, chctx->flcoeffs2);
882  else if (stream_format_code & 0x4)
884  chctx->flcoeffs1, chctx->flcoeffs2);
885  else
887  chctx->flcoeffs1, chctx->flcoeffs2);
888 
889  memcpy(chctx->old_floor, chctx->flcoeffs1, 32 * sizeof(float));
890 
891  counter = 0;
892  if (stream_format_code & 0x1) {
893  for (i = 0; i < BANDS; i++) {
894  chctx->bandWidthT[i] = band_tab[i + 1] - band_tab[i];
895  chctx->bandFlagsBuf[i] = 0;
896  chctx->flcoeffs3[i] = chctx->flcoeffs2[i] * 2;
897  chctx->flcoeffs5[i] = 1.0;
898  }
899  } else {
900  for (i = 0; i < BANDS; i++) {
901  if (chctx->levlCoeffBuf[i] == 16) {
902  chctx->bandWidthT[i] = 0;
903  counter++;
904  } else
905  chctx->bandWidthT[i] = band_tab[i + 1] - band_tab[i];
906  }
907 
908  memset(chctx->bandFlagsBuf, 0, BANDS * sizeof(int));
909  for (i = 0; i < BANDS - 1; i++)
910  if (chctx->bandWidthT[i])
911  chctx->bandFlagsBuf[i] = get_bits1(&q->gb);
912 
913  imc_calculate_coeffs(q, chctx->flcoeffs1, chctx->flcoeffs2,
914  chctx->bandWidthT, chctx->flcoeffs3,
915  chctx->flcoeffs5);
916  }
917 
918  bitscount = 0;
919  /* first 4 bands will be assigned 5 bits per coefficient */
920  if (stream_format_code & 0x2) {
921  bitscount += 15;
922 
923  chctx->bitsBandT[0] = 5;
924  chctx->CWlengthT[0] = 5;
925  chctx->CWlengthT[1] = 5;
926  chctx->CWlengthT[2] = 5;
927  for (i = 1; i < 4; i++) {
928  if (stream_format_code & 0x1)
929  bits = 5;
930  else
931  bits = (chctx->levlCoeffBuf[i] == 16) ? 0 : 5;
932  chctx->bitsBandT[i] = bits;
933  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
934  chctx->CWlengthT[j] = bits;
935  bitscount += bits;
936  }
937  }
938  }
939  if (avctx->codec_id == AV_CODEC_ID_IAC) {
940  bitscount += !!chctx->bandWidthT[BANDS - 1];
941  if (!(stream_format_code & 0x2))
942  bitscount += 16;
943  }
944 
945  if ((ret = bit_allocation(q, chctx, stream_format_code,
946  512 - bitscount - get_bits_count(&q->gb),
947  flag)) < 0) {
948  av_log(avctx, AV_LOG_ERROR, "Bit allocations failed\n");
949  chctx->decoder_reset = 1;
950  return ret;
951  }
952 
953  if (stream_format_code & 0x1) {
954  for (i = 0; i < BANDS; i++)
955  chctx->skipFlags[i] = 0;
956  } else {
957  imc_refine_bit_allocation(q, chctx);
958  }
959 
960  for (i = 0; i < BANDS; i++) {
961  chctx->sumLenArr[i] = 0;
962 
963  for (j = band_tab[i]; j < band_tab[i + 1]; j++)
964  if (!chctx->skipFlags[j])
965  chctx->sumLenArr[i] += chctx->CWlengthT[j];
966  }
967 
968  memset(chctx->codewords, 0, sizeof(chctx->codewords));
969 
970  if (imc_get_coeffs(q, chctx) < 0) {
971  av_log(avctx, AV_LOG_ERROR, "Read coefficients failed\n");
972  chctx->decoder_reset = 1;
973  return AVERROR_INVALIDDATA;
974  }
975 
976  if (inverse_quant_coeff(q, chctx, stream_format_code) < 0) {
977  av_log(avctx, AV_LOG_ERROR, "Inverse quantization of coefficients failed\n");
978  chctx->decoder_reset = 1;
979  return AVERROR_INVALIDDATA;
980  }
981 
982  memset(chctx->skipFlags, 0, sizeof(chctx->skipFlags));
983 
984  imc_imdct256(q, chctx, avctx->channels);
985 
986  return 0;
987 }
988 
989 static int imc_decode_frame(AVCodecContext *avctx, void *data,
990  int *got_frame_ptr, AVPacket *avpkt)
991 {
992  AVFrame *frame = data;
993  const uint8_t *buf = avpkt->data;
994  int buf_size = avpkt->size;
995  int ret, i;
996 
997  IMCContext *q = avctx->priv_data;
998 
1000 
1001  if (buf_size < IMC_BLOCK_SIZE * avctx->channels) {
1002  av_log(avctx, AV_LOG_ERROR, "frame too small!\n");
1003  return AVERROR_INVALIDDATA;
1004  }
1005 
1006  /* get output buffer */
1007  frame->nb_samples = COEFFS;
1008  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1009  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1010  return ret;
1011  }
1012 
1013  for (i = 0; i < avctx->channels; i++) {
1014  q->out_samples = (float *)frame->extended_data[i];
1015 
1016  q->bdsp.bswap16_buf(buf16, (const uint16_t *) buf, IMC_BLOCK_SIZE / 2);
1017 
1018  init_get_bits(&q->gb, (const uint8_t*)buf16, IMC_BLOCK_SIZE * 8);
1019 
1020  buf += IMC_BLOCK_SIZE;
1021 
1022  if ((ret = imc_decode_block(avctx, q, i)) < 0)
1023  return ret;
1024  }
1025 
1026  if (avctx->channels == 2) {
1027  q->fdsp.butterflies_float((float *)frame->extended_data[0],
1028  (float *)frame->extended_data[1], COEFFS);
1029  }
1030 
1031  *got_frame_ptr = 1;
1032 
1033  return IMC_BLOCK_SIZE * avctx->channels;
1034 }
1035 
1036 
1038 {
1039  IMCContext *q = avctx->priv_data;
1040 
1041  ff_fft_end(&q->fft);
1042 
1043  return 0;
1044 }
1045 
1046 
1048  .name = "imc",
1049  .long_name = NULL_IF_CONFIG_SMALL("IMC (Intel Music Coder)"),
1050  .type = AVMEDIA_TYPE_AUDIO,
1051  .id = AV_CODEC_ID_IMC,
1052  .priv_data_size = sizeof(IMCContext),
1053  .init = imc_decode_init,
1054  .close = imc_decode_close,
1056  .capabilities = AV_CODEC_CAP_DR1,
1057  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1059 };
1060 
1062  .name = "iac",
1063  .long_name = NULL_IF_CONFIG_SMALL("IAC (Indeo Audio Coder)"),
1064  .type = AVMEDIA_TYPE_AUDIO,
1065  .id = AV_CODEC_ID_IAC,
1066  .priv_data_size = sizeof(IMCContext),
1067  .init = imc_decode_init,
1068  .close = imc_decode_close,
1070  .capabilities = AV_CODEC_CAP_DR1,
1071  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1073 };
int skipFlags[COEFFS]
skip coefficient decoding or not
Definition: imc.c:73
AVCodec ff_imc_decoder
Definition: imc.c:1047
float flcoeffs3[BANDS]
Definition: imc.c:58
float, planar
Definition: samplefmt.h:71
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
float flcoeffs1[BANDS]
Definition: imc.c:56
This structure describes decoded (raw) audio or video data.
Definition: frame.h:140
int codewords[COEFFS]
raw codewords read from bitstream
Definition: imc.c:74
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
Definition: bswapdsp.h:26
float post_sin[COEFFS]
Definition: imc.c:88
float re
Definition: fft.c:69
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:228
int skipFlagRaw[BANDS]
skip flags are stored in raw form or not
Definition: imc.c:70
static const int vlc_offsets[17]
Definition: imc.c:112
int size
Definition: avcodec.h:1347
int flag
Definition: cpu.c:35
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, 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)
float mdct_sine_window[COEFFS]
MDCT tables.
Definition: imc.c:86
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:58
static const uint8_t imc_huffman_lens[4][4][18]
Definition: imcdata.h:115
int skipFlagCount[BANDS]
skipped coefficients per band
Definition: imc.c:72
static const float imc_weights2[31]
Definition: imcdata.h:53
FFTSample re
Definition: avfft.h:38
int8_t cyclTab2[32]
Definition: imc.c:104
#define AV_CH_LAYOUT_STEREO
static void imc_read_level_coeffs(IMCContext *q, int stream_format_code, int *levlCoeffs)
Definition: imc.c:312
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
float flcoeffs4[BANDS]
Definition: imc.c:59
AVCodec.
Definition: avcodec.h:3120
float sqrt_tab[30]
Definition: imc.c:93
float old_floor[BANDS]
Definition: imc.c:55
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:252
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2160
uint8_t
#define av_cold
Definition: attributes.h:66
float pre_coef1[COEFFS]
Definition: imc.c:89
float CWdecoded[COEFFS]
Definition: imc.c:62
int bandFlagsBuf[BANDS]
flags for each band
Definition: imc.c:68
int coef0_pos
Definition: imc.c:102
static av_cold int imc_decode_close(AVCodecContext *avctx)
Definition: imc.c:1037
static const int8_t cyclTab[32]
Definition: imcdata.h:36
const char data[16]
Definition: mxf.c:70
uint8_t * data
Definition: avcodec.h:1346
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:182
static const float imc_weights1[31]
Definition: imcdata.h:47
bitstream reader API header.
float weights2[31]
Definition: imc.c:105
static void imc_get_skip_coeff(IMCContext *q, IMCChannel *chctx)
Definition: imc.c:601
static void imc_refine_bit_allocation(IMCContext *q, IMCChannel *chctx)
Definition: imc.c:799
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:124
float pre_coef2[COEFFS]
Definition: imc.c:90
void(* fft_permute)(struct FFTContext *s, FFTComplex *z)
Do the permutation needed BEFORE calling fft_calc().
Definition: fft.h:86
static const float *const imc_exp_tab2
Definition: imcdata.h:97
static void imc_decode_level_coefficients_raw(IMCContext *q, int *levlCoeffBuf, float *flcoeffs1, float *flcoeffs2)
Definition: imc.c:405
float weights1[31]
Definition: imc.c:105
#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. ...
Definition: internal.h:148
static void imc_imdct256(IMCContext *q, IMCChannel *chctx, int channels)
Definition: imc.c:699
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1503
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.
Definition: avcodec.h:3127
#define FFMAX(a, b)
Definition: common.h:64
GetBitContext gb
Definition: imc.c:94
Definition: vlc.h:26
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2203
#define IMC_BLOCK_SIZE
Definition: imc.c:49
IMCChannel chctx[2]
Definition: imc.c:82
#define powf(x, y)
Definition: libm.h:44
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:989
static void imc_decode_level_coefficients2(IMCContext *q, int *levlCoeffBuf, float *old_floor, float *flcoeffs1, float *flcoeffs2)
Definition: imc.c:385
common internal API header
#define COEFFS
Definition: imc.c:52
AVFloatDSPContext fdsp
Definition: imc.c:97
Definition: fft.h:73
audio channel layout utility functions
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:788
static const uint16_t band_tab[33]
Definition: imcdata.h:29
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
Definition: avconv.c:1288
FFTContext fft
Definition: imc.c:98
#define ff_fft_init
Definition: fft.h:132
static int imc_get_coeffs(IMCContext *q, IMCChannel *chctx)
Definition: imc.c:772
float flcoeffs5[BANDS]
Definition: imc.c:60
int bitsBandT[BANDS]
how many bits per codeword in band
Definition: imc.c:65
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:493
Definition: imc.c:81
float last_fft_im[COEFFS]
Definition: imc.c:76
float post_cos[COEFFS]
Definition: imc.c:87
int bits
Definition: vlc.h:27
if(ac->has_optimized_func)
void ff_sine_window_init(float *window, int n)
Generate a sine window.
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
int table_allocated
Definition: vlc.h:29
NULL
Definition: eval.c:55
#define AV_LOG_INFO
Standard information.
Definition: log.h:135
float flcoeffs6[BANDS]
Definition: imc.c:61
static const float xTab[14]
Definition: imcdata.h:84
FFTComplex samples[COEFFS/2]
Definition: imc.c:99
Libavcodec external API header.
#define ff_dlog(ctx,...)
Definition: internal.h:60
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:60
int8_t cyclTab[32]
Definition: imc.c:104
enum AVCodecID codec_id
Definition: avcodec.h:1426
static int inverse_quant_coeff(IMCContext *q, IMCChannel *chctx, int stream_format_code)
Definition: imc.c:732
int sample_rate
samples per second
Definition: avcodec.h:2152
Definition: imc.c:54
main external API structure.
Definition: avcodec.h:1409
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:589
static double freq2bark(double freq)
Definition: imc.c:119
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:267
int bandWidthT[BANDS]
codewords per band
Definition: imc.c:64
float * out_samples
Definition: imc.c:100
float im
Definition: fft.c:69
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:362
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:51
av_cold void avpriv_float_dsp_init(AVFloatDSPContext *fdsp, int bit_exact)
Initialize a float DSP context.
Definition: float_dsp.c:115
uint8_t level
Definition: svq3.c:204
static av_cold void iac_generate_tabs(IMCContext *q, int sampling_rate)
Definition: imc.c:124
int levlCoeffBuf[BANDS]
Definition: imc.c:67
int decoder_reset
Definition: imc.c:78
common internal api header.
FFTSample im
Definition: avfft.h:38
static int imc_decode_block(AVCodecContext *avctx, IMCContext *q, int ch)
Definition: imc.c:843
#define log2f(x)
Definition: libm.h:116
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:55
BswapDSPContext bdsp
Definition: imc.c:96
#define ff_fft_end
Definition: fft.h:133
void(* fft_calc)(struct FFTContext *s, FFTComplex *z)
Do a complex FFT with the parameters defined in ff_fft_init().
Definition: fft.h:91
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:430
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:582
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:638
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:1451
int channels
number of audio channels
Definition: avcodec.h:2153
static uint8_t tmp[8]
Definition: des.c:38
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:700
void(* butterflies_float)(float *restrict v1, float *restrict v2, int len)
Calculate the sum and difference of two vectors of floats.
Definition: float_dsp.h:148
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:111
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:657
#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:69
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:174
#define AV_CH_LAYOUT_MONO
static void imc_read_level_coeffs_raw(IMCContext *q, int stream_format_code, int *levlCoeffs)
Definition: imc.c:340
This structure stores compressed data.
Definition: avcodec.h:1323
static void imc_decode_level_coefficients(IMCContext *q, int *levlCoeffBuf, float *flcoeffs1, float *flcoeffs2)
Definition: imc.c:351
int skipFlagBits[BANDS]
bits used to code skip flags
Definition: imc.c:71
static av_cold int imc_decode_init(AVCodecContext *avctx)
Definition: imc.c:175
AVCodec ff_iac_decoder
Definition: imc.c:1061
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:184
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:838
static const float imc_exp_tab[32]
Definition: imcdata.h:87
float flcoeffs2[BANDS]
Definition: imc.c:57
for(j=16;j >0;--j)
static const uint16_t imc_huffman_bits[4][4][18]
Definition: imcdata.h:142
int CWlengthT[COEFFS]
how many bits in each codeword
Definition: imc.c:66