avformat (JavaCPP Presets for FFmpeg 7.1-1.5.11 API)

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

All Implemented Interfaces:

InfoMapper
```
public class avformat
extends avformat
```

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`AV_DISPOSITION_ATTACHED_PIC` The stream is stored in the file as an attached picture/"cover art" (e.g.
`static int`	`AV_DISPOSITION_CAPTIONS` The subtitle stream contains captions, providing a transcription and possibly a translation of audio.
`static int`	`AV_DISPOSITION_CLEAN_EFFECTS` The audio stream contains music and sound effects without voice.
`static int`	`AV_DISPOSITION_COMMENT` The stream is a commentary track.
`static int`	`AV_DISPOSITION_DEFAULT` The stream should be chosen by default among other streams of the same type, unless the user has explicitly specified otherwise.
`static int`	`AV_DISPOSITION_DEPENDENT` The stream is intended to be mixed with another stream before presentation.
`static int`	`AV_DISPOSITION_DESCRIPTIONS` The subtitle stream contains a textual description of the video content.
`static int`	`AV_DISPOSITION_DUB` The stream is not in original language.
`static int`	`AV_DISPOSITION_FORCED` Track should be used during playback by default.
`static int`	`AV_DISPOSITION_HEARING_IMPAIRED` The stream is intended for hearing impaired audiences.
`static int`	`AV_DISPOSITION_KARAOKE` The stream contains karaoke audio.
`static int`	`AV_DISPOSITION_LYRICS` The stream contains song lyrics.
`static int`	`AV_DISPOSITION_METADATA` The subtitle stream contains time-aligned metadata that is not intended to be directly presented to the user.
`static int`	`AV_DISPOSITION_MULTILAYER` The video stream contains multiple layers, e.g.
`static int`	`AV_DISPOSITION_NON_DIEGETIC` The stream is intended to be mixed with a spatial audio track.
`static int`	`AV_DISPOSITION_ORIGINAL` The stream is in original language.
`static int`	`AV_DISPOSITION_STILL_IMAGE` The video stream contains still images.
`static int`	`AV_DISPOSITION_TIMED_THUMBNAILS` The stream is sparse, and contains thumbnail images, often corresponding to chapter markers.
`static int`	`AV_DISPOSITION_VISUAL_IMPAIRED` The stream is intended for visually impaired audiences.
`static int`	`AV_FRAME_FILENAME_FLAGS_MULTIPLE` Allow multiple %d
`static int`	`AV_PROGRAM_RUNNING`
`static int`	`AV_PTS_WRAP_ADD_OFFSET` add the format specific offset on wrap detection
`static int`	`AV_PTS_WRAP_IGNORE` ignore the wrap
`static int`	`AV_PTS_WRAP_SUB_OFFSET` subtract the format specific offset on wrap detection
`static int`	`AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT` enum AVStreamGroupParamsType
`static int`	`AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION` enum AVStreamGroupParamsType
`static int`	`AV_STREAM_GROUP_PARAMS_LCEVC` enum AVStreamGroupParamsType
`static int`	`AV_STREAM_GROUP_PARAMS_NONE` enum AVStreamGroupParamsType
`static int`	`AV_STREAM_GROUP_PARAMS_TILE_GRID` enum AVStreamGroupParamsType
`static int`	`AVFMT_ALLOW_FLUSH` Deprecated. : Just send a NULL packet if you want to flush a muxer.
`static int`	`AVFMT_DURATION_FROM_BITRATE` enum AVDurationEstimationMethod
`static int`	`AVFMT_DURATION_FROM_PTS` enum AVDurationEstimationMethod
`static int`	`AVFMT_DURATION_FROM_STREAM` enum AVDurationEstimationMethod
`static int`	`AVFMT_EXPERIMENTAL` The muxer/demuxer is experimental and should be used with caution.
`static int`	`AVFMT_GENERIC_INDEX` Use generic index building code.
`static int`	`AVFMT_GLOBALHEADER` Format wants global header.
`static int`	`AVFMT_NEEDNUMBER` Needs '%d' in filename.
`static int`	`AVFMT_NO_BYTE_SEEK` Format does not allow seeking by bytes
`static int`	`AVFMT_NOBINSEARCH` Format does not allow to fall back on binary search via read_timestamp
`static int`	`AVFMT_NODIMENSIONS` Format does not need width/height
`static int`	`AVFMT_NOFILE` Demuxer will use avio_open, no opened file should be provided by the caller.
`static int`	`AVFMT_NOGENSEARCH` Format does not allow to fall back on generic search
`static int`	`AVFMT_NOSTREAMS` Format does not require any streams
`static int`	`AVFMT_NOTIMESTAMPS` Format does not need / have any timestamps.
`static int`	`AVFMT_SEEK_TO_PTS` Seeking is based on PTS
`static int`	`AVFMT_SHOW_IDS` Show format stream IDs numbers.
`static int`	`AVFMT_TBCF_AUTO` enum AVTimebaseSource
`static int`	`AVFMT_TBCF_DECODER` enum AVTimebaseSource
`static int`	`AVFMT_TBCF_DEMUXER` enum AVTimebaseSource
`static int`	`AVFMT_TBCF_R_FRAMERATE` enum AVTimebaseSource
`static int`	`AVFMT_TS_DISCONT` Format allows timestamp discontinuities.
`static int`	`AVFMT_TS_NEGATIVE` Format allows muxing negative timestamps.
`static int`	`AVFMT_TS_NONSTRICT` Format does not require strictly increasing timestamps, but they must still be monotonic
`static int`	`AVFMT_VARIABLE_FPS` Format allows variable fps.
`static int`	`AVFMTCTX_NOHEADER` signal that no header is present (streams are added dynamically)
`static int`	`AVFMTCTX_UNSEEKABLE` signal that the stream is definitely not seekable, and attempts to call the seek function will fail.
`static int`	`AVIO_DATA_MARKER_BOUNDARY_POINT` enum AVIODataMarkerType
`static int`	`AVIO_DATA_MARKER_FLUSH_POINT` enum AVIODataMarkerType
`static int`	`AVIO_DATA_MARKER_HEADER` enum AVIODataMarkerType
`static int`	`AVIO_DATA_MARKER_SYNC_POINT` enum AVIODataMarkerType
`static int`	`AVIO_DATA_MARKER_TRAILER` enum AVIODataMarkerType
`static int`	`AVIO_DATA_MARKER_UNKNOWN` enum AVIODataMarkerType
`static int`	`AVIO_ENTRY_BLOCK_DEVICE` enum AVIODirEntryType
`static int`	`AVIO_ENTRY_CHARACTER_DEVICE` enum AVIODirEntryType
`static int`	`AVIO_ENTRY_DIRECTORY` enum AVIODirEntryType
`static int`	`AVIO_ENTRY_FILE` enum AVIODirEntryType
`static int`	`AVIO_ENTRY_NAMED_PIPE` enum AVIODirEntryType
`static int`	`AVIO_ENTRY_SERVER` enum AVIODirEntryType
`static int`	`AVIO_ENTRY_SHARE` enum AVIODirEntryType
`static int`	`AVIO_ENTRY_SOCKET` enum AVIODirEntryType
`static int`	`AVIO_ENTRY_SYMBOLIC_LINK` enum AVIODirEntryType
`static int`	`AVIO_ENTRY_UNKNOWN` enum AVIODirEntryType
`static int`	`AVIO_ENTRY_WORKGROUP` enum AVIODirEntryType
`static int`	`AVIO_FLAG_DIRECT` Use direct mode.
`static int`	`AVIO_FLAG_NONBLOCK` Use non-blocking mode.
`static int`	`AVIO_FLAG_READ` read-only
`static int`	`AVIO_FLAG_READ_WRITE` read-write pseudo flag
`static int`	`AVIO_FLAG_WRITE` write-only
`static int`	`AVIO_SEEKABLE_NORMAL` Seeking works like for a local file.
`static int`	`AVIO_SEEKABLE_TIME` Seeking by timestamp with avio_seek_time() is possible.
`static int`	`AVPROBE_PADDING_SIZE` extra allocated bytes at the end of the probe buffer
`static int`	`AVPROBE_SCORE_EXTENSION` score for file extension
`static int`	`AVPROBE_SCORE_MAX` maximum score
`static int`	`AVPROBE_SCORE_MIME` score for file mime type
`static int`	`AVPROBE_SCORE_RETRY`
`static int`	`AVPROBE_SCORE_STREAM_RETRY`
`static int`	`AVSEEK_FLAG_ANY` seek to any frame, even non-keyframes
`static int`	`AVSEEK_FLAG_BACKWARD` seek backward
`static int`	`AVSEEK_FLAG_BYTE` seeking based on position in bytes
`static int`	`AVSEEK_FLAG_FRAME` seeking based on frame number
`static int`	`AVSEEK_FORCE` Passing this flag as the "whence" parameter to a seek function causes it to seek by any means (like reopening and linear reading) or other normally unreasonable means that can be extremely slow.
`static int`	`AVSEEK_SIZE` ORing this as the "whence" parameter to a seek function causes it to return the filesize without seeking anywhere.
`static int`	`AVSTREAM_INIT_IN_INIT_OUTPUT` stream parameters initialized in avformat_init_output
`static int`	`AVSTREAM_INIT_IN_WRITE_HEADER` stream parameters initialized in avformat_write_header
`static int`	`AVSTREAM_PARSE_FULL` enum AVStreamParseType
`static int`	`AVSTREAM_PARSE_FULL_ONCE` enum AVStreamParseType
`static int`	`AVSTREAM_PARSE_FULL_RAW` enum AVStreamParseType
`static int`	`AVSTREAM_PARSE_HEADERS` enum AVStreamParseType
`static int`	`AVSTREAM_PARSE_NONE` enum AVStreamParseType
`static int`	`AVSTREAM_PARSE_TIMESTAMPS` enum AVStreamParseType
`static boolean`	`FF_API_ALLOW_FLUSH`
`static boolean`	`FF_API_AVSTREAM_SIDE_DATA`
`static boolean`	`FF_API_COMPUTE_PKT_FIELDS2` FF_API_* defines may be placed below to indicate public API that will be dropped at a future version bump.
`static boolean`	`FF_API_GET_DUR_ESTIMATE_METHOD`
`static boolean`	`FF_API_INTERNAL_TIMING`
`static boolean`	`FF_API_LAVF_SHORTEST`
`static int`	`FF_API_R_FRAME_RATE`
`static int`	`LIBAVFORMAT_BUILD`
`static String`	`LIBAVFORMAT_IDENT`
`static int`	`LIBAVFORMAT_VERSION_INT`
`static int`	`LIBAVFORMAT_VERSION_MAJOR` \file \ingroup libavf Libavformat version macros
`static int`	`LIBAVFORMAT_VERSION_MICRO`
`static int`	`LIBAVFORMAT_VERSION_MINOR` \file \ingroup libavf Libavformat version macros

Constructor Summary

Constructors
Constructor and Description

avformat()

Constructors
Constructor and Description
`avformat()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static int`	`av_add_index_entry(AVStream st, long pos, long timestamp, int size, int distance, int flags)` Add an index entry into a sorted list.
`static int`	`av_append_packet(AVIOContext s, AVPacket pkt, int size)` Read data and append it to the current content of the AVPacket.
`static int`	`av_codec_get_id(AVCodecTag tags, int tag)`
`static int`	`av_codec_get_id(PointerPointer tags, int tag)` Get the AVCodecID for the given codec tag tag.
`static int`	`av_codec_get_tag(AVCodecTag tags, int id)`
`static int`	`av_codec_get_tag(PointerPointer tags, int id)` Get the codec tag for the given codec id id.
`static int`	`av_codec_get_tag2(AVCodecTag tags, int id, int[] tag)`
`static int`	`av_codec_get_tag2(AVCodecTag tags, int id, IntBuffer tag)`
`static int`	`av_codec_get_tag2(AVCodecTag tags, int id, IntPointer tag)`
`static int`	`av_codec_get_tag2(PointerPointer tags, int id, IntPointer tag)` Get the codec tag for the given codec id.
`static AVInputFormat`	`av_demuxer_iterate(Pointer opaque)`
`static AVInputFormat`	`av_demuxer_iterate(PointerPointer opaque)` Iterate over all registered demuxers.
`static int`	`av_disposition_from_string(BytePointer disp)`
`static int`	`av_disposition_from_string(String disp)`
`static BytePointer`	`av_disposition_to_string(int disposition)`
`static void`	`av_dump_format(AVFormatContext ic, int index, BytePointer url, int is_output)` Print detailed information about the input or output format, such as duration, bitrate, streams, container, programs, metadata, side data, codec and time base.
`static void`	`av_dump_format(AVFormatContext ic, int index, String url, int is_output)`
`static int`	`av_filename_number_test(BytePointer filename)` Check whether filename actually is a numbered sequence generator.
`static int`	`av_filename_number_test(String filename)`
`static int`	`av_find_best_stream(AVFormatContext ic, int type, int wanted_stream_nb, int related_stream, AVCodec decoder_ret, int flags)`
`static int`	`av_find_best_stream(AVFormatContext ic, int type, int wanted_stream_nb, int related_stream, PointerPointer decoder_ret, int flags)` Find the "best" stream in the file.
`static int`	`av_find_default_stream_index(AVFormatContext s)`
`static AVInputFormat`	`av_find_input_format(BytePointer short_name)` Find AVInputFormat based on the short name of the input format.
`static AVInputFormat`	`av_find_input_format(String short_name)`
`static AVProgram`	`av_find_program_from_stream(AVFormatContext ic, AVProgram last, int s)` Find the programs which belong to a given stream.
`static int`	`av_fmt_ctx_get_duration_estimation_method(AVFormatContext ctx)` Deprecated. duration_estimation_method is public and can be read directly.
`static void`	`av_format_inject_global_side_data(AVFormatContext s)` This function will cause global side data to be injected in the next packet of each stream as well as after any subsequent seek.
`static int`	`av_get_frame_filename(byte[] buf, int buf_size, BytePointer path, int number)`
`static int`	`av_get_frame_filename(byte[] buf, int buf_size, String path, int number)`
`static int`	`av_get_frame_filename(ByteBuffer buf, int buf_size, BytePointer path, int number)`
`static int`	`av_get_frame_filename(ByteBuffer buf, int buf_size, String path, int number)`
`static int`	`av_get_frame_filename(BytePointer buf, int buf_size, BytePointer path, int number)`
`static int`	`av_get_frame_filename(BytePointer buf, int buf_size, String path, int number)`
`static int`	`av_get_frame_filename2(byte[] buf, int buf_size, BytePointer path, int number, int flags)`
`static int`	`av_get_frame_filename2(byte[] buf, int buf_size, String path, int number, int flags)`
`static int`	`av_get_frame_filename2(ByteBuffer buf, int buf_size, BytePointer path, int number, int flags)`
`static int`	`av_get_frame_filename2(ByteBuffer buf, int buf_size, String path, int number, int flags)`
`static int`	`av_get_frame_filename2(BytePointer buf, int buf_size, BytePointer path, int number, int flags)` Return in 'buf' the path with '%d' replaced by a number.
`static int`	`av_get_frame_filename2(BytePointer buf, int buf_size, String path, int number, int flags)`
`static int`	`av_get_output_timestamp(AVFormatContext s, int stream, long[] dts, long[] wall)`
`static int`	`av_get_output_timestamp(AVFormatContext s, int stream, LongBuffer dts, LongBuffer wall)`
`static int`	`av_get_output_timestamp(AVFormatContext s, int stream, LongPointer dts, LongPointer wall)` Get timing information for the data currently output.
`static int`	`av_get_packet(AVIOContext s, AVPacket pkt, int size)` Allocate and read the payload of a packet and initialize its fields with default values.
`static int`	`av_guess_codec(AVOutputFormat fmt, BytePointer short_name, BytePointer filename, BytePointer mime_type, int type)` Guess the codec ID based upon muxer and filename.
`static int`	`av_guess_codec(AVOutputFormat fmt, String short_name, String filename, String mime_type, int type)`
`static AVOutputFormat`	`av_guess_format(BytePointer short_name, BytePointer filename, BytePointer mime_type)` Return the output format in the list of registered output formats which best matches the provided parameters, or return NULL if there is no match.
`static AVOutputFormat`	`av_guess_format(String short_name, String filename, String mime_type)`
`static AVRational`	`av_guess_frame_rate(AVFormatContext ctx, AVStream stream, AVFrame frame)` Guess the frame rate, based on both the container and codec information.
`static AVRational`	`av_guess_sample_aspect_ratio(AVFormatContext format, AVStream stream, AVFrame frame)` Guess the sample aspect ratio of a frame, based on both the stream and the frame aspect ratio.
`static void`	`av_hex_dump_log(Pointer avcl, int level, byte[] buf, int size)`
`static void`	`av_hex_dump_log(Pointer avcl, int level, ByteBuffer buf, int size)`
`static void`	`av_hex_dump_log(Pointer avcl, int level, BytePointer buf, int size)` Send a nice hexadecimal dump of a buffer to the log.
`static void`	`av_hex_dump(Pointer f, byte[] buf, int size)`
`static void`	`av_hex_dump(Pointer f, ByteBuffer buf, int size)`
`static void`	`av_hex_dump(Pointer f, BytePointer buf, int size)` Send a nice hexadecimal dump of a buffer to the specified file stream.
`static int`	`av_index_search_timestamp(AVStream st, long timestamp, int flags)` Get the index for a specific timestamp.
`static int`	`av_interleaved_write_frame(AVFormatContext s, AVPacket pkt)` Write a packet to an output media file ensuring correct interleaving.
`static int`	`av_interleaved_write_uncoded_frame(AVFormatContext s, int stream_index, AVFrame frame)` Write an uncoded frame to an output media file.
`static int`	`av_match_ext(BytePointer filename, BytePointer extensions)` Return a positive value if the given filename has one of the given extensions, 0 otherwise.
`static int`	`av_match_ext(String filename, String extensions)`
`static AVOutputFormat`	`av_muxer_iterate(Pointer opaque)`
`static AVOutputFormat`	`av_muxer_iterate(PointerPointer opaque)` Iterate over all registered muxers.
`static AVProgram`	`av_new_program(AVFormatContext s, int id)`
`static void`	`av_pkt_dump_log2(Pointer avcl, int level, AVPacket pkt, int dump_payload, AVStream st)` Send a nice dump of a packet to the log.
`static void`	`av_pkt_dump2(Pointer f, AVPacket pkt, int dump_payload, AVStream st)` Send a nice dump of a packet to the specified file stream.
`static int`	`av_probe_input_buffer(AVIOContext pb, AVInputFormat fmt, BytePointer url, Pointer logctx, int offset, int max_probe_size)`
`static int`	`av_probe_input_buffer(AVIOContext pb, AVInputFormat fmt, String url, Pointer logctx, int offset, int max_probe_size)`
`static int`	`av_probe_input_buffer(AVIOContext pb, PointerPointer fmt, BytePointer url, Pointer logctx, int offset, int max_probe_size)` Like av_probe_input_buffer2() but returns 0 on success
`static int`	`av_probe_input_buffer2(AVIOContext pb, AVInputFormat fmt, BytePointer url, Pointer logctx, int offset, int max_probe_size)`
`static int`	`av_probe_input_buffer2(AVIOContext pb, AVInputFormat fmt, String url, Pointer logctx, int offset, int max_probe_size)`
`static int`	`av_probe_input_buffer2(AVIOContext pb, PointerPointer fmt, BytePointer url, Pointer logctx, int offset, int max_probe_size)` Probe a bytestream to determine the input format.
`static AVInputFormat`	`av_probe_input_format(AVProbeData pd, int is_opened)` Guess the file format.
`static AVInputFormat`	`av_probe_input_format2(AVProbeData pd, int is_opened, int[] score_max)`
`static AVInputFormat`	`av_probe_input_format2(AVProbeData pd, int is_opened, IntBuffer score_max)`
`static AVInputFormat`	`av_probe_input_format2(AVProbeData pd, int is_opened, IntPointer score_max)` Guess the file format.
`static AVInputFormat`	`av_probe_input_format3(AVProbeData pd, int is_opened, int[] score_ret)`
`static AVInputFormat`	`av_probe_input_format3(AVProbeData pd, int is_opened, IntBuffer score_ret)`
`static AVInputFormat`	`av_probe_input_format3(AVProbeData pd, int is_opened, IntPointer score_ret)` Guess the file format.
`static void`	`av_program_add_stream_index(AVFormatContext ac, int progid, int idx)`
`static int`	`av_read_frame(AVFormatContext s, AVPacket pkt)` Return the next frame of a stream.
`static int`	`av_read_pause(AVFormatContext s)` Pause a network-based stream (e.g.
`static int`	`av_read_play(AVFormatContext s)` Start playing a network-based stream (e.g.
`static int`	`av_sdp_create(AVFormatContext ac, int n_files, byte[] buf, int size)`
`static int`	`av_sdp_create(AVFormatContext ac, int n_files, ByteBuffer buf, int size)`
`static int`	`av_sdp_create(AVFormatContext ac, int n_files, BytePointer buf, int size)`
`static int`	`av_sdp_create(PointerPointer ac, int n_files, BytePointer buf, int size)` Generate an SDP for an RTP session.
`static int`	`av_seek_frame(AVFormatContext s, int stream_index, long timestamp, int flags)` Seek to the keyframe at timestamp.
`static int`	`av_stream_add_side_data(AVStream st, int type, byte[] data, long size)` Deprecated.
`static int`	`av_stream_add_side_data(AVStream st, int type, ByteBuffer data, long size)` Deprecated.
`static int`	`av_stream_add_side_data(AVStream st, int type, BytePointer data, long size)` Deprecated. use av_packet_side_data_add() with the stream's \ref AVCodecParameters.coded_side_data "codecpar side data"
`static AVClass`	`av_stream_get_class()` Get the AVClass for AVStream.
`static AVRational`	`av_stream_get_codec_timebase(AVStream st)` Deprecated. do not call this function
`static AVCodecParserContext`	`av_stream_get_parser(AVStream s)`
`static BytePointer`	`av_stream_get_side_data(AVStream stream, int type, SizeTPointer size)` Deprecated. use av_packet_side_data_get() with the stream's \ref AVCodecParameters.coded_side_data "codecpar side data"
`static AVClass`	`av_stream_group_get_class()` Get the AVClass for AVStreamGroup.
`static BytePointer`	`av_stream_new_side_data(AVStream stream, int type, long size)` Deprecated. use av_packet_side_data_new() with the stream's \ref AVCodecParameters.coded_side_data "codecpar side data"
`static void`	`av_url_split(byte[] proto, int proto_size, byte[] authorization, int authorization_size, byte[] hostname, int hostname_size, int[] port_ptr, byte[] path, int path_size, BytePointer url)`
`static void`	`av_url_split(byte[] proto, int proto_size, byte[] authorization, int authorization_size, byte[] hostname, int hostname_size, int[] port_ptr, byte[] path, int path_size, String url)`
`static void`	`av_url_split(ByteBuffer proto, int proto_size, ByteBuffer authorization, int authorization_size, ByteBuffer hostname, int hostname_size, IntBuffer port_ptr, ByteBuffer path, int path_size, BytePointer url)`
`static void`	`av_url_split(ByteBuffer proto, int proto_size, ByteBuffer authorization, int authorization_size, ByteBuffer hostname, int hostname_size, IntBuffer port_ptr, ByteBuffer path, int path_size, String url)`
`static void`	`av_url_split(BytePointer proto, int proto_size, BytePointer authorization, int authorization_size, BytePointer hostname, int hostname_size, IntPointer port_ptr, BytePointer path, int path_size, BytePointer url)` Split a URL string into components.
`static void`	`av_url_split(BytePointer proto, int proto_size, BytePointer authorization, int authorization_size, BytePointer hostname, int hostname_size, IntPointer port_ptr, BytePointer path, int path_size, String url)`
`static int`	`av_write_frame(AVFormatContext s, AVPacket pkt)` Write a packet to an output media file.
`static int`	`av_write_trailer(AVFormatContext s)` Write the stream trailer to an output media file and free the file private data.
`static int`	`av_write_uncoded_frame_query(AVFormatContext s, int stream_index)` Test whether a muxer supports uncoded frame.
`static int`	`av_write_uncoded_frame(AVFormatContext s, int stream_index, AVFrame frame)` Write an uncoded frame to an output media file.
`static AVFormatContext`	`avformat_alloc_context()` Allocate an AVFormatContext.
`static int`	`avformat_alloc_output_context2(AVFormatContext ctx, AVOutputFormat oformat, BytePointer format_name, BytePointer filename)`
`static int`	`avformat_alloc_output_context2(AVFormatContext ctx, AVOutputFormat oformat, String format_name, String filename)`
`static int`	`avformat_alloc_output_context2(PointerPointer ctx, AVOutputFormat oformat, BytePointer format_name, BytePointer filename)` Allocate an AVFormatContext for an output format.
`static void`	`avformat_close_input(AVFormatContext s)`
`static void`	`avformat_close_input(PointerPointer s)` Close an opened input AVFormatContext.
`static BytePointer`	`avformat_configuration()` Return the libavformat build-time configuration.
`static int`	`avformat_find_stream_info(AVFormatContext ic, AVDictionary options)`
`static int`	`avformat_find_stream_info(AVFormatContext ic, PointerPointer options)` Read packets of a media file to get stream information.
`static int`	`avformat_flush(AVFormatContext s)` Discard all internally buffered data.
`static void`	`avformat_free_context(AVFormatContext s)` Free an AVFormatContext and all its streams.
`static AVClass`	`avformat_get_class()` Get the AVClass for AVFormatContext.
`static AVCodecTag`	`avformat_get_mov_audio_tags()`
`static AVCodecTag`	`avformat_get_mov_video_tags()`
`static AVCodecTag`	`avformat_get_riff_audio_tags()`
`static AVCodecTag`	`avformat_get_riff_video_tags()`
`static int`	`avformat_index_get_entries_count(AVStream st)` Get the index entry count for the given AVStream.
`static AVIndexEntry`	`avformat_index_get_entry_from_timestamp(AVStream st, long wanted_timestamp, int flags)` Get the AVIndexEntry corresponding to the given timestamp.
`static AVIndexEntry`	`avformat_index_get_entry(AVStream st, int idx)` Get the AVIndexEntry corresponding to the given index.
`static int`	`avformat_init_output(AVFormatContext s, AVDictionary options)`
`static int`	`avformat_init_output(AVFormatContext s, PointerPointer options)` Allocate the stream private data and initialize the codec, but do not write the header.
`static BytePointer`	`avformat_license()` Return the libavformat license.
`static int`	`avformat_match_stream_specifier(AVFormatContext s, AVStream st, BytePointer spec)` Check if the stream st contained in s is matched by the stream specifier spec.
`static int`	`avformat_match_stream_specifier(AVFormatContext s, AVStream st, String spec)`
`static int`	`avformat_network_deinit()` Undo the initialization done by avformat_network_init.
`static int`	`avformat_network_init()` Do global initialization of network libraries.
`static AVStream`	`avformat_new_stream(AVFormatContext s, AVCodec c)` Add a new stream to a media file.
`static int`	`avformat_open_input(AVFormatContext ps, BytePointer url, AVInputFormat fmt, AVDictionary options)`
`static int`	`avformat_open_input(AVFormatContext ps, String url, AVInputFormat fmt, AVDictionary options)`
`static int`	`avformat_open_input(PointerPointer ps, BytePointer url, AVInputFormat fmt, PointerPointer options)` Open an input stream and read the header.
`static int`	`avformat_query_codec(AVOutputFormat ofmt, int codec_id, int std_compliance)` Test if the given container can store a codec.
`static int`	`avformat_queue_attached_pictures(AVFormatContext s)`
`static int`	`avformat_seek_file(AVFormatContext s, int stream_index, long min_ts, long ts, long max_ts, int flags)` Seek to timestamp ts.
`static int`	`avformat_stream_group_add_stream(AVStreamGroup stg, AVStream st)` Add an already allocated stream to a stream group.
`static AVStreamGroup`	`avformat_stream_group_create(AVFormatContext s, int type, AVDictionary options)`
`static AVStreamGroup`	`avformat_stream_group_create(AVFormatContext s, int type, PointerPointer options)` Add a new empty stream group to a media file.
`static BytePointer`	`avformat_stream_group_name(int type)`
`static int`	`avformat_transfer_internal_stream_timing_info(AVOutputFormat ofmt, AVStream ost, AVStream ist, int copy_tb)` Deprecated. do not call this function
`static int`	`avformat_version()` Return the LIBAVFORMAT_VERSION_INT constant.
`static int`	`avformat_write_header(AVFormatContext s, AVDictionary options)`
`static int`	`avformat_write_header(AVFormatContext s, PointerPointer options)` Allocate the stream private data and write the stream header to an output media file.
`static int`	`avio_accept(AVIOContext s, AVIOContext c)`
`static int`	`avio_accept(AVIOContext s, PointerPointer c)` Accept and allocate a client context on a server context.
`static AVIOContext`	`avio_alloc_context(byte[] buffer, int buffer_size, int write_flag, Pointer opaque, Read_packet_Pointer_byte___int read_packet, Write_packet_Pointer_byte___int write_packet, Seek_Pointer_long_int seek)`
`static AVIOContext`	`avio_alloc_context(ByteBuffer buffer, int buffer_size, int write_flag, Pointer opaque, Read_packet_Pointer_ByteBuffer_int read_packet, Write_packet_Pointer_ByteBuffer_int write_packet, Seek_Pointer_long_int seek)`
`static AVIOContext`	`avio_alloc_context(BytePointer buffer, int buffer_size, int write_flag, Pointer opaque, Read_packet_Pointer_BytePointer_int read_packet, Write_packet_Pointer_BytePointer_int write_packet, Seek_Pointer_long_int seek)`
`static int`	`avio_check(BytePointer url, int flags)` Return AVIO_FLAG_* access flags corresponding to the access permissions of the resource in url, or a negative value corresponding to an AVERROR code in case of failure.
`static int`	`avio_check(String url, int flags)`
`static int`	`avio_close_dir(AVIODirContext s)`
`static int`	`avio_close_dir(PointerPointer s)` Close directory.
`static int`	`avio_close_dyn_buf(AVIOContext s, byte[] pbuffer)`
`static int`	`avio_close_dyn_buf(AVIOContext s, ByteBuffer pbuffer)`
`static int`	`avio_close_dyn_buf(AVIOContext s, BytePointer pbuffer)`
`static int`	`avio_close_dyn_buf(AVIOContext s, PointerPointer pbuffer)` Return the written size and a pointer to the buffer.
`static int`	`avio_close(AVIOContext s)` Close the resource accessed by the AVIOContext s and free it.
`static int`	`avio_closep(AVIOContext s)`
`static int`	`avio_closep(PointerPointer s)` Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL.
`static void`	`avio_context_free(AVIOContext s)`
`static void`	`avio_context_free(PointerPointer s)` Free the supplied IO context and everything associated with it.
`static BytePointer`	`avio_enum_protocols(Pointer opaque, int output)`
`static BytePointer`	`avio_enum_protocols(PointerPointer opaque, int output)` Iterate through names of available protocols.
`static int`	`avio_feof(AVIOContext s)` Similar to feof() but also returns nonzero on read errors.
`static BytePointer`	`avio_find_protocol_name(BytePointer url)` Return the name of the protocol that will handle the passed URL.
`static String`	`avio_find_protocol_name(String url)`
`static void`	`avio_flush(AVIOContext s)` Force flushing of buffered data.
`static void`	`avio_free_directory_entry(AVIODirEntry entry)`
`static void`	`avio_free_directory_entry(PointerPointer entry)` Free entry allocated by avio_read_dir().
`static int`	`avio_get_dyn_buf(AVIOContext s, byte[] pbuffer)`
`static int`	`avio_get_dyn_buf(AVIOContext s, ByteBuffer pbuffer)`
`static int`	`avio_get_dyn_buf(AVIOContext s, BytePointer pbuffer)`
`static int`	`avio_get_dyn_buf(AVIOContext s, PointerPointer pbuffer)` Return the written size and a pointer to the buffer.
`static int`	`avio_get_str(AVIOContext pb, int maxlen, byte[] buf, int buflen)`
`static int`	`avio_get_str(AVIOContext pb, int maxlen, ByteBuffer buf, int buflen)`
`static int`	`avio_get_str(AVIOContext pb, int maxlen, BytePointer buf, int buflen)` Read a string from pb into buf.
`static int`	`avio_get_str16be(AVIOContext pb, int maxlen, byte[] buf, int buflen)`
`static int`	`avio_get_str16be(AVIOContext pb, int maxlen, ByteBuffer buf, int buflen)`
`static int`	`avio_get_str16be(AVIOContext pb, int maxlen, BytePointer buf, int buflen)`
`static int`	`avio_get_str16le(AVIOContext pb, int maxlen, byte[] buf, int buflen)`
`static int`	`avio_get_str16le(AVIOContext pb, int maxlen, ByteBuffer buf, int buflen)`
`static int`	`avio_get_str16le(AVIOContext pb, int maxlen, BytePointer buf, int buflen)` Read a UTF-16 string from pb and convert it to UTF-8.
`static int`	`avio_handshake(AVIOContext c)` Perform one step of the protocol handshake to accept a new client.
`static int`	`avio_open_dir(AVIODirContext s, BytePointer url, AVDictionary options)`
`static int`	`avio_open_dir(AVIODirContext s, String url, AVDictionary options)`
`static int`	`avio_open_dir(PointerPointer s, BytePointer url, PointerPointer options)` Open directory for reading.
`static int`	`avio_open_dyn_buf(AVIOContext s)`
`static int`	`avio_open_dyn_buf(PointerPointer s)` Open a write only memory stream.
`static int`	`avio_open(AVIOContext s, BytePointer url, int flags)`
`static int`	`avio_open(AVIOContext s, String url, int flags)`
`static int`	`avio_open(PointerPointer s, BytePointer url, int flags)` Create and initialize a AVIOContext for accessing the resource indicated by url.
`static int`	`avio_open2(AVIOContext s, BytePointer url, int flags, AVIOInterruptCB int_cb, AVDictionary options)`
`static int`	`avio_open2(AVIOContext s, String url, int flags, AVIOInterruptCB int_cb, AVDictionary options)`
`static int`	`avio_open2(PointerPointer s, BytePointer url, int flags, AVIOInterruptCB int_cb, PointerPointer options)` Create and initialize a AVIOContext for accessing the resource indicated by url.
`static int`	`avio_pause(AVIOContext h, int pause)` Pause and resume playing - only meaningful if using a network streaming protocol (e.g.
`static void`	`avio_print_string_array(AVIOContext s, byte[] strings)`
`static void`	`avio_print_string_array(AVIOContext s, ByteBuffer strings)`
`static void`	`avio_print_string_array(AVIOContext s, BytePointer strings)`
`static void`	`avio_print_string_array(AVIOContext s, PointerPointer strings)` Write a NULL terminated array of strings to the context.
`static int`	`avio_printf(AVIOContext s, BytePointer fmt)` Writes a formatted string to the context.
`static int`	`avio_printf(AVIOContext s, String fmt)`
`static AVClass`	`avio_protocol_get_class(BytePointer name)` Get AVClass by names of available protocols.
`static AVClass`	`avio_protocol_get_class(String name)`
`static int`	`avio_put_str(AVIOContext s, BytePointer str)` Write a NULL-terminated string.
`static int`	`avio_put_str(AVIOContext s, String str)`
`static int`	`avio_put_str16be(AVIOContext s, BytePointer str)` Convert an UTF-8 string to UTF-16BE and write it.
`static int`	`avio_put_str16be(AVIOContext s, String str)`
`static int`	`avio_put_str16le(AVIOContext s, BytePointer str)` Convert an UTF-8 string to UTF-16LE and write it.
`static int`	`avio_put_str16le(AVIOContext s, String str)`
`static int`	`avio_r8(AVIOContext s)` \name Functions for reading from AVIOContext \{ \note return 0 if EOF, so you cannot use it if EOF handling is necessary
`static int`	`avio_rb16(AVIOContext s)`
`static int`	`avio_rb24(AVIOContext s)`
`static int`	`avio_rb32(AVIOContext s)`
`static long`	`avio_rb64(AVIOContext s)`
`static int`	`avio_read_dir(AVIODirContext s, AVIODirEntry next)`
`static int`	`avio_read_dir(AVIODirContext s, PointerPointer next)` Get next directory entry.
`static int`	`avio_read_partial(AVIOContext s, byte[] buf, int size)`
`static int`	`avio_read_partial(AVIOContext s, ByteBuffer buf, int size)`
`static int`	`avio_read_partial(AVIOContext s, BytePointer buf, int size)` Read size bytes from AVIOContext into buf.
`static int`	`avio_read_to_bprint(AVIOContext h, Pointer pb, long max_size)` Read contents of h into print buffer, up to max_size bytes, or up to EOF.
`static int`	`avio_read(AVIOContext s, byte[] buf, int size)`
`static int`	`avio_read(AVIOContext s, ByteBuffer buf, int size)`
`static int`	`avio_read(AVIOContext s, BytePointer buf, int size)` Read size bytes from AVIOContext into buf.
`static int`	`avio_rl16(AVIOContext s)`
`static int`	`avio_rl24(AVIOContext s)`
`static int`	`avio_rl32(AVIOContext s)`
`static long`	`avio_rl64(AVIOContext s)`
`static long`	`avio_seek_time(AVIOContext h, int stream_index, long timestamp, int flags)` Seek to a given timestamp relative to some component stream.
`static long`	`avio_seek(AVIOContext s, long offset, int whence)` fseek() equivalent for AVIOContext.
`static long`	`avio_size(AVIOContext s)` Get the filesize.
`static long`	`avio_skip(AVIOContext s, long offset)` Skip given number of bytes forward
`static long`	`avio_tell(AVIOContext s)` ftell() equivalent for AVIOContext.
`static int`	`avio_vprintf(AVIOContext s, BytePointer fmt, Pointer ap)` Writes a formatted string to the context taking a va_list.
`static int`	`avio_vprintf(AVIOContext s, String fmt, Pointer ap)`
`static void`	`avio_w8(AVIOContext s, int b)`
`static void`	`avio_wb16(AVIOContext s, int val)`
`static void`	`avio_wb24(AVIOContext s, int val)`
`static void`	`avio_wb32(AVIOContext s, int val)`
`static void`	`avio_wb64(AVIOContext s, long val)`
`static void`	`avio_wl16(AVIOContext s, int val)`
`static void`	`avio_wl24(AVIOContext s, int val)`
`static void`	`avio_wl32(AVIOContext s, int val)`
`static void`	`avio_wl64(AVIOContext s, long val)`
`static void`	`avio_write_marker(AVIOContext s, long time, int type)` Mark the written bytestream as a specific type.
`static void`	`avio_write(AVIOContext s, byte[] buf, int size)`
`static void`	`avio_write(AVIOContext s, ByteBuffer buf, int size)`
`static void`	`avio_write(AVIOContext s, BytePointer buf, int size)`
`static int`	`AVPROBE_SCORE_RETRY()`
`static int`	`AVPROBE_SCORE_STREAM_RETRY()`
`static String`	`LIBAVFORMAT_IDENT()`
`static int`	`LIBAVFORMAT_VERSION_INT()`

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

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

Field Detail
- AVIO_SEEKABLE_NORMAL
```
public static final int AVIO_SEEKABLE_NORMAL
```
  Seeking works like for a local file.
  
  See Also:
  
  Constant Field Values
- AVIO_SEEKABLE_TIME
```
public static final int AVIO_SEEKABLE_TIME
```
  Seeking by timestamp with avio_seek_time() is possible.
  
  See Also:
  
  Constant Field Values
- AVIO_ENTRY_UNKNOWN
```
public static final int AVIO_ENTRY_UNKNOWN
```
  enum AVIODirEntryType
  
  See Also:
  
  Constant Field Values
- AVIO_ENTRY_BLOCK_DEVICE
```
public static final int AVIO_ENTRY_BLOCK_DEVICE
```
  enum AVIODirEntryType
  
  See Also:
  
  Constant Field Values
- AVIO_ENTRY_CHARACTER_DEVICE
```
public static final int AVIO_ENTRY_CHARACTER_DEVICE
```
  enum AVIODirEntryType
  
  See Also:
  
  Constant Field Values
- AVIO_ENTRY_DIRECTORY
```
public static final int AVIO_ENTRY_DIRECTORY
```
  enum AVIODirEntryType
  
  See Also:
  
  Constant Field Values
- AVIO_ENTRY_NAMED_PIPE
```
public static final int AVIO_ENTRY_NAMED_PIPE
```
  enum AVIODirEntryType
  
  See Also:
  
  Constant Field Values
- AVIO_ENTRY_SYMBOLIC_LINK
```
public static final int AVIO_ENTRY_SYMBOLIC_LINK
```
  enum AVIODirEntryType
  
  See Also:
  
  Constant Field Values
- AVIO_ENTRY_SOCKET
```
public static final int AVIO_ENTRY_SOCKET
```
  enum AVIODirEntryType
  
  See Also:
  
  Constant Field Values
- AVIO_ENTRY_FILE
```
public static final int AVIO_ENTRY_FILE
```
  enum AVIODirEntryType
  
  See Also:
  
  Constant Field Values
- AVIO_ENTRY_SERVER
```
public static final int AVIO_ENTRY_SERVER
```
  enum AVIODirEntryType
  
  See Also:
  
  Constant Field Values
- AVIO_ENTRY_SHARE
```
public static final int AVIO_ENTRY_SHARE
```
  enum AVIODirEntryType
  
  See Also:
  
  Constant Field Values
- AVIO_ENTRY_WORKGROUP
```
public static final int AVIO_ENTRY_WORKGROUP
```
  enum AVIODirEntryType
  
  See Also:
  
  Constant Field Values
- AVIO_DATA_MARKER_HEADER
```
public static final int AVIO_DATA_MARKER_HEADER
```
  enum AVIODataMarkerType
  
  See Also:
  
  Constant Field Values
- AVIO_DATA_MARKER_SYNC_POINT
```
public static final int AVIO_DATA_MARKER_SYNC_POINT
```
  enum AVIODataMarkerType
  
  See Also:
  
  Constant Field Values
- AVIO_DATA_MARKER_BOUNDARY_POINT
```
public static final int AVIO_DATA_MARKER_BOUNDARY_POINT
```
  enum AVIODataMarkerType
  
  See Also:
  
  Constant Field Values
- AVIO_DATA_MARKER_UNKNOWN
```
public static final int AVIO_DATA_MARKER_UNKNOWN
```
  enum AVIODataMarkerType
  
  See Also:
  
  Constant Field Values
- AVIO_DATA_MARKER_TRAILER
```
public static final int AVIO_DATA_MARKER_TRAILER
```
  enum AVIODataMarkerType
  
  See Also:
  
  Constant Field Values
- AVIO_DATA_MARKER_FLUSH_POINT
```
public static final int AVIO_DATA_MARKER_FLUSH_POINT
```
  enum AVIODataMarkerType
  
  See Also:
  
  Constant Field Values
- AVSEEK_SIZE
```
public static final int AVSEEK_SIZE
```
  ORing this as the "whence" parameter to a seek function causes it to return the filesize without seeking anywhere. Supporting this is optional. If it is not supported then the seek function will return <0.
  
  See Also:
  
  Constant Field Values
- AVSEEK_FORCE
```
public static final int AVSEEK_FORCE
```
  Passing this flag as the "whence" parameter to a seek function causes it to seek by any means (like reopening and linear reading) or other normally unreasonable means that can be extremely slow. This may be ignored by the seek code.
  
  See Also:
  
  Constant Field Values
- AVIO_FLAG_READ
```
public static final int AVIO_FLAG_READ
```
  read-only
  
  See Also:
  
  Constant Field Values
- AVIO_FLAG_WRITE
```
public static final int AVIO_FLAG_WRITE
```
  write-only
  
  See Also:
  
  Constant Field Values
- AVIO_FLAG_READ_WRITE
```
public static final int AVIO_FLAG_READ_WRITE
```
  read-write pseudo flag
  
  See Also:
  
  Constant Field Values
- AVIO_FLAG_NONBLOCK
```
public static final int AVIO_FLAG_NONBLOCK
```
  Use non-blocking mode. If this flag is set, operations on the context will return AVERROR(EAGAIN) if they can not be performed immediately. If this flag is not set, operations on the context will never return AVERROR(EAGAIN). Note that this flag does not affect the opening/connecting of the context. Connecting a protocol will always block if necessary (e.g. on network protocols) but never hang (e.g. on busy devices). Warning: non-blocking protocols is work-in-progress; this flag may be silently ignored.
  
  See Also:
  
  Constant Field Values
- AVIO_FLAG_DIRECT
```
public static final int AVIO_FLAG_DIRECT
```
  Use direct mode. avio_read and avio_write should if possible be satisfied directly instead of going through a buffer, and avio_seek will always call the underlying seek function directly.
  
  See Also:
  
  Constant Field Values
- AVPROBE_SCORE_RETRY
```
public static final int AVPROBE_SCORE_RETRY
```
- AVPROBE_SCORE_STREAM_RETRY
```
public static final int AVPROBE_SCORE_STREAM_RETRY
```
- AVPROBE_SCORE_EXTENSION
```
public static final int AVPROBE_SCORE_EXTENSION
```
  score for file extension
  
  See Also:
  
  Constant Field Values
- AVPROBE_SCORE_MIME
```
public static final int AVPROBE_SCORE_MIME
```
  score for file mime type
  
  See Also:
  
  Constant Field Values
- AVPROBE_SCORE_MAX
```
public static final int AVPROBE_SCORE_MAX
```
  maximum score
  
  See Also:
  
  Constant Field Values
- AVPROBE_PADDING_SIZE
```
public static final int AVPROBE_PADDING_SIZE
```
  extra allocated bytes at the end of the probe buffer
  
  See Also:
  
  Constant Field Values
- AVFMT_NOFILE
```
public static final int AVFMT_NOFILE
```
  Demuxer will use avio_open, no opened file should be provided by the caller.
  
  See Also:
  
  Constant Field Values
- AVFMT_NEEDNUMBER
```
public static final int AVFMT_NEEDNUMBER
```
  Needs '%d' in filename.
  
  See Also:
  
  Constant Field Values
- AVFMT_EXPERIMENTAL
```
public static final int AVFMT_EXPERIMENTAL
```
  The muxer/demuxer is experimental and should be used with caution. - demuxers: will not be selected automatically by probing, must be specified explicitly.
  
  See Also:
  
  Constant Field Values
- AVFMT_SHOW_IDS
```
public static final int AVFMT_SHOW_IDS
```
  Show format stream IDs numbers.
  
  See Also:
  
  Constant Field Values
- AVFMT_GLOBALHEADER
```
public static final int AVFMT_GLOBALHEADER
```
  Format wants global header.
  
  See Also:
  
  Constant Field Values
- AVFMT_NOTIMESTAMPS
```
public static final int AVFMT_NOTIMESTAMPS
```
  Format does not need / have any timestamps.
  
  See Also:
  
  Constant Field Values
- AVFMT_GENERIC_INDEX
```
public static final int AVFMT_GENERIC_INDEX
```
  Use generic index building code.
  
  See Also:
  
  Constant Field Values
- AVFMT_TS_DISCONT
```
public static final int AVFMT_TS_DISCONT
```
  Format allows timestamp discontinuities. Note, muxers always require valid (monotone) timestamps
  
  See Also:
  
  Constant Field Values
- AVFMT_VARIABLE_FPS
```
public static final int AVFMT_VARIABLE_FPS
```
  Format allows variable fps.
  
  See Also:
  
  Constant Field Values
- AVFMT_NODIMENSIONS
```
public static final int AVFMT_NODIMENSIONS
```
  Format does not need width/height
  
  See Also:
  
  Constant Field Values
- AVFMT_NOSTREAMS
```
public static final int AVFMT_NOSTREAMS
```
  Format does not require any streams
  
  See Also:
  
  Constant Field Values
- AVFMT_NOBINSEARCH
```
public static final int AVFMT_NOBINSEARCH
```
  Format does not allow to fall back on binary search via read_timestamp
  
  See Also:
  
  Constant Field Values
- AVFMT_NOGENSEARCH
```
public static final int AVFMT_NOGENSEARCH
```
  Format does not allow to fall back on generic search
  
  See Also:
  
  Constant Field Values
- AVFMT_NO_BYTE_SEEK
```
public static final int AVFMT_NO_BYTE_SEEK
```
  Format does not allow seeking by bytes
  
  See Also:
  
  Constant Field Values
- AVFMT_ALLOW_FLUSH
```
public static final int AVFMT_ALLOW_FLUSH
```
  Deprecated. : Just send a NULL packet if you want to flush a muxer.
  
  See Also:
  
  Constant Field Values
- AVFMT_TS_NONSTRICT
```
public static final int AVFMT_TS_NONSTRICT
```
  Format does not require strictly increasing timestamps, but they must still be monotonic
  
  See Also:
  
  Constant Field Values
- AVFMT_TS_NEGATIVE
```
public static final int AVFMT_TS_NEGATIVE
```
  Format allows muxing negative timestamps. If not set the timestamp will be shifted in av_write_frame and av_interleaved_write_frame so they start from 0. The user or muxer can override this through AVFormatContext.avoid_negative_ts
  
  See Also:
  
  Constant Field Values
- AVFMT_SEEK_TO_PTS
```
public static final int AVFMT_SEEK_TO_PTS
```
  Seeking is based on PTS
  
  See Also:
  
  Constant Field Values
- AVSTREAM_PARSE_NONE
```
public static final int AVSTREAM_PARSE_NONE
```
  enum AVStreamParseType
  
  See Also:
  
  Constant Field Values
- AVSTREAM_PARSE_FULL
```
public static final int AVSTREAM_PARSE_FULL
```
  enum AVStreamParseType
  
  See Also:
  
  Constant Field Values
- AVSTREAM_PARSE_HEADERS
```
public static final int AVSTREAM_PARSE_HEADERS
```
  enum AVStreamParseType
  
  See Also:
  
  Constant Field Values
- AVSTREAM_PARSE_TIMESTAMPS
```
public static final int AVSTREAM_PARSE_TIMESTAMPS
```
  enum AVStreamParseType
  
  See Also:
  
  Constant Field Values
- AVSTREAM_PARSE_FULL_ONCE
```
public static final int AVSTREAM_PARSE_FULL_ONCE
```
  enum AVStreamParseType
  
  See Also:
  
  Constant Field Values
- AVSTREAM_PARSE_FULL_RAW
```
public static final int AVSTREAM_PARSE_FULL_RAW
```
  enum AVStreamParseType
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_DEFAULT
```
public static final int AV_DISPOSITION_DEFAULT
```
  The stream should be chosen by default among other streams of the same type, unless the user has explicitly specified otherwise.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_DUB
```
public static final int AV_DISPOSITION_DUB
```
  The stream is not in original language. \note AV_DISPOSITION_ORIGINAL is the inverse of this disposition. At most one of them should be set in properly tagged streams. \note This disposition may apply to any stream type, not just audio.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_ORIGINAL
```
public static final int AV_DISPOSITION_ORIGINAL
```
  The stream is in original language.
  
  See Also:
  
  notes for AV_DISPOSITION_DUB, Constant Field Values
- AV_DISPOSITION_COMMENT
```
public static final int AV_DISPOSITION_COMMENT
```
  The stream is a commentary track.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_LYRICS
```
public static final int AV_DISPOSITION_LYRICS
```
  The stream contains song lyrics.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_KARAOKE
```
public static final int AV_DISPOSITION_KARAOKE
```
  The stream contains karaoke audio.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_FORCED
```
public static final int AV_DISPOSITION_FORCED
```
  Track should be used during playback by default. Useful for subtitle track that should be displayed even when user did not explicitly ask for subtitles.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_HEARING_IMPAIRED
```
public static final int AV_DISPOSITION_HEARING_IMPAIRED
```
  The stream is intended for hearing impaired audiences.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_VISUAL_IMPAIRED
```
public static final int AV_DISPOSITION_VISUAL_IMPAIRED
```
  The stream is intended for visually impaired audiences.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_CLEAN_EFFECTS
```
public static final int AV_DISPOSITION_CLEAN_EFFECTS
```
  The audio stream contains music and sound effects without voice.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_ATTACHED_PIC
```
public static final int AV_DISPOSITION_ATTACHED_PIC
```
  The stream is stored in the file as an attached picture/"cover art" (e.g. APIC frame in ID3v2). The first (usually only) packet associated with it will be returned among the first few packets read from the file unless seeking takes place. It can also be accessed at any time in AVStream.attached_pic.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_TIMED_THUMBNAILS
```
public static final int AV_DISPOSITION_TIMED_THUMBNAILS
```
  The stream is sparse, and contains thumbnail images, often corresponding to chapter markers. Only ever used with AV_DISPOSITION_ATTACHED_PIC.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_NON_DIEGETIC
```
public static final int AV_DISPOSITION_NON_DIEGETIC
```
  The stream is intended to be mixed with a spatial audio track. For example, it could be used for narration or stereo music, and may remain unchanged by listener head rotation.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_CAPTIONS
```
public static final int AV_DISPOSITION_CAPTIONS
```
  The subtitle stream contains captions, providing a transcription and possibly a translation of audio. Typically intended for hearing-impaired audiences.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_DESCRIPTIONS
```
public static final int AV_DISPOSITION_DESCRIPTIONS
```
  The subtitle stream contains a textual description of the video content. Typically intended for visually-impaired audiences or for the cases where the video cannot be seen.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_METADATA
```
public static final int AV_DISPOSITION_METADATA
```
  The subtitle stream contains time-aligned metadata that is not intended to be directly presented to the user.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_DEPENDENT
```
public static final int AV_DISPOSITION_DEPENDENT
```
  The stream is intended to be mixed with another stream before presentation. Used for example to signal the stream contains an image part of a HEIF grid, or for mix_type=0 in mpegts.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_STILL_IMAGE
```
public static final int AV_DISPOSITION_STILL_IMAGE
```
  The video stream contains still images.
  
  See Also:
  
  Constant Field Values
- AV_DISPOSITION_MULTILAYER
```
public static final int AV_DISPOSITION_MULTILAYER
```
  The video stream contains multiple layers, e.g. stereoscopic views (cf. H.264 Annex G/H, or HEVC Annex F).
  
  See Also:
  
  Constant Field Values
- AV_PTS_WRAP_IGNORE
```
public static final int AV_PTS_WRAP_IGNORE
```
  ignore the wrap
  
  See Also:
  
  Constant Field Values
- AV_PTS_WRAP_ADD_OFFSET
```
public static final int AV_PTS_WRAP_ADD_OFFSET
```
  add the format specific offset on wrap detection
  
  See Also:
  
  Constant Field Values
- AV_PTS_WRAP_SUB_OFFSET
```
public static final int AV_PTS_WRAP_SUB_OFFSET
```
  subtract the format specific offset on wrap detection
  
  See Also:
  
  Constant Field Values
- AV_STREAM_GROUP_PARAMS_NONE
```
public static final int AV_STREAM_GROUP_PARAMS_NONE
```
  enum AVStreamGroupParamsType
  
  See Also:
  
  Constant Field Values
- AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
```
public static final int AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
```
  enum AVStreamGroupParamsType
  
  See Also:
  
  Constant Field Values
- AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
```
public static final int AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
```
  enum AVStreamGroupParamsType
  
  See Also:
  
  Constant Field Values
- AV_STREAM_GROUP_PARAMS_TILE_GRID
```
public static final int AV_STREAM_GROUP_PARAMS_TILE_GRID
```
  enum AVStreamGroupParamsType
  
  See Also:
  
  Constant Field Values
- AV_STREAM_GROUP_PARAMS_LCEVC
```
public static final int AV_STREAM_GROUP_PARAMS_LCEVC
```
  enum AVStreamGroupParamsType
  
  See Also:
  
  Constant Field Values
- AV_PROGRAM_RUNNING
```
public static final int AV_PROGRAM_RUNNING
```
  See Also:
  
  Constant Field Values
- AVFMTCTX_NOHEADER
```
public static final int AVFMTCTX_NOHEADER
```
  signal that no header is present (streams are added dynamically)
  
  See Also:
  
  Constant Field Values
- AVFMTCTX_UNSEEKABLE
```
public static final int AVFMTCTX_UNSEEKABLE
```
  signal that the stream is definitely not seekable, and attempts to call the seek function will fail. For some network protocols (e.g. HLS), this can change dynamically at runtime.
  
  See Also:
  
  Constant Field Values
- AVFMT_DURATION_FROM_PTS
```
public static final int AVFMT_DURATION_FROM_PTS
```
  enum AVDurationEstimationMethod
  
  See Also:
  
  Constant Field Values
- AVFMT_DURATION_FROM_STREAM
```
public static final int AVFMT_DURATION_FROM_STREAM
```
  enum AVDurationEstimationMethod
  
  See Also:
  
  Constant Field Values
- AVFMT_DURATION_FROM_BITRATE
```
public static final int AVFMT_DURATION_FROM_BITRATE
```
  enum AVDurationEstimationMethod
  
  See Also:
  
  Constant Field Values
- AVSEEK_FLAG_BACKWARD
```
public static final int AVSEEK_FLAG_BACKWARD
```
  seek backward
  
  See Also:
  
  Constant Field Values
- AVSEEK_FLAG_BYTE
```
public static final int AVSEEK_FLAG_BYTE
```
  seeking based on position in bytes
  
  See Also:
  
  Constant Field Values
- AVSEEK_FLAG_ANY
```
public static final int AVSEEK_FLAG_ANY
```
  seek to any frame, even non-keyframes
  
  See Also:
  
  Constant Field Values
- AVSEEK_FLAG_FRAME
```
public static final int AVSEEK_FLAG_FRAME
```
  seeking based on frame number
  
  See Also:
  
  Constant Field Values
- AVSTREAM_INIT_IN_WRITE_HEADER
```
public static final int AVSTREAM_INIT_IN_WRITE_HEADER
```
  stream parameters initialized in avformat_write_header
  
  See Also:
  
  Constant Field Values
- AVSTREAM_INIT_IN_INIT_OUTPUT
```
public static final int AVSTREAM_INIT_IN_INIT_OUTPUT
```
  stream parameters initialized in avformat_init_output
  
  See Also:
  
  Constant Field Values
- AV_FRAME_FILENAME_FLAGS_MULTIPLE
```
public static final int AV_FRAME_FILENAME_FLAGS_MULTIPLE
```
  Allow multiple %d
  
  See Also:
  
  Constant Field Values
- AVFMT_TBCF_AUTO
```
public static final int AVFMT_TBCF_AUTO
```
  enum AVTimebaseSource
  
  See Also:
  
  Constant Field Values
- AVFMT_TBCF_DECODER
```
public static final int AVFMT_TBCF_DECODER
```
  enum AVTimebaseSource
  
  See Also:
  
  Constant Field Values
- AVFMT_TBCF_DEMUXER
```
public static final int AVFMT_TBCF_DEMUXER
```
  enum AVTimebaseSource
  
  See Also:
  
  Constant Field Values
- AVFMT_TBCF_R_FRAMERATE
```
public static final int AVFMT_TBCF_R_FRAMERATE
```
  enum AVTimebaseSource
  
  See Also:
  
  Constant Field Values
- LIBAVFORMAT_VERSION_MAJOR
```
public static final int LIBAVFORMAT_VERSION_MAJOR
```
  \file \ingroup libavf Libavformat version macros
  
  See Also:
  
  Constant Field Values
- FF_API_COMPUTE_PKT_FIELDS2
```
public static final boolean FF_API_COMPUTE_PKT_FIELDS2
```
  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. \note, when bumping the major version it is recommended to manually disable each FF_API_* in its own commit instead of disabling them all at once through the bump. This improves the git bisect-ability of the change.
  
  See Also:
  
  Constant Field Values
- FF_API_LAVF_SHORTEST
```
public static final boolean FF_API_LAVF_SHORTEST
```
  See Also:
  
  Constant Field Values
- FF_API_ALLOW_FLUSH
```
public static final boolean FF_API_ALLOW_FLUSH
```
  See Also:
  
  Constant Field Values
- FF_API_AVSTREAM_SIDE_DATA
```
public static final boolean FF_API_AVSTREAM_SIDE_DATA
```
  See Also:
  
  Constant Field Values
- FF_API_GET_DUR_ESTIMATE_METHOD
```
public static final boolean FF_API_GET_DUR_ESTIMATE_METHOD
```
  See Also:
  
  Constant Field Values
- FF_API_INTERNAL_TIMING
```
public static final boolean FF_API_INTERNAL_TIMING
```
  See Also:
  
  Constant Field Values
- FF_API_R_FRAME_RATE
```
public static final int FF_API_R_FRAME_RATE
```
  See Also:
  
  Constant Field Values
- LIBAVFORMAT_VERSION_MINOR
```
public static final int LIBAVFORMAT_VERSION_MINOR
```
  \file \ingroup libavf Libavformat version macros
  
  See Also:
  
  Constant Field Values
- LIBAVFORMAT_VERSION_MICRO
```
public static final int LIBAVFORMAT_VERSION_MICRO
```
  See Also:
  
  Constant Field Values
- LIBAVFORMAT_VERSION_INT
```
public static final int LIBAVFORMAT_VERSION_INT
```
- LIBAVFORMAT_BUILD
```
public static final int LIBAVFORMAT_BUILD
```
- LIBAVFORMAT_IDENT
```
public static final String LIBAVFORMAT_IDENT
```

Constructor Detail
- avformat
```
public avformat()
```

Method Detail

avio_find_protocol_name

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

Return the name of the protocol that will handle the passed URL. NULL is returned if no protocol could be found for the given URL.

Returns:: Name of the protocol or NULL.

avio_find_protocol_name

@NoException
public static String avio_find_protocol_name(String url)

avio_check
```
@NoException
public static int avio_check(@Cast(value="const char*")
                                          BytePointer url,
                                          int flags)
```
Return AVIO_FLAG_* access flags corresponding to the access permissions of the resource in url, or a negative value corresponding to an AVERROR code in case of failure. The returned access flags are masked by the value in flags. \note This function is intrinsically unsafe, in the sense that the checked resource may change its existence or permission status from one call to another. Thus you should not trust the returned value, unless you are sure that no other processes are accessing the checked resource.

avio_check

@NoException
public static int avio_check(String url,
                                          int flags)

avio_open_dir

@NoException
public static int avio_open_dir(@Cast(value="AVIODirContext**")
                                             PointerPointer s,
                                             @Cast(value="const char*")
                                             BytePointer url,
                                             @Cast(value="AVDictionary**")
                                             PointerPointer options)

Open directory for reading.

Parameters:: s - directory read context. Pointer to a NULL pointer must be passed.; url - directory to be listed.; options - A dictionary filled with protocol-private options. On return this parameter will be destroyed and replaced with a dictionary containing options that were not found. May be NULL.
Returns:: >=0 on success or negative on error.

avio_open_dir

@NoException
public static int avio_open_dir(@ByPtrPtr
                                             AVIODirContext s,
                                             @Cast(value="const char*")
                                             BytePointer url,
                                             @ByPtrPtr
                                             AVDictionary options)

avio_open_dir

@NoException
public static int avio_open_dir(@ByPtrPtr
                                             AVIODirContext s,
                                             String url,
                                             @ByPtrPtr
                                             AVDictionary options)

avio_read_dir
```
@NoException
public static int avio_read_dir(AVIODirContext s,
                                             @Cast(value="AVIODirEntry**")
                                             PointerPointer next)
```
Get next directory entry. Returned entry must be freed with avio_free_directory_entry(). In particular it may outlive AVIODirContext.

Parameters:

s - directory read context.

next - [out] next entry or NULL when no more entries.

Returns:

>=0 on success or negative on error. End of list is not considered an error.

avio_read_dir

@NoException
public static int avio_read_dir(AVIODirContext s,
                                             @ByPtrPtr
                                             AVIODirEntry next)

avio_close_dir
```
@NoException
public static int avio_close_dir(@Cast(value="AVIODirContext**")
                                              PointerPointer s)
```
Close directory. \note Entries created using avio_read_dir() are not deleted and must be freeded with avio_free_directory_entry().

Parameters:

s - directory read context.

Returns:

>=0 on success or negative on error.

avio_close_dir

@NoException
public static int avio_close_dir(@ByPtrPtr
                                              AVIODirContext s)

avio_free_directory_entry

@NoException
public static void avio_free_directory_entry(@Cast(value="AVIODirEntry**")
                                                          PointerPointer entry)

Free entry allocated by avio_read_dir().

Parameters:: entry - entry to be freed.

avio_free_directory_entry

@NoException
public static void avio_free_directory_entry(@ByPtrPtr
                                                          AVIODirEntry entry)

avio_alloc_context

@NoException
public static AVIOContext avio_alloc_context(@Cast(value="unsigned char*")
                                                          BytePointer buffer,
                                                          int buffer_size,
                                                          int write_flag,
                                                          Pointer opaque,
                                                          Read_packet_Pointer_BytePointer_int read_packet,
                                                          Write_packet_Pointer_BytePointer_int write_packet,
                                                          Seek_Pointer_long_int seek)

avio_alloc_context

@NoException
public static AVIOContext avio_alloc_context(@Cast(value="unsigned char*")
                                                          ByteBuffer buffer,
                                                          int buffer_size,
                                                          int write_flag,
                                                          Pointer opaque,
                                                          Read_packet_Pointer_ByteBuffer_int read_packet,
                                                          Write_packet_Pointer_ByteBuffer_int write_packet,
                                                          Seek_Pointer_long_int seek)

avio_alloc_context

@NoException
public static AVIOContext avio_alloc_context(@Cast(value="unsigned char*")
                                                          byte[] buffer,
                                                          int buffer_size,
                                                          int write_flag,
                                                          Pointer opaque,
                                                          Read_packet_Pointer_byte___int read_packet,
                                                          Write_packet_Pointer_byte___int write_packet,
                                                          Seek_Pointer_long_int seek)

avio_context_free

@NoException
public static void avio_context_free(@Cast(value="AVIOContext**")
                                                  PointerPointer s)

Free the supplied IO context and everything associated with it.

Parameters:: s - Double pointer to the IO context. This function will write NULL into s.

avio_context_free

@NoException
public static void avio_context_free(@ByPtrPtr
                                                  AVIOContext s)

avio_w8

@NoException
public static void avio_w8(AVIOContext s,
                                        int b)

avio_write

@NoException
public static void avio_write(AVIOContext s,
                                           @Cast(value="const unsigned char*")
                                           BytePointer buf,
                                           int size)

avio_write

@NoException
public static void avio_write(AVIOContext s,
                                           @Cast(value="const unsigned char*")
                                           ByteBuffer buf,
                                           int size)

avio_write

@NoException
public static void avio_write(AVIOContext s,
                                           @Cast(value="const unsigned char*")
                                           byte[] buf,
                                           int size)

avio_wl64

@NoException
public static void avio_wl64(AVIOContext s,
                                          @Cast(value="uint64_t")
                                          long val)

avio_wb64

@NoException
public static void avio_wb64(AVIOContext s,
                                          @Cast(value="uint64_t")
                                          long val)

avio_wl32

@NoException
public static void avio_wl32(AVIOContext s,
                                          @Cast(value="unsigned int")
                                          int val)

avio_wb32

@NoException
public static void avio_wb32(AVIOContext s,
                                          @Cast(value="unsigned int")
                                          int val)

avio_wl24

@NoException
public static void avio_wl24(AVIOContext s,
                                          @Cast(value="unsigned int")
                                          int val)

avio_wb24

@NoException
public static void avio_wb24(AVIOContext s,
                                          @Cast(value="unsigned int")
                                          int val)

avio_wl16

@NoException
public static void avio_wl16(AVIOContext s,
                                          @Cast(value="unsigned int")
                                          int val)

avio_wb16

@NoException
public static void avio_wb16(AVIOContext s,
                                          @Cast(value="unsigned int")
                                          int val)

avio_put_str

@NoException
public static int avio_put_str(AVIOContext s,
                                            @Cast(value="const char*")
                                            BytePointer str)

Write a NULL-terminated string.

Returns:: number of bytes written.

avio_put_str

@NoException
public static int avio_put_str(AVIOContext s,
                                            String str)

avio_put_str16le

@NoException
public static int avio_put_str16le(AVIOContext s,
                                                @Cast(value="const char*")
                                                BytePointer str)

Convert an UTF-8 string to UTF-16LE and write it.

Parameters:: s - the AVIOContext; str - NULL-terminated UTF-8 string
Returns:: number of bytes written.

avio_put_str16le

@NoException
public static int avio_put_str16le(AVIOContext s,
                                                String str)

avio_put_str16be

@NoException
public static int avio_put_str16be(AVIOContext s,
                                                @Cast(value="const char*")
                                                BytePointer str)

Convert an UTF-8 string to UTF-16BE and write it.

Parameters:: s - the AVIOContext; str - NULL-terminated UTF-8 string
Returns:: number of bytes written.

avio_put_str16be

@NoException
public static int avio_put_str16be(AVIOContext s,
                                                String str)

avio_write_marker

@NoException
public static void avio_write_marker(AVIOContext s,
                                                  @Cast(value="int64_t")
                                                  long time,
                                                  @Cast(value="AVIODataMarkerType")
                                                  int type)

Mark the written bytestream as a specific type. Zero-length ranges are omitted from the output.

Parameters:: s - the AVIOContext; time - the stream time the current bytestream pos corresponds to (in AV_TIME_BASE units), or AV_NOPTS_VALUE if unknown or not applicable; type - the kind of data written starting at the current pos

avio_seek

@NoException
 @Cast(value="int64_t")
public static long avio_seek(AVIOContext s,
                                                                  @Cast(value="int64_t")
                                                                  long offset,
                                                                  int whence)

fseek() equivalent for AVIOContext.

Returns:: new position or AVERROR.

avio_skip

@NoException
 @Cast(value="int64_t")
public static long avio_skip(AVIOContext s,
                                                                  @Cast(value="int64_t")
                                                                  long offset)

Skip given number of bytes forward

Returns:: new position or AVERROR.

avio_tell

@NoException
 @Cast(value="int64_t")
public static long avio_tell(AVIOContext s)

ftell() equivalent for AVIOContext.

Returns:: position or AVERROR.

avio_size

@NoException
 @Cast(value="int64_t")
public static long avio_size(AVIOContext s)

Get the filesize.

Returns:: filesize or AVERROR

avio_feof
```
@NoException
public static int avio_feof(AVIOContext s)
```
Similar to feof() but also returns nonzero on read errors.

Returns:

non zero if and only if at end of file or a read error happened when reading.

avio_vprintf

@NoException
public static int avio_vprintf(AVIOContext s,
                                            @Cast(value="const char*")
                                            BytePointer fmt,
                                            @ByVal @Cast(value="va_list*")
                                            Pointer ap)

Writes a formatted string to the context taking a va_list.

Returns:: number of bytes written, < 0 on error.

avio_vprintf

@NoException
public static int avio_vprintf(AVIOContext s,
                                            String fmt,
                                            @ByVal @Cast(value="va_list*")
                                            Pointer ap)

avio_printf

@NoException
public static int avio_printf(AVIOContext s,
                                           @Cast(value="const char*")
                                           BytePointer fmt)

Writes a formatted string to the context.

Returns:: number of bytes written, < 0 on error.

avio_printf

@NoException
public static int avio_printf(AVIOContext s,
                                           String fmt)

avio_print_string_array

@NoException
public static void avio_print_string_array(AVIOContext s,
                                                        @Cast(value="const char*const*")
                                                        PointerPointer strings)

Write a NULL terminated array of strings to the context. Usually you don't need to use this function directly but its macro wrapper, avio_print.

avio_print_string_array

@NoException
public static void avio_print_string_array(AVIOContext s,
                                                        @Cast(value="const char*const*") @ByPtrPtr
                                                        BytePointer strings)

avio_print_string_array

@NoException
public static void avio_print_string_array(AVIOContext s,
                                                        @Cast(value="const char*const*") @ByPtrPtr
                                                        ByteBuffer strings)

avio_print_string_array

@NoException
public static void avio_print_string_array(AVIOContext s,
                                                        @Cast(value="const char*const*") @ByPtrPtr
                                                        byte[] strings)

avio_flush
```
@NoException
public static void avio_flush(AVIOContext s)
```
Force flushing of buffered data. For write streams, force the buffered data to be immediately written to the output, without to wait to fill the internal buffer. For read streams, discard all currently buffered data, and advance the reported file position to that of the underlying stream. This does not read new data, and does not perform any seeks.

avio_read

@NoException
public static int avio_read(AVIOContext s,
                                         @Cast(value="unsigned char*")
                                         BytePointer buf,
                                         int size)

Read size bytes from AVIOContext into buf.

Returns:: number of bytes read or AVERROR

avio_read

@NoException
public static int avio_read(AVIOContext s,
                                         @Cast(value="unsigned char*")
                                         ByteBuffer buf,
                                         int size)

avio_read

@NoException
public static int avio_read(AVIOContext s,
                                         @Cast(value="unsigned char*")
                                         byte[] buf,
                                         int size)

avio_read_partial

@NoException
public static int avio_read_partial(AVIOContext s,
                                                 @Cast(value="unsigned char*")
                                                 BytePointer buf,
                                                 int size)

Read size bytes from AVIOContext into buf. Unlike avio_read(), this is allowed to read fewer bytes than requested. The missing bytes can be read in the next call. This always tries to read at least 1 byte. Useful to reduce latency in certain cases.

Returns:: number of bytes read or AVERROR

avio_read_partial

@NoException
public static int avio_read_partial(AVIOContext s,
                                                 @Cast(value="unsigned char*")
                                                 ByteBuffer buf,
                                                 int size)

avio_read_partial

@NoException
public static int avio_read_partial(AVIOContext s,
                                                 @Cast(value="unsigned char*")
                                                 byte[] buf,
                                                 int size)

avio_r8
```
@NoException
public static int avio_r8(AVIOContext s)
```
\name Functions for reading from AVIOContext \{ \note return 0 if EOF, so you cannot use it if EOF handling is necessary

avio_rl16

@NoException
 @Cast(value="unsigned int")
public static int avio_rl16(AVIOContext s)

avio_rl24

@NoException
 @Cast(value="unsigned int")
public static int avio_rl24(AVIOContext s)

avio_rl32

@NoException
 @Cast(value="unsigned int")
public static int avio_rl32(AVIOContext s)

avio_rl64

@NoException
 @Cast(value="uint64_t")
public static long avio_rl64(AVIOContext s)

avio_rb16

@NoException
 @Cast(value="unsigned int")
public static int avio_rb16(AVIOContext s)

avio_rb24

@NoException
 @Cast(value="unsigned int")
public static int avio_rb24(AVIOContext s)

avio_rb32

@NoException
 @Cast(value="unsigned int")
public static int avio_rb32(AVIOContext s)

avio_rb64

@NoException
 @Cast(value="uint64_t")
public static long avio_rb64(AVIOContext s)

avio_get_str
```
@NoException
public static int avio_get_str(AVIOContext pb,
                                            int maxlen,
                                            @Cast(value="char*")
                                            BytePointer buf,
                                            int buflen)
```
Read a string from pb into buf. The reading will terminate when either a NULL character was encountered, maxlen bytes have been read, or nothing more can be read from pb. The result is guaranteed to be NULL-terminated, it will be truncated if buf is too small. Note that the string is not interpreted or validated in any way, it might get truncated in the middle of a sequence for multi-byte encodings.

Returns:

number of bytes read (is always <= maxlen). If reading ends on EOF or error, the return value will be one more than bytes actually read.

avio_get_str

@NoException
public static int avio_get_str(AVIOContext pb,
                                            int maxlen,
                                            @Cast(value="char*")
                                            ByteBuffer buf,
                                            int buflen)

avio_get_str

@NoException
public static int avio_get_str(AVIOContext pb,
                                            int maxlen,
                                            @Cast(value="char*")
                                            byte[] buf,
                                            int buflen)

avio_get_str16le

@NoException
public static int avio_get_str16le(AVIOContext pb,
                                                int maxlen,
                                                @Cast(value="char*")
                                                BytePointer buf,
                                                int buflen)

Read a UTF-16 string from pb and convert it to UTF-8. The reading will terminate when either a null or invalid character was encountered or maxlen bytes have been read.

Returns:: number of bytes read (is always <= maxlen)

avio_get_str16le

@NoException
public static int avio_get_str16le(AVIOContext pb,
                                                int maxlen,
                                                @Cast(value="char*")
                                                ByteBuffer buf,
                                                int buflen)

avio_get_str16le

@NoException
public static int avio_get_str16le(AVIOContext pb,
                                                int maxlen,
                                                @Cast(value="char*")
                                                byte[] buf,
                                                int buflen)

avio_get_str16be

@NoException
public static int avio_get_str16be(AVIOContext pb,
                                                int maxlen,
                                                @Cast(value="char*")
                                                BytePointer buf,
                                                int buflen)

avio_get_str16be

@NoException
public static int avio_get_str16be(AVIOContext pb,
                                                int maxlen,
                                                @Cast(value="char*")
                                                ByteBuffer buf,
                                                int buflen)

avio_get_str16be

@NoException
public static int avio_get_str16be(AVIOContext pb,
                                                int maxlen,
                                                @Cast(value="char*")
                                                byte[] buf,
                                                int buflen)

avio_open
```
@NoException
public static int avio_open(@Cast(value="AVIOContext**")
                                         PointerPointer s,
                                         @Cast(value="const char*")
                                         BytePointer url,
                                         int flags)
```
Create and initialize a AVIOContext for accessing the resource indicated by url. \note When the resource indicated by url has been opened in read+write mode, the AVIOContext can be used only for writing.

Parameters:

s - Used to return the pointer to the created AVIOContext. In case of failure the pointed to value is set to NULL.

url - resource to access

flags - flags which control how the resource indicated by url is to be opened

Returns:

>= 0 in case of success, a negative value corresponding to an AVERROR code in case of failure

avio_open

@NoException
public static int avio_open(@ByPtrPtr
                                         AVIOContext s,
                                         @Cast(value="const char*")
                                         BytePointer url,
                                         int flags)

avio_open

@NoException
public static int avio_open(@ByPtrPtr
                                         AVIOContext s,
                                         String url,
                                         int flags)

avio_open2

@NoException
public static int avio_open2(@Cast(value="AVIOContext**")
                                          PointerPointer s,
                                          @Cast(value="const char*")
                                          BytePointer url,
                                          int flags,
                                          @Const
                                          AVIOInterruptCB int_cb,
                                          @Cast(value="AVDictionary**")
                                          PointerPointer options)

Create and initialize a AVIOContext for accessing the resource indicated by url. \note When the resource indicated by url has been opened in read+write mode, the AVIOContext can be used only for writing.

Parameters:: s - Used to return the pointer to the created AVIOContext. In case of failure the pointed to value is set to NULL.; url - resource to access; flags - flags which control how the resource indicated by url is to be opened; int_cb - an interrupt callback to be used at the protocols level; options - A dictionary filled with protocol-private options. On return this parameter will be destroyed and replaced with a dict containing options that were not found. May be NULL.
Returns:: >= 0 in case of success, a negative value corresponding to an AVERROR code in case of failure

avio_open2

@NoException
public static int avio_open2(@ByPtrPtr
                                          AVIOContext s,
                                          @Cast(value="const char*")
                                          BytePointer url,
                                          int flags,
                                          @Const
                                          AVIOInterruptCB int_cb,
                                          @ByPtrPtr
                                          AVDictionary options)

avio_open2

@NoException
public static int avio_open2(@ByPtrPtr
                                          AVIOContext s,
                                          String url,
                                          int flags,
                                          @Const
                                          AVIOInterruptCB int_cb,
                                          @ByPtrPtr
                                          AVDictionary options)

avio_close
```
@NoException
public static int avio_close(AVIOContext s)
```
Close the resource accessed by the AVIOContext s and free it. This function can only be used if s was opened by avio_open(). The internal buffer is automatically flushed before closing the resource.

Returns:

0 on success, an AVERROR < 0 on error.

See Also:

avio_closep

avio_closep
```
@NoException
public static int avio_closep(@Cast(value="AVIOContext**")
                                           PointerPointer s)
```
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL. This function can only be used if s was opened by avio_open(). The internal buffer is automatically flushed before closing the resource.

Returns:

0 on success, an AVERROR < 0 on error.

See Also:

avio_close

avio_closep

@NoException
public static int avio_closep(@ByPtrPtr
                                           AVIOContext s)

avio_open_dyn_buf

@NoException
public static int avio_open_dyn_buf(@Cast(value="AVIOContext**")
                                                 PointerPointer s)

Open a write only memory stream.

Parameters:: s - new IO context
Returns:: zero if no error.

avio_open_dyn_buf

@NoException
public static int avio_open_dyn_buf(@ByPtrPtr
                                                 AVIOContext s)

avio_get_dyn_buf

@NoException
public static int avio_get_dyn_buf(AVIOContext s,
                                                @Cast(value="uint8_t**")
                                                PointerPointer pbuffer)

Return the written size and a pointer to the buffer. The AVIOContext stream is left intact. The buffer must NOT be freed. No padding is added to the buffer.

Parameters:: s - IO context; pbuffer - pointer to a byte buffer
Returns:: the length of the byte buffer

avio_get_dyn_buf

@NoException
public static int avio_get_dyn_buf(AVIOContext s,
                                                @Cast(value="uint8_t**") @ByPtrPtr
                                                BytePointer pbuffer)

avio_get_dyn_buf

@NoException
public static int avio_get_dyn_buf(AVIOContext s,
                                                @Cast(value="uint8_t**") @ByPtrPtr
                                                ByteBuffer pbuffer)

avio_get_dyn_buf

@NoException
public static int avio_get_dyn_buf(AVIOContext s,
                                                @Cast(value="uint8_t**") @ByPtrPtr
                                                byte[] pbuffer)

avio_close_dyn_buf

@NoException
public static int avio_close_dyn_buf(AVIOContext s,
                                                  @Cast(value="uint8_t**")
                                                  PointerPointer pbuffer)

Return the written size and a pointer to the buffer. The buffer must be freed with av_free(). Padding of AV_INPUT_BUFFER_PADDING_SIZE is added to the buffer.

Parameters:: s - IO context; pbuffer - pointer to a byte buffer
Returns:: the length of the byte buffer

avio_close_dyn_buf

@NoException
public static int avio_close_dyn_buf(AVIOContext s,
                                                  @Cast(value="uint8_t**") @ByPtrPtr
                                                  BytePointer pbuffer)

avio_close_dyn_buf

@NoException
public static int avio_close_dyn_buf(AVIOContext s,
                                                  @Cast(value="uint8_t**") @ByPtrPtr
                                                  ByteBuffer pbuffer)

avio_close_dyn_buf

@NoException
public static int avio_close_dyn_buf(AVIOContext s,
                                                  @Cast(value="uint8_t**") @ByPtrPtr
                                                  byte[] pbuffer)

avio_enum_protocols
```
@NoException
 @Cast(value="const char*")
public static BytePointer avio_enum_protocols(@Cast(value="void**")
                                                                                       PointerPointer opaque,
                                                                                       int output)
```
Iterate through names of available protocols.

Parameters:

opaque - A private pointer representing current protocol. It must be a pointer to NULL on first iteration and will be updated by successive calls to avio_enum_protocols.

output - If set to 1, iterate over output protocols, otherwise over input protocols.

Returns:

A static string containing the name of current protocol or NULL

avio_enum_protocols

@NoException
 @Cast(value="const char*")
public static BytePointer avio_enum_protocols(@Cast(value="void**") @ByPtrPtr
                                                                                       Pointer opaque,
                                                                                       int output)

avio_protocol_get_class

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

Get AVClass by names of available protocols.

Returns:: A AVClass of input protocol name or NULL

avio_protocol_get_class

@NoException
 @Const
public static AVClass avio_protocol_get_class(String name)

avio_pause
```
@NoException
public static int avio_pause(AVIOContext h,
                                          int pause)
```
Pause and resume playing - only meaningful if using a network streaming protocol (e.g. MMS).

Parameters:

h - IO context from which to call the read_pause function pointer

pause - 1 for pause, 0 for resume

avio_seek_time
```
@NoException
 @Cast(value="int64_t")
public static long avio_seek_time(AVIOContext h,
                                                                       int stream_index,
                                                                       @Cast(value="int64_t")
                                                                       long timestamp,
                                                                       int flags)
```
Seek to a given timestamp relative to some component stream. Only meaningful if using a network streaming protocol (e.g. MMS.).

Parameters:

h - IO context from which to call the seek function pointers

stream_index - The stream index that the timestamp is relative to. If stream_index is (-1) the timestamp should be in AV_TIME_BASE units from the beginning of the presentation. If a stream_index >= 0 is used and the protocol does not support seeking based on component streams, the call will fail.

timestamp - timestamp in AVStream.time_base units or if there is no stream specified then in AV_TIME_BASE units.

flags - Optional combination of AVSEEK_FLAG_BACKWARD, AVSEEK_FLAG_BYTE and AVSEEK_FLAG_ANY. The protocol may silently ignore AVSEEK_FLAG_BACKWARD and AVSEEK_FLAG_ANY, but AVSEEK_FLAG_BYTE will fail if used and not supported.

Returns:

>= 0 on success

See Also:

AVInputFormat::read_seek

avio_read_to_bprint

@NoException
public static int avio_read_to_bprint(AVIOContext h,
                                                   @Cast(value="AVBPrint*")
                                                   Pointer pb,
                                                   @Cast(value="size_t")
                                                   long max_size)

Read contents of h into print buffer, up to max_size bytes, or up to EOF.

Returns:: 0 for success (max_size bytes read or EOF reached), negative error code otherwise

avio_accept

@NoException
public static int avio_accept(AVIOContext s,
                                           @Cast(value="AVIOContext**")
                                           PointerPointer c)

Accept and allocate a client context on a server context.

Parameters:: s - the server context; c - the client context, must be unallocated
Returns:: >= 0 on success or a negative value corresponding to an AVERROR on failure

avio_accept

@NoException
public static int avio_accept(AVIOContext s,
                                           @ByPtrPtr
                                           AVIOContext c)

avio_handshake
```
@NoException
public static int avio_handshake(AVIOContext c)
```
Perform one step of the protocol handshake to accept a new client. This function must be called on a client returned by avio_accept() before using it as a read/write context. It is separate from avio_accept() because it may block. A step of the handshake is defined by places where the application may decide to change the proceedings. For example, on a protocol with a request header and a reply header, each one can constitute a step because the application may use the parameters from the request to change parameters in the reply; or each individual chunk of the request can constitute a step. If the handshake is already finished, avio_handshake() does nothing and returns 0 immediately.

Parameters:

c - the client context to perform the handshake on

Returns:

0 on a complete and successful handshake > 0 if the handshake progressed, but is not complete < 0 for an AVERROR code

av_get_packet

@NoException
public static int av_get_packet(AVIOContext s,
                                             AVPacket pkt,
                                             int size)

Allocate and read the payload of a packet and initialize its fields with default values.

Parameters:: s - associated IO context; pkt - packet; size - desired payload size
Returns:: >0 (read size) if OK, AVERROR_xxx otherwise

av_append_packet
```
@NoException
public static int av_append_packet(AVIOContext s,
                                                AVPacket pkt,
                                                int size)
```
Read data and append it to the current content of the AVPacket. If pkt->size is 0 this is identical to av_get_packet. Note that this uses av_grow_packet and thus involves a realloc which is inefficient. Thus this function should only be used when there is no reasonable way to know (an upper bound of) the final size.

Parameters:

s - associated IO context

pkt - packet

size - amount of data to read

Returns:

>0 (read size) if OK, AVERROR_xxx otherwise, previous data will not be lost even if an error occurs.

AVPROBE_SCORE_RETRY

@MemberGetter
public static int AVPROBE_SCORE_RETRY()

AVPROBE_SCORE_STREAM_RETRY

@MemberGetter
public static int AVPROBE_SCORE_STREAM_RETRY()

av_disposition_from_string

@NoException
public static int av_disposition_from_string(@Cast(value="const char*")
                                                          BytePointer disp)

Returns:: The AV_DISPOSITION_* flag corresponding to disp or a negative error code if disp does not correspond to a known stream disposition.

av_disposition_from_string

@NoException
public static int av_disposition_from_string(String disp)

av_disposition_to_string
```
@NoException
 @Cast(value="const char*")
public static BytePointer av_disposition_to_string(int disposition)
```
Parameters:

disposition - a combination of AV_DISPOSITION_* values

Returns:

The string description corresponding to the lowest set bit in disposition. NULL when the lowest set bit does not correspond to a known disposition or when disposition is 0.

av_stream_get_parser

@NoException
public static AVCodecParserContext av_stream_get_parser(@Const
                                                                     AVStream s)

av_format_inject_global_side_data
```
@NoException
public static void av_format_inject_global_side_data(AVFormatContext s)
```
This function will cause global side data to be injected in the next packet of each stream as well as after any subsequent seek. \note global side data is always available in every AVStream's \ref AVCodecParameters.coded_side_data "codecpar side data" array, and in a \ref AVCodecContext.coded_side_data "decoder's side data" array if initialized with said stream's codecpar.

See Also:

av_packet_side_data_get()

av_fmt_ctx_get_duration_estimation_method

@NoException
 @Cast(value="AVDurationEstimationMethod")
 @Deprecated
public static int av_fmt_ctx_get_duration_estimation_method(@Const
                                                                                                                                 AVFormatContext ctx)

Deprecated. duration_estimation_method is public and can be read directly.

Returns the method used to set ctx->duration.

Returns:: AVFMT_DURATION_FROM_PTS, AVFMT_DURATION_FROM_STREAM, or AVFMT_DURATION_FROM_BITRATE.

avformat_version

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

Return the LIBAVFORMAT_VERSION_INT constant.

avformat_configuration

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

Return the libavformat build-time configuration.

avformat_license

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

Return the libavformat license.

avformat_network_init
```
@NoException
public static int avformat_network_init()
```
Do global initialization of network libraries. This is optional, and not recommended anymore. This functions only exists to work around thread-safety issues with older GnuTLS or OpenSSL libraries. If libavformat is linked to newer versions of those libraries, or if you do not use them, calling this function is unnecessary. Otherwise, you need to call this function before any other threads using them are started. This function will be deprecated once support for older GnuTLS and OpenSSL libraries is removed, and this function has no purpose anymore.

avformat_network_deinit
```
@NoException
public static int avformat_network_deinit()
```
Undo the initialization done by avformat_network_init. Call it only once for each time you called avformat_network_init.

av_muxer_iterate
```
@NoException
 @Const
public static AVOutputFormat av_muxer_iterate(@Cast(value="void**")
                                                                   PointerPointer opaque)
```
Iterate over all registered muxers.

Parameters:

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

Returns:

the next registered muxer or NULL when the iteration is finished

av_muxer_iterate

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

av_demuxer_iterate
```
@NoException
 @Const
public static AVInputFormat av_demuxer_iterate(@Cast(value="void**")
                                                                    PointerPointer opaque)
```
Iterate over all registered demuxers.

Parameters:

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

Returns:

the next registered demuxer or NULL when the iteration is finished

av_demuxer_iterate

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

avformat_alloc_context
```
@NoException
public static AVFormatContext avformat_alloc_context()
```
Allocate an AVFormatContext. avformat_free_context() can be used to free the context and everything allocated by the framework within it.

avformat_free_context
```
@NoException
public static void avformat_free_context(AVFormatContext s)
```
Free an AVFormatContext and all its streams.

Parameters:

s - context to free

avformat_get_class
```
@NoException
 @Const
public static AVClass avformat_get_class()
```
Get the AVClass for AVFormatContext. It can be used in combination with AV_OPT_SEARCH_FAKE_OBJ for examining options.

See Also:

av_opt_find().

av_stream_get_class
```
@NoException
 @Const
public static AVClass av_stream_get_class()
```
Get the AVClass for AVStream. It can be used in combination with AV_OPT_SEARCH_FAKE_OBJ for examining options.

See Also:

av_opt_find().

av_stream_group_get_class
```
@NoException
 @Const
public static AVClass av_stream_group_get_class()
```
Get the AVClass for AVStreamGroup. It can be used in combination with AV_OPT_SEARCH_FAKE_OBJ for examining options.

See Also:

av_opt_find().

avformat_stream_group_name

@NoException
 @Cast(value="const char*")
public static BytePointer avformat_stream_group_name(@Cast(value="AVStreamGroupParamsType")
                                                                                              int type)

Returns:: a string identifying the stream group type, or NULL if unknown

avformat_stream_group_create

@NoException
public static AVStreamGroup avformat_stream_group_create(AVFormatContext s,
                                                                      @Cast(value="AVStreamGroupParamsType")
                                                                      int type,
                                                                      @Cast(value="AVDictionary**")
                                                                      PointerPointer options)

Add a new empty stream group to a media file. When demuxing, it may be called by the demuxer in read_header(). If the flag AVFMTCTX_NOHEADER is set in s.ctx_flags, then it may also be called in read_packet(). When muxing, may be called by the user before avformat_write_header(). User is required to call avformat_free_context() to clean up the allocation by avformat_stream_group_create(). New streams can be added to the group with avformat_stream_group_add_stream().

Parameters:: s - media file handle
Returns:: newly created group or NULL on error.
See Also:: avformat_new_stream, avformat_stream_group_add_stream.

avformat_stream_group_create

@NoException
public static AVStreamGroup avformat_stream_group_create(AVFormatContext s,
                                                                      @Cast(value="AVStreamGroupParamsType")
                                                                      int type,
                                                                      @ByPtrPtr
                                                                      AVDictionary options)

avformat_new_stream
```
@NoException
public static AVStream avformat_new_stream(AVFormatContext s,
                                                        @Const
                                                        AVCodec c)
```
Add a new stream to a media file. When demuxing, it is called by the demuxer in read_header(). If the flag AVFMTCTX_NOHEADER is set in s.ctx_flags, then it may also be called in read_packet(). When muxing, should be called by the user before avformat_write_header(). User is required to call avformat_free_context() to clean up the allocation by avformat_new_stream().

Parameters:

s - media file handle

c - unused, does nothing

Returns:

newly created stream or NULL on error.

avformat_stream_group_add_stream
```
@NoException
public static int avformat_stream_group_add_stream(AVStreamGroup stg,
                                                                AVStream st)
```
Add an already allocated stream to a stream group. When demuxing, it may be called by the demuxer in read_header(). If the flag AVFMTCTX_NOHEADER is set in s.ctx_flags, then it may also be called in read_packet(). When muxing, may be called by the user before avformat_write_header() after having allocated a new group with avformat_stream_group_create() and stream with avformat_new_stream(). User is required to call avformat_free_context() to clean up the allocation by avformat_stream_group_add_stream().

Parameters:

stg - stream group belonging to a media file.

st - stream in the media file to add to the group. \retval 0 success \retval AVERROR(EEXIST) the stream was already in the group \retval "another negative error code" legitimate errors

See Also:

avformat_new_stream, avformat_stream_group_create.

av_stream_add_side_data

@NoException
 @Deprecated
public static int av_stream_add_side_data(AVStream st,
                                                                    @Cast(value="AVPacketSideDataType")
                                                                    int type,
                                                                    @Cast(value="uint8_t*")
                                                                    BytePointer data,
                                                                    @Cast(value="size_t")
                                                                    long size)

Deprecated. use av_packet_side_data_add() with the stream's \ref AVCodecParameters.coded_side_data "codecpar side data"

Wrap an existing array as stream side data.

Parameters:: st - stream; type - side information type; data - the side data array. It must be allocated with the av_malloc() family of functions. The ownership of the data is transferred to st.; size - side information size
Returns:: zero on success, a negative AVERROR code on failure. On failure, the stream is unchanged and the data remains owned by the caller.

av_stream_add_side_data

@NoException
 @Deprecated
public static int av_stream_add_side_data(AVStream st,
                                                                    @Cast(value="AVPacketSideDataType")
                                                                    int type,
                                                                    @Cast(value="uint8_t*")
                                                                    ByteBuffer data,
                                                                    @Cast(value="size_t")
                                                                    long size)

Deprecated.

av_stream_add_side_data

@NoException
 @Deprecated
public static int av_stream_add_side_data(AVStream st,
                                                                    @Cast(value="AVPacketSideDataType")
                                                                    int type,
                                                                    @Cast(value="uint8_t*")
                                                                    byte[] data,
                                                                    @Cast(value="size_t")
                                                                    long size)

Deprecated.

av_stream_new_side_data

@NoException
 @Cast(value="uint8_t*")
 @Deprecated
public static BytePointer av_stream_new_side_data(AVStream stream,
                                                                                                     @Cast(value="AVPacketSideDataType")
                                                                                                     int type,
                                                                                                     @Cast(value="size_t")
                                                                                                     long size)

Deprecated. use av_packet_side_data_new() with the stream's \ref AVCodecParameters.coded_side_data "codecpar side data"

Allocate new information from stream.

Parameters:: stream - stream; type - desired side information type; size - side information size
Returns:: pointer to fresh allocated data or NULL otherwise

av_stream_get_side_data

@NoException
 @Cast(value="uint8_t*")
 @Deprecated
public static BytePointer av_stream_get_side_data(@Const
                                                                                                     AVStream stream,
                                                                                                     @Cast(value="AVPacketSideDataType")
                                                                                                     int type,
                                                                                                     @Cast(value="size_t*")
                                                                                                     SizeTPointer size)

Deprecated. use av_packet_side_data_get() with the stream's \ref AVCodecParameters.coded_side_data "codecpar side data"

Get side information from stream.

Parameters:: stream - stream; type - desired side information type; size - If supplied, *size will be set to the size of the side data or to zero if the desired side data is not present.
Returns:: pointer to data if present or NULL otherwise

av_new_program

@NoException
public static AVProgram av_new_program(AVFormatContext s,
                                                    int id)

avformat_alloc_output_context2

@NoException
public static int avformat_alloc_output_context2(@Cast(value="AVFormatContext**")
                                                              PointerPointer ctx,
                                                              @Const
                                                              AVOutputFormat oformat,
                                                              @Cast(value="const char*")
                                                              BytePointer format_name,
                                                              @Cast(value="const char*")
                                                              BytePointer filename)

Allocate an AVFormatContext for an output format. avformat_free_context() can be used to free the context and everything allocated by the framework within it.

Parameters:: ctx - pointee is set to the created format context, or to NULL in case of failure; oformat - format to use for allocating the context, if NULL format_name and filename are used instead; format_name - the name of output format to use for allocating the context, if NULL filename is used instead; filename - the name of the filename to use for allocating the context, may be NULL
Returns:: >= 0 in case of success, a negative AVERROR code in case of failure

avformat_alloc_output_context2

@NoException
public static int avformat_alloc_output_context2(@ByPtrPtr
                                                              AVFormatContext ctx,
                                                              @Const
                                                              AVOutputFormat oformat,
                                                              @Cast(value="const char*")
                                                              BytePointer format_name,
                                                              @Cast(value="const char*")
                                                              BytePointer filename)

avformat_alloc_output_context2

@NoException
public static int avformat_alloc_output_context2(@ByPtrPtr
                                                              AVFormatContext ctx,
                                                              @Const
                                                              AVOutputFormat oformat,
                                                              String format_name,
                                                              String filename)

av_find_input_format

@NoException
 @Const
public static AVInputFormat av_find_input_format(@Cast(value="const char*")
                                                                      BytePointer short_name)

Find AVInputFormat based on the short name of the input format.

av_find_input_format

@NoException
 @Const
public static AVInputFormat av_find_input_format(String short_name)

av_probe_input_format

@NoException
 @Const
public static AVInputFormat av_probe_input_format(@Const
                                                                       AVProbeData pd,
                                                                       int is_opened)

Guess the file format.

Parameters:: pd - data to be probed; is_opened - Whether the file is already opened; determines whether demuxers with or without AVFMT_NOFILE are probed.

av_probe_input_format2
```
@NoException
 @Const
public static AVInputFormat av_probe_input_format2(@Const
                                                                        AVProbeData pd,
                                                                        int is_opened,
                                                                        IntPointer score_max)
```
Guess the file format.

Parameters:

pd - data to be probed

is_opened - Whether the file is already opened; determines whether demuxers with or without AVFMT_NOFILE are probed.

score_max - A probe score larger that this is required to accept a detection, the variable is set to the actual detection score afterwards. If the score is <= AVPROBE_SCORE_MAX / 4 it is recommended to retry with a larger probe buffer.

av_probe_input_format2

@NoException
 @Const
public static AVInputFormat av_probe_input_format2(@Const
                                                                        AVProbeData pd,
                                                                        int is_opened,
                                                                        IntBuffer score_max)

av_probe_input_format2

@NoException
 @Const
public static AVInputFormat av_probe_input_format2(@Const
                                                                        AVProbeData pd,
                                                                        int is_opened,
                                                                        int[] score_max)

av_probe_input_format3

@NoException
 @Const
public static AVInputFormat av_probe_input_format3(@Const
                                                                        AVProbeData pd,
                                                                        int is_opened,
                                                                        IntPointer score_ret)

Guess the file format.

Parameters:: is_opened - Whether the file is already opened; determines whether demuxers with or without AVFMT_NOFILE are probed.; score_ret - The score of the best detection.

av_probe_input_format3

@NoException
 @Const
public static AVInputFormat av_probe_input_format3(@Const
                                                                        AVProbeData pd,
                                                                        int is_opened,
                                                                        IntBuffer score_ret)

av_probe_input_format3

@NoException
 @Const
public static AVInputFormat av_probe_input_format3(@Const
                                                                        AVProbeData pd,
                                                                        int is_opened,
                                                                        int[] score_ret)

av_probe_input_buffer2

@NoException
public static int av_probe_input_buffer2(AVIOContext pb,
                                                      @Cast(value="const AVInputFormat**")
                                                      PointerPointer fmt,
                                                      @Cast(value="const char*")
                                                      BytePointer url,
                                                      Pointer logctx,
                                                      @Cast(value="unsigned int")
                                                      int offset,
                                                      @Cast(value="unsigned int")
                                                      int max_probe_size)

Probe a bytestream to determine the input format. Each time a probe returns with a score that is too low, the probe buffer size is increased and another attempt is made. When the maximum probe size is reached, the input format with the highest score is returned.

Parameters:: pb - the bytestream to probe; fmt - the input format is put here; url - the url of the stream; logctx - the log context; offset - the offset within the bytestream to probe from; max_probe_size - the maximum probe buffer size (zero for default)
Returns:: the score in case of success, a negative value corresponding to an the maximal score is AVPROBE_SCORE_MAX AVERROR code otherwise

av_probe_input_buffer2

@NoException
public static int av_probe_input_buffer2(AVIOContext pb,
                                                      @Const @ByPtrPtr
                                                      AVInputFormat fmt,
                                                      @Cast(value="const char*")
                                                      BytePointer url,
                                                      Pointer logctx,
                                                      @Cast(value="unsigned int")
                                                      int offset,
                                                      @Cast(value="unsigned int")
                                                      int max_probe_size)

av_probe_input_buffer2

@NoException
public static int av_probe_input_buffer2(AVIOContext pb,
                                                      @Const @ByPtrPtr
                                                      AVInputFormat fmt,
                                                      String url,
                                                      Pointer logctx,
                                                      @Cast(value="unsigned int")
                                                      int offset,
                                                      @Cast(value="unsigned int")
                                                      int max_probe_size)

av_probe_input_buffer

@NoException
public static int av_probe_input_buffer(AVIOContext pb,
                                                     @Cast(value="const AVInputFormat**")
                                                     PointerPointer fmt,
                                                     @Cast(value="const char*")
                                                     BytePointer url,
                                                     Pointer logctx,
                                                     @Cast(value="unsigned int")
                                                     int offset,
                                                     @Cast(value="unsigned int")
                                                     int max_probe_size)

Like av_probe_input_buffer2() but returns 0 on success

av_probe_input_buffer

@NoException
public static int av_probe_input_buffer(AVIOContext pb,
                                                     @Const @ByPtrPtr
                                                     AVInputFormat fmt,
                                                     @Cast(value="const char*")
                                                     BytePointer url,
                                                     Pointer logctx,
                                                     @Cast(value="unsigned int")
                                                     int offset,
                                                     @Cast(value="unsigned int")
                                                     int max_probe_size)

av_probe_input_buffer

@NoException
public static int av_probe_input_buffer(AVIOContext pb,
                                                     @Const @ByPtrPtr
                                                     AVInputFormat fmt,
                                                     String url,
                                                     Pointer logctx,
                                                     @Cast(value="unsigned int")
                                                     int offset,
                                                     @Cast(value="unsigned int")
                                                     int max_probe_size)

avformat_open_input
```
@NoException
public static int avformat_open_input(@Cast(value="AVFormatContext**")
                                                   PointerPointer ps,
                                                   @Cast(value="const char*")
                                                   BytePointer url,
                                                   @Const
                                                   AVInputFormat fmt,
                                                   @Cast(value="AVDictionary**")
                                                   PointerPointer options)
```
Open an input stream and read the header. The codecs are not opened. The stream must be closed with avformat_close_input().

Parameters:

ps - Pointer to user-supplied AVFormatContext (allocated by avformat_alloc_context). May be a pointer to NULL, in which case an AVFormatContext is allocated by this function and written into ps. Note that a user-supplied AVFormatContext will be freed on failure.

url - URL of the stream to open.

fmt - If non-NULL, this parameter forces a specific input format. Otherwise the format is autodetected.

options - A dictionary filled with AVFormatContext and demuxer-private options. On return this parameter will be destroyed and replaced with a dict containing options that were not found. May be NULL.

Returns:

0 on success, a negative AVERROR on failure. \note If you want to use custom IO, preallocate the format context and set its pb field.

avformat_open_input

@NoException
public static int avformat_open_input(@ByPtrPtr
                                                   AVFormatContext ps,
                                                   @Cast(value="const char*")
                                                   BytePointer url,
                                                   @Const
                                                   AVInputFormat fmt,
                                                   @ByPtrPtr
                                                   AVDictionary options)

avformat_open_input

@NoException
public static int avformat_open_input(@ByPtrPtr
                                                   AVFormatContext ps,
                                                   String url,
                                                   @Const
                                                   AVInputFormat fmt,
                                                   @ByPtrPtr
                                                   AVDictionary options)

avformat_find_stream_info
```
@NoException
public static int avformat_find_stream_info(AVFormatContext ic,
                                                         @Cast(value="AVDictionary**")
                                                         PointerPointer options)
```
Read packets of a media file to get stream information. This is useful for file formats with no headers such as MPEG. This function also computes the real framerate in case of MPEG-2 repeat frame mode. The logical file position is not changed by this function; examined packets may be buffered for later processing.

Parameters:

ic - media file handle

options - If non-NULL, an ic.nb_streams long array of pointers to dictionaries, where i-th member contains options for codec corresponding to i-th stream. On return each dictionary will be filled with options that were not found.

Returns:

>=0 if OK, AVERROR_xxx on error \note this function isn't guaranteed to open all the codecs, so options being non-empty at return is a perfectly normal behavior. \todo Let the user decide somehow what information is needed so that we do not waste time getting stuff the user does not need.

avformat_find_stream_info

@NoException
public static int avformat_find_stream_info(AVFormatContext ic,
                                                         @ByPtrPtr
                                                         AVDictionary options)

av_find_program_from_stream
```
@NoException
public static AVProgram av_find_program_from_stream(AVFormatContext ic,
                                                                 AVProgram last,
                                                                 int s)
```
Find the programs which belong to a given stream.

Parameters:

ic - media file handle

last - the last found program, the search will start after this program, or from the beginning if it is NULL

s - stream index

Returns:

the next program which belongs to s, NULL if no program is found or the last program is not among the programs of ic.

av_program_add_stream_index

@NoException
public static void av_program_add_stream_index(AVFormatContext ac,
                                                            int progid,
                                                            @Cast(value="unsigned int")
                                                            int idx)

av_find_best_stream
```
@NoException
public static int av_find_best_stream(AVFormatContext ic,
                                                   @Cast(value="AVMediaType")
                                                   int type,
                                                   int wanted_stream_nb,
                                                   int related_stream,
                                                   @Cast(value="const AVCodec**")
                                                   PointerPointer decoder_ret,
                                                   int flags)
```
Find the "best" stream in the file. The best stream is determined according to various heuristics as the most likely to be what the user expects. If the decoder parameter is non-NULL, av_find_best_stream will find the default decoder for the stream's codec; streams for which no decoder can be found are ignored.

Parameters:

ic - media file handle

type - stream type: video, audio, subtitles, etc.

wanted_stream_nb - user-requested stream number, or -1 for automatic selection

related_stream - try to find a stream related (eg. in the same program) to this one, or -1 if none

decoder_ret - if non-NULL, returns the decoder for the selected stream

flags - flags; none are currently defined

Returns:

the non-negative stream number in case of success, AVERROR_STREAM_NOT_FOUND if no stream with the requested type could be found, AVERROR_DECODER_NOT_FOUND if streams were found but no decoder \note If av_find_best_stream returns successfully and decoder_ret is not NULL, then *decoder_ret is guaranteed to be set to a valid AVCodec.

av_find_best_stream

@NoException
public static int av_find_best_stream(AVFormatContext ic,
                                                   @Cast(value="AVMediaType")
                                                   int type,
                                                   int wanted_stream_nb,
                                                   int related_stream,
                                                   @Const @ByPtrPtr
                                                   AVCodec decoder_ret,
                                                   int flags)

av_read_frame
```
@NoException
public static int av_read_frame(AVFormatContext s,
                                             AVPacket pkt)
```
Return the next frame of a stream. This function returns what is stored in the file, and does not validate that what is there are valid frames for the decoder. It will split what is stored in the file into frames and return one for each call. It will not omit invalid data between valid frames so as to give the decoder the maximum information possible for decoding. On success, the returned packet is reference-counted (pkt->buf is set) and valid indefinitely. The packet must be freed with av_packet_unref() when it is no longer needed. For video, the packet contains exactly one frame. For audio, it contains an integer number of frames if each frame has a known fixed size (e.g. PCM or ADPCM data). If the audio frames have a variable size (e.g. MPEG audio), then it contains one frame. pkt->pts, pkt->dts and pkt->duration are always set to correct values in AVStream.time_base units (and guessed if the format cannot provide them). pkt->pts can be AV_NOPTS_VALUE if the video format has B-frames, so it is better to rely on pkt->dts if you do not decompress the payload.

Returns:

0 if OK, < 0 on error or end of file. On error, pkt will be blank (as if it came from av_packet_alloc()). \note pkt will be initialized, so it may be uninitialized, but it must not contain data that needs to be freed.

av_seek_frame
```
@NoException
public static int av_seek_frame(AVFormatContext s,
                                             int stream_index,
                                             @Cast(value="int64_t")
                                             long timestamp,
                                             int flags)
```
Seek to the keyframe at timestamp. 'timestamp' in 'stream_index'.

Parameters:

s - media file handle

stream_index - If stream_index is (-1), a default stream is selected, and timestamp is automatically converted from AV_TIME_BASE units to the stream specific time_base.

timestamp - Timestamp in AVStream.time_base units or, if no stream is specified, in AV_TIME_BASE units.

flags - flags which select direction and seeking mode

Returns:

>= 0 on success

avformat_seek_file
```
@NoException
public static int avformat_seek_file(AVFormatContext s,
                                                  int stream_index,
                                                  @Cast(value="int64_t")
                                                  long min_ts,
                                                  @Cast(value="int64_t")
                                                  long ts,
                                                  @Cast(value="int64_t")
                                                  long max_ts,
                                                  int flags)
```
Seek to timestamp ts. Seeking will be done so that the point from which all active streams can be presented successfully will be closest to ts and within min/max_ts. Active streams are all streams that have AVStream.discard < AVDISCARD_ALL. If flags contain AVSEEK_FLAG_BYTE, then all timestamps are in bytes and are the file position (this may not be supported by all demuxers). If flags contain AVSEEK_FLAG_FRAME, then all timestamps are in frames in the stream with stream_index (this may not be supported by all demuxers). Otherwise all timestamps are in units of the stream selected by stream_index or if stream_index is -1, in AV_TIME_BASE units. If flags contain AVSEEK_FLAG_ANY, then non-keyframes are treated as keyframes (this may not be supported by all demuxers). If flags contain AVSEEK_FLAG_BACKWARD, it is ignored.

Parameters:

s - media file handle

stream_index - index of the stream which is used as time base reference

min_ts - smallest acceptable timestamp

ts - target timestamp

max_ts - largest acceptable timestamp

flags - flags

Returns:

>=0 on success, error code otherwise \note This is part of the new seek API which is still under construction.

avformat_flush
```
@NoException
public static int avformat_flush(AVFormatContext s)
```
Discard all internally buffered data. This can be useful when dealing with discontinuities in the byte stream. Generally works only with formats that can resync. This includes headerless formats like MPEG-TS/TS but should also work with NUT, Ogg and in a limited way AVI for example. The set of streams, the detected duration, stream parameters and codecs do not change when calling this function. If you want a complete reset, it's better to open a new AVFormatContext. This does not flush the AVIOContext (s->pb). If necessary, call avio_flush(s->pb) before calling this function.

Parameters:

s - media file handle

Returns:

>=0 on success, error code otherwise

av_read_play
```
@NoException
public static int av_read_play(AVFormatContext s)
```
Start playing a network-based stream (e.g. RTSP stream) at the current position.

av_read_pause
```
@NoException
public static int av_read_pause(AVFormatContext s)
```
Pause a network-based stream (e.g. RTSP stream). Use av_read_play() to resume it.

avformat_close_input

@NoException
public static void avformat_close_input(@Cast(value="AVFormatContext**")
                                                     PointerPointer s)

Close an opened input AVFormatContext. Free it and all its contents and set *s to NULL.

avformat_close_input

@NoException
public static void avformat_close_input(@ByPtrPtr
                                                     AVFormatContext s)

avformat_write_header
```
@NoException
public static int avformat_write_header(AVFormatContext s,
                                                     @Cast(value="AVDictionary**")
                                                     PointerPointer options)
```
Allocate the stream private data and write the stream header to an output media file.

Parameters:

s - Media file handle, must be allocated with avformat_alloc_context(). Its \ref AVFormatContext.oformat "oformat" field must be set to the desired output format; Its \ref AVFormatContext.pb "pb" field must be set to an already opened ::AVIOContext.

options - An ::AVDictionary filled with AVFormatContext and muxer-private options. On return this parameter will be destroyed and replaced with a dict containing options that were not found. May be NULL. \retval AVSTREAM_INIT_IN_WRITE_HEADER On success, if the codec had not already been fully initialized in avformat_init_output(). \retval AVSTREAM_INIT_IN_INIT_OUTPUT On success, if the codec had already been fully initialized in avformat_init_output(). \retval AVERROR A negative AVERROR on failure.

See Also:

av_opt_find, av_dict_set, avio_open, av_oformat_next, avformat_init_output.

avformat_write_header

@NoException
public static int avformat_write_header(AVFormatContext s,
                                                     @ByPtrPtr
                                                     AVDictionary options)

avformat_init_output
```
@NoException
public static int avformat_init_output(AVFormatContext s,
                                                    @Cast(value="AVDictionary**")
                                                    PointerPointer options)
```
Allocate the stream private data and initialize the codec, but do not write the header. May optionally be used before avformat_write_header() to initialize stream parameters before actually writing the header. If using this function, do not pass the same options to avformat_write_header().

Parameters:

s - Media file handle, must be allocated with avformat_alloc_context(). Its \ref AVFormatContext.oformat "oformat" field must be set to the desired output format; Its \ref AVFormatContext.pb "pb" field must be set to an already opened ::AVIOContext.

options - An ::AVDictionary filled with AVFormatContext and muxer-private options. On return this parameter will be destroyed and replaced with a dict containing options that were not found. May be NULL. \retval AVSTREAM_INIT_IN_WRITE_HEADER On success, if the codec requires avformat_write_header to fully initialize. \retval AVSTREAM_INIT_IN_INIT_OUTPUT On success, if the codec has been fully initialized. \retval AVERROR Anegative AVERROR on failure.

See Also:

av_opt_find, av_dict_set, avio_open, av_oformat_next, avformat_write_header.

avformat_init_output

@NoException
public static int avformat_init_output(AVFormatContext s,
                                                    @ByPtrPtr
                                                    AVDictionary options)

av_write_frame
```
@NoException
public static int av_write_frame(AVFormatContext s,
                                              AVPacket pkt)
```
Write a packet to an output media file. This function passes the packet directly to the muxer, without any buffering or reordering. The caller is responsible for correctly interleaving the packets if the format requires it. Callers that want libavformat to handle the interleaving should call av_interleaved_write_frame() instead of this function.

Parameters:

s - media file handle

pkt - The packet containing the data to be written. Note that unlike av_interleaved_write_frame(), this function does not take ownership of the packet passed to it (though some muxers may make an internal reference to the input packet).
This parameter can be NULL (at any time, not just at the end), in order to immediately flush data buffered within the muxer, for muxers that buffer up data internally before writing it to the output.
Packet's \ref AVPacket.stream_index "stream_index" field must be set to the index of the corresponding stream in \ref AVFormatContext.streams "s->streams".
The timestamps (\ref AVPacket.pts "pts", \ref AVPacket.dts "dts") must be set to correct values in the stream's timebase (unless the output format is flagged with the AVFMT_NOTIMESTAMPS flag, then they can be set to AV_NOPTS_VALUE). The dts for subsequent packets passed to this function must be strictly increasing when compared in their respective timebases (unless the output format is flagged with the AVFMT_TS_NONSTRICT, then they merely have to be nondecreasing). \ref AVPacket.duration "duration") should also be set if known.

Returns:

< 0 on error, = 0 if OK, 1 if flushed and there is no more data to flush

See Also:

av_interleaved_write_frame()

av_interleaved_write_frame
```
@NoException
public static int av_interleaved_write_frame(AVFormatContext s,
                                                          AVPacket pkt)
```
Write a packet to an output media file ensuring correct interleaving. This function will buffer the packets internally as needed to make sure the packets in the output file are properly interleaved, usually ordered by increasing dts. Callers doing their own interleaving should call av_write_frame() instead of this function. Using this function instead of av_write_frame() can give muxers advance knowledge of future packets, improving e.g. the behaviour of the mp4 muxer for VFR content in fragmenting mode.

Parameters:

s - media file handle

pkt - The packet containing the data to be written.
If the packet is reference-counted, this function will take ownership of this reference and unreference it later when it sees fit. If the packet is not reference-counted, libavformat will make a copy. The returned packet will be blank (as if returned from av_packet_alloc()), even on error.
This parameter can be NULL (at any time, not just at the end), to flush the interleaving queues.
Packet's \ref AVPacket.stream_index "stream_index" field must be set to the index of the corresponding stream in \ref AVFormatContext.streams "s->streams".
The timestamps (\ref AVPacket.pts "pts", \ref AVPacket.dts "dts") must be set to correct values in the stream's timebase (unless the output format is flagged with the AVFMT_NOTIMESTAMPS flag, then they can be set to AV_NOPTS_VALUE). The dts for subsequent packets in one stream must be strictly increasing (unless the output format is flagged with the AVFMT_TS_NONSTRICT, then they merely have to be nondecreasing). \ref AVPacket.duration "duration" should also be set if known.

Returns:

0 on success, a negative AVERROR on error.

See Also:

av_write_frame(), AVFormatContext.max_interleave_delta

av_write_uncoded_frame

@NoException
public static int av_write_uncoded_frame(AVFormatContext s,
                                                      int stream_index,
                                                      AVFrame frame)

Write an uncoded frame to an output media file. The frame must be correctly interleaved according to the container specification; if not, av_interleaved_write_uncoded_frame() must be used. See av_interleaved_write_uncoded_frame() for details.

av_interleaved_write_uncoded_frame
```
@NoException
public static int av_interleaved_write_uncoded_frame(AVFormatContext s,
                                                                  int stream_index,
                                                                  AVFrame frame)
```
Write an uncoded frame to an output media file. If the muxer supports it, this function makes it possible to write an AVFrame structure directly, without encoding it into a packet. It is mostly useful for devices and similar special muxers that use raw video or PCM data and will not serialize it into a byte stream. To test whether it is possible to use it with a given muxer and stream, use av_write_uncoded_frame_query(). The caller gives up ownership of the frame and must not access it afterwards.

Returns:

>=0 for success, a negative code on error

av_write_uncoded_frame_query
```
@NoException
public static int av_write_uncoded_frame_query(AVFormatContext s,
                                                            int stream_index)
```
Test whether a muxer supports uncoded frame.

Returns:

>=0 if an uncoded frame can be written to that muxer and stream, <0 if not

av_write_trailer
```
@NoException
public static int av_write_trailer(AVFormatContext s)
```
Write the stream trailer to an output media file and free the file private data. May only be called after a successful call to avformat_write_header.

Parameters:

s - media file handle

Returns:

0 if OK, AVERROR_xxx on error

av_guess_format

@NoException
 @Const
public static AVOutputFormat av_guess_format(@Cast(value="const char*")
                                                                  BytePointer short_name,
                                                                  @Cast(value="const char*")
                                                                  BytePointer filename,
                                                                  @Cast(value="const char*")
                                                                  BytePointer mime_type)

Return the output format in the list of registered output formats which best matches the provided parameters, or return NULL if there is no match.

Parameters:: short_name - if non-NULL checks if short_name matches with the names of the registered formats; filename - if non-NULL checks if filename terminates with the extensions of the registered formats; mime_type - if non-NULL checks if mime_type matches with the MIME type of the registered formats

av_guess_format

@NoException
 @Const
public static AVOutputFormat av_guess_format(String short_name,
                                                                  String filename,
                                                                  String mime_type)

av_guess_codec

@NoException
 @Cast(value="AVCodecID")
public static int av_guess_codec(@Const
                                                                        AVOutputFormat fmt,
                                                                        @Cast(value="const char*")
                                                                        BytePointer short_name,
                                                                        @Cast(value="const char*")
                                                                        BytePointer filename,
                                                                        @Cast(value="const char*")
                                                                        BytePointer mime_type,
                                                                        @Cast(value="AVMediaType")
                                                                        int type)

Guess the codec ID based upon muxer and filename.

av_guess_codec

@NoException
 @Cast(value="AVCodecID")
public static int av_guess_codec(@Const
                                                                        AVOutputFormat fmt,
                                                                        String short_name,
                                                                        String filename,
                                                                        String mime_type,
                                                                        @Cast(value="AVMediaType")
                                                                        int type)

av_get_output_timestamp

@NoException
public static int av_get_output_timestamp(AVFormatContext s,
                                                       int stream,
                                                       @Cast(value="int64_t*")
                                                       LongPointer dts,
                                                       @Cast(value="int64_t*")
                                                       LongPointer wall)

Get timing information for the data currently output. The exact meaning of "currently output" depends on the format. It is mostly relevant for devices that have an internal buffer and/or work in real time.

Parameters:: s - media file handle; stream - stream in the media file; dts - [out] DTS of the last packet output for the stream, in stream time_base units; wall - [out] absolute time when that packet whas output, in microsecond \retval 0 Success \retval AVERROR(ENOSYS) The format does not support it \note Some formats or devices may not allow to measure dts and wall atomically.

av_get_output_timestamp

@NoException
public static int av_get_output_timestamp(AVFormatContext s,
                                                       int stream,
                                                       @Cast(value="int64_t*")
                                                       LongBuffer dts,
                                                       @Cast(value="int64_t*")
                                                       LongBuffer wall)

av_get_output_timestamp

@NoException
public static int av_get_output_timestamp(AVFormatContext s,
                                                       int stream,
                                                       @Cast(value="int64_t*")
                                                       long[] dts,
                                                       @Cast(value="int64_t*")
                                                       long[] wall)

av_hex_dump

@NoException
public static void av_hex_dump(@Cast(value="FILE*")
                                            Pointer f,
                                            @Cast(value="const uint8_t*")
                                            BytePointer buf,
                                            int size)

Send a nice hexadecimal dump of a buffer to the specified file stream.

Parameters:: f - The file stream pointer where the dump should be sent to.; buf - buffer; size - buffer size
See Also:: av_hex_dump_log, av_pkt_dump2, av_pkt_dump_log2

av_hex_dump

@NoException
public static void av_hex_dump(@Cast(value="FILE*")
                                            Pointer f,
                                            @Cast(value="const uint8_t*")
                                            ByteBuffer buf,
                                            int size)

av_hex_dump

@NoException
public static void av_hex_dump(@Cast(value="FILE*")
                                            Pointer f,
                                            @Cast(value="const uint8_t*")
                                            byte[] buf,
                                            int size)

av_hex_dump_log

@NoException
public static void av_hex_dump_log(Pointer avcl,
                                                int level,
                                                @Cast(value="const uint8_t*")
                                                BytePointer buf,
                                                int size)

Send a nice hexadecimal dump of a buffer to the log.

Parameters:: avcl - A pointer to an arbitrary struct of which the first field is a pointer to an AVClass struct.; level - The importance level of the message, lower values signifying higher importance.; buf - buffer; size - buffer size
See Also:: av_hex_dump, av_pkt_dump2, av_pkt_dump_log2

av_hex_dump_log

@NoException
public static void av_hex_dump_log(Pointer avcl,
                                                int level,
                                                @Cast(value="const uint8_t*")
                                                ByteBuffer buf,
                                                int size)

av_hex_dump_log

@NoException
public static void av_hex_dump_log(Pointer avcl,
                                                int level,
                                                @Cast(value="const uint8_t*")
                                                byte[] buf,
                                                int size)

av_pkt_dump2

@NoException
public static void av_pkt_dump2(@Cast(value="FILE*")
                                             Pointer f,
                                             @Const
                                             AVPacket pkt,
                                             int dump_payload,
                                             @Const
                                             AVStream st)

Send a nice dump of a packet to the specified file stream.

Parameters:: f - The file stream pointer where the dump should be sent to.; pkt - packet to dump; dump_payload - True if the payload must be displayed, too.; st - AVStream that the packet belongs to

av_pkt_dump_log2

@NoException
public static void av_pkt_dump_log2(Pointer avcl,
                                                 int level,
                                                 @Const
                                                 AVPacket pkt,
                                                 int dump_payload,
                                                 @Const
                                                 AVStream st)

Send a nice dump of a packet to the log.

Parameters:: avcl - A pointer to an arbitrary struct of which the first field is a pointer to an AVClass struct.; level - The importance level of the message, lower values signifying higher importance.; pkt - packet to dump; dump_payload - True if the payload must be displayed, too.; st - AVStream that the packet belongs to

av_codec_get_id

@NoException
 @Cast(value="AVCodecID")
public static int av_codec_get_id(@Cast(value="const AVCodecTag*const*")
                                                                         PointerPointer tags,
                                                                         @Cast(value="unsigned int")
                                                                         int tag)

Get the AVCodecID for the given codec tag tag. If no codec id is found returns AV_CODEC_ID_NONE.

Parameters:: tags - list of supported codec_id-codec_tag pairs, as stored in AVInputFormat.codec_tag and AVOutputFormat.codec_tag; tag - codec tag to match to a codec ID

av_codec_get_id

@NoException
 @Cast(value="AVCodecID")
public static int av_codec_get_id(@Const @ByPtrPtr
                                                                         AVCodecTag tags,
                                                                         @Cast(value="unsigned int")
                                                                         int tag)

av_codec_get_tag

@NoException
 @Cast(value="unsigned int")
public static int av_codec_get_tag(@Cast(value="const AVCodecTag*const*")
                                                                             PointerPointer tags,
                                                                             @Cast(value="AVCodecID")
                                                                             int id)

Get the codec tag for the given codec id id. If no codec tag is found returns 0.

Parameters:: tags - list of supported codec_id-codec_tag pairs, as stored in AVInputFormat.codec_tag and AVOutputFormat.codec_tag; id - codec ID to match to a codec tag

av_codec_get_tag

@NoException
 @Cast(value="unsigned int")
public static int av_codec_get_tag(@Const @ByPtrPtr
                                                                             AVCodecTag tags,
                                                                             @Cast(value="AVCodecID")
                                                                             int id)

av_codec_get_tag2

@NoException
public static int av_codec_get_tag2(@Cast(value="const AVCodecTag*const*")
                                                 PointerPointer tags,
                                                 @Cast(value="AVCodecID")
                                                 int id,
                                                 @Cast(value="unsigned int*")
                                                 IntPointer tag)

Get the codec tag for the given codec id.

Parameters:: tags - list of supported codec_id - codec_tag pairs, as stored in AVInputFormat.codec_tag and AVOutputFormat.codec_tag; id - codec id that should be searched for in the list; tag - A pointer to the found tag
Returns:: 0 if id was not found in tags, > 0 if it was found

av_codec_get_tag2

@NoException
public static int av_codec_get_tag2(@Const @ByPtrPtr
                                                 AVCodecTag tags,
                                                 @Cast(value="AVCodecID")
                                                 int id,
                                                 @Cast(value="unsigned int*")
                                                 IntPointer tag)

av_codec_get_tag2

@NoException
public static int av_codec_get_tag2(@Const @ByPtrPtr
                                                 AVCodecTag tags,
                                                 @Cast(value="AVCodecID")
                                                 int id,
                                                 @Cast(value="unsigned int*")
                                                 IntBuffer tag)

av_codec_get_tag2

@NoException
public static int av_codec_get_tag2(@Const @ByPtrPtr
                                                 AVCodecTag tags,
                                                 @Cast(value="AVCodecID")
                                                 int id,
                                                 @Cast(value="unsigned int*")
                                                 int[] tag)

av_find_default_stream_index

@NoException
public static int av_find_default_stream_index(AVFormatContext s)

av_index_search_timestamp
```
@NoException
public static int av_index_search_timestamp(AVStream st,
                                                         @Cast(value="int64_t")
                                                         long timestamp,
                                                         int flags)
```
Get the index for a specific timestamp.

Parameters:

st - stream that the timestamp belongs to

timestamp - timestamp to retrieve the index for

flags - if AVSEEK_FLAG_BACKWARD then the returned index will correspond to the timestamp which is <= the requested one, if backward is 0, then it will be >= if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise

Returns:

< 0 if no such timestamp could be found

avformat_index_get_entries_count

@NoException
public static int avformat_index_get_entries_count(@Const
                                                                AVStream st)

Get the index entry count for the given AVStream.

Parameters:: st - stream
Returns:: the number of index entries in the stream

avformat_index_get_entry
```
@NoException
 @Const
public static AVIndexEntry avformat_index_get_entry(AVStream st,
                                                                         int idx)
```
Get the AVIndexEntry corresponding to the given index.

Parameters:

st - Stream containing the requested AVIndexEntry.

idx - The desired index.

Returns:

A pointer to the requested AVIndexEntry if it exists, NULL otherwise. \note The pointer returned by this function is only guaranteed to be valid until any function that takes the stream or the parent AVFormatContext as input argument is called.

avformat_index_get_entry_from_timestamp
```
@NoException
 @Const
public static AVIndexEntry avformat_index_get_entry_from_timestamp(AVStream st,
                                                                                        @Cast(value="int64_t")
                                                                                        long wanted_timestamp,
                                                                                        int flags)
```
Get the AVIndexEntry corresponding to the given timestamp.

Parameters:

st - Stream containing the requested AVIndexEntry.

wanted_timestamp - Timestamp to retrieve the index entry for.

flags - If AVSEEK_FLAG_BACKWARD then the returned entry will correspond to the timestamp which is <= the requested one, if backward is 0, then it will be >= if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise.

Returns:

A pointer to the requested AVIndexEntry if it exists, NULL otherwise. \note The pointer returned by this function is only guaranteed to be valid until any function that takes the stream or the parent AVFormatContext as input argument is called.

av_add_index_entry

@NoException
public static int av_add_index_entry(AVStream st,
                                                  @Cast(value="int64_t")
                                                  long pos,
                                                  @Cast(value="int64_t")
                                                  long timestamp,
                                                  int size,
                                                  int distance,
                                                  int flags)

Add an index entry into a sorted list. Update the entry if the list already contains it.

Parameters:: timestamp - timestamp in the time base of the given stream

av_url_split

@NoException
public static void av_url_split(@Cast(value="char*")
                                             BytePointer proto,
                                             int proto_size,
                                             @Cast(value="char*")
                                             BytePointer authorization,
                                             int authorization_size,
                                             @Cast(value="char*")
                                             BytePointer hostname,
                                             int hostname_size,
                                             IntPointer port_ptr,
                                             @Cast(value="char*")
                                             BytePointer path,
                                             int path_size,
                                             @Cast(value="const char*")
                                             BytePointer url)

Split a URL string into components. The pointers to buffers for storing individual components may be null, in order to ignore that component. Buffers for components not found are set to empty strings. If the port is not found, it is set to a negative value.

Parameters:: proto - the buffer for the protocol; proto_size - the size of the proto buffer; authorization - the buffer for the authorization; authorization_size - the size of the authorization buffer; hostname - the buffer for the host name; hostname_size - the size of the hostname buffer; port_ptr - a pointer to store the port number in; path - the buffer for the path; path_size - the size of the path buffer; url - the URL to split

av_url_split

@NoException
public static void av_url_split(@Cast(value="char*")
                                             ByteBuffer proto,
                                             int proto_size,
                                             @Cast(value="char*")
                                             ByteBuffer authorization,
                                             int authorization_size,
                                             @Cast(value="char*")
                                             ByteBuffer hostname,
                                             int hostname_size,
                                             IntBuffer port_ptr,
                                             @Cast(value="char*")
                                             ByteBuffer path,
                                             int path_size,
                                             String url)

av_url_split

@NoException
public static void av_url_split(@Cast(value="char*")
                                             byte[] proto,
                                             int proto_size,
                                             @Cast(value="char*")
                                             byte[] authorization,
                                             int authorization_size,
                                             @Cast(value="char*")
                                             byte[] hostname,
                                             int hostname_size,
                                             int[] port_ptr,
                                             @Cast(value="char*")
                                             byte[] path,
                                             int path_size,
                                             @Cast(value="const char*")
                                             BytePointer url)

av_url_split

@NoException
public static void av_url_split(@Cast(value="char*")
                                             BytePointer proto,
                                             int proto_size,
                                             @Cast(value="char*")
                                             BytePointer authorization,
                                             int authorization_size,
                                             @Cast(value="char*")
                                             BytePointer hostname,
                                             int hostname_size,
                                             IntPointer port_ptr,
                                             @Cast(value="char*")
                                             BytePointer path,
                                             int path_size,
                                             String url)

av_url_split

@NoException
public static void av_url_split(@Cast(value="char*")
                                             ByteBuffer proto,
                                             int proto_size,
                                             @Cast(value="char*")
                                             ByteBuffer authorization,
                                             int authorization_size,
                                             @Cast(value="char*")
                                             ByteBuffer hostname,
                                             int hostname_size,
                                             IntBuffer port_ptr,
                                             @Cast(value="char*")
                                             ByteBuffer path,
                                             int path_size,
                                             @Cast(value="const char*")
                                             BytePointer url)

av_url_split

@NoException
public static void av_url_split(@Cast(value="char*")
                                             byte[] proto,
                                             int proto_size,
                                             @Cast(value="char*")
                                             byte[] authorization,
                                             int authorization_size,
                                             @Cast(value="char*")
                                             byte[] hostname,
                                             int hostname_size,
                                             int[] port_ptr,
                                             @Cast(value="char*")
                                             byte[] path,
                                             int path_size,
                                             String url)

av_dump_format

@NoException
public static void av_dump_format(AVFormatContext ic,
                                               int index,
                                               @Cast(value="const char*")
                                               BytePointer url,
                                               int is_output)

Print detailed information about the input or output format, such as duration, bitrate, streams, container, programs, metadata, side data, codec and time base.

Parameters:: ic - the context to analyze; index - index of the stream to dump information about; url - the URL to print, such as source or destination file; is_output - Select whether the specified context is an input(0) or output(1)

av_dump_format

@NoException
public static void av_dump_format(AVFormatContext ic,
                                               int index,
                                               String url,
                                               int is_output)

av_get_frame_filename2

@NoException
public static int av_get_frame_filename2(@Cast(value="char*")
                                                      BytePointer buf,
                                                      int buf_size,
                                                      @Cast(value="const char*")
                                                      BytePointer path,
                                                      int number,
                                                      int flags)

Return in 'buf' the path with '%d' replaced by a number. Also handles the '%0nd' format where 'n' is the total number of digits and '%%'.

Parameters:: buf - destination buffer; buf_size - destination buffer size; path - numbered sequence string; number - frame number; flags - AV_FRAME_FILENAME_FLAGS_*
Returns:: 0 if OK, -1 on format error

av_get_frame_filename2

@NoException
public static int av_get_frame_filename2(@Cast(value="char*")
                                                      ByteBuffer buf,
                                                      int buf_size,
                                                      String path,
                                                      int number,
                                                      int flags)

av_get_frame_filename2

@NoException
public static int av_get_frame_filename2(@Cast(value="char*")
                                                      byte[] buf,
                                                      int buf_size,
                                                      @Cast(value="const char*")
                                                      BytePointer path,
                                                      int number,
                                                      int flags)

av_get_frame_filename2

@NoException
public static int av_get_frame_filename2(@Cast(value="char*")
                                                      BytePointer buf,
                                                      int buf_size,
                                                      String path,
                                                      int number,
                                                      int flags)

av_get_frame_filename2

@NoException
public static int av_get_frame_filename2(@Cast(value="char*")
                                                      ByteBuffer buf,
                                                      int buf_size,
                                                      @Cast(value="const char*")
                                                      BytePointer path,
                                                      int number,
                                                      int flags)

av_get_frame_filename2

@NoException
public static int av_get_frame_filename2(@Cast(value="char*")
                                                      byte[] buf,
                                                      int buf_size,
                                                      String path,
                                                      int number,
                                                      int flags)

av_get_frame_filename

@NoException
public static int av_get_frame_filename(@Cast(value="char*")
                                                     BytePointer buf,
                                                     int buf_size,
                                                     @Cast(value="const char*")
                                                     BytePointer path,
                                                     int number)

av_get_frame_filename

@NoException
public static int av_get_frame_filename(@Cast(value="char*")
                                                     ByteBuffer buf,
                                                     int buf_size,
                                                     String path,
                                                     int number)

av_get_frame_filename

@NoException
public static int av_get_frame_filename(@Cast(value="char*")
                                                     byte[] buf,
                                                     int buf_size,
                                                     @Cast(value="const char*")
                                                     BytePointer path,
                                                     int number)

av_get_frame_filename

@NoException
public static int av_get_frame_filename(@Cast(value="char*")
                                                     BytePointer buf,
                                                     int buf_size,
                                                     String path,
                                                     int number)

av_get_frame_filename

@NoException
public static int av_get_frame_filename(@Cast(value="char*")
                                                     ByteBuffer buf,
                                                     int buf_size,
                                                     @Cast(value="const char*")
                                                     BytePointer path,
                                                     int number)

av_get_frame_filename

@NoException
public static int av_get_frame_filename(@Cast(value="char*")
                                                     byte[] buf,
                                                     int buf_size,
                                                     String path,
                                                     int number)

av_filename_number_test

@NoException
public static int av_filename_number_test(@Cast(value="const char*")
                                                       BytePointer filename)

Check whether filename actually is a numbered sequence generator.

Parameters:: filename - possible numbered sequence string
Returns:: 1 if a valid numbered sequence string, 0 otherwise

av_filename_number_test

@NoException
public static int av_filename_number_test(String filename)

av_sdp_create
```
@NoException
public static int av_sdp_create(@Cast(value="AVFormatContext**")
                                             PointerPointer ac,
                                             int n_files,
                                             @Cast(value="char*")
                                             BytePointer buf,
                                             int size)
```
Generate an SDP for an RTP session. Note, this overwrites the id values of AVStreams in the muxer contexts for getting unique dynamic payload types.

Parameters:

ac - array of AVFormatContexts describing the RTP streams. If the array is composed by only one context, such context can contain multiple AVStreams (one AVStream per RTP stream). Otherwise, all the contexts in the array (an AVCodecContext per RTP stream) must contain only one AVStream.

n_files - number of AVCodecContexts contained in ac

buf - buffer where the SDP will be stored (must be allocated by the caller)

size - the size of the buffer

Returns:

0 if OK, AVERROR_xxx on error

av_sdp_create

@NoException
public static int av_sdp_create(@ByPtrPtr
                                             AVFormatContext ac,
                                             int n_files,
                                             @Cast(value="char*")
                                             BytePointer buf,
                                             int size)

av_sdp_create

@NoException
public static int av_sdp_create(@ByPtrPtr
                                             AVFormatContext ac,
                                             int n_files,
                                             @Cast(value="char*")
                                             ByteBuffer buf,
                                             int size)

av_sdp_create

@NoException
public static int av_sdp_create(@ByPtrPtr
                                             AVFormatContext ac,
                                             int n_files,
                                             @Cast(value="char*")
                                             byte[] buf,
                                             int size)

av_match_ext

@NoException
public static int av_match_ext(@Cast(value="const char*")
                                            BytePointer filename,
                                            @Cast(value="const char*")
                                            BytePointer extensions)

Return a positive value if the given filename has one of the given extensions, 0 otherwise.

Parameters:: filename - file name to check against the given extensions; extensions - a comma-separated list of filename extensions

av_match_ext

@NoException
public static int av_match_ext(String filename,
                                            String extensions)

avformat_query_codec

@NoException
public static int avformat_query_codec(@Const
                                                    AVOutputFormat ofmt,
                                                    @Cast(value="AVCodecID")
                                                    int codec_id,
                                                    int std_compliance)

Test if the given container can store a codec.

Parameters:: ofmt - container to check for compatibility; codec_id - codec to potentially store in container; std_compliance - standards compliance level, one of FF_COMPLIANCE_*
Returns:: 1 if codec with ID codec_id can be stored in ofmt, 0 if it cannot. A negative number if this information is not available.

avformat_get_riff_video_tags
```
@NoException
 @Const
public static AVCodecTag avformat_get_riff_video_tags()
```
Returns:

the table mapping RIFF FourCCs for video to libavcodec AVCodecID.

avformat_get_riff_audio_tags
```
@NoException
 @Const
public static AVCodecTag avformat_get_riff_audio_tags()
```
Returns:

the table mapping RIFF FourCCs for audio to AVCodecID.

avformat_get_mov_video_tags
```
@NoException
 @Const
public static AVCodecTag avformat_get_mov_video_tags()
```
Returns:

the table mapping MOV FourCCs for video to libavcodec AVCodecID.

avformat_get_mov_audio_tags
```
@NoException
 @Const
public static AVCodecTag avformat_get_mov_audio_tags()
```
Returns:

the table mapping MOV FourCCs for audio to AVCodecID.

av_guess_sample_aspect_ratio
```
@NoException
 @ByVal
public static AVRational av_guess_sample_aspect_ratio(AVFormatContext format,
                                                                           AVStream stream,
                                                                           AVFrame frame)
```
Guess the sample aspect ratio of a frame, based on both the stream and the frame aspect ratio. Since the frame aspect ratio is set by the codec but the stream aspect ratio is set by the demuxer, these two may not be equal. This function tries to return the value that you should use if you would like to display the frame. Basic logic is to use the stream aspect ratio if it is set to something sane otherwise use the frame aspect ratio. This way a container setting, which is usually easy to modify can override the coded value in the frames.

Parameters:

format - the format context which the stream is part of

stream - the stream which the frame is part of

frame - the frame with the aspect ratio to be determined

Returns:

the guessed (valid) sample_aspect_ratio, 0/1 if no idea

av_guess_frame_rate

@NoException
 @ByVal
public static AVRational av_guess_frame_rate(AVFormatContext ctx,
                                                                  AVStream stream,
                                                                  AVFrame frame)

Guess the frame rate, based on both the container and codec information.

Parameters:: ctx - the format context which the stream is part of; stream - the stream which the frame is part of; frame - the frame for which the frame rate should be determined, may be NULL
Returns:: the guessed (valid) frame rate, 0/1 if no idea

avformat_match_stream_specifier

@NoException
public static int avformat_match_stream_specifier(AVFormatContext s,
                                                               AVStream st,
                                                               @Cast(value="const char*")
                                                               BytePointer spec)

Check if the stream st contained in s is matched by the stream specifier spec. See the "stream specifiers" chapter in the documentation for the syntax of spec.

Returns:: >0 if st is matched by spec; 0 if st is not matched by spec; AVERROR code if spec is invalid \note A stream specifier can match several streams in the format.

avformat_match_stream_specifier

@NoException
public static int avformat_match_stream_specifier(AVFormatContext s,
                                                               AVStream st,
                                                               String spec)

avformat_queue_attached_pictures

@NoException
public static int avformat_queue_attached_pictures(AVFormatContext s)

avformat_transfer_internal_stream_timing_info

@NoException
 @Deprecated
public static int avformat_transfer_internal_stream_timing_info(@Const
                                                                                          AVOutputFormat ofmt,
                                                                                          AVStream ost,
                                                                                          @Const
                                                                                          AVStream ist,
                                                                                          @Cast(value="AVTimebaseSource")
                                                                                          int copy_tb)

Deprecated. do not call this function

av_stream_get_codec_timebase

@NoException
 @Deprecated
 @ByVal
public static AVRational av_stream_get_codec_timebase(@Const
                                                                                        AVStream st)

Deprecated. do not call this function

LIBAVFORMAT_VERSION_INT

@MemberGetter
public static int LIBAVFORMAT_VERSION_INT()

LIBAVFORMAT_IDENT

@MemberGetter
public static String LIBAVFORMAT_IDENT()

Class avformat

Field Summary

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

AVIO_SEEKABLE_NORMAL

AVIO_SEEKABLE_TIME

AVIO_ENTRY_UNKNOWN

AVIO_ENTRY_BLOCK_DEVICE

AVIO_ENTRY_CHARACTER_DEVICE

AVIO_ENTRY_DIRECTORY

AVIO_ENTRY_NAMED_PIPE

AVIO_ENTRY_SYMBOLIC_LINK

AVIO_ENTRY_SOCKET

AVIO_ENTRY_FILE

AVIO_ENTRY_SERVER

AVIO_ENTRY_SHARE

AVIO_ENTRY_WORKGROUP

AVIO_DATA_MARKER_HEADER

AVIO_DATA_MARKER_SYNC_POINT

AVIO_DATA_MARKER_BOUNDARY_POINT

AVIO_DATA_MARKER_UNKNOWN

AVIO_DATA_MARKER_TRAILER

AVIO_DATA_MARKER_FLUSH_POINT

AVSEEK_SIZE

AVSEEK_FORCE

AVIO_FLAG_READ

AVIO_FLAG_WRITE

AVIO_FLAG_READ_WRITE

AVIO_FLAG_NONBLOCK

AVIO_FLAG_DIRECT

AVPROBE_SCORE_RETRY

AVPROBE_SCORE_STREAM_RETRY

AVPROBE_SCORE_EXTENSION

AVPROBE_SCORE_MIME

AVPROBE_SCORE_MAX

AVPROBE_PADDING_SIZE

AVFMT_NOFILE

AVFMT_NEEDNUMBER

AVFMT_EXPERIMENTAL

AVFMT_SHOW_IDS

AVFMT_GLOBALHEADER

AVFMT_NOTIMESTAMPS

AVFMT_GENERIC_INDEX

AVFMT_TS_DISCONT

AVFMT_VARIABLE_FPS

AVFMT_NODIMENSIONS

AVFMT_NOSTREAMS

AVFMT_NOBINSEARCH

AVFMT_NOGENSEARCH

AVFMT_NO_BYTE_SEEK

AVFMT_ALLOW_FLUSH

AVFMT_TS_NONSTRICT

AVFMT_TS_NEGATIVE

AVFMT_SEEK_TO_PTS

AVSTREAM_PARSE_NONE

AVSTREAM_PARSE_FULL

AVSTREAM_PARSE_HEADERS

AVSTREAM_PARSE_TIMESTAMPS

AVSTREAM_PARSE_FULL_ONCE

AVSTREAM_PARSE_FULL_RAW

AV_DISPOSITION_DEFAULT

AV_DISPOSITION_DUB

AV_DISPOSITION_ORIGINAL

AV_DISPOSITION_COMMENT

AV_DISPOSITION_LYRICS

AV_DISPOSITION_KARAOKE

AV_DISPOSITION_FORCED

AV_DISPOSITION_HEARING_IMPAIRED

AV_DISPOSITION_VISUAL_IMPAIRED

AV_DISPOSITION_CLEAN_EFFECTS

AV_DISPOSITION_ATTACHED_PIC

AV_DISPOSITION_TIMED_THUMBNAILS

AV_DISPOSITION_NON_DIEGETIC

AV_DISPOSITION_CAPTIONS

AV_DISPOSITION_DESCRIPTIONS

AV_DISPOSITION_METADATA

AV_DISPOSITION_DEPENDENT