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