libavcodec/wavpack.c

   1 /*
   2  * WavPack lossless audio decoder
   3  * Copyright (c) 2006 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 libavcodec/wavpack.c
  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 #define MAX_TERMS 16
  71
  72 typedef struct Decorr {
  73     int delta;
  74     int value;
  75     int weightA;
  76     int weightB;
  77     int samplesA[8];
  78     int samplesB[8];
  79 } Decorr;
  80
  81 typedef struct WvChannel {
  82     int median[3];
  83     int slow_level, error_limit;
  84     int bitrate_acc, bitrate_delta;
  85 } WvChannel;
  86
  87 typedef struct WavpackContext {
  88     AVCodecContext *avctx;
  89     int frame_flags;
  90     int stereo, stereo_in;
  91     int joint;
  92     uint32_t CRC;
  93     GetBitContext gb;
  94     int got_extra_bits;
  95     uint32_t crc_extra_bits;
  96     GetBitContext gb_extra_bits;
  97     int data_size; // in bits
  98     int samples;
  99     int terms;
 100     Decorr decorr[MAX_TERMS];
 101     int zero, one, zeroes;
 102     int extra_bits;
 103     int and, or, shift;
 104     int post_shift;
 105     int hybrid, hybrid_bitrate;
 106     int float_flag;
 107     int float_shift;
 108     int float_max_exp;
 109     WvChannel ch[2];
 110 } WavpackContext;
 111
 112 // exponent table copied from WavPack source
 113 static const uint8_t wp_exp2_table [256] = {
 114     0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
 115     0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
 116     0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
 117     0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
 118     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
 119     0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
 120     0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
 121     0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
 122     0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
 123     0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
 124     0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
 125     0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
 126     0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
 127     0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
 128     0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
 129     0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
 130 };
 131
 132 static const uint8_t wp_log2_table [] = {
 133     0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
 134     0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
 135     0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
 136     0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
 137     0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
 138     0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
 139     0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
 140     0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
 141     0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
 142     0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
 143     0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
 144     0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
 145     0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
 146     0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
 147     0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
 148     0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
 149 };
 150
 151 static av_always_inline int wp_exp2(int16_t val)
 152 {
 153     int res, neg = 0;
 154
 155     if(val < 0){
 156         val = -val;
 157         neg = 1;
 158     }
 159
 160     res = wp_exp2_table[val & 0xFF] | 0x100;
 161     val >>= 8;
 162     res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
 163     return neg ? -res : res;
 164 }
 165
 166 static av_always_inline int wp_log2(int32_t val)
 167 {
 168     int bits;
 169
 170     if(!val)
 171         return 0;
 172     if(val == 1)
 173         return 256;
 174     val += val >> 9;
 175     bits = av_log2(val) + 1;
 176     if(bits < 9)
 177         return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
 178     else
 179         return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
 180 }
 181
 182 #define LEVEL_DECAY(a)  ((a + 0x80) >> 8)
 183
 184 // macros for manipulating median values
 185 #define GET_MED(n) ((c->median[n] >> 4) + 1)
 186 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2
 187 #define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5
 188
 189 // macros for applying weight
 190 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
 191         if(samples && in){ \
 192             if((samples ^ in) < 0){ \
 193                 weight -= delta; \
 194                 if(weight < -1024) weight = -1024; \
 195             }else{ \
 196                 weight += delta; \
 197                 if(weight > 1024) weight = 1024; \
 198             } \
 199         }
 200
 201
 202 static av_always_inline int get_tail(GetBitContext *gb, int k)
 203 {
 204     int p, e, res;
 205
 206     if(k<1)return 0;
 207     p = av_log2(k);
 208     e = (1 << (p + 1)) - k - 1;
 209     res = p ? get_bits(gb, p) : 0;
 210     if(res >= e){
 211         res = (res<<1) - e + get_bits1(gb);
 212     }
 213     return res;
 214 }
 215
 216 static void update_error_limit(WavpackContext *ctx)
 217 {
 218     int i, br[2], sl[2];
 219
 220     for(i = 0; i <= ctx->stereo_in; i++){
 221         ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
 222         br[i] = ctx->ch[i].bitrate_acc >> 16;
 223         sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
 224     }
 225     if(ctx->stereo_in && ctx->hybrid_bitrate){
 226         int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
 227         if(balance > br[0]){
 228             br[1] = br[0] << 1;
 229             br[0] = 0;
 230         }else if(-balance > br[0]){
 231             br[0] <<= 1;
 232             br[1] = 0;
 233         }else{
 234             br[1] = br[0] + balance;
 235             br[0] = br[0] - balance;
 236         }
 237     }
 238     for(i = 0; i <= ctx->stereo_in; i++){
 239         if(ctx->hybrid_bitrate){
 240             if(sl[i] - br[i] > -0x100)
 241                 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
 242             else
 243                 ctx->ch[i].error_limit = 0;
 244         }else{
 245             ctx->ch[i].error_limit = wp_exp2(br[i]);
 246         }
 247     }
 248 }
 249
 250 static int wv_get_value(WavpackContext *ctx, GetBitContext *gb, int channel, int *last)
 251 {
 252     int t, t2;
 253     int sign, base, add, ret;
 254     WvChannel *c = &ctx->ch[channel];
 255
 256     *last = 0;
 257
 258     if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){
 259         if(ctx->zeroes){
 260             ctx->zeroes--;
 261             if(ctx->zeroes){
 262                 c->slow_level -= LEVEL_DECAY(c->slow_level);
 263                 return 0;
 264             }
 265         }else{
 266             t = get_unary_0_33(gb);
 267             if(t >= 2) t = get_bits(gb, t - 1) | (1 << (t-1));
 268             ctx->zeroes = t;
 269             if(ctx->zeroes){
 270                 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
 271                 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
 272                 c->slow_level -= LEVEL_DECAY(c->slow_level);
 273                 return 0;
 274             }
 275         }
 276     }
 277
 278     if(get_bits_count(gb) >= ctx->data_size){
 279         *last = 1;
 280         return 0;
 281     }
 282
 283     if(ctx->zero){
 284         t = 0;
 285         ctx->zero = 0;
 286     }else{
 287         t = get_unary_0_33(gb);
 288         if(get_bits_count(gb) >= ctx->data_size){
 289             *last = 1;
 290             return 0;
 291         }
 292         if(t == 16) {
 293             t2 = get_unary_0_33(gb);
 294             if(t2 < 2) t += t2;
 295             else t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
 296         }
 297
 298         if(ctx->one){
 299             ctx->one = t&1;
 300             t = (t>>1) + 1;
 301         }else{
 302             ctx->one = t&1;
 303             t >>= 1;
 304         }
 305         ctx->zero = !ctx->one;
 306     }
 307
 308     if(ctx->hybrid && !channel)
 309         update_error_limit(ctx);
 310
 311     if(!t){
 312         base = 0;
 313         add = GET_MED(0) - 1;
 314         DEC_MED(0);
 315     }else if(t == 1){
 316         base = GET_MED(0);
 317         add = GET_MED(1) - 1;
 318         INC_MED(0);
 319         DEC_MED(1);
 320     }else if(t == 2){
 321         base = GET_MED(0) + GET_MED(1);
 322         add = GET_MED(2) - 1;
 323         INC_MED(0);
 324         INC_MED(1);
 325         DEC_MED(2);
 326     }else{
 327         base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
 328         add = GET_MED(2) - 1;
 329         INC_MED(0);
 330         INC_MED(1);
 331         INC_MED(2);
 332     }
 333     if(!c->error_limit){
 334         ret = base + get_tail(gb, add);
 335     }else{
 336         int mid = (base*2 + add + 1) >> 1;
 337         while(add > c->error_limit){
 338             if(get_bits1(gb)){
 339                 add -= (mid - base);
 340                 base = mid;
 341             }else
 342                 add = mid - base - 1;
 343             mid = (base*2 + add + 1) >> 1;
 344         }
 345         ret = mid;
 346     }
 347     sign = get_bits1(gb);
 348     if(ctx->hybrid_bitrate)
 349         c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
 350     return sign ? ~ret : ret;
 351 }
 352
 353 static inline int wv_get_value_integer(WavpackContext *s, uint32_t *crc, int S)
 354 {
 355     int bit;
 356
 357     if(s->extra_bits){
 358         S <<= s->extra_bits;
 359
 360         if(s->got_extra_bits){
 361             S |= get_bits(&s->gb_extra_bits, s->extra_bits);
 362             *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
 363         }
 364     }
 365     bit = (S & s->and) | s->or;
 366     return (((S + bit) << s->shift) - bit) << s->post_shift;
 367 }
 368
 369 static float wv_get_value_float(WavpackContext *s, uint32_t *crc, int S)
 370 {
 371     union {
 372         float    f;
 373         uint32_t u;
 374     } value;
 375
 376     int sign;
 377     int exp = s->float_max_exp;
 378
 379     if(s->got_extra_bits){
 380         const int max_bits = 1 + 23 + 8 + 1;
 381         const int left_bits = s->gb_extra_bits.size_in_bits - get_bits_count(&s->gb_extra_bits);
 382
 383         if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
 384             return 0.0;
 385     }
 386
 387     if(S){
 388         S <<= s->float_shift;
 389         sign = S < 0;
 390         if(sign)
 391             S = -S;
 392         if(S >= 0x1000000){
 393             if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
 394                 S = get_bits(&s->gb_extra_bits, 23);
 395             }else{
 396                 S = 0;
 397             }
 398             exp = 255;
 399         }else if(exp){
 400             int shift = 23 - av_log2(S);
 401             exp = s->float_max_exp;
 402             if(exp <= shift){
 403                 shift = --exp;
 404             }
 405             exp -= shift;
 406
 407             if(shift){
 408                 S <<= shift;
 409                 if((s->float_flag & WV_FLT_SHIFT_ONES) ||
 410                    (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
 411                     S |= (1 << shift) - 1;
 412                 } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
 413                     S |= get_bits(&s->gb_extra_bits, shift);
 414                 }
 415             }
 416         }else{
 417             exp = s->float_max_exp;
 418         }
 419         S &= 0x7fffff;
 420     }else{
 421         sign = 0;
 422         exp = 0;
 423         if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
 424             if(get_bits1(&s->gb_extra_bits)){
 425                 S = get_bits(&s->gb_extra_bits, 23);
 426                 if(s->float_max_exp >= 25)
 427                     exp = get_bits(&s->gb_extra_bits, 8);
 428                 sign = get_bits1(&s->gb_extra_bits);
 429             }else{
 430                 if(s->float_flag & WV_FLT_ZERO_SIGN)
 431                     sign = get_bits1(&s->gb_extra_bits);
 432             }
 433         }
 434     }
 435
 436     *crc = *crc * 27 + S * 9 + exp * 3 + sign;
 437
 438     value.u = (sign << 31) | (exp << 23) | S;
 439     return value.f;
 440 }
 441
 442 static inline int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, void *dst, const int type)
 443 {
 444     int i, j, count = 0;
 445     int last, t;
 446     int A, B, L, L2, R, R2;
 447     int pos = 0;
 448     uint32_t crc = 0xFFFFFFFF;
 449     uint32_t crc_extra_bits = 0xFFFFFFFF;
 450     int16_t *dst16 = dst;
 451     int32_t *dst32 = dst;
 452     float   *dstfl = dst;
 453
 454     s->one = s->zero = s->zeroes = 0;
 455     do{
 456         L = wv_get_value(s, gb, 0, &last);
 457         if(last) break;
 458         R = wv_get_value(s, gb, 1, &last);
 459         if(last) break;
 460         for(i = 0; i < s->terms; i++){
 461             t = s->decorr[i].value;
 462             if(t > 0){
 463                 if(t > 8){
 464                     if(t & 1){
 465                         A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 466                         B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
 467                     }else{
 468                         A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 469                         B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
 470                     }
 471                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 472                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
 473                     j = 0;
 474                 }else{
 475                     A = s->decorr[i].samplesA[pos];
 476                     B = s->decorr[i].samplesB[pos];
 477                     j = (pos + t) & 7;
 478                 }
 479                 if(type != SAMPLE_FMT_S16){
 480                     L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 481                     R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
 482                 }else{
 483                     L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
 484                     R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
 485                 }
 486                 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 487                 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
 488                 s->decorr[i].samplesA[j] = L = L2;
 489                 s->decorr[i].samplesB[j] = R = R2;
 490             }else if(t == -1){
 491                 if(type != SAMPLE_FMT_S16)
 492                     L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
 493                 else
 494                     L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
 495                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
 496                 L = L2;
 497                 if(type != SAMPLE_FMT_S16)
 498                     R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
 499                 else
 500                     R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
 501                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
 502                 R = R2;
 503                 s->decorr[i].samplesA[0] = R;
 504             }else{
 505                 if(type != SAMPLE_FMT_S16)
 506                     R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
 507                 else
 508                     R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
 509                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
 510                 R = R2;
 511
 512                 if(t == -3){
 513                     R2 = s->decorr[i].samplesA[0];
 514                     s->decorr[i].samplesA[0] = R;
 515                 }
 516
 517                 if(type != SAMPLE_FMT_S16)
 518                     L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
 519                 else
 520                     L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
 521                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
 522                 L = L2;
 523                 s->decorr[i].samplesB[0] = L;
 524             }
 525         }
 526         pos = (pos + 1) & 7;
 527         if(s->joint)
 528             L += (R -= (L >> 1));
 529         crc = (crc * 3 + L) * 3 + R;
 530
 531         if(type == SAMPLE_FMT_FLT){
 532             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
 533             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
 534         } else if(type == SAMPLE_FMT_S32){
 535             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
 536             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
 537         } else {
 538             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
 539             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
 540         }
 541         count++;
 542     }while(!last && count < s->samples);
 543
 544     if(crc != s->CRC){
 545         av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
 546         return -1;
 547     }
 548     if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
 549         av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 550         return -1;
 551     }
 552     return count * 2;
 553 }
 554
 555 static inline int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, void *dst, const int type)
 556 {
 557     int i, j, count = 0;
 558     int last, t;
 559     int A, S, T;
 560     int pos = 0;
 561     uint32_t crc = 0xFFFFFFFF;
 562     uint32_t crc_extra_bits = 0xFFFFFFFF;
 563     int16_t *dst16 = dst;
 564     int32_t *dst32 = dst;
 565     float   *dstfl = dst;
 566
 567     s->one = s->zero = s->zeroes = 0;
 568     do{
 569         T = wv_get_value(s, gb, 0, &last);
 570         S = 0;
 571         if(last) break;
 572         for(i = 0; i < s->terms; i++){
 573             t = s->decorr[i].value;
 574             if(t > 8){
 575                 if(t & 1)
 576                     A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 577                 else
 578                     A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 579                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 580                 j = 0;
 581             }else{
 582                 A = s->decorr[i].samplesA[pos];
 583                 j = (pos + t) & 7;
 584             }
 585             if(type != SAMPLE_FMT_S16)
 586                 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 587             else
 588                 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
 589             if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 590             s->decorr[i].samplesA[j] = T = S;
 591         }
 592         pos = (pos + 1) & 7;
 593         crc = crc * 3 + S;
 594
 595         if(type == SAMPLE_FMT_FLT)
 596             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S);
 597         else if(type == SAMPLE_FMT_S32)
 598             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S);
 599         else
 600             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);
 601         count++;
 602     }while(!last && count < s->samples);
 603
 604     if(crc != s->CRC){
 605         av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
 606         return -1;
 607     }
 608     if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
 609         av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 610         return -1;
 611     }
 612     return count;
 613 }
 614
 615 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
 616 {
 617     WavpackContext *s = avctx->priv_data;
 618
 619     s->avctx = avctx;
 620     s->stereo = (avctx->channels == 2);
 621     if(avctx->bits_per_coded_sample <= 16)
 622         avctx->sample_fmt = SAMPLE_FMT_S16;
 623     else
 624         avctx->sample_fmt = SAMPLE_FMT_S32;
 625     avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
 626
 627     return 0;
 628 }
 629
 630 static int wavpack_decode_frame(AVCodecContext *avctx,
 631                             void *data, int *data_size,
 632                             AVPacket *avpkt)
 633 {
 634     const uint8_t *buf = avpkt->data;
 635     int buf_size = avpkt->size;
 636     WavpackContext *s = avctx->priv_data;
 637     void *samples = data;
 638     int samplecount;
 639     int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
 640     int got_hybrid = 0;
 641     const uint8_t* buf_end = buf + buf_size;
 642     int i, j, id, size, ssize, weights, t;
 643     int bpp;
 644
 645     if (buf_size == 0){
 646         *data_size = 0;
 647         return 0;
 648     }
 649
 650     memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
 651     memset(s->ch, 0, sizeof(s->ch));
 652     s->extra_bits = 0;
 653     s->and = s->or = s->shift = 0;
 654     s->got_extra_bits = 0;
 655
 656     s->samples = AV_RL32(buf); buf += 4;
 657     if(!s->samples){
 658         *data_size = 0;
 659         return buf_size;
 660     }
 661     s->frame_flags = AV_RL32(buf); buf += 4;
 662     if(s->frame_flags&0x80){
 663         bpp = sizeof(float);
 664         avctx->sample_fmt = SAMPLE_FMT_FLT;
 665     } else if((s->frame_flags&0x03) <= 1){
 666         bpp = 2;
 667         avctx->sample_fmt = SAMPLE_FMT_S16;
 668     } else {
 669         bpp = 4;
 670         avctx->sample_fmt = SAMPLE_FMT_S32;
 671     }
 672     s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
 673     s->joint = s->frame_flags & WV_JOINT_STEREO;
 674     s->hybrid = s->frame_flags & WV_HYBRID_MODE;
 675     s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
 676     s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
 677     s->CRC = AV_RL32(buf); buf += 4;
 678
 679     /* should not happen but who knows */
 680     if(s->samples * bpp * avctx->channels > *data_size){
 681         av_log(avctx, AV_LOG_ERROR, "Packet size is too big to be handled in lavc!\n");
 682         return -1;
 683     }
 684
 685     // parse metadata blocks
 686     while(buf < buf_end){
 687         id = *buf++;
 688         size = *buf++;
 689         if(id & WP_IDF_LONG) {
 690             size |= (*buf++) << 8;
 691             size |= (*buf++) << 16;
 692         }
 693         size <<= 1; // size is specified in words
 694         ssize = size;
 695         if(id & WP_IDF_ODD) size--;
 696         if(size < 0){
 697             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
 698             break;
 699         }
 700         if(buf + ssize > buf_end){
 701             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
 702             break;
 703         }
 704         if(id & WP_IDF_IGNORE){
 705             buf += ssize;
 706             continue;
 707         }
 708         switch(id & WP_IDF_MASK){
 709         case WP_ID_DECTERMS:
 710             s->terms = size;
 711             if(s->terms > MAX_TERMS){
 712                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
 713                 buf += ssize;
 714                 continue;
 715             }
 716             for(i = 0; i < s->terms; i++) {
 717                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
 718                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
 719                 buf++;
 720             }
 721             got_terms = 1;
 722             break;
 723         case WP_ID_DECWEIGHTS:
 724             if(!got_terms){
 725                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 726                 continue;
 727             }
 728             weights = size >> s->stereo_in;
 729             if(weights > MAX_TERMS || weights > s->terms){
 730                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
 731                 buf += ssize;
 732                 continue;
 733             }
 734             for(i = 0; i < weights; i++) {
 735                 t = (int8_t)(*buf++);
 736                 s->decorr[s->terms - i - 1].weightA = t << 3;
 737                 if(s->decorr[s->terms - i - 1].weightA > 0)
 738                     s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
 739                 if(s->stereo_in){
 740                     t = (int8_t)(*buf++);
 741                     s->decorr[s->terms - i - 1].weightB = t << 3;
 742                     if(s->decorr[s->terms - i - 1].weightB > 0)
 743                         s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
 744                 }
 745             }
 746             got_weights = 1;
 747             break;
 748         case WP_ID_DECSAMPLES:
 749             if(!got_terms){
 750                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 751                 continue;
 752             }
 753             t = 0;
 754             for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
 755                 if(s->decorr[i].value > 8){
 756                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 757                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 758                     if(s->stereo_in){
 759                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 760                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 761                         t += 4;
 762                     }
 763                     t += 4;
 764                 }else if(s->decorr[i].value < 0){
 765                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 766                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 767                     t += 4;
 768                 }else{
 769                     for(j = 0; j < s->decorr[i].value; j++){
 770                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 771                         if(s->stereo_in){
 772                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 773                         }
 774                     }
 775                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
 776                 }
 777             }
 778             got_samples = 1;
 779             break;
 780         case WP_ID_ENTROPY:
 781             if(size != 6 * (s->stereo_in + 1)){
 782                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
 783                 buf += ssize;
 784                 continue;
 785             }
 786             for(j = 0; j <= s->stereo_in; j++){
 787                 for(i = 0; i < 3; i++){
 788                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
 789                     buf += 2;
 790                 }
 791             }
 792             got_entropy = 1;
 793             break;
 794         case WP_ID_HYBRID:
 795             if(s->hybrid_bitrate){
 796                 for(i = 0; i <= s->stereo_in; i++){
 797                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
 798                     buf += 2;
 799                     size -= 2;
 800                 }
 801             }
 802             for(i = 0; i < (s->stereo_in + 1); i++){
 803                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
 804                 buf += 2;
 805                 size -= 2;
 806             }
 807             if(size > 0){
 808                 for(i = 0; i < (s->stereo_in + 1); i++){
 809                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
 810                     buf += 2;
 811                 }
 812             }else{
 813                 for(i = 0; i < (s->stereo_in + 1); i++)
 814                     s->ch[i].bitrate_delta = 0;
 815             }
 816             got_hybrid = 1;
 817             break;
 818         case WP_ID_INT32INFO:
 819             if(size != 4){
 820                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
 821                 buf += ssize;
 822                 continue;
 823             }
 824             if(buf[0])
 825                 s->extra_bits = buf[0];
 826             else if(buf[1])
 827                 s->shift = buf[1];
 828             else if(buf[2]){
 829                 s->and = s->or = 1;
 830                 s->shift = buf[2];
 831             }else if(buf[3]){
 832                 s->and = 1;
 833                 s->shift = buf[3];
 834             }
 835             buf += 4;
 836             break;
 837         case WP_ID_FLOATINFO:
 838             if(size != 4){
 839                 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
 840                 buf += ssize;
 841                 continue;
 842             }
 843             s->float_flag = buf[0];
 844             s->float_shift = buf[1];
 845             s->float_max_exp = buf[2];
 846             buf += 4;
 847             got_float = 1;
 848             break;
 849         case WP_ID_DATA:
 850             init_get_bits(&s->gb, buf, size * 8);
 851             s->data_size = size * 8;
 852             buf += size;
 853             got_bs = 1;
 854             break;
 855         case WP_ID_EXTRABITS:
 856             if(size <= 4){
 857                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
 858                 buf += size;
 859                 continue;
 860             }
 861             init_get_bits(&s->gb_extra_bits, buf, size * 8);
 862             s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
 863             buf += size;
 864             s->got_extra_bits = 1;
 865             break;
 866         default:
 867             buf += size;
 868         }
 869         if(id & WP_IDF_ODD) buf++;
 870     }
 871     if(!got_terms){
 872         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
 873         return -1;
 874     }
 875     if(!got_weights){
 876         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
 877         return -1;
 878     }
 879     if(!got_samples){
 880         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
 881         return -1;
 882     }
 883     if(!got_entropy){
 884         av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
 885         return -1;
 886     }
 887     if(s->hybrid && !got_hybrid){
 888         av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
 889         return -1;
 890     }
 891     if(!got_bs){
 892         av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
 893         return -1;
 894     }
 895     if(!got_float && avctx->sample_fmt == SAMPLE_FMT_FLT){
 896         av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
 897         return -1;
 898     }
 899     if(s->got_extra_bits && avctx->sample_fmt != SAMPLE_FMT_FLT){
 900         const int size = s->gb_extra_bits.size_in_bits - get_bits_count(&s->gb_extra_bits);
 901         const int wanted = s->samples * s->extra_bits << s->stereo_in;
 902         if(size < wanted){
 903             av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
 904             s->got_extra_bits = 0;
 905         }
 906     }
 907
 908     if(s->stereo_in){
 909         if(avctx->sample_fmt == SAMPLE_FMT_S16)
 910             samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S16);
 911         else if(avctx->sample_fmt == SAMPLE_FMT_S32)
 912             samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S32);
 913         else
 914             samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_FLT);
 915
 916     }else{
 917         if(avctx->sample_fmt == SAMPLE_FMT_S16)
 918             samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S16);
 919         else if(avctx->sample_fmt == SAMPLE_FMT_S32)
 920             samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S32);
 921         else
 922             samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_FLT);
 923
 924         if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S16){
 925             int16_t *dst = (int16_t*)samples + samplecount * 2;
 926             int16_t *src = (int16_t*)samples + samplecount;
 927             int cnt = samplecount;
 928             while(cnt--){
 929                 *--dst = *--src;
 930                 *--dst = *src;
 931             }
 932             samplecount *= 2;
 933         }else if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S32){
 934             int32_t *dst = (int32_t*)samples + samplecount * 2;
 935             int32_t *src = (int32_t*)samples + samplecount;
 936             int cnt = samplecount;
 937             while(cnt--){
 938                 *--dst = *--src;
 939                 *--dst = *src;
 940             }
 941             samplecount *= 2;
 942         }else if(s->stereo){
 943             float *dst = (float*)samples + samplecount * 2;
 944             float *src = (float*)samples + samplecount;
 945             int cnt = samplecount;
 946             while(cnt--){
 947                 *--dst = *--src;
 948                 *--dst = *src;
 949             }
 950             samplecount *= 2;
 951         }
 952     }
 953     *data_size = samplecount * bpp;
 954
 955     return buf_size;
 956 }
 957
 958 AVCodec wavpack_decoder = {
 959     "wavpack",
 960     CODEC_TYPE_AUDIO,
 961     CODEC_ID_WAVPACK,
 962     sizeof(WavpackContext),
 963     wavpack_decode_init,
 964     NULL,
 965     NULL,
 966     wavpack_decode_frame,
 967     .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
 968 };