点击(此处)折叠或打开

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!\n");
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. }

点击(此处)折叠或打开

1. int configure_video_filters(AVInputStream *ist, 
2.                             AVOutputStream *ost)
3. {
4.    // 类似于directshow一样初始化filter graph等;
5.   ost->graph = avfilter_graph_alloc();
6.   …

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. }

点击(此处)折叠或打开

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, "=,;[\n");
8.     int ret;
10.     if (**buf == ‘=‘) {
11.         (*buf)++;
12.         opts = av_get_token(buf, "[],;\n");
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. }

点击(此处)折叠或打开

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. }

点击(此处)折叠或打开

1. int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
2. {
3.     int ret;

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. }

点击(此处)折叠或打开

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. }

点击(此处)折叠或打开

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!\n");
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. }