FFmpeg filter浅析--中篇

typedef struct AVFilterGraph {
    AVFilterContext **filters;
    unsigned nb_filters;
    // .... 略
} AVFilterGraph;

/**
 * Filter definition. This defines the pads a filter contains, and all the
 * callback functions used to interact with the filter.
 */
typedef struct AVFilter {
    /**
     * Filter name. Must be non-NULL and unique among filters.
     */
    const char *name;

    /**
     * A description of the filter. May be NULL.
     *
     * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
     */
    const char *description;

    /**
     * List of static inputs.
     *
     * NULL if there are no (static) inputs. Instances of filters with
     * AVFILTER_FLAG_DYNAMIC_INPUTS set may have more inputs than present in
     * this list.
     */
    const AVFilterPad *inputs;

    /**
     * List of static outputs.
     *
     * NULL if there are no (static) outputs. Instances of filters with
     * AVFILTER_FLAG_DYNAMIC_OUTPUTS set may have more outputs than present in
     * this list.
     */
    const AVFilterPad *outputs;

    // ...略
} AVFilter;

/** An instance of a filter */
struct AVFilterContext {
    const AVFilter *filter; ///< the AVFilter of which this is an instance
    AVFilterPad *input_pads; ///< array of input pads
    AVFilterLink **inputs; ///< array of pointers to input links
    unsigned    nb_inputs; ///< number of input pads

    AVFilterPad *output_pads; ///< array of output pads
    AVFilterLink **outputs; ///< array of pointers to output links
    unsigned    nb_outputs; ///< number of output pads

    struct AVFilterGraph *graph;    ///< filtergraph this filter belongs to

    // ...略
};

/**
 * A link between two filters. This contains pointers to the source and
 * destination filters between which this link exists, and the indexes of
 * the pads involved. In addition, this link also contains the parameters
 * which have been negotiated and agreed upon between the filter, such as
 * image dimensions, format, etc.
 *
 * Applications must not normally access the link structure directly.
 * Use the buffersrc and buffersink API instead.
 * In the future, access to the header may be reserved for filters
 * implementation.
 */
struct AVFilterLink {
    AVFilterContext *src; ///< source filter
    AVFilterPad *srcpad; ///< output pad on the source filter

    AVFilterContext *dst; ///< dest filter
    AVFilterPad *dstpad; ///< input pad on the dest filter

    /**
     * Graph the filter belongs to.
     */
    struct AVFilterGraph *graph;

    // ...略
};

/**
 * A linked-list of the inputs/outputs of the filter chain.
 *
 * This is mainly useful for avfilter_graph_parse() / avfilter_graph_parse2(),
 * where it is used to communicate open (unlinked) inputs and outputs from and
 * to the caller.
 * This struct specifies, per each not connected pad contained in the graph, the
 * filter context and the pad index required for establishing a link.
 */
typedef struct AVFilterInOut {
    /** unique name for this input/output in the list */
    char *name;

    /** filter context associated to this input/output */
    AVFilterContext *filter_ctx;

    /** index of the filt_ctx pad to use for linking */
    int pad_idx;

    /** next input/input in the list, NULL if this is the last */
    struct AVFilterInOut *next;
} AVFilterInOut;

int main(int argc, char **argv) {
    // ...初始化相关变量，包括原始frame，过滤器处理结果filt_frame，packet等
    
    // 打开输入file，查找视频stream，打开解码器等
    if ((ret = open_input_file(argv[1])) < 0)
        goto end;

    // 初始化过滤器相关
    if ((ret = init_filters(filter_descr)) < 0)
        goto end;

    while (1) {
        // 读包
        av_read_frame(...);
        // 解码
        avcodec_send_packet(...);
        avcodec_receive_frame(...);
        /* 将解码后的原始frame push到filtergraph */
        av_buffersrc_add_frame_flags(buffersrc_ctx, frame, AV_BUFFERSRC_FLAG_KEEP_REF)
        /* 从filtergraph pull经过滤波处理的frame */
        av_buffersink_get_frame(buffersink_ctx, filt_frame);
        // 显示
        display_frame(filt_frame, buffersink_ctx->inputs[0]->time_base);
        // ... 略
    }
end:
    // 主要是相关资源释放
    avfilter_graph_free(&filter_graph);
    // ... 略
}

static int open_input_file(const char *filename) {
    // 打开文件
    avformat_open_input(&fmt_ctx, filename, NULL, NULL));

    // 查找video stream
    avformat_find_stream_info(fmt_ctx, NULL));
    av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0);

    // 创建和初始化解码器context
    dec_ctx = avcodec_alloc_context3(dec);
    avcodec_parameters_to_context(dec_ctx, fmt_ctx->streams[video_stream_index]->codecpar);
    
    // 打开解码器
    avcodec_open2(dec_ctx, dec, NULL);
}

static int init_filters(const char *filters_descr) {
    char args[512];
    int ret = 0;

    // 获取buffer & buffersink filter
    const AVFilter *buffersrc = avfilter_get_by_name("buffer");
    const AVFilter *buffersink = avfilter_get_by_name("buffersink");

    // 
    AVFilterInOut *outputs = avfilter_inout_alloc();
    AVFilterInOut *inputs = avfilter_inout_alloc();
    AVRational time_base = fmt_ctx->streams[video_stream_index]->time_base;
    enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };

    // 创建过滤器图
    filter_graph = avfilter_graph_alloc();
    
    /* buffer video source: the decoded frames from the decoder will be inserted here. */
    snprintf(args, sizeof(args),
            "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
            dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
            time_base.num, time_base.den,
            dec_ctx->sample_aspect_ratio.num, dec_ctx->sample_aspect_ratio.den);

    // 创建过滤器图的输入端，即buffer过滤器并配置相关参数
    ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
                                       args, NULL, filter_graph);

    // 创建过滤器图的输出端，即buffersink过滤器并配置相关参数
    ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
                                       NULL, NULL, filter_graph);

    ret = av_opt_set_int_list(buffersink_ctx, "pix_fmts", pix_fmts,
                              AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);

    /*
     * Set the endpoints for the filter graph. The filter_graph will
     * be linked to the graph described by filters_descr.
     */

    /*
     * The buffer source output must be connected to the input pad of
     * the first filter described by filters_descr; since the first
     * filter input label is not specified, it is set to "in" by
     * default.
     */
    outputs->name = av_strdup("in");
    outputs->filter_ctx = buffersrc_ctx;
    outputs->pad_idx = 0;
    outputs->next = NULL;

    /*
     * The buffer sink input must be connected to the output pad of
     * the last filter described by filters_descr; since the last
     * filter output label is not specified, it is set to "out" by
     * default.
     */
    inputs->name = av_strdup("out");
    inputs->filter_ctx = buffersink_ctx;
    inputs->pad_idx = 0;
    inputs->next = NULL;

    // 将filter_descr字符串描述的过滤器链添加到filter grapha中
    // const char *filter_descr = "scale=78:24,transpose=cclock";
    // filter_descr表示的是一个过滤器链，scale+transpose
    if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,
                                    &inputs, &outputs, NULL)) < 0)
        goto end;

    // 为filter graph中所有过滤器建立链接
    if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
        goto end;

end:
    avfilter_inout_free(&inputs);
    avfilter_inout_free(&outputs);

    return ret;
}