2 * Copyright (c) 2003 Fabrice Bellard
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 * libavformat API example.
27 * @example libavformat/output-example.c
28 * Output a media file in any supported libavformat format.
29 * The default codecs are used.
37 #include "libavutil/mathematics.h"
38 #include "libavformat/avformat.h"
39 #include "libswscale/swscale.h"
43 /* 5 seconds stream duration */
44 #define STREAM_DURATION 5.0
45 #define STREAM_FRAME_RATE 25 /* 25 images/s */
46 #define STREAM_NB_FRAMES ((int)(STREAM_DURATION * STREAM_FRAME_RATE))
47 #define STREAM_PIX_FMT AV_PIX_FMT_YUV420P /* default pix_fmt */
49 static int sws_flags = SWS_BICUBIC;
51 /**************************************************************/
54 static float t, tincr, tincr2;
55 static int16_t *samples;
56 static int audio_input_frame_size;
59 * add an audio output stream
61 static AVStream *add_audio_stream(AVFormatContext *oc, enum AVCodecID codec_id)
67 /* find the audio encoder */
68 codec = avcodec_find_encoder(codec_id);
70 fprintf(stderr, "codec not found\n");
74 st = avformat_new_stream(oc, codec);
76 fprintf(stderr, "Could not alloc stream\n");
82 /* put sample parameters */
83 c->sample_fmt = AV_SAMPLE_FMT_S16;
85 c->sample_rate = 44100;
88 // some formats want stream headers to be separate
89 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
90 c->flags |= CODEC_FLAG_GLOBAL_HEADER;
95 static void open_audio(AVFormatContext *oc, AVStream *st)
102 if (avcodec_open2(c, NULL, NULL) < 0) {
103 fprintf(stderr, "could not open codec\n");
107 /* init signal generator */
109 tincr = 2 * M_PI * 110.0 / c->sample_rate;
110 /* increment frequency by 110 Hz per second */
111 tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;
113 if (c->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)
114 audio_input_frame_size = 10000;
116 audio_input_frame_size = c->frame_size;
117 samples = av_malloc(audio_input_frame_size *
118 av_get_bytes_per_sample(c->sample_fmt) *
122 /* Prepare a 16 bit dummy audio frame of 'frame_size' samples and
123 * 'nb_channels' channels. */
124 static void get_audio_frame(int16_t *samples, int frame_size, int nb_channels)
130 for (j = 0; j < frame_size; j++) {
131 v = (int)(sin(t) * 10000);
132 for (i = 0; i < nb_channels; i++)
139 static void write_audio_frame(AVFormatContext *oc, AVStream *st)
142 AVPacket pkt = { 0 }; // data and size must be 0;
143 AVFrame *frame = avcodec_alloc_frame();
146 av_init_packet(&pkt);
149 get_audio_frame(samples, audio_input_frame_size, c->channels);
150 frame->nb_samples = audio_input_frame_size;
151 avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
153 audio_input_frame_size *
154 av_get_bytes_per_sample(c->sample_fmt) *
157 avcodec_encode_audio2(c, &pkt, frame, &got_packet);
161 pkt.stream_index = st->index;
163 /* Write the compressed frame to the media file. */
164 if (av_interleaved_write_frame(oc, &pkt) != 0) {
165 fprintf(stderr, "Error while writing audio frame\n");
168 avcodec_free_frame(&frame);
171 static void close_audio(AVFormatContext *oc, AVStream *st)
173 avcodec_close(st->codec);
178 /**************************************************************/
181 static AVFrame *picture, *tmp_picture;
182 static uint8_t *video_outbuf;
183 static int frame_count, video_outbuf_size;
185 /* Add a video output stream. */
186 static AVStream *add_video_stream(AVFormatContext *oc, enum AVCodecID codec_id)
192 /* find the video encoder */
193 codec = avcodec_find_encoder(codec_id);
195 fprintf(stderr, "codec not found\n");
199 st = avformat_new_stream(oc, codec);
201 fprintf(stderr, "Could not alloc stream\n");
207 /* Put sample parameters. */
208 c->bit_rate = 400000;
209 /* Resolution must be a multiple of two. */
212 /* timebase: This is the fundamental unit of time (in seconds) in terms
213 * of which frame timestamps are represented. For fixed-fps content,
214 * timebase should be 1/framerate and timestamp increments should be
216 c->time_base.den = STREAM_FRAME_RATE;
217 c->time_base.num = 1;
218 c->gop_size = 12; /* emit one intra frame every twelve frames at most */
219 c->pix_fmt = STREAM_PIX_FMT;
220 if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
221 /* just for testing, we also add B frames */
224 if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
225 /* Needed to avoid using macroblocks in which some coeffs overflow.
226 * This does not happen with normal video, it just happens here as
227 * the motion of the chroma plane does not match the luma plane. */
230 /* Some formats want stream headers to be separate. */
231 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
232 c->flags |= CODEC_FLAG_GLOBAL_HEADER;
237 static AVFrame *alloc_picture(enum AVPixelFormat pix_fmt, int width, int height)
240 uint8_t *picture_buf;
243 picture = avcodec_alloc_frame();
246 size = avpicture_get_size(pix_fmt, width, height);
247 picture_buf = av_malloc(size);
252 avpicture_fill((AVPicture *)picture, picture_buf,
253 pix_fmt, width, height);
257 static void open_video(AVFormatContext *oc, AVStream *st)
264 if (avcodec_open2(c, NULL, NULL) < 0) {
265 fprintf(stderr, "could not open codec\n");
270 if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {
271 /* Allocate output buffer. */
272 /* XXX: API change will be done. */
273 /* Buffers passed into lav* can be allocated any way you prefer,
274 * as long as they're aligned enough for the architecture, and
275 * they're freed appropriately (such as using av_free for buffers
276 * allocated with av_malloc). */
277 video_outbuf_size = 200000;
278 video_outbuf = av_malloc(video_outbuf_size);
281 /* Allocate the encoded raw picture. */
282 picture = alloc_picture(c->pix_fmt, c->width, c->height);
284 fprintf(stderr, "Could not allocate picture\n");
288 /* If the output format is not YUV420P, then a temporary YUV420P
289 * picture is needed too. It is then converted to the required
292 if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
293 tmp_picture = alloc_picture(AV_PIX_FMT_YUV420P, c->width, c->height);
295 fprintf(stderr, "Could not allocate temporary picture\n");
301 /* Prepare a dummy image. */
302 static void fill_yuv_image(AVFrame *pict, int frame_index,
303 int width, int height)
310 for (y = 0; y < height; y++)
311 for (x = 0; x < width; x++)
312 pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
315 for (y = 0; y < height / 2; y++) {
316 for (x = 0; x < width / 2; x++) {
317 pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
318 pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
323 static void write_video_frame(AVFormatContext *oc, AVStream *st)
327 static struct SwsContext *img_convert_ctx;
331 if (frame_count >= STREAM_NB_FRAMES) {
332 /* No more frames to compress. The codec has a latency of a few
333 * frames if using B-frames, so we get the last frames by
334 * passing the same picture again. */
336 if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
337 /* as we only generate a YUV420P picture, we must convert it
338 * to the codec pixel format if needed */
339 if (img_convert_ctx == NULL) {
340 img_convert_ctx = sws_getContext(c->width, c->height,
344 sws_flags, NULL, NULL, NULL);
345 if (img_convert_ctx == NULL) {
347 "Cannot initialize the conversion context\n");
351 fill_yuv_image(tmp_picture, frame_count, c->width, c->height);
352 sws_scale(img_convert_ctx, tmp_picture->data, tmp_picture->linesize,
353 0, c->height, picture->data, picture->linesize);
355 fill_yuv_image(picture, frame_count, c->width, c->height);
359 if (oc->oformat->flags & AVFMT_RAWPICTURE) {
360 /* Raw video case - the API will change slightly in the near
361 * future for that. */
363 av_init_packet(&pkt);
365 pkt.flags |= AV_PKT_FLAG_KEY;
366 pkt.stream_index = st->index;
367 pkt.data = (uint8_t *)picture;
368 pkt.size = sizeof(AVPicture);
370 ret = av_interleaved_write_frame(oc, &pkt);
372 /* encode the image */
373 out_size = avcodec_encode_video(c, video_outbuf,
374 video_outbuf_size, picture);
375 /* If size is zero, it means the image was buffered. */
378 av_init_packet(&pkt);
380 if (c->coded_frame->pts != AV_NOPTS_VALUE)
381 pkt.pts = av_rescale_q(c->coded_frame->pts,
382 c->time_base, st->time_base);
383 if (c->coded_frame->key_frame)
384 pkt.flags |= AV_PKT_FLAG_KEY;
385 pkt.stream_index = st->index;
386 pkt.data = video_outbuf;
389 /* Write the compressed frame to the media file. */
390 ret = av_interleaved_write_frame(oc, &pkt);
396 fprintf(stderr, "Error while writing video frame\n");
402 static void close_video(AVFormatContext *oc, AVStream *st)
404 avcodec_close(st->codec);
405 av_free(picture->data[0]);
408 av_free(tmp_picture->data[0]);
409 av_free(tmp_picture);
411 av_free(video_outbuf);
414 /**************************************************************/
415 /* media file output */
417 int main(int argc, char **argv)
419 const char *filename;
422 AVStream *audio_st, *video_st;
423 double audio_pts, video_pts;
426 /* Initialize libavcodec, and register all codecs and formats. */
430 printf("usage: %s output_file\n"
431 "API example program to output a media file with libavformat.\n"
432 "The output format is automatically guessed according to the file extension.\n"
433 "Raw images can also be output by using '%%d' in the filename\n"
440 /* Autodetect the output format from the name. default is MPEG. */
441 fmt = av_guess_format(NULL, filename, NULL);
443 printf("Could not deduce output format from file extension: using MPEG.\n");
444 fmt = av_guess_format("mpeg", NULL, NULL);
447 fprintf(stderr, "Could not find suitable output format\n");
451 /* Allocate the output media context. */
452 oc = avformat_alloc_context();
454 fprintf(stderr, "Memory error\n");
458 snprintf(oc->filename, sizeof(oc->filename), "%s", filename);
460 /* Add the audio and video streams using the default format codecs
461 * and initialize the codecs. */
464 if (fmt->video_codec != AV_CODEC_ID_NONE) {
465 video_st = add_video_stream(oc, fmt->video_codec);
467 if (fmt->audio_codec != AV_CODEC_ID_NONE) {
468 audio_st = add_audio_stream(oc, fmt->audio_codec);
471 /* Now that all the parameters are set, we can open the audio and
472 * video codecs and allocate the necessary encode buffers. */
474 open_video(oc, video_st);
476 open_audio(oc, audio_st);
478 av_dump_format(oc, 0, filename, 1);
480 /* open the output file, if needed */
481 if (!(fmt->flags & AVFMT_NOFILE)) {
482 if (avio_open(&oc->pb, filename, AVIO_FLAG_WRITE) < 0) {
483 fprintf(stderr, "Could not open '%s'\n", filename);
488 /* Write the stream header, if any. */
489 avformat_write_header(oc, NULL);
492 /* Compute current audio and video time. */
494 audio_pts = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
499 video_pts = (double)video_st->pts.val * video_st->time_base.num /
500 video_st->time_base.den;
504 if ((!audio_st || audio_pts >= STREAM_DURATION) &&
505 (!video_st || video_pts >= STREAM_DURATION))
508 /* write interleaved audio and video frames */
509 if (!video_st || (video_st && audio_st && audio_pts < video_pts)) {
510 write_audio_frame(oc, audio_st);
512 write_video_frame(oc, video_st);
516 /* Write the trailer, if any. The trailer must be written before you
517 * close the CodecContexts open when you wrote the header; otherwise
518 * av_write_trailer() may try to use memory that was freed on
519 * av_codec_close(). */
520 av_write_trailer(oc);
522 /* Close each codec. */
524 close_video(oc, video_st);
526 close_audio(oc, audio_st);
528 /* Free the streams. */
529 for (i = 0; i < oc->nb_streams; i++) {
530 av_freep(&oc->streams[i]->codec);
531 av_freep(&oc->streams[i]);
534 if (!(fmt->flags & AVFMT_NOFILE))
535 /* Close the output file. */
538 /* free the stream */