avfilter.h 39.4 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

    int needs_writable;
Vitor Sessak's avatar
Vitor Sessak committed
362
};
363
#endif
Vitor Sessak's avatar
Vitor Sessak committed
364

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

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
 */
380
const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx);
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
 */
391
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx);
392

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)
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)
410

411
/**
412
 * Filter definition. This defines the pads a filter contains, and all the
413 414
 * callback functions used to interact with the filter.
 */
415
typedef struct AVFilter {
416 417 418 419
    /**
     * Filter name. Must be non-NULL and unique among filters.
     */
    const char *name;
Vitor Sessak's avatar
Vitor Sessak committed
420

421
    /**
422 423 424
     * A description of the filter. May be NULL.
     *
     * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
425 426 427
     */
    const char *description;

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;
444

445
    /**
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.
452 453 454
     */
    const AVClass *priv_class;

455 456 457 458 459
    /**
     * A combination of AVFILTER_FLAG_*
     */
    int flags;

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's avatar
Vitor Sessak committed
467

468
    /**
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
488
     */
489
    int (*init)(AVFilterContext *ctx);
490

491
    /**
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".
501 502 503
     */
    int (*init_dict)(AVFilterContext *ctx, AVDictionary **options);

504
    /**
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.
513
     */
Vitor Sessak's avatar
Vitor Sessak committed
514 515
    void (*uninit)(AVFilterContext *ctx);

516
    /**
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.
534
     *
535 536
     * @return zero on success, a negative value corresponding to an
     * AVERROR code otherwise
537 538 539
     */
    int (*query_formats)(AVFilterContext *);

540
    int priv_size;      ///< size of private data to allocate for the filter
541

542 543 544 545
    /**
     * Used by the filter registration system. Must not be touched by any other
     * code.
     */
546
    struct AVFilter *next;
Vitor Sessak's avatar
Vitor Sessak committed
547 548
} AVFilter;

549 550 551 552 553 554 555
/**
 * Process multiple parts of the frame concurrently.
 */
#define AVFILTER_THREAD_SLICE (1 << 0)

typedef struct AVFilterInternal AVFilterInternal;

556
/** An instance of a filter */
557
struct AVFilterContext {
558
    const AVClass *av_class;              ///< needed for av_log()
Vitor Sessak's avatar
Vitor Sessak committed
559

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

562
    char *name;                     ///< name of this filter instance
563

564 565
    AVFilterPad   *input_pads;      ///< array of input pads
    AVFilterLink **inputs;          ///< array of pointers to input links
566
#if FF_API_FOO_COUNT
567
    attribute_deprecated unsigned input_count; ///< @deprecated use nb_inputs
568
#endif
569
    unsigned    nb_inputs;          ///< number of input pads
570

571 572
    AVFilterPad   *output_pads;     ///< array of output pads
    AVFilterLink **outputs;         ///< array of pointers to output links
573
#if FF_API_FOO_COUNT
574
    attribute_deprecated unsigned output_count; ///< @deprecated use nb_outputs
575
#endif
576
    unsigned    nb_outputs;         ///< number of output pads
Vitor Sessak's avatar
Vitor Sessak committed
577

578
    void *priv;                     ///< private data for use by the filter
579 580

    struct AVFilterGraph *graph;    ///< filtergraph this filter belongs to
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's avatar
Vitor Sessak committed
604 605
};

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

617
    AVFilterContext *dst;       ///< dest filter
618
    AVFilterPad *dstpad;        ///< input pad on the dest filter
Vitor Sessak's avatar
Vitor Sessak committed
619

620 621
    enum AVMediaType type;      ///< filter media type

622
    /* These parameters apply only to video */
623 624
    int w;                      ///< agreed upon image width
    int h;                      ///< agreed upon image height
625
    AVRational sample_aspect_ratio; ///< agreed upon sample aspect ratio
626
    /* These two parameters apply only to audio */
627
    uint64_t channel_layout;    ///< channel layout of current buffer (see libavutil/channel_layout.h)
628
    int sample_rate;            ///< samples per second
629

630
    int format;                 ///< agreed upon media format
Vitor Sessak's avatar
Vitor Sessak committed
631

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;
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.
     *****************************************************************
     */
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;

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;
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;
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's avatar
Vitor Sessak committed
680 681
};

682
/**
683
 * Link two filters together.
684
 *
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
690
 */
Vitor Sessak's avatar
Vitor Sessak committed
691 692 693
int avfilter_link(AVFilterContext *src, unsigned srcpad,
                  AVFilterContext *dst, unsigned dstpad);

694
/**
695
 * Negotiate the media format, dimensions, etc of all inputs to a filter.
696
 *
697 698
 * @param filter the filter to negotiate the properties for its inputs
 * @return       zero on successful negotiation
699
 */
700
int avfilter_config_links(AVFilterContext *filter);
701

702
#if FF_API_AVFILTERBUFFER
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
 */
714
attribute_deprecated
715 716
AVFilterBufferRef *
avfilter_get_video_buffer_ref_from_arrays(uint8_t *data[4], int linesize[4], int perms,
717
                                          int w, int h, enum AVPixelFormat format);
718

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
 */
730
attribute_deprecated
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);
737
#endif
738

739
/** Initialize the filter system. Register all builtin filters. */
Vitor Sessak's avatar
Vitor Sessak committed
740
void avfilter_register_all(void);
741

742
#if FF_API_OLD_FILTER_REGISTER
743
/** Uninitialize the filter system. Unregister all filters. */
744
attribute_deprecated
Vitor Sessak's avatar
Vitor Sessak committed
745
void avfilter_uninit(void);
746
#endif
747 748

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

/**
761
 * Get a filter definition matching the given name.
762
 *
763 764
 * @param name the filter name to find
 * @return     the filter definition, if any matching one is registered.
765 766
 *             NULL if none found.
 */
767
AVFilter *avfilter_get_by_name(const char *name);
Vitor Sessak's avatar
Vitor Sessak committed
768

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
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.
782
 * @deprecated use avfilter_next()
783
 */
784
attribute_deprecated
785
AVFilter **av_filter_next(AVFilter **filter);
786
#endif
787

788
#if FF_API_AVFILTER_OPEN
789
/**
790
 * Create a filter instance.
791 792 793
 *
 * @param filter_ctx put here a pointer to the created filter context
 * on success, NULL on failure
794
 * @param filter    the filter to create an instance of
795
 * @param inst_name Name to give to the new instance. Can be NULL for none.
796
 * @return >= 0 in case of success, a negative error code otherwise
797
 * @deprecated use avfilter_graph_alloc_filter() instead
798
 */
799
attribute_deprecated
800
int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name);
801
#endif
802

803 804

#if FF_API_AVFILTER_INIT_FILTER
805
/**
806
 * Initialize a filter.
807
 *
808
 * @param filter the filter to initialize
809 810
 * @param args   A string of parameters to use when initializing the filter.
 *               The format and meaning of this string varies by filter.
811
 * @param opaque Any extra non-string data needed by the filter. The meaning
812
 *               of this parameter varies by filter.
813
 * @return       zero on success
814
 */
815
attribute_deprecated
816
int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque);
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);
830

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

853
/**
854 855
 * Free a filter context. This will also remove the filter from its
 * filtergraph's list of filters.
856
 *
857
 * @param filter the filter to free
858
 */
859
void avfilter_free(AVFilterContext *filter);
Vitor Sessak's avatar
Vitor Sessak committed
860

861
/**
862
 * Insert a filter in the middle of an existing link.
863
 *
864 865
 * @param link the link into which the filter should be inserted
 * @param filt the filter to be inserted
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
868
 * @return     zero on success
869
 */
870
int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
871
                           unsigned filt_srcpad_idx, unsigned filt_dstpad_idx);
872

873
#if FF_API_AVFILTERBUFFER
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.
 */
880
attribute_deprecated
881 882
int avfilter_copy_frame_props(AVFilterBufferRef *dst, const AVFrame *src);

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.
 */
889
attribute_deprecated
890
int avfilter_copy_buf_props(AVFrame *dst, const AVFilterBufferRef *src);
891
#endif
892

893 894 895 896 897 898 899
/**
 * @return AVClass for AVFilterContext.
 *
 * @see av_opt_find().
 */
const AVClass *avfilter_get_class(void);

900 901
typedef struct AVFilterGraphInternal AVFilterGraphInternal;

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
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;
944 945 946 947 948 949 950
} AVFilterGraph;

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

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

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

977
#if FF_API_AVFILTER_OPEN
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
983 984 985
 *
 * @deprecated use avfilter_graph_alloc_filter() to allocate a filter in a
 * filter graph
986
 */
987
attribute_deprecated
988
int avfilter_graph_add_filter(AVFilterGraph *graphctx, AVFilterContext *filter);
989
#endif
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
 * <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);

1106 1107 1108 1109
/**
 * @}
 */

1110
#endif /* AVFILTER_AVFILTER_H */