2 * Copyright (c) 2002 Mark Hills <mark@pogo.org.uk>
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 #include <vorbis/vorbisenc.h>
23 #include "libavutil/avassert.h"
24 #include "libavutil/fifo.h"
25 #include "libavutil/opt.h"
27 #include "audio_frame_queue.h"
30 #include "vorbis_parser.h"
33 /* Number of samples the user should send in each call.
34 * This value is used because it is the LCD of all possible frame sizes, so
35 * an output packet will always start at the same point as one of the input
38 #define LIBVORBIS_FRAME_SIZE 64
40 #define BUFFER_SIZE (1024 * 64)
42 typedef struct LibvorbisEncContext
{
43 AVClass
*av_class
; /**< class for AVOptions */
44 vorbis_info vi
; /**< vorbis_info used during init */
45 vorbis_dsp_state vd
; /**< DSP state used for analysis */
46 vorbis_block vb
; /**< vorbis_block used for analysis */
47 AVFifoBuffer
*pkt_fifo
; /**< output packet buffer */
48 int eof
; /**< end-of-file flag */
49 int dsp_initialized
; /**< vd has been initialized */
50 vorbis_comment vc
; /**< VorbisComment info */
51 double iblock
; /**< impulse block bias option */
52 AVVorbisParseContext
*vp
; /**< parse context to get durations */
53 AudioFrameQueue afq
; /**< frame queue for timestamps */
54 } LibvorbisEncContext
;
56 static const AVOption options
[] = {
57 { "iblock", "Sets the impulse block bias", offsetof(LibvorbisEncContext
, iblock
), AV_OPT_TYPE_DOUBLE
, { .dbl
= 0 }, -15, 0, AV_OPT_FLAG_AUDIO_PARAM
| AV_OPT_FLAG_ENCODING_PARAM
},
61 static const AVCodecDefault defaults
[] = {
66 static const AVClass vorbis_class
= {
67 .class_name
= "libvorbis",
68 .item_name
= av_default_item_name
,
70 .version
= LIBAVUTIL_VERSION_INT
,
73 static int vorbis_error_to_averror(int ov_err
)
76 case OV_EFAULT
: return AVERROR_BUG
;
77 case OV_EINVAL
: return AVERROR(EINVAL
);
78 case OV_EIMPL
: return AVERROR(EINVAL
);
79 default: return AVERROR_UNKNOWN
;
83 static av_cold
int libvorbis_setup(vorbis_info
*vi
, AVCodecContext
*avctx
)
85 LibvorbisEncContext
*s
= avctx
->priv_data
;
89 if (avctx
->flags
& CODEC_FLAG_QSCALE
|| !avctx
->bit_rate
) {
91 * NOTE: we use the oggenc range of -1 to 10 for global_quality for
92 * user convenience, but libvorbis uses -0.1 to 1.0.
94 float q
= avctx
->global_quality
/ (float)FF_QP2LAMBDA
;
95 /* default to 3 if the user did not set quality or bitrate */
96 if (!(avctx
->flags
& CODEC_FLAG_QSCALE
))
98 if ((ret
= vorbis_encode_setup_vbr(vi
, avctx
->channels
,
103 int minrate
= avctx
->rc_min_rate
> 0 ? avctx
->rc_min_rate
: -1;
104 int maxrate
= avctx
->rc_max_rate
> 0 ? avctx
->rc_max_rate
: -1;
106 /* average bitrate */
107 if ((ret
= vorbis_encode_setup_managed(vi
, avctx
->channels
,
108 avctx
->sample_rate
, maxrate
,
109 avctx
->bit_rate
, minrate
)))
112 /* variable bitrate by estimate, disable slow rate management */
113 if (minrate
== -1 && maxrate
== -1)
114 if ((ret
= vorbis_encode_ctl(vi
, OV_ECTL_RATEMANAGE2_SET
, NULL
)))
115 goto error
; /* should not happen */
118 /* cutoff frequency */
119 if (avctx
->cutoff
> 0) {
120 cfreq
= avctx
->cutoff
/ 1000.0;
121 if ((ret
= vorbis_encode_ctl(vi
, OV_ECTL_LOWPASS_SET
, &cfreq
)))
122 goto error
; /* should not happen */
125 /* impulse block bias */
127 if ((ret
= vorbis_encode_ctl(vi
, OV_ECTL_IBLOCK_SET
, &s
->iblock
)))
131 if (avctx
->channels
== 3 &&
132 avctx
->channel_layout
!= (AV_CH_LAYOUT_STEREO
|AV_CH_FRONT_CENTER
) ||
133 avctx
->channels
== 4 &&
134 avctx
->channel_layout
!= AV_CH_LAYOUT_2_2
&&
135 avctx
->channel_layout
!= AV_CH_LAYOUT_QUAD
||
136 avctx
->channels
== 5 &&
137 avctx
->channel_layout
!= AV_CH_LAYOUT_5POINT0
&&
138 avctx
->channel_layout
!= AV_CH_LAYOUT_5POINT0_BACK
||
139 avctx
->channels
== 6 &&
140 avctx
->channel_layout
!= AV_CH_LAYOUT_5POINT1
&&
141 avctx
->channel_layout
!= AV_CH_LAYOUT_5POINT1_BACK
||
142 avctx
->channels
== 7 &&
143 avctx
->channel_layout
!= (AV_CH_LAYOUT_5POINT1
|AV_CH_BACK_CENTER
) ||
144 avctx
->channels
== 8 &&
145 avctx
->channel_layout
!= AV_CH_LAYOUT_7POINT1
) {
146 if (avctx
->channel_layout
) {
148 av_get_channel_layout_string(name
, sizeof(name
), avctx
->channels
,
149 avctx
->channel_layout
);
150 av_log(avctx
, AV_LOG_ERROR
, "%s not supported by Vorbis: "
151 "output stream will have incorrect "
152 "channel layout.\n", name
);
154 av_log(avctx
, AV_LOG_WARNING
, "No channel layout specified. The encoder "
155 "will use Vorbis channel layout for "
156 "%d channels.\n", avctx
->channels
);
160 if ((ret
= vorbis_encode_setup_init(vi
)))
165 return vorbis_error_to_averror(ret
);
168 /* How many bytes are needed for a buffer of length 'l' */
169 static int xiph_len(int l
)
171 return 1 + l
/ 255 + l
;
174 static av_cold
int libvorbis_encode_close(AVCodecContext
*avctx
)
176 LibvorbisEncContext
*s
= avctx
->priv_data
;
178 /* notify vorbisenc this is EOF */
179 if (s
->dsp_initialized
)
180 vorbis_analysis_wrote(&s
->vd
, 0);
182 vorbis_block_clear(&s
->vb
);
183 vorbis_dsp_clear(&s
->vd
);
184 vorbis_info_clear(&s
->vi
);
186 av_fifo_freep(&s
->pkt_fifo
);
187 ff_af_queue_close(&s
->afq
);
188 av_freep(&avctx
->extradata
);
190 av_vorbis_parse_free(&s
->vp
);
195 static av_cold
int libvorbis_encode_init(AVCodecContext
*avctx
)
197 LibvorbisEncContext
*s
= avctx
->priv_data
;
198 ogg_packet header
, header_comm
, header_code
;
203 vorbis_info_init(&s
->vi
);
204 if ((ret
= libvorbis_setup(&s
->vi
, avctx
))) {
205 av_log(avctx
, AV_LOG_ERROR
, "encoder setup failed\n");
208 if ((ret
= vorbis_analysis_init(&s
->vd
, &s
->vi
))) {
209 av_log(avctx
, AV_LOG_ERROR
, "analysis init failed\n");
210 ret
= vorbis_error_to_averror(ret
);
213 s
->dsp_initialized
= 1;
214 if ((ret
= vorbis_block_init(&s
->vd
, &s
->vb
))) {
215 av_log(avctx
, AV_LOG_ERROR
, "dsp init failed\n");
216 ret
= vorbis_error_to_averror(ret
);
220 vorbis_comment_init(&s
->vc
);
221 if (!(avctx
->flags
& CODEC_FLAG_BITEXACT
))
222 vorbis_comment_add_tag(&s
->vc
, "encoder", LIBAVCODEC_IDENT
);
224 if ((ret
= vorbis_analysis_headerout(&s
->vd
, &s
->vc
, &header
, &header_comm
,
226 ret
= vorbis_error_to_averror(ret
);
230 avctx
->extradata_size
= 1 + xiph_len(header
.bytes
) +
231 xiph_len(header_comm
.bytes
) +
233 p
= avctx
->extradata
= av_malloc(avctx
->extradata_size
+
234 FF_INPUT_BUFFER_PADDING_SIZE
);
236 ret
= AVERROR(ENOMEM
);
241 offset
+= av_xiphlacing(&p
[offset
], header
.bytes
);
242 offset
+= av_xiphlacing(&p
[offset
], header_comm
.bytes
);
243 memcpy(&p
[offset
], header
.packet
, header
.bytes
);
244 offset
+= header
.bytes
;
245 memcpy(&p
[offset
], header_comm
.packet
, header_comm
.bytes
);
246 offset
+= header_comm
.bytes
;
247 memcpy(&p
[offset
], header_code
.packet
, header_code
.bytes
);
248 offset
+= header_code
.bytes
;
249 av_assert0(offset
== avctx
->extradata_size
);
251 s
->vp
= av_vorbis_parse_init(avctx
->extradata
, avctx
->extradata_size
);
253 av_log(avctx
, AV_LOG_ERROR
, "invalid extradata\n");
257 vorbis_comment_clear(&s
->vc
);
259 avctx
->frame_size
= LIBVORBIS_FRAME_SIZE
;
260 ff_af_queue_init(avctx
, &s
->afq
);
262 s
->pkt_fifo
= av_fifo_alloc(BUFFER_SIZE
);
264 ret
= AVERROR(ENOMEM
);
270 libvorbis_encode_close(avctx
);
274 static int libvorbis_encode_frame(AVCodecContext
*avctx
, AVPacket
*avpkt
,
275 const AVFrame
*frame
, int *got_packet_ptr
)
277 LibvorbisEncContext
*s
= avctx
->priv_data
;
281 /* send samples to libvorbis */
283 const int samples
= frame
->nb_samples
;
285 int c
, channels
= s
->vi
.channels
;
287 buffer
= vorbis_analysis_buffer(&s
->vd
, samples
);
288 for (c
= 0; c
< channels
; c
++) {
289 int co
= (channels
> 8) ? c
:
290 ff_vorbis_encoding_channel_layout_offsets
[channels
- 1][c
];
291 memcpy(buffer
[c
], frame
->extended_data
[co
],
292 samples
* sizeof(*buffer
[c
]));
294 if ((ret
= vorbis_analysis_wrote(&s
->vd
, samples
)) < 0) {
295 av_log(avctx
, AV_LOG_ERROR
, "error in vorbis_analysis_wrote()\n");
296 return vorbis_error_to_averror(ret
);
298 if ((ret
= ff_af_queue_add(&s
->afq
, frame
)) < 0)
301 if (!s
->eof
&& s
->afq
.frame_alloc
)
302 if ((ret
= vorbis_analysis_wrote(&s
->vd
, 0)) < 0) {
303 av_log(avctx
, AV_LOG_ERROR
, "error in vorbis_analysis_wrote()\n");
304 return vorbis_error_to_averror(ret
);
309 /* retrieve available packets from libvorbis */
310 while ((ret
= vorbis_analysis_blockout(&s
->vd
, &s
->vb
)) == 1) {
311 if ((ret
= vorbis_analysis(&s
->vb
, NULL
)) < 0)
313 if ((ret
= vorbis_bitrate_addblock(&s
->vb
)) < 0)
316 /* add any available packets to the output packet buffer */
317 while ((ret
= vorbis_bitrate_flushpacket(&s
->vd
, &op
)) == 1) {
318 if (av_fifo_space(s
->pkt_fifo
) < sizeof(ogg_packet
) + op
.bytes
) {
319 av_log(avctx
, AV_LOG_ERROR
, "packet buffer is too small\n");
322 av_fifo_generic_write(s
->pkt_fifo
, &op
, sizeof(ogg_packet
), NULL
);
323 av_fifo_generic_write(s
->pkt_fifo
, op
.packet
, op
.bytes
, NULL
);
326 av_log(avctx
, AV_LOG_ERROR
, "error getting available packets\n");
331 av_log(avctx
, AV_LOG_ERROR
, "error getting available packets\n");
332 return vorbis_error_to_averror(ret
);
335 /* check for available packets */
336 if (av_fifo_size(s
->pkt_fifo
) < sizeof(ogg_packet
))
339 av_fifo_generic_read(s
->pkt_fifo
, &op
, sizeof(ogg_packet
), NULL
);
341 if ((ret
= ff_alloc_packet2(avctx
, avpkt
, op
.bytes
)) < 0)
343 av_fifo_generic_read(s
->pkt_fifo
, avpkt
->data
, op
.bytes
, NULL
);
345 avpkt
->pts
= ff_samples_to_time_base(avctx
, op
.granulepos
);
347 duration
= av_vorbis_parse_frame(s
->vp
, avpkt
->data
, avpkt
->size
);
349 /* we do not know encoder delay until we get the first packet from
350 * libvorbis, so we have to update the AudioFrameQueue counts */
351 if (!avctx
->initial_padding
&& s
->afq
.frames
) {
352 avctx
->initial_padding
= duration
;
353 av_assert0(!s
->afq
.remaining_delay
);
354 s
->afq
.frames
->duration
+= duration
;
355 if (s
->afq
.frames
->pts
!= AV_NOPTS_VALUE
)
356 s
->afq
.frames
->pts
-= duration
;
357 s
->afq
.remaining_samples
+= duration
;
359 ff_af_queue_remove(&s
->afq
, duration
, &avpkt
->pts
, &avpkt
->duration
);
366 AVCodec ff_libvorbis_encoder
= {
368 .long_name
= NULL_IF_CONFIG_SMALL("libvorbis"),
369 .type
= AVMEDIA_TYPE_AUDIO
,
370 .id
= AV_CODEC_ID_VORBIS
,
371 .priv_data_size
= sizeof(LibvorbisEncContext
),
372 .init
= libvorbis_encode_init
,
373 .encode2
= libvorbis_encode_frame
,
374 .close
= libvorbis_encode_close
,
375 .capabilities
= CODEC_CAP_DELAY
| CODEC_CAP_SMALL_LAST_FRAME
,
376 .sample_fmts
= (const enum AVSampleFormat
[]) { AV_SAMPLE_FMT_FLTP
,
377 AV_SAMPLE_FMT_NONE
},
378 .priv_class
= &vorbis_class
,
379 .defaults
= defaults
,