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 {
73 } WavPackWords;
74 
75 typedef struct WavPackEncodeContext {
76  AVClass *class;
83  int ch_offset;
84 
86  int samples_size[2];
87 
90 
92  int temp_buffer_size[2][2];
93 
96 
99 
102 
103  unsigned extra_flags;
106  int joint;
108 
109  uint32_t flags;
110  uint32_t crc_x;
112 
117 
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 
187  s->num_decorrs = decorr_filter_sizes[s->decorr_filter];
188  s->decorr_specs = decorr_filters[s->decorr_filter];
189 
190  s->delta_decay = 2.0;
191 
192  return 0;
193 }
194 
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) {
228  s->float_flags |= FLOAT_EXCEPTIONS;
229  value = 0x1000000;
230  shift_count = 0;
231  } else if (get_exponent(f)) {
232  shift_count = s->max_exp - get_exponent(f);
233  value = 0x800000 + get_mantissa(f);
234  } else {
235  shift_count = s->max_exp ? s->max_exp - 1 : 0;
236  value = get_mantissa(f);
237  }
238 
239  if (shift_count < 25)
240  value >>= shift_count;
241  else
242  value = 0;
243 
244  if (!value) {
245  if (get_exponent(f) || get_mantissa(f))
246  s->false_zeros++;
247  else if (get_sign(f))
248  s->neg_zeros++;
249  } else if (shift_count) {
250  int32_t mask = (1 << shift_count) - 1;
251 
252  if (!(get_mantissa(f) & mask))
253  s->shifted_zeros++;
254  else if ((get_mantissa(f) & mask) == mask)
255  s->shifted_ones++;
256  else
257  s->shifted_both++;
258  }
259 
260  s->ordata |= value;
261  *sample = get_sign(f) ? -value : value;
262 }
263 
265  int32_t *samples_l, int32_t *samples_r,
266  int nb_samples)
267 {
268  uint32_t crc = 0xffffffffu;
269  int i;
270 
271  s->shifted_ones = s->shifted_zeros = s->shifted_both = s->ordata = 0;
272  s->float_shift = s->float_flags = 0;
273  s->false_zeros = s->neg_zeros = 0;
274  s->max_exp = 0;
275 
276  if (s->flags & WV_MONO_DATA) {
277  for (i = 0; i < nb_samples; i++) {
278  int32_t f = samples_l[i];
279  crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f);
280 
281  if (get_exponent(f) > s->max_exp && get_exponent(f) < 255)
282  s->max_exp = get_exponent(f);
283  }
284  } else {
285  for (i = 0; i < nb_samples; i++) {
286  int32_t f;
287 
288  f = samples_l[i];
289  crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f);
290  if (get_exponent(f) > s->max_exp && get_exponent(f) < 255)
291  s->max_exp = get_exponent(f);
292 
293  f = samples_r[i];
294  crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f);
295 
296  if (get_exponent(f) > s->max_exp && get_exponent(f) < 255)
297  s->max_exp = get_exponent(f);
298  }
299  }
300 
301  s->crc_x = crc;
302 
303  if (s->flags & WV_MONO_DATA) {
304  for (i = 0; i < nb_samples; i++)
305  process_float(s, &samples_l[i]);
306  } else {
307  for (i = 0; i < nb_samples; i++) {
308  process_float(s, &samples_l[i]);
309  process_float(s, &samples_r[i]);
310  }
311  }
312 
313  s->float_max_exp = s->max_exp;
314 
315  if (s->shifted_both)
316  s->float_flags |= FLOAT_SHIFT_SENT;
317  else if (s->shifted_ones && !s->shifted_zeros)
318  s->float_flags |= FLOAT_SHIFT_ONES;
319  else if (s->shifted_ones && s->shifted_zeros)
320  s->float_flags |= FLOAT_SHIFT_SAME;
321  else if (s->ordata && !(s->ordata & 1)) {
322  do {
323  s->float_shift++;
324  s->ordata >>= 1;
325  } while (!(s->ordata & 1));
326 
327  if (s->flags & WV_MONO_DATA)
328  shift_mono(samples_l, nb_samples, s->float_shift);
329  else
330  shift_stereo(samples_l, samples_r, nb_samples, s->float_shift);
331  }
332 
333  s->flags &= ~MAG_MASK;
334 
335  while (s->ordata) {
336  s->flags += 1 << MAG_LSB;
337  s->ordata >>= 1;
338  }
339 
340  if (s->false_zeros || s->neg_zeros)
341  s->float_flags |= FLOAT_ZEROS_SENT;
342 
343  if (s->neg_zeros)
344  s->float_flags |= FLOAT_NEG_ZEROS;
345 
346  return s->float_flags & (FLOAT_EXCEPTIONS | FLOAT_ZEROS_SENT |
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) + ff_wp_log2_table[(v << (9 - dbits)) & 0xff];
648  } else {
649  *result += dbits = (dbits << 8) + ff_wp_log2_table[(v >> (dbits - 9)) & 0xff];
650 
651  if (limit && dbits >= limit)
652  return 1;
653  }
654 
655  return 0;
656 }
657 
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 
882 static int allocate_buffers2(WavPackEncodeContext *s, int nterms)
883 {
884  int i;
885 
886  for (i = 0; i < nterms + 2; i++) {
887  av_fast_padded_malloc(&s->sampleptrs[i][0], &s->sampleptrs_size[i][0],
888  s->block_samples * 4);
889  if (!s->sampleptrs[i][0])
890  return AVERROR(ENOMEM);
891  if (!(s->flags & WV_MONO_DATA)) {
892  av_fast_padded_malloc(&s->sampleptrs[i][1], &s->sampleptrs_size[i][1],
893  s->block_samples * 4);
894  if (!s->sampleptrs[i][1])
895  return AVERROR(ENOMEM);
896  }
897  }
898 
899  return 0;
900 }
901 
903 {
904  int i;
905 
906  for (i = 0; i < 2; i++) {
907  av_fast_padded_malloc(&s->best_buffer[0], &s->best_buffer_size[0],
908  s->block_samples * 4);
909  if (!s->best_buffer[0])
910  return AVERROR(ENOMEM);
911 
912  av_fast_padded_malloc(&s->temp_buffer[i][0], &s->temp_buffer_size[i][0],
913  s->block_samples * 4);
914  if (!s->temp_buffer[i][0])
915  return AVERROR(ENOMEM);
916  if (!(s->flags & WV_MONO_DATA)) {
917  av_fast_padded_malloc(&s->best_buffer[1], &s->best_buffer_size[1],
918  s->block_samples * 4);
919  if (!s->best_buffer[1])
920  return AVERROR(ENOMEM);
921 
922  av_fast_padded_malloc(&s->temp_buffer[i][1], &s->temp_buffer_size[i][1],
923  s->block_samples * 4);
924  if (!s->temp_buffer[i][1])
925  return AVERROR(ENOMEM);
926  }
927  }
928 
929  return 0;
930 }
931 
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 
965  if ((s->extra_flags & EXTRA_ADJUST_DELTAS) && s->decorr_passes[0].value)
966  s->delta_decay = (float)((s->delta_decay * 2.0 + s->decorr_passes[0].delta) / 3.0);
967  else
968  s->delta_decay = 2.0;
969  }
970 
971  if (s->extra_flags & EXTRA_SORT_LAST)
972  sort_mono(s, &info);
973 
974  if (do_samples)
975  memcpy(samples, s->sampleptrs[info.nterms + 1][0], s->block_samples * 4);
976 
977  for (i = 0; i < info.nterms; i++)
978  if (!s->decorr_passes[i].value)
979  break;
980 
981  s->num_terms = i;
982 }
983 
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) {
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++)
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];
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;
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;
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 ||
1957  s->joint_stereo != s->decorr_specs[s->best_decorr].joint_stereo) {
1958  s->joint_stereo = s->decorr_specs[s->best_decorr].joint_stereo;
1959  CLEAR(s->w);
1960  scan_word(s, &s->w.c[0], s->best_buffer[0], nb_samples, -1);
1961  scan_word(s, &s->w.c[1], s->best_buffer[1], nb_samples, -1);
1962  }
1963  return 0;
1964 }
1965 
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;
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) {
2491  s->flags &= ~(WV_JOINT_STEREO | WV_CROSS_DECORR);
2492  s->flags |= WV_FALSE_STEREO;
2493 
2494  if (!s->false_stereo) {
2495  s->false_stereo = 1;
2496  s->num_terms = 0;
2497  CLEAR(s->w);
2498  }
2499  } else if (s->false_stereo) {
2500  s->false_stereo = 0;
2501  s->num_terms = 0;
2502  CLEAR(s->w);
2503  }
2504  }
2505 
2506  if (s->flags & SHIFT_MASK) {
2507  int shift = (s->flags & SHIFT_MASK) >> SHIFT_LSB;
2508  int mag = (s->flags & MAG_MASK) >> MAG_LSB;
2509 
2510  if (s->flags & WV_MONO_DATA)
2511  shift_mono(samples_l, nb_samples, shift);
2512  else
2513  shift_stereo(samples_l, samples_r, nb_samples, shift);
2514 
2515  if ((mag -= shift) < 0)
2516  s->flags &= ~MAG_MASK;
2517  else
2518  s->flags -= (1 << MAG_LSB) * shift;
2519  }
2520 
2521  if ((s->flags & WV_FLOAT_DATA) || (s->flags & MAG_MASK) >> MAG_LSB >= 24) {
2522  av_fast_padded_malloc(&s->orig_l, &s->orig_l_size, sizeof(int32_t) * nb_samples);
2523  memcpy(s->orig_l, samples_l, sizeof(int32_t) * nb_samples);
2524  if (!(s->flags & WV_MONO_DATA)) {
2525  av_fast_padded_malloc(&s->orig_r, &s->orig_r_size, sizeof(int32_t) * nb_samples);
2526  memcpy(s->orig_r, samples_r, sizeof(int32_t) * nb_samples);
2527  }
2528 
2529  if (s->flags & WV_FLOAT_DATA)
2530  got_extra = scan_float(s, samples_l, samples_r, nb_samples);
2531  else
2532  got_extra = scan_int32(s, samples_l, samples_r, nb_samples);
2533  s->num_terms = 0;
2534  } else {
2535  scan_int23(s, samples_l, samples_r, nb_samples);
2536  if (s->shift != s->int32_zeros + s->int32_ones + s->int32_dups) {
2537  s->shift = s->int32_zeros + s->int32_ones + s->int32_dups;
2538  s->num_terms = 0;
2539  }
2540  }
2541 
2542  if (!s->num_passes && !s->num_terms) {
2543  s->num_passes = 1;
2544 
2545  if (s->flags & WV_MONO_DATA)
2546  ret = wv_mono(s, samples_l, 1, 0);
2547  else
2548  ret = wv_stereo(s, samples_l, samples_r, 1, 0);
2549 
2550  s->num_passes = 0;
2551  }
2552  if (s->flags & WV_MONO_DATA) {
2553  for (i = 0; i < nb_samples; i++)
2554  crc += (crc << 1) + samples_l[i];
2555 
2556  if (s->num_passes)
2557  ret = wv_mono(s, samples_l, !s->num_terms, 1);
2558  } else {
2559  for (i = 0; i < nb_samples; i++)
2560  crc += (crc << 3) + ((uint32_t)samples_l[i] << 1) + samples_l[i] + samples_r[i];
2561 
2562  if (s->num_passes)
2563  ret = wv_stereo(s, samples_l, samples_r, !s->num_terms, 1);
2564  }
2565  if (ret < 0)
2566  return ret;
2567 
2568  if (!s->ch_offset)
2569  s->flags |= WV_INITIAL_BLOCK;
2570 
2571  s->ch_offset += 1 + !(s->flags & WV_MONO);
2572 
2573  if (s->ch_offset == s->avctx->channels)
2574  s->flags |= WV_FINAL_BLOCK;
2575 
2577  bytestream2_put_le32(&pb, MKTAG('w', 'v', 'p', 'k'));
2578  bytestream2_put_le32(&pb, 0);
2579  bytestream2_put_le16(&pb, 0x410);
2580  bytestream2_put_le16(&pb, 0);
2581  bytestream2_put_le32(&pb, 0);
2582  bytestream2_put_le32(&pb, s->sample_index);
2583  bytestream2_put_le32(&pb, nb_samples);
2584  bytestream2_put_le32(&pb, s->flags);
2585  bytestream2_put_le32(&pb, crc);
2586 
2587  if (s->flags & WV_INITIAL_BLOCK &&
2588  s->avctx->channel_layout != AV_CH_LAYOUT_MONO &&
2589  s->avctx->channel_layout != AV_CH_LAYOUT_STEREO) {
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 
2602  put_metadata_block(&pb, WP_ID_DECTERMS, s->num_terms);
2603  for (i = 0; i < s->num_terms; i++) {
2604  struct Decorr *dpp = &s->decorr_passes[i];
2605  bytestream2_put_byte(&pb, ((dpp->value + 5) & 0x1f) | ((dpp->delta << 5) & 0xe0));
2606  }
2607  if (s->num_terms & 1)
2608  bytestream2_put_byte(&pb, 0);
2609 
2610 #define WRITE_DECWEIGHT(type) do { \
2611  temp = store_weight(type); \
2612  bytestream2_put_byte(&pb, temp); \
2613  type = restore_weight(temp); \
2614  } while (0)
2615 
2616  bytestream2_put_byte(&pb, WP_ID_DECWEIGHTS);
2617  bytestream2_put_byte(&pb, 0);
2618  start = bytestream2_tell_p(&pb);
2619  for (i = s->num_terms - 1; i >= 0; --i) {
2620  struct Decorr *dpp = &s->decorr_passes[i];
2621 
2622  if (store_weight(dpp->weightA) ||
2623  (!(s->flags & WV_MONO_DATA) && store_weight(dpp->weightB)))
2624  break;
2625  }
2626  tcount = i + 1;
2627  for (i = 0; i < s->num_terms; i++) {
2628  struct Decorr *dpp = &s->decorr_passes[i];
2629  if (i < tcount) {
2630  WRITE_DECWEIGHT(dpp->weightA);
2631  if (!(s->flags & WV_MONO_DATA))
2632  WRITE_DECWEIGHT(dpp->weightB);
2633  } else {
2634  dpp->weightA = dpp->weightB = 0;
2635  }
2636  }
2637  end = bytestream2_tell_p(&pb);
2638  out[start - 2] = WP_ID_DECWEIGHTS | (((end - start) & 1) ? WP_IDF_ODD: 0);
2639  out[start - 1] = (end - start + 1) >> 1;
2640  if ((end - start) & 1)
2641  bytestream2_put_byte(&pb, 0);
2642 
2643 #define WRITE_DECSAMPLE(type) do { \
2644  temp = log2s(type); \
2645  type = wp_exp2(temp); \
2646  bytestream2_put_le16(&pb, temp); \
2647  } while (0)
2648 
2649  bytestream2_put_byte(&pb, WP_ID_DECSAMPLES);
2650  bytestream2_put_byte(&pb, 0);
2651  start = bytestream2_tell_p(&pb);
2652  for (i = 0; i < s->num_terms; i++) {
2653  struct Decorr *dpp = &s->decorr_passes[i];
2654  if (i == 0) {
2655  if (dpp->value > MAX_TERM) {
2656  WRITE_DECSAMPLE(dpp->samplesA[0]);
2657  WRITE_DECSAMPLE(dpp->samplesA[1]);
2658  if (!(s->flags & WV_MONO_DATA)) {
2659  WRITE_DECSAMPLE(dpp->samplesB[0]);
2660  WRITE_DECSAMPLE(dpp->samplesB[1]);
2661  }
2662  } else if (dpp->value < 0) {
2663  WRITE_DECSAMPLE(dpp->samplesA[0]);
2664  WRITE_DECSAMPLE(dpp->samplesB[0]);
2665  } else {
2666  for (j = 0; j < dpp->value; j++) {
2667  WRITE_DECSAMPLE(dpp->samplesA[j]);
2668  if (!(s->flags & WV_MONO_DATA))
2669  WRITE_DECSAMPLE(dpp->samplesB[j]);
2670  }
2671  }
2672  } else {
2673  CLEAR(dpp->samplesA);
2674  CLEAR(dpp->samplesB);
2675  }
2676  }
2677  end = bytestream2_tell_p(&pb);
2678  out[start - 1] = (end - start) >> 1;
2679 
2680 #define WRITE_CHAN_ENTROPY(chan) do { \
2681  for (i = 0; i < 3; i++) { \
2682  temp = wp_log2(s->w.c[chan].median[i]); \
2683  bytestream2_put_le16(&pb, temp); \
2684  s->w.c[chan].median[i] = wp_exp2(temp); \
2685  } \
2686  } while (0)
2687 
2688  put_metadata_block(&pb, WP_ID_ENTROPY, 6 * (1 + (!(s->flags & WV_MONO_DATA))));
2689  WRITE_CHAN_ENTROPY(0);
2690  if (!(s->flags & WV_MONO_DATA))
2691  WRITE_CHAN_ENTROPY(1);
2692 
2693  if (s->flags & WV_FLOAT_DATA) {
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);
2768  init_put_bits(&s->pb, pb.buffer + 3, bytestream2_get_bytes_left_p(&pb));
2769  if (s->flags & WV_MONO_DATA) {
2770  for (i = 0; i < nb_samples; i++)
2771  wavpack_encode_sample(s, &s->w.c[0], s->samples[0][i]);
2772  } else {
2773  for (i = 0; i < nb_samples; i++) {
2774  wavpack_encode_sample(s, &s->w.c[0], s->samples[0][i]);
2775  wavpack_encode_sample(s, &s->w.c[1], s->samples[1][i]);
2776  }
2777  }
2778  encode_flush(s);
2779  flush_put_bits(&s->pb);
2780  data_size = put_bytes_output(&s->pb);
2781  bytestream2_put_le24(&pb, (data_size + 1) >> 1);
2782  bytestream2_skip_p(&pb, data_size);
2783  if (data_size & 1)
2784  bytestream2_put_byte(&pb, 0);
2785 
2786  if (got_extra) {
2787  bytestream2_put_byte(&pb, WP_ID_EXTRABITS | WP_IDF_LONG);
2788  init_put_bits(&s->pb, pb.buffer + 7, bytestream2_get_bytes_left_p(&pb));
2789  if (s->flags & WV_FLOAT_DATA)
2790  pack_float(s, s->orig_l, s->orig_r, nb_samples);
2791  else
2792  pack_int32(s, s->orig_l, s->orig_r, nb_samples);
2793  flush_put_bits(&s->pb);
2794  data_size = put_bytes_output(&s->pb);
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;
2859  av_fast_padded_malloc(&s->samples[0], &s->samples_size[0],
2860  sizeof(int32_t) * s->block_samples);
2861  if (!s->samples[0])
2862  return AVERROR(ENOMEM);
2863  if (avctx->channels > 1) {
2864  av_fast_padded_malloc(&s->samples[1], &s->samples_size[1],
2865  sizeof(int32_t) * s->block_samples);
2866  if (!s->samples[1])
2867  return AVERROR(ENOMEM);
2868  }
2869 
2870  buf_size = s->block_samples * avctx->channels * 8
2871  + 200 * avctx->channels /* for headers */;
2872  if ((ret = ff_alloc_packet2(avctx, avpkt, buf_size, 0)) < 0)
2873  return ret;
2874  buf = avpkt->data;
2875 
2876  for (s->ch_offset = 0; s->ch_offset < avctx->channels;) {
2877  set_samplerate(s);
2878 
2879  switch (s->avctx->sample_fmt) {
2880  case AV_SAMPLE_FMT_S16P: s->flags |= 1; break;
2881  case AV_SAMPLE_FMT_S32P: s->flags |= 3 - (s->avctx->bits_per_raw_sample <= 24); break;
2882  case AV_SAMPLE_FMT_FLTP: s->flags |= 3 | WV_FLOAT_DATA;
2883  }
2884 
2885  fill_buffer(s, frame->extended_data[s->ch_offset], s->samples[0], s->block_samples);
2886  if (avctx->channels - s->ch_offset == 1) {
2887  s->flags |= WV_MONO;
2888  } else {
2889  s->flags |= WV_CROSS_DECORR;
2890  fill_buffer(s, frame->extended_data[s->ch_offset + 1], s->samples[1], s->block_samples);
2891  }
2892 
2893  s->flags += (1 << MAG_LSB) * ((s->flags & 3) * 8 + 7);
2894 
2895  if ((ret = wavpack_encode_block(s, s->samples[0], s->samples[1],
2896  buf, buf_size)) < 0)
2897  return ret;
2898 
2899  buf += ret;
2900  buf_size -= ret;
2901  }
2902  s->sample_index += frame->nb_samples;
2903 
2904  avpkt->pts = frame->pts;
2905  avpkt->size = buf - avpkt->data;
2906  avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples);
2907  *got_packet_ptr = 1;
2908  return 0;
2909 }
2910 
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 };
M
#define M(a, b)
Definition: vp3dsp.c:45
MAG_MASK
#define MAG_MASK
Definition: wavpackenc.c:52
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1216
WavPackEncodeContext::temp_buffer
int32_t * temp_buffer[2][2]
Definition: wavpackenc.c:91
AVCodec
AVCodec.
Definition: codec.h:197
WavPackEncodeContext::shift
int shift
Definition: wavpackenc.c:118
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
decorr_filters
static const WavPackDecorrSpec *const decorr_filters[]
Definition: wavpackenc.h:640
WavPackEncodeContext::float_flags
uint8_t float_flags
Definition: wavpackenc.c:114
shift_mono
static void shift_mono(int32_t *samples, int nb_samples, int shift)
Definition: wavpackenc.c:195
av_clip
#define av_clip
Definition: common.h:122
bytestream2_get_eof
static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p)
Definition: bytestream.h:332
WavPackEncodeContext::shifted_ones
int32_t shifted_ones
Definition: wavpackenc.c:115
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
WavPackEncodeContext::decorr_passes
struct Decorr decorr_passes[MAX_TERMS]
Definition: wavpackenc.c:120
update_weight_clip_d2
#define update_weight_clip_d2(weight, delta, source, result)
Definition: wavpackenc.c:2341
AVERROR
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
opt.h
restore_weight
static int restore_weight(int8_t weight)
Definition: wavpackenc.c:530
WavPackEncodeContext::extra_flags
unsigned extra_flags
Definition: wavpackenc.c:103
WavPackEncodeContext::orig_r
int32_t * orig_r
Definition: wavpackenc.c:100
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
WavPackEncodeContext::flags
uint32_t flags
Definition: wavpackenc.c:109
log2sample
static uint32_t log2sample(uint32_t v, int limit, uint32_t *result)
Definition: wavpackenc.c:642
encode_flush
static void encode_flush(WavPackEncodeContext *s)
Definition: wavpackenc.c:1966
out
FILE * out
Definition: movenc.c:54
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:93
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1196
WavPackWords
Definition: wavpackenc.c:69
WP_ID_FLOATINFO
@ WP_ID_FLOATINFO
Definition: wavpack.h:75
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
WavPackEncodeContext::block_samples
int block_samples
Definition: wavpackenc.c:79
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:926
WV_MAX_SAMPLES
#define WV_MAX_SAMPLES
Definition: wavpack.h:57
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:478
WRITE_DECWEIGHT
#define WRITE_DECWEIGHT(type)
MAX_TERMS
#define MAX_TERMS
Definition: wavpack.h:27
scan_int23
static void scan_int23(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
Definition: wavpackenc.c:350
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:290
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:66
WP_ID_DECWEIGHTS
@ WP_ID_DECWEIGHTS
Definition: wavpack.h:70
out_size
int out_size
Definition: movenc.c:55
scan_float
static int scan_float(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
Definition: wavpackenc.c:264
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:324
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:27
get_exponent
#define get_exponent(f)
Definition: wavpackenc.c:220
WP_IDF_LONG
@ WP_IDF_LONG
Definition: wavpack.h:63
w
uint8_t w
Definition: llviddspenc.c:39
R
#define R
Definition: huffyuvdsp.h:34
internal.h
WavPackEncodeContext::orig_l_size
int orig_l_size
Definition: wavpackenc.c:101
AVPacket::data
uint8_t * data
Definition: packet.h:369
OFFSET
#define OFFSET(x)
Definition: wavpackenc.c:2945
AVOption
AVOption.
Definition: opt.h:248
WavPackEncodeContext::optimize_mono
int optimize_mono
Definition: wavpackenc.c:104
WV_MONO
@ WV_MONO
Definition: wvdec.c:32
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:68
bytestream2_tell_p
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
Definition: bytestream.h:197
wavpack_encoder_class
static const AVClass wavpack_encoder_class
Definition: wavpackenc.c:2953
WavPackEncodeContext::max_exp
uint8_t max_exp
Definition: wavpackenc.c:114
WRITE_CHAN_ENTROPY
#define WRITE_CHAN_ENTROPY(chan)
WavPackEncodeContext::sample_index
int sample_index
Definition: wavpackenc.c:81
MAX_TERM
#define MAX_TERM
Definition: wavpack.h:28
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
WvChannel
Definition: wavpack.h:96
Decorr::weightA
int weightA
Definition: wavpack.h:88
wavpack_encode_block
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
COPY_SAMPLES
#define COPY_SAMPLES(type, offset, shift)
WavPackWords::zeros_acc
int zeros_acc
Definition: wavpackenc.c:70
FF_COMPRESSION_DEFAULT
#define FF_COMPRESSION_DEFAULT
Definition: avcodec.h:609
WV_FLOAT_DATA
#define WV_FLOAT_DATA
Definition: wavpack.h:35
update_weight_d2
#define update_weight_d2(weight, delta, source, result)
Definition: wavpackenc.c:2337
set_samplerate
static void set_samplerate(WavPackEncodeContext *s)
Definition: wavpackenc.c:2839
Decorr::sumA
int sumA
Definition: wavpack.h:92
decorr_stereo_buffer
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
WavPackDecorrSpec::terms
int8_t terms[MAX_TERMS+1]
Definition: wavpackenc.h:27
WavPackWords::c
WvChannel c[2]
Definition: wavpackenc.c:72
WavPackEncodeContext::stereo_in
int stereo_in
Definition: wavpackenc.c:82
WavPackEncodeContext::delta_decay
float delta_decay
Definition: wavpackenc.c:122
WV_FINAL_BLOCK
#define WV_FINAL_BLOCK
Definition: wavpack.h:45
SRATE_MASK
#define SRATE_MASK
Definition: wavpackenc.c:55
WP_ID_DATA
@ WP_ID_DATA
Definition: wavpack.h:77
decorr_mono_buffer
static void decorr_mono_buffer(int32_t *samples, int32_t *outsamples, int nb_samples, struct Decorr *dpp, int tindex)
Definition: wavpackenc.c:680
Decorr
Definition: wavpack.h:85
recurse_mono
static void recurse_mono(WavPackEncodeContext *s, WavPackExtraInfo *info, int depth, int delta, uint32_t input_bits)
Definition: wavpackenc.c:719
WV_INT32_DATA
#define WV_INT32_DATA
Definition: wavpack.h:36
WP_ID_SAMPLE_RATE
@ WP_ID_SAMPLE_RATE
Definition: wavpack.h:82
wavpack_encode_close
static av_cold int wavpack_encode_close(AVCodecContext *avctx)
Definition: wavpackenc.c:2911
WP_ID_ENTROPY
@ WP_ID_ENTROPY
Definition: wavpack.h:72
WavPackEncodeContext::num_terms
int num_terms
Definition: wavpackenc.c:118
WavPackEncodeContext::best_buffer
int32_t * best_buffer[2]
Definition: wavpackenc.c:94
WavPackEncodeContext::avctx
AVCodecContext * avctx
Definition: wavpackenc.c:77
EXTRA_SORT_LAST
#define EXTRA_SORT_LAST
Definition: wavpackenc.c:61
EXTRA_SORT_FIRST
#define EXTRA_SORT_FIRST
Definition: wavpackenc.c:59
WavPackEncodeContext::temp_buffer_size
int temp_buffer_size[2][2]
Definition: wavpackenc.c:92
WavPackEncodeContext::orig_l
int32_t * orig_l
Definition: wavpackenc.c:100
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
wp_log2
static av_always_inline int wp_log2(uint32_t val)
Definition: wavpack.h:147
wavpackenc.h
WV_MONO_DATA
#define WV_MONO_DATA
Definition: wavpack.h:47
Decorr::delta
int delta
Definition: wavpack.h:86
ff_samples_to_time_base
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:272
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
bytestream2_get_bytes_left_p
static av_always_inline int bytestream2_get_bytes_left_p(PutByteContext *p)
Definition: bytestream.h:163
WavPackEncodeContext::js_left_size
int js_left_size
Definition: wavpackenc.c:98
WavPackEncodeContext::sampleptrs_size
int sampleptrs_size[MAX_TERMS+2][2]
Definition: wavpackenc.c:89
av_cold
#define av_cold
Definition: attributes.h:90
WavPackEncodeContext::num_decorrs
int num_decorrs
Definition: wavpackenc.c:119
FLOAT_EXCEPTIONS
#define FLOAT_EXCEPTIONS
Definition: wavpackenc.c:217
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
mask
static const uint16_t mask[17]
Definition: lzw.c:38
WavPackWords::pend_data
int pend_data
Definition: wavpackenc.c:70
WavPackEncodeContext::js_right_size
int js_right_size
Definition: wavpackenc.c:98
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
decorr_filter_nterms
static const uint8_t decorr_filter_nterms[]
Definition: wavpackenc.h:651
WavPackEncodeContext::float_max_exp
uint8_t float_max_exp
Definition: wavpackenc.c:114
wv_stereo
static int wv_stereo(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int no_history, int do_samples)
Definition: wavpackenc.c:1806
WavPackEncodeContext::orig_r_size
int orig_r_size
Definition: wavpackenc.c:101
WavPackEncodeContext::int32_sent_bits
uint8_t int32_sent_bits
Definition: wavpackenc.c:113
floor
static __device__ float floor(float a)
Definition: cuda_runtime.h:173
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
WP_ID_EXTRABITS
@ WP_ID_EXTRABITS
Definition: wavpack.h:79
wv_rates
static const int wv_rates[16]
Definition: wavpack.h:121
info
MIPS optimizations info
Definition: mips.txt:2
bits
uint8_t bits
Definition: vp3data.h:141
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
WavPackEncodeContext::decorr_filter
int decorr_filter
Definition: wavpackenc.c:105
wp_exp2
static av_always_inline int wp_exp2(int16_t val)
Definition: wavpack.h:130
Decorr::value
int value
Definition: wavpack.h:87
store_weight
static int8_t store_weight(int weight)
Definition: wavpackenc.c:521
log2s
static int log2s(int32_t value)
Definition: wavpackenc.c:540
delta_mono
static void delta_mono(WavPackEncodeContext *s, WavPackExtraInfo *info)
Definition: wavpackenc.c:829
WavPackEncodeContext::decorr_specs
const WavPackDecorrSpec * decorr_specs
Definition: wavpackenc.c:121
EXTRA_BRANCHES
#define EXTRA_BRANCHES
Definition: wavpackenc.c:60
WavPackEncodeContext::joint_stereo
int joint_stereo
Definition: wavpackenc.c:118
WavPackDecorrSpec::joint_stereo
int8_t joint_stereo
Definition: wavpackenc.h:27
f
#define f(width, name)
Definition: cbs_vp9.c:255
PutBitContext
Definition: put_bits.h:51
WavPackEncodeContext::num_passes
int num_passes
Definition: wavpackenc.c:119
int32_t
int32_t
Definition: audio_convert.c:194
if
if(ret)
Definition: filter_design.txt:179
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
WV_FALSE_STEREO
#define WV_FALSE_STEREO
Definition: wavpack.h:37
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
sort_stereo
static void sort_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info)
Definition: wavpackenc.c:1547
NULL
#define NULL
Definition: coverity.c:32
WavPackEncodeContext::shifted_both
int32_t shifted_both
Definition: wavpackenc.c:115
WavPackEncodeContext::stereo
int stereo
Definition: wavpackenc.c:82
WavPackEncodeContext::pb
PutBitContext pb
Definition: wavpackenc.c:78
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
WavPackWords::holding_zero
int holding_zero
Definition: wavpackenc.c:71
src
#define src
Definition: vp8dsp.c:255
WV_INITIAL_BLOCK
#define WV_INITIAL_BLOCK
Definition: wavpack.h:44
WavPackEncodeContext::samples_size
int samples_size[2]
Definition: wavpackenc.c:86
decorr_stereo_pass_id2
static void decorr_stereo_pass_id2(struct Decorr *dpp, int32_t *samples_l, int32_t *samples_r, int nb_samples)
Definition: wavpackenc.c:2348
get_sign
#define get_sign(f)
Definition: wavpackenc.c:221
WavPackWords::pend_count
int pend_count
Definition: wavpackenc.c:71
reverse_mono_decorr
static void reverse_mono_decorr(struct Decorr *dpp)
Definition: wavpackenc.c:608
scan_int32
static int scan_int32(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
Definition: wavpackenc.c:431
WavPackEncodeContext::int32_zeros
uint8_t int32_zeros
Definition: wavpackenc.c:113
abs
#define abs(x)
Definition: cuda_runtime.h:35
analyze_stereo
static void analyze_stereo(WavPackEncodeContext *s, int32_t *in_left, int32_t *in_right, int do_samples)
Definition: wavpackenc.c:1737
FLOAT_SHIFT_SAME
#define FLOAT_SHIFT_SAME
Definition: wavpackenc.c:213
WavPackEncodeContext::best_decorr
int best_decorr
Definition: wavpackenc.c:119
WavPackEncodeContext::buffer_size
int buffer_size
Definition: wavpackenc.c:80
pack_int32
static void pack_int32(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
Definition: wavpackenc.c:2132
c
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
wavpack_encode_init
static av_cold int wavpack_encode_init(AVCodecContext *avctx)
Definition: wavpackenc.c:125
SHIFT_LSB
#define SHIFT_LSB
Definition: wavpackenc.c:48
weight
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1561
PutByteContext
Definition: bytestream.h:37
wavpack_encode_frame
static int wavpack_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: wavpackenc.c:2851
EXTRA_TRY_DELTAS
#define EXTRA_TRY_DELTAS
Definition: wavpackenc.c:57
AVPacket::size
int size
Definition: packet.h:370
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AV_SAMPLE_FMT_U8P
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
Definition: samplefmt.h:66
WavPackEncodeContext::sampleptrs
int32_t * sampleptrs[MAX_TERMS+2][2]
Definition: wavpackenc.c:88
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
PutByteContext::buffer
uint8_t * buffer
Definition: bytestream.h:38
sample
#define sample
Definition: flacdsp_template.c:44
FLOAT_ZEROS_SENT
#define FLOAT_ZEROS_SENT
Definition: wavpackenc.c:215
size
int size
Definition: twinvq_data.h:10344
process_float
static void process_float(WavPackEncodeContext *s, int32_t *sample)
Definition: wavpackenc.c:223
MAG_LSB
#define MAG_LSB
Definition: wavpackenc.c:51
WP_IDF_ODD
@ WP_IDF_ODD
Definition: wavpack.h:62
WavPackEncodeContext::best_buffer_size
int best_buffer_size[2]
Definition: wavpackenc.c:95
Decorr::samplesA
int samplesA[MAX_TERM]
Definition: wavpack.h:90
decorr_filter_sizes
static const uint16_t decorr_filter_sizes[]
Definition: wavpackenc.h:644
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
WavPackEncodeContext::float_shift
uint8_t float_shift
Definition: wavpackenc.c:114
count_bits
#define count_bits(av)
Definition: wavpackenc.c:640
WP_ID_DECTERMS
@ WP_ID_DECTERMS
Definition: wavpack.h:69
WavPackEncodeContext::ordata
int32_t ordata
Definition: wavpackenc.c:116
Decorr::sumB
int sumB
Definition: wavpack.h:93
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:67
WavPackExtraInfo
Definition: wavpackenc.c:63
WV_CROSS_DECORR
#define WV_CROSS_DECORR
Definition: wavpack.h:34
WavPackExtraInfo::gt16bit
int gt16bit
Definition: wavpackenc.c:65
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1197
pack_float_sample
static void pack_float_sample(WavPackEncodeContext *s, int32_t *sample)
Definition: wavpackenc.c:2157
i
int i
Definition: input.c:407
decorr_stereo
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
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
code
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
Definition: filter_design.txt:178
WavPackEncodeContext::w
WavPackWords w
Definition: wavpackenc.c:111
bytestream2_skip_p
static av_always_inline void bytestream2_skip_p(PutByteContext *p, unsigned int size)
Definition: bytestream.h:180
WavPackEncodeContext::samples
int32_t * samples[2]
Definition: wavpackenc.c:85
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
delta
float delta
Definition: vorbis_enc_data.h:457
av_fast_padded_malloc
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:50
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
put_metadata_block
static void put_metadata_block(PutByteContext *pb, int flags, int size)
Definition: wavpackenc.c:2457
wavpack.h
WP_ID_CHANINFO
@ WP_ID_CHANINFO
Definition: wavpack.h:80
uint8_t
uint8_t
Definition: audio_convert.c:194
WavPackEncodeContext::crc_x
uint32_t crc_x
Definition: wavpackenc.c:110
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
WavPackExtraInfo::dps
struct Decorr dps[MAX_TERMS]
Definition: wavpackenc.c:64
WavPackEncodeContext::joint
int joint
Definition: wavpackenc.c:106
WavPackEncodeContext::shifted_zeros
int32_t shifted_zeros
Definition: wavpackenc.c:115
FLOAT_SHIFT_ONES
#define FLOAT_SHIFT_ONES
Definition: wavpackenc.c:212
WavPackExtraInfo::nterms
int nterms
Definition: wavpackenc.c:65
WavPackEncodeContext::neg_zeros
int32_t neg_zeros
Definition: wavpackenc.c:116
EXTRA_ADJUST_DELTAS
#define EXTRA_ADJUST_DELTAS
Definition: wavpackenc.c:58
avcodec.h
WP_ID_DECSAMPLES
@ WP_ID_DECSAMPLES
Definition: wavpack.h:71
WavPackEncodeContext::js_right
int32_t * js_right
Definition: wavpackenc.c:97
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
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
frame
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
Definition: filter_design.txt:264
WavPackExtraInfo::log_limit
int log_limit
Definition: wavpackenc.c:65
GET_MED
#define GET_MED(n)
Definition: wavpack.h:103
FLOAT_NEG_ZEROS
#define FLOAT_NEG_ZEROS
Definition: wavpackenc.c:216
APPLY_WEIGHT
#define APPLY_WEIGHT(weight, sample)
Definition: wavpackenc.c:43
left
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:386
SHIFT_MASK
#define SHIFT_MASK
Definition: wavpackenc.c:49
L
#define L(x)
Definition: vp56_arith.h:36
WavPackEncodeContext::false_zeros
int32_t false_zeros
Definition: wavpackenc.c:116
AVCodecContext
main external API structure.
Definition: avcodec.h:536
WavPackWords::holding_one
int holding_one
Definition: wavpackenc.c:70
APPLY_WEIGHT_I
#define APPLY_WEIGHT_I(weight, sample)
Definition: wavpackenc.c:41
allocate_buffers
static int allocate_buffers(WavPackEncodeContext *s)
Definition: wavpackenc.c:902
UPDATE_WEIGHT_CLIP
#define UPDATE_WEIGHT_CLIP(weight, delta, samples, in)
Definition: wavpack.h:108
log2mono
static uint32_t log2mono(int32_t *samples, int nb_samples, int limit)
Definition: wavpackenc.c:658
WavPackEncodeContext
Definition: wavpackenc.c:75
CLEAR
#define CLEAR(destin)
Definition: wavpackenc.c:46
Decorr::weightB
int weightB
Definition: wavpack.h:89
sort_mono
static void sort_mono(WavPackEncodeContext *s, WavPackExtraInfo *info)
Definition: wavpackenc.c:782
temp
else temp
Definition: vf_mcdeint.c:259
reverse_decorr
static void reverse_decorr(struct Decorr *dpp)
Definition: wavpackenc.c:1315
decorr_stereo_quick
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
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
UPDATE_WEIGHT
#define UPDATE_WEIGHT(weight, delta, source, result)
Definition: wavpackenc.c:32
WRITE_DECSAMPLE
#define WRITE_DECSAMPLE(type)
WavPackDecorrSpec
Definition: wavpackenc.h:26
decorr_mono
static void decorr_mono(int32_t *in_samples, int32_t *out_samples, int nb_samples, struct Decorr *dpp, int dir)
Definition: wavpackenc.c:545
WavPackExtraInfo::best_bits
uint32_t best_bits
Definition: wavpackenc.c:66
recurse_stereo
static void recurse_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info, int depth, int delta, uint32_t input_bits)
Definition: wavpackenc.c:1664
shift
static int shift(int a, int b)
Definition: sonic.c:82
scan_word
static void scan_word(WavPackEncodeContext *s, WvChannel *c, int32_t *samples, int nb_samples, int dir)
Definition: wavpackenc.c:984
log2stereo
static uint32_t log2stereo(int32_t *samples_l, int32_t *samples_r, int nb_samples, int limit)
Definition: wavpackenc.c:668
INC_MED
#define INC_MED(n)
Definition: wavpack.h:105
WavPackEncodeContext::ch_offset
int ch_offset
Definition: wavpackenc.c:83
DEC_MED
#define DEC_MED(n)
Definition: wavpack.h:104
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:147
SRATE_LSB
#define SRATE_LSB
Definition: wavpackenc.c:54
FLOAT_SHIFT_SENT
#define FLOAT_SHIFT_SENT
Definition: wavpackenc.c:214
fill_buffer
static void fill_buffer(WavPackEncodeContext *s, const int8_t *src, int32_t *dst, int nb_samples)
Definition: wavpackenc.c:2810
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
WV_JOINT_STEREO
#define WV_JOINT_STEREO
Definition: wavpack.h:33
AVPacket
This structure stores compressed data.
Definition: packet.h:346
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
analyze_mono
static void analyze_mono(WavPackEncodeContext *s, int32_t *samples, int do_samples)
Definition: wavpackenc.c:932
WavPackEncodeContext::false_stereo
int false_stereo
Definition: wavpackenc.c:118
delta_stereo
static void delta_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info)
Definition: wavpackenc.c:1604
d
d
Definition: ffmpeg_filter.c:158
shift_stereo
static void shift_stereo(int32_t *left, int32_t *right, int nb_samples, int shift)
Definition: wavpackenc.c:202
bytestream.h
WavPackEncodeContext::num_branches
int num_branches
Definition: wavpackenc.c:107
ff_wp_log2_table
const uint8_t ff_wp_log2_table[256]
Definition: wavpackdata.c:43
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_CODEC_ID_WAVPACK
@ AV_CODEC_ID_WAVPACK
Definition: codec_id.h:449
WP_ID_INT32INFO
@ WP_ID_INT32INFO
Definition: wavpack.h:76
wavpack_encode_sample
static void wavpack_encode_sample(WavPackEncodeContext *s, WvChannel *c, int32_t sample)
Definition: wavpackenc.c:2039
ff_wavpack_encoder
AVCodec ff_wavpack_encoder
Definition: wavpackenc.c:2960
decorr_stereo_pass2
static void decorr_stereo_pass2(struct Decorr *dpp, int32_t *samples_l, int32_t *samples_r, int nb_samples)
Definition: wavpackenc.c:2229
WavPackEncodeContext::mask_decorr
int mask_decorr
Definition: wavpackenc.c:119
FLAGS
#define FLAGS
Definition: wavpackenc.c:2946
WavPackEncodeContext::int32_dups
uint8_t int32_dups
Definition: wavpackenc.c:113
AV_CODEC_CAP_SMALL_LAST_FRAME
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:82
WavPackEncodeContext::js_left
int32_t * js_left
Definition: wavpackenc.c:97
allocate_buffers2
static int allocate_buffers2(WavPackEncodeContext *s, int nterms)
Definition: wavpackenc.c:882
ff_alloc_packet2
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:33
put_bits.h
WavPackEncodeContext::int32_ones
uint8_t int32_ones
Definition: wavpackenc.c:113
WavPackDecorrSpec::delta
int8_t delta
Definition: wavpackenc.h:27
Decorr::samplesB
int samplesB[MAX_TERM]
Definition: wavpack.h:91
pack_float
static void pack_float(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
Definition: wavpackenc.c:2212
AVCodecContext::compression_level
int compression_level
Definition: avcodec.h:608
get_mantissa
#define get_mantissa(f)
Definition: wavpackenc.c:219
wv_mono
static int wv_mono(WavPackEncodeContext *s, int32_t *samples, int no_history, int do_samples)
Definition: wavpackenc.c:1016
options
static const AVOption options[]
Definition: wavpackenc.c:2947