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;                    ///< compressed frame data
  76     int             max_frame_size;                 ///< max bitstream size
  77     PutBitContext   pb;                             ///< context for filling the frame_data buffer
  78
  79     /* frame size dependent frame information (set during initialization) */
  80     uint32_t        decode_flags;                   ///< used compression features
  81     int             len_prefix;                     ///< frame is prefixed with its length
  82     int             dynamic_range_compression;      ///< frame contains DRC data
  83     uint8_t         bits_per_sample;                ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
  84     uint16_t        samples_per_frame;              ///< number of samples to output
  85     uint16_t        log2_frame_size;
  86     int8_t          num_channels;                   ///< number of channels in the stream (same as AVCodecContext.num_channels)
  87     int8_t          lfe_channel;                    ///< lfe channel index
  88     uint8_t         max_num_subframes;
  89     uint8_t         subframe_len_bits;              ///< number of bits used for the subframe length
  90     uint8_t         max_subframe_len_bit;           ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
  91     uint16_t        min_samples_per_subframe;
  92
  93     /* packet decode state */
  94     GetBitContext   pgb;                            ///< bitstream reader context for the packet
  95     int             next_packet_start;              ///< start offset of the next WMA packet in the demuxer packet
  96     uint8_t         packet_offset;                  ///< offset to the frame in the packet
  97     uint8_t         packet_sequence_number;         ///< current packet number
  98     int             num_saved_bits;                 ///< saved number of bits
  99     int             frame_offset;                   ///< frame offset in the bit reservoir
 100     int             subframe_offset;                ///< subframe offset in the bit reservoir
 101     uint8_t         packet_loss;                    ///< set in case of bitstream error
 102     uint8_t         packet_done;                    ///< set when a packet is fully decoded
 103
 104     /* frame decode state */
 105     uint32_t        frame_num;                      ///< current frame number (not used for decoding)
 106     GetBitContext   gb;                             ///< bitstream reader context
 107     int             buf_bit_size;                   ///< buffer size in bits
 108     int16_t         *samples_16[WMALL_MAX_CHANNELS]; ///< current sample buffer pointer (16-bit)
 109     int32_t         *samples_32[WMALL_MAX_CHANNELS]; ///< current sample buffer pointer (24-bit)
 110     uint8_t         drc_gain;                       ///< gain for the DRC tool
 111     int8_t          skip_frame;                     ///< skip output step
 112     int8_t          parsed_all_subframes;           ///< all subframes decoded?
 113
 114     /* subframe/block decode state */
 115     int16_t         subframe_len;                   ///< current subframe length
 116     int8_t          channels_for_cur_subframe;      ///< number of channels that contain the subframe
 117     int8_t          channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
 118
 119     WmallChannelCtx channel[WMALL_MAX_CHANNELS];    ///< per channel data
 120
 121     // WMA Lossless-specific
 122
 123     uint8_t do_arith_coding;
 124     uint8_t do_ac_filter;
 125     uint8_t do_inter_ch_decorr;
 126     uint8_t do_mclms;
 127     uint8_t do_lpc;
 128
 129     int8_t  acfilter_order;
 130     int8_t  acfilter_scaling;
 131     int16_t acfilter_coeffs[16];
 132     int     acfilter_prevvalues[WMALL_MAX_CHANNELS][16];
 133
 134     int8_t  mclms_order;
 135     int8_t  mclms_scaling;
 136     int16_t mclms_coeffs[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS * 32];
 137     int16_t mclms_coeffs_cur[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS];
 138     int32_t mclms_prevvalues[WMALL_MAX_CHANNELS * 2 * 32];
 139     int32_t mclms_updates[WMALL_MAX_CHANNELS * 2 * 32];
 140     int     mclms_recent;
 141
 142     int     movave_scaling;
 143     int     quant_stepsize;
 144
 145     struct {
 146         int order;
 147         int scaling;
 148         int coefsend;
 149         int bitsend;
 150         DECLARE_ALIGNED(16, int16_t, coefs)[MAX_ORDER + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
 151         DECLARE_ALIGNED(16, int32_t, lms_prevvalues)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
 152         DECLARE_ALIGNED(16, int16_t, lms_updates)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
 153         int recent;
 154     } cdlms[WMALL_MAX_CHANNELS][9];
 155
 156     int cdlms_ttl[WMALL_MAX_CHANNELS];
 157
 158     int bV3RTM;
 159
 160     int is_channel_coded[WMALL_MAX_CHANNELS];
 161     int update_speed[WMALL_MAX_CHANNELS];
 162
 163     int transient[WMALL_MAX_CHANNELS];
 164     int transient_pos[WMALL_MAX_CHANNELS];
 165     int seekable_tile;
 166
 167     int ave_sum[WMALL_MAX_CHANNELS];
 168
 169     int channel_residues[WMALL_MAX_CHANNELS][WMALL_BLOCK_MAX_SIZE];
 170
 171     int lpc_coefs[WMALL_MAX_CHANNELS][40];
 172     int lpc_order;
 173     int lpc_scaling;
 174     int lpc_intbits;
 175 } WmallDecodeCtx;
 176
 177 /** Get sign of integer (1 for positive, -1 for negative and 0 for zero) */
 178 #define WMASIGN(x) (((x) > 0) - ((x) < 0))
 179
 180 static av_cold int decode_init(AVCodecContext *avctx)
 181 {
 182     WmallDecodeCtx *s  = avctx->priv_data;
 183     uint8_t *edata_ptr = avctx->extradata;
 184     unsigned int channel_mask;
 185     int i, log2_max_num_subframes;
 186
 187     if (avctx->block_align <= 0) {
 188         av_log(avctx, AV_LOG_ERROR, "block_align is not set or invalid\n");
 189         return AVERROR(EINVAL);
 190     }
 191
 192     av_assert0(avctx->channels >= 0);
 193     if (avctx->channels > WMALL_MAX_CHANNELS) {
 194         avpriv_request_sample(avctx,
 195                               "More than " AV_STRINGIFY(WMALL_MAX_CHANNELS) " channels");
 196         return AVERROR_PATCHWELCOME;
 197     }
 198
 199     s->max_frame_size = MAX_FRAMESIZE * avctx->channels;
 200     s->frame_data = av_mallocz(s->max_frame_size + AV_INPUT_BUFFER_PADDING_SIZE);
 201     if (!s->frame_data)
 202         return AVERROR(ENOMEM);
 203
 204     s->avctx = avctx;
 205     ff_llauddsp_init(&s->dsp);
 206     init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
 207
 208     if (avctx->extradata_size >= 18) {
 209         s->decode_flags    = AV_RL16(edata_ptr + 14);
 210         channel_mask       = AV_RL32(edata_ptr +  2);
 211         s->bits_per_sample = AV_RL16(edata_ptr);
 212         if (s->bits_per_sample == 16)
 213             avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
 214         else if (s->bits_per_sample == 24) {
 215             avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
 216             avctx->bits_per_raw_sample = 24;
 217         } else {
 218             av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %"PRIu8"\n",
 219                    s->bits_per_sample);
 220             return AVERROR_INVALIDDATA;
 221         }
 222         /* dump the extradata */
 223         for (i = 0; i < avctx->extradata_size; i++)
 224             ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
 225         ff_dlog(avctx, "\n");
 226
 227     } else {
 228         avpriv_request_sample(avctx, "Unsupported extradata size");
 229         return AVERROR_PATCHWELCOME;
 230     }
 231
 232     /* generic init */
 233     s->log2_frame_size = av_log2(avctx->block_align) + 4;
 234
 235     /* frame info */
 236     s->skip_frame  = 1; /* skip first frame */
 237     s->packet_loss = 1;
 238     s->len_prefix  = s->decode_flags & 0x40;
 239
 240     /* get frame len */
 241     s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
 242                                                           3, s->decode_flags);
 243     av_assert0(s->samples_per_frame <= WMALL_BLOCK_MAX_SIZE);
 244
 245     /* init previous block len */
 246     for (i = 0; i < avctx->channels; i++)
 247         s->channel[i].prev_block_len = s->samples_per_frame;
 248
 249     /* subframe info */
 250     log2_max_num_subframes  = (s->decode_flags & 0x38) >> 3;
 251     s->max_num_subframes    = 1 << log2_max_num_subframes;
 252     s->max_subframe_len_bit = 0;
 253     s->subframe_len_bits    = av_log2(log2_max_num_subframes) + 1;
 254
 255     s->min_samples_per_subframe  = s->samples_per_frame / s->max_num_subframes;
 256     s->dynamic_range_compression = s->decode_flags & 0x80;
 257     s->bV3RTM                    = s->decode_flags & 0x100;
 258
 259     if (s->max_num_subframes > MAX_SUBFRAMES) {
 260         av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRIu8"\n",
 261                s->max_num_subframes);
 262         return AVERROR_INVALIDDATA;
 263     }
 264
 265     s->num_channels = avctx->channels;
 266
 267     /* extract lfe channel position */
 268     s->lfe_channel = -1;
 269
 270     if (channel_mask & 8) {
 271         unsigned int mask;
 272         for (mask = 1; mask < 16; mask <<= 1)
 273             if (channel_mask & mask)
 274                 ++s->lfe_channel;
 275     }
 276
 277     s->frame = av_frame_alloc();
 278     if (!s->frame)
 279         return AVERROR(ENOMEM);
 280
 281     avctx->channel_layout = channel_mask;
 282     return 0;
 283 }
 284
 285 /**
 286  * @brief Decode the subframe length.
 287  * @param s      context
 288  * @param offset sample offset in the frame
 289  * @return decoded subframe length on success, < 0 in case of an error
 290  */
 291 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
 292 {
 293     int frame_len_ratio, subframe_len, len;
 294
 295     /* no need to read from the bitstream when only one length is possible */
 296     if (offset == s->samples_per_frame - s->min_samples_per_subframe)
 297         return s->min_samples_per_subframe;
 298
 299     len             = av_log2(s->max_num_subframes - 1) + 1;
 300     frame_len_ratio = get_bits(&s->gb, len);
 301     subframe_len    = s->min_samples_per_subframe * (frame_len_ratio + 1);
 302
 303     /* sanity check the length */
 304     if (subframe_len < s->min_samples_per_subframe ||
 305         subframe_len > s->samples_per_frame) {
 306         av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
 307                subframe_len);
 308         return AVERROR_INVALIDDATA;
 309     }
 310     return subframe_len;
 311 }
 312
 313 /**
 314  * @brief Decode how the data in the frame is split into subframes.
 315  *       Every WMA frame contains the encoded data for a fixed number of
 316  *       samples per channel. The data for every channel might be split
 317  *       into several subframes. This function will reconstruct the list of
 318  *       subframes for every channel.
 319  *
 320  *       If the subframes are not evenly split, the algorithm estimates the
 321  *       channels with the lowest number of total samples.
 322  *       Afterwards, for each of these channels a bit is read from the
 323  *       bitstream that indicates if the channel contains a subframe with the
 324  *       next subframe size that is going to be read from the bitstream or not.
 325  *       If a channel contains such a subframe, the subframe size gets added to
 326  *       the channel's subframe list.
 327  *       The algorithm repeats these steps until the frame is properly divided
 328  *       between the individual channels.
 329  *
 330  * @param s context
 331  * @return 0 on success, < 0 in case of an error
 332  */
 333 static int decode_tilehdr(WmallDecodeCtx *s)
 334 {
 335     uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
 336     uint8_t  contains_subframe[WMALL_MAX_CHANNELS];   /* flag indicating if a channel contains the current subframe */
 337     int channels_for_cur_subframe = s->num_channels;  /* number of channels that contain the current subframe */
 338     int fixed_channel_layout = 0;                     /* flag indicating that all channels use the same subfra2me offsets and sizes */
 339     int min_channel_len = 0;                          /* smallest sum of samples (channels with this length will be processed first) */
 340     int c, tile_aligned;
 341
 342     /* reset tiling information */
 343     for (c = 0; c < s->num_channels; c++)
 344         s->channel[c].num_subframes = 0;
 345
 346     tile_aligned = get_bits1(&s->gb);
 347     if (s->max_num_subframes == 1 || tile_aligned)
 348         fixed_channel_layout = 1;
 349
 350     /* loop until the frame data is split between the subframes */
 351     do {
 352         int subframe_len, in_use = 0;
 353
 354         /* check which channels contain the subframe */
 355         for (c = 0; c < s->num_channels; c++) {
 356             if (num_samples[c] == min_channel_len) {
 357                 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
 358                    (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
 359                     contains_subframe[c] = 1;
 360                 } else {
 361                     contains_subframe[c] = get_bits1(&s->gb);
 362                 }
 363                 in_use |= contains_subframe[c];
 364             } else
 365                 contains_subframe[c] = 0;
 366         }
 367
 368         if (!in_use) {
 369             av_log(s->avctx, AV_LOG_ERROR,
 370                    "Found empty subframe\n");
 371             return AVERROR_INVALIDDATA;
 372         }
 373
 374         /* get subframe length, subframe_len == 0 is not allowed */
 375         if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
 376             return AVERROR_INVALIDDATA;
 377         /* add subframes to the individual channels and find new min_channel_len */
 378         min_channel_len += subframe_len;
 379         for (c = 0; c < s->num_channels; c++) {
 380             WmallChannelCtx *chan = &s->channel[c];
 381
 382             if (contains_subframe[c]) {
 383                 if (chan->num_subframes >= MAX_SUBFRAMES) {
 384                     av_log(s->avctx, AV_LOG_ERROR,
 385                            "broken frame: num subframes > 31\n");
 386                     return AVERROR_INVALIDDATA;
 387                 }
 388                 chan->subframe_len[chan->num_subframes] = subframe_len;
 389                 num_samples[c] += subframe_len;
 390                 ++chan->num_subframes;
 391                 if (num_samples[c] > s->samples_per_frame) {
 392                     av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
 393                            "channel len(%"PRIu16") > samples_per_frame(%"PRIu16")\n",
 394                            num_samples[c], s->samples_per_frame);
 395                     return AVERROR_INVALIDDATA;
 396                 }
 397             } else if (num_samples[c] <= min_channel_len) {
 398                 if (num_samples[c] < min_channel_len) {
 399                     channels_for_cur_subframe = 0;
 400                     min_channel_len = num_samples[c];
 401                 }
 402                 ++channels_for_cur_subframe;
 403             }
 404         }
 405     } while (min_channel_len < s->samples_per_frame);
 406
 407     for (c = 0; c < s->num_channels; c++) {
 408         int i, offset = 0;
 409         for (i = 0; i < s->channel[c].num_subframes; i++) {
 410             s->channel[c].subframe_offsets[i] = offset;
 411             offset += s->channel[c].subframe_len[i];
 412         }
 413     }
 414
 415     return 0;
 416 }
 417
 418 static void decode_ac_filter(WmallDecodeCtx *s)
 419 {
 420     int i;
 421     s->acfilter_order   = get_bits(&s->gb, 4) + 1;
 422     s->acfilter_scaling = get_bits(&s->gb, 4);
 423
 424     for (i = 0; i < s->acfilter_order; i++)
 425         s->acfilter_coeffs[i] = get_bitsz(&s->gb, s->acfilter_scaling) + 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 = get_bitsz(&s->gb, cbits) + 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 && s->bits_per_sample == 16) {
 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_bitsz(&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] - (unsigned)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(int32_t) * order * num_channels);
 655         memcpy(&s->mclms_updates[order * num_channels],
 656                s->mclms_updates,
 657                sizeof(int32_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] += (uint32_t)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] += (uint32_t)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] += (unsigned)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 use_high_update_speed(WmallDecodeCtx *s, int ich)
 694 {
 695     int ilms, recent, icoef;
 696     for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
 697         recent = s->cdlms[ich][ilms].recent;
 698         if (s->update_speed[ich] == 16)
 699             continue;
 700         if (s->bV3RTM) {
 701             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
 702                 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
 703         } else {
 704             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
 705                 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
 706         }
 707     }
 708     s->update_speed[ich] = 16;
 709 }
 710
 711 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
 712 {
 713     int ilms, recent, icoef;
 714     for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
 715         recent = s->cdlms[ich][ilms].recent;
 716         if (s->update_speed[ich] == 8)
 717             continue;
 718         if (s->bV3RTM)
 719             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
 720                 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
 721         else
 722             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
 723                 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
 724     }
 725     s->update_speed[ich] = 8;
 726 }
 727
 728 #define CD_LMS(bits, ROUND) \
 729 static void lms_update ## bits (WmallDecodeCtx *s, int ich, int ilms, int input) \
 730 { \
 731     int recent = s->cdlms[ich][ilms].recent; \
 732     int range  = 1 << s->bits_per_sample - 1; \
 733     int order  = s->cdlms[ich][ilms].order; \
 734     int ##bits##_t *prev = (int##bits##_t *)s->cdlms[ich][ilms].lms_prevvalues; \
 735  \
 736     if (recent) \
 737         recent--; \
 738     else { \
 739         memcpy(prev + order, prev, (bits/8) * order); \
 740         memcpy(s->cdlms[ich][ilms].lms_updates + order, \
 741                s->cdlms[ich][ilms].lms_updates, \
 742                sizeof(*s->cdlms[ich][ilms].lms_updates) * order); \
 743         recent = order - 1; \
 744     } \
 745  \
 746     prev[recent] = av_clip(input, -range, range - 1); \
 747     s->cdlms[ich][ilms].lms_updates[recent] = WMASIGN(input) * s->update_speed[ich]; \
 748  \
 749     s->cdlms[ich][ilms].lms_updates[recent + (order >> 4)] >>= 2; \
 750     s->cdlms[ich][ilms].lms_updates[recent + (order >> 3)] >>= 1; \
 751     s->cdlms[ich][ilms].recent = recent; \
 752     memset(s->cdlms[ich][ilms].lms_updates + recent + order, 0, \
 753            sizeof(s->cdlms[ich][ilms].lms_updates) - \
 754            sizeof(*s->cdlms[ich][ilms].lms_updates)*(recent+order)); \
 755 } \
 756  \
 757 static void revert_cdlms ## bits (WmallDecodeCtx *s, int ch, \
 758                                   int coef_begin, int coef_end) \
 759 { \
 760     int icoef, pred, ilms, num_lms, residue, input; \
 761  \
 762     num_lms = s->cdlms_ttl[ch]; \
 763     for (ilms = num_lms - 1; ilms >= 0; ilms--) { \
 764         for (icoef = coef_begin; icoef < coef_end; icoef++) { \
 765             int##bits##_t *prevvalues = (int##bits##_t *)s->cdlms[ch][ilms].lms_prevvalues; \
 766             pred = (1 << s->cdlms[ch][ilms].scaling) >> 1; \
 767             residue = s->channel_residues[ch][icoef]; \
 768             pred += s->dsp.scalarproduct_and_madd_int## bits (s->cdlms[ch][ilms].coefs, \
 769                                                         prevvalues + s->cdlms[ch][ilms].recent, \
 770                                                         s->cdlms[ch][ilms].lms_updates + \
 771                                                         s->cdlms[ch][ilms].recent, \
 772                                                         FFALIGN(s->cdlms[ch][ilms].order, ROUND), \
 773                                                         WMASIGN(residue)); \
 774             input = residue + (pred >> s->cdlms[ch][ilms].scaling); \
 775             lms_update ## bits(s, ch, ilms, input); \
 776             s->channel_residues[ch][icoef] = input; \
 777         } \
 778     } \
 779     if (bits <= 16) emms_c(); \
 780 }
 781
 782 CD_LMS(16, WMALL_COEFF_PAD_SIZE)
 783 CD_LMS(32, 8)
 784
 785 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
 786 {
 787     if (s->num_channels != 2)
 788         return;
 789     else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
 790         int icoef;
 791         for (icoef = 0; icoef < tile_size; icoef++) {
 792             s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
 793             s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
 794         }
 795     }
 796 }
 797
 798 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
 799 {
 800     int ich, pred, i, j;
 801     int16_t *filter_coeffs = s->acfilter_coeffs;
 802     int scaling            = s->acfilter_scaling;
 803     int order              = s->acfilter_order;
 804
 805     for (ich = 0; ich < s->num_channels; ich++) {
 806         int *prevvalues = s->acfilter_prevvalues[ich];
 807         for (i = 0; i < order; i++) {
 808             pred = 0;
 809             for (j = 0; j < order; j++) {
 810                 if (i <= j)
 811                     pred += (uint32_t)filter_coeffs[j] * prevvalues[j - i];
 812                 else
 813                     pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
 814             }
 815             pred >>= scaling;
 816             s->channel_residues[ich][i] += (unsigned)pred;
 817         }
 818         for (i = order; i < tile_size; i++) {
 819             pred = 0;
 820             for (j = 0; j < order; j++)
 821                 pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
 822             pred >>= scaling;
 823             s->channel_residues[ich][i] += (unsigned)pred;
 824         }
 825         for (j = 0; j < order; j++)
 826             prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
 827     }
 828 }
 829
 830 static int decode_subframe(WmallDecodeCtx *s)
 831 {
 832     int offset        = s->samples_per_frame;
 833     int subframe_len  = s->samples_per_frame;
 834     int total_samples = s->samples_per_frame * s->num_channels;
 835     int i, j, rawpcm_tile, padding_zeroes, res;
 836
 837     s->subframe_offset = get_bits_count(&s->gb);
 838
 839     /* reset channel context and find the next block offset and size
 840         == the next block of the channel with the smallest number of
 841         decoded samples */
 842     for (i = 0; i < s->num_channels; i++) {
 843         if (offset > s->channel[i].decoded_samples) {
 844             offset = s->channel[i].decoded_samples;
 845             subframe_len =
 846                 s->channel[i].subframe_len[s->channel[i].cur_subframe];
 847         }
 848     }
 849
 850     /* get a list of all channels that contain the estimated block */
 851     s->channels_for_cur_subframe = 0;
 852     for (i = 0; i < s->num_channels; i++) {
 853         const int cur_subframe = s->channel[i].cur_subframe;
 854         /* subtract already processed samples */
 855         total_samples -= s->channel[i].decoded_samples;
 856
 857         /* and count if there are multiple subframes that match our profile */
 858         if (offset == s->channel[i].decoded_samples &&
 859             subframe_len == s->channel[i].subframe_len[cur_subframe]) {
 860             total_samples -= s->channel[i].subframe_len[cur_subframe];
 861             s->channel[i].decoded_samples +=
 862                 s->channel[i].subframe_len[cur_subframe];
 863             s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
 864             ++s->channels_for_cur_subframe;
 865         }
 866     }
 867
 868     /* check if the frame will be complete after processing the
 869         estimated block */
 870     if (!total_samples)
 871         s->parsed_all_subframes = 1;
 872
 873
 874     s->seekable_tile = get_bits1(&s->gb);
 875     if (s->seekable_tile) {
 876         clear_codec_buffers(s);
 877
 878         s->do_arith_coding    = get_bits1(&s->gb);
 879         if (s->do_arith_coding) {
 880             avpriv_request_sample(s->avctx, "Arithmetic coding");
 881             return AVERROR_PATCHWELCOME;
 882         }
 883         s->do_ac_filter       = get_bits1(&s->gb);
 884         s->do_inter_ch_decorr = get_bits1(&s->gb);
 885         s->do_mclms           = get_bits1(&s->gb);
 886
 887         if (s->do_ac_filter)
 888             decode_ac_filter(s);
 889
 890         if (s->do_mclms)
 891             decode_mclms(s);
 892
 893         if ((res = decode_cdlms(s)) < 0)
 894             return res;
 895         s->movave_scaling = get_bits(&s->gb, 3);
 896         s->quant_stepsize = get_bits(&s->gb, 8) + 1;
 897
 898         reset_codec(s);
 899     }
 900
 901     rawpcm_tile = get_bits1(&s->gb);
 902
 903     if (!rawpcm_tile && !s->cdlms[0][0].order) {
 904         av_log(s->avctx, AV_LOG_DEBUG,
 905                "Waiting for seekable tile\n");
 906         av_frame_unref(s->frame);
 907         return -1;
 908     }
 909
 910
 911     for (i = 0; i < s->num_channels; i++)
 912         s->is_channel_coded[i] = 1;
 913
 914     if (!rawpcm_tile) {
 915         for (i = 0; i < s->num_channels; i++)
 916             s->is_channel_coded[i] = get_bits1(&s->gb);
 917
 918         if (s->bV3RTM) {
 919             // LPC
 920             s->do_lpc = get_bits1(&s->gb);
 921             if (s->do_lpc) {
 922                 decode_lpc(s);
 923                 avpriv_request_sample(s->avctx, "Expect wrong output since "
 924                                       "inverse LPC filter");
 925             }
 926         } else
 927             s->do_lpc = 0;
 928     }
 929
 930
 931     if (get_bits1(&s->gb))
 932         padding_zeroes = get_bits(&s->gb, 5);
 933     else
 934         padding_zeroes = 0;
 935
 936     if (rawpcm_tile) {
 937         int bits = s->bits_per_sample - padding_zeroes;
 938         if (bits <= 0) {
 939             av_log(s->avctx, AV_LOG_ERROR,
 940                    "Invalid number of padding bits in raw PCM tile\n");
 941             return AVERROR_INVALIDDATA;
 942         }
 943         ff_dlog(s->avctx, "RAWPCM %d bits per sample. "
 944                 "total %d bits, remain=%d\n", bits,
 945                 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
 946         for (i = 0; i < s->num_channels; i++)
 947             for (j = 0; j < subframe_len; j++)
 948                 s->channel_residues[i][j] = get_sbits_long(&s->gb, bits);
 949     } else {
 950         if (s->bits_per_sample < padding_zeroes)
 951             return AVERROR_INVALIDDATA;
 952         for (i = 0; i < s->num_channels; i++) {
 953             if (s->is_channel_coded[i]) {
 954                 decode_channel_residues(s, i, subframe_len);
 955                 if (s->seekable_tile)
 956                     use_high_update_speed(s, i);
 957                 else
 958                     use_normal_update_speed(s, i);
 959                 if (s->bits_per_sample > 16)
 960                     revert_cdlms32(s, i, 0, subframe_len);
 961                 else
 962                     revert_cdlms16(s, i, 0, subframe_len);
 963             } else {
 964                 memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
 965             }
 966         }
 967
 968         if (s->do_mclms)
 969             revert_mclms(s, subframe_len);
 970         if (s->do_inter_ch_decorr)
 971             revert_inter_ch_decorr(s, subframe_len);
 972         if (s->do_ac_filter)
 973             revert_acfilter(s, subframe_len);
 974
 975         /* Dequantize */
 976         if (s->quant_stepsize != 1)
 977             for (i = 0; i < s->num_channels; i++)
 978                 for (j = 0; j < subframe_len; j++)
 979                     s->channel_residues[i][j] *= (unsigned)s->quant_stepsize;
 980     }
 981
 982     /* Write to proper output buffer depending on bit-depth */
 983     for (i = 0; i < s->channels_for_cur_subframe; i++) {
 984         int c = s->channel_indexes_for_cur_subframe[i];
 985         int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
 986
 987         for (j = 0; j < subframe_len; j++) {
 988             if (s->bits_per_sample == 16) {
 989                 *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] * (1 << padding_zeroes);
 990             } else {
 991                 *s->samples_32[c]++ = s->channel_residues[c][j] * (256 << padding_zeroes);
 992             }
 993         }
 994     }
 995
 996     /* handled one subframe */
 997     for (i = 0; i < s->channels_for_cur_subframe; i++) {
 998         int c = s->channel_indexes_for_cur_subframe[i];
 999         if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1000             av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1001             return AVERROR_INVALIDDATA;
1002         }
1003         ++s->channel[c].cur_subframe;
1004     }
1005     return 0;
1006 }
1007
1008 /**
1009  * @brief Decode one WMA frame.
1010  * @param s codec context
1011  * @return 0 if the trailer bit indicates that this is the last frame,
1012  *         1 if there are additional frames
1013  */
1014 static int decode_frame(WmallDecodeCtx *s)
1015 {
1016     GetBitContext* gb = &s->gb;
1017     int more_frames = 0, len = 0, i, ret;
1018
1019     s->frame->nb_samples = s->samples_per_frame;
1020     if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1021         /* return an error if no frame could be decoded at all */
1022         s->packet_loss = 1;
1023         s->frame->nb_samples = 0;
1024         return ret;
1025     }
1026     for (i = 0; i < s->num_channels; i++) {
1027         s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1028         s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1029     }
1030
1031     /* get frame length */
1032     if (s->len_prefix)
1033         len = get_bits(gb, s->log2_frame_size);
1034
1035     /* decode tile information */
1036     if ((ret = decode_tilehdr(s))) {
1037         s->packet_loss = 1;
1038         av_frame_unref(s->frame);
1039         return ret;
1040     }
1041
1042     /* read drc info */
1043     if (s->dynamic_range_compression)
1044         s->drc_gain = get_bits(gb, 8);
1045
1046     /* no idea what these are for, might be the number of samples
1047        that need to be skipped at the beginning or end of a stream */
1048     if (get_bits1(gb)) {
1049         int av_unused skip;
1050
1051         /* usually true for the first frame */
1052         if (get_bits1(gb)) {
1053             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1054             ff_dlog(s->avctx, "start skip: %i\n", skip);
1055         }
1056
1057         /* sometimes true for the last frame */
1058         if (get_bits1(gb)) {
1059             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1060             ff_dlog(s->avctx, "end skip: %i\n", skip);
1061             s->frame->nb_samples -= skip;
1062             if (s->frame->nb_samples <= 0)
1063                 return AVERROR_INVALIDDATA;
1064         }
1065
1066     }
1067
1068     /* reset subframe states */
1069     s->parsed_all_subframes = 0;
1070     for (i = 0; i < s->num_channels; i++) {
1071         s->channel[i].decoded_samples = 0;
1072         s->channel[i].cur_subframe    = 0;
1073     }
1074
1075     /* decode all subframes */
1076     while (!s->parsed_all_subframes) {
1077         int decoded_samples = s->channel[0].decoded_samples;
1078         if (decode_subframe(s) < 0) {
1079             s->packet_loss = 1;
1080             if (s->frame->nb_samples)
1081                 s->frame->nb_samples = decoded_samples;
1082             return 0;
1083         }
1084     }
1085
1086     ff_dlog(s->avctx, "Frame done\n");
1087
1088     s->skip_frame = 0;
1089
1090     if (s->len_prefix) {
1091         if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1092             /* FIXME: not sure if this is always an error */
1093             av_log(s->avctx, AV_LOG_ERROR,
1094                    "frame[%"PRIu32"] would have to skip %i bits\n",
1095                    s->frame_num,
1096                    len - (get_bits_count(gb) - s->frame_offset) - 1);
1097             s->packet_loss = 1;
1098             return 0;
1099         }
1100
1101         /* skip the rest of the frame data */
1102         skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1103     }
1104
1105     /* decode trailer bit */
1106     more_frames = get_bits1(gb);
1107     ++s->frame_num;
1108     return more_frames;
1109 }
1110
1111 /**
1112  * @brief Calculate remaining input buffer length.
1113  * @param s  codec context
1114  * @param gb bitstream reader context
1115  * @return remaining size in bits
1116  */
1117 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1118 {
1119     return s->buf_bit_size - get_bits_count(gb);
1120 }
1121
1122 /**
1123  * @brief Fill the bit reservoir with a (partial) frame.
1124  * @param s      codec context
1125  * @param gb     bitstream reader context
1126  * @param len    length of the partial frame
1127  * @param append decides whether to reset the buffer or not
1128  */
1129 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1130                       int append)
1131 {
1132     int buflen;
1133     PutBitContext tmp;
1134
1135     /* when the frame data does not need to be concatenated, the input buffer
1136         is reset and additional bits from the previous frame are copied
1137         and skipped later so that a fast byte copy is possible */
1138
1139     if (!append) {
1140         s->frame_offset   = get_bits_count(gb) & 7;
1141         s->num_saved_bits = s->frame_offset;
1142         init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1143     }
1144
1145     buflen = (s->num_saved_bits + len + 8) >> 3;
1146
1147     if (len <= 0 || buflen > s->max_frame_size) {
1148         avpriv_request_sample(s->avctx, "Too small input buffer");
1149         s->packet_loss = 1;
1150         s->num_saved_bits = 0;
1151         return;
1152     }
1153
1154     s->num_saved_bits += len;
1155     if (!append) {
1156         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1157                          s->num_saved_bits);
1158     } else {
1159         int align = 8 - (get_bits_count(gb) & 7);
1160         align = FFMIN(align, len);
1161         put_bits(&s->pb, align, get_bits(gb, align));
1162         len -= align;
1163         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1164     }
1165     skip_bits_long(gb, len);
1166
1167     tmp = s->pb;
1168     flush_put_bits(&tmp);
1169
1170     init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1171     skip_bits(&s->gb, s->frame_offset);
1172 }
1173
1174 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1175                          AVPacket* avpkt)
1176 {
1177     WmallDecodeCtx *s = avctx->priv_data;
1178     GetBitContext* gb  = &s->pgb;
1179     const uint8_t* buf = avpkt->data;
1180     int buf_size       = avpkt->size;
1181     int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1182
1183     s->frame->nb_samples = 0;
1184
1185     if (!buf_size && s->num_saved_bits > get_bits_count(&s->gb)) {
1186         s->packet_done = 0;
1187         if (!decode_frame(s))
1188             s->num_saved_bits = 0;
1189     } else if (s->packet_done || s->packet_loss) {
1190         s->packet_done = 0;
1191
1192         if (!buf_size)
1193             return 0;
1194
1195         s->next_packet_start = buf_size - FFMIN(avctx->block_align, buf_size);
1196         buf_size             = FFMIN(avctx->block_align, buf_size);
1197         s->buf_bit_size      = buf_size << 3;
1198
1199         /* parse packet header */
1200         init_get_bits(gb, buf, s->buf_bit_size);
1201         packet_sequence_number = get_bits(gb, 4);
1202         skip_bits(gb, 1);   // Skip seekable_frame_in_packet, currently unused
1203         spliced_packet = get_bits1(gb);
1204         if (spliced_packet)
1205             avpriv_request_sample(avctx, "Bitstream splicing");
1206
1207         /* get number of bits that need to be added to the previous frame */
1208         num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1209
1210         /* check for packet loss */
1211         if (!s->packet_loss &&
1212             ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1213             s->packet_loss = 1;
1214             av_log(avctx, AV_LOG_ERROR,
1215                    "Packet loss detected! seq %"PRIx8" vs %x\n",
1216                    s->packet_sequence_number, packet_sequence_number);
1217         }
1218         s->packet_sequence_number = packet_sequence_number;
1219
1220         if (num_bits_prev_frame > 0) {
1221             int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1222             if (num_bits_prev_frame >= remaining_packet_bits) {
1223                 num_bits_prev_frame = remaining_packet_bits;
1224                 s->packet_done = 1;
1225             }
1226
1227             /* Append the previous frame data to the remaining data from the
1228              * previous packet to create a full frame. */
1229             save_bits(s, gb, num_bits_prev_frame, 1);
1230
1231             /* decode the cross packet frame if it is valid */
1232             if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1233                 decode_frame(s);
1234         } else if (s->num_saved_bits - s->frame_offset) {
1235             ff_dlog(avctx, "ignoring %x previously saved bits\n",
1236                     s->num_saved_bits - s->frame_offset);
1237         }
1238
1239         if (s->packet_loss) {
1240             /* Reset number of saved bits so that the decoder does not start
1241              * to decode incomplete frames in the s->len_prefix == 0 case. */
1242             s->num_saved_bits = 0;
1243             s->packet_loss    = 0;
1244             init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1245         }
1246
1247     } else {
1248         int frame_size;
1249
1250         s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1251         init_get_bits(gb, avpkt->data, s->buf_bit_size);
1252         skip_bits(gb, s->packet_offset);
1253
1254         if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1255             (frame_size = show_bits(gb, s->log2_frame_size)) &&
1256             frame_size <= remaining_bits(s, gb)) {
1257             save_bits(s, gb, frame_size, 0);
1258
1259             if (!s->packet_loss)
1260                 s->packet_done = !decode_frame(s);
1261         } else if (!s->len_prefix
1262                    && s->num_saved_bits > get_bits_count(&s->gb)) {
1263             /* when the frames do not have a length prefix, we don't know the
1264              * compressed length of the individual frames however, we know what
1265              * part of a new packet belongs to the previous frame therefore we
1266              * save the incoming packet first, then we append the "previous
1267              * frame" data from the next packet so that we get a buffer that
1268              * only contains full frames */
1269             s->packet_done = !decode_frame(s);
1270         } else {
1271             s->packet_done = 1;
1272         }
1273     }
1274
1275     if (remaining_bits(s, gb) < 0) {
1276         av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1277         s->packet_loss = 1;
1278     }
1279
1280     if (s->packet_done && !s->packet_loss &&
1281         remaining_bits(s, gb) > 0) {
1282         /* save the rest of the data so that it can be decoded
1283          * with the next packet */
1284         save_bits(s, gb, remaining_bits(s, gb), 0);
1285     }
1286
1287     *got_frame_ptr   = s->frame->nb_samples > 0;
1288     av_frame_move_ref(data, s->frame);
1289
1290     s->packet_offset = get_bits_count(gb) & 7;
1291
1292     return (s->packet_loss) ? AVERROR_INVALIDDATA : buf_size ? get_bits_count(gb) >> 3 : 0;
1293 }
1294
1295 static void flush(AVCodecContext *avctx)
1296 {
1297     WmallDecodeCtx *s    = avctx->priv_data;
1298     s->packet_loss       = 1;
1299     s->packet_done       = 0;
1300     s->num_saved_bits    = 0;
1301     s->frame_offset      = 0;
1302     s->next_packet_start = 0;
1303     s->cdlms[0][0].order = 0;
1304     s->frame->nb_samples = 0;
1305     init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1306 }
1307
1308 static av_cold int decode_close(AVCodecContext *avctx)
1309 {
1310     WmallDecodeCtx *s = avctx->priv_data;
1311
1312     av_frame_free(&s->frame);
1313     av_freep(&s->frame_data);
1314
1315     return 0;
1316 }
1317
1318 AVCodec ff_wmalossless_decoder = {
1319     .name           = "wmalossless",
1320     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1321     .type           = AVMEDIA_TYPE_AUDIO,
1322     .id             = AV_CODEC_ID_WMALOSSLESS,
1323     .priv_data_size = sizeof(WmallDecodeCtx),
1324     .init           = decode_init,
1325     .close          = decode_close,
1326     .decode         = decode_packet,
1327     .flush          = flush,
1328     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1329     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
1330     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1331                                                       AV_SAMPLE_FMT_S32P,
1332                                                       AV_SAMPLE_FMT_NONE },
1333 };