FFmpeg
dcaenc.c
Go to the documentation of this file.
1 /*
2  * DCA encoder
3  * Copyright (C) 2008-2012 Alexander E. Patrakov
4  * 2010 Benjamin Larsson
5  * 2011 Xiang Wang
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 #define FFT_FLOAT 0
25 #define FFT_FIXED_32 1
26 
27 #include "libavutil/avassert.h"
28 #include "libavutil/channel_layout.h"
29 #include "libavutil/common.h"
30 #include "libavutil/ffmath.h"
31 #include "libavutil/opt.h"
32 #include "avcodec.h"
33 #include "dca.h"
34 #include "dcaadpcm.h"
35 #include "dcamath.h"
36 #include "dca_core.h"
37 #include "dcadata.h"
38 #include "dcaenc.h"
39 #include "fft.h"
40 #include "internal.h"
41 #include "mathops.h"
42 #include "put_bits.h"
43 
44 #define MAX_CHANNELS 6
45 #define DCA_MAX_FRAME_SIZE 16384
46 #define DCA_HEADER_SIZE 13
47 #define DCA_LFE_SAMPLES 8
48 
49 #define DCAENC_SUBBANDS 32
50 #define SUBFRAMES 1
51 #define SUBSUBFRAMES 2
52 #define SUBBAND_SAMPLES (SUBFRAMES * SUBSUBFRAMES * 8)
53 #define AUBANDS 25
54 
55 #define COS_T(x) (c->cos_table[(x) & 2047])
56 
57 typedef struct CompressionOptions {
58  int adpcm_mode;
59 } CompressionOptions;
60 
61 typedef struct DCAEncContext {
62  AVClass *class;
63  PutBitContext pb;
64  DCAADPCMEncContext adpcm_ctx;
65  FFTContext mdct;
66  CompressionOptions options;
67  int frame_size;
68  int frame_bits;
69  int fullband_channels;
70  int channels;
71  int lfe_channel;
72  int samplerate_index;
73  int bitrate_index;
74  int channel_config;
75  const int32_t *band_interpolation;
76  const int32_t *band_spectrum;
77  int lfe_scale_factor;
78  softfloat lfe_quant;
79  int32_t lfe_peak_cb;
80  const int8_t *channel_order_tab; ///< channel reordering table, lfe and non lfe
81 
82  int32_t prediction_mode[MAX_CHANNELS][DCAENC_SUBBANDS];
83  int32_t adpcm_history[MAX_CHANNELS][DCAENC_SUBBANDS][DCA_ADPCM_COEFFS * 2];
84  int32_t history[MAX_CHANNELS][512]; /* This is a circular buffer */
85  int32_t *subband[MAX_CHANNELS][DCAENC_SUBBANDS];
86  int32_t quantized[MAX_CHANNELS][DCAENC_SUBBANDS][SUBBAND_SAMPLES];
87  int32_t peak_cb[MAX_CHANNELS][DCAENC_SUBBANDS];
88  int32_t diff_peak_cb[MAX_CHANNELS][DCAENC_SUBBANDS]; ///< expected peak of residual signal
89  int32_t downsampled_lfe[DCA_LFE_SAMPLES];
90  int32_t masking_curve_cb[SUBSUBFRAMES][256];
91  int32_t bit_allocation_sel[MAX_CHANNELS];
92  int abits[MAX_CHANNELS][DCAENC_SUBBANDS];
93  int scale_factor[MAX_CHANNELS][DCAENC_SUBBANDS];
94  softfloat quant[MAX_CHANNELS][DCAENC_SUBBANDS];
95  int32_t quant_index_sel[MAX_CHANNELS][DCA_CODE_BOOKS];
96  int32_t eff_masking_curve_cb[256];
97  int32_t band_masking_cb[32];
98  int32_t worst_quantization_noise;
99  int32_t worst_noise_ever;
100  int consumed_bits;
101  int consumed_adpcm_bits; ///< Number of bits to transmit ADPCM related info
102 
103  int32_t cos_table[2048];
104  int32_t band_interpolation_tab[2][512];
105  int32_t band_spectrum_tab[2][8];
106  int32_t auf[9][AUBANDS][256];
107  int32_t cb_to_add[256];
108  int32_t cb_to_level[2048];
109  int32_t lfe_fir_64i[512];
110 } DCAEncContext;
111 
112 /* Transfer function of outer and middle ear, Hz -> dB */
113 static double hom(double f)
114 {
115  double f1 = f / 1000;
116 
117  return -3.64 * pow(f1, -0.8)
118  + 6.8 * exp(-0.6 * (f1 - 3.4) * (f1 - 3.4))
119  - 6.0 * exp(-0.15 * (f1 - 8.7) * (f1 - 8.7))
120  - 0.0006 * (f1 * f1) * (f1 * f1);
121 }
122 
123 static double gammafilter(int i, double f)
124 {
125  double h = (f - fc[i]) / erb[i];
126 
127  h = 1 + h * h;
128  h = 1 / (h * h);
129  return 20 * log10(h);
130 }
131 
132 static int subband_bufer_alloc(DCAEncContext *c)
133 {
134  int ch, band;
135  int32_t *bufer = av_calloc(MAX_CHANNELS * DCAENC_SUBBANDS *
136  (SUBBAND_SAMPLES + DCA_ADPCM_COEFFS),
137  sizeof(int32_t));
138  if (!bufer)
139  return AVERROR(ENOMEM);
140 
141  /* we need a place for DCA_ADPCM_COEFF samples from previous frame
142  * to calc prediction coefficients for each subband */
143  for (ch = 0; ch < MAX_CHANNELS; ch++) {
144  for (band = 0; band < DCAENC_SUBBANDS; band++) {
145  c->subband[ch][band] = bufer +
146  ch * DCAENC_SUBBANDS * (SUBBAND_SAMPLES + DCA_ADPCM_COEFFS) +
147  band * (SUBBAND_SAMPLES + DCA_ADPCM_COEFFS) + DCA_ADPCM_COEFFS;
148  }
149  }
150  return 0;
151 }
152 
153 static void subband_bufer_free(DCAEncContext *c)
154 {
155  if (c->subband[0][0]) {
156  int32_t *bufer = c->subband[0][0] - DCA_ADPCM_COEFFS;
157  av_free(bufer);
158  c->subband[0][0] = NULL;
159  }
160 }
161 
162 static int encode_init(AVCodecContext *avctx)
163 {
164  DCAEncContext *c = avctx->priv_data;
165  uint64_t layout = avctx->channel_layout;
166  int i, j, k, min_frame_bits;
167  int ret;
168 
169  if ((ret = subband_bufer_alloc(c)) < 0)
170  return ret;
171 
172  c->fullband_channels = c->channels = avctx->channels;
173  c->lfe_channel = (avctx->channels == 3 || avctx->channels == 6);
174  c->band_interpolation = c->band_interpolation_tab[1];
175  c->band_spectrum = c->band_spectrum_tab[1];
176  c->worst_quantization_noise = -2047;
177  c->worst_noise_ever = -2047;
178  c->consumed_adpcm_bits = 0;
179 
180  if (ff_dcaadpcm_init(&c->adpcm_ctx))
181  return AVERROR(ENOMEM);
182 
183  if (!layout) {
184  av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The "
185  "encoder will guess the layout, but it "
186  "might be incorrect.\n");
187  layout = av_get_default_channel_layout(avctx->channels);
188  }
189  switch (layout) {
190  case AV_CH_LAYOUT_MONO: c->channel_config = 0; break;
191  case AV_CH_LAYOUT_STEREO: c->channel_config = 2; break;
192  case AV_CH_LAYOUT_2_2: c->channel_config = 8; break;
193  case AV_CH_LAYOUT_5POINT0: c->channel_config = 9; break;
194  case AV_CH_LAYOUT_5POINT1: c->channel_config = 9; break;
195  default:
196  av_log(avctx, AV_LOG_ERROR, "Unsupported channel layout!\n");
197  return AVERROR_PATCHWELCOME;
198  }
199 
200  if (c->lfe_channel) {
201  c->fullband_channels--;
202  c->channel_order_tab = channel_reorder_lfe[c->channel_config];
203  } else {
204  c->channel_order_tab = channel_reorder_nolfe[c->channel_config];
205  }
206 
207  for (i = 0; i < MAX_CHANNELS; i++) {
208  for (j = 0; j < DCA_CODE_BOOKS; j++) {
209  c->quant_index_sel[i][j] = ff_dca_quant_index_group_size[j];
210  }
211  /* 6 - no Huffman */
212  c->bit_allocation_sel[i] = 6;
213 
214  for (j = 0; j < DCAENC_SUBBANDS; j++) {
215  /* -1 - no ADPCM */
216  c->prediction_mode[i][j] = -1;
217  memset(c->adpcm_history[i][j], 0, sizeof(int32_t)*DCA_ADPCM_COEFFS);
218  }
219  }
220 
221  for (i = 0; i < 9; i++) {
222  if (sample_rates[i] == avctx->sample_rate)
223  break;
224  }
225  if (i == 9)
226  return AVERROR(EINVAL);
227  c->samplerate_index = i;
228 
229  if (avctx->bit_rate < 32000 || avctx->bit_rate > 3840000) {
230  av_log(avctx, AV_LOG_ERROR, "Bit rate %"PRId64" not supported.", avctx->bit_rate);
231  return AVERROR(EINVAL);
232  }
233  for (i = 0; ff_dca_bit_rates[i] < avctx->bit_rate; i++)
234  ;
235  c->bitrate_index = i;
236  c->frame_bits = FFALIGN((avctx->bit_rate * 512 + avctx->sample_rate - 1) / avctx->sample_rate, 32);
237  min_frame_bits = 132 + (493 + 28 * 32) * c->fullband_channels + c->lfe_channel * 72;
238  if (c->frame_bits < min_frame_bits || c->frame_bits > (DCA_MAX_FRAME_SIZE << 3))
239  return AVERROR(EINVAL);
240 
241  c->frame_size = (c->frame_bits + 7) / 8;
242 
243  avctx->frame_size = 32 * SUBBAND_SAMPLES;
244 
245  if ((ret = ff_mdct_init(&c->mdct, 9, 0, 1.0)) < 0)
246  return ret;
247 
248  /* Init all tables */
249  c->cos_table[0] = 0x7fffffff;
250  c->cos_table[512] = 0;
251  c->cos_table[1024] = -c->cos_table[0];
252  for (i = 1; i < 512; i++) {
253  c->cos_table[i] = (int32_t)(0x7fffffff * cos(M_PI * i / 1024));
254  c->cos_table[1024-i] = -c->cos_table[i];
255  c->cos_table[1024+i] = -c->cos_table[i];
256  c->cos_table[2048-i] = +c->cos_table[i];
257  }
258 
259  for (i = 0; i < 2048; i++)
260  c->cb_to_level[i] = (int32_t)(0x7fffffff * ff_exp10(-0.005 * i));
261 
262  for (k = 0; k < 32; k++) {
263  for (j = 0; j < 8; j++) {
264  c->lfe_fir_64i[64 * j + k] = (int32_t)(0xffffff800000ULL * ff_dca_lfe_fir_64[8 * k + j]);
265  c->lfe_fir_64i[64 * (7-j) + (63 - k)] = (int32_t)(0xffffff800000ULL * ff_dca_lfe_fir_64[8 * k + j]);
266  }
267  }
268 
269  for (i = 0; i < 512; i++) {
270  c->band_interpolation_tab[0][i] = (int32_t)(0x1000000000ULL * ff_dca_fir_32bands_perfect[i]);
271  c->band_interpolation_tab[1][i] = (int32_t)(0x1000000000ULL * ff_dca_fir_32bands_nonperfect[i]);
272  }
273 
274  for (i = 0; i < 9; i++) {
275  for (j = 0; j < AUBANDS; j++) {
276  for (k = 0; k < 256; k++) {
277  double freq = sample_rates[i] * (k + 0.5) / 512;
278 
279  c->auf[i][j][k] = (int32_t)(10 * (hom(freq) + gammafilter(j, freq)));
280  }
281  }
282  }
283 
284  for (i = 0; i < 256; i++) {
285  double add = 1 + ff_exp10(-0.01 * i);
286  c->cb_to_add[i] = (int32_t)(100 * log10(add));
287  }
288  for (j = 0; j < 8; j++) {
289  double accum = 0;
290  for (i = 0; i < 512; i++) {
291  double reconst = ff_dca_fir_32bands_perfect[i] * ((i & 64) ? (-1) : 1);
292  accum += reconst * cos(2 * M_PI * (i + 0.5 - 256) * (j + 0.5) / 512);
293  }
294  c->band_spectrum_tab[0][j] = (int32_t)(200 * log10(accum));
295  }
296  for (j = 0; j < 8; j++) {
297  double accum = 0;
298  for (i = 0; i < 512; i++) {
299  double reconst = ff_dca_fir_32bands_nonperfect[i] * ((i & 64) ? (-1) : 1);
300  accum += reconst * cos(2 * M_PI * (i + 0.5 - 256) * (j + 0.5) / 512);
301  }
302  c->band_spectrum_tab[1][j] = (int32_t)(200 * log10(accum));
303  }
304 
305  return 0;
306 }
307 
308 static av_cold int encode_close(AVCodecContext *avctx)
309 {
310  DCAEncContext *c = avctx->priv_data;
311  ff_mdct_end(&c->mdct);
312  subband_bufer_free(c);
313  ff_dcaadpcm_free(&c->adpcm_ctx);
314 
315  return 0;
316 }
317 
318 static void subband_transform(DCAEncContext *c, const int32_t *input)
319 {
320  int ch, subs, i, k, j;
321 
322  for (ch = 0; ch < c->fullband_channels; ch++) {
323  /* History is copied because it is also needed for PSY */
324  int32_t hist[512];
325  int hist_start = 0;
326  const int chi = c->channel_order_tab[ch];
327 
328  memcpy(hist, &c->history[ch][0], 512 * sizeof(int32_t));
329 
330  for (subs = 0; subs < SUBBAND_SAMPLES; subs++) {
331  int32_t accum[64];
332  int32_t resp;
333  int band;
334 
335  /* Calculate the convolutions at once */
336  memset(accum, 0, 64 * sizeof(int32_t));
337 
338  for (k = 0, i = hist_start, j = 0;
339  i < 512; k = (k + 1) & 63, i++, j++)
340  accum[k] += mul32(hist[i], c->band_interpolation[j]);
341  for (i = 0; i < hist_start; k = (k + 1) & 63, i++, j++)
342  accum[k] += mul32(hist[i], c->band_interpolation[j]);
343 
344  for (k = 16; k < 32; k++)
345  accum[k] = accum[k] - accum[31 - k];
346  for (k = 32; k < 48; k++)
347  accum[k] = accum[k] + accum[95 - k];
348 
349  for (band = 0; band < 32; band++) {
350  resp = 0;
351  for (i = 16; i < 48; i++) {
352  int s = (2 * band + 1) * (2 * (i + 16) + 1);
353  resp += mul32(accum[i], COS_T(s << 3)) >> 3;
354  }
355 
356  c->subband[ch][band][subs] = ((band + 1) & 2) ? -resp : resp;
357  }
358 
359  /* Copy in 32 new samples from input */
360  for (i = 0; i < 32; i++)
361  hist[i + hist_start] = input[(subs * 32 + i) * c->channels + chi];
362 
363  hist_start = (hist_start + 32) & 511;
364  }
365  }
366 }
367 
368 static void lfe_downsample(DCAEncContext *c, const int32_t *input)
369 {
370  /* FIXME: make 128x LFE downsampling possible */
371  const int lfech = lfe_index[c->channel_config];
372  int i, j, lfes;
373  int32_t hist[512];
374  int32_t accum;
375  int hist_start = 0;
376 
377  memcpy(hist, &c->history[c->channels - 1][0], 512 * sizeof(int32_t));
378 
379  for (lfes = 0; lfes < DCA_LFE_SAMPLES; lfes++) {
380  /* Calculate the convolution */
381  accum = 0;
382 
383  for (i = hist_start, j = 0; i < 512; i++, j++)
384  accum += mul32(hist[i], c->lfe_fir_64i[j]);
385  for (i = 0; i < hist_start; i++, j++)
386  accum += mul32(hist[i], c->lfe_fir_64i[j]);
387 
388  c->downsampled_lfe[lfes] = accum;
389 
390  /* Copy in 64 new samples from input */
391  for (i = 0; i < 64; i++)
392  hist[i + hist_start] = input[(lfes * 64 + i) * c->channels + lfech];
393 
394  hist_start = (hist_start + 64) & 511;
395  }
396 }
397 
398 static int32_t get_cb(DCAEncContext *c, int32_t in)
399 {
400  int i, res = 0;
401  in = FFABS(in);
402 
403  for (i = 1024; i > 0; i >>= 1) {
404  if (c->cb_to_level[i + res] >= in)
405  res += i;
406  }
407  return -res;
408 }
409 
410 static int32_t add_cb(DCAEncContext *c, int32_t a, int32_t b)
411 {
412  if (a < b)
413  FFSWAP(int32_t, a, b);
414 
415  if (a - b >= 256)
416  return a;
417  return a + c->cb_to_add[a - b];
418 }
419 
420 static void calc_power(DCAEncContext *c,
421  const int32_t in[2 * 256], int32_t power[256])
422 {
423  int i;
424  LOCAL_ALIGNED_32(int32_t, data, [512]);
425  LOCAL_ALIGNED_32(int32_t, coeff, [256]);
426 
427  for (i = 0; i < 512; i++)
428  data[i] = norm__(mul32(in[i], 0x3fffffff - (COS_T(4 * i + 2) >> 1)), 4);
429 
430  c->mdct.mdct_calc(&c->mdct, coeff, data);
431  for (i = 0; i < 256; i++) {
432  const int32_t cb = get_cb(c, coeff[i]);
433  power[i] = add_cb(c, cb, cb);
434  }
435 }
436 
437 static void adjust_jnd(DCAEncContext *c,
438  const int32_t in[512], int32_t out_cb[256])
439 {
440  int32_t power[256];
441  int32_t out_cb_unnorm[256];
442  int32_t denom;
443  const int32_t ca_cb = -1114;
444  const int32_t cs_cb = 928;
445  const int samplerate_index = c->samplerate_index;
446  int i, j;
447 
448  calc_power(c, in, power);
449 
450  for (j = 0; j < 256; j++)
451  out_cb_unnorm[j] = -2047; /* and can only grow */
452 
453  for (i = 0; i < AUBANDS; i++) {
454  denom = ca_cb; /* and can only grow */
455  for (j = 0; j < 256; j++)
456  denom = add_cb(c, denom, power[j] + c->auf[samplerate_index][i][j]);
457  for (j = 0; j < 256; j++)
458  out_cb_unnorm[j] = add_cb(c, out_cb_unnorm[j],
459  -denom + c->auf[samplerate_index][i][j]);
460  }
461 
462  for (j = 0; j < 256; j++)
463  out_cb[j] = add_cb(c, out_cb[j], -out_cb_unnorm[j] - ca_cb - cs_cb);
464 }
465 
466 typedef void (*walk_band_t)(DCAEncContext *c, int band1, int band2, int f,
467  int32_t spectrum1, int32_t spectrum2, int channel,
468  int32_t * arg);
469 
470 static void walk_band_low(DCAEncContext *c, int band, int channel,
471  walk_band_t walk, int32_t *arg)
472 {
473  int f;
474 
475  if (band == 0) {
476  for (f = 0; f < 4; f++)
477  walk(c, 0, 0, f, 0, -2047, channel, arg);
478  } else {
479  for (f = 0; f < 8; f++)
480  walk(c, band, band - 1, 8 * band - 4 + f,
481  c->band_spectrum[7 - f], c->band_spectrum[f], channel, arg);
482  }
483 }
484 
485 static void walk_band_high(DCAEncContext *c, int band, int channel,
486  walk_band_t walk, int32_t *arg)
487 {
488  int f;
489 
490  if (band == 31) {
491  for (f = 0; f < 4; f++)
492  walk(c, 31, 31, 256 - 4 + f, 0, -2047, channel, arg);
493  } else {
494  for (f = 0; f < 8; f++)
495  walk(c, band, band + 1, 8 * band + 4 + f,
496  c->band_spectrum[f], c->band_spectrum[7 - f], channel, arg);
497  }
498 }
499 
500 static void update_band_masking(DCAEncContext *c, int band1, int band2,
501  int f, int32_t spectrum1, int32_t spectrum2,
502  int channel, int32_t * arg)
503 {
504  int32_t value = c->eff_masking_curve_cb[f] - spectrum1;
505 
506  if (value < c->band_masking_cb[band1])
507  c->band_masking_cb[band1] = value;
508 }
509 
510 static void calc_masking(DCAEncContext *c, const int32_t *input)
511 {
512  int i, k, band, ch, ssf;
513  int32_t data[512];
514 
515  for (i = 0; i < 256; i++)
516  for (ssf = 0; ssf < SUBSUBFRAMES; ssf++)
517  c->masking_curve_cb[ssf][i] = -2047;
518 
519  for (ssf = 0; ssf < SUBSUBFRAMES; ssf++)
520  for (ch = 0; ch < c->fullband_channels; ch++) {
521  const int chi = c->channel_order_tab[ch];
522 
523  for (i = 0, k = 128 + 256 * ssf; k < 512; i++, k++)
524  data[i] = c->history[ch][k];
525  for (k -= 512; i < 512; i++, k++)
526  data[i] = input[k * c->channels + chi];
527  adjust_jnd(c, data, c->masking_curve_cb[ssf]);
528  }
529  for (i = 0; i < 256; i++) {
530  int32_t m = 2048;
531 
532  for (ssf = 0; ssf < SUBSUBFRAMES; ssf++)
533  if (c->masking_curve_cb[ssf][i] < m)
534  m = c->masking_curve_cb[ssf][i];
535  c->eff_masking_curve_cb[i] = m;
536  }
537 
538  for (band = 0; band < 32; band++) {
539  c->band_masking_cb[band] = 2048;
540  walk_band_low(c, band, 0, update_band_masking, NULL);
541  walk_band_high(c, band, 0, update_band_masking, NULL);
542  }
543 }
544 
545 static inline int32_t find_peak(DCAEncContext *c, const int32_t *in, int len)
546 {
547  int sample;
548  int32_t m = 0;
549  for (sample = 0; sample < len; sample++) {
550  int32_t s = abs(in[sample]);
551  if (m < s)
552  m = s;
553  }
554  return get_cb(c, m);
555 }
556 
557 static void find_peaks(DCAEncContext *c)
558 {
559  int band, ch;
560 
561  for (ch = 0; ch < c->fullband_channels; ch++) {
562  for (band = 0; band < 32; band++)
563  c->peak_cb[ch][band] = find_peak(c, c->subband[ch][band],
564  SUBBAND_SAMPLES);
565  }
566 
567  if (c->lfe_channel)
568  c->lfe_peak_cb = find_peak(c, c->downsampled_lfe, DCA_LFE_SAMPLES);
569 }
570 
571 static void adpcm_analysis(DCAEncContext *c)
572 {
573  int ch, band;
574  int pred_vq_id;
575  int32_t *samples;
576  int32_t estimated_diff[SUBBAND_SAMPLES];
577 
578  c->consumed_adpcm_bits = 0;
579  for (ch = 0; ch < c->fullband_channels; ch++) {
580  for (band = 0; band < 32; band++) {
581  samples = c->subband[ch][band] - DCA_ADPCM_COEFFS;
582  pred_vq_id = ff_dcaadpcm_subband_analysis(&c->adpcm_ctx, samples,
583  SUBBAND_SAMPLES, estimated_diff);
584  if (pred_vq_id >= 0) {
585  c->prediction_mode[ch][band] = pred_vq_id;
586  c->consumed_adpcm_bits += 12; //12 bits to transmit prediction vq index
587  c->diff_peak_cb[ch][band] = find_peak(c, estimated_diff, 16);
588  } else {
589  c->prediction_mode[ch][band] = -1;
590  }
591  }
592  }
593 }
594 
595 static const int snr_fudge = 128;
596 #define USED_1ABITS 1
597 #define USED_26ABITS 4
598 
599 static inline int32_t get_step_size(DCAEncContext *c, int ch, int band)
600 {
601  int32_t step_size;
602 
603  if (c->bitrate_index == 3)
604  step_size = ff_dca_lossless_quant[c->abits[ch][band]];
605  else
606  step_size = ff_dca_lossy_quant[c->abits[ch][band]];
607 
608  return step_size;
609 }
610 
611 static int calc_one_scale(DCAEncContext *c, int32_t peak_cb, int abits,
612  softfloat *quant)
613 {
614  int32_t peak;
615  int our_nscale, try_remove;
616  softfloat our_quant;
617 
618  av_assert0(peak_cb <= 0);
619  av_assert0(peak_cb >= -2047);
620 
621  our_nscale = 127;
622  peak = c->cb_to_level[-peak_cb];
623 
624  for (try_remove = 64; try_remove > 0; try_remove >>= 1) {
625  if (scalefactor_inv[our_nscale - try_remove].e + stepsize_inv[abits].e <= 17)
626  continue;
627  our_quant.m = mul32(scalefactor_inv[our_nscale - try_remove].m, stepsize_inv[abits].m);
628  our_quant.e = scalefactor_inv[our_nscale - try_remove].e + stepsize_inv[abits].e - 17;
629  if ((ff_dca_quant_levels[abits] - 1) / 2 < quantize_value(peak, our_quant))
630  continue;
631  our_nscale -= try_remove;
632  }
633 
634  if (our_nscale >= 125)
635  our_nscale = 124;
636 
637  quant->m = mul32(scalefactor_inv[our_nscale].m, stepsize_inv[abits].m);
638  quant->e = scalefactor_inv[our_nscale].e + stepsize_inv[abits].e - 17;
639  av_assert0((ff_dca_quant_levels[abits] - 1) / 2 >= quantize_value(peak, *quant));
640 
641  return our_nscale;
642 }
643 
644 static inline void quantize_adpcm_subband(DCAEncContext *c, int ch, int band)
645 {
646  int32_t step_size;
647  int32_t diff_peak_cb = c->diff_peak_cb[ch][band];
648  c->scale_factor[ch][band] = calc_one_scale(c, diff_peak_cb,
649  c->abits[ch][band],
650  &c->quant[ch][band]);
651 
652  step_size = get_step_size(c, ch, band);
653  ff_dcaadpcm_do_real(c->prediction_mode[ch][band],
654  c->quant[ch][band],
655  ff_dca_scale_factor_quant7[c->scale_factor[ch][band]],
656  step_size, c->adpcm_history[ch][band], c->subband[ch][band],
657  c->adpcm_history[ch][band] + 4, c->quantized[ch][band],
658  SUBBAND_SAMPLES, c->cb_to_level[-diff_peak_cb]);
659 }
660 
661 static void quantize_adpcm(DCAEncContext *c)
662 {
663  int band, ch;
664 
665  for (ch = 0; ch < c->fullband_channels; ch++)
666  for (band = 0; band < 32; band++)
667  if (c->prediction_mode[ch][band] >= 0)
668  quantize_adpcm_subband(c, ch, band);
669 }
670 
671 static void quantize_pcm(DCAEncContext *c)
672 {
673  int sample, band, ch;
674 
675  for (ch = 0; ch < c->fullband_channels; ch++) {
676  for (band = 0; band < 32; band++) {
677  if (c->prediction_mode[ch][band] == -1) {
678  for (sample = 0; sample < SUBBAND_SAMPLES; sample++) {
679  int32_t val = quantize_value(c->subband[ch][band][sample],
680  c->quant[ch][band]);
681  c->quantized[ch][band][sample] = val;
682  }
683  }
684  }
685  }
686 }
687 
688 static void accumulate_huff_bit_consumption(int abits, int32_t *quantized,
689  uint32_t *result)
690 {
691  uint8_t sel, id = abits - 1;
692  for (sel = 0; sel < ff_dca_quant_index_group_size[id]; sel++)
693  result[sel] += ff_dca_vlc_calc_quant_bits(quantized, SUBBAND_SAMPLES,
694  sel, id);
695 }
696 
697 static uint32_t set_best_code(uint32_t vlc_bits[DCA_CODE_BOOKS][7],
698  uint32_t clc_bits[DCA_CODE_BOOKS],
699  int32_t res[DCA_CODE_BOOKS])
700 {
701  uint8_t i, sel;
702  uint32_t best_sel_bits[DCA_CODE_BOOKS];
703  int32_t best_sel_id[DCA_CODE_BOOKS];
704  uint32_t t, bits = 0;
705 
706  for (i = 0; i < DCA_CODE_BOOKS; i++) {
707 
708  av_assert0(!((!!vlc_bits[i][0]) ^ (!!clc_bits[i])));
709  if (vlc_bits[i][0] == 0) {
710  /* do not transmit adjustment index for empty codebooks */
711  res[i] = ff_dca_quant_index_group_size[i];
712  /* and skip it */
713  continue;
714  }
715 
716  best_sel_bits[i] = vlc_bits[i][0];
717  best_sel_id[i] = 0;
718  for (sel = 0; sel < ff_dca_quant_index_group_size[i]; sel++) {
719  if (best_sel_bits[i] > vlc_bits[i][sel] && vlc_bits[i][sel]) {
720  best_sel_bits[i] = vlc_bits[i][sel];
721  best_sel_id[i] = sel;
722  }
723  }
724 
725  /* 2 bits to transmit scale factor adjustment index */
726  t = best_sel_bits[i] + 2;
727  if (t < clc_bits[i]) {
728  res[i] = best_sel_id[i];
729  bits += t;
730  } else {
731  res[i] = ff_dca_quant_index_group_size[i];
732  bits += clc_bits[i];
733  }
734  }
735  return bits;
736 }
737 
738 static uint32_t set_best_abits_code(int abits[DCAENC_SUBBANDS], int bands,
739  int32_t *res)
740 {
741  uint8_t i;
742  uint32_t t;
743  int32_t best_sel = 6;
744  int32_t best_bits = bands * 5;
745 
746  /* Check do we have subband which cannot be encoded by Huffman tables */
747  for (i = 0; i < bands; i++) {
748  if (abits[i] > 12 || abits[i] == 0) {
749  *res = best_sel;
750  return best_bits;
751  }
752  }
753 
754  for (i = 0; i < DCA_BITALLOC_12_COUNT; i++) {
755  t = ff_dca_vlc_calc_alloc_bits(abits, bands, i);
756  if (t < best_bits) {
757  best_bits = t;
758  best_sel = i;
759  }
760  }
761 
762  *res = best_sel;
763  return best_bits;
764 }
765 
766 static int init_quantization_noise(DCAEncContext *c, int noise, int forbid_zero)
767 {
768  int ch, band, ret = USED_26ABITS | USED_1ABITS;
769  uint32_t huff_bit_count_accum[MAX_CHANNELS][DCA_CODE_BOOKS][7];
770  uint32_t clc_bit_count_accum[MAX_CHANNELS][DCA_CODE_BOOKS];
771  uint32_t bits_counter = 0;
772 
773  c->consumed_bits = 132 + 333 * c->fullband_channels;
774  c->consumed_bits += c->consumed_adpcm_bits;
775  if (c->lfe_channel)
776  c->consumed_bits += 72;
777 
778  /* attempt to guess the bit distribution based on the prevoius frame */
779  for (ch = 0; ch < c->fullband_channels; ch++) {
780  for (band = 0; band < 32; band++) {
781  int snr_cb = c->peak_cb[ch][band] - c->band_masking_cb[band] - noise;
782 
783  if (snr_cb >= 1312) {
784  c->abits[ch][band] = 26;
785  ret &= ~USED_1ABITS;
786  } else if (snr_cb >= 222) {
787  c->abits[ch][band] = 8 + mul32(snr_cb - 222, 69000000);
788  ret &= ~(USED_26ABITS | USED_1ABITS);
789  } else if (snr_cb >= 0) {
790  c->abits[ch][band] = 2 + mul32(snr_cb, 106000000);
791  ret &= ~(USED_26ABITS | USED_1ABITS);
792  } else if (forbid_zero || snr_cb >= -140) {
793  c->abits[ch][band] = 1;
794  ret &= ~USED_26ABITS;
795  } else {
796  c->abits[ch][band] = 0;
797  ret &= ~(USED_26ABITS | USED_1ABITS);
798  }
799  }
800  c->consumed_bits += set_best_abits_code(c->abits[ch], 32,
801  &c->bit_allocation_sel[ch]);
802  }
803 
804  /* Recalc scale_factor each time to get bits consumption in case of Huffman coding.
805  It is suboptimal solution */
806  /* TODO: May be cache scaled values */
807  for (ch = 0; ch < c->fullband_channels; ch++) {
808  for (band = 0; band < 32; band++) {
809  if (c->prediction_mode[ch][band] == -1) {
810  c->scale_factor[ch][band] = calc_one_scale(c, c->peak_cb[ch][band],
811  c->abits[ch][band],
812  &c->quant[ch][band]);
813  }
814  }
815  }
816  quantize_adpcm(c);
817  quantize_pcm(c);
818 
819  memset(huff_bit_count_accum, 0, MAX_CHANNELS * DCA_CODE_BOOKS * 7 * sizeof(uint32_t));
820  memset(clc_bit_count_accum, 0, MAX_CHANNELS * DCA_CODE_BOOKS * sizeof(uint32_t));
821  for (ch = 0; ch < c->fullband_channels; ch++) {
822  for (band = 0; band < 32; band++) {
823  if (c->abits[ch][band] && c->abits[ch][band] <= DCA_CODE_BOOKS) {
824  accumulate_huff_bit_consumption(c->abits[ch][band],
825  c->quantized[ch][band],
826  huff_bit_count_accum[ch][c->abits[ch][band] - 1]);
827  clc_bit_count_accum[ch][c->abits[ch][band] - 1] += bit_consumption[c->abits[ch][band]];
828  } else {
829  bits_counter += bit_consumption[c->abits[ch][band]];
830  }
831  }
832  }
833 
834  for (ch = 0; ch < c->fullband_channels; ch++) {
835  bits_counter += set_best_code(huff_bit_count_accum[ch],
836  clc_bit_count_accum[ch],
837  c->quant_index_sel[ch]);
838  }
839 
840  c->consumed_bits += bits_counter;
841 
842  return ret;
843 }
844 
845 static void assign_bits(DCAEncContext *c)
846 {
847  /* Find the bounds where the binary search should work */
848  int low, high, down;
849  int used_abits = 0;
850  int forbid_zero = 1;
851 restart:
852  init_quantization_noise(c, c->worst_quantization_noise, forbid_zero);
853  low = high = c->worst_quantization_noise;
854  if (c->consumed_bits > c->frame_bits) {
855  while (c->consumed_bits > c->frame_bits) {
856  if (used_abits == USED_1ABITS && forbid_zero) {
857  forbid_zero = 0;
858  goto restart;
859  }
860  low = high;
861  high += snr_fudge;
862  used_abits = init_quantization_noise(c, high, forbid_zero);
863  }
864  } else {
865  while (c->consumed_bits <= c->frame_bits) {
866  high = low;
867  if (used_abits == USED_26ABITS)
868  goto out; /* The requested bitrate is too high, pad with zeros */
869  low -= snr_fudge;
870  used_abits = init_quantization_noise(c, low, forbid_zero);
871  }
872  }
873 
874  /* Now do a binary search between low and high to see what fits */
875  for (down = snr_fudge >> 1; down; down >>= 1) {
876  init_quantization_noise(c, high - down, forbid_zero);
877  if (c->consumed_bits <= c->frame_bits)
878  high -= down;
879  }
880  init_quantization_noise(c, high, forbid_zero);
881 out:
882  c->worst_quantization_noise = high;
883  if (high > c->worst_noise_ever)
884  c->worst_noise_ever = high;
885 }
886 
887 static void shift_history(DCAEncContext *c, const int32_t *input)
888 {
889  int k, ch;
890 
891  for (k = 0; k < 512; k++)
892  for (ch = 0; ch < c->channels; ch++) {
893  const int chi = c->channel_order_tab[ch];
894 
895  c->history[ch][k] = input[k * c->channels + chi];
896  }
897 }
898 
899 static void fill_in_adpcm_bufer(DCAEncContext *c)
900 {
901  int ch, band;
902  int32_t step_size;
903  /* We fill in ADPCM work buffer for subbands which hasn't been ADPCM coded
904  * in current frame - we need this data if subband of next frame is
905  * ADPCM
906  */
907  for (ch = 0; ch < c->channels; ch++) {
908  for (band = 0; band < 32; band++) {
909  int32_t *samples = c->subband[ch][band] - DCA_ADPCM_COEFFS;
910  if (c->prediction_mode[ch][band] == -1) {
911  step_size = get_step_size(c, ch, band);
912 
913  ff_dca_core_dequantize(c->adpcm_history[ch][band],
914  c->quantized[ch][band]+12, step_size,
915  ff_dca_scale_factor_quant7[c->scale_factor[ch][band]], 0, 4);
916  } else {
917  AV_COPY128U(c->adpcm_history[ch][band], c->adpcm_history[ch][band]+4);
918  }
919  /* Copy dequantized values for LPC analysis.
920  * It reduces artifacts in case of extreme quantization,
921  * example: in current frame abits is 1 and has no prediction flag,
922  * but end of this frame is sine like signal. In this case, if LPC analysis uses
923  * original values, likely LPC analysis returns good prediction gain, and sets prediction flag.
924  * But there are no proper value in decoder history, so likely result will be no good.
925  * Bitstream has "Predictor history flag switch", but this flag disables history for all subbands
926  */
927  samples[0] = c->adpcm_history[ch][band][0] << 7;
928  samples[1] = c->adpcm_history[ch][band][1] << 7;
929  samples[2] = c->adpcm_history[ch][band][2] << 7;
930  samples[3] = c->adpcm_history[ch][band][3] << 7;
931  }
932  }
933 }
934 
935 static void calc_lfe_scales(DCAEncContext *c)
936 {
937  if (c->lfe_channel)
938  c->lfe_scale_factor = calc_one_scale(c, c->lfe_peak_cb, 11, &c->lfe_quant);
939 }
940 
941 static void put_frame_header(DCAEncContext *c)
942 {
943  /* SYNC */
944  put_bits(&c->pb, 16, 0x7ffe);
945  put_bits(&c->pb, 16, 0x8001);
946 
947  /* Frame type: normal */
948  put_bits(&c->pb, 1, 1);
949 
950  /* Deficit sample count: none */
951  put_bits(&c->pb, 5, 31);
952 
953  /* CRC is not present */
954  put_bits(&c->pb, 1, 0);
955 
956  /* Number of PCM sample blocks */
957  put_bits(&c->pb, 7, SUBBAND_SAMPLES - 1);
958 
959  /* Primary frame byte size */
960  put_bits(&c->pb, 14, c->frame_size - 1);
961 
962  /* Audio channel arrangement */
963  put_bits(&c->pb, 6, c->channel_config);
964 
965  /* Core audio sampling frequency */
966  put_bits(&c->pb, 4, bitstream_sfreq[c->samplerate_index]);
967 
968  /* Transmission bit rate */
969  put_bits(&c->pb, 5, c->bitrate_index);
970 
971  /* Embedded down mix: disabled */
972  put_bits(&c->pb, 1, 0);
973 
974  /* Embedded dynamic range flag: not present */
975  put_bits(&c->pb, 1, 0);
976 
977  /* Embedded time stamp flag: not present */
978  put_bits(&c->pb, 1, 0);
979 
980  /* Auxiliary data flag: not present */
981  put_bits(&c->pb, 1, 0);
982 
983  /* HDCD source: no */
984  put_bits(&c->pb, 1, 0);
985 
986  /* Extension audio ID: N/A */
987  put_bits(&c->pb, 3, 0);
988 
989  /* Extended audio data: not present */
990  put_bits(&c->pb, 1, 0);
991 
992  /* Audio sync word insertion flag: after each sub-frame */
993  put_bits(&c->pb, 1, 0);
994 
995  /* Low frequency effects flag: not present or 64x subsampling */
996  put_bits(&c->pb, 2, c->lfe_channel ? 2 : 0);
997 
998  /* Predictor history switch flag: on */
999  put_bits(&c->pb, 1, 1);
1000 
1001  /* No CRC */
1002  /* Multirate interpolator switch: non-perfect reconstruction */
1003  put_bits(&c->pb, 1, 0);
1004 
1005  /* Encoder software revision: 7 */
1006  put_bits(&c->pb, 4, 7);
1007 
1008  /* Copy history: 0 */
1009  put_bits(&c->pb, 2, 0);
1010 
1011  /* Source PCM resolution: 16 bits, not DTS ES */
1012  put_bits(&c->pb, 3, 0);
1013 
1014  /* Front sum/difference coding: no */
1015  put_bits(&c->pb, 1, 0);
1016 
1017  /* Surrounds sum/difference coding: no */
1018  put_bits(&c->pb, 1, 0);
1019 
1020  /* Dialog normalization: 0 dB */
1021  put_bits(&c->pb, 4, 0);
1022 }
1023 
1024 static void put_primary_audio_header(DCAEncContext *c)
1025 {
1026  int ch, i;
1027  /* Number of subframes */
1028  put_bits(&c->pb, 4, SUBFRAMES - 1);
1029 
1030  /* Number of primary audio channels */
1031  put_bits(&c->pb, 3, c->fullband_channels - 1);
1032 
1033  /* Subband activity count */
1034  for (ch = 0; ch < c->fullband_channels; ch++)
1035  put_bits(&c->pb, 5, DCAENC_SUBBANDS - 2);
1036 
1037  /* High frequency VQ start subband */
1038  for (ch = 0; ch < c->fullband_channels; ch++)
1039  put_bits(&c->pb, 5, DCAENC_SUBBANDS - 1);
1040 
1041  /* Joint intensity coding index: 0, 0 */
1042  for (ch = 0; ch < c->fullband_channels; ch++)
1043  put_bits(&c->pb, 3, 0);
1044 
1045  /* Transient mode codebook: A4, A4 (arbitrary) */
1046  for (ch = 0; ch < c->fullband_channels; ch++)
1047  put_bits(&c->pb, 2, 0);
1048 
1049  /* Scale factor code book: 7 bit linear, 7-bit sqrt table (for each channel) */
1050  for (ch = 0; ch < c->fullband_channels; ch++)
1051  put_bits(&c->pb, 3, 6);
1052 
1053  /* Bit allocation quantizer select: linear 5-bit */
1054  for (ch = 0; ch < c->fullband_channels; ch++)
1055  put_bits(&c->pb, 3, c->bit_allocation_sel[ch]);
1056 
1057  /* Quantization index codebook select */
1058  for (i = 0; i < DCA_CODE_BOOKS; i++)
1059  for (ch = 0; ch < c->fullband_channels; ch++)
1060  put_bits(&c->pb, ff_dca_quant_index_sel_nbits[i], c->quant_index_sel[ch][i]);
1061 
1062  /* Scale factor adjustment index: transmitted in case of Huffman coding */
1063  for (i = 0; i < DCA_CODE_BOOKS; i++)
1064  for (ch = 0; ch < c->fullband_channels; ch++)
1065  if (c->quant_index_sel[ch][i] < ff_dca_quant_index_group_size[i])
1066  put_bits(&c->pb, 2, 0);
1067 
1068  /* Audio header CRC check word: not transmitted */
1069 }
1070 
1071 static void put_subframe_samples(DCAEncContext *c, int ss, int band, int ch)
1072 {
1073  int i, j, sum, bits, sel;
1074  if (c->abits[ch][band] <= DCA_CODE_BOOKS) {
1075  av_assert0(c->abits[ch][band] > 0);
1076  sel = c->quant_index_sel[ch][c->abits[ch][band] - 1];
1077  // Huffman codes
1078  if (sel < ff_dca_quant_index_group_size[c->abits[ch][band] - 1]) {
1079  ff_dca_vlc_enc_quant(&c->pb, &c->quantized[ch][band][ss * 8], 8,
1080  sel, c->abits[ch][band] - 1);
1081  return;
1082  }
1083 
1084  // Block codes
1085  if (c->abits[ch][band] <= 7) {
1086  for (i = 0; i < 8; i += 4) {
1087  sum = 0;
1088  for (j = 3; j >= 0; j--) {
1089  sum *= ff_dca_quant_levels[c->abits[ch][band]];
1090  sum += c->quantized[ch][band][ss * 8 + i + j];
1091  sum += (ff_dca_quant_levels[c->abits[ch][band]] - 1) / 2;
1092  }
1093  put_bits(&c->pb, bit_consumption[c->abits[ch][band]] / 4, sum);
1094  }
1095  return;
1096  }
1097  }
1098 
1099  for (i = 0; i < 8; i++) {
1100  bits = bit_consumption[c->abits[ch][band]] / 16;
1101  put_sbits(&c->pb, bits, c->quantized[ch][band][ss * 8 + i]);
1102  }
1103 }
1104 
1105 static void put_subframe(DCAEncContext *c, int subframe)
1106 {
1107  int i, band, ss, ch;
1108 
1109  /* Subsubframes count */
1110  put_bits(&c->pb, 2, SUBSUBFRAMES -1);
1111 
1112  /* Partial subsubframe sample count: dummy */
1113  put_bits(&c->pb, 3, 0);
1114 
1115  /* Prediction mode: no ADPCM, in each channel and subband */
1116  for (ch = 0; ch < c->fullband_channels; ch++)
1117  for (band = 0; band < DCAENC_SUBBANDS; band++)
1118  put_bits(&c->pb, 1, !(c->prediction_mode[ch][band] == -1));
1119 
1120  /* Prediction VQ address */
1121  for (ch = 0; ch < c->fullband_channels; ch++)
1122  for (band = 0; band < DCAENC_SUBBANDS; band++)
1123  if (c->prediction_mode[ch][band] >= 0)
1124  put_bits(&c->pb, 12, c->prediction_mode[ch][band]);
1125 
1126  /* Bit allocation index */
1127  for (ch = 0; ch < c->fullband_channels; ch++) {
1128  if (c->bit_allocation_sel[ch] == 6) {
1129  for (band = 0; band < DCAENC_SUBBANDS; band++) {
1130  put_bits(&c->pb, 5, c->abits[ch][band]);
1131  }
1132  } else {
1133  ff_dca_vlc_enc_alloc(&c->pb, c->abits[ch], DCAENC_SUBBANDS,
1134  c->bit_allocation_sel[ch]);
1135  }
1136  }
1137 
1138  if (SUBSUBFRAMES > 1) {
1139  /* Transition mode: none for each channel and subband */
1140  for (ch = 0; ch < c->fullband_channels; ch++)
1141  for (band = 0; band < DCAENC_SUBBANDS; band++)
1142  if (c->abits[ch][band])
1143  put_bits(&c->pb, 1, 0); /* codebook A4 */
1144  }
1145 
1146  /* Scale factors */
1147  for (ch = 0; ch < c->fullband_channels; ch++)
1148  for (band = 0; band < DCAENC_SUBBANDS; band++)
1149  if (c->abits[ch][band])
1150  put_bits(&c->pb, 7, c->scale_factor[ch][band]);
1151 
1152  /* Joint subband scale factor codebook select: not transmitted */
1153  /* Scale factors for joint subband coding: not transmitted */
1154  /* Stereo down-mix coefficients: not transmitted */
1155  /* Dynamic range coefficient: not transmitted */
1156  /* Stde information CRC check word: not transmitted */
1157  /* VQ encoded high frequency subbands: not transmitted */
1158 
1159  /* LFE data: 8 samples and scalefactor */
1160  if (c->lfe_channel) {
1161  for (i = 0; i < DCA_LFE_SAMPLES; i++)
1162  put_bits(&c->pb, 8, quantize_value(c->downsampled_lfe[i], c->lfe_quant) & 0xff);
1163  put_bits(&c->pb, 8, c->lfe_scale_factor);
1164  }
1165 
1166  /* Audio data (subsubframes) */
1167  for (ss = 0; ss < SUBSUBFRAMES ; ss++)
1168  for (ch = 0; ch < c->fullband_channels; ch++)
1169  for (band = 0; band < DCAENC_SUBBANDS; band++)
1170  if (c->abits[ch][band])
1171  put_subframe_samples(c, ss, band, ch);
1172 
1173  /* DSYNC */
1174  put_bits(&c->pb, 16, 0xffff);
1175 }
1176 
1177 static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
1178  const AVFrame *frame, int *got_packet_ptr)
1179 {
1180  DCAEncContext *c = avctx->priv_data;
1181  const int32_t *samples;
1182  int ret, i;
1183 
1184  if ((ret = ff_alloc_packet2(avctx, avpkt, c->frame_size, 0)) < 0)
1185  return ret;
1186 
1187  samples = (const int32_t *)frame->data[0];
1188 
1189  subband_transform(c, samples);
1190  if (c->lfe_channel)
1191  lfe_downsample(c, samples);
1192 
1193  calc_masking(c, samples);
1194  if (c->options.adpcm_mode)
1195  adpcm_analysis(c);
1196  find_peaks(c);
1197  assign_bits(c);
1198  calc_lfe_scales(c);
1199  shift_history(c, samples);
1200 
1201  init_put_bits(&c->pb, avpkt->data, avpkt->size);
1202  fill_in_adpcm_bufer(c);
1203  put_frame_header(c);
1204  put_primary_audio_header(c);
1205  for (i = 0; i < SUBFRAMES; i++)
1206  put_subframe(c, i);
1207 
1208 
1209  for (i = put_bits_count(&c->pb); i < 8*c->frame_size; i++)
1210  put_bits(&c->pb, 1, 0);
1211 
1212  flush_put_bits(&c->pb);
1213 
1214  avpkt->pts = frame->pts;
1215  avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples);
1216  avpkt->size = put_bits_count(&c->pb) >> 3;
1217  *got_packet_ptr = 1;
1218  return 0;
1219 }
1220 
1221 #define DCAENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1222 
1223 static const AVOption options[] = {
1224  { "dca_adpcm", "Use ADPCM encoding", offsetof(DCAEncContext, options.adpcm_mode), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DCAENC_FLAGS },
1225  { NULL },
1226 };
1227 
1228 static const AVClass dcaenc_class = {
1229  .class_name = "DCA (DTS Coherent Acoustics)",
1230  .item_name = av_default_item_name,
1231  .option = options,
1232  .version = LIBAVUTIL_VERSION_INT,
1233 };
1234 
1235 static const AVCodecDefault defaults[] = {
1236  { "b", "1411200" },
1237  { NULL },
1238 };
1239 
1240 AVCodec ff_dca_encoder = {
1241  .name = "dca",
1242  .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1243  .type = AVMEDIA_TYPE_AUDIO,
1244  .id = AV_CODEC_ID_DTS,
1245  .priv_data_size = sizeof(DCAEncContext),
1246  .init = encode_init,
1247  .close = encode_close,
1248  .encode2 = encode_frame,
1249  .capabilities = AV_CODEC_CAP_EXPERIMENTAL,
1250  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
1251  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32,
1252  AV_SAMPLE_FMT_NONE },
1253  .supported_samplerates = sample_rates,
1254  .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO,
1255  AV_CH_LAYOUT_STEREO,
1256  AV_CH_LAYOUT_2_2,
1257  AV_CH_LAYOUT_5POINT0,
1258  AV_CH_LAYOUT_5POINT1,
1259  0 },
1260  .defaults = defaults,
1261  .priv_class = &dcaenc_class,
1262 };
dcamath.h
DCAEncContext::pb
PutBitContext pb
Definition: dcaenc.c:63
lfe_downsample
static void lfe_downsample(DCAEncContext *c, const int32_t *input)
Definition: dcaenc.c:368
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2245
AVCodec
AVCodec.
Definition: avcodec.h:3481
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
ff_exp10
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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
opt.h
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2276
ff_dcaadpcm_do_real
int ff_dcaadpcm_do_real(int pred_vq_index, softfloat quant, int32_t scale_factor, int32_t step_size, const int32_t *prev_hist, const int32_t *in, int32_t *next_hist, int32_t *out, int len, int32_t peak)
Definition: dcaadpcm.c:183
DCAADPCMEncContext
Definition: dcaadpcm.h:29
DCAEncContext::subband
int32_t * subband[MAX_CHANNELS][DCAENC_SUBBANDS]
Definition: dcaenc.c:85
out
FILE * out
Definition: movenc.c:54
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:2225
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:112
dca.h
options
static const AVOption options[]
Definition: dcaenc.c:1223
DCAEncContext::frame_size
int frame_size
Definition: dcaenc.c:67
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:686
walk_band_low
static void walk_band_low(DCAEncContext *c, int band, int channel, walk_band_t walk, int32_t *arg)
Definition: dcaenc.c:470
DCAEncContext::worst_noise_ever
int32_t worst_noise_ever
Definition: dcaenc.c:99
ff_dca_bit_rates
const uint32_t ff_dca_bit_rates[32]
Definition: dcadata.c:32
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:85
SUBSUBFRAMES
#define SUBSUBFRAMES
Definition: dcaenc.c:51
ff_dcaadpcm_free
av_cold void ff_dcaadpcm_free(DCAADPCMEncContext *s)
Definition: dcaadpcm.c:225
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
scalefactor_inv
static const softfloat scalefactor_inv[128]
Definition: dcaenc.h:63
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:240
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
erb
static const uint16_t erb[]
Definition: dcaenc.h:48
lfe_index
static const uint8_t lfe_index[7]
Definition: dca_lbr.c:105
put_subframe
static void put_subframe(DCAEncContext *c, int subframe)
Definition: dcaenc.c:1105
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
DCAEncContext::options
CompressionOptions options
Definition: dcaenc.c:66
internal.h
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
get_step_size
static int32_t get_step_size(DCAEncContext *c, int ch, int band)
Definition: dcaenc.c:599
ff_dca_lossy_quant
const uint32_t ff_dca_lossy_quant[32]
Definition: dcadata.c:4223
AVOption
AVOption.
Definition: opt.h:246
b
#define b
Definition: input.c:41
MAX_CHANNELS
#define MAX_CHANNELS
Definition: dcaenc.c:44
data
const char data[16]
Definition: mxf.c:91
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:169
calc_lfe_scales
static void calc_lfe_scales(DCAEncContext *c)
Definition: dcaenc.c:935
DCAEncContext::adpcm_history
int32_t adpcm_history[MAX_CHANNELS][DCAENC_SUBBANDS][DCA_ADPCM_COEFFS *2]
Definition: dcaenc.c:83
ff_dca_encoder
AVCodec ff_dca_encoder
Definition: dcaenc.c:1240
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:555
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1495
update_band_masking
static void update_band_masking(DCAEncContext *c, int band1, int band2, int f, int32_t spectrum1, int32_t spectrum2, int channel, int32_t *arg)
Definition: dcaenc.c:500
calc_one_scale
static int calc_one_scale(DCAEncContext *c, int32_t peak_cb, int abits, softfloat *quant)
Definition: dcaenc.c:611
DCAEncContext::lfe_quant
softfloat lfe_quant
Definition: dcaenc.c:78
quantize_value
static int32_t quantize_value(int32_t value, softfloat quant)
Definition: dcaenc.h:149
DCAEncContext::band_interpolation
const int32_t * band_interpolation
Definition: dcaenc.c:75
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: dcaenc.c:1177
put_frame_header
static void put_frame_header(DCAEncContext *c)
Definition: dcaenc.c:941
DCAEncContext::adpcm_ctx
DCAADPCMEncContext adpcm_ctx
Definition: dcaenc.c:64
ff_dca_vlc_calc_alloc_bits
uint32_t ff_dca_vlc_calc_alloc_bits(int *values, uint8_t n, uint8_t sel)
Definition: dcahuff.c:1360
DCAEncContext::history
int32_t history[MAX_CHANNELS][512]
Definition: dcaenc.c:84
calc_masking
static void calc_masking(DCAEncContext *c, const int32_t *input)
Definition: dcaenc.c:510
DCAEncContext::fullband_channels
int fullband_channels
Definition: dcaenc.c:69
adpcm_analysis
static void adpcm_analysis(DCAEncContext *c)
Definition: dcaenc.c:571
ff_dca_fir_32bands_nonperfect
const float ff_dca_fir_32bands_nonperfect[512]
Definition: dcadata.c:6808
ff_dca_quant_index_group_size
const uint8_t ff_dca_quant_index_group_size[DCA_CODE_BOOKS]
Definition: dcadata.c:53
CompressionOptions::adpcm_mode
int adpcm_mode
Definition: dcaenc.c:58
accumulate_huff_bit_consumption
static void accumulate_huff_bit_consumption(int abits, int32_t *quantized, uint32_t *result)
Definition: dcaenc.c:688
init_quantization_noise
static int init_quantization_noise(DCAEncContext *c, int noise, int forbid_zero)
Definition: dcaenc.c:766
ff_dca_quant_levels
const uint32_t ff_dca_quant_levels[32]
Definition: dcadata.c:4215
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
dcadata.h
dca_core.h
DCAEncContext::auf
int32_t auf[9][AUBANDS][256]
Definition: dcaenc.c:106
DCAEncContext::consumed_bits
int consumed_bits
Definition: dcaenc.c:100
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:86
bit_consumption
static const int bit_consumption[27]
Definition: dcaenc.h:101
walk_band_high
static void walk_band_high(DCAEncContext *c, int band, int channel, walk_band_t walk, int32_t *arg)
Definition: dcaenc.c:485
quantize_adpcm_subband
static void quantize_adpcm_subband(DCAEncContext *c, int ch, int band)
Definition: dcaenc.c:644
DCAEncContext::quantized
int32_t quantized[MAX_CHANNELS][DCAENC_SUBBANDS][SUBBAND_SAMPLES]
Definition: dcaenc.c:86
avassert.h
DCAEncContext::lfe_fir_64i
int32_t lfe_fir_64i[512]
Definition: dcaenc.c:109
ff_samples_to_time_base
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
Definition: internal.h:288
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AV_CODEC_CAP_EXPERIMENTAL
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:1029
av_cold
#define av_cold
Definition: attributes.h:84
DCA_LFE_SAMPLES
#define DCA_LFE_SAMPLES
Definition: dcaenc.c:47
quantize_adpcm
static void quantize_adpcm(DCAEncContext *c)
Definition: dcaenc.c:661
DCAEncContext::lfe_channel
int lfe_channel
Definition: dcaenc.c:71
DCAEncContext::abits
int abits[MAX_CHANNELS][DCAENC_SUBBANDS]
Definition: dcaenc.c:92
DCAEncContext::peak_cb
int32_t peak_cb[MAX_CHANNELS][DCAENC_SUBBANDS]
Definition: dcaenc.c:87
DCAEncContext::band_spectrum
const int32_t * band_spectrum
Definition: dcaenc.c:76
DCAEncContext::lfe_scale_factor
int lfe_scale_factor
Definition: dcaenc.c:77
s
#define s(width, name)
Definition: cbs_vp9.c:257
DCA_ADPCM_COEFFS
#define DCA_ADPCM_COEFFS
Definition: dcadata.h:28
hom
static double hom(double f)
Definition: dcaenc.c:113
DCAEncContext::eff_masking_curve_cb
int32_t eff_masking_curve_cb[256]
Definition: dcaenc.c:96
DCAEncContext::downsampled_lfe
int32_t downsampled_lfe[DCA_LFE_SAMPLES]
Definition: dcaenc.c:89
SUBBAND_SAMPLES
#define SUBBAND_SAMPLES
Definition: dcaenc.c:52
frame_size
int frame_size
Definition: mxfenc.c:2215
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
DCAEncContext::samplerate_index
int samplerate_index
Definition: dcaenc.c:72
bits
uint8_t bits
Definition: vp3data.h:202
set_best_abits_code
static uint32_t set_best_abits_code(int abits[DCAENC_SUBBANDS], int bands, int32_t *res)
Definition: dcaenc.c:738
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
CompressionOptions
Definition: dcaenc.c:57
bands
static const float bands[]
Definition: af_superequalizer.c:56
f
#define f(width, name)
Definition: cbs_vp9.c:255
PutBitContext
Definition: put_bits.h:35
int32_t
int32_t
Definition: audio_convert.c:194
arg
const char * arg
Definition: jacosubdec.c:66
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
if
if(ret)
Definition: filter_design.txt:179
AVCodecDefault
Definition: internal.h:231
softfloat
Definition: dcaenc.h:29
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
adjust_jnd
static void adjust_jnd(DCAEncContext *c, const int32_t in[512], int32_t out_cb[256])
Definition: dcaenc.c:437
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
ff_dca_lossless_quant
const uint32_t ff_dca_lossless_quant[32]
Definition: dcadata.c:4231
mul32
static int32_t mul32(int32_t a, int32_t b)
Definition: dcamath.h:52
ff_dca_lfe_fir_64
const float ff_dca_lfe_fir_64[256]
Definition: dcadata.c:7339
AV_COPY128U
#define AV_COPY128U(d, s)
Definition: intreadwrite.h:580
USED_26ABITS
#define USED_26ABITS
Definition: dcaenc.c:597
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1615
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
USED_1ABITS
#define USED_1ABITS
Definition: dcaenc.c:596
ff_dca_vlc_calc_quant_bits
uint32_t ff_dca_vlc_calc_quant_bits(int *values, uint8_t n, uint8_t sel, uint8_t table)
Definition: dcahuff.c:1338
stepsize_inv
static const softfloat stepsize_inv[27]
Definition: dcaenc.h:53
mathops.h
AV_CH_LAYOUT_5POINT1
#define AV_CH_LAYOUT_5POINT1
Definition: channel_layout.h:96
softfloat::e
int32_t e
Definition: dcaenc.h:31
DCAEncContext::band_masking_cb
int32_t band_masking_cb[32]
Definition: dcaenc.c:97
abs
#define abs(x)
Definition: cuda_runtime.h:35
ff_dcaadpcm_subband_analysis
int ff_dcaadpcm_subband_analysis(const DCAADPCMEncContext *s, const int32_t *in, int len, int *diff)
Definition: dcaadpcm.c:125
DCAEncContext::mdct
FFTContext mdct
Definition: dcaenc.c:65
exp
int8_t exp
Definition: eval.c:72
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
DCAEncContext::channels
int channels
Definition: dcaenc.c:70
encode_close
static av_cold int encode_close(AVCodecContext *avctx)
Definition: dcaenc.c:308
SUBFRAMES
#define SUBFRAMES
Definition: dcaenc.c:50
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
DCAEncContext::worst_quantization_noise
int32_t worst_quantization_noise
Definition: dcaenc.c:98
DCAEncContext::band_interpolation_tab
int32_t band_interpolation_tab[2][512]
Definition: dcaenc.c:104
DCAEncContext::lfe_peak_cb
int32_t lfe_peak_cb
Definition: dcaenc.c:79
ff_dca_scale_factor_quant7
const uint32_t ff_dca_scale_factor_quant7[128]
Definition: dcadata.c:4172
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
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:329
subband_bufer_free
static void subband_bufer_free(DCAEncContext *c)
Definition: dcaenc.c:153
DCAEncContext::quant
softfloat quant[MAX_CHANNELS][DCAENC_SUBBANDS]
Definition: dcaenc.c:94
walk_band_t
void(* walk_band_t)(DCAEncContext *c, int band1, int band2, int f, int32_t spectrum1, int32_t spectrum2, int channel, int32_t *arg)
Definition: dcaenc.c:466
add_cb
static int32_t add_cb(DCAEncContext *c, int32_t a, int32_t b)
Definition: dcaenc.c:410
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: avcodec.h:568
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
sample
#define sample
Definition: flacdsp_template.c:44
DCA_CODE_BOOKS
#define DCA_CODE_BOOKS
Definition: dcahuff.h:32
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:170
DCA_BITALLOC_12_COUNT
#define DCA_BITALLOC_12_COUNT
Definition: dcahuff.h:33
encode_init
static int encode_init(AVCodecContext *avctx)
Definition: dcaenc.c:162
fill_in_adpcm_bufer
static void fill_in_adpcm_bufer(DCAEncContext *c)
Definition: dcaenc.c:899
DCAEncContext::bitrate_index
int bitrate_index
Definition: dcaenc.c:73
dcaadpcm.h
DCA_MAX_FRAME_SIZE
#define DCA_MAX_FRAME_SIZE
Definition: dcaenc.c:45
quantize_pcm
static void quantize_pcm(DCAEncContext *c)
Definition: dcaenc.c:671
val
const char const char void * val
Definition: avisynth_c.h:863
DCAEncContext::masking_curve_cb
int32_t masking_curve_cb[SUBSUBFRAMES][256]
Definition: dcaenc.c:90
dcaenc.h
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
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
put_primary_audio_header
static void put_primary_audio_header(DCAEncContext *c)
Definition: dcaenc.c:1024
M_PI
#define M_PI
Definition: mathematics.h:52
sample_rates
sample_rates
Definition: ffmpeg_filter.c:191
DCAEncContext::quant_index_sel
int32_t quant_index_sel[MAX_CHANNELS][DCA_CODE_BOOKS]
Definition: dcaenc.c:95
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:2226
layout
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 layout
Definition: filter_design.txt:18
DCAEncContext::frame_bits
int frame_bits
Definition: dcaenc.c:68
AV_CH_LAYOUT_5POINT0
#define AV_CH_LAYOUT_5POINT0
Definition: channel_layout.h:95
find_peaks
static void find_peaks(DCAEncContext *c)
Definition: dcaenc.c:557
ff_dca_quant_index_sel_nbits
const uint8_t ff_dca_quant_index_sel_nbits[DCA_CODE_BOOKS]
Definition: dcadata.c:49
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:326
FFTContext
Definition: fft.h:88
ff_dca_vlc_enc_quant
void ff_dca_vlc_enc_quant(PutBitContext *pb, int *values, uint8_t n, uint8_t sel, uint8_t table)
Definition: dcahuff.c:1350
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
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
common.h
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
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
AUBANDS
#define AUBANDS
Definition: dcaenc.c:53
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
len
int len
Definition: vorbis_enc_data.h:452
norm__
static int32_t norm__(int64_t a, int bits)
Definition: dcamath.h:27
DCAEncContext::channel_config
int channel_config
Definition: dcaenc.c:74
channel_reorder_nolfe
static const int8_t channel_reorder_nolfe[7][5]
Definition: dca_lbr.c:85
avcodec.h
snr_fudge
static const int snr_fudge
Definition: dcaenc.c:595
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
subband_transform
static void subband_transform(DCAEncContext *c, const int32_t *input)
Definition: dcaenc.c:318
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
DCAEncContext::consumed_adpcm_bits
int consumed_adpcm_bits
Number of bits to transmit ADPCM related info.
Definition: dcaenc.c:101
channel_reorder_lfe
static const int8_t channel_reorder_lfe[7][5]
Definition: dca_lbr.c:95
ff_dca_core_dequantize
static void ff_dca_core_dequantize(int32_t *output, const int32_t *input, int32_t step_size, int32_t scale, int residual, int len)
Definition: dca_core.h:227
fft.h
ff_dcaadpcm_init
av_cold int ff_dcaadpcm_init(DCAADPCMEncContext *s)
Definition: dcaadpcm.c:212
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
channel_layout.h
noise
static int noise(AVBSFContext *ctx, AVPacket *pkt)
Definition: noise_bsf.c:38
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
DCAEncContext
Definition: dcaenc.c:61
ffmath.h
subband_bufer_alloc
static int subband_bufer_alloc(DCAEncContext *c)
Definition: dcaenc.c:132
assign_bits
static void assign_bits(DCAEncContext *c)
Definition: dcaenc.c:845
DCAENC_SUBBANDS
#define DCAENC_SUBBANDS
Definition: dcaenc.c:49
get_cb
static int32_t get_cb(DCAEncContext *c, int32_t in)
Definition: dcaenc.c:398
DCAEncContext::cos_table
int32_t cos_table[2048]
Definition: dcaenc.c:103
bitstream_sfreq
static const uint8_t bitstream_sfreq[]
Definition: dcaenc.h:38
find_peak
static int32_t find_peak(DCAEncContext *c, const int32_t *in, int len)
Definition: dcaenc.c:545
av_get_default_channel_layout
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
Definition: channel_layout.c:225
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
quant
const uint8_t * quant
Definition: vorbis_enc_data.h:458
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1592
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:240
ff_dca_fir_32bands_perfect
const float ff_dca_fir_32bands_perfect[512]
Definition: dcadata.c:6293
defaults
static const AVCodecDefault defaults[]
Definition: dcaenc.c:1235
shift_history
static void shift_history(DCAEncContext *c, const int32_t *input)
Definition: dcaenc.c:887
set_best_code
static uint32_t set_best_code(uint32_t vlc_bits[DCA_CODE_BOOKS][7], uint32_t clc_bits[DCA_CODE_BOOKS], int32_t res[DCA_CODE_BOOKS])
Definition: dcaenc.c:697
softfloat::m
int32_t m
Definition: dcaenc.h:30
DCAEncContext::prediction_mode
int32_t prediction_mode[MAX_CHANNELS][DCAENC_SUBBANDS]
Definition: dcaenc.c:82
ff_dca_vlc_enc_alloc
void ff_dca_vlc_enc_alloc(PutBitContext *pb, int *values, uint8_t n, uint8_t sel)
Definition: dcahuff.c:1371
DCAEncContext::cb_to_add
int32_t cb_to_add[256]
Definition: dcaenc.c:107
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition: internal.h:137
COS_T
#define COS_T(x)
Definition: dcaenc.c:55
h
h
Definition: vp9dsp_template.c:2038
DCAEncContext::cb_to_level
int32_t cb_to_level[2048]
Definition: dcaenc.c:108
put_subframe_samples
static void put_subframe_samples(DCAEncContext *c, int ss, int band, int ch)
Definition: dcaenc.c:1071
DCAEncContext::bit_allocation_sel
int32_t bit_allocation_sel[MAX_CHANNELS]
Definition: dcaenc.c:91
DCAEncContext::band_spectrum_tab
int32_t band_spectrum_tab[2][8]
Definition: dcaenc.c:105
ff_alloc_packet2
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
put_bits.h
calc_power
static void calc_power(DCAEncContext *c, const int32_t in[2 *256], int32_t power[256])
Definition: dcaenc.c:420
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:62
AV_CH_LAYOUT_2_2
#define AV_CH_LAYOUT_2_2
Definition: channel_layout.h:93
channel
channel
Definition: ebur128.h:39
DCAEncContext::diff_peak_cb
int32_t diff_peak_cb[MAX_CHANNELS][DCAENC_SUBBANDS]
expected peak of residual signal
Definition: dcaenc.c:88
DCAENC_FLAGS
#define DCAENC_FLAGS
Definition: dcaenc.c:1221
dcaenc_class
static const AVClass dcaenc_class
Definition: dcaenc.c:1228
DCAEncContext::scale_factor
int scale_factor[MAX_CHANNELS][DCAENC_SUBBANDS]
Definition: dcaenc.c:93
gammafilter
static double gammafilter(int i, double f)
Definition: dcaenc.c:123
DCAEncContext::channel_order_tab
const int8_t * channel_order_tab
channel reordering table, lfe and non lfe
Definition: dcaenc.c:80
Generated on Wed Aug 24 2022 21:26:37 for FFmpeg by   doxygen 1.8.17