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
 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     return 0;
 744 }
 745
 746 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
 747 {
 748     WavpackContext *s = avctx->priv_data;
 749     int i;
 750
 751     for (i = 0; i < s->fdec_num; i++)
 752         av_freep(&s->fdec[i]);
 753     s->fdec_num = 0;
 754
 755     return 0;
 756 }
 757
 758 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
 759                                 void *data, int *got_frame_ptr,
 760                                 const uint8_t *buf, int buf_size)
 761 {
 762     WavpackContext *wc = avctx->priv_data;
 763     WavpackFrameContext *s;
 764     void *samples = data;
 765     int samplecount;
 766     int got_terms   = 0, got_weights = 0, got_samples = 0,
 767         got_entropy = 0, got_bs      = 0, got_float   = 0, got_hybrid = 0;
 768     const uint8_t *orig_buf = buf;
 769     const uint8_t *buf_end  = buf + buf_size;
 770     int i, j, id, size, ssize, weights, t;
 771     int bpp, chan, chmask, orig_bpp;
 772
 773     if (buf_size == 0) {
 774         *got_frame_ptr = 0;
 775         return 0;
 776     }
 777
 778     if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
 779         av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
 780         return -1;
 781     }
 782
 783     s = wc->fdec[block_no];
 784     if (!s) {
 785         av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
 786         return -1;
 787     }
 788
 789     if (wc->ch_offset >= avctx->channels) {
 790         av_log(avctx, AV_LOG_ERROR, "too many channels\n");
 791         return -1;
 792     }
 793
 794     memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
 795     memset(s->ch, 0, sizeof(s->ch));
 796     s->extra_bits = 0;
 797     s->and = s->or = s->shift = 0;
 798     s->got_extra_bits = 0;
 799
 800     if (!wc->mkv_mode) {
 801         s->samples = AV_RL32(buf); buf += 4;
 802         if (!s->samples) {
 803             *got_frame_ptr = 0;
 804             return 0;
 805         }
 806         if (s->samples > wc->samples) {
 807             av_log(avctx, AV_LOG_ERROR, "too many samples in block");
 808             return -1;
 809         }
 810     } else {
 811         s->samples = wc->samples;
 812     }
 813     s->frame_flags = AV_RL32(buf); buf += 4;
 814     bpp = av_get_bytes_per_sample(avctx->sample_fmt);
 815     samples = (uint8_t*)samples + bpp * wc->ch_offset;
 816     orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
 817
 818     s->stereo         = !(s->frame_flags & WV_MONO);
 819     s->stereo_in      =  (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
 820     s->joint          =   s->frame_flags & WV_JOINT_STEREO;
 821     s->hybrid         =   s->frame_flags & WV_HYBRID_MODE;
 822     s->hybrid_bitrate =   s->frame_flags & WV_HYBRID_BITRATE;
 823     s->post_shift     = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
 824     s->hybrid_maxclip = (( 1LL << (orig_bpp - 1)) - 1);
 825     s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));
 826     s->CRC            = AV_RL32(buf); buf += 4;
 827     if (wc->mkv_mode)
 828         buf += 4; //skip block size;
 829
 830     wc->ch_offset += 1 + s->stereo;
 831
 832     // parse metadata blocks
 833     while (buf < buf_end) {
 834         id   = *buf++;
 835         size = *buf++;
 836         if (id & WP_IDF_LONG) {
 837             size |= (*buf++) << 8;
 838             size |= (*buf++) << 16;
 839         }
 840         size <<= 1; // size is specified in words
 841         ssize = size;
 842         if (id & WP_IDF_ODD)
 843             size--;
 844         if (size < 0) {
 845             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
 846             break;
 847         }
 848         if (buf + ssize > buf_end) {
 849             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
 850             break;
 851         }
 852         if (id & WP_IDF_IGNORE) {
 853             buf += ssize;
 854             continue;
 855         }
 856         switch (id & WP_IDF_MASK) {
 857         case WP_ID_DECTERMS:
 858             if (size > MAX_TERMS) {
 859                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
 860                 s->terms = 0;
 861                 buf += ssize;
 862                 continue;
 863             }
 864             s->terms = size;
 865             for (i = 0; i < s->terms; i++) {
 866                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
 867                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
 868                 buf++;
 869             }
 870             got_terms = 1;
 871             break;
 872         case WP_ID_DECWEIGHTS:
 873             if (!got_terms) {
 874                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 875                 continue;
 876             }
 877             weights = size >> s->stereo_in;
 878             if (weights > MAX_TERMS || weights > s->terms) {
 879                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
 880                 buf += ssize;
 881                 continue;
 882             }
 883             for (i = 0; i < weights; i++) {
 884                 t = (int8_t)(*buf++);
 885                 s->decorr[s->terms - i - 1].weightA = t << 3;
 886                 if (s->decorr[s->terms - i - 1].weightA > 0)
 887                     s->decorr[s->terms - i - 1].weightA +=
 888                             (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
 889                 if (s->stereo_in) {
 890                     t = (int8_t)(*buf++);
 891                     s->decorr[s->terms - i - 1].weightB = t << 3;
 892                     if (s->decorr[s->terms - i - 1].weightB > 0)
 893                         s->decorr[s->terms - i - 1].weightB +=
 894                                 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
 895                 }
 896             }
 897             got_weights = 1;
 898             break;
 899         case WP_ID_DECSAMPLES:
 900             if (!got_terms) {
 901                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 902                 continue;
 903             }
 904             t = 0;
 905             for (i = s->terms - 1; (i >= 0) && (t < size) && buf <= buf_end; i--) {
 906                 if (s->decorr[i].value > 8) {
 907                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 908                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 909                     if (s->stereo_in) {
 910                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 911                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 912                         t += 4;
 913                     }
 914                     t += 4;
 915                 } else if (s->decorr[i].value < 0) {
 916                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 917                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 918                     t += 4;
 919                 } else {
 920                     for (j = 0; j < s->decorr[i].value && buf+1<buf_end; j++) {
 921                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 922                         if (s->stereo_in) {
 923                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 924                         }
 925                     }
 926                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
 927                 }
 928             }
 929             got_samples = 1;
 930             break;
 931         case WP_ID_ENTROPY:
 932             if (size != 6 * (s->stereo_in + 1)) {
 933                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, "
 934                        "got %i", 6 * (s->stereo_in + 1), size);
 935                 buf += ssize;
 936                 continue;
 937             }
 938             for (j = 0; j <= s->stereo_in; j++) {
 939                 for (i = 0; i < 3; i++) {
 940                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
 941                     buf += 2;
 942                 }
 943             }
 944             got_entropy = 1;
 945             break;
 946         case WP_ID_HYBRID:
 947             if (s->hybrid_bitrate) {
 948                 for (i = 0; i <= s->stereo_in; i++) {
 949                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
 950                     buf += 2;
 951                     size -= 2;
 952                 }
 953             }
 954             for (i = 0; i < (s->stereo_in + 1); i++) {
 955                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
 956                 buf += 2;
 957                 size -= 2;
 958             }
 959             if (size > 0) {
 960                 for (i = 0; i < (s->stereo_in + 1); i++) {
 961                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
 962                     buf += 2;
 963                 }
 964             } else {
 965                 for (i = 0; i < (s->stereo_in + 1); i++)
 966                     s->ch[i].bitrate_delta = 0;
 967             }
 968             got_hybrid = 1;
 969             break;
 970         case WP_ID_INT32INFO:
 971             if (size != 4) {
 972                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
 973                 buf += ssize;
 974                 continue;
 975             }
 976             if (buf[0])
 977                 s->extra_bits = buf[0];
 978             else if (buf[1])
 979                 s->shift = buf[1];
 980             else if (buf[2]){
 981                 s->and = s->or = 1;
 982                 s->shift = buf[2];
 983             } else if(buf[3]) {
 984                 s->and   = 1;
 985                 s->shift = buf[3];
 986             }
 987             /* original WavPack decoder forces 32-bit lossy sound to be treated
 988              * as 24-bit one in order to have proper clipping
 989              */
 990             if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
 991                 s->post_shift += 8;
 992                 s->shift      -= 8;
 993                 s->hybrid_maxclip >>= 8;
 994                 s->hybrid_minclip >>= 8;
 995             }
 996             buf += 4;
 997             break;
 998         case WP_ID_FLOATINFO:
 999             if (size != 4) {
1000                 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
1001                 buf += ssize;
1002                 continue;
1003             }
1004             s->float_flag    = buf[0];
1005             s->float_shift   = buf[1];
1006             s->float_max_exp = buf[2];
1007             buf += 4;
1008             got_float = 1;
1009             break;
1010         case WP_ID_DATA:
1011             s->sc.offset = buf - orig_buf;
1012             s->sc.size   = size * 8;
1013             init_get_bits(&s->gb, buf, size * 8);
1014             s->data_size = size * 8;
1015             buf += size;
1016             got_bs = 1;
1017             break;
1018         case WP_ID_EXTRABITS:
1019             if (size <= 4) {
1020                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1021                        size);
1022                 buf += size;
1023                 continue;
1024             }
1025             s->extra_sc.offset = buf - orig_buf;
1026             s->extra_sc.size   = size * 8;
1027             init_get_bits(&s->gb_extra_bits, buf, size * 8);
1028             s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1029             buf += size;
1030             s->got_extra_bits = 1;
1031             break;
1032         case WP_ID_CHANINFO:
1033             if (size <= 1) {
1034                 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1035                 return -1;
1036             }
1037             chan = *buf++;
1038             switch (size - 2) {
1039             case 0: chmask = *buf;         break;
1040             case 1: chmask = AV_RL16(buf); break;
1041             case 2: chmask = AV_RL24(buf); break;
1042             case 3: chmask = AV_RL32(buf); break;
1043             case 5:
1044                 chan |= (buf[1] & 0xF) << 8;
1045                 chmask = AV_RL24(buf + 2);
1046                 break;
1047             default:
1048                 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1049                        size);
1050                 chan   = avctx->channels;
1051                 chmask = avctx->channel_layout;
1052             }
1053             if (chan != avctx->channels) {
1054                 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, "
1055                        "decoder believes it's %d channels\n", chan,
1056                        avctx->channels);
1057                 return -1;
1058             }
1059             if (!avctx->channel_layout)
1060                 avctx->channel_layout = chmask;
1061             buf += size - 1;
1062             break;
1063         default:
1064             buf += size;
1065         }
1066         if (id & WP_IDF_ODD)
1067             buf++;
1068     }
1069
1070     if (!got_terms) {
1071         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1072         return -1;
1073     }
1074     if (!got_weights) {
1075         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1076         return -1;
1077     }
1078     if (!got_samples) {
1079         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1080         return -1;
1081     }
1082     if (!got_entropy) {
1083         av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1084         return -1;
1085     }
1086     if (s->hybrid && !got_hybrid) {
1087         av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1088         return -1;
1089     }
1090     if (!got_bs) {
1091         av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1092         return -1;
1093     }
1094     if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1095         av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1096         return -1;
1097     }
1098     if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT) {
1099         const int size   = get_bits_left(&s->gb_extra_bits);
1100         const int wanted = s->samples * s->extra_bits << s->stereo_in;
1101         if (size < wanted) {
1102             av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1103             s->got_extra_bits = 0;
1104         }
1105     }
1106
1107     if (s->stereo_in) {
1108         if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1109             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1110         else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1111             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1112         else
1113             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1114
1115         if (samplecount < 0)
1116             return -1;
1117
1118         samplecount >>= 1;
1119     } else {
1120         const int channel_stride = avctx->channels;
1121
1122         if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1123             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1124         else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1125             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1126         else
1127             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1128
1129         if (samplecount < 0)
1130             return -1;
1131
1132         if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
1133             int16_t *dst = (int16_t*)samples + 1;
1134             int16_t *src = (int16_t*)samples;
1135             int cnt = samplecount;
1136             while (cnt--) {
1137                 *dst = *src;
1138                 src += channel_stride;
1139                 dst += channel_stride;
1140             }
1141         } else if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
1142             int32_t *dst = (int32_t*)samples + 1;
1143             int32_t *src = (int32_t*)samples;
1144             int cnt = samplecount;
1145             while (cnt--) {
1146                 *dst = *src;
1147                 src += channel_stride;
1148                 dst += channel_stride;
1149             }
1150         } else if (s->stereo) {
1151             float *dst = (float*)samples + 1;
1152             float *src = (float*)samples;
1153             int cnt = samplecount;
1154             while (cnt--) {
1155                 *dst = *src;
1156                 src += channel_stride;
1157                 dst += channel_stride;
1158             }
1159         }
1160     }
1161
1162     *got_frame_ptr = 1;
1163
1164     return samplecount * bpp;
1165 }
1166
1167 static void wavpack_decode_flush(AVCodecContext *avctx)
1168 {
1169     WavpackContext *s = avctx->priv_data;
1170     int i;
1171
1172     for (i = 0; i < s->fdec_num; i++)
1173         wv_reset_saved_context(s->fdec[i]);
1174 }
1175
1176 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1177                                 int *got_frame_ptr, AVPacket *avpkt)
1178 {
1179     WavpackContext *s  = avctx->priv_data;
1180     const uint8_t *buf = avpkt->data;
1181     int buf_size       = avpkt->size;
1182     AVFrame *frame     = data;
1183     int frame_size, ret, frame_flags;
1184     int samplecount = 0;
1185
1186     s->block     = 0;
1187     s->ch_offset = 0;
1188
1189     /* determine number of samples */
1190     if (s->mkv_mode) {
1191         s->samples  = AV_RL32(buf); buf += 4;
1192         frame_flags = AV_RL32(buf);
1193     } else {
1194         if (s->multichannel) {
1195             s->samples  = AV_RL32(buf + 4);
1196             frame_flags = AV_RL32(buf + 8);
1197         } else {
1198             s->samples  = AV_RL32(buf);
1199             frame_flags = AV_RL32(buf + 4);
1200         }
1201     }
1202     if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) {
1203         av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1204                s->samples);
1205         return AVERROR(EINVAL);
1206     }
1207
1208     if (frame_flags & 0x80) {
1209         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1210     } else if ((frame_flags & 0x03) <= 1) {
1211         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1212     } else {
1213         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1214         avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1215     }
1216
1217     /* get output buffer */
1218     frame->nb_samples = s->samples + 1;
1219     if ((ret = ff_get_buffer(avctx, frame)) < 0) {
1220         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1221         return ret;
1222     }
1223     frame->nb_samples = s->samples;
1224
1225     while (buf_size > 0) {
1226         if (!s->multichannel) {
1227             frame_size = buf_size;
1228         } else {
1229             if (!s->mkv_mode) {
1230                 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1231             } else {
1232                 if (buf_size < 12) //MKV files can have zero flags after last block
1233                     break;
1234                 frame_size = AV_RL32(buf + 8) + 12;
1235             }
1236         }
1237         if (frame_size < 0 || frame_size > buf_size) {
1238             av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d "
1239                    "vs. %d bytes left)\n", s->block, frame_size, buf_size);
1240             wavpack_decode_flush(avctx);
1241             return AVERROR_INVALIDDATA;
1242         }
1243         if ((samplecount = wavpack_decode_block(avctx, s->block,
1244                                                 frame->data[0], got_frame_ptr,
1245                                                 buf, frame_size)) < 0) {
1246             wavpack_decode_flush(avctx);
1247             return AVERROR_INVALIDDATA;
1248         }
1249         s->block++;
1250         buf += frame_size; buf_size -= frame_size;
1251     }
1252
1253     return avpkt->size;
1254 }
1255
1256 AVCodec ff_wavpack_decoder = {
1257     .name           = "wavpack",
1258     .type           = AVMEDIA_TYPE_AUDIO,
1259     .id             = AV_CODEC_ID_WAVPACK,
1260     .priv_data_size = sizeof(WavpackContext),
1261     .init           = wavpack_decode_init,
1262     .close          = wavpack_decode_end,
1263     .decode         = wavpack_decode_frame,
1264     .flush          = wavpack_decode_flush,
1265     .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1266     .long_name      = NULL_IF_CONFIG_SMALL("WavPack"),
1267 };