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