ffmpeg

package
v1.5.1 Latest Latest
Warning

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

 Go to latest Published: Dec 16, 2022 License: Apache-2.0 Imports: 12 Imported by: 0

Documentation

Overview

Package ffmpeg provides low-level ffmpeg for go

Index

Constants

View Source 
const (
	AV_CH_LAYOUT_NONE              AVChannelLayout = 0
	AV_CH_LAYOUT_MIN                               = AV_CH_FRONT_LEFT
	AV_CH_LAYOUT_MAX                               = AV_CH_STEREO_RIGHT
	AV_CH_LAYOUT_MONO                              = (AV_CH_FRONT_CENTER)
	AV_CH_LAYOUT_STEREO                            = (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT)
	AV_CH_LAYOUT_2POINT1                           = (AV_CH_LAYOUT_STEREO | AV_CH_LOW_FREQUENCY)
	AV_CH_LAYOUT_2_1                               = (AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER)
	AV_CH_LAYOUT_SURROUND                          = (AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER)
	AV_CH_LAYOUT_3POINT1                           = (AV_CH_LAYOUT_SURROUND | AV_CH_LOW_FREQUENCY)
	AV_CH_LAYOUT_4POINT0                           = (AV_CH_LAYOUT_SURROUND | AV_CH_BACK_CENTER)
	AV_CH_LAYOUT_4POINT1                           = (AV_CH_LAYOUT_4POINT0 | AV_CH_LOW_FREQUENCY)
	AV_CH_LAYOUT_2_2                               = (AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT)
	AV_CH_LAYOUT_QUAD                              = (AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)
	AV_CH_LAYOUT_5POINT0                           = (AV_CH_LAYOUT_SURROUND | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT)
	AV_CH_LAYOUT_5POINT1                           = (AV_CH_LAYOUT_5POINT0 | AV_CH_LOW_FREQUENCY)
	AV_CH_LAYOUT_5POINT0_BACK                      = (AV_CH_LAYOUT_SURROUND | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)
	AV_CH_LAYOUT_5POINT1_BACK                      = (AV_CH_LAYOUT_5POINT0_BACK | AV_CH_LOW_FREQUENCY)
	AV_CH_LAYOUT_6POINT0                           = (AV_CH_LAYOUT_5POINT0 | AV_CH_BACK_CENTER)
	AV_CH_LAYOUT_6POINT0_FRONT                     = (AV_CH_LAYOUT_2_2 | AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
	AV_CH_LAYOUT_HEXAGONAL                         = (AV_CH_LAYOUT_5POINT0_BACK | AV_CH_BACK_CENTER)
	AV_CH_LAYOUT_6POINT1                           = (AV_CH_LAYOUT_5POINT1 | AV_CH_BACK_CENTER)
	AV_CH_LAYOUT_6POINT1_BACK                      = (AV_CH_LAYOUT_5POINT1_BACK | AV_CH_BACK_CENTER)
	AV_CH_LAYOUT_6POINT1_FRONT                     = (AV_CH_LAYOUT_6POINT0_FRONT | AV_CH_LOW_FREQUENCY)
	AV_CH_LAYOUT_7POINT0                           = (AV_CH_LAYOUT_5POINT0 | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)
	AV_CH_LAYOUT_7POINT0_FRONT                     = (AV_CH_LAYOUT_5POINT0 | AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
	AV_CH_LAYOUT_7POINT1                           = (AV_CH_LAYOUT_5POINT1 | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)
	AV_CH_LAYOUT_7POINT1_WIDE                      = (AV_CH_LAYOUT_5POINT1 | AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
	AV_CH_LAYOUT_7POINT1_WIDE_BACK                 = (AV_CH_LAYOUT_5POINT1_BACK | AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
	AV_CH_LAYOUT_OCTAGONAL                         = (AV_CH_LAYOUT_5POINT0 | AV_CH_BACK_LEFT | AV_CH_BACK_CENTER | AV_CH_BACK_RIGHT)
	AV_CH_LAYOUT_HEXADECAGONAL                     = (AV_CH_LAYOUT_OCTAGONAL | AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT | AV_CH_TOP_BACK_LEFT | AV_CH_TOP_BACK_RIGHT | AV_CH_TOP_BACK_CENTER | AV_CH_TOP_FRONT_CENTER | AV_CH_TOP_FRONT_LEFT | AV_CH_TOP_FRONT_RIGHT)
	AV_CH_LAYOUT_STEREO_DOWNMIX                    = (AV_CH_STEREO_LEFT | AV_CH_STEREO_RIGHT)
)
View Source 
const (
	AV_CODEC_ID_MIN = AV_CODEC_ID_MPEG1VIDEO
	AV_CODEC_ID_MAX = AV_CODEC_ID_WRAPPED_AVFRAME
)
View Source 
const (
	BUF_SIZE = 1024
)

Variables

This section is empty.

Functions

func AVDumpFormat 

func AVDumpFormat(ctx *AVFormatContext, index int, filename string, is_output bool)

func AVFormatDeinit 

func AVFormatDeinit()

func AVFormatInit 

func AVFormatInit()

Register and Deregister

func AVFormatVersion 

func AVFormatVersion() uint

func AVFree 

func AVFree(ptr unsafe.Pointer)

func AVLogSetCallback 

func AVLogSetCallback(level AVLogLevel, cb AVLogCallback)

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

func AVMalloc 

func AVMalloc(sz int64) unsafe.Pointer

Types

type AVBufferRef 

type AVBufferRef C.AVBufferRef

func (*AVBufferRef) Data 

func (this *AVBufferRef) Data() []byte

func (*AVBufferRef) Size 

func (this *AVBufferRef) Size() int

func (*AVBufferRef) String 

func (this *AVBufferRef) String() string

type AVChannelLayout 

type AVChannelLayout uint64
const (
	AV_CH_FRONT_LEFT            AVChannelLayout = 0x00000001
	AV_CH_FRONT_RIGHT           AVChannelLayout = 0x00000002
	AV_CH_FRONT_CENTER          AVChannelLayout = 0x00000004
	AV_CH_LOW_FREQUENCY         AVChannelLayout = 0x00000008
	AV_CH_BACK_LEFT             AVChannelLayout = 0x00000010
	AV_CH_BACK_RIGHT            AVChannelLayout = 0x00000020
	AV_CH_FRONT_LEFT_OF_CENTER  AVChannelLayout = 0x00000040
	AV_CH_FRONT_RIGHT_OF_CENTER AVChannelLayout = 0x00000080
	AV_CH_BACK_CENTER           AVChannelLayout = 0x00000100
	AV_CH_SIDE_LEFT             AVChannelLayout = 0x00000200
	AV_CH_SIDE_RIGHT            AVChannelLayout = 0x00000400
	AV_CH_TOP_CENTER            AVChannelLayout = 0x00000800
	AV_CH_TOP_FRONT_LEFT        AVChannelLayout = 0x00001000
	AV_CH_TOP_FRONT_CENTER      AVChannelLayout = 0x00002000
	AV_CH_TOP_FRONT_RIGHT       AVChannelLayout = 0x00004000
	AV_CH_TOP_BACK_LEFT         AVChannelLayout = 0x00008000
	AV_CH_TOP_BACK_CENTER       AVChannelLayout = 0x00010000
	AV_CH_TOP_BACK_RIGHT        AVChannelLayout = 0x00020000
	AV_CH_STEREO_LEFT           AVChannelLayout = 0x20000000
	AV_CH_STEREO_RIGHT          AVChannelLayout = 0x40000000
	AV_CH_WIDE_LEFT             AVChannelLayout = 0x0000000080000000
	AV_CH_WIDE_RIGHT            AVChannelLayout = 0x0000000100000000
)

func (AVChannelLayout) FlagString 

func (c AVChannelLayout) FlagString() string

func (AVChannelLayout) String 

func (c AVChannelLayout) String() string

type AVCodec 

type AVCodec C.struct_AVCodec

func AllCodecs 

func AllCodecs() []*AVCodec

AllCodecs returns all registered codecs

func FindCodecById 

func FindCodecById(id AVCodecId) *AVCodec

func FindCodecByName 

func FindCodecByName(name string) *AVCodec

func FindDecoderById 

func FindDecoderById(id AVCodecId) *AVCodec

func FindDecoderByName 

func FindDecoderByName(name string) *AVCodec

func FindEncoderById 

func FindEncoderById(id AVCodecId) *AVCodec

func FindEncoderByName 

func FindEncoderByName(name string) *AVCodec

func (*AVCodec) Capabilities 

func (this *AVCodec) Capabilities() AVCodecCap

func (*AVCodec) Description 

func (this *AVCodec) Description() string

func (*AVCodec) Id 

func (this *AVCodec) Id() AVCodecId

func (*AVCodec) IsDecoder 

func (this *AVCodec) IsDecoder() bool

func (*AVCodec) IsEncoder 

func (this *AVCodec) IsEncoder() bool

func (*AVCodec) Name 

func (this *AVCodec) Name() string

func (*AVCodec) String 

func (this *AVCodec) String() string

func (*AVCodec) Type 

func (this *AVCodec) Type() AVMediaType

func (*AVCodec) WrapperName 

func (this *AVCodec) WrapperName() string

type AVCodecCap 

type AVCodecCap uint32
const (
	AV_CODEC_CAP_DRAW_HORIZ_BAND     AVCodecCap = (1 << 0) // Decoder can use draw_horiz_band callback
	AV_CODEC_CAP_DR1                 AVCodecCap = (1 << 1) // Codec uses get_buffer() for allocating buffers and supports custom allocators
	AV_CODEC_CAP_TRUNCATED           AVCodecCap = (1 << 3)
	AV_CODEC_CAP_DELAY               AVCodecCap = (1 << 5)   // 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 = (1 << 6)   // Codec can be fed a final frame with a smaller size
	AV_CODEC_CAP_SUBFRAMES           AVCodecCap = (1 << 8)   // 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 = (1 << 9)   // Codec is experimental and is thus avoided in favor of non experimental encoders
	AV_CODEC_CAP_CHANNEL_CONF        AVCodecCap = (1 << 10)  // Codec should fill in channel configuration and samplerate instead of container
	AV_CODEC_CAP_FRAME_THREADS       AVCodecCap = (1 << 12)  // Codec supports frame-level multithreading
	AV_CODEC_CAP_SLICE_THREADS       AVCodecCap = (1 << 13)  // Codec supports slice-based (or partition-based) multithreading
	AV_CODEC_CAP_PARAM_CHANGE        AVCodecCap = (1 << 14)  // Codec supports changed parameters at any point
	AV_CODEC_CAP_AUTO_THREADS        AVCodecCap = (1 << 15)  // Codec supports avctx->thread_count == 0 (auto)
	AV_CODEC_CAP_VARIABLE_FRAME_SIZE AVCodecCap = (1 << 16)  // Audio encoder supports receiving a different number of samples in each call
	AV_CODEC_CAP_AVOID_PROBING       AVCodecCap = (1 << 17)  // Decoder is not a preferred choice for probing
	AV_CODEC_CAP_HARDWARE            AVCodecCap = (1 << 18)  // Codec is backed by a hardware implementation
	AV_CODEC_CAP_HYBRID              AVCodecCap = (1 << 19)  // Codec is potentially backed by a hardware implementation, but not necessarily
	AV_CODEC_CAP_INTRA_ONLY          AVCodecCap = 0x40000000 // Codec is intra only
	AV_CODEC_CAP_LOSSLESS            AVCodecCap = 0x80000000 // Codec is lossless
	AV_CODEC_CAP_NONE                AVCodecCap = 0
	AV_CODEC_CAP_MIN                 AVCodecCap = AV_CODEC_CAP_DRAW_HORIZ_BAND
	AV_CODEC_CAP_MAX                 AVCodecCap = AV_CODEC_CAP_LOSSLESS
)

func (AVCodecCap) FlagString 

func (v AVCodecCap) FlagString() string

func (AVCodecCap) String 

func (v AVCodecCap) String() string

type AVCodecContext 

type AVCodecContext C.struct_AVCodecContext

func NewAVCodecContext 

func NewAVCodecContext(codec *AVCodec) *AVCodecContext

NewAVCodecContext allocates an AVCodecContext and set its fields to default values

func (*AVCodecContext) Close 

func (this *AVCodecContext) Close() error

Close a given AVCodecContext and free all the data associated with it, but not the AVCodecContext itself

func (*AVCodecContext) Codec 

func (this *AVCodecContext) Codec() *AVCodec

func (*AVCodecContext) DecodeFrame 

func (this *AVCodecContext) DecodeFrame(frame *AVFrame) error

DecodeFrame does the frame decoding

func (*AVCodecContext) DecodePacket 

func (this *AVCodecContext) DecodePacket(packet *AVPacket) error

DecodePacket does the packet decode

func (*AVCodecContext) Frame 

func (this *AVCodecContext) Frame() int

func (*AVCodecContext) Free 

func (this *AVCodecContext) Free()

Free AVCodecContext

func (*AVCodecContext) Open 

func (this *AVCodecContext) Open(codec *AVCodec, options *AVDictionary) error

Open will initialize the AVCodecContext to use the given AVCodec

func (*AVCodecContext) PixelFormat 

func (this *AVCodecContext) PixelFormat() AVPixelFormat

func (*AVCodecContext) SampleFormat 

func (this *AVCodecContext) SampleFormat() AVSampleFormat

func (*AVCodecContext) String 

func (this *AVCodecContext) String() string

func (*AVCodecContext) Type 

func (this *AVCodecContext) Type() AVMediaType

type AVCodecId 

type AVCodecId C.enum_AVCodecID
const (
	AV_CODEC_ID_NONE AVCodecId = iota
	AV_CODEC_ID_MPEG1VIDEO
	AV_CODEC_ID_MPEG2VIDEO ///< preferred ID for MPEG-1/2 video decoding
	AV_CODEC_ID_H261
	AV_CODEC_ID_H263
	AV_CODEC_ID_RV10
	AV_CODEC_ID_RV20
	AV_CODEC_ID_MJPEG
	AV_CODEC_ID_MJPEGB
	AV_CODEC_ID_LJPEG
	AV_CODEC_ID_SP5X
	AV_CODEC_ID_JPEGLS
	AV_CODEC_ID_MPEG4
	AV_CODEC_ID_RAWVIDEO
	AV_CODEC_ID_MSMPEG4V1
	AV_CODEC_ID_MSMPEG4V2
	AV_CODEC_ID_MSMPEG4V3
	AV_CODEC_ID_WMV1
	AV_CODEC_ID_WMV2
	AV_CODEC_ID_H263P
	AV_CODEC_ID_H263I
	AV_CODEC_ID_FLV1
	AV_CODEC_ID_SVQ1
	AV_CODEC_ID_SVQ3
	AV_CODEC_ID_DVVIDEO
	AV_CODEC_ID_HUFFYUV
	AV_CODEC_ID_CYUV
	AV_CODEC_ID_H264
	AV_CODEC_ID_INDEO3
	AV_CODEC_ID_VP3
	AV_CODEC_ID_THEORA
	AV_CODEC_ID_ASV1
	AV_CODEC_ID_ASV2
	AV_CODEC_ID_FFV1
	AV_CODEC_ID_4XM
	AV_CODEC_ID_VCR1
	AV_CODEC_ID_CLJR
	AV_CODEC_ID_MDEC
	AV_CODEC_ID_ROQ
	AV_CODEC_ID_INTERPLAY_VIDEO
	AV_CODEC_ID_XAN_WC3
	AV_CODEC_ID_XAN_WC4
	AV_CODEC_ID_RPZA
	AV_CODEC_ID_CINEPAK
	AV_CODEC_ID_WS_VQA
	AV_CODEC_ID_MSRLE
	AV_CODEC_ID_MSVIDEO1
	AV_CODEC_ID_IDCIN
	AV_CODEC_ID_8BPS
	AV_CODEC_ID_SMC
	AV_CODEC_ID_FLIC
	AV_CODEC_ID_TRUEMOTION1
	AV_CODEC_ID_VMDVIDEO
	AV_CODEC_ID_MSZH
	AV_CODEC_ID_ZLIB
	AV_CODEC_ID_QTRLE
	AV_CODEC_ID_TSCC
	AV_CODEC_ID_ULTI
	AV_CODEC_ID_QDRAW
	AV_CODEC_ID_VIXL
	AV_CODEC_ID_QPEG
	AV_CODEC_ID_PNG
	AV_CODEC_ID_PPM
	AV_CODEC_ID_PBM
	AV_CODEC_ID_PGM
	AV_CODEC_ID_PGMYUV
	AV_CODEC_ID_PAM
	AV_CODEC_ID_FFVHUFF
	AV_CODEC_ID_RV30
	AV_CODEC_ID_RV40
	AV_CODEC_ID_VC1
	AV_CODEC_ID_WMV3
	AV_CODEC_ID_LOCO
	AV_CODEC_ID_WNV1
	AV_CODEC_ID_AASC
	AV_CODEC_ID_INDEO2
	AV_CODEC_ID_FRAPS
	AV_CODEC_ID_TRUEMOTION2
	AV_CODEC_ID_BMP
	AV_CODEC_ID_CSCD
	AV_CODEC_ID_MMVIDEO
	AV_CODEC_ID_ZMBV
	AV_CODEC_ID_AVS
	AV_CODEC_ID_SMACKVIDEO
	AV_CODEC_ID_NUV
	AV_CODEC_ID_KMVC
	AV_CODEC_ID_FLASHSV
	AV_CODEC_ID_CAVS
	AV_CODEC_ID_JPEG2000
	AV_CODEC_ID_VMNC
	AV_CODEC_ID_VP5
	AV_CODEC_ID_VP6
	AV_CODEC_ID_VP6F
	AV_CODEC_ID_TARGA
	AV_CODEC_ID_DSICINVIDEO
	AV_CODEC_ID_TIERTEXSEQVIDEO
	AV_CODEC_ID_TIFF
	AV_CODEC_ID_GIF
	AV_CODEC_ID_DXA
	AV_CODEC_ID_DNXHD
	AV_CODEC_ID_THP
	AV_CODEC_ID_SGI
	AV_CODEC_ID_C93
	AV_CODEC_ID_BETHSOFTVID
	AV_CODEC_ID_PTX
	AV_CODEC_ID_TXD
	AV_CODEC_ID_VP6A
	AV_CODEC_ID_AMV
	AV_CODEC_ID_VB
	AV_CODEC_ID_PCX
	AV_CODEC_ID_SUNRAST
	AV_CODEC_ID_INDEO4
	AV_CODEC_ID_INDEO5
	AV_CODEC_ID_MIMIC
	AV_CODEC_ID_RL2
	AV_CODEC_ID_ESCAPE124
	AV_CODEC_ID_DIRAC
	AV_CODEC_ID_BFI
	AV_CODEC_ID_CMV
	AV_CODEC_ID_MOTIONPIXELS
	AV_CODEC_ID_TGV
	AV_CODEC_ID_TGQ
	AV_CODEC_ID_TQI
	AV_CODEC_ID_AURA
	AV_CODEC_ID_AURA2
	AV_CODEC_ID_V210X
	AV_CODEC_ID_TMV
	AV_CODEC_ID_V210
	AV_CODEC_ID_DPX
	AV_CODEC_ID_MAD
	AV_CODEC_ID_FRWU
	AV_CODEC_ID_FLASHSV2
	AV_CODEC_ID_CDGRAPHICS
	AV_CODEC_ID_R210
	AV_CODEC_ID_ANM
	AV_CODEC_ID_BINKVIDEO
	AV_CODEC_ID_IFF_ILBM
	AV_CODEC_ID_KGV1
	AV_CODEC_ID_YOP
	AV_CODEC_ID_VP8
	AV_CODEC_ID_PICTOR
	AV_CODEC_ID_ANSI
	AV_CODEC_ID_A64_MULTI
	AV_CODEC_ID_A64_MULTI5
	AV_CODEC_ID_R10K
	AV_CODEC_ID_MXPEG
	AV_CODEC_ID_LAGARITH
	AV_CODEC_ID_PRORES
	AV_CODEC_ID_JV
	AV_CODEC_ID_DFA
	AV_CODEC_ID_WMV3IMAGE
	AV_CODEC_ID_VC1IMAGE
	AV_CODEC_ID_UTVIDEO
	AV_CODEC_ID_BMV_VIDEO
	AV_CODEC_ID_VBLE
	AV_CODEC_ID_DXTORY
	AV_CODEC_ID_V410
	AV_CODEC_ID_XWD
	AV_CODEC_ID_CDXL
	AV_CODEC_ID_XBM
	AV_CODEC_ID_ZEROCODEC
	AV_CODEC_ID_MSS1
	AV_CODEC_ID_MSA1
	AV_CODEC_ID_TSCC2
	AV_CODEC_ID_MTS2
	AV_CODEC_ID_CLLC
	AV_CODEC_ID_MSS2
	AV_CODEC_ID_VP9
	AV_CODEC_ID_AIC
	AV_CODEC_ID_ESCAPE130
	AV_CODEC_ID_G2M
	AV_CODEC_ID_WEBP
	AV_CODEC_ID_HNM4_VIDEO
	AV_CODEC_ID_HEVC
	AV_CODEC_ID_FIC
	AV_CODEC_ID_ALIAS_PIX
	AV_CODEC_ID_BRENDER_PIX
	AV_CODEC_ID_PAF_VIDEO
	AV_CODEC_ID_EXR
	AV_CODEC_ID_VP7
	AV_CODEC_ID_SANM
	AV_CODEC_ID_SGIRLE
	AV_CODEC_ID_MVC1
	AV_CODEC_ID_MVC2
	AV_CODEC_ID_HQX
	AV_CODEC_ID_TDSC
	AV_CODEC_ID_HQ_HQA
	AV_CODEC_ID_HAP
	AV_CODEC_ID_DDS
	AV_CODEC_ID_DXV
	AV_CODEC_ID_SCREENPRESSO
	AV_CODEC_ID_RSCC
	AV_CODEC_ID_AVS2
	AV_CODEC_ID_H265         = AV_CODEC_ID_HEVC
	AV_CODEC_ID_IFF_BYTERUN1 = AV_CODEC_ID_IFF_ILBM
)
const (
	AV_CODEC_ID_Y41P AVCodecId = iota + 0x8000
	AV_CODEC_ID_AVRP
	AV_CODEC_ID_012V
	AV_CODEC_ID_AVUI
	AV_CODEC_ID_AYUV
	AV_CODEC_ID_TARGA_Y216
	AV_CODEC_ID_V308
	AV_CODEC_ID_V408
	AV_CODEC_ID_YUV4
	AV_CODEC_ID_AVRN
	AV_CODEC_ID_CPIA
	AV_CODEC_ID_XFACE
	AV_CODEC_ID_SNOW
	AV_CODEC_ID_SMVJPEG
	AV_CODEC_ID_APNG
	AV_CODEC_ID_DAALA
	AV_CODEC_ID_CFHD
	AV_CODEC_ID_TRUEMOTION2RT
	AV_CODEC_ID_M101
	AV_CODEC_ID_MAGICYUV
	AV_CODEC_ID_SHEERVIDEO
	AV_CODEC_ID_YLC
	AV_CODEC_ID_PSD
	AV_CODEC_ID_PIXLET
	AV_CODEC_ID_SPEEDHQ
	AV_CODEC_ID_FMVC
	AV_CODEC_ID_SCPR
	AV_CODEC_ID_CLEARVIDEO
	AV_CODEC_ID_XPM
	AV_CODEC_ID_AV1
	AV_CODEC_ID_BITPACKED
	AV_CODEC_ID_MSCC
	AV_CODEC_ID_SRGC
	AV_CODEC_ID_SVG
	AV_CODEC_ID_GDV
	AV_CODEC_ID_FITS
	AV_CODEC_ID_IMM4
	AV_CODEC_ID_PROSUMER
	AV_CODEC_ID_MWSC
	AV_CODEC_ID_WCMV
	AV_CODEC_ID_RASC
)
const (
	// Audio Codecs
	AV_CODEC_ID_FIRST_AUDIO           = AV_CODEC_ID_PCM_S16LE
	AV_CODEC_ID_PCM_S16LE   AVCodecId = iota + 0x10000
	AV_CODEC_ID_PCM_S16BE
	AV_CODEC_ID_PCM_U16LE
	AV_CODEC_ID_PCM_U16BE
	AV_CODEC_ID_PCM_S8
	AV_CODEC_ID_PCM_U8
	AV_CODEC_ID_PCM_MULAW
	AV_CODEC_ID_PCM_ALAW
	AV_CODEC_ID_PCM_S32LE
	AV_CODEC_ID_PCM_S32BE
	AV_CODEC_ID_PCM_U32LE
	AV_CODEC_ID_PCM_U32BE
	AV_CODEC_ID_PCM_S24LE
	AV_CODEC_ID_PCM_S24BE
	AV_CODEC_ID_PCM_U24LE
	AV_CODEC_ID_PCM_U24BE
	AV_CODEC_ID_PCM_S24DAUD
	AV_CODEC_ID_PCM_ZORK
	AV_CODEC_ID_PCM_S16LE_PLANAR
	AV_CODEC_ID_PCM_DVD
	AV_CODEC_ID_PCM_F32BE
	AV_CODEC_ID_PCM_F32LE
	AV_CODEC_ID_PCM_F64BE
	AV_CODEC_ID_PCM_F64LE
	AV_CODEC_ID_PCM_BLURAY
	AV_CODEC_ID_PCM_LXF
	AV_CODEC_ID_S302M
	AV_CODEC_ID_PCM_S8_PLANAR
	AV_CODEC_ID_PCM_S24LE_PLANAR
	AV_CODEC_ID_PCM_S32LE_PLANAR
	AV_CODEC_ID_PCM_S16BE_PLANAR
)
const (
	AV_CODEC_ID_PCM_S64LE AVCodecId = iota + 0x10800
	AV_CODEC_ID_PCM_S64BE
	AV_CODEC_ID_PCM_F16LE
	AV_CODEC_ID_PCM_F24LE
	AV_CODEC_ID_PCM_VIDC
)
const (
	AV_CODEC_ID_ADPCM_IMA_QT AVCodecId = iota + 0x11000
	AV_CODEC_ID_ADPCM_IMA_WAV
	AV_CODEC_ID_ADPCM_IMA_DK3
	AV_CODEC_ID_ADPCM_IMA_DK4
	AV_CODEC_ID_ADPCM_IMA_WS
	AV_CODEC_ID_ADPCM_IMA_SMJPEG
	AV_CODEC_ID_ADPCM_MS
	AV_CODEC_ID_ADPCM_4XM
	AV_CODEC_ID_ADPCM_XA
	AV_CODEC_ID_ADPCM_ADX
	AV_CODEC_ID_ADPCM_EA
	AV_CODEC_ID_ADPCM_G726
	AV_CODEC_ID_ADPCM_CT
	AV_CODEC_ID_ADPCM_SWF
	AV_CODEC_ID_ADPCM_YAMAHA
	AV_CODEC_ID_ADPCM_SBPRO_4
	AV_CODEC_ID_ADPCM_SBPRO_3
	AV_CODEC_ID_ADPCM_SBPRO_2
	AV_CODEC_ID_ADPCM_THP
	AV_CODEC_ID_ADPCM_IMA_AMV
	AV_CODEC_ID_ADPCM_EA_R1
	AV_CODEC_ID_ADPCM_EA_R3
	AV_CODEC_ID_ADPCM_EA_R2
	AV_CODEC_ID_ADPCM_IMA_EA_SEAD
	AV_CODEC_ID_ADPCM_IMA_EA_EACS
	AV_CODEC_ID_ADPCM_EA_XAS
	AV_CODEC_ID_ADPCM_EA_MAXIS_XA
	AV_CODEC_ID_ADPCM_IMA_ISS
	AV_CODEC_ID_ADPCM_G722
	AV_CODEC_ID_ADPCM_IMA_APC
	AV_CODEC_ID_ADPCM_VIMA
)
const (
	AV_CODEC_ID_ADPCM_AFC AVCodecId = iota + 0x11800
	AV_CODEC_ID_ADPCM_IMA_OKI
	AV_CODEC_ID_ADPCM_DTK
	AV_CODEC_ID_ADPCM_IMA_RAD
	AV_CODEC_ID_ADPCM_G726LE
	AV_CODEC_ID_ADPCM_THP_LE
	AV_CODEC_ID_ADPCM_PSX
	AV_CODEC_ID_ADPCM_AICA
	AV_CODEC_ID_ADPCM_IMA_DAT4
	AV_CODEC_ID_ADPCM_MTAF
)
const (
	AV_CODEC_ID_AMR_NB AVCodecId = iota + 0x12000
	AV_CODEC_ID_AMR_WB
)
const (
	AV_CODEC_ID_RA_144 AVCodecId = iota + 0x13000
	AV_CODEC_ID_RA_288
)
const (
	AV_CODEC_ID_ROQ_DPCM AVCodecId = iota + 0x14000
	AV_CODEC_ID_INTERPLAY_DPCM
	AV_CODEC_ID_XAN_DPCM
	AV_CODEC_ID_SOL_DPCM
)
const (
	AV_CODEC_ID_SDX2_DPCM AVCodecId = iota + 0x14800
	AV_CODEC_ID_GREMLIN_DPCM
)
const (
	AV_CODEC_ID_MP2 AVCodecId = iota + 0x15000
	AV_CODEC_ID_MP3           ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
	AV_CODEC_ID_AAC
	AV_CODEC_ID_AC3
	AV_CODEC_ID_DTS
	AV_CODEC_ID_VORBIS
	AV_CODEC_ID_DVAUDIO
	AV_CODEC_ID_WMAV1
	AV_CODEC_ID_WMAV2
	AV_CODEC_ID_MACE3
	AV_CODEC_ID_MACE6
	AV_CODEC_ID_VMDAUDIO
	AV_CODEC_ID_FLAC
	AV_CODEC_ID_MP3ADU
	AV_CODEC_ID_MP3ON4
	AV_CODEC_ID_SHORTEN
	AV_CODEC_ID_ALAC
	AV_CODEC_ID_WESTWOOD_SND1
	AV_CODEC_ID_GSM ///< as in Berlin toast format
	AV_CODEC_ID_QDM2
	AV_CODEC_ID_COOK
	AV_CODEC_ID_TRUESPEECH
	AV_CODEC_ID_TTA
	AV_CODEC_ID_SMACKAUDIO
	AV_CODEC_ID_QCELP
	AV_CODEC_ID_WAVPACK
	AV_CODEC_ID_DSICINAUDIO
	AV_CODEC_ID_IMC
	AV_CODEC_ID_MUSEPACK7
	AV_CODEC_ID_MLP
	AV_CODEC_ID_GSM_MS /* as found in WAV */
	AV_CODEC_ID_ATRAC3
	AV_CODEC_ID_APE
	AV_CODEC_ID_NELLYMOSER
	AV_CODEC_ID_MUSEPACK8
	AV_CODEC_ID_SPEEX
	AV_CODEC_ID_WMAVOICE
	AV_CODEC_ID_WMAPRO
	AV_CODEC_ID_WMALOSSLESS
	AV_CODEC_ID_ATRAC3P
	AV_CODEC_ID_EAC3
	AV_CODEC_ID_SIPR
	AV_CODEC_ID_MP1
	AV_CODEC_ID_TWINVQ
	AV_CODEC_ID_TRUEHD
	AV_CODEC_ID_MP4ALS
	AV_CODEC_ID_ATRAC1
	AV_CODEC_ID_BINKAUDIO_RDFT
	AV_CODEC_ID_BINKAUDIO_DCT
	AV_CODEC_ID_AAC_LATM
	AV_CODEC_ID_QDMC
	AV_CODEC_ID_CELT
	AV_CODEC_ID_G723_1
	AV_CODEC_ID_G729
	AV_CODEC_ID_8SVX_EXP
	AV_CODEC_ID_8SVX_FIB
	AV_CODEC_ID_BMV_AUDIO
	AV_CODEC_ID_RALF
	AV_CODEC_ID_IAC
	AV_CODEC_ID_ILBC
	AV_CODEC_ID_OPUS
	AV_CODEC_ID_COMFORT_NOISE
	AV_CODEC_ID_TAK
	AV_CODEC_ID_METASOUND
	AV_CODEC_ID_PAF_AUDIO
	AV_CODEC_ID_ON2AVC
	AV_CODEC_ID_DSS_SP
	AV_CODEC_ID_CODEC2
)
const (
	AV_CODEC_ID_FFWAVESYNTH AVCodecId = iota + 0x15800
	AV_CODEC_ID_SONIC
	AV_CODEC_ID_SONIC_LS
	AV_CODEC_ID_EVRC
	AV_CODEC_ID_SMV
	AV_CODEC_ID_DSD_LSBF
	AV_CODEC_ID_DSD_MSBF
	AV_CODEC_ID_DSD_LSBF_PLANAR
	AV_CODEC_ID_DSD_MSBF_PLANAR
	AV_CODEC_ID_4GV
	AV_CODEC_ID_INTERPLAY_ACM
	AV_CODEC_ID_XMA1
	AV_CODEC_ID_XMA2
	AV_CODEC_ID_DST
	AV_CODEC_ID_ATRAC3AL
	AV_CODEC_ID_ATRAC3PAL
	AV_CODEC_ID_DOLBY_E
	AV_CODEC_ID_APTX
	AV_CODEC_ID_APTX_HD
	AV_CODEC_ID_SBC
	AV_CODEC_ID_ATRAC9
)
const (
	AV_CODEC_ID_FIRST_SUBTITLE           = AV_CODEC_ID_DVD_SUBTITLE
	AV_CODEC_ID_DVD_SUBTITLE   AVCodecId = iota + 0x17000
	AV_CODEC_ID_DVB_SUBTITLE
	AV_CODEC_ID_TEXT ///< raw UTF-8 text
	AV_CODEC_ID_XSUB
	AV_CODEC_ID_SSA
	AV_CODEC_ID_MOV_TEXT
	AV_CODEC_ID_HDMV_PGS_SUBTITLE
	AV_CODEC_ID_DVB_TELETEXT
	AV_CODEC_ID_SRT
)
const (
	AV_CODEC_ID_MICRODVD AVCodecId = iota + 0x17800
	AV_CODEC_ID_EIA_608
	AV_CODEC_ID_JACOSUB
	AV_CODEC_ID_SAMI
	AV_CODEC_ID_REALTEXT
	AV_CODEC_ID_STL
	AV_CODEC_ID_SUBVIEWER1
	AV_CODEC_ID_SUBVIEWER
	AV_CODEC_ID_SUBRIP
	AV_CODEC_ID_WEBVTT
	AV_CODEC_ID_MPL2
	AV_CODEC_ID_VPLAYER
	AV_CODEC_ID_PJS
	AV_CODEC_ID_ASS
	AV_CODEC_ID_HDMV_TEXT_SUBTITLE
	AV_CODEC_ID_TTML
)
const (
	AV_CODEC_ID_FIRST_UNKNOWN           = AV_CODEC_ID_TTF
	AV_CODEC_ID_TTF           AVCodecId = iota + 0x18000
	AV_CODEC_ID_SCTE_35                 ///< Contain timestamp estimated through PCR of program stream.
)
const (
	AV_CODEC_ID_BINTEXT AVCodecId = iota + 0x18800
	AV_CODEC_ID_XBIN
	AV_CODEC_ID_IDF
	AV_CODEC_ID_OTF
	AV_CODEC_ID_SMPTE_KLV
	AV_CODEC_ID_DVD_NAV
	AV_CODEC_ID_TIMED_ID3
	AV_CODEC_ID_BIN_DATA

	AV_CODEC_ID_PROBE           AVCodecId = 0x19000 ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
	AV_CODEC_ID_MPEG2TS         AVCodecId = 0x20000 // _FAKE_ codec to indicate a raw MPEG-2 TS
	AV_CODEC_ID_MPEG4SYSTEMS    AVCodecId = 0x20001 // _FAKE_ codec to indicate a MPEG-4 Systems
	AV_CODEC_ID_FFMETADATA      AVCodecId = 0x21000 // Dummy codec for streams containing only metadata information.
	AV_CODEC_ID_WRAPPED_AVFRAME AVCodecId = 0x21001 // Passthrough codec, AVFrames wrapped in AVPacket
)

func (AVCodecId) String 

func (v AVCodecId) String() string

type AVCodecParameters 

type AVCodecParameters C.struct_AVCodecParameters

func NewAVCodecParameters 

func NewAVCodecParameters() *AVCodecParameters

NewAVCodecParameters allocates a new AVCodecParameters and set its fields to default values (unknown/invalid/0)

func (*AVCodecParameters) BitRate 

func (this *AVCodecParameters) BitRate() int32

func (*AVCodecParameters) CopyFrom 

func (this *AVCodecParameters) CopyFrom(codecpar *AVCodecParameters) error

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

func (*AVCodecParameters) Free 

func (this *AVCodecParameters) Free()

Free AVCodecParameters

func (*AVCodecParameters) FromContext 

func (this *AVCodecParameters) FromContext(other *AVCodecContext) error

FromContext fill the parameters based on the values from the supplied codec context

func (*AVCodecParameters) Height 

func (this *AVCodecParameters) Height() uint

func (*AVCodecParameters) Id 

func (this *AVCodecParameters) Id() AVCodecId

func (*AVCodecParameters) NewDecoderContext 

func (this *AVCodecParameters) NewDecoderContext() (*AVCodecContext, *AVCodec)

Create a new Codec decoder context

func (*AVCodecParameters) String 

func (this *AVCodecParameters) String() string

func (*AVCodecParameters) Tag 

func (this *AVCodecParameters) Tag() uint32

func (*AVCodecParameters) ToContext 

func (this *AVCodecParameters) ToContext(other *AVCodecContext) error

ToContext fills the codec context based on the values

func (*AVCodecParameters) Type 

func (this *AVCodecParameters) Type() AVMediaType

func (*AVCodecParameters) Width 

func (this *AVCodecParameters) Width() uint

type AVDictionary 

type AVDictionary struct {
	// contains filtered or unexported fields
}

func NewAVDictionary 

func NewAVDictionary() *AVDictionary

func (*AVDictionary) Close 

func (this *AVDictionary) Close()

func (*AVDictionary) Count 

func (this *AVDictionary) Count() int

func (*AVDictionary) Entries 

func (this *AVDictionary) Entries() []*AVDictionaryEntry

func (*AVDictionary) Get 

func (this *AVDictionary) Get(key string, prev *AVDictionaryEntry, flags AVDictionaryFlag) *AVDictionaryEntry

func (*AVDictionary) Keys 

func (this *AVDictionary) Keys() []string

func (*AVDictionary) Set 

func (this *AVDictionary) Set(key, value string, flags AVDictionaryFlag) error

func (*AVDictionary) String 

func (this *AVDictionary) String() string

type AVDictionaryEntry 

type AVDictionaryEntry C.struct_AVDictionaryEntry

func (*AVDictionaryEntry) Key 

func (this *AVDictionaryEntry) Key() string

func (*AVDictionaryEntry) String 

func (this *AVDictionaryEntry) String() string

func (*AVDictionaryEntry) Value 

func (this *AVDictionaryEntry) Value() string

type AVDictionaryFlag 

type AVDictionaryFlag int
const (
	AV_DICT_NONE            AVDictionaryFlag = 0
	AV_DICT_MATCH_CASE      AVDictionaryFlag = 1
	AV_DICT_IGNORE_SUFFIX   AVDictionaryFlag = 2
	AV_DICT_DONT_STRDUP_KEY AVDictionaryFlag = 4
	AV_DICT_DONT_STRDUP_VAL AVDictionaryFlag = 8
	AV_DICT_DONT_OVERWRITE  AVDictionaryFlag = 16
	AV_DICT_APPEND          AVDictionaryFlag = 32
	AV_DICT_MULTIKEY        AVDictionaryFlag = 64
)

type AVDisposition 

type AVDisposition int
const (
	AV_DISPOSITION_DEFAULT          AVDisposition = 0x0001
	AV_DISPOSITION_DUB              AVDisposition = 0x0002
	AV_DISPOSITION_ORIGINAL         AVDisposition = 0x0004
	AV_DISPOSITION_COMMENT          AVDisposition = 0x0008
	AV_DISPOSITION_LYRICS           AVDisposition = 0x0010
	AV_DISPOSITION_KARAOKE          AVDisposition = 0x0020
	AV_DISPOSITION_FORCED           AVDisposition = 0x0040
	AV_DISPOSITION_HEARING_IMPAIRED AVDisposition = 0x0080 // Stream for hearing impaired audiences
	AV_DISPOSITION_VISUAL_IMPAIRED  AVDisposition = 0x0100 // Stream for visual impaired audiences
	AV_DISPOSITION_CLEAN_EFFECTS    AVDisposition = 0x0200 // Stream without voice
	AV_DISPOSITION_ATTACHED_PIC     AVDisposition = 0x0400
	AV_DISPOSITION_TIMED_THUMBNAILS AVDisposition = 0x0800
	AV_DISPOSITION_CAPTIONS         AVDisposition = 0x10000
	AV_DISPOSITION_DESCRIPTIONS     AVDisposition = 0x20000
	AV_DISPOSITION_METADATA         AVDisposition = 0x40000
	AV_DISPOSITION_DEPENDENT        AVDisposition = 0x80000  // Dependent audio stream (mix_type=0 in mpegts)
	AV_DISPOSITION_STILL_IMAGE      AVDisposition = 0x100000 // Still images in video stream (still_picture_flag=1 in mpegts)
	AV_DISPOSITION_NONE             AVDisposition = 0
	AV_DISPOSITION_MIN                            = AV_DISPOSITION_DEFAULT
	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 int
const (
	AVERROR_EOF AVError = C.AVERROR_EOF
)

func (AVError) Error 

func (this AVError) Error() string

func (AVError) IsErrno 

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

type AVFormatContext 

type AVFormatContext C.struct_AVFormatContext

func NewAVFormatContext 

func NewAVFormatContext() *AVFormatContext

NewAVFormatContext creates a new empty format context

func NewAVFormatOutputContext 

func NewAVFormatOutputContext(filename string, output_format *AVOutputFormat) (*AVFormatContext, error)

NewAVFormatOutputContext creates a new format context with context populated with output parameters

func (*AVFormatContext) CloseInput 

func (this *AVFormatContext) CloseInput()

Close Input

func (*AVFormatContext) Dump 

func (this *AVFormatContext) Dump(index int)

func (*AVFormatContext) Filename 

func (this *AVFormatContext) Filename() string

Return Filename

func (*AVFormatContext) FindStreamInfo 

func (this *AVFormatContext) FindStreamInfo() error

Find Stream Info

func (*AVFormatContext) Flags 

func (this *AVFormatContext) Flags() AVFormatFlag

Return flags

func (*AVFormatContext) Free 

func (this *AVFormatContext) Free()

Free AVFormatContext

func (*AVFormatContext) IOContext 

func (this *AVFormatContext) IOContext() *AVIOContext

IOContext returns the current IO context

func (*AVFormatContext) InputFormat 

func (this *AVFormatContext) InputFormat() *AVInputFormat

Return Input Format

func (*AVFormatContext) Metadata 

func (this *AVFormatContext) Metadata() *AVDictionary

Return Metadata Dictionary

func (*AVFormatContext) NumStreams 

func (this *AVFormatContext) NumStreams() uint

Return number of streams

func (*AVFormatContext) OpenInput 

func (this *AVFormatContext) OpenInput(filename string, input_format *AVInputFormat) error

Open Input

func (*AVFormatContext) OpenInputIO 

func (this *AVFormatContext) OpenInputIO(io *AVIOContext, input_format *AVInputFormat) error

Open Input with AVIO Context

func (*AVFormatContext) OpenInputUrl 

func (this *AVFormatContext) OpenInputUrl(url string, input_format *AVInputFormat) error

Open Input URL

func (*AVFormatContext) OutputFormat 

func (this *AVFormatContext) OutputFormat() *AVOutputFormat

Return Output Format

func (*AVFormatContext) ReadPacket 

func (this *AVFormatContext) ReadPacket(packet *AVPacket) error

func (*AVFormatContext) SetIOContext 

func (this *AVFormatContext) SetIOContext(avio *AVIOContext)

SetIOContext sets the current IO context

func (*AVFormatContext) Streams 

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

Return Streams

func (*AVFormatContext) String 

func (this *AVFormatContext) String() string

func (*AVFormatContext) Url 

func (this *AVFormatContext) Url() *url.URL

Return URL

func (*AVFormatContext) WriteHeader 

func (this *AVFormatContext) WriteHeader(dict *AVDictionary) error

Write header

func (*AVFormatContext) WritePacket 

func (this *AVFormatContext) WritePacket(packet *AVPacket, out *AVFormatContext) error

func (*AVFormatContext) WriteTrailer 

func (this *AVFormatContext) WriteTrailer() error

Write trailer

type AVFormatFlag 

type AVFormatFlag int
const (
	AVFMT_NOFILE        AVFormatFlag = 0x0001
	AVFMT_NEEDNUMBER    AVFormatFlag = 0x0002    // Needs '%d' in filename
	AVFMT_SHOW_IDS      AVFormatFlag = 0x0008    // Show format stream IDs numbers
	AVFMT_GLOBALHEADER  AVFormatFlag = 0x0040    // Format wants global header
	AVFMT_NOTIMESTAMPS  AVFormatFlag = 0x0080    // Format does not need / have any timestamps
	AVFMT_GENERIC_INDEX AVFormatFlag = 0x0100    // Use generic index building code
	AVFMT_TS_DISCONT    AVFormatFlag = 0x0200    // Format allows timestamp discontinuities. Note, muxers always require valid (monotone) timestamps
	AVFMT_VARIABLE_FPS  AVFormatFlag = 0x0400    // Format allows variable fps
	AVFMT_NODIMENSIONS  AVFormatFlag = 0x0800    // Format does not need width/height
	AVFMT_NOSTREAMS     AVFormatFlag = 0x1000    // Format does not require any streams
	AVFMT_NOBINSEARCH   AVFormatFlag = 0x2000    // Format does not allow to fall back on binary search via read_timestamp
	AVFMT_NOGENSEARCH   AVFormatFlag = 0x4000    // Format does not allow to fall back on generic search
	AVFMT_NO_BYTE_SEEK  AVFormatFlag = 0x8000    // Format does not allow seeking by bytes
	AVFMT_ALLOW_FLUSH   AVFormatFlag = 0x10000   // Format allows flushing. If not set, the muxer will not receive a NULL packet in the write_packet function
	AVFMT_TS_NONSTRICT  AVFormatFlag = 0x20000   // Format does not require strictly increasing timestamps, but they must still be monotonic
	AVFMT_TS_NEGATIVE   AVFormatFlag = 0x40000   // Format allows muxing negative timestamps. If not set the timestamp will be shifted in av_write_frame and av_interleaved_write_frame so they start from 0. The user or muxer can override this through AVFormatContext.avoid_negative_ts
	AVFMT_SEEK_TO_PTS   AVFormatFlag = 0x4000000 // Seeking is based on PTS
	AVFMT_NONE          AVFormatFlag = 0
	AVFMT_MIN                        = AVFMT_NOFILE
	AVFMT_MAX                        = AVFMT_SEEK_TO_PTS
)

func (AVFormatFlag) FlagString 

func (v AVFormatFlag) FlagString() string

func (AVFormatFlag) String 

func (v AVFormatFlag) String() string

type AVFrame 

type AVFrame C.struct_AVFrame

func NewAVFrame 

func NewAVFrame() *AVFrame

func NewAudioFrame 

func NewAudioFrame(f AVSampleFormat, rate int, layout AVChannelLayout) *AVFrame

func (*AVFrame) Buffer 

func (this *AVFrame) Buffer(plane int) *AVBufferRef

func (*AVFrame) ChannelLayout 

func (this *AVFrame) ChannelLayout() AVChannelLayout

func (*AVFrame) Channels 

func (this *AVFrame) Channels() int

func (*AVFrame) Free 

func (this *AVFrame) Free()

func (*AVFrame) GetAudioBuffer 

func (this *AVFrame) GetAudioBuffer(num_samples int) error

func (*AVFrame) IsPlanar 

func (this *AVFrame) IsPlanar() bool

func (*AVFrame) KeyFrame 

func (this *AVFrame) KeyFrame() bool

func (*AVFrame) NumSamples 

func (this *AVFrame) NumSamples() int

func (*AVFrame) PictHeight 

func (this *AVFrame) PictHeight() int

func (*AVFrame) PictType 

func (this *AVFrame) PictType() AVPictureType

func (*AVFrame) PictWidth 

func (this *AVFrame) PictWidth() int

func (*AVFrame) PixelFormat 

func (this *AVFrame) PixelFormat() AVPixelFormat

func (*AVFrame) Release 

func (this *AVFrame) Release()

func (*AVFrame) SampleFormat 

func (this *AVFrame) SampleFormat() AVSampleFormat

func (*AVFrame) SampleRate 

func (this *AVFrame) SampleRate() int

func (*AVFrame) StrideForPlane 

func (this *AVFrame) StrideForPlane(i int) int

func (*AVFrame) String 

func (this *AVFrame) String() string

type AVIOContext 

type AVIOContext C.struct_AVIOContext

func NewAVIOOpen 

func NewAVIOOpen(url *url.URL, flags AVIOFlag) (*AVIOContext, error)

func (*AVIOContext) Bytes 

func (this *AVIOContext) Bytes() []byte

func (*AVIOContext) Close 

func (this *AVIOContext) Close() error

func (*AVIOContext) Direct 

func (this *AVIOContext) Direct() bool

func (*AVIOContext) EOF 

func (this *AVIOContext) EOF() bool

func (*AVIOContext) Flush 

func (this *AVIOContext) Flush()

func (*AVIOContext) Free 

func (this *AVIOContext) Free()

func (*AVIOContext) Pos 

func (this *AVIOContext) Pos() int64

func (*AVIOContext) Read 

func (this *AVIOContext) Read(buf []byte) (int, error)

func (*AVIOContext) Seekable 

func (this *AVIOContext) Seekable() bool

func (*AVIOContext) Size 

func (this *AVIOContext) Size() int

func (*AVIOContext) String 

func (this *AVIOContext) String() string

func (*AVIOContext) Write 

func (this *AVIOContext) Write(buf []byte)

func (*AVIOContext) Writeable 

func (this *AVIOContext) Writeable() bool

type AVIOContextEx 

type AVIOContextEx struct {
	*AVIOContext
	// contains filtered or unexported fields
}

func NewAVIOContext 

func NewAVIOContext(size int, writeable bool, reader, writer AVIOReadWriteFunc, seeker AVIOSeekFunc) *AVIOContextEx

func (*AVIOContextEx) Free 

func (this *AVIOContextEx) Free()

type AVIOFlag 

type AVIOFlag int
const (
	AVIO_FLAG_NONE       AVIOFlag = 0
	AVIO_FLAG_READ       AVIOFlag = 1
	AVIO_FLAG_WRITE      AVIOFlag = 2
	AVIO_FLAG_READ_WRITE AVIOFlag = (AVIO_FLAG_READ | AVIO_FLAG_WRITE)
)

type AVIOReadWriteFunc 

type AVIOReadWriteFunc func(buf []byte) (int, error)

type AVIOSeekFunc 

type AVIOSeekFunc func(offset int64, whence int) (int64, error)

type AVInputFormat 

type AVInputFormat C.struct_AVInputFormat

func AllDemuxers 

func AllDemuxers() []*AVInputFormat

AllDemuxers returns all registered demultiplexers

func EnumerateInputFormats 

func EnumerateInputFormats() []*AVInputFormat

Return input formats

func (*AVInputFormat) Description 

func (this *AVInputFormat) Description() string

func (*AVInputFormat) Ext 

func (this *AVInputFormat) Ext() string

func (*AVInputFormat) Flags 

func (this *AVInputFormat) Flags() AVFormatFlag

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(level AVLogLevel, message string, userInfo uintptr)

type AVLogLevel 

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

func AVGetLogLevel 

func AVGetLogLevel() AVLogLevel

func (AVLogLevel) String 

func (v AVLogLevel) String() string

type AVMediaType 

type AVMediaType int
const (
	AVMEDIA_TYPE_VIDEO AVMediaType = iota
	AVMEDIA_TYPE_AUDIO
	AVMEDIA_TYPE_DATA // Opaque data information usually continuous
	AVMEDIA_TYPE_SUBTITLE
	AVMEDIA_TYPE_ATTACHMENT                  // Opaque data information usually sparse
	AVMEDIA_TYPE_UNKNOWN    AVMediaType = -1 // Usually treated as AVMEDIA_TYPE_DATA
)

func (AVMediaType) String 

func (v AVMediaType) String() string

type AVOutputFormat 

type AVOutputFormat C.struct_AVOutputFormat

func AllMuxers 

func AllMuxers() []*AVOutputFormat

AllMuxers returns all registered multiplexers

func EnumerateOutputFormats 

func EnumerateOutputFormats() []*AVOutputFormat

Return output formats

func (*AVOutputFormat) Description 

func (this *AVOutputFormat) Description() string

func (*AVOutputFormat) Ext 

func (this *AVOutputFormat) Ext() string

func (*AVOutputFormat) Flags 

func (this *AVOutputFormat) Flags() AVFormatFlag

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 NewAVPacket 

func NewAVPacket() *AVPacket

NewAVPacket allocates an AVPacket and set its fields to default values

func (*AVPacket) Bytes 

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

Returns bytes for a packet

func (*AVPacket) Dts 

func (this *AVPacket) Dts() int64

func (*AVPacket) Duration 

func (this *AVPacket) Duration() int64

func (*AVPacket) Flags 

func (this *AVPacket) Flags() AVPacketFlag

func (*AVPacket) Free 

func (this *AVPacket) Free()

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

func (*AVPacket) Pos 

func (this *AVPacket) Pos() int64

func (*AVPacket) Pts 

func (this *AVPacket) Pts() int64

func (*AVPacket) Release 

func (this *AVPacket) Release()

Release AVPacket, wiping packet data

func (*AVPacket) Size 

func (this *AVPacket) Size() int

func (*AVPacket) Stream 

func (this *AVPacket) Stream() int

func (*AVPacket) String 

func (this *AVPacket) String() string

type AVPacketFlag 

type AVPacketFlag int
const (
	AV_PKT_FLAG_NONE       AVPacketFlag = 0
	AV_PKT_FLAG_KEY        AVPacketFlag = 0x0001 // The packet contains a keyframe
	AV_PKT_FLAG_CORRUPT    AVPacketFlag = 0x0002 // The packet content is corrupted
	AV_PKT_FLAG_DISCARD    AVPacketFlag = 0x0004 // Flag is used to discard packets
	AV_PKT_FLAG_TRUSTED    AVPacketFlag = 0x0008 // The packet comes from a trusted source
	AV_PKT_FLAG_DISPOSABLE AVPacketFlag = 0x0010 // The packet contains frames that can be discarded
	AV_PKT_FLAG_MIN                     = AV_PKT_FLAG_KEY
	AV_PKT_FLAG_MAX                     = AV_PKT_FLAG_DISPOSABLE
)

func (AVPacketFlag) FlagString 

func (v AVPacketFlag) FlagString() string

func (AVPacketFlag) String 

func (f AVPacketFlag) String() string

type AVPictureType 

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

func (AVPictureType) String 

func (p AVPictureType) String() string

type AVPixelFormat 

type AVPixelFormat C.enum_AVPixelFormat
const (
	AV_PIX_FMT_YUV420P        AVPixelFormat = iota // planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
	AV_PIX_FMT_YUYV422                             // packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
	AV_PIX_FMT_RGB24                               // packed RGB 8:8:8, 24bpp, RGBRGB...
	AV_PIX_FMT_BGR24                               // packed RGB 8:8:8, 24bpp, BGRBGR...
	AV_PIX_FMT_YUV422P                             // planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
	AV_PIX_FMT_YUV444P                             // planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
	AV_PIX_FMT_YUV410P                             // planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
	AV_PIX_FMT_YUV411P                             // planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
	AV_PIX_FMT_GRAY8                               // 8bpp.
	AV_PIX_FMT_MONOWHITE                           // 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
	AV_PIX_FMT_MONOBLACK                           // 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
	AV_PIX_FMT_PAL8                                // 8 bits with AV_PIX_FMT_RGB32 palette
	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                            // 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                            // 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                             // packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
	AV_PIX_FMT_UYYVYY411                           // packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
	AV_PIX_FMT_BGR8                                // packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
	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                           // packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
	AV_PIX_FMT_RGB8                                // packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
	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                           // packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
	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                                // as above, but U and V bytes are swapped
	AV_PIX_FMT_ARGB                                // packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
	AV_PIX_FMT_RGBA                                // packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
	AV_PIX_FMT_ABGR                                // packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
	AV_PIX_FMT_BGRA                                // packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
	AV_PIX_FMT_GRAY16BE                            // 16bpp, big-endian.
	AV_PIX_FMT_GRAY16LE                            // 16bpp, little-endian.
	AV_PIX_FMT_YUV440P                             // planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
	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                            // planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
	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                             // 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                            // packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
	AV_PIX_FMT_RGB565LE                            // packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
	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                            // packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
	AV_PIX_FMT_BGR565BE                            // packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
	AV_PIX_FMT_BGR565LE                            // packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
	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                            // packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
	AV_PIX_FMT_VAAPI_MOCO                          // HW acceleration through VA API at motion compensation entry-point, Picture.data[3] contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers.
	AV_PIX_FMT_VAAPI_IDCT                          // HW acceleration through VA API at IDCT entry-point, Picture.data[3] contains a vaapi_render_state struct which contains fields extracted from headers.
	AV_PIX_FMT_VAAPI_VLD                           // HW decoding through VA API, Picture.data[3] contains a VASurfaceID.
	AV_PIX_FMT_VAAPI                               //
	AV_PIX_FMT_YUV420P16LE                         // planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
	AV_PIX_FMT_YUV420P16BE                         // planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
	AV_PIX_FMT_YUV422P16LE                         // planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AV_PIX_FMT_YUV422P16BE                         // planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AV_PIX_FMT_YUV444P16LE                         // planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	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                           // HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
	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                            // packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
	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                            // packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
	AV_PIX_FMT_YA8                                 // 8 bits gray, 8 bits alpha
	AV_PIX_FMT_Y400A                               // alias for AV_PIX_FMT_YA8
	AV_PIX_FMT_GRAY8A                              // alias for AV_PIX_FMT_YA8
	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                             // 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                          // The following 12 formats have the disadvantage of needing 1 format for each bit depth.
	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                         // planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
	AV_PIX_FMT_YUV420P10LE                         // planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
	AV_PIX_FMT_YUV422P10BE                         // planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AV_PIX_FMT_YUV422P10LE                         // planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AV_PIX_FMT_YUV444P9BE                          // planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
	AV_PIX_FMT_YUV444P9LE                          // planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	AV_PIX_FMT_YUV444P10BE                         // planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
	AV_PIX_FMT_YUV444P10LE                         // planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	AV_PIX_FMT_YUV422P9BE                          // planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AV_PIX_FMT_YUV422P9LE                          // planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AV_PIX_FMT_GBRP                                //
	AV_PIX_FMT_GBR24P                              // planar GBR 4:4:4 24bpp
	AV_PIX_FMT_GBRP9BE                             // planar GBR 4:4:4 27bpp, big-endian
	AV_PIX_FMT_GBRP9LE                             // planar GBR 4:4:4 27bpp, little-endian
	AV_PIX_FMT_GBRP10BE                            // planar GBR 4:4:4 30bpp, big-endian
	AV_PIX_FMT_GBRP10LE                            // planar GBR 4:4:4 30bpp, little-endian
	AV_PIX_FMT_GBRP16BE                            // planar GBR 4:4:4 48bpp, big-endian
	AV_PIX_FMT_GBRP16LE                            // planar GBR 4:4:4 48bpp, little-endian
	AV_PIX_FMT_YUVA422P                            // planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
	AV_PIX_FMT_YUVA444P                            // planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
	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                         // planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
	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                         // planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
	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                         // planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
	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                        // planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
	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                        // planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
	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                        // planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
	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                        // planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
	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                        // planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
	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                        // planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
	AV_PIX_FMT_VDPAU                               // HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
	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                             // 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                                // interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
	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                              // interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	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                            // 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                            // 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                            // 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                             // packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
	AV_PIX_FMT_YA16BE                              // 16 bits gray, 16 bits alpha (big-endian)
	AV_PIX_FMT_YA16LE                              // 16 bits gray, 16 bits alpha (little-endian)
	AV_PIX_FMT_GBRAP                               // planar GBRA 4:4:4:4 32bpp
	AV_PIX_FMT_GBRAP16BE                           // planar GBRA 4:4:4:4 64bpp, big-endian
	AV_PIX_FMT_GBRAP16LE                           // planar GBRA 4:4:4:4 64bpp, little-endian
	AV_PIX_FMT_QSV                                 // HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
	AV_PIX_FMT_MMAL                                // HW acceleration though MMAL, data[3] contains a pointer to the MMAL_BUFFER_HEADER_T structure.
	AV_PIX_FMT_D3D11VA_VLD                         // HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView pointer.
	AV_PIX_FMT_CUDA                                // HW acceleration through CUDA.
	AV_PIX_FMT_0RGB                                // packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
	AV_PIX_FMT_RGB0                                // packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
	AV_PIX_FMT_0BGR                                // packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
	AV_PIX_FMT_BGR0                                // packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
	AV_PIX_FMT_YUV420P12BE                         // planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
	AV_PIX_FMT_YUV420P12LE                         // planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
	AV_PIX_FMT_YUV420P14BE                         // planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
	AV_PIX_FMT_YUV420P14LE                         // planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
	AV_PIX_FMT_YUV422P12BE                         // planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AV_PIX_FMT_YUV422P12LE                         // planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AV_PIX_FMT_YUV422P14BE                         // planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AV_PIX_FMT_YUV422P14LE                         // planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AV_PIX_FMT_YUV444P12BE                         // planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
	AV_PIX_FMT_YUV444P12LE                         // planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	AV_PIX_FMT_YUV444P14BE                         // planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
	AV_PIX_FMT_YUV444P14LE                         // planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	AV_PIX_FMT_GBRP12BE                            // planar GBR 4:4:4 36bpp, big-endian
	AV_PIX_FMT_GBRP12LE                            // planar GBR 4:4:4 36bpp, little-endian
	AV_PIX_FMT_GBRP14BE                            // planar GBR 4:4:4 42bpp, big-endian
	AV_PIX_FMT_GBRP14LE                            // planar GBR 4:4:4 42bpp, little-endian
	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                         // bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
	AV_PIX_FMT_BAYER_RGGB8                         // bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples
	AV_PIX_FMT_BAYER_GBRG8                         // bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples
	AV_PIX_FMT_BAYER_GRBG8                         // bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples
	AV_PIX_FMT_BAYER_BGGR16LE                      // bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian
	AV_PIX_FMT_BAYER_BGGR16BE                      // bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian
	AV_PIX_FMT_BAYER_RGGB16LE                      // bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian
	AV_PIX_FMT_BAYER_RGGB16BE                      // bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian
	AV_PIX_FMT_BAYER_GBRG16LE                      // bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian
	AV_PIX_FMT_BAYER_GBRG16BE                      // bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian
	AV_PIX_FMT_BAYER_GRBG16LE                      // bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian
	AV_PIX_FMT_BAYER_GRBG16BE                      // bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian
	AV_PIX_FMT_XVMC                                // XVideo Motion Acceleration via common packet passing.
	AV_PIX_FMT_YUV440P10LE                         // planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
	AV_PIX_FMT_YUV440P10BE                         // planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
	AV_PIX_FMT_YUV440P12LE                         // planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
	AV_PIX_FMT_YUV440P12BE                         // planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
	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                            // packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
	AV_PIX_FMT_VIDEOTOOLBOX                        // hardware decoding through Videotoolbox
	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                              // like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, big-endian
	AV_PIX_FMT_GBRAP12BE                           // planar GBR 4:4:4:4 48bpp, big-endian
	AV_PIX_FMT_GBRAP12LE                           // planar GBR 4:4:4:4 48bpp, little-endian
	AV_PIX_FMT_GBRAP10BE                           // planar GBR 4:4:4:4 40bpp, big-endian
	AV_PIX_FMT_GBRAP10LE                           // planar GBR 4:4:4:4 40bpp, little-endian
	AV_PIX_FMT_MEDIACODEC                          // hardware decoding through MediaCodec
	AV_PIX_FMT_GRAY12BE                            // Y , 12bpp, big-endian.
	AV_PIX_FMT_GRAY12LE                            // Y , 12bpp, little-endian.
	AV_PIX_FMT_GRAY10BE                            // Y , 10bpp, big-endian.
	AV_PIX_FMT_GRAY10LE                            // Y , 10bpp, little-endian.
	AV_PIX_FMT_P016LE                              // like NV12, with 16bpp per component, little-endian
	AV_PIX_FMT_P016BE                              // like NV12, with 16bpp per component, big-endian
	AV_PIX_FMT_D3D11                               // Hardware surfaces for Direct3D11.
	AV_PIX_FMT_GRAY9BE                             // Y , 9bpp, big-endian.
	AV_PIX_FMT_GRAY9LE                             // Y , 9bpp, little-endian.
	AV_PIX_FMT_GBRPF32BE                           // IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
	AV_PIX_FMT_GBRPF32LE                           // IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.
	AV_PIX_FMT_GBRAPF32BE                          // IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.
	AV_PIX_FMT_GBRAPF32LE                          // IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
	AV_PIX_FMT_DRM_PRIME                           // DRM-managed buffers exposed through PRIME buffer sharing.
	AV_PIX_FMT_OPENCL                              // Hardware surfaces for OpenCL.
	AV_PIX_FMT_GRAY14BE                            // Y , 14bpp, big-endian.
	AV_PIX_FMT_GRAY14LE                            // Y , 14bpp, little-endian.
	AV_PIX_FMT_GRAYF32BE                           // IEEE-754 single precision Y, 32bpp, big-endian.
	AV_PIX_FMT_GRAYF32LE                           // IEEE-754 single precision Y, 32bpp, little-endian.
	AV_PIX_FMT_NONE           AVPixelFormat = -1
	AV_PIX_FMT_MIN                          = AV_PIX_FMT_YUV420P
	AV_PIX_FMT_MAX                          = AV_PIX_FMT_GRAYF32LE
)

func (AVPixelFormat) String 

func (f AVPixelFormat) String() string

type AVRational 

type AVRational C.struct_AVRational

func (AVRational) Den 

func (this AVRational) Den() int

func (AVRational) Float 

func (this AVRational) Float(multiplier int64) float64

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

func (AVRational) Num 

func (this AVRational) Num() int

func (AVRational) String 

func (this AVRational) String() string

type AVSampleFormat 

type AVSampleFormat C.enum_AVSampleFormat
const (
	AV_SAMPLE_FMT_NONE AVSampleFormat = iota
	AV_SAMPLE_FMT_U8                  //	unsigned 8 bits
	AV_SAMPLE_FMT_S16                 //	signed 16 bits
	AV_SAMPLE_FMT_S32                 //	signed 32 bits
	AV_SAMPLE_FMT_FLT                 //	float
	AV_SAMPLE_FMT_DBL                 //	double
	AV_SAMPLE_FMT_U8P                 //	unsigned 8 bits, planar
	AV_SAMPLE_FMT_S16P                //	signed 16 bits, planar
	AV_SAMPLE_FMT_S32P                //	signed 32 bits, planar
	AV_SAMPLE_FMT_FLTP                //	float, planar
	AV_SAMPLE_FMT_DBLP                //	double, planar
	AV_SAMPLE_FMT_S64                 //	signed 64 bits
	AV_SAMPLE_FMT_S64P                //	signed 64 bits, planar
)

func (AVSampleFormat) String 

func (f AVSampleFormat) String() string

type AVStream 

type AVStream C.struct_AVStream

func NewStream 

func NewStream(ctx *AVFormatContext, codec *AVCodec) *AVStream

func (*AVStream) AttachedPicture 

func (this *AVStream) AttachedPicture() *AVPacket

func (*AVStream) CodecPar 

func (this *AVStream) CodecPar() *AVCodecParameters

func (*AVStream) Disposition 

func (this *AVStream) Disposition() AVDisposition

func (*AVStream) Duration 

func (this *AVStream) Duration() int64

func (*AVStream) Id 

func (this *AVStream) Id() int

func (*AVStream) Index 

func (this *AVStream) Index() int

func (*AVStream) MeanFrameRate 

func (this *AVStream) MeanFrameRate() AVRational

func (*AVStream) Metadata 

func (this *AVStream) Metadata() *AVDictionary

func (*AVStream) NumFrames 

func (this *AVStream) NumFrames() int64

func (*AVStream) StartTime 

func (this *AVStream) StartTime() int64

func (*AVStream) String 

func (this *AVStream) String() string

func (*AVStream) TimeBase 

func (this *AVStream) TimeBase() AVRational

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.