Merge remote-tracking branch 'qatar/master'
[ffmpeg.git] / libavcodec / imc.c
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
34 #include <math.h>
35 #include <stddef.h>
36 #include <stdio.h>
37
38 #include "avcodec.h"
39 #include "get_bits.h"
40 #include "dsputil.h"
41 #include "fft.h"
42 #include "libavutil/audioconvert.h"
43 #include "sinewin.h"
44
45 #include "imcdata.h"
46
47 #define IMC_BLOCK_SIZE 64
48 #define IMC_FRAME_ID 0x21
49 #define BANDS 32
50 #define COEFFS 256
51
52 typedef struct IMCChannel {
53     float old_floor[BANDS];
54     float flcoeffs1[BANDS];
55     float flcoeffs2[BANDS];
56     float flcoeffs3[BANDS];
57     float flcoeffs4[BANDS];
58     float flcoeffs5[BANDS];
59     float flcoeffs6[BANDS];
60     float CWdecoded[COEFFS];
61
62     int bandWidthT[BANDS];     ///< codewords per band
63     int bitsBandT[BANDS];      ///< how many bits per codeword in band
64     int CWlengthT[COEFFS];     ///< how many bits in each codeword
65     int levlCoeffBuf[BANDS];
66     int bandFlagsBuf[BANDS];   ///< flags for each band
67     int sumLenArr[BANDS];      ///< bits for all coeffs in band
68     int skipFlagRaw[BANDS];    ///< skip flags are stored in raw form or not
69     int skipFlagBits[BANDS];   ///< bits used to code skip flags
70     int skipFlagCount[BANDS];  ///< skipped coeffients per band
71     int skipFlags[COEFFS];     ///< skip coefficient decoding or not
72     int codewords[COEFFS];     ///< raw codewords read from bitstream
73
74     float last_fft_im[COEFFS];
75
76     int decoder_reset;
77 } IMCChannel;
78
79 typedef struct {
80     AVFrame frame;
81
82     IMCChannel chctx[2];
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
93     float sqrt_tab[30];
94     GetBitContext gb;
95
96     DSPContext dsp;
97     FFTContext fft;
98     DECLARE_ALIGNED(32, FFTComplex, samples)[COEFFS / 2];
99     float *out_samples;
100
101     int8_t cyclTab[32], cyclTab2[32];
102     float  weights1[31], weights2[31];
103 } IMCContext;
104
105 static VLC huffman_vlc[4][4];
106
107 #define VLC_TABLES_SIZE 9512
108
109 static const int vlc_offsets[17] = {
110     0,     640, 1156, 1732, 2308, 2852, 3396, 3924,
111     4452, 5220, 5860, 6628, 7268, 7908, 8424, 8936, VLC_TABLES_SIZE
112 };
113
114 static VLC_TYPE vlc_tables[VLC_TABLES_SIZE][2];
115
116 static inline double freq2bark(double freq)
117 {
118     return 3.5 * atan((freq / 7500.0) * (freq / 7500.0)) + 13.0 * atan(freq * 0.00076);
119 }
120
121 static av_cold void iac_generate_tabs(IMCContext *q, int sampling_rate)
122 {
123     double freqmin[32], freqmid[32], freqmax[32];
124     double scale = sampling_rate / (256.0 * 2.0 * 2.0);
125     double nyquist_freq = sampling_rate * 0.5;
126     double freq, bark, prev_bark = 0, tf, tb;
127     int i, j;
128
129     for (i = 0; i < 32; i++) {
130         freq = (band_tab[i] + band_tab[i + 1] - 1) * scale;
131         bark = freq2bark(freq);
132
133         if (i > 0) {
134             tb = bark - prev_bark;
135             q->weights1[i - 1] = pow(10.0, -1.0 * tb);
136             q->weights2[i - 1] = pow(10.0, -2.7 * tb);
137         }
138         prev_bark = bark;
139
140         freqmid[i] = freq;
141
142         tf = freq;
143         while (tf < nyquist_freq) {
144             tf += 0.5;
145             tb =  freq2bark(tf);
146             if (tb > bark + 0.5)
147                 break;
148         }
149         freqmax[i] = tf;
150
151         tf = freq;
152         while (tf > 0.0) {
153             tf -= 0.5;
154             tb =  freq2bark(tf);
155             if (tb <= bark - 0.5)
156                 break;
157         }
158         freqmin[i] = tf;
159     }
160
161     for (i = 0; i < 32; i++) {
162         freq = freqmax[i];
163         for (j = 31; j > 0 && freq <= freqmid[j]; j--);
164         q->cyclTab[i] = j + 1;
165
166         freq = freqmin[i];
167         for (j = 0; j < 32 && freq >= freqmid[j]; j++);
168         q->cyclTab2[i] = j - 1;
169     }
170 }
171
172 static av_cold int imc_decode_init(AVCodecContext *avctx)
173 {
174     int i, j, ret;
175     IMCContext *q = avctx->priv_data;
176     double r1, r2;
177
178     if ((avctx->codec_id == AV_CODEC_ID_IMC && avctx->channels != 1)
179         || (avctx->codec_id == AV_CODEC_ID_IAC && avctx->channels > 2)) {
180         av_log_ask_for_sample(avctx, "Number of channels is not supported\n");
181         return AVERROR_PATCHWELCOME;
182     }
183
184     for (j = 0; j < avctx->channels; j++) {
185         q->chctx[j].decoder_reset = 1;
186
187         for (i = 0; i < BANDS; i++)
188             q->chctx[j].old_floor[i] = 1.0;
189
190         for (i = 0; i < COEFFS / 2; i++)
191             q->chctx[j].last_fft_im[i] = 0;
192     }
193
194     /* Build mdct window, a simple sine window normalized with sqrt(2) */
195     ff_sine_window_init(q->mdct_sine_window, COEFFS);
196     for (i = 0; i < COEFFS; i++)
197         q->mdct_sine_window[i] *= sqrt(2.0);
198     for (i = 0; i < COEFFS / 2; i++) {
199         q->post_cos[i] = (1.0f / 32768) * cos(i / 256.0 * M_PI);
200         q->post_sin[i] = (1.0f / 32768) * sin(i / 256.0 * M_PI);
201
202         r1 = sin((i * 4.0 + 1.0) / 1024.0 * M_PI);
203         r2 = cos((i * 4.0 + 1.0) / 1024.0 * M_PI);
204
205         if (i & 0x1) {
206             q->pre_coef1[i] =  (r1 + r2) * sqrt(2.0);
207             q->pre_coef2[i] = -(r1 - r2) * sqrt(2.0);
208         } else {
209             q->pre_coef1[i] = -(r1 + r2) * sqrt(2.0);
210             q->pre_coef2[i] =  (r1 - r2) * sqrt(2.0);
211         }
212     }
213
214     /* Generate a square root table */
215
216     for (i = 0; i < 30; i++)
217         q->sqrt_tab[i] = sqrt(i);
218
219     /* initialize the VLC tables */
220     for (i = 0; i < 4 ; i++) {
221         for (j = 0; j < 4; j++) {
222             huffman_vlc[i][j].table = &vlc_tables[vlc_offsets[i * 4 + j]];
223             huffman_vlc[i][j].table_allocated = vlc_offsets[i * 4 + j + 1] - vlc_offsets[i * 4 + j];
224             init_vlc(&huffman_vlc[i][j], 9, imc_huffman_sizes[i],
225                      imc_huffman_lens[i][j], 1, 1,
226                      imc_huffman_bits[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
227         }
228     }
229
230     if (avctx->codec_id == AV_CODEC_ID_IAC) {
231         iac_generate_tabs(q, avctx->sample_rate);
232     } else {
233         memcpy(q->cyclTab,  cyclTab,  sizeof(cyclTab));
234         memcpy(q->cyclTab2, cyclTab2, sizeof(cyclTab2));
235         memcpy(q->weights1, imc_weights1, sizeof(imc_weights1));
236         memcpy(q->weights2, imc_weights2, sizeof(imc_weights2));
237     }
238
239     if ((ret = ff_fft_init(&q->fft, 7, 1))) {
240         av_log(avctx, AV_LOG_INFO, "FFT init failed\n");
241         return ret;
242     }
243     ff_dsputil_init(&q->dsp, avctx);
244     avctx->sample_fmt     = AV_SAMPLE_FMT_FLT;
245     avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO
246                                                  : AV_CH_LAYOUT_STEREO;
247
248     avcodec_get_frame_defaults(&q->frame);
249     avctx->coded_frame = &q->frame;
250
251     return 0;
252 }
253
254 static void imc_calculate_coeffs(IMCContext *q, float *flcoeffs1,
255                                  float *flcoeffs2, int *bandWidthT,
256                                  float *flcoeffs3, float *flcoeffs5)
257 {
258     float   workT1[BANDS];
259     float   workT2[BANDS];
260     float   workT3[BANDS];
261     float   snr_limit = 1.e-30;
262     float   accum = 0.0;
263     int i, cnt2;
264
265     for (i = 0; i < BANDS; i++) {
266         flcoeffs5[i] = workT2[i] = 0.0;
267         if (bandWidthT[i]) {
268             workT1[i] = flcoeffs1[i] * flcoeffs1[i];
269             flcoeffs3[i] = 2.0 * flcoeffs2[i];
270         } else {
271             workT1[i]    = 0.0;
272             flcoeffs3[i] = -30000.0;
273         }
274         workT3[i] = bandWidthT[i] * workT1[i] * 0.01;
275         if (workT3[i] <= snr_limit)
276             workT3[i] = 0.0;
277     }
278
279     for (i = 0; i < BANDS; i++) {
280         for (cnt2 = i; cnt2 < q->cyclTab[i]; cnt2++)
281             flcoeffs5[cnt2] = flcoeffs5[cnt2] + workT3[i];
282         workT2[cnt2 - 1] = workT2[cnt2 - 1] + workT3[i];
283     }
284
285     for (i = 1; i < BANDS; i++) {
286         accum = (workT2[i - 1] + accum) * q->weights1[i - 1];
287         flcoeffs5[i] += accum;
288     }
289
290     for (i = 0; i < BANDS; i++)
291         workT2[i] = 0.0;
292
293     for (i = 0; i < BANDS; i++) {
294         for (cnt2 = i - 1; cnt2 > q->cyclTab2[i]; cnt2--)
295             flcoeffs5[cnt2] += workT3[i];
296         workT2[cnt2+1] += workT3[i];
297     }
298
299     accum = 0.0;
300
301     for (i = BANDS-2; i >= 0; i--) {
302         accum = (workT2[i+1] + accum) * q->weights2[i];
303         flcoeffs5[i] += accum;
304         // there is missing code here, but it seems to never be triggered
305     }
306 }
307
308
309 static void imc_read_level_coeffs(IMCContext *q, int stream_format_code,
310                                   int *levlCoeffs)
311 {
312     int i;
313     VLC *hufftab[4];
314     int start = 0;
315     const uint8_t *cb_sel;
316     int s;
317
318     s = stream_format_code >> 1;
319     hufftab[0] = &huffman_vlc[s][0];
320     hufftab[1] = &huffman_vlc[s][1];
321     hufftab[2] = &huffman_vlc[s][2];
322     hufftab[3] = &huffman_vlc[s][3];
323     cb_sel = imc_cb_select[s];
324
325     if (stream_format_code & 4)
326         start = 1;
327     if (start)
328         levlCoeffs[0] = get_bits(&q->gb, 7);
329     for (i = start; i < BANDS; i++) {
330         levlCoeffs[i] = get_vlc2(&q->gb, hufftab[cb_sel[i]]->table,
331                                  hufftab[cb_sel[i]]->bits, 2);
332         if (levlCoeffs[i] == 17)
333             levlCoeffs[i] += get_bits(&q->gb, 4);
334     }
335 }
336
337 static void imc_decode_level_coefficients(IMCContext *q, int *levlCoeffBuf,
338                                           float *flcoeffs1, float *flcoeffs2)
339 {
340     int i, level;
341     float tmp, tmp2;
342     // maybe some frequency division thingy
343
344     flcoeffs1[0] = 20000.0 / pow (2, levlCoeffBuf[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
345     flcoeffs2[0] = log2f(flcoeffs1[0]);
346     tmp  = flcoeffs1[0];
347     tmp2 = flcoeffs2[0];
348
349     for (i = 1; i < BANDS; i++) {
350         level = levlCoeffBuf[i];
351         if (level == 16) {
352             flcoeffs1[i] = 1.0;
353             flcoeffs2[i] = 0.0;
354         } else {
355             if (level < 17)
356                 level -= 7;
357             else if (level <= 24)
358                 level -= 32;
359             else
360                 level -= 16;
361
362             tmp  *= imc_exp_tab[15 + level];
363             tmp2 += 0.83048 * level;  // 0.83048 = log2(10) * 0.25
364             flcoeffs1[i] = tmp;
365             flcoeffs2[i] = tmp2;
366         }
367     }
368 }
369
370
371 static void imc_decode_level_coefficients2(IMCContext *q, int *levlCoeffBuf,
372                                            float *old_floor, float *flcoeffs1,
373                                            float *flcoeffs2)
374 {
375     int i;
376     /* FIXME maybe flag_buf = noise coding and flcoeffs1 = new scale factors
377      *       and flcoeffs2 old scale factors
378      *       might be incomplete due to a missing table that is in the binary code
379      */
380     for (i = 0; i < BANDS; i++) {
381         flcoeffs1[i] = 0;
382         if (levlCoeffBuf[i] < 16) {
383             flcoeffs1[i] = imc_exp_tab2[levlCoeffBuf[i]] * old_floor[i];
384             flcoeffs2[i] = (levlCoeffBuf[i] - 7) * 0.83048 + flcoeffs2[i]; // 0.83048 = log2(10) * 0.25
385         } else {
386             flcoeffs1[i] = old_floor[i];
387         }
388     }
389 }
390
391 /**
392  * Perform bit allocation depending on bits available
393  */
394 static int bit_allocation(IMCContext *q, IMCChannel *chctx,
395                           int stream_format_code, int freebits, int flag)
396 {
397     int i, j;
398     const float limit = -1.e20;
399     float highest = 0.0;
400     int indx;
401     int t1 = 0;
402     int t2 = 1;
403     float summa = 0.0;
404     int iacc = 0;
405     int summer = 0;
406     int rres, cwlen;
407     float lowest = 1.e10;
408     int low_indx = 0;
409     float workT[32];
410     int flg;
411     int found_indx = 0;
412
413     for (i = 0; i < BANDS; i++)
414         highest = FFMAX(highest, chctx->flcoeffs1[i]);
415
416     for (i = 0; i < BANDS - 1; i++)
417         chctx->flcoeffs4[i] = chctx->flcoeffs3[i] - log2f(chctx->flcoeffs5[i]);
418     chctx->flcoeffs4[BANDS - 1] = limit;
419
420     highest = highest * 0.25;
421
422     for (i = 0; i < BANDS; i++) {
423         indx = -1;
424         if ((band_tab[i + 1] - band_tab[i]) == chctx->bandWidthT[i])
425             indx = 0;
426
427         if ((band_tab[i + 1] - band_tab[i]) > chctx->bandWidthT[i])
428             indx = 1;
429
430         if (((band_tab[i + 1] - band_tab[i]) / 2) >= chctx->bandWidthT[i])
431             indx = 2;
432
433         if (indx == -1)
434             return AVERROR_INVALIDDATA;
435
436         chctx->flcoeffs4[i] += xTab[(indx * 2 + (chctx->flcoeffs1[i] < highest)) * 2 + flag];
437     }
438
439     if (stream_format_code & 0x2) {
440         chctx->flcoeffs4[0] = limit;
441         chctx->flcoeffs4[1] = limit;
442         chctx->flcoeffs4[2] = limit;
443         chctx->flcoeffs4[3] = limit;
444     }
445
446     for (i = (stream_format_code & 0x2) ? 4 : 0; i < BANDS - 1; i++) {
447         iacc  += chctx->bandWidthT[i];
448         summa += chctx->bandWidthT[i] * chctx->flcoeffs4[i];
449     }
450     chctx->bandWidthT[BANDS - 1] = 0;
451     summa = (summa * 0.5 - freebits) / iacc;
452
453
454     for (i = 0; i < BANDS / 2; i++) {
455         rres = summer - freebits;
456         if ((rres >= -8) && (rres <= 8))
457             break;
458
459         summer = 0;
460         iacc   = 0;
461
462         for (j = (stream_format_code & 0x2) ? 4 : 0; j < BANDS; j++) {
463             cwlen = av_clipf(((chctx->flcoeffs4[j] * 0.5) - summa + 0.5), 0, 6);
464
465             chctx->bitsBandT[j] = cwlen;
466             summer += chctx->bandWidthT[j] * cwlen;
467
468             if (cwlen > 0)
469                 iacc += chctx->bandWidthT[j];
470         }
471
472         flg = t2;
473         t2 = 1;
474         if (freebits < summer)
475             t2 = -1;
476         if (i == 0)
477             flg = t2;
478         if (flg != t2)
479             t1++;
480
481         summa = (float)(summer - freebits) / ((t1 + 1) * iacc) + summa;
482     }
483
484     for (i = (stream_format_code & 0x2) ? 4 : 0; i < BANDS; i++) {
485         for (j = band_tab[i]; j < band_tab[i + 1]; j++)
486             chctx->CWlengthT[j] = chctx->bitsBandT[i];
487     }
488
489     if (freebits > summer) {
490         for (i = 0; i < BANDS; i++) {
491             workT[i] = (chctx->bitsBandT[i] == 6) ? -1.e20
492                                               : (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] - 0.415);
493         }
494
495         highest = 0.0;
496
497         do {
498             if (highest <= -1.e20)
499                 break;
500
501             found_indx = 0;
502             highest = -1.e20;
503
504             for (i = 0; i < BANDS; i++) {
505                 if (workT[i] > highest) {
506                     highest = workT[i];
507                     found_indx = i;
508                 }
509             }
510
511             if (highest > -1.e20) {
512                 workT[found_indx] -= 2.0;
513                 if (++chctx->bitsBandT[found_indx] == 6)
514                     workT[found_indx] = -1.e20;
515
516                 for (j = band_tab[found_indx]; j < band_tab[found_indx + 1] && (freebits > summer); j++) {
517                     chctx->CWlengthT[j]++;
518                     summer++;
519                 }
520             }
521         } while (freebits > summer);
522     }
523     if (freebits < summer) {
524         for (i = 0; i < BANDS; i++) {
525             workT[i] = chctx->bitsBandT[i] ? (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] + 1.585)
526                                        : 1.e20;
527         }
528         if (stream_format_code & 0x2) {
529             workT[0] = 1.e20;
530             workT[1] = 1.e20;
531             workT[2] = 1.e20;
532             workT[3] = 1.e20;
533         }
534         while (freebits < summer) {
535             lowest   = 1.e10;
536             low_indx = 0;
537             for (i = 0; i < BANDS; i++) {
538                 if (workT[i] < lowest) {
539                     lowest   = workT[i];
540                     low_indx = i;
541                 }
542             }
543             // if (lowest >= 1.e10)
544             //     break;
545             workT[low_indx] = lowest + 2.0;
546
547             if (!--chctx->bitsBandT[low_indx])
548                 workT[low_indx] = 1.e20;
549
550             for (j = band_tab[low_indx]; j < band_tab[low_indx+1] && (freebits < summer); j++) {
551                 if (chctx->CWlengthT[j] > 0) {
552                     chctx->CWlengthT[j]--;
553                     summer--;
554                 }
555             }
556         }
557     }
558     return 0;
559 }
560
561 static void imc_get_skip_coeff(IMCContext *q, IMCChannel *chctx)
562 {
563     int i, j;
564
565     memset(chctx->skipFlagBits,  0, sizeof(chctx->skipFlagBits));
566     memset(chctx->skipFlagCount, 0, sizeof(chctx->skipFlagCount));
567     for (i = 0; i < BANDS; i++) {
568         if (!chctx->bandFlagsBuf[i] || !chctx->bandWidthT[i])
569             continue;
570
571         if (!chctx->skipFlagRaw[i]) {
572             chctx->skipFlagBits[i] = band_tab[i + 1] - band_tab[i];
573
574             for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
575                 chctx->skipFlags[j] = get_bits1(&q->gb);
576                 if (chctx->skipFlags[j])
577                     chctx->skipFlagCount[i]++;
578             }
579         } else {
580             for (j = band_tab[i]; j < band_tab[i + 1] - 1; j += 2) {
581                 if (!get_bits1(&q->gb)) { // 0
582                     chctx->skipFlagBits[i]++;
583                     chctx->skipFlags[j]      = 1;
584                     chctx->skipFlags[j + 1]  = 1;
585                     chctx->skipFlagCount[i] += 2;
586                 } else {
587                     if (get_bits1(&q->gb)) { // 11
588                         chctx->skipFlagBits[i] += 2;
589                         chctx->skipFlags[j]     = 0;
590                         chctx->skipFlags[j + 1] = 1;
591                         chctx->skipFlagCount[i]++;
592                     } else {
593                         chctx->skipFlagBits[i] += 3;
594                         chctx->skipFlags[j + 1] = 0;
595                         if (!get_bits1(&q->gb)) { // 100
596                             chctx->skipFlags[j] = 1;
597                             chctx->skipFlagCount[i]++;
598                         } else { // 101
599                             chctx->skipFlags[j] = 0;
600                         }
601                     }
602                 }
603             }
604
605             if (j < band_tab[i + 1]) {
606                 chctx->skipFlagBits[i]++;
607                 if ((chctx->skipFlags[j] = get_bits1(&q->gb)))
608                     chctx->skipFlagCount[i]++;
609             }
610         }
611     }
612 }
613
614 /**
615  * Increase highest' band coefficient sizes as some bits won't be used
616  */
617 static void imc_adjust_bit_allocation(IMCContext *q, IMCChannel *chctx,
618                                       int summer)
619 {
620     float workT[32];
621     int corrected = 0;
622     int i, j;
623     float highest  = 0;
624     int found_indx = 0;
625
626     for (i = 0; i < BANDS; i++) {
627         workT[i] = (chctx->bitsBandT[i] == 6) ? -1.e20
628                                           : (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] - 0.415);
629     }
630
631     while (corrected < summer) {
632         if (highest <= -1.e20)
633             break;
634
635         highest = -1.e20;
636
637         for (i = 0; i < BANDS; i++) {
638             if (workT[i] > highest) {
639                 highest = workT[i];
640                 found_indx = i;
641             }
642         }
643
644         if (highest > -1.e20) {
645             workT[found_indx] -= 2.0;
646             if (++(chctx->bitsBandT[found_indx]) == 6)
647                 workT[found_indx] = -1.e20;
648
649             for (j = band_tab[found_indx]; j < band_tab[found_indx+1] && (corrected < summer); j++) {
650                 if (!chctx->skipFlags[j] && (chctx->CWlengthT[j] < 6)) {
651                     chctx->CWlengthT[j]++;
652                     corrected++;
653                 }
654             }
655         }
656     }
657 }
658
659 static void imc_imdct256(IMCContext *q, IMCChannel *chctx, int channels)
660 {
661     int i;
662     float re, im;
663     float *dst1 = q->out_samples;
664     float *dst2 = q->out_samples + (COEFFS - 1) * channels;
665
666     /* prerotation */
667     for (i = 0; i < COEFFS / 2; i++) {
668         q->samples[i].re = -(q->pre_coef1[i] * chctx->CWdecoded[COEFFS - 1 - i * 2]) -
669                             (q->pre_coef2[i] * chctx->CWdecoded[i * 2]);
670         q->samples[i].im =  (q->pre_coef2[i] * chctx->CWdecoded[COEFFS - 1 - i * 2]) -
671                             (q->pre_coef1[i] * chctx->CWdecoded[i * 2]);
672     }
673
674     /* FFT */
675     q->fft.fft_permute(&q->fft, q->samples);
676     q->fft.fft_calc(&q->fft, q->samples);
677
678     /* postrotation, window and reorder */
679     for (i = 0; i < COEFFS / 2; i++) {
680         re = ( q->samples[i].re * q->post_cos[i]) + (-q->samples[i].im * q->post_sin[i]);
681         im = (-q->samples[i].im * q->post_cos[i]) - ( q->samples[i].re * q->post_sin[i]);
682         *dst1 =  (q->mdct_sine_window[COEFFS - 1 - i * 2] * chctx->last_fft_im[i])
683                + (q->mdct_sine_window[i * 2] * re);
684         *dst2 =  (q->mdct_sine_window[i * 2] * chctx->last_fft_im[i])
685                - (q->mdct_sine_window[COEFFS - 1 - i * 2] * re);
686         dst1 += channels * 2;
687         dst2 -= channels * 2;
688         chctx->last_fft_im[i] = im;
689     }
690 }
691
692 static int inverse_quant_coeff(IMCContext *q, IMCChannel *chctx,
693                                int stream_format_code)
694 {
695     int i, j;
696     int middle_value, cw_len, max_size;
697     const float *quantizer;
698
699     for (i = 0; i < BANDS; i++) {
700         for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
701             chctx->CWdecoded[j] = 0;
702             cw_len = chctx->CWlengthT[j];
703
704             if (cw_len <= 0 || chctx->skipFlags[j])
705                 continue;
706
707             max_size     = 1 << cw_len;
708             middle_value = max_size >> 1;
709
710             if (chctx->codewords[j] >= max_size || chctx->codewords[j] < 0)
711                 return AVERROR_INVALIDDATA;
712
713             if (cw_len >= 4) {
714                 quantizer = imc_quantizer2[(stream_format_code & 2) >> 1];
715                 if (chctx->codewords[j] >= middle_value)
716                     chctx->CWdecoded[j] =  quantizer[chctx->codewords[j] - 8]                * chctx->flcoeffs6[i];
717                 else
718                     chctx->CWdecoded[j] = -quantizer[max_size - chctx->codewords[j] - 8 - 1] * chctx->flcoeffs6[i];
719             }else{
720                 quantizer = imc_quantizer1[((stream_format_code & 2) >> 1) | (chctx->bandFlagsBuf[i] << 1)];
721                 if (chctx->codewords[j] >= middle_value)
722                     chctx->CWdecoded[j] =  quantizer[chctx->codewords[j] - 1]            * chctx->flcoeffs6[i];
723                 else
724                     chctx->CWdecoded[j] = -quantizer[max_size - 2 - chctx->codewords[j]] * chctx->flcoeffs6[i];
725             }
726         }
727     }
728     return 0;
729 }
730
731
732 static int imc_get_coeffs(IMCContext *q, IMCChannel *chctx)
733 {
734     int i, j, cw_len, cw;
735
736     for (i = 0; i < BANDS; i++) {
737         if (!chctx->sumLenArr[i])
738             continue;
739         if (chctx->bandFlagsBuf[i] || chctx->bandWidthT[i]) {
740             for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
741                 cw_len = chctx->CWlengthT[j];
742                 cw = 0;
743
744                 if (get_bits_count(&q->gb) + cw_len > 512) {
745                     // av_log(NULL, 0, "Band %i coeff %i cw_len %i\n", i, j, cw_len);
746                     return AVERROR_INVALIDDATA;
747                 }
748
749                 if (cw_len && (!chctx->bandFlagsBuf[i] || !chctx->skipFlags[j]))
750                     cw = get_bits(&q->gb, cw_len);
751
752                 chctx->codewords[j] = cw;
753             }
754         }
755     }
756     return 0;
757 }
758
759 static int imc_decode_block(AVCodecContext *avctx, IMCContext *q, int ch)
760 {
761     int stream_format_code;
762     int imc_hdr, i, j, ret;
763     int flag;
764     int bits, summer;
765     int counter, bitscount;
766     IMCChannel *chctx = q->chctx + ch;
767
768
769     /* Check the frame header */
770     imc_hdr = get_bits(&q->gb, 9);
771     if (imc_hdr & 0x18) {
772         av_log(avctx, AV_LOG_ERROR, "frame header check failed!\n");
773         av_log(avctx, AV_LOG_ERROR, "got %X.\n", imc_hdr);
774         return AVERROR_INVALIDDATA;
775     }
776     stream_format_code = get_bits(&q->gb, 3);
777
778     if (stream_format_code & 1) {
779         av_log_ask_for_sample(avctx, "Stream format %X is not supported\n",
780                               stream_format_code);
781         return AVERROR_PATCHWELCOME;
782     }
783
784 //    av_log(avctx, AV_LOG_DEBUG, "stream_format_code = %d\n", stream_format_code);
785
786     if (stream_format_code & 0x04)
787         chctx->decoder_reset = 1;
788
789     if (chctx->decoder_reset) {
790         memset(q->out_samples, 0, COEFFS * sizeof(*q->out_samples));
791         for (i = 0; i < BANDS; i++)
792             chctx->old_floor[i] = 1.0;
793         for (i = 0; i < COEFFS; i++)
794             chctx->CWdecoded[i] = 0;
795         chctx->decoder_reset = 0;
796     }
797
798     flag = get_bits1(&q->gb);
799     imc_read_level_coeffs(q, stream_format_code, chctx->levlCoeffBuf);
800
801     if (stream_format_code & 0x4)
802         imc_decode_level_coefficients(q, chctx->levlCoeffBuf,
803                                       chctx->flcoeffs1, chctx->flcoeffs2);
804     else
805         imc_decode_level_coefficients2(q, chctx->levlCoeffBuf, chctx->old_floor,
806                                        chctx->flcoeffs1, chctx->flcoeffs2);
807
808     memcpy(chctx->old_floor, chctx->flcoeffs1, 32 * sizeof(float));
809
810     counter = 0;
811     for (i = 0; i < BANDS; i++) {
812         if (chctx->levlCoeffBuf[i] == 16) {
813             chctx->bandWidthT[i] = 0;
814             counter++;
815         } else
816             chctx->bandWidthT[i] = band_tab[i + 1] - band_tab[i];
817     }
818     memset(chctx->bandFlagsBuf, 0, BANDS * sizeof(int));
819     for (i = 0; i < BANDS - 1; i++) {
820         if (chctx->bandWidthT[i])
821             chctx->bandFlagsBuf[i] = get_bits1(&q->gb);
822     }
823
824     imc_calculate_coeffs(q, chctx->flcoeffs1, chctx->flcoeffs2, chctx->bandWidthT, chctx->flcoeffs3, chctx->flcoeffs5);
825
826     bitscount = 0;
827     /* first 4 bands will be assigned 5 bits per coefficient */
828     if (stream_format_code & 0x2) {
829         bitscount += 15;
830
831         chctx->bitsBandT[0] = 5;
832         chctx->CWlengthT[0] = 5;
833         chctx->CWlengthT[1] = 5;
834         chctx->CWlengthT[2] = 5;
835         for (i = 1; i < 4; i++) {
836             bits = (chctx->levlCoeffBuf[i] == 16) ? 0 : 5;
837             chctx->bitsBandT[i] = bits;
838             for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
839                 chctx->CWlengthT[j] = bits;
840                 bitscount      += bits;
841             }
842         }
843     }
844     if (avctx->codec_id == AV_CODEC_ID_IAC) {
845         bitscount += !!chctx->bandWidthT[BANDS - 1];
846         if (!(stream_format_code & 0x2))
847             bitscount += 16;
848     }
849
850     if ((ret = bit_allocation(q, chctx, stream_format_code,
851                               512 - bitscount - get_bits_count(&q->gb),
852                               flag)) < 0) {
853         av_log(avctx, AV_LOG_ERROR, "Bit allocations failed\n");
854         chctx->decoder_reset = 1;
855         return ret;
856     }
857
858     for (i = 0; i < BANDS; i++) {
859         chctx->sumLenArr[i]   = 0;
860         chctx->skipFlagRaw[i] = 0;
861         for (j = band_tab[i]; j < band_tab[i + 1]; j++)
862             chctx->sumLenArr[i] += chctx->CWlengthT[j];
863         if (chctx->bandFlagsBuf[i])
864             if ((((band_tab[i + 1] - band_tab[i]) * 1.5) > chctx->sumLenArr[i]) && (chctx->sumLenArr[i] > 0))
865                 chctx->skipFlagRaw[i] = 1;
866     }
867
868     imc_get_skip_coeff(q, chctx);
869
870     for (i = 0; i < BANDS; i++) {
871         chctx->flcoeffs6[i] = chctx->flcoeffs1[i];
872         /* band has flag set and at least one coded coefficient */
873         if (chctx->bandFlagsBuf[i] && (band_tab[i + 1] - band_tab[i]) != chctx->skipFlagCount[i]) {
874             chctx->flcoeffs6[i] *= q->sqrt_tab[ band_tab[i + 1] - band_tab[i]] /
875                                    q->sqrt_tab[(band_tab[i + 1] - band_tab[i] - chctx->skipFlagCount[i])];
876         }
877     }
878
879     /* calculate bits left, bits needed and adjust bit allocation */
880     bits = summer = 0;
881
882     for (i = 0; i < BANDS; i++) {
883         if (chctx->bandFlagsBuf[i]) {
884             for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
885                 if (chctx->skipFlags[j]) {
886                     summer += chctx->CWlengthT[j];
887                     chctx->CWlengthT[j] = 0;
888                 }
889             }
890             bits   += chctx->skipFlagBits[i];
891             summer -= chctx->skipFlagBits[i];
892         }
893     }
894     imc_adjust_bit_allocation(q, chctx, summer);
895
896     for (i = 0; i < BANDS; i++) {
897         chctx->sumLenArr[i] = 0;
898
899         for (j = band_tab[i]; j < band_tab[i + 1]; j++)
900             if (!chctx->skipFlags[j])
901                 chctx->sumLenArr[i] += chctx->CWlengthT[j];
902     }
903
904     memset(chctx->codewords, 0, sizeof(chctx->codewords));
905
906     if (imc_get_coeffs(q, chctx) < 0) {
907         av_log(avctx, AV_LOG_ERROR, "Read coefficients failed\n");
908         chctx->decoder_reset = 1;
909         return AVERROR_INVALIDDATA;
910     }
911
912     if (inverse_quant_coeff(q, chctx, stream_format_code) < 0) {
913         av_log(avctx, AV_LOG_ERROR, "Inverse quantization of coefficients failed\n");
914         chctx->decoder_reset = 1;
915         return AVERROR_INVALIDDATA;
916     }
917
918     memset(chctx->skipFlags, 0, sizeof(chctx->skipFlags));
919
920     imc_imdct256(q, chctx, avctx->channels);
921
922     return 0;
923 }
924
925 static int imc_decode_frame(AVCodecContext *avctx, void *data,
926                             int *got_frame_ptr, AVPacket *avpkt)
927 {
928     const uint8_t *buf = avpkt->data;
929     int buf_size = avpkt->size;
930     int ret, i;
931
932     IMCContext *q = avctx->priv_data;
933
934     LOCAL_ALIGNED_16(uint16_t, buf16, [IMC_BLOCK_SIZE / 2]);
935
936     if (buf_size < IMC_BLOCK_SIZE * avctx->channels) {
937         av_log(avctx, AV_LOG_ERROR, "frame too small!\n");
938         return AVERROR_INVALIDDATA;
939     }
940
941     /* get output buffer */
942     q->frame.nb_samples = COEFFS;
943     if ((ret = avctx->get_buffer(avctx, &q->frame)) < 0) {
944         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
945         return ret;
946     }
947
948     for (i = 0; i < avctx->channels; i++) {
949         q->out_samples = (float*)q->frame.data[0] + i;
950
951         q->dsp.bswap16_buf(buf16, (const uint16_t*)buf, IMC_BLOCK_SIZE / 2);
952
953         init_get_bits(&q->gb, (const uint8_t*)buf16, IMC_BLOCK_SIZE * 8);
954
955         buf += IMC_BLOCK_SIZE;
956
957         if ((ret = imc_decode_block(avctx, q, i)) < 0)
958             return ret;
959     }
960
961     if (avctx->channels == 2) {
962         float *src = (float*)q->frame.data[0], t1, t2;
963
964         for (i = 0; i < COEFFS; i++) {
965             t1     = src[0];
966             t2     = src[1];
967             src[0] = t1 + t2;
968             src[1] = t1 - t2;
969             src   += 2;
970         }
971     }
972
973     *got_frame_ptr   = 1;
974     *(AVFrame *)data = q->frame;
975
976     return IMC_BLOCK_SIZE * avctx->channels;
977 }
978
979
980 static av_cold int imc_decode_close(AVCodecContext * avctx)
981 {
982     IMCContext *q = avctx->priv_data;
983
984     ff_fft_end(&q->fft);
985
986     return 0;
987 }
988
989 #if CONFIG_IMC_DECODER
990 AVCodec ff_imc_decoder = {
991     .name           = "imc",
992     .type           = AVMEDIA_TYPE_AUDIO,
993     .id             = AV_CODEC_ID_IMC,
994     .priv_data_size = sizeof(IMCContext),
995     .init           = imc_decode_init,
996     .close          = imc_decode_close,
997     .decode         = imc_decode_frame,
998     .capabilities   = CODEC_CAP_DR1,
999     .long_name      = NULL_IF_CONFIG_SMALL("IMC (Intel Music Coder)"),
1000 };
1001 #endif
1002 #if CONFIG_IAC_DECODER
1003 AVCodec ff_iac_decoder = {
1004     .name           = "iac",
1005     .type           = AVMEDIA_TYPE_AUDIO,
1006     .id             = AV_CODEC_ID_IAC,
1007     .priv_data_size = sizeof(IMCContext),
1008     .init           = imc_decode_init,
1009     .close          = imc_decode_close,
1010     .decode         = imc_decode_frame,
1011     .capabilities   = CODEC_CAP_DR1,
1012     .long_name      = NULL_IF_CONFIG_SMALL("IAC (Indeo Audio Coder)"),
1013 };
1014 #endif