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