git.sesse.net Git - ffmpeg/blob - doc/examples/muxing-example.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: Output a media file in any supported
  26  * libavformat format. The default codecs are used.
  27  */
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <math.h>
  33
  34 #include "libavformat/avformat.h"
  35 #include "libswscale/swscale.h"
  36
  37 #undef exit
  38
  39 /* 5 seconds stream duration */
  40 #define STREAM_DURATION   5.0
  41 #define STREAM_FRAME_RATE 25 /* 25 images/s */
  42 #define STREAM_NB_FRAMES  ((int)(STREAM_DURATION * STREAM_FRAME_RATE))
  43 #define STREAM_PIX_FMT PIX_FMT_YUV420P /* default pix_fmt */
  44
  45 static int sws_flags = SWS_BICUBIC;
  46
  47 /**************************************************************/
  48 /* audio output */
  49
  50 float t, tincr, tincr2;
  51 int16_t *samples;
  52 uint8_t *audio_outbuf;
  53 int audio_outbuf_size;
  54 int audio_input_frame_size;
  55
  56 /*
  57  * add an audio output stream
  58  */
  59 static AVStream *add_audio_stream(AVFormatContext *oc, enum CodecID codec_id)
  60 {
  61     AVCodecContext *c;
  62     AVStream *st;
  63
  64     st = av_new_stream(oc, 1);
  65     if (!st) {
  66         fprintf(stderr, "Could not alloc stream\n");
  67         exit(1);
  68     }
  69
  70     c = st->codec;
  71     c->codec_id = codec_id;
  72     c->codec_type = AVMEDIA_TYPE_AUDIO;
  73
  74     /* put sample parameters */
  75     c->sample_fmt = AV_SAMPLE_FMT_S16;
  76     c->bit_rate = 64000;
  77     c->sample_rate = 44100;
  78     c->channels = 2;
  79
  80     // some formats want stream headers to be separate
  81     if(oc->oformat->flags & AVFMT_GLOBALHEADER)
  82         c->flags |= CODEC_FLAG_GLOBAL_HEADER;
  83
  84     return st;
  85 }
  86
  87 static void open_audio(AVFormatContext *oc, AVStream *st)
  88 {
  89     AVCodecContext *c;
  90     AVCodec *codec;
  91
  92     c = st->codec;
  93
  94     /* find the audio encoder */
  95     codec = avcodec_find_encoder(c->codec_id);
  96     if (!codec) {
  97         fprintf(stderr, "codec not found\n");
  98         exit(1);
  99     }
 100
 101     /* open it */
 102     if (avcodec_open(c, codec) < 0) {
 103         fprintf(stderr, "could not open codec\n");
 104         exit(1);
 105     }
 106
 107     /* init signal generator */
 108     t = 0;
 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;
 112
 113     audio_outbuf_size = 10000;
 114     audio_outbuf = av_malloc(audio_outbuf_size);
 115
 116     /* ugly hack for PCM codecs (will be removed ASAP with new PCM
 117        support to compute the input frame size in samples */
 118     if (c->frame_size <= 1) {
 119         audio_input_frame_size = audio_outbuf_size / c->channels;
 120         switch(st->codec->codec_id) {
 121         case CODEC_ID_PCM_S16LE:
 122         case CODEC_ID_PCM_S16BE:
 123         case CODEC_ID_PCM_U16LE:
 124         case CODEC_ID_PCM_U16BE:
 125             audio_input_frame_size >>= 1;
 126             break;
 127         default:
 128             break;
 129         }
 130     } else {
 131         audio_input_frame_size = c->frame_size;
 132     }
 133     samples = av_malloc(audio_input_frame_size * 2 * c->channels);
 134 }
 135
 136 /* prepare a 16 bit dummy audio frame of 'frame_size' samples and
 137    'nb_channels' channels */
 138 static void get_audio_frame(int16_t *samples, int frame_size, int nb_channels)
 139 {
 140     int j, i, v;
 141     int16_t *q;
 142
 143     q = samples;
 144     for(j=0;j<frame_size;j++) {
 145         v = (int)(sin(t) * 10000);
 146         for(i = 0; i < nb_channels; i++)
 147             *q++ = v;
 148         t += tincr;
 149         tincr += tincr2;
 150     }
 151 }
 152
 153 static void write_audio_frame(AVFormatContext *oc, AVStream *st)
 154 {
 155     AVCodecContext *c;
 156     AVPacket pkt;
 157     av_init_packet(&pkt);
 158
 159     c = st->codec;
 160
 161     get_audio_frame(samples, audio_input_frame_size, c->channels);
 162
 163     pkt.size= avcodec_encode_audio(c, audio_outbuf, audio_outbuf_size, samples);
 164
 165     if (c->coded_frame && c->coded_frame->pts != AV_NOPTS_VALUE)
 166         pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
 167     pkt.flags |= AV_PKT_FLAG_KEY;
 168     pkt.stream_index= st->index;
 169     pkt.data= audio_outbuf;
 170
 171     /* write the compressed frame in the media file */
 172     if (av_interleaved_write_frame(oc, &pkt) != 0) {
 173         fprintf(stderr, "Error while writing audio frame\n");
 174         exit(1);
 175     }
 176 }
 177
 178 static void close_audio(AVFormatContext *oc, AVStream *st)
 179 {
 180     avcodec_close(st->codec);
 181
 182     av_free(samples);
 183     av_free(audio_outbuf);
 184 }
 185
 186 /**************************************************************/
 187 /* video output */
 188
 189 AVFrame *picture, *tmp_picture;
 190 uint8_t *video_outbuf;
 191 int frame_count, video_outbuf_size;
 192
 193 /* add a video output stream */
 194 static AVStream *add_video_stream(AVFormatContext *oc, enum CodecID codec_id)
 195 {
 196     AVCodecContext *c;
 197     AVStream *st;
 198
 199     st = av_new_stream(oc, 0);
 200     if (!st) {
 201         fprintf(stderr, "Could not alloc stream\n");
 202         exit(1);
 203     }
 204
 205     c = st->codec;
 206     c->codec_id = codec_id;
 207     c->codec_type = AVMEDIA_TYPE_VIDEO;
 208
 209     /* put sample parameters */
 210     c->bit_rate = 400000;
 211     /* resolution must be a multiple of two */
 212     c->width = 352;
 213     c->height = 288;
 214     /* time base: this is the fundamental unit of time (in seconds) in terms
 215        of which frame timestamps are represented. for fixed-fps content,
 216        timebase should be 1/framerate and timestamp increments should be
 217        identically 1. */
 218     c->time_base.den = STREAM_FRAME_RATE;
 219     c->time_base.num = 1;
 220     c->gop_size = 12; /* emit one intra frame every twelve frames at most */
 221     c->pix_fmt = STREAM_PIX_FMT;
 222     if (c->codec_id == CODEC_ID_MPEG2VIDEO) {
 223         /* just for testing, we also add B frames */
 224         c->max_b_frames = 2;
 225     }
 226     if (c->codec_id == CODEC_ID_MPEG1VIDEO){
 227         /* Needed to avoid using macroblocks in which some coeffs overflow.
 228            This does not happen with normal video, it just happens here as
 229            the motion of the chroma plane does not match the luma plane. */
 230         c->mb_decision=2;
 231     }
 232     // some formats want stream headers to be separate
 233     if(oc->oformat->flags & AVFMT_GLOBALHEADER)
 234         c->flags |= CODEC_FLAG_GLOBAL_HEADER;
 235
 236     return st;
 237 }
 238
 239 static AVFrame *alloc_picture(enum PixelFormat pix_fmt, int width, int height)
 240 {
 241     AVFrame *picture;
 242     uint8_t *picture_buf;
 243     int size;
 244
 245     picture = avcodec_alloc_frame();
 246     if (!picture)
 247         return NULL;
 248     size = avpicture_get_size(pix_fmt, width, height);
 249     picture_buf = av_malloc(size);
 250     if (!picture_buf) {
 251         av_free(picture);
 252         return NULL;
 253     }
 254     avpicture_fill((AVPicture *)picture, picture_buf,
 255                    pix_fmt, width, height);
 256     return picture;
 257 }
 258
 259 static void open_video(AVFormatContext *oc, AVStream *st)
 260 {
 261     AVCodec *codec;
 262     AVCodecContext *c;
 263
 264     c = st->codec;
 265
 266     /* find the video encoder */
 267     codec = avcodec_find_encoder(c->codec_id);
 268     if (!codec) {
 269         fprintf(stderr, "codec not found\n");
 270         exit(1);
 271     }
 272
 273     /* open the codec */
 274     if (avcodec_open(c, codec) < 0) {
 275         fprintf(stderr, "could not open codec\n");
 276         exit(1);
 277     }
 278
 279     video_outbuf = NULL;
 280     if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {
 281         /* allocate output buffer */
 282         /* XXX: API change will be done */
 283         /* buffers passed into lav* can be allocated any way you prefer,
 284            as long as they're aligned enough for the architecture, and
 285            they're freed appropriately (such as using av_free for buffers
 286            allocated with av_malloc) */
 287         video_outbuf_size = 200000;
 288         video_outbuf = av_malloc(video_outbuf_size);
 289     }
 290
 291     /* allocate the encoded raw picture */
 292     picture = alloc_picture(c->pix_fmt, c->width, c->height);
 293     if (!picture) {
 294         fprintf(stderr, "Could not allocate picture\n");
 295         exit(1);
 296     }
 297
 298     /* if the output format is not YUV420P, then a temporary YUV420P
 299        picture is needed too. It is then converted to the required
 300        output format */
 301     tmp_picture = NULL;
 302     if (c->pix_fmt != PIX_FMT_YUV420P) {
 303         tmp_picture = alloc_picture(PIX_FMT_YUV420P, c->width, c->height);
 304         if (!tmp_picture) {
 305             fprintf(stderr, "Could not allocate temporary picture\n");
 306             exit(1);
 307         }
 308     }
 309 }
 310
 311 /* prepare a dummy image */
 312 static void fill_yuv_image(AVFrame *pict, int frame_index, int width, int height)
 313 {
 314     int x, y, i;
 315
 316     i = frame_index;
 317
 318     /* Y */
 319     for(y=0;y<height;y++) {
 320         for(x=0;x<width;x++) {
 321             pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
 322         }
 323     }
 324
 325     /* Cb and Cr */
 326     for(y=0;y<height/2;y++) {
 327         for(x=0;x<width/2;x++) {
 328             pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
 329             pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
 330         }
 331     }
 332 }
 333
 334 static void write_video_frame(AVFormatContext *oc, AVStream *st)
 335 {
 336     int out_size, ret;
 337     AVCodecContext *c;
 338     static struct SwsContext *img_convert_ctx;
 339
 340     c = st->codec;
 341
 342     if (frame_count >= STREAM_NB_FRAMES) {
 343         /* no more frame to compress. The codec has a latency of a few
 344            frames if using B frames, so we get the last frames by
 345            passing the same picture again */
 346     } else {
 347         if (c->pix_fmt != PIX_FMT_YUV420P) {
 348             /* as we only generate a YUV420P picture, we must convert it
 349                to the codec pixel format if needed */
 350             if (img_convert_ctx == NULL) {
 351                 img_convert_ctx = sws_getContext(c->width, c->height,
 352                                                  PIX_FMT_YUV420P,
 353                                                  c->width, c->height,
 354                                                  c->pix_fmt,
 355                                                  sws_flags, NULL, NULL, NULL);
 356                 if (img_convert_ctx == NULL) {
 357                     fprintf(stderr, "Cannot initialize the conversion context\n");
 358                     exit(1);
 359                 }
 360             }
 361             fill_yuv_image(tmp_picture, frame_count, c->width, c->height);
 362             sws_scale(img_convert_ctx, tmp_picture->data, tmp_picture->linesize,
 363                       0, c->height, picture->data, picture->linesize);
 364         } else {
 365             fill_yuv_image(picture, frame_count, c->width, c->height);
 366         }
 367     }
 368
 369
 370     if (oc->oformat->flags & AVFMT_RAWPICTURE) {
 371         /* raw video case. The API will change slightly in the near
 372            futur for that */
 373         AVPacket pkt;
 374         av_init_packet(&pkt);
 375
 376         pkt.flags |= AV_PKT_FLAG_KEY;
 377         pkt.stream_index= st->index;
 378         pkt.data= (uint8_t *)picture;
 379         pkt.size= sizeof(AVPicture);
 380
 381         ret = av_interleaved_write_frame(oc, &pkt);
 382     } else {
 383         /* encode the image */
 384         out_size = avcodec_encode_video(c, video_outbuf, video_outbuf_size, picture);
 385         /* if zero size, it means the image was buffered */
 386         if (out_size > 0) {
 387             AVPacket pkt;
 388             av_init_packet(&pkt);
 389
 390             if (c->coded_frame->pts != AV_NOPTS_VALUE)
 391                 pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
 392             if(c->coded_frame->key_frame)
 393                 pkt.flags |= AV_PKT_FLAG_KEY;
 394             pkt.stream_index= st->index;
 395             pkt.data= video_outbuf;
 396             pkt.size= out_size;
 397
 398             /* write the compressed frame in the media file */
 399             ret = av_interleaved_write_frame(oc, &pkt);
 400         } else {
 401             ret = 0;
 402         }
 403     }
 404     if (ret != 0) {
 405         fprintf(stderr, "Error while writing video frame\n");
 406         exit(1);
 407     }
 408     frame_count++;
 409 }
 410
 411 static void close_video(AVFormatContext *oc, AVStream *st)
 412 {
 413     avcodec_close(st->codec);
 414     av_free(picture->data[0]);
 415     av_free(picture);
 416     if (tmp_picture) {
 417         av_free(tmp_picture->data[0]);
 418         av_free(tmp_picture);
 419     }
 420     av_free(video_outbuf);
 421 }
 422
 423 /**************************************************************/
 424 /* media file output */
 425
 426 int main(int argc, char **argv)
 427 {
 428     const char *filename;
 429     AVOutputFormat *fmt;
 430     AVFormatContext *oc;
 431     AVStream *audio_st, *video_st;
 432     double audio_pts, video_pts;
 433     int i;
 434
 435     /* initialize libavcodec, and register all codecs and formats */
 436     av_register_all();
 437
 438     if (argc != 2) {
 439         printf("usage: %s output_file\n"
 440                "API example program to output a media file with libavformat.\n"
 441                "The output format is automatically guessed according to the file extension.\n"
 442                "Raw images can also be output by using '%%d' in the filename\n"
 443                "\n", argv[0]);
 444         exit(1);
 445     }
 446
 447     filename = argv[1];
 448
 449     /* allocate the output media context */
 450     avformat_alloc_output_context2(&oc, NULL, NULL, filename);
 451     if (!oc) {
 452         printf("Could not deduce output format from file extension: using MPEG.\n");
 453         avformat_alloc_output_context2(&oc, NULL, "mpeg", filename);
 454     }
 455     if (!oc) {
 456         exit(1);
 457     }
 458     fmt= oc->oformat;
 459
 460     /* add the audio and video streams using the default format codecs
 461        and initialize the codecs */
 462     video_st = NULL;
 463     audio_st = NULL;
 464     if (fmt->video_codec != CODEC_ID_NONE) {
 465         video_st = add_video_stream(oc, fmt->video_codec);
 466     }
 467     if (fmt->audio_codec != CODEC_ID_NONE) {
 468         audio_st = add_audio_stream(oc, fmt->audio_codec);
 469     }
 470
 471     av_dump_format(oc, 0, filename, 1);
 472
 473     /* now that all the parameters are set, we can open the audio and
 474        video codecs and allocate the necessary encode buffers */
 475     if (video_st)
 476         open_video(oc, video_st);
 477     if (audio_st)
 478         open_audio(oc, audio_st);
 479
 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);
 484             exit(1);
 485         }
 486     }
 487
 488     /* write the stream header, if any */
 489     av_write_header(oc);
 490
 491     for(;;) {
 492         /* compute current audio and video time */
 493         if (audio_st)
 494             audio_pts = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
 495         else
 496             audio_pts = 0.0;
 497
 498         if (video_st)
 499             video_pts = (double)video_st->pts.val * video_st->time_base.num / video_st->time_base.den;
 500         else
 501             video_pts = 0.0;
 502
 503         if ((!audio_st || audio_pts >= STREAM_DURATION) &&
 504             (!video_st || video_pts >= STREAM_DURATION))
 505             break;
 506
 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);
 510         } else {
 511             write_video_frame(oc, video_st);
 512         }
 513     }
 514
 515     /* write the trailer, if any.  the trailer must be written
 516      * before you close the CodecContexts open when you wrote the
 517      * header; otherwise write_trailer may try to use memory that
 518      * was freed on av_codec_close() */
 519     av_write_trailer(oc);
 520
 521     /* close each codec */
 522     if (video_st)
 523         close_video(oc, video_st);
 524     if (audio_st)
 525         close_audio(oc, audio_st);
 526
 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]);
 531     }
 532
 533     if (!(fmt->flags & AVFMT_NOFILE)) {
 534         /* close the output file */
 535         avio_close(oc->pb);
 536     }
 537
 538     /* free the stream */
 539     av_free(oc);
 540
 541     return 0;
 542 }