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 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 (int 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  AVFrame *cur = NULL;
119  const int subframesize = s->avctx->frame_size;
120  int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;
121 
122  cur = ff_bufqueue_get(&s->bufqueue);
123 
124  for (int ch = 0; ch < f->channels; ch++) {
125  CeltBlock *b = &f->block[ch];
126  const void *input = cur->extended_data[ch];
127  size_t bps = av_get_bytes_per_sample(cur->format);
128  memcpy(b->overlap, input, bps*cur->nb_samples);
129  }
130 
131  av_frame_free(&cur);
132 
133  for (int sf = 0; sf < subframes; sf++) {
134  if (sf != (subframes - 1))
135  cur = ff_bufqueue_get(&s->bufqueue);
136  else
137  cur = ff_bufqueue_peek(&s->bufqueue, 0);
138 
139  for (int ch = 0; ch < f->channels; ch++) {
140  CeltBlock *b = &f->block[ch];
141  const void *input = cur->extended_data[ch];
142  const size_t bps = av_get_bytes_per_sample(cur->format);
143  const size_t left = (subframesize - cur->nb_samples)*bps;
144  const size_t len = FFMIN(subframesize, cur->nb_samples)*bps;
145  memcpy(&b->samples[sf*subframesize], input, len);
146  memset(&b->samples[cur->nb_samples], 0, left);
147  }
148 
149  /* Last frame isn't popped off and freed yet - we need it for overlap */
150  if (sf != (subframes - 1))
151  av_frame_free(&cur);
152  }
153 }
154 
155 /* Apply the pre emphasis filter */
157 {
158  const int subframesize = s->avctx->frame_size;
159  const int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;
160 
161  /* Filter overlap */
162  for (int ch = 0; ch < f->channels; ch++) {
163  CeltBlock *b = &f->block[ch];
164  float m = b->emph_coeff;
165  for (int i = 0; i < CELT_OVERLAP; i++) {
166  float sample = b->overlap[i];
167  b->overlap[i] = sample - m;
168  m = sample * CELT_EMPH_COEFF;
169  }
170  b->emph_coeff = m;
171  }
172 
173  /* Filter the samples but do not update the last subframe's coeff - overlap ^^^ */
174  for (int sf = 0; sf < subframes; sf++) {
175  for (int ch = 0; ch < f->channels; ch++) {
176  CeltBlock *b = &f->block[ch];
177  float m = b->emph_coeff;
178  for (int i = 0; i < subframesize; i++) {
179  float sample = b->samples[sf*subframesize + i];
180  b->samples[sf*subframesize + i] = sample - m;
181  m = sample * CELT_EMPH_COEFF;
182  }
183  if (sf != (subframes - 1))
184  b->emph_coeff = m;
185  }
186  }
187 }
188 
189 /* Create the window and do the mdct */
191 {
192  float *win = s->scratch, *temp = s->scratch + 1920;
193 
194  if (f->transient) {
195  for (int ch = 0; ch < f->channels; ch++) {
196  CeltBlock *b = &f->block[ch];
197  float *src1 = b->overlap;
198  for (int t = 0; t < f->blocks; t++) {
199  float *src2 = &b->samples[CELT_OVERLAP*t];
200  s->dsp->vector_fmul(win, src1, ff_celt_window, 128);
201  s->dsp->vector_fmul_reverse(&win[CELT_OVERLAP], src2,
202  ff_celt_window - 8, 128);
203  src1 = src2;
204  s->mdct[0]->mdct(s->mdct[0], b->coeffs + t, win, f->blocks);
205  }
206  }
207  } else {
208  int blk_len = OPUS_BLOCK_SIZE(f->size), wlen = OPUS_BLOCK_SIZE(f->size + 1);
209  int rwin = blk_len - CELT_OVERLAP, lap_dst = (wlen - blk_len - CELT_OVERLAP) >> 1;
210  memset(win, 0, wlen*sizeof(float));
211  for (int ch = 0; ch < f->channels; ch++) {
212  CeltBlock *b = &f->block[ch];
213 
214  /* Overlap */
215  s->dsp->vector_fmul(temp, b->overlap, ff_celt_window, 128);
216  memcpy(win + lap_dst, temp, CELT_OVERLAP*sizeof(float));
217 
218  /* Samples, flat top window */
219  memcpy(&win[lap_dst + CELT_OVERLAP], b->samples, rwin*sizeof(float));
220 
221  /* Samples, windowed */
222  s->dsp->vector_fmul_reverse(temp, b->samples + rwin,
223  ff_celt_window - 8, 128);
224  memcpy(win + lap_dst + blk_len, temp, CELT_OVERLAP*sizeof(float));
225 
226  s->mdct[f->size]->mdct(s->mdct[f->size], b->coeffs, win, 1);
227  }
228  }
229 
230  for (int ch = 0; ch < f->channels; ch++) {
231  CeltBlock *block = &f->block[ch];
232  for (int i = 0; i < CELT_MAX_BANDS; i++) {
233  float ener = 0.0f;
234  int band_offset = ff_celt_freq_bands[i] << f->size;
235  int band_size = ff_celt_freq_range[i] << f->size;
236  float *coeffs = &block->coeffs[band_offset];
237 
238  for (int j = 0; j < band_size; j++)
239  ener += coeffs[j]*coeffs[j];
240 
241  block->lin_energy[i] = sqrtf(ener) + FLT_EPSILON;
242  ener = 1.0f/block->lin_energy[i];
243 
244  for (int j = 0; j < band_size; j++)
245  coeffs[j] *= ener;
246 
247  block->energy[i] = log2f(block->lin_energy[i]) - ff_celt_mean_energy[i];
248 
249  /* CELT_ENERGY_SILENCE is what the decoder uses and its not -infinity */
250  block->energy[i] = FFMAX(block->energy[i], CELT_ENERGY_SILENCE);
251  }
252  }
253 }
254 
256 {
257  int tf_select = 0, diff = 0, tf_changed = 0, tf_select_needed;
258  int bits = f->transient ? 2 : 4;
259 
260  tf_select_needed = ((f->size && (opus_rc_tell(rc) + bits + 1) <= f->framebits));
261 
262  for (int i = f->start_band; i < f->end_band; i++) {
263  if ((opus_rc_tell(rc) + bits + tf_select_needed) <= f->framebits) {
264  const int tbit = (diff ^ 1) == f->tf_change[i];
265  ff_opus_rc_enc_log(rc, tbit, bits);
266  diff ^= tbit;
267  tf_changed |= diff;
268  }
269  bits = f->transient ? 4 : 5;
270  }
271 
272  if (tf_select_needed && ff_celt_tf_select[f->size][f->transient][0][tf_changed] !=
273  ff_celt_tf_select[f->size][f->transient][1][tf_changed]) {
274  ff_opus_rc_enc_log(rc, f->tf_select, 1);
275  tf_select = f->tf_select;
276  }
277 
278  for (int i = f->start_band; i < f->end_band; i++)
279  f->tf_change[i] = ff_celt_tf_select[f->size][f->transient][tf_select][f->tf_change[i]];
280 }
281 
283 {
284  float gain = f->pf_gain;
285  int txval, octave = f->pf_octave, period = f->pf_period, tapset = f->pf_tapset;
286 
287  ff_opus_rc_enc_log(rc, f->pfilter, 1);
288  if (!f->pfilter)
289  return;
290 
291  /* Octave */
292  txval = FFMIN(octave, 6);
293  ff_opus_rc_enc_uint(rc, txval, 6);
294  octave = txval;
295  /* Period */
296  txval = av_clip(period - (16 << octave) + 1, 0, (1 << (4 + octave)) - 1);
297  ff_opus_rc_put_raw(rc, period, 4 + octave);
298  period = txval + (16 << octave) - 1;
299  /* Gain */
300  txval = FFMIN(((int)(gain / 0.09375f)) - 1, 7);
301  ff_opus_rc_put_raw(rc, txval, 3);
302  gain = 0.09375f * (txval + 1);
303  /* Tapset */
304  if ((opus_rc_tell(rc) + 2) <= f->framebits)
306  else
307  tapset = 0;
308  /* Finally create the coeffs */
309  for (int i = 0; i < 2; i++) {
310  CeltBlock *block = &f->block[i];
311 
313  block->pf_gains_new[0] = gain * ff_celt_postfilter_taps[tapset][0];
314  block->pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1];
315  block->pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2];
316  }
317 }
318 
320  float last_energy[][CELT_MAX_BANDS], int intra)
321 {
322  float alpha, beta, prev[2] = { 0, 0 };
323  const uint8_t *pmod = ff_celt_coarse_energy_dist[f->size][intra];
324 
325  /* Inter is really just differential coding */
326  if (opus_rc_tell(rc) + 3 <= f->framebits)
327  ff_opus_rc_enc_log(rc, intra, 3);
328  else
329  intra = 0;
330 
331  if (intra) {
332  alpha = 0.0f;
333  beta = 1.0f - (4915.0f/32768.0f);
334  } else {
335  alpha = ff_celt_alpha_coef[f->size];
336  beta = ff_celt_beta_coef[f->size];
337  }
338 
339  for (int i = f->start_band; i < f->end_band; i++) {
340  for (int ch = 0; ch < f->channels; ch++) {
341  CeltBlock *block = &f->block[ch];
342  const int left = f->framebits - opus_rc_tell(rc);
343  const float last = FFMAX(-9.0f, last_energy[ch][i]);
344  float diff = block->energy[i] - prev[ch] - last*alpha;
345  int q_en = lrintf(diff);
346  if (left >= 15) {
347  ff_opus_rc_enc_laplace(rc, &q_en, pmod[i << 1] << 7, pmod[(i << 1) + 1] << 6);
348  } else if (left >= 2) {
349  q_en = av_clip(q_en, -1, 1);
350  ff_opus_rc_enc_cdf(rc, 2*q_en + 3*(q_en < 0), ff_celt_model_energy_small);
351  } else if (left >= 1) {
352  q_en = av_clip(q_en, -1, 0);
353  ff_opus_rc_enc_log(rc, (q_en & 1), 1);
354  } else q_en = -1;
355 
356  block->error_energy[i] = q_en - diff;
357  prev[ch] += beta * q_en;
358  }
359  }
360 }
361 
363  float last_energy[][CELT_MAX_BANDS])
364 {
365  uint32_t inter, intra;
367 
368  exp_quant_coarse(rc, f, last_energy, 1);
369  intra = OPUS_RC_CHECKPOINT_BITS(rc);
370 
372 
373  exp_quant_coarse(rc, f, last_energy, 0);
374  inter = OPUS_RC_CHECKPOINT_BITS(rc);
375 
376  if (inter > intra) { /* Unlikely */
378  exp_quant_coarse(rc, f, last_energy, 1);
379  }
380 }
381 
383 {
384  for (int i = f->start_band; i < f->end_band; i++) {
385  if (!f->fine_bits[i])
386  continue;
387  for (int ch = 0; ch < f->channels; ch++) {
388  CeltBlock *block = &f->block[ch];
389  int quant, lim = (1 << f->fine_bits[i]);
390  float offset, diff = 0.5f - block->error_energy[i];
391  quant = av_clip(floor(diff*lim), 0, lim - 1);
392  ff_opus_rc_put_raw(rc, quant, f->fine_bits[i]);
393  offset = 0.5f - ((quant + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f);
394  block->error_energy[i] -= offset;
395  }
396  }
397 }
398 
400 {
401  for (int priority = 0; priority < 2; priority++) {
402  for (int i = f->start_band; i < f->end_band && (f->framebits - opus_rc_tell(rc)) >= f->channels; i++) {
403  if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS)
404  continue;
405  for (int ch = 0; ch < f->channels; ch++) {
406  CeltBlock *block = &f->block[ch];
407  const float err = block->error_energy[i];
408  const float offset = 0.5f * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f;
409  const int sign = FFABS(err + offset) < FFABS(err - offset);
410  ff_opus_rc_put_raw(rc, sign, 1);
411  block->error_energy[i] -= offset*(1 - 2*sign);
412  }
413  }
414  }
415 }
416 
418  CeltFrame *f, int index)
419 {
421 
422  ff_opus_psy_celt_frame_init(&s->psyctx, f, index);
423 
425 
426  if (f->silence) {
427  if (f->framebits >= 16)
428  ff_opus_rc_enc_log(rc, 1, 15); /* Silence (if using explicit singalling) */
429  for (int ch = 0; ch < s->channels; ch++)
430  memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
431  return;
432  }
433 
434  /* Filters */
436  if (f->pfilter) {
437  ff_opus_rc_enc_log(rc, 0, 15);
438  celt_enc_quant_pfilter(rc, f);
439  }
440 
441  /* Transform */
442  celt_frame_mdct(s, f);
443 
444  /* Need to handle transient/non-transient switches at any point during analysis */
445  while (ff_opus_psy_celt_frame_process(&s->psyctx, f, index))
446  celt_frame_mdct(s, f);
447 
449 
450  /* Silence */
451  ff_opus_rc_enc_log(rc, 0, 15);
452 
453  /* Pitch filter */
454  if (!f->start_band && opus_rc_tell(rc) + 16 <= f->framebits)
455  celt_enc_quant_pfilter(rc, f);
456 
457  /* Transient flag */
458  if (f->size && opus_rc_tell(rc) + 3 <= f->framebits)
459  ff_opus_rc_enc_log(rc, f->transient, 3);
460 
461  /* Main encoding */
463  celt_enc_tf (f, rc);
464  ff_celt_bitalloc (f, rc, 1);
465  celt_quant_fine (f, rc);
466  ff_celt_quant_bands(f, rc);
467 
468  /* Anticollapse bit */
469  if (f->anticollapse_needed)
470  ff_opus_rc_put_raw(rc, f->anticollapse, 1);
471 
472  /* Final per-band energy adjustments from leftover bits */
473  celt_quant_final(s, rc, f);
474 
475  for (int ch = 0; ch < f->channels; ch++) {
476  CeltBlock *block = &f->block[ch];
477  for (int i = 0; i < CELT_MAX_BANDS; i++)
478  s->last_quantized_energy[ch][i] = block->energy[i] + block->error_energy[i];
479  }
480 }
481 
482 static inline int write_opuslacing(uint8_t *dst, int v)
483 {
484  dst[0] = FFMIN(v - FFALIGN(v - 255, 4), v);
485  dst[1] = v - dst[0] >> 2;
486  return 1 + (v >= 252);
487 }
488 
490 {
491  int offset, fsize_needed;
492 
493  /* Write toc */
494  opus_gen_toc(s, avpkt->data, &offset, &fsize_needed);
495 
496  /* Frame sizes if needed */
497  if (fsize_needed) {
498  for (int i = 0; i < s->packet.frames - 1; i++) {
499  offset += write_opuslacing(avpkt->data + offset,
500  s->frame[i].framebits >> 3);
501  }
502  }
503 
504  /* Packets */
505  for (int i = 0; i < s->packet.frames; i++) {
506  ff_opus_rc_enc_end(&s->rc[i], avpkt->data + offset,
507  s->frame[i].framebits >> 3);
508  offset += s->frame[i].framebits >> 3;
509  }
510 
511  avpkt->size = offset;
512 }
513 
514 /* Used as overlap for the first frame and padding for the last encoded packet */
516 {
517  AVFrame *f = av_frame_alloc();
518  if (!f)
519  return NULL;
520  f->format = s->avctx->sample_fmt;
521  f->nb_samples = s->avctx->frame_size;
523  if (av_frame_get_buffer(f, 4)) {
524  av_frame_free(&f);
525  return NULL;
526  }
527  for (int i = 0; i < s->channels; i++) {
528  size_t bps = av_get_bytes_per_sample(f->format);
529  memset(f->extended_data[i], 0, bps*f->nb_samples);
530  }
531  return f;
532 }
533 
534 static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
535  const AVFrame *frame, int *got_packet_ptr)
536 {
537  OpusEncContext *s = avctx->priv_data;
538  int ret, frame_size, alloc_size = 0;
539 
540  if (frame) { /* Add new frame to queue */
541  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
542  return ret;
543  ff_bufqueue_add(avctx, &s->bufqueue, av_frame_clone(frame));
544  } else {
546  if (!s->afq.remaining_samples)
547  return 0; /* We've been flushed and there's nothing left to encode */
548  }
549 
550  /* Run the psychoacoustic system */
551  if (ff_opus_psy_process(&s->psyctx, &s->packet))
552  return 0;
553 
554  frame_size = OPUS_BLOCK_SIZE(s->packet.framesize);
555 
556  if (!frame) {
557  /* This can go negative, that's not a problem, we only pad if positive */
558  int pad_empty = s->packet.frames*(frame_size/s->avctx->frame_size) - s->bufqueue.available + 1;
559  /* Pad with empty 2.5 ms frames to whatever framesize was decided,
560  * this should only happen at the very last flush frame. The frames
561  * allocated here will be freed (because they have no other references)
562  * after they get used by celt_frame_setup_input() */
563  for (int i = 0; i < pad_empty; i++) {
564  AVFrame *empty = spawn_empty_frame(s);
565  if (!empty)
566  return AVERROR(ENOMEM);
567  ff_bufqueue_add(avctx, &s->bufqueue, empty);
568  }
569  }
570 
571  for (int i = 0; i < s->packet.frames; i++) {
572  celt_encode_frame(s, &s->rc[i], &s->frame[i], i);
573  alloc_size += s->frame[i].framebits >> 3;
574  }
575 
576  /* Worst case toc + the frame lengths if needed */
577  alloc_size += 2 + s->packet.frames*2;
578 
579  if ((ret = ff_alloc_packet2(avctx, avpkt, alloc_size, 0)) < 0)
580  return ret;
581 
582  /* Assemble packet */
583  opus_packet_assembler(s, avpkt);
584 
585  /* Update the psychoacoustic system */
587 
588  /* Remove samples from queue and skip if needed */
589  ff_af_queue_remove(&s->afq, s->packet.frames*frame_size, &avpkt->pts, &avpkt->duration);
590  if (s->packet.frames*frame_size > avpkt->duration) {
592  if (!side)
593  return AVERROR(ENOMEM);
594  AV_WL32(&side[4], s->packet.frames*frame_size - avpkt->duration + 120);
595  }
596 
597  *got_packet_ptr = 1;
598 
599  return 0;
600 }
601 
603 {
604  OpusEncContext *s = avctx->priv_data;
605 
606  for (int i = 0; i < CELT_BLOCK_NB; i++)
607  ff_mdct15_uninit(&s->mdct[i]);
608 
609  ff_celt_pvq_uninit(&s->pvq);
610  av_freep(&s->dsp);
611  av_freep(&s->frame);
612  av_freep(&s->rc);
613  ff_af_queue_close(&s->afq);
614  ff_opus_psy_end(&s->psyctx);
616  av_freep(&avctx->extradata);
617 
618  return 0;
619 }
620 
622 {
623  int ret, max_frames;
624  OpusEncContext *s = avctx->priv_data;
625 
626  s->avctx = avctx;
627  s->channels = avctx->channels;
628 
629  /* Opus allows us to change the framesize on each packet (and each packet may
630  * have multiple frames in it) but we can't change the codec's frame size on
631  * runtime, so fix it to the lowest possible number of samples and use a queue
632  * to accumulate AVFrames until we have enough to encode whatever the encoder
633  * decides is the best */
634  avctx->frame_size = 120;
635  /* Initial padding will change if SILK is ever supported */
636  avctx->initial_padding = 120;
637 
638  if (!avctx->bit_rate) {
639  int coupled = ff_opus_default_coupled_streams[s->channels - 1];
640  avctx->bit_rate = coupled*(96000) + (s->channels - coupled*2)*(48000);
641  } else if (avctx->bit_rate < 6000 || avctx->bit_rate > 255000 * s->channels) {
642  int64_t clipped_rate = av_clip(avctx->bit_rate, 6000, 255000 * s->channels);
643  av_log(avctx, AV_LOG_ERROR, "Unsupported bitrate %"PRId64" kbps, clipping to %"PRId64" kbps\n",
644  avctx->bit_rate/1000, clipped_rate/1000);
645  avctx->bit_rate = clipped_rate;
646  }
647 
648  /* Extradata */
649  avctx->extradata_size = 19;
651  if (!avctx->extradata)
652  return AVERROR(ENOMEM);
653  opus_write_extradata(avctx);
654 
655  ff_af_queue_init(avctx, &s->afq);
656 
657  if ((ret = ff_celt_pvq_init(&s->pvq, 1)) < 0)
658  return ret;
659 
661  return AVERROR(ENOMEM);
662 
663  /* I have no idea why a base scaling factor of 68 works, could be the twiddles */
664  for (int i = 0; i < CELT_BLOCK_NB; i++)
665  if ((ret = ff_mdct15_init(&s->mdct[i], 0, i + 3, 68 << (CELT_BLOCK_NB - 1 - i))))
666  return AVERROR(ENOMEM);
667 
668  /* Zero out previous energy (matters for inter first frame) */
669  for (int ch = 0; ch < s->channels; ch++)
670  memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
671 
672  /* Allocate an empty frame to use as overlap for the first frame of audio */
674  if (!ff_bufqueue_peek(&s->bufqueue, 0))
675  return AVERROR(ENOMEM);
676 
677  if ((ret = ff_opus_psy_init(&s->psyctx, s->avctx, &s->bufqueue, &s->options)))
678  return ret;
679 
680  /* Frame structs and range coder buffers */
681  max_frames = ceilf(FFMIN(s->options.max_delay_ms, 120.0f)/2.5f);
682  s->frame = av_malloc(max_frames*sizeof(CeltFrame));
683  if (!s->frame)
684  return AVERROR(ENOMEM);
685  s->rc = av_malloc(max_frames*sizeof(OpusRangeCoder));
686  if (!s->rc)
687  return AVERROR(ENOMEM);
688 
689  for (int i = 0; i < max_frames; i++) {
690  s->frame[i].dsp = s->dsp;
691  s->frame[i].avctx = s->avctx;
692  s->frame[i].seed = 0;
693  s->frame[i].pvq = s->pvq;
694  s->frame[i].apply_phase_inv = 1;
695  s->frame[i].block[0].emph_coeff = s->frame[i].block[1].emph_coeff = 0.0f;
696  }
697 
698  return 0;
699 }
700 
701 #define OPUSENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
702 static const AVOption opusenc_options[] = {
703  { "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" },
704  { NULL },
705 };
706 
707 static const AVClass opusenc_class = {
708  .class_name = "Opus encoder",
709  .item_name = av_default_item_name,
710  .option = opusenc_options,
711  .version = LIBAVUTIL_VERSION_INT,
712 };
713 
715  { "b", "0" },
716  { "compression_level", "10" },
717  { NULL },
718 };
719 
721  .name = "opus",
722  .long_name = NULL_IF_CONFIG_SMALL("Opus"),
723  .type = AVMEDIA_TYPE_AUDIO,
724  .id = AV_CODEC_ID_OPUS,
725  .defaults = opusenc_defaults,
726  .priv_class = &opusenc_class,
727  .priv_data_size = sizeof(OpusEncContext),
729  .encode2 = opus_encode_frame,
730  .close = opus_encode_end,
733  .supported_samplerates = (const int []){ 48000, 0 },
734  .channel_layouts = (const uint64_t []){ AV_CH_LAYOUT_MONO,
735  AV_CH_LAYOUT_STEREO, 0 },
736  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
738 };
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:621
enum OpusBandwidth bandwidth
Definition: opusenc.h:49
#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:218
static void celt_enc_tf(CeltFrame *f, OpusRangeCoder *rc)
Definition: opusenc.c:255
static const AVCodecDefault opusenc_defaults[]
Definition: opusenc.c:714
AVOption.
Definition: opt.h:246
int framebits
Definition: opus_celt.h:131
static const AVOption opusenc_options[]
Definition: opusenc.c:702
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:515
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:1582
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static void opus_packet_assembler(OpusEncContext *s, AVPacket *avpkt)
Definition: opusenc.c:489
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:1445
const char * b
Definition: vf_curves.c:113
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
float pf_gains_new[3]
Definition: opus_celt.h:83
static av_cold int opus_encode_end(AVCodecContext *avctx)
Definition: opusenc.c:602
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:1015
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:3423
int pf_period
Definition: opus_celt.h:126
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:701
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:992
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:319
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:2196
uint8_t
#define av_cold
Definition: attributes.h:82
AVCodec ff_opus_encoder
Definition: opusenc.c:720
#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:189
const float * ff_celt_window
Definition: opustab.c:1130
int silence
Definition: opus_celt.h:115
AVOptions.
#define f(width, name)
Definition: cbs_vp9.c:255
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:1462
#define OPUS_MAX_LOOKAHEAD
Definition: opusenc.h:32
AudioFrameQueue afq
Definition: opusenc.c:38
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1633
int ff_opus_psy_process(OpusPsyContext *s, OpusPacketInfo *p)
Definition: opusenc_psy.c:223
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:1444
int ff_opus_psy_celt_frame_process(OpusPsyContext *s, CeltFrame *f, int index)
Definition: opusenc_psy.c:455
enum OpusMode mode
Definition: opusenc.h:48
#define lrintf(x)
Definition: libm_mips.h:70
ptrdiff_t size
Definition: opengl_enc.c:101
float lin_energy[CELT_MAX_BANDS]
Definition: opus_celt.h:67
#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:534
#define av_log(a,...)
float samples[FFALIGN(CELT_MAX_FRAME_SIZE, 16)]
Definition: opus_celt.h:79
#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:135
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:202
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:3046
#define OPUS_RC_CHECKPOINT_ROLLBACK(rc)
Definition: opus_rc.h:123
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1612
av_cold int ff_opus_psy_init(OpusPsyContext *s, AVCodecContext *avctx, struct FFBufQueue *bufqueue, OpusEncOptions *options)
Definition: opusenc_psy.c:516
int tf_change[CELT_MAX_BANDS]
Definition: opus_celt.h:138
const char * name
Name of the codec implementation.
Definition: avcodec.h:3430
static void celt_quant_fine(CeltFrame *f, OpusRangeCoder *rc)
Definition: opusenc.c:382
float emph_coeff
Definition: opus_celt.h:89
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:190
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:2239
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:396
AVCodecContext * avctx
Definition: opus_celt.h:94
uint32_t seed
Definition: opus_celt.h:121
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:894
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: avcodec.h:997
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
#define s(width, name)
Definition: cbs_vp9.c:257
int blocks
Definition: opus_celt.h:113
int transient
Definition: opus_celt.h:107
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:538
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:291
AVCodecContext * avctx
Definition: opusenc.c:37
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2208
struct FFBufQueue bufqueue
Definition: opusenc.c:42
#define src1
Definition: h264pred.c:139
int frame_size
Definition: mxfenc.c:2166
static void celt_encode_frame(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f, int index)
Definition: opusenc.c:417
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:2188
int pf_tapset
Definition: opus_celt.h:127
main external API structure.
Definition: avcodec.h:1532
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:1634
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:482
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:588
int index
Definition: gxfenc.c:89
#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:1267
void ff_celt_bitalloc(CeltFrame *f, OpusRangeCoder *rc, int encode)
Definition: opus.c:552
av_cold int ff_opus_psy_end(OpusPsyContext *s)
Definition: opusenc_psy.c:593
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:362
void ff_opus_psy_postencode_update(OpusPsyContext *s, CeltFrame *f, OpusRangeCoder *rc)
Definition: opusenc_psy.c:479
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:322
#define OPUS_MAX_CHANNELS
Definition: opusenc.h:34
AVFloatDSPContext * dsp
Definition: opusenc.c:39
int framesize
Definition: opusenc.h:50
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
float energy[CELT_MAX_BANDS]
Definition: opus_celt.h:66
OpusPacketInfo packet
Definition: opusenc.c:47
static const AVClass opusenc_class
Definition: opusenc.c:707
static void celt_quant_final(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f)
Definition: opusenc.c:399
const float ff_celt_beta_coef[]
Definition: opustab.c:799
const OptionDef options[]
Definition: ffmpeg_opt.c:3322
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.
#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
unsigned bps
Definition: movenc.c:1484
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:368
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:781
av_cold void ff_mdct15_uninit(MDCT15Context **ps)
Definition: mdct15.c:43
void * priv_data
Definition: avcodec.h:1559
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)
int len
int channels
number of audio channels
Definition: avcodec.h:2189
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:282
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
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:265
#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:1421
const uint16_t ff_celt_model_tapset[]
Definition: opustab.c:753
static void celt_apply_preemph_filter(OpusEncContext *s, CeltFrame *f)
Definition: opusenc.c:156
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:284
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1437
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
void ff_celt_quant_bands(CeltFrame *f, OpusRangeCoder *rc)
Definition: opus.c:443
#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 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