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     unsigned 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 || avctx->block_align > (1<<21)) {
 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 rem, rem_bits;
 536         unsigned quo = 0, residue;
 537         while(get_bits1(&s->gb)) {
 538             quo++;
 539             if (get_bits_left(&s->gb) <= 0)
 540                 return -1;
 541         }
 542         if (quo >= 32)
 543             quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
 544
 545         ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
 546         if (ave_mean <= 1)
 547             residue = quo;
 548         else {
 549             rem_bits = av_ceil_log2(ave_mean);
 550             rem      = get_bits_long(&s->gb, rem_bits);
 551             residue  = (quo << rem_bits) + rem;
 552         }
 553
 554         s->ave_sum[ch] = residue + s->ave_sum[ch] -
 555                          (s->ave_sum[ch] >> s->movave_scaling);
 556
 557         residue = (residue >> 1) ^ -(residue & 1);
 558         s->channel_residues[ch][i] = residue;
 559     }
 560
 561     return 0;
 562
 563 }
 564
 565 static void decode_lpc(WmallDecodeCtx *s)
 566 {
 567     int ch, i, cbits;
 568     s->lpc_order   = get_bits(&s->gb, 5) + 1;
 569     s->lpc_scaling = get_bits(&s->gb, 4);
 570     s->lpc_intbits = get_bits(&s->gb, 3) + 1;
 571     cbits = s->lpc_scaling + s->lpc_intbits;
 572     for (ch = 0; ch < s->num_channels; ch++)
 573         for (i = 0; i < s->lpc_order; i++)
 574             s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
 575 }
 576
 577 static void clear_codec_buffers(WmallDecodeCtx *s)
 578 {
 579     int ich, ilms;
 580
 581     memset(s->acfilter_coeffs,     0, sizeof(s->acfilter_coeffs));
 582     memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
 583     memset(s->lpc_coefs,           0, sizeof(s->lpc_coefs));
 584
 585     memset(s->mclms_coeffs,     0, sizeof(s->mclms_coeffs));
 586     memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
 587     memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
 588     memset(s->mclms_updates,    0, sizeof(s->mclms_updates));
 589
 590     for (ich = 0; ich < s->num_channels; ich++) {
 591         for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
 592             memset(s->cdlms[ich][ilms].coefs, 0,
 593                    sizeof(s->cdlms[ich][ilms].coefs));
 594             memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
 595                    sizeof(s->cdlms[ich][ilms].lms_prevvalues));
 596             memset(s->cdlms[ich][ilms].lms_updates, 0,
 597                    sizeof(s->cdlms[ich][ilms].lms_updates));
 598         }
 599         s->ave_sum[ich] = 0;
 600     }
 601 }
 602
 603 /**
 604  * @brief Reset filter parameters and transient area at new seekable tile.
 605  */
 606 static void reset_codec(WmallDecodeCtx *s)
 607 {
 608     int ich, ilms;
 609     s->mclms_recent = s->mclms_order * s->num_channels;
 610     for (ich = 0; ich < s->num_channels; ich++) {
 611         for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
 612             s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
 613         /* first sample of a seekable subframe is considered as the starting of
 614             a transient area which is samples_per_frame samples long */
 615         s->channel[ich].transient_counter = s->samples_per_frame;
 616         s->transient[ich]     = 1;
 617         s->transient_pos[ich] = 0;
 618     }
 619 }
 620
 621 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
 622 {
 623     int i, j, ich, pred_error;
 624     int order        = s->mclms_order;
 625     int num_channels = s->num_channels;
 626     int range        = 1 << (s->bits_per_sample - 1);
 627
 628     for (ich = 0; ich < num_channels; ich++) {
 629         pred_error = s->channel_residues[ich][icoef] - (unsigned)pred[ich];
 630         if (pred_error > 0) {
 631             for (i = 0; i < order * num_channels; i++)
 632                 s->mclms_coeffs[i + ich * order * num_channels] +=
 633                     s->mclms_updates[s->mclms_recent + i];
 634             for (j = 0; j < ich; j++)
 635                 s->mclms_coeffs_cur[ich * num_channels + j] += WMASIGN(s->channel_residues[j][icoef]);
 636         } else if (pred_error < 0) {
 637             for (i = 0; i < order * num_channels; i++)
 638                 s->mclms_coeffs[i + ich * order * num_channels] -=
 639                     s->mclms_updates[s->mclms_recent + i];
 640             for (j = 0; j < ich; j++)
 641                 s->mclms_coeffs_cur[ich * num_channels + j] -= WMASIGN(s->channel_residues[j][icoef]);
 642         }
 643     }
 644
 645     for (ich = num_channels - 1; ich >= 0; ich--) {
 646         s->mclms_recent--;
 647         s->mclms_prevvalues[s->mclms_recent] = av_clip(s->channel_residues[ich][icoef],
 648             -range, range - 1);
 649         s->mclms_updates[s->mclms_recent] = WMASIGN(s->channel_residues[ich][icoef]);
 650     }
 651
 652     if (s->mclms_recent == 0) {
 653         memcpy(&s->mclms_prevvalues[order * num_channels],
 654                s->mclms_prevvalues,
 655                sizeof(int32_t) * order * num_channels);
 656         memcpy(&s->mclms_updates[order * num_channels],
 657                s->mclms_updates,
 658                sizeof(int32_t) * order * num_channels);
 659         s->mclms_recent = num_channels * order;
 660     }
 661 }
 662
 663 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
 664 {
 665     int ich, i;
 666     int order        = s->mclms_order;
 667     int num_channels = s->num_channels;
 668
 669     for (ich = 0; ich < num_channels; ich++) {
 670         pred[ich] = 0;
 671         if (!s->is_channel_coded[ich])
 672             continue;
 673         for (i = 0; i < order * num_channels; i++)
 674             pred[ich] += (uint32_t)s->mclms_prevvalues[i + s->mclms_recent] *
 675                          s->mclms_coeffs[i + order * num_channels * ich];
 676         for (i = 0; i < ich; i++)
 677             pred[ich] += (uint32_t)s->channel_residues[i][icoef] *
 678                          s->mclms_coeffs_cur[i + num_channels * ich];
 679         pred[ich] += (1U << s->mclms_scaling) >> 1;
 680         pred[ich] >>= s->mclms_scaling;
 681         s->channel_residues[ich][icoef] += (unsigned)pred[ich];
 682     }
 683 }
 684
 685 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
 686 {
 687     int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
 688     for (icoef = 0; icoef < tile_size; icoef++) {
 689         mclms_predict(s, icoef, pred);
 690         mclms_update(s, icoef, pred);
 691     }
 692 }
 693
 694 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
 695 {
 696     int ilms, recent, icoef;
 697     for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
 698         recent = s->cdlms[ich][ilms].recent;
 699         if (s->update_speed[ich] == 16)
 700             continue;
 701         if (s->bV3RTM) {
 702             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
 703                 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
 704         } else {
 705             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
 706                 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
 707         }
 708     }
 709     s->update_speed[ich] = 16;
 710 }
 711
 712 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
 713 {
 714     int ilms, recent, icoef;
 715     for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
 716         recent = s->cdlms[ich][ilms].recent;
 717         if (s->update_speed[ich] == 8)
 718             continue;
 719         if (s->bV3RTM)
 720             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
 721                 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
 722         else
 723             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
 724                 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
 725     }
 726     s->update_speed[ich] = 8;
 727 }
 728
 729 #define CD_LMS(bits, ROUND) \
 730 static void lms_update ## bits (WmallDecodeCtx *s, int ich, int ilms, int input) \
 731 { \
 732     int recent = s->cdlms[ich][ilms].recent; \
 733     int range  = 1 << s->bits_per_sample - 1; \
 734     int order  = s->cdlms[ich][ilms].order; \
 735     int ##bits##_t *prev = (int##bits##_t *)s->cdlms[ich][ilms].lms_prevvalues; \
 736  \
 737     if (recent) \
 738         recent--; \
 739     else { \
 740         memcpy(prev + order, prev, (bits/8) * order); \
 741         memcpy(s->cdlms[ich][ilms].lms_updates + order, \
 742                s->cdlms[ich][ilms].lms_updates, \
 743                sizeof(*s->cdlms[ich][ilms].lms_updates) * order); \
 744         recent = order - 1; \
 745     } \
 746  \
 747     prev[recent] = av_clip(input, -range, range - 1); \
 748     s->cdlms[ich][ilms].lms_updates[recent] = WMASIGN(input) * s->update_speed[ich]; \
 749  \
 750     s->cdlms[ich][ilms].lms_updates[recent + (order >> 4)] >>= 2; \
 751     s->cdlms[ich][ilms].lms_updates[recent + (order >> 3)] >>= 1; \
 752     s->cdlms[ich][ilms].recent = recent; \
 753     memset(s->cdlms[ich][ilms].lms_updates + recent + order, 0, \
 754            sizeof(s->cdlms[ich][ilms].lms_updates) - \
 755            sizeof(*s->cdlms[ich][ilms].lms_updates)*(recent+order)); \
 756 } \
 757  \
 758 static void revert_cdlms ## bits (WmallDecodeCtx *s, int ch, \
 759                                   int coef_begin, int coef_end) \
 760 { \
 761     int icoef, ilms, num_lms, residue, input; \
 762     unsigned pred;\
 763  \
 764     num_lms = s->cdlms_ttl[ch]; \
 765     for (ilms = num_lms - 1; ilms >= 0; ilms--) { \
 766         for (icoef = coef_begin; icoef < coef_end; icoef++) { \
 767             int##bits##_t *prevvalues = (int##bits##_t *)s->cdlms[ch][ilms].lms_prevvalues; \
 768             pred = (1 << s->cdlms[ch][ilms].scaling) >> 1; \
 769             residue = s->channel_residues[ch][icoef]; \
 770             pred += s->dsp.scalarproduct_and_madd_int## bits (s->cdlms[ch][ilms].coefs, \
 771                                                         prevvalues + s->cdlms[ch][ilms].recent, \
 772                                                         s->cdlms[ch][ilms].lms_updates + \
 773                                                         s->cdlms[ch][ilms].recent, \
 774                                                         FFALIGN(s->cdlms[ch][ilms].order, ROUND), \
 775                                                         WMASIGN(residue)); \
 776             input = residue + (unsigned)((int)pred >> s->cdlms[ch][ilms].scaling); \
 777             lms_update ## bits(s, ch, ilms, input); \
 778             s->channel_residues[ch][icoef] = input; \
 779         } \
 780     } \
 781     if (bits <= 16) emms_c(); \
 782 }
 783
 784 CD_LMS(16, WMALL_COEFF_PAD_SIZE)
 785 CD_LMS(32, 8)
 786
 787 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
 788 {
 789     if (s->num_channels != 2)
 790         return;
 791     else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
 792         int icoef;
 793         for (icoef = 0; icoef < tile_size; icoef++) {
 794             s->channel_residues[0][icoef] -= (unsigned)(s->channel_residues[1][icoef] >> 1);
 795             s->channel_residues[1][icoef] += (unsigned) s->channel_residues[0][icoef];
 796         }
 797     }
 798 }
 799
 800 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
 801 {
 802     int ich, pred, i, j;
 803     int16_t *filter_coeffs = s->acfilter_coeffs;
 804     int scaling            = s->acfilter_scaling;
 805     int order              = s->acfilter_order;
 806
 807     for (ich = 0; ich < s->num_channels; ich++) {
 808         int *prevvalues = s->acfilter_prevvalues[ich];
 809         for (i = 0; i < order; i++) {
 810             pred = 0;
 811             for (j = 0; j < order; j++) {
 812                 if (i <= j)
 813                     pred += (uint32_t)filter_coeffs[j] * prevvalues[j - i];
 814                 else
 815                     pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
 816             }
 817             pred >>= scaling;
 818             s->channel_residues[ich][i] += (unsigned)pred;
 819         }
 820         for (i = order; i < tile_size; i++) {
 821             pred = 0;
 822             for (j = 0; j < order; j++)
 823                 pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
 824             pred >>= scaling;
 825             s->channel_residues[ich][i] += (unsigned)pred;
 826         }
 827         for (j = order - 1; j >= 0; j--)
 828             if (tile_size <= j) {
 829                 prevvalues[j] = prevvalues[j - tile_size];
 830             }else
 831                 prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
 832     }
 833 }
 834
 835 static int decode_subframe(WmallDecodeCtx *s)
 836 {
 837     int offset        = s->samples_per_frame;
 838     int subframe_len  = s->samples_per_frame;
 839     int total_samples = s->samples_per_frame * s->num_channels;
 840     int i, j, rawpcm_tile, padding_zeroes, res;
 841
 842     s->subframe_offset = get_bits_count(&s->gb);
 843
 844     /* reset channel context and find the next block offset and size
 845         == the next block of the channel with the smallest number of
 846         decoded samples */
 847     for (i = 0; i < s->num_channels; i++) {
 848         if (offset > s->channel[i].decoded_samples) {
 849             offset = s->channel[i].decoded_samples;
 850             subframe_len =
 851                 s->channel[i].subframe_len[s->channel[i].cur_subframe];
 852         }
 853     }
 854
 855     /* get a list of all channels that contain the estimated block */
 856     s->channels_for_cur_subframe = 0;
 857     for (i = 0; i < s->num_channels; i++) {
 858         const int cur_subframe = s->channel[i].cur_subframe;
 859         /* subtract already processed samples */
 860         total_samples -= s->channel[i].decoded_samples;
 861
 862         /* and count if there are multiple subframes that match our profile */
 863         if (offset == s->channel[i].decoded_samples &&
 864             subframe_len == s->channel[i].subframe_len[cur_subframe]) {
 865             total_samples -= s->channel[i].subframe_len[cur_subframe];
 866             s->channel[i].decoded_samples +=
 867                 s->channel[i].subframe_len[cur_subframe];
 868             s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
 869             ++s->channels_for_cur_subframe;
 870         }
 871     }
 872
 873     /* check if the frame will be complete after processing the
 874         estimated block */
 875     if (!total_samples)
 876         s->parsed_all_subframes = 1;
 877
 878
 879     s->seekable_tile = get_bits1(&s->gb);
 880     if (s->seekable_tile) {
 881         clear_codec_buffers(s);
 882
 883         s->do_arith_coding    = get_bits1(&s->gb);
 884         if (s->do_arith_coding) {
 885             avpriv_request_sample(s->avctx, "Arithmetic coding");
 886             return AVERROR_PATCHWELCOME;
 887         }
 888         s->do_ac_filter       = get_bits1(&s->gb);
 889         s->do_inter_ch_decorr = get_bits1(&s->gb);
 890         s->do_mclms           = get_bits1(&s->gb);
 891
 892         if (s->do_ac_filter)
 893             decode_ac_filter(s);
 894
 895         if (s->do_mclms)
 896             decode_mclms(s);
 897
 898         if ((res = decode_cdlms(s)) < 0)
 899             return res;
 900         s->movave_scaling = get_bits(&s->gb, 3);
 901         s->quant_stepsize = get_bits(&s->gb, 8) + 1;
 902
 903         reset_codec(s);
 904     }
 905
 906     rawpcm_tile = get_bits1(&s->gb);
 907
 908     if (!rawpcm_tile && !s->cdlms[0][0].order) {
 909         av_log(s->avctx, AV_LOG_DEBUG,
 910                "Waiting for seekable tile\n");
 911         av_frame_unref(s->frame);
 912         return -1;
 913     }
 914
 915
 916     for (i = 0; i < s->num_channels; i++)
 917         s->is_channel_coded[i] = 1;
 918
 919     if (!rawpcm_tile) {
 920         for (i = 0; i < s->num_channels; i++)
 921             s->is_channel_coded[i] = get_bits1(&s->gb);
 922
 923         if (s->bV3RTM) {
 924             // LPC
 925             s->do_lpc = get_bits1(&s->gb);
 926             if (s->do_lpc) {
 927                 decode_lpc(s);
 928                 avpriv_request_sample(s->avctx, "Expect wrong output since "
 929                                       "inverse LPC filter");
 930             }
 931         } else
 932             s->do_lpc = 0;
 933     }
 934
 935     if (get_bits_left(&s->gb) < 1)
 936         return AVERROR_INVALIDDATA;
 937
 938     if (get_bits1(&s->gb))
 939         padding_zeroes = get_bits(&s->gb, 5);
 940     else
 941         padding_zeroes = 0;
 942
 943     if (rawpcm_tile) {
 944         int bits = s->bits_per_sample - padding_zeroes;
 945         if (bits <= 0) {
 946             av_log(s->avctx, AV_LOG_ERROR,
 947                    "Invalid number of padding bits in raw PCM tile\n");
 948             return AVERROR_INVALIDDATA;
 949         }
 950         ff_dlog(s->avctx, "RAWPCM %d bits per sample. "
 951                 "total %d bits, remain=%d\n", bits,
 952                 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
 953         for (i = 0; i < s->num_channels; i++)
 954             for (j = 0; j < subframe_len; j++)
 955                 s->channel_residues[i][j] = get_sbits_long(&s->gb, bits);
 956     } else {
 957         if (s->bits_per_sample < padding_zeroes)
 958             return AVERROR_INVALIDDATA;
 959         for (i = 0; i < s->num_channels; i++) {
 960             if (s->is_channel_coded[i]) {
 961                 decode_channel_residues(s, i, subframe_len);
 962                 if (s->seekable_tile)
 963                     use_high_update_speed(s, i);
 964                 else
 965                     use_normal_update_speed(s, i);
 966                 if (s->bits_per_sample > 16)
 967                     revert_cdlms32(s, i, 0, subframe_len);
 968                 else
 969                     revert_cdlms16(s, i, 0, subframe_len);
 970             } else {
 971                 memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
 972             }
 973         }
 974
 975         if (s->do_mclms)
 976             revert_mclms(s, subframe_len);
 977         if (s->do_inter_ch_decorr)
 978             revert_inter_ch_decorr(s, subframe_len);
 979         if (s->do_ac_filter)
 980             revert_acfilter(s, subframe_len);
 981
 982         /* Dequantize */
 983         if (s->quant_stepsize != 1)
 984             for (i = 0; i < s->num_channels; i++)
 985                 for (j = 0; j < subframe_len; j++)
 986                     s->channel_residues[i][j] *= (unsigned)s->quant_stepsize;
 987     }
 988
 989     /* Write to proper output buffer depending on bit-depth */
 990     for (i = 0; i < s->channels_for_cur_subframe; i++) {
 991         int c = s->channel_indexes_for_cur_subframe[i];
 992         int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
 993
 994         for (j = 0; j < subframe_len; j++) {
 995             if (s->bits_per_sample == 16) {
 996                 *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] * (1 << padding_zeroes);
 997             } else {
 998                 *s->samples_32[c]++ = s->channel_residues[c][j] * (256U << padding_zeroes);
 999             }
1000         }
1001     }
1002
1003     /* handled one subframe */
1004     for (i = 0; i < s->channels_for_cur_subframe; i++) {
1005         int c = s->channel_indexes_for_cur_subframe[i];
1006         if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1007             av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1008             return AVERROR_INVALIDDATA;
1009         }
1010         ++s->channel[c].cur_subframe;
1011     }
1012     return 0;
1013 }
1014
1015 /**
1016  * @brief Decode one WMA frame.
1017  * @param s codec context
1018  * @return 0 if the trailer bit indicates that this is the last frame,
1019  *         1 if there are additional frames
1020  */
1021 static int decode_frame(WmallDecodeCtx *s)
1022 {
1023     GetBitContext* gb = &s->gb;
1024     int more_frames = 0, len = 0, i, ret;
1025
1026     s->frame->nb_samples = s->samples_per_frame;
1027     if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1028         /* return an error if no frame could be decoded at all */
1029         s->packet_loss = 1;
1030         s->frame->nb_samples = 0;
1031         return ret;
1032     }
1033     for (i = 0; i < s->num_channels; i++) {
1034         s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1035         s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1036     }
1037
1038     /* get frame length */
1039     if (s->len_prefix)
1040         len = get_bits(gb, s->log2_frame_size);
1041
1042     /* decode tile information */
1043     if ((ret = decode_tilehdr(s))) {
1044         s->packet_loss = 1;
1045         av_frame_unref(s->frame);
1046         return ret;
1047     }
1048
1049     /* read drc info */
1050     if (s->dynamic_range_compression)
1051         s->drc_gain = get_bits(gb, 8);
1052
1053     /* no idea what these are for, might be the number of samples
1054        that need to be skipped at the beginning or end of a stream */
1055     if (get_bits1(gb)) {
1056         int av_unused skip;
1057
1058         /* usually true for the first frame */
1059         if (get_bits1(gb)) {
1060             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1061             ff_dlog(s->avctx, "start skip: %i\n", skip);
1062         }
1063
1064         /* sometimes true for the last frame */
1065         if (get_bits1(gb)) {
1066             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1067             ff_dlog(s->avctx, "end skip: %i\n", skip);
1068             s->frame->nb_samples -= skip;
1069             if (s->frame->nb_samples <= 0)
1070                 return AVERROR_INVALIDDATA;
1071         }
1072
1073     }
1074
1075     /* reset subframe states */
1076     s->parsed_all_subframes = 0;
1077     for (i = 0; i < s->num_channels; i++) {
1078         s->channel[i].decoded_samples = 0;
1079         s->channel[i].cur_subframe    = 0;
1080     }
1081
1082     /* decode all subframes */
1083     while (!s->parsed_all_subframes) {
1084         int decoded_samples = s->channel[0].decoded_samples;
1085         if (decode_subframe(s) < 0) {
1086             s->packet_loss = 1;
1087             if (s->frame->nb_samples)
1088                 s->frame->nb_samples = decoded_samples;
1089             return 0;
1090         }
1091     }
1092
1093     ff_dlog(s->avctx, "Frame done\n");
1094
1095     s->skip_frame = 0;
1096
1097     if (s->len_prefix) {
1098         if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1099             /* FIXME: not sure if this is always an error */
1100             av_log(s->avctx, AV_LOG_ERROR,
1101                    "frame[%"PRIu32"] would have to skip %i bits\n",
1102                    s->frame_num,
1103                    len - (get_bits_count(gb) - s->frame_offset) - 1);
1104             s->packet_loss = 1;
1105             return 0;
1106         }
1107
1108         /* skip the rest of the frame data */
1109         skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1110     }
1111
1112     /* decode trailer bit */
1113     more_frames = get_bits1(gb);
1114     ++s->frame_num;
1115     return more_frames;
1116 }
1117
1118 /**
1119  * @brief Calculate remaining input buffer length.
1120  * @param s  codec context
1121  * @param gb bitstream reader context
1122  * @return remaining size in bits
1123  */
1124 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1125 {
1126     return s->buf_bit_size - get_bits_count(gb);
1127 }
1128
1129 /**
1130  * @brief Fill the bit reservoir with a (partial) frame.
1131  * @param s      codec context
1132  * @param gb     bitstream reader context
1133  * @param len    length of the partial frame
1134  * @param append decides whether to reset the buffer or not
1135  */
1136 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1137                       int append)
1138 {
1139     int buflen;
1140     PutBitContext tmp;
1141
1142     /* when the frame data does not need to be concatenated, the input buffer
1143         is reset and additional bits from the previous frame are copied
1144         and skipped later so that a fast byte copy is possible */
1145
1146     if (!append) {
1147         s->frame_offset   = get_bits_count(gb) & 7;
1148         s->num_saved_bits = s->frame_offset;
1149         init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1150     }
1151
1152     buflen = (s->num_saved_bits + len + 8) >> 3;
1153
1154     if (len <= 0 || buflen > s->max_frame_size) {
1155         avpriv_request_sample(s->avctx, "Too small input buffer");
1156         s->packet_loss = 1;
1157         s->num_saved_bits = 0;
1158         return;
1159     }
1160
1161     s->num_saved_bits += len;
1162     if (!append) {
1163         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1164                          s->num_saved_bits);
1165     } else {
1166         int align = 8 - (get_bits_count(gb) & 7);
1167         align = FFMIN(align, len);
1168         put_bits(&s->pb, align, get_bits(gb, align));
1169         len -= align;
1170         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1171     }
1172     skip_bits_long(gb, len);
1173
1174     tmp = s->pb;
1175     flush_put_bits(&tmp);
1176
1177     init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1178     skip_bits(&s->gb, s->frame_offset);
1179 }
1180
1181 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1182                          AVPacket* avpkt)
1183 {
1184     WmallDecodeCtx *s = avctx->priv_data;
1185     GetBitContext* gb  = &s->pgb;
1186     const uint8_t* buf = avpkt->data;
1187     int buf_size       = avpkt->size;
1188     int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1189
1190     s->frame->nb_samples = 0;
1191
1192     if (!buf_size && s->num_saved_bits > get_bits_count(&s->gb)) {
1193         s->packet_done = 0;
1194         if (!decode_frame(s))
1195             s->num_saved_bits = 0;
1196     } else if (s->packet_done || s->packet_loss) {
1197         s->packet_done = 0;
1198
1199         if (!buf_size)
1200             return 0;
1201
1202         s->next_packet_start = buf_size - FFMIN(avctx->block_align, buf_size);
1203         buf_size             = FFMIN(avctx->block_align, buf_size);
1204         s->buf_bit_size      = buf_size << 3;
1205
1206         /* parse packet header */
1207         init_get_bits(gb, buf, s->buf_bit_size);
1208         packet_sequence_number = get_bits(gb, 4);
1209         skip_bits(gb, 1);   // Skip seekable_frame_in_packet, currently unused
1210         spliced_packet = get_bits1(gb);
1211         if (spliced_packet)
1212             avpriv_request_sample(avctx, "Bitstream splicing");
1213
1214         /* get number of bits that need to be added to the previous frame */
1215         num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1216
1217         /* check for packet loss */
1218         if (!s->packet_loss &&
1219             ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1220             s->packet_loss = 1;
1221             av_log(avctx, AV_LOG_ERROR,
1222                    "Packet loss detected! seq %"PRIx8" vs %x\n",
1223                    s->packet_sequence_number, packet_sequence_number);
1224         }
1225         s->packet_sequence_number = packet_sequence_number;
1226
1227         if (num_bits_prev_frame > 0) {
1228             int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1229             if (num_bits_prev_frame >= remaining_packet_bits) {
1230                 num_bits_prev_frame = remaining_packet_bits;
1231                 s->packet_done = 1;
1232             }
1233
1234             /* Append the previous frame data to the remaining data from the
1235              * previous packet to create a full frame. */
1236             save_bits(s, gb, num_bits_prev_frame, 1);
1237
1238             /* decode the cross packet frame if it is valid */
1239             if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1240                 decode_frame(s);
1241         } else if (s->num_saved_bits - s->frame_offset) {
1242             ff_dlog(avctx, "ignoring %x previously saved bits\n",
1243                     s->num_saved_bits - s->frame_offset);
1244         }
1245
1246         if (s->packet_loss) {
1247             /* Reset number of saved bits so that the decoder does not start
1248              * to decode incomplete frames in the s->len_prefix == 0 case. */
1249             s->num_saved_bits = 0;
1250             s->packet_loss    = 0;
1251             init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1252         }
1253
1254     } else {
1255         int frame_size;
1256
1257         s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1258         init_get_bits(gb, avpkt->data, s->buf_bit_size);
1259         skip_bits(gb, s->packet_offset);
1260
1261         if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1262             (frame_size = show_bits(gb, s->log2_frame_size)) &&
1263             frame_size <= remaining_bits(s, gb)) {
1264             save_bits(s, gb, frame_size, 0);
1265
1266             if (!s->packet_loss)
1267                 s->packet_done = !decode_frame(s);
1268         } else if (!s->len_prefix
1269                    && s->num_saved_bits > get_bits_count(&s->gb)) {
1270             /* when the frames do not have a length prefix, we don't know the
1271              * compressed length of the individual frames however, we know what
1272              * part of a new packet belongs to the previous frame therefore we
1273              * save the incoming packet first, then we append the "previous
1274              * frame" data from the next packet so that we get a buffer that
1275              * only contains full frames */
1276             s->packet_done = !decode_frame(s);
1277         } else {
1278             s->packet_done = 1;
1279         }
1280     }
1281
1282     if (remaining_bits(s, gb) < 0) {
1283         av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1284         s->packet_loss = 1;
1285     }
1286
1287     if (s->packet_done && !s->packet_loss &&
1288         remaining_bits(s, gb) > 0) {
1289         /* save the rest of the data so that it can be decoded
1290          * with the next packet */
1291         save_bits(s, gb, remaining_bits(s, gb), 0);
1292     }
1293
1294     *got_frame_ptr   = s->frame->nb_samples > 0;
1295     av_frame_move_ref(data, s->frame);
1296
1297     s->packet_offset = get_bits_count(gb) & 7;
1298
1299     return (s->packet_loss) ? AVERROR_INVALIDDATA : buf_size ? get_bits_count(gb) >> 3 : 0;
1300 }
1301
1302 static void flush(AVCodecContext *avctx)
1303 {
1304     WmallDecodeCtx *s    = avctx->priv_data;
1305     s->packet_loss       = 1;
1306     s->packet_done       = 0;
1307     s->num_saved_bits    = 0;
1308     s->frame_offset      = 0;
1309     s->next_packet_start = 0;
1310     s->cdlms[0][0].order = 0;
1311     s->frame->nb_samples = 0;
1312     init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1313 }
1314
1315 static av_cold int decode_close(AVCodecContext *avctx)
1316 {
1317     WmallDecodeCtx *s = avctx->priv_data;
1318
1319     av_frame_free(&s->frame);
1320     av_freep(&s->frame_data);
1321
1322     return 0;
1323 }
1324
1325 AVCodec ff_wmalossless_decoder = {
1326     .name           = "wmalossless",
1327     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1328     .type           = AVMEDIA_TYPE_AUDIO,
1329     .id             = AV_CODEC_ID_WMALOSSLESS,
1330     .priv_data_size = sizeof(WmallDecodeCtx),
1331     .init           = decode_init,
1332     .close          = decode_close,
1333     .decode         = decode_packet,
1334     .flush          = flush,
1335     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1336     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
1337     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1338                                                       AV_SAMPLE_FMT_S32P,
1339                                                       AV_SAMPLE_FMT_NONE },
1340 };