2 * IMC compatible decoder
3 * Copyright (c) 2002-2004 Maxim Poliakovski
4 * Copyright (c) 2006 Benjamin Larsson
5 * Copyright (c) 2006 Konstantin Shishkov
7 * This file is part of FFmpeg.
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.
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.
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
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.
38 #include "libavutil/channel_layout.h"
39 #include "libavutil/float_dsp.h"
40 #include "libavutil/internal.h"
41 #include "libavutil/libm.h"
51 #define IMC_BLOCK_SIZE 64
52 #define IMC_FRAME_ID 0x21
56 typedef struct IMCChannel
{
57 float old_floor
[BANDS
];
58 float flcoeffs1
[BANDS
];
59 float flcoeffs2
[BANDS
];
60 float flcoeffs3
[BANDS
];
61 float flcoeffs4
[BANDS
];
62 float flcoeffs5
[BANDS
];
63 float flcoeffs6
[BANDS
];
64 float CWdecoded
[COEFFS
];
66 int bandWidthT
[BANDS
]; ///< codewords per band
67 int bitsBandT
[BANDS
]; ///< how many bits per codeword in band
68 int CWlengthT
[COEFFS
]; ///< how many bits in each codeword
69 int levlCoeffBuf
[BANDS
];
70 int bandFlagsBuf
[BANDS
]; ///< flags for each band
71 int sumLenArr
[BANDS
]; ///< bits for all coeffs in band
72 int skipFlagRaw
[BANDS
]; ///< skip flags are stored in raw form or not
73 int skipFlagBits
[BANDS
]; ///< bits used to code skip flags
74 int skipFlagCount
[BANDS
]; ///< skipped coeffients per band
75 int skipFlags
[COEFFS
]; ///< skip coefficient decoding or not
76 int codewords
[COEFFS
]; ///< raw codewords read from bitstream
78 float last_fft_im
[COEFFS
];
88 float mdct_sine_window
[COEFFS
];
89 float post_cos
[COEFFS
];
90 float post_sin
[COEFFS
];
91 float pre_coef1
[COEFFS
];
92 float pre_coef2
[COEFFS
];
99 AVFloatDSPContext fdsp
;
101 DECLARE_ALIGNED(32, FFTComplex
, samples
)[COEFFS
/ 2];
106 int8_t cyclTab
[32], cyclTab2
[32];
107 float weights1
[31], weights2
[31];
110 static VLC huffman_vlc
[4][4];
112 #define VLC_TABLES_SIZE 9512
114 static const int vlc_offsets
[17] = {
115 0, 640, 1156, 1732, 2308, 2852, 3396, 3924,
116 4452, 5220, 5860, 6628, 7268, 7908, 8424, 8936, VLC_TABLES_SIZE
119 static VLC_TYPE vlc_tables
[VLC_TABLES_SIZE
][2];
121 static inline double freq2bark(double freq
)
123 return 3.5 * atan((freq
/ 7500.0) * (freq
/ 7500.0)) + 13.0 * atan(freq
* 0.00076);
126 static av_cold
void iac_generate_tabs(IMCContext
*q
, int sampling_rate
)
128 double freqmin
[32], freqmid
[32], freqmax
[32];
129 double scale
= sampling_rate
/ (256.0 * 2.0 * 2.0);
130 double nyquist_freq
= sampling_rate
* 0.5;
131 double freq
, bark
, prev_bark
= 0, tf
, tb
;
134 for (i
= 0; i
< 32; i
++) {
135 freq
= (band_tab
[i
] + band_tab
[i
+ 1] - 1) * scale
;
136 bark
= freq2bark(freq
);
139 tb
= bark
- prev_bark
;
140 q
->weights1
[i
- 1] = pow(10.0, -1.0 * tb
);
141 q
->weights2
[i
- 1] = pow(10.0, -2.7 * tb
);
148 while (tf
< nyquist_freq
) {
160 if (tb
<= bark
- 0.5)
166 for (i
= 0; i
< 32; i
++) {
168 for (j
= 31; j
> 0 && freq
<= freqmid
[j
]; j
--);
169 q
->cyclTab
[i
] = j
+ 1;
172 for (j
= 0; j
< 32 && freq
>= freqmid
[j
]; j
++);
173 q
->cyclTab2
[i
] = j
- 1;
177 static av_cold
int imc_decode_init(AVCodecContext
*avctx
)
180 IMCContext
*q
= avctx
->priv_data
;
183 if (avctx
->codec_id
== AV_CODEC_ID_IAC
&& avctx
->sample_rate
> 96000) {
184 av_log(avctx
, AV_LOG_ERROR
,
185 "Strange sample rate of %i, file likely corrupt or "
186 "needing a new table derivation method.\n",
188 return AVERROR_PATCHWELCOME
;
191 if (avctx
->codec_id
== AV_CODEC_ID_IMC
)
194 if (avctx
->channels
> 2) {
195 avpriv_request_sample(avctx
, "Number of channels > 2");
196 return AVERROR_PATCHWELCOME
;
199 for (j
= 0; j
< avctx
->channels
; j
++) {
200 q
->chctx
[j
].decoder_reset
= 1;
202 for (i
= 0; i
< BANDS
; i
++)
203 q
->chctx
[j
].old_floor
[i
] = 1.0;
205 for (i
= 0; i
< COEFFS
/ 2; i
++)
206 q
->chctx
[j
].last_fft_im
[i
] = 0;
209 /* Build mdct window, a simple sine window normalized with sqrt(2) */
210 ff_sine_window_init(q
->mdct_sine_window
, COEFFS
);
211 for (i
= 0; i
< COEFFS
; i
++)
212 q
->mdct_sine_window
[i
] *= sqrt(2.0);
213 for (i
= 0; i
< COEFFS
/ 2; i
++) {
214 q
->post_cos
[i
] = (1.0f
/ 32768) * cos(i
/ 256.0 * M_PI
);
215 q
->post_sin
[i
] = (1.0f
/ 32768) * sin(i
/ 256.0 * M_PI
);
217 r1
= sin((i
* 4.0 + 1.0) / 1024.0 * M_PI
);
218 r2
= cos((i
* 4.0 + 1.0) / 1024.0 * M_PI
);
221 q
->pre_coef1
[i
] = (r1
+ r2
) * sqrt(2.0);
222 q
->pre_coef2
[i
] = -(r1
- r2
) * sqrt(2.0);
224 q
->pre_coef1
[i
] = -(r1
+ r2
) * sqrt(2.0);
225 q
->pre_coef2
[i
] = (r1
- r2
) * sqrt(2.0);
229 /* Generate a square root table */
231 for (i
= 0; i
< 30; i
++)
232 q
->sqrt_tab
[i
] = sqrt(i
);
234 /* initialize the VLC tables */
235 for (i
= 0; i
< 4 ; i
++) {
236 for (j
= 0; j
< 4; j
++) {
237 huffman_vlc
[i
][j
].table
= &vlc_tables
[vlc_offsets
[i
* 4 + j
]];
238 huffman_vlc
[i
][j
].table_allocated
= vlc_offsets
[i
* 4 + j
+ 1] - vlc_offsets
[i
* 4 + j
];
239 init_vlc(&huffman_vlc
[i
][j
], 9, imc_huffman_sizes
[i
],
240 imc_huffman_lens
[i
][j
], 1, 1,
241 imc_huffman_bits
[i
][j
], 2, 2, INIT_VLC_USE_NEW_STATIC
);
245 if (avctx
->codec_id
== AV_CODEC_ID_IAC
) {
246 iac_generate_tabs(q
, avctx
->sample_rate
);
248 memcpy(q
->cyclTab
, cyclTab
, sizeof(cyclTab
));
249 memcpy(q
->cyclTab2
, cyclTab2
, sizeof(cyclTab2
));
250 memcpy(q
->weights1
, imc_weights1
, sizeof(imc_weights1
));
251 memcpy(q
->weights2
, imc_weights2
, sizeof(imc_weights2
));
254 if ((ret
= ff_fft_init(&q
->fft
, 7, 1))) {
255 av_log(avctx
, AV_LOG_INFO
, "FFT init failed\n");
258 ff_bswapdsp_init(&q
->bdsp
);
259 avpriv_float_dsp_init(&q
->fdsp
, avctx
->flags
& CODEC_FLAG_BITEXACT
);
260 avctx
->sample_fmt
= AV_SAMPLE_FMT_FLTP
;
261 avctx
->channel_layout
= avctx
->channels
== 1 ? AV_CH_LAYOUT_MONO
262 : AV_CH_LAYOUT_STEREO
;
267 static void imc_calculate_coeffs(IMCContext
*q
, float *flcoeffs1
,
268 float *flcoeffs2
, int *bandWidthT
,
269 float *flcoeffs3
, float *flcoeffs5
)
274 float snr_limit
= 1.e
-30;
278 for (i
= 0; i
< BANDS
; i
++) {
279 flcoeffs5
[i
] = workT2
[i
] = 0.0;
281 workT1
[i
] = flcoeffs1
[i
] * flcoeffs1
[i
];
282 flcoeffs3
[i
] = 2.0 * flcoeffs2
[i
];
285 flcoeffs3
[i
] = -30000.0;
287 workT3
[i
] = bandWidthT
[i
] * workT1
[i
] * 0.01;
288 if (workT3
[i
] <= snr_limit
)
292 for (i
= 0; i
< BANDS
; i
++) {
293 for (cnt2
= i
; cnt2
< q
->cyclTab
[i
]; cnt2
++)
294 flcoeffs5
[cnt2
] = flcoeffs5
[cnt2
] + workT3
[i
];
295 workT2
[cnt2
- 1] = workT2
[cnt2
- 1] + workT3
[i
];
298 for (i
= 1; i
< BANDS
; i
++) {
299 accum
= (workT2
[i
- 1] + accum
) * q
->weights1
[i
- 1];
300 flcoeffs5
[i
] += accum
;
303 for (i
= 0; i
< BANDS
; i
++)
306 for (i
= 0; i
< BANDS
; i
++) {
307 for (cnt2
= i
- 1; cnt2
> q
->cyclTab2
[i
]; cnt2
--)
308 flcoeffs5
[cnt2
] += workT3
[i
];
309 workT2
[cnt2
+1] += workT3
[i
];
314 for (i
= BANDS
-2; i
>= 0; i
--) {
315 accum
= (workT2
[i
+1] + accum
) * q
->weights2
[i
];
316 flcoeffs5
[i
] += accum
;
317 // there is missing code here, but it seems to never be triggered
322 static void imc_read_level_coeffs(IMCContext
*q
, int stream_format_code
,
328 const uint8_t *cb_sel
;
331 s
= stream_format_code
>> 1;
332 hufftab
[0] = &huffman_vlc
[s
][0];
333 hufftab
[1] = &huffman_vlc
[s
][1];
334 hufftab
[2] = &huffman_vlc
[s
][2];
335 hufftab
[3] = &huffman_vlc
[s
][3];
336 cb_sel
= imc_cb_select
[s
];
338 if (stream_format_code
& 4)
341 levlCoeffs
[0] = get_bits(&q
->gb
, 7);
342 for (i
= start
; i
< BANDS
; i
++) {
343 levlCoeffs
[i
] = get_vlc2(&q
->gb
, hufftab
[cb_sel
[i
]]->table
,
344 hufftab
[cb_sel
[i
]]->bits
, 2);
345 if (levlCoeffs
[i
] == 17)
346 levlCoeffs
[i
] += get_bits(&q
->gb
, 4);
350 static void imc_read_level_coeffs_raw(IMCContext
*q
, int stream_format_code
,
355 q
->coef0_pos
= get_bits(&q
->gb
, 5);
356 levlCoeffs
[0] = get_bits(&q
->gb
, 7);
357 for (i
= 1; i
< BANDS
; i
++)
358 levlCoeffs
[i
] = get_bits(&q
->gb
, 4);
361 static void imc_decode_level_coefficients(IMCContext
*q
, int *levlCoeffBuf
,
362 float *flcoeffs1
, float *flcoeffs2
)
366 // maybe some frequency division thingy
368 flcoeffs1
[0] = 20000.0 / exp2 (levlCoeffBuf
[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
369 flcoeffs2
[0] = log2f(flcoeffs1
[0]);
373 for (i
= 1; i
< BANDS
; i
++) {
374 level
= levlCoeffBuf
[i
];
381 else if (level
<= 24)
386 tmp
*= imc_exp_tab
[15 + level
];
387 tmp2
+= 0.83048 * level
; // 0.83048 = log2(10) * 0.25
395 static void imc_decode_level_coefficients2(IMCContext
*q
, int *levlCoeffBuf
,
396 float *old_floor
, float *flcoeffs1
,
400 /* FIXME maybe flag_buf = noise coding and flcoeffs1 = new scale factors
401 * and flcoeffs2 old scale factors
402 * might be incomplete due to a missing table that is in the binary code
404 for (i
= 0; i
< BANDS
; i
++) {
406 if (levlCoeffBuf
[i
] < 16) {
407 flcoeffs1
[i
] = imc_exp_tab2
[levlCoeffBuf
[i
]] * old_floor
[i
];
408 flcoeffs2
[i
] = (levlCoeffBuf
[i
] - 7) * 0.83048 + flcoeffs2
[i
]; // 0.83048 = log2(10) * 0.25
410 flcoeffs1
[i
] = old_floor
[i
];
415 static void imc_decode_level_coefficients_raw(IMCContext
*q
, int *levlCoeffBuf
,
416 float *flcoeffs1
, float *flcoeffs2
)
422 flcoeffs1
[pos
] = 20000.0 / pow (2, levlCoeffBuf
[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
423 flcoeffs2
[pos
] = log2f(flcoeffs1
[0]);
424 tmp
= flcoeffs1
[pos
];
425 tmp2
= flcoeffs2
[pos
];
428 for (i
= 0; i
< BANDS
; i
++) {
431 level
= *levlCoeffBuf
++;
432 flcoeffs1
[i
] = tmp
* powf(10.0, -level
* 0.4375); //todo tab
433 flcoeffs2
[i
] = tmp2
- 1.4533435415 * level
; // 1.4533435415 = log2(10) * 0.4375
438 * Perform bit allocation depending on bits available
440 static int bit_allocation(IMCContext
*q
, IMCChannel
*chctx
,
441 int stream_format_code
, int freebits
, int flag
)
444 const float limit
= -1.e20
;
453 float lowest
= 1.e10
;
459 for (i
= 0; i
< BANDS
; i
++)
460 highest
= FFMAX(highest
, chctx
->flcoeffs1
[i
]);
462 for (i
= 0; i
< BANDS
- 1; i
++) {
463 if (chctx
->flcoeffs5
[i
] <= 0) {
464 av_log(NULL
, AV_LOG_ERROR
, "flcoeffs5 %f invalid\n", chctx
->flcoeffs5
[i
]);
465 return AVERROR_INVALIDDATA
;
467 chctx
->flcoeffs4
[i
] = chctx
->flcoeffs3
[i
] - log2f(chctx
->flcoeffs5
[i
]);
469 chctx
->flcoeffs4
[BANDS
- 1] = limit
;
471 highest
= highest
* 0.25;
473 for (i
= 0; i
< BANDS
; i
++) {
475 if ((band_tab
[i
+ 1] - band_tab
[i
]) == chctx
->bandWidthT
[i
])
478 if ((band_tab
[i
+ 1] - band_tab
[i
]) > chctx
->bandWidthT
[i
])
481 if (((band_tab
[i
+ 1] - band_tab
[i
]) / 2) >= chctx
->bandWidthT
[i
])
485 return AVERROR_INVALIDDATA
;
487 chctx
->flcoeffs4
[i
] += xTab
[(indx
* 2 + (chctx
->flcoeffs1
[i
] < highest
)) * 2 + flag
];
490 if (stream_format_code
& 0x2) {
491 chctx
->flcoeffs4
[0] = limit
;
492 chctx
->flcoeffs4
[1] = limit
;
493 chctx
->flcoeffs4
[2] = limit
;
494 chctx
->flcoeffs4
[3] = limit
;
497 for (i
= (stream_format_code
& 0x2) ? 4 : 0; i
< BANDS
- 1; i
++) {
498 iacc
+= chctx
->bandWidthT
[i
];
499 summa
+= chctx
->bandWidthT
[i
] * chctx
->flcoeffs4
[i
];
503 return AVERROR_INVALIDDATA
;
505 chctx
->bandWidthT
[BANDS
- 1] = 0;
506 summa
= (summa
* 0.5 - freebits
) / iacc
;
509 for (i
= 0; i
< BANDS
/ 2; i
++) {
510 rres
= summer
- freebits
;
511 if ((rres
>= -8) && (rres
<= 8))
517 for (j
= (stream_format_code
& 0x2) ? 4 : 0; j
< BANDS
; j
++) {
518 cwlen
= av_clipf(((chctx
->flcoeffs4
[j
] * 0.5) - summa
+ 0.5), 0, 6);
520 chctx
->bitsBandT
[j
] = cwlen
;
521 summer
+= chctx
->bandWidthT
[j
] * cwlen
;
524 iacc
+= chctx
->bandWidthT
[j
];
529 if (freebits
< summer
)
536 summa
= (float)(summer
- freebits
) / ((t1
+ 1) * iacc
) + summa
;
539 for (i
= (stream_format_code
& 0x2) ? 4 : 0; i
< BANDS
; i
++) {
540 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++)
541 chctx
->CWlengthT
[j
] = chctx
->bitsBandT
[i
];
544 if (freebits
> summer
) {
545 for (i
= 0; i
< BANDS
; i
++) {
546 workT
[i
] = (chctx
->bitsBandT
[i
] == 6) ? -1.e20
547 : (chctx
->bitsBandT
[i
] * -2 + chctx
->flcoeffs4
[i
] - 0.415);
553 if (highest
<= -1.e20
)
559 for (i
= 0; i
< BANDS
; i
++) {
560 if (workT
[i
] > highest
) {
566 if (highest
> -1.e20
) {
567 workT
[found_indx
] -= 2.0;
568 if (++chctx
->bitsBandT
[found_indx
] == 6)
569 workT
[found_indx
] = -1.e20
;
571 for (j
= band_tab
[found_indx
]; j
< band_tab
[found_indx
+ 1] && (freebits
> summer
); j
++) {
572 chctx
->CWlengthT
[j
]++;
576 } while (freebits
> summer
);
578 if (freebits
< summer
) {
579 for (i
= 0; i
< BANDS
; i
++) {
580 workT
[i
] = chctx
->bitsBandT
[i
] ? (chctx
->bitsBandT
[i
] * -2 + chctx
->flcoeffs4
[i
] + 1.585)
583 if (stream_format_code
& 0x2) {
589 while (freebits
< summer
) {
592 for (i
= 0; i
< BANDS
; i
++) {
593 if (workT
[i
] < lowest
) {
598 // if (lowest >= 1.e10)
600 workT
[low_indx
] = lowest
+ 2.0;
602 if (!--chctx
->bitsBandT
[low_indx
])
603 workT
[low_indx
] = 1.e20
;
605 for (j
= band_tab
[low_indx
]; j
< band_tab
[low_indx
+1] && (freebits
< summer
); j
++) {
606 if (chctx
->CWlengthT
[j
] > 0) {
607 chctx
->CWlengthT
[j
]--;
616 static void imc_get_skip_coeff(IMCContext
*q
, IMCChannel
*chctx
)
620 memset(chctx
->skipFlagBits
, 0, sizeof(chctx
->skipFlagBits
));
621 memset(chctx
->skipFlagCount
, 0, sizeof(chctx
->skipFlagCount
));
622 for (i
= 0; i
< BANDS
; i
++) {
623 if (!chctx
->bandFlagsBuf
[i
] || !chctx
->bandWidthT
[i
])
626 if (!chctx
->skipFlagRaw
[i
]) {
627 chctx
->skipFlagBits
[i
] = band_tab
[i
+ 1] - band_tab
[i
];
629 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
630 chctx
->skipFlags
[j
] = get_bits1(&q
->gb
);
631 if (chctx
->skipFlags
[j
])
632 chctx
->skipFlagCount
[i
]++;
635 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1] - 1; j
+= 2) {
636 if (!get_bits1(&q
->gb
)) { // 0
637 chctx
->skipFlagBits
[i
]++;
638 chctx
->skipFlags
[j
] = 1;
639 chctx
->skipFlags
[j
+ 1] = 1;
640 chctx
->skipFlagCount
[i
] += 2;
642 if (get_bits1(&q
->gb
)) { // 11
643 chctx
->skipFlagBits
[i
] += 2;
644 chctx
->skipFlags
[j
] = 0;
645 chctx
->skipFlags
[j
+ 1] = 1;
646 chctx
->skipFlagCount
[i
]++;
648 chctx
->skipFlagBits
[i
] += 3;
649 chctx
->skipFlags
[j
+ 1] = 0;
650 if (!get_bits1(&q
->gb
)) { // 100
651 chctx
->skipFlags
[j
] = 1;
652 chctx
->skipFlagCount
[i
]++;
654 chctx
->skipFlags
[j
] = 0;
660 if (j
< band_tab
[i
+ 1]) {
661 chctx
->skipFlagBits
[i
]++;
662 if ((chctx
->skipFlags
[j
] = get_bits1(&q
->gb
)))
663 chctx
->skipFlagCount
[i
]++;
670 * Increase highest' band coefficient sizes as some bits won't be used
672 static void imc_adjust_bit_allocation(IMCContext
*q
, IMCChannel
*chctx
,
681 for (i
= 0; i
< BANDS
; i
++) {
682 workT
[i
] = (chctx
->bitsBandT
[i
] == 6) ? -1.e20
683 : (chctx
->bitsBandT
[i
] * -2 + chctx
->flcoeffs4
[i
] - 0.415);
686 while (corrected
< summer
) {
687 if (highest
<= -1.e20
)
692 for (i
= 0; i
< BANDS
; i
++) {
693 if (workT
[i
] > highest
) {
699 if (highest
> -1.e20
) {
700 workT
[found_indx
] -= 2.0;
701 if (++(chctx
->bitsBandT
[found_indx
]) == 6)
702 workT
[found_indx
] = -1.e20
;
704 for (j
= band_tab
[found_indx
]; j
< band_tab
[found_indx
+1] && (corrected
< summer
); j
++) {
705 if (!chctx
->skipFlags
[j
] && (chctx
->CWlengthT
[j
] < 6)) {
706 chctx
->CWlengthT
[j
]++;
714 static void imc_imdct256(IMCContext
*q
, IMCChannel
*chctx
, int channels
)
718 float *dst1
= q
->out_samples
;
719 float *dst2
= q
->out_samples
+ (COEFFS
- 1);
722 for (i
= 0; i
< COEFFS
/ 2; i
++) {
723 q
->samples
[i
].re
= -(q
->pre_coef1
[i
] * chctx
->CWdecoded
[COEFFS
- 1 - i
* 2]) -
724 (q
->pre_coef2
[i
] * chctx
->CWdecoded
[i
* 2]);
725 q
->samples
[i
].im
= (q
->pre_coef2
[i
] * chctx
->CWdecoded
[COEFFS
- 1 - i
* 2]) -
726 (q
->pre_coef1
[i
] * chctx
->CWdecoded
[i
* 2]);
730 q
->fft
.fft_permute(&q
->fft
, q
->samples
);
731 q
->fft
.fft_calc(&q
->fft
, q
->samples
);
733 /* postrotation, window and reorder */
734 for (i
= 0; i
< COEFFS
/ 2; i
++) {
735 re
= ( q
->samples
[i
].re
* q
->post_cos
[i
]) + (-q
->samples
[i
].im
* q
->post_sin
[i
]);
736 im
= (-q
->samples
[i
].im
* q
->post_cos
[i
]) - ( q
->samples
[i
].re
* q
->post_sin
[i
]);
737 *dst1
= (q
->mdct_sine_window
[COEFFS
- 1 - i
* 2] * chctx
->last_fft_im
[i
])
738 + (q
->mdct_sine_window
[i
* 2] * re
);
739 *dst2
= (q
->mdct_sine_window
[i
* 2] * chctx
->last_fft_im
[i
])
740 - (q
->mdct_sine_window
[COEFFS
- 1 - i
* 2] * re
);
743 chctx
->last_fft_im
[i
] = im
;
747 static int inverse_quant_coeff(IMCContext
*q
, IMCChannel
*chctx
,
748 int stream_format_code
)
751 int middle_value
, cw_len
, max_size
;
752 const float *quantizer
;
754 for (i
= 0; i
< BANDS
; i
++) {
755 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
756 chctx
->CWdecoded
[j
] = 0;
757 cw_len
= chctx
->CWlengthT
[j
];
759 if (cw_len
<= 0 || chctx
->skipFlags
[j
])
762 max_size
= 1 << cw_len
;
763 middle_value
= max_size
>> 1;
765 if (chctx
->codewords
[j
] >= max_size
|| chctx
->codewords
[j
] < 0)
766 return AVERROR_INVALIDDATA
;
769 quantizer
= imc_quantizer2
[(stream_format_code
& 2) >> 1];
770 if (chctx
->codewords
[j
] >= middle_value
)
771 chctx
->CWdecoded
[j
] = quantizer
[chctx
->codewords
[j
] - 8] * chctx
->flcoeffs6
[i
];
773 chctx
->CWdecoded
[j
] = -quantizer
[max_size
- chctx
->codewords
[j
] - 8 - 1] * chctx
->flcoeffs6
[i
];
775 quantizer
= imc_quantizer1
[((stream_format_code
& 2) >> 1) | (chctx
->bandFlagsBuf
[i
] << 1)];
776 if (chctx
->codewords
[j
] >= middle_value
)
777 chctx
->CWdecoded
[j
] = quantizer
[chctx
->codewords
[j
] - 1] * chctx
->flcoeffs6
[i
];
779 chctx
->CWdecoded
[j
] = -quantizer
[max_size
- 2 - chctx
->codewords
[j
]] * chctx
->flcoeffs6
[i
];
787 static int imc_get_coeffs(IMCContext
*q
, IMCChannel
*chctx
)
789 int i
, j
, cw_len
, cw
;
791 for (i
= 0; i
< BANDS
; i
++) {
792 if (!chctx
->sumLenArr
[i
])
794 if (chctx
->bandFlagsBuf
[i
] || chctx
->bandWidthT
[i
]) {
795 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
796 cw_len
= chctx
->CWlengthT
[j
];
799 if (get_bits_count(&q
->gb
) + cw_len
> 512) {
800 av_dlog(NULL
, "Band %i coeff %i cw_len %i\n", i
, j
, cw_len
);
801 return AVERROR_INVALIDDATA
;
804 if (cw_len
&& (!chctx
->bandFlagsBuf
[i
] || !chctx
->skipFlags
[j
]))
805 cw
= get_bits(&q
->gb
, cw_len
);
807 chctx
->codewords
[j
] = cw
;
814 static void imc_refine_bit_allocation(IMCContext
*q
, IMCChannel
*chctx
)
819 for (i
= 0; i
< BANDS
; i
++) {
820 chctx
->sumLenArr
[i
] = 0;
821 chctx
->skipFlagRaw
[i
] = 0;
822 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++)
823 chctx
->sumLenArr
[i
] += chctx
->CWlengthT
[j
];
824 if (chctx
->bandFlagsBuf
[i
])
825 if ((((band_tab
[i
+ 1] - band_tab
[i
]) * 1.5) > chctx
->sumLenArr
[i
]) && (chctx
->sumLenArr
[i
] > 0))
826 chctx
->skipFlagRaw
[i
] = 1;
829 imc_get_skip_coeff(q
, chctx
);
831 for (i
= 0; i
< BANDS
; i
++) {
832 chctx
->flcoeffs6
[i
] = chctx
->flcoeffs1
[i
];
833 /* band has flag set and at least one coded coefficient */
834 if (chctx
->bandFlagsBuf
[i
] && (band_tab
[i
+ 1] - band_tab
[i
]) != chctx
->skipFlagCount
[i
]) {
835 chctx
->flcoeffs6
[i
] *= q
->sqrt_tab
[ band_tab
[i
+ 1] - band_tab
[i
]] /
836 q
->sqrt_tab
[(band_tab
[i
+ 1] - band_tab
[i
] - chctx
->skipFlagCount
[i
])];
840 /* calculate bits left, bits needed and adjust bit allocation */
843 for (i
= 0; i
< BANDS
; i
++) {
844 if (chctx
->bandFlagsBuf
[i
]) {
845 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
846 if (chctx
->skipFlags
[j
]) {
847 summer
+= chctx
->CWlengthT
[j
];
848 chctx
->CWlengthT
[j
] = 0;
851 bits
+= chctx
->skipFlagBits
[i
];
852 summer
-= chctx
->skipFlagBits
[i
];
855 imc_adjust_bit_allocation(q
, chctx
, summer
);
858 static int imc_decode_block(AVCodecContext
*avctx
, IMCContext
*q
, int ch
)
860 int stream_format_code
;
861 int imc_hdr
, i
, j
, ret
;
864 int counter
, bitscount
;
865 IMCChannel
*chctx
= q
->chctx
+ ch
;
868 /* Check the frame header */
869 imc_hdr
= get_bits(&q
->gb
, 9);
870 if (imc_hdr
& 0x18) {
871 av_log(avctx
, AV_LOG_ERROR
, "frame header check failed!\n");
872 av_log(avctx
, AV_LOG_ERROR
, "got %X.\n", imc_hdr
);
873 return AVERROR_INVALIDDATA
;
875 stream_format_code
= get_bits(&q
->gb
, 3);
877 if (stream_format_code
& 0x04)
878 chctx
->decoder_reset
= 1;
880 if (chctx
->decoder_reset
) {
881 for (i
= 0; i
< BANDS
; i
++)
882 chctx
->old_floor
[i
] = 1.0;
883 for (i
= 0; i
< COEFFS
; i
++)
884 chctx
->CWdecoded
[i
] = 0;
885 chctx
->decoder_reset
= 0;
888 flag
= get_bits1(&q
->gb
);
889 if (stream_format_code
& 0x1)
890 imc_read_level_coeffs_raw(q
, stream_format_code
, chctx
->levlCoeffBuf
);
892 imc_read_level_coeffs(q
, stream_format_code
, chctx
->levlCoeffBuf
);
894 if (stream_format_code
& 0x1)
895 imc_decode_level_coefficients_raw(q
, chctx
->levlCoeffBuf
,
896 chctx
->flcoeffs1
, chctx
->flcoeffs2
);
897 else if (stream_format_code
& 0x4)
898 imc_decode_level_coefficients(q
, chctx
->levlCoeffBuf
,
899 chctx
->flcoeffs1
, chctx
->flcoeffs2
);
901 imc_decode_level_coefficients2(q
, chctx
->levlCoeffBuf
, chctx
->old_floor
,
902 chctx
->flcoeffs1
, chctx
->flcoeffs2
);
904 for(i
=0; i
<BANDS
; i
++) {
905 if(chctx
->flcoeffs1
[i
] > INT_MAX
) {
906 av_log(avctx
, AV_LOG_ERROR
, "scalefactor out of range\n");
907 return AVERROR_INVALIDDATA
;
911 memcpy(chctx
->old_floor
, chctx
->flcoeffs1
, 32 * sizeof(float));
914 if (stream_format_code
& 0x1) {
915 for (i
= 0; i
< BANDS
; i
++) {
916 chctx
->bandWidthT
[i
] = band_tab
[i
+ 1] - band_tab
[i
];
917 chctx
->bandFlagsBuf
[i
] = 0;
918 chctx
->flcoeffs3
[i
] = chctx
->flcoeffs2
[i
] * 2;
919 chctx
->flcoeffs5
[i
] = 1.0;
922 for (i
= 0; i
< BANDS
; i
++) {
923 if (chctx
->levlCoeffBuf
[i
] == 16) {
924 chctx
->bandWidthT
[i
] = 0;
927 chctx
->bandWidthT
[i
] = band_tab
[i
+ 1] - band_tab
[i
];
930 memset(chctx
->bandFlagsBuf
, 0, BANDS
* sizeof(int));
931 for (i
= 0; i
< BANDS
- 1; i
++)
932 if (chctx
->bandWidthT
[i
])
933 chctx
->bandFlagsBuf
[i
] = get_bits1(&q
->gb
);
935 imc_calculate_coeffs(q
, chctx
->flcoeffs1
, chctx
->flcoeffs2
,
936 chctx
->bandWidthT
, chctx
->flcoeffs3
,
941 /* first 4 bands will be assigned 5 bits per coefficient */
942 if (stream_format_code
& 0x2) {
945 chctx
->bitsBandT
[0] = 5;
946 chctx
->CWlengthT
[0] = 5;
947 chctx
->CWlengthT
[1] = 5;
948 chctx
->CWlengthT
[2] = 5;
949 for (i
= 1; i
< 4; i
++) {
950 if (stream_format_code
& 0x1)
953 bits
= (chctx
->levlCoeffBuf
[i
] == 16) ? 0 : 5;
954 chctx
->bitsBandT
[i
] = bits
;
955 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
956 chctx
->CWlengthT
[j
] = bits
;
961 if (avctx
->codec_id
== AV_CODEC_ID_IAC
) {
962 bitscount
+= !!chctx
->bandWidthT
[BANDS
- 1];
963 if (!(stream_format_code
& 0x2))
967 if ((ret
= bit_allocation(q
, chctx
, stream_format_code
,
968 512 - bitscount
- get_bits_count(&q
->gb
),
970 av_log(avctx
, AV_LOG_ERROR
, "Bit allocations failed\n");
971 chctx
->decoder_reset
= 1;
975 if (stream_format_code
& 0x1) {
976 for (i
= 0; i
< BANDS
; i
++)
977 chctx
->skipFlags
[i
] = 0;
979 imc_refine_bit_allocation(q
, chctx
);
982 for (i
= 0; i
< BANDS
; i
++) {
983 chctx
->sumLenArr
[i
] = 0;
985 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++)
986 if (!chctx
->skipFlags
[j
])
987 chctx
->sumLenArr
[i
] += chctx
->CWlengthT
[j
];
990 memset(chctx
->codewords
, 0, sizeof(chctx
->codewords
));
992 if (imc_get_coeffs(q
, chctx
) < 0) {
993 av_log(avctx
, AV_LOG_ERROR
, "Read coefficients failed\n");
994 chctx
->decoder_reset
= 1;
995 return AVERROR_INVALIDDATA
;
998 if (inverse_quant_coeff(q
, chctx
, stream_format_code
) < 0) {
999 av_log(avctx
, AV_LOG_ERROR
, "Inverse quantization of coefficients failed\n");
1000 chctx
->decoder_reset
= 1;
1001 return AVERROR_INVALIDDATA
;
1004 memset(chctx
->skipFlags
, 0, sizeof(chctx
->skipFlags
));
1006 imc_imdct256(q
, chctx
, avctx
->channels
);
1011 static int imc_decode_frame(AVCodecContext
*avctx
, void *data
,
1012 int *got_frame_ptr
, AVPacket
*avpkt
)
1014 AVFrame
*frame
= data
;
1015 const uint8_t *buf
= avpkt
->data
;
1016 int buf_size
= avpkt
->size
;
1019 IMCContext
*q
= avctx
->priv_data
;
1021 LOCAL_ALIGNED_16(uint16_t, buf16
, [IMC_BLOCK_SIZE
/ 2 + FF_INPUT_BUFFER_PADDING_SIZE
/2]);
1023 if (buf_size
< IMC_BLOCK_SIZE
* avctx
->channels
) {
1024 av_log(avctx
, AV_LOG_ERROR
, "frame too small!\n");
1025 return AVERROR_INVALIDDATA
;
1028 /* get output buffer */
1029 frame
->nb_samples
= COEFFS
;
1030 if ((ret
= ff_get_buffer(avctx
, frame
, 0)) < 0)
1033 for (i
= 0; i
< avctx
->channels
; i
++) {
1034 q
->out_samples
= (float *)frame
->extended_data
[i
];
1036 q
->bdsp
.bswap16_buf(buf16
, (const uint16_t *) buf
, IMC_BLOCK_SIZE
/ 2);
1038 init_get_bits(&q
->gb
, (const uint8_t*)buf16
, IMC_BLOCK_SIZE
* 8);
1040 buf
+= IMC_BLOCK_SIZE
;
1042 if ((ret
= imc_decode_block(avctx
, q
, i
)) < 0)
1046 if (avctx
->channels
== 2) {
1047 q
->fdsp
.butterflies_float((float *)frame
->extended_data
[0],
1048 (float *)frame
->extended_data
[1], COEFFS
);
1053 return IMC_BLOCK_SIZE
* avctx
->channels
;
1057 static av_cold
int imc_decode_close(AVCodecContext
* avctx
)
1059 IMCContext
*q
= avctx
->priv_data
;
1061 ff_fft_end(&q
->fft
);
1066 static av_cold
void flush(AVCodecContext
*avctx
)
1068 IMCContext
*q
= avctx
->priv_data
;
1070 q
->chctx
[0].decoder_reset
=
1071 q
->chctx
[1].decoder_reset
= 1;
1074 #if CONFIG_IMC_DECODER
1075 AVCodec ff_imc_decoder
= {
1077 .long_name
= NULL_IF_CONFIG_SMALL("IMC (Intel Music Coder)"),
1078 .type
= AVMEDIA_TYPE_AUDIO
,
1079 .id
= AV_CODEC_ID_IMC
,
1080 .priv_data_size
= sizeof(IMCContext
),
1081 .init
= imc_decode_init
,
1082 .close
= imc_decode_close
,
1083 .decode
= imc_decode_frame
,
1085 .capabilities
= CODEC_CAP_DR1
,
1086 .sample_fmts
= (const enum AVSampleFormat
[]) { AV_SAMPLE_FMT_FLTP
,
1087 AV_SAMPLE_FMT_NONE
},
1090 #if CONFIG_IAC_DECODER
1091 AVCodec ff_iac_decoder
= {
1093 .long_name
= NULL_IF_CONFIG_SMALL("IAC (Indeo Audio Coder)"),
1094 .type
= AVMEDIA_TYPE_AUDIO
,
1095 .id
= AV_CODEC_ID_IAC
,
1096 .priv_data_size
= sizeof(IMCContext
),
1097 .init
= imc_decode_init
,
1098 .close
= imc_decode_close
,
1099 .decode
= imc_decode_frame
,
1101 .capabilities
= CODEC_CAP_DR1
,
1102 .sample_fmts
= (const enum AVSampleFormat
[]) { AV_SAMPLE_FMT_FLTP
,
1103 AV_SAMPLE_FMT_NONE
},