Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wmadec.c @ 7ae7300e

History | View | Annotate | Download (27.2 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 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);
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
    return 0;
130
}
131

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
290

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

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

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

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

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

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

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

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

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

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

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

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

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

    
344

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

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

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

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

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

    
395
    if (s->nb_channels == 2) {
396
        s->ms_stereo = get_bits1(&s->gb);
397
    }
398
    v = 0;
399
    for(ch = 0; ch < s->nb_channels; ch++) {
400
        a = get_bits1(&s->gb);
401
        s->channel_coded[ch] = a;
402
        v |= a;
403
    }
404
    /* if no channel coded, no need to go further */
405
    /* XXX: fix potential framing problems */
406
    if (!v)
407
        goto next;
408

    
409
    bsize = s->frame_len_bits - s->block_len_bits;
410

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

    
421
    coef_nb_bits= ff_wma_total_gain_to_bits(total_gain);
422

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

    
428
    /* complex coding */
429
    if (s->use_noise_coding) {
430

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

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

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

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

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

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

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

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

    
571
                n1 = s->exponent_high_sizes[bsize];
572

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

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

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

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

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

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

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

    
682
    for(ch = 0; ch < s->nb_channels; ch++) {
683
        if (s->channel_coded[ch]) {
684
            int n4, index, n;
685

    
686
            n = s->block_len;
687
            n4 = s->block_len / 2;
688
            s->mdct_ctx[bsize].fft.imdct_calc(&s->mdct_ctx[bsize],
689
                          s->output, s->coefs[ch], s->mdct_tmp);
690

    
691
            /* multiply by the window and add in the frame */
692
            index = (s->frame_len / 2) + s->block_pos - n4;
693
            wma_window(s, &s->frame_out[ch][index]);
694

    
695
            /* specific fast case for ms-stereo : add to second
696
               channel if it is not coded */
697
            if (s->ms_stereo && !s->channel_coded[1]) {
698
                wma_window(s, &s->frame_out[1][index]);
699
            }
700
        }
701
    }
702
 next:
703
    /* update block number */
704
    s->block_num++;
705
    s->block_pos += s->block_len;
706
    if (s->block_pos >= s->frame_len)
707
        return 1;
708
    else
709
        return 0;
710
}
711

    
712
/* decode a frame of frame_len samples */
713
static int wma_decode_frame(WMACodecContext *s, int16_t *samples)
714
{
715
    int ret, i, n, a, ch, incr;
716
    int16_t *ptr;
717
    float *iptr;
718

    
719
#ifdef TRACE
720
    tprintf(s->avctx, "***decode_frame: %d size=%d\n", s->frame_count++, s->frame_len);
721
#endif
722

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

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

    
741
        for(i=0;i<n;i++) {
742
            a = lrintf(*iptr++);
743
            if (a > 32767)
744
                a = 32767;
745
            else if (a < -32768)
746
                a = -32768;
747
            *ptr = a;
748
            ptr += incr;
749
        }
750
        /* prepare for next block */
751
        memmove(&s->frame_out[ch][0], &s->frame_out[ch][s->frame_len],
752
                s->frame_len * sizeof(float));
753
    }
754

    
755
#ifdef TRACE
756
    dump_shorts(s, "samples", samples, n * s->nb_channels);
757
#endif
758
    return 0;
759
}
760

    
761
static int wma_decode_superframe(AVCodecContext *avctx,
762
                                 void *data, int *data_size,
763
                                 uint8_t *buf, int buf_size)
764
{
765
    WMACodecContext *s = avctx->priv_data;
766
    int nb_frames, bit_offset, i, pos, len;
767
    uint8_t *q;
768
    int16_t *samples;
769

    
770
    tprintf(avctx, "***decode_superframe:\n");
771

    
772
    if(buf_size==0){
773
        s->last_superframe_len = 0;
774
        return 0;
775
    }
776

    
777
    samples = data;
778

    
779
    init_get_bits(&s->gb, buf, buf_size*8);
780

    
781
    if (s->use_bit_reservoir) {
782
        /* read super frame header */
783
        skip_bits(&s->gb, 4); /* super frame index */
784
        nb_frames = get_bits(&s->gb, 4) - 1;
785

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

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

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

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

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

    
830
        /* we copy the end of the frame in the last frame buffer */
831
        pos = get_bits_count(&s->gb) + ((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7);
832
        s->last_bitoffset = pos & 7;
833
        pos >>= 3;
834
        len = buf_size - pos;
835
        if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) {
836
            goto fail;
837
        }
838
        s->last_superframe_len = len;
839
        memcpy(s->last_superframe, buf + pos, len);
840
    } else {
841
        /* single frame decode */
842
        if (wma_decode_frame(s, samples) < 0)
843
            goto fail;
844
        samples += s->nb_channels * s->frame_len;
845
    }
846

    
847
//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);
848

    
849
    *data_size = (int8_t *)samples - (int8_t *)data;
850
    return s->block_align;
851
 fail:
852
    /* when error, we reset the bit reservoir */
853
    s->last_superframe_len = 0;
854
    return -1;
855
}
856

    
857
AVCodec wmav1_decoder =
858
{
859
    "wmav1",
860
    CODEC_TYPE_AUDIO,
861
    CODEC_ID_WMAV1,
862
    sizeof(WMACodecContext),
863
    wma_decode_init,
864
    NULL,
865
    ff_wma_end,
866
    wma_decode_superframe,
867
};
868

    
869
AVCodec wmav2_decoder =
870
{
871
    "wmav2",
872
    CODEC_TYPE_AUDIO,
873
    CODEC_ID_WMAV2,
874
    sizeof(WMACodecContext),
875
    wma_decode_init,
876
    NULL,
877
    ff_wma_end,
878
    wma_decode_superframe,
879
};