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