examples: add remuxing example
[ffmpeg.git] / doc / examples / muxing.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  * Output a media file in any supported libavformat format.
28  * The default codecs are used.
29  * @example doc/examples/muxing.c
30  */
31
32 #include <stdlib.h>
33 #include <stdio.h>
34 #include <string.h>
35 #include <math.h>
36
37 #include <libavutil/opt.h>
38 #include <libavutil/mathematics.h>
39 #include <libavformat/avformat.h>
40 #include <libswscale/swscale.h>
41 #include <libswresample/swresample.h>
42
43 /* 5 seconds stream duration */
44 #define STREAM_DURATION   200.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 */
48
49 static int sws_flags = SWS_BICUBIC;
50
51 /* Add an output stream. */
52 static AVStream *add_stream(AVFormatContext *oc, AVCodec **codec,
53                             enum AVCodecID codec_id)
54 {
55     AVCodecContext *c;
56     AVStream *st;
57
58     /* find the encoder */
59     *codec = avcodec_find_encoder(codec_id);
60     if (!(*codec)) {
61         fprintf(stderr, "Could not find encoder for '%s'\n",
62                 avcodec_get_name(codec_id));
63         exit(1);
64     }
65
66     st = avformat_new_stream(oc, *codec);
67     if (!st) {
68         fprintf(stderr, "Could not allocate stream\n");
69         exit(1);
70     }
71     st->id = oc->nb_streams-1;
72     c = st->codec;
73
74     switch ((*codec)->type) {
75     case AVMEDIA_TYPE_AUDIO:
76         c->sample_fmt  = (*codec)->sample_fmts ?
77             (*codec)->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;
78         c->bit_rate    = 64000;
79         c->sample_rate = 44100;
80         c->channels    = 2;
81         break;
82
83     case AVMEDIA_TYPE_VIDEO:
84         c->codec_id = codec_id;
85
86         c->bit_rate = 400000;
87         /* Resolution must be a multiple of two. */
88         c->width    = 352;
89         c->height   = 288;
90         /* timebase: This is the fundamental unit of time (in seconds) in terms
91          * of which frame timestamps are represented. For fixed-fps content,
92          * timebase should be 1/framerate and timestamp increments should be
93          * identical to 1. */
94         c->time_base.den = STREAM_FRAME_RATE;
95         c->time_base.num = 1;
96         c->gop_size      = 12; /* emit one intra frame every twelve frames at most */
97         c->pix_fmt       = STREAM_PIX_FMT;
98         if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
99             /* just for testing, we also add B frames */
100             c->max_b_frames = 2;
101         }
102         if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
103             /* Needed to avoid using macroblocks in which some coeffs overflow.
104              * This does not happen with normal video, it just happens here as
105              * the motion of the chroma plane does not match the luma plane. */
106             c->mb_decision = 2;
107         }
108     break;
109
110     default:
111         break;
112     }
113
114     /* Some formats want stream headers to be separate. */
115     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
116         c->flags |= CODEC_FLAG_GLOBAL_HEADER;
117
118     return st;
119 }
120
121 /**************************************************************/
122 /* audio output */
123
124 static float t, tincr, tincr2;
125
126 AVFrame *audio_frame;
127 static uint8_t **src_samples_data;
128 static int       src_samples_linesize;
129 static int       src_nb_samples;
130
131 static int max_dst_nb_samples;
132 uint8_t **dst_samples_data;
133 int       dst_samples_linesize;
134 int       dst_samples_size;
135 int samples_count;
136
137 struct SwrContext *swr_ctx = NULL;
138
139 static void open_audio(AVFormatContext *oc, AVCodec *codec, AVStream *st)
140 {
141     AVCodecContext *c;
142     int ret;
143
144     c = st->codec;
145
146     /* allocate and init a re-usable frame */
147     audio_frame = av_frame_alloc();
148     if (!audio_frame) {
149         fprintf(stderr, "Could not allocate audio frame\n");
150         exit(1);
151     }
152
153     /* open it */
154     ret = avcodec_open2(c, codec, NULL);
155     if (ret < 0) {
156         fprintf(stderr, "Could not open audio codec: %s\n", av_err2str(ret));
157         exit(1);
158     }
159
160     /* init signal generator */
161     t     = 0;
162     tincr = 2 * M_PI * 110.0 / c->sample_rate;
163     /* increment frequency by 110 Hz per second */
164     tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;
165
166     src_nb_samples = c->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE ?
167         10000 : c->frame_size;
168
169     ret = av_samples_alloc_array_and_samples(&src_samples_data, &src_samples_linesize, c->channels,
170                                              src_nb_samples, AV_SAMPLE_FMT_S16, 0);
171     if (ret < 0) {
172         fprintf(stderr, "Could not allocate source samples\n");
173         exit(1);
174     }
175
176     /* compute the number of converted samples: buffering is avoided
177      * ensuring that the output buffer will contain at least all the
178      * converted input samples */
179     max_dst_nb_samples = src_nb_samples;
180
181     /* create resampler context */
182     if (c->sample_fmt != AV_SAMPLE_FMT_S16) {
183         swr_ctx = swr_alloc();
184         if (!swr_ctx) {
185             fprintf(stderr, "Could not allocate resampler context\n");
186             exit(1);
187         }
188
189         /* set options */
190         av_opt_set_int       (swr_ctx, "in_channel_count",   c->channels,       0);
191         av_opt_set_int       (swr_ctx, "in_sample_rate",     c->sample_rate,    0);
192         av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt",      AV_SAMPLE_FMT_S16, 0);
193         av_opt_set_int       (swr_ctx, "out_channel_count",  c->channels,       0);
194         av_opt_set_int       (swr_ctx, "out_sample_rate",    c->sample_rate,    0);
195         av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt",     c->sample_fmt,     0);
196
197         /* initialize the resampling context */
198         if ((ret = swr_init(swr_ctx)) < 0) {
199             fprintf(stderr, "Failed to initialize the resampling context\n");
200             exit(1);
201         }
202
203         ret = av_samples_alloc_array_and_samples(&dst_samples_data, &dst_samples_linesize, c->channels,
204                                                  max_dst_nb_samples, c->sample_fmt, 0);
205         if (ret < 0) {
206             fprintf(stderr, "Could not allocate destination samples\n");
207             exit(1);
208         }
209     } else {
210         dst_samples_data = src_samples_data;
211     }
212     dst_samples_size = av_samples_get_buffer_size(NULL, c->channels, max_dst_nb_samples,
213                                                   c->sample_fmt, 0);
214 }
215
216 /* Prepare a 16 bit dummy audio frame of 'frame_size' samples and
217  * 'nb_channels' channels. */
218 static void get_audio_frame(int16_t *samples, int frame_size, int nb_channels)
219 {
220     int j, i, v;
221     int16_t *q;
222
223     q = samples;
224     for (j = 0; j < frame_size; j++) {
225         v = (int)(sin(t) * 10000);
226         for (i = 0; i < nb_channels; i++)
227             *q++ = v;
228         t     += tincr;
229         tincr += tincr2;
230     }
231 }
232
233 static void write_audio_frame(AVFormatContext *oc, AVStream *st)
234 {
235     AVCodecContext *c;
236     AVPacket pkt = { 0 }; // data and size must be 0;
237     int got_packet, ret, dst_nb_samples;
238
239     av_init_packet(&pkt);
240     c = st->codec;
241
242     get_audio_frame((int16_t *)src_samples_data[0], src_nb_samples, c->channels);
243
244     /* convert samples from native format to destination codec format, using the resampler */
245     if (swr_ctx) {
246         /* compute destination number of samples */
247         dst_nb_samples = av_rescale_rnd(swr_get_delay(swr_ctx, c->sample_rate) + src_nb_samples,
248                                         c->sample_rate, c->sample_rate, AV_ROUND_UP);
249         if (dst_nb_samples > max_dst_nb_samples) {
250             av_free(dst_samples_data[0]);
251             ret = av_samples_alloc(dst_samples_data, &dst_samples_linesize, c->channels,
252                                    dst_nb_samples, c->sample_fmt, 0);
253             if (ret < 0)
254                 exit(1);
255             max_dst_nb_samples = dst_nb_samples;
256             dst_samples_size = av_samples_get_buffer_size(NULL, c->channels, dst_nb_samples,
257                                                           c->sample_fmt, 0);
258         }
259
260         /* convert to destination format */
261         ret = swr_convert(swr_ctx,
262                           dst_samples_data, dst_nb_samples,
263                           (const uint8_t **)src_samples_data, src_nb_samples);
264         if (ret < 0) {
265             fprintf(stderr, "Error while converting\n");
266             exit(1);
267         }
268     } else {
269         dst_nb_samples = src_nb_samples;
270     }
271
272     audio_frame->nb_samples = dst_nb_samples;
273     audio_frame->pts = av_rescale_q(samples_count, (AVRational){1, c->sample_rate}, c->time_base);
274     avcodec_fill_audio_frame(audio_frame, c->channels, c->sample_fmt,
275                              dst_samples_data[0], dst_samples_size, 0);
276     samples_count += dst_nb_samples;
277
278     ret = avcodec_encode_audio2(c, &pkt, audio_frame, &got_packet);
279     if (ret < 0) {
280         fprintf(stderr, "Error encoding audio frame: %s\n", av_err2str(ret));
281         exit(1);
282     }
283
284     if (!got_packet)
285         return;
286
287     /* rescale output packet timestamp values from codec to stream timebase */
288     pkt.pts = av_rescale_q_rnd(pkt.pts, c->time_base, st->time_base, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
289     pkt.dts = av_rescale_q_rnd(pkt.dts, c->time_base, st->time_base, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
290     pkt.duration = av_rescale_q(pkt.duration, c->time_base, st->time_base);
291     pkt.stream_index = st->index;
292
293     /* Write the compressed frame to the media file. */
294     ret = av_interleaved_write_frame(oc, &pkt);
295     if (ret != 0) {
296         fprintf(stderr, "Error while writing audio frame: %s\n",
297                 av_err2str(ret));
298         exit(1);
299     }
300 }
301
302 static void close_audio(AVFormatContext *oc, AVStream *st)
303 {
304     avcodec_close(st->codec);
305     if (dst_samples_data != src_samples_data) {
306         av_free(dst_samples_data[0]);
307         av_free(dst_samples_data);
308     }
309     av_free(src_samples_data[0]);
310     av_free(src_samples_data);
311     av_frame_free(&audio_frame);
312 }
313
314 /**************************************************************/
315 /* video output */
316
317 static AVFrame *frame;
318 static AVPicture src_picture, dst_picture;
319 static int frame_count;
320
321 static void open_video(AVFormatContext *oc, AVCodec *codec, AVStream *st)
322 {
323     int ret;
324     AVCodecContext *c = st->codec;
325
326     /* open the codec */
327     ret = avcodec_open2(c, codec, NULL);
328     if (ret < 0) {
329         fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));
330         exit(1);
331     }
332
333     /* allocate and init a re-usable frame */
334     frame = av_frame_alloc();
335     if (!frame) {
336         fprintf(stderr, "Could not allocate video frame\n");
337         exit(1);
338     }
339     frame->format = c->pix_fmt;
340     frame->width = c->width;
341     frame->height = c->height;
342
343     /* Allocate the encoded raw picture. */
344     ret = avpicture_alloc(&dst_picture, c->pix_fmt, c->width, c->height);
345     if (ret < 0) {
346         fprintf(stderr, "Could not allocate picture: %s\n", av_err2str(ret));
347         exit(1);
348     }
349
350     /* If the output format is not YUV420P, then a temporary YUV420P
351      * picture is needed too. It is then converted to the required
352      * output format. */
353     if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
354         ret = avpicture_alloc(&src_picture, AV_PIX_FMT_YUV420P, c->width, c->height);
355         if (ret < 0) {
356             fprintf(stderr, "Could not allocate temporary picture: %s\n",
357                     av_err2str(ret));
358             exit(1);
359         }
360     }
361
362     /* copy data and linesize picture pointers to frame */
363     *((AVPicture *)frame) = dst_picture;
364 }
365
366 /* Prepare a dummy image. */
367 static void fill_yuv_image(AVPicture *pict, int frame_index,
368                            int width, int height)
369 {
370     int x, y, i;
371
372     i = frame_index;
373
374     /* Y */
375     for (y = 0; y < height; y++)
376         for (x = 0; x < width; x++)
377             pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
378
379     /* Cb and Cr */
380     for (y = 0; y < height / 2; y++) {
381         for (x = 0; x < width / 2; x++) {
382             pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
383             pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
384         }
385     }
386 }
387
388 static void write_video_frame(AVFormatContext *oc, AVStream *st)
389 {
390     int ret;
391     static struct SwsContext *sws_ctx;
392     AVCodecContext *c = st->codec;
393
394     if (frame_count >= STREAM_NB_FRAMES) {
395         /* No more frames to compress. The codec has a latency of a few
396          * frames if using B-frames, so we get the last frames by
397          * passing the same picture again. */
398     } else {
399         if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
400             /* as we only generate a YUV420P picture, we must convert it
401              * to the codec pixel format if needed */
402             if (!sws_ctx) {
403                 sws_ctx = sws_getContext(c->width, c->height, AV_PIX_FMT_YUV420P,
404                                          c->width, c->height, c->pix_fmt,
405                                          sws_flags, NULL, NULL, NULL);
406                 if (!sws_ctx) {
407                     fprintf(stderr,
408                             "Could not initialize the conversion context\n");
409                     exit(1);
410                 }
411             }
412             fill_yuv_image(&src_picture, frame_count, c->width, c->height);
413             sws_scale(sws_ctx,
414                       (const uint8_t * const *)src_picture.data, src_picture.linesize,
415                       0, c->height, dst_picture.data, dst_picture.linesize);
416         } else {
417             fill_yuv_image(&dst_picture, frame_count, c->width, c->height);
418         }
419     }
420
421     if (oc->oformat->flags & AVFMT_RAWPICTURE) {
422         /* Raw video case - directly store the picture in the packet */
423         AVPacket pkt;
424         av_init_packet(&pkt);
425
426         pkt.flags        |= AV_PKT_FLAG_KEY;
427         pkt.stream_index  = st->index;
428         pkt.data          = dst_picture.data[0];
429         pkt.size          = sizeof(AVPicture);
430
431         ret = av_interleaved_write_frame(oc, &pkt);
432     } else {
433         AVPacket pkt = { 0 };
434         int got_packet;
435         av_init_packet(&pkt);
436
437         /* encode the image */
438         frame->pts = frame_count;
439         ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);
440         if (ret < 0) {
441             fprintf(stderr, "Error encoding video frame: %s\n", av_err2str(ret));
442             exit(1);
443         }
444         /* If size is zero, it means the image was buffered. */
445
446         if (!ret && got_packet && pkt.size) {
447             /* rescale output packet timestamp values from codec to stream timebase */
448             pkt.pts = av_rescale_q_rnd(pkt.pts, c->time_base, st->time_base, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
449             pkt.dts = av_rescale_q_rnd(pkt.dts, c->time_base, st->time_base, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
450             pkt.duration = av_rescale_q(pkt.duration, c->time_base, st->time_base);
451             pkt.stream_index = st->index;
452
453             /* Write the compressed frame to the media file. */
454             ret = av_interleaved_write_frame(oc, &pkt);
455         } else {
456             ret = 0;
457         }
458     }
459     if (ret != 0) {
460         fprintf(stderr, "Error while writing video frame: %s\n", av_err2str(ret));
461         exit(1);
462     }
463     frame_count++;
464 }
465
466 static void close_video(AVFormatContext *oc, AVStream *st)
467 {
468     avcodec_close(st->codec);
469     av_free(src_picture.data[0]);
470     av_free(dst_picture.data[0]);
471     av_frame_free(&frame);
472 }
473
474 /**************************************************************/
475 /* media file output */
476
477 int main(int argc, char **argv)
478 {
479     const char *filename;
480     AVOutputFormat *fmt;
481     AVFormatContext *oc;
482     AVStream *audio_st, *video_st;
483     AVCodec *audio_codec, *video_codec;
484     double audio_time, video_time;
485     int ret;
486
487     /* Initialize libavcodec, and register all codecs and formats. */
488     av_register_all();
489
490     if (argc != 2) {
491         printf("usage: %s output_file\n"
492                "API example program to output a media file with libavformat.\n"
493                "This program generates a synthetic audio and video stream, encodes and\n"
494                "muxes them into a file named output_file.\n"
495                "The output format is automatically guessed according to the file extension.\n"
496                "Raw images can also be output by using '%%d' in the filename.\n"
497                "\n", argv[0]);
498         return 1;
499     }
500
501     filename = argv[1];
502
503     /* allocate the output media context */
504     avformat_alloc_output_context2(&oc, NULL, NULL, filename);
505     if (!oc) {
506         printf("Could not deduce output format from file extension: using MPEG.\n");
507         avformat_alloc_output_context2(&oc, NULL, "mpeg", filename);
508     }
509     if (!oc) {
510         return 1;
511     }
512     fmt = oc->oformat;
513
514     /* Add the audio and video streams using the default format codecs
515      * and initialize the codecs. */
516     video_st = NULL;
517     audio_st = NULL;
518
519     if (fmt->video_codec != AV_CODEC_ID_NONE) {
520         video_st = add_stream(oc, &video_codec, fmt->video_codec);
521     }
522     if (fmt->audio_codec != AV_CODEC_ID_NONE) {
523         audio_st = add_stream(oc, &audio_codec, fmt->audio_codec);
524     }
525
526     /* Now that all the parameters are set, we can open the audio and
527      * video codecs and allocate the necessary encode buffers. */
528     if (video_st)
529         open_video(oc, video_codec, video_st);
530     if (audio_st)
531         open_audio(oc, audio_codec, audio_st);
532
533     av_dump_format(oc, 0, filename, 1);
534
535     /* open the output file, if needed */
536     if (!(fmt->flags & AVFMT_NOFILE)) {
537         ret = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE);
538         if (ret < 0) {
539             fprintf(stderr, "Could not open '%s': %s\n", filename,
540                     av_err2str(ret));
541             return 1;
542         }
543     }
544
545     /* Write the stream header, if any. */
546     ret = avformat_write_header(oc, NULL);
547     if (ret < 0) {
548         fprintf(stderr, "Error occurred when opening output file: %s\n",
549                 av_err2str(ret));
550         return 1;
551     }
552
553     for (;;) {
554         /* Compute current audio and video time. */
555         audio_time = audio_st ? audio_st->pts.val * av_q2d(audio_st->time_base) : 0.0;
556         video_time = video_st ? video_st->pts.val * av_q2d(video_st->time_base) : 0.0;
557
558         if ((!audio_st || audio_time >= STREAM_DURATION) &&
559             (!video_st || video_time >= STREAM_DURATION))
560             break;
561
562         /* write interleaved audio and video frames */
563         if (!video_st || (video_st && audio_st && audio_time < video_time)) {
564             write_audio_frame(oc, audio_st);
565         } else {
566             write_video_frame(oc, video_st);
567         }
568     }
569
570     /* Write the trailer, if any. The trailer must be written before you
571      * close the CodecContexts open when you wrote the header; otherwise
572      * av_write_trailer() may try to use memory that was freed on
573      * av_codec_close(). */
574     av_write_trailer(oc);
575
576     /* Close each codec. */
577     if (video_st)
578         close_video(oc, video_st);
579     if (audio_st)
580         close_audio(oc, audio_st);
581
582     if (!(fmt->flags & AVFMT_NOFILE))
583         /* Close the output file. */
584         avio_close(oc->pb);
585
586     /* free the stream */
587     avformat_free_context(oc);
588
589     return 0;
590 }