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 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 CodecID 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");
170 static void close_audio(AVFormatContext *oc, AVStream *st)
172 avcodec_close(st->codec);
177 /**************************************************************/
180 static AVFrame *picture, *tmp_picture;
181 static uint8_t *video_outbuf;
182 static int frame_count, video_outbuf_size;
184 /* Add a video output stream. */
185 static AVStream *add_video_stream(AVFormatContext *oc, enum CodecID codec_id)
191 /* find the video encoder */
192 codec = avcodec_find_encoder(codec_id);
194 fprintf(stderr, "codec not found\n");
198 st = avformat_new_stream(oc, codec);
200 fprintf(stderr, "Could not alloc stream\n");
206 /* Put sample parameters. */
207 c->bit_rate = 400000;
208 /* Resolution must be a multiple of two. */
211 /* timebase: This is the fundamental unit of time (in seconds) in terms
212 * of which frame timestamps are represented. For fixed-fps content,
213 * timebase should be 1/framerate and timestamp increments should be
215 c->time_base.den = STREAM_FRAME_RATE;
216 c->time_base.num = 1;
217 c->gop_size = 12; /* emit one intra frame every twelve frames at most */
218 c->pix_fmt = STREAM_PIX_FMT;
219 if (c->codec_id == CODEC_ID_MPEG2VIDEO) {
220 /* just for testing, we also add B frames */
223 if (c->codec_id == CODEC_ID_MPEG1VIDEO) {
224 /* Needed to avoid using macroblocks in which some coeffs overflow.
225 * This does not happen with normal video, it just happens here as
226 * the motion of the chroma plane does not match the luma plane. */
229 /* Some formats want stream headers to be separate. */
230 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
231 c->flags |= CODEC_FLAG_GLOBAL_HEADER;
236 static AVFrame *alloc_picture(enum PixelFormat pix_fmt, int width, int height)
239 uint8_t *picture_buf;
242 picture = avcodec_alloc_frame();
245 size = avpicture_get_size(pix_fmt, width, height);
246 picture_buf = av_malloc(size);
251 avpicture_fill((AVPicture *)picture, picture_buf,
252 pix_fmt, width, height);
256 static void open_video(AVFormatContext *oc, AVStream *st)
263 if (avcodec_open2(c, NULL, NULL) < 0) {
264 fprintf(stderr, "could not open codec\n");
269 if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {
270 /* Allocate output buffer. */
271 /* XXX: API change will be done. */
272 /* Buffers passed into lav* can be allocated any way you prefer,
273 * as long as they're aligned enough for the architecture, and
274 * they're freed appropriately (such as using av_free for buffers
275 * allocated with av_malloc). */
276 video_outbuf_size = 200000;
277 video_outbuf = av_malloc(video_outbuf_size);
280 /* Allocate the encoded raw picture. */
281 picture = alloc_picture(c->pix_fmt, c->width, c->height);
283 fprintf(stderr, "Could not allocate picture\n");
287 /* If the output format is not YUV420P, then a temporary YUV420P
288 * picture is needed too. It is then converted to the required
291 if (c->pix_fmt != PIX_FMT_YUV420P) {
292 tmp_picture = alloc_picture(PIX_FMT_YUV420P, c->width, c->height);
294 fprintf(stderr, "Could not allocate temporary picture\n");
300 /* Prepare a dummy image. */
301 static void fill_yuv_image(AVFrame *pict, int frame_index,
302 int width, int height)
309 for (y = 0; y < height; y++)
310 for (x = 0; x < width; x++)
311 pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
314 for (y = 0; y < height / 2; y++) {
315 for (x = 0; x < width / 2; x++) {
316 pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
317 pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
322 static void write_video_frame(AVFormatContext *oc, AVStream *st)
326 static struct SwsContext *img_convert_ctx;
330 if (frame_count >= STREAM_NB_FRAMES) {
331 /* No more frames to compress. The codec has a latency of a few
332 * frames if using B-frames, so we get the last frames by
333 * passing the same picture again. */
335 if (c->pix_fmt != PIX_FMT_YUV420P) {
336 /* as we only generate a YUV420P picture, we must convert it
337 * to the codec pixel format if needed */
338 if (img_convert_ctx == NULL) {
339 img_convert_ctx = sws_getContext(c->width, c->height,
343 sws_flags, NULL, NULL, NULL);
344 if (img_convert_ctx == NULL) {
346 "Cannot initialize the conversion context\n");
350 fill_yuv_image(tmp_picture, frame_count, c->width, c->height);
351 sws_scale(img_convert_ctx, tmp_picture->data, tmp_picture->linesize,
352 0, c->height, picture->data, picture->linesize);
354 fill_yuv_image(picture, frame_count, c->width, c->height);
358 if (oc->oformat->flags & AVFMT_RAWPICTURE) {
359 /* Raw video case - the API will change slightly in the near
360 * future for that. */
362 av_init_packet(&pkt);
364 pkt.flags |= AV_PKT_FLAG_KEY;
365 pkt.stream_index = st->index;
366 pkt.data = (uint8_t *)picture;
367 pkt.size = sizeof(AVPicture);
369 ret = av_interleaved_write_frame(oc, &pkt);
371 /* encode the image */
372 out_size = avcodec_encode_video(c, video_outbuf,
373 video_outbuf_size, picture);
374 /* If size is zero, it means the image was buffered. */
377 av_init_packet(&pkt);
379 if (c->coded_frame->pts != AV_NOPTS_VALUE)
380 pkt.pts = av_rescale_q(c->coded_frame->pts,
381 c->time_base, st->time_base);
382 if (c->coded_frame->key_frame)
383 pkt.flags |= AV_PKT_FLAG_KEY;
384 pkt.stream_index = st->index;
385 pkt.data = video_outbuf;
388 /* Write the compressed frame to the media file. */
389 ret = av_interleaved_write_frame(oc, &pkt);
395 fprintf(stderr, "Error while writing video frame\n");
401 static void close_video(AVFormatContext *oc, AVStream *st)
403 avcodec_close(st->codec);
404 av_free(picture->data[0]);
407 av_free(tmp_picture->data[0]);
408 av_free(tmp_picture);
410 av_free(video_outbuf);
413 /**************************************************************/
414 /* media file output */
416 int main(int argc, char **argv)
418 const char *filename;
421 AVStream *audio_st, *video_st;
422 double audio_pts, video_pts;
425 /* Initialize libavcodec, and register all codecs and formats. */
429 printf("usage: %s output_file\n"
430 "API example program to output a media file with libavformat.\n"
431 "The output format is automatically guessed according to the file extension.\n"
432 "Raw images can also be output by using '%%d' in the filename\n"
439 /* Autodetect the output format from the name. default is MPEG. */
440 fmt = av_guess_format(NULL, filename, NULL);
442 printf("Could not deduce output format from file extension: using MPEG.\n");
443 fmt = av_guess_format("mpeg", NULL, NULL);
446 fprintf(stderr, "Could not find suitable output format\n");
450 /* Allocate the output media context. */
451 oc = avformat_alloc_context();
453 fprintf(stderr, "Memory error\n");
457 snprintf(oc->filename, sizeof(oc->filename), "%s", filename);
459 /* Add the audio and video streams using the default format codecs
460 * and initialize the codecs. */
463 if (fmt->video_codec != CODEC_ID_NONE) {
464 video_st = add_video_stream(oc, fmt->video_codec);
466 if (fmt->audio_codec != CODEC_ID_NONE) {
467 audio_st = add_audio_stream(oc, fmt->audio_codec);
470 /* Now that all the parameters are set, we can open the audio and
471 * video codecs and allocate the necessary encode buffers. */
473 open_video(oc, video_st);
475 open_audio(oc, audio_st);
477 av_dump_format(oc, 0, filename, 1);
479 /* open the output file, if needed */
480 if (!(fmt->flags & AVFMT_NOFILE)) {
481 if (avio_open(&oc->pb, filename, AVIO_FLAG_WRITE) < 0) {
482 fprintf(stderr, "Could not open '%s'\n", filename);
487 /* Write the stream header, if any. */
488 avformat_write_header(oc, NULL);
491 /* Compute current audio and video time. */
493 audio_pts = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
498 video_pts = (double)video_st->pts.val * video_st->time_base.num /
499 video_st->time_base.den;
503 if ((!audio_st || audio_pts >= STREAM_DURATION) &&
504 (!video_st || video_pts >= STREAM_DURATION))
507 /* write interleaved audio and video frames */
508 if (!video_st || (video_st && audio_st && audio_pts < video_pts)) {
509 write_audio_frame(oc, audio_st);
511 write_video_frame(oc, video_st);
515 /* Write the trailer, if any. The trailer must be written before you
516 * close the CodecContexts open when you wrote the header; otherwise
517 * av_write_trailer() may try to use memory that was freed on
518 * av_codec_close(). */
519 av_write_trailer(oc);
521 /* Close each codec. */
523 close_video(oc, video_st);
525 close_audio(oc, audio_st);
527 /* Free the streams. */
528 for (i = 0; i < oc->nb_streams; i++) {
529 av_freep(&oc->streams[i]->codec);
530 av_freep(&oc->streams[i]);
533 if (!(fmt->flags & AVFMT_NOFILE))
534 /* Close the output file. */
537 /* free the stream */