avfilter (JavaCPP Presets for FFmpeg 5.0-1.5.7 API)

java.lang.Object
- org.bytedeco.ffmpeg.presets.avfilter
- - org.bytedeco.ffmpeg.global.avfilter

All Implemented Interfaces:

InfoMapper
```
public class avfilter
extends avfilter
```

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`AV_BUFFERSINK_FLAG_NO_REQUEST` Tell av_buffersink_get_buffer_ref() not to request a frame from its input.
`static int`	`AV_BUFFERSINK_FLAG_PEEK` Tell av_buffersink_get_buffer_ref() to read video/samples buffer reference, but not remove it from the buffer.
`static int`	`AV_BUFFERSRC_FLAG_KEEP_REF` enum
`static int`	`AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT` enum
`static int`	`AV_BUFFERSRC_FLAG_PUSH` enum
`static int`	`AVFILTER_AUTO_CONVERT_ALL` enum
`static int`	`AVFILTER_AUTO_CONVERT_NONE` enum
`static int`	`AVFILTER_CMD_FLAG_FAST` Only execute command when its fast (like a video out that supports contrast adjustment in hw)
`static int`	`AVFILTER_CMD_FLAG_ONE` Stop once a filter understood the command (for target=all for example), fast filters are favored automatically
`static int`	`AVFILTER_FLAG_DYNAMIC_INPUTS` The number of the filter inputs is not determined just by AVFilter.inputs.
`static int`	`AVFILTER_FLAG_DYNAMIC_OUTPUTS` The number of the filter outputs is not determined just by AVFilter.outputs.
`static int`	`AVFILTER_FLAG_METADATA_ONLY` The filter is a "metadata" filter - it does not modify the frame data in any way.
`static int`	`AVFILTER_FLAG_SLICE_THREADS` The filter supports multithreading by splitting frames into multiple parts and processing them concurrently.
`static int`	`AVFILTER_FLAG_SUPPORT_TIMELINE` Handy mask to test whether the filter supports or no the timeline feature (internally or generically).
`static int`	`AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC` Some filters support a generic "enable" expression option that can be used to enable or disable a filter in the timeline.
`static int`	`AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL` Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() callback(s) called as usual even when the enable expression is false.
`static int`	`AVFILTER_THREAD_SLICE` Process multiple parts of the frame concurrently.
`static boolean`	`FF_API_BUFFERSINK_ALLOC`
`static boolean`	`FF_API_PAD_COUNT`
`static boolean`	`FF_API_SWS_PARAM_OPTION` FF_API_* defines may be placed below to indicate public API that will be dropped at a future version bump.
`static int`	`LIBAVFILTER_BUILD`
`static String`	`LIBAVFILTER_IDENT`
`static int`	`LIBAVFILTER_VERSION_INT`
`static int`	`LIBAVFILTER_VERSION_MAJOR` \file \ingroup lavfi Libavfilter version macros
`static int`	`LIBAVFILTER_VERSION_MICRO`
`static int`	`LIBAVFILTER_VERSION_MINOR`

Constructor Summary

Constructors
Constructor and Description

avfilter()

Constructors
Constructor and Description
`avfilter()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static AVABufferSinkParams`	`av_abuffersink_params_alloc()` Deprecated.
`static long`	`av_buffersink_get_channel_layout(AVFilterContext ctx)`
`static int`	`av_buffersink_get_channels(AVFilterContext ctx)`
`static int`	`av_buffersink_get_format(AVFilterContext ctx)`
`static int`	`av_buffersink_get_frame_flags(AVFilterContext ctx, AVFrame frame, int flags)` Get a frame with filtered data from sink and put it in frame.
`static AVRational`	`av_buffersink_get_frame_rate(AVFilterContext ctx)`
`static int`	`av_buffersink_get_frame(AVFilterContext ctx, AVFrame frame)` Get a frame with filtered data from sink and put it in frame.
`static int`	`av_buffersink_get_h(AVFilterContext ctx)`
`static AVBufferRef`	`av_buffersink_get_hw_frames_ctx(AVFilterContext ctx)`
`static AVRational`	`av_buffersink_get_sample_aspect_ratio(AVFilterContext ctx)`
`static int`	`av_buffersink_get_sample_rate(AVFilterContext ctx)`
`static int`	`av_buffersink_get_samples(AVFilterContext ctx, AVFrame frame, int nb_samples)` Same as av_buffersink_get_frame(), but with the ability to specify the number of samples read.
`static AVRational`	`av_buffersink_get_time_base(AVFilterContext ctx)`
`static int`	`av_buffersink_get_type(AVFilterContext ctx)` \defgroup lavfi_buffersink_accessors Buffer sink accessors Get the properties of the stream \{
`static int`	`av_buffersink_get_w(AVFilterContext ctx)`
`static AVBufferSinkParams`	`av_buffersink_params_alloc()` Deprecated.
`static void`	`av_buffersink_set_frame_size(AVFilterContext ctx, int frame_size)` Set the frame size for an audio buffer sink.
`static int`	`av_buffersrc_add_frame_flags(AVFilterContext buffer_src, AVFrame frame, int flags)` Add a frame to the buffer source.
`static int`	`av_buffersrc_add_frame(AVFilterContext ctx, AVFrame frame)` Add a frame to the buffer source.
`static int`	`av_buffersrc_close(AVFilterContext ctx, long pts, int flags)` Close the buffer source after EOF.
`static int`	`av_buffersrc_get_nb_failed_requests(AVFilterContext buffer_src)` Get the number of failed requests.
`static AVBufferSrcParameters`	`av_buffersrc_parameters_alloc()` Allocate a new AVBufferSrcParameters instance.
`static int`	`av_buffersrc_parameters_set(AVFilterContext ctx, AVBufferSrcParameters param)` Initialize the buffersrc or abuffersrc filter with the provided parameters.
`static int`	`av_buffersrc_write_frame(AVFilterContext ctx, AVFrame frame)` Add a frame to the buffer source.
`static AVFilter`	`av_filter_iterate(Pointer opaque)`
`static AVFilter`	`av_filter_iterate(PointerPointer opaque)` Iterate over all registered filters.
`static int`	`avfilter_config_links(AVFilterContext filter)` Negotiate the media format, dimensions, etc of all inputs to a filter.
`static BytePointer`	`avfilter_configuration()` Return the libavfilter build-time configuration.
`static int`	`avfilter_filter_pad_count(AVFilter filter, int is_output)` Get the number of elements in an AVFilter's inputs or outputs array.
`static void`	`avfilter_free(AVFilterContext filter)` Free a filter context.
`static AVFilter`	`avfilter_get_by_name(BytePointer name)` Get a filter definition matching the given name.
`static AVFilter`	`avfilter_get_by_name(String name)`
`static AVClass`	`avfilter_get_class()`
`static AVFilterContext`	`avfilter_graph_alloc_filter(AVFilterGraph graph, AVFilter filter, BytePointer name)` Create a new filter instance in a filter graph.
`static AVFilterContext`	`avfilter_graph_alloc_filter(AVFilterGraph graph, AVFilter filter, String name)`
`static AVFilterGraph`	`avfilter_graph_alloc()` Allocate a filter graph.
`static int`	`avfilter_graph_config(AVFilterGraph graphctx, Pointer log_ctx)` Check validity and configure all the links and formats in the graph.
`static int`	`avfilter_graph_create_filter(AVFilterContext filt_ctx, AVFilter filt, BytePointer name, BytePointer args, Pointer opaque, AVFilterGraph graph_ctx)`
`static int`	`avfilter_graph_create_filter(AVFilterContext filt_ctx, AVFilter filt, String name, String args, Pointer opaque, AVFilterGraph graph_ctx)`
`static int`	`avfilter_graph_create_filter(PointerPointer filt_ctx, AVFilter filt, BytePointer name, BytePointer args, Pointer opaque, AVFilterGraph graph_ctx)` Create and add a filter instance into an existing graph.
`static BytePointer`	`avfilter_graph_dump(AVFilterGraph graph, BytePointer options)` Dump a graph into a human-readable string representation.
`static ByteBuffer`	`avfilter_graph_dump(AVFilterGraph graph, String options)`
`static void`	`avfilter_graph_free(AVFilterGraph graph)`
`static void`	`avfilter_graph_free(PointerPointer graph)` Free a graph, destroy its links, and set *graph to NULL.
`static AVFilterContext`	`avfilter_graph_get_filter(AVFilterGraph graph, BytePointer name)` Get a filter instance identified by instance name from graph.
`static AVFilterContext`	`avfilter_graph_get_filter(AVFilterGraph graph, String name)`
`static int`	`avfilter_graph_parse_ptr(AVFilterGraph graph, BytePointer filters, AVFilterInOut inputs, AVFilterInOut outputs, Pointer log_ctx)`
`static int`	`avfilter_graph_parse_ptr(AVFilterGraph graph, BytePointer filters, PointerPointer inputs, PointerPointer outputs, Pointer log_ctx)` Add a graph described by a string to a graph.
`static int`	`avfilter_graph_parse_ptr(AVFilterGraph graph, String filters, AVFilterInOut inputs, AVFilterInOut outputs, Pointer log_ctx)`
`static int`	`avfilter_graph_parse(AVFilterGraph graph, BytePointer filters, AVFilterInOut inputs, AVFilterInOut outputs, Pointer log_ctx)` Add a graph described by a string to a graph.
`static int`	`avfilter_graph_parse(AVFilterGraph graph, String filters, AVFilterInOut inputs, AVFilterInOut outputs, Pointer log_ctx)`
`static int`	`avfilter_graph_parse2(AVFilterGraph graph, BytePointer filters, AVFilterInOut inputs, AVFilterInOut outputs)`
`static int`	`avfilter_graph_parse2(AVFilterGraph graph, BytePointer filters, PointerPointer inputs, PointerPointer outputs)` Add a graph described by a string to a graph.
`static int`	`avfilter_graph_parse2(AVFilterGraph graph, String filters, AVFilterInOut inputs, AVFilterInOut outputs)`
`static int`	`avfilter_graph_queue_command(AVFilterGraph graph, BytePointer target, BytePointer cmd, BytePointer arg, int flags, double ts)` Queue a command for one or more filter instances.
`static int`	`avfilter_graph_queue_command(AVFilterGraph graph, String target, String cmd, String arg, int flags, double ts)`
`static int`	`avfilter_graph_request_oldest(AVFilterGraph graph)` Request a frame on the oldest sink link.
`static int`	`avfilter_graph_send_command(AVFilterGraph graph, BytePointer target, BytePointer cmd, BytePointer arg, byte[] res, int res_len, int flags)`
`static int`	`avfilter_graph_send_command(AVFilterGraph graph, BytePointer target, BytePointer cmd, BytePointer arg, ByteBuffer res, int res_len, int flags)`
`static int`	`avfilter_graph_send_command(AVFilterGraph graph, BytePointer target, BytePointer cmd, BytePointer arg, BytePointer res, int res_len, int flags)` Send a command to one or more filter instances.
`static int`	`avfilter_graph_send_command(AVFilterGraph graph, String target, String cmd, String arg, byte[] res, int res_len, int flags)`
`static int`	`avfilter_graph_send_command(AVFilterGraph graph, String target, String cmd, String arg, ByteBuffer res, int res_len, int flags)`
`static int`	`avfilter_graph_send_command(AVFilterGraph graph, String target, String cmd, String arg, BytePointer res, int res_len, int flags)`
`static void`	`avfilter_graph_set_auto_convert(AVFilterGraph graph, int flags)` Enable or disable automatic format conversion inside the graph.
`static int`	`avfilter_init_dict(AVFilterContext ctx, AVDictionary options)`
`static int`	`avfilter_init_dict(AVFilterContext ctx, PointerPointer options)` Initialize a filter with the supplied dictionary of options.
`static int`	`avfilter_init_str(AVFilterContext ctx, BytePointer args)` Initialize a filter with the supplied parameters.
`static int`	`avfilter_init_str(AVFilterContext ctx, String args)`
`static AVFilterInOut`	`avfilter_inout_alloc()` Allocate a single AVFilterInOut entry.
`static void`	`avfilter_inout_free(AVFilterInOut inout)`
`static void`	`avfilter_inout_free(PointerPointer inout)` Free the supplied list of AVFilterInOut and set *inout to NULL.
`static int`	`avfilter_insert_filter(AVFilterLink link, AVFilterContext filt, int filt_srcpad_idx, int filt_dstpad_idx)` Insert a filter in the middle of an existing link.
`static BytePointer`	`avfilter_license()` Return the libavfilter license.
`static void`	`avfilter_link_free(AVFilterLink link)`
`static void`	`avfilter_link_free(PointerPointer link)` Free the link in *link, and set its pointer to NULL.
`static int`	`avfilter_link(AVFilterContext src, int srcpad, AVFilterContext dst, int dstpad)` Link two filters together.
`static int`	`avfilter_pad_count(AVFilterPad pads)` Deprecated. Use avfilter_filter_pad_count() instead.
`static BytePointer`	`avfilter_pad_get_name(AVFilterPad pads, int pad_idx)` Get the name of an AVFilterPad.
`static int`	`avfilter_pad_get_type(AVFilterPad pads, int pad_idx)` Get the type of an AVFilterPad.
`static int`	`avfilter_process_command(AVFilterContext filter, BytePointer cmd, BytePointer arg, byte[] res, int res_len, int flags)`
`static int`	`avfilter_process_command(AVFilterContext filter, BytePointer cmd, BytePointer arg, ByteBuffer res, int res_len, int flags)`
`static int`	`avfilter_process_command(AVFilterContext filter, BytePointer cmd, BytePointer arg, BytePointer res, int res_len, int flags)` Make the filter instance process a command.
`static int`	`avfilter_process_command(AVFilterContext filter, String cmd, String arg, byte[] res, int res_len, int flags)`
`static int`	`avfilter_process_command(AVFilterContext filter, String cmd, String arg, ByteBuffer res, int res_len, int flags)`
`static int`	`avfilter_process_command(AVFilterContext filter, String cmd, String arg, BytePointer res, int res_len, int flags)`
`static int`	`avfilter_version()` Return the LIBAVFILTER_VERSION_INT constant.
`static String`	`LIBAVFILTER_IDENT()`
`static int`	`LIBAVFILTER_VERSION_INT()`

Methods inherited from class org.bytedeco.ffmpeg.presets.avfilter
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- AVFILTER_FLAG_DYNAMIC_INPUTS
```
public static final int AVFILTER_FLAG_DYNAMIC_INPUTS
```
  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.
  
  See Also:
  
  Constant Field Values
- AVFILTER_FLAG_DYNAMIC_OUTPUTS
```
public static final int AVFILTER_FLAG_DYNAMIC_OUTPUTS
```
  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.
  
  See Also:
  
  Constant Field Values
- AVFILTER_FLAG_SLICE_THREADS
```
public static final int AVFILTER_FLAG_SLICE_THREADS
```
  The filter supports multithreading by splitting frames into multiple parts and processing them concurrently.
  
  See Also:
  
  Constant Field Values
- AVFILTER_FLAG_METADATA_ONLY
```
public static final int AVFILTER_FLAG_METADATA_ONLY
```
  The filter is a "metadata" filter - it does not modify the frame data in any way. It may only affect the metadata (i.e. those fields copied by av_frame_copy_props()). More precisely, this means: - video: the data of any frame output by the filter must be exactly equal to some frame that is received on one of its inputs. Furthermore, all frames produced on a given output must correspond to frames received on the same input and their order must be unchanged. Note that the filter may still drop or duplicate the frames. - audio: the data produced by the filter on any of its outputs (viewed e.g. as an array of interleaved samples) must be exactly equal to the data received by the filter on one of its inputs.
  
  See Also:
  
  Constant Field Values
- AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
```
public static final int AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
```
  Some filters support a generic "enable" expression option that can be used to enable or disable a filter in the timeline. Filters supporting this option have this flag set. When the enable expression is false, the default no-op filter_frame() function is called in place of the filter_frame() callback defined on each input pad, thus the frame is passed unchanged to the next filters.
  
  See Also:
  
  Constant Field Values
- AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
```
public static final int AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
```
  Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() callback(s) called as usual even when the enable expression is false. The filter will disable filtering within the filter_frame() callback(s) itself, for example executing code depending on the AVFilterContext->is_disabled value.
  
  See Also:
  
  Constant Field Values
- AVFILTER_FLAG_SUPPORT_TIMELINE
```
public static final int AVFILTER_FLAG_SUPPORT_TIMELINE
```
  Handy mask to test whether the filter supports or no the timeline feature (internally or generically).
  
  See Also:
  
  Constant Field Values
- AVFILTER_THREAD_SLICE
```
public static final int AVFILTER_THREAD_SLICE
```
  Process multiple parts of the frame concurrently.
  
  See Also:
  
  Constant Field Values
- AVFILTER_CMD_FLAG_ONE
```
public static final int AVFILTER_CMD_FLAG_ONE
```
  Stop once a filter understood the command (for target=all for example), fast filters are favored automatically
  
  See Also:
  
  Constant Field Values
- AVFILTER_CMD_FLAG_FAST
```
public static final int AVFILTER_CMD_FLAG_FAST
```
  Only execute command when its fast (like a video out that supports contrast adjustment in hw)
  
  See Also:
  
  Constant Field Values
- AVFILTER_AUTO_CONVERT_ALL
```
public static final int AVFILTER_AUTO_CONVERT_ALL
```
  enum
  
  See Also:
  
  Constant Field Values
- AVFILTER_AUTO_CONVERT_NONE
```
public static final int AVFILTER_AUTO_CONVERT_NONE
```
  enum
  
  See Also:
  
  Constant Field Values
- AV_BUFFERSINK_FLAG_PEEK
```
public static final int AV_BUFFERSINK_FLAG_PEEK
```
  Tell av_buffersink_get_buffer_ref() to read video/samples buffer reference, but not remove it from the buffer. This is useful if you need only to read a video/samples buffer, without to fetch it.
  
  See Also:
  
  Constant Field Values
- AV_BUFFERSINK_FLAG_NO_REQUEST
```
public static final int AV_BUFFERSINK_FLAG_NO_REQUEST
```
  Tell av_buffersink_get_buffer_ref() not to request a frame from its input. If a frame is already buffered, it is read (and removed from the buffer), but if no frame is present, return AVERROR(EAGAIN).
  
  See Also:
  
  Constant Field Values
- AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT
```
public static final int AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT
```
  enum
  
  See Also:
  
  Constant Field Values
- AV_BUFFERSRC_FLAG_PUSH
```
public static final int AV_BUFFERSRC_FLAG_PUSH
```
  enum
  
  See Also:
  
  Constant Field Values
- AV_BUFFERSRC_FLAG_KEEP_REF
```
public static final int AV_BUFFERSRC_FLAG_KEEP_REF
```
  enum
  
  See Also:
  
  Constant Field Values
- LIBAVFILTER_VERSION_MAJOR
```
public static final int LIBAVFILTER_VERSION_MAJOR
```
  \file \ingroup lavfi Libavfilter version macros
  
  See Also:
  
  Constant Field Values
- LIBAVFILTER_VERSION_MINOR
```
public static final int LIBAVFILTER_VERSION_MINOR
```
  See Also:
  
  Constant Field Values
- LIBAVFILTER_VERSION_MICRO
```
public static final int LIBAVFILTER_VERSION_MICRO
```
  See Also:
  
  Constant Field Values
- LIBAVFILTER_VERSION_INT
```
public static final int LIBAVFILTER_VERSION_INT
```
- LIBAVFILTER_BUILD
```
public static final int LIBAVFILTER_BUILD
```
- LIBAVFILTER_IDENT
```
public static final String LIBAVFILTER_IDENT
```
- FF_API_SWS_PARAM_OPTION
```
public static final boolean FF_API_SWS_PARAM_OPTION
```
  FF_API_* defines may be placed below to indicate public API that will be dropped at a future version bump. The defines themselves are not part of the public API and may change, break or disappear at any time.
  
  See Also:
  
  Constant Field Values
- FF_API_BUFFERSINK_ALLOC
```
public static final boolean FF_API_BUFFERSINK_ALLOC
```
  See Also:
  
  Constant Field Values
- FF_API_PAD_COUNT
```
public static final boolean FF_API_PAD_COUNT
```
  See Also:
  
  Constant Field Values

Constructor Detail
- avfilter
```
public avfilter()
```

Method Detail

avfilter_version

@NoException
 @Cast(value="unsigned")
public static int avfilter_version()

Return the LIBAVFILTER_VERSION_INT constant.

avfilter_configuration

@NoException
 @Cast(value="const char*")
public static BytePointer avfilter_configuration()

Return the libavfilter build-time configuration.

avfilter_license

@NoException
 @Cast(value="const char*")
public static BytePointer avfilter_license()

Return the libavfilter license.

avfilter_pad_count

@NoException
 @Deprecated
public static int avfilter_pad_count(@Const
                                                               AVFilterPad pads)

Deprecated. Use avfilter_filter_pad_count() instead.

Get the number of elements in an AVFilter's inputs or outputs array.

avfilter_pad_get_name

@NoException
 @Cast(value="const char*")
public static BytePointer avfilter_pad_get_name(@Const
                                                                                         AVFilterPad pads,
                                                                                         int pad_idx)

Get the name of an AVFilterPad.

Parameters:: pads - an array of AVFilterPads; pad_idx - index of the pad in the array; it is the caller's responsibility to ensure the index is valid
Returns:: name of the pad_idx'th pad in pads

avfilter_pad_get_type

@NoException
 @Cast(value="AVMediaType")
public static int avfilter_pad_get_type(@Const
                                                                                 AVFilterPad pads,
                                                                                 int pad_idx)

Get the type of an AVFilterPad.

Parameters:: pads - an array of AVFilterPads; pad_idx - index of the pad in the array; it is the caller's responsibility to ensure the index is valid
Returns:: type of the pad_idx'th pad in pads

avfilter_filter_pad_count

@NoException
 @Cast(value="unsigned")
public static int avfilter_filter_pad_count(@Const
                                                                                  AVFilter filter,
                                                                                  int is_output)

Get the number of elements in an AVFilter's inputs or outputs array.

avfilter_link

@NoException
public static int avfilter_link(AVFilterContext src,
                                             @Cast(value="unsigned")
                                             int srcpad,
                                             AVFilterContext dst,
                                             @Cast(value="unsigned")
                                             int dstpad)

Link two filters together.

Parameters:: src - the source filter; srcpad - index of the output pad on the source filter; dst - the destination filter; dstpad - index of the input pad on the destination filter
Returns:: zero on success

avfilter_link_free

@NoException
public static void avfilter_link_free(@Cast(value="AVFilterLink**")
                                                   PointerPointer link)

Free the link in *link, and set its pointer to NULL.

avfilter_link_free

@NoException
public static void avfilter_link_free(@ByPtrPtr
                                                   AVFilterLink link)

avfilter_config_links
```
@NoException
public static int avfilter_config_links(AVFilterContext filter)
```
Negotiate the media format, dimensions, etc of all inputs to a filter.

Parameters:

filter - the filter to negotiate the properties for its inputs

Returns:

zero on successful negotiation

avfilter_process_command

@NoException
public static int avfilter_process_command(AVFilterContext filter,
                                                        @Cast(value="const char*")
                                                        BytePointer cmd,
                                                        @Cast(value="const char*")
                                                        BytePointer arg,
                                                        @Cast(value="char*")
                                                        BytePointer res,
                                                        int res_len,
                                                        int flags)

Make the filter instance process a command. It is recommended to use avfilter_graph_send_command().

avfilter_process_command

@NoException
public static int avfilter_process_command(AVFilterContext filter,
                                                        String cmd,
                                                        String arg,
                                                        @Cast(value="char*")
                                                        ByteBuffer res,
                                                        int res_len,
                                                        int flags)

avfilter_process_command

@NoException
public static int avfilter_process_command(AVFilterContext filter,
                                                        @Cast(value="const char*")
                                                        BytePointer cmd,
                                                        @Cast(value="const char*")
                                                        BytePointer arg,
                                                        @Cast(value="char*")
                                                        byte[] res,
                                                        int res_len,
                                                        int flags)

avfilter_process_command

@NoException
public static int avfilter_process_command(AVFilterContext filter,
                                                        String cmd,
                                                        String arg,
                                                        @Cast(value="char*")
                                                        BytePointer res,
                                                        int res_len,
                                                        int flags)

avfilter_process_command

@NoException
public static int avfilter_process_command(AVFilterContext filter,
                                                        @Cast(value="const char*")
                                                        BytePointer cmd,
                                                        @Cast(value="const char*")
                                                        BytePointer arg,
                                                        @Cast(value="char*")
                                                        ByteBuffer res,
                                                        int res_len,
                                                        int flags)

avfilter_process_command

@NoException
public static int avfilter_process_command(AVFilterContext filter,
                                                        String cmd,
                                                        String arg,
                                                        @Cast(value="char*")
                                                        byte[] res,
                                                        int res_len,
                                                        int flags)

av_filter_iterate
```
@NoException
 @Const
public static AVFilter av_filter_iterate(@Cast(value="void**")
                                                              PointerPointer opaque)
```
Iterate over all registered filters.

Parameters:

opaque - a pointer where libavfilter will store the iteration state. Must point to NULL to start the iteration.

Returns:

the next registered filter or NULL when the iteration is finished

av_filter_iterate

@NoException
 @Const
public static AVFilter av_filter_iterate(@Cast(value="void**") @ByPtrPtr
                                                              Pointer opaque)

avfilter_get_by_name

@NoException
 @Const
public static AVFilter avfilter_get_by_name(@Cast(value="const char*")
                                                                 BytePointer name)

Get a filter definition matching the given name.

Parameters:: name - the filter name to find
Returns:: the filter definition, if any matching one is registered. NULL if none found.

avfilter_get_by_name

@NoException
 @Const
public static AVFilter avfilter_get_by_name(String name)

avfilter_init_str
```
@NoException
public static int avfilter_init_str(AVFilterContext ctx,
                                                 @Cast(value="const char*")
                                                 BytePointer args)
```
Initialize a filter with the supplied parameters.

Parameters:

ctx - uninitialized filter context to initialize

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.

Returns:

0 on success, a negative AVERROR on failure

avfilter_init_str

@NoException
public static int avfilter_init_str(AVFilterContext ctx,
                                                 String args)

avfilter_init_dict
```
@NoException
public static int avfilter_init_dict(AVFilterContext ctx,
                                                  @Cast(value="AVDictionary**")
                                                  PointerPointer options)
```
Initialize a filter with the supplied dictionary of options.

Parameters:

ctx - uninitialized filter context to initialize

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.

Returns:

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.

avfilter_init_dict

@NoException
public static int avfilter_init_dict(AVFilterContext ctx,
                                                  @ByPtrPtr
                                                  AVDictionary options)

avfilter_free
```
@NoException
public static void avfilter_free(AVFilterContext filter)
```
Free a filter context. This will also remove the filter from its filtergraph's list of filters.

Parameters:

filter - the filter to free

avfilter_insert_filter

@NoException
public static int avfilter_insert_filter(AVFilterLink link,
                                                      AVFilterContext filt,
                                                      @Cast(value="unsigned")
                                                      int filt_srcpad_idx,
                                                      @Cast(value="unsigned")
                                                      int filt_dstpad_idx)

Insert a filter in the middle of an existing link.

Parameters:: link - the link into which the filter should be inserted; filt - the filter to be inserted; filt_srcpad_idx - the input pad on the filter to connect; filt_dstpad_idx - the output pad on the filter to connect
Returns:: zero on success

avfilter_get_class
```
@NoException
 @Const
public static AVClass avfilter_get_class()
```
Returns:

AVClass for AVFilterContext.

See Also:

av_opt_find().

avfilter_graph_alloc
```
@NoException
public static AVFilterGraph avfilter_graph_alloc()
```
Allocate a filter graph.

Returns:

the allocated filter graph on success or NULL.

avfilter_graph_alloc_filter

@NoException
public static AVFilterContext avfilter_graph_alloc_filter(AVFilterGraph graph,
                                                                       @Const
                                                                       AVFilter filter,
                                                                       @Cast(value="const char*")
                                                                       BytePointer name)

Create a new filter instance in a filter graph.

Parameters:: graph - graph in which the new filter will be used; filter - the filter to create an instance of; 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.
Returns:: 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 on failure.

avfilter_graph_alloc_filter

@NoException
public static AVFilterContext avfilter_graph_alloc_filter(AVFilterGraph graph,
                                                                       @Const
                                                                       AVFilter filter,
                                                                       String name)

avfilter_graph_get_filter

@NoException
public static AVFilterContext avfilter_graph_get_filter(AVFilterGraph graph,
                                                                     @Cast(value="const char*")
                                                                     BytePointer name)

Get a filter instance identified by instance name from graph.

Parameters:: graph - filter graph to search through.; name - filter instance name (should be unique in the graph).
Returns:: the pointer to the found filter instance or NULL if it cannot be found.

avfilter_graph_get_filter

@NoException
public static AVFilterContext avfilter_graph_get_filter(AVFilterGraph graph,
                                                                     String name)

avfilter_graph_create_filter

@NoException
public static int avfilter_graph_create_filter(@Cast(value="AVFilterContext**")
                                                            PointerPointer filt_ctx,
                                                            @Const
                                                            AVFilter filt,
                                                            @Cast(value="const char*")
                                                            BytePointer name,
                                                            @Cast(value="const char*")
                                                            BytePointer args,
                                                            Pointer opaque,
                                                            AVFilterGraph graph_ctx)

Create and add a filter instance into an existing graph. The filter instance is created from the filter filt and inited with the parameter args. opaque is currently ignored. In case of success put in *filt_ctx the pointer to the created filter instance, otherwise set *filt_ctx to NULL.

Parameters:: name - the instance name to give to the created filter instance; graph_ctx - the filter graph
Returns:: a negative AVERROR error code in case of failure, a non negative value otherwise

avfilter_graph_create_filter

@NoException
public static int avfilter_graph_create_filter(@ByPtrPtr
                                                            AVFilterContext filt_ctx,
                                                            @Const
                                                            AVFilter filt,
                                                            @Cast(value="const char*")
                                                            BytePointer name,
                                                            @Cast(value="const char*")
                                                            BytePointer args,
                                                            Pointer opaque,
                                                            AVFilterGraph graph_ctx)

avfilter_graph_create_filter

@NoException
public static int avfilter_graph_create_filter(@ByPtrPtr
                                                            AVFilterContext filt_ctx,
                                                            @Const
                                                            AVFilter filt,
                                                            String name,
                                                            String args,
                                                            Pointer opaque,
                                                            AVFilterGraph graph_ctx)

avfilter_graph_set_auto_convert

@NoException
public static void avfilter_graph_set_auto_convert(AVFilterGraph graph,
                                                                @Cast(value="unsigned")
                                                                int flags)

Enable or disable automatic format conversion inside the graph. Note that format conversion can still happen inside explicitly inserted scale and aresample filters.

Parameters:: flags - any of the AVFILTER_AUTO_CONVERT_* constants

avfilter_graph_config
```
@NoException
public static int avfilter_graph_config(AVFilterGraph graphctx,
                                                     Pointer log_ctx)
```
Check validity and configure all the links and formats in the graph.

Parameters:

graphctx - the filter graph

log_ctx - context used for logging

Returns:

>= 0 in case of success, a negative AVERROR code otherwise

avfilter_graph_free

@NoException
public static void avfilter_graph_free(@Cast(value="AVFilterGraph**")
                                                    PointerPointer graph)

Free a graph, destroy its links, and set *graph to NULL. If *graph is NULL, do nothing.

avfilter_graph_free

@NoException
public static void avfilter_graph_free(@ByPtrPtr
                                                    AVFilterGraph graph)

avfilter_inout_alloc
```
@NoException
public static AVFilterInOut avfilter_inout_alloc()
```
Allocate a single AVFilterInOut entry. Must be freed with avfilter_inout_free().

Returns:

allocated AVFilterInOut on success, NULL on failure.

avfilter_inout_free

@NoException
public static void avfilter_inout_free(@Cast(value="AVFilterInOut**")
                                                    PointerPointer inout)

Free the supplied list of AVFilterInOut and set *inout to NULL. If *inout is NULL, do nothing.

avfilter_inout_free

@NoException
public static void avfilter_inout_free(@ByPtrPtr
                                                    AVFilterInOut inout)

avfilter_graph_parse
```
@NoException
public static int avfilter_graph_parse(AVFilterGraph graph,
                                                    @Cast(value="const char*")
                                                    BytePointer filters,
                                                    AVFilterInOut inputs,
                                                    AVFilterInOut outputs,
                                                    Pointer log_ctx)
```
Add a graph described by a string to a graph. \note The caller must provide the lists of inputs and outputs, which therefore must be known before calling the function. \note The inputs parameter describes inputs of the already existing part of the graph; i.e. from the point of view of the newly created part, they are outputs. Similarly the outputs parameter describes outputs of the already existing filters, which are provided as inputs to the parsed filters.

Parameters:

graph - the filter graph where to link the parsed graph context

filters - string to be parsed

inputs - linked list to the inputs of the graph

outputs - linked list to the outputs of the graph

Returns:

zero on success, a negative AVERROR code on error

avfilter_graph_parse

@NoException
public static int avfilter_graph_parse(AVFilterGraph graph,
                                                    String filters,
                                                    AVFilterInOut inputs,
                                                    AVFilterInOut outputs,
                                                    Pointer log_ctx)

avfilter_graph_parse_ptr

@NoException
public static int avfilter_graph_parse_ptr(AVFilterGraph graph,
                                                        @Cast(value="const char*")
                                                        BytePointer filters,
                                                        @Cast(value="AVFilterInOut**")
                                                        PointerPointer inputs,
                                                        @Cast(value="AVFilterInOut**")
                                                        PointerPointer outputs,
                                                        Pointer log_ctx)

Add a graph described by a string to a graph. In the graph filters description, if the input label of the first filter is not specified, "in" is assumed; if the output label of the last filter is not specified, "out" is assumed.

Parameters:: graph - the filter graph where to link the parsed graph context; filters - string to be parsed; inputs - pointer to a linked list to the inputs of the graph, may be NULL. If non-NULL, *inputs is updated to contain the list of open inputs after the parsing, should be freed with avfilter_inout_free().; outputs - pointer to a linked list to the outputs of the graph, may be NULL. If non-NULL, *outputs is updated to contain the list of open outputs after the parsing, should be freed with avfilter_inout_free().
Returns:: non negative on success, a negative AVERROR code on error

avfilter_graph_parse_ptr

@NoException
public static int avfilter_graph_parse_ptr(AVFilterGraph graph,
                                                        @Cast(value="const char*")
                                                        BytePointer filters,
                                                        @ByPtrPtr
                                                        AVFilterInOut inputs,
                                                        @ByPtrPtr
                                                        AVFilterInOut outputs,
                                                        Pointer log_ctx)

avfilter_graph_parse_ptr

@NoException
public static int avfilter_graph_parse_ptr(AVFilterGraph graph,
                                                        String filters,
                                                        @ByPtrPtr
                                                        AVFilterInOut inputs,
                                                        @ByPtrPtr
                                                        AVFilterInOut outputs,
                                                        Pointer log_ctx)

avfilter_graph_parse2
```
@NoException
public static int avfilter_graph_parse2(AVFilterGraph graph,
                                                     @Cast(value="const char*")
                                                     BytePointer filters,
                                                     @Cast(value="AVFilterInOut**")
                                                     PointerPointer inputs,
                                                     @Cast(value="AVFilterInOut**")
                                                     PointerPointer outputs)
```
Add a graph described by a string to a graph.

Parameters:

graph - [in] the filter graph where to link the parsed graph context

filters - [in] string to be parsed

inputs - [out] 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().

outputs - [out] 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().

Returns:

zero on success, a negative AVERROR code on error \note This function returns the inputs and outputs that are left unlinked after parsing the graph and the caller then deals with them. \note This function 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.

avfilter_graph_parse2

@NoException
public static int avfilter_graph_parse2(AVFilterGraph graph,
                                                     @Cast(value="const char*")
                                                     BytePointer filters,
                                                     @ByPtrPtr
                                                     AVFilterInOut inputs,
                                                     @ByPtrPtr
                                                     AVFilterInOut outputs)

avfilter_graph_parse2

@NoException
public static int avfilter_graph_parse2(AVFilterGraph graph,
                                                     String filters,
                                                     @ByPtrPtr
                                                     AVFilterInOut inputs,
                                                     @ByPtrPtr
                                                     AVFilterInOut outputs)

avfilter_graph_send_command

@NoException
public static int avfilter_graph_send_command(AVFilterGraph graph,
                                                           @Cast(value="const char*")
                                                           BytePointer target,
                                                           @Cast(value="const char*")
                                                           BytePointer cmd,
                                                           @Cast(value="const char*")
                                                           BytePointer arg,
                                                           @Cast(value="char*")
                                                           BytePointer res,
                                                           int res_len,
                                                           int flags)

Send a command to one or more filter instances.

Parameters:: graph - the filter graph; target - the filter(s) to which the command should be sent "all" sends to all filters otherwise it can be a filter or filter instance name which will send the command to all matching filters.; cmd - the command to send, for handling simplicity all commands must be alphanumeric only; arg - the argument for the command; res - a buffer with size res_size where the filter(s) can return a response.
Returns:: >=0 on success otherwise an error code. AVERROR(ENOSYS) on unsupported commands

avfilter_graph_send_command

@NoException
public static int avfilter_graph_send_command(AVFilterGraph graph,
                                                           String target,
                                                           String cmd,
                                                           String arg,
                                                           @Cast(value="char*")
                                                           ByteBuffer res,
                                                           int res_len,
                                                           int flags)

avfilter_graph_send_command

@NoException
public static int avfilter_graph_send_command(AVFilterGraph graph,
                                                           @Cast(value="const char*")
                                                           BytePointer target,
                                                           @Cast(value="const char*")
                                                           BytePointer cmd,
                                                           @Cast(value="const char*")
                                                           BytePointer arg,
                                                           @Cast(value="char*")
                                                           byte[] res,
                                                           int res_len,
                                                           int flags)

avfilter_graph_send_command

@NoException
public static int avfilter_graph_send_command(AVFilterGraph graph,
                                                           String target,
                                                           String cmd,
                                                           String arg,
                                                           @Cast(value="char*")
                                                           BytePointer res,
                                                           int res_len,
                                                           int flags)

avfilter_graph_send_command

@NoException
public static int avfilter_graph_send_command(AVFilterGraph graph,
                                                           @Cast(value="const char*")
                                                           BytePointer target,
                                                           @Cast(value="const char*")
                                                           BytePointer cmd,
                                                           @Cast(value="const char*")
                                                           BytePointer arg,
                                                           @Cast(value="char*")
                                                           ByteBuffer res,
                                                           int res_len,
                                                           int flags)

avfilter_graph_send_command

@NoException
public static int avfilter_graph_send_command(AVFilterGraph graph,
                                                           String target,
                                                           String cmd,
                                                           String arg,
                                                           @Cast(value="char*")
                                                           byte[] res,
                                                           int res_len,
                                                           int flags)

avfilter_graph_queue_command

@NoException
public static int avfilter_graph_queue_command(AVFilterGraph graph,
                                                            @Cast(value="const char*")
                                                            BytePointer target,
                                                            @Cast(value="const char*")
                                                            BytePointer cmd,
                                                            @Cast(value="const char*")
                                                            BytePointer arg,
                                                            int flags,
                                                            double ts)

Queue a command for one or more filter instances.

Parameters:: graph - the filter graph; target - the filter(s) to which the command should be sent "all" sends to all filters otherwise it can be a filter or filter instance name which will send the command to all matching filters.; cmd - the command to sent, for handling simplicity all commands must be alphanumeric only; arg - the argument for the command; ts - time at which the command should be sent to the filter \note As this executes commands after this function returns, no return code from the filter is provided, also AVFILTER_CMD_FLAG_ONE is not supported.

avfilter_graph_queue_command

@NoException
public static int avfilter_graph_queue_command(AVFilterGraph graph,
                                                            String target,
                                                            String cmd,
                                                            String arg,
                                                            int flags,
                                                            double ts)

avfilter_graph_dump

@NoException
 @Cast(value="char*")
public static BytePointer avfilter_graph_dump(AVFilterGraph graph,
                                                                                 @Cast(value="const char*")
                                                                                 BytePointer options)

Dump a graph into a human-readable string representation.

Parameters:: graph - the graph to dump; options - formatting options; currently ignored
Returns:: a string, or NULL in case of memory allocation failure; the string must be freed using av_free

avfilter_graph_dump

@NoException
 @Cast(value="char*")
public static ByteBuffer avfilter_graph_dump(AVFilterGraph graph,
                                                                                String options)

avfilter_graph_request_oldest
```
@NoException
public static int avfilter_graph_request_oldest(AVFilterGraph graph)
```
Request a frame on the oldest sink link. If the request returns AVERROR_EOF, try the next. Note that this function is not meant to be the sole scheduling mechanism of a filtergraph, only a convenience function to help drain a filtergraph in a balanced way under normal circumstances. Also note that AVERROR_EOF does not mean that frames did not arrive on some of the sinks during the process. When there are multiple sink links, in case the requested link returns an EOF, this may cause a filter to flush pending frames which are sent to another sink link, although unrequested.

Returns:

the return value of ff_request_frame(), or AVERROR_EOF if all links returned AVERROR_EOF

av_buffersink_get_frame_flags
```
@NoException
public static int av_buffersink_get_frame_flags(AVFilterContext ctx,
                                                             AVFrame frame,
                                                             int flags)
```
Get a frame with filtered data from sink and put it in frame.

Parameters:

ctx - pointer to a buffersink or abuffersink filter context.

frame - pointer to an allocated frame that will be filled with data. The data must be freed using av_frame_unref() / av_frame_free()

flags - a combination of AV_BUFFERSINK_FLAG_* flags

Returns:

>= 0 in for success, a negative AVERROR code for failure.

av_buffersink_params_alloc
```
@NoException
 @Deprecated
public static AVBufferSinkParams av_buffersink_params_alloc()
```
Deprecated.

Create an AVBufferSinkParams structure. Must be freed with av_free().

av_abuffersink_params_alloc
```
@NoException
 @Deprecated
public static AVABufferSinkParams av_abuffersink_params_alloc()
```
Deprecated.

Create an AVABufferSinkParams structure. Must be freed with av_free().

av_buffersink_set_frame_size

@NoException
public static void av_buffersink_set_frame_size(AVFilterContext ctx,
                                                             @Cast(value="unsigned")
                                                             int frame_size)

Set the frame size for an audio buffer sink. All calls to av_buffersink_get_buffer_ref will return a buffer with exactly the specified number of samples, or AVERROR(EAGAIN) if there is not enough. The last buffer at EOF will be padded with 0.

av_buffersink_get_type

@NoException
 @Cast(value="AVMediaType")
public static int av_buffersink_get_type(@Const
                                                                                  AVFilterContext ctx)

\defgroup lavfi_buffersink_accessors Buffer sink accessors Get the properties of the stream \{

av_buffersink_get_time_base

@NoException
 @ByVal
public static AVRational av_buffersink_get_time_base(@Const
                                                                          AVFilterContext ctx)

av_buffersink_get_format

@NoException
public static int av_buffersink_get_format(@Const
                                                        AVFilterContext ctx)

av_buffersink_get_frame_rate

@NoException
 @ByVal
public static AVRational av_buffersink_get_frame_rate(@Const
                                                                           AVFilterContext ctx)

av_buffersink_get_w

@NoException
public static int av_buffersink_get_w(@Const
                                                   AVFilterContext ctx)

av_buffersink_get_h

@NoException
public static int av_buffersink_get_h(@Const
                                                   AVFilterContext ctx)

av_buffersink_get_sample_aspect_ratio

@NoException
 @ByVal
public static AVRational av_buffersink_get_sample_aspect_ratio(@Const
                                                                                    AVFilterContext ctx)

av_buffersink_get_channels

@NoException
public static int av_buffersink_get_channels(@Const
                                                          AVFilterContext ctx)

av_buffersink_get_channel_layout

@NoException
 @Cast(value="uint64_t")
public static long av_buffersink_get_channel_layout(@Const
                                                                                          AVFilterContext ctx)

av_buffersink_get_sample_rate

@NoException
public static int av_buffersink_get_sample_rate(@Const
                                                             AVFilterContext ctx)

av_buffersink_get_hw_frames_ctx

@NoException
public static AVBufferRef av_buffersink_get_hw_frames_ctx(@Const
                                                                       AVFilterContext ctx)

av_buffersink_get_frame
```
@NoException
public static int av_buffersink_get_frame(AVFilterContext ctx,
                                                       AVFrame frame)
```
Get a frame with filtered data from sink and put it in frame.

Parameters:

ctx - pointer to a context of a buffersink or abuffersink AVFilter.

frame - pointer to an allocated frame that will be filled with data. The data must be freed using av_frame_unref() / av_frame_free()

Returns:

- >= 0 if a frame was successfully returned. - AVERROR(EAGAIN) if no frames are available at this point; more input frames must be added to the filtergraph to get more output. - AVERROR_EOF if there will be no more output frames on this sink. - A different negative AVERROR code in other failure cases.

av_buffersink_get_samples
```
@NoException
public static int av_buffersink_get_samples(AVFilterContext ctx,
                                                         AVFrame frame,
                                                         int nb_samples)
```
Same as av_buffersink_get_frame(), but with the ability to specify the number of samples read. This function is less efficient than av_buffersink_get_frame(), because it copies the data around.

Parameters:

ctx - pointer to a context of the abuffersink AVFilter.

frame - pointer to an allocated frame that will be filled with data. The data must be freed using av_frame_unref() / av_frame_free() frame will contain exactly nb_samples audio samples, except at the end of stream, when it can contain less than nb_samples.

Returns:

The return codes have the same meaning as for av_buffersink_get_frame(). \warning do not mix this function with av_buffersink_get_frame(). Use only one or the other with a single sink, not both.

av_buffersrc_get_nb_failed_requests
```
@NoException
 @Cast(value="unsigned")
public static int av_buffersrc_get_nb_failed_requests(AVFilterContext buffer_src)
```
Get the number of failed requests. A failed request is when the request_frame method is called while no frame is present in the buffer. The number is reset when a frame is added.

av_buffersrc_parameters_alloc
```
@NoException
public static AVBufferSrcParameters av_buffersrc_parameters_alloc()
```
Allocate a new AVBufferSrcParameters instance. It should be freed by the caller with av_free().

av_buffersrc_parameters_set
```
@NoException
public static int av_buffersrc_parameters_set(AVFilterContext ctx,
                                                           AVBufferSrcParameters param)
```
Initialize the buffersrc or abuffersrc filter with the provided parameters. This function may be called multiple times, the later calls override the previous ones. Some of the parameters may also be set through AVOptions, then whatever method is used last takes precedence.

Parameters:

ctx - an instance of the buffersrc or abuffersrc filter

param - the stream parameters. The frames later passed to this filter must conform to those parameters. All the allocated fields in param remain owned by the caller, libavfilter will make internal copies or references when necessary.

Returns:

0 on success, a negative AVERROR code on failure.

av_buffersrc_write_frame
```
@NoException
public static int av_buffersrc_write_frame(AVFilterContext ctx,
                                                        @Const
                                                        AVFrame frame)
```
Add a frame to the buffer source.

Parameters:

ctx - an instance of the buffersrc filter

frame - frame to be added. If the frame is reference counted, this function will make a new reference to it. Otherwise the frame data will be copied.

Returns:

0 on success, a negative AVERROR on error This function is equivalent to av_buffersrc_add_frame_flags() with the AV_BUFFERSRC_FLAG_KEEP_REF flag.

av_buffersrc_add_frame
```
@NoException
public static int av_buffersrc_add_frame(AVFilterContext ctx,
                                                      AVFrame frame)
```
Add a frame to the buffer source.

Parameters:

ctx - an instance of the buffersrc filter

frame - frame to be added. If the frame is reference counted, this function will take ownership of the reference(s) and reset the frame. Otherwise the frame data will be copied. If this function returns an error, the input frame is not touched.

Returns:

0 on success, a negative AVERROR on error. \note the difference between this function and av_buffersrc_write_frame() is that av_buffersrc_write_frame() creates a new reference to the input frame, while this function takes ownership of the reference passed to it. This function is equivalent to av_buffersrc_add_frame_flags() without the AV_BUFFERSRC_FLAG_KEEP_REF flag.

av_buffersrc_add_frame_flags
```
@NoException
public static int av_buffersrc_add_frame_flags(AVFilterContext buffer_src,
                                                            AVFrame frame,
                                                            int flags)
```
Add a frame to the buffer source. By default, if the frame is reference-counted, this function will take ownership of the reference(s) and reset the frame. This can be controlled using the flags. If this function returns an error, the input frame is not touched.

Parameters:

buffer_src - pointer to a buffer source context

frame - a frame, or NULL to mark EOF

flags - a combination of AV_BUFFERSRC_FLAG_*

Returns:

>= 0 in case of success, a negative AVERROR code in case of failure

av_buffersrc_close

@NoException
public static int av_buffersrc_close(AVFilterContext ctx,
                                                  @Cast(value="int64_t")
                                                  long pts,
                                                  @Cast(value="unsigned")
                                                  int flags)

Close the buffer source after EOF. This is similar to passing NULL to av_buffersrc_add_frame_flags() except it takes the timestamp of the EOF, i.e. the timestamp of the end of the last frame.

LIBAVFILTER_VERSION_INT

@MemberGetter
public static int LIBAVFILTER_VERSION_INT()

LIBAVFILTER_IDENT

@MemberGetter
public static String LIBAVFILTER_IDENT()

Class avfilter

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.ffmpeg.presets.avfilter

Methods inherited from class java.lang.Object

Field Detail

AVFILTER_FLAG_DYNAMIC_INPUTS

AVFILTER_FLAG_DYNAMIC_OUTPUTS

AVFILTER_FLAG_SLICE_THREADS

AVFILTER_FLAG_METADATA_ONLY

AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC

AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL

AVFILTER_FLAG_SUPPORT_TIMELINE

AVFILTER_THREAD_SLICE

AVFILTER_CMD_FLAG_ONE

AVFILTER_CMD_FLAG_FAST

AVFILTER_AUTO_CONVERT_ALL

AVFILTER_AUTO_CONVERT_NONE

AV_BUFFERSINK_FLAG_PEEK

AV_BUFFERSINK_FLAG_NO_REQUEST

AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT

AV_BUFFERSRC_FLAG_PUSH

AV_BUFFERSRC_FLAG_KEEP_REF

LIBAVFILTER_VERSION_MAJOR

LIBAVFILTER_VERSION_MINOR

LIBAVFILTER_VERSION_MICRO

LIBAVFILTER_VERSION_INT

LIBAVFILTER_BUILD

LIBAVFILTER_IDENT

FF_API_SWS_PARAM_OPTION

FF_API_BUFFERSINK_ALLOC

FF_API_PAD_COUNT

Constructor Detail

avfilter

Method Detail

avfilter_version

avfilter_configuration

avfilter_license

avfilter_pad_count

avfilter_pad_get_name

avfilter_pad_get_type

avfilter_filter_pad_count

avfilter_link

avfilter_link_free

avfilter_link_free

avfilter_config_links

avfilter_process_command

avfilter_process_command

avfilter_process_command

avfilter_process_command

avfilter_process_command

avfilter_process_command

av_filter_iterate

av_filter_iterate

avfilter_get_by_name

avfilter_get_by_name

avfilter_init_str

avfilter_init_str

avfilter_init_dict

avfilter_init_dict

avfilter_free

avfilter_insert_filter

avfilter_get_class

avfilter_graph_alloc

avfilter_graph_alloc_filter

avfilter_graph_alloc_filter

avfilter_graph_get_filter

avfilter_graph_get_filter

avfilter_graph_create_filter

avfilter_graph_create_filter

avfilter_graph_create_filter

avfilter_graph_set_auto_convert

avfilter_graph_config

avfilter_graph_free

avfilter_graph_free

avfilter_inout_alloc

avfilter_inout_free

avfilter_inout_free

avfilter_graph_parse