avformat (JavaCPP Presets for FFmpeg 3.2.1-1.3 API)

java.lang.Object
- org.bytedeco.javacpp.presets.avformat
- - org.bytedeco.javacpp.avformat

All Implemented Interfaces:

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

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`avformat.av_format_control_message` Callback used by devices to communicate with application.
`static class`	`avformat.AVBPrint`
`static class`	`avformat.AVChapter`
`static class`	`avformat.AVCodecTag`
`static class`	`avformat.AVDeviceCapabilitiesQuery`
`static class`	`avformat.AVDeviceInfoList` \defgroup libavf libavformat I/O and Muxing/Demuxing Library Libavformat (lavf) is a library for dealing with various media container formats.
`static class`	`avformat.AVFormatContext` Format I/O context.
`static class`	`avformat.AVFormatInternal`
`static class`	`avformat.AVFrac` The exact value of the fractional number is: 'val + num / den'.
`static class`	`avformat.AVIndexEntry`
`static class`	`avformat.AVInputFormat` \addtogroup lavf_decoding \{
`static class`	`avformat.AVIOContext` Bytestream IO Context.
`static class`	`avformat.AVIODirContext`
`static class`	`avformat.AVIODirEntry` Describes single entry of the directory.
`static class`	`avformat.AVIOInterruptCB` Callback for checking whether to abort blocking functions.
`static class`	`avformat.AVOpenCallback`
`static class`	`avformat.AVOutputFormat` \addtogroup lavf_encoding \{
`static class`	`avformat.AVPacketList`
`static class`	`avformat.AVProbeData` This structure contains the data a format has to probe a file.
`static class`	`avformat.AVProgram` New fields can be added to the end with minor version bumps.
`static class`	`avformat.AVStream` Stream structure.
`static class`	`avformat.AVStreamInternal`
`static class`	`avformat.Read_packet_Pointer_byte___int`
`static class`	`avformat.Read_packet_Pointer_ByteBuffer_int`
`static class`	`avformat.Read_packet_Pointer_BytePointer_int` Allocate and initialize an AVIOContext for buffered I/O.
`static class`	`avformat.Seek_Pointer_long_int`
`static class`	`avformat.Write_packet_Pointer_byte___int`
`static class`	`avformat.Write_packet_Pointer_ByteBuffer_int`
`static class`	`avformat.Write_packet_Pointer_BytePointer_int`

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` To specify text track kind (different from subtitles default).
`static int`	`AV_DISPOSITION_CLEAN_EFFECTS` stream without voice
`static int`	`AV_DISPOSITION_COMMENT`
`static int`	`AV_DISPOSITION_DEFAULT`
`static int`	`AV_DISPOSITION_DESCRIPTIONS`
`static int`	`AV_DISPOSITION_DUB`
`static int`	`AV_DISPOSITION_FORCED` Track should be used during playback by default.
`static int`	`AV_DISPOSITION_HEARING_IMPAIRED` stream for hearing impaired audiences
`static int`	`AV_DISPOSITION_KARAOKE`
`static int`	`AV_DISPOSITION_LYRICS`
`static int`	`AV_DISPOSITION_METADATA`
`static int`	`AV_DISPOSITION_ORIGINAL`
`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` stream for visual 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`	`AVFMT_ALLOW_FLUSH` Format allows flushing.
`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_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_RAWPICTURE` Format wants AVPicture structure for raw picture data.
`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`	`AVIO_DATA_MARKER_BOUNDARY_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`	`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`
`static int`	`AVSTREAM_PARSE_HEADERS` enum AVStreamParseType
`static int`	`AVSTREAM_PARSE_NONE` enum AVStreamParseType
`static int`	`AVSTREAM_PARSE_TIMESTAMPS` enum AVStreamParseType

Constructor Summary

Constructors
Constructor and Description

avformat()

Constructors
Constructor and Description
`avformat()`

Method Summary

Methods
Modifier and Type	Method and Description
`static int`	`av_add_index_entry(avformat.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(avformat.AVIOContext s, avcodec.AVPacket pkt, int size)` Read data and append it to the current content of the AVPacket.
`static int`	`av_apply_bitstream_filters(avcodec.AVCodecContext codec, avcodec.AVPacket pkt, avcodec.AVBitStreamFilterContext bsfc)` Deprecated.
`static int`	`av_codec_get_id(avformat.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(avformat.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(avformat.AVCodecTag tags, int id, int[] tag)`
`static int`	`av_codec_get_tag2(avformat.AVCodecTag tags, int id, IntBuffer tag)`
`static int`	`av_codec_get_tag2(avformat.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 int`	`av_demuxer_open(avformat.AVFormatContext ic)` Deprecated.
`static void`	`av_dump_format(avformat.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(avformat.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(avformat.AVFormatContext ic, int type, int wanted_stream_nb, int related_stream, avcodec.AVCodec decoder_ret, int flags)`
`static int`	`av_find_best_stream(avformat.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(avformat.AVFormatContext s)`
`static avformat.AVInputFormat`	`av_find_input_format(BytePointer short_name)` Find AVInputFormat based on the short name of the input format.
`static avformat.AVInputFormat`	`av_find_input_format(String short_name)`
`static avformat.AVProgram`	`av_find_program_from_stream(avformat.AVFormatContext ic, avformat.AVProgram last, int s)` Find the programs which belong to a given stream.
`static int`	`av_fmt_ctx_get_duration_estimation_method(avformat.AVFormatContext ctx)` Returns the method used to set ctx->duration.
`static avcodec.AVCodec`	`av_format_get_audio_codec(avformat.AVFormatContext s)`
`static avformat.av_format_control_message`	`av_format_get_control_message_cb(avformat.AVFormatContext s)`
`static avcodec.AVCodec`	`av_format_get_data_codec(avformat.AVFormatContext s)`
`static int`	`av_format_get_metadata_header_padding(avformat.AVFormatContext s)`
`static Pointer`	`av_format_get_opaque(avformat.AVFormatContext s)`
`static avformat.AVOpenCallback`	`av_format_get_open_cb(avformat.AVFormatContext s)` Deprecated.
`static int`	`av_format_get_probe_score(avformat.AVFormatContext s)`
`static avcodec.AVCodec`	`av_format_get_subtitle_codec(avformat.AVFormatContext s)`
`static avcodec.AVCodec`	`av_format_get_video_codec(avformat.AVFormatContext s)`
`static void`	`av_format_inject_global_side_data(avformat.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 void`	`av_format_set_audio_codec(avformat.AVFormatContext s, avcodec.AVCodec c)`
`static void`	`av_format_set_control_message_cb(avformat.AVFormatContext s, avformat.av_format_control_message callback)`
`static void`	`av_format_set_data_codec(avformat.AVFormatContext s, avcodec.AVCodec c)`
`static void`	`av_format_set_metadata_header_padding(avformat.AVFormatContext s, int c)`
`static void`	`av_format_set_opaque(avformat.AVFormatContext s, Pointer opaque)`
`static void`	`av_format_set_open_cb(avformat.AVFormatContext s, avformat.AVOpenCallback callback)` Deprecated.
`static void`	`av_format_set_subtitle_codec(avformat.AVFormatContext s, avcodec.AVCodec c)`
`static void`	`av_format_set_video_codec(avformat.AVFormatContext s, avcodec.AVCodec c)`
`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(avformat.AVFormatContext s, int stream, long[] dts, long[] wall)`
`static int`	`av_get_output_timestamp(avformat.AVFormatContext s, int stream, LongBuffer dts, LongBuffer wall)`
`static int`	`av_get_output_timestamp(avformat.AVFormatContext s, int stream, LongPointer dts, LongPointer wall)` Get timing information for the data currently output.
`static int`	`av_get_packet(avformat.AVIOContext s, avcodec.AVPacket pkt, int size)` Allocate and read the payload of a packet and initialize its fields with default values.
`static int`	`av_guess_codec(avformat.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(avformat.AVOutputFormat fmt, String short_name, String filename, String mime_type, int type)`
`static avformat.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 avformat.AVOutputFormat`	`av_guess_format(String short_name, String filename, String mime_type)`
`static avutil.AVRational`	`av_guess_frame_rate(avformat.AVFormatContext ctx, avformat.AVStream stream, avutil.AVFrame frame)` Guess the frame rate, based on both the container and codec information.
`static avutil.AVRational`	`av_guess_sample_aspect_ratio(avformat.AVFormatContext format, avformat.AVStream stream, avutil.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 avformat.AVInputFormat`	`av_iformat_next(avformat.AVInputFormat f)` If f is NULL, returns the first registered input format, if f is non-NULL, returns the next registered input format after f or NULL if f is the last one.
`static int`	`av_index_search_timestamp(avformat.AVStream st, long timestamp, int flags)` Get the index for a specific timestamp.
`static int`	`av_interleaved_write_frame(avformat.AVFormatContext s, avcodec.AVPacket pkt)` Write a packet to an output media file ensuring correct interleaving.
`static int`	`av_interleaved_write_uncoded_frame(avformat.AVFormatContext s, int stream_index, avutil.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 avformat.AVProgram`	`av_new_program(avformat.AVFormatContext s, int id)`
`static avformat.AVOutputFormat`	`av_oformat_next(avformat.AVOutputFormat f)` If f is NULL, returns the first registered output format, if f is non-NULL, returns the next registered output format after f or NULL if f is the last one.
`static void`	`av_pkt_dump_log2(Pointer avcl, int level, avcodec.AVPacket pkt, int dump_payload, avformat.AVStream st)` Send a nice dump of a packet to the log.
`static void`	`av_pkt_dump2(Pointer f, avcodec.AVPacket pkt, int dump_payload, avformat.AVStream st)` Send a nice dump of a packet to the specified file stream.
`static int`	`av_probe_input_buffer(avformat.AVIOContext pb, avformat.AVInputFormat fmt, BytePointer url, Pointer logctx, int offset, int max_probe_size)`
`static int`	`av_probe_input_buffer(avformat.AVIOContext pb, avformat.AVInputFormat fmt, String url, Pointer logctx, int offset, int max_probe_size)`
`static int`	`av_probe_input_buffer(avformat.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(avformat.AVIOContext pb, avformat.AVInputFormat fmt, BytePointer url, Pointer logctx, int offset, int max_probe_size)`
`static int`	`av_probe_input_buffer2(avformat.AVIOContext pb, avformat.AVInputFormat fmt, String url, Pointer logctx, int offset, int max_probe_size)`
`static int`	`av_probe_input_buffer2(avformat.AVIOContext pb, PointerPointer fmt, BytePointer url, Pointer logctx, int offset, int max_probe_size)` Probe a bytestream to determine the input format.
`static avformat.AVInputFormat`	`av_probe_input_format(avformat.AVProbeData pd, int is_opened)` Guess the file format.
`static avformat.AVInputFormat`	`av_probe_input_format2(avformat.AVProbeData pd, int is_opened, int[] score_max)`
`static avformat.AVInputFormat`	`av_probe_input_format2(avformat.AVProbeData pd, int is_opened, IntBuffer score_max)`
`static avformat.AVInputFormat`	`av_probe_input_format2(avformat.AVProbeData pd, int is_opened, IntPointer score_max)` Guess the file format.
`static avformat.AVInputFormat`	`av_probe_input_format3(avformat.AVProbeData pd, int is_opened, int[] score_ret)`
`static avformat.AVInputFormat`	`av_probe_input_format3(avformat.AVProbeData pd, int is_opened, IntBuffer score_ret)`
`static avformat.AVInputFormat`	`av_probe_input_format3(avformat.AVProbeData pd, int is_opened, IntPointer score_ret)` Guess the file format.
`static void`	`av_program_add_stream_index(avformat.AVFormatContext ac, int progid, int idx)`
`static int`	`av_read_frame(avformat.AVFormatContext s, avcodec.AVPacket pkt)` Return the next frame of a stream.
`static int`	`av_read_pause(avformat.AVFormatContext s)` Pause a network-based stream (e.g.
`static int`	`av_read_play(avformat.AVFormatContext s)` Start playing a network-based stream (e.g.
`static void`	`av_register_all()` Initialize libavformat and register all the muxers, demuxers and protocols.
`static void`	`av_register_input_format(avformat.AVInputFormat format)`
`static void`	`av_register_output_format(avformat.AVOutputFormat format)`
`static int`	`av_sdp_create(avformat.AVFormatContext ac, int n_files, byte[] buf, int size)`
`static int`	`av_sdp_create(avformat.AVFormatContext ac, int n_files, ByteBuffer buf, int size)`
`static int`	`av_sdp_create(avformat.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(avformat.AVFormatContext s, int stream_index, long timestamp, int flags)` Seek to the keyframe at timestamp.
`static avutil.AVRational`	`av_stream_get_codec_timebase(avformat.AVStream st)` Get the internal codec timebase from a stream.
`static long`	`av_stream_get_end_pts(avformat.AVStream st)` Returns the pts of the last muxed packet + its duration the retuned value is undefined when used with a demuxer.
`static avcodec.AVCodecParserContext`	`av_stream_get_parser(avformat.AVStream s)`
`static avutil.AVRational`	`av_stream_get_r_frame_rate(avformat.AVStream s)`
`static BytePointer`	`av_stream_get_recommended_encoder_configuration(avformat.AVStream s)`
`static byte[]`	`av_stream_get_side_data(avformat.AVStream stream, int type, int[] size)`
`static ByteBuffer`	`av_stream_get_side_data(avformat.AVStream stream, int type, IntBuffer size)`
`static BytePointer`	`av_stream_get_side_data(avformat.AVStream stream, int type, IntPointer size)` Get side information from stream.
`static BytePointer`	`av_stream_new_side_data(avformat.AVStream stream, int type, int size)` Allocate new information from stream.
`static void`	`av_stream_set_r_frame_rate(avformat.AVStream s, avutil.AVRational r)`
`static void`	`av_stream_set_recommended_encoder_configuration(avformat.AVStream s, byte[] configuration)`
`static void`	`av_stream_set_recommended_encoder_configuration(avformat.AVStream s, ByteBuffer configuration)`
`static void`	`av_stream_set_recommended_encoder_configuration(avformat.AVStream s, BytePointer configuration)`
`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(avformat.AVFormatContext s, avcodec.AVPacket pkt)` Write a packet to an output media file.
`static int`	`av_write_trailer(avformat.AVFormatContext s)` Write the stream trailer to an output media file and free the file private data.
`static int`	`av_write_uncoded_frame_query(avformat.AVFormatContext s, int stream_index)` Test whether a muxer supports uncoded frame.
`static int`	`av_write_uncoded_frame(avformat.AVFormatContext s, int stream_index, avutil.AVFrame frame)` Write an uncoded frame to an output media file.
`static avformat.AVFormatContext`	`avformat_alloc_context()` Allocate an AVFormatContext.
`static int`	`avformat_alloc_output_context2(avformat.AVFormatContext ctx, avformat.AVOutputFormat oformat, BytePointer format_name, BytePointer filename)`
`static int`	`avformat_alloc_output_context2(avformat.AVFormatContext ctx, avformat.AVOutputFormat oformat, String format_name, String filename)`
`static int`	`avformat_alloc_output_context2(PointerPointer ctx, avformat.AVOutputFormat oformat, BytePointer format_name, BytePointer filename)` Allocate an AVFormatContext for an output format.
`static void`	`avformat_close_input(avformat.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(avformat.AVFormatContext ic, avutil.AVDictionary options)`
`static int`	`avformat_find_stream_info(avformat.AVFormatContext ic, PointerPointer options)` Read packets of a media file to get stream information.
`static int`	`avformat_flush(avformat.AVFormatContext s)` Discard all internally buffered data.
`static void`	`avformat_free_context(avformat.AVFormatContext s)` Free an AVFormatContext and all its streams.
`static avutil.AVClass`	`avformat_get_class()` Get the AVClass for AVFormatContext.
`static avformat.AVCodecTag`	`avformat_get_mov_audio_tags()`
`static avformat.AVCodecTag`	`avformat_get_mov_video_tags()`
`static avformat.AVCodecTag`	`avformat_get_riff_audio_tags()`
`static avformat.AVCodecTag`	`avformat_get_riff_video_tags()`
`static int`	`avformat_init_output(avformat.AVFormatContext s, avutil.AVDictionary options)`
`static int`	`avformat_init_output(avformat.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(avformat.AVFormatContext s, avformat.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(avformat.AVFormatContext s, avformat.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 components.
`static avformat.AVStream`	`avformat_new_stream(avformat.AVFormatContext s, avcodec.AVCodec c)` Add a new stream to a media file.
`static int`	`avformat_open_input(avformat.AVFormatContext ps, BytePointer url, avformat.AVInputFormat fmt, avutil.AVDictionary options)`
`static int`	`avformat_open_input(avformat.AVFormatContext ps, String url, avformat.AVInputFormat fmt, avutil.AVDictionary options)`
`static int`	`avformat_open_input(PointerPointer ps, BytePointer url, avformat.AVInputFormat fmt, PointerPointer options)` Open an input stream and read the header.
`static int`	`avformat_query_codec(avformat.AVOutputFormat ofmt, int codec_id, int std_compliance)` Test if the given container can store a codec.
`static int`	`avformat_queue_attached_pictures(avformat.AVFormatContext s)`
`static int`	`avformat_seek_file(avformat.AVFormatContext s, int stream_index, long min_ts, long ts, long max_ts, int flags)` Seek to timestamp ts.
`static int`	`avformat_transfer_internal_stream_timing_info(avformat.AVOutputFormat ofmt, avformat.AVStream ost, avformat.AVStream ist, int copy_tb)` Transfer internal timing information from one stream to another.
`static int`	`avformat_version()` Return the LIBAVFORMAT_VERSION_INT constant.
`static int`	`avformat_write_header(avformat.AVFormatContext s, avutil.AVDictionary options)`
`static int`	`avformat_write_header(avformat.AVFormatContext s, PointerPointer options)` Allocate the stream private data and write the stream header to an output media file.
`static int`	`avio_accept(avformat.AVIOContext s, avformat.AVIOContext c)`
`static int`	`avio_accept(avformat.AVIOContext s, PointerPointer c)` Accept and allocate a client context on a server context.
`static avformat.AVIOContext`	`avio_alloc_context(byte[] buffer, int buffer_size, int write_flag, Pointer opaque, avformat.Read_packet_Pointer_byte___int read_packet, avformat.Write_packet_Pointer_byte___int write_packet, avformat.Seek_Pointer_long_int seek)`
`static avformat.AVIOContext`	`avio_alloc_context(ByteBuffer buffer, int buffer_size, int write_flag, Pointer opaque, avformat.Read_packet_Pointer_ByteBuffer_int read_packet, avformat.Write_packet_Pointer_ByteBuffer_int write_packet, avformat.Seek_Pointer_long_int seek)`
`static avformat.AVIOContext`	`avio_alloc_context(BytePointer buffer, int buffer_size, int write_flag, Pointer opaque, avformat.Read_packet_Pointer_BytePointer_int read_packet, avformat.Write_packet_Pointer_BytePointer_int write_packet, avformat.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(avformat.AVIODirContext s)`
`static int`	`avio_close_dir(PointerPointer s)` Close directory.
`static int`	`avio_close_dyn_buf(avformat.AVIOContext s, byte[] pbuffer)`
`static int`	`avio_close_dyn_buf(avformat.AVIOContext s, ByteBuffer pbuffer)`
`static int`	`avio_close_dyn_buf(avformat.AVIOContext s, BytePointer pbuffer)`
`static int`	`avio_close_dyn_buf(avformat.AVIOContext s, PointerPointer pbuffer)` Return the written size and a pointer to the buffer.
`static int`	`avio_close(avformat.AVIOContext s)` Close the resource accessed by the AVIOContext s and free it.
`static int`	`avio_closep(avformat.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 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(avformat.AVIOContext s)` feof() equivalent for AVIOContext.
`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(avformat.AVIOContext s)` Force flushing of buffered data.
`static void`	`avio_free_directory_entry(avformat.AVIODirEntry entry)`
`static void`	`avio_free_directory_entry(PointerPointer entry)` Free entry allocated by avio_read_dir().
`static int`	`avio_get_str(avformat.AVIOContext pb, int maxlen, byte[] buf, int buflen)`
`static int`	`avio_get_str(avformat.AVIOContext pb, int maxlen, ByteBuffer buf, int buflen)`
`static int`	`avio_get_str(avformat.AVIOContext pb, int maxlen, BytePointer buf, int buflen)` Read a string from pb into buf.
`static int`	`avio_get_str16be(avformat.AVIOContext pb, int maxlen, byte[] buf, int buflen)`
`static int`	`avio_get_str16be(avformat.AVIOContext pb, int maxlen, ByteBuffer buf, int buflen)`
`static int`	`avio_get_str16be(avformat.AVIOContext pb, int maxlen, BytePointer buf, int buflen)`
`static int`	`avio_get_str16le(avformat.AVIOContext pb, int maxlen, byte[] buf, int buflen)`
`static int`	`avio_get_str16le(avformat.AVIOContext pb, int maxlen, ByteBuffer buf, int buflen)`
`static int`	`avio_get_str16le(avformat.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(avformat.AVIOContext c)` Perform one step of the protocol handshake to accept a new client.
`static int`	`avio_open_dir(avformat.AVIODirContext s, BytePointer url, avutil.AVDictionary options)`
`static int`	`avio_open_dir(avformat.AVIODirContext s, String url, avutil.AVDictionary options)`
`static int`	`avio_open_dir(PointerPointer s, BytePointer url, PointerPointer options)` Open directory for reading.
`static int`	`avio_open_dyn_buf(avformat.AVIOContext s)`
`static int`	`avio_open_dyn_buf(PointerPointer s)` Open a write only memory stream.
`static int`	`avio_open(avformat.AVIOContext s, BytePointer url, int flags)`
`static int`	`avio_open(avformat.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(avformat.AVIOContext s, BytePointer url, int flags, avformat.AVIOInterruptCB int_cb, avutil.AVDictionary options)`
`static int`	`avio_open2(avformat.AVIOContext s, String url, int flags, avformat.AVIOInterruptCB int_cb, avutil.AVDictionary options)`
`static int`	`avio_open2(PointerPointer s, BytePointer url, int flags, avformat.AVIOInterruptCB int_cb, PointerPointer options)` Create and initialize a AVIOContext for accessing the resource indicated by url.
`static int`	`avio_pause(avformat.AVIOContext h, int pause)` Pause and resume playing - only meaningful if using a network streaming protocol (e.g.
`static int`	`avio_printf(avformat.AVIOContext s, BytePointer fmt)` \warning Writes up to 4 KiB per call
`static int`	`avio_printf(avformat.AVIOContext s, String fmt)`
`static int`	`avio_put_str(avformat.AVIOContext s, BytePointer str)` Write a NULL-terminated string.
`static int`	`avio_put_str(avformat.AVIOContext s, String str)`
`static int`	`avio_put_str16be(avformat.AVIOContext s, BytePointer str)` Convert an UTF-8 string to UTF-16BE and write it.
`static int`	`avio_put_str16be(avformat.AVIOContext s, String str)`
`static int`	`avio_put_str16le(avformat.AVIOContext s, BytePointer str)` Convert an UTF-8 string to UTF-16LE and write it.
`static int`	`avio_put_str16le(avformat.AVIOContext s, String str)`
`static int`	`avio_r8(avformat.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(avformat.AVIOContext s)`
`static int`	`avio_rb24(avformat.AVIOContext s)`
`static int`	`avio_rb32(avformat.AVIOContext s)`
`static long`	`avio_rb64(avformat.AVIOContext s)`
`static int`	`avio_read_dir(avformat.AVIODirContext s, avformat.AVIODirEntry next)`
`static int`	`avio_read_dir(avformat.AVIODirContext s, PointerPointer next)` Get next directory entry.
`static int`	`avio_read_to_bprint(avformat.AVIOContext h, avformat.AVBPrint pb, long max_size)` Read contents of h into print buffer, up to max_size bytes, or up to EOF.
`static int`	`avio_read(avformat.AVIOContext s, byte[] buf, int size)`
`static int`	`avio_read(avformat.AVIOContext s, ByteBuffer buf, int size)`
`static int`	`avio_read(avformat.AVIOContext s, BytePointer buf, int size)` Read size bytes from AVIOContext into buf.
`static int`	`avio_rl16(avformat.AVIOContext s)`
`static int`	`avio_rl24(avformat.AVIOContext s)`
`static int`	`avio_rl32(avformat.AVIOContext s)`
`static long`	`avio_rl64(avformat.AVIOContext s)`
`static long`	`avio_seek_time(avformat.AVIOContext h, int stream_index, long timestamp, int flags)` Seek to a given timestamp relative to some component stream.
`static long`	`avio_seek(avformat.AVIOContext s, long offset, int whence)` fseek() equivalent for AVIOContext.
`static long`	`avio_size(avformat.AVIOContext s)` Get the filesize.
`static long`	`avio_skip(avformat.AVIOContext s, long offset)` Skip given number of bytes forward
`static long`	`avio_tell(avformat.AVIOContext s)` ftell() equivalent for AVIOContext.
`static void`	`avio_w8(avformat.AVIOContext s, int b)`
`static void`	`avio_wb16(avformat.AVIOContext s, int val)`
`static void`	`avio_wb24(avformat.AVIOContext s, int val)`
`static void`	`avio_wb32(avformat.AVIOContext s, int val)`
`static void`	`avio_wb64(avformat.AVIOContext s, long val)`
`static void`	`avio_wl16(avformat.AVIOContext s, int val)`
`static void`	`avio_wl24(avformat.AVIOContext s, int val)`
`static void`	`avio_wl32(avformat.AVIOContext s, int val)`
`static void`	`avio_wl64(avformat.AVIOContext s, long val)`
`static void`	`avio_write_marker(avformat.AVIOContext s, long time, int type)` Mark the written bytestream as a specific type.
`static void`	`avio_write(avformat.AVIOContext s, byte[] buf, int size)`
`static void`	`avio_write(avformat.AVIOContext s, ByteBuffer buf, int size)`
`static void`	`avio_write(avformat.AVIOContext s, BytePointer buf, int size)`
`static int`	`avpriv_io_delete(BytePointer url)` Delete a resource.
`static int`	`avpriv_io_delete(String url)`
`static int`	`avpriv_io_move(BytePointer url_src, BytePointer url_dst)` Move or rename a resource.
`static int`	`avpriv_io_move(String url_src, String url_dst)`
`static int`	`AVPROBE_SCORE_RETRY()`
`static int`	`AVPROBE_SCORE_STREAM_RETRY()`
`static int`	`AVSTREAM_PARSE_FULL_RAW()`
`static int`	`url_feof(avformat.AVIOContext s)` Deprecated. use avio_feof()

Methods inherited from class org.bytedeco.javacpp.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_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
- 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_SHOW_IDS
```
public static final int AVFMT_SHOW_IDS
```
  Show format stream IDs numbers.
  
  See Also:
  Constant Field Values
- AVFMT_RAWPICTURE
```
public static final int AVFMT_RAWPICTURE
```
  Format wants AVPicture structure for raw picture data. @deprecated Not used anymore
  
  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
```
  Format allows flushing. If not set, the muxer will not receive a NULL packet in the write_packet function.
  
  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
```
- AV_DISPOSITION_DEFAULT
```
public static final int AV_DISPOSITION_DEFAULT
```
  See Also:
  Constant Field Values
- AV_DISPOSITION_DUB
```
public static final int AV_DISPOSITION_DUB
```
  See Also:
  Constant Field Values
- AV_DISPOSITION_ORIGINAL
```
public static final int AV_DISPOSITION_ORIGINAL
```
  See Also:
  Constant Field Values
- AV_DISPOSITION_COMMENT
```
public static final int AV_DISPOSITION_COMMENT
```
  See Also:
  Constant Field Values
- AV_DISPOSITION_LYRICS
```
public static final int AV_DISPOSITION_LYRICS
```
  See Also:
  Constant Field Values
- AV_DISPOSITION_KARAOKE
```
public static final int AV_DISPOSITION_KARAOKE
```
  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
```
  stream for hearing impaired audiences
  
  See Also:
  Constant Field Values
- AV_DISPOSITION_VISUAL_IMPAIRED
```
public static final int AV_DISPOSITION_VISUAL_IMPAIRED
```
  stream for visual impaired audiences
  
  See Also:
  Constant Field Values
- AV_DISPOSITION_CLEAN_EFFECTS
```
public static final int AV_DISPOSITION_CLEAN_EFFECTS
```
  stream 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_CAPTIONS
```
public static final int AV_DISPOSITION_CAPTIONS
```
  To specify text track kind (different from subtitles default).
  
  See Also:
  Constant Field Values
- AV_DISPOSITION_DESCRIPTIONS
```
public static final int AV_DISPOSITION_DESCRIPTIONS
```
  See Also:
  Constant Field Values
- AV_DISPOSITION_METADATA
```
public static final int AV_DISPOSITION_METADATA
```
  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_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
- 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

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)

avpriv_io_move

@NoException
public static int avpriv_io_move(@Cast(value="const char*")
                             BytePointer url_src,
                             @Cast(value="const char*")
                             BytePointer url_dst)

Move or rename a resource. \note url_src and url_dst should share the same protocol and authority.

Parameters:: url_src - url to resource to be moved; url_dst - new url to resource if the operation succeeded
Returns:: >=0 on success or negative on error.

avpriv_io_move

@NoException
public static int avpriv_io_move(String url_src,
                             String url_dst)

avpriv_io_delete

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

Delete a resource.

Parameters:: url - resource to be deleted.
Returns:: >=0 on success or negative on error.

avpriv_io_delete

@NoException
public static int avpriv_io_delete(String url)

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
                            avformat.AVIODirContext s,
                            @Cast(value="const char*")
                            BytePointer url,
                            @ByPtrPtr
                            avutil.AVDictionary options)

avio_open_dir

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

avio_read_dir
```
@NoException
public static int avio_read_dir(avformat.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.
[out] - next 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(avformat.AVIODirContext s,
                            @ByPtrPtr
                            avformat.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
                             avformat.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
                                         avformat.AVIODirEntry entry)

avio_alloc_context

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

avio_alloc_context

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

avio_alloc_context

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

avio_w8

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

avio_write

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

avio_write

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

avio_write

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

avio_wl64

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

avio_wb64

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

avio_wl32

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

avio_wb32

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

avio_wl24

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

avio_wb24

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

avio_wl16

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

avio_wb16

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

avio_put_str

@NoException
public static int avio_put_str(avformat.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(avformat.AVIOContext s,
                           String str)

avio_put_str16le

@NoException
public static int avio_put_str16le(avformat.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(avformat.AVIOContext s,
                               String str)

avio_put_str16be

@NoException
public static int avio_put_str16be(avformat.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(avformat.AVIOContext s,
                               String str)

avio_write_marker

@NoException
public static void avio_write_marker(avformat.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:: 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(avformat.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(avformat.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(avformat.AVIOContext s)

ftell() equivalent for AVIOContext.

Returns:: position or AVERROR.

avio_size

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

Get the filesize.

Returns:: filesize or AVERROR

avio_feof
```
@NoException
public static int avio_feof(avformat.AVIOContext s)
```
feof() equivalent for AVIOContext.

Returns:
non zero if and only if end of file

url_feof

@NoException
@Deprecated
public static int url_feof(avformat.AVIOContext s)

Deprecated. use avio_feof()

avio_printf

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

\warning Writes up to 4 KiB per call

avio_printf

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

avio_flush
```
@NoException
public static void avio_flush(avformat.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(avformat.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(avformat.AVIOContext s,
                        @Cast(value="unsigned char*")
                        ByteBuffer buf,
                        int size)

avio_read

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

avio_r8
```
@NoException
public static int avio_r8(avformat.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(avformat.AVIOContext s)

avio_rl24

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

avio_rl32

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

avio_rl64

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

avio_rb16

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

avio_rb24

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

avio_rb32

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

avio_rb64

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

avio_get_str
```
@NoException
public static int avio_get_str(avformat.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(avformat.AVIOContext pb,
                           int maxlen,
                           @Cast(value="char*")
                           ByteBuffer buf,
                           int buflen)

avio_get_str

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

avio_get_str16le

@NoException
public static int avio_get_str16le(avformat.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(avformat.AVIOContext pb,
                               int maxlen,
                               @Cast(value="char*")
                               ByteBuffer buf,
                               int buflen)

avio_get_str16le

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

avio_get_str16be

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

avio_get_str16be

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

avio_get_str16be

@NoException
public static int avio_get_str16be(avformat.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
                        avformat.AVIOContext s,
                        @Cast(value="const char*")
                        BytePointer url,
                        int flags)

avio_open

@NoException
public static int avio_open(@ByPtrPtr
                        avformat.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
                         avformat.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
                         avformat.AVIOContext s,
                         @Cast(value="const char*")
                         BytePointer url,
                         int flags,
                         @Const
                         avformat.AVIOInterruptCB int_cb,
                         @ByPtrPtr
                         avutil.AVDictionary options)

avio_open2

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

avio_close
```
@NoException
public static int avio_close(avformat.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
                          avformat.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
                                avformat.AVIOContext s)

avio_close_dyn_buf
```
@NoException
public static int avio_close_dyn_buf(avformat.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(avformat.AVIOContext s,
                                 @Cast(value="uint8_t**")@ByPtrPtr
                                 BytePointer pbuffer)

avio_close_dyn_buf

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

avio_close_dyn_buf

@NoException
public static int avio_close_dyn_buf(avformat.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_pause
```
@NoException
public static int avio_pause(avformat.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(avformat.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(avformat.AVIOContext h,
                                  avformat.AVBPrint 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(avformat.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(avformat.AVIOContext s,
                          @ByPtrPtr
                          avformat.AVIOContext c)

avio_handshake
```
@NoException
public static int avio_handshake(avformat.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(avformat.AVIOContext s,
                            avcodec.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(avformat.AVIOContext s,
                               avcodec.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()

AVSTREAM_PARSE_FULL_RAW

@MemberGetter
public static int AVSTREAM_PARSE_FULL_RAW()

av_stream_get_r_frame_rate

@NoException
@ByVal
public static avutil.AVRational av_stream_get_r_frame_rate(@Const
                                                             avformat.AVStream s)

av_stream_set_r_frame_rate

@NoException
public static void av_stream_set_r_frame_rate(avformat.AVStream s,
                                          @ByVal
                                          avutil.AVRational r)

av_stream_get_parser

@NoException
public static avcodec.AVCodecParserContext av_stream_get_parser(@Const
                                                            avformat.AVStream s)

av_stream_get_recommended_encoder_configuration

@NoException
@Cast(value="char*")
public static BytePointer av_stream_get_recommended_encoder_configuration(@Const
                                                                                avformat.AVStream s)

av_stream_set_recommended_encoder_configuration

@NoException
public static void av_stream_set_recommended_encoder_configuration(avformat.AVStream s,
                                                               @Cast(value="char*")
                                                               BytePointer configuration)

av_stream_set_recommended_encoder_configuration

@NoException
public static void av_stream_set_recommended_encoder_configuration(avformat.AVStream s,
                                                               @Cast(value="char*")
                                                               ByteBuffer configuration)

av_stream_set_recommended_encoder_configuration

@NoException
public static void av_stream_set_recommended_encoder_configuration(avformat.AVStream s,
                                                               @Cast(value="char*")
                                                               byte[] configuration)

av_stream_get_end_pts

@NoException
@Cast(value="int64_t")
public static long av_stream_get_end_pts(@Const
                                               avformat.AVStream st)

Returns the pts of the last muxed packet + its duration the retuned value is undefined when used with a demuxer.

av_format_get_probe_score

@NoException
public static int av_format_get_probe_score(@Const
                                        avformat.AVFormatContext s)

av_format_get_video_codec

@NoException
public static avcodec.AVCodec av_format_get_video_codec(@Const
                                                    avformat.AVFormatContext s)

av_format_set_video_codec

@NoException
public static void av_format_set_video_codec(avformat.AVFormatContext s,
                                         avcodec.AVCodec c)

av_format_get_audio_codec

@NoException
public static avcodec.AVCodec av_format_get_audio_codec(@Const
                                                    avformat.AVFormatContext s)

av_format_set_audio_codec

@NoException
public static void av_format_set_audio_codec(avformat.AVFormatContext s,
                                         avcodec.AVCodec c)

av_format_get_subtitle_codec

@NoException
public static avcodec.AVCodec av_format_get_subtitle_codec(@Const
                                                       avformat.AVFormatContext s)

av_format_set_subtitle_codec

@NoException
public static void av_format_set_subtitle_codec(avformat.AVFormatContext s,
                                            avcodec.AVCodec c)

av_format_get_data_codec

@NoException
public static avcodec.AVCodec av_format_get_data_codec(@Const
                                                   avformat.AVFormatContext s)

av_format_set_data_codec

@NoException
public static void av_format_set_data_codec(avformat.AVFormatContext s,
                                        avcodec.AVCodec c)

av_format_get_metadata_header_padding

@NoException
public static int av_format_get_metadata_header_padding(@Const
                                                    avformat.AVFormatContext s)

av_format_set_metadata_header_padding

@NoException
public static void av_format_set_metadata_header_padding(avformat.AVFormatContext s,
                                                     int c)

av_format_get_opaque

@NoException
public static Pointer av_format_get_opaque(@Const
                                       avformat.AVFormatContext s)

av_format_set_opaque

@NoException
public static void av_format_set_opaque(avformat.AVFormatContext s,
                                    Pointer opaque)

av_format_get_control_message_cb

@NoException
public static avformat.av_format_control_message av_format_get_control_message_cb(@Const
                                                                              avformat.AVFormatContext s)

av_format_set_control_message_cb

@NoException
public static void av_format_set_control_message_cb(avformat.AVFormatContext s,
                                                avformat.av_format_control_message callback)

av_format_get_open_cb

@NoException
@Deprecated
public static avformat.AVOpenCallback av_format_get_open_cb(@Const
                                                                   avformat.AVFormatContext s)

Deprecated.

av_format_set_open_cb

@NoException
@Deprecated
public static void av_format_set_open_cb(avformat.AVFormatContext s,
                                                avformat.AVOpenCallback callback)

Deprecated.

av_format_inject_global_side_data
```
@NoException
public static void av_format_inject_global_side_data(avformat.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.

av_fmt_ctx_get_duration_estimation_method

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

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.

av_register_all
```
@NoException
public static void av_register_all()
```
Initialize libavformat and register all the muxers, demuxers and protocols. If you do not call this function, then you can select exactly which formats you want to support.

See Also:
av_register_input_format(), av_register_output_format()

av_register_input_format

@NoException
public static void av_register_input_format(avformat.AVInputFormat format)

av_register_output_format

@NoException
public static void av_register_output_format(avformat.AVOutputFormat format)

avformat_network_init
```
@NoException
public static int avformat_network_init()
```
Do global initialization of network components. This is optional, but recommended, since it avoids the overhead of implicitly doing the setup for each session. Calling this function will become mandatory if using network protocols at some major version bump.

avformat_network_deinit
```
@NoException
public static int avformat_network_deinit()
```
Undo the initialization done by avformat_network_init.

av_iformat_next

@NoException
public static avformat.AVInputFormat av_iformat_next(@Const
                                                 avformat.AVInputFormat f)

If f is NULL, returns the first registered input format, if f is non-NULL, returns the next registered input format after f or NULL if f is the last one.

av_oformat_next

@NoException
public static avformat.AVOutputFormat av_oformat_next(@Const
                                                  avformat.AVOutputFormat f)

If f is NULL, returns the first registered output format, if f is non-NULL, returns the next registered output format after f or NULL if f is the last one.

avformat_alloc_context
```
@NoException
public static avformat.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(avformat.AVFormatContext s)
```
Free an AVFormatContext and all its streams.

Parameters:
s - context to free

avformat_get_class
```
@NoException
@Const
public static avutil.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().

avformat_new_stream
```
@NoException
public static avformat.AVStream avformat_new_stream(avformat.AVFormatContext s,
                                                @Const
                                                avcodec.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 avcodec_close() and avformat_free_context() to clean up the allocation by avformat_new_stream().

Parameters:
s - media file handle
c - If non-NULL, the AVCodecContext corresponding to the new stream will be initialized to use this codec. This is needed for e.g. codec-specific defaults to be set, so codec should be provided if it is known.

Returns:
newly created stream or NULL on error.

av_stream_new_side_data

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

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*")
public static BytePointer av_stream_get_side_data(avformat.AVStream stream,
                                                        @Cast(value="AVPacketSideDataType")
                                                        int type,
                                                        IntPointer size)

Get side information from stream.

Parameters:: stream - stream; type - desired side information type; size - pointer for side information size to store (optional)
Returns:: pointer to data if present or NULL otherwise

av_stream_get_side_data

@NoException
@Cast(value="uint8_t*")
public static ByteBuffer av_stream_get_side_data(avformat.AVStream stream,
                                                       @Cast(value="AVPacketSideDataType")
                                                       int type,
                                                       IntBuffer size)

av_stream_get_side_data

@NoException
@Cast(value="uint8_t*")
public static byte[] av_stream_get_side_data(avformat.AVStream stream,
                                                   @Cast(value="AVPacketSideDataType")
                                                   int type,
                                                   int[] size)

av_new_program

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

avformat_alloc_output_context2

@NoException
public static int avformat_alloc_output_context2(@Cast(value="AVFormatContext**")
                                             PointerPointer ctx,
                                             avformat.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 - 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
                                             avformat.AVFormatContext ctx,
                                             avformat.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
                                             avformat.AVFormatContext ctx,
                                             avformat.AVOutputFormat oformat,
                                             String format_name,
                                             String filename)

av_find_input_format

@NoException
public static avformat.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
public static avformat.AVInputFormat av_find_input_format(String short_name)

av_probe_input_format
```
@NoException
public static avformat.AVInputFormat av_probe_input_format(avformat.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
public static avformat.AVInputFormat av_probe_input_format2(avformat.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
public static avformat.AVInputFormat av_probe_input_format2(avformat.AVProbeData pd,
                                                        int is_opened,
                                                        IntBuffer score_max)

av_probe_input_format2

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

av_probe_input_format3

@NoException
public static avformat.AVInputFormat av_probe_input_format3(avformat.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
public static avformat.AVInputFormat av_probe_input_format3(avformat.AVProbeData pd,
                                                        int is_opened,
                                                        IntBuffer score_ret)

av_probe_input_format3

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

av_probe_input_buffer2

@NoException
public static int av_probe_input_buffer2(avformat.AVIOContext pb,
                                     @Cast(value="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(avformat.AVIOContext pb,
                                     @ByPtrPtr
                                     avformat.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(avformat.AVIOContext pb,
                                     @ByPtrPtr
                                     avformat.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(avformat.AVIOContext pb,
                                    @Cast(value="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(avformat.AVIOContext pb,
                                    @ByPtrPtr
                                    avformat.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(avformat.AVIOContext pb,
                                    @ByPtrPtr
                                    avformat.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,
                                  avformat.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
                                  avformat.AVFormatContext ps,
                                  @Cast(value="const char*")
                                  BytePointer url,
                                  avformat.AVInputFormat fmt,
                                  @ByPtrPtr
                                  avutil.AVDictionary options)

avformat_open_input

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

av_demuxer_open

@NoException
@Deprecated
public static int av_demuxer_open(avformat.AVFormatContext ic)

Deprecated.

avformat_find_stream_info
```
@NoException
public static int avformat_find_stream_info(avformat.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(avformat.AVFormatContext ic,
                                        @ByPtrPtr
                                        avutil.AVDictionary options)

av_find_program_from_stream
```
@NoException
public static avformat.AVProgram av_find_program_from_stream(avformat.AVFormatContext ic,
                                                         avformat.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(avformat.AVFormatContext ac,
                                           int progid,
                                           @Cast(value="unsigned int")
                                           int idx)

av_find_best_stream
```
@NoException
public static int av_find_best_stream(avformat.AVFormatContext ic,
                                  @Cast(value="AVMediaType")
                                  int type,
                                  int wanted_stream_nb,
                                  int related_stream,
                                  @Cast(value="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(avformat.AVFormatContext ic,
                                  @Cast(value="AVMediaType")
                                  int type,
                                  int wanted_stream_nb,
                                  int related_stream,
                                  @ByPtrPtr
                                  avcodec.AVCodec decoder_ret,
                                  int flags)

av_read_frame
```
@NoException
public static int av_read_frame(avformat.AVFormatContext s,
                            avcodec.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. If pkt->buf is NULL, then the packet is valid until the next av_read_frame() or until avformat_close_input(). Otherwise the packet is valid indefinitely. In both cases 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

av_seek_frame
```
@NoException
public static int av_seek_frame(avformat.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(avformat.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. Thus do not use this yet. It may change at any time, do not expect ABI compatibility yet!

avformat_flush
```
@NoException
public static int avformat_flush(avformat.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(avformat.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(avformat.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
                                    avformat.AVFormatContext s)

avformat_write_header
```
@NoException
public static int avformat_write_header(avformat.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 oformat field must be set to the desired output format; Its 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.

Returns:
AVSTREAM_INIT_IN_WRITE_HEADER on success if the codec had not already been fully initialized in avformat_init, AVSTREAM_INIT_IN_INIT_OUTPUT on success if the codec had already been fully initialized in avformat_init, 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(avformat.AVFormatContext s,
                                    @ByPtrPtr
                                    avutil.AVDictionary options)

avformat_init_output
```
@NoException
public static int avformat_init_output(avformat.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 oformat field must be set to the desired output format; Its 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.

Returns:
AVSTREAM_INIT_IN_WRITE_HEADER on success if the codec requires avformat_write_header to fully initialize, AVSTREAM_INIT_IN_INIT_OUTPUT on success if the codec has been fully initialized, negative 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(avformat.AVFormatContext s,
                                   @ByPtrPtr
                                   avutil.AVDictionary options)

av_write_frame
```
@NoException
public static int av_write_frame(avformat.AVFormatContext s,
                             avcodec.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(avformat.AVFormatContext s,
                                         avcodec.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 in the order of 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. The caller must not access the data through this reference after this function returns. If the packet is not reference-counted, libavformat will make a copy.
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. Libavformat will always take care of freeing the packet, even if this function fails.
See Also:
av_write_frame(), AVFormatContext.max_interleave_delta

av_write_uncoded_frame
```
@NoException
public static int av_write_uncoded_frame(avformat.AVFormatContext s,
                                     int stream_index,
                                     avutil.AVFrame frame)
```
Write an uncoded frame to an output media file. The frame must be correctly interleaved according to the container specification; if not, then av_interleaved_write_frame() must be used. See av_interleaved_write_frame() for details.

av_interleaved_write_uncoded_frame
```
@NoException
public static int av_interleaved_write_uncoded_frame(avformat.AVFormatContext s,
                                                 int stream_index,
                                                 avutil.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(avformat.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(avformat.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
public static avformat.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
public static avformat.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(avformat.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(avformat.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(avformat.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
[out] - dts DTS of the last packet output for the stream, in stream time_base units
[out] - wall absolute time when that packet whas output, in microsecond

Returns:
0 if OK, AVERROR(ENOSYS) if 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(avformat.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(avformat.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
                            avcodec.AVPacket pkt,
                            int dump_payload,
                            @Const
                            avformat.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
                                avcodec.AVPacket pkt,
                                int dump_payload,
                                @Const
                                avformat.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
                                        avformat.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
                                         avformat.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
                                avformat.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
                                avformat.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
                                avformat.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(avformat.AVFormatContext s)

av_index_search_timestamp
```
@NoException
public static int av_index_search_timestamp(avformat.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

av_add_index_entry

@NoException
public static int av_add_index_entry(avformat.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(avformat.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(avformat.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
                            avformat.AVFormatContext ac,
                            int n_files,
                            @Cast(value="char*")
                            BytePointer buf,
                            int size)

av_sdp_create

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

av_sdp_create

@NoException
public static int av_sdp_create(@ByPtrPtr
                            avformat.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
                                   avformat.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 avformat.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 avformat.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 avformat.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 avformat.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 avutil.AVRational av_guess_sample_aspect_ratio(avformat.AVFormatContext format,
                                                               avformat.AVStream stream,
                                                               avutil.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 avutil.AVRational av_guess_frame_rate(avformat.AVFormatContext ctx,
                                                      avformat.AVStream stream,
                                                      avutil.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(avformat.AVFormatContext s,
                                              avformat.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(avformat.AVFormatContext s,
                                              avformat.AVStream st,
                                              String spec)

avformat_queue_attached_pictures

@NoException
public static int avformat_queue_attached_pictures(avformat.AVFormatContext s)

av_apply_bitstream_filters
```
@NoException
@Deprecated
public static int av_apply_bitstream_filters(avcodec.AVCodecContext codec,
                                                    avcodec.AVPacket pkt,
                                                    avcodec.AVBitStreamFilterContext bsfc)
```
Deprecated.

Apply a list of bitstream filters to a packet.

Parameters:
codec - AVCodecContext, usually from an AVStream
pkt - the packet to apply filters to. If, on success, the returned packet has size == 0 and side_data_elems == 0, it indicates that the packet should be dropped
bsfc - a NULL-terminated list of filters to apply

Returns:
>=0 on success; AVERROR code on failure

avformat_transfer_internal_stream_timing_info

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

Transfer internal timing information from one stream to another. This function is useful when doing stream copy.

Parameters:: ofmt - target output format for ost; ost - output stream which needs timings copy and adjustments; ist - reference input stream to copy timings from; copy_tb - define from where the stream codec timebase needs to be imported

av_stream_get_codec_timebase

@NoException
@ByVal
public static avutil.AVRational av_stream_get_codec_timebase(@Const
                                                               avformat.AVStream st)

Get the internal codec timebase from a stream.

Parameters:: st - input stream to extract the timebase from

Class avformat

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

AVIO_SEEKABLE_NORMAL

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

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_SHOW_IDS

AVFMT_RAWPICTURE

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_CAPTIONS

AV_DISPOSITION_DESCRIPTIONS

AV_DISPOSITION_METADATA

AV_PTS_WRAP_IGNORE

AV_PTS_WRAP_ADD_OFFSET

AV_PTS_WRAP_SUB_OFFSET