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