Revision c1061cc7 libavcodec/wmaprodec.c

View differences:

libavcodec/wmaprodec.c
86 86
 * subframe in order to reconstruct the output samples.
87 87
 */
88 88

  
89
#include "avcodec.h"
90
#include "internal.h"
91
#include "get_bits.h"
92
#include "put_bits.h"
93
#include "wmaprodata.h"
94
#include "dsputil.h"
95
#include "wma.h"
96

  
97
/** current decoder limitations */
98
#define WMAPRO_MAX_CHANNELS    8                             ///< max number of handled channels
99
#define MAX_SUBFRAMES  32                                    ///< max number of subframes per channel
100
#define MAX_BANDS      29                                    ///< max number of scale factor bands
101
#define MAX_FRAMESIZE  16384                                 ///< maximum compressed frame size
102

  
103
#define WMAPRO_BLOCK_MAX_BITS 12                                           ///< log2 of max block size
104
#define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS)                 ///< maximum block size
105
#define WMAPRO_BLOCK_SIZES    (WMAPRO_BLOCK_MAX_BITS - BLOCK_MIN_BITS + 1) ///< possible block sizes
106

  
107

  
108
#define VLCBITS            9
109
#define SCALEVLCBITS       8
110
#define VEC4MAXDEPTH    ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
111
#define VEC2MAXDEPTH    ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
112
#define VEC1MAXDEPTH    ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
113
#define SCALEMAXDEPTH   ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
114
#define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
115

  
116
static VLC              sf_vlc;           ///< scale factor DPCM vlc
117
static VLC              sf_rl_vlc;        ///< scale factor run length vlc
118
static VLC              vec4_vlc;         ///< 4 coefficients per symbol
119
static VLC              vec2_vlc;         ///< 2 coefficients per symbol
120
static VLC              vec1_vlc;         ///< 1 coefficient per symbol
121
static VLC              coef_vlc[2];      ///< coefficient run length vlc codes
122
static float            sin64[33];        ///< sinus table for decorrelation
123

  
124
/**
125
 * @brief frame specific decoder context for a single channel
126
 */
127
typedef struct {
128
    int16_t  prev_block_len;                          ///< length of the previous block
129
    uint8_t  transmit_coefs;
130
    uint8_t  num_subframes;
131
    uint16_t subframe_len[MAX_SUBFRAMES];             ///< subframe length in samples
132
    uint16_t subframe_offset[MAX_SUBFRAMES];          ///< subframe positions in the current frame
133
    uint8_t  cur_subframe;                            ///< current subframe number
134
    uint16_t decoded_samples;                         ///< number of already processed samples
135
    uint8_t  grouped;                                 ///< channel is part of a group
136
    int      quant_step;                              ///< quantization step for the current subframe
137
    int8_t   reuse_sf;                                ///< share scale factors between subframes
138
    int8_t   scale_factor_step;                       ///< scaling step for the current subframe
139
    int      max_scale_factor;                        ///< maximum scale factor for the current subframe
140
    int      scale_factors[MAX_BANDS];                ///< scale factor values for the current subframe
141
    int      saved_scale_factors[MAX_BANDS];          ///< scale factors from a previous subframe
142
    uint8_t  table_idx;                               ///< index in sf_offsets for the scale factor reference block
143
    float*   coeffs;                                  ///< pointer to the subframe decode buffer
144
    DECLARE_ALIGNED_16(float, out[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]); ///< output buffer
145
} WMAProChannelCtx;
146

  
147
/**
148
 * @brief channel group for channel transformations
149
 */
150
typedef struct {
151
    uint8_t num_channels;                                     ///< number of channels in the group
152
    int8_t  transform;                                        ///< transform on / off
153
    int8_t  transform_band[MAX_BANDS];                        ///< controls if the transform is enabled for a certain band
154
    float   decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];
155
    float*  channel_data[WMAPRO_MAX_CHANNELS];                ///< transformation coefficients
156
} WMAProChannelGrp;
157

  
158
/**
159
 * @brief main decoder context
160
 */
161
typedef struct WMAProDecodeCtx {
162
    /* generic decoder variables */
163
    AVCodecContext*  avctx;                         ///< codec context for av_log
164
    DSPContext       dsp;                           ///< accelerated DSP functions
165
    uint8_t          frame_data[MAX_FRAMESIZE +
166
                      FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
167
    PutBitContext    pb;                            ///< context for filling the frame_data buffer
168
    MDCTContext      mdct_ctx[WMAPRO_BLOCK_SIZES];  ///< MDCT context per block size
169
    DECLARE_ALIGNED_16(float, tmp[WMAPRO_BLOCK_MAX_SIZE]); ///< IMDCT output buffer
170
    float*           windows[WMAPRO_BLOCK_SIZES];   ///< windows for the different block sizes
171

  
172
    /* frame size dependent frame information (set during initialization) */
173
    uint32_t         decode_flags;                  ///< used compression features
174
    uint8_t          len_prefix;                    ///< frame is prefixed with its length
175
    uint8_t          dynamic_range_compression;     ///< frame contains DRC data
176
    uint8_t          bits_per_sample;               ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
177
    uint16_t         samples_per_frame;             ///< number of samples to output
178
    uint16_t         log2_frame_size;
179
    int8_t           num_channels;                  ///< number of channels in the stream (same as AVCodecContext.num_channels)
180
    int8_t           lfe_channel;                   ///< lfe channel index
181
    uint8_t          max_num_subframes;
182
    uint8_t          subframe_len_bits;             ///< number of bits used for the subframe length
183
    uint8_t          max_subframe_len_bit;          ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
184
    uint16_t         min_samples_per_subframe;
185
    int8_t           num_sfb[WMAPRO_BLOCK_SIZES];   ///< scale factor bands per block size
186
    int16_t          sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS];                    ///< scale factor band offsets (multiples of 4)
187
    int8_t           sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
188
    int16_t          subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values
189

  
190
    /* packet decode state */
191
    uint8_t          packet_sequence_number;        ///< current packet number
192
    int              num_saved_bits;                ///< saved number of bits
193
    int              frame_offset;                  ///< frame offset in the bit reservoir
194
    int              subframe_offset;               ///< subframe offset in the bit reservoir
195
    uint8_t          packet_loss;                   ///< set in case of bitstream error
196

  
197
    /* frame decode state */
198
    uint32_t         frame_num;                     ///< current frame number (not used for decoding)
199
    GetBitContext    gb;                            ///< bitstream reader context
200
    int              buf_bit_size;                  ///< buffer size in bits
201
    float*           samples;                       ///< current samplebuffer pointer
202
    float*           samples_end;                   ///< maximum samplebuffer pointer
203
    uint8_t          drc_gain;                      ///< gain for the DRC tool
204
    int8_t           skip_frame;                    ///< skip output step
205
    int8_t           parsed_all_subframes;          ///< all subframes decoded?
206

  
207
    /* subframe/block decode state */
208
    int16_t          subframe_len;                  ///< current subframe length
209
    int8_t           channels_for_cur_subframe;     ///< number of channels that contain the subframe
210
    int8_t           channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS];
211
    int8_t           num_bands;                     ///< number of scale factor bands
212
    int16_t*         cur_sfb_offsets;               ///< sfb offsets for the current block
213
    uint8_t          table_idx;                     ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
214
    int8_t           esc_len;                       ///< length of escaped coefficients
215

  
216
    uint8_t          num_chgroups;                  ///< number of channel groups
217
    WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS];  ///< channel group information
218

  
219
    WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS];  ///< per channel data
220
} WMAProDecodeCtx;
221

  
222

  
223
/**
224
 *@brief helper function to print the most important members of the context
225
 *@param s context
226
 */
227
static void av_cold dump_context(WMAProDecodeCtx *s)
228
{
229
#define PRINT(a, b)     av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
230
#define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b);
231

  
232
    PRINT("ed sample bit depth", s->bits_per_sample);
233
    PRINT_HEX("ed decode flags", s->decode_flags);
234
    PRINT("samples per frame",   s->samples_per_frame);
235
    PRINT("log2 frame size",     s->log2_frame_size);
236
    PRINT("max num subframes",   s->max_num_subframes);
237
    PRINT("len prefix",          s->len_prefix);
238
    PRINT("num channels",        s->num_channels);
239
}
240

  
89 241
/**
90 242
 *@brief Uninitialize the decoder and free all resources.
91 243
 *@param avctx codec context
......
93 245
 */
94 246
static av_cold int decode_end(AVCodecContext *avctx)
95 247
{
96
    WMA3DecodeContext *s = avctx->priv_data;
248
    WMAProDecodeCtx *s = avctx->priv_data;
97 249
    int i;
98 250

  
99 251
    for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
......
103 255
}
104 256

  
105 257
/**
258
 *@brief Initialize the decoder.
259
 *@param avctx codec context
260
 *@return 0 on success, -1 otherwise
261
 */
262
static av_cold int decode_init(AVCodecContext *avctx)
263
{
264
    WMAProDecodeCtx *s = avctx->priv_data;
265
    uint8_t *edata_ptr   = avctx->extradata;
266
    unsigned int channel_mask;
267
    int i;
268
    int log2_max_num_subframes;
269
    int num_possible_block_sizes;
270

  
271
    s->avctx = avctx;
272
    dsputil_init(&s->dsp, avctx);
273
    init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
274

  
275
    avctx->sample_fmt = SAMPLE_FMT_FLT;
276

  
277
    if (avctx->extradata_size >= 18) {
278
        s->decode_flags    = AV_RL16(edata_ptr+14);
279
        channel_mask       = AV_RL32(edata_ptr+2);
280
        s->bits_per_sample = AV_RL16(edata_ptr);
281
        /** dump the extradata */
282
        for (i = 0; i < avctx->extradata_size; i++)
283
            dprintf(avctx, "[%x] ", avctx->extradata[i]);
284
        dprintf(avctx, "\n");
285

  
286
    } else {
287
        av_log_ask_for_sample(avctx, "Unknown extradata size\n");
288
        return AVERROR_INVALIDDATA;
289
    }
290

  
291
    /** generic init */
292
    s->log2_frame_size = av_log2(avctx->block_align) + 4;
293

  
294
    /** frame info */
295
    s->skip_frame  = 1; /** skip first frame */
296
    s->packet_loss = 1;
297
    s->len_prefix  = (s->decode_flags & 0x40);
298

  
299
    if (!s->len_prefix) {
300
        av_log_ask_for_sample(avctx, "no length prefix\n");
301
        return AVERROR_INVALIDDATA;
302
    }
303

  
304
    /** get frame len */
305
    s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
306
                                                          3, s->decode_flags);
307

  
308
    /** init previous block len */
309
    for (i = 0; i < avctx->channels; i++)
310
        s->channel[i].prev_block_len = s->samples_per_frame;
311

  
312
    /** subframe info */
313
    log2_max_num_subframes       = ((s->decode_flags & 0x38) >> 3);
314
    s->max_num_subframes         = 1 << log2_max_num_subframes;
315
    if (s->max_num_subframes == 16)
316
        s->max_subframe_len_bit = 1;
317
    s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
318

  
319
    num_possible_block_sizes     = log2_max_num_subframes + 1;
320
    s->min_samples_per_subframe  = s->samples_per_frame / s->max_num_subframes;
321
    s->dynamic_range_compression = (s->decode_flags & 0x80);
322

  
323
    if (s->max_num_subframes > MAX_SUBFRAMES) {
324
        av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
325
               s->max_num_subframes);
326
        return AVERROR_INVALIDDATA;
327
    }
328

  
329
    s->num_channels = avctx->channels;
330

  
331
    /** extract lfe channel position */
332
    s->lfe_channel = -1;
333

  
334
    if (channel_mask & 8) {
335
        unsigned int mask;
336
        for (mask = 1; mask < 16; mask <<= 1) {
337
            if (channel_mask & mask)
338
                ++s->lfe_channel;
339
        }
340
    }
341

  
342
    if (s->num_channels < 0 || s->num_channels > WMAPRO_MAX_CHANNELS) {
343
        av_log_ask_for_sample(avctx, "invalid number of channels\n");
344
        return AVERROR_NOTSUPP;
345
    }
346

  
347
    INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
348
                    scale_huffbits, 1, 1,
349
                    scale_huffcodes, 2, 2, 616);
350

  
351
    INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
352
                    scale_rl_huffbits, 1, 1,
353
                    scale_rl_huffcodes, 4, 4, 1406);
354

  
355
    INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
356
                    coef0_huffbits, 1, 1,
357
                    coef0_huffcodes, 4, 4, 2108);
358

  
359
    INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
360
                    coef1_huffbits, 1, 1,
361
                    coef1_huffcodes, 4, 4, 3912);
362

  
363
    INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
364
                    vec4_huffbits, 1, 1,
365
                    vec4_huffcodes, 2, 2, 604);
366

  
367
    INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
368
                    vec2_huffbits, 1, 1,
369
                    vec2_huffcodes, 2, 2, 562);
370

  
371
    INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
372
                    vec1_huffbits, 1, 1,
373
                    vec1_huffcodes, 2, 2, 562);
374

  
375
    /** calculate number of scale factor bands and their offsets
376
        for every possible block size */
377
    for (i = 0; i < num_possible_block_sizes; i++) {
378
        int subframe_len = s->samples_per_frame >> i;
379
        int x;
380
        int band = 1;
381

  
382
        s->sfb_offsets[i][0] = 0;
383

  
384
        for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band-1] < subframe_len; x++) {
385
            int offset = (subframe_len * 2 * critical_freq[x])
386
                          / s->avctx->sample_rate + 2;
387
            offset &= ~3;
388
            if ( offset > s->sfb_offsets[i][band - 1] )
389
                s->sfb_offsets[i][band++] = offset;
390
        }
391
        s->sfb_offsets[i][band - 1] = subframe_len;
392
        s->num_sfb[i]               = band - 1;
393
    }
394

  
395

  
396
    /** Scale factors can be shared between blocks of different size
397
        as every block has a different scale factor band layout.
398
        The matrix sf_offsets is needed to find the correct scale factor.
399
     */
400

  
401
    for (i = 0; i < num_possible_block_sizes; i++) {
402
        int b;
403
        for (b = 0; b < s->num_sfb[i]; b++) {
404
            int x;
405
            int offset = ((s->sfb_offsets[i][b]
406
                         + s->sfb_offsets[i][b + 1] - 1)<<i) >> 1;
407
            for (x = 0; x < num_possible_block_sizes; x++) {
408
                int v = 0;
409
                while (s->sfb_offsets[x][v + 1] << x < offset)
410
                    ++v;
411
                s->sf_offsets[i][x][b] = v;
412
            }
413
        }
414
    }
415

  
416
    /** init MDCT, FIXME: only init needed sizes */
417
    for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
418
        ff_mdct_init(&s->mdct_ctx[i], BLOCK_MIN_BITS+1+i, 1,
419
                     1.0 / (1 <<(BLOCK_MIN_BITS + i - 1))
420
                     / (1 << (s->bits_per_sample - 1)));
421

  
422
    /** init MDCT windows: simple sinus window */
423
    for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
424
        const int n       = 1 << (WMAPRO_BLOCK_MAX_BITS - i);
425
        const int win_idx = WMAPRO_BLOCK_MAX_BITS - i - 7;
426
        ff_sine_window_init(ff_sine_windows[win_idx], n);
427
        s->windows[WMAPRO_BLOCK_SIZES-i-1] = ff_sine_windows[win_idx];
428
    }
429

  
430
    /** calculate subwoofer cutoff values */
431
    for (i = 0; i < num_possible_block_sizes; i++) {
432
        int block_size = s->samples_per_frame >> i;
433
        int cutoff = (440*block_size + 3 * (s->avctx->sample_rate >> 1) - 1)
434
                     / s->avctx->sample_rate;
435
        s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
436
    }
437

  
438
    /** calculate sine values for the decorrelation matrix */
439
    for (i = 0; i < 33; i++)
440
        sin64[i] = sin(i*M_PI / 64.0);
441

  
442
    if (avctx->debug & FF_DEBUG_BITSTREAM)
443
        dump_context(s);
444

  
445
    avctx->channel_layout = channel_mask;
446
    return 0;
447
}
448

  
449
/**
450
 *@brief Decode the subframe length.
451
 *@param s context
452
 *@param offset sample offset in the frame
453
 *@return decoded subframe length on success, < 0 in case of an error
454
 */
455
static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
456
{
457
    int frame_len_shift = 0;
458
    int subframe_len;
459

  
460
    /** no need to read from the bitstream when only one length is possible */
461
    if (offset == s->samples_per_frame - s->min_samples_per_subframe)
462
        return s->min_samples_per_subframe;
463

  
464
    /** 1 bit indicates if the subframe is of maximum length */
465
    if (s->max_subframe_len_bit) {
466
        if (get_bits1(&s->gb))
467
            frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
468
    } else
469
        frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
470

  
471
    subframe_len = s->samples_per_frame >> frame_len_shift;
472

  
473
    /** sanity check the length */
474
    if (subframe_len < s->min_samples_per_subframe
475
              || subframe_len > s->samples_per_frame) {
476
        av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
477
               subframe_len);
478
        return AVERROR_INVALIDDATA;
479
    }
480
    return subframe_len;
481
}
482

  
483
/**
484
 *@brief Decode how the data in the frame is split into subframes.
485
 *       Every WMA frame contains the encoded data for a fixed number of
486
 *       samples per channel. The data for every channel might be split
487
 *       into several subframes. This function will reconstruct the list of
488
 *       subframes for every channel.
489
 *
490
 *       If the subframes are not evenly split, the algorithm estimates the
491
 *       channels with the lowest number of total samples.
492
 *       Afterwards, for each of these channels a bit is read from the
493
 *       bitstream that indicates if the channel contains a subframe with the
494
 *       next subframe size that is going to be read from the bitstream or not.
495
 *       If a channel contains such a subframe, the subframe size gets added to
496
 *       the channel's subframe list.
497
 *       The algorithm repeats these steps until the frame is properly divided
498
 *       between the individual channels.
499
 *
500
 *@param s context
501
 *@return 0 on success, < 0 in case of an error
502
 */
503
static int decode_tilehdr(WMAProDecodeCtx *s)
504
{
505
    uint16_t num_samples[WMAPRO_MAX_CHANNELS];        /** sum of samples for all currently known subframes of a channel */
506
    uint8_t  contains_subframe[WMAPRO_MAX_CHANNELS];  /** flag indicating if a channel contains the current subframe */
507
    int channels_for_cur_subframe = s->num_channels;  /** number of channels that contain the current subframe */
508
    int fixed_channel_layout = 0;                     /** flag indicating that all channels use the same subframe offsets and sizes */
509
    int min_channel_len = 0;                          /** smallest sum of samples (channels with this length will be processed first) */
510
    int c;
511

  
512
    /* Should never consume more than 3073 bits (256 iterations for the
513
     * while loop when always the minimum amount of 128 samples is substracted
514
     * from missing samples in the 8 channel case).
515
     * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS  + 4)
516
     */
517

  
518
    /** reset tiling information */
519
    for (c = 0; c < s->num_channels; c++)
520
        s->channel[c].num_subframes = 0;
521

  
522
    memset(num_samples, 0, sizeof(num_samples));
523

  
524
    if (s->max_num_subframes == 1 || get_bits1(&s->gb))
525
        fixed_channel_layout = 1;
526

  
527
    /** loop until the frame data is split between the subframes */
528
    do {
529
        int subframe_len;
530

  
531
        /** check which channels contain the subframe */
532
        for (c = 0; c < s->num_channels; c++) {
533
            if (num_samples[c] == min_channel_len) {
534
                if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
535
                   (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
536
                    contains_subframe[c] = 1;
537
                else
538
                    contains_subframe[c] = get_bits1(&s->gb);
539
            } else
540
                contains_subframe[c] = 0;
541
        }
542

  
543
        /** get subframe length, subframe_len == 0 is not allowed */
544
        if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
545
            return AVERROR_INVALIDDATA;
546

  
547
        /** add subframes to the individual channels and find new min_channel_len */
548
        min_channel_len += subframe_len;
549
        for (c = 0; c < s->num_channels; c++) {
550
            WMAProChannelCtx* chan = &s->channel[c];
551

  
552
            if (contains_subframe[c]) {
553
                if (chan->num_subframes >= MAX_SUBFRAMES) {
554
                    av_log(s->avctx, AV_LOG_ERROR,
555
                           "broken frame: num subframes > 31\n");
556
                    return AVERROR_INVALIDDATA;
557
                }
558
                chan->subframe_len[chan->num_subframes] = subframe_len;
559
                num_samples[c] += subframe_len;
560
                ++chan->num_subframes;
561
                if (num_samples[c] > s->samples_per_frame) {
562
                    av_log(s->avctx, AV_LOG_ERROR,"broken frame: "
563
                           "channel len > samples_per_frame\n");
564
                    return AVERROR_INVALIDDATA;
565
                }
566
            } else if(num_samples[c] <= min_channel_len) {
567
                if (num_samples[c] < min_channel_len) {
568
                    channels_for_cur_subframe = 0;
569
                    min_channel_len = num_samples[c];
570
                }
571
                ++channels_for_cur_subframe;
572
            }
573
        }
574
    } while (min_channel_len < s->samples_per_frame);
575

  
576
    for (c = 0; c < s->num_channels; c++) {
577
        int i;
578
        int offset = 0;
579
        for (i = 0; i < s->channel[c].num_subframes; i++) {
580
            dprintf(s->avctx, "frame[%i] channel[%i] subframe[%i]"
581
                   " len %i\n", s->frame_num, c, i, s->channel[c].subframe_len[i]);
582
            s->channel[c].subframe_offset[i] = offset;
583
            offset += s->channel[c].subframe_len[i];
584
        }
585
    }
586

  
587
    return 0;
588
}
589

  
590
/**
106 591
 *@brief Calculate a decorrelation matrix from the bitstream parameters.
107 592
 *@param s codec context
108 593
 *@param chgroup channel group for which the matrix needs to be calculated
109 594
 */
110
static void decode_decorrelation_matrix(WMA3DecodeContext *s,
111
                                        WMA3ChannelGroup *chgroup)
595
static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
596
                                        WMAProChannelGrp *chgroup)
112 597
{
113 598
    int i;
114 599
    int offset = 0;
115 600
    int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
116
    memset(chgroup->decorrelation_matrix, 0,
117
           sizeof(float) *s->num_channels * s->num_channels);
601
    memset(chgroup->decorrelation_matrix, 0, s->num_channels *
602
           s->num_channels * sizeof(*chgroup->decorrelation_matrix));
118 603

  
119 604
    for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
120 605
        rotation_offset[i] = get_bits(&s->gb, 6);
......
153 638
}
154 639

  
155 640
/**
641
 *@brief Decode channel transformation parameters
642
 *@param s codec context
643
 *@return 0 in case of success, < 0 in case of bitstream errors
644
 */
645
static int decode_channel_transform(WMAProDecodeCtx* s)
646
{
647
    int i;
648
    /* should never consume more than 1921 bits for the 8 channel case
649
     * 1 + MAX_CHANNELS * ( MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
650
     * + MAX_CHANNELS + MAX_BANDS + 1)
651
     */
652

  
653
    /** in the one channel case channel transforms are pointless */
654
    s->num_chgroups = 0;
655
    if (s->num_channels > 1) {
656
        int remaining_channels = s->channels_for_cur_subframe;
657

  
658
        if (get_bits1(&s->gb)) {
659
            av_log_ask_for_sample(s->avctx,
660
                                  "unsupported channel transform bit\n");
661
            return AVERROR_INVALIDDATA;
662
        }
663

  
664
        for (s->num_chgroups = 0; remaining_channels &&
665
            s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
666
            WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
667
            float** channel_data = chgroup->channel_data;
668
            chgroup->num_channels = 0;
669
            chgroup->transform = 0;
670

  
671
            /** decode channel mask */
672
            if (remaining_channels > 2) {
673
                for (i = 0; i < s->channels_for_cur_subframe; i++) {
674
                    int channel_idx = s->channel_indexes_for_cur_subframe[i];
675
                    if (!s->channel[channel_idx].grouped
676
                        && get_bits1(&s->gb)) {
677
                        ++chgroup->num_channels;
678
                        s->channel[channel_idx].grouped = 1;
679
                        *channel_data++ = s->channel[channel_idx].coeffs;
680
                    }
681
                }
682
            } else {
683
                chgroup->num_channels = remaining_channels;
684
                for (i = 0; i < s->channels_for_cur_subframe; i++) {
685
                    int channel_idx = s->channel_indexes_for_cur_subframe[i];
686
                    if (!s->channel[channel_idx].grouped)
687
                        *channel_data++ = s->channel[channel_idx].coeffs;
688
                    s->channel[channel_idx].grouped = 1;
689
                }
690
            }
691

  
692
            /** decode transform type */
693
            if (chgroup->num_channels == 2) {
694
                if (get_bits1(&s->gb)) {
695
                    if (get_bits1(&s->gb)) {
696
                        av_log_ask_for_sample(s->avctx,
697
                               "unsupported channel transform type\n");
698
                    }
699
                } else {
700
                    chgroup->transform = 1;
701
                    if (s->num_channels == 2) {
702
                        chgroup->decorrelation_matrix[0] =  1.0;
703
                        chgroup->decorrelation_matrix[1] = -1.0;
704
                        chgroup->decorrelation_matrix[2] =  1.0;
705
                        chgroup->decorrelation_matrix[3] =  1.0;
706
                    } else {
707
                        /** cos(pi/4) */
708
                        chgroup->decorrelation_matrix[0] =  0.70703125;
709
                        chgroup->decorrelation_matrix[1] = -0.70703125;
710
                        chgroup->decorrelation_matrix[2] =  0.70703125;
711
                        chgroup->decorrelation_matrix[3] =  0.70703125;
712
                    }
713
                }
714
            } else if (chgroup->num_channels > 2) {
715
                if (get_bits1(&s->gb)) {
716
                    chgroup->transform = 1;
717
                    if (get_bits1(&s->gb)) {
718
                        decode_decorrelation_matrix(s, chgroup);
719
                    } else {
720
                        /** FIXME: more than 6 coupled channels not supported */
721
                        if (chgroup->num_channels > 6) {
722
                            av_log_ask_for_sample(s->avctx,
723
                                   "coupled channels > 6\n");
724
                        } else {
725
                            memcpy(chgroup->decorrelation_matrix,
726
                              default_decorrelation[chgroup->num_channels],
727
                              chgroup->num_channels * chgroup->num_channels *
728
                              sizeof(*chgroup->decorrelation_matrix));
729
                        }
730
                    }
731
                }
732
            }
733

  
734
            /** decode transform on / off */
735
            if (chgroup->transform) {
736
                if (!get_bits1(&s->gb)) {
737
                    int i;
738
                    /** transform can be enabled for individual bands */
739
                    for (i = 0; i < s->num_bands; i++) {
740
                        chgroup->transform_band[i] = get_bits1(&s->gb);
741
                    }
742
                } else {
743
                    memset(chgroup->transform_band, 1, s->num_bands);
744
                }
745
            }
746
            remaining_channels -= chgroup->num_channels;
747
        }
748
    }
749
    return 0;
750
}
751

  
752
/**
156 753
 *@brief Extract the coefficients from the bitstream.
157 754
 *@param s codec context
158 755
 *@param c current channel number
159 756
 *@return 0 on success, < 0 in case of bitstream errors
160 757
 */
161
static int decode_coeffs(WMA3DecodeContext *s, int c)
758
static int decode_coeffs(WMAProDecodeCtx *s, int c)
162 759
{
163 760
    int vlctable;
164 761
    VLC* vlc;
165
    WMA3ChannelCtx* ci = &s->channel[c];
762
    WMAProChannelCtx* ci = &s->channel[c];
166 763
    int rl_mode = 0;
167 764
    int cur_coeff = 0;
168 765
    int num_zeros = 0;
......
220 817
                ci->coeffs[cur_coeff] = (vals[i]^sign) - sign;
221 818
                num_zeros = 0;
222 819
            } else {
820
                ci->coeffs[cur_coeff] = 0;
223 821
                /** switch to run level mode when subframe_len / 128 zeros
224 822
                   were found in a row */
225 823
                rl_mode |= (++num_zeros > s->subframe_len>>8);
......
230 828

  
231 829
    /** decode run level coded coefficients */
232 830
    if (rl_mode) {
831
        memset(&ci->coeffs[cur_coeff], 0,
832
               sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
233 833
        if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
234 834
                                    level, run, 1, ci->coeffs,
235 835
                                    cur_coeff, s->subframe_len,
......
241 841
}
242 842

  
243 843
/**
844
 *@brief Extract scale factors from the bitstream.
845
 *@param s codec context
846
 *@return 0 on success, < 0 in case of bitstream errors
847
 */
848
static int decode_scale_factors(WMAProDecodeCtx* s)
849
{
850
    int i;
851

  
852
    /** should never consume more than 5344 bits
853
     *  MAX_CHANNELS * (1 +  MAX_BANDS * 23)
854
     */
855

  
856
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
857
        int c = s->channel_indexes_for_cur_subframe[i];
858
        int* sf;
859
        int* sf_end = s->channel[c].scale_factors + s->num_bands;
860

  
861
        /** resample scale factors for the new block size
862
         *  as the scale factors might need to be resampled several times
863
         *  before some  new values are transmitted, a backup of the last
864
         *  transmitted scale factors is kept in saved_scale_factors
865
         */
866
        if (s->channel[c].reuse_sf) {
867
            const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
868
            int b;
869
            for (b = 0; b < s->num_bands; b++)
870
                s->channel[c].scale_factors[b] =
871
                                   s->channel[c].saved_scale_factors[*sf_offsets++];
872
        }
873

  
874
        if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
875

  
876
            if (!s->channel[c].reuse_sf) {
877
                int val;
878
                /** decode DPCM coded scale factors */
879
                s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
880
                val = 45 / s->channel[c].scale_factor_step;
881
                for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
882
                    val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
883
                    *sf = val;
884
                }
885
            } else {
886
                int i;
887
                /** run level decode differences to the resampled factors */
888
                for (i = 0; i < s->num_bands; i++) {
889
                    int idx;
890
                    int skip;
891
                    int val;
892
                    int sign;
893

  
894
                    idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
895

  
896
                    if ( !idx ) {
897
                        uint32_t code = get_bits(&s->gb, 14);
898
                        val  =  code >> 6;
899
                        sign = (code & 1) - 1;
900
                        skip = (code & 0x3f) >> 1;
901
                    } else if (idx == 1) {
902
                        break;
903
                    } else {
904
                        skip = scale_rl_run[idx];
905
                        val  = scale_rl_level[idx];
906
                        sign = get_bits1(&s->gb)-1;
907
                    }
908

  
909
                    i += skip;
910
                    if (i >= s->num_bands) {
911
                        av_log(s->avctx,AV_LOG_ERROR,
912
                               "invalid scale factor coding\n");
913
                        return AVERROR_INVALIDDATA;
914
                    }
915
                    s->channel[c].scale_factors[i] += (val ^ sign) - sign;
916
                }
917
            }
918

  
919
            /** save transmitted scale factors so that they can be reused for
920
                the next subframe */
921
            memcpy(s->channel[c].saved_scale_factors,
922
                   s->channel[c].scale_factors, s->num_bands *
923
                   sizeof(*s->channel[c].saved_scale_factors));
924
            s->channel[c].table_idx = s->table_idx;
925
            s->channel[c].reuse_sf  = 1;
926
        }
927

  
928
        /** calculate new scale factor maximum */
929
        s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
930
        for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
931
            s->channel[c].max_scale_factor =
932
                FFMAX(s->channel[c].max_scale_factor, *sf);
933
        }
934

  
935
    }
936
    return 0;
937
}
938

  
939
/**
244 940
 *@brief Reconstruct the individual channel data.
245 941
 *@param s codec context
246 942
 */
247
static void inverse_channel_transform(WMA3DecodeContext *s)
943
static void inverse_channel_transform(WMAProDecodeCtx *s)
248 944
{
249 945
    int i;
250 946

  
......
292 988
    }
293 989
}
294 990

  
991
/**
992
 *@brief Apply sine window and reconstruct the output buffer.
993
 *@param s codec context
994
 */
995
static void wmapro_window(WMAProDecodeCtx *s)
996
{
997
    int i;
998
    for (i = 0; i< s->channels_for_cur_subframe; i++) {
999
        int c = s->channel_indexes_for_cur_subframe[i];
1000
        float* window;
1001
        int winlen = s->channel[c].prev_block_len;
1002
        float* start = s->channel[c].coeffs - (winlen >> 1);
1003

  
1004
        if (s->subframe_len < winlen) {
1005
            start += (winlen - s->subframe_len)>>1;
1006
            winlen = s->subframe_len;
1007
        }
1008

  
1009
        window = s->windows[av_log2(winlen)-BLOCK_MIN_BITS];
1010

  
1011
        winlen >>= 1;
1012

  
1013
        s->dsp.vector_fmul_window(start, start, start + winlen,
1014
                                  window, 0, winlen);
1015

  
1016
        s->channel[c].prev_block_len = s->subframe_len;
1017
    }
1018
}
1019

  
1020
/**
1021
 *@brief Decode a single subframe (block).
1022
 *@param s codec context
1023
 *@return 0 on success, < 0 when decoding failed
1024
 */
1025
static int decode_subframe(WMAProDecodeCtx *s)
1026
{
1027
    int offset = s->samples_per_frame;
1028
    int subframe_len = s->samples_per_frame;
1029
    int i;
1030
    int total_samples   = s->samples_per_frame * s->num_channels;
1031
    int transmit_coeffs = 0;
1032
    int cur_subwoofer_cutoff;
1033

  
1034
    s->subframe_offset = get_bits_count(&s->gb);
1035

  
1036
    /** reset channel context and find the next block offset and size
1037
        == the next block of the channel with the smallest number of
1038
        decoded samples
1039
    */
1040
    for (i = 0; i < s->num_channels; i++) {
1041
        s->channel[i].grouped = 0;
1042
        if (offset > s->channel[i].decoded_samples) {
1043
            offset = s->channel[i].decoded_samples;
1044
            subframe_len =
1045
                s->channel[i].subframe_len[s->channel[i].cur_subframe];
1046
        }
1047
    }
1048

  
1049
    dprintf(s->avctx,
1050
           "processing subframe with offset %i len %i\n", offset, subframe_len);
1051

  
1052
    /** get a list of all channels that contain the estimated block */
1053
    s->channels_for_cur_subframe = 0;
1054
    for (i = 0; i < s->num_channels; i++) {
1055
        const int cur_subframe = s->channel[i].cur_subframe;
1056
        /** substract already processed samples */
1057
        total_samples -= s->channel[i].decoded_samples;
1058

  
1059
        /** and count if there are multiple subframes that match our profile */
1060
        if (offset == s->channel[i].decoded_samples &&
1061
           subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1062
            total_samples -= s->channel[i].subframe_len[cur_subframe];
1063
            s->channel[i].decoded_samples +=
1064
                s->channel[i].subframe_len[cur_subframe];
1065
            s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1066
            ++s->channels_for_cur_subframe;
1067
        }
1068
    }
1069

  
1070
    /** check if the frame will be complete after processing the
1071
        estimated block */
1072
    if (!total_samples)
1073
        s->parsed_all_subframes = 1;
1074

  
1075

  
1076
    dprintf(s->avctx, "subframe is part of %i channels\n",
1077
           s->channels_for_cur_subframe);
1078

  
1079
    /** calculate number of scale factor bands and their offsets */
1080
    s->table_idx         = av_log2(s->samples_per_frame/subframe_len);
1081
    s->num_bands         = s->num_sfb[s->table_idx];
1082
    s->cur_sfb_offsets   = s->sfb_offsets[s->table_idx];
1083
    cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1084

  
1085
    /** configure the decoder for the current subframe */
1086
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1087
        int c = s->channel_indexes_for_cur_subframe[i];
1088

  
1089
        s->channel[c].coeffs = &s->channel[c].out[(s->samples_per_frame>>1)
1090
                                                  + offset];
1091
    }
1092

  
1093
    s->subframe_len = subframe_len;
1094
    s->esc_len = av_log2(s->subframe_len - 1) + 1;
1095

  
1096
    /** skip extended header if any */
1097
    if (get_bits1(&s->gb)) {
1098
        int num_fill_bits;
1099
        if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1100
            int len = get_bits(&s->gb, 4);
1101
            num_fill_bits = get_bits(&s->gb, len) + 1;
1102
        }
1103

  
1104
        if (num_fill_bits >= 0) {
1105
            if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1106
                av_log(s->avctx,AV_LOG_ERROR,"invalid number of fill bits\n");
1107
                return AVERROR_INVALIDDATA;
1108
            }
1109

  
1110
            skip_bits_long(&s->gb, num_fill_bits);
1111
        }
1112
    }
1113

  
1114
    /** no idea for what the following bit is used */
1115
    if (get_bits1(&s->gb)) {
1116
        av_log_ask_for_sample(s->avctx, "reserved bit set\n");
1117
        return AVERROR_INVALIDDATA;
1118
    }
1119

  
1120

  
1121
    if (decode_channel_transform(s) < 0)
1122
        return AVERROR_INVALIDDATA;
1123

  
1124

  
1125
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1126
        int c = s->channel_indexes_for_cur_subframe[i];
1127
        if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1128
            transmit_coeffs = 1;
1129
    }
1130

  
1131
    if (transmit_coeffs) {
1132
        int step;
1133
        int quant_step = 90 * s->bits_per_sample >> 4;
1134
        if ((get_bits1(&s->gb))) {
1135
            /** FIXME: might change run level mode decision */
1136
            av_log_ask_for_sample(s->avctx, "unsupported quant step coding\n");
1137
            return AVERROR_INVALIDDATA;
1138
        }
1139
        /** decode quantization step */
1140
        step = get_sbits(&s->gb, 6);
1141
        quant_step += step;
1142
        if (step == -32 || step == 31) {
1143
            const int sign = (step == 31) - 1;
1144
            int quant = 0;
1145
            while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1146
                   (step = get_bits(&s->gb, 5)) == 31 ) {
1147
                     quant += 31;
1148
            }
1149
            quant_step += ((quant + step) ^ sign) - sign;
1150
        }
1151
        if (quant_step < 0) {
1152
            av_log(s->avctx,AV_LOG_DEBUG,"negative quant step\n");
1153
        }
1154

  
1155
        /** decode quantization step modifiers for every channel */
1156

  
1157
        if (s->channels_for_cur_subframe == 1) {
1158
            s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1159
        } else {
1160
            int modifier_len = get_bits(&s->gb, 3);
1161
            for (i = 0; i < s->channels_for_cur_subframe; i++) {
1162
                int c = s->channel_indexes_for_cur_subframe[i];
1163
                s->channel[c].quant_step = quant_step;
1164
                if (get_bits1(&s->gb)) {
1165
                    if (modifier_len) {
1166
                        s->channel[c].quant_step +=
1167
                                get_bits(&s->gb, modifier_len) + 1;
1168
                    } else
1169
                        ++s->channel[c].quant_step;
1170
                }
1171
            }
1172
        }
1173

  
1174
        /** decode scale factors */
1175
        if (decode_scale_factors(s) < 0)
1176
            return AVERROR_INVALIDDATA;
1177
    }
1178

  
1179
    dprintf(s->avctx, "BITSTREAM: subframe header length was %i\n",
1180
           get_bits_count(&s->gb) - s->subframe_offset);
1181

  
1182
    /** parse coefficients */
1183
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1184
        int c = s->channel_indexes_for_cur_subframe[i];
1185
        if (s->channel[c].transmit_coefs &&
1186
           get_bits_count(&s->gb) < s->num_saved_bits) {
1187
                decode_coeffs(s, c);
1188
        } else
1189
            memset(s->channel[c].coeffs, 0,
1190
                   sizeof(*s->channel[c].coeffs) * subframe_len);
1191
    }
1192

  
1193
    dprintf(s->avctx, "BITSTREAM: subframe length was %i\n",
1194
           get_bits_count(&s->gb) - s->subframe_offset);
1195

  
1196
    if (transmit_coeffs) {
1197
        /** reconstruct the per channel data */
1198
        inverse_channel_transform(s);
1199
        for (i = 0; i < s->channels_for_cur_subframe; i++) {
1200
            int c = s->channel_indexes_for_cur_subframe[i];
1201
            const int* sf = s->channel[c].scale_factors;
1202
            int b;
1203

  
1204
            if (c == s->lfe_channel)
1205
                memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1206
                       (subframe_len - cur_subwoofer_cutoff));
1207

  
1208
            /** inverse quantization and rescaling */
1209
            for (b = 0; b < s->num_bands; b++) {
1210
                const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1211
                const int exp = s->channel[c].quant_step -
1212
                            (s->channel[c].max_scale_factor - *sf++) *
1213
                            s->channel[c].scale_factor_step;
1214
                const float quant = pow(10.0, exp / 20.0);
1215
                int start;
1216

  
1217
                for (start = s->cur_sfb_offsets[b]; start < end; start++)
1218
                    s->tmp[start] = s->channel[c].coeffs[start] * quant;
1219
            }
1220

  
1221
            /** apply imdct (ff_imdct_half == DCTIV with reverse) */
1222
            ff_imdct_half(&s->mdct_ctx[av_log2(subframe_len)-BLOCK_MIN_BITS],
1223
                          s->channel[c].coeffs, s->tmp);
1224
        }
1225
    }
1226

  
1227
    /** window and overlapp-add */
1228
    wmapro_window(s);
1229

  
1230
    /** handled one subframe */
1231
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1232
        int c = s->channel_indexes_for_cur_subframe[i];
1233
        if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1234
            av_log(s->avctx,AV_LOG_ERROR,"broken subframe\n");
1235
            return AVERROR_INVALIDDATA;
1236
        }
1237
        ++s->channel[c].cur_subframe;
1238
    }
1239

  
1240
    return 0;
1241
}
1242

  
1243
/**
1244
 *@brief Decode one WMA frame.
1245
 *@param s codec context
1246
 *@return 0 if the trailer bit indicates that this is the last frame,
1247
 *        1 if there are additional frames
1248
 */
1249
static int decode_frame(WMAProDecodeCtx *s)
1250
{
1251
    GetBitContext* gb = &s->gb;
1252
    int more_frames = 0;
1253
    int len = 0;
1254
    int i;
1255

  
1256
    /** check for potential output buffer overflow */
1257
    if (s->num_channels * s->samples_per_frame > s->samples_end - s->samples) {
1258
        av_log(s->avctx,AV_LOG_ERROR,
1259
               "not enough space for the output samples\n");
1260
        s->packet_loss = 1;
1261
        return 0;
1262
    }
1263

  
1264
    /** get frame length */
1265
    if (s->len_prefix)
1266
        len = get_bits(gb, s->log2_frame_size);
1267

  
1268
    dprintf(s->avctx, "decoding frame with length %x\n", len);
1269

  
1270
    /** decode tile information */
1271
    if (decode_tilehdr(s)) {
1272
        s->packet_loss = 1;
1273
        return 0;
1274
    }
1275

  
1276
    /** read postproc transform */
1277
    if (s->num_channels > 1 && get_bits1(gb)) {
1278
        av_log_ask_for_sample(s->avctx, "Unsupported postproc transform found\n");
1279
        s->packet_loss = 1;
1280
        return 0;
1281
    }
1282

  
1283
    /** read drc info */
1284
    if (s->dynamic_range_compression) {
1285
        s->drc_gain = get_bits(gb, 8);
1286
        dprintf(s->avctx, "drc_gain %i\n", s->drc_gain);
1287
    }
1288

  
1289
    /** no idea what these are for, might be the number of samples
1290
        that need to be skipped at the beginning or end of a stream */
1291
    if (get_bits1(gb)) {
1292
        int skip;
1293

  
1294
        /** usually true for the first frame */
1295
        if (get_bits1(gb)) {
1296
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1297
            dprintf(s->avctx, "start skip: %i\n", skip);
1298
        }
1299

  
1300
        /** sometimes true for the last frame */
1301
        if (get_bits1(gb)) {
1302
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1303
            dprintf(s->avctx, "end skip: %i\n", skip);
1304
        }
1305

  
1306
    }
1307

  
1308
    dprintf(s->avctx, "BITSTREAM: frame header length was %i\n",
1309
           get_bits_count(gb) - s->frame_offset);
1310

  
1311
    /** reset subframe states */
1312
    s->parsed_all_subframes = 0;
1313
    for (i = 0; i < s->num_channels; i++) {
1314
        s->channel[i].decoded_samples = 0;
1315
        s->channel[i].cur_subframe    = 0;
1316
        s->channel[i].reuse_sf        = 0;
1317
    }
1318

  
1319
    /** decode all subframes */
1320
    while (!s->parsed_all_subframes) {
1321
        if (decode_subframe(s) < 0) {
1322
            s->packet_loss = 1;
1323
            return 0;
1324
        }
1325
    }
1326

  
1327
    /** interleave samples and write them to the output buffer */
1328
    for (i = 0; i < s->num_channels; i++) {
1329
        float* ptr;
1330
        int incr = s->num_channels;
1331
        float* iptr = s->channel[i].out;
1332
        int x;
1333

  
1334
        ptr = s->samples + i;
1335

  
1336
        for (x = 0; x < s->samples_per_frame; x++) {
1337
            *ptr = av_clipf(*iptr++, -1.0, 32767.0 / 32768.0);
1338
            ptr += incr;
1339
        }
1340

  
1341
        /** reuse second half of the IMDCT output for the next frame */
1342
        memcpy(&s->channel[i].out[0],
1343
               &s->channel[i].out[s->samples_per_frame],
1344
               s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1345
    }
1346

  
1347
    if (s->skip_frame) {
1348
        s->skip_frame = 0;
1349
    } else
1350
        s->samples += s->num_channels * s->samples_per_frame;
1351

  
1352
    if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1353
        /** FIXME: not sure if this is always an error */
1354
        av_log(s->avctx,AV_LOG_ERROR,"frame[%i] would have to skip %i bits\n",
1355
               s->frame_num, len - (get_bits_count(gb) - s->frame_offset) - 1);
1356
        s->packet_loss = 1;
1357
        return 0;
1358
    }
1359

  
1360
    /** skip the rest of the frame data */
1361
    skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1362

  
1363
    /** decode trailer bit */
1364
    more_frames = get_bits1(gb);
1365

  
1366
    ++s->frame_num;
1367
    return more_frames;
1368
}
1369

  
1370
/**
1371
 *@brief Calculate remaining input buffer length.
1372
 *@param s codec context
1373
 *@param gb bitstream reader context
1374
 *@return remaining size in bits
1375
 */
1376
static int remaining_bits(WMAProDecodeCtx *s, GetBitContext* gb)
1377
{
1378
    return s->buf_bit_size - get_bits_count(gb);
1379
}
1380

  
1381
/**
1382
 *@brief Fill the bit reservoir with a (partial) frame.
1383
 *@param s codec context
1384
 *@param gb bitstream reader context
1385
 *@param len length of the partial frame
1386
 *@param append decides wether to reset the buffer or not
1387
 */
1388
static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1389
                          int append)
1390
{
1391
    int buflen;
1392

  
1393
    /** when the frame data does not need to be concatenated, the input buffer
1394
        is resetted and additional bits from the previous frame are copyed
1395
        and skipped later so that a fast byte copy is possible */
1396

  
1397
    if (!append) {
1398
        s->frame_offset = get_bits_count(gb) & 7;
1399
        s->num_saved_bits = s->frame_offset;
1400
        init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1401
    }
1402

  
1403
    buflen = (s->num_saved_bits + len + 8) >> 3;
1404

  
1405
    if (len <= 0 || buflen > MAX_FRAMESIZE) {
1406
         av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1407
         s->packet_loss = 1;
1408
         return;
1409
    }
1410

  
1411
    s->num_saved_bits += len;
1412
    if (!append) {
1413
        ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), s->num_saved_bits);
1414
    } else {
1415
        int align = 8 - (get_bits_count(gb) & 7);
1416
        align = FFMIN(align, len);
1417
        put_bits(&s->pb, align, get_bits(gb, align));
1418
        len -= align;
1419
        ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1420
    }
1421
    skip_bits_long(gb, len);
1422

  
1423
    {
1424
    PutBitContext tmp = s->pb;
1425
    flush_put_bits(&tmp);
1426
    }
1427

  
1428
    init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1429
    skip_bits(&s->gb, s->frame_offset);
1430
}
1431

  
1432
/**
1433
 *@brief Decode a single WMA packet.
1434
 *@param avctx codec context
1435
 *@param data the output buffer
1436
 *@param data_size number of bytes that were written to the output buffer
1437
 *@param avpkt input packet
1438
 *@return number of bytes that were read from the input buffer
1439
 */
1440
static int decode_packet(AVCodecContext *avctx,
1441
                             void *data, int *data_size, AVPacket* avpkt)
1442
{
1443
    GetBitContext gb;
1444
    WMAProDecodeCtx *s = avctx->priv_data;
1445
    const uint8_t* buf   = avpkt->data;
1446
    int buf_size         = avpkt->size;
1447
    int more_frames      = 1;
1448
    int num_bits_prev_frame;
1449
    int packet_sequence_number;
1450

  
1451
    s->samples      = data;
1452
    s->samples_end  = (float*)((int8_t*)data + *data_size);
1453
    s->buf_bit_size = buf_size << 3;
1454

  
1455

  
1456
    *data_size = 0;
1457

  
1458
    /** sanity check for the buffer length */
1459
    if (buf_size < avctx->block_align)
1460
        return 0;
1461

  
1462
    buf_size = avctx->block_align;
1463

  
1464
    /** parse packet header */
1465
    init_get_bits(&gb, buf, s->buf_bit_size);
1466
    packet_sequence_number = get_bits(&gb, 4);
1467
    skip_bits(&gb, 2);
1468

  
1469
    /** get number of bits that need to be added to the previous frame */
1470
    num_bits_prev_frame = get_bits(&gb, s->log2_frame_size);
1471
    dprintf(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1472
                  num_bits_prev_frame);
1473

  
1474
    /** check for packet loss */
1475
    if (!s->packet_loss &&
1476
        ((s->packet_sequence_number + 1)&0xF) != packet_sequence_number) {
1477
        s->packet_loss = 1;
1478
        av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1479
                      s->packet_sequence_number, packet_sequence_number);
1480
    }
1481
    s->packet_sequence_number = packet_sequence_number;
1482

  
1483
    if (num_bits_prev_frame > 0) {
1484
        /** append the previous frame data to the remaining data from the
1485
            previous packet to create a full frame */
1486
        save_bits(s, &gb, num_bits_prev_frame, 1);
1487
        dprintf(avctx, "accumulated %x bits of frame data\n",
1488
                      s->num_saved_bits - s->frame_offset);
1489

  
1490
        /** decode the cross packet frame if it is valid */
1491
        if (!s->packet_loss)
1492
            decode_frame(s);
1493
    } else if (s->num_saved_bits - s->frame_offset) {
1494
        dprintf(avctx, "ignoring %x previously saved bits\n",
1495
                      s->num_saved_bits - s->frame_offset);
1496
    }
1497

  
1498
    s->packet_loss = 0;
1499
    /** decode the rest of the packet */
1500
    while (!s->packet_loss && more_frames &&
1501
          remaining_bits(s, &gb) > s->log2_frame_size) {
1502
        int frame_size = show_bits(&gb, s->log2_frame_size);
1503

  
1504
        /** there is enough data for a full frame */
1505
        if (remaining_bits(s,&gb) >= frame_size && frame_size > 0) {
1506
            save_bits(s, &gb, frame_size, 0);
1507

  
1508
            /** decode the frame */
1509
            more_frames = decode_frame(s);
1510

  
1511
            if (!more_frames) {
1512
                dprintf(avctx, "no more frames\n");
1513
            }
1514
        } else
1515
            more_frames = 0;
1516
    }
1517

  
1518
    if (!s->packet_loss && remaining_bits(s,&gb) > 0) {
1519
        /** save the rest of the data so that it can be decoded
1520
            with the next packet */
1521
        save_bits(s, &gb, remaining_bits(s,&gb), 0);
1522
    }
1523

  
1524
    *data_size = (int8_t *)s->samples - (int8_t *)data;
1525

  
1526
    return avctx->block_align;
1527
}
1528

  
1529
/**
1530
 *@brief Clear decoder buffers (for seeking).
1531
 *@param avctx codec context
1532
 */
1533
static void flush(AVCodecContext *avctx)
1534
{
1535
    WMAProDecodeCtx *s = avctx->priv_data;
1536
    int i;
1537
    /** reset output buffer as a part of it is used during the windowing of a
1538
        new frame */
1539
    for (i = 0; i < s->num_channels; i++)
1540
        memset(s->channel[i].out, 0, s->samples_per_frame *
1541
               sizeof(*s->channel[i].out));
1542
    s->packet_loss = 1;
1543
}
1544

  
1545

  
1546
/**
1547
 *@brief wmapro decoder
1548
 */
1549
AVCodec wmapro_decoder = {
1550
    "wmapro",
1551
    CODEC_TYPE_AUDIO,
1552
    CODEC_ID_WMAPRO,
1553
    sizeof(WMAProDecodeCtx),
1554
    decode_init,
1555
    NULL,
1556
    decode_end,
1557
    decode_packet,
1558
    .flush= flush,
1559
    .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1560
};

Also available in: Unified diff