ffmpeg

package
v1.8.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 7, 2026 License: Apache-2.0 Imports: 9 Imported by: 0

Documentation

Overview

The low-level ffmpeg bindings for ffmpeg version 8.0. It's more likely you would use the higher-level package github.com/mutablelogic/go-media/pkg/ffmpeg which provides a more idiomatic interface to ffmpeg.

Ref: https://ffmpeg.org/doxygen/8.0/index.html

Index

Constants

View Source 
const (
	AV_CODEC_FLAG_UNALIGNED      AVCodecFlag  = C.AV_CODEC_FLAG_UNALIGNED
	AV_CODEC_FLAG_QSCALE         AVCodecFlag  = C.AV_CODEC_FLAG_QSCALE
	AV_CODEC_FLAG_4MV            AVCodecFlag  = C.AV_CODEC_FLAG_4MV
	AV_CODEC_FLAG_OUTPUT_CORRUPT AVCodecFlag  = C.AV_CODEC_FLAG_OUTPUT_CORRUPT
	AV_CODEC_FLAG_QPEL           AVCodecFlag  = C.AV_CODEC_FLAG_QPEL
	AV_CODEC_FLAG_RECON_FRAME    AVCodecFlag  = C.AV_CODEC_FLAG_RECON_FRAME
	AV_CODEC_FLAG_COPY_OPAQUE    AVCodecFlag  = C.AV_CODEC_FLAG_COPY_OPAQUE
	AV_CODEC_FLAG_FRAME_DURATION AVCodecFlag  = C.AV_CODEC_FLAG_FRAME_DURATION
	AV_CODEC_FLAG_PASS1          AVCodecFlag  = C.AV_CODEC_FLAG_PASS1
	AV_CODEC_FLAG_PASS2          AVCodecFlag  = C.AV_CODEC_FLAG_PASS2
	AV_CODEC_FLAG_LOOP_FILTER    AVCodecFlag  = C.AV_CODEC_FLAG_LOOP_FILTER
	AV_CODEC_FLAG_GRAY           AVCodecFlag  = C.AV_CODEC_FLAG_GRAY
	AV_CODEC_FLAG_PSNR           AVCodecFlag  = C.AV_CODEC_FLAG_PSNR
	AV_CODEC_FLAG_INTERLACED_DCT AVCodecFlag  = C.AV_CODEC_FLAG_INTERLACED_DCT
	AV_CODEC_FLAG_LOW_DELAY      AVCodecFlag  = C.AV_CODEC_FLAG_LOW_DELAY
	AV_CODEC_FLAG_GLOBAL_HEADER  AVCodecFlag  = C.AV_CODEC_FLAG_GLOBAL_HEADER
	AV_CODEC_FLAG_BITEXACT       AVCodecFlag  = C.AV_CODEC_FLAG_BITEXACT
	AV_CODEC_FLAG_AC_PRED        AVCodecFlag  = C.AV_CODEC_FLAG_AC_PRED
	AV_CODEC_FLAG_INTERLACED_ME  AVCodecFlag  = C.AV_CODEC_FLAG_INTERLACED_ME
	AV_CODEC_FLAG_CLOSED_GOP     AVCodecFlag  = C.AV_CODEC_FLAG_CLOSED_GOP
	AV_CODEC_FLAG2_FAST          AVCodecFlag2 = C.AV_CODEC_FLAG2_FAST
	AV_CODEC_FLAG2_NO_OUTPUT     AVCodecFlag2 = C.AV_CODEC_FLAG2_NO_OUTPUT
	AV_CODEC_FLAG2_LOCAL_HEADER  AVCodecFlag2 = C.AV_CODEC_FLAG2_LOCAL_HEADER
	AV_CODEC_FLAG2_CHUNKS        AVCodecFlag2 = C.AV_CODEC_FLAG2_CHUNKS
	AV_CODEC_FLAG2_IGNORE_CROP   AVCodecFlag2 = C.AV_CODEC_FLAG2_IGNORE_CROP
	AV_CODEC_FLAG2_SHOW_ALL      AVCodecFlag2 = C.AV_CODEC_FLAG2_SHOW_ALL
	AV_CODEC_FLAG2_EXPORT_MVS    AVCodecFlag2 = C.AV_CODEC_FLAG2_EXPORT_MVS
	AV_CODEC_FLAG2_SKIP_MANUAL   AVCodecFlag2 = C.AV_CODEC_FLAG2_SKIP_MANUAL
	AV_CODEC_FLAG2_RO_FLUSH_NOOP AVCodecFlag2 = C.AV_CODEC_FLAG2_RO_FLUSH_NOOP
	AV_CODEC_FLAG2_ICC_PROFILES  AVCodecFlag2 = C.AV_CODEC_FLAG2_ICC_PROFILES
)
View Source 
const (
	AV_PKT_FLAG_KEY     = C.AV_PKT_FLAG_KEY     // Packet contains a keyframe
	AV_PKT_FLAG_CORRUPT = C.AV_PKT_FLAG_CORRUPT // Packet is corrupted
)
View Source 
const (
	/**
	* ORing this as the "whence" parameter to a seek function causes it to
	* return the filesize without seeking anywhere. Supporting this is optional.
	* If it is not supported then the seek function will return <0.
	 */
	AVSEEK_SIZE = C.AVSEEK_SIZE

	/**
	 * Passing this flag as the "whence" parameter to a seek function causes it to
	 * seek by any means (like reopening and linear reading) or other normally unreasonable
	 * means that can be extremely slow.
	 * This may be ignored by the seek code.
	 */
	AVSEEK_FORCE = C.AVSEEK_FORCE
)
View Source 
const (
	AVERROR_BSF_NOT_FOUND      = C.AVERROR_BSF_NOT_FOUND      ///< Bitstream filter not found
	AVERROR_BUG                = C.AVERROR_BUG                ///< Internal bug, also see AVERROR_BUG2
	AVERROR_BUFFER_TOO_SMALL   = C.AVERROR_BUFFER_TOO_SMALL   ///< Buffer too small
	AVERROR_DECODER_NOT_FOUND  = C.AVERROR_DECODER_NOT_FOUND  ///< Decoder not found
	AVERROR_DEMUXER_NOT_FOUND  = C.AVERROR_DEMUXER_NOT_FOUND  ///< Demuxer not found
	AVERROR_ENCODER_NOT_FOUND  = C.AVERROR_ENCODER_NOT_FOUND  ///< Encoder not found
	AVERROR_EOF                = C.AVERROR_EOF                ///< End of file
	AVERROR_EXIT               = C.AVERROR_EXIT               ///< Immediate exit was requested; the called function should not be restarted
	AVERROR_EXTERNAL           = C.AVERROR_EXTERNAL           ///< Generic error in an external library
	AVERROR_FILTER_NOT_FOUND   = C.AVERROR_FILTER_NOT_FOUND   ///< Filter not found
	AVERROR_INVALIDDATA        = C.AVERROR_INVALIDDATA        ///< Invalid data found when processing input
	AVERROR_MUXER_NOT_FOUND    = C.AVERROR_MUXER_NOT_FOUND    ///< Muxer not found
	AVERROR_OPTION_NOT_FOUND   = C.AVERROR_OPTION_NOT_FOUND   ///< Option not found
	AVERROR_PATCHWELCOME       = C.AVERROR_PATCHWELCOME       ///< Not yet implemented in FFmpeg, patches welcome
	AVERROR_PROTOCOL_NOT_FOUND = C.AVERROR_PROTOCOL_NOT_FOUND ///< Protocol not found
	AVERROR_STREAM_NOT_FOUND   = C.AVERROR_STREAM_NOT_FOUND   ///< Stream not found
	AVERROR_BUG2               = C.AVERROR_BUG2               // This is semantically identical to AVERROR_BUG, it has been introduced in Libav after our AVERROR_BUG and with a modified value
	AVERROR_UNKNOWN            = C.AVERROR_UNKNOWN            ///< Unknown error, typically from an external library
	AVERROR_EXPERIMENTAL       = C.AVERROR_EXPERIMENTAL       ///< Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
	AVERROR_INPUT_CHANGED      = C.AVERROR_INPUT_CHANGED      ///< Input changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_OUTPUT_CHANGED)
	AVERROR_OUTPUT_CHANGED     = C.AVERROR_OUTPUT_CHANGED     ///< Output changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_INPUT_CHANGED)
	AVERROR_HTTP_BAD_REQUEST   = C.AVERROR_HTTP_BAD_REQUEST   // HTTP & RTSP errors
	AVERROR_HTTP_UNAUTHORIZED  = C.AVERROR_HTTP_UNAUTHORIZED  // HTTP & RTSP errors
	AVERROR_HTTP_FORBIDDEN     = C.AVERROR_HTTP_FORBIDDEN     // HTTP & RTSP errors
	AVERROR_HTTP_NOT_FOUND     = C.AVERROR_HTTP_NOT_FOUND     // HTTP & RTSP errors
	AVERROR_HTTP_OTHER_4XX     = C.AVERROR_HTTP_OTHER_4XX     // HTTP & RTSP errors
	AVERROR_HTTP_SERVER_ERROR  = C.AVERROR_HTTP_SERVER_ERROR  // HTTP & RTSP errors
)
View Source 
const (
	AV_PIX_FMT_FLAG_BE        = 1 << 0  // Big-endian
	AV_PIX_FMT_FLAG_PAL       = 1 << 1  // Paletted format
	AV_PIX_FMT_FLAG_BITSTREAM = 1 << 2  // Bitstream format
	AV_PIX_FMT_FLAG_HWACCEL   = 1 << 3  // Hardware accelerated format
	AV_PIX_FMT_FLAG_PLANAR    = 1 << 4  // Planar format
	AV_PIX_FMT_FLAG_RGB       = 1 << 5  // RGB-like format
	AV_PIX_FMT_FLAG_ALPHA     = 1 << 7  // Has alpha channel
	AV_PIX_FMT_FLAG_BAYER     = 1 << 8  // Bayer pattern
	AV_PIX_FMT_FLAG_FLOAT     = 1 << 9  // Floating point format
	AV_PIX_FMT_FLAG_XYZ       = 1 << 10 // XYZ color space
)

Pixel format flag constants

View Source 
const (
	AV_INPUT_BUFFER_PADDING_SIZE int = C.AV_INPUT_BUFFER_PADDING_SIZE
)

Variables

This section is empty.

Functions

func AVBufferSink_get_frame 

func AVBufferSink_get_frame(ctx *AVFilterContext, frame *AVFrame) error

Get a frame from the buffer sink.

func AVBufferSink_get_frame_flags 

func AVBufferSink_get_frame_flags(ctx *AVFilterContext, frame *AVFrame, flags int) error

Get a frame with flags from the buffer sink.

func AVBufferSink_get_h 

func AVBufferSink_get_h(ctx *AVFilterContext) int

Get the height from the buffer sink.

func AVBufferSink_get_sample_rate 

func AVBufferSink_get_sample_rate(ctx *AVFilterContext) int

Get the sample rate from the buffer sink (audio).

func AVBufferSink_get_w 

func AVBufferSink_get_w(ctx *AVFilterContext) int

Get the width from the buffer sink.

func AVBufferSink_set_frame_size 

func AVBufferSink_set_frame_size(ctx *AVFilterContext, frame_size uint)

Set the frame size for the buffer sink.

func AVBufferSrc_add_frame 

func AVBufferSrc_add_frame(ctx *AVFilterContext, frame *AVFrame) error

Add a frame to the buffer source (simplified version without flags).

func AVBufferSrc_add_frame_flags 

func AVBufferSrc_add_frame_flags(ctx *AVFilterContext, frame *AVFrame, flags AVBufferSrcFlag) error

Add a frame to the buffer source.

func AVBufferSrc_close 

func AVBufferSrc_close(ctx *AVFilterContext, pts int64, flags AVBufferSrcFlag) error

Close the buffer source.

func AVBufferSrc_write_frame 

func AVBufferSrc_write_frame(ctx *AVFilterContext, frame *AVFrame) error

Write a frame to the buffer source.

func AVCodec_configuration 

func AVCodec_configuration() string

Return the libavcodec build-time configuration.

func AVCodec_encode_subtitle 

func AVCodec_encode_subtitle(ctx *AVCodecContext, buf []byte, sub *AVSubtitle) (int, error)

Encode subtitles to a buffer. Returns the number of bytes written to buf on success, or a negative error code on failure. Note: Subtitles use a legacy API and don't support the send/receive pattern.

func AVCodec_flush_buffers 

func AVCodec_flush_buffers(ctx *AVCodecContext)

Reset the internal codec state and flush internal buffers. Should be called before seeking or when switching to a different stream. Note: This does not flush the AVCodecContext, only the internal codec buffers.

func AVCodec_free_context 

func AVCodec_free_context(ctx *AVCodecContext)

Free the codec context and everything associated with it.

func AVCodec_grow_packet 

func AVCodec_grow_packet(pkt *AVPacket, size int) error

Increase packet size, correctly zeroing padding.

func AVCodec_is_decoder 

func AVCodec_is_decoder(codec *AVCodec) bool

Return true if codec is a decoder, false otherwise.

func AVCodec_is_encoder 

func AVCodec_is_encoder(codec *AVCodec) bool

Return true if codec is an encoder, false otherwise.

func AVCodec_license 

func AVCodec_license() string

Return the libavcodec license.

func AVCodec_new_packet 

func AVCodec_new_packet(pkt *AVPacket, size int) error

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

func AVCodec_open 

func AVCodec_open(ctx *AVCodecContext, codec *AVCodec, options *AVDictionary) error

Initialize the AVCodecContext to use the given AVCodec.

func AVCodec_packet_free 

func AVCodec_packet_free(packet *AVPacket)

Free the packet, if the packet is reference counted, it will be unreferenced first.

func AVCodec_packet_freep 

func AVCodec_packet_freep(packet **AVPacket)

Free the packet and set the caller's pointer to nil.

Prefer this over AVCodec_packet_free when you want to avoid accidental use-after-free of a stale Go pointer.

func AVCodec_packet_from_data 

func AVCodec_packet_from_data(pkt *AVPacket, data []byte) error

Create a new packet with a copy of the provided data

func AVCodec_packet_ref 

func AVCodec_packet_ref(dst, src *AVPacket) error

Setup dst as a reference to src (increment reference count without copying data). More efficient than clone when you just need another reference to the same data.

func AVCodec_packet_rescale_ts 

func AVCodec_packet_rescale_ts(pkt *AVPacket, tb_src, tb_dst AVRational)

Convert valid timing fields (timestamps / durations) in a packet from one timebase to another.

func AVCodec_packet_unref 

func AVCodec_packet_unref(packet *AVPacket)

Wipe the packet and unreference any buffer.

func AVCodec_parameters_copy 

func AVCodec_parameters_copy(ctx *AVCodecParameters, codecpar *AVCodecParameters) error

From fill the parameters based on the values from the supplied codec parameters

func AVCodec_parameters_free 

func AVCodec_parameters_free(par *AVCodecParameters)

Free an AVCodecParameters instance and everything associated with it.

func AVCodec_parameters_from_context 

func AVCodec_parameters_from_context(codecpar *AVCodecParameters, ctx *AVCodecContext) error

Fill the parameters struct based on the values from the supplied codec context (encoding)

func AVCodec_parameters_to_context 

func AVCodec_parameters_to_context(ctx *AVCodecContext, codecpar *AVCodecParameters) error

Fill the codec context based on the values from the supplied codec parameters (decoding)

func AVCodec_parser_close 

func AVCodec_parser_close(parser *AVCodecParserContext)

Close and free a parser context.

func AVCodec_parser_parse 

func AVCodec_parser_parse(parser *AVCodecParserContext, ctx *AVCodecContext, packet *AVPacket, buf []byte, pts int64, dts int64, pos int64) int

Parse a packet from input buffer.

func AVCodec_receive_frame 

func AVCodec_receive_frame(ctx *AVCodecContext, frame *AVFrame) error

Return decoded output data from a decoder. Returns syscall.EAGAIN if more input is needed to produce output. Returns io.EOF when the decoder has been flushed and no more output is available. Returns syscall.EINVAL if the codec is not opened or requires encoder parameters.

func AVCodec_receive_packet 

func AVCodec_receive_packet(ctx *AVCodecContext, pkt *AVPacket) error

Return encoded output data from an encoder. Returns syscall.EAGAIN if more input is needed to produce output. Returns io.EOF when the encoder has been flushed and no more output is available. Returns syscall.EINVAL if the codec is not opened or requires decoder parameters.

func AVCodec_send_frame 

func AVCodec_send_frame(ctx *AVCodecContext, frame *AVFrame) error

Supply a raw video or audio frame to the encoder. Pass nil to flush the encoder and signal end of stream. Returns syscall.EAGAIN if the encoder cannot accept more input at this time. Returns syscall.EINVAL if the codec is not opened or requires encoder parameters.

func AVCodec_send_packet 

func AVCodec_send_packet(ctx *AVCodecContext, pkt *AVPacket) error

Supply raw packet data as input to a decoder. Pass nil to flush the decoder and signal end of stream. Returns syscall.EAGAIN if the decoder cannot accept more input at this time. Returns syscall.EINVAL if the codec is not opened or requires decoder parameters.

func AVCodec_shrink_packet 

func AVCodec_shrink_packet(pkt *AVPacket, size int)

Reduce packet size, correctly zeroing padding.

func AVCodec_version 

func AVCodec_version() uint

Return the LIBAVCODEC_VERSION_INT constant.

func AVDevice_configuration 

func AVDevice_configuration() string

Return the libavdevice build-time configuration.

func AVDevice_free_list_devices 

func AVDevice_free_list_devices(device_list *AVDeviceInfoList)

func AVDevice_license 

func AVDevice_license() string

Return the libavdevice license.

func AVDevice_version 

func AVDevice_version() uint

Return the LIBAVDEVICE_VERSION_INT constant.

func AVFilterContext_free 

func AVFilterContext_free(ctx *AVFilterContext)

Free a filter context. This will also remove the filter from the graph's list of filters. 

func AVFilterContext_link(src *AVFilterContext, srcpad uint, dst *AVFilterContext, dstpad uint) error

Link two filters together.

func AVFilterGraph_config 

func AVFilterGraph_config(graph *AVFilterGraph) error

Check validity and configure all the links and formats in the graph.

func AVFilterGraph_dump 

func AVFilterGraph_dump(graph *AVFilterGraph) string

Dump the graph out. The graph should be configured first with AVFilterGraph_config for a complete dump. Returns empty string if graph cannot be dumped or is nil.

func AVFilterGraph_free 

func AVFilterGraph_free(graph *AVFilterGraph)

func AVFilterGraph_parse 

func AVFilterGraph_parse(graph *AVFilterGraph, filters string) ([]*AVFilterInOut, []*AVFilterInOut, error)

Add a graph described by a string to a graph, returning inputs and outputs. Will return an error if not all inputs and outputs are specified. The inputs and outputs should be freed with AVFilterInOut_free() when no longer needed.

func AVFilterInOut_free 

func AVFilterInOut_free(inout *AVFilterInOut)

Free the entire linked list of AVFilterInOut entries starting from the given entry. This calls avfilter_inout_free() which frees the supplied list and all entries linked via the 'next' field. Only call this on the head of a list or on an unlinked entry to avoid double-free issues.

func AVFilterInOut_list_free 

func AVFilterInOut_list_free(list []*AVFilterInOut)

Free an array of AVFilterInOut entries, given the first entry.

func AVFilter_configuration 

func AVFilter_configuration() string

Return the libavfilter build-time configuration.

func AVFilter_inputs 

func AVFilter_inputs(filter *AVFilter) uint

Return number of input pads for a filter.

func AVFilter_license 

func AVFilter_license() string

Return the libavfilter license.

func AVFilter_outputs 

func AVFilter_outputs(filter *AVFilter) uint

Return number of output pads for a filter.

func AVFilter_version 

func AVFilter_version() uint

Return the LIBAVFILTER_VERSION_INT constant.

func AVFormat_avio_close 

func AVFormat_avio_close(ctx *AVIOContextEx) error

Close the resource and free it. This function can only be used if it was opened by avio_open().

func AVFormat_avio_context_free 

func AVFormat_avio_context_free(ctx *AVIOContextEx)

avio_context_free

func AVFormat_avio_flush 

func AVFormat_avio_flush(ctx *AVIOContextEx)

avio_flush

func AVFormat_avio_put_str 

func AVFormat_avio_put_str(ctx *AVIOContextEx, str string) int

avio_put_str

func AVFormat_avio_read 

func AVFormat_avio_read(ctx *AVIOContextEx, buf []byte) int

avio_read

func AVFormat_avio_seek 

func AVFormat_avio_seek(ctx *AVIOContextEx, offset int64, whence int) int64

avio_seek whence: SEEK_SET, SEEK_CUR, SEEK_END (like fseek) and AVSEEK_SIZE

func AVFormat_avio_w8 

func AVFormat_avio_w8(ctx *AVIOContextEx, b int)

avio_w8

func AVFormat_avio_wl64 

func AVFormat_avio_wl64(ctx *AVIOContextEx, b uint64)

avio_wl64

func AVFormat_avio_write 

func AVFormat_avio_write(ctx *AVIOContextEx, buf []byte)

avio_write

func AVFormat_close_input 

func AVFormat_close_input(ctx *AVFormatContext)

Close an opened input AVFormatContext, free it and all its contents.

func AVFormat_close_writer 

func AVFormat_close_writer(ctx *AVFormatContext) error

Close an output writer and free resources. Closes the I/O context if it was opened by AVFormat_create_file. Does not close custom I/O contexts created by AVFormat_open_writer.

func AVFormat_configuration added in v1.8.1 

func AVFormat_configuration() string

Return the libavformat build-time configuration.

func AVFormat_dump_format 

func AVFormat_dump_format(ctx *AVFormatContext, stream_index int, filename string)

func AVFormat_find_stream_info 

func AVFormat_find_stream_info(ctx *AVFormatContext, options *AVDictionary) error

Read packets of a media file to get stream information.

func AVFormat_flush 

func AVFormat_flush(ctx *AVFormatContext) error

Discard all internally buffered data.

func AVFormat_free_context 

func AVFormat_free_context(ctx *AVFormatContext)

Free an AVFormatContext and all its streams.

func AVFormat_init_output 

func AVFormat_init_output(ctx *AVFormatContext, options *AVDictionary) error

Allocate the stream private data and initialize the codec, but do not write the header. May optionally be used before avformat_write_header() to initialize stream parameters before actually writing the header.

func AVFormat_interleaved_write_frame 

func AVFormat_interleaved_write_frame(ctx *AVFormatContext, pkt *AVPacket) error

Write a packet to an output media file ensuring correct interleaving. This function will buffer the packets internally as needed to make sure the packets in the output file are properly interleaved, usually ordered by increasing dts. Callers doing their own interleaving should call AVFormat_write_frame() instead of this function.

func AVFormat_license added in v1.8.1 

func AVFormat_license() string

Return the libavformat license.

func AVFormat_read_frame 

func AVFormat_read_frame(ctx *AVFormatContext, packet *AVPacket) error

Read a frame from the input stream. Return io.EOF if the end of the stream is reached.

func AVFormat_read_pause 

func AVFormat_read_pause(ctx *AVFormatContext) error

Pause a network-based stream (e.g. RTSP stream).

func AVFormat_read_play 

func AVFormat_read_play(ctx *AVFormatContext) error

Start playing a network-based stream (e.g. RTSP stream) at the current position.

func AVFormat_seek_file 

func AVFormat_seek_file(ctx *AVFormatContext, stream int, min_ts, ts, max_ts int64, flags AVSeekFlag) error

Seek to the keyframe at timestamp.

func AVFormat_seek_frame 

func AVFormat_seek_frame(ctx *AVFormatContext, stream int, ts int64, flags AVSeekFlag) error

Seek to timestamp ts.

func AVFormat_version added in v1.8.1 

func AVFormat_version() uint

Return the LIBAVFORMAT_VERSION_INT constant.

func AVFormat_write_frame 

func AVFormat_write_frame(ctx *AVFormatContext, pkt *AVPacket) error

Write a packet to an output media file without interleaving. The caller is responsible for correctly interleaving the packets if the codec requires it. Most callers should use AVFormat_interleaved_write_frame() instead for proper interleaving.

func AVFormat_write_header 

func AVFormat_write_header(ctx *AVFormatContext, options *AVDictionary) error

Allocate the stream private data and write the stream header to an output media file.

func AVFormat_write_trailer 

func AVFormat_write_trailer(ctx *AVFormatContext) error

Write the stream trailer to an output media file and free the file private data.

func AVSubtitle_free 

func AVSubtitle_free(sub *AVSubtitle)

Free all allocated data in the given subtitle struct.

func AVUtil_channel_description 

func AVUtil_channel_description(channel AVChannel) (string, error)

Get a human readable string describing a given channel.

func AVUtil_channel_layout_check 

func AVUtil_channel_layout_check(ch_layout *AVChannelLayout) bool

Check whether a channel layout is valid

func AVUtil_channel_layout_compare 

func AVUtil_channel_layout_compare(a *AVChannelLayout, b *AVChannelLayout) bool

Check whether two channel layouts are semantically the same

func AVUtil_channel_layout_default 

func AVUtil_channel_layout_default(ch_layout *AVChannelLayout, nb_channels int)

Get the default channel layout for a given number of channels.

func AVUtil_channel_layout_describe 

func AVUtil_channel_layout_describe(channel_layout *AVChannelLayout) (string, error)

Get a human-readable string describing the channel layout properties.

func AVUtil_channel_layout_from_string 

func AVUtil_channel_layout_from_string(ch_layout *AVChannelLayout, str string) error

Return channel layout from a description

func AVUtil_channel_layout_index_from_channel 

func AVUtil_channel_layout_index_from_channel(ch_layout *AVChannelLayout, channel AVChannel) int

Get the index of a given channel in a channel layout.

func AVUtil_channel_layout_uninit 

func AVUtil_channel_layout_uninit(ch_layout *AVChannelLayout)

Free any allocated data in the channel layout and reset the channel count to 0.

func AVUtil_channel_name 

func AVUtil_channel_name(channel AVChannel) (string, error)

Get the name of a given channel.

func AVUtil_compare_ts 

func AVUtil_compare_ts(a int64, a_tb AVRational, b int64, b_tb AVRational) int

Compare two timestamps each in its own time base. Returns -1 if a is before b, 1 if a is after b, or 0 if they are equal.

func AVUtil_configuration 

func AVUtil_configuration() string

Return the libavformat build-time configuration.

func AVUtil_dict_count 

func AVUtil_dict_count(dict *AVDictionary) int

Get the number of entries in the dictionary.

func AVUtil_dict_free 

func AVUtil_dict_free(dict *AVDictionary)

Free a dictionary and all entries in the dictionary.

func AVUtil_dict_keys 

func AVUtil_dict_keys(dict *AVDictionary) []string

Get the keys for the dictionary.

func AVUtil_dict_parse_string 

func AVUtil_dict_parse_string(dict *AVDictionary, opts, key_value_sep, pairs_sep string, flags AVDictionaryFlag) error

Parse the key/value pairs list and add the parsed entries to a dictionary.

func AVUtil_dict_set 

func AVUtil_dict_set(dict *AVDictionary, key, value string, flags AVDictionaryFlag) error

Set the given entry, overwriting an existing entry.

func AVUtil_frame_copy 

func AVUtil_frame_copy(dst, src *AVFrame) error

Copy frame data

func AVUtil_frame_copy_props 

func AVUtil_frame_copy_props(dst, src *AVFrame) error

Copy only "metadata" fields from src to dst, those fields that do not affect the data layout in the buffers. E.g. pts, sample rate (for audio) or sample aspect ratio (for video), but not width/height or channel layout. Side data is also copied.

func AVUtil_frame_free 

func AVUtil_frame_free(frame *AVFrame)

Free the frame and any dynamically allocated objects in it

func AVUtil_frame_get_buffer 

func AVUtil_frame_get_buffer(frame *AVFrame, align bool) error

Allocate new buffer(s) for audio or video data. The following fields must be set on frame before calling this function: format, width and height for video, format, nb_samples and ch_layout for audio

func AVUtil_frame_get_num_planes 

func AVUtil_frame_get_num_planes(frame *AVFrame) int

Return the number of planes in the frame data.

func AVUtil_frame_is_allocated 

func AVUtil_frame_is_allocated(frame *AVFrame) bool

func AVUtil_frame_make_writable 

func AVUtil_frame_make_writable(frame *AVFrame) error

Ensure that the frame data is writable, avoiding data copy if possible. Do nothing if the frame is writable, allocate new buffers and copy the data if it is not. Non-refcounted frames behave as non-writable, i.e. a copy is always made.

func AVUtil_frame_unref 

func AVUtil_frame_unref(frame *AVFrame)

Unreference all the buffers referenced by frame and reset the frame fields.

func AVUtil_get_bits_per_pixel 

func AVUtil_get_bits_per_pixel(pixfmt AVPixelFormat) int

Return the number of bits per pixel for a pixel format

func AVUtil_get_bytes_per_sample 

func AVUtil_get_bytes_per_sample(sample_fmt AVSampleFormat) int

Return number of bytes per sample.

func AVUtil_get_channel_layout_nb_channels 

func AVUtil_get_channel_layout_nb_channels(ch_layout *AVChannelLayout) int

Return number of channels

func AVUtil_get_padded_bits_per_pixel 

func AVUtil_get_padded_bits_per_pixel(pixfmt AVPixelFormat) int

Return the number of bits per pixel for a pixel format, including padding

func AVUtil_get_picture_type_char 

func AVUtil_get_picture_type_char(pict_type AVPictureType) rune

Return a single character representing the picture type

func AVUtil_get_pix_fmt_name 

func AVUtil_get_pix_fmt_name(pixfmt AVPixelFormat) string

func AVUtil_get_sample_fmt_name 

func AVUtil_get_sample_fmt_name(sample_fmt AVSampleFormat) string

Return the name of sample_fmt, or empty string if sample_fmt is not recognized

func AVUtil_license 

func AVUtil_license() string

Return the libavformat license.

func AVUtil_log 

func AVUtil_log(class *AVClass, level AVLog, v string, args ...any)

Send the specified message to the log if the level is less than or equal to the current av_log_level.

func AVUtil_log_set_callback 

func AVUtil_log_set_callback(cb AVLogFunc)

Set callback for logging. If cb is nil, the default callback will be set.

func AVUtil_log_set_level 

func AVUtil_log_set_level(level AVLog)

func AVUtil_parse_time 

func AVUtil_parse_time(timestr string, duration bool) (int64, error)

AVUtil_parse_time parses a time string and returns the time in microseconds. The time string can be in various formats:

  • [-][HH:]MM:SS[.m...]
  • [-]S+[.m...]

If duration is true, the parsing is for a duration (can be negative).

Returns time in microseconds and error if parsing fails.

func AVUtil_parse_video_size 

func AVUtil_parse_video_size(size string) (int, int, error)

AVUtil_parse_video_size parses a string representing a video size and returns the width and height. The string can be in the format "WIDTHxHEIGHT" (e.g., "1920x1080") or a named resolution (e.g., "vga", "hd720", "hd1080", "4k").

Returns width, height, and error if parsing fails.

func AVUtil_pix_fmt_count_planes 

func AVUtil_pix_fmt_count_planes(pixfmt AVPixelFormat) int

Return the number of planes in pix_fmt

func AVUtil_pix_fmt_flags 

func AVUtil_pix_fmt_flags(pixfmt AVPixelFormat) uint64

Return the flags for a pixel format

func AVUtil_pix_fmt_has_alpha 

func AVUtil_pix_fmt_has_alpha(pixfmt AVPixelFormat) bool

Check if pixel format has alpha

func AVUtil_pix_fmt_is_be 

func AVUtil_pix_fmt_is_be(pixfmt AVPixelFormat) bool

Check if pixel format is big-endian

func AVUtil_pix_fmt_is_float 

func AVUtil_pix_fmt_is_float(pixfmt AVPixelFormat) bool

Check if pixel format is floating point

func AVUtil_pix_fmt_is_hwaccel 

func AVUtil_pix_fmt_is_hwaccel(pixfmt AVPixelFormat) bool

Check if pixel format is hardware accelerated

func AVUtil_pix_fmt_is_planar 

func AVUtil_pix_fmt_is_planar(pixfmt AVPixelFormat) bool

Check if pixel format is planar

func AVUtil_pix_fmt_is_rgb 

func AVUtil_pix_fmt_is_rgb(pixfmt AVPixelFormat) bool

Check if pixel format is RGB-like

func AVUtil_pix_fmt_num_components 

func AVUtil_pix_fmt_num_components(pixfmt AVPixelFormat) int

Return the number of components for a pixel format

func AVUtil_rational_equal 

func AVUtil_rational_equal(a, b AVRational) bool

Compare two rationals.

func AVUtil_rational_q2d 

func AVUtil_rational_q2d(a AVRational) float64

Convert an AVRational to a float64.

func AVUtil_rational_rescale_q 

func AVUtil_rational_rescale_q(a int64, bq AVRational, cq AVRational) int64

Rescale a rational

func AVUtil_rescale_rnd 

func AVUtil_rescale_rnd(a, b, c int64, rnd AVRounding) int64

Rescale a value from one range to another.

func AVUtil_sample_fmt_is_planar 

func AVUtil_sample_fmt_is_planar(sample_fmt AVSampleFormat) bool

Check if the sample format is planar.

func AVUtil_ts2str 

func AVUtil_ts2str(ts int64) string

Convenience function: convert timestamp to string

func AVUtil_ts2timestr 

func AVUtil_ts2timestr(ts int64, tb *AVRational) string

Convenience function: convert timestamp and time base to time string

func AVUtil_ts_make_string 

func AVUtil_ts_make_string(ts int64) string

Convert a timestamp to a string representation

func AVUtil_ts_make_time_string 

func AVUtil_ts_make_time_string(ts int64, tb *AVRational) string

Convert a timestamp and time base to a time string representation

func AVUtil_version 

func AVUtil_version() uint

Return the LIBAVFORMAT_VERSION_INT constant.

func SWResample_close 

func SWResample_close(ctx *SWRContext)

Closes the context so that swr_is_initialized() returns 0

func SWResample_config_frame 

func SWResample_config_frame(ctx *SWRContext, src, dest *AVFrame) error

Configure or reconfigure the SwrContext using the information provided by the AVFrames.

func SWResample_configuration 

func SWResample_configuration() string

Return the swr build-time configuration.

func SWResample_convert_frame 

func SWResample_convert_frame(ctx *SWRContext, src, dest *AVFrame) error

Convert the samples in the input AVFrame and write them to the output AVFrame.

func SWResample_drop_output 

func SWResample_drop_output(ctx *SWRContext, count int) error

Drops the specified number of output samples.

func SWResample_free 

func SWResample_free(ctx *SWRContext)

Free the given SwrContext.

func SWResample_get_delay 

func SWResample_get_delay(ctx *SWRContext, base int64) int64

Gets the delay the next input sample will experience relative to the next output sample.

func SWResample_get_out_samples 

func SWResample_get_out_samples(ctx *SWRContext, in_samples int) (int, error)

Find an upper bound on the number of samples that the next swr_convert call will output, if called with in_samples of input samples.

func SWResample_init 

func SWResample_init(ctx *SWRContext) error

Initialize context after user parameters have been set.

func SWResample_inject_silence 

func SWResample_inject_silence(ctx *SWRContext, count int) error

Inject the specified number of silence samples.

func SWResample_is_initialized 

func SWResample_is_initialized(ctx *SWRContext) bool

Check whether an swr context has been initialized or not.

func SWResample_license 

func SWResample_license() string

Return the swr license.

func SWResample_next_pts 

func SWResample_next_pts(ctx *SWRContext, pts int64) int64

Convert the next timestamp from input to output timestamps are in 1/(in_sample_rate * out_sample_rate) units.

func SWResample_set_opts 

func SWResample_set_opts(ctx *SWRContext, out_ch_layout AVChannelLayout, out_sample_fmt AVSampleFormat, out_sample_rate int, in_ch_layout AVChannelLayout, in_sample_fmt AVSampleFormat, in_sample_rate int) error

Set common parameters for resampling.

func SWResample_version 

func SWResample_version() uint

Return the LIBSWRESAMPLE_VERSION_INT constant.

func SWScale_configuration 

func SWScale_configuration() string

Return the swr build-time configuration.

func SWScale_frame_end 

func SWScale_frame_end(ctx *SWSContext)

Finish the scaling process for a pair of source/destination frames.

func SWScale_frame_start 

func SWScale_frame_start(ctx *SWSContext, dest, src *AVFrame) error

Initialize the scaling process for a given pair of source/destination frames.

func SWScale_free_context 

func SWScale_free_context(ctx *SWSContext)

Free the swscaler context swsContext.

func SWScale_init_context 

func SWScale_init_context(ctx *SWSContext, src, dst *SWSFilter)

Initialize the swscaler context sws_context.

func SWScale_license 

func SWScale_license() string

Return the swr license.

func SWScale_receive_slice 

func SWScale_receive_slice(ctx *SWSContext, slice_start, slice_height uint) error

Request a horizontal slice of the output data to be written into the frame

func SWScale_scale 

func SWScale_scale(ctx *SWSContext, src [][]byte, src_stride []int, src_slice_y, src_slice_height int, dest [][]byte, dest_stride []int) int

Scale the image slice in src and put the resulting scaled slice in the image in dst. Returns the height of the output slice.

func SWScale_scale_frame 

func SWScale_scale_frame(ctx *SWSContext, dest, src *AVFrame, native bool) error

Scale source data from src and write the output to dst.

The native parameter controls which FFmpeg API is used:

  • native=true: Uses sws_scale_frame() - works in dynamic mode with uninitialized context (created via SWScale_alloc_context). Returns -22 (EINVAL) when used with initialized context (created via SWScale_get_context).
  • native=false: Uses sws_frame_start/send_slice/receive_slice/frame_end sequence - works with both initialized and uninitialized contexts.

For best compatibility, use native=false or use an uninitialized context (SWScale_alloc_context) with native=true.

func SWScale_send_slice 

func SWScale_send_slice(ctx *SWSContext, slice_start, slice_height uint) error

Indicate that a horizontal slice of input data is available in the source frame

func SWScale_version 

func SWScale_version() uint

Return the LIBSWSCALE_VERSION_INT constant.

Types

type AVAppToDevMessageType 

type AVAppToDevMessageType C.enum_AVAppToDevMessageType

type AVBufferSrcFlag 

type AVBufferSrcFlag C.int
const (
	AV_BUFFERSRC_FLAG_NONE            AVBufferSrcFlag = 0
	AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT AVBufferSrcFlag = C.AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT
	AV_BUFFERSRC_FLAG_PUSH            AVBufferSrcFlag = C.AV_BUFFERSRC_FLAG_PUSH
	AV_BUFFERSRC_FLAG_KEEP_REF        AVBufferSrcFlag = C.AV_BUFFERSRC_FLAG_KEEP_REF
)

type AVChannel 

type AVChannel C.enum_AVChannel

func AVUtil_channel_from_string 

func AVUtil_channel_from_string(name string) AVChannel

This is the inverse function of av_channel_name.

func AVUtil_channel_layout_channel_from_index 

func AVUtil_channel_layout_channel_from_index(ch_layout *AVChannelLayout, index int) AVChannel

Get the channel with the given index in a channel layout.

type AVChannelLayout 

type AVChannelLayout C.AVChannelLayout

func AVBufferSink_get_ch_layout 

func AVBufferSink_get_ch_layout(ctx *AVFilterContext) AVChannelLayout

Get the channel layout from the buffer sink (audio).

func AVUtil_channel_layout_standard 

func AVUtil_channel_layout_standard(iterator *uintptr) *AVChannelLayout

Iterate over all standard channel layouts.

func AV_CHANNEL_LAYOUT_22POINT2 

func AV_CHANNEL_LAYOUT_22POINT2() AVChannelLayout

func AV_CHANNEL_LAYOUT_2POINT1 

func AV_CHANNEL_LAYOUT_2POINT1() AVChannelLayout

func AV_CHANNEL_LAYOUT_2_1 

func AV_CHANNEL_LAYOUT_2_1() AVChannelLayout

func AV_CHANNEL_LAYOUT_2_2 

func AV_CHANNEL_LAYOUT_2_2() AVChannelLayout

func AV_CHANNEL_LAYOUT_3POINT1 

func AV_CHANNEL_LAYOUT_3POINT1() AVChannelLayout

func AV_CHANNEL_LAYOUT_4POINT0 

func AV_CHANNEL_LAYOUT_4POINT0() AVChannelLayout

func AV_CHANNEL_LAYOUT_4POINT1 

func AV_CHANNEL_LAYOUT_4POINT1() AVChannelLayout

func AV_CHANNEL_LAYOUT_5POINT0 

func AV_CHANNEL_LAYOUT_5POINT0() AVChannelLayout

func AV_CHANNEL_LAYOUT_5POINT0_BACK 

func AV_CHANNEL_LAYOUT_5POINT0_BACK() AVChannelLayout

func AV_CHANNEL_LAYOUT_5POINT1 

func AV_CHANNEL_LAYOUT_5POINT1() AVChannelLayout

func AV_CHANNEL_LAYOUT_5POINT1_BACK 

func AV_CHANNEL_LAYOUT_5POINT1_BACK() AVChannelLayout

func AV_CHANNEL_LAYOUT_6POINT0 

func AV_CHANNEL_LAYOUT_6POINT0() AVChannelLayout

func AV_CHANNEL_LAYOUT_6POINT0_FRONT 

func AV_CHANNEL_LAYOUT_6POINT0_FRONT() AVChannelLayout

func AV_CHANNEL_LAYOUT_6POINT1 

func AV_CHANNEL_LAYOUT_6POINT1() AVChannelLayout

func AV_CHANNEL_LAYOUT_6POINT1_BACK 

func AV_CHANNEL_LAYOUT_6POINT1_BACK() AVChannelLayout

func AV_CHANNEL_LAYOUT_6POINT1_FRONT 

func AV_CHANNEL_LAYOUT_6POINT1_FRONT() AVChannelLayout

func AV_CHANNEL_LAYOUT_7POINT0 

func AV_CHANNEL_LAYOUT_7POINT0() AVChannelLayout

func AV_CHANNEL_LAYOUT_7POINT0_FRONT 

func AV_CHANNEL_LAYOUT_7POINT0_FRONT() AVChannelLayout

func AV_CHANNEL_LAYOUT_7POINT1 

func AV_CHANNEL_LAYOUT_7POINT1() AVChannelLayout

func AV_CHANNEL_LAYOUT_7POINT1_WIDE 

func AV_CHANNEL_LAYOUT_7POINT1_WIDE() AVChannelLayout

func AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK 

func AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK() AVChannelLayout

func AV_CHANNEL_LAYOUT_AMBISONIC_FIRST_ORDER 

func AV_CHANNEL_LAYOUT_AMBISONIC_FIRST_ORDER() AVChannelLayout

func AV_CHANNEL_LAYOUT_HEXADECAGONAL 

func AV_CHANNEL_LAYOUT_HEXADECAGONAL() AVChannelLayout

func AV_CHANNEL_LAYOUT_HEXAGONAL 

func AV_CHANNEL_LAYOUT_HEXAGONAL() AVChannelLayout

func AV_CHANNEL_LAYOUT_MONO 

func AV_CHANNEL_LAYOUT_MONO() AVChannelLayout

func AV_CHANNEL_LAYOUT_OCTAGONAL 

func AV_CHANNEL_LAYOUT_OCTAGONAL() AVChannelLayout

func AV_CHANNEL_LAYOUT_QUAD 

func AV_CHANNEL_LAYOUT_QUAD() AVChannelLayout

func AV_CHANNEL_LAYOUT_STEREO 

func AV_CHANNEL_LAYOUT_STEREO() AVChannelLayout

func AV_CHANNEL_LAYOUT_STEREO_DOWNMIX 

func AV_CHANNEL_LAYOUT_STEREO_DOWNMIX() AVChannelLayout

func AV_CHANNEL_LAYOUT_SURROUND 

func AV_CHANNEL_LAYOUT_SURROUND() AVChannelLayout

func (AVChannelLayout) MarshalJSON 

func (ch AVChannelLayout) MarshalJSON() ([]byte, error)

func (AVChannelLayout) NumChannels 

func (ctx AVChannelLayout) NumChannels() int

func (AVChannelLayout) Order 

func (ctx AVChannelLayout) Order() AVChannelOrder

type AVChannelOrder 

type AVChannelOrder C.enum_AVChannelOrder

func (AVChannelOrder) String 

func (o AVChannelOrder) String() string

type AVClass 

type AVClass C.struct_AVClass

type AVCodec 

type AVCodec C.struct_AVCodec

func AVCodec_find_decoder 

func AVCodec_find_decoder(id AVCodecID) *AVCodec

Find a registered decoder with a matching codec ID.

func AVCodec_find_decoder_by_name 

func AVCodec_find_decoder_by_name(name string) *AVCodec

Find a registered decoder with the specified name.

func AVCodec_find_encoder 

func AVCodec_find_encoder(id AVCodecID) *AVCodec

Find a registered encoder with a matching codec ID.

func AVCodec_find_encoder_by_name 

func AVCodec_find_encoder_by_name(name string) *AVCodec

Find a registered encoder with the specified name.

func AVCodec_iterate 

func AVCodec_iterate(opaque *uintptr) *AVCodec

Iterate over all registered codecs.

func AVFormat_find_best_stream 

func AVFormat_find_best_stream(ctx *AVFormatContext, t AVMediaType, wanted int, related int) (int, *AVCodec, error)

Find the best stream given the media type, wanted stream number, and related stream number.

func (*AVCodec) Capabilities 

func (c *AVCodec) Capabilities() AVCodecCap

func (*AVCodec) ChannelLayouts 

func (c *AVCodec) ChannelLayouts() []AVChannelLayout

func (*AVCodec) ID 

func (c *AVCodec) ID() AVCodecID

func (*AVCodec) LongName 

func (c *AVCodec) LongName() string

func (*AVCodec) MarshalJSON 

func (ctx *AVCodec) MarshalJSON() ([]byte, error)

func (*AVCodec) Name 

func (c *AVCodec) Name() string

func (*AVCodec) PixelFormats 

func (c *AVCodec) PixelFormats() []AVPixelFormat

func (*AVCodec) Profiles 

func (c *AVCodec) Profiles() []AVProfile

func (*AVCodec) SampleFormats 

func (c *AVCodec) SampleFormats() []AVSampleFormat

func (*AVCodec) String 

func (ctx *AVCodec) String() string

func (*AVCodec) SupportedFramerates 

func (c *AVCodec) SupportedFramerates() []AVRational

func (*AVCodec) SupportedSamplerates 

func (c *AVCodec) SupportedSamplerates() []int

func (*AVCodec) Type 

func (c *AVCodec) Type() AVMediaType

type AVCodecCap 

type AVCodecCap C.uint32_t
const (
	AV_CODEC_CAP_NONE                     AVCodecCap = 0
	AV_CODEC_CAP_DRAW_HORIZ_BAND          AVCodecCap = C.AV_CODEC_CAP_DRAW_HORIZ_BAND
	AV_CODEC_CAP_DR1                      AVCodecCap = C.AV_CODEC_CAP_DR1
	AV_CODEC_CAP_DELAY                    AVCodecCap = C.AV_CODEC_CAP_DELAY
	AV_CODEC_CAP_SMALL_LAST_FRAME         AVCodecCap = C.AV_CODEC_CAP_SMALL_LAST_FRAME
	AV_CODEC_CAP_EXPERIMENTAL             AVCodecCap = C.AV_CODEC_CAP_EXPERIMENTAL
	AV_CODEC_CAP_CHANNEL_CONF             AVCodecCap = C.AV_CODEC_CAP_CHANNEL_CONF
	AV_CODEC_CAP_FRAME_THREADS            AVCodecCap = C.AV_CODEC_CAP_FRAME_THREADS
	AV_CODEC_CAP_SLICE_THREADS            AVCodecCap = C.AV_CODEC_CAP_SLICE_THREADS
	AV_CODEC_CAP_PARAM_CHANGE             AVCodecCap = C.AV_CODEC_CAP_PARAM_CHANGE
	AV_CODEC_CAP_OTHER_THREADS            AVCodecCap = C.AV_CODEC_CAP_OTHER_THREADS
	AV_CODEC_CAP_VARIABLE_FRAME_SIZE      AVCodecCap = C.AV_CODEC_CAP_VARIABLE_FRAME_SIZE
	AV_CODEC_CAP_AVOID_PROBING            AVCodecCap = C.AV_CODEC_CAP_AVOID_PROBING
	AV_CODEC_CAP_HARDWARE                 AVCodecCap = C.AV_CODEC_CAP_HARDWARE
	AV_CODEC_CAP_HYBRID                   AVCodecCap = C.AV_CODEC_CAP_HYBRID
	AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE AVCodecCap = C.AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
	AV_CODEC_CAP_ENCODER_FLUSH            AVCodecCap = C.AV_CODEC_CAP_ENCODER_FLUSH
	AV_CODEC_CAP_ENCODER_RECON_FRAME      AVCodecCap = C.AV_CODEC_CAP_ENCODER_RECON_FRAME
	AV_CODEC_CAP_MAX                                 = AV_CODEC_CAP_ENCODER_RECON_FRAME
)

func (AVCodecCap) FlagString 

func (v AVCodecCap) FlagString() string

func (AVCodecCap) Is 

func (v AVCodecCap) Is(cap AVCodecCap) bool

func (AVCodecCap) MarshalJSON 

func (v AVCodecCap) MarshalJSON() ([]byte, error)

func (AVCodecCap) String 

func (v AVCodecCap) String() string

type AVCodecContext 

type AVCodecContext C.struct_AVCodecContext

func AVCodec_alloc_context 

func AVCodec_alloc_context(codec *AVCodec) *AVCodecContext

Allocate an AVCodecContext and set its fields to default values.

func (*AVCodecContext) BitRate 

func (ctx *AVCodecContext) BitRate() int64

func (*AVCodecContext) ChannelLayout 

func (ctx *AVCodecContext) ChannelLayout() AVChannelLayout

func (*AVCodecContext) Codec 

func (ctx *AVCodecContext) Codec() *AVCodec

func (*AVCodecContext) CodecID 

func (ctx *AVCodecContext) CodecID() AVCodecID

func (*AVCodecContext) CodecTag 

func (ctx *AVCodecContext) CodecTag() uint32

func (*AVCodecContext) CodecType 

func (ctx *AVCodecContext) CodecType() AVMediaType

func (*AVCodecContext) CodedHeight 

func (ctx *AVCodecContext) CodedHeight() int

func (*AVCodecContext) CodedWidth 

func (ctx *AVCodecContext) CodedWidth() int

func (*AVCodecContext) Delay 

func (ctx *AVCodecContext) Delay() int

func (*AVCodecContext) Flags 

func (ctx *AVCodecContext) Flags() AVCodecFlag

func (*AVCodecContext) Flags2 

func (ctx *AVCodecContext) Flags2() AVCodecFlag2

func (*AVCodecContext) FrameNum 

func (ctx *AVCodecContext) FrameNum() int64

func (*AVCodecContext) FrameSize 

func (ctx *AVCodecContext) FrameSize() int

func (*AVCodecContext) Framerate 

func (ctx *AVCodecContext) Framerate() AVRational

func (*AVCodecContext) GopSize 

func (ctx *AVCodecContext) GopSize() int

func (*AVCodecContext) Height 

func (ctx *AVCodecContext) Height() int

func (*AVCodecContext) MarshalJSON 

func (ctx *AVCodecContext) MarshalJSON() ([]byte, error)

func (*AVCodecContext) MaxBFrames 

func (ctx *AVCodecContext) MaxBFrames() int

func (*AVCodecContext) PixFmt 

func (ctx *AVCodecContext) PixFmt() AVPixelFormat

func (*AVCodecContext) SampleAspectRatio 

func (ctx *AVCodecContext) SampleAspectRatio() AVRational

func (*AVCodecContext) SampleFormat 

func (ctx *AVCodecContext) SampleFormat() AVSampleFormat

func (*AVCodecContext) SampleRate 

func (ctx *AVCodecContext) SampleRate() int

func (*AVCodecContext) SetBitRate 

func (ctx *AVCodecContext) SetBitRate(bit_rate int64)

func (*AVCodecContext) SetChannelLayout 

func (ctx *AVCodecContext) SetChannelLayout(src AVChannelLayout) error

func (*AVCodecContext) SetFlags 

func (ctx *AVCodecContext) SetFlags(flags AVCodecFlag)

func (*AVCodecContext) SetFlags2 

func (ctx *AVCodecContext) SetFlags2(flags2 AVCodecFlag2)

func (*AVCodecContext) SetFramerate 

func (ctx *AVCodecContext) SetFramerate(framerate AVRational)

func (*AVCodecContext) SetGopSize 

func (ctx *AVCodecContext) SetGopSize(gop_size int)

func (*AVCodecContext) SetHeight 

func (ctx *AVCodecContext) SetHeight(height int)

func (*AVCodecContext) SetMaxBFrames 

func (ctx *AVCodecContext) SetMaxBFrames(max_b_frames int)

func (*AVCodecContext) SetPixFmt 

func (ctx *AVCodecContext) SetPixFmt(pix_fmt AVPixelFormat)

func (*AVCodecContext) SetPrivDataKV 

func (ctx *AVCodecContext) SetPrivDataKV(name, value string) error

func (*AVCodecContext) SetSampleAspectRatio 

func (ctx *AVCodecContext) SetSampleAspectRatio(sample_aspect_ratio AVRational)

func (*AVCodecContext) SetSampleFormat 

func (ctx *AVCodecContext) SetSampleFormat(sample_fmt AVSampleFormat)

func (*AVCodecContext) SetSampleRate 

func (ctx *AVCodecContext) SetSampleRate(sample_rate int)

func (*AVCodecContext) SetTimeBase 

func (ctx *AVCodecContext) SetTimeBase(time_base AVRational)

func (*AVCodecContext) SetWidth 

func (ctx *AVCodecContext) SetWidth(width int)

func (*AVCodecContext) String 

func (ctx *AVCodecContext) String() string

func (*AVCodecContext) TimeBase 

func (ctx *AVCodecContext) TimeBase() AVRational

func (*AVCodecContext) Width 

func (ctx *AVCodecContext) Width() int

type AVCodecFlag 

type AVCodecFlag C.uint32_t

type AVCodecFlag2 

type AVCodecFlag2 C.uint32_t

type AVCodecID 

type AVCodecID C.enum_AVCodecID
const (
	AV_CODEC_ID_NONE       AVCodecID = C.AV_CODEC_ID_NONE
	AV_CODEC_ID_MP2        AVCodecID = C.AV_CODEC_ID_MP2
	AV_CODEC_ID_H264       AVCodecID = C.AV_CODEC_ID_H264
	AV_CODEC_ID_MPEG1VIDEO AVCodecID = C.AV_CODEC_ID_MPEG1VIDEO
	AV_CODEC_ID_MPEG2VIDEO AVCodecID = C.AV_CODEC_ID_MPEG2VIDEO
	AV_CODEC_ID_MJPEG      AVCodecID = C.AV_CODEC_ID_MJPEG
	AV_CODEC_ID_PNG        AVCodecID = C.AV_CODEC_ID_PNG
	AV_CODEC_ID_GIF        AVCodecID = C.AV_CODEC_ID_GIF
	AV_CODEC_ID_BMP        AVCodecID = C.AV_CODEC_ID_BMP
	AV_CODEC_ID_WEBP       AVCodecID = C.AV_CODEC_ID_WEBP
)
const (
	AV_CODEC_ID_FIRST_SUBTITLE     AVCodecID = C.AV_CODEC_ID_FIRST_SUBTITLE
	AV_CODEC_ID_DVD_SUBTITLE       AVCodecID = C.AV_CODEC_ID_DVD_SUBTITLE
	AV_CODEC_ID_DVB_SUBTITLE       AVCodecID = C.AV_CODEC_ID_DVB_SUBTITLE
	AV_CODEC_ID_TEXT               AVCodecID = C.AV_CODEC_ID_TEXT
	AV_CODEC_ID_XSUB               AVCodecID = C.AV_CODEC_ID_XSUB
	AV_CODEC_ID_SSA                AVCodecID = C.AV_CODEC_ID_SSA
	AV_CODEC_ID_MOV_TEXT           AVCodecID = C.AV_CODEC_ID_MOV_TEXT
	AV_CODEC_ID_HDMV_PGS_SUBTITLE  AVCodecID = C.AV_CODEC_ID_HDMV_PGS_SUBTITLE
	AV_CODEC_ID_DVB_TELETEXT       AVCodecID = C.AV_CODEC_ID_DVB_TELETEXT
	AV_CODEC_ID_SRT                AVCodecID = C.AV_CODEC_ID_SRT
	AV_CODEC_ID_MICRODVD           AVCodecID = C.AV_CODEC_ID_MICRODVD
	AV_CODEC_ID_EIA_608            AVCodecID = C.AV_CODEC_ID_EIA_608
	AV_CODEC_ID_JACOSUB            AVCodecID = C.AV_CODEC_ID_JACOSUB
	AV_CODEC_ID_SAMI               AVCodecID = C.AV_CODEC_ID_SAMI
	AV_CODEC_ID_REALTEXT           AVCodecID = C.AV_CODEC_ID_REALTEXT
	AV_CODEC_ID_STL                AVCodecID = C.AV_CODEC_ID_STL
	AV_CODEC_ID_SUBRIP             AVCodecID = C.AV_CODEC_ID_SUBRIP
	AV_CODEC_ID_SUBVIEWER1         AVCodecID = C.AV_CODEC_ID_SUBVIEWER1
	AV_CODEC_ID_SUBVIEWER          AVCodecID = C.AV_CODEC_ID_SUBVIEWER
	AV_CODEC_ID_SUBRIP_WEBVTT      AVCodecID = C.AV_CODEC_ID_SUBRIP // Alias
	AV_CODEC_ID_MPL2               AVCodecID = C.AV_CODEC_ID_MPL2
	AV_CODEC_ID_VPLAYER            AVCodecID = C.AV_CODEC_ID_VPLAYER
	AV_CODEC_ID_PJS                AVCodecID = C.AV_CODEC_ID_PJS
	AV_CODEC_ID_ASS                AVCodecID = C.AV_CODEC_ID_ASS
	AV_CODEC_ID_HDMV_TEXT_SUBTITLE AVCodecID = C.AV_CODEC_ID_HDMV_TEXT_SUBTITLE
	AV_CODEC_ID_TTML               AVCodecID = C.AV_CODEC_ID_TTML
	AV_CODEC_ID_ARIB_CAPTION       AVCodecID = C.AV_CODEC_ID_ARIB_CAPTION
	AV_CODEC_ID_WEBVTT             AVCodecID = C.AV_CODEC_ID_WEBVTT
)

Subtitle codec IDs

func (AVCodecID) MarshalJSON 

func (v AVCodecID) MarshalJSON() ([]byte, error)

func (AVCodecID) Name 

func (v AVCodecID) Name() string

func (AVCodecID) String 

func (v AVCodecID) String() string

func (AVCodecID) Type 

func (v AVCodecID) Type() AVMediaType

type AVCodecParameters 

type AVCodecParameters C.struct_AVCodecParameters

func AVCodec_parameters_alloc 

func AVCodec_parameters_alloc() *AVCodecParameters

Allocate a new AVCodecParameters and set its fields to default values.

func (*AVCodecParameters) BitRate 

func (ctx *AVCodecParameters) BitRate() int64

Audio and Video

func (*AVCodecParameters) ChannelLayout 

func (ctx *AVCodecParameters) ChannelLayout() AVChannelLayout

Audio

func (*AVCodecParameters) CodecID 

func (ctx *AVCodecParameters) CodecID() AVCodecID

func (*AVCodecParameters) CodecTag 

func (ctx *AVCodecParameters) CodecTag() uint32

func (*AVCodecParameters) CodecType 

func (ctx *AVCodecParameters) CodecType() AVMediaType

func (*AVCodecParameters) Format 

func (ctx *AVCodecParameters) Format() int

Audio and Video

func (*AVCodecParameters) FrameSize 

func (ctx *AVCodecParameters) FrameSize() int

Audio

func (*AVCodecParameters) Height 

func (ctx *AVCodecParameters) Height() int

Video

func (AVCodecParameters) MarshalJSON 

func (ctx AVCodecParameters) MarshalJSON() ([]byte, error)

func (*AVCodecParameters) PixelFormat 

func (ctx *AVCodecParameters) PixelFormat() AVPixelFormat

Video

func (*AVCodecParameters) SampleAspectRatio 

func (ctx *AVCodecParameters) SampleAspectRatio() AVRational

Video

func (*AVCodecParameters) SampleFormat 

func (ctx *AVCodecParameters) SampleFormat() AVSampleFormat

Audio

func (*AVCodecParameters) SampleRate 

func (ctx *AVCodecParameters) SampleRate() int

Audio

func (*AVCodecParameters) SetBitRate 

func (ctx *AVCodecParameters) SetBitRate(rate int64)

func (*AVCodecParameters) SetChannelLayout 

func (ctx *AVCodecParameters) SetChannelLayout(layout AVChannelLayout) error

func (*AVCodecParameters) SetCodecID 

func (ctx *AVCodecParameters) SetCodecID(id AVCodecID)

func (*AVCodecParameters) SetCodecTag 

func (ctx *AVCodecParameters) SetCodecTag(tag uint32)

func (*AVCodecParameters) SetCodecType 

func (ctx *AVCodecParameters) SetCodecType(t AVMediaType)

func (*AVCodecParameters) SetFrameSize 

func (ctx *AVCodecParameters) SetFrameSize(size int)

func (*AVCodecParameters) SetHeight 

func (ctx *AVCodecParameters) SetHeight(height int)

func (*AVCodecParameters) SetPixelFormat 

func (ctx *AVCodecParameters) SetPixelFormat(format AVPixelFormat)

func (*AVCodecParameters) SetSampleAspectRatio 

func (ctx *AVCodecParameters) SetSampleAspectRatio(aspect AVRational)

func (*AVCodecParameters) SetSampleFormat 

func (ctx *AVCodecParameters) SetSampleFormat(format AVSampleFormat)

func (*AVCodecParameters) SetSampleRate 

func (ctx *AVCodecParameters) SetSampleRate(rate int)

func (*AVCodecParameters) SetWidth 

func (ctx *AVCodecParameters) SetWidth(width int)

func (*AVCodecParameters) String 

func (ctx *AVCodecParameters) String() string

func (*AVCodecParameters) Width 

func (ctx *AVCodecParameters) Width() int

Video

type AVCodecParser 

type AVCodecParser C.struct_AVCodecParser

func AVCodec_parser_iterate 

func AVCodec_parser_iterate(opaque *uintptr) *AVCodecParser

Iterate over all registered codec parsers.

type AVCodecParserContext 

type AVCodecParserContext C.struct_AVCodecParserContext

func AVCodec_parser_init 

func AVCodec_parser_init(codec_id AVCodecID) *AVCodecParserContext

Initialize a parser context for the specified codec ID.

type AVColorRange 

type AVColorRange C.enum_AVColorRange
const (
	AVCOL_RANGE_UNSPECIFIED AVColorRange = C.AVCOL_RANGE_UNSPECIFIED ///< Unspecified
	AVCOL_RANGE_MPEG        AVColorRange = C.AVCOL_RANGE_MPEG        ///< Narrow or limited range (16-235)
	AVCOL_RANGE_JPEG        AVColorRange = C.AVCOL_RANGE_JPEG        ///< Full range (0-255)
)

func (AVColorRange) String 

func (v AVColorRange) String() string

type AVColorSpace 

type AVColorSpace C.enum_AVColorSpace
const (
	AVCOL_SPC_RGB                AVColorSpace = C.AVCOL_SPC_RGB   ///< order of coefficients is actually GBR
	AVCOL_SPC_BT709              AVColorSpace = C.AVCOL_SPC_BT709 ///< also ITU-R BT1361
	AVCOL_SPC_UNSPECIFIED        AVColorSpace = C.AVCOL_SPC_UNSPECIFIED
	AVCOL_SPC_RESERVED           AVColorSpace = C.AVCOL_SPC_RESERVED
	AVCOL_SPC_FCC                AVColorSpace = C.AVCOL_SPC_FCC
	AVCOL_SPC_BT470BG            AVColorSpace = C.AVCOL_SPC_BT470BG
	AVCOL_SPC_SMPTE170M          AVColorSpace = C.AVCOL_SPC_SMPTE170M
	AVCOL_SPC_SMPTE240M          AVColorSpace = C.AVCOL_SPC_SMPTE240M
	AVCOL_SPC_YCGCO              AVColorSpace = C.AVCOL_SPC_YCGCO
	AVCOL_SPC_BT2020_NCL         AVColorSpace = C.AVCOL_SPC_BT2020_NCL
	AVCOL_SPC_BT2020_CL          AVColorSpace = C.AVCOL_SPC_BT2020_CL
	AVCOL_SPC_SMPTE2085          AVColorSpace = C.AVCOL_SPC_SMPTE2085
	AVCOL_SPC_CHROMA_DERIVED_NCL AVColorSpace = C.AVCOL_SPC_CHROMA_DERIVED_NCL
	AVCOL_SPC_CHROMA_DERIVED_CL  AVColorSpace = C.AVCOL_SPC_CHROMA_DERIVED_CL
	AVCOL_SPC_ICTCP              AVColorSpace = C.AVCOL_SPC_ICTCP
)

func (AVColorSpace) String 

func (v AVColorSpace) String() string

type AVDevToAppMessageType 

type AVDevToAppMessageType C.enum_AVDevToAppMessageType

type AVDeviceInfo 

type AVDeviceInfo C.struct_AVDeviceInfo

func (*AVDeviceInfo) Description 

func (ctx *AVDeviceInfo) Description() string

func (*AVDeviceInfo) MarshalJSON 

func (ctx *AVDeviceInfo) MarshalJSON() ([]byte, error)

func (*AVDeviceInfo) MediaTypes 

func (ctx *AVDeviceInfo) MediaTypes() []AVMediaType

func (*AVDeviceInfo) Name 

func (ctx *AVDeviceInfo) Name() string

func (*AVDeviceInfo) String 

func (ctx *AVDeviceInfo) String() string

type AVDeviceInfoList 

type AVDeviceInfoList C.struct_AVDeviceInfoList

func AVDevice_list_devices 

func AVDevice_list_devices(ctx *AVFormatContext) (*AVDeviceInfoList, error)

func AVDevice_list_input_sources 

func AVDevice_list_input_sources(device *AVInputFormat, device_name string, device_options *AVDictionary) (*AVDeviceInfoList, error)

List devices. Returns available device names and their parameters, or nil if the enumeration of devices is not supported. Device format may be nil if device name is set. Call AVDevice_free_list_devices to free resources afterwards.

func AVDevice_list_output_sinks 

func AVDevice_list_output_sinks(device *AVOutputFormat, device_name string, device_options *AVDictionary) (*AVDeviceInfoList, error)

List devices. Returns available device names and their parameters, or nil if the enumeration of devices is not supported. Device format may be nil if device name is set. Call AVDevice_free_list_devices to free resources afterwards.

func (*AVDeviceInfoList) Default 

func (ctx *AVDeviceInfoList) Default() int

index of default device or -1 if no default

func (*AVDeviceInfoList) Devices 

func (ctx *AVDeviceInfoList) Devices() []*AVDeviceInfo

list of autodetected devices

func (*AVDeviceInfoList) MarshalJSON 

func (ctx *AVDeviceInfoList) MarshalJSON() ([]byte, error)

func (*AVDeviceInfoList) NumDevices 

func (ctx *AVDeviceInfoList) NumDevices() int

number of autodetected devices

func (*AVDeviceInfoList) String 

func (ctx *AVDeviceInfoList) String() string

type AVDictionary 

type AVDictionary struct {
	// contains filtered or unexported fields

} // Wrapper

func AVUtil_dict_alloc 

func AVUtil_dict_alloc() *AVDictionary

Allocate a dictionary

func AVUtil_dict_copy 

func AVUtil_dict_copy(dict *AVDictionary, flags AVDictionaryFlag) (*AVDictionary, error)

Copy entries from one dictionary into another.

func AVUtil_dict_delete 

func AVUtil_dict_delete(dict *AVDictionary, key string) (*AVDictionary, error)

Delete the given entry. If dictionary becomes empty, the return value is nil

func (*AVDictionary) MarshalJSON 

func (ctx *AVDictionary) MarshalJSON() ([]byte, error)

func (*AVDictionary) String 

func (ctx *AVDictionary) String() string

type AVDictionaryEntry 

type AVDictionaryEntry C.struct_AVDictionaryEntry

func AVUtil_dict_entries 

func AVUtil_dict_entries(dict *AVDictionary) []*AVDictionaryEntry

Get the entries for the dictionary.

func AVUtil_dict_get 

func AVUtil_dict_get(dict *AVDictionary, key string, prev *AVDictionaryEntry, flags AVDictionaryFlag) *AVDictionaryEntry

Get a dictionary entry with matching key.

func (*AVDictionaryEntry) Key 

func (e *AVDictionaryEntry) Key() string

Return dictionary entry key

func (*AVDictionaryEntry) MarshalJSON 

func (ctx *AVDictionaryEntry) MarshalJSON() ([]byte, error)

func (*AVDictionaryEntry) Value 

func (e *AVDictionaryEntry) Value() string

Return dictionary entry value

type AVDictionaryFlag 

type AVDictionaryFlag C.int
const (
	// No flags
	AV_DICT_NONE AVDictionaryFlag = 0

	// Only get an entry with exact-case key match.
	AV_DICT_MATCH_CASE AVDictionaryFlag = C.AV_DICT_MATCH_CASE

	// Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
	AV_DICT_IGNORE_SUFFIX AVDictionaryFlag = C.AV_DICT_IGNORE_SUFFIX

	// Take ownership of  key that has been allocated with av_malloc()
	AV_DICT_DONT_STRDUP_KEY AVDictionaryFlag = C.AV_DICT_DONT_STRDUP_KEY

	// Take ownership of  value that has been allocated with av_malloc()
	AV_DICT_DONT_STRDUP_VAL AVDictionaryFlag = C.AV_DICT_DONT_STRDUP_VAL

	// Don't overwrite existing entries.
	AV_DICT_DONT_OVERWRITE AVDictionaryFlag = C.AV_DICT_DONT_OVERWRITE

	// Append to existing key.
	AV_DICT_APPEND AVDictionaryFlag = C.AV_DICT_APPEND

	// Allow to store several equal keys in the dictionary.
	AV_DICT_MULTIKEY AVDictionaryFlag = C.AV_DICT_MULTIKEY
)

type AVDisposition 

type AVDisposition C.int
const (
	AV_DISPOSITION_DEFAULT          AVDisposition = C.AV_DISPOSITION_DEFAULT
	AV_DISPOSITION_DUB              AVDisposition = C.AV_DISPOSITION_DUB
	AV_DISPOSITION_ORIGINAL         AVDisposition = C.AV_DISPOSITION_ORIGINAL
	AV_DISPOSITION_COMMENT          AVDisposition = C.AV_DISPOSITION_COMMENT
	AV_DISPOSITION_LYRICS           AVDisposition = C.AV_DISPOSITION_LYRICS
	AV_DISPOSITION_KARAOKE          AVDisposition = C.AV_DISPOSITION_KARAOKE
	AV_DISPOSITION_FORCED           AVDisposition = C.AV_DISPOSITION_FORCED
	AV_DISPOSITION_HEARING_IMPAIRED AVDisposition = C.AV_DISPOSITION_HEARING_IMPAIRED
	AV_DISPOSITION_VISUAL_IMPAIRED  AVDisposition = C.AV_DISPOSITION_VISUAL_IMPAIRED
	AV_DISPOSITION_CLEAN_EFFECTS    AVDisposition = C.AV_DISPOSITION_CLEAN_EFFECTS
	AV_DISPOSITION_ATTACHED_PIC     AVDisposition = C.AV_DISPOSITION_ATTACHED_PIC
	AV_DISPOSITION_TIMED_THUMBNAILS AVDisposition = C.AV_DISPOSITION_TIMED_THUMBNAILS
	AV_DISPOSITION_NON_DIEGETIC     AVDisposition = C.AV_DISPOSITION_NON_DIEGETIC
	AV_DISPOSITION_CAPTIONS         AVDisposition = C.AV_DISPOSITION_CAPTIONS
	AV_DISPOSITION_DESCRIPTIONS     AVDisposition = C.AV_DISPOSITION_DESCRIPTIONS
	AV_DISPOSITION_METADATA         AVDisposition = C.AV_DISPOSITION_METADATA
	AV_DISPOSITION_DEPENDENT        AVDisposition = C.AV_DISPOSITION_DEPENDENT
	AV_DISPOSITION_STILL_IMAGE      AVDisposition = C.AV_DISPOSITION_STILL_IMAGE
	AV_DISPOSITION_MULTILAYER       AVDisposition = C.AV_DISPOSITION_MULTILAYER
	AV_DISPOSITION_MIN                            = AV_DISPOSITION_DEFAULT
	AV_DISPOSITION_MAX                            = AV_DISPOSITION_MULTILAYER
)

func (AVDisposition) FlagString 

func (v AVDisposition) FlagString() string

func (AVDisposition) Is 

func (f AVDisposition) Is(flag AVDisposition) bool

func (AVDisposition) MarshalJSON 

func (v AVDisposition) MarshalJSON() ([]byte, error)

func (AVDisposition) String 

func (v AVDisposition) String() string

type AVError 

type AVError C.int

func (AVError) Error 

func (err AVError) Error() string

func (AVError) IsErrno 

func (err AVError) IsErrno(v syscall.Errno) bool

type AVFilter 

type AVFilter C.AVFilter

func AVFilter_get_by_name 

func AVFilter_get_by_name(name string) *AVFilter

Get a filter definition matching the given name.

func AVFilter_iterate 

func AVFilter_iterate(opaque *uintptr) *AVFilter

Iterate over all registered filters.

func (*AVFilter) Description 

func (c *AVFilter) Description() string

func (*AVFilter) Flags 

func (c *AVFilter) Flags() AVFilterFlag

func (*AVFilter) MarshalJSON 

func (ctx *AVFilter) MarshalJSON() ([]byte, error)

func (*AVFilter) Name 

func (c *AVFilter) Name() string

func (*AVFilter) NumInputs 

func (c *AVFilter) NumInputs() uint

func (*AVFilter) NumOutputs 

func (c *AVFilter) NumOutputs() uint

func (*AVFilter) String 

func (ctx *AVFilter) String() string

type AVFilterContext 

type AVFilterContext C.AVFilterContext

func AVFilterGraph_create_filter 

func AVFilterGraph_create_filter(graph *AVFilterGraph, filter *AVFilter, name, args string) (*AVFilterContext, error)

Allocate and initialize a filter in a single step. The filter instance is created from the filter and inited with the parameter args.

func (*AVFilterContext) Filter 

func (c *AVFilterContext) Filter() *AVFilter

func (*AVFilterContext) MarshalJSON 

func (ctx *AVFilterContext) MarshalJSON() ([]byte, error)

func (*AVFilterContext) Name 

func (c *AVFilterContext) Name() string

func (*AVFilterContext) NumInputs 

func (c *AVFilterContext) NumInputs() uint

func (*AVFilterContext) NumOutputs 

func (c *AVFilterContext) NumOutputs() uint

func (*AVFilterContext) String 

func (ctx *AVFilterContext) String() string

type AVFilterFlag 

type AVFilterFlag C.int
const (
	AVFILTER_FLAG_NONE                      AVFilterFlag = 0
	AVFILTER_FLAG_DYNAMIC_INPUTS            AVFilterFlag = C.AVFILTER_FLAG_DYNAMIC_INPUTS
	AVFILTER_FLAG_DYNAMIC_OUTPUTS           AVFilterFlag = C.AVFILTER_FLAG_DYNAMIC_OUTPUTS
	AVFILTER_FLAG_SLICE_THREADS             AVFilterFlag = C.AVFILTER_FLAG_SLICE_THREADS
	AVFILTER_FLAG_METADATA_ONLY             AVFilterFlag = C.AVFILTER_FLAG_METADATA_ONLY
	AVFILTER_FLAG_HWDEVICE                  AVFilterFlag = C.AVFILTER_FLAG_HWDEVICE
	AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC  AVFilterFlag = C.AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
	AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL AVFilterFlag = C.AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
	AVFILTER_FLAG_SUPPORT_TIMELINE          AVFilterFlag = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
	AVFILTER_FLAG_MAX                                    = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
)

func (AVFilterFlag) FlagString 

func (v AVFilterFlag) FlagString() string

func (AVFilterFlag) Is 

func (v AVFilterFlag) Is(f AVFilterFlag) bool

func (AVFilterFlag) MarshalJSON 

func (v AVFilterFlag) MarshalJSON() ([]byte, error)

func (AVFilterFlag) String 

func (v AVFilterFlag) String() string

type AVFilterGraph 

type AVFilterGraph C.AVFilterGraph

func AVFilterGraph_alloc 

func AVFilterGraph_alloc() *AVFilterGraph

func (*AVFilterGraph) MarshalJSON 

func (ctx *AVFilterGraph) MarshalJSON() ([]byte, error)

func (*AVFilterGraph) NumFilters 

func (ctx *AVFilterGraph) NumFilters() uint

func (*AVFilterGraph) String 

func (ctx *AVFilterGraph) String() string

type AVFilterInOut 

type AVFilterInOut C.AVFilterInOut

func AVFilterInOut_alloc 

func AVFilterInOut_alloc(name string, filter *AVFilterContext, pad int) *AVFilterInOut

Allocate a single AVFilterInOut entry, with name, filter context and pad index. 

func AVFilterInOut_link(inout ...*AVFilterInOut) *AVFilterInOut

Link an array of AVFilterInOut entries together, and return the first entry. If the array is empty, or the first entry is nil, nil is returned. A nil entry after the first acts as a terminator for the chain and subsequent entries are ignored.

func AVFilterInOut_list 

func AVFilterInOut_list(head *AVFilterInOut) []*AVFilterInOut

Return an array of AVFilterInOut entries, given the first entry. Returns nil if the first entry is nil.

func (*AVFilterInOut) Filter 

func (c *AVFilterInOut) Filter() *AVFilterContext

func (*AVFilterInOut) MarshalJSON 

func (ctx *AVFilterInOut) MarshalJSON() ([]byte, error)

func (*AVFilterInOut) Name 

func (c *AVFilterInOut) Name() string

func (*AVFilterInOut) Next 

func (c *AVFilterInOut) Next() *AVFilterInOut

func (*AVFilterInOut) Pad 

func (c *AVFilterInOut) Pad() int

func (*AVFilterInOut) SetNext 

func (c *AVFilterInOut) SetNext(next *AVFilterInOut)

func (*AVFilterInOut) String 

func (ctx *AVFilterInOut) String() string

type AVFormat 

type AVFormat C.int
const (
	AVFMT_NONE         AVFormat = 0
	AVFMT_NOFILE       AVFormat = C.AVFMT_NOFILE        // Demuxer will use avio_open, no opened file should be provided by the caller.
	AVFMT_NEEDNUMBER   AVFormat = C.AVFMT_NEEDNUMBER    // Needs '%d' in filename.
	AVFMT_EXPERIMENTAL AVFormat = C.AVFMT_EXPERIMENTAL  // The muxer/demuxer is experimental and should be used with caution
	AVFMT_SHOWIDS      AVFormat = C.AVFMT_SHOW_IDS      // Show format stream IDs numbers.
	AVFMT_GLOBALHEADER AVFormat = C.AVFMT_GLOBALHEADER  // Format wants global header.
	AVFMT_NOTIMESTAMPS AVFormat = C.AVFMT_NOTIMESTAMPS  // Format does not need / have any timestamps.
	AVFMT_GENERICINDEX AVFormat = C.AVFMT_GENERIC_INDEX // Use generic index building code.
	AVFMT_TSDISCONT    AVFormat = C.AVFMT_TS_DISCONT    // Format allows timestamp discontinuities. Note, muxers always require valid (monotone) timestamps
	AVFMT_VARIABLEFPS  AVFormat = C.AVFMT_VARIABLE_FPS  // Format allows variable fps.
	AVFMT_NODIMENSIONS AVFormat = C.AVFMT_NODIMENSIONS  // Format does not need width/height
	AVFMT_NOSTREAMS    AVFormat = C.AVFMT_NOSTREAMS     // Format does not require any streams
	AVFMT_NOBINSEARCH  AVFormat = C.AVFMT_NOBINSEARCH   // Format does not allow to fall back on binary search via read_timestamp
	AVFMT_NOGENSEARCH  AVFormat = C.AVFMT_NOGENSEARCH   // Format does not allow to fall back on generic search
	AVFMT_NOBYTESEEK   AVFormat = C.AVFMT_NO_BYTE_SEEK  // Format does not allow seeking by bytes
	AVFMT_TS_NONSTRICT AVFormat = C.AVFMT_TS_NONSTRICT  // Format does not require strictly increasing timestamps, but they must still be monotonic
	AVFMT_TS_NEGATIVE  AVFormat = C.AVFMT_TS_NEGATIVE   // Format allows muxing negative timestamps
	AVFMT_SEEK_TO_PTS  AVFormat = C.AVFMT_SEEK_TO_PTS   // Seeking is based on PTS
	AVFMT_MIN          AVFormat = AVFMT_NOFILE
	AVFMT_MAX          AVFormat = AVFMT_SEEK_TO_PTS
)

func (AVFormat) FlagString 

func (f AVFormat) FlagString() string

func (AVFormat) Is 

func (f AVFormat) Is(flag AVFormat) bool

func (AVFormat) MarshalJSON 

func (v AVFormat) MarshalJSON() ([]byte, error)

func (AVFormat) String 

func (v AVFormat) String() string

type AVFormatContext 

type AVFormatContext C.struct_AVFormatContext

func AVFormat_alloc_context 

func AVFormat_alloc_context() *AVFormatContext

Allocate an AVFormatContext.

func AVFormat_create_file 

func AVFormat_create_file(filename string, format *AVOutputFormat) (*AVFormatContext, error)

Create an output file with automatic I/O management. Opens the file for writing and sets up the AVIOContext. The format parameter can be nil to auto-detect from the filename.

func AVFormat_open_device 

func AVFormat_open_device(format *AVInputFormat, options *AVDictionary) (*AVFormatContext, error)

Open an input stream from a device.

func AVFormat_open_reader 

func AVFormat_open_reader(reader *AVIOContextEx, format *AVInputFormat, options *AVDictionary) (*AVFormatContext, error)

Open an input stream and read the header.

func AVFormat_open_url 

func AVFormat_open_url(url string, format *AVInputFormat, options *AVDictionary) (*AVFormatContext, error)

Open an input stream from a URL and read the header.

func AVFormat_open_writer 

func AVFormat_open_writer(writer *AVIOContextEx, format *AVOutputFormat, filename string) (*AVFormatContext, error)

Open an output stream with custom I/O (using AVIOContextEx). Useful for writing to memory, network, or custom destinations. The format parameter can be nil to auto-detect from the filename.

func (*AVFormatContext) BitRate 

func (ctx *AVFormatContext) BitRate() int64

func (*AVFormatContext) ContextFlags 

func (ctx *AVFormatContext) ContextFlags() int

func (*AVFormatContext) Duration 

func (ctx *AVFormatContext) Duration() int64

func (*AVFormatContext) Filename 

func (ctx *AVFormatContext) Filename() string

func (*AVFormatContext) Flags 

func (ctx *AVFormatContext) Flags() AVFormatFlag

func (*AVFormatContext) Input 

func (ctx *AVFormatContext) Input() *AVInputFormat

func (*AVFormatContext) MaxAnalyzeDuration 

func (ctx *AVFormatContext) MaxAnalyzeDuration() int64

func (*AVFormatContext) Metadata 

func (ctx *AVFormatContext) Metadata() *AVDictionary

func (*AVFormatContext) NumChapters 

func (ctx *AVFormatContext) NumChapters() uint

func (*AVFormatContext) NumPrograms 

func (ctx *AVFormatContext) NumPrograms() uint

func (*AVFormatContext) NumStreams 

func (ctx *AVFormatContext) NumStreams() uint

func (*AVFormatContext) Output 

func (ctx *AVFormatContext) Output() *AVOutputFormat

func (*AVFormatContext) ProbeSize 

func (ctx *AVFormatContext) ProbeSize() int64

func (*AVFormatContext) SetFlags 

func (ctx *AVFormatContext) SetFlags(flag AVFormatFlag)

func (*AVFormatContext) SetMaxAnalyzeDuration 

func (ctx *AVFormatContext) SetMaxAnalyzeDuration(duration int64)

func (*AVFormatContext) SetMetadata 

func (ctx *AVFormatContext) SetMetadata(dict *AVDictionary)

func (*AVFormatContext) SetPb 

func (ctx *AVFormatContext) SetPb(pb *AVIOContextEx)

func (*AVFormatContext) SetProbeSize 

func (ctx *AVFormatContext) SetProbeSize(size int64)

func (*AVFormatContext) StartTime 

func (ctx *AVFormatContext) StartTime() int64

func (*AVFormatContext) Stream 

func (ctx *AVFormatContext) Stream(stream int) *AVStream

func (*AVFormatContext) Streams 

func (ctx *AVFormatContext) Streams() []*AVStream

type AVFormatFlag 

type AVFormatFlag C.int
const (
	AVFMT_FLAG_NONE            AVFormatFlag = 0
	AVFMT_FLAG_GENPTS          AVFormatFlag = C.AVFMT_FLAG_GENPTS          ///< Generate missing pts even if it requires parsing future frames.
	AVFMT_FLAG_IGNIDX          AVFormatFlag = C.AVFMT_FLAG_IGNIDX          ///< Ignore index.
	AVFMT_FLAG_NONBLOCK        AVFormatFlag = C.AVFMT_FLAG_NONBLOCK        ///< Do not block when reading packets from input.
	AVFMT_FLAG_IGNDTS          AVFormatFlag = C.AVFMT_FLAG_IGNDTS          ///< Ignore DTS on frames that contain both DTS & PTS
	AVFMT_FLAG_NOFILLIN        AVFormatFlag = C.AVFMT_FLAG_NOFILLIN        ///< Do not infer any values from other values, just return what is stored in the container
	AVFMT_FLAG_NOPARSE         AVFormatFlag = C.AVFMT_FLAG_NOPARSE         ///< Do not use AVParsers, you also must set AVFMT_FLAG_NOFILLIN as the fillin code works on frames and no parsing -> no frames. Also seeking to frames can not work if parsing to find frame boundaries has been disabled
	AVFMT_FLAG_NOBUFFER        AVFormatFlag = C.AVFMT_FLAG_NOBUFFER        ///< Do not buffer frames when possible
	AVFMT_FLAG_CUSTOM_IO       AVFormatFlag = C.AVFMT_FLAG_CUSTOM_IO       ///< The caller has supplied a custom AVIOContext, don't avio_close() it.
	AVFMT_FLAG_DISCARD_CORRUPT AVFormatFlag = C.AVFMT_FLAG_DISCARD_CORRUPT ///< Discard frames marked corrupted
	AVFMT_FLAG_FLUSH_PACKETS   AVFormatFlag = C.AVFMT_FLAG_FLUSH_PACKETS   ///< Flush the AVIOContext every packet.
	AVFMT_FLAG_BITEXACT        AVFormatFlag = C.AVFMT_FLAG_BITEXACT        // When muxing, try to avoid writing any random/volatile data to the output.
	AVFMT_FLAG_SORT_DTS        AVFormatFlag = C.AVFMT_FLAG_SORT_DTS        ///< try to interleave outputted packets by dts (using this flag can slow demuxing down)
	AVFMT_FLAG_FAST_SEEK       AVFormatFlag = C.AVFMT_FLAG_FAST_SEEK       ///< Enable fast, but inaccurate seeks for some formats
	AVFMT_FLAG_AUTO_BSF        AVFormatFlag = C.AVFMT_FLAG_AUTO_BSF        ///< Add bitstream filters as requested by the muxer
	AVFMT_FLAG_MIN                          = AVFMT_FLAG_GENPTS
	AVFMT_FLAG_MAX                          = AVFMT_FLAG_AUTO_BSF
)

func (AVFormatFlag) FlagString 

func (f AVFormatFlag) FlagString() string

func (AVFormatFlag) Is 

func (f AVFormatFlag) Is(flag AVFormatFlag) bool

func (AVFormatFlag) MarshalJSON 

func (f AVFormatFlag) MarshalJSON() ([]byte, error)

func (AVFormatFlag) String 

func (f AVFormatFlag) String() string

type AVFrame 

type AVFrame C.struct_AVFrame

func AVUtil_frame_alloc 

func AVUtil_frame_alloc() *AVFrame

Allocate an AVFrame and set its fields to default values.

func (*AVFrame) Bytes 

func (ctx *AVFrame) Bytes(plane int) []byte

Returns a plane as a byte array (same as uint8).

func (*AVFrame) ChannelLayout 

func (ctx *AVFrame) ChannelLayout() AVChannelLayout

func (*AVFrame) ColorRange 

func (ctx *AVFrame) ColorRange() AVColorRange

func (*AVFrame) Colorspace 

func (ctx *AVFrame) Colorspace() AVColorSpace

func (*AVFrame) Data 

func (ctx *AVFrame) Data() ([][]byte, []int)

Returns the data as a set of planes and strides

func (*AVFrame) Duration 

func (ctx *AVFrame) Duration() int64

func (*AVFrame) Float32 

func (ctx *AVFrame) Float32(plane int) []float32

Returns a plane as a float32 array.

func (*AVFrame) Float64 

func (ctx *AVFrame) Float64(plane int) []float64

Returns a plane as a float64 array.

func (*AVFrame) Height 

func (ctx *AVFrame) Height() int

func (*AVFrame) Int16 

func (ctx *AVFrame) Int16(plane int) []int16

Returns a plane as a int16 array.

func (*AVFrame) Int32 

func (ctx *AVFrame) Int32(plane int) []int32

Returns a plane as a int32 array.

func (*AVFrame) Int8 

func (ctx *AVFrame) Int8(plane int) []int8

Returns a plane as a int8 array.

func (*AVFrame) Linesize 

func (ctx *AVFrame) Linesize(plane int) int

Return stride of a plane for images, or plane size for audio.

func (*AVFrame) MarshalJSON 

func (ctx *AVFrame) MarshalJSON() ([]byte, error)

func (*AVFrame) NumChannels 

func (ctx *AVFrame) NumChannels() int

func (*AVFrame) NumSamples 

func (ctx *AVFrame) NumSamples() int

func (*AVFrame) PixFmt 

func (ctx *AVFrame) PixFmt() AVPixelFormat

func (*AVFrame) Planesize 

func (ctx *AVFrame) Planesize(plane int) int

Return size of a plane in bytes

func (*AVFrame) Pts 

func (ctx *AVFrame) Pts() int64

func (*AVFrame) SampleAspectRatio 

func (ctx *AVFrame) SampleAspectRatio() AVRational

func (*AVFrame) SampleFormat 

func (ctx *AVFrame) SampleFormat() AVSampleFormat

func (*AVFrame) SampleRate 

func (ctx *AVFrame) SampleRate() int

func (*AVFrame) SetChannelLayout 

func (ctx *AVFrame) SetChannelLayout(src AVChannelLayout) error

func (*AVFrame) SetColorRange 

func (ctx *AVFrame) SetColorRange(color_range AVColorRange)

func (*AVFrame) SetColorspace 

func (ctx *AVFrame) SetColorspace(colorspace AVColorSpace)

func (*AVFrame) SetDuration 

func (ctx *AVFrame) SetDuration(duration int64)

func (*AVFrame) SetHeight 

func (ctx *AVFrame) SetHeight(height int)

func (*AVFrame) SetNumSamples 

func (ctx *AVFrame) SetNumSamples(nb_samples int)

func (*AVFrame) SetPixFmt 

func (ctx *AVFrame) SetPixFmt(format AVPixelFormat)

func (*AVFrame) SetPts 

func (ctx *AVFrame) SetPts(pts int64)

func (*AVFrame) SetSampleAspectRatio 

func (ctx *AVFrame) SetSampleAspectRatio(aspect_ratio AVRational)

func (*AVFrame) SetSampleFormat 

func (ctx *AVFrame) SetSampleFormat(format AVSampleFormat)

func (*AVFrame) SetSampleRate 

func (ctx *AVFrame) SetSampleRate(sample_rate int)

func (*AVFrame) SetTimeBase 

func (ctx *AVFrame) SetTimeBase(timeBase AVRational)

func (*AVFrame) SetWidth 

func (ctx *AVFrame) SetWidth(width int)

func (*AVFrame) String 

func (ctx *AVFrame) String() string

func (*AVFrame) TimeBase 

func (ctx *AVFrame) TimeBase() AVRational

func (*AVFrame) Uint16 

func (ctx *AVFrame) Uint16(plane int) []uint16

Returns a plane as a uint16 array.

func (*AVFrame) Uint32 

func (ctx *AVFrame) Uint32(plane int) []uint32

Returns a plane as a uint32 array.

func (*AVFrame) Uint8 

func (ctx *AVFrame) Uint8(plane int) []uint8

Returns a plane as a uint8 array.

func (*AVFrame) Width 

func (ctx *AVFrame) Width() int

type AVIOContext 

type AVIOContext C.struct_AVIOContext

type AVIOContextCallback 

type AVIOContextCallback interface {
	Reader(buf []byte) int
	Writer(buf []byte) int
	Seeker(offset int64, whence int) int64
}

Callbacks for AVIOContextEx

type AVIOContextEx 

type AVIOContextEx struct {
	*AVIOContext
}

Wrapper around AVIOContext with callbacks

func AVFormat_avio_alloc_context 

func AVFormat_avio_alloc_context(sz int, writeable bool, callback AVIOContextCallback) *AVIOContextEx

avio_alloc_context

func AVFormat_avio_open 

func AVFormat_avio_open(url string, flags AVIOFlag) (*AVIOContextEx, error)

Create and initialize a AVIOContext for accessing the resource indicated by url.

type AVIOFlag 

type AVIOFlag C.int
const (
	AVIO_FLAG_NONE       AVIOFlag = 0
	AVIO_FLAG_READ       AVIOFlag = C.AVIO_FLAG_READ                     ///< read-only
	AVIO_FLAG_WRITE      AVIOFlag = C.AVIO_FLAG_WRITE                    ///< write-only
	AVIO_FLAG_READ_WRITE AVIOFlag = C.AVIO_FLAG_READ | C.AVIO_FLAG_WRITE ///< read-write pseudo flag
	AVIO_FLAG_NONBLOCK   AVIOFlag = C.AVIO_FLAG_NONBLOCK                 ///< Use non-blocking mode
	AVIO_FLAG_DIRECT     AVIOFlag = C.AVIO_FLAG_DIRECT                   ///< Use direct mode
	AVIO_FLAG_MIN        AVIOFlag = AVIO_FLAG_READ
	AVIO_FLAG_MAX        AVIOFlag = AVIO_FLAG_DIRECT
)

func (AVIOFlag) FlagString 

func (f AVIOFlag) FlagString() string

func (AVIOFlag) Is 

func (f AVIOFlag) Is(flag AVIOFlag) bool

func (AVIOFlag) MarshalJSON 

func (f AVIOFlag) MarshalJSON() ([]byte, error)

func (AVIOFlag) String 

func (f AVIOFlag) String() string

type AVInputFormat 

type AVInputFormat C.struct_AVInputFormat

func AVDevice_input_audio_device_first 

func AVDevice_input_audio_device_first() *AVInputFormat

Return the first registered audio input format, or NULL if there are none.

func AVDevice_input_audio_device_next 

func AVDevice_input_audio_device_next(d *AVInputFormat) *AVInputFormat

Return the next registered audio input device.

func AVDevice_input_video_device_first 

func AVDevice_input_video_device_first() *AVInputFormat

Return the first registered video input format, or NULL if there are none.

func AVDevice_input_video_device_next 

func AVDevice_input_video_device_next(d *AVInputFormat) *AVInputFormat

Return the next registered video input device.

func AVFormat_demuxer_iterate 

func AVFormat_demuxer_iterate(opaque *uintptr) *AVInputFormat

Iterate over all AVInputFormats

func AVFormat_find_input_format 

func AVFormat_find_input_format(name string) *AVInputFormat

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

func (*AVInputFormat) Extensions 

func (ctx *AVInputFormat) Extensions() string

func (*AVInputFormat) Flags 

func (ctx *AVInputFormat) Flags() AVFormat

func (*AVInputFormat) LongName 

func (ctx *AVInputFormat) LongName() string

func (*AVInputFormat) MarshalJSON 

func (ctx *AVInputFormat) MarshalJSON() ([]byte, error)

func (*AVInputFormat) MimeTypes 

func (ctx *AVInputFormat) MimeTypes() string

func (*AVInputFormat) Name 

func (ctx *AVInputFormat) Name() string

func (*AVInputFormat) String 

func (ctx *AVInputFormat) String() string

type AVLog 

type AVLog C.int
const (
	AV_LOG_QUIET   AVLog = -8 // C.AV_LOG_QUIET
	AV_LOG_PANIC   AVLog = 0  // C.AV_LOG_PANIC
	AV_LOG_FATAL   AVLog = 8  // C.AV_LOG_FATAL
	AV_LOG_ERROR   AVLog = 16 // C.AV_LOG_ERROR
	AV_LOG_WARNING AVLog = 24 // C.AV_LOG_WARNING
	AV_LOG_INFO    AVLog = 32 // C.AV_LOG_INFO
	AV_LOG_VERBOSE AVLog = 40 // C.AV_LOG_VERBOSE
	AV_LOG_DEBUG   AVLog = 48 // C.AV_LOG_DEBUG
	AV_LOG_TRACE   AVLog = 56 // C.AV_LOG_TRACE
)

func AVUtil_log_get_level 

func AVUtil_log_get_level() AVLog

func (AVLog) MarshalJSON 

func (v AVLog) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaler interface

func (AVLog) String 

func (v AVLog) String() string

type AVLogFunc 

type AVLogFunc func(level AVLog, message string, userInfo any)

type AVMediaType 

type AVMediaType C.enum_AVMediaType
const (
	AVMEDIA_TYPE_UNKNOWN    AVMediaType = C.AVMEDIA_TYPE_UNKNOWN ///< Usually treated as AVMEDIA_TYPE_DATA
	AVMEDIA_TYPE_VIDEO      AVMediaType = C.AVMEDIA_TYPE_VIDEO
	AVMEDIA_TYPE_AUDIO      AVMediaType = C.AVMEDIA_TYPE_AUDIO
	AVMEDIA_TYPE_DATA       AVMediaType = C.AVMEDIA_TYPE_DATA ///< Opaque data information usually continuous
	AVMEDIA_TYPE_SUBTITLE   AVMediaType = C.AVMEDIA_TYPE_SUBTITLE
	AVMEDIA_TYPE_ATTACHMENT AVMediaType = C.AVMEDIA_TYPE_ATTACHMENT ///< Opaque data information usually sparse
)

func (AVMediaType) Is 

func (m AVMediaType) Is(v AVMediaType) bool

func (AVMediaType) MarshalJSON 

func (v AVMediaType) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaler interface

func (AVMediaType) String 

func (v AVMediaType) String() string

type AVOutputFormat 

type AVOutputFormat C.struct_AVOutputFormat

func AVDevice_output_audio_device_first 

func AVDevice_output_audio_device_first() *AVOutputFormat

Return the first registered audio output format, or NULL if there are none.

func AVDevice_output_audio_device_next 

func AVDevice_output_audio_device_next(d *AVOutputFormat) *AVOutputFormat

Return the next registered audio output device.

func AVDevice_output_video_device_first 

func AVDevice_output_video_device_first() *AVOutputFormat

Return the first registered video output format, or NULL if there are none.

func AVDevice_output_video_device_next 

func AVDevice_output_video_device_next(d *AVOutputFormat) *AVOutputFormat

Return the next registered video output device.

func AVFormat_guess_format 

func AVFormat_guess_format(format, filename, mimetype string) *AVOutputFormat

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.

func AVFormat_muxer_iterate 

func AVFormat_muxer_iterate(opaque *uintptr) *AVOutputFormat

Iterate over all AVOutputFormats

func (*AVOutputFormat) AudioCodec 

func (ctx *AVOutputFormat) AudioCodec() AVCodecID

func (*AVOutputFormat) Extensions 

func (ctx *AVOutputFormat) Extensions() string

func (*AVOutputFormat) Flags 

func (ctx *AVOutputFormat) Flags() AVFormat

func (*AVOutputFormat) LongName 

func (ctx *AVOutputFormat) LongName() string

func (*AVOutputFormat) MarshalJSON 

func (ctx *AVOutputFormat) MarshalJSON() ([]byte, error)

func (*AVOutputFormat) MimeTypes 

func (ctx *AVOutputFormat) MimeTypes() string

func (*AVOutputFormat) Name 

func (ctx *AVOutputFormat) Name() string

func (*AVOutputFormat) String 

func (ctx *AVOutputFormat) String() string

func (*AVOutputFormat) SubtitleCodec 

func (ctx *AVOutputFormat) SubtitleCodec() AVCodecID

func (*AVOutputFormat) VideoCodec 

func (ctx *AVOutputFormat) VideoCodec() AVCodecID

type AVPacket 

type AVPacket C.struct_AVPacket

func AVCodec_packet_alloc 

func AVCodec_packet_alloc() *AVPacket

Allocate an AVPacket and set its fields to default values.

func AVCodec_packet_clone 

func AVCodec_packet_clone(src *AVPacket) *AVPacket

Create a new packet that references the same data as src.

func (*AVPacket) Bytes 

func (ctx *AVPacket) Bytes() []byte

func (*AVPacket) Dts 

func (ctx *AVPacket) Dts() int64

func (*AVPacket) Duration 

func (ctx *AVPacket) Duration() int64

func (*AVPacket) Flags 

func (ctx *AVPacket) Flags() int

func (*AVPacket) MarshalJSON 

func (ctx *AVPacket) MarshalJSON() ([]byte, error)

func (*AVPacket) Pos 

func (ctx *AVPacket) Pos() int64

func (*AVPacket) Pts 

func (ctx *AVPacket) Pts() int64

func (*AVPacket) SetDts 

func (ctx *AVPacket) SetDts(dts int64)

func (*AVPacket) SetDuration 

func (ctx *AVPacket) SetDuration(duration int64)

func (*AVPacket) SetFlags 

func (ctx *AVPacket) SetFlags(flags int)

func (*AVPacket) SetPos 

func (ctx *AVPacket) SetPos(pos int64)

func (*AVPacket) SetPts 

func (ctx *AVPacket) SetPts(pts int64)

func (*AVPacket) SetStreamIndex 

func (ctx *AVPacket) SetStreamIndex(index int)

func (*AVPacket) SetTimeBase 

func (ctx *AVPacket) SetTimeBase(tb AVRational)

func (*AVPacket) Size 

func (ctx *AVPacket) Size() int

func (*AVPacket) StreamIndex 

func (ctx *AVPacket) StreamIndex() int

func (*AVPacket) String 

func (ctx *AVPacket) String() string

func (*AVPacket) TimeBase 

func (ctx *AVPacket) TimeBase() AVRational

type AVPictureType 

type AVPictureType C.enum_AVPictureType
const (
	AV_PICTURE_TYPE_NONE AVPictureType = C.AV_PICTURE_TYPE_NONE ///< Undefined
	AV_PICTURE_TYPE_I    AVPictureType = C.AV_PICTURE_TYPE_I    ///< Intra
	AV_PICTURE_TYPE_P    AVPictureType = C.AV_PICTURE_TYPE_P    ///< Predicted
	AV_PICTURE_TYPE_B    AVPictureType = C.AV_PICTURE_TYPE_B    ///< Bi-dir predicted
	AV_PICTURE_TYPE_S    AVPictureType = C.AV_PICTURE_TYPE_S    ///< S(GMC)-VOP MPEG-4
	AV_PICTURE_TYPE_SI   AVPictureType = C.AV_PICTURE_TYPE_SI   ///< Switching Intra
	AV_PICTURE_TYPE_SP   AVPictureType = C.AV_PICTURE_TYPE_SP   ///< Switching Predicted
	AV_PICTURE_TYPE_BI   AVPictureType = C.AV_PICTURE_TYPE_BI   ///< BI type
)

func (AVPictureType) MarshalJSON 

func (v AVPictureType) MarshalJSON() ([]byte, error)

func (AVPictureType) String 

func (v AVPictureType) String() string

type AVPixFmtDescriptor 

type AVPixFmtDescriptor C.AVPixFmtDescriptor

func AVUtil_get_pix_fmt_desc 

func AVUtil_get_pix_fmt_desc(pixfmt AVPixelFormat) *AVPixFmtDescriptor

func (*AVPixFmtDescriptor) Log2ChromaH added in v1.8.1 

func (desc *AVPixFmtDescriptor) Log2ChromaH() int

Return log2_chroma_h

func (*AVPixFmtDescriptor) Log2ChromaW added in v1.8.1 

func (desc *AVPixFmtDescriptor) Log2ChromaW() int

Return log2_chroma_w

type AVPixelFormat 

type AVPixelFormat C.enum_AVPixelFormat
const (
	AV_PIX_FMT_NONE           AVPixelFormat = C.AV_PIX_FMT_NONE
	AV_PIX_FMT_YUV420P        AVPixelFormat = C.AV_PIX_FMT_YUV420P   ///< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
	AV_PIX_FMT_YUYV422        AVPixelFormat = C.AV_PIX_FMT_YUYV422   ///< packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
	AV_PIX_FMT_RGB24          AVPixelFormat = C.AV_PIX_FMT_RGB24     ///< packed RGB 8:8:8, 24bpp, RGBRGB...
	AV_PIX_FMT_BGR24          AVPixelFormat = C.AV_PIX_FMT_BGR24     ///< packed RGB 8:8:8, 24bpp, BGRBGR...
	AV_PIX_FMT_YUV422P        AVPixelFormat = C.AV_PIX_FMT_YUV422P   ///< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
	AV_PIX_FMT_YUV444P        AVPixelFormat = C.AV_PIX_FMT_YUV444P   ///< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
	AV_PIX_FMT_YUV410P        AVPixelFormat = C.AV_PIX_FMT_YUV410P   ///< planar YUV 4:1:0,  9bpp, (1 Cr & Cb sample per 4x4 Y samples)
	AV_PIX_FMT_YUV411P        AVPixelFormat = C.AV_PIX_FMT_YUV411P   ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
	AV_PIX_FMT_GRAY8          AVPixelFormat = C.AV_PIX_FMT_GRAY8     ///<        Y        ,  8bpp
	AV_PIX_FMT_MONOWHITE      AVPixelFormat = C.AV_PIX_FMT_MONOWHITE ///<        Y        ,  1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb
	AV_PIX_FMT_MONOBLACK      AVPixelFormat = C.AV_PIX_FMT_MONOBLACK ///<        Y        ,  1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb
	AV_PIX_FMT_PAL8           AVPixelFormat = C.AV_PIX_FMT_PAL8      ///< 8 bits with AV_PIX_FMT_RGB32 palette
	AV_PIX_FMT_YUVJ420P       AVPixelFormat = C.AV_PIX_FMT_YUVJ420P  ///< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting color_range
	AV_PIX_FMT_YUVJ422P       AVPixelFormat = C.AV_PIX_FMT_YUVJ422P  ///< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting color_range
	AV_PIX_FMT_YUVJ444P       AVPixelFormat = C.AV_PIX_FMT_YUVJ444P  ///< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting color_range
	AV_PIX_FMT_UYVY422        AVPixelFormat = C.AV_PIX_FMT_UYVY422   ///< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
	AV_PIX_FMT_UYYVYY411      AVPixelFormat = C.AV_PIX_FMT_UYYVYY411 ///< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
	AV_PIX_FMT_BGR8           AVPixelFormat = C.AV_PIX_FMT_BGR8      ///< packed RGB 3:3:2,  8bpp, (msb)2B 3G 3R(lsb)
	AV_PIX_FMT_BGR4           AVPixelFormat = C.AV_PIX_FMT_BGR4      ///< packed RGB 1:2:1 bitstream,  4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits
	AV_PIX_FMT_BGR4_BYTE      AVPixelFormat = C.AV_PIX_FMT_BGR4_BYTE ///< packed RGB 1:2:1,  8bpp, (msb)1B 2G 1R(lsb)
	AV_PIX_FMT_RGB8           AVPixelFormat = C.AV_PIX_FMT_RGB8      ///< packed RGB 3:3:2,  8bpp, (msb)2R 3G 3B(lsb)
	AV_PIX_FMT_RGB4           AVPixelFormat = C.AV_PIX_FMT_RGB4      ///< packed RGB 1:2:1 bitstream,  4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits
	AV_PIX_FMT_RGB4_BYTE      AVPixelFormat = C.AV_PIX_FMT_RGB4_BYTE ///< packed RGB 1:2:1,  8bpp, (msb)1R 2G 1B(lsb)
	AV_PIX_FMT_NV12           AVPixelFormat = C.AV_PIX_FMT_NV12      ///< planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
	AV_PIX_FMT_NV21           AVPixelFormat = C.AV_PIX_FMT_NV21      ///< as above, but U and V bytes are swapped
	AV_PIX_FMT_ARGB           AVPixelFormat = C.AV_PIX_FMT_ARGB      ///< packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
	AV_PIX_FMT_RGBA           AVPixelFormat = C.AV_PIX_FMT_RGBA      ///< packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
	AV_PIX_FMT_ABGR           AVPixelFormat = C.AV_PIX_FMT_ABGR      ///< packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
	AV_PIX_FMT_BGRA           AVPixelFormat = C.AV_PIX_FMT_BGRA      ///< packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
	AV_PIX_FMT_GRAY16BE       AVPixelFormat = C.AV_PIX_FMT_GRAY16BE  ///<        Y        , 16bpp, big-endian
	AV_PIX_FMT_GRAY16LE       AVPixelFormat = C.AV_PIX_FMT_GRAY16LE  ///<        Y        , 16bpp, little-endian
	AV_PIX_FMT_YUV440P        AVPixelFormat = C.AV_PIX_FMT_YUV440P   ///< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
	AV_PIX_FMT_YUVJ440P       AVPixelFormat = C.AV_PIX_FMT_YUVJ440P  ///< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
	AV_PIX_FMT_YUVA420P       AVPixelFormat = C.AV_PIX_FMT_YUVA420P  ///< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
	AV_PIX_FMT_RGB48BE        AVPixelFormat = C.AV_PIX_FMT_RGB48BE   ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian
	AV_PIX_FMT_RGB48LE        AVPixelFormat = C.AV_PIX_FMT_RGB48LE   ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian
	AV_PIX_FMT_RGB565BE       AVPixelFormat = C.AV_PIX_FMT_RGB565BE  ///< packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), big-endian
	AV_PIX_FMT_RGB565LE       AVPixelFormat = C.AV_PIX_FMT_RGB565LE  ///< packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), little-endian
	AV_PIX_FMT_RGB555BE       AVPixelFormat = C.AV_PIX_FMT_RGB555BE  ///< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian   , X=unused/undefined
	AV_PIX_FMT_RGB555LE       AVPixelFormat = C.AV_PIX_FMT_RGB555LE  ///< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
	AV_PIX_FMT_BGR565BE       AVPixelFormat = C.AV_PIX_FMT_BGR565BE  ///< packed BGR 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), big-endian
	AV_PIX_FMT_BGR565LE       AVPixelFormat = C.AV_PIX_FMT_BGR565LE  ///< packed BGR 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), little-endian
	AV_PIX_FMT_BGR555BE       AVPixelFormat = C.AV_PIX_FMT_BGR555BE  ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian   , X=unused/undefined
	AV_PIX_FMT_BGR555LE       AVPixelFormat = C.AV_PIX_FMT_BGR555LE  ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
	AV_PIX_FMT_VAAPI          AVPixelFormat = C.AV_PIX_FMT_VAAPI
	AV_PIX_FMT_YUV420P16LE    AVPixelFormat = C.AV_PIX_FMT_YUV420P16LE  ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
	AV_PIX_FMT_YUV420P16BE    AVPixelFormat = C.AV_PIX_FMT_YUV420P16BE  ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
	AV_PIX_FMT_YUV422P16LE    AVPixelFormat = C.AV_PIX_FMT_YUV422P16LE  ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AV_PIX_FMT_YUV422P16BE    AVPixelFormat = C.AV_PIX_FMT_YUV422P16BE  ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AV_PIX_FMT_YUV444P16LE    AVPixelFormat = C.AV_PIX_FMT_YUV444P16LE  ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	AV_PIX_FMT_YUV444P16BE    AVPixelFormat = C.AV_PIX_FMT_YUV444P16BE  ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
	AV_PIX_FMT_DXVA2_VLD      AVPixelFormat = C.AV_PIX_FMT_DXVA2_VLD    ///< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer
	AV_PIX_FMT_RGB444LE       AVPixelFormat = C.AV_PIX_FMT_RGB444LE     ///< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
	AV_PIX_FMT_RGB444BE       AVPixelFormat = C.AV_PIX_FMT_RGB444BE     ///< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian,    X=unused/undefined
	AV_PIX_FMT_BGR444LE       AVPixelFormat = C.AV_PIX_FMT_BGR444LE     ///< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
	AV_PIX_FMT_BGR444BE       AVPixelFormat = C.AV_PIX_FMT_BGR444BE     ///< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian,    X=unused/undefined
	AV_PIX_FMT_YA8            AVPixelFormat = C.AV_PIX_FMT_YA8          ///< 8 bits gray, 8 bits alpha
	AV_PIX_FMT_Y400A          AVPixelFormat = C.AV_PIX_FMT_Y400A        ///< alias for AV_PIX_FMT_YA8
	AV_PIX_FMT_GRAY8A         AVPixelFormat = C.AV_PIX_FMT_GRAY8A       ///< alias for AV_PIX_FMT_YA8
	AV_PIX_FMT_BGR48BE        AVPixelFormat = C.AV_PIX_FMT_BGR48BE      ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian
	AV_PIX_FMT_BGR48LE        AVPixelFormat = C.AV_PIX_FMT_BGR48LE      ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian
	AV_PIX_FMT_YUV420P9BE     AVPixelFormat = C.AV_PIX_FMT_YUV420P9BE   ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
	AV_PIX_FMT_YUV420P9LE     AVPixelFormat = C.AV_PIX_FMT_YUV420P9LE   ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
	AV_PIX_FMT_YUV420P10BE    AVPixelFormat = C.AV_PIX_FMT_YUV420P10BE  ///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
	AV_PIX_FMT_YUV420P10LE    AVPixelFormat = C.AV_PIX_FMT_YUV420P10LE  ///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
	AV_PIX_FMT_YUV422P10BE    AVPixelFormat = C.AV_PIX_FMT_YUV422P10BE  ///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AV_PIX_FMT_YUV422P10LE    AVPixelFormat = C.AV_PIX_FMT_YUV422P10LE  ///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AV_PIX_FMT_YUV444P9BE     AVPixelFormat = C.AV_PIX_FMT_YUV444P9BE   ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
	AV_PIX_FMT_YUV444P9LE     AVPixelFormat = C.AV_PIX_FMT_YUV444P9LE   ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	AV_PIX_FMT_YUV444P10BE    AVPixelFormat = C.AV_PIX_FMT_YUV444P10BE  ///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
	AV_PIX_FMT_YUV444P10LE    AVPixelFormat = C.AV_PIX_FMT_YUV444P10LE  ///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	AV_PIX_FMT_YUV422P9BE     AVPixelFormat = C.AV_PIX_FMT_YUV422P9BE   ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AV_PIX_FMT_YUV422P9LE     AVPixelFormat = C.AV_PIX_FMT_YUV422P9LE   ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AV_PIX_FMT_GBRP           AVPixelFormat = C.AV_PIX_FMT_GBRP         ///< planar GBR 4:4:4 24bpp
	AV_PIX_FMT_GBR24P         AVPixelFormat = C.AV_PIX_FMT_GBR24P       // alias for #AV_PIX_FMT_GBRP
	AV_PIX_FMT_GBRP9BE        AVPixelFormat = C.AV_PIX_FMT_GBRP9BE      ///< planar GBR 4:4:4 27bpp, big-endian
	AV_PIX_FMT_GBRP9LE        AVPixelFormat = C.AV_PIX_FMT_GBRP9LE      ///< planar GBR 4:4:4 27bpp, little-endian
	AV_PIX_FMT_GBRP10BE       AVPixelFormat = C.AV_PIX_FMT_GBRP10BE     ///< planar GBR 4:4:4 30bpp, big-endian
	AV_PIX_FMT_GBRP10LE       AVPixelFormat = C.AV_PIX_FMT_GBRP10LE     ///< planar GBR 4:4:4 30bpp, little-endian
	AV_PIX_FMT_GBRP16BE       AVPixelFormat = C.AV_PIX_FMT_GBRP16BE     ///< planar GBR 4:4:4 48bpp, big-endian
	AV_PIX_FMT_GBRP16LE       AVPixelFormat = C.AV_PIX_FMT_GBRP16LE     ///< planar GBR 4:4:4 48bpp, little-endian
	AV_PIX_FMT_YUVA422P       AVPixelFormat = C.AV_PIX_FMT_YUVA422P     ///< planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
	AV_PIX_FMT_YUVA444P       AVPixelFormat = C.AV_PIX_FMT_YUVA444P     ///< planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
	AV_PIX_FMT_YUVA420P9BE    AVPixelFormat = C.AV_PIX_FMT_YUVA420P9BE  ///< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
	AV_PIX_FMT_YUVA420P9LE    AVPixelFormat = C.AV_PIX_FMT_YUVA420P9LE  ///< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
	AV_PIX_FMT_YUVA422P9BE    AVPixelFormat = C.AV_PIX_FMT_YUVA422P9BE  ///< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
	AV_PIX_FMT_YUVA422P9LE    AVPixelFormat = C.AV_PIX_FMT_YUVA422P9LE  ///< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
	AV_PIX_FMT_YUVA444P9BE    AVPixelFormat = C.AV_PIX_FMT_YUVA444P9BE  ///< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
	AV_PIX_FMT_YUVA444P9LE    AVPixelFormat = C.AV_PIX_FMT_YUVA444P9LE  ///< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
	AV_PIX_FMT_YUVA420P10BE   AVPixelFormat = C.AV_PIX_FMT_YUVA420P10BE ///< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
	AV_PIX_FMT_YUVA420P10LE   AVPixelFormat = C.AV_PIX_FMT_YUVA420P10LE ///< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
	AV_PIX_FMT_YUVA422P10BE   AVPixelFormat = C.AV_PIX_FMT_YUVA422P10BE ///< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
	AV_PIX_FMT_YUVA422P10LE   AVPixelFormat = C.AV_PIX_FMT_YUVA422P10LE ///< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
	AV_PIX_FMT_YUVA444P10BE   AVPixelFormat = C.AV_PIX_FMT_YUVA444P10BE ///< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
	AV_PIX_FMT_YUVA444P10LE   AVPixelFormat = C.AV_PIX_FMT_YUVA444P10LE ///< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
	AV_PIX_FMT_YUVA420P16BE   AVPixelFormat = C.AV_PIX_FMT_YUVA420P16BE ///< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
	AV_PIX_FMT_YUVA420P16LE   AVPixelFormat = C.AV_PIX_FMT_YUVA420P16LE ///< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
	AV_PIX_FMT_YUVA422P16BE   AVPixelFormat = C.AV_PIX_FMT_YUVA422P16BE ///< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
	AV_PIX_FMT_YUVA422P16LE   AVPixelFormat = C.AV_PIX_FMT_YUVA422P16LE ///< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
	AV_PIX_FMT_YUVA444P16BE   AVPixelFormat = C.AV_PIX_FMT_YUVA444P16BE ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
	AV_PIX_FMT_YUVA444P16LE   AVPixelFormat = C.AV_PIX_FMT_YUVA444P16LE ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
	AV_PIX_FMT_VDPAU          AVPixelFormat = C.AV_PIX_FMT_VDPAU        ///< HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface
	AV_PIX_FMT_XYZ12LE        AVPixelFormat = C.AV_PIX_FMT_XYZ12LE      ///< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as little-endian, the 4 lower bits are set to 0
	AV_PIX_FMT_XYZ12BE        AVPixelFormat = C.AV_PIX_FMT_XYZ12BE      ///< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big-endian, the 4 lower bits are set to 0
	AV_PIX_FMT_NV16           AVPixelFormat = C.AV_PIX_FMT_NV16         ///< interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
	AV_PIX_FMT_NV20LE         AVPixelFormat = C.AV_PIX_FMT_NV20LE       ///< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AV_PIX_FMT_NV20BE         AVPixelFormat = C.AV_PIX_FMT_NV20BE       ///< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AV_PIX_FMT_RGBA64BE       AVPixelFormat = C.AV_PIX_FMT_RGBA64BE     ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
	AV_PIX_FMT_RGBA64LE       AVPixelFormat = C.AV_PIX_FMT_RGBA64LE     ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
	AV_PIX_FMT_BGRA64BE       AVPixelFormat = C.AV_PIX_FMT_BGRA64BE     ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
	AV_PIX_FMT_BGRA64LE       AVPixelFormat = C.AV_PIX_FMT_BGRA64LE     ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
	AV_PIX_FMT_YVYU422        AVPixelFormat = C.AV_PIX_FMT_YVYU422      ///< packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
	AV_PIX_FMT_YA16BE         AVPixelFormat = C.AV_PIX_FMT_YA16BE       ///< 16 bits gray, 16 bits alpha (big-endian)
	AV_PIX_FMT_YA16LE         AVPixelFormat = C.AV_PIX_FMT_YA16LE       ///< 16 bits gray, 16 bits alpha (little-endian)
	AV_PIX_FMT_GBRAP          AVPixelFormat = C.AV_PIX_FMT_GBRAP        ///< planar GBRA 4:4:4:4 32bpp
	AV_PIX_FMT_GBRAP16BE      AVPixelFormat = C.AV_PIX_FMT_GBRAP16BE    ///< planar GBRA 4:4:4:4 64bpp, big-endian
	AV_PIX_FMT_GBRAP16LE      AVPixelFormat = C.AV_PIX_FMT_GBRAP16LE    ///< planar GBRA 4:4:4:4 64bpp, little-endian
	AV_PIX_FMT_QSV            AVPixelFormat = C.AV_PIX_FMT_QSV
	AV_PIX_FMT_MMAL           AVPixelFormat = C.AV_PIX_FMT_MMAL
	AV_PIX_FMT_D3D11VA_VLD    AVPixelFormat = C.AV_PIX_FMT_D3D11VA_VLD ///< HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView pointer
	AV_PIX_FMT_CUDA           AVPixelFormat = C.AV_PIX_FMT_CUDA
	AV_PIX_FMT_0RGB           AVPixelFormat = C.AV_PIX_FMT_0RGB           ///< packed RGB 8:8:8, 32bpp, XRGBXRGB...   X=unused/undefined
	AV_PIX_FMT_RGB0           AVPixelFormat = C.AV_PIX_FMT_RGB0           ///< packed RGB 8:8:8, 32bpp, RGBXRGBX...   X=unused/undefined
	AV_PIX_FMT_0BGR           AVPixelFormat = C.AV_PIX_FMT_0BGR           ///< packed BGR 8:8:8, 32bpp, XBGRXBGR...   X=unused/undefined
	AV_PIX_FMT_BGR0           AVPixelFormat = C.AV_PIX_FMT_BGR0           ///< packed BGR 8:8:8, 32bpp, BGRXBGRX...   X=unused/undefined
	AV_PIX_FMT_YUV420P12BE    AVPixelFormat = C.AV_PIX_FMT_YUV420P12BE    ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
	AV_PIX_FMT_YUV420P12LE    AVPixelFormat = C.AV_PIX_FMT_YUV420P12LE    ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
	AV_PIX_FMT_YUV420P14BE    AVPixelFormat = C.AV_PIX_FMT_YUV420P14BE    ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
	AV_PIX_FMT_YUV420P14LE    AVPixelFormat = C.AV_PIX_FMT_YUV420P14LE    ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
	AV_PIX_FMT_YUV422P12BE    AVPixelFormat = C.AV_PIX_FMT_YUV422P12BE    ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AV_PIX_FMT_YUV422P12LE    AVPixelFormat = C.AV_PIX_FMT_YUV422P12LE    ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AV_PIX_FMT_YUV422P14BE    AVPixelFormat = C.AV_PIX_FMT_YUV422P14BE    ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AV_PIX_FMT_YUV422P14LE    AVPixelFormat = C.AV_PIX_FMT_YUV422P14LE    ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AV_PIX_FMT_YUV444P12BE    AVPixelFormat = C.AV_PIX_FMT_YUV444P12BE    ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
	AV_PIX_FMT_YUV444P12LE    AVPixelFormat = C.AV_PIX_FMT_YUV444P12LE    ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	AV_PIX_FMT_YUV444P14BE    AVPixelFormat = C.AV_PIX_FMT_YUV444P14BE    ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
	AV_PIX_FMT_YUV444P14LE    AVPixelFormat = C.AV_PIX_FMT_YUV444P14LE    ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	AV_PIX_FMT_GBRP12BE       AVPixelFormat = C.AV_PIX_FMT_GBRP12BE       ///< planar GBR 4:4:4 36bpp, big-endian
	AV_PIX_FMT_GBRP12LE       AVPixelFormat = C.AV_PIX_FMT_GBRP12LE       ///< planar GBR 4:4:4 36bpp, little-endian
	AV_PIX_FMT_GBRP14BE       AVPixelFormat = C.AV_PIX_FMT_GBRP14BE       ///< planar GBR 4:4:4 42bpp, big-endian
	AV_PIX_FMT_GBRP14LE       AVPixelFormat = C.AV_PIX_FMT_GBRP14LE       ///< planar GBR 4:4:4 42bpp, little-endian
	AV_PIX_FMT_YUVJ411P       AVPixelFormat = C.AV_PIX_FMT_YUVJ411P       ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV411P and setting color_range
	AV_PIX_FMT_BAYER_BGGR8    AVPixelFormat = C.AV_PIX_FMT_BAYER_BGGR8    ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
	AV_PIX_FMT_BAYER_RGGB8    AVPixelFormat = C.AV_PIX_FMT_BAYER_RGGB8    ///< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples
	AV_PIX_FMT_BAYER_GBRG8    AVPixelFormat = C.AV_PIX_FMT_BAYER_GBRG8    ///< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples
	AV_PIX_FMT_BAYER_GRBG8    AVPixelFormat = C.AV_PIX_FMT_BAYER_GRBG8    ///< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples
	AV_PIX_FMT_BAYER_BGGR16LE AVPixelFormat = C.AV_PIX_FMT_BAYER_BGGR16LE ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian
	AV_PIX_FMT_BAYER_BGGR16BE AVPixelFormat = C.AV_PIX_FMT_BAYER_BGGR16BE ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian
	AV_PIX_FMT_BAYER_RGGB16LE AVPixelFormat = C.AV_PIX_FMT_BAYER_RGGB16LE ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian
	AV_PIX_FMT_BAYER_RGGB16BE AVPixelFormat = C.AV_PIX_FMT_BAYER_RGGB16BE ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian
	AV_PIX_FMT_BAYER_GBRG16LE AVPixelFormat = C.AV_PIX_FMT_BAYER_GBRG16LE ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian
	AV_PIX_FMT_BAYER_GBRG16BE AVPixelFormat = C.AV_PIX_FMT_BAYER_GBRG16BE ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian
	AV_PIX_FMT_BAYER_GRBG16LE AVPixelFormat = C.AV_PIX_FMT_BAYER_GRBG16LE ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian
	AV_PIX_FMT_BAYER_GRBG16BE AVPixelFormat = C.AV_PIX_FMT_BAYER_GRBG16BE ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian
	AV_PIX_FMT_YUV440P10LE    AVPixelFormat = C.AV_PIX_FMT_YUV440P10LE    ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
	AV_PIX_FMT_YUV440P10BE    AVPixelFormat = C.AV_PIX_FMT_YUV440P10BE    ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
	AV_PIX_FMT_YUV440P12LE    AVPixelFormat = C.AV_PIX_FMT_YUV440P12LE    ///< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
	AV_PIX_FMT_YUV440P12BE    AVPixelFormat = C.AV_PIX_FMT_YUV440P12BE    ///< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
	AV_PIX_FMT_AYUV64LE       AVPixelFormat = C.AV_PIX_FMT_AYUV64LE       ///< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
	AV_PIX_FMT_AYUV64BE       AVPixelFormat = C.AV_PIX_FMT_AYUV64BE       ///< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
	AV_PIX_FMT_VIDEOTOOLBOX   AVPixelFormat = C.AV_PIX_FMT_VIDEOTOOLBOX   ///< hardware decoding through Videotoolbox
	AV_PIX_FMT_P010LE         AVPixelFormat = C.AV_PIX_FMT_P010LE         ///< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, little-endian
	AV_PIX_FMT_P010BE         AVPixelFormat = C.AV_PIX_FMT_P010BE         ///< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, big-endian
	AV_PIX_FMT_GBRAP12BE      AVPixelFormat = C.AV_PIX_FMT_GBRAP12BE      ///< planar GBR 4:4:4:4 48bpp, big-endian
	AV_PIX_FMT_GBRAP12LE      AVPixelFormat = C.AV_PIX_FMT_GBRAP12LE      ///< planar GBR 4:4:4:4 48bpp, little-endian
	AV_PIX_FMT_GBRAP10BE      AVPixelFormat = C.AV_PIX_FMT_GBRAP10BE      ///< planar GBR 4:4:4:4 40bpp, big-endian
	AV_PIX_FMT_GBRAP10LE      AVPixelFormat = C.AV_PIX_FMT_GBRAP10LE      ///< planar GBR 4:4:4:4 40bpp, little-endian
	AV_PIX_FMT_MEDIACODEC     AVPixelFormat = C.AV_PIX_FMT_MEDIACODEC     ///< hardware decoding through MediaCodec
	AV_PIX_FMT_GRAY12BE       AVPixelFormat = C.AV_PIX_FMT_GRAY12BE       ///<        Y        , 12bpp, big-endian
	AV_PIX_FMT_GRAY12LE       AVPixelFormat = C.AV_PIX_FMT_GRAY12LE       ///<        Y        , 12bpp, little-endian
	AV_PIX_FMT_GRAY10BE       AVPixelFormat = C.AV_PIX_FMT_GRAY10BE       ///<        Y        , 10bpp, big-endian
	AV_PIX_FMT_GRAY10LE       AVPixelFormat = C.AV_PIX_FMT_GRAY10LE       ///<        Y        , 10bpp, little-endian
	AV_PIX_FMT_P016LE         AVPixelFormat = C.AV_PIX_FMT_P016LE         ///< like NV12, with 16bpp per component, little-endian
	AV_PIX_FMT_P016BE         AVPixelFormat = C.AV_PIX_FMT_P016BE         ///< like NV12, with 16bpp per component, big-endian
	AV_PIX_FMT_D3D11          AVPixelFormat = C.AV_PIX_FMT_D3D11
	AV_PIX_FMT_GRAY9BE        AVPixelFormat = C.AV_PIX_FMT_GRAY9BE    ///<        Y        , 9bpp, big-endian
	AV_PIX_FMT_GRAY9LE        AVPixelFormat = C.AV_PIX_FMT_GRAY9LE    ///<        Y        , 9bpp, little-endian
	AV_PIX_FMT_GBRPF32BE      AVPixelFormat = C.AV_PIX_FMT_GBRPF32BE  ///< IEEE-754 single precision planar GBR 4:4:4,     96bpp, big-endian
	AV_PIX_FMT_GBRPF32LE      AVPixelFormat = C.AV_PIX_FMT_GBRPF32LE  ///< IEEE-754 single precision planar GBR 4:4:4,     96bpp, little-endian
	AV_PIX_FMT_GBRAPF32BE     AVPixelFormat = C.AV_PIX_FMT_GBRAPF32BE ///< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian
	AV_PIX_FMT_GBRAPF32LE     AVPixelFormat = C.AV_PIX_FMT_GBRAPF32LE ///< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian
	AV_PIX_FMT_DRM_PRIME      AVPixelFormat = C.AV_PIX_FMT_DRM_PRIME
	AV_PIX_FMT_OPENCL         AVPixelFormat = C.AV_PIX_FMT_OPENCL
	AV_PIX_FMT_GRAY14BE       AVPixelFormat = C.AV_PIX_FMT_GRAY14BE     ///<        Y        , 14bpp, big-endian
	AV_PIX_FMT_GRAY14LE       AVPixelFormat = C.AV_PIX_FMT_GRAY14LE     ///<        Y        , 14bpp, little-endian
	AV_PIX_FMT_GRAYF32BE      AVPixelFormat = C.AV_PIX_FMT_GRAYF32BE    ///< IEEE-754 single precision Y, 32bpp, big-endian
	AV_PIX_FMT_GRAYF32LE      AVPixelFormat = C.AV_PIX_FMT_GRAYF32LE    ///< IEEE-754 single precision Y, 32bpp, little-endian
	AV_PIX_FMT_YUVA422P12BE   AVPixelFormat = C.AV_PIX_FMT_YUVA422P12BE ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian
	AV_PIX_FMT_YUVA422P12LE   AVPixelFormat = C.AV_PIX_FMT_YUVA422P12LE ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian
	AV_PIX_FMT_YUVA444P12BE   AVPixelFormat = C.AV_PIX_FMT_YUVA444P12BE ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian
	AV_PIX_FMT_YUVA444P12LE   AVPixelFormat = C.AV_PIX_FMT_YUVA444P12LE ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian
	AV_PIX_FMT_NV24           AVPixelFormat = C.AV_PIX_FMT_NV24         ///< planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
	AV_PIX_FMT_NV42           AVPixelFormat = C.AV_PIX_FMT_NV42         ///< as above, but U and V bytes are swapped
	AV_PIX_FMT_VULKAN         AVPixelFormat = C.AV_PIX_FMT_VULKAN
	AV_PIX_FMT_Y210BE         AVPixelFormat = C.AV_PIX_FMT_Y210BE    ///< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, big-endian
	AV_PIX_FMT_Y210LE         AVPixelFormat = C.AV_PIX_FMT_Y210LE    ///< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian
	AV_PIX_FMT_X2RGB10LE      AVPixelFormat = C.AV_PIX_FMT_X2RGB10LE ///< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined
	AV_PIX_FMT_X2RGB10BE      AVPixelFormat = C.AV_PIX_FMT_X2RGB10BE ///< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), big-endian, X=unused/undefined
	AV_PIX_FMT_X2BGR10LE      AVPixelFormat = C.AV_PIX_FMT_X2BGR10LE ///< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined
	AV_PIX_FMT_X2BGR10BE      AVPixelFormat = C.AV_PIX_FMT_X2BGR10BE ///< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), big-endian, X=unused/undefined
	AV_PIX_FMT_P210BE         AVPixelFormat = C.AV_PIX_FMT_P210BE    ///< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, big-endian
	AV_PIX_FMT_P210LE         AVPixelFormat = C.AV_PIX_FMT_P210LE    ///< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, little-endian
	AV_PIX_FMT_P410BE         AVPixelFormat = C.AV_PIX_FMT_P410BE    ///< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, big-endian
	AV_PIX_FMT_P410LE         AVPixelFormat = C.AV_PIX_FMT_P410LE    ///< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, little-endian
	AV_PIX_FMT_P216BE         AVPixelFormat = C.AV_PIX_FMT_P216BE    ///< interleaved chroma YUV 4:2:2, 32bpp, big-endian
	AV_PIX_FMT_P216LE         AVPixelFormat = C.AV_PIX_FMT_P216LE    ///< interleaved chroma YUV 4:2:2, 32bpp, little-endian
	AV_PIX_FMT_P416BE         AVPixelFormat = C.AV_PIX_FMT_P416BE    ///< interleaved chroma YUV 4:4:4, 48bpp, big-endian
	AV_PIX_FMT_P416LE         AVPixelFormat = C.AV_PIX_FMT_P416LE    ///< interleaved chroma YUV 4:4:4, 48bpp, little-endian
	AV_PIX_FMT_VUYA           AVPixelFormat = C.AV_PIX_FMT_VUYA      ///< packed VUYA 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), VUYAVUYA...
	AV_PIX_FMT_RGBAF16BE      AVPixelFormat = C.AV_PIX_FMT_RGBAF16BE ///< IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., big-endian
	AV_PIX_FMT_RGBAF16LE      AVPixelFormat = C.AV_PIX_FMT_RGBAF16LE ///< IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., little-endian
	AV_PIX_FMT_VUYX           AVPixelFormat = C.AV_PIX_FMT_VUYX      ///< packed VUYX 4:4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined
	AV_PIX_FMT_P012LE         AVPixelFormat = C.AV_PIX_FMT_P012LE    ///< like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, little-endian
	AV_PIX_FMT_P012BE         AVPixelFormat = C.AV_PIX_FMT_P012BE    ///< like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, big-endian
	AV_PIX_FMT_Y212BE         AVPixelFormat = C.AV_PIX_FMT_Y212BE    ///< packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, big-endian
	AV_PIX_FMT_Y212LE         AVPixelFormat = C.AV_PIX_FMT_Y212LE    ///< packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, little-endian
	AV_PIX_FMT_XV30BE         AVPixelFormat = C.AV_PIX_FMT_XV30BE    ///< packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), big-endian, variant of Y410 where alpha channel is left undefined
	AV_PIX_FMT_XV30LE         AVPixelFormat = C.AV_PIX_FMT_XV30LE    ///< packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), little-endian, variant of Y410 where alpha channel is left undefined
	AV_PIX_FMT_XV36BE         AVPixelFormat = C.AV_PIX_FMT_XV36BE    ///< packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, big-endian, variant of Y412 where alpha channel is left undefined
	AV_PIX_FMT_XV36LE         AVPixelFormat = C.AV_PIX_FMT_XV36LE    ///< packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, little-endian, variant of Y412 where alpha channel is left undefined
	AV_PIX_FMT_RGBF32BE       AVPixelFormat = C.AV_PIX_FMT_RGBF32BE  ///< IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., big-endian
	AV_PIX_FMT_RGBF32LE       AVPixelFormat = C.AV_PIX_FMT_RGBF32LE  ///< IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., little-endian
	AV_PIX_FMT_RGBAF32BE      AVPixelFormat = C.AV_PIX_FMT_RGBAF32BE ///< IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., big-endian
	AV_PIX_FMT_RGBAF32LE      AVPixelFormat = C.AV_PIX_FMT_RGBAF32LE ///< IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., little-endian
	AV_PIX_FMT_P212BE         AVPixelFormat = C.AV_PIX_FMT_P212BE    ///< interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, big-endian
	AV_PIX_FMT_P212LE         AVPixelFormat = C.AV_PIX_FMT_P212LE    ///< interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, little-endian
	AV_PIX_FMT_P412BE         AVPixelFormat = C.AV_PIX_FMT_P412BE    ///< interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, big-endian
	AV_PIX_FMT_P412LE         AVPixelFormat = C.AV_PIX_FMT_P412LE    ///< interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, little-endian
	AV_PIX_FMT_GBRAP14BE      AVPixelFormat = C.AV_PIX_FMT_GBRAP14BE ///< planar GBR 4:4:4:4 56bpp, big-endian
	AV_PIX_FMT_GBRAP14LE      AVPixelFormat = C.AV_PIX_FMT_GBRAP14LE ///< planar GBR 4:4:4:4 56bpp, little-endian
	AV_PIX_FMT_D3D12          AVPixelFormat = C.AV_PIX_FMT_D3D12
	AV_PIX_FMT_AYUV           AVPixelFormat = C.AV_PIX_FMT_AYUV       ///< packed AYUV 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), AYUVAYUV...
	AV_PIX_FMT_UYVA           AVPixelFormat = C.AV_PIX_FMT_UYVA       ///< packed UYVA 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), UYVAUYVA...
	AV_PIX_FMT_VYU444         AVPixelFormat = C.AV_PIX_FMT_VYU444     ///< packed VYU 4:4:4, 24bpp (1 Cr & Cb sample per 1x1 Y), VYUVYU...
	AV_PIX_FMT_V30XBE         AVPixelFormat = C.AV_PIX_FMT_V30XBE     ///< packed VYUX 4:4:4 like XV30, 32bpp, (msb)10V 10Y 10U 2X(lsb), big-endian
	AV_PIX_FMT_V30XLE         AVPixelFormat = C.AV_PIX_FMT_V30XLE     ///< packed VYUX 4:4:4 like XV30, 32bpp, (msb)10V 10Y 10U 2X(lsb), little-endian
	AV_PIX_FMT_RGBF16BE       AVPixelFormat = C.AV_PIX_FMT_RGBF16BE   ///< IEEE-754 half precision packed RGB 16:16:16, 48bpp, RGBRGB..., big-endian
	AV_PIX_FMT_RGBF16LE       AVPixelFormat = C.AV_PIX_FMT_RGBF16LE   ///< IEEE-754 half precision packed RGB 16:16:16, 48bpp, RGBRGB..., little-endian
	AV_PIX_FMT_RGBA128BE      AVPixelFormat = C.AV_PIX_FMT_RGBA128BE  ///< packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., big-endian
	AV_PIX_FMT_RGBA128LE      AVPixelFormat = C.AV_PIX_FMT_RGBA128LE  ///< packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., little-endian
	AV_PIX_FMT_RGB96BE        AVPixelFormat = C.AV_PIX_FMT_RGB96BE    ///< packed RGB 32:32:32, 96bpp, RGBRGB..., big-endian
	AV_PIX_FMT_RGB96LE        AVPixelFormat = C.AV_PIX_FMT_RGB96LE    ///< packed RGB 32:32:32, 96bpp, RGBRGB..., little-endian
	AV_PIX_FMT_Y216BE         AVPixelFormat = C.AV_PIX_FMT_Y216BE     ///< packed YUV 4:2:2 like YUYV422, 32bpp, big-endian
	AV_PIX_FMT_Y216LE         AVPixelFormat = C.AV_PIX_FMT_Y216LE     ///< packed YUV 4:2:2 like YUYV422, 32bpp, little-endian
	AV_PIX_FMT_XV48BE         AVPixelFormat = C.AV_PIX_FMT_XV48BE     ///< packed XVYU 4:4:4, 64bpp, big-endian, variant of Y416 where alpha channel is left undefined
	AV_PIX_FMT_XV48LE         AVPixelFormat = C.AV_PIX_FMT_XV48LE     ///< packed XVYU 4:4:4, 64bpp, little-endian, variant of Y416 where alpha channel is left undefined
	AV_PIX_FMT_GBRPF16BE      AVPixelFormat = C.AV_PIX_FMT_GBRPF16BE  ///< IEEE-754 half precision planar GBR 4:4:4, 48bpp, big-endian
	AV_PIX_FMT_GBRPF16LE      AVPixelFormat = C.AV_PIX_FMT_GBRPF16LE  ///< IEEE-754 half precision planar GBR 4:4:4, 48bpp, little-endian
	AV_PIX_FMT_GBRAPF16BE     AVPixelFormat = C.AV_PIX_FMT_GBRAPF16BE ///< IEEE-754 half precision planar GBRA 4:4:4:4, 64bpp, big-endian
	AV_PIX_FMT_GBRAPF16LE     AVPixelFormat = C.AV_PIX_FMT_GBRAPF16LE ///< IEEE-754 half precision planar GBRA 4:4:4:4, 64bpp, little-endian
	AV_PIX_FMT_GRAYF16BE      AVPixelFormat = C.AV_PIX_FMT_GRAYF16BE  ///< IEEE-754 half precision Y, 16bpp, big-endian
	AV_PIX_FMT_GRAYF16LE      AVPixelFormat = C.AV_PIX_FMT_GRAYF16LE  ///< IEEE-754 half precision Y, 16bpp, little-endian
	AV_PIX_FMT_AMF_SURFACE    AVPixelFormat = C.AV_PIX_FMT_AMF_SURFACE
	AV_PIX_FMT_GRAY32BE       AVPixelFormat = C.AV_PIX_FMT_GRAY32BE       ///<        Y        , 32bpp, big-endian
	AV_PIX_FMT_GRAY32LE       AVPixelFormat = C.AV_PIX_FMT_GRAY32LE       ///<        Y        , 32bpp, little-endian
	AV_PIX_FMT_YAF32BE        AVPixelFormat = C.AV_PIX_FMT_YAF32BE        ///< IEEE-754 single precision packed YA, 32 bits gray, 32 bits alpha, 64bpp, big-endian
	AV_PIX_FMT_YAF32LE        AVPixelFormat = C.AV_PIX_FMT_YAF32LE        ///< IEEE-754 single precision packed YA, 32 bits gray, 32 bits alpha, 64bpp, little-endian
	AV_PIX_FMT_YAF16BE        AVPixelFormat = C.AV_PIX_FMT_YAF16BE        ///< IEEE-754 half precision packed YA, 16 bits gray, 16 bits alpha, 32bpp, big-endian
	AV_PIX_FMT_YAF16LE        AVPixelFormat = C.AV_PIX_FMT_YAF16LE        ///< IEEE-754 half precision packed YA, 16 bits gray, 16 bits alpha, 32bpp, little-endian
	AV_PIX_FMT_GBRAP32BE      AVPixelFormat = C.AV_PIX_FMT_GBRAP32BE      ///< planar GBRA 4:4:4:4 128bpp, big-endian
	AV_PIX_FMT_GBRAP32LE      AVPixelFormat = C.AV_PIX_FMT_GBRAP32LE      ///< planar GBRA 4:4:4:4 128bpp, little-endian
	AV_PIX_FMT_YUV444P10MSBBE AVPixelFormat = C.AV_PIX_FMT_YUV444P10MSBBE ///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, big-endian
	AV_PIX_FMT_YUV444P10MSBLE AVPixelFormat = C.AV_PIX_FMT_YUV444P10MSBLE ///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, little-endian
	AV_PIX_FMT_YUV444P12MSBBE AVPixelFormat = C.AV_PIX_FMT_YUV444P12MSBBE ///< planar YUV 4:4:4, 36bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, big-endian
	AV_PIX_FMT_YUV444P12MSBLE AVPixelFormat = C.AV_PIX_FMT_YUV444P12MSBLE ///< planar YUV 4:4:4, 36bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, little-endian
	AV_PIX_FMT_GBRP10MSBBE    AVPixelFormat = C.AV_PIX_FMT_GBRP10MSBBE    ///< planar GBR 4:4:4 30bpp, lowest bits zero, big-endian
	AV_PIX_FMT_GBRP10MSBLE    AVPixelFormat = C.AV_PIX_FMT_GBRP10MSBLE    ///< planar GBR 4:4:4 30bpp, lowest bits zero, little-endian
	AV_PIX_FMT_GBRP12MSBBE    AVPixelFormat = C.AV_PIX_FMT_GBRP12MSBBE    ///< planar GBR 4:4:4 36bpp, lowest bits zero, big-endian
	AV_PIX_FMT_GBRP12MSBLE    AVPixelFormat = C.AV_PIX_FMT_GBRP12MSBLE    ///< planar GBR 4:4:4 36bpp, lowest bits zero, little-endian
	AV_PIX_FMT_OHCODEC        AVPixelFormat = C.AV_PIX_FMT_OHCODEC        ///< hardware decoding through openharmony
)

func AVBufferSink_get_format 

func AVBufferSink_get_format(ctx *AVFilterContext) AVPixelFormat

Get the pixel format from the buffer sink.

func AVCodec_supported_pixelformat 

func AVCodec_supported_pixelformat(codec *AVCodec, pixelfmt AVPixelFormat) (AVPixelFormat, error)

Return a supported pixel format that is closest to the given pixel format.

func AVUtil_get_pix_fmt 

func AVUtil_get_pix_fmt(name string) AVPixelFormat

Return the pixel format corresponding to name. If no pixel format has been found, returns AV_PIX_FMT_NONE

func AVUtil_next_pixel_fmt 

func AVUtil_next_pixel_fmt(iterator *uintptr) AVPixelFormat

Enumerate pixel formats

func (AVPixelFormat) MarshalJSON 

func (v AVPixelFormat) MarshalJSON() ([]byte, error)

func (AVPixelFormat) String 

func (v AVPixelFormat) String() string

type AVProfile 

type AVProfile C.struct_AVProfile

func (*AVProfile) ID 

func (c *AVProfile) ID() int

func (AVProfile) MarshalJSON 

func (ctx AVProfile) MarshalJSON() ([]byte, error)

func (*AVProfile) Name 

func (c *AVProfile) Name() string

func (AVProfile) String 

func (ctx AVProfile) String() string

type AVRational 

type AVRational C.AVRational

func AVBufferSink_get_frame_rate 

func AVBufferSink_get_frame_rate(ctx *AVFilterContext) AVRational

Get the frame rate from the buffer sink.

func AVBufferSink_get_sample_aspect_ratio 

func AVBufferSink_get_sample_aspect_ratio(ctx *AVFilterContext) AVRational

Get the sample aspect ratio from the buffer sink.

func AVBufferSink_get_time_base 

func AVBufferSink_get_time_base(ctx *AVFilterContext) AVRational

Get the time base from the buffer sink.

func AVUtil_parse_video_rate 

func AVUtil_parse_video_rate(rate string) (AVRational, error)

AVUtil_parse_video_rate parses a string representing a video frame rate and returns an AVRational. The string can be in formats like "25", "30000/1001", "29.97", etc.

Returns AVRational and error if parsing fails.

func AVUtil_rational 

func AVUtil_rational(num, den int) AVRational

Create a new rational

func AVUtil_rational_d2q 

func AVUtil_rational_d2q(d float64, max int) AVRational

Convert a float64 to a rational.

func AVUtil_rational_invert 

func AVUtil_rational_invert(q AVRational) AVRational

Invert a rational.

func (AVRational) Den 

func (r AVRational) Den() int

Denominator

func (AVRational) Float 

func (r AVRational) Float(multiplier int64) float64

Float is used to convert an int64 value multipled by the rational to a float64

func (AVRational) IsZero 

func (r AVRational) IsZero() bool

IsZero returns true if the rational is zero

func (AVRational) MarshalJSON 

func (r AVRational) MarshalJSON() ([]byte, error)

func (AVRational) Num 

func (r AVRational) Num() int

Numerator

func (AVRational) String 

func (r AVRational) String() string

type AVRounding 

type AVRounding C.enum_AVRounding
const (
	AV_ROUND_ZERO        AVRounding = C.AV_ROUND_ZERO        // Round toward zero.
	AV_ROUND_INF         AVRounding = C.AV_ROUND_INF         // Round away from zero.
	AV_ROUND_DOWN        AVRounding = C.AV_ROUND_DOWN        // Round toward -infinity.
	AV_ROUND_UP          AVRounding = C.AV_ROUND_UP          // Round toward +infinity.
	AV_ROUND_NEAR_INF    AVRounding = C.AV_ROUND_NEAR_INF    // Round to nearest and halfway cases away from zero.
	AV_ROUND_PASS_MINMAX AVRounding = C.AV_ROUND_PASS_MINMAX // Flag to pass INT64_MIN/MAX through instead of rescaling, this avoids special cases for AV_NOPTS_VALUE
)

type AVSampleFormat 

type AVSampleFormat C.enum_AVSampleFormat
const (
	AV_SAMPLE_FMT_NONE AVSampleFormat = C.AV_SAMPLE_FMT_NONE
	AV_SAMPLE_FMT_U8   AVSampleFormat = C.AV_SAMPLE_FMT_U8
	AV_SAMPLE_FMT_S16  AVSampleFormat = C.AV_SAMPLE_FMT_S16
	AV_SAMPLE_FMT_S32  AVSampleFormat = C.AV_SAMPLE_FMT_S32
	AV_SAMPLE_FMT_FLT  AVSampleFormat = C.AV_SAMPLE_FMT_FLT
	AV_SAMPLE_FMT_DBL  AVSampleFormat = C.AV_SAMPLE_FMT_DBL
	AV_SAMPLE_FMT_U8P  AVSampleFormat = C.AV_SAMPLE_FMT_U8P
	AV_SAMPLE_FMT_S16P AVSampleFormat = C.AV_SAMPLE_FMT_S16P
	AV_SAMPLE_FMT_S32P AVSampleFormat = C.AV_SAMPLE_FMT_S32P
	AV_SAMPLE_FMT_FLTP AVSampleFormat = C.AV_SAMPLE_FMT_FLTP
	AV_SAMPLE_FMT_DBLP AVSampleFormat = C.AV_SAMPLE_FMT_DBLP
	AV_SAMPLE_FMT_S64  AVSampleFormat = C.AV_SAMPLE_FMT_S64
	AV_SAMPLE_FMT_S64P AVSampleFormat = C.AV_SAMPLE_FMT_S64P
	AV_SAMPLE_FMT_NB   AVSampleFormat = C.AV_SAMPLE_FMT_NB
)

func AVCodec_supported_sampleformat 

func AVCodec_supported_sampleformat(codec *AVCodec, samplefmt AVSampleFormat) (AVSampleFormat, error)

Return a supported sample format that is closest to the given sample format.

func AVUtil_get_packed_sample_fmt 

func AVUtil_get_packed_sample_fmt(sample_fmt AVSampleFormat) AVSampleFormat

Get the packed alternative form of the given sample format. If the passed sample_fmt is already in packed format, the format returned is the same as the input.

func AVUtil_get_planar_sample_fmt 

func AVUtil_get_planar_sample_fmt(sample_fmt AVSampleFormat) AVSampleFormat

Get the planar alternative form of the given sample format. If the passed sample_fmt is already in planar format, the format returned is the same as the input.

func AVUtil_get_sample_fmt 

func AVUtil_get_sample_fmt(name string) AVSampleFormat

Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE on error.

func AVUtil_next_sample_fmt 

func AVUtil_next_sample_fmt(iterator *uintptr) AVSampleFormat

Enumerate sample formats

func (AVSampleFormat) MarshalJSON 

func (v AVSampleFormat) MarshalJSON() ([]byte, error)

func (AVSampleFormat) String 

func (v AVSampleFormat) String() string

type AVSeekFlag 

type AVSeekFlag C.int
const (
	AVSEEK_FLAG_NONE     AVSeekFlag = 0                      ///< no special flags
	AVSEEK_FLAG_BACKWARD AVSeekFlag = C.AVSEEK_FLAG_BACKWARD ///< seek backward
	AVSEEK_FLAG_BYTE     AVSeekFlag = C.AVSEEK_FLAG_BYTE     ///< seek by byte
	AVSEEK_FLAG_ANY      AVSeekFlag = C.AVSEEK_FLAG_ANY      ///< seek to any frame
	AVSEEK_FLAG_FRAME    AVSeekFlag = C.AVSEEK_FLAG_FRAME    ///< seek to frame
	AVSEEK_FLAG_MIN                 = AVSEEK_FLAG_BACKWARD
	AVSEEK_FLAG_MAX                 = AVSEEK_FLAG_FRAME
)

func (AVSeekFlag) FlagString 

func (f AVSeekFlag) FlagString() string

func (AVSeekFlag) Is 

func (f AVSeekFlag) Is(flag AVSeekFlag) bool

func (AVSeekFlag) MarshalJSON 

func (f AVSeekFlag) MarshalJSON() ([]byte, error)

func (AVSeekFlag) String 

func (f AVSeekFlag) String() string

type AVStream 

type AVStream C.struct_AVStream

func AVFormat_new_stream 

func AVFormat_new_stream(ctx *AVFormatContext, c *AVCodec) *AVStream

func (*AVStream) AttachedPic 

func (ctx *AVStream) AttachedPic() *AVPacket

func (*AVStream) CodecPar 

func (ctx *AVStream) CodecPar() *AVCodecParameters

func (*AVStream) Disposition 

func (ctx *AVStream) Disposition() AVDisposition

func (*AVStream) Duration 

func (ctx *AVStream) Duration() int64

func (*AVStream) Id 

func (ctx *AVStream) Id() int

func (*AVStream) Index 

func (ctx *AVStream) Index() int

func (*AVStream) MarshalJSON 

func (ctx *AVStream) MarshalJSON() ([]byte, error)

func (*AVStream) NumFrames 

func (ctx *AVStream) NumFrames() int64

func (*AVStream) SetAttachedPic 

func (ctx *AVStream) SetAttachedPic(pkt *AVPacket)

func (*AVStream) SetDisposition 

func (ctx *AVStream) SetDisposition(disposition AVDisposition)

func (*AVStream) SetId 

func (ctx *AVStream) SetId(id int)

func (*AVStream) SetTimeBase 

func (ctx *AVStream) SetTimeBase(time_base AVRational)

func (*AVStream) StartTime 

func (ctx *AVStream) StartTime() int64

func (*AVStream) String 

func (ctx *AVStream) String() string

func (*AVStream) TimeBase 

func (ctx *AVStream) TimeBase() AVRational

type AVSubtitle 

type AVSubtitle C.struct_AVSubtitle

func AVCodec_decode_subtitle 

func AVCodec_decode_subtitle(ctx *AVCodecContext, pkt *AVPacket) (*AVSubtitle, error)

Decode a subtitle message. Returns the decoded subtitle or nil if no subtitle could be decompressed. Returns an error on failure.

func (*AVSubtitle) EndDisplayTime 

func (sub *AVSubtitle) EndDisplayTime() uint32

func (*AVSubtitle) Format 

func (sub *AVSubtitle) Format() uint16

func (*AVSubtitle) MarshalJSON 

func (sub *AVSubtitle) MarshalJSON() ([]byte, error)

func (*AVSubtitle) NumRects 

func (sub *AVSubtitle) NumRects() uint

func (*AVSubtitle) PTS 

func (sub *AVSubtitle) PTS() int64

func (*AVSubtitle) Rects 

func (sub *AVSubtitle) Rects() []*AVSubtitleRect

func (*AVSubtitle) SetEndDisplayTime 

func (sub *AVSubtitle) SetEndDisplayTime(ms uint32)

func (*AVSubtitle) SetFormat 

func (sub *AVSubtitle) SetFormat(format uint16)

func (*AVSubtitle) SetPTS 

func (sub *AVSubtitle) SetPTS(pts int64)

func (*AVSubtitle) SetStartDisplayTime 

func (sub *AVSubtitle) SetStartDisplayTime(ms uint32)

func (*AVSubtitle) StartDisplayTime 

func (sub *AVSubtitle) StartDisplayTime() uint32

func (*AVSubtitle) String 

func (sub *AVSubtitle) String() string

type AVSubtitleRect 

type AVSubtitleRect C.struct_AVSubtitleRect

func (*AVSubtitleRect) Data 

func (rect *AVSubtitleRect) Data(plane int) []byte

Get bitmap data for SUBTITLE_BITMAP type

func (*AVSubtitleRect) Flags 

func (rect *AVSubtitleRect) Flags() int

func (*AVSubtitleRect) Height 

func (rect *AVSubtitleRect) Height() int

func (*AVSubtitleRect) Linesize 

func (rect *AVSubtitleRect) Linesize(plane int) int

func (*AVSubtitleRect) MarshalJSON 

func (rect *AVSubtitleRect) MarshalJSON() ([]byte, error)

func (*AVSubtitleRect) NumColors 

func (rect *AVSubtitleRect) NumColors() int

func (*AVSubtitleRect) SetFlags 

func (rect *AVSubtitleRect) SetFlags(flags int)

func (*AVSubtitleRect) SetHeight 

func (rect *AVSubtitleRect) SetHeight(h int)

func (*AVSubtitleRect) SetNumColors 

func (rect *AVSubtitleRect) SetNumColors(n int)

func (*AVSubtitleRect) SetType 

func (rect *AVSubtitleRect) SetType(t AVSubtitleType)

func (*AVSubtitleRect) SetWidth 

func (rect *AVSubtitleRect) SetWidth(w int)

func (*AVSubtitleRect) SetX 

func (rect *AVSubtitleRect) SetX(x int)

func (*AVSubtitleRect) SetY 

func (rect *AVSubtitleRect) SetY(y int)

func (*AVSubtitleRect) String 

func (rect *AVSubtitleRect) String() string

func (*AVSubtitleRect) Text 

func (rect *AVSubtitleRect) Text() string

Get text content for SUBTITLE_TEXT or SUBTITLE_ASS types. Returns the text field for SUBTITLE_TEXT or the ass field for SUBTITLE_ASS. Returns empty string for other types (BITMAP, NONE).

func (*AVSubtitleRect) Type 

func (rect *AVSubtitleRect) Type() AVSubtitleType

func (*AVSubtitleRect) Width 

func (rect *AVSubtitleRect) Width() int

func (*AVSubtitleRect) X 

func (rect *AVSubtitleRect) X() int

func (*AVSubtitleRect) Y 

func (rect *AVSubtitleRect) Y() int

type AVSubtitleType 

type AVSubtitleType C.enum_AVSubtitleType
const (
	SUBTITLE_NONE   AVSubtitleType = C.SUBTITLE_NONE
	SUBTITLE_BITMAP AVSubtitleType = C.SUBTITLE_BITMAP
	SUBTITLE_TEXT   AVSubtitleType = C.SUBTITLE_TEXT
	SUBTITLE_ASS    AVSubtitleType = C.SUBTITLE_ASS
)

func (AVSubtitleType) MarshalJSON 

func (t AVSubtitleType) MarshalJSON() ([]byte, error)

func (AVSubtitleType) String 

func (t AVSubtitleType) String() string

type AVTimestamp 

type AVTimestamp C.int64_t
const (
	AV_NOPTS_VALUE AVTimestamp = C.AV_NOPTS_VALUE
	AV_TIME_BASE               = C.AV_TIME_BASE // Internal time base
)

func (AVTimestamp) MarshalJSON 

func (v AVTimestamp) MarshalJSON() ([]byte, error)

type SWRContext 

type SWRContext C.struct_SwrContext

func SWResample_alloc 

func SWResample_alloc() *SWRContext

Allocate SwrContext.

func (*SWRContext) String 

func (ctx *SWRContext) String() string

type SWSContext 

type SWSContext C.struct_SwsContext

func SWScale_alloc_context 

func SWScale_alloc_context() *SWSContext

Allocate an empty SWSContext.

func SWScale_get_cached_context 

func SWScale_get_cached_context(ctx *SWSContext, src_width, src_height int, src_format AVPixelFormat, dst_width, dst_height int, dst_format AVPixelFormat, flags SWSFlag, src_filter, dst_filter *SWSFilter, param []float64) *SWSContext

Check if context can be reused, otherwise reallocate a new one.

If context is nil, just calls sws_getContext() to get a new context. Otherwise, checks if the parameters match those already saved in context. If they match, returns the current context. Otherwise, frees context and gets a new context with the new parameters.

Note: src_filter and dst_filter are not checked, they are assumed to remain the same.

func SWScale_get_context 

func SWScale_get_context(src_width, src_height int, src_format AVPixelFormat, dst_width, dst_height int, dst_format AVPixelFormat, flags SWSFlag, src_filter, dst_filter *SWSFilter, param []float64) *SWSContext

Allocate and return an SwsContext.

func (*SWSContext) String 

func (ctx *SWSContext) String() string

type SWSFilter 

type SWSFilter C.struct_SwsFilter

func (*SWSFilter) String 

func (filter *SWSFilter) String() string

type SWSFlag 

type SWSFlag C.int
const (
	SWS_NONE          SWSFlag = 0
	SWS_FAST_BILINEAR SWSFlag = C.SWS_FAST_BILINEAR
	SWS_BILINEAR      SWSFlag = C.SWS_BILINEAR
	SWS_BICUBIC       SWSFlag = C.SWS_BICUBIC
	SWS_X             SWSFlag = C.SWS_X
	SWS_POINT         SWSFlag = C.SWS_POINT
	SWS_AREA          SWSFlag = C.SWS_AREA
	SWS_BICUBLIN      SWSFlag = C.SWS_BICUBLIN
	SWS_GAUSS         SWSFlag = C.SWS_GAUSS
	SWS_SINC          SWSFlag = C.SWS_SINC
	SWS_LANCZOS       SWSFlag = C.SWS_LANCZOS
	SWS_SPLINE        SWSFlag = C.SWS_SPLINE
	SWS_MIN                   = SWS_FAST_BILINEAR
	SWS_MAX                   = SWS_SPLINE
)

func (SWSFlag) FlagString 

func (v SWSFlag) FlagString() string

func (SWSFlag) String 

func (v SWSFlag) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.