请选择 进入手机版 | 继续访问电脑版

北南南北论坛

 找回密码
 立即注册
查看: 12|回复: 1

ffmpeg用filter实现视频scale

[复制链接]

646

主题

898

帖子

2885

积分

管理员

Rank: 9Rank: 9Rank: 9

积分
2885
发表于 2017-11-18 21:31:53 | 显示全部楼层 |阅读模式
1、概述

此例子用ffmpeg的filter实现视频scale。
2、代码

  1. /**
  2. * 最简单的基于FFmpeg的AVFilter例子(scale)
  3. *
  4. *
  5. * 本程序使用FFmpeg的AVfilter实现了视频的缩放功能。
  6. *
  7. *
  8. */

  9. #include "stdafx.h"

  10. #ifdef __cplusplus
  11. extern "C"
  12. {
  13. #endif
  14. #include <libavcodec/avcodec.h>
  15. #include <libavformat/avformat.h>
  16. #include <libavfilter/avfiltergraph.h>
  17. #include <libavfilter/avcodec.h>
  18. #include <libavfilter/buffersink.h>
  19. #include <libavfilter/buffersrc.h>
  20. #include <libavutil/avutil.h>
  21. #include <libswscale/swscale.h>
  22. #ifdef __cplusplus
  23. };
  24. #endif

  25. #pragma comment(lib, "avcodec.lib")
  26. #pragma comment(lib, "avformat.lib")
  27. #pragma comment(lib, "avutil.lib")
  28. #pragma comment(lib, "avdevice.lib")
  29. #pragma comment(lib, "avfilter.lib")

  30. //#pragma comment(lib, "avfilter.lib")
  31. //#pragma comment(lib, "postproc.lib")
  32. //#pragma comment(lib, "swresample.lib")
  33. #pragma comment(lib, "swscale.lib")


  34. static AVFormatContext *ifmt_ctx, *ofmt_ctx;
  35. static AVCodecContext *pCodecCtx;
  36. AVFilterContext *buffersink_ctx;
  37. AVFilterContext *buffersrc_ctx;
  38. AVFilterGraph *filter_graph;
  39. static int video_stream_index = -1;
  40. static int64_t last_pts = AV_NOPTS_VALUE;


  41. static int open_input_file(const char *filename)
  42. {
  43.         int ret;
  44.         AVCodec *dec;

  45.         if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
  46.                 printf( "Cannot open input file\n");
  47.                 return ret;
  48.         }

  49.         if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
  50.                 printf( "Cannot find stream information\n");
  51.                 return ret;
  52.         }

  53.         /* select the video stream */
  54.         ret = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0);
  55.         if (ret < 0) {
  56.                 printf( "Cannot find a video stream in the input file\n");
  57.                 return ret;
  58.         }
  59.         video_stream_index = ret;
  60.         pCodecCtx = ifmt_ctx->streams[video_stream_index]->codec;

  61.         /* init the video decoder */
  62.         if ((ret = avcodec_open2(pCodecCtx, dec, NULL)) < 0)
  63.         {
  64.                 printf( "Cannot open video decoder\n");
  65.                 return ret;
  66.         }

  67.         return 0;
  68. }

  69. int openoutputfile(const char* filename, int width, int height)
  70. {
  71.         AVStream *out_stream;
  72.         int ret = 0;
  73.         if ((ret = avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, filename)) < 0)
  74.         {
  75.                 printf("can not alloc output context");
  76.                 return ret;
  77.         }
  78.         for (int i = 0; i < ifmt_ctx->nb_streams; i++)
  79.         {
  80.                 //if the stream is video stream then find the encoder default
  81.                 //and set context and open the encoder
  82.                 if (ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
  83.                 {
  84.                         out_stream = NULL;
  85.                         //new a stream
  86.                         out_stream = avformat_new_stream(ofmt_ctx, NULL);
  87.                         if (!out_stream)
  88.                         {
  89.                                 printf("can not new stream for output");
  90.                                 return AVERROR_UNKNOWN;
  91.                         }

  92.                         //use default video encoder
  93.                         out_stream->codec->codec = avcodec_find_encoder(ofmt_ctx->oformat->video_codec);
  94.                                                                
  95.                         out_stream->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  96.                         out_stream->codec->pix_fmt = PIX_FMT_YUV420P;
  97.                         out_stream->codec->width = width;  
  98.                         out_stream->codec->height = height;
  99.                         out_stream->codec->time_base.num = 1;  
  100.                         out_stream->codec->time_base.den = 25;  
  101.                         out_stream->codec->bit_rate = 400000;  
  102.                         out_stream->codec->gop_size=250;
  103.                         //H264
  104.                         out_stream->codec->qmin = 10;
  105.                         out_stream->codec->qmax = 40;
  106.                         //Optional Param
  107.                         out_stream->codec->max_b_frames=3;

  108.                         AVDictionary *param = NULL;
  109.                         if (out_stream->codec->codec->id == AV_CODEC_ID_H264)
  110.                         {
  111.                                 av_dict_set(¶m, "preset", "slow", 0);
  112.                                 av_dict_set(¶m, "tune", "zerolatency", 0);
  113.                                 av_dict_set(¶m, "profile", "main", 0);
  114.                         }

  115.                         //open encoder
  116.                         ret = avcodec_open2(out_stream->codec, out_stream->codec->codec, ¶m);

  117.                         if (ret < 0)
  118.                         {
  119.                                 printf("can not open encoder");
  120.                                 return ret;
  121.                         }

  122.                         if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
  123.                                 out_stream->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;

  124.                         break;
  125.                 }
  126.         }

  127.         //dump output info
  128.         av_dump_format(ofmt_ctx, 0, filename, 1);

  129.         //open the output file handle
  130.         if (!(ofmt_ctx->oformat->flags & AVFMT_NOFILE))
  131.         {
  132.                 ret = avio_open(&ofmt_ctx->pb, filename, AVIO_FLAG_WRITE);
  133.                 if (ret < 0)
  134.                 {
  135.                         printf("can not open the output file handle");
  136.                         return ret;
  137.                 }
  138.         }

  139.         //write output file header
  140.         if ((ret = avformat_write_header(ofmt_ctx, NULL)) < 0)
  141.         {
  142.                 printf("can not write output file header");
  143.                 return ret;
  144.         }

  145.         return 0;
  146. }

  147. static int init_filters(const char *filters_descr)
  148. {
  149.         char args[512];
  150.         int ret;
  151.         AVFilter *buffersrc  = avfilter_get_by_name("buffer");
  152.         AVFilter *buffersink = avfilter_get_by_name("ffbuffersink");
  153.         AVFilterInOut *outputs = avfilter_inout_alloc();
  154.         AVFilterInOut *inputs  = avfilter_inout_alloc();
  155.         enum PixelFormat pix_fmts[] = { PIX_FMT_YUV420P, PIX_FMT_NONE };
  156.         AVBufferSinkParams *buffersink_params;

  157.         filter_graph = avfilter_graph_alloc();

  158.         /* buffer video source: the decoded frames from the decoder will be inserted here. */
  159.         _snprintf(args, sizeof(args),
  160.                 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
  161.                 pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt,
  162.                 pCodecCtx->time_base.num, pCodecCtx->time_base.den,
  163.                 pCodecCtx->sample_aspect_ratio.num, pCodecCtx->sample_aspect_ratio.den);

  164.         ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
  165.                 args, NULL, filter_graph);
  166.         if (ret < 0) {
  167.                 printf("Cannot create buffer source\n");
  168.                 return ret;
  169.         }

  170.         /* buffer video sink: to terminate the filter chain. */
  171.         buffersink_params = av_buffersink_params_alloc();
  172.         buffersink_params->pixel_fmts = pix_fmts;
  173.         ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
  174.                 NULL, buffersink_params, filter_graph);
  175.         av_free(buffersink_params);
  176.         if (ret < 0) {
  177.                 printf("Cannot create buffer sink\n");
  178.                 return ret;
  179.         }

  180.         /* Endpoints for the filter graph. */
  181.         outputs->name       = av_strdup("in");
  182.         outputs->filter_ctx = buffersrc_ctx;
  183.         outputs->pad_idx    = 0;
  184.         outputs->next       = NULL;

  185.         inputs->name       = av_strdup("out");
  186.         inputs->filter_ctx = buffersink_ctx;
  187.         inputs->pad_idx    = 0;
  188.         inputs->next       = NULL;

  189.         if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,
  190.                 &inputs, &outputs, NULL)) < 0)
  191.                 return ret;

  192.         if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
  193.                 return ret;
  194.         return 0;
  195. }

  196. static int encode_write_video_frame(AVFrame *filt_frame, int *got_frame)
  197. {
  198.         int ret;
  199.         int got_frame_local;
  200.         AVPacket enc_pkt;
  201.         unsigned int stream_index = 0;
  202.         if (!got_frame)
  203.                 got_frame = &got_frame_local;
  204.         av_log(NULL, AV_LOG_INFO, "Encoding frame\n");
  205.         /* encode filtered frame */
  206.         enc_pkt.data = NULL;
  207.         enc_pkt.size = 0;
  208.         av_init_packet(&enc_pkt);
  209.         ret = avcodec_encode_video2(ofmt_ctx->streams[stream_index]->codec, &enc_pkt,
  210.                 filt_frame, got_frame);
  211.         av_frame_free(&filt_frame);
  212.         if (ret < 0)
  213.                 return ret;
  214.         if (!(*got_frame))
  215.                 return 0;
  216.         /* prepare packet for muxing */
  217.         enc_pkt.stream_index = stream_index;
  218.         enc_pkt.dts = av_rescale_q_rnd(enc_pkt.dts,
  219.                 ofmt_ctx->streams[stream_index]->codec->time_base,
  220.                 ofmt_ctx->streams[stream_index]->time_base,
  221.                 (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
  222.         enc_pkt.pts = av_rescale_q_rnd(enc_pkt.pts,
  223.                 ofmt_ctx->streams[stream_index]->codec->time_base,
  224.                 ofmt_ctx->streams[stream_index]->time_base,
  225.                 (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
  226.         enc_pkt.duration = av_rescale_q(enc_pkt.duration,
  227.                 ofmt_ctx->streams[stream_index]->codec->time_base,
  228.                 ofmt_ctx->streams[stream_index]->time_base);
  229.         av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");
  230.         /* mux encoded frame */
  231.         ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
  232.         return ret;
  233. }

  234. static int filter_encode_write_video_frame(AVFrame *frame)
  235. {
  236.     int ret;
  237.     AVFrame *filt_frame;
  238.     av_log(NULL, AV_LOG_INFO, "Pushing decoded frame to filters\n");
  239.     /* push the decoded frame into the filtergraph */
  240.     ret = av_buffersrc_add_frame_flags(buffersrc_ctx,
  241.             frame, 0);
  242.     if (ret < 0) {
  243.         av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
  244.         return ret;
  245.     }
  246.     /* pull filtered frames from the filtergraph */
  247.     while (1) {
  248.         filt_frame = av_frame_alloc();
  249.         if (!filt_frame) {
  250.             ret = AVERROR(ENOMEM);
  251.             break;
  252.         }
  253.         av_log(NULL, AV_LOG_INFO, "Pulling filtered frame from filters\n");
  254.         ret = av_buffersink_get_frame(buffersink_ctx,
  255.                 filt_frame);
  256.         if (ret < 0) {
  257.             /* if no more frames for output - returns AVERROR(EAGAIN)
  258.              * if flushed and no more frames for output - returns AVERROR_EOF
  259.              * rewrite retcode to 0 to show it as normal procedure completion
  260.              */
  261.             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
  262.                 ret = 0;
  263.             av_frame_free(&filt_frame);
  264.             break;
  265.         }
  266.         filt_frame->pict_type = AV_PICTURE_TYPE_NONE;
  267.         ret = encode_write_video_frame(filt_frame, NULL);
  268.         if (ret < 0)
  269.             break;
  270.     }
  271.     return ret;
  272. }

  273. int flush_encoder(AVFormatContext *fmt_ctx,unsigned int stream_index)
  274. {
  275.         int ret;
  276.         int got_frame;
  277.         if (!(ofmt_ctx->streams[stream_index]->codec->codec->capabilities &
  278.                 CODEC_CAP_DELAY))
  279.                 return 0;
  280.         while (1) {
  281.                 av_log(NULL, AV_LOG_INFO, "Flushing stream #%u encoder\n", stream_index);
  282.                 ret = encode_write_video_frame(NULL, &got_frame);
  283.                 if (ret < 0)
  284.                         break;
  285.                 if (!got_frame)
  286.                         return 0;
  287.         }
  288.         return ret;
  289. }

  290. int _tmain(int argc, _TCHAR* argv[])
  291. {
  292.         char filter_descr[100]/* = "movie=my_logo.png[wm];[in][wm]overlay=5:5[out]"*/;
  293.         AVPacket pkt_in, pkt_out;
  294.         unsigned int stream_index;
  295.         int ret;
  296.         AVPacket packet;
  297.         AVFrame *frame;
  298.         int got_frame;
  299.         int width, height;
  300.         width = 400;
  301.         height = 300;
  302.         
  303.         sprintf(filter_descr, "[in]scale=%d:%d[out]", width, height);

  304.         avcodec_register_all();
  305.         av_register_all();
  306.         avfilter_register_all();

  307.         if ((ret = open_input_file("test.mp4")) < 0)
  308.                 goto end;
  309.         if ((ret = init_filters(filter_descr)) < 0)
  310.                 goto end;
  311.         if ((ret = openoutputfile("test_scale.mp4", width, height)) < 0)
  312.                 goto end;
  313.         
  314.         // to be add
  315.         while(1)
  316.         {
  317.                 if (av_read_frame(ifmt_ctx, &pkt_in) < 0)
  318.                 {
  319.                         break;
  320.                 }
  321.                 pkt_out.data = NULL;
  322.                 pkt_out.size = 0;
  323.                 av_init_packet(&pkt_out);
  324.                 stream_index = pkt_in.stream_index;
  325.                 frame = av_frame_alloc();
  326.                 int got_frame = -1;
  327.                 int ret = -1;

  328.                 //calculate the pts and dts
  329.                 pkt_in.dts = av_rescale_q_rnd(pkt_in.dts,
  330.                         ifmt_ctx->streams[stream_index]->time_base,
  331.                         ifmt_ctx->streams[stream_index]->codec->time_base,
  332.                         (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
  333.                 pkt_in.pts = av_rescale_q_rnd(pkt_in.pts,
  334.                         ifmt_ctx->streams[stream_index]->time_base,
  335.                         ifmt_ctx->streams[stream_index]->codec->time_base,
  336.                         (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));

  337.                
  338.                 if (ifmt_ctx->streams[stream_index]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
  339.                 {
  340.                         ret = avcodec_decode_video2(ifmt_ctx->streams[stream_index]->codec, frame, &got_frame, &pkt_in);
  341.                         if (ret < 0)
  342.                         {
  343.                                 av_frame_free(&frame);
  344.                                 printf("decoding video stream failed\n");
  345.                                 break;
  346.                         }

  347.                         if (got_frame)
  348.                         {
  349.                                 frame->pts = av_frame_get_best_effort_timestamp(frame);
  350.                                 ret = filter_encode_write_video_frame(frame);
  351.                                 av_frame_free(&frame);
  352.                                 if (ret < 0)
  353.                                         goto end;
  354.                         }

  355.                 }
  356.         }


  357.         //Flush Encoder
  358.         ret = flush_encoder(ofmt_ctx,0);
  359.         if (ret < 0) {
  360.                 printf("Flushing encoder failed\n");
  361.                 return -1;
  362.         }

  363.         av_write_trailer(ofmt_ctx);
  364.         
  365. end:
  366.         avfilter_graph_free(&filter_graph);
  367.         if (pCodecCtx)
  368.                 avcodec_close(pCodecCtx);
  369.         avformat_close_input(&ifmt_ctx);

  370.         if (ofmt_ctx && !(ofmt_ctx->oformat->flags & AVFMT_NOFILE))
  371.         {
  372.                 for (int i = 0; i < ofmt_ctx->nb_streams; i++)
  373.                 {
  374.                         if (ofmt_ctx->streams[i]->codec)
  375.                         {
  376.                                 avcodec_close(ofmt_ctx->streams[i]->codec);
  377.                         }
  378.                 }

  379.                 avio_close(ofmt_ctx->pb);
  380.         }
  381.         avformat_free_context(ofmt_ctx);

  382.         if (ret < 0 && ret != AVERROR_EOF) {
  383.                 char buf[1024];
  384.                 av_strerror(ret, buf, sizeof(buf));
  385.                 printf("Error occurred: %s\n", buf);
  386.                 return -1;
  387.         }

  388.         return 0;
  389. }
复制代码
回复

使用道具 举报

646

主题

898

帖子

2885

积分

管理员

Rank: 9Rank: 9Rank: 9

积分
2885
 楼主| 发表于 2017-11-18 21:32:24 | 显示全部楼层
3、解释

简单说下流程:open input->open output->init filter -> read packet -> decode frame -> push into filter -> pull from filter -> encode -> write into file
回复 支持 反对

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则


手机版|北南南北论坛  

GMT+8, 2017-12-16 17:14 , Processed in 0.065281 second(s), 26 queries .

© 2001-2016 VxWorks6 Inc.

快速回复 返回顶部 返回列表