FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
opusenc.c
Go to the documentation of this file.
1 /*
2  * Opus encoder
3  * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "opusenc.h"
23 #include "opus_pvq.h"
24 #include "opusenc_psy.h"
25 #include "opustab.h"
26 
27 #include "libavutil/float_dsp.h"
28 #include "libavutil/opt.h"
29 #include "internal.h"
30 #include "bytestream.h"
31 #include "audio_frame_queue.h"
32 
33 typedef struct OpusEncContext {
43 
46 
48 
49  int channels;
50 
53 
54  /* Actual energy the decoder will have */
56 
57  DECLARE_ALIGNED(32, float, scratch)[2048];
59 
61 {
62  uint8_t *bs = avctx->extradata;
63 
64  bytestream_put_buffer(&bs, "OpusHead", 8);
65  bytestream_put_byte (&bs, 0x1);
66  bytestream_put_byte (&bs, avctx->channels);
67  bytestream_put_le16 (&bs, avctx->initial_padding);
68  bytestream_put_le32 (&bs, avctx->sample_rate);
69  bytestream_put_le16 (&bs, 0x0);
70  bytestream_put_byte (&bs, 0x0); /* Default layout */
71 }
72 
73 static int opus_gen_toc(OpusEncContext *s, uint8_t *toc, int *size, int *fsize_needed)
74 {
75  int i, tmp = 0x0, extended_toc = 0;
76  static const int toc_cfg[][OPUS_MODE_NB][OPUS_BANDWITH_NB] = {
77  /* Silk Hybrid Celt Layer */
78  /* NB MB WB SWB FB NB MB WB SWB FB NB MB WB SWB FB Bandwidth */
79  { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 17, 0, 21, 25, 29 } }, /* 2.5 ms */
80  { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 18, 0, 22, 26, 30 } }, /* 5 ms */
81  { { 1, 5, 9, 0, 0 }, { 0, 0, 0, 13, 15 }, { 19, 0, 23, 27, 31 } }, /* 10 ms */
82  { { 2, 6, 10, 0, 0 }, { 0, 0, 0, 14, 16 }, { 20, 0, 24, 28, 32 } }, /* 20 ms */
83  { { 3, 7, 11, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } }, /* 40 ms */
84  { { 4, 8, 12, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } }, /* 60 ms */
85  };
86  int cfg = toc_cfg[s->packet.framesize][s->packet.mode][s->packet.bandwidth];
87  *fsize_needed = 0;
88  if (!cfg)
89  return 1;
90  if (s->packet.frames == 2) { /* 2 packets */
91  if (s->frame[0].framebits == s->frame[1].framebits) { /* same size */
92  tmp = 0x1;
93  } else { /* different size */
94  tmp = 0x2;
95  *fsize_needed = 1; /* put frame sizes in the packet */
96  }
97  } else if (s->packet.frames > 2) {
98  tmp = 0x3;
99  extended_toc = 1;
100  }
101  tmp |= (s->channels > 1) << 2; /* Stereo or mono */
102  tmp |= (cfg - 1) << 3; /* codec configuration */
103  *toc++ = tmp;
104  if (extended_toc) {
105  for (i = 0; i < (s->packet.frames - 1); i++)
106  *fsize_needed |= (s->frame[i].framebits != s->frame[i + 1].framebits);
107  tmp = (*fsize_needed) << 7; /* vbr flag */
108  tmp |= (0) << 6; /* padding flag */
109  tmp |= s->packet.frames;
110  *toc++ = tmp;
111  }
112  *size = 1 + extended_toc;
113  return 0;
114 }
115 
117 {
118  int sf, ch;
119  AVFrame *cur = NULL;
120  const int subframesize = s->avctx->frame_size;
121  int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;
122 
123  cur = ff_bufqueue_get(&s->bufqueue);
124 
125  for (ch = 0; ch < f->channels; ch++) {
126  CeltBlock *b = &f->block[ch];
127  const void *input = cur->extended_data[ch];
128  size_t bps = av_get_bytes_per_sample(cur->format);
129  memcpy(b->overlap, input, bps*cur->nb_samples);
130  }
131 
132  av_frame_free(&cur);
133 
134  for (sf = 0; sf < subframes; sf++) {
135  if (sf != (subframes - 1))
136  cur = ff_bufqueue_get(&s->bufqueue);
137  else
138  cur = ff_bufqueue_peek(&s->bufqueue, 0);
139 
140  for (ch = 0; ch < f->channels; ch++) {
141  CeltBlock *b = &f->block[ch];
142  const void *input = cur->extended_data[ch];
143  const size_t bps = av_get_bytes_per_sample(cur->format);
144  const size_t left = (subframesize - cur->nb_samples)*bps;
145  const size_t len = FFMIN(subframesize, cur->nb_samples)*bps;
146  memcpy(&b->samples[sf*subframesize], input, len);
147  memset(&b->samples[cur->nb_samples], 0, left);
148  }
149 
150  /* Last frame isn't popped off and freed yet - we need it for overlap */
151  if (sf != (subframes - 1))
152  av_frame_free(&cur);
153  }
154 }
155 
156 /* Apply the pre emphasis filter */
158 {
159  int i, sf, ch;
160  const int subframesize = s->avctx->frame_size;
161  const int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;
162 
163  /* Filter overlap */
164  for (ch = 0; ch < f->channels; ch++) {
165  CeltBlock *b = &f->block[ch];
166  float m = b->emph_coeff;
167  for (i = 0; i < CELT_OVERLAP; i++) {
168  float sample = b->overlap[i];
169  b->overlap[i] = sample - m;
170  m = sample * CELT_EMPH_COEFF;
171  }
172  b->emph_coeff = m;
173  }
174 
175  /* Filter the samples but do not update the last subframe's coeff - overlap ^^^ */
176  for (sf = 0; sf < subframes; sf++) {
177  for (ch = 0; ch < f->channels; ch++) {
178  CeltBlock *b = &f->block[ch];
179  float m = b->emph_coeff;
180  for (i = 0; i < subframesize; i++) {
181  float sample = b->samples[sf*subframesize + i];
182  b->samples[sf*subframesize + i] = sample - m;
183  m = sample * CELT_EMPH_COEFF;
184  }
185  if (sf != (subframes - 1))
186  b->emph_coeff = m;
187  }
188  }
189 }
190 
191 /* Create the window and do the mdct */
193 {
194  int i, j, t, ch;
195  float *win = s->scratch, *temp = s->scratch + 1920;
196 
197  if (f->transient) {
198  for (ch = 0; ch < f->channels; ch++) {
199  CeltBlock *b = &f->block[ch];
200  float *src1 = b->overlap;
201  for (t = 0; t < f->blocks; t++) {
202  float *src2 = &b->samples[CELT_OVERLAP*t];
203  s->dsp->vector_fmul(win, src1, ff_celt_window, 128);
204  s->dsp->vector_fmul_reverse(&win[CELT_OVERLAP], src2,
205  ff_celt_window - 8, 128);
206  src1 = src2;
207  s->mdct[0]->mdct(s->mdct[0], b->coeffs + t, win, f->blocks);
208  }
209  }
210  } else {
211  int blk_len = OPUS_BLOCK_SIZE(f->size), wlen = OPUS_BLOCK_SIZE(f->size + 1);
212  int rwin = blk_len - CELT_OVERLAP, lap_dst = (wlen - blk_len - CELT_OVERLAP) >> 1;
213  memset(win, 0, wlen*sizeof(float));
214  for (ch = 0; ch < f->channels; ch++) {
215  CeltBlock *b = &f->block[ch];
216 
217  /* Overlap */
218  s->dsp->vector_fmul(temp, b->overlap, ff_celt_window, 128);
219  memcpy(win + lap_dst, temp, CELT_OVERLAP*sizeof(float));
220 
221  /* Samples, flat top window */
222  memcpy(&win[lap_dst + CELT_OVERLAP], b->samples, rwin*sizeof(float));
223 
224  /* Samples, windowed */
225  s->dsp->vector_fmul_reverse(temp, b->samples + rwin,
226  ff_celt_window - 8, 128);
227  memcpy(win + lap_dst + blk_len, temp, CELT_OVERLAP*sizeof(float));
228 
229  s->mdct[f->size]->mdct(s->mdct[f->size], b->coeffs, win, 1);
230  }
231  }
232 
233  for (ch = 0; ch < f->channels; ch++) {
234  CeltBlock *block = &f->block[ch];
235  for (i = 0; i < CELT_MAX_BANDS; i++) {
236  float ener = 0.0f;
237  int band_offset = ff_celt_freq_bands[i] << f->size;
238  int band_size = ff_celt_freq_range[i] << f->size;
239  float *coeffs = &block->coeffs[band_offset];
240 
241  for (j = 0; j < band_size; j++)
242  ener += coeffs[j]*coeffs[j];
243 
244  block->lin_energy[i] = sqrtf(ener) + FLT_EPSILON;
245  ener = 1.0f/block->lin_energy[i];
246 
247  for (j = 0; j < band_size; j++)
248  coeffs[j] *= ener;
249 
250  block->energy[i] = log2f(block->lin_energy[i]) - ff_celt_mean_energy[i];
251 
252  /* CELT_ENERGY_SILENCE is what the decoder uses and its not -infinity */
253  block->energy[i] = FFMAX(block->energy[i], CELT_ENERGY_SILENCE);
254  }
255  }
256 }
257 
259 {
260  int i, tf_select = 0, diff = 0, tf_changed = 0, tf_select_needed;
261  int bits = f->transient ? 2 : 4;
262 
263  tf_select_needed = ((f->size && (opus_rc_tell(rc) + bits + 1) <= f->framebits));
264 
265  for (i = f->start_band; i < f->end_band; i++) {
266  if ((opus_rc_tell(rc) + bits + tf_select_needed) <= f->framebits) {
267  const int tbit = (diff ^ 1) == f->tf_change[i];
268  ff_opus_rc_enc_log(rc, tbit, bits);
269  diff ^= tbit;
270  tf_changed |= diff;
271  }
272  bits = f->transient ? 4 : 5;
273  }
274 
275  if (tf_select_needed && ff_celt_tf_select[f->size][f->transient][0][tf_changed] !=
276  ff_celt_tf_select[f->size][f->transient][1][tf_changed]) {
277  ff_opus_rc_enc_log(rc, f->tf_select, 1);
278  tf_select = f->tf_select;
279  }
280 
281  for (i = f->start_band; i < f->end_band; i++)
282  f->tf_change[i] = ff_celt_tf_select[f->size][f->transient][tf_select][f->tf_change[i]];
283 }
284 
286 {
287  int i, j, low, high, total, done, bandbits, remaining, tbits_8ths;
288  int skip_startband = f->start_band;
289  int skip_bit = 0;
290  int intensitystereo_bit = 0;
291  int dualstereo_bit = 0;
292  int dynalloc = 6;
293  int extrabits = 0;
294 
295  int *cap = f->caps;
296  int boost[CELT_MAX_BANDS];
297  int trim_offset[CELT_MAX_BANDS];
298  int threshold[CELT_MAX_BANDS];
299  int bits1[CELT_MAX_BANDS];
300  int bits2[CELT_MAX_BANDS];
301 
302  /* Tell the spread to the decoder */
303  if (opus_rc_tell(rc) + 4 <= f->framebits)
305  else
307 
308  /* Generate static allocation caps */
309  for (i = 0; i < CELT_MAX_BANDS; i++) {
310  cap[i] = (ff_celt_static_caps[f->size][f->channels - 1][i] + 64)
311  * ff_celt_freq_range[i] << (f->channels - 1) << f->size >> 2;
312  }
313 
314  /* Band boosts */
315  tbits_8ths = f->framebits << 3;
316  for (i = f->start_band; i < f->end_band; i++) {
317  int quanta, b_dynalloc, boost_amount = f->alloc_boost[i];
318 
319  boost[i] = 0;
320 
321  quanta = ff_celt_freq_range[i] << (f->channels - 1) << f->size;
322  quanta = FFMIN(quanta << 3, FFMAX(6 << 3, quanta));
323  b_dynalloc = dynalloc;
324 
325  while (opus_rc_tell_frac(rc) + (b_dynalloc << 3) < tbits_8ths && boost[i] < cap[i]) {
326  int is_boost = boost_amount--;
327 
328  ff_opus_rc_enc_log(rc, is_boost, b_dynalloc);
329  if (!is_boost)
330  break;
331 
332  boost[i] += quanta;
333  tbits_8ths -= quanta;
334 
335  b_dynalloc = 1;
336  }
337 
338  if (boost[i])
339  dynalloc = FFMAX(2, dynalloc - 1);
340  }
341 
342  /* Put allocation trim */
343  if (opus_rc_tell_frac(rc) + (6 << 3) <= tbits_8ths)
345 
346  /* Anti-collapse bit reservation */
347  tbits_8ths = (f->framebits << 3) - opus_rc_tell_frac(rc) - 1;
348  f->anticollapse_needed = 0;
349  if (f->transient && f->size >= 2 && tbits_8ths >= ((f->size + 2) << 3))
350  f->anticollapse_needed = 1 << 3;
351  tbits_8ths -= f->anticollapse_needed;
352 
353  /* Band skip bit reservation */
354  if (tbits_8ths >= 1 << 3)
355  skip_bit = 1 << 3;
356  tbits_8ths -= skip_bit;
357 
358  /* Intensity/dual stereo bit reservation */
359  if (f->channels == 2) {
360  intensitystereo_bit = ff_celt_log2_frac[f->end_band - f->start_band];
361  if (intensitystereo_bit <= tbits_8ths) {
362  tbits_8ths -= intensitystereo_bit;
363  if (tbits_8ths >= 1 << 3) {
364  dualstereo_bit = 1 << 3;
365  tbits_8ths -= 1 << 3;
366  }
367  } else {
368  intensitystereo_bit = 0;
369  }
370  }
371 
372  /* Trim offsets */
373  for (i = f->start_band; i < f->end_band; i++) {
374  int trim = f->alloc_trim - 5 - f->size;
375  int band = ff_celt_freq_range[i] * (f->end_band - i - 1);
376  int duration = f->size + 3;
377  int scale = duration + f->channels - 1;
378 
379  /* PVQ minimum allocation threshold, below this value the band is
380  * skipped */
381  threshold[i] = FFMAX(3 * ff_celt_freq_range[i] << duration >> 4,
382  f->channels << 3);
383 
384  trim_offset[i] = trim * (band << scale) >> 6;
385 
386  if (ff_celt_freq_range[i] << f->size == 1)
387  trim_offset[i] -= f->channels << 3;
388  }
389 
390  /* Bisection */
391  low = 1;
392  high = CELT_VECTORS - 1;
393  while (low <= high) {
394  int center = (low + high) >> 1;
395  done = total = 0;
396 
397  for (i = f->end_band - 1; i >= f->start_band; i--) {
398  bandbits = ff_celt_freq_range[i] * ff_celt_static_alloc[center][i]
399  << (f->channels - 1) << f->size >> 2;
400 
401  if (bandbits)
402  bandbits = FFMAX(0, bandbits + trim_offset[i]);
403  bandbits += boost[i];
404 
405  if (bandbits >= threshold[i] || done) {
406  done = 1;
407  total += FFMIN(bandbits, cap[i]);
408  } else if (bandbits >= f->channels << 3)
409  total += f->channels << 3;
410  }
411 
412  if (total > tbits_8ths)
413  high = center - 1;
414  else
415  low = center + 1;
416  }
417  high = low--;
418 
419  /* Bisection */
420  for (i = f->start_band; i < f->end_band; i++) {
421  bits1[i] = ff_celt_freq_range[i] * ff_celt_static_alloc[low][i]
422  << (f->channels - 1) << f->size >> 2;
423  bits2[i] = high >= CELT_VECTORS ? cap[i] :
425  << (f->channels - 1) << f->size >> 2;
426 
427  if (bits1[i])
428  bits1[i] = FFMAX(0, bits1[i] + trim_offset[i]);
429  if (bits2[i])
430  bits2[i] = FFMAX(0, bits2[i] + trim_offset[i]);
431  if (low)
432  bits1[i] += boost[i];
433  bits2[i] += boost[i];
434 
435  if (boost[i])
436  skip_startband = i;
437  bits2[i] = FFMAX(0, bits2[i] - bits1[i]);
438  }
439 
440  /* Bisection */
441  low = 0;
442  high = 1 << CELT_ALLOC_STEPS;
443  for (i = 0; i < CELT_ALLOC_STEPS; i++) {
444  int center = (low + high) >> 1;
445  done = total = 0;
446 
447  for (j = f->end_band - 1; j >= f->start_band; j--) {
448  bandbits = bits1[j] + (center * bits2[j] >> CELT_ALLOC_STEPS);
449 
450  if (bandbits >= threshold[j] || done) {
451  done = 1;
452  total += FFMIN(bandbits, cap[j]);
453  } else if (bandbits >= f->channels << 3)
454  total += f->channels << 3;
455  }
456  if (total > tbits_8ths)
457  high = center;
458  else
459  low = center;
460  }
461 
462  /* Bisection */
463  done = total = 0;
464  for (i = f->end_band - 1; i >= f->start_band; i--) {
465  bandbits = bits1[i] + (low * bits2[i] >> CELT_ALLOC_STEPS);
466 
467  if (bandbits >= threshold[i] || done)
468  done = 1;
469  else
470  bandbits = (bandbits >= f->channels << 3) ?
471  f->channels << 3 : 0;
472 
473  bandbits = FFMIN(bandbits, cap[i]);
474  f->pulses[i] = bandbits;
475  total += bandbits;
476  }
477 
478  /* Band skipping */
479  for (f->coded_bands = f->end_band; ; f->coded_bands--) {
480  int allocation;
481  j = f->coded_bands - 1;
482 
483  if (j == skip_startband) {
484  /* all remaining bands are not skipped */
485  tbits_8ths += skip_bit;
486  break;
487  }
488 
489  /* determine the number of bits available for coding "do not skip" markers */
490  remaining = tbits_8ths - total;
491  bandbits = remaining / (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]);
492  remaining -= bandbits * (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]);
493  allocation = f->pulses[j] + bandbits * ff_celt_freq_range[j]
494  + FFMAX(0, remaining - (ff_celt_freq_bands[j] - ff_celt_freq_bands[f->start_band]));
495 
496  /* a "do not skip" marker is only coded if the allocation is
497  above the chosen threshold */
498  if (allocation >= FFMAX(threshold[j], (f->channels + 1) << 3)) {
499  const int do_not_skip = f->coded_bands <= f->skip_band_floor;
500  ff_opus_rc_enc_log(rc, do_not_skip, 1);
501  if (do_not_skip)
502  break;
503 
504  total += 1 << 3;
505  allocation -= 1 << 3;
506  }
507 
508  /* the band is skipped, so reclaim its bits */
509  total -= f->pulses[j];
510  if (intensitystereo_bit) {
511  total -= intensitystereo_bit;
512  intensitystereo_bit = ff_celt_log2_frac[j - f->start_band];
513  total += intensitystereo_bit;
514  }
515 
516  total += f->pulses[j] = (allocation >= f->channels << 3) ? f->channels << 3 : 0;
517  }
518 
519  /* Encode stereo flags */
520  if (intensitystereo_bit) {
523  }
524  if (f->intensity_stereo <= f->start_band)
525  tbits_8ths += dualstereo_bit; /* no intensity stereo means no dual stereo */
526  else if (dualstereo_bit)
527  ff_opus_rc_enc_log(rc, f->dual_stereo, 1);
528 
529  /* Supply the remaining bits in this frame to lower bands */
530  remaining = tbits_8ths - total;
531  bandbits = remaining / (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]);
532  remaining -= bandbits * (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]);
533  for (i = f->start_band; i < f->coded_bands; i++) {
534  int bits = FFMIN(remaining, ff_celt_freq_range[i]);
535 
536  f->pulses[i] += bits + bandbits * ff_celt_freq_range[i];
537  remaining -= bits;
538  }
539 
540  /* Finally determine the allocation */
541  for (i = f->start_band; i < f->coded_bands; i++) {
542  int N = ff_celt_freq_range[i] << f->size;
543  int prev_extra = extrabits;
544  f->pulses[i] += extrabits;
545 
546  if (N > 1) {
547  int dof; // degrees of freedom
548  int temp; // dof * channels * log(dof)
549  int offset; // fine energy quantization offset, i.e.
550  // extra bits assigned over the standard
551  // totalbits/dof
552  int fine_bits, max_bits;
553 
554  extrabits = FFMAX(0, f->pulses[i] - cap[i]);
555  f->pulses[i] -= extrabits;
556 
557  /* intensity stereo makes use of an extra degree of freedom */
558  dof = N * f->channels + (f->channels == 2 && N > 2 && !f->dual_stereo && i < f->intensity_stereo);
559  temp = dof * (ff_celt_log_freq_range[i] + (f->size << 3));
560  offset = (temp >> 1) - dof * CELT_FINE_OFFSET;
561  if (N == 2) /* dof=2 is the only case that doesn't fit the model */
562  offset += dof << 1;
563 
564  /* grant an additional bias for the first and second pulses */
565  if (f->pulses[i] + offset < 2 * (dof << 3))
566  offset += temp >> 2;
567  else if (f->pulses[i] + offset < 3 * (dof << 3))
568  offset += temp >> 3;
569 
570  fine_bits = (f->pulses[i] + offset + (dof << 2)) / (dof << 3);
571  max_bits = FFMIN((f->pulses[i] >> 3) >> (f->channels - 1), CELT_MAX_FINE_BITS);
572 
573  max_bits = FFMAX(max_bits, 0);
574 
575  f->fine_bits[i] = av_clip(fine_bits, 0, max_bits);
576 
577  /* if fine_bits was rounded down or capped,
578  give priority for the final fine energy pass */
579  f->fine_priority[i] = (f->fine_bits[i] * (dof << 3) >= f->pulses[i] + offset);
580 
581  /* the remaining bits are assigned to PVQ */
582  f->pulses[i] -= f->fine_bits[i] << (f->channels - 1) << 3;
583  } else {
584  /* all bits go to fine energy except for the sign bit */
585  extrabits = FFMAX(0, f->pulses[i] - (f->channels << 3));
586  f->pulses[i] -= extrabits;
587  f->fine_bits[i] = 0;
588  f->fine_priority[i] = 1;
589  }
590 
591  /* hand back a limited number of extra fine energy bits to this band */
592  if (extrabits > 0) {
593  int fineextra = FFMIN(extrabits >> (f->channels + 2),
594  CELT_MAX_FINE_BITS - f->fine_bits[i]);
595  f->fine_bits[i] += fineextra;
596 
597  fineextra <<= f->channels + 2;
598  f->fine_priority[i] = (fineextra >= extrabits - prev_extra);
599  extrabits -= fineextra;
600  }
601  }
602  f->remaining = extrabits;
603 
604  /* skipped bands dedicate all of their bits for fine energy */
605  for (; i < f->end_band; i++) {
606  f->fine_bits[i] = f->pulses[i] >> (f->channels - 1) >> 3;
607  f->pulses[i] = 0;
608  f->fine_priority[i] = f->fine_bits[i] < 1;
609  }
610 }
611 
613 {
614  float gain = f->pf_gain;
615  int i, txval, octave = f->pf_octave, period = f->pf_period, tapset = f->pf_tapset;
616 
617  ff_opus_rc_enc_log(rc, f->pfilter, 1);
618  if (!f->pfilter)
619  return;
620 
621  /* Octave */
622  txval = FFMIN(octave, 6);
623  ff_opus_rc_enc_uint(rc, txval, 6);
624  octave = txval;
625  /* Period */
626  txval = av_clip(period - (16 << octave) + 1, 0, (1 << (4 + octave)) - 1);
627  ff_opus_rc_put_raw(rc, period, 4 + octave);
628  period = txval + (16 << octave) - 1;
629  /* Gain */
630  txval = FFMIN(((int)(gain / 0.09375f)) - 1, 7);
631  ff_opus_rc_put_raw(rc, txval, 3);
632  gain = 0.09375f * (txval + 1);
633  /* Tapset */
634  if ((opus_rc_tell(rc) + 2) <= f->framebits)
636  else
637  tapset = 0;
638  /* Finally create the coeffs */
639  for (i = 0; i < 2; i++) {
640  CeltBlock *block = &f->block[i];
641 
643  block->pf_gains_new[0] = gain * ff_celt_postfilter_taps[tapset][0];
644  block->pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1];
645  block->pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2];
646  }
647 }
648 
650  float last_energy[][CELT_MAX_BANDS], int intra)
651 {
652  int i, ch;
653  float alpha, beta, prev[2] = { 0, 0 };
654  const uint8_t *pmod = ff_celt_coarse_energy_dist[f->size][intra];
655 
656  /* Inter is really just differential coding */
657  if (opus_rc_tell(rc) + 3 <= f->framebits)
658  ff_opus_rc_enc_log(rc, intra, 3);
659  else
660  intra = 0;
661 
662  if (intra) {
663  alpha = 0.0f;
664  beta = 1.0f - (4915.0f/32768.0f);
665  } else {
666  alpha = ff_celt_alpha_coef[f->size];
667  beta = ff_celt_beta_coef[f->size];
668  }
669 
670  for (i = f->start_band; i < f->end_band; i++) {
671  for (ch = 0; ch < f->channels; ch++) {
672  CeltBlock *block = &f->block[ch];
673  const int left = f->framebits - opus_rc_tell(rc);
674  const float last = FFMAX(-9.0f, last_energy[ch][i]);
675  float diff = block->energy[i] - prev[ch] - last*alpha;
676  int q_en = lrintf(diff);
677  if (left >= 15) {
678  ff_opus_rc_enc_laplace(rc, &q_en, pmod[i << 1] << 7, pmod[(i << 1) + 1] << 6);
679  } else if (left >= 2) {
680  q_en = av_clip(q_en, -1, 1);
681  ff_opus_rc_enc_cdf(rc, 2*q_en + 3*(q_en < 0), ff_celt_model_energy_small);
682  } else if (left >= 1) {
683  q_en = av_clip(q_en, -1, 0);
684  ff_opus_rc_enc_log(rc, (q_en & 1), 1);
685  } else q_en = -1;
686 
687  block->error_energy[i] = q_en - diff;
688  prev[ch] += beta * q_en;
689  }
690  }
691 }
692 
694  float last_energy[][CELT_MAX_BANDS])
695 {
696  uint32_t inter, intra;
698 
699  exp_quant_coarse(rc, f, last_energy, 1);
700  intra = OPUS_RC_CHECKPOINT_BITS(rc);
701 
703 
704  exp_quant_coarse(rc, f, last_energy, 0);
705  inter = OPUS_RC_CHECKPOINT_BITS(rc);
706 
707  if (inter > intra) { /* Unlikely */
709  exp_quant_coarse(rc, f, last_energy, 1);
710  }
711 }
712 
714 {
715  int i, ch;
716  for (i = f->start_band; i < f->end_band; i++) {
717  if (!f->fine_bits[i])
718  continue;
719  for (ch = 0; ch < f->channels; ch++) {
720  CeltBlock *block = &f->block[ch];
721  int quant, lim = (1 << f->fine_bits[i]);
722  float offset, diff = 0.5f - block->error_energy[i];
723  quant = av_clip(floor(diff*lim), 0, lim - 1);
724  ff_opus_rc_put_raw(rc, quant, f->fine_bits[i]);
725  offset = 0.5f - ((quant + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f);
726  block->error_energy[i] -= offset;
727  }
728  }
729 }
730 
732 {
733  int i, ch, priority;
734  for (priority = 0; priority < 2; priority++) {
735  for (i = f->start_band; i < f->end_band && (f->framebits - opus_rc_tell(rc)) >= f->channels; i++) {
736  if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS)
737  continue;
738  for (ch = 0; ch < f->channels; ch++) {
739  CeltBlock *block = &f->block[ch];
740  const float err = block->error_energy[i];
741  const float offset = 0.5f * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f;
742  const int sign = FFABS(err + offset) < FFABS(err - offset);
743  ff_opus_rc_put_raw(rc, sign, 1);
744  block->error_energy[i] -= offset*(1 - 2*sign);
745  }
746  }
747  }
748 }
749 
751  CeltFrame *f, int index)
752 {
753  int i, ch;
754 
756 
757  ff_opus_psy_celt_frame_init(&s->psyctx, f, index);
758 
760 
761  if (f->silence) {
762  if (f->framebits >= 16)
763  ff_opus_rc_enc_log(rc, 1, 15); /* Silence (if using explicit singalling) */
764  for (ch = 0; ch < s->channels; ch++)
765  memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
766  return;
767  }
768 
769  /* Filters */
771  if (f->pfilter) {
772  ff_opus_rc_enc_log(rc, 0, 15);
773  celt_enc_quant_pfilter(rc, f);
774  }
775 
776  /* Transform */
777  celt_frame_mdct(s, f);
778 
779  /* Need to handle transient/non-transient switches at any point during analysis */
780  while (ff_opus_psy_celt_frame_process(&s->psyctx, f, index))
781  celt_frame_mdct(s, f);
782 
784 
785  /* Silence */
786  ff_opus_rc_enc_log(rc, 0, 15);
787 
788  /* Pitch filter */
789  if (!f->start_band && opus_rc_tell(rc) + 16 <= f->framebits)
790  celt_enc_quant_pfilter(rc, f);
791 
792  /* Transient flag */
793  if (f->size && opus_rc_tell(rc) + 3 <= f->framebits)
794  ff_opus_rc_enc_log(rc, f->transient, 3);
795 
796  /* Main encoding */
798  celt_enc_tf (f, rc);
799  ff_celt_enc_bitalloc(f, rc);
800  celt_quant_fine (f, rc);
801  ff_celt_quant_bands (f, rc);
802 
803  /* Anticollapse bit */
804  if (f->anticollapse_needed)
805  ff_opus_rc_put_raw(rc, f->anticollapse, 1);
806 
807  /* Final per-band energy adjustments from leftover bits */
808  celt_quant_final(s, rc, f);
809 
810  for (ch = 0; ch < f->channels; ch++) {
811  CeltBlock *block = &f->block[ch];
812  for (i = 0; i < CELT_MAX_BANDS; i++)
813  s->last_quantized_energy[ch][i] = block->energy[i] + block->error_energy[i];
814  }
815 }
816 
817 static inline int write_opuslacing(uint8_t *dst, int v)
818 {
819  dst[0] = FFMIN(v - FFALIGN(v - 255, 4), v);
820  dst[1] = v - dst[0] >> 2;
821  return 1 + (v >= 252);
822 }
823 
825 {
826  int i, offset, fsize_needed;
827 
828  /* Write toc */
829  opus_gen_toc(s, avpkt->data, &offset, &fsize_needed);
830 
831  /* Frame sizes if needed */
832  if (fsize_needed) {
833  for (i = 0; i < s->packet.frames - 1; i++) {
834  offset += write_opuslacing(avpkt->data + offset,
835  s->frame[i].framebits >> 3);
836  }
837  }
838 
839  /* Packets */
840  for (i = 0; i < s->packet.frames; i++) {
841  ff_opus_rc_enc_end(&s->rc[i], avpkt->data + offset,
842  s->frame[i].framebits >> 3);
843  offset += s->frame[i].framebits >> 3;
844  }
845 
846  avpkt->size = offset;
847 }
848 
849 /* Used as overlap for the first frame and padding for the last encoded packet */
851 {
852  int i;
853  AVFrame *f = av_frame_alloc();
854  if (!f)
855  return NULL;
856  f->format = s->avctx->sample_fmt;
857  f->nb_samples = s->avctx->frame_size;
859  if (av_frame_get_buffer(f, 4)) {
860  av_frame_free(&f);
861  return NULL;
862  }
863  for (i = 0; i < s->channels; i++) {
864  size_t bps = av_get_bytes_per_sample(f->format);
865  memset(f->extended_data[i], 0, bps*f->nb_samples);
866  }
867  return f;
868 }
869 
870 static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
871  const AVFrame *frame, int *got_packet_ptr)
872 {
873  OpusEncContext *s = avctx->priv_data;
874  int i, ret, frame_size, alloc_size = 0;
875 
876  if (frame) { /* Add new frame to queue */
877  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
878  return ret;
879  ff_bufqueue_add(avctx, &s->bufqueue, av_frame_clone(frame));
880  } else {
882  if (!s->afq.remaining_samples)
883  return 0; /* We've been flushed and there's nothing left to encode */
884  }
885 
886  /* Run the psychoacoustic system */
887  if (ff_opus_psy_process(&s->psyctx, &s->packet))
888  return 0;
889 
890  frame_size = OPUS_BLOCK_SIZE(s->packet.framesize);
891 
892  if (!frame) {
893  /* This can go negative, that's not a problem, we only pad if positive */
894  int pad_empty = s->packet.frames*(frame_size/s->avctx->frame_size) - s->bufqueue.available + 1;
895  /* Pad with empty 2.5 ms frames to whatever framesize was decided,
896  * this should only happen at the very last flush frame. The frames
897  * allocated here will be freed (because they have no other references)
898  * after they get used by celt_frame_setup_input() */
899  for (i = 0; i < pad_empty; i++) {
900  AVFrame *empty = spawn_empty_frame(s);
901  if (!empty)
902  return AVERROR(ENOMEM);
903  ff_bufqueue_add(avctx, &s->bufqueue, empty);
904  }
905  }
906 
907  for (i = 0; i < s->packet.frames; i++) {
908  celt_encode_frame(s, &s->rc[i], &s->frame[i], i);
909  alloc_size += s->frame[i].framebits >> 3;
910  }
911 
912  /* Worst case toc + the frame lengths if needed */
913  alloc_size += 2 + s->packet.frames*2;
914 
915  if ((ret = ff_alloc_packet2(avctx, avpkt, alloc_size, 0)) < 0)
916  return ret;
917 
918  /* Assemble packet */
919  opus_packet_assembler(s, avpkt);
920 
921  /* Update the psychoacoustic system */
923 
924  /* Remove samples from queue and skip if needed */
925  ff_af_queue_remove(&s->afq, s->packet.frames*frame_size, &avpkt->pts, &avpkt->duration);
926  if (s->packet.frames*frame_size > avpkt->duration) {
928  if (!side)
929  return AVERROR(ENOMEM);
930  AV_WL32(&side[4], s->packet.frames*frame_size - avpkt->duration + 120);
931  }
932 
933  *got_packet_ptr = 1;
934 
935  return 0;
936 }
937 
939 {
940  int i;
941  OpusEncContext *s = avctx->priv_data;
942 
943  for (i = 0; i < CELT_BLOCK_NB; i++)
944  ff_mdct15_uninit(&s->mdct[i]);
945 
946  ff_celt_pvq_uninit(&s->pvq);
947  av_freep(&s->dsp);
948  av_freep(&s->frame);
949  av_freep(&s->rc);
950  ff_af_queue_close(&s->afq);
951  ff_opus_psy_end(&s->psyctx);
953  av_freep(&avctx->extradata);
954 
955  return 0;
956 }
957 
959 {
960  int i, ch, ret, max_frames;
961  OpusEncContext *s = avctx->priv_data;
962 
963  s->avctx = avctx;
964  s->channels = avctx->channels;
965 
966  /* Opus allows us to change the framesize on each packet (and each packet may
967  * have multiple frames in it) but we can't change the codec's frame size on
968  * runtime, so fix it to the lowest possible number of samples and use a queue
969  * to accumulate AVFrames until we have enough to encode whatever the encoder
970  * decides is the best */
971  avctx->frame_size = 120;
972  /* Initial padding will change if SILK is ever supported */
973  avctx->initial_padding = 120;
974 
975  if (!avctx->bit_rate) {
976  int coupled = ff_opus_default_coupled_streams[s->channels - 1];
977  avctx->bit_rate = coupled*(96000) + (s->channels - coupled*2)*(48000);
978  } else if (avctx->bit_rate < 6000 || avctx->bit_rate > 255000 * s->channels) {
979  int64_t clipped_rate = av_clip(avctx->bit_rate, 6000, 255000 * s->channels);
980  av_log(avctx, AV_LOG_ERROR, "Unsupported bitrate %"PRId64" kbps, clipping to %"PRId64" kbps\n",
981  avctx->bit_rate/1000, clipped_rate/1000);
982  avctx->bit_rate = clipped_rate;
983  }
984 
985  /* Extradata */
986  avctx->extradata_size = 19;
988  if (!avctx->extradata)
989  return AVERROR(ENOMEM);
990  opus_write_extradata(avctx);
991 
992  ff_af_queue_init(avctx, &s->afq);
993 
994  if ((ret = ff_celt_pvq_init(&s->pvq, 1)) < 0)
995  return ret;
996 
998  return AVERROR(ENOMEM);
999 
1000  /* I have no idea why a base scaling factor of 68 works, could be the twiddles */
1001  for (i = 0; i < CELT_BLOCK_NB; i++)
1002  if ((ret = ff_mdct15_init(&s->mdct[i], 0, i + 3, 68 << (CELT_BLOCK_NB - 1 - i))))
1003  return AVERROR(ENOMEM);
1004 
1005  /* Zero out previous energy (matters for inter first frame) */
1006  for (ch = 0; ch < s->channels; ch++)
1007  memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
1008 
1009  /* Allocate an empty frame to use as overlap for the first frame of audio */
1010  ff_bufqueue_add(avctx, &s->bufqueue, spawn_empty_frame(s));
1011  if (!ff_bufqueue_peek(&s->bufqueue, 0))
1012  return AVERROR(ENOMEM);
1013 
1014  if ((ret = ff_opus_psy_init(&s->psyctx, s->avctx, &s->bufqueue, &s->options)))
1015  return ret;
1016 
1017  /* Frame structs and range coder buffers */
1018  max_frames = ceilf(FFMIN(s->options.max_delay_ms, 120.0f)/2.5f);
1019  s->frame = av_malloc(max_frames*sizeof(CeltFrame));
1020  if (!s->frame)
1021  return AVERROR(ENOMEM);
1022  s->rc = av_malloc(max_frames*sizeof(OpusRangeCoder));
1023  if (!s->rc)
1024  return AVERROR(ENOMEM);
1025 
1026  for (i = 0; i < max_frames; i++) {
1027  s->frame[i].dsp = s->dsp;
1028  s->frame[i].avctx = s->avctx;
1029  s->frame[i].seed = 0;
1030  s->frame[i].pvq = s->pvq;
1031  s->frame[i].apply_phase_inv = 1;
1032  s->frame[i].block[0].emph_coeff = s->frame[i].block[1].emph_coeff = 0.0f;
1033  }
1034 
1035  return 0;
1036 }
1037 
1038 #define OPUSENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1039 static const AVOption opusenc_options[] = {
1040  { "opus_delay", "Maximum delay in milliseconds", offsetof(OpusEncContext, options.max_delay_ms), AV_OPT_TYPE_FLOAT, { .dbl = OPUS_MAX_LOOKAHEAD }, 2.5f, OPUS_MAX_LOOKAHEAD, OPUSENC_FLAGS, "max_delay_ms" },
1041  { NULL },
1042 };
1043 
1044 static const AVClass opusenc_class = {
1045  .class_name = "Opus encoder",
1046  .item_name = av_default_item_name,
1047  .option = opusenc_options,
1048  .version = LIBAVUTIL_VERSION_INT,
1049 };
1050 
1052  { "b", "0" },
1053  { "compression_level", "10" },
1054  { NULL },
1055 };
1056 
1058  .name = "opus",
1059  .long_name = NULL_IF_CONFIG_SMALL("Opus"),
1060  .type = AVMEDIA_TYPE_AUDIO,
1061  .id = AV_CODEC_ID_OPUS,
1062  .defaults = opusenc_defaults,
1063  .priv_class = &opusenc_class,
1064  .priv_data_size = sizeof(OpusEncContext),
1066  .encode2 = opus_encode_frame,
1067  .close = opus_encode_end,
1070  .supported_samplerates = (const int []){ 48000, 0 },
1071  .channel_layouts = (const uint64_t []){ AV_CH_LAYOUT_MONO,
1072  AV_CH_LAYOUT_STEREO, 0 },
1073  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
1075 };
int channels
Definition: opus_celt.h:99
float max_delay_ms
Definition: opusenc.h:44
#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
static AVFrame * ff_bufqueue_get(struct FFBufQueue *queue)
Get the first buffer from the queue and remove it.
Definition: bufferqueue.h:98
void ff_opus_psy_celt_frame_init(OpusPsyContext *s, CeltFrame *f, int index)
Definition: opusenc_psy.c:254
float, planar
Definition: samplefmt.h:69
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
#define NULL
Definition: coverity.c:32
int anticollapse
Definition: opus_celt.h:117
static av_cold int opus_encode_init(AVCodecContext *avctx)
Definition: opusenc.c:958
enum OpusBandwidth bandwidth
Definition: opusenc.h:49
const char * s
Definition: avisynth_c.h:768
#define OPUS_RC_CHECKPOINT_SPAWN(rc)
Definition: opus_rc.h:116
CeltFrame * frame
Definition: opusenc.c:51
static float alpha(float a)
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
static void celt_enc_tf(CeltFrame *f, OpusRangeCoder *rc)
Definition: opusenc.c:258
static const AVCodecDefault opusenc_defaults[]
Definition: opusenc.c:1051
AVOption.
Definition: opt.h:246
int framebits
Definition: opus_celt.h:131
static const AVOption opusenc_options[]
Definition: opusenc.c:1039
const uint8_t ff_celt_coarse_energy_dist[4][2][42]
Definition: opustab.c:803
static AVFrame * spawn_empty_frame(OpusEncContext *s)
Definition: opusenc.c:850
const uint8_t ff_celt_log_freq_range[]
Definition: opustab.c:771
void ff_opus_rc_enc_init(OpusRangeCoder *rc)
Definition: opus_rc.c:402
float coeffs[CELT_MAX_FRAME_SIZE]
Definition: opus_celt.h:75
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1538
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static void opus_packet_assembler(OpusEncContext *s, AVPacket *avpkt)
Definition: opusenc.c:824
else temp
Definition: vf_mcdeint.c:256
static float win(SuperEqualizerContext *s, float n, int N)
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
const uint8_t ff_celt_freq_bands[]
Definition: opustab.c:763
int size
Definition: avcodec.h:1401
const char * b
Definition: vf_curves.c:113
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:193
float pf_gains_new[3]
Definition: opus_celt.h:83
static av_cold int opus_encode_end(AVCodecContext *avctx)
Definition: opusenc.c:938
void ff_celt_enc_bitalloc(CeltFrame *f, OpusRangeCoder *rc)
Definition: opusenc.c:285
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:1004
void ff_opus_rc_enc_log(OpusRangeCoder *rc, int val, uint32_t bits)
Definition: opus_rc.c:131
void(* vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats, and store the result in a vector of floats...
Definition: float_dsp.h:154
int av_cold ff_celt_pvq_init(CeltPVQ **pvq, int encode)
Definition: opus_pvq.c:897
const float ff_celt_postfilter_taps[3][3]
Definition: opustab.c:1093
#define AV_CH_LAYOUT_STEREO
#define sample
AVCodec.
Definition: avcodec.h:3351
int pf_period
Definition: opus_celt.h:126
#define N
Definition: af_mcompand.c:54
void ff_opus_rc_enc_uint(OpusRangeCoder *rc, uint32_t val, uint32_t size)
CELT: write a uniformly distributed integer.
Definition: opus_rc.c:204
int pf_period_new
Definition: opus_celt.h:82
Structure holding the queue.
Definition: bufferqueue.h:49
#define OPUSENC_FLAGS
Definition: opusenc.c:1038
static int16_t block[64]
Definition: dct.c:115
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
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:981
int fine_priority[CELT_MAX_BANDS]
Definition: opus_celt.h:136
CeltBlock block[2]
Definition: opus_celt.h:97
static void exp_quant_coarse(OpusRangeCoder *rc, CeltFrame *f, float last_energy[][CELT_MAX_BANDS], int intra)
Definition: opusenc.c:649
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
CeltPVQ * pvq
Definition: opusenc.c:41
#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
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2151
uint8_t
#define av_cold
Definition: attributes.h:82
AVCodec ff_opus_encoder
Definition: opusenc.c:1057
#define CELT_OVERLAP
Definition: opus.h:42
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
const float * ff_celt_window
Definition: opustab.c:1130
int silence
Definition: opus_celt.h:115
AVOptions.
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1418
#define OPUS_MAX_LOOKAHEAD
Definition: opusenc.h:32
AudioFrameQueue afq
Definition: opusenc.c:38
#define CELT_VECTORS
Definition: opus_celt.h:36
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1588
int ff_opus_psy_process(OpusPsyContext *s, OpusPacketInfo *p)
Definition: opusenc_psy.c:223
int64_t duration
Definition: movenc.c:63
av_cold int ff_mdct15_init(MDCT15Context **ps, int inverse, int N, double scale)
Definition: mdct15.c:247
#define CELT_POSTFILTER_MINPERIOD
Definition: opus_celt.h:44
static AVFrame * frame
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
uint8_t * data
Definition: avcodec.h:1400
int dual_stereo
Definition: opus_celt.h:119
static const uint8_t bits2[81]
Definition: aactab.c:140
int ff_opus_psy_celt_frame_process(OpusPsyContext *s, CeltFrame *f, int index)
Definition: opusenc_psy.c:449
enum OpusMode mode
Definition: opusenc.h:48
#define lrintf(x)
Definition: libm_mips.h:70
ptrdiff_t size
Definition: opengl_enc.c:101
int coded_bands
Definition: opus_celt.h:106
float lin_energy[CELT_MAX_BANDS]
Definition: opus_celt.h:67
int skip_band_floor
Definition: opus_celt.h:109
const OptionDef options[]
Definition: ffserver.c:3948
#define FFALIGN(x, a)
Definition: macros.h:48
static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: opusenc.c:870
#define av_log(a,...)
int end_band
Definition: opus_celt.h:105
float samples[FFALIGN(CELT_MAX_FRAME_SIZE, 16)]
Definition: opus_celt.h:79
const uint8_t ff_celt_log2_frac[]
Definition: opustab.c:925
int alloc_boost[CELT_MAX_BANDS]
Definition: opus_celt.h:112
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:127
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats and store the result in a vector of floats...
Definition: float_dsp.h:38
#define OPUS_BLOCK_SIZE(x)
Definition: opusenc.h:39
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:163
int start_band
Definition: opus_celt.h:104
#define CELT_EMPH_COEFF
Definition: opus_celt.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
OpusEncOptions options
Definition: opusenc.c:35
int initial_padding
Audio only.
Definition: avcodec.h:2989
#define OPUS_RC_CHECKPOINT_ROLLBACK(rc)
Definition: opus_rc.h:123
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1568
av_cold int ff_opus_psy_init(OpusPsyContext *s, AVCodecContext *avctx, struct FFBufQueue *bufqueue, OpusEncOptions *options)
Definition: opusenc_psy.c:510
int tf_change[CELT_MAX_BANDS]
Definition: opus_celt.h:138
const char * name
Name of the codec implementation.
Definition: avcodec.h:3358
static void celt_quant_fine(CeltFrame *f, OpusRangeCoder *rc)
Definition: opusenc.c:713
float emph_coeff
Definition: opus_celt.h:89
int pulses[CELT_MAX_BANDS]
Definition: opus_celt.h:137
static int opus_gen_toc(OpusEncContext *s, uint8_t *toc, int *size, int *fsize_needed)
Definition: opusenc.c:73
int pfilter
Definition: opus_celt.h:108
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
int apply_phase_inv
Definition: opus_celt.h:101
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
#define FFMAX(a, b)
Definition: common.h:94
static void celt_frame_mdct(OpusEncContext *s, CeltFrame *f)
Definition: opusenc.c:192
int anticollapse_needed
Definition: opus_celt.h:116
int fine_bits[CELT_MAX_BANDS]
Definition: opus_celt.h:135
float pf_gain
Definition: opus_celt.h:128
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2194
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:379
AVCodecContext * avctx
Definition: opus_celt.h:94
uint32_t seed
Definition: opus_celt.h:121
int caps[CELT_MAX_BANDS]
Definition: opus_celt.h:134
const int8_t ff_celt_tf_select[4][2][2][2]
Definition: opustab.c:777
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:883
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: avcodec.h:986
int enc_id_bits
Definition: opusenc.c:45
uint8_t enc_id[64]
Definition: opusenc.c:44
#define FFMIN(a, b)
Definition: common.h:96
#define OPUS_RC_CHECKPOINT_BITS(rc)
Definition: opus_rc.h:120
MDCT15Context * mdct[CELT_BLOCK_NB]
Definition: opusenc.c:40
static void celt_frame_setup_input(OpusEncContext *s, CeltFrame *f)
Definition: opusenc.c:116
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
int blocks
Definition: opus_celt.h:113
int transient
Definition: opus_celt.h:107
#define CELT_FINE_OFFSET
Definition: opus_celt.h:38
float error_energy[CELT_MAX_BANDS]
Definition: opus_celt.h:68
static void ff_bufqueue_discard_all(struct FFBufQueue *queue)
Unref and remove all buffers from the queue.
Definition: bufferqueue.h:111
const uint8_t ff_celt_freq_range[]
Definition: opustab.c:767
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:497
const uint8_t ff_opus_default_coupled_streams[]
Definition: opustab.c:25
void ff_opus_rc_enc_cdf(OpusRangeCoder *rc, int val, const uint16_t *cdf)
Definition: opus_rc.c:109
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:274
AVCodecContext * avctx
Definition: opusenc.c:37
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2163
const uint8_t ff_celt_static_caps[4][2][21]
Definition: opustab.c:861
struct FFBufQueue bufqueue
Definition: opusenc.c:42
#define src1
Definition: h264pred.c:139
int frame_size
Definition: mxfenc.c:1947
static void celt_encode_frame(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f, int index)
Definition: opusenc.c:750
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
#define CELT_MAX_BANDS
Definition: opus.h:45
unsigned short available
number of available buffers
Definition: bufferqueue.h:52
int sample_rate
samples per second
Definition: avcodec.h:2143
int pf_tapset
Definition: opus_celt.h:127
const uint16_t ff_celt_model_spread[]
Definition: opustab.c:755
main external API structure.
Definition: avcodec.h:1488
static av_always_inline uint32_t opus_rc_tell(const OpusRangeCoder *rc)
CELT: estimate bits of entropy that have thus far been consumed for the current CELT frame...
Definition: opus_rc.h:61
#define CELT_MAX_FINE_BITS
Definition: opus_celt.h:39
float scratch[2048]
Definition: opusenc.c:57
AVFloatDSPContext * dsp
Definition: opus_celt.h:96
int extradata_size
Definition: avcodec.h:1589
void ff_opus_rc_enc_laplace(OpusRangeCoder *rc, int *value, uint32_t symbol, int decay)
Definition: opus_rc.c:314
static int write_opuslacing(uint8_t *dst, int v)
Definition: opusenc.c:817
OpusPsyContext psyctx
Definition: opusenc.c:36
Describe the class of an AVClass context structure.
Definition: log.h:67
void ff_opus_psy_signal_eof(OpusPsyContext *s)
Definition: opusenc_psy.c:582
int index
Definition: gxfenc.c:89
const uint8_t ff_celt_static_alloc[11][21]
Definition: opustab.c:847
#define CELT_ENERGY_SILENCE
Definition: opus_celt.h:45
static void opus_write_extradata(AVCodecContext *avctx)
Definition: opusenc.c:60
Recommmends skipping the specified number of samples.
Definition: avcodec.h:1242
av_cold int ff_opus_psy_end(OpusPsyContext *s)
Definition: opusenc_psy.c:587
CeltPVQ * pvq
Definition: opus_celt.h:98
AVClass * av_class
Definition: opusenc.c:34
static void celt_quant_coarse(CeltFrame *f, OpusRangeCoder *rc, float last_energy[][CELT_MAX_BANDS])
Definition: opusenc.c:693
void ff_opus_psy_postencode_update(OpusPsyContext *s, CeltFrame *f, OpusRangeCoder *rc)
Definition: opusenc_psy.c:473
const uint16_t ff_celt_model_energy_small[]
Definition: opustab.c:761
const uint8_t * quant
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:283
#define OPUS_MAX_CHANNELS
Definition: opusenc.h:34
AVFloatDSPContext * dsp
Definition: opusenc.c:39
int framesize
Definition: opusenc.h:50
const uint16_t ff_celt_model_alloc_trim[]
Definition: opustab.c:757
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
int channels
Definition: opusenc.c:49
int remaining
Definition: opus_celt.h:132
float energy[CELT_MAX_BANDS]
Definition: opus_celt.h:66
OpusPacketInfo packet
Definition: opusenc.c:47
static const AVClass opusenc_class
Definition: opusenc.c:1044
static void celt_quant_final(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f)
Definition: opusenc.c:731
const float ff_celt_beta_coef[]
Definition: opustab.c:799
void ff_opus_rc_put_raw(OpusRangeCoder *rc, uint32_t val, uint32_t count)
CELT: write 0 - 31 bits to the rawbits buffer.
Definition: opus_rc.c:161
common internal api header.
if(ret< 0)
Definition: vf_mcdeint.c:279
#define log2f(x)
Definition: libm.h:409
void ff_opus_rc_enc_end(OpusRangeCoder *rc, uint8_t *dst, int size)
Definition: opus_rc.c:360
#define CELT_ALLOC_STEPS
Definition: opus_celt.h:37
unsigned bps
Definition: movenc.c:1449
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:368
enum CeltSpread spread
Definition: opus_celt.h:122
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:770
av_cold void ff_mdct15_uninit(MDCT15Context **ps)
Definition: mdct15.c:43
void * priv_data
Definition: avcodec.h:1515
float last_quantized_energy[OPUS_MAX_CHANNELS][CELT_MAX_BANDS]
Definition: opusenc.c:55
int tf_select
Definition: opus_celt.h:110
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static const int16_t coeffs[]
int len
int channels
number of audio channels
Definition: avcodec.h:2144
const float ff_celt_alpha_coef[]
Definition: opustab.c:795
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
const float ff_celt_mean_energy[]
Definition: opustab.c:787
static void celt_enc_quant_pfilter(OpusRangeCoder *rc, CeltFrame *f)
Definition: opusenc.c:612
OpusRangeCoder * rc
Definition: opusenc.c:52
#define av_freep(p)
static void ff_bufqueue_add(void *log, struct FFBufQueue *queue, AVFrame *buf)
Add a buffer to the queue.
Definition: bufferqueue.h:71
enum CeltBlockSize size
Definition: opus_celt.h:103
int alloc_trim
Definition: opus_celt.h:111
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:329
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:248
#define AV_CH_LAYOUT_MONO
void(* mdct)(struct MDCT15Context *s, float *dst, const float *src, ptrdiff_t stride)
Definition: mdct15.h:49
This structure stores compressed data.
Definition: avcodec.h:1377
const uint16_t ff_celt_model_tapset[]
Definition: opustab.c:753
static void celt_apply_preemph_filter(OpusEncContext *s, CeltFrame *f)
Definition: opusenc.c:157
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:267
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1393
for(j=16;j >0;--j)
int pf_octave
Definition: opus_celt.h:125
float overlap[FFALIGN(CELT_OVERLAP, 16)]
Definition: opus_celt.h:78
void av_cold ff_celt_pvq_uninit(CeltPVQ **pvq)
Definition: opus_pvq.c:914
int intensity_stereo
Definition: opus_celt.h:118
void ff_celt_quant_bands(CeltFrame *f, OpusRangeCoder *rc)
Definition: opus.c:443
static const uint8_t bits1[81]
Definition: aactab.c:117
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
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 av_always_inline uint32_t opus_rc_tell_frac(const OpusRangeCoder *rc)
Definition: opus_rc.h:66
static AVFrame * ff_bufqueue_peek(struct FFBufQueue *queue, unsigned index)
Get a buffer from the queue without altering it.
Definition: bufferqueue.h:87
static uint8_t tmp[11]
Definition: aes_ctr.c:26