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