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

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