Go to the documentation of this file.
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 = 0xffffffff
u;
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 = 0xffffffff
u;
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;
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--) {
574 out_samples[0] =
left;
578 }
else if (dpp->
value > 0) {
579 while (nb_samples--) {
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)
646 if ((v += v >> 9) < (1 << 8)) {
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;
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)
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))
743 info->dps[depth].value = term;
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;
774 info->dps[depth].value = best_term;
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++) {
842 info->dps[
i].value =
s->decorr_passes[
i].value;
843 info->dps[
i].delta = d;
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++) {
864 info->dps[
i].value =
s->decorr_passes[
i].value;
865 info->dps[
i].delta = d;
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])
940 info.nterms =
s->num_terms;
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);
977 for (
i = 0;
i <
info.nterms;
i++)
978 if (!
s->decorr_passes[
i].value)
990 while (nb_samples--) {
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);
1581 s->block_samples,
info->log_limit);
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++) {
1615 info->dps[
i].value =
s->decorr_passes[
i].value;
1616 info->dps[
i].delta = d;
1618 s->sampleptrs[
i ][0],
s->sampleptrs[
i ][1],
1619 s->sampleptrs[
i+1][0],
s->sampleptrs[
i+1][1],
1620 s->block_samples,
i);
1624 s->block_samples,
info->log_limit);
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++) {
1639 info->dps[
i].value =
s->decorr_passes[
i].value;
1640 info->dps[
i].delta = d;
1642 s->sampleptrs[
i ][0],
s->sampleptrs[
i ][1],
1643 s->sampleptrs[
i+1][0],
s->sampleptrs[
i+1][1],
1644 s->block_samples,
i);
1648 s->block_samples,
info->log_limit);
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))
1694 info->dps[depth].value = term;
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);
1749 info.nterms =
s->num_terms;
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);
1799 for (
i = 0;
i <
info.nterms;
i++)
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 = 0xffffffff
u;
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) {
2553 for (
i = 0;
i < nb_samples;
i++)
2554 crc += (crc << 1) + samples_l[
i];
2559 for (
i = 0;
i < nb_samples;
i++)
2560 crc += (crc << 3) + ((uint32_t)samples_l[
i] << 1) + samples_l[
i] + samples_r[
i];
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++) {
2858 s->block_samples =
frame->nb_samples;
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)
2902 s->sample_index +=
frame->nb_samples;
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
int frame_size
Number of samples per channel in an audio frame.
int32_t * temp_buffer[2][2]
@ AV_SAMPLE_FMT_FLTP
float, planar
static const WavPackDecorrSpec *const decorr_filters[]
static void shift_mono(int32_t *samples, int nb_samples, int shift)
static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p)
static av_cold int init(AVCodecContext *avctx)
struct Decorr decorr_passes[MAX_TERMS]
#define update_weight_clip_d2(weight, delta, source, result)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
static int restore_weight(int8_t weight)
static uint32_t log2sample(uint32_t v, int limit, uint32_t *result)
static void encode_flush(WavPackEncodeContext *s)
int sample_rate
samples per second
#define u(width, name, range_min, range_max)
static enum AVSampleFormat sample_fmts[]
#define MKTAG(a, b, c, d)
#define WRITE_DECWEIGHT(type)
static void scan_int23(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
#define AV_CH_LAYOUT_MONO
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 av_cold int end(AVCodecContext *avctx)
static int scan_float(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
This structure describes decoded (raw) audio or video data.
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
static const AVClass wavpack_encoder_class
#define WRITE_CHAN_ENTROPY(chan)
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
static int wavpack_encode_block(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, uint8_t *out, int out_size)
#define COPY_SAMPLES(type, offset, shift)
#define FF_COMPRESSION_DEFAULT
#define update_weight_d2(weight, delta, source, result)
static void set_samplerate(WavPackEncodeContext *s)
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)
int8_t terms[MAX_TERMS+1]
static void decorr_mono_buffer(int32_t *samples, int32_t *outsamples, int nb_samples, struct Decorr *dpp, int tindex)
static void recurse_mono(WavPackEncodeContext *s, WavPackExtraInfo *info, int depth, int delta, uint32_t input_bits)
static av_cold int wavpack_encode_close(AVCodecContext *avctx)
int temp_buffer_size[2][2]
#define AV_CH_LAYOUT_STEREO
static av_always_inline int wp_log2(uint32_t val)
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static av_always_inline int bytestream2_get_bytes_left_p(PutByteContext *p)
int sampleptrs_size[MAX_TERMS+2][2]
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
static const uint16_t mask[17]
static const uint8_t decorr_filter_nterms[]
static int wv_stereo(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int no_history, int do_samples)
static const int wv_rates[16]
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static av_always_inline int wp_exp2(int16_t val)
static int8_t store_weight(int weight)
static int log2s(int32_t value)
static void delta_mono(WavPackEncodeContext *s, WavPackExtraInfo *info)
const WavPackDecorrSpec * decorr_specs
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
and forward the result(frame or status change) to the corresponding input. If nothing is possible
static void sort_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info)
const char * av_default_item_name(void *ptr)
Return the context name.
static void decorr_stereo_pass_id2(struct Decorr *dpp, int32_t *samples_l, int32_t *samples_r, int nb_samples)
static void reverse_mono_decorr(struct Decorr *dpp)
static int scan_int32(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
static void analyze_stereo(WavPackEncodeContext *s, int32_t *in_left, int32_t *in_right, int do_samples)
static void pack_int32(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
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
static av_cold int wavpack_encode_init(AVCodecContext *avctx)
static int weight(int i, int blen, int offset)
static int wavpack_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
int32_t * sampleptrs[MAX_TERMS+2][2]
static void process_float(WavPackEncodeContext *s, int32_t *sample)
static const uint16_t decorr_filter_sizes[]
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
int channels
number of audio channels
static void pack_float_sample(WavPackEncodeContext *s, int32_t *sample)
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)
#define i(width, name, range_min, range_max)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
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
static int put_bits_count(PutBitContext *s)
static av_always_inline void bytestream2_skip_p(PutByteContext *p, unsigned int size)
AVSampleFormat
Audio sample formats.
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...
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
static void put_metadata_block(PutByteContext *pb, int flags, int size)
const char * name
Name of the codec implementation.
#define EXTRA_ADJUST_DELTAS
static const uint8_t wp_log2_table[]
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define APPLY_WEIGHT(weight, sample)
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
main external API structure.
#define APPLY_WEIGHT_I(weight, sample)
static int allocate_buffers(WavPackEncodeContext *s)
#define UPDATE_WEIGHT_CLIP(weight, delta, samples, in)
static uint32_t log2mono(int32_t *samples, int nb_samples, int limit)
static void sort_mono(WavPackEncodeContext *s, WavPackExtraInfo *info)
static void reverse_decorr(struct Decorr *dpp)
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)
Filter the word “frame” indicates either a video frame or a group of audio samples
#define UPDATE_WEIGHT(weight, delta, source, result)
#define WRITE_DECSAMPLE(type)
static void decorr_mono(int32_t *in_samples, int32_t *out_samples, 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 int shift(int a, int b)
static void scan_word(WavPackEncodeContext *s, WvChannel *c, int32_t *samples, int nb_samples, int dir)
static uint32_t log2stereo(int32_t *samples_l, int32_t *samples_r, int nb_samples, int limit)
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static void fill_buffer(WavPackEncodeContext *s, const int8_t *src, int32_t *dst, int nb_samples)
static av_always_inline int diff(const uint32_t a, const uint32_t b)
This structure stores compressed data.
static void analyze_mono(WavPackEncodeContext *s, int32_t *samples, int do_samples)
static void delta_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info)
static void shift_stereo(int32_t *left, int32_t *right, int nb_samples, int shift)
#define flags(name, subs,...)
static void wavpack_encode_sample(WavPackEncodeContext *s, WvChannel *c, int32_t sample)
AVCodec ff_wavpack_encoder
static void decorr_stereo_pass2(struct Decorr *dpp, int32_t *samples_l, int32_t *samples_r, int nb_samples)
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
static int allocate_buffers2(WavPackEncodeContext *s, int nterms)
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
static void pack_float(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
static int wv_mono(WavPackEncodeContext *s, int32_t *samples, int no_history, int do_samples)
static const AVOption options[]