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