FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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
101  int consumed_adpcm_bits; ///< Number of bits to transmit ADPCM related info
102 
106  int32_t auf[9][AUBANDS][256];
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 -1;
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 (subband_bufer_alloc(c))
170  return AVERROR(ENOMEM);
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 
318 static void subband_transform(DCAEncContext *c, const int32_t *input)
319 {
320  int ch, subs, i, k, j;
321 
322  for (ch = 0; ch < c->fullband_channels; ch++) {
323  /* History is copied because it is also needed for PSY */
324  int32_t hist[512];
325  int hist_start = 0;
326  const int chi = c->channel_order_tab[ch];
327 
328  memcpy(hist, &c->history[ch][0], 512 * sizeof(int32_t));
329 
330  for (subs = 0; subs < SUBBAND_SAMPLES; subs++) {
331  int32_t accum[64];
332  int32_t resp;
333  int band;
334 
335  /* Calculate the convolutions at once */
336  memset(accum, 0, 64 * sizeof(int32_t));
337 
338  for (k = 0, i = hist_start, j = 0;
339  i < 512; k = (k + 1) & 63, i++, j++)
340  accum[k] += mul32(hist[i], c->band_interpolation[j]);
341  for (i = 0; i < hist_start; k = (k + 1) & 63, i++, j++)
342  accum[k] += mul32(hist[i], c->band_interpolation[j]);
343 
344  for (k = 16; k < 32; k++)
345  accum[k] = accum[k] - accum[31 - k];
346  for (k = 32; k < 48; k++)
347  accum[k] = accum[k] + accum[95 - k];
348 
349  for (band = 0; band < 32; band++) {
350  resp = 0;
351  for (i = 16; i < 48; i++) {
352  int s = (2 * band + 1) * (2 * (i + 16) + 1);
353  resp += mul32(accum[i], COS_T(s << 3)) >> 3;
354  }
355 
356  c->subband[ch][band][subs] = ((band + 1) & 2) ? -resp : resp;
357  }
358 
359  /* Copy in 32 new samples from input */
360  for (i = 0; i < 32; i++)
361  hist[i + hist_start] = input[(subs * 32 + i) * c->channels + chi];
362 
363  hist_start = (hist_start + 32) & 511;
364  }
365  }
366 }
367 
368 static void lfe_downsample(DCAEncContext *c, const int32_t *input)
369 {
370  /* FIXME: make 128x LFE downsampling possible */
371  const int lfech = lfe_index[c->channel_config];
372  int i, j, lfes;
373  int32_t hist[512];
374  int32_t accum;
375  int hist_start = 0;
376 
377  memcpy(hist, &c->history[c->channels - 1][0], 512 * sizeof(int32_t));
378 
379  for (lfes = 0; lfes < DCA_LFE_SAMPLES; lfes++) {
380  /* Calculate the convolution */
381  accum = 0;
382 
383  for (i = hist_start, j = 0; i < 512; i++, j++)
384  accum += mul32(hist[i], c->lfe_fir_64i[j]);
385  for (i = 0; i < hist_start; i++, j++)
386  accum += mul32(hist[i], c->lfe_fir_64i[j]);
387 
388  c->downsampled_lfe[lfes] = accum;
389 
390  /* Copy in 64 new samples from input */
391  for (i = 0; i < 64; i++)
392  hist[i + hist_start] = input[(lfes * 64 + i) * c->channels + lfech];
393 
394  hist_start = (hist_start + 64) & 511;
395  }
396 }
397 
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 */
711  res[i] = ff_dca_quant_index_group_size[i];
712  /* and skip it */
713  continue;
714  }
715 
716  best_sel_bits[i] = vlc_bits[i][0];
717  best_sel_id[i] = 0;
718  for (sel = 0; sel < ff_dca_quant_index_group_size[i]; sel++) {
719  if (best_sel_bits[i] > vlc_bits[i][sel] && vlc_bits[i][sel]) {
720  best_sel_bits[i] = vlc_bits[i][sel];
721  best_sel_id[i] = sel;
722  }
723  }
724 
725  /* 2 bits to transmit scale factor adjustment index */
726  t = best_sel_bits[i] + 2;
727  if (t < clc_bits[i]) {
728  res[i] = best_sel_id[i];
729  bits += t;
730  } else {
731  res[i] = ff_dca_quant_index_group_size[i];
732  bits += clc_bits[i];
733  }
734  }
735  return bits;
736 }
737 
738 static uint32_t set_best_abits_code(int abits[DCAENC_SUBBANDS], int bands,
739  int32_t *res)
740 {
741  uint8_t i;
742  uint32_t t;
743  int32_t best_sel = 6;
744  int32_t best_bits = bands * 5;
745 
746  /* Check do we have subband which cannot be encoded by Huffman tables */
747  for (i = 0; i < bands; i++) {
748  if (abits[i] > 12 || abits[i] == 0) {
749  *res = best_sel;
750  return best_bits;
751  }
752  }
753 
754  for (i = 0; i < DCA_BITALLOC_12_COUNT; i++) {
755  t = ff_dca_vlc_calc_alloc_bits(abits, bands, i);
756  if (t < best_bits) {
757  best_bits = t;
758  best_sel = i;
759  }
760  }
761 
762  *res = best_sel;
763  return best_bits;
764 }
765 
766 static int init_quantization_noise(DCAEncContext *c, int noise, int forbid_zero)
767 {
768  int ch, band, ret = USED_26ABITS | USED_1ABITS;
769  uint32_t huff_bit_count_accum[MAX_CHANNELS][DCA_CODE_BOOKS][7];
770  uint32_t clc_bit_count_accum[MAX_CHANNELS][DCA_CODE_BOOKS];
771  uint32_t bits_counter = 0;
772 
773  c->consumed_bits = 132 + 333 * c->fullband_channels;
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 
887 static void shift_history(DCAEncContext *c, const int32_t *input)
888 {
889  int k, ch;
890 
891  for (k = 0; k < 512; k++)
892  for (ch = 0; ch < c->channels; ch++) {
893  const int chi = c->channel_order_tab[ch];
894 
895  c->history[ch][k] = input[k * c->channels + chi];
896  }
897 }
898 
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:771
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:218
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:101
int32_t eff_masking_curve_cb[256]
Definition: dcaenc.c:96
void(* mdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:109
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:1582
#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:1445
const char * b
Definition: vf_curves.c:113
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
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:1015
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:3423
#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:1462
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:311
int32_t masking_curve_cb[SUBSUBFRAMES][256]
Definition: dcaenc.c:90
static AVFrame * frame
int32_t cb_to_level[2048]
Definition: dcaenc.c:108
uint8_t * data
Definition: avcodec.h:1444
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:565
#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
static double hom(double f)
Definition: dcaenc.c:113
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 AVERROR(e)
Definition: error.h:43
#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
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: avcodec.h:3430
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:2239
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
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
static const uint16_t fc[]
Definition: dcaenc.h:43
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)
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
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
#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
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:2208
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:2166
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:2188
main external API structure.
Definition: avcodec.h:1532
static const float bands[]
int32_t cos_table[2048]
Definition: dcaenc.c:103
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;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);returnNULL;}returnac;}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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
static void put_subframe_samples(DCAEncContext *c, int ss, int band, int ch)
Definition: dcaenc.c:1071
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
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:232
#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
if(ret< 0)
Definition: vf_mcdeint.c:279
#define USED_26ABITS
Definition: dcaenc.c:597
#define ff_mdct_end
Definition: fft.h:170
static double c[64]
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:1559
#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:2189
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
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
uint64_t layout
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
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:280
#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
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:1421
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:284
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:1437
int32_t band_interpolation_tab[2][512]
Definition: dcaenc.c:104
for(j=16;j >0;--j)
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_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),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){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) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;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)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8: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);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
static int32_t get_step_size(DCAEncContext *c, int ch, int band)
Definition: dcaenc.c:599
bitstream writer API