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