avformat (JavaCPP Presets for FFmpeg 2.7.1-1.0 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`
`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`
`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`
`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.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_VISUAL_IMPAIRED` stream for visual impaired audiences
`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_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_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` Oring this flag as into 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` Passing this as the "whence" parameter to a seek function causes it to return the filesize without seeking anywhere.
`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

All Methods Static Methods Concrete Methods Deprecated 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_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)`
`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)`
`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)` Return in 'buf' the path with '%d' replaced by a number.
`static int`	`av_get_frame_filename(BytePointer buf, int buf_size, String path, int number)`
`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 a 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 filename, Pointer logctx, int offset, int max_probe_size)`
`static int`	`av_probe_input_buffer(avformat.AVIOContext pb, avformat.AVInputFormat fmt, String filename, Pointer logctx, int offset, int max_probe_size)`
`static int`	`av_probe_input_buffer(avformat.AVIOContext pb, PointerPointer fmt, BytePointer filename, 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 filename, Pointer logctx, int offset, int max_probe_size)`
`static int`	`av_probe_input_buffer2(avformat.AVIOContext pb, avformat.AVInputFormat fmt, String filename, Pointer logctx, int offset, int max_probe_size)`
`static int`	`av_probe_input_buffer2(avformat.AVIOContext pb, PointerPointer fmt, BytePointer filename, 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 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 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 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 a 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 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 filename, avformat.AVInputFormat fmt, avutil.AVDictionary options)`
`static int`	`avformat_open_input(avformat.AVFormatContext ps, String filename, avformat.AVInputFormat fmt, avutil.AVDictionary options)`
`static int`	`avformat_open_input(PointerPointer ps, BytePointer filename, 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_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 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_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)`
`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)`
`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(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`	`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
- AVSEEK_SIZE
```
public static final int AVSEEK_SIZE
```
  Passing 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
```
  Oring this flag as into 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.
  
  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 single 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_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

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

Method Detail

avio_find_protocol_name

@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

public static String avio_find_protocol_name(String url)

avio_check
```
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.

avio_check

public static int avio_check(String url,
                             int flags)

avio_open_dir

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

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

avio_open_dir

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

avio_read_dir
```
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.

Returns:

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

avio_read_dir

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

avio_close_dir

public static int avio_close_dir(@Cast(value="AVIODirContext**")
                                 PointerPointer s)

Close directory.

Parameters:: s - directory read context.
Returns:: >=0 on success or negative on error.

avio_close_dir

public static int avio_close_dir(@ByPtrPtr
                                 avformat.AVIODirContext s)

avio_free_directory_entry

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

public static void avio_free_directory_entry(@ByPtrPtr
                                             avformat.AVIODirEntry entry)

avio_alloc_context

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

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

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

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

avio_write

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

avio_write

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

avio_write

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

avio_wl64

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

avio_wb64

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

avio_wl32

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

avio_wb32

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

avio_wl24

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

avio_wb24

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

avio_wl16

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

avio_wb16

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

avio_put_str

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

public static int avio_put_str(avformat.AVIOContext s,
                               String str)

avio_put_str16le

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

public static int avio_put_str16le(avformat.AVIOContext s,
                                   String str)

avio_put_str16be

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

public static int avio_put_str16be(avformat.AVIOContext s,
                                   String str)

avio_seek

public static long avio_seek(avformat.AVIOContext s,
                             long offset,
                             int whence)

fseek() equivalent for AVIOContext.

Returns:: new position or AVERROR.

avio_skip

public static long avio_skip(avformat.AVIOContext s,
                             long offset)

Skip given number of bytes forward

Returns:: new position or AVERROR.

avio_tell
```
public static long avio_tell(avformat.AVIOContext s)
```
ftell() equivalent for AVIOContext.

Returns:

position or AVERROR.

avio_size

public static long avio_size(avformat.AVIOContext s)

Get the filesize.

Returns:: filesize or AVERROR

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

Returns:

non zero if and only if end of file

url_feof

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

Deprecated. use avio_feof()

avio_printf

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

avio_printf

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

avio_flush
```
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

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

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

avio_read

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

avio_r8

public static int avio_r8(avformat.AVIOContext s)

avio_rl16

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

avio_rl24

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

avio_rl32

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

avio_rl64

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

avio_rb16

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

avio_rb24

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

avio_rb32

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

avio_rb64

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

avio_get_str
```
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

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

avio_get_str

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

avio_get_str16le

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

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

avio_get_str16le

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

avio_get_str16be

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

avio_get_str16be

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

avio_get_str16be

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

avio_open
```
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.

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

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

avio_open

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

avio_open2

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.

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

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

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

avio_close
```
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
```
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

public static int avio_closep(@ByPtrPtr
                              avformat.AVIOContext s)

avio_open_dyn_buf

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

public static int avio_open_dyn_buf(@ByPtrPtr
                                    avformat.AVIOContext s)

avio_close_dyn_buf
```
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 FF_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

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

avio_close_dyn_buf

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

avio_close_dyn_buf

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

avio_enum_protocols
```
@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

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

avio_pause
```
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
```
public 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. 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

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

av_get_packet
```
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
```
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

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

av_stream_set_r_frame_rate

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

av_stream_get_parser

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

av_stream_get_recommended_encoder_configuration

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

av_stream_set_recommended_encoder_configuration

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

av_stream_set_recommended_encoder_configuration

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

av_stream_set_recommended_encoder_configuration

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

av_stream_get_end_pts

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

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

av_format_get_video_codec

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

av_format_set_video_codec

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

av_format_get_audio_codec

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

av_format_set_audio_codec

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

av_format_get_subtitle_codec

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

av_format_set_subtitle_codec

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

av_format_get_data_codec

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

av_format_set_data_codec

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

av_format_get_metadata_header_padding

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

av_format_set_metadata_header_padding

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

av_format_get_opaque

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

av_format_set_opaque

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

av_format_get_control_message_cb

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

av_format_set_control_message_cb

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

av_format_get_open_cb

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

av_format_set_open_cb

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

av_format_inject_global_side_data
```
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

@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

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

Return the LIBAVFORMAT_VERSION_INT constant.

avformat_configuration

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

Return the libavformat build-time configuration.

avformat_license

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

Return the libavformat license.

av_register_all
```
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

public static void av_register_input_format(avformat.AVInputFormat format)

av_register_output_format

public static void av_register_output_format(avformat.AVOutputFormat format)

avformat_network_init
```
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
```
public static int avformat_network_deinit()
```
Undo the initialization done by avformat_network_init.

av_iformat_next

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

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

Parameters:

s - context to free

avformat_get_class
```
@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
```
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_get_side_data

@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

@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

@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

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

avformat_alloc_output_context2

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

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

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

av_find_input_format

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

public static avformat.AVInputFormat av_find_input_format(String short_name)

av_probe_input_format
```
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
```
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

public static avformat.AVInputFormat av_probe_input_format2(avformat.AVProbeData pd,
                                                            int is_opened,
                                                            IntBuffer score_max)

av_probe_input_format2

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

av_probe_input_format3

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

public static avformat.AVInputFormat av_probe_input_format3(avformat.AVProbeData pd,
                                                            int is_opened,
                                                            IntBuffer score_ret)

av_probe_input_format3

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

av_probe_input_buffer2

public static int av_probe_input_buffer2(avformat.AVIOContext pb,
                                         @Cast(value="AVInputFormat**")
                                         PointerPointer fmt,
                                         @Cast(value="const char*")
                                         BytePointer filename,
                                         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; filename - the filename 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

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

av_probe_input_buffer2

public static int av_probe_input_buffer2(avformat.AVIOContext pb,
                                         @ByPtrPtr
                                         avformat.AVInputFormat fmt,
                                         String filename,
                                         Pointer logctx,
                                         @Cast(value="unsigned int")
                                         int offset,
                                         @Cast(value="unsigned int")
                                         int max_probe_size)

av_probe_input_buffer

public static int av_probe_input_buffer(avformat.AVIOContext pb,
                                        @Cast(value="AVInputFormat**")
                                        PointerPointer fmt,
                                        @Cast(value="const char*")
                                        BytePointer filename,
                                        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

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

av_probe_input_buffer

public static int av_probe_input_buffer(avformat.AVIOContext pb,
                                        @ByPtrPtr
                                        avformat.AVInputFormat fmt,
                                        String filename,
                                        Pointer logctx,
                                        @Cast(value="unsigned int")
                                        int offset,
                                        @Cast(value="unsigned int")
                                        int max_probe_size)

avformat_open_input
```
public static int avformat_open_input(@Cast(value="AVFormatContext**")
                                      PointerPointer ps,
                                      @Cast(value="const char*")
                                      BytePointer filename,
                                      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.

filename - Name 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.

avformat_open_input

public static int avformat_open_input(@ByPtrPtr
                                      avformat.AVFormatContext ps,
                                      @Cast(value="const char*")
                                      BytePointer filename,
                                      avformat.AVInputFormat fmt,
                                      @ByPtrPtr
                                      avutil.AVDictionary options)

avformat_open_input

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

av_demuxer_open

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

Deprecated.

avformat_find_stream_info
```
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

avformat_find_stream_info

public static int avformat_find_stream_info(avformat.AVFormatContext ic,
                                            @ByPtrPtr
                                            avutil.AVDictionary options)

av_find_program_from_stream
```
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_find_best_stream
```
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

av_find_best_stream

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
```
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_free_packet 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
```
public static int av_seek_frame(avformat.AVFormatContext s,
                                int stream_index,
                                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
```
public 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. 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

avformat_flush
```
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
```
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
```
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

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

public static void avformat_close_input(@ByPtrPtr
                                        avformat.AVFormatContext s)

avformat_write_header
```
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:

0 on success, negative AVERROR on failure.

See Also:

av_opt_find, av_dict_set, avio_open, av_oformat_next.

avformat_write_header

public static int avformat_write_header(avformat.AVFormatContext s,
                                        @ByPtrPtr
                                        avutil.AVDictionary options)

av_write_frame
```
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". It is very strongly recommended that timing information (@ref AVPacket.pts "pts", @ref AVPacket.dts "dts", @ref AVPacket.duration "duration") is set to correct values.

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

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". It is very strongly recommended that timing information (@ref AVPacket.pts "pts", @ref AVPacket.dts "dts", @ref AVPacket.duration "duration") is set to correct values.

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
```
public static int av_write_uncoded_frame(avformat.AVFormatContext s,
                                         int stream_index,
                                         avutil.AVFrame frame)
```
Write a 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
```
public static int av_interleaved_write_uncoded_frame(avformat.AVFormatContext s,
                                                     int stream_index,
                                                     avutil.AVFrame frame)
```
Write a 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
```
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
```
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

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

public static avformat.AVOutputFormat av_guess_format(String short_name,
                                                      String filename,
                                                      String mime_type)

av_guess_codec

@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

@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
```
public static int av_get_output_timestamp(avformat.AVFormatContext s,
                                          int stream,
                                          LongPointer dts,
                                          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

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

public static int av_get_output_timestamp(avformat.AVFormatContext s,
                                          int stream,
                                          LongBuffer dts,
                                          LongBuffer wall)

av_get_output_timestamp

public static int av_get_output_timestamp(avformat.AVFormatContext s,
                                          int stream,
                                          long[] dts,
                                          long[] wall)

av_hex_dump

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

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

av_hex_dump

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

av_hex_dump_log
```
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

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

av_hex_dump_log

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

av_pkt_dump2

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

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

@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

@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

@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

@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

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

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

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

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

public static int av_find_default_stream_index(avformat.AVFormatContext s)

av_index_search_timestamp
```
public static int av_index_search_timestamp(avformat.AVStream st,
                                            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

public 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. Update the entry if the list already contains it.

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

av_url_split

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

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

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

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

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

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
```
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

public static void av_dump_format(avformat.AVFormatContext ic,
                                  int index,
                                  String url,
                                  int is_output)

av_get_frame_filename

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

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
Returns:: 0 if OK, -1 on format error

av_get_frame_filename

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

av_get_frame_filename

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

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

av_get_frame_filename

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

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

av_filename_number_test
```
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

public static int av_filename_number_test(String filename)

av_sdp_create
```
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

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

av_sdp_create

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

av_sdp_create

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

av_match_ext

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

public static int av_match_ext(String filename,
                               String extensions)

avformat_query_codec

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
```
@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
```
@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
```
@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
```
@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
```
@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

@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

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

avformat_match_stream_specifier

public static int avformat_match_stream_specifier(avformat.AVFormatContext s,
                                                  avformat.AVStream st,
                                                  String spec)

avformat_queue_attached_pictures

public static int avformat_queue_attached_pictures(avformat.AVFormatContext s)

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

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_CAPTIONS

AV_DISPOSITION_DESCRIPTIONS

AV_DISPOSITION_METADATA

AV_PTS_WRAP_IGNORE

AV_PTS_WRAP_ADD_OFFSET

AV_PTS_WRAP_SUB_OFFSET

AV_PROGRAM_RUNNING

AVFMTCTX_NOHEADER

AVFMT_DURATION_FROM_PTS

AVFMT_DURATION_FROM_STREAM

AVFMT_DURATION_FROM_BITRATE

AVSEEK_FLAG_BACKWARD