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