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

   1 /*
   2  * WavPack lossless audio encoder
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #define BITSTREAM_WRITER_LE
  22
  23 #include "libavutil/intreadwrite.h"
  24 #include "libavutil/opt.h"
  25 #include "avcodec.h"
  26 #include "internal.h"
  27 #include "put_bits.h"
  28 #include "bytestream.h"
  29 #include "wavpackenc.h"
  30 #include "wavpack.h"
  31
  32 #define UPDATE_WEIGHT(weight, delta, source, result) \
  33     if (source && result) { \
  34         int32_t s = (int32_t) (source ^ result) >> 31; \
  35         weight = (delta ^ s) + (weight - s); \
  36     }
  37
  38 #define APPLY_WEIGHT_F(weight, sample) (((((sample & 0xffff) * weight) >> 9) + \
  39     (((sample & ~0xffff) >> 9) * weight) + 1) >> 1)
  40
  41 #define APPLY_WEIGHT_I(weight, sample) ((weight * sample + 512) >> 10)
  42
  43 #define APPLY_WEIGHT(weight, sample) (sample != (short) sample ? \
  44     APPLY_WEIGHT_F(weight, sample) : APPLY_WEIGHT_I (weight, sample))
  45
  46 #define CLEAR(destin) memset(&destin, 0, sizeof(destin));
  47
  48 #define SHIFT_LSB       13
  49 #define SHIFT_MASK      (0x1FU << SHIFT_LSB)
  50
  51 #define MAG_LSB         18
  52 #define MAG_MASK        (0x1FU << MAG_LSB)
  53
  54 #define SRATE_LSB       23
  55 #define SRATE_MASK      (0xFU << SRATE_LSB)
  56
  57 #define EXTRA_TRY_DELTAS     1
  58 #define EXTRA_ADJUST_DELTAS  2
  59 #define EXTRA_SORT_FIRST     4
  60 #define EXTRA_BRANCHES       8
  61 #define EXTRA_SORT_LAST     16
  62
  63 typedef struct WavPackExtraInfo {
  64     struct Decorr dps[MAX_TERMS];
  65     int nterms, log_limit, gt16bit;
  66     uint32_t best_bits;
  67 } WavPackExtraInfo;
  68
  69 typedef struct WavPackWords {
  70     int pend_data, holding_one, zeros_acc;
  71     int holding_zero, pend_count;
  72     WvChannel c[2];
  73 } WavPackWords;
  74
  75 typedef struct WavPackEncodeContext {
  76     AVClass *class;
  77     AVCodecContext *avctx;
  78     PutBitContext pb;
  79     int block_samples;
  80     int buffer_size;
  81     int sample_index;
  82     int stereo, stereo_in;
  83     int ch_offset;
  84
  85     int32_t *samples[2];
  86     int samples_size[2];
  87
  88     int32_t *sampleptrs[MAX_TERMS+2][2];
  89     int sampleptrs_size[MAX_TERMS+2][2];
  90
  91     int32_t *temp_buffer[2][2];
  92     int temp_buffer_size[2][2];
  93
  94     int32_t *best_buffer[2];
  95     int best_buffer_size[2];
  96
  97     int32_t *js_left, *js_right;
  98     int js_left_size, js_right_size;
  99
 100     int32_t *orig_l, *orig_r;
 101     int orig_l_size, orig_r_size;
 102
 103     unsigned extra_flags;
 104     int optimize_mono;
 105     int decorr_filter;
 106     int joint;
 107     int num_branches;
 108
 109     uint32_t flags;
 110     uint32_t crc_x;
 111     WavPackWords w;
 112
 113     uint8_t int32_sent_bits, int32_zeros, int32_ones, int32_dups;
 114     uint8_t float_flags, float_shift, float_max_exp, max_exp;
 115     int32_t shifted_ones, shifted_zeros, shifted_both;
 116     int32_t false_zeros, neg_zeros, ordata;
 117
 118     int num_terms, shift, joint_stereo, false_stereo;
 119     int num_decorrs, num_passes, best_decorr, mask_decorr;
 120     struct Decorr decorr_passes[MAX_TERMS];
 121     const WavPackDecorrSpec *decorr_specs;
 122     float delta_decay;
 123 } WavPackEncodeContext;
 124
 125 static av_cold int wavpack_encode_init(AVCodecContext *avctx)
 126 {
 127     WavPackEncodeContext *s = avctx->priv_data;
 128
 129     s->avctx = avctx;
 130
 131     if (!avctx->frame_size) {
 132         int block_samples;
 133         if (!(avctx->sample_rate & 1))
 134             block_samples = avctx->sample_rate / 2;
 135         else
 136             block_samples = avctx->sample_rate;
 137
 138         while (block_samples * avctx->channels > 150000)
 139             block_samples /= 2;
 140
 141         while (block_samples * avctx->channels < 40000)
 142             block_samples *= 2;
 143         avctx->frame_size = block_samples;
 144     } else if (avctx->frame_size && (avctx->frame_size < 128 ||
 145                               avctx->frame_size > WV_MAX_SAMPLES)) {
 146         av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n", avctx->frame_size);
 147         return AVERROR(EINVAL);
 148     }
 149
 150     if (avctx->compression_level != FF_COMPRESSION_DEFAULT) {
 151         if (avctx->compression_level >= 3) {
 152             s->decorr_filter = 3;
 153             s->num_passes = 9;
 154             if      (avctx->compression_level >= 8) {
 155                 s->num_branches = 4;
 156                 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_SORT_LAST|EXTRA_BRANCHES;
 157             } else if (avctx->compression_level >= 7) {
 158                 s->num_branches = 3;
 159                 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_BRANCHES;
 160             } else if (avctx->compression_level >= 6) {
 161                 s->num_branches = 2;
 162                 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_BRANCHES;
 163             } else if (avctx->compression_level >= 5) {
 164                 s->num_branches = 1;
 165                 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_BRANCHES;
 166             } else if (avctx->compression_level >= 4) {
 167                 s->num_branches = 1;
 168                 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_BRANCHES;
 169             }
 170         } else if (avctx->compression_level == 2) {
 171             s->decorr_filter = 2;
 172             s->num_passes = 4;
 173         } else if (avctx->compression_level == 1) {
 174             s->decorr_filter = 1;
 175             s->num_passes = 2;
 176         } else if (avctx->compression_level < 1) {
 177             s->decorr_filter = 0;
 178             s->num_passes = 0;
 179         }
 180     }
 181
 182     s->num_decorrs = decorr_filter_sizes[s->decorr_filter];
 183     s->decorr_specs = decorr_filters[s->decorr_filter];
 184
 185     s->delta_decay = 2.0;
 186
 187     return 0;
 188 }
 189
 190 static void shift_mono(int32_t *samples, int nb_samples, int shift)
 191 {
 192     int i;
 193     for (i = 0; i < nb_samples; i++)
 194         samples[i] >>= shift;
 195 }
 196
 197 static void shift_stereo(int32_t *left, int32_t *right,
 198                          int nb_samples, int shift)
 199 {
 200     int i;
 201     for (i = 0; i < nb_samples; i++) {
 202         left [i] >>= shift;
 203         right[i] >>= shift;
 204     }
 205 }
 206
 207 #define FLOAT_SHIFT_ONES 1
 208 #define FLOAT_SHIFT_SAME 2
 209 #define FLOAT_SHIFT_SENT 4
 210 #define FLOAT_ZEROS_SENT 8
 211 #define FLOAT_NEG_ZEROS  0x10
 212 #define FLOAT_EXCEPTIONS 0x20
 213
 214 #define get_mantissa(f)     ((f) & 0x7fffff)
 215 #define get_exponent(f)     (((f) >> 23) & 0xff)
 216 #define get_sign(f)         (((f) >> 31) & 0x1)
 217
 218 static void process_float(WavPackEncodeContext *s, int32_t *sample)
 219 {
 220     int32_t shift_count, value, f = *sample;
 221
 222     if (get_exponent(f) == 255) {
 223         s->float_flags |= FLOAT_EXCEPTIONS;
 224         value = 0x1000000;
 225         shift_count = 0;
 226     } else if (get_exponent(f)) {
 227         shift_count = s->max_exp - get_exponent(f);
 228         value = 0x800000 + get_mantissa(f);
 229     } else {
 230         shift_count = s->max_exp ? s->max_exp - 1 : 0;
 231         value = get_mantissa(f);
 232     }
 233
 234     if (shift_count < 25)
 235         value >>= shift_count;
 236     else
 237         value = 0;
 238
 239     if (!value) {
 240         if (get_exponent(f) || get_mantissa(f))
 241             s->false_zeros++;
 242         else if (get_sign(f))
 243             s->neg_zeros++;
 244     } else if (shift_count) {
 245         int32_t mask = (1 << shift_count) - 1;
 246
 247         if (!(get_mantissa(f) & mask))
 248             s->shifted_zeros++;
 249         else if ((get_mantissa(f) & mask) == mask)
 250             s->shifted_ones++;
 251         else
 252             s->shifted_both++;
 253     }
 254
 255     s->ordata |= value;
 256     *sample = get_sign(f) ? -value : value;
 257 }
 258
 259 static int scan_float(WavPackEncodeContext *s,
 260                       int32_t *samples_l, int32_t *samples_r,
 261                       int nb_samples)
 262 {
 263     uint32_t crc = 0xffffffffu;
 264     int i;
 265
 266     s->shifted_ones = s->shifted_zeros = s->shifted_both = s->ordata = 0;
 267     s->float_shift = s->float_flags = 0;
 268     s->false_zeros = s->neg_zeros = 0;
 269     s->max_exp = 0;
 270
 271     if (s->flags & WV_MONO_DATA) {
 272         for (i = 0; i < nb_samples; i++) {
 273             int32_t f = samples_l[i];
 274             crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f);
 275
 276             if (get_exponent(f) > s->max_exp && get_exponent(f) < 255)
 277                 s->max_exp = get_exponent(f);
 278         }
 279     } else {
 280         for (i = 0; i < nb_samples; i++) {
 281             int32_t f;
 282
 283             f = samples_l[i];
 284             crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f);
 285             if (get_exponent(f) > s->max_exp && get_exponent(f) < 255)
 286                 s->max_exp = get_exponent(f);
 287
 288             f = samples_r[i];
 289             crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f);
 290
 291             if (get_exponent(f) > s->max_exp && get_exponent(f) < 255)
 292                 s->max_exp = get_exponent(f);
 293         }
 294     }
 295
 296     s->crc_x = crc;
 297
 298     if (s->flags & WV_MONO_DATA) {
 299         for (i = 0; i < nb_samples; i++)
 300             process_float(s, &samples_l[i]);
 301     } else {
 302         for (i = 0; i < nb_samples; i++) {
 303             process_float(s, &samples_l[i]);
 304             process_float(s, &samples_r[i]);
 305         }
 306     }
 307
 308     s->float_max_exp = s->max_exp;
 309
 310     if (s->shifted_both)
 311         s->float_flags |= FLOAT_SHIFT_SENT;
 312     else if (s->shifted_ones && !s->shifted_zeros)
 313         s->float_flags |= FLOAT_SHIFT_ONES;
 314     else if (s->shifted_ones && s->shifted_zeros)
 315         s->float_flags |= FLOAT_SHIFT_SAME;
 316     else if (s->ordata && !(s->ordata & 1)) {
 317         do {
 318             s->float_shift++;
 319             s->ordata >>= 1;
 320         } while (!(s->ordata & 1));
 321
 322         if (s->flags & WV_MONO_DATA)
 323             shift_mono(samples_l, nb_samples, s->float_shift);
 324         else
 325             shift_stereo(samples_l, samples_r, nb_samples, s->float_shift);
 326     }
 327
 328     s->flags &= ~MAG_MASK;
 329
 330     while (s->ordata) {
 331         s->flags += 1 << MAG_LSB;
 332         s->ordata >>= 1;
 333     }
 334
 335     if (s->false_zeros || s->neg_zeros)
 336         s->float_flags |= FLOAT_ZEROS_SENT;
 337
 338     if (s->neg_zeros)
 339         s->float_flags |= FLOAT_NEG_ZEROS;
 340
 341     return s->float_flags & (FLOAT_EXCEPTIONS | FLOAT_ZEROS_SENT |
 342                              FLOAT_SHIFT_SENT | FLOAT_SHIFT_SAME);
 343 }
 344
 345 static void scan_int23(WavPackEncodeContext *s,
 346                        int32_t *samples_l, int32_t *samples_r,
 347                        int nb_samples)
 348 {
 349     uint32_t magdata = 0, ordata = 0, xordata = 0, anddata = ~0;
 350     int i, total_shift = 0;
 351
 352     s->int32_sent_bits = s->int32_zeros = s->int32_ones = s->int32_dups = 0;
 353
 354     if (s->flags & WV_MONO_DATA) {
 355         for (i = 0; i < nb_samples; i++) {
 356             int32_t M = samples_l[i];
 357
 358             magdata |= (M < 0) ? ~M : M;
 359             xordata |= M ^ -(M & 1);
 360             anddata &= M;
 361             ordata  |= M;
 362
 363             if ((ordata & 1) && !(anddata & 1) && (xordata & 2))
 364                 return;
 365         }
 366     } else {
 367         for (i = 0; i < nb_samples; i++) {
 368             int32_t L = samples_l[i];
 369             int32_t R = samples_r[i];
 370
 371             magdata |= (L < 0) ? ~L : L;
 372             magdata |= (R < 0) ? ~R : R;
 373             xordata |= L ^ -(L & 1);
 374             xordata |= R ^ -(R & 1);
 375             anddata &= L & R;
 376             ordata  |= L | R;
 377
 378             if ((ordata & 1) && !(anddata & 1) && (xordata & 2))
 379                 return;
 380         }
 381     }
 382
 383     s->flags &= ~MAG_MASK;
 384
 385     while (magdata) {
 386         s->flags += 1 << MAG_LSB;
 387         magdata >>= 1;
 388     }
 389
 390     if (!(s->flags & MAG_MASK))
 391         return;
 392
 393     if (!(ordata & 1)) {
 394         do {
 395             s->flags -= 1 << MAG_LSB;
 396             s->int32_zeros++;
 397             total_shift++;
 398             ordata >>= 1;
 399         } while (!(ordata & 1));
 400     } else if (anddata & 1) {
 401         do {
 402             s->flags -= 1 << MAG_LSB;
 403             s->int32_ones++;
 404             total_shift++;
 405             anddata >>= 1;
 406         } while (anddata & 1);
 407     } else if (!(xordata & 2)) {
 408         do {
 409             s->flags -= 1 << MAG_LSB;
 410             s->int32_dups++;
 411             total_shift++;
 412             xordata >>= 1;
 413         } while (!(xordata & 2));
 414     }
 415
 416     if (total_shift) {
 417         s->flags |= WV_INT32_DATA;
 418
 419         if (s->flags & WV_MONO_DATA)
 420             shift_mono(samples_l, nb_samples, total_shift);
 421         else
 422             shift_stereo(samples_l, samples_r, nb_samples, total_shift);
 423     }
 424 }
 425
 426 static int scan_int32(WavPackEncodeContext *s,
 427                       int32_t *samples_l, int32_t *samples_r,
 428                       int nb_samples)
 429 {
 430     uint32_t magdata = 0, ordata = 0, xordata = 0, anddata = ~0;
 431     uint32_t crc = 0xffffffffu;
 432     int i, total_shift = 0;
 433
 434     s->int32_sent_bits = s->int32_zeros = s->int32_ones = s->int32_dups = 0;
 435
 436     if (s->flags & WV_MONO_DATA) {
 437         for (i = 0; i < nb_samples; i++) {
 438             int32_t M = samples_l[i];
 439
 440             crc = crc * 9 + (M & 0xffff) * 3 + ((M >> 16) & 0xffff);
 441             magdata |= (M < 0) ? ~M : M;
 442             xordata |= M ^ -(M & 1);
 443             anddata &= M;
 444             ordata  |= M;
 445         }
 446     } else {
 447         for (i = 0; i < nb_samples; i++) {
 448             int32_t L = samples_l[i];
 449             int32_t R = samples_r[i];
 450
 451             crc = crc * 9 + (L & 0xffff) * 3 + ((L >> 16) & 0xffff);
 452             crc = crc * 9 + (R & 0xffff) * 3 + ((R >> 16) & 0xffff);
 453             magdata |= (L < 0) ? ~L : L;
 454             magdata |= (R < 0) ? ~R : R;
 455             xordata |= L ^ -(L & 1);
 456             xordata |= R ^ -(R & 1);
 457             anddata &= L & R;
 458             ordata  |= L | R;
 459         }
 460     }
 461
 462     s->crc_x = crc;
 463     s->flags &= ~MAG_MASK;
 464
 465     while (magdata) {
 466         s->flags += 1 << MAG_LSB;
 467         magdata >>= 1;
 468     }
 469
 470     if (!((s->flags & MAG_MASK) >> MAG_LSB)) {
 471         s->flags &= ~WV_INT32_DATA;
 472         return 0;
 473     }
 474
 475     if (!(ordata & 1))
 476         do {
 477             s->flags -= 1 << MAG_LSB;
 478             s->int32_zeros++;
 479             total_shift++;
 480             ordata >>= 1;
 481         } while (!(ordata & 1));
 482     else if (anddata & 1)
 483         do {
 484             s->flags -= 1 << MAG_LSB;
 485             s->int32_ones++;
 486             total_shift++;
 487             anddata >>= 1;
 488         } while (anddata & 1);
 489     else if (!(xordata & 2))
 490         do {
 491             s->flags -= 1 << MAG_LSB;
 492             s->int32_dups++;
 493             total_shift++;
 494             xordata >>= 1;
 495         } while (!(xordata & 2));
 496
 497     if (((s->flags & MAG_MASK) >> MAG_LSB) > 23) {
 498         s->int32_sent_bits = (uint8_t)(((s->flags & MAG_MASK) >> MAG_LSB) - 23);
 499         total_shift += s->int32_sent_bits;
 500         s->flags &= ~MAG_MASK;
 501         s->flags += 23 << MAG_LSB;
 502     }
 503
 504     if (total_shift) {
 505         s->flags |= WV_INT32_DATA;
 506
 507         if (s->flags & WV_MONO_DATA)
 508             shift_mono(samples_l, nb_samples, total_shift);
 509         else
 510             shift_stereo(samples_l, samples_r, nb_samples, total_shift);
 511     }
 512
 513     return s->int32_sent_bits;
 514 }
 515
 516 static int8_t store_weight(int weight)
 517 {
 518     weight = av_clip(weight, -1024, 1024);
 519     if (weight > 0)
 520         weight -= (weight + 64) >> 7;
 521
 522     return (weight + 4) >> 3;
 523 }
 524
 525 static int restore_weight(int8_t weight)
 526 {
 527     int result;
 528
 529     if ((result = (int) weight << 3) > 0)
 530         result += (result + 64) >> 7;
 531
 532     return result;
 533 }
 534
 535 static int log2s(int32_t value)
 536 {
 537     return (value < 0) ? -wp_log2(-value) : wp_log2(value);
 538 }
 539
 540 static void decorr_mono(int32_t *in_samples, int32_t *out_samples,
 541                         int nb_samples, struct Decorr *dpp, int dir)
 542 {
 543     int m = 0, i;
 544
 545     dpp->sumA = 0;
 546
 547     if (dir < 0) {
 548         out_samples += (nb_samples - 1);
 549         in_samples  += (nb_samples - 1);
 550     }
 551
 552     dpp->weightA = restore_weight(store_weight(dpp->weightA));
 553
 554     for (i = 0; i < MAX_TERM; i++)
 555         dpp->samplesA[i] = wp_exp2(log2s(dpp->samplesA[i]));
 556
 557     if (dpp->value > MAX_TERM) {
 558         while (nb_samples--) {
 559             int32_t left, sam_A;
 560
 561             sam_A = ((3 - (dpp->value & 1)) * dpp->samplesA[0] - dpp->samplesA[1]) >> !(dpp->value & 1);
 562
 563             dpp->samplesA[1] = dpp->samplesA[0];
 564             dpp->samplesA[0] = left = in_samples[0];
 565
 566             left -= APPLY_WEIGHT(dpp->weightA, sam_A);
 567             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam_A, left);
 568             dpp->sumA += dpp->weightA;
 569             out_samples[0] = left;
 570             in_samples += dir;
 571             out_samples += dir;
 572         }
 573     } else if (dpp->value > 0) {
 574         while (nb_samples--) {
 575             int k = (m + dpp->value) & (MAX_TERM - 1);
 576             int32_t left, sam_A;
 577
 578             sam_A = dpp->samplesA[m];
 579             dpp->samplesA[k] = left = in_samples[0];
 580             m = (m + 1) & (MAX_TERM - 1);
 581
 582             left -= APPLY_WEIGHT(dpp->weightA, sam_A);
 583             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam_A, left);
 584             dpp->sumA += dpp->weightA;
 585             out_samples[0] = left;
 586             in_samples += dir;
 587             out_samples += dir;
 588         }
 589     }
 590
 591     if (m && dpp->value > 0 && dpp->value <= MAX_TERM) {
 592         int32_t temp_A[MAX_TERM];
 593
 594         memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA));
 595
 596         for (i = 0; i < MAX_TERM; i++) {
 597             dpp->samplesA[i] = temp_A[m];
 598             m = (m + 1) & (MAX_TERM - 1);
 599         }
 600     }
 601 }
 602
 603 static void reverse_mono_decorr(struct Decorr *dpp)
 604 {
 605     if (dpp->value > MAX_TERM) {
 606         int32_t sam_A;
 607
 608         if (dpp->value & 1)
 609             sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1];
 610         else
 611             sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1;
 612
 613         dpp->samplesA[1] = dpp->samplesA[0];
 614         dpp->samplesA[0] = sam_A;
 615
 616         if (dpp->value & 1)
 617             sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1];
 618         else
 619             sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1;
 620
 621         dpp->samplesA[1] = sam_A;
 622     } else if (dpp->value > 1) {
 623         int i, j, k;
 624
 625         for (i = 0, j = dpp->value - 1, k = 0; k < dpp->value / 2; i++, j--, k++) {
 626             i &= (MAX_TERM - 1);
 627             j &= (MAX_TERM - 1);
 628             dpp->samplesA[i] ^= dpp->samplesA[j];
 629             dpp->samplesA[j] ^= dpp->samplesA[i];
 630             dpp->samplesA[i] ^= dpp->samplesA[j];
 631         }
 632     }
 633 }
 634
 635 static uint32_t log2sample(uint32_t v, int limit, uint32_t *result)
 636 {
 637     uint32_t dbits;
 638
 639     if ((v += v >> 9) < (1 << 8)) {
 640         dbits = nbits_table[v];
 641         result += (dbits << 8) + wp_log2_table[(v << (9 - dbits)) & 0xff];
 642     } else {
 643         if (v < (1L << 16))
 644             dbits = nbits_table[v >> 8] + 8;
 645         else if (v < (1L << 24))
 646             dbits = nbits_table[v >> 16] + 16;
 647         else
 648             dbits = nbits_table[v >> 24] + 24;
 649
 650         result += dbits = (dbits << 8) + wp_log2_table[(v >> (dbits - 9)) & 0xff];
 651
 652         if (limit && dbits >= limit)
 653             return 1;
 654     }
 655
 656     return 0;
 657 }
 658
 659 static uint32_t log2mono(int32_t *samples, int nb_samples, int limit)
 660 {
 661     uint32_t result = 0;
 662     while (nb_samples--) {
 663         if (log2sample(abs(*samples++), limit, &result))
 664             return UINT32_MAX;
 665     }
 666     return result;
 667 }
 668
 669 static uint32_t log2stereo(int32_t *samples_l, int32_t *samples_r,
 670                            int nb_samples, int limit)
 671 {
 672     uint32_t result = 0;
 673     while (nb_samples--) {
 674         if (log2sample(abs(*samples_l++), limit, &result) ||
 675             log2sample(abs(*samples_r++), limit, &result))
 676             return UINT32_MAX;
 677     }
 678     return result;
 679 }
 680
 681 static void decorr_mono_buffer(int32_t *samples, int32_t *outsamples,
 682                                int nb_samples, struct Decorr *dpp,
 683                                int tindex)
 684 {
 685     struct Decorr dp, *dppi = dpp + tindex;
 686     int delta = dppi->delta, pre_delta, term = dppi->value;
 687
 688     if (delta == 7)
 689         pre_delta = 7;
 690     else if (delta < 2)
 691         pre_delta = 3;
 692     else
 693         pre_delta = delta + 1;
 694
 695     CLEAR(dp);
 696     dp.value = term;
 697     dp.delta = pre_delta;
 698     decorr_mono(samples, outsamples, FFMIN(2048, nb_samples), &dp, -1);
 699     dp.delta = delta;
 700
 701     if (tindex == 0)
 702         reverse_mono_decorr(&dp);
 703     else
 704         CLEAR(dp.samplesA);
 705
 706     memcpy(dppi->samplesA, dp.samplesA, sizeof(dp.samplesA));
 707     dppi->weightA = dp.weightA;
 708
 709     if (delta == 0) {
 710         dp.delta = 1;
 711         decorr_mono(samples, outsamples, nb_samples, &dp, 1);
 712         dp.delta = 0;
 713         memcpy(dp.samplesA, dppi->samplesA, sizeof(dp.samplesA));
 714         dppi->weightA = dp.weightA = dp.sumA / nb_samples;
 715     }
 716
 717     decorr_mono(samples, outsamples, nb_samples, &dp, 1);
 718 }
 719
 720 static void recurse_mono(WavPackEncodeContext *s, WavPackExtraInfo *info,
 721                          int depth, int delta, uint32_t input_bits)
 722 {
 723     int term, branches = s->num_branches - depth;
 724     int32_t *samples, *outsamples;
 725     uint32_t term_bits[22], bits;
 726
 727     if (branches < 1 || depth + 1 == info->nterms)
 728         branches = 1;
 729
 730     CLEAR(term_bits);
 731     samples = s->sampleptrs[depth][0];
 732     outsamples = s->sampleptrs[depth + 1][0];
 733
 734     for (term = 1; term <= 18; term++) {
 735         if (term == 17 && branches == 1 && depth + 1 < info->nterms)
 736             continue;
 737
 738         if (term > 8 && term < 17)
 739             continue;
 740
 741         if (!s->extra_flags && (term > 4 && term < 17))
 742             continue;
 743
 744         info->dps[depth].value = term;
 745         info->dps[depth].delta = delta;
 746         decorr_mono_buffer(samples, outsamples, s->block_samples, info->dps, depth);
 747         bits = log2mono(outsamples, s->block_samples, info->log_limit);
 748
 749         if (bits < info->best_bits) {
 750             info->best_bits = bits;
 751             CLEAR(s->decorr_passes);
 752             memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * (depth + 1));
 753             memcpy(s->sampleptrs[info->nterms + 1][0],
 754                    s->sampleptrs[depth + 1][0], s->block_samples * 4);
 755         }
 756
 757         term_bits[term + 3] = bits;
 758     }
 759
 760     while (depth + 1 < info->nterms && branches--) {
 761         uint32_t local_best_bits = input_bits;
 762         int best_term = 0, i;
 763
 764         for (i = 0; i < 22; i++)
 765             if (term_bits[i] && term_bits[i] < local_best_bits) {
 766                 local_best_bits = term_bits[i];
 767                 best_term = i - 3;
 768             }
 769
 770         if (!best_term)
 771             break;
 772
 773         term_bits[best_term + 3] = 0;
 774
 775         info->dps[depth].value = best_term;
 776         info->dps[depth].delta = delta;
 777         decorr_mono_buffer(samples, outsamples, s->block_samples, info->dps, depth);
 778
 779         recurse_mono(s, info, depth + 1, delta, local_best_bits);
 780     }
 781 }
 782
 783 static void sort_mono(WavPackEncodeContext *s, WavPackExtraInfo *info)
 784 {
 785     int reversed = 1;
 786     uint32_t bits;
 787
 788     while (reversed) {
 789         int ri, i;
 790
 791         memcpy(info->dps, s->decorr_passes, sizeof(s->decorr_passes));
 792         reversed = 0;
 793
 794         for (ri = 0; ri < info->nterms && s->decorr_passes[ri].value; ri++) {
 795
 796             if (ri + 1 >= info->nterms || !s->decorr_passes[ri+1].value)
 797                 break;
 798
 799             if (s->decorr_passes[ri].value == s->decorr_passes[ri+1].value) {
 800                 decorr_mono_buffer(s->sampleptrs[ri][0], s->sampleptrs[ri+1][0],
 801                                    s->block_samples, info->dps, ri);
 802                 continue;
 803             }
 804
 805             info->dps[ri  ] = s->decorr_passes[ri+1];
 806             info->dps[ri+1] = s->decorr_passes[ri  ];
 807
 808             for (i = ri; i < info->nterms && s->decorr_passes[i].value; i++)
 809                 decorr_mono_buffer(s->sampleptrs[i][0], s->sampleptrs[i+1][0],
 810                                    s->block_samples, info->dps, i);
 811
 812             bits = log2mono(s->sampleptrs[i][0], s->block_samples, info->log_limit);
 813             if (bits < info->best_bits) {
 814                 reversed = 1;
 815                 info->best_bits = bits;
 816                 CLEAR(s->decorr_passes);
 817                 memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i);
 818                 memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[i][0],
 819                        s->block_samples * 4);
 820             } else {
 821                 info->dps[ri  ] = s->decorr_passes[ri];
 822                 info->dps[ri+1] = s->decorr_passes[ri+1];
 823                 decorr_mono_buffer(s->sampleptrs[ri][0], s->sampleptrs[ri+1][0],
 824                                    s->block_samples, info->dps, ri);
 825             }
 826         }
 827     }
 828 }
 829
 830 static void delta_mono(WavPackEncodeContext *s, WavPackExtraInfo *info)
 831 {
 832     int lower = 0, delta, d;
 833     uint32_t bits;
 834
 835     if (!s->decorr_passes[0].value)
 836         return;
 837     delta = s->decorr_passes[0].delta;
 838
 839     for (d = delta - 1; d >= 0; d--) {
 840         int i;
 841
 842         for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) {
 843             info->dps[i].value = s->decorr_passes[i].value;
 844             info->dps[i].delta = d;
 845             decorr_mono_buffer(s->sampleptrs[i][0], s->sampleptrs[i+1][0],
 846                                s->block_samples, info->dps, i);
 847         }
 848
 849         bits = log2mono(s->sampleptrs[i][0], s->block_samples, info->log_limit);
 850         if (bits >= info->best_bits)
 851             break;
 852
 853         lower = 1;
 854         info->best_bits = bits;
 855         CLEAR(s->decorr_passes);
 856         memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i);
 857         memcpy(s->sampleptrs[info->nterms + 1][0],  s->sampleptrs[i][0],
 858                s->block_samples * 4);
 859     }
 860
 861     for (d = delta + 1; !lower && d <= 7; d++) {
 862         int i;
 863
 864         for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) {
 865             info->dps[i].value = s->decorr_passes[i].value;
 866             info->dps[i].delta = d;
 867             decorr_mono_buffer(s->sampleptrs[i][0], s->sampleptrs[i+1][0],
 868                                s->block_samples, info->dps, i);
 869         }
 870
 871         bits = log2mono(s->sampleptrs[i][0], s->block_samples, info->log_limit);
 872         if (bits >= info->best_bits)
 873             break;
 874
 875         info->best_bits = bits;
 876         CLEAR(s->decorr_passes);
 877         memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i);
 878         memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[i][0],
 879                s->block_samples * 4);
 880     }
 881 }
 882
 883 static int allocate_buffers2(WavPackEncodeContext *s, int nterms)
 884 {
 885     int i;
 886
 887     for (i = 0; i < nterms + 2; i++) {
 888         av_fast_padded_malloc(&s->sampleptrs[i][0], &s->sampleptrs_size[i][0],
 889                               s->block_samples * 4);
 890         if (!s->sampleptrs[i][0])
 891             return AVERROR(ENOMEM);
 892         if (!(s->flags & WV_MONO_DATA)) {
 893             av_fast_padded_malloc(&s->sampleptrs[i][1], &s->sampleptrs_size[i][1],
 894                                   s->block_samples * 4);
 895             if (!s->sampleptrs[i][1])
 896                 return AVERROR(ENOMEM);
 897         }
 898     }
 899
 900     return 0;
 901 }
 902
 903 static int allocate_buffers(WavPackEncodeContext *s)
 904 {
 905     int i;
 906
 907     for (i = 0; i < 2; i++) {
 908         av_fast_padded_malloc(&s->best_buffer[0], &s->best_buffer_size[0],
 909                               s->block_samples * 4);
 910         if (!s->best_buffer[0])
 911             return AVERROR(ENOMEM);
 912
 913         av_fast_padded_malloc(&s->temp_buffer[i][0], &s->temp_buffer_size[i][0],
 914                               s->block_samples * 4);
 915         if (!s->temp_buffer[i][0])
 916             return AVERROR(ENOMEM);
 917         if (!(s->flags & WV_MONO_DATA)) {
 918             av_fast_padded_malloc(&s->best_buffer[1], &s->best_buffer_size[1],
 919                                   s->block_samples * 4);
 920             if (!s->best_buffer[1])
 921                 return AVERROR(ENOMEM);
 922
 923             av_fast_padded_malloc(&s->temp_buffer[i][1], &s->temp_buffer_size[i][1],
 924                                   s->block_samples * 4);
 925             if (!s->temp_buffer[i][1])
 926                 return AVERROR(ENOMEM);
 927         }
 928     }
 929
 930     return 0;
 931 }
 932
 933 static void analyze_mono(WavPackEncodeContext *s, int32_t *samples, int do_samples)
 934 {
 935     WavPackExtraInfo info;
 936     int i;
 937
 938     info.log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256;
 939     info.log_limit = FFMIN(6912, info.log_limit);
 940
 941     info.nterms = s->num_terms;
 942
 943     if (allocate_buffers2(s, s->num_terms))
 944         return;
 945
 946     memcpy(info.dps, s->decorr_passes, sizeof(info.dps));
 947     memcpy(s->sampleptrs[0][0], samples, s->block_samples * 4);
 948
 949     for (i = 0; i < info.nterms && info.dps[i].value; i++)
 950         decorr_mono(s->sampleptrs[i][0], s->sampleptrs[i + 1][0],
 951                     s->block_samples, info.dps + i, 1);
 952
 953     info.best_bits = log2mono(s->sampleptrs[info.nterms][0], s->block_samples, 0) * 1;
 954     memcpy(s->sampleptrs[info.nterms + 1][0], s->sampleptrs[i][0], s->block_samples * 4);
 955
 956     if (s->extra_flags & EXTRA_BRANCHES)
 957         recurse_mono(s, &info, 0, (int) floor(s->delta_decay + 0.5),
 958                      log2mono(s->sampleptrs[0][0], s->block_samples, 0));
 959
 960     if (s->extra_flags & EXTRA_SORT_FIRST)
 961         sort_mono(s, &info);
 962
 963     if (s->extra_flags & EXTRA_TRY_DELTAS) {
 964         delta_mono(s, &info);
 965
 966         if ((s->extra_flags & EXTRA_ADJUST_DELTAS) && s->decorr_passes[0].value)
 967             s->delta_decay = (float)((s->delta_decay * 2.0 + s->decorr_passes[0].delta) / 3.0);
 968         else
 969             s->delta_decay = 2.0;
 970     }
 971
 972     if (s->extra_flags & EXTRA_SORT_LAST)
 973         sort_mono(s, &info);
 974
 975     if (do_samples)
 976         memcpy(samples, s->sampleptrs[info.nterms + 1][0], s->block_samples * 4);
 977
 978     for (i = 0; i < info.nterms; i++)
 979         if (!s->decorr_passes[i].value)
 980             break;
 981
 982     s->num_terms = i;
 983 }
 984
 985 static void scan_word(WavPackEncodeContext *s, WvChannel *c,
 986                       int32_t *samples, int nb_samples, int dir)
 987 {
 988     if (dir < 0)
 989         samples += nb_samples - 1;
 990
 991     while (nb_samples--) {
 992         uint32_t low, value = labs(samples[0]);
 993
 994         if (value < GET_MED(0)) {
 995             DEC_MED(0);
 996         } else {
 997             low = GET_MED(0);
 998             INC_MED(0);
 999
1000             if (value - low < GET_MED(1)) {
1001                 DEC_MED(1);
1002             } else {
1003                 low += GET_MED(1);
1004                 INC_MED(1);
1005
1006                 if (value - low < GET_MED(2)) {
1007                     DEC_MED(2);
1008                 } else {
1009                     INC_MED(2);
1010                 }
1011             }
1012         }
1013         samples += dir;
1014     }
1015 }
1016
1017 static int wv_mono(WavPackEncodeContext *s, int32_t *samples,
1018                    int no_history, int do_samples)
1019 {
1020     struct Decorr temp_decorr_pass, save_decorr_passes[MAX_TERMS] = {{0}};
1021     int nb_samples = s->block_samples;
1022     int buf_size = sizeof(int32_t) * nb_samples;
1023     uint32_t best_size = UINT32_MAX, size;
1024     int log_limit, pi, i, ret;
1025
1026     for (i = 0; i < nb_samples; i++)
1027         if (samples[i])
1028             break;
1029
1030     if (i == nb_samples) {
1031         CLEAR(s->decorr_passes);
1032         CLEAR(s->w);
1033         s->num_terms = 0;
1034         return 0;
1035     }
1036
1037     log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256;
1038     log_limit = FFMIN(6912, log_limit);
1039
1040     if ((ret = allocate_buffers(s)) < 0)
1041         return ret;
1042
1043     if (no_history || s->num_passes >= 7)
1044         s->best_decorr = s->mask_decorr = 0;
1045
1046     for (pi = 0; pi < s->num_passes;) {
1047         const WavPackDecorrSpec *wpds;
1048         int nterms, c, j;
1049
1050         if (!pi) {
1051             c = s->best_decorr;
1052         } else {
1053             if (s->mask_decorr == 0)
1054                 c = 0;
1055             else
1056                 c = (s->best_decorr & (s->mask_decorr - 1)) | s->mask_decorr;
1057
1058             if (c == s->best_decorr) {
1059                 s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1;
1060                 continue;
1061             }
1062         }
1063
1064         wpds = &s->decorr_specs[c];
1065         nterms = decorr_filter_nterms[s->decorr_filter];
1066
1067         while (1) {
1068         memcpy(s->temp_buffer[0][0], samples, buf_size);
1069         CLEAR(save_decorr_passes);
1070
1071         for (j = 0; j < nterms; j++) {
1072             CLEAR(temp_decorr_pass);
1073             temp_decorr_pass.delta = wpds->delta;
1074             temp_decorr_pass.value = wpds->terms[j];
1075
1076             if (temp_decorr_pass.value < 0)
1077                 temp_decorr_pass.value = 1;
1078
1079             decorr_mono(s->temp_buffer[j&1][0], s->temp_buffer[~j&1][0],
1080                         FFMIN(nb_samples, 2048), &temp_decorr_pass, -1);
1081
1082             if (j) {
1083                 CLEAR(temp_decorr_pass.samplesA);
1084             } else {
1085                 reverse_mono_decorr(&temp_decorr_pass);
1086             }
1087
1088             memcpy(save_decorr_passes + j, &temp_decorr_pass, sizeof(struct Decorr));
1089             decorr_mono(s->temp_buffer[j&1][0], s->temp_buffer[~j&1][0],
1090                         nb_samples, &temp_decorr_pass, 1);
1091         }
1092
1093         size = log2mono(s->temp_buffer[j&1][0], nb_samples, log_limit);
1094         if (size != UINT32_MAX || !nterms)
1095             break;
1096         nterms >>= 1;
1097         }
1098
1099         if (size < best_size) {
1100             memcpy(s->best_buffer[0], s->temp_buffer[j&1][0], buf_size);
1101             memcpy(s->decorr_passes, save_decorr_passes, sizeof(struct Decorr) * MAX_TERMS);
1102             s->num_terms = nterms;
1103             s->best_decorr = c;
1104             best_size = size;
1105         }
1106
1107         if (pi++)
1108             s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1;
1109     }
1110
1111     if (s->extra_flags)
1112         analyze_mono(s, samples, do_samples);
1113     else if (do_samples)
1114         memcpy(samples, s->best_buffer[0], buf_size);
1115
1116     if (no_history || s->extra_flags) {
1117         CLEAR(s->w);
1118         scan_word(s, &s->w.c[0], s->best_buffer[0], nb_samples, -1);
1119     }
1120     return 0;
1121 }
1122
1123 static void decorr_stereo(int32_t *in_left, int32_t *in_right,
1124                           int32_t *out_left, int32_t *out_right,
1125                           int nb_samples, struct Decorr *dpp, int dir)
1126 {
1127     int m = 0, i;
1128
1129     dpp->sumA = dpp->sumB = 0;
1130
1131     if (dir < 0) {
1132         out_left  += nb_samples - 1;
1133         out_right += nb_samples - 1;
1134         in_left   += nb_samples - 1;
1135         in_right  += nb_samples - 1;
1136     }
1137
1138     dpp->weightA = restore_weight(store_weight(dpp->weightA));
1139     dpp->weightB = restore_weight(store_weight(dpp->weightB));
1140
1141     for (i = 0; i < MAX_TERM; i++) {
1142         dpp->samplesA[i] = wp_exp2(log2s(dpp->samplesA[i]));
1143         dpp->samplesB[i] = wp_exp2(log2s(dpp->samplesB[i]));
1144     }
1145
1146     switch (dpp->value) {
1147     case 2:
1148         while (nb_samples--) {
1149             int32_t sam, tmp;
1150
1151             sam = dpp->samplesA[0];
1152             dpp->samplesA[0] = dpp->samplesA[1];
1153             out_left[0] = tmp = (dpp->samplesA[1] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam);
1154             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
1155             dpp->sumA += dpp->weightA;
1156
1157             sam = dpp->samplesB[0];
1158             dpp->samplesB[0] = dpp->samplesB[1];
1159             out_right[0] = tmp = (dpp->samplesB[1] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam);
1160             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
1161             dpp->sumB += dpp->weightB;
1162
1163             in_left   += dir;
1164             out_left  += dir;
1165             in_right  += dir;
1166             out_right += dir;
1167         }
1168         break;
1169     case 17:
1170         while (nb_samples--) {
1171             int32_t sam, tmp;
1172
1173             sam = 2 * dpp->samplesA[0] - dpp->samplesA[1];
1174             dpp->samplesA[1] = dpp->samplesA[0];
1175             out_left[0] = tmp = (dpp->samplesA[0] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam);
1176             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
1177             dpp->sumA += dpp->weightA;
1178
1179             sam = 2 * dpp->samplesB[0] - dpp->samplesB[1];
1180             dpp->samplesB[1] = dpp->samplesB[0];
1181             out_right[0] = tmp = (dpp->samplesB[0] = in_right[0]) - APPLY_WEIGHT (dpp->weightB, sam);
1182             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
1183             dpp->sumB += dpp->weightB;
1184
1185             in_left   += dir;
1186             out_left  += dir;
1187             in_right  += dir;
1188             out_right += dir;
1189         }
1190         break;
1191     case 18:
1192         while (nb_samples--) {
1193             int32_t sam, tmp;
1194
1195             sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1);
1196             dpp->samplesA[1] = dpp->samplesA[0];
1197             out_left[0] = tmp = (dpp->samplesA[0] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam);
1198             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
1199             dpp->sumA += dpp->weightA;
1200
1201             sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1);
1202             dpp->samplesB[1] = dpp->samplesB[0];
1203             out_right[0] = tmp = (dpp->samplesB[0] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam);
1204             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
1205             dpp->sumB += dpp->weightB;
1206
1207             in_left   += dir;
1208             out_left  += dir;
1209             in_right  += dir;
1210             out_right += dir;
1211         }
1212         break;
1213     default: {
1214         int k = dpp->value & (MAX_TERM - 1);
1215
1216         while (nb_samples--) {
1217             int32_t sam, tmp;
1218
1219             sam = dpp->samplesA[m];
1220             out_left[0] = tmp = (dpp->samplesA[k] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam);
1221             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
1222             dpp->sumA += dpp->weightA;
1223
1224             sam = dpp->samplesB[m];
1225             out_right[0] = tmp = (dpp->samplesB[k] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam);
1226             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
1227             dpp->sumB += dpp->weightB;
1228
1229             in_left   += dir;
1230             out_left  += dir;
1231             in_right  += dir;
1232             out_right += dir;
1233             m = (m + 1) & (MAX_TERM - 1);
1234             k = (k + 1) & (MAX_TERM - 1);
1235         }
1236
1237         if (m) {
1238             int32_t temp_A[MAX_TERM], temp_B[MAX_TERM];
1239             int k;
1240
1241             memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA));
1242             memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB));
1243
1244             for (k = 0; k < MAX_TERM; k++) {
1245                 dpp->samplesA[k] = temp_A[m];
1246                 dpp->samplesB[k] = temp_B[m];
1247                 m = (m + 1) & (MAX_TERM - 1);
1248             }
1249         }
1250         break;
1251         }
1252     case -1:
1253         while (nb_samples--) {
1254             int32_t sam_A, sam_B, tmp;
1255
1256             sam_A = dpp->samplesA[0];
1257             out_left[0] = tmp = (sam_B = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam_A);
1258             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
1259             dpp->sumA += dpp->weightA;
1260
1261             out_right[0] = tmp = (dpp->samplesA[0] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam_B);
1262             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
1263             dpp->sumB += dpp->weightB;
1264
1265             in_left   += dir;
1266             out_left  += dir;
1267             in_right  += dir;
1268             out_right += dir;
1269         }
1270         break;
1271     case -2:
1272         while (nb_samples--) {
1273             int32_t sam_A, sam_B, tmp;
1274
1275             sam_B = dpp->samplesB[0];
1276             out_right[0] = tmp = (sam_A = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam_B);
1277             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
1278             dpp->sumB += dpp->weightB;
1279
1280             out_left[0] = tmp = (dpp->samplesB[0] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam_A);
1281             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
1282             dpp->sumA += dpp->weightA;
1283
1284             in_left   += dir;
1285             out_left  += dir;
1286             in_right  += dir;
1287             out_right += dir;
1288         }
1289         break;
1290     case -3:
1291         while (nb_samples--) {
1292             int32_t sam_A, sam_B, tmp;
1293
1294             sam_A = dpp->samplesA[0];
1295             sam_B = dpp->samplesB[0];
1296
1297             dpp->samplesA[0] = tmp = in_right[0];
1298             out_right[0] = tmp -= APPLY_WEIGHT(dpp->weightB, sam_B);
1299             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
1300             dpp->sumB += dpp->weightB;
1301
1302             dpp->samplesB[0] = tmp = in_left[0];
1303             out_left[0] = tmp -= APPLY_WEIGHT(dpp->weightA, sam_A);
1304             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
1305             dpp->sumA += dpp->weightA;
1306
1307             in_left   += dir;
1308             out_left  += dir;
1309             in_right  += dir;
1310             out_right += dir;
1311         }
1312         break;
1313     }
1314 }
1315
1316 static void reverse_decorr(struct Decorr *dpp)
1317 {
1318     if (dpp->value > MAX_TERM) {
1319         int32_t sam_A, sam_B;
1320
1321         if (dpp->value & 1) {
1322             sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1];
1323             sam_B = 2 * dpp->samplesB[0] - dpp->samplesB[1];
1324         } else {
1325             sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1;
1326             sam_B = (3 * dpp->samplesB[0] - dpp->samplesB[1]) >> 1;
1327         }
1328
1329         dpp->samplesA[1] = dpp->samplesA[0];
1330         dpp->samplesB[1] = dpp->samplesB[0];
1331         dpp->samplesA[0] = sam_A;
1332         dpp->samplesB[0] = sam_B;
1333
1334         if (dpp->value & 1) {
1335             sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1];
1336             sam_B = 2 * dpp->samplesB[0] - dpp->samplesB[1];
1337         } else {
1338             sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1;
1339             sam_B = (3 * dpp->samplesB[0] - dpp->samplesB[1]) >> 1;
1340         }
1341
1342         dpp->samplesA[1] = sam_A;
1343         dpp->samplesB[1] = sam_B;
1344     } else if (dpp->value > 1) {
1345         int i, j, k;
1346
1347         for (i = 0, j = dpp->value - 1, k = 0; k < dpp->value / 2; i++, j--, k++) {
1348             i &= (MAX_TERM - 1);
1349             j &= (MAX_TERM - 1);
1350             dpp->samplesA[i] ^= dpp->samplesA[j];
1351             dpp->samplesA[j] ^= dpp->samplesA[i];
1352             dpp->samplesA[i] ^= dpp->samplesA[j];
1353             dpp->samplesB[i] ^= dpp->samplesB[j];
1354             dpp->samplesB[j] ^= dpp->samplesB[i];
1355             dpp->samplesB[i] ^= dpp->samplesB[j];
1356         }
1357     }
1358 }
1359
1360 static void decorr_stereo_quick(int32_t *in_left,  int32_t *in_right,
1361                                 int32_t *out_left, int32_t *out_right,
1362                                 int nb_samples, struct Decorr *dpp)
1363 {
1364     int m = 0, i;
1365
1366     dpp->weightA = restore_weight(store_weight(dpp->weightA));
1367     dpp->weightB = restore_weight(store_weight(dpp->weightB));
1368
1369     for (i = 0; i < MAX_TERM; i++) {
1370         dpp->samplesA[i] = wp_exp2(log2s(dpp->samplesA[i]));
1371         dpp->samplesB[i] = wp_exp2(log2s(dpp->samplesB[i]));
1372     }
1373
1374     switch (dpp->value) {
1375     case 2:
1376         for (i = 0; i < nb_samples; i++) {
1377             int32_t sam, tmp;
1378
1379             sam = dpp->samplesA[0];
1380             dpp->samplesA[0] = dpp->samplesA[1];
1381             out_left[i] = tmp = (dpp->samplesA[1] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam);
1382             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
1383
1384             sam = dpp->samplesB[0];
1385             dpp->samplesB[0] = dpp->samplesB[1];
1386             out_right[i] = tmp = (dpp->samplesB[1] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam);
1387             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
1388         }
1389         break;
1390     case 17:
1391         for (i = 0; i < nb_samples; i++) {
1392             int32_t sam, tmp;
1393
1394             sam = 2 * dpp->samplesA[0] - dpp->samplesA[1];
1395             dpp->samplesA[1] = dpp->samplesA[0];
1396             out_left[i] = tmp = (dpp->samplesA[0] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam);
1397             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
1398
1399             sam = 2 * dpp->samplesB[0] - dpp->samplesB[1];
1400             dpp->samplesB[1] = dpp->samplesB[0];
1401             out_right[i] = tmp = (dpp->samplesB[0] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam);
1402             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
1403         }
1404         break;
1405     case 18:
1406         for (i = 0; i < nb_samples; i++) {
1407             int32_t sam, tmp;
1408
1409             sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1);
1410             dpp->samplesA[1] = dpp->samplesA[0];
1411             out_left[i] = tmp = (dpp->samplesA[0] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam);
1412             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
1413
1414             sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1);
1415             dpp->samplesB[1] = dpp->samplesB[0];
1416             out_right[i] = tmp = (dpp->samplesB[0] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam);
1417             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
1418         }
1419         break;
1420     default: {
1421         int k = dpp->value & (MAX_TERM - 1);
1422
1423         for (i = 0; i < nb_samples; i++) {
1424             int32_t sam, tmp;
1425
1426             sam = dpp->samplesA[m];
1427             out_left[i] = tmp = (dpp->samplesA[k] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam);
1428             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
1429
1430             sam = dpp->samplesB[m];
1431             out_right[i] = tmp = (dpp->samplesB[k] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam);
1432             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
1433
1434             m = (m + 1) & (MAX_TERM - 1);
1435             k = (k + 1) & (MAX_TERM - 1);
1436         }
1437
1438         if (m) {
1439             int32_t temp_A[MAX_TERM], temp_B[MAX_TERM];
1440             int k;
1441
1442             memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA));
1443             memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB));
1444
1445             for (k = 0; k < MAX_TERM; k++) {
1446                 dpp->samplesA[k] = temp_A[m];
1447                 dpp->samplesB[k] = temp_B[m];
1448                 m = (m + 1) & (MAX_TERM - 1);
1449             }
1450         }
1451         break;
1452     }
1453     case -1:
1454         for (i = 0; i < nb_samples; i++) {
1455             int32_t sam_A, sam_B, tmp;
1456
1457             sam_A = dpp->samplesA[0];
1458             out_left[i] = tmp = (sam_B = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A);
1459             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
1460
1461             out_right[i] = tmp = (dpp->samplesA[0] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B);
1462             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
1463         }
1464         break;
1465     case -2:
1466         for (i = 0; i < nb_samples; i++) {
1467             int32_t sam_A, sam_B, tmp;
1468
1469             sam_B = dpp->samplesB[0];
1470             out_right[i] = tmp = (sam_A = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B);
1471             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
1472
1473             out_left[i] = tmp = (dpp->samplesB[0] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A);
1474             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
1475         }
1476         break;
1477     case -3:
1478         for (i = 0; i < nb_samples; i++) {
1479             int32_t sam_A, sam_B, tmp;
1480
1481             sam_A = dpp->samplesA[0];
1482             sam_B = dpp->samplesB[0];
1483
1484             dpp->samplesA[0] = tmp = in_right[i];
1485             out_right[i] = tmp -= APPLY_WEIGHT_I(dpp->weightB, sam_B);
1486             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
1487
1488             dpp->samplesB[0] = tmp = in_left[i];
1489             out_left[i] = tmp -= APPLY_WEIGHT_I(dpp->weightA, sam_A);
1490             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
1491         }
1492         break;
1493     }
1494 }
1495
1496 static void decorr_stereo_buffer(WavPackExtraInfo *info,
1497                                  int32_t *in_left,  int32_t *in_right,
1498                                  int32_t *out_left, int32_t *out_right,
1499                                  int nb_samples, int tindex)
1500 {
1501     struct Decorr dp = {0}, *dppi = info->dps + tindex;
1502     int delta = dppi->delta, pre_delta;
1503     int term = dppi->value;
1504
1505     if (delta == 7)
1506         pre_delta = 7;
1507     else if (delta < 2)
1508         pre_delta = 3;
1509     else
1510         pre_delta = delta + 1;
1511
1512     dp.value = term;
1513     dp.delta = pre_delta;
1514     decorr_stereo(in_left, in_right, out_left, out_right,
1515                   FFMIN(2048, nb_samples), &dp, -1);
1516     dp.delta = delta;
1517
1518     if (tindex == 0) {
1519         reverse_decorr(&dp);
1520     } else {
1521         CLEAR(dp.samplesA);
1522         CLEAR(dp.samplesB);
1523     }
1524
1525     memcpy(dppi->samplesA, dp.samplesA, sizeof(dp.samplesA));
1526     memcpy(dppi->samplesB, dp.samplesB, sizeof(dp.samplesB));
1527     dppi->weightA = dp.weightA;
1528     dppi->weightB = dp.weightB;
1529
1530     if (delta == 0) {
1531         dp.delta = 1;
1532         decorr_stereo(in_left, in_right, out_left, out_right, nb_samples, &dp, 1);
1533         dp.delta = 0;
1534         memcpy(dp.samplesA, dppi->samplesA, sizeof(dp.samplesA));
1535         memcpy(dp.samplesB, dppi->samplesB, sizeof(dp.samplesB));
1536         dppi->weightA = dp.weightA = dp.sumA / nb_samples;
1537         dppi->weightB = dp.weightB = dp.sumB / nb_samples;
1538     }
1539
1540     if (info->gt16bit)
1541         decorr_stereo(in_left, in_right, out_left, out_right,
1542                            nb_samples, &dp, 1);
1543     else
1544         decorr_stereo_quick(in_left, in_right, out_left, out_right,
1545                             nb_samples, &dp);
1546 }
1547
1548 static void sort_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info)
1549 {
1550     int reversed = 1;
1551     uint32_t bits;
1552
1553     while (reversed) {
1554         int ri, i;
1555
1556         memcpy(info->dps, s->decorr_passes, sizeof(s->decorr_passes));
1557         reversed = 0;
1558
1559         for (ri = 0; ri < info->nterms && s->decorr_passes[ri].value; ri++) {
1560
1561             if (ri + 1 >= info->nterms || !s->decorr_passes[ri+1].value)
1562                 break;
1563
1564             if (s->decorr_passes[ri].value == s->decorr_passes[ri+1].value) {
1565                 decorr_stereo_buffer(info,
1566                                      s->sampleptrs[ri  ][0], s->sampleptrs[ri  ][1],
1567                                      s->sampleptrs[ri+1][0], s->sampleptrs[ri+1][1],
1568                                      s->block_samples, ri);
1569                 continue;
1570             }
1571
1572             info->dps[ri  ] = s->decorr_passes[ri+1];
1573             info->dps[ri+1] = s->decorr_passes[ri  ];
1574
1575             for (i = ri; i < info->nterms && s->decorr_passes[i].value; i++)
1576                 decorr_stereo_buffer(info,
1577                                      s->sampleptrs[i  ][0], s->sampleptrs[i  ][1],
1578                                      s->sampleptrs[i+1][0], s->sampleptrs[i+1][1],
1579                                      s->block_samples, i);
1580
1581             bits = log2stereo(s->sampleptrs[i][0], s->sampleptrs[i][1],
1582                               s->block_samples, info->log_limit);
1583
1584             if (bits < info->best_bits) {
1585                 reversed = 1;
1586                 info->best_bits = bits;
1587                 CLEAR(s->decorr_passes);
1588                 memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i);
1589                 memcpy(s->sampleptrs[info->nterms + 1][0],
1590                        s->sampleptrs[i][0], s->block_samples * 4);
1591                 memcpy(s->sampleptrs[info->nterms + 1][1],
1592                        s->sampleptrs[i][1], s->block_samples * 4);
1593             } else {
1594                 info->dps[ri  ] = s->decorr_passes[ri  ];
1595                 info->dps[ri+1] = s->decorr_passes[ri+1];
1596                 decorr_stereo_buffer(info,
1597                                      s->sampleptrs[ri  ][0], s->sampleptrs[ri  ][1],
1598                                      s->sampleptrs[ri+1][0], s->sampleptrs[ri+1][1],
1599                                      s->block_samples, ri);
1600             }
1601         }
1602     }
1603 }
1604
1605 static void delta_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info)
1606 {
1607     int lower = 0, delta, d, i;
1608     uint32_t bits;
1609
1610     if (!s->decorr_passes[0].value)
1611         return;
1612     delta = s->decorr_passes[0].delta;
1613
1614     for (d = delta - 1; d >= 0; d--) {
1615         for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) {
1616             info->dps[i].value = s->decorr_passes[i].value;
1617             info->dps[i].delta = d;
1618             decorr_stereo_buffer(info,
1619                                  s->sampleptrs[i  ][0], s->sampleptrs[i  ][1],
1620                                  s->sampleptrs[i+1][0], s->sampleptrs[i+1][1],
1621                                  s->block_samples, i);
1622         }
1623
1624         bits = log2stereo(s->sampleptrs[i][0], s->sampleptrs[i][1],
1625                           s->block_samples, info->log_limit);
1626         if (bits >= info->best_bits)
1627             break;
1628         lower = 1;
1629         info->best_bits = bits;
1630         CLEAR(s->decorr_passes);
1631         memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i);
1632         memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[i][0],
1633                s->block_samples * 4);
1634         memcpy(s->sampleptrs[info->nterms + 1][1], s->sampleptrs[i][1],
1635                s->block_samples * 4);
1636     }
1637
1638     for (d = delta + 1; !lower && d <= 7; d++) {
1639         for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) {
1640             info->dps[i].value = s->decorr_passes[i].value;
1641             info->dps[i].delta = d;
1642             decorr_stereo_buffer(info,
1643                                  s->sampleptrs[i  ][0], s->sampleptrs[i  ][1],
1644                                  s->sampleptrs[i+1][0], s->sampleptrs[i+1][1],
1645                                  s->block_samples, i);
1646         }
1647
1648         bits = log2stereo(s->sampleptrs[i][0], s->sampleptrs[i][1],
1649                           s->block_samples, info->log_limit);
1650
1651         if (bits < info->best_bits) {
1652             info->best_bits = bits;
1653             CLEAR(s->decorr_passes);
1654             memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i);
1655             memcpy(s->sampleptrs[info->nterms + 1][0],
1656                    s->sampleptrs[i][0], s->block_samples * 4);
1657             memcpy(s->sampleptrs[info->nterms + 1][1],
1658                    s->sampleptrs[i][1], s->block_samples * 4);
1659         }
1660         else
1661             break;
1662     }
1663 }
1664
1665 static void recurse_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info,
1666                            int depth, int delta, uint32_t input_bits)
1667 {
1668     int term, branches = s->num_branches - depth;
1669     int32_t *in_left, *in_right, *out_left, *out_right;
1670     uint32_t term_bits[22], bits;
1671
1672     if (branches < 1 || depth + 1 == info->nterms)
1673         branches = 1;
1674
1675     CLEAR(term_bits);
1676     in_left   = s->sampleptrs[depth    ][0];
1677     in_right  = s->sampleptrs[depth    ][1];
1678     out_left  = s->sampleptrs[depth + 1][0];
1679     out_right = s->sampleptrs[depth + 1][1];
1680
1681     for (term = -3; term <= 18; term++) {
1682         if (!term || (term > 8 && term < 17))
1683             continue;
1684
1685         if (term == 17 && branches == 1 && depth + 1 < info->nterms)
1686             continue;
1687
1688         if (term == -1 || term == -2)
1689             if (!(s->flags & WV_CROSS_DECORR))
1690                 continue;
1691
1692         if (!s->extra_flags && (term > 4 && term < 17))
1693             continue;
1694
1695         info->dps[depth].value = term;
1696         info->dps[depth].delta = delta;
1697         decorr_stereo_buffer(info, in_left, in_right, out_left, out_right,
1698                              s->block_samples, depth);
1699         bits = log2stereo(out_left, out_right, s->block_samples, info->log_limit);
1700
1701         if (bits < info->best_bits) {
1702             info->best_bits = bits;
1703             CLEAR(s->decorr_passes);
1704             memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * (depth + 1));
1705             memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[depth + 1][0],
1706                    s->block_samples * 4);
1707             memcpy(s->sampleptrs[info->nterms + 1][1], s->sampleptrs[depth + 1][1],
1708                    s->block_samples * 4);
1709         }
1710
1711         term_bits[term + 3] = bits;
1712     }
1713
1714     while (depth + 1 < info->nterms && branches--) {
1715         uint32_t local_best_bits = input_bits;
1716         int best_term = 0, i;
1717
1718         for (i = 0; i < 22; i++)
1719             if (term_bits[i] && term_bits[i] < local_best_bits) {
1720                 local_best_bits = term_bits[i];
1721                 best_term = i - 3;
1722             }
1723
1724         if (!best_term)
1725             break;
1726
1727         term_bits[best_term + 3] = 0;
1728
1729         info->dps[depth].value = best_term;
1730         info->dps[depth].delta = delta;
1731         decorr_stereo_buffer(info, in_left, in_right, out_left, out_right,
1732                              s->block_samples, depth);
1733
1734         recurse_stereo(s, info, depth + 1, delta, local_best_bits);
1735     }
1736 }
1737
1738 static void analyze_stereo(WavPackEncodeContext *s,
1739                            int32_t *in_left, int32_t *in_right,
1740                            int do_samples)
1741 {
1742     WavPackExtraInfo info;
1743     int i;
1744
1745     info.gt16bit = ((s->flags & MAG_MASK) >> MAG_LSB) >= 16;
1746
1747     info.log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256;
1748     info.log_limit = FFMIN(6912, info.log_limit);
1749
1750     info.nterms = s->num_terms;
1751
1752     if (allocate_buffers2(s, s->num_terms))
1753         return;
1754
1755     memcpy(info.dps, s->decorr_passes, sizeof(info.dps));
1756     memcpy(s->sampleptrs[0][0], in_left,  s->block_samples * 4);
1757     memcpy(s->sampleptrs[0][1], in_right, s->block_samples * 4);
1758
1759     for (i = 0; i < info.nterms && info.dps[i].value; i++)
1760         if (info.gt16bit)
1761             decorr_stereo(s->sampleptrs[i    ][0], s->sampleptrs[i    ][1],
1762                           s->sampleptrs[i + 1][0], s->sampleptrs[i + 1][1],
1763                           s->block_samples, info.dps + i, 1);
1764         else
1765             decorr_stereo_quick(s->sampleptrs[i    ][0], s->sampleptrs[i    ][1],
1766                                 s->sampleptrs[i + 1][0], s->sampleptrs[i + 1][1],
1767                                 s->block_samples, info.dps + i);
1768
1769     info.best_bits = log2stereo(s->sampleptrs[info.nterms][0], s->sampleptrs[info.nterms][1],
1770                                 s->block_samples, 0);
1771
1772     memcpy(s->sampleptrs[info.nterms + 1][0], s->sampleptrs[i][0], s->block_samples * 4);
1773     memcpy(s->sampleptrs[info.nterms + 1][1], s->sampleptrs[i][1], s->block_samples * 4);
1774
1775     if (s->extra_flags & EXTRA_BRANCHES)
1776         recurse_stereo(s, &info, 0, (int) floor(s->delta_decay + 0.5),
1777                        log2stereo(s->sampleptrs[0][0], s->sampleptrs[0][1],
1778                                   s->block_samples, 0));
1779
1780     if (s->extra_flags & EXTRA_SORT_FIRST)
1781         sort_stereo(s, &info);
1782
1783     if (s->extra_flags & EXTRA_TRY_DELTAS) {
1784         delta_stereo(s, &info);
1785
1786         if ((s->extra_flags & EXTRA_ADJUST_DELTAS) && s->decorr_passes[0].value)
1787             s->delta_decay = (float)((s->delta_decay * 2.0 + s->decorr_passes[0].delta) / 3.0);
1788         else
1789             s->delta_decay = 2.0;
1790     }
1791
1792     if (s->extra_flags & EXTRA_SORT_LAST)
1793         sort_stereo(s, &info);
1794
1795     if (do_samples) {
1796         memcpy(in_left,  s->sampleptrs[info.nterms + 1][0], s->block_samples * 4);
1797         memcpy(in_right, s->sampleptrs[info.nterms + 1][1], s->block_samples * 4);
1798     }
1799
1800     for (i = 0; i < info.nterms; i++)
1801         if (!s->decorr_passes[i].value)
1802             break;
1803
1804     s->num_terms = i;
1805 }
1806
1807 static int wv_stereo(WavPackEncodeContext *s,
1808                      int32_t *samples_l, int32_t *samples_r,
1809                      int no_history, int do_samples)
1810 {
1811     struct Decorr temp_decorr_pass, save_decorr_passes[MAX_TERMS] = {{0}};
1812     int nb_samples = s->block_samples, ret;
1813     int buf_size = sizeof(int32_t) * nb_samples;
1814     int log_limit, force_js = 0, force_ts = 0, got_js = 0, pi, i;
1815     uint32_t best_size = UINT32_MAX, size;
1816
1817     for (i = 0; i < nb_samples; i++)
1818         if (samples_l[i] || samples_r[i])
1819             break;
1820
1821     if (i == nb_samples) {
1822         s->flags &= ~((uint32_t) WV_JOINT_STEREO);
1823         CLEAR(s->decorr_passes);
1824         CLEAR(s->w);
1825         s->num_terms = 0;
1826         return 0;
1827     }
1828
1829     log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256;
1830     log_limit = FFMIN(6912, log_limit);
1831
1832     if (s->joint) {
1833         force_js = s->joint > 0;
1834         force_ts = s->joint < 0;
1835     }
1836
1837     if ((ret = allocate_buffers(s)) < 0)
1838         return ret;
1839
1840     if (no_history || s->num_passes >= 7)
1841         s->best_decorr = s->mask_decorr = 0;
1842
1843     for (pi = 0; pi < s->num_passes;) {
1844         const WavPackDecorrSpec *wpds;
1845         int nterms, c, j;
1846
1847         if (!pi)
1848             c = s->best_decorr;
1849         else {
1850             if (s->mask_decorr == 0)
1851                 c = 0;
1852             else
1853                 c = (s->best_decorr & (s->mask_decorr - 1)) | s->mask_decorr;
1854
1855             if (c == s->best_decorr) {
1856                 s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1;
1857                 continue;
1858             }
1859         }
1860
1861         wpds = &s->decorr_specs[c];
1862         nterms = decorr_filter_nterms[s->decorr_filter];
1863
1864         while (1) {
1865             if (force_js || (wpds->joint_stereo && !force_ts)) {
1866                 if (!got_js) {
1867                     av_fast_padded_malloc(&s->js_left,  &s->js_left_size,  buf_size);
1868                     av_fast_padded_malloc(&s->js_right, &s->js_right_size, buf_size);
1869                     memcpy(s->js_left,  samples_l, buf_size);
1870                     memcpy(s->js_right, samples_r, buf_size);
1871
1872                     for (i = 0; i < nb_samples; i++)
1873                         s->js_right[i] += ((s->js_left[i] -= s->js_right[i]) >> 1);
1874                     got_js = 1;
1875                 }
1876
1877                 memcpy(s->temp_buffer[0][0], s->js_left,  buf_size);
1878                 memcpy(s->temp_buffer[0][1], s->js_right, buf_size);
1879             } else {
1880                 memcpy(s->temp_buffer[0][0], samples_l, buf_size);
1881                 memcpy(s->temp_buffer[0][1], samples_r, buf_size);
1882             }
1883
1884             CLEAR(save_decorr_passes);
1885
1886             for (j = 0; j < nterms; j++) {
1887                 CLEAR(temp_decorr_pass);
1888                 temp_decorr_pass.delta = wpds->delta;
1889                 temp_decorr_pass.value = wpds->terms[j];
1890
1891                 if (temp_decorr_pass.value < 0 && !(s->flags & WV_CROSS_DECORR))
1892                     temp_decorr_pass.value = -3;
1893
1894                 decorr_stereo(s->temp_buffer[ j&1][0], s->temp_buffer[ j&1][1],
1895                               s->temp_buffer[~j&1][0], s->temp_buffer[~j&1][1],
1896                               FFMIN(2048, nb_samples), &temp_decorr_pass, -1);
1897
1898                 if (j) {
1899                     CLEAR(temp_decorr_pass.samplesA);
1900                     CLEAR(temp_decorr_pass.samplesB);
1901                 } else {
1902                     reverse_decorr(&temp_decorr_pass);
1903                 }
1904
1905                 memcpy(save_decorr_passes + j, &temp_decorr_pass, sizeof(struct Decorr));
1906
1907                 if (((s->flags & MAG_MASK) >> MAG_LSB) >= 16)
1908                     decorr_stereo(s->temp_buffer[ j&1][0], s->temp_buffer[ j&1][1],
1909                                   s->temp_buffer[~j&1][0], s->temp_buffer[~j&1][1],
1910                                   nb_samples, &temp_decorr_pass, 1);
1911                 else
1912                     decorr_stereo_quick(s->temp_buffer[ j&1][0], s->temp_buffer[ j&1][1],
1913                                         s->temp_buffer[~j&1][0], s->temp_buffer[~j&1][1],
1914                                         nb_samples, &temp_decorr_pass);
1915             }
1916
1917             size = log2stereo(s->temp_buffer[j&1][0], s->temp_buffer[j&1][1],
1918                               nb_samples, log_limit);
1919             if (size != UINT32_MAX || !nterms)
1920                 break;
1921             nterms >>= 1;
1922         }
1923
1924         if (size < best_size) {
1925             memcpy(s->best_buffer[0], s->temp_buffer[j&1][0], buf_size);
1926             memcpy(s->best_buffer[1], s->temp_buffer[j&1][1], buf_size);
1927             memcpy(s->decorr_passes, save_decorr_passes, sizeof(struct Decorr) * MAX_TERMS);
1928             s->num_terms = nterms;
1929             s->best_decorr = c;
1930             best_size = size;
1931         }
1932
1933         if (pi++)
1934             s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1;
1935     }
1936
1937     if (force_js || (s->decorr_specs[s->best_decorr].joint_stereo && !force_ts))
1938         s->flags |= WV_JOINT_STEREO;
1939     else
1940         s->flags &= ~((uint32_t) WV_JOINT_STEREO);
1941
1942     if (s->extra_flags) {
1943         if (s->flags & WV_JOINT_STEREO) {
1944             analyze_stereo(s, s->js_left, s->js_right, do_samples);
1945
1946             if (do_samples) {
1947                 memcpy(samples_l, s->js_left,  buf_size);
1948                 memcpy(samples_r, s->js_right, buf_size);
1949             }
1950         } else
1951             analyze_stereo(s, samples_l, samples_r, do_samples);
1952     } else if (do_samples) {
1953         memcpy(samples_l, s->best_buffer[0], buf_size);
1954         memcpy(samples_r, s->best_buffer[1], buf_size);
1955     }
1956
1957     if (s->extra_flags || no_history ||
1958         s->joint_stereo != s->decorr_specs[s->best_decorr].joint_stereo) {
1959         s->joint_stereo = s->decorr_specs[s->best_decorr].joint_stereo;
1960         CLEAR(s->w);
1961         scan_word(s, &s->w.c[0], s->best_buffer[0], nb_samples, -1);
1962         scan_word(s, &s->w.c[1], s->best_buffer[1], nb_samples, -1);
1963     }
1964     return 0;
1965 }
1966
1967 #define count_bits(av) ( \
1968  (av) < (1 << 8) ? nbits_table[av] : \
1969   ( \
1970    (av) < (1L << 16) ? nbits_table[(av) >> 8] + 8 : \
1971    ((av) < (1L << 24) ? nbits_table[(av) >> 16] + 16 : nbits_table[(av) >> 24] + 24) \
1972   ) \
1973 )
1974
1975 static void encode_flush(WavPackEncodeContext *s)
1976 {
1977     WavPackWords *w = &s->w;
1978     PutBitContext *pb = &s->pb;
1979
1980     if (w->zeros_acc) {
1981         int cbits = count_bits(w->zeros_acc);
1982
1983         do {
1984             if (cbits > 31) {
1985                 put_bits(pb, 31, 0x7FFFFFFF);
1986                 cbits -= 31;
1987             } else {
1988                 put_bits(pb, cbits, (1 << cbits) - 1);
1989                 cbits = 0;
1990             }
1991         } while (cbits);
1992
1993         put_bits(pb, 1, 0);
1994
1995         while (w->zeros_acc > 1) {
1996             put_bits(pb, 1, w->zeros_acc & 1);
1997             w->zeros_acc >>= 1;
1998         }
1999
2000         w->zeros_acc = 0;
2001     }
2002
2003     if (w->holding_one) {
2004         if (w->holding_one >= 16) {
2005             int cbits;
2006
2007             put_bits(pb, 16, (1 << 16) - 1);
2008             put_bits(pb, 1, 0);
2009             w->holding_one -= 16;
2010             cbits = count_bits(w->holding_one);
2011
2012             do {
2013                 if (cbits > 31) {
2014                     put_bits(pb, 31, 0x7FFFFFFF);
2015                     cbits -= 31;
2016                 } else {
2017                     put_bits(pb, cbits, (1 << cbits) - 1);
2018                     cbits = 0;
2019                 }
2020             } while (cbits);
2021
2022             put_bits(pb, 1, 0);
2023
2024             while (w->holding_one > 1) {
2025                 put_bits(pb, 1, w->holding_one & 1);
2026                 w->holding_one >>= 1;
2027             }
2028
2029             w->holding_zero = 0;
2030         } else {
2031             put_bits(pb, w->holding_one, (1 << w->holding_one) - 1);
2032         }
2033
2034         w->holding_one = 0;
2035     }
2036
2037     if (w->holding_zero) {
2038         put_bits(pb, 1, 0);
2039         w->holding_zero = 0;
2040     }
2041
2042     if (w->pend_count) {
2043         put_bits(pb, w->pend_count, w->pend_data);
2044         w->pend_data = w->pend_count = 0;
2045     }
2046 }
2047
2048 static void wavpack_encode_sample(WavPackEncodeContext *s, WvChannel *c, int32_t sample)
2049 {
2050     WavPackWords *w = &s->w;
2051     uint32_t ones_count, low, high;
2052     int sign = sample < 0;
2053
2054     if (s->w.c[0].median[0] < 2 && !s->w.holding_zero && s->w.c[1].median[0] < 2) {
2055         if (w->zeros_acc) {
2056             if (sample)
2057                 encode_flush(s);
2058             else {
2059                 w->zeros_acc++;
2060                 return;
2061             }
2062         } else if (sample) {
2063             put_bits(&s->pb, 1, 0);
2064         } else {
2065             CLEAR(s->w.c[0].median);
2066             CLEAR(s->w.c[1].median);
2067             w->zeros_acc = 1;
2068             return;
2069         }
2070     }
2071
2072     if (sign)
2073         sample = ~sample;
2074
2075     if (sample < (int32_t) GET_MED(0)) {
2076         ones_count = low = 0;
2077         high = GET_MED(0) - 1;
2078         DEC_MED(0);
2079     } else {
2080         low = GET_MED(0);
2081         INC_MED(0);
2082
2083         if (sample - low < GET_MED(1)) {
2084             ones_count = 1;
2085             high = low + GET_MED(1) - 1;
2086             DEC_MED(1);
2087         } else {
2088             low += GET_MED(1);
2089             INC_MED(1);
2090
2091             if (sample - low < GET_MED(2)) {
2092                 ones_count = 2;
2093                 high = low + GET_MED(2) - 1;
2094                 DEC_MED(2);
2095             } else {
2096                 ones_count = 2 + (sample - low) / GET_MED(2);
2097                 low += (ones_count - 2) * GET_MED(2);
2098                 high = low + GET_MED(2) - 1;
2099                 INC_MED(2);
2100             }
2101         }
2102     }
2103
2104     if (w->holding_zero) {
2105         if (ones_count)
2106             w->holding_one++;
2107
2108         encode_flush(s);
2109
2110         if (ones_count) {
2111             w->holding_zero = 1;
2112             ones_count--;
2113         } else
2114             w->holding_zero = 0;
2115     } else
2116         w->holding_zero = 1;
2117
2118     w->holding_one = ones_count * 2;
2119
2120     if (high != low) {
2121         uint32_t maxcode = high - low, code = sample - low;
2122         int bitcount = count_bits(maxcode);
2123         uint32_t extras = (1 << bitcount) - maxcode - 1;
2124
2125         if (code < extras) {
2126             w->pend_data |= code << w->pend_count;
2127             w->pend_count += bitcount - 1;
2128         } else {
2129             w->pend_data |= ((code + extras) >> 1) << w->pend_count;
2130             w->pend_count += bitcount - 1;
2131             w->pend_data |= ((code + extras) & 1) << w->pend_count++;
2132         }
2133     }
2134
2135     w->pend_data |= ((int32_t) sign << w->pend_count++);
2136
2137     if (!w->holding_zero)
2138         encode_flush(s);
2139 }
2140
2141 static void pack_int32(WavPackEncodeContext *s,
2142                        int32_t *samples_l, int32_t *samples_r,
2143                        int nb_samples)
2144 {
2145     const int sent_bits = s->int32_sent_bits;
2146     int32_t value, mask = (1 << sent_bits) - 1;
2147     PutBitContext *pb = &s->pb;
2148     int i, pre_shift;
2149
2150     pre_shift = s->int32_zeros + s->int32_ones + s->int32_dups;
2151
2152     if (!sent_bits)
2153         return;
2154
2155     if (s->flags & WV_MONO_DATA) {
2156         for (i = 0; i < nb_samples; i++) {
2157             value = (samples_l[i] >> pre_shift) & mask;
2158             put_bits(pb, sent_bits, value);
2159         }
2160     } else {
2161         for (i = 0; i < nb_samples; i++) {
2162             value = (samples_l[i] >> pre_shift) & mask;
2163             put_bits(pb, sent_bits, value);
2164             value = (samples_r[i] >> pre_shift) & mask;
2165             put_bits(pb, sent_bits, value);
2166         }
2167     }
2168 }
2169
2170 static void pack_float_sample(WavPackEncodeContext *s, int32_t *sample)
2171 {
2172     const int max_exp = s->float_max_exp;
2173     PutBitContext *pb = &s->pb;
2174     int32_t value, shift_count;
2175
2176     if (get_exponent(*sample) == 255) {
2177         if (get_mantissa(*sample)) {
2178             put_bits(pb, 1, 1);
2179             put_bits(pb, 23, get_mantissa(*sample));
2180         } else {
2181             put_bits(pb, 1, 0);
2182         }
2183
2184         value = 0x1000000;
2185         shift_count = 0;
2186     } else if (get_exponent(*sample)) {
2187         shift_count = max_exp - get_exponent(*sample);
2188         value = 0x800000 + get_mantissa(*sample);
2189     } else {
2190         shift_count = max_exp ? max_exp - 1 : 0;
2191         value = get_mantissa(*sample);
2192     }
2193
2194     if (shift_count < 25)
2195         value >>= shift_count;
2196     else
2197         value = 0;
2198
2199     if (!value) {
2200         if (s->float_flags & FLOAT_ZEROS_SENT) {
2201             if (get_exponent(*sample) || get_mantissa(*sample)) {
2202                 put_bits(pb, 1, 1);
2203                 put_bits(pb, 23, get_mantissa(*sample));
2204
2205                 if (max_exp >= 25)
2206                     put_bits(pb, 8, get_exponent(*sample));
2207
2208                 put_bits(pb, 1, get_sign(*sample));
2209             } else {
2210                 put_bits(pb, 1, 0);
2211
2212                 if (s->float_flags & FLOAT_NEG_ZEROS)
2213                     put_bits(pb, 1, get_sign(*sample));
2214             }
2215         }
2216     } else if (shift_count) {
2217         if (s->float_flags & FLOAT_SHIFT_SENT) {
2218             int32_t data = get_mantissa(*sample) & ((1 << shift_count) - 1);
2219             put_bits(pb, shift_count, data);
2220         } else if (s->float_flags & FLOAT_SHIFT_SAME) {
2221             put_bits(pb, 1, get_mantissa(*sample) & 1);
2222         }
2223     }
2224 }
2225
2226 static void pack_float(WavPackEncodeContext *s,
2227                        int32_t *samples_l, int32_t *samples_r,
2228                        int nb_samples)
2229 {
2230     int i;
2231
2232     if (s->flags & WV_MONO_DATA) {
2233         for (i = 0; i < nb_samples; i++)
2234             pack_float_sample(s, &samples_l[i]);
2235     } else {
2236         for (i = 0; i < nb_samples; i++) {
2237             pack_float_sample(s, &samples_l[i]);
2238             pack_float_sample(s, &samples_r[i]);
2239         }
2240     }
2241 }
2242
2243 static void decorr_stereo_pass2(struct Decorr *dpp,
2244                                 int32_t *samples_l, int32_t *samples_r,
2245                                 int nb_samples)
2246 {
2247     int i, m, k;
2248
2249     switch (dpp->value) {
2250     case 17:
2251         for (i = 0; i < nb_samples; i++) {
2252             int32_t sam, tmp;
2253
2254             sam = 2 * dpp->samplesA[0] - dpp->samplesA[1];
2255             dpp->samplesA[1] = dpp->samplesA[0];
2256             samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam);
2257             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
2258
2259             sam = 2 * dpp->samplesB[0] - dpp->samplesB[1];
2260             dpp->samplesB[1] = dpp->samplesB[0];
2261             samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam);
2262             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
2263         }
2264         break;
2265     case 18:
2266         for (i = 0; i < nb_samples; i++) {
2267             int32_t sam, tmp;
2268
2269             sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1);
2270             dpp->samplesA[1] = dpp->samplesA[0];
2271             samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam);
2272             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
2273
2274             sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1);
2275             dpp->samplesB[1] = dpp->samplesB[0];
2276             samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam);
2277             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
2278         }
2279         break;
2280     default:
2281         for (m = 0, k = dpp->value & (MAX_TERM - 1), i = 0; i < nb_samples; i++) {
2282             int32_t sam, tmp;
2283
2284             sam = dpp->samplesA[m];
2285             samples_l[i] = tmp = (dpp->samplesA[k] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam);
2286             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
2287
2288             sam = dpp->samplesB[m];
2289             samples_r[i] = tmp = (dpp->samplesB[k] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam);
2290             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
2291
2292             m = (m + 1) & (MAX_TERM - 1);
2293             k = (k + 1) & (MAX_TERM - 1);
2294         }
2295         if (m) {
2296             int32_t temp_A[MAX_TERM], temp_B[MAX_TERM];
2297
2298             memcpy(temp_A, dpp->samplesA, sizeof (dpp->samplesA));
2299             memcpy(temp_B, dpp->samplesB, sizeof (dpp->samplesB));
2300
2301             for (k = 0; k < MAX_TERM; k++) {
2302                 dpp->samplesA[k] = temp_A[m];
2303                 dpp->samplesB[k] = temp_B[m];
2304                 m = (m + 1) & (MAX_TERM - 1);
2305             }
2306         }
2307         break;
2308     case -1:
2309         for (i = 0; i < nb_samples; i++) {
2310             int32_t sam_A, sam_B, tmp;
2311
2312             sam_A = dpp->samplesA[0];
2313             samples_l[i] = tmp = (sam_B = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam_A);
2314             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
2315
2316             samples_r[i] = tmp = (dpp->samplesA[0] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam_B);
2317             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
2318         }
2319         break;
2320     case -2:
2321         for (i = 0; i < nb_samples; i++) {
2322             int32_t sam_A, sam_B, tmp;
2323
2324             sam_B = dpp->samplesB[0];
2325             samples_r[i] = tmp = (sam_A = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam_B);
2326             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
2327
2328             samples_l[i] = tmp = (dpp->samplesB[0] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam_A);
2329             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
2330         }
2331         break;
2332     case -3:
2333         for (i = 0; i < nb_samples; i++) {
2334             int32_t sam_A, sam_B, tmp;
2335
2336             sam_A = dpp->samplesA[0];
2337             sam_B = dpp->samplesB[0];
2338
2339             dpp->samplesA[0] = tmp = samples_r[i];
2340             samples_r[i] = tmp -= APPLY_WEIGHT(dpp->weightB, sam_B);
2341             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
2342
2343             dpp->samplesB[0] = tmp = samples_l[i];
2344             samples_l[i] = tmp -= APPLY_WEIGHT(dpp->weightA, sam_A);
2345             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
2346         }
2347         break;
2348     }
2349 }
2350
2351 #define update_weight_d2(weight, delta, source, result) \
2352     if (source && result) \
2353         weight -= (((source ^ result) >> 29) & 4) - 2;
2354
2355 #define update_weight_clip_d2(weight, delta, source, result) \
2356     if (source && result) { \
2357         const int32_t s = (source ^ result) >> 31; \
2358         if ((weight = (weight ^ s) + (2 - s)) > 1024) weight = 1024; \
2359         weight = (weight ^ s) - s; \
2360     }
2361
2362 static void decorr_stereo_pass_id2(struct Decorr *dpp,
2363                                    int32_t *samples_l, int32_t *samples_r,
2364                                    int nb_samples)
2365 {
2366     int i, m, k;
2367
2368     switch (dpp->value) {
2369     case 17:
2370         for (i = 0; i < nb_samples; i++) {
2371             int32_t sam, tmp;
2372
2373             sam = 2 * dpp->samplesA[0] - dpp->samplesA[1];
2374             dpp->samplesA[1] = dpp->samplesA[0];
2375             samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam);
2376             update_weight_d2(dpp->weightA, dpp->delta, sam, tmp);
2377
2378             sam = 2 * dpp->samplesB[0] - dpp->samplesB[1];
2379             dpp->samplesB[1] = dpp->samplesB[0];
2380             samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam);
2381             update_weight_d2(dpp->weightB, dpp->delta, sam, tmp);
2382         }
2383         break;
2384     case 18:
2385         for (i = 0; i < nb_samples; i++) {
2386             int32_t sam, tmp;
2387
2388             sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1);
2389             dpp->samplesA[1] = dpp->samplesA[0];
2390             samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam);
2391             update_weight_d2(dpp->weightA, dpp->delta, sam, tmp);
2392
2393             sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1);
2394             dpp->samplesB[1] = dpp->samplesB[0];
2395             samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam);
2396             update_weight_d2(dpp->weightB, dpp->delta, sam, tmp);
2397         }
2398         break;
2399     default:
2400         for (m = 0, k = dpp->value & (MAX_TERM - 1), i = 0; i < nb_samples; i++) {
2401             int32_t sam, tmp;
2402
2403             sam = dpp->samplesA[m];
2404             samples_l[i] = tmp = (dpp->samplesA[k] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam);
2405             update_weight_d2(dpp->weightA, dpp->delta, sam, tmp);
2406
2407             sam = dpp->samplesB[m];
2408             samples_r[i] = tmp = (dpp->samplesB[k] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam);
2409             update_weight_d2(dpp->weightB, dpp->delta, sam, tmp);
2410
2411             m = (m + 1) & (MAX_TERM - 1);
2412             k = (k + 1) & (MAX_TERM - 1);
2413         }
2414
2415         if (m) {
2416             int32_t temp_A[MAX_TERM], temp_B[MAX_TERM];
2417
2418             memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA));
2419             memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB));
2420
2421             for (k = 0; k < MAX_TERM; k++) {
2422                 dpp->samplesA[k] = temp_A[m];
2423                 dpp->samplesB[k] = temp_B[m];
2424                 m = (m + 1) & (MAX_TERM - 1);
2425             }
2426         }
2427         break;
2428     case -1:
2429         for (i = 0; i < nb_samples; i++) {
2430             int32_t sam_A, sam_B, tmp;
2431
2432             sam_A = dpp->samplesA[0];
2433             samples_l[i] = tmp = (sam_B = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A);
2434             update_weight_clip_d2(dpp->weightA, dpp->delta, sam_A, tmp);
2435
2436             samples_r[i] = tmp = (dpp->samplesA[0] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B);
2437             update_weight_clip_d2(dpp->weightB, dpp->delta, sam_B, tmp);
2438         }
2439         break;
2440     case -2:
2441         for (i = 0; i < nb_samples; i++) {
2442             int32_t sam_A, sam_B, tmp;
2443
2444             sam_B = dpp->samplesB[0];
2445             samples_r[i] = tmp = (sam_A = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B);
2446             update_weight_clip_d2(dpp->weightB, dpp->delta, sam_B, tmp);
2447
2448             samples_l[i] = tmp = (dpp->samplesB[0] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A);
2449             update_weight_clip_d2(dpp->weightA, dpp->delta, sam_A, tmp);
2450         }
2451         break;
2452     case -3:
2453         for (i = 0; i < nb_samples; i++) {
2454             int32_t sam_A, sam_B, tmp;
2455
2456             sam_A = dpp->samplesA[0];
2457             sam_B = dpp->samplesB[0];
2458
2459             dpp->samplesA[0] = tmp = samples_r[i];
2460             samples_r[i] = tmp -= APPLY_WEIGHT_I(dpp->weightB, sam_B);
2461             update_weight_clip_d2(dpp->weightB, dpp->delta, sam_B, tmp);
2462
2463             dpp->samplesB[0] = tmp = samples_l[i];
2464             samples_l[i] = tmp -= APPLY_WEIGHT_I(dpp->weightA, sam_A);
2465             update_weight_clip_d2(dpp->weightA, dpp->delta, sam_A, tmp);
2466         }
2467         break;
2468     }
2469 }
2470
2471 static void put_metadata_block(PutByteContext *pb, int flags, int size)
2472 {
2473     if (size & 1)
2474         flags |= WP_IDF_ODD;
2475
2476     bytestream2_put_byte(pb, flags);
2477     bytestream2_put_byte(pb, (size + 1) >> 1);
2478 }
2479
2480 static int wavpack_encode_block(WavPackEncodeContext *s,
2481                                 int32_t *samples_l, int32_t *samples_r,
2482                                 uint8_t *out, int out_size)
2483 {
2484     int block_size, start, end, data_size, tcount, temp, m = 0;
2485     int i, j, ret = 0, got_extra = 0, nb_samples = s->block_samples;
2486     uint32_t crc = 0xffffffffu;
2487     struct Decorr *dpp;
2488     PutByteContext pb;
2489
2490     if (!(s->flags & WV_MONO) && s->optimize_mono) {
2491         int32_t lor = 0, diff = 0;
2492
2493         for (i = 0; i < nb_samples; i++) {
2494             lor  |= samples_l[i] | samples_r[i];
2495             diff |= samples_l[i] - samples_r[i];
2496
2497             if (lor && diff)
2498                 break;
2499         }
2500
2501         if (i == nb_samples && lor && !diff) {
2502             s->flags &= ~(WV_JOINT_STEREO | WV_CROSS_DECORR);
2503             s->flags |= WV_FALSE_STEREO;
2504
2505             if (!s->false_stereo) {
2506                 s->false_stereo = 1;
2507                 s->num_terms = 0;
2508                 CLEAR(s->w);
2509             }
2510         } else if (s->false_stereo) {
2511             s->false_stereo = 0;
2512             s->num_terms = 0;
2513             CLEAR(s->w);
2514         }
2515     }
2516
2517     if (s->flags & SHIFT_MASK) {
2518         int shift = (s->flags & SHIFT_MASK) >> SHIFT_LSB;
2519         int mag = (s->flags & MAG_MASK) >> MAG_LSB;
2520
2521         if (s->flags & WV_MONO_DATA)
2522             shift_mono(samples_l, nb_samples, shift);
2523         else
2524             shift_stereo(samples_l, samples_r, nb_samples, shift);
2525
2526         if ((mag -= shift) < 0)
2527             s->flags &= ~MAG_MASK;
2528         else
2529             s->flags -= (1 << MAG_LSB) * shift;
2530     }
2531
2532     if ((s->flags & WV_FLOAT_DATA) || (s->flags & MAG_MASK) >> MAG_LSB >= 24) {
2533         av_fast_padded_malloc(&s->orig_l, &s->orig_l_size, sizeof(int32_t) * nb_samples);
2534         memcpy(s->orig_l, samples_l, sizeof(int32_t) * nb_samples);
2535         if (!(s->flags & WV_MONO_DATA)) {
2536             av_fast_padded_malloc(&s->orig_r, &s->orig_r_size, sizeof(int32_t) * nb_samples);
2537             memcpy(s->orig_r, samples_r, sizeof(int32_t) * nb_samples);
2538         }
2539
2540         if (s->flags & WV_FLOAT_DATA)
2541             got_extra = scan_float(s, samples_l, samples_r, nb_samples);
2542         else
2543             got_extra = scan_int32(s, samples_l, samples_r, nb_samples);
2544         s->num_terms = 0;
2545     } else {
2546         scan_int23(s, samples_l, samples_r, nb_samples);
2547         if (s->shift != s->int32_zeros + s->int32_ones + s->int32_dups) {
2548             s->shift = s->int32_zeros + s->int32_ones + s->int32_dups;
2549             s->num_terms = 0;
2550         }
2551     }
2552
2553     if (!s->num_passes && !s->num_terms) {
2554         s->num_passes = 1;
2555
2556         if (s->flags & WV_MONO_DATA)
2557             ret = wv_mono(s, samples_l, 1, 0);
2558         else
2559             ret = wv_stereo(s, samples_l, samples_r, 1, 0);
2560
2561         s->num_passes = 0;
2562     }
2563     if (s->flags & WV_MONO_DATA) {
2564         for (i = 0; i < nb_samples; i++)
2565             crc += (crc << 1) + samples_l[i];
2566
2567         if (s->num_passes)
2568             ret = wv_mono(s, samples_l, !s->num_terms, 1);
2569     } else {
2570         for (i = 0; i < nb_samples; i++)
2571             crc += (crc << 3) + (samples_l[i] << 1) + samples_l[i] + samples_r[i];
2572
2573         if (s->num_passes)
2574             ret = wv_stereo(s, samples_l, samples_r, !s->num_terms, 1);
2575     }
2576     if (ret < 0)
2577         return ret;
2578
2579     if (!s->ch_offset)
2580         s->flags |= WV_INITIAL_BLOCK;
2581
2582     s->ch_offset += 1 + !(s->flags & WV_MONO);
2583
2584     if (s->ch_offset == s->avctx->channels)
2585         s->flags |= WV_FINAL_BLOCK;
2586
2587     bytestream2_init_writer(&pb, out, out_size);
2588     bytestream2_put_le32(&pb, MKTAG('w', 'v', 'p', 'k'));
2589     bytestream2_put_le32(&pb, 0);
2590     bytestream2_put_le16(&pb, 0x410);
2591     bytestream2_put_le16(&pb, 0);
2592     bytestream2_put_le32(&pb, 0);
2593     bytestream2_put_le32(&pb, s->sample_index);
2594     bytestream2_put_le32(&pb, nb_samples);
2595     bytestream2_put_le32(&pb, s->flags);
2596     bytestream2_put_le32(&pb, crc);
2597
2598     if (s->flags & WV_INITIAL_BLOCK &&
2599         s->avctx->channel_layout != AV_CH_LAYOUT_MONO &&
2600         s->avctx->channel_layout != AV_CH_LAYOUT_STEREO) {
2601         put_metadata_block(&pb, WP_ID_CHANINFO, 5);
2602         bytestream2_put_byte(&pb, s->avctx->channels);
2603         bytestream2_put_le32(&pb, s->avctx->channel_layout);
2604         bytestream2_put_byte(&pb, 0);
2605     }
2606
2607     if ((s->flags & SRATE_MASK) == SRATE_MASK) {
2608         put_metadata_block(&pb, WP_ID_SAMPLE_RATE, 3);
2609         bytestream2_put_le24(&pb, s->avctx->sample_rate);
2610         bytestream2_put_byte(&pb, 0);
2611     }
2612
2613     put_metadata_block(&pb, WP_ID_DECTERMS, s->num_terms);
2614     for (i = 0; i < s->num_terms; i++) {
2615         struct Decorr *dpp = &s->decorr_passes[i];
2616         bytestream2_put_byte(&pb, ((dpp->value + 5) & 0x1f) | ((dpp->delta << 5) & 0xe0));
2617     }
2618     if (s->num_terms & 1)
2619         bytestream2_put_byte(&pb, 0);
2620
2621 #define WRITE_DECWEIGHT(type) do {            \
2622         temp = store_weight(type);    \
2623         bytestream2_put_byte(&pb, temp);      \
2624         type = restore_weight(temp);  \
2625     } while (0)
2626
2627     bytestream2_put_byte(&pb, WP_ID_DECWEIGHTS);
2628     bytestream2_put_byte(&pb, 0);
2629     start = bytestream2_tell_p(&pb);
2630     for (i = s->num_terms - 1; i >= 0; --i) {
2631         struct Decorr *dpp = &s->decorr_passes[i];
2632
2633         if (store_weight(dpp->weightA) ||
2634             (!(s->flags & WV_MONO_DATA) && store_weight(dpp->weightB)))
2635                 break;
2636     }
2637     tcount = i + 1;
2638     for (i = 0; i < s->num_terms; i++) {
2639         struct Decorr *dpp = &s->decorr_passes[i];
2640         if (i < tcount) {
2641             WRITE_DECWEIGHT(dpp->weightA);
2642             if (!(s->flags & WV_MONO_DATA))
2643                 WRITE_DECWEIGHT(dpp->weightB);
2644         } else {
2645             dpp->weightA = dpp->weightB = 0;
2646         }
2647     }
2648     end = bytestream2_tell_p(&pb);
2649     out[start - 2] = WP_ID_DECWEIGHTS | (((end - start) & 1) ? WP_IDF_ODD: 0);
2650     out[start - 1] = (end - start + 1) >> 1;
2651     if ((end - start) & 1)
2652         bytestream2_put_byte(&pb, 0);
2653
2654 #define WRITE_DECSAMPLE(type) do {        \
2655         temp = log2s(type);               \
2656         type = wp_exp2(temp);             \
2657         bytestream2_put_le16(&pb, temp);  \
2658     } while (0)
2659
2660     bytestream2_put_byte(&pb, WP_ID_DECSAMPLES);
2661     bytestream2_put_byte(&pb, 0);
2662     start = bytestream2_tell_p(&pb);
2663     for (i = 0; i < s->num_terms; i++) {
2664         struct Decorr *dpp = &s->decorr_passes[i];
2665         if (i == 0) {
2666             if (dpp->value > MAX_TERM) {
2667                 WRITE_DECSAMPLE(dpp->samplesA[0]);
2668                 WRITE_DECSAMPLE(dpp->samplesA[1]);
2669                 if (!(s->flags & WV_MONO_DATA)) {
2670                     WRITE_DECSAMPLE(dpp->samplesB[0]);
2671                     WRITE_DECSAMPLE(dpp->samplesB[1]);
2672                 }
2673             } else if (dpp->value < 0) {
2674                 WRITE_DECSAMPLE(dpp->samplesA[0]);
2675                 WRITE_DECSAMPLE(dpp->samplesB[0]);
2676             } else {
2677                 for (j = 0; j < dpp->value; j++) {
2678                     WRITE_DECSAMPLE(dpp->samplesA[j]);
2679                     if (!(s->flags & WV_MONO_DATA))
2680                         WRITE_DECSAMPLE(dpp->samplesB[j]);
2681                 }
2682             }
2683         } else {
2684             CLEAR(dpp->samplesA);
2685             CLEAR(dpp->samplesB);
2686         }
2687     }
2688     end = bytestream2_tell_p(&pb);
2689     out[start - 1] = (end - start) >> 1;
2690
2691 #define WRITE_CHAN_ENTROPY(chan) do {               \
2692         for (i = 0; i < 3; i++) {                   \
2693             temp = wp_log2(s->w.c[chan].median[i]); \
2694             bytestream2_put_le16(&pb, temp);        \
2695             s->w.c[chan].median[i] = wp_exp2(temp); \
2696         }                                           \
2697     } while (0)
2698
2699     put_metadata_block(&pb, WP_ID_ENTROPY, 6 * (1 + (!(s->flags & WV_MONO_DATA))));
2700     WRITE_CHAN_ENTROPY(0);
2701     if (!(s->flags & WV_MONO_DATA))
2702         WRITE_CHAN_ENTROPY(1);
2703
2704     if (s->flags & WV_FLOAT_DATA) {
2705         put_metadata_block(&pb, WP_ID_FLOATINFO, 4);
2706         bytestream2_put_byte(&pb, s->float_flags);
2707         bytestream2_put_byte(&pb, s->float_shift);
2708         bytestream2_put_byte(&pb, s->float_max_exp);
2709         bytestream2_put_byte(&pb, 127);
2710     }
2711
2712     if (s->flags & WV_INT32_DATA) {
2713         put_metadata_block(&pb, WP_ID_INT32INFO, 4);
2714         bytestream2_put_byte(&pb, s->int32_sent_bits);
2715         bytestream2_put_byte(&pb, s->int32_zeros);
2716         bytestream2_put_byte(&pb, s->int32_ones);
2717         bytestream2_put_byte(&pb, s->int32_dups);
2718     }
2719
2720     if (s->flags & WV_MONO_DATA && !s->num_passes) {
2721         for (i = 0; i < nb_samples; i++) {
2722             int32_t code = samples_l[i];
2723
2724             for (tcount = s->num_terms, dpp = s->decorr_passes; tcount--; dpp++) {
2725                 int32_t sam;
2726
2727                 if (dpp->value > MAX_TERM) {
2728                     if (dpp->value & 1)
2729                         sam = 2 * dpp->samplesA[0] - dpp->samplesA[1];
2730                     else
2731                         sam = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1;
2732
2733                     dpp->samplesA[1] = dpp->samplesA[0];
2734                     dpp->samplesA[0] = code;
2735                 } else {
2736                     sam = dpp->samplesA[m];
2737                     dpp->samplesA[(m + dpp->value) & (MAX_TERM - 1)] = code;
2738                 }
2739
2740                 code -= APPLY_WEIGHT(dpp->weightA, sam);
2741                 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, code);
2742             }
2743
2744             m = (m + 1) & (MAX_TERM - 1);
2745             samples_l[i] = code;
2746         }
2747         if (m) {
2748             for (tcount = s->num_terms, dpp = s->decorr_passes; tcount--; dpp++)
2749                 if (dpp->value > 0 && dpp->value <= MAX_TERM) {
2750                 int32_t temp_A[MAX_TERM], temp_B[MAX_TERM];
2751                 int k;
2752
2753                 memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA));
2754                 memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB));
2755
2756                 for (k = 0; k < MAX_TERM; k++) {
2757                     dpp->samplesA[k] = temp_A[m];
2758                     dpp->samplesB[k] = temp_B[m];
2759                     m = (m + 1) & (MAX_TERM - 1);
2760                 }
2761             }
2762         }
2763     } else if (!s->num_passes) {
2764         if (s->flags & WV_JOINT_STEREO) {
2765             for (i = 0; i < nb_samples; i++)
2766                 samples_r[i] += ((samples_l[i] -= samples_r[i]) >> 1);
2767         }
2768
2769         for (i = 0; i < s->num_terms; i++) {
2770             struct Decorr *dpp = &s->decorr_passes[i];
2771             if (((s->flags & MAG_MASK) >> MAG_LSB) >= 16 || dpp->delta != 2)
2772                 decorr_stereo_pass2(dpp, samples_l, samples_r, nb_samples);
2773             else
2774                 decorr_stereo_pass_id2(dpp, samples_l, samples_r, nb_samples);
2775         }
2776     }
2777
2778     bytestream2_put_byte(&pb, WP_ID_DATA | WP_IDF_LONG);
2779     init_put_bits(&s->pb, pb.buffer + 3, bytestream2_get_bytes_left_p(&pb));
2780     if (s->flags & WV_MONO_DATA) {
2781         for (i = 0; i < nb_samples; i++)
2782             wavpack_encode_sample(s, &s->w.c[0], s->samples[0][i]);
2783     } else {
2784         for (i = 0; i < nb_samples; i++) {
2785             wavpack_encode_sample(s, &s->w.c[0], s->samples[0][i]);
2786             wavpack_encode_sample(s, &s->w.c[1], s->samples[1][i]);
2787         }
2788     }
2789     encode_flush(s);
2790     flush_put_bits(&s->pb);
2791     data_size = put_bits_count(&s->pb) >> 3;
2792     bytestream2_put_le24(&pb, (data_size + 1) >> 1);
2793     bytestream2_skip_p(&pb, data_size);
2794     if (data_size & 1)
2795         bytestream2_put_byte(&pb, 0);
2796
2797     if (got_extra) {
2798         bytestream2_put_byte(&pb, WP_ID_EXTRABITS | WP_IDF_LONG);
2799         init_put_bits(&s->pb, pb.buffer + 7, bytestream2_get_bytes_left_p(&pb));
2800         if (s->flags & WV_FLOAT_DATA)
2801             pack_float(s, s->orig_l, s->orig_r, nb_samples);
2802         else
2803             pack_int32(s, s->orig_l, s->orig_r, nb_samples);
2804         flush_put_bits(&s->pb);
2805         data_size = put_bits_count(&s->pb) >> 3;
2806         bytestream2_put_le24(&pb, (data_size + 5) >> 1);
2807         bytestream2_put_le32(&pb, s->crc_x);
2808         bytestream2_skip_p(&pb, data_size);
2809         if (data_size & 1)
2810             bytestream2_put_byte(&pb, 0);
2811     }
2812
2813     block_size = bytestream2_tell_p(&pb);
2814     AV_WL32(out + 4, block_size - 8);
2815
2816     return block_size;
2817 }
2818
2819 static void fill_buffer(WavPackEncodeContext *s,
2820                         const int8_t *src, int32_t *dst,
2821                         int nb_samples)
2822 {
2823     int i;
2824
2825 #define COPY_SAMPLES(type, offset, shift) do {            \
2826         const type *sptr = (const type *)src;             \
2827         for (i = 0; i < nb_samples; i++)                  \
2828             dst[i] = (sptr[i] - offset) >> shift;         \
2829     } while (0)
2830
2831     switch (s->avctx->sample_fmt) {
2832     case AV_SAMPLE_FMT_U8P:
2833         COPY_SAMPLES(int8_t, 0x80, 0);
2834         break;
2835     case AV_SAMPLE_FMT_S16P:
2836         COPY_SAMPLES(int16_t, 0, 0);
2837         break;
2838     case AV_SAMPLE_FMT_S32P:
2839         if (s->avctx->bits_per_raw_sample <= 24) {
2840             COPY_SAMPLES(int32_t, 0, 8);
2841             break;
2842         }
2843     case AV_SAMPLE_FMT_FLTP:
2844         memcpy(dst, src, nb_samples * 4);
2845     }
2846 }
2847
2848 static void set_samplerate(WavPackEncodeContext *s)
2849 {
2850     int i;
2851
2852     for (i = 0; i < 15; i++) {
2853         if (wv_rates[i] == s->avctx->sample_rate)
2854             break;
2855     }
2856
2857     s->flags = i << SRATE_LSB;
2858 }
2859
2860 static int wavpack_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
2861                                 const AVFrame *frame, int *got_packet_ptr)
2862 {
2863     WavPackEncodeContext *s = avctx->priv_data;
2864     int buf_size, ret;
2865     uint8_t *buf;
2866
2867     s->block_samples = frame->nb_samples;
2868     av_fast_padded_malloc(&s->samples[0], &s->samples_size[0],
2869                           sizeof(int32_t) * s->block_samples);
2870     if (!s->samples[0])
2871         return AVERROR(ENOMEM);
2872     if (avctx->channels > 1) {
2873         av_fast_padded_malloc(&s->samples[1], &s->samples_size[1],
2874                               sizeof(int32_t) * s->block_samples);
2875         if (!s->samples[1])
2876             return AVERROR(ENOMEM);
2877     }
2878
2879     if ((ret = ff_alloc_packet2(avctx, avpkt, s->block_samples * avctx->channels * 8)) < 0)
2880         return ret;
2881     buf = avpkt->data;
2882     buf_size = avpkt->size;
2883
2884     for (s->ch_offset = 0; s->ch_offset < avctx->channels;) {
2885         set_samplerate(s);
2886
2887         switch (s->avctx->sample_fmt) {
2888         case AV_SAMPLE_FMT_S16P: s->flags |= 1; break;
2889         case AV_SAMPLE_FMT_S32P: s->flags |= 3 - (s->avctx->bits_per_raw_sample <= 24); break;
2890         case AV_SAMPLE_FMT_FLTP: s->flags |= 3 | WV_FLOAT_DATA;
2891         }
2892
2893         fill_buffer(s, frame->extended_data[s->ch_offset], s->samples[0], s->block_samples);
2894         if (avctx->channels - s->ch_offset == 1) {
2895             s->flags |= WV_MONO;
2896         } else {
2897             s->flags |= WV_CROSS_DECORR;
2898             fill_buffer(s, frame->extended_data[s->ch_offset + 1], s->samples[1], s->block_samples);
2899         }
2900
2901         s->flags += (1 << MAG_LSB) * ((s->flags & 3) * 8 + 7);
2902
2903         if ((ret = wavpack_encode_block(s, s->samples[0], s->samples[1],
2904                                         buf, buf_size)) < 0)
2905             return ret;
2906
2907         buf      += ret;
2908         buf_size -= ret;
2909     }
2910     s->sample_index += frame->nb_samples;
2911
2912     avpkt->pts      = frame->pts;
2913     avpkt->size     = buf - avpkt->data;
2914     avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples);
2915     *got_packet_ptr = 1;
2916     return 0;
2917 }
2918
2919 static av_cold int wavpack_encode_close(AVCodecContext *avctx)
2920 {
2921     WavPackEncodeContext *s = avctx->priv_data;
2922     int i;
2923
2924     for (i = 0; i < MAX_TERMS + 2; i++) {
2925         av_freep(&s->sampleptrs[i][0]);
2926         av_freep(&s->sampleptrs[i][1]);
2927         s->sampleptrs_size[i][0] = s->sampleptrs_size[i][1] = 0;
2928     }
2929
2930     for (i = 0; i < 2; i++) {
2931         av_freep(&s->samples[i]);
2932         s->samples_size[i] = 0;
2933
2934         av_freep(&s->best_buffer[i]);
2935         s->best_buffer_size[i] = 0;
2936
2937         av_freep(&s->temp_buffer[i][0]);
2938         av_freep(&s->temp_buffer[i][1]);
2939         s->temp_buffer_size[i][0] = s->temp_buffer_size[i][1] = 0;
2940     }
2941
2942     av_freep(&s->js_left);
2943     av_freep(&s->js_right);
2944     s->js_left_size = s->js_right_size = 0;
2945
2946     av_freep(&s->orig_l);
2947     av_freep(&s->orig_r);
2948     s->orig_l_size = s->orig_r_size = 0;
2949
2950     return 0;
2951 }
2952
2953 #define OFFSET(x) offsetof(WavPackEncodeContext, x)
2954 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
2955 static const AVOption options[] = {
2956     { "joint_stereo",  "", OFFSET(joint), AV_OPT_TYPE_INT, {.i64=0},-1, 1, FLAGS, "joint" },
2957     { "on",   "mid/side",   0, AV_OPT_TYPE_CONST, {.i64= 1}, 0, 0, FLAGS, "joint"},
2958     { "off",  "left/right", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, FLAGS, "joint"},
2959     { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 0}, 0, 0, FLAGS, "joint"},
2960     { "optimize_mono",        "", OFFSET(optimize_mono), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "opt_mono" },
2961     { "on",   NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "opt_mono"},
2962     { "off",  NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "opt_mono"},
2963     { NULL },
2964 };
2965
2966 static const AVClass wavpack_encoder_class = {
2967     .class_name = "WavPack encoder",
2968     .item_name  = av_default_item_name,
2969     .option     = options,
2970     .version    = LIBAVUTIL_VERSION_INT,
2971 };
2972
2973 AVCodec ff_wavpack_encoder = {
2974     .name           = "wavpack",
2975     .long_name      = NULL_IF_CONFIG_SMALL("WavPack"),
2976     .type           = AVMEDIA_TYPE_AUDIO,
2977     .id             = AV_CODEC_ID_WAVPACK,
2978     .priv_data_size = sizeof(WavPackEncodeContext),
2979     .priv_class     = &wavpack_encoder_class,
2980     .init           = wavpack_encode_init,
2981     .encode2        = wavpack_encode_frame,
2982     .close          = wavpack_encode_close,
2983     .capabilities   = CODEC_CAP_SMALL_LAST_FRAME,
2984     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_U8P,
2985                                                      AV_SAMPLE_FMT_S16P,
2986                                                      AV_SAMPLE_FMT_S32P,
2987                                                      AV_SAMPLE_FMT_FLTP,
2988                                                      AV_SAMPLE_FMT_NONE },
2989 };