git.sesse.net Git - ffmpeg/blob - libavcodec/wavpack.c

   1 /*
   2  * WavPack lossless audio decoder
   3  * Copyright (c) 2006,2011 Konstantin Shishkov
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #define BITSTREAM_READER_LE
  23
  24 #include "libavutil/audioconvert.h"
  25 #include "avcodec.h"
  26 #include "get_bits.h"
  27 #include "unary.h"
  28
  29 /**
  30  * @file
  31  * WavPack lossless audio decoder
  32  */
  33
  34 #define WV_MONO           0x00000004
  35 #define WV_JOINT_STEREO   0x00000010
  36 #define WV_FALSE_STEREO   0x40000000
  37
  38 #define WV_HYBRID_MODE    0x00000008
  39 #define WV_HYBRID_SHAPE   0x00000008
  40 #define WV_HYBRID_BITRATE 0x00000200
  41 #define WV_HYBRID_BALANCE 0x00000400
  42
  43 #define WV_FLT_SHIFT_ONES 0x01
  44 #define WV_FLT_SHIFT_SAME 0x02
  45 #define WV_FLT_SHIFT_SENT 0x04
  46 #define WV_FLT_ZERO_SENT  0x08
  47 #define WV_FLT_ZERO_SIGN  0x10
  48
  49 enum WP_ID_Flags {
  50     WP_IDF_MASK   = 0x1F,
  51     WP_IDF_IGNORE = 0x20,
  52     WP_IDF_ODD    = 0x40,
  53     WP_IDF_LONG   = 0x80
  54 };
  55
  56 enum WP_ID {
  57     WP_ID_DUMMY = 0,
  58     WP_ID_ENCINFO,
  59     WP_ID_DECTERMS,
  60     WP_ID_DECWEIGHTS,
  61     WP_ID_DECSAMPLES,
  62     WP_ID_ENTROPY,
  63     WP_ID_HYBRID,
  64     WP_ID_SHAPING,
  65     WP_ID_FLOATINFO,
  66     WP_ID_INT32INFO,
  67     WP_ID_DATA,
  68     WP_ID_CORR,
  69     WP_ID_EXTRABITS,
  70     WP_ID_CHANINFO
  71 };
  72
  73 typedef struct SavedContext {
  74     int offset;
  75     int size;
  76     int bits_used;
  77     uint32_t crc;
  78 } SavedContext;
  79
  80 #define MAX_TERMS 16
  81
  82 typedef struct Decorr {
  83     int delta;
  84     int value;
  85     int weightA;
  86     int weightB;
  87     int samplesA[8];
  88     int samplesB[8];
  89 } Decorr;
  90
  91 typedef struct WvChannel {
  92     int median[3];
  93     int slow_level, error_limit;
  94     int bitrate_acc, bitrate_delta;
  95 } WvChannel;
  96
  97 typedef struct WavpackFrameContext {
  98     AVCodecContext *avctx;
  99     int frame_flags;
 100     int stereo, stereo_in;
 101     int joint;
 102     uint32_t CRC;
 103     GetBitContext gb;
 104     int got_extra_bits;
 105     uint32_t crc_extra_bits;
 106     GetBitContext gb_extra_bits;
 107     int data_size; // in bits
 108     int samples;
 109     int terms;
 110     Decorr decorr[MAX_TERMS];
 111     int zero, one, zeroes;
 112     int extra_bits;
 113     int and, or, shift;
 114     int post_shift;
 115     int hybrid, hybrid_bitrate, hybrid_maxclip;
 116     int float_flag;
 117     int float_shift;
 118     int float_max_exp;
 119     WvChannel ch[2];
 120     int pos;
 121     SavedContext sc, extra_sc;
 122 } WavpackFrameContext;
 123
 124 #define WV_MAX_FRAME_DECODERS 14
 125
 126 typedef struct WavpackContext {
 127     AVCodecContext *avctx;
 128     AVFrame frame;
 129
 130     WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
 131     int fdec_num;
 132
 133     int multichannel;
 134     int mkv_mode;
 135     int block;
 136     int samples;
 137     int ch_offset;
 138 } WavpackContext;
 139
 140 // exponent table copied from WavPack source
 141 static const uint8_t wp_exp2_table [256] = {
 142     0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
 143     0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
 144     0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
 145     0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
 146     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
 147     0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
 148     0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
 149     0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
 150     0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
 151     0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
 152     0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
 153     0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
 154     0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
 155     0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
 156     0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
 157     0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
 158 };
 159
 160 static const uint8_t wp_log2_table [] = {
 161     0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
 162     0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
 163     0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
 164     0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
 165     0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
 166     0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
 167     0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
 168     0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
 169     0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
 170     0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
 171     0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
 172     0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
 173     0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
 174     0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
 175     0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
 176     0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
 177 };
 178
 179 static av_always_inline int wp_exp2(int16_t val)
 180 {
 181     int res, neg = 0;
 182
 183     if (val < 0) {
 184         val = -val;
 185         neg = 1;
 186     }
 187
 188     res = wp_exp2_table[val & 0xFF] | 0x100;
 189     val >>= 8;
 190     res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
 191     return neg ? -res : res;
 192 }
 193
 194 static av_always_inline int wp_log2(int32_t val)
 195 {
 196     int bits;
 197
 198     if (!val)
 199         return 0;
 200     if (val == 1)
 201         return 256;
 202     val += val >> 9;
 203     bits = av_log2(val) + 1;
 204     if (bits < 9)
 205         return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
 206     else
 207         return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
 208 }
 209
 210 #define LEVEL_DECAY(a)  ((a + 0x80) >> 8)
 211
 212 // macros for manipulating median values
 213 #define GET_MED(n) ((c->median[n] >> 4) + 1)
 214 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2
 215 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n)    ) / (128 >> n)) * 5
 216
 217 // macros for applying weight
 218 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
 219     if (samples && in) { \
 220         if ((samples ^ in) < 0) { \
 221             weight -= delta; \
 222             if (weight < -1024) \
 223                 weight = -1024; \
 224         } else { \
 225             weight += delta; \
 226             if (weight > 1024) \
 227                 weight = 1024; \
 228         } \
 229     }
 230
 231
 232 static av_always_inline int get_tail(GetBitContext *gb, int k)
 233 {
 234     int p, e, res;
 235
 236     if (k < 1)
 237         return 0;
 238     p = av_log2(k);
 239     e = (1 << (p + 1)) - k - 1;
 240     res = p ? get_bits(gb, p) : 0;
 241     if (res >= e)
 242         res = (res << 1) - e + get_bits1(gb);
 243     return res;
 244 }
 245
 246 static void update_error_limit(WavpackFrameContext *ctx)
 247 {
 248     int i, br[2], sl[2];
 249
 250     for (i = 0; i <= ctx->stereo_in; i++) {
 251         ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
 252         br[i] = ctx->ch[i].bitrate_acc >> 16;
 253         sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
 254     }
 255     if (ctx->stereo_in && ctx->hybrid_bitrate) {
 256         int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
 257         if (balance > br[0]) {
 258             br[1] = br[0] << 1;
 259             br[0] = 0;
 260         } else if (-balance > br[0]) {
 261             br[0] <<= 1;
 262             br[1] = 0;
 263         } else {
 264             br[1] = br[0] + balance;
 265             br[0] = br[0] - balance;
 266         }
 267     }
 268     for (i = 0; i <= ctx->stereo_in; i++) {
 269         if (ctx->hybrid_bitrate) {
 270             if (sl[i] - br[i] > -0x100)
 271                 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
 272             else
 273                 ctx->ch[i].error_limit = 0;
 274         } else {
 275             ctx->ch[i].error_limit = wp_exp2(br[i]);
 276         }
 277     }
 278 }
 279
 280 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
 281                         int channel, int *last)
 282 {
 283     int t, t2;
 284     int sign, base, add, ret;
 285     WvChannel *c = &ctx->ch[channel];
 286
 287     *last = 0;
 288
 289     if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&
 290         !ctx->zero && !ctx->one) {
 291         if (ctx->zeroes) {
 292             ctx->zeroes--;
 293             if (ctx->zeroes) {
 294                 c->slow_level -= LEVEL_DECAY(c->slow_level);
 295                 return 0;
 296             }
 297         } else {
 298             t = get_unary_0_33(gb);
 299             if (t >= 2) {
 300                 if (get_bits_left(gb) < t - 1)
 301                     goto error;
 302                 t = get_bits(gb, t - 1) | (1 << (t-1));
 303             } else {
 304                 if (get_bits_left(gb) < 0)
 305                     goto error;
 306             }
 307             ctx->zeroes = t;
 308             if (ctx->zeroes) {
 309                 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
 310                 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
 311                 c->slow_level -= LEVEL_DECAY(c->slow_level);
 312                 return 0;
 313             }
 314         }
 315     }
 316
 317     if (ctx->zero) {
 318         t = 0;
 319         ctx->zero = 0;
 320     } else {
 321         t = get_unary_0_33(gb);
 322         if (get_bits_left(gb) < 0)
 323             goto error;
 324         if (t == 16) {
 325             t2 = get_unary_0_33(gb);
 326             if (t2 < 2) {
 327                 if (get_bits_left(gb) < 0)
 328                     goto error;
 329                 t += t2;
 330             } else {
 331                 if (get_bits_left(gb) < t2 - 1)
 332                     goto error;
 333                 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
 334             }
 335         }
 336
 337         if (ctx->one) {
 338             ctx->one = t & 1;
 339             t = (t >> 1) + 1;
 340         } else {
 341             ctx->one = t & 1;
 342             t >>= 1;
 343         }
 344         ctx->zero = !ctx->one;
 345     }
 346
 347     if (ctx->hybrid && !channel)
 348         update_error_limit(ctx);
 349
 350     if (!t) {
 351         base = 0;
 352         add  = GET_MED(0) - 1;
 353         DEC_MED(0);
 354     } else if (t == 1) {
 355         base = GET_MED(0);
 356         add  = GET_MED(1) - 1;
 357         INC_MED(0);
 358         DEC_MED(1);
 359     } else if (t == 2) {
 360         base = GET_MED(0) + GET_MED(1);
 361         add  = GET_MED(2) - 1;
 362         INC_MED(0);
 363         INC_MED(1);
 364         DEC_MED(2);
 365     } else {
 366         base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
 367         add  = GET_MED(2) - 1;
 368         INC_MED(0);
 369         INC_MED(1);
 370         INC_MED(2);
 371     }
 372     if (!c->error_limit) {
 373         ret = base + get_tail(gb, add);
 374         if (get_bits_left(gb) <= 0)
 375             goto error;
 376     } else {
 377         int mid = (base * 2 + add + 1) >> 1;
 378         while (add > c->error_limit) {
 379             if (get_bits_left(gb) <= 0)
 380                 goto error;
 381             if (get_bits1(gb)) {
 382                 add -= (mid - base);
 383                 base = mid;
 384             } else
 385                 add = mid - base - 1;
 386             mid = (base * 2 + add + 1) >> 1;
 387         }
 388         ret = mid;
 389     }
 390     sign = get_bits1(gb);
 391     if (ctx->hybrid_bitrate)
 392         c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
 393     return sign ? ~ret : ret;
 394
 395 error:
 396     *last = 1;
 397     return 0;
 398 }
 399
 400 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
 401                                        int S)
 402 {
 403     int bit;
 404
 405     if (s->extra_bits){
 406         S <<= s->extra_bits;
 407
 408         if (s->got_extra_bits && get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {
 409             S |= get_bits(&s->gb_extra_bits, s->extra_bits);
 410             *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);
 411         }
 412     }
 413
 414     bit = (S & s->and) | s->or;
 415     bit = (((S + bit) << s->shift) - bit);
 416
 417     if (s->hybrid)
 418         bit = av_clip(bit, -s->hybrid_maxclip - 1, s->hybrid_maxclip);
 419
 420     return bit << s->post_shift;
 421 }
 422
 423 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
 424 {
 425     union {
 426         float    f;
 427         uint32_t u;
 428     } value;
 429
 430     int sign;
 431     int exp = s->float_max_exp;
 432
 433     if (s->got_extra_bits) {
 434         const int max_bits  = 1 + 23 + 8 + 1;
 435         const int left_bits = get_bits_left(&s->gb_extra_bits);
 436
 437         if (left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
 438             return 0.0;
 439     }
 440
 441     if (S) {
 442         S <<= s->float_shift;
 443         sign = S < 0;
 444         if (sign)
 445             S = -S;
 446         if (S >= 0x1000000) {
 447             if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))
 448                 S = get_bits(&s->gb_extra_bits, 23);
 449             else
 450                 S = 0;
 451             exp = 255;
 452         } else if (exp) {
 453             int shift = 23 - av_log2(S);
 454             exp = s->float_max_exp;
 455             if (exp <= shift)
 456                 shift = --exp;
 457             exp -= shift;
 458
 459             if (shift) {
 460                 S <<= shift;
 461                 if ((s->float_flag & WV_FLT_SHIFT_ONES) ||
 462                     (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) &&
 463                      get_bits1(&s->gb_extra_bits))) {
 464                     S |= (1 << shift) - 1;
 465                 } else if (s->got_extra_bits &&
 466                            (s->float_flag & WV_FLT_SHIFT_SENT)) {
 467                     S |= get_bits(&s->gb_extra_bits, shift);
 468                 }
 469             }
 470         } else {
 471             exp = s->float_max_exp;
 472         }
 473         S &= 0x7fffff;
 474     } else {
 475         sign = 0;
 476         exp = 0;
 477         if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {
 478             if (get_bits1(&s->gb_extra_bits)) {
 479                 S = get_bits(&s->gb_extra_bits, 23);
 480                 if (s->float_max_exp >= 25)
 481                     exp = get_bits(&s->gb_extra_bits, 8);
 482                 sign = get_bits1(&s->gb_extra_bits);
 483             } else {
 484                 if (s->float_flag & WV_FLT_ZERO_SIGN)
 485                     sign = get_bits1(&s->gb_extra_bits);
 486             }
 487         }
 488     }
 489
 490     *crc = *crc * 27 + S * 9 + exp * 3 + sign;
 491
 492     value.u = (sign << 31) | (exp << 23) | S;
 493     return value.f;
 494 }
 495
 496 static void wv_reset_saved_context(WavpackFrameContext *s)
 497 {
 498     s->pos = 0;
 499     s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
 500 }
 501
 502 static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc,
 503                                uint32_t crc_extra_bits)
 504 {
 505     if (crc != s->CRC) {
 506         av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
 507         return AVERROR_INVALIDDATA;
 508     }
 509     if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
 510         av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 511         return AVERROR_INVALIDDATA;
 512     }
 513
 514     return 0;
 515 }
 516
 517 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
 518                                    void *dst, const int type)
 519 {
 520     int i, j, count = 0;
 521     int last, t;
 522     int A, B, L, L2, R, R2;
 523     int pos = s->pos;
 524     uint32_t crc = s->sc.crc;
 525     uint32_t crc_extra_bits = s->extra_sc.crc;
 526     int16_t *dst16 = dst;
 527     int32_t *dst32 = dst;
 528     float   *dstfl = dst;
 529     const int channel_pad = s->avctx->channels - 2;
 530
 531     s->one = s->zero = s->zeroes = 0;
 532     do {
 533         L = wv_get_value(s, gb, 0, &last);
 534         if (last)
 535             break;
 536         R = wv_get_value(s, gb, 1, &last);
 537         if (last)
 538             break;
 539         for (i = 0; i < s->terms; i++) {
 540             t = s->decorr[i].value;
 541             if (t > 0) {
 542                 if (t > 8) {
 543                     if (t & 1) {
 544                         A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 545                         B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
 546                     } else {
 547                         A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 548                         B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
 549                     }
 550                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 551                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
 552                     j = 0;
 553                 } else {
 554                     A = s->decorr[i].samplesA[pos];
 555                     B = s->decorr[i].samplesB[pos];
 556                     j = (pos + t) & 7;
 557                 }
 558                 if (type != AV_SAMPLE_FMT_S16) {
 559                     L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 560                     R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
 561                 } else {
 562                     L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
 563                     R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
 564                 }
 565                 if (A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 566                 if (B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
 567                 s->decorr[i].samplesA[j] = L = L2;
 568                 s->decorr[i].samplesB[j] = R = R2;
 569             } else if (t == -1) {
 570                 if (type != AV_SAMPLE_FMT_S16)
 571                     L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
 572                 else
 573                     L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
 574                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
 575                 L = L2;
 576                 if (type != AV_SAMPLE_FMT_S16)
 577                     R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
 578                 else
 579                     R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
 580                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
 581                 R = R2;
 582                 s->decorr[i].samplesA[0] = R;
 583             } else {
 584                 if (type != AV_SAMPLE_FMT_S16)
 585                     R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
 586                 else
 587                     R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
 588                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
 589                 R = R2;
 590
 591                 if (t == -3) {
 592                     R2 = s->decorr[i].samplesA[0];
 593                     s->decorr[i].samplesA[0] = R;
 594                 }
 595
 596                 if (type != AV_SAMPLE_FMT_S16)
 597                     L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
 598                 else
 599                     L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
 600                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
 601                 L = L2;
 602                 s->decorr[i].samplesB[0] = L;
 603             }
 604         }
 605         pos = (pos + 1) & 7;
 606         if (s->joint)
 607             L += (R -= (L >> 1));
 608         crc = (crc * 3 + L) * 3 + R;
 609
 610         if (type == AV_SAMPLE_FMT_FLT) {
 611             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
 612             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
 613             dstfl += channel_pad;
 614         } else if (type == AV_SAMPLE_FMT_S32) {
 615             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
 616             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
 617             dst32 += channel_pad;
 618         } else {
 619             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
 620             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
 621             dst16 += channel_pad;
 622         }
 623         count++;
 624     } while (!last && count < s->samples);
 625
 626     wv_reset_saved_context(s);
 627     if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
 628         wv_check_crc(s, crc, crc_extra_bits))
 629         return AVERROR_INVALIDDATA;
 630
 631     return count * 2;
 632 }
 633
 634 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
 635                                  void *dst, const int type)
 636 {
 637     int i, j, count = 0;
 638     int last, t;
 639     int A, S, T;
 640     int pos = s->pos;
 641     uint32_t crc = s->sc.crc;
 642     uint32_t crc_extra_bits = s->extra_sc.crc;
 643     int16_t *dst16 = dst;
 644     int32_t *dst32 = dst;
 645     float   *dstfl = dst;
 646     const int channel_stride = s->avctx->channels;
 647
 648     s->one = s->zero = s->zeroes = 0;
 649     do {
 650         T = wv_get_value(s, gb, 0, &last);
 651         S = 0;
 652         if (last)
 653             break;
 654         for (i = 0; i < s->terms; i++) {
 655             t = s->decorr[i].value;
 656             if (t > 8) {
 657                 if (t & 1)
 658                     A =  2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 659                 else
 660                     A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 661                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 662                 j = 0;
 663             } else {
 664                 A = s->decorr[i].samplesA[pos];
 665                 j = (pos + t) & 7;
 666             }
 667             if (type != AV_SAMPLE_FMT_S16)
 668                 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 669             else
 670                 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
 671             if (A && T)
 672                 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 673             s->decorr[i].samplesA[j] = T = S;
 674         }
 675         pos = (pos + 1) & 7;
 676         crc = crc * 3 + S;
 677
 678         if (type == AV_SAMPLE_FMT_FLT) {
 679             *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
 680             dstfl += channel_stride;
 681         } else if (type == AV_SAMPLE_FMT_S32) {
 682             *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
 683             dst32 += channel_stride;
 684         } else {
 685             *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
 686             dst16 += channel_stride;
 687         }
 688         count++;
 689     } while (!last && count < s->samples);
 690
 691     wv_reset_saved_context(s);
 692     if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
 693         wv_check_crc(s, crc, crc_extra_bits))
 694         return AVERROR_INVALIDDATA;
 695
 696     return count;
 697 }
 698
 699 static av_cold int wv_alloc_frame_context(WavpackContext *c)
 700 {
 701
 702     if (c->fdec_num == WV_MAX_FRAME_DECODERS)
 703         return -1;
 704
 705     c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
 706     if (!c->fdec[c->fdec_num])
 707         return -1;
 708     c->fdec_num++;
 709     c->fdec[c->fdec_num - 1]->avctx = c->avctx;
 710     wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
 711
 712     return 0;
 713 }
 714
 715 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
 716 {
 717     WavpackContext *s = avctx->priv_data;
 718
 719     s->avctx = avctx;
 720     if (avctx->bits_per_coded_sample <= 16)
 721         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 722     else
 723         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 724     if (avctx->channels <= 2 && !avctx->channel_layout)
 725         avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO :
 726                                                          AV_CH_LAYOUT_MONO;
 727
 728     s->multichannel = avctx->channels > 2;
 729     /* lavf demuxer does not provide extradata, Matroska stores 0x403
 730        there, use this to detect decoding mode for multichannel */
 731     s->mkv_mode = 0;
 732     if (s->multichannel && avctx->extradata && avctx->extradata_size == 2) {
 733         int ver = AV_RL16(avctx->extradata);
 734         if (ver >= 0x402 && ver <= 0x410)
 735             s->mkv_mode = 1;
 736     }
 737
 738     s->fdec_num = 0;
 739
 740     avcodec_get_frame_defaults(&s->frame);
 741     avctx->coded_frame = &s->frame;
 742
 743     return 0;
 744 }
 745
 746 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
 747 {
 748     WavpackContext *s = avctx->priv_data;
 749     int i;
 750
 751     for (i = 0; i < s->fdec_num; i++)
 752         av_freep(&s->fdec[i]);
 753     s->fdec_num = 0;
 754
 755     return 0;
 756 }
 757
 758 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
 759                                 void *data, int *got_frame_ptr,
 760                                 const uint8_t *buf, int buf_size)
 761 {
 762     WavpackContext *wc = avctx->priv_data;
 763     WavpackFrameContext *s;
 764     void *samples = data;
 765     int samplecount;
 766     int got_terms   = 0, got_weights = 0, got_samples = 0,
 767         got_entropy = 0, got_bs      = 0, got_float   = 0, got_hybrid = 0;
 768     const uint8_t *orig_buf = buf;
 769     const uint8_t *buf_end  = buf + buf_size;
 770     int i, j, id, size, ssize, weights, t;
 771     int bpp, chan, chmask;
 772
 773     if (buf_size == 0) {
 774         *got_frame_ptr = 0;
 775         return 0;
 776     }
 777
 778     if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
 779         av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
 780         return -1;
 781     }
 782
 783     s = wc->fdec[block_no];
 784     if (!s) {
 785         av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
 786         return -1;
 787     }
 788
 789     memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
 790     memset(s->ch, 0, sizeof(s->ch));
 791     s->extra_bits = 0;
 792     s->and = s->or = s->shift = 0;
 793     s->got_extra_bits = 0;
 794
 795     if (!wc->mkv_mode) {
 796         s->samples = AV_RL32(buf); buf += 4;
 797         if (!s->samples) {
 798             *got_frame_ptr = 0;
 799             return 0;
 800         }
 801     } else {
 802         s->samples = wc->samples;
 803     }
 804     s->frame_flags = AV_RL32(buf); buf += 4;
 805     bpp = av_get_bytes_per_sample(avctx->sample_fmt);
 806     samples = (uint8_t*)samples + bpp * wc->ch_offset;
 807
 808     s->stereo         = !(s->frame_flags & WV_MONO);
 809     s->stereo_in      =  (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
 810     s->joint          =   s->frame_flags & WV_JOINT_STEREO;
 811     s->hybrid         =   s->frame_flags & WV_HYBRID_MODE;
 812     s->hybrid_bitrate =   s->frame_flags & WV_HYBRID_BITRATE;
 813     s->hybrid_maxclip = (1LL << ((((s->frame_flags & 0x03) + 1) << 3) - 1)) - 1;
 814     s->post_shift     = 8 * (bpp - 1 - (s->frame_flags & 0x03)) +
 815                         ((s->frame_flags >> 13) & 0x1f);
 816     s->CRC            = AV_RL32(buf); buf += 4;
 817     if (wc->mkv_mode)
 818         buf += 4; //skip block size;
 819
 820     wc->ch_offset += 1 + s->stereo;
 821
 822     // parse metadata blocks
 823     while (buf < buf_end) {
 824         id   = *buf++;
 825         size = *buf++;
 826         if (id & WP_IDF_LONG) {
 827             size |= (*buf++) << 8;
 828             size |= (*buf++) << 16;
 829         }
 830         size <<= 1; // size is specified in words
 831         ssize = size;
 832         if (id & WP_IDF_ODD)
 833             size--;
 834         if (size < 0) {
 835             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
 836             break;
 837         }
 838         if (buf + ssize > buf_end) {
 839             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
 840             break;
 841         }
 842         if (id & WP_IDF_IGNORE) {
 843             buf += ssize;
 844             continue;
 845         }
 846         switch (id & WP_IDF_MASK) {
 847         case WP_ID_DECTERMS:
 848             if (size > MAX_TERMS) {
 849                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
 850                 s->terms = 0;
 851                 buf += ssize;
 852                 continue;
 853             }
 854             s->terms = size;
 855             for (i = 0; i < s->terms; i++) {
 856                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
 857                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
 858                 buf++;
 859             }
 860             got_terms = 1;
 861             break;
 862         case WP_ID_DECWEIGHTS:
 863             if (!got_terms) {
 864                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 865                 continue;
 866             }
 867             weights = size >> s->stereo_in;
 868             if (weights > MAX_TERMS || weights > s->terms) {
 869                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
 870                 buf += ssize;
 871                 continue;
 872             }
 873             for (i = 0; i < weights; i++) {
 874                 t = (int8_t)(*buf++);
 875                 s->decorr[s->terms - i - 1].weightA = t << 3;
 876                 if (s->decorr[s->terms - i - 1].weightA > 0)
 877                     s->decorr[s->terms - i - 1].weightA +=
 878                             (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
 879                 if (s->stereo_in) {
 880                     t = (int8_t)(*buf++);
 881                     s->decorr[s->terms - i - 1].weightB = t << 3;
 882                     if (s->decorr[s->terms - i - 1].weightB > 0)
 883                         s->decorr[s->terms - i - 1].weightB +=
 884                                 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
 885                 }
 886             }
 887             got_weights = 1;
 888             break;
 889         case WP_ID_DECSAMPLES:
 890             if (!got_terms) {
 891                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 892                 continue;
 893             }
 894             t = 0;
 895             for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
 896                 if (s->decorr[i].value > 8) {
 897                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 898                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 899                     if (s->stereo_in) {
 900                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 901                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 902                         t += 4;
 903                     }
 904                     t += 4;
 905                 } else if (s->decorr[i].value < 0) {
 906                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 907                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 908                     t += 4;
 909                 } else {
 910                     for (j = 0; j < s->decorr[i].value; j++) {
 911                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 912                         if (s->stereo_in) {
 913                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 914                         }
 915                     }
 916                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
 917                 }
 918             }
 919             got_samples = 1;
 920             break;
 921         case WP_ID_ENTROPY:
 922             if (size != 6 * (s->stereo_in + 1)) {
 923                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, "
 924                        "got %i", 6 * (s->stereo_in + 1), size);
 925                 buf += ssize;
 926                 continue;
 927             }
 928             for (j = 0; j <= s->stereo_in; j++) {
 929                 for (i = 0; i < 3; i++) {
 930                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
 931                     buf += 2;
 932                 }
 933             }
 934             got_entropy = 1;
 935             break;
 936         case WP_ID_HYBRID:
 937             if (s->hybrid_bitrate) {
 938                 for (i = 0; i <= s->stereo_in; i++) {
 939                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
 940                     buf += 2;
 941                     size -= 2;
 942                 }
 943             }
 944             for (i = 0; i < (s->stereo_in + 1); i++) {
 945                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
 946                 buf += 2;
 947                 size -= 2;
 948             }
 949             if (size > 0) {
 950                 for (i = 0; i < (s->stereo_in + 1); i++) {
 951                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
 952                     buf += 2;
 953                 }
 954             } else {
 955                 for (i = 0; i < (s->stereo_in + 1); i++)
 956                     s->ch[i].bitrate_delta = 0;
 957             }
 958             got_hybrid = 1;
 959             break;
 960         case WP_ID_INT32INFO:
 961             if (size != 4) {
 962                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
 963                 buf += ssize;
 964                 continue;
 965             }
 966             if (buf[0])
 967                 s->extra_bits = buf[0];
 968             else if (buf[1])
 969                 s->shift = buf[1];
 970             else if (buf[2]){
 971                 s->and = s->or = 1;
 972                 s->shift = buf[2];
 973             } else if(buf[3]) {
 974                 s->and   = 1;
 975                 s->shift = buf[3];
 976             }
 977             buf += 4;
 978             break;
 979         case WP_ID_FLOATINFO:
 980             if (size != 4) {
 981                 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
 982                 buf += ssize;
 983                 continue;
 984             }
 985             s->float_flag    = buf[0];
 986             s->float_shift   = buf[1];
 987             s->float_max_exp = buf[2];
 988             buf += 4;
 989             got_float = 1;
 990             break;
 991         case WP_ID_DATA:
 992             s->sc.offset = buf - orig_buf;
 993             s->sc.size   = size * 8;
 994             init_get_bits(&s->gb, buf, size * 8);
 995             s->data_size = size * 8;
 996             buf += size;
 997             got_bs = 1;
 998             break;
 999         case WP_ID_EXTRABITS:
1000             if (size <= 4) {
1001                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1002                        size);
1003                 buf += size;
1004                 continue;
1005             }
1006             s->extra_sc.offset = buf - orig_buf;
1007             s->extra_sc.size   = size * 8;
1008             init_get_bits(&s->gb_extra_bits, buf, size * 8);
1009             s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1010             buf += size;
1011             s->got_extra_bits = 1;
1012             break;
1013         case WP_ID_CHANINFO:
1014             if (size <= 1) {
1015                 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1016                 return -1;
1017             }
1018             chan = *buf++;
1019             switch (size - 2) {
1020             case 0: chmask = *buf;         break;
1021             case 1: chmask = AV_RL16(buf); break;
1022             case 2: chmask = AV_RL24(buf); break;
1023             case 3: chmask = AV_RL32(buf); break;
1024             case 5:
1025                 chan |= (buf[1] & 0xF) << 8;
1026                 chmask = AV_RL24(buf + 2);
1027                 break;
1028             default:
1029                 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1030                        size);
1031                 chan   = avctx->channels;
1032                 chmask = avctx->channel_layout;
1033             }
1034             if (chan != avctx->channels) {
1035                 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, "
1036                        "decoder believes it's %d channels\n", chan,
1037                        avctx->channels);
1038                 return -1;
1039             }
1040             if (!avctx->channel_layout)
1041                 avctx->channel_layout = chmask;
1042             buf += size - 1;
1043             break;
1044         default:
1045             buf += size;
1046         }
1047         if (id & WP_IDF_ODD)
1048             buf++;
1049     }
1050
1051     if (!got_terms) {
1052         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1053         return -1;
1054     }
1055     if (!got_weights) {
1056         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1057         return -1;
1058     }
1059     if (!got_samples) {
1060         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1061         return -1;
1062     }
1063     if (!got_entropy) {
1064         av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1065         return -1;
1066     }
1067     if (s->hybrid && !got_hybrid) {
1068         av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1069         return -1;
1070     }
1071     if (!got_bs) {
1072         av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1073         return -1;
1074     }
1075     if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1076         av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1077         return -1;
1078     }
1079     if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT) {
1080         const int size   = get_bits_left(&s->gb_extra_bits);
1081         const int wanted = s->samples * s->extra_bits << s->stereo_in;
1082         if (size < wanted) {
1083             av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1084             s->got_extra_bits = 0;
1085         }
1086     }
1087
1088     if (s->stereo_in) {
1089         if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1090             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1091         else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1092             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1093         else
1094             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1095
1096         if (samplecount < 0)
1097             return -1;
1098
1099         samplecount >>= 1;
1100     } else {
1101         const int channel_stride = avctx->channels;
1102
1103         if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1104             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1105         else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1106             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1107         else
1108             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1109
1110         if (samplecount < 0)
1111             return -1;
1112
1113         if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
1114             int16_t *dst = (int16_t*)samples + 1;
1115             int16_t *src = (int16_t*)samples;
1116             int cnt = samplecount;
1117             while (cnt--) {
1118                 *dst = *src;
1119                 src += channel_stride;
1120                 dst += channel_stride;
1121             }
1122         } else if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
1123             int32_t *dst = (int32_t*)samples + 1;
1124             int32_t *src = (int32_t*)samples;
1125             int cnt = samplecount;
1126             while (cnt--) {
1127                 *dst = *src;
1128                 src += channel_stride;
1129                 dst += channel_stride;
1130             }
1131         } else if (s->stereo) {
1132             float *dst = (float*)samples + 1;
1133             float *src = (float*)samples;
1134             int cnt = samplecount;
1135             while (cnt--) {
1136                 *dst = *src;
1137                 src += channel_stride;
1138                 dst += channel_stride;
1139             }
1140         }
1141     }
1142
1143     *got_frame_ptr = 1;
1144
1145     return samplecount * bpp;
1146 }
1147
1148 static void wavpack_decode_flush(AVCodecContext *avctx)
1149 {
1150     WavpackContext *s = avctx->priv_data;
1151     int i;
1152
1153     for (i = 0; i < s->fdec_num; i++)
1154         wv_reset_saved_context(s->fdec[i]);
1155 }
1156
1157 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1158                                 int *got_frame_ptr, AVPacket *avpkt)
1159 {
1160     WavpackContext *s  = avctx->priv_data;
1161     const uint8_t *buf = avpkt->data;
1162     int buf_size       = avpkt->size;
1163     int frame_size, ret, frame_flags;
1164     int samplecount = 0;
1165
1166     s->block     = 0;
1167     s->ch_offset = 0;
1168
1169     /* determine number of samples */
1170     if (s->mkv_mode) {
1171         s->samples  = AV_RL32(buf); buf += 4;
1172         frame_flags = AV_RL32(buf);
1173     } else {
1174         if (s->multichannel) {
1175             s->samples  = AV_RL32(buf + 4);
1176             frame_flags = AV_RL32(buf + 8);
1177         } else {
1178             s->samples  = AV_RL32(buf);
1179             frame_flags = AV_RL32(buf + 4);
1180         }
1181     }
1182     if (s->samples <= 0) {
1183         av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1184                s->samples);
1185         return AVERROR(EINVAL);
1186     }
1187
1188     if (frame_flags & 0x80) {
1189         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1190     } else if ((frame_flags & 0x03) <= 1) {
1191         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1192     } else {
1193         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1194     }
1195
1196     /* get output buffer */
1197     s->frame.nb_samples = s->samples;
1198     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1199         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1200         return ret;
1201     }
1202
1203     while (buf_size > 0) {
1204         if (!s->multichannel) {
1205             frame_size = buf_size;
1206         } else {
1207             if (!s->mkv_mode) {
1208                 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1209             } else {
1210                 if (buf_size < 12) //MKV files can have zero flags after last block
1211                     break;
1212                 frame_size = AV_RL32(buf + 8) + 12;
1213             }
1214         }
1215         if (frame_size < 0 || frame_size > buf_size) {
1216             av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d "
1217                    "vs. %d bytes left)\n", s->block, frame_size, buf_size);
1218             wavpack_decode_flush(avctx);
1219             return -1;
1220         }
1221         if ((samplecount = wavpack_decode_block(avctx, s->block,
1222                                                 s->frame.data[0], got_frame_ptr,
1223                                                 buf, frame_size)) < 0) {
1224             wavpack_decode_flush(avctx);
1225             return -1;
1226         }
1227         s->block++;
1228         buf += frame_size; buf_size -= frame_size;
1229     }
1230
1231     if (*got_frame_ptr)
1232         *(AVFrame *)data = s->frame;
1233
1234     return avpkt->size;
1235 }
1236
1237 AVCodec ff_wavpack_decoder = {
1238     .name           = "wavpack",
1239     .type           = AVMEDIA_TYPE_AUDIO,
1240     .id             = CODEC_ID_WAVPACK,
1241     .priv_data_size = sizeof(WavpackContext),
1242     .init           = wavpack_decode_init,
1243     .close          = wavpack_decode_end,
1244     .decode         = wavpack_decode_frame,
1245     .flush          = wavpack_decode_flush,
1246     .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1247     .long_name      = NULL_IF_CONFIG_SMALL("WavPack"),
1248 };