Merge commit '9d3009c6c4b9b6734f07df7c88f6a42ded6cdf38'
[ffmpeg.git] / doc / examples / muxing.c
index c6b0294..7305cc6 100644 (file)
@@ -26,6 +26,7 @@
  *
  * Output a media file in any supported libavformat format.
  * The default codecs are used.
+ * @example doc/examples/muxing.c
  */
 
 #include <stdlib.h>
@@ -52,19 +53,18 @@ static float t, tincr, tincr2;
 static int16_t *samples;
 static int audio_input_frame_size;
 
-/*
- * add an audio output stream
- */
-static AVStream *add_audio_stream(AVFormatContext *oc, AVCodec **codec,
-                                  enum AVCodecID codec_id)
+/* Add an output stream. */
+static AVStream *add_stream(AVFormatContext *oc, AVCodec **codec,
+                            enum AVCodecID codec_id)
 {
     AVCodecContext *c;
     AVStream *st;
 
-    /* find the audio encoder */
+    /* find the encoder */
     *codec = avcodec_find_encoder(codec_id);
     if (!(*codec)) {
-        fprintf(stderr, "Could not find codec\n");
+        fprintf(stderr, "Could not find encoder for '%s'\n",
+                avcodec_get_name(codec_id));
         exit(1);
     }
 
@@ -73,32 +73,74 @@ static AVStream *add_audio_stream(AVFormatContext *oc, AVCodec **codec,
         fprintf(stderr, "Could not allocate stream\n");
         exit(1);
     }
-    st->id = 1;
-
+    st->id = oc->nb_streams-1;
     c = st->codec;
 
-    /* put sample parameters */
-    c->sample_fmt  = AV_SAMPLE_FMT_S16;
-    c->bit_rate    = 64000;
-    c->sample_rate = 44100;
-    c->channels    = 2;
+    switch ((*codec)->type) {
+    case AVMEDIA_TYPE_AUDIO:
+        st->id = 1;
+        c->sample_fmt  = AV_SAMPLE_FMT_S16;
+        c->bit_rate    = 64000;
+        c->sample_rate = 44100;
+        c->channels    = 2;
+        break;
+
+    case AVMEDIA_TYPE_VIDEO:
+        c->codec_id = codec_id;
+
+        c->bit_rate = 400000;
+        /* Resolution must be a multiple of two. */
+        c->width    = 352;
+        c->height   = 288;
+        /* timebase: This is the fundamental unit of time (in seconds) in terms
+         * of which frame timestamps are represented. For fixed-fps content,
+         * timebase should be 1/framerate and timestamp increments should be
+         * identical to 1. */
+        c->time_base.den = STREAM_FRAME_RATE;
+        c->time_base.num = 1;
+        c->gop_size      = 12; /* emit one intra frame every twelve frames at most */
+        c->pix_fmt       = STREAM_PIX_FMT;
+        if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
+            /* just for testing, we also add B frames */
+            c->max_b_frames = 2;
+        }
+        if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
+            /* Needed to avoid using macroblocks in which some coeffs overflow.
+             * This does not happen with normal video, it just happens here as
+             * the motion of the chroma plane does not match the luma plane. */
+            c->mb_decision = 2;
+        }
+    break;
+
+    default:
+        break;
+    }
 
-    // some formats want stream headers to be separate
+    /* Some formats want stream headers to be separate. */
     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
         c->flags |= CODEC_FLAG_GLOBAL_HEADER;
 
     return st;
 }
 
+/**************************************************************/
+/* audio output */
+
+static float t, tincr, tincr2;
+static int16_t *samples;
+static int audio_input_frame_size;
+
 static void open_audio(AVFormatContext *oc, AVCodec *codec, AVStream *st)
 {
     AVCodecContext *c;
+    int ret;
 
     c = st->codec;
 
     /* open it */
-    if (avcodec_open2(c, codec, NULL) < 0) {
-        fprintf(stderr, "Could not open codec\n");
+    ret = avcodec_open2(c, codec, NULL);
+    if (ret < 0) {
+        fprintf(stderr, "Could not open audio codec: %s\n", av_err2str(ret));
         exit(1);
     }
 
@@ -158,7 +200,7 @@ static void write_audio_frame(AVFormatContext *oc, AVStream *st)
 
     ret = avcodec_encode_audio2(c, &pkt, frame, &got_packet);
     if (ret < 0) {
-        fprintf(stderr, "Error encoding audio frame\n");
+        fprintf(stderr, "Error encoding audio frame: %s\n", av_err2str(ret));
         exit(1);
     }
 
@@ -168,8 +210,10 @@ static void write_audio_frame(AVFormatContext *oc, AVStream *st)
     pkt.stream_index = st->index;
 
     /* Write the compressed frame to the media file. */
-    if (av_interleaved_write_frame(oc, &pkt) != 0) {
-        fprintf(stderr, "Error while writing audio frame\n");
+    ret = av_interleaved_write_frame(oc, &pkt);
+    if (ret != 0) {
+        fprintf(stderr, "Error while writing audio frame: %s\n",
+                av_err2str(ret));
         exit(1);
     }
     avcodec_free_frame(&frame);
@@ -187,64 +231,7 @@ static void close_audio(AVFormatContext *oc, AVStream *st)
 
 static AVFrame *frame;
 static AVPicture src_picture, dst_picture;
-static uint8_t *video_outbuf;
-static int frame_count, video_outbuf_size;
-
-/* Add a video output stream. */
-static AVStream *add_video_stream(AVFormatContext *oc, AVCodec **codec,
-                                  enum AVCodecID codec_id)
-{
-    AVCodecContext *c;
-    AVStream *st;
-
-    /* find the video encoder */
-    *codec = avcodec_find_encoder(codec_id);
-    if (!(*codec)) {
-        fprintf(stderr, "codec not found\n");
-        exit(1);
-    }
-
-    st = avformat_new_stream(oc, *codec);
-    if (!st) {
-        fprintf(stderr, "Could not alloc stream\n");
-        exit(1);
-    }
-
-    c = st->codec;
-
-    avcodec_get_context_defaults3(c, *codec);
-
-    c->codec_id = codec_id;
-
-    /* Put sample parameters. */
-    c->bit_rate = 400000;
-    /* Resolution must be a multiple of two. */
-    c->width    = 352;
-    c->height   = 288;
-    /* timebase: This is the fundamental unit of time (in seconds) in terms
-     * of which frame timestamps are represented. For fixed-fps content,
-     * timebase should be 1/framerate and timestamp increments should be
-     * identical to 1. */
-    c->time_base.den = STREAM_FRAME_RATE;
-    c->time_base.num = 1;
-    c->gop_size      = 12; /* emit one intra frame every twelve frames at most */
-    c->pix_fmt       = STREAM_PIX_FMT;
-    if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
-        /* just for testing, we also add B frames */
-        c->max_b_frames = 2;
-    }
-    if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
-        /* Needed to avoid using macroblocks in which some coeffs overflow.
-         * This does not happen with normal video, it just happens here as
-         * the motion of the chroma plane does not match the luma plane. */
-        c->mb_decision = 2;
-    }
-    /* Some formats want stream headers to be separate. */
-    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
-        c->flags |= CODEC_FLAG_GLOBAL_HEADER;
-
-    return st;
-}
+static int frame_count;
 
 static void open_video(AVFormatContext *oc, AVCodec *codec, AVStream *st)
 {
@@ -252,23 +239,12 @@ static void open_video(AVFormatContext *oc, AVCodec *codec, AVStream *st)
     AVCodecContext *c = st->codec;
 
     /* open the codec */
-    if (avcodec_open2(c, codec, NULL) < 0) {
-        fprintf(stderr, "Could not open codec\n");
+    ret = avcodec_open2(c, codec, NULL);
+    if (ret < 0) {
+        fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));
         exit(1);
     }
 
-    video_outbuf = NULL;
-    if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {
-        /* Allocate output buffer. */
-        /* XXX: API change will be done. */
-        /* Buffers passed into lav* can be allocated any way you prefer,
-         * as long as they're aligned enough for the architecture, and
-         * they're freed appropriately (such as using av_free for buffers
-         * allocated with av_malloc). */
-        video_outbuf_size = 200000;
-        video_outbuf      = av_malloc(video_outbuf_size);
-    }
-
     /* allocate and init a re-usable frame */
     frame = avcodec_alloc_frame();
     if (!frame) {
@@ -279,7 +255,7 @@ static void open_video(AVFormatContext *oc, AVCodec *codec, AVStream *st)
     /* Allocate the encoded raw picture. */
     ret = avpicture_alloc(&dst_picture, c->pix_fmt, c->width, c->height);
     if (ret < 0) {
-        fprintf(stderr, "Could not allocate picture\n");
+        fprintf(stderr, "Could not allocate picture: %s\n", av_err2str(ret));
         exit(1);
     }
 
@@ -289,7 +265,8 @@ static void open_video(AVFormatContext *oc, AVCodec *codec, AVStream *st)
     if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
         ret = avpicture_alloc(&src_picture, AV_PIX_FMT_YUV420P, c->width, c->height);
         if (ret < 0) {
-            fprintf(stderr, "Could not allocate temporary picture\n");
+            fprintf(stderr, "Could not allocate temporary picture: %s\n",
+                    av_err2str(ret));
             exit(1);
         }
     }
@@ -354,8 +331,7 @@ static void write_video_frame(AVFormatContext *oc, AVStream *st)
     }
 
     if (oc->oformat->flags & AVFMT_RAWPICTURE) {
-        /* Raw video case - the API will change slightly in the near
-         * future for that. */
+        /* Raw video case - directly store the picture in the packet */
         AVPacket pkt;
         av_init_packet(&pkt);
 
@@ -366,28 +342,19 @@ static void write_video_frame(AVFormatContext *oc, AVStream *st)
 
         ret = av_interleaved_write_frame(oc, &pkt);
     } else {
-        /* encode the image */
-        AVPacket pkt;
-        int got_output;
-
+        AVPacket pkt = { 0 };
+        int got_packet;
         av_init_packet(&pkt);
-        pkt.data = NULL;    // packet data will be allocated by the encoder
-        pkt.size = 0;
 
-        ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
+        /* encode the image */
+        ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);
         if (ret < 0) {
-            fprintf(stderr, "Error encoding video frame\n");
+            fprintf(stderr, "Error encoding video frame: %s\n", av_err2str(ret));
             exit(1);
         }
-
         /* If size is zero, it means the image was buffered. */
-        if (got_output) {
-            if (c->coded_frame->pts != AV_NOPTS_VALUE)
-                pkt.pts = av_rescale_q(c->coded_frame->pts,
-                                       c->time_base, st->time_base);
-            if (c->coded_frame->key_frame)
-                pkt.flags |= AV_PKT_FLAG_KEY;
 
+        if (!ret && got_packet && pkt.size) {
             pkt.stream_index = st->index;
 
             /* Write the compressed frame to the media file. */
@@ -397,7 +364,7 @@ static void write_video_frame(AVFormatContext *oc, AVStream *st)
         }
     }
     if (ret != 0) {
-        fprintf(stderr, "Error while writing video frame\n");
+        fprintf(stderr, "Error while writing video frame: %s\n", av_err2str(ret));
         exit(1);
     }
     frame_count++;
@@ -409,7 +376,6 @@ static void close_video(AVFormatContext *oc, AVStream *st)
     av_free(src_picture.data[0]);
     av_free(dst_picture.data[0]);
     av_free(frame);
-    av_free(video_outbuf);
 }
 
 /**************************************************************/
@@ -423,7 +389,7 @@ int main(int argc, char **argv)
     AVStream *audio_st, *video_st;
     AVCodec *audio_codec, *video_codec;
     double audio_pts, video_pts;
-    int i;
+    int ret;
 
     /* Initialize libavcodec, and register all codecs and formats. */
     av_register_all();
@@ -431,8 +397,10 @@ int main(int argc, char **argv)
     if (argc != 2) {
         printf("usage: %s output_file\n"
                "API example program to output a media file with libavformat.\n"
+               "This program generates a synthetic audio and video stream, encodes and\n"
+               "muxes them into a file named output_file.\n"
                "The output format is automatically guessed according to the file extension.\n"
-               "Raw images can also be output by using '%%d' in the filename\n"
+               "Raw images can also be output by using '%%d' in the filename.\n"
                "\n", argv[0]);
         return 1;
     }
@@ -454,11 +422,12 @@ int main(int argc, char **argv)
      * and initialize the codecs. */
     video_st = NULL;
     audio_st = NULL;
+
     if (fmt->video_codec != AV_CODEC_ID_NONE) {
-        video_st = add_video_stream(oc, &video_codec, fmt->video_codec);
+        video_st = add_stream(oc, &video_codec, fmt->video_codec);
     }
     if (fmt->audio_codec != AV_CODEC_ID_NONE) {
-        audio_st = add_audio_stream(oc, &audio_codec, fmt->audio_codec);
+        audio_st = add_stream(oc, &audio_codec, fmt->audio_codec);
     }
 
     /* Now that all the parameters are set, we can open the audio and
@@ -472,19 +441,24 @@ int main(int argc, char **argv)
 
     /* open the output file, if needed */
     if (!(fmt->flags & AVFMT_NOFILE)) {
-        if (avio_open(&oc->pb, filename, AVIO_FLAG_WRITE) < 0) {
-            fprintf(stderr, "Could not open '%s'\n", filename);
+        ret = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE);
+        if (ret < 0) {
+            fprintf(stderr, "Could not open '%s': %s\n", filename,
+                    av_err2str(ret));
             return 1;
         }
     }
 
     /* Write the stream header, if any. */
-    if (avformat_write_header(oc, NULL) < 0) {
-        fprintf(stderr, "Error occurred when opening output file\n");
+    ret = avformat_write_header(oc, NULL);
+    if (ret < 0) {
+        fprintf(stderr, "Error occurred when opening output file: %s\n",
+                av_err2str(ret));
         return 1;
     }
 
-    frame->pts = 0;
+    if (frame)
+        frame->pts = 0;
     for (;;) {
         /* Compute current audio and video time. */
         if (audio_st)
@@ -507,7 +481,7 @@ int main(int argc, char **argv)
             write_audio_frame(oc, audio_st);
         } else {
             write_video_frame(oc, video_st);
-            frame->pts++;
+            frame->pts += av_rescale_q(1, video_st->codec->time_base, video_st->time_base);
         }
     }
 
@@ -523,18 +497,12 @@ int main(int argc, char **argv)
     if (audio_st)
         close_audio(oc, audio_st);
 
-    /* Free the streams. */
-    for (i = 0; i < oc->nb_streams; i++) {
-        av_freep(&oc->streams[i]->codec);
-        av_freep(&oc->streams[i]);
-    }
-
     if (!(fmt->flags & AVFMT_NOFILE))
         /* Close the output file. */
         avio_close(oc->pb);
 
     /* free the stream */
-    av_free(oc);
+    avformat_free_context(oc);
 
     return 0;
 }