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