tizen/distrib/libav/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){
 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->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
 489 }
 490
 491 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
 492 {
 493     int i, j, count = 0;
 494     int last, t;
 495     int A, B, L, L2, R, R2;
 496     int pos = s->pos;
 497     uint32_t crc = s->sc.crc;
 498     uint32_t crc_extra_bits = s->extra_sc.crc;
 499     int16_t *dst16 = dst;
 500     int32_t *dst32 = dst;
 501     float   *dstfl = dst;
 502     const int channel_pad = s->avctx->channels - 2;
 503
 504     if(s->samples_left == s->samples)
 505         s->one = s->zero = s->zeroes = 0;
 506     do{
 507         L = wv_get_value(s, gb, 0, &last);
 508         if(last) break;
 509         R = wv_get_value(s, gb, 1, &last);
 510         if(last) break;
 511         for(i = 0; i < s->terms; i++){
 512             t = s->decorr[i].value;
 513             if(t > 0){
 514                 if(t > 8){
 515                     if(t & 1){
 516                         A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 517                         B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
 518                     }else{
 519                         A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 520                         B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
 521                     }
 522                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 523                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
 524                     j = 0;
 525                 }else{
 526                     A = s->decorr[i].samplesA[pos];
 527                     B = s->decorr[i].samplesB[pos];
 528                     j = (pos + t) & 7;
 529                 }
 530                 if(type != AV_SAMPLE_FMT_S16){
 531                     L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 532                     R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
 533                 }else{
 534                     L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
 535                     R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
 536                 }
 537                 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 538                 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
 539                 s->decorr[i].samplesA[j] = L = L2;
 540                 s->decorr[i].samplesB[j] = R = R2;
 541             }else if(t == -1){
 542                 if(type != AV_SAMPLE_FMT_S16)
 543                     L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
 544                 else
 545                     L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
 546                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
 547                 L = L2;
 548                 if(type != AV_SAMPLE_FMT_S16)
 549                     R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
 550                 else
 551                     R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
 552                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
 553                 R = R2;
 554                 s->decorr[i].samplesA[0] = R;
 555             }else{
 556                 if(type != AV_SAMPLE_FMT_S16)
 557                     R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
 558                 else
 559                     R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
 560                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
 561                 R = R2;
 562
 563                 if(t == -3){
 564                     R2 = s->decorr[i].samplesA[0];
 565                     s->decorr[i].samplesA[0] = R;
 566                 }
 567
 568                 if(type != AV_SAMPLE_FMT_S16)
 569                     L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
 570                 else
 571                     L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
 572                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
 573                 L = L2;
 574                 s->decorr[i].samplesB[0] = L;
 575             }
 576         }
 577         pos = (pos + 1) & 7;
 578         if(s->joint)
 579             L += (R -= (L >> 1));
 580         crc = (crc * 3 + L) * 3 + R;
 581
 582         if(type == AV_SAMPLE_FMT_FLT){
 583             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
 584             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
 585             dstfl += channel_pad;
 586         } else if(type == AV_SAMPLE_FMT_S32){
 587             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
 588             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
 589             dst32 += channel_pad;
 590         } else {
 591             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
 592             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
 593             dst16 += channel_pad;
 594         }
 595         count++;
 596     }while(!last && count < s->max_samples);
 597
 598     if (last)
 599         s->samples_left = 0;
 600     else
 601         s->samples_left -= count;
 602     if(!s->samples_left){
 603         if(crc != s->CRC){
 604             av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
 605             return -1;
 606         }
 607         if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
 608             av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 609             return -1;
 610         }
 611         wv_reset_saved_context(s);
 612     }else{
 613         s->pos = pos;
 614         s->sc.crc = crc;
 615         s->sc.bits_used = get_bits_count(&s->gb);
 616         if(s->got_extra_bits){
 617             s->extra_sc.crc = crc_extra_bits;
 618             s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
 619         }
 620     }
 621     return count * 2;
 622 }
 623
 624 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
 625 {
 626     int i, j, count = 0;
 627     int last, t;
 628     int A, S, T;
 629     int pos = s->pos;
 630     uint32_t crc = s->sc.crc;
 631     uint32_t crc_extra_bits = s->extra_sc.crc;
 632     int16_t *dst16 = dst;
 633     int32_t *dst32 = dst;
 634     float   *dstfl = dst;
 635     const int channel_stride = s->avctx->channels;
 636
 637     if(s->samples_left == s->samples)
 638         s->one = s->zero = s->zeroes = 0;
 639     do{
 640         T = wv_get_value(s, gb, 0, &last);
 641         S = 0;
 642         if(last) break;
 643         for(i = 0; i < s->terms; i++){
 644             t = s->decorr[i].value;
 645             if(t > 8){
 646                 if(t & 1)
 647                     A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 648                 else
 649                     A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 650                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 651                 j = 0;
 652             }else{
 653                 A = s->decorr[i].samplesA[pos];
 654                 j = (pos + t) & 7;
 655             }
 656             if(type != AV_SAMPLE_FMT_S16)
 657                 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 658             else
 659                 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
 660             if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 661             s->decorr[i].samplesA[j] = T = S;
 662         }
 663         pos = (pos + 1) & 7;
 664         crc = crc * 3 + S;
 665
 666         if(type == AV_SAMPLE_FMT_FLT){
 667             *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
 668             dstfl += channel_stride;
 669         }else if(type == AV_SAMPLE_FMT_S32){
 670             *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
 671             dst32 += channel_stride;
 672         }else{
 673             *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
 674             dst16 += channel_stride;
 675         }
 676         count++;
 677     }while(!last && count < s->max_samples);
 678
 679     if (last)
 680         s->samples_left = 0;
 681     else
 682         s->samples_left -= count;
 683     if(!s->samples_left){
 684         if(crc != s->CRC){
 685             av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
 686             return -1;
 687         }
 688         if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
 689             av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 690             return -1;
 691         }
 692         wv_reset_saved_context(s);
 693     }else{
 694         s->pos = pos;
 695         s->sc.crc = crc;
 696         s->sc.bits_used = get_bits_count(&s->gb);
 697         if(s->got_extra_bits){
 698             s->extra_sc.crc = crc_extra_bits;
 699             s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
 700         }
 701     }
 702     return count;
 703 }
 704
 705 static av_cold int wv_alloc_frame_context(WavpackContext *c)
 706 {
 707
 708     if(c->fdec_num == WV_MAX_FRAME_DECODERS)
 709         return -1;
 710
 711     c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
 712     if(!c->fdec[c->fdec_num])
 713         return -1;
 714     c->fdec_num++;
 715     c->fdec[c->fdec_num - 1]->avctx = c->avctx;
 716     wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
 717
 718     return 0;
 719 }
 720
 721 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
 722 {
 723     WavpackContext *s = avctx->priv_data;
 724
 725     s->avctx = avctx;
 726     if(avctx->bits_per_coded_sample <= 16)
 727         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 728     else
 729         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 730     if(avctx->channels <= 2 && !avctx->channel_layout)
 731         avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
 732
 733     s->multichannel = avctx->channels > 2;
 734     /* lavf demuxer does not provide extradata, Matroska stores 0x403
 735        there, use this to detect decoding mode for multichannel */
 736     s->mkv_mode = 0;
 737     if(s->multichannel && avctx->extradata && avctx->extradata_size == 2){
 738         int ver = AV_RL16(avctx->extradata);
 739         if(ver >= 0x402 && ver <= 0x410)
 740             s->mkv_mode = 1;
 741     }
 742
 743     s->fdec_num = 0;
 744
 745     return 0;
 746 }
 747
 748 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
 749 {
 750     WavpackContext *s = avctx->priv_data;
 751     int i;
 752
 753     for(i = 0; i < s->fdec_num; i++)
 754         av_freep(&s->fdec[i]);
 755     s->fdec_num = 0;
 756
 757     return 0;
 758 }
 759
 760 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
 761                                 void *data, int *data_size,
 762                                 const uint8_t *buf, int buf_size)
 763 {
 764     WavpackContext *wc = avctx->priv_data;
 765     WavpackFrameContext *s;
 766     void *samples = data;
 767     int samplecount;
 768     int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
 769     int got_hybrid = 0;
 770     const uint8_t* orig_buf = buf;
 771     const uint8_t* buf_end = buf + buf_size;
 772     int i, j, id, size, ssize, weights, t;
 773     int bpp, chan, chmask;
 774
 775     if (buf_size == 0){
 776         *data_size = 0;
 777         return 0;
 778     }
 779
 780     if(block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0){
 781         av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
 782         return -1;
 783     }
 784
 785     s = wc->fdec[block_no];
 786     if(!s){
 787         av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
 788         return -1;
 789     }
 790
 791     if(!s->samples_left){
 792         memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
 793         memset(s->ch, 0, sizeof(s->ch));
 794         s->extra_bits = 0;
 795         s->and = s->or = s->shift = 0;
 796         s->got_extra_bits = 0;
 797     }
 798
 799     if(!wc->mkv_mode){
 800         s->samples = AV_RL32(buf); buf += 4;
 801         if(!s->samples){
 802             *data_size = 0;
 803             return buf_size;
 804         }
 805     }else{
 806         s->samples = wc->samples;
 807     }
 808     s->frame_flags = AV_RL32(buf); buf += 4;
 809     if(s->frame_flags&0x80){
 810         bpp = sizeof(float);
 811         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
 812     } else if((s->frame_flags&0x03) <= 1){
 813         bpp = 2;
 814         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 815     } else {
 816         bpp = 4;
 817         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 818     }
 819     samples = (uint8_t*)samples + bpp * wc->ch_offset;
 820
 821     s->stereo = !(s->frame_flags & WV_MONO);
 822     s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
 823     s->joint = s->frame_flags & WV_JOINT_STEREO;
 824     s->hybrid = s->frame_flags & WV_HYBRID_MODE;
 825     s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
 826     s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
 827     s->CRC = AV_RL32(buf); buf += 4;
 828     if(wc->mkv_mode)
 829         buf += 4; //skip block size;
 830
 831     wc->ch_offset += 1 + s->stereo;
 832
 833     s->max_samples = *data_size / (bpp * avctx->channels);
 834     s->max_samples = FFMIN(s->max_samples, s->samples);
 835     if(s->samples_left > 0){
 836         s->max_samples = FFMIN(s->max_samples, s->samples_left);
 837         buf = buf_end;
 838     }
 839
 840     // parse metadata blocks
 841     while(buf < buf_end){
 842         id = *buf++;
 843         size = *buf++;
 844         if(id & WP_IDF_LONG) {
 845             size |= (*buf++) << 8;
 846             size |= (*buf++) << 16;
 847         }
 848         size <<= 1; // size is specified in words
 849         ssize = size;
 850         if(id & WP_IDF_ODD) size--;
 851         if(size < 0){
 852             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
 853             break;
 854         }
 855         if(buf + ssize > buf_end){
 856             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
 857             break;
 858         }
 859         if(id & WP_IDF_IGNORE){
 860             buf += ssize;
 861             continue;
 862         }
 863         switch(id & WP_IDF_MASK){
 864         case WP_ID_DECTERMS:
 865             if(size > MAX_TERMS){
 866                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
 867                 s->terms = 0;
 868                 buf += ssize;
 869                 continue;
 870             }
 871             s->terms = size;
 872             for(i = 0; i < s->terms; i++) {
 873                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
 874                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
 875                 buf++;
 876             }
 877             got_terms = 1;
 878             break;
 879         case WP_ID_DECWEIGHTS:
 880             if(!got_terms){
 881                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 882                 continue;
 883             }
 884             weights = size >> s->stereo_in;
 885             if(weights > MAX_TERMS || weights > s->terms){
 886                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
 887                 buf += ssize;
 888                 continue;
 889             }
 890             for(i = 0; i < weights; i++) {
 891                 t = (int8_t)(*buf++);
 892                 s->decorr[s->terms - i - 1].weightA = t << 3;
 893                 if(s->decorr[s->terms - i - 1].weightA > 0)
 894                     s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
 895                 if(s->stereo_in){
 896                     t = (int8_t)(*buf++);
 897                     s->decorr[s->terms - i - 1].weightB = t << 3;
 898                     if(s->decorr[s->terms - i - 1].weightB > 0)
 899                         s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
 900                 }
 901             }
 902             got_weights = 1;
 903             break;
 904         case WP_ID_DECSAMPLES:
 905             if(!got_terms){
 906                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 907                 continue;
 908             }
 909             t = 0;
 910             for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
 911                 if(s->decorr[i].value > 8){
 912                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 913                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 914                     if(s->stereo_in){
 915                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 916                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 917                         t += 4;
 918                     }
 919                     t += 4;
 920                 }else if(s->decorr[i].value < 0){
 921                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 922                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 923                     t += 4;
 924                 }else{
 925                     for(j = 0; j < s->decorr[i].value; j++){
 926                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 927                         if(s->stereo_in){
 928                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 929                         }
 930                     }
 931                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
 932                 }
 933             }
 934             got_samples = 1;
 935             break;
 936         case WP_ID_ENTROPY:
 937             if(size != 6 * (s->stereo_in + 1)){
 938                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
 939                 buf += ssize;
 940                 continue;
 941             }
 942             for(j = 0; j <= s->stereo_in; j++){
 943                 for(i = 0; i < 3; i++){
 944                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
 945                     buf += 2;
 946                 }
 947             }
 948             got_entropy = 1;
 949             break;
 950         case WP_ID_HYBRID:
 951             if(s->hybrid_bitrate){
 952                 for(i = 0; i <= s->stereo_in; i++){
 953                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
 954                     buf += 2;
 955                     size -= 2;
 956                 }
 957             }
 958             for(i = 0; i < (s->stereo_in + 1); i++){
 959                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
 960                 buf += 2;
 961                 size -= 2;
 962             }
 963             if(size > 0){
 964                 for(i = 0; i < (s->stereo_in + 1); i++){
 965                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
 966                     buf += 2;
 967                 }
 968             }else{
 969                 for(i = 0; i < (s->stereo_in + 1); i++)
 970                     s->ch[i].bitrate_delta = 0;
 971             }
 972             got_hybrid = 1;
 973             break;
 974         case WP_ID_INT32INFO:
 975             if(size != 4){
 976                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
 977                 buf += ssize;
 978                 continue;
 979             }
 980             if(buf[0])
 981                 s->extra_bits = buf[0];
 982             else if(buf[1])
 983                 s->shift = buf[1];
 984             else if(buf[2]){
 985                 s->and = s->or = 1;
 986                 s->shift = buf[2];
 987             }else if(buf[3]){
 988                 s->and = 1;
 989                 s->shift = buf[3];
 990             }
 991             buf += 4;
 992             break;
 993         case WP_ID_FLOATINFO:
 994             if(size != 4){
 995                 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
 996                 buf += ssize;
 997                 continue;
 998             }
 999             s->float_flag = buf[0];
1000             s->float_shift = buf[1];
1001             s->float_max_exp = buf[2];
1002             buf += 4;
1003             got_float = 1;
1004             break;
1005         case WP_ID_DATA:
1006             s->sc.offset = buf - orig_buf;
1007             s->sc.size   = size * 8;
1008             init_get_bits(&s->gb, buf, size * 8);
1009             s->data_size = size * 8;
1010             buf += size;
1011             got_bs = 1;
1012             break;
1013         case WP_ID_EXTRABITS:
1014             if(size <= 4){
1015                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
1016                 buf += size;
1017                 continue;
1018             }
1019             s->extra_sc.offset = buf - orig_buf;
1020             s->extra_sc.size   = size * 8;
1021             init_get_bits(&s->gb_extra_bits, buf, size * 8);
1022             s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1023             buf += size;
1024             s->got_extra_bits = 1;
1025             break;
1026         case WP_ID_CHANINFO:
1027             if(size <= 1){
1028                 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1029                 return -1;
1030             }
1031             chan = *buf++;
1032             switch(size - 2){
1033             case 0:
1034                 chmask = *buf;
1035                 break;
1036             case 1:
1037                 chmask = AV_RL16(buf);
1038                 break;
1039             case 2:
1040                 chmask = AV_RL24(buf);
1041                 break;
1042             case 3:
1043                 chmask = AV_RL32(buf);
1044                 break;
1045             case 5:
1046                 chan |= (buf[1] & 0xF) << 8;
1047                 chmask = AV_RL24(buf + 2);
1048                 break;
1049             default:
1050                 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);
1051                 chan = avctx->channels;
1052                 chmask = avctx->channel_layout;
1053             }
1054             if(chan != avctx->channels){
1055                 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, decoder believes it's %d channels\n",
1056                        chan, avctx->channels);
1057                 return -1;
1058             }
1059             if(!avctx->channel_layout)
1060                 avctx->channel_layout = chmask;
1061             buf += size - 1;
1062             break;
1063         default:
1064             buf += size;
1065         }
1066         if(id & WP_IDF_ODD) buf++;
1067     }
1068     if(!s->samples_left){
1069         if(!got_terms){
1070             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1071             return -1;
1072         }
1073         if(!got_weights){
1074             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1075             return -1;
1076         }
1077         if(!got_samples){
1078             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1079             return -1;
1080         }
1081         if(!got_entropy){
1082             av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1083             return -1;
1084         }
1085         if(s->hybrid && !got_hybrid){
1086             av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1087             return -1;
1088         }
1089         if(!got_bs){
1090             av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1091             return -1;
1092         }
1093         if(!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT){
1094             av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1095             return -1;
1096         }
1097         if(s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT){
1098             const int size = get_bits_left(&s->gb_extra_bits);
1099             const int wanted = s->samples * s->extra_bits << s->stereo_in;
1100             if(size < wanted){
1101                 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1102                 s->got_extra_bits = 0;
1103             }
1104         }
1105         s->samples_left = s->samples;
1106     }else{
1107         init_get_bits(&s->gb, orig_buf + s->sc.offset, s->sc.size);
1108         skip_bits_long(&s->gb, s->sc.bits_used);
1109         if(s->got_extra_bits){
1110             init_get_bits(&s->gb_extra_bits, orig_buf + s->extra_sc.offset,
1111                           s->extra_sc.size);
1112             skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
1113         }
1114     }
1115
1116     if(s->stereo_in){
1117         if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1118             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1119         else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1120             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1121         else
1122             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1123
1124         if (samplecount < 0)
1125             return -1;
1126
1127         samplecount >>= 1;
1128     }else{
1129         const int channel_stride = avctx->channels;
1130
1131         if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1132             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1133         else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1134             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1135         else
1136             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1137
1138         if (samplecount < 0)
1139             return -1;
1140
1141         if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16){
1142             int16_t *dst = (int16_t*)samples + 1;
1143             int16_t *src = (int16_t*)samples;
1144             int cnt = samplecount;
1145             while(cnt--){
1146                 *dst = *src;
1147                 src += channel_stride;
1148                 dst += channel_stride;
1149             }
1150         }else if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32){
1151             int32_t *dst = (int32_t*)samples + 1;
1152             int32_t *src = (int32_t*)samples;
1153             int cnt = samplecount;
1154             while(cnt--){
1155                 *dst = *src;
1156                 src += channel_stride;
1157                 dst += channel_stride;
1158             }
1159         }else if(s->stereo){
1160             float *dst = (float*)samples + 1;
1161             float *src = (float*)samples;
1162             int cnt = samplecount;
1163             while(cnt--){
1164                 *dst = *src;
1165                 src += channel_stride;
1166                 dst += channel_stride;
1167             }
1168         }
1169     }
1170
1171     wc->samples_left = s->samples_left;
1172
1173     return samplecount * bpp;
1174 }
1175
1176 static int wavpack_decode_frame(AVCodecContext *avctx,
1177                             void *data, int *data_size,
1178                             AVPacket *avpkt)
1179 {
1180     WavpackContext *s = avctx->priv_data;
1181     const uint8_t *buf = avpkt->data;
1182     int buf_size = avpkt->size;
1183     int frame_size;
1184     int samplecount = 0;
1185
1186     s->block = 0;
1187     s->samples_left = 0;
1188     s->ch_offset = 0;
1189
1190     if(s->mkv_mode){
1191         s->samples = AV_RL32(buf); buf += 4;
1192     }
1193     while(buf_size > 0){
1194         if(!s->multichannel){
1195             frame_size = buf_size;
1196         }else{
1197             if(!s->mkv_mode){
1198                 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1199             }else{
1200                 if(buf_size < 12) //MKV files can have zero flags after last block
1201                     break;
1202                 frame_size = AV_RL32(buf + 8) + 12;
1203             }
1204         }
1205         if(frame_size < 0 || frame_size > buf_size){
1206             av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",
1207                    s->block, frame_size, buf_size);
1208             return -1;
1209         }
1210         if((samplecount = wavpack_decode_block(avctx, s->block, data,
1211                                                data_size, buf, frame_size)) < 0)
1212             return -1;
1213         s->block++;
1214         buf += frame_size; buf_size -= frame_size;
1215     }
1216     *data_size = samplecount * avctx->channels;
1217
1218     return s->samples_left > 0 ? 0 : avpkt->size;
1219 }
1220
1221 AVCodec ff_wavpack_decoder = {
1222     "wavpack",
1223     AVMEDIA_TYPE_AUDIO,
1224     CODEC_ID_WAVPACK,
1225     sizeof(WavpackContext),
1226     wavpack_decode_init,
1227     NULL,
1228     wavpack_decode_end,
1229     wavpack_decode_frame,
1230     .capabilities = CODEC_CAP_SUBFRAMES,
1231     .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
1232 };