ffmpeg

package
v1.6.2 Latest Latest
Warning

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

 Go to latest Published: Jun 18, 2024 License: Apache-2.0 Imports: 7 Imported by: 1

Documentation

Overview

Package ffmpeg provides low-level ffmpeg for go

Index

Constants

View Source 
const (
	AV_ROUND_ZERO        = C.AV_ROUND_ZERO        ///< Round toward zero.
	AV_ROUND_INF         = C.AV_ROUND_INF         ///< Round away from zero.
	AV_ROUND_DOWN        = C.AV_ROUND_DOWN        ///< Round toward -infinity.
	AV_ROUND_UP          = C.AV_ROUND_UP          ///< Round toward +infinity.
	AV_ROUND_NEAR_INF    = C.AV_ROUND_NEAR_INF    ///< Round to nearest and halfway cases away from zero.
	AV_ROUND_PASS_MINMAX = C.AV_ROUND_PASS_MINMAX ///< Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged
)
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 (
	FF_PROFILE_UNKNOWN = C.FF_PROFILE_UNKNOWN
)

Variables

View Source 
var (
	AV_CHANNEL_LAYOUT_MONO                  = AVChannelLayout(C._AV_CHANNEL_LAYOUT_MONO)
	AV_CHANNEL_LAYOUT_STEREO                = AVChannelLayout(C._AV_CHANNEL_LAYOUT_STEREO)
	AV_CHANNEL_LAYOUT_2POINT1               = AVChannelLayout(C._AV_CHANNEL_LAYOUT_2POINT1)
	AV_CHANNEL_LAYOUT_2_1                   = AVChannelLayout(C._AV_CHANNEL_LAYOUT_2_1)
	AV_CHANNEL_LAYOUT_SURROUND              = AVChannelLayout(C._AV_CHANNEL_LAYOUT_SURROUND)
	AV_CHANNEL_LAYOUT_3POINT1               = AVChannelLayout(C._AV_CHANNEL_LAYOUT_3POINT1)
	AV_CHANNEL_LAYOUT_4POINT0               = AVChannelLayout(C._AV_CHANNEL_LAYOUT_4POINT0)
	AV_CHANNEL_LAYOUT_4POINT1               = AVChannelLayout(C._AV_CHANNEL_LAYOUT_4POINT1)
	AV_CHANNEL_LAYOUT_2_2                   = AVChannelLayout(C._AV_CHANNEL_LAYOUT_2_2)
	AV_CHANNEL_LAYOUT_QUAD                  = AVChannelLayout(C._AV_CHANNEL_LAYOUT_QUAD)
	AV_CHANNEL_LAYOUT_5POINT0               = AVChannelLayout(C._AV_CHANNEL_LAYOUT_5POINT0)
	AV_CHANNEL_LAYOUT_5POINT1               = AVChannelLayout(C._AV_CHANNEL_LAYOUT_5POINT1)
	AV_CHANNEL_LAYOUT_5POINT0_BACK          = AVChannelLayout(C._AV_CHANNEL_LAYOUT_5POINT0_BACK)
	AV_CHANNEL_LAYOUT_5POINT1_BACK          = AVChannelLayout(C._AV_CHANNEL_LAYOUT_5POINT1_BACK)
	AV_CHANNEL_LAYOUT_6POINT0               = AVChannelLayout(C._AV_CHANNEL_LAYOUT_6POINT0)
	AV_CHANNEL_LAYOUT_6POINT0_FRONT         = AVChannelLayout(C._AV_CHANNEL_LAYOUT_6POINT0_FRONT)
	AV_CHANNEL_LAYOUT_HEXAGONAL             = AVChannelLayout(C._AV_CHANNEL_LAYOUT_HEXAGONAL)
	AV_CHANNEL_LAYOUT_6POINT1               = AVChannelLayout(C._AV_CHANNEL_LAYOUT_6POINT1)
	AV_CHANNEL_LAYOUT_6POINT1_BACK          = AVChannelLayout(C._AV_CHANNEL_LAYOUT_6POINT1_BACK)
	AV_CHANNEL_LAYOUT_6POINT1_FRONT         = AVChannelLayout(C._AV_CHANNEL_LAYOUT_6POINT1_FRONT)
	AV_CHANNEL_LAYOUT_7POINT0               = AVChannelLayout(C._AV_CHANNEL_LAYOUT_7POINT0)
	AV_CHANNEL_LAYOUT_7POINT0_FRONT         = AVChannelLayout(C._AV_CHANNEL_LAYOUT_7POINT0_FRONT)
	AV_CHANNEL_LAYOUT_7POINT1               = AVChannelLayout(C._AV_CHANNEL_LAYOUT_7POINT1)
	AV_CHANNEL_LAYOUT_7POINT1_WIDE          = AVChannelLayout(C._AV_CHANNEL_LAYOUT_7POINT1_WIDE)
	AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK     = AVChannelLayout(C._AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK)
	AV_CHANNEL_LAYOUT_OCTAGONAL             = AVChannelLayout(C._AV_CHANNEL_LAYOUT_OCTAGONAL)
	AV_CHANNEL_LAYOUT_HEXADECAGONAL         = AVChannelLayout(C._AV_CHANNEL_LAYOUT_HEXADECAGONAL)
	AV_CHANNEL_LAYOUT_STEREO_DOWNMIX        = AVChannelLayout(C._AV_CHANNEL_LAYOUT_STEREO_DOWNMIX)
	AV_CHANNEL_LAYOUT_22POINT2              = AVChannelLayout(C._AV_CHANNEL_LAYOUT_22POINT2)
	AV_CHANNEL_LAYOUT_AMBISONIC_FIRST_ORDER = AVChannelLayout(C._AV_CHANNEL_LAYOUT_AMBISONIC_FIRST_ORDER)
)

Functions

func AVCodec_av_grow_packet 

func AVCodec_av_grow_packet(pkt *AVPacket, size int) error

Increase packet size, correctly zeroing padding.

func AVCodec_av_new_packet 

func AVCodec_av_new_packet(pkt *AVPacket, size int) error

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

func AVCodec_av_packet_free 

func AVCodec_av_packet_free(pkt **AVPacket)

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

func AVCodec_av_packet_free_ptr 

func AVCodec_av_packet_free_ptr(pkt *AVPacket)

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

func AVCodec_av_packet_unref 

func AVCodec_av_packet_unref(pkt *AVPacket)

Unreference the packet to release the data

func AVCodec_av_shrink_packet 

func AVCodec_av_shrink_packet(pkt *AVPacket, size int)

Reduce packet size, correctly zeroing padding.

func AVCodec_configuration 

func AVCodec_configuration() string

Return the libavcodec build-time configuration.

func AVCodec_free_context 

func AVCodec_free_context(ctx **AVCodecContext)

Free the codec context and everything associated with it and write NULL to the provided pointer.

func AVCodec_free_context_ptr 

func AVCodec_free_context_ptr(ctx *AVCodecContext)

Free the codec context and everything associated with it

func AVCodec_license 

func AVCodec_license() string

Return the libavcodec license.

func AVCodec_open2 

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

Initialize the AVCodecContext to use the given AVCodec.

func AVCodec_parameters_to_context 

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

Copy codec parameters from input stream to output codec context.

func AVCodec_receive_frame 

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

Return decoded output data from a decoder or encoder. Error return of EAGAIN means that more input is needed to produce output, while EINVAL means that the decoder has been flushed and no more output is available.

func AVCodec_send_packet 

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

Send a packet with a compressed frame to a decoder. Error return of EAGAIN means that more input is needed to produce output, while EINVAL means that the decoder has been flushed and no more output is available.

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_license 

func AVDevice_license() string

Return the libavdevice license.

func AVDevice_register_all 

func AVDevice_register_all()

Initialize libavdevice and register all the input and output devices.

func AVDevice_version 

func AVDevice_version() uint

Return the LIBAVDEVICE_VERSION_INT constant.

func AVFormat_av_find_best_stream 

func AVFormat_av_find_best_stream(ctx *AVFormatContext, media_type AVMediaType, wanted_stream_nb int, related_stream int, decoder_ret **AVCodec, flags int) (int, error)

Find the best stream based on a media type.

func AVFormat_av_read_frame 

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

Return the next frame of a stream. Returns io.EOF when no more frames are available.

func AVFormat_avio_close 

func AVFormat_avio_close(ctx *AVIOContext) error

func AVFormat_avio_find_protocol_name 

func AVFormat_avio_find_protocol_name(url string) string

func AVFormat_close_input 

func AVFormat_close_input(ctx **AVFormatContext)

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

func AVFormat_close_input_ptr 

func AVFormat_close_input_ptr(ctx *AVFormatContext)

Close an opened input AVFormatContext.

func AVFormat_configuration 

func AVFormat_configuration() string

Return the libavformat build-time configuration.

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_free_context 

func AVFormat_free_context(ctx *AVFormatContext)

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.

func AVFormat_license 

func AVFormat_license() string

Return the libavformat license.

func AVFormat_version 

func AVFormat_version() uint

Return the LIBAVFORMAT_VERSION_INT constant.

func AVFormat_write_frame 

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

Write a packet to an output media file. Returns true if flushed and there is no more data to flush.

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 AVUtil_av_channel_description 

func AVUtil_av_channel_description(channel AVChannel) (string, error)

Get a human readable string describing a given channel.

func AVUtil_av_channel_layout_check 

func AVUtil_av_channel_layout_check(ch_layout *AVChannelLayout) bool

Check whether a channel layout is valid

func AVUtil_av_channel_layout_default 

func AVUtil_av_channel_layout_default(ch_layout *AVChannelLayout, nb_channels int)

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

func AVUtil_av_channel_layout_describe 

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

Iterate over all standard channel layouts.

func AVUtil_av_channel_layout_from_string 

func AVUtil_av_channel_layout_from_string(ch_layout *AVChannelLayout, str string) error

Return channel layout from a description

func AVUtil_av_channel_layout_index_from_channel 

func AVUtil_av_channel_layout_index_from_channel(ch_layout *AVChannelLayout, channel AVChannel) int

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

func AVUtil_av_channel_layout_uninit 

func AVUtil_av_channel_layout_uninit(ch_layout *AVChannelLayout)

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

func AVUtil_av_channel_name 

func AVUtil_av_channel_name(channel AVChannel) (string, error)

Get the name of a given channel.

func AVUtil_av_dict_count 

func AVUtil_av_dict_count(dict *AVDictionary) int

Get the number of entries in the dictionary.

func AVUtil_av_dict_free 

func AVUtil_av_dict_free(dict **AVDictionary)

Free a dictionary and all entries in the dictionary.

func AVUtil_av_dict_free_ptr 

func AVUtil_av_dict_free_ptr(dict *AVDictionary)

Free a dictionary and all entries in the dictionary.

func AVUtil_av_dict_keys 

func AVUtil_av_dict_keys(dict *AVDictionary) []string

Get the keys for the dictionary.

func AVUtil_av_dict_set 

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

Set the given entry, overwriting an existing entry.

func AVUtil_av_get_bytes_per_sample 

func AVUtil_av_get_bytes_per_sample(f AVSampleFormat) int

Return number of bytes per sample or zero if unknown for the given sample format

func AVUtil_av_get_channel_layout_nb_channels 

func AVUtil_av_get_channel_layout_nb_channels(ch_layout *AVChannelLayout) int

Return number of channels

func AVUtil_av_get_sample_fmt_name 

func AVUtil_av_get_sample_fmt_name(v AVSampleFormat) string

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

func AVUtil_av_log 

func AVUtil_av_log(class *AVClass, level AVLogLevel, 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_av_log_set_level 

func AVUtil_av_log_set_level(level AVLogLevel, cb AVLogCallback)

sets both the callback function and the level of output for logging. Where the callback is nil, the default ffmpeg logging is used.

func AVUtil_av_rescale 

func AVUtil_av_rescale(a, b, c int64) int64

Rescale a 64-bit integer with rounding to nearest. The operation is mathematically equivalent to `a * b / c`, but writing that udirectly can overflow.

func AVUtil_av_rescale_rnd 

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

Rescale a 64-bit integer with specified rounding. The operation is mathematically equivalent to `a * b / c“, but writing that directly can overflow, and does not support different rounding methods. If the result is not representable then INT64_MIN is returned.

func AVUtil_av_sample_fmt_is_planar 

func AVUtil_av_sample_fmt_is_planar(f AVSampleFormat) bool

Check if the sample format is planar.

func AVUtil_av_samples_alloc 

func AVUtil_av_samples_alloc(data **uint8, linesize *int, nb_channels int, nb_samples int, sample_fmt AVSampleFormat, align int) error

Allocate a samples buffer for nb_samples samples, and fill data pointers and linesize accordingly. Allocated data will be initialized to silence. When align is 1 no alignment is done

func AVUtil_av_samples_free 

func AVUtil_av_samples_free(data **uint8)

Free buffers which were allocated by av_samples_alloc().

func AVUtil_av_samples_get_buffer_size 

func AVUtil_av_samples_get_buffer_size(linesize *int, nb_channels int, nb_samples int, sample_fmt AVSampleFormat, align int) (int, error)

Get the required buffer size for the given audio parameters. When align is 1 no alignment is done

func AVUtil_configuration 

func AVUtil_configuration() string

Return the libavformat build-time configuration.

func AVUtil_frame_free 

func AVUtil_frame_free(frame **AVFrame)

Free the frame and any dynamically allocated objects in it

func AVUtil_frame_free_ptr 

func AVUtil_frame_free_ptr(frame *AVFrame)

Free the frame and any dynamically allocated objects in it

func AVUtil_frame_unref 

func AVUtil_frame_unref(frame *AVFrame)

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

func AVUtil_license 

func AVUtil_license() string

Return the libavformat license.

func AVUtil_version 

func AVUtil_version() uint

Return the LIBAVFORMAT_VERSION_INT constant.

func SWS_configuration 

func SWS_configuration() string

Return the swr build-time configuration.

func SWS_frame_end 

func SWS_frame_end(ctx *SWSContext)

Finish the scaling process for a pair of source/destination frames previously submitted with sws_frame_start

func SWS_frame_start 

func SWS_frame_start(ctx *SWSContext, src, dst *AVFrame) error

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

func SWS_free_context 

func SWS_free_context(ctx *SWSContext)

Free the swscaler context swsContext.

func SWS_get_coefficients 

func SWS_get_coefficients(colorspace int) *int

Return a pointer to yuv<->rgb coefficients for the given colorspace suitable for sws_setColorspaceDetails().

func SWS_init_context 

func SWS_init_context(ctx *SWSContext, src, dst *SWSFilter) bool

Initialize the swscaler context sws_context.

func SWS_is_supported_input 

func SWS_is_supported_input(pix_fmt AVPixelFormat) bool

Return true if pix_fmt is a supported input format

func SWS_is_supported_output 

func SWS_is_supported_output(pix_fmt AVPixelFormat) bool

Return true if pix_fmt is a supported output format

func SWS_license 

func SWS_license() string

Return the swr license.

func SWS_receive_slice 

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

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

func SWS_receive_slice_alignment 

func SWS_receive_slice_alignment(ctx *SWSContext) uint

Get the alignment required for slices.

func SWS_scale 

func SWS_scale(ctx *SWSContext, src_slice **uint8, src_stride *int, src_slice_y, src_slice_height int, dst **uint8, dst_stride *int) int

Scale the image slice in srcSlice and put the resulting scaled slice in the image in dst.

func SWS_scale_frame 

func SWS_scale_frame(ctx *SWSContext, src, dst *AVFrame) error

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

func SWS_send_slice 

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

Indicate that a horizontal slice of input data is available in the source frame previously provided to sws_frame_start

func SWS_version 

func SWS_version() uint

Return the LIBSWSCALE_VERSION_INT constant.

Types

type AVAppToDevMessageType 

type AVAppToDevMessageType C.enum_AVAppToDevMessageType
const (
	// Dummy message.
	AV_APP_TO_DEV_NONE AVAppToDevMessageType = C.AV_APP_TO_DEV_NONE
	// Window size change message.
	// data: AVDeviceRect: new window size.
	AV_APP_TO_DEV_WINDOW_SIZE AVAppToDevMessageType = C.AV_APP_TO_DEV_WINDOW_SIZE
	// Repaint request message.
	// data: AVDeviceRect: area required to be repainted, or NULL if whole area is required to be repainted.
	AV_APP_TO_DEV_WINDOW_REPAINT AVAppToDevMessageType = C.AV_APP_TO_DEV_WINDOW_REPAINT
	// Message sent when device is paused.
	// data: NULL
	AV_APP_TO_DEV_PAUSE AVAppToDevMessageType = C.AV_APP_TO_DEV_PAUSE
	// Message sent when device is unpaused.
	// data: NULL
	AV_APP_TO_DEV_PLAY AVAppToDevMessageType = C.AV_APP_TO_DEV_PLAY
	// Message sent when device play/pause is toggled.
	// data: NULL
	AV_APP_TO_DEV_TOGGLE_PAUSE AVAppToDevMessageType = C.AV_APP_TO_DEV_TOGGLE_PAUSE
	// Volume control message.
	// data: double: new volume with range of 0.0 - 1.0.
	AV_APP_TO_DEV_SET_VOLUME AVAppToDevMessageType = C.AV_APP_TO_DEV_SET_VOLUME
	// Mute control messages.
	// data: NULL.
	AV_APP_TO_DEV_MUTE        AVAppToDevMessageType = C.AV_APP_TO_DEV_MUTE
	AV_APP_TO_DEV_UNMUTE      AVAppToDevMessageType = C.AV_APP_TO_DEV_UNMUTE
	AV_APP_TO_DEV_TOGGLE_MUTE AVAppToDevMessageType = C.AV_APP_TO_DEV_TOGGLE_MUTE
	// Get volume/mute messages.
	// Force the device to send AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED or AV_DEV_TO_APP_MUTE_STATE_CHANGED command respectively.
	// data: NULL.
	AV_APP_TO_DEV_GET_VOLUME AVAppToDevMessageType = C.AV_APP_TO_DEV_GET_VOLUME
	AV_APP_TO_DEV_GET_MUTE   AVAppToDevMessageType = C.AV_APP_TO_DEV_GET_MUTE
)

type AVChannel 

type AVChannel C.enum_AVChannel
const (
	AV_CHAN_NONE                  AVChannel = C.AV_CHAN_NONE
	AV_CHAN_FRONT_LEFT            AVChannel = C.AV_CHAN_FRONT_LEFT
	AV_CHAN_FRONT_RIGHT           AVChannel = C.AV_CHAN_FRONT_RIGHT
	AV_CHAN_FRONT_CENTER          AVChannel = C.AV_CHAN_FRONT_CENTER
	AV_CHAN_LOW_FREQUENCY         AVChannel = C.AV_CHAN_LOW_FREQUENCY
	AV_CHAN_BACK_LEFT             AVChannel = C.AV_CHAN_BACK_LEFT
	AV_CHAN_BACK_RIGHT            AVChannel = C.AV_CHAN_BACK_RIGHT
	AV_CHAN_FRONT_LEFT_OF_CENTER  AVChannel = C.AV_CHAN_FRONT_LEFT_OF_CENTER
	AV_CHAN_FRONT_RIGHT_OF_CENTER AVChannel = C.AV_CHAN_FRONT_RIGHT_OF_CENTER
	AV_CHAN_BACK_CENTER           AVChannel = C.AV_CHAN_BACK_CENTER
	AV_CHAN_SIDE_LEFT             AVChannel = C.AV_CHAN_SIDE_LEFT
	AV_CHAN_SIDE_RIGHT            AVChannel = C.AV_CHAN_SIDE_RIGHT
	AV_CHAN_TOP_CENTER            AVChannel = C.AV_CHAN_TOP_CENTER
	AV_CHAN_TOP_FRONT_LEFT        AVChannel = C.AV_CHAN_TOP_FRONT_LEFT
	AV_CHAN_TOP_FRONT_CENTER      AVChannel = C.AV_CHAN_TOP_FRONT_CENTER
	AV_CHAN_TOP_FRONT_RIGHT       AVChannel = C.AV_CHAN_TOP_FRONT_RIGHT
	AV_CHAN_TOP_BACK_LEFT         AVChannel = C.AV_CHAN_TOP_BACK_LEFT
	AV_CHAN_TOP_BACK_CENTER       AVChannel = C.AV_CHAN_TOP_BACK_CENTER
	AV_CHAN_TOP_BACK_RIGHT        AVChannel = C.AV_CHAN_TOP_BACK_RIGHT
	AV_CHAN_STEREO_LEFT           AVChannel = C.AV_CHAN_STEREO_LEFT
	AV_CHAN_STEREO_RIGHT          AVChannel = C.AV_CHAN_STEREO_RIGHT
	AV_CHAN_WIDE_LEFT             AVChannel = C.AV_CHAN_WIDE_LEFT
	AV_CHAN_WIDE_RIGHT            AVChannel = C.AV_CHAN_WIDE_RIGHT
	AV_CHAN_SURROUND_DIRECT_LEFT  AVChannel = C.AV_CHAN_SURROUND_DIRECT_LEFT
	AV_CHAN_SURROUND_DIRECT_RIGHT AVChannel = C.AV_CHAN_SURROUND_DIRECT_RIGHT
	AV_CHAN_LOW_FREQUENCY_2       AVChannel = C.AV_CHAN_LOW_FREQUENCY_2
	AV_CHAN_TOP_SIDE_LEFT         AVChannel = C.AV_CHAN_TOP_SIDE_LEFT
	AV_CHAN_TOP_SIDE_RIGHT        AVChannel = C.AV_CHAN_TOP_SIDE_RIGHT
	AV_CHAN_BOTTOM_FRONT_CENTER   AVChannel = C.AV_CHAN_BOTTOM_FRONT_CENTER
	AV_CHAN_BOTTOM_FRONT_LEFT     AVChannel = C.AV_CHAN_BOTTOM_FRONT_LEFT
	AV_CHAN_BOTTOM_FRONT_RIGHT    AVChannel = C.AV_CHAN_BOTTOM_FRONT_RIGHT
	AV_CHAN_UNUSED                AVChannel = C.AV_CHAN_UNUSED
	AV_CHAN_UNKNOWN               AVChannel = C.AV_CHAN_UNKNOWN
	AV_CHAN_AMBISONIC_BASE        AVChannel = C.AV_CHAN_AMBISONIC_BASE
	AV_CHAN_AMBISONIC_END         AVChannel = C.AV_CHAN_AMBISONIC_END
)

func AVUtil_av_channel_from_string 

func AVUtil_av_channel_from_string(name string) AVChannel

This is the inverse function of av_channel_name.

func AVUtil_av_channel_layout_channel_from_index 

func AVUtil_av_channel_layout_channel_from_index(ch_layout *AVChannelLayout, index int) AVChannel

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

func (AVChannel) String 

func (v AVChannel) String() string

type AVChannelCustom 

type AVChannelCustom C.struct_AVChannelCustom

type AVChannelLayout 

type AVChannelLayout C.struct_AVChannelLayout

func AVUtil_av_channel_layout_standard 

func AVUtil_av_channel_layout_standard(iterator *uintptr) *AVChannelLayout

Iterate over all standard channel layouts.

func (AVChannelLayout) String 

func (l AVChannelLayout) String() string

type AVChannelOrder 

type AVChannelOrder C.enum_AVChannelOrder
const (
	AV_CHANNEL_ORDER_UNSPEC    AVChannelOrder = C.AV_CHANNEL_ORDER_UNSPEC
	AV_CHANNEL_ORDER_NATIVE    AVChannelOrder = C.AV_CHANNEL_ORDER_NATIVE
	AV_CHANNEL_ORDER_CUSTOM    AVChannelOrder = C.AV_CHANNEL_ORDER_CUSTOM
	AV_CHANNEL_ORDER_AMBISONIC AVChannelOrder = C.AV_CHANNEL_ORDER_AMBISONIC
)

func (AVChannelOrder) String 

func (v AVChannelOrder) String() string

type AVClass 

type AVClass C.struct_AVClass

func AVCodec_get_class 

func AVCodec_get_class() *AVClass

Get the AVClass for AVCodecContext.

func AVCodec_get_subtitle_rect_class 

func AVCodec_get_subtitle_rect_class() *AVClass

Get the AVClass for AVSubtitleRect.

func AVFormat_avformat_get_class 

func AVFormat_avformat_get_class() *AVClass

func AVFormat_avstream_getclass 

func AVFormat_avstream_getclass() *AVClass

func SWS_get_class 

func SWS_get_class() *AVClass

Get the AVClass for swsContext.

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 (*AVCodec) AVCodec_is_decoder 

func (codec *AVCodec) AVCodec_is_decoder() bool

Return true if codec is a decoder, false otherwise.

func (*AVCodec) AVCodec_is_encoder 

func (codec *AVCodec) AVCodec_is_encoder() bool

Return true if codec is an encoder, false otherwise.

func (*AVCodec) Cap 

func (c *AVCodec) Cap() AVCodecCap

func (*AVCodec) ChannelLayouts 

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

func (*AVCodec) Description 

func (c *AVCodec) Description() string

func (*AVCodec) ID 

func (c *AVCodec) ID() AVCodecID

func (*AVCodec) MediaType 

func (c *AVCodec) MediaType() AVMediaType

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) SampleRates 

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

func (*AVCodec) String 

func (c *AVCodec) String() string

func (*AVCodec) WrapperName 

func (c *AVCodec) WrapperName() string

type AVCodecCap 

type AVCodecCap C.int
const (
	AV_CODEC_CAP_NONE             AVCodecCap = 0
	AV_CODEC_CAP_DRAW_HORIZ_BAND  AVCodecCap = C.AV_CODEC_CAP_DRAW_HORIZ_BAND  // Decoder can use draw_horiz_band callback
	AV_CODEC_CAP_DR1              AVCodecCap = C.AV_CODEC_CAP_DR1              // Codec uses get_buffer() for allocating buffers and supports custom allocators
	AV_CODEC_CAP_DELAY            AVCodecCap = C.AV_CODEC_CAP_DELAY            // Encoder or decoder requires flushing with NULL input at the end in order to give the complete and correct output
	AV_CODEC_CAP_SMALL_LAST_FRAME AVCodecCap = C.AV_CODEC_CAP_SMALL_LAST_FRAME // Codec can be fed a final frame with a smaller size
	AV_CODEC_CAP_SUBFRAMES        AVCodecCap = C.AV_CODEC_CAP_SUBFRAMES        // Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time, demuxers which do not do are connected to a parser to split what they return into proper frames
	AV_CODEC_CAP_EXPERIMENTAL     AVCodecCap = C.AV_CODEC_CAP_EXPERIMENTAL     // Codec is experimental and is thus avoided in favor of non experimental encoders
	AV_CODEC_CAP_CHANNEL_CONF     AVCodecCap = C.AV_CODEC_CAP_CHANNEL_CONF     // Codec should fill in channel configuration and samplerate instead of container
	AV_CODEC_CAP_FRAME_THREADS    AVCodecCap = C.AV_CODEC_CAP_FRAME_THREADS    // Codec supports frame-level multithreading
	AV_CODEC_CAP_SLICE_THREADS    AVCodecCap = C.AV_CODEC_CAP_SLICE_THREADS    // Codec supports slice-based (or partition-based) multithreading
	AV_CODEC_CAP_PARAM_CHANGE     AVCodecCap = C.AV_CODEC_CAP_PARAM_CHANGE     // Codec supports changed parameters at any point
	//	AV_CODEC_CAP_AUTO_THREADS             AVCodecCap = C.AV_CODEC_CAP_AUTO_THREADS        // Codec supports avctx->thread_count == 0 (auto)
	AV_CODEC_CAP_VARIABLE_FRAME_SIZE      AVCodecCap = C.AV_CODEC_CAP_VARIABLE_FRAME_SIZE // Audio encoder supports receiving a different number of samples in each call
	AV_CODEC_CAP_AVOID_PROBING            AVCodecCap = C.AV_CODEC_CAP_AVOID_PROBING       // Decoder is not a preferred choice for probing
	AV_CODEC_CAP_HARDWARE                 AVCodecCap = C.AV_CODEC_CAP_HARDWARE            // Codec is backed by a hardware implementation
	AV_CODEC_CAP_HYBRID                   AVCodecCap = C.AV_CODEC_CAP_HYBRID              // Codec is potentially backed by a hardware implementation, but not necessarily
	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 //  This encoder can be flushed using avcodec_flush_buffers()
	//AV_CODEC_CAP_ENCODER_RECON_FRAME      AVCodecCap = C.AV_CODEC_CAP_ENCODER_RECON_FRAME // The encoder is able to output reconstructed frame data
	AV_CODEC_CAP_MAX = AV_CODEC_CAP_ENCODER_FLUSH
)

func (AVCodecCap) FlagString 

func (v AVCodecCap) FlagString() string

func (AVCodecCap) String 

func (v AVCodecCap) String() string

type AVCodecContext 

type AVCodecContext C.struct_AVCodecContext

func AVCodec_alloc_context3 

func AVCodec_alloc_context3(codec *AVCodec) *AVCodecContext

Allocate an AVCodecContext and set its fields to default values.

func (*AVCodecContext) BitRate 

func (c *AVCodecContext) BitRate() int64

func (*AVCodecContext) BitRateTolerance 

func (c *AVCodecContext) BitRateTolerance() int

func (*AVCodecContext) ChannelLayout added in v1.6.1 

func (c *AVCodecContext) ChannelLayout() AVChannelLayout

func (*AVCodecContext) Codec 

func (c *AVCodecContext) Codec() *AVCodec

func (*AVCodecContext) CodecID 

func (c *AVCodecContext) CodecID() AVCodecID

func (*AVCodecContext) CodecType 

func (c *AVCodecContext) CodecType() AVMediaType

func (*AVCodecContext) CodedHeight 

func (c *AVCodecContext) CodedHeight() int

func (*AVCodecContext) CodedWidth 

func (c *AVCodecContext) CodedWidth() int

func (*AVCodecContext) CompressionLevel 

func (c *AVCodecContext) CompressionLevel() int

func (*AVCodecContext) GlobalQuality 

func (c *AVCodecContext) GlobalQuality() int

func (*AVCodecContext) GopSize 

func (c *AVCodecContext) GopSize() int

func (*AVCodecContext) Height 

func (c *AVCodecContext) Height() int

func (*AVCodecContext) PixelFormat 

func (c *AVCodecContext) PixelFormat() AVPixelFormat

func (*AVCodecContext) SampleFormat 

func (c *AVCodecContext) SampleFormat() AVSampleFormat

func (*AVCodecContext) String 

func (codec *AVCodecContext) String() string

func (*AVCodecContext) TimeBase 

func (c *AVCodecContext) TimeBase() AVRational

func (*AVCodecContext) Width 

func (c *AVCodecContext) Width() int

type AVCodecID 

type AVCodecID C.enum_AVCodecID
const (
	AV_CODEC_ID_NONE AVCodecID = 0
)

type AVCodecParameters 

type AVCodecParameters C.struct_AVCodecParameters

func (*AVCodecParameters) BitRate 

func (c *AVCodecParameters) BitRate() int64

func (*AVCodecParameters) CodecID 

func (c *AVCodecParameters) CodecID() AVCodecID

func (*AVCodecParameters) CodecType 

func (c *AVCodecParameters) CodecType() AVMediaType

func (*AVCodecParameters) Height 

func (c *AVCodecParameters) Height() int

func (*AVCodecParameters) SampleRate 

func (c *AVCodecParameters) SampleRate() int

func (*AVCodecParameters) String 

func (codec *AVCodecParameters) String() string

func (*AVCodecParameters) Width 

func (c *AVCodecParameters) Width() int

type AVContextFlags 

type AVContextFlags C.int
const (
	AVFMTCTX_NONE       AVContextFlags = 0
	AVFMTCTX_NOHEADER   AVContextFlags = C.AVFMTCTX_NOHEADER   // signal that no header is present (streams are added dynamically)
	AVFMTCTX_UNSEEKABLE AVContextFlags = C.AVFMTCTX_UNSEEKABLE // signal that the stream is definitely not seekable
)

type AVDevToAppMessageType 

type AVDevToAppMessageType C.enum_AVDevToAppMessageType

type AVDictionary 

type AVDictionary C.struct_AVDictionary

func AVUtil_av_dict_delete_ptr 

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

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

func AVUtil_av_dict_set_ptr 

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

Set the given entry, overwriting an existing entry. If the dict pointer is nil, then allocate a new dictionary. Return the dictionary (newly created or not)

func (*AVDictionary) String 

func (d *AVDictionary) String() string

type AVDictionaryEntry 

type AVDictionaryEntry C.struct_AVDictionaryEntry

func AVUtil_av_dict_entries 

func AVUtil_av_dict_entries(dict *AVDictionary) []*AVDictionaryEntry

Get the entries for the dictionary.

func AVUtil_av_dict_get 

func AVUtil_av_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) String 

func (e *AVDictionaryEntry) String() string

func (*AVDictionaryEntry) Value 

func (e *AVDictionaryEntry) Value() string

Return dictionary entry value

type AVDictionaryFlag 

type AVDictionaryFlag int
const (
	AV_DICT_MATCH_CASE      AVDictionaryFlag = C.AV_DICT_MATCH_CASE
	AV_DICT_IGNORE_SUFFIX   AVDictionaryFlag = C.AV_DICT_IGNORE_SUFFIX
	AV_DICT_DONT_STRDUP_KEY AVDictionaryFlag = C.AV_DICT_DONT_STRDUP_KEY
	AV_DICT_DONT_STRDUP_VAL AVDictionaryFlag = C.AV_DICT_DONT_STRDUP_VAL
	AV_DICT_DONT_OVERWRITE  AVDictionaryFlag = C.AV_DICT_DONT_OVERWRITE
	AV_DICT_APPEND          AVDictionaryFlag = C.AV_DICT_APPEND
	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 // Stream for hearing impaired audiences
	AV_DISPOSITION_VISUAL_IMPAIRED  AVDisposition = C.AV_DISPOSITION_VISUAL_IMPAIRED  // Stream for visual impaired audiences
	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_NONE             AVDisposition = 0
	AV_DISPOSITION_MAX                            = AV_DISPOSITION_STILL_IMAGE
)

func (AVDisposition) FlagString 

func (v AVDisposition) FlagString() string

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 AVFormat 

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

func (AVFormat) FlagString 

func (f AVFormat) FlagString() string

func (AVFormat) Is 

func (v AVFormat) Is(f AVFormat) bool

func (AVFormat) String 

func (f AVFormat) String() string

type AVFormatContext 

type AVFormatContext C.struct_AVFormatContext

func AVFormat_alloc_context 

func AVFormat_alloc_context() *AVFormatContext

func AVFormat_alloc_output_context2 

func AVFormat_alloc_output_context2(oformat *AVOutputFormat, format string, filename string) (*AVFormatContext, error)

Allocate an AVFormatContext for an output format.

func AVFormat_open_input 

func AVFormat_open_input(url string, input_fmt *AVInputFormat, options **AVDictionary) (*AVFormatContext, error)

Open an input stream and read the header.

func (*AVFormatContext) AVDevice_app_to_dev_control_message 

func (ctx *AVFormatContext) AVDevice_app_to_dev_control_message(typ AVAppToDevMessageType, data []byte) int

Send control message from application to device.

func (*AVFormatContext) AVDevice_dev_to_app_control_message 

func (ctx *AVFormatContext) AVDevice_dev_to_app_control_message(typ AVDevToAppMessageType, data []byte) int

Send control message from device to application.

func (*AVFormatContext) AudioCodecID 

func (ctx *AVFormatContext) AudioCodecID() AVCodecID

func (*AVFormatContext) BitRate 

func (ctx *AVFormatContext) BitRate() int64

func (*AVFormatContext) Class 

func (ctx *AVFormatContext) Class() *AVClass

func (*AVFormatContext) ContextFlags 

func (ctx *AVFormatContext) ContextFlags() AVContextFlags

func (*AVFormatContext) DataCodecID 

func (ctx *AVFormatContext) DataCodecID() AVCodecID

func (*AVFormatContext) Duration 

func (ctx *AVFormatContext) Duration() int64

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) MaxDelay 

func (ctx *AVFormatContext) MaxDelay() int

func (*AVFormatContext) Metadata 

func (ctx *AVFormatContext) Metadata() **AVDictionary

func (*AVFormatContext) NumStreams 

func (ctx *AVFormatContext) NumStreams() uint

func (*AVFormatContext) Output 

func (ctx *AVFormatContext) Output() *AVOutputFormat

func (*AVFormatContext) PB 

func (ctx *AVFormatContext) PB() *AVIOContext

func (*AVFormatContext) PacketSize 

func (ctx *AVFormatContext) PacketSize() uint

func (*AVFormatContext) ProbeSize 

func (ctx *AVFormatContext) ProbeSize() int64

func (*AVFormatContext) SetPB 

func (ctx *AVFormatContext) SetPB(pb *AVIOContext)

func (*AVFormatContext) StartTime 

func (ctx *AVFormatContext) StartTime() int64

func (*AVFormatContext) Streams 

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

func (*AVFormatContext) String 

func (ctx *AVFormatContext) String() string

func (*AVFormatContext) SubtitleCodecID 

func (ctx *AVFormatContext) SubtitleCodecID() AVCodecID

func (*AVFormatContext) Url 

func (ctx *AVFormatContext) Url() string

func (*AVFormatContext) VideoCodecID 

func (ctx *AVFormatContext) VideoCodecID() AVCodecID

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_SHORTEST        AVFormatFlag = C.AVFMT_FLAG_SHORTEST        ///< Stop muxing when the shortest stream stops.
	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) 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) ChannelLayout 

func (f *AVFrame) ChannelLayout() AVChannelLayout

func (*AVFrame) Channels 

func (f *AVFrame) Channels() int

func (*AVFrame) Data 

func (f *AVFrame) Data(ch int) *byte

func (*AVFrame) Height 

func (f *AVFrame) Height() int

func (*AVFrame) IsInterlaced 

func (f *AVFrame) IsInterlaced() bool

func (*AVFrame) IsKeyFrame 

func (f *AVFrame) IsKeyFrame() bool

func (*AVFrame) IsPaletteHasChanged 

func (f *AVFrame) IsPaletteHasChanged() bool

func (*AVFrame) IsPlanar 

func (f *AVFrame) IsPlanar() bool

func (*AVFrame) IsTopFieldFirst 

func (f *AVFrame) IsTopFieldFirst() bool

func (*AVFrame) LineSize 

func (f *AVFrame) LineSize(ch int) int

func (*AVFrame) NumSamples 

func (f *AVFrame) NumSamples() int

func (*AVFrame) PacketDts 

func (f *AVFrame) PacketDts() int64

func (*AVFrame) PictType 

func (f *AVFrame) PictType() AVPictureType

func (*AVFrame) PixelAspectRatio 

func (f *AVFrame) PixelAspectRatio() AVRational

func (*AVFrame) PixelFormat 

func (f *AVFrame) PixelFormat() AVPixelFormat

func (*AVFrame) Pts 

func (f *AVFrame) Pts() int64

func (*AVFrame) Quality 

func (f *AVFrame) Quality() int

func (*AVFrame) SampleFormat 

func (f *AVFrame) SampleFormat() AVSampleFormat

func (*AVFrame) SampleRate 

func (f *AVFrame) SampleRate() int

func (*AVFrame) String 

func (f *AVFrame) String() string

func (*AVFrame) Width 

func (f *AVFrame) Width() int

type AVIOContext 

type AVIOContext C.struct_AVIOContext

func AVFormat_avio_open 

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

func (*AVIOContext) Buffer 

func (ctx *AVIOContext) Buffer() []byte

func (*AVIOContext) BufferSize 

func (ctx *AVIOContext) BufferSize() int

func (*AVIOContext) Class 

func (ctx *AVIOContext) Class() *AVClass

func (*AVIOContext) Error 

func (ctx *AVIOContext) Error() error

func (*AVIOContext) IsDirect 

func (ctx *AVIOContext) IsDirect() bool

func (*AVIOContext) IsEOF 

func (ctx *AVIOContext) IsEOF() bool

func (*AVIOContext) IsSeekable 

func (ctx *AVIOContext) IsSeekable() bool

func (*AVIOContext) IsWriteable 

func (ctx *AVIOContext) IsWriteable() bool

func (*AVIOContext) Pos 

func (ctx *AVIOContext) Pos() int64

func (*AVIOContext) String 

func (ctx *AVIOContext) String() string

type AVIOFlag 

type AVIOFlag C.int
const (
	AVIO_FLAG_NONE       AVIOFlag = 0
	AVIO_FLAG_READ       AVIOFlag = C.AVIO_FLAG_READ
	AVIO_FLAG_WRITE      AVIOFlag = C.AVIO_FLAG_WRITE
	AVIO_FLAG_READ_WRITE AVIOFlag = C.AVIO_FLAG_READ_WRITE
)

type AVInputFormat 

type AVInputFormat C.struct_AVInputFormat

func AVDevice_av_input_audio_device_first 

func AVDevice_av_input_audio_device_first() *AVInputFormat

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

func AVDevice_av_input_video_device_first 

func AVDevice_av_input_video_device_first() *AVInputFormat

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

func AVFormat_av_demuxer_iterate 

func AVFormat_av_demuxer_iterate(opaque *uintptr) *AVInputFormat

func AVFormat_av_find_input_format 

func AVFormat_av_find_input_format(short_name string) *AVInputFormat

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

func (*AVInputFormat) AVDevice_av_input_audio_device_next 

func (ctx *AVInputFormat) AVDevice_av_input_audio_device_next() *AVInputFormat

Return the next registered audio input device.

func (*AVInputFormat) AVDevice_av_input_video_device_next 

func (ctx *AVInputFormat) AVDevice_av_input_video_device_next() *AVInputFormat

Return the next registered video input device.

func (*AVInputFormat) Description 

func (this *AVInputFormat) Description() string

func (*AVInputFormat) Ext 

func (this *AVInputFormat) Ext() string

func (*AVInputFormat) Format 

func (this *AVInputFormat) Format() AVFormat

func (*AVInputFormat) MimeType 

func (this *AVInputFormat) MimeType() string

func (*AVInputFormat) Name 

func (this *AVInputFormat) Name() string

func (*AVInputFormat) String 

func (this *AVInputFormat) String() string

type AVLogCallback 

type AVLogCallback func(AVLogLevel, string, uintptr)

type AVLogLevel 

type AVLogLevel C.int
const (
	AV_LOG_QUIET   AVLogLevel = C.AV_LOG_QUIET
	AV_LOG_PANIC   AVLogLevel = C.AV_LOG_PANIC
	AV_LOG_FATAL   AVLogLevel = C.AV_LOG_FATAL
	AV_LOG_ERROR   AVLogLevel = C.AV_LOG_ERROR
	AV_LOG_WARNING AVLogLevel = C.AV_LOG_WARNING
	AV_LOG_INFO    AVLogLevel = C.AV_LOG_INFO
	AV_LOG_VERBOSE AVLogLevel = C.AV_LOG_VERBOSE
	AV_LOG_DEBUG   AVLogLevel = C.AV_LOG_DEBUG
	AV_LOG_TRACE   AVLogLevel = C.AV_LOG_TRACE
)

func AVUtil_av_log_get_level 

func AVUtil_av_log_get_level() AVLogLevel

Get the current log level.

func (AVLogLevel) String 

func (v AVLogLevel) String() string

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) String 

func (v AVMediaType) String() string

type AVOutputFormat 

type AVOutputFormat C.struct_AVOutputFormat

func AVDevice_av_output_audio_device_first 

func AVDevice_av_output_audio_device_first() *AVOutputFormat

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

func AVDevice_av_output_video_device_first 

func AVDevice_av_output_video_device_first() *AVOutputFormat

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

func AVFormat_av_muxer_iterate 

func AVFormat_av_muxer_iterate(opaque *uintptr) *AVOutputFormat

func (*AVOutputFormat) AVDevice_av_output_audio_device_next 

func (ctx *AVOutputFormat) AVDevice_av_output_audio_device_next() *AVOutputFormat

Return the next registered audio output device.

func (*AVOutputFormat) AVDevice_av_output_video_device_next 

func (ctx *AVOutputFormat) AVDevice_av_output_video_device_next() *AVOutputFormat

Return the next registered video output device.

func (*AVOutputFormat) DefaultAudioCodec 

func (this *AVOutputFormat) DefaultAudioCodec() AVCodecID

func (*AVOutputFormat) DefaultSubtitleCodec 

func (this *AVOutputFormat) DefaultSubtitleCodec() AVCodecID

func (*AVOutputFormat) DefaultVideoCodec 

func (this *AVOutputFormat) DefaultVideoCodec() AVCodecID

func (*AVOutputFormat) Description 

func (this *AVOutputFormat) Description() string

func (*AVOutputFormat) Ext 

func (this *AVOutputFormat) Ext() string

func (*AVOutputFormat) Format 

func (this *AVOutputFormat) Format() AVFormat

func (*AVOutputFormat) MimeType 

func (this *AVOutputFormat) MimeType() string

func (*AVOutputFormat) Name 

func (this *AVOutputFormat) Name() string

func (*AVOutputFormat) String 

func (this *AVOutputFormat) String() string

type AVPacket 

type AVPacket C.struct_AVPacket

func AVCodec_av_packet_alloc 

func AVCodec_av_packet_alloc() *AVPacket

Allocate an AVPacket and set its fields to default values.

func AVCodec_av_packet_clone 

func AVCodec_av_packet_clone(src *AVPacket) *AVPacket

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

func (*AVPacket) Bytes 

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

Return slice of data from packet

func (*AVPacket) Data 

func (packet *AVPacket) Data() *byte

func (*AVPacket) Dts 

func (packet *AVPacket) Dts() int64

func (*AVPacket) Duration 

func (packet *AVPacket) Duration() int64

func (*AVPacket) Flags 

func (packet *AVPacket) Flags() AVPacketFlag

func (*AVPacket) Pos 

func (packet *AVPacket) Pos() int64

func (*AVPacket) Pts 

func (packet *AVPacket) Pts() int64

func (*AVPacket) Size 

func (packet *AVPacket) Size() int

func (*AVPacket) StreamIndex 

func (packet *AVPacket) StreamIndex() int

func (*AVPacket) String 

func (packet *AVPacket) String() string

func (*AVPacket) TimeBase 

func (packet *AVPacket) TimeBase() AVRational

type AVPacketFlag 

type AVPacketFlag C.int
const (
	AV_PKT_FLAG_NONE       AVPacketFlag = 0
	AV_PKT_FLAG_KEY        AVPacketFlag = C.AV_PKT_FLAG_KEY        ///< The packet contains a keyframe
	AV_PKT_FLAG_CORRUPT    AVPacketFlag = C.AV_PKT_FLAG_CORRUPT    ///< The packet content is corrupted
	AV_PKT_FLAG_DISCARD    AVPacketFlag = C.AV_PKT_FLAG_DISCARD    // Flag is used to discard packets which are required to maintain valid decoder state
	AV_PKT_FLAG_TRUSTED    AVPacketFlag = C.AV_PKT_FLAG_TRUSTED    // The packet comes from a trusted source.
	AV_PKT_FLAG_DISPOSABLE AVPacketFlag = C.AV_PKT_FLAG_DISPOSABLE // The packet can be discarded if it is not stored
	AV_PKT_FLAG_MAX                     = AV_PKT_FLAG_DISPOSABLE
)

func (AVPacketFlag) FlagString 

func (v AVPacketFlag) FlagString() string

func (AVPacketFlag) String 

func (v AVPacketFlag) String() string

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) String 

func (v AVPictureType) String() string

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

)

func (AVPixelFormat) String 

func (v AVPixelFormat) String() string

type AVProfile 

type AVProfile C.struct_AVProfile

func (AVProfile) String 

func (p AVProfile) String() string

type AVRational 

type AVRational C.struct_AVRational

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) Num 

func (r AVRational) Num() int

Numerator

func (AVRational) String 

func (r AVRational) String() string

type AVRounding 

type AVRounding C.enum_AVRounding

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 AVUtil_av_get_alt_sample_fmt 

func AVUtil_av_get_alt_sample_fmt(f AVSampleFormat, planar bool) AVSampleFormat

Return the planar or packed audio corresponding to f. Returns AV_SAMPLE_FMT_NONE on error.

func AVUtil_av_get_packed_sample_fmt 

func AVUtil_av_get_packed_sample_fmt(f AVSampleFormat) AVSampleFormat

Return the packed audio corresponding to f. Returns AV_SAMPLE_FMT_NONE on error.

func AVUtil_av_get_planar_sample_fmt 

func AVUtil_av_get_planar_sample_fmt(f AVSampleFormat) AVSampleFormat

Return the planar audio corresponding to f. Returns AV_SAMPLE_FMT_NONE on error.

func AVUtil_av_get_sample_fmt 

func AVUtil_av_get_sample_fmt(s string) AVSampleFormat

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

func (AVSampleFormat) String 

func (v AVSampleFormat) String() string

type AVStream 

type AVStream C.struct_AVStream

func AVFormat_avformat_new_stream 

func AVFormat_avformat_new_stream(oc *AVFormatContext, c *AVCodec) *AVStream

func (*AVStream) AttachedPic 

func (ctx *AVStream) AttachedPic() AVPacket

func (*AVStream) AverageFrameRate 

func (ctx *AVStream) AverageFrameRate() AVRational

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) Metadata 

func (ctx *AVStream) Metadata() *AVDictionary

func (*AVStream) NumFrames 

func (ctx *AVStream) NumFrames() int64

func (*AVStream) RealFrameRate 

func (ctx *AVStream) RealFrameRate() AVRational

func (*AVStream) SampleAspectRatio 

func (ctx *AVStream) SampleAspectRatio() 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 SWSContext 

type SWSContext C.struct_SwsContext

func SWS_alloc_context 

func SWS_alloc_context() *SWSContext

Allocate an empty SWSContext.

func SWS_get_context 

func SWS_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.

type SWSFilter 

type SWSFilter C.struct_SwsFilter

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.