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