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 
34 #include <math.h>
35 #include <stddef.h>
36 #include <stdio.h>
37 
39 #include "avcodec.h"
40 #include "get_bits.h"
41 #include "dsputil.h"
42 #include "fft.h"
43 #include "internal.h"
44 #include "sinewin.h"
45 
46 #include "imcdata.h"
47 
48 #define IMC_BLOCK_SIZE 64
49 #define IMC_FRAME_ID 0x21
50 #define BANDS 32
51 #define COEFFS 256
52 
53 typedef struct IMCChannel {
54  float old_floor[BANDS];
55  float flcoeffs1[BANDS];
56  float flcoeffs2[BANDS];
57  float flcoeffs3[BANDS];
58  float flcoeffs4[BANDS];
59  float flcoeffs5[BANDS];
60  float flcoeffs6[BANDS];
61  float CWdecoded[COEFFS];
62 
74 
76 
78 } IMCChannel;
79 
80 typedef struct {
82 
83  IMCChannel chctx[2];
84 
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];
93 
94  float sqrt_tab[30];
96 
100  float *out_samples;
101 
102  int8_t cyclTab[32], cyclTab2[32];
103  float weights1[31], weights2[31];
104 } IMCContext;
105 
106 static VLC huffman_vlc[4][4];
107 
108 #define VLC_TABLES_SIZE 9512
109 
110 static const int vlc_offsets[17] = {
111  0, 640, 1156, 1732, 2308, 2852, 3396, 3924,
112  4452, 5220, 5860, 6628, 7268, 7908, 8424, 8936, VLC_TABLES_SIZE
113 };
114 
116 
117 static inline double freq2bark(double freq)
118 {
119  return 3.5 * atan((freq / 7500.0) * (freq / 7500.0)) + 13.0 * atan(freq * 0.00076);
120 }
121 
122 static av_cold void iac_generate_tabs(IMCContext *q, int sampling_rate)
123 {
124  double freqmin[32], freqmid[32], freqmax[32];
125  double scale = sampling_rate / (256.0 * 2.0 * 2.0);
126  double nyquist_freq = sampling_rate * 0.5;
127  double freq, bark, prev_bark = 0, tf, tb;
128  int i, j;
129 
130  for (i = 0; i < 32; i++) {
131  freq = (band_tab[i] + band_tab[i + 1] - 1) * scale;
132  bark = freq2bark(freq);
133 
134  if (i > 0) {
135  tb = bark - prev_bark;
136  q->weights1[i - 1] = pow(10.0, -1.0 * tb);
137  q->weights2[i - 1] = pow(10.0, -2.7 * tb);
138  }
139  prev_bark = bark;
140 
141  freqmid[i] = freq;
142 
143  tf = freq;
144  while (tf < nyquist_freq) {
145  tf += 0.5;
146  tb = freq2bark(tf);
147  if (tb > bark + 0.5)
148  break;
149  }
150  freqmax[i] = tf;
151 
152  tf = freq;
153  while (tf > 0.0) {
154  tf -= 0.5;
155  tb = freq2bark(tf);
156  if (tb <= bark - 0.5)
157  break;
158  }
159  freqmin[i] = tf;
160  }
161 
162  for (i = 0; i < 32; i++) {
163  freq = freqmax[i];
164  for (j = 31; j > 0 && freq <= freqmid[j]; j--);
165  q->cyclTab[i] = j + 1;
166 
167  freq = freqmin[i];
168  for (j = 0; j < 32 && freq >= freqmid[j]; j++);
169  q->cyclTab2[i] = j - 1;
170  }
171 }
172 
174 {
175  int i, j, ret;
176  IMCContext *q = avctx->priv_data;
177  double r1, r2;
178 
179  if (avctx->codec_id == AV_CODEC_ID_IMC)
180  avctx->channels = 1;
181 
182  if (avctx->channels > 2) {
183  av_log_ask_for_sample(avctx, "Number of channels is not supported\n");
184  return AVERROR_PATCHWELCOME;
185  }
186 
187  for (j = 0; j < avctx->channels; j++) {
188  q->chctx[j].decoder_reset = 1;
189 
190  for (i = 0; i < BANDS; i++)
191  q->chctx[j].old_floor[i] = 1.0;
192 
193  for (i = 0; i < COEFFS / 2; i++)
194  q->chctx[j].last_fft_im[i] = 0;
195  }
196 
197  /* Build mdct window, a simple sine window normalized with sqrt(2) */
199  for (i = 0; i < COEFFS; i++)
200  q->mdct_sine_window[i] *= sqrt(2.0);
201  for (i = 0; i < COEFFS / 2; i++) {
202  q->post_cos[i] = (1.0f / 32768) * cos(i / 256.0 * M_PI);
203  q->post_sin[i] = (1.0f / 32768) * sin(i / 256.0 * M_PI);
204 
205  r1 = sin((i * 4.0 + 1.0) / 1024.0 * M_PI);
206  r2 = cos((i * 4.0 + 1.0) / 1024.0 * M_PI);
207 
208  if (i & 0x1) {
209  q->pre_coef1[i] = (r1 + r2) * sqrt(2.0);
210  q->pre_coef2[i] = -(r1 - r2) * sqrt(2.0);
211  } else {
212  q->pre_coef1[i] = -(r1 + r2) * sqrt(2.0);
213  q->pre_coef2[i] = (r1 - r2) * sqrt(2.0);
214  }
215  }
216 
217  /* Generate a square root table */
218 
219  for (i = 0; i < 30; i++)
220  q->sqrt_tab[i] = sqrt(i);
221 
222  /* initialize the VLC tables */
223  for (i = 0; i < 4 ; i++) {
224  for (j = 0; j < 4; j++) {
225  huffman_vlc[i][j].table = &vlc_tables[vlc_offsets[i * 4 + j]];
226  huffman_vlc[i][j].table_allocated = vlc_offsets[i * 4 + j + 1] - vlc_offsets[i * 4 + j];
227  init_vlc(&huffman_vlc[i][j], 9, imc_huffman_sizes[i],
228  imc_huffman_lens[i][j], 1, 1,
230  }
231  }
232 
233  if (avctx->codec_id == AV_CODEC_ID_IAC) {
234  iac_generate_tabs(q, avctx->sample_rate);
235  } else {
236  memcpy(q->cyclTab, cyclTab, sizeof(cyclTab));
237  memcpy(q->cyclTab2, cyclTab2, sizeof(cyclTab2));
238  memcpy(q->weights1, imc_weights1, sizeof(imc_weights1));
239  memcpy(q->weights2, imc_weights2, sizeof(imc_weights2));
240  }
241 
242  if ((ret = ff_fft_init(&q->fft, 7, 1))) {
243  av_log(avctx, AV_LOG_INFO, "FFT init failed\n");
244  return ret;
245  }
246  ff_dsputil_init(&q->dsp, avctx);
248  avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO
250 
252  avctx->coded_frame = &q->frame;
253 
254  return 0;
255 }
256 
257 static void imc_calculate_coeffs(IMCContext *q, float *flcoeffs1,
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_decode_level_coefficients(IMCContext *q, int *levlCoeffBuf,
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 / pow (2, 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 
374 static void imc_decode_level_coefficients2(IMCContext *q, int *levlCoeffBuf,
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 
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 
454  if (!iacc)
455  return AVERROR_INVALIDDATA;
456 
457  chctx->bandWidthT[BANDS - 1] = 0;
458  summa = (summa * 0.5 - freebits) / iacc;
459 
460 
461  for (i = 0; i < BANDS / 2; i++) {
462  rres = summer - freebits;
463  if ((rres >= -8) && (rres <= 8))
464  break;
465 
466  summer = 0;
467  iacc = 0;
468 
469  for (j = (stream_format_code & 0x2) ? 4 : 0; j < BANDS; j++) {
470  cwlen = av_clipf(((chctx->flcoeffs4[j] * 0.5) - summa + 0.5), 0, 6);
471 
472  chctx->bitsBandT[j] = cwlen;
473  summer += chctx->bandWidthT[j] * cwlen;
474 
475  if (cwlen > 0)
476  iacc += chctx->bandWidthT[j];
477  }
478 
479  flg = t2;
480  t2 = 1;
481  if (freebits < summer)
482  t2 = -1;
483  if (i == 0)
484  flg = t2;
485  if (flg != t2)
486  t1++;
487 
488  summa = (float)(summer - freebits) / ((t1 + 1) * iacc) + summa;
489  }
490 
491  for (i = (stream_format_code & 0x2) ? 4 : 0; i < BANDS; i++) {
492  for (j = band_tab[i]; j < band_tab[i + 1]; j++)
493  chctx->CWlengthT[j] = chctx->bitsBandT[i];
494  }
495 
496  if (freebits > summer) {
497  for (i = 0; i < BANDS; i++) {
498  workT[i] = (chctx->bitsBandT[i] == 6) ? -1.e20
499  : (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] - 0.415);
500  }
501 
502  highest = 0.0;
503 
504  do {
505  if (highest <= -1.e20)
506  break;
507 
508  found_indx = 0;
509  highest = -1.e20;
510 
511  for (i = 0; i < BANDS; i++) {
512  if (workT[i] > highest) {
513  highest = workT[i];
514  found_indx = i;
515  }
516  }
517 
518  if (highest > -1.e20) {
519  workT[found_indx] -= 2.0;
520  if (++chctx->bitsBandT[found_indx] == 6)
521  workT[found_indx] = -1.e20;
522 
523  for (j = band_tab[found_indx]; j < band_tab[found_indx + 1] && (freebits > summer); j++) {
524  chctx->CWlengthT[j]++;
525  summer++;
526  }
527  }
528  } while (freebits > summer);
529  }
530  if (freebits < summer) {
531  for (i = 0; i < BANDS; i++) {
532  workT[i] = chctx->bitsBandT[i] ? (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] + 1.585)
533  : 1.e20;
534  }
535  if (stream_format_code & 0x2) {
536  workT[0] = 1.e20;
537  workT[1] = 1.e20;
538  workT[2] = 1.e20;
539  workT[3] = 1.e20;
540  }
541  while (freebits < summer) {
542  lowest = 1.e10;
543  low_indx = 0;
544  for (i = 0; i < BANDS; i++) {
545  if (workT[i] < lowest) {
546  lowest = workT[i];
547  low_indx = i;
548  }
549  }
550  // if (lowest >= 1.e10)
551  // break;
552  workT[low_indx] = lowest + 2.0;
553 
554  if (!--chctx->bitsBandT[low_indx])
555  workT[low_indx] = 1.e20;
556 
557  for (j = band_tab[low_indx]; j < band_tab[low_indx+1] && (freebits < summer); j++) {
558  if (chctx->CWlengthT[j] > 0) {
559  chctx->CWlengthT[j]--;
560  summer--;
561  }
562  }
563  }
564  }
565  return 0;
566 }
567 
568 static void imc_get_skip_coeff(IMCContext *q, IMCChannel *chctx)
569 {
570  int i, j;
571 
572  memset(chctx->skipFlagBits, 0, sizeof(chctx->skipFlagBits));
573  memset(chctx->skipFlagCount, 0, sizeof(chctx->skipFlagCount));
574  for (i = 0; i < BANDS; i++) {
575  if (!chctx->bandFlagsBuf[i] || !chctx->bandWidthT[i])
576  continue;
577 
578  if (!chctx->skipFlagRaw[i]) {
579  chctx->skipFlagBits[i] = band_tab[i + 1] - band_tab[i];
580 
581  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
582  chctx->skipFlags[j] = get_bits1(&q->gb);
583  if (chctx->skipFlags[j])
584  chctx->skipFlagCount[i]++;
585  }
586  } else {
587  for (j = band_tab[i]; j < band_tab[i + 1] - 1; j += 2) {
588  if (!get_bits1(&q->gb)) { // 0
589  chctx->skipFlagBits[i]++;
590  chctx->skipFlags[j] = 1;
591  chctx->skipFlags[j + 1] = 1;
592  chctx->skipFlagCount[i] += 2;
593  } else {
594  if (get_bits1(&q->gb)) { // 11
595  chctx->skipFlagBits[i] += 2;
596  chctx->skipFlags[j] = 0;
597  chctx->skipFlags[j + 1] = 1;
598  chctx->skipFlagCount[i]++;
599  } else {
600  chctx->skipFlagBits[i] += 3;
601  chctx->skipFlags[j + 1] = 0;
602  if (!get_bits1(&q->gb)) { // 100
603  chctx->skipFlags[j] = 1;
604  chctx->skipFlagCount[i]++;
605  } else { // 101
606  chctx->skipFlags[j] = 0;
607  }
608  }
609  }
610  }
611 
612  if (j < band_tab[i + 1]) {
613  chctx->skipFlagBits[i]++;
614  if ((chctx->skipFlags[j] = get_bits1(&q->gb)))
615  chctx->skipFlagCount[i]++;
616  }
617  }
618  }
619 }
620 
625  int summer)
626 {
627  float workT[32];
628  int corrected = 0;
629  int i, j;
630  float highest = 0;
631  int found_indx = 0;
632 
633  for (i = 0; i < BANDS; i++) {
634  workT[i] = (chctx->bitsBandT[i] == 6) ? -1.e20
635  : (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] - 0.415);
636  }
637 
638  while (corrected < summer) {
639  if (highest <= -1.e20)
640  break;
641 
642  highest = -1.e20;
643 
644  for (i = 0; i < BANDS; i++) {
645  if (workT[i] > highest) {
646  highest = workT[i];
647  found_indx = i;
648  }
649  }
650 
651  if (highest > -1.e20) {
652  workT[found_indx] -= 2.0;
653  if (++(chctx->bitsBandT[found_indx]) == 6)
654  workT[found_indx] = -1.e20;
655 
656  for (j = band_tab[found_indx]; j < band_tab[found_indx+1] && (corrected < summer); j++) {
657  if (!chctx->skipFlags[j] && (chctx->CWlengthT[j] < 6)) {
658  chctx->CWlengthT[j]++;
659  corrected++;
660  }
661  }
662  }
663  }
664 }
665 
666 static void imc_imdct256(IMCContext *q, IMCChannel *chctx, int channels)
667 {
668  int i;
669  float re, im;
670  float *dst1 = q->out_samples;
671  float *dst2 = q->out_samples + (COEFFS - 1);
672 
673  /* prerotation */
674  for (i = 0; i < COEFFS / 2; i++) {
675  q->samples[i].re = -(q->pre_coef1[i] * chctx->CWdecoded[COEFFS - 1 - i * 2]) -
676  (q->pre_coef2[i] * chctx->CWdecoded[i * 2]);
677  q->samples[i].im = (q->pre_coef2[i] * chctx->CWdecoded[COEFFS - 1 - i * 2]) -
678  (q->pre_coef1[i] * chctx->CWdecoded[i * 2]);
679  }
680 
681  /* FFT */
682  q->fft.fft_permute(&q->fft, q->samples);
683  q->fft.fft_calc(&q->fft, q->samples);
684 
685  /* postrotation, window and reorder */
686  for (i = 0; i < COEFFS / 2; i++) {
687  re = ( q->samples[i].re * q->post_cos[i]) + (-q->samples[i].im * q->post_sin[i]);
688  im = (-q->samples[i].im * q->post_cos[i]) - ( q->samples[i].re * q->post_sin[i]);
689  *dst1 = (q->mdct_sine_window[COEFFS - 1 - i * 2] * chctx->last_fft_im[i])
690  + (q->mdct_sine_window[i * 2] * re);
691  *dst2 = (q->mdct_sine_window[i * 2] * chctx->last_fft_im[i])
692  - (q->mdct_sine_window[COEFFS - 1 - i * 2] * re);
693  dst1 += 2;
694  dst2 -= 2;
695  chctx->last_fft_im[i] = im;
696  }
697 }
698 
700  int stream_format_code)
701 {
702  int i, j;
703  int middle_value, cw_len, max_size;
704  const float *quantizer;
705 
706  for (i = 0; i < BANDS; i++) {
707  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
708  chctx->CWdecoded[j] = 0;
709  cw_len = chctx->CWlengthT[j];
710 
711  if (cw_len <= 0 || chctx->skipFlags[j])
712  continue;
713 
714  max_size = 1 << cw_len;
715  middle_value = max_size >> 1;
716 
717  if (chctx->codewords[j] >= max_size || chctx->codewords[j] < 0)
718  return AVERROR_INVALIDDATA;
719 
720  if (cw_len >= 4) {
721  quantizer = imc_quantizer2[(stream_format_code & 2) >> 1];
722  if (chctx->codewords[j] >= middle_value)
723  chctx->CWdecoded[j] = quantizer[chctx->codewords[j] - 8] * chctx->flcoeffs6[i];
724  else
725  chctx->CWdecoded[j] = -quantizer[max_size - chctx->codewords[j] - 8 - 1] * chctx->flcoeffs6[i];
726  }else{
727  quantizer = imc_quantizer1[((stream_format_code & 2) >> 1) | (chctx->bandFlagsBuf[i] << 1)];
728  if (chctx->codewords[j] >= middle_value)
729  chctx->CWdecoded[j] = quantizer[chctx->codewords[j] - 1] * chctx->flcoeffs6[i];
730  else
731  chctx->CWdecoded[j] = -quantizer[max_size - 2 - chctx->codewords[j]] * chctx->flcoeffs6[i];
732  }
733  }
734  }
735  return 0;
736 }
737 
738 
739 static int imc_get_coeffs(IMCContext *q, IMCChannel *chctx)
740 {
741  int i, j, cw_len, cw;
742 
743  for (i = 0; i < BANDS; i++) {
744  if (!chctx->sumLenArr[i])
745  continue;
746  if (chctx->bandFlagsBuf[i] || chctx->bandWidthT[i]) {
747  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
748  cw_len = chctx->CWlengthT[j];
749  cw = 0;
750 
751  if (get_bits_count(&q->gb) + cw_len > 512) {
752  av_dlog(NULL, "Band %i coeff %i cw_len %i\n", i, j, cw_len);
753  return AVERROR_INVALIDDATA;
754  }
755 
756  if (cw_len && (!chctx->bandFlagsBuf[i] || !chctx->skipFlags[j]))
757  cw = get_bits(&q->gb, cw_len);
758 
759  chctx->codewords[j] = cw;
760  }
761  }
762  }
763  return 0;
764 }
765 
766 static int imc_decode_block(AVCodecContext *avctx, IMCContext *q, int ch)
767 {
768  int stream_format_code;
769  int imc_hdr, i, j, ret;
770  int flag;
771  int bits, summer;
772  int counter, bitscount;
773  IMCChannel *chctx = q->chctx + ch;
774 
775 
776  /* Check the frame header */
777  imc_hdr = get_bits(&q->gb, 9);
778  if (imc_hdr & 0x18) {
779  av_log(avctx, AV_LOG_ERROR, "frame header check failed!\n");
780  av_log(avctx, AV_LOG_ERROR, "got %X.\n", imc_hdr);
781  return AVERROR_INVALIDDATA;
782  }
783  stream_format_code = get_bits(&q->gb, 3);
784 
785  if (stream_format_code & 1) {
786  av_log_ask_for_sample(avctx, "Stream format %X is not supported\n",
787  stream_format_code);
788  return AVERROR_PATCHWELCOME;
789  }
790 
791  if (stream_format_code & 0x04)
792  chctx->decoder_reset = 1;
793 
794  if (chctx->decoder_reset) {
795  for (i = 0; i < BANDS; i++)
796  chctx->old_floor[i] = 1.0;
797  for (i = 0; i < COEFFS; i++)
798  chctx->CWdecoded[i] = 0;
799  chctx->decoder_reset = 0;
800  }
801 
802  flag = get_bits1(&q->gb);
803  imc_read_level_coeffs(q, stream_format_code, chctx->levlCoeffBuf);
804 
805  if (stream_format_code & 0x4)
807  chctx->flcoeffs1, chctx->flcoeffs2);
808  else
810  chctx->flcoeffs1, chctx->flcoeffs2);
811 
812  memcpy(chctx->old_floor, chctx->flcoeffs1, 32 * sizeof(float));
813 
814  counter = 0;
815  for (i = 0; i < BANDS; i++) {
816  if (chctx->levlCoeffBuf[i] == 16) {
817  chctx->bandWidthT[i] = 0;
818  counter++;
819  } else
820  chctx->bandWidthT[i] = band_tab[i + 1] - band_tab[i];
821  }
822  memset(chctx->bandFlagsBuf, 0, BANDS * sizeof(int));
823  for (i = 0; i < BANDS - 1; i++) {
824  if (chctx->bandWidthT[i])
825  chctx->bandFlagsBuf[i] = get_bits1(&q->gb);
826  }
827 
828  imc_calculate_coeffs(q, chctx->flcoeffs1, chctx->flcoeffs2, chctx->bandWidthT, chctx->flcoeffs3, chctx->flcoeffs5);
829 
830  bitscount = 0;
831  /* first 4 bands will be assigned 5 bits per coefficient */
832  if (stream_format_code & 0x2) {
833  bitscount += 15;
834 
835  chctx->bitsBandT[0] = 5;
836  chctx->CWlengthT[0] = 5;
837  chctx->CWlengthT[1] = 5;
838  chctx->CWlengthT[2] = 5;
839  for (i = 1; i < 4; i++) {
840  bits = (chctx->levlCoeffBuf[i] == 16) ? 0 : 5;
841  chctx->bitsBandT[i] = bits;
842  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
843  chctx->CWlengthT[j] = bits;
844  bitscount += bits;
845  }
846  }
847  }
848  if (avctx->codec_id == AV_CODEC_ID_IAC) {
849  bitscount += !!chctx->bandWidthT[BANDS - 1];
850  if (!(stream_format_code & 0x2))
851  bitscount += 16;
852  }
853 
854  if ((ret = bit_allocation(q, chctx, stream_format_code,
855  512 - bitscount - get_bits_count(&q->gb),
856  flag)) < 0) {
857  av_log(avctx, AV_LOG_ERROR, "Bit allocations failed\n");
858  chctx->decoder_reset = 1;
859  return ret;
860  }
861 
862  for (i = 0; i < BANDS; i++) {
863  chctx->sumLenArr[i] = 0;
864  chctx->skipFlagRaw[i] = 0;
865  for (j = band_tab[i]; j < band_tab[i + 1]; j++)
866  chctx->sumLenArr[i] += chctx->CWlengthT[j];
867  if (chctx->bandFlagsBuf[i])
868  if ((((band_tab[i + 1] - band_tab[i]) * 1.5) > chctx->sumLenArr[i]) && (chctx->sumLenArr[i] > 0))
869  chctx->skipFlagRaw[i] = 1;
870  }
871 
872  imc_get_skip_coeff(q, chctx);
873 
874  for (i = 0; i < BANDS; i++) {
875  chctx->flcoeffs6[i] = chctx->flcoeffs1[i];
876  /* band has flag set and at least one coded coefficient */
877  if (chctx->bandFlagsBuf[i] && (band_tab[i + 1] - band_tab[i]) != chctx->skipFlagCount[i]) {
878  chctx->flcoeffs6[i] *= q->sqrt_tab[ band_tab[i + 1] - band_tab[i]] /
879  q->sqrt_tab[(band_tab[i + 1] - band_tab[i] - chctx->skipFlagCount[i])];
880  }
881  }
882 
883  /* calculate bits left, bits needed and adjust bit allocation */
884  bits = summer = 0;
885 
886  for (i = 0; i < BANDS; i++) {
887  if (chctx->bandFlagsBuf[i]) {
888  for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
889  if (chctx->skipFlags[j]) {
890  summer += chctx->CWlengthT[j];
891  chctx->CWlengthT[j] = 0;
892  }
893  }
894  bits += chctx->skipFlagBits[i];
895  summer -= chctx->skipFlagBits[i];
896  }
897  }
898  imc_adjust_bit_allocation(q, chctx, summer);
899 
900  for (i = 0; i < BANDS; i++) {
901  chctx->sumLenArr[i] = 0;
902 
903  for (j = band_tab[i]; j < band_tab[i + 1]; j++)
904  if (!chctx->skipFlags[j])
905  chctx->sumLenArr[i] += chctx->CWlengthT[j];
906  }
907 
908  memset(chctx->codewords, 0, sizeof(chctx->codewords));
909 
910  if (imc_get_coeffs(q, chctx) < 0) {
911  av_log(avctx, AV_LOG_ERROR, "Read coefficients failed\n");
912  chctx->decoder_reset = 1;
913  return AVERROR_INVALIDDATA;
914  }
915 
916  if (inverse_quant_coeff(q, chctx, stream_format_code) < 0) {
917  av_log(avctx, AV_LOG_ERROR, "Inverse quantization of coefficients failed\n");
918  chctx->decoder_reset = 1;
919  return AVERROR_INVALIDDATA;
920  }
921 
922  memset(chctx->skipFlags, 0, sizeof(chctx->skipFlags));
923 
924  imc_imdct256(q, chctx, avctx->channels);
925 
926  return 0;
927 }
928 
929 static int imc_decode_frame(AVCodecContext *avctx, void *data,
930  int *got_frame_ptr, AVPacket *avpkt)
931 {
932  const uint8_t *buf = avpkt->data;
933  int buf_size = avpkt->size;
934  int ret, i;
935 
936  IMCContext *q = avctx->priv_data;
937 
938  LOCAL_ALIGNED_16(uint16_t, buf16, [IMC_BLOCK_SIZE / 2]);
939 
940  if (buf_size < IMC_BLOCK_SIZE * avctx->channels) {
941  av_log(avctx, AV_LOG_ERROR, "frame too small!\n");
942  return AVERROR_INVALIDDATA;
943  }
944 
945  /* get output buffer */
946  q->frame.nb_samples = COEFFS;
947  if ((ret = ff_get_buffer(avctx, &q->frame)) < 0) {
948  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
949  return ret;
950  }
951 
952  for (i = 0; i < avctx->channels; i++) {
953  q->out_samples = (float *)q->frame.extended_data[i];
954 
955  q->dsp.bswap16_buf(buf16, (const uint16_t*)buf, IMC_BLOCK_SIZE / 2);
956 
957  init_get_bits(&q->gb, (const uint8_t*)buf16, IMC_BLOCK_SIZE * 8);
958 
959  buf += IMC_BLOCK_SIZE;
960 
961  if ((ret = imc_decode_block(avctx, q, i)) < 0)
962  return ret;
963  }
964 
965  if (avctx->channels == 2) {
966  q->dsp.butterflies_float((float *)q->frame.extended_data[0],
967  (float *)q->frame.extended_data[1], COEFFS);
968  }
969 
970  *got_frame_ptr = 1;
971  *(AVFrame *)data = q->frame;
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 
988  .name = "imc",
989  .type = AVMEDIA_TYPE_AUDIO,
990  .id = AV_CODEC_ID_IMC,
991  .priv_data_size = sizeof(IMCContext),
995  .capabilities = CODEC_CAP_DR1,
996  .long_name = NULL_IF_CONFIG_SMALL("IMC (Intel Music Coder)"),
997  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
999 };
1000 
1002  .name = "iac",
1003  .type = AVMEDIA_TYPE_AUDIO,
1004  .id = AV_CODEC_ID_IAC,
1005  .priv_data_size = sizeof(IMCContext),
1006  .init = imc_decode_init,
1009  .capabilities = CODEC_CAP_DR1,
1010  .long_name = NULL_IF_CONFIG_SMALL("IAC (Indeo Audio Coder)"),
1011  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1013 };
int skipFlags[COEFFS]
skip coefficient decoding or not
Definition: imc.c:72
AVCodec ff_imc_decoder
Definition: imc.c:987
struct IMCChannel IMCChannel
float flcoeffs3[BANDS]
Definition: imc.c:57
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2656
static int16_t * samples
float flcoeffs1[BANDS]
Definition: imc.c:55
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
int codewords[COEFFS]
raw codewords read from bitstream
Definition: imc.c:73
float post_sin[COEFFS]
Definition: imc.c:89
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
int skipFlagRaw[BANDS]
skip flags are stored in raw form or not
Definition: imc.c:69
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2725
static const int vlc_offsets[17]
Definition: imc.c:110
int size
Definition: avcodec.h:916
float mdct_sine_window[COEFFS]
MDCT tables.
Definition: imc.c:87
void(* fft_permute)(struct FFTContext *s, FFTComplex *z)
Do the permutation needed BEFORE calling fft_calc().
Definition: fft.h:75
static const uint8_t imc_huffman_lens[4][4][18]
Definition: imcdata.h:115
int skipFlagCount[BANDS]
skipped coeffients per band
Definition: imc.c:71
static const float imc_weights2[31]
Definition: imcdata.h:53
FFTSample re
Definition: avfft.h:38
int8_t cyclTab2[32]
Definition: imc.c:102
#define VLC_TYPE
Definition: get_bits.h:61
AVFrame frame
Definition: imc.c:81
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)
#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:58
AVCodec.
Definition: avcodec.h:2960
float sqrt_tab[30]
Definition: imc.c:94
float old_floor[BANDS]
Definition: imc.c:54
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
uint8_t bits
Definition: crc.c:31
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2112
uint8_t
float pre_coef1[COEFFS]
Definition: imc.c:90
float CWdecoded[COEFFS]
Definition: imc.c:61
int bandFlagsBuf[BANDS]
flags for each band
Definition: imc.c:67
static av_cold int imc_decode_close(AVCodecContext *avctx)
Definition: imc.c:977
static const int8_t cyclTab[32]
Definition: imcdata.h:36
const char data[16]
Definition: mxf.c:66
uint8_t * data
Definition: avcodec.h:915
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:192
static const float imc_weights1[31]
Definition: imcdata.h:47
bitstream reader API header.
float weights2[31]
Definition: imc.c:103
static void imc_get_skip_coeff(IMCContext *q, IMCChannel *chctx)
Definition: imc.c:568
#define LOCAL_ALIGNED_16(t, v,...)
Definition: dsputil.h:602
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
float, planar
Definition: samplefmt.h:60
float pre_coef2[COEFFS]
Definition: imc.c:91
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
Definition: dsputil.h:344
static const float *const imc_exp_tab2
Definition: imcdata.h:97
void av_log_ask_for_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message asking for a sample.
float weights1[31]
Definition: imc.c:103
#define VLC_TABLES_SIZE
Definition: imc.c:108
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
static void imc_imdct256(IMCContext *q, IMCChannel *chctx, int channels)
Definition: imc.c:666
#define t1
Definition: regdef.h:29
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
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:2967
GetBitContext gb
Definition: imc.c:95
Definition: get_bits.h:63
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2165
#define IMC_BLOCK_SIZE
Definition: imc.c:48
IMCChannel chctx[2]
Definition: imc.c:83
static const int8_t cyclTab2[32]
Definition: imcdata.h:42
DSPContext dsp
Definition: imc.c:97
static int imc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: imc.c:929
static void imc_decode_level_coefficients2(IMCContext *q, int *levlCoeffBuf, float *old_floor, float *flcoeffs1, float *flcoeffs2)
Definition: imc.c:374
#define COEFFS
Definition: imc.c:51
Definition: fft.h:62
audio channel layout utility functions
static const uint16_t band_tab[33]
Definition: imcdata.h:29
FFTContext fft
Definition: imc.c:98
#define ff_fft_init
Definition: fft.h:126
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
Definition: utils.c:464
static int imc_get_coeffs(IMCContext *q, IMCChannel *chctx)
Definition: imc.c:739
float flcoeffs5[BANDS]
Definition: imc.c:59
int bitsBandT[BANDS]
how many bits per codeword in band
Definition: imc.c:64
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:515
Definition: imc.c:80
#define INIT_VLC_USE_NEW_STATIC
Definition: get_bits.h:433
float last_fft_im[COEFFS]
Definition: imc.c:75
float post_cos[COEFFS]
Definition: imc.c:88
int bits
Definition: get_bits.h:64
void ff_sine_window_init(float *window, int n)
Generate a sine window.
int table_allocated
Definition: get_bits.h:66
NULL
Definition: eval.c:52
float flcoeffs6[BANDS]
Definition: imc.c:60
static const float xTab[14]
Definition: imcdata.h:84
FFTComplex samples[COEFFS/2]
Definition: imc.c:99
external API header
float im
Definition: fft-test.c:64
int8_t cyclTab[32]
Definition: imc.c:102
enum AVCodecID codec_id
Definition: avcodec.h:1350
static int inverse_quant_coeff(IMCContext *q, IMCChannel *chctx, int stream_format_code)
Definition: imc.c:699
AV_SAMPLE_FMT_NONE
Definition: avconv_filter.c:63
int sample_rate
samples per second
Definition: avcodec.h:2104
Definition: imc.c:53
main external API structure.
Definition: avcodec.h:1339
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:326
void(* butterflies_float)(float *restrict v1, float *restrict v2, int len)
Calculate the sum and difference of two vectors of floats.
Definition: dsputil.h:374
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:418
static double freq2bark(double freq)
Definition: imc.c:117
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Definition: utils.c:604
int bandWidthT[BANDS]
codewords per band
Definition: imc.c:63
float * out_samples
Definition: imc.c:100
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:372
static VLC huffman_vlc[4][4]
Definition: imc.c:106
static VLC_TYPE vlc_tables[VLC_TABLES_SIZE][2]
Definition: imc.c:115
static const float imc_quantizer1[4][8]
Definition: imcdata.h:59
#define BANDS
Definition: imc.c:50
static const uint16_t scale[4]
uint8_t level
Definition: svq3.c:125
static av_cold void iac_generate_tabs(IMCContext *q, int sampling_rate)
Definition: imc.c:122
int levlCoeffBuf[BANDS]
Definition: imc.c:66
int decoder_reset
Definition: imc.c:77
common internal api header.
FFTSample im
Definition: avfft.h:38
static int imc_decode_block(AVCodecContext *avctx, IMCContext *q, int ch)
Definition: imc.c:766
#define log2f(x)
Definition: libm.h:116
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:49
#define ff_fft_end
Definition: fft.h:127
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
void(* fft_calc)(struct FFTContext *s, FFTComplex *z)
Do a complex FFT with the parameters defined in ff_fft_init().
Definition: fft.h:80
DSP utils.
static const uint8_t imc_cb_select[4][32]
Definition: imcdata.h:100
void * priv_data
Definition: avcodec.h:1382
float re
Definition: fft-test.c:64
int channels
number of audio channels
Definition: avcodec.h:2105
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
static void imc_adjust_bit_allocation(IMCContext *q, IMCChannel *chctx, int summer)
Increase highest' band coefficient sizes as some bits won't be used.
Definition: imc.c:624
static const float imc_quantizer2[2][56]
Definition: imcdata.h:66
int sumLenArr[BANDS]
bits for all coeffs in band
Definition: imc.c:68
static const uint8_t imc_huffman_sizes[4]
Definition: imcdata.h:111
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: avcodec.h:1028
#define AV_CH_LAYOUT_MONO
This structure stores compressed data.
Definition: avcodec.h:898
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:70
static av_cold int imc_decode_init(AVCodecContext *avctx)
Definition: imc.c:173
AVCodec ff_iac_decoder
Definition: imc.c:1001
int nb_samples
number of audio samples (per channel) described by this frame
Definition: avcodec.h:1042
static const float imc_exp_tab[32]
Definition: imcdata.h:87
float flcoeffs2[BANDS]
Definition: imc.c:56
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
DSPContext.
Definition: dsputil.h:194
int CWlengthT[COEFFS]
how many bits in each codeword
Definition: imc.c:65
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)