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