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