wmaprodec.c 64.3 KB
Newer Older
1 2 3
/*
 * Wmapro compatible decoder
 * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
4
 * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
24
 * @file
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
 * @brief wmapro decoder implementation
 * Wmapro is an MDCT based codec comparable to wma standard or AAC.
 * The decoding therefore consists of the following steps:
 * - bitstream decoding
 * - reconstruction of per-channel data
 * - rescaling and inverse quantization
 * - IMDCT
 * - windowing and overlapp-add
 *
 * The compressed wmapro bitstream is split into individual packets.
 * Every such packet contains one or more wma frames.
 * The compressed frames may have a variable length and frames may
 * cross packet boundaries.
 * Common to all wmapro frames is the number of samples that are stored in
 * a frame.
 * The number of samples and a few other decode flags are stored
 * as extradata that has to be passed to the decoder.
 *
 * The wmapro frames themselves are again split into a variable number of
 * subframes. Every subframe contains the data for 2^N time domain samples
 * where N varies between 7 and 12.
 *
 * Example wmapro bitstream (in samples):
 *
 * ||   packet 0           || packet 1 || packet 2      packets
 * ---------------------------------------------------
 * || frame 0      || frame 1       || frame 2    ||    frames
 * ---------------------------------------------------
 * ||   |      |   ||   |   |   |   ||            ||    subframes of channel 0
 * ---------------------------------------------------
 * ||      |   |   ||   |   |   |   ||            ||    subframes of channel 1
 * ---------------------------------------------------
 *
 * The frame layouts for the individual channels of a wma frame does not need
 * to be the same.
 *
 * However, if the offsets and lengths of several subframes of a frame are the
 * same, the subframes of the channels can be grouped.
 * Every group may then use special coding techniques like M/S stereo coding
 * to improve the compression ratio. These channel transformations do not
 * need to be applied to a whole subframe. Instead, they can also work on
 * individual scale factor bands (see below).
 * The coefficients that carry the audio signal in the frequency domain
 * are transmitted as huffman-coded vectors with 4, 2 and 1 elements.
 * In addition to that, the encoder can switch to a runlevel coding scheme
 * by transmitting subframe_length / 128 zero coefficients.
 *
 * Before the audio signal can be converted to the time domain, the
 * coefficients have to be rescaled and inverse quantized.
 * A subframe is therefore split into several scale factor bands that get
 * scaled individually.
 * Scale factors are submitted for every frame but they might be shared
 * between the subframes of a channel. Scale factors are initially DPCM-coded.
 * Once scale factors are shared, the differences are transmitted as runlevel
 * codes.
 * Every subframe length and offset combination in the frame layout shares a
 * common quantization factor that can be adjusted for every channel by a
 * modifier.
 * After the inverse quantization, the coefficients get processed by an IMDCT.
 * The resulting values are then windowed with a sine window and the first half
 * of the values are added to the second half of the output from the previous
 * subframe in order to reconstruct the output samples.
 */

89
#include "libavutil/float_dsp.h"
90
#include "libavutil/intfloat.h"
91
#include "libavutil/intreadwrite.h"
92 93 94 95 96
#include "avcodec.h"
#include "internal.h"
#include "get_bits.h"
#include "put_bits.h"
#include "wmaprodata.h"
97
#include "sinewin.h"
98
#include "wma.h"
99
#include "wma_common.h"
100 101 102 103 104

/** current decoder limitations */
#define WMAPRO_MAX_CHANNELS    8                             ///< max number of handled channels
#define MAX_SUBFRAMES  32                                    ///< max number of subframes per channel
#define MAX_BANDS      29                                    ///< max number of scale factor bands
105
#define MAX_FRAMESIZE  32768                                 ///< maximum compressed frame size
106

107
#define WMAPRO_BLOCK_MIN_BITS  6                                           ///< log2 of min block size
108
#define WMAPRO_BLOCK_MAX_BITS 13                                           ///< log2 of max block size
109
#define WMAPRO_BLOCK_MIN_SIZE (1 << WMAPRO_BLOCK_MIN_BITS)                 ///< minimum block size
110
#define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS)                 ///< maximum block size
111
#define WMAPRO_BLOCK_SIZES    (WMAPRO_BLOCK_MAX_BITS - WMAPRO_BLOCK_MIN_BITS + 1) ///< possible block sizes
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127


#define VLCBITS            9
#define SCALEVLCBITS       8
#define VEC4MAXDEPTH    ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
#define VEC2MAXDEPTH    ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
#define VEC1MAXDEPTH    ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
#define SCALEMAXDEPTH   ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
#define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)

static VLC              sf_vlc;           ///< scale factor DPCM vlc
static VLC              sf_rl_vlc;        ///< scale factor run length vlc
static VLC              vec4_vlc;         ///< 4 coefficients per symbol
static VLC              vec2_vlc;         ///< 2 coefficients per symbol
static VLC              vec1_vlc;         ///< 1 coefficient per symbol
static VLC              coef_vlc[2];      ///< coefficient run length vlc codes
Diego Biurrun's avatar
Diego Biurrun committed
128
static float            sin64[33];        ///< sine table for decorrelation
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145

/**
 * @brief frame specific decoder context for a single channel
 */
typedef struct {
    int16_t  prev_block_len;                          ///< length of the previous block
    uint8_t  transmit_coefs;
    uint8_t  num_subframes;
    uint16_t subframe_len[MAX_SUBFRAMES];             ///< subframe length in samples
    uint16_t subframe_offset[MAX_SUBFRAMES];          ///< subframe positions in the current frame
    uint8_t  cur_subframe;                            ///< current subframe number
    uint16_t decoded_samples;                         ///< number of already processed samples
    uint8_t  grouped;                                 ///< channel is part of a group
    int      quant_step;                              ///< quantization step for the current subframe
    int8_t   reuse_sf;                                ///< share scale factors between subframes
    int8_t   scale_factor_step;                       ///< scaling step for the current subframe
    int      max_scale_factor;                        ///< maximum scale factor for the current subframe
146 147 148
    int      saved_scale_factors[2][MAX_BANDS];       ///< resampled and (previously) transmitted scale factor values
    int8_t   scale_factor_idx;                        ///< index for the transmitted scale factor values (used for resampling)
    int*     scale_factors;                           ///< pointer to the scale factor values used for decoding
149 150
    uint8_t  table_idx;                               ///< index in sf_offsets for the scale factor reference block
    float*   coeffs;                                  ///< pointer to the subframe decode buffer
151
    uint16_t num_vec_coeffs;                          ///< number of vector coded coefficients
152
    DECLARE_ALIGNED(32, float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; ///< output buffer
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
} WMAProChannelCtx;

/**
 * @brief channel group for channel transformations
 */
typedef struct {
    uint8_t num_channels;                                     ///< number of channels in the group
    int8_t  transform;                                        ///< transform on / off
    int8_t  transform_band[MAX_BANDS];                        ///< controls if the transform is enabled for a certain band
    float   decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];
    float*  channel_data[WMAPRO_MAX_CHANNELS];                ///< transformation coefficients
} WMAProChannelGrp;

/**
 * @brief main decoder context
 */
typedef struct WMAProDecodeCtx {
    /* generic decoder variables */
    AVCodecContext*  avctx;                         ///< codec context for av_log
172
    AVFloatDSPContext fdsp;
173 174 175
    uint8_t          frame_data[MAX_FRAMESIZE +
                      FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
    PutBitContext    pb;                            ///< context for filling the frame_data buffer
176
    FFTContext       mdct_ctx[WMAPRO_BLOCK_SIZES];  ///< MDCT context per block size
177
    DECLARE_ALIGNED(32, float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; ///< IMDCT output buffer
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
    float*           windows[WMAPRO_BLOCK_SIZES];   ///< windows for the different block sizes

    /* frame size dependent frame information (set during initialization) */
    uint32_t         decode_flags;                  ///< used compression features
    uint8_t          len_prefix;                    ///< frame is prefixed with its length
    uint8_t          dynamic_range_compression;     ///< frame contains DRC data
    uint8_t          bits_per_sample;               ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
    uint16_t         samples_per_frame;             ///< number of samples to output
    uint16_t         log2_frame_size;
    int8_t           lfe_channel;                   ///< lfe channel index
    uint8_t          max_num_subframes;
    uint8_t          subframe_len_bits;             ///< number of bits used for the subframe length
    uint8_t          max_subframe_len_bit;          ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
    uint16_t         min_samples_per_subframe;
    int8_t           num_sfb[WMAPRO_BLOCK_SIZES];   ///< scale factor bands per block size
    int16_t          sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS];                    ///< scale factor band offsets (multiples of 4)
    int8_t           sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
    int16_t          subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values

    /* packet decode state */
198
    GetBitContext    pgb;                           ///< bitstream reader context for the packet
199
    int              next_packet_start;             ///< start offset of the next wma packet in the demuxer packet
200
    uint8_t          packet_offset;                 ///< frame offset in the packet
201 202 203 204 205
    uint8_t          packet_sequence_number;        ///< current packet number
    int              num_saved_bits;                ///< saved number of bits
    int              frame_offset;                  ///< frame offset in the bit reservoir
    int              subframe_offset;               ///< subframe offset in the bit reservoir
    uint8_t          packet_loss;                   ///< set in case of bitstream error
206
    uint8_t          packet_done;                   ///< set when a packet is fully decoded
207 208 209 210 211 212 213 214 215 216 217 218 219 220

    /* frame decode state */
    uint32_t         frame_num;                     ///< current frame number (not used for decoding)
    GetBitContext    gb;                            ///< bitstream reader context
    int              buf_bit_size;                  ///< buffer size in bits
    uint8_t          drc_gain;                      ///< gain for the DRC tool
    int8_t           skip_frame;                    ///< skip output step
    int8_t           parsed_all_subframes;          ///< all subframes decoded?

    /* subframe/block decode state */
    int16_t          subframe_len;                  ///< current subframe length
    int8_t           channels_for_cur_subframe;     ///< number of channels that contain the subframe
    int8_t           channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS];
    int8_t           num_bands;                     ///< number of scale factor bands
221
    int8_t           transmit_num_vec_coeffs;       ///< number of vector coded coefficients is part of the bitstream
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
    int16_t*         cur_sfb_offsets;               ///< sfb offsets for the current block
    uint8_t          table_idx;                     ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
    int8_t           esc_len;                       ///< length of escaped coefficients

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

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


/**
 *@brief helper function to print the most important members of the context
 *@param s context
 */
237
static av_cold void dump_context(WMAProDecodeCtx *s)
238 239 240 241 242 243 244 245 246 247
{
#define PRINT(a, b)     av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
#define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b);

    PRINT("ed sample bit depth", s->bits_per_sample);
    PRINT_HEX("ed decode flags", s->decode_flags);
    PRINT("samples per frame",   s->samples_per_frame);
    PRINT("log2 frame size",     s->log2_frame_size);
    PRINT("max num subframes",   s->max_num_subframes);
    PRINT("len prefix",          s->len_prefix);
248
    PRINT("num channels",        s->avctx->channels);
249 250
}

251 252 253 254 255 256 257
/**
 *@brief Uninitialize the decoder and free all resources.
 *@param avctx codec context
 *@return 0 on success, < 0 otherwise
 */
static av_cold int decode_end(AVCodecContext *avctx)
{
258
    WMAProDecodeCtx *s = avctx->priv_data;
259 260
    int i;

Diego Biurrun's avatar
Diego Biurrun committed
261
    for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
262 263 264 265 266
        ff_mdct_end(&s->mdct_ctx[i]);

    return 0;
}

267 268 269 270 271 272 273 274
/**
 *@brief Initialize the decoder.
 *@param avctx codec context
 *@return 0 on success, -1 otherwise
 */
static av_cold int decode_init(AVCodecContext *avctx)
{
    WMAProDecodeCtx *s = avctx->priv_data;
275
    uint8_t *edata_ptr = avctx->extradata;
276
    unsigned int channel_mask;
277
    int i, bits;
278 279 280
    int log2_max_num_subframes;
    int num_possible_block_sizes;

281 282 283 284 285
    if (!avctx->block_align) {
        av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
        return AVERROR(EINVAL);
    }

286
    s->avctx = avctx;
287 288
    avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);

289 290
    init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);

291
    avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
292 293 294 295 296 297 298

    if (avctx->extradata_size >= 18) {
        s->decode_flags    = AV_RL16(edata_ptr+14);
        channel_mask       = AV_RL32(edata_ptr+2);
        s->bits_per_sample = AV_RL16(edata_ptr);
        /** dump the extradata */
        for (i = 0; i < avctx->extradata_size; i++)
299 300
            av_dlog(avctx, "[%x] ", avctx->extradata[i]);
        av_dlog(avctx, "\n");
301 302

    } else {
303
        avpriv_request_sample(avctx, "Unknown extradata size");
304
        return AVERROR_PATCHWELCOME;
305 306 307 308
    }

    /** generic init */
    s->log2_frame_size = av_log2(avctx->block_align) + 4;
309 310 311 312
    if (s->log2_frame_size > 25) {
        avpriv_request_sample(avctx, "Large block align");
        return AVERROR_PATCHWELCOME;
    }
313 314

    /** frame info */
315
    s->skip_frame  = 1; /* skip first frame */
316 317 318 319
    s->packet_loss = 1;
    s->len_prefix  = (s->decode_flags & 0x40);

    /** get frame len */
320 321
    bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);
    if (bits > WMAPRO_BLOCK_MAX_BITS) {
322
        avpriv_request_sample(avctx, "14-bit block sizes");
323
        return AVERROR_PATCHWELCOME;
324 325
    }
    s->samples_per_frame = 1 << bits;
326 327 328 329

    /** subframe info */
    log2_max_num_subframes       = ((s->decode_flags & 0x38) >> 3);
    s->max_num_subframes         = 1 << log2_max_num_subframes;
330
    if (s->max_num_subframes == 16 || s->max_num_subframes == 4)
331 332 333 334 335 336 337 338 339 340 341 342 343
        s->max_subframe_len_bit = 1;
    s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;

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

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

344
    if (s->min_samples_per_subframe < WMAPRO_BLOCK_MIN_SIZE) {
345 346 347 348 349
        av_log(avctx, AV_LOG_ERROR, "min_samples_per_subframe of %d too small\n",
               s->min_samples_per_subframe);
        return AVERROR_INVALIDDATA;
    }

350 351 352 353 354
    if (s->avctx->sample_rate <= 0) {
        av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
        return AVERROR_INVALIDDATA;
    }

355 356 357
    if (avctx->channels < 0) {
        av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
               avctx->channels);
358
        return AVERROR_INVALIDDATA;
359
    } else if (avctx->channels > WMAPRO_MAX_CHANNELS) {
360 361
        avpriv_request_sample(avctx,
                              "More than %d channels", WMAPRO_MAX_CHANNELS);
362 363 364 365
        return AVERROR_PATCHWELCOME;
    }

    /** init previous block len */
366
    for (i = 0; i < avctx->channels; i++)
367 368
        s->channel[i].prev_block_len = s->samples_per_frame;

369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416
    /** extract lfe channel position */
    s->lfe_channel = -1;

    if (channel_mask & 8) {
        unsigned int mask;
        for (mask = 1; mask < 16; mask <<= 1) {
            if (channel_mask & mask)
                ++s->lfe_channel;
        }
    }

    INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
                    scale_huffbits, 1, 1,
                    scale_huffcodes, 2, 2, 616);

    INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
                    scale_rl_huffbits, 1, 1,
                    scale_rl_huffcodes, 4, 4, 1406);

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

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

    INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
                    vec4_huffbits, 1, 1,
                    vec4_huffcodes, 2, 2, 604);

    INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
                    vec2_huffbits, 1, 1,
                    vec2_huffcodes, 2, 2, 562);

    INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
                    vec1_huffbits, 1, 1,
                    vec1_huffcodes, 2, 2, 562);

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

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

417
        for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
418 419 420
            int offset = (subframe_len * 2 * critical_freq[x])
                          / s->avctx->sample_rate + 2;
            offset &= ~3;
421
            if (offset > s->sfb_offsets[i][band - 1])
422 423 424 425
                s->sfb_offsets[i][band++] = offset;
        }
        s->sfb_offsets[i][band - 1] = subframe_len;
        s->num_sfb[i]               = band - 1;
426 427 428 429
        if (s->num_sfb[i] <= 0) {
            av_log(avctx, AV_LOG_ERROR, "num_sfb invalid\n");
            return AVERROR_INVALIDDATA;
        }
430 431 432 433 434 435 436 437 438 439 440 441 442
    }


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

    for (i = 0; i < num_possible_block_sizes; i++) {
        int b;
        for (b = 0; b < s->num_sfb[i]; b++) {
            int x;
            int offset = ((s->sfb_offsets[i][b]
443
                           + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
444 445
            for (x = 0; x < num_possible_block_sizes; x++) {
                int v = 0;
446 447 448 449
                while (s->sfb_offsets[x][v + 1] << x < offset) {
                    v++;
                    av_assert0(v < MAX_BANDS);
                }
450 451 452 453 454 455 456
                s->sf_offsets[i][x][b] = v;
            }
        }
    }

    /** init MDCT, FIXME: only init needed sizes */
    for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
457 458
        ff_mdct_init(&s->mdct_ctx[i], WMAPRO_BLOCK_MIN_BITS+1+i, 1,
                     1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i - 1))
459 460
                     / (1 << (s->bits_per_sample - 1)));

Diego Biurrun's avatar
Diego Biurrun committed
461
    /** init MDCT windows: simple sine window */
462
    for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
463
        const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
464
        ff_init_ff_sine_windows(win_idx);
465
        s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483
    }

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

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

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

    avctx->channel_layout = channel_mask;
484

485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502
    return 0;
}

/**
 *@brief Decode the subframe length.
 *@param s context
 *@param offset sample offset in the frame
 *@return decoded subframe length on success, < 0 in case of an error
 */
static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
{
    int frame_len_shift = 0;
    int subframe_len;

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

503 504 505
    if (get_bits_left(&s->gb) < 1)
        return AVERROR_INVALIDDATA;

506 507 508 509 510 511 512 513 514 515
    /** 1 bit indicates if the subframe is of maximum length */
    if (s->max_subframe_len_bit) {
        if (get_bits1(&s->gb))
            frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
    } else
        frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);

    subframe_len = s->samples_per_frame >> frame_len_shift;

    /** sanity check the length */
516 517
    if (subframe_len < s->min_samples_per_subframe ||
        subframe_len > s->samples_per_frame) {
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
        av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
               subframe_len);
        return AVERROR_INVALIDDATA;
    }
    return subframe_len;
}

/**
 *@brief Decode how the data in the frame is split into subframes.
 *       Every WMA frame contains the encoded data for a fixed number of
 *       samples per channel. The data for every channel might be split
 *       into several subframes. This function will reconstruct the list of
 *       subframes for every channel.
 *
 *       If the subframes are not evenly split, the algorithm estimates the
 *       channels with the lowest number of total samples.
 *       Afterwards, for each of these channels a bit is read from the
 *       bitstream that indicates if the channel contains a subframe with the
 *       next subframe size that is going to be read from the bitstream or not.
 *       If a channel contains such a subframe, the subframe size gets added to
 *       the channel's subframe list.
 *       The algorithm repeats these steps until the frame is properly divided
 *       between the individual channels.
 *
 *@param s context
 *@return 0 on success, < 0 in case of an error
 */
static int decode_tilehdr(WMAProDecodeCtx *s)
{
547
    uint16_t num_samples[WMAPRO_MAX_CHANNELS] = { 0 };/**< sum of samples for all currently known subframes of a channel */
548
    uint8_t  contains_subframe[WMAPRO_MAX_CHANNELS];  /**< flag indicating if a channel contains the current subframe */
549
    int channels_for_cur_subframe = s->avctx->channels; /**< number of channels that contain the current subframe */
550 551
    int fixed_channel_layout = 0;                     /**< flag indicating that all channels use the same subframe offsets and sizes */
    int min_channel_len = 0;                          /**< smallest sum of samples (channels with this length will be processed first) */
552 553 554
    int c;

    /* Should never consume more than 3073 bits (256 iterations for the
555
     * while loop when always the minimum amount of 128 samples is subtracted
556 557 558 559 560
     * from missing samples in the 8 channel case).
     * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS  + 4)
     */

    /** reset tiling information */
561
    for (c = 0; c < s->avctx->channels; c++)
562 563 564 565 566 567 568 569 570 571
        s->channel[c].num_subframes = 0;

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

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

        /** check which channels contain the subframe */
572
        for (c = 0; c < s->avctx->channels; c++) {
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
            if (num_samples[c] == min_channel_len) {
                if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
                   (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
                    contains_subframe[c] = 1;
                else
                    contains_subframe[c] = get_bits1(&s->gb);
            } else
                contains_subframe[c] = 0;
        }

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

        /** add subframes to the individual channels and find new min_channel_len */
        min_channel_len += subframe_len;
589
        for (c = 0; c < s->avctx->channels; c++) {
590 591 592 593 594 595 596 597 598 599 600 601
            WMAProChannelCtx* chan = &s->channel[c];

            if (contains_subframe[c]) {
                if (chan->num_subframes >= MAX_SUBFRAMES) {
                    av_log(s->avctx, AV_LOG_ERROR,
                           "broken frame: num subframes > 31\n");
                    return AVERROR_INVALIDDATA;
                }
                chan->subframe_len[chan->num_subframes] = subframe_len;
                num_samples[c] += subframe_len;
                ++chan->num_subframes;
                if (num_samples[c] > s->samples_per_frame) {
602
                    av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
603 604 605
                           "channel len > samples_per_frame\n");
                    return AVERROR_INVALIDDATA;
                }
606
            } else if (num_samples[c] <= min_channel_len) {
607 608 609 610 611 612 613 614 615
                if (num_samples[c] < min_channel_len) {
                    channels_for_cur_subframe = 0;
                    min_channel_len = num_samples[c];
                }
                ++channels_for_cur_subframe;
            }
        }
    } while (min_channel_len < s->samples_per_frame);

616
    for (c = 0; c < s->avctx->channels; c++) {
617 618 619
        int i;
        int offset = 0;
        for (i = 0; i < s->channel[c].num_subframes; i++) {
620
            av_dlog(s->avctx, "frame[%i] channel[%i] subframe[%i]"
621 622
                    " len %i\n", s->frame_num, c, i,
                    s->channel[c].subframe_len[i]);
623 624 625 626 627 628 629 630
            s->channel[c].subframe_offset[i] = offset;
            offset += s->channel[c].subframe_len[i];
        }
    }

    return 0;
}

631 632 633 634 635
/**
 *@brief Calculate a decorrelation matrix from the bitstream parameters.
 *@param s codec context
 *@param chgroup channel group for which the matrix needs to be calculated
 */
636 637
static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
                                        WMAProChannelGrp *chgroup)
638 639 640 641
{
    int i;
    int offset = 0;
    int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
642 643
    memset(chgroup->decorrelation_matrix, 0, s->avctx->channels *
           s->avctx->channels * sizeof(*chgroup->decorrelation_matrix));
644

645
    for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
Diego Biurrun's avatar
Diego Biurrun committed
646
        rotation_offset[i] = get_bits(&s->gb, 6);
647

648
    for (i = 0; i < chgroup->num_channels; i++)
649
        chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
650
            get_bits1(&s->gb) ? 1.0 : -1.0;
651

652
    for (i = 1; i < chgroup->num_channels; i++) {
653
        int x;
654
        for (x = 0; x < i; x++) {
655
            int y;
Diego Biurrun's avatar
Diego Biurrun committed
656
            for (y = 0; y < i + 1; y++) {
657 658 659 660 661 662
                float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
                float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
                int n = rotation_offset[offset + x];
                float sinv;
                float cosv;

663
                if (n < 32) {
664
                    sinv = sin64[n];
665
                    cosv = sin64[32 - n];
666
                } else {
667 668
                    sinv =  sin64[64 -  n];
                    cosv = -sin64[n  - 32];
669 670 671 672 673 674 675 676 677 678 679 680
                }

                chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
                                               (v1 * sinv) - (v2 * cosv);
                chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
                                               (v1 * cosv) + (v2 * sinv);
            }
        }
        offset += i;
    }
}

681 682 683 684 685 686 687 688 689
/**
 *@brief Decode channel transformation parameters
 *@param s codec context
 *@return 0 in case of success, < 0 in case of bitstream errors
 */
static int decode_channel_transform(WMAProDecodeCtx* s)
{
    int i;
    /* should never consume more than 1921 bits for the 8 channel case
690
     * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
691 692 693 694 695
     * + MAX_CHANNELS + MAX_BANDS + 1)
     */

    /** in the one channel case channel transforms are pointless */
    s->num_chgroups = 0;
696
    if (s->avctx->channels > 1) {
697 698 699
        int remaining_channels = s->channels_for_cur_subframe;

        if (get_bits1(&s->gb)) {
700 701
            avpriv_request_sample(s->avctx,
                                  "Channel transform bit");
702
            return AVERROR_PATCHWELCOME;
703 704 705
        }

        for (s->num_chgroups = 0; remaining_channels &&
706
             s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
            WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
            float** channel_data = chgroup->channel_data;
            chgroup->num_channels = 0;
            chgroup->transform = 0;

            /** decode channel mask */
            if (remaining_channels > 2) {
                for (i = 0; i < s->channels_for_cur_subframe; i++) {
                    int channel_idx = s->channel_indexes_for_cur_subframe[i];
                    if (!s->channel[channel_idx].grouped
                        && get_bits1(&s->gb)) {
                        ++chgroup->num_channels;
                        s->channel[channel_idx].grouped = 1;
                        *channel_data++ = s->channel[channel_idx].coeffs;
                    }
                }
            } else {
                chgroup->num_channels = remaining_channels;
                for (i = 0; i < s->channels_for_cur_subframe; i++) {
                    int channel_idx = s->channel_indexes_for_cur_subframe[i];
                    if (!s->channel[channel_idx].grouped)
                        *channel_data++ = s->channel[channel_idx].coeffs;
                    s->channel[channel_idx].grouped = 1;
                }
            }

            /** decode transform type */
            if (chgroup->num_channels == 2) {
                if (get_bits1(&s->gb)) {
                    if (get_bits1(&s->gb)) {
737 738
                        avpriv_request_sample(s->avctx,
                                              "Unknown channel transform type");
739
                        return AVERROR_PATCHWELCOME;
740 741 742
                    }
                } else {
                    chgroup->transform = 1;
743
                    if (s->avctx->channels == 2) {
744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763
                        chgroup->decorrelation_matrix[0] =  1.0;
                        chgroup->decorrelation_matrix[1] = -1.0;
                        chgroup->decorrelation_matrix[2] =  1.0;
                        chgroup->decorrelation_matrix[3] =  1.0;
                    } else {
                        /** cos(pi/4) */
                        chgroup->decorrelation_matrix[0] =  0.70703125;
                        chgroup->decorrelation_matrix[1] = -0.70703125;
                        chgroup->decorrelation_matrix[2] =  0.70703125;
                        chgroup->decorrelation_matrix[3] =  0.70703125;
                    }
                }
            } else if (chgroup->num_channels > 2) {
                if (get_bits1(&s->gb)) {
                    chgroup->transform = 1;
                    if (get_bits1(&s->gb)) {
                        decode_decorrelation_matrix(s, chgroup);
                    } else {
                        /** FIXME: more than 6 coupled channels not supported */
                        if (chgroup->num_channels > 6) {
764 765
                            avpriv_request_sample(s->avctx,
                                                  "Coupled channels > 6");
766 767
                        } else {
                            memcpy(chgroup->decorrelation_matrix,
768 769 770
                                   default_decorrelation[chgroup->num_channels],
                                   chgroup->num_channels * chgroup->num_channels *
                                   sizeof(*chgroup->decorrelation_matrix));
771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793
                        }
                    }
                }
            }

            /** decode transform on / off */
            if (chgroup->transform) {
                if (!get_bits1(&s->gb)) {
                    int i;
                    /** transform can be enabled for individual bands */
                    for (i = 0; i < s->num_bands; i++) {
                        chgroup->transform_band[i] = get_bits1(&s->gb);
                    }
                } else {
                    memset(chgroup->transform_band, 1, s->num_bands);
                }
            }
            remaining_channels -= chgroup->num_channels;
        }
    }
    return 0;
}

Sascha Sommer's avatar
Sascha Sommer committed
794 795 796 797 798 799
/**
 *@brief Extract the coefficients from the bitstream.
 *@param s codec context
 *@param c current channel number
 *@return 0 on success, < 0 in case of bitstream errors
 */
800
static int decode_coeffs(WMAProDecodeCtx *s, int c)
Sascha Sommer's avatar
Sascha Sommer committed
801
{
802 803 804
    /* Integers 0..15 as single-precision floats.  The table saves a
       costly int to float conversion, and storing the values as
       integers allows fast sign-flipping. */
805
    static const uint32_t fval_tab[16] = {
806 807 808 809 810
        0x00000000, 0x3f800000, 0x40000000, 0x40400000,
        0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
        0x41000000, 0x41100000, 0x41200000, 0x41300000,
        0x41400000, 0x41500000, 0x41600000, 0x41700000,
    };
Sascha Sommer's avatar
Sascha Sommer committed
811 812
    int vlctable;
    VLC* vlc;
813
    WMAProChannelCtx* ci = &s->channel[c];
Sascha Sommer's avatar
Sascha Sommer committed
814 815 816 817
    int rl_mode = 0;
    int cur_coeff = 0;
    int num_zeros = 0;
    const uint16_t* run;
818
    const float* level;
Sascha Sommer's avatar
Sascha Sommer committed
819

820
    av_dlog(s->avctx, "decode coefficients for channel %i\n", c);
Sascha Sommer's avatar
Sascha Sommer committed
821 822 823 824 825 826 827 828 829 830 831 832 833 834

    vlctable = get_bits1(&s->gb);
    vlc = &coef_vlc[vlctable];

    if (vlctable) {
        run = coef1_run;
        level = coef1_level;
    } else {
        run = coef0_run;
        level = coef0_level;
    }

    /** decode vector coefficients (consumes up to 167 bits per iteration for
      4 vector coded large values) */
835 836
    while ((s->transmit_num_vec_coeffs || !rl_mode) &&
           (cur_coeff + 3 < ci->num_vec_coeffs)) {
837
        uint32_t vals[4];
Sascha Sommer's avatar
Sascha Sommer committed
838 839 840 841 842
        int i;
        unsigned int idx;

        idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);

Diego Biurrun's avatar
Diego Biurrun committed
843
        if (idx == HUFF_VEC4_SIZE - 1) {
Sascha Sommer's avatar
Sascha Sommer committed
844 845
            for (i = 0; i < 4; i += 2) {
                idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
Diego Biurrun's avatar
Diego Biurrun committed
846
                if (idx == HUFF_VEC2_SIZE - 1) {
847
                    uint32_t v0, v1;
848 849 850 851 852 853
                    v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
                    if (v0 == HUFF_VEC1_SIZE - 1)
                        v0 += ff_wma_get_large_val(&s->gb);
                    v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
                    if (v1 == HUFF_VEC1_SIZE - 1)
                        v1 += ff_wma_get_large_val(&s->gb);
854 855
                    vals[i  ] = av_float2int(v0);
                    vals[i+1] = av_float2int(v1);
Sascha Sommer's avatar
Sascha Sommer committed
856
                } else {
857 858
                    vals[i]   = fval_tab[symbol_to_vec2[idx] >> 4 ];
                    vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
Sascha Sommer's avatar
Sascha Sommer committed
859 860 861
                }
            }
        } else {
862 863 864 865
            vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12      ];
            vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
            vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
            vals[3] = fval_tab[ symbol_to_vec4[idx]       & 0xF];
Sascha Sommer's avatar
Sascha Sommer committed
866 867 868 869 870
        }

        /** decode sign */
        for (i = 0; i < 4; i++) {
            if (vals[i]) {
871 872
                uint32_t sign = get_bits1(&s->gb) - 1;
                AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
Sascha Sommer's avatar
Sascha Sommer committed
873 874
                num_zeros = 0;
            } else {
875
                ci->coeffs[cur_coeff] = 0;
Sascha Sommer's avatar
Sascha Sommer committed
876
                /** switch to run level mode when subframe_len / 128 zeros
877 878
                    were found in a row */
                rl_mode |= (++num_zeros > s->subframe_len >> 8);
Sascha Sommer's avatar
Sascha Sommer committed
879 880 881 882 883 884
            }
            ++cur_coeff;
        }
    }

    /** decode run level coded coefficients */
885
    if (cur_coeff < s->subframe_len) {
886 887
        memset(&ci->coeffs[cur_coeff], 0,
               sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
Diego Biurrun's avatar
Diego Biurrun committed
888 889 890 891
        if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
                                    level, run, 1, ci->coeffs,
                                    cur_coeff, s->subframe_len,
                                    s->subframe_len, s->esc_len, 0))
Sascha Sommer's avatar
Sascha Sommer committed
892 893 894 895 896 897
            return AVERROR_INVALIDDATA;
    }

    return 0;
}

898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913
/**
 *@brief Extract scale factors from the bitstream.
 *@param s codec context
 *@return 0 on success, < 0 in case of bitstream errors
 */
static int decode_scale_factors(WMAProDecodeCtx* s)
{
    int i;

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

    for (i = 0; i < s->channels_for_cur_subframe; i++) {
        int c = s->channel_indexes_for_cur_subframe[i];
        int* sf;
914 915 916
        int* sf_end;
        s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
        sf_end = s->channel[c].scale_factors + s->num_bands;
917 918 919 920 921 922 923 924 925 926 927

        /** resample scale factors for the new block size
         *  as the scale factors might need to be resampled several times
         *  before some  new values are transmitted, a backup of the last
         *  transmitted scale factors is kept in saved_scale_factors
         */
        if (s->channel[c].reuse_sf) {
            const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
            int b;
            for (b = 0; b < s->num_bands; b++)
                s->channel[c].scale_factors[b] =
928
                    s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952
        }

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

            if (!s->channel[c].reuse_sf) {
                int val;
                /** decode DPCM coded scale factors */
                s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
                val = 45 / s->channel[c].scale_factor_step;
                for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
                    val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
                    *sf = val;
                }
            } else {
                int i;
                /** run level decode differences to the resampled factors */
                for (i = 0; i < s->num_bands; i++) {
                    int idx;
                    int skip;
                    int val;
                    int sign;

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

953
                    if (!idx) {
954 955 956 957 958 959 960 961 962 963 964 965 966 967
                        uint32_t code = get_bits(&s->gb, 14);
                        val  =  code >> 6;
                        sign = (code & 1) - 1;
                        skip = (code & 0x3f) >> 1;
                    } else if (idx == 1) {
                        break;
                    } else {
                        skip = scale_rl_run[idx];
                        val  = scale_rl_level[idx];
                        sign = get_bits1(&s->gb)-1;
                    }

                    i += skip;
                    if (i >= s->num_bands) {
968
                        av_log(s->avctx, AV_LOG_ERROR,
969 970 971 972 973 974
                               "invalid scale factor coding\n");
                        return AVERROR_INVALIDDATA;
                    }
                    s->channel[c].scale_factors[i] += (val ^ sign) - sign;
                }
            }
975 976
            /** swap buffers */
            s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
            s->channel[c].table_idx = s->table_idx;
            s->channel[c].reuse_sf  = 1;
        }

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

    }
    return 0;
}

992 993 994 995
/**
 *@brief Reconstruct the individual channel data.
 *@param s codec context
 */
996
static void inverse_channel_transform(WMAProDecodeCtx *s)
997 998 999
{
    int i;

1000
    for (i = 0; i < s->num_chgroups; i++) {
1001
        if (s->chgroup[i].transform) {
1002 1003 1004 1005 1006 1007 1008 1009
            float data[WMAPRO_MAX_CHANNELS];
            const int num_channels = s->chgroup[i].num_channels;
            float** ch_data = s->chgroup[i].channel_data;
            float** ch_end = ch_data + num_channels;
            const int8_t* tb = s->chgroup[i].transform_band;
            int16_t* sfb;

            /** multichannel decorrelation */
Diego Biurrun's avatar
Diego Biurrun committed
1010
            for (sfb = s->cur_sfb_offsets;
1011
                 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
1012
                int y;
1013 1014
                if (*tb++ == 1) {
                    /** multiply values with the decorrelation_matrix */
1015
                    for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
1016
                        const float* mat = s->chgroup[i].decorrelation_matrix;
1017 1018
                        const float* data_end = data + num_channels;
                        float* data_ptr = data;
1019 1020
                        float** ch;

Diego Biurrun's avatar
Diego Biurrun committed
1021
                        for (ch = ch_data; ch < ch_end; ch++)
1022
                            *data_ptr++ = (*ch)[y];
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032

                        for (ch = ch_data; ch < ch_end; ch++) {
                            float sum = 0;
                            data_ptr = data;
                            while (data_ptr < data_end)
                                sum += *data_ptr++ * *mat++;

                            (*ch)[y] = sum;
                        }
                    }
1033
                } else if (s->avctx->channels == 2) {
1034
                    int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
1035 1036 1037 1038 1039 1040
                    s->fdsp.vector_fmul_scalar(ch_data[0] + sfb[0],
                                               ch_data[0] + sfb[0],
                                               181.0 / 128, len);
                    s->fdsp.vector_fmul_scalar(ch_data[1] + sfb[0],
                                               ch_data[1] + sfb[0],
                                               181.0 / 128, len);
1041 1042 1043 1044 1045 1046
                }
            }
        }
    }
}

1047 1048 1049 1050 1051 1052 1053
/**
 *@brief Apply sine window and reconstruct the output buffer.
 *@param s codec context
 */
static void wmapro_window(WMAProDecodeCtx *s)
{
    int i;
1054
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1055 1056 1057 1058 1059 1060
        int c = s->channel_indexes_for_cur_subframe[i];
        float* window;
        int winlen = s->channel[c].prev_block_len;
        float* start = s->channel[c].coeffs - (winlen >> 1);

        if (s->subframe_len < winlen) {
1061
            start += (winlen - s->subframe_len) >> 1;
1062 1063 1064
            winlen = s->subframe_len;
        }

1065
        window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1066 1067 1068

        winlen >>= 1;

1069 1070
        s->fdsp.vector_fmul_window(start, start, start + winlen,
                                   window, winlen);
1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085

        s->channel[c].prev_block_len = s->subframe_len;
    }
}

/**
 *@brief Decode a single subframe (block).
 *@param s codec context
 *@return 0 on success, < 0 when decoding failed
 */
static int decode_subframe(WMAProDecodeCtx *s)
{
    int offset = s->samples_per_frame;
    int subframe_len = s->samples_per_frame;
    int i;
1086
    int total_samples   = s->samples_per_frame * s->avctx->channels;
1087 1088 1089 1090 1091 1092 1093 1094 1095
    int transmit_coeffs = 0;
    int cur_subwoofer_cutoff;

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

    /** reset channel context and find the next block offset and size
        == the next block of the channel with the smallest number of
        decoded samples
    */
1096
    for (i = 0; i < s->avctx->channels; i++) {
1097 1098 1099 1100 1101 1102 1103 1104
        s->channel[i].grouped = 0;
        if (offset > s->channel[i].decoded_samples) {
            offset = s->channel[i].decoded_samples;
            subframe_len =
                s->channel[i].subframe_len[s->channel[i].cur_subframe];
        }
    }

1105
    av_dlog(s->avctx,
1106
            "processing subframe with offset %i len %i\n", offset, subframe_len);
1107 1108 1109

    /** get a list of all channels that contain the estimated block */
    s->channels_for_cur_subframe = 0;
1110
    for (i = 0; i < s->avctx->channels; i++) {
1111
        const int cur_subframe = s->channel[i].cur_subframe;
Diego Biurrun's avatar
Diego Biurrun committed
1112
        /** subtract already processed samples */
1113 1114 1115 1116
        total_samples -= s->channel[i].decoded_samples;

        /** and count if there are multiple subframes that match our profile */
        if (offset == s->channel[i].decoded_samples &&
1117
            subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
            total_samples -= s->channel[i].subframe_len[cur_subframe];
            s->channel[i].decoded_samples +=
                s->channel[i].subframe_len[cur_subframe];
            s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
            ++s->channels_for_cur_subframe;
        }
    }

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


1132
    av_dlog(s->avctx, "subframe is part of %i channels\n",
1133
            s->channels_for_cur_subframe);
1134 1135 1136 1137 1138 1139 1140 1141

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

    /** configure the decoder for the current subframe */
1142 1143
    offset += s->samples_per_frame >> 1;

1144 1145 1146
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
        int c = s->channel_indexes_for_cur_subframe[i];

1147
        s->channel[c].coeffs = &s->channel[c].out[offset];
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
    }

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

    /** skip extended header if any */
    if (get_bits1(&s->gb)) {
        int num_fill_bits;
        if (!(num_fill_bits = get_bits(&s->gb, 2))) {
            int len = get_bits(&s->gb, 4);
1158
            num_fill_bits = (len ? get_bits(&s->gb, len) : 0) + 1;
1159 1160 1161 1162
        }

        if (num_fill_bits >= 0) {
            if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1163
                av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1164 1165 1166 1167 1168 1169 1170 1171 1172
                return AVERROR_INVALIDDATA;
            }

            skip_bits_long(&s->gb, num_fill_bits);
        }
    }

    /** no idea for what the following bit is used */
    if (get_bits1(&s->gb)) {
1173
        avpriv_request_sample(s->avctx, "Reserved bit");
1174
        return AVERROR_PATCHWELCOME;
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187
    }


    if (decode_channel_transform(s) < 0)
        return AVERROR_INVALIDDATA;


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

1188
    av_assert0(s->subframe_len <= WMAPRO_BLOCK_MAX_SIZE);
1189 1190 1191
    if (transmit_coeffs) {
        int step;
        int quant_step = 90 * s->bits_per_sample >> 4;
1192 1193 1194 1195 1196 1197

        /** decode number of vector coded coefficients */
        if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
            int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
            for (i = 0; i < s->channels_for_cur_subframe; i++) {
                int c = s->channel_indexes_for_cur_subframe[i];
1198
                int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1199
                if (num_vec_coeffs > s->subframe_len) {
1200 1201 1202
                    av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs);
                    return AVERROR_INVALIDDATA;
                }
1203
                av_assert0(num_vec_coeffs + offset <= FF_ARRAY_ELEMS(s->channel[c].out));
1204
                s->channel[c].num_vec_coeffs = num_vec_coeffs;
1205 1206 1207 1208 1209 1210
            }
        } else {
            for (i = 0; i < s->channels_for_cur_subframe; i++) {
                int c = s->channel_indexes_for_cur_subframe[i];
                s->channel[c].num_vec_coeffs = s->subframe_len;
            }
1211 1212 1213 1214 1215 1216 1217 1218
        }
        /** decode quantization step */
        step = get_sbits(&s->gb, 6);
        quant_step += step;
        if (step == -32 || step == 31) {
            const int sign = (step == 31) - 1;
            int quant = 0;
            while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1219 1220
                   (step = get_bits(&s->gb, 5)) == 31) {
                quant += 31;
1221 1222 1223 1224
            }
            quant_step += ((quant + step) ^ sign) - sign;
        }
        if (quant_step < 0) {
1225
            av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238
        }

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

        if (s->channels_for_cur_subframe == 1) {
            s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
        } else {
            int modifier_len = get_bits(&s->gb, 3);
            for (i = 0; i < s->channels_for_cur_subframe; i++) {
                int c = s->channel_indexes_for_cur_subframe[i];
                s->channel[c].quant_step = quant_step;
                if (get_bits1(&s->gb)) {
                    if (modifier_len) {
1239
                        s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
                    } else
                        ++s->channel[c].quant_step;
                }
            }
        }

        /** decode scale factors */
        if (decode_scale_factors(s) < 0)
            return AVERROR_INVALIDDATA;
    }

1251
    av_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1252
            get_bits_count(&s->gb) - s->subframe_offset);
1253 1254 1255 1256 1257

    /** parse coefficients */
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
        int c = s->channel_indexes_for_cur_subframe[i];
        if (s->channel[c].transmit_coefs &&
1258 1259
            get_bits_count(&s->gb) < s->num_saved_bits) {
            decode_coeffs(s, c);
1260 1261 1262 1263 1264
        } else
            memset(s->channel[c].coeffs, 0,
                   sizeof(*s->channel[c].coeffs) * subframe_len);
    }

1265
    av_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1266
            get_bits_count(&s->gb) - s->subframe_offset);
1267 1268

    if (transmit_coeffs) {
1269
        FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287
        /** reconstruct the per channel data */
        inverse_channel_transform(s);
        for (i = 0; i < s->channels_for_cur_subframe; i++) {
            int c = s->channel_indexes_for_cur_subframe[i];
            const int* sf = s->channel[c].scale_factors;
            int b;

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

            /** inverse quantization and rescaling */
            for (b = 0; b < s->num_bands; b++) {
                const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
                const int exp = s->channel[c].quant_step -
                            (s->channel[c].max_scale_factor - *sf++) *
                            s->channel[c].scale_factor_step;
                const float quant = pow(10.0, exp / 20.0);
1288
                int start = s->cur_sfb_offsets[b];
1289 1290 1291
                s->fdsp.vector_fmul_scalar(s->tmp + start,
                                           s->channel[c].coeffs + start,
                                           quant, end - start);
1292 1293
            }

1294 1295
            /** apply imdct (imdct_half == DCTIV with reverse) */
            mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305
        }
    }

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

    /** handled one subframe */
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
        int c = s->channel_indexes_for_cur_subframe[i];
        if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1306
            av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320
            return AVERROR_INVALIDDATA;
        }
        ++s->channel[c].cur_subframe;
    }

    return 0;
}

/**
 *@brief Decode one WMA frame.
 *@param s codec context
 *@return 0 if the trailer bit indicates that this is the last frame,
 *        1 if there are additional frames
 */
1321
static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
1322
{
1323
    AVCodecContext *avctx = s->avctx;
1324 1325 1326
    GetBitContext* gb = &s->gb;
    int more_frames = 0;
    int len = 0;
1327
    int i, ret;
1328 1329 1330 1331 1332

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

1333
    av_dlog(s->avctx, "decoding frame with length %x\n", len);
1334 1335 1336 1337 1338 1339 1340 1341

    /** decode tile information */
    if (decode_tilehdr(s)) {
        s->packet_loss = 1;
        return 0;
    }

    /** read postproc transform */
1342
    if (s->avctx->channels > 1 && get_bits1(gb)) {
1343
        if (get_bits1(gb)) {
1344
            for (i = 0; i < avctx->channels * avctx->channels; i++)
1345 1346
                skip_bits(gb, 4);
        }
1347 1348 1349 1350 1351
    }

    /** read drc info */
    if (s->dynamic_range_compression) {
        s->drc_gain = get_bits(gb, 8);
1352
        av_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1353 1354 1355 1356 1357
    }

    /** no idea what these are for, might be the number of samples
        that need to be skipped at the beginning or end of a stream */
    if (get_bits1(gb)) {
1358
        int av_unused skip;
1359 1360 1361 1362

        /** usually true for the first frame */
        if (get_bits1(gb)) {
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1363
            av_dlog(s->avctx, "start skip: %i\n", skip);
1364 1365 1366 1367 1368
        }

        /** sometimes true for the last frame */
        if (get_bits1(gb)) {
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1369
            av_dlog(s->avctx, "end skip: %i\n", skip);
1370 1371 1372 1373
        }

    }

1374
    av_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1375
            get_bits_count(gb) - s->frame_offset);
1376 1377 1378

    /** reset subframe states */
    s->parsed_all_subframes = 0;
1379
    for (i = 0; i < avctx->channels; i++) {
1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392
        s->channel[i].decoded_samples = 0;
        s->channel[i].cur_subframe    = 0;
        s->channel[i].reuse_sf        = 0;
    }

    /** decode all subframes */
    while (!s->parsed_all_subframes) {
        if (decode_subframe(s) < 0) {
            s->packet_loss = 1;
            return 0;
        }
    }

1393
    /* get output buffer */
1394
    frame->nb_samples = s->samples_per_frame;
1395
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1396 1397 1398 1399
        s->packet_loss = 1;
        return 0;
    }

1400
    /** copy samples to the output buffer */
1401
    for (i = 0; i < avctx->channels; i++)
1402
        memcpy(frame->extended_data[i], s->channel[i].out,
1403
               s->samples_per_frame * sizeof(*s->channel[i].out));
1404

1405
    for (i = 0; i < avctx->channels; i++) {
1406 1407 1408 1409 1410 1411 1412 1413
        /** reuse second half of the IMDCT output for the next frame */
        memcpy(&s->channel[i].out[0],
               &s->channel[i].out[s->samples_per_frame],
               s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
    }

    if (s->skip_frame) {
        s->skip_frame = 0;
1414
        *got_frame_ptr = 0;
1415
        av_frame_unref(frame);
1416 1417 1418
    } else {
        *got_frame_ptr = 1;
    }
1419

1420
    if (s->len_prefix) {
Sascha Sommer's avatar
Sascha Sommer committed
1421 1422 1423 1424 1425 1426 1427 1428
        if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
            /** FIXME: not sure if this is always an error */
            av_log(s->avctx, AV_LOG_ERROR,
                   "frame[%i] would have to skip %i bits\n", s->frame_num,
                   len - (get_bits_count(gb) - s->frame_offset) - 1);
            s->packet_loss = 1;
            return 0;
        }
1429

Sascha Sommer's avatar
Sascha Sommer committed
1430 1431
        /** skip the rest of the frame data */
        skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1432 1433 1434 1435
    } else {
        while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
        }
    }
1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449

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

    ++s->frame_num;
    return more_frames;
}

/**
 *@brief Calculate remaining input buffer length.
 *@param s codec context
 *@param gb bitstream reader context
 *@return remaining size in bits
 */
1450
static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1451 1452 1453 1454 1455 1456 1457 1458 1459
{
    return s->buf_bit_size - get_bits_count(gb);
}

/**
 *@brief Fill the bit reservoir with a (partial) frame.
 *@param s codec context
 *@param gb bitstream reader context
 *@param len length of the partial frame
1460
 *@param append decides whether to reset the buffer or not
1461 1462
 */
static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1463
                      int append)
1464 1465 1466 1467
{
    int buflen;

    /** when the frame data does not need to be concatenated, the input buffer
1468
        is reset and additional bits from the previous frame are copied
1469 1470 1471 1472 1473 1474 1475 1476
        and skipped later so that a fast byte copy is possible */

    if (!append) {
        s->frame_offset = get_bits_count(gb) & 7;
        s->num_saved_bits = s->frame_offset;
        init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
    }

1477
    buflen = (put_bits_count(&s->pb) + len + 8) >> 3;
1478 1479

    if (len <= 0 || buflen > MAX_FRAMESIZE) {
1480
        avpriv_request_sample(s->avctx, "Too small input buffer");
1481 1482
        s->packet_loss = 1;
        return;
1483 1484
    }

1485
    av_assert0(len <= put_bits_left(&s->pb));
1486

1487 1488
    s->num_saved_bits += len;
    if (!append) {
1489
        avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1490
                     s->num_saved_bits);
1491 1492 1493 1494 1495
    } else {
        int align = 8 - (get_bits_count(gb) & 7);
        align = FFMIN(align, len);
        put_bits(&s->pb, align, get_bits(gb, align));
        len -= align;
1496
        avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1497 1498 1499 1500
    }
    skip_bits_long(gb, len);

    {
1501 1502
        PutBitContext tmp = s->pb;
        flush_put_bits(&tmp);
1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
    }

    init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
    skip_bits(&s->gb, s->frame_offset);
}

/**
 *@brief Decode a single WMA packet.
 *@param avctx codec context
 *@param data the output buffer
 *@param avpkt input packet
 *@return number of bytes that were read from the input buffer
 */
1516 1517
static int decode_packet(AVCodecContext *avctx, void *data,
                         int *got_frame_ptr, AVPacket* avpkt)
1518 1519
{
    WMAProDecodeCtx *s = avctx->priv_data;
Sascha Sommer's avatar
Sascha Sommer committed
1520 1521 1522
    GetBitContext* gb  = &s->pgb;
    const uint8_t* buf = avpkt->data;
    int buf_size       = avpkt->size;
1523 1524 1525
    int num_bits_prev_frame;
    int packet_sequence_number;

1526
    *got_frame_ptr = 0;
1527

1528 1529
    if (s->packet_done || s->packet_loss) {
        s->packet_done = 0;
1530

Sascha Sommer's avatar
Sascha Sommer committed
1531
        /** sanity check for the buffer length */
1532 1533 1534 1535 1536
        if (buf_size < avctx->block_align) {
            av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
                   buf_size, avctx->block_align);
            return AVERROR_INVALIDDATA;
        }
1537

1538
        s->next_packet_start = buf_size - avctx->block_align;
Sascha Sommer's avatar
Sascha Sommer committed
1539
        buf_size = avctx->block_align;
1540
        s->buf_bit_size = buf_size << 3;
1541

Sascha Sommer's avatar
Sascha Sommer committed
1542 1543 1544 1545
        /** parse packet header */
        init_get_bits(gb, buf, s->buf_bit_size);
        packet_sequence_number = get_bits(gb, 4);
        skip_bits(gb, 2);
1546

Sascha Sommer's avatar
Sascha Sommer committed
1547 1548
        /** get number of bits that need to be added to the previous frame */
        num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1549
        av_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
Sascha Sommer's avatar
Sascha Sommer committed
1550
                num_bits_prev_frame);
1551

Sascha Sommer's avatar
Sascha Sommer committed
1552 1553 1554 1555 1556 1557 1558 1559 1560 1561
        /** check for packet loss */
        if (!s->packet_loss &&
            ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
            s->packet_loss = 1;
            av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
                   s->packet_sequence_number, packet_sequence_number);
        }
        s->packet_sequence_number = packet_sequence_number;

        if (num_bits_prev_frame > 0) {
1562 1563 1564 1565 1566 1567
            int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
            if (num_bits_prev_frame >= remaining_packet_bits) {
                num_bits_prev_frame = remaining_packet_bits;
                s->packet_done = 1;
            }

Sascha Sommer's avatar
Sascha Sommer committed
1568 1569 1570
            /** append the previous frame data to the remaining data from the
                previous packet to create a full frame */
            save_bits(s, gb, num_bits_prev_frame, 1);
1571
            av_dlog(avctx, "accumulated %x bits of frame data\n",
Sascha Sommer's avatar
Sascha Sommer committed
1572 1573 1574 1575
                    s->num_saved_bits - s->frame_offset);

            /** decode the cross packet frame if it is valid */
            if (!s->packet_loss)
1576
                decode_frame(s, data, got_frame_ptr);
Sascha Sommer's avatar
Sascha Sommer committed
1577
        } else if (s->num_saved_bits - s->frame_offset) {
1578
            av_dlog(avctx, "ignoring %x previously saved bits\n",
Sascha Sommer's avatar
Sascha Sommer committed
1579 1580
                    s->num_saved_bits - s->frame_offset);
        }
1581

1582 1583 1584 1585 1586 1587 1588
        if (s->packet_loss) {
            /** reset number of saved bits so that the decoder
                does not start to decode incomplete frames in the
                s->len_prefix == 0 case */
            s->num_saved_bits = 0;
            s->packet_loss = 0;
        }
1589 1590

    } else {
1591
        int frame_size;
1592
        s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1593 1594
        init_get_bits(gb, avpkt->data, s->buf_bit_size);
        skip_bits(gb, s->packet_offset);
1595
        if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1596 1597
            (frame_size = show_bits(gb, s->log2_frame_size)) &&
            frame_size <= remaining_bits(s, gb)) {
1598
            save_bits(s, gb, frame_size, 0);
1599 1600
            if (!s->packet_loss)
                s->packet_done = !decode_frame(s, data, got_frame_ptr);
1601 1602 1603 1604 1605 1606 1607 1608 1609
        } else if (!s->len_prefix
                   && s->num_saved_bits > get_bits_count(&s->gb)) {
            /** when the frames do not have a length prefix, we don't know
                the compressed length of the individual frames
                however, we know what part of a new packet belongs to the
                previous frame
                therefore we save the incoming packet first, then we append
                the "previous frame" data from the next packet so that
                we get a buffer that only contains full frames */
1610
            s->packet_done = !decode_frame(s, data, got_frame_ptr);
1611
        } else
1612
            s->packet_done = 1;
1613 1614
    }

1615
    if (s->packet_done && !s->packet_loss &&
1616
        remaining_bits(s, gb) > 0) {
1617 1618
        /** save the rest of the data so that it can be decoded
            with the next packet */
1619
        save_bits(s, gb, remaining_bits(s, gb), 0);
1620 1621
    }

1622
    s->packet_offset = get_bits_count(gb) & 7;
1623 1624 1625 1626
    if (s->packet_loss)
        return AVERROR_INVALIDDATA;

    return get_bits_count(gb) >> 3;
1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638
}

/**
 *@brief Clear decoder buffers (for seeking).
 *@param avctx codec context
 */
static void flush(AVCodecContext *avctx)
{
    WMAProDecodeCtx *s = avctx->priv_data;
    int i;
    /** reset output buffer as a part of it is used during the windowing of a
        new frame */
1639
    for (i = 0; i < avctx->channels; i++)
1640 1641 1642 1643 1644 1645 1646 1647 1648
        memset(s->channel[i].out, 0, s->samples_per_frame *
               sizeof(*s->channel[i].out));
    s->packet_loss = 1;
}


/**
 *@brief wmapro decoder
 */
1649
AVCodec ff_wmapro_decoder = {
1650
    .name           = "wmapro",
1651
    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1652
    .type           = AVMEDIA_TYPE_AUDIO,
1653
    .id             = AV_CODEC_ID_WMAPRO,
1654 1655 1656 1657
    .priv_data_size = sizeof(WMAProDecodeCtx),
    .init           = decode_init,
    .close          = decode_end,
    .decode         = decode_packet,
1658
    .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1659
    .flush          = flush,
1660 1661
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
                                                      AV_SAMPLE_FMT_NONE },
1662
};