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