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_get_value_integer(WavpackContext *s, uint32_t *crc, int S)
 345 {
 346     int bit;
 347
 348     if(s->extra_bits){
 349         S <<= s->extra_bits;
 350
 351         if(s->got_extra_bits){
 352             S |= get_bits(&s->gb_extra_bits, s->extra_bits);
 353             *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
 354         }
 355     }
 356     bit = (S & s->and) | s->or;
 357     return (((S + bit) << s->shift) - bit) << s->post_shift;
 358 }
 359
 360 static inline int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, void *dst, const int type)
 361 {
 362     int i, j, count = 0;
 363     int last, t;
 364     int A, B, L, L2, R, R2;
 365     int pos = 0;
 366     uint32_t crc = 0xFFFFFFFF;
 367     uint32_t crc_extra_bits = 0xFFFFFFFF;
 368     int16_t *dst16 = dst;
 369     int32_t *dst32 = dst;
 370
 371     s->one = s->zero = s->zeroes = 0;
 372     do{
 373         L = wv_get_value(s, gb, 0, &last);
 374         if(last) break;
 375         R = wv_get_value(s, gb, 1, &last);
 376         if(last) break;
 377         for(i = 0; i < s->terms; i++){
 378             t = s->decorr[i].value;
 379             if(t > 0){
 380                 if(t > 8){
 381                     if(t & 1){
 382                         A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 383                         B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
 384                     }else{
 385                         A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 386                         B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
 387                     }
 388                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 389                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
 390                     j = 0;
 391                 }else{
 392                     A = s->decorr[i].samplesA[pos];
 393                     B = s->decorr[i].samplesB[pos];
 394                     j = (pos + t) & 7;
 395                 }
 396                 if(type != SAMPLE_FMT_S16){
 397                     L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 398                     R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
 399                 }else{
 400                     L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
 401                     R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
 402                 }
 403                 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 404                 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
 405                 s->decorr[i].samplesA[j] = L = L2;
 406                 s->decorr[i].samplesB[j] = R = R2;
 407             }else if(t == -1){
 408                 if(type != SAMPLE_FMT_S16)
 409                     L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
 410                 else
 411                     L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
 412                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
 413                 L = L2;
 414                 if(type != SAMPLE_FMT_S16)
 415                     R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
 416                 else
 417                     R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
 418                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
 419                 R = R2;
 420                 s->decorr[i].samplesA[0] = R;
 421             }else{
 422                 if(type != SAMPLE_FMT_S16)
 423                     R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
 424                 else
 425                     R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
 426                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
 427                 R = R2;
 428
 429                 if(t == -3){
 430                     R2 = s->decorr[i].samplesA[0];
 431                     s->decorr[i].samplesA[0] = R;
 432                 }
 433
 434                 if(type != SAMPLE_FMT_S16)
 435                     L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
 436                 else
 437                     L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
 438                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
 439                 L = L2;
 440                 s->decorr[i].samplesB[0] = L;
 441             }
 442         }
 443         pos = (pos + 1) & 7;
 444         if(s->joint)
 445             L += (R -= (L >> 1));
 446         crc = (crc * 3 + L) * 3 + R;
 447
 448         if(type == SAMPLE_FMT_S32){
 449             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
 450             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
 451         } else {
 452             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
 453             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
 454         }
 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     if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
 463         av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 464         return -1;
 465     }
 466     return count * 2;
 467 }
 468
 469 static inline int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, void *dst, const int type)
 470 {
 471     int i, j, count = 0;
 472     int last, t;
 473     int A, S, T;
 474     int pos = 0;
 475     uint32_t crc = 0xFFFFFFFF;
 476     uint32_t crc_extra_bits = 0xFFFFFFFF;
 477     int16_t *dst16 = dst;
 478     int32_t *dst32 = dst;
 479
 480     s->one = s->zero = s->zeroes = 0;
 481     do{
 482         T = wv_get_value(s, gb, 0, &last);
 483         S = 0;
 484         if(last) break;
 485         for(i = 0; i < s->terms; i++){
 486             t = s->decorr[i].value;
 487             if(t > 8){
 488                 if(t & 1)
 489                     A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 490                 else
 491                     A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 492                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 493                 j = 0;
 494             }else{
 495                 A = s->decorr[i].samplesA[pos];
 496                 j = (pos + t) & 7;
 497             }
 498             if(type != SAMPLE_FMT_S16)
 499                 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 500             else
 501                 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
 502             if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 503             s->decorr[i].samplesA[j] = T = S;
 504         }
 505         pos = (pos + 1) & 7;
 506         crc = crc * 3 + S;
 507
 508         if(type == SAMPLE_FMT_S32)
 509             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S);
 510         else
 511             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);
 512         count++;
 513     }while(!last && count < s->samples);
 514
 515     if(crc != s->CRC){
 516         av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
 517         return -1;
 518     }
 519     if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
 520         av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 521         return -1;
 522     }
 523     return count;
 524 }
 525
 526 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
 527 {
 528     WavpackContext *s = avctx->priv_data;
 529
 530     s->avctx = avctx;
 531     s->stereo = (avctx->channels == 2);
 532     if(avctx->bits_per_coded_sample <= 16)
 533         avctx->sample_fmt = SAMPLE_FMT_S16;
 534     else
 535         avctx->sample_fmt = SAMPLE_FMT_S32;
 536     avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
 537
 538     return 0;
 539 }
 540
 541 static int wavpack_decode_frame(AVCodecContext *avctx,
 542                             void *data, int *data_size,
 543                             AVPacket *avpkt)
 544 {
 545     const uint8_t *buf = avpkt->data;
 546     int buf_size = avpkt->size;
 547     WavpackContext *s = avctx->priv_data;
 548     void *samples = data;
 549     int samplecount;
 550     int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0;
 551     int got_hybrid = 0;
 552     const uint8_t* buf_end = buf + buf_size;
 553     int i, j, id, size, ssize, weights, t;
 554     int bpp;
 555
 556     if (buf_size == 0){
 557         *data_size = 0;
 558         return 0;
 559     }
 560
 561     memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
 562     memset(s->ch, 0, sizeof(s->ch));
 563     s->extra_bits = 0;
 564     s->and = s->or = s->shift = 0;
 565     s->got_extra_bits = 0;
 566
 567     s->samples = AV_RL32(buf); buf += 4;
 568     if(!s->samples){
 569         *data_size = 0;
 570         return buf_size;
 571     }
 572     s->frame_flags = AV_RL32(buf); buf += 4;
 573     if((s->frame_flags&0x03) <= 1){
 574         bpp = 2;
 575         avctx->sample_fmt = SAMPLE_FMT_S16;
 576     } else {
 577         bpp = 4;
 578         avctx->sample_fmt = SAMPLE_FMT_S32;
 579     }
 580     s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
 581     s->joint = s->frame_flags & WV_JOINT_STEREO;
 582     s->hybrid = s->frame_flags & WV_HYBRID_MODE;
 583     s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
 584     s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
 585     s->CRC = AV_RL32(buf); buf += 4;
 586
 587     /* should not happen but who knows */
 588     if(s->samples * bpp * avctx->channels > *data_size){
 589         av_log(avctx, AV_LOG_ERROR, "Packet size is too big to be handled in lavc!\n");
 590         return -1;
 591     }
 592
 593     // parse metadata blocks
 594     while(buf < buf_end){
 595         id = *buf++;
 596         size = *buf++;
 597         if(id & WP_IDF_LONG) {
 598             size |= (*buf++) << 8;
 599             size |= (*buf++) << 16;
 600         }
 601         size <<= 1; // size is specified in words
 602         ssize = size;
 603         if(id & WP_IDF_ODD) size--;
 604         if(size < 0){
 605             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
 606             break;
 607         }
 608         if(buf + ssize > buf_end){
 609             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
 610             break;
 611         }
 612         if(id & WP_IDF_IGNORE){
 613             buf += ssize;
 614             continue;
 615         }
 616         switch(id & WP_IDF_MASK){
 617         case WP_ID_DECTERMS:
 618             s->terms = size;
 619             if(s->terms > MAX_TERMS){
 620                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
 621                 buf += ssize;
 622                 continue;
 623             }
 624             for(i = 0; i < s->terms; i++) {
 625                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
 626                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
 627                 buf++;
 628             }
 629             got_terms = 1;
 630             break;
 631         case WP_ID_DECWEIGHTS:
 632             if(!got_terms){
 633                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 634                 continue;
 635             }
 636             weights = size >> s->stereo_in;
 637             if(weights > MAX_TERMS || weights > s->terms){
 638                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
 639                 buf += ssize;
 640                 continue;
 641             }
 642             for(i = 0; i < weights; i++) {
 643                 t = (int8_t)(*buf++);
 644                 s->decorr[s->terms - i - 1].weightA = t << 3;
 645                 if(s->decorr[s->terms - i - 1].weightA > 0)
 646                     s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
 647                 if(s->stereo_in){
 648                     t = (int8_t)(*buf++);
 649                     s->decorr[s->terms - i - 1].weightB = t << 3;
 650                     if(s->decorr[s->terms - i - 1].weightB > 0)
 651                         s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
 652                 }
 653             }
 654             got_weights = 1;
 655             break;
 656         case WP_ID_DECSAMPLES:
 657             if(!got_terms){
 658                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 659                 continue;
 660             }
 661             t = 0;
 662             for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
 663                 if(s->decorr[i].value > 8){
 664                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 665                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 666                     if(s->stereo_in){
 667                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 668                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 669                         t += 4;
 670                     }
 671                     t += 4;
 672                 }else if(s->decorr[i].value < 0){
 673                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 674                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 675                     t += 4;
 676                 }else{
 677                     for(j = 0; j < s->decorr[i].value; j++){
 678                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 679                         if(s->stereo_in){
 680                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 681                         }
 682                     }
 683                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
 684                 }
 685             }
 686             got_samples = 1;
 687             break;
 688         case WP_ID_ENTROPY:
 689             if(size != 6 * (s->stereo_in + 1)){
 690                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
 691                 buf += ssize;
 692                 continue;
 693             }
 694             for(j = 0; j <= s->stereo_in; j++){
 695                 for(i = 0; i < 3; i++){
 696                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
 697                     buf += 2;
 698                 }
 699             }
 700             got_entropy = 1;
 701             break;
 702         case WP_ID_HYBRID:
 703             if(s->hybrid_bitrate){
 704                 for(i = 0; i <= s->stereo_in; i++){
 705                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
 706                     buf += 2;
 707                     size -= 2;
 708                 }
 709             }
 710             for(i = 0; i < (s->stereo_in + 1); i++){
 711                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
 712                 buf += 2;
 713                 size -= 2;
 714             }
 715             if(size > 0){
 716                 for(i = 0; i < (s->stereo_in + 1); i++){
 717                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
 718                     buf += 2;
 719                 }
 720             }else{
 721                 for(i = 0; i < (s->stereo_in + 1); i++)
 722                     s->ch[i].bitrate_delta = 0;
 723             }
 724             got_hybrid = 1;
 725             break;
 726         case WP_ID_INT32INFO:
 727             if(size != 4){
 728                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
 729                 buf += ssize;
 730                 continue;
 731             }
 732             if(buf[0])
 733                 s->extra_bits = buf[0];
 734             else if(buf[1])
 735                 s->shift = buf[1];
 736             else if(buf[2]){
 737                 s->and = s->or = 1;
 738                 s->shift = buf[2];
 739             }else if(buf[3]){
 740                 s->and = 1;
 741                 s->shift = buf[3];
 742             }
 743             buf += 4;
 744             break;
 745         case WP_ID_DATA:
 746             init_get_bits(&s->gb, buf, size * 8);
 747             s->data_size = size * 8;
 748             buf += size;
 749             got_bs = 1;
 750             break;
 751         case WP_ID_EXTRABITS:
 752             if(size <= 4){
 753                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
 754                 buf += size;
 755                 continue;
 756             }
 757             init_get_bits(&s->gb_extra_bits, buf, size * 8);
 758             s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
 759             buf += size;
 760             s->got_extra_bits = 1;
 761             break;
 762         default:
 763             buf += size;
 764         }
 765         if(id & WP_IDF_ODD) buf++;
 766     }
 767     if(!got_terms){
 768         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
 769         return -1;
 770     }
 771     if(!got_weights){
 772         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
 773         return -1;
 774     }
 775     if(!got_samples){
 776         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
 777         return -1;
 778     }
 779     if(!got_entropy){
 780         av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
 781         return -1;
 782     }
 783     if(s->hybrid && !got_hybrid){
 784         av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
 785         return -1;
 786     }
 787     if(!got_bs){
 788         av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
 789         return -1;
 790     }
 791     if(s->got_extra_bits){
 792         const int size = s->gb_extra_bits.size_in_bits - get_bits_count(&s->gb_extra_bits);
 793         const int wanted = s->samples * s->extra_bits << s->stereo_in;
 794         if(size < wanted){
 795             av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
 796             s->got_extra_bits = 0;
 797         }
 798     }
 799
 800     if(s->stereo_in){
 801         if(avctx->sample_fmt == SAMPLE_FMT_S16)
 802             samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S16);
 803         else
 804             samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S32);
 805     }else{
 806         if(avctx->sample_fmt == SAMPLE_FMT_S16)
 807             samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S16);
 808         else
 809             samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S32);
 810         if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S16){
 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 };