FFmpeg
libopusenc.c
Go to the documentation of this file.
1 /*
2  * Opus encoder using libopus
3  * Copyright (c) 2012 Nathan Caldwell
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 <opus.h>
23 #include <opus_multistream.h>
24 
26 #include "libavutil/mem.h"
27 #include "libavutil/opt.h"
28 #include "avcodec.h"
29 #include "bytestream.h"
30 #include "codec_internal.h"
31 #include "encode.h"
32 #include "libopus.h"
33 #include "audio_frame_queue.h"
34 #include "vorbis_data.h"
35 
36 typedef struct LibopusEncOpts {
37  int vbr;
40  int fec;
46 #ifdef OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST
47  int apply_phase_inv;
48 #endif
50 
51 typedef struct LibopusEncContext {
52  AVClass *class;
53  OpusMSEncoder *enc;
55  uint8_t *samples;
58  const uint8_t *encoder_channel_map;
60 
61 static const uint8_t opus_coupled_streams[8] = {
62  0, 1, 1, 2, 2, 2, 2, 3
63 };
64 
65 /* Opus internal to Vorbis channel order mapping written in the header */
66 static const uint8_t opus_vorbis_channel_map[8][8] = {
67  { 0 },
68  { 0, 1 },
69  { 0, 2, 1 },
70  { 0, 1, 2, 3 },
71  { 0, 4, 1, 2, 3 },
72  { 0, 4, 1, 2, 3, 5 },
73  { 0, 4, 1, 2, 3, 5, 6 },
74  { 0, 6, 1, 2, 3, 4, 5, 7 },
75 };
76 
77 /* libavcodec to libopus channel order mapping, passed to libopus */
78 static const uint8_t libavcodec_libopus_channel_map[8][8] = {
79  { 0 },
80  { 0, 1 },
81  { 0, 1, 2 },
82  { 0, 1, 2, 3 },
83  { 0, 1, 3, 4, 2 },
84  { 0, 1, 4, 5, 2, 3 },
85  { 0, 1, 5, 6, 2, 4, 3 },
86  { 0, 1, 6, 7, 4, 5, 2, 3 },
87 };
88 
89 static void libopus_write_header(AVCodecContext *avctx, int stream_count,
90  int coupled_stream_count,
91  int mapping_family,
92  const uint8_t *channel_mapping)
93 {
94  uint8_t *p = avctx->extradata;
95  int channels = avctx->ch_layout.nb_channels;
96 
97  bytestream_put_buffer(&p, "OpusHead", 8);
98  bytestream_put_byte(&p, 1); /* Version */
99  bytestream_put_byte(&p, channels);
100  bytestream_put_le16(&p, avctx->initial_padding * 48000 / avctx->sample_rate); /* Lookahead samples at 48kHz */
101  bytestream_put_le32(&p, avctx->sample_rate); /* Original sample rate */
102  bytestream_put_le16(&p, 0); /* Gain of 0dB is recommended. */
103 
104  /* Channel mapping */
105  bytestream_put_byte(&p, mapping_family);
106  if (mapping_family != 0) {
107  bytestream_put_byte(&p, stream_count);
108  bytestream_put_byte(&p, coupled_stream_count);
109  bytestream_put_buffer(&p, channel_mapping, channels);
110  }
111 }
112 
113 static int libopus_configure_encoder(AVCodecContext *avctx, OpusMSEncoder *enc,
115 {
116  int ret;
117 
118  if (avctx->global_quality) {
119  av_log(avctx, AV_LOG_ERROR,
120  "Quality-based encoding not supported, "
121  "please specify a bitrate and VBR setting.\n");
122  return AVERROR(EINVAL);
123  }
124 
125  ret = opus_multistream_encoder_ctl(enc, OPUS_SET_BITRATE(avctx->bit_rate));
126  if (ret != OPUS_OK) {
127  av_log(avctx, AV_LOG_ERROR,
128  "Failed to set bitrate: %s\n", opus_strerror(ret));
129  return ret;
130  }
131 
132  ret = opus_multistream_encoder_ctl(enc,
133  OPUS_SET_COMPLEXITY(opts->complexity));
134  if (ret != OPUS_OK)
135  av_log(avctx, AV_LOG_WARNING,
136  "Unable to set complexity: %s\n", opus_strerror(ret));
137 
138  ret = opus_multistream_encoder_ctl(enc, OPUS_SET_VBR(!!opts->vbr));
139  if (ret != OPUS_OK)
140  av_log(avctx, AV_LOG_WARNING,
141  "Unable to set VBR: %s\n", opus_strerror(ret));
142 
143  ret = opus_multistream_encoder_ctl(enc,
144  OPUS_SET_VBR_CONSTRAINT(opts->vbr == 2));
145  if (ret != OPUS_OK)
146  av_log(avctx, AV_LOG_WARNING,
147  "Unable to set constrained VBR: %s\n", opus_strerror(ret));
148 
149  ret = opus_multistream_encoder_ctl(enc,
150  OPUS_SET_PACKET_LOSS_PERC(opts->packet_loss));
151  if (ret != OPUS_OK)
152  av_log(avctx, AV_LOG_WARNING,
153  "Unable to set expected packet loss percentage: %s\n",
154  opus_strerror(ret));
155 
156  ret = opus_multistream_encoder_ctl(enc,
157  OPUS_SET_INBAND_FEC(opts->fec));
158  if (ret != OPUS_OK)
159  av_log(avctx, AV_LOG_WARNING,
160  "Unable to set inband FEC: %s\n",
161  opus_strerror(ret));
162 
163  if (avctx->cutoff) {
164  ret = opus_multistream_encoder_ctl(enc,
165  OPUS_SET_MAX_BANDWIDTH(opts->max_bandwidth));
166  if (ret != OPUS_OK)
167  av_log(avctx, AV_LOG_WARNING,
168  "Unable to set maximum bandwidth: %s\n", opus_strerror(ret));
169  }
170 
171 #ifdef OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST
172  ret = opus_multistream_encoder_ctl(enc,
173  OPUS_SET_PHASE_INVERSION_DISABLED(!opts->apply_phase_inv));
174  if (ret != OPUS_OK)
175  av_log(avctx, AV_LOG_WARNING,
176  "Unable to set phase inversion: %s\n",
177  opus_strerror(ret));
178 #endif
179  return OPUS_OK;
180 }
181 
183  int max_channels) {
184  if (avctx->ch_layout.nb_channels > max_channels) {
185  av_log(avctx, AV_LOG_ERROR, "Opus mapping family undefined for %d channels.\n",
186  avctx->ch_layout.nb_channels);
187  return AVERROR(EINVAL);
188  }
189 
190  return 0;
191 }
192 
193 static int libopus_check_vorbis_layout(AVCodecContext *avctx, int mapping_family) {
195 
196  if (avctx->ch_layout.order == AV_CHANNEL_ORDER_UNSPEC) {
197  av_log(avctx, AV_LOG_WARNING,
198  "No channel layout specified. Opus encoder will use Vorbis "
199  "channel layout for %d channels.\n", avctx->ch_layout.nb_channels);
201  char name[32];
202 
203  av_channel_layout_describe(&avctx->ch_layout, name, sizeof(name));
204  av_log(avctx, AV_LOG_ERROR,
205  "Invalid channel layout %s for specified mapping family %d.\n",
206  name, mapping_family);
207 
208  return AVERROR(EINVAL);
209  }
210 
211  return 0;
212 }
213 
215  AVCodecContext *avctx,
216  int mapping_family,
217  const uint8_t ** channel_map_result)
218 {
219  const uint8_t * channel_map = NULL;
220  int ret;
221 
222  switch (mapping_family) {
223  case -1:
224  ret = libopus_check_max_channels(avctx, 8);
225  if (ret == 0) {
226  ret = libopus_check_vorbis_layout(avctx, mapping_family);
227  /* Channels do not need to be reordered. */
228  }
229 
230  break;
231  case 0:
232  ret = libopus_check_max_channels(avctx, 2);
233  if (ret == 0) {
234  ret = libopus_check_vorbis_layout(avctx, mapping_family);
235  }
236  break;
237  case 1:
238  /* Opus expects channels to be in Vorbis order. */
239  ret = libopus_check_max_channels(avctx, 8);
240  if (ret == 0) {
241  ret = libopus_check_vorbis_layout(avctx, mapping_family);
243  }
244  break;
245  case 255:
246  ret = libopus_check_max_channels(avctx, 254);
247  break;
248  default:
249  av_log(avctx, AV_LOG_WARNING,
250  "Unknown channel mapping family %d. Output channel layout may be invalid.\n",
251  mapping_family);
252  ret = 0;
253  }
254 
255  *channel_map_result = channel_map;
256  return ret;
257 }
258 
260 {
261  LibopusEncContext *opus = avctx->priv_data;
262  OpusMSEncoder *enc;
263  uint8_t libopus_channel_mapping[255];
264  int ret = OPUS_OK;
265  int channels = avctx->ch_layout.nb_channels;
266  int av_ret;
267  int coupled_stream_count, header_size, frame_size;
268  int mapping_family;
269 
270  frame_size = opus->opts.frame_duration * 48000 / 1000;
271  switch (frame_size) {
272  case 120:
273  case 240:
274  if (opus->opts.application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
275  av_log(avctx, AV_LOG_WARNING,
276  "LPC mode cannot be used with a frame duration of less "
277  "than 10ms. Enabling restricted low-delay mode.\n"
278  "Use a longer frame duration if this is not what you want.\n");
279  /* Frame sizes less than 10 ms can only use MDCT mode, so switching to
280  * RESTRICTED_LOWDELAY avoids an unnecessary extra 2.5ms lookahead. */
281  opus->opts.application = OPUS_APPLICATION_RESTRICTED_LOWDELAY;
282  case 480:
283  case 960:
284  case 1920:
285  case 2880:
286 #ifdef OPUS_FRAMESIZE_120_MS
287  case 3840:
288  case 4800:
289  case 5760:
290 #endif
291  opus->opts.packet_size =
292  avctx->frame_size = frame_size * avctx->sample_rate / 48000;
293  break;
294  default:
295  av_log(avctx, AV_LOG_ERROR, "Invalid frame duration: %g.\n"
296  "Frame duration must be exactly one of: 2.5, 5, 10, 20, 40"
297 #ifdef OPUS_FRAMESIZE_120_MS
298  ", 60, 80, 100 or 120.\n",
299 #else
300  " or 60.\n",
301 #endif
302  opus->opts.frame_duration);
303  return AVERROR(EINVAL);
304  }
305 
306  if (avctx->compression_level < 0 || avctx->compression_level > 10) {
307  av_log(avctx, AV_LOG_WARNING,
308  "Compression level must be in the range 0 to 10. "
309  "Defaulting to 10.\n");
310  opus->opts.complexity = 10;
311  } else {
312  opus->opts.complexity = avctx->compression_level;
313  }
314 
315  if (avctx->cutoff) {
316  switch (avctx->cutoff) {
317  case 4000:
319  break;
320  case 6000:
322  break;
323  case 8000:
325  break;
326  case 12000:
328  break;
329  case 20000:
331  break;
332  default:
333  av_log(avctx, AV_LOG_WARNING,
334  "Invalid frequency cutoff: %d. Using default maximum bandwidth.\n"
335  "Cutoff frequency must be exactly one of: 4000, 6000, 8000, 12000 or 20000.\n",
336  avctx->cutoff);
337  avctx->cutoff = 0;
338  }
339  }
340 
341  /* Channels may need to be reordered to match opus mapping. */
343  &opus->encoder_channel_map);
344  if (av_ret) {
345  return av_ret;
346  }
347 
348  if (opus->opts.mapping_family == -1) {
349  /* By default, use mapping family 1 for the header but use the older
350  * libopus multistream API to avoid surround masking. */
351 
352  /* Set the mapping family so that the value is correct in the header */
353  mapping_family = channels > 2 ? 1 : 0;
354  coupled_stream_count = opus_coupled_streams[channels - 1];
355  opus->stream_count = channels - coupled_stream_count;
356  memcpy(libopus_channel_mapping,
358  channels * sizeof(*libopus_channel_mapping));
359 
360  enc = opus_multistream_encoder_create(
361  avctx->sample_rate, channels, opus->stream_count,
362  coupled_stream_count,
364  opus->opts.application, &ret);
365  } else {
366  /* Use the newer multistream API. The encoder will set the channel
367  * mapping and coupled stream counts to its internal defaults and will
368  * use surround masking analysis to save bits. */
369  mapping_family = opus->opts.mapping_family;
370  enc = opus_multistream_surround_encoder_create(
371  avctx->sample_rate, channels, mapping_family,
372  &opus->stream_count, &coupled_stream_count, libopus_channel_mapping,
373  opus->opts.application, &ret);
374  }
375 
376  if (ret != OPUS_OK) {
377  av_log(avctx, AV_LOG_ERROR,
378  "Failed to create encoder: %s\n", opus_strerror(ret));
380  }
381 
382  if (!avctx->bit_rate) {
383  /* Sane default copied from opusenc */
384  avctx->bit_rate = 64000 * opus->stream_count +
385  32000 * coupled_stream_count;
386  av_log(avctx, AV_LOG_WARNING,
387  "No bit rate set. Defaulting to %"PRId64" bps.\n", avctx->bit_rate);
388  }
389 
390  if (avctx->bit_rate < 500 || avctx->bit_rate > 256000 * channels) {
391  av_log(avctx, AV_LOG_ERROR, "The bit rate %"PRId64" bps is unsupported. "
392  "Please choose a value between 500 and %d.\n", avctx->bit_rate,
393  256000 * channels);
394  ret = AVERROR(EINVAL);
395  goto fail;
396  }
397 
398  ret = libopus_configure_encoder(avctx, enc, &opus->opts);
399  if (ret != OPUS_OK) {
401  goto fail;
402  }
403 
404  /* Header includes channel mapping table if and only if mapping family is NOT 0 */
405  header_size = 19 + (mapping_family == 0 ? 0 : 2 + channels);
406  avctx->extradata = av_malloc(header_size + AV_INPUT_BUFFER_PADDING_SIZE);
407  if (!avctx->extradata) {
408  av_log(avctx, AV_LOG_ERROR, "Failed to allocate extradata.\n");
409  ret = AVERROR(ENOMEM);
410  goto fail;
411  }
412  avctx->extradata_size = header_size;
413 
416  if (!opus->samples) {
417  av_log(avctx, AV_LOG_ERROR, "Failed to allocate samples buffer.\n");
418  ret = AVERROR(ENOMEM);
419  goto fail;
420  }
421 
422  ret = opus_multistream_encoder_ctl(enc, OPUS_GET_LOOKAHEAD(&avctx->initial_padding));
423  if (ret != OPUS_OK)
424  av_log(avctx, AV_LOG_WARNING,
425  "Unable to get number of lookahead samples: %s\n",
426  opus_strerror(ret));
427 
428  libopus_write_header(avctx, opus->stream_count, coupled_stream_count,
429  mapping_family, libopus_channel_mapping);
430 
431  ff_af_queue_init(avctx, &opus->afq);
432 
433  opus->enc = enc;
434 
435  return 0;
436 
437 fail:
438  opus_multistream_encoder_destroy(enc);
439  return ret;
440 }
441 
443  uint8_t *dst, const uint8_t *src, const uint8_t *channel_map,
444  int nb_channels, int nb_samples, int bytes_per_sample) {
445  int sample, channel;
446  for (sample = 0; sample < nb_samples; ++sample) {
447  for (channel = 0; channel < nb_channels; ++channel) {
448  const size_t src_pos = bytes_per_sample * (nb_channels * sample + channel);
449  const size_t dst_pos = bytes_per_sample * (nb_channels * sample + channel_map[channel]);
450 
451  memcpy(&dst[dst_pos], &src[src_pos], bytes_per_sample);
452  }
453  }
454 }
455 
456 static int libopus_encode(AVCodecContext *avctx, AVPacket *avpkt,
457  const AVFrame *frame, int *got_packet_ptr)
458 {
459  LibopusEncContext *opus = avctx->priv_data;
460  const int bytes_per_sample = av_get_bytes_per_sample(avctx->sample_fmt);
461  const int channels = avctx->ch_layout.nb_channels;
462  const int sample_size = channels * bytes_per_sample;
463  const uint8_t *audio;
464  int ret;
465  int discard_padding;
466 
467  if (frame) {
468  ret = ff_af_queue_add(&opus->afq, frame);
469  if (ret < 0)
470  return ret;
471  if (opus->encoder_channel_map != NULL) {
472  audio = opus->samples;
474  opus->samples, frame->data[0], opus->encoder_channel_map,
475  channels, frame->nb_samples, bytes_per_sample);
476  } else if (frame->nb_samples < opus->opts.packet_size) {
477  audio = opus->samples;
478  memcpy(opus->samples, frame->data[0], frame->nb_samples * sample_size);
479  } else
480  audio = frame->data[0];
481  } else {
482  if (!opus->afq.remaining_samples || (!opus->afq.frame_alloc && !opus->afq.frame_count))
483  return 0;
484  audio = opus->samples;
485  memset(opus->samples, 0, opus->opts.packet_size * sample_size);
486  }
487 
488  /* Maximum packet size taken from opusenc in opus-tools. 120ms packets
489  * consist of 6 frames in one packet. The maximum frame size is 1275
490  * bytes along with the largest possible packet header of 7 bytes. */
491  if ((ret = ff_alloc_packet(avctx, avpkt, (1275 * 6 + 7) * opus->stream_count)) < 0)
492  return ret;
493 
494  if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT)
495  ret = opus_multistream_encode_float(opus->enc, (const float *)audio,
496  opus->opts.packet_size,
497  avpkt->data, avpkt->size);
498  else
499  ret = opus_multistream_encode(opus->enc, (const opus_int16 *)audio,
500  opus->opts.packet_size,
501  avpkt->data, avpkt->size);
502 
503  if (ret < 0) {
504  av_log(avctx, AV_LOG_ERROR,
505  "Error encoding frame: %s\n", opus_strerror(ret));
507  }
508 
509  av_shrink_packet(avpkt, ret);
510 
511  ff_af_queue_remove(&opus->afq, opus->opts.packet_size,
512  &avpkt->pts, &avpkt->duration);
513 
514  discard_padding = opus->opts.packet_size - avpkt->duration;
515  // Check if subtraction resulted in an overflow
516  if ((discard_padding < opus->opts.packet_size) != (avpkt->duration > 0))
517  return AVERROR(EINVAL);
518  if (discard_padding > 0) {
519  uint8_t* side_data = av_packet_new_side_data(avpkt,
521  10);
522  if (!side_data)
523  return AVERROR(ENOMEM);
524  AV_WL32(side_data + 4, discard_padding);
525  }
526 
527  *got_packet_ptr = 1;
528 
529  return 0;
530 }
531 
533 {
534  LibopusEncContext *opus = avctx->priv_data;
535 
536  opus_multistream_encoder_destroy(opus->enc);
537 
538  ff_af_queue_close(&opus->afq);
539 
540  av_freep(&opus->samples);
541 
542  return 0;
543 }
544 
545 #define OFFSET(x) offsetof(LibopusEncContext, opts.x)
546 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
547 static const AVOption libopus_options[] = {
548  { "application", "Intended application type", OFFSET(application), AV_OPT_TYPE_INT, { .i64 = OPUS_APPLICATION_AUDIO }, OPUS_APPLICATION_VOIP, OPUS_APPLICATION_RESTRICTED_LOWDELAY, FLAGS, .unit = "application" },
549  { "voip", "Favor improved speech intelligibility", 0, AV_OPT_TYPE_CONST, { .i64 = OPUS_APPLICATION_VOIP }, 0, 0, FLAGS, .unit = "application" },
550  { "audio", "Favor faithfulness to the input", 0, AV_OPT_TYPE_CONST, { .i64 = OPUS_APPLICATION_AUDIO }, 0, 0, FLAGS, .unit = "application" },
551  { "lowdelay", "Restrict to only the lowest delay modes, disable voice-optimized modes", 0, AV_OPT_TYPE_CONST, { .i64 = OPUS_APPLICATION_RESTRICTED_LOWDELAY }, 0, 0, FLAGS, .unit = "application" },
552  { "frame_duration", "Duration of a frame in milliseconds", OFFSET(frame_duration), AV_OPT_TYPE_FLOAT, { .dbl = 20.0 }, 2.5, 120.0, FLAGS },
553  { "packet_loss", "Expected packet loss percentage", OFFSET(packet_loss), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, FLAGS },
554  { "fec", "Enable inband FEC. Expected packet loss must be non-zero", OFFSET(fec), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
555  { "vbr", "Variable bit rate mode", OFFSET(vbr), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 2, FLAGS, .unit = "vbr" },
556  { "off", "Use constant bit rate", 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, FLAGS, .unit = "vbr" },
557  { "on", "Use variable bit rate", 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, 0, 0, FLAGS, .unit = "vbr" },
558  { "constrained", "Use constrained VBR", 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, 0, 0, FLAGS, .unit = "vbr" },
559  { "mapping_family", "Channel Mapping Family", OFFSET(mapping_family), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 255, FLAGS, .unit = "mapping_family" },
560 #ifdef OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST
561  { "apply_phase_inv", "Apply intensity stereo phase inversion", OFFSET(apply_phase_inv), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
562 #endif
563  { NULL },
564 };
565 
566 static const AVClass libopus_class = {
567  .class_name = "libopus",
568  .item_name = av_default_item_name,
569  .option = libopus_options,
570  .version = LIBAVUTIL_VERSION_INT,
571 };
572 
574  { "b", "0" },
575  { "compression_level", "10" },
576  { NULL },
577 };
578 
579 static const int libopus_sample_rates[] = {
580  48000, 24000, 16000, 12000, 8000, 0,
581 };
582 
584  .p.name = "libopus",
585  CODEC_LONG_NAME("libopus Opus"),
586  .p.type = AVMEDIA_TYPE_AUDIO,
587  .p.id = AV_CODEC_ID_OPUS,
588  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
590  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE,
591  .priv_data_size = sizeof(LibopusEncContext),
594  .close = libopus_encode_close,
595  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
598  .p.supported_samplerates = libopus_sample_rates,
599  .p.priv_class = &libopus_class,
600  .defaults = libopus_defaults,
601  .p.wrapper_name = "libopus",
602 };
ff_libopus_encoder
const FFCodec ff_libopus_encoder
Definition: libopusenc.c:583
libopus_class
static const AVClass libopus_class
Definition: libopusenc.c:566
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1077
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
libopus.h
LibopusEncOpts::application
int application
Definition: libopusenc.c:38
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
libopus_encode
static int libopus_encode(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: libopusenc.c:456
LibopusEncContext::opts
LibopusEncOpts opts
Definition: libopusenc.c:56
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
ff_af_queue_remove
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
Definition: audio_frame_queue.c:75
OPUS_BANDWIDTH_NARROWBAND
@ OPUS_BANDWIDTH_NARROWBAND
Definition: opus.h:50
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
ff_af_queue_close
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
Definition: audio_frame_queue.c:36
ff_af_queue_init
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
Definition: audio_frame_queue.c:28
LibopusEncContext::enc
OpusMSEncoder * enc
Definition: libopusenc.c:53
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
LibopusEncOpts::complexity
int complexity
Definition: libopusenc.c:41
AVPacket::data
uint8_t * data
Definition: packet.h:524
AVOption
AVOption.
Definition: opt.h:357
LibopusEncOpts::packet_size
int packet_size
Definition: libopusenc.c:43
encode.h
opus.h
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:34
FFCodec
Definition: codec_internal.h:126
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:542
OPUS_BANDWIDTH_FULLBAND
@ OPUS_BANDWIDTH_FULLBAND
Definition: opus.h:54
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:308
LibopusEncOpts::frame_duration
float frame_duration
Definition: libopusenc.c:42
opus_vorbis_channel_map
static const uint8_t opus_vorbis_channel_map[8][8]
Definition: libopusenc.c:66
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
vorbis_data.h
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
libopus_encode_init
static av_cold int libopus_encode_init(AVCodecContext *avctx)
Definition: libopusenc.c:259
FFCodecDefault
Definition: codec_internal.h:96
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
fail
#define fail()
Definition: checkasm.h:183
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: packet.c:113
audio_frame_queue.h
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1122
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:295
ff_af_queue_add
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
Definition: audio_frame_queue.c:44
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:644
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
libopus_encode_close
static av_cold int libopus_encode_close(AVCodecContext *avctx)
Definition: libopusenc.c:532
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1239
frame_size
int frame_size
Definition: mxfenc.c:2423
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:112
AudioFrameQueue::remaining_samples
int remaining_samples
Definition: audio_frame_queue.h:35
libopus_write_header
static void libopus_write_header(AVCodecContext *avctx, int stream_count, int coupled_stream_count, int mapping_family, const uint8_t *channel_mapping)
Definition: libopusenc.c:89
AudioFrameQueue
Definition: audio_frame_queue.h:32
channels
channels
Definition: aptx.h:31
channel_map
static const uint8_t channel_map[8][8]
Definition: atrac3plusdec.c:52
ff_opus_error_to_averror
int ff_opus_error_to_averror(int err)
Definition: libopus.c:27
FLAGS
#define FLAGS
Definition: libopusenc.c:546
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
LibopusEncOpts::fec
int fec
Definition: libopusenc.c:40
OPUS_BANDWIDTH_WIDEBAND
@ OPUS_BANDWIDTH_WIDEBAND
Definition: opus.h:52
LibopusEncOpts::mapping_family
int mapping_family
Definition: libopusenc.c:45
opts
AVDictionary * opts
Definition: movenc.c:51
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
LibopusEncContext
Definition: libopusenc.c:51
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
libopus_configure_encoder
static int libopus_configure_encoder(AVCodecContext *avctx, OpusMSEncoder *enc, LibopusEncOpts *opts)
Definition: libopusenc.c:113
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:495
LibopusEncContext::samples
uint8_t * samples
Definition: libopusenc.c:55
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
libopus_options
static const AVOption libopus_options[]
Definition: libopusenc.c:547
OPUS_BANDWIDTH_SUPERWIDEBAND
@ OPUS_BANDWIDTH_SUPERWIDEBAND
Definition: opus.h:53
LibopusEncContext::afq
AudioFrameQueue afq
Definition: libopusenc.c:57
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:525
codec_internal.h
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1057
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
sample
#define sample
Definition: flacdsp_template.c:44
LibopusEncOpts
Definition: libopusenc.c:36
AV_CODEC_ID_OPUS
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:500
LibopusEncContext::encoder_channel_map
const uint8_t * encoder_channel_map
Definition: libopusenc.c:58
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:800
OFFSET
#define OFFSET(x)
Definition: libopusenc.c:545
ff_vorbis_channel_layout_offsets
const uint8_t ff_vorbis_channel_layout_offsets[8][8]
Definition: vorbis_data.c:26
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:248
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
bytestream_put_buffer
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:372
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:517
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:108
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
AVCodecContext::cutoff
int cutoff
Audio cutoff bandwidth (0 means "automatic")
Definition: avcodec.h:1090
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
avcodec.h
AudioFrameQueue::frame_count
unsigned frame_count
Definition: audio_frame_queue.h:37
libopus_check_max_channels
static int libopus_check_max_channels(AVCodecContext *avctx, int max_channels)
Definition: libopusenc.c:182
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
LibopusEncContext::stream_count
int stream_count
Definition: libopusenc.c:54
libopus_defaults
static const FFCodecDefault libopus_defaults[]
Definition: libopusenc.c:573
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
libopus_check_vorbis_layout
static int libopus_check_vorbis_layout(AVCodecContext *avctx, int mapping_family)
Definition: libopusenc.c:193
AVCodecContext
main external API structure.
Definition: avcodec.h:445
LibopusEncOpts::vbr
int vbr
Definition: libopusenc.c:37
AudioFrameQueue::frame_alloc
unsigned frame_alloc
Definition: audio_frame_queue.h:38
channel_layout.h
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
Definition: packet.c:231
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:157
AV_CODEC_CAP_DELAY
#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: codec.h:76
mem.h
ff_vorbis_ch_layouts
const AVChannelLayout ff_vorbis_ch_layouts[9]
Definition: vorbis_data.c:37
OPUS_BANDWIDTH_MEDIUMBAND
@ OPUS_BANDWIDTH_MEDIUMBAND
Definition: opus.h:51
AVPacket
This structure stores compressed data.
Definition: packet.h:501
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
LibopusEncOpts::packet_loss
int packet_loss
Definition: libopusenc.c:39
bytestream.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
LibopusEncOpts::max_bandwidth
int max_bandwidth
Definition: libopusenc.c:44
AV_CODEC_CAP_SMALL_LAST_FRAME
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:81
libopus_validate_layout_and_get_channel_map
static int libopus_validate_layout_and_get_channel_map(AVCodecContext *avctx, int mapping_family, const uint8_t **channel_map_result)
Definition: libopusenc.c:214
libavcodec_libopus_channel_map
static const uint8_t libavcodec_libopus_channel_map[8][8]
Definition: libopusenc.c:78
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:62
libopus_copy_samples_with_channel_map
static void libopus_copy_samples_with_channel_map(uint8_t *dst, const uint8_t *src, const uint8_t *channel_map, int nb_channels, int nb_samples, int bytes_per_sample)
Definition: libopusenc.c:442
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60
channel
channel
Definition: ebur128.h:39
opus_coupled_streams
static const uint8_t opus_coupled_streams[8]
Definition: libopusenc.c:61
AVCodecContext::compression_level
int compression_level
Definition: avcodec.h:1245
libopus_sample_rates
static const int libopus_sample_rates[]
Definition: libopusenc.c:579