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