libavcodec/wavpack.c

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