d316ba4cbb1d07cee15fe187646e8cfe013ed4d6
[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 imc.c IMC - Intel Music Coder
26  *  A mdct based codec using a 256 points large transform
27  *  divied into 32 bands with some mix of scale factors.
28  *  Only mono is supported.
29  *
30  */
31
32
33 #include <math.h>
34 #include <stddef.h>
35 #include <stdio.h>
36
37 #define ALT_BITSTREAM_READER
38 #include "avcodec.h"
39 #include "bitstream.h"
40 #include "dsputil.h"
41
42 #include "imcdata.h"
43
44 #define IMC_BLOCK_SIZE 64
45 #define IMC_FRAME_ID 0x21
46 #define BANDS 32
47 #define COEFFS 256
48
49 typedef struct {
50     float old_floor[BANDS];
51     float flcoeffs1[BANDS];
52     float flcoeffs2[BANDS];
53     float flcoeffs3[BANDS];
54     float flcoeffs4[BANDS];
55     float flcoeffs5[BANDS];
56     float flcoeffs6[BANDS];
57     float CWdecoded[COEFFS];
58
59     /** MDCT tables */
60     //@{
61     float mdct_sine_window[COEFFS];
62     float post_cos[COEFFS];
63     float post_sin[COEFFS];
64     float pre_coef1[COEFFS];
65     float pre_coef2[COEFFS];
66     float last_fft_im[COEFFS];
67     //@}
68
69     int bandWidthT[BANDS];     ///< codewords per band
70     int bitsBandT[BANDS];      ///< how many bits per codeword in band
71     int CWlengthT[COEFFS];     ///< how many bits in each codeword
72     int levlCoeffBuf[BANDS];
73     int bandFlagsBuf[BANDS];   ///< flags for each band
74     int sumLenArr[BANDS];      ///< bits for all coeffs in band
75     int skipFlagRaw[BANDS];    ///< skip flags are stored in raw form or not
76     int skipFlagBits[BANDS];   ///< bits used to code skip flags
77     int skipFlagCount[BANDS];  ///< skipped coeffients per band
78     int skipFlags[COEFFS];     ///< skip coefficient decoding or not
79     int codewords[COEFFS];     ///< raw codewords read from bitstream
80     float sqrt_tab[30];
81     GetBitContext gb;
82     int decoder_reset;
83     float one_div_log2;
84
85     DSPContext dsp;
86     FFTContext fft;
87     DECLARE_ALIGNED_16(FFTComplex, samples[COEFFS/2]);
88     DECLARE_ALIGNED_16(float, out_samples[COEFFS]);
89 } IMCContext;
90
91 static VLC huffman_vlc[4][4];
92
93 #define VLC_TABLES_SIZE 9512
94
95 static const int vlc_offsets[17] = {
96     0,     640, 1156, 1732, 2308, 2852, 3396, 3924,
97     4452, 5220, 5860, 6628, 7268, 7908, 8424, 8936, VLC_TABLES_SIZE};
98
99 static VLC_TYPE vlc_tables[VLC_TABLES_SIZE][2];
100
101 static av_cold int imc_decode_init(AVCodecContext * avctx)
102 {
103     int i, j;
104     IMCContext *q = avctx->priv_data;
105     double r1, r2;
106
107     q->decoder_reset = 1;
108
109     for(i = 0; i < BANDS; i++)
110         q->old_floor[i] = 1.0;
111
112     /* Build mdct window, a simple sine window normalized with sqrt(2) */
113     ff_sine_window_init(q->mdct_sine_window, COEFFS);
114     for(i = 0; i < COEFFS; i++)
115         q->mdct_sine_window[i] *= sqrt(2.0);
116     for(i = 0; i < COEFFS/2; i++){
117         q->post_cos[i] = cos(i / 256.0 * M_PI);
118         q->post_sin[i] = sin(i / 256.0 * M_PI);
119
120         r1 = sin((i * 4.0 + 1.0) / 1024.0 * M_PI);
121         r2 = cos((i * 4.0 + 1.0) / 1024.0 * M_PI);
122
123         if (i & 0x1)
124         {
125             q->pre_coef1[i] =  (r1 + r2) * sqrt(2.0);
126             q->pre_coef2[i] = -(r1 - r2) * sqrt(2.0);
127         }
128         else
129         {
130             q->pre_coef1[i] = -(r1 + r2) * sqrt(2.0);
131             q->pre_coef2[i] =  (r1 - r2) * sqrt(2.0);
132         }
133
134         q->last_fft_im[i] = 0;
135     }
136
137     /* Generate a square root table */
138
139     for(i = 0; i < 30; i++) {
140         q->sqrt_tab[i] = sqrt(i);
141     }
142
143     /* initialize the VLC tables */
144     for(i = 0; i < 4 ; i++) {
145         for(j = 0; j < 4; j++) {
146             huffman_vlc[i][j].table = vlc_tables[vlc_offsets[i * 4 + j]];
147             huffman_vlc[i][j].table_allocated = vlc_offsets[i * 4 + j + 1] - vlc_offsets[i * 4 + j];
148             init_vlc(&huffman_vlc[i][j], 9, imc_huffman_sizes[i],
149                      imc_huffman_lens[i][j], 1, 1,
150                      imc_huffman_bits[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
151         }
152     }
153     q->one_div_log2 = 1/log(2);
154
155     ff_fft_init(&q->fft, 7, 1);
156     dsputil_init(&q->dsp, avctx);
157     return 0;
158 }
159
160 static void imc_calculate_coeffs(IMCContext* q, float* flcoeffs1, float* flcoeffs2, int* bandWidthT,
161                                 float* flcoeffs3, float* flcoeffs5)
162 {
163     float   workT1[BANDS];
164     float   workT2[BANDS];
165     float   workT3[BANDS];
166     float   snr_limit = 1.e-30;
167     float   accum = 0.0;
168     int i, cnt2;
169
170     for(i = 0; i < BANDS; i++) {
171         flcoeffs5[i] = workT2[i] = 0.0;
172         if (bandWidthT[i]){
173             workT1[i] = flcoeffs1[i] * flcoeffs1[i];
174             flcoeffs3[i] = 2.0 * flcoeffs2[i];
175         } else {
176             workT1[i] = 0.0;
177             flcoeffs3[i] = -30000.0;
178         }
179         workT3[i] = bandWidthT[i] * workT1[i] * 0.01;
180         if (workT3[i] <= snr_limit)
181             workT3[i] = 0.0;
182     }
183
184     for(i = 0; i < BANDS; i++) {
185         for(cnt2 = i; cnt2 < cyclTab[i]; cnt2++)
186             flcoeffs5[cnt2] = flcoeffs5[cnt2] + workT3[i];
187         workT2[cnt2-1] = workT2[cnt2-1] + workT3[i];
188     }
189
190     for(i = 1; i < BANDS; i++) {
191         accum = (workT2[i-1] + accum) * imc_weights1[i-1];
192         flcoeffs5[i] += accum;
193     }
194
195     for(i = 0; i < BANDS; i++)
196         workT2[i] = 0.0;
197
198     for(i = 0; i < BANDS; i++) {
199         for(cnt2 = i-1; cnt2 > cyclTab2[i]; cnt2--)
200             flcoeffs5[cnt2] += workT3[i];
201         workT2[cnt2+1] += workT3[i];
202     }
203
204     accum = 0.0;
205
206     for(i = BANDS-2; i >= 0; i--) {
207         accum = (workT2[i+1] + accum) * imc_weights2[i];
208         flcoeffs5[i] += accum;
209         //there is missing code here, but it seems to never be triggered
210     }
211 }
212
213
214 static void imc_read_level_coeffs(IMCContext* q, int stream_format_code, int* levlCoeffs)
215 {
216     int i;
217     VLC *hufftab[4];
218     int start = 0;
219     const uint8_t *cb_sel;
220     int s;
221
222     s = stream_format_code >> 1;
223     hufftab[0] = &huffman_vlc[s][0];
224     hufftab[1] = &huffman_vlc[s][1];
225     hufftab[2] = &huffman_vlc[s][2];
226     hufftab[3] = &huffman_vlc[s][3];
227     cb_sel = imc_cb_select[s];
228
229     if(stream_format_code & 4)
230         start = 1;
231     if(start)
232         levlCoeffs[0] = get_bits(&q->gb, 7);
233     for(i = start; i < BANDS; i++){
234         levlCoeffs[i] = get_vlc2(&q->gb, hufftab[cb_sel[i]]->table, hufftab[cb_sel[i]]->bits, 2);
235         if(levlCoeffs[i] == 17)
236             levlCoeffs[i] += get_bits(&q->gb, 4);
237     }
238 }
239
240 static void imc_decode_level_coefficients(IMCContext* q, int* levlCoeffBuf, float* flcoeffs1,
241                                          float* flcoeffs2)
242 {
243     int i, level;
244     float tmp, tmp2;
245     //maybe some frequency division thingy
246
247     flcoeffs1[0] = 20000.0 / pow (2, levlCoeffBuf[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
248     flcoeffs2[0] = log(flcoeffs1[0])/log(2);
249     tmp = flcoeffs1[0];
250     tmp2 = flcoeffs2[0];
251
252     for(i = 1; i < BANDS; i++) {
253         level = levlCoeffBuf[i];
254         if (level == 16) {
255             flcoeffs1[i] = 1.0;
256             flcoeffs2[i] = 0.0;
257         } else {
258             if (level < 17)
259                 level -=7;
260             else if (level <= 24)
261                 level -=32;
262             else
263                 level -=16;
264
265             tmp  *= imc_exp_tab[15 + level];
266             tmp2 += 0.83048 * level;  // 0.83048 = log2(10) * 0.25
267             flcoeffs1[i] = tmp;
268             flcoeffs2[i] = tmp2;
269         }
270     }
271 }
272
273
274 static void imc_decode_level_coefficients2(IMCContext* q, int* levlCoeffBuf, float* old_floor, float* flcoeffs1,
275                                           float* flcoeffs2) {
276     int i;
277         //FIXME maybe flag_buf = noise coding and flcoeffs1 = new scale factors
278         //      and flcoeffs2 old scale factors
279         //      might be incomplete due to a missing table that is in the binary code
280     for(i = 0; i < BANDS; i++) {
281         flcoeffs1[i] = 0;
282         if(levlCoeffBuf[i] < 16) {
283             flcoeffs1[i] = imc_exp_tab2[levlCoeffBuf[i]] * old_floor[i];
284             flcoeffs2[i] = (levlCoeffBuf[i]-7) * 0.83048 + flcoeffs2[i]; // 0.83048 = log2(10) * 0.25
285         } else {
286             flcoeffs1[i] = old_floor[i];
287         }
288     }
289 }
290
291 /**
292  * Perform bit allocation depending on bits available
293  */
294 static int bit_allocation (IMCContext* q, int stream_format_code, int freebits, int flag) {
295     int i, j;
296     const float limit = -1.e20;
297     float highest = 0.0;
298     int indx;
299     int t1 = 0;
300     int t2 = 1;
301     float summa = 0.0;
302     int iacc = 0;
303     int summer = 0;
304     int rres, cwlen;
305     float lowest = 1.e10;
306     int low_indx = 0;
307     float workT[32];
308     int flg;
309     int found_indx = 0;
310
311     for(i = 0; i < BANDS; i++)
312         highest = FFMAX(highest, q->flcoeffs1[i]);
313
314     for(i = 0; i < BANDS-1; i++) {
315         q->flcoeffs4[i] = q->flcoeffs3[i] - log(q->flcoeffs5[i])/log(2);
316     }
317     q->flcoeffs4[BANDS - 1] = limit;
318
319     highest = highest * 0.25;
320
321     for(i = 0; i < BANDS; i++) {
322         indx = -1;
323         if ((band_tab[i+1] - band_tab[i]) == q->bandWidthT[i])
324             indx = 0;
325
326         if ((band_tab[i+1] - band_tab[i]) > q->bandWidthT[i])
327             indx = 1;
328
329         if (((band_tab[i+1] - band_tab[i])/2) >= q->bandWidthT[i])
330             indx = 2;
331
332         if (indx == -1)
333             return -1;
334
335         q->flcoeffs4[i] = q->flcoeffs4[i] + xTab[(indx*2 + (q->flcoeffs1[i] < highest)) * 2 + flag];
336     }
337
338     if (stream_format_code & 0x2) {
339         q->flcoeffs4[0] = limit;
340         q->flcoeffs4[1] = limit;
341         q->flcoeffs4[2] = limit;
342         q->flcoeffs4[3] = limit;
343     }
344
345     for(i = (stream_format_code & 0x2)?4:0; i < BANDS-1; i++) {
346         iacc += q->bandWidthT[i];
347         summa += q->bandWidthT[i] * q->flcoeffs4[i];
348     }
349     q->bandWidthT[BANDS-1] = 0;
350     summa = (summa * 0.5 - freebits) / iacc;
351
352
353     for(i = 0; i < BANDS/2; i++) {
354         rres = summer - freebits;
355         if((rres >= -8) && (rres <= 8)) break;
356
357         summer = 0;
358         iacc = 0;
359
360         for(j = (stream_format_code & 0x2)?4:0; j < BANDS; j++) {
361             cwlen = av_clip((int)((q->flcoeffs4[j] * 0.5) - summa + 0.5), 0, 6);
362
363             q->bitsBandT[j] = cwlen;
364             summer += q->bandWidthT[j] * cwlen;
365
366             if (cwlen > 0)
367                 iacc += q->bandWidthT[j];
368         }
369
370         flg = t2;
371         t2 = 1;
372         if (freebits < summer)
373             t2 = -1;
374         if (i == 0)
375             flg = t2;
376         if(flg != t2)
377             t1++;
378
379         summa = (float)(summer - freebits) / ((t1 + 1) * iacc) + summa;
380     }
381
382     for(i = (stream_format_code & 0x2)?4:0; i < BANDS; i++) {
383         for(j = band_tab[i]; j < band_tab[i+1]; j++)
384             q->CWlengthT[j] = q->bitsBandT[i];
385     }
386
387     if (freebits > summer) {
388         for(i = 0; i < BANDS; i++) {
389             workT[i] = (q->bitsBandT[i] == 6) ? -1.e20 : (q->bitsBandT[i] * -2 + q->flcoeffs4[i] - 0.415);
390         }
391
392         highest = 0.0;
393
394         do{
395             if (highest <= -1.e20)
396                 break;
397
398             found_indx = 0;
399             highest = -1.e20;
400
401             for(i = 0; i < BANDS; i++) {
402                 if (workT[i] > highest) {
403                     highest = workT[i];
404                     found_indx = i;
405                 }
406             }
407
408             if (highest > -1.e20) {
409                 workT[found_indx] -= 2.0;
410                 if (++(q->bitsBandT[found_indx]) == 6)
411                     workT[found_indx] = -1.e20;
412
413                 for(j = band_tab[found_indx]; j < band_tab[found_indx+1] && (freebits > summer); j++){
414                     q->CWlengthT[j]++;
415                     summer++;
416                 }
417             }
418         }while (freebits > summer);
419     }
420     if (freebits < summer) {
421         for(i = 0; i < BANDS; i++) {
422             workT[i] = q->bitsBandT[i] ? (q->bitsBandT[i] * -2 + q->flcoeffs4[i] + 1.585) : 1.e20;
423         }
424         if (stream_format_code & 0x2) {
425             workT[0] = 1.e20;
426             workT[1] = 1.e20;
427             workT[2] = 1.e20;
428             workT[3] = 1.e20;
429         }
430         while (freebits < summer){
431             lowest = 1.e10;
432             low_indx = 0;
433             for(i = 0; i < BANDS; i++) {
434                 if (workT[i] < lowest) {
435                     lowest = workT[i];
436                     low_indx = i;
437                 }
438             }
439             //if(lowest >= 1.e10) break;
440             workT[low_indx] = lowest + 2.0;
441
442             if (!(--q->bitsBandT[low_indx]))
443                 workT[low_indx] = 1.e20;
444
445             for(j = band_tab[low_indx]; j < band_tab[low_indx+1] && (freebits < summer); j++){
446                 if(q->CWlengthT[j] > 0){
447                     q->CWlengthT[j]--;
448                     summer--;
449                 }
450             }
451         }
452     }
453     return 0;
454 }
455
456 static void imc_get_skip_coeff(IMCContext* q) {
457     int i, j;
458
459     memset(q->skipFlagBits, 0, sizeof(q->skipFlagBits));
460     memset(q->skipFlagCount, 0, sizeof(q->skipFlagCount));
461     for(i = 0; i < BANDS; i++) {
462         if (!q->bandFlagsBuf[i] || !q->bandWidthT[i])
463             continue;
464
465         if (!q->skipFlagRaw[i]) {
466             q->skipFlagBits[i] = band_tab[i+1] - band_tab[i];
467
468             for(j = band_tab[i]; j < band_tab[i+1]; j++) {
469                 if ((q->skipFlags[j] = get_bits1(&q->gb)))
470                     q->skipFlagCount[i]++;
471             }
472         } else {
473             for(j = band_tab[i]; j < (band_tab[i+1]-1); j += 2) {
474                 if(!get_bits1(&q->gb)){//0
475                     q->skipFlagBits[i]++;
476                     q->skipFlags[j]=1;
477                     q->skipFlags[j+1]=1;
478                     q->skipFlagCount[i] += 2;
479                 }else{
480                     if(get_bits1(&q->gb)){//11
481                         q->skipFlagBits[i] +=2;
482                         q->skipFlags[j]=0;
483                         q->skipFlags[j+1]=1;
484                         q->skipFlagCount[i]++;
485                     }else{
486                         q->skipFlagBits[i] +=3;
487                         q->skipFlags[j+1]=0;
488                         if(!get_bits1(&q->gb)){//100
489                             q->skipFlags[j]=1;
490                             q->skipFlagCount[i]++;
491                         }else{//101
492                             q->skipFlags[j]=0;
493                         }
494                     }
495                 }
496             }
497
498             if (j < band_tab[i+1]) {
499                 q->skipFlagBits[i]++;
500                 if ((q->skipFlags[j] = get_bits1(&q->gb)))
501                     q->skipFlagCount[i]++;
502             }
503         }
504     }
505 }
506
507 /**
508  * Increase highest' band coefficient sizes as some bits won't be used
509  */
510 static void imc_adjust_bit_allocation (IMCContext* q, int summer) {
511     float workT[32];
512     int corrected = 0;
513     int i, j;
514     float highest = 0;
515     int found_indx=0;
516
517     for(i = 0; i < BANDS; i++) {
518         workT[i] = (q->bitsBandT[i] == 6) ? -1.e20 : (q->bitsBandT[i] * -2 + q->flcoeffs4[i] - 0.415);
519     }
520
521     while (corrected < summer) {
522         if(highest <= -1.e20)
523             break;
524
525         highest = -1.e20;
526
527         for(i = 0; i < BANDS; i++) {
528             if (workT[i] > highest) {
529                 highest = workT[i];
530                 found_indx = i;
531             }
532         }
533
534         if (highest > -1.e20) {
535             workT[found_indx] -= 2.0;
536             if (++(q->bitsBandT[found_indx]) == 6)
537                 workT[found_indx] = -1.e20;
538
539             for(j = band_tab[found_indx]; j < band_tab[found_indx+1] && (corrected < summer); j++) {
540                 if (!q->skipFlags[j] && (q->CWlengthT[j] < 6)) {
541                     q->CWlengthT[j]++;
542                     corrected++;
543                 }
544             }
545         }
546     }
547 }
548
549 static void imc_imdct256(IMCContext *q) {
550     int i;
551     float re, im;
552
553     /* prerotation */
554     for(i=0; i < COEFFS/2; i++){
555         q->samples[i].re = -(q->pre_coef1[i] * q->CWdecoded[COEFFS-1-i*2]) -
556                            (q->pre_coef2[i] * q->CWdecoded[i*2]);
557         q->samples[i].im = (q->pre_coef2[i] * q->CWdecoded[COEFFS-1-i*2]) -
558                            (q->pre_coef1[i] * q->CWdecoded[i*2]);
559     }
560
561     /* FFT */
562     ff_fft_permute(&q->fft, q->samples);
563     ff_fft_calc (&q->fft, q->samples);
564
565     /* postrotation, window and reorder */
566     for(i = 0; i < COEFFS/2; i++){
567         re = (q->samples[i].re * q->post_cos[i]) + (-q->samples[i].im * q->post_sin[i]);
568         im = (-q->samples[i].im * q->post_cos[i]) - (q->samples[i].re * q->post_sin[i]);
569         q->out_samples[i*2] = (q->mdct_sine_window[COEFFS-1-i*2] * q->last_fft_im[i]) + (q->mdct_sine_window[i*2] * re);
570         q->out_samples[COEFFS-1-i*2] = (q->mdct_sine_window[i*2] * q->last_fft_im[i]) - (q->mdct_sine_window[COEFFS-1-i*2] * re);
571         q->last_fft_im[i] = im;
572     }
573 }
574
575 static int inverse_quant_coeff (IMCContext* q, int stream_format_code) {
576     int i, j;
577     int middle_value, cw_len, max_size;
578     const float* quantizer;
579
580     for(i = 0; i < BANDS; i++) {
581         for(j = band_tab[i]; j < band_tab[i+1]; j++) {
582             q->CWdecoded[j] = 0;
583             cw_len = q->CWlengthT[j];
584
585             if (cw_len <= 0 || q->skipFlags[j])
586                 continue;
587
588             max_size = 1 << cw_len;
589             middle_value = max_size >> 1;
590
591             if (q->codewords[j] >= max_size || q->codewords[j] < 0)
592                 return -1;
593
594             if (cw_len >= 4){
595                 quantizer = imc_quantizer2[(stream_format_code & 2) >> 1];
596                 if (q->codewords[j] >= middle_value)
597                     q->CWdecoded[j] = quantizer[q->codewords[j] - 8] * q->flcoeffs6[i];
598                 else
599                     q->CWdecoded[j] = -quantizer[max_size - q->codewords[j] - 8 - 1] * q->flcoeffs6[i];
600             }else{
601                 quantizer = imc_quantizer1[((stream_format_code & 2) >> 1) | (q->bandFlagsBuf[i] << 1)];
602                 if (q->codewords[j] >= middle_value)
603                     q->CWdecoded[j] = quantizer[q->codewords[j] - 1] * q->flcoeffs6[i];
604                 else
605                     q->CWdecoded[j] = -quantizer[max_size - 2 - q->codewords[j]] * q->flcoeffs6[i];
606             }
607         }
608     }
609     return 0;
610 }
611
612
613 static int imc_get_coeffs (IMCContext* q) {
614     int i, j, cw_len, cw;
615
616     for(i = 0; i < BANDS; i++) {
617         if(!q->sumLenArr[i]) continue;
618         if (q->bandFlagsBuf[i] || q->bandWidthT[i]) {
619             for(j = band_tab[i]; j < band_tab[i+1]; j++) {
620                 cw_len = q->CWlengthT[j];
621                 cw = 0;
622
623                 if (get_bits_count(&q->gb) + cw_len > 512){
624 //av_log(NULL,0,"Band %i coeff %i cw_len %i\n",i,j,cw_len);
625                     return -1;
626                 }
627
628                 if(cw_len && (!q->bandFlagsBuf[i] || !q->skipFlags[j]))
629                     cw = get_bits(&q->gb, cw_len);
630
631                 q->codewords[j] = cw;
632             }
633         }
634     }
635     return 0;
636 }
637
638 static int imc_decode_frame(AVCodecContext * avctx,
639                             void *data, int *data_size,
640                             const uint8_t * buf, int buf_size)
641 {
642
643     IMCContext *q = avctx->priv_data;
644
645     int stream_format_code;
646     int imc_hdr, i, j;
647     int flag;
648     int bits, summer;
649     int counter, bitscount;
650     uint16_t buf16[IMC_BLOCK_SIZE / 2];
651
652     if (buf_size < IMC_BLOCK_SIZE) {
653         av_log(avctx, AV_LOG_ERROR, "imc frame too small!\n");
654         return -1;
655     }
656     for(i = 0; i < IMC_BLOCK_SIZE / 2; i++)
657         buf16[i] = bswap_16(((const uint16_t*)buf)[i]);
658
659     init_get_bits(&q->gb, (const uint8_t*)buf16, IMC_BLOCK_SIZE * 8);
660
661     /* Check the frame header */
662     imc_hdr = get_bits(&q->gb, 9);
663     if (imc_hdr != IMC_FRAME_ID) {
664         av_log(avctx, AV_LOG_ERROR, "imc frame header check failed!\n");
665         av_log(avctx, AV_LOG_ERROR, "got %x instead of 0x21.\n", imc_hdr);
666         return -1;
667     }
668     stream_format_code = get_bits(&q->gb, 3);
669
670     if(stream_format_code & 1){
671         av_log(avctx, AV_LOG_ERROR, "Stream code format %X is not supported\n", stream_format_code);
672         return -1;
673     }
674
675 //    av_log(avctx, AV_LOG_DEBUG, "stream_format_code = %d\n", stream_format_code);
676
677     if (stream_format_code & 0x04)
678         q->decoder_reset = 1;
679
680     if(q->decoder_reset) {
681         memset(q->out_samples, 0, sizeof(q->out_samples));
682         for(i = 0; i < BANDS; i++)q->old_floor[i] = 1.0;
683         for(i = 0; i < COEFFS; i++)q->CWdecoded[i] = 0;
684         q->decoder_reset = 0;
685     }
686
687     flag = get_bits1(&q->gb);
688     imc_read_level_coeffs(q, stream_format_code, q->levlCoeffBuf);
689
690     if (stream_format_code & 0x4)
691         imc_decode_level_coefficients(q, q->levlCoeffBuf, q->flcoeffs1, q->flcoeffs2);
692     else
693         imc_decode_level_coefficients2(q, q->levlCoeffBuf, q->old_floor, q->flcoeffs1, q->flcoeffs2);
694
695     memcpy(q->old_floor, q->flcoeffs1, 32 * sizeof(float));
696
697     counter = 0;
698     for (i=0 ; i<BANDS ; i++) {
699         if (q->levlCoeffBuf[i] == 16) {
700             q->bandWidthT[i] = 0;
701             counter++;
702         } else
703             q->bandWidthT[i] = band_tab[i+1] - band_tab[i];
704     }
705     memset(q->bandFlagsBuf, 0, BANDS * sizeof(int));
706     for(i = 0; i < BANDS-1; i++) {
707         if (q->bandWidthT[i])
708             q->bandFlagsBuf[i] = get_bits1(&q->gb);
709     }
710
711     imc_calculate_coeffs(q, q->flcoeffs1, q->flcoeffs2, q->bandWidthT, q->flcoeffs3, q->flcoeffs5);
712
713     bitscount = 0;
714     /* first 4 bands will be assigned 5 bits per coefficient */
715     if (stream_format_code & 0x2) {
716         bitscount += 15;
717
718         q->bitsBandT[0] = 5;
719         q->CWlengthT[0] = 5;
720         q->CWlengthT[1] = 5;
721         q->CWlengthT[2] = 5;
722         for(i = 1; i < 4; i++){
723             bits = (q->levlCoeffBuf[i] == 16) ? 0 : 5;
724             q->bitsBandT[i] = bits;
725             for(j = band_tab[i]; j < band_tab[i+1]; j++) {
726                 q->CWlengthT[j] = bits;
727                 bitscount += bits;
728             }
729         }
730     }
731
732     if(bit_allocation (q, stream_format_code, 512 - bitscount - get_bits_count(&q->gb), flag) < 0) {
733         av_log(avctx, AV_LOG_ERROR, "Bit allocations failed\n");
734         q->decoder_reset = 1;
735         return -1;
736     }
737
738     for(i = 0; i < BANDS; i++) {
739         q->sumLenArr[i] = 0;
740         q->skipFlagRaw[i] = 0;
741         for(j = band_tab[i]; j < band_tab[i+1]; j++)
742             q->sumLenArr[i] += q->CWlengthT[j];
743         if (q->bandFlagsBuf[i])
744             if( (((band_tab[i+1] - band_tab[i]) * 1.5) > q->sumLenArr[i]) && (q->sumLenArr[i] > 0))
745                 q->skipFlagRaw[i] = 1;
746     }
747
748     imc_get_skip_coeff(q);
749
750     for(i = 0; i < BANDS; i++) {
751         q->flcoeffs6[i] = q->flcoeffs1[i];
752         /* band has flag set and at least one coded coefficient */
753         if (q->bandFlagsBuf[i] && (band_tab[i+1] - band_tab[i]) != q->skipFlagCount[i]){
754                 q->flcoeffs6[i] *= q->sqrt_tab[band_tab[i+1] - band_tab[i]] /
755                                    q->sqrt_tab[(band_tab[i+1] - band_tab[i] - q->skipFlagCount[i])];
756         }
757     }
758
759     /* calculate bits left, bits needed and adjust bit allocation */
760     bits = summer = 0;
761
762     for(i = 0; i < BANDS; i++) {
763         if (q->bandFlagsBuf[i]) {
764             for(j = band_tab[i]; j < band_tab[i+1]; j++) {
765                 if(q->skipFlags[j]) {
766                     summer += q->CWlengthT[j];
767                     q->CWlengthT[j] = 0;
768                 }
769             }
770             bits += q->skipFlagBits[i];
771             summer -= q->skipFlagBits[i];
772         }
773     }
774     imc_adjust_bit_allocation(q, summer);
775
776     for(i = 0; i < BANDS; i++) {
777         q->sumLenArr[i] = 0;
778
779         for(j = band_tab[i]; j < band_tab[i+1]; j++)
780             if (!q->skipFlags[j])
781                 q->sumLenArr[i] += q->CWlengthT[j];
782     }
783
784     memset(q->codewords, 0, sizeof(q->codewords));
785
786     if(imc_get_coeffs(q) < 0) {
787         av_log(avctx, AV_LOG_ERROR, "Read coefficients failed\n");
788         q->decoder_reset = 1;
789         return 0;
790     }
791
792     if(inverse_quant_coeff(q, stream_format_code) < 0) {
793         av_log(avctx, AV_LOG_ERROR, "Inverse quantization of coefficients failed\n");
794         q->decoder_reset = 1;
795         return 0;
796     }
797
798     memset(q->skipFlags, 0, sizeof(q->skipFlags));
799
800     imc_imdct256(q);
801
802     q->dsp.float_to_int16(data, q->out_samples, COEFFS);
803
804     *data_size = COEFFS * sizeof(int16_t);
805
806     return IMC_BLOCK_SIZE;
807 }
808
809
810 static av_cold int imc_decode_close(AVCodecContext * avctx)
811 {
812     IMCContext *q = avctx->priv_data;
813
814     ff_fft_end(&q->fft);
815     return 0;
816 }
817
818
819 AVCodec imc_decoder = {
820     .name = "imc",
821     .type = CODEC_TYPE_AUDIO,
822     .id = CODEC_ID_IMC,
823     .priv_data_size = sizeof(IMCContext),
824     .init = imc_decode_init,
825     .close = imc_decode_close,
826     .decode = imc_decode_frame,
827     .long_name = NULL_IF_CONFIG_SMALL("IMC (Intel Music Coder)"),
828 };