avfilter.h 41.5 KB
Newer Older
Vitor Sessak's avatar
Vitor Sessak committed
1
/*
2
 * filter layer
3
 * Copyright (c) 2007 Bobby Bingham
Vitor Sessak's avatar
Vitor Sessak committed
4
 *
5
 * This file is part of Libav.
Vitor Sessak's avatar
Vitor Sessak committed
6
 *
7
 * Libav is free software; you can redistribute it and/or
Vitor Sessak's avatar
Vitor Sessak committed
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.
 *
12
 * Libav is distributed in the hope that it will be useful,
Vitor Sessak's avatar
Vitor Sessak committed
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
18
 * License along with Libav; if not, write to the Free Software
Vitor Sessak's avatar
Vitor Sessak committed
19 20 21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

22 23
#ifndef AVFILTER_AVFILTER_H
#define AVFILTER_AVFILTER_H
Vitor Sessak's avatar
Vitor Sessak committed
24

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
 * @{
 */

36
#include "libavutil/attributes.h"
37
#include "libavutil/avutil.h"
38
#include "libavutil/frame.h"
39
#include "libavutil/log.h"
40
#include "libavutil/samplefmt.h"
41
#include "libavutil/pixfmt.h"
42
#include "libavutil/rational.h"
43
#include "libavcodec/avcodec.h"
44

45
#include <stddef.h>
Vitor Sessak's avatar
Vitor Sessak committed
46

47 48
#include "libavfilter/version.h"

49
/**
50
 * Return the LIBAVFILTER_VERSION_INT constant.
51 52 53
 */
unsigned avfilter_version(void);

54
/**
55
 * Return the libavfilter build-time configuration.
56
 */
57
const char *avfilter_configuration(void);
58 59

/**
60
 * Return the libavfilter license.
61
 */
62
const char *avfilter_license(void);
63 64


Vitor Sessak's avatar
Vitor Sessak committed
65 66 67
typedef struct AVFilterContext AVFilterContext;
typedef struct AVFilterLink    AVFilterLink;
typedef struct AVFilterPad     AVFilterPad;
68
typedef struct AVFilterFormats AVFilterFormats;
Vitor Sessak's avatar
Vitor Sessak committed
69

70
#if FF_API_AVFILTERBUFFER
Vitor Sessak's avatar
Vitor Sessak committed
71
/**
72
 * A reference-counted buffer data type used by the filter system. Filters
Vitor Sessak's avatar
Vitor Sessak committed
73
 * should not store pointers to this structure directly, but instead use the
74
 * AVFilterBufferRef structure below.
Vitor Sessak's avatar
Vitor Sessak committed
75
 */
76
typedef struct AVFilterBuffer {
77
    uint8_t *data[8];           ///< buffer data for each plane/channel
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;
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
109
} AVFilterBuffer;
Vitor Sessak's avatar
Vitor Sessak committed
110

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
116
#define AV_PERM_NEG_LINESIZES 0x20  ///< the buffer requested can have negative linesizes
117

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 {
124
    uint64_t channel_layout;    ///< channel layout of audio buffer
125
    int nb_samples;             ///< number of audio samples
126
    int sample_rate;            ///< audio buffer sample rate
127 128 129
    int planar;                 ///< audio buffer - planar or packed
} AVFilterBufferRefAudioProps;

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.
 */
135
typedef struct AVFilterBufferRefVideoProps {
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
141
    enum AVPictureType pict_type; ///< picture type of the frame
142
    int key_frame;              ///< 1 -> keyframe, 0-> not
143 144
} AVFilterBufferRefVideoProps;

Vitor Sessak's avatar
Vitor Sessak committed
145
/**
146
 * A reference to an AVFilterBuffer. Since filters can manipulate the origin of
147
 * a buffer to, for example, crop image without any memcpy, the buffer origin
148
 * and dimensions are per-reference properties. Linesize is also useful for
149
 * image flipping, frame to field filters, etc, and so is also per-reference.
Vitor Sessak's avatar
Vitor Sessak committed
150
 *
151
 * TODO: add anything necessary for frame reordering
Vitor Sessak's avatar
Vitor Sessak committed
152
 */
153
typedef struct AVFilterBufferRef {
154
    AVFilterBuffer *buf;        ///< the buffer that this is a reference to
155
    uint8_t *data[8];           ///< picture/audio data for each plane
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;
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
189
} AVFilterBufferRef;
Vitor Sessak's avatar
Vitor Sessak committed
190

191
/**
192
 * Copy properties of src to dst, without copying the actual data
193
 */
194
attribute_deprecated
195
void avfilter_copy_buffer_ref_props(AVFilterBufferRef *dst, AVFilterBufferRef *src);
196

Vitor Sessak's avatar
Vitor Sessak committed
197
/**
198
 * Add a new reference to a buffer.
199
 *
200
 * @param ref   an existing reference to the buffer
201
 * @param pmask a bitmask containing the allowable permissions in the new
202
 *              reference
203
 * @return      a new reference to the buffer with the same properties as the
204
 *              old, excluding any permissions denied by pmask
Vitor Sessak's avatar
Vitor Sessak committed
205
 */
206
attribute_deprecated
207
AVFilterBufferRef *avfilter_ref_buffer(AVFilterBufferRef *ref, int pmask);
Vitor Sessak's avatar
Vitor Sessak committed
208 209

/**
210 211
 * Remove a reference to a buffer. If this is the last reference to the
 * buffer, the buffer itself is also automatically freed.
212
 *
213
 * @param ref reference to the buffer, may be NULL
214 215 216
 *
 * @note it is recommended to use avfilter_unref_bufferp() instead of this
 * function
Vitor Sessak's avatar
Vitor Sessak committed
217
 */
218
attribute_deprecated
219
void avfilter_unref_buffer(AVFilterBufferRef *ref);
Vitor Sessak's avatar
Vitor Sessak committed
220

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
 */
228
attribute_deprecated
229
void avfilter_unref_bufferp(AVFilterBufferRef **ref);
230
#endif
231

232
#if FF_API_AVFILTERPAD_PUBLIC
233
/**
234
 * A filter pad used for either input or output.
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.
240
 */
241
struct AVFilterPad {
Vitor Sessak's avatar
Vitor Sessak committed
242
    /**
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
245
     * pad has no need to ever be referenced by name.
Vitor Sessak's avatar
Vitor Sessak committed
246
     */
247
    const char *name;
Vitor Sessak's avatar
Vitor Sessak committed
248 249

    /**
250
     * AVFilterPad type.
Vitor Sessak's avatar
Vitor Sessak committed
251
     */
252
    enum AVMediaType type;
Vitor Sessak's avatar
Vitor Sessak committed
253

254
    /**
255
     * Minimum required permissions on incoming buffers. Any buffer with
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.
     */
261
    attribute_deprecated int min_perms;
262 263

    /**
264
     * Permissions which are not accepted on incoming buffers. Any buffer
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
267
     * permissions. This can be used to easily disallow buffers with
268
     * AV_PERM_REUSE.
269 270 271
     *
     * Input pads only.
     */
272
    attribute_deprecated int rej_perms;
273

Vitor Sessak's avatar
Vitor Sessak committed
274
    /**
275
     * @deprecated unused
Vitor Sessak's avatar
Vitor Sessak committed
276
     */
277
    int (*start_frame)(AVFilterLink *link, AVFilterBufferRef *picref);
Vitor Sessak's avatar
Vitor Sessak committed
278 279

    /**
280
     * Callback function to get a video buffer. If NULL, the filter system will
281
     * use avfilter_default_get_video_buffer().
282 283
     *
     * Input video pads only.
Vitor Sessak's avatar
Vitor Sessak committed
284
     */
285
    AVFrame *(*get_video_buffer)(AVFilterLink *link, int w, int h);
Vitor Sessak's avatar
Vitor Sessak committed
286

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.
     */
293
    AVFrame *(*get_audio_buffer)(AVFilterLink *link, int nb_samples);
294

Vitor Sessak's avatar
Vitor Sessak committed
295
    /**
296
     * @deprecated unused
Vitor Sessak's avatar
Vitor Sessak committed
297
     */
298
    int (*end_frame)(AVFilterLink *link);
Vitor Sessak's avatar
Vitor Sessak committed
299 300

    /**
301
     * @deprecated unused
Vitor Sessak's avatar
Vitor Sessak committed
302
     */
303
    int (*draw_slice)(AVFilterLink *link, int y, int height, int slice_dir);
Vitor Sessak's avatar
Vitor Sessak committed
304

305
    /**
306 307
     * Filtering callback. This is where a filter receives a frame with
     * audio/video data and should do its processing.
308
     *
309
     * Input pads only.
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.
314
     */
315
    int (*filter_frame)(AVFilterLink *link, AVFrame *frame);
316

317
    /**
318
     * Frame poll callback. This returns the number of immediately available
319
     * samples. It should return a positive value if the next request_frame()
320 321 322 323
     * is guaranteed to return one frame (with no delay).
     *
     * Defaults to just calling the source poll_frame() method.
     *
324
     * Output pads only.
325 326 327
     */
    int (*poll_frame)(AVFilterLink *link);

Vitor Sessak's avatar
Vitor Sessak committed
328
    /**
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
331 332
     * success, and another value on error.
     *
333
     * Output pads only.
Vitor Sessak's avatar
Vitor Sessak committed
334
     */
335
    int (*request_frame)(AVFilterLink *link);
Vitor Sessak's avatar
Vitor Sessak committed
336 337

    /**
338 339 340
     * Link configuration callback.
     *
     * For output pads, this should set the link properties such as
341
     * width/height. This should NOT set the format property - that is
342 343
     * negotiated between filters by the filter system using the
     * query_formats() callback before this function is called.
344 345 346
     *
     * For input pads, this should check the properties of the link, and update
     * the filter's internal state as necessary.
347 348 349
     *
     * For both input and output filters, this should return zero on success,
     * and another value on error.
Vitor Sessak's avatar
Vitor Sessak committed
350
     */
351
    int (*config_props)(AVFilterLink *link);
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;
360

361 362 363 364 365 366
    /**
     * The filter expects writable frames from its input link,
     * duplicating data buffers if needed.
     *
     * input pads only.
     */
367
    int needs_writable;
Vitor Sessak's avatar
Vitor Sessak committed
368
};
369
#endif
Vitor Sessak's avatar
Vitor Sessak committed
370

371 372 373 374 375 376
/**
 * Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
 * AVFilter.inputs/outputs).
 */
int avfilter_pad_count(const AVFilterPad *pads);

377 378 379 380 381 382 383 384 385
/**
 * 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
 */
386
const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx);
387 388 389 390 391 392 393 394 395 396

/**
 * 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
 */
397
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx);
398

399 400 401 402 403 404 405 406 407 408 409 410
/**
 * 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)
411 412 413 414 415
/**
 * The filter supports multithreading by splitting frames into multiple parts
 * and processing them concurrently.
 */
#define AVFILTER_FLAG_SLICE_THREADS         (1 << 2)
416

417
/**
418
 * Filter definition. This defines the pads a filter contains, and all the
419 420
 * callback functions used to interact with the filter.
 */
421
typedef struct AVFilter {
422 423 424 425
    /**
     * Filter name. Must be non-NULL and unique among filters.
     */
    const char *name;
Vitor Sessak's avatar
Vitor Sessak committed
426

427
    /**
428 429 430
     * A description of the filter. May be NULL.
     *
     * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
431 432 433
     */
    const char *description;

434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
    /**
     * 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;
450

451
    /**
452 453 454 455 456 457
     * 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.
458 459 460
     */
    const AVClass *priv_class;

461 462 463 464 465
    /**
     * A combination of AVFILTER_FLAG_*
     */
    int flags;

466 467 468 469 470 471 472
    /*****************************************************************
     * 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's avatar
Vitor Sessak committed
473

474
    /**
475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
     * 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
494
     */
495
    int (*init)(AVFilterContext *ctx);
496

497
    /**
498 499 500 501 502 503 504 505 506
     * 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".
507 508 509
     */
    int (*init_dict)(AVFilterContext *ctx, AVDictionary **options);

510
    /**
511 512 513 514 515 516 517 518
     * 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.
519
     */
Vitor Sessak's avatar
Vitor Sessak committed
520 521
    void (*uninit)(AVFilterContext *ctx);

522
    /**
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
     * 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.
540
     *
541 542
     * @return zero on success, a negative value corresponding to an
     * AVERROR code otherwise
543 544 545
     */
    int (*query_formats)(AVFilterContext *);

546
    int priv_size;      ///< size of private data to allocate for the filter
547

548 549 550 551
    /**
     * Used by the filter registration system. Must not be touched by any other
     * code.
     */
552
    struct AVFilter *next;
Vitor Sessak's avatar
Vitor Sessak committed
553 554
} AVFilter;

555 556 557 558 559 560 561
/**
 * Process multiple parts of the frame concurrently.
 */
#define AVFILTER_THREAD_SLICE (1 << 0)

typedef struct AVFilterInternal AVFilterInternal;

562
/** An instance of a filter */
563
struct AVFilterContext {
564
    const AVClass *av_class;              ///< needed for av_log()
Vitor Sessak's avatar
Vitor Sessak committed
565

566
    const AVFilter *filter;         ///< the AVFilter of which this is an instance
Vitor Sessak's avatar
Vitor Sessak committed
567

568
    char *name;                     ///< name of this filter instance
569

570 571
    AVFilterPad   *input_pads;      ///< array of input pads
    AVFilterLink **inputs;          ///< array of pointers to input links
572
#if FF_API_FOO_COUNT
573
    attribute_deprecated unsigned input_count; ///< @deprecated use nb_inputs
574
#endif
575
    unsigned    nb_inputs;          ///< number of input pads
576

577 578
    AVFilterPad   *output_pads;     ///< array of output pads
    AVFilterLink **outputs;         ///< array of pointers to output links
579
#if FF_API_FOO_COUNT
580
    attribute_deprecated unsigned output_count; ///< @deprecated use nb_outputs
581
#endif
582
    unsigned    nb_outputs;         ///< number of output pads
Vitor Sessak's avatar
Vitor Sessak committed
583

584
    void *priv;                     ///< private data for use by the filter
585 586

    struct AVFilterGraph *graph;    ///< filtergraph this filter belongs to
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609

    /**
     * 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's avatar
Vitor Sessak committed
610 611
};

612
/**
613
 * A link between two filters. This contains pointers to the source and
614
 * destination filters between which this link exists, and the indexes of
615
 * the pads involved. In addition, this link also contains the parameters
616
 * which have been negotiated and agreed upon between the filter, such as
617
 * image dimensions, format, etc.
618
 */
619
struct AVFilterLink {
620
    AVFilterContext *src;       ///< source filter
621
    AVFilterPad *srcpad;        ///< output pad on the source filter
Vitor Sessak's avatar
Vitor Sessak committed
622

623
    AVFilterContext *dst;       ///< dest filter
624
    AVFilterPad *dstpad;        ///< input pad on the dest filter
Vitor Sessak's avatar
Vitor Sessak committed
625

626 627
    enum AVMediaType type;      ///< filter media type

628
    /* These parameters apply only to video */
629 630
    int w;                      ///< agreed upon image width
    int h;                      ///< agreed upon image height
631
    AVRational sample_aspect_ratio; ///< agreed upon sample aspect ratio
632
    /* These two parameters apply only to audio */
633
    uint64_t channel_layout;    ///< channel layout of current buffer (see libavutil/channel_layout.h)
634
    int sample_rate;            ///< samples per second
635

636
    int format;                 ///< agreed upon media format
Vitor Sessak's avatar
Vitor Sessak committed
637

638 639 640 641 642 643 644 645
    /**
     * 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;
646 647 648 649 650 651 652 653

    /*****************************************************************
     * 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.
     *****************************************************************
     */
654 655 656 657 658 659 660 661
    /**
     * 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;

662 663 664 665 666 667 668 669
    /**
     * 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;
670 671 672 673 674 675 676 677 678

    /**
     * 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;
679 680 681 682 683 684 685

    /** 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's avatar
Vitor Sessak committed
686 687
};

688
/**
689
 * Link two filters together.
690
 *
691 692 693 694 695
 * @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
696
 */
Vitor Sessak's avatar
Vitor Sessak committed
697 698 699
int avfilter_link(AVFilterContext *src, unsigned srcpad,
                  AVFilterContext *dst, unsigned dstpad);

700
/**
701
 * Negotiate the media format, dimensions, etc of all inputs to a filter.
702
 *
703 704
 * @param filter the filter to negotiate the properties for its inputs
 * @return       zero on successful negotiation
705
 */
706
int avfilter_config_links(AVFilterContext *filter);
707

708
#if FF_API_AVFILTERBUFFER
709 710 711 712 713 714 715 716 717 718 719
/**
 * 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
 */
720
attribute_deprecated
721 722
AVFilterBufferRef *
avfilter_get_video_buffer_ref_from_arrays(uint8_t *data[4], int linesize[4], int perms,
723
                                          int w, int h, enum AVPixelFormat format);
724

725 726 727 728 729 730 731 732 733 734 735
/**
 * 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
 */
736
attribute_deprecated
737 738 739 740 741 742
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);
743
#endif
744

745
/** Initialize the filter system. Register all builtin filters. */
Vitor Sessak's avatar
Vitor Sessak committed
746
void avfilter_register_all(void);
747

748
#if FF_API_OLD_FILTER_REGISTER
749
/** Uninitialize the filter system. Unregister all filters. */
750
attribute_deprecated
Vitor Sessak's avatar
Vitor Sessak committed
751
void avfilter_uninit(void);
752
#endif
753 754

/**
755
 * Register a filter. This is only needed if you plan to use
756
 * avfilter_get_by_name later to lookup the AVFilter structure by name. A
757 758
 * filter can still by instantiated with avfilter_graph_alloc_filter even if it
 * is not registered.
759
 *
760
 * @param filter the filter to register
761 762
 * @return 0 if the registration was succesfull, a negative value
 * otherwise
763
 */
764
int avfilter_register(AVFilter *filter);
765 766

/**
767
 * Get a filter definition matching the given name.
768
 *
769 770
 * @param name the filter name to find
 * @return     the filter definition, if any matching one is registered.
771 772
 *             NULL if none found.
 */
773 774 775
#if !FF_API_NOCONST_GET_NAME
const
#endif
776
AVFilter *avfilter_get_by_name(const char *name);
Vitor Sessak's avatar
Vitor Sessak committed
777

778 779 780 781 782 783 784 785
/**
 * 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
786 787 788 789 790
/**
 * 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.
791
 * @deprecated use avfilter_next()
792
 */
793
attribute_deprecated
794
AVFilter **av_filter_next(AVFilter **filter);
795
#endif
796

797
#if FF_API_AVFILTER_OPEN
798
/**
799
 * Create a filter instance.
800 801 802
 *
 * @param filter_ctx put here a pointer to the created filter context
 * on success, NULL on failure
803
 * @param filter    the filter to create an instance of
804
 * @param inst_name Name to give to the new instance. Can be NULL for none.
805
 * @return >= 0 in case of success, a negative error code otherwise
806
 * @deprecated use avfilter_graph_alloc_filter() instead
807
 */
808
attribute_deprecated
809
int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name);
810
#endif
811

812 813

#if FF_API_AVFILTER_INIT_FILTER
814
/**
815
 * Initialize a filter.
816
 *
817
 * @param filter the filter to initialize
818 819
 * @param args   A string of parameters to use when initializing the filter.
 *               The format and meaning of this string varies by filter.
820
 * @param opaque Any extra non-string data needed by the filter. The meaning
821
 *               of this parameter varies by filter.
822
 * @return       zero on success
823
 */
824
attribute_deprecated
825
int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque);
826 827 828 829 830 831 832 833 834 835 836 837 838
#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);
839

840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861
/**
 * 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);

862
/**
863 864
 * Free a filter context. This will also remove the filter from its
 * filtergraph's list of filters.
865
 *
866
 * @param filter the filter to free
867
 */
868
void avfilter_free(AVFilterContext *filter);
Vitor Sessak's avatar
Vitor Sessak committed
869

870
/**
871
 * Insert a filter in the middle of an existing link.
872
 *
873 874
 * @param link the link into which the filter should be inserted
 * @param filt the filter to be inserted
875 876
 * @param filt_srcpad_idx the input pad on the filter to connect
 * @param filt_dstpad_idx the output pad on the filter to connect
877
 * @return     zero on success
878
 */
879
int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
880
                           unsigned filt_srcpad_idx, unsigned filt_dstpad_idx);
881

882
#if FF_API_AVFILTERBUFFER
883 884 885 886 887 888
/**
 * Copy the frame properties of src to dst, without copying the actual
 * image data.
 *
 * @return 0 on success, a negative number on error.
 */
889
attribute_deprecated
890 891
int avfilter_copy_frame_props(AVFilterBufferRef *dst, const AVFrame *src);

892 893 894 895 896 897
/**
 * 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.
 */
898
attribute_deprecated
899
int avfilter_copy_buf_props(AVFrame *dst, const AVFilterBufferRef *src);
900
#endif
901

902 903 904 905 906 907 908
/**
 * @return AVClass for AVFilterContext.
 *
 * @see av_opt_find().
 */
const AVClass *avfilter_get_class(void);

909 910
typedef struct AVFilterGraphInternal AVFilterGraphInternal;

911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939
/**
 * A function pointer passed to the @ref AVFilterGraph.execute callback to be
 * executed multiple times, possibly in parallel.
 *
 * @param ctx the filter context the job belongs to
 * @param arg an opaque parameter passed through from @ref
 *            AVFilterGraph.execute
 * @param jobnr the index of the job being executed
 * @param nb_jobs the total number of jobs
 *
 * @return 0 on success, a negative AVERROR on error
 */
typedef int (avfilter_action_func)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);

/**
 * A function executing multiple jobs, possibly in parallel.
 *
 * @param ctx the filter context to which the jobs belong
 * @param func the function to be called multiple times
 * @param arg the argument to be passed to func
 * @param ret a nb_jobs-sized array to be filled with return values from each
 *            invocation of func
 * @param nb_jobs the number of jobs to execute
 *
 * @return 0 on success, a negative AVERROR on error
 */
typedef int (avfilter_execute_func)(AVFilterContext *ctx, avfilter_action_func *func,
                                    void *arg, int *ret, int nb_jobs);

940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955
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
956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981

    /**
     * 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;
982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002

    /**
     * Opaque user data. May be set by the caller to an arbitrary value, e.g. to
     * be used from callbacks like @ref AVFilterGraph.execute.
     * Libavfilter will not touch this field in any way.
     */
    void *opaque;

    /**
     * This callback may be set by the caller immediately after allocating the
     * graph and before adding any filters to it, to provide a custom
     * multithreading implementation.
     *
     * If set, filters with slice threading capability will call this callback
     * to execute multiple jobs in parallel.
     *
     * If this field is left unset, libavfilter will use its internal
     * implementation, which may or may not be multithreaded depending on the
     * platform and build options.
     */
    avfilter_execute_func *execute;
1003 1004 1005 1006 1007 1008 1009
} AVFilterGraph;

/**
 * Allocate a filter graph.
 */
AVFilterGraph *avfilter_graph_alloc(void);

1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
/**
 * 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);

1028 1029 1030 1031 1032 1033 1034 1035
/**
 * 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);

1036
#if FF_API_AVFILTER_OPEN
1037 1038 1039 1040 1041
/**
 * Add an existing filter instance to a filter graph.
 *
 * @param graphctx  the filter graph
 * @param filter the filter to be added
1042 1043 1044
 *
 * @deprecated use avfilter_graph_alloc_filter() to allocate a filter in a
 * filter graph
1045
 */
1046
attribute_deprecated
1047
int avfilter_graph_add_filter(AVFilterGraph *graphctx, AVFilterContext *filter);
1048
#endif
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062

/**
 * 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
 */
1063
int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt,
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 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
                                 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
 * <em>already existing</em> 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);

1165 1166 1167 1168
/**
 * @}
 */

1169
#endif /* AVFILTER_AVFILTER_H */