• 深入理解FFmpeg--libavformat接口使用(一)

    libavformat（lavf）是一个用于处理各种媒体容器格式的库。它的主要两个目的是去复用（即将媒体文件拆分为组件流）和复用的反向过程（以指定的容器格式写入提供的数据）。它还有一个I/O模块，支持多种访问数据的协议（如文件、tcp、http等）。在使用lavf之前，您需要调用av_register_all（）来注册所有已编译的复用器、解复用器和协议。除非您绝对确定不会使用libavformat的网络功能，否则还应该调用avformat_network_init（）；

    一、媒体流封装（Muxing）

    媒体流封装主要是指以AVPackets的形式获取编码后的数据后，以指定的容器格式将其写入到文件或者其他方式输出到字节流中。

    Muxing实际执行的主要API有：

    初始化：avformat_alloc_output_context2();

    创建媒体流（如果有的话）：avformat_new_stream()；

    写文件头：avformat_write_header()；

    写数据包：av_write_frame()/av_interleaved_write_frame();

    写文件尾：av_write_trailer();

    流程图：

    代码示例：

    在官方源码：/doc/examples/muxing.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15.  
    16. #define STREAM_DURATION   10.0
    17. #define STREAM_FRAME_RATE 25 /* 25 images/s */
    18. #define STREAM_PIX_FMT    AV_PIX_FMT_YUV420P /* default pix_fmt */
    19.  
    20. #define SCALE_FLAGS SWS_BICUBIC
    21.  
    22. // a wrapper around a single output AVStream
    23. typedef struct OutputStream {
    24.     AVStream *st;
    25.     AVCodecContext *enc;
    26.  
    27.     /* pts of the next frame that will be generated */
    28.     int64_t next_pts;
    29.     int samples_count;
    30.  
    31.     AVFrame *frame;
    32.     AVFrame *tmp_frame;
    33.  
    34.     AVPacket *tmp_pkt;
    35.  
    36.     float t, tincr, tincr2;
    37.  
    38.     struct SwsContext *sws_ctx;
    39.     struct SwrContext *swr_ctx;
    40. } OutputStream;
    41.  
    42. static void log_packet(const AVFormatContext *fmt_ctx, const AVPacket *pkt)
    43. {
    44.     AVRational *time_base = &fmt_ctx->streams[pkt->stream_index]->time_base;
    45.  
    46.     printf("pts:%s pts_time:%s dts:%s dts_time:%s duration:%s duration_time:%s stream_index:%d\n",
    47.            av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, time_base),
    48.            av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, time_base),
    49.            av_ts2str(pkt->duration), av_ts2timestr(pkt->duration, time_base),
    50.            pkt->stream_index);
    51. }
    52.  
    53. static int write_frame(AVFormatContext *fmt_ctx, AVCodecContext *c,
    54.                        AVStream *st, AVFrame *frame, AVPacket *pkt)
    55. {
    56.     int ret;
    57.  
    58.     // send the frame to the encoder
    59.     ret = avcodec_send_frame(c, frame);
    60.     if (ret < 0) {
    61.         fprintf(stderr, "Error sending a frame to the encoder: %s\n",
    62.                 av_err2str(ret));
    63.         exit(1);
    64.     }
    65.  
    66.     while (ret >= 0) {
    67.         ret = avcodec_receive_packet(c, pkt);
    68.         if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
    69.             break;
    70.         else if (ret < 0) {
    71.             fprintf(stderr, "Error encoding a frame: %s\n", av_err2str(ret));
    72.             exit(1);
    73.         }
    74.  
    75.         /* rescale output packet timestamp values from codec to stream timebase */
    76.         av_packet_rescale_ts(pkt, c->time_base, st->time_base);
    77.         pkt->stream_index = st->index;
    78.  
    79.         /* Write the compressed frame to the media file. */
    80.         log_packet(fmt_ctx, pkt);
    81.         ret = av_interleaved_write_frame(fmt_ctx, pkt);
    82.         /* pkt is now blank (av_interleaved_write_frame() takes ownership of
    83.          * its contents and resets pkt), so that no unreferencing is necessary.
    84.          * This would be different if one used av_write_frame(). */
    85.         if (ret < 0) {
    86.             fprintf(stderr, "Error while writing output packet: %s\n", av_err2str(ret));
    87.             exit(1);
    88.         }
    89.     }
    90.  
    91.     return ret == AVERROR_EOF ? 1 : 0;
    92. }
    93.  
    94. /* Add an output stream. */
    95. static void add_stream(OutputStream *ost, AVFormatContext *oc,
    96.                        const AVCodec **codec,
    97.                        enum AVCodecID codec_id)
    98. {
    99.     AVCodecContext *c;
    100.     int i;
    101.  
    102.     /* find the encoder */
    103.     *codec = avcodec_find_encoder(codec_id);
    104.     if (!(*codec)) {
    105.         fprintf(stderr, "Could not find encoder for '%s'\n",
    106.                 avcodec_get_name(codec_id));
    107.         exit(1);
    108.     }
    109.  
    110.     ost->tmp_pkt = av_packet_alloc();
    111.     if (!ost->tmp_pkt) {
    112.         fprintf(stderr, "Could not allocate AVPacket\n");
    113.         exit(1);
    114.     }
    115.  
    116.     ost->st = avformat_new_stream(oc, NULL);
    117.     if (!ost->st) {
    118.         fprintf(stderr, "Could not allocate stream\n");
    119.         exit(1);
    120.     }
    121.     ost->st->id = oc->nb_streams-1;
    122.     c = avcodec_alloc_context3(*codec);
    123.     if (!c) {
    124.         fprintf(stderr, "Could not alloc an encoding context\n");
    125.         exit(1);
    126.     }
    127.     ost->enc = c;
    128.  
    129.     switch ((*codec)->type) {
    130.     case AVMEDIA_TYPE_AUDIO:
    131.         c->sample_fmt  = (*codec)->sample_fmts ?
    132.             (*codec)->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;
    133.         c->bit_rate    = 64000;
    134.         c->sample_rate = 44100;
    135.         if ((*codec)->supported_samplerates) {
    136.             c->sample_rate = (*codec)->supported_samplerates[0];
    137.             for (i = 0; (*codec)->supported_samplerates[i]; i++) {
    138.                 if ((*codec)->supported_samplerates[i] == 44100)
    139.                     c->sample_rate = 44100;
    140.             }
    141.         }
    142.         c->channels        = av_get_channel_layout_nb_channels(c->channel_layout);
    143.         c->channel_layout = AV_CH_LAYOUT_STEREO;
    144.         if ((*codec)->channel_layouts) {
    145.             c->channel_layout = (*codec)->channel_layouts[0];
    146.             for (i = 0; (*codec)->channel_layouts[i]; i++) {
    147.                 if ((*codec)->channel_layouts[i] == AV_CH_LAYOUT_STEREO)
    148.                     c->channel_layout = AV_CH_LAYOUT_STEREO;
    149.             }
    150.         }
    151.         c->channels        = av_get_channel_layout_nb_channels(c->channel_layout);
    152.         ost->st->time_base = (AVRational){ 1, c->sample_rate };
    153.         break;
    154.  
    155.     case AVMEDIA_TYPE_VIDEO:
    156.         c->codec_id = codec_id;
    157.  
    158.         c->bit_rate = 400000;
    159.         /* Resolution must be a multiple of two. */
    160.         c->width    = 352;
    161.         c->height   = 288;
    162.         /* timebase: This is the fundamental unit of time (in seconds) in terms
    163.          * of which frame timestamps are represented. For fixed-fps content,
    164.          * timebase should be 1/framerate and timestamp increments should be
    165.          * identical to 1. */
    166.         ost->st->time_base = (AVRational){ 1, STREAM_FRAME_RATE };
    167.         c->time_base       = ost->st->time_base;
    168.  
    169.         c->gop_size      = 12; /* emit one intra frame every twelve frames at most */
    170.         c->pix_fmt       = STREAM_PIX_FMT;
    171.         if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
    172.             /* just for testing, we also add B-frames */
    173.             c->max_b_frames = 2;
    174.         }
    175.         if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
    176.             /* Needed to avoid using macroblocks in which some coeffs overflow.
    177.              * This does not happen with normal video, it just happens here as
    178.              * the motion of the chroma plane does not match the luma plane. */
    179.             c->mb_decision = 2;
    180.         }
    181.         break;
    182.  
    183.     default:
    184.         break;
    185.     }
    186.  
    187.     /* Some formats want stream headers to be separate. */
    188.     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
    189.         c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
    190. }
    191.  
    192. /**************************************************************/
    193. /* audio output */
    194.  
    195. static AVFrame *alloc_audio_frame(enum AVSampleFormat sample_fmt,
    196.                                   uint64_t channel_layout,
    197.                                   int sample_rate, int nb_samples)
    198. {
    199.     AVFrame *frame = av_frame_alloc();
    200.     int ret;
    201.  
    202.     if (!frame) {
    203.         fprintf(stderr, "Error allocating an audio frame\n");
    204.         exit(1);
    205.     }
    206.  
    207.     frame->format = sample_fmt;
    208.     frame->channel_layout = channel_layout;
    209.     frame->sample_rate = sample_rate;
    210.     frame->nb_samples = nb_samples;
    211.  
    212.     if (nb_samples) {
    213.         ret = av_frame_get_buffer(frame, 0);
    214.         if (ret < 0) {
    215.             fprintf(stderr, "Error allocating an audio buffer\n");
    216.             exit(1);
    217.         }
    218.     }
    219.  
    220.     return frame;
    221. }
    222.  
    223. static void open_audio(AVFormatContext *oc, const AVCodec *codec,
    224.                        OutputStream *ost, AVDictionary *opt_arg)
    225. {
    226.     AVCodecContext *c;
    227.     int nb_samples;
    228.     int ret;
    229.     AVDictionary *opt = NULL;
    230.  
    231.     c = ost->enc;
    232.  
    233.     /* open it */
    234.     av_dict_copy(&opt, opt_arg, 0);
    235.     ret = avcodec_open2(c, codec, &opt);
    236.     av_dict_free(&opt);
    237.     if (ret < 0) {
    238.         fprintf(stderr, "Could not open audio codec: %s\n", av_err2str(ret));
    239.         exit(1);
    240.     }
    241.  
    242.     /* init signal generator */
    243.     ost->t     = 0;
    244.     ost->tincr = 2 * M_PI * 110.0 / c->sample_rate;
    245.     /* increment frequency by 110 Hz per second */
    246.     ost->tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;
    247.  
    248.     if (c->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)
    249.         nb_samples = 10000;
    250.     else
    251.         nb_samples = c->frame_size;
    252.  
    253.     ost->frame     = alloc_audio_frame(c->sample_fmt, c->channel_layout,
    254.                                        c->sample_rate, nb_samples);
    255.     ost->tmp_frame = alloc_audio_frame(AV_SAMPLE_FMT_S16, c->channel_layout,
    256.                                        c->sample_rate, nb_samples);
    257.  
    258.     /* copy the stream parameters to the muxer */
    259.     ret = avcodec_parameters_from_context(ost->st->codecpar, c);
    260.     if (ret < 0) {
    261.         fprintf(stderr, "Could not copy the stream parameters\n");
    262.         exit(1);
    263.     }
    264.  
    265.     /* create resampler context */
    266.     ost->swr_ctx = swr_alloc();
    267.     if (!ost->swr_ctx) {
    268.         fprintf(stderr, "Could not allocate resampler context\n");
    269.         exit(1);
    270.     }
    271.  
    272.     /* set options */
    273.     av_opt_set_int       (ost->swr_ctx, "in_channel_count",   c->channels,       0);
    274.     av_opt_set_int       (ost->swr_ctx, "in_sample_rate",     c->sample_rate,    0);
    275.     av_opt_set_sample_fmt(ost->swr_ctx, "in_sample_fmt",      AV_SAMPLE_FMT_S16, 0);
    276.     av_opt_set_int       (ost->swr_ctx, "out_channel_count",  c->channels,       0);
    277.     av_opt_set_int       (ost->swr_ctx, "out_sample_rate",    c->sample_rate,    0);
    278.     av_opt_set_sample_fmt(ost->swr_ctx, "out_sample_fmt",     c->sample_fmt,     0);
    279.  
    280.     /* initialize the resampling context */
    281.     if ((ret = swr_init(ost->swr_ctx)) < 0) {
    282.         fprintf(stderr, "Failed to initialize the resampling context\n");
    283.         exit(1);
    284.     }
    285. }
    286.  
    287. /* Prepare a 16 bit dummy audio frame of 'frame_size' samples and
    288.  * 'nb_channels' channels. */
    289. static AVFrame *get_audio_frame(OutputStream *ost)
    290. {
    291.     AVFrame *frame = ost->tmp_frame;
    292.     int j, i, v;
    293.     int16_t *q = (int16_t*)frame->data[0];
    294.  
    295.     /* check if we want to generate more frames */
    296.     if (av_compare_ts(ost->next_pts, ost->enc->time_base,
    297.                       STREAM_DURATION, (AVRational){ 1, 1 }) > 0)
    298.         return NULL;
    299.  
    300.     for (j = 0; j nb_samples; j++) {
    301.         v = (int)(sin(ost->t) * 10000);
    302.         for (i = 0; i < ost->enc->channels; i++)
    303.             *q++ = v;
    304.         ost->t     += ost->tincr;
    305.         ost->tincr += ost->tincr2;
    306.     }
    307.  
    308.     frame->pts = ost->next_pts;
    309.     ost->next_pts  += frame->nb_samples;
    310.  
    311.     return frame;
    312. }
    313.  
    314. /*
    315.  * encode one audio frame and send it to the muxer
    316.  * return 1 when encoding is finished, 0 otherwise
    317.  */
    318. static int write_audio_frame(AVFormatContext *oc, OutputStream *ost)
    319. {
    320.     AVCodecContext *c;
    321.     AVFrame *frame;
    322.     int ret;
    323.     int dst_nb_samples;
    324.  
    325.     c = ost->enc;
    326.  
    327.     frame = get_audio_frame(ost);
    328.  
    329.     if (frame) {
    330.         /* convert samples from native format to destination codec format, using the resampler */
    331.         /* compute destination number of samples */
    332.         dst_nb_samples = av_rescale_rnd(swr_get_delay(ost->swr_ctx, c->sample_rate) + frame->nb_samples,
    333.                                         c->sample_rate, c->sample_rate, AV_ROUND_UP);
    334.         av_assert0(dst_nb_samples == frame->nb_samples);
    335.  
    336.         /* when we pass a frame to the encoder, it may keep a reference to it
    337.          * internally;
    338.          * make sure we do not overwrite it here
    339.          */
    340.         ret = av_frame_make_writable(ost->frame);
    341.         if (ret < 0)
    342.             exit(1);
    343.  
    344.         /* convert to destination format */
    345.         ret = swr_convert(ost->swr_ctx,
    346.                           ost->frame->data, dst_nb_samples,
    347.                           (const uint8_t **)frame->data, frame->nb_samples);
    348.         if (ret < 0) {
    349.             fprintf(stderr, "Error while converting\n");
    350.             exit(1);
    351.         }
    352.         frame = ost->frame;
    353.  
    354.         frame->pts = av_rescale_q(ost->samples_count, (AVRational){1, c->sample_rate}, c->time_base);
    355.         ost->samples_count += dst_nb_samples;
    356.     }
    357.  
    358.     return write_frame(oc, c, ost->st, frame, ost->tmp_pkt);
    359. }
    360.  
    361. /**************************************************************/
    362. /* video output */
    363.  
    364. static AVFrame *alloc_picture(enum AVPixelFormat pix_fmt, int width, int height)
    365. {
    366.     AVFrame *picture;
    367.     int ret;
    368.  
    369.     picture = av_frame_alloc();
    370.     if (!picture)
    371.         return NULL;
    372.  
    373.     picture->format = pix_fmt;
    374.     picture->width  = width;
    375.     picture->height = height;
    376.  
    377.     /* allocate the buffers for the frame data */
    378.     ret = av_frame_get_buffer(picture, 0);
    379.     if (ret < 0) {
    380.         fprintf(stderr, "Could not allocate frame data.\n");
    381.         exit(1);
    382.     }
    383.  
    384.     return picture;
    385. }
    386.  
    387. static void open_video(AVFormatContext *oc, const AVCodec *codec,
    388.                        OutputStream *ost, AVDictionary *opt_arg)
    389. {
    390.     int ret;
    391.     AVCodecContext *c = ost->enc;
    392.     AVDictionary *opt = NULL;
    393.  
    394.     av_dict_copy(&opt, opt_arg, 0);
    395.  
    396.     /* open the codec */
    397.     ret = avcodec_open2(c, codec, &opt);
    398.     av_dict_free(&opt);
    399.     if (ret < 0) {
    400.         fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));
    401.         exit(1);
    402.     }
    403.  
    404.     /* allocate and init a re-usable frame */
    405.     ost->frame = alloc_picture(c->pix_fmt, c->width, c->height);
    406.     if (!ost->frame) {
    407.         fprintf(stderr, "Could not allocate video frame\n");
    408.         exit(1);
    409.     }
    410.  
    411.     /* If the output format is not YUV420P, then a temporary YUV420P
    412.      * picture is needed too. It is then converted to the required
    413.      * output format. */
    414.     ost->tmp_frame = NULL;
    415.     if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
    416.         ost->tmp_frame = alloc_picture(AV_PIX_FMT_YUV420P, c->width, c->height);
    417.         if (!ost->tmp_frame) {
    418.             fprintf(stderr, "Could not allocate temporary picture\n");
    419.             exit(1);
    420.         }
    421.     }
    422.  
    423.     /* copy the stream parameters to the muxer */
    424.     ret = avcodec_parameters_from_context(ost->st->codecpar, c);
    425.     if (ret < 0) {
    426.         fprintf(stderr, "Could not copy the stream parameters\n");
    427.         exit(1);
    428.     }
    429. }
    430.  
    431. /* Prepare a dummy image. */
    432. static void fill_yuv_image(AVFrame *pict, int frame_index,
    433.                            int width, int height)
    434. {
    435.     int x, y, i;
    436.  
    437.     i = frame_index;
    438.  
    439.     /* Y */
    440.     for (y = 0; y < height; y++)
    441.         for (x = 0; x < width; x++)
    442.             pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
    443.  
    444.     /* Cb and Cr */
    445.     for (y = 0; y < height / 2; y++) {
    446.         for (x = 0; x < width / 2; x++) {
    447.             pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
    448.             pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
    449.         }
    450.     }
    451. }
    452.  
    453. static AVFrame *get_video_frame(OutputStream *ost)
    454. {
    455.     AVCodecContext *c = ost->enc;
    456.  
    457.     /* check if we want to generate more frames */
    458.     if (av_compare_ts(ost->next_pts, c->time_base,
    459.                       STREAM_DURATION, (AVRational){ 1, 1 }) > 0)
    460.         return NULL;
    461.  
    462.     /* when we pass a frame to the encoder, it may keep a reference to it
    463.      * internally; make sure we do not overwrite it here */
    464.     if (av_frame_make_writable(ost->frame) < 0)
    465.         exit(1);
    466.  
    467.     if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
    468.         /* as we only generate a YUV420P picture, we must convert it
    469.          * to the codec pixel format if needed */
    470.         if (!ost->sws_ctx) {
    471.             ost->sws_ctx = sws_getContext(c->width, c->height,
    472.                                           AV_PIX_FMT_YUV420P,
    473.                                           c->width, c->height,
    474.                                           c->pix_fmt,
    475.                                           SCALE_FLAGS, NULL, NULL, NULL);
    476.             if (!ost->sws_ctx) {
    477.                 fprintf(stderr,
    478.                         "Could not initialize the conversion context\n");
    479.                 exit(1);
    480.             }
    481.         }
    482.         fill_yuv_image(ost->tmp_frame, ost->next_pts, c->width, c->height);
    483.         sws_scale(ost->sws_ctx, (const uint8_t * const *) ost->tmp_frame->data,
    484.                   ost->tmp_frame->linesize, 0, c->height, ost->frame->data,
    485.                   ost->frame->linesize);
    486.     } else {
    487.         fill_yuv_image(ost->frame, ost->next_pts, c->width, c->height);
    488.     }
    489.  
    490.     ost->frame->pts = ost->next_pts++;
    491.  
    492.     return ost->frame;
    493. }
    494.  
    495. /*
    496.  * encode one video frame and send it to the muxer
    497.  * return 1 when encoding is finished, 0 otherwise
    498.  */
    499. static int write_video_frame(AVFormatContext *oc, OutputStream *ost)
    500. {
    501.     return write_frame(oc, ost->enc, ost->st, get_video_frame(ost), ost->tmp_pkt);
    502. }
    503.  
    504. static void close_stream(AVFormatContext *oc, OutputStream *ost)
    505. {
    506.     avcodec_free_context(&ost->enc);
    507.     av_frame_free(&ost->frame);
    508.     av_frame_free(&ost->tmp_frame);
    509.     av_packet_free(&ost->tmp_pkt);
    510.     sws_freeContext(ost->sws_ctx);
    511.     swr_free(&ost->swr_ctx);
    512. }
    513.  
    514. /**************************************************************/
    515. /* media file output */
    516.  
    517. int main(int argc, char **argv)
    518. {
    519.     OutputStream video_st = { 0 }, audio_st = { 0 };
    520.     const AVOutputFormat *fmt;
    521.     const char *filename;
    522.     AVFormatContext *oc;
    523.     const AVCodec *audio_codec, *video_codec;
    524.     int ret;
    525.     int have_video = 0, have_audio = 0;
    526.     int encode_video = 0, encode_audio = 0;
    527.     AVDictionary *opt = NULL;
    528.     int i;
    529.  
    530.     if (argc < 2) {
    531.         printf("usage: %s output_file\n"
    532.                "API example program to output a media file with libavformat.\n"
    533.                "This program generates a synthetic audio and video stream, encodes and\n"
    534.                "muxes them into a file named output_file.\n"
    535.                "The output format is automatically guessed according to the file extension.\n"
    536.                "Raw images can also be output by using '%%d' in the filename.\n"
    537.                "\n", argv[0]);
    538.         return 1;
    539.     }
    540.  
    541.     filename = argv[1];
    542.     for (i = 2; i+1 < argc; i+=2) {
    543.         if (!strcmp(argv[i], "-flags") || !strcmp(argv[i], "-fflags"))
    544.             av_dict_set(&opt, argv[i]+1, argv[i+1], 0);
    545.     }
    546.  
    547.     /* allocate the output media context */
    548.     avformat_alloc_output_context2(&oc, NULL, NULL, filename);
    549.     if (!oc) {
    550.         printf("Could not deduce output format from file extension: using MPEG.\n");
    551.         avformat_alloc_output_context2(&oc, NULL, "mpeg", filename);
    552.     }
    553.     if (!oc)
    554.         return 1;
    555.  
    556.     fmt = oc->oformat;
    557.  
    558.     /* Add the audio and video streams using the default format codecs
    559.      * and initialize the codecs. */
    560.     if (fmt->video_codec != AV_CODEC_ID_NONE) {
    561.         add_stream(&video_st, oc, &video_codec, fmt->video_codec);
    562.         have_video = 1;
    563.         encode_video = 1;
    564.     }
    565.     if (fmt->audio_codec != AV_CODEC_ID_NONE) {
    566.         add_stream(&audio_st, oc, &audio_codec, fmt->audio_codec);
    567.         have_audio = 1;
    568.         encode_audio = 1;
    569.     }
    570.  
    571.     /* Now that all the parameters are set, we can open the audio and
    572.      * video codecs and allocate the necessary encode buffers. */
    573.     if (have_video)
    574.         open_video(oc, video_codec, &video_st, opt);
    575.  
    576.     if (have_audio)
    577.         open_audio(oc, audio_codec, &audio_st, opt);
    578.  
    579.     av_dump_format(oc, 0, filename, 1);
    580.  
    581.     /* open the output file, if needed */
    582.     if (!(fmt->flags & AVFMT_NOFILE)) {
    583.         ret = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE);
    584.         if (ret < 0) {
    585.             fprintf(stderr, "Could not open '%s': %s\n", filename,
    586.                     av_err2str(ret));
    587.             return 1;
    588.         }
    589.     }
    590.  
    591.     /* Write the stream header, if any. */
    592.     ret = avformat_write_header(oc, &opt);
    593.     if (ret < 0) {
    594.         fprintf(stderr, "Error occurred when opening output file: %s\n",
    595.                 av_err2str(ret));
    596.         return 1;
    597.     }
    598.  
    599.     while (encode_video || encode_audio) {
    600.         /* select the stream to encode */
    601.         if (encode_video &&
    602.             (!encode_audio || av_compare_ts(video_st.next_pts, video_st.enc->time_base,
    603.                                             audio_st.next_pts, audio_st.enc->time_base) <= 0)) {
    604.             encode_video = !write_video_frame(oc, &video_st);
    605.         } else {
    606.             encode_audio = !write_audio_frame(oc, &audio_st);
    607.         }
    608.     }
    609.  
    610.     /* Write the trailer, if any. The trailer must be written before you
    611.      * close the CodecContexts open when you wrote the header; otherwise
    612.      * av_write_trailer() may try to use memory that was freed on
    613.      * av_codec_close(). */
    614.     av_write_trailer(oc);
    615.  
    616.     /* Close each codec. */
    617.     if (have_video)
    618.         close_stream(oc, &video_st);
    619.     if (have_audio)
    620.         close_stream(oc, &audio_st);
    621.  
    622.     if (!(fmt->flags & AVFMT_NOFILE))
    623.         /* Close the output file. */
    624.         avio_closep(&oc->pb);
    625.  
    626.     /* free the stream */
    627.     avformat_free_context(oc);
    628.  
    629.     return 0;
    630. }

  • 相关阅读:
    Linux 系统 Vi和Vim编辑器—笔记7
    java技术专家面试指南80问【java学习+面试宝典】（九）
    MySQL的SQL 优化：提升数据库性能
    树形DP小结
    PS的抠图算法原理剖析 1
    大数据之Stream流
    回溯算法题目
    Android versionCode会变成指定数值加001、002、003等后缀
    云服务器CVM_云主机_云计算服务器_弹性云服务器-腾讯云
    【leetcode】1137. 第 N 个泰波那契数
  • 原文地址：https://blog.csdn.net/Lemon_D1999/article/details/140315030