2 * Opus encoder using libopus
3 * Copyright (c) 2012 Nathan Caldwell
5 * This file is part of FFmpeg.
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.
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.
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
23 #include <opus_multistream.h>
25 #include "libavutil/opt.h"
27 #include "bytestream.h"
31 #include "audio_frame_queue.h"
33 typedef struct LibopusEncOpts
{
43 typedef struct LibopusEncContext
{
52 static const uint8_t opus_coupled_streams
[8] = {
53 0, 1, 1, 2, 2, 2, 2, 3
56 /* Opus internal to Vorbis channel order mapping written in the header */
57 static const uint8_t opus_vorbis_channel_map
[8][8] = {
64 { 0, 4, 1, 2, 3, 5, 6 },
65 { 0, 6, 1, 2, 3, 4, 5, 7 },
68 /* libavcodec to libopus channel order mapping, passed to libopus */
69 static const uint8_t libavcodec_libopus_channel_map
[8][8] = {
76 { 0, 1, 5, 6, 2, 4, 3 },
77 { 0, 1, 6, 7, 4, 5, 2, 3 },
80 static void libopus_write_header(AVCodecContext
*avctx
, int stream_count
,
81 int coupled_stream_count
,
82 const uint8_t *channel_mapping
)
84 uint8_t *p
= avctx
->extradata
;
85 int channels
= avctx
->channels
;
87 bytestream_put_buffer(&p
, "OpusHead", 8);
88 bytestream_put_byte(&p
, 1); /* Version */
89 bytestream_put_byte(&p
, channels
);
90 bytestream_put_le16(&p
, avctx
->initial_padding
); /* Lookahead samples at 48kHz */
91 bytestream_put_le32(&p
, avctx
->sample_rate
); /* Original sample rate */
92 bytestream_put_le16(&p
, 0); /* Gain of 0dB is recommended. */
96 bytestream_put_byte(&p
, channels
<= 8 ? 1 : 255);
97 bytestream_put_byte(&p
, stream_count
);
98 bytestream_put_byte(&p
, coupled_stream_count
);
99 bytestream_put_buffer(&p
, channel_mapping
, channels
);
101 bytestream_put_byte(&p
, 0);
105 static int libopus_configure_encoder(AVCodecContext
*avctx
, OpusMSEncoder
*enc
,
106 LibopusEncOpts
*opts
)
110 if (avctx
->global_quality
) {
111 av_log(avctx
, AV_LOG_ERROR
,
112 "Quality-based encoding not supported, "
113 "please specify a bitrate and VBR setting.\n");
114 return AVERROR(EINVAL
);
117 ret
= opus_multistream_encoder_ctl(enc
, OPUS_SET_BITRATE(avctx
->bit_rate
));
118 if (ret
!= OPUS_OK
) {
119 av_log(avctx
, AV_LOG_ERROR
,
120 "Failed to set bitrate: %s\n", opus_strerror(ret
));
124 ret
= opus_multistream_encoder_ctl(enc
,
125 OPUS_SET_COMPLEXITY(opts
->complexity
));
127 av_log(avctx
, AV_LOG_WARNING
,
128 "Unable to set complexity: %s\n", opus_strerror(ret
));
130 ret
= opus_multistream_encoder_ctl(enc
, OPUS_SET_VBR(!!opts
->vbr
));
132 av_log(avctx
, AV_LOG_WARNING
,
133 "Unable to set VBR: %s\n", opus_strerror(ret
));
135 ret
= opus_multistream_encoder_ctl(enc
,
136 OPUS_SET_VBR_CONSTRAINT(opts
->vbr
== 2));
138 av_log(avctx
, AV_LOG_WARNING
,
139 "Unable to set constrained VBR: %s\n", opus_strerror(ret
));
141 ret
= opus_multistream_encoder_ctl(enc
,
142 OPUS_SET_PACKET_LOSS_PERC(opts
->packet_loss
));
144 av_log(avctx
, AV_LOG_WARNING
,
145 "Unable to set expected packet loss percentage: %s\n",
149 ret
= opus_multistream_encoder_ctl(enc
,
150 OPUS_SET_MAX_BANDWIDTH(opts
->max_bandwidth
));
152 av_log(avctx
, AV_LOG_WARNING
,
153 "Unable to set maximum bandwidth: %s\n", opus_strerror(ret
));
159 static av_cold
int libopus_encode_init(AVCodecContext
*avctx
)
161 LibopusEncContext
*opus
= avctx
->priv_data
;
162 const uint8_t *channel_mapping
;
165 int coupled_stream_count
, header_size
, frame_size
;
167 coupled_stream_count
= opus_coupled_streams
[avctx
->channels
- 1];
168 opus
->stream_count
= avctx
->channels
- coupled_stream_count
;
169 channel_mapping
= libavcodec_libopus_channel_map
[avctx
->channels
- 1];
171 /* FIXME: Opus can handle up to 255 channels. However, the mapping for
172 * anything greater than 8 is undefined. */
173 if (avctx
->channels
> 8) {
174 av_log(avctx
, AV_LOG_ERROR
,
175 "Channel layout undefined for %d channels.\n", avctx
->channels
);
176 return AVERROR_PATCHWELCOME
;
178 if (!avctx
->bit_rate
) {
179 /* Sane default copied from opusenc */
180 avctx
->bit_rate
= 64000 * opus
->stream_count
+
181 32000 * coupled_stream_count
;
182 av_log(avctx
, AV_LOG_WARNING
,
183 "No bit rate set. Defaulting to %d bps.\n", avctx
->bit_rate
);
186 if (avctx
->bit_rate
< 500 || avctx
->bit_rate
> 256000 * avctx
->channels
) {
187 av_log(avctx
, AV_LOG_ERROR
, "The bit rate %d bps is unsupported. "
188 "Please choose a value between 500 and %d.\n", avctx
->bit_rate
,
189 256000 * avctx
->channels
);
190 return AVERROR(EINVAL
);
193 frame_size
= opus
->opts
.frame_duration
* 48000 / 1000;
194 switch (frame_size
) {
197 if (opus
->opts
.application
!= OPUS_APPLICATION_RESTRICTED_LOWDELAY
)
198 av_log(avctx
, AV_LOG_WARNING
,
199 "LPC mode cannot be used with a frame duration of less "
200 "than 10ms. Enabling restricted low-delay mode.\n"
201 "Use a longer frame duration if this is not what you want.\n");
202 /* Frame sizes less than 10 ms can only use MDCT mode, so switching to
203 * RESTRICTED_LOWDELAY avoids an unnecessary extra 2.5ms lookahead. */
204 opus
->opts
.application
= OPUS_APPLICATION_RESTRICTED_LOWDELAY
;
209 opus
->opts
.packet_size
=
210 avctx
->frame_size
= frame_size
* avctx
->sample_rate
/ 48000;
213 av_log(avctx
, AV_LOG_ERROR
, "Invalid frame duration: %g.\n"
214 "Frame duration must be exactly one of: 2.5, 5, 10, 20, 40 or 60.\n",
215 opus
->opts
.frame_duration
);
216 return AVERROR(EINVAL
);
219 if (avctx
->compression_level
< 0 || avctx
->compression_level
> 10) {
220 av_log(avctx
, AV_LOG_WARNING
,
221 "Compression level must be in the range 0 to 10. "
222 "Defaulting to 10.\n");
223 opus
->opts
.complexity
= 10;
225 opus
->opts
.complexity
= avctx
->compression_level
;
229 switch (avctx
->cutoff
) {
231 opus
->opts
.max_bandwidth
= OPUS_BANDWIDTH_NARROWBAND
;
234 opus
->opts
.max_bandwidth
= OPUS_BANDWIDTH_MEDIUMBAND
;
237 opus
->opts
.max_bandwidth
= OPUS_BANDWIDTH_WIDEBAND
;
240 opus
->opts
.max_bandwidth
= OPUS_BANDWIDTH_SUPERWIDEBAND
;
243 opus
->opts
.max_bandwidth
= OPUS_BANDWIDTH_FULLBAND
;
246 av_log(avctx
, AV_LOG_WARNING
,
247 "Invalid frequency cutoff: %d. Using default maximum bandwidth.\n"
248 "Cutoff frequency must be exactly one of: 4000, 6000, 8000, 12000 or 20000.\n",
254 enc
= opus_multistream_encoder_create(avctx
->sample_rate
, avctx
->channels
,
256 coupled_stream_count
,
258 opus
->opts
.application
, &ret
);
259 if (ret
!= OPUS_OK
) {
260 av_log(avctx
, AV_LOG_ERROR
,
261 "Failed to create encoder: %s\n", opus_strerror(ret
));
262 return ff_opus_error_to_averror(ret
);
265 ret
= libopus_configure_encoder(avctx
, enc
, &opus
->opts
);
266 if (ret
!= OPUS_OK
) {
267 ret
= ff_opus_error_to_averror(ret
);
271 header_size
= 19 + (avctx
->channels
> 2 ? 2 + avctx
->channels
: 0);
272 avctx
->extradata
= av_malloc(header_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
273 if (!avctx
->extradata
) {
274 av_log(avctx
, AV_LOG_ERROR
, "Failed to allocate extradata.\n");
275 ret
= AVERROR(ENOMEM
);
278 avctx
->extradata_size
= header_size
;
280 opus
->samples
= av_mallocz(frame_size
* avctx
->channels
*
281 av_get_bytes_per_sample(avctx
->sample_fmt
));
282 if (!opus
->samples
) {
283 av_log(avctx
, AV_LOG_ERROR
, "Failed to allocate samples buffer.\n");
284 ret
= AVERROR(ENOMEM
);
288 ret
= opus_multistream_encoder_ctl(enc
, OPUS_GET_LOOKAHEAD(&avctx
->initial_padding
));
290 av_log(avctx
, AV_LOG_WARNING
,
291 "Unable to get number of lookahead samples: %s\n",
294 libopus_write_header(avctx
, opus
->stream_count
, coupled_stream_count
,
295 opus_vorbis_channel_map
[avctx
->channels
- 1]);
297 ff_af_queue_init(avctx
, &opus
->afq
);
304 opus_multistream_encoder_destroy(enc
);
305 av_freep(&avctx
->extradata
);
309 static int libopus_encode(AVCodecContext
*avctx
, AVPacket
*avpkt
,
310 const AVFrame
*frame
, int *got_packet_ptr
)
312 LibopusEncContext
*opus
= avctx
->priv_data
;
313 const int sample_size
= avctx
->channels
*
314 av_get_bytes_per_sample(avctx
->sample_fmt
);
320 ret
= ff_af_queue_add(&opus
->afq
, frame
);
323 if (frame
->nb_samples
< opus
->opts
.packet_size
) {
324 audio
= opus
->samples
;
325 memcpy(audio
, frame
->data
[0], frame
->nb_samples
* sample_size
);
327 audio
= frame
->data
[0];
329 if (!opus
->afq
.remaining_samples
)
331 audio
= opus
->samples
;
332 memset(audio
, 0, opus
->opts
.packet_size
* sample_size
);
335 /* Maximum packet size taken from opusenc in opus-tools. 60ms packets
336 * consist of 3 frames in one packet. The maximum frame size is 1275
337 * bytes along with the largest possible packet header of 7 bytes. */
338 if ((ret
= ff_alloc_packet2(avctx
, avpkt
, (1275 * 3 + 7) * opus
->stream_count
)) < 0)
341 if (avctx
->sample_fmt
== AV_SAMPLE_FMT_FLT
)
342 ret
= opus_multistream_encode_float(opus
->enc
, (float *)audio
,
343 opus
->opts
.packet_size
,
344 avpkt
->data
, avpkt
->size
);
346 ret
= opus_multistream_encode(opus
->enc
, (opus_int16
*)audio
,
347 opus
->opts
.packet_size
,
348 avpkt
->data
, avpkt
->size
);
351 av_log(avctx
, AV_LOG_ERROR
,
352 "Error encoding frame: %s\n", opus_strerror(ret
));
353 return ff_opus_error_to_averror(ret
);
356 av_shrink_packet(avpkt
, ret
);
358 ff_af_queue_remove(&opus
->afq
, opus
->opts
.packet_size
,
359 &avpkt
->pts
, &avpkt
->duration
);
361 discard_padding
= opus
->opts
.packet_size
- avpkt
->duration
;
362 // Check if subtraction resulted in an overflow
363 if ((discard_padding
< opus
->opts
.packet_size
) != (avpkt
->duration
> 0)) {
364 av_free_packet(avpkt
);
366 return AVERROR(EINVAL
);
368 if (discard_padding
> 0) {
369 uint8_t* side_data
= av_packet_new_side_data(avpkt
,
370 AV_PKT_DATA_SKIP_SAMPLES
,
373 av_free_packet(avpkt
);
375 return AVERROR(ENOMEM
);
377 AV_WL32(side_data
+ 4, discard_padding
);
385 static av_cold
int libopus_encode_close(AVCodecContext
*avctx
)
387 LibopusEncContext
*opus
= avctx
->priv_data
;
389 opus_multistream_encoder_destroy(opus
->enc
);
391 ff_af_queue_close(&opus
->afq
);
393 av_freep(&opus
->samples
);
394 av_freep(&avctx
->extradata
);
399 #define OFFSET(x) offsetof(LibopusEncContext, opts.x)
400 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
401 static const AVOption libopus_options
[] = {
402 { "application", "Intended application type", OFFSET(application
), AV_OPT_TYPE_INT
, { .i64
= OPUS_APPLICATION_AUDIO
}, OPUS_APPLICATION_VOIP
, OPUS_APPLICATION_RESTRICTED_LOWDELAY
, FLAGS
, "application" },
403 { "voip", "Favor improved speech intelligibility", 0, AV_OPT_TYPE_CONST
, { .i64
= OPUS_APPLICATION_VOIP
}, 0, 0, FLAGS
, "application" },
404 { "audio", "Favor faithfulness to the input", 0, AV_OPT_TYPE_CONST
, { .i64
= OPUS_APPLICATION_AUDIO
}, 0, 0, FLAGS
, "application" },
405 { "lowdelay", "Restrict to only the lowest delay modes", 0, AV_OPT_TYPE_CONST
, { .i64
= OPUS_APPLICATION_RESTRICTED_LOWDELAY
}, 0, 0, FLAGS
, "application" },
406 { "frame_duration", "Duration of a frame in milliseconds", OFFSET(frame_duration
), AV_OPT_TYPE_FLOAT
, { .dbl
= 20.0 }, 2.5, 60.0, FLAGS
},
407 { "packet_loss", "Expected packet loss percentage", OFFSET(packet_loss
), AV_OPT_TYPE_INT
, { .i64
= 0 }, 0, 100, FLAGS
},
408 { "vbr", "Variable bit rate mode", OFFSET(vbr
), AV_OPT_TYPE_INT
, { .i64
= 1 }, 0, 2, FLAGS
, "vbr" },
409 { "off", "Use constant bit rate", 0, AV_OPT_TYPE_CONST
, { .i64
= 0 }, 0, 0, FLAGS
, "vbr" },
410 { "on", "Use variable bit rate", 0, AV_OPT_TYPE_CONST
, { .i64
= 1 }, 0, 0, FLAGS
, "vbr" },
411 { "constrained", "Use constrained VBR", 0, AV_OPT_TYPE_CONST
, { .i64
= 2 }, 0, 0, FLAGS
, "vbr" },
415 static const AVClass libopus_class
= {
416 .class_name
= "libopus",
417 .item_name
= av_default_item_name
,
418 .option
= libopus_options
,
419 .version
= LIBAVUTIL_VERSION_INT
,
422 static const AVCodecDefault libopus_defaults
[] = {
424 { "compression_level", "10" },
428 static const int libopus_sample_rates
[] = {
429 48000, 24000, 16000, 12000, 8000, 0,
432 AVCodec ff_libopus_encoder
= {
434 .long_name
= NULL_IF_CONFIG_SMALL("libopus Opus"),
435 .type
= AVMEDIA_TYPE_AUDIO
,
436 .id
= AV_CODEC_ID_OPUS
,
437 .priv_data_size
= sizeof(LibopusEncContext
),
438 .init
= libopus_encode_init
,
439 .encode2
= libopus_encode
,
440 .close
= libopus_encode_close
,
441 .capabilities
= CODEC_CAP_DELAY
| CODEC_CAP_SMALL_LAST_FRAME
,
442 .sample_fmts
= (const enum AVSampleFormat
[]){ AV_SAMPLE_FMT_S16
,
444 AV_SAMPLE_FMT_NONE
},
445 .channel_layouts
= ff_vorbis_channel_layouts
,
446 .supported_samplerates
= libopus_sample_rates
,
447 .priv_class
= &libopus_class
,
448 .defaults
= libopus_defaults
,