2 * Copyright (C) 2017 foo86
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 #include "libavutil/float_dsp.h"
22 #include "libavutil/thread.h"
23 #include "libavutil/mem.h"
24 #include "libavutil/mem_internal.h"
32 static int skip_input(DBEContext *s, int nb_words)
34 if (nb_words > s->input_size) {
35 av_log(s->avctx, AV_LOG_ERROR, "Packet too short\n");
36 return AVERROR_INVALIDDATA;
39 s->input += nb_words * s->word_bytes;
40 s->input_size -= nb_words;
44 static int parse_key(DBEContext *s)
47 uint8_t *key = s->input;
48 int ret = skip_input(s, 1);
51 return AV_RB24(key) >> 24 - s->word_bits;
56 static int convert_input(DBEContext *s, int nb_words, int key)
58 uint8_t *src = s->input;
59 uint8_t *dst = s->buffer;
63 av_assert0(nb_words <= 1024u);
65 if (nb_words > s->input_size) {
66 av_log(s->avctx, AV_LOG_ERROR, "Packet too short\n");
67 return AVERROR_INVALIDDATA;
70 switch (s->word_bits) {
72 for (i = 0; i < nb_words; i++, src += 2, dst += 2)
73 AV_WB16(dst, AV_RB16(src) ^ key);
76 init_put_bits(&pb, s->buffer, sizeof(s->buffer));
77 for (i = 0; i < nb_words; i++, src += 3)
78 put_bits(&pb, 20, AV_RB24(src) >> 4 ^ key);
82 for (i = 0; i < nb_words; i++, src += 3, dst += 3)
83 AV_WB24(dst, AV_RB24(src) ^ key);
89 return init_get_bits(&s->gb, s->buffer, nb_words * s->word_bits);
92 static int parse_metadata(DBEContext *s)
94 int i, ret, key, mtd_size;
96 if ((key = parse_key(s)) < 0)
98 if ((ret = convert_input(s, 1, key)) < 0)
101 skip_bits(&s->gb, 4);
102 mtd_size = get_bits(&s->gb, 10);
104 av_log(s->avctx, AV_LOG_ERROR, "Invalid metadata size\n");
105 return AVERROR_INVALIDDATA;
108 if ((ret = convert_input(s, mtd_size, key)) < 0)
111 skip_bits(&s->gb, 14);
112 s->prog_conf = get_bits(&s->gb, 6);
113 if (s->prog_conf > MAX_PROG_CONF) {
114 av_log(s->avctx, AV_LOG_ERROR, "Invalid program configuration\n");
115 return AVERROR_INVALIDDATA;
118 s->nb_channels = nb_channels_tab[s->prog_conf];
119 s->nb_programs = nb_programs_tab[s->prog_conf];
121 s->fr_code = get_bits(&s->gb, 4);
122 s->fr_code_orig = get_bits(&s->gb, 4);
123 if (!sample_rate_tab[s->fr_code] ||
124 !sample_rate_tab[s->fr_code_orig]) {
125 av_log(s->avctx, AV_LOG_ERROR, "Invalid frame rate code\n");
126 return AVERROR_INVALIDDATA;
129 skip_bits_long(&s->gb, 88);
130 for (i = 0; i < s->nb_channels; i++)
131 s->ch_size[i] = get_bits(&s->gb, 10);
132 s->mtd_ext_size = get_bits(&s->gb, 8);
133 s->meter_size = get_bits(&s->gb, 8);
135 skip_bits_long(&s->gb, 10 * s->nb_programs);
136 for (i = 0; i < s->nb_channels; i++) {
137 s->rev_id[i] = get_bits(&s->gb, 4);
139 s->begin_gain[i] = get_bits(&s->gb, 10);
140 s->end_gain[i] = get_bits(&s->gb, 10);
143 if (get_bits_left(&s->gb) < 0) {
144 av_log(s->avctx, AV_LOG_ERROR, "Read past end of metadata\n");
145 return AVERROR_INVALIDDATA;
148 return skip_input(s, mtd_size + 1);
151 static int parse_metadata_ext(DBEContext *s)
154 return skip_input(s, s->key_present + s->mtd_ext_size + 1);
158 static void unbias_exponents(DBEContext *s, DBEChannel *c, DBEGroup *g)
160 int mstr_exp[MAX_MSTR_EXP];
161 int bias_exp[MAX_BIAS_EXP];
164 for (i = 0; i < c->nb_mstr_exp; i++)
165 mstr_exp[i] = get_bits(&s->gb, 2) * 6;
167 for (i = 0; i < g->nb_exponent; i++)
168 bias_exp[i] = get_bits(&s->gb, 5);
170 for (i = k = 0; i < c->nb_mstr_exp; i++)
171 for (j = 0; j < g->nb_bias_exp[i]; j++, k++)
172 c->exponents[g->exp_ofs + k] = mstr_exp[i] + bias_exp[k];
175 static int parse_exponents(DBEContext *s, DBEChannel *c)
180 for (i = 0, p = NULL, g = c->groups; i < c->nb_groups; i++, p = g, g++) {
181 c->exp_strategy[i] = !i || g->nb_exponent != p->nb_exponent || get_bits1(&s->gb);
182 if (c->exp_strategy[i]) {
183 unbias_exponents(s, c, g);
185 memcpy(c->exponents + g->exp_ofs,
186 c->exponents + p->exp_ofs,
187 g->nb_exponent * sizeof(c->exponents[0]));
194 static inline int log_add(int a, int b)
196 int c = FFABS(a - b) >> 1;
197 return FFMAX(a, b) + log_add_tab[FFMIN(c, 211)];
200 static void calc_lowcomp(int *msk_val)
202 int lwc_val[17] = { 0 };
205 for (i = 0; i < 11; i++) {
210 for (j = FFMAX(i - 3, 0), k = 0; j <= i + 3; j++, k++) {
211 int v = msk_val[j] + lwc_gain_tab[i][k];
216 thr = log_add(thr, v);
219 if (msk_val[i] < thr) {
220 for (j = FFMAX(max_j - 3, 0),
221 k = FFMAX(3 - max_j, 0);
222 j <= max_j + 3; j++, k++)
223 lwc_val[j] += lwc_adj_tab[k];
227 for (i = 0; i < 16; i++) {
228 int v = FFMAX(lwc_val[i], -512);
229 msk_val[i] = FFMAX(msk_val[i] + v, 0);
233 static void bit_allocate(int nb_exponent, int nb_code, int fr_code,
235 int fg_spc, int fg_ofs, int msk_mod, int snr_ofs)
237 int msk_val[MAX_BIAS_EXP];
238 int psd_val[MAX_BIAS_EXP];
241 int dc_code = dc_code_tab[fr_code - 1];
242 int ht_code = ht_code_tab[fr_code - 1];
243 int fast_gain = fast_gain_tab[fg_ofs];
244 int slow_decay = slow_decay_tab[dc_code][msk_mod];
245 int misc_decay = misc_decay_tab[nb_code][dc_code][msk_mod];
246 const uint16_t *slow_gain = slow_gain_tab[nb_code][msk_mod];
247 const uint16_t *fast_decay = fast_decay_tab[nb_code][dc_code][msk_mod];
248 const uint16_t *fast_gain_adj = fast_gain_adj_tab[nb_code][dc_code];
249 const uint16_t *hearing_thresh = hearing_thresh_tab[nb_code][ht_code];
252 for (i = 0; i < nb_exponent; i++)
253 psd_val[i] = (48 - exp[i]) * 64;
255 fast_gain_adj += band_ofs_tab[nb_code][fg_spc];
256 for (i = 0; i < nb_exponent; i++) {
257 fast_leak = log_add(fast_leak - fast_decay[i],
258 psd_val[i] - fast_gain + fast_gain_adj[i]);
259 slow_leak = log_add(slow_leak - slow_decay,
260 psd_val[i] - slow_gain[i]);
261 msk_val[i] = FFMAX(fast_leak, slow_leak);
265 for (i = nb_exponent - 1; i > band_low_tab[nb_code]; i--) {
266 fast_leak = log_add(fast_leak - misc_decay, psd_val[i] - fast_gain);
267 msk_val[i] = FFMAX(msk_val[i], fast_leak);
270 for (i = 0; i < nb_exponent; i++)
271 msk_val[i] = FFMAX(msk_val[i], hearing_thresh[i]);
274 calc_lowcomp(msk_val);
276 for (i = 0; i < nb_exponent; i++) {
277 int v = 16 * (snr_ofs - 64) + psd_val[i] - msk_val[i] >> 5;
278 bap[i] = bap_tab[av_clip_uintp2(v, 6)];
282 static int parse_bit_alloc(DBEContext *s, DBEChannel *c)
285 int bap_strategy[MAX_GROUPS], fg_spc[MAX_GROUPS];
286 int fg_ofs[MAX_GROUPS], msk_mod[MAX_GROUPS];
289 for (i = 0; i < c->nb_groups; i++) {
290 bap_strategy[i] = !i || get_bits1(&s->gb);
291 if (bap_strategy[i]) {
292 fg_spc[i] = get_bits(&s->gb, 2);
293 fg_ofs[i] = get_bits(&s->gb, 3);
294 msk_mod[i] = get_bits1(&s->gb);
296 fg_spc[i] = fg_spc[i - 1];
297 fg_ofs[i] = fg_ofs[i - 1];
298 msk_mod[i] = msk_mod[i - 1];
302 if (get_bits1(&s->gb)) {
303 avpriv_report_missing_feature(s->avctx, "Delta bit allocation");
304 return AVERROR_PATCHWELCOME;
307 snr_ofs = get_bits(&s->gb, 8);
309 memset(c->bap, 0, sizeof(c->bap));
313 for (i = 0, p = NULL, g = c->groups; i < c->nb_groups; i++, p = g, g++) {
314 if (c->exp_strategy[i] || bap_strategy[i]) {
315 bit_allocate(g->nb_exponent, g->imdct_idx, s->fr_code,
316 c->exponents + g->exp_ofs, c->bap + g->exp_ofs,
317 fg_spc[i], fg_ofs[i], msk_mod[i], snr_ofs);
319 memcpy(c->bap + g->exp_ofs,
321 g->nb_exponent * sizeof(c->bap[0]));
328 static int parse_indices(DBEContext *s, DBEChannel *c)
333 for (i = 0, p = NULL, g = c->groups; i < c->nb_groups; i++, p = g, g++) {
334 if (get_bits1(&s->gb)) {
335 int start = get_bits(&s->gb, 6);
337 if (start > g->nb_exponent) {
338 av_log(s->avctx, AV_LOG_ERROR, "Invalid start index\n");
339 return AVERROR_INVALIDDATA;
342 for (j = 0; j < start; j++)
343 c->idx[g->exp_ofs + j] = 0;
345 for (; j < g->nb_exponent; j++)
346 c->idx[g->exp_ofs + j] = get_bits(&s->gb, 2);
347 } else if (i && g->nb_exponent == p->nb_exponent) {
348 memcpy(c->idx + g->exp_ofs,
350 g->nb_exponent * sizeof(c->idx[0]));
352 memset(c->idx + g->exp_ofs, 0, g->nb_exponent * sizeof(c->idx[0]));
359 static int parse_mantissas(DBEContext *s, DBEChannel *c)
364 for (i = 0, g = c->groups; i < c->nb_groups; i++, g++) {
365 float *mnt = c->mantissas + g->mnt_ofs;
367 for (j = 0; j < g->nb_exponent; j++) {
368 int bap = c->bap[g->exp_ofs + j];
369 int idx = c->idx[g->exp_ofs + j];
370 int size1 = mantissa_size1[bap][idx];
371 int count = g->nb_mantissa[j];
372 float exp = exponent_tab[c->exponents[g->exp_ofs + j]];
373 float scale = mantissa_tab1[size1][idx] * exp;
376 memset(mnt, 0, count * sizeof(*mnt));
379 int escape = -(1 << size1 - 1);
381 for (k = 0; k < count; k++)
382 values[k] = get_sbits(&s->gb, size1);
384 for (k = 0; k < count; k++) {
385 if (values[k] != escape) {
386 mnt[k] = values[k] * scale;
388 int size2 = mantissa_size2[bap][idx];
389 int value = get_sbits(&s->gb, size2);
390 float a = mantissa_tab2[size2][idx];
391 float b = mantissa_tab3[size2][idx];
393 mnt[k] = ((value + 1) * a - b) * exp;
395 mnt[k] = (value * a + b) * exp;
399 for (k = 0; k < count; k++)
400 mnt[k] = get_sbits(&s->gb, size1) * scale;
406 for (; j < g->nb_exponent + c->bw_code; j++) {
407 memset(mnt, 0, g->nb_mantissa[j] * sizeof(*mnt));
408 mnt += g->nb_mantissa[j];
415 static int parse_channel(DBEContext *s, int ch, int seg_id)
417 DBEChannel *c = &s->channels[seg_id][ch];
420 if (s->rev_id[ch] > 1) {
421 avpriv_report_missing_feature(s->avctx, "Encoder revision %d", s->rev_id[ch]);
422 return AVERROR_PATCHWELCOME;
425 if (ch == lfe_channel_tab[s->prog_conf]) {
429 c->gr_code = get_bits(&s->gb, 2);
430 c->bw_code = get_bits(&s->gb, 3);
431 if (c->gr_code == 3) {
432 av_log(s->avctx, AV_LOG_ERROR, "Invalid group type code\n");
433 return AVERROR_INVALIDDATA;
437 c->nb_groups = nb_groups_tab[c->gr_code];
438 c->nb_mstr_exp = nb_mstr_exp_tab[c->gr_code];
440 for (i = 0; i < c->nb_groups; i++) {
441 c->groups[i] = frm_ofs_tab[seg_id][c->gr_code][i];
442 if (c->nb_mstr_exp == 2) {
443 c->groups[i].nb_exponent -= c->bw_code;
444 c->groups[i].nb_bias_exp[1] -= c->bw_code;
448 if ((ret = parse_exponents(s, c)) < 0)
450 if ((ret = parse_bit_alloc(s, c)) < 0)
452 if ((ret = parse_indices(s, c)) < 0)
454 if ((ret = parse_mantissas(s, c)) < 0)
457 if (get_bits_left(&s->gb) < 0) {
458 av_log(s->avctx, AV_LOG_ERROR, "Read past end of channel %d\n", ch);
459 return AVERROR_INVALIDDATA;
465 static int parse_audio(DBEContext *s, int start, int end, int seg_id)
469 if ((key = parse_key(s)) < 0)
472 for (ch = start; ch < end; ch++) {
473 if (!s->ch_size[ch]) {
474 s->channels[seg_id][ch].nb_groups = 0;
477 if ((ret = convert_input(s, s->ch_size[ch], key)) < 0)
479 if ((ret = parse_channel(s, ch, seg_id)) < 0) {
480 if (s->avctx->err_recognition & AV_EF_EXPLODE)
482 s->channels[seg_id][ch].nb_groups = 0;
484 if ((ret = skip_input(s, s->ch_size[ch])) < 0)
488 return skip_input(s, 1);
491 static int parse_meter(DBEContext *s)
494 return skip_input(s, s->key_present + s->meter_size + 1);
498 static void imdct_calc(DBEContext *s, DBEGroup *g, float *result, float *values)
500 FFTContext *imdct = &s->imdct[g->imdct_idx];
501 int n = 1 << imdct_bits_tab[g->imdct_idx];
505 switch (g->imdct_phs) {
507 imdct->imdct_half(imdct, result, values);
508 for (i = 0; i < n2; i++)
509 result[n2 + i] = result[n2 - i - 1];
512 imdct->imdct_calc(imdct, result, values);
515 imdct->imdct_half(imdct, result + n2, values);
516 for (i = 0; i < n2; i++)
517 result[i] = -result[n - i - 1];
524 static void transform(DBEContext *s, DBEChannel *c, float *history, float *output)
526 LOCAL_ALIGNED_32(float, buffer, [2048]);
527 LOCAL_ALIGNED_32(float, result, [1152]);
531 memset(result, 0, 1152 * sizeof(float));
532 for (i = 0, g = c->groups; i < c->nb_groups; i++, g++) {
533 float *src = buffer + g->src_ofs;
534 float *dst = result + g->dst_ofs;
535 float *win = window + g->win_ofs;
537 imdct_calc(s, g, buffer, c->mantissas + g->mnt_ofs);
538 s->fdsp->vector_fmul_add(dst, src, win, dst, g->win_len);
541 for (i = 0; i < 256; i++)
542 output[i] = history[i] + result[i];
543 for (i = 256; i < 896; i++)
544 output[i] = result[i];
545 for (i = 0; i < 256; i++)
546 history[i] = result[896 + i];
549 static void apply_gain(DBEContext *s, int begin, int end, float *output)
551 if (begin == 960 && end == 960)
555 s->fdsp->vector_fmul_scalar(output, output, gain_tab[end], FRAME_SAMPLES);
557 float a = gain_tab[begin] * (1.0f / (FRAME_SAMPLES - 1));
558 float b = gain_tab[end ] * (1.0f / (FRAME_SAMPLES - 1));
561 for (i = 0; i < FRAME_SAMPLES; i++)
562 output[i] *= a * (FRAME_SAMPLES - i - 1) + b * i;
566 static int filter_frame(DBEContext *s, AVFrame *frame)
568 const uint8_t *reorder;
571 if (s->nb_channels == 4)
572 reorder = ch_reorder_4;
573 else if (s->nb_channels == 6)
574 reorder = ch_reorder_6;
575 else if (s->nb_programs == 1 && !(s->avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE))
576 reorder = ch_reorder_8;
578 reorder = ch_reorder_n;
580 frame->nb_samples = FRAME_SAMPLES;
581 if ((ret = ff_get_buffer(s->avctx, frame, 0)) < 0)
584 for (ch = 0; ch < s->nb_channels; ch++) {
585 float *output = (float *)frame->extended_data[reorder[ch]];
586 transform(s, &s->channels[0][ch], s->history[ch], output);
587 transform(s, &s->channels[1][ch], s->history[ch], output + FRAME_SAMPLES / 2);
588 apply_gain(s, s->begin_gain[ch], s->end_gain[ch], output);
594 static int dolby_e_decode_frame(AVCodecContext *avctx, void *data,
595 int *got_frame_ptr, AVPacket *avpkt)
597 DBEContext *s = avctx->priv_data;
601 return AVERROR_INVALIDDATA;
603 hdr = AV_RB24(avpkt->data);
604 if ((hdr & 0xfffffe) == 0x7888e) {
606 } else if ((hdr & 0xffffe0) == 0x788e0) {
608 } else if ((hdr & 0xfffe00) == 0x78e00) {
611 av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
612 return AVERROR_INVALIDDATA;
615 s->word_bytes = s->word_bits + 7 >> 3;
616 s->input = avpkt->data + s->word_bytes;
617 s->input_size = avpkt->size / s->word_bytes - 1;
618 s->key_present = hdr >> 24 - s->word_bits & 1;
620 if ((ret = parse_metadata(s)) < 0)
623 if (s->nb_programs > 1 && !s->multi_prog_warned) {
624 av_log(avctx, AV_LOG_WARNING, "Stream has %d programs (configuration %d), "
625 "channels will be output in native order.\n", s->nb_programs, s->prog_conf);
626 s->multi_prog_warned = 1;
629 switch (s->nb_channels) {
631 avctx->channel_layout = AV_CH_LAYOUT_4POINT0;
634 avctx->channel_layout = AV_CH_LAYOUT_5POINT1;
637 avctx->channel_layout = AV_CH_LAYOUT_7POINT1;
641 avctx->channels = s->nb_channels;
642 avctx->sample_rate = sample_rate_tab[s->fr_code];
643 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
645 i = s->nb_channels / 2;
647 if ((ret = parse_audio(s, 0, i, 0)) < 0)
649 if ((ret = parse_audio(s, i, j, 0)) < 0)
651 if ((ret = parse_metadata_ext(s)) < 0)
653 if ((ret = parse_audio(s, 0, i, 1)) < 0)
655 if ((ret = parse_audio(s, i, j, 1)) < 0)
657 if ((ret = parse_meter(s)) < 0)
659 if ((ret = filter_frame(s, data)) < 0)
666 static av_cold void dolby_e_flush(AVCodecContext *avctx)
668 DBEContext *s = avctx->priv_data;
670 memset(s->history, 0, sizeof(s->history));
673 static av_cold int dolby_e_close(AVCodecContext *avctx)
675 DBEContext *s = avctx->priv_data;
678 for (i = 0; i < 3; i++)
679 ff_mdct_end(&s->imdct[i]);
686 static av_cold void init_tables(void)
690 for (i = 1; i < 17; i++)
691 mantissa_tab1[i][0] = 1.0f / (1 << i - 1);
693 for (i = 2; i < 16; i++) {
694 mantissa_tab1[i][1] = 1.0f / ((1 << i) - 1);
695 mantissa_tab1[i][2] = 0.5f / ((1 << i) - 1);
696 mantissa_tab1[i][3] = 0.25f / ((1 << i) - 1);
699 mantissa_tab1[i][1] = 0.5f / (1 << 15);
700 mantissa_tab1[i][2] = 0.75f / (1 << 15);
701 mantissa_tab1[i][3] = 0.875f / (1 << 15);
703 for (i = 1; i < 17; i++) {
704 mantissa_tab2[i][1] = mantissa_tab1[i][0] * 0.5f;
705 mantissa_tab2[i][2] = mantissa_tab1[i][0] * 0.75f;
706 mantissa_tab2[i][3] = mantissa_tab1[i][0] * 0.875f;
707 for (j = 1; j < 4; j++)
708 mantissa_tab3[i][j] = 1.0f / (1 << i) + 1.0f / (1 << j) - 1.0f / (1 << i + j);
711 mantissa_tab3[1][3] = 0.6875f;
713 for (i = 0; i < 25; i++) {
714 exponent_tab[i * 2 ] = 1.0f / (1 << i);
715 exponent_tab[i * 2 + 1] = M_SQRT1_2 / (1 << i);
718 for (i = 1; i < 1024; i++)
719 gain_tab[i] = exp2f((i - 960) / 64.0f);
722 ff_kbd_window_init(window, 3.0f, 128);
723 for (i = 0; i < 128; i++)
724 window[128 + i] = window[127 - i];
727 for (i = 0; i < 192; i++)
728 window[256 + i] = start_window[i];
731 for (i = 0; i < 192; i++)
732 window[448 + i] = short_window2[i];
733 for (i = 0; i < 64; i++)
734 window[640 + i] = window[63 - i];
737 for (i = 0; i < 64; i++)
738 window[704 + i] = short_window3[i];
739 for (i = 0; i < 192; i++)
740 window[768 + i] = window[64 + i];
743 for (i = 0; i < 128; i++)
744 window[960 + i] = window[i];
745 for (i = 0; i < 64; i++)
746 window[1088 + i] = 1.0f;
749 ff_kbd_window_init(window + 1408, 3.0f, 256);
750 for (i = 0; i < 640; i++)
751 window[1664 + i] = 1.0f;
752 for (i = 0; i < 256; i++)
753 window[2304 + i] = window[1152 + i] = window[1663 - i];
756 for (i = 0; i < 192; i++)
757 window[2560 + i] = window[447 - i];
760 for (i = 0; i < 256; i++)
761 window[2752 + i] = window[703 - i];
764 for (i = 0; i < 256; i++)
765 window[3008 + i] = window[959 - i];
768 for (i = 0; i < 448; i++)
769 window[3264 + i] = window[1407 - i];
772 static av_cold int dolby_e_init(AVCodecContext *avctx)
774 static AVOnce init_once = AV_ONCE_INIT;
775 DBEContext *s = avctx->priv_data;
778 if (ff_thread_once(&init_once, init_tables))
779 return AVERROR_UNKNOWN;
781 for (i = 0; i < 3; i++)
782 if (ff_mdct_init(&s->imdct[i], imdct_bits_tab[i], 1, 2.0) < 0)
783 return AVERROR(ENOMEM);
785 if (!(s->fdsp = avpriv_float_dsp_alloc(0)))
786 return AVERROR(ENOMEM);
788 s->multi_prog_warned = !!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE);
793 AVCodec ff_dolby_e_decoder = {
795 .long_name = NULL_IF_CONFIG_SMALL("Dolby E"),
796 .type = AVMEDIA_TYPE_AUDIO,
797 .id = AV_CODEC_ID_DOLBY_E,
798 .priv_data_size = sizeof(DBEContext),
799 .init = dolby_e_init,
800 .decode = dolby_e_decode_frame,
801 .close = dolby_e_close,
802 .flush = dolby_e_flush,
803 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
804 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE },
805 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,