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 #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) t = get_bits(gb, t - 1) | (1 << (t-1));
 296             ctx->zeroes = t;
 297             if(ctx->zeroes){
 298                 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
 299                 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
 300                 c->slow_level -= LEVEL_DECAY(c->slow_level);
 301                 return 0;
 302             }
 303         }
 304     }
 305
 306     if(get_bits_count(gb) >= ctx->data_size){
 307         *last = 1;
 308         return 0;
 309     }
 310
 311     if(ctx->zero){
 312         t = 0;
 313         ctx->zero = 0;
 314     }else{
 315         t = get_unary_0_33(gb);
 316         if(get_bits_count(gb) >= ctx->data_size){
 317             *last = 1;
 318             return 0;
 319         }
 320         if(t == 16) {
 321             t2 = get_unary_0_33(gb);
 322             if(t2 < 2) t += t2;
 323             else t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
 324         }
 325
 326         if(ctx->one){
 327             ctx->one = t&1;
 328             t = (t>>1) + 1;
 329         }else{
 330             ctx->one = t&1;
 331             t >>= 1;
 332         }
 333         ctx->zero = !ctx->one;
 334     }
 335
 336     if(ctx->hybrid && !channel)
 337         update_error_limit(ctx);
 338
 339     if(!t){
 340         base = 0;
 341         add = GET_MED(0) - 1;
 342         DEC_MED(0);
 343     }else if(t == 1){
 344         base = GET_MED(0);
 345         add = GET_MED(1) - 1;
 346         INC_MED(0);
 347         DEC_MED(1);
 348     }else if(t == 2){
 349         base = GET_MED(0) + GET_MED(1);
 350         add = GET_MED(2) - 1;
 351         INC_MED(0);
 352         INC_MED(1);
 353         DEC_MED(2);
 354     }else{
 355         base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
 356         add = GET_MED(2) - 1;
 357         INC_MED(0);
 358         INC_MED(1);
 359         INC_MED(2);
 360     }
 361     if(!c->error_limit){
 362         ret = base + get_tail(gb, add);
 363     }else{
 364         int mid = (base*2 + add + 1) >> 1;
 365         while(add > c->error_limit){
 366             if(get_bits1(gb)){
 367                 add -= (mid - base);
 368                 base = mid;
 369             }else
 370                 add = mid - base - 1;
 371             mid = (base*2 + add + 1) >> 1;
 372         }
 373         ret = mid;
 374     }
 375     sign = get_bits1(gb);
 376     if(ctx->hybrid_bitrate)
 377         c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
 378     return sign ? ~ret : ret;
 379 }
 380
 381 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, int S)
 382 {
 383     int bit;
 384
 385     if(s->extra_bits){
 386         S <<= s->extra_bits;
 387
 388         if(s->got_extra_bits){
 389             S |= get_bits(&s->gb_extra_bits, s->extra_bits);
 390             *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
 391         }
 392     }
 393     bit = (S & s->and) | s->or;
 394     return (((S + bit) << s->shift) - bit) << s->post_shift;
 395 }
 396
 397 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
 398 {
 399     union {
 400         float    f;
 401         uint32_t u;
 402     } value;
 403
 404     int sign;
 405     int exp = s->float_max_exp;
 406
 407     if(s->got_extra_bits){
 408         const int max_bits = 1 + 23 + 8 + 1;
 409         const int left_bits = get_bits_left(&s->gb_extra_bits);
 410
 411         if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
 412             return 0.0;
 413     }
 414
 415     if(S){
 416         S <<= s->float_shift;
 417         sign = S < 0;
 418         if(sign)
 419             S = -S;
 420         if(S >= 0x1000000){
 421             if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
 422                 S = get_bits(&s->gb_extra_bits, 23);
 423             }else{
 424                 S = 0;
 425             }
 426             exp = 255;
 427         }else if(exp){
 428             int shift = 23 - av_log2(S);
 429             exp = s->float_max_exp;
 430             if(exp <= shift){
 431                 shift = --exp;
 432             }
 433             exp -= shift;
 434
 435             if(shift){
 436                 S <<= shift;
 437                 if((s->float_flag & WV_FLT_SHIFT_ONES) ||
 438                    (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
 439                     S |= (1 << shift) - 1;
 440                 } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
 441                     S |= get_bits(&s->gb_extra_bits, shift);
 442                 }
 443             }
 444         }else{
 445             exp = s->float_max_exp;
 446         }
 447         S &= 0x7fffff;
 448     }else{
 449         sign = 0;
 450         exp = 0;
 451         if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
 452             if(get_bits1(&s->gb_extra_bits)){
 453                 S = get_bits(&s->gb_extra_bits, 23);
 454                 if(s->float_max_exp >= 25)
 455                     exp = get_bits(&s->gb_extra_bits, 8);
 456                 sign = get_bits1(&s->gb_extra_bits);
 457             }else{
 458                 if(s->float_flag & WV_FLT_ZERO_SIGN)
 459                     sign = get_bits1(&s->gb_extra_bits);
 460             }
 461         }
 462     }
 463
 464     *crc = *crc * 27 + S * 9 + exp * 3 + sign;
 465
 466     value.u = (sign << 31) | (exp << 23) | S;
 467     return value.f;
 468 }
 469
 470 static void wv_reset_saved_context(WavpackFrameContext *s)
 471 {
 472     s->pos = 0;
 473     s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
 474 }
 475
 476 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
 477 {
 478     int i, j, count = 0;
 479     int last, t;
 480     int A, B, L, L2, R, R2;
 481     int pos = s->pos;
 482     uint32_t crc = s->sc.crc;
 483     uint32_t crc_extra_bits = s->extra_sc.crc;
 484     int16_t *dst16 = dst;
 485     int32_t *dst32 = dst;
 486     float   *dstfl = dst;
 487     const int channel_pad = s->avctx->channels - 2;
 488
 489     if(s->samples_left == s->samples)
 490         s->one = s->zero = s->zeroes = 0;
 491     do{
 492         L = wv_get_value(s, gb, 0, &last);
 493         if(last) break;
 494         R = wv_get_value(s, gb, 1, &last);
 495         if(last) break;
 496         for(i = 0; i < s->terms; i++){
 497             t = s->decorr[i].value;
 498             if(t > 0){
 499                 if(t > 8){
 500                     if(t & 1){
 501                         A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 502                         B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
 503                     }else{
 504                         A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 505                         B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
 506                     }
 507                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 508                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
 509                     j = 0;
 510                 }else{
 511                     A = s->decorr[i].samplesA[pos];
 512                     B = s->decorr[i].samplesB[pos];
 513                     j = (pos + t) & 7;
 514                 }
 515                 if(type != AV_SAMPLE_FMT_S16){
 516                     L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 517                     R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
 518                 }else{
 519                     L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
 520                     R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
 521                 }
 522                 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 523                 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
 524                 s->decorr[i].samplesA[j] = L = L2;
 525                 s->decorr[i].samplesB[j] = R = R2;
 526             }else if(t == -1){
 527                 if(type != AV_SAMPLE_FMT_S16)
 528                     L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
 529                 else
 530                     L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
 531                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
 532                 L = L2;
 533                 if(type != AV_SAMPLE_FMT_S16)
 534                     R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
 535                 else
 536                     R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
 537                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
 538                 R = R2;
 539                 s->decorr[i].samplesA[0] = R;
 540             }else{
 541                 if(type != AV_SAMPLE_FMT_S16)
 542                     R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
 543                 else
 544                     R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
 545                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
 546                 R = R2;
 547
 548                 if(t == -3){
 549                     R2 = s->decorr[i].samplesA[0];
 550                     s->decorr[i].samplesA[0] = R;
 551                 }
 552
 553                 if(type != AV_SAMPLE_FMT_S16)
 554                     L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
 555                 else
 556                     L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
 557                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
 558                 L = L2;
 559                 s->decorr[i].samplesB[0] = L;
 560             }
 561         }
 562         pos = (pos + 1) & 7;
 563         if(s->joint)
 564             L += (R -= (L >> 1));
 565         crc = (crc * 3 + L) * 3 + R;
 566
 567         if(type == AV_SAMPLE_FMT_FLT){
 568             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
 569             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
 570             dstfl += channel_pad;
 571         } else if(type == AV_SAMPLE_FMT_S32){
 572             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
 573             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
 574             dst32 += channel_pad;
 575         } else {
 576             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
 577             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
 578             dst16 += channel_pad;
 579         }
 580         count++;
 581     }while(!last && count < s->max_samples);
 582
 583     s->samples_left -= count;
 584     if(!s->samples_left){
 585         if(crc != s->CRC){
 586             av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
 587             return -1;
 588         }
 589         if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
 590             av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 591             return -1;
 592         }
 593         wv_reset_saved_context(s);
 594     }else{
 595         s->pos = pos;
 596         s->sc.crc = crc;
 597         s->sc.bits_used = get_bits_count(&s->gb);
 598         if(s->got_extra_bits){
 599             s->extra_sc.crc = crc_extra_bits;
 600             s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
 601         }
 602     }
 603     return count * 2;
 604 }
 605
 606 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
 607 {
 608     int i, j, count = 0;
 609     int last, t;
 610     int A, S, T;
 611     int pos = s->pos;
 612     uint32_t crc = s->sc.crc;
 613     uint32_t crc_extra_bits = s->extra_sc.crc;
 614     int16_t *dst16 = dst;
 615     int32_t *dst32 = dst;
 616     float   *dstfl = dst;
 617     const int channel_stride = s->avctx->channels;
 618
 619     if(s->samples_left == s->samples)
 620         s->one = s->zero = s->zeroes = 0;
 621     do{
 622         T = wv_get_value(s, gb, 0, &last);
 623         S = 0;
 624         if(last) break;
 625         for(i = 0; i < s->terms; i++){
 626             t = s->decorr[i].value;
 627             if(t > 8){
 628                 if(t & 1)
 629                     A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 630                 else
 631                     A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 632                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 633                 j = 0;
 634             }else{
 635                 A = s->decorr[i].samplesA[pos];
 636                 j = (pos + t) & 7;
 637             }
 638             if(type != AV_SAMPLE_FMT_S16)
 639                 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 640             else
 641                 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
 642             if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 643             s->decorr[i].samplesA[j] = T = S;
 644         }
 645         pos = (pos + 1) & 7;
 646         crc = crc * 3 + S;
 647
 648         if(type == AV_SAMPLE_FMT_FLT){
 649             *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
 650             dstfl += channel_stride;
 651         }else if(type == AV_SAMPLE_FMT_S32){
 652             *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
 653             dst32 += channel_stride;
 654         }else{
 655             *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
 656             dst16 += channel_stride;
 657         }
 658         count++;
 659     }while(!last && count < s->max_samples);
 660
 661     s->samples_left -= count;
 662     if(!s->samples_left){
 663         if(crc != s->CRC){
 664             av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
 665             return -1;
 666         }
 667         if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
 668             av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 669             return -1;
 670         }
 671         wv_reset_saved_context(s);
 672     }else{
 673         s->pos = pos;
 674         s->sc.crc = crc;
 675         s->sc.bits_used = get_bits_count(&s->gb);
 676         if(s->got_extra_bits){
 677             s->extra_sc.crc = crc_extra_bits;
 678             s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
 679         }
 680     }
 681     return count;
 682 }
 683
 684 static av_cold int wv_alloc_frame_context(WavpackContext *c)
 685 {
 686
 687     if(c->fdec_num == WV_MAX_FRAME_DECODERS)
 688         return -1;
 689
 690     c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
 691     if(!c->fdec[c->fdec_num])
 692         return -1;
 693     c->fdec_num++;
 694     c->fdec[c->fdec_num - 1]->avctx = c->avctx;
 695     wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
 696
 697     return 0;
 698 }
 699
 700 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
 701 {
 702     WavpackContext *s = avctx->priv_data;
 703
 704     s->avctx = avctx;
 705     if(avctx->bits_per_coded_sample <= 16)
 706         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 707     else
 708         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 709     if(avctx->channels <= 2 && !avctx->channel_layout)
 710         avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
 711
 712     s->multichannel = avctx->channels > 2;
 713     /* lavf demuxer does not provide extradata, Matroska stores 0x403
 714        there, use this to detect decoding mode for multichannel */
 715     s->mkv_mode = 0;
 716     if(s->multichannel && avctx->extradata && avctx->extradata_size == 2){
 717         int ver = AV_RL16(avctx->extradata);
 718         if(ver >= 0x402 && ver <= 0x410)
 719             s->mkv_mode = 1;
 720     }
 721
 722     s->fdec_num = 0;
 723
 724     return 0;
 725 }
 726
 727 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
 728 {
 729     WavpackContext *s = avctx->priv_data;
 730     int i;
 731
 732     for(i = 0; i < s->fdec_num; i++)
 733         av_freep(&s->fdec[i]);
 734     s->fdec_num = 0;
 735
 736     return 0;
 737 }
 738
 739 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
 740                                 void *data, int *data_size,
 741                                 const uint8_t *buf, int buf_size)
 742 {
 743     WavpackContext *wc = avctx->priv_data;
 744     WavpackFrameContext *s;
 745     void *samples = data;
 746     int samplecount;
 747     int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
 748     int got_hybrid = 0;
 749     const uint8_t* orig_buf = buf;
 750     const uint8_t* buf_end = buf + buf_size;
 751     int i, j, id, size, ssize, weights, t;
 752     int bpp, chan, chmask;
 753
 754     if (buf_size == 0){
 755         *data_size = 0;
 756         return 0;
 757     }
 758
 759     if(block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0){
 760         av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
 761         return -1;
 762     }
 763
 764     s = wc->fdec[block_no];
 765     if(!s){
 766         av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
 767         return -1;
 768     }
 769
 770     if(!s->samples_left){
 771         memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
 772         memset(s->ch, 0, sizeof(s->ch));
 773         s->extra_bits = 0;
 774         s->and = s->or = s->shift = 0;
 775         s->got_extra_bits = 0;
 776     }
 777
 778     if(!wc->mkv_mode){
 779         s->samples = AV_RL32(buf); buf += 4;
 780         if(!s->samples){
 781             *data_size = 0;
 782             return buf_size;
 783         }
 784     }else{
 785         s->samples = wc->samples;
 786     }
 787     s->frame_flags = AV_RL32(buf); buf += 4;
 788     if(s->frame_flags&0x80){
 789         bpp = sizeof(float);
 790         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
 791     } else if((s->frame_flags&0x03) <= 1){
 792         bpp = 2;
 793         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 794     } else {
 795         bpp = 4;
 796         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 797     }
 798     samples = (uint8_t*)samples + bpp * wc->ch_offset;
 799
 800     s->stereo = !(s->frame_flags & WV_MONO);
 801     s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
 802     s->joint = s->frame_flags & WV_JOINT_STEREO;
 803     s->hybrid = s->frame_flags & WV_HYBRID_MODE;
 804     s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
 805     s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
 806     s->CRC = AV_RL32(buf); buf += 4;
 807     if(wc->mkv_mode)
 808         buf += 4; //skip block size;
 809
 810     wc->ch_offset += 1 + s->stereo;
 811
 812     s->max_samples = *data_size / (bpp * avctx->channels);
 813     s->max_samples = FFMIN(s->max_samples, s->samples);
 814     if(s->samples_left > 0){
 815         s->max_samples = FFMIN(s->max_samples, s->samples_left);
 816         buf = buf_end;
 817     }
 818
 819     // parse metadata blocks
 820     while(buf < buf_end){
 821         id = *buf++;
 822         size = *buf++;
 823         if(id & WP_IDF_LONG) {
 824             size |= (*buf++) << 8;
 825             size |= (*buf++) << 16;
 826         }
 827         size <<= 1; // size is specified in words
 828         ssize = size;
 829         if(id & WP_IDF_ODD) size--;
 830         if(size < 0){
 831             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
 832             break;
 833         }
 834         if(buf + ssize > buf_end){
 835             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
 836             break;
 837         }
 838         if(id & WP_IDF_IGNORE){
 839             buf += ssize;
 840             continue;
 841         }
 842         switch(id & WP_IDF_MASK){
 843         case WP_ID_DECTERMS:
 844             s->terms = size;
 845             if(s->terms > MAX_TERMS){
 846                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
 847                 buf += ssize;
 848                 continue;
 849             }
 850             for(i = 0; i < s->terms; i++) {
 851                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
 852                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
 853                 buf++;
 854             }
 855             got_terms = 1;
 856             break;
 857         case WP_ID_DECWEIGHTS:
 858             if(!got_terms){
 859                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 860                 continue;
 861             }
 862             weights = size >> s->stereo_in;
 863             if(weights > MAX_TERMS || weights > s->terms){
 864                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
 865                 buf += ssize;
 866                 continue;
 867             }
 868             for(i = 0; i < weights; i++) {
 869                 t = (int8_t)(*buf++);
 870                 s->decorr[s->terms - i - 1].weightA = t << 3;
 871                 if(s->decorr[s->terms - i - 1].weightA > 0)
 872                     s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
 873                 if(s->stereo_in){
 874                     t = (int8_t)(*buf++);
 875                     s->decorr[s->terms - i - 1].weightB = t << 3;
 876                     if(s->decorr[s->terms - i - 1].weightB > 0)
 877                         s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
 878                 }
 879             }
 880             got_weights = 1;
 881             break;
 882         case WP_ID_DECSAMPLES:
 883             if(!got_terms){
 884                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 885                 continue;
 886             }
 887             t = 0;
 888             for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
 889                 if(s->decorr[i].value > 8){
 890                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 891                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 892                     if(s->stereo_in){
 893                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 894                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 895                         t += 4;
 896                     }
 897                     t += 4;
 898                 }else if(s->decorr[i].value < 0){
 899                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 900                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 901                     t += 4;
 902                 }else{
 903                     for(j = 0; j < s->decorr[i].value; j++){
 904                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 905                         if(s->stereo_in){
 906                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 907                         }
 908                     }
 909                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
 910                 }
 911             }
 912             got_samples = 1;
 913             break;
 914         case WP_ID_ENTROPY:
 915             if(size != 6 * (s->stereo_in + 1)){
 916                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
 917                 buf += ssize;
 918                 continue;
 919             }
 920             for(j = 0; j <= s->stereo_in; j++){
 921                 for(i = 0; i < 3; i++){
 922                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
 923                     buf += 2;
 924                 }
 925             }
 926             got_entropy = 1;
 927             break;
 928         case WP_ID_HYBRID:
 929             if(s->hybrid_bitrate){
 930                 for(i = 0; i <= s->stereo_in; i++){
 931                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
 932                     buf += 2;
 933                     size -= 2;
 934                 }
 935             }
 936             for(i = 0; i < (s->stereo_in + 1); i++){
 937                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
 938                 buf += 2;
 939                 size -= 2;
 940             }
 941             if(size > 0){
 942                 for(i = 0; i < (s->stereo_in + 1); i++){
 943                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
 944                     buf += 2;
 945                 }
 946             }else{
 947                 for(i = 0; i < (s->stereo_in + 1); i++)
 948                     s->ch[i].bitrate_delta = 0;
 949             }
 950             got_hybrid = 1;
 951             break;
 952         case WP_ID_INT32INFO:
 953             if(size != 4){
 954                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
 955                 buf += ssize;
 956                 continue;
 957             }
 958             if(buf[0])
 959                 s->extra_bits = buf[0];
 960             else if(buf[1])
 961                 s->shift = buf[1];
 962             else if(buf[2]){
 963                 s->and = s->or = 1;
 964                 s->shift = buf[2];
 965             }else if(buf[3]){
 966                 s->and = 1;
 967                 s->shift = buf[3];
 968             }
 969             buf += 4;
 970             break;
 971         case WP_ID_FLOATINFO:
 972             if(size != 4){
 973                 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
 974                 buf += ssize;
 975                 continue;
 976             }
 977             s->float_flag = buf[0];
 978             s->float_shift = buf[1];
 979             s->float_max_exp = buf[2];
 980             buf += 4;
 981             got_float = 1;
 982             break;
 983         case WP_ID_DATA:
 984             s->sc.offset = buf - orig_buf;
 985             s->sc.size   = size * 8;
 986             init_get_bits(&s->gb, buf, size * 8);
 987             s->data_size = size * 8;
 988             buf += size;
 989             got_bs = 1;
 990             break;
 991         case WP_ID_EXTRABITS:
 992             if(size <= 4){
 993                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
 994                 buf += size;
 995                 continue;
 996             }
 997             s->extra_sc.offset = buf - orig_buf;
 998             s->extra_sc.size   = size * 8;
 999             init_get_bits(&s->gb_extra_bits, buf, size * 8);
1000             s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1001             buf += size;
1002             s->got_extra_bits = 1;
1003             break;
1004         case WP_ID_CHANINFO:
1005             if(size <= 1){
1006                 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1007                 return -1;
1008             }
1009             chan = *buf++;
1010             switch(size - 2){
1011             case 0:
1012                 chmask = *buf;
1013                 break;
1014             case 1:
1015                 chmask = AV_RL16(buf);
1016                 break;
1017             case 2:
1018                 chmask = AV_RL24(buf);
1019                 break;
1020             case 3:
1021                 chmask = AV_RL32(buf);
1022                 break;
1023             case 5:
1024                 chan |= (buf[1] & 0xF) << 8;
1025                 chmask = AV_RL24(buf + 2);
1026                 break;
1027             default:
1028                 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);
1029                 chan = avctx->channels;
1030                 chmask = avctx->channel_layout;
1031             }
1032             if(chan != avctx->channels){
1033                 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, decoder believes it's %d channels\n",
1034                        chan, avctx->channels);
1035                 return -1;
1036             }
1037             if(!avctx->channel_layout)
1038                 avctx->channel_layout = chmask;
1039             buf += size - 1;
1040             break;
1041         default:
1042             buf += size;
1043         }
1044         if(id & WP_IDF_ODD) buf++;
1045     }
1046     if(!s->samples_left){
1047         if(!got_terms){
1048             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1049             return -1;
1050         }
1051         if(!got_weights){
1052             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1053             return -1;
1054         }
1055         if(!got_samples){
1056             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1057             return -1;
1058         }
1059         if(!got_entropy){
1060             av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1061             return -1;
1062         }
1063         if(s->hybrid && !got_hybrid){
1064             av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1065             return -1;
1066         }
1067         if(!got_bs){
1068             av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1069             return -1;
1070         }
1071         if(!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT){
1072             av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1073             return -1;
1074         }
1075         if(s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT){
1076             const int size = get_bits_left(&s->gb_extra_bits);
1077             const int wanted = s->samples * s->extra_bits << s->stereo_in;
1078             if(size < wanted){
1079                 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1080                 s->got_extra_bits = 0;
1081             }
1082         }
1083         s->samples_left = s->samples;
1084     }else{
1085         init_get_bits(&s->gb, orig_buf + s->sc.offset, s->sc.size);
1086         skip_bits_long(&s->gb, s->sc.bits_used);
1087         if(s->got_extra_bits){
1088             init_get_bits(&s->gb_extra_bits, orig_buf + s->extra_sc.offset,
1089                           s->extra_sc.size);
1090             skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
1091         }
1092     }
1093
1094     if(s->stereo_in){
1095         if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1096             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1097         else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1098             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1099         else
1100             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1101         samplecount >>= 1;
1102     }else{
1103         const int channel_stride = avctx->channels;
1104
1105         if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1106             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1107         else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1108             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1109         else
1110             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1111
1112         if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16){
1113             int16_t *dst = (int16_t*)samples + 1;
1114             int16_t *src = (int16_t*)samples;
1115             int cnt = samplecount;
1116             while(cnt--){
1117                 *dst = *src;
1118                 src += channel_stride;
1119                 dst += channel_stride;
1120             }
1121         }else if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32){
1122             int32_t *dst = (int32_t*)samples + 1;
1123             int32_t *src = (int32_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){
1131             float *dst = (float*)samples + 1;
1132             float *src = (float*)samples;
1133             int cnt = samplecount;
1134             while(cnt--){
1135                 *dst = *src;
1136                 src += channel_stride;
1137                 dst += channel_stride;
1138             }
1139         }
1140     }
1141
1142     wc->samples_left = s->samples_left;
1143
1144     return samplecount * bpp;
1145 }
1146
1147 static int wavpack_decode_frame(AVCodecContext *avctx,
1148                             void *data, int *data_size,
1149                             AVPacket *avpkt)
1150 {
1151     WavpackContext *s = avctx->priv_data;
1152     const uint8_t *buf = avpkt->data;
1153     int buf_size = avpkt->size;
1154     int frame_size;
1155     int samplecount = 0;
1156
1157     s->block = 0;
1158     s->samples_left = 0;
1159     s->ch_offset = 0;
1160
1161     if(s->mkv_mode){
1162         s->samples = AV_RL32(buf); buf += 4;
1163     }
1164     while(buf_size > 0){
1165         if(!s->multichannel){
1166             frame_size = buf_size;
1167         }else{
1168             if(!s->mkv_mode){
1169                 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1170             }else{
1171                 if(buf_size < 12) //MKV files can have zero flags after last block
1172                     break;
1173                 frame_size = AV_RL32(buf + 8) + 12;
1174             }
1175         }
1176         if(frame_size < 0 || frame_size > buf_size){
1177             av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",
1178                    s->block, frame_size, buf_size);
1179             return -1;
1180         }
1181         if((samplecount = wavpack_decode_block(avctx, s->block, data,
1182                                                data_size, buf, frame_size)) < 0)
1183             return -1;
1184         s->block++;
1185         buf += frame_size; buf_size -= frame_size;
1186     }
1187     *data_size = samplecount * avctx->channels;
1188
1189     return s->samples_left > 0 ? 0 : avpkt->size;
1190 }
1191
1192 AVCodec ff_wavpack_decoder = {
1193     .name           = "wavpack",
1194     .type           = AVMEDIA_TYPE_AUDIO,
1195     .id             = CODEC_ID_WAVPACK,
1196     .priv_data_size = sizeof(WavpackContext),
1197     .init           = wavpack_decode_init,
1198     .close          = wavpack_decode_end,
1199     .decode         = wavpack_decode_frame,
1200     .capabilities = CODEC_CAP_SUBFRAMES,
1201     .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
1202 };