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