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