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