repositories / deb_ffmpeg.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Debian version 2.4.3~trusty1
[deb_ffmpeg.git] / ffmpeg / libavcodec / wavpackenc.c
CommitLineData
2ba45a60
DM		 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 > WV_MAX_SAMPLES)
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_DATA) {
2491 CLEAR(s->w);
2492 }
2493 if (!(s->flags & WV_MONO) && s->optimize_mono) {
2494 int32_t lor = 0, diff = 0;
2495
2496 for (i = 0; i < nb_samples; i++) {
2497 lor |= samples_l[i] | samples_r[i];
2498 diff |= samples_l[i] - samples_r[i];
2499
2500 if (lor && diff)
2501 break;
2502 }
2503
2504 if (i == nb_samples && lor && !diff) {
2505 s->flags &= ~(WV_JOINT_STEREO | WV_CROSS_DECORR);
2506 s->flags |= WV_FALSE_STEREO;
2507
2508 if (!s->false_stereo) {
2509 s->false_stereo = 1;
2510 s->num_terms = 0;
2511 CLEAR(s->w);
2512 }
2513 } else if (s->false_stereo) {
2514 s->false_stereo = 0;
2515 s->num_terms = 0;
2516 CLEAR(s->w);
2517 }
2518 }
2519
2520 if (s->flags & SHIFT_MASK) {
2521 int shift = (s->flags & SHIFT_MASK) >> SHIFT_LSB;
2522 int mag = (s->flags & MAG_MASK) >> MAG_LSB;
2523
2524 if (s->flags & WV_MONO_DATA)
2525 shift_mono(samples_l, nb_samples, shift);
2526 else
2527 shift_stereo(samples_l, samples_r, nb_samples, shift);
2528
2529 if ((mag -= shift) < 0)
2530 s->flags &= ~MAG_MASK;
2531 else
2532 s->flags -= (1 << MAG_LSB) * shift;
2533 }
2534
2535 if ((s->flags & WV_FLOAT_DATA) || (s->flags & MAG_MASK) >> MAG_LSB >= 24) {
2536 av_fast_padded_malloc(&s->orig_l, &s->orig_l_size, sizeof(int32_t) * nb_samples);
2537 memcpy(s->orig_l, samples_l, sizeof(int32_t) * nb_samples);
2538 if (!(s->flags & WV_MONO_DATA)) {
2539 av_fast_padded_malloc(&s->orig_r, &s->orig_r_size, sizeof(int32_t) * nb_samples);
2540 memcpy(s->orig_r, samples_r, sizeof(int32_t) * nb_samples);
2541 }
2542
2543 if (s->flags & WV_FLOAT_DATA)
2544 got_extra = scan_float(s, samples_l, samples_r, nb_samples);
2545 else
2546 got_extra = scan_int32(s, samples_l, samples_r, nb_samples);
2547 s->num_terms = 0;
2548 } else {
2549 scan_int23(s, samples_l, samples_r, nb_samples);
2550 if (s->shift != s->int32_zeros + s->int32_ones + s->int32_dups) {
2551 s->shift = s->int32_zeros + s->int32_ones + s->int32_dups;
2552 s->num_terms = 0;
2553 }
2554 }
2555
2556 if (!s->num_passes && !s->num_terms) {
2557 s->num_passes = 1;
2558
2559 if (s->flags & WV_MONO_DATA)
2560 ret = wv_mono(s, samples_l, 1, 0);
2561 else
2562 ret = wv_stereo(s, samples_l, samples_r, 1, 0);
2563
2564 s->num_passes = 0;
2565 }
2566 if (s->flags & WV_MONO_DATA) {
2567 for (i = 0; i < nb_samples; i++)
2568 crc += (crc << 1) + samples_l[i];
2569
2570 if (s->num_passes)
2571 ret = wv_mono(s, samples_l, !s->num_terms, 1);
2572 } else {
2573 for (i = 0; i < nb_samples; i++)
2574 crc += (crc << 3) + (samples_l[i] << 1) + samples_l[i] + samples_r[i];
2575
2576 if (s->num_passes)
2577 ret = wv_stereo(s, samples_l, samples_r, !s->num_terms, 1);
2578 }
2579 if (ret < 0)
2580 return ret;
2581
2582 if (!s->ch_offset)
2583 s->flags |= WV_INITIAL_BLOCK;
2584
2585 s->ch_offset += 1 + !(s->flags & WV_MONO);
2586
2587 if (s->ch_offset == s->avctx->channels)
2588 s->flags |= WV_FINAL_BLOCK;
2589
2590 bytestream2_init_writer(&pb, out, out_size);
2591 bytestream2_put_le32(&pb, MKTAG('w', 'v', 'p', 'k'));
2592 bytestream2_put_le32(&pb, 0);
2593 bytestream2_put_le16(&pb, 0x410);
2594 bytestream2_put_le16(&pb, 0);
2595 bytestream2_put_le32(&pb, 0);
2596 bytestream2_put_le32(&pb, s->sample_index);
2597 bytestream2_put_le32(&pb, nb_samples);
2598 bytestream2_put_le32(&pb, s->flags);
2599 bytestream2_put_le32(&pb, crc);
2600
2601 if (s->flags & WV_INITIAL_BLOCK &&
2602 s->avctx->channel_layout != AV_CH_LAYOUT_MONO &&
2603 s->avctx->channel_layout != AV_CH_LAYOUT_STEREO) {
2604 put_metadata_block(&pb, WP_ID_CHANINFO, 5);
2605 bytestream2_put_byte(&pb, s->avctx->channels);
2606 bytestream2_put_le32(&pb, s->avctx->channel_layout);
2607 bytestream2_put_byte(&pb, 0);
2608 }
2609
2610 if ((s->flags & SRATE_MASK) == SRATE_MASK) {
2611 put_metadata_block(&pb, WP_ID_SAMPLE_RATE, 3);
2612 bytestream2_put_le24(&pb, s->avctx->sample_rate);
2613 bytestream2_put_byte(&pb, 0);
2614 }
2615
2616 put_metadata_block(&pb, WP_ID_DECTERMS, s->num_terms);
2617 for (i = 0; i < s->num_terms; i++) {
2618 struct Decorr *dpp = &s->decorr_passes[i];
2619 bytestream2_put_byte(&pb, ((dpp->value + 5) & 0x1f) | ((dpp->delta << 5) & 0xe0));
2620 }
2621 if (s->num_terms & 1)
2622 bytestream2_put_byte(&pb, 0);
2623
2624#define WRITE_DECWEIGHT(type) do { \
2625 temp = store_weight(type); \
2626 bytestream2_put_byte(&pb, temp); \
2627 type = restore_weight(temp); \
2628 } while (0)
2629
2630 bytestream2_put_byte(&pb, WP_ID_DECWEIGHTS);
2631 bytestream2_put_byte(&pb, 0);
2632 start = bytestream2_tell_p(&pb);
2633 for (i = s->num_terms - 1; i >= 0; --i) {
2634 struct Decorr *dpp = &s->decorr_passes[i];
2635
2636 if (store_weight(dpp->weightA) ||
2637 (!(s->flags & WV_MONO_DATA) && store_weight(dpp->weightB)))
2638 break;
2639 }
2640 tcount = i + 1;
2641 for (i = 0; i < s->num_terms; i++) {
2642 struct Decorr *dpp = &s->decorr_passes[i];
2643 if (i < tcount) {
2644 WRITE_DECWEIGHT(dpp->weightA);
2645 if (!(s->flags & WV_MONO_DATA))
2646 WRITE_DECWEIGHT(dpp->weightB);
2647 } else {
2648 dpp->weightA = dpp->weightB = 0;
2649 }
2650 }
2651 end = bytestream2_tell_p(&pb);
2652 out[start - 2] = WP_ID_DECWEIGHTS | (((end - start) & 1) ? WP_IDF_ODD: 0);
2653 out[start - 1] = (end - start + 1) >> 1;
2654 if ((end - start) & 1)
2655 bytestream2_put_byte(&pb, 0);
2656
2657#define WRITE_DECSAMPLE(type) do { \
2658 temp = log2s(type); \
2659 type = wp_exp2(temp); \
2660 bytestream2_put_le16(&pb, temp); \
2661 } while (0)
2662
2663 bytestream2_put_byte(&pb, WP_ID_DECSAMPLES);
2664 bytestream2_put_byte(&pb, 0);
2665 start = bytestream2_tell_p(&pb);
2666 for (i = 0; i < s->num_terms; i++) {
2667 struct Decorr *dpp = &s->decorr_passes[i];
2668 if (i == 0) {
2669 if (dpp->value > MAX_TERM) {
2670 WRITE_DECSAMPLE(dpp->samplesA[0]);
2671 WRITE_DECSAMPLE(dpp->samplesA[1]);
2672 if (!(s->flags & WV_MONO_DATA)) {
2673 WRITE_DECSAMPLE(dpp->samplesB[0]);
2674 WRITE_DECSAMPLE(dpp->samplesB[1]);
2675 }
2676 } else if (dpp->value < 0) {
2677 WRITE_DECSAMPLE(dpp->samplesA[0]);
2678 WRITE_DECSAMPLE(dpp->samplesB[0]);
2679 } else {
2680 for (j = 0; j < dpp->value; j++) {
2681 WRITE_DECSAMPLE(dpp->samplesA[j]);
2682 if (!(s->flags & WV_MONO_DATA))
2683 WRITE_DECSAMPLE(dpp->samplesB[j]);
2684 }
2685 }
2686 } else {
2687 CLEAR(dpp->samplesA);
2688 CLEAR(dpp->samplesB);
2689 }
2690 }
2691 end = bytestream2_tell_p(&pb);
2692 out[start - 1] = (end - start) >> 1;
2693
2694#define WRITE_CHAN_ENTROPY(chan) do { \
2695 for (i = 0; i < 3; i++) { \
2696 temp = wp_log2(s->w.c[chan].median[i]); \
2697 bytestream2_put_le16(&pb, temp); \
2698 s->w.c[chan].median[i] = wp_exp2(temp); \
2699 } \
2700 } while (0)
2701
2702 put_metadata_block(&pb, WP_ID_ENTROPY, 6 * (1 + (!(s->flags & WV_MONO_DATA))));
2703 WRITE_CHAN_ENTROPY(0);
2704 if (!(s->flags & WV_MONO_DATA))
2705 WRITE_CHAN_ENTROPY(1);
2706
2707 if (s->flags & WV_FLOAT_DATA) {
2708 put_metadata_block(&pb, WP_ID_FLOATINFO, 4);
2709 bytestream2_put_byte(&pb, s->float_flags);
2710 bytestream2_put_byte(&pb, s->float_shift);
2711 bytestream2_put_byte(&pb, s->float_max_exp);
2712 bytestream2_put_byte(&pb, 127);
2713 }
2714
2715 if (s->flags & WV_INT32_DATA) {
2716 put_metadata_block(&pb, WP_ID_INT32INFO, 4);
2717 bytestream2_put_byte(&pb, s->int32_sent_bits);
2718 bytestream2_put_byte(&pb, s->int32_zeros);
2719 bytestream2_put_byte(&pb, s->int32_ones);
2720 bytestream2_put_byte(&pb, s->int32_dups);
2721 }
2722
2723 if (s->flags & WV_MONO_DATA && !s->num_passes) {
2724 for (i = 0; i < nb_samples; i++) {
2725 int32_t code = samples_l[i];
2726
2727 for (tcount = s->num_terms, dpp = s->decorr_passes; tcount--; dpp++) {
2728 int32_t sam;
2729
2730 if (dpp->value > MAX_TERM) {
2731 if (dpp->value & 1)
2732 sam = 2 * dpp->samplesA[0] - dpp->samplesA[1];
2733 else
2734 sam = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1;
2735
2736 dpp->samplesA[1] = dpp->samplesA[0];
2737 dpp->samplesA[0] = code;
2738 } else {
2739 sam = dpp->samplesA[m];
2740 dpp->samplesA[(m + dpp->value) & (MAX_TERM - 1)] = code;
2741 }
2742
2743 code -= APPLY_WEIGHT(dpp->weightA, sam);
2744 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, code);
2745 }
2746
2747 m = (m + 1) & (MAX_TERM - 1);
2748 samples_l[i] = code;
2749 }
2750 if (m) {
2751 for (tcount = s->num_terms, dpp = s->decorr_passes; tcount--; dpp++)
2752 if (dpp->value > 0 && dpp->value <= MAX_TERM) {
2753 int32_t temp_A[MAX_TERM], temp_B[MAX_TERM];
2754 int k;
2755
2756 memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA));
2757 memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB));
2758
2759 for (k = 0; k < MAX_TERM; k++) {
2760 dpp->samplesA[k] = temp_A[m];
2761 dpp->samplesB[k] = temp_B[m];
2762 m = (m + 1) & (MAX_TERM - 1);
2763 }
2764 }
2765 }
2766 } else if (!s->num_passes) {
2767 if (s->flags & WV_JOINT_STEREO) {
2768 for (i = 0; i < nb_samples; i++)
2769 samples_r[i] += ((samples_l[i] -= samples_r[i]) >> 1);
2770 }
2771
2772 for (i = 0; i < s->num_terms; i++) {
2773 struct Decorr *dpp = &s->decorr_passes[i];
2774 if (((s->flags & MAG_MASK) >> MAG_LSB) >= 16 || dpp->delta != 2)
2775 decorr_stereo_pass2(dpp, samples_l, samples_r, nb_samples);
2776 else
2777 decorr_stereo_pass_id2(dpp, samples_l, samples_r, nb_samples);
2778 }
2779 }
2780
2781 bytestream2_put_byte(&pb, WP_ID_DATA | WP_IDF_LONG);
2782 init_put_bits(&s->pb, pb.buffer + 3, bytestream2_get_bytes_left_p(&pb));
2783 if (s->flags & WV_MONO_DATA) {
2784 for (i = 0; i < nb_samples; i++)
2785 wavpack_encode_sample(s, &s->w.c[0], s->samples[0][i]);
2786 } else {
2787 for (i = 0; i < nb_samples; i++) {
2788 wavpack_encode_sample(s, &s->w.c[0], s->samples[0][i]);
2789 wavpack_encode_sample(s, &s->w.c[1], s->samples[1][i]);
2790 }
2791 }
2792 encode_flush(s);
2793 flush_put_bits(&s->pb);
2794 data_size = put_bits_count(&s->pb) >> 3;
2795 bytestream2_put_le24(&pb, (data_size + 1) >> 1);
2796 bytestream2_skip_p(&pb, data_size);
2797 if (data_size & 1)
2798 bytestream2_put_byte(&pb, 0);
2799
2800 if (got_extra) {
2801 bytestream2_put_byte(&pb, WP_ID_EXTRABITS | WP_IDF_LONG);
2802 init_put_bits(&s->pb, pb.buffer + 7, bytestream2_get_bytes_left_p(&pb));
2803 if (s->flags & WV_FLOAT_DATA)
2804 pack_float(s, s->orig_l, s->orig_r, nb_samples);
2805 else
2806 pack_int32(s, s->orig_l, s->orig_r, nb_samples);
2807 flush_put_bits(&s->pb);
2808 data_size = put_bits_count(&s->pb) >> 3;
2809 bytestream2_put_le24(&pb, (data_size + 5) >> 1);
2810 bytestream2_put_le32(&pb, s->crc_x);
2811 bytestream2_skip_p(&pb, data_size);
2812 if (data_size & 1)
2813 bytestream2_put_byte(&pb, 0);
2814 }
2815
2816 block_size = bytestream2_tell_p(&pb);
2817 AV_WL32(out + 4, block_size - 8);
2818
2819 av_assert0(!bytestream2_get_eof(&pb));
2820
2821 return block_size;
2822}
2823
2824static void fill_buffer(WavPackEncodeContext *s,
2825 const int8_t *src, int32_t *dst,
2826 int nb_samples)
2827{
2828 int i;
2829
2830#define COPY_SAMPLES(type, offset, shift) do { \
2831 const type *sptr = (const type *)src; \
2832 for (i = 0; i < nb_samples; i++) \
2833 dst[i] = (sptr[i] - offset) >> shift; \
2834 } while (0)
2835
2836 switch (s->avctx->sample_fmt) {
2837 case AV_SAMPLE_FMT_U8P:
2838 COPY_SAMPLES(int8_t, 0x80, 0);
2839 break;
2840 case AV_SAMPLE_FMT_S16P:
2841 COPY_SAMPLES(int16_t, 0, 0);
2842 break;
2843 case AV_SAMPLE_FMT_S32P:
2844 if (s->avctx->bits_per_raw_sample <= 24) {
2845 COPY_SAMPLES(int32_t, 0, 8);
2846 break;
2847 }
2848 case AV_SAMPLE_FMT_FLTP:
2849 memcpy(dst, src, nb_samples * 4);
2850 }
2851}
2852
2853static void set_samplerate(WavPackEncodeContext *s)
2854{
2855 int i;
2856
2857 for (i = 0; i < 15; i++) {
2858 if (wv_rates[i] == s->avctx->sample_rate)
2859 break;
2860 }
2861
2862 s->flags = i << SRATE_LSB;
2863}
2864
2865static int wavpack_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
2866 const AVFrame *frame, int *got_packet_ptr)
2867{
2868 WavPackEncodeContext *s = avctx->priv_data;
2869 int buf_size, ret;
2870 uint8_t *buf;
2871
2872 s->block_samples = frame->nb_samples;
2873 av_fast_padded_malloc(&s->samples[0], &s->samples_size[0],
2874 sizeof(int32_t) * s->block_samples);
2875 if (!s->samples[0])
2876 return AVERROR(ENOMEM);
2877 if (avctx->channels > 1) {
2878 av_fast_padded_malloc(&s->samples[1], &s->samples_size[1],
2879 sizeof(int32_t) * s->block_samples);
2880 if (!s->samples[1])
2881 return AVERROR(ENOMEM);
2882 }
2883
2884 buf_size = s->block_samples * avctx->channels * 8
2885 + 200 /* for headers */;
2886 if ((ret = ff_alloc_packet2(avctx, avpkt, buf_size)) < 0)
2887 return ret;
2888 buf = avpkt->data;
2889
2890 for (s->ch_offset = 0; s->ch_offset < avctx->channels;) {
2891 set_samplerate(s);
2892
2893 switch (s->avctx->sample_fmt) {
2894 case AV_SAMPLE_FMT_S16P: s->flags |= 1; break;
2895 case AV_SAMPLE_FMT_S32P: s->flags |= 3 - (s->avctx->bits_per_raw_sample <= 24); break;
2896 case AV_SAMPLE_FMT_FLTP: s->flags |= 3 | WV_FLOAT_DATA;
2897 }
2898
2899 fill_buffer(s, frame->extended_data[s->ch_offset], s->samples[0], s->block_samples);
2900 if (avctx->channels - s->ch_offset == 1) {
2901 s->flags |= WV_MONO;
2902 } else {
2903 s->flags |= WV_CROSS_DECORR;
2904 fill_buffer(s, frame->extended_data[s->ch_offset + 1], s->samples[1], s->block_samples);
2905 }
2906
2907 s->flags += (1 << MAG_LSB) * ((s->flags & 3) * 8 + 7);
2908
2909 if ((ret = wavpack_encode_block(s, s->samples[0], s->samples[1],
2910 buf, buf_size)) < 0)
2911 return ret;
2912
2913 buf += ret;
2914 buf_size -= ret;
2915 }
2916 s->sample_index += frame->nb_samples;
2917
2918 avpkt->pts = frame->pts;
2919 avpkt->size = buf - avpkt->data;
2920 avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples);
2921 *got_packet_ptr = 1;
2922 return 0;
2923}
2924
2925static av_cold int wavpack_encode_close(AVCodecContext *avctx)
2926{
2927 WavPackEncodeContext *s = avctx->priv_data;
2928 int i;
2929
2930 for (i = 0; i < MAX_TERMS + 2; i++) {
2931 av_freep(&s->sampleptrs[i][0]);
2932 av_freep(&s->sampleptrs[i][1]);
2933 s->sampleptrs_size[i][0] = s->sampleptrs_size[i][1] = 0;
2934 }
2935
2936 for (i = 0; i < 2; i++) {
2937 av_freep(&s->samples[i]);
2938 s->samples_size[i] = 0;
2939
2940 av_freep(&s->best_buffer[i]);
2941 s->best_buffer_size[i] = 0;
2942
2943 av_freep(&s->temp_buffer[i][0]);
2944 av_freep(&s->temp_buffer[i][1]);
2945 s->temp_buffer_size[i][0] = s->temp_buffer_size[i][1] = 0;
2946 }
2947
2948 av_freep(&s->js_left);
2949 av_freep(&s->js_right);
2950 s->js_left_size = s->js_right_size = 0;
2951
2952 av_freep(&s->orig_l);
2953 av_freep(&s->orig_r);
2954 s->orig_l_size = s->orig_r_size = 0;
2955
2956 return 0;
2957}
2958
2959#define OFFSET(x) offsetof(WavPackEncodeContext, x)
2960#define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
2961static const AVOption options[] = {
2962 { "joint_stereo", "", OFFSET(joint), AV_OPT_TYPE_INT, {.i64=0},-1, 1, FLAGS, "joint" },
2963 { "on", "mid/side", 0, AV_OPT_TYPE_CONST, {.i64= 1}, 0, 0, FLAGS, "joint"},
2964 { "off", "left/right", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, FLAGS, "joint"},
2965 { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 0}, 0, 0, FLAGS, "joint"},
2966 { "optimize_mono", "", OFFSET(optimize_mono), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "opt_mono" },
2967 { "on", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "opt_mono"},
2968 { "off", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "opt_mono"},
2969 { NULL },
2970};
2971
2972static const AVClass wavpack_encoder_class = {
2973 .class_name = "WavPack encoder",
2974 .item_name = av_default_item_name,
2975 .option = options,
2976 .version = LIBAVUTIL_VERSION_INT,
2977};
2978
2979AVCodec ff_wavpack_encoder = {
2980 .name = "wavpack",
2981 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
2982 .type = AVMEDIA_TYPE_AUDIO,
2983 .id = AV_CODEC_ID_WAVPACK,
2984 .priv_data_size = sizeof(WavPackEncodeContext),
2985 .priv_class = &wavpack_encoder_class,
2986 .init = wavpack_encode_init,
2987 .encode2 = wavpack_encode_frame,
2988 .close = wavpack_encode_close,
2989 .capabilities = CODEC_CAP_SMALL_LAST_FRAME,
2990 .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_U8P,
2991 AV_SAMPLE_FMT_S16P,
2992 AV_SAMPLE_FMT_S32P,
2993 AV_SAMPLE_FMT_FLTP,
2994 AV_SAMPLE_FMT_NONE },
2995};
ffmpeg Piment Noir Debian package repository