• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

libavfilter/avfilter.h

Go to the documentation of this file.
00001 /*
00002  * filter layer
00003  * Copyright (c) 2007 Bobby Bingham
00004  *
00005  * This file is part of Libav.
00006  *
00007  * Libav is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * Libav is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with Libav; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00022 #ifndef AVFILTER_AVFILTER_H
00023 #define AVFILTER_AVFILTER_H
00024 
00025 #include "libavutil/avutil.h"
00026 #include "libavutil/log.h"
00027 #include "libavutil/samplefmt.h"
00028 #include "libavutil/pixfmt.h"
00029 #include "libavutil/rational.h"
00030 #include "libavcodec/avcodec.h"
00031 
00032 #include <stddef.h>
00033 
00034 #include "libavfilter/version.h"
00035 
00039 unsigned avfilter_version(void);
00040 
00044 const char *avfilter_configuration(void);
00045 
00049 const char *avfilter_license(void);
00050 
00051 
00052 typedef struct AVFilterContext AVFilterContext;
00053 typedef struct AVFilterLink    AVFilterLink;
00054 typedef struct AVFilterPad     AVFilterPad;
00055 
00061 typedef struct AVFilterBuffer {
00062     uint8_t *data[8];           
00063     int linesize[8];            
00064 
00065     unsigned refcount;          
00066 
00068     void *priv;
00075     void (*free)(struct AVFilterBuffer *buf);
00076 
00077     int format;                 
00078     int w, h;                   
00079 } AVFilterBuffer;
00080 
00081 #define AV_PERM_READ     0x01   ///< can read from the buffer
00082 #define AV_PERM_WRITE    0x02   ///< can write to the buffer
00083 #define AV_PERM_PRESERVE 0x04   ///< nobody else can overwrite the buffer
00084 #define AV_PERM_REUSE    0x08   ///< can output the buffer multiple times, with the same contents each time
00085 #define AV_PERM_REUSE2   0x10   ///< can output the buffer multiple times, modified each time
00086 #define AV_PERM_NEG_LINESIZES 0x20  ///< the buffer requested can have negative linesizes
00087 
00093 typedef struct AVFilterBufferRefAudioProps {
00094     uint64_t channel_layout;    
00095     int nb_samples;             
00096     int size;                   
00097     uint32_t sample_rate;       
00098     int planar;                 
00099 } AVFilterBufferRefAudioProps;
00100 
00106 typedef struct AVFilterBufferRefVideoProps {
00107     int w;                      
00108     int h;                      
00109     AVRational pixel_aspect;    
00110     int interlaced;             
00111     int top_field_first;        
00112     enum AVPictureType pict_type; 
00113     int key_frame;              
00114 } AVFilterBufferRefVideoProps;
00115 
00124 typedef struct AVFilterBufferRef {
00125     AVFilterBuffer *buf;        
00126     uint8_t *data[8];           
00127     int linesize[8];            
00128     int format;                 
00129 
00135     int64_t pts;
00136     int64_t pos;                
00137 
00138     int perms;                  
00139 
00140     enum AVMediaType type;      
00141     AVFilterBufferRefVideoProps *video; 
00142     AVFilterBufferRefAudioProps *audio; 
00143 } AVFilterBufferRef;
00144 
00148 static inline void avfilter_copy_buffer_ref_props(AVFilterBufferRef *dst, AVFilterBufferRef *src)
00149 {
00150     // copy common properties
00151     dst->pts             = src->pts;
00152     dst->pos             = src->pos;
00153 
00154     switch (src->type) {
00155     case AVMEDIA_TYPE_VIDEO: *dst->video = *src->video; break;
00156     case AVMEDIA_TYPE_AUDIO: *dst->audio = *src->audio; break;
00157     default: break;
00158     }
00159 }
00160 
00170 AVFilterBufferRef *avfilter_ref_buffer(AVFilterBufferRef *ref, int pmask);
00171 
00178 void avfilter_unref_buffer(AVFilterBufferRef *ref);
00179 
00220 typedef struct AVFilterFormats {
00221     unsigned format_count;      
00222     int *formats;               
00223 
00224     unsigned refcount;          
00225     struct AVFilterFormats ***refs; 
00226 }  AVFilterFormats;
00227 
00235 AVFilterFormats *avfilter_make_format_list(const int *fmts);
00236 
00245 int avfilter_add_format(AVFilterFormats **avff, int fmt);
00246 
00250 AVFilterFormats *avfilter_all_formats(enum AVMediaType type);
00251 
00260 AVFilterFormats *avfilter_merge_formats(AVFilterFormats *a, AVFilterFormats *b);
00261 
00274 void avfilter_formats_ref(AVFilterFormats *formats, AVFilterFormats **ref);
00275 
00291 void avfilter_formats_unref(AVFilterFormats **ref);
00292 
00306 void avfilter_formats_changeref(AVFilterFormats **oldref,
00307                                 AVFilterFormats **newref);
00308 
00312 struct AVFilterPad {
00318     const char *name;
00319 
00324     enum AVMediaType type;
00325 
00333     int min_perms;
00334 
00344     int rej_perms;
00345 
00353     void (*start_frame)(AVFilterLink *link, AVFilterBufferRef *picref);
00354 
00361     AVFilterBufferRef *(*get_video_buffer)(AVFilterLink *link, int perms, int w, int h);
00362 
00369     AVFilterBufferRef *(*get_audio_buffer)(AVFilterLink *link, int perms,
00370                                            enum AVSampleFormat sample_fmt, int size,
00371                                            uint64_t channel_layout, int planar);
00372 
00380     void (*end_frame)(AVFilterLink *link);
00381 
00388     void (*draw_slice)(AVFilterLink *link, int y, int height, int slice_dir);
00389 
00396     void (*filter_samples)(AVFilterLink *link, AVFilterBufferRef *samplesref);
00397 
00407     int (*poll_frame)(AVFilterLink *link);
00408 
00416     int (*request_frame)(AVFilterLink *link);
00417 
00432     int (*config_props)(AVFilterLink *link);
00433 };
00434 
00436 void avfilter_default_start_frame(AVFilterLink *link, AVFilterBufferRef *picref);
00437 
00439 void avfilter_default_draw_slice(AVFilterLink *link, int y, int h, int slice_dir);
00440 
00442 void avfilter_default_end_frame(AVFilterLink *link);
00443 
00445 void avfilter_default_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref);
00446 
00448 int avfilter_default_config_output_link(AVFilterLink *link);
00449 
00451 int avfilter_default_config_input_link (AVFilterLink *link);
00452 
00454 AVFilterBufferRef *avfilter_default_get_video_buffer(AVFilterLink *link,
00455                                                      int perms, int w, int h);
00456 
00458 AVFilterBufferRef *avfilter_default_get_audio_buffer(AVFilterLink *link, int perms,
00459                                                      enum AVSampleFormat sample_fmt, int size,
00460                                                      uint64_t channel_layout, int planar);
00461 
00467 void avfilter_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats);
00468 
00470 int avfilter_default_query_formats(AVFilterContext *ctx);
00471 
00473 void avfilter_null_start_frame(AVFilterLink *link, AVFilterBufferRef *picref);
00474 
00476 void avfilter_null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir);
00477 
00479 void avfilter_null_end_frame(AVFilterLink *link);
00480 
00482 void avfilter_null_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref);
00483 
00485 AVFilterBufferRef *avfilter_null_get_video_buffer(AVFilterLink *link,
00486                                                   int perms, int w, int h);
00487 
00489 AVFilterBufferRef *avfilter_null_get_audio_buffer(AVFilterLink *link, int perms,
00490                                                   enum AVSampleFormat sample_fmt, int size,
00491                                                   uint64_t channel_layout, int planar);
00492 
00497 typedef struct AVFilter {
00498     const char *name;         
00499 
00500     int priv_size;      
00501 
00508     int (*init)(AVFilterContext *ctx, const char *args, void *opaque);
00509 
00515     void (*uninit)(AVFilterContext *ctx);
00516 
00525     int (*query_formats)(AVFilterContext *);
00526 
00527     const AVFilterPad *inputs;  
00528     const AVFilterPad *outputs; 
00529 
00534     const char *description;
00535 } AVFilter;
00536 
00538 struct AVFilterContext {
00539     const AVClass *av_class;              
00540 
00541     AVFilter *filter;               
00542 
00543     char *name;                     
00544 
00545     unsigned input_count;           
00546     AVFilterPad   *input_pads;      
00547     AVFilterLink **inputs;          
00548 
00549     unsigned output_count;          
00550     AVFilterPad   *output_pads;     
00551     AVFilterLink **outputs;         
00552 
00553     void *priv;                     
00554 };
00555 
00563 struct AVFilterLink {
00564     AVFilterContext *src;       
00565     AVFilterPad *srcpad;        
00566 
00567     AVFilterContext *dst;       
00568     AVFilterPad *dstpad;        
00569 
00571     enum {
00572         AVLINK_UNINIT = 0,      
00573         AVLINK_STARTINIT,       
00574         AVLINK_INIT             
00575     } init_state;
00576 
00577     enum AVMediaType type;      
00578 
00579     /* These parameters apply only to video */
00580     int w;                      
00581     int h;                      
00582     AVRational sample_aspect_ratio; 
00583     /* These two parameters apply only to audio */
00584     uint64_t channel_layout;    
00585     int64_t sample_rate;        
00586 
00587     int format;                 
00588 
00594     AVFilterFormats *in_formats;
00595     AVFilterFormats *out_formats;
00596 
00604     AVFilterBufferRef *src_buf;
00605 
00606     AVFilterBufferRef *cur_buf;
00607     AVFilterBufferRef *out_buf;
00608 
00616     AVRational time_base;
00617 };
00618 
00628 int avfilter_link(AVFilterContext *src, unsigned srcpad,
00629                   AVFilterContext *dst, unsigned dstpad);
00630 
00637 int avfilter_config_links(AVFilterContext *filter);
00638 
00650 AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms,
00651                                           int w, int h);
00652 
00664 AVFilterBufferRef *
00665 avfilter_get_video_buffer_ref_from_arrays(uint8_t *data[4], int linesize[4], int perms,
00666                                           int w, int h, enum PixelFormat format);
00667 
00681 AVFilterBufferRef *avfilter_get_audio_buffer(AVFilterLink *link, int perms,
00682                                              enum AVSampleFormat sample_fmt, int size,
00683                                              uint64_t channel_layout, int planar);
00684 
00691 int avfilter_request_frame(AVFilterLink *link);
00692 
00700 int avfilter_poll_frame(AVFilterLink *link);
00701 
00711 void avfilter_start_frame(AVFilterLink *link, AVFilterBufferRef *picref);
00712 
00718 void avfilter_end_frame(AVFilterLink *link);
00719 
00735 void avfilter_draw_slice(AVFilterLink *link, int y, int h, int slice_dir);
00736 
00745 void avfilter_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref);
00746 
00748 void avfilter_register_all(void);
00749 
00751 void avfilter_uninit(void);
00752 
00763 int avfilter_register(AVFilter *filter);
00764 
00772 AVFilter *avfilter_get_by_name(const char *name);
00773 
00780 AVFilter **av_filter_next(AVFilter **filter);
00781 
00791 int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name);
00792 
00803 int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque);
00804 
00810 void avfilter_free(AVFilterContext *filter);
00811 
00821 int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
00822                            unsigned filt_srcpad_idx, unsigned filt_dstpad_idx);
00823 
00837 void avfilter_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
00838                          AVFilterPad **pads, AVFilterLink ***links,
00839                          AVFilterPad *newpad);
00840 
00842 static inline void avfilter_insert_inpad(AVFilterContext *f, unsigned index,
00843                                          AVFilterPad *p)
00844 {
00845     avfilter_insert_pad(index, &f->input_count, offsetof(AVFilterLink, dstpad),
00846                         &f->input_pads, &f->inputs, p);
00847 }
00848 
00850 static inline void avfilter_insert_outpad(AVFilterContext *f, unsigned index,
00851                                           AVFilterPad *p)
00852 {
00853     avfilter_insert_pad(index, &f->output_count, offsetof(AVFilterLink, srcpad),
00854                         &f->output_pads, &f->outputs, p);
00855 }
00856 
00863 int avfilter_copy_frame_props(AVFilterBufferRef *dst, const AVFrame *src);
00864 
00865 #endif /* AVFILTER_AVFILTER_H */
Generated on Sun Apr 22 2012 21:54:06 for Libav by doxygen 1.7.1