Go to the documentation of this file.
53 { {-52, 4}, {-29, 5}, {-31, 4}, { 19, 4}, {-16, 4},
54 { 12, 3}, { -7, 3}, { 9, 3}, { -5, 3}, { 6, 3},
55 { -4, 3}, { 3, 3}, { -3, 2}, { 3, 2}, { -2, 2},
56 { 3, 2}, { -1, 2}, { 2, 2}, { -1, 2}, { 2, 2} },
57 { {-58, 3}, {-42, 4}, {-46, 4}, { 37, 5}, {-36, 4},
58 { 29, 4}, {-29, 4}, { 25, 4}, {-23, 4}, { 20, 4},
59 {-17, 4}, { 16, 4}, {-12, 4}, { 12, 3}, {-10, 4},
60 { 7, 3}, { -4, 4}, { 3, 3}, { -1, 3}, { 1, 3} },
61 { {-59, 3}, {-45, 5}, {-50, 4}, { 38, 4}, {-39, 4},
62 { 32, 4}, {-30, 4}, { 25, 3}, {-23, 3}, { 20, 3},
63 {-20, 3}, { 16, 3}, {-13, 3}, { 10, 3}, { -7, 3},
64 { 3, 3}, { 0, 3}, { -1, 3}, { 2, 3}, { -1, 2} }
74 -1048544 / 32, -1048288 / 32, -1047776 / 32, -1047008 / 32,
75 -1045984 / 32, -1044704 / 32, -1043168 / 32, -1041376 / 32,
76 -1039328 / 32, -1037024 / 32, -1034464 / 32, -1031648 / 32,
77 -1028576 / 32, -1025248 / 32, -1021664 / 32, -1017824 / 32,
78 -1013728 / 32, -1009376 / 32, -1004768 / 32, -999904 / 32,
79 -994784 / 32, -989408 / 32, -983776 / 32, -977888 / 32,
80 -971744 / 32, -965344 / 32, -958688 / 32, -951776 / 32,
81 -944608 / 32, -937184 / 32, -929504 / 32, -921568 / 32,
82 -913376 / 32, -904928 / 32, -896224 / 32, -887264 / 32,
83 -878048 / 32, -868576 / 32, -858848 / 32, -848864 / 32,
84 -838624 / 32, -828128 / 32, -817376 / 32, -806368 / 32,
85 -795104 / 32, -783584 / 32, -771808 / 32, -759776 / 32,
86 -747488 / 32, -734944 / 32, -722144 / 32, -709088 / 32,
87 -695776 / 32, -682208 / 32, -668384 / 32, -654304 / 32,
88 -639968 / 32, -625376 / 32, -610528 / 32, -595424 / 32,
89 -580064 / 32, -564448 / 32, -548576 / 32, -532448 / 32,
90 -516064 / 32, -499424 / 32, -482528 / 32, -465376 / 32,
91 -447968 / 32, -430304 / 32, -412384 / 32, -394208 / 32,
92 -375776 / 32, -357088 / 32, -338144 / 32, -318944 / 32,
93 -299488 / 32, -279776 / 32, -259808 / 32, -239584 / 32,
94 -219104 / 32, -198368 / 32, -177376 / 32, -156128 / 32,
95 -134624 / 32, -112864 / 32, -90848 / 32, -68576 / 32,
96 -46048 / 32, -23264 / 32, -224 / 32, 23072 / 32,
97 46624 / 32, 70432 / 32, 94496 / 32, 118816 / 32,
98 143392 / 32, 168224 / 32, 193312 / 32, 218656 / 32,
99 244256 / 32, 270112 / 32, 296224 / 32, 322592 / 32,
100 349216 / 32, 376096 / 32, 403232 / 32, 430624 / 32,
101 458272 / 32, 486176 / 32, 514336 / 32, 542752 / 32,
102 571424 / 32, 600352 / 32, 629536 / 32, 658976 / 32,
103 688672 / 32, 718624 / 32, 748832 / 32, 779296 / 32,
104 810016 / 32, 840992 / 32, 872224 / 32, 903712 / 32,
105 935456 / 32, 967456 / 32, 999712 / 32, 1032224 / 32
124 204, 192, 179, 166, 153, 140, 128, 115,
125 102, 89, 76, 64, 51, 38, 25, 12,
126 0, -12, -25, -38, -51, -64, -76, -89,
127 -102, -115, -128, -140, -153, -166, -179, -192
134 { 74, 44, 25, 13, 7, 3},
135 { 68, 42, 24, 13, 7, 3},
136 { 58, 39, 23, 13, 7, 3},
137 {126, 70, 37, 19, 10, 5},
138 {132, 70, 37, 20, 10, 5},
139 {124, 70, 38, 20, 10, 5},
140 {120, 69, 37, 20, 11, 5},
141 {116, 67, 37, 20, 11, 5},
142 {108, 66, 36, 20, 10, 5},
143 {102, 62, 36, 20, 10, 5},
144 { 88, 58, 34, 19, 10, 5},
145 {162, 89, 49, 25, 13, 7},
146 {156, 87, 49, 26, 14, 7},
147 {150, 86, 47, 26, 14, 7},
148 {142, 84, 47, 26, 14, 7},
149 {131, 79, 46, 26, 14, 7}
298 int i, config_offset;
302 uint32_t als_id, header_size, trailer_size;
311 if (config_offset < 0)
357 if (als_id !=
MKBETAG(
'A',
'L',
'S',
'\0'))
415 if (header_size == 0xFFFFFFFF)
417 if (trailer_size == 0xFFFFFFFF)
420 ht_size = ((
int64_t)(header_size) + (
int64_t)(trailer_size)) << 3;
427 if (ht_size > INT32_MAX)
440 ctx->crc = 0xFFFFFFFF;
463 #define MISSING_ERR(cond, str, errval) \
466 avpriv_report_missing_feature(ctx->avctx, \
482 unsigned int div,
unsigned int **div_blocks,
483 unsigned int *num_blocks)
485 if (n < 31 && ((bs_info << n) & 0x40000000)) {
526 for (
i = 0, j = k - 1;
i < j;
i++, j--) {
527 unsigned tmp1 = ((
MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
528 cof[j] += ((
MUL64(par[k], cof[
i]) + (1 << 19)) >> 20);
532 cof[
i] += ((
MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
547 unsigned int *ptr_div_blocks = div_blocks;
553 *bs_info <<= (32 - bs_info_len);
574 for (
b = 0;
b <
ctx->num_blocks;
b++)
575 div_blocks[
b] =
ctx->sconf.frame_length >> div_blocks[
b];
577 if (
ctx->cur_frame_length !=
ctx->sconf.frame_length) {
578 unsigned int remaining =
ctx->cur_frame_length;
580 for (
b = 0;
b <
ctx->num_blocks;
b++) {
581 if (remaining <= div_blocks[
b]) {
582 div_blocks[
b] = remaining;
583 ctx->num_blocks =
b + 1;
587 remaining -= div_blocks[
b];
647 unsigned int sub_blocks, log2_sub_blocks, sb_length;
648 unsigned int start = 0;
649 unsigned int opt_order;
673 sub_blocks = 1 << log2_sub_blocks;
679 "Block length is not evenly divisible by the number of subblocks.\n");
687 for (k = 1; k < sub_blocks; k++)
690 for (k = 0; k < sub_blocks; k++) {
696 for (k = 1; k < sub_blocks; k++)
699 for (k = 1; k < sub_blocks; k++)
740 for (k = 2; k < opt_order; k++)
747 k_max =
FFMIN(opt_order, 20);
748 for (k = 0; k < k_max; k++) {
752 if (quant_cof[k] < -64 || quant_cof[k] > 63) {
754 "quant_cof %"PRId32
" is out of range.\n",
761 k_max =
FFMIN(opt_order, 127);
762 for (; k < k_max; k++)
766 for (; k < opt_order; k++)
775 for (k = 2; k < opt_order; k++)
776 quant_cof[k] = (quant_cof[k] * (1
U << 14)) + (add_base << 13);
809 start =
FFMIN(opt_order, 3);
811 if (sb_length <= start) {
842 for (sb = 0; sb < sub_blocks; sb++) {
843 unsigned int sb_len = sb_length - (sb ? 0 : start);
845 k [sb] =
s[sb] >
b ?
s[sb] -
b : 0;
846 delta[sb] = 5 -
s[sb] + k[sb];
854 current_res += sb_len;
863 for (sb = 0; sb < sub_blocks; sb++, start = 0) {
865 unsigned int cur_k = k[sb];
866 unsigned int cur_s =
s[sb];
868 for (; start < sb_length; start++) {
871 if (res == cur_tail_code) {
872 unsigned int max_msb = (2 + (sx[sb] > 2) + (sx[sb] > 10))
878 res += (max_msb ) << cur_k;
880 res -= (max_msb - 1) << cur_k;
883 if (res > cur_tail_code)
897 *current_res++ = res;
903 for (sb = 0; sb < sub_blocks; sb++, start = 0)
904 for (; start < sb_length; start++)
918 unsigned int smp = 0;
927 int32_t *lpc_cof_reversed =
ctx->lpc_cof_reversed_buffer;
933 for (ltp_smp =
FFMAX(*bd->
ltp_lag - 2, 0); ltp_smp < block_length; ltp_smp++) {
934 int center = ltp_smp - *bd->
ltp_lag;
935 int begin =
FFMAX(0, center - 2);
936 int end = center + 3;
937 int tab = 5 - (end - begin);
945 raw_samples[ltp_smp] += y >> 7;
951 for (smp = 0; smp <
FFMIN(opt_order, block_length); smp++) {
954 for (sb = 0; sb < smp; sb++)
955 y += (uint64_t)
MUL64(lpc_cof[sb], raw_samples[-(sb + 1)]);
957 *raw_samples++ -= y >> 20;
961 for (k = 0; k < opt_order; k++)
971 uint32_t *
left, *right;
981 for (sb = -1; sb >= -sconf->
max_order; sb--)
982 raw_samples[sb] = right[sb] -
left[sb];
987 for (sb = -1; sb >= -sconf->
max_order; sb--)
992 lpc_cof = lpc_cof + opt_order;
994 for (sb = 0; sb < opt_order; sb++)
995 lpc_cof_reversed[sb] = lpc_cof[-(sb + 1)];
999 lpc_cof = lpc_cof_reversed + opt_order;
1001 for (; raw_samples < raw_samples_end; raw_samples++) {
1004 for (sb = -opt_order; sb < 0; sb++)
1005 y += (uint64_t)
MUL64(lpc_cof[sb], raw_samples[sb]);
1007 *raw_samples -= y >> 20;
1015 sizeof(*raw_samples) * sconf->
max_order);
1091 const unsigned int *div_blocks,
int32_t *buf)
1093 unsigned int count = 0;
1096 count += div_blocks[
b++];
1099 memset(buf, 0,
sizeof(*buf) * count);
1106 unsigned int c,
const unsigned int *div_blocks,
1107 unsigned int *js_blocks)
1127 for (
b = 0;
b <
ctx->num_blocks;
b++) {
1146 unsigned int c,
const unsigned int *div_blocks,
1147 unsigned int *js_blocks)
1182 for (
b = 0;
b <
ctx->num_blocks;
b++) {
1199 if (bd[0].js_blocks) {
1200 if (bd[1].js_blocks)
1203 for (
s = 0;
s < div_blocks[
b];
s++)
1204 bd[0].raw_samples[
s] = bd[1].raw_samples[
s] - (
unsigned)bd[0].
raw_samples[
s];
1205 }
else if (bd[1].js_blocks) {
1206 for (
s = 0;
s < div_blocks[
b];
s++)
1207 bd[1].raw_samples[
s] = bd[1].raw_samples[
s] + (
unsigned)bd[0].
raw_samples[
s];
1242 unsigned int channels =
ctx->avctx->ch_layout.nb_channels;
1290 unsigned int dep = 0;
1291 unsigned int channels =
ctx->avctx->ch_layout.nb_channels;
1292 unsigned int channel_size =
ctx->sconf.frame_length +
ctx->sconf.max_order;
1299 while (dep <
channels && !ch[dep].stop_flag) {
1301 ch[dep].master_channel);
1322 for (dep = 0; !ch[dep].
stop_flag; dep++) {
1324 ptrdiff_t begin = 1;
1329 if (ch[dep].master_channel ==
c)
1332 if (ch[dep].time_diff_flag) {
1335 if (ch[dep].time_diff_sign) {
1350 if (
FFMIN(begin - 1, begin - 1 + t) <
ctx->raw_buffer -
master ||
1353 "sample pointer range [%p, %p] not contained in raw_buffer [%p, %p].\n",
1359 for (smp = begin; smp < end; smp++) {
1364 MUL64(ch[dep].weighting[3],
master[smp - 1 + t]) +
1372 if (begin - 1 <
ctx->raw_buffer -
master ||
1375 "sample pointer range [%p, %p] not contained in raw_buffer [%p, %p].\n",
1381 for (smp = begin; smp < end; smp++) {
1399 uint64_t mantissa_temp;
1401 int cutoff_bit_count;
1402 unsigned char last_2_bits;
1403 unsigned int mantissa;
1405 uint32_t return_val = 0;
1408 sign =
a.sign ^
b.sign;
1411 mantissa_temp = (uint64_t)
a.mant * (uint64_t)
b.mant;
1412 mask_64 = (uint64_t)0x1 << 47;
1418 while (!(mantissa_temp & mask_64) && mask_64) {
1424 cutoff_bit_count = bit_count - 24;
1425 if (cutoff_bit_count > 0) {
1426 last_2_bits = (
unsigned char)(((
unsigned int)mantissa_temp >> (cutoff_bit_count - 1)) & 0x3 );
1427 if ((last_2_bits == 0x3) || ((last_2_bits == 0x1) && ((
unsigned int)mantissa_temp & ((0x1UL << (cutoff_bit_count - 1)) - 1)))) {
1429 mantissa_temp += (uint64_t)0x1 << cutoff_bit_count;
1433 if (cutoff_bit_count >= 0) {
1434 mantissa = (
unsigned int)(mantissa_temp >> cutoff_bit_count);
1436 mantissa = (
unsigned int)(mantissa_temp <<-cutoff_bit_count);
1440 if (mantissa & 0x01000000ul) {
1446 return_val = 0x80000000
U;
1449 return_val |= ((unsigned)
av_clip(
a.exp +
b.exp + bit_count - 47, -126, 127) << 23) & 0x7F800000;
1450 return_val |= mantissa;
1461 int *shift_value =
ctx->shift_value;
1462 int *last_shift_value =
ctx->last_shift_value;
1463 int *last_acf_mantissa =
ctx->last_acf_mantissa;
1464 int **raw_mantissa =
ctx->raw_mantissa;
1465 int *nbits =
ctx->nbits;
1466 unsigned char *larray =
ctx->larray;
1467 int frame_length =
ctx->cur_frame_length;
1469 unsigned int partA_flag;
1470 unsigned int highest_byte;
1471 unsigned int shift_amp;
1502 last_acf_mantissa[
c] = tmp_32;
1504 tmp_32 = last_acf_mantissa[
c];
1517 last_shift_value[
c] = shift_value[
c];
1519 shift_value[
c] = last_shift_value[
c];
1524 for (
i = 0;
i < frame_length; ++
i) {
1525 if (
ctx->raw_samples[
c][
i] == 0) {
1531 for (
i = 0;
i < frame_length; ++
i) {
1532 if (
ctx->raw_samples[
c][
i] == 0) {
1538 if(tmp_32 != nchars) {
1543 for (
i = 0;
i < frame_length; ++
i) {
1551 for (
i = 0;
i < frame_length; ++
i) {
1552 if (
ctx->raw_samples[
c][
i] != 0) {
1559 nbits[
i] =
FFMIN(nbits[
i], highest_byte*8);
1564 for (
i = 0;
i < frame_length; ++
i) {
1565 if (
ctx->raw_samples[
c][
i] != 0) {
1571 for (
i = 0;
i < frame_length; ++
i) {
1572 if (
ctx->raw_samples[
c][
i]) {
1573 nchars += (int) nbits[
i] / 8;
1581 if(tmp_32 != nchars) {
1587 for (
i = 0;
i < frame_length; ++
i) {
1588 if (
ctx->raw_samples[
c][
i]) {
1590 nbits_aligned = 8 * ((
unsigned int)(nbits[
i] / 8) + 1);
1592 nbits_aligned = nbits[
i];
1595 for (k = 0; k < nbits_aligned/8; ++k) {
1596 acc = (acc << 8) + larray[j++];
1598 acc >>= (nbits_aligned - nbits[
i]);
1599 raw_mantissa[
c][
i] = acc;
1605 for (
i = 0;
i < frame_length; ++
i) {
1609 if (
ctx->raw_samples[
c][
i] != 0) {
1616 mantissa = (pcm_sf.
mant | 0x800000) + raw_mantissa[
c][
i];
1618 while(mantissa >= 0x1000000) {
1623 if (mantissa) e += (shift_value[
c] - 127);
1624 mantissa &= 0x007fffffUL;
1626 tmp_32 = (sign << 31) | ((e +
EXP_BIAS) << 23) | (mantissa);
1627 ctx->raw_samples[
c][
i] = tmp_32;
1629 ctx->raw_samples[
c][
i] = raw_mantissa[
c][
i] & 0x007fffffUL;
1645 unsigned int div_blocks[32];
1647 unsigned int js_blocks[2];
1649 uint32_t bs_info = 0;
1681 if (independent_bs) {
1683 div_blocks, js_blocks);
1699 ctx->highest_decoded_channel =
c;
1704 int *reverted_channels =
ctx->reverted_channels;
1708 if (
ctx->chan_data[
c] <
ctx->chan_data_buffer) {
1713 memset(reverted_channels, 0,
sizeof(*reverted_channels) *
channels);
1720 for (
b = 0;
b <
ctx->num_blocks;
b++) {
1724 "Invalid block length %u in channel data!\n",
1750 reverted_channels,
offset,
c);
1769 ctx->highest_decoded_channel =
FFMAX(
ctx->highest_decoded_channel,
c);
1772 memset(reverted_channels, 0,
channels *
sizeof(*reverted_channels));
1800 int *got_frame_ptr,
AVPacket *avpkt)
1805 int buffer_size = avpkt->
size;
1806 int invalid_frame,
ret;
1820 if (sconf->
samples != 0xFFFFFFFF)
1826 ctx->highest_decoded_channel = -1;
1830 "Reading frame data failed. Skipping RA unit.\n");
1832 if (
ctx->highest_decoded_channel == -1) {
1834 "No channel data decoded.\n");
1841 frame->nb_samples =
ctx->cur_frame_length;
1846 #define INTERLEAVE_OUTPUT(bps) \
1848 int##bps##_t *dest = (int##bps##_t*)frame->data[0]; \
1849 int32_t *raw_samples = ctx->raw_samples[0]; \
1850 int raw_step = channels > 1 ? ctx->raw_samples[1] - raw_samples : 1; \
1851 shift = bps - ctx->avctx->bits_per_raw_sample; \
1852 if (!ctx->cs_switch) { \
1853 for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1854 for (c = 0; c < channels; c++) \
1855 *dest++ = raw_samples[c*raw_step + sample] * (1U << shift); \
1857 for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1858 for (c = 0; c < channels; c++) \
1859 *dest++ = raw_samples[sconf->chan_pos[c]*raw_step + sample] * (1U << shift);\
1863 if (
ctx->avctx->bits_per_raw_sample <= 16) {
1871 int swap = HAVE_BIGENDIAN != sconf->
msb_first;
1873 if (
ctx->avctx->bits_per_raw_sample == 24) {
1885 if (!HAVE_BIGENDIAN)
1891 uint8_t *crc_source;
1894 if (
ctx->avctx->bits_per_raw_sample <= 16) {
1895 int16_t *
src = (int16_t*)
frame->data[0];
1896 int16_t *dest = (int16_t*)
ctx->crc_buffer;
1902 ctx->bdsp.bswap_buf((uint32_t *)
ctx->crc_buffer,
1903 (uint32_t *)
frame->data[0],
1906 crc_source =
ctx->crc_buffer;
1908 crc_source =
frame->data[0];
1919 ctx->crc_org !=
ctx->crc) {
1928 bytes_read = invalid_frame ? buffer_size :
1974 if (
ctx->raw_mantissa) {
1992 unsigned int channel_size;
1993 int num_buffers,
ret;
2044 if (num_buffers * (uint64_t)num_buffers > INT_MAX)
2050 sizeof(*
ctx->quant_cof_buffer));
2052 sizeof(*
ctx->lpc_cof_buffer));
2054 sizeof(*
ctx->lpc_cof_buffer));
2056 if (!
ctx->quant_cof || !
ctx->lpc_cof ||
2057 !
ctx->quant_cof_buffer || !
ctx->lpc_cof_buffer ||
2058 !
ctx->lpc_cof_reversed_buffer) {
2064 for (
c = 0;
c < num_buffers;
c++) {
2079 if (!
ctx->const_block || !
ctx->shift_lsbs ||
2080 !
ctx->opt_order || !
ctx->store_prev_samples ||
2081 !
ctx->use_ltp || !
ctx->ltp_lag ||
2082 !
ctx->ltp_gain || !
ctx->ltp_gain_buffer) {
2087 for (
c = 0;
c < num_buffers;
c++)
2088 ctx->ltp_gain[
c] =
ctx->ltp_gain_buffer +
c * 5;
2092 ctx->chan_data_buffer =
av_calloc(num_buffers * num_buffers,
2093 sizeof(*
ctx->chan_data_buffer));
2096 sizeof(*
ctx->reverted_channels));
2098 if (!
ctx->chan_data_buffer || !
ctx->chan_data || !
ctx->reverted_channels) {
2103 for (
c = 0;
c < num_buffers;
c++)
2104 ctx->chan_data[
c] =
ctx->chan_data_buffer +
c * num_buffers;
2108 ctx->reverted_channels =
NULL;
2122 if (!
ctx->mlz || !
ctx->acf || !
ctx->shift_value || !
ctx->last_shift_value
2123 || !
ctx->last_acf_mantissa || !
ctx->raw_mantissa) {
2144 if (!
ctx->prev_raw_samples || !
ctx->raw_buffer|| !
ctx->raw_samples) {
2152 ctx->raw_samples[
c] =
ctx->raw_samples[
c - 1] + channel_size;
2160 sizeof(*
ctx->crc_buffer));
2161 if (!
ctx->crc_buffer) {
2194 #if FF_API_SUBFRAMES
2195 AV_CODEC_CAP_SUBFRAMES |
static void error(const char *err)
MLZ * mlz
masked lz decompression structure
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
unsigned int * opt_order
contains opt_order flags for all channels
unsigned int cur_frame_length
length of the current frame to decode
int32_t ** lpc_cof
coefficients of the direct form prediction filter for a channel
#define AV_EF_EXPLODE
abort decoding on minor error detection
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
#define AV_EF_CAREFUL
consider things that violate the spec, are fast to calculate and have not been seen in the wild as er...
static int get_bits_left(GetBitContext *gb)
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
int * ltp_lag
contains ltp lag values for all channels
uint32_t crc_org
CRC value of the original input data.
int * reverted_channels
stores a flag for each reverted channel
int block_switching
number of block switching levels
int ff_bgmc_decode_init(GetBitContext *gb, unsigned int *h, unsigned int *l, unsigned int *v)
Initialize decoding and reads the first value.
int * shift_value
value by which the binary point is to be shifted for all channels
av_cold void ff_mlz_flush_dict(MLZ *mlz)
Flush the dictionary.
int sample_rate
samples per second
int msb_first
1 = original CRC calculated on big-endian system, 0 = little-endian
int32_t * raw_samples
decoded raw samples / residuals for this block
ALSChannelData * chan_data_buffer
contains channel data for all channels
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
static int decode_blocks(ALSDecContext *ctx, unsigned int ra_frame, unsigned int c, const unsigned int *div_blocks, unsigned int *js_blocks)
Decode blocks dependently.
static SoftFloat_IEEE754 av_bits2sf_ieee754(uint32_t n)
Make a softfloat out of the bitstream.
static av_cold int decode_init(AVCodecContext *avctx)
Initialize the ALS decoder.
unsigned int * opt_order
prediction order of this block
static int get_bits_count(const GetBitContext *s)
unsigned int ra_block
if true, this is a random access block
static const int16_t mcc_weightings[]
Inter-channel weighting factors for multi-channel correlation.
uint8_t * bgmc_lut
pointer at lookup tables used for BGMC
This structure describes decoded (raw) audio or video data.
int frame_length
frame length for each frame (last frame may differ)
static int als_weighting(GetBitContext *gb, int k, int off)
static int read_decode_block(ALSDecContext *ctx, ALSBlockData *bd)
Read and decode block data successively.
int resolution
000 = 8-bit; 001 = 16-bit; 010 = 24-bit; 011 = 32-bit
static int read_diff_float_data(ALSDecContext *ctx, unsigned int ra_frame)
Read and decode the floating point sample data.
ALSChannelData ** chan_data
channel data for multi-channel correlation
unsigned char * larray
buffer to store the output of masked lz decompression
enum AVChannelOrder order
Channel order used in this layout.
int nb_channels
Number of channels in this layout.
int joint_stereo
joint stereo: 1 = on, 0 = off
static const SoftFloat FLOAT_1
1.0
unsigned int cs_switch
if true, channel rearrangement is done
unsigned int js_switch
if true, joint-stereo decoding is enforced
av_cold void ff_bgmc_end(uint8_t **cf_lut, int **cf_lut_status)
Release the lookup table arrays.
static SoftFloat_IEEE754 av_int2sf_ieee754(int64_t n, int e)
Convert integer to softfloat.
static void skip_bits(GetBitContext *s, int n)
int ra_distance
distance between RA frames (in frames, 0...255)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
AVCodec p
The public AVCodec.
AVChannelLayout ch_layout
Audio channel layout.
static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Read the block data for a non-constant block.
static const uint8_t ltp_gain_values[4][4]
Gain values of p(0) for long-term prediction.
int * store_prev_samples
if true, carryover samples have to be stored
int * const_block
contains const_block flags for all channels
static const struct twinvq_data tab
int highest_decoded_channel
static double val(void *priv, double ch)
int32_t * raw_buffer
contains all decoded raw samples including carryover samples
int * ltp_gain
gain values for ltp 5-tap filter
int32_t * raw_other
decoded raw samples of the other channel of a channel pair
int adapt_order
adaptive order: 1 = on, 0 = off
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
unsigned int * shift_lsbs
shift of values for this block
#define FF_ARRAY_ELEMS(a)
#define MISSING_ERR(cond, str, errval)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
static int revert_channel_correlation(ALSDecContext *ctx, ALSBlockData *bd, ALSChannelData **cd, int *reverted, unsigned int offset, int c)
Recursively reverts the inter-channel correlation for a block.
int chan_sort
channel rearrangement: 1 = on, 0 = off
int avpriv_mpeg4audio_get_config2(MPEG4AudioConfig *c, const uint8_t *buf, int size, int sync_extension, void *logctx)
Parse MPEG-4 systems extradata from a raw buffer to retrieve audio configuration.
#define FF_CODEC_DECODE_CB(func)
int ltp_lag_length
number of bits used for ltp lag value
static void zero_remaining(unsigned int b, unsigned int b_max, const unsigned int *div_blocks, int32_t *buf)
Compute the number of samples left to decode for the current frame and sets these samples to zero.
void ff_bgmc_decode(GetBitContext *gb, unsigned int num, int32_t *dst, int delta, unsigned int sx, unsigned int *h, unsigned int *l, unsigned int *v, uint8_t *cf_lut, int *cf_lut_status)
Read and decode a block Gilbert-Moore coded symbol.
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
static void decode_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Decode the block data for a constant block.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)
Convert PARCOR coefficient k to direct filter coefficient.
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
static int av_cmp_sf_ieee754(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b)
Compare a with b strictly.
int * last_shift_value
contains last shift value for all channels
int * ltp_lag
lag value for long-term prediction
static SoftFloat_IEEE754 multiply(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b)
multiply two softfloats and handle the rounding off
int bgmc
"Block Gilbert-Moore Code": 1 = on, 0 = off (Rice coding only)
int * ltp_gain_buffer
contains all gain values for ltp 5-tap filter
#define CODEC_LONG_NAME(str)
uint32_t crc
CRC value calculated from decoded data.
static av_cold int decode_end(AVCodecContext *avctx)
Uninitialize the ALS decoder.
unsigned int block_length
number of samples within the block
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
#define PTRDIFF_SPECIFIER
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static const SoftFloat FLOAT_0
0.0
int chan_config
indicates that a chan_config_info field is present
static int check_specific_config(ALSDecContext *ctx)
Check the ALSSpecificConfig for unsupported features.
unsigned int num_blocks
number of blocks used in the current frame
static unsigned int get_bits1(GetBitContext *s)
int * chan_pos
original channel positions
int * bgmc_lut_status
pointer at lookup table status flags used for BGMC
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
int long_term_prediction
long term prediction (LTP): 1 = on, 0 = off
enum RA_Flag ra_flag
indicates where the size of ra units is stored
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 int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
static int read_block(ALSDecContext *ctx, ALSBlockData *bd)
Read the block data.
static const uint8_t tail_code[16][6]
Tail codes used in arithmetic coding using block Gilbert-Moore codes.
static const int16_t parcor_scaled_values[]
Scaled PARCOR values used for the first two PARCOR coefficients.
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
av_cold int ff_bgmc_init(void *logctx, uint8_t **cf_lut, int **cf_lut_status)
Initialize the lookup table arrays.
unsigned int s_max
maximum Rice parameter allowed in entropy coding
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
int(* init)(AVBSFContext *ctx)
int ** ltp_gain
gain values for ltp 5-tap filter for a channel
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
int * nbits
contains the number of bits to read for masked lz decompression for all samples
static int read_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Read the block data for a constant block.
int chan_config_info
mapping of channels to loudspeaker locations. Unused until setting channel configuration is implement...
int32_t * lpc_cof_buffer
contains all coefficients of the direct form prediction filter
static int shift(int a, int b)
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
enum AVSampleFormat sample_fmt
audio sample format
#define MKBETAG(a, b, c, d)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
unsigned int * shift_lsbs
contains shift_lsbs flags for all channels
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
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 offset
int crc_enabled
enable Cyclic Redundancy Checksum
int * use_ltp
contains use_ltp flags for all channels
int floating
1 = IEEE 32-bit floating-point, 0 = integer
static void skip_bits1(GetBitContext *s)
int * store_prev_samples
contains store_prev_samples flags for all channels
static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame, unsigned int c, const unsigned int *div_blocks, unsigned int *js_blocks)
Decode blocks independently.
int * use_ltp
if true, long-term prediction is used
#define i(width, name, range_min, range_max)
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
int rlslms
use "Recursive Least Square-Least Mean Square" predictor: 1 = on, 0 = off
#define av_malloc_array(a, b)
int * last_acf_mantissa
contains the last acf mantissa data of common multiplier for all channels
int32_t * quant_cof
quantized parcor coefficients
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
@ AV_SAMPLE_FMT_S16
signed 16 bits
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const char * name
Name of the codec implementation.
int32_t ** quant_cof
quantized parcor coefficients for a channel
int ** raw_mantissa
decoded mantissa bits of the difference signal
int32_t * lpc_cof
coefficients of the direct form prediction
void * av_calloc(size_t nmemb, size_t size)
int32_t * prev_raw_samples
contains unshifted raw samples from the previous block
int sb_part
sub-block partition
static av_cold void dprint_specific_config(ALSDecContext *ctx)
uint8_t * crc_buffer
buffer of byte order corrected samples used for CRC check
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
static const uint8_t * align_get_bits(GetBitContext *s)
static SoftFloat_IEEE754 av_div_sf_ieee754(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b)
Divide a by b.
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
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Decode an ALS frame.
main external API structure.
int coef_table
table index of Rice code parameters
static int read_channel_data(ALSDecContext *ctx, ALSChannelData *cd, int c)
Read the channel data.
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
int32_t ** raw_samples
decoded raw samples for each channel
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
int32_t * lpc_cof_reversed_buffer
temporary buffer to set up a reversed versio of lpc_cof_buffer
static int32_t decode_rice(GetBitContext *gb, unsigned int k)
Read and decode a Rice codeword.
int32_t * quant_cof_buffer
contains all quantized parcor coefficients
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
static av_cold int read_specific_config(ALSDecContext *ctx)
Read an ALSSpecificConfig from a buffer into the output struct.
int ff_mlz_decompression(MLZ *mlz, GetBitContext *gb, int size, unsigned char *buff)
Run mlz decompression on the next size bits and the output will be stored in buff.
int32_t * prev_raw_samples
contains unshifted raw samples from the previous block
uint32_t samples
number of samples, 0xFFFFFFFF if unknown
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
int js_blocks
true if this block contains a difference signal
static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)
Read the frame data.
#define avpriv_request_sample(...)
static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Decode the block data for a non-constant block.
static void scale(int *out, const int *in, const int w, const int h, const int shift)
#define INTERLEAVE_OUTPUT(bps)
This structure stores compressed data.
unsigned int frame_id
the frame ID / number of the current frame
static int decode_block(ALSDecContext *ctx, ALSBlockData *bd)
Decode the block data.
av_cold int ff_mlz_init_dict(void *context, MLZ *mlz)
Initialize the dictionary.
void ff_bgmc_decode_end(GetBitContext *gb)
Finish decoding.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int max_order
maximum prediction order (0..1023)
#define FF_SANE_NB_CHANNELS
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
@ AV_SAMPLE_FMT_S32
signed 32 bits
SoftFloat_IEEE754 * acf
contains common multiplier for all channels
int mc_coding
extended inter-channel coding (multi channel coding): 1 = on, 0 = off
static void get_block_sizes(ALSDecContext *ctx, unsigned int *div_blocks, uint32_t *bs_info)
Read block switching field if necessary and set actual block sizes.
const FFCodec ff_als_decoder
static void parse_bs_info(const uint32_t bs_info, unsigned int n, unsigned int div, unsigned int **div_blocks, unsigned int *num_blocks)
Parse the bs_info field to extract the block partitioning used in block switching mode,...
static const int8_t parcor_rice_table[3][20][2]
Rice parameters and corresponding index offsets for decoding the indices of scaled PARCOR values.
int * const_block
if true, this is a constant value block