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