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