21 #define BITSTREAM_WRITER_LE
32 #define UPDATE_WEIGHT(weight, delta, source, result) \
33 if ((source) && (result)) { \
34 int32_t s = (int32_t) ((source) ^ (result)) >> 31; \
35 weight = ((delta) ^ s) + ((weight) - s); \
38 #define APPLY_WEIGHT_F(weight, sample) ((((((sample) & 0xffff) * (weight)) >> 9) + \
39 ((((sample) & ~0xffff) >> 9) * (weight)) + 1) >> 1)
41 #define APPLY_WEIGHT_I(weight, sample) (((weight) * (sample) + 512) >> 10)
43 #define APPLY_WEIGHT(weight, sample) ((sample) != (short) (sample) ? \
44 APPLY_WEIGHT_F(weight, sample) : APPLY_WEIGHT_I (weight, sample))
46 #define CLEAR(destin) memset(&destin, 0, sizeof(destin));
49 #define SHIFT_MASK (0x1FU << SHIFT_LSB)
52 #define MAG_MASK (0x1FU << MAG_LSB)
55 #define SRATE_MASK (0xFU << SRATE_LSB)
57 #define EXTRA_TRY_DELTAS 1
58 #define EXTRA_ADJUST_DELTAS 2
59 #define EXTRA_SORT_FIRST 4
60 #define EXTRA_BRANCHES 8
61 #define EXTRA_SORT_LAST 16
146 while (block_samples * avctx->
channels < 40000)
157 s->decorr_filter = 3;
176 s->decorr_filter = 2;
179 s->decorr_filter = 1;
182 s->decorr_filter = 0;
190 s->delta_decay = 2.0;
198 for (
i = 0;
i < nb_samples;
i++)
203 int nb_samples,
int shift)
206 for (
i = 0;
i < nb_samples;
i++) {
212 #define FLOAT_SHIFT_ONES 1
213 #define FLOAT_SHIFT_SAME 2
214 #define FLOAT_SHIFT_SENT 4
215 #define FLOAT_ZEROS_SENT 8
216 #define FLOAT_NEG_ZEROS 0x10
217 #define FLOAT_EXCEPTIONS 0x20
219 #define get_mantissa(f) ((f) & 0x7fffff)
220 #define get_exponent(f) (((f) >> 23) & 0xff)
221 #define get_sign(f) (((f) >> 31) & 0x1)
235 shift_count =
s->max_exp ?
s->max_exp - 1 : 0;
239 if (shift_count < 25)
240 value >>= shift_count;
249 }
else if (shift_count) {
268 uint32_t crc = 0xffffffffu;
271 s->shifted_ones =
s->shifted_zeros =
s->shifted_both =
s->ordata = 0;
272 s->float_shift =
s->float_flags = 0;
273 s->false_zeros =
s->neg_zeros = 0;
277 for (
i = 0;
i < nb_samples;
i++) {
285 for (
i = 0;
i < nb_samples;
i++) {
304 for (
i = 0;
i < nb_samples;
i++)
307 for (
i = 0;
i < nb_samples;
i++) {
313 s->float_max_exp =
s->max_exp;
317 else if (
s->shifted_ones && !
s->shifted_zeros)
319 else if (
s->shifted_ones &&
s->shifted_zeros)
321 else if (
s->ordata && !(
s->ordata & 1)) {
325 }
while (!(
s->ordata & 1));
330 shift_stereo(samples_l, samples_r, nb_samples,
s->float_shift);
340 if (
s->false_zeros ||
s->neg_zeros)
354 uint32_t magdata = 0, ordata = 0, xordata = 0, anddata = ~0;
355 int i, total_shift = 0;
357 s->int32_sent_bits =
s->int32_zeros =
s->int32_ones =
s->int32_dups = 0;
360 for (
i = 0;
i < nb_samples;
i++) {
363 magdata |= (
M < 0) ? ~
M :
M;
364 xordata |=
M ^ -(
M & 1);
368 if ((ordata & 1) && !(anddata & 1) && (xordata & 2))
372 for (
i = 0;
i < nb_samples;
i++) {
376 magdata |= (
L < 0) ? ~
L :
L;
377 magdata |= (
R < 0) ? ~
R :
R;
378 xordata |=
L ^ -(
L & 1);
379 xordata |=
R ^ -(
R & 1);
383 if ((ordata & 1) && !(anddata & 1) && (xordata & 2))
404 }
while (!(ordata & 1));
405 }
else if (anddata & 1) {
411 }
while (anddata & 1);
412 }
else if (!(xordata & 2)) {
418 }
while (!(xordata & 2));
425 shift_mono(samples_l, nb_samples, total_shift);
427 shift_stereo(samples_l, samples_r, nb_samples, total_shift);
435 uint32_t magdata = 0, ordata = 0, xordata = 0, anddata = ~0;
436 uint32_t crc = 0xffffffffu;
437 int i, total_shift = 0;
439 s->int32_sent_bits =
s->int32_zeros =
s->int32_ones =
s->int32_dups = 0;
442 for (
i = 0;
i < nb_samples;
i++) {
445 crc = crc * 9 + (
M & 0xffff) * 3 + ((
M >> 16) & 0xffff);
446 magdata |= (
M < 0) ? ~
M :
M;
447 xordata |=
M ^ -(
M & 1);
452 for (
i = 0;
i < nb_samples;
i++) {
456 crc = crc * 9 + (
L & 0xffff) * 3 + ((
L >> 16) & 0xffff);
457 crc = crc * 9 + (
R & 0xffff) * 3 + ((
R >> 16) & 0xffff);
458 magdata |= (
L < 0) ? ~
L :
L;
459 magdata |= (
R < 0) ? ~
R :
R;
460 xordata |=
L ^ -(
L & 1);
461 xordata |=
R ^ -(
R & 1);
486 }
while (!(ordata & 1));
487 else if (anddata & 1)
493 }
while (anddata & 1);
494 else if (!(xordata & 2))
500 }
while (!(xordata & 2));
504 total_shift +=
s->int32_sent_bits;
513 shift_mono(samples_l, nb_samples, total_shift);
515 shift_stereo(samples_l, samples_r, nb_samples, total_shift);
518 return s->int32_sent_bits;
535 result += (result + 64) >> 7;
546 int nb_samples,
struct Decorr *dpp,
int dir)
553 out_samples += (nb_samples - 1);
554 in_samples += (nb_samples - 1);
563 while (nb_samples--) {
569 dpp->
samplesA[0] = left = in_samples[0];
574 out_samples[0] = left;
578 }
else if (dpp->
value > 0) {
579 while (nb_samples--) {
584 dpp->
samplesA[k] = left = in_samples[0];
590 out_samples[0] = left;
627 }
else if (dpp->
value > 1) {
630 for (
i = 0, j = dpp->
value - 1, k = 0; k < dpp->
value / 2;
i++, j--, k++) {
640 #define count_bits(av) ((av) ? 32 - ff_clz(av) : 0)
642 static uint32_t
log2sample(uint32_t v,
int limit, uint32_t *result)
646 if ((v += v >> 9) < (1 << 8)) {
649 *result += dbits = (dbits << 8) +
ff_wp_log2_table[(v >> (dbits - 9)) & 0xff];
651 if (limit && dbits >= limit)
661 while (nb_samples--) {
669 int nb_samples,
int limit)
672 while (nb_samples--) {
681 int nb_samples,
struct Decorr *dpp,
684 struct Decorr dp, *dppi = dpp + tindex;
692 pre_delta =
delta + 1;
696 dp.
delta = pre_delta;
710 decorr_mono(samples, outsamples, nb_samples, &dp, 1);
716 decorr_mono(samples, outsamples, nb_samples, &dp, 1);
720 int depth,
int delta, uint32_t input_bits)
722 int term, branches =
s->num_branches - depth;
724 uint32_t term_bits[22],
bits;
726 if (branches < 1 || depth + 1 == info->nterms)
730 samples =
s->sampleptrs[depth][0];
731 outsamples =
s->sampleptrs[depth + 1][0];
733 for (term = 1; term <= 18; term++) {
734 if (term == 17 && branches == 1 && depth + 1 < info->
nterms)
737 if (term > 8 && term < 17)
740 if (!
s->extra_flags && (term > 4 && term < 17))
748 if (bits < info->best_bits) {
751 memcpy(
s->decorr_passes, info->
dps,
sizeof(info->
dps[0]) * (depth + 1));
752 memcpy(
s->sampleptrs[info->
nterms + 1][0],
753 s->sampleptrs[depth + 1][0],
s->block_samples * 4);
756 term_bits[term + 3] =
bits;
759 while (depth + 1 < info->
nterms && branches--) {
760 uint32_t local_best_bits = input_bits;
761 int best_term = 0,
i;
763 for (
i = 0;
i < 22;
i++)
764 if (term_bits[
i] && term_bits[
i] < local_best_bits) {
765 local_best_bits = term_bits[
i];
772 term_bits[best_term + 3] = 0;
790 memcpy(info->
dps,
s->decorr_passes,
sizeof(
s->decorr_passes));
793 for (ri = 0; ri < info->
nterms &&
s->decorr_passes[ri].value; ri++) {
795 if (ri + 1 >= info->
nterms || !
s->decorr_passes[ri+1].value)
798 if (
s->decorr_passes[ri].value ==
s->decorr_passes[ri+1].value) {
800 s->block_samples, info->
dps, ri);
804 info->
dps[ri ] =
s->decorr_passes[ri+1];
805 info->
dps[ri+1] =
s->decorr_passes[ri ];
807 for (
i = ri;
i < info->
nterms &&
s->decorr_passes[
i].value;
i++)
809 s->block_samples, info->
dps,
i);
812 if (bits < info->best_bits) {
816 memcpy(
s->decorr_passes, info->
dps,
sizeof(info->
dps[0]) *
i);
817 memcpy(
s->sampleptrs[info->
nterms + 1][0],
s->sampleptrs[
i][0],
818 s->block_samples * 4);
820 info->
dps[ri ] =
s->decorr_passes[ri];
821 info->
dps[ri+1] =
s->decorr_passes[ri+1];
823 s->block_samples, info->
dps, ri);
831 int lower = 0,
delta, d;
834 if (!
s->decorr_passes[0].value)
836 delta =
s->decorr_passes[0].delta;
838 for (d =
delta - 1; d >= 0; d--) {
841 for (
i = 0;
i < info->
nterms &&
s->decorr_passes[
i].value;
i++) {
845 s->block_samples, info->
dps,
i);
855 memcpy(
s->decorr_passes, info->
dps,
sizeof(info->
dps[0]) *
i);
856 memcpy(
s->sampleptrs[info->
nterms + 1][0],
s->sampleptrs[
i][0],
857 s->block_samples * 4);
860 for (d =
delta + 1; !lower && d <= 7; d++) {
863 for (
i = 0;
i < info->
nterms &&
s->decorr_passes[
i].value;
i++) {
867 s->block_samples, info->
dps,
i);
876 memcpy(
s->decorr_passes, info->
dps,
sizeof(info->
dps[0]) *
i);
877 memcpy(
s->sampleptrs[info->
nterms + 1][0],
s->sampleptrs[
i][0],
878 s->block_samples * 4);
886 for (
i = 0;
i < nterms + 2;
i++) {
888 s->block_samples * 4);
889 if (!
s->sampleptrs[
i][0])
893 s->block_samples * 4);
894 if (!
s->sampleptrs[
i][1])
906 for (
i = 0;
i < 2;
i++) {
908 s->block_samples * 4);
909 if (!
s->best_buffer[0])
913 s->block_samples * 4);
914 if (!
s->temp_buffer[
i][0])
918 s->block_samples * 4);
919 if (!
s->best_buffer[1])
923 s->block_samples * 4);
924 if (!
s->temp_buffer[
i][1])
945 memcpy(info.
dps,
s->decorr_passes,
sizeof(info.
dps));
946 memcpy(
s->sampleptrs[0][0], samples,
s->block_samples * 4);
950 s->block_samples, info.
dps +
i, 1);
953 memcpy(
s->sampleptrs[info.
nterms + 1][0],
s->sampleptrs[
i][0],
s->block_samples * 4);
957 log2mono(
s->sampleptrs[0][0],
s->block_samples, 0));
966 s->delta_decay = (float)((
s->delta_decay * 2.0 +
s->decorr_passes[0].delta) / 3.0);
968 s->delta_decay = 2.0;
975 memcpy(samples,
s->sampleptrs[info.
nterms + 1][0],
s->block_samples * 4);
978 if (!
s->decorr_passes[
i].value)
985 int32_t *samples,
int nb_samples,
int dir)
988 samples += nb_samples - 1;
990 while (nb_samples--) {
991 uint32_t low,
value = labs(samples[0]);
1017 int no_history,
int do_samples)
1019 struct Decorr temp_decorr_pass, save_decorr_passes[
MAX_TERMS] = {{0}};
1020 int nb_samples =
s->block_samples;
1021 int buf_size =
sizeof(
int32_t) * nb_samples;
1022 uint32_t best_size = UINT32_MAX,
size;
1023 int log_limit, pi,
i, ret;
1025 for (
i = 0;
i < nb_samples;
i++)
1029 if (
i == nb_samples) {
1037 log_limit =
FFMIN(6912, log_limit);
1042 if (no_history ||
s->num_passes >= 7)
1043 s->best_decorr =
s->mask_decorr = 0;
1045 for (pi = 0; pi <
s->num_passes;) {
1052 if (
s->mask_decorr == 0)
1055 c = (
s->best_decorr & (
s->mask_decorr - 1)) |
s->mask_decorr;
1057 if (
c ==
s->best_decorr) {
1058 s->mask_decorr =
s->mask_decorr ? ((
s->mask_decorr << 1) & (
s->num_decorrs - 1)) : 1;
1063 wpds = &
s->decorr_specs[
c];
1067 memcpy(
s->temp_buffer[0][0], samples, buf_size);
1068 CLEAR(save_decorr_passes);
1070 for (j = 0; j < nterms; j++) {
1071 CLEAR(temp_decorr_pass);
1075 if (temp_decorr_pass.
value < 0)
1076 temp_decorr_pass.
value = 1;
1078 decorr_mono(
s->temp_buffer[j&1][0],
s->temp_buffer[~j&1][0],
1079 FFMIN(nb_samples, 2048), &temp_decorr_pass, -1);
1087 memcpy(save_decorr_passes + j, &temp_decorr_pass,
sizeof(
struct Decorr));
1088 decorr_mono(
s->temp_buffer[j&1][0],
s->temp_buffer[~j&1][0],
1089 nb_samples, &temp_decorr_pass, 1);
1092 size =
log2mono(
s->temp_buffer[j&1][0], nb_samples, log_limit);
1093 if (
size != UINT32_MAX || !nterms)
1098 if (
size < best_size) {
1099 memcpy(
s->best_buffer[0],
s->temp_buffer[j&1][0], buf_size);
1100 memcpy(
s->decorr_passes, save_decorr_passes,
sizeof(
struct Decorr) *
MAX_TERMS);
1101 s->num_terms = nterms;
1107 s->mask_decorr =
s->mask_decorr ? ((
s->mask_decorr << 1) & (
s->num_decorrs - 1)) : 1;
1112 else if (do_samples)
1113 memcpy(samples,
s->best_buffer[0], buf_size);
1115 if (no_history ||
s->extra_flags) {
1117 scan_word(
s, &
s->w.c[0],
s->best_buffer[0], nb_samples, -1);
1124 int nb_samples,
struct Decorr *dpp,
int dir)
1131 out_left += nb_samples - 1;
1132 out_right += nb_samples - 1;
1133 in_left += nb_samples - 1;
1134 in_right += nb_samples - 1;
1145 switch (dpp->
value) {
1147 while (nb_samples--) {
1169 while (nb_samples--) {
1191 while (nb_samples--) {
1215 while (nb_samples--) {
1252 while (nb_samples--) {
1271 while (nb_samples--) {
1290 while (nb_samples--) {
1320 if (dpp->
value & 1) {
1333 if (dpp->
value & 1) {
1343 }
else if (dpp->
value > 1) {
1346 for (
i = 0, j = dpp->
value - 1, k = 0; k < dpp->
value / 2;
i++, j--, k++) {
1361 int nb_samples,
struct Decorr *dpp)
1373 switch (dpp->
value) {
1375 for (
i = 0;
i < nb_samples;
i++) {
1390 for (
i = 0;
i < nb_samples;
i++) {
1405 for (
i = 0;
i < nb_samples;
i++) {
1422 for (
i = 0;
i < nb_samples;
i++) {
1453 for (
i = 0;
i < nb_samples;
i++) {
1465 for (
i = 0;
i < nb_samples;
i++) {
1477 for (
i = 0;
i < nb_samples;
i++) {
1498 int nb_samples,
int tindex)
1500 struct Decorr dp = {0}, *dppi = info->
dps + tindex;
1501 int delta = dppi->delta, pre_delta;
1502 int term = dppi->value;
1509 pre_delta =
delta + 1;
1512 dp.
delta = pre_delta;
1514 FFMIN(2048, nb_samples), &dp, -1);
1531 decorr_stereo(in_left, in_right, out_left, out_right, nb_samples, &dp, 1);
1535 dppi->weightA = dp.
weightA = dp.
sumA / nb_samples;
1536 dppi->weightB = dp.
weightB = dp.
sumB / nb_samples;
1541 nb_samples, &dp, 1);
1555 memcpy(info->
dps,
s->decorr_passes,
sizeof(
s->decorr_passes));
1558 for (ri = 0; ri < info->
nterms &&
s->decorr_passes[ri].value; ri++) {
1560 if (ri + 1 >= info->
nterms || !
s->decorr_passes[ri+1].value)
1563 if (
s->decorr_passes[ri].value ==
s->decorr_passes[ri+1].value) {
1565 s->sampleptrs[ri ][0],
s->sampleptrs[ri ][1],
1566 s->sampleptrs[ri+1][0],
s->sampleptrs[ri+1][1],
1567 s->block_samples, ri);
1571 info->
dps[ri ] =
s->decorr_passes[ri+1];
1572 info->
dps[ri+1] =
s->decorr_passes[ri ];
1574 for (
i = ri;
i < info->
nterms &&
s->decorr_passes[
i].value;
i++)
1576 s->sampleptrs[
i ][0],
s->sampleptrs[
i ][1],
1577 s->sampleptrs[
i+1][0],
s->sampleptrs[
i+1][1],
1578 s->block_samples,
i);
1583 if (bits < info->best_bits) {
1587 memcpy(
s->decorr_passes, info->
dps,
sizeof(info->
dps[0]) *
i);
1588 memcpy(
s->sampleptrs[info->
nterms + 1][0],
1589 s->sampleptrs[
i][0],
s->block_samples * 4);
1590 memcpy(
s->sampleptrs[info->
nterms + 1][1],
1591 s->sampleptrs[
i][1],
s->block_samples * 4);
1593 info->
dps[ri ] =
s->decorr_passes[ri ];
1594 info->
dps[ri+1] =
s->decorr_passes[ri+1];
1596 s->sampleptrs[ri ][0],
s->sampleptrs[ri ][1],
1597 s->sampleptrs[ri+1][0],
s->sampleptrs[ri+1][1],
1598 s->block_samples, ri);
1606 int lower = 0,
delta, d,
i;
1609 if (!
s->decorr_passes[0].value)
1611 delta =
s->decorr_passes[0].delta;
1613 for (d =
delta - 1; d >= 0; d--) {
1614 for (
i = 0;
i < info->
nterms &&
s->decorr_passes[
i].value;
i++) {
1618 s->sampleptrs[
i ][0],
s->sampleptrs[
i ][1],
1619 s->sampleptrs[
i+1][0],
s->sampleptrs[
i+1][1],
1620 s->block_samples,
i);
1630 memcpy(
s->decorr_passes, info->
dps,
sizeof(info->
dps[0]) *
i);
1631 memcpy(
s->sampleptrs[info->
nterms + 1][0],
s->sampleptrs[
i][0],
1632 s->block_samples * 4);
1633 memcpy(
s->sampleptrs[info->
nterms + 1][1],
s->sampleptrs[
i][1],
1634 s->block_samples * 4);
1637 for (d =
delta + 1; !lower && d <= 7; d++) {
1638 for (
i = 0;
i < info->
nterms &&
s->decorr_passes[
i].value;
i++) {
1642 s->sampleptrs[
i ][0],
s->sampleptrs[
i ][1],
1643 s->sampleptrs[
i+1][0],
s->sampleptrs[
i+1][1],
1644 s->block_samples,
i);
1650 if (bits < info->best_bits) {
1653 memcpy(
s->decorr_passes, info->
dps,
sizeof(info->
dps[0]) *
i);
1654 memcpy(
s->sampleptrs[info->
nterms + 1][0],
1655 s->sampleptrs[
i][0],
s->block_samples * 4);
1656 memcpy(
s->sampleptrs[info->
nterms + 1][1],
1657 s->sampleptrs[
i][1],
s->block_samples * 4);
1665 int depth,
int delta, uint32_t input_bits)
1667 int term, branches =
s->num_branches - depth;
1668 int32_t *in_left, *in_right, *out_left, *out_right;
1669 uint32_t term_bits[22],
bits;
1671 if (branches < 1 || depth + 1 == info->nterms)
1675 in_left =
s->sampleptrs[depth ][0];
1676 in_right =
s->sampleptrs[depth ][1];
1677 out_left =
s->sampleptrs[depth + 1][0];
1678 out_right =
s->sampleptrs[depth + 1][1];
1680 for (term = -3; term <= 18; term++) {
1681 if (!term || (term > 8 && term < 17))
1684 if (term == 17 && branches == 1 && depth + 1 < info->
nterms)
1687 if (term == -1 || term == -2)
1691 if (!
s->extra_flags && (term > 4 && term < 17))
1697 s->block_samples, depth);
1700 if (bits < info->best_bits) {
1703 memcpy(
s->decorr_passes, info->
dps,
sizeof(info->
dps[0]) * (depth + 1));
1704 memcpy(
s->sampleptrs[info->
nterms + 1][0],
s->sampleptrs[depth + 1][0],
1705 s->block_samples * 4);
1706 memcpy(
s->sampleptrs[info->
nterms + 1][1],
s->sampleptrs[depth + 1][1],
1707 s->block_samples * 4);
1710 term_bits[term + 3] =
bits;
1713 while (depth + 1 < info->
nterms && branches--) {
1714 uint32_t local_best_bits = input_bits;
1715 int best_term = 0,
i;
1717 for (
i = 0;
i < 22;
i++)
1718 if (term_bits[
i] && term_bits[
i] < local_best_bits) {
1719 local_best_bits = term_bits[
i];
1726 term_bits[best_term + 3] = 0;
1728 info->
dps[depth].
value = best_term;
1731 s->block_samples, depth);
1754 memcpy(info.
dps,
s->decorr_passes,
sizeof(info.
dps));
1755 memcpy(
s->sampleptrs[0][0], in_left,
s->block_samples * 4);
1756 memcpy(
s->sampleptrs[0][1], in_right,
s->block_samples * 4);
1761 s->sampleptrs[
i + 1][0],
s->sampleptrs[
i + 1][1],
1762 s->block_samples, info.
dps +
i, 1);
1765 s->sampleptrs[
i + 1][0],
s->sampleptrs[
i + 1][1],
1766 s->block_samples, info.
dps +
i);
1769 s->block_samples, 0);
1771 memcpy(
s->sampleptrs[info.
nterms + 1][0],
s->sampleptrs[
i][0],
s->block_samples * 4);
1772 memcpy(
s->sampleptrs[info.
nterms + 1][1],
s->sampleptrs[
i][1],
s->block_samples * 4);
1777 s->block_samples, 0));
1786 s->delta_decay = (float)((
s->delta_decay * 2.0 +
s->decorr_passes[0].delta) / 3.0);
1788 s->delta_decay = 2.0;
1795 memcpy(in_left,
s->sampleptrs[info.
nterms + 1][0],
s->block_samples * 4);
1796 memcpy(in_right,
s->sampleptrs[info.
nterms + 1][1],
s->block_samples * 4);
1800 if (!
s->decorr_passes[
i].value)
1808 int no_history,
int do_samples)
1810 struct Decorr temp_decorr_pass, save_decorr_passes[
MAX_TERMS] = {{0}};
1811 int nb_samples =
s->block_samples, ret;
1812 int buf_size =
sizeof(
int32_t) * nb_samples;
1813 int log_limit, force_js = 0, force_ts = 0, got_js = 0, pi,
i;
1814 uint32_t best_size = UINT32_MAX,
size;
1816 for (
i = 0;
i < nb_samples;
i++)
1817 if (samples_l[
i] || samples_r[
i])
1820 if (
i == nb_samples) {
1829 log_limit =
FFMIN(6912, log_limit);
1831 if (
s->joint != -1) {
1832 force_js =
s->joint;
1833 force_ts = !
s->joint;
1839 if (no_history ||
s->num_passes >= 7)
1840 s->best_decorr =
s->mask_decorr = 0;
1842 for (pi = 0; pi <
s->num_passes;) {
1849 if (
s->mask_decorr == 0)
1852 c = (
s->best_decorr & (
s->mask_decorr - 1)) |
s->mask_decorr;
1854 if (
c ==
s->best_decorr) {
1855 s->mask_decorr =
s->mask_decorr ? ((
s->mask_decorr << 1) & (
s->num_decorrs - 1)) : 1;
1860 wpds = &
s->decorr_specs[
c];
1868 memcpy(
s->js_left, samples_l, buf_size);
1869 memcpy(
s->js_right, samples_r, buf_size);
1871 for (
i = 0;
i < nb_samples;
i++)
1872 s->js_right[
i] += ((
s->js_left[
i] -=
s->js_right[
i]) >> 1);
1876 memcpy(
s->temp_buffer[0][0],
s->js_left, buf_size);
1877 memcpy(
s->temp_buffer[0][1],
s->js_right, buf_size);
1879 memcpy(
s->temp_buffer[0][0], samples_l, buf_size);
1880 memcpy(
s->temp_buffer[0][1], samples_r, buf_size);
1883 CLEAR(save_decorr_passes);
1885 for (j = 0; j < nterms; j++) {
1886 CLEAR(temp_decorr_pass);
1891 temp_decorr_pass.
value = -3;
1894 s->temp_buffer[~j&1][0],
s->temp_buffer[~j&1][1],
1895 FFMIN(2048, nb_samples), &temp_decorr_pass, -1);
1904 memcpy(save_decorr_passes + j, &temp_decorr_pass,
sizeof(
struct Decorr));
1908 s->temp_buffer[~j&1][0],
s->temp_buffer[~j&1][1],
1909 nb_samples, &temp_decorr_pass, 1);
1912 s->temp_buffer[~j&1][0],
s->temp_buffer[~j&1][1],
1913 nb_samples, &temp_decorr_pass);
1917 nb_samples, log_limit);
1918 if (
size != UINT32_MAX || !nterms)
1923 if (
size < best_size) {
1924 memcpy(
s->best_buffer[0],
s->temp_buffer[j&1][0], buf_size);
1925 memcpy(
s->best_buffer[1],
s->temp_buffer[j&1][1], buf_size);
1926 memcpy(
s->decorr_passes, save_decorr_passes,
sizeof(
struct Decorr) *
MAX_TERMS);
1927 s->num_terms = nterms;
1933 s->mask_decorr =
s->mask_decorr ? ((
s->mask_decorr << 1) & (
s->num_decorrs - 1)) : 1;
1936 if (force_js || (
s->decorr_specs[
s->best_decorr].joint_stereo && !force_ts))
1941 if (
s->extra_flags) {
1946 memcpy(samples_l,
s->js_left, buf_size);
1947 memcpy(samples_r,
s->js_right, buf_size);
1951 }
else if (do_samples) {
1952 memcpy(samples_l,
s->best_buffer[0], buf_size);
1953 memcpy(samples_r,
s->best_buffer[1], buf_size);
1956 if (
s->extra_flags || no_history ||
1957 s->joint_stereo !=
s->decorr_specs[
s->best_decorr].joint_stereo) {
1958 s->joint_stereo =
s->decorr_specs[
s->best_decorr].joint_stereo;
1960 scan_word(
s, &
s->w.c[0],
s->best_buffer[0], nb_samples, -1);
1961 scan_word(
s, &
s->w.c[1],
s->best_buffer[1], nb_samples, -1);
1979 put_bits(pb, cbits, (1 << cbits) - 1);
1986 while (
w->zeros_acc > 1) {
1994 if (
w->holding_one) {
1995 if (
w->holding_one >= 16) {
2000 w->holding_one -= 16;
2008 put_bits(pb, cbits, (1 << cbits) - 1);
2015 while (
w->holding_one > 1) {
2017 w->holding_one >>= 1;
2020 w->holding_zero = 0;
2022 put_bits(pb,
w->holding_one, (1 <<
w->holding_one) - 1);
2028 if (
w->holding_zero) {
2030 w->holding_zero = 0;
2033 if (
w->pend_count) {
2035 w->pend_data =
w->pend_count = 0;
2042 uint32_t ones_count, low, high;
2045 if (
s->w.c[0].median[0] < 2 && !
s->w.holding_zero &&
s->w.c[1].median[0] < 2) {
2067 ones_count = low = 0;
2088 low += (ones_count - 2) *
GET_MED(2);
2095 if (
w->holding_zero) {
2102 w->holding_zero = 1;
2105 w->holding_zero = 0;
2107 w->holding_zero = 1;
2109 w->holding_one = ones_count * 2;
2112 uint32_t maxcode = high - low,
code =
sample - low;
2114 uint32_t extras = (1 << bitcount) - maxcode - 1;
2116 if (
code < extras) {
2117 w->pend_data |=
code <<
w->pend_count;
2118 w->pend_count += bitcount - 1;
2120 w->pend_data |= ((
code + extras) >> 1) <<
w->pend_count;
2121 w->pend_count += bitcount - 1;
2122 w->pend_data |= ((
code + extras) & 1) <<
w->pend_count++;
2126 w->pend_data |= ((
int32_t) sign <<
w->pend_count++);
2128 if (!
w->holding_zero)
2136 const int sent_bits =
s->int32_sent_bits;
2140 pre_shift =
s->int32_zeros +
s->int32_ones +
s->int32_dups;
2146 for (
i = 0;
i < nb_samples;
i++) {
2147 put_sbits(pb, sent_bits, samples_l[
i] >> pre_shift);
2150 for (
i = 0;
i < nb_samples;
i++) {
2151 put_sbits(pb, sent_bits, samples_l[
i] >> pre_shift);
2152 put_sbits(pb, sent_bits, samples_r[
i] >> pre_shift);
2159 const int max_exp =
s->float_max_exp;
2177 shift_count = max_exp ? max_exp - 1 : 0;
2181 if (shift_count < 25)
2182 value >>= shift_count;
2203 }
else if (shift_count) {
2219 for (
i = 0;
i < nb_samples;
i++)
2222 for (
i = 0;
i < nb_samples;
i++) {
2235 switch (dpp->
value) {
2237 for (
i = 0;
i < nb_samples;
i++) {
2252 for (
i = 0;
i < nb_samples;
i++) {
2295 for (
i = 0;
i < nb_samples;
i++) {
2307 for (
i = 0;
i < nb_samples;
i++) {
2319 for (
i = 0;
i < nb_samples;
i++) {
2337 #define update_weight_d2(weight, delta, source, result) \
2338 if (source && result) \
2339 weight -= (((source ^ result) >> 29) & 4) - 2;
2341 #define update_weight_clip_d2(weight, delta, source, result) \
2342 if (source && result) { \
2343 const int32_t s = (source ^ result) >> 31; \
2344 if ((weight = (weight ^ s) + (2 - s)) > 1024) weight = 1024; \
2345 weight = (weight ^ s) - s; \
2354 switch (dpp->
value) {
2356 for (
i = 0;
i < nb_samples;
i++) {
2371 for (
i = 0;
i < nb_samples;
i++) {
2415 for (
i = 0;
i < nb_samples;
i++) {
2427 for (
i = 0;
i < nb_samples;
i++) {
2439 for (
i = 0;
i < nb_samples;
i++) {
2462 bytestream2_put_byte(pb,
flags);
2463 bytestream2_put_byte(pb, (
size + 1) >> 1);
2470 int block_size, start, end, data_size, tcount,
temp, m = 0;
2471 int i, j, ret = 0, got_extra = 0, nb_samples =
s->block_samples;
2472 uint32_t crc = 0xffffffffu;
2479 if (!(
s->flags &
WV_MONO) &&
s->optimize_mono) {
2482 for (
i = 0;
i < nb_samples;
i++) {
2483 lor |= samples_l[
i] | samples_r[
i];
2484 diff |= samples_l[
i] - samples_r[
i];
2490 if (
i == nb_samples && lor && !
diff) {
2494 if (!
s->false_stereo) {
2495 s->false_stereo = 1;
2499 }
else if (
s->false_stereo) {
2500 s->false_stereo = 0;
2515 if ((mag -=
shift) < 0)
2523 memcpy(
s->orig_l, samples_l,
sizeof(
int32_t) * nb_samples);
2526 memcpy(
s->orig_r, samples_r,
sizeof(
int32_t) * nb_samples);
2530 got_extra =
scan_float(
s, samples_l, samples_r, nb_samples);
2532 got_extra =
scan_int32(
s, samples_l, samples_r, nb_samples);
2536 if (
s->shift !=
s->int32_zeros +
s->int32_ones +
s->int32_dups) {
2537 s->shift =
s->int32_zeros +
s->int32_ones +
s->int32_dups;
2542 if (!
s->num_passes && !
s->num_terms) {
2548 ret =
wv_stereo(
s, samples_l, samples_r, 1, 0);
2553 for (
i = 0;
i < nb_samples;
i++)
2554 crc += (crc << 1) + samples_l[
i];
2557 ret =
wv_mono(
s, samples_l, !
s->num_terms, 1);
2559 for (
i = 0;
i < nb_samples;
i++)
2560 crc += (crc << 3) + ((uint32_t)samples_l[
i] << 1) + samples_l[
i] + samples_r[
i];
2563 ret =
wv_stereo(
s, samples_l, samples_r, !
s->num_terms, 1);
2571 s->ch_offset += 1 + !(
s->flags &
WV_MONO);
2573 if (
s->ch_offset ==
s->avctx->channels)
2577 bytestream2_put_le32(&pb,
MKTAG(
'w',
'v',
'p',
'k'));
2578 bytestream2_put_le32(&pb, 0);
2579 bytestream2_put_le16(&pb, 0x410);
2580 bytestream2_put_le16(&pb, 0);
2581 bytestream2_put_le32(&pb, 0);
2582 bytestream2_put_le32(&pb,
s->sample_index);
2583 bytestream2_put_le32(&pb, nb_samples);
2584 bytestream2_put_le32(&pb,
s->flags);
2585 bytestream2_put_le32(&pb, crc);
2591 bytestream2_put_byte(&pb,
s->avctx->channels);
2592 bytestream2_put_le32(&pb,
s->avctx->channel_layout);
2593 bytestream2_put_byte(&pb, 0);
2598 bytestream2_put_le24(&pb,
s->avctx->sample_rate);
2599 bytestream2_put_byte(&pb, 0);
2603 for (
i = 0;
i <
s->num_terms;
i++) {
2604 struct Decorr *dpp = &
s->decorr_passes[
i];
2605 bytestream2_put_byte(&pb, ((dpp->
value + 5) & 0x1f) | ((dpp->
delta << 5) & 0xe0));
2607 if (
s->num_terms & 1)
2608 bytestream2_put_byte(&pb, 0);
2610 #define WRITE_DECWEIGHT(type) do { \
2611 temp = store_weight(type); \
2612 bytestream2_put_byte(&pb, temp); \
2613 type = restore_weight(temp); \
2617 bytestream2_put_byte(&pb, 0);
2619 for (
i =
s->num_terms - 1;
i >= 0; --
i) {
2620 struct Decorr *dpp = &
s->decorr_passes[
i];
2627 for (
i = 0;
i <
s->num_terms;
i++) {
2628 struct Decorr *dpp = &
s->decorr_passes[
i];
2639 out[start - 1] = (end - start + 1) >> 1;
2640 if ((end - start) & 1)
2641 bytestream2_put_byte(&pb, 0);
2643 #define WRITE_DECSAMPLE(type) do { \
2644 temp = log2s(type); \
2645 type = wp_exp2(temp); \
2646 bytestream2_put_le16(&pb, temp); \
2650 bytestream2_put_byte(&pb, 0);
2652 for (
i = 0;
i <
s->num_terms;
i++) {
2653 struct Decorr *dpp = &
s->decorr_passes[
i];
2662 }
else if (dpp->
value < 0) {
2666 for (j = 0; j < dpp->
value; j++) {
2678 out[start - 1] = (end - start) >> 1;
2680 #define WRITE_CHAN_ENTROPY(chan) do { \
2681 for (i = 0; i < 3; i++) { \
2682 temp = wp_log2(s->w.c[chan].median[i]); \
2683 bytestream2_put_le16(&pb, temp); \
2684 s->w.c[chan].median[i] = wp_exp2(temp); \
2695 bytestream2_put_byte(&pb,
s->float_flags);
2696 bytestream2_put_byte(&pb,
s->float_shift);
2697 bytestream2_put_byte(&pb,
s->float_max_exp);
2698 bytestream2_put_byte(&pb, 127);
2703 bytestream2_put_byte(&pb,
s->int32_sent_bits);
2704 bytestream2_put_byte(&pb,
s->int32_zeros);
2705 bytestream2_put_byte(&pb,
s->int32_ones);
2706 bytestream2_put_byte(&pb,
s->int32_dups);
2710 for (
i = 0;
i < nb_samples;
i++) {
2713 for (tcount =
s->num_terms, dpp =
s->decorr_passes; tcount--; dpp++) {
2734 samples_l[
i] =
code;
2737 for (tcount =
s->num_terms, dpp =
s->decorr_passes; tcount--; dpp++)
2752 }
else if (!
s->num_passes) {
2754 for (
i = 0;
i < nb_samples;
i++)
2755 samples_r[
i] += ((samples_l[
i] -= samples_r[
i]) >> 1);
2758 for (
i = 0;
i <
s->num_terms;
i++) {
2759 struct Decorr *dpp = &
s->decorr_passes[
i];
2770 for (
i = 0;
i < nb_samples;
i++)
2773 for (
i = 0;
i < nb_samples;
i++) {
2781 bytestream2_put_le24(&pb, (data_size + 1) >> 1);
2784 bytestream2_put_byte(&pb, 0);
2795 bytestream2_put_le24(&pb, (data_size + 5) >> 1);
2796 bytestream2_put_le32(&pb,
s->crc_x);
2799 bytestream2_put_byte(&pb, 0);
2816 #define COPY_SAMPLES(type, offset, shift) do { \
2817 const type *sptr = (const type *)src; \
2818 for (i = 0; i < nb_samples; i++) \
2819 dst[i] = (sptr[i] - offset) >> shift; \
2822 switch (
s->avctx->sample_fmt) {
2830 if (
s->avctx->bits_per_raw_sample <= 24) {
2835 memcpy(dst,
src, nb_samples * 4);
2843 for (
i = 0;
i < 15;
i++) {
2860 sizeof(
int32_t) *
s->block_samples);
2865 sizeof(
int32_t) *
s->block_samples);
2870 buf_size =
s->block_samples * avctx->
channels * 8
2876 for (
s->ch_offset = 0;
s->ch_offset < avctx->
channels;) {
2879 switch (
s->avctx->sample_fmt) {
2886 if (avctx->
channels -
s->ch_offset == 1) {
2893 s->flags += (1 <<
MAG_LSB) * ((
s->flags & 3) * 8 + 7);
2896 buf, buf_size)) < 0)
2907 *got_packet_ptr = 1;
2919 s->sampleptrs_size[
i][0] =
s->sampleptrs_size[
i][1] = 0;
2922 for (
i = 0;
i < 2;
i++) {
2924 s->samples_size[
i] = 0;
2927 s->best_buffer_size[
i] = 0;
2931 s->temp_buffer_size[
i][0] =
s->temp_buffer_size[
i][1] = 0;
2936 s->js_left_size =
s->js_right_size = 0;
2940 s->orig_l_size =
s->orig_r_size = 0;
2945 #define OFFSET(x) offsetof(WavPackEncodeContext, x)
2946 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
static enum AVSampleFormat sample_fmts[]
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Libavcodec external API header.
#define FF_COMPRESSION_DEFAULT
static av_cold int init(AVCodecContext *avctx)
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
static av_always_inline void bytestream2_skip_p(PutByteContext *p, unsigned int size)
static av_always_inline int bytestream2_get_bytes_left_p(PutByteContext *p)
static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p)
#define flags(name, subs,...)
#define MKTAG(a, b, c, d)
static __device__ float floor(float a)
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
#define AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_STEREO
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
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...
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
AVSampleFormat
Audio sample formats.
@ AV_SAMPLE_FMT_FLTP
float, planar
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
#define LIBAVUTIL_VERSION_INT
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
static int weight(int i, int blen, int offset)
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static const uint16_t mask[17]
static void put_sbits(PutBitContext *pb, int n, int32_t value)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static int put_bits_count(PutBitContext *s)
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static int shift(int a, int b)
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
main external API structure.
int sample_rate
samples per second
int channels
number of audio channels
int frame_size
Number of samples per channel in an audio frame.
const char * name
Name of the codec implementation.
This structure describes decoded (raw) audio or video data.
int nb_samples
number of audio samples (per channel) described by this frame
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
uint8_t ** extended_data
pointers to the data planes/channels.
This structure stores compressed data.
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int8_t terms[MAX_TERMS+1]
int32_t * sampleptrs[MAX_TERMS+2][2]
int temp_buffer_size[2][2]
int32_t * temp_buffer[2][2]
struct Decorr decorr_passes[MAX_TERMS]
int sampleptrs_size[MAX_TERMS+2][2]
const WavPackDecorrSpec * decorr_specs
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static av_always_inline int wp_exp2(int16_t val)
const uint8_t ff_wp_log2_table[256]
static const int wv_rates[16]
static av_always_inline int wp_log2(uint32_t val)
#define UPDATE_WEIGHT_CLIP(weight, delta, samples, in)
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)
static void recurse_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info, int depth, int delta, uint32_t input_bits)
static void process_float(WavPackEncodeContext *s, int32_t *sample)
AVCodec ff_wavpack_encoder
static av_cold int wavpack_encode_close(AVCodecContext *avctx)
static void analyze_mono(WavPackEncodeContext *s, int32_t *samples, int do_samples)
static void encode_flush(WavPackEncodeContext *s)
#define update_weight_clip_d2(weight, delta, source, result)
static int scan_int32(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
static const AVClass wavpack_encoder_class
#define EXTRA_ADJUST_DELTAS
static void decorr_stereo_pass2(struct Decorr *dpp, int32_t *samples_l, int32_t *samples_r, int nb_samples)
static const AVOption options[]
static uint32_t log2sample(uint32_t v, int limit, uint32_t *result)
static void reverse_decorr(struct Decorr *dpp)
static void pack_int32(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
static void wavpack_encode_sample(WavPackEncodeContext *s, WvChannel *c, int32_t sample)
static uint32_t log2stereo(int32_t *samples_l, int32_t *samples_r, int nb_samples, int limit)
static void sort_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info)
static void sort_mono(WavPackEncodeContext *s, WavPackExtraInfo *info)
static void scan_word(WavPackEncodeContext *s, WvChannel *c, int32_t *samples, int nb_samples, int dir)
#define COPY_SAMPLES(type, offset, shift)
static int wv_mono(WavPackEncodeContext *s, int32_t *samples, int no_history, int do_samples)
#define UPDATE_WEIGHT(weight, delta, source, result)
static void put_metadata_block(PutByteContext *pb, int flags, int size)
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)
static int8_t store_weight(int weight)
static void fill_buffer(WavPackEncodeContext *s, const int8_t *src, int32_t *dst, int nb_samples)
static void pack_float(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
#define update_weight_d2(weight, delta, source, result)
static uint32_t log2mono(int32_t *samples, int nb_samples, int limit)
static void recurse_mono(WavPackEncodeContext *s, WavPackExtraInfo *info, int depth, int delta, uint32_t input_bits)
static void scan_int23(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
static int allocate_buffers2(WavPackEncodeContext *s, int nterms)
static void shift_stereo(int32_t *left, int32_t *right, int nb_samples, int shift)
static int restore_weight(int8_t weight)
static void set_samplerate(WavPackEncodeContext *s)
static int allocate_buffers(WavPackEncodeContext *s)
static av_cold int wavpack_encode_init(AVCodecContext *avctx)
static int wavpack_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
#define WRITE_CHAN_ENTROPY(chan)
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)
static void delta_mono(WavPackEncodeContext *s, WavPackExtraInfo *info)
static void reverse_mono_decorr(struct Decorr *dpp)
#define WRITE_DECSAMPLE(type)
#define APPLY_WEIGHT_I(weight, sample)
static int scan_float(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
static int log2s(int32_t value)
static void shift_mono(int32_t *samples, int nb_samples, int shift)
static void delta_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info)
static void decorr_mono_buffer(int32_t *samples, int32_t *outsamples, int nb_samples, struct Decorr *dpp, int tindex)
static int wavpack_encode_block(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, uint8_t *out, int out_size)
static void decorr_mono(int32_t *in_samples, int32_t *out_samples, int nb_samples, struct Decorr *dpp, int dir)
#define WRITE_DECWEIGHT(type)
static void pack_float_sample(WavPackEncodeContext *s, int32_t *sample)
#define APPLY_WEIGHT(weight, sample)
static void analyze_stereo(WavPackEncodeContext *s, int32_t *in_left, int32_t *in_right, int do_samples)
static int wv_stereo(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int no_history, int do_samples)
static void decorr_stereo_pass_id2(struct Decorr *dpp, int32_t *samples_l, int32_t *samples_r, int nb_samples)
static const uint8_t decorr_filter_nterms[]
static const WavPackDecorrSpec *const decorr_filters[]
static const uint16_t decorr_filter_sizes[]