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