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