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