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->samples_left = 0;
 489     s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
 490 }
 491
 492 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
 493 {
 494     int i, j, count = 0;
 495     int last, t;
 496     int A, B, L, L2, R, R2;
 497     int pos = s->pos;
 498     uint32_t crc = s->sc.crc;
 499     uint32_t crc_extra_bits = s->extra_sc.crc;
 500     int16_t *dst16 = dst;
 501     int32_t *dst32 = dst;
 502     float   *dstfl = dst;
 503     const int channel_pad = s->avctx->channels - 2;
 504
 505     if(s->samples_left == s->samples)
 506         s->one = s->zero = s->zeroes = 0;
 507     do{
 508         L = wv_get_value(s, gb, 0, &last);
 509         if(last) break;
 510         R = wv_get_value(s, gb, 1, &last);
 511         if(last) break;
 512         for(i = 0; i < s->terms; i++){
 513             t = s->decorr[i].value;
 514             if(t > 0){
 515                 if(t > 8){
 516                     if(t & 1){
 517                         A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 518                         B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
 519                     }else{
 520                         A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 521                         B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
 522                     }
 523                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 524                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
 525                     j = 0;
 526                 }else{
 527                     A = s->decorr[i].samplesA[pos];
 528                     B = s->decorr[i].samplesB[pos];
 529                     j = (pos + t) & 7;
 530                 }
 531                 if(type != AV_SAMPLE_FMT_S16){
 532                     L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 533                     R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
 534                 }else{
 535                     L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
 536                     R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
 537                 }
 538                 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 539                 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
 540                 s->decorr[i].samplesA[j] = L = L2;
 541                 s->decorr[i].samplesB[j] = R = R2;
 542             }else if(t == -1){
 543                 if(type != AV_SAMPLE_FMT_S16)
 544                     L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
 545                 else
 546                     L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
 547                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
 548                 L = L2;
 549                 if(type != AV_SAMPLE_FMT_S16)
 550                     R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
 551                 else
 552                     R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
 553                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
 554                 R = R2;
 555                 s->decorr[i].samplesA[0] = R;
 556             }else{
 557                 if(type != AV_SAMPLE_FMT_S16)
 558                     R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
 559                 else
 560                     R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
 561                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
 562                 R = R2;
 563
 564                 if(t == -3){
 565                     R2 = s->decorr[i].samplesA[0];
 566                     s->decorr[i].samplesA[0] = R;
 567                 }
 568
 569                 if(type != AV_SAMPLE_FMT_S16)
 570                     L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
 571                 else
 572                     L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
 573                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
 574                 L = L2;
 575                 s->decorr[i].samplesB[0] = L;
 576             }
 577         }
 578         pos = (pos + 1) & 7;
 579         if(s->joint)
 580             L += (R -= (L >> 1));
 581         crc = (crc * 3 + L) * 3 + R;
 582
 583         if(type == AV_SAMPLE_FMT_FLT){
 584             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
 585             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
 586             dstfl += channel_pad;
 587         } else if(type == AV_SAMPLE_FMT_S32){
 588             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
 589             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
 590             dst32 += channel_pad;
 591         } else {
 592             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
 593             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
 594             dst16 += channel_pad;
 595         }
 596         count++;
 597     }while(!last && count < s->max_samples);
 598
 599     if (last)
 600         s->samples_left = 0;
 601     else
 602         s->samples_left -= count;
 603     if(!s->samples_left){
 604         wv_reset_saved_context(s);
 605         if(crc != s->CRC){
 606             av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
 607             return -1;
 608         }
 609         if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
 610             av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 611             return -1;
 612         }
 613     }else{
 614         s->pos = pos;
 615         s->sc.crc = crc;
 616         s->sc.bits_used = get_bits_count(&s->gb);
 617         if(s->got_extra_bits){
 618             s->extra_sc.crc = crc_extra_bits;
 619             s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
 620         }
 621     }
 622     return count * 2;
 623 }
 624
 625 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
 626 {
 627     int i, j, count = 0;
 628     int last, t;
 629     int A, S, T;
 630     int pos = s->pos;
 631     uint32_t crc = s->sc.crc;
 632     uint32_t crc_extra_bits = s->extra_sc.crc;
 633     int16_t *dst16 = dst;
 634     int32_t *dst32 = dst;
 635     float   *dstfl = dst;
 636     const int channel_stride = s->avctx->channels;
 637
 638     if(s->samples_left == s->samples)
 639         s->one = s->zero = s->zeroes = 0;
 640     do{
 641         T = wv_get_value(s, gb, 0, &last);
 642         S = 0;
 643         if(last) break;
 644         for(i = 0; i < s->terms; i++){
 645             t = s->decorr[i].value;
 646             if(t > 8){
 647                 if(t & 1)
 648                     A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 649                 else
 650                     A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 651                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 652                 j = 0;
 653             }else{
 654                 A = s->decorr[i].samplesA[pos];
 655                 j = (pos + t) & 7;
 656             }
 657             if(type != AV_SAMPLE_FMT_S16)
 658                 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 659             else
 660                 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
 661             if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 662             s->decorr[i].samplesA[j] = T = S;
 663         }
 664         pos = (pos + 1) & 7;
 665         crc = crc * 3 + S;
 666
 667         if(type == AV_SAMPLE_FMT_FLT){
 668             *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
 669             dstfl += channel_stride;
 670         }else if(type == AV_SAMPLE_FMT_S32){
 671             *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
 672             dst32 += channel_stride;
 673         }else{
 674             *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
 675             dst16 += channel_stride;
 676         }
 677         count++;
 678     }while(!last && count < s->max_samples);
 679
 680     if (last)
 681         s->samples_left = 0;
 682     else
 683         s->samples_left -= count;
 684     if(!s->samples_left){
 685         wv_reset_saved_context(s);
 686         if(crc != s->CRC){
 687             av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
 688             return -1;
 689         }
 690         if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
 691             av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 692             return -1;
 693         }
 694     }else{
 695         s->pos = pos;
 696         s->sc.crc = crc;
 697         s->sc.bits_used = get_bits_count(&s->gb);
 698         if(s->got_extra_bits){
 699             s->extra_sc.crc = crc_extra_bits;
 700             s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
 701         }
 702     }
 703     return count;
 704 }
 705
 706 static av_cold int wv_alloc_frame_context(WavpackContext *c)
 707 {
 708
 709     if(c->fdec_num == WV_MAX_FRAME_DECODERS)
 710         return -1;
 711
 712     c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
 713     if(!c->fdec[c->fdec_num])
 714         return -1;
 715     c->fdec_num++;
 716     c->fdec[c->fdec_num - 1]->avctx = c->avctx;
 717     wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
 718
 719     return 0;
 720 }
 721
 722 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
 723 {
 724     WavpackContext *s = avctx->priv_data;
 725
 726     s->avctx = avctx;
 727     if(avctx->bits_per_coded_sample <= 16)
 728         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 729     else
 730         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 731     if(avctx->channels <= 2 && !avctx->channel_layout)
 732         avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
 733
 734     s->multichannel = avctx->channels > 2;
 735     /* lavf demuxer does not provide extradata, Matroska stores 0x403
 736        there, use this to detect decoding mode for multichannel */
 737     s->mkv_mode = 0;
 738     if(s->multichannel && avctx->extradata && avctx->extradata_size == 2){
 739         int ver = AV_RL16(avctx->extradata);
 740         if(ver >= 0x402 && ver <= 0x410)
 741             s->mkv_mode = 1;
 742     }
 743
 744     s->fdec_num = 0;
 745
 746     return 0;
 747 }
 748
 749 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
 750 {
 751     WavpackContext *s = avctx->priv_data;
 752     int i;
 753
 754     for(i = 0; i < s->fdec_num; i++)
 755         av_freep(&s->fdec[i]);
 756     s->fdec_num = 0;
 757
 758     return 0;
 759 }
 760
 761 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
 762                                 void *data, int *data_size,
 763                                 const uint8_t *buf, int buf_size)
 764 {
 765     WavpackContext *wc = avctx->priv_data;
 766     WavpackFrameContext *s;
 767     void *samples = data;
 768     int samplecount;
 769     int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
 770     int got_hybrid = 0;
 771     const uint8_t* orig_buf = buf;
 772     const uint8_t* buf_end = buf + buf_size;
 773     int i, j, id, size, ssize, weights, t;
 774     int bpp, chan, chmask;
 775
 776     if (buf_size == 0){
 777         *data_size = 0;
 778         return 0;
 779     }
 780
 781     if(block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0){
 782         av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
 783         return -1;
 784     }
 785
 786     s = wc->fdec[block_no];
 787     if(!s){
 788         av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
 789         return -1;
 790     }
 791
 792     if(!s->samples_left){
 793         memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
 794         memset(s->ch, 0, sizeof(s->ch));
 795         s->extra_bits = 0;
 796         s->and = s->or = s->shift = 0;
 797         s->got_extra_bits = 0;
 798     }
 799
 800     if(!wc->mkv_mode){
 801         s->samples = AV_RL32(buf); buf += 4;
 802         if(!s->samples){
 803             *data_size = 0;
 804             return 0;
 805         }
 806     }else{
 807         s->samples = wc->samples;
 808     }
 809     s->frame_flags = AV_RL32(buf); buf += 4;
 810     if(s->frame_flags&0x80){
 811         bpp = sizeof(float);
 812         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
 813     } else if((s->frame_flags&0x03) <= 1){
 814         bpp = 2;
 815         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 816     } else {
 817         bpp = 4;
 818         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 819     }
 820     samples = (uint8_t*)samples + bpp * wc->ch_offset;
 821
 822     s->stereo = !(s->frame_flags & WV_MONO);
 823     s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
 824     s->joint = s->frame_flags & WV_JOINT_STEREO;
 825     s->hybrid = s->frame_flags & WV_HYBRID_MODE;
 826     s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
 827     s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
 828     s->CRC = AV_RL32(buf); buf += 4;
 829     if(wc->mkv_mode)
 830         buf += 4; //skip block size;
 831
 832     wc->ch_offset += 1 + s->stereo;
 833
 834     s->max_samples = *data_size / (bpp * avctx->channels);
 835     s->max_samples = FFMIN(s->max_samples, s->samples);
 836     if(s->samples_left > 0){
 837         s->max_samples = FFMIN(s->max_samples, s->samples_left);
 838         buf = buf_end;
 839     }
 840
 841     // parse metadata blocks
 842     while(buf < buf_end){
 843         id = *buf++;
 844         size = *buf++;
 845         if(id & WP_IDF_LONG) {
 846             size |= (*buf++) << 8;
 847             size |= (*buf++) << 16;
 848         }
 849         size <<= 1; // size is specified in words
 850         ssize = size;
 851         if(id & WP_IDF_ODD) size--;
 852         if(size < 0){
 853             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
 854             break;
 855         }
 856         if(buf + ssize > buf_end){
 857             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
 858             break;
 859         }
 860         if(id & WP_IDF_IGNORE){
 861             buf += ssize;
 862             continue;
 863         }
 864         switch(id & WP_IDF_MASK){
 865         case WP_ID_DECTERMS:
 866             s->terms = size;
 867             if(s->terms > MAX_TERMS){
 868                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
 869                 buf += ssize;
 870                 continue;
 871             }
 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 static void wavpack_decode_flush(AVCodecContext *avctx)
1222 {
1223     WavpackContext *s = avctx->priv_data;
1224     int i;
1225
1226     for (i = 0; i < s->fdec_num; i++)
1227         wv_reset_saved_context(s->fdec[i]);
1228 }
1229
1230 AVCodec ff_wavpack_decoder = {
1231     .name           = "wavpack",
1232     .type           = AVMEDIA_TYPE_AUDIO,
1233     .id             = CODEC_ID_WAVPACK,
1234     .priv_data_size = sizeof(WavpackContext),
1235     .init           = wavpack_decode_init,
1236     .close          = wavpack_decode_end,
1237     .decode         = wavpack_decode_frame,
1238     .flush          = wavpack_decode_flush,
1239     .capabilities = CODEC_CAP_SUBFRAMES,
1240     .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
1241 };