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

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