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