zoukankan      html  css  js  c++  java

  • FFmpeg滤镜代码级分析

    http://blog.chinaunix.net/uid-26000296-id-3322071.html

    前一篇文章《为FFmpeg添加自定义滤镜》详细讲述了FFmpeg的滤镜添加步骤，并给出了代码实例。

    本文将以FFmpeg自带的deinterlace滤镜”yadif – yet another deinterlace filter”为例分析

    FFmpeg滤镜的代码级实现机制。

     

    总的来说,FFmpeg的滤镜机制和MicroSoft Directshow机制基本相同——不知道谁学了谁的，还是程

    序员所见略同：

    构建机制上：FFmpeg自己实现了统一的对象模型，DShow是COM的实现;

    框架实现上：都使用filter graph来管理滤镜;

    连接方式上：FFmpeg使用Pad结构体，DShow使用Pin，两者都是分配器的机制;

     

    下面是以层级来分析代码：

    FFmpeg转码层的伪码如下所示，红色粗体是和filter相关的函数:

    点击(此处)折叠或打开

    1. int transcode(AVFormatContext **output_files,
    2.               int nb_output_files,
    3.               AVInputFile *input_files,
    4.               int nb_input_files,
    5.               AVStreamMap *stream_maps, 
    6.               int nb_stream_maps)
    7. {
    8.   …
    9.   解码参数计算;
    12.   #if CONFIG_AVFILTER
    13.   if (configure_video_filters(ist, ost)) {
    14.     fprintf(stderr, "Error opening filters! ");
    15.     ret = AVERROR(EINVAL);
    16.     goto fail;
    17.   }
    18.   #endif
    21.   编码参数计算;
    23.   output_packet(ist, ist_index, ost_table,
    24.                 nb_ostreams, &pkt, &errorflag);
    26.   ……
    28.   return ret;
    29. }

    函数configure_video_filters是用来初始化filter graph 和filter本身的初始化；

    函数output_packet是FFmpeg整个解码，滤镜处理，编码调用的实现。

     

    1. 先来看configure_video_filters的实现：

    点击(此处)折叠或打开

    1. int configure_video_filters(AVInputStream *ist, 
    2.                             AVOutputStream *ost)
    3. {
    4.    // 类似于directshow一样初始化filter graph等;
    5.   ost->graph = avfilter_graph_alloc();
    6.   …
        // 初始化filter graph和filter
    1.   avfilter_graph_parse(ost->graph, ost->avfilter, 
    2.                        &inputs, &outputs, NULL)
    5.   // 检查filter支持的媒体类型
    6.   avfilter_graph_config(ost->graph, NULL);
    8.   。。。
    10.   return 0;
    11. }

    filter graph和filter的初始化:

    点击(此处)折叠或打开

    1. int avfilter_graph_parse(AVFilterGraph *graph, 
    2.                          const char *filters,
    3.                          AVFilterInOut **open_inputs, 
    4.                          AVFilterInOut **open_outputs,
    5.                          void *log_ctx)
    6. {
    8.     do {
    10.         parse_inputs(&filters, &curr_inputs, open_outputs, log_ctx);
    12.         parse_filter(&filter, &filters, graph, index, log_ctx);
    15.         if (filter->input_count == 1 && !curr_inputs && !index) {
    16.             /* First input can be omitted if it is "[in]" */
    17.             const char *tmp = "[in]";
    18.             if ((ret = parse_inputs(&tmp, &curr_inputs, open_outputs, 
    19.                                     log_ctx)) < 0)
    20.                 goto fail;
    21.         }
    24.         link_filter_inouts(filter, &curr_inputs, open_inputs, log_ctx);
    27.         parse_outputs(&filters, &curr_inputs, open_inputs, 
    28.                       open_outputs, log_ctx);
    31.         filters += strspn(filters, WHITESPACES);
    32.         chr = *filters++;
    34.         index++;
    35.     } while (chr == ',' || chr == ';');
    37.     if (open_inputs && *open_inputs && 
    38.         !strcmp((*open_inputs)->name, ""out"") && curr_inputs) {
    39.         /* Last output can be omitted if it is "[out]" */
    40.         const char *tmp = "[out]";
    41.         if ((ret = parse_outputs(&tmp, &curr_inputs, open_inputs, 
    42.                                               open_outputs, log_ctx)) < 0)
    43.             goto fail;
    45.     }
    47.     return 0;
    48. }

    点击(此处)折叠或打开

    2. static int parse_filter(AVFilterContext **filt_ctx, 
    3.                         const char **buf, AVFilterGraph *graph,"
    4.                         int index, void *log_ctx)
    5. {
    6.     char *opts = NULL;
    7.     char *name = av_get_token(buf, "=,;[ ");
    8.     int ret;
    10.     if (**buf == '=') {
    11.         (*buf)++;
    12.         opts = av_get_token(buf, "[],; ");
    13.     }
    15.     ret = create_filter(filt_ctx, graph, index, name, opts, log_ctx);
    17.     av_free(name);
    18.     av_free(opts);
    19.     return ret;
    20. }

    到了真正的Filter graph初始化，这部分和DShow很相似：

    点击(此处)折叠或打开

    1. int create_filter(AVFilterContext **filt_ctx, 
    2.                   AVFilterGraph *ctx, int index,
    3.                   const char *filt_name, const char *args, 
    4.                   void *log_ctx)
    6. {
    7.     AVFilter *filt;
    8.     char inst_name[30];
    9.     char tmp_args[256];
    10.     int ret;
    12.     // 注册当前filter到静态数组中
    13.     filt = avfilter_get_by_name(filt_name);
    15.     // 分配并初始化输入输出Pad
    16.     ret = avfilter_open(filt_ctx, filt, inst_name);
    18.     // 将当前filter添加到filter graph中
    19.     ret = avfilter_graph_add_filter(ctx, *filt_ctx);
    21.     // 通过函数指针，调用当前filter的初始化函数
    22.     ret = avfilter_init_filter(*filt_ctx, args, NULL);
    23.     return 0;
    24. }

    点击(此处)折叠或打开

    1. int avfilter_init_filter(AVFilterContext *filter, 
    2.                          const char *args, 
    3.                          void *opaque)
    4. {
    5.     int ret=0;
    7.     if (filter->filter->init)
    8.         ret = filter->filter->init(filter, args, opaque);
    9.     return ret;
    10. }

    点击(此处)折叠或打开

    1. static av_cold int init(AVFilterContext *ctx, 
    2.                                   const char *args, 
    3.                                   void *opaque)
    4. {
    5.     YADIFContext *yadif = ctx->priv;
    6.     av_unused int cpu_flags = av_get_cpu_flags();
    8.     yadif->mode = 0;
    9.     yadif->parity = -1;
    10.     yadif->csp = NULL;
    12.     // 滤镜函数指针初始化赋值
    13.     yadif->filter_line = filter_line_c;
    15.     return 0;
    16. }

    2. 接着来看两个filter的Pad连接时的媒体类型的协商机制

    点击(此处)折叠或打开

    1. int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
    2. {
    3.     int ret;
         // 检查filter的权限
    1.     if ((ret = ff_avfilter_graph_check_validity(graphctx, log_ctx)))
    2.         return ret;
    3.     
    4.     // 检查Pad支持的媒体类型
    5.     if ((ret = ff_avfilter_graph_config_formats(graphctx, log_ctx)))
    6.         return ret;
         // 
    1.     if ((ret = ff_avfilter_graph_config_links(graphctx, log_ctx)))
    2.         return ret;
    4.     return 0;
    5. }

    检查Pad支持的媒体类型 :

    点击(此处)折叠或打开

    1. int ff_avfilter_graph_config_formats(AVFilterGraph *graph, 
    2.                                                           AVClass *log_ctx)
    3. {
    4.     int ret;
    6.     /* find supported formats from sub-filters, and merge along links */
    7.     if ((ret = query_formats(graph, log_ctx)) < 0)
    8.         return ret;
    10.     /* Once everything is merged, it's possible that we'll still have
    11.      * multiple valid media format choices. We pick the first one. */
    12.     pick_formats(graph);
    14.     return 0;
    15. }

    点击(此处)折叠或打开

    1. static int query_formats(AVFilterGraph *graph, 
    2.                          AVClass *log_ctx)
    3. {
    4.     int i, j, ret;
    5.     int scaler_count = 0;
    6.     char inst_name[30];
    8.     /* ask all the sub-filters for their supported media formats */
    9.     for (i = 0; i < graph->filter_count; i++) {
    10.         if (graph->filters[i]->filter->query_formats)
    11.             graph->filters[i]->filter->query_formats(graph->filters[i]);
    12.         else
    13.             avfilter_default_query_formats(graph->filters[i]);
    14.     }
    16.     /* go through and merge as many format lists as possible */
    17.     for (i = 0; i < graph->filter_count; i++) {
    19.        … 
    20.     
    21.     }
    23.     return 0;
    24. }

    点击(此处)折叠或打开

    1. /* 检查连接用Pad支持的媒体类型 */
    2. static int query_formats(AVFilterContext *ctx)
    3. {
    4.     static const enum PixelFormat pix_fmts[] = {
    5.         PIX_FMT_YUV420P,
    6.         PIX_FMT_YUV422P,
    7.         PIX_FMT_YUV444P,
    8.         PIX_FMT_YUV410P,
    9.         PIX_FMT_YUV411P,
    10.         PIX_FMT_GRAY8,
    11.         PIX_FMT_YUVJ420P,
    12.         PIX_FMT_YUVJ422P,
    13.         PIX_FMT_YUVJ444P,
    14.         AV_NE( PIX_FMT_GRAY16BE, PIX_FMT_GRAY16LE ),
    15.         PIX_FMT_YUV440P,
    16.         PIX_FMT_YUVJ440P,
    17.         AV_NE( PIX_FMT_YUV420P16BE, PIX_FMT_YUV420P16LE ),
    18.         AV_NE( PIX_FMT_YUV422P16BE, PIX_FMT_YUV422P16LE ),
    19.         AV_NE( PIX_FMT_YUV444P16BE, PIX_FMT_YUV444P16LE ),
    20.         PIX_FMT_NONE
    21.     };
    23.     avfilter_set_common_pixel_formats(ctx, 
    24.                                       avfilter_make_format_list(pix_fmts));
    26.     return 0;
    27. }

    3. 最后来看滤镜的连接和对每帧图像处理时的调用

    点击(此处)折叠或打开

    1. int output_packet(AVInputStream *ist, int ist_index,
    2.                   AVOutputStream **ost_table,
    3.                   int nb_ostreams,
    4.                   const AVPacket *pkt, 
    5.                   int *errorflag)
    6. {
    8.   /* decode the packet if needed */
    9.   if (ist->decoding_needed) {
    11.     解码;
    13. #if CONFIG_AVFILTER
    14.     if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
    15.     if (start_time == 0 || ist->pts >= start_time) {
    16.       for(i=0;i<nb_ostreams;i++) {
    17.         ost = ost_table[i];
    18.         if (ost->input_video_filter && ost->source_index == ist_index) {
    19.           if (!picture.sample_aspect_ratio.num)
    20.           picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
    21.           picture.pts = ist->pts;
    23.           av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
    25.         }
    26.       }
    27.     }
    28. #endif
    30. #if CONFIG_AVFILTER
    31.     frame_available = ist->st->codec->codec_type
    32.                       != AVMEDIA_TYPE_VIDEO ||
    33.                       !ost->output_video_filter ||
    34.                       avfilter_poll_frame(ost->output_video_filter->inputs[0]);
    35.     while (frame_available) {
    36.       if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
    37.           ost->output_video_filter) {
    38.         AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
    39.         if (av_vsink_buffer_get_video_buffer_ref(ost->output_video_filter,
    40.             &ost->picref, 0) < 0)
    41.           goto cont;
    42.         if (ost->picref) {
    43.           AVRational tempVar = {1, AV_TIME_BASE};
    44.           avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
    45.           //ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
    46.           ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, tempVar);//modify by chenrui
    47.         }
    48.       }
    49. #endif
    51.       编码;
    53.       return 0;
    54.       fail_decode:
    55.       return -1;
    56.    }
    57.   }
    58. }

    先来看滤镜的连接：

    点击(此处)折叠或打开

    2. int av_vsrc_buffer_add_frame(AVFilterContext *buffer_src,
    3.                              const AVFrame *frame, int flags)
    4. {
    5.     // 从帧列表中得到当前帧
    6.     AVFilterBufferRef *picref =
    7.         avfilter_get_video_buffer_ref_from_frame(frame, 
    8.                                                  AV_PERM_WRITE);
    9.     if (!picref)
    10.         return AVERROR(ENOMEM);
    11.     ret = av_vsrc_buffer_add_video_buffer_ref(buffer_src, 
    12.                                               picref, flags);
    13.  
    14.  
    15.     picref->buf->data[0] = NULL;
    16.     avfilter_unref_buffer(picref);
    17.  
    18.     return ret;
    19. }
    20.  
    21.  
    22. int av_vsrc_buffer_add_video_buffer_ref(AVFilterContext *buffer_filter,
    23.                                         AVFilterBufferRef *picref, int flags)"
    24. {
    25.  
    26.     智能插入相应的filter; 
    27.  
    28.     c->picref = avfilter_get_video_buffer(outlink, AV_PERM_WRITE,
    29.                                           picref->video->w, picref->video->h);
    30.  
    31.     av_image_copy(c->picref->data, c->picref->linesize,
    32.                   picref->data, picref->linesize,
    33.                   picref->format, picref->video->w, picref->video->h);
    34.     avfilter_copy_buffer_ref_props(c->picref, picref);
    35.  
    36.     return 0;
    37. }
    38.  
    39.  
    40. AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link,
    41.                                       int perms, int w, int h)
    42. {
    43.     AVFilterBufferRef *ret = NULL;
    44.  
    45.     if (link->dstpad->get_video_buffer)
    46.         ret = link->dstpad->get_video_buffer(link, perms, w, h);
    47.  
    48.     if (!ret)
    49.         ret = avfilter_default_get_video_buffer(link, perms, w, h);
    50.  
    51.     if (ret)
    52.         ret->type = AVMEDIA_TYPE_VIDEO;
    53.  
    54.     return ret;
    55. }
    56.  
    57. AVFilterBufferRef *get_video_buffer(AVFilterLink *link, int perms, 
    58.                                     int w, int h)
    59. {
    60.     AVFilterBufferRef *picref;
    61.     int width = FFALIGN(w, 32);
    62.     int height= FFALIGN(h+2, 32);
    63.     int i;
    64.  
    65.     picref = avfilter_default_get_video_buffer(link, perms, width, height);
    66.  
    67.     picref->video->w = w;
    68.     picref->video->h = h;
    69.  
    70.     for (i = 0; i < 3; i++)
    71.         picref->data[i] += picref->linesize[i];
    72.  
    73.     return picref;
    74. }

    最后来看图像处理函数的实现：

    点击(此处)折叠或打开

    1. int avfilter_poll_frame(AVFilterLink *link)
    2. {
    3.     int i, min = INT_MAX;
    5.     if (link->srcpad->poll_frame)
    6.         return link->srcpad->poll_frame(link);
    7.     for (i = 0; i < link->src->input_count; i++) {
    8.         int val;
    9.         if (!link->src->inputs[i])
    10.             return -1;
    11.         val = avfilter_poll_frame(link->src->inputs[i]);
    12.         min = FFMIN(min, val);
    13.     }
    15.     return min;
    16. }
    19. int poll_frame(AVFilterLink *link)
    20. {
    21.     YADIFContext *yadif = link->src->priv;
    22.     int ret, val;
    24.     if (yadif->frame_pending)
    25.         return 1;
    27.     val = avfilter_poll_frame(link->src->inputs[0]);
    29.     if (val==1 && !yadif->next) { 
    30.       //FIXME change API to not requre this red tape
    31.       if ((ret = avfilter_request_frame(link->src->inputs[0])) < 0)
    32.         return ret;
    33.       val = avfilter_poll_frame(link->src->inputs[0]);
    34.     }
    35.     assert(yadif->next || !val);
    37.     return val * ((yadif->mode&1)+1);
    38. }
    40. int avfilter_request_frame(AVFilterLink *link)
    41. {
    44.     if (link->srcpad->request_frame)
    45.         return link->srcpad->request_frame(link);
    46.     else if (link->src->inputs[0])
    47.         return avfilter_request_frame(link->src->inputs[0]);
    48.     else return -1;
    49. }
    53. static int request_frame(AVFilterLink *link)
    54. {
    55.     BufferSourceContext *c = link->src->priv;
    57.     if (!c->picref) {
    58.         av_log(link->src, AV_LOG_WARNING,
    59.                "request_frame() called with no available frame! ");
    60.         return AVERROR(EINVAL);
    61.     }
         // 图像处理函数的真正实现
    1.     avfilter_start_frame(link, avfilter_ref_buffer(c->picref, ~0));
    2.     avfilter_draw_slice(link, 0, link->h, 1);
    3.     avfilter_end_frame(link);
    4.  
    5.     avfilter_unref_buffer(c->picref);
    6.     c->picref = NULL;
    8.     return 0;
    9. }

    完结。
  • 相关阅读:
    RegExp.$1
    Wide&Deep 模型学习教程
    docker 安装与使用的相关问题
    Centos 防火墙
    odoo ERP 系统安装与使用
    Linux 开机自动启动脚本
    intel RDT技术管理cache和memory_bandwidth
    tensorflow 中 inter_op 和 intra_op
    centos 7 安装 nginx 或 apache，及其比较
    Dependency injection in .NET Core的最佳实践
  • 原文地址：https://www.cnblogs.com/youngt/p/3737036.html
Copyright © 2011-2022 走看看