zoukankan      html  css  js  c++  java

  • 最简单的基于FFMPEG的转码程序

    本文介绍一个简单的基于FFmpeg的转码器。它可以将一种视频格式（包括封转格式和编码格式）转换为另一种视频格式。转码器在视音频编解码处理的程序中，属于一个比较复杂的东西。因为它结合了视频的解码和编码。一个视频播放器，一般只包含解码功能；一个视频编码工具，一般只包含编码功能；而一个视频转码器，则需要先对视频进行解码，然后再对视频进行编码，因而相当于解码器和编码器的结合。下图例举了一个视频的转码流程。输入视频的封装格式是FLV，视频编码标准是H.264，音频编码标准是AAC；输出视频的封装格式是AVI，视频编码标准是MPEG2，音频编码标准是MP3。从流程中可以看出，首先从输入视频中分离出视频码流和音频压缩码流，然后分别将视频码流和音频码流进行解码，获取到非压缩的像素数据/音频采样数据，接着将非压缩的像素数据/音频采样数据重新进行编码，获得重新编码后的视频码流和音频码流，最后将视频码流和音频码流重新封装成一个文件。

     

    本文介绍的视频转码器正是使用FFMPEG类库从编程的角度实现了上述流程。该例子是从FFmpeg的例子改编的，平台是VC2010，类库版本是2014.5.6。

    流程图（2014.9.29更新）

    下面附两张使用FFmpeg转码视频的流程图。图中使用浅绿色标出了视频的编码、解码函数。从代码中可以看出，使用了AVFilter的不少东西，因此建议先学习AVFilter的内容后再看这个转码器的源代码。

    PS：实际上，转码器不是一定依赖AVFilter的。因此打算有时间对这个转码器进行进一步的简化，使学习的人无需AVFilter的基础也可以理解转码器。

    简单介绍一下流程中各个函数的意义：
    open_input_file()：打开输入文件，并初始化相关的结构体。
    open_output_file()：打开输出文件，并初始化相关的结构体。
    init_filters()：初始化AVFilter相关的结构体。
    av_read_frame()：从输入文件中读取一个AVPacket。
    avcodec_decode_video2()：解码一个视频AVPacket（存储H.264等压缩码流数据）为AVFrame（存储YUV等非压缩的像素数据）。
    avcodec_decode_video4()：解码一个音频AVPacket（存储MP3等压缩码流数据）为AVFrame（存储PCM采样数据）。
    filter_encode_write_frame()：编码一个AVFrame。
    flush_encoder()：输入文件读取完毕后，输出编码器中剩余的AVPacket。

    以上函数中open_input_file()，open_output_file()，init_filters()中的函数在其他文章中都有所叙述，在这里不再重复：

    open_input_file()可参考：100行代码实现最简单的基于FFMPEG+SDL的视频播放器（SDL1.x）

    open_output_file()可参考：最简单的基于FFMPEG的视频编码器（YUV编码为H.264）

    init_filters()可参考：最简单的基于FFmpeg的AVfilter例子（水印叠加）

    在这里介绍一下其中编码的函数filter_encode_write_frame()。filter_encode_write_frame()函数的流程如下图所示，它完成了视频/音频的编码功能。

    PS：视频和音频的编码流程中除了编码函数avcodec_encode_video2()和avcodec_encode_audio2()不一样之外，其他部分几乎完全一样。

    简单介绍一下filter_encode_write_frame()中各个函数的意义：

    av_buffersrc_add_frame()：将解码后的AVFrame加入Filtergraph。

    av_buffersink_get_buffer_ref()：从Filtergraph中取一个AVFrame。

    avcodec_encode_video2()：编码一个视频AVFrame为AVPacket。

    avcodec_encode_audio2()：编码一个音频AVFrame为AVPacket。

    av_interleaved_write_frame()：将编码后的AVPacket写入文件。

    代码

    贴上代码

    [cpp] view plain copy 在CODE上查看代码片派生到我的代码片
    1. /* 
    2.  *最简单的基于FFmpeg的转码器 
    3.  *Simplest FFmpeg Transcoder 
    4.  * 
    5.  *雷霄骅 Lei Xiaohua 
    6.  *leixiaohua1020@126.com 
    7.  *中国传媒大学/数字电视技术 
    8.  *Communication University of China / DigitalTV Technology 
    9.  *http://blog.csdn.net/leixiaohua1020 
    10.  * 
    11.  *本程序实现了视频格式之间的转换。是一个最简单的视频转码程序。 
    12.  * 
    13.  */  
    14.    
    15. #include "stdafx.h"  
    16. extern "C"  
    17. {  
    18. #include "libavcodec/avcodec.h"  
    19. #include "libavformat/avformat.h"  
    20. #include "libavfilter/avfiltergraph.h"  
    21. #include "libavfilter/avcodec.h"  
    22. #include "libavfilter/buffersink.h"  
    23. #include "libavfilter/buffersrc.h"  
    24. #include "libavutil/avutil.h"  
    25. #include "libavutil/opt.h"  
    26. #include "libavutil/pixdesc.h"  
    27. };  
    28.    
    29.    
    30.    
    31. static AVFormatContext *ifmt_ctx;  
    32. static AVFormatContext *ofmt_ctx;  
    33. typedef struct FilteringContext{  
    34.     AVFilterContext*buffersink_ctx;  
    35.     AVFilterContext*buffersrc_ctx;  
    36.     AVFilterGraph*filter_graph;  
    37. } FilteringContext;  
    38. static FilteringContext *filter_ctx;  
    39. static int open_input_file(const char *filename)  
    40. {  
    41.     int ret;  
    42.     unsigned int i;  
    43.     ifmt_ctx =NULL;  
    44.     if ((ret = avformat_open_input(&ifmt_ctx,filename, NULL, NULL)) < 0) {  
    45.        av_log(NULL, AV_LOG_ERROR, "Cannot openinput file ");  
    46.         return ret;  
    47.     }  
    48.     if ((ret = avformat_find_stream_info(ifmt_ctx, NULL))< 0) {  
    49.        av_log(NULL, AV_LOG_ERROR, "Cannot findstream information ");  
    50.         return ret;  
    51.     }  
    52.     for (i = 0; i < ifmt_ctx->nb_streams; i++) {  
    53.         AVStream*stream;  
    54.        AVCodecContext *codec_ctx;  
    55.         stream =ifmt_ctx->streams[i];  
    56.         codec_ctx =stream->codec;  
    57.         /* Reencode video & audio and remux subtitles etc. */  
    58.         if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO  
    59.                 ||codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {  
    60.             /* Open decoder */  
    61.             ret =avcodec_open2(codec_ctx,  
    62.                    avcodec_find_decoder(codec_ctx->codec_id), NULL);  
    63.             if (ret < 0) {  
    64.                av_log(NULL, AV_LOG_ERROR, "Failed toopen decoder for stream #%u ", i);  
    65.                 return ret;  
    66.             }  
    67.         }  
    68.     }  
    69.    av_dump_format(ifmt_ctx, 0, filename, 0);  
    70.     return 0;  
    71. }  
    72. static int open_output_file(const char *filename)  
    73. {  
    74.     AVStream*out_stream;  
    75.     AVStream*in_stream;  
    76.     AVCodecContext*dec_ctx, *enc_ctx;  
    77.     AVCodec*encoder;  
    78.     int ret;  
    79.     unsigned int i;  
    80.     ofmt_ctx =NULL;  
    81.    avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, filename);  
    82.     if (!ofmt_ctx) {  
    83.        av_log(NULL, AV_LOG_ERROR, "Could notcreate output context ");  
    84.         return AVERROR_UNKNOWN;  
    85.     }  
    86.     for (i = 0; i < ifmt_ctx->nb_streams; i++) {  
    87.         out_stream= avformat_new_stream(ofmt_ctx, NULL);  
    88.         if (!out_stream) {  
    89.            av_log(NULL, AV_LOG_ERROR, "Failedallocating output stream ");  
    90.             return AVERROR_UNKNOWN;  
    91.         }  
    92.         in_stream =ifmt_ctx->streams[i];  
    93.         dec_ctx =in_stream->codec;  
    94.         enc_ctx =out_stream->codec;  
    95.         if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO  
    96.                 ||dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {  
    97.             /* in this example, we choose transcoding to same codec */  
    98.             encoder= avcodec_find_encoder(dec_ctx->codec_id);  
    99.             /* In this example, we transcode to same properties(picture size, 
    100.             * sample rate etc.). These properties can be changed for output 
    101.             * streams easily using filters */  
    102.             if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {  
    103.                enc_ctx->height = dec_ctx->height;  
    104.                enc_ctx->width = dec_ctx->width;  
    105.                enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio;  
    106.                 /* take first format from list of supported formats */  
    107.                enc_ctx->pix_fmt = encoder->pix_fmts[0];  
    108.                 /* video time_base can be set to whatever is handy andsupported by encoder */  
    109.                enc_ctx->time_base = dec_ctx->time_base;  
    110.             } else {  
    111.                enc_ctx->sample_rate = dec_ctx->sample_rate;  
    112.                enc_ctx->channel_layout = dec_ctx->channel_layout;  
    113.                enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout);  
    114.                 /* take first format from list of supported formats */  
    115.                enc_ctx->sample_fmt = encoder->sample_fmts[0];  
    116.                 AVRationaltime_base={1, enc_ctx->sample_rate};  
    117.                enc_ctx->time_base = time_base;  
    118.             }  
    119.             /* Third parameter can be used to pass settings to encoder*/  
    120.             ret =avcodec_open2(enc_ctx, encoder, NULL);  
    121.             if (ret < 0) {  
    122.                av_log(NULL, AV_LOG_ERROR, "Cannot openvideo encoder for stream #%u ", i);  
    123.                 return ret;  
    124.             }  
    125.         } else if(dec_ctx->codec_type == AVMEDIA_TYPE_UNKNOWN) {  
    126.            av_log(NULL, AV_LOG_FATAL, "Elementarystream #%d is of unknown type, cannot proceed ", i);  
    127.             return AVERROR_INVALIDDATA;  
    128.         } else {  
    129.             /* if this stream must be remuxed */  
    130.             ret =avcodec_copy_context(ofmt_ctx->streams[i]->codec,  
    131.                    ifmt_ctx->streams[i]->codec);  
    132.             if (ret < 0) {  
    133.                av_log(NULL, AV_LOG_ERROR, "Copyingstream context failed ");  
    134.                 return ret;  
    135.             }  
    136.         }  
    137.         if (ofmt_ctx->oformat->flags &AVFMT_GLOBALHEADER)  
    138.            enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;  
    139.     }  
    140.    av_dump_format(ofmt_ctx, 0, filename, 1);  
    141.     if (!(ofmt_ctx->oformat->flags &AVFMT_NOFILE)) {  
    142.         ret =avio_open(&ofmt_ctx->pb, filename, AVIO_FLAG_WRITE);  
    143.         if (ret < 0) {  
    144.            av_log(NULL, AV_LOG_ERROR, "Could notopen output file '%s'", filename);  
    145.             return ret;  
    146.         }  
    147.     }  
    148.     /* init muxer, write output file header */  
    149.     ret =avformat_write_header(ofmt_ctx, NULL);  
    150.     if (ret < 0) {  
    151.         av_log(NULL,AV_LOG_ERROR, "Error occurred when openingoutput file ");  
    152.         return ret;  
    153.     }  
    154.     return 0;  
    155. }  
    156. static intinit_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,  
    157.        AVCodecContext *enc_ctx, const char *filter_spec)  
    158. {  
    159.     char args[512];  
    160.     int ret = 0;  
    161.     AVFilter*buffersrc = NULL;  
    162.     AVFilter*buffersink = NULL;  
    163.     AVFilterContext*buffersrc_ctx = NULL;  
    164.     AVFilterContext*buffersink_ctx = NULL;  
    165.     AVFilterInOut*outputs = avfilter_inout_alloc();  
    166.     AVFilterInOut*inputs  = avfilter_inout_alloc();  
    167.     AVFilterGraph*filter_graph = avfilter_graph_alloc();  
    168.     if (!outputs || !inputs || !filter_graph) {  
    169.         ret =AVERROR(ENOMEM);  
    170.         goto end;  
    171.     }  
    172.     if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {  
    173.         buffersrc =avfilter_get_by_name("buffer");  
    174.         buffersink= avfilter_get_by_name("buffersink");  
    175.         if (!buffersrc || !buffersink) {  
    176.            av_log(NULL, AV_LOG_ERROR, "filteringsource or sink element not found ");  
    177.             ret = AVERROR_UNKNOWN;  
    178.             goto end;  
    179.         }  
    180.        _snprintf(args, sizeof(args),  
    181.                 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",  
    182.                dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,  
    183.                 dec_ctx->time_base.num,dec_ctx->time_base.den,  
    184.                dec_ctx->sample_aspect_ratio.num,  
    185.                dec_ctx->sample_aspect_ratio.den);  
    186.         ret =avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",  
    187.                args, NULL, filter_graph);  
    188.         if (ret < 0) {  
    189.            av_log(NULL, AV_LOG_ERROR, "Cannotcreate buffer source ");  
    190.             goto end;  
    191.         }  
    192.         ret =avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",  
    193.                NULL, NULL, filter_graph);  
    194.         if (ret < 0) {  
    195.            av_log(NULL, AV_LOG_ERROR, "Cannotcreate buffer sink ");  
    196.             goto end;  
    197.         }  
    198.         ret =av_opt_set_bin(buffersink_ctx, "pix_fmts",  
    199.                (uint8_t*)&enc_ctx->pix_fmt, sizeof(enc_ctx->pix_fmt),  
    200.                AV_OPT_SEARCH_CHILDREN);  
    201.         if (ret < 0) {  
    202.            av_log(NULL, AV_LOG_ERROR, "Cannot setoutput pixel format ");  
    203.             goto end;  
    204.         }  
    205.     } else if(dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {  
    206.         buffersrc = avfilter_get_by_name("abuffer");  
    207.         buffersink= avfilter_get_by_name("abuffersink");  
    208.         if (!buffersrc || !buffersink) {  
    209.            av_log(NULL, AV_LOG_ERROR, "filteringsource or sink element not found ");  
    210.             ret =AVERROR_UNKNOWN;  
    211.             goto end;  
    212.         }  
    213.         if (!dec_ctx->channel_layout)  
    214.            dec_ctx->channel_layout =  
    215.                av_get_default_channel_layout(dec_ctx->channels);  
    216.        _snprintf(args, sizeof(args),  
    217.                 "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%I64x",  
    218.                dec_ctx->time_base.num, dec_ctx->time_base.den,dec_ctx->sample_rate,  
    219.                av_get_sample_fmt_name(dec_ctx->sample_fmt),  
    220.                dec_ctx->channel_layout);  
    221.         ret =avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",  
    222.                args, NULL, filter_graph);  
    223.         if (ret < 0) {  
    224.            av_log(NULL, AV_LOG_ERROR, "Cannotcreate audio buffer source ");  
    225.             goto end;  
    226.         }  
    227.         ret =avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",  
    228.                NULL, NULL, filter_graph);  
    229.         if (ret < 0) {  
    230.            av_log(NULL, AV_LOG_ERROR, "Cannotcreate audio buffer sink ");  
    231.             goto end;  
    232.         }  
    233.         ret = av_opt_set_bin(buffersink_ctx, "sample_fmts",  
    234.                (uint8_t*)&enc_ctx->sample_fmt, sizeof(enc_ctx->sample_fmt),  
    235.                AV_OPT_SEARCH_CHILDREN);  
    236.         if (ret < 0) {  
    237.            av_log(NULL, AV_LOG_ERROR, "Cannot setoutput sample format ");  
    238.             goto end;  
    239.         }  
    240.         ret =av_opt_set_bin(buffersink_ctx, "channel_layouts",  
    241.                (uint8_t*)&enc_ctx->channel_layout,  
    242.                 sizeof(enc_ctx->channel_layout),AV_OPT_SEARCH_CHILDREN);  
    243.         if (ret < 0) {  
    244.            av_log(NULL, AV_LOG_ERROR, "Cannot setoutput channel layout ");  
    245.             goto end;  
    246.         }  
    247.         ret =av_opt_set_bin(buffersink_ctx, "sample_rates",  
    248.                (uint8_t*)&enc_ctx->sample_rate, sizeof(enc_ctx->sample_rate),  
    249.                AV_OPT_SEARCH_CHILDREN);  
    250.         if (ret < 0) {  
    251.            av_log(NULL, AV_LOG_ERROR, "Cannot setoutput sample rate ");  
    252.             goto end;  
    253.         }  
    254.     } else {  
    255.         ret =AVERROR_UNKNOWN;  
    256.         goto end;  
    257.     }  
    258.     /* Endpoints for the filter graph. */  
    259.    outputs->name       =av_strdup("in");  
    260.    outputs->filter_ctx = buffersrc_ctx;  
    261.    outputs->pad_idx    = 0;  
    262.    outputs->next       = NULL;  
    263.    inputs->name       = av_strdup("out");  
    264.    inputs->filter_ctx = buffersink_ctx;  
    265.    inputs->pad_idx    = 0;  
    266.    inputs->next       = NULL;  
    267.     if (!outputs->name || !inputs->name) {  
    268.         ret =AVERROR(ENOMEM);  
    269.         goto end;  
    270.     }  
    271.     if ((ret = avfilter_graph_parse_ptr(filter_graph,filter_spec,  
    272.                    &inputs, &outputs, NULL)) < 0)  
    273.         goto end;  
    274.     if ((ret = avfilter_graph_config(filter_graph, NULL))< 0)  
    275.         goto end;  
    276.     /* Fill FilteringContext */  
    277.    fctx->buffersrc_ctx = buffersrc_ctx;  
    278.    fctx->buffersink_ctx = buffersink_ctx;  
    279.     fctx->filter_graph= filter_graph;  
    280. end:  
    281.    avfilter_inout_free(&inputs);  
    282.    avfilter_inout_free(&outputs);  
    283.     return ret;  
    284. }  
    285. static int init_filters(void)  
    286. {  
    287.     const char*filter_spec;  
    288.     unsigned int i;  
    289.     int ret;  
    290.     filter_ctx =(FilteringContext *)av_malloc_array(ifmt_ctx->nb_streams, sizeof(*filter_ctx));  
    291.     if (!filter_ctx)  
    292.         return AVERROR(ENOMEM);  
    293.     for (i = 0; i < ifmt_ctx->nb_streams; i++) {  
    294.        filter_ctx[i].buffersrc_ctx  =NULL;  
    295.         filter_ctx[i].buffersink_ctx= NULL;  
    296.        filter_ctx[i].filter_graph   =NULL;  
    297.         if(!(ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO  
    298.                 ||ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO))  
    299.             continue;  
    300.         if (ifmt_ctx->streams[i]->codec->codec_type== AVMEDIA_TYPE_VIDEO)  
    301.            filter_spec = "null"; /* passthrough (dummy) filter for video */  
    302.         else  
    303.            filter_spec = "anull"; /* passthrough (dummy) filter for audio */  
    304.         ret =init_filter(&filter_ctx[i], ifmt_ctx->streams[i]->codec,  
    305.                ofmt_ctx->streams[i]->codec, filter_spec);  
    306.         if (ret)  
    307.             return ret;  
    308.     }  
    309.     return 0;  
    310. }  
    311. static intencode_write_frame(AVFrame *filt_frame, unsignedint stream_index, int*got_frame) {  
    312.     int ret;  
    313.     int got_frame_local;  
    314.     AVPacketenc_pkt;  
    315.     int (*enc_func)(AVCodecContext *, AVPacket *, const AVFrame *, int*) =  
    316.        (ifmt_ctx->streams[stream_index]->codec->codec_type ==  
    317.         AVMEDIA_TYPE_VIDEO) ? avcodec_encode_video2 : avcodec_encode_audio2;  
    318.     if (!got_frame)  
    319.         got_frame =&got_frame_local;  
    320.     av_log(NULL,AV_LOG_INFO, "Encoding frame ");  
    321.     /* encode filtered frame */  
    322.     enc_pkt.data =NULL;  
    323.     enc_pkt.size =0;  
    324.     av_init_packet(&enc_pkt);  
    325.     ret =enc_func(ofmt_ctx->streams[stream_index]->codec, &enc_pkt,  
    326.            filt_frame, got_frame);  
    327.    av_frame_free(&filt_frame);  
    328.     if (ret < 0)  
    329.         return ret;  
    330.     if (!(*got_frame))  
    331.         return 0;  
    332.     /* prepare packet for muxing */  
    333.    enc_pkt.stream_index = stream_index;  
    334.     enc_pkt.dts =av_rescale_q_rnd(enc_pkt.dts,  
    335.            ofmt_ctx->streams[stream_index]->codec->time_base,  
    336.            ofmt_ctx->streams[stream_index]->time_base,  
    337.            (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));  
    338.     enc_pkt.pts =av_rescale_q_rnd(enc_pkt.pts,  
    339.            ofmt_ctx->streams[stream_index]->codec->time_base,  
    340.            ofmt_ctx->streams[stream_index]->time_base,  
    341.            (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));  
    342.    enc_pkt.duration = av_rescale_q(enc_pkt.duration,  
    343.            ofmt_ctx->streams[stream_index]->codec->time_base,  
    344.            ofmt_ctx->streams[stream_index]->time_base);  
    345.     av_log(NULL,AV_LOG_DEBUG, "Muxing frame ");  
    346.     /* mux encoded frame */  
    347.     ret =av_interleaved_write_frame(ofmt_ctx, &enc_pkt);  
    348.     return ret;  
    349. }  
    350. static intfilter_encode_write_frame(AVFrame *frame, unsignedint stream_index)  
    351. {  
    352.     int ret;  
    353.     AVFrame*filt_frame;  
    354.     av_log(NULL,AV_LOG_INFO, "Pushing decoded frame tofilters ");  
    355.     /* push the decoded frame into the filtergraph */  
    356.     ret =av_buffersrc_add_frame_flags(filter_ctx[stream_index].buffersrc_ctx,  
    357.             frame,0);  
    358.     if (ret < 0) {  
    359.        av_log(NULL, AV_LOG_ERROR, "Error whilefeeding the filtergraph ");  
    360.         return ret;  
    361.     }  
    362.     /* pull filtered frames from the filtergraph */  
    363.     while (1) {  
    364.         filt_frame= av_frame_alloc();  
    365.         if (!filt_frame) {  
    366.             ret =AVERROR(ENOMEM);  
    367.             break;  
    368.         }  
    369.        av_log(NULL, AV_LOG_INFO, "Pullingfiltered frame from filters ");  
    370.         ret =av_buffersink_get_frame(filter_ctx[stream_index].buffersink_ctx,  
    371.                filt_frame);  
    372.         if (ret < 0) {  
    373.             /* if nomore frames for output - returns AVERROR(EAGAIN) 
    374.             * if flushed and no more frames for output - returns AVERROR_EOF 
    375.             * rewrite retcode to 0 to show it as normal procedure completion 
    376.             */  
    377.             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)  
    378.                 ret= 0;  
    379.            av_frame_free(&filt_frame);  
    380.             break;  
    381.         }  
    382.        filt_frame->pict_type = AV_PICTURE_TYPE_NONE;  
    383.         ret =encode_write_frame(filt_frame, stream_index, NULL);  
    384.         if (ret < 0)  
    385.             break;  
    386.     }  
    387.     return ret;  
    388. }  
    389. static int flush_encoder(unsigned intstream_index)  
    390. {  
    391.     int ret;  
    392.     int got_frame;  
    393.     if(!(ofmt_ctx->streams[stream_index]->codec->codec->capabilities&  
    394.                CODEC_CAP_DELAY))  
    395.         return 0;  
    396.     while (1) {  
    397.        av_log(NULL, AV_LOG_INFO, "Flushingstream #%u encoder ", stream_index);  
    398.         ret =encode_write_frame(NULL, stream_index, &got_frame);  
    399.         if (ret < 0)  
    400.             break;  
    401.         if (!got_frame)  
    402.             return 0;  
    403.     }  
    404.     return ret;  
    405. }  
    406.    
    407. int_tmain(int argc, _TCHAR* argv[])  
    408. {  
    409.     int ret;  
    410.     AVPacketpacket;  
    411.     AVFrame *frame= NULL;  
    412.     enum AVMediaType type;  
    413.     unsigned intstream_index;  
    414.     unsigned int i;  
    415.     int got_frame;  
    416.     int (*dec_func)(AVCodecContext *, AVFrame *, int *, const AVPacket*);  
    417.     if (argc != 3) {  
    418.        av_log(NULL, AV_LOG_ERROR, "Usage: %s<input file> <output file> ", argv[0]);  
    419.         return 1;  
    420.     }  
    421.    av_register_all();  
    422.    avfilter_register_all();  
    423.     if ((ret = open_input_file(argv[1])) < 0)  
    424.         goto end;  
    425.     if ((ret = open_output_file(argv[2])) < 0)  
    426.         goto end;  
    427.     if ((ret = init_filters()) < 0)  
    428.         goto end;  
    429.     /* read all packets */  
    430.     while (1) {  
    431.         if ((ret= av_read_frame(ifmt_ctx, &packet)) < 0)  
    432.             break;  
    433.        stream_index = packet.stream_index;  
    434.         type =ifmt_ctx->streams[packet.stream_index]->codec->codec_type;  
    435.        av_log(NULL, AV_LOG_DEBUG, "Demuxergave frame of stream_index %u ",  
    436.                stream_index);  
    437.         if (filter_ctx[stream_index].filter_graph) {  
    438.            av_log(NULL, AV_LOG_DEBUG, "Going toreencode&filter the frame ");  
    439.             frame =av_frame_alloc();  
    440.             if (!frame) {  
    441.                 ret = AVERROR(ENOMEM);  
    442.                 break;  
    443.             }  
    444.            packet.dts = av_rescale_q_rnd(packet.dts,  
    445.                    ifmt_ctx->streams[stream_index]->time_base,  
    446.                    ifmt_ctx->streams[stream_index]->codec->time_base,  
    447.                     (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));  
    448.            packet.pts = av_rescale_q_rnd(packet.pts,  
    449.                    ifmt_ctx->streams[stream_index]->time_base,  
    450.                    ifmt_ctx->streams[stream_index]->codec->time_base,  
    451.                    (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));  
    452.            dec_func = (type == AVMEDIA_TYPE_VIDEO) ? avcodec_decode_video2 :  
    453.                avcodec_decode_audio4;  
    454.             ret =dec_func(ifmt_ctx->streams[stream_index]->codec, frame,  
    455.                    &got_frame, &packet);  
    456.             if (ret < 0) {  
    457.                av_frame_free(&frame);  
    458.                av_log(NULL, AV_LOG_ERROR, "Decodingfailed ");  
    459.                 break;  
    460.             }  
    461.             if (got_frame) {  
    462.                frame->pts = av_frame_get_best_effort_timestamp(frame);  
    463.                 ret= filter_encode_write_frame(frame, stream_index);  
    464.                av_frame_free(&frame);  
    465.                 if (ret< 0)  
    466.                    goto end;  
    467.             } else {  
    468.                av_frame_free(&frame);  
    469.             }  
    470.         } else {  
    471.             /* remux this frame without reencoding */  
    472.            packet.dts = av_rescale_q_rnd(packet.dts,  
    473.                    ifmt_ctx->streams[stream_index]->time_base,  
    474.                    ofmt_ctx->streams[stream_index]->time_base,  
    475.                     (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));  
    476.            packet.pts = av_rescale_q_rnd(packet.pts,  
    477.                    ifmt_ctx->streams[stream_index]->time_base,  
    478.                    ofmt_ctx->streams[stream_index]->time_base,  
    479.                     (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));  
    480.             ret =av_interleaved_write_frame(ofmt_ctx, &packet);  
    481.             if (ret < 0)  
    482.                 goto end;  
    483.         }  
    484.        av_free_packet(&packet);  
    485.     }  
    486.     /* flush filters and encoders */  
    487.     for (i = 0; i < ifmt_ctx->nb_streams; i++) {  
    488.         /* flush filter */  
    489.         if (!filter_ctx[i].filter_graph)  
    490.             continue;  
    491.         ret =filter_encode_write_frame(NULL, i);  
    492.         if (ret < 0) {  
    493.            av_log(NULL, AV_LOG_ERROR, "Flushingfilter failed ");  
    494.             goto end;  
    495.         }  
    496.         /* flush encoder */  
    497.         ret = flush_encoder(i);  
    498.         if (ret < 0) {  
    499.            av_log(NULL, AV_LOG_ERROR, "Flushingencoder failed ");  
    500.             goto end;  
    501.         }  
    502.     }  
    503.    av_write_trailer(ofmt_ctx);  
    504. end:  
    505.    av_free_packet(&packet);  
    506.    av_frame_free(&frame);  
    507.     for (i = 0; i < ifmt_ctx->nb_streams; i++) {  
    508.        avcodec_close(ifmt_ctx->streams[i]->codec);  
    509.         if (ofmt_ctx && ofmt_ctx->nb_streams >i && ofmt_ctx->streams[i] &&ofmt_ctx->streams[i]->codec)  
    510.            avcodec_close(ofmt_ctx->streams[i]->codec);  
    511.         if(filter_ctx && filter_ctx[i].filter_graph)  
    512.            avfilter_graph_free(&filter_ctx[i].filter_graph);  
    513.     }  
    514.    av_free(filter_ctx);  
    515.    avformat_close_input(&ifmt_ctx);  
    516.     if (ofmt_ctx &&!(ofmt_ctx->oformat->flags & AVFMT_NOFILE))  
    517.         avio_close(ofmt_ctx->pb);  
    518.    avformat_free_context(ofmt_ctx);  
    519.     if (ret < 0)  
    520.        av_log(NULL, AV_LOG_ERROR, "Erroroccurred ");  
    521.     return (ret? 1:0);  
    522. }  

    程序运行截图：

    默认情况下运行程序，会将“cuc_ieschool.ts”转换为“cuc_ieschool.avi”。调试的时候，可以修改“配置属性->调试->命令参数”中的参数，即可改变转码的输入输出文件。

    工程下载地址（VC2010）：http://download.csdn.net/detail/leixiaohua1020/7394649
  • 相关阅读:
    1.5环境变量与文件查找（学习过程）
    1.4程序的机器级表示（学习过程）
    1.3信息的表示和处理（学习过程）
    hdu4706
    【多重背包】Transport Ship
    【动态规划】Mathematical Curse
    【动态规划】subsequence 1
    学习线性基
    学习秦九韶算法
    学习裴蜀定理
  • 原文地址：https://www.cnblogs.com/android-blogs/p/5663138.html
Copyright © 2011-2022 走看看