libavfilter/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/avutil.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);

const AVClass *avfilter_get_class(void);

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

typedef struct AVFilterBuffer {
    uint8_t *data[8];           

    uint8_t **extended_data;
    int linesize[8];            

    void *priv;
    void (*free)(struct AVFilterBuffer *buf);

    int format;                 
    int w, h;                   
    unsigned refcount;          
} AVFilterBuffer;

#define AV_PERM_READ     0x01   
#define AV_PERM_WRITE    0x02   
#define AV_PERM_PRESERVE 0x04   
#define AV_PERM_REUSE    0x08   
#define AV_PERM_REUSE2   0x10   
#define AV_PERM_NEG_LINESIZES 0x20  
#define AV_PERM_ALIGN    0x40   

#define AVFILTER_ALIGN 16 //not part of ABI

typedef struct AVFilterBufferRefAudioProps {
    uint64_t channel_layout;    
    int nb_samples;             
    int sample_rate;            
} AVFilterBufferRefAudioProps;

typedef struct AVFilterBufferRefVideoProps {
    int w;                      
    int h;                      
    AVRational sample_aspect_ratio; 
    int interlaced;             
    int top_field_first;        
    enum AVPictureType pict_type; 
    int key_frame;              
    int qp_table_linesize;                
    int qp_table_size;            
    int8_t *qp_table;             
} AVFilterBufferRefVideoProps;

typedef struct AVFilterBufferRef {
    AVFilterBuffer *buf;        
    uint8_t *data[8];           

    uint8_t **extended_data;
    int linesize[8];            

    AVFilterBufferRefVideoProps *video; 
    AVFilterBufferRefAudioProps *audio; 

    int64_t pts;
    int64_t pos;                

    int format;                 

    int perms;                  

    enum AVMediaType type;      
} AVFilterBufferRef;

void avfilter_copy_buffer_ref_props(AVFilterBufferRef *dst, AVFilterBufferRef *src);

AVFilterBufferRef *avfilter_ref_buffer(AVFilterBufferRef *ref, int pmask);

void avfilter_unref_buffer(AVFilterBufferRef *ref);

void avfilter_unref_bufferp(AVFilterBufferRef **ref);

#if FF_API_AVFILTERPAD_PUBLIC

struct AVFilterPad {
    const char *name;

    enum AVMediaType type;

    int min_perms;

    int rej_perms;

    int (*start_frame)(AVFilterLink *link, AVFilterBufferRef *picref);

    AVFilterBufferRef *(*get_video_buffer)(AVFilterLink *link, int perms, int w, int h);

    AVFilterBufferRef *(*get_audio_buffer)(AVFilterLink *link, int perms,
                                           int nb_samples);

    int (*end_frame)(AVFilterLink *link);

    int (*draw_slice)(AVFilterLink *link, int y, int height, int slice_dir);

    int (*filter_samples)(AVFilterLink *link, AVFilterBufferRef *samplesref);

    int (*poll_frame)(AVFilterLink *link);

    int (*request_frame)(AVFilterLink *link);

    int (*config_props)(AVFilterLink *link);

    int needs_fifo;
};
#endif

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

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

typedef struct AVFilter {
    const char *name;         

    const char *description;

    const AVFilterPad *inputs;  
    const AVFilterPad *outputs; 

    /*****************************************************************
     * 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 (*init)(AVFilterContext *ctx, const char *args);

    void (*uninit)(AVFilterContext *ctx);

    int (*query_formats)(AVFilterContext *);

    int priv_size;      

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

    int (*init_opaque)(AVFilterContext *ctx, const char *args, void *opaque);

    const AVClass *priv_class;      
} AVFilter;

struct AVFilterContext {
    const AVClass *av_class;        

    AVFilter *filter;               

    char *name;                     

    AVFilterPad   *input_pads;      
    AVFilterLink **inputs;          
#if FF_API_FOO_COUNT
    unsigned input_count;           
#endif
    unsigned    nb_inputs;          

    AVFilterPad   *output_pads;     
    AVFilterLink **outputs;         
#if FF_API_FOO_COUNT
    unsigned output_count;          
#endif
    unsigned    nb_outputs;         

    void *priv;                     

    struct AVFilterCommand *command_queue;
};

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;

    AVFilterBufferRef *src_buf;

    AVFilterBufferRef *cur_buf;

    AVFilterBufferRef *out_buf;

    struct AVFilterPool *pool;

    struct AVFilterGraph *graph;

    int64_t current_pts;

    int age_index;

    AVRational frame_rate;

    AVFilterBufferRef *partial_buf;

    int partial_buf_size;

    int min_samples;

    int max_samples;

    AVFilterBufferRef *cur_buf_copy;

    int closed;
};

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

void avfilter_link_free(AVFilterLink **link);

void avfilter_link_set_closed(AVFilterLink *link, int closed);

int avfilter_config_links(AVFilterContext *filter);

AVFilterBufferRef *
avfilter_get_video_buffer_ref_from_arrays(uint8_t * const data[4], const int linesize[4], int perms,
                                          int w, int h, enum PixelFormat format);

AVFilterBufferRef *avfilter_get_audio_buffer_ref_from_arrays(uint8_t **data,
                                                             int linesize,
                                                             int perms,
                                                             int nb_samples,
                                                             enum AVSampleFormat sample_fmt,
                                                             uint64_t channel_layout);


#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);

void avfilter_register_all(void);

void avfilter_uninit(void);

int avfilter_register(AVFilter *filter);

AVFilter *avfilter_get_by_name(const char *name);

AVFilter **av_filter_next(AVFilter **filter);

int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name);

int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque);

void avfilter_free(AVFilterContext *filter);

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

#endif /* AVFILTER_AVFILTER_H */

---