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