org.bytedeco.javacpp

Class avfilter

java.lang.Object

org.bytedeco.javacpp.presets.avfilter

org.bytedeco.javacpp.avfilter

All Implemented Interfaces:

InfoMapper

public class avfilter
extends avfilter

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	avfilter.AVABufferSinkParams Struct to use for initializing an abuffersink context.
static class	avfilter.AVBufferSinkParams Struct to use for initializing a buffersink context.
static class	avfilter.AVBufferSrcParameters This structure contains the parameters describing the frames that will be passed to this filter.
static class	avfilter.AVFilter Filter definition.
static class	avfilter.avfilter_action_func A function pointer passed to the \ref AVFilterGraph.execute callback to be executed multiple times, possibly in parallel.
static class	avfilter.avfilter_execute_func A function executing multiple jobs, possibly in parallel.
static class	avfilter.AVFilterContext An instance of a filter
static class	avfilter.AVFilterFormats
static class	avfilter.AVFilterGraph
static class	avfilter.AVFilterGraphInternal
static class	avfilter.AVFilterInOut A linked-list of the inputs/outputs of the filter chain.
static class	avfilter.AVFilterInternal
static class	avfilter.AVFilterLink A link between two filters.
static class	avfilter.AVFilterPad

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_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.

Constructor Summary

Constructors

Constructor and Description
avfilter()

Method Summary

Methods

Modifier and Type	Method and Description
static avfilter.AVABufferSinkParams	av_abuffersink_params_alloc() Create an AVABufferSinkParams structure.
static int	av_buffersink_get_frame_flags(avfilter.AVFilterContext ctx, avutil.AVFrame frame, int flags) Get a frame with filtered data from sink and put it in frame.
static avutil.AVRational	av_buffersink_get_frame_rate(avfilter.AVFilterContext ctx) Get the frame rate of the input.
static int	av_buffersink_get_frame(avfilter.AVFilterContext ctx, avutil.AVFrame frame) Get a frame with filtered data from sink and put it in frame.
static int	av_buffersink_get_samples(avfilter.AVFilterContext ctx, avutil.AVFrame frame, int nb_samples) Same as av_buffersink_get_frame(), but with the ability to specify the number of samples read.
static avfilter.AVBufferSinkParams	av_buffersink_params_alloc() Create an AVBufferSinkParams structure.
static void	av_buffersink_set_frame_size(avfilter.AVFilterContext ctx, int frame_size) Set the frame size for an audio buffer sink.
static int	av_buffersrc_add_frame_flags(avfilter.AVFilterContext buffer_src, avutil.AVFrame frame, int flags) Add a frame to the buffer source.
static int	av_buffersrc_add_frame(avfilter.AVFilterContext ctx, avutil.AVFrame frame) Add a frame to the buffer source.
static int	av_buffersrc_get_nb_failed_requests(avfilter.AVFilterContext buffer_src) Get the number of failed requests.
static avfilter.AVBufferSrcParameters	av_buffersrc_parameters_alloc() Allocate a new AVBufferSrcParameters instance.
static int	av_buffersrc_parameters_set(avfilter.AVFilterContext ctx, avfilter.AVBufferSrcParameters param) Initialize the buffersrc or abuffersrc filter with the provided parameters.
static int	av_buffersrc_write_frame(avfilter.AVFilterContext ctx, avutil.AVFrame frame) Add a frame to the buffer source.
static avfilter.AVFilter	av_filter_next(avfilter.AVFilter filter) Deprecated.
static PointerPointer	av_filter_next(PointerPointer filter) Deprecated. use avfilter_next()
static int	avfilter_config_links(avfilter.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 void	avfilter_free(avfilter.AVFilterContext filter) Free a filter context.
static avfilter.AVFilter	avfilter_get_by_name(BytePointer name) Get a filter definition matching the given name.
static avfilter.AVFilter	avfilter_get_by_name(String name)
static avutil.AVClass	avfilter_get_class()
static int	avfilter_graph_add_filter(avfilter.AVFilterGraph graphctx, avfilter.AVFilterContext filter) Deprecated. use avfilter_graph_alloc_filter() to allocate a filter in a filter graph
static avfilter.AVFilterContext	avfilter_graph_alloc_filter(avfilter.AVFilterGraph graph, avfilter.AVFilter filter, BytePointer name) Create a new filter instance in a filter graph.
static avfilter.AVFilterContext	avfilter_graph_alloc_filter(avfilter.AVFilterGraph graph, avfilter.AVFilter filter, String name)
static avfilter.AVFilterGraph	avfilter_graph_alloc() Allocate a filter graph.
static int	avfilter_graph_config(avfilter.AVFilterGraph graphctx, Pointer log_ctx) Check validity and configure all the links and formats in the graph.
static int	avfilter_graph_create_filter(avfilter.AVFilterContext filt_ctx, avfilter.AVFilter filt, BytePointer name, BytePointer args, Pointer opaque, avfilter.AVFilterGraph graph_ctx)
static int	avfilter_graph_create_filter(avfilter.AVFilterContext filt_ctx, avfilter.AVFilter filt, String name, String args, Pointer opaque, avfilter.AVFilterGraph graph_ctx)
static int	avfilter_graph_create_filter(PointerPointer filt_ctx, avfilter.AVFilter filt, BytePointer name, BytePointer args, Pointer opaque, avfilter.AVFilterGraph graph_ctx) Create and add a filter instance into an existing graph.
static BytePointer	avfilter_graph_dump(avfilter.AVFilterGraph graph, BytePointer options) Dump a graph into a human-readable string representation.
static ByteBuffer	avfilter_graph_dump(avfilter.AVFilterGraph graph, String options)
static void	avfilter_graph_free(avfilter.AVFilterGraph graph)
static void	avfilter_graph_free(PointerPointer graph) Free a graph, destroy its links, and set *graph to NULL.
static avfilter.AVFilterContext	avfilter_graph_get_filter(avfilter.AVFilterGraph graph, BytePointer name) Get a filter instance identified by instance name from graph.
static avfilter.AVFilterContext	avfilter_graph_get_filter(avfilter.AVFilterGraph graph, String name)
static int	avfilter_graph_parse_ptr(avfilter.AVFilterGraph graph, BytePointer filters, avfilter.AVFilterInOut inputs, avfilter.AVFilterInOut outputs, Pointer log_ctx)
static int	avfilter_graph_parse_ptr(avfilter.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(avfilter.AVFilterGraph graph, String filters, avfilter.AVFilterInOut inputs, avfilter.AVFilterInOut outputs, Pointer log_ctx)
static int	avfilter_graph_parse(avfilter.AVFilterGraph graph, BytePointer filters, avfilter.AVFilterInOut inputs, avfilter.AVFilterInOut outputs, Pointer log_ctx) Add a graph described by a string to a graph.
static int	avfilter_graph_parse(avfilter.AVFilterGraph graph, String filters, avfilter.AVFilterInOut inputs, avfilter.AVFilterInOut outputs, Pointer log_ctx)
static int	avfilter_graph_parse2(avfilter.AVFilterGraph graph, BytePointer filters, avfilter.AVFilterInOut inputs, avfilter.AVFilterInOut outputs)
static int	avfilter_graph_parse2(avfilter.AVFilterGraph graph, BytePointer filters, PointerPointer inputs, PointerPointer outputs) Add a graph described by a string to a graph.
static int	avfilter_graph_parse2(avfilter.AVFilterGraph graph, String filters, avfilter.AVFilterInOut inputs, avfilter.AVFilterInOut outputs)
static int	avfilter_graph_queue_command(avfilter.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(avfilter.AVFilterGraph graph, String target, String cmd, String arg, int flags, double ts)
static int	avfilter_graph_request_oldest(avfilter.AVFilterGraph graph) Request a frame on the oldest sink link.
static int	avfilter_graph_send_command(avfilter.AVFilterGraph graph, BytePointer target, BytePointer cmd, BytePointer arg, byte[] res, int res_len, int flags)
static int	avfilter_graph_send_command(avfilter.AVFilterGraph graph, BytePointer target, BytePointer cmd, BytePointer arg, ByteBuffer res, int res_len, int flags)
static int	avfilter_graph_send_command(avfilter.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(avfilter.AVFilterGraph graph, String target, String cmd, String arg, byte[] res, int res_len, int flags)
static int	avfilter_graph_send_command(avfilter.AVFilterGraph graph, String target, String cmd, String arg, ByteBuffer res, int res_len, int flags)
static int	avfilter_graph_send_command(avfilter.AVFilterGraph graph, String target, String cmd, String arg, BytePointer res, int res_len, int flags)
static void	avfilter_graph_set_auto_convert(avfilter.AVFilterGraph graph, int flags) Enable or disable automatic format conversion inside the graph.
static int	avfilter_init_dict(avfilter.AVFilterContext ctx, avutil.AVDictionary options)
static int	avfilter_init_dict(avfilter.AVFilterContext ctx, PointerPointer options) Initialize a filter with the supplied dictionary of options.
static int	avfilter_init_filter(avfilter.AVFilterContext filter, BytePointer args, Pointer opaque) Deprecated.
static int	avfilter_init_filter(avfilter.AVFilterContext filter, String args, Pointer opaque) Deprecated.
static int	avfilter_init_str(avfilter.AVFilterContext ctx, BytePointer args) Initialize a filter with the supplied parameters.
static int	avfilter_init_str(avfilter.AVFilterContext ctx, String args)
static avfilter.AVFilterInOut	avfilter_inout_alloc() Allocate a single AVFilterInOut entry.
static void	avfilter_inout_free(avfilter.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(avfilter.AVFilterLink link, avfilter.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(avfilter.AVFilterLink link)
static void	avfilter_link_free(PointerPointer link) Free the link in *link, and set its pointer to NULL.
static int	avfilter_link_get_channels(avfilter.AVFilterLink link) Get the number of channels of a link.
static void	avfilter_link_set_closed(avfilter.AVFilterLink link, int closed) Deprecated. applications are not supposed to mess with links, they should close the sinks.
static int	avfilter_link(avfilter.AVFilterContext src, int srcpad, avfilter.AVFilterContext dst, int dstpad) Link two filters together.
static avfilter.AVFilter	avfilter_next(avfilter.AVFilter prev) Iterate over all registered filters.
static int	avfilter_open(avfilter.AVFilterContext filter_ctx, avfilter.AVFilter filter, BytePointer inst_name) Deprecated.
static int	avfilter_open(avfilter.AVFilterContext filter_ctx, avfilter.AVFilter filter, String inst_name) Deprecated.
static int	avfilter_open(PointerPointer filter_ctx, avfilter.AVFilter filter, BytePointer inst_name) Deprecated. use avfilter_graph_alloc_filter() instead
static int	avfilter_pad_count(avfilter.AVFilterPad pads) Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
static BytePointer	avfilter_pad_get_name(avfilter.AVFilterPad pads, int pad_idx) Get the name of an AVFilterPad.
static int	avfilter_pad_get_type(avfilter.AVFilterPad pads, int pad_idx) Get the type of an AVFilterPad.
static int	avfilter_process_command(avfilter.AVFilterContext filter, BytePointer cmd, BytePointer arg, byte[] res, int res_len, int flags)
static int	avfilter_process_command(avfilter.AVFilterContext filter, BytePointer cmd, BytePointer arg, ByteBuffer res, int res_len, int flags)
static int	avfilter_process_command(avfilter.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(avfilter.AVFilterContext filter, String cmd, String arg, byte[] res, int res_len, int flags)
static int	avfilter_process_command(avfilter.AVFilterContext filter, String cmd, String arg, ByteBuffer res, int res_len, int flags)
static int	avfilter_process_command(avfilter.AVFilterContext filter, String cmd, String arg, BytePointer res, int res_len, int flags)
static void	avfilter_register_all() Initialize the filter system.
static int	avfilter_register(avfilter.AVFilter filter) Register a filter.
static void	avfilter_uninit() Deprecated.
static int	avfilter_version() Return the LIBAVFILTER_VERSION_INT constant.

Methods inherited from class org.bytedeco.javacpp.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_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

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
public static int avfilter_pad_count(@Const
                                 avfilter.AVFilterPad pads)

Get the number of elements in a NULL-terminated array of AVFilterPads (e.g. AVFilter.inputs/outputs).

avfilter_pad_get_name

@NoException
@Cast(value="const char*")
public static BytePointer avfilter_pad_get_name(@Const
                                                      avfilter.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
                                              avfilter.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_link

@NoException
public static int avfilter_link(avfilter.AVFilterContext src,
                            @Cast(value="unsigned")
                            int srcpad,
                            avfilter.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
                                  avfilter.AVFilterLink link)

avfilter_link_get_channels

@NoException
public static int avfilter_link_get_channels(avfilter.AVFilterLink link)

Get the number of channels of a link.

avfilter_link_set_closed

@NoException
@Deprecated
public static void avfilter_link_set_closed(avfilter.AVFilterLink link,
                                                   int closed)

Deprecated. applications are not supposed to mess with links, they should close the sinks.

Set the closed field of a link.

avfilter_config_links

@NoException
public static int avfilter_config_links(avfilter.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(avfilter.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(avfilter.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(avfilter.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(avfilter.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(avfilter.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(avfilter.AVFilterContext filter,
                                       String cmd,
                                       String arg,
                                       @Cast(value="char*")
                                       byte[] res,
                                       int res_len,
                                       int flags)

avfilter_register_all

@NoException
public static void avfilter_register_all()

Initialize the filter system. Register all builtin filters.

avfilter_uninit

@NoException
@Deprecated
public static void avfilter_uninit()

Deprecated.

Uninitialize the filter system. Unregister all filters.

avfilter_register

@NoException
public static int avfilter_register(avfilter.AVFilter filter)

Register a filter. This is only needed if you plan to use avfilter_get_by_name later to lookup the AVFilter structure by name. A filter can still by instantiated with avfilter_graph_alloc_filter even if it is not registered.

Parameters:

filter - the filter to register

Returns:

0 if the registration was successful, a negative value otherwise

avfilter_get_by_name

@NoException
@Const
public static avfilter.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 avfilter_get_by_name(String name)

avfilter_next

@NoException
@Const
public static avfilter.AVFilter avfilter_next(@Const
                                                avfilter.AVFilter prev)

Iterate over all registered filters.

Returns:

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.

av_filter_next

@NoException
@Cast(value="AVFilter**")
@Deprecated
public static PointerPointer av_filter_next(@Cast(value="AVFilter**")
                                                             PointerPointer filter)

Deprecated. use avfilter_next()

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.

av_filter_next

@NoException
@Deprecated
@ByPtrPtr
public static avfilter.AVFilter av_filter_next(@ByPtrPtr
                                                               avfilter.AVFilter filter)

Deprecated.

avfilter_open

@NoException
@Deprecated
public static int avfilter_open(@Cast(value="AVFilterContext**")
                                       PointerPointer filter_ctx,
                                       avfilter.AVFilter filter,
                                       @Cast(value="const char*")
                                       BytePointer inst_name)

Deprecated. use avfilter_graph_alloc_filter() instead

Create a filter instance.

Parameters:

filter_ctx - put here a pointer to the created filter context on success, NULL on failure

filter - the filter to create an instance of

inst_name - Name to give to the new instance. Can be NULL for none.

Returns:

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

avfilter_open

@NoException
@Deprecated
public static int avfilter_open(@ByPtrPtr
                                       avfilter.AVFilterContext filter_ctx,
                                       avfilter.AVFilter filter,
                                       @Cast(value="const char*")
                                       BytePointer inst_name)

Deprecated.

avfilter_open

@NoException
@Deprecated
public static int avfilter_open(@ByPtrPtr
                                       avfilter.AVFilterContext filter_ctx,
                                       avfilter.AVFilter filter,
                                       String inst_name)

Deprecated.

avfilter_init_filter

@NoException
@Deprecated
public static int avfilter_init_filter(avfilter.AVFilterContext filter,
                                              @Cast(value="const char*")
                                              BytePointer args,
                                              Pointer opaque)

Deprecated.

Initialize a filter.

Parameters:

filter - the filter to initialize

args - A string of parameters to use when initializing the filter. The format and meaning of this string varies by filter.

opaque - Any extra non-string data needed by the filter. The meaning of this parameter varies by filter.

Returns:

zero on success

avfilter_init_filter

@NoException
@Deprecated
public static int avfilter_init_filter(avfilter.AVFilterContext filter,
                                              String args,
                                              Pointer opaque)

Deprecated.

avfilter_init_str

@NoException
public static int avfilter_init_str(avfilter.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(avfilter.AVFilterContext ctx,
                                String args)

avfilter_init_dict

@NoException
public static int avfilter_init_dict(avfilter.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(avfilter.AVFilterContext ctx,
                                 @ByPtrPtr
                                 avutil.AVDictionary options)

avfilter_free

@NoException
public static void avfilter_free(avfilter.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(avfilter.AVFilterLink link,
                                     avfilter.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 avutil.AVClass avfilter_get_class()

Returns:

AVClass for AVFilterContext.

See Also:

av_opt_find().

avfilter_graph_alloc

@NoException
public static avfilter.AVFilterGraph avfilter_graph_alloc()

Allocate a filter graph.

Returns:

the allocated filter graph on success or NULL.

avfilter_graph_alloc_filter

@NoException
public static avfilter.AVFilterContext avfilter_graph_alloc_filter(avfilter.AVFilterGraph graph,
                                                               @Const
                                                               avfilter.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 avfilter.AVFilterContext avfilter_graph_alloc_filter(avfilter.AVFilterGraph graph,
                                                               @Const
                                                               avfilter.AVFilter filter,
                                                               String name)

avfilter_graph_get_filter

@NoException
public static avfilter.AVFilterContext avfilter_graph_get_filter(avfilter.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 avfilter.AVFilterContext avfilter_graph_get_filter(avfilter.AVFilterGraph graph,
                                                             String name)

avfilter_graph_add_filter

@NoException
@Deprecated
public static int avfilter_graph_add_filter(avfilter.AVFilterGraph graphctx,
                                                   avfilter.AVFilterContext filter)

Deprecated. use avfilter_graph_alloc_filter() to allocate a filter in a filter graph

Add an existing filter instance to a filter graph.

Parameters:

graphctx - the filter graph

filter - the filter to be added

avfilter_graph_create_filter

@NoException
public static int avfilter_graph_create_filter(@Cast(value="AVFilterContext**")
                                           PointerPointer filt_ctx,
                                           @Const
                                           avfilter.AVFilter filt,
                                           @Cast(value="const char*")
                                           BytePointer name,
                                           @Cast(value="const char*")
                                           BytePointer args,
                                           Pointer opaque,
                                           avfilter.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 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.

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
                                           avfilter.AVFilterContext filt_ctx,
                                           @Const
                                           avfilter.AVFilter filt,
                                           @Cast(value="const char*")
                                           BytePointer name,
                                           @Cast(value="const char*")
                                           BytePointer args,
                                           Pointer opaque,
                                           avfilter.AVFilterGraph graph_ctx)

avfilter_graph_create_filter

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

avfilter_graph_set_auto_convert

@NoException
public static void avfilter_graph_set_auto_convert(avfilter.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(avfilter.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
                                   avfilter.AVFilterGraph graph)

avfilter_inout_alloc

@NoException
public static avfilter.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
                                   avfilter.AVFilterInOut inout)

avfilter_graph_parse

@NoException
public static int avfilter_graph_parse(avfilter.AVFilterGraph graph,
                                   @Cast(value="const char*")
                                   BytePointer filters,
                                   avfilter.AVFilterInOut inputs,
                                   avfilter.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(avfilter.AVFilterGraph graph,
                                   String filters,
                                   avfilter.AVFilterInOut inputs,
                                   avfilter.AVFilterInOut outputs,
                                   Pointer log_ctx)

avfilter_graph_parse_ptr

@NoException
public static int avfilter_graph_parse_ptr(avfilter.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(avfilter.AVFilterGraph graph,
                                       @Cast(value="const char*")
                                       BytePointer filters,
                                       @ByPtrPtr
                                       avfilter.AVFilterInOut inputs,
                                       @ByPtrPtr
                                       avfilter.AVFilterInOut outputs,
                                       Pointer log_ctx)

avfilter_graph_parse_ptr

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

avfilter_graph_parse2

@NoException
public static int avfilter_graph_parse2(avfilter.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:

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

[in] - filters string to be parsed

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

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

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(avfilter.AVFilterGraph graph,
                                    @Cast(value="const char*")
                                    BytePointer filters,
                                    @ByPtrPtr
                                    avfilter.AVFilterInOut inputs,
                                    @ByPtrPtr
                                    avfilter.AVFilterInOut outputs)

avfilter_graph_parse2

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

avfilter_graph_send_command

@NoException
public static int avfilter_graph_send_command(avfilter.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(avfilter.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(avfilter.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(avfilter.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(avfilter.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(avfilter.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(avfilter.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(avfilter.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(avfilter.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(avfilter.AVFilterGraph graph,
                                                   String options)

avfilter_graph_request_oldest

@NoException
public static int avfilter_graph_request_oldest(avfilter.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(avfilter.AVFilterContext ctx,
                                            avutil.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
public static avfilter.AVBufferSinkParams av_buffersink_params_alloc()

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

av_abuffersink_params_alloc

@NoException
public static avfilter.AVABufferSinkParams av_abuffersink_params_alloc()

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

av_buffersink_set_frame_size

@NoException
public static void av_buffersink_set_frame_size(avfilter.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_frame_rate

@NoException
@ByVal
public static avutil.AVRational av_buffersink_get_frame_rate(avfilter.AVFilterContext ctx)

Get the frame rate of the input.

av_buffersink_get_frame

@NoException
public static int av_buffersink_get_frame(avfilter.AVFilterContext ctx,
                                      avutil.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(avfilter.AVFilterContext ctx,
                                        avutil.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_samples(). \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(avfilter.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 avfilter.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(avfilter.AVFilterContext ctx,
                                          avfilter.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(avfilter.AVFilterContext ctx,
                                       @Const
                                       avutil.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(avfilter.AVFilterContext ctx,
                                     avutil.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(avfilter.AVFilterContext buffer_src,
                                           avutil.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