21 #define BITSTREAM_READER_LE
87 { 0, -1, -1, -1, -1 },
97 { 0, -1, -1, -1, -1 },
100 { 1, 2, -1, -1, -1 },
135 for (
i = 0;
i < 256;
i++)
138 for (
i = 0;
i < 16;
i++)
147 int i, ps, si,
code, step_i;
153 value = (((ps & 0x7fffff) ^ -si) + si) * (1.0f / 0x7fffff);
156 if (step_i > step_max) {
163 for (
i = 0;
i < 64;
i++) {
166 delta = step * 0.03125f;
170 delta += step * 0.5f;
172 delta += step * 0.25f;
174 delta += step * 0.125f;
176 delta += step * 0.0625f;
189 step_i =
av_clip(step_i, 0, step_max);
192 s->lfe_data[
i] =
value *
s->lfe_scale;
201 int i, ps, si,
code, step_i;
207 value = (((ps & 0x7fff) ^ -si) + si) * (1.0f / 0x7fff);
210 if (step_i > step_max) {
217 for (
i = 0;
i < 64;
i++) {
220 delta = step * 0.125f;
224 delta += step * 0.5f;
226 delta += step * 0.25f;
239 step_i =
av_clip(step_i, 0, step_max);
242 s->lfe_data[
i] =
value *
s->lfe_scale;
263 if (chunk->
len >= 52)
265 if (chunk->
len >= 35)
286 int sf, sf_idx, ch, main_ch, freq;
290 for (sf = 0; sf < 1 << group; sf +=
diff ? 8 : 1) {
291 sf_idx = ((
s->framenum << group) + sf) & 31;
292 s->tonal_bounds[group][sf_idx][0] =
s->ntones;
295 for (freq = 1;; freq++) {
312 if (freq >> (5 - group) >
s->nsubbands * 4 - 6) {
321 +
s->limited_range - 2;
322 amp[main_ch] = main_amp <
AMP_MAX ? main_amp : 0;
326 for (ch = 0; ch <
s->nchannels_total; ch++) {
343 t->
x_freq = freq >> (5 - group);
344 t->
f_delt = (freq & ((1 << (5 - group)) - 1)) << group;
350 for (ch = 0; ch <
s->nchannels; ch++) {
352 t->
phs[ch] = 128 - phs[ch] * 32 +
shift;
357 s->tonal_bounds[group][sf_idx][1] =
s->ntones;
381 for (sb = 0; sb < 6; sb++)
387 for (group = 0; group < 5; group++) {
428 int i, sf, prev, next, dist;
437 for (sf = 0; sf < 7; sf += dist) {
457 next = prev + ((next + 1) >> 1);
459 next = prev - ( next >> 1);
465 scf[sf + 1] = prev + ((next - prev) >> 1);
467 scf[sf + 1] = prev - ((prev - next) >> 1);
472 scf[sf + 1] = prev + ( (next - prev) >> 2);
473 scf[sf + 2] = prev + ( (next - prev) >> 1);
474 scf[sf + 3] = prev + (((next - prev) * 3) >> 2);
476 scf[sf + 1] = prev - ( (prev - next) >> 2);
477 scf[sf + 2] = prev - ( (prev - next) >> 1);
478 scf[sf + 3] = prev - (((prev - next) * 3) >> 2);
483 for (
i = 1;
i < dist;
i++)
484 scf[sf +
i] = prev + (next - prev) *
i / dist;
512 int ch, sb, sf, nsubbands, ret;
523 for (sb = 2; sb < nsubbands; sb++) {
538 for (sb = 0; sb <
s->nsubbands - 4; sb++) {
541 if (sb + 4 <
s->min_mono_subband)
544 s->grid_3_avg[ch2][sb] =
s->grid_3_avg[ch1][sb];
563 nsubbands = (
s->nsubbands -
s->min_mono_subband + 3) / 4;
564 for (sb = 0; sb < nsubbands; sb++)
565 for (ch = ch1; ch <= ch2; ch++)
566 for (sf = 1; sf <= 4; sf++)
570 s->part_stereo_pres |= 1 << ch1;
580 int sb, nsubbands, ret;
584 for (sb = 2; sb < nsubbands; sb++) {
593 for (sb = 0; sb <
s->nsubbands - 4; sb++) {
594 if (sb + 4 >=
s->min_mono_subband) {
608 for (ch = ch1; ch <= ch2; ch++) {
609 if ((ch != ch1 && sb + 4 >=
s->min_mono_subband) !=
flag)
612 if (
s->grid_3_pres[ch] & (1U << sb))
615 for (
i = 0;
i < 8;
i++) {
622 s->grid_3_pres[ch] |= 1U << sb;
628 s->lbr_rand = 1103515245U *
s->lbr_rand + 12345U;
629 return s->lbr_rand *
s->sb_scf[sb];
637 float *samples =
s->time_samples[ch][sb];
638 int i, j,
code, nblocks, coding_method;
645 switch (quant_level) {
648 for (
i = 0;
i < nblocks;
i++, samples += 8) {
650 for (j = 0; j < 8; j++)
666 for (
i = 0;
i < nblocks;
i++, samples += 5) {
668 for (j = 0; j < 5; j++)
677 for (
i = 0;
i < nblocks;
i++, samples += 3) {
679 for (j = 0; j < 3; j++)
692 for (
i = 0;
i < nblocks;
i++)
706 s->ch_pres[ch] |= 1U << sb;
710 int start_sb,
int end_sb,
int flag)
712 int sb, sb_g3, sb_reorder, quant_level;
714 for (sb = start_sb; sb < end_sb; sb++) {
718 }
else if (
flag && sb < s->max_mono_subband) {
719 sb_reorder =
s->sb_indices[sb];
723 sb_reorder =
get_bits(&
s->gb,
s->limited_range + 3);
726 s->sb_indices[sb] = sb_reorder;
728 if (sb_reorder >=
s->nsubbands)
733 for (sb_g3 = 0; sb_g3 <
s->g3_avg_only_start_sb - 4; sb_g3++)
735 }
else if (sb < 12 && sb_reorder >= 4) {
743 if (!
flag || sb_reorder >=
s->max_mono_subband)
744 s->sec_ch_sbms[ch1 / 2][sb_reorder] =
get_bits(&
s->gb, 8);
745 if (
flag && sb_reorder >=
s->min_mono_subband)
746 s->sec_ch_lrms[ch1 / 2][sb_reorder] =
get_bits(&
s->gb, 8);
749 quant_level =
s->quant_levels[ch1 / 2][sb];
754 if (sb < s->max_mono_subband && sb_reorder >=
s->min_mono_subband) {
756 parse_ch(
s, ch1, sb_reorder, quant_level, 0);
758 parse_ch(
s, ch2, sb_reorder, quant_level, 1);
760 parse_ch(
s, ch1, sb_reorder, quant_level, 0);
762 parse_ch(
s, ch2, sb_reorder, quant_level, 0);
776 for (
i = 0;
i < 8;
i++) {
778 for (j = 0; j < (
i + 1) / 2; j++) {
779 float tmp1 =
coeff[ j ];
780 float tmp2 =
coeff[
i - j - 1];
781 coeff[ j ] = tmp1 + rc * tmp2;
782 coeff[
i - j - 1] = tmp2 + rc * tmp1;
790 int f =
s->framenum & 1;
791 int i, sb, ch, codes[16];
794 for (sb = start_sb; sb < end_sb; sb++) {
795 int ncodes = 8 * (1 + (sb < 2));
796 for (ch = ch1; ch <= ch2; ch++) {
799 for (
i = 0;
i < ncodes;
i++)
801 for (
i = 0;
i < ncodes / 8;
i++)
812 int sb, ch, ol, st, max_sb,
profile, ret;
831 for (sb = 0; sb <
s->nsubbands; sb++) {
832 int f = sb *
s->limited_rate /
s->nsubbands;
833 int a = 18000 / (12 *
f / 1000 + 100 + 40 * st) + 20 * ol;
835 quant_levels[sb] = 1;
837 quant_levels[sb] = 2;
839 quant_levels[sb] = 3;
841 quant_levels[sb] = 4;
843 quant_levels[sb] = 5;
847 for (sb = 0; sb < 8; sb++)
849 for (; sb <
s->nsubbands; sb++)
850 s->quant_levels[ch1 / 2][sb] = quant_levels[sb];
863 for (sb = 0; sb < 2; sb++)
864 for (ch = ch1; ch <= ch2; ch++)
872 int start_sb,
int end_sb,
int flag)
874 int i, j, sb, ch, nsubbands;
877 if (end_sb > nsubbands)
880 for (sb = start_sb; sb < end_sb; sb++) {
881 for (ch = ch1; ch <= ch2; ch++) {
882 uint8_t *g2_scf =
s->grid_2_scf[ch][sb];
886 memcpy(g2_scf,
s->grid_2_scf[ch1][sb], 64);
891 for (
i = 0;
i < 8;
i++, g2_scf += 8) {
893 memset(g2_scf, 0, 64 -
i * 8);
898 for (j = 0; j < 8; j++) {
904 memset(g2_scf, 0, 8);
922 if ((ret =
parse_ts(
s, ch1, ch2, 2, 4, 0)) < 0)
926 if ((ret =
parse_ts(
s, ch1, ch2, 4, 6, 0)) < 0)
941 if ((ret =
parse_ts(
s, ch1, ch2, 6,
s->max_mono_subband, 0)) < 0)
949 if ((ret =
parse_ts(
s, ch1, ch2,
s->min_mono_subband,
s->nsubbands, 1)) < 0)
956 double scale = (-1.0 / (1 << 17)) * sqrt(1 << (2 -
s->limited_range));
957 int i, br_per_ch =
s->bit_rate_scaled /
s->nchannels_total;
966 for (
i = 0;
i < 32 <<
s->freq_range;
i++)
969 if (br_per_ch < 14000)
971 else if (br_per_ch < 32000)
972 scale = (br_per_ch - 14000) * (1.0 / 120000) + 0.85;
976 scale *= 1.0 / INT_MAX;
978 for (
i = 0;
i <
s->nsubbands;
i++) {
982 s->sb_scf[
i] = (
i - 1) * 0.25 * 0.785 * scale;
984 s->sb_scf[
i] = 0.785 * scale;
987 s->lfe_scale = (16 <<
s->freq_range) * 0.0000078265894;
996 int nsamples = nchsamples *
s->nchannels *
s->nsubbands;
1006 for (ch = 0; ch <
s->nchannels; ch++) {
1007 for (sb = 0; sb <
s->nsubbands; sb++) {
1008 s->time_samples[ch][sb] = ptr;
1018 int old_rate =
s->sample_rate;
1019 int old_band_limit =
s->band_limit;
1020 int old_nchannels =
s->nchannels;
1022 unsigned int sr_code;
1025 sr_code = bytestream2_get_byte(gb);
1031 if (
s->sample_rate > 48000) {
1037 s->ch_mask = bytestream2_get_le16(gb);
1038 if (!(
s->ch_mask & 0x7)) {
1042 if ((
s->ch_mask & 0xfff0) && !(
s->warned & 1)) {
1048 version = bytestream2_get_le16(gb);
1049 if ((
version & 0xff00) != 0x0800) {
1055 s->flags = bytestream2_get_byte(gb);
1061 if (!(
s->warned & 2)) {
1069 bit_rate_hi = bytestream2_get_byte(gb);
1072 s->bit_rate_orig = bytestream2_get_le16(gb) | ((bit_rate_hi & 0x0F) << 16);
1075 s->bit_rate_scaled = bytestream2_get_le16(gb) | ((bit_rate_hi & 0xF0) << 12);
1101 if (
s->bit_rate_orig >= 44000 * (
s->nchannels_total + 2))
1103 else if (
s->bit_rate_orig >= 25000 * (
s->nchannels_total + 2))
1109 s->limited_rate =
s->sample_rate >>
s->band_limit;
1110 s->limited_range =
s->freq_range -
s->band_limit;
1111 if (
s->limited_range < 0) {
1116 s->nsubbands = 8 <<
s->limited_range;
1119 if (
s->g3_avg_only_start_sb >
s->nsubbands)
1120 s->g3_avg_only_start_sb =
s->nsubbands;
1122 s->min_mono_subband =
s->nsubbands * 2000 / (
s->limited_rate / 2);
1123 if (
s->min_mono_subband >
s->nsubbands)
1124 s->min_mono_subband =
s->nsubbands;
1126 s->max_mono_subband =
s->nsubbands * 14000 / (
s->limited_rate / 2);
1127 if (
s->max_mono_subband >
s->nsubbands)
1128 s->max_mono_subband =
s->nsubbands;
1131 if ((old_rate !=
s->sample_rate || old_band_limit !=
s->band_limit) &&
init_sample_rate(
s) < 0)
1150 s->nchannels_total += 2;
1157 if (old_rate !=
s->sample_rate
1158 || old_band_limit !=
s->band_limit
1159 || old_nchannels !=
s->nchannels) {
1182 int i, ch, sb, sf, ret, group, chunk_id, chunk_len;
1193 switch (bytestream2_get_byte(&gb)) {
1195 if (!
s->sample_rate) {
1212 chunk_id = bytestream2_get_byte(&gb);
1213 chunk_len = (chunk_id & 0x80) ? bytestream2_get_be16(&gb) : bytestream2_get_byte(&gb);
1224 switch (chunk_id & 0x7f) {
1227 int checksum = bytestream2_get_be16(&gb);
1228 uint16_t res = chunk_id;
1229 res += (chunk_len >> 8) & 0xff;
1230 res += chunk_len & 0xff;
1231 for (
i = 0;
i < chunk_len - 2;
i++)
1250 memset(
s->quant_levels, 0,
sizeof(
s->quant_levels));
1251 memset(
s->sb_indices, 0xff,
sizeof(
s->sb_indices));
1252 memset(
s->sec_ch_sbms, 0,
sizeof(
s->sec_ch_sbms));
1253 memset(
s->sec_ch_lrms, 0,
sizeof(
s->sec_ch_lrms));
1254 memset(
s->ch_pres, 0,
sizeof(
s->ch_pres));
1255 memset(
s->grid_1_scf, 0,
sizeof(
s->grid_1_scf));
1256 memset(
s->grid_2_scf, 0,
sizeof(
s->grid_2_scf));
1257 memset(
s->grid_3_avg, 0,
sizeof(
s->grid_3_avg));
1258 memset(
s->grid_3_scf, 0,
sizeof(
s->grid_3_scf));
1259 memset(
s->grid_3_pres, 0,
sizeof(
s->grid_3_pres));
1260 memset(
s->tonal_scf, 0,
sizeof(
s->tonal_scf));
1261 memset(
s->lfe_data, 0,
sizeof(
s->lfe_data));
1262 s->part_stereo_pres = 0;
1263 s->framenum = (
s->framenum + 1) & 31;
1265 for (ch = 0; ch <
s->nchannels; ch++) {
1266 for (sb = 0; sb <
s->nsubbands / 4; sb++) {
1267 s->part_stereo[ch][sb][0] =
s->part_stereo[ch][sb][4];
1268 s->part_stereo[ch][sb][4] = 16;
1272 memset(
s->lpc_coeff[
s->framenum & 1], 0,
sizeof(
s->lpc_coeff[0]));
1274 for (group = 0; group < 5; group++) {
1275 for (sf = 0; sf < 1 << group; sf++) {
1276 int sf_idx = ((
s->framenum << group) + sf) & 31;
1277 s->tonal_bounds[group][sf_idx][0] =
1278 s->tonal_bounds[group][sf_idx][1] =
s->ntones;
1284 chunk_id = bytestream2_get_byte(&gb);
1285 chunk_len = (chunk_id & 0x80) ? bytestream2_get_be16(&gb) : bytestream2_get_byte(&gb);
1297 chunk.lfe.len = chunk_len;
1298 chunk.lfe.data = gb.
buffer;
1304 chunk.tonal.id = chunk_id;
1305 chunk.tonal.len = chunk_len;
1306 chunk.tonal.data = gb.
buffer;
1315 chunk.tonal_grp[
i].id =
i;
1316 chunk.tonal_grp[
i].len = chunk_len;
1317 chunk.tonal_grp[
i].data = gb.
buffer;
1326 chunk.tonal_grp[
i].id =
i;
1327 chunk.tonal_grp[
i].len = chunk_len;
1328 chunk.tonal_grp[
i].data = gb.
buffer;
1335 chunk.grid1[
i].len = chunk_len;
1336 chunk.grid1[
i].data = gb.
buffer;
1343 chunk.hr_grid[
i].len = chunk_len;
1344 chunk.hr_grid[
i].data = gb.
buffer;
1351 chunk.ts1[
i].len = chunk_len;
1352 chunk.ts1[
i].data = gb.
buffer;
1359 chunk.ts2[
i].len = chunk_len;
1360 chunk.ts2[
i].data = gb.
buffer;
1372 for (
i = 0;
i < 5;
i++)
1375 for (
i = 0;
i < (
s->nchannels + 1) / 2;
i++) {
1377 int ch2 =
FFMIN(ch1 + 1,
s->nchannels - 1);
1386 if (!chunk.grid1[
i].len || !chunk.hr_grid[
i].len || !chunk.ts1[
i].len)
1409 for (ch = ch1; ch <= ch2; ch++) {
1410 for (sb = 0; sb <
s->nsubbands; sb++) {
1413 uint8_t *g1_scf_a =
s->grid_1_scf[ch][g1_sb ];
1414 uint8_t *g1_scf_b =
s->grid_1_scf[ch][g1_sb + 1];
1419 uint8_t *hr_scf =
s->high_res_scf[ch][sb];
1422 for (
i = 0;
i < 8;
i++) {
1423 int scf = w1 * g1_scf_a[
i] + w2 * g1_scf_b[
i];
1424 hr_scf[
i] = scf >> 7;
1427 int8_t *g3_scf =
s->grid_3_scf[ch][sb - 4];
1428 int g3_avg =
s->grid_3_avg[ch][sb - 4];
1430 for (
i = 0;
i < 8;
i++) {
1431 int scf = w1 * g1_scf_a[
i] + w2 * g1_scf_b[
i];
1432 hr_scf[
i] = (scf >> 7) - g3_avg - g3_scf[
i];
1444 int i, j, k, ch, sb;
1446 for (ch = ch1; ch <= ch2; ch++) {
1447 for (sb = 0; sb <
s->nsubbands; sb++) {
1448 float *samples =
s->time_samples[ch][sb];
1450 if (
s->ch_pres[ch] & (1U << sb))
1456 }
else if (sb < 10) {
1461 float accum[8] = { 0 };
1464 for (k = 2; k < 6; k++) {
1465 float *other = &
s->time_samples[ch][k][
i * 8];
1466 for (j = 0; j < 8; j++)
1467 accum[j] +=
fabs(other[j]);
1470 for (j = 0; j < 8; j++)
1471 samples[j] = (accum[j] * 0.25f + 0.5f) *
lbr_rand(
s, sb);
1482 for (
i = 0;
i < nsamples;
i++) {
1484 for (j = 0; j < 8; j++)
1485 res +=
coeff[j] * samples[
i - j - 1];
1492 int f =
s->framenum & 1;
1495 for (ch = ch1; ch <= ch2; ch++) {
1496 float *samples =
s->time_samples[ch][sb];
1498 if (!(
s->ch_pres[ch] & (1U << sb)))
1502 predict(samples,
s->lpc_coeff[
f^1][ch][sb][1], 16);
1503 predict(samples + 16,
s->lpc_coeff[
f ][ch][sb][0], 64);
1504 predict(samples + 80,
s->lpc_coeff[
f ][ch][sb][1], 48);
1506 predict(samples,
s->lpc_coeff[
f^1][ch][sb][0], 16);
1507 predict(samples + 16,
s->lpc_coeff[
f ][ch][sb][0], 112);
1516 for (sb = 0; sb <
s->nsubbands; sb++) {
1518 for (ch = ch1; ch <= ch2; ch++) {
1519 float *samples =
s->time_samples[ch][sb];
1520 uint8_t *hr_scf =
s->high_res_scf[ch][sb];
1523 unsigned int scf = hr_scf[
i];
1526 for (j = 0; j < 16; j++)
1532 unsigned int scf = hr_scf[
i / 8] - g2_scf[
i];
1543 float *samples_l =
s->time_samples[ch1][sb];
1544 float *samples_r =
s->time_samples[ch2][sb];
1545 int ch2_pres =
s->ch_pres[ch2] & (1U << sb);
1548 int sbms = (
s->sec_ch_sbms[ch1 / 2][sb] >>
i) & 1;
1549 int lrms = (
s->sec_ch_lrms[ch1 / 2][sb] >>
i) & 1;
1551 if (sb >=
s->min_mono_subband) {
1552 if (lrms && ch2_pres) {
1554 for (j = 0; j < 16; j++) {
1555 float tmp = samples_l[j];
1556 samples_l[j] = samples_r[j];
1557 samples_r[j] = -
tmp;
1560 for (j = 0; j < 16; j++) {
1561 float tmp = samples_l[j];
1562 samples_l[j] = samples_r[j];
1566 }
else if (!ch2_pres) {
1567 if (sbms && (
s->part_stereo_pres & (1 << ch1))) {
1568 for (j = 0; j < 16; j++)
1569 samples_r[j] = -samples_l[j];
1571 for (j = 0; j < 16; j++)
1572 samples_r[j] = samples_l[j];
1575 }
else if (sbms && ch2_pres) {
1576 for (j = 0; j < 16; j++) {
1577 float tmp = samples_l[j];
1578 samples_l[j] = (
tmp + samples_r[j]) * 0.5f;
1579 samples_r[j] = (
tmp - samples_r[j]) * 0.5f;
1601 for (ch = ch1; ch <= ch2; ch++) {
1602 for (sb =
s->min_mono_subband; sb < s->nsubbands; sb++) {
1603 uint8_t *pt_st =
s->part_stereo[ch][(sb -
s->min_mono_subband) / 4];
1604 float *samples =
s->time_samples[ch][sb];
1606 if (
s->ch_pres[ch2] & (1U << sb))
1609 for (sf = 1; sf <= 4; sf++, samples += 32) {
1613 for (
i = 0;
i < 32;
i++)
1614 samples[
i] *= (32 -
i) * prev +
i * next;
1624 int group,
int group_sf,
int synth_idx)
1626 int i, start, count;
1631 start =
s->tonal_bounds[group][group_sf][0];
1632 count = (
s->tonal_bounds[group][group_sf][1] - start) & (
DCA_LBR_TONES - 1);
1634 for (
i = 0;
i < count;
i++) {
1648 values[3] += cf[0] * -
s;
1649 values[2] += cf[1] *
c;
1650 values[1] += cf[2] *
s;
1651 values[0] += cf[3] * -
c;
1654 values[2] += cf[0] * -
s;
1655 values[1] += cf[1] *
c;
1656 values[0] += cf[2] *
s;
1659 values[1] += cf[0] * -
s;
1660 values[0] += cf[1] *
c;
1663 values[0] += cf[0] * -
s;
1667 values[x_freq - 5] += cf[ 0] * -
s;
1668 p4: values[x_freq - 4] += cf[ 1] *
c;
1669 p3: values[x_freq - 3] += cf[ 2] *
s;
1670 p2: values[x_freq - 2] += cf[ 3] * -
c;
1671 p1: values[x_freq - 1] += cf[ 4] * -
s;
1672 p0: values[x_freq ] += cf[ 5] *
c;
1673 values[x_freq + 1] += cf[ 6] *
s;
1674 values[x_freq + 2] += cf[ 7] * -
c;
1675 values[x_freq + 3] += cf[ 8] * -
s;
1676 values[x_freq + 4] += cf[ 9] *
c;
1677 values[x_freq + 5] += cf[10] *
s;
1692 for (group = 0; group < 5; group++) {
1693 int group_sf = (
s->framenum << group) + ((sf - 22) >> (5 - group));
1694 int synth_idx = ((((sf - 22) & 31) << group) & 31) + (1 << group) - 1;
1696 synth_tones(
s, ch, values, group, (group_sf - 1) & 31, 30 - synth_idx);
1697 synth_tones(
s, ch, values, group, (group_sf ) & 31, synth_idx);
1705 int sf, sb, nsubbands =
s->nsubbands, noutsubbands = 8 <<
s->freq_range;
1708 if (nsubbands < noutsubbands)
1709 memset(values[nsubbands], 0, (noutsubbands - nsubbands) *
sizeof(values[0]));
1713 s->dcadsp->lbr_bank(values,
s->time_samples[ch],
1718 s->imdct.imdct_calc(&
s->imdct, result[0], values[0]);
1721 s->fdsp->vector_fmul_add(output, result[0],
s->window,
1722 s->history[ch], noutsubbands * 4);
1723 s->fdsp->vector_fmul_reverse(
s->history[ch], result[noutsubbands],
1724 s->window, noutsubbands * 4);
1725 output += noutsubbands * 4;
1729 for (sb = 0; sb < nsubbands; sb++) {
1738 int i, ret, nchannels, ch_conf = (
s->ch_mask & 0x7) - 1;
1739 const int8_t *reorder;
1762 for (
i = 0;
i < (
s->nchannels + 1) / 2;
i++) {
1764 int ch2 =
FFMIN(ch1 + 1,
s->nchannels - 1);
1772 if (ch1 != ch2 && (
s->part_stereo_pres & (1 << ch1)))
1775 if (ch1 < nchannels)
1778 if (ch1 != ch2 && ch2 < nchannels)
1786 s->lfe_history, 16 <<
s->freq_range);
1799 if (!
s->sample_rate)
1803 memset(
s->part_stereo, 16,
sizeof(
s->part_stereo));
1804 memset(
s->lpc_coeff, 0,
sizeof(
s->lpc_coeff));
1805 memset(
s->history, 0,
sizeof(
s->history));
1806 memset(
s->tonal_bounds, 0,
sizeof(
s->tonal_bounds));
1807 memset(
s->lfe_history, 0,
sizeof(
s->lfe_history));
1811 for (ch = 0; ch <
s->nchannels; ch++) {
1812 for (sb = 0; sb <
s->nsubbands; sb++) {
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
#define AV_EF_EXPLODE
abort decoding on minor error detection
#define FF_PROFILE_DTS_EXPRESS
#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 av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
audio channel layout utility functions
static __device__ float fabs(float a)
const uint8_t ff_dca_freq_ranges[16]
const uint32_t ff_dca_sampling_freqs[16]
#define DCA_SPEAKER_LAYOUT_STEREO
static int ff_dca_count_chs_for_mask(unsigned int mask)
Return number of individual channels in DCASpeakerPair mask.
static void random_ts(DCALbrDecoder *s, int ch1, int ch2)
Fill unallocated subbands with randomness.
static int alloc_sample_buffer(DCALbrDecoder *s)
static int parse_grid_1_sec_ch(DCALbrDecoder *s, int ch2)
int ff_dca_lbr_filter_frame(DCALbrDecoder *s, AVFrame *frame)
static void filter_ts(DCALbrDecoder *s, int ch1, int ch2)
static void decode_grid(DCALbrDecoder *s, int ch1, int ch2)
Reconstruct high-frequency resolution grid from first and third grids.
static void predict(float *samples, const float *coeff, int nsamples)
static const int8_t channel_reorder_lfe[7][5]
static int parse_decoder_init(DCALbrDecoder *s, GetByteContext *gb)
static void transform_channel(DCALbrDecoder *s, int ch, float *output)
static int parse_vlc(GetBitContext *s, VLC *vlc, int max_depth)
static int parse_lfe_chunk(DCALbrDecoder *s, LBRChunk *chunk)
static const uint16_t channel_layouts[7]
static void decode_part_stereo(DCALbrDecoder *s, int ch1, int ch2)
Modulate by interpolated partial stereo coefficients.
static int parse_tonal_chunk(DCALbrDecoder *s, LBRChunk *chunk)
static int parse_tonal(DCALbrDecoder *s, int group)
static const uint8_t channel_counts[7]
int ff_dca_lbr_parse(DCALbrDecoder *s, uint8_t *data, DCAExssAsset *asset)
static const uint8_t lfe_index[7]
static int ensure_bits(GetBitContext *s, int n)
Check point to ensure that enough bits are left.
static av_cold void init_tables(void)
static int parse_high_res_grid(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
static int parse_ts1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
static void synth_lpc(DCALbrDecoder *s, int ch1, int ch2, int sb)
av_cold int ff_dca_lbr_init(DCALbrDecoder *s)
@ LBR_FLAG_BAND_LIMIT_1_4
@ LBR_FLAG_BAND_LIMIT_1_2
@ LBR_FLAG_BAND_LIMIT_MASK
@ LBR_FLAG_BAND_LIMIT_2_3
@ LBR_FLAG_BAND_LIMIT_1_8
@ LBR_FLAG_BAND_LIMIT_1_3
@ LBR_FLAG_BAND_LIMIT_NONE
static int parse_tonal_group(DCALbrDecoder *s, LBRChunk *chunk)
static float cos_tab[256]
static float lbr_rand(DCALbrDecoder *s, int sb)
static void synth_tones(DCALbrDecoder *s, int ch, float *values, int group, int group_sf, int synth_idx)
Synthesise tones in the given group for the given tonal subframe.
static int parse_ts2_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
static void parse_grid_3(DCALbrDecoder *s, int ch1, int ch2, int sb, int flag)
static int parse_st_code(GetBitContext *s, int min_v)
static int init_sample_rate(DCALbrDecoder *s)
static int parse_grid_1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
av_cold void ff_dca_lbr_close(DCALbrDecoder *s)
static void parse_ch(DCALbrDecoder *s, int ch, int sb, int quant_level, int flag)
Parse time samples for one subband, filling truncated samples with randomness.
static int parse_lfe_16(DCALbrDecoder *s)
static int parse_lpc(DCALbrDecoder *s, int ch1, int ch2, int start_sb, int end_sb)
static const int8_t channel_reorder_nolfe[7][5]
av_cold void ff_dca_lbr_flush(DCALbrDecoder *s)
static void convert_lpc(float *coeff, const int *codes)
Convert from reflection coefficients to direct form coefficients.
@ LBR_CHUNK_TONAL_SCF_GRP_3
@ LBR_CHUNK_RES_TS_1_LAST
@ LBR_CHUNK_RES_GRID_LR_LAST
@ LBR_CHUNK_TONAL_SCF_GRP_2
@ LBR_CHUNK_RES_GRID_HR_LAST
@ LBR_CHUNK_TONAL_SCF_GRP_1
@ LBR_CHUNK_RES_TS_2_LAST
@ LBR_CHUNK_TONAL_SCF_GRP_5
@ LBR_CHUNK_FRAME_NO_CSUM
@ LBR_CHUNK_TONAL_SCF_GRP_4
static int parse_ts(DCALbrDecoder *s, int ch1, int ch2, int start_sb, int end_sb, int flag)
static int parse_grid_2(DCALbrDecoder *s, int ch1, int ch2, int start_sb, int end_sb, int flag)
static int parse_scale_factors(DCALbrDecoder *s, uint8_t *scf)
static void base_func_synth(DCALbrDecoder *s, int ch, float *values, int sf)
Synthesise all tones in all groups for the given residual subframe.
static int parse_lfe_24(DCALbrDecoder *s)
@ DCA_LBR_HEADER_SYNC_ONLY
@ DCA_LBR_HEADER_DECODER_INIT
#define DCA_LBR_CHANNELS_TOTAL
#define DCA_LBR_TIME_SAMPLES
#define DCA_LBR_TIME_HISTORY
const float ff_dca_lfe_step_size_24[144]
const float ff_dca_rsd_level_5[5]
const uint8_t ff_dca_scf_to_grid_2[32]
const int8_t ff_dca_lfe_delta_index_24[32]
const float ff_dca_rsd_level_8[8]
const float ff_dca_rsd_level_2b[2]
const uint8_t ff_dca_freq_to_sb[32]
const float ff_dca_bank_coeff[10]
const float ff_dca_rsd_level_16[16]
const float ff_dca_quant_amp[57]
const float ff_dca_corr_cf[32][11]
const float ff_dca_rsd_level_2a[2]
const float ff_dca_lfe_step_size_16[101]
const int8_t ff_dca_lfe_delta_index_16[8]
const uint8_t ff_dca_grid_1_to_scf[11]
const uint16_t ff_dca_fst_amp[44]
const uint8_t ff_dca_grid_2_to_scf[3]
const float ff_dca_st_coeff[34]
const uint8_t ff_dca_rsd_pack_3_in_7[128][3]
const float ff_dca_long_window[128]
const uint8_t ff_dca_grid_1_weights[12][32]
const float ff_dca_rsd_level_3[3]
const uint8_t ff_dca_sb_reorder[8][8]
const uint16_t ff_dca_avg_g3_freqs[3]
const float ff_dca_lfe_iir[5][4]
const uint8_t ff_dca_scf_to_grid_1[32]
const uint16_t ff_dca_rsd_pack_5_in_8[256]
const float ff_dca_synth_env[32]
const int8_t ff_dca_ph0_shift[8]
VLC ff_dca_vlc_fst_rsd_amp
VLC ff_dca_vlc_tnl_grp[5]
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
static int get_bits_left(GetBitContext *gb)
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
static unsigned int get_bits1(GetBitContext *s)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
#define AV_CH_LAYOUT_5POINT0
#define AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_SURROUND
#define AV_CH_LAYOUT_STEREO
@ AV_MATRIX_ENCODING_NONE
#define AV_CH_FRONT_CENTER
#define AV_CH_LOW_FREQUENCY
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size)
Allocate and clear a buffer, reusing the given one if large enough.
@ AV_SAMPLE_FMT_FLTP
float, planar
int ff_side_data_update_matrix_encoding(AVFrame *frame, enum AVMatrixEncoding matrix_encoding)
Add or update AV_FRAME_DATA_MATRIXENCODING side data.
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
#define LOCAL_ALIGNED_32(t, v,...)
#define FF_ARRAY_ELEMS(a)
static int shift(int a, int b)
main external API structure.
enum AVSampleFormat sample_fmt
audio sample format
int64_t bit_rate
the average bitrate
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
int sample_rate
samples per second
int channels
number of audio channels
uint64_t channel_layout
Audio channel layout.
This structure describes decoded (raw) audio or video data.
int nb_samples
number of audio samples (per channel) described by this frame
uint8_t ** extended_data
pointers to the data planes/channels.
int request_channel_layout
Converted from avctx.request_channel_layout.
int lbr_offset
Offset to LBR component from start of substream.
int lbr_size
Size of LBR component in extension substream.
uint8_t amp[DCA_LBR_CHANNELS]
Per-channel amplitude.
uint8_t phs[DCA_LBR_CHANNELS]
Per-channel phase.
uint8_t f_delt
Difference between original and center frequency.
uint8_t ph_rot
Phase rotation.
uint8_t x_freq
Spectral line offset.
VLC_TYPE(* table)[2]
code, bits
static volatile int checksum
static const double coeff[2][5]
static av_always_inline int diff(const uint32_t a, const uint32_t b)