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