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

   1 /*
   2  * Windows Media Audio Lossless decoder
   3  * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
   4  * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
   5  * Copyright (c) 2011 Andreas Öman
   6  * Copyright (c) 2011 - 2012 Mashiat Sarker Shakkhar
   7  *
   8  * This file is part of FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 #include <inttypes.h>
  26
  27 #include "libavutil/attributes.h"
  28 #include "libavutil/avassert.h"
  29
  30 #include "avcodec.h"
  31 #include "internal.h"
  32 #include "get_bits.h"
  33 #include "put_bits.h"
  34 #include "lossless_audiodsp.h"
  35 #include "wma.h"
  36 #include "wma_common.h"
  37
  38 /** current decoder limitations */
  39 #define WMALL_MAX_CHANNELS      8                       ///< max number of handled channels
  40 #define MAX_SUBFRAMES          32                       ///< max number of subframes per channel
  41 #define MAX_BANDS              29                       ///< max number of scale factor bands
  42 #define MAX_FRAMESIZE       32768                       ///< maximum compressed frame size
  43 #define MAX_ORDER             256
  44
  45 #define WMALL_BLOCK_MIN_BITS    6                       ///< log2 of min block size
  46 #define WMALL_BLOCK_MAX_BITS   14                       ///< log2 of max block size
  47 #define WMALL_BLOCK_MAX_SIZE (1 << WMALL_BLOCK_MAX_BITS)    ///< maximum block size
  48 #define WMALL_BLOCK_SIZES    (WMALL_BLOCK_MAX_BITS - WMALL_BLOCK_MIN_BITS + 1) ///< possible block sizes
  49
  50 #define WMALL_COEFF_PAD_SIZE   16                       ///< pad coef buffers with 0 for use with SIMD
  51
  52 /**
  53  * @brief frame-specific decoder context for a single channel
  54  */
  55 typedef struct WmallChannelCtx {
  56     int16_t     prev_block_len;                         ///< length of the previous block
  57     uint8_t     transmit_coefs;
  58     uint8_t     num_subframes;
  59     uint16_t    subframe_len[MAX_SUBFRAMES];            ///< subframe length in samples
  60     uint16_t    subframe_offsets[MAX_SUBFRAMES];        ///< subframe positions in the current frame
  61     uint8_t     cur_subframe;                           ///< current subframe number
  62     uint16_t    decoded_samples;                        ///< number of already processed samples
  63     int         quant_step;                             ///< quantization step for the current subframe
  64     int         transient_counter;                      ///< number of transient samples from the beginning of the transient zone
  65 } WmallChannelCtx;
  66
  67 /**
  68  * @brief main decoder context
  69  */
  70 typedef struct WmallDecodeCtx {
  71     /* generic decoder variables */
  72     AVCodecContext  *avctx;
  73     AVFrame         *frame;
  74     LLAudDSPContext dsp;                           ///< accelerated DSP functions
  75     uint8_t         frame_data[MAX_FRAMESIZE + FF_INPUT_BUFFER_PADDING_SIZE];  ///< compressed frame data
  76     PutBitContext   pb;                             ///< context for filling the frame_data buffer
  77
  78     /* frame size dependent frame information (set during initialization) */
  79     uint32_t        decode_flags;                   ///< used compression features
  80     int             len_prefix;                     ///< frame is prefixed with its length
  81     int             dynamic_range_compression;      ///< frame contains DRC data
  82     uint8_t         bits_per_sample;                ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
  83     uint16_t        samples_per_frame;              ///< number of samples to output
  84     uint16_t        log2_frame_size;
  85     int8_t          num_channels;                   ///< number of channels in the stream (same as AVCodecContext.num_channels)
  86     int8_t          lfe_channel;                    ///< lfe channel index
  87     uint8_t         max_num_subframes;
  88     uint8_t         subframe_len_bits;              ///< number of bits used for the subframe length
  89     uint8_t         max_subframe_len_bit;           ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
  90     uint16_t        min_samples_per_subframe;
  91
  92     /* packet decode state */
  93     GetBitContext   pgb;                            ///< bitstream reader context for the packet
  94     int             next_packet_start;              ///< start offset of the next WMA packet in the demuxer packet
  95     uint8_t         packet_offset;                  ///< offset to the frame in the packet
  96     uint8_t         packet_sequence_number;         ///< current packet number
  97     int             num_saved_bits;                 ///< saved number of bits
  98     int             frame_offset;                   ///< frame offset in the bit reservoir
  99     int             subframe_offset;                ///< subframe offset in the bit reservoir
 100     uint8_t         packet_loss;                    ///< set in case of bitstream error
 101     uint8_t         packet_done;                    ///< set when a packet is fully decoded
 102
 103     /* frame decode state */
 104     uint32_t        frame_num;                      ///< current frame number (not used for decoding)
 105     GetBitContext   gb;                             ///< bitstream reader context
 106     int             buf_bit_size;                   ///< buffer size in bits
 107     int16_t         *samples_16[WMALL_MAX_CHANNELS]; ///< current samplebuffer pointer (16-bit)
 108     int32_t         *samples_32[WMALL_MAX_CHANNELS]; ///< current samplebuffer pointer (24-bit)
 109     uint8_t         drc_gain;                       ///< gain for the DRC tool
 110     int8_t          skip_frame;                     ///< skip output step
 111     int8_t          parsed_all_subframes;           ///< all subframes decoded?
 112
 113     /* subframe/block decode state */
 114     int16_t         subframe_len;                   ///< current subframe length
 115     int8_t          channels_for_cur_subframe;      ///< number of channels that contain the subframe
 116     int8_t          channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
 117
 118     WmallChannelCtx channel[WMALL_MAX_CHANNELS];    ///< per channel data
 119
 120     // WMA Lossless-specific
 121
 122     uint8_t do_arith_coding;
 123     uint8_t do_ac_filter;
 124     uint8_t do_inter_ch_decorr;
 125     uint8_t do_mclms;
 126     uint8_t do_lpc;
 127
 128     int8_t  acfilter_order;
 129     int8_t  acfilter_scaling;
 130     int16_t acfilter_coeffs[16];
 131     int     acfilter_prevvalues[WMALL_MAX_CHANNELS][16];
 132
 133     int8_t  mclms_order;
 134     int8_t  mclms_scaling;
 135     int16_t mclms_coeffs[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS * 32];
 136     int16_t mclms_coeffs_cur[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS];
 137     int16_t mclms_prevvalues[WMALL_MAX_CHANNELS * 2 * 32];
 138     int16_t mclms_updates[WMALL_MAX_CHANNELS * 2 * 32];
 139     int     mclms_recent;
 140
 141     int     movave_scaling;
 142     int     quant_stepsize;
 143
 144     struct {
 145         int order;
 146         int scaling;
 147         int coefsend;
 148         int bitsend;
 149         DECLARE_ALIGNED(16, int16_t, coefs)[MAX_ORDER + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
 150         DECLARE_ALIGNED(16, int16_t, lms_prevvalues)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
 151         DECLARE_ALIGNED(16, int16_t, lms_updates)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
 152         int recent;
 153     } cdlms[WMALL_MAX_CHANNELS][9];
 154
 155     int cdlms_ttl[WMALL_MAX_CHANNELS];
 156
 157     int bV3RTM;
 158
 159     int is_channel_coded[WMALL_MAX_CHANNELS];
 160     int update_speed[WMALL_MAX_CHANNELS];
 161
 162     int transient[WMALL_MAX_CHANNELS];
 163     int transient_pos[WMALL_MAX_CHANNELS];
 164     int seekable_tile;
 165
 166     int ave_sum[WMALL_MAX_CHANNELS];
 167
 168     int channel_residues[WMALL_MAX_CHANNELS][WMALL_BLOCK_MAX_SIZE];
 169
 170     int lpc_coefs[WMALL_MAX_CHANNELS][40];
 171     int lpc_order;
 172     int lpc_scaling;
 173     int lpc_intbits;
 174
 175     int channel_coeffs[WMALL_MAX_CHANNELS][WMALL_BLOCK_MAX_SIZE];
 176 } WmallDecodeCtx;
 177
 178 /** Get sign of integer (1 for positive, -1 for negative and 0 for zero) */
 179 #define WMASIGN(x) (((x) > 0) - ((x) < 0))
 180
 181 static av_cold int decode_init(AVCodecContext *avctx)
 182 {
 183     WmallDecodeCtx *s  = avctx->priv_data;
 184     uint8_t *edata_ptr = avctx->extradata;
 185     unsigned int channel_mask;
 186     int i, log2_max_num_subframes;
 187
 188     if (!avctx->block_align) {
 189         av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
 190         return AVERROR(EINVAL);
 191     }
 192
 193     s->avctx = avctx;
 194     ff_llauddsp_init(&s->dsp);
 195     init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
 196
 197     if (avctx->extradata_size >= 18) {
 198         s->decode_flags    = AV_RL16(edata_ptr + 14);
 199         channel_mask       = AV_RL32(edata_ptr +  2);
 200         s->bits_per_sample = AV_RL16(edata_ptr);
 201         if (s->bits_per_sample == 16)
 202             avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
 203         else if (s->bits_per_sample == 24) {
 204             avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
 205             avctx->bits_per_raw_sample = 24;
 206         } else {
 207             av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %"PRIu8"\n",
 208                    s->bits_per_sample);
 209             return AVERROR_INVALIDDATA;
 210         }
 211         /* dump the extradata */
 212         for (i = 0; i < avctx->extradata_size; i++)
 213             ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
 214         ff_dlog(avctx, "\n");
 215
 216     } else {
 217         avpriv_request_sample(avctx, "Unsupported extradata size");
 218         return AVERROR_PATCHWELCOME;
 219     }
 220
 221     /* generic init */
 222     s->log2_frame_size = av_log2(avctx->block_align) + 4;
 223
 224     /* frame info */
 225     s->skip_frame  = 1; /* skip first frame */
 226     s->packet_loss = 1;
 227     s->len_prefix  = s->decode_flags & 0x40;
 228
 229     /* get frame len */
 230     s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
 231                                                           3, s->decode_flags);
 232     av_assert0(s->samples_per_frame <= WMALL_BLOCK_MAX_SIZE);
 233
 234     /* init previous block len */
 235     for (i = 0; i < avctx->channels; i++)
 236         s->channel[i].prev_block_len = s->samples_per_frame;
 237
 238     /* subframe info */
 239     log2_max_num_subframes  = (s->decode_flags & 0x38) >> 3;
 240     s->max_num_subframes    = 1 << log2_max_num_subframes;
 241     s->max_subframe_len_bit = 0;
 242     s->subframe_len_bits    = av_log2(log2_max_num_subframes) + 1;
 243
 244     s->min_samples_per_subframe  = s->samples_per_frame / s->max_num_subframes;
 245     s->dynamic_range_compression = s->decode_flags & 0x80;
 246     s->bV3RTM                    = s->decode_flags & 0x100;
 247
 248     if (s->max_num_subframes > MAX_SUBFRAMES) {
 249         av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRIu8"\n",
 250                s->max_num_subframes);
 251         return AVERROR_INVALIDDATA;
 252     }
 253
 254     s->num_channels = avctx->channels;
 255
 256     /* extract lfe channel position */
 257     s->lfe_channel = -1;
 258
 259     if (channel_mask & 8) {
 260         unsigned int mask;
 261         for (mask = 1; mask < 16; mask <<= 1)
 262             if (channel_mask & mask)
 263                 ++s->lfe_channel;
 264     }
 265
 266     if (s->num_channels < 0) {
 267         av_log(avctx, AV_LOG_ERROR, "invalid number of channels %"PRId8"\n",
 268                s->num_channels);
 269         return AVERROR_INVALIDDATA;
 270     } else if (s->num_channels > WMALL_MAX_CHANNELS) {
 271         avpriv_request_sample(avctx,
 272                               "More than %d channels", WMALL_MAX_CHANNELS);
 273         return AVERROR_PATCHWELCOME;
 274     }
 275
 276     s->frame = av_frame_alloc();
 277     if (!s->frame)
 278         return AVERROR(ENOMEM);
 279
 280     avctx->channel_layout = channel_mask;
 281     return 0;
 282 }
 283
 284 /**
 285  * @brief Decode the subframe length.
 286  * @param s      context
 287  * @param offset sample offset in the frame
 288  * @return decoded subframe length on success, < 0 in case of an error
 289  */
 290 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
 291 {
 292     int frame_len_ratio, subframe_len, len;
 293
 294     /* no need to read from the bitstream when only one length is possible */
 295     if (offset == s->samples_per_frame - s->min_samples_per_subframe)
 296         return s->min_samples_per_subframe;
 297
 298     len             = av_log2(s->max_num_subframes - 1) + 1;
 299     frame_len_ratio = get_bits(&s->gb, len);
 300     subframe_len    = s->min_samples_per_subframe * (frame_len_ratio + 1);
 301
 302     /* sanity check the length */
 303     if (subframe_len < s->min_samples_per_subframe ||
 304         subframe_len > s->samples_per_frame) {
 305         av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
 306                subframe_len);
 307         return AVERROR_INVALIDDATA;
 308     }
 309     return subframe_len;
 310 }
 311
 312 /**
 313  * @brief Decode how the data in the frame is split into subframes.
 314  *       Every WMA frame contains the encoded data for a fixed number of
 315  *       samples per channel. The data for every channel might be split
 316  *       into several subframes. This function will reconstruct the list of
 317  *       subframes for every channel.
 318  *
 319  *       If the subframes are not evenly split, the algorithm estimates the
 320  *       channels with the lowest number of total samples.
 321  *       Afterwards, for each of these channels a bit is read from the
 322  *       bitstream that indicates if the channel contains a subframe with the
 323  *       next subframe size that is going to be read from the bitstream or not.
 324  *       If a channel contains such a subframe, the subframe size gets added to
 325  *       the channel's subframe list.
 326  *       The algorithm repeats these steps until the frame is properly divided
 327  *       between the individual channels.
 328  *
 329  * @param s context
 330  * @return 0 on success, < 0 in case of an error
 331  */
 332 static int decode_tilehdr(WmallDecodeCtx *s)
 333 {
 334     uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
 335     uint8_t  contains_subframe[WMALL_MAX_CHANNELS];   /* flag indicating if a channel contains the current subframe */
 336     int channels_for_cur_subframe = s->num_channels;  /* number of channels that contain the current subframe */
 337     int fixed_channel_layout = 0;                     /* flag indicating that all channels use the same subfra2me offsets and sizes */
 338     int min_channel_len = 0;                          /* smallest sum of samples (channels with this length will be processed first) */
 339     int c, tile_aligned;
 340
 341     /* reset tiling information */
 342     for (c = 0; c < s->num_channels; c++)
 343         s->channel[c].num_subframes = 0;
 344
 345     tile_aligned = get_bits1(&s->gb);
 346     if (s->max_num_subframes == 1 || tile_aligned)
 347         fixed_channel_layout = 1;
 348
 349     /* loop until the frame data is split between the subframes */
 350     do {
 351         int subframe_len, in_use = 0;
 352
 353         /* check which channels contain the subframe */
 354         for (c = 0; c < s->num_channels; c++) {
 355             if (num_samples[c] == min_channel_len) {
 356                 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
 357                    (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
 358                     contains_subframe[c] = 1;
 359                 } else {
 360                     contains_subframe[c] = get_bits1(&s->gb);
 361                 }
 362                 in_use |= contains_subframe[c];
 363             } else
 364                 contains_subframe[c] = 0;
 365         }
 366
 367         if (!in_use) {
 368             av_log(s->avctx, AV_LOG_ERROR,
 369                    "Found empty subframe\n");
 370             return AVERROR_INVALIDDATA;
 371         }
 372
 373         /* get subframe length, subframe_len == 0 is not allowed */
 374         if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
 375             return AVERROR_INVALIDDATA;
 376         /* add subframes to the individual channels and find new min_channel_len */
 377         min_channel_len += subframe_len;
 378         for (c = 0; c < s->num_channels; c++) {
 379             WmallChannelCtx *chan = &s->channel[c];
 380
 381             if (contains_subframe[c]) {
 382                 if (chan->num_subframes >= MAX_SUBFRAMES) {
 383                     av_log(s->avctx, AV_LOG_ERROR,
 384                            "broken frame: num subframes > 31\n");
 385                     return AVERROR_INVALIDDATA;
 386                 }
 387                 chan->subframe_len[chan->num_subframes] = subframe_len;
 388                 num_samples[c] += subframe_len;
 389                 ++chan->num_subframes;
 390                 if (num_samples[c] > s->samples_per_frame) {
 391                     av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
 392                            "channel len(%"PRIu16") > samples_per_frame(%"PRIu16")\n",
 393                            num_samples[c], s->samples_per_frame);
 394                     return AVERROR_INVALIDDATA;
 395                 }
 396             } else if (num_samples[c] <= min_channel_len) {
 397                 if (num_samples[c] < min_channel_len) {
 398                     channels_for_cur_subframe = 0;
 399                     min_channel_len = num_samples[c];
 400                 }
 401                 ++channels_for_cur_subframe;
 402             }
 403         }
 404     } while (min_channel_len < s->samples_per_frame);
 405
 406     for (c = 0; c < s->num_channels; c++) {
 407         int i, offset = 0;
 408         for (i = 0; i < s->channel[c].num_subframes; i++) {
 409             s->channel[c].subframe_offsets[i] = offset;
 410             offset += s->channel[c].subframe_len[i];
 411         }
 412     }
 413
 414     return 0;
 415 }
 416
 417 static void decode_ac_filter(WmallDecodeCtx *s)
 418 {
 419     int i;
 420     s->acfilter_order   = get_bits(&s->gb, 4) + 1;
 421     s->acfilter_scaling = get_bits(&s->gb, 4);
 422
 423     for (i = 0; i < s->acfilter_order; i++)
 424         s->acfilter_coeffs[i] = (s->acfilter_scaling ?
 425                                  get_bits(&s->gb, s->acfilter_scaling) : 0) + 1;
 426 }
 427
 428 static void decode_mclms(WmallDecodeCtx *s)
 429 {
 430     s->mclms_order   = (get_bits(&s->gb, 4) + 1) * 2;
 431     s->mclms_scaling = get_bits(&s->gb, 4);
 432     if (get_bits1(&s->gb)) {
 433         int i, send_coef_bits;
 434         int cbits = av_log2(s->mclms_scaling + 1);
 435         if (1 << cbits < s->mclms_scaling + 1)
 436             cbits++;
 437
 438         send_coef_bits = (cbits ? get_bits(&s->gb, cbits) : 0) + 2;
 439
 440         for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
 441             s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
 442
 443         for (i = 0; i < s->num_channels; i++) {
 444             int c;
 445             for (c = 0; c < i; c++)
 446                 s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
 447         }
 448     }
 449 }
 450
 451 static int decode_cdlms(WmallDecodeCtx *s)
 452 {
 453     int c, i;
 454     int cdlms_send_coef = get_bits1(&s->gb);
 455
 456     for (c = 0; c < s->num_channels; c++) {
 457         s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
 458         for (i = 0; i < s->cdlms_ttl[c]; i++) {
 459             s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
 460             if (s->cdlms[c][i].order > MAX_ORDER) {
 461                 av_log(s->avctx, AV_LOG_ERROR,
 462                        "Order[%d][%d] %d > max (%d), not supported\n",
 463                        c, i, s->cdlms[c][i].order, MAX_ORDER);
 464                 s->cdlms[0][0].order = 0;
 465                 return AVERROR_INVALIDDATA;
 466             }
 467             if(s->cdlms[c][i].order & 8) {
 468                 static int warned;
 469                 if(!warned)
 470                     avpriv_request_sample(s->avctx, "CDLMS of order %d",
 471                                           s->cdlms[c][i].order);
 472                 warned = 1;
 473             }
 474         }
 475
 476         for (i = 0; i < s->cdlms_ttl[c]; i++)
 477             s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
 478
 479         if (cdlms_send_coef) {
 480             for (i = 0; i < s->cdlms_ttl[c]; i++) {
 481                 int cbits, shift_l, shift_r, j;
 482                 cbits = av_log2(s->cdlms[c][i].order);
 483                 if ((1 << cbits) < s->cdlms[c][i].order)
 484                     cbits++;
 485                 s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
 486
 487                 cbits = av_log2(s->cdlms[c][i].scaling + 1);
 488                 if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
 489                     cbits++;
 490
 491                 s->cdlms[c][i].bitsend = get_bits(&s->gb, cbits) + 2;
 492                 shift_l = 32 - s->cdlms[c][i].bitsend;
 493                 shift_r = 32 - s->cdlms[c][i].scaling - 2;
 494                 for (j = 0; j < s->cdlms[c][i].coefsend; j++)
 495                     s->cdlms[c][i].coefs[j] =
 496                         (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
 497             }
 498         }
 499
 500         for (i = 0; i < s->cdlms_ttl[c]; i++)
 501             memset(s->cdlms[c][i].coefs + s->cdlms[c][i].order,
 502                    0, WMALL_COEFF_PAD_SIZE);
 503     }
 504
 505     return 0;
 506 }
 507
 508 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
 509 {
 510     int i = 0;
 511     unsigned int ave_mean;
 512     s->transient[ch] = get_bits1(&s->gb);
 513     if (s->transient[ch]) {
 514         s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
 515         if (s->transient_pos[ch])
 516             s->transient[ch] = 0;
 517         s->channel[ch].transient_counter =
 518             FFMAX(s->channel[ch].transient_counter, s->samples_per_frame / 2);
 519     } else if (s->channel[ch].transient_counter)
 520         s->transient[ch] = 1;
 521
 522     if (s->seekable_tile) {
 523         ave_mean = get_bits(&s->gb, s->bits_per_sample);
 524         s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
 525     }
 526
 527     if (s->seekable_tile) {
 528         if (s->do_inter_ch_decorr)
 529             s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample + 1);
 530         else
 531             s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample);
 532         i++;
 533     }
 534     for (; i < tile_size; i++) {
 535         int quo = 0, rem, rem_bits, residue;
 536         while(get_bits1(&s->gb)) {
 537             quo++;
 538             if (get_bits_left(&s->gb) <= 0)
 539                 return -1;
 540         }
 541         if (quo >= 32)
 542             quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
 543
 544         ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
 545         if (ave_mean <= 1)
 546             residue = quo;
 547         else {
 548             rem_bits = av_ceil_log2(ave_mean);
 549             rem      = get_bits_long(&s->gb, rem_bits);
 550             residue  = (quo << rem_bits) + rem;
 551         }
 552
 553         s->ave_sum[ch] = residue + s->ave_sum[ch] -
 554                          (s->ave_sum[ch] >> s->movave_scaling);
 555
 556         residue = (residue >> 1) ^ -(residue & 1);
 557         s->channel_residues[ch][i] = residue;
 558     }
 559
 560     return 0;
 561
 562 }
 563
 564 static void decode_lpc(WmallDecodeCtx *s)
 565 {
 566     int ch, i, cbits;
 567     s->lpc_order   = get_bits(&s->gb, 5) + 1;
 568     s->lpc_scaling = get_bits(&s->gb, 4);
 569     s->lpc_intbits = get_bits(&s->gb, 3) + 1;
 570     cbits = s->lpc_scaling + s->lpc_intbits;
 571     for (ch = 0; ch < s->num_channels; ch++)
 572         for (i = 0; i < s->lpc_order; i++)
 573             s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
 574 }
 575
 576 static void clear_codec_buffers(WmallDecodeCtx *s)
 577 {
 578     int ich, ilms;
 579
 580     memset(s->acfilter_coeffs,     0, sizeof(s->acfilter_coeffs));
 581     memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
 582     memset(s->lpc_coefs,           0, sizeof(s->lpc_coefs));
 583
 584     memset(s->mclms_coeffs,     0, sizeof(s->mclms_coeffs));
 585     memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
 586     memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
 587     memset(s->mclms_updates,    0, sizeof(s->mclms_updates));
 588
 589     for (ich = 0; ich < s->num_channels; ich++) {
 590         for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
 591             memset(s->cdlms[ich][ilms].coefs, 0,
 592                    sizeof(s->cdlms[ich][ilms].coefs));
 593             memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
 594                    sizeof(s->cdlms[ich][ilms].lms_prevvalues));
 595             memset(s->cdlms[ich][ilms].lms_updates, 0,
 596                    sizeof(s->cdlms[ich][ilms].lms_updates));
 597         }
 598         s->ave_sum[ich] = 0;
 599     }
 600 }
 601
 602 /**
 603  * @brief Reset filter parameters and transient area at new seekable tile.
 604  */
 605 static void reset_codec(WmallDecodeCtx *s)
 606 {
 607     int ich, ilms;
 608     s->mclms_recent = s->mclms_order * s->num_channels;
 609     for (ich = 0; ich < s->num_channels; ich++) {
 610         for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
 611             s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
 612         /* first sample of a seekable subframe is considered as the starting of
 613             a transient area which is samples_per_frame samples long */
 614         s->channel[ich].transient_counter = s->samples_per_frame;
 615         s->transient[ich]     = 1;
 616         s->transient_pos[ich] = 0;
 617     }
 618 }
 619
 620 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
 621 {
 622     int i, j, ich, pred_error;
 623     int order        = s->mclms_order;
 624     int num_channels = s->num_channels;
 625     int range        = 1 << (s->bits_per_sample - 1);
 626
 627     for (ich = 0; ich < num_channels; ich++) {
 628         pred_error = s->channel_residues[ich][icoef] - pred[ich];
 629         if (pred_error > 0) {
 630             for (i = 0; i < order * num_channels; i++)
 631                 s->mclms_coeffs[i + ich * order * num_channels] +=
 632                     s->mclms_updates[s->mclms_recent + i];
 633             for (j = 0; j < ich; j++)
 634                 s->mclms_coeffs_cur[ich * num_channels + j] += WMASIGN(s->channel_residues[j][icoef]);
 635         } else if (pred_error < 0) {
 636             for (i = 0; i < order * num_channels; i++)
 637                 s->mclms_coeffs[i + ich * order * num_channels] -=
 638                     s->mclms_updates[s->mclms_recent + i];
 639             for (j = 0; j < ich; j++)
 640                 s->mclms_coeffs_cur[ich * num_channels + j] -= WMASIGN(s->channel_residues[j][icoef]);
 641         }
 642     }
 643
 644     for (ich = num_channels - 1; ich >= 0; ich--) {
 645         s->mclms_recent--;
 646         s->mclms_prevvalues[s->mclms_recent] = av_clip(s->channel_residues[ich][icoef],
 647             -range, range - 1);
 648         s->mclms_updates[s->mclms_recent] = WMASIGN(s->channel_residues[ich][icoef]);
 649     }
 650
 651     if (s->mclms_recent == 0) {
 652         memcpy(&s->mclms_prevvalues[order * num_channels],
 653                s->mclms_prevvalues,
 654                sizeof(int16_t) * order * num_channels);
 655         memcpy(&s->mclms_updates[order * num_channels],
 656                s->mclms_updates,
 657                sizeof(int16_t) * order * num_channels);
 658         s->mclms_recent = num_channels * order;
 659     }
 660 }
 661
 662 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
 663 {
 664     int ich, i;
 665     int order        = s->mclms_order;
 666     int num_channels = s->num_channels;
 667
 668     for (ich = 0; ich < num_channels; ich++) {
 669         pred[ich] = 0;
 670         if (!s->is_channel_coded[ich])
 671             continue;
 672         for (i = 0; i < order * num_channels; i++)
 673             pred[ich] += s->mclms_prevvalues[i + s->mclms_recent] *
 674                          s->mclms_coeffs[i + order * num_channels * ich];
 675         for (i = 0; i < ich; i++)
 676             pred[ich] += s->channel_residues[i][icoef] *
 677                          s->mclms_coeffs_cur[i + num_channels * ich];
 678         pred[ich] += 1 << s->mclms_scaling - 1;
 679         pred[ich] >>= s->mclms_scaling;
 680         s->channel_residues[ich][icoef] += pred[ich];
 681     }
 682 }
 683
 684 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
 685 {
 686     int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
 687     for (icoef = 0; icoef < tile_size; icoef++) {
 688         mclms_predict(s, icoef, pred);
 689         mclms_update(s, icoef, pred);
 690     }
 691 }
 692
 693 static void lms_update(WmallDecodeCtx *s, int ich, int ilms, int input)
 694 {
 695     int recent = s->cdlms[ich][ilms].recent;
 696     int range  = 1 << s->bits_per_sample - 1;
 697     int order  = s->cdlms[ich][ilms].order;
 698
 699     if (recent)
 700         recent--;
 701     else {
 702         memcpy(s->cdlms[ich][ilms].lms_prevvalues + order,
 703                s->cdlms[ich][ilms].lms_prevvalues, sizeof(*s->cdlms[ich][ilms].lms_prevvalues) * order);
 704         memcpy(s->cdlms[ich][ilms].lms_updates + order,
 705                s->cdlms[ich][ilms].lms_updates, sizeof(*s->cdlms[ich][ilms].lms_updates) * order);
 706         recent = order - 1;
 707     }
 708
 709     s->cdlms[ich][ilms].lms_prevvalues[recent] = av_clip(input, -range, range - 1);
 710     s->cdlms[ich][ilms].lms_updates[recent] = WMASIGN(input) * s->update_speed[ich];
 711
 712     s->cdlms[ich][ilms].lms_updates[recent + (order >> 4)] >>= 2;
 713     s->cdlms[ich][ilms].lms_updates[recent + (order >> 3)] >>= 1;
 714     s->cdlms[ich][ilms].recent = recent;
 715     memset(s->cdlms[ich][ilms].lms_updates + recent + order, 0,
 716            sizeof(s->cdlms[ich][ilms].lms_updates) - 2*(recent+order));
 717 }
 718
 719 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
 720 {
 721     int ilms, recent, icoef;
 722     for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
 723         recent = s->cdlms[ich][ilms].recent;
 724         if (s->update_speed[ich] == 16)
 725             continue;
 726         if (s->bV3RTM) {
 727             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
 728                 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
 729         } else {
 730             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
 731                 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
 732         }
 733     }
 734     s->update_speed[ich] = 16;
 735 }
 736
 737 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
 738 {
 739     int ilms, recent, icoef;
 740     for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
 741         recent = s->cdlms[ich][ilms].recent;
 742         if (s->update_speed[ich] == 8)
 743             continue;
 744         if (s->bV3RTM)
 745             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
 746                 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
 747         else
 748             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
 749                 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
 750     }
 751     s->update_speed[ich] = 8;
 752 }
 753
 754 static void revert_cdlms(WmallDecodeCtx *s, int ch,
 755                          int coef_begin, int coef_end)
 756 {
 757     int icoef, pred, ilms, num_lms, residue, input;
 758
 759     num_lms = s->cdlms_ttl[ch];
 760     for (ilms = num_lms - 1; ilms >= 0; ilms--) {
 761         for (icoef = coef_begin; icoef < coef_end; icoef++) {
 762             pred = 1 << (s->cdlms[ch][ilms].scaling - 1);
 763             residue = s->channel_residues[ch][icoef];
 764             pred += s->dsp.scalarproduct_and_madd_int16(s->cdlms[ch][ilms].coefs,
 765                                                         s->cdlms[ch][ilms].lms_prevvalues
 766                                                             + s->cdlms[ch][ilms].recent,
 767                                                         s->cdlms[ch][ilms].lms_updates
 768                                                             + s->cdlms[ch][ilms].recent,
 769                                                         FFALIGN(s->cdlms[ch][ilms].order,
 770                                                                 WMALL_COEFF_PAD_SIZE),
 771                                                         WMASIGN(residue));
 772             input = residue + (pred >> s->cdlms[ch][ilms].scaling);
 773             lms_update(s, ch, ilms, input);
 774             s->channel_residues[ch][icoef] = input;
 775         }
 776     }
 777     emms_c();
 778 }
 779
 780 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
 781 {
 782     if (s->num_channels != 2)
 783         return;
 784     else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
 785         int icoef;
 786         for (icoef = 0; icoef < tile_size; icoef++) {
 787             s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
 788             s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
 789         }
 790     }
 791 }
 792
 793 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
 794 {
 795     int ich, pred, i, j;
 796     int16_t *filter_coeffs = s->acfilter_coeffs;
 797     int scaling            = s->acfilter_scaling;
 798     int order              = s->acfilter_order;
 799
 800     for (ich = 0; ich < s->num_channels; ich++) {
 801         int *prevvalues = s->acfilter_prevvalues[ich];
 802         for (i = 0; i < order; i++) {
 803             pred = 0;
 804             for (j = 0; j < order; j++) {
 805                 if (i <= j)
 806                     pred += filter_coeffs[j] * prevvalues[j - i];
 807                 else
 808                     pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
 809             }
 810             pred >>= scaling;
 811             s->channel_residues[ich][i] += pred;
 812         }
 813         for (i = order; i < tile_size; i++) {
 814             pred = 0;
 815             for (j = 0; j < order; j++)
 816                 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
 817             pred >>= scaling;
 818             s->channel_residues[ich][i] += pred;
 819         }
 820         for (j = 0; j < order; j++)
 821             prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
 822     }
 823 }
 824
 825 static int decode_subframe(WmallDecodeCtx *s)
 826 {
 827     int offset        = s->samples_per_frame;
 828     int subframe_len  = s->samples_per_frame;
 829     int total_samples = s->samples_per_frame * s->num_channels;
 830     int i, j, rawpcm_tile, padding_zeroes, res;
 831
 832     s->subframe_offset = get_bits_count(&s->gb);
 833
 834     /* reset channel context and find the next block offset and size
 835         == the next block of the channel with the smallest number of
 836         decoded samples */
 837     for (i = 0; i < s->num_channels; i++) {
 838         if (offset > s->channel[i].decoded_samples) {
 839             offset = s->channel[i].decoded_samples;
 840             subframe_len =
 841                 s->channel[i].subframe_len[s->channel[i].cur_subframe];
 842         }
 843     }
 844
 845     /* get a list of all channels that contain the estimated block */
 846     s->channels_for_cur_subframe = 0;
 847     for (i = 0; i < s->num_channels; i++) {
 848         const int cur_subframe = s->channel[i].cur_subframe;
 849         /* subtract already processed samples */
 850         total_samples -= s->channel[i].decoded_samples;
 851
 852         /* and count if there are multiple subframes that match our profile */
 853         if (offset == s->channel[i].decoded_samples &&
 854             subframe_len == s->channel[i].subframe_len[cur_subframe]) {
 855             total_samples -= s->channel[i].subframe_len[cur_subframe];
 856             s->channel[i].decoded_samples +=
 857                 s->channel[i].subframe_len[cur_subframe];
 858             s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
 859             ++s->channels_for_cur_subframe;
 860         }
 861     }
 862
 863     /* check if the frame will be complete after processing the
 864         estimated block */
 865     if (!total_samples)
 866         s->parsed_all_subframes = 1;
 867
 868
 869     s->seekable_tile = get_bits1(&s->gb);
 870     if (s->seekable_tile) {
 871         clear_codec_buffers(s);
 872
 873         s->do_arith_coding    = get_bits1(&s->gb);
 874         if (s->do_arith_coding) {
 875             avpriv_request_sample(s->avctx, "Arithmetic coding");
 876             return AVERROR_PATCHWELCOME;
 877         }
 878         s->do_ac_filter       = get_bits1(&s->gb);
 879         s->do_inter_ch_decorr = get_bits1(&s->gb);
 880         s->do_mclms           = get_bits1(&s->gb);
 881
 882         if (s->do_ac_filter)
 883             decode_ac_filter(s);
 884
 885         if (s->do_mclms)
 886             decode_mclms(s);
 887
 888         if ((res = decode_cdlms(s)) < 0)
 889             return res;
 890         s->movave_scaling = get_bits(&s->gb, 3);
 891         s->quant_stepsize = get_bits(&s->gb, 8) + 1;
 892
 893         reset_codec(s);
 894     } else if (!s->cdlms[0][0].order) {
 895         av_log(s->avctx, AV_LOG_DEBUG,
 896                "Waiting for seekable tile\n");
 897         av_frame_unref(s->frame);
 898         return -1;
 899     }
 900
 901     rawpcm_tile = get_bits1(&s->gb);
 902
 903     for (i = 0; i < s->num_channels; i++)
 904         s->is_channel_coded[i] = 1;
 905
 906     if (!rawpcm_tile) {
 907         for (i = 0; i < s->num_channels; i++)
 908             s->is_channel_coded[i] = get_bits1(&s->gb);
 909
 910         if (s->bV3RTM) {
 911             // LPC
 912             s->do_lpc = get_bits1(&s->gb);
 913             if (s->do_lpc) {
 914                 decode_lpc(s);
 915                 avpriv_request_sample(s->avctx, "Expect wrong output since "
 916                                       "inverse LPC filter");
 917             }
 918         } else
 919             s->do_lpc = 0;
 920     }
 921
 922
 923     if (get_bits1(&s->gb))
 924         padding_zeroes = get_bits(&s->gb, 5);
 925     else
 926         padding_zeroes = 0;
 927
 928     if (rawpcm_tile) {
 929         int bits = s->bits_per_sample - padding_zeroes;
 930         if (bits <= 0) {
 931             av_log(s->avctx, AV_LOG_ERROR,
 932                    "Invalid number of padding bits in raw PCM tile\n");
 933             return AVERROR_INVALIDDATA;
 934         }
 935         ff_dlog(s->avctx, "RAWPCM %d bits per sample. "
 936                 "total %d bits, remain=%d\n", bits,
 937                 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
 938         for (i = 0; i < s->num_channels; i++)
 939             for (j = 0; j < subframe_len; j++)
 940                 s->channel_coeffs[i][j] = get_sbits_long(&s->gb, bits);
 941     } else {
 942         for (i = 0; i < s->num_channels; i++)
 943             if (s->is_channel_coded[i]) {
 944                 decode_channel_residues(s, i, subframe_len);
 945                 if (s->seekable_tile)
 946                     use_high_update_speed(s, i);
 947                 else
 948                     use_normal_update_speed(s, i);
 949                 revert_cdlms(s, i, 0, subframe_len);
 950             } else {
 951                 memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
 952             }
 953     }
 954     if (s->do_mclms)
 955         revert_mclms(s, subframe_len);
 956     if (s->do_inter_ch_decorr)
 957         revert_inter_ch_decorr(s, subframe_len);
 958     if (s->do_ac_filter)
 959         revert_acfilter(s, subframe_len);
 960
 961     /* Dequantize */
 962     if (s->quant_stepsize != 1)
 963         for (i = 0; i < s->num_channels; i++)
 964             for (j = 0; j < subframe_len; j++)
 965                 s->channel_residues[i][j] *= s->quant_stepsize;
 966
 967     /* Write to proper output buffer depending on bit-depth */
 968     for (i = 0; i < s->channels_for_cur_subframe; i++) {
 969         int c = s->channel_indexes_for_cur_subframe[i];
 970         int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
 971
 972         for (j = 0; j < subframe_len; j++) {
 973             if (s->bits_per_sample == 16) {
 974                 *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] << padding_zeroes;
 975             } else {
 976                 *s->samples_32[c]++ = s->channel_residues[c][j] << (padding_zeroes + 8);
 977             }
 978         }
 979     }
 980
 981     /* handled one subframe */
 982     for (i = 0; i < s->channels_for_cur_subframe; i++) {
 983         int c = s->channel_indexes_for_cur_subframe[i];
 984         if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
 985             av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
 986             return AVERROR_INVALIDDATA;
 987         }
 988         ++s->channel[c].cur_subframe;
 989     }
 990     return 0;
 991 }
 992
 993 /**
 994  * @brief Decode one WMA frame.
 995  * @param s codec context
 996  * @return 0 if the trailer bit indicates that this is the last frame,
 997  *         1 if there are additional frames
 998  */
 999 static int decode_frame(WmallDecodeCtx *s)
1000 {
1001     GetBitContext* gb = &s->gb;
1002     int more_frames = 0, len = 0, i, ret;
1003
1004     s->frame->nb_samples = s->samples_per_frame;
1005     if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1006         /* return an error if no frame could be decoded at all */
1007         s->packet_loss = 1;
1008         return ret;
1009     }
1010     for (i = 0; i < s->num_channels; i++) {
1011         s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1012         s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1013     }
1014
1015     /* get frame length */
1016     if (s->len_prefix)
1017         len = get_bits(gb, s->log2_frame_size);
1018
1019     /* decode tile information */
1020     if ((ret = decode_tilehdr(s))) {
1021         s->packet_loss = 1;
1022         av_frame_unref(s->frame);
1023         return ret;
1024     }
1025
1026     /* read drc info */
1027     if (s->dynamic_range_compression)
1028         s->drc_gain = get_bits(gb, 8);
1029
1030     /* no idea what these are for, might be the number of samples
1031        that need to be skipped at the beginning or end of a stream */
1032     if (get_bits1(gb)) {
1033         int av_unused skip;
1034
1035         /* usually true for the first frame */
1036         if (get_bits1(gb)) {
1037             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1038             ff_dlog(s->avctx, "start skip: %i\n", skip);
1039         }
1040
1041         /* sometimes true for the last frame */
1042         if (get_bits1(gb)) {
1043             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1044             ff_dlog(s->avctx, "end skip: %i\n", skip);
1045         }
1046
1047     }
1048
1049     /* reset subframe states */
1050     s->parsed_all_subframes = 0;
1051     for (i = 0; i < s->num_channels; i++) {
1052         s->channel[i].decoded_samples = 0;
1053         s->channel[i].cur_subframe    = 0;
1054     }
1055
1056     /* decode all subframes */
1057     while (!s->parsed_all_subframes) {
1058         int decoded_samples = s->channel[0].decoded_samples;
1059         if (decode_subframe(s) < 0) {
1060             s->packet_loss = 1;
1061             if (s->frame->nb_samples)
1062                 s->frame->nb_samples = decoded_samples;
1063             return 0;
1064         }
1065     }
1066
1067     ff_dlog(s->avctx, "Frame done\n");
1068
1069     s->skip_frame = 0;
1070
1071     if (s->len_prefix) {
1072         if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1073             /* FIXME: not sure if this is always an error */
1074             av_log(s->avctx, AV_LOG_ERROR,
1075                    "frame[%"PRIu32"] would have to skip %i bits\n",
1076                    s->frame_num,
1077                    len - (get_bits_count(gb) - s->frame_offset) - 1);
1078             s->packet_loss = 1;
1079             return 0;
1080         }
1081
1082         /* skip the rest of the frame data */
1083         skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1084     }
1085
1086     /* decode trailer bit */
1087     more_frames = get_bits1(gb);
1088     ++s->frame_num;
1089     return more_frames;
1090 }
1091
1092 /**
1093  * @brief Calculate remaining input buffer length.
1094  * @param s  codec context
1095  * @param gb bitstream reader context
1096  * @return remaining size in bits
1097  */
1098 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1099 {
1100     return s->buf_bit_size - get_bits_count(gb);
1101 }
1102
1103 /**
1104  * @brief Fill the bit reservoir with a (partial) frame.
1105  * @param s      codec context
1106  * @param gb     bitstream reader context
1107  * @param len    length of the partial frame
1108  * @param append decides whether to reset the buffer or not
1109  */
1110 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1111                       int append)
1112 {
1113     int buflen;
1114     PutBitContext tmp;
1115
1116     /* when the frame data does not need to be concatenated, the input buffer
1117         is reset and additional bits from the previous frame are copied
1118         and skipped later so that a fast byte copy is possible */
1119
1120     if (!append) {
1121         s->frame_offset   = get_bits_count(gb) & 7;
1122         s->num_saved_bits = s->frame_offset;
1123         init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1124     }
1125
1126     buflen = (s->num_saved_bits + len + 8) >> 3;
1127
1128     if (len <= 0 || buflen > MAX_FRAMESIZE) {
1129         avpriv_request_sample(s->avctx, "Too small input buffer");
1130         s->packet_loss = 1;
1131         return;
1132     }
1133
1134     s->num_saved_bits += len;
1135     if (!append) {
1136         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1137                          s->num_saved_bits);
1138     } else {
1139         int align = 8 - (get_bits_count(gb) & 7);
1140         align = FFMIN(align, len);
1141         put_bits(&s->pb, align, get_bits(gb, align));
1142         len -= align;
1143         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1144     }
1145     skip_bits_long(gb, len);
1146
1147     tmp = s->pb;
1148     flush_put_bits(&tmp);
1149
1150     init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1151     skip_bits(&s->gb, s->frame_offset);
1152 }
1153
1154 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1155                          AVPacket* avpkt)
1156 {
1157     WmallDecodeCtx *s = avctx->priv_data;
1158     GetBitContext* gb  = &s->pgb;
1159     const uint8_t* buf = avpkt->data;
1160     int buf_size       = avpkt->size;
1161     int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1162
1163     s->frame->nb_samples = 0;
1164
1165     if (s->packet_done || s->packet_loss) {
1166         s->packet_done = 0;
1167
1168         if (!buf_size)
1169             return 0;
1170         /* sanity check for the buffer length */
1171         if (buf_size < avctx->block_align) {
1172             av_log(avctx, AV_LOG_ERROR, "buf size %d invalid\n", buf_size);
1173             return AVERROR_INVALIDDATA;
1174         }
1175
1176         s->next_packet_start = buf_size - avctx->block_align;
1177         buf_size             = avctx->block_align;
1178         s->buf_bit_size      = buf_size << 3;
1179
1180         /* parse packet header */
1181         init_get_bits(gb, buf, s->buf_bit_size);
1182         packet_sequence_number = get_bits(gb, 4);
1183         skip_bits(gb, 1);   // Skip seekable_frame_in_packet, currently ununused
1184         spliced_packet = get_bits1(gb);
1185         if (spliced_packet)
1186             avpriv_request_sample(avctx, "Bitstream splicing");
1187
1188         /* get number of bits that need to be added to the previous frame */
1189         num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1190
1191         /* check for packet loss */
1192         if (!s->packet_loss &&
1193             ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1194             s->packet_loss = 1;
1195             av_log(avctx, AV_LOG_ERROR,
1196                    "Packet loss detected! seq %"PRIx8" vs %x\n",
1197                    s->packet_sequence_number, packet_sequence_number);
1198         }
1199         s->packet_sequence_number = packet_sequence_number;
1200
1201         if (num_bits_prev_frame > 0) {
1202             int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1203             if (num_bits_prev_frame >= remaining_packet_bits) {
1204                 num_bits_prev_frame = remaining_packet_bits;
1205                 s->packet_done = 1;
1206             }
1207
1208             /* Append the previous frame data to the remaining data from the
1209              * previous packet to create a full frame. */
1210             save_bits(s, gb, num_bits_prev_frame, 1);
1211
1212             /* decode the cross packet frame if it is valid */
1213             if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1214                 decode_frame(s);
1215         } else if (s->num_saved_bits - s->frame_offset) {
1216             ff_dlog(avctx, "ignoring %x previously saved bits\n",
1217                     s->num_saved_bits - s->frame_offset);
1218         }
1219
1220         if (s->packet_loss) {
1221             /* Reset number of saved bits so that the decoder does not start
1222              * to decode incomplete frames in the s->len_prefix == 0 case. */
1223             s->num_saved_bits = 0;
1224             s->packet_loss    = 0;
1225             init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1226         }
1227
1228     } else {
1229         int frame_size;
1230
1231         s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1232         init_get_bits(gb, avpkt->data, s->buf_bit_size);
1233         skip_bits(gb, s->packet_offset);
1234
1235         if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1236             (frame_size = show_bits(gb, s->log2_frame_size)) &&
1237             frame_size <= remaining_bits(s, gb)) {
1238             save_bits(s, gb, frame_size, 0);
1239             s->packet_done = !decode_frame(s);
1240         } else if (!s->len_prefix
1241                    && s->num_saved_bits > get_bits_count(&s->gb)) {
1242             /* when the frames do not have a length prefix, we don't know the
1243              * compressed length of the individual frames however, we know what
1244              * part of a new packet belongs to the previous frame therefore we
1245              * save the incoming packet first, then we append the "previous
1246              * frame" data from the next packet so that we get a buffer that
1247              * only contains full frames */
1248             s->packet_done = !decode_frame(s);
1249         } else {
1250             s->packet_done = 1;
1251         }
1252     }
1253
1254     if (s->packet_done && !s->packet_loss &&
1255         remaining_bits(s, gb) > 0) {
1256         /* save the rest of the data so that it can be decoded
1257          * with the next packet */
1258         save_bits(s, gb, remaining_bits(s, gb), 0);
1259     }
1260
1261     *got_frame_ptr   = s->frame->nb_samples > 0;
1262     av_frame_move_ref(data, s->frame);
1263
1264     s->packet_offset = get_bits_count(gb) & 7;
1265
1266     return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1267 }
1268
1269 static void flush(AVCodecContext *avctx)
1270 {
1271     WmallDecodeCtx *s    = avctx->priv_data;
1272     s->packet_loss       = 1;
1273     s->packet_done       = 0;
1274     s->num_saved_bits    = 0;
1275     s->frame_offset      = 0;
1276     s->next_packet_start = 0;
1277     s->cdlms[0][0].order = 0;
1278     s->frame->nb_samples = 0;
1279     init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1280 }
1281
1282 static av_cold int decode_close(AVCodecContext *avctx)
1283 {
1284     WmallDecodeCtx *s = avctx->priv_data;
1285
1286     av_frame_free(&s->frame);
1287
1288     return 0;
1289 }
1290
1291 AVCodec ff_wmalossless_decoder = {
1292     .name           = "wmalossless",
1293     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1294     .type           = AVMEDIA_TYPE_AUDIO,
1295     .id             = AV_CODEC_ID_WMALOSSLESS,
1296     .priv_data_size = sizeof(WmallDecodeCtx),
1297     .init           = decode_init,
1298     .close          = decode_close,
1299     .decode         = decode_packet,
1300     .flush          = flush,
1301     .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1302     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1303                                                       AV_SAMPLE_FMT_S32P,
1304                                                       AV_SAMPLE_FMT_NONE },
1305 };