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