30 return (v >> 1) ^ -(v & 1);
42 return (v >> 1) ^ -(v & 1);
75 int i, j, *coeff_ptr =
c->dmix_coeff;
77 for (
i = 0;
i < m;
i++) {
78 int code, sign,
coeff, scale, scale_inv = 0;
82 if (!
c->primary_chset) {
84 sign = (
code >> 8) - 1;
92 c->dmix_scale[
i] = (scale ^ sign) - sign;
93 c->dmix_scale_inv[
i] = (scale_inv ^ sign) - sign;
97 for (j = 0; j <
c->nchannels; j++) {
99 sign = (
code >> 8) - 1;
106 if (!
c->primary_chset)
109 *coeff_ptr++ = (
coeff ^ sign) - sign;
139 c->residual_encode =
get_bits(&
s->gb,
c->nchannels);
146 if (
c->storage_bit_res != 16 &&
c->storage_bit_res != 20 &&
c->storage_bit_res != 24) {
151 if (
c->pcm_bit_res >
c->storage_bit_res) {
152 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);
158 if (
c->freq > 192000) {
178 if (
c->primary_chset != (
c == p)) {
187 c->dmix_embedded =
c->dmix_coeffs_present &&
get_bits1(&
s->gb);
190 if (
c->dmix_coeffs_present &&
c->primary_chset) {
200 if (!
c->hier_chset &&
s->nchsets != 1) {
223 for (
i = 0, j = 0;
i <
s->ch_mask_nbits;
i++)
224 if (
c->ch_mask & (1U <<
i))
225 c->ch_remap[j++] =
i;
228 if (
c->nchannels != 2 ||
s->nchsets != 1 ||
get_bits1(&
s->gb)) {
234 c->primary_chset = 1;
235 c->dmix_coeffs_present = 0;
236 c->dmix_embedded = 0;
243 if (
c->freq > 96000) {
256 c->freq >>=
c->nfreqbands - 1;
267 if (
c->storage_bit_res > 16)
269 else if (
c->storage_bit_res > 8)
275 if ((
s->nchsets > 1 ||
c->nfreqbands > 1) &&
c->nabits < 5)
278 for (band = 0,
b =
c->bands; band < c->nfreqbands; band++,
b++) {
280 if ((
b->decor_enabled =
get_bits1(&
s->gb)) &&
c->nchannels > 1) {
284 for (
i = 0;
i <
c->nchannels;
i++) {
286 if (
b->orig_order[
i] >=
c->nchannels) {
293 for (
i = 0;
i <
c->nchannels / 2;
i++)
296 for (
i = 0;
i <
c->nchannels;
i++)
297 b->orig_order[
i] =
i;
298 for (
i = 0;
i <
c->nchannels / 2;
i++)
299 b->decor_coeff[
i] = 0;
303 b->highest_pred_order = 0;
304 for (
i = 0;
i <
c->nchannels;
i++) {
306 if (
b->adapt_pred_order[
i] >
b->highest_pred_order)
307 b->highest_pred_order =
b->adapt_pred_order[
i];
309 if (
b->highest_pred_order >
s->nsegsamples) {
315 for (
i = 0;
i <
c->nchannels;
i++)
316 b->fixed_pred_order[
i] =
b->adapt_pred_order[
i] ? 0 :
get_bits(&
s->gb, 2);
319 for (
i = 0;
i <
c->nchannels;
i++) {
320 for (j = 0; j <
b->adapt_pred_order[
i]; j++) {
334 b->dmix_embedded =
c->dmix_embedded && (band == 0 ||
get_bits1(&
s->gb));
337 if ((band == 0 &&
s->scalable_lsbs) || (band != 0 &&
get_bits1(&
s->gb))) {
340 if (
b->lsb_section_size < 0 ||
b->lsb_section_size >
s->frame_size) {
346 if (
b->lsb_section_size && (
s->band_crc_present > 2 ||
347 (band == 0 &&
s->band_crc_present > 1)))
348 b->lsb_section_size += 2;
351 for (
i = 0;
i <
c->nchannels;
i++) {
353 if (
b->nscalablelsbs[
i] && !
b->lsb_section_size) {
359 b->lsb_section_size = 0;
360 for (
i = 0;
i <
c->nchannels;
i++)
361 b->nscalablelsbs[
i] = 0;
365 if ((band == 0 &&
s->scalable_lsbs) || (band != 0 &&
get_bits1(&
s->gb))) {
367 for (
i = 0;
i <
c->nchannels;
i++)
370 for (
i = 0;
i <
c->nchannels;
i++)
371 b->bit_width_adjust[
i] = 0;
389 int nchsamples =
s->nframesamples + ndecisamples;
390 int i, j, nsamples = nchsamples *
c->nchannels *
c->nfreqbands;
395 if (!
c->sample_buffer[0])
398 ptr =
c->sample_buffer[0] + ndecisamples;
399 for (
i = 0;
i <
c->nfreqbands;
i++) {
400 for (j = 0; j <
c->nchannels; j++) {
401 c->bands[
i].msb_sample_buffer[j] = ptr;
411 int i, j, nsamples = 0;
415 for (
i = 0;
i <
c->nfreqbands;
i++)
416 if (
c->bands[
i].lsb_section_size)
417 nsamples +=
s->nframesamples *
c->nchannels;
423 if (!
c->sample_buffer[1])
426 ptr =
c->sample_buffer[1];
427 for (
i = 0;
i <
c->nfreqbands;
i++) {
428 if (
c->bands[
i].lsb_section_size) {
429 for (j = 0; j <
c->nchannels; j++) {
430 c->bands[
i].lsb_sample_buffer[j] = ptr;
431 ptr +=
s->nframesamples;
434 for (j = 0; j <
c->nchannels; j++)
435 c->bands[
i].lsb_sample_buffer[j] =
NULL;
455 k =
c->seg_common ? 1 :
c->nchannels;
458 for (
i = 0;
i < k;
i++) {
464 if (!
c->seg_common &&
c->rice_code_flag[
i] &&
get_bits1(&
s->gb))
466 c->bitalloc_hybrid_linear[
i] =
get_bits(&
s->gb,
c->nabits) + 1;
469 c->bitalloc_hybrid_linear[
i] = 0;
473 for (
i = 0;
i < k;
i++) {
479 if (!
c->rice_code_flag[
i] &&
c->bitalloc_part_a[
i])
480 c->bitalloc_part_a[
i]++;
483 c->nsamples_part_a[
i] =
b->adapt_pred_order[
i];
485 c->nsamples_part_a[
i] =
b->highest_pred_order;
487 c->bitalloc_part_a[
i] = 0;
488 c->nsamples_part_a[
i] = 0;
495 if (!
c->rice_code_flag[
i] &&
c->bitalloc_part_b[
i])
496 c->bitalloc_part_b[
i]++;
501 for (
i = 0;
i <
c->nchannels;
i++) {
506 k =
c->seg_common ? 0 :
i;
509 part_a =
b->msb_sample_buffer[
i] + seg *
s->nsegsamples;
510 part_b = part_a +
c->nsamples_part_a[k];
511 nsamples_part_b =
s->nsegsamples -
c->nsamples_part_a[k];
516 if (!
c->rice_code_flag[k]) {
520 c->bitalloc_part_a[k]);
524 c->bitalloc_part_b[k]);
529 c->bitalloc_part_a[k]);
531 if (
c->bitalloc_hybrid_linear[k]) {
534 int nisosamples =
get_bits(&
s->gb,
s->nsegsamples_log2);
537 memset(part_b, 0,
sizeof(*part_b) * nsamples_part_b);
540 for (j = 0; j < nisosamples; j++) {
541 int loc =
get_bits(&
s->gb,
s->nsegsamples_log2);
542 if (loc >= nsamples_part_b) {
550 for (j = 0; j < nsamples_part_b; j++) {
552 part_b[j] =
get_linear(&
s->gb,
c->bitalloc_hybrid_linear[k]);
554 part_b[j] =
get_rice(&
s->gb,
c->bitalloc_part_b[k]);
565 if (seg == 0 && band == 1) {
567 for (
i = 0;
i <
c->nchannels;
i++)
573 if (
b->lsb_section_size) {
581 for (
i = 0;
i <
c->nchannels;
i++) {
582 if (
b->nscalablelsbs[
i]) {
584 b->lsb_sample_buffer[
i] + seg *
s->nsegsamples,
585 s->nsegsamples,
b->nscalablelsbs[
i]);
606 nsamples =
s->nframesamples;
609 nsamples =
s->nsegsamples;
612 for (
i = 0;
i <
c->nchannels;
i++) {
613 memset(
b->msb_sample_buffer[
i] +
offset, 0, nsamples *
sizeof(
int32_t));
614 if (
b->lsb_section_size)
615 memset(
b->lsb_sample_buffer[
i] +
offset, 0, nsamples *
sizeof(
int32_t));
618 if (seg <= 0 && band)
619 memset(
c->deci_history, 0,
sizeof(
c->deci_history));
622 memset(
b->nscalablelsbs, 0,
sizeof(
b->nscalablelsbs));
623 memset(
b->bit_width_adjust, 0,
sizeof(
b->bit_width_adjust));
630 int nsamples =
s->nframesamples;
634 for (
i = 0;
i <
c->nchannels;
i++) {
636 int order =
b->adapt_pred_order[
i];
640 for (j = 0; j < order; j++) {
641 int rc =
b->adapt_refl_coeff[
i][j];
642 for (k = 0; k < (j + 1) / 2; k++) {
643 int tmp1 =
coeff[ k ];
644 int tmp2 =
coeff[j - k - 1];
651 for (j = 0; j < nsamples - order; j++) {
653 for (k = 0; k < order; k++)
659 for (j = 0; j <
b->fixed_pred_order[
i]; j++)
660 for (k = 1; k < nsamples; k++)
661 buf[k] += (
unsigned)buf[k - 1];
666 if (
b->decor_enabled) {
669 for (
i = 0;
i <
c->nchannels / 2;
i++) {
672 s->dcadsp->decor(
b->msb_sample_buffer[
i * 2 + 1],
673 b->msb_sample_buffer[
i * 2 ],
679 for (
i = 0;
i <
c->nchannels;
i++)
680 tmp[
i] =
b->msb_sample_buffer[
i];
682 for (
i = 0;
i <
c->nchannels;
i++)
683 b->msb_sample_buffer[
b->orig_order[
i]] =
tmp[
i];
687 if (
c->nfreqbands == 1)
688 for (
i = 0;
i <
c->nchannels;
i++)
689 s->output_samples[
c->ch_remap[
i]] =
b->msb_sample_buffer[
i];
694 int adj =
c->bands[band].bit_width_adjust[ch];
695 int shift =
c->bands[band].nscalablelsbs[ch];
697 if (
s->fixed_lsb_width)
698 shift =
s->fixed_lsb_width;
699 else if (
shift && adj)
710 int n, ch, nsamples =
s->nframesamples;
712 for (ch = 0; ch <
c->nchannels; ch++) {
715 int32_t *msb =
b->msb_sample_buffer[ch];
716 if (
b->nscalablelsbs[ch]) {
717 int32_t *lsb =
b->lsb_sample_buffer[ch];
718 int adj =
b->bit_width_adjust[ch];
719 for (n = 0; n < nsamples; n++)
720 msb[n] = msb[n] * (
SUINT)(1 <<
shift) + (lsb[n] << adj);
722 for (n = 0; n < nsamples; n++)
731 int ch, nsamples =
s->nframesamples;
738 2 * nsamples *
c->nchannels *
sizeof(
int32_t));
739 if (!
c->sample_buffer[2])
743 ptr =
c->sample_buffer[2];
744 for (ch = 0; ch <
c->nchannels; ch++) {
745 int32_t *band0 =
c->bands[0].msb_sample_buffer[ch];
746 int32_t *band1 =
c->bands[1].msb_sample_buffer[ch];
750 c->deci_history[ch],
sizeof(
c->deci_history[0]));
753 s->dcadsp->assemble_freq_bands(ptr, band0, band1,
758 s->output_samples[
c->ch_remap[ch]] = ptr;
767 int stream_ver, header_size, frame_size_nbits, nframesegs_log2;
777 if (stream_ver > 1) {
792 frame_size_nbits =
get_bits(&
s->gb, 5) + 1;
811 s->nframesegs = 1 << nframesegs_log2;
812 if (
s->nframesegs > 1024) {
821 if (!
s->nsegsamples_log2) {
825 s->nsegsamples = 1 <<
s->nsegsamples_log2;
826 if (
s->nsegsamples > 512) {
832 s->nframesamples_log2 =
s->nsegsamples_log2 + nframesegs_log2;
833 s->nframesamples = 1 <<
s->nframesamples_log2;
834 if (
s->nframesamples > 65536) {
856 if (
s->scalable_lsbs)
859 s->fixed_lsb_width = 0;
874 return !
c->primary_chset &&
c->dmix_embedded &&
c->hier_chset;
880 while (++c < &s->chset[
s->nchsets])
889 int i, j, *coeff_ptr =
c->dmix_coeff;
891 for (
i = 0;
i <
c->hier_ofs;
i++) {
894 c->dmix_scale[
i] =
mul15(
c->dmix_scale[
i], scale);
895 c->dmix_scale_inv[
i] =
mul16(
c->dmix_scale_inv[
i], scale_inv);
896 for (j = 0; j <
c->nchannels; j++) {
913 for (
i = 0,
c =
s->chset; i < s->nchsets;
i++,
c++) {
914 c->hier_ofs =
s->nchannels;
917 if (
c->nfreqbands >
s->nfreqbands)
918 s->nfreqbands =
c->nfreqbands;
920 s->nchannels +=
c->nchannels;
921 if (
c->residual_encode != (1 <<
c->nchannels) - 1)
926 for (
i =
s->nchsets - 1,
c = &
s->chset[
i];
i > 0;
i--,
c--) {
937 s->nactivechsets = 1;
941 s->nactivechsets = (
s->chset[0].nchannels < 5 &&
s->nchsets > 1) ? 2 : 1;
944 s->nactivechsets =
s->nchsets;
953 int chs, seg, band, navi_nb, navi_pos, *navi_ptr;
957 navi_nb =
s->nfreqbands *
s->nframesegs *
s->nchsets;
958 if (navi_nb > 1024) {
971 for (band = 0; band <
s->nfreqbands; band++) {
972 for (seg = 0; seg <
s->nframesegs; seg++) {
973 for (chs = 0,
c =
s->chset; chs < s->nchsets; chs++,
c++) {
975 if (
c->nfreqbands > band) {
977 if (size < 0 || size >=
s->frame_size) {
1004 int ret, chs, seg, band, navi_pos, *navi_ptr;
1007 for (chs = 0,
c =
s->chset; chs < s->nactivechsets; chs++,
c++) {
1016 for (band = 0; band <
s->nfreqbands; band++) {
1017 for (seg = 0; seg <
s->nframesegs; seg++) {
1018 for (chs = 0,
c =
s->chset; chs < s->nchsets; chs++,
c++) {
1019 if (
c->nfreqbands > band) {
1020 navi_pos += *navi_ptr * 8;
1021 if (navi_pos >
s->gb.size_in_bits) {
1025 if (chs < s->nactivechsets &&
1077 s->pbr_length =
size;
1078 s->pbr_delay = delay;
1109 if (
s->frame_size >
size)
1113 if (
s->frame_size <
size)
1129 memcpy(
s->pbr_buffer +
s->pbr_length,
data,
size);
1130 s->pbr_length +=
size;
1133 if (
s->pbr_delay > 0 && --
s->pbr_delay)
1136 if ((ret =
parse_frame(
s,
s->pbr_buffer,
s->pbr_length, asset)) < 0)
1139 if (
s->frame_size >
s->pbr_length) {
1144 if (
s->frame_size ==
s->pbr_length) {
1148 s->pbr_length -=
s->frame_size;
1149 memmove(
s->pbr_buffer,
s->pbr_buffer +
s->frame_size,
s->pbr_length);
1180 int i, j, k, nchannels = 0, *coeff_ptr = o->
dmix_coeff;
1183 for (
i = 0,
c =
s->chset; i < s->nactivechsets;
i++,
c++) {
1188 for (j = 0; j <
c->nchannels; j++) {
1190 int coeff = *coeff_ptr++;
1192 s->dcadsp->dmix_sub(
c->bands[band].msb_sample_buffer[j],
1194 coeff,
s->nframesamples);
1196 s->dcadsp->dmix_sub(
c->deci_history[j],
1203 nchannels +=
c->nchannels;
1211 int i, j, nchannels = 0;
1214 for (
i = 0,
c =
s->chset; i < s->nactivechsets;
i++,
c++) {
1219 for (j = 0; j <
c->nchannels; j++) {
1221 if (scale != (1 << 15)) {
1222 s->dcadsp->dmix_scale(
c->bands[band].msb_sample_buffer[j],
1223 scale,
s->nframesamples);
1225 s->dcadsp->dmix_scale(
c->deci_history[j],
1242 for (band = 0; band <
c->nfreqbands; band++)
1245 for (ch = 0; ch <
c->nchannels; ch++) {
1246 if (!(
c->residual_encode & (1 << ch)))
1250 c->residual_encode &= ~(1 << ch);
1257 int ch, nsamples =
s->nframesamples;
1282 for (ch = 0; ch <
c->nchannels; ch++) {
1286 if (
c->residual_encode & (1 << ch))
1292 av_log(
s->avctx,
AV_LOG_WARNING,
"Residual encoded channel (%d) references unavailable core channel\n",
c->ch_remap[ch]);
1306 dst =
c->bands[0].msb_sample_buffer[ch];
1310 for (n = 0; n < nsamples; n++)
1314 for (n = 0; n < nsamples; n++)
1329 int i, j, k, ret,
shift, nsamples, request_mask;
1334 for (
i = 0,
c =
s->chset; i < s->nchsets;
i++,
c++) {
1335 if (i < s->nactivechsets)
1338 if (!
c->primary_chset)
1339 c->dmix_embedded = 0;
1342 s->scalable_lsbs = 0;
1343 s->fixed_lsb_width = 0;
1348 for (
i = 0,
c =
s->chset; i < s->nactivechsets;
i++,
c++) {
1351 if (
c->residual_encode != (1 <<
c->nchannels) - 1
1355 if (
s->scalable_lsbs)
1358 if (
c->nfreqbands > 1) {
1363 s->output_mask |=
c->ch_mask;
1367 for (
i = 1,
c = &
s->chset[1]; i < s->nchsets;
i++,
c++) {
1371 if (
i >=
s->nactivechsets) {
1372 for (j = 0; j <
c->nfreqbands; j++)
1373 if (
c->bands[j].dmix_embedded)
1378 for (j = 0; j <
c->nfreqbands; j++)
1379 if (
c->bands[j].dmix_embedded)
1384 if (
s->nfreqbands > 1) {
1385 for (
i = 0;
i <
s->nactivechsets;
i++)
1409 request_mask =
s->output_mask;
1438 if (request_mask !=
s->output_mask) {
1445 int32_t *samples =
s->output_samples[ch_remap[
i]];
1448 for (k = 0; k < nsamples; k++)
1452 for (k = 0; k < nsamples; k++)
1484 c->sample_size[j] = 0;
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
#define AV_EF_EXPLODE
abort decoding on minor error detection
#define FF_PROFILE_DTS_HD_MA
const uint32_t ff_dca_sampling_freqs[16]
#define DCA_SPEAKER_LAYOUT_5POINT0
#define DCA_SPEAKER_LAYOUT_STEREO
#define DCA_HAS_STEREO(mask)
#define DCA_SPEAKER_LAYOUT_5POINT1
static int ff_dca_core_map_spkr(DCACoreDecoder *core, int spkr)
static int combine_residual_frame(DCAXllDecoder *s, DCAXllChSet *c)
static int parse_frame(DCAXllDecoder *s, uint8_t *data, int size, DCAExssAsset *asset)
static int get_rice(GetBitContext *gb, int k)
static int parse_navi_table(DCAXllDecoder *s)
static void get_rice_array(GetBitContext *gb, int32_t *array, int size, int k)
static int parse_frame_no_pbr(DCAXllDecoder *s, uint8_t *data, int size, DCAExssAsset *asset)
int ff_dca_xll_filter_frame(DCAXllDecoder *s, AVFrame *frame)
static int parse_sub_headers(DCAXllDecoder *s, DCAExssAsset *asset)
static void prescale_down_mix(DCAXllChSet *c, DCAXllChSet *o)
static void chs_filter_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band)
static int chs_assemble_freq_bands(DCAXllDecoder *s, DCAXllChSet *c)
static int parse_dmix_coeffs(DCAXllDecoder *s, DCAXllChSet *c)
static int chs_parse_header(DCAXllDecoder *s, DCAXllChSet *c, DCAExssAsset *asset)
static void clear_pbr(DCAXllDecoder *s)
static int chs_alloc_msb_band_data(DCAXllDecoder *s, DCAXllChSet *c)
static int get_linear(GetBitContext *gb, int n)
static int get_rice_un(GetBitContext *gb, int k)
av_cold void ff_dca_xll_flush(DCAXllDecoder *s)
static void get_linear_array(GetBitContext *gb, int32_t *array, int size, int n)
static int copy_to_pbr(DCAXllDecoder *s, uint8_t *data, int size, int delay)
static DCAXllChSet * find_next_hier_dmix_chset(DCAXllDecoder *s, DCAXllChSet *c)
static av_cold void chs_clear_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band, int seg)
static int chs_get_lsb_width(DCAXllDecoder *s, DCAXllChSet *c, int band, int ch)
static void scale_down_mix(DCAXllDecoder *s, DCAXllChSet *o, int band)
static void get_array(GetBitContext *gb, int32_t *array, int size, int n)
int ff_dca_xll_parse(DCAXllDecoder *s, uint8_t *data, DCAExssAsset *asset)
static void undo_down_mix(DCAXllDecoder *s, DCAXllChSet *o, int band)
static int parse_common_header(DCAXllDecoder *s)
static av_cold void force_lossy_output(DCAXllDecoder *s, DCAXllChSet *c)
static void chs_assemble_msbs_lsbs(DCAXllDecoder *s, DCAXllChSet *c, int band)
static int is_hier_dmix_chset(DCAXllChSet *c)
static int chs_alloc_lsb_band_data(DCAXllDecoder *s, DCAXllChSet *c)
static int parse_frame_pbr(DCAXllDecoder *s, uint8_t *data, int size, DCAExssAsset *asset)
static int parse_band_data(DCAXllDecoder *s)
av_cold void ff_dca_xll_close(DCAXllDecoder *s)
static int chs_parse_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band, int seg, int band_data_end)
#define DCA_XLL_CHANNELS_MAX
#define DCA_XLL_DECI_HISTORY_MAX
#define DCA_XLL_CHSETS_MAX
#define DCA_XLL_SAMPLE_BUFFERS_MAX
#define DCA_XLL_PBR_BUFFER_MAX
#define DCA_XLL_ADAPT_PRED_ORDER_MAX
const uint16_t ff_dca_dmixtable[FF_DCA_DMIXTABLE_SIZE]
const uint16_t ff_dca_xll_refl_coeff[128]
const int32_t ff_dca_xll_band_coeff[20]
const uint8_t ff_dca_dmix_primary_nch[8]
const uint32_t ff_dca_inv_dmixtable[FF_DCA_INV_DMIXTABLE_SIZE]
#define FF_DCA_INV_DMIXTABLE_SIZE
#define FF_DCA_DMIXTABLE_SIZE
#define FF_DCA_DMIXTABLE_OFFSET
int ff_dca_set_channel_layout(AVCodecContext *avctx, int *ch_remap, int dca_mask)
void ff_dca_downmix_to_stereo_fixed(DCADSPContext *dcadsp, int32_t **samples, int *coeff_l, int nsamples, int ch_mask)
#define DCA_PACKET_RECOVERY
Sync error recovery flag.
static int ff_dca_check_crc(AVCodecContext *avctx, GetBitContext *s, int p1, int p2)
static int ff_dca_seek_bits(GetBitContext *s, int p)
static int32_t mul16(int32_t a, int32_t b)
static int32_t norm16(int64_t a)
static int32_t clip23(int32_t a)
static int32_t mul15(int32_t a, int32_t b)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
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 void skip_bits(GetBitContext *s, int n)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
static int get_bits_count(const GetBitContext *s)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
@ AV_MATRIX_ENCODING_NONE
@ AV_MATRIX_ENCODING_DOLBY
@ AV_MATRIX_ENCODING_DOLBYHEADPHONE
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
#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_VERBOSE
Detailed information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
int ff_side_data_update_matrix_encoding(AVFrame *frame, enum AVMatrixEncoding matrix_encoding)
Add or update AV_FRAME_DATA_MATRIXENCODING side data.
static av_always_inline av_const double round(double x)
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
This structure describes decoded (raw) audio or video data.
int nb_samples
number of audio samples (per channel) described by this frame
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
uint8_t ** extended_data
pointers to the data planes/channels.
DCACoreDecoder core
Core decoder context.
DCAExssParser exss
EXSS parser context.
int request_channel_layout
Converted from avctx.request_channel_layout.
int npcmsamples
Number of PCM samples per channel.
int output_rate
Output sample rate (1x or 2x header rate)
int32_t * output_samples[DCA_SPEAKER_COUNT]
PCM output for fixed point mode.
int xll_offset
Offset to XLL data from start of substream.
int hd_stream_id
DTS-HD stream ID.
int xll_sync_present
XLL sync word present flag.
int xll_size
Size of XLL data in extension substream.
int xll_delay_nframes
Initial XLL decoding delay in frames.
int representation_type
Representation type.
int xll_sync_offset
Number of bytes offset to XLL sync.
int one_to_one_map_ch_to_spkr
One to one channel to speaker mapping flag.
DCAExssAsset assets[1]
Audio asset descriptors.
int32_t * msb_sample_buffer[DCA_XLL_CHANNELS_MAX]
MSB sample buffer pointers.
int nfreqbands
Number of frequency bands (1 or 2)
int32_t deci_history[DCA_XLL_CHANNELS_MAX][DCA_XLL_DECI_HISTORY_MAX]
Decimator history for frequency band 1.
int freq
Original sampling frequency (max. 96000 Hz)
int dmix_type
Primary channel set downmix type.
int nchannels
Number of channels in the channel set (N)
int pcm_bit_res
PCM bit resolution (variable)
int dmix_embedded
Downmix already performed by encoder.
int storage_bit_res
Storage bit resolution (16 or 24)
DCAXllBand bands[DCA_XLL_BANDS_MAX]
Frequency bands.
int dmix_scale[DCA_XLL_DMIX_SCALES_MAX]
Downmixing scales.
int dmix_coeff[DCA_XLL_DMIX_COEFFS_MAX]
Downmixing coefficients.
int dmix_scale_inv[DCA_XLL_DMIX_SCALES_MAX]
Inverse downmixing scales.
int hier_ofs
Number of preceding channels in a hierarchy (M)
#define avpriv_request_sample(...)
static int array[MAX_W *MAX_W]
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
static const double coeff[2][5]
static const uint8_t offset[127][2]