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 Libav.
9 * Libav 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 * Libav 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 Libav; 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.
42 #include "libavutil/audioconvert.h"
47 #define IMC_BLOCK_SIZE 64
48 #define IMC_FRAME_ID 0x21
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
];
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
74 float last_fft_im
[COEFFS
];
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
];
99 DECLARE_ALIGNED(32, FFTComplex
, samples
)[COEFFS
/ 2];
102 int8_t cyclTab
[32], cyclTab2
[32];
103 float weights1
[31], weights2
[31];
106 static VLC huffman_vlc
[4][4];
108 #define VLC_TABLES_SIZE 9512
110 static const int vlc_offsets
[17] = {
111 0, 640, 1156, 1732, 2308, 2852, 3396, 3924,
112 4452, 5220, 5860, 6628, 7268, 7908, 8424, 8936, VLC_TABLES_SIZE
115 static VLC_TYPE vlc_tables
[VLC_TABLES_SIZE
][2];
117 static inline double freq2bark(double freq
)
119 return 3.5 * atan((freq
/ 7500.0) * (freq
/ 7500.0)) + 13.0 * atan(freq
* 0.00076);
122 static av_cold
void iac_generate_tabs(IMCContext
*q
, int sampling_rate
)
124 double freqmin
[32], freqmid
[32], freqmax
[32];
125 double scale
= sampling_rate
/ (256.0 * 2.0 * 2.0);
126 double nyquist_freq
= sampling_rate
* 0.5;
127 double freq
, bark
, prev_bark
= 0, tf
, tb
;
130 for (i
= 0; i
< 32; i
++) {
131 freq
= (band_tab
[i
] + band_tab
[i
+ 1] - 1) * scale
;
132 bark
= freq2bark(freq
);
135 tb
= bark
- prev_bark
;
136 q
->weights1
[i
- 1] = pow(10.0, -1.0 * tb
);
137 q
->weights2
[i
- 1] = pow(10.0, -2.7 * tb
);
144 while (tf
< nyquist_freq
) {
156 if (tb
<= bark
- 0.5)
162 for (i
= 0; i
< 32; i
++) {
164 for (j
= 31; j
> 0 && freq
<= freqmid
[j
]; j
--);
165 q
->cyclTab
[i
] = j
+ 1;
168 for (j
= 0; j
< 32 && freq
>= freqmid
[j
]; j
++);
169 q
->cyclTab2
[i
] = j
- 1;
173 static av_cold
int imc_decode_init(AVCodecContext
*avctx
)
176 IMCContext
*q
= avctx
->priv_data
;
179 if ((avctx
->codec_id
== CODEC_ID_IMC
&& avctx
->channels
!= 1)
180 || (avctx
->codec_id
== CODEC_ID_IAC
&& avctx
->channels
> 2)) {
181 av_log_ask_for_sample(avctx
, "Number of channels is not supported\n");
182 return AVERROR_PATCHWELCOME
;
185 for (j
= 0; j
< avctx
->channels
; j
++) {
186 q
->chctx
[j
].decoder_reset
= 1;
188 for (i
= 0; i
< BANDS
; i
++)
189 q
->chctx
[j
].old_floor
[i
] = 1.0;
191 for (i
= 0; i
< COEFFS
/ 2; i
++)
192 q
->chctx
[j
].last_fft_im
[i
] = 0;
195 /* Build mdct window, a simple sine window normalized with sqrt(2) */
196 ff_sine_window_init(q
->mdct_sine_window
, COEFFS
);
197 for (i
= 0; i
< COEFFS
; i
++)
198 q
->mdct_sine_window
[i
] *= sqrt(2.0);
199 for (i
= 0; i
< COEFFS
/ 2; i
++) {
200 q
->post_cos
[i
] = (1.0f
/ 32768) * cos(i
/ 256.0 * M_PI
);
201 q
->post_sin
[i
] = (1.0f
/ 32768) * sin(i
/ 256.0 * M_PI
);
203 r1
= sin((i
* 4.0 + 1.0) / 1024.0 * M_PI
);
204 r2
= cos((i
* 4.0 + 1.0) / 1024.0 * M_PI
);
207 q
->pre_coef1
[i
] = (r1
+ r2
) * sqrt(2.0);
208 q
->pre_coef2
[i
] = -(r1
- r2
) * sqrt(2.0);
210 q
->pre_coef1
[i
] = -(r1
+ r2
) * sqrt(2.0);
211 q
->pre_coef2
[i
] = (r1
- r2
) * sqrt(2.0);
215 /* Generate a square root table */
217 for (i
= 0; i
< 30; i
++)
218 q
->sqrt_tab
[i
] = sqrt(i
);
220 /* initialize the VLC tables */
221 for (i
= 0; i
< 4 ; i
++) {
222 for (j
= 0; j
< 4; j
++) {
223 huffman_vlc
[i
][j
].table
= &vlc_tables
[vlc_offsets
[i
* 4 + j
]];
224 huffman_vlc
[i
][j
].table_allocated
= vlc_offsets
[i
* 4 + j
+ 1] - vlc_offsets
[i
* 4 + j
];
225 init_vlc(&huffman_vlc
[i
][j
], 9, imc_huffman_sizes
[i
],
226 imc_huffman_lens
[i
][j
], 1, 1,
227 imc_huffman_bits
[i
][j
], 2, 2, INIT_VLC_USE_NEW_STATIC
);
230 q
->one_div_log2
= 1 / log(2);
232 if (avctx
->codec_id
== CODEC_ID_IAC
) {
235 if (avctx
->codec_id
== CODEC_ID_IAC
) {
236 iac_generate_tabs(q
, avctx
->sample_rate
);
238 memcpy(q
->cyclTab
, cyclTab
, sizeof(cyclTab
));
239 memcpy(q
->cyclTab2
, cyclTab2
, sizeof(cyclTab2
));
240 memcpy(q
->weights1
, imc_weights1
, sizeof(imc_weights1
));
241 memcpy(q
->weights2
, imc_weights2
, sizeof(imc_weights2
));
244 if ((ret
= ff_fft_init(&q
->fft
, 7, 1))) {
245 av_log(avctx
, AV_LOG_INFO
, "FFT init failed\n");
248 ff_dsputil_init(&q
->dsp
, avctx
);
249 avctx
->sample_fmt
= AV_SAMPLE_FMT_FLT
;
250 avctx
->channel_layout
= avctx
->channels
== 1 ? AV_CH_LAYOUT_MONO
251 : AV_CH_LAYOUT_STEREO
;
253 avcodec_get_frame_defaults(&q
->frame
);
254 avctx
->coded_frame
= &q
->frame
;
259 static void imc_calculate_coeffs(IMCContext
*q
, float *flcoeffs1
,
260 float *flcoeffs2
, int *bandWidthT
,
261 float *flcoeffs3
, float *flcoeffs5
)
266 float snr_limit
= 1.e
-30;
270 for (i
= 0; i
< BANDS
; i
++) {
271 flcoeffs5
[i
] = workT2
[i
] = 0.0;
273 workT1
[i
] = flcoeffs1
[i
] * flcoeffs1
[i
];
274 flcoeffs3
[i
] = 2.0 * flcoeffs2
[i
];
277 flcoeffs3
[i
] = -30000.0;
279 workT3
[i
] = bandWidthT
[i
] * workT1
[i
] * 0.01;
280 if (workT3
[i
] <= snr_limit
)
284 for (i
= 0; i
< BANDS
; i
++) {
285 for (cnt2
= i
; cnt2
< q
->cyclTab
[i
]; cnt2
++)
286 flcoeffs5
[cnt2
] = flcoeffs5
[cnt2
] + workT3
[i
];
287 workT2
[cnt2
- 1] = workT2
[cnt2
- 1] + workT3
[i
];
290 for (i
= 1; i
< BANDS
; i
++) {
291 accum
= (workT2
[i
- 1] + accum
) * q
->weights1
[i
- 1];
292 flcoeffs5
[i
] += accum
;
295 for (i
= 0; i
< BANDS
; i
++)
298 for (i
= 0; i
< BANDS
; i
++) {
299 for (cnt2
= i
- 1; cnt2
> q
->cyclTab2
[i
]; cnt2
--)
300 flcoeffs5
[cnt2
] += workT3
[i
];
301 workT2
[cnt2
+1] += workT3
[i
];
306 for (i
= BANDS
-2; i
>= 0; i
--) {
307 accum
= (workT2
[i
+1] + accum
) * q
->weights2
[i
];
308 flcoeffs5
[i
] += accum
;
309 // there is missing code here, but it seems to never be triggered
314 static void imc_read_level_coeffs(IMCContext
*q
, int stream_format_code
,
320 const uint8_t *cb_sel
;
323 s
= stream_format_code
>> 1;
324 hufftab
[0] = &huffman_vlc
[s
][0];
325 hufftab
[1] = &huffman_vlc
[s
][1];
326 hufftab
[2] = &huffman_vlc
[s
][2];
327 hufftab
[3] = &huffman_vlc
[s
][3];
328 cb_sel
= imc_cb_select
[s
];
330 if (stream_format_code
& 4)
333 levlCoeffs
[0] = get_bits(&q
->gb
, 7);
334 for (i
= start
; i
< BANDS
; i
++) {
335 levlCoeffs
[i
] = get_vlc2(&q
->gb
, hufftab
[cb_sel
[i
]]->table
,
336 hufftab
[cb_sel
[i
]]->bits
, 2);
337 if (levlCoeffs
[i
] == 17)
338 levlCoeffs
[i
] += get_bits(&q
->gb
, 4);
342 static void imc_decode_level_coefficients(IMCContext
*q
, int *levlCoeffBuf
,
343 float *flcoeffs1
, float *flcoeffs2
)
347 // maybe some frequency division thingy
349 flcoeffs1
[0] = 20000.0 / pow (2, levlCoeffBuf
[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
350 flcoeffs2
[0] = log(flcoeffs1
[0]) / log(2);
354 for (i
= 1; i
< BANDS
; i
++) {
355 level
= levlCoeffBuf
[i
];
362 else if (level
<= 24)
367 tmp
*= imc_exp_tab
[15 + level
];
368 tmp2
+= 0.83048 * level
; // 0.83048 = log2(10) * 0.25
376 static void imc_decode_level_coefficients2(IMCContext
*q
, int *levlCoeffBuf
,
377 float *old_floor
, float *flcoeffs1
,
381 /* FIXME maybe flag_buf = noise coding and flcoeffs1 = new scale factors
382 * and flcoeffs2 old scale factors
383 * might be incomplete due to a missing table that is in the binary code
385 for (i
= 0; i
< BANDS
; i
++) {
387 if (levlCoeffBuf
[i
] < 16) {
388 flcoeffs1
[i
] = imc_exp_tab2
[levlCoeffBuf
[i
]] * old_floor
[i
];
389 flcoeffs2
[i
] = (levlCoeffBuf
[i
] - 7) * 0.83048 + flcoeffs2
[i
]; // 0.83048 = log2(10) * 0.25
391 flcoeffs1
[i
] = old_floor
[i
];
397 * Perform bit allocation depending on bits available
399 static int bit_allocation(IMCContext
*q
, IMCChannel
*chctx
,
400 int stream_format_code
, int freebits
, int flag
)
403 const float limit
= -1.e20
;
412 float lowest
= 1.e10
;
418 for (i
= 0; i
< BANDS
; i
++)
419 highest
= FFMAX(highest
, chctx
->flcoeffs1
[i
]);
421 for (i
= 0; i
< BANDS
- 1; i
++)
422 chctx
->flcoeffs4
[i
] = chctx
->flcoeffs3
[i
] - log(chctx
->flcoeffs5
[i
]) / log(2);
423 chctx
->flcoeffs4
[BANDS
- 1] = limit
;
425 highest
= highest
* 0.25;
427 for (i
= 0; i
< BANDS
; i
++) {
429 if ((band_tab
[i
+ 1] - band_tab
[i
]) == chctx
->bandWidthT
[i
])
432 if ((band_tab
[i
+ 1] - band_tab
[i
]) > chctx
->bandWidthT
[i
])
435 if (((band_tab
[i
+ 1] - band_tab
[i
]) / 2) >= chctx
->bandWidthT
[i
])
439 return AVERROR_INVALIDDATA
;
441 chctx
->flcoeffs4
[i
] += xTab
[(indx
* 2 + (chctx
->flcoeffs1
[i
] < highest
)) * 2 + flag
];
444 if (stream_format_code
& 0x2) {
445 chctx
->flcoeffs4
[0] = limit
;
446 chctx
->flcoeffs4
[1] = limit
;
447 chctx
->flcoeffs4
[2] = limit
;
448 chctx
->flcoeffs4
[3] = limit
;
451 for (i
= (stream_format_code
& 0x2) ? 4 : 0; i
< BANDS
- 1; i
++) {
452 iacc
+= chctx
->bandWidthT
[i
];
453 summa
+= chctx
->bandWidthT
[i
] * chctx
->flcoeffs4
[i
];
455 chctx
->bandWidthT
[BANDS
- 1] = 0;
456 summa
= (summa
* 0.5 - freebits
) / iacc
;
459 for (i
= 0; i
< BANDS
/ 2; i
++) {
460 rres
= summer
- freebits
;
461 if ((rres
>= -8) && (rres
<= 8))
467 for (j
= (stream_format_code
& 0x2) ? 4 : 0; j
< BANDS
; j
++) {
468 cwlen
= av_clipf(((chctx
->flcoeffs4
[j
] * 0.5) - summa
+ 0.5), 0, 6);
470 chctx
->bitsBandT
[j
] = cwlen
;
471 summer
+= chctx
->bandWidthT
[j
] * cwlen
;
474 iacc
+= chctx
->bandWidthT
[j
];
479 if (freebits
< summer
)
486 summa
= (float)(summer
- freebits
) / ((t1
+ 1) * iacc
) + summa
;
489 for (i
= (stream_format_code
& 0x2) ? 4 : 0; i
< BANDS
; i
++) {
490 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++)
491 chctx
->CWlengthT
[j
] = chctx
->bitsBandT
[i
];
494 if (freebits
> summer
) {
495 for (i
= 0; i
< BANDS
; i
++) {
496 workT
[i
] = (chctx
->bitsBandT
[i
] == 6) ? -1.e20
497 : (chctx
->bitsBandT
[i
] * -2 + chctx
->flcoeffs4
[i
] - 0.415);
503 if (highest
<= -1.e20
)
509 for (i
= 0; i
< BANDS
; i
++) {
510 if (workT
[i
] > highest
) {
516 if (highest
> -1.e20
) {
517 workT
[found_indx
] -= 2.0;
518 if (++chctx
->bitsBandT
[found_indx
] == 6)
519 workT
[found_indx
] = -1.e20
;
521 for (j
= band_tab
[found_indx
]; j
< band_tab
[found_indx
+ 1] && (freebits
> summer
); j
++) {
522 chctx
->CWlengthT
[j
]++;
526 } while (freebits
> summer
);
528 if (freebits
< summer
) {
529 for (i
= 0; i
< BANDS
; i
++) {
530 workT
[i
] = chctx
->bitsBandT
[i
] ? (chctx
->bitsBandT
[i
] * -2 + chctx
->flcoeffs4
[i
] + 1.585)
533 if (stream_format_code
& 0x2) {
539 while (freebits
< summer
) {
542 for (i
= 0; i
< BANDS
; i
++) {
543 if (workT
[i
] < lowest
) {
548 // if (lowest >= 1.e10)
550 workT
[low_indx
] = lowest
+ 2.0;
552 if (!--chctx
->bitsBandT
[low_indx
])
553 workT
[low_indx
] = 1.e20
;
555 for (j
= band_tab
[low_indx
]; j
< band_tab
[low_indx
+1] && (freebits
< summer
); j
++) {
556 if (chctx
->CWlengthT
[j
] > 0) {
557 chctx
->CWlengthT
[j
]--;
566 static void imc_get_skip_coeff(IMCContext
*q
, IMCChannel
*chctx
)
570 memset(chctx
->skipFlagBits
, 0, sizeof(chctx
->skipFlagBits
));
571 memset(chctx
->skipFlagCount
, 0, sizeof(chctx
->skipFlagCount
));
572 for (i
= 0; i
< BANDS
; i
++) {
573 if (!chctx
->bandFlagsBuf
[i
] || !chctx
->bandWidthT
[i
])
576 if (!chctx
->skipFlagRaw
[i
]) {
577 chctx
->skipFlagBits
[i
] = band_tab
[i
+ 1] - band_tab
[i
];
579 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
580 chctx
->skipFlags
[j
] = get_bits1(&q
->gb
);
581 if (chctx
->skipFlags
[j
])
582 chctx
->skipFlagCount
[i
]++;
585 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1] - 1; j
+= 2) {
586 if (!get_bits1(&q
->gb
)) { // 0
587 chctx
->skipFlagBits
[i
]++;
588 chctx
->skipFlags
[j
] = 1;
589 chctx
->skipFlags
[j
+ 1] = 1;
590 chctx
->skipFlagCount
[i
] += 2;
592 if (get_bits1(&q
->gb
)) { // 11
593 chctx
->skipFlagBits
[i
] += 2;
594 chctx
->skipFlags
[j
] = 0;
595 chctx
->skipFlags
[j
+ 1] = 1;
596 chctx
->skipFlagCount
[i
]++;
598 chctx
->skipFlagBits
[i
] += 3;
599 chctx
->skipFlags
[j
+ 1] = 0;
600 if (!get_bits1(&q
->gb
)) { // 100
601 chctx
->skipFlags
[j
] = 1;
602 chctx
->skipFlagCount
[i
]++;
604 chctx
->skipFlags
[j
] = 0;
610 if (j
< band_tab
[i
+ 1]) {
611 chctx
->skipFlagBits
[i
]++;
612 if ((chctx
->skipFlags
[j
] = get_bits1(&q
->gb
)))
613 chctx
->skipFlagCount
[i
]++;
620 * Increase highest' band coefficient sizes as some bits won't be used
622 static void imc_adjust_bit_allocation(IMCContext
*q
, IMCChannel
*chctx
,
631 for (i
= 0; i
< BANDS
; i
++) {
632 workT
[i
] = (chctx
->bitsBandT
[i
] == 6) ? -1.e20
633 : (chctx
->bitsBandT
[i
] * -2 + chctx
->flcoeffs4
[i
] - 0.415);
636 while (corrected
< summer
) {
637 if (highest
<= -1.e20
)
642 for (i
= 0; i
< BANDS
; i
++) {
643 if (workT
[i
] > highest
) {
649 if (highest
> -1.e20
) {
650 workT
[found_indx
] -= 2.0;
651 if (++(chctx
->bitsBandT
[found_indx
]) == 6)
652 workT
[found_indx
] = -1.e20
;
654 for (j
= band_tab
[found_indx
]; j
< band_tab
[found_indx
+1] && (corrected
< summer
); j
++) {
655 if (!chctx
->skipFlags
[j
] && (chctx
->CWlengthT
[j
] < 6)) {
656 chctx
->CWlengthT
[j
]++;
664 static void imc_imdct256(IMCContext
*q
, IMCChannel
*chctx
, int channels
)
668 float *dst1
= q
->out_samples
;
669 float *dst2
= q
->out_samples
+ (COEFFS
- 1) * channels
;
672 for (i
= 0; i
< COEFFS
/ 2; i
++) {
673 q
->samples
[i
].re
= -(q
->pre_coef1
[i
] * chctx
->CWdecoded
[COEFFS
- 1 - i
* 2]) -
674 (q
->pre_coef2
[i
] * chctx
->CWdecoded
[i
* 2]);
675 q
->samples
[i
].im
= (q
->pre_coef2
[i
] * chctx
->CWdecoded
[COEFFS
- 1 - i
* 2]) -
676 (q
->pre_coef1
[i
] * chctx
->CWdecoded
[i
* 2]);
680 q
->fft
.fft_permute(&q
->fft
, q
->samples
);
681 q
->fft
.fft_calc(&q
->fft
, q
->samples
);
683 /* postrotation, window and reorder */
684 for (i
= 0; i
< COEFFS
/ 2; i
++) {
685 re
= ( q
->samples
[i
].re
* q
->post_cos
[i
]) + (-q
->samples
[i
].im
* q
->post_sin
[i
]);
686 im
= (-q
->samples
[i
].im
* q
->post_cos
[i
]) - ( q
->samples
[i
].re
* q
->post_sin
[i
]);
687 *dst1
= (q
->mdct_sine_window
[COEFFS
- 1 - i
* 2] * chctx
->last_fft_im
[i
])
688 + (q
->mdct_sine_window
[i
* 2] * re
);
689 *dst2
= (q
->mdct_sine_window
[i
* 2] * chctx
->last_fft_im
[i
])
690 - (q
->mdct_sine_window
[COEFFS
- 1 - i
* 2] * re
);
691 dst1
+= channels
* 2;
692 dst2
-= channels
* 2;
693 chctx
->last_fft_im
[i
] = im
;
697 static int inverse_quant_coeff(IMCContext
*q
, IMCChannel
*chctx
,
698 int stream_format_code
)
701 int middle_value
, cw_len
, max_size
;
702 const float *quantizer
;
704 for (i
= 0; i
< BANDS
; i
++) {
705 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
706 chctx
->CWdecoded
[j
] = 0;
707 cw_len
= chctx
->CWlengthT
[j
];
709 if (cw_len
<= 0 || chctx
->skipFlags
[j
])
712 max_size
= 1 << cw_len
;
713 middle_value
= max_size
>> 1;
715 if (chctx
->codewords
[j
] >= max_size
|| chctx
->codewords
[j
] < 0)
716 return AVERROR_INVALIDDATA
;
719 quantizer
= imc_quantizer2
[(stream_format_code
& 2) >> 1];
720 if (chctx
->codewords
[j
] >= middle_value
)
721 chctx
->CWdecoded
[j
] = quantizer
[chctx
->codewords
[j
] - 8] * chctx
->flcoeffs6
[i
];
723 chctx
->CWdecoded
[j
] = -quantizer
[max_size
- chctx
->codewords
[j
] - 8 - 1] * chctx
->flcoeffs6
[i
];
725 quantizer
= imc_quantizer1
[((stream_format_code
& 2) >> 1) | (chctx
->bandFlagsBuf
[i
] << 1)];
726 if (chctx
->codewords
[j
] >= middle_value
)
727 chctx
->CWdecoded
[j
] = quantizer
[chctx
->codewords
[j
] - 1] * chctx
->flcoeffs6
[i
];
729 chctx
->CWdecoded
[j
] = -quantizer
[max_size
- 2 - chctx
->codewords
[j
]] * chctx
->flcoeffs6
[i
];
737 static int imc_get_coeffs(IMCContext
*q
, IMCChannel
*chctx
)
739 int i
, j
, cw_len
, cw
;
741 for (i
= 0; i
< BANDS
; i
++) {
742 if (!chctx
->sumLenArr
[i
])
744 if (chctx
->bandFlagsBuf
[i
] || chctx
->bandWidthT
[i
]) {
745 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
746 cw_len
= chctx
->CWlengthT
[j
];
749 if (get_bits_count(&q
->gb
) + cw_len
> 512) {
750 // av_log(NULL, 0, "Band %i coeff %i cw_len %i\n", i, j, cw_len);
751 return AVERROR_INVALIDDATA
;
754 if (cw_len
&& (!chctx
->bandFlagsBuf
[i
] || !chctx
->skipFlags
[j
]))
755 cw
= get_bits(&q
->gb
, cw_len
);
757 chctx
->codewords
[j
] = cw
;
764 static int imc_decode_block(AVCodecContext
*avctx
, IMCContext
*q
, int ch
)
766 int stream_format_code
;
767 int imc_hdr
, i
, j
, ret
;
770 int counter
, bitscount
;
771 IMCChannel
*chctx
= q
->chctx
+ ch
;
774 /* Check the frame header */
775 imc_hdr
= get_bits(&q
->gb
, 9);
776 if (imc_hdr
& 0x18) {
777 av_log(avctx
, AV_LOG_ERROR
, "frame header check failed!\n");
778 av_log(avctx
, AV_LOG_ERROR
, "got %X.\n", imc_hdr
);
779 return AVERROR_INVALIDDATA
;
781 stream_format_code
= get_bits(&q
->gb
, 3);
783 if (stream_format_code
& 1) {
784 av_log_ask_for_sample(avctx
, "Stream format %X is not supported\n",
786 return AVERROR_PATCHWELCOME
;
789 // av_log(avctx, AV_LOG_DEBUG, "stream_format_code = %d\n", stream_format_code);
791 if (stream_format_code
& 0x04)
792 chctx
->decoder_reset
= 1;
794 if (chctx
->decoder_reset
) {
795 memset(q
->out_samples
, 0, sizeof(q
->out_samples
));
796 for (i
= 0; i
< BANDS
; i
++)
797 chctx
->old_floor
[i
] = 1.0;
798 for (i
= 0; i
< COEFFS
; i
++)
799 chctx
->CWdecoded
[i
] = 0;
800 chctx
->decoder_reset
= 0;
803 flag
= get_bits1(&q
->gb
);
804 imc_read_level_coeffs(q
, stream_format_code
, chctx
->levlCoeffBuf
);
806 if (stream_format_code
& 0x4)
807 imc_decode_level_coefficients(q
, chctx
->levlCoeffBuf
,
808 chctx
->flcoeffs1
, chctx
->flcoeffs2
);
810 imc_decode_level_coefficients2(q
, chctx
->levlCoeffBuf
, chctx
->old_floor
,
811 chctx
->flcoeffs1
, chctx
->flcoeffs2
);
813 memcpy(chctx
->old_floor
, chctx
->flcoeffs1
, 32 * sizeof(float));
816 for (i
= 0; i
< BANDS
; i
++) {
817 if (chctx
->levlCoeffBuf
[i
] == 16) {
818 chctx
->bandWidthT
[i
] = 0;
821 chctx
->bandWidthT
[i
] = band_tab
[i
+ 1] - band_tab
[i
];
823 memset(chctx
->bandFlagsBuf
, 0, BANDS
* sizeof(int));
824 for (i
= 0; i
< BANDS
- 1; i
++) {
825 if (chctx
->bandWidthT
[i
])
826 chctx
->bandFlagsBuf
[i
] = get_bits1(&q
->gb
);
829 imc_calculate_coeffs(q
, chctx
->flcoeffs1
, chctx
->flcoeffs2
, chctx
->bandWidthT
, chctx
->flcoeffs3
, chctx
->flcoeffs5
);
832 /* first 4 bands will be assigned 5 bits per coefficient */
833 if (stream_format_code
& 0x2) {
836 chctx
->bitsBandT
[0] = 5;
837 chctx
->CWlengthT
[0] = 5;
838 chctx
->CWlengthT
[1] = 5;
839 chctx
->CWlengthT
[2] = 5;
840 for (i
= 1; i
< 4; i
++) {
841 bits
= (chctx
->levlCoeffBuf
[i
] == 16) ? 0 : 5;
842 chctx
->bitsBandT
[i
] = bits
;
843 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
844 chctx
->CWlengthT
[j
] = bits
;
849 if (avctx
->codec_id
== CODEC_ID_IAC
) {
850 bitscount
+= !!chctx
->bandWidthT
[BANDS
- 1];
851 if (!(stream_format_code
& 0x2))
855 if ((ret
= bit_allocation(q
, chctx
, stream_format_code
,
856 512 - bitscount
- get_bits_count(&q
->gb
),
858 av_log(avctx
, AV_LOG_ERROR
, "Bit allocations failed\n");
859 chctx
->decoder_reset
= 1;
863 for (i
= 0; i
< BANDS
; i
++) {
864 chctx
->sumLenArr
[i
] = 0;
865 chctx
->skipFlagRaw
[i
] = 0;
866 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++)
867 chctx
->sumLenArr
[i
] += chctx
->CWlengthT
[j
];
868 if (chctx
->bandFlagsBuf
[i
])
869 if ((((band_tab
[i
+ 1] - band_tab
[i
]) * 1.5) > chctx
->sumLenArr
[i
]) && (chctx
->sumLenArr
[i
] > 0))
870 chctx
->skipFlagRaw
[i
] = 1;
873 imc_get_skip_coeff(q
, chctx
);
875 for (i
= 0; i
< BANDS
; i
++) {
876 chctx
->flcoeffs6
[i
] = chctx
->flcoeffs1
[i
];
877 /* band has flag set and at least one coded coefficient */
878 if (chctx
->bandFlagsBuf
[i
] && (band_tab
[i
+ 1] - band_tab
[i
]) != chctx
->skipFlagCount
[i
]) {
879 chctx
->flcoeffs6
[i
] *= q
->sqrt_tab
[ band_tab
[i
+ 1] - band_tab
[i
]] /
880 q
->sqrt_tab
[(band_tab
[i
+ 1] - band_tab
[i
] - chctx
->skipFlagCount
[i
])];
884 /* calculate bits left, bits needed and adjust bit allocation */
887 for (i
= 0; i
< BANDS
; i
++) {
888 if (chctx
->bandFlagsBuf
[i
]) {
889 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++) {
890 if (chctx
->skipFlags
[j
]) {
891 summer
+= chctx
->CWlengthT
[j
];
892 chctx
->CWlengthT
[j
] = 0;
895 bits
+= chctx
->skipFlagBits
[i
];
896 summer
-= chctx
->skipFlagBits
[i
];
899 imc_adjust_bit_allocation(q
, chctx
, summer
);
901 for (i
= 0; i
< BANDS
; i
++) {
902 chctx
->sumLenArr
[i
] = 0;
904 for (j
= band_tab
[i
]; j
< band_tab
[i
+ 1]; j
++)
905 if (!chctx
->skipFlags
[j
])
906 chctx
->sumLenArr
[i
] += chctx
->CWlengthT
[j
];
909 memset(chctx
->codewords
, 0, sizeof(chctx
->codewords
));
911 if (imc_get_coeffs(q
, chctx
) < 0) {
912 av_log(avctx
, AV_LOG_ERROR
, "Read coefficients failed\n");
913 chctx
->decoder_reset
= 1;
914 return AVERROR_INVALIDDATA
;
917 if (inverse_quant_coeff(q
, chctx
, stream_format_code
) < 0) {
918 av_log(avctx
, AV_LOG_ERROR
, "Inverse quantization of coefficients failed\n");
919 chctx
->decoder_reset
= 1;
920 return AVERROR_INVALIDDATA
;
923 memset(chctx
->skipFlags
, 0, sizeof(chctx
->skipFlags
));
925 imc_imdct256(q
, chctx
, avctx
->channels
);
930 static int imc_decode_frame(AVCodecContext
*avctx
, void *data
,
931 int *got_frame_ptr
, AVPacket
*avpkt
)
933 const uint8_t *buf
= avpkt
->data
;
934 int buf_size
= avpkt
->size
;
937 IMCContext
*q
= avctx
->priv_data
;
939 LOCAL_ALIGNED_16(uint16_t, buf16
, [IMC_BLOCK_SIZE
/ 2]);
941 if (buf_size
< IMC_BLOCK_SIZE
* avctx
->channels
) {
942 av_log(avctx
, AV_LOG_ERROR
, "frame too small!\n");
943 return AVERROR_INVALIDDATA
;
946 /* get output buffer */
947 q
->frame
.nb_samples
= COEFFS
;
948 if ((ret
= avctx
->get_buffer(avctx
, &q
->frame
)) < 0) {
949 av_log(avctx
, AV_LOG_ERROR
, "get_buffer() failed\n");
953 for (i
= 0; i
< avctx
->channels
; i
++) {
954 q
->out_samples
= (float*)q
->frame
.data
[0] + i
;
956 q
->dsp
.bswap16_buf(buf16
, (const uint16_t*)buf
, IMC_BLOCK_SIZE
/ 2);
958 init_get_bits(&q
->gb
, (const uint8_t*)buf16
, IMC_BLOCK_SIZE
* 8);
960 buf
+= IMC_BLOCK_SIZE
;
962 if ((ret
= imc_decode_block(avctx
, q
, i
)) < 0)
966 if (avctx
->channels
== 2) {
967 float *src
= (float*)q
->frame
.data
[0], t1
, t2
;
969 for (i
= 0; i
< COEFFS
; i
++) {
979 *(AVFrame
*)data
= q
->frame
;
981 return IMC_BLOCK_SIZE
* avctx
->channels
;
985 static av_cold
int imc_decode_close(AVCodecContext
* avctx
)
987 IMCContext
*q
= avctx
->priv_data
;
995 AVCodec ff_imc_decoder
= {
997 .type
= AVMEDIA_TYPE_AUDIO
,
999 .priv_data_size
= sizeof(IMCContext
),
1000 .init
= imc_decode_init
,
1001 .close
= imc_decode_close
,
1002 .decode
= imc_decode_frame
,
1003 .capabilities
= CODEC_CAP_DR1
,
1004 .long_name
= NULL_IF_CONFIG_SMALL("IMC (Intel Music Coder)"),
1007 AVCodec ff_iac_decoder
= {
1009 .type
= AVMEDIA_TYPE_AUDIO
,
1011 .priv_data_size
= sizeof(IMCContext
),
1012 .init
= imc_decode_init
,
1013 .close
= imc_decode_close
,
1014 .decode
= imc_decode_frame
,
1015 .capabilities
= CODEC_CAP_DR1
,
1016 .long_name
= NULL_IF_CONFIG_SMALL("IAC (Indeo Audio Coder)"),