Go to the documentation of this file.
21 #define BITSTREAM_WRITER_LE
34 #define UPDATE_WEIGHT(weight, delta, source, result) \
35 if ((source) && (result)) { \
36 int32_t s = (int32_t) ((source) ^ (result)) >> 31; \
37 weight = ((delta) ^ s) + ((weight) - s); \
40 #define APPLY_WEIGHT_F(weight, sample) ((((((sample) & 0xffff) * (weight)) >> 9) + \
41 ((((sample) & ~0xffff) >> 9) * (weight)) + 1) >> 1)
43 #define APPLY_WEIGHT_I(weight, sample) (((weight) * (sample) + 512) >> 10)
45 #define APPLY_WEIGHT(weight, sample) ((sample) != (short) (sample) ? \
46 APPLY_WEIGHT_F(weight, sample) : APPLY_WEIGHT_I (weight, sample))
48 #define CLEAR(destin) memset(&destin, 0, sizeof(destin));
51 #define SHIFT_MASK (0x1FU << SHIFT_LSB)
54 #define MAG_MASK (0x1FU << MAG_LSB)
57 #define SRATE_MASK (0xFU << SRATE_LSB)
59 #define EXTRA_TRY_DELTAS 1
60 #define EXTRA_ADJUST_DELTAS 2
61 #define EXTRA_SORT_FIRST 4
62 #define EXTRA_BRANCHES 8
63 #define EXTRA_SORT_LAST 16
159 s->decorr_filter = 3;
178 s->decorr_filter = 2;
181 s->decorr_filter = 1;
184 s->decorr_filter = 0;
192 s->delta_decay = 2.0;
200 for (
i = 0;
i < nb_samples;
i++)
205 int nb_samples,
int shift)
208 for (
i = 0;
i < nb_samples;
i++) {
214 #define FLOAT_SHIFT_ONES 1
215 #define FLOAT_SHIFT_SAME 2
216 #define FLOAT_SHIFT_SENT 4
217 #define FLOAT_ZEROS_SENT 8
218 #define FLOAT_NEG_ZEROS 0x10
219 #define FLOAT_EXCEPTIONS 0x20
221 #define get_mantissa(f) ((f) & 0x7fffff)
222 #define get_exponent(f) (((f) >> 23) & 0xff)
223 #define get_sign(f) (((f) >> 31) & 0x1)
237 shift_count =
s->max_exp ?
s->max_exp - 1 : 0;
241 if (shift_count < 25)
242 value >>= shift_count;
251 }
else if (shift_count) {
270 uint32_t crc = 0xffffffff
u;
273 s->shifted_ones =
s->shifted_zeros =
s->shifted_both =
s->ordata = 0;
274 s->float_shift =
s->float_flags = 0;
275 s->false_zeros =
s->neg_zeros = 0;
279 for (
i = 0;
i < nb_samples;
i++) {
287 for (
i = 0;
i < nb_samples;
i++) {
306 for (
i = 0;
i < nb_samples;
i++)
309 for (
i = 0;
i < nb_samples;
i++) {
315 s->float_max_exp =
s->max_exp;
319 else if (
s->shifted_ones && !
s->shifted_zeros)
321 else if (
s->shifted_ones &&
s->shifted_zeros)
323 else if (
s->ordata && !(
s->ordata & 1)) {
327 }
while (!(
s->ordata & 1));
332 shift_stereo(samples_l, samples_r, nb_samples,
s->float_shift);
342 if (
s->false_zeros ||
s->neg_zeros)
356 uint32_t magdata = 0, ordata = 0, xordata = 0, anddata = ~0;
357 int i, total_shift = 0;
359 s->int32_sent_bits =
s->int32_zeros =
s->int32_ones =
s->int32_dups = 0;
362 for (
i = 0;
i < nb_samples;
i++) {
365 magdata |= (
M < 0) ? ~
M :
M;
366 xordata |=
M ^ -(
M & 1);
370 if ((ordata & 1) && !(anddata & 1) && (xordata & 2))
374 for (
i = 0;
i < nb_samples;
i++) {
378 magdata |= (
L < 0) ? ~
L :
L;
379 magdata |= (
R < 0) ? ~
R :
R;
380 xordata |=
L ^ -(
L & 1);
381 xordata |=
R ^ -(
R & 1);
385 if ((ordata & 1) && !(anddata & 1) && (xordata & 2))
406 }
while (!(ordata & 1));
407 }
else if (anddata & 1) {
413 }
while (anddata & 1);
414 }
else if (!(xordata & 2)) {
420 }
while (!(xordata & 2));
427 shift_mono(samples_l, nb_samples, total_shift);
429 shift_stereo(samples_l, samples_r, nb_samples, total_shift);
437 uint32_t magdata = 0, ordata = 0, xordata = 0, anddata = ~0;
438 uint32_t crc = 0xffffffff
u;
439 int i, total_shift = 0;
441 s->int32_sent_bits =
s->int32_zeros =
s->int32_ones =
s->int32_dups = 0;
444 for (
i = 0;
i < nb_samples;
i++) {
447 crc = crc * 9 + (
M & 0xffff) * 3 + ((
M >> 16) & 0xffff);
448 magdata |= (
M < 0) ? ~
M :
M;
449 xordata |=
M ^ -(
M & 1);
454 for (
i = 0;
i < nb_samples;
i++) {
458 crc = crc * 9 + (
L & 0xffff) * 3 + ((
L >> 16) & 0xffff);
459 crc = crc * 9 + (
R & 0xffff) * 3 + ((
R >> 16) & 0xffff);
460 magdata |= (
L < 0) ? ~
L :
L;
461 magdata |= (
R < 0) ? ~
R :
R;
462 xordata |=
L ^ -(
L & 1);
463 xordata |=
R ^ -(
R & 1);
488 }
while (!(ordata & 1));
489 else if (anddata & 1)
495 }
while (anddata & 1);
496 else if (!(xordata & 2))
502 }
while (!(xordata & 2));
506 total_shift +=
s->int32_sent_bits;
515 shift_mono(samples_l, nb_samples, total_shift);
517 shift_stereo(samples_l, samples_r, nb_samples, total_shift);
520 return s->int32_sent_bits;
548 int nb_samples,
struct Decorr *dpp,
int dir)
555 out_samples += (nb_samples - 1);
556 in_samples += (nb_samples - 1);
565 while (nb_samples--) {
576 out_samples[0] =
left;
580 }
else if (dpp->
value > 0) {
581 while (nb_samples--) {
592 out_samples[0] =
left;
629 }
else if (dpp->
value > 1) {
632 for (
i = 0, j = dpp->
value - 1, k = 0; k < dpp->
value / 2;
i++, j--, k++) {
642 #define count_bits(av) ((av) ? 32 - ff_clz(av) : 0)
648 if ((v += v >> 9) < (1 << 8)) {
663 while (nb_samples--) {
671 int nb_samples,
int limit)
674 while (nb_samples--) {
683 int nb_samples,
struct Decorr *dpp,
686 struct Decorr dp, *dppi = dpp + tindex;
694 pre_delta =
delta + 1;
698 dp.
delta = pre_delta;
722 int depth,
int delta, uint32_t input_bits)
724 int term, branches =
s->num_branches - depth;
726 uint32_t term_bits[22],
bits;
728 if (branches < 1 || depth + 1 == info->nterms)
733 outsamples =
s->sampleptrs[depth + 1][0];
735 for (term = 1; term <= 18; term++) {
736 if (term == 17 && branches == 1 && depth + 1 <
info->nterms)
739 if (term > 8 && term < 17)
742 if (!
s->extra_flags && (term > 4 && term < 17))
745 info->dps[depth].value = term;
750 if (bits < info->best_bits) {
753 memcpy(
s->decorr_passes,
info->dps,
sizeof(
info->dps[0]) * (depth + 1));
754 memcpy(
s->sampleptrs[
info->nterms + 1][0],
755 s->sampleptrs[depth + 1][0],
s->block_samples * 4);
758 term_bits[term + 3] =
bits;
761 while (depth + 1 <
info->nterms && branches--) {
762 uint32_t local_best_bits = input_bits;
763 int best_term = 0,
i;
765 for (
i = 0;
i < 22;
i++)
766 if (term_bits[
i] && term_bits[
i] < local_best_bits) {
767 local_best_bits = term_bits[
i];
774 term_bits[best_term + 3] = 0;
776 info->dps[depth].value = best_term;
792 memcpy(
info->dps,
s->decorr_passes,
sizeof(
s->decorr_passes));
795 for (ri = 0; ri <
info->nterms &&
s->decorr_passes[ri].value; ri++) {
797 if (ri + 1 >=
info->nterms || !
s->decorr_passes[ri+1].value)
800 if (
s->decorr_passes[ri].value ==
s->decorr_passes[ri+1].value) {
802 s->block_samples,
info->dps, ri);
806 info->dps[ri ] =
s->decorr_passes[ri+1];
807 info->dps[ri+1] =
s->decorr_passes[ri ];
809 for (
i = ri;
i <
info->nterms &&
s->decorr_passes[
i].value;
i++)
811 s->block_samples,
info->dps,
i);
814 if (bits < info->best_bits) {
818 memcpy(
s->decorr_passes,
info->dps,
sizeof(
info->dps[0]) *
i);
819 memcpy(
s->sampleptrs[
info->nterms + 1][0],
s->sampleptrs[
i][0],
820 s->block_samples * 4);
822 info->dps[ri ] =
s->decorr_passes[ri];
823 info->dps[ri+1] =
s->decorr_passes[ri+1];
825 s->block_samples,
info->dps, ri);
836 if (!
s->decorr_passes[0].value)
838 delta =
s->decorr_passes[0].delta;
843 for (
i = 0;
i <
info->nterms &&
s->decorr_passes[
i].value;
i++) {
844 info->dps[
i].value =
s->decorr_passes[
i].value;
847 s->block_samples,
info->dps,
i);
857 memcpy(
s->decorr_passes,
info->dps,
sizeof(
info->dps[0]) *
i);
858 memcpy(
s->sampleptrs[
info->nterms + 1][0],
s->sampleptrs[
i][0],
859 s->block_samples * 4);
862 for (
d =
delta + 1; !lower &&
d <= 7;
d++) {
865 for (
i = 0;
i <
info->nterms &&
s->decorr_passes[
i].value;
i++) {
866 info->dps[
i].value =
s->decorr_passes[
i].value;
869 s->block_samples,
info->dps,
i);
878 memcpy(
s->decorr_passes,
info->dps,
sizeof(
info->dps[0]) *
i);
879 memcpy(
s->sampleptrs[
info->nterms + 1][0],
s->sampleptrs[
i][0],
880 s->block_samples * 4);
888 for (
i = 0;
i < nterms + 2;
i++) {
890 s->block_samples * 4);
891 if (!
s->sampleptrs[
i][0])
895 s->block_samples * 4);
896 if (!
s->sampleptrs[
i][1])
908 for (
i = 0;
i < 2;
i++) {
910 s->block_samples * 4);
911 if (!
s->best_buffer[0])
915 s->block_samples * 4);
916 if (!
s->temp_buffer[
i][0])
920 s->block_samples * 4);
921 if (!
s->best_buffer[1])
925 s->block_samples * 4);
926 if (!
s->temp_buffer[
i][1])
942 info.nterms =
s->num_terms;
947 memcpy(
info.dps,
s->decorr_passes,
sizeof(
info.dps));
948 memcpy(
s->sampleptrs[0][0],
samples,
s->block_samples * 4);
952 s->block_samples,
info.dps +
i, 1);
955 memcpy(
s->sampleptrs[
info.nterms + 1][0],
s->sampleptrs[
i][0],
s->block_samples * 4);
959 log2mono(
s->sampleptrs[0][0],
s->block_samples, 0));
968 s->delta_decay = (
float)((
s->delta_decay * 2.0 +
s->decorr_passes[0].delta) / 3.0);
970 s->delta_decay = 2.0;
977 memcpy(
samples,
s->sampleptrs[
info.nterms + 1][0],
s->block_samples * 4);
979 for (
i = 0;
i <
info.nterms;
i++)
980 if (!
s->decorr_passes[
i].value)
992 while (nb_samples--) {
1019 int no_history,
int do_samples)
1021 struct Decorr temp_decorr_pass, save_decorr_passes[
MAX_TERMS] = {{0}};
1022 int nb_samples =
s->block_samples;
1023 int buf_size =
sizeof(
int32_t) * nb_samples;
1024 uint32_t best_size = UINT32_MAX,
size;
1025 int log_limit, pi,
i,
ret;
1027 for (
i = 0;
i < nb_samples;
i++)
1031 if (
i == nb_samples) {
1039 log_limit =
FFMIN(6912, log_limit);
1044 if (no_history ||
s->num_passes >= 7)
1045 s->best_decorr =
s->mask_decorr = 0;
1047 for (pi = 0; pi <
s->num_passes;) {
1054 if (
s->mask_decorr == 0)
1057 c = (
s->best_decorr & (
s->mask_decorr - 1)) |
s->mask_decorr;
1059 if (
c ==
s->best_decorr) {
1060 s->mask_decorr =
s->mask_decorr ? ((
s->mask_decorr << 1) & (
s->num_decorrs - 1)) : 1;
1065 wpds = &
s->decorr_specs[
c];
1069 memcpy(
s->temp_buffer[0][0],
samples, buf_size);
1070 CLEAR(save_decorr_passes);
1072 for (j = 0; j < nterms; j++) {
1073 CLEAR(temp_decorr_pass);
1077 if (temp_decorr_pass.
value < 0)
1078 temp_decorr_pass.
value = 1;
1080 decorr_mono(
s->temp_buffer[j&1][0],
s->temp_buffer[~j&1][0],
1081 FFMIN(nb_samples, 2048), &temp_decorr_pass, -1);
1089 memcpy(save_decorr_passes + j, &temp_decorr_pass,
sizeof(
struct Decorr));
1090 decorr_mono(
s->temp_buffer[j&1][0],
s->temp_buffer[~j&1][0],
1091 nb_samples, &temp_decorr_pass, 1);
1094 size =
log2mono(
s->temp_buffer[j&1][0], nb_samples, log_limit);
1095 if (
size != UINT32_MAX || !nterms)
1100 if (
size < best_size) {
1101 memcpy(
s->best_buffer[0],
s->temp_buffer[j&1][0], buf_size);
1102 memcpy(
s->decorr_passes, save_decorr_passes,
sizeof(
struct Decorr) *
MAX_TERMS);
1103 s->num_terms = nterms;
1109 s->mask_decorr =
s->mask_decorr ? ((
s->mask_decorr << 1) & (
s->num_decorrs - 1)) : 1;
1114 else if (do_samples)
1115 memcpy(
samples,
s->best_buffer[0], buf_size);
1117 if (no_history ||
s->extra_flags) {
1119 scan_word(
s, &
s->w.c[0],
s->best_buffer[0], nb_samples, -1);
1126 int nb_samples,
struct Decorr *dpp,
int dir)
1133 out_left += nb_samples - 1;
1134 out_right += nb_samples - 1;
1135 in_left += nb_samples - 1;
1136 in_right += nb_samples - 1;
1147 switch (dpp->
value) {
1149 while (nb_samples--) {
1171 while (nb_samples--) {
1193 while (nb_samples--) {
1217 while (nb_samples--) {
1254 while (nb_samples--) {
1273 while (nb_samples--) {
1292 while (nb_samples--) {
1322 if (dpp->
value & 1) {
1335 if (dpp->
value & 1) {
1345 }
else if (dpp->
value > 1) {
1348 for (
i = 0, j = dpp->
value - 1, k = 0; k < dpp->
value / 2;
i++, j--, k++) {
1363 int nb_samples,
struct Decorr *dpp)
1375 switch (dpp->
value) {
1377 for (
i = 0;
i < nb_samples;
i++) {
1392 for (
i = 0;
i < nb_samples;
i++) {
1407 for (
i = 0;
i < nb_samples;
i++) {
1424 for (
i = 0;
i < nb_samples;
i++) {
1455 for (
i = 0;
i < nb_samples;
i++) {
1467 for (
i = 0;
i < nb_samples;
i++) {
1479 for (
i = 0;
i < nb_samples;
i++) {
1500 int nb_samples,
int tindex)
1502 struct Decorr dp = {0}, *dppi =
info->dps + tindex;
1503 int delta = dppi->delta, pre_delta;
1504 int term = dppi->value;
1511 pre_delta =
delta + 1;
1514 dp.
delta = pre_delta;
1516 FFMIN(2048, nb_samples), &dp, -1);
1533 decorr_stereo(in_left, in_right, out_left, out_right, nb_samples, &dp, 1);
1537 dppi->weightA = dp.
weightA = dp.
sumA / nb_samples;
1538 dppi->weightB = dp.
weightB = dp.
sumB / nb_samples;
1543 nb_samples, &dp, 1);
1557 memcpy(
info->dps,
s->decorr_passes,
sizeof(
s->decorr_passes));
1560 for (ri = 0; ri <
info->nterms &&
s->decorr_passes[ri].value; ri++) {
1562 if (ri + 1 >=
info->nterms || !
s->decorr_passes[ri+1].value)
1565 if (
s->decorr_passes[ri].value ==
s->decorr_passes[ri+1].value) {
1567 s->sampleptrs[ri ][0],
s->sampleptrs[ri ][1],
1568 s->sampleptrs[ri+1][0],
s->sampleptrs[ri+1][1],
1569 s->block_samples, ri);
1573 info->dps[ri ] =
s->decorr_passes[ri+1];
1574 info->dps[ri+1] =
s->decorr_passes[ri ];
1576 for (
i = ri;
i <
info->nterms &&
s->decorr_passes[
i].value;
i++)
1578 s->sampleptrs[
i ][0],
s->sampleptrs[
i ][1],
1579 s->sampleptrs[
i+1][0],
s->sampleptrs[
i+1][1],
1580 s->block_samples,
i);
1583 s->block_samples,
info->log_limit);
1585 if (bits < info->best_bits) {
1589 memcpy(
s->decorr_passes,
info->dps,
sizeof(
info->dps[0]) *
i);
1590 memcpy(
s->sampleptrs[
info->nterms + 1][0],
1591 s->sampleptrs[
i][0],
s->block_samples * 4);
1592 memcpy(
s->sampleptrs[
info->nterms + 1][1],
1593 s->sampleptrs[
i][1],
s->block_samples * 4);
1595 info->dps[ri ] =
s->decorr_passes[ri ];
1596 info->dps[ri+1] =
s->decorr_passes[ri+1];
1598 s->sampleptrs[ri ][0],
s->sampleptrs[ri ][1],
1599 s->sampleptrs[ri+1][0],
s->sampleptrs[ri+1][1],
1600 s->block_samples, ri);
1611 if (!
s->decorr_passes[0].value)
1613 delta =
s->decorr_passes[0].delta;
1616 for (
i = 0;
i <
info->nterms &&
s->decorr_passes[
i].value;
i++) {
1617 info->dps[
i].value =
s->decorr_passes[
i].value;
1620 s->sampleptrs[
i ][0],
s->sampleptrs[
i ][1],
1621 s->sampleptrs[
i+1][0],
s->sampleptrs[
i+1][1],
1622 s->block_samples,
i);
1626 s->block_samples,
info->log_limit);
1632 memcpy(
s->decorr_passes,
info->dps,
sizeof(
info->dps[0]) *
i);
1633 memcpy(
s->sampleptrs[
info->nterms + 1][0],
s->sampleptrs[
i][0],
1634 s->block_samples * 4);
1635 memcpy(
s->sampleptrs[
info->nterms + 1][1],
s->sampleptrs[
i][1],
1636 s->block_samples * 4);
1639 for (
d =
delta + 1; !lower &&
d <= 7;
d++) {
1640 for (
i = 0;
i <
info->nterms &&
s->decorr_passes[
i].value;
i++) {
1641 info->dps[
i].value =
s->decorr_passes[
i].value;
1644 s->sampleptrs[
i ][0],
s->sampleptrs[
i ][1],
1645 s->sampleptrs[
i+1][0],
s->sampleptrs[
i+1][1],
1646 s->block_samples,
i);
1650 s->block_samples,
info->log_limit);
1652 if (bits < info->best_bits) {
1655 memcpy(
s->decorr_passes,
info->dps,
sizeof(
info->dps[0]) *
i);
1656 memcpy(
s->sampleptrs[
info->nterms + 1][0],
1657 s->sampleptrs[
i][0],
s->block_samples * 4);
1658 memcpy(
s->sampleptrs[
info->nterms + 1][1],
1659 s->sampleptrs[
i][1],
s->block_samples * 4);
1667 int depth,
int delta, uint32_t input_bits)
1669 int term, branches =
s->num_branches - depth;
1670 int32_t *in_left, *in_right, *out_left, *out_right;
1671 uint32_t term_bits[22],
bits;
1673 if (branches < 1 || depth + 1 == info->nterms)
1677 in_left =
s->sampleptrs[depth ][0];
1678 in_right =
s->sampleptrs[depth ][1];
1679 out_left =
s->sampleptrs[depth + 1][0];
1680 out_right =
s->sampleptrs[depth + 1][1];
1682 for (term = -3; term <= 18; term++) {
1683 if (!term || (term > 8 && term < 17))
1686 if (term == 17 && branches == 1 && depth + 1 <
info->nterms)
1689 if (term == -1 || term == -2)
1693 if (!
s->extra_flags && (term > 4 && term < 17))
1696 info->dps[depth].value = term;
1699 s->block_samples, depth);
1702 if (bits < info->best_bits) {
1705 memcpy(
s->decorr_passes,
info->dps,
sizeof(
info->dps[0]) * (depth + 1));
1706 memcpy(
s->sampleptrs[
info->nterms + 1][0],
s->sampleptrs[depth + 1][0],
1707 s->block_samples * 4);
1708 memcpy(
s->sampleptrs[
info->nterms + 1][1],
s->sampleptrs[depth + 1][1],
1709 s->block_samples * 4);
1712 term_bits[term + 3] =
bits;
1715 while (depth + 1 <
info->nterms && branches--) {
1716 uint32_t local_best_bits = input_bits;
1717 int best_term = 0,
i;
1719 for (
i = 0;
i < 22;
i++)
1720 if (term_bits[
i] && term_bits[
i] < local_best_bits) {
1721 local_best_bits = term_bits[
i];
1728 term_bits[best_term + 3] = 0;
1730 info->dps[depth].value = best_term;
1733 s->block_samples, depth);
1751 info.nterms =
s->num_terms;
1756 memcpy(
info.dps,
s->decorr_passes,
sizeof(
info.dps));
1757 memcpy(
s->sampleptrs[0][0], in_left,
s->block_samples * 4);
1758 memcpy(
s->sampleptrs[0][1], in_right,
s->block_samples * 4);
1763 s->sampleptrs[
i + 1][0],
s->sampleptrs[
i + 1][1],
1764 s->block_samples,
info.dps +
i, 1);
1767 s->sampleptrs[
i + 1][0],
s->sampleptrs[
i + 1][1],
1768 s->block_samples,
info.dps +
i);
1771 s->block_samples, 0);
1773 memcpy(
s->sampleptrs[
info.nterms + 1][0],
s->sampleptrs[
i][0],
s->block_samples * 4);
1774 memcpy(
s->sampleptrs[
info.nterms + 1][1],
s->sampleptrs[
i][1],
s->block_samples * 4);
1779 s->block_samples, 0));
1788 s->delta_decay = (
float)((
s->delta_decay * 2.0 +
s->decorr_passes[0].delta) / 3.0);
1790 s->delta_decay = 2.0;
1797 memcpy(in_left,
s->sampleptrs[
info.nterms + 1][0],
s->block_samples * 4);
1798 memcpy(in_right,
s->sampleptrs[
info.nterms + 1][1],
s->block_samples * 4);
1801 for (
i = 0;
i <
info.nterms;
i++)
1802 if (!
s->decorr_passes[
i].value)
1810 int no_history,
int do_samples)
1812 struct Decorr temp_decorr_pass, save_decorr_passes[
MAX_TERMS] = {{0}};
1813 int nb_samples =
s->block_samples,
ret;
1814 int buf_size =
sizeof(
int32_t) * nb_samples;
1815 int log_limit, force_js = 0, force_ts = 0, got_js = 0, pi,
i;
1816 uint32_t best_size = UINT32_MAX,
size;
1818 for (
i = 0;
i < nb_samples;
i++)
1819 if (samples_l[
i] || samples_r[
i])
1822 if (
i == nb_samples) {
1831 log_limit =
FFMIN(6912, log_limit);
1833 if (
s->joint != -1) {
1834 force_js =
s->joint;
1835 force_ts = !
s->joint;
1841 if (no_history ||
s->num_passes >= 7)
1842 s->best_decorr =
s->mask_decorr = 0;
1844 for (pi = 0; pi <
s->num_passes;) {
1851 if (
s->mask_decorr == 0)
1854 c = (
s->best_decorr & (
s->mask_decorr - 1)) |
s->mask_decorr;
1856 if (
c ==
s->best_decorr) {
1857 s->mask_decorr =
s->mask_decorr ? ((
s->mask_decorr << 1) & (
s->num_decorrs - 1)) : 1;
1862 wpds = &
s->decorr_specs[
c];
1870 memcpy(
s->js_left, samples_l, buf_size);
1871 memcpy(
s->js_right, samples_r, buf_size);
1873 for (
i = 0;
i < nb_samples;
i++)
1874 s->js_right[
i] += ((
s->js_left[
i] -=
s->js_right[
i]) >> 1);
1878 memcpy(
s->temp_buffer[0][0],
s->js_left, buf_size);
1879 memcpy(
s->temp_buffer[0][1],
s->js_right, buf_size);
1881 memcpy(
s->temp_buffer[0][0], samples_l, buf_size);
1882 memcpy(
s->temp_buffer[0][1], samples_r, buf_size);
1885 CLEAR(save_decorr_passes);
1887 for (j = 0; j < nterms; j++) {
1888 CLEAR(temp_decorr_pass);
1893 temp_decorr_pass.
value = -3;
1896 s->temp_buffer[~j&1][0],
s->temp_buffer[~j&1][1],
1897 FFMIN(2048, nb_samples), &temp_decorr_pass, -1);
1906 memcpy(save_decorr_passes + j, &temp_decorr_pass,
sizeof(
struct Decorr));
1910 s->temp_buffer[~j&1][0],
s->temp_buffer[~j&1][1],
1911 nb_samples, &temp_decorr_pass, 1);
1914 s->temp_buffer[~j&1][0],
s->temp_buffer[~j&1][1],
1915 nb_samples, &temp_decorr_pass);
1919 nb_samples, log_limit);
1920 if (
size != UINT32_MAX || !nterms)
1925 if (
size < best_size) {
1926 memcpy(
s->best_buffer[0],
s->temp_buffer[j&1][0], buf_size);
1927 memcpy(
s->best_buffer[1],
s->temp_buffer[j&1][1], buf_size);
1928 memcpy(
s->decorr_passes, save_decorr_passes,
sizeof(
struct Decorr) *
MAX_TERMS);
1929 s->num_terms = nterms;
1935 s->mask_decorr =
s->mask_decorr ? ((
s->mask_decorr << 1) & (
s->num_decorrs - 1)) : 1;
1938 if (force_js || (
s->decorr_specs[
s->best_decorr].joint_stereo && !force_ts))
1943 if (
s->extra_flags) {
1948 memcpy(samples_l,
s->js_left, buf_size);
1949 memcpy(samples_r,
s->js_right, buf_size);
1953 }
else if (do_samples) {
1954 memcpy(samples_l,
s->best_buffer[0], buf_size);
1955 memcpy(samples_r,
s->best_buffer[1], buf_size);
1958 if (
s->extra_flags || no_history ||
1959 s->joint_stereo !=
s->decorr_specs[
s->best_decorr].joint_stereo) {
1960 s->joint_stereo =
s->decorr_specs[
s->best_decorr].joint_stereo;
1962 scan_word(
s, &
s->w.c[0],
s->best_buffer[0], nb_samples, -1);
1963 scan_word(
s, &
s->w.c[1],
s->best_buffer[1], nb_samples, -1);
1981 put_bits(pb, cbits, (1 << cbits) - 1);
1988 while (
w->zeros_acc > 1) {
1996 if (
w->holding_one) {
1997 if (
w->holding_one >= 16) {
2002 w->holding_one -= 16;
2010 put_bits(pb, cbits, (1 << cbits) - 1);
2017 while (
w->holding_one > 1) {
2019 w->holding_one >>= 1;
2022 w->holding_zero = 0;
2024 put_bits(pb,
w->holding_one, (1 <<
w->holding_one) - 1);
2030 if (
w->holding_zero) {
2032 w->holding_zero = 0;
2035 if (
w->pend_count) {
2037 w->pend_data =
w->pend_count = 0;
2044 uint32_t ones_count, low, high;
2047 if (
s->w.c[0].median[0] < 2 && !
s->w.holding_zero &&
s->w.c[1].median[0] < 2) {
2069 ones_count = low = 0;
2090 low += (ones_count - 2) *
GET_MED(2);
2097 if (
w->holding_zero) {
2104 w->holding_zero = 1;
2107 w->holding_zero = 0;
2109 w->holding_zero = 1;
2111 w->holding_one = ones_count * 2;
2114 uint32_t maxcode = high - low,
code =
sample - low;
2116 uint32_t extras = (1 << bitcount) - maxcode - 1;
2118 if (
code < extras) {
2119 w->pend_data |=
code <<
w->pend_count;
2120 w->pend_count += bitcount - 1;
2122 w->pend_data |= ((
code + extras) >> 1) <<
w->pend_count;
2123 w->pend_count += bitcount - 1;
2124 w->pend_data |= ((
code + extras) & 1) <<
w->pend_count++;
2128 w->pend_data |= ((
int32_t) sign <<
w->pend_count++);
2130 if (!
w->holding_zero)
2138 const int sent_bits =
s->int32_sent_bits;
2142 pre_shift =
s->int32_zeros +
s->int32_ones +
s->int32_dups;
2148 for (
i = 0;
i < nb_samples;
i++) {
2149 put_sbits(pb, sent_bits, samples_l[
i] >> pre_shift);
2152 for (
i = 0;
i < nb_samples;
i++) {
2153 put_sbits(pb, sent_bits, samples_l[
i] >> pre_shift);
2154 put_sbits(pb, sent_bits, samples_r[
i] >> pre_shift);
2161 const int max_exp =
s->float_max_exp;
2179 shift_count = max_exp ? max_exp - 1 : 0;
2183 if (shift_count < 25)
2184 value >>= shift_count;
2205 }
else if (shift_count) {
2221 for (
i = 0;
i < nb_samples;
i++)
2224 for (
i = 0;
i < nb_samples;
i++) {
2237 switch (dpp->
value) {
2239 for (
i = 0;
i < nb_samples;
i++) {
2254 for (
i = 0;
i < nb_samples;
i++) {
2297 for (
i = 0;
i < nb_samples;
i++) {
2309 for (
i = 0;
i < nb_samples;
i++) {
2321 for (
i = 0;
i < nb_samples;
i++) {
2339 #define update_weight_d2(weight, delta, source, result) \
2340 if (source && result) \
2341 weight -= (((source ^ result) >> 29) & 4) - 2;
2343 #define update_weight_clip_d2(weight, delta, source, result) \
2344 if (source && result) { \
2345 const int32_t s = (source ^ result) >> 31; \
2346 if ((weight = (weight ^ s) + (2 - s)) > 1024) weight = 1024; \
2347 weight = (weight ^ s) - s; \
2356 switch (dpp->
value) {
2358 for (
i = 0;
i < nb_samples;
i++) {
2373 for (
i = 0;
i < nb_samples;
i++) {
2417 for (
i = 0;
i < nb_samples;
i++) {
2429 for (
i = 0;
i < nb_samples;
i++) {
2441 for (
i = 0;
i < nb_samples;
i++) {
2464 bytestream2_put_byte(pb,
flags);
2465 bytestream2_put_byte(pb, (
size + 1) >> 1);
2472 int block_size, start, end, data_size, tcount,
temp, m = 0;
2473 int i, j,
ret = 0, got_extra = 0, nb_samples =
s->block_samples;
2474 uint32_t crc = 0xffffffff
u;
2481 if (!(
s->flags &
WV_MONO) &&
s->optimize_mono) {
2484 for (
i = 0;
i < nb_samples;
i++) {
2485 lor |= samples_l[
i] | samples_r[
i];
2486 diff |= samples_l[
i] - samples_r[
i];
2492 if (
i == nb_samples && lor && !
diff) {
2496 if (!
s->false_stereo) {
2497 s->false_stereo = 1;
2501 }
else if (
s->false_stereo) {
2502 s->false_stereo = 0;
2517 if ((mag -=
shift) < 0)
2525 memcpy(
s->orig_l, samples_l,
sizeof(
int32_t) * nb_samples);
2528 memcpy(
s->orig_r, samples_r,
sizeof(
int32_t) * nb_samples);
2532 got_extra =
scan_float(
s, samples_l, samples_r, nb_samples);
2534 got_extra =
scan_int32(
s, samples_l, samples_r, nb_samples);
2538 if (
s->shift !=
s->int32_zeros +
s->int32_ones +
s->int32_dups) {
2539 s->shift =
s->int32_zeros +
s->int32_ones +
s->int32_dups;
2544 if (!
s->num_passes && !
s->num_terms) {
2555 for (
i = 0;
i < nb_samples;
i++)
2556 crc += (crc << 1) + samples_l[
i];
2561 for (
i = 0;
i < nb_samples;
i++)
2562 crc += (crc << 3) + ((uint32_t)samples_l[
i] << 1) + samples_l[
i] + samples_r[
i];
2573 s->ch_offset += 1 + !(
s->flags &
WV_MONO);
2575 if (
s->ch_offset ==
s->avctx->ch_layout.nb_channels)
2579 bytestream2_put_le32(&pb,
MKTAG(
'w',
'v',
'p',
'k'));
2580 bytestream2_put_le32(&pb, 0);
2581 bytestream2_put_le16(&pb, 0x410);
2582 bytestream2_put_le16(&pb, 0);
2583 bytestream2_put_le32(&pb, 0);
2584 bytestream2_put_le32(&pb,
s->sample_index);
2585 bytestream2_put_le32(&pb, nb_samples);
2586 bytestream2_put_le32(&pb,
s->flags);
2587 bytestream2_put_le32(&pb, crc);
2594 bytestream2_put_byte(&pb,
s->avctx->ch_layout.nb_channels);
2595 if (
s->avctx->ch_layout.u.mask >> 32)
2596 bytestream2_put_le32(&pb, 0);
2598 bytestream2_put_le32(&pb,
s->avctx->ch_layout.u.mask);
2599 bytestream2_put_byte(&pb, 0);
2603 bytestream2_put_byte(&pb,
s->avctx->ch_layout.nb_channels);
2604 bytestream2_put_le32(&pb, 0);
2605 bytestream2_put_byte(&pb, 0);
2610 bytestream2_put_le24(&pb,
s->avctx->sample_rate);
2611 bytestream2_put_byte(&pb, 0);
2615 for (
i = 0;
i <
s->num_terms;
i++) {
2616 struct Decorr *dpp = &
s->decorr_passes[
i];
2617 bytestream2_put_byte(&pb, ((dpp->
value + 5) & 0x1f) | ((dpp->
delta << 5) & 0xe0));
2619 if (
s->num_terms & 1)
2620 bytestream2_put_byte(&pb, 0);
2622 #define WRITE_DECWEIGHT(type) do { \
2623 temp = store_weight(type); \
2624 bytestream2_put_byte(&pb, temp); \
2625 type = restore_weight(temp); \
2629 bytestream2_put_byte(&pb, 0);
2631 for (
i =
s->num_terms - 1;
i >= 0; --
i) {
2632 struct Decorr *dpp = &
s->decorr_passes[
i];
2639 for (
i = 0;
i <
s->num_terms;
i++) {
2640 struct Decorr *dpp = &
s->decorr_passes[
i];
2651 out[start - 1] = (end - start + 1) >> 1;
2652 if ((end - start) & 1)
2653 bytestream2_put_byte(&pb, 0);
2655 #define WRITE_DECSAMPLE(type) do { \
2656 temp = log2s(type); \
2657 type = wp_exp2(temp); \
2658 bytestream2_put_le16(&pb, temp); \
2662 bytestream2_put_byte(&pb, 0);
2664 for (
i = 0;
i <
s->num_terms;
i++) {
2665 struct Decorr *dpp = &
s->decorr_passes[
i];
2674 }
else if (dpp->
value < 0) {
2678 for (j = 0; j < dpp->
value; j++) {
2690 out[start - 1] = (end - start) >> 1;
2692 #define WRITE_CHAN_ENTROPY(chan) do { \
2693 for (i = 0; i < 3; i++) { \
2694 temp = wp_log2(s->w.c[chan].median[i]); \
2695 bytestream2_put_le16(&pb, temp); \
2696 s->w.c[chan].median[i] = wp_exp2(temp); \
2707 bytestream2_put_byte(&pb,
s->float_flags);
2708 bytestream2_put_byte(&pb,
s->float_shift);
2709 bytestream2_put_byte(&pb,
s->float_max_exp);
2710 bytestream2_put_byte(&pb, 127);
2715 bytestream2_put_byte(&pb,
s->int32_sent_bits);
2716 bytestream2_put_byte(&pb,
s->int32_zeros);
2717 bytestream2_put_byte(&pb,
s->int32_ones);
2718 bytestream2_put_byte(&pb,
s->int32_dups);
2722 for (
i = 0;
i < nb_samples;
i++) {
2725 for (tcount =
s->num_terms, dpp =
s->decorr_passes; tcount--; dpp++) {
2746 samples_l[
i] =
code;
2749 for (tcount =
s->num_terms, dpp =
s->decorr_passes; tcount--; dpp++)
2764 }
else if (!
s->num_passes) {
2766 for (
i = 0;
i < nb_samples;
i++)
2767 samples_r[
i] += ((samples_l[
i] -= samples_r[
i]) >> 1);
2770 for (
i = 0;
i <
s->num_terms;
i++) {
2771 struct Decorr *dpp = &
s->decorr_passes[
i];
2782 for (
i = 0;
i < nb_samples;
i++)
2785 for (
i = 0;
i < nb_samples;
i++) {
2793 bytestream2_put_le24(&pb, (data_size + 1) >> 1);
2796 bytestream2_put_byte(&pb, 0);
2807 bytestream2_put_le24(&pb, (data_size + 5) >> 1);
2808 bytestream2_put_le32(&pb,
s->crc_x);
2811 bytestream2_put_byte(&pb, 0);
2828 #define COPY_SAMPLES(type, offset, shift) do { \
2829 const type *sptr = (const type *)src; \
2830 for (i = 0; i < nb_samples; i++) \
2831 dst[i] = (sptr[i] - offset) >> shift; \
2834 switch (
s->avctx->sample_fmt) {
2842 if (
s->avctx->bits_per_raw_sample <= 24) {
2847 memcpy(dst,
src, nb_samples * 4);
2855 for (
i = 0;
i < 15;
i++) {
2872 sizeof(
int32_t) *
s->block_samples);
2877 sizeof(
int32_t) *
s->block_samples);
2891 switch (
s->avctx->sample_fmt) {
2905 s->flags += (1 <<
MAG_LSB) * ((
s->flags & 3) * 8 + 7);
2908 buf, buf_size)) < 0)
2917 *got_packet_ptr = 1;
2929 s->sampleptrs_size[
i][0] =
s->sampleptrs_size[
i][1] = 0;
2932 for (
i = 0;
i < 2;
i++) {
2934 s->samples_size[
i] = 0;
2937 s->best_buffer_size[
i] = 0;
2941 s->temp_buffer_size[
i][0] =
s->temp_buffer_size[
i][1] = 0;
2946 s->js_left_size =
s->js_right_size = 0;
2950 s->orig_l_size =
s->orig_r_size = 0;
2955 #define OFFSET(x) offsetof(WavPackEncodeContext, x)
2956 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
2971 .
p.
name =
"wavpack",
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[]
const FFCodec ff_wavpack_encoder
static void shift_mono(int32_t *samples, int nb_samples, int shift)
static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p)
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)
static int put_bytes_output(const PutBitContext *s)
int sample_rate
samples per second
#define u(width, name, range_min, range_max)
#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 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)
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)
int nb_channels
Number of channels in this layout.
#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)
AVCodec p
The public AVCodec.
static void recurse_mono(WavPackEncodeContext *s, WavPackExtraInfo *info, int depth, int delta, uint32_t input_bits)
AVChannelLayout ch_layout
Audio channel layout.
static av_cold int wavpack_encode_close(AVCodecContext *avctx)
#define FF_CODEC_ENCODE_CB(func)
int temp_buffer_size[2][2]
#define AV_CH_LAYOUT_STEREO
static av_always_inline int wp_log2(uint32_t val)
#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 __device__ float floor(float a)
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
static const int wv_rates[16]
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
#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 CODEC_LONG_NAME(str)
#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 AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
int32_t * sampleptrs[MAX_TERMS+2][2]
static int shift(int a, int b)
static void process_float(WavPackEncodeContext *s, int32_t *sample)
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
static const uint16_t decorr_filter_sizes[]
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
int nb_samples
number of audio samples (per channel) described by this frame
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)
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 av_always_inline void bytestream2_skip_p(PutByteContext *p, unsigned int size)
uint8_t ** extended_data
pointers to the data planes/channels.
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 double limit(double x)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#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 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)
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)
const uint8_t ff_wp_log2_table[256]
#define flags(name, subs,...)
static void wavpack_encode_sample(WavPackEncodeContext *s, WvChannel *c, int32_t sample)
#define MKTAG(a, b, c, d)
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_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and 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[]