joy4: github.com/nareix/joy4/av Index | Files | Directories

package av

import "github.com/nareix/joy4/av"

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

Index

Package Files

av.go

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)
    AAC        = MakeAudioCodecType(avCodecTypeMagic + 1)
    PCM_MULAW  = MakeAudioCodecType(avCodecTypeMagic + 2)
    PCM_ALAW   = MakeAudioCodecType(avCodecTypeMagic + 3)
    SPEEX      = MakeAudioCodecType(avCodecTypeMagic + 4)
    NELLYMOSER = MakeAudioCodecType(avCodecTypeMagic + 5)
)

type AudioCodecData Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

Concat two audio frames.

func (AudioFrame) Duration Uses

func (self AudioFrame) Duration() time.Duration

func (AudioFrame) HasSameFormat Uses

func (self AudioFrame) HasSameFormat(other AudioFrame) bool

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

func (AudioFrame) Slice Uses

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

Split sample audio sample from this frame.

type AudioResampler Uses

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 Uses

type ChannelLayout uint16

Audio channel layout.

func (ChannelLayout) Count Uses

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

func (ChannelLayout) String Uses

func (self ChannelLayout) String() string

type CodecData Uses

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 Uses

type CodecType uint32

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

func MakeAudioCodecType Uses

func MakeAudioCodecType(base uint32) (c CodecType)

Make a new audio codec type.

func MakeVideoCodecType Uses

func MakeVideoCodecType(base uint32) (c CodecType)

Make a new video codec type.

func (CodecType) IsAudio Uses

func (self CodecType) IsAudio() bool

func (CodecType) IsVideo Uses

func (self CodecType) IsVideo() bool

func (CodecType) String Uses

func (self CodecType) String() string

type DemuxCloser Uses

type DemuxCloser interface {
    Demuxer
    Close() error
}

Demuxer with Close() method

type Demuxer Uses

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 Uses

type MuxCloser interface {
    Muxer
    Close() error
}

Muxer with Close() method

type Muxer Uses

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 Uses

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
    Data            []byte        // packet data
}

Packet stores compressed audio/video data.

type PacketReader Uses

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

type PacketWriter Uses

type PacketWriter interface {
    WritePacket(Packet) error
}

type SampleFormat Uses

type SampleFormat uint8

Audio sample format.

func (SampleFormat) BytesPerSample Uses

func (self SampleFormat) BytesPerSample() int

func (SampleFormat) IsPlanar Uses

func (self SampleFormat) IsPlanar() bool

Check if this sample format is in planar.

func (SampleFormat) String Uses

func (self SampleFormat) String() string

type VideoCodecData Uses

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

Directories

PathSynopsis
avconv
avutil
pktquePackage pktque provides packet Filter interface and structures used by other components.
pubsubPackege pubsub implements publisher-subscribers model used in multi-channel streaming.
transcodePackage transcoder implements Transcoder based on Muxer/Demuxer and AudioEncoder/AudioDecoder interface.

Package av imports 2 packages (graph) and is imported by 153 packages. Updated 2018-10-22. Refresh now. Tools for package owners.