vp9: assert -> av_assert and fix associated compile error.
[ffmpeg.git] / libavcodec / dolby_e.c
1 /*
2  * Copyright (C) 2017 foo86
3  *
4  * This file is part of FFmpeg.
5  *
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.
10  *
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.
15  *
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
19  */
20
21 #include "libavutil/float_dsp.h"
22 #include "libavutil/thread.h"
23 #include "libavutil/mem.h"
24
25 #include "internal.h"
26 #include "get_bits.h"
27 #include "put_bits.h"
28 #include "dolby_e.h"
29 #include "fft.h"
30
31 static int skip_input(DBEContext *s, int nb_words)
32 {
33     if (nb_words > s->input_size) {
34         av_log(s->avctx, AV_LOG_ERROR, "Packet too short\n");
35         return AVERROR_INVALIDDATA;
36     }
37
38     s->input      += nb_words * s->word_bytes;
39     s->input_size -= nb_words;
40     return 0;
41 }
42
43 static int parse_key(DBEContext *s)
44 {
45     if (s->key_present) {
46         uint8_t *key = s->input;
47         int      ret = skip_input(s, 1);
48         if (ret < 0)
49             return ret;
50         return AV_RB24(key) >> 24 - s->word_bits;
51     }
52     return 0;
53 }
54
55 static int convert_input(DBEContext *s, int nb_words, int key)
56 {
57     uint8_t *src = s->input;
58     uint8_t *dst = s->buffer;
59     PutBitContext pb;
60     int i;
61
62     av_assert0(nb_words <= 1024u);
63
64     if (nb_words > s->input_size) {
65         av_log(s->avctx, AV_LOG_ERROR, "Packet too short\n");
66         return AVERROR_INVALIDDATA;
67     }
68
69     switch (s->word_bits) {
70     case 16:
71         for (i = 0; i < nb_words; i++, src += 2, dst += 2)
72             AV_WB16(dst, AV_RB16(src) ^ key);
73         break;
74     case 20:
75         init_put_bits(&pb, s->buffer, sizeof(s->buffer));
76         for (i = 0; i < nb_words; i++, src += 3)
77             put_bits(&pb, 20, AV_RB24(src) >> 4 ^ key);
78         flush_put_bits(&pb);
79         break;
80     case 24:
81         for (i = 0; i < nb_words; i++, src += 3, dst += 3)
82             AV_WB24(dst, AV_RB24(src) ^ key);
83         break;
84     default:
85         av_assert0(0);
86     }
87
88     return init_get_bits(&s->gb, s->buffer, nb_words * s->word_bits);
89 }
90
91 static int parse_metadata(DBEContext *s)
92 {
93     int i, ret, key, mtd_size;
94
95     if ((key = parse_key(s)) < 0)
96         return key;
97     if ((ret = convert_input(s, 1, key)) < 0)
98         return ret;
99
100     skip_bits(&s->gb, 4);
101     mtd_size = get_bits(&s->gb, 10);
102     if (!mtd_size) {
103         av_log(s->avctx, AV_LOG_ERROR, "Invalid metadata size\n");
104         return AVERROR_INVALIDDATA;
105     }
106
107     if ((ret = convert_input(s, mtd_size, key)) < 0)
108         return ret;
109
110     skip_bits(&s->gb, 14);
111     s->prog_conf = get_bits(&s->gb, 6);
112     if (s->prog_conf > MAX_PROG_CONF) {
113         av_log(s->avctx, AV_LOG_ERROR, "Invalid program configuration\n");
114         return AVERROR_INVALIDDATA;
115     }
116
117     s->nb_channels = nb_channels_tab[s->prog_conf];
118     s->nb_programs = nb_programs_tab[s->prog_conf];
119
120     s->fr_code      = get_bits(&s->gb, 4);
121     s->fr_code_orig = get_bits(&s->gb, 4);
122     if (!sample_rate_tab[s->fr_code] ||
123         !sample_rate_tab[s->fr_code_orig]) {
124         av_log(s->avctx, AV_LOG_ERROR, "Invalid frame rate code\n");
125         return AVERROR_INVALIDDATA;
126     }
127
128     skip_bits_long(&s->gb, 88);
129     for (i = 0; i < s->nb_channels; i++)
130         s->ch_size[i] = get_bits(&s->gb, 10);
131     s->mtd_ext_size = get_bits(&s->gb, 8);
132     s->meter_size   = get_bits(&s->gb, 8);
133
134     skip_bits_long(&s->gb, 10 * s->nb_programs);
135     for (i = 0; i < s->nb_channels; i++) {
136         s->rev_id[i]     = get_bits(&s->gb,  4);
137         skip_bits1(&s->gb);
138         s->begin_gain[i] = get_bits(&s->gb, 10);
139         s->end_gain[i]   = get_bits(&s->gb, 10);
140     }
141
142     if (get_bits_left(&s->gb) < 0) {
143         av_log(s->avctx, AV_LOG_ERROR, "Read past end of metadata\n");
144         return AVERROR_INVALIDDATA;
145     }
146
147     return skip_input(s, mtd_size + 1);
148 }
149
150 static int parse_metadata_ext(DBEContext *s)
151 {
152     if (s->mtd_ext_size)
153         return skip_input(s, s->key_present + s->mtd_ext_size + 1);
154     return 0;
155 }
156
157 static void unbias_exponents(DBEContext *s, DBEChannel *c, DBEGroup *g)
158 {
159     int mstr_exp[MAX_MSTR_EXP];
160     int bias_exp[MAX_BIAS_EXP];
161     int i, j, k;
162
163     for (i = 0; i < c->nb_mstr_exp; i++)
164         mstr_exp[i] = get_bits(&s->gb, 2) * 6;
165
166     for (i = 0; i < g->nb_exponent; i++)
167         bias_exp[i] = get_bits(&s->gb, 5);
168
169     for (i = k = 0; i < c->nb_mstr_exp; i++)
170         for (j = 0; j < g->nb_bias_exp[i]; j++, k++)
171             c->exponents[g->exp_ofs + k] = mstr_exp[i] + bias_exp[k];
172 }
173
174 static int parse_exponents(DBEContext *s, DBEChannel *c)
175 {
176     DBEGroup *p, *g;
177     int i;
178
179     for (i = 0, p = NULL, g = c->groups; i < c->nb_groups; i++, p = g, g++) {
180         c->exp_strategy[i] = !i || g->nb_exponent != p->nb_exponent || get_bits1(&s->gb);
181         if (c->exp_strategy[i]) {
182             unbias_exponents(s, c, g);
183         } else {
184             memcpy(c->exponents + g->exp_ofs,
185                    c->exponents + p->exp_ofs,
186                    g->nb_exponent * sizeof(c->exponents[0]));
187         }
188     }
189
190     return 0;
191 }
192
193 static inline int log_add(int a, int b)
194 {
195     int c = FFABS(a - b) >> 1;
196     return FFMAX(a, b) + log_add_tab[FFMIN(c, 211)];
197 }
198
199 static void calc_lowcomp(int *msk_val)
200 {
201     int lwc_val[17] = { 0 };
202     int i, j, k;
203
204     for (i = 0; i < 11; i++) {
205         int max_j = 0;
206         int max_v = INT_MIN;
207         int thr   = 0;
208
209         for (j = FFMAX(i - 3, 0), k = 0; j <= i + 3; j++, k++) {
210             int v = msk_val[j] + lwc_gain_tab[i][k];
211             if (v > max_v) {
212                 max_j = j;
213                 max_v = v;
214             }
215             thr = log_add(thr, v);
216         }
217
218         if (msk_val[i] < thr) {
219             for (j = FFMAX(max_j - 3, 0),
220                  k = FFMAX(3 - max_j, 0);
221                  j <= max_j + 3; j++, k++)
222                 lwc_val[j] += lwc_adj_tab[k];
223         }
224     }
225
226     for (i = 0; i < 16; i++) {
227         int v = FFMAX(lwc_val[i], -512);
228         msk_val[i] = FFMAX(msk_val[i] + v, 0);
229     }
230 }
231
232 static void bit_allocate(int nb_exponent, int nb_code, int fr_code,
233                          int *exp, int *bap,
234                          int fg_spc, int fg_ofs, int msk_mod, int snr_ofs)
235 {
236     int msk_val[MAX_BIAS_EXP];
237     int psd_val[MAX_BIAS_EXP];
238     int fast_leak  = 0;
239     int slow_leak  = 0;
240     int dc_code    = dc_code_tab[fr_code - 1];
241     int ht_code    = ht_code_tab[fr_code - 1];
242     int fast_gain  = fast_gain_tab[fg_ofs];
243     int slow_decay = slow_decay_tab[dc_code][msk_mod];
244     int misc_decay = misc_decay_tab[nb_code][dc_code][msk_mod];
245     const uint16_t *slow_gain      = slow_gain_tab[nb_code][msk_mod];
246     const uint16_t *fast_decay     = fast_decay_tab[nb_code][dc_code][msk_mod];
247     const uint16_t *fast_gain_adj  = fast_gain_adj_tab[nb_code][dc_code];
248     const uint16_t *hearing_thresh = hearing_thresh_tab[nb_code][ht_code];
249     int i;
250
251     for (i = 0; i < nb_exponent; i++)
252         psd_val[i] = (48 - exp[i]) * 64;
253
254     fast_gain_adj += band_ofs_tab[nb_code][fg_spc];
255     for (i = 0; i < nb_exponent; i++) {
256         fast_leak = log_add(fast_leak  - fast_decay[i],
257                             psd_val[i] - fast_gain + fast_gain_adj[i]);
258         slow_leak = log_add(slow_leak  - slow_decay,
259                             psd_val[i] - slow_gain[i]);
260         msk_val[i] = FFMAX(fast_leak, slow_leak);
261     }
262
263     fast_leak = 0;
264     for (i = nb_exponent - 1; i > band_low_tab[nb_code]; i--) {
265         fast_leak = log_add(fast_leak - misc_decay, psd_val[i] - fast_gain);
266         msk_val[i] = FFMAX(msk_val[i], fast_leak);
267     }
268
269     for (i = 0; i < nb_exponent; i++)
270         msk_val[i] = FFMAX(msk_val[i], hearing_thresh[i]);
271
272     if (!nb_code)
273         calc_lowcomp(msk_val);
274
275     for (i = 0; i < nb_exponent; i++) {
276         int v = 16 * (snr_ofs - 64) + psd_val[i] - msk_val[i] >> 5;
277         bap[i] = bap_tab[av_clip_uintp2(v, 6)];
278     }
279 }
280
281 static int parse_bit_alloc(DBEContext *s, DBEChannel *c)
282 {
283     DBEGroup *p, *g;
284     int bap_strategy[MAX_GROUPS], fg_spc[MAX_GROUPS];
285     int fg_ofs[MAX_GROUPS], msk_mod[MAX_GROUPS];
286     int i, snr_ofs;
287
288     for (i = 0; i < c->nb_groups; i++) {
289         bap_strategy[i] = !i || get_bits1(&s->gb);
290         if (bap_strategy[i]) {
291              fg_spc[i] = get_bits(&s->gb, 2);
292              fg_ofs[i] = get_bits(&s->gb, 3);
293             msk_mod[i] = get_bits1(&s->gb);
294         } else {
295              fg_spc[i] =  fg_spc[i - 1];
296              fg_ofs[i] =  fg_ofs[i - 1];
297             msk_mod[i] = msk_mod[i - 1];
298         }
299     }
300
301     if (get_bits1(&s->gb)) {
302         avpriv_report_missing_feature(s->avctx, "Delta bit allocation");
303         return AVERROR_PATCHWELCOME;
304     }
305
306     snr_ofs = get_bits(&s->gb, 8);
307     if (!snr_ofs) {
308         memset(c->bap, 0, sizeof(c->bap));
309         return 0;
310     }
311
312     for (i = 0, p = NULL, g = c->groups; i < c->nb_groups; i++, p = g, g++) {
313         if (c->exp_strategy[i] || bap_strategy[i]) {
314             bit_allocate(g->nb_exponent, g->imdct_idx, s->fr_code,
315                          c->exponents + g->exp_ofs, c->bap + g->exp_ofs,
316                          fg_spc[i], fg_ofs[i], msk_mod[i], snr_ofs);
317         } else {
318             memcpy(c->bap + g->exp_ofs,
319                    c->bap + p->exp_ofs,
320                    g->nb_exponent * sizeof(c->bap[0]));
321         }
322     }
323
324     return 0;
325 }
326
327 static int parse_indices(DBEContext *s, DBEChannel *c)
328 {
329     DBEGroup *p, *g;
330     int i, j;
331
332     for (i = 0, p = NULL, g = c->groups; i < c->nb_groups; i++, p = g, g++) {
333         if (get_bits1(&s->gb)) {
334             int start = get_bits(&s->gb, 6);
335
336             if (start > g->nb_exponent) {
337                 av_log(s->avctx, AV_LOG_ERROR, "Invalid start index\n");
338                 return AVERROR_INVALIDDATA;
339             }
340
341             for (j = 0; j < start; j++)
342                 c->idx[g->exp_ofs + j] = 0;
343
344             for (; j < g->nb_exponent; j++)
345                 c->idx[g->exp_ofs + j] = get_bits(&s->gb, 2);
346         } else if (i && g->nb_exponent == p->nb_exponent) {
347             memcpy(c->idx + g->exp_ofs,
348                    c->idx + p->exp_ofs,
349                    g->nb_exponent * sizeof(c->idx[0]));
350         } else {
351             memset(c->idx + g->exp_ofs, 0, g->nb_exponent * sizeof(c->idx[0]));
352         }
353     }
354
355     return 0;
356 }
357
358 static int parse_mantissas(DBEContext *s, DBEChannel *c)
359 {
360     DBEGroup *g;
361     int i, j, k;
362
363     for (i = 0, g = c->groups; i < c->nb_groups; i++, g++) {
364         float *mnt = c->mantissas + g->mnt_ofs;
365
366         for (j = 0; j < g->nb_exponent; j++) {
367             int bap     = c->bap[g->exp_ofs + j];
368             int idx     = c->idx[g->exp_ofs + j];
369             int size1   = mantissa_size1[bap][idx];
370             int count   = g->nb_mantissa[j];
371             float exp   = exponent_tab[c->exponents[g->exp_ofs + j]];
372             float scale = mantissa_tab1[size1][idx] * exp;
373
374             if (!size1) {
375                 memset(mnt, 0, count * sizeof(*mnt));
376             } else if (idx) {
377                 int values[100];
378                 int escape = -(1 << size1 - 1);
379
380                 for (k = 0; k < count; k++)
381                     values[k] = get_sbits(&s->gb, size1);
382
383                 for (k = 0; k < count; k++) {
384                     if (values[k] != escape) {
385                         mnt[k] = values[k] * scale;
386                     } else {
387                         int size2 = mantissa_size2[bap][idx];
388                         int value = get_sbits(&s->gb, size2);
389                         float a = mantissa_tab2[size2][idx];
390                         float b = mantissa_tab3[size2][idx];
391                         if (value < 0)
392                             mnt[k] = ((value + 1) * a - b) * exp;
393                         else
394                             mnt[k] = (value * a + b) * exp;
395                     }
396                 }
397             } else {
398                 for (k = 0; k < count; k++)
399                     mnt[k] = get_sbits(&s->gb, size1) * scale;
400             }
401
402             mnt += count;
403         }
404
405         for (; j < g->nb_exponent + c->bw_code; j++) {
406             memset(mnt, 0, g->nb_mantissa[j] * sizeof(*mnt));
407             mnt += g->nb_mantissa[j];
408         }
409     }
410
411     return 0;
412 }
413
414 static int parse_channel(DBEContext *s, int ch, int seg_id)
415 {
416     DBEChannel *c = &s->channels[seg_id][ch];
417     int i, ret;
418
419     if (s->rev_id[ch] > 1) {
420         avpriv_report_missing_feature(s->avctx, "Encoder revision %d", s->rev_id[ch]);
421         return AVERROR_PATCHWELCOME;
422     }
423
424     if (ch == lfe_channel_tab[s->prog_conf]) {
425         c->gr_code = 3;
426         c->bw_code = 29;
427     } else {
428         c->gr_code = get_bits(&s->gb, 2);
429         c->bw_code = get_bits(&s->gb, 3);
430         if (c->gr_code == 3) {
431             av_log(s->avctx, AV_LOG_ERROR, "Invalid group type code\n");
432             return AVERROR_INVALIDDATA;
433         }
434     }
435
436     c->nb_groups   = nb_groups_tab[c->gr_code];
437     c->nb_mstr_exp = nb_mstr_exp_tab[c->gr_code];
438
439     for (i = 0; i < c->nb_groups; i++) {
440         c->groups[i] = frm_ofs_tab[seg_id][c->gr_code][i];
441         if (c->nb_mstr_exp == 2) {
442             c->groups[i].nb_exponent    -= c->bw_code;
443             c->groups[i].nb_bias_exp[1] -= c->bw_code;
444         }
445     }
446
447     if ((ret = parse_exponents(s, c)) < 0)
448         return ret;
449     if ((ret = parse_bit_alloc(s, c)) < 0)
450         return ret;
451     if ((ret = parse_indices(s, c)) < 0)
452         return ret;
453     if ((ret = parse_mantissas(s, c)) < 0)
454         return ret;
455
456     if (get_bits_left(&s->gb) < 0) {
457         av_log(s->avctx, AV_LOG_ERROR, "Read past end of channel %d\n", ch);
458         return AVERROR_INVALIDDATA;
459     }
460
461     return 0;
462 }
463
464 static int parse_audio(DBEContext *s, int start, int end, int seg_id)
465 {
466     int ch, ret, key;
467
468     if ((key = parse_key(s)) < 0)
469         return key;
470
471     for (ch = start; ch < end; ch++) {
472         if (!s->ch_size[ch]) {
473             s->channels[seg_id][ch].nb_groups = 0;
474             continue;
475         }
476         if ((ret = convert_input(s, s->ch_size[ch], key)) < 0)
477             return ret;
478         if ((ret = parse_channel(s, ch, seg_id)) < 0) {
479             if (s->avctx->err_recognition & AV_EF_EXPLODE)
480                 return ret;
481             s->channels[seg_id][ch].nb_groups = 0;
482         }
483         if ((ret = skip_input(s, s->ch_size[ch])) < 0)
484             return ret;
485     }
486
487     return skip_input(s, 1);
488 }
489
490 static int parse_meter(DBEContext *s)
491 {
492     if (s->meter_size)
493         return skip_input(s, s->key_present + s->meter_size + 1);
494     return 0;
495 }
496
497 static void imdct_calc(DBEContext *s, DBEGroup *g, float *result, float *values)
498 {
499     FFTContext *imdct = &s->imdct[g->imdct_idx];
500     int n   = 1 << imdct_bits_tab[g->imdct_idx];
501     int n2  = n >> 1;
502     int i;
503
504     switch (g->imdct_phs) {
505     case 0:
506         imdct->imdct_half(imdct, result, values);
507         for (i = 0; i < n2; i++)
508             result[n2 + i] = result[n2 - i - 1];
509         break;
510     case 1:
511         imdct->imdct_calc(imdct, result, values);
512         break;
513     case 2:
514         imdct->imdct_half(imdct, result + n2, values);
515         for (i = 0; i < n2; i++)
516             result[i] = -result[n - i - 1];
517         break;
518     default:
519         av_assert0(0);
520     }
521 }
522
523 static void transform(DBEContext *s, DBEChannel *c, float *history, float *output)
524 {
525     LOCAL_ALIGNED_32(float, buffer, [2048]);
526     LOCAL_ALIGNED_32(float, result, [1152]);
527     DBEGroup *g;
528     int i;
529
530     memset(result, 0, 1152 * sizeof(float));
531     for (i = 0, g = c->groups; i < c->nb_groups; i++, g++) {
532         float *src = buffer + g->src_ofs;
533         float *dst = result + g->dst_ofs;
534         float *win = window + g->win_ofs;
535
536         imdct_calc(s, g, buffer, c->mantissas + g->mnt_ofs);
537         s->fdsp->vector_fmul_add(dst, src, win, dst, g->win_len);
538     }
539
540     for (i = 0; i < 256; i++)
541         output[i] = history[i] + result[i];
542     for (i = 256; i < 896; i++)
543         output[i] = result[i];
544     for (i = 0; i < 256; i++)
545         history[i] = result[896 + i];
546 }
547
548 static void apply_gain(DBEContext *s, int begin, int end, float *output)
549 {
550     if (begin == 960 && end == 960)
551         return;
552
553     if (begin == end) {
554         s->fdsp->vector_fmul_scalar(output, output, gain_tab[end], FRAME_SAMPLES);
555     } else {
556         float a = gain_tab[begin] * (1.0f / (FRAME_SAMPLES - 1));
557         float b = gain_tab[end  ] * (1.0f / (FRAME_SAMPLES - 1));
558         int i;
559
560         for (i = 0; i < FRAME_SAMPLES; i++)
561             output[i] *= a * (FRAME_SAMPLES - i - 1) + b * i;
562     }
563 }
564
565 static int filter_frame(DBEContext *s, AVFrame *frame)
566 {
567     const uint8_t *reorder;
568     int ch, ret;
569
570     if (s->nb_channels == 4)
571         reorder = ch_reorder_4;
572     else if (s->nb_channels == 6)
573         reorder = ch_reorder_6;
574     else if (s->nb_programs == 1 && !(s->avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE))
575         reorder = ch_reorder_8;
576     else
577         reorder = ch_reorder_n;
578
579     frame->nb_samples = FRAME_SAMPLES;
580     if ((ret = ff_get_buffer(s->avctx, frame, 0)) < 0)
581         return ret;
582
583     for (ch = 0; ch < s->nb_channels; ch++) {
584         float *output = (float *)frame->extended_data[reorder[ch]];
585         transform(s, &s->channels[0][ch], s->history[ch], output);
586         transform(s, &s->channels[1][ch], s->history[ch], output + FRAME_SAMPLES / 2);
587         apply_gain(s, s->begin_gain[ch], s->end_gain[ch], output);
588     }
589
590     return 0;
591 }
592
593 static int dolby_e_decode_frame(AVCodecContext *avctx, void *data,
594                                 int *got_frame_ptr, AVPacket *avpkt)
595 {
596     DBEContext *s = avctx->priv_data;
597     int i, j, hdr, ret;
598
599     if (avpkt->size < 3)
600         return AVERROR_INVALIDDATA;
601
602     hdr = AV_RB24(avpkt->data);
603     if ((hdr & 0xfffffe) == 0x7888e) {
604         s->word_bits = 24;
605     } else if ((hdr & 0xffffe0) == 0x788e0) {
606         s->word_bits = 20;
607     } else if ((hdr & 0xfffe00) == 0x78e00) {
608         s->word_bits = 16;
609     } else {
610         av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
611         return AVERROR_INVALIDDATA;
612     }
613
614     s->word_bytes  = s->word_bits + 7 >> 3;
615     s->input       = avpkt->data + s->word_bytes;
616     s->input_size  = avpkt->size / s->word_bytes - 1;
617     s->key_present = hdr >> 24 - s->word_bits & 1;
618
619     if ((ret = parse_metadata(s)) < 0)
620         return ret;
621
622     if (s->nb_programs > 1 && !s->multi_prog_warned) {
623         av_log(avctx, AV_LOG_WARNING, "Stream has %d programs (configuration %d), "
624                "channels will be output in native order.\n", s->nb_programs, s->prog_conf);
625         s->multi_prog_warned = 1;
626     }
627
628     switch (s->nb_channels) {
629     case 4:
630         avctx->channel_layout = AV_CH_LAYOUT_4POINT0;
631         break;
632     case 6:
633         avctx->channel_layout = AV_CH_LAYOUT_5POINT1;
634         break;
635     case 8:
636         avctx->channel_layout = AV_CH_LAYOUT_7POINT1;
637         break;
638     }
639
640     avctx->channels    = s->nb_channels;
641     avctx->sample_rate = sample_rate_tab[s->fr_code];
642     avctx->sample_fmt  = AV_SAMPLE_FMT_FLTP;
643
644     i = s->nb_channels / 2;
645     j = s->nb_channels;
646     if ((ret = parse_audio(s, 0, i, 0)) < 0)
647         return ret;
648     if ((ret = parse_audio(s, i, j, 0)) < 0)
649         return ret;
650     if ((ret = parse_metadata_ext(s)) < 0)
651         return ret;
652     if ((ret = parse_audio(s, 0, i, 1)) < 0)
653         return ret;
654     if ((ret = parse_audio(s, i, j, 1)) < 0)
655         return ret;
656     if ((ret = parse_meter(s)) < 0)
657         return ret;
658     if ((ret = filter_frame(s, data)) < 0)
659         return ret;
660
661     *got_frame_ptr = 1;
662     return avpkt->size;
663 }
664
665 static av_cold void dolby_e_flush(AVCodecContext *avctx)
666 {
667     DBEContext *s = avctx->priv_data;
668
669     memset(s->history, 0, sizeof(s->history));
670 }
671
672 static av_cold int dolby_e_close(AVCodecContext *avctx)
673 {
674     DBEContext *s = avctx->priv_data;
675     int i;
676
677     for (i = 0; i < 3; i++)
678         ff_mdct_end(&s->imdct[i]);
679
680     av_freep(&s->fdsp);
681     return 0;
682 }
683
684 static av_cold int dolby_e_init(AVCodecContext *avctx)
685 {
686     static AVOnce init_once = AV_ONCE_INIT;
687     DBEContext *s = avctx->priv_data;
688     int i;
689
690     if (ff_thread_once(&init_once, init_tables))
691         return AVERROR_UNKNOWN;
692
693     for (i = 0; i < 3; i++)
694         if (ff_mdct_init(&s->imdct[i], imdct_bits_tab[i], 1, 2.0) < 0)
695             return AVERROR(ENOMEM);
696
697     if (!(s->fdsp = avpriv_float_dsp_alloc(0)))
698         return AVERROR(ENOMEM);
699
700     s->multi_prog_warned = !!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE);
701     s->avctx = avctx;
702     return 0;
703 }
704
705 AVCodec ff_dolby_e_decoder = {
706     .name           = "dolby_e",
707     .long_name      = NULL_IF_CONFIG_SMALL("Dolby E"),
708     .type           = AVMEDIA_TYPE_AUDIO,
709     .id             = AV_CODEC_ID_DOLBY_E,
710     .priv_data_size = sizeof(DBEContext),
711     .init           = dolby_e_init,
712     .decode         = dolby_e_decode_frame,
713     .close          = dolby_e_close,
714     .flush          = dolby_e_flush,
715     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
716     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE },
717     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
718 };