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