最简单的基于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\n");  
  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\n");  
  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\n", 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\n");  
  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\n");  
  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\n", 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\n", 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\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n", 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>\n", 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\n",  
  436.                stream_index);  
  437.         if (filter_ctx[stream_index].filter_graph) {  
  438.            av_log(NULL, AV_LOG_DEBUG, "Going toreencode&filter the frame\n");  
  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\n");  
  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\n");  
  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\n");  
  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\n");  
  521.     return (ret? 1:0);  
  522. }  

程序运行截图:


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



工程下载地址(VC2010):http://download.csdn.net/detail/leixiaohua1020/7394649

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值