FFMPEG中的两输入Filter实现(一)

2023-09-27 09:03:28

开帖大吉！ 

利用FFMPEG工作已有一年多，许多学习文档散落在电脑各处，没有一个清晰明确的组织脉络；还有踩过又填平的各种坑，时间久了难免遗忘，再次遭遇时仍然要从头查起；而且事必躬亲也是毫无疑问的低效率，不利于后来同事的成长。因此有了开博的决定，希望记录下自己走过的脚印，见证自己的成长，也能帮助后来人。

近期在ffmpeg3.3版本上开发一个基于overlay滤镜的新功能，因此花了些时间把双输入滤镜的实现梳理了一番，整理的大致的函数调用关系图如下：最左侧浅黄色分支为滤镜注册；中间分支浅绿色部分是滤镜的解析和初始化；最右侧分支的浅紫色部分是滤镜的主体实现过程。因为涉及到的函数比较多，因此本篇先分析滤镜注册和初始化部分，滤镜的具体实现留到下一篇分析。

 

FFMPEG中的两输入Filter实现(一)

使用的命令行如下：

ffmpeg -i input.ts -i logo.png -c:v libx264 -s 1280x720 -b:v 2000k -filter_complex "[0:v][1:v]overlay=100:100"  -c:a copy -f mpegts -y overlayout.ts

一、滤镜的注册

 avfilter_register_all()：ffmpeg中，任何滤镜在使用之前，必须先经过注册。overlay滤镜的注册如下：

REGISTER_FILTER(OVERLAY,        overlay,        vf);
再来看看最终调用的注册函数： 

    

  1. int avfilter_register(AVFilter *filter)
    2. 

  2. {
    3. 

  3.     AVFilter **f = last_filter;
    4. 

  4.  
    5. 

  5.     /* the filter must select generic or internal exclusively */
    6. 

  6.     av_assert0((filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE) != AVFILTER_FLAG_SUPPORT_TIMELINE);
    7. 

  7.  
    8. 

  8.     filter->next = NULL;
    9. 

  9.  
    10. 

  10.     while(*f || avpriv_atomic_ptr_cas((void * volatile *)f, NULL, filter))
    11. 

  11.         f = &(*f)->next;
    12. 

  12.  
    13. 

  13.     last_filter = &filter->next;    return 0;
    14. 

  14. }
    15. 

所谓的滤镜注册，也就是把目标滤镜的结构体加入到滤镜结构体链表中。
二、滤镜的解析与初始化


FFMPEG中的两输入Filter实现(一)


由于overlay的输入含有两个或以上，因此采用的是complex filter。complex filter的解析和初始化在ffmpeg_parse_options阶段完成，下面我们来逐层分析该阶段对滤镜的操作。

1. init_complex_filters():

    

  1. static int init_complex_filters(void)
    2. 

  2. {
    3. 

  3.     int i, ret = 0;
    4. 

  4.  
    5. 

  5.     for (i = 0; i < nb_filtergraphs; i++) {
    6. 

  6.         ret = init_complex_filtergraph(filtergraphs[i]);
    7. 

  7.         if (ret < 0)
    8. 

  8.             return ret;
    9. 

  9.     }
    10. 

  10.     return 0;
    11. 

  11. }
    12.
逐个初始化滤镜图，nb_filtergraphs在解析参数阶段被赋值，在本例中，nb_filtergraphs = 1。


2. init_complex_filtergraph():

    

  1. int init_complex_filtergraph(FilterGraph *fg)
    2. 

  2. {
    3. 

  3.     AVFilterInOut *inputs, *outputs, *cur;
    4. 

  4.     AVFilterGraph *graph;
    5. 

  5.     int ret = 0;
    6. 

  6.  
    7. 

  7.     /* this graph is only used for determining the kinds of inputs
    8. 

  8.      * and outputs we have, and is discarded on exit from this function */
    9. 

  9.     graph = avfilter_graph_alloc();  //为临时filter graph分配空间
    10. 

  10.     if (!graph)
    11. 

  11.         return AVERROR(ENOMEM);
    12. 

  12.  
    13. 

  13.     ret = avfilter_graph_parse2(graph, fg->graph_desc, &inputs, &outputs); //解析并创建filter
    14. 

  14.     if (ret < 0)
    15. 

  15.         goto fail;
    16. 

  16.  
    17. 

  17.     for (cur = inputs; cur; cur = cur->next)    //初始化输入
    18. 

  18.         init_input_filter(fg, cur);
    19. 

  19.  
    20. 

  20.     for (cur = outputs; cur;) {       //初始化输出，此例中只有一个输出
    21. 

  21.         GROW_ARRAY(fg->outputs, fg->nb_outputs);
    22. 

  22.         fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]));
    23. 

  23.         if (!fg->outputs[fg->nb_outputs - 1])
    24. 

  24.             exit_program(1);
    25. 

  25.  
    26. 

  26.         fg->outputs[fg->nb_outputs - 1]->graph   = fg;
    27. 

  27.         fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
    28. 

  28.         fg->outputs[fg->nb_outputs - 1]->type    = avfilter_pad_get_type(cur->filter_ctx->output_pads,
    29. 

  29.                                                                          cur->pad_idx);
    30. 

  30.         fg->outputs[fg->nb_outputs - 1]->name = describe_filter_link(fg, cur, 0);
    31. 

  31.         cur = cur->next;
    32. 

  32.         fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
    33. 

  33.     }
    34. 

  34.  
    35. 

  35. fail:
    36. 

  36.     avfilter_inout_free(&inputs); //删除分配的临时空间
    37. 

  37.     avfilter_graph_free(&graph);
    38. 

  38.     return ret;
    39. 

  39. }
    40. 

FFMPEG中的两输入Filter实现(一)

3. av_filter_graph_parse2(): 

    

  1. int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters,
    2. 

  2.                           AVFilterInOut **inputs,
    3. 

  3.                           AVFilterInOut **outputs)
    4. 

  4. {
    5. 

  5.     int index = 0, ret = 0;
    6. 

  6.     char chr = 0;
    7. 

  7.  
    8. 

  8.     AVFilterInOut *curr_inputs = NULL, *open_inputs = NULL, *open_outputs = NULL;
    9. 

  9.  
    10. 

  10.     filters += strspn(filters, WHITESPACES);
    11. 

  11.  
    12. 

  12.     if ((ret = parse_sws_flags(&filters, graph)) < 0)
    13. 

  13.         goto fail;
    14. 

  14.  
    15. 

  15.     do {
    16. 

  16.         AVFilterContext *filter;
    17. 

  17.         filters += strspn(filters, WHITESPACES);
    18. 

  18.  
    19. 

  19.         if ((ret = parse_inputs(&filters, &curr_inputs, &open_outputs, graph)) < 0) //根据命令行解析filter的输入，此例中为[0:v]和[1:v]
    20. 

  20.             goto end;
    21. 

  21.         if ((ret = parse_filter(&filter, &filters, graph, index, graph)) < 0)   //解析filter名称及其options，并创建该filter
    22. 

  22.             goto end;
    23. 

  23.  
    24. 

  24.  
    25. 

  25.         if ((ret = link_filter_inouts(filter, &curr_inputs, &open_inputs, graph)) < 0)   //将输入输出加入filter link链表
    26. 

  26.             goto end;
    27. 

  27.  
    28. 

  28.         if ((ret = parse_outputs(&filters, &curr_inputs, &open_inputs, &open_outputs,  //解析filter输出
    29. 

  29.                                  graph)) < 0)
    30. 

  30.             goto end;
    31. 

  31.  
    32. 

  32.         filters += strspn(filters, WHITESPACES);
    33. 

  33.         chr = *filters++;
    34. 

  34.  
    35. 

  35.         if (chr == ';' && curr_inputs)
    36. 

  36.             append_inout(&open_outputs, &curr_inputs);
    37. 

  37.         index++;
    38. 

  38.     } while (chr == ',' || chr == ';');
    39. 

  39.  
    40. 

  40.     if (chr) {
    41. 

  41.         av_log(graph, AV_LOG_ERROR,
    42. 

  42.                "Unable to parse graph description substring: \"%s\"\n",
    43. 

  43.                filters - 1);
    44. 

  44.         ret = AVERROR(EINVAL);
    45. 

  45.         goto end;
    46. 

  46.     }
    47. 

  47.  
    48. 

  48.     append_inout(&open_outputs, &curr_inputs);
    49. 

  49.  
    50. 

  50.  
    51. 

  51.     *inputs  = open_inputs;
    52. 

  52.     *outputs = open_outputs;
    53. 

  53.     return 0;
    54. 

  54.  
    55. 

  55.  fail:end:
    56. 

  56.     while (graph->nb_filters)
    57. 

  57.         avfilter_free(graph->filters[0]);
    58. 

  58.     av_freep(&graph->filters);
    59. 

  59.     avfilter_inout_free(&open_inputs);
    60. 

  60.     avfilter_inout_free(&open_outputs);
    61. 

  61.     avfilter_inout_free(&curr_inputs);
    62. 

  62.  
    63. 

  63.     *inputs  = NULL;
    64. 

  64.     *outputs = NULL;
    65. 

  65.  
    66. 

  66.     return ret;
    67. 

  67. }
    68. 

FFMPEG中的两输入Filter实现(一)

4. init_input_filter(): 

    

  1. static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
    2. 

  2. {
    3. 

  3.     InputStream *ist = NULL;
    4. 

  4.     enum AVMediaType type = avfilter_pad_get_type(in->filter_ctx->input_pads, in->pad_idx);  //获取filter输出类型，目前只支持视频类型和音频类型
    5. 

  5.     int i;
    6. 

  6.  
    7. 

  7.     // TODO: support other filter types
    8. 

  8.     if (type != AVMEDIA_TYPE_VIDEO && type != AVMEDIA_TYPE_AUDIO) {
    9. 

  9.         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters supported "
    10. 

  10.                "currently.\n");
    11. 

  11.         exit_program(1);
    12. 

  12.     }
    13. 

  13.  
    14. 

  14.     if (in->name) {       //输入name，此例中为[0:v]或[1:v]
    15. 

  15.         AVFormatContext *s;
    16. 

  16.         AVStream       *st = NULL;
    17. 

  17.         char *p;
    18. 

  18.         int file_idx = strtol(in->name, &p, 0);    //通过输入name得到当前输入的file_index
    19. 

  19.  
    20. 

  20.         if (file_idx < 0 || file_idx >= nb_input_files) {
    21. 

  21.             av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtergraph description %s.\n",
    22. 

  22.                    file_idx, fg->graph_desc);
    23. 

  23.             exit_program(1);
    24. 

  24.         }
    25. 

  25.         s = input_files[file_idx]->ctx;     //当前file的ACFormatContext结构体
    26. 

  26.  
    27. 

  27.         for (i = 0; i < s->nb_streams; i++) {
    28. 

  28.             enum AVMediaType stream_type = s->streams[i]->codecpar->codec_type;
    29. 

  29.             if (stream_type != type &&
    30. 

  30.                 !(stream_type == AVMEDIA_TYPE_SUBTITLE &&
    31. 

  31.                   type == AVMEDIA_TYPE_VIDEO /* sub2video hack */))
    32. 

  32.                 continue;
    33. 

  33.             if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {
    34. 

  34.                 st = s->streams[i];     //确定当前输入的stream
    35. 

  35.                 break;
    36. 

  36.             }
    37. 

  37.         }
    38. 

  38.         if (!st) {
    39. 

  39.             av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
    40. 

  40.                    "matches no streams.\n", p, fg->graph_desc);
    41. 

  41.             exit_program(1);
    42. 

  42.         }
    43. 

  43.         ist = input_streams[input_files[file_idx]->ist_index + st->index];   //根据file_index和st->index确定input_stream[]数组中的index
    44. 

  44.     } else {         //如果命令行中没有指定filter的输入，则根据media type确定相应的输入流
    45. 

  45.         /* find the first unused stream of corresponding type */
    46. 

  46.         for (i = 0; i < nb_input_streams; i++) {
    47. 

  47.             ist = input_streams[i];
    48. 

  48.             if (ist->dec_ctx->codec_type == type && ist->discard)
    49. 

  49.                 break;
    50. 

  50.         }
    51. 

  51.         if (i == nb_input_streams) {
    52. 

  52.             av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "
    53. 

  53.                    "unlabeled input pad %d on filter %s\n", in->pad_idx,
    54. 

  54.                    in->filter_ctx->name);
    55. 

  55.             exit_program(1);
    56. 

  56.         }
    57. 

  57.     }
    58. 

  58.     av_assert0(ist);
    59. 

  59.  
    60. 

  60.     ist->discard         = 0;
    61. 

  61.     ist->decoding_needed |= DECODING_FOR_FILTER;
    62. 

  62.     ist->st->discard = AVDISCARD_NONE;
    63. 

  63.  
    64. 

  64.     GROW_ARRAY(fg->inputs, fg->nb_inputs);     //扩展filter graph中input结构体
    65. 

  65.     if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))    //为新扩展的输入分配空间
    66. 

  66.         exit_program(1);
    67. 

  67.     fg->inputs[fg->nb_inputs - 1]->ist   = ist;     //为新扩展的filter graph输入赋值
    68. 

  68.     fg->inputs[fg->nb_inputs - 1]->graph = fg;
    69. 

  69.     fg->inputs[fg->nb_inputs - 1]->format = -1;
    70. 

  70.     fg->inputs[fg->nb_inputs - 1]->type = ist->st->codecpar->codec_type;
    71. 

  71.     fg->inputs[fg->nb_inputs - 1]->name = describe_filter_link(fg, in, 1);
    72. 

  72.  
    73. 

  73.     fg->inputs[fg->nb_inputs - 1]->frame_queue = av_fifo_alloc(8 * sizeof(AVFrame*));
    74. 

  74.     if (!fg->inputs[fg->nb_inputs - 1]->frame_queue)
    75. 

  75.         exit_program(1);
    76. 

  76.  
    77. 

  77.     GROW_ARRAY(ist->filters, ist->nb_filters);    //扩展输入流中的filter结构体，并将当前的filter graph写入到当前输入流中相应filter结构体
    78. 

  78.     ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
    79. 

  79. }
    80. 

FFMPEG中的两输入Filter实现(一)

5. parse_filter():

下面我们再来分析一下如何解析并创建一个filter实例。

    

  1. static int parse_filter(AVFilterContext **filt_ctx, const char **buf, AVFilterGraph *graph,
    2. 

  2.                         int index, void *log_ctx)
    3. 

  3. {
    4. 

  4.     char *opts = NULL;
    5. 

  5.     char *name = av_get_token(buf, "=,;[");   //根据命令行得到filter的名称，这里是"overlay"
    6. 

  6.     int ret;
    7. 

  7.  
    8. 

  8.     if (**buf == '=') {       //提取命令行中filter的参数和选项，此处应该是100:00
    9. 

  9.         (*buf)++;
    10. 

  10.         opts = av_get_token(buf, "[],;");
    11. 

  11.     }
    12. 

  12.  
    13. 

  13.     ret = create_filter(filt_ctx, graph, index, name, opts, log_ctx);  //根据filter的名称和参数创建filter实例
    14. 

  14.     av_free(name);
    15. 

  15.     av_free(opts);
    16. 

  16.     return ret;
    17. 

  17. }
    18. 

FFMPEG中的两输入Filter实现(一)

6. create_filter():

最后，创建filter实例。

    

  1. static int create_filter(AVFilterContext **filt_ctx, AVFilterGraph *ctx, int index,
    2. 

  2.                          const char *filt_name, const char *args, void *log_ctx)
    3. 

  3. {
    4. 

  4.     AVFilter *filt;
    5. 

  5.     char inst_name[30];
    6. 

  6.     char *tmp_args = NULL;
    7. 

  7.     int ret;
    8. 

  8.  
    9. 

  9.     snprintf(inst_name, sizeof(inst_name), "Parsed_%s_%d", filt_name, index);
    10. 

  10.  
    11. 

  11.     filt = avfilter_get_by_name(filt_name);   //根据filter name从注册的AVFilter链表中提取出该filter
    12. 

  12.  
    13. 

  13.     if (!filt) {
    14. 

  14.         av_log(log_ctx, AV_LOG_ERROR,
    15. 

  15.                "No such filter: '%s'\n", filt_name);
    16. 

  16.         return AVERROR(EINVAL);
    17. 

  17.     }
    18. 

  18.  
    19. 

  19.     *filt_ctx = avfilter_graph_alloc_filter(ctx, filt, inst_name);  //创建filter实例，并加入到filter graph
    20. 

  20.     if (!*filt_ctx) {
    21. 

  21.         av_log(log_ctx, AV_LOG_ERROR,
    22. 

  22.                "Error creating filter '%s'\n", filt_name);
    23. 

  23.         return AVERROR(ENOMEM);
    24. 

  24.     }
    25. 

  25.  
    26. 

  26.     if (!strcmp(filt_name, "scale") && (!args || !strstr(args, "flags")) &&
    27. 

  27.         ctx->scale_sws_opts) {
    28. 

  28.         if (args) {
    29. 

  29.             tmp_args = av_asprintf("%s:%s",
    30. 

  30.                     args, ctx->scale_sws_opts);
    31. 

  31.             if (!tmp_args)
    32. 

  32.                 return AVERROR(ENOMEM);
    33. 

  33.             args = tmp_args;
    34. 

  34.         } else
    35. 

  35.             args = ctx->scale_sws_opts;
    36. 

  36.     }
    37. 

  37.  
    38. 

  38.     ret = avfilter_init_str(*filt_ctx, args);   //解析filter的参数并加入到该filter的私有域，并完成实例的初始化工作
    39. 

  39.     if (ret < 0) {
    40. 

  40.         av_log(log_ctx, AV_LOG_ERROR,
    41. 

  41.                "Error initializing filter '%s'", filt_name);
    42. 

  42.         if (args)
    43. 

  43.             av_log(log_ctx, AV_LOG_ERROR, " with args '%s'", args);
    44. 

  44.         av_log(log_ctx, AV_LOG_ERROR, "\n");
    45. 

  45.         avfilter_free(*filt_ctx);
    46. 

  46.         *filt_ctx = NULL;
    47. 

  47.     }
    48. 

  48.  
    49. 

  49.     av_free(tmp_args);
    50. 

  50.     return ret;
    51. 

  51. }
    52. 

FFMPEG中的两输入Filter实现(一)
到此，overlay filter就创建成功了。至于该filter在转码过程中是如何使用的，将会在另一篇文章中来做详细说明。

以上内容只分析了filter的注册、解析、创建和初始化，而对于filter的一些基本概念，例如滤镜图(filter graph)、滤镜链(filter link)、输入输出pad等等，由于篇幅原因，未做详细说明。有时间准备单独开一篇来整理这些概念。

上一篇：【数字信号处理】线性常系数差分方程 ( 卷积 与 “ 线性常系数差分方程 “ | 使用 matlab 求解 “ 线性常系数差分方程 “ )


下一篇：python3实现Fofa用户版批量提取ip（附流程详解）