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  float gain = f->pf_gain;
288  int i, txval, octave = f->pf_octave, period = f->pf_period, tapset = f->pf_tapset;
289 
290  ff_opus_rc_enc_log(rc, f->pfilter, 1);
291  if (!f->pfilter)
292  return;
293 
294  /* Octave */
295  txval = FFMIN(octave, 6);
296  ff_opus_rc_enc_uint(rc, txval, 6);
297  octave = txval;
298  /* Period */
299  txval = av_clip(period - (16 << octave) + 1, 0, (1 << (4 + octave)) - 1);
300  ff_opus_rc_put_raw(rc, period, 4 + octave);
301  period = txval + (16 << octave) - 1;
302  /* Gain */
303  txval = FFMIN(((int)(gain / 0.09375f)) - 1, 7);
304  ff_opus_rc_put_raw(rc, txval, 3);
305  gain = 0.09375f * (txval + 1);
306  /* Tapset */
307  if ((opus_rc_tell(rc) + 2) <= f->framebits)
309  else
310  tapset = 0;
311  /* Finally create the coeffs */
312  for (i = 0; i < 2; i++) {
313  CeltBlock *block = &f->block[i];
314 
316  block->pf_gains_new[0] = gain * ff_celt_postfilter_taps[tapset][0];
317  block->pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1];
318  block->pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2];
319  }
320 }
321 
323  float last_energy[][CELT_MAX_BANDS], int intra)
324 {
325  int i, ch;
326  float alpha, beta, prev[2] = { 0, 0 };
327  const uint8_t *pmod = ff_celt_coarse_energy_dist[f->size][intra];
328 
329  /* Inter is really just differential coding */
330  if (opus_rc_tell(rc) + 3 <= f->framebits)
331  ff_opus_rc_enc_log(rc, intra, 3);
332  else
333  intra = 0;
334 
335  if (intra) {
336  alpha = 0.0f;
337  beta = 1.0f - (4915.0f/32768.0f);
338  } else {
339  alpha = ff_celt_alpha_coef[f->size];
340  beta = ff_celt_beta_coef[f->size];
341  }
342 
343  for (i = f->start_band; i < f->end_band; i++) {
344  for (ch = 0; ch < f->channels; ch++) {
345  CeltBlock *block = &f->block[ch];
346  const int left = f->framebits - opus_rc_tell(rc);
347  const float last = FFMAX(-9.0f, last_energy[ch][i]);
348  float diff = block->energy[i] - prev[ch] - last*alpha;
349  int q_en = lrintf(diff);
350  if (left >= 15) {
351  ff_opus_rc_enc_laplace(rc, &q_en, pmod[i << 1] << 7, pmod[(i << 1) + 1] << 6);
352  } else if (left >= 2) {
353  q_en = av_clip(q_en, -1, 1);
354  ff_opus_rc_enc_cdf(rc, 2*q_en + 3*(q_en < 0), ff_celt_model_energy_small);
355  } else if (left >= 1) {
356  q_en = av_clip(q_en, -1, 0);
357  ff_opus_rc_enc_log(rc, (q_en & 1), 1);
358  } else q_en = -1;
359 
360  block->error_energy[i] = q_en - diff;
361  prev[ch] += beta * q_en;
362  }
363  }
364 }
365 
367  float last_energy[][CELT_MAX_BANDS])
368 {
369  uint32_t inter, intra;
371 
372  exp_quant_coarse(rc, f, last_energy, 1);
373  intra = OPUS_RC_CHECKPOINT_BITS(rc);
374 
376 
377  exp_quant_coarse(rc, f, last_energy, 0);
378  inter = OPUS_RC_CHECKPOINT_BITS(rc);
379 
380  if (inter > intra) { /* Unlikely */
382  exp_quant_coarse(rc, f, last_energy, 1);
383  }
384 }
385 
387 {
388  int i, ch;
389  for (i = f->start_band; i < f->end_band; i++) {
390  if (!f->fine_bits[i])
391  continue;
392  for (ch = 0; ch < f->channels; ch++) {
393  CeltBlock *block = &f->block[ch];
394  int quant, lim = (1 << f->fine_bits[i]);
395  float offset, diff = 0.5f - block->error_energy[i];
396  quant = av_clip(floor(diff*lim), 0, lim - 1);
397  ff_opus_rc_put_raw(rc, quant, f->fine_bits[i]);
398  offset = 0.5f - ((quant + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f);
399  block->error_energy[i] -= offset;
400  }
401  }
402 }
403 
405 {
406  int i, ch, priority;
407  for (priority = 0; priority < 2; priority++) {
408  for (i = f->start_band; i < f->end_band && (f->framebits - opus_rc_tell(rc)) >= f->channels; i++) {
409  if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS)
410  continue;
411  for (ch = 0; ch < f->channels; ch++) {
412  CeltBlock *block = &f->block[ch];
413  const float err = block->error_energy[i];
414  const float offset = 0.5f * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f;
415  const int sign = FFABS(err + offset) < FFABS(err - offset);
416  ff_opus_rc_put_raw(rc, sign, 1);
417  block->error_energy[i] -= offset*(1 - 2*sign);
418  }
419  }
420  }
421 }
422 
424  CeltFrame *f, int index)
425 {
426  int i, ch;
427 
429 
430  ff_opus_psy_celt_frame_init(&s->psyctx, f, index);
431 
433 
434  if (f->silence) {
435  if (f->framebits >= 16)
436  ff_opus_rc_enc_log(rc, 1, 15); /* Silence (if using explicit singalling) */
437  for (ch = 0; ch < s->channels; ch++)
438  memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
439  return;
440  }
441 
442  /* Filters */
444  if (f->pfilter) {
445  ff_opus_rc_enc_log(rc, 0, 15);
446  celt_enc_quant_pfilter(rc, f);
447  }
448 
449  /* Transform */
450  celt_frame_mdct(s, f);
451 
452  /* Need to handle transient/non-transient switches at any point during analysis */
453  while (ff_opus_psy_celt_frame_process(&s->psyctx, f, index))
454  celt_frame_mdct(s, f);
455 
457 
458  /* Silence */
459  ff_opus_rc_enc_log(rc, 0, 15);
460 
461  /* Pitch filter */
462  if (!f->start_band && opus_rc_tell(rc) + 16 <= f->framebits)
463  celt_enc_quant_pfilter(rc, f);
464 
465  /* Transient flag */
466  if (f->size && opus_rc_tell(rc) + 3 <= f->framebits)
467  ff_opus_rc_enc_log(rc, f->transient, 3);
468 
469  /* Main encoding */
471  celt_enc_tf (f, rc);
472  ff_celt_bitalloc (f, rc, 1);
473  celt_quant_fine (f, rc);
474  ff_celt_quant_bands(f, rc);
475 
476  /* Anticollapse bit */
477  if (f->anticollapse_needed)
478  ff_opus_rc_put_raw(rc, f->anticollapse, 1);
479 
480  /* Final per-band energy adjustments from leftover bits */
481  celt_quant_final(s, rc, f);
482 
483  for (ch = 0; ch < f->channels; ch++) {
484  CeltBlock *block = &f->block[ch];
485  for (i = 0; i < CELT_MAX_BANDS; i++)
486  s->last_quantized_energy[ch][i] = block->energy[i] + block->error_energy[i];
487  }
488 }
489 
490 static inline int write_opuslacing(uint8_t *dst, int v)
491 {
492  dst[0] = FFMIN(v - FFALIGN(v - 255, 4), v);
493  dst[1] = v - dst[0] >> 2;
494  return 1 + (v >= 252);
495 }
496 
498 {
499  int i, offset, fsize_needed;
500 
501  /* Write toc */
502  opus_gen_toc(s, avpkt->data, &offset, &fsize_needed);
503 
504  /* Frame sizes if needed */
505  if (fsize_needed) {
506  for (i = 0; i < s->packet.frames - 1; i++) {
507  offset += write_opuslacing(avpkt->data + offset,
508  s->frame[i].framebits >> 3);
509  }
510  }
511 
512  /* Packets */
513  for (i = 0; i < s->packet.frames; i++) {
514  ff_opus_rc_enc_end(&s->rc[i], avpkt->data + offset,
515  s->frame[i].framebits >> 3);
516  offset += s->frame[i].framebits >> 3;
517  }
518 
519  avpkt->size = offset;
520 }
521 
522 /* Used as overlap for the first frame and padding for the last encoded packet */
524 {
525  int i;
526  AVFrame *f = av_frame_alloc();
527  if (!f)
528  return NULL;
529  f->format = s->avctx->sample_fmt;
530  f->nb_samples = s->avctx->frame_size;
532  if (av_frame_get_buffer(f, 4)) {
533  av_frame_free(&f);
534  return NULL;
535  }
536  for (i = 0; i < s->channels; i++) {
537  size_t bps = av_get_bytes_per_sample(f->format);
538  memset(f->extended_data[i], 0, bps*f->nb_samples);
539  }
540  return f;
541 }
542 
543 static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
544  const AVFrame *frame, int *got_packet_ptr)
545 {
546  OpusEncContext *s = avctx->priv_data;
547  int i, ret, frame_size, alloc_size = 0;
548 
549  if (frame) { /* Add new frame to queue */
550  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
551  return ret;
552  ff_bufqueue_add(avctx, &s->bufqueue, av_frame_clone(frame));
553  } else {
555  if (!s->afq.remaining_samples)
556  return 0; /* We've been flushed and there's nothing left to encode */
557  }
558 
559  /* Run the psychoacoustic system */
560  if (ff_opus_psy_process(&s->psyctx, &s->packet))
561  return 0;
562 
563  frame_size = OPUS_BLOCK_SIZE(s->packet.framesize);
564 
565  if (!frame) {
566  /* This can go negative, that's not a problem, we only pad if positive */
567  int pad_empty = s->packet.frames*(frame_size/s->avctx->frame_size) - s->bufqueue.available + 1;
568  /* Pad with empty 2.5 ms frames to whatever framesize was decided,
569  * this should only happen at the very last flush frame. The frames
570  * allocated here will be freed (because they have no other references)
571  * after they get used by celt_frame_setup_input() */
572  for (i = 0; i < pad_empty; i++) {
573  AVFrame *empty = spawn_empty_frame(s);
574  if (!empty)
575  return AVERROR(ENOMEM);
576  ff_bufqueue_add(avctx, &s->bufqueue, empty);
577  }
578  }
579 
580  for (i = 0; i < s->packet.frames; i++) {
581  celt_encode_frame(s, &s->rc[i], &s->frame[i], i);
582  alloc_size += s->frame[i].framebits >> 3;
583  }
584 
585  /* Worst case toc + the frame lengths if needed */
586  alloc_size += 2 + s->packet.frames*2;
587 
588  if ((ret = ff_alloc_packet2(avctx, avpkt, alloc_size, 0)) < 0)
589  return ret;
590 
591  /* Assemble packet */
592  opus_packet_assembler(s, avpkt);
593 
594  /* Update the psychoacoustic system */
596 
597  /* Remove samples from queue and skip if needed */
598  ff_af_queue_remove(&s->afq, s->packet.frames*frame_size, &avpkt->pts, &avpkt->duration);
599  if (s->packet.frames*frame_size > avpkt->duration) {
601  if (!side)
602  return AVERROR(ENOMEM);
603  AV_WL32(&side[4], s->packet.frames*frame_size - avpkt->duration + 120);
604  }
605 
606  *got_packet_ptr = 1;
607 
608  return 0;
609 }
610 
612 {
613  int i;
614  OpusEncContext *s = avctx->priv_data;
615 
616  for (i = 0; i < CELT_BLOCK_NB; i++)
617  ff_mdct15_uninit(&s->mdct[i]);
618 
619  ff_celt_pvq_uninit(&s->pvq);
620  av_freep(&s->dsp);
621  av_freep(&s->frame);
622  av_freep(&s->rc);
623  ff_af_queue_close(&s->afq);
624  ff_opus_psy_end(&s->psyctx);
626  av_freep(&avctx->extradata);
627 
628  return 0;
629 }
630 
632 {
633  int i, ch, ret, max_frames;
634  OpusEncContext *s = avctx->priv_data;
635 
636  s->avctx = avctx;
637  s->channels = avctx->channels;
638 
639  /* Opus allows us to change the framesize on each packet (and each packet may
640  * have multiple frames in it) but we can't change the codec's frame size on
641  * runtime, so fix it to the lowest possible number of samples and use a queue
642  * to accumulate AVFrames until we have enough to encode whatever the encoder
643  * decides is the best */
644  avctx->frame_size = 120;
645  /* Initial padding will change if SILK is ever supported */
646  avctx->initial_padding = 120;
647 
648  if (!avctx->bit_rate) {
649  int coupled = ff_opus_default_coupled_streams[s->channels - 1];
650  avctx->bit_rate = coupled*(96000) + (s->channels - coupled*2)*(48000);
651  } else if (avctx->bit_rate < 6000 || avctx->bit_rate > 255000 * s->channels) {
652  int64_t clipped_rate = av_clip(avctx->bit_rate, 6000, 255000 * s->channels);
653  av_log(avctx, AV_LOG_ERROR, "Unsupported bitrate %"PRId64" kbps, clipping to %"PRId64" kbps\n",
654  avctx->bit_rate/1000, clipped_rate/1000);
655  avctx->bit_rate = clipped_rate;
656  }
657 
658  /* Extradata */
659  avctx->extradata_size = 19;
661  if (!avctx->extradata)
662  return AVERROR(ENOMEM);
663  opus_write_extradata(avctx);
664 
665  ff_af_queue_init(avctx, &s->afq);
666 
667  if ((ret = ff_celt_pvq_init(&s->pvq, 1)) < 0)
668  return ret;
669 
671  return AVERROR(ENOMEM);
672 
673  /* I have no idea why a base scaling factor of 68 works, could be the twiddles */
674  for (i = 0; i < CELT_BLOCK_NB; i++)
675  if ((ret = ff_mdct15_init(&s->mdct[i], 0, i + 3, 68 << (CELT_BLOCK_NB - 1 - i))))
676  return AVERROR(ENOMEM);
677 
678  /* Zero out previous energy (matters for inter first frame) */
679  for (ch = 0; ch < s->channels; ch++)
680  memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
681 
682  /* Allocate an empty frame to use as overlap for the first frame of audio */
684  if (!ff_bufqueue_peek(&s->bufqueue, 0))
685  return AVERROR(ENOMEM);
686 
687  if ((ret = ff_opus_psy_init(&s->psyctx, s->avctx, &s->bufqueue, &s->options)))
688  return ret;
689 
690  /* Frame structs and range coder buffers */
691  max_frames = ceilf(FFMIN(s->options.max_delay_ms, 120.0f)/2.5f);
692  s->frame = av_malloc(max_frames*sizeof(CeltFrame));
693  if (!s->frame)
694  return AVERROR(ENOMEM);
695  s->rc = av_malloc(max_frames*sizeof(OpusRangeCoder));
696  if (!s->rc)
697  return AVERROR(ENOMEM);
698 
699  for (i = 0; i < max_frames; i++) {
700  s->frame[i].dsp = s->dsp;
701  s->frame[i].avctx = s->avctx;
702  s->frame[i].seed = 0;
703  s->frame[i].pvq = s->pvq;
704  s->frame[i].apply_phase_inv = 1;
705  s->frame[i].block[0].emph_coeff = s->frame[i].block[1].emph_coeff = 0.0f;
706  }
707 
708  return 0;
709 }
710 
711 #define OPUSENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
712 static const AVOption opusenc_options[] = {
713  { "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" },
714  { NULL },
715 };
716 
717 static const AVClass opusenc_class = {
718  .class_name = "Opus encoder",
719  .item_name = av_default_item_name,
720  .option = opusenc_options,
721  .version = LIBAVUTIL_VERSION_INT,
722 };
723 
725  { "b", "0" },
726  { "compression_level", "10" },
727  { NULL },
728 };
729 
731  .name = "opus",
732  .long_name = NULL_IF_CONFIG_SMALL("Opus"),
733  .type = AVMEDIA_TYPE_AUDIO,
734  .id = AV_CODEC_ID_OPUS,
735  .defaults = opusenc_defaults,
736  .priv_class = &opusenc_class,
737  .priv_data_size = sizeof(OpusEncContext),
739  .encode2 = opus_encode_frame,
740  .close = opus_encode_end,
743  .supported_samplerates = (const int []){ 48000, 0 },
744  .channel_layouts = (const uint64_t []){ AV_CH_LAYOUT_MONO,
745  AV_CH_LAYOUT_STEREO, 0 },
746  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
748 };
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:631
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:724
AVOption.
Definition: opt.h:246
int framebits
Definition: opus_celt.h:131
static const AVOption opusenc_options[]
Definition: opusenc.c:712
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:523
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:1553
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static void opus_packet_assembler(OpusEncContext *s, AVPacket *avpkt)
Definition: opusenc.c:497
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:1416
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:611
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:1005
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:3386
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:711
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:982
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:322
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:2166
uint8_t
#define av_cold
Definition: attributes.h:82
AVCodec ff_opus_encoder
Definition: opusenc.c:730
#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:1433
#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:1603
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:1415
int ff_opus_psy_celt_frame_process(OpusPsyContext *s, CeltFrame *f, int index)
Definition: opusenc_psy.c:456
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:543
#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: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:3010
#define OPUS_RC_CHECKPOINT_ROLLBACK(rc)
Definition: opus_rc.h:123
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1583
av_cold int ff_opus_psy_init(OpusPsyContext *s, AVCodecContext *avctx, struct FFBufQueue *bufqueue, OpusEncOptions *options)
Definition: opusenc_psy.c:517
int tf_change[CELT_MAX_BANDS]
Definition: opus_celt.h:138
const char * name
Name of the codec implementation.
Definition: avcodec.h:3393
static void celt_quant_fine(CeltFrame *f, OpusRangeCoder *rc)
Definition: opusenc.c:386
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: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:2209
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
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:884
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: avcodec.h:987
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
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:2178
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:423
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:2158
int pf_tapset
Definition: opus_celt.h:127
main external API structure.
Definition: avcodec.h:1503
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:1604
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:490
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:589
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:1257
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:594
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:366
void ff_opus_psy_postencode_update(OpusPsyContext *s, CeltFrame *f, OpusRangeCoder *rc)
Definition: opusenc_psy.c:480
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
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:717
static void celt_quant_final(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f)
Definition: opusenc.c:404
const float ff_celt_beta_coef[]
Definition: opustab.c:799
const OptionDef options[]
Definition: ffmpeg_opt.c:3291
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:1450
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:771
av_cold void ff_mdct15_uninit(MDCT15Context **ps)
Definition: mdct15.c:43
void * priv_data
Definition: avcodec.h:1530
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:2159
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:285
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: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:1392
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:1408
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