FFmpeg
dolby_e.c
Go to the documentation of this file.
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 
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 
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 
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 
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 
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 
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 
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 
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 
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:
631  break;
632  case 6:
634  break;
635  case 8:
637  break;
638  }
639 
640  avctx->channels = s->nb_channels;
641  avctx->sample_rate = sample_rate_tab[s->fr_code];
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 
666 {
667  DBEContext *s = avctx->priv_data;
668 
669  memset(s->history, 0, sizeof(s->history));
670 }
671 
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 
685 static av_cold void init_tables(void)
686 {
687  int i, j;
688 
689  for (i = 1; i < 17; i++)
690  mantissa_tab1[i][0] = 1.0f / (1 << i - 1);
691 
692  for (i = 2; i < 16; i++) {
693  mantissa_tab1[i][1] = 1.0f / ((1 << i) - 1);
694  mantissa_tab1[i][2] = 0.5f / ((1 << i) - 1);
695  mantissa_tab1[i][3] = 0.25f / ((1 << i) - 1);
696  }
697 
698  mantissa_tab1[i][1] = 0.5f / (1 << 15);
699  mantissa_tab1[i][2] = 0.75f / (1 << 15);
700  mantissa_tab1[i][3] = 0.875f / (1 << 15);
701 
702  for (i = 1; i < 17; i++) {
703  mantissa_tab2[i][1] = mantissa_tab1[i][0] * 0.5f;
704  mantissa_tab2[i][2] = mantissa_tab1[i][0] * 0.75f;
705  mantissa_tab2[i][3] = mantissa_tab1[i][0] * 0.875f;
706  for (j = 1; j < 4; j++)
707  mantissa_tab3[i][j] = 1.0f / (1 << i) + 1.0f / (1 << j) - 1.0f / (1 << i + j);
708  }
709 
710  mantissa_tab3[1][3] = 0.6875f;
711 
712  for (i = 0; i < 25; i++) {
713  exponent_tab[i * 2 ] = 1.0f / (1 << i);
714  exponent_tab[i * 2 + 1] = M_SQRT1_2 / (1 << i);
715  }
716 
717  for (i = 1; i < 1024; i++)
718  gain_tab[i] = exp2f((i - 960) / 64.0f);
719 
720  // short 1
721  ff_kbd_window_init(window, 3.0f, 128);
722  for (i = 0; i < 128; i++)
723  window[128 + i] = window[127 - i];
724 
725  // start
726  for (i = 0; i < 192; i++)
727  window[256 + i] = start_window[i];
728 
729  // short 2
730  for (i = 0; i < 192; i++)
731  window[448 + i] = short_window2[i];
732  for (i = 0; i < 64; i++)
733  window[640 + i] = window[63 - i];
734 
735  // short 3
736  for (i = 0; i < 64; i++)
737  window[704 + i] = short_window3[i];
738  for (i = 0; i < 192; i++)
739  window[768 + i] = window[64 + i];
740 
741  // bridge
742  for (i = 0; i < 128; i++)
743  window[960 + i] = window[i];
744  for (i = 0; i < 64; i++)
745  window[1088 + i] = 1.0f;
746 
747  // long
748  ff_kbd_window_init(window + 1408, 3.0f, 256);
749  for (i = 0; i < 640; i++)
750  window[1664 + i] = 1.0f;
751  for (i = 0; i < 256; i++)
752  window[2304 + i] = window[1152 + i] = window[1663 - i];
753 
754  // reverse start
755  for (i = 0; i < 192; i++)
756  window[2560 + i] = window[447 - i];
757 
758  // reverse short 2
759  for (i = 0; i < 256; i++)
760  window[2752 + i] = window[703 - i];
761 
762  // reverse short 3
763  for (i = 0; i < 256; i++)
764  window[3008 + i] = window[959 - i];
765 
766  // reverse bridge
767  for (i = 0; i < 448; i++)
768  window[3264 + i] = window[1407 - i];
769 }
770 
772 {
773  static AVOnce init_once = AV_ONCE_INIT;
774  DBEContext *s = avctx->priv_data;
775  int i;
776 
777  if (ff_thread_once(&init_once, init_tables))
778  return AVERROR_UNKNOWN;
779 
780  for (i = 0; i < 3; i++)
781  if (ff_mdct_init(&s->imdct[i], imdct_bits_tab[i], 1, 2.0) < 0)
782  return AVERROR(ENOMEM);
783 
784  if (!(s->fdsp = avpriv_float_dsp_alloc(0)))
785  return AVERROR(ENOMEM);
786 
787  s->multi_prog_warned = !!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE);
788  s->avctx = avctx;
789  return 0;
790 }
791 
793  .name = "dolby_e",
794  .long_name = NULL_IF_CONFIG_SMALL("Dolby E"),
795  .type = AVMEDIA_TYPE_AUDIO,
796  .id = AV_CODEC_ID_DOLBY_E,
797  .priv_data_size = sizeof(DBEContext),
798  .init = dolby_e_init,
800  .close = dolby_e_close,
801  .flush = dolby_e_flush,
805 };
ch_reorder_6
static const uint8_t ch_reorder_6[6]
Definition: dolby_e.h:129
mantissa_tab2
static float mantissa_tab2[17][4]
Definition: dolby_e.h:640
AVCodec
AVCodec.
Definition: avcodec.h:3481
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
nb_programs_tab
static const uint8_t nb_programs_tab[MAX_PROG_CONF+1]
Definition: dolby_e.h:115
dolby_e_close
static av_cold int dolby_e_close(AVCodecContext *avctx)
Definition: dolby_e.c:672
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
AVERROR
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
DBEGroup::exp_ofs
uint16_t exp_ofs
Definition: dolby_e.h:50
lfe_channel_tab
static const int8_t lfe_channel_tab[MAX_PROG_CONF+1]
Definition: dolby_e.h:123
dolby_e_init
static av_cold int dolby_e_init(AVCodecContext *avctx)
Definition: dolby_e.c:771
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2276
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:2225
n
int n
Definition: avisynth_c.h:760
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:686
thread.h
log_add_tab
static const uint8_t log_add_tab[212]
Definition: dolby_e.h:615
ch
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
count
void INT64 INT64 count
Definition: avisynth_c.h:767
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
dc_code_tab
static const uint8_t dc_code_tab[5]
Definition: dolby_e.h:364
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
internal.h
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
b
#define b
Definition: input.c:41
short_window2
static const float short_window2[192]
Definition: dolby_e.h:292
data
const char data[16]
Definition: mxf.c:91
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:169
nb_mstr_exp_tab
static const uint8_t nb_mstr_exp_tab[4]
Definition: dolby_e.h:139
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
AVCodecContext::request_channel_layout
uint64_t request_channel_layout
Request decoder to use this channel layout if it can (0 for default)
Definition: avcodec.h:2283
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
mantissa_tab1
static float mantissa_tab1[17][4]
Definition: dolby_e.h:639
win
static float win(SuperEqualizerContext *s, float n, int N)
Definition: af_superequalizer.c:119
exponent_tab
static float exponent_tab[50]
Definition: dolby_e.h:642
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
FRAME_SAMPLES
#define FRAME_SAMPLES
Definition: dolby_e.h:33
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
parse_bit_alloc
static int parse_bit_alloc(DBEContext *s, DBEChannel *c)
Definition: dolby_e.c:281
window
static SDL_Window * window
Definition: ffplay.c:367
convert_input
static int convert_input(DBEContext *s, int nb_words, int key)
Definition: dolby_e.c:55
start
void INT64 start
Definition: avisynth_c.h:767
misc_decay_tab
static const uint16_t misc_decay_tab[3][2][2]
Definition: dolby_e.h:380
DBEContext
Definition: dolby_e.h:77
nb_channels_tab
static const uint8_t nb_channels_tab[MAX_PROG_CONF+1]
Definition: dolby_e.h:119
lwc_adj_tab
static const int16_t lwc_adj_tab[7]
Definition: dolby_e.h:611
parse_mantissas
static int parse_mantissas(DBEContext *s, DBEChannel *c)
Definition: dolby_e.c:358
src
#define src
Definition: vp8dsp.c:254
slow_decay_tab
static const uint16_t slow_decay_tab[2][2]
Definition: dolby_e.h:378
mantissa_size2
static const uint8_t mantissa_size2[16][4]
Definition: dolby_e.h:232
transform
static void transform(DBEContext *s, DBEChannel *c, float *history, float *output)
Definition: dolby_e.c:523
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:162
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:84
parse_audio
static int parse_audio(DBEContext *s, int start, int end, int seg_id)
Definition: dolby_e.c:464
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
dolby_e_flush
static av_cold void dolby_e_flush(AVCodecContext *avctx)
Definition: dolby_e.c:665
s
#define s(width, name)
Definition: cbs_vp9.c:257
g
const char * g
Definition: vf_curves.c:115
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
frm_ofs_tab
static const DBEGroup *const frm_ofs_tab[2][4]
Definition: dolby_e.h:220
short_window3
static const float short_window3[64]
Definition: dolby_e.h:345
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
parse_meter
static int parse_meter(DBEContext *s)
Definition: dolby_e.c:490
parse_key
static int parse_key(DBEContext *s)
Definition: dolby_e.c:43
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
sample_rate_tab
static const uint16_t sample_rate_tab[16]
Definition: dolby_e.h:133
exp2f
#define exp2f(x)
Definition: libm.h:293
get_bits.h
unbias_exponents
static void unbias_exponents(DBEContext *s, DBEChannel *c, DBEGroup *g)
Definition: dolby_e.c:157
AV_CODEC_ID_DOLBY_E
@ AV_CODEC_ID_DOLBY_E
Definition: avcodec.h:649
lwc_gain_tab
static const int16_t lwc_gain_tab[11][7]
Definition: dolby_e.h:597
key
const char * key
Definition: hwcontext_opencl.c:168
f
#define f(width, name)
Definition: cbs_vp9.c:255
PutBitContext
Definition: put_bits.h:35
bit_allocate
static void bit_allocate(int nb_exponent, int nb_code, int fr_code, int *exp, int *bap, int fg_spc, int fg_ofs, int msk_mod, int snr_ofs)
Definition: dolby_e.c:232
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
band_low_tab
static const uint8_t band_low_tab[3]
Definition: dolby_e.h:372
band_ofs_tab
static const uint8_t band_ofs_tab[3][4]
Definition: dolby_e.h:368
slow_gain_tab
static const uint16_t slow_gain_tab[3][2][50]
Definition: dolby_e.h:504
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:160
MAX_MSTR_EXP
#define MAX_MSTR_EXP
Definition: dolby_e.h:44
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:500
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
parse_exponents
static int parse_exponents(DBEContext *s, DBEChannel *c)
Definition: dolby_e.c:174
MAX_BIAS_EXP
#define MAX_BIAS_EXP
Definition: dolby_e.h:45
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
parse_metadata
static int parse_metadata(DBEContext *s)
Definition: dolby_e.c:91
nb_groups_tab
static const uint8_t nb_groups_tab[4]
Definition: dolby_e.h:137
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
AV_CH_LAYOUT_5POINT1
#define AV_CH_LAYOUT_5POINT1
Definition: channel_layout.h:96
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2705
fast_gain_adj_tab
static const uint16_t fast_gain_adj_tab[3][2][62]
Definition: dolby_e.h:458
exp
int8_t exp
Definition: eval.c:72
dolby_e_decode_frame
static int dolby_e_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: dolby_e.c:593
AVOnce
#define AVOnce
Definition: thread.h:159
c
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
Definition: undefined.txt:32
float_dsp.h
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
FFTContext::imdct_half
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:108
DBEGroup::nb_exponent
uint8_t nb_exponent
Definition: dolby_e.h:48
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: avcodec.h:1033
FFTContext::imdct_calc
void(* imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:107
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1965
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
imdct_calc
static void imdct_calc(DBEContext *s, DBEGroup *g, float *result, float *values)
Definition: dolby_e.c:497
AVPacket::size
int size
Definition: avcodec.h:1478
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
MAX_PROG_CONF
#define MAX_PROG_CONF
Definition: dolby_e.h:35
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2233
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:170
fast_decay_tab
static const uint16_t fast_decay_tab[3][2][2][50]
Definition: dolby_e.h:386
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
ht_code_tab
static const uint8_t ht_code_tab[5]
Definition: dolby_e.h:366
start_window
static const float start_window[192]
Definition: dolby_e.h:239
apply_gain
static void apply_gain(DBEContext *s, int begin, int end, float *output)
Definition: dolby_e.c:548
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
skip_input
static int skip_input(DBEContext *s, int nb_words)
Definition: dolby_e.c:31
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:2226
calc_lowcomp
static void calc_lowcomp(int *msk_val)
Definition: dolby_e.c:199
hearing_thresh_tab
static const uint16_t hearing_thresh_tab[3][3][50]
Definition: dolby_e.h:542
FFTContext
Definition: fft.h:88
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
parse_metadata_ext
static int parse_metadata_ext(DBEContext *s)
Definition: dolby_e.c:150
filter_frame
static int filter_frame(DBEContext *s, AVFrame *frame)
Definition: dolby_e.c:565
AV_CH_LAYOUT_NATIVE
#define AV_CH_LAYOUT_NATIVE
Channel mask value used for AVCodecContext.request_channel_layout to indicate that the user requests ...
Definition: channel_layout.h:78
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
AV_CH_LAYOUT_7POINT1
#define AV_CH_LAYOUT_7POINT1
Definition: channel_layout.h:107
ch_reorder_n
static const uint8_t ch_reorder_n[8]
Definition: dolby_e.h:131
value
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 default value
Definition: writing_filters.txt:86
uint8_t
uint8_t
Definition: audio_convert.c:194
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
ret
ret
Definition: filter_design.txt:187
frame
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
Definition: filter_design.txt:264
gain_tab
static float gain_tab[1024]
Definition: dolby_e.h:643
log_add
static int log_add(int a, int b)
Definition: dolby_e.c:193
M_SQRT1_2
#define M_SQRT1_2
Definition: mathematics.h:58
DBEChannel
Definition: dolby_e.h:61
fft.h
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
ff_kbd_window_init
av_cold void ff_kbd_window_init(float *window, float alpha, int n)
Generate a Kaiser-Bessel Derived Window.
Definition: kbdwin.c:26
imdct_bits_tab
static const uint8_t imdct_bits_tab[3]
Definition: dolby_e.h:160
ch_reorder_8
static const uint8_t ch_reorder_8[8]
Definition: dolby_e.h:130
values
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 values
Definition: filter_design.txt:263
bap_tab
static const uint8_t bap_tab[64]
Definition: dolby_e.h:632
ch_reorder_4
static const uint8_t ch_reorder_4[4]
Definition: dolby_e.h:128
mem.h
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
parse_indices
static int parse_indices(DBEContext *s, DBEChannel *c)
Definition: dolby_e.c:327
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1592
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
mantissa_tab3
static float mantissa_tab3[17][4]
Definition: dolby_e.h:641
AV_CH_LAYOUT_4POINT0
#define AV_CH_LAYOUT_4POINT0
Definition: channel_layout.h:91
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
dolby_e.h
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition: internal.h:137
ff_dolby_e_decoder
AVCodec ff_dolby_e_decoder
Definition: dolby_e.c:792
parse_channel
static int parse_channel(DBEContext *s, int ch, int seg_id)
Definition: dolby_e.c:414
fast_gain_tab
static const uint16_t fast_gain_tab[8]
Definition: dolby_e.h:374
mantissa_size1
static const uint8_t mantissa_size1[16][4]
Definition: dolby_e.h:225
AV_RB24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:93
put_bits.h
init_tables
static av_cold void init_tables(void)
Definition: dolby_e.c:685
DBEGroup
Definition: dolby_e.h:47
MAX_GROUPS
#define MAX_GROUPS
Definition: dolby_e.h:40
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:94