git.sesse.net Git - ffmpeg/blob - libavcodec/wavpack.c

   1 /*
   2  * WavPack lossless audio decoder
   3  * Copyright (c) 2006,2011 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
  22 #define BITSTREAM_READER_LE
  23
  24 #include "libavutil/channel_layout.h"
  25 #include "avcodec.h"
  26 #include "get_bits.h"
  27 #include "internal.h"
  28 #include "unary.h"
  29
  30 /**
  31  * @file
  32  * WavPack lossless audio decoder
  33  */
  34
  35 #define WV_MONO           0x00000004
  36 #define WV_JOINT_STEREO   0x00000010
  37 #define WV_FALSE_STEREO   0x40000000
  38
  39 #define WV_HYBRID_MODE    0x00000008
  40 #define WV_HYBRID_SHAPE   0x00000008
  41 #define WV_HYBRID_BITRATE 0x00000200
  42 #define WV_HYBRID_BALANCE 0x00000400
  43
  44 #define WV_FLT_SHIFT_ONES 0x01
  45 #define WV_FLT_SHIFT_SAME 0x02
  46 #define WV_FLT_SHIFT_SENT 0x04
  47 #define WV_FLT_ZERO_SENT  0x08
  48 #define WV_FLT_ZERO_SIGN  0x10
  49
  50 #define WV_MAX_SAMPLES    131072
  51
  52 enum WP_ID_Flags {
  53     WP_IDF_MASK   = 0x1F,
  54     WP_IDF_IGNORE = 0x20,
  55     WP_IDF_ODD    = 0x40,
  56     WP_IDF_LONG   = 0x80
  57 };
  58
  59 enum WP_ID {
  60     WP_ID_DUMMY = 0,
  61     WP_ID_ENCINFO,
  62     WP_ID_DECTERMS,
  63     WP_ID_DECWEIGHTS,
  64     WP_ID_DECSAMPLES,
  65     WP_ID_ENTROPY,
  66     WP_ID_HYBRID,
  67     WP_ID_SHAPING,
  68     WP_ID_FLOATINFO,
  69     WP_ID_INT32INFO,
  70     WP_ID_DATA,
  71     WP_ID_CORR,
  72     WP_ID_EXTRABITS,
  73     WP_ID_CHANINFO
  74 };
  75
  76 typedef struct SavedContext {
  77     int offset;
  78     int size;
  79     int bits_used;
  80     uint32_t crc;
  81 } SavedContext;
  82
  83 #define MAX_TERMS 16
  84
  85 typedef struct Decorr {
  86     int delta;
  87     int value;
  88     int weightA;
  89     int weightB;
  90     int samplesA[8];
  91     int samplesB[8];
  92 } Decorr;
  93
  94 typedef struct WvChannel {
  95     int median[3];
  96     int slow_level, error_limit;
  97     int bitrate_acc, bitrate_delta;
  98 } WvChannel;
  99
 100 typedef struct WavpackFrameContext {
 101     AVCodecContext *avctx;
 102     int frame_flags;
 103     int stereo, stereo_in;
 104     int joint;
 105     uint32_t CRC;
 106     GetBitContext gb;
 107     int got_extra_bits;
 108     uint32_t crc_extra_bits;
 109     GetBitContext gb_extra_bits;
 110     int data_size; // in bits
 111     int samples;
 112     int terms;
 113     Decorr decorr[MAX_TERMS];
 114     int zero, one, zeroes;
 115     int extra_bits;
 116     int and, or, shift;
 117     int post_shift;
 118     int hybrid, hybrid_bitrate;
 119     int hybrid_maxclip, hybrid_minclip;
 120     int float_flag;
 121     int float_shift;
 122     int float_max_exp;
 123     WvChannel ch[2];
 124     int pos;
 125     SavedContext sc, extra_sc;
 126 } WavpackFrameContext;
 127
 128 #define WV_MAX_FRAME_DECODERS 14
 129
 130 typedef struct WavpackContext {
 131     AVCodecContext *avctx;
 132
 133     WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
 134     int fdec_num;
 135
 136     int multichannel;
 137     int mkv_mode;
 138     int block;
 139     int samples;
 140     int ch_offset;
 141 } WavpackContext;
 142
 143 // exponent table copied from WavPack source
 144 static const uint8_t wp_exp2_table [256] = {
 145     0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
 146     0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
 147     0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
 148     0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
 149     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
 150     0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
 151     0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
 152     0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
 153     0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
 154     0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
 155     0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
 156     0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
 157     0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
 158     0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
 159     0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
 160     0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
 161 };
 162
 163 static const uint8_t wp_log2_table [] = {
 164     0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
 165     0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
 166     0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
 167     0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
 168     0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
 169     0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
 170     0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
 171     0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
 172     0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
 173     0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
 174     0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
 175     0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
 176     0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
 177     0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
 178     0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
 179     0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
 180 };
 181
 182 static av_always_inline int wp_exp2(int16_t val)
 183 {
 184     int res, neg = 0;
 185
 186     if (val < 0) {
 187         val = -val;
 188         neg = 1;
 189     }
 190
 191     res = wp_exp2_table[val & 0xFF] | 0x100;
 192     val >>= 8;
 193     res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
 194     return neg ? -res : res;
 195 }
 196
 197 static av_always_inline int wp_log2(int32_t val)
 198 {
 199     int bits;
 200
 201     if (!val)
 202         return 0;
 203     if (val == 1)
 204         return 256;
 205     val += val >> 9;
 206     bits = av_log2(val) + 1;
 207     if (bits < 9)
 208         return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
 209     else
 210         return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
 211 }
 212
 213 #define LEVEL_DECAY(a)  ((a + 0x80) >> 8)
 214
 215 // macros for manipulating median values
 216 #define GET_MED(n) ((c->median[n] >> 4) + 1)
 217 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2
 218 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n)    ) / (128 >> n)) * 5
 219
 220 // macros for applying weight
 221 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
 222     if (samples && in) { \
 223         if ((samples ^ in) < 0) { \
 224             weight -= delta; \
 225             if (weight < -1024) \
 226                 weight = -1024; \
 227         } else { \
 228             weight += delta; \
 229             if (weight > 1024) \
 230                 weight = 1024; \
 231         } \
 232     }
 233
 234
 235 static av_always_inline int get_tail(GetBitContext *gb, int k)
 236 {
 237     int p, e, res;
 238
 239     if (k < 1)
 240         return 0;
 241     p = av_log2(k);
 242     e = (1 << (p + 1)) - k - 1;
 243     res = p ? get_bits(gb, p) : 0;
 244     if (res >= e)
 245         res = (res << 1) - e + get_bits1(gb);
 246     return res;
 247 }
 248
 249 static void update_error_limit(WavpackFrameContext *ctx)
 250 {
 251     int i, br[2], sl[2];
 252
 253     for (i = 0; i <= ctx->stereo_in; i++) {
 254         ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
 255         br[i] = ctx->ch[i].bitrate_acc >> 16;
 256         sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
 257     }
 258     if (ctx->stereo_in && ctx->hybrid_bitrate) {
 259         int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
 260         if (balance > br[0]) {
 261             br[1] = br[0] << 1;
 262             br[0] = 0;
 263         } else if (-balance > br[0]) {
 264             br[0] <<= 1;
 265             br[1] = 0;
 266         } else {
 267             br[1] = br[0] + balance;
 268             br[0] = br[0] - balance;
 269         }
 270     }
 271     for (i = 0; i <= ctx->stereo_in; i++) {
 272         if (ctx->hybrid_bitrate) {
 273             if (sl[i] - br[i] > -0x100)
 274                 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
 275             else
 276                 ctx->ch[i].error_limit = 0;
 277         } else {
 278             ctx->ch[i].error_limit = wp_exp2(br[i]);
 279         }
 280     }
 281 }
 282
 283 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
 284                         int channel, int *last)
 285 {
 286     int t, t2;
 287     int sign, base, add, ret;
 288     WvChannel *c = &ctx->ch[channel];
 289
 290     *last = 0;
 291
 292     if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&
 293         !ctx->zero && !ctx->one) {
 294         if (ctx->zeroes) {
 295             ctx->zeroes--;
 296             if (ctx->zeroes) {
 297                 c->slow_level -= LEVEL_DECAY(c->slow_level);
 298                 return 0;
 299             }
 300         } else {
 301             t = get_unary_0_33(gb);
 302             if (t >= 2) {
 303                 if (get_bits_left(gb) < t - 1)
 304                     goto error;
 305                 t = get_bits(gb, t - 1) | (1 << (t-1));
 306             } else {
 307                 if (get_bits_left(gb) < 0)
 308                     goto error;
 309             }
 310             ctx->zeroes = t;
 311             if (ctx->zeroes) {
 312                 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
 313                 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
 314                 c->slow_level -= LEVEL_DECAY(c->slow_level);
 315                 return 0;
 316             }
 317         }
 318     }
 319
 320     if (ctx->zero) {
 321         t = 0;
 322         ctx->zero = 0;
 323     } else {
 324         t = get_unary_0_33(gb);
 325         if (get_bits_left(gb) < 0)
 326             goto error;
 327         if (t == 16) {
 328             t2 = get_unary_0_33(gb);
 329             if (t2 < 2) {
 330                 if (get_bits_left(gb) < 0)
 331                     goto error;
 332                 t += t2;
 333             } else {
 334                 if (get_bits_left(gb) < t2 - 1)
 335                     goto error;
 336                 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
 337             }
 338         }
 339
 340         if (ctx->one) {
 341             ctx->one = t & 1;
 342             t = (t >> 1) + 1;
 343         } else {
 344             ctx->one = t & 1;
 345             t >>= 1;
 346         }
 347         ctx->zero = !ctx->one;
 348     }
 349
 350     if (ctx->hybrid && !channel)
 351         update_error_limit(ctx);
 352
 353     if (!t) {
 354         base = 0;
 355         add  = GET_MED(0) - 1;
 356         DEC_MED(0);
 357     } else if (t == 1) {
 358         base = GET_MED(0);
 359         add  = GET_MED(1) - 1;
 360         INC_MED(0);
 361         DEC_MED(1);
 362     } else if (t == 2) {
 363         base = GET_MED(0) + GET_MED(1);
 364         add  = GET_MED(2) - 1;
 365         INC_MED(0);
 366         INC_MED(1);
 367         DEC_MED(2);
 368     } else {
 369         base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
 370         add  = GET_MED(2) - 1;
 371         INC_MED(0);
 372         INC_MED(1);
 373         INC_MED(2);
 374     }
 375     if (!c->error_limit) {
 376         if (add >= 0x2000000U) {
 377             av_log(ctx->avctx, AV_LOG_ERROR, "k %d is too large\n", add);
 378             goto error;
 379         }
 380         ret = base + get_tail(gb, add);
 381         if (get_bits_left(gb) <= 0)
 382             goto error;
 383     } else {
 384         int mid = (base * 2 + add + 1) >> 1;
 385         while (add > c->error_limit) {
 386             if (get_bits_left(gb) <= 0)
 387                 goto error;
 388             if (get_bits1(gb)) {
 389                 add -= (mid - base);
 390                 base = mid;
 391             } else
 392                 add = mid - base - 1;
 393             mid = (base * 2 + add + 1) >> 1;
 394         }
 395         ret = mid;
 396     }
 397     sign = get_bits1(gb);
 398     if (ctx->hybrid_bitrate)
 399         c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
 400     return sign ? ~ret : ret;
 401
 402 error:
 403     *last = 1;
 404     return 0;
 405 }
 406
 407 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
 408                                        int S)
 409 {
 410     int bit;
 411
 412     if (s->extra_bits){
 413         S <<= s->extra_bits;
 414
 415         if (s->got_extra_bits && get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {
 416             S |= get_bits(&s->gb_extra_bits, s->extra_bits);
 417             *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);
 418         }
 419     }
 420
 421     bit = (S & s->and) | s->or;
 422     bit = ((S + bit) << s->shift) - bit;
 423
 424     if (s->hybrid)
 425         bit = av_clip(bit, s->hybrid_minclip, s->hybrid_maxclip);
 426
 427     return bit << s->post_shift;
 428 }
 429
 430 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
 431 {
 432     union {
 433         float    f;
 434         uint32_t u;
 435     } value;
 436
 437     unsigned int sign;
 438     int exp = s->float_max_exp;
 439
 440     if (s->got_extra_bits) {
 441         const int max_bits  = 1 + 23 + 8 + 1;
 442         const int left_bits = get_bits_left(&s->gb_extra_bits);
 443
 444         if (left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
 445             return 0.0;
 446     }
 447
 448     if (S) {
 449         S <<= s->float_shift;
 450         sign = S < 0;
 451         if (sign)
 452             S = -S;
 453         if (S >= 0x1000000) {
 454             if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))
 455                 S = get_bits(&s->gb_extra_bits, 23);
 456             else
 457                 S = 0;
 458             exp = 255;
 459         } else if (exp) {
 460             int shift = 23 - av_log2(S);
 461             exp = s->float_max_exp;
 462             if (exp <= shift)
 463                 shift = --exp;
 464             exp -= shift;
 465
 466             if (shift) {
 467                 S <<= shift;
 468                 if ((s->float_flag & WV_FLT_SHIFT_ONES) ||
 469                     (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) &&
 470                      get_bits1(&s->gb_extra_bits))) {
 471                     S |= (1 << shift) - 1;
 472                 } else if (s->got_extra_bits &&
 473                            (s->float_flag & WV_FLT_SHIFT_SENT)) {
 474                     S |= get_bits(&s->gb_extra_bits, shift);
 475                 }
 476             }
 477         } else {
 478             exp = s->float_max_exp;
 479         }
 480         S &= 0x7fffff;
 481     } else {
 482         sign = 0;
 483         exp = 0;
 484         if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {
 485             if (get_bits1(&s->gb_extra_bits)) {
 486                 S = get_bits(&s->gb_extra_bits, 23);
 487                 if (s->float_max_exp >= 25)
 488                     exp = get_bits(&s->gb_extra_bits, 8);
 489                 sign = get_bits1(&s->gb_extra_bits);
 490             } else {
 491                 if (s->float_flag & WV_FLT_ZERO_SIGN)
 492                     sign = get_bits1(&s->gb_extra_bits);
 493             }
 494         }
 495     }
 496
 497     *crc = *crc * 27 + S * 9 + exp * 3 + sign;
 498
 499     value.u = (sign << 31) | (exp << 23) | S;
 500     return value.f;
 501 }
 502
 503 static void wv_reset_saved_context(WavpackFrameContext *s)
 504 {
 505     s->pos = 0;
 506     s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
 507 }
 508
 509 static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc,
 510                                uint32_t crc_extra_bits)
 511 {
 512     if (crc != s->CRC) {
 513         av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
 514         return AVERROR_INVALIDDATA;
 515     }
 516     if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
 517         av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 518         return AVERROR_INVALIDDATA;
 519     }
 520
 521     return 0;
 522 }
 523
 524 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
 525                                    void *dst, const int type)
 526 {
 527     int i, j, count = 0;
 528     int last, t;
 529     int A, B, L, L2, R, R2;
 530     int pos = s->pos;
 531     uint32_t crc = s->sc.crc;
 532     uint32_t crc_extra_bits = s->extra_sc.crc;
 533     int16_t *dst16 = dst;
 534     int32_t *dst32 = dst;
 535     float   *dstfl = dst;
 536     const int channel_pad = s->avctx->channels - 2;
 537
 538     s->one = s->zero = s->zeroes = 0;
 539     do {
 540         L = wv_get_value(s, gb, 0, &last);
 541         if (last)
 542             break;
 543         R = wv_get_value(s, gb, 1, &last);
 544         if (last)
 545             break;
 546         for (i = 0; i < s->terms; i++) {
 547             t = s->decorr[i].value;
 548             if (t > 0) {
 549                 if (t > 8) {
 550                     if (t & 1) {
 551                         A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 552                         B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
 553                     } else {
 554                         A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 555                         B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
 556                     }
 557                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 558                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
 559                     j = 0;
 560                 } else {
 561                     A = s->decorr[i].samplesA[pos];
 562                     B = s->decorr[i].samplesB[pos];
 563                     j = (pos + t) & 7;
 564                 }
 565                 if (type != AV_SAMPLE_FMT_S16) {
 566                     L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 567                     R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
 568                 } else {
 569                     L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
 570                     R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
 571                 }
 572                 if (A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 573                 if (B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
 574                 s->decorr[i].samplesA[j] = L = L2;
 575                 s->decorr[i].samplesB[j] = R = R2;
 576             } else if (t == -1) {
 577                 if (type != AV_SAMPLE_FMT_S16)
 578                     L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
 579                 else
 580                     L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
 581                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
 582                 L = L2;
 583                 if (type != AV_SAMPLE_FMT_S16)
 584                     R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
 585                 else
 586                     R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
 587                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
 588                 R = R2;
 589                 s->decorr[i].samplesA[0] = R;
 590             } else {
 591                 if (type != AV_SAMPLE_FMT_S16)
 592                     R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
 593                 else
 594                     R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
 595                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
 596                 R = R2;
 597
 598                 if (t == -3) {
 599                     R2 = s->decorr[i].samplesA[0];
 600                     s->decorr[i].samplesA[0] = R;
 601                 }
 602
 603                 if (type != AV_SAMPLE_FMT_S16)
 604                     L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
 605                 else
 606                     L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
 607                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
 608                 L = L2;
 609                 s->decorr[i].samplesB[0] = L;
 610             }
 611         }
 612         pos = (pos + 1) & 7;
 613         if (s->joint)
 614             L += (R -= (L >> 1));
 615         crc = (crc * 3 + L) * 3 + R;
 616
 617         if (type == AV_SAMPLE_FMT_FLT) {
 618             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
 619             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
 620             dstfl += channel_pad;
 621         } else if (type == AV_SAMPLE_FMT_S32) {
 622             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
 623             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
 624             dst32 += channel_pad;
 625         } else {
 626             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
 627             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
 628             dst16 += channel_pad;
 629         }
 630         count++;
 631     } while (!last && count < s->samples);
 632
 633     wv_reset_saved_context(s);
 634     if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
 635         wv_check_crc(s, crc, crc_extra_bits))
 636         return AVERROR_INVALIDDATA;
 637
 638     return count * 2;
 639 }
 640
 641 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
 642                                  void *dst, const int type)
 643 {
 644     int i, j, count = 0;
 645     int last, t;
 646     int A, S, T;
 647     int pos = s->pos;
 648     uint32_t crc = s->sc.crc;
 649     uint32_t crc_extra_bits = s->extra_sc.crc;
 650     int16_t *dst16 = dst;
 651     int32_t *dst32 = dst;
 652     float   *dstfl = dst;
 653     const int channel_stride = s->avctx->channels;
 654
 655     s->one = s->zero = s->zeroes = 0;
 656     do {
 657         T = wv_get_value(s, gb, 0, &last);
 658         S = 0;
 659         if (last)
 660             break;
 661         for (i = 0; i < s->terms; i++) {
 662             t = s->decorr[i].value;
 663             if (t > 8) {
 664                 if (t & 1)
 665                     A =  2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 666                 else
 667                     A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 668                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 669                 j = 0;
 670             } else {
 671                 A = s->decorr[i].samplesA[pos];
 672                 j = (pos + t) & 7;
 673             }
 674             if (type != AV_SAMPLE_FMT_S16)
 675                 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 676             else
 677                 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
 678             if (A && T)
 679                 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 680             s->decorr[i].samplesA[j] = T = S;
 681         }
 682         pos = (pos + 1) & 7;
 683         crc = crc * 3 + S;
 684
 685         if (type == AV_SAMPLE_FMT_FLT) {
 686             *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
 687             dstfl += channel_stride;
 688         } else if (type == AV_SAMPLE_FMT_S32) {
 689             *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
 690             dst32 += channel_stride;
 691         } else {
 692             *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
 693             dst16 += channel_stride;
 694         }
 695         count++;
 696     } while (!last && count < s->samples);
 697
 698     wv_reset_saved_context(s);
 699     if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
 700         wv_check_crc(s, crc, crc_extra_bits))
 701         return AVERROR_INVALIDDATA;
 702
 703     return count;
 704 }
 705
 706 static av_cold int wv_alloc_frame_context(WavpackContext *c)
 707 {
 708
 709     if (c->fdec_num == WV_MAX_FRAME_DECODERS)
 710         return -1;
 711
 712     c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
 713     if (!c->fdec[c->fdec_num])
 714         return -1;
 715     c->fdec_num++;
 716     c->fdec[c->fdec_num - 1]->avctx = c->avctx;
 717     wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
 718
 719     return 0;
 720 }
 721
 722 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
 723 {
 724     WavpackContext *s = avctx->priv_data;
 725
 726     s->avctx = avctx;
 727     if (avctx->bits_per_coded_sample <= 16)
 728         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 729     else
 730         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 731     if (avctx->channels <= 2 && !avctx->channel_layout)
 732         avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO :
 733                                                          AV_CH_LAYOUT_MONO;
 734
 735     s->multichannel = avctx->channels > 2;
 736     /* lavf demuxer does not provide extradata, Matroska stores 0x403
 737        there, use this to detect decoding mode for multichannel */
 738     s->mkv_mode = 0;
 739     if (s->multichannel && avctx->extradata && avctx->extradata_size == 2) {
 740         int ver = AV_RL16(avctx->extradata);
 741         if (ver >= 0x402 && ver <= 0x410)
 742             s->mkv_mode = 1;
 743     }
 744
 745     s->fdec_num = 0;
 746
 747     return 0;
 748 }
 749
 750 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
 751 {
 752     WavpackContext *s = avctx->priv_data;
 753     int i;
 754
 755     for (i = 0; i < s->fdec_num; i++)
 756         av_freep(&s->fdec[i]);
 757     s->fdec_num = 0;
 758
 759     return 0;
 760 }
 761
 762 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
 763                                 void *data, int *got_frame_ptr,
 764                                 const uint8_t *buf, int buf_size)
 765 {
 766     WavpackContext *wc = avctx->priv_data;
 767     WavpackFrameContext *s;
 768     void *samples = data;
 769     int samplecount;
 770     int got_terms   = 0, got_weights = 0, got_samples = 0,
 771         got_entropy = 0, got_bs      = 0, got_float   = 0, got_hybrid = 0;
 772     const uint8_t *orig_buf = buf;
 773     const uint8_t *buf_end  = buf + buf_size;
 774     int i, j, id, size, ssize, weights, t;
 775     int bpp, chan, chmask, orig_bpp;
 776
 777     if (buf_size == 0) {
 778         *got_frame_ptr = 0;
 779         return 0;
 780     }
 781
 782     if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
 783         av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
 784         return -1;
 785     }
 786
 787     s = wc->fdec[block_no];
 788     if (!s) {
 789         av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
 790         return -1;
 791     }
 792
 793     if (wc->ch_offset >= avctx->channels) {
 794         av_log(avctx, AV_LOG_ERROR, "too many channels\n");
 795         return -1;
 796     }
 797
 798     memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
 799     memset(s->ch, 0, sizeof(s->ch));
 800     s->extra_bits = 0;
 801     s->and = s->or = s->shift = 0;
 802     s->got_extra_bits = 0;
 803
 804     if (!wc->mkv_mode) {
 805         s->samples = AV_RL32(buf); buf += 4;
 806         if (!s->samples) {
 807             *got_frame_ptr = 0;
 808             return 0;
 809         }
 810         if (s->samples > wc->samples) {
 811             av_log(avctx, AV_LOG_ERROR, "too many samples in block");
 812             return -1;
 813         }
 814     } else {
 815         s->samples = wc->samples;
 816     }
 817     s->frame_flags = AV_RL32(buf); buf += 4;
 818     bpp = av_get_bytes_per_sample(avctx->sample_fmt);
 819     samples = (uint8_t*)samples + bpp * wc->ch_offset;
 820     orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
 821
 822     s->stereo         = !(s->frame_flags & WV_MONO);
 823     s->stereo_in      =  (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
 824     s->joint          =   s->frame_flags & WV_JOINT_STEREO;
 825     s->hybrid         =   s->frame_flags & WV_HYBRID_MODE;
 826     s->hybrid_bitrate =   s->frame_flags & WV_HYBRID_BITRATE;
 827     s->post_shift     = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
 828     s->hybrid_maxclip = (( 1LL << (orig_bpp - 1)) - 1);
 829     s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));
 830     s->CRC            = AV_RL32(buf); buf += 4;
 831     if (wc->mkv_mode)
 832         buf += 4; //skip block size;
 833
 834     wc->ch_offset += 1 + s->stereo;
 835
 836     // parse metadata blocks
 837     while (buf < buf_end) {
 838         id   = *buf++;
 839         size = *buf++;
 840         if (id & WP_IDF_LONG) {
 841             size |= (*buf++) << 8;
 842             size |= (*buf++) << 16;
 843         }
 844         size <<= 1; // size is specified in words
 845         ssize = size;
 846         if (id & WP_IDF_ODD)
 847             size--;
 848         if (size < 0) {
 849             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
 850             break;
 851         }
 852         if (buf + ssize > buf_end) {
 853             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
 854             break;
 855         }
 856         if (id & WP_IDF_IGNORE) {
 857             buf += ssize;
 858             continue;
 859         }
 860         switch (id & WP_IDF_MASK) {
 861         case WP_ID_DECTERMS:
 862             if (size > MAX_TERMS) {
 863                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
 864                 s->terms = 0;
 865                 buf += ssize;
 866                 continue;
 867             }
 868             s->terms = size;
 869             for (i = 0; i < s->terms; i++) {
 870                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
 871                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
 872                 buf++;
 873             }
 874             got_terms = 1;
 875             break;
 876         case WP_ID_DECWEIGHTS:
 877             if (!got_terms) {
 878                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 879                 continue;
 880             }
 881             weights = size >> s->stereo_in;
 882             if (weights > MAX_TERMS || weights > s->terms) {
 883                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
 884                 buf += ssize;
 885                 continue;
 886             }
 887             for (i = 0; i < weights; i++) {
 888                 t = (int8_t)(*buf++);
 889                 s->decorr[s->terms - i - 1].weightA = t << 3;
 890                 if (s->decorr[s->terms - i - 1].weightA > 0)
 891                     s->decorr[s->terms - i - 1].weightA +=
 892                             (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
 893                 if (s->stereo_in) {
 894                     t = (int8_t)(*buf++);
 895                     s->decorr[s->terms - i - 1].weightB = t << 3;
 896                     if (s->decorr[s->terms - i - 1].weightB > 0)
 897                         s->decorr[s->terms - i - 1].weightB +=
 898                                 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
 899                 }
 900             }
 901             got_weights = 1;
 902             break;
 903         case WP_ID_DECSAMPLES:
 904             if (!got_terms) {
 905                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 906                 continue;
 907             }
 908             t = 0;
 909             for (i = s->terms - 1; (i >= 0) && (t < size) && buf <= buf_end; i--) {
 910                 if (s->decorr[i].value > 8) {
 911                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 912                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 913                     if (s->stereo_in) {
 914                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 915                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 916                         t += 4;
 917                     }
 918                     t += 4;
 919                 } else if (s->decorr[i].value < 0) {
 920                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 921                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 922                     t += 4;
 923                 } else {
 924                     for (j = 0; j < s->decorr[i].value && buf+1<buf_end; j++) {
 925                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 926                         if (s->stereo_in) {
 927                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 928                         }
 929                     }
 930                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
 931                 }
 932             }
 933             got_samples = 1;
 934             break;
 935         case WP_ID_ENTROPY:
 936             if (size != 6 * (s->stereo_in + 1)) {
 937                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, "
 938                        "got %i", 6 * (s->stereo_in + 1), size);
 939                 buf += ssize;
 940                 continue;
 941             }
 942             for (j = 0; j <= s->stereo_in; j++) {
 943                 for (i = 0; i < 3; i++) {
 944                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
 945                     buf += 2;
 946                 }
 947             }
 948             got_entropy = 1;
 949             break;
 950         case WP_ID_HYBRID:
 951             if (s->hybrid_bitrate) {
 952                 for (i = 0; i <= s->stereo_in; i++) {
 953                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
 954                     buf += 2;
 955                     size -= 2;
 956                 }
 957             }
 958             for (i = 0; i < (s->stereo_in + 1); i++) {
 959                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
 960                 buf += 2;
 961                 size -= 2;
 962             }
 963             if (size > 0) {
 964                 for (i = 0; i < (s->stereo_in + 1); i++) {
 965                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
 966                     buf += 2;
 967                 }
 968             } else {
 969                 for (i = 0; i < (s->stereo_in + 1); i++)
 970                     s->ch[i].bitrate_delta = 0;
 971             }
 972             got_hybrid = 1;
 973             break;
 974         case WP_ID_INT32INFO:
 975             if (size != 4) {
 976                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
 977                 buf += ssize;
 978                 continue;
 979             }
 980             if (buf[0])
 981                 s->extra_bits = buf[0];
 982             else if (buf[1])
 983                 s->shift = buf[1];
 984             else if (buf[2]){
 985                 s->and = s->or = 1;
 986                 s->shift = buf[2];
 987             } else if(buf[3]) {
 988                 s->and   = 1;
 989                 s->shift = buf[3];
 990             }
 991             /* original WavPack decoder forces 32-bit lossy sound to be treated
 992              * as 24-bit one in order to have proper clipping
 993              */
 994             if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
 995                 s->post_shift += 8;
 996                 s->shift      -= 8;
 997                 s->hybrid_maxclip >>= 8;
 998                 s->hybrid_minclip >>= 8;
 999             }
1000             buf += 4;
1001             break;
1002         case WP_ID_FLOATINFO:
1003             if (size != 4) {
1004                 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
1005                 buf += ssize;
1006                 continue;
1007             }
1008             s->float_flag    = buf[0];
1009             s->float_shift   = buf[1];
1010             s->float_max_exp = buf[2];
1011             buf += 4;
1012             got_float = 1;
1013             break;
1014         case WP_ID_DATA:
1015             s->sc.offset = buf - orig_buf;
1016             s->sc.size   = size * 8;
1017             init_get_bits(&s->gb, buf, size * 8);
1018             s->data_size = size * 8;
1019             buf += size;
1020             got_bs = 1;
1021             break;
1022         case WP_ID_EXTRABITS:
1023             if (size <= 4) {
1024                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1025                        size);
1026                 buf += size;
1027                 continue;
1028             }
1029             s->extra_sc.offset = buf - orig_buf;
1030             s->extra_sc.size   = size * 8;
1031             init_get_bits(&s->gb_extra_bits, buf, size * 8);
1032             s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1033             buf += size;
1034             s->got_extra_bits = 1;
1035             break;
1036         case WP_ID_CHANINFO:
1037             if (size <= 1) {
1038                 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1039                 return -1;
1040             }
1041             chan = *buf++;
1042             switch (size - 2) {
1043             case 0: chmask = *buf;         break;
1044             case 1: chmask = AV_RL16(buf); break;
1045             case 2: chmask = AV_RL24(buf); break;
1046             case 3: chmask = AV_RL32(buf); break;
1047             case 5:
1048                 chan |= (buf[1] & 0xF) << 8;
1049                 chmask = AV_RL24(buf + 2);
1050                 break;
1051             default:
1052                 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1053                        size);
1054                 chan   = avctx->channels;
1055                 chmask = avctx->channel_layout;
1056             }
1057             if (chan != avctx->channels) {
1058                 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, "
1059                        "decoder believes it's %d channels\n", chan,
1060                        avctx->channels);
1061                 return -1;
1062             }
1063             if (!avctx->channel_layout)
1064                 avctx->channel_layout = chmask;
1065             buf += size - 1;
1066             break;
1067         default:
1068             buf += size;
1069         }
1070         if (id & WP_IDF_ODD)
1071             buf++;
1072     }
1073
1074     if (!got_terms) {
1075         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1076         return -1;
1077     }
1078     if (!got_weights) {
1079         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1080         return -1;
1081     }
1082     if (!got_samples) {
1083         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1084         return -1;
1085     }
1086     if (!got_entropy) {
1087         av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1088         return -1;
1089     }
1090     if (s->hybrid && !got_hybrid) {
1091         av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1092         return -1;
1093     }
1094     if (!got_bs) {
1095         av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1096         return -1;
1097     }
1098     if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1099         av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1100         return -1;
1101     }
1102     if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT) {
1103         const int size   = get_bits_left(&s->gb_extra_bits);
1104         const int wanted = s->samples * s->extra_bits << s->stereo_in;
1105         if (size < wanted) {
1106             av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1107             s->got_extra_bits = 0;
1108         }
1109     }
1110
1111     if (s->stereo_in) {
1112         if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1113             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1114         else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1115             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1116         else
1117             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1118
1119         if (samplecount < 0)
1120             return -1;
1121
1122         samplecount >>= 1;
1123     } else {
1124         const int channel_stride = avctx->channels;
1125
1126         if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1127             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1128         else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1129             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1130         else
1131             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1132
1133         if (samplecount < 0)
1134             return -1;
1135
1136         if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
1137             int16_t *dst = (int16_t*)samples + 1;
1138             int16_t *src = (int16_t*)samples;
1139             int cnt = samplecount;
1140             while (cnt--) {
1141                 *dst = *src;
1142                 src += channel_stride;
1143                 dst += channel_stride;
1144             }
1145         } else if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
1146             int32_t *dst = (int32_t*)samples + 1;
1147             int32_t *src = (int32_t*)samples;
1148             int cnt = samplecount;
1149             while (cnt--) {
1150                 *dst = *src;
1151                 src += channel_stride;
1152                 dst += channel_stride;
1153             }
1154         } else if (s->stereo) {
1155             float *dst = (float*)samples + 1;
1156             float *src = (float*)samples;
1157             int cnt = samplecount;
1158             while (cnt--) {
1159                 *dst = *src;
1160                 src += channel_stride;
1161                 dst += channel_stride;
1162             }
1163         }
1164     }
1165
1166     *got_frame_ptr = 1;
1167
1168     return samplecount * bpp;
1169 }
1170
1171 static void wavpack_decode_flush(AVCodecContext *avctx)
1172 {
1173     WavpackContext *s = avctx->priv_data;
1174     int i;
1175
1176     for (i = 0; i < s->fdec_num; i++)
1177         wv_reset_saved_context(s->fdec[i]);
1178 }
1179
1180 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1181                                 int *got_frame_ptr, AVPacket *avpkt)
1182 {
1183     WavpackContext *s  = avctx->priv_data;
1184     const uint8_t *buf = avpkt->data;
1185     int buf_size       = avpkt->size;
1186     AVFrame *frame     = data;
1187     int frame_size, ret, frame_flags;
1188     int samplecount = 0;
1189
1190     s->block     = 0;
1191     s->ch_offset = 0;
1192
1193     /* determine number of samples */
1194     if (s->mkv_mode) {
1195         s->samples  = AV_RL32(buf); buf += 4;
1196         frame_flags = AV_RL32(buf);
1197     } else {
1198         if (s->multichannel) {
1199             s->samples  = AV_RL32(buf + 4);
1200             frame_flags = AV_RL32(buf + 8);
1201         } else {
1202             s->samples  = AV_RL32(buf);
1203             frame_flags = AV_RL32(buf + 4);
1204         }
1205     }
1206     if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) {
1207         av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1208                s->samples);
1209         return AVERROR(EINVAL);
1210     }
1211
1212     if (frame_flags & 0x80) {
1213         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1214     } else if ((frame_flags & 0x03) <= 1) {
1215         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1216     } else {
1217         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1218         avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1219     }
1220
1221     /* get output buffer */
1222     frame->nb_samples = s->samples + 1;
1223     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1224         return ret;
1225     frame->nb_samples = s->samples;
1226
1227     while (buf_size > 0) {
1228         if (!s->multichannel) {
1229             frame_size = buf_size;
1230         } else {
1231             if (!s->mkv_mode) {
1232                 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1233             } else {
1234                 if (buf_size < 12) //MKV files can have zero flags after last block
1235                     break;
1236                 frame_size = AV_RL32(buf + 8) + 12;
1237             }
1238         }
1239         if (frame_size < 0 || frame_size > buf_size) {
1240             av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d "
1241                    "vs. %d bytes left)\n", s->block, frame_size, buf_size);
1242             wavpack_decode_flush(avctx);
1243             return AVERROR_INVALIDDATA;
1244         }
1245         if ((samplecount = wavpack_decode_block(avctx, s->block,
1246                                                 frame->data[0], got_frame_ptr,
1247                                                 buf, frame_size)) < 0) {
1248             wavpack_decode_flush(avctx);
1249             return AVERROR_INVALIDDATA;
1250         }
1251         s->block++;
1252         buf += frame_size; buf_size -= frame_size;
1253     }
1254
1255     return avpkt->size;
1256 }
1257
1258 AVCodec ff_wavpack_decoder = {
1259     .name           = "wavpack",
1260     .type           = AVMEDIA_TYPE_AUDIO,
1261     .id             = AV_CODEC_ID_WAVPACK,
1262     .priv_data_size = sizeof(WavpackContext),
1263     .init           = wavpack_decode_init,
1264     .close          = wavpack_decode_end,
1265     .decode         = wavpack_decode_frame,
1266     .flush          = wavpack_decode_flush,
1267     .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1268     .long_name      = NULL_IF_CONFIG_SMALL("WavPack"),
1269 };