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