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