avfilter.h 39.4 KB
 Vitor Sessak committed Feb 15, 2008 1 /*  Vitor Sessak committed Feb 15, 2008 2  * filter layer  Stefano Sabatini committed Nov 28, 2010 3  * Copyright (c) 2007 Bobby Bingham  Vitor Sessak committed Feb 15, 2008 4  *  Mans Rullgard committed Mar 19, 2011 5  * This file is part of Libav.  Vitor Sessak committed Feb 15, 2008 6  *  Mans Rullgard committed Mar 19, 2011 7  * Libav is free software; you can redistribute it and/or  Vitor Sessak committed Feb 15, 2008 8 9 10 11  * 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. *  Mans Rullgard committed Mar 19, 2011 12  * Libav is distributed in the hope that it will be useful,  Vitor Sessak committed Feb 15, 2008 13 14 15 16 17  * 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  Mans Rullgard committed Mar 19, 2011 18  * License along with Libav; if not, write to the Free Software  Vitor Sessak committed Feb 15, 2008 19 20 21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */  Stefano Sabatini committed Aug 31, 2008 22 23 #ifndef AVFILTER_AVFILTER_H #define AVFILTER_AVFILTER_H  Vitor Sessak committed Feb 15, 2008 24   Anton Khirnov committed May 17, 2013 25 26 27 28 29 30 31 32 33 34 35 /** * @file * @ingroup lavfi * Main libavfilter public API header */ /** * @defgroup lavfi Libavfilter - graph-based frame editing library * @{ */  Diego Biurrun committed Jul 27, 2013 36 #include "libavutil/attributes.h"  Diego Biurrun committed Nov 16, 2009 37 #include "libavutil/avutil.h"  Anton Khirnov committed Mar 08, 2013 38 #include "libavutil/frame.h"  Mans Rullgard committed Jul 03, 2011 39 #include "libavutil/log.h"  Reinhard Tartler committed Feb 15, 2011 40 #include "libavutil/samplefmt.h"  Mans Rullgard committed Jul 03, 2011 41 #include "libavutil/pixfmt.h"  Mans Rullgard committed Jul 03, 2011 42 #include "libavutil/rational.h"  Stefano Sabatini committed Dec 25, 2011 43 #include "libavcodec/avcodec.h"  Diego Biurrun committed Nov 16, 2009 44   Vitor Sessak committed Feb 15, 2008 45 #include  Vitor Sessak committed Feb 15, 2008 46   Anton Khirnov committed Jan 12, 2012 47 48 #include "libavfilter/version.h"  Stefano Sabatini committed Aug 08, 2008 49 /**  Måns Rullgård committed Jun 30, 2010 50  * Return the LIBAVFILTER_VERSION_INT constant.  Stefano Sabatini committed Aug 08, 2008 51 52 53  */ unsigned avfilter_version(void);  Diego Biurrun committed Nov 18, 2009 54 /**  Måns Rullgård committed Jun 30, 2010 55  * Return the libavfilter build-time configuration.  Diego Biurrun committed Nov 18, 2009 56  */  Stefano Sabatini committed Jan 03, 2010 57 const char *avfilter_configuration(void);  Diego Biurrun committed Nov 18, 2009 58 59  /**  Måns Rullgård committed Jun 30, 2010 60  * Return the libavfilter license.  Diego Biurrun committed Nov 18, 2009 61  */  Stefano Sabatini committed Jan 03, 2010 62 const char *avfilter_license(void);  Diego Biurrun committed Nov 18, 2009 63 64   Vitor Sessak committed Feb 15, 2008 65 66 67 typedef struct AVFilterContext AVFilterContext; typedef struct AVFilterLink AVFilterLink; typedef struct AVFilterPad AVFilterPad;  Anton Khirnov committed Jun 05, 2012 68 typedef struct AVFilterFormats AVFilterFormats;  Vitor Sessak committed Feb 15, 2008 69   Anton Khirnov committed Mar 08, 2013 70 #if FF_API_AVFILTERBUFFER  Vitor Sessak committed Feb 15, 2008 71 /**  Stefano Sabatini committed Jul 17, 2010 72  * A reference-counted buffer data type used by the filter system. Filters  Vitor Sessak committed Feb 15, 2008 73  * should not store pointers to this structure directly, but instead use the  S.N. Hemanth Meenakshisundaram committed Aug 07, 2010 74  * AVFilterBufferRef structure below.  Vitor Sessak committed Feb 15, 2008 75  */  Stefano Sabatini committed Aug 12, 2010 76 typedef struct AVFilterBuffer {  S.N. Hemanth Meenakshisundaram committed Jul 30, 2010 77  uint8_t *data[8]; ///< buffer data for each plane/channel  Anton Khirnov committed May 09, 2012 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93  /** * pointers to the data planes/channels. * * For video, this should simply point to data[]. * * For planar audio, each channel has a separate data pointer, and * linesize[0] contains the size of each channel buffer. * For packed audio, there is just one data pointer, and linesize[0] * contains the total size of the buffer for all channels. * * Note: Both data and extended_data will always be set, but for planar * audio with more channels that can fit in data, extended_data must be used * in order to access all channels. */ uint8_t **extended_data;  Anton Khirnov committed Jun 26, 2012 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108  int linesize[8]; ///< number of bytes per line /** private data to be used by a custom free function */ void *priv; /** * A pointer to the function to deallocate this buffer if the default * function is not sufficient. This could, for example, add the memory * back into a memory pool to be reused later without the overhead of * reallocating it from scratch. */ void (*free)(struct AVFilterBuffer *buf); int format; ///< media format int w, h; ///< width and height of the allocated buffer unsigned refcount; ///< number of references to this buffer  S.N. Hemanth Meenakshisundaram committed Jul 17, 2010 109 } AVFilterBuffer;  Vitor Sessak committed Feb 15, 2008 110   S.N. Hemanth Meenakshisundaram committed Jul 17, 2010 111 112 113 114 115 #define AV_PERM_READ 0x01 ///< can read from the buffer #define AV_PERM_WRITE 0x02 ///< can write to the buffer #define AV_PERM_PRESERVE 0x04 ///< nobody else can overwrite the buffer #define AV_PERM_REUSE 0x08 ///< can output the buffer multiple times, with the same contents each time #define AV_PERM_REUSE2 0x10 ///< can output the buffer multiple times, modified each time  Michael Niedermayer committed Dec 27, 2010 116 #define AV_PERM_NEG_LINESIZES 0x20 ///< the buffer requested can have negative linesizes  S.N. Hemanth Meenakshisundaram committed Jul 17, 2010 117   S.N. Hemanth Meenakshisundaram committed Aug 17, 2010 118 119 120 121 122 123 /** * Audio specific properties in a reference to an AVFilterBuffer. Since * AVFilterBufferRef is common to different media formats, audio specific * per reference properties must be separated out. */ typedef struct AVFilterBufferRefAudioProps {  Mans Rullgard committed Nov 25, 2011 124  uint64_t channel_layout; ///< channel layout of audio buffer  Stefano Sabatini committed Jan 15, 2011 125  int nb_samples; ///< number of audio samples  Anton Khirnov committed May 09, 2012 126  int sample_rate; ///< audio buffer sample rate  S.N. Hemanth Meenakshisundaram committed Aug 17, 2010 127 128 129  int planar; ///< audio buffer - planar or packed } AVFilterBufferRefAudioProps;  S.N. Hemanth Meenakshisundaram committed Aug 11, 2010 130 131 132 133 134 /** * Video specific properties in a reference to an AVFilterBuffer. Since * AVFilterBufferRef is common to different media formats, video specific * per reference properties must be separated out. */  Stefano Sabatini committed Aug 12, 2010 135 typedef struct AVFilterBufferRefVideoProps {  S.N. Hemanth Meenakshisundaram committed Aug 11, 2010 136 137 138 139 140  int w; ///< image width int h; ///< image height AVRational pixel_aspect; ///< pixel aspect ratio int interlaced; ///< is frame interlaced int top_field_first; ///< field order  Stefano Sabatini committed Apr 26, 2011 141  enum AVPictureType pict_type; ///< picture type of the frame  Roger Pau Monné committed Apr 26, 2011 142  int key_frame; ///< 1 -> keyframe, 0-> not  S.N. Hemanth Meenakshisundaram committed Aug 11, 2010 143 144 } AVFilterBufferRefVideoProps;  Vitor Sessak committed Feb 15, 2008 145 /**  S.N. Hemanth Meenakshisundaram committed Jul 17, 2010 146  * A reference to an AVFilterBuffer. Since filters can manipulate the origin of  S.N. Hemanth Meenakshisundaram committed Aug 07, 2010 147  * a buffer to, for example, crop image without any memcpy, the buffer origin  Stefano Sabatini committed May 14, 2009 148  * and dimensions are per-reference properties. Linesize is also useful for  Vitor Sessak committed Feb 15, 2008 149  * image flipping, frame to field filters, etc, and so is also per-reference.  Vitor Sessak committed Feb 15, 2008 150  *  Vitor Sessak committed Feb 15, 2008 151  * TODO: add anything necessary for frame reordering  Vitor Sessak committed Feb 15, 2008 152  */  Stefano Sabatini committed Aug 12, 2010 153 typedef struct AVFilterBufferRef {  S.N. Hemanth Meenakshisundaram committed Aug 07, 2010 154  AVFilterBuffer *buf; ///< the buffer that this is a reference to  S.N. Hemanth Meenakshisundaram committed Aug 17, 2010 155  uint8_t *data[8]; ///< picture/audio data for each plane  Anton Khirnov committed May 09, 2012 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170  /** * pointers to the data planes/channels. * * For video, this should simply point to data[]. * * For planar audio, each channel has a separate data pointer, and * linesize[0] contains the size of each channel buffer. * For packed audio, there is just one data pointer, and linesize[0] * contains the total size of the buffer for all channels. * * Note: Both data and extended_data will always be set, but for planar * audio with more channels that can fit in data, extended_data must be used * in order to access all channels. */ uint8_t **extended_data;  Anton Khirnov committed Jun 26, 2012 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188  int linesize[8]; ///< number of bytes per line AVFilterBufferRefVideoProps *video; ///< video buffer specific properties AVFilterBufferRefAudioProps *audio; ///< audio buffer specific properties /** * presentation timestamp. The time unit may change during * filtering, as it is specified in the link and the filter code * may need to rescale the PTS accordingly. */ int64_t pts; int64_t pos; ///< byte position in stream, -1 if unknown int format; ///< media format int perms; ///< permissions, see the AV_PERM_* flags enum AVMediaType type; ///< media type of buffer data  S.N. Hemanth Meenakshisundaram committed Aug 07, 2010 189 } AVFilterBufferRef;  Vitor Sessak committed Feb 15, 2008 190   Stefano Sabatini committed Jul 07, 2010 191 /**  S.N. Hemanth Meenakshisundaram committed Aug 17, 2010 192  * Copy properties of src to dst, without copying the actual data  Stefano Sabatini committed Jul 07, 2010 193  */  Anton Khirnov committed Mar 08, 2013 194 attribute_deprecated  Anton Khirnov committed May 07, 2012 195 void avfilter_copy_buffer_ref_props(AVFilterBufferRef *dst, AVFilterBufferRef *src);  Stefano Sabatini committed Jul 07, 2010 196   Vitor Sessak committed Feb 15, 2008 197 /**  S.N. Hemanth Meenakshisundaram committed Aug 07, 2010 198  * Add a new reference to a buffer.  Stefano Sabatini committed Aug 20, 2010 199  *  S.N. Hemanth Meenakshisundaram committed Aug 07, 2010 200  * @param ref an existing reference to the buffer  Vitor Sessak committed Feb 15, 2008 201  * @param pmask a bitmask containing the allowable permissions in the new  Vitor Sessak committed Feb 15, 2008 202  * reference  S.N. Hemanth Meenakshisundaram committed Aug 07, 2010 203  * @return a new reference to the buffer with the same properties as the  Vitor Sessak committed Feb 15, 2008 204  * old, excluding any permissions denied by pmask  Vitor Sessak committed Feb 15, 2008 205  */  Anton Khirnov committed Mar 08, 2013 206 attribute_deprecated  S.N. Hemanth Meenakshisundaram committed Aug 07, 2010 207 AVFilterBufferRef *avfilter_ref_buffer(AVFilterBufferRef *ref, int pmask);  Vitor Sessak committed Feb 15, 2008 208 209  /**  S.N. Hemanth Meenakshisundaram committed Aug 07, 2010 210 211  * Remove a reference to a buffer. If this is the last reference to the * buffer, the buffer itself is also automatically freed.  Stefano Sabatini committed Aug 20, 2010 212  *  Stefano Sabatini committed Jan 15, 2011 213  * @param ref reference to the buffer, may be NULL  Robert Nagy committed Jul 20, 2012 214 215 216  * * @note it is recommended to use avfilter_unref_bufferp() instead of this * function  Vitor Sessak committed Feb 15, 2008 217  */  Anton Khirnov committed Mar 08, 2013 218 attribute_deprecated  S.N. Hemanth Meenakshisundaram committed Aug 07, 2010 219 void avfilter_unref_buffer(AVFilterBufferRef *ref);  Vitor Sessak committed Feb 15, 2008 220   Robert Nagy committed Jul 20, 2012 221 222 223 224 225 226 227 /** * Remove a reference to a buffer and set the pointer to NULL. * If this is the last reference to the buffer, the buffer itself * is also automatically freed. * * @param ref pointer to the buffer reference */  Anton Khirnov committed Mar 08, 2013 228 attribute_deprecated  Robert Nagy committed Jul 20, 2012 229 void avfilter_unref_bufferp(AVFilterBufferRef **ref);  Anton Khirnov committed Mar 08, 2013 230 #endif  Robert Nagy committed Jul 20, 2012 231   Anton Khirnov committed Jun 13, 2012 232 #if FF_API_AVFILTERPAD_PUBLIC  Vitor Sessak committed Feb 15, 2008 233 /**  Vitor Sessak committed Feb 15, 2008 234  * A filter pad used for either input or output.  Anton Khirnov committed Jun 13, 2012 235 236 237 238 239  * * @warning this struct will be removed from public API. * users should call avfilter_pad_get_name() and avfilter_pad_get_type() * to access the name and type fields; there should be no need to access * any other fields from outside of libavfilter.  Vitor Sessak committed Feb 15, 2008 240  */  Stefano Sabatini committed Aug 12, 2010 241 struct AVFilterPad {  Vitor Sessak committed Feb 15, 2008 242  /**  Stefano Sabatini committed May 14, 2009 243 244  * Pad name. The name is unique among inputs and among outputs, but an * input may have the same name as an output. This may be NULL if this  Vitor Sessak committed Feb 15, 2008 245  * pad has no need to ever be referenced by name.  Vitor Sessak committed Feb 15, 2008 246  */  Vitor Sessak committed Feb 15, 2008 247  const char *name;  Vitor Sessak committed Feb 15, 2008 248 249  /**  Anton Khirnov committed May 22, 2012 250  * AVFilterPad type.  Vitor Sessak committed Feb 15, 2008 251  */  Stefano Sabatini committed Mar 30, 2010 252  enum AVMediaType type;  Vitor Sessak committed Feb 15, 2008 253   Vitor Sessak committed Feb 15, 2008 254  /**  Stefano Sabatini committed May 14, 2009 255  * Minimum required permissions on incoming buffers. Any buffer with  Vitor Sessak committed Feb 15, 2008 256 257 258 259 260  * insufficient permissions will be automatically copied by the filter * system to a new buffer which provides the needed access permissions. * * Input pads only. */  Anton Khirnov committed Mar 08, 2013 261  attribute_deprecated int min_perms;  Vitor Sessak committed Feb 15, 2008 262 263  /**  Stefano Sabatini committed May 14, 2009 264  * Permissions which are not accepted on incoming buffers. Any buffer  Stefano Sabatini committed Jan 02, 2009 265 266  * which has any of these permissions set will be automatically copied * by the filter system to a new buffer which does not have those  Stefano Sabatini committed May 14, 2009 267  * permissions. This can be used to easily disallow buffers with  Stefano Sabatini committed Jan 02, 2009 268  * AV_PERM_REUSE.  Vitor Sessak committed Feb 15, 2008 269 270 271  * * Input pads only. */  Anton Khirnov committed Mar 08, 2013 272  attribute_deprecated int rej_perms;  Vitor Sessak committed Feb 15, 2008 273   Vitor Sessak committed Feb 15, 2008 274  /**  Anton Khirnov committed Nov 28, 2012 275  * @deprecated unused  Vitor Sessak committed Feb 15, 2008 276  */  Anton Khirnov committed Jul 22, 2012 277  int (*start_frame)(AVFilterLink *link, AVFilterBufferRef *picref);  Vitor Sessak committed Feb 15, 2008 278 279  /**  S.N. Hemanth Meenakshisundaram committed Aug 17, 2010 280  * Callback function to get a video buffer. If NULL, the filter system will  Stefano Sabatini committed Nov 03, 2009 281  * use avfilter_default_get_video_buffer().  Vitor Sessak committed Feb 15, 2008 282 283  * * Input video pads only.  Vitor Sessak committed Feb 15, 2008 284  */  Anton Khirnov committed Mar 08, 2013 285  AVFrame *(*get_video_buffer)(AVFilterLink *link, int w, int h);  Vitor Sessak committed Feb 15, 2008 286   S.N. Hemanth Meenakshisundaram committed Aug 17, 2010 287 288 289 290 291 292  /** * Callback function to get an audio buffer. If NULL, the filter system will * use avfilter_default_get_audio_buffer(). * * Input audio pads only. */  Anton Khirnov committed Mar 08, 2013 293  AVFrame *(*get_audio_buffer)(AVFilterLink *link, int nb_samples);  S.N. Hemanth Meenakshisundaram committed Aug 17, 2010 294   Vitor Sessak committed Feb 15, 2008 295  /**  Anton Khirnov committed Nov 28, 2012 296  * @deprecated unused  Vitor Sessak committed Feb 15, 2008 297  */  Anton Khirnov committed Jul 22, 2012 298  int (*end_frame)(AVFilterLink *link);  Vitor Sessak committed Feb 15, 2008 299 300  /**  Anton Khirnov committed Nov 28, 2012 301  * @deprecated unused  Vitor Sessak committed Feb 15, 2008 302  */  Anton Khirnov committed Jul 22, 2012 303  int (*draw_slice)(AVFilterLink *link, int y, int height, int slice_dir);  Vitor Sessak committed Feb 15, 2008 304   S.N. Hemanth Meenakshisundaram committed Aug 17, 2010 305  /**  Anton Khirnov committed Nov 28, 2012 306 307  * Filtering callback. This is where a filter receives a frame with * audio/video data and should do its processing.  S.N. Hemanth Meenakshisundaram committed Aug 17, 2010 308  *  Anton Khirnov committed Nov 28, 2012 309  * Input pads only.  Anton Khirnov committed Jul 09, 2012 310 311 312 313  * * @return >= 0 on success, a negative AVERROR on error. This function * must ensure that samplesref is properly unreferenced on error if it * hasn't been passed on to another filter.  S.N. Hemanth Meenakshisundaram committed Aug 17, 2010 314  */  Anton Khirnov committed Mar 08, 2013 315  int (*filter_frame)(AVFilterLink *link, AVFrame *frame);  S.N. Hemanth Meenakshisundaram committed Aug 17, 2010 316   Vitor Sessak committed Feb 15, 2008 317  /**  Stefano Sabatini committed May 14, 2009 318  * Frame poll callback. This returns the number of immediately available  Michael Niedermayer committed Sep 23, 2010 319  * samples. It should return a positive value if the next request_frame()  Vitor Sessak committed Feb 15, 2008 320 321 322 323  * is guaranteed to return one frame (with no delay). * * Defaults to just calling the source poll_frame() method. *  Anton Khirnov committed May 22, 2012 324  * Output pads only.  Vitor Sessak committed Feb 15, 2008 325 326 327  */ int (*poll_frame)(AVFilterLink *link);  Vitor Sessak committed Feb 15, 2008 328  /**  Stefano Sabatini committed May 14, 2009 329 330  * Frame request callback. A call to this should result in at least one * frame being output over the given link. This should return zero on  Vitor Sessak committed Feb 15, 2008 331 332  * success, and another value on error. *  Anton Khirnov committed May 22, 2012 333  * Output pads only.  Vitor Sessak committed Feb 15, 2008 334  */  Vitor Sessak committed Feb 15, 2008 335  int (*request_frame)(AVFilterLink *link);  Vitor Sessak committed Feb 15, 2008 336 337  /**  Vitor Sessak committed Feb 15, 2008 338 339 340  * Link configuration callback. * * For output pads, this should set the link properties such as  Stefano Sabatini committed May 14, 2009 341  * width/height. This should NOT set the format property - that is  Vitor Sessak committed Feb 15, 2008 342 343  * negotiated between filters by the filter system using the * query_formats() callback before this function is called.  Vitor Sessak committed Feb 15, 2008 344 345 346  * * For input pads, this should check the properties of the link, and update * the filter's internal state as necessary.  Vitor Sessak committed Feb 15, 2008 347 348 349  * * For both input and output filters, this should return zero on success, * and another value on error.  Vitor Sessak committed Feb 15, 2008 350  */  Vitor Sessak committed Feb 15, 2008 351  int (*config_props)(AVFilterLink *link);  Anton Khirnov committed Jun 22, 2012 352 353 354 355 356 357 358 359  /** * The filter expects a fifo to be inserted on its input link, * typically because it has a delay. * * input pads only. */ int needs_fifo;  Anton Khirnov committed Mar 08, 2013 360 361  int needs_writable;  Vitor Sessak committed Feb 15, 2008 362 };  Anton Khirnov committed Jun 13, 2012 363 #endif  Vitor Sessak committed Feb 15, 2008 364   Anton Khirnov committed Apr 11, 2013 365 366 367 368 369 370 /** * Get the number of elements in a NULL-terminated array of AVFilterPads (e.g. * AVFilter.inputs/outputs). */ int avfilter_pad_count(const AVFilterPad *pads);  Anton Khirnov committed Jun 13, 2012 371 372 373 374 375 376 377 378 379 /** * Get the name of an AVFilterPad. * * @param pads an array of AVFilterPads * @param pad_idx index of the pad in the array it; is the caller's * responsibility to ensure the index is valid * * @return name of the pad_idx'th pad in pads */  Anton Khirnov committed Apr 11, 2013 380 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx);  Anton Khirnov committed Jun 13, 2012 381 382 383 384 385 386 387 388 389 390  /** * Get the type of an AVFilterPad. * * @param pads an array of AVFilterPads * @param pad_idx index of the pad in the array; it is the caller's * responsibility to ensure the index is valid * * @return type of the pad_idx'th pad in pads */  Anton Khirnov committed Apr 11, 2013 391 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx);  Anton Khirnov committed Jun 13, 2012 392   Anton Khirnov committed Apr 11, 2013 393 394 395 396 397 398 399 400 401 402 403 404 /** * The number of the filter inputs is not determined just by AVFilter.inputs. * The filter might add additional inputs during initialization depending on the * options supplied to it. */ #define AVFILTER_FLAG_DYNAMIC_INPUTS (1 << 0) /** * The number of the filter outputs is not determined just by AVFilter.outputs. * The filter might add additional outputs during initialization depending on * the options supplied to it. */ #define AVFILTER_FLAG_DYNAMIC_OUTPUTS (1 << 1)  Anton Khirnov committed May 24, 2013 405 406 407 408 409 /** * The filter supports multithreading by splitting frames into multiple parts * and processing them concurrently. */ #define AVFILTER_FLAG_SLICE_THREADS (1 << 2)  Anton Khirnov committed Apr 11, 2013 410   Vitor Sessak committed Feb 15, 2008 411 /**  Stefano Sabatini committed May 14, 2009 412  * Filter definition. This defines the pads a filter contains, and all the  Vitor Sessak committed Feb 15, 2008 413 414  * callback functions used to interact with the filter. */  Stefano Sabatini committed Aug 12, 2010 415 typedef struct AVFilter {  Anton Khirnov committed Jun 04, 2013 416 417 418 419  /** * Filter name. Must be non-NULL and unique among filters. */ const char *name;  Vitor Sessak committed Feb 15, 2008 420   Anton Khirnov committed Jun 26, 2012 421  /**  Anton Khirnov committed Jun 04, 2013 422 423 424  * A description of the filter. May be NULL. * * You should use the NULL_IF_CONFIG_SMALL() macro to define it.  Anton Khirnov committed Jun 26, 2012 425 426 427  */ const char *description;  Anton Khirnov committed Jun 04, 2013 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443  /** * List of inputs, terminated by a zeroed element. * * 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 outputs, terminated by a zeroed element. * * 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;  Anton Khirnov committed Jun 26, 2012 444   Anton Khirnov committed Apr 09, 2013 445  /**  Anton Khirnov committed Jun 04, 2013 446 447 448 449 450 451  * A class for the private data, used to declare filter private AVOptions. * This field is NULL for filters that do not declare any options. * * If this field is non-NULL, the first member of the filter private data * must be a pointer to AVClass, which will be set by libavfilter generic * code to this class.  Anton Khirnov committed Apr 09, 2013 452 453 454  */ const AVClass *priv_class;  Anton Khirnov committed Apr 11, 2013 455 456 457 458 459  /** * A combination of AVFILTER_FLAG_* */ int flags;  Anton Khirnov committed Jun 26, 2012 460 461 462 463 464 465 466  /***************************************************************** * 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. ***************************************************************** */  Vitor Sessak committed Feb 15, 2008 467   Vitor Sessak committed Feb 15, 2008 468  /**  Anton Khirnov committed Jun 04, 2013 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487  * Filter initialization function. * * This callback will be called only once during the filter lifetime, after * all the options have been set, but before links between filters are * established and format negotiation is done. * * Basic filter initialization should be done here. Filters with dynamic * inputs and/or outputs should create those inputs/outputs here based on * provided options. No more changes to this filter's inputs/outputs can be * done after this callback. * * This callback must not assume that the filter links exist or frame * parameters are known. * * @ref AVFilter.uninit "uninit" is guaranteed to be called even if * initialization fails, so this callback does not have to clean up on * failure. * * @return 0 on success, a negative AVERROR on failure  Vitor Sessak committed Feb 15, 2008 488  */  Anton Khirnov committed Apr 09, 2013 489  int (*init)(AVFilterContext *ctx);  Vitor Sessak committed Feb 15, 2008 490   Anton Khirnov committed Apr 09, 2013 491  /**  Anton Khirnov committed Jun 04, 2013 492 493 494 495 496 497 498 499 500  * Should be set instead of @ref AVFilter.init "init" by the filters that * want to pass a dictionary of AVOptions to nested contexts that are * allocated during init. * * On return, the options dict should be freed and replaced with one that * contains all the options which could not be processed by this filter (or * with NULL if all the options were processed). * * Otherwise the semantics is the same as for @ref AVFilter.init "init".  Anton Khirnov committed Apr 09, 2013 501 502 503  */ int (*init_dict)(AVFilterContext *ctx, AVDictionary **options);  Vitor Sessak committed Feb 15, 2008 504  /**  Anton Khirnov committed Jun 04, 2013 505 506 507 508 509 510 511 512  * Filter uninitialization function. * * Called only once right before the filter is freed. Should deallocate any * memory held by the filter, release any buffer references, etc. It does * not need to deallocate the AVFilterContext.priv memory itself. * * This callback may be called even if @ref AVFilter.init "init" was not * called or failed, so it must be prepared to handle such a situation.  Vitor Sessak committed Feb 15, 2008 513  */  Vitor Sessak committed Feb 15, 2008 514 515  void (*uninit)(AVFilterContext *ctx);  Vitor Sessak committed Feb 15, 2008 516  /**  Anton Khirnov committed Jun 04, 2013 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533  * Query formats supported by the filter on its inputs and outputs. * * This callback is called after the filter is initialized (so the inputs * and outputs are fixed), shortly before the format negotiation. This * callback may be called more than once. * * This callback must set AVFilterLink.out_formats on every input link and * AVFilterLink.in_formats on every output link to a list of pixel/sample * formats that the filter supports on that link. For audio links, this * filter must also set @ref AVFilterLink.in_samplerates "in_samplerates" / * @ref AVFilterLink.out_samplerates "out_samplerates" and * @ref AVFilterLink.in_channel_layouts "in_channel_layouts" / * @ref AVFilterLink.out_channel_layouts "out_channel_layouts" analogously. * * This callback may be NULL for filters with one input, in which case * libavfilter assumes that it supports all input formats and preserves * them on output.  Vitor Sessak committed Feb 15, 2008 534  *  Stefano Sabatini committed Jan 07, 2010 535 536  * @return zero on success, a negative value corresponding to an * AVERROR code otherwise  Vitor Sessak committed Feb 15, 2008 537 538 539  */ int (*query_formats)(AVFilterContext *);  Anton Khirnov committed Jun 26, 2012 540  int priv_size; ///< size of private data to allocate for the filter  Anton Khirnov committed Apr 11, 2013 541   Anton Khirnov committed Jun 04, 2013 542 543 544 545  /** * Used by the filter registration system. Must not be touched by any other * code. */  Anton Khirnov committed Apr 11, 2013 546  struct AVFilter *next;  Vitor Sessak committed Feb 15, 2008 547 548 } AVFilter;  Anton Khirnov committed May 24, 2013 549 550 551 552 553 554 555 /** * Process multiple parts of the frame concurrently. */ #define AVFILTER_THREAD_SLICE (1 << 0) typedef struct AVFilterInternal AVFilterInternal;  Vitor Sessak committed Feb 15, 2008 556 /** An instance of a filter */  Stefano Sabatini committed Aug 12, 2010 557 struct AVFilterContext {  Panagiotis Issaris committed Mar 06, 2008 558  const AVClass *av_class; ///< needed for av_log()  Vitor Sessak committed Feb 15, 2008 559   Anton Khirnov committed Apr 11, 2013 560  const AVFilter *filter; ///< the AVFilter of which this is an instance  Vitor Sessak committed Feb 15, 2008 561   Vitor Sessak committed Feb 15, 2008 562  char *name; ///< name of this filter instance  Vitor Sessak committed Feb 15, 2008 563   Anton Khirnov committed Jun 26, 2012 564 565  AVFilterPad *input_pads; ///< array of input pads AVFilterLink **inputs; ///< array of pointers to input links  Anton Khirnov committed Jun 13, 2012 566 #if FF_API_FOO_COUNT  Diego Biurrun committed Jul 27, 2013 567  attribute_deprecated unsigned input_count; ///< @deprecated use nb_inputs  Anton Khirnov committed Jun 13, 2012 568 #endif  Anton Khirnov committed Jun 26, 2012 569  unsigned nb_inputs; ///< number of input pads  Vitor Sessak committed Feb 15, 2008 570   Anton Khirnov committed Jun 26, 2012 571 572  AVFilterPad *output_pads; ///< array of output pads AVFilterLink **outputs; ///< array of pointers to output links  Anton Khirnov committed Jun 13, 2012 573 #if FF_API_FOO_COUNT  Diego Biurrun committed Jul 27, 2013 574  attribute_deprecated unsigned output_count; ///< @deprecated use nb_outputs  Anton Khirnov committed Jun 13, 2012 575 #endif  Anton Khirnov committed Jun 26, 2012 576  unsigned nb_outputs; ///< number of output pads  Vitor Sessak committed Feb 15, 2008 577   Vitor Sessak committed Feb 15, 2008 578  void *priv; ///< private data for use by the filter  Anton Khirnov committed Apr 11, 2013 579 580  struct AVFilterGraph *graph; ///< filtergraph this filter belongs to  Anton Khirnov committed May 24, 2013 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603  /** * Type of multithreading being allowed/used. A combination of * AVFILTER_THREAD_* flags. * * May be set by the caller before initializing the filter to forbid some * or all kinds of multithreading for this filter. The default is allowing * everything. * * When the filter is initialized, this field is combined using bit AND with * AVFilterGraph.thread_type to get the final mask used for determining * allowed threading types. I.e. a threading type needs to be set in both * to be allowed. * * After the filter is initialzed, libavfilter sets this field to the * threading type that is actually used (0 for no multithreading). */ int thread_type; /** * An opaque struct for libavfilter internal use. */ AVFilterInternal *internal;  Vitor Sessak committed Feb 15, 2008 604 605 };  Vitor Sessak committed Feb 15, 2008 606 /**  Stefano Sabatini committed May 14, 2009 607  * A link between two filters. This contains pointers to the source and  Diego Biurrun committed May 26, 2008 608  * destination filters between which this link exists, and the indexes of  Stefano Sabatini committed May 14, 2009 609  * the pads involved. In addition, this link also contains the parameters  Vitor Sessak committed Feb 15, 2008 610  * which have been negotiated and agreed upon between the filter, such as  Stefano Sabatini committed Jan 10, 2009 611  * image dimensions, format, etc.  Vitor Sessak committed Feb 15, 2008 612  */  Stefano Sabatini committed Aug 12, 2010 613 struct AVFilterLink {  Vitor Sessak committed Feb 15, 2008 614  AVFilterContext *src; ///< source filter  Stefano Sabatini committed Sep 27, 2010 615  AVFilterPad *srcpad; ///< output pad on the source filter  Vitor Sessak committed Feb 15, 2008 616   Vitor Sessak committed Feb 15, 2008 617  AVFilterContext *dst; ///< dest filter  Stefano Sabatini committed Sep 27, 2010 618  AVFilterPad *dstpad; ///< input pad on the dest filter  Vitor Sessak committed Feb 15, 2008 619   S.N. Hemanth Meenakshisundaram committed Jul 22, 2010 620 621  enum AVMediaType type; ///< filter media type  Michael Niedermayer committed Feb 14, 2011 622  /* These parameters apply only to video */  Vitor Sessak committed Feb 15, 2008 623 624  int w; ///< agreed upon image width int h; ///< agreed upon image height  Michael Niedermayer committed Feb 14, 2011 625  AVRational sample_aspect_ratio; ///< agreed upon sample aspect ratio  S.N. Hemanth Meenakshisundaram committed Aug 17, 2010 626  /* These two parameters apply only to audio */  Justin Ruggles committed Nov 11, 2012 627  uint64_t channel_layout; ///< channel layout of current buffer (see libavutil/channel_layout.h)  Anton Khirnov committed May 09, 2012 628  int sample_rate; ///< samples per second  S.N. Hemanth Meenakshisundaram committed Aug 17, 2010 629   S.N. Hemanth Meenakshisundaram committed Jul 22, 2010 630  int format; ///< agreed upon media format  Vitor Sessak committed Feb 15, 2008 631   Stefano Sabatini committed Oct 10, 2010 632 633 634 635 636 637 638 639  /** * Define the time base used by the PTS of the frames/samples * which will pass through this link. * During the configuration stage, each filter is supposed to * change only the output timebase, while the timebase of the * input link is assumed to be an unchangeable property. */ AVRational time_base;  Anton Khirnov committed May 14, 2012 640 641 642 643 644 645 646 647  /***************************************************************** * 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. ***************************************************************** */  Anton Khirnov committed Jun 26, 2012 648 649 650 651 652 653 654 655  /** * Lists of formats supported by the input and output filters respectively. * These lists are used for negotiating the format to actually be used, * which will be loaded into the format member, above, when chosen. */ AVFilterFormats *in_formats; AVFilterFormats *out_formats;  Anton Khirnov committed May 14, 2012 656 657 658 659 660 661 662 663  /** * Lists of channel layouts and sample rates used for automatic * negotiation. */ AVFilterFormats *in_samplerates; AVFilterFormats *out_samplerates; struct AVFilterChannelLayouts *in_channel_layouts; struct AVFilterChannelLayouts *out_channel_layouts;  Anton Khirnov committed Jun 22, 2012 664 665 666 667 668 669 670 671 672  /** * Audio only, the destination filter sets this to a non-zero value to * request that buffers with the given number of samples should be sent to * it. AVFilterPad.needs_fifo must also be set on the corresponding input * pad. * Last buffer before EOF will be padded with silence. */ int request_samples;  Anton Khirnov committed Jun 26, 2012 673 674 675 676 677 678 679  /** stage of the initialization of the link properties (dimensions, etc) */ enum { AVLINK_UNINIT = 0, ///< not started AVLINK_STARTINIT, ///< started, but incomplete AVLINK_INIT ///< complete } init_state;  Vitor Sessak committed Feb 15, 2008 680 681 };  Vitor Sessak committed Feb 15, 2008 682 /**  Måns Rullgård committed Jun 30, 2010 683  * Link two filters together.  Stefano Sabatini committed Aug 20, 2010 684  *  Vitor Sessak committed Feb 15, 2008 685 686 687 688 689  * @param src the source filter * @param srcpad index of the output pad on the source filter * @param dst the destination filter * @param dstpad index of the input pad on the destination filter * @return zero on success  Vitor Sessak committed Feb 15, 2008 690  */  Vitor Sessak committed Feb 15, 2008 691 692 693 int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad);  Vitor Sessak committed Feb 15, 2008 694 /**  S.N. Hemanth Meenakshisundaram committed Jul 22, 2010 695  * Negotiate the media format, dimensions, etc of all inputs to a filter.  Stefano Sabatini committed Aug 20, 2010 696  *  Vitor Sessak committed Feb 15, 2008 697 698  * @param filter the filter to negotiate the properties for its inputs * @return zero on successful negotiation  Vitor Sessak committed Feb 15, 2008 699  */  Vitor Sessak committed Feb 15, 2008 700 int avfilter_config_links(AVFilterContext *filter);  Vitor Sessak committed Feb 15, 2008 701   Anton Khirnov committed Mar 08, 2013 702 #if FF_API_AVFILTERBUFFER  Stefano Sabatini committed Nov 25, 2010 703 704 705 706 707 708 709 710 711 712 713 /** * Create a buffer reference wrapped around an already allocated image * buffer. * * @param data pointers to the planes of the image to reference * @param linesize linesizes for the planes of the image to reference * @param perms the required access permissions * @param w the width of the image specified by the data and linesize arrays * @param h the height of the image specified by the data and linesize arrays * @param format the pixel format of the image specified by the data and linesize arrays */  Anton Khirnov committed Mar 08, 2013 714 attribute_deprecated  Stefano Sabatini committed Nov 25, 2010 715 716 AVFilterBufferRef * avfilter_get_video_buffer_ref_from_arrays(uint8_t *data[4], int linesize[4], int perms,  Anton Khirnov committed Oct 08, 2012 717  int w, int h, enum AVPixelFormat format);  Stefano Sabatini committed Nov 25, 2010 718   Stefano Sabatini committed May 09, 2012 719 720 721 722 723 724 725 726 727 728 729 /** * Create an audio buffer reference wrapped around an already * allocated samples buffer. * * @param data pointers to the samples plane buffers * @param linesize linesize for the samples plane buffers * @param perms the required access permissions * @param nb_samples number of samples per channel * @param sample_fmt the format of each sample in the buffer to allocate * @param channel_layout the channel layout of the buffer */  Anton Khirnov committed Mar 08, 2013 730 attribute_deprecated  Stefano Sabatini committed May 09, 2012 731 732 733 734 735 736 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);  Anton Khirnov committed Mar 08, 2013 737 #endif  Stefano Sabatini committed May 09, 2012 738   Måns Rullgård committed Jun 30, 2010 739 /** Initialize the filter system. Register all builtin filters. */  Vitor Sessak committed Feb 15, 2008 740 void avfilter_register_all(void);  Vitor Sessak committed Feb 15, 2008 741   Anton Khirnov committed Apr 11, 2013 742 #if FF_API_OLD_FILTER_REGISTER  Måns Rullgård committed Jun 30, 2010 743 /** Uninitialize the filter system. Unregister all filters. */  Anton Khirnov committed Apr 11, 2013 744 attribute_deprecated  Vitor Sessak committed Feb 15, 2008 745 void avfilter_uninit(void);  Anton Khirnov committed Apr 11, 2013 746 #endif  Vitor Sessak committed Feb 15, 2008 747 748  /**  Måns Rullgård committed Jun 30, 2010 749  * Register a filter. This is only needed if you plan to use  Vitor Sessak committed Feb 15, 2008 750  * avfilter_get_by_name later to lookup the AVFilter structure by name. A  Anton Khirnov committed Apr 11, 2013 751 752  * filter can still by instantiated with avfilter_graph_alloc_filter even if it * is not registered.  Stefano Sabatini committed Aug 20, 2010 753  *  Vitor Sessak committed Feb 15, 2008 754  * @param filter the filter to register  Stefano Sabatini committed Nov 24, 2009 755 756  * @return 0 if the registration was succesfull, a negative value * otherwise  Vitor Sessak committed Feb 15, 2008 757  */  Stefano Sabatini committed Nov 24, 2009 758 int avfilter_register(AVFilter *filter);  Vitor Sessak committed Feb 15, 2008 759 760  /**  Måns Rullgård committed Jun 30, 2010 761  * Get a filter definition matching the given name.  Stefano Sabatini committed Aug 20, 2010 762  *  Vitor Sessak committed Feb 15, 2008 763 764  * @param name the filter name to find * @return the filter definition, if any matching one is registered.  Vitor Sessak committed Feb 15, 2008 765 766  * NULL if none found. */  Vitor Sessak committed Feb 15, 2008 767 AVFilter *avfilter_get_by_name(const char *name);  Vitor Sessak committed Feb 15, 2008 768   Anton Khirnov committed Apr 11, 2013 769 770 771 772 773 774 775 776 /** * Iterate over all registered filters. * @return If prev is non-NULL, next registered filter after prev or NULL if * prev is the last filter. If prev is NULL, return the first registered filter. */ const AVFilter *avfilter_next(const AVFilter *prev); #if FF_API_OLD_FILTER_REGISTER  Stefano Sabatini committed Nov 24, 2009 777 778 779 780 781 /** * If filter is NULL, returns a pointer to the first registered filter pointer, * if filter is non-NULL, returns the next pointer after filter. * If the returned pointer points to NULL, the last registered filter * was already reached.  Anton Khirnov committed Apr 11, 2013 782  * @deprecated use avfilter_next()  Stefano Sabatini committed Nov 24, 2009 783  */  Anton Khirnov committed Apr 11, 2013 784 attribute_deprecated  Stefano Sabatini committed Nov 24, 2009 785 AVFilter **av_filter_next(AVFilter **filter);  Anton Khirnov committed Apr 11, 2013 786 #endif  Stefano Sabatini committed Nov 24, 2009 787   Anton Khirnov committed Apr 11, 2013 788 #if FF_API_AVFILTER_OPEN  Vitor Sessak committed Feb 15, 2008 789 /**  Måns Rullgård committed Jun 30, 2010 790  * Create a filter instance.  Stefano Sabatini committed Aug 11, 2010 791 792 793  * * @param filter_ctx put here a pointer to the created filter context * on success, NULL on failure  Vitor Sessak committed Feb 15, 2008 794  * @param filter the filter to create an instance of  Stefano Sabatini committed May 14, 2009 795  * @param inst_name Name to give to the new instance. Can be NULL for none.  Stefano Sabatini committed Aug 11, 2010 796  * @return >= 0 in case of success, a negative error code otherwise  Anton Khirnov committed Apr 11, 2013 797  * @deprecated use avfilter_graph_alloc_filter() instead  Vitor Sessak committed Feb 15, 2008 798  */  Anton Khirnov committed Apr 11, 2013 799 attribute_deprecated  Stefano Sabatini committed Aug 11, 2010 800 int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name);  Anton Khirnov committed Apr 11, 2013 801 #endif  Vitor Sessak committed Feb 15, 2008 802   Anton Khirnov committed Apr 11, 2013 803 804  #if FF_API_AVFILTER_INIT_FILTER  Vitor Sessak committed Feb 15, 2008 805 /**  Måns Rullgård committed Jun 30, 2010 806  * Initialize a filter.  Stefano Sabatini committed Aug 20, 2010 807  *  Vitor Sessak committed Feb 15, 2008 808  * @param filter the filter to initialize  Vitor Sessak committed Feb 15, 2008 809 810  * @param args A string of parameters to use when initializing the filter. * The format and meaning of this string varies by filter.  Stefano Sabatini committed May 14, 2009 811  * @param opaque Any extra non-string data needed by the filter. The meaning  Vitor Sessak committed Feb 15, 2008 812  * of this parameter varies by filter.  Vitor Sessak committed Feb 15, 2008 813  * @return zero on success  Vitor Sessak committed Feb 15, 2008 814  */  Anton Khirnov committed Apr 11, 2013 815 attribute_deprecated  Vitor Sessak committed Feb 15, 2008 816 int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque);  Anton Khirnov committed Apr 11, 2013 817 818 819 820 821 822 823 824 825 826 827 828 829 #endif /** * Initialize a filter with the supplied parameters. * * @param ctx uninitialized filter context to initialize * @param args Options to initialize the filter with. This must be a * ':'-separated list of options in the 'key=value' form. * May be NULL if the options have been set directly using the * AVOptions API or there are no options that need to be set. * @return 0 on success, a negative AVERROR on failure */ int avfilter_init_str(AVFilterContext *ctx, const char *args);  Vitor Sessak committed Feb 15, 2008 830   Anton Khirnov committed Apr 11, 2013 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 /** * Initialize a filter with the supplied dictionary of options. * * @param ctx uninitialized filter context to initialize * @param options An AVDictionary filled with options for this filter. On * return this parameter will be destroyed and replaced with * a dict containing options that were not found. This dictionary * must be freed by the caller. * May be NULL, then this function is equivalent to * avfilter_init_str() with the second parameter set to NULL. * @return 0 on success, a negative AVERROR on failure * * @note This function and avfilter_init_str() do essentially the same thing, * the difference is in manner in which the options are passed. It is up to the * calling code to choose whichever is more preferable. The two functions also * behave differently when some of the provided options are not declared as * supported by the filter. In such a case, avfilter_init_str() will fail, but * this function will leave those extra options in the options AVDictionary and * continue as usual. */ int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options);  Vitor Sessak committed Feb 15, 2008 853 /**  Anton Khirnov committed Apr 11, 2013 854 855  * Free a filter context. This will also remove the filter from its * filtergraph's list of filters.  Stefano Sabatini committed Aug 20, 2010 856  *  Stefano Sabatini committed Nov 08, 2010 857  * @param filter the filter to free  Vitor Sessak committed Feb 15, 2008 858  */  Stefano Sabatini committed Nov 08, 2010 859 void avfilter_free(AVFilterContext *filter);  Vitor Sessak committed Feb 15, 2008 860   Vitor Sessak committed Feb 15, 2008 861 /**  Måns Rullgård committed Jun 30, 2010 862  * Insert a filter in the middle of an existing link.  Stefano Sabatini committed Aug 20, 2010 863  *  Vitor Sessak committed Feb 15, 2008 864 865  * @param link the link into which the filter should be inserted * @param filt the filter to be inserted  Stefano Sabatini committed Sep 27, 2010 866 867  * @param filt_srcpad_idx the input pad on the filter to connect * @param filt_dstpad_idx the output pad on the filter to connect  Vitor Sessak committed Feb 15, 2008 868  * @return zero on success  Vitor Sessak committed Feb 15, 2008 869  */  Vitor Sessak committed Feb 15, 2008 870 int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,  Stefano Sabatini committed Sep 27, 2010 871  unsigned filt_srcpad_idx, unsigned filt_dstpad_idx);  Vitor Sessak committed Feb 15, 2008 872   Anton Khirnov committed Mar 08, 2013 873 #if FF_API_AVFILTERBUFFER  Stefano Sabatini committed Dec 25, 2011 874 875 876 877 878 879 /** * Copy the frame properties of src to dst, without copying the actual * image data. * * @return 0 on success, a negative number on error. */  Anton Khirnov committed Mar 08, 2013 880 attribute_deprecated  Stefano Sabatini committed Dec 25, 2011 881 882 int avfilter_copy_frame_props(AVFilterBufferRef *dst, const AVFrame *src);  Anton Khirnov committed May 09, 2012 883 884 885 886 887 888 /** * Copy the frame properties and data pointers of src to dst, without copying * the actual data. * * @return 0 on success, a negative number on error. */  Anton Khirnov committed Mar 08, 2013 889 attribute_deprecated  Anton Khirnov committed May 09, 2012 890 int avfilter_copy_buf_props(AVFrame *dst, const AVFilterBufferRef *src);  Anton Khirnov committed Mar 08, 2013 891 #endif  Anton Khirnov committed May 09, 2012 892   Anton Khirnov committed Apr 09, 2013 893 894 895 896 897 898 899 /** * @return AVClass for AVFilterContext. * * @see av_opt_find(). */ const AVClass *avfilter_get_class(void);  Anton Khirnov committed May 24, 2013 900 901 typedef struct AVFilterGraphInternal AVFilterGraphInternal;  Anton Khirnov committed Apr 11, 2013 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 typedef struct AVFilterGraph { const AVClass *av_class; #if FF_API_FOO_COUNT attribute_deprecated unsigned filter_count; #endif AVFilterContext **filters; #if !FF_API_FOO_COUNT unsigned nb_filters; #endif char *scale_sws_opts; ///< sws options to use for the auto-inserted scale filters char *resample_lavr_opts; ///< libavresample options to use for the auto-inserted resample filters #if FF_API_FOO_COUNT unsigned nb_filters; #endif  Anton Khirnov committed May 24, 2013 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943  /** * Type of multithreading allowed for filters in this graph. A combination * of AVFILTER_THREAD_* flags. * * May be set by the caller at any point, the setting will apply to all * filters initialized after that. The default is allowing everything. * * When a filter in this graph is initialized, this field is combined using * bit AND with AVFilterContext.thread_type to get the final mask used for * determining allowed threading types. I.e. a threading type needs to be * set in both to be allowed. */ int thread_type; /** * Maximum number of threads used by filters in this graph. May be set by * the caller before adding any filters to the filtergraph. Zero (the * default) means that the number of threads is determined automatically. */ int nb_threads; /** * Opaque object for libavfilter internal use. */ AVFilterGraphInternal *internal;  Anton Khirnov committed Apr 11, 2013 944 945 946 947 948 949 950 } AVFilterGraph; /** * Allocate a filter graph. */ AVFilterGraph *avfilter_graph_alloc(void);  Anton Khirnov committed Apr 11, 2013 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 /** * Create a new filter instance in a filter graph. * * @param graph graph in which the new filter will be used * @param filter the filter to create an instance of * @param name Name to give to the new instance (will be copied to * AVFilterContext.name). This may be used by the caller to identify * different filters, libavfilter itself assigns no semantics to * this parameter. May be NULL. * * @return the context of the newly created filter instance (note that it is * also retrievable directly through AVFilterGraph.filters or with * avfilter_graph_get_filter()) on success or NULL or failure. */ AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph, const AVFilter *filter, const char *name);  Anton Khirnov committed Apr 11, 2013 969 970 971 972 973 974 975 976 /** * Get a filter instance with name name from graph. * * @return the pointer to the found filter instance or NULL if it * cannot be found. */ AVFilterContext *avfilter_graph_get_filter(AVFilterGraph *graph, char *name);  Anton Khirnov committed Apr 11, 2013 977 #if FF_API_AVFILTER_OPEN  Anton Khirnov committed Apr 11, 2013 978 979 980 981 982 /** * Add an existing filter instance to a filter graph. * * @param graphctx the filter graph * @param filter the filter to be added  Anton Khirnov committed Apr 11, 2013 983 984 985  * * @deprecated use avfilter_graph_alloc_filter() to allocate a filter in a * filter graph  Anton Khirnov committed Apr 11, 2013 986  */  Anton Khirnov committed Apr 11, 2013 987 attribute_deprecated  Anton Khirnov committed Apr 11, 2013 988 int avfilter_graph_add_filter(AVFilterGraph *graphctx, AVFilterContext *filter);  Anton Khirnov committed Apr 11, 2013 989 #endif  Anton Khirnov committed Apr 11, 2013 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105  /** * Create and add a filter instance into an existing graph. * The filter instance is created from the filter filt and inited * with the parameters args and opaque. * * In case of success put in *filt_ctx the pointer to the created * filter instance, otherwise set *filt_ctx to NULL. * * @param name the instance name to give to the created filter instance * @param graph_ctx the filter graph * @return a negative AVERROR error code in case of failure, a non * negative value otherwise */ int avfilter_graph_create_filter(AVFilterContext **filt_ctx, AVFilter *filt, const char *name, const char *args, void *opaque, AVFilterGraph *graph_ctx); /** * Check validity and configure all the links and formats in the graph. * * @param graphctx the filter graph * @param log_ctx context used for logging * @return 0 in case of success, a negative AVERROR code otherwise */ int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx); /** * Free a graph, destroy its links, and set *graph to NULL. * If *graph is NULL, do nothing. */ void avfilter_graph_free(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; /** * Allocate a single AVFilterInOut entry. * Must be freed with avfilter_inout_free(). * @return allocated AVFilterInOut on success, NULL on failure. */ AVFilterInOut *avfilter_inout_alloc(void); /** * Free the supplied list of AVFilterInOut and set *inout to NULL. * If *inout is NULL, do nothing. */ void avfilter_inout_free(AVFilterInOut **inout); /** * Add a graph described by a string to a graph. * * @param graph the filter graph where to link the parsed graph context * @param filters string to be parsed * @param inputs linked list to the inputs of the graph * @param outputs linked list to the outputs of the graph * @return zero on success, a negative AVERROR code on error */ int avfilter_graph_parse(AVFilterGraph *graph, const char *filters, AVFilterInOut *inputs, AVFilterInOut *outputs, void *log_ctx); /** * Add a graph described by a string to a graph. * * @param[in] graph the filter graph where to link the parsed graph context * @param[in] filters string to be parsed * @param[out] inputs a linked list of all free (unlinked) inputs of the * parsed graph will be returned here. It is to be freed * by the caller using avfilter_inout_free(). * @param[out] outputs a linked list of all free (unlinked) outputs of the * parsed graph will be returned here. It is to be freed by the * caller using avfilter_inout_free(). * @return zero on success, a negative AVERROR code on error * * @note the difference between avfilter_graph_parse2() and * avfilter_graph_parse() is that in avfilter_graph_parse(), the caller provides * the lists of inputs and outputs, which therefore must be known before calling * the function. On the other hand, avfilter_graph_parse2() \em returns the * inputs and outputs that are left unlinked after parsing the graph and the * caller then deals with them. Another difference is that in * avfilter_graph_parse(), the inputs parameter describes inputs of the * already existing part of the graph; i.e. from the point of view of * the newly created part, they are outputs. Similarly the outputs parameter * describes outputs of the already existing filters, which are provided as * inputs to the parsed filters. * avfilter_graph_parse2() takes the opposite approach -- it makes no reference * whatsoever to already existing parts of the graph and the inputs parameter * will on return contain inputs of the newly parsed part of the graph. * Analogously the outputs parameter will contain outputs of the newly created * filters. */ int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters, AVFilterInOut **inputs, AVFilterInOut **outputs);  Anton Khirnov committed May 17, 2013 1106 1107 1108 1109 /** * @} */  Diego Biurrun committed May 21, 2011 1110 #endif /* AVFILTER_AVFILTER_H */