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)
198 for (i = 0; i < nb_samples; i++)
199 samples[i] >>= shift;
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)
239 if (shift_count < 25)
240 value >>= shift_count;
249 }
else if (shift_count) {
268 uint32_t crc = 0xffffffff
u;
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++) {
325 }
while (!(s->
ordata & 1));
354 uint32_t magdata = 0, ordata = 0, xordata = 0, anddata = ~0;
355 int i, total_shift = 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;
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));
513 shift_mono(samples_l, nb_samples, total_shift);
515 shift_stereo(samples_l, samples_r, nb_samples, total_shift);
523 weight = av_clip(weight, -1024, 1024);
525 weight -= (weight + 64) >> 7;
527 return (weight + 4) >> 3;
534 if ((result = (
int) weight << 3) > 0)
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);
562 if (dpp->
value > MAX_TERM) {
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--) {
580 int k = (m + dpp->
value) & (MAX_TERM - 1);
584 dpp->
samplesA[k] = left = in_samples[0];
585 m = (m + 1) & (MAX_TERM - 1);
590 out_samples[0] = left;
596 if (m && dpp->
value > 0 && dpp->
value <= MAX_TERM) {
603 m = (m + 1) & (MAX_TERM - 1);
627 }
else if (dpp->
value > 1) {
630 for (i = 0, j = dpp->
value - 1, k = 0; k < dpp->
value / 2; i++, j--, k++) {
640 static uint32_t
log2sample(uint32_t v,
int limit, uint32_t *result)
644 if ((v += v >> 9) < (1 << 8)) {
646 *result += (dbits << 8) +
wp_log2_table[(v << (9 - dbits)) & 0xff];
650 else if (v < (1 << 24))
655 *result += dbits = (dbits << 8) + wp_log2_table[(v >> (dbits - 9)) & 0xff];
657 if (limit && dbits >= limit)
667 while (nb_samples--) {
668 if (
log2sample(abs(*samples++), limit, &result))
675 int nb_samples,
int limit)
678 while (nb_samples--) {
679 if (
log2sample(abs(*samples_l++), limit, &result) ||
680 log2sample(abs(*samples_r++), limit, &result))
687 int nb_samples,
struct Decorr *dpp,
690 struct Decorr dp, *dppi = dpp + tindex;
698 pre_delta = delta + 1;
702 dp.
delta = pre_delta;
716 decorr_mono(samples, outsamples, nb_samples, &dp, 1);
722 decorr_mono(samples, outsamples, nb_samples, &dp, 1);
730 uint32_t term_bits[22],
bits;
732 if (branches < 1 || depth + 1 == info->nterms)
739 for (term = 1; term <= 18; term++) {
740 if (term == 17 && branches == 1 && depth + 1 < info->
nterms)
743 if (term > 8 && term < 17)
754 if (bits < info->best_bits) {
762 term_bits[term + 3] =
bits;
765 while (depth + 1 < info->
nterms && branches--) {
766 uint32_t local_best_bits = input_bits;
767 int best_term = 0, i;
769 for (i = 0; i < 22; i++)
770 if (term_bits[i] && term_bits[i] < local_best_bits) {
771 local_best_bits = term_bits[i];
778 term_bits[best_term + 3] = 0;
784 recurse_mono(s, info, depth + 1, delta, local_best_bits);
818 if (bits < info->best_bits) {
837 int lower = 0,
delta, d;
844 for (d =
delta - 1; d >= 0; d--) {
866 for (d =
delta + 1; !lower && d <= 7; d++) {
892 for (i = 0; i < nterms + 2; i++) {
912 for (i = 0; i < 2; i++) {
983 for (i = 0; i < info.
nterms; i++)
991 int32_t *samples,
int nb_samples,
int dir)
994 samples += nb_samples - 1;
996 while (nb_samples--) {
997 uint32_t low,
value = labs(samples[0]);
1005 if (value - low <
GET_MED(1)) {
1011 if (value - low <
GET_MED(2)) {
1023 int no_history,
int do_samples)
1025 struct Decorr temp_decorr_pass, save_decorr_passes[MAX_TERMS] = {{0}};
1027 int buf_size =
sizeof(
int32_t) * nb_samples;
1028 uint32_t best_size = UINT32_MAX,
size;
1029 int log_limit, pi, i, ret;
1031 for (i = 0; i < nb_samples; i++)
1035 if (i == nb_samples) {
1043 log_limit =
FFMIN(6912, log_limit);
1074 CLEAR(save_decorr_passes);
1076 for (j = 0; j < nterms; j++) {
1077 CLEAR(temp_decorr_pass);
1081 if (temp_decorr_pass.
value < 0)
1082 temp_decorr_pass.
value = 1;
1085 FFMIN(nb_samples, 2048), &temp_decorr_pass, -1);
1093 memcpy(save_decorr_passes + j, &temp_decorr_pass,
sizeof(
struct Decorr));
1095 nb_samples, &temp_decorr_pass, 1);
1099 if (size != UINT32_MAX || !nterms)
1104 if (size < best_size) {
1118 else if (do_samples)
1130 int nb_samples,
struct Decorr *dpp,
int dir)
1137 out_left += nb_samples - 1;
1138 out_right += nb_samples - 1;
1139 in_left += nb_samples - 1;
1140 in_right += nb_samples - 1;
1151 switch (dpp->
value) {
1153 while (nb_samples--) {
1175 while (nb_samples--) {
1197 while (nb_samples--) {
1219 int k = dpp->
value & (MAX_TERM - 1);
1221 while (nb_samples--) {
1238 m = (m + 1) & (MAX_TERM - 1);
1239 k = (k + 1) & (MAX_TERM - 1);
1252 m = (m + 1) & (MAX_TERM - 1);
1258 while (nb_samples--) {
1277 while (nb_samples--) {
1296 while (nb_samples--) {
1302 dpp->
samplesA[0] = tmp = in_right[0];
1307 dpp->
samplesB[0] = tmp = in_left[0];
1326 if (dpp->
value & 1) {
1339 if (dpp->
value & 1) {
1349 }
else if (dpp->
value > 1) {
1352 for (i = 0, j = dpp->
value - 1, k = 0; k < dpp->
value / 2; i++, j--, k++) {
1367 int nb_samples,
struct Decorr *dpp)
1379 switch (dpp->
value) {
1381 for (i = 0; i < nb_samples; i++) {
1396 for (i = 0; i < nb_samples; i++) {
1411 for (i = 0; i < nb_samples; i++) {
1426 int k = dpp->
value & (MAX_TERM - 1);
1428 for (i = 0; i < nb_samples; i++) {
1439 m = (m + 1) & (MAX_TERM - 1);
1440 k = (k + 1) & (MAX_TERM - 1);
1453 m = (m + 1) & (MAX_TERM - 1);
1459 for (i = 0; i < nb_samples; i++) {
1471 for (i = 0; i < nb_samples; i++) {
1483 for (i = 0; i < nb_samples; i++) {
1489 dpp->
samplesA[0] = tmp = in_right[i];
1493 dpp->
samplesB[0] = tmp = in_left[i];
1504 int nb_samples,
int tindex)
1506 struct Decorr dp = {0}, *dppi = info->
dps + tindex;
1507 int delta = dppi->delta, pre_delta;
1508 int term = dppi->value;
1515 pre_delta = delta + 1;
1518 dp.
delta = pre_delta;
1520 FFMIN(2048, nb_samples), &dp, -1);
1537 decorr_stereo(in_left, in_right, out_left, out_right, nb_samples, &dp, 1);
1541 dppi->weightA = dp.
weightA = dp.
sumA / nb_samples;
1542 dppi->weightB = dp.
weightB = dp.
sumB / nb_samples;
1547 nb_samples, &dp, 1);
1589 if (bits < info->best_bits) {
1612 int lower = 0,
delta, d, i;
1619 for (d =
delta - 1; d >= 0; d--) {
1643 for (d =
delta + 1; !lower && d <= 7; d++) {
1656 if (bits < info->best_bits) {
1674 int32_t *in_left, *in_right, *out_left, *out_right;
1675 uint32_t term_bits[22],
bits;
1677 if (branches < 1 || depth + 1 == info->nterms)
1686 for (term = -3; term <= 18; term++) {
1687 if (!term || (term > 8 && term < 17))
1690 if (term == 17 && branches == 1 && depth + 1 < info->
nterms)
1693 if (term == -1 || term == -2)
1706 if (bits < info->best_bits) {
1716 term_bits[term + 3] =
bits;
1719 while (depth + 1 < info->
nterms && branches--) {
1720 uint32_t local_best_bits = input_bits;
1721 int best_term = 0, i;
1723 for (i = 0; i < 22; i++)
1724 if (term_bits[i] && term_bits[i] < local_best_bits) {
1725 local_best_bits = term_bits[i];
1732 term_bits[best_term + 3] = 0;
1805 for (i = 0; i < info.
nterms; i++)
1814 int no_history,
int do_samples)
1816 struct Decorr temp_decorr_pass, save_decorr_passes[MAX_TERMS] = {{0}};
1818 int buf_size =
sizeof(
int32_t) * nb_samples;
1819 int log_limit, force_js = 0, force_ts = 0, got_js = 0, pi, i;
1820 uint32_t best_size = UINT32_MAX,
size;
1822 for (i = 0; i < nb_samples; i++)
1823 if (samples_l[i] || samples_r[i])
1826 if (i == nb_samples) {
1835 log_limit =
FFMIN(6912, log_limit);
1837 if (s->
joint != -1) {
1838 force_js = s->
joint;
1839 force_ts = !s->
joint;
1874 memcpy(s->
js_left, samples_l, buf_size);
1875 memcpy(s->
js_right, samples_r, buf_size);
1877 for (i = 0; i < nb_samples; i++)
1885 memcpy(s->
temp_buffer[0][0], samples_l, buf_size);
1886 memcpy(s->
temp_buffer[0][1], samples_r, buf_size);
1889 CLEAR(save_decorr_passes);
1891 for (j = 0; j < nterms; j++) {
1892 CLEAR(temp_decorr_pass);
1897 temp_decorr_pass.
value = -3;
1901 FFMIN(2048, nb_samples), &temp_decorr_pass, -1);
1910 memcpy(save_decorr_passes + j, &temp_decorr_pass,
sizeof(
struct Decorr));
1915 nb_samples, &temp_decorr_pass, 1);
1919 nb_samples, &temp_decorr_pass);
1923 nb_samples, log_limit);
1924 if (size != UINT32_MAX || !nterms)
1929 if (size < best_size) {
1952 memcpy(samples_l, s->
js_left, buf_size);
1953 memcpy(samples_r, s->
js_right, buf_size);
1957 }
else if (do_samples) {
1972 #define count_bits(av) ( \
1973 (av) < (1 << 8) ? nbits_table[av] : \
1975 (av) < (1 << 16) ? nbits_table[(av) >> 8] + 8 : \
1976 ((av) < (1 << 24) ? nbits_table[(av) >> 16] + 16 : nbits_table[(av) >> 24] + 24) \
1993 put_bits(pb, cbits, (1 << cbits) - 1);
2022 put_bits(pb, cbits, (1 << cbits) - 1);
2056 uint32_t ones_count, low, high;
2057 int sign = sample < 0;
2067 }
else if (sample) {
2081 ones_count = low = 0;
2088 if (sample - low <
GET_MED(1)) {
2096 if (sample - low <
GET_MED(2)) {
2101 ones_count = 2 + (sample - low) /
GET_MED(2);
2102 low += (ones_count - 2) *
GET_MED(2);
2126 uint32_t maxcode = high - low, code = sample - low;
2128 uint32_t extras = (1 << bitcount) - maxcode - 1;
2130 if (code < extras) {
2160 for (i = 0; i < nb_samples; i++) {
2161 put_sbits(pb, sent_bits, samples_l[i] >> pre_shift);
2164 for (i = 0; i < nb_samples; i++) {
2165 put_sbits(pb, sent_bits, samples_l[i] >> pre_shift);
2166 put_sbits(pb, sent_bits, samples_r[i] >> pre_shift);
2191 shift_count = max_exp ? max_exp - 1 : 0;
2195 if (shift_count < 25)
2196 value >>= shift_count;
2217 }
else if (shift_count) {
2233 for (i = 0; i < nb_samples; i++)
2236 for (i = 0; i < nb_samples; i++) {
2249 switch (dpp->
value) {
2251 for (i = 0; i < nb_samples; i++) {
2266 for (i = 0; i < nb_samples; i++) {
2281 for (m = 0, k = dpp->
value & (
MAX_TERM - 1), i = 0; i < nb_samples; i++) {
2304 m = (m + 1) & (MAX_TERM - 1);
2309 for (i = 0; i < nb_samples; i++) {
2321 for (i = 0; i < nb_samples; i++) {
2333 for (i = 0; i < nb_samples; i++) {
2339 dpp->
samplesA[0] = tmp = samples_r[i];
2343 dpp->
samplesB[0] = tmp = samples_l[i];
2351 #define update_weight_d2(weight, delta, source, result) \
2352 if (source && result) \
2353 weight -= (((source ^ result) >> 29) & 4) - 2;
2355 #define update_weight_clip_d2(weight, delta, source, result) \
2356 if (source && result) { \
2357 const int32_t s = (source ^ result) >> 31; \
2358 if ((weight = (weight ^ s) + (2 - s)) > 1024) weight = 1024; \
2359 weight = (weight ^ s) - s; \
2368 switch (dpp->
value) {
2370 for (i = 0; i < nb_samples; i++) {
2385 for (i = 0; i < nb_samples; i++) {
2400 for (m = 0, k = dpp->
value & (
MAX_TERM - 1), i = 0; i < nb_samples; i++) {
2424 m = (m + 1) & (MAX_TERM - 1);
2429 for (i = 0; i < nb_samples; i++) {
2441 for (i = 0; i < nb_samples; i++) {
2453 for (i = 0; i < nb_samples; i++) {
2459 dpp->
samplesA[0] = tmp = samples_r[i];
2463 dpp->
samplesB[0] = tmp = samples_l[i];
2476 bytestream2_put_byte(pb, flags);
2477 bytestream2_put_byte(pb, (size + 1) >> 1);
2484 int block_size,
start,
end, data_size, tcount,
temp, m = 0;
2485 int i, j, ret = 0, got_extra = 0, nb_samples = s->
block_samples;
2486 uint32_t crc = 0xffffffff
u;
2496 for (i = 0; i < nb_samples; i++) {
2497 lor |= samples_l[i] | samples_r[i];
2498 diff |= samples_l[i] - samples_r[i];
2504 if (i == nb_samples && lor && !
diff) {
2529 if ((mag -= shift) < 0)
2544 got_extra =
scan_float(s, samples_l, samples_r, nb_samples);
2546 got_extra =
scan_int32(s, samples_l, samples_r, nb_samples);
2549 scan_int23(s, samples_l, samples_r, nb_samples);
2560 ret =
wv_mono(s, samples_l, 1, 0);
2562 ret =
wv_stereo(s, samples_l, samples_r, 1, 0);
2567 for (i = 0; i < nb_samples; i++)
2568 crc += (crc << 1) + samples_l[i];
2573 for (i = 0; i < nb_samples; i++)
2574 crc += (crc << 3) + (samples_l[i] << 1) + samples_l[i] + samples_r[i];
2591 bytestream2_put_le32(&pb,
MKTAG(
'w',
'v',
'p',
'k'));
2592 bytestream2_put_le32(&pb, 0);
2593 bytestream2_put_le16(&pb, 0x410);
2594 bytestream2_put_le16(&pb, 0);
2595 bytestream2_put_le32(&pb, 0);
2597 bytestream2_put_le32(&pb, nb_samples);
2598 bytestream2_put_le32(&pb, s->
flags);
2599 bytestream2_put_le32(&pb, crc);
2607 bytestream2_put_byte(&pb, 0);
2613 bytestream2_put_byte(&pb, 0);
2619 bytestream2_put_byte(&pb, ((dpp->
value + 5) & 0x1f) | ((dpp->
delta << 5) & 0xe0));
2622 bytestream2_put_byte(&pb, 0);
2624 #define WRITE_DECWEIGHT(type) do { \
2625 temp = store_weight(type); \
2626 bytestream2_put_byte(&pb, temp); \
2627 type = restore_weight(temp); \
2631 bytestream2_put_byte(&pb, 0);
2633 for (i = s->
num_terms - 1; i >= 0; --i) {
2653 out[start - 1] = (end - start + 1) >> 1;
2654 if ((end - start) & 1)
2655 bytestream2_put_byte(&pb, 0);
2657 #define WRITE_DECSAMPLE(type) do { \
2658 temp = log2s(type); \
2659 type = wp_exp2(temp); \
2660 bytestream2_put_le16(&pb, temp); \
2664 bytestream2_put_byte(&pb, 0);
2676 }
else if (dpp->
value < 0) {
2680 for (j = 0; j < dpp->
value; j++) {
2692 out[start - 1] = (end -
start) >> 1;
2694 #define WRITE_CHAN_ENTROPY(chan) do { \
2695 for (i = 0; i < 3; i++) { \
2696 temp = wp_log2(s->w.c[chan].median[i]); \
2697 bytestream2_put_le16(&pb, temp); \
2698 s->w.c[chan].median[i] = wp_exp2(temp); \
2712 bytestream2_put_byte(&pb, 127);
2724 for (i = 0; i < nb_samples; i++) {
2748 samples_l[i] = code;
2762 m = (m + 1) & (MAX_TERM - 1);
2768 for (i = 0; i < nb_samples; i++)
2769 samples_r[i] += ((samples_l[i] -= samples_r[i]) >> 1);
2784 for (i = 0; i < nb_samples; i++)
2787 for (i = 0; i < nb_samples; i++) {
2795 bytestream2_put_le24(&pb, (data_size + 1) >> 1);
2798 bytestream2_put_byte(&pb, 0);
2809 bytestream2_put_le24(&pb, (data_size + 5) >> 1);
2810 bytestream2_put_le32(&pb, s->
crc_x);
2813 bytestream2_put_byte(&pb, 0);
2817 AV_WL32(out + 4, block_size - 8);
2830 #define COPY_SAMPLES(type, offset, shift) do { \
2831 const type *sptr = (const type *)src; \
2832 for (i = 0; i < nb_samples; i++) \
2833 dst[i] = (sptr[i] - offset) >> shift; \
2849 memcpy(dst, src, nb_samples * 4);
2857 for (i = 0; i < 15; i++) {
2910 buf, buf_size)) < 0)
2921 *got_packet_ptr = 1;
2936 for (i = 0; i < 2; i++) {
2959 #define OFFSET(x) offsetof(WavPackEncodeContext, x)
2960 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
2980 .priv_class = &wavpack_encoder_class,
#define WRITE_DECWEIGHT(type)
#define FF_COMPRESSION_DEFAULT
static int shift(int a, int b)
This structure describes decoded (raw) audio or video data.
static void put_sbits(PutBitContext *pb, int n, int32_t value)
static av_cold int wavpack_encode_close(AVCodecContext *avctx)
static void shift_stereo(int32_t *left, int32_t *right, int nb_samples, int shift)
static int scan_float(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
static int wv_stereo(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int no_history, int do_samples)
static int wavpack_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
#define LIBAVUTIL_VERSION_INT
static void process_float(WavPackEncodeContext *s, int32_t *sample)
static av_cold int init(AVCodecContext *avctx)
static void shift_mono(int32_t *samples, int nb_samples, int shift)
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
static void delta_mono(WavPackEncodeContext *s, WavPackExtraInfo *info)
static int allocate_buffers2(WavPackEncodeContext *s, int nterms)
static void sort_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info)
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...
static void pack_float_sample(WavPackEncodeContext *s, int32_t *sample)
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
#define AV_CH_LAYOUT_STEREO
static void put_metadata_block(PutByteContext *pb, int flags, int size)
static void wavpack_encode_sample(WavPackEncodeContext *s, WvChannel *c, int32_t sample)
static uint32_t log2mono(int32_t *samples, int nb_samples, int limit)
static av_cold int wavpack_encode_init(AVCodecContext *avctx)
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 av_assert0(cond)
assert() equivalent, that is always enabled.
enum AVSampleFormat sample_fmt
audio sample format
#define UPDATE_WEIGHT(weight, delta, source, result)
static void pack_int32(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
const WavPackDecorrSpec * decorr_specs
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 APPLY_WEIGHT_I(weight, sample)
static av_cold int end(AVCodecContext *avctx)
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
AVCodec ff_wavpack_encoder
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
static void delta_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info)
#define WRITE_CHAN_ENTROPY(chan)
static void fill_buffer(WavPackEncodeContext *s, const int8_t *src, int32_t *dst, int nb_samples)
static void decorr_mono_buffer(int32_t *samples, int32_t *outsamples, int nb_samples, struct Decorr *dpp, int tindex)
struct Decorr decorr_passes[MAX_TERMS]
#define APPLY_WEIGHT(weight, sample)
static void analyze_stereo(WavPackEncodeContext *s, int32_t *in_left, int32_t *in_right, int do_samples)
static const AVOption options[]
static void reverse_mono_decorr(struct Decorr *dpp)
int32_t * sampleptrs[MAX_TERMS+2][2]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static av_always_inline unsigned int bytestream2_get_bytes_left_p(PutByteContext *p)
static const uint16_t mask[17]
#define EXTRA_ADJUST_DELTAS
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static void set_samplerate(WavPackEncodeContext *s)
static av_always_inline int wp_exp2(int16_t val)
static void recurse_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info, int depth, int delta, uint32_t input_bits)
const char * name
Name of the codec implementation.
static void decorr_stereo_pass_id2(struct Decorr *dpp, int32_t *samples_l, int32_t *samples_r, int nb_samples)
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
int8_t terms[MAX_TERMS+1]
static int log2s(int32_t value)
uint64_t channel_layout
Audio channel layout.
static int put_bits_count(PutBitContext *s)
static const WavPackDecorrSpec *const decorr_filters[]
static av_always_inline void bytestream2_skip_p(PutByteContext *p, unsigned int size)
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
static void decorr_stereo_pass2(struct Decorr *dpp, int32_t *samples_l, int32_t *samples_r, int nb_samples)
static void scan_word(WavPackEncodeContext *s, WvChannel *c, int32_t *samples, int nb_samples, int dir)
static const int wv_rates[16]
GLsizei GLboolean const GLfloat * value
static void pack_float(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
static uint32_t log2sample(uint32_t v, int limit, uint32_t *result)
#define update_weight_d2(weight, delta, source, result)
int frame_size
Number of samples per channel in an audio frame.
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)
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
int sample_rate
samples per second
static int allocate_buffers(WavPackEncodeContext *s)
static void analyze_mono(WavPackEncodeContext *s, int32_t *samples, int do_samples)
main external API structure.
static int scan_int32(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
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)
#define WRITE_DECSAMPLE(type)
Describe the class of an AVClass context structure.
static int8_t store_weight(int weight)
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
int32_t * temp_buffer[2][2]
static void scan_int23(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, int nb_samples)
static int weight(int i, int blen, int offset)
#define update_weight_clip_d2(weight, delta, source, result)
#define UPDATE_WEIGHT_CLIP(weight, delta, samples, in)
static int restore_weight(int8_t weight)
static uint32_t log2stereo(int32_t *samples_l, int32_t *samples_r, int nb_samples, int limit)
static const AVClass wavpack_encoder_class
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static int wavpack_encode_block(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, uint8_t *out, int out_size)
static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p)
static const uint8_t decorr_filter_nterms[]
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static av_always_inline int wp_log2(int32_t val)
static void encode_flush(WavPackEncodeContext *s)
static void recurse_mono(WavPackEncodeContext *s, WavPackExtraInfo *info, int depth, int delta, uint32_t input_bits)
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static int wv_mono(WavPackEncodeContext *s, int32_t *samples, int no_history, int do_samples)
#define COPY_SAMPLES(type, offset, shift)
int channels
number of audio channels
static void decorr_mono(int32_t *in_samples, int32_t *out_samples, int nb_samples, struct Decorr *dpp, int dir)
static void reverse_decorr(struct Decorr *dpp)
int sampleptrs_size[MAX_TERMS+2][2]
static const uint8_t wp_log2_table[]
static const uint16_t decorr_filter_sizes[]
static enum AVSampleFormat sample_fmts[]
int temp_buffer_size[2][2]
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
static void sort_mono(WavPackEncodeContext *s, WavPackExtraInfo *info)
uint8_t ** extended_data
pointers to the data planes/channels.
#define AV_CH_LAYOUT_MONO
#define MKTAG(a, b, c, d)
static const int8_t nbits_table[]
This structure stores compressed data.
int nb_samples
number of audio samples (per channel) described by this frame
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...