·您当前的位置:首页 > 技术教程 > FFmpeg技术 >

[FFmpeg]基于FFmpeg技术的视音频编解码

时间:2014-07-06 16:59雷霄骅
转码器在视音频编解码处理的程序中,属于一个比较复杂的东西。因为它结合了视频的解码和编码

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

 

本文介绍的视频转码器正是使用FFMPEG类库从编程的角度实现了上述流程。

下面贴上代码,代码是从FFmpeg的例子改编的,平台是VC2010,类库版本是2014.5.6

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

热门文章推荐

请稍候...

保利威视云平台-轻松实现点播直播视频应用

酷播云数据统计分析跨平台播放器