git.sesse.net Git - ffmpeg/blob - libavcodec/wavpack.c

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