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 = avctx->bits_per_coded_sample <= 16 ? 2 : 4;
 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     /* should not happen but who knows */
 544     if(s->samples * bpp * avctx->channels > *data_size){
 545         av_log(avctx, AV_LOG_ERROR, "Packet size is too big to be handled in lavc!\n");
 546         return -1;
 547     }
 548     s->frame_flags = AV_RL32(buf); buf += 4;
 549     s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
 550     s->joint = s->frame_flags & WV_JOINT_STEREO;
 551     s->hybrid = s->frame_flags & WV_HYBRID_MODE;
 552     s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
 553     s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
 554     s->CRC = AV_RL32(buf); buf += 4;
 555     // parse metadata blocks
 556     while(buf < buf_end){
 557         id = *buf++;
 558         size = *buf++;
 559         if(id & WP_IDF_LONG) {
 560             size |= (*buf++) << 8;
 561             size |= (*buf++) << 16;
 562         }
 563         size <<= 1; // size is specified in words
 564         ssize = size;
 565         if(id & WP_IDF_ODD) size--;
 566         if(size < 0){
 567             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
 568             break;
 569         }
 570         if(buf + ssize > buf_end){
 571             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
 572             break;
 573         }
 574         if(id & WP_IDF_IGNORE){
 575             buf += ssize;
 576             continue;
 577         }
 578         switch(id & WP_IDF_MASK){
 579         case WP_ID_DECTERMS:
 580             s->terms = size;
 581             if(s->terms > MAX_TERMS){
 582                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
 583                 buf += ssize;
 584                 continue;
 585             }
 586             for(i = 0; i < s->terms; i++) {
 587                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
 588                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
 589                 buf++;
 590             }
 591             got_terms = 1;
 592             break;
 593         case WP_ID_DECWEIGHTS:
 594             if(!got_terms){
 595                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 596                 continue;
 597             }
 598             weights = size >> s->stereo_in;
 599             if(weights > MAX_TERMS || weights > s->terms){
 600                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
 601                 buf += ssize;
 602                 continue;
 603             }
 604             for(i = 0; i < weights; i++) {
 605                 t = (int8_t)(*buf++);
 606                 s->decorr[s->terms - i - 1].weightA = t << 3;
 607                 if(s->decorr[s->terms - i - 1].weightA > 0)
 608                     s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
 609                 if(s->stereo_in){
 610                     t = (int8_t)(*buf++);
 611                     s->decorr[s->terms - i - 1].weightB = t << 3;
 612                     if(s->decorr[s->terms - i - 1].weightB > 0)
 613                         s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
 614                 }
 615             }
 616             got_weights = 1;
 617             break;
 618         case WP_ID_DECSAMPLES:
 619             if(!got_terms){
 620                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 621                 continue;
 622             }
 623             t = 0;
 624             for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
 625                 if(s->decorr[i].value > 8){
 626                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 627                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 628                     if(s->stereo_in){
 629                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 630                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 631                         t += 4;
 632                     }
 633                     t += 4;
 634                 }else if(s->decorr[i].value < 0){
 635                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 636                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 637                     t += 4;
 638                 }else{
 639                     for(j = 0; j < s->decorr[i].value; j++){
 640                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 641                         if(s->stereo_in){
 642                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 643                         }
 644                     }
 645                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
 646                 }
 647             }
 648             got_samples = 1;
 649             break;
 650         case WP_ID_ENTROPY:
 651             if(size != 6 * (s->stereo_in + 1)){
 652                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
 653                 buf += ssize;
 654                 continue;
 655             }
 656             for(j = 0; j <= s->stereo_in; j++){
 657                 for(i = 0; i < 3; i++){
 658                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
 659                     buf += 2;
 660                 }
 661             }
 662             got_entropy = 1;
 663             break;
 664         case WP_ID_HYBRID:
 665             if(s->hybrid_bitrate){
 666                 for(i = 0; i <= s->stereo_in; i++){
 667                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
 668                     buf += 2;
 669                     size -= 2;
 670                 }
 671             }
 672             for(i = 0; i < (s->stereo_in + 1); i++){
 673                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
 674                 buf += 2;
 675                 size -= 2;
 676             }
 677             if(size > 0){
 678                 for(i = 0; i < (s->stereo_in + 1); i++){
 679                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
 680                     buf += 2;
 681                 }
 682             }else{
 683                 for(i = 0; i < (s->stereo_in + 1); i++)
 684                     s->ch[i].bitrate_delta = 0;
 685             }
 686             got_hybrid = 1;
 687             break;
 688         case WP_ID_INT32INFO:
 689             if(size != 4){
 690                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
 691                 buf += ssize;
 692                 continue;
 693             }
 694             if(buf[0])
 695                 s->post_shift = buf[0];
 696             else if(buf[1])
 697                 s->shift = buf[1];
 698             else if(buf[2]){
 699                 s->and = s->or = 1;
 700                 s->shift = buf[2];
 701             }else if(buf[3]){
 702                 s->and = 1;
 703                 s->shift = buf[3];
 704             }
 705             buf += 4;
 706             break;
 707         case WP_ID_DATA:
 708             init_get_bits(&s->gb, buf, size * 8);
 709             s->data_size = size * 8;
 710             buf += size;
 711             got_bs = 1;
 712             break;
 713         default:
 714             buf += size;
 715         }
 716         if(id & WP_IDF_ODD) buf++;
 717     }
 718     if(!got_terms){
 719         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
 720         return -1;
 721     }
 722     if(!got_weights){
 723         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
 724         return -1;
 725     }
 726     if(!got_samples){
 727         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
 728         return -1;
 729     }
 730     if(!got_entropy){
 731         av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
 732         return -1;
 733     }
 734     if(s->hybrid && !got_hybrid){
 735         av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
 736         return -1;
 737     }
 738     if(!got_bs){
 739         av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
 740         return -1;
 741     }
 742
 743     if(s->stereo_in){
 744         if(bpp == 2)
 745             samplecount = wv_unpack_stereo(s, &s->gb, samples, 0);
 746         else
 747             samplecount = wv_unpack_stereo(s, &s->gb, samples, 1);
 748     }else{
 749         if(bpp == 2)
 750             samplecount = wv_unpack_mono(s, &s->gb, samples, 0);
 751         else
 752             samplecount = wv_unpack_mono(s, &s->gb, samples, 1);
 753         if(s->stereo && bpp == 2){
 754             int16_t *dst = (int16_t*)samples + samplecount * 2;
 755             int16_t *src = (int16_t*)samples + samplecount;
 756             int cnt = samplecount;
 757             while(cnt--){
 758                 *--dst = *--src;
 759                 *--dst = *src;
 760             }
 761             samplecount *= 2;
 762         }else if(s->stereo){ //32-bit output
 763             int32_t *dst = (int32_t*)samples + samplecount * 2;
 764             int32_t *src = (int32_t*)samples + samplecount;
 765             int cnt = samplecount;
 766             while(cnt--){
 767                 *--dst = *--src;
 768                 *--dst = *src;
 769             }
 770             samplecount *= 2;
 771         }
 772     }
 773     *data_size = samplecount * bpp;
 774
 775     return buf_size;
 776 }
 777
 778 AVCodec wavpack_decoder = {
 779     "wavpack",
 780     CODEC_TYPE_AUDIO,
 781     CODEC_ID_WAVPACK,
 782     sizeof(WavpackContext),
 783     wavpack_decode_init,
 784     NULL,
 785     NULL,
 786     wavpack_decode_frame,
 787     .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
 788 };