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

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