FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/wavpackenc.c
Date: 2021-09-16 08:47:15
Exec Total Coverage
Lines: 791 1746 45.3%
Branches: 551 1441 38.2%

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