lavc: remove unused traces of fmtconvert usage
[ffmpeg.git] / libavcodec / wma.c
1 /*
2  * WMA compatible codec
3  * Copyright (c) 2002-2007 The Libav Project
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "libavutil/attributes.h"
23
24 #include "avcodec.h"
25 #include "sinewin.h"
26 #include "wma.h"
27 #include "wma_common.h"
28 #include "wma_freqs.h"
29 #include "wmadata.h"
30
31 #undef NDEBUG
32 #include <assert.h>
33
34 /* XXX: use same run/length optimization as mpeg decoders */
35 // FIXME maybe split decode / encode or pass flag
36 static av_cold int init_coef_vlc(VLC *vlc, uint16_t **prun_table,
37                                  float **plevel_table, uint16_t **pint_table,
38                                  const CoefVLCTable *vlc_table)
39 {
40     int n                        = vlc_table->n;
41     const uint8_t  *table_bits   = vlc_table->huffbits;
42     const uint32_t *table_codes  = vlc_table->huffcodes;
43     const uint16_t *levels_table = vlc_table->levels;
44     uint16_t *run_table, *level_table, *int_table;
45     float *flevel_table;
46     int i, l, j, k, level;
47
48     init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0);
49
50     run_table    = av_malloc(n * sizeof(uint16_t));
51     level_table  = av_malloc(n * sizeof(uint16_t));
52     flevel_table = av_malloc(n * sizeof(*flevel_table));
53     int_table    = av_malloc(n * sizeof(uint16_t));
54     if (!run_table || !level_table || !flevel_table || !int_table) {
55         av_freep(&run_table);
56         av_freep(&level_table);
57         av_freep(&flevel_table);
58         av_freep(&int_table);
59         return AVERROR(ENOMEM);
60     }
61     i            = 2;
62     level        = 1;
63     k            = 0;
64     while (i < n) {
65         int_table[k] = i;
66         l            = levels_table[k++];
67         for (j = 0; j < l; j++) {
68             run_table[i]    = j;
69             level_table[i]  = level;
70             flevel_table[i] = level;
71             i++;
72         }
73         level++;
74     }
75     *prun_table   = run_table;
76     *plevel_table = flevel_table;
77     *pint_table   = int_table;
78     av_free(level_table);
79
80     return 0;
81 }
82
83 av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
84 {
85     WMACodecContext *s = avctx->priv_data;
86     int i, ret;
87     float bps1, high_freq;
88     volatile float bps;
89     int sample_rate1;
90     int coef_vlc_table;
91
92     if (avctx->sample_rate <= 0 || avctx->sample_rate > 50000 ||
93         avctx->channels    <= 0 || avctx->channels    > 2     ||
94         avctx->bit_rate    <= 0)
95         return -1;
96
97     avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
98
99     if (avctx->codec->id == AV_CODEC_ID_WMAV1)
100         s->version = 1;
101     else
102         s->version = 2;
103
104     /* compute MDCT block size */
105     s->frame_len_bits = ff_wma_get_frame_len_bits(avctx->sample_rate,
106                                                   s->version, 0);
107     s->next_block_len_bits = s->frame_len_bits;
108     s->prev_block_len_bits = s->frame_len_bits;
109     s->block_len_bits      = s->frame_len_bits;
110
111     s->frame_len = 1 << s->frame_len_bits;
112     if (s->use_variable_block_len) {
113         int nb_max, nb;
114         nb = ((flags2 >> 3) & 3) + 1;
115         if ((avctx->bit_rate / avctx->channels) >= 32000)
116             nb += 2;
117         nb_max = s->frame_len_bits - BLOCK_MIN_BITS;
118         if (nb > nb_max)
119             nb = nb_max;
120         s->nb_block_sizes = nb + 1;
121     } else
122         s->nb_block_sizes = 1;
123
124     /* init rate dependent parameters */
125     s->use_noise_coding = 1;
126     high_freq           = avctx->sample_rate * 0.5;
127
128     /* if version 2, then the rates are normalized */
129     sample_rate1 = avctx->sample_rate;
130     if (s->version == 2) {
131         if (sample_rate1 >= 44100)
132             sample_rate1 = 44100;
133         else if (sample_rate1 >= 22050)
134             sample_rate1 = 22050;
135         else if (sample_rate1 >= 16000)
136             sample_rate1 = 16000;
137         else if (sample_rate1 >= 11025)
138             sample_rate1 = 11025;
139         else if (sample_rate1 >= 8000)
140             sample_rate1 = 8000;
141     }
142
143     bps                 = (float) avctx->bit_rate /
144                           (float) (avctx->channels * avctx->sample_rate);
145     s->byte_offset_bits = av_log2((int) (bps * s->frame_len / 8.0 + 0.5)) + 2;
146
147     /* compute high frequency value and choose if noise coding should
148      * be activated */
149     bps1 = bps;
150     if (avctx->channels == 2)
151         bps1 = bps * 1.6;
152     if (sample_rate1 == 44100) {
153         if (bps1 >= 0.61)
154             s->use_noise_coding = 0;
155         else
156             high_freq = high_freq * 0.4;
157     } else if (sample_rate1 == 22050) {
158         if (bps1 >= 1.16)
159             s->use_noise_coding = 0;
160         else if (bps1 >= 0.72)
161             high_freq = high_freq * 0.7;
162         else
163             high_freq = high_freq * 0.6;
164     } else if (sample_rate1 == 16000) {
165         if (bps > 0.5)
166             high_freq = high_freq * 0.5;
167         else
168             high_freq = high_freq * 0.3;
169     } else if (sample_rate1 == 11025)
170         high_freq = high_freq * 0.7;
171     else if (sample_rate1 == 8000) {
172         if (bps <= 0.625)
173             high_freq = high_freq * 0.5;
174         else if (bps > 0.75)
175             s->use_noise_coding = 0;
176         else
177             high_freq = high_freq * 0.65;
178     } else {
179         if (bps >= 0.8)
180             high_freq = high_freq * 0.75;
181         else if (bps >= 0.6)
182             high_freq = high_freq * 0.6;
183         else
184             high_freq = high_freq * 0.5;
185     }
186     av_dlog(s->avctx, "flags2=0x%x\n", flags2);
187     av_dlog(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",
188             s->version, avctx->channels, avctx->sample_rate, avctx->bit_rate,
189             avctx->block_align);
190     av_dlog(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
191             bps, bps1, high_freq, s->byte_offset_bits);
192     av_dlog(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
193             s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes);
194
195     /* compute the scale factor band sizes for each MDCT block size */
196     {
197         int a, b, pos, lpos, k, block_len, i, j, n;
198         const uint8_t *table;
199
200         if (s->version == 1)
201             s->coefs_start = 3;
202         else
203             s->coefs_start = 0;
204         for (k = 0; k < s->nb_block_sizes; k++) {
205             block_len = s->frame_len >> k;
206
207             if (s->version == 1) {
208                 lpos = 0;
209                 for (i = 0; i < 25; i++) {
210                     a   = ff_wma_critical_freqs[i];
211                     b   = avctx->sample_rate;
212                     pos = ((block_len * 2 * a) + (b >> 1)) / b;
213                     if (pos > block_len)
214                         pos = block_len;
215                     s->exponent_bands[0][i] = pos - lpos;
216                     if (pos >= block_len) {
217                         i++;
218                         break;
219                     }
220                     lpos = pos;
221                 }
222                 s->exponent_sizes[0] = i;
223             } else {
224                 /* hardcoded tables */
225                 table = NULL;
226                 a     = s->frame_len_bits - BLOCK_MIN_BITS - k;
227                 if (a < 3) {
228                     if (avctx->sample_rate >= 44100)
229                         table = exponent_band_44100[a];
230                     else if (avctx->sample_rate >= 32000)
231                         table = exponent_band_32000[a];
232                     else if (avctx->sample_rate >= 22050)
233                         table = exponent_band_22050[a];
234                 }
235                 if (table) {
236                     n = *table++;
237                     for (i = 0; i < n; i++)
238                         s->exponent_bands[k][i] = table[i];
239                     s->exponent_sizes[k] = n;
240                 } else {
241                     j    = 0;
242                     lpos = 0;
243                     for (i = 0; i < 25; i++) {
244                         a     = ff_wma_critical_freqs[i];
245                         b     = avctx->sample_rate;
246                         pos   = ((block_len * 2 * a) + (b << 1)) / (4 * b);
247                         pos <<= 2;
248                         if (pos > block_len)
249                             pos = block_len;
250                         if (pos > lpos)
251                             s->exponent_bands[k][j++] = pos - lpos;
252                         if (pos >= block_len)
253                             break;
254                         lpos = pos;
255                     }
256                     s->exponent_sizes[k] = j;
257                 }
258             }
259
260             /* max number of coefs */
261             s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k;
262             /* high freq computation */
263             s->high_band_start[k] = (int) ((block_len * 2 * high_freq) /
264                                            avctx->sample_rate + 0.5);
265             n   = s->exponent_sizes[k];
266             j   = 0;
267             pos = 0;
268             for (i = 0; i < n; i++) {
269                 int start, end;
270                 start = pos;
271                 pos  += s->exponent_bands[k][i];
272                 end   = pos;
273                 if (start < s->high_band_start[k])
274                     start = s->high_band_start[k];
275                 if (end > s->coefs_end[k])
276                     end = s->coefs_end[k];
277                 if (end > start)
278                     s->exponent_high_bands[k][j++] = end - start;
279             }
280             s->exponent_high_sizes[k] = j;
281 #if 0
282             tprintf(s->avctx, "%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ",
283                     s->frame_len >> k,
284                     s->coefs_end[k],
285                     s->high_band_start[k],
286                     s->exponent_high_sizes[k]);
287             for (j = 0; j < s->exponent_high_sizes[k]; j++)
288                 tprintf(s->avctx, " %d", s->exponent_high_bands[k][j]);
289             tprintf(s->avctx, "\n");
290 #endif /* 0 */
291         }
292     }
293
294 #ifdef TRACE
295     {
296         int i, j;
297         for (i = 0; i < s->nb_block_sizes; i++) {
298             tprintf(s->avctx, "%5d: n=%2d:",
299                     s->frame_len >> i,
300                     s->exponent_sizes[i]);
301             for (j = 0; j < s->exponent_sizes[i]; j++)
302                 tprintf(s->avctx, " %d", s->exponent_bands[i][j]);
303             tprintf(s->avctx, "\n");
304         }
305     }
306 #endif /* TRACE */
307
308     /* init MDCT windows : simple sine window */
309     for (i = 0; i < s->nb_block_sizes; i++) {
310         ff_init_ff_sine_windows(s->frame_len_bits - i);
311         s->windows[i] = ff_sine_windows[s->frame_len_bits - i];
312     }
313
314     s->reset_block_lengths = 1;
315
316     if (s->use_noise_coding) {
317         /* init the noise generator */
318         if (s->use_exp_vlc)
319             s->noise_mult = 0.02;
320         else
321             s->noise_mult = 0.04;
322
323 #ifdef TRACE
324         for (i = 0; i < NOISE_TAB_SIZE; i++)
325             s->noise_table[i] = 1.0 * s->noise_mult;
326 #else
327         {
328             unsigned int seed;
329             float norm;
330             seed = 1;
331             norm = (1.0 / (float) (1LL << 31)) * sqrt(3) * s->noise_mult;
332             for (i = 0; i < NOISE_TAB_SIZE; i++) {
333                 seed              = seed * 314159 + 1;
334                 s->noise_table[i] = (float) ((int) seed) * norm;
335             }
336         }
337 #endif /* TRACE */
338     }
339
340     /* choose the VLC tables for the coefficients */
341     coef_vlc_table = 2;
342     if (avctx->sample_rate >= 32000) {
343         if (bps1 < 0.72)
344             coef_vlc_table = 0;
345         else if (bps1 < 1.16)
346             coef_vlc_table = 1;
347     }
348     s->coef_vlcs[0] = &coef_vlcs[coef_vlc_table * 2];
349     s->coef_vlcs[1] = &coef_vlcs[coef_vlc_table * 2 + 1];
350     ret = init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0],
351                         &s->int_table[0], s->coef_vlcs[0]);
352     if (ret < 0)
353         return ret;
354
355     return init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1],
356                          &s->int_table[1], s->coef_vlcs[1]);
357 }
358
359 int ff_wma_total_gain_to_bits(int total_gain)
360 {
361     if (total_gain < 15)
362         return 13;
363     else if (total_gain < 32)
364         return 12;
365     else if (total_gain < 40)
366         return 11;
367     else if (total_gain < 45)
368         return 10;
369     else
370         return  9;
371 }
372
373 int ff_wma_end(AVCodecContext *avctx)
374 {
375     WMACodecContext *s = avctx->priv_data;
376     int i;
377
378     for (i = 0; i < s->nb_block_sizes; i++)
379         ff_mdct_end(&s->mdct_ctx[i]);
380
381     if (s->use_exp_vlc)
382         ff_free_vlc(&s->exp_vlc);
383     if (s->use_noise_coding)
384         ff_free_vlc(&s->hgain_vlc);
385     for (i = 0; i < 2; i++) {
386         ff_free_vlc(&s->coef_vlc[i]);
387         av_free(s->run_table[i]);
388         av_free(s->level_table[i]);
389         av_free(s->int_table[i]);
390     }
391
392     return 0;
393 }
394
395 /**
396  * Decode an uncompressed coefficient.
397  * @param gb GetBitContext
398  * @return the decoded coefficient
399  */
400 unsigned int ff_wma_get_large_val(GetBitContext *gb)
401 {
402     /** consumes up to 34 bits */
403     int n_bits = 8;
404     /** decode length */
405     if (get_bits1(gb)) {
406         n_bits += 8;
407         if (get_bits1(gb)) {
408             n_bits += 8;
409             if (get_bits1(gb))
410                 n_bits += 7;
411         }
412     }
413     return get_bits_long(gb, n_bits);
414 }
415
416 /**
417  * Decode run level compressed coefficients.
418  * @param avctx codec context
419  * @param gb bitstream reader context
420  * @param vlc vlc table for get_vlc2
421  * @param level_table level codes
422  * @param run_table run codes
423  * @param version 0 for wma1,2 1 for wmapro
424  * @param ptr output buffer
425  * @param offset offset in the output buffer
426  * @param num_coefs number of input coefficents
427  * @param block_len input buffer length (2^n)
428  * @param frame_len_bits number of bits for escaped run codes
429  * @param coef_nb_bits number of bits for escaped level codes
430  * @return 0 on success, -1 otherwise
431  */
432 int ff_wma_run_level_decode(AVCodecContext *avctx, GetBitContext *gb,
433                             VLC *vlc, const float *level_table,
434                             const uint16_t *run_table, int version,
435                             WMACoef *ptr, int offset, int num_coefs,
436                             int block_len, int frame_len_bits,
437                             int coef_nb_bits)
438 {
439     int code, level, sign;
440     const uint32_t *ilvl = (const uint32_t *) level_table;
441     uint32_t *iptr = (uint32_t *) ptr;
442     const unsigned int coef_mask = block_len - 1;
443     for (; offset < num_coefs; offset++) {
444         code = get_vlc2(gb, vlc->table, VLCBITS, VLCMAX);
445         if (code > 1) {
446             /** normal code */
447             offset                  += run_table[code];
448             sign                     = get_bits1(gb) - 1;
449             iptr[offset & coef_mask] = ilvl[code] ^ sign << 31;
450         } else if (code == 1) {
451             /** EOB */
452             break;
453         } else {
454             /** escape */
455             if (!version) {
456                 level = get_bits(gb, coef_nb_bits);
457                 /** NOTE: this is rather suboptimal. reading
458                  *  block_len_bits would be better */
459                 offset += get_bits(gb, frame_len_bits);
460             } else {
461                 level = ff_wma_get_large_val(gb);
462                 /** escape decode */
463                 if (get_bits1(gb)) {
464                     if (get_bits1(gb)) {
465                         if (get_bits1(gb)) {
466                             av_log(avctx, AV_LOG_ERROR,
467                                    "broken escape sequence\n");
468                             return -1;
469                         } else
470                             offset += get_bits(gb, frame_len_bits) + 4;
471                     } else
472                         offset += get_bits(gb, 2) + 1;
473                 }
474             }
475             sign                    = get_bits1(gb) - 1;
476             ptr[offset & coef_mask] = (level ^ sign) - sign;
477         }
478     }
479     /** NOTE: EOB can be omitted */
480     if (offset > num_coefs) {
481         av_log(avctx, AV_LOG_ERROR, "overflow in spectral RLE, ignoring\n");
482         return -1;
483     }
484
485     return 0;
486 }