883d55f0e2c28f00fd90081a3c2064ebcad30821
[ffmpeg.git] / doc / examples / output.c
1 /*
2  * Copyright (c) 2003 Fabrice Bellard
3  *
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:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
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
20  * THE SOFTWARE.
21  */
22
23 /**
24  * @file
25  * libavformat API example.
26  *
27  * @example output.c
28  * Output a media file in any supported libavformat format. The default
29  * codecs are used.
30  */
31
32 #include <stdlib.h>
33 #include <stdio.h>
34 #include <string.h>
35 #include <math.h>
36
37 #include "libavutil/channel_layout.h"
38 #include "libavutil/mathematics.h"
39 #include "libavformat/avformat.h"
40 #include "libswscale/swscale.h"
41
42 /* 5 seconds stream duration */
43 #define STREAM_DURATION   5.0
44 #define STREAM_FRAME_RATE 25 /* 25 images/s */
45 #define STREAM_NB_FRAMES  ((int)(STREAM_DURATION * STREAM_FRAME_RATE))
46 #define STREAM_PIX_FMT    AV_PIX_FMT_YUV420P /* default pix_fmt */
47
48 #define SCALE_FLAGS SWS_BICUBIC
49
50 // a wrapper around a single output AVStream
51 typedef struct OutputStream {
52     AVStream *st;
53
54     /* pts of the next frame that will be generated */
55     int64_t next_pts;
56
57     AVFrame *frame;
58     AVFrame *tmp_frame;
59
60     float t, tincr, tincr2;
61
62     struct SwsContext *sws_ctx;
63 } OutputStream;
64
65 /**************************************************************/
66 /* audio output */
67
68 /*
69  * add an audio output stream
70  */
71 static void add_audio_stream(OutputStream *ost, AVFormatContext *oc,
72                              enum AVCodecID codec_id)
73 {
74     AVCodecContext *c;
75     AVCodec *codec;
76
77     /* find the audio encoder */
78     codec = avcodec_find_encoder(codec_id);
79     if (!codec) {
80         fprintf(stderr, "codec not found\n");
81         exit(1);
82     }
83
84     ost->st = avformat_new_stream(oc, codec);
85     if (!ost->st) {
86         fprintf(stderr, "Could not alloc stream\n");
87         exit(1);
88     }
89
90     c = ost->st->codec;
91
92     /* put sample parameters */
93     c->sample_fmt  = AV_SAMPLE_FMT_S16;
94     c->bit_rate    = 64000;
95     c->sample_rate = 44100;
96     c->channels    = 2;
97     c->channel_layout = AV_CH_LAYOUT_STEREO;
98
99     // some formats want stream headers to be separate
100     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
101         c->flags |= CODEC_FLAG_GLOBAL_HEADER;
102 }
103
104 static void open_audio(AVFormatContext *oc, OutputStream *ost)
105 {
106     AVCodecContext *c;
107     int ret;
108
109     c = ost->st->codec;
110
111     /* open it */
112     if (avcodec_open2(c, NULL, NULL) < 0) {
113         fprintf(stderr, "could not open codec\n");
114         exit(1);
115     }
116
117     /* init signal generator */
118     ost->t     = 0;
119     ost->tincr = 2 * M_PI * 110.0 / c->sample_rate;
120     /* increment frequency by 110 Hz per second */
121     ost->tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;
122
123     ost->frame = av_frame_alloc();
124     if (!ost->frame)
125         exit(1);
126
127     ost->frame->sample_rate    = c->sample_rate;
128     ost->frame->format         = AV_SAMPLE_FMT_S16;
129     ost->frame->channel_layout = c->channel_layout;
130
131     if (c->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)
132         ost->frame->nb_samples = 10000;
133     else
134         ost->frame->nb_samples = c->frame_size;
135
136     ret = av_frame_get_buffer(ost->frame, 0);
137     if (ret < 0) {
138         fprintf(stderr, "Could not allocate an audio frame.\n");
139         exit(1);
140     }
141 }
142
143 /* Prepare a 16 bit dummy audio frame of 'frame_size' samples and
144  * 'nb_channels' channels. */
145 static AVFrame *get_audio_frame(OutputStream *ost)
146 {
147     int j, i, v, ret;
148     int16_t *q = (int16_t*)ost->frame->data[0];
149
150     /* check if we want to generate more frames */
151     if (av_compare_ts(ost->next_pts, ost->st->codec->time_base,
152                       STREAM_DURATION, (AVRational){ 1, 1 }) >= 0)
153         return NULL;
154
155     /* when we pass a frame to the encoder, it may keep a reference to it
156      * internally;
157      * make sure we do not overwrite it here
158      */
159     ret = av_frame_make_writable(ost->frame);
160     if (ret < 0)
161         exit(1);
162
163     for (j = 0; j < ost->frame->nb_samples; j++) {
164         v = (int)(sin(ost->t) * 10000);
165         for (i = 0; i < ost->st->codec->channels; i++)
166             *q++ = v;
167         ost->t     += ost->tincr;
168         ost->tincr += ost->tincr2;
169     }
170
171     ost->frame->pts = ost->next_pts;
172     ost->next_pts  += ost->frame->nb_samples;
173
174     return ost->frame;
175 }
176
177 /*
178  * encode one audio frame and send it to the muxer
179  * return 1 when encoding is finished, 0 otherwise
180  */
181 static int write_audio_frame(AVFormatContext *oc, OutputStream *ost)
182 {
183     AVCodecContext *c;
184     AVPacket pkt = { 0 }; // data and size must be 0;
185     AVFrame *frame;
186     int got_packet;
187
188     av_init_packet(&pkt);
189     c = ost->st->codec;
190
191     frame = get_audio_frame(ost);
192
193     avcodec_encode_audio2(c, &pkt, frame, &got_packet);
194
195     if (got_packet) {
196         pkt.stream_index = ost->st->index;
197
198         /* Write the compressed frame to the media file. */
199         if (av_interleaved_write_frame(oc, &pkt) != 0) {
200             fprintf(stderr, "Error while writing audio frame\n");
201             exit(1);
202         }
203     }
204
205     return (frame || got_packet) ? 0 : 1;
206 }
207
208 /**************************************************************/
209 /* video output */
210
211 /* Add a video output stream. */
212 static void add_video_stream(OutputStream *ost, AVFormatContext *oc,
213                              enum AVCodecID codec_id)
214 {
215     AVCodecContext *c;
216     AVCodec *codec;
217
218     /* find the video encoder */
219     codec = avcodec_find_encoder(codec_id);
220     if (!codec) {
221         fprintf(stderr, "codec not found\n");
222         exit(1);
223     }
224
225     ost->st = avformat_new_stream(oc, codec);
226     if (!ost->st) {
227         fprintf(stderr, "Could not alloc stream\n");
228         exit(1);
229     }
230
231     c = ost->st->codec;
232
233     /* Put sample parameters. */
234     c->bit_rate = 400000;
235     /* Resolution must be a multiple of two. */
236     c->width    = 352;
237     c->height   = 288;
238     /* timebase: This is the fundamental unit of time (in seconds) in terms
239      * of which frame timestamps are represented. For fixed-fps content,
240      * timebase should be 1/framerate and timestamp increments should be
241      * identical to 1. */
242     c->time_base.den = STREAM_FRAME_RATE;
243     c->time_base.num = 1;
244     c->gop_size      = 12; /* emit one intra frame every twelve frames at most */
245     c->pix_fmt       = STREAM_PIX_FMT;
246     if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
247         /* just for testing, we also add B frames */
248         c->max_b_frames = 2;
249     }
250     if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
251         /* Needed to avoid using macroblocks in which some coeffs overflow.
252          * This does not happen with normal video, it just happens here as
253          * the motion of the chroma plane does not match the luma plane. */
254         c->mb_decision = 2;
255     }
256     /* Some formats want stream headers to be separate. */
257     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
258         c->flags |= CODEC_FLAG_GLOBAL_HEADER;
259 }
260
261 static AVFrame *alloc_picture(enum AVPixelFormat pix_fmt, int width, int height)
262 {
263     AVFrame *picture;
264     int ret;
265
266     picture = av_frame_alloc();
267     if (!picture)
268         return NULL;
269
270     picture->format = pix_fmt;
271     picture->width  = width;
272     picture->height = height;
273
274     /* allocate the buffers for the frame data */
275     ret = av_frame_get_buffer(picture, 32);
276     if (ret < 0) {
277         fprintf(stderr, "Could not allocate frame data.\n");
278         exit(1);
279     }
280
281     return picture;
282 }
283
284 static void open_video(AVFormatContext *oc, OutputStream *ost)
285 {
286     AVCodecContext *c;
287
288     c = ost->st->codec;
289
290     /* open the codec */
291     if (avcodec_open2(c, NULL, NULL) < 0) {
292         fprintf(stderr, "could not open codec\n");
293         exit(1);
294     }
295
296     /* Allocate the encoded raw picture. */
297     ost->frame = alloc_picture(c->pix_fmt, c->width, c->height);
298     if (!ost->frame) {
299         fprintf(stderr, "Could not allocate picture\n");
300         exit(1);
301     }
302
303     /* If the output format is not YUV420P, then a temporary YUV420P
304      * picture is needed too. It is then converted to the required
305      * output format. */
306     ost->tmp_frame = NULL;
307     if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
308         ost->tmp_frame = alloc_picture(AV_PIX_FMT_YUV420P, c->width, c->height);
309         if (!ost->tmp_frame) {
310             fprintf(stderr, "Could not allocate temporary picture\n");
311             exit(1);
312         }
313     }
314 }
315
316 /* Prepare a dummy image. */
317 static void fill_yuv_image(AVFrame *pict, int frame_index,
318                            int width, int height)
319 {
320     int x, y, i, ret;
321
322     /* when we pass a frame to the encoder, it may keep a reference to it
323      * internally;
324      * make sure we do not overwrite it here
325      */
326     ret = av_frame_make_writable(pict);
327     if (ret < 0)
328         exit(1);
329
330     i = frame_index;
331
332     /* Y */
333     for (y = 0; y < height; y++)
334         for (x = 0; x < width; x++)
335             pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
336
337     /* Cb and Cr */
338     for (y = 0; y < height / 2; y++) {
339         for (x = 0; x < width / 2; x++) {
340             pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
341             pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
342         }
343     }
344 }
345
346 static AVFrame *get_video_frame(OutputStream *ost)
347 {
348     AVCodecContext *c = ost->st->codec;
349
350     /* check if we want to generate more frames */
351     if (av_compare_ts(ost->next_pts, ost->st->codec->time_base,
352                       STREAM_DURATION, (AVRational){ 1, 1 }) >= 0)
353         return NULL;
354
355     if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
356         /* as we only generate a YUV420P picture, we must convert it
357          * to the codec pixel format if needed */
358         if (!ost->sws_ctx) {
359             ost->sws_ctx = sws_getContext(c->width, c->height,
360                                           AV_PIX_FMT_YUV420P,
361                                           c->width, c->height,
362                                           c->pix_fmt,
363                                           SCALE_FLAGS, NULL, NULL, NULL);
364             if (!ost->sws_ctx) {
365                 fprintf(stderr,
366                         "Cannot initialize the conversion context\n");
367                 exit(1);
368             }
369         }
370         fill_yuv_image(ost->tmp_frame, ost->next_pts, c->width, c->height);
371         sws_scale(ost->sws_ctx, ost->tmp_frame->data, ost->tmp_frame->linesize,
372                   0, c->height, ost->frame->data, ost->frame->linesize);
373     } else {
374         fill_yuv_image(ost->frame, ost->next_pts, c->width, c->height);
375     }
376
377     ost->frame->pts = ost->next_pts++;
378
379     return ost->frame;
380 }
381
382 /*
383  * encode one video frame and send it to the muxer
384  * return 1 when encoding is finished, 0 otherwise
385  */
386 static int write_video_frame(AVFormatContext *oc, OutputStream *ost)
387 {
388     int ret;
389     AVCodecContext *c;
390     AVFrame *frame;
391     int got_packet = 0;
392
393     c = ost->st->codec;
394
395     frame = get_video_frame(ost);
396
397     if (oc->oformat->flags & AVFMT_RAWPICTURE) {
398         /* a hack to avoid data copy with some raw video muxers */
399         AVPacket pkt;
400         av_init_packet(&pkt);
401
402         if (!frame)
403             return 1;
404
405         pkt.flags        |= AV_PKT_FLAG_KEY;
406         pkt.stream_index  = ost->st->index;
407         pkt.data          = (uint8_t *)frame;
408         pkt.size          = sizeof(AVPicture);
409
410         pkt.pts = pkt.dts = frame->pts;
411         av_packet_rescale_ts(&pkt, c->time_base, ost->st->time_base);
412
413         ret = av_interleaved_write_frame(oc, &pkt);
414     } else {
415         AVPacket pkt = { 0 };
416         av_init_packet(&pkt);
417
418         /* encode the image */
419         ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);
420         if (ret < 0) {
421             fprintf(stderr, "Error encoding a video frame\n");
422             exit(1);
423         }
424
425         if (got_packet) {
426             av_packet_rescale_ts(&pkt, c->time_base, ost->st->time_base);
427             pkt.stream_index = ost->st->index;
428
429             /* Write the compressed frame to the media file. */
430             ret = av_interleaved_write_frame(oc, &pkt);
431         }
432     }
433     if (ret != 0) {
434         fprintf(stderr, "Error while writing video frame\n");
435         exit(1);
436     }
437
438     return (frame || got_packet) ? 0 : 1;
439 }
440
441 static void close_stream(AVFormatContext *oc, OutputStream *ost)
442 {
443     avcodec_close(ost->st->codec);
444     av_frame_free(&ost->frame);
445     av_frame_free(&ost->tmp_frame);
446     sws_freeContext(ost->sws_ctx);
447 }
448
449 /**************************************************************/
450 /* media file output */
451
452 int main(int argc, char **argv)
453 {
454     OutputStream video_st = { 0 }, audio_st = { 0 };
455     const char *filename;
456     AVOutputFormat *fmt;
457     AVFormatContext *oc;
458     int have_video = 0, have_audio = 0;
459     int encode_video = 0, encode_audio = 0;
460
461     /* Initialize libavcodec, and register all codecs and formats. */
462     av_register_all();
463
464     if (argc != 2) {
465         printf("usage: %s output_file\n"
466                "API example program to output a media file with libavformat.\n"
467                "The output format is automatically guessed according to the file extension.\n"
468                "Raw images can also be output by using '%%d' in the filename\n"
469                "\n", argv[0]);
470         return 1;
471     }
472
473     filename = argv[1];
474
475     /* Autodetect the output format from the name. default is MPEG. */
476     fmt = av_guess_format(NULL, filename, NULL);
477     if (!fmt) {
478         printf("Could not deduce output format from file extension: using MPEG.\n");
479         fmt = av_guess_format("mpeg", NULL, NULL);
480     }
481     if (!fmt) {
482         fprintf(stderr, "Could not find suitable output format\n");
483         return 1;
484     }
485
486     /* Allocate the output media context. */
487     oc = avformat_alloc_context();
488     if (!oc) {
489         fprintf(stderr, "Memory error\n");
490         return 1;
491     }
492     oc->oformat = fmt;
493     snprintf(oc->filename, sizeof(oc->filename), "%s", filename);
494
495     /* Add the audio and video streams using the default format codecs
496      * and initialize the codecs. */
497     if (fmt->video_codec != AV_CODEC_ID_NONE) {
498         add_video_stream(&video_st, oc, fmt->video_codec);
499         have_video = 1;
500         encode_video = 1;
501     }
502     if (fmt->audio_codec != AV_CODEC_ID_NONE) {
503         add_audio_stream(&audio_st, oc, fmt->audio_codec);
504         have_audio = 1;
505         encode_audio = 1;
506     }
507
508     /* Now that all the parameters are set, we can open the audio and
509      * video codecs and allocate the necessary encode buffers. */
510     if (have_video)
511         open_video(oc, &video_st);
512     if (have_audio)
513         open_audio(oc, &audio_st);
514
515     av_dump_format(oc, 0, filename, 1);
516
517     /* open the output file, if needed */
518     if (!(fmt->flags & AVFMT_NOFILE)) {
519         if (avio_open(&oc->pb, filename, AVIO_FLAG_WRITE) < 0) {
520             fprintf(stderr, "Could not open '%s'\n", filename);
521             return 1;
522         }
523     }
524
525     /* Write the stream header, if any. */
526     avformat_write_header(oc, NULL);
527
528     while (encode_video || encode_audio) {
529         /* select the stream to encode */
530         if (encode_video &&
531             (!encode_audio || av_compare_ts(video_st.next_pts, video_st.st->codec->time_base,
532                                             audio_st.next_pts, audio_st.st->codec->time_base) <= 0)) {
533             encode_video = !write_video_frame(oc, &video_st);
534         } else {
535             encode_audio = !write_audio_frame(oc, &audio_st);
536         }
537     }
538
539     /* Write the trailer, if any. The trailer must be written before you
540      * close the CodecContexts open when you wrote the header; otherwise
541      * av_write_trailer() may try to use memory that was freed on
542      * av_codec_close(). */
543     av_write_trailer(oc);
544
545     /* Close each codec. */
546     if (have_video)
547         close_stream(oc, &video_st);
548     if (have_audio)
549         close_stream(oc, &audio_st);
550
551     if (!(fmt->flags & AVFMT_NOFILE))
552         /* Close the output file. */
553         avio_close(oc->pb);
554
555     /* free the stream */
556     avformat_free_context(oc);
557
558     return 0;
559 }