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"
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 {
60 
61 typedef struct DCAEncContext {
62  AVClass *class;
70  int channels;
80  const int8_t *channel_order_tab; ///< channel reordering table, lfe and non lfe
81 
84  int32_t history[MAX_CHANNELS][512]; /* This is a circular buffer */
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];
93  int scale_factor[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];
101  int consumed_adpcm_bits; ///< Number of bits to transmit ADPCM related info
102 
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 
133 {
134  int ch, band;
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) +
148  }
149  }
150  return 0;
151 }
152 
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);
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--;
203  } else {
205  }
206 
207  for (i = 0; i < MAX_CHANNELS; i++) {
208  for (j = 0; j < DCA_CODE_BOOKS; 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 
309 {
310  DCAEncContext *c = avctx->priv_data;
311  ff_mdct_end(&c->mdct);
314 
315  return 0;
316 }
317 
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 
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 
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 
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 
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 
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);
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 
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],
565  }
566 
567  if (c->lfe_channel)
569 }
570 
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);
654  c->quant[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 
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 
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 */
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;
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) {
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 
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:
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 
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 
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 
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 
936 {
937  if (c->lfe_channel)
939 }
940 
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 */
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 
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++)
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++)
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);
1203  put_frame_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 
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,
1251  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32,
1253  .supported_samplerates = sample_rates,
1254  .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO,
1259  0 },
1260  .defaults = defaults,
1261  .priv_class = &dcaenc_class,
1262 };
#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
av_cold int ff_dcaadpcm_init(DCAADPCMEncContext *s)
Definition: dcaadpcm.c:212
static int32_t find_peak(DCAEncContext *c, const int32_t *in, int len)
Definition: dcaenc.c:545
#define MAX_CHANNELS
Definition: dcaenc.c:44
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:863
int32_t diff_peak_cb[MAX_CHANNELS][DCAENC_SUBBANDS]
expected peak of residual signal
Definition: dcaenc.c:88
int32_t m
Definition: dcaenc.h:30
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
uint32_t ff_dca_vlc_calc_alloc_bits(int *values, uint8_t n, uint8_t sel)
Definition: dcahuff.c:1360
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int32_t eff_masking_curve_cb[256]
Definition: dcaenc.c:96
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:240
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
static void put_frame_header(DCAEncContext *c)
Definition: dcaenc.c:941
const uint32_t ff_dca_lossy_quant[32]
Definition: dcadata.c:4223
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1618
#define AUBANDS
Definition: dcaenc.c:53
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
const int8_t * channel_order_tab
channel reordering table, lfe and non lfe
Definition: dcaenc.c:80
int size
Definition: avcodec.h:1481
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
static const uint8_t bitstream_sfreq[]
Definition: dcaenc.h:38
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
static const uint16_t erb[]
Definition: dcaenc.h:48
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:36
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:1032
static int calc_one_scale(DCAEncContext *c, int32_t peak_cb, int abits, softfloat *quant)
Definition: dcaenc.c:611
static void shift_history(DCAEncContext *c, const int32_t *input)
Definition: dcaenc.c:887
softfloat lfe_quant
Definition: dcaenc.c:78
#define AV_CH_LAYOUT_STEREO
static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: dcaenc.c:1177
#define sample
static void walk_band_high(DCAEncContext *c, int band, int channel, walk_band_t walk, int32_t *arg)
Definition: dcaenc.c:485
AVCodec.
Definition: avcodec.h:3484
#define AV_CH_LAYOUT_5POINT0
CompressionOptions options
Definition: dcaenc.c:66
int abits[MAX_CHANNELS][DCAENC_SUBBANDS]
Definition: dcaenc.c:92
static av_cold int encode_close(AVCodecContext *avctx)
Definition: dcaenc.c:308
int frame_size
Definition: dcaenc.c:67
const float ff_dca_fir_32bands_nonperfect[512]
Definition: dcadata.c:6808
static void walk_band_low(DCAEncContext *c, int band, int channel, walk_band_t walk, int32_t *arg)
Definition: dcaenc.c:470
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
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
static int32_t quantize_value(int32_t value, softfloat quant)
Definition: dcaenc.h:149
softfloat quant[MAX_CHANNELS][DCAENC_SUBBANDS]
Definition: dcaenc.c:94
static void accumulate_huff_bit_consumption(int abits, int32_t *quantized, uint32_t *result)
Definition: dcaenc.c:688
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
int32_t cb_to_add[256]
Definition: dcaenc.c:107
static int32_t get_cb(DCAEncContext *c, int32_t in)
Definition: dcaenc.c:398
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define SUBSUBFRAMES
Definition: dcaenc.c:51
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
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:112
#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
static void calc_masking(DCAEncContext *c, const int32_t *input)
Definition: dcaenc.c:510
static const softfloat stepsize_inv[27]
Definition: dcaenc.h:53
const uint32_t ff_dca_bit_rates[32]
Definition: dcadata.c:32
uint8_t
#define av_cold
Definition: attributes.h:82
AVOptions.
#define f(width, name)
Definition: cbs_vp9.c:255
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1498
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
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
int32_t masking_curve_cb[SUBSUBFRAMES][256]
Definition: dcaenc.c:90
int32_t cb_to_level[2048]
Definition: dcaenc.c:108
uint8_t * data
Definition: avcodec.h:1480
int frame_bits
Definition: dcaenc.c:68
int lfe_channel
Definition: dcaenc.c:71
static void adjust_jnd(DCAEncContext *c, const int32_t in[512], int32_t out_cb[256])
Definition: dcaenc.c:437
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
signed 32 bits
Definition: samplefmt.h:62
#define AV_COPY128U(d, s)
Definition: intreadwrite.h:580
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
int scale_factor[MAX_CHANNELS][DCAENC_SUBBANDS]
Definition: dcaenc.c:93
#define DCA_LFE_SAMPLES
Definition: dcaenc.c:47
static void adpcm_analysis(DCAEncContext *c)
Definition: dcaenc.c:571
#define AV_CH_LAYOUT_5POINT1
#define USED_1ABITS
Definition: dcaenc.c:596
static const softfloat scalefactor_inv[128]
Definition: dcaenc.h:63
static void lfe_downsample(DCAEncContext *c, const int32_t *input)
Definition: dcaenc.c:368
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:551
static double hom(double f)
Definition: dcaenc.c:113
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int32_t band_masking_cb[32]
Definition: dcaenc.c:97
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static void put_subframe(DCAEncContext *c, int subframe)
Definition: dcaenc.c:1105
int32_t auf[9][AUBANDS][256]
Definition: dcaenc.c:106
int samplerate_index
Definition: dcaenc.c:72
static const int snr_fudge
Definition: dcaenc.c:595
#define DCA_ADPCM_COEFFS
Definition: dcadata.h:28
const uint8_t ff_dca_quant_index_group_size[DCA_CODE_BOOKS]
Definition: dcadata.c:53
const uint32_t ff_dca_lossless_quant[32]
Definition: dcadata.c:4231
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int channels
Definition: dcaenc.c:70
static uint32_t set_best_abits_code(int abits[DCAENC_SUBBANDS], int bands, int32_t *res)
Definition: dcaenc.c:738
const float ff_dca_lfe_fir_64[256]
Definition: dcadata.c:7339
const char * arg
Definition: jacosubdec.c:66
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
void(* mdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:109
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: avcodec.h:3491
uint8_t bits
Definition: vp3data.h:202
const uint32_t ff_dca_quant_levels[32]
Definition: dcadata.c:4215
#define ff_mdct_init
Definition: fft.h:169
int8_t exp
Definition: eval.c:72
static int32_t add_cb(DCAEncContext *c, int32_t a, int32_t b)
Definition: dcaenc.c:410
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2279
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
int32_t e
Definition: dcaenc.h:31
#define AV_CH_LAYOUT_2_2
static const unsigned short cos_table[(1<< COS_TABLE_BITS)+2]
Definition: audiogen.c:52
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
#define b
Definition: input.c:41
Definition: fft.h:88
static void assign_bits(DCAEncContext *c)
Definition: dcaenc.c:845
audio channel layout utility functions
static int subband_bufer_alloc(DCAEncContext *c)
Definition: dcaenc.c:132
int32_t prediction_mode[MAX_CHANNELS][DCAENC_SUBBANDS]
Definition: dcaenc.c:82
static void calc_lfe_scales(DCAEncContext *c)
Definition: dcaenc.c:935
int fullband_channels
Definition: dcaenc.c:69
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
DCAADPCMEncContext adpcm_ctx
Definition: dcaenc.c:64
uint32_t ff_dca_vlc_calc_quant_bits(int *values, uint8_t n, uint8_t sel, uint8_t table)
Definition: dcahuff.c:1338
int32_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
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
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
static void quantize_adpcm_subband(DCAEncContext *c, int ch, int band)
Definition: dcaenc.c:644
int32_t worst_noise_ever
Definition: dcaenc.c:99
#define DCA_MAX_FRAME_SIZE
Definition: dcaenc.c:45
int consumed_adpcm_bits
Number of bits to transmit ADPCM related info.
Definition: dcaenc.c:101
#define DCAENC_SUBBANDS
Definition: dcaenc.c:49
if(ret)
int32_t lfe_peak_cb
Definition: dcaenc.c:79
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
const uint32_t ff_dca_scale_factor_quant7[128]
Definition: dcadata.c:4172
static int32_t mul32(int32_t a, int32_t b)
Definition: dcamath.h:52
#define SUBBAND_SAMPLES
Definition: dcaenc.c:52
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2248
int32_t band_spectrum_tab[2][8]
Definition: dcaenc.c:105
static int init_quantization_noise(DCAEncContext *c, int noise, int forbid_zero)
Definition: dcaenc.c:766
int bitrate_index
Definition: dcaenc.c:73
static const int8_t channel_reorder_lfe[7][5]
Definition: dca_lbr.c:95
static void put_primary_audio_header(DCAEncContext *c)
Definition: dcaenc.c:1024
int frame_size
Definition: mxfenc.c:2214
static void find_peaks(DCAEncContext *c)
Definition: dcaenc.c:557
void ff_dca_vlc_enc_quant(PutBitContext *pb, int *values, uint8_t n, uint8_t sel, uint8_t table)
Definition: dcahuff.c:1350
Libavcodec external API header.
const int32_t * band_spectrum
Definition: dcaenc.c:76
#define DCAENC_FLAGS
Definition: dcaenc.c:1221
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int32_t history[MAX_CHANNELS][512]
Definition: dcaenc.c:84
#define DCA_CODE_BOOKS
Definition: dcahuff.h:32
int sample_rate
samples per second
Definition: avcodec.h:2228
#define abs(x)
Definition: cuda_runtime.h:35
main external API structure.
Definition: avcodec.h:1568
static const float bands[]
int32_t cos_table[2048]
Definition: dcaenc.c:103
static void put_subframe_samples(DCAEncContext *c, int ss, int band, int ch)
Definition: dcaenc.c:1071
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
static void quantize_adpcm(DCAEncContext *c)
Definition: dcaenc.c:661
static void calc_power(DCAEncContext *c, const int32_t in[2 *256], int32_t power[256])
Definition: dcaenc.c:420
Describe the class of an AVClass context structure.
Definition: log.h:67
FFTContext mdct
Definition: dcaenc.c:65
static const AVOption options[]
Definition: dcaenc.c:1223
int ff_dcaadpcm_subband_analysis(const DCAADPCMEncContext *s, const int32_t *in, int len, int *diff)
Definition: dcaadpcm.c:125
const uint8_t ff_dca_quant_index_sel_nbits[DCA_CODE_BOOKS]
Definition: dcadata.c:49
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
int32_t worst_quantization_noise
Definition: dcaenc.c:98
static int encode_init(AVCodecContext *avctx)
Definition: dcaenc.c:162
static void fill_in_adpcm_bufer(DCAEncContext *c)
Definition: dcaenc.c:899
static void quantize_pcm(DCAEncContext *c)
Definition: dcaenc.c:671
#define DCA_BITALLOC_12_COUNT
Definition: dcahuff.h:33
static int noise(AVBSFContext *ctx, AVPacket *pkt)
Definition: noise_bsf.c:38
const uint8_t * quant
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
#define SUBFRAMES
Definition: dcaenc.c:50
static void subband_transform(DCAEncContext *c, const int32_t *input)
Definition: dcaenc.c:318
#define LOCAL_ALIGNED_32(t, v,...)
Definition: internal.h:137
internal math functions header
int channel_config
Definition: dcaenc.c:74
AVCodec ff_dca_encoder
Definition: dcaenc.c:1240
#define COS_T(x)
Definition: dcaenc.c:55
PutBitContext pb
Definition: dcaenc.c:63
common internal api header.
sample_rates
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
common internal and external API header
#define USED_26ABITS
Definition: dcaenc.c:597
#define ff_mdct_end
Definition: fft.h:170
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
static void subband_bufer_free(DCAEncContext *c)
Definition: dcaenc.c:153
int lfe_scale_factor
Definition: dcaenc.c:77
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
int32_t quant_index_sel[MAX_CHANNELS][DCA_CODE_BOOKS]
Definition: dcaenc.c:95
void * priv_data
Definition: avcodec.h:1595
#define av_free(p)
int32_t quantized[MAX_CHANNELS][DCAENC_SUBBANDS][SUBBAND_SAMPLES]
Definition: dcaenc.c:86
int consumed_bits
Definition: dcaenc.c:100
int len
int channels
number of audio channels
Definition: avcodec.h:2229
static int32_t norm__(int64_t a, int bits)
Definition: dcamath.h:27
int32_t * subband[MAX_CHANNELS][DCAENC_SUBBANDS]
Definition: dcaenc.c:85
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
static const int8_t channel_reorder_nolfe[7][5]
Definition: dca_lbr.c:85
and forward the result(frame or status change) to the corresponding input.If nothing is possible
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
FILE * out
Definition: movenc.c:54
Filter the word “frame” indicates either a video frame or a group of audio samples
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
const int32_t * band_interpolation
Definition: dcaenc.c:75
int32_t downsampled_lfe[DCA_LFE_SAMPLES]
Definition: dcaenc.c:89
int32_t peak_cb[MAX_CHANNELS][DCAENC_SUBBANDS]
Definition: dcaenc.c:87
int32_t bit_allocation_sel[MAX_CHANNELS]
Definition: dcaenc.c:91
#define M_PI
Definition: mathematics.h:52
av_cold void ff_dcaadpcm_free(DCAADPCMEncContext *s)
Definition: dcaadpcm.c:225
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
#define FFSWAP(type, a, b)
Definition: common.h:99
static const AVCodecDefault defaults[]
Definition: dcaenc.c:1235
static const uint8_t lfe_index[7]
Definition: dca_lbr.c:105
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
static const int bit_consumption[27]
Definition: dcaenc.h:101
const float ff_dca_fir_32bands_perfect[512]
Definition: dcadata.c:6293
int32_t adpcm_history[MAX_CHANNELS][DCAENC_SUBBANDS][DCA_ADPCM_COEFFS *2]
Definition: dcaenc.c:83
#define AV_CH_LAYOUT_MONO
int32_t lfe_fir_64i[512]
Definition: dcaenc.c:109
enum AVCodecID id
This structure stores compressed data.
Definition: avcodec.h:1457
static const AVClass dcaenc_class
Definition: dcaenc.c:1228
void ff_dca_vlc_enc_alloc(PutBitContext *pb, int *values, uint8_t n, uint8_t sel)
Definition: dcahuff.c:1371
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
static double gammafilter(int i, double f)
Definition: dcaenc.c:123
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1473
int32_t band_interpolation_tab[2][512]
Definition: dcaenc.c:104
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
for(j=16;j >0;--j)
static int32_t get_step_size(DCAEncContext *c, int ch, int band)
Definition: dcaenc.c:599
bitstream writer API