Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wmadec.c @ 7d485f16

History | View | Annotate | Download (27.5 KB)

1
/*
2
 * WMA compatible decoder
3
 * Copyright (c) 2002 The FFmpeg Project
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg 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
 * FFmpeg 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 FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/**
23
 * @file libavcodec/wmadec.c
24
 * WMA compatible decoder.
25
 * This decoder handles Microsoft Windows Media Audio data, versions 1 & 2.
26
 * WMA v1 is identified by audio format 0x160 in Microsoft media files
27
 * (ASF/AVI/WAV). WMA v2 is identified by audio format 0x161.
28
 *
29
 * To use this decoder, a calling application must supply the extra data
30
 * bytes provided with the WMA data. These are the extra, codec-specific
31
 * bytes at the end of a WAVEFORMATEX data structure. Transmit these bytes
32
 * to the decoder using the extradata[_size] fields in AVCodecContext. There
33
 * should be 4 extra bytes for v1 data and 6 extra bytes for v2 data.
34
 */
35

    
36
#include "avcodec.h"
37
#include "wma.h"
38

    
39
#undef NDEBUG
40
#include <assert.h>
41

    
42
#define EXPVLCBITS 8
43
#define EXPMAX ((19+EXPVLCBITS-1)/EXPVLCBITS)
44

    
45
#define HGAINVLCBITS 9
46
#define HGAINMAX ((13+HGAINVLCBITS-1)/HGAINVLCBITS)
47

    
48
static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len);
49

    
50
#ifdef TRACE
51
static void dump_shorts(WMACodecContext *s, const char *name, const short *tab, int n)
52
{
53
    int i;
54

    
55
    tprintf(s->avctx, "%s[%d]:\n", name, n);
56
    for(i=0;i<n;i++) {
57
        if ((i & 7) == 0)
58
            tprintf(s->avctx, "%4d: ", i);
59
        tprintf(s->avctx, " %5d.0", tab[i]);
60
        if ((i & 7) == 7)
61
            tprintf(s->avctx, "\n");
62
    }
63
}
64

    
65
static void dump_floats(WMACodecContext *s, const char *name, int prec, const float *tab, int n)
66
{
67
    int i;
68

    
69
    tprintf(s->avctx, "%s[%d]:\n", name, n);
70
    for(i=0;i<n;i++) {
71
        if ((i & 7) == 0)
72
            tprintf(s->avctx, "%4d: ", i);
73
        tprintf(s->avctx, " %8.*f", prec, tab[i]);
74
        if ((i & 7) == 7)
75
            tprintf(s->avctx, "\n");
76
    }
77
    if ((i & 7) != 0)
78
        tprintf(s->avctx, "\n");
79
}
80
#endif
81

    
82
static int wma_decode_init(AVCodecContext * avctx)
83
{
84
    WMACodecContext *s = avctx->priv_data;
85
    int i, flags1, flags2;
86
    uint8_t *extradata;
87

    
88
    s->avctx = avctx;
89

    
90
    /* extract flag infos */
91
    flags1 = 0;
92
    flags2 = 0;
93
    extradata = avctx->extradata;
94
    if (avctx->codec->id == CODEC_ID_WMAV1 && avctx->extradata_size >= 4) {
95
        flags1 = AV_RL16(extradata);
96
        flags2 = AV_RL16(extradata+2);
97
    } else if (avctx->codec->id == CODEC_ID_WMAV2 && avctx->extradata_size >= 6) {
98
        flags1 = AV_RL32(extradata);
99
        flags2 = AV_RL16(extradata+4);
100
    }
101
// for(i=0; i<avctx->extradata_size; i++)
102
//     av_log(NULL, AV_LOG_ERROR, "%02X ", extradata[i]);
103

    
104
    s->use_exp_vlc = flags2 & 0x0001;
105
    s->use_bit_reservoir = flags2 & 0x0002;
106
    s->use_variable_block_len = flags2 & 0x0004;
107

    
108
    if(ff_wma_init(avctx, flags2)<0)
109
        return -1;
110

    
111
    /* init MDCT */
112
    for(i = 0; i < s->nb_block_sizes; i++)
113
        ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 1, 1.0);
114

    
115
    if (s->use_noise_coding) {
116
        init_vlc(&s->hgain_vlc, HGAINVLCBITS, sizeof(ff_wma_hgain_huffbits),
117
                 ff_wma_hgain_huffbits, 1, 1,
118
                 ff_wma_hgain_huffcodes, 2, 2, 0);
119
    }
120

    
121
    if (s->use_exp_vlc) {
122
        init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(ff_wma_scale_huffbits), //FIXME move out of context
123
                 ff_wma_scale_huffbits, 1, 1,
124
                 ff_wma_scale_huffcodes, 4, 4, 0);
125
    } else {
126
        wma_lsp_to_curve_init(s, s->frame_len);
127
    }
128

    
129
    avctx->sample_fmt = SAMPLE_FMT_S16;
130
    return 0;
131
}
132

    
133
/**
134
 * compute x^-0.25 with an exponent and mantissa table. We use linear
135
 * interpolation to reduce the mantissa table size at a small speed
136
 * expense (linear interpolation approximately doubles the number of
137
 * bits of precision).
138
 */
139
static inline float pow_m1_4(WMACodecContext *s, float x)
140
{
141
    union {
142
        float f;
143
        unsigned int v;
144
    } u, t;
145
    unsigned int e, m;
146
    float a, b;
147

    
148
    u.f = x;
149
    e = u.v >> 23;
150
    m = (u.v >> (23 - LSP_POW_BITS)) & ((1 << LSP_POW_BITS) - 1);
151
    /* build interpolation scale: 1 <= t < 2. */
152
    t.v = ((u.v << LSP_POW_BITS) & ((1 << 23) - 1)) | (127 << 23);
153
    a = s->lsp_pow_m_table1[m];
154
    b = s->lsp_pow_m_table2[m];
155
    return s->lsp_pow_e_table[e] * (a + b * t.f);
156
}
157

    
158
static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)
159
{
160
    float wdel, a, b;
161
    int i, e, m;
162

    
163
    wdel = M_PI / frame_len;
164
    for(i=0;i<frame_len;i++)
165
        s->lsp_cos_table[i] = 2.0f * cos(wdel * i);
166

    
167
    /* tables for x^-0.25 computation */
168
    for(i=0;i<256;i++) {
169
        e = i - 126;
170
        s->lsp_pow_e_table[i] = pow(2.0, e * -0.25);
171
    }
172

    
173
    /* NOTE: these two tables are needed to avoid two operations in
174
       pow_m1_4 */
175
    b = 1.0;
176
    for(i=(1 << LSP_POW_BITS) - 1;i>=0;i--) {
177
        m = (1 << LSP_POW_BITS) + i;
178
        a = (float)m * (0.5 / (1 << LSP_POW_BITS));
179
        a = pow(a, -0.25);
180
        s->lsp_pow_m_table1[i] = 2 * a - b;
181
        s->lsp_pow_m_table2[i] = b - a;
182
        b = a;
183
    }
184
#if 0
185
    for(i=1;i<20;i++) {
186
        float v, r1, r2;
187
        v = 5.0 / i;
188
        r1 = pow_m1_4(s, v);
189
        r2 = pow(v,-0.25);
190
        printf("%f^-0.25=%f e=%f\n", v, r1, r2 - r1);
191
    }
192
#endif
193
}
194

    
195
/**
196
 * NOTE: We use the same code as Vorbis here
197
 * @todo optimize it further with SSE/3Dnow
198
 */
199
static void wma_lsp_to_curve(WMACodecContext *s,
200
                             float *out, float *val_max_ptr,
201
                             int n, float *lsp)
202
{
203
    int i, j;
204
    float p, q, w, v, val_max;
205

    
206
    val_max = 0;
207
    for(i=0;i<n;i++) {
208
        p = 0.5f;
209
        q = 0.5f;
210
        w = s->lsp_cos_table[i];
211
        for(j=1;j<NB_LSP_COEFS;j+=2){
212
            q *= w - lsp[j - 1];
213
            p *= w - lsp[j];
214
        }
215
        p *= p * (2.0f - w);
216
        q *= q * (2.0f + w);
217
        v = p + q;
218
        v = pow_m1_4(s, v);
219
        if (v > val_max)
220
            val_max = v;
221
        out[i] = v;
222
    }
223
    *val_max_ptr = val_max;
224
}
225

    
226
/**
227
 * decode exponents coded with LSP coefficients (same idea as Vorbis)
228
 */
229
static void decode_exp_lsp(WMACodecContext *s, int ch)
230
{
231
    float lsp_coefs[NB_LSP_COEFS];
232
    int val, i;
233

    
234
    for(i = 0; i < NB_LSP_COEFS; i++) {
235
        if (i == 0 || i >= 8)
236
            val = get_bits(&s->gb, 3);
237
        else
238
            val = get_bits(&s->gb, 4);
239
        lsp_coefs[i] = ff_wma_lsp_codebook[i][val];
240
    }
241

    
242
    wma_lsp_to_curve(s, s->exponents[ch], &s->max_exponent[ch],
243
                     s->block_len, lsp_coefs);
244
}
245

    
246
/**
247
 * decode exponents coded with VLC codes
248
 */
249
static int decode_exp_vlc(WMACodecContext *s, int ch)
250
{
251
    int last_exp, n, code;
252
    const uint16_t *ptr, *band_ptr;
253
    float v, *q, max_scale, *q_end;
254

    
255
    band_ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
256
    ptr = band_ptr;
257
    q = s->exponents[ch];
258
    q_end = q + s->block_len;
259
    max_scale = 0;
260
    if (s->version == 1) {
261
        last_exp = get_bits(&s->gb, 5) + 10;
262
        /* XXX: use a table */
263
        v = pow(10, last_exp * (1.0 / 16.0));
264
        max_scale = v;
265
        n = *ptr++;
266
        do {
267
            *q++ = v;
268
        } while (--n);
269
    }else
270
        last_exp = 36;
271

    
272
    while (q < q_end) {
273
        code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX);
274
        if (code < 0)
275
            return -1;
276
        /* NOTE: this offset is the same as MPEG4 AAC ! */
277
        last_exp += code - 60;
278
        /* XXX: use a table */
279
        v = pow(10, last_exp * (1.0 / 16.0));
280
        if (v > max_scale)
281
            max_scale = v;
282
        n = *ptr++;
283
        do {
284
            *q++ = v;
285
        } while (--n);
286
    }
287
    s->max_exponent[ch] = max_scale;
288
    return 0;
289
}
290

    
291

    
292
/**
293
 * Apply MDCT window and add into output.
294
 *
295
 * We ensure that when the windows overlap their squared sum
296
 * is always 1 (MDCT reconstruction rule).
297
 */
298
static void wma_window(WMACodecContext *s, float *out)
299
{
300
    float *in = s->output;
301
    int block_len, bsize, n;
302

    
303
    /* left part */
304
    if (s->block_len_bits <= s->prev_block_len_bits) {
305
        block_len = s->block_len;
306
        bsize = s->frame_len_bits - s->block_len_bits;
307

    
308
        s->dsp.vector_fmul_add_add(out, in, s->windows[bsize],
309
                                   out, 0, block_len, 1);
310

    
311
    } else {
312
        block_len = 1 << s->prev_block_len_bits;
313
        n = (s->block_len - block_len) / 2;
314
        bsize = s->frame_len_bits - s->prev_block_len_bits;
315

    
316
        s->dsp.vector_fmul_add_add(out+n, in+n, s->windows[bsize],
317
                                   out+n, 0, block_len, 1);
318

    
319
        memcpy(out+n+block_len, in+n+block_len, n*sizeof(float));
320
    }
321

    
322
    out += s->block_len;
323
    in += s->block_len;
324

    
325
    /* right part */
326
    if (s->block_len_bits <= s->next_block_len_bits) {
327
        block_len = s->block_len;
328
        bsize = s->frame_len_bits - s->block_len_bits;
329

    
330
        s->dsp.vector_fmul_reverse(out, in, s->windows[bsize], block_len);
331

    
332
    } else {
333
        block_len = 1 << s->next_block_len_bits;
334
        n = (s->block_len - block_len) / 2;
335
        bsize = s->frame_len_bits - s->next_block_len_bits;
336

    
337
        memcpy(out, in, n*sizeof(float));
338

    
339
        s->dsp.vector_fmul_reverse(out+n, in+n, s->windows[bsize], block_len);
340

    
341
        memset(out+n+block_len, 0, n*sizeof(float));
342
    }
343
}
344

    
345

    
346
/**
347
 * @return 0 if OK. 1 if last block of frame. return -1 if
348
 * unrecorrable error.
349
 */
350
static int wma_decode_block(WMACodecContext *s)
351
{
352
    int n, v, a, ch, code, bsize;
353
    int coef_nb_bits, total_gain;
354
    int nb_coefs[MAX_CHANNELS];
355
    float mdct_norm;
356

    
357
#ifdef TRACE
358
    tprintf(s->avctx, "***decode_block: %d:%d\n", s->frame_count - 1, s->block_num);
359
#endif
360

    
361
    /* compute current block length */
362
    if (s->use_variable_block_len) {
363
        n = av_log2(s->nb_block_sizes - 1) + 1;
364

    
365
        if (s->reset_block_lengths) {
366
            s->reset_block_lengths = 0;
367
            v = get_bits(&s->gb, n);
368
            if (v >= s->nb_block_sizes)
369
                return -1;
370
            s->prev_block_len_bits = s->frame_len_bits - v;
371
            v = get_bits(&s->gb, n);
372
            if (v >= s->nb_block_sizes)
373
                return -1;
374
            s->block_len_bits = s->frame_len_bits - v;
375
        } else {
376
            /* update block lengths */
377
            s->prev_block_len_bits = s->block_len_bits;
378
            s->block_len_bits = s->next_block_len_bits;
379
        }
380
        v = get_bits(&s->gb, n);
381
        if (v >= s->nb_block_sizes)
382
            return -1;
383
        s->next_block_len_bits = s->frame_len_bits - v;
384
    } else {
385
        /* fixed block len */
386
        s->next_block_len_bits = s->frame_len_bits;
387
        s->prev_block_len_bits = s->frame_len_bits;
388
        s->block_len_bits = s->frame_len_bits;
389
    }
390

    
391
    /* now check if the block length is coherent with the frame length */
392
    s->block_len = 1 << s->block_len_bits;
393
    if ((s->block_pos + s->block_len) > s->frame_len)
394
        return -1;
395

    
396
    if (s->nb_channels == 2) {
397
        s->ms_stereo = get_bits1(&s->gb);
398
    }
399
    v = 0;
400
    for(ch = 0; ch < s->nb_channels; ch++) {
401
        a = get_bits1(&s->gb);
402
        s->channel_coded[ch] = a;
403
        v |= a;
404
    }
405

    
406
    bsize = s->frame_len_bits - s->block_len_bits;
407

    
408
    /* if no channel coded, no need to go further */
409
    /* XXX: fix potential framing problems */
410
    if (!v)
411
        goto next;
412

    
413
    /* read total gain and extract corresponding number of bits for
414
       coef escape coding */
415
    total_gain = 1;
416
    for(;;) {
417
        a = get_bits(&s->gb, 7);
418
        total_gain += a;
419
        if (a != 127)
420
            break;
421
    }
422

    
423
    coef_nb_bits= ff_wma_total_gain_to_bits(total_gain);
424

    
425
    /* compute number of coefficients */
426
    n = s->coefs_end[bsize] - s->coefs_start;
427
    for(ch = 0; ch < s->nb_channels; ch++)
428
        nb_coefs[ch] = n;
429

    
430
    /* complex coding */
431
    if (s->use_noise_coding) {
432

    
433
        for(ch = 0; ch < s->nb_channels; ch++) {
434
            if (s->channel_coded[ch]) {
435
                int i, n, a;
436
                n = s->exponent_high_sizes[bsize];
437
                for(i=0;i<n;i++) {
438
                    a = get_bits1(&s->gb);
439
                    s->high_band_coded[ch][i] = a;
440
                    /* if noise coding, the coefficients are not transmitted */
441
                    if (a)
442
                        nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
443
                }
444
            }
445
        }
446
        for(ch = 0; ch < s->nb_channels; ch++) {
447
            if (s->channel_coded[ch]) {
448
                int i, n, val, code;
449

    
450
                n = s->exponent_high_sizes[bsize];
451
                val = (int)0x80000000;
452
                for(i=0;i<n;i++) {
453
                    if (s->high_band_coded[ch][i]) {
454
                        if (val == (int)0x80000000) {
455
                            val = get_bits(&s->gb, 7) - 19;
456
                        } else {
457
                            code = get_vlc2(&s->gb, s->hgain_vlc.table, HGAINVLCBITS, HGAINMAX);
458
                            if (code < 0)
459
                                return -1;
460
                            val += code - 18;
461
                        }
462
                        s->high_band_values[ch][i] = val;
463
                    }
464
                }
465
            }
466
        }
467
    }
468

    
469
    /* exponents can be reused in short blocks. */
470
    if ((s->block_len_bits == s->frame_len_bits) ||
471
        get_bits1(&s->gb)) {
472
        for(ch = 0; ch < s->nb_channels; ch++) {
473
            if (s->channel_coded[ch]) {
474
                if (s->use_exp_vlc) {
475
                    if (decode_exp_vlc(s, ch) < 0)
476
                        return -1;
477
                } else {
478
                    decode_exp_lsp(s, ch);
479
                }
480
                s->exponents_bsize[ch] = bsize;
481
            }
482
        }
483
    }
484

    
485
    /* parse spectral coefficients : just RLE encoding */
486
    for(ch = 0; ch < s->nb_channels; ch++) {
487
        if (s->channel_coded[ch]) {
488
            VLC *coef_vlc;
489
            int level, run, sign, tindex;
490
            int16_t *ptr, *eptr;
491
            const uint16_t *level_table, *run_table;
492

    
493
            /* special VLC tables are used for ms stereo because
494
               there is potentially less energy there */
495
            tindex = (ch == 1 && s->ms_stereo);
496
            coef_vlc = &s->coef_vlc[tindex];
497
            run_table = s->run_table[tindex];
498
            level_table = s->level_table[tindex];
499
            /* XXX: optimize */
500
            ptr = &s->coefs1[ch][0];
501
            eptr = ptr + nb_coefs[ch];
502
            memset(ptr, 0, s->block_len * sizeof(int16_t));
503
            for(;;) {
504
                code = get_vlc2(&s->gb, coef_vlc->table, VLCBITS, VLCMAX);
505
                if (code < 0)
506
                    return -1;
507
                if (code == 1) {
508
                    /* EOB */
509
                    break;
510
                } else if (code == 0) {
511
                    /* escape */
512
                    level = get_bits(&s->gb, coef_nb_bits);
513
                    /* NOTE: this is rather suboptimal. reading
514
                       block_len_bits would be better */
515
                    run = get_bits(&s->gb, s->frame_len_bits);
516
                } else {
517
                    /* normal code */
518
                    run = run_table[code];
519
                    level = level_table[code];
520
                }
521
                sign = get_bits1(&s->gb);
522
                if (!sign)
523
                    level = -level;
524
                ptr += run;
525
                if (ptr >= eptr)
526
                {
527
                    av_log(NULL, AV_LOG_ERROR, "overflow in spectral RLE, ignoring\n");
528
                    break;
529
                }
530
                *ptr++ = level;
531
                /* NOTE: EOB can be omitted */
532
                if (ptr >= eptr)
533
                    break;
534
            }
535
        }
536
        if (s->version == 1 && s->nb_channels >= 2) {
537
            align_get_bits(&s->gb);
538
        }
539
    }
540

    
541
    /* normalize */
542
    {
543
        int n4 = s->block_len / 2;
544
        mdct_norm = 1.0 / (float)n4;
545
        if (s->version == 1) {
546
            mdct_norm *= sqrt(n4);
547
        }
548
    }
549

    
550
    /* finally compute the MDCT coefficients */
551
    for(ch = 0; ch < s->nb_channels; ch++) {
552
        if (s->channel_coded[ch]) {
553
            int16_t *coefs1;
554
            float *coefs, *exponents, mult, mult1, noise;
555
            int i, j, n, n1, last_high_band, esize;
556
            float exp_power[HIGH_BAND_MAX_SIZE];
557

    
558
            coefs1 = s->coefs1[ch];
559
            exponents = s->exponents[ch];
560
            esize = s->exponents_bsize[ch];
561
            mult = pow(10, total_gain * 0.05) / s->max_exponent[ch];
562
            mult *= mdct_norm;
563
            coefs = s->coefs[ch];
564
            if (s->use_noise_coding) {
565
                mult1 = mult;
566
                /* very low freqs : noise */
567
                for(i = 0;i < s->coefs_start; i++) {
568
                    *coefs++ = s->noise_table[s->noise_index] *
569
                      exponents[i<<bsize>>esize] * mult1;
570
                    s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
571
                }
572

    
573
                n1 = s->exponent_high_sizes[bsize];
574

    
575
                /* compute power of high bands */
576
                exponents = s->exponents[ch] +
577
                    (s->high_band_start[bsize]<<bsize);
578
                last_high_band = 0; /* avoid warning */
579
                for(j=0;j<n1;j++) {
580
                    n = s->exponent_high_bands[s->frame_len_bits -
581
                                              s->block_len_bits][j];
582
                    if (s->high_band_coded[ch][j]) {
583
                        float e2, v;
584
                        e2 = 0;
585
                        for(i = 0;i < n; i++) {
586
                            v = exponents[i<<bsize>>esize];
587
                            e2 += v * v;
588
                        }
589
                        exp_power[j] = e2 / n;
590
                        last_high_band = j;
591
                        tprintf(s->avctx, "%d: power=%f (%d)\n", j, exp_power[j], n);
592
                    }
593
                    exponents += n<<bsize;
594
                }
595

    
596
                /* main freqs and high freqs */
597
                exponents = s->exponents[ch] + (s->coefs_start<<bsize);
598
                for(j=-1;j<n1;j++) {
599
                    if (j < 0) {
600
                        n = s->high_band_start[bsize] -
601
                            s->coefs_start;
602
                    } else {
603
                        n = s->exponent_high_bands[s->frame_len_bits -
604
                                                  s->block_len_bits][j];
605
                    }
606
                    if (j >= 0 && s->high_band_coded[ch][j]) {
607
                        /* use noise with specified power */
608
                        mult1 = sqrt(exp_power[j] / exp_power[last_high_band]);
609
                        /* XXX: use a table */
610
                        mult1 = mult1 * pow(10, s->high_band_values[ch][j] * 0.05);
611
                        mult1 = mult1 / (s->max_exponent[ch] * s->noise_mult);
612
                        mult1 *= mdct_norm;
613
                        for(i = 0;i < n; i++) {
614
                            noise = s->noise_table[s->noise_index];
615
                            s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
616
                            *coefs++ =  noise *
617
                                exponents[i<<bsize>>esize] * mult1;
618
                        }
619
                        exponents += n<<bsize;
620
                    } else {
621
                        /* coded values + small noise */
622
                        for(i = 0;i < n; i++) {
623
                            noise = s->noise_table[s->noise_index];
624
                            s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
625
                            *coefs++ = ((*coefs1++) + noise) *
626
                                exponents[i<<bsize>>esize] * mult;
627
                        }
628
                        exponents += n<<bsize;
629
                    }
630
                }
631

    
632
                /* very high freqs : noise */
633
                n = s->block_len - s->coefs_end[bsize];
634
                mult1 = mult * exponents[((-1<<bsize))>>esize];
635
                for(i = 0; i < n; i++) {
636
                    *coefs++ = s->noise_table[s->noise_index] * mult1;
637
                    s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
638
                }
639
            } else {
640
                /* XXX: optimize more */
641
                for(i = 0;i < s->coefs_start; i++)
642
                    *coefs++ = 0.0;
643
                n = nb_coefs[ch];
644
                for(i = 0;i < n; i++) {
645
                    *coefs++ = coefs1[i] * exponents[i<<bsize>>esize] * mult;
646
                }
647
                n = s->block_len - s->coefs_end[bsize];
648
                for(i = 0;i < n; i++)
649
                    *coefs++ = 0.0;
650
            }
651
        }
652
    }
653

    
654
#ifdef TRACE
655
    for(ch = 0; ch < s->nb_channels; ch++) {
656
        if (s->channel_coded[ch]) {
657
            dump_floats(s, "exponents", 3, s->exponents[ch], s->block_len);
658
            dump_floats(s, "coefs", 1, s->coefs[ch], s->block_len);
659
        }
660
    }
661
#endif
662

    
663
    if (s->ms_stereo && s->channel_coded[1]) {
664
        float a, b;
665
        int i;
666

    
667
        /* nominal case for ms stereo: we do it before mdct */
668
        /* no need to optimize this case because it should almost
669
           never happen */
670
        if (!s->channel_coded[0]) {
671
            tprintf(s->avctx, "rare ms-stereo case happened\n");
672
            memset(s->coefs[0], 0, sizeof(float) * s->block_len);
673
            s->channel_coded[0] = 1;
674
        }
675

    
676
        for(i = 0; i < s->block_len; i++) {
677
            a = s->coefs[0][i];
678
            b = s->coefs[1][i];
679
            s->coefs[0][i] = a + b;
680
            s->coefs[1][i] = a - b;
681
        }
682
    }
683

    
684
next:
685
    for(ch = 0; ch < s->nb_channels; ch++) {
686
        int n4, index;
687

    
688
        n4 = s->block_len / 2;
689
        if(s->channel_coded[ch]){
690
            ff_imdct_calc(&s->mdct_ctx[bsize], s->output, s->coefs[ch]);
691
        }else if(!(s->ms_stereo && ch==1))
692
            memset(s->output, 0, sizeof(s->output));
693

    
694
        /* multiply by the window and add in the frame */
695
        index = (s->frame_len / 2) + s->block_pos - n4;
696
        wma_window(s, &s->frame_out[ch][index]);
697
    }
698

    
699
    /* update block number */
700
    s->block_num++;
701
    s->block_pos += s->block_len;
702
    if (s->block_pos >= s->frame_len)
703
        return 1;
704
    else
705
        return 0;
706
}
707

    
708
/* decode a frame of frame_len samples */
709
static int wma_decode_frame(WMACodecContext *s, int16_t *samples)
710
{
711
    int ret, i, n, ch, incr;
712
    int16_t *ptr;
713
    float *iptr;
714

    
715
#ifdef TRACE
716
    tprintf(s->avctx, "***decode_frame: %d size=%d\n", s->frame_count++, s->frame_len);
717
#endif
718

    
719
    /* read each block */
720
    s->block_num = 0;
721
    s->block_pos = 0;
722
    for(;;) {
723
        ret = wma_decode_block(s);
724
        if (ret < 0)
725
            return -1;
726
        if (ret)
727
            break;
728
    }
729

    
730
    /* convert frame to integer */
731
    n = s->frame_len;
732
    incr = s->nb_channels;
733
    for(ch = 0; ch < s->nb_channels; ch++) {
734
        ptr = samples + ch;
735
        iptr = s->frame_out[ch];
736

    
737
        for(i=0;i<n;i++) {
738
            *ptr = av_clip_int16(lrintf(*iptr++));
739
            ptr += incr;
740
        }
741
        /* prepare for next block */
742
        memmove(&s->frame_out[ch][0], &s->frame_out[ch][s->frame_len],
743
                s->frame_len * sizeof(float));
744
    }
745

    
746
#ifdef TRACE
747
    dump_shorts(s, "samples", samples, n * s->nb_channels);
748
#endif
749
    return 0;
750
}
751

    
752
static int wma_decode_superframe(AVCodecContext *avctx,
753
                                 void *data, int *data_size,
754
                                 AVPacket *avpkt)
755
{
756
    const uint8_t *buf = avpkt->data;
757
    int buf_size = avpkt->size;
758
    WMACodecContext *s = avctx->priv_data;
759
    int nb_frames, bit_offset, i, pos, len;
760
    uint8_t *q;
761
    int16_t *samples;
762

    
763
    tprintf(avctx, "***decode_superframe:\n");
764

    
765
    if(buf_size==0){
766
        s->last_superframe_len = 0;
767
        return 0;
768
    }
769
    if (buf_size < s->block_align)
770
        return 0;
771
    buf_size = s->block_align;
772

    
773
    samples = data;
774

    
775
    init_get_bits(&s->gb, buf, buf_size*8);
776

    
777
    if (s->use_bit_reservoir) {
778
        /* read super frame header */
779
        skip_bits(&s->gb, 4); /* super frame index */
780
        nb_frames = get_bits(&s->gb, 4) - 1;
781

    
782
        if((nb_frames+1) * s->nb_channels * s->frame_len * sizeof(int16_t) > *data_size){
783
            av_log(s->avctx, AV_LOG_ERROR, "Insufficient output space\n");
784
            goto fail;
785
        }
786

    
787
        bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3);
788

    
789
        if (s->last_superframe_len > 0) {
790
            //        printf("skip=%d\n", s->last_bitoffset);
791
            /* add bit_offset bits to last frame */
792
            if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) >
793
                MAX_CODED_SUPERFRAME_SIZE)
794
                goto fail;
795
            q = s->last_superframe + s->last_superframe_len;
796
            len = bit_offset;
797
            while (len > 7) {
798
                *q++ = (get_bits)(&s->gb, 8);
799
                len -= 8;
800
            }
801
            if (len > 0) {
802
                *q++ = (get_bits)(&s->gb, len) << (8 - len);
803
            }
804

    
805
            /* XXX: bit_offset bits into last frame */
806
            init_get_bits(&s->gb, s->last_superframe, MAX_CODED_SUPERFRAME_SIZE*8);
807
            /* skip unused bits */
808
            if (s->last_bitoffset > 0)
809
                skip_bits(&s->gb, s->last_bitoffset);
810
            /* this frame is stored in the last superframe and in the
811
               current one */
812
            if (wma_decode_frame(s, samples) < 0)
813
                goto fail;
814
            samples += s->nb_channels * s->frame_len;
815
        }
816

    
817
        /* read each frame starting from bit_offset */
818
        pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3;
819
        init_get_bits(&s->gb, buf + (pos >> 3), (MAX_CODED_SUPERFRAME_SIZE - (pos >> 3))*8);
820
        len = pos & 7;
821
        if (len > 0)
822
            skip_bits(&s->gb, len);
823

    
824
        s->reset_block_lengths = 1;
825
        for(i=0;i<nb_frames;i++) {
826
            if (wma_decode_frame(s, samples) < 0)
827
                goto fail;
828
            samples += s->nb_channels * s->frame_len;
829
        }
830

    
831
        /* we copy the end of the frame in the last frame buffer */
832
        pos = get_bits_count(&s->gb) + ((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7);
833
        s->last_bitoffset = pos & 7;
834
        pos >>= 3;
835
        len = buf_size - pos;
836
        if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) {
837
            goto fail;
838
        }
839
        s->last_superframe_len = len;
840
        memcpy(s->last_superframe, buf + pos, len);
841
    } else {
842
        if(s->nb_channels * s->frame_len * sizeof(int16_t) > *data_size){
843
            av_log(s->avctx, AV_LOG_ERROR, "Insufficient output space\n");
844
            goto fail;
845
        }
846
        /* single frame decode */
847
        if (wma_decode_frame(s, samples) < 0)
848
            goto fail;
849
        samples += s->nb_channels * s->frame_len;
850
    }
851

    
852
//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d outbytes:%d eaten:%d\n", s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len,        (int8_t *)samples - (int8_t *)data, s->block_align);
853

    
854
    *data_size = (int8_t *)samples - (int8_t *)data;
855
    return s->block_align;
856
 fail:
857
    /* when error, we reset the bit reservoir */
858
    s->last_superframe_len = 0;
859
    return -1;
860
}
861

    
862
AVCodec wmav1_decoder =
863
{
864
    "wmav1",
865
    CODEC_TYPE_AUDIO,
866
    CODEC_ID_WMAV1,
867
    sizeof(WMACodecContext),
868
    wma_decode_init,
869
    NULL,
870
    ff_wma_end,
871
    wma_decode_superframe,
872
    .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
873
};
874

    
875
AVCodec wmav2_decoder =
876
{
877
    "wmav2",
878
    CODEC_TYPE_AUDIO,
879
    CODEC_ID_WMAV2,
880
    sizeof(WMACodecContext),
881
    wma_decode_init,
882
    NULL,
883
    ff_wma_end,
884
    wma_decode_superframe,
885
    .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
886
};