git.sesse.net Git - ffmpeg/blob - libavcodec/wmaprodec.c

   1 /*
   2  * Wmapro compatible decoder
   3  * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
   4  * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /**
  24  * @file
  25  * @brief wmapro decoder implementation
  26  * Wmapro is an MDCT based codec comparable to wma standard or AAC.
  27  * The decoding therefore consists of the following steps:
  28  * - bitstream decoding
  29  * - reconstruction of per-channel data
  30  * - rescaling and inverse quantization
  31  * - IMDCT
  32  * - windowing and overlapp-add
  33  *
  34  * The compressed wmapro bitstream is split into individual packets.
  35  * Every such packet contains one or more wma frames.
  36  * The compressed frames may have a variable length and frames may
  37  * cross packet boundaries.
  38  * Common to all wmapro frames is the number of samples that are stored in
  39  * a frame.
  40  * The number of samples and a few other decode flags are stored
  41  * as extradata that has to be passed to the decoder.
  42  *
  43  * The wmapro frames themselves are again split into a variable number of
  44  * subframes. Every subframe contains the data for 2^N time domain samples
  45  * where N varies between 7 and 12.
  46  *
  47  * Example wmapro bitstream (in samples):
  48  *
  49  * ||   packet 0           || packet 1 || packet 2      packets
  50  * ---------------------------------------------------
  51  * || frame 0      || frame 1       || frame 2    ||    frames
  52  * ---------------------------------------------------
  53  * ||   |      |   ||   |   |   |   ||            ||    subframes of channel 0
  54  * ---------------------------------------------------
  55  * ||      |   |   ||   |   |   |   ||            ||    subframes of channel 1
  56  * ---------------------------------------------------
  57  *
  58  * The frame layouts for the individual channels of a wma frame does not need
  59  * to be the same.
  60  *
  61  * However, if the offsets and lengths of several subframes of a frame are the
  62  * same, the subframes of the channels can be grouped.
  63  * Every group may then use special coding techniques like M/S stereo coding
  64  * to improve the compression ratio. These channel transformations do not
  65  * need to be applied to a whole subframe. Instead, they can also work on
  66  * individual scale factor bands (see below).
  67  * The coefficients that carry the audio signal in the frequency domain
  68  * are transmitted as huffman-coded vectors with 4, 2 and 1 elements.
  69  * In addition to that, the encoder can switch to a runlevel coding scheme
  70  * by transmitting subframe_length / 128 zero coefficients.
  71  *
  72  * Before the audio signal can be converted to the time domain, the
  73  * coefficients have to be rescaled and inverse quantized.
  74  * A subframe is therefore split into several scale factor bands that get
  75  * scaled individually.
  76  * Scale factors are submitted for every frame but they might be shared
  77  * between the subframes of a channel. Scale factors are initially DPCM-coded.
  78  * Once scale factors are shared, the differences are transmitted as runlevel
  79  * codes.
  80  * Every subframe length and offset combination in the frame layout shares a
  81  * common quantization factor that can be adjusted for every channel by a
  82  * modifier.
  83  * After the inverse quantization, the coefficients get processed by an IMDCT.
  84  * The resulting values are then windowed with a sine window and the first half
  85  * of the values are added to the second half of the output from the previous
  86  * subframe in order to reconstruct the output samples.
  87  */
  88
  89 #include <inttypes.h>
  90
  91 #include "libavutil/ffmath.h"
  92 #include "libavutil/float_dsp.h"
  93 #include "libavutil/intfloat.h"
  94 #include "libavutil/intreadwrite.h"
  95 #include "avcodec.h"
  96 #include "internal.h"
  97 #include "get_bits.h"
  98 #include "put_bits.h"
  99 #include "wmaprodata.h"
 100 #include "sinewin.h"
 101 #include "wma.h"
 102 #include "wma_common.h"
 103
 104 /** current decoder limitations */
 105 #define WMAPRO_MAX_CHANNELS    8                             ///< max number of handled channels
 106 #define MAX_SUBFRAMES  32                                    ///< max number of subframes per channel
 107 #define MAX_BANDS      29                                    ///< max number of scale factor bands
 108 #define MAX_FRAMESIZE  32768                                 ///< maximum compressed frame size
 109
 110 #define WMAPRO_BLOCK_MIN_BITS  6                                           ///< log2 of min block size
 111 #define WMAPRO_BLOCK_MAX_BITS 13                                           ///< log2 of max block size
 112 #define WMAPRO_BLOCK_MIN_SIZE (1 << WMAPRO_BLOCK_MIN_BITS)                 ///< minimum block size
 113 #define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS)                 ///< maximum block size
 114 #define WMAPRO_BLOCK_SIZES    (WMAPRO_BLOCK_MAX_BITS - WMAPRO_BLOCK_MIN_BITS + 1) ///< possible block sizes
 115
 116
 117 #define VLCBITS            9
 118 #define SCALEVLCBITS       8
 119 #define VEC4MAXDEPTH    ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
 120 #define VEC2MAXDEPTH    ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
 121 #define VEC1MAXDEPTH    ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
 122 #define SCALEMAXDEPTH   ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
 123 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
 124
 125 static VLC              sf_vlc;           ///< scale factor DPCM vlc
 126 static VLC              sf_rl_vlc;        ///< scale factor run length vlc
 127 static VLC              vec4_vlc;         ///< 4 coefficients per symbol
 128 static VLC              vec2_vlc;         ///< 2 coefficients per symbol
 129 static VLC              vec1_vlc;         ///< 1 coefficient per symbol
 130 static VLC              coef_vlc[2];      ///< coefficient run length vlc codes
 131 static float            sin64[33];        ///< sine table for decorrelation
 132
 133 /**
 134  * @brief frame specific decoder context for a single channel
 135  */
 136 typedef struct WMAProChannelCtx {
 137     int16_t  prev_block_len;                          ///< length of the previous block
 138     uint8_t  transmit_coefs;
 139     uint8_t  num_subframes;
 140     uint16_t subframe_len[MAX_SUBFRAMES];             ///< subframe length in samples
 141     uint16_t subframe_offset[MAX_SUBFRAMES];          ///< subframe positions in the current frame
 142     uint8_t  cur_subframe;                            ///< current subframe number
 143     uint16_t decoded_samples;                         ///< number of already processed samples
 144     uint8_t  grouped;                                 ///< channel is part of a group
 145     int      quant_step;                              ///< quantization step for the current subframe
 146     int8_t   reuse_sf;                                ///< share scale factors between subframes
 147     int8_t   scale_factor_step;                       ///< scaling step for the current subframe
 148     int      max_scale_factor;                        ///< maximum scale factor for the current subframe
 149     int      saved_scale_factors[2][MAX_BANDS];       ///< resampled and (previously) transmitted scale factor values
 150     int8_t   scale_factor_idx;                        ///< index for the transmitted scale factor values (used for resampling)
 151     int*     scale_factors;                           ///< pointer to the scale factor values used for decoding
 152     uint8_t  table_idx;                               ///< index in sf_offsets for the scale factor reference block
 153     float*   coeffs;                                  ///< pointer to the subframe decode buffer
 154     uint16_t num_vec_coeffs;                          ///< number of vector coded coefficients
 155     DECLARE_ALIGNED(32, float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; ///< output buffer
 156 } WMAProChannelCtx;
 157
 158 /**
 159  * @brief channel group for channel transformations
 160  */
 161 typedef struct WMAProChannelGrp {
 162     uint8_t num_channels;                                     ///< number of channels in the group
 163     int8_t  transform;                                        ///< transform on / off
 164     int8_t  transform_band[MAX_BANDS];                        ///< controls if the transform is enabled for a certain band
 165     float   decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];
 166     float*  channel_data[WMAPRO_MAX_CHANNELS];                ///< transformation coefficients
 167 } WMAProChannelGrp;
 168
 169 /**
 170  * @brief main decoder context
 171  */
 172 typedef struct WMAProDecodeCtx {
 173     /* generic decoder variables */
 174     AVCodecContext*  avctx;                         ///< codec context for av_log
 175     AVFloatDSPContext *fdsp;
 176     uint8_t          frame_data[MAX_FRAMESIZE +
 177                       AV_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
 178     PutBitContext    pb;                            ///< context for filling the frame_data buffer
 179     FFTContext       mdct_ctx[WMAPRO_BLOCK_SIZES];  ///< MDCT context per block size
 180     DECLARE_ALIGNED(32, float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; ///< IMDCT output buffer
 181     const float*     windows[WMAPRO_BLOCK_SIZES];   ///< windows for the different block sizes
 182
 183     /* frame size dependent frame information (set during initialization) */
 184     uint32_t         decode_flags;                  ///< used compression features
 185     uint8_t          len_prefix;                    ///< frame is prefixed with its length
 186     uint8_t          dynamic_range_compression;     ///< frame contains DRC data
 187     uint8_t          bits_per_sample;               ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
 188     uint16_t         samples_per_frame;             ///< number of samples to output
 189     uint16_t         log2_frame_size;
 190     int8_t           lfe_channel;                   ///< lfe channel index
 191     uint8_t          max_num_subframes;
 192     uint8_t          subframe_len_bits;             ///< number of bits used for the subframe length
 193     uint8_t          max_subframe_len_bit;          ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
 194     uint16_t         min_samples_per_subframe;
 195     int8_t           num_sfb[WMAPRO_BLOCK_SIZES];   ///< scale factor bands per block size
 196     int16_t          sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS];                    ///< scale factor band offsets (multiples of 4)
 197     int8_t           sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
 198     int16_t          subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values
 199
 200     /* packet decode state */
 201     GetBitContext    pgb;                           ///< bitstream reader context for the packet
 202     int              next_packet_start;             ///< start offset of the next wma packet in the demuxer packet
 203     uint8_t          packet_offset;                 ///< frame offset in the packet
 204     uint8_t          packet_sequence_number;        ///< current packet number
 205     int              num_saved_bits;                ///< saved number of bits
 206     int              frame_offset;                  ///< frame offset in the bit reservoir
 207     int              subframe_offset;               ///< subframe offset in the bit reservoir
 208     uint8_t          packet_loss;                   ///< set in case of bitstream error
 209     uint8_t          packet_done;                   ///< set when a packet is fully decoded
 210     uint8_t          skip_packets;
 211
 212     /* frame decode state */
 213     uint32_t         frame_num;                     ///< current frame number (not used for decoding)
 214     int              num_frames;
 215     GetBitContext    gb;                            ///< bitstream reader context
 216     int              buf_bit_size;                  ///< buffer size in bits
 217     uint8_t          drc_gain;                      ///< gain for the DRC tool
 218     int8_t           skip_frame;                    ///< skip output step
 219     int8_t           parsed_all_subframes;          ///< all subframes decoded?
 220
 221     /* subframe/block decode state */
 222     int16_t          subframe_len;                  ///< current subframe length
 223     int8_t           channels_for_cur_subframe;     ///< number of channels that contain the subframe
 224     int8_t           channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS];
 225     int8_t           num_bands;                     ///< number of scale factor bands
 226     int8_t           transmit_num_vec_coeffs;       ///< number of vector coded coefficients is part of the bitstream
 227     int16_t*         cur_sfb_offsets;               ///< sfb offsets for the current block
 228     uint8_t          table_idx;                     ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
 229     int8_t           esc_len;                       ///< length of escaped coefficients
 230
 231     uint8_t          num_chgroups;                  ///< number of channel groups
 232     WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS];  ///< channel group information
 233
 234     WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS];  ///< per channel data
 235 } WMAProDecodeCtx;
 236
 237
 238 /**
 239  *@brief helper function to print the most important members of the context
 240  *@param s context
 241  */
 242 static av_cold void dump_context(WMAProDecodeCtx *s)
 243 {
 244 #define PRINT(a, b)     av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
 245 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %"PRIx32"\n", a, b);
 246
 247     PRINT("ed sample bit depth", s->bits_per_sample);
 248     PRINT_HEX("ed decode flags", s->decode_flags);
 249     PRINT("samples per frame",   s->samples_per_frame);
 250     PRINT("log2 frame size",     s->log2_frame_size);
 251     PRINT("max num subframes",   s->max_num_subframes);
 252     PRINT("len prefix",          s->len_prefix);
 253     PRINT("num channels",        s->avctx->channels);
 254 }
 255
 256 /**
 257  *@brief Uninitialize the decoder and free all resources.
 258  *@param avctx codec context
 259  *@return 0 on success, < 0 otherwise
 260  */
 261 static av_cold int decode_end(AVCodecContext *avctx)
 262 {
 263     WMAProDecodeCtx *s = avctx->priv_data;
 264     int i;
 265
 266     av_freep(&s->fdsp);
 267
 268     for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
 269         ff_mdct_end(&s->mdct_ctx[i]);
 270
 271     return 0;
 272 }
 273
 274 static av_cold int get_rate(AVCodecContext *avctx)
 275 {
 276     if (avctx->codec_id != AV_CODEC_ID_WMAPRO) { // XXX: is this really only for XMA?
 277         if (avctx->sample_rate > 44100)
 278             return 48000;
 279         else if (avctx->sample_rate > 32000)
 280             return 44100;
 281         else if (avctx->sample_rate > 24000)
 282             return 32000;
 283         return 24000;
 284     }
 285
 286     return avctx->sample_rate;
 287 }
 288
 289 /**
 290  *@brief Initialize the decoder.
 291  *@param avctx codec context
 292  *@return 0 on success, -1 otherwise
 293  */
 294 static av_cold int decode_init(AVCodecContext *avctx)
 295 {
 296     WMAProDecodeCtx *s = avctx->priv_data;
 297     uint8_t *edata_ptr = avctx->extradata;
 298     unsigned int channel_mask;
 299     int i, bits;
 300     int log2_max_num_subframes;
 301     int num_possible_block_sizes;
 302
 303     if (avctx->codec_id == AV_CODEC_ID_XMA1 || avctx->codec_id == AV_CODEC_ID_XMA2)
 304         avctx->block_align = 2048;
 305
 306     if (!avctx->block_align) {
 307         av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
 308         return AVERROR(EINVAL);
 309     }
 310
 311     s->avctx = avctx;
 312     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
 313     if (!s->fdsp)
 314         return AVERROR(ENOMEM);
 315
 316     init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
 317
 318     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
 319
 320     if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size >= 34) {
 321         s->decode_flags    = 0x10d6;
 322         channel_mask       = AV_RL32(edata_ptr+2);
 323         s->bits_per_sample = 16;
 324         /** dump the extradata */
 325         for (i = 0; i < avctx->extradata_size; i++)
 326             ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
 327         ff_dlog(avctx, "\n");
 328
 329      } else if (avctx->codec_id == AV_CODEC_ID_XMA1 && avctx->extradata_size >= 28) {
 330         s->decode_flags    = 0x10d6;
 331         s->bits_per_sample = 16;
 332         channel_mask       = 0;
 333         /** dump the extradata */
 334         for (i = 0; i < avctx->extradata_size; i++)
 335             ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
 336         ff_dlog(avctx, "\n");
 337
 338      } else if (avctx->extradata_size >= 18) {
 339         s->decode_flags    = AV_RL16(edata_ptr+14);
 340         channel_mask       = AV_RL32(edata_ptr+2);
 341         s->bits_per_sample = AV_RL16(edata_ptr);
 342
 343         if (s->bits_per_sample > 32 || s->bits_per_sample < 1) {
 344             avpriv_request_sample(avctx, "bits per sample is %d", s->bits_per_sample);
 345             return AVERROR_PATCHWELCOME;
 346         }
 347
 348         /** dump the extradata */
 349         for (i = 0; i < avctx->extradata_size; i++)
 350             ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
 351         ff_dlog(avctx, "\n");
 352
 353     } else {
 354         avpriv_request_sample(avctx, "Unknown extradata size");
 355         return AVERROR_PATCHWELCOME;
 356     }
 357
 358     if (avctx->codec_id != AV_CODEC_ID_WMAPRO && avctx->channels > 2) {
 359         avpriv_report_missing_feature(avctx, ">2 channels support");
 360         return AVERROR_PATCHWELCOME;
 361     }
 362
 363     /** generic init */
 364     s->log2_frame_size = av_log2(avctx->block_align) + 4;
 365     if (s->log2_frame_size > 25) {
 366         avpriv_request_sample(avctx, "Large block align");
 367         return AVERROR_PATCHWELCOME;
 368     }
 369
 370     /** frame info */
 371     if (avctx->codec_id != AV_CODEC_ID_WMAPRO)
 372         s->skip_frame = 0;
 373     else
 374         s->skip_frame = 1; /* skip first frame */
 375
 376     s->packet_loss = 1;
 377     s->len_prefix  = (s->decode_flags & 0x40);
 378
 379     /** get frame len */
 380     if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
 381         bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);
 382         if (bits > WMAPRO_BLOCK_MAX_BITS) {
 383             avpriv_request_sample(avctx, "14-bit block sizes");
 384             return AVERROR_PATCHWELCOME;
 385         }
 386         s->samples_per_frame = 1 << bits;
 387     } else {
 388         s->samples_per_frame = 512;
 389     }
 390
 391     /** subframe info */
 392     log2_max_num_subframes       = ((s->decode_flags & 0x38) >> 3);
 393     s->max_num_subframes         = 1 << log2_max_num_subframes;
 394     if (s->max_num_subframes == 16 || s->max_num_subframes == 4)
 395         s->max_subframe_len_bit = 1;
 396     s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
 397
 398     num_possible_block_sizes     = log2_max_num_subframes + 1;
 399     s->min_samples_per_subframe  = s->samples_per_frame / s->max_num_subframes;
 400     s->dynamic_range_compression = (s->decode_flags & 0x80);
 401
 402     if (s->max_num_subframes > MAX_SUBFRAMES) {
 403         av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRId8"\n",
 404                s->max_num_subframes);
 405         return AVERROR_INVALIDDATA;
 406     }
 407
 408     if (s->min_samples_per_subframe < WMAPRO_BLOCK_MIN_SIZE) {
 409         av_log(avctx, AV_LOG_ERROR, "min_samples_per_subframe of %d too small\n",
 410                s->min_samples_per_subframe);
 411         return AVERROR_INVALIDDATA;
 412     }
 413
 414     if (s->avctx->sample_rate <= 0) {
 415         av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
 416         return AVERROR_INVALIDDATA;
 417     }
 418
 419     if (avctx->channels < 0) {
 420         av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
 421                avctx->channels);
 422         return AVERROR_INVALIDDATA;
 423     } else if (avctx->channels > WMAPRO_MAX_CHANNELS) {
 424         avpriv_request_sample(avctx,
 425                               "More than %d channels", WMAPRO_MAX_CHANNELS);
 426         return AVERROR_PATCHWELCOME;
 427     }
 428
 429     /** init previous block len */
 430     for (i = 0; i < avctx->channels; i++)
 431         s->channel[i].prev_block_len = s->samples_per_frame;
 432
 433     /** extract lfe channel position */
 434     s->lfe_channel = -1;
 435
 436     if (channel_mask & 8) {
 437         unsigned int mask;
 438         for (mask = 1; mask < 16; mask <<= 1) {
 439             if (channel_mask & mask)
 440                 ++s->lfe_channel;
 441         }
 442     }
 443
 444     INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
 445                     scale_huffbits, 1, 1,
 446                     scale_huffcodes, 2, 2, 616);
 447
 448     INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
 449                     scale_rl_huffbits, 1, 1,
 450                     scale_rl_huffcodes, 4, 4, 1406);
 451
 452     INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
 453                     coef0_huffbits, 1, 1,
 454                     coef0_huffcodes, 4, 4, 2108);
 455
 456     INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
 457                     coef1_huffbits, 1, 1,
 458                     coef1_huffcodes, 4, 4, 3912);
 459
 460     INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
 461                     vec4_huffbits, 1, 1,
 462                     vec4_huffcodes, 2, 2, 604);
 463
 464     INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
 465                     vec2_huffbits, 1, 1,
 466                     vec2_huffcodes, 2, 2, 562);
 467
 468     INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
 469                     vec1_huffbits, 1, 1,
 470                     vec1_huffcodes, 2, 2, 562);
 471
 472     /** calculate number of scale factor bands and their offsets
 473         for every possible block size */
 474     for (i = 0; i < num_possible_block_sizes; i++) {
 475         int subframe_len = s->samples_per_frame >> i;
 476         int x;
 477         int band = 1;
 478         int rate = get_rate(avctx);
 479
 480         s->sfb_offsets[i][0] = 0;
 481
 482         for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
 483             int offset = (subframe_len * 2 * critical_freq[x]) / rate + 2;
 484             offset &= ~3;
 485             if (offset > s->sfb_offsets[i][band - 1])
 486                 s->sfb_offsets[i][band++] = offset;
 487
 488             if (offset >= subframe_len)
 489                 break;
 490         }
 491         s->sfb_offsets[i][band - 1] = subframe_len;
 492         s->num_sfb[i]               = band - 1;
 493         if (s->num_sfb[i] <= 0) {
 494             av_log(avctx, AV_LOG_ERROR, "num_sfb invalid\n");
 495             return AVERROR_INVALIDDATA;
 496         }
 497     }
 498
 499
 500     /** Scale factors can be shared between blocks of different size
 501         as every block has a different scale factor band layout.
 502         The matrix sf_offsets is needed to find the correct scale factor.
 503      */
 504
 505     for (i = 0; i < num_possible_block_sizes; i++) {
 506         int b;
 507         for (b = 0; b < s->num_sfb[i]; b++) {
 508             int x;
 509             int offset = ((s->sfb_offsets[i][b]
 510                            + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
 511             for (x = 0; x < num_possible_block_sizes; x++) {
 512                 int v = 0;
 513                 while (s->sfb_offsets[x][v + 1] << x < offset) {
 514                     v++;
 515                     av_assert0(v < MAX_BANDS);
 516                 }
 517                 s->sf_offsets[i][x][b] = v;
 518             }
 519         }
 520     }
 521
 522     /** init MDCT, FIXME: only init needed sizes */
 523     for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
 524         ff_mdct_init(&s->mdct_ctx[i], WMAPRO_BLOCK_MIN_BITS+1+i, 1,
 525                      1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i - 1))
 526                      / (1 << (s->bits_per_sample - 1)));
 527
 528     /** init MDCT windows: simple sine window */
 529     for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
 530         const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
 531         ff_init_ff_sine_windows(win_idx);
 532         s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
 533     }
 534
 535     /** calculate subwoofer cutoff values */
 536     for (i = 0; i < num_possible_block_sizes; i++) {
 537         int block_size = s->samples_per_frame >> i;
 538         int cutoff = (440*block_size + 3LL * (s->avctx->sample_rate >> 1) - 1)
 539                      / s->avctx->sample_rate;
 540         s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
 541     }
 542
 543     /** calculate sine values for the decorrelation matrix */
 544     for (i = 0; i < 33; i++)
 545         sin64[i] = sin(i*M_PI / 64.0);
 546
 547     if (avctx->debug & FF_DEBUG_BITSTREAM)
 548         dump_context(s);
 549
 550     avctx->channel_layout = channel_mask;
 551
 552     return 0;
 553 }
 554
 555 /**
 556  *@brief Decode the subframe length.
 557  *@param s context
 558  *@param offset sample offset in the frame
 559  *@return decoded subframe length on success, < 0 in case of an error
 560  */
 561 static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
 562 {
 563     int frame_len_shift = 0;
 564     int subframe_len;
 565
 566     /** no need to read from the bitstream when only one length is possible */
 567     if (offset == s->samples_per_frame - s->min_samples_per_subframe)
 568         return s->min_samples_per_subframe;
 569
 570     if (get_bits_left(&s->gb) < 1)
 571         return AVERROR_INVALIDDATA;
 572
 573     /** 1 bit indicates if the subframe is of maximum length */
 574     if (s->max_subframe_len_bit) {
 575         if (get_bits1(&s->gb))
 576             frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
 577     } else
 578         frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
 579
 580     subframe_len = s->samples_per_frame >> frame_len_shift;
 581
 582     /** sanity check the length */
 583     if (subframe_len < s->min_samples_per_subframe ||
 584         subframe_len > s->samples_per_frame) {
 585         av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
 586                subframe_len);
 587         return AVERROR_INVALIDDATA;
 588     }
 589     return subframe_len;
 590 }
 591
 592 /**
 593  *@brief Decode how the data in the frame is split into subframes.
 594  *       Every WMA frame contains the encoded data for a fixed number of
 595  *       samples per channel. The data for every channel might be split
 596  *       into several subframes. This function will reconstruct the list of
 597  *       subframes for every channel.
 598  *
 599  *       If the subframes are not evenly split, the algorithm estimates the
 600  *       channels with the lowest number of total samples.
 601  *       Afterwards, for each of these channels a bit is read from the
 602  *       bitstream that indicates if the channel contains a subframe with the
 603  *       next subframe size that is going to be read from the bitstream or not.
 604  *       If a channel contains such a subframe, the subframe size gets added to
 605  *       the channel's subframe list.
 606  *       The algorithm repeats these steps until the frame is properly divided
 607  *       between the individual channels.
 608  *
 609  *@param s context
 610  *@return 0 on success, < 0 in case of an error
 611  */
 612 static int decode_tilehdr(WMAProDecodeCtx *s)
 613 {
 614     uint16_t num_samples[WMAPRO_MAX_CHANNELS] = { 0 };/**< sum of samples for all currently known subframes of a channel */
 615     uint8_t  contains_subframe[WMAPRO_MAX_CHANNELS];  /**< flag indicating if a channel contains the current subframe */
 616     int channels_for_cur_subframe = s->avctx->channels; /**< number of channels that contain the current subframe */
 617     int fixed_channel_layout = 0;                     /**< flag indicating that all channels use the same subframe offsets and sizes */
 618     int min_channel_len = 0;                          /**< smallest sum of samples (channels with this length will be processed first) */
 619     int c;
 620
 621     /* Should never consume more than 3073 bits (256 iterations for the
 622      * while loop when always the minimum amount of 128 samples is subtracted
 623      * from missing samples in the 8 channel case).
 624      * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS  + 4)
 625      */
 626
 627     /** reset tiling information */
 628     for (c = 0; c < s->avctx->channels; c++)
 629         s->channel[c].num_subframes = 0;
 630
 631     if (s->max_num_subframes == 1 || get_bits1(&s->gb))
 632         fixed_channel_layout = 1;
 633
 634     /** loop until the frame data is split between the subframes */
 635     do {
 636         int subframe_len;
 637
 638         /** check which channels contain the subframe */
 639         for (c = 0; c < s->avctx->channels; c++) {
 640             if (num_samples[c] == min_channel_len) {
 641                 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
 642                    (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
 643                     contains_subframe[c] = 1;
 644                 else
 645                     contains_subframe[c] = get_bits1(&s->gb);
 646             } else
 647                 contains_subframe[c] = 0;
 648         }
 649
 650         /** get subframe length, subframe_len == 0 is not allowed */
 651         if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
 652             return AVERROR_INVALIDDATA;
 653
 654         /** add subframes to the individual channels and find new min_channel_len */
 655         min_channel_len += subframe_len;
 656         for (c = 0; c < s->avctx->channels; c++) {
 657             WMAProChannelCtx* chan = &s->channel[c];
 658
 659             if (contains_subframe[c]) {
 660                 if (chan->num_subframes >= MAX_SUBFRAMES) {
 661                     av_log(s->avctx, AV_LOG_ERROR,
 662                            "broken frame: num subframes > 31\n");
 663                     return AVERROR_INVALIDDATA;
 664                 }
 665                 chan->subframe_len[chan->num_subframes] = subframe_len;
 666                 num_samples[c] += subframe_len;
 667                 ++chan->num_subframes;
 668                 if (num_samples[c] > s->samples_per_frame) {
 669                     av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
 670                            "channel len > samples_per_frame\n");
 671                     return AVERROR_INVALIDDATA;
 672                 }
 673             } else if (num_samples[c] <= min_channel_len) {
 674                 if (num_samples[c] < min_channel_len) {
 675                     channels_for_cur_subframe = 0;
 676                     min_channel_len = num_samples[c];
 677                 }
 678                 ++channels_for_cur_subframe;
 679             }
 680         }
 681     } while (min_channel_len < s->samples_per_frame);
 682
 683     for (c = 0; c < s->avctx->channels; c++) {
 684         int i;
 685         int offset = 0;
 686         for (i = 0; i < s->channel[c].num_subframes; i++) {
 687             ff_dlog(s->avctx, "frame[%i] channel[%i] subframe[%i]"
 688                     " len %i\n", s->frame_num, c, i,
 689                     s->channel[c].subframe_len[i]);
 690             s->channel[c].subframe_offset[i] = offset;
 691             offset += s->channel[c].subframe_len[i];
 692         }
 693     }
 694
 695     return 0;
 696 }
 697
 698 /**
 699  *@brief Calculate a decorrelation matrix from the bitstream parameters.
 700  *@param s codec context
 701  *@param chgroup channel group for which the matrix needs to be calculated
 702  */
 703 static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
 704                                         WMAProChannelGrp *chgroup)
 705 {
 706     int i;
 707     int offset = 0;
 708     int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
 709     memset(chgroup->decorrelation_matrix, 0, s->avctx->channels *
 710            s->avctx->channels * sizeof(*chgroup->decorrelation_matrix));
 711
 712     for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
 713         rotation_offset[i] = get_bits(&s->gb, 6);
 714
 715     for (i = 0; i < chgroup->num_channels; i++)
 716         chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
 717             get_bits1(&s->gb) ? 1.0 : -1.0;
 718
 719     for (i = 1; i < chgroup->num_channels; i++) {
 720         int x;
 721         for (x = 0; x < i; x++) {
 722             int y;
 723             for (y = 0; y < i + 1; y++) {
 724                 float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
 725                 float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
 726                 int n = rotation_offset[offset + x];
 727                 float sinv;
 728                 float cosv;
 729
 730                 if (n < 32) {
 731                     sinv = sin64[n];
 732                     cosv = sin64[32 - n];
 733                 } else {
 734                     sinv =  sin64[64 -  n];
 735                     cosv = -sin64[n  - 32];
 736                 }
 737
 738                 chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
 739                                                (v1 * sinv) - (v2 * cosv);
 740                 chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
 741                                                (v1 * cosv) + (v2 * sinv);
 742             }
 743         }
 744         offset += i;
 745     }
 746 }
 747
 748 /**
 749  *@brief Decode channel transformation parameters
 750  *@param s codec context
 751  *@return >= 0 in case of success, < 0 in case of bitstream errors
 752  */
 753 static int decode_channel_transform(WMAProDecodeCtx* s)
 754 {
 755     int i;
 756     /* should never consume more than 1921 bits for the 8 channel case
 757      * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
 758      * + MAX_CHANNELS + MAX_BANDS + 1)
 759      */
 760
 761     /** in the one channel case channel transforms are pointless */
 762     s->num_chgroups = 0;
 763     if (s->avctx->channels > 1) {
 764         int remaining_channels = s->channels_for_cur_subframe;
 765
 766         if (get_bits1(&s->gb)) {
 767             avpriv_request_sample(s->avctx,
 768                                   "Channel transform bit");
 769             return AVERROR_PATCHWELCOME;
 770         }
 771
 772         for (s->num_chgroups = 0; remaining_channels &&
 773              s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
 774             WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
 775             float** channel_data = chgroup->channel_data;
 776             chgroup->num_channels = 0;
 777             chgroup->transform = 0;
 778
 779             /** decode channel mask */
 780             if (remaining_channels > 2) {
 781                 for (i = 0; i < s->channels_for_cur_subframe; i++) {
 782                     int channel_idx = s->channel_indexes_for_cur_subframe[i];
 783                     if (!s->channel[channel_idx].grouped
 784                         && get_bits1(&s->gb)) {
 785                         ++chgroup->num_channels;
 786                         s->channel[channel_idx].grouped = 1;
 787                         *channel_data++ = s->channel[channel_idx].coeffs;
 788                     }
 789                 }
 790             } else {
 791                 chgroup->num_channels = remaining_channels;
 792                 for (i = 0; i < s->channels_for_cur_subframe; i++) {
 793                     int channel_idx = s->channel_indexes_for_cur_subframe[i];
 794                     if (!s->channel[channel_idx].grouped)
 795                         *channel_data++ = s->channel[channel_idx].coeffs;
 796                     s->channel[channel_idx].grouped = 1;
 797                 }
 798             }
 799
 800             /** decode transform type */
 801             if (chgroup->num_channels == 2) {
 802                 if (get_bits1(&s->gb)) {
 803                     if (get_bits1(&s->gb)) {
 804                         avpriv_request_sample(s->avctx,
 805                                               "Unknown channel transform type");
 806                         return AVERROR_PATCHWELCOME;
 807                     }
 808                 } else {
 809                     chgroup->transform = 1;
 810                     if (s->avctx->channels == 2) {
 811                         chgroup->decorrelation_matrix[0] =  1.0;
 812                         chgroup->decorrelation_matrix[1] = -1.0;
 813                         chgroup->decorrelation_matrix[2] =  1.0;
 814                         chgroup->decorrelation_matrix[3] =  1.0;
 815                     } else {
 816                         /** cos(pi/4) */
 817                         chgroup->decorrelation_matrix[0] =  0.70703125;
 818                         chgroup->decorrelation_matrix[1] = -0.70703125;
 819                         chgroup->decorrelation_matrix[2] =  0.70703125;
 820                         chgroup->decorrelation_matrix[3] =  0.70703125;
 821                     }
 822                 }
 823             } else if (chgroup->num_channels > 2) {
 824                 if (get_bits1(&s->gb)) {
 825                     chgroup->transform = 1;
 826                     if (get_bits1(&s->gb)) {
 827                         decode_decorrelation_matrix(s, chgroup);
 828                     } else {
 829                         /** FIXME: more than 6 coupled channels not supported */
 830                         if (chgroup->num_channels > 6) {
 831                             avpriv_request_sample(s->avctx,
 832                                                   "Coupled channels > 6");
 833                         } else {
 834                             memcpy(chgroup->decorrelation_matrix,
 835                                    default_decorrelation[chgroup->num_channels],
 836                                    chgroup->num_channels * chgroup->num_channels *
 837                                    sizeof(*chgroup->decorrelation_matrix));
 838                         }
 839                     }
 840                 }
 841             }
 842
 843             /** decode transform on / off */
 844             if (chgroup->transform) {
 845                 if (!get_bits1(&s->gb)) {
 846                     int i;
 847                     /** transform can be enabled for individual bands */
 848                     for (i = 0; i < s->num_bands; i++) {
 849                         chgroup->transform_band[i] = get_bits1(&s->gb);
 850                     }
 851                 } else {
 852                     memset(chgroup->transform_band, 1, s->num_bands);
 853                 }
 854             }
 855             remaining_channels -= chgroup->num_channels;
 856         }
 857     }
 858     return 0;
 859 }
 860
 861 /**
 862  *@brief Extract the coefficients from the bitstream.
 863  *@param s codec context
 864  *@param c current channel number
 865  *@return 0 on success, < 0 in case of bitstream errors
 866  */
 867 static int decode_coeffs(WMAProDecodeCtx *s, int c)
 868 {
 869     /* Integers 0..15 as single-precision floats.  The table saves a
 870        costly int to float conversion, and storing the values as
 871        integers allows fast sign-flipping. */
 872     static const uint32_t fval_tab[16] = {
 873         0x00000000, 0x3f800000, 0x40000000, 0x40400000,
 874         0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
 875         0x41000000, 0x41100000, 0x41200000, 0x41300000,
 876         0x41400000, 0x41500000, 0x41600000, 0x41700000,
 877     };
 878     int vlctable;
 879     VLC* vlc;
 880     WMAProChannelCtx* ci = &s->channel[c];
 881     int rl_mode = 0;
 882     int cur_coeff = 0;
 883     int num_zeros = 0;
 884     const uint16_t* run;
 885     const float* level;
 886
 887     ff_dlog(s->avctx, "decode coefficients for channel %i\n", c);
 888
 889     vlctable = get_bits1(&s->gb);
 890     vlc = &coef_vlc[vlctable];
 891
 892     if (vlctable) {
 893         run = coef1_run;
 894         level = coef1_level;
 895     } else {
 896         run = coef0_run;
 897         level = coef0_level;
 898     }
 899
 900     /** decode vector coefficients (consumes up to 167 bits per iteration for
 901       4 vector coded large values) */
 902     while ((s->transmit_num_vec_coeffs || !rl_mode) &&
 903            (cur_coeff + 3 < ci->num_vec_coeffs)) {
 904         uint32_t vals[4];
 905         int i;
 906         unsigned int idx;
 907
 908         idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
 909
 910         if (idx == HUFF_VEC4_SIZE - 1) {
 911             for (i = 0; i < 4; i += 2) {
 912                 idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
 913                 if (idx == HUFF_VEC2_SIZE - 1) {
 914                     uint32_t v0, v1;
 915                     v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
 916                     if (v0 == HUFF_VEC1_SIZE - 1)
 917                         v0 += ff_wma_get_large_val(&s->gb);
 918                     v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
 919                     if (v1 == HUFF_VEC1_SIZE - 1)
 920                         v1 += ff_wma_get_large_val(&s->gb);
 921                     vals[i  ] = av_float2int(v0);
 922                     vals[i+1] = av_float2int(v1);
 923                 } else {
 924                     vals[i]   = fval_tab[symbol_to_vec2[idx] >> 4 ];
 925                     vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
 926                 }
 927             }
 928         } else {
 929             vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12      ];
 930             vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
 931             vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
 932             vals[3] = fval_tab[ symbol_to_vec4[idx]       & 0xF];
 933         }
 934
 935         /** decode sign */
 936         for (i = 0; i < 4; i++) {
 937             if (vals[i]) {
 938                 uint32_t sign = get_bits1(&s->gb) - 1;
 939                 AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
 940                 num_zeros = 0;
 941             } else {
 942                 ci->coeffs[cur_coeff] = 0;
 943                 /** switch to run level mode when subframe_len / 128 zeros
 944                     were found in a row */
 945                 rl_mode |= (++num_zeros > s->subframe_len >> 8);
 946             }
 947             ++cur_coeff;
 948         }
 949     }
 950
 951     /** decode run level coded coefficients */
 952     if (cur_coeff < s->subframe_len) {
 953         memset(&ci->coeffs[cur_coeff], 0,
 954                sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
 955         if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
 956                                     level, run, 1, ci->coeffs,
 957                                     cur_coeff, s->subframe_len,
 958                                     s->subframe_len, s->esc_len, 0))
 959             return AVERROR_INVALIDDATA;
 960     }
 961
 962     return 0;
 963 }
 964
 965 /**
 966  *@brief Extract scale factors from the bitstream.
 967  *@param s codec context
 968  *@return 0 on success, < 0 in case of bitstream errors
 969  */
 970 static int decode_scale_factors(WMAProDecodeCtx* s)
 971 {
 972     int i;
 973
 974     /** should never consume more than 5344 bits
 975      *  MAX_CHANNELS * (1 +  MAX_BANDS * 23)
 976      */
 977
 978     for (i = 0; i < s->channels_for_cur_subframe; i++) {
 979         int c = s->channel_indexes_for_cur_subframe[i];
 980         int* sf;
 981         int* sf_end;
 982         s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
 983         sf_end = s->channel[c].scale_factors + s->num_bands;
 984
 985         /** resample scale factors for the new block size
 986          *  as the scale factors might need to be resampled several times
 987          *  before some  new values are transmitted, a backup of the last
 988          *  transmitted scale factors is kept in saved_scale_factors
 989          */
 990         if (s->channel[c].reuse_sf) {
 991             const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
 992             int b;
 993             for (b = 0; b < s->num_bands; b++)
 994                 s->channel[c].scale_factors[b] =
 995                     s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
 996         }
 997
 998         if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
 999
1000             if (!s->channel[c].reuse_sf) {
1001                 int val;
1002                 /** decode DPCM coded scale factors */
1003                 s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
1004                 val = 45 / s->channel[c].scale_factor_step;
1005                 for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
1006                     val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
1007                     *sf = val;
1008                 }
1009             } else {
1010                 int i;
1011                 /** run level decode differences to the resampled factors */
1012                 for (i = 0; i < s->num_bands; i++) {
1013                     int idx;
1014                     int skip;
1015                     int val;
1016                     int sign;
1017
1018                     idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
1019
1020                     if (!idx) {
1021                         uint32_t code = get_bits(&s->gb, 14);
1022                         val  =  code >> 6;
1023                         sign = (code & 1) - 1;
1024                         skip = (code & 0x3f) >> 1;
1025                     } else if (idx == 1) {
1026                         break;
1027                     } else {
1028                         skip = scale_rl_run[idx];
1029                         val  = scale_rl_level[idx];
1030                         sign = get_bits1(&s->gb)-1;
1031                     }
1032
1033                     i += skip;
1034                     if (i >= s->num_bands) {
1035                         av_log(s->avctx, AV_LOG_ERROR,
1036                                "invalid scale factor coding\n");
1037                         return AVERROR_INVALIDDATA;
1038                     }
1039                     s->channel[c].scale_factors[i] += (val ^ sign) - sign;
1040                 }
1041             }
1042             /** swap buffers */
1043             s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
1044             s->channel[c].table_idx = s->table_idx;
1045             s->channel[c].reuse_sf  = 1;
1046         }
1047
1048         /** calculate new scale factor maximum */
1049         s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
1050         for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
1051             s->channel[c].max_scale_factor =
1052                 FFMAX(s->channel[c].max_scale_factor, *sf);
1053         }
1054
1055     }
1056     return 0;
1057 }
1058
1059 /**
1060  *@brief Reconstruct the individual channel data.
1061  *@param s codec context
1062  */
1063 static void inverse_channel_transform(WMAProDecodeCtx *s)
1064 {
1065     int i;
1066
1067     for (i = 0; i < s->num_chgroups; i++) {
1068         if (s->chgroup[i].transform) {
1069             float data[WMAPRO_MAX_CHANNELS];
1070             const int num_channels = s->chgroup[i].num_channels;
1071             float** ch_data = s->chgroup[i].channel_data;
1072             float** ch_end = ch_data + num_channels;
1073             const int8_t* tb = s->chgroup[i].transform_band;
1074             int16_t* sfb;
1075
1076             /** multichannel decorrelation */
1077             for (sfb = s->cur_sfb_offsets;
1078                  sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
1079                 int y;
1080                 if (*tb++ == 1) {
1081                     /** multiply values with the decorrelation_matrix */
1082                     for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
1083                         const float* mat = s->chgroup[i].decorrelation_matrix;
1084                         const float* data_end = data + num_channels;
1085                         float* data_ptr = data;
1086                         float** ch;
1087
1088                         for (ch = ch_data; ch < ch_end; ch++)
1089                             *data_ptr++ = (*ch)[y];
1090
1091                         for (ch = ch_data; ch < ch_end; ch++) {
1092                             float sum = 0;
1093                             data_ptr = data;
1094                             while (data_ptr < data_end)
1095                                 sum += *data_ptr++ * *mat++;
1096
1097                             (*ch)[y] = sum;
1098                         }
1099                     }
1100                 } else if (s->avctx->channels == 2) {
1101                     int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
1102                     s->fdsp->vector_fmul_scalar(ch_data[0] + sfb[0],
1103                                                ch_data[0] + sfb[0],
1104                                                181.0 / 128, len);
1105                     s->fdsp->vector_fmul_scalar(ch_data[1] + sfb[0],
1106                                                ch_data[1] + sfb[0],
1107                                                181.0 / 128, len);
1108                 }
1109             }
1110         }
1111     }
1112 }
1113
1114 /**
1115  *@brief Apply sine window and reconstruct the output buffer.
1116  *@param s codec context
1117  */
1118 static void wmapro_window(WMAProDecodeCtx *s)
1119 {
1120     int i;
1121     for (i = 0; i < s->channels_for_cur_subframe; i++) {
1122         int c = s->channel_indexes_for_cur_subframe[i];
1123         const float* window;
1124         int winlen = s->channel[c].prev_block_len;
1125         float* start = s->channel[c].coeffs - (winlen >> 1);
1126
1127         if (s->subframe_len < winlen) {
1128             start += (winlen - s->subframe_len) >> 1;
1129             winlen = s->subframe_len;
1130         }
1131
1132         window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1133
1134         winlen >>= 1;
1135
1136         s->fdsp->vector_fmul_window(start, start, start + winlen,
1137                                    window, winlen);
1138
1139         s->channel[c].prev_block_len = s->subframe_len;
1140     }
1141 }
1142
1143 /**
1144  *@brief Decode a single subframe (block).
1145  *@param s codec context
1146  *@return 0 on success, < 0 when decoding failed
1147  */
1148 static int decode_subframe(WMAProDecodeCtx *s)
1149 {
1150     int offset = s->samples_per_frame;
1151     int subframe_len = s->samples_per_frame;
1152     int i;
1153     int total_samples   = s->samples_per_frame * s->avctx->channels;
1154     int transmit_coeffs = 0;
1155     int cur_subwoofer_cutoff;
1156
1157     s->subframe_offset = get_bits_count(&s->gb);
1158
1159     /** reset channel context and find the next block offset and size
1160         == the next block of the channel with the smallest number of
1161         decoded samples
1162     */
1163     for (i = 0; i < s->avctx->channels; i++) {
1164         s->channel[i].grouped = 0;
1165         if (offset > s->channel[i].decoded_samples) {
1166             offset = s->channel[i].decoded_samples;
1167             subframe_len =
1168                 s->channel[i].subframe_len[s->channel[i].cur_subframe];
1169         }
1170     }
1171
1172     ff_dlog(s->avctx,
1173             "processing subframe with offset %i len %i\n", offset, subframe_len);
1174
1175     /** get a list of all channels that contain the estimated block */
1176     s->channels_for_cur_subframe = 0;
1177     for (i = 0; i < s->avctx->channels; i++) {
1178         const int cur_subframe = s->channel[i].cur_subframe;
1179         /** subtract already processed samples */
1180         total_samples -= s->channel[i].decoded_samples;
1181
1182         /** and count if there are multiple subframes that match our profile */
1183         if (offset == s->channel[i].decoded_samples &&
1184             subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1185             total_samples -= s->channel[i].subframe_len[cur_subframe];
1186             s->channel[i].decoded_samples +=
1187                 s->channel[i].subframe_len[cur_subframe];
1188             s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1189             ++s->channels_for_cur_subframe;
1190         }
1191     }
1192
1193     /** check if the frame will be complete after processing the
1194         estimated block */
1195     if (!total_samples)
1196         s->parsed_all_subframes = 1;
1197
1198
1199     ff_dlog(s->avctx, "subframe is part of %i channels\n",
1200             s->channels_for_cur_subframe);
1201
1202     /** calculate number of scale factor bands and their offsets */
1203     s->table_idx         = av_log2(s->samples_per_frame/subframe_len);
1204     s->num_bands         = s->num_sfb[s->table_idx];
1205     s->cur_sfb_offsets   = s->sfb_offsets[s->table_idx];
1206     cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1207
1208     /** configure the decoder for the current subframe */
1209     offset += s->samples_per_frame >> 1;
1210
1211     for (i = 0; i < s->channels_for_cur_subframe; i++) {
1212         int c = s->channel_indexes_for_cur_subframe[i];
1213
1214         s->channel[c].coeffs = &s->channel[c].out[offset];
1215     }
1216
1217     s->subframe_len = subframe_len;
1218     s->esc_len = av_log2(s->subframe_len - 1) + 1;
1219
1220     /** skip extended header if any */
1221     if (get_bits1(&s->gb)) {
1222         int num_fill_bits;
1223         if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1224             int len = get_bits(&s->gb, 4);
1225             num_fill_bits = get_bitsz(&s->gb, len) + 1;
1226         }
1227
1228         if (num_fill_bits >= 0) {
1229             if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1230                 av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1231                 return AVERROR_INVALIDDATA;
1232             }
1233
1234             skip_bits_long(&s->gb, num_fill_bits);
1235         }
1236     }
1237
1238     /** no idea for what the following bit is used */
1239     if (get_bits1(&s->gb)) {
1240         avpriv_request_sample(s->avctx, "Reserved bit");
1241         return AVERROR_PATCHWELCOME;
1242     }
1243
1244
1245     if (decode_channel_transform(s) < 0)
1246         return AVERROR_INVALIDDATA;
1247
1248
1249     for (i = 0; i < s->channels_for_cur_subframe; i++) {
1250         int c = s->channel_indexes_for_cur_subframe[i];
1251         if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1252             transmit_coeffs = 1;
1253     }
1254
1255     av_assert0(s->subframe_len <= WMAPRO_BLOCK_MAX_SIZE);
1256     if (transmit_coeffs) {
1257         int step;
1258         int quant_step = 90 * s->bits_per_sample >> 4;
1259
1260         /** decode number of vector coded coefficients */
1261         if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
1262             int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
1263             for (i = 0; i < s->channels_for_cur_subframe; i++) {
1264                 int c = s->channel_indexes_for_cur_subframe[i];
1265                 int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1266                 if (num_vec_coeffs > s->subframe_len) {
1267                     av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs);
1268                     return AVERROR_INVALIDDATA;
1269                 }
1270                 av_assert0(num_vec_coeffs + offset <= FF_ARRAY_ELEMS(s->channel[c].out));
1271                 s->channel[c].num_vec_coeffs = num_vec_coeffs;
1272             }
1273         } else {
1274             for (i = 0; i < s->channels_for_cur_subframe; i++) {
1275                 int c = s->channel_indexes_for_cur_subframe[i];
1276                 s->channel[c].num_vec_coeffs = s->subframe_len;
1277             }
1278         }
1279         /** decode quantization step */
1280         step = get_sbits(&s->gb, 6);
1281         quant_step += step;
1282         if (step == -32 || step == 31) {
1283             const int sign = (step == 31) - 1;
1284             int quant = 0;
1285             while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1286                    (step = get_bits(&s->gb, 5)) == 31) {
1287                 quant += 31;
1288             }
1289             quant_step += ((quant + step) ^ sign) - sign;
1290         }
1291         if (quant_step < 0) {
1292             av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1293         }
1294
1295         /** decode quantization step modifiers for every channel */
1296
1297         if (s->channels_for_cur_subframe == 1) {
1298             s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1299         } else {
1300             int modifier_len = get_bits(&s->gb, 3);
1301             for (i = 0; i < s->channels_for_cur_subframe; i++) {
1302                 int c = s->channel_indexes_for_cur_subframe[i];
1303                 s->channel[c].quant_step = quant_step;
1304                 if (get_bits1(&s->gb)) {
1305                     if (modifier_len) {
1306                         s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1307                     } else
1308                         ++s->channel[c].quant_step;
1309                 }
1310             }
1311         }
1312
1313         /** decode scale factors */
1314         if (decode_scale_factors(s) < 0)
1315             return AVERROR_INVALIDDATA;
1316     }
1317
1318     ff_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1319             get_bits_count(&s->gb) - s->subframe_offset);
1320
1321     /** parse coefficients */
1322     for (i = 0; i < s->channels_for_cur_subframe; i++) {
1323         int c = s->channel_indexes_for_cur_subframe[i];
1324         if (s->channel[c].transmit_coefs &&
1325             get_bits_count(&s->gb) < s->num_saved_bits) {
1326             decode_coeffs(s, c);
1327         } else
1328             memset(s->channel[c].coeffs, 0,
1329                    sizeof(*s->channel[c].coeffs) * subframe_len);
1330     }
1331
1332     ff_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1333             get_bits_count(&s->gb) - s->subframe_offset);
1334
1335     if (transmit_coeffs) {
1336         FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1337         /** reconstruct the per channel data */
1338         inverse_channel_transform(s);
1339         for (i = 0; i < s->channels_for_cur_subframe; i++) {
1340             int c = s->channel_indexes_for_cur_subframe[i];
1341             const int* sf = s->channel[c].scale_factors;
1342             int b;
1343
1344             if (c == s->lfe_channel)
1345                 memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1346                        (subframe_len - cur_subwoofer_cutoff));
1347
1348             /** inverse quantization and rescaling */
1349             for (b = 0; b < s->num_bands; b++) {
1350                 const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1351                 const int exp = s->channel[c].quant_step -
1352                             (s->channel[c].max_scale_factor - *sf++) *
1353                             s->channel[c].scale_factor_step;
1354                 const float quant = ff_exp10(exp / 20.0);
1355                 int start = s->cur_sfb_offsets[b];
1356                 s->fdsp->vector_fmul_scalar(s->tmp + start,
1357                                            s->channel[c].coeffs + start,
1358                                            quant, end - start);
1359             }
1360
1361             /** apply imdct (imdct_half == DCTIV with reverse) */
1362             mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1363         }
1364     }
1365
1366     /** window and overlapp-add */
1367     wmapro_window(s);
1368
1369     /** handled one subframe */
1370     for (i = 0; i < s->channels_for_cur_subframe; i++) {
1371         int c = s->channel_indexes_for_cur_subframe[i];
1372         if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1373             av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1374             return AVERROR_INVALIDDATA;
1375         }
1376         ++s->channel[c].cur_subframe;
1377     }
1378
1379     return 0;
1380 }
1381
1382 /**
1383  *@brief Decode one WMA frame.
1384  *@param s codec context
1385  *@return 0 if the trailer bit indicates that this is the last frame,
1386  *        1 if there are additional frames
1387  */
1388 static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
1389 {
1390     AVCodecContext *avctx = s->avctx;
1391     GetBitContext* gb = &s->gb;
1392     int more_frames = 0;
1393     int len = 0;
1394     int i, ret;
1395
1396     /** get frame length */
1397     if (s->len_prefix)
1398         len = get_bits(gb, s->log2_frame_size);
1399
1400     ff_dlog(s->avctx, "decoding frame with length %x\n", len);
1401
1402     /** decode tile information */
1403     if (decode_tilehdr(s)) {
1404         s->packet_loss = 1;
1405         return 0;
1406     }
1407
1408     /** read postproc transform */
1409     if (s->avctx->channels > 1 && get_bits1(gb)) {
1410         if (get_bits1(gb)) {
1411             for (i = 0; i < avctx->channels * avctx->channels; i++)
1412                 skip_bits(gb, 4);
1413         }
1414     }
1415
1416     /** read drc info */
1417     if (s->dynamic_range_compression) {
1418         s->drc_gain = get_bits(gb, 8);
1419         ff_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1420     }
1421
1422     /** no idea what these are for, might be the number of samples
1423         that need to be skipped at the beginning or end of a stream */
1424     if (get_bits1(gb)) {
1425         int av_unused skip;
1426
1427         /** usually true for the first frame */
1428         if (get_bits1(gb)) {
1429             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1430             ff_dlog(s->avctx, "start skip: %i\n", skip);
1431         }
1432
1433         /** sometimes true for the last frame */
1434         if (get_bits1(gb)) {
1435             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1436             ff_dlog(s->avctx, "end skip: %i\n", skip);
1437         }
1438
1439     }
1440
1441     ff_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1442             get_bits_count(gb) - s->frame_offset);
1443
1444     /** reset subframe states */
1445     s->parsed_all_subframes = 0;
1446     for (i = 0; i < avctx->channels; i++) {
1447         s->channel[i].decoded_samples = 0;
1448         s->channel[i].cur_subframe    = 0;
1449         s->channel[i].reuse_sf        = 0;
1450     }
1451
1452     /** decode all subframes */
1453     while (!s->parsed_all_subframes) {
1454         if (decode_subframe(s) < 0) {
1455             s->packet_loss = 1;
1456             return 0;
1457         }
1458     }
1459
1460     /* get output buffer */
1461     frame->nb_samples = s->samples_per_frame;
1462     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1463         s->packet_loss = 1;
1464         return 0;
1465     }
1466
1467     /** copy samples to the output buffer */
1468     for (i = 0; i < avctx->channels; i++)
1469         memcpy(frame->extended_data[i], s->channel[i].out,
1470                s->samples_per_frame * sizeof(*s->channel[i].out));
1471
1472     for (i = 0; i < avctx->channels; i++) {
1473         /** reuse second half of the IMDCT output for the next frame */
1474         memcpy(&s->channel[i].out[0],
1475                &s->channel[i].out[s->samples_per_frame],
1476                s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1477     }
1478
1479     if (s->skip_frame) {
1480         s->skip_frame = 0;
1481         *got_frame_ptr = 0;
1482         av_frame_unref(frame);
1483     } else {
1484         *got_frame_ptr = 1;
1485     }
1486
1487     if (s->len_prefix) {
1488         if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1489             /** FIXME: not sure if this is always an error */
1490             av_log(s->avctx, AV_LOG_ERROR,
1491                    "frame[%"PRIu32"] would have to skip %i bits\n",
1492                    s->frame_num,
1493                    len - (get_bits_count(gb) - s->frame_offset) - 1);
1494             s->packet_loss = 1;
1495             return 0;
1496         }
1497
1498         /** skip the rest of the frame data */
1499         skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1500     } else {
1501         while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1502         }
1503     }
1504
1505     /** decode trailer bit */
1506     more_frames = get_bits1(gb);
1507
1508     ++s->frame_num;
1509     return more_frames;
1510 }
1511
1512 /**
1513  *@brief Calculate remaining input buffer length.
1514  *@param s codec context
1515  *@param gb bitstream reader context
1516  *@return remaining size in bits
1517  */
1518 static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1519 {
1520     return s->buf_bit_size - get_bits_count(gb);
1521 }
1522
1523 /**
1524  *@brief Fill the bit reservoir with a (partial) frame.
1525  *@param s codec context
1526  *@param gb bitstream reader context
1527  *@param len length of the partial frame
1528  *@param append decides whether to reset the buffer or not
1529  */
1530 static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1531                       int append)
1532 {
1533     int buflen;
1534
1535     /** when the frame data does not need to be concatenated, the input buffer
1536         is reset and additional bits from the previous frame are copied
1537         and skipped later so that a fast byte copy is possible */
1538
1539     if (!append) {
1540         s->frame_offset = get_bits_count(gb) & 7;
1541         s->num_saved_bits = s->frame_offset;
1542         init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1543     }
1544
1545     buflen = (put_bits_count(&s->pb) + len + 8) >> 3;
1546
1547     if (len <= 0 || buflen > MAX_FRAMESIZE) {
1548         avpriv_request_sample(s->avctx, "Too small input buffer");
1549         s->packet_loss = 1;
1550         return;
1551     }
1552
1553     av_assert0(len <= put_bits_left(&s->pb));
1554
1555     s->num_saved_bits += len;
1556     if (!append) {
1557         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1558                      s->num_saved_bits);
1559     } else {
1560         int align = 8 - (get_bits_count(gb) & 7);
1561         align = FFMIN(align, len);
1562         put_bits(&s->pb, align, get_bits(gb, align));
1563         len -= align;
1564         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1565     }
1566     skip_bits_long(gb, len);
1567
1568     {
1569         PutBitContext tmp = s->pb;
1570         flush_put_bits(&tmp);
1571     }
1572
1573     init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1574     skip_bits(&s->gb, s->frame_offset);
1575 }
1576
1577 /**
1578  *@brief Decode a single WMA packet.
1579  *@param avctx codec context
1580  *@param data the output buffer
1581  *@param avpkt input packet
1582  *@return number of bytes that were read from the input buffer
1583  */
1584 static int decode_packet(AVCodecContext *avctx, void *data,
1585                          int *got_frame_ptr, AVPacket* avpkt)
1586 {
1587     WMAProDecodeCtx *s = avctx->priv_data;
1588     GetBitContext* gb  = &s->pgb;
1589     const uint8_t* buf = avpkt->data;
1590     int buf_size       = avpkt->size;
1591     int num_bits_prev_frame;
1592     int packet_sequence_number;
1593
1594     *got_frame_ptr = 0;
1595
1596     if (s->skip_packets > 0) {
1597         s->skip_packets--;
1598         return FFMIN(avpkt->size, avctx->block_align);
1599     }
1600
1601     if (s->packet_done || s->packet_loss) {
1602         s->packet_done = 0;
1603
1604         /** sanity check for the buffer length */
1605         if (avctx->codec_id == AV_CODEC_ID_WMAPRO && buf_size < avctx->block_align) {
1606             av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
1607                    buf_size, avctx->block_align);
1608             return AVERROR_INVALIDDATA;
1609         }
1610
1611         if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
1612             s->next_packet_start = buf_size - avctx->block_align;
1613             buf_size = avctx->block_align;
1614         } else {
1615             s->next_packet_start = buf_size - FFMIN(buf_size, avctx->block_align);
1616             buf_size = FFMIN(buf_size, avctx->block_align);
1617         }
1618         s->buf_bit_size = buf_size << 3;
1619
1620         /** parse packet header */
1621         init_get_bits(gb, buf, s->buf_bit_size);
1622         if (avctx->codec_id != AV_CODEC_ID_XMA2) {
1623             packet_sequence_number = get_bits(gb, 4);
1624             skip_bits(gb, 2);
1625         } else {
1626             s->num_frames = get_bits(gb, 6);
1627             packet_sequence_number = 0;
1628         }
1629
1630         /** get number of bits that need to be added to the previous frame */
1631         num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1632         if (avctx->codec_id != AV_CODEC_ID_WMAPRO) {
1633             skip_bits(gb, 3);
1634             s->skip_packets = get_bits(gb, 8);
1635         }
1636
1637         ff_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1638                 num_bits_prev_frame);
1639
1640         /** check for packet loss */
1641         if (avctx->codec_id != AV_CODEC_ID_XMA2 && !s->packet_loss &&
1642             ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1643             s->packet_loss = 1;
1644             av_log(avctx, AV_LOG_ERROR,
1645                    "Packet loss detected! seq %"PRIx8" vs %x\n",
1646                    s->packet_sequence_number, packet_sequence_number);
1647         }
1648         s->packet_sequence_number = packet_sequence_number;
1649
1650         if (num_bits_prev_frame > 0) {
1651             int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1652             if (num_bits_prev_frame >= remaining_packet_bits) {
1653                 num_bits_prev_frame = remaining_packet_bits;
1654                 s->packet_done = 1;
1655             }
1656
1657             /** append the previous frame data to the remaining data from the
1658                 previous packet to create a full frame */
1659             save_bits(s, gb, num_bits_prev_frame, 1);
1660             ff_dlog(avctx, "accumulated %x bits of frame data\n",
1661                     s->num_saved_bits - s->frame_offset);
1662
1663             /** decode the cross packet frame if it is valid */
1664             if (!s->packet_loss)
1665                 decode_frame(s, data, got_frame_ptr);
1666         } else if (s->num_saved_bits - s->frame_offset) {
1667             ff_dlog(avctx, "ignoring %x previously saved bits\n",
1668                     s->num_saved_bits - s->frame_offset);
1669         }
1670
1671         if (s->packet_loss) {
1672             /** reset number of saved bits so that the decoder
1673                 does not start to decode incomplete frames in the
1674                 s->len_prefix == 0 case */
1675             s->num_saved_bits = 0;
1676             s->packet_loss = 0;
1677         }
1678
1679     } else {
1680         int frame_size;
1681         s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1682         init_get_bits(gb, avpkt->data, s->buf_bit_size);
1683         skip_bits(gb, s->packet_offset);
1684         if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1685             (frame_size = show_bits(gb, s->log2_frame_size)) &&
1686             frame_size <= remaining_bits(s, gb)) {
1687             save_bits(s, gb, frame_size, 0);
1688             if (!s->packet_loss)
1689                 s->packet_done = !decode_frame(s, data, got_frame_ptr);
1690         } else if (!s->len_prefix
1691                    && s->num_saved_bits > get_bits_count(&s->gb)) {
1692             /** when the frames do not have a length prefix, we don't know
1693                 the compressed length of the individual frames
1694                 however, we know what part of a new packet belongs to the
1695                 previous frame
1696                 therefore we save the incoming packet first, then we append
1697                 the "previous frame" data from the next packet so that
1698                 we get a buffer that only contains full frames */
1699             s->packet_done = !decode_frame(s, data, got_frame_ptr);
1700         } else
1701             s->packet_done = 1;
1702     }
1703
1704     if (remaining_bits(s, gb) < 0) {
1705         av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1706         s->packet_loss = 1;
1707     }
1708
1709     if (s->packet_done && !s->packet_loss &&
1710         remaining_bits(s, gb) > 0) {
1711         /** save the rest of the data so that it can be decoded
1712             with the next packet */
1713         save_bits(s, gb, remaining_bits(s, gb), 0);
1714     }
1715
1716     s->packet_offset = get_bits_count(gb) & 7;
1717     if (s->packet_loss)
1718         return AVERROR_INVALIDDATA;
1719
1720     return get_bits_count(gb) >> 3;
1721 }
1722
1723 /**
1724  *@brief Clear decoder buffers (for seeking).
1725  *@param avctx codec context
1726  */
1727 static void flush(AVCodecContext *avctx)
1728 {
1729     WMAProDecodeCtx *s = avctx->priv_data;
1730     int i;
1731     /** reset output buffer as a part of it is used during the windowing of a
1732         new frame */
1733     for (i = 0; i < avctx->channels; i++)
1734         memset(s->channel[i].out, 0, s->samples_per_frame *
1735                sizeof(*s->channel[i].out));
1736     s->packet_loss = 1;
1737 }
1738
1739
1740 /**
1741  *@brief wmapro decoder
1742  */
1743 AVCodec ff_wmapro_decoder = {
1744     .name           = "wmapro",
1745     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1746     .type           = AVMEDIA_TYPE_AUDIO,
1747     .id             = AV_CODEC_ID_WMAPRO,
1748     .priv_data_size = sizeof(WMAProDecodeCtx),
1749     .init           = decode_init,
1750     .close          = decode_end,
1751     .decode         = decode_packet,
1752     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1753     .flush          = flush,
1754     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1755                                                       AV_SAMPLE_FMT_NONE },
1756 };
1757
1758 AVCodec ff_xma1_decoder = {
1759     .name           = "xma1",
1760     .long_name      = NULL_IF_CONFIG_SMALL("Xbox Media Audio 1"),
1761     .type           = AVMEDIA_TYPE_AUDIO,
1762     .id             = AV_CODEC_ID_XMA1,
1763     .priv_data_size = sizeof(WMAProDecodeCtx),
1764     .init           = decode_init,
1765     .close          = decode_end,
1766     .decode         = decode_packet,
1767     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1768     .flush          = flush,
1769     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1770                                                       AV_SAMPLE_FMT_NONE },
1771 };
1772
1773 AVCodec ff_xma2_decoder = {
1774     .name           = "xma2",
1775     .long_name      = NULL_IF_CONFIG_SMALL("Xbox Media Audio 2"),
1776     .type           = AVMEDIA_TYPE_AUDIO,
1777     .id             = AV_CODEC_ID_XMA2,
1778     .priv_data_size = sizeof(WMAProDecodeCtx),
1779     .init           = decode_init,
1780     .close          = decode_end,
1781     .decode         = decode_packet,
1782     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1783     .flush          = flush,
1784     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1785                                                       AV_SAMPLE_FMT_NONE },
1786 };