av

Documentation

Overview

Package av defines basic interfaces and data structures of container demux/mux and audio encode/decode.

Index

• Constants
• Variables
• type AudioCodecData
• type AudioDecoder
• type AudioEncoder
• type AudioFrame
  • func (self AudioFrame) Concat(in AudioFrame) (out AudioFrame)
  • func (self AudioFrame) Duration() time.Duration
  • func (self AudioFrame) HasSameFormat(other AudioFrame) bool
  • func (self AudioFrame) Slice(start int, end int) (out AudioFrame)
• type AudioResampler
• type ChannelLayout
  • func (self ChannelLayout) Count() (n int)
  • func (self ChannelLayout) String() string
• type CodecData
• type CodecType
  • func MakeAudioCodecType(base uint32) (c CodecType)
  • func MakeVideoCodecType(base uint32) (c CodecType)
  • func (self CodecType) IsAudio() bool
  • func (self CodecType) IsVideo() bool
  • func (self CodecType) String() string
• type DemuxCloser
• type Demuxer
• type MuxCloser
• type Muxer
• type Packet
• type PacketReader
• type PacketWriter
• type SampleFormat
  • func (self SampleFormat) BytesPerSample() int
  • func (self SampleFormat) IsPlanar() bool
  • func (self SampleFormat) String() string
• type VideoCodecData

Constants

const (
	U8   = SampleFormat(iota + 1) // 8-bit unsigned integer
	S16                           // signed 16-bit integer
	S32                           // signed 32-bit integer
	FLT                           // 32-bit float
	DBL                           // 64-bit float
	U8P                           // 8-bit unsigned integer in planar
	S16P                          // signed 16-bit integer in planar
	S32P                          // signed 32-bit integer in planar
	FLTP                          // 32-bit float in planar
	DBLP                          // 64-bit float in planar
	U32                           // unsigned 32-bit integer
)

const (
	CH_FRONT_CENTER = ChannelLayout(1 << iota)
	CH_FRONT_LEFT
	CH_FRONT_RIGHT
	CH_BACK_CENTER
	CH_BACK_LEFT
	CH_BACK_RIGHT
	CH_SIDE_LEFT
	CH_SIDE_RIGHT
	CH_LOW_FREQ
	CH_NR

	CH_MONO     = ChannelLayout(CH_FRONT_CENTER)
	CH_STEREO   = ChannelLayout(CH_FRONT_LEFT | CH_FRONT_RIGHT)
	CH_2_1      = ChannelLayout(CH_STEREO | CH_BACK_CENTER)
	CH_2POINT1  = ChannelLayout(CH_STEREO | CH_LOW_FREQ)
	CH_SURROUND = ChannelLayout(CH_STEREO | CH_FRONT_CENTER)
	CH_3POINT1  = ChannelLayout(CH_SURROUND | CH_LOW_FREQ)
)

Variables

var (
	H264       = MakeVideoCodecType(avCodecTypeMagic + 1)
	H265       = MakeVideoCodecType(avCodecTypeMagic + 2)
	JPEG       = MakeVideoCodecType(avCodecTypeMagic + 3)
	VP8        = MakeVideoCodecType(avCodecTypeMagic + 4)
	VP9        = MakeVideoCodecType(avCodecTypeMagic + 5)
	AV1        = MakeVideoCodecType(avCodecTypeMagic + 6)
	MJPEG      = MakeVideoCodecType(avCodecTypeMagic + 7)
	AAC        = MakeAudioCodecType(avCodecTypeMagic + 1)
	PCM_MULAW  = MakeAudioCodecType(avCodecTypeMagic + 2)
	PCM_ALAW   = MakeAudioCodecType(avCodecTypeMagic + 3)
	SPEEX      = MakeAudioCodecType(avCodecTypeMagic + 4)
	NELLYMOSER = MakeAudioCodecType(avCodecTypeMagic + 5)
	PCM        = MakeAudioCodecType(avCodecTypeMagic + 6)
	OPUS       = MakeAudioCodecType(avCodecTypeMagic + 7)
)

Types

type AudioCodecData

type AudioCodecData interface {
	CodecData
	SampleFormat() SampleFormat                   // audio sample format
	SampleRate() int                              // audio sample rate
	ChannelLayout() ChannelLayout                 // audio channel layout
	PacketDuration([]byte) (time.Duration, error) // get audio compressed packet duration
}

type AudioDecoder

type AudioDecoder interface {
	Decode([]byte) (bool, AudioFrame, error) // decode one compressed audio packet
	Close()                                  // close decode, free cgo contexts
}

AudioDecoder can decode compressed audio packets into raw audio frame. use ffmpeg.NewAudioDecoder to create it.

type AudioEncoder

type AudioEncoder interface {
	CodecData() (AudioCodecData, error)   // encoder's codec data can put into container
	Encode(AudioFrame) ([][]byte, error)  // encode raw audio frame into compressed pakcet(s)
	Close()                               // close encoder, free cgo contexts
	SetSampleRate(int) error              // set encoder sample rate
	SetChannelLayout(ChannelLayout) error // set encoder channel layout
	SetSampleFormat(SampleFormat) error   // set encoder sample format
	SetBitrate(int) error                 // set encoder bitrate
	SetOption(string, interface{}) error  // encoder setopt, in ffmpeg is av_opt_set_dict()
	GetOption(string, interface{}) error  // encoder getopt
}

AudioEncoder can encode raw audio frame into compressed audio packets. cgo/ffmpeg inplements AudioEncoder, using ffmpeg.NewAudioEncoder to create it.

type AudioFrame

type AudioFrame struct {
	SampleFormat  SampleFormat  // audio sample format, e.g: S16,FLTP,...
	ChannelLayout ChannelLayout // audio channel layout, e.g: CH_MONO,CH_STEREO,...
	SampleCount   int           // sample count in this frame
	SampleRate    int           // sample rate
	Data          [][]byte      // data array for planar format len(Data) > 1
}

Raw audio frame.

func (AudioFrame) Concat

func (self AudioFrame) Concat(in AudioFrame) (out AudioFrame)

Concat two audio frames.

func (AudioFrame) Duration

func (self AudioFrame) Duration() time.Duration

func (AudioFrame) HasSameFormat

func (self AudioFrame) HasSameFormat(other AudioFrame) bool

Check this audio frame has same format as other audio frame.

func (AudioFrame) Slice

func (self AudioFrame) Slice(start int, end int) (out AudioFrame)

Split sample audio sample from this frame.

type AudioResampler

type AudioResampler interface {
	Resample(AudioFrame) (AudioFrame, error) // convert raw audio frames
}

AudioResampler can convert raw audio frames in different sample rate/format/channel layout.

type ChannelLayout

type ChannelLayout uint16

Audio channel layout.

func (ChannelLayout) Count

func (self ChannelLayout) Count() (n int)

func (ChannelLayout) String

func (self ChannelLayout) String() string

type CodecData

type CodecData interface {
	Type() CodecType // Video/Audio codec type
}

CodecData is some important bytes for initializing audio/video decoder, can be converted to VideoCodecData or AudioCodecData using:

codecdata.(AudioCodecData) or codecdata.(VideoCodecData)

for H264, CodecData is AVCDecoderConfigure bytes, includes SPS/PPS.

type CodecType

type CodecType uint32

Video/Audio codec type. can be H264/AAC/SPEEX/...

func MakeAudioCodecType

func MakeAudioCodecType(base uint32) (c CodecType)

Make a new audio codec type.

func MakeVideoCodecType

func MakeVideoCodecType(base uint32) (c CodecType)

Make a new video codec type.

func (CodecType) IsAudio

func (self CodecType) IsAudio() bool

func (CodecType) IsVideo

func (self CodecType) IsVideo() bool

func (CodecType) String

func (self CodecType) String() string

type DemuxCloser

type DemuxCloser interface {
	Demuxer
	Close() error
}

Demuxer with Close() method

type Demuxer

type Demuxer interface {
	PacketReader                   // read compressed audio/video packets
	Streams() ([]CodecData, error) // reads the file header, contains video/audio meta infomations
}

Demuxer can read compressed audio/video packets from container formats like MP4/FLV/MPEG-TS.

type MuxCloser

type MuxCloser interface {
	Muxer
	Close() error
}

Muxer with Close() method

type Muxer

type Muxer interface {
	WriteHeader([]CodecData) error // write the file header
	PacketWriter                   // write compressed audio/video packets
	WriteTrailer() error           // finish writing file, this func can be called only once
}

Muxer describes the steps of writing compressed audio/video packets into container formats like MP4/FLV/MPEG-TS.

Container formats, rtmp.Conn, and transcode.Muxer implements Muxer interface.

type Packet

type Packet struct {
	IsKeyFrame      bool          // video packet is key frame
	Idx             int8          // stream index in container format
	CompositionTime time.Duration // packet presentation time minus decode time for H264 B-Frame
	Time            time.Duration // packet decode time
	Duration        time.Duration //packet duration
	Data            []byte        // packet data
}

Packet stores compressed audio/video data.

type PacketReader

type PacketReader interface {
	ReadPacket() (Packet, error)
}

type PacketWriter

type PacketWriter interface {
	WritePacket(Packet) error
}

type SampleFormat

type SampleFormat uint8

Audio sample format.

func (SampleFormat) BytesPerSample

func (self SampleFormat) BytesPerSample() int

func (SampleFormat) IsPlanar

func (self SampleFormat) IsPlanar() bool

Check if this sample format is in planar.

func (SampleFormat) String

func (self SampleFormat) String() string

type VideoCodecData

type VideoCodecData interface {
	CodecData
	Width() int  // Video width
	Height() int // Video height
}