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

   1 /*
   2  * WavPack lossless audio decoder
   3  * Copyright (c) 2006,2011 Konstantin Shishkov
   4  * Copyright (c) 2020 David Bryant
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include "libavutil/channel_layout.h"
  24
  25 #define BITSTREAM_READER_LE
  26 #include "avcodec.h"
  27 #include "bytestream.h"
  28 #include "get_bits.h"
  29 #include "internal.h"
  30 #include "thread.h"
  31 #include "unary.h"
  32 #include "wavpack.h"
  33 #include "dsd.h"
  34
  35 /**
  36  * @file
  37  * WavPack lossless audio decoder
  38  */
  39
  40 #define DSD_BYTE_READY(low,high) (!(((low) ^ (high)) & 0xff000000))
  41
  42 #define PTABLE_BITS 8
  43 #define PTABLE_BINS (1<<PTABLE_BITS)
  44 #define PTABLE_MASK (PTABLE_BINS-1)
  45
  46 #define UP   0x010000fe
  47 #define DOWN 0x00010000
  48 #define DECAY 8
  49
  50 #define PRECISION 20
  51 #define VALUE_ONE (1 << PRECISION)
  52 #define PRECISION_USE 12
  53
  54 #define RATE_S 20
  55
  56 #define MAX_HISTORY_BITS    5
  57 #define MAX_HISTORY_BINS    (1 << MAX_HISTORY_BITS)
  58 #define MAX_BIN_BYTES       1280    // for value_lookup, per bin (2k - 512 - 256)
  59
  60 typedef enum {
  61     MODULATION_PCM,     // pulse code modulation
  62     MODULATION_DSD      // pulse density modulation (aka DSD)
  63 } Modulation;
  64
  65 typedef struct WavpackFrameContext {
  66     AVCodecContext *avctx;
  67     int frame_flags;
  68     int stereo, stereo_in;
  69     int joint;
  70     uint32_t CRC;
  71     GetBitContext gb;
  72     int got_extra_bits;
  73     uint32_t crc_extra_bits;
  74     GetBitContext gb_extra_bits;
  75     int samples;
  76     int terms;
  77     Decorr decorr[MAX_TERMS];
  78     int zero, one, zeroes;
  79     int extra_bits;
  80     int and, or, shift;
  81     int post_shift;
  82     int hybrid, hybrid_bitrate;
  83     int hybrid_maxclip, hybrid_minclip;
  84     int float_flag;
  85     int float_shift;
  86     int float_max_exp;
  87     WvChannel ch[2];
  88
  89     GetByteContext gbyte;
  90     int ptable [PTABLE_BINS];
  91     uint8_t value_lookup_buffer[MAX_HISTORY_BINS*MAX_BIN_BYTES];
  92     uint16_t summed_probabilities[MAX_HISTORY_BINS][256];
  93     uint8_t probabilities[MAX_HISTORY_BINS][256];
  94     uint8_t *value_lookup[MAX_HISTORY_BINS];
  95 } WavpackFrameContext;
  96
  97 #define WV_MAX_FRAME_DECODERS 14
  98
  99 typedef struct WavpackContext {
 100     AVCodecContext *avctx;
 101
 102     WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
 103     int fdec_num;
 104
 105     int block;
 106     int samples;
 107     int ch_offset;
 108
 109     AVFrame *frame;
 110     ThreadFrame curr_frame, prev_frame;
 111     Modulation modulation;
 112     DSDContext *dsdctx;
 113 } WavpackContext;
 114
 115 #define LEVEL_DECAY(a)  (((a) + 0x80) >> 8)
 116
 117 static av_always_inline unsigned get_tail(GetBitContext *gb, int k)
 118 {
 119     int p, e, res;
 120
 121     if (k < 1)
 122         return 0;
 123     p   = av_log2(k);
 124     e   = (1 << (p + 1)) - k - 1;
 125     res = get_bitsz(gb, p);
 126     if (res >= e)
 127         res = (res << 1) - e + get_bits1(gb);
 128     return res;
 129 }
 130
 131 static int update_error_limit(WavpackFrameContext *ctx)
 132 {
 133     int i, br[2], sl[2];
 134
 135     for (i = 0; i <= ctx->stereo_in; i++) {
 136         if (ctx->ch[i].bitrate_acc > UINT_MAX - ctx->ch[i].bitrate_delta)
 137             return AVERROR_INVALIDDATA;
 138         ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
 139         br[i]                   = ctx->ch[i].bitrate_acc >> 16;
 140         sl[i]                   = LEVEL_DECAY(ctx->ch[i].slow_level);
 141     }
 142     if (ctx->stereo_in && ctx->hybrid_bitrate) {
 143         int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
 144         if (balance > br[0]) {
 145             br[1] = br[0] * 2;
 146             br[0] = 0;
 147         } else if (-balance > br[0]) {
 148             br[0]  *= 2;
 149             br[1]   = 0;
 150         } else {
 151             br[1] = br[0] + balance;
 152             br[0] = br[0] - balance;
 153         }
 154     }
 155     for (i = 0; i <= ctx->stereo_in; i++) {
 156         if (ctx->hybrid_bitrate) {
 157             if (sl[i] - br[i] > -0x100)
 158                 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
 159             else
 160                 ctx->ch[i].error_limit = 0;
 161         } else {
 162             ctx->ch[i].error_limit = wp_exp2(br[i]);
 163         }
 164     }
 165
 166     return 0;
 167 }
 168
 169 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
 170                         int channel, int *last)
 171 {
 172     int t, t2;
 173     int sign, base, add, ret;
 174     WvChannel *c = &ctx->ch[channel];
 175
 176     *last = 0;
 177
 178     if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&
 179         !ctx->zero && !ctx->one) {
 180         if (ctx->zeroes) {
 181             ctx->zeroes--;
 182             if (ctx->zeroes) {
 183                 c->slow_level -= LEVEL_DECAY(c->slow_level);
 184                 return 0;
 185             }
 186         } else {
 187             t = get_unary_0_33(gb);
 188             if (t >= 2) {
 189                 if (t >= 32 || get_bits_left(gb) < t - 1)
 190                     goto error;
 191                 t = get_bits_long(gb, t - 1) | (1 << (t - 1));
 192             } else {
 193                 if (get_bits_left(gb) < 0)
 194                     goto error;
 195             }
 196             ctx->zeroes = t;
 197             if (ctx->zeroes) {
 198                 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
 199                 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
 200                 c->slow_level -= LEVEL_DECAY(c->slow_level);
 201                 return 0;
 202             }
 203         }
 204     }
 205
 206     if (ctx->zero) {
 207         t         = 0;
 208         ctx->zero = 0;
 209     } else {
 210         t = get_unary_0_33(gb);
 211         if (get_bits_left(gb) < 0)
 212             goto error;
 213         if (t == 16) {
 214             t2 = get_unary_0_33(gb);
 215             if (t2 < 2) {
 216                 if (get_bits_left(gb) < 0)
 217                     goto error;
 218                 t += t2;
 219             } else {
 220                 if (t2 >= 32 || get_bits_left(gb) < t2 - 1)
 221                     goto error;
 222                 t += get_bits_long(gb, t2 - 1) | (1 << (t2 - 1));
 223             }
 224         }
 225
 226         if (ctx->one) {
 227             ctx->one = t & 1;
 228             t        = (t >> 1) + 1;
 229         } else {
 230             ctx->one = t & 1;
 231             t      >>= 1;
 232         }
 233         ctx->zero = !ctx->one;
 234     }
 235
 236     if (ctx->hybrid && !channel) {
 237         if (update_error_limit(ctx) < 0)
 238             goto error;
 239     }
 240
 241     if (!t) {
 242         base = 0;
 243         add  = GET_MED(0) - 1;
 244         DEC_MED(0);
 245     } else if (t == 1) {
 246         base = GET_MED(0);
 247         add  = GET_MED(1) - 1;
 248         INC_MED(0);
 249         DEC_MED(1);
 250     } else if (t == 2) {
 251         base = GET_MED(0) + GET_MED(1);
 252         add  = GET_MED(2) - 1;
 253         INC_MED(0);
 254         INC_MED(1);
 255         DEC_MED(2);
 256     } else {
 257         base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2U);
 258         add  = GET_MED(2) - 1;
 259         INC_MED(0);
 260         INC_MED(1);
 261         INC_MED(2);
 262     }
 263     if (!c->error_limit) {
 264         if (add >= 0x2000000U) {
 265             av_log(ctx->avctx, AV_LOG_ERROR, "k %d is too large\n", add);
 266             goto error;
 267         }
 268         ret = base + get_tail(gb, add);
 269         if (get_bits_left(gb) <= 0)
 270             goto error;
 271     } else {
 272         int mid = (base * 2U + add + 1) >> 1;
 273         while (add > c->error_limit) {
 274             if (get_bits_left(gb) <= 0)
 275                 goto error;
 276             if (get_bits1(gb)) {
 277                 add -= (mid - (unsigned)base);
 278                 base = mid;
 279             } else
 280                 add = mid - (unsigned)base - 1;
 281             mid = (base * 2U + add + 1) >> 1;
 282         }
 283         ret = mid;
 284     }
 285     sign = get_bits1(gb);
 286     if (ctx->hybrid_bitrate)
 287         c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
 288     return sign ? ~ret : ret;
 289
 290 error:
 291     ret = get_bits_left(gb);
 292     if (ret <= 0) {
 293         av_log(ctx->avctx, AV_LOG_ERROR, "Too few bits (%d) left\n", ret);
 294     }
 295     *last = 1;
 296     return 0;
 297 }
 298
 299 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
 300                                        unsigned S)
 301 {
 302     unsigned bit;
 303
 304     if (s->extra_bits) {
 305         S *= 1 << s->extra_bits;
 306
 307         if (s->got_extra_bits &&
 308             get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {
 309             S   |= get_bits_long(&s->gb_extra_bits, s->extra_bits);
 310             *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);
 311         }
 312     }
 313
 314     bit = (S & s->and) | s->or;
 315     bit = ((S + bit) << s->shift) - bit;
 316
 317     if (s->hybrid)
 318         bit = av_clip(bit, s->hybrid_minclip, s->hybrid_maxclip);
 319
 320     return bit << s->post_shift;
 321 }
 322
 323 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
 324 {
 325     union {
 326         float    f;
 327         uint32_t u;
 328     } value;
 329
 330     unsigned int sign;
 331     int exp = s->float_max_exp;
 332
 333     if (s->got_extra_bits) {
 334         const int max_bits  = 1 + 23 + 8 + 1;
 335         const int left_bits = get_bits_left(&s->gb_extra_bits);
 336
 337         if (left_bits + 8 * AV_INPUT_BUFFER_PADDING_SIZE < max_bits)
 338             return 0.0;
 339     }
 340
 341     if (S) {
 342         S  *= 1U << s->float_shift;
 343         sign = S < 0;
 344         if (sign)
 345             S = -(unsigned)S;
 346         if (S >= 0x1000000U) {
 347             if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))
 348                 S = get_bits(&s->gb_extra_bits, 23);
 349             else
 350                 S = 0;
 351             exp = 255;
 352         } else if (exp) {
 353             int shift = 23 - av_log2(S);
 354             exp = s->float_max_exp;
 355             if (exp <= shift)
 356                 shift = --exp;
 357             exp -= shift;
 358
 359             if (shift) {
 360                 S <<= shift;
 361                 if ((s->float_flag & WV_FLT_SHIFT_ONES) ||
 362                     (s->got_extra_bits &&
 363                      (s->float_flag & WV_FLT_SHIFT_SAME) &&
 364                      get_bits1(&s->gb_extra_bits))) {
 365                     S |= (1 << shift) - 1;
 366                 } else if (s->got_extra_bits &&
 367                            (s->float_flag & WV_FLT_SHIFT_SENT)) {
 368                     S |= get_bits(&s->gb_extra_bits, shift);
 369                 }
 370             }
 371         } else {
 372             exp = s->float_max_exp;
 373         }
 374         S &= 0x7fffff;
 375     } else {
 376         sign = 0;
 377         exp  = 0;
 378         if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {
 379             if (get_bits1(&s->gb_extra_bits)) {
 380                 S = get_bits(&s->gb_extra_bits, 23);
 381                 if (s->float_max_exp >= 25)
 382                     exp = get_bits(&s->gb_extra_bits, 8);
 383                 sign = get_bits1(&s->gb_extra_bits);
 384             } else {
 385                 if (s->float_flag & WV_FLT_ZERO_SIGN)
 386                     sign = get_bits1(&s->gb_extra_bits);
 387             }
 388         }
 389     }
 390
 391     *crc = *crc * 27 + S * 9 + exp * 3 + sign;
 392
 393     value.u = (sign << 31) | (exp << 23) | S;
 394     return value.f;
 395 }
 396
 397 static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc,
 398                                uint32_t crc_extra_bits)
 399 {
 400     if (crc != s->CRC) {
 401         av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
 402         return AVERROR_INVALIDDATA;
 403     }
 404     if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
 405         av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 406         return AVERROR_INVALIDDATA;
 407     }
 408
 409     return 0;
 410 }
 411
 412 static void init_ptable(int *table, int rate_i, int rate_s)
 413 {
 414     int value = 0x808000, rate = rate_i << 8;
 415
 416     for (int c = (rate + 128) >> 8; c--;)
 417         value += (DOWN - value) >> DECAY;
 418
 419     for (int i = 0; i < PTABLE_BINS/2; i++) {
 420         table[i] = value;
 421         table[PTABLE_BINS-1-i] = 0x100ffff - value;
 422
 423         if (value > 0x010000) {
 424             rate += (rate * rate_s + 128) >> 8;
 425
 426             for (int c = (rate + 64) >> 7; c--;)
 427                 value += (DOWN - value) >> DECAY;
 428         }
 429     }
 430 }
 431
 432 typedef struct {
 433     int32_t value, fltr0, fltr1, fltr2, fltr3, fltr4, fltr5, fltr6, factor;
 434     unsigned int byte;
 435 } DSDfilters;
 436
 437 static int wv_unpack_dsd_high(WavpackFrameContext *s, uint8_t *dst_left, uint8_t *dst_right)
 438 {
 439     uint32_t checksum = 0xFFFFFFFF;
 440     uint8_t *dst_l = dst_left, *dst_r = dst_right;
 441     int total_samples = s->samples, stereo = dst_r ? 1 : 0;
 442     DSDfilters filters[2], *sp = filters;
 443     int rate_i, rate_s;
 444     uint32_t low, high, value;
 445
 446     if (bytestream2_get_bytes_left(&s->gbyte) < (stereo ? 20 : 13))
 447         return AVERROR_INVALIDDATA;
 448
 449     rate_i = bytestream2_get_byte(&s->gbyte);
 450     rate_s = bytestream2_get_byte(&s->gbyte);
 451
 452     if (rate_s != RATE_S)
 453         return AVERROR_INVALIDDATA;
 454
 455     init_ptable(s->ptable, rate_i, rate_s);
 456
 457     for (int channel = 0; channel < stereo + 1; channel++) {
 458         DSDfilters *sp = filters + channel;
 459
 460         sp->fltr1 = bytestream2_get_byte(&s->gbyte) << (PRECISION - 8);
 461         sp->fltr2 = bytestream2_get_byte(&s->gbyte) << (PRECISION - 8);
 462         sp->fltr3 = bytestream2_get_byte(&s->gbyte) << (PRECISION - 8);
 463         sp->fltr4 = bytestream2_get_byte(&s->gbyte) << (PRECISION - 8);
 464         sp->fltr5 = bytestream2_get_byte(&s->gbyte) << (PRECISION - 8);
 465         sp->fltr6 = 0;
 466         sp->factor = bytestream2_get_byte(&s->gbyte) & 0xff;
 467         sp->factor |= (bytestream2_get_byte(&s->gbyte) << 8) & 0xff00;
 468         sp->factor = (int32_t)((uint32_t)sp->factor << 16) >> 16;
 469     }
 470
 471     value = bytestream2_get_be32(&s->gbyte);
 472     high = 0xffffffff;
 473     low = 0x0;
 474
 475     while (total_samples--) {
 476         int bitcount = 8;
 477
 478         sp[0].value = sp[0].fltr1 - sp[0].fltr5 + ((sp[0].fltr6 * sp[0].factor) >> 2);
 479
 480         if (stereo)
 481             sp[1].value = sp[1].fltr1 - sp[1].fltr5 + ((sp[1].fltr6 * sp[1].factor) >> 2);
 482
 483         while (bitcount--) {
 484             int32_t *pp = s->ptable + ((sp[0].value >> (PRECISION - PRECISION_USE)) & PTABLE_MASK);
 485             uint32_t split = low + ((high - low) >> 8) * (*pp >> 16);
 486
 487             if (value <= split) {
 488                 high = split;
 489                 *pp += (UP - *pp) >> DECAY;
 490                 sp[0].fltr0 = -1;
 491             } else {
 492                 low = split + 1;
 493                 *pp += (DOWN - *pp) >> DECAY;
 494                 sp[0].fltr0 = 0;
 495             }
 496
 497             while (DSD_BYTE_READY(high, low) && bytestream2_get_bytes_left(&s->gbyte)) {
 498                 value = (value << 8) | bytestream2_get_byte(&s->gbyte);
 499                 high = (high << 8) | 0xff;
 500                 low <<= 8;
 501             }
 502
 503             sp[0].value += sp[0].fltr6 * 8;
 504             sp[0].byte = (sp[0].byte << 1) | (sp[0].fltr0 & 1);
 505             sp[0].factor += (((sp[0].value ^ sp[0].fltr0) >> 31) | 1) &
 506                 ((sp[0].value ^ (sp[0].value - (sp[0].fltr6 * 16))) >> 31);
 507             sp[0].fltr1 += ((sp[0].fltr0 & VALUE_ONE) - sp[0].fltr1) >> 6;
 508             sp[0].fltr2 += ((sp[0].fltr0 & VALUE_ONE) - sp[0].fltr2) >> 4;
 509             sp[0].fltr3 += (sp[0].fltr2 - sp[0].fltr3) >> 4;
 510             sp[0].fltr4 += (sp[0].fltr3 - sp[0].fltr4) >> 4;
 511             sp[0].value = (sp[0].fltr4 - sp[0].fltr5) >> 4;
 512             sp[0].fltr5 += sp[0].value;
 513             sp[0].fltr6 += (sp[0].value - sp[0].fltr6) >> 3;
 514             sp[0].value = sp[0].fltr1 - sp[0].fltr5 + ((sp[0].fltr6 * sp[0].factor) >> 2);
 515
 516             if (!stereo)
 517                 continue;
 518
 519             pp = s->ptable + ((sp[1].value >> (PRECISION - PRECISION_USE)) & PTABLE_MASK);
 520             split = low + ((high - low) >> 8) * (*pp >> 16);
 521
 522             if (value <= split) {
 523                 high = split;
 524                 *pp += (UP - *pp) >> DECAY;
 525                 sp[1].fltr0 = -1;
 526             } else {
 527                 low = split + 1;
 528                 *pp += (DOWN - *pp) >> DECAY;
 529                 sp[1].fltr0 = 0;
 530             }
 531
 532             while (DSD_BYTE_READY(high, low) && bytestream2_get_bytes_left(&s->gbyte)) {
 533                 value = (value << 8) | bytestream2_get_byte(&s->gbyte);
 534                 high = (high << 8) | 0xff;
 535                 low <<= 8;
 536             }
 537
 538             sp[1].value += sp[1].fltr6 * 8;
 539             sp[1].byte = (sp[1].byte << 1) | (sp[1].fltr0 & 1);
 540             sp[1].factor += (((sp[1].value ^ sp[1].fltr0) >> 31) | 1) &
 541                 ((sp[1].value ^ (sp[1].value - (sp[1].fltr6 * 16))) >> 31);
 542             sp[1].fltr1 += ((sp[1].fltr0 & VALUE_ONE) - sp[1].fltr1) >> 6;
 543             sp[1].fltr2 += ((sp[1].fltr0 & VALUE_ONE) - sp[1].fltr2) >> 4;
 544             sp[1].fltr3 += (sp[1].fltr2 - sp[1].fltr3) >> 4;
 545             sp[1].fltr4 += (sp[1].fltr3 - sp[1].fltr4) >> 4;
 546             sp[1].value = (sp[1].fltr4 - sp[1].fltr5) >> 4;
 547             sp[1].fltr5 += sp[1].value;
 548             sp[1].fltr6 += (sp[1].value - sp[1].fltr6) >> 3;
 549             sp[1].value = sp[1].fltr1 - sp[1].fltr5 + ((sp[1].fltr6 * sp[1].factor) >> 2);
 550         }
 551
 552         checksum += (checksum << 1) + (*dst_l = sp[0].byte & 0xff);
 553         sp[0].factor -= (sp[0].factor + 512) >> 10;
 554         dst_l += 4;
 555
 556         if (stereo) {
 557             checksum += (checksum << 1) + (*dst_r = filters[1].byte & 0xff);
 558             filters[1].factor -= (filters[1].factor + 512) >> 10;
 559             dst_r += 4;
 560         }
 561     }
 562
 563     if (wv_check_crc(s, checksum, 0)) {
 564         if (s->avctx->err_recognition & AV_EF_CRCCHECK)
 565             return AVERROR_INVALIDDATA;
 566
 567         memset(dst_left, 0x69, s->samples * 4);
 568
 569         if (dst_r)
 570             memset(dst_right, 0x69, s->samples * 4);
 571     }
 572
 573     return 0;
 574 }
 575
 576 static int wv_unpack_dsd_fast(WavpackFrameContext *s, uint8_t *dst_left, uint8_t *dst_right)
 577 {
 578     uint8_t *dst_l = dst_left, *dst_r = dst_right;
 579     uint8_t history_bits, max_probability;
 580     int total_summed_probabilities  = 0;
 581     int total_samples               = s->samples;
 582     uint8_t *vlb                    = s->value_lookup_buffer;
 583     int history_bins, p0, p1, chan;
 584     uint32_t checksum               = 0xFFFFFFFF;
 585     uint32_t low, high, value;
 586
 587     if (!bytestream2_get_bytes_left(&s->gbyte))
 588         return AVERROR_INVALIDDATA;
 589
 590     history_bits = bytestream2_get_byte(&s->gbyte);
 591
 592     if (!bytestream2_get_bytes_left(&s->gbyte) || history_bits > MAX_HISTORY_BITS)
 593         return AVERROR_INVALIDDATA;
 594
 595     history_bins = 1 << history_bits;
 596     max_probability = bytestream2_get_byte(&s->gbyte);
 597
 598     if (max_probability < 0xff) {
 599         uint8_t *outptr = (uint8_t *)s->probabilities;
 600         uint8_t *outend = outptr + sizeof(*s->probabilities) * history_bins;
 601
 602         while (outptr < outend && bytestream2_get_bytes_left(&s->gbyte)) {
 603             int code = bytestream2_get_byte(&s->gbyte);
 604
 605             if (code > max_probability) {
 606                 int zcount = code - max_probability;
 607
 608                 while (outptr < outend && zcount--)
 609                     *outptr++ = 0;
 610             } else if (code) {
 611                 *outptr++ = code;
 612             }
 613             else {
 614                 break;
 615             }
 616         }
 617
 618         if (outptr < outend ||
 619             (bytestream2_get_bytes_left(&s->gbyte) && bytestream2_get_byte(&s->gbyte)))
 620                 return AVERROR_INVALIDDATA;
 621     } else if (bytestream2_get_bytes_left(&s->gbyte) > (int)sizeof(*s->probabilities) * history_bins) {
 622         bytestream2_get_buffer(&s->gbyte, (uint8_t *)s->probabilities,
 623             sizeof(*s->probabilities) * history_bins);
 624     } else {
 625         return AVERROR_INVALIDDATA;
 626     }
 627
 628     for (p0 = 0; p0 < history_bins; p0++) {
 629         int32_t sum_values = 0;
 630
 631         for (int i = 0; i < 256; i++)
 632             s->summed_probabilities[p0][i] = sum_values += s->probabilities[p0][i];
 633
 634         if (sum_values) {
 635             total_summed_probabilities += sum_values;
 636
 637             if (total_summed_probabilities > history_bins * MAX_BIN_BYTES)
 638                 return AVERROR_INVALIDDATA;
 639
 640             s->value_lookup[p0] = vlb;
 641
 642             for (int i = 0; i < 256; i++) {
 643                 int c = s->probabilities[p0][i];
 644
 645                 while (c--)
 646                     *vlb++ = i;
 647             }
 648         }
 649     }
 650
 651     if (bytestream2_get_bytes_left(&s->gbyte) < 4)
 652         return AVERROR_INVALIDDATA;
 653
 654     chan = p0 = p1 = 0;
 655     low = 0; high = 0xffffffff;
 656     value = bytestream2_get_be32(&s->gbyte);
 657
 658     if (dst_r)
 659         total_samples *= 2;
 660
 661     while (total_samples--) {
 662         unsigned int mult, index, code;
 663
 664         if (!s->summed_probabilities[p0][255])
 665             return AVERROR_INVALIDDATA;
 666
 667         mult = (high - low) / s->summed_probabilities[p0][255];
 668
 669         if (!mult) {
 670             if (bytestream2_get_bytes_left(&s->gbyte) >= 4)
 671                 value = bytestream2_get_be32(&s->gbyte);
 672
 673             low = 0;
 674             high = 0xffffffff;
 675             mult = high / s->summed_probabilities[p0][255];
 676
 677             if (!mult)
 678                 return AVERROR_INVALIDDATA;
 679         }
 680
 681         index = (value - low) / mult;
 682
 683         if (index >= s->summed_probabilities[p0][255])
 684             return AVERROR_INVALIDDATA;
 685
 686         if (!dst_r) {
 687             if ((*dst_l = code = s->value_lookup[p0][index]))
 688                 low += s->summed_probabilities[p0][code-1] * mult;
 689
 690             dst_l += 4;
 691         } else {
 692             if ((code = s->value_lookup[p0][index]))
 693                 low += s->summed_probabilities[p0][code-1] * mult;
 694
 695             if (chan) {
 696                 *dst_r = code;
 697                 dst_r += 4;
 698             }
 699             else {
 700                 *dst_l = code;
 701                 dst_l += 4;
 702             }
 703
 704             chan ^= 1;
 705         }
 706
 707         high = low + s->probabilities[p0][code] * mult - 1;
 708         checksum += (checksum << 1) + code;
 709
 710         if (!dst_r) {
 711             p0 = code & (history_bins-1);
 712         } else {
 713             p0 = p1;
 714             p1 = code & (history_bins-1);
 715         }
 716
 717         while (DSD_BYTE_READY(high, low) && bytestream2_get_bytes_left(&s->gbyte)) {
 718             value = (value << 8) | bytestream2_get_byte(&s->gbyte);
 719             high = (high << 8) | 0xff;
 720             low <<= 8;
 721         }
 722     }
 723
 724     if (wv_check_crc(s, checksum, 0)) {
 725         if (s->avctx->err_recognition & AV_EF_CRCCHECK)
 726             return AVERROR_INVALIDDATA;
 727
 728         memset(dst_left, 0x69, s->samples * 4);
 729
 730         if (dst_r)
 731             memset(dst_right, 0x69, s->samples * 4);
 732     }
 733
 734     return 0;
 735 }
 736
 737 static int wv_unpack_dsd_copy(WavpackFrameContext *s, uint8_t *dst_left, uint8_t *dst_right)
 738 {
 739     uint8_t *dst_l = dst_left, *dst_r = dst_right;
 740     int total_samples           = s->samples;
 741     uint32_t checksum           = 0xFFFFFFFF;
 742
 743     if (bytestream2_get_bytes_left(&s->gbyte) != total_samples * (dst_r ? 2 : 1))
 744         return AVERROR_INVALIDDATA;
 745
 746     while (total_samples--) {
 747         checksum += (checksum << 1) + (*dst_l = bytestream2_get_byte(&s->gbyte));
 748         dst_l += 4;
 749
 750         if (dst_r) {
 751             checksum += (checksum << 1) + (*dst_r = bytestream2_get_byte(&s->gbyte));
 752             dst_r += 4;
 753         }
 754     }
 755
 756     if (wv_check_crc(s, checksum, 0)) {
 757         if (s->avctx->err_recognition & AV_EF_CRCCHECK)
 758             return AVERROR_INVALIDDATA;
 759
 760         memset(dst_left, 0x69, s->samples * 4);
 761
 762         if (dst_r)
 763             memset(dst_right, 0x69, s->samples * 4);
 764     }
 765
 766     return 0;
 767 }
 768
 769 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
 770                                    void *dst_l, void *dst_r, const int type)
 771 {
 772     int i, j, count = 0;
 773     int last, t;
 774     int A, B, L, L2, R, R2;
 775     int pos                 = 0;
 776     uint32_t crc            = 0xFFFFFFFF;
 777     uint32_t crc_extra_bits = 0xFFFFFFFF;
 778     int16_t *dst16_l        = dst_l;
 779     int16_t *dst16_r        = dst_r;
 780     int32_t *dst32_l        = dst_l;
 781     int32_t *dst32_r        = dst_r;
 782     float *dstfl_l          = dst_l;
 783     float *dstfl_r          = dst_r;
 784
 785     s->one = s->zero = s->zeroes = 0;
 786     do {
 787         L = wv_get_value(s, gb, 0, &last);
 788         if (last)
 789             break;
 790         R = wv_get_value(s, gb, 1, &last);
 791         if (last)
 792             break;
 793         for (i = 0; i < s->terms; i++) {
 794             t = s->decorr[i].value;
 795             if (t > 0) {
 796                 if (t > 8) {
 797                     if (t & 1) {
 798                         A = 2U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 799                         B = 2U * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
 800                     } else {
 801                         A = (int)(3U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 802                         B = (int)(3U * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
 803                     }
 804                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 805                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
 806                     j                        = 0;
 807                 } else {
 808                     A = s->decorr[i].samplesA[pos];
 809                     B = s->decorr[i].samplesB[pos];
 810                     j = (pos + t) & 7;
 811                 }
 812                 if (type != AV_SAMPLE_FMT_S16P) {
 813                     L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 814                     R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
 815                 } else {
 816                     L2 = L + (unsigned)((int)(s->decorr[i].weightA * (unsigned)A + 512) >> 10);
 817                     R2 = R + (unsigned)((int)(s->decorr[i].weightB * (unsigned)B + 512) >> 10);
 818                 }
 819                 if (A && L)
 820                     s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 821                 if (B && R)
 822                     s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
 823                 s->decorr[i].samplesA[j] = L = L2;
 824                 s->decorr[i].samplesB[j] = R = R2;
 825             } else if (t == -1) {
 826                 if (type != AV_SAMPLE_FMT_S16P)
 827                     L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
 828                 else
 829                     L2 = L + (unsigned)((int)(s->decorr[i].weightA * (unsigned)s->decorr[i].samplesA[0] + 512) >> 10);
 830                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
 831                 L = L2;
 832                 if (type != AV_SAMPLE_FMT_S16P)
 833                     R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
 834                 else
 835                     R2 = R + (unsigned)((int)(s->decorr[i].weightB * (unsigned)L2 + 512) >> 10);
 836                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
 837                 R                        = R2;
 838                 s->decorr[i].samplesA[0] = R;
 839             } else {
 840                 if (type != AV_SAMPLE_FMT_S16P)
 841                     R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
 842                 else
 843                     R2 = R + (unsigned)((int)(s->decorr[i].weightB * (unsigned)s->decorr[i].samplesB[0] + 512) >> 10);
 844                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
 845                 R = R2;
 846
 847                 if (t == -3) {
 848                     R2                       = s->decorr[i].samplesA[0];
 849                     s->decorr[i].samplesA[0] = R;
 850                 }
 851
 852                 if (type != AV_SAMPLE_FMT_S16P)
 853                     L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
 854                 else
 855                     L2 = L + (unsigned)((int)(s->decorr[i].weightA * (unsigned)R2 + 512) >> 10);
 856                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
 857                 L                        = L2;
 858                 s->decorr[i].samplesB[0] = L;
 859             }
 860         }
 861
 862         if (type == AV_SAMPLE_FMT_S16P) {
 863             if (FFABS((int64_t)L) + FFABS((int64_t)R) > (1<<19)) {
 864                 av_log(s->avctx, AV_LOG_ERROR, "sample %d %d too large\n", L, R);
 865                 return AVERROR_INVALIDDATA;
 866             }
 867         }
 868
 869         pos = (pos + 1) & 7;
 870         if (s->joint)
 871             L += (unsigned)(R -= (unsigned)(L >> 1));
 872         crc = (crc * 3 + L) * 3 + R;
 873
 874         if (type == AV_SAMPLE_FMT_FLTP) {
 875             *dstfl_l++ = wv_get_value_float(s, &crc_extra_bits, L);
 876             *dstfl_r++ = wv_get_value_float(s, &crc_extra_bits, R);
 877         } else if (type == AV_SAMPLE_FMT_S32P) {
 878             *dst32_l++ = wv_get_value_integer(s, &crc_extra_bits, L);
 879             *dst32_r++ = wv_get_value_integer(s, &crc_extra_bits, R);
 880         } else {
 881             *dst16_l++ = wv_get_value_integer(s, &crc_extra_bits, L);
 882             *dst16_r++ = wv_get_value_integer(s, &crc_extra_bits, R);
 883         }
 884         count++;
 885     } while (!last && count < s->samples);
 886
 887     if (last && count < s->samples) {
 888         int size = av_get_bytes_per_sample(type);
 889         memset((uint8_t*)dst_l + count*size, 0, (s->samples-count)*size);
 890         memset((uint8_t*)dst_r + count*size, 0, (s->samples-count)*size);
 891     }
 892
 893     if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
 894         wv_check_crc(s, crc, crc_extra_bits))
 895         return AVERROR_INVALIDDATA;
 896
 897     return 0;
 898 }
 899
 900 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
 901                                  void *dst, const int type)
 902 {
 903     int i, j, count = 0;
 904     int last, t;
 905     int A, S, T;
 906     int pos                  = 0;
 907     uint32_t crc             = 0xFFFFFFFF;
 908     uint32_t crc_extra_bits  = 0xFFFFFFFF;
 909     int16_t *dst16           = dst;
 910     int32_t *dst32           = dst;
 911     float *dstfl             = dst;
 912
 913     s->one = s->zero = s->zeroes = 0;
 914     do {
 915         T = wv_get_value(s, gb, 0, &last);
 916         S = 0;
 917         if (last)
 918             break;
 919         for (i = 0; i < s->terms; i++) {
 920             t = s->decorr[i].value;
 921             if (t > 8) {
 922                 if (t & 1)
 923                     A =  2U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 924                 else
 925                     A = (int)(3U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 926                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 927                 j                        = 0;
 928             } else {
 929                 A = s->decorr[i].samplesA[pos];
 930                 j = (pos + t) & 7;
 931             }
 932             if (type != AV_SAMPLE_FMT_S16P)
 933                 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 934             else
 935                 S = T + (unsigned)((int)(s->decorr[i].weightA * (unsigned)A + 512) >> 10);
 936             if (A && T)
 937                 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 938             s->decorr[i].samplesA[j] = T = S;
 939         }
 940         pos = (pos + 1) & 7;
 941         crc = crc * 3 + S;
 942
 943         if (type == AV_SAMPLE_FMT_FLTP) {
 944             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S);
 945         } else if (type == AV_SAMPLE_FMT_S32P) {
 946             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S);
 947         } else {
 948             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);
 949         }
 950         count++;
 951     } while (!last && count < s->samples);
 952
 953     if (last && count < s->samples) {
 954         int size = av_get_bytes_per_sample(type);
 955         memset((uint8_t*)dst + count*size, 0, (s->samples-count)*size);
 956     }
 957
 958     if (s->avctx->err_recognition & AV_EF_CRCCHECK) {
 959         int ret = wv_check_crc(s, crc, crc_extra_bits);
 960         if (ret < 0 && s->avctx->err_recognition & AV_EF_EXPLODE)
 961             return ret;
 962     }
 963
 964     return 0;
 965 }
 966
 967 static av_cold int wv_alloc_frame_context(WavpackContext *c)
 968 {
 969     if (c->fdec_num == WV_MAX_FRAME_DECODERS)
 970         return -1;
 971
 972     c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
 973     if (!c->fdec[c->fdec_num])
 974         return -1;
 975     c->fdec_num++;
 976     c->fdec[c->fdec_num - 1]->avctx = c->avctx;
 977
 978     return 0;
 979 }
 980
 981 #if HAVE_THREADS
 982 static int init_thread_copy(AVCodecContext *avctx)
 983 {
 984     WavpackContext *s = avctx->priv_data;
 985     s->avctx = avctx;
 986
 987     s->curr_frame.f = av_frame_alloc();
 988     s->prev_frame.f = av_frame_alloc();
 989
 990     if (!s->curr_frame.f || !s->prev_frame.f)
 991         return AVERROR(ENOMEM);
 992
 993     return 0;
 994 }
 995
 996 static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
 997 {
 998     WavpackContext *fsrc = src->priv_data;
 999     WavpackContext *fdst = dst->priv_data;
1000     int ret;
1001
1002     if (dst == src)
1003         return 0;
1004
1005     ff_thread_release_buffer(dst, &fdst->curr_frame);
1006     if (fsrc->curr_frame.f->data[0]) {
1007         if ((ret = ff_thread_ref_frame(&fdst->curr_frame, &fsrc->curr_frame)) < 0)
1008             return ret;
1009     }
1010
1011     return 0;
1012 }
1013 #endif
1014
1015 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
1016 {
1017     WavpackContext *s = avctx->priv_data;
1018
1019     s->avctx = avctx;
1020
1021     s->fdec_num = 0;
1022
1023     avctx->internal->allocate_progress = 1;
1024
1025     s->curr_frame.f = av_frame_alloc();
1026     s->prev_frame.f = av_frame_alloc();
1027
1028     // the DSD to PCM context is shared (and used serially) between all decoding threads
1029     s->dsdctx = av_calloc(avctx->channels, sizeof(DSDContext));
1030
1031     if (!s->curr_frame.f || !s->prev_frame.f || !s->dsdctx)
1032         return AVERROR(ENOMEM);
1033
1034     for (int i = 0; i < avctx->channels; i++)
1035         memset(s->dsdctx[i].buf, 0x69, sizeof(s->dsdctx[i].buf));
1036
1037     ff_init_dsd_data();
1038
1039     return 0;
1040 }
1041
1042 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
1043 {
1044     WavpackContext *s = avctx->priv_data;
1045
1046     for (int i = 0; i < s->fdec_num; i++)
1047         av_freep(&s->fdec[i]);
1048     s->fdec_num = 0;
1049
1050     ff_thread_release_buffer(avctx, &s->curr_frame);
1051     av_frame_free(&s->curr_frame.f);
1052
1053     ff_thread_release_buffer(avctx, &s->prev_frame);
1054     av_frame_free(&s->prev_frame.f);
1055
1056     if (!avctx->internal->is_copy)
1057         av_freep(&s->dsdctx);
1058
1059     return 0;
1060 }
1061
1062 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
1063                                 const uint8_t *buf, int buf_size)
1064 {
1065     WavpackContext *wc = avctx->priv_data;
1066     WavpackFrameContext *s;
1067     GetByteContext gb;
1068     void *samples_l = NULL, *samples_r = NULL;
1069     int ret;
1070     int got_terms   = 0, got_weights = 0, got_samples = 0,
1071         got_entropy = 0, got_pcm     = 0, got_float   = 0, got_hybrid = 0;
1072     int got_dsd = 0;
1073     int i, j, id, size, ssize, weights, t;
1074     int bpp, chan = 0, orig_bpp, sample_rate = 0, rate_x = 1, dsd_mode = 0;
1075     int multiblock;
1076     uint64_t chmask = 0;
1077
1078     if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
1079         av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
1080         return AVERROR_INVALIDDATA;
1081     }
1082
1083     s = wc->fdec[block_no];
1084     if (!s) {
1085         av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n",
1086                block_no);
1087         return AVERROR_INVALIDDATA;
1088     }
1089
1090     memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
1091     memset(s->ch, 0, sizeof(s->ch));
1092     s->extra_bits     = 0;
1093     s->and            = s->or = s->shift = 0;
1094     s->got_extra_bits = 0;
1095
1096     bytestream2_init(&gb, buf, buf_size);
1097
1098     s->samples = bytestream2_get_le32(&gb);
1099     if (s->samples != wc->samples) {
1100         av_log(avctx, AV_LOG_ERROR, "Mismatching number of samples in "
1101                "a sequence: %d and %d\n", wc->samples, s->samples);
1102         return AVERROR_INVALIDDATA;
1103     }
1104     s->frame_flags = bytestream2_get_le32(&gb);
1105     bpp            = av_get_bytes_per_sample(avctx->sample_fmt);
1106     orig_bpp       = ((s->frame_flags & 0x03) + 1) << 3;
1107     multiblock     = (s->frame_flags & WV_SINGLE_BLOCK) != WV_SINGLE_BLOCK;
1108
1109     s->stereo         = !(s->frame_flags & WV_MONO);
1110     s->stereo_in      =  (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
1111     s->joint          =   s->frame_flags & WV_JOINT_STEREO;
1112     s->hybrid         =   s->frame_flags & WV_HYBRID_MODE;
1113     s->hybrid_bitrate =   s->frame_flags & WV_HYBRID_BITRATE;
1114     s->post_shift     = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
1115     if (s->post_shift < 0 || s->post_shift > 31) {
1116         return AVERROR_INVALIDDATA;
1117     }
1118     s->hybrid_maxclip =  ((1LL << (orig_bpp - 1)) - 1);
1119     s->hybrid_minclip = ((-1UL << (orig_bpp - 1)));
1120     s->CRC            = bytestream2_get_le32(&gb);
1121
1122     // parse metadata blocks
1123     while (bytestream2_get_bytes_left(&gb)) {
1124         id   = bytestream2_get_byte(&gb);
1125         size = bytestream2_get_byte(&gb);
1126         if (id & WP_IDF_LONG)
1127             size |= (bytestream2_get_le16u(&gb)) << 8;
1128         size <<= 1; // size is specified in words
1129         ssize  = size;
1130         if (id & WP_IDF_ODD)
1131             size--;
1132         if (size < 0) {
1133             av_log(avctx, AV_LOG_ERROR,
1134                    "Got incorrect block %02X with size %i\n", id, size);
1135             break;
1136         }
1137         if (bytestream2_get_bytes_left(&gb) < ssize) {
1138             av_log(avctx, AV_LOG_ERROR,
1139                    "Block size %i is out of bounds\n", size);
1140             break;
1141         }
1142         switch (id & WP_IDF_MASK) {
1143         case WP_ID_DECTERMS:
1144             if (size > MAX_TERMS) {
1145                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
1146                 s->terms = 0;
1147                 bytestream2_skip(&gb, ssize);
1148                 continue;
1149             }
1150             s->terms = size;
1151             for (i = 0; i < s->terms; i++) {
1152                 uint8_t val = bytestream2_get_byte(&gb);
1153                 s->decorr[s->terms - i - 1].value = (val & 0x1F) - 5;
1154                 s->decorr[s->terms - i - 1].delta =  val >> 5;
1155             }
1156             got_terms = 1;
1157             break;
1158         case WP_ID_DECWEIGHTS:
1159             if (!got_terms) {
1160                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
1161                 continue;
1162             }
1163             weights = size >> s->stereo_in;
1164             if (weights > MAX_TERMS || weights > s->terms) {
1165                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
1166                 bytestream2_skip(&gb, ssize);
1167                 continue;
1168             }
1169             for (i = 0; i < weights; i++) {
1170                 t = (int8_t)bytestream2_get_byte(&gb);
1171                 s->decorr[s->terms - i - 1].weightA = t * (1 << 3);
1172                 if (s->decorr[s->terms - i - 1].weightA > 0)
1173                     s->decorr[s->terms - i - 1].weightA +=
1174                         (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
1175                 if (s->stereo_in) {
1176                     t = (int8_t)bytestream2_get_byte(&gb);
1177                     s->decorr[s->terms - i - 1].weightB = t * (1 << 3);
1178                     if (s->decorr[s->terms - i - 1].weightB > 0)
1179                         s->decorr[s->terms - i - 1].weightB +=
1180                             (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
1181                 }
1182             }
1183             got_weights = 1;
1184             break;
1185         case WP_ID_DECSAMPLES:
1186             if (!got_terms) {
1187                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
1188                 continue;
1189             }
1190             t = 0;
1191             for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
1192                 if (s->decorr[i].value > 8) {
1193                     s->decorr[i].samplesA[0] =
1194                         wp_exp2(bytestream2_get_le16(&gb));
1195                     s->decorr[i].samplesA[1] =
1196                         wp_exp2(bytestream2_get_le16(&gb));
1197
1198                     if (s->stereo_in) {
1199                         s->decorr[i].samplesB[0] =
1200                             wp_exp2(bytestream2_get_le16(&gb));
1201                         s->decorr[i].samplesB[1] =
1202                             wp_exp2(bytestream2_get_le16(&gb));
1203                         t                       += 4;
1204                     }
1205                     t += 4;
1206                 } else if (s->decorr[i].value < 0) {
1207                     s->decorr[i].samplesA[0] =
1208                         wp_exp2(bytestream2_get_le16(&gb));
1209                     s->decorr[i].samplesB[0] =
1210                         wp_exp2(bytestream2_get_le16(&gb));
1211                     t                       += 4;
1212                 } else {
1213                     for (j = 0; j < s->decorr[i].value; j++) {
1214                         s->decorr[i].samplesA[j] =
1215                             wp_exp2(bytestream2_get_le16(&gb));
1216                         if (s->stereo_in) {
1217                             s->decorr[i].samplesB[j] =
1218                                 wp_exp2(bytestream2_get_le16(&gb));
1219                         }
1220                     }
1221                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
1222                 }
1223             }
1224             got_samples = 1;
1225             break;
1226         case WP_ID_ENTROPY:
1227             if (size != 6 * (s->stereo_in + 1)) {
1228                 av_log(avctx, AV_LOG_ERROR,
1229                        "Entropy vars size should be %i, got %i.\n",
1230                        6 * (s->stereo_in + 1), size);
1231                 bytestream2_skip(&gb, ssize);
1232                 continue;
1233             }
1234             for (j = 0; j <= s->stereo_in; j++)
1235                 for (i = 0; i < 3; i++) {
1236                     s->ch[j].median[i] = wp_exp2(bytestream2_get_le16(&gb));
1237                 }
1238             got_entropy = 1;
1239             break;
1240         case WP_ID_HYBRID:
1241             if (s->hybrid_bitrate) {
1242                 for (i = 0; i <= s->stereo_in; i++) {
1243                     s->ch[i].slow_level = wp_exp2(bytestream2_get_le16(&gb));
1244                     size               -= 2;
1245                 }
1246             }
1247             for (i = 0; i < (s->stereo_in + 1); i++) {
1248                 s->ch[i].bitrate_acc = bytestream2_get_le16(&gb) << 16;
1249                 size                -= 2;
1250             }
1251             if (size > 0) {
1252                 for (i = 0; i < (s->stereo_in + 1); i++) {
1253                     s->ch[i].bitrate_delta =
1254                         wp_exp2((int16_t)bytestream2_get_le16(&gb));
1255                 }
1256             } else {
1257                 for (i = 0; i < (s->stereo_in + 1); i++)
1258                     s->ch[i].bitrate_delta = 0;
1259             }
1260             got_hybrid = 1;
1261             break;
1262         case WP_ID_INT32INFO: {
1263             uint8_t val[4];
1264             if (size != 4) {
1265                 av_log(avctx, AV_LOG_ERROR,
1266                        "Invalid INT32INFO, size = %i\n",
1267                        size);
1268                 bytestream2_skip(&gb, ssize - 4);
1269                 continue;
1270             }
1271             bytestream2_get_buffer(&gb, val, 4);
1272             if (val[0] > 30) {
1273                 av_log(avctx, AV_LOG_ERROR,
1274                        "Invalid INT32INFO, extra_bits = %d (> 30)\n", val[0]);
1275                 continue;
1276             } else if (val[0]) {
1277                 s->extra_bits = val[0];
1278             } else if (val[1]) {
1279                 s->shift = val[1];
1280             } else if (val[2]) {
1281                 s->and   = s->or = 1;
1282                 s->shift = val[2];
1283             } else if (val[3]) {
1284                 s->and   = 1;
1285                 s->shift = val[3];
1286             }
1287             if (s->shift > 31) {
1288                 av_log(avctx, AV_LOG_ERROR,
1289                        "Invalid INT32INFO, shift = %d (> 31)\n", s->shift);
1290                 s->and = s->or = s->shift = 0;
1291                 continue;
1292             }
1293             /* original WavPack decoder forces 32-bit lossy sound to be treated
1294              * as 24-bit one in order to have proper clipping */
1295             if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
1296                 s->post_shift      += 8;
1297                 s->shift           -= 8;
1298                 s->hybrid_maxclip >>= 8;
1299                 s->hybrid_minclip >>= 8;
1300             }
1301             break;
1302         }
1303         case WP_ID_FLOATINFO:
1304             if (size != 4) {
1305                 av_log(avctx, AV_LOG_ERROR,
1306                        "Invalid FLOATINFO, size = %i\n", size);
1307                 bytestream2_skip(&gb, ssize);
1308                 continue;
1309             }
1310             s->float_flag    = bytestream2_get_byte(&gb);
1311             s->float_shift   = bytestream2_get_byte(&gb);
1312             s->float_max_exp = bytestream2_get_byte(&gb);
1313             if (s->float_shift > 31) {
1314                 av_log(avctx, AV_LOG_ERROR,
1315                        "Invalid FLOATINFO, shift = %d (> 31)\n", s->float_shift);
1316                 s->float_shift = 0;
1317                 continue;
1318             }
1319             got_float        = 1;
1320             bytestream2_skip(&gb, 1);
1321             break;
1322         case WP_ID_DATA:
1323             if ((ret = init_get_bits8(&s->gb, gb.buffer, size)) < 0)
1324                 return ret;
1325             bytestream2_skip(&gb, size);
1326             got_pcm      = 1;
1327             break;
1328         case WP_ID_DSD_DATA:
1329             if (size < 2) {
1330                 av_log(avctx, AV_LOG_ERROR, "Invalid DSD_DATA, size = %i\n",
1331                        size);
1332                 bytestream2_skip(&gb, ssize);
1333                 continue;
1334             }
1335             rate_x = 1 << bytestream2_get_byte(&gb);
1336             dsd_mode = bytestream2_get_byte(&gb);
1337             if (dsd_mode && dsd_mode != 1 && dsd_mode != 3) {
1338                 av_log(avctx, AV_LOG_ERROR, "Invalid DSD encoding mode: %d\n",
1339                     dsd_mode);
1340                 return AVERROR_INVALIDDATA;
1341             }
1342             bytestream2_init(&s->gbyte, gb.buffer, size-2);
1343             bytestream2_skip(&gb, size-2);
1344             got_dsd      = 1;
1345             break;
1346         case WP_ID_EXTRABITS:
1347             if (size <= 4) {
1348                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1349                        size);
1350                 bytestream2_skip(&gb, size);
1351                 continue;
1352             }
1353             if ((ret = init_get_bits8(&s->gb_extra_bits, gb.buffer, size)) < 0)
1354                 return ret;
1355             s->crc_extra_bits  = get_bits_long(&s->gb_extra_bits, 32);
1356             bytestream2_skip(&gb, size);
1357             s->got_extra_bits  = 1;
1358             break;
1359         case WP_ID_CHANINFO:
1360             if (size <= 1) {
1361                 av_log(avctx, AV_LOG_ERROR,
1362                        "Insufficient channel information\n");
1363                 return AVERROR_INVALIDDATA;
1364             }
1365             chan = bytestream2_get_byte(&gb);
1366             switch (size - 2) {
1367             case 0:
1368                 chmask = bytestream2_get_byte(&gb);
1369                 break;
1370             case 1:
1371                 chmask = bytestream2_get_le16(&gb);
1372                 break;
1373             case 2:
1374                 chmask = bytestream2_get_le24(&gb);
1375                 break;
1376             case 3:
1377                 chmask = bytestream2_get_le32(&gb);
1378                 break;
1379             case 4:
1380                 size = bytestream2_get_byte(&gb);
1381                 chan  |= (bytestream2_get_byte(&gb) & 0xF) << 8;
1382                 chan  += 1;
1383                 if (avctx->channels != chan)
1384                     av_log(avctx, AV_LOG_WARNING, "%i channels signalled"
1385                            " instead of %i.\n", chan, avctx->channels);
1386                 chmask = bytestream2_get_le24(&gb);
1387                 break;
1388             case 5:
1389                 size = bytestream2_get_byte(&gb);
1390                 chan  |= (bytestream2_get_byte(&gb) & 0xF) << 8;
1391                 chan  += 1;
1392                 if (avctx->channels != chan)
1393                     av_log(avctx, AV_LOG_WARNING, "%i channels signalled"
1394                            " instead of %i.\n", chan, avctx->channels);
1395                 chmask = bytestream2_get_le32(&gb);
1396                 break;
1397             default:
1398                 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1399                        size);
1400                 chan   = avctx->channels;
1401                 chmask = avctx->channel_layout;
1402             }
1403             break;
1404         case WP_ID_SAMPLE_RATE:
1405             if (size != 3) {
1406                 av_log(avctx, AV_LOG_ERROR, "Invalid custom sample rate.\n");
1407                 return AVERROR_INVALIDDATA;
1408             }
1409             sample_rate = bytestream2_get_le24(&gb);
1410             break;
1411         default:
1412             bytestream2_skip(&gb, size);
1413         }
1414         if (id & WP_IDF_ODD)
1415             bytestream2_skip(&gb, 1);
1416     }
1417
1418     if (got_pcm) {
1419         if (!got_terms) {
1420             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1421             return AVERROR_INVALIDDATA;
1422         }
1423         if (!got_weights) {
1424             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1425             return AVERROR_INVALIDDATA;
1426         }
1427         if (!got_samples) {
1428             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1429             return AVERROR_INVALIDDATA;
1430         }
1431         if (!got_entropy) {
1432             av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1433             return AVERROR_INVALIDDATA;
1434         }
1435         if (s->hybrid && !got_hybrid) {
1436             av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1437             return AVERROR_INVALIDDATA;
1438         }
1439         if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLTP) {
1440             av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1441             return AVERROR_INVALIDDATA;
1442         }
1443         if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLTP) {
1444             const int size   = get_bits_left(&s->gb_extra_bits);
1445             const int wanted = s->samples * s->extra_bits << s->stereo_in;
1446             if (size < wanted) {
1447                 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1448                 s->got_extra_bits = 0;
1449             }
1450         }
1451     }
1452
1453     if (!got_pcm && !got_dsd) {
1454         av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1455         return AVERROR_INVALIDDATA;
1456     }
1457
1458     if ((got_pcm && wc->modulation != MODULATION_PCM) ||
1459         (got_dsd && wc->modulation != MODULATION_DSD)) {
1460             av_log(avctx, AV_LOG_ERROR, "Invalid PCM/DSD mix encountered\n");
1461             return AVERROR_INVALIDDATA;
1462     }
1463
1464     if (!wc->ch_offset) {
1465         int sr = (s->frame_flags >> 23) & 0xf;
1466         if (sr == 0xf) {
1467             if (!sample_rate) {
1468                 av_log(avctx, AV_LOG_ERROR, "Custom sample rate missing.\n");
1469                 return AVERROR_INVALIDDATA;
1470             }
1471             avctx->sample_rate = sample_rate * rate_x;
1472         } else
1473             avctx->sample_rate = wv_rates[sr] * rate_x;
1474
1475         if (multiblock) {
1476             if (chan)
1477                 avctx->channels = chan;
1478             if (chmask)
1479                 avctx->channel_layout = chmask;
1480         } else {
1481             avctx->channels       = s->stereo ? 2 : 1;
1482             avctx->channel_layout = s->stereo ? AV_CH_LAYOUT_STEREO :
1483                                                 AV_CH_LAYOUT_MONO;
1484         }
1485
1486         ff_thread_release_buffer(avctx, &wc->prev_frame);
1487         FFSWAP(ThreadFrame, wc->curr_frame, wc->prev_frame);
1488
1489         /* get output buffer */
1490         wc->curr_frame.f->nb_samples = s->samples;
1491         if ((ret = ff_thread_get_buffer(avctx, &wc->curr_frame, AV_GET_BUFFER_FLAG_REF)) < 0)
1492             return ret;
1493
1494         wc->frame = wc->curr_frame.f;
1495         ff_thread_finish_setup(avctx);
1496     }
1497
1498     if (wc->ch_offset + s->stereo >= avctx->channels) {
1499         av_log(avctx, AV_LOG_WARNING, "Too many channels coded in a packet.\n");
1500         return ((avctx->err_recognition & AV_EF_EXPLODE) || !wc->ch_offset) ? AVERROR_INVALIDDATA : 0;
1501     }
1502
1503     samples_l = wc->frame->extended_data[wc->ch_offset];
1504     if (s->stereo)
1505         samples_r = wc->frame->extended_data[wc->ch_offset + 1];
1506
1507     wc->ch_offset += 1 + s->stereo;
1508
1509     if (s->stereo_in) {
1510         if (got_dsd) {
1511             if (dsd_mode == 3) {
1512                 ret = wv_unpack_dsd_high(s, samples_l, samples_r);
1513             } else if (dsd_mode == 1) {
1514                 ret = wv_unpack_dsd_fast(s, samples_l, samples_r);
1515             } else {
1516                 ret = wv_unpack_dsd_copy(s, samples_l, samples_r);
1517             }
1518         } else {
1519             ret = wv_unpack_stereo(s, &s->gb, samples_l, samples_r, avctx->sample_fmt);
1520         }
1521         if (ret < 0)
1522             return ret;
1523     } else {
1524         if (got_dsd) {
1525             if (dsd_mode == 3) {
1526                 ret = wv_unpack_dsd_high(s, samples_l, NULL);
1527             } else if (dsd_mode == 1) {
1528                 ret = wv_unpack_dsd_fast(s, samples_l, NULL);
1529             } else {
1530                 ret = wv_unpack_dsd_copy(s, samples_l, NULL);
1531             }
1532         } else {
1533             ret = wv_unpack_mono(s, &s->gb, samples_l, avctx->sample_fmt);
1534         }
1535         if (ret < 0)
1536             return ret;
1537
1538         if (s->stereo)
1539             memcpy(samples_r, samples_l, bpp * s->samples);
1540     }
1541
1542     return 0;
1543 }
1544
1545 static void wavpack_decode_flush(AVCodecContext *avctx)
1546 {
1547     WavpackContext *s = avctx->priv_data;
1548
1549     if (!avctx->internal->is_copy) {
1550         for (int i = 0; i < avctx->channels; i++)
1551             memset(s->dsdctx[i].buf, 0x69, sizeof(s->dsdctx[i].buf));
1552     }
1553 }
1554
1555 static int dsd_channel(AVCodecContext *avctx, void *frmptr, int jobnr, int threadnr)
1556 {
1557     WavpackContext *s  = avctx->priv_data;
1558     AVFrame *frame = frmptr;
1559
1560     ff_dsd2pcm_translate (&s->dsdctx [jobnr], s->samples, 0,
1561         (uint8_t *)frame->extended_data[jobnr], 4,
1562         (float *)frame->extended_data[jobnr], 1);
1563
1564     return 0;
1565 }
1566
1567 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1568                                 int *got_frame_ptr, AVPacket *avpkt)
1569 {
1570     WavpackContext *s  = avctx->priv_data;
1571     const uint8_t *buf = avpkt->data;
1572     int buf_size       = avpkt->size;
1573     int frame_size, ret, frame_flags;
1574
1575     if (avpkt->size <= WV_HEADER_SIZE)
1576         return AVERROR_INVALIDDATA;
1577
1578     s->frame     = NULL;
1579     s->block     = 0;
1580     s->ch_offset = 0;
1581
1582     /* determine number of samples */
1583     s->samples  = AV_RL32(buf + 20);
1584     frame_flags = AV_RL32(buf + 24);
1585     if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) {
1586         av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1587                s->samples);
1588         return AVERROR_INVALIDDATA;
1589     }
1590
1591     s->modulation = (frame_flags & WV_DSD_DATA) ? MODULATION_DSD : MODULATION_PCM;
1592
1593     if (frame_flags & (WV_FLOAT_DATA | WV_DSD_DATA)) {
1594         avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1595     } else if ((frame_flags & 0x03) <= 1) {
1596         avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
1597     } else {
1598         avctx->sample_fmt          = AV_SAMPLE_FMT_S32P;
1599         avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1600     }
1601
1602     while (buf_size > WV_HEADER_SIZE) {
1603         frame_size = AV_RL32(buf + 4) - 12;
1604         buf       += 20;
1605         buf_size  -= 20;
1606         if (frame_size <= 0 || frame_size > buf_size) {
1607             av_log(avctx, AV_LOG_ERROR,
1608                    "Block %d has invalid size (size %d vs. %d bytes left)\n",
1609                    s->block, frame_size, buf_size);
1610             ret = AVERROR_INVALIDDATA;
1611             goto error;
1612         }
1613         if ((ret = wavpack_decode_block(avctx, s->block, buf, frame_size)) < 0)
1614             goto error;
1615         s->block++;
1616         buf      += frame_size;
1617         buf_size -= frame_size;
1618     }
1619
1620     if (s->ch_offset != avctx->channels) {
1621         av_log(avctx, AV_LOG_ERROR, "Not enough channels coded in a packet.\n");
1622         ret = AVERROR_INVALIDDATA;
1623         goto error;
1624     }
1625
1626     ff_thread_await_progress(&s->prev_frame, INT_MAX, 0);
1627     ff_thread_release_buffer(avctx, &s->prev_frame);
1628
1629     if (s->modulation == MODULATION_DSD)
1630         avctx->execute2(avctx, dsd_channel, s->frame, NULL, avctx->channels);
1631
1632     ff_thread_report_progress(&s->curr_frame, INT_MAX, 0);
1633
1634     if ((ret = av_frame_ref(data, s->frame)) < 0)
1635         return ret;
1636
1637     *got_frame_ptr = 1;
1638
1639     return avpkt->size;
1640
1641 error:
1642     if (s->frame) {
1643         ff_thread_await_progress(&s->prev_frame, INT_MAX, 0);
1644         ff_thread_release_buffer(avctx, &s->prev_frame);
1645         ff_thread_report_progress(&s->curr_frame, INT_MAX, 0);
1646     }
1647
1648     return ret;
1649 }
1650
1651 AVCodec ff_wavpack_decoder = {
1652     .name           = "wavpack",
1653     .long_name      = NULL_IF_CONFIG_SMALL("WavPack"),
1654     .type           = AVMEDIA_TYPE_AUDIO,
1655     .id             = AV_CODEC_ID_WAVPACK,
1656     .priv_data_size = sizeof(WavpackContext),
1657     .init           = wavpack_decode_init,
1658     .close          = wavpack_decode_end,
1659     .decode         = wavpack_decode_frame,
1660     .flush          = wavpack_decode_flush,
1661     .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
1662     .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context),
1663     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
1664                       AV_CODEC_CAP_SLICE_THREADS
1665 };