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
37 #include "libavutil/channel_layout.h"
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
68 int levlCoeffBuf[BANDS];
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
77 float last_fft_im[COEFFS];
78
79 int decoder_reset;
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];
95 GetBitContext gb;
96
97 BswapDSPContext bdsp;
98 AVFloatDSPContext *fdsp;
99 FFTContext fft;
100 DECLARE_ALIGNED(32, FFTComplex, samples)[COEFFS / 2];
101 float *out_samples;
102
103 int coef0_pos;
104
105 int8_t cyclTab[32], cyclTab2[32];
106 float weights1[31], weights2[31];
107
108 AVCodecContext *avctx;
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
120 static VLC_TYPE vlc_tables[VLC_TABLES_SIZE][2];
121
freq2bark(double freq)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
iac_generate_tabs(IMCContext * q,int sampling_rate)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
imc_decode_init(AVCodecContext * avctx)178 static av_cold int imc_decode_init(AVCodecContext *avctx)
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) */
211 ff_sine_window_init(q->mdct_sine_window, COEFFS);
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,
242 imc_huffman_bits[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
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);
260 q->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
261 if (!q->fdsp) {
262 ff_fft_end(&q->fft);
263
264 return AVERROR(ENOMEM);
265 }
266
267 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
268 avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO
269 : AV_CH_LAYOUT_STEREO;
270
271 return 0;
272 }
273
imc_calculate_coeffs(IMCContext * q,float * flcoeffs1,float * flcoeffs2,int * bandWidthT,float * flcoeffs3,float * flcoeffs5)274 static void imc_calculate_coeffs(IMCContext *q, float *flcoeffs1,
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
imc_read_level_coeffs(IMCContext * q,int stream_format_code,int * levlCoeffs)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
imc_read_level_coeffs_raw(IMCContext * q,int stream_format_code,int * levlCoeffs)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
imc_decode_level_coefficients(IMCContext * q,int * levlCoeffBuf,float * flcoeffs1,float * flcoeffs2)368 static void imc_decode_level_coefficients(IMCContext *q, int *levlCoeffBuf,
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
imc_decode_level_coefficients2(IMCContext * q,int * levlCoeffBuf,float * old_floor,float * flcoeffs1,float * flcoeffs2)402 static void imc_decode_level_coefficients2(IMCContext *q, int *levlCoeffBuf,
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
imc_decode_level_coefficients_raw(IMCContext * q,int * levlCoeffBuf,float * flcoeffs1,float * flcoeffs2)422 static void imc_decode_level_coefficients_raw(IMCContext *q, int *levlCoeffBuf,
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 */
bit_allocation(IMCContext * q,IMCChannel * chctx,int stream_format_code,int freebits,int flag)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
imc_get_skip_coeff(IMCContext * q,IMCChannel * chctx)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 */
imc_adjust_bit_allocation(IMCContext * q,IMCChannel * chctx,int summer)679 static void imc_adjust_bit_allocation(IMCContext *q, IMCChannel *chctx,
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
imc_imdct256(IMCContext * q,IMCChannel * chctx,int channels)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
inverse_quant_coeff(IMCContext * q,IMCChannel * chctx,int stream_format_code)754 static int inverse_quant_coeff(IMCContext *q, IMCChannel *chctx,
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
imc_get_coeffs(AVCodecContext * avctx,IMCContext * q,IMCChannel * chctx)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
imc_refine_bit_allocation(IMCContext * q,IMCChannel * chctx)822 static void imc_refine_bit_allocation(IMCContext *q, IMCChannel *chctx)
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
imc_decode_block(AVCodecContext * avctx,IMCContext * q,int ch)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)
903 imc_decode_level_coefficients_raw(q, chctx->levlCoeffBuf,
904 chctx->flcoeffs1, chctx->flcoeffs2);
905 else if (stream_format_code & 0x4)
906 imc_decode_level_coefficients(q, chctx->levlCoeffBuf,
907 chctx->flcoeffs1, chctx->flcoeffs2);
908 else
909 imc_decode_level_coefficients2(q, chctx->levlCoeffBuf, chctx->old_floor,
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
imc_decode_frame(AVCodecContext * avctx,void * data,int * got_frame_ptr,AVPacket * avpkt)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
imc_decode_close(AVCodecContext * avctx)1062 static av_cold int imc_decode_close(AVCodecContext * avctx)
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
flush(AVCodecContext * avctx)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
1081 AVCodec ff_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,
1089 .decode = imc_decode_frame,
1090 .flush = flush,
1091 .capabilities = AV_CODEC_CAP_DR1,
1092 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1093 AV_SAMPLE_FMT_NONE },
1094 };
1095 #endif
1096 #if CONFIG_IAC_DECODER
1097 AVCodec ff_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,
1105 .decode = imc_decode_frame,
1106 .flush = flush,
1107 .capabilities = AV_CODEC_CAP_DR1,
1108 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1109 AV_SAMPLE_FMT_NONE },
1110 };
1111 #endif
1112