Go to the documentation of this file.
34 return (v >> 1) ^ -(v & 1);
46 return (v >> 1) ^ -(v & 1);
79 int i, j, *coeff_ptr =
c->dmix_coeff;
81 for (
i = 0;
i < m;
i++) {
86 if (!
c->primary_chset) {
88 sign = (
code >> 8) - 1;
96 c->dmix_scale[
i] = (
scale ^ sign) - sign;
97 c->dmix_scale_inv[
i] = (scale_inv ^ sign) - sign;
101 for (j = 0; j <
c->nchannels; j++) {
103 sign = (
code >> 8) - 1;
110 if (!
c->primary_chset)
113 *coeff_ptr++ = (
coeff ^ sign) - sign;
143 c->residual_encode =
get_bits(&
s->gb,
c->nchannels);
150 if (
c->storage_bit_res != 16 &&
c->storage_bit_res != 20 &&
c->storage_bit_res != 24) {
155 if (
c->pcm_bit_res >
c->storage_bit_res) {
156 av_log(
s->avctx,
AV_LOG_ERROR,
"Invalid PCM bit resolution for XLL channel set (%d > %d)\n",
c->pcm_bit_res,
c->storage_bit_res);
162 if (
c->freq > 192000) {
182 if (
c->primary_chset != (
c == p)) {
191 c->dmix_embedded =
c->dmix_coeffs_present &&
get_bits1(&
s->gb);
194 if (
c->dmix_coeffs_present &&
c->primary_chset) {
204 if (!
c->hier_chset &&
s->nchsets != 1) {
227 for (
i = 0, j = 0;
i <
s->ch_mask_nbits;
i++)
228 if (
c->ch_mask & (1
U <<
i))
229 c->ch_remap[j++] =
i;
232 if (
c->nchannels != 2 ||
s->nchsets != 1 ||
get_bits1(&
s->gb)) {
238 c->primary_chset = 1;
239 c->dmix_coeffs_present = 0;
240 c->dmix_embedded = 0;
247 if (
c->freq > 96000) {
260 c->freq >>=
c->nfreqbands - 1;
271 if (
c->storage_bit_res > 16)
273 else if (
c->storage_bit_res > 8)
279 if ((
s->nchsets > 1 ||
c->nfreqbands > 1) &&
c->nabits < 5)
282 for (band = 0,
b =
c->bands; band < c->nfreqbands; band++,
b++) {
284 if ((
b->decor_enabled =
get_bits1(&
s->gb)) &&
c->nchannels > 1) {
288 for (
i = 0;
i <
c->nchannels;
i++) {
290 if (
b->orig_order[
i] >=
c->nchannels) {
297 for (
i = 0;
i <
c->nchannels / 2;
i++)
300 for (
i = 0;
i <
c->nchannels;
i++)
301 b->orig_order[
i] =
i;
302 for (
i = 0;
i <
c->nchannels / 2;
i++)
303 b->decor_coeff[
i] = 0;
307 b->highest_pred_order = 0;
308 for (
i = 0;
i <
c->nchannels;
i++) {
310 if (
b->adapt_pred_order[
i] >
b->highest_pred_order)
311 b->highest_pred_order =
b->adapt_pred_order[
i];
313 if (
b->highest_pred_order >
s->nsegsamples) {
319 for (
i = 0;
i <
c->nchannels;
i++)
320 b->fixed_pred_order[
i] =
b->adapt_pred_order[
i] ? 0 :
get_bits(&
s->gb, 2);
323 for (
i = 0;
i <
c->nchannels;
i++) {
324 for (j = 0; j <
b->adapt_pred_order[
i]; j++) {
338 b->dmix_embedded =
c->dmix_embedded && (band == 0 ||
get_bits1(&
s->gb));
341 if ((band == 0 &&
s->scalable_lsbs) || (band != 0 &&
get_bits1(&
s->gb))) {
344 if (
b->lsb_section_size < 0 ||
b->lsb_section_size >
s->frame_size) {
350 if (
b->lsb_section_size && (
s->band_crc_present > 2 ||
351 (band == 0 &&
s->band_crc_present > 1)))
352 b->lsb_section_size += 2;
355 for (
i = 0;
i <
c->nchannels;
i++) {
357 if (
b->nscalablelsbs[
i] && !
b->lsb_section_size) {
363 b->lsb_section_size = 0;
364 for (
i = 0;
i <
c->nchannels;
i++)
365 b->nscalablelsbs[
i] = 0;
369 if ((band == 0 &&
s->scalable_lsbs) || (band != 0 &&
get_bits1(&
s->gb))) {
371 for (
i = 0;
i <
c->nchannels;
i++)
374 for (
i = 0;
i <
c->nchannels;
i++)
375 b->bit_width_adjust[
i] = 0;
393 int nchsamples =
s->nframesamples + ndecisamples;
394 int i, j, nsamples = nchsamples *
c->nchannels *
c->nfreqbands;
399 if (!
c->sample_buffer[0])
402 ptr =
c->sample_buffer[0] + ndecisamples;
403 for (
i = 0;
i <
c->nfreqbands;
i++) {
404 for (j = 0; j <
c->nchannels; j++) {
405 c->bands[
i].msb_sample_buffer[j] = ptr;
415 int i, j, nsamples = 0;
419 for (
i = 0;
i <
c->nfreqbands;
i++)
420 if (
c->bands[
i].lsb_section_size)
421 nsamples +=
s->nframesamples *
c->nchannels;
427 if (!
c->sample_buffer[1])
430 ptr =
c->sample_buffer[1];
431 for (
i = 0;
i <
c->nfreqbands;
i++) {
432 if (
c->bands[
i].lsb_section_size) {
433 for (j = 0; j <
c->nchannels; j++) {
434 c->bands[
i].lsb_sample_buffer[j] = ptr;
435 ptr +=
s->nframesamples;
438 for (j = 0; j <
c->nchannels; j++)
439 c->bands[
i].lsb_sample_buffer[j] =
NULL;
459 k =
c->seg_common ? 1 :
c->nchannels;
462 for (
i = 0;
i < k;
i++) {
468 if (!
c->seg_common &&
c->rice_code_flag[
i] &&
get_bits1(&
s->gb))
470 c->bitalloc_hybrid_linear[
i] =
get_bits(&
s->gb,
c->nabits) + 1;
473 c->bitalloc_hybrid_linear[
i] = 0;
477 for (
i = 0;
i < k;
i++) {
483 if (!
c->rice_code_flag[
i] &&
c->bitalloc_part_a[
i])
484 c->bitalloc_part_a[
i]++;
487 c->nsamples_part_a[
i] =
b->adapt_pred_order[
i];
489 c->nsamples_part_a[
i] =
b->highest_pred_order;
491 c->bitalloc_part_a[
i] = 0;
492 c->nsamples_part_a[
i] = 0;
499 if (!
c->rice_code_flag[
i] &&
c->bitalloc_part_b[
i])
500 c->bitalloc_part_b[
i]++;
505 for (
i = 0;
i <
c->nchannels;
i++) {
510 k =
c->seg_common ? 0 :
i;
513 part_a =
b->msb_sample_buffer[
i] + seg *
s->nsegsamples;
514 part_b = part_a +
c->nsamples_part_a[k];
515 nsamples_part_b =
s->nsegsamples -
c->nsamples_part_a[k];
520 if (!
c->rice_code_flag[k]) {
524 c->bitalloc_part_a[k]);
528 c->bitalloc_part_b[k]);
533 c->bitalloc_part_a[k]);
535 if (
c->bitalloc_hybrid_linear[k]) {
538 int nisosamples =
get_bits(&
s->gb,
s->nsegsamples_log2);
541 memset(part_b, 0,
sizeof(*part_b) * nsamples_part_b);
544 for (j = 0; j < nisosamples; j++) {
545 int loc =
get_bits(&
s->gb,
s->nsegsamples_log2);
546 if (loc >= nsamples_part_b) {
554 for (j = 0; j < nsamples_part_b; j++) {
556 part_b[j] =
get_linear(&
s->gb,
c->bitalloc_hybrid_linear[k]);
558 part_b[j] =
get_rice(&
s->gb,
c->bitalloc_part_b[k]);
569 if (seg == 0 && band == 1) {
571 for (
i = 0;
i <
c->nchannels;
i++)
577 if (
b->lsb_section_size) {
585 for (
i = 0;
i <
c->nchannels;
i++) {
586 if (
b->nscalablelsbs[
i]) {
588 b->lsb_sample_buffer[
i] + seg *
s->nsegsamples,
589 s->nsegsamples,
b->nscalablelsbs[
i]);
610 nsamples =
s->nframesamples;
613 nsamples =
s->nsegsamples;
616 for (
i = 0;
i <
c->nchannels;
i++) {
617 memset(
b->msb_sample_buffer[
i] +
offset, 0, nsamples *
sizeof(
int32_t));
618 if (
b->lsb_section_size)
619 memset(
b->lsb_sample_buffer[
i] +
offset, 0, nsamples *
sizeof(
int32_t));
622 if (seg <= 0 && band)
623 memset(
c->deci_history, 0,
sizeof(
c->deci_history));
626 memset(
b->nscalablelsbs, 0,
sizeof(
b->nscalablelsbs));
627 memset(
b->bit_width_adjust, 0,
sizeof(
b->bit_width_adjust));
634 int nsamples =
s->nframesamples;
638 for (
i = 0;
i <
c->nchannels;
i++) {
640 int order =
b->adapt_pred_order[
i];
644 for (j = 0; j < order; j++) {
645 int rc =
b->adapt_refl_coeff[
i][j];
646 for (k = 0; k < (j + 1) / 2; k++) {
647 int tmp1 =
coeff[ k ];
648 int tmp2 =
coeff[j - k - 1];
655 for (j = 0; j < nsamples - order; j++) {
657 for (k = 0; k < order; k++)
663 for (j = 0; j <
b->fixed_pred_order[
i]; j++)
664 for (k = 1; k < nsamples; k++)
665 buf[k] += (
unsigned)buf[k - 1];
670 if (
b->decor_enabled) {
673 for (
i = 0;
i <
c->nchannels / 2;
i++) {
676 s->dcadsp->decor(
b->msb_sample_buffer[
i * 2 + 1],
677 b->msb_sample_buffer[
i * 2 ],
683 for (
i = 0;
i <
c->nchannels;
i++)
684 tmp[
i] =
b->msb_sample_buffer[
i];
686 for (
i = 0;
i <
c->nchannels;
i++)
687 b->msb_sample_buffer[
b->orig_order[
i]] =
tmp[
i];
691 if (
c->nfreqbands == 1)
692 for (
i = 0;
i <
c->nchannels;
i++)
693 s->output_samples[
c->ch_remap[
i]] =
b->msb_sample_buffer[
i];
698 int adj =
c->bands[band].bit_width_adjust[ch];
699 int shift =
c->bands[band].nscalablelsbs[ch];
701 if (
s->fixed_lsb_width)
702 shift =
s->fixed_lsb_width;
703 else if (
shift && adj)
714 int n, ch, nsamples =
s->nframesamples;
716 for (ch = 0; ch <
c->nchannels; ch++) {
719 int32_t *msb =
b->msb_sample_buffer[ch];
720 if (
b->nscalablelsbs[ch]) {
721 int32_t *lsb =
b->lsb_sample_buffer[ch];
722 int adj =
b->bit_width_adjust[ch];
723 for (n = 0; n < nsamples; n++)
724 msb[n] = msb[n] * (
SUINT)(1 <<
shift) + (lsb[n] << adj);
726 for (n = 0; n < nsamples; n++)
735 int ch, nsamples =
s->nframesamples;
742 2 * nsamples *
c->nchannels *
sizeof(
int32_t));
743 if (!
c->sample_buffer[2])
747 ptr =
c->sample_buffer[2];
748 for (ch = 0; ch <
c->nchannels; ch++) {
749 int32_t *band0 =
c->bands[0].msb_sample_buffer[ch];
750 int32_t *band1 =
c->bands[1].msb_sample_buffer[ch];
754 c->deci_history[ch],
sizeof(
c->deci_history[0]));
757 s->dcadsp->assemble_freq_bands(ptr, band0, band1,
762 s->output_samples[
c->ch_remap[ch]] = ptr;
771 int stream_ver, header_size, frame_size_nbits, nframesegs_log2;
781 if (stream_ver > 1) {
796 frame_size_nbits =
get_bits(&
s->gb, 5) + 1;
815 s->nframesegs = 1 << nframesegs_log2;
816 if (
s->nframesegs > 1024) {
825 if (!
s->nsegsamples_log2) {
829 s->nsegsamples = 1 <<
s->nsegsamples_log2;
830 if (
s->nsegsamples > 512) {
836 s->nframesamples_log2 =
s->nsegsamples_log2 + nframesegs_log2;
837 s->nframesamples = 1 <<
s->nframesamples_log2;
838 if (
s->nframesamples > 65536) {
860 if (
s->scalable_lsbs)
863 s->fixed_lsb_width = 0;
878 return !
c->primary_chset &&
c->dmix_embedded &&
c->hier_chset;
884 while (++c < &s->chset[
s->nchsets])
893 int i, j, *coeff_ptr =
c->dmix_coeff;
895 for (
i = 0;
i <
c->hier_ofs;
i++) {
899 c->dmix_scale_inv[
i] =
mul16(
c->dmix_scale_inv[
i], scale_inv);
900 for (j = 0; j <
c->nchannels; j++) {
917 for (
i = 0,
c =
s->chset; i < s->nchsets;
i++,
c++) {
918 c->hier_ofs =
s->nchannels;
921 if (
c->nfreqbands >
s->nfreqbands)
922 s->nfreqbands =
c->nfreqbands;
924 s->nchannels +=
c->nchannels;
925 if (
c->residual_encode != (1 <<
c->nchannels) - 1)
930 for (
i =
s->nchsets - 1,
c = &
s->chset[
i];
i > 0;
i--,
c--) {
941 s->nactivechsets = 1;
945 s->nactivechsets = (
s->chset[0].nchannels < 5 &&
s->nchsets > 1) ? 2 : 1;
948 s->nactivechsets =
s->nchsets;
957 int chs, seg, band, navi_nb, navi_pos, *navi_ptr;
961 navi_nb =
s->nfreqbands *
s->nframesegs *
s->nchsets;
962 if (navi_nb > 1024) {
975 for (band = 0; band <
s->nfreqbands; band++) {
976 for (seg = 0; seg <
s->nframesegs; seg++) {
977 for (chs = 0,
c =
s->chset; chs < s->nchsets; chs++,
c++) {
979 if (
c->nfreqbands > band) {
981 if (size < 0 || size >=
s->frame_size) {
1008 int ret, chs, seg, band, navi_pos, *navi_ptr;
1011 for (chs = 0,
c =
s->chset; chs < s->nactivechsets; chs++,
c++) {
1020 for (band = 0; band <
s->nfreqbands; band++) {
1021 for (seg = 0; seg <
s->nframesegs; seg++) {
1022 for (chs = 0,
c =
s->chset; chs < s->nchsets; chs++,
c++) {
1023 if (
c->nfreqbands > band) {
1024 navi_pos += *navi_ptr * 8;
1025 if (navi_pos >
s->gb.size_in_bits) {
1029 if (chs < s->nactivechsets &&
1061 unsigned int extradata_syncword;
1069 s->x_syncword_present = 1;
1071 s->x_imax_syncword_present = 1;
1097 s->pbr_length =
size;
1098 s->pbr_delay = delay;
1129 if (
s->frame_size >
size)
1133 if (
s->frame_size <
size)
1149 memcpy(
s->pbr_buffer +
s->pbr_length,
data,
size);
1150 s->pbr_length +=
size;
1153 if (
s->pbr_delay > 0 && --
s->pbr_delay)
1159 if (
s->frame_size >
s->pbr_length) {
1164 if (
s->frame_size ==
s->pbr_length) {
1168 s->pbr_length -=
s->frame_size;
1169 memmove(
s->pbr_buffer,
s->pbr_buffer +
s->frame_size,
s->pbr_length);
1200 int i, j, k, nchannels = 0, *coeff_ptr = o->
dmix_coeff;
1203 for (
i = 0,
c =
s->chset; i < s->nactivechsets;
i++,
c++) {
1208 for (j = 0; j <
c->nchannels; j++) {
1210 int coeff = *coeff_ptr++;
1212 s->dcadsp->dmix_sub(
c->bands[band].msb_sample_buffer[j],
1214 coeff,
s->nframesamples);
1216 s->dcadsp->dmix_sub(
c->deci_history[j],
1223 nchannels +=
c->nchannels;
1231 int i, j, nchannels = 0;
1234 for (
i = 0,
c =
s->chset; i < s->nactivechsets;
i++,
c++) {
1239 for (j = 0; j <
c->nchannels; j++) {
1241 if (
scale != (1 << 15)) {
1242 s->dcadsp->dmix_scale(
c->bands[band].msb_sample_buffer[j],
1243 scale,
s->nframesamples);
1245 s->dcadsp->dmix_scale(
c->deci_history[j],
1262 for (band = 0; band <
c->nfreqbands; band++)
1265 for (ch = 0; ch <
c->nchannels; ch++) {
1266 if (!(
c->residual_encode & (1 << ch)))
1270 c->residual_encode &= ~(1 << ch);
1277 int ch, nsamples =
s->nframesamples;
1302 for (ch = 0; ch <
c->nchannels; ch++) {
1306 if (
c->residual_encode & (1 << ch))
1312 av_log(
s->avctx,
AV_LOG_WARNING,
"Residual encoded channel (%d) references unavailable core channel\n",
c->ch_remap[ch]);
1326 dst =
c->bands[0].msb_sample_buffer[ch];
1330 for (n = 0; n < nsamples; n++)
1334 for (n = 0; n < nsamples; n++)
1349 int i, j, k,
ret,
shift, nsamples, request_mask;
1354 for (
i = 0,
c =
s->chset; i < s->nchsets;
i++,
c++) {
1355 if (i < s->nactivechsets)
1358 if (!
c->primary_chset)
1359 c->dmix_embedded = 0;
1362 s->scalable_lsbs = 0;
1363 s->fixed_lsb_width = 0;
1368 for (
i = 0,
c =
s->chset; i < s->nactivechsets;
i++,
c++) {
1371 if (
c->residual_encode != (1 <<
c->nchannels) - 1
1375 if (
s->scalable_lsbs)
1378 if (
c->nfreqbands > 1) {
1383 s->output_mask |=
c->ch_mask;
1387 for (
i = 1,
c = &
s->chset[1]; i < s->nchsets;
i++,
c++) {
1391 if (
i >=
s->nactivechsets) {
1392 for (j = 0; j <
c->nfreqbands; j++)
1393 if (
c->bands[j].dmix_embedded)
1398 for (j = 0; j <
c->nfreqbands; j++)
1399 if (
c->bands[j].dmix_embedded)
1404 if (
s->nfreqbands > 1) {
1405 for (
i = 0;
i <
s->nactivechsets;
i++)
1429 request_mask =
s->output_mask;
1449 if (
s->x_imax_syncword_present) {
1451 }
else if (
s->x_syncword_present) {
1460 frame->nb_samples = nsamples =
s->nframesamples << (
s->nfreqbands - 1);
1465 if (request_mask !=
s->output_mask) {
1474 int16_t *plane = (int16_t *)
frame->extended_data[
i];
1475 for (k = 0; k < nsamples; k++)
1479 for (k = 0; k < nsamples; k++)
1511 c->sample_size[j] = 0;
static DCAXllChSet * find_next_hier_dmix_chset(DCAXllDecoder *s, DCAXllChSet *c)
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.
#define AV_EF_EXPLODE
abort decoding on minor error detection
int ff_dca_xll_parse(DCAXllDecoder *s, const uint8_t *data, DCAExssAsset *asset)
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
static int get_bits_left(GetBitContext *gb)
static int parse_dmix_coeffs(DCAXllDecoder *s, DCAXllChSet *c)
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
#define DCA_XLL_DECI_HISTORY_MAX
int sample_rate
samples per second
static int32_t norm16(int64_t a)
#define DCA_SPEAKER_LAYOUT_5POINT0
int npcmsamples
Number of PCM samples per channel.
static int32_t mul15(int32_t a, int32_t b)
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
static int chs_assemble_freq_bands(DCAXllDecoder *s, DCAXllChSet *c)
static void get_array(GetBitContext *gb, int32_t *array, int size, int n)
static int get_bits_count(const GetBitContext *s)
static void scale_down_mix(DCAXllDecoder *s, DCAXllChSet *o, int band)
This structure describes decoded (raw) audio or video data.
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
#define DCA_SPEAKER_LAYOUT_STEREO
static int is_hier_dmix_chset(DCAXllChSet *c)
int request_channel_layout
Converted from avctx.request_channel_layout.
static int ff_dca_seek_bits(GetBitContext *s, int p)
#define AV_LOG_VERBOSE
Detailed information.
int xll_size
Size of XLL data in extension substream.
static void chs_assemble_msbs_lsbs(DCAXllDecoder *s, DCAXllChSet *c, int band)
static int ff_dca_check_crc(AVCodecContext *avctx, GetBitContext *s, int p1, int p2)
int nb_channels
Number of channels in this layout.
static int copy_to_pbr(DCAXllDecoder *s, const uint8_t *data, int size, int delay)
int hier_ofs
Number of preceding channels in a hierarchy (M)
#define FF_DCA_DMIXTABLE_OFFSET
int one_to_one_map_ch_to_spkr
One to one channel to speaker mapping flag.
static int parse_navi_table(DCAXllDecoder *s)
#define DCA_XLL_PBR_BUFFER_MAX
#define DCA_PACKET_RECOVERY
Sync error recovery flag.
static void skip_bits(GetBitContext *s, int n)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static void undo_down_mix(DCAXllDecoder *s, DCAXllChSet *o, int band)
#define AV_PROFILE_DTS_HD_MA_X
int dmix_coeff[DCA_XLL_DMIX_COEFFS_MAX]
Downmixing coefficients.
AVChannelLayout ch_layout
Audio channel layout.
#define DCA_SYNCWORD_XLL_X
static int parse_common_header(DCAXllDecoder *s)
static int chs_alloc_msb_band_data(DCAXllDecoder *s, DCAXllChSet *c)
static int32_t clip23(int32_t a)
int nchannels
Number of channels in the channel set (N)
#define DCA_SYNCWORD_XLL_X_IMAX
DCAExssParser exss
EXSS parser context.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int ff_side_data_update_matrix_encoding(AVFrame *frame, enum AVMatrixEncoding matrix_encoding)
Add or update AV_FRAME_DATA_MATRIXENCODING side data.
@ AV_MATRIX_ENCODING_DOLBY
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
int output_rate
Output sample rate (1x or 2x header rate)
void ff_dca_downmix_to_stereo_fixed(DCADSPContext *dcadsp, int32_t **samples, int *coeff_l, int nsamples, int ch_mask)
#define DCA_XLL_ADAPT_PRED_ORDER_MAX
#define DCA_SPEAKER_LAYOUT_5POINT1
static int chs_get_lsb_width(DCAXllDecoder *s, DCAXllChSet *c, int band, int ch)
const uint16_t ff_dca_xll_refl_coeff[128]
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
int storage_bit_res
Storage bit resolution (16 or 24)
static int32_t mul16(int32_t a, int32_t b)
int dmix_type
Primary channel set downmix type.
int dmix_embedded
Downmix already performed by encoder.
static int chs_alloc_lsb_band_data(DCAXllDecoder *s, DCAXllChSet *c)
int ff_dca_set_channel_layout(AVCodecContext *avctx, int *ch_remap, int dca_mask)
@ AV_MATRIX_ENCODING_DOLBYHEADPHONE
static void clear_pbr(DCAXllDecoder *s)
#define DCA_HAS_STEREO(mask)
int32_t * output_samples[DCA_SPEAKER_COUNT]
PCM output for fixed point mode.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
const uint8_t ff_dca_dmix_primary_nch[8]
int64_t bit_rate
the average bitrate
static unsigned int get_bits1(GetBitContext *s)
#define DCA_XLL_SAMPLE_BUFFERS_MAX
static int get_rice(GetBitContext *gb, int k)
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.
int xll_offset
Offset to XLL data from start of substream.
const uint32_t ff_dca_inv_dmixtable[FF_DCA_INV_DMIXTABLE_SIZE]
static int combine_residual_frame(DCAXllDecoder *s, DCAXllChSet *c)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
const uint16_t ff_dca_dmixtable[FF_DCA_DMIXTABLE_SIZE]
const int32_t ff_dca_xll_band_coeff[20]
static int shift(int a, int b)
@ AV_MATRIX_ENCODING_NONE
enum AVSampleFormat sample_fmt
audio sample format
static int chs_parse_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band, int seg, int band_data_end)
int xll_delay_nframes
Initial XLL decoding delay in frames.
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
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
static void chs_filter_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band)
#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 av_const double round(double x)
#define DCA_XLL_CHANNELS_MAX
static int parse_frame_pbr(DCAXllDecoder *s, const uint8_t *data, int size, DCAExssAsset *asset)
int32_t * msb_sample_buffer[DCA_XLL_CHANNELS_MAX]
MSB sample buffer pointers.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
int pcm_bit_res
PCM bit resolution (variable)
int xll_sync_offset
Number of bytes offset to XLL sync.
DCAExssAsset assets[1]
Audio asset descriptors.
int32_t deci_history[DCA_XLL_CHANNELS_MAX][DCA_XLL_DECI_HISTORY_MAX]
Decimator history for frequency band 1.
int ff_dca_xll_filter_frame(DCAXllDecoder *s, AVFrame *frame)
static int ff_dca_core_map_spkr(DCACoreDecoder *core, int spkr)
int dmix_scale_inv[DCA_XLL_DMIX_SCALES_MAX]
Inverse downmixing scales.
static int array[MAX_W *MAX_W]
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
int nfreqbands
Number of frequency bands (1 or 2)
DCAXllBand bands[DCA_XLL_BANDS_MAX]
Frequency bands.
#define DCA_XLL_CHSETS_MAX
static int parse_frame_no_pbr(DCAXllDecoder *s, const uint8_t *data, int size, DCAExssAsset *asset)
#define AV_INPUT_BUFFER_PADDING_SIZE
main external API structure.
#define AV_PROFILE_DTS_HD_MA
int xll_sync_present
XLL sync word present flag.
#define FF_DCA_DMIXTABLE_SIZE
int dmix_scale[DCA_XLL_DMIX_SCALES_MAX]
Downmixing scales.
const uint32_t ff_dca_sampling_freqs[16]
static int get_rice_un(GetBitContext *gb, int k)
#define FF_DCA_INV_DMIXTABLE_SIZE
static void prescale_down_mix(DCAXllChSet *c, DCAXllChSet *o)
static int chs_parse_header(DCAXllDecoder *s, DCAXllChSet *c, DCAExssAsset *asset)
#define AV_PROFILE_DTS_HD_MA_X_IMAX
static void get_linear_array(GetBitContext *gb, int32_t *array, int size, int n)
Filter the word “frame” indicates either a video frame or a group of audio samples
static int parse_sub_headers(DCAXllDecoder *s, DCAExssAsset *asset)
static int parse_frame(DCAXllDecoder *s, const uint8_t *data, int size, DCAExssAsset *asset)
int freq
Original sampling frequency (max. 96000 Hz)
static void get_rice_array(GetBitContext *gb, int32_t *array, int size, int k)
#define avpriv_request_sample(...)
static void scale(int *out, const int *in, const int w, const int h, const int shift)
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
av_cold void ff_dca_xll_flush(DCAXllDecoder *s)
static av_cold void force_lossy_output(DCAXllDecoder *s, DCAXllChSet *c)
DCACoreDecoder core
Core decoder context.
static const double coeff[2][5]
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
static av_cold void chs_clear_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band, int seg)
static int get_linear(GetBitContext *gb, int n)
int representation_type
Representation type.
int hd_stream_id
DTS-HD stream ID.
static int parse_band_data(DCAXllDecoder *s)
av_cold void ff_dca_xll_close(DCAXllDecoder *s)