libavcodec/wmaprodec.c

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