avfilter.h

Go to the documentation of this file.

/*
 * filter layer
 * Copyright (c) 2007 Bobby Bingham
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef AVFILTER_AVFILTER_H
#define AVFILTER_AVFILTER_H

#include <stddef.h>

#include "libavutil/attributes.h"
#include "libavutil/avutil.h"
#include "libavutil/buffer.h"
#include "libavutil/dict.h"
#include "libavutil/frame.h"
#include "libavutil/log.h"
#include "libavutil/samplefmt.h"
#include "libavutil/pixfmt.h"
#include "libavutil/rational.h"

#include "libavfilter/version.h"

unsigned avfilter_version(void);

const char *avfilter_configuration(void);

const char *avfilter_license(void);

typedef struct AVFilterContext AVFilterContext;
typedef struct AVFilterLink    AVFilterLink;
typedef struct AVFilterPad     AVFilterPad;
typedef struct AVFilterFormats AVFilterFormats;

int avfilter_pad_count(const AVFilterPad *pads);

const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx);

enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx);

#define AVFILTER_FLAG_DYNAMIC_INPUTS        (1 << 0)

#define AVFILTER_FLAG_DYNAMIC_OUTPUTS       (1 << 1)

#define AVFILTER_FLAG_SLICE_THREADS         (1 << 2)

#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC  (1 << 16)

#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL (1 << 17)

#define AVFILTER_FLAG_SUPPORT_TIMELINE (AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL)

typedef struct AVFilter {
    const char *name;

    const char *description;

    const AVFilterPad *inputs;
    const AVFilterPad *outputs;

    const AVClass *priv_class;

    int flags;

    /*****************************************************************
     * All fields below this line are not part of the public API. They
     * may not be used outside of libavfilter and can be changed and
     * removed at will.
     * New public fields should be added right above.
     *****************************************************************
     */

    int (*preinit)(AVFilterContext *ctx);

    int (*init)(AVFilterContext *ctx);

    int (*init_dict)(AVFilterContext *ctx, AVDictionary **options);

    void (*uninit)(AVFilterContext *ctx);

    int (*query_formats)(AVFilterContext *);

    int priv_size;      

    int flags_internal; 

    struct AVFilter *next;

    int (*process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags);

    int (*init_opaque)(AVFilterContext *ctx, void *opaque);

    int (*activate)(AVFilterContext *ctx);
} AVFilter;

#define AVFILTER_THREAD_SLICE (1 << 0)

typedef struct AVFilterInternal AVFilterInternal;

struct AVFilterContext {
    const AVClass *av_class;        

    const AVFilter *filter;         

    char *name;                     

    AVFilterPad   *input_pads;      
    AVFilterLink **inputs;          
    unsigned    nb_inputs;          

    AVFilterPad   *output_pads;     
    AVFilterLink **outputs;         
    unsigned    nb_outputs;         

    void *priv;                     

    struct AVFilterGraph *graph;    

    int thread_type;

    AVFilterInternal *internal;

    struct AVFilterCommand *command_queue;

    char *enable_str;               
    void *enable;                   
    double *var_values;             
    int is_disabled;                

    AVBufferRef *hw_device_ctx;

    int nb_threads;

    unsigned ready;

    int extra_hw_frames;
};

struct AVFilterLink {
    AVFilterContext *src;       
    AVFilterPad *srcpad;        

    AVFilterContext *dst;       
    AVFilterPad *dstpad;        

    enum AVMediaType type;      

    /* These parameters apply only to video */
    int w;                      
    int h;                      
    AVRational sample_aspect_ratio; 
    /* These parameters apply only to audio */
    uint64_t channel_layout;    
    int sample_rate;            

    int format;                 

    AVRational time_base;

    /*****************************************************************
     * All fields below this line are not part of the public API. They
     * may not be used outside of libavfilter and can be changed and
     * removed at will.
     * New public fields should be added right above.
     *****************************************************************
     */
    AVFilterFormats *in_formats;
    AVFilterFormats *out_formats;

    AVFilterFormats  *in_samplerates;
    AVFilterFormats *out_samplerates;
    struct AVFilterChannelLayouts  *in_channel_layouts;
    struct AVFilterChannelLayouts *out_channel_layouts;

    int request_samples;

    enum {
        AVLINK_UNINIT = 0,      
        AVLINK_STARTINIT,       
        AVLINK_INIT             
    } init_state;

    struct AVFilterGraph *graph;

    int64_t current_pts;

    int64_t current_pts_us;

    int age_index;

    AVRational frame_rate;

    AVFrame *partial_buf;

    int partial_buf_size;

    int min_samples;

    int max_samples;

    int channels;

    unsigned flags;

    int64_t frame_count_in, frame_count_out;

    void *frame_pool;

    int frame_wanted_out;

    AVBufferRef *hw_frames_ctx;

#ifndef FF_INTERNAL_FIELDS

    char reserved[0xF000];

#else /* FF_INTERNAL_FIELDS */

    FFFrameQueue fifo;

    int frame_blocked_in;

    int status_in;

    int64_t status_in_pts;

    int status_out;

#endif /* FF_INTERNAL_FIELDS */

};

int avfilter_link(AVFilterContext *src, unsigned srcpad,
                  AVFilterContext *dst, unsigned dstpad);

void avfilter_link_free(AVFilterLink **link);

#if FF_API_FILTER_GET_SET

attribute_deprecated
int avfilter_link_get_channels(AVFilterLink *link);
#endif

attribute_deprecated
void avfilter_link_set_closed(AVFilterLink *link, int closed);

int avfilter_config_links(AVFilterContext *filter);

#define AVFILTER_CMD_FLAG_ONE   1 
#define AVFILTER_CMD_FLAG_FAST  2 


int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags);

const AVFilter *av_filter_iterate(void **opaque);

#if FF_API_NEXT

attribute_deprecated
void avfilter_register_all(void);

attribute_deprecated
int avfilter_register(AVFilter *filter);

attribute_deprecated
const AVFilter *avfilter_next(const AVFilter *prev);
#endif

const AVFilter *avfilter_get_by_name(const char *name);


int avfilter_init_str(AVFilterContext *ctx, const char *args);

int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options);

void avfilter_free(AVFilterContext *filter);

int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
                           unsigned filt_srcpad_idx, unsigned filt_dstpad_idx);

const AVClass *avfilter_get_class(void);

typedef struct AVFilterGraphInternal AVFilterGraphInternal;

typedef int (avfilter_action_func)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);

typedef int (avfilter_execute_func)(AVFilterContext *ctx, avfilter_action_func *func,
                                    void *arg, int *ret, int nb_jobs);

typedef struct AVFilterGraph {
    const AVClass *av_class;
    AVFilterContext **filters;
    unsigned nb_filters;

    char *scale_sws_opts; 
#if FF_API_LAVR_OPTS
    attribute_deprecated char *resample_lavr_opts;   
#endif

    int thread_type;

    int nb_threads;

    AVFilterGraphInternal *internal;

    void *opaque;

    avfilter_execute_func *execute;

    char *aresample_swr_opts; 

    AVFilterLink **sink_links;
    int sink_links_count;

    unsigned disable_auto_convert;
} AVFilterGraph;

AVFilterGraph *avfilter_graph_alloc(void);

AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph,
                                             const AVFilter *filter,
                                             const char *name);

AVFilterContext *avfilter_graph_get_filter(AVFilterGraph *graph, const char *name);

int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt,
                                 const char *name, const char *args, void *opaque,
                                 AVFilterGraph *graph_ctx);

void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags);

enum {
    AVFILTER_AUTO_CONVERT_ALL  =  0, 
    AVFILTER_AUTO_CONVERT_NONE = -1, 
};

int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx);

void avfilter_graph_free(AVFilterGraph **graph);

typedef struct AVFilterInOut {
    char *name;

    AVFilterContext *filter_ctx;

    int pad_idx;

    struct AVFilterInOut *next;
} AVFilterInOut;

AVFilterInOut *avfilter_inout_alloc(void);

void avfilter_inout_free(AVFilterInOut **inout);

int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,
                         AVFilterInOut *inputs, AVFilterInOut *outputs,
                         void *log_ctx);

int avfilter_graph_parse_ptr(AVFilterGraph *graph, const char *filters,
                             AVFilterInOut **inputs, AVFilterInOut **outputs,
                             void *log_ctx);

int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters,
                          AVFilterInOut **inputs,
                          AVFilterInOut **outputs);

int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags);

int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, int flags, double ts);


char *avfilter_graph_dump(AVFilterGraph *graph, const char *options);

int avfilter_graph_request_oldest(AVFilterGraph *graph);

#endif /* AVFILTER_AVFILTER_H */