ac3enc: Restructure DEBUG ifdefs to avoid unused function parameter warnings
[libav.git] / libavcodec / imc.c
CommitLineData
84ed36da
KS
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 *
2912e87a 7 * This file is part of Libav.
84ed36da 8 *
2912e87a 9 * Libav is free software; you can redistribute it and/or
84ed36da
KS
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 *
2912e87a 14 * Libav is distributed in the hope that it will be useful,
84ed36da
KS
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
2912e87a 20 * License along with Libav; if not, write to the Free Software
84ed36da 21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
84ed36da
KS
22 */
23
24/**
ba87f080
DB
25 * @file
26 * IMC - Intel Music Coder
84ed36da 27 * A mdct based codec using a 256 points large transform
f05b69a7 28 * divided into 32 bands with some mix of scale factors.
84ed36da 29 * Only mono is supported.
84ed36da
KS
30 */
31
32
33#include <math.h>
34#include <stddef.h>
35#include <stdio.h>
36
a903f8f0 37#include "libavutil/channel_layout.h"
5959bfac 38#include "libavutil/float_dsp.h"
218aefce 39#include "libavutil/internal.h"
84ed36da 40#include "avcodec.h"
c67b449b 41#include "bswapdsp.h"
9106a698 42#include "get_bits.h"
1429224b 43#include "fft.h"
594d4d5d 44#include "internal.h"
4538729a 45#include "sinewin.h"
84ed36da
KS
46
47#include "imcdata.h"
48
0fe04628 49#define IMC_BLOCK_SIZE 64
84ed36da
KS
50#define IMC_FRAME_ID 0x21
51#define BANDS 32
52#define COEFFS 256
53
c45e2da6 54typedef struct IMCChannel {
84ed36da
KS
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
84ed36da
KS
64 int bandWidthT[BANDS]; ///< codewords per band
65 int bitsBandT[BANDS]; ///< how many bits per codeword in band
66 int CWlengthT[COEFFS]; ///< how many bits in each codeword
67 int levlCoeffBuf[BANDS];
68 int bandFlagsBuf[BANDS]; ///< flags for each band
69 int sumLenArr[BANDS]; ///< bits for all coeffs in band
70 int skipFlagRaw[BANDS]; ///< skip flags are stored in raw form or not
71 int skipFlagBits[BANDS]; ///< bits used to code skip flags
41ed7ab4 72 int skipFlagCount[BANDS]; ///< skipped coefficients per band
84ed36da
KS
73 int skipFlags[COEFFS]; ///< skip coefficient decoding or not
74 int codewords[COEFFS]; ///< raw codewords read from bitstream
c45e2da6
KS
75
76 float last_fft_im[COEFFS];
77
78 int decoder_reset;
79} IMCChannel;
80
7f9f771e 81typedef struct IMCContext {
c6061443 82 IMCChannel chctx[2];
c45e2da6
KS
83
84 /** MDCT tables */
85 //@{
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];
91 //@}
92
84ed36da
KS
93 float sqrt_tab[30];
94 GetBitContext gb;
84ed36da 95
c67b449b 96 BswapDSPContext bdsp;
5959bfac 97 AVFloatDSPContext fdsp;
84ed36da 98 FFTContext fft;
d073f122 99 DECLARE_ALIGNED(32, FFTComplex, samples)[COEFFS / 2];
66b84e4a 100 float *out_samples;
c6061443 101
4eb4bb3a
KS
102 int coef0_pos;
103
c6061443
KS
104 int8_t cyclTab[32], cyclTab2[32];
105 float weights1[31], weights2[31];
84ed36da
KS
106} IMCContext;
107
09fec2b9
RD
108static VLC huffman_vlc[4][4];
109
110#define VLC_TABLES_SIZE 9512
111
112static const int vlc_offsets[17] = {
113 0, 640, 1156, 1732, 2308, 2852, 3396, 3924,
d073f122
KS
114 4452, 5220, 5860, 6628, 7268, 7908, 8424, 8936, VLC_TABLES_SIZE
115};
09fec2b9
RD
116
117static VLC_TYPE vlc_tables[VLC_TABLES_SIZE][2];
84ed36da 118
cac4760b
KS
119static 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
124static 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
d073f122 175static av_cold int imc_decode_init(AVCodecContext *avctx)
84ed36da 176{
95fee70d 177 int i, j, ret;
84ed36da
KS
178 IMCContext *q = avctx->priv_data;
179 double r1, r2;
180
1c7a0161
JR
181 if (avctx->codec_id == AV_CODEC_ID_IMC)
182 avctx->channels = 1;
183
184 if (avctx->channels > 2) {
6d97484d 185 avpriv_request_sample(avctx, "Number of channels > 2");
7b7f47e7
JR
186 return AVERROR_PATCHWELCOME;
187 }
188
c45e2da6
KS
189 for (j = 0; j < avctx->channels; j++) {
190 q->chctx[j].decoder_reset = 1;
84ed36da 191
c45e2da6
KS
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 }
84ed36da
KS
198
199 /* Build mdct window, a simple sine window normalized with sqrt(2) */
9146e4d6 200 ff_sine_window_init(q->mdct_sine_window, COEFFS);
d073f122 201 for (i = 0; i < COEFFS; i++)
9146e4d6 202 q->mdct_sine_window[i] *= sqrt(2.0);
d073f122 203 for (i = 0; i < COEFFS / 2; i++) {
66b84e4a
VS
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);
84ed36da
KS
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
d073f122 210 if (i & 0x1) {
84ed36da
KS
211 q->pre_coef1[i] = (r1 + r2) * sqrt(2.0);
212 q->pre_coef2[i] = -(r1 - r2) * sqrt(2.0);
d073f122 213 } else {
84ed36da
KS
214 q->pre_coef1[i] = -(r1 + r2) * sqrt(2.0);
215 q->pre_coef2[i] = (r1 - r2) * sqrt(2.0);
216 }
84ed36da 217 }
84ed36da
KS
218
219 /* Generate a square root table */
220
d073f122 221 for (i = 0; i < 30; i++)
84ed36da 222 q->sqrt_tab[i] = sqrt(i);
84ed36da
KS
223
224 /* initialize the VLC tables */
d073f122
KS
225 for (i = 0; i < 4 ; i++) {
226 for (j = 0; j < 4; j++) {
b836fb00 227 huffman_vlc[i][j].table = &vlc_tables[vlc_offsets[i * 4 + j]];
09fec2b9
RD
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],
84ed36da 230 imc_huffman_lens[i][j], 1, 1,
09fec2b9 231 imc_huffman_bits[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
84ed36da
KS
232 }
233 }
84ed36da 234
36ef5369 235 if (avctx->codec_id == AV_CODEC_ID_IAC) {
cac4760b 236 iac_generate_tabs(q, avctx->sample_rate);
c6061443 237 } else {
cac4760b
KS
238 memcpy(q->cyclTab, cyclTab, sizeof(cyclTab));
239 memcpy(q->cyclTab2, cyclTab2, sizeof(cyclTab2));
c6061443
KS
240 memcpy(q->weights1, imc_weights1, sizeof(imc_weights1));
241 memcpy(q->weights2, imc_weights2, sizeof(imc_weights2));
242 }
243
95fee70d
JR
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 }
c67b449b 248 ff_bswapdsp_init(&q->bdsp);
7c6eb0a1 249 avpriv_float_dsp_init(&q->fdsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
3fca0d72 250 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
c45e2da6
KS
251 avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO
252 : AV_CH_LAYOUT_STEREO;
0eea2129 253
84ed36da
KS
254 return 0;
255}
256
d073f122
KS
257static void imc_calculate_coeffs(IMCContext *q, float *flcoeffs1,
258 float *flcoeffs2, int *bandWidthT,
259 float *flcoeffs3, float *flcoeffs5)
84ed36da
KS
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
d073f122 268 for (i = 0; i < BANDS; i++) {
84ed36da 269 flcoeffs5[i] = workT2[i] = 0.0;
d073f122 270 if (bandWidthT[i]) {
84ed36da
KS
271 workT1[i] = flcoeffs1[i] * flcoeffs1[i];
272 flcoeffs3[i] = 2.0 * flcoeffs2[i];
273 } else {
d073f122 274 workT1[i] = 0.0;
84ed36da
KS
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
d073f122 282 for (i = 0; i < BANDS; i++) {
c6061443 283 for (cnt2 = i; cnt2 < q->cyclTab[i]; cnt2++)
84ed36da 284 flcoeffs5[cnt2] = flcoeffs5[cnt2] + workT3[i];
d073f122 285 workT2[cnt2 - 1] = workT2[cnt2 - 1] + workT3[i];
84ed36da
KS
286 }
287
d073f122 288 for (i = 1; i < BANDS; i++) {
c6061443 289 accum = (workT2[i - 1] + accum) * q->weights1[i - 1];
84ed36da
KS
290 flcoeffs5[i] += accum;
291 }
292
d073f122 293 for (i = 0; i < BANDS; i++)
84ed36da
KS
294 workT2[i] = 0.0;
295
d073f122 296 for (i = 0; i < BANDS; i++) {
c6061443 297 for (cnt2 = i - 1; cnt2 > q->cyclTab2[i]; cnt2--)
84ed36da
KS
298 flcoeffs5[cnt2] += workT3[i];
299 workT2[cnt2+1] += workT3[i];
300 }
301
302 accum = 0.0;
303
d073f122 304 for (i = BANDS-2; i >= 0; i--) {
c6061443 305 accum = (workT2[i+1] + accum) * q->weights2[i];
84ed36da 306 flcoeffs5[i] += accum;
d073f122 307 // there is missing code here, but it seems to never be triggered
84ed36da
KS
308 }
309}
310
311
d073f122
KS
312static void imc_read_level_coeffs(IMCContext *q, int stream_format_code,
313 int *levlCoeffs)
84ed36da
KS
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;
09fec2b9
RD
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];
84ed36da
KS
326 cb_sel = imc_cb_select[s];
327
d073f122 328 if (stream_format_code & 4)
84ed36da 329 start = 1;
d073f122 330 if (start)
84ed36da 331 levlCoeffs[0] = get_bits(&q->gb, 7);
d073f122
KS
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)
84ed36da
KS
336 levlCoeffs[i] += get_bits(&q->gb, 4);
337 }
338}
339
4eb4bb3a
KS
340static 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
d073f122
KS
351static void imc_decode_level_coefficients(IMCContext *q, int *levlCoeffBuf,
352 float *flcoeffs1, float *flcoeffs2)
84ed36da
KS
353{
354 int i, level;
355 float tmp, tmp2;
d073f122 356 // maybe some frequency division thingy
84ed36da 357
521fe1d2 358 flcoeffs1[0] = 20000.0 / pow (2, levlCoeffBuf[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
d752509b 359 flcoeffs2[0] = log2f(flcoeffs1[0]);
d073f122 360 tmp = flcoeffs1[0];
84ed36da
KS
361 tmp2 = flcoeffs2[0];
362
d073f122 363 for (i = 1; i < BANDS; i++) {
84ed36da
KS
364 level = levlCoeffBuf[i];
365 if (level == 16) {
366 flcoeffs1[i] = 1.0;
367 flcoeffs2[i] = 0.0;
368 } else {
369 if (level < 17)
d073f122 370 level -= 7;
84ed36da 371 else if (level <= 24)
d073f122 372 level -= 32;
84ed36da 373 else
d073f122 374 level -= 16;
84ed36da
KS
375
376 tmp *= imc_exp_tab[15 + level];
521fe1d2 377 tmp2 += 0.83048 * level; // 0.83048 = log2(10) * 0.25
84ed36da
KS
378 flcoeffs1[i] = tmp;
379 flcoeffs2[i] = tmp2;
380 }
381 }
382}
383
384
d073f122
KS
385static void imc_decode_level_coefficients2(IMCContext *q, int *levlCoeffBuf,
386 float *old_floor, float *flcoeffs1,
387 float *flcoeffs2)
388{
84ed36da 389 int i;
d073f122
KS
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++) {
84ed36da 395 flcoeffs1[i] = 0;
d073f122 396 if (levlCoeffBuf[i] < 16) {
84ed36da 397 flcoeffs1[i] = imc_exp_tab2[levlCoeffBuf[i]] * old_floor[i];
d073f122 398 flcoeffs2[i] = (levlCoeffBuf[i] - 7) * 0.83048 + flcoeffs2[i]; // 0.83048 = log2(10) * 0.25
84ed36da
KS
399 } else {
400 flcoeffs1[i] = old_floor[i];
401 }
402 }
403}
404
4eb4bb3a
KS
405static void imc_decode_level_coefficients_raw(IMCContext *q, int *levlCoeffBuf,
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
1410eeb6 413 flcoeffs2[pos] = log2f(flcoeffs1[pos]);
4eb4bb3a
KS
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
84ed36da
KS
427/**
428 * Perform bit allocation depending on bits available
429 */
c45e2da6
KS
430static int bit_allocation(IMCContext *q, IMCChannel *chctx,
431 int stream_format_code, int freebits, int flag)
d073f122 432{
84ed36da
KS
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
d073f122 449 for (i = 0; i < BANDS; i++)
c45e2da6 450 highest = FFMAX(highest, chctx->flcoeffs1[i]);
84ed36da 451
d073f122 452 for (i = 0; i < BANDS - 1; i++)
d752509b 453 chctx->flcoeffs4[i] = chctx->flcoeffs3[i] - log2f(chctx->flcoeffs5[i]);
c45e2da6 454 chctx->flcoeffs4[BANDS - 1] = limit;
84ed36da
KS
455
456 highest = highest * 0.25;
457
d073f122 458 for (i = 0; i < BANDS; i++) {
84ed36da 459 indx = -1;
c45e2da6 460 if ((band_tab[i + 1] - band_tab[i]) == chctx->bandWidthT[i])
84ed36da
KS
461 indx = 0;
462
c45e2da6 463 if ((band_tab[i + 1] - band_tab[i]) > chctx->bandWidthT[i])
84ed36da
KS
464 indx = 1;
465
c45e2da6 466 if (((band_tab[i + 1] - band_tab[i]) / 2) >= chctx->bandWidthT[i])
84ed36da
KS
467 indx = 2;
468
469 if (indx == -1)
08e5cd38 470 return AVERROR_INVALIDDATA;
84ed36da 471
c45e2da6 472 chctx->flcoeffs4[i] += xTab[(indx * 2 + (chctx->flcoeffs1[i] < highest)) * 2 + flag];
84ed36da
KS
473 }
474
475 if (stream_format_code & 0x2) {
c45e2da6
KS
476 chctx->flcoeffs4[0] = limit;
477 chctx->flcoeffs4[1] = limit;
478 chctx->flcoeffs4[2] = limit;
479 chctx->flcoeffs4[3] = limit;
84ed36da
KS
480 }
481
d073f122 482 for (i = (stream_format_code & 0x2) ? 4 : 0; i < BANDS - 1; i++) {
c45e2da6
KS
483 iacc += chctx->bandWidthT[i];
484 summa += chctx->bandWidthT[i] * chctx->flcoeffs4[i];
84ed36da 485 }
bbf6a4aa
LB
486
487 if (!iacc)
488 return AVERROR_INVALIDDATA;
489
c45e2da6 490 chctx->bandWidthT[BANDS - 1] = 0;
84ed36da
KS
491 summa = (summa * 0.5 - freebits) / iacc;
492
493
d073f122 494 for (i = 0; i < BANDS / 2; i++) {
84ed36da 495 rres = summer - freebits;
d073f122
KS
496 if ((rres >= -8) && (rres <= 8))
497 break;
84ed36da
KS
498
499 summer = 0;
d073f122 500 iacc = 0;
84ed36da 501
d073f122 502 for (j = (stream_format_code & 0x2) ? 4 : 0; j < BANDS; j++) {
c45e2da6 503 cwlen = av_clipf(((chctx->flcoeffs4[j] * 0.5) - summa + 0.5), 0, 6);
84ed36da 504
c45e2da6
KS
505 chctx->bitsBandT[j] = cwlen;
506 summer += chctx->bandWidthT[j] * cwlen;
84ed36da
KS
507
508 if (cwlen > 0)
c45e2da6 509 iacc += chctx->bandWidthT[j];
84ed36da
KS
510 }
511
512 flg = t2;
513 t2 = 1;
514 if (freebits < summer)
515 t2 = -1;
516 if (i == 0)
517 flg = t2;
d073f122 518 if (flg != t2)
84ed36da
KS
519 t1++;
520
521 summa = (float)(summer - freebits) / ((t1 + 1) * iacc) + summa;
522 }
523
d073f122
KS
524 for (i = (stream_format_code & 0x2) ? 4 : 0; i < BANDS; i++) {
525 for (j = band_tab[i]; j < band_tab[i + 1]; j++)
c45e2da6 526 chctx->CWlengthT[j] = chctx->bitsBandT[i];
84ed36da
KS
527 }
528
529 if (freebits > summer) {
d073f122 530 for (i = 0; i < BANDS; i++) {
c45e2da6
KS
531 workT[i] = (chctx->bitsBandT[i] == 6) ? -1.e20
532 : (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] - 0.415);
84ed36da
KS
533 }
534
535 highest = 0.0;
536
d073f122 537 do {
84ed36da
KS
538 if (highest <= -1.e20)
539 break;
540
541 found_indx = 0;
542 highest = -1.e20;
543
d073f122 544 for (i = 0; i < BANDS; i++) {
84ed36da
KS
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;
c45e2da6 553 if (++chctx->bitsBandT[found_indx] == 6)
84ed36da
KS
554 workT[found_indx] = -1.e20;
555
d073f122 556 for (j = band_tab[found_indx]; j < band_tab[found_indx + 1] && (freebits > summer); j++) {
c45e2da6 557 chctx->CWlengthT[j]++;
84ed36da
KS
558 summer++;
559 }
560 }
d073f122 561 } while (freebits > summer);
84ed36da
KS
562 }
563 if (freebits < summer) {
d073f122 564 for (i = 0; i < BANDS; i++) {
c45e2da6 565 workT[i] = chctx->bitsBandT[i] ? (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] + 1.585)
d073f122 566 : 1.e20;
84ed36da
KS
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 }
d073f122
KS
574 while (freebits < summer) {
575 lowest = 1.e10;
84ed36da 576 low_indx = 0;
d073f122 577 for (i = 0; i < BANDS; i++) {
84ed36da 578 if (workT[i] < lowest) {
d073f122 579 lowest = workT[i];
84ed36da
KS
580 low_indx = i;
581 }
582 }
d073f122
KS
583 // if (lowest >= 1.e10)
584 // break;
84ed36da
KS
585 workT[low_indx] = lowest + 2.0;
586
c45e2da6 587 if (!--chctx->bitsBandT[low_indx])
84ed36da
KS
588 workT[low_indx] = 1.e20;
589
d073f122 590 for (j = band_tab[low_indx]; j < band_tab[low_indx+1] && (freebits < summer); j++) {
c45e2da6
KS
591 if (chctx->CWlengthT[j] > 0) {
592 chctx->CWlengthT[j]--;
84ed36da
KS
593 summer--;
594 }
595 }
596 }
597 }
598 return 0;
599}
600
c45e2da6 601static void imc_get_skip_coeff(IMCContext *q, IMCChannel *chctx)
d073f122 602{
84ed36da
KS
603 int i, j;
604
c45e2da6
KS
605 memset(chctx->skipFlagBits, 0, sizeof(chctx->skipFlagBits));
606 memset(chctx->skipFlagCount, 0, sizeof(chctx->skipFlagCount));
d073f122 607 for (i = 0; i < BANDS; i++) {
c45e2da6 608 if (!chctx->bandFlagsBuf[i] || !chctx->bandWidthT[i])
84ed36da
KS
609 continue;
610
c45e2da6
KS
611 if (!chctx->skipFlagRaw[i]) {
612 chctx->skipFlagBits[i] = band_tab[i + 1] - band_tab[i];
84ed36da 613
d073f122 614 for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
c45e2da6
KS
615 chctx->skipFlags[j] = get_bits1(&q->gb);
616 if (chctx->skipFlags[j])
617 chctx->skipFlagCount[i]++;
84ed36da
KS
618 }
619 } else {
d073f122
KS
620 for (j = band_tab[i]; j < band_tab[i + 1] - 1; j += 2) {
621 if (!get_bits1(&q->gb)) { // 0
c45e2da6
KS
622 chctx->skipFlagBits[i]++;
623 chctx->skipFlags[j] = 1;
624 chctx->skipFlags[j + 1] = 1;
625 chctx->skipFlagCount[i] += 2;
d073f122
KS
626 } else {
627 if (get_bits1(&q->gb)) { // 11
c45e2da6
KS
628 chctx->skipFlagBits[i] += 2;
629 chctx->skipFlags[j] = 0;
630 chctx->skipFlags[j + 1] = 1;
631 chctx->skipFlagCount[i]++;
d073f122 632 } else {
c45e2da6
KS
633 chctx->skipFlagBits[i] += 3;
634 chctx->skipFlags[j + 1] = 0;
d073f122 635 if (!get_bits1(&q->gb)) { // 100
c45e2da6
KS
636 chctx->skipFlags[j] = 1;
637 chctx->skipFlagCount[i]++;
d073f122 638 } else { // 101
c45e2da6 639 chctx->skipFlags[j] = 0;
84ed36da
KS
640 }
641 }
642 }
643 }
644
d073f122 645 if (j < band_tab[i + 1]) {
c45e2da6
KS
646 chctx->skipFlagBits[i]++;
647 if ((chctx->skipFlags[j] = get_bits1(&q->gb)))
648 chctx->skipFlagCount[i]++;
84ed36da
KS
649 }
650 }
651 }
652}
653
654/**
655 * Increase highest' band coefficient sizes as some bits won't be used
656 */
c45e2da6
KS
657static void imc_adjust_bit_allocation(IMCContext *q, IMCChannel *chctx,
658 int summer)
d073f122 659{
84ed36da
KS
660 float workT[32];
661 int corrected = 0;
662 int i, j;
d073f122
KS
663 float highest = 0;
664 int found_indx = 0;
84ed36da 665
d073f122 666 for (i = 0; i < BANDS; i++) {
c45e2da6
KS
667 workT[i] = (chctx->bitsBandT[i] == 6) ? -1.e20
668 : (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] - 0.415);
84ed36da
KS
669 }
670
671 while (corrected < summer) {
d073f122 672 if (highest <= -1.e20)
84ed36da
KS
673 break;
674
675 highest = -1.e20;
676
d073f122 677 for (i = 0; i < BANDS; i++) {
84ed36da
KS
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;
c45e2da6 686 if (++(chctx->bitsBandT[found_indx]) == 6)
84ed36da
KS
687 workT[found_indx] = -1.e20;
688
d073f122 689 for (j = band_tab[found_indx]; j < band_tab[found_indx+1] && (corrected < summer); j++) {
c45e2da6
KS
690 if (!chctx->skipFlags[j] && (chctx->CWlengthT[j] < 6)) {
691 chctx->CWlengthT[j]++;
84ed36da
KS
692 corrected++;
693 }
694 }
695 }
696 }
697}
698
34271cab 699static void imc_imdct256(IMCContext *q, IMCChannel *chctx, int channels)
d073f122 700{
84ed36da
KS
701 int i;
702 float re, im;
34271cab 703 float *dst1 = q->out_samples;
3fca0d72 704 float *dst2 = q->out_samples + (COEFFS - 1);
84ed36da
KS
705
706 /* prerotation */
d073f122 707 for (i = 0; i < COEFFS / 2; i++) {
c45e2da6
KS
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]);
84ed36da
KS
712 }
713
714 /* FFT */
26f548bb 715 q->fft.fft_permute(&q->fft, q->samples);
d073f122 716 q->fft.fft_calc(&q->fft, q->samples);
84ed36da
KS
717
718 /* postrotation, window and reorder */
d073f122
KS
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]);
34271cab
KS
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);
3fca0d72
JR
726 dst1 += 2;
727 dst2 -= 2;
c45e2da6 728 chctx->last_fft_im[i] = im;
84ed36da
KS
729 }
730}
731
c45e2da6
KS
732static int inverse_quant_coeff(IMCContext *q, IMCChannel *chctx,
733 int stream_format_code)
d073f122 734{
84ed36da
KS
735 int i, j;
736 int middle_value, cw_len, max_size;
d073f122 737 const float *quantizer;
84ed36da 738
d073f122
KS
739 for (i = 0; i < BANDS; i++) {
740 for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
c45e2da6
KS
741 chctx->CWdecoded[j] = 0;
742 cw_len = chctx->CWlengthT[j];
84ed36da 743
c45e2da6 744 if (cw_len <= 0 || chctx->skipFlags[j])
84ed36da
KS
745 continue;
746
d073f122 747 max_size = 1 << cw_len;
84ed36da
KS
748 middle_value = max_size >> 1;
749
c45e2da6 750 if (chctx->codewords[j] >= max_size || chctx->codewords[j] < 0)
08e5cd38 751 return AVERROR_INVALIDDATA;
84ed36da 752
d073f122 753 if (cw_len >= 4) {
84ed36da 754 quantizer = imc_quantizer2[(stream_format_code & 2) >> 1];
c45e2da6
KS
755 if (chctx->codewords[j] >= middle_value)
756 chctx->CWdecoded[j] = quantizer[chctx->codewords[j] - 8] * chctx->flcoeffs6[i];
84ed36da 757 else
c45e2da6 758 chctx->CWdecoded[j] = -quantizer[max_size - chctx->codewords[j] - 8 - 1] * chctx->flcoeffs6[i];
84ed36da 759 }else{
c45e2da6
KS
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];
84ed36da 763 else
c45e2da6 764 chctx->CWdecoded[j] = -quantizer[max_size - 2 - chctx->codewords[j]] * chctx->flcoeffs6[i];
84ed36da
KS
765 }
766 }
767 }
768 return 0;
769}
770
771
c45e2da6 772static int imc_get_coeffs(IMCContext *q, IMCChannel *chctx)
d073f122 773{
84ed36da
KS
774 int i, j, cw_len, cw;
775
d073f122 776 for (i = 0; i < BANDS; i++) {
c45e2da6 777 if (!chctx->sumLenArr[i])
d073f122 778 continue;
c45e2da6 779 if (chctx->bandFlagsBuf[i] || chctx->bandWidthT[i]) {
d073f122 780 for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
c45e2da6 781 cw_len = chctx->CWlengthT[j];
84ed36da
KS
782 cw = 0;
783
d073f122 784 if (get_bits_count(&q->gb) + cw_len > 512) {
6a85dfc8 785 ff_dlog(NULL, "Band %i coeff %i cw_len %i\n", i, j, cw_len);
08e5cd38 786 return AVERROR_INVALIDDATA;
84ed36da
KS
787 }
788
c45e2da6 789 if (cw_len && (!chctx->bandFlagsBuf[i] || !chctx->skipFlags[j]))
84ed36da
KS
790 cw = get_bits(&q->gb, cw_len);
791
c45e2da6 792 chctx->codewords[j] = cw;
84ed36da
KS
793 }
794 }
795 }
796 return 0;
797}
798
4eb4bb3a
KS
799static void imc_refine_bit_allocation(IMCContext *q, IMCChannel *chctx)
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
c45e2da6 843static int imc_decode_block(AVCodecContext *avctx, IMCContext *q, int ch)
84ed36da 844{
84ed36da 845 int stream_format_code;
0eea2129 846 int imc_hdr, i, j, ret;
84ed36da 847 int flag;
4eb4bb3a 848 int bits;
84ed36da 849 int counter, bitscount;
c45e2da6 850 IMCChannel *chctx = q->chctx + ch;
84ed36da 851
84ed36da
KS
852
853 /* Check the frame header */
854 imc_hdr = get_bits(&q->gb, 9);
c6061443
KS
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);
08e5cd38 858 return AVERROR_INVALIDDATA;
84ed36da
KS
859 }
860 stream_format_code = get_bits(&q->gb, 3);
861
84ed36da 862 if (stream_format_code & 0x04)
c45e2da6 863 chctx->decoder_reset = 1;
84ed36da 864
c45e2da6 865 if (chctx->decoder_reset) {
d073f122 866 for (i = 0; i < BANDS; i++)
c45e2da6 867 chctx->old_floor[i] = 1.0;
d073f122 868 for (i = 0; i < COEFFS; i++)
c45e2da6
KS
869 chctx->CWdecoded[i] = 0;
870 chctx->decoder_reset = 0;
84ed36da
KS
871 }
872
873 flag = get_bits1(&q->gb);
4eb4bb3a 874 if (stream_format_code & 0x1)
4eb4bb3a
KS
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);
84ed36da 878
1ac5a29b
VG
879 if (stream_format_code & 0x1)
880 imc_decode_level_coefficients_raw(q, chctx->levlCoeffBuf,
881 chctx->flcoeffs1, chctx->flcoeffs2);
882 else if (stream_format_code & 0x4)
c45e2da6
KS
883 imc_decode_level_coefficients(q, chctx->levlCoeffBuf,
884 chctx->flcoeffs1, chctx->flcoeffs2);
84ed36da 885 else
c45e2da6
KS
886 imc_decode_level_coefficients2(q, chctx->levlCoeffBuf, chctx->old_floor,
887 chctx->flcoeffs1, chctx->flcoeffs2);
84ed36da 888
c45e2da6 889 memcpy(chctx->old_floor, chctx->flcoeffs1, 32 * sizeof(float));
84ed36da
KS
890
891 counter = 0;
4eb4bb3a
KS
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);
84ed36da 912
4eb4bb3a
KS
913 imc_calculate_coeffs(q, chctx->flcoeffs1, chctx->flcoeffs2,
914 chctx->bandWidthT, chctx->flcoeffs3,
915 chctx->flcoeffs5);
916 }
84ed36da
KS
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
c45e2da6
KS
923 chctx->bitsBandT[0] = 5;
924 chctx->CWlengthT[0] = 5;
925 chctx->CWlengthT[1] = 5;
926 chctx->CWlengthT[2] = 5;
d073f122 927 for (i = 1; i < 4; i++) {
4eb4bb3a
KS
928 if (stream_format_code & 0x1)
929 bits = 5;
930 else
931 bits = (chctx->levlCoeffBuf[i] == 16) ? 0 : 5;
c45e2da6 932 chctx->bitsBandT[i] = bits;
d073f122 933 for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
c45e2da6 934 chctx->CWlengthT[j] = bits;
d073f122 935 bitscount += bits;
84ed36da
KS
936 }
937 }
938 }
36ef5369 939 if (avctx->codec_id == AV_CODEC_ID_IAC) {
c6061443
KS
940 bitscount += !!chctx->bandWidthT[BANDS - 1];
941 if (!(stream_format_code & 0x2))
942 bitscount += 16;
943 }
84ed36da 944
c45e2da6 945 if ((ret = bit_allocation(q, chctx, stream_format_code,
d073f122
KS
946 512 - bitscount - get_bits_count(&q->gb),
947 flag)) < 0) {
84ed36da 948 av_log(avctx, AV_LOG_ERROR, "Bit allocations failed\n");
c45e2da6 949 chctx->decoder_reset = 1;
08e5cd38 950 return ret;
84ed36da
KS
951 }
952
4eb4bb3a
KS
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);
84ed36da 958 }
84ed36da 959
d073f122 960 for (i = 0; i < BANDS; i++) {
c45e2da6 961 chctx->sumLenArr[i] = 0;
84ed36da 962
d073f122 963 for (j = band_tab[i]; j < band_tab[i + 1]; j++)
c45e2da6
KS
964 if (!chctx->skipFlags[j])
965 chctx->sumLenArr[i] += chctx->CWlengthT[j];
84ed36da
KS
966 }
967
c45e2da6 968 memset(chctx->codewords, 0, sizeof(chctx->codewords));
84ed36da 969
c45e2da6 970 if (imc_get_coeffs(q, chctx) < 0) {
84ed36da 971 av_log(avctx, AV_LOG_ERROR, "Read coefficients failed\n");
c45e2da6 972 chctx->decoder_reset = 1;
a4998e44 973 return AVERROR_INVALIDDATA;
84ed36da
KS
974 }
975
c45e2da6 976 if (inverse_quant_coeff(q, chctx, stream_format_code) < 0) {
84ed36da 977 av_log(avctx, AV_LOG_ERROR, "Inverse quantization of coefficients failed\n");
c45e2da6
KS
978 chctx->decoder_reset = 1;
979 return AVERROR_INVALIDDATA;
980 }
981
982 memset(chctx->skipFlags, 0, sizeof(chctx->skipFlags));
983
34271cab 984 imc_imdct256(q, chctx, avctx->channels);
c45e2da6
KS
985
986 return 0;
987}
988
989static int imc_decode_frame(AVCodecContext *avctx, void *data,
990 int *got_frame_ptr, AVPacket *avpkt)
991{
9b28e583 992 AVFrame *frame = data;
c45e2da6
KS
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
059a9348 999 LOCAL_ALIGNED_16(uint16_t, buf16, [(IMC_BLOCK_SIZE + AV_INPUT_BUFFER_PADDING_SIZE) / 2]);
c45e2da6 1000
c6061443
KS
1001 if (buf_size < IMC_BLOCK_SIZE * avctx->channels) {
1002 av_log(avctx, AV_LOG_ERROR, "frame too small!\n");
a4998e44 1003 return AVERROR_INVALIDDATA;
84ed36da
KS
1004 }
1005
c45e2da6 1006 /* get output buffer */
9b28e583 1007 frame->nb_samples = COEFFS;
759001c5 1008 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
c45e2da6
KS
1009 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1010 return ret;
1011 }
84ed36da 1012
c45e2da6 1013 for (i = 0; i < avctx->channels; i++) {
9b28e583 1014 q->out_samples = (float *)frame->extended_data[i];
c45e2da6 1015
c67b449b 1016 q->bdsp.bswap16_buf(buf16, (const uint16_t *) buf, IMC_BLOCK_SIZE / 2);
c45e2da6
KS
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 }
84ed36da 1025
c6061443 1026 if (avctx->channels == 2) {
9b28e583
JR
1027 q->fdsp.butterflies_float((float *)frame->extended_data[0],
1028 (float *)frame->extended_data[1], COEFFS);
c6061443
KS
1029 }
1030
9b28e583 1031 *got_frame_ptr = 1;
84ed36da 1032
c45e2da6 1033 return IMC_BLOCK_SIZE * avctx->channels;
84ed36da
KS
1034}
1035
1036
98a6fff9 1037static av_cold int imc_decode_close(AVCodecContext * avctx)
84ed36da
KS
1038{
1039 IMCContext *q = avctx->priv_data;
1040
1041 ff_fft_end(&q->fft);
0eea2129 1042
84ed36da
KS
1043 return 0;
1044}
1045
1046
d36beb3f 1047AVCodec ff_imc_decoder = {
00c3b67b 1048 .name = "imc",
b2bed932 1049 .long_name = NULL_IF_CONFIG_SMALL("IMC (Intel Music Coder)"),
00c3b67b 1050 .type = AVMEDIA_TYPE_AUDIO,
36ef5369 1051 .id = AV_CODEC_ID_IMC,
84ed36da 1052 .priv_data_size = sizeof(IMCContext),
00c3b67b
MS
1053 .init = imc_decode_init,
1054 .close = imc_decode_close,
1055 .decode = imc_decode_frame,
def97856 1056 .capabilities = AV_CODEC_CAP_DR1,
3fca0d72
JR
1057 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1058 AV_SAMPLE_FMT_NONE },
84ed36da 1059};
c6061443
KS
1060
1061AVCodec ff_iac_decoder = {
1062 .name = "iac",
b2bed932 1063 .long_name = NULL_IF_CONFIG_SMALL("IAC (Indeo Audio Coder)"),
c6061443 1064 .type = AVMEDIA_TYPE_AUDIO,
36ef5369 1065 .id = AV_CODEC_ID_IAC,
c6061443
KS
1066 .priv_data_size = sizeof(IMCContext),
1067 .init = imc_decode_init,
1068 .close = imc_decode_close,
1069 .decode = imc_decode_frame,
def97856 1070 .capabilities = AV_CODEC_CAP_DR1,
3fca0d72
JR
1071 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1072 AV_SAMPLE_FMT_NONE },
c6061443 1073};