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 q
->fdsp
= avpriv_float_dsp_alloc(avctx
->flags
& CODEC_FLAG_BITEXACT
);
263 return AVERROR(ENOMEM
);
266 avctx
->sample_fmt
= AV_SAMPLE_FMT_FLTP
;
267 avctx
->channel_layout
= avctx
->channels
== 1 ? AV_CH_LAYOUT_MONO
268 : AV_CH_LAYOUT_STEREO
;
273 static void imc_calculate_coeffs(IMCContext
*q
, float *flcoeffs1
,
274 float *flcoeffs2
, int *bandWidthT
,
275 float *flcoeffs3
, float *flcoeffs5
)
280 float snr_limit
= 1.e
-30;
284 for (i
= 0; i
< BANDS
; i
++) {
285 flcoeffs5
[i
] = workT2
[i
] = 0.0;
287 workT1
[i
] = flcoeffs1
[i
] * flcoeffs1
[i
];
288 flcoeffs3
[i
] = 2.0 * flcoeffs2
[i
];
291 flcoeffs3
[i
] = -30000.0;
293 workT3
[i
] = bandWidthT
[i
] * workT1
[i
] * 0.01;
294 if (workT3
[i
] <= snr_limit
)
298 for (i
= 0; i
< BANDS
; i
++) {
299 for (cnt2
= i
; cnt2
< q
->cyclTab
[i
]; cnt2
++)
300 flcoeffs5
[cnt2
] = flcoeffs5
[cnt2
] + workT3
[i
];
301 workT2
[cnt2
- 1] = workT2
[cnt2
- 1] + workT3
[i
];
304 for (i
= 1; i
< BANDS
; i
++) {
305 accum
= (workT2
[i
- 1] + accum
) * q
->weights1
[i
- 1];
306 flcoeffs5
[i
] += accum
;
309 for (i
= 0; i
< BANDS
; i
++)
312 for (i
= 0; i
< BANDS
; i
++) {
313 for (cnt2
= i
- 1; cnt2
> q
->cyclTab2
[i
]; cnt2
--)
314 flcoeffs5
[cnt2
] += workT3
[i
];
315 workT2
[cnt2
+1] += workT3
[i
];
320 for (i
= BANDS
-2; i
>= 0; i
--) {
321 accum
= (workT2
[i
+1] + accum
) * q
->weights2
[i
];
322 flcoeffs5
[i
] += accum
;
323 // there is missing code here, but it seems to never be triggered
328 static void imc_read_level_coeffs(IMCContext
*q
, int stream_format_code
,
334 const uint8_t *cb_sel
;
337 s
= stream_format_code
>> 1;
338 hufftab
[0] = &huffman_vlc
[s
][0];
339 hufftab
[1] = &huffman_vlc
[s
][1];
340 hufftab
[2] = &huffman_vlc
[s
][2];
341 hufftab
[3] = &huffman_vlc
[s
][3];
342 cb_sel
= imc_cb_select
[s
];
344 if (stream_format_code
& 4)
347 levlCoeffs
[0] = get_bits(&q
->gb
, 7);
348 for (i
= start
; i
< BANDS
; i
++) {
349 levlCoeffs
[i
] = get_vlc2(&q
->gb
, hufftab
[cb_sel
[i
]]->table
,
350 hufftab
[cb_sel
[i
]]->bits
, 2);
351 if (levlCoeffs
[i
] == 17)
352 levlCoeffs
[i
] += get_bits(&q
->gb
, 4);
356 static void imc_read_level_coeffs_raw(IMCContext
*q
, int stream_format_code
,
361 q
->coef0_pos
= get_bits(&q
->gb
, 5);
362 levlCoeffs
[0] = get_bits(&q
->gb
, 7);
363 for (i
= 1; i
< BANDS
; i
++)
364 levlCoeffs
[i
] = get_bits(&q
->gb
, 4);
367 static void imc_decode_level_coefficients(IMCContext
*q
, int *levlCoeffBuf
,
368 float *flcoeffs1
, float *flcoeffs2
)
372 // maybe some frequency division thingy
374 flcoeffs1
[0] = 20000.0 / exp2 (levlCoeffBuf
[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
375 flcoeffs2
[0] = log2f(flcoeffs1
[0]);
379 for (i
= 1; i
< BANDS
; i
++) {
380 level
= levlCoeffBuf
[i
];
387 else if (level
<= 24)
392 tmp
*= imc_exp_tab
[15 + level
];
393 tmp2
+= 0.83048 * level
; // 0.83048 = log2(10) * 0.25
401 static void imc_decode_level_coefficients2(IMCContext
*q
, int *levlCoeffBuf
,
402 float *old_floor
, float *flcoeffs1
,
406 /* FIXME maybe flag_buf = noise coding and flcoeffs1 = new scale factors
407 * and flcoeffs2 old scale factors
408 * might be incomplete due to a missing table that is in the binary code
410 for (i
= 0; i
< BANDS
; i
++) {
412 if (levlCoeffBuf
[i
] < 16) {
413 flcoeffs1
[i
] = imc_exp_tab2
[levlCoeffBuf
[i
]] * old_floor
[i
];
414 flcoeffs2
[i
] = (levlCoeffBuf
[i
] - 7) * 0.83048 + flcoeffs2
[i
]; // 0.83048 = log2(10) * 0.25
416 flcoeffs1
[i
] = old_floor
[i
];
421 static void imc_decode_level_coefficients_raw(IMCContext
*q
, int *levlCoeffBuf
,
422 float *flcoeffs1
, float *flcoeffs2
)
428 flcoeffs1
[pos
] = 20000.0 / pow (2, levlCoeffBuf
[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
429 flcoeffs2
[pos
] = log2f(flcoeffs1
[0]);
430 tmp
= flcoeffs1
[pos
];
431 tmp2
= flcoeffs2
[pos
];
434 for (i
= 0; i
< BANDS
; i
++) {
437 level
= *levlCoeffBuf
++;
438 flcoeffs1
[i
] = tmp
* powf(10.0, -level
* 0.4375); //todo tab
439 flcoeffs2
[i
] = tmp2
- 1.4533435415 * level
; // 1.4533435415 = log2(10) * 0.4375
444 * Perform bit allocation depending on bits available
446 static int bit_allocation(IMCContext
*q
, IMCChannel
*chctx
,
447 int stream_format_code
, int freebits
, int flag
)
450 const float limit
= -1.e20
;
459 float lowest
= 1.e10
;
465 for (i
= 0; i
< BANDS
; i
++)
466 highest
= FFMAX(highest
, chctx
->flcoeffs1
[i
]);
468 for (i
= 0; i
< BANDS
- 1; i
++) {
469 if (chctx
->flcoeffs5
[i
] <= 0) {
470 av_log(NULL
, AV_LOG_ERROR
, "flcoeffs5 %f invalid\n", chctx
->flcoeffs5
[i
]);
471 return AVERROR_INVALIDDATA
;
473 chctx
->flcoeffs4
[i
] = chctx
->flcoeffs3
[i
] - log2f(chctx
->flcoeffs5
[i
]);
475 chctx
->flcoeffs4
[BANDS
- 1] = limit
;
477 highest
= highest
* 0.25;
479 for (i
= 0; i
< BANDS
; i
++) {
481 if ((band_tab
[i
+ 1] - band_tab
[i
]) == chctx
->bandWidthT
[i
])
484 if ((band_tab
[i
+ 1] - band_tab
[i
]) > chctx
->bandWidthT
[i
])
487 if (((band_tab
[i
+ 1] - band_tab
[i
]) / 2) >= chctx
->bandWidthT
[i
])
491 return AVERROR_INVALIDDATA
;
493 chctx
->flcoeffs4
[i
] += xTab
[(indx
* 2 + (chctx
->flcoeffs1
[i
] < highest
)) * 2 + flag
];
496 if (stream_format_code
& 0x2) {
497 chctx
->flcoeffs4
[0] = limit
;
498 chctx
->flcoeffs4
[1] = limit
;
499 chctx
->flcoeffs4
[2] = limit
;
500 chctx
->flcoeffs4
[3] = limit
;
503 for (i
= (stream_format_code
& 0x2) ? 4 : 0; i
< BANDS
- 1; i
++) {
504 iacc
+= chctx
->bandWidthT
[i
];
505 summa
+= chctx
->bandWidthT
[i
] * chctx
->flcoeffs4
[i
];
509 return AVERROR_INVALIDDATA
;
511 chctx
->bandWidthT
[BANDS
- 1] = 0;
512 summa
= (summa
* 0.5 - freebits
) / iacc
;
515 for (i
= 0; i
< BANDS
/ 2; i
++) {
516 rres
= summer
- freebits
;
517 if ((rres
>= -8) && (rres
<= 8))
523 for (j
= (stream_format_code
& 0x2) ? 4 : 0; j
< BANDS
; j
++) {
524 cwlen
= av_clipf(((chctx
->flcoeffs4
[j
] * 0.5) - summa
+ 0.5), 0, 6);
526 chctx
->bitsBandT
[j
] = cwlen
;
527 summer
+= chctx
->bandWidthT
[j
] * cwlen
;
530 iacc
+= chctx
->bandWidthT
[j
];
535 if (freebits
< summer
)
542 summa
= (float)(summer
- freebits
) / ((t1
+ 1) * iacc
) + summa
;
545 for (i
= (stream_format_code
& 0x2) ? 4 : 0; i
< BANDS
; i
++) {
546 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++)
547 chctx
->CWlengthT
[j
] = chctx
->bitsBandT
[i
];
550 if (freebits
> summer
) {
551 for (i
= 0; i
< BANDS
; i
++) {
552 workT
[i
] = (chctx
->bitsBandT
[i
] == 6) ? -1.e20
553 : (chctx
->bitsBandT
[i
] * -2 + chctx
->flcoeffs4
[i
] - 0.415);
559 if (highest
<= -1.e20
)
565 for (i
= 0; i
< BANDS
; i
++) {
566 if (workT
[i
] > highest
) {
572 if (highest
> -1.e20
) {
573 workT
[found_indx
] -= 2.0;
574 if (++chctx
->bitsBandT
[found_indx
] == 6)
575 workT
[found_indx
] = -1.e20
;
577 for (j
= band_tab
[found_indx
]; j
< band_tab
[found_indx
+ 1] && (freebits
> summer
); j
++) {
578 chctx
->CWlengthT
[j
]++;
582 } while (freebits
> summer
);
584 if (freebits
< summer
) {
585 for (i
= 0; i
< BANDS
; i
++) {
586 workT
[i
] = chctx
->bitsBandT
[i
] ? (chctx
->bitsBandT
[i
] * -2 + chctx
->flcoeffs4
[i
] + 1.585)
589 if (stream_format_code
& 0x2) {
595 while (freebits
< summer
) {
598 for (i
= 0; i
< BANDS
; i
++) {
599 if (workT
[i
] < lowest
) {
604 // if (lowest >= 1.e10)
606 workT
[low_indx
] = lowest
+ 2.0;
608 if (!--chctx
->bitsBandT
[low_indx
])
609 workT
[low_indx
] = 1.e20
;
611 for (j
= band_tab
[low_indx
]; j
< band_tab
[low_indx
+1] && (freebits
< summer
); j
++) {
612 if (chctx
->CWlengthT
[j
] > 0) {
613 chctx
->CWlengthT
[j
]--;
622 static void imc_get_skip_coeff(IMCContext
*q
, IMCChannel
*chctx
)
626 memset(chctx
->skipFlagBits
, 0, sizeof(chctx
->skipFlagBits
));
627 memset(chctx
->skipFlagCount
, 0, sizeof(chctx
->skipFlagCount
));
628 for (i
= 0; i
< BANDS
; i
++) {
629 if (!chctx
->bandFlagsBuf
[i
] || !chctx
->bandWidthT
[i
])
632 if (!chctx
->skipFlagRaw
[i
]) {
633 chctx
->skipFlagBits
[i
] = band_tab
[i
+ 1] - band_tab
[i
];
635 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
636 chctx
->skipFlags
[j
] = get_bits1(&q
->gb
);
637 if (chctx
->skipFlags
[j
])
638 chctx
->skipFlagCount
[i
]++;
641 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1] - 1; j
+= 2) {
642 if (!get_bits1(&q
->gb
)) { // 0
643 chctx
->skipFlagBits
[i
]++;
644 chctx
->skipFlags
[j
] = 1;
645 chctx
->skipFlags
[j
+ 1] = 1;
646 chctx
->skipFlagCount
[i
] += 2;
648 if (get_bits1(&q
->gb
)) { // 11
649 chctx
->skipFlagBits
[i
] += 2;
650 chctx
->skipFlags
[j
] = 0;
651 chctx
->skipFlags
[j
+ 1] = 1;
652 chctx
->skipFlagCount
[i
]++;
654 chctx
->skipFlagBits
[i
] += 3;
655 chctx
->skipFlags
[j
+ 1] = 0;
656 if (!get_bits1(&q
->gb
)) { // 100
657 chctx
->skipFlags
[j
] = 1;
658 chctx
->skipFlagCount
[i
]++;
660 chctx
->skipFlags
[j
] = 0;
666 if (j
< band_tab
[i
+ 1]) {
667 chctx
->skipFlagBits
[i
]++;
668 if ((chctx
->skipFlags
[j
] = get_bits1(&q
->gb
)))
669 chctx
->skipFlagCount
[i
]++;
676 * Increase highest' band coefficient sizes as some bits won't be used
678 static void imc_adjust_bit_allocation(IMCContext
*q
, IMCChannel
*chctx
,
687 for (i
= 0; i
< BANDS
; i
++) {
688 workT
[i
] = (chctx
->bitsBandT
[i
] == 6) ? -1.e20
689 : (chctx
->bitsBandT
[i
] * -2 + chctx
->flcoeffs4
[i
] - 0.415);
692 while (corrected
< summer
) {
693 if (highest
<= -1.e20
)
698 for (i
= 0; i
< BANDS
; i
++) {
699 if (workT
[i
] > highest
) {
705 if (highest
> -1.e20
) {
706 workT
[found_indx
] -= 2.0;
707 if (++(chctx
->bitsBandT
[found_indx
]) == 6)
708 workT
[found_indx
] = -1.e20
;
710 for (j
= band_tab
[found_indx
]; j
< band_tab
[found_indx
+1] && (corrected
< summer
); j
++) {
711 if (!chctx
->skipFlags
[j
] && (chctx
->CWlengthT
[j
] < 6)) {
712 chctx
->CWlengthT
[j
]++;
720 static void imc_imdct256(IMCContext
*q
, IMCChannel
*chctx
, int channels
)
724 float *dst1
= q
->out_samples
;
725 float *dst2
= q
->out_samples
+ (COEFFS
- 1);
728 for (i
= 0; i
< COEFFS
/ 2; i
++) {
729 q
->samples
[i
].re
= -(q
->pre_coef1
[i
] * chctx
->CWdecoded
[COEFFS
- 1 - i
* 2]) -
730 (q
->pre_coef2
[i
] * chctx
->CWdecoded
[i
* 2]);
731 q
->samples
[i
].im
= (q
->pre_coef2
[i
] * chctx
->CWdecoded
[COEFFS
- 1 - i
* 2]) -
732 (q
->pre_coef1
[i
] * chctx
->CWdecoded
[i
* 2]);
736 q
->fft
.fft_permute(&q
->fft
, q
->samples
);
737 q
->fft
.fft_calc(&q
->fft
, q
->samples
);
739 /* postrotation, window and reorder */
740 for (i
= 0; i
< COEFFS
/ 2; i
++) {
741 re
= ( q
->samples
[i
].re
* q
->post_cos
[i
]) + (-q
->samples
[i
].im
* q
->post_sin
[i
]);
742 im
= (-q
->samples
[i
].im
* q
->post_cos
[i
]) - ( q
->samples
[i
].re
* q
->post_sin
[i
]);
743 *dst1
= (q
->mdct_sine_window
[COEFFS
- 1 - i
* 2] * chctx
->last_fft_im
[i
])
744 + (q
->mdct_sine_window
[i
* 2] * re
);
745 *dst2
= (q
->mdct_sine_window
[i
* 2] * chctx
->last_fft_im
[i
])
746 - (q
->mdct_sine_window
[COEFFS
- 1 - i
* 2] * re
);
749 chctx
->last_fft_im
[i
] = im
;
753 static int inverse_quant_coeff(IMCContext
*q
, IMCChannel
*chctx
,
754 int stream_format_code
)
757 int middle_value
, cw_len
, max_size
;
758 const float *quantizer
;
760 for (i
= 0; i
< BANDS
; i
++) {
761 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
762 chctx
->CWdecoded
[j
] = 0;
763 cw_len
= chctx
->CWlengthT
[j
];
765 if (cw_len
<= 0 || chctx
->skipFlags
[j
])
768 max_size
= 1 << cw_len
;
769 middle_value
= max_size
>> 1;
771 if (chctx
->codewords
[j
] >= max_size
|| chctx
->codewords
[j
] < 0)
772 return AVERROR_INVALIDDATA
;
775 quantizer
= imc_quantizer2
[(stream_format_code
& 2) >> 1];
776 if (chctx
->codewords
[j
] >= middle_value
)
777 chctx
->CWdecoded
[j
] = quantizer
[chctx
->codewords
[j
] - 8] * chctx
->flcoeffs6
[i
];
779 chctx
->CWdecoded
[j
] = -quantizer
[max_size
- chctx
->codewords
[j
] - 8 - 1] * chctx
->flcoeffs6
[i
];
781 quantizer
= imc_quantizer1
[((stream_format_code
& 2) >> 1) | (chctx
->bandFlagsBuf
[i
] << 1)];
782 if (chctx
->codewords
[j
] >= middle_value
)
783 chctx
->CWdecoded
[j
] = quantizer
[chctx
->codewords
[j
] - 1] * chctx
->flcoeffs6
[i
];
785 chctx
->CWdecoded
[j
] = -quantizer
[max_size
- 2 - chctx
->codewords
[j
]] * chctx
->flcoeffs6
[i
];
793 static int imc_get_coeffs(IMCContext
*q
, IMCChannel
*chctx
)
795 int i
, j
, cw_len
, cw
;
797 for (i
= 0; i
< BANDS
; i
++) {
798 if (!chctx
->sumLenArr
[i
])
800 if (chctx
->bandFlagsBuf
[i
] || chctx
->bandWidthT
[i
]) {
801 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
802 cw_len
= chctx
->CWlengthT
[j
];
805 if (get_bits_count(&q
->gb
) + cw_len
> 512) {
806 av_dlog(NULL
, "Band %i coeff %i cw_len %i\n", i
, j
, cw_len
);
807 return AVERROR_INVALIDDATA
;
810 if (cw_len
&& (!chctx
->bandFlagsBuf
[i
] || !chctx
->skipFlags
[j
]))
811 cw
= get_bits(&q
->gb
, cw_len
);
813 chctx
->codewords
[j
] = cw
;
820 static void imc_refine_bit_allocation(IMCContext
*q
, IMCChannel
*chctx
)
825 for (i
= 0; i
< BANDS
; i
++) {
826 chctx
->sumLenArr
[i
] = 0;
827 chctx
->skipFlagRaw
[i
] = 0;
828 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++)
829 chctx
->sumLenArr
[i
] += chctx
->CWlengthT
[j
];
830 if (chctx
->bandFlagsBuf
[i
])
831 if ((((band_tab
[i
+ 1] - band_tab
[i
]) * 1.5) > chctx
->sumLenArr
[i
]) && (chctx
->sumLenArr
[i
] > 0))
832 chctx
->skipFlagRaw
[i
] = 1;
835 imc_get_skip_coeff(q
, chctx
);
837 for (i
= 0; i
< BANDS
; i
++) {
838 chctx
->flcoeffs6
[i
] = chctx
->flcoeffs1
[i
];
839 /* band has flag set and at least one coded coefficient */
840 if (chctx
->bandFlagsBuf
[i
] && (band_tab
[i
+ 1] - band_tab
[i
]) != chctx
->skipFlagCount
[i
]) {
841 chctx
->flcoeffs6
[i
] *= q
->sqrt_tab
[ band_tab
[i
+ 1] - band_tab
[i
]] /
842 q
->sqrt_tab
[(band_tab
[i
+ 1] - band_tab
[i
] - chctx
->skipFlagCount
[i
])];
846 /* calculate bits left, bits needed and adjust bit allocation */
849 for (i
= 0; i
< BANDS
; i
++) {
850 if (chctx
->bandFlagsBuf
[i
]) {
851 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
852 if (chctx
->skipFlags
[j
]) {
853 summer
+= chctx
->CWlengthT
[j
];
854 chctx
->CWlengthT
[j
] = 0;
857 bits
+= chctx
->skipFlagBits
[i
];
858 summer
-= chctx
->skipFlagBits
[i
];
861 imc_adjust_bit_allocation(q
, chctx
, summer
);
864 static int imc_decode_block(AVCodecContext
*avctx
, IMCContext
*q
, int ch
)
866 int stream_format_code
;
867 int imc_hdr
, i
, j
, ret
;
870 int counter
, bitscount
;
871 IMCChannel
*chctx
= q
->chctx
+ ch
;
874 /* Check the frame header */
875 imc_hdr
= get_bits(&q
->gb
, 9);
876 if (imc_hdr
& 0x18) {
877 av_log(avctx
, AV_LOG_ERROR
, "frame header check failed!\n");
878 av_log(avctx
, AV_LOG_ERROR
, "got %X.\n", imc_hdr
);
879 return AVERROR_INVALIDDATA
;
881 stream_format_code
= get_bits(&q
->gb
, 3);
883 if (stream_format_code
& 0x04)
884 chctx
->decoder_reset
= 1;
886 if (chctx
->decoder_reset
) {
887 for (i
= 0; i
< BANDS
; i
++)
888 chctx
->old_floor
[i
] = 1.0;
889 for (i
= 0; i
< COEFFS
; i
++)
890 chctx
->CWdecoded
[i
] = 0;
891 chctx
->decoder_reset
= 0;
894 flag
= get_bits1(&q
->gb
);
895 if (stream_format_code
& 0x1)
896 imc_read_level_coeffs_raw(q
, stream_format_code
, chctx
->levlCoeffBuf
);
898 imc_read_level_coeffs(q
, stream_format_code
, chctx
->levlCoeffBuf
);
900 if (stream_format_code
& 0x1)
901 imc_decode_level_coefficients_raw(q
, chctx
->levlCoeffBuf
,
902 chctx
->flcoeffs1
, chctx
->flcoeffs2
);
903 else if (stream_format_code
& 0x4)
904 imc_decode_level_coefficients(q
, chctx
->levlCoeffBuf
,
905 chctx
->flcoeffs1
, chctx
->flcoeffs2
);
907 imc_decode_level_coefficients2(q
, chctx
->levlCoeffBuf
, chctx
->old_floor
,
908 chctx
->flcoeffs1
, chctx
->flcoeffs2
);
910 for(i
=0; i
<BANDS
; i
++) {
911 if(chctx
->flcoeffs1
[i
] > INT_MAX
) {
912 av_log(avctx
, AV_LOG_ERROR
, "scalefactor out of range\n");
913 return AVERROR_INVALIDDATA
;
917 memcpy(chctx
->old_floor
, chctx
->flcoeffs1
, 32 * sizeof(float));
920 if (stream_format_code
& 0x1) {
921 for (i
= 0; i
< BANDS
; i
++) {
922 chctx
->bandWidthT
[i
] = band_tab
[i
+ 1] - band_tab
[i
];
923 chctx
->bandFlagsBuf
[i
] = 0;
924 chctx
->flcoeffs3
[i
] = chctx
->flcoeffs2
[i
] * 2;
925 chctx
->flcoeffs5
[i
] = 1.0;
928 for (i
= 0; i
< BANDS
; i
++) {
929 if (chctx
->levlCoeffBuf
[i
] == 16) {
930 chctx
->bandWidthT
[i
] = 0;
933 chctx
->bandWidthT
[i
] = band_tab
[i
+ 1] - band_tab
[i
];
936 memset(chctx
->bandFlagsBuf
, 0, BANDS
* sizeof(int));
937 for (i
= 0; i
< BANDS
- 1; i
++)
938 if (chctx
->bandWidthT
[i
])
939 chctx
->bandFlagsBuf
[i
] = get_bits1(&q
->gb
);
941 imc_calculate_coeffs(q
, chctx
->flcoeffs1
, chctx
->flcoeffs2
,
942 chctx
->bandWidthT
, chctx
->flcoeffs3
,
947 /* first 4 bands will be assigned 5 bits per coefficient */
948 if (stream_format_code
& 0x2) {
951 chctx
->bitsBandT
[0] = 5;
952 chctx
->CWlengthT
[0] = 5;
953 chctx
->CWlengthT
[1] = 5;
954 chctx
->CWlengthT
[2] = 5;
955 for (i
= 1; i
< 4; i
++) {
956 if (stream_format_code
& 0x1)
959 bits
= (chctx
->levlCoeffBuf
[i
] == 16) ? 0 : 5;
960 chctx
->bitsBandT
[i
] = bits
;
961 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
962 chctx
->CWlengthT
[j
] = bits
;
967 if (avctx
->codec_id
== AV_CODEC_ID_IAC
) {
968 bitscount
+= !!chctx
->bandWidthT
[BANDS
- 1];
969 if (!(stream_format_code
& 0x2))
973 if ((ret
= bit_allocation(q
, chctx
, stream_format_code
,
974 512 - bitscount
- get_bits_count(&q
->gb
),
976 av_log(avctx
, AV_LOG_ERROR
, "Bit allocations failed\n");
977 chctx
->decoder_reset
= 1;
981 if (stream_format_code
& 0x1) {
982 for (i
= 0; i
< BANDS
; i
++)
983 chctx
->skipFlags
[i
] = 0;
985 imc_refine_bit_allocation(q
, chctx
);
988 for (i
= 0; i
< BANDS
; i
++) {
989 chctx
->sumLenArr
[i
] = 0;
991 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++)
992 if (!chctx
->skipFlags
[j
])
993 chctx
->sumLenArr
[i
] += chctx
->CWlengthT
[j
];
996 memset(chctx
->codewords
, 0, sizeof(chctx
->codewords
));
998 if (imc_get_coeffs(q
, chctx
) < 0) {
999 av_log(avctx
, AV_LOG_ERROR
, "Read coefficients failed\n");
1000 chctx
->decoder_reset
= 1;
1001 return AVERROR_INVALIDDATA
;
1004 if (inverse_quant_coeff(q
, chctx
, stream_format_code
) < 0) {
1005 av_log(avctx
, AV_LOG_ERROR
, "Inverse quantization of coefficients failed\n");
1006 chctx
->decoder_reset
= 1;
1007 return AVERROR_INVALIDDATA
;
1010 memset(chctx
->skipFlags
, 0, sizeof(chctx
->skipFlags
));
1012 imc_imdct256(q
, chctx
, avctx
->channels
);
1017 static int imc_decode_frame(AVCodecContext
*avctx
, void *data
,
1018 int *got_frame_ptr
, AVPacket
*avpkt
)
1020 AVFrame
*frame
= data
;
1021 const uint8_t *buf
= avpkt
->data
;
1022 int buf_size
= avpkt
->size
;
1025 IMCContext
*q
= avctx
->priv_data
;
1027 LOCAL_ALIGNED_16(uint16_t, buf16
, [IMC_BLOCK_SIZE
/ 2 + FF_INPUT_BUFFER_PADDING_SIZE
/2]);
1029 if (buf_size
< IMC_BLOCK_SIZE
* avctx
->channels
) {
1030 av_log(avctx
, AV_LOG_ERROR
, "frame too small!\n");
1031 return AVERROR_INVALIDDATA
;
1034 /* get output buffer */
1035 frame
->nb_samples
= COEFFS
;
1036 if ((ret
= ff_get_buffer(avctx
, frame
, 0)) < 0)
1039 for (i
= 0; i
< avctx
->channels
; i
++) {
1040 q
->out_samples
= (float *)frame
->extended_data
[i
];
1042 q
->bdsp
.bswap16_buf(buf16
, (const uint16_t *) buf
, IMC_BLOCK_SIZE
/ 2);
1044 init_get_bits(&q
->gb
, (const uint8_t*)buf16
, IMC_BLOCK_SIZE
* 8);
1046 buf
+= IMC_BLOCK_SIZE
;
1048 if ((ret
= imc_decode_block(avctx
, q
, i
)) < 0)
1052 if (avctx
->channels
== 2) {
1053 q
->fdsp
->butterflies_float((float *)frame
->extended_data
[0],
1054 (float *)frame
->extended_data
[1], COEFFS
);
1059 return IMC_BLOCK_SIZE
* avctx
->channels
;
1062 static av_cold
int imc_decode_close(AVCodecContext
* avctx
)
1064 IMCContext
*q
= avctx
->priv_data
;
1066 ff_fft_end(&q
->fft
);
1072 static av_cold
void flush(AVCodecContext
*avctx
)
1074 IMCContext
*q
= avctx
->priv_data
;
1076 q
->chctx
[0].decoder_reset
=
1077 q
->chctx
[1].decoder_reset
= 1;
1080 #if CONFIG_IMC_DECODER
1081 AVCodec ff_imc_decoder
= {
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
,
1091 .capabilities
= CODEC_CAP_DR1
,
1092 .sample_fmts
= (const enum AVSampleFormat
[]) { AV_SAMPLE_FMT_FLTP
,
1093 AV_SAMPLE_FMT_NONE
},
1096 #if CONFIG_IAC_DECODER
1097 AVCodec ff_iac_decoder
= {
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
,
1107 .capabilities
= CODEC_CAP_DR1
,
1108 .sample_fmts
= (const enum AVSampleFormat
[]) { AV_SAMPLE_FMT_FLTP
,
1109 AV_SAMPLE_FMT_NONE
},