astilibav

package
v0.25.0 Latest Latest
Warning

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

 Go to latest Published: Mar 24, 2022 License: MIT Imports: 18 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	EventNameLog = "astilibav.log"
	// First frame of new node has been received by the rate enforcer
	EventNameRateEnforcerSwitchedIn = "astilibav.rate.enforcer.switched.in"
	// First frame of new node has been dispatched by the rate enforcer
	EventNameRateEnforcerSwitchedOut = "astilibav.rate.enforcer.switched.out"
)

Event names

View Source 
const (
	StatNameAverageDelay  = "astilibav.average.delay"
	StatNameFilledRate    = "astilibav.filled.rate"
	StatNameIncomingRate  = "astilibav.incoming.rate"
	StatNameOutgoingRate  = "astilibav.outgoing.rate"
	StatNameProcessedRate = "astilibav.processed.rate"
	StatNameWorkRatio     = "astilibav.work.ratio"
)

Stat names

Variables

View Source 
var PktDumpFile = func(pkt *astiav.Packet, args PktDumperHandlerArgs) (err error) {
	// Create file
	var f *os.File
	if f, err = os.Create(args.Pattern); err != nil {
		err = fmt.Errorf("astilibav: creating file %s failed: %w", args.Pattern, err)
		return
	}
	defer f.Close()

	if _, err = f.Write(pkt.Data()); err != nil {
		err = fmt.Errorf("astilibav: writing to file %s failed: %w", args.Pattern, err)
		return
	}
	return
}

PktDumpFunc is a PktDumpFunc that dumps the packet to a file

Functions

func AddStream 

func AddStream(formatCtx *astiav.FormatContext) *astiav.Stream

AddStream adds a stream to the format ctx

func CloneStream 

func CloneStream(i *Stream, formatCtx *astiav.FormatContext) (o *astiav.Stream, err error)

CloneStream clones a stream and add it to the format ctx

func HandleLogs added in v0.11.0 

func HandleLogs(eh *astiencoder.EventHandler)

TODO Process parent and update event's target

func LoggerEventHandlerAdapter added in v0.11.0 

func LoggerEventHandlerAdapter(o LoggerEventHandlerAdapterOptions, i astikit.StdLogger, h *astiencoder.EventHandler)

func NewFrameRateEnforcerFiller added in v0.13.0 

func NewFrameRateEnforcerFiller(fn func(fm *astiav.Frame) error, c *astikit.Closer) (f *frameRateEnforcerFiller, err error)

Types

type Context 

type Context struct {
	// Shared
	BitRate      int64
	CodecID      astiav.CodecID
	CodecName    string
	Dictionary   *Dictionary
	GlobalHeader bool
	Index        int
	MediaType    astiav.MediaType
	ThreadCount  *int
	ThreadType   *astiav.ThreadType
	TimeBase     astiav.Rational

	// Audio
	ChannelLayout astiav.ChannelLayout
	Channels      int
	SampleFormat  astiav.SampleFormat
	SampleRate    int

	// Video
	FrameRate         astiav.Rational
	GopSize           int
	Height            int
	PixelFormat       astiav.PixelFormat
	Rotation          float64
	SampleAspectRatio astiav.Rational
	Width             int
}

Context represents parameters of an audio or a video context

func NewContextFromStream 

func NewContextFromStream(s *astiav.Stream) (ctx Context)

func (Context) Descriptor added in v0.14.0 

func (ctx Context) Descriptor() Descriptor

func (Context) String added in v0.11.0 

func (ctx Context) String() string

type Decoder 

type Decoder struct {
	*astiencoder.BaseNode
	// contains filtered or unexported fields
}

Decoder represents an object capable of decoding packets

func NewDecoder 

func NewDecoder(o DecoderOptions, eh *astiencoder.EventHandler, c *astikit.Closer, s *astiencoder.Stater) (d *Decoder, err error)

NewDecoder creates a new decoder

func (*Decoder) Connect 

func (d *Decoder) Connect(h FrameHandler)

Connect implements the FrameHandlerConnector interface

func (*Decoder) Disconnect 

func (d *Decoder) Disconnect(h FrameHandler)

Disconnect implements the FrameHandlerConnector interface

func (*Decoder) HandlePkt 

func (d *Decoder) HandlePkt(p PktHandlerPayload)

HandlePkt implements the PktHandler interface

func (*Decoder) OutputCtx added in v0.8.0 

func (d *Decoder) OutputCtx() Context

OutputCtx returns the output ctx

func (*Decoder) Start 

func (d *Decoder) Start(ctx context.Context, t astiencoder.CreateTaskFunc)

Start starts the decoder

type DecoderOptions 

type DecoderOptions struct {
	CodecParameters *astiav.CodecParameters
	Name            string
	Node            astiencoder.NodeOptions
	OutputCtx       Context
}

DecoderOptions represents decoder options

type Demuxer 

type Demuxer struct {
	*astiencoder.BaseNode
	// contains filtered or unexported fields
}

Demuxer represents an object capable of demuxing packets out of an input

func NewDemuxer 

func NewDemuxer(o DemuxerOptions, eh *astiencoder.EventHandler, c *astikit.Closer, s *astiencoder.Stater) (d *Demuxer, err error)

NewDemuxer creates a new demuxer

func (*Demuxer) Connect 

func (d *Demuxer) Connect(h PktHandler)

Connect implements the PktHandlerConnector interface

func (*Demuxer) ConnectForStream 

func (d *Demuxer) ConnectForStream(h PktHandler, i *Stream)

ConnectForStream connects the demuxer to a PktHandler for a specific stream

func (*Demuxer) Disconnect 

func (d *Demuxer) Disconnect(h PktHandler)

Disconnect implements the PktHandlerConnector interface

func (*Demuxer) DisconnectForStream 

func (d *Demuxer) DisconnectForStream(h PktHandler, i *Stream)

DisconnectForStream disconnects the demuxer from a PktHandler for a specific stream

func (*Demuxer) SetLoop added in v0.21.0 

func (d *Demuxer) SetLoop(loop bool)

func (*Demuxer) Start 

func (d *Demuxer) Start(ctx context.Context, t astiencoder.CreateTaskFunc)

Start starts the demuxer

func (*Demuxer) Streams added in v0.14.0 

func (d *Demuxer) Streams() (ss []*Stream)

Streams returns the streams ordered by index

type DemuxerOptions 

type DemuxerOptions struct {
	// String content of the demuxer as you would use in ffmpeg
	Dictionary *Dictionary
	// If true, the demuxer will sleep between packets for the exact duration of the packet
	EmulateRate bool
	// Max duration of continuous packets of the same stream the demuxer receives has to be
	// inferior to this value.
	// Defaults to 1s
	EmulateRateBufferDuration time.Duration
	// Exact input format
	Format *astiav.InputFormat
	// If true, at the end of the input the demuxer will seek to its beginning and start over
	// In this case the packets are restamped
	Loop bool
	// Basic node options
	Node astiencoder.NodeOptions
	// Context used to cancel probing
	ProbeCtx context.Context
	// Custom read frame error handler
	// If handled is false, default error handling will be executed
	ReadFrameErrorHandler DemuxerReadFrameErrorHandler
	// URL of the input
	URL string
}

DemuxerOptions represents demuxer options

type DemuxerReadFrameErrorHandler added in v0.14.0 

type DemuxerReadFrameErrorHandler func(d *Demuxer, err error) (stop, handled bool)

type Descriptor 

type Descriptor interface {
	TimeBase() astiav.Rational
}

Descriptor is an object that can describe a set of parameters

func NewDescriptor added in v0.14.0 

func NewDescriptor(timeBase astiav.Rational) Descriptor

type Dictionary added in v0.23.0 

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

func NewDefaultDictionary added in v0.23.0 

func NewDefaultDictionary(i string) *Dictionary

func NewDefaultDictionaryf added in v0.23.0 

func NewDefaultDictionaryf(format string, args ...interface{}) *Dictionary

func NewDictionary added in v0.23.0 

func NewDictionary(content, keyValSep, pairsSep string, flags astiav.DictionaryFlags) *Dictionary

type Encoder 

type Encoder struct {
	*astiencoder.BaseNode
	// contains filtered or unexported fields
}

Encoder represents an object capable of encoding frames

func NewEncoder 

func NewEncoder(o EncoderOptions, eh *astiencoder.EventHandler, c *astikit.Closer, s *astiencoder.Stater) (e *Encoder, err error)

NewEncoder creates a new encoder

func (*Encoder) AddStream 

func (e *Encoder) AddStream(formatCtx *astiav.FormatContext) (o *astiav.Stream, err error)

AddStream adds a stream based on the codec ctx

func (*Encoder) Connect 

func (e *Encoder) Connect(h PktHandler)

Connect implements the PktHandlerConnector interface

func (*Encoder) Disconnect 

func (e *Encoder) Disconnect(h PktHandler)

Disconnect implements the PktHandlerConnector interface

func (*Encoder) FrameSize 

func (e *Encoder) FrameSize() int

FrameSize returns the encoder frame size

func (*Encoder) HandleFrame 

func (e *Encoder) HandleFrame(p FrameHandlerPayload)

HandleFrame implements the FrameHandler interface

func (*Encoder) Start 

func (e *Encoder) Start(ctx context.Context, t astiencoder.CreateTaskFunc)

Start starts the encoder

type EncoderOptions 

type EncoderOptions struct {
	Ctx  Context
	Node astiencoder.NodeOptions
}

EncoderOptions represents encoder options

type EventLog added in v0.11.0 

type EventLog struct {
	Fmt    string
	Level  astiav.LogLevel
	Msg    string
	Parent string
}

type Filterer 

type Filterer struct {
	*astiencoder.BaseNode
	// contains filtered or unexported fields
}

Filterer represents an object capable of applying a filter to frames

func NewFilterer 

func NewFilterer(o FiltererOptions, eh *astiencoder.EventHandler, c *astikit.Closer, s *astiencoder.Stater) (f *Filterer, err error)

NewFilterer creates a new filterer

func (*Filterer) Connect 

func (f *Filterer) Connect(h FrameHandler)

Connect implements the FrameHandlerConnector interface

func (*Filterer) Disconnect 

func (f *Filterer) Disconnect(h FrameHandler)

Disconnect implements the FrameHandlerConnector interface

func (*Filterer) HandleFrame 

func (f *Filterer) HandleFrame(p FrameHandlerPayload)

HandleFrame implements the FrameHandler interface

func (*Filterer) OutputCtx added in v0.8.0 

func (f *Filterer) OutputCtx() Context

OutputCtx returns the output ctx

func (*Filterer) SendCommand 

func (f *Filterer) SendCommand(target, cmd, args string, fs astiav.FilterCommandFlags) (resp string, err error)

SendCommand sends a command to the filterer

func (*Filterer) Start 

func (f *Filterer) Start(ctx context.Context, t astiencoder.CreateTaskFunc)

Start starts the filterer

type FiltererOptions 

type FiltererOptions struct {
	Content     string
	EmulateRate astiav.Rational
	Inputs      map[string]astiencoder.Node
	Node        astiencoder.NodeOptions
	OutputCtx   Context
	Restamper   FrameRestamper
}

FiltererOptions represents filterer options

type Forwarder 

type Forwarder struct {
	*astiencoder.BaseNode
	// contains filtered or unexported fields
}

Forwarder represents an object capable of forwarding frames

func NewForwarder 

func NewForwarder(o ForwarderOptions, eh *astiencoder.EventHandler, c *astikit.Closer, s *astiencoder.Stater) (f *Forwarder)

NewForwarder creates a new forwarder

func (*Forwarder) Connect 

func (f *Forwarder) Connect(h FrameHandler)

Connect implements the FrameHandlerConnector interface

func (*Forwarder) Disconnect 

func (f *Forwarder) Disconnect(h FrameHandler)

Disconnect implements the FrameHandlerConnector interface

func (*Forwarder) HandleFrame 

func (f *Forwarder) HandleFrame(p FrameHandlerPayload)

HandleFrame implements the FrameHandler interface

func (*Forwarder) OutputCtx added in v0.8.0 

func (f *Forwarder) OutputCtx() Context

OutputCtx returns the output ctx

func (*Forwarder) Start 

func (f *Forwarder) Start(ctx context.Context, t astiencoder.CreateTaskFunc)

Start starts the forwarder

type ForwarderOptions 

type ForwarderOptions struct {
	Node      astiencoder.NodeOptions
	OutputCtx Context
	Restamper FrameRestamper
}

ForwarderOptions represents forwarder options

type FrameHandler 

type FrameHandler interface {
	astiencoder.Node
	HandleFrame(p FrameHandlerPayload)
}

FrameHandler represents a node that can handle a frame

type FrameHandlerConnector 

type FrameHandlerConnector interface {
	Connect(next FrameHandler)
	Disconnect(next FrameHandler)
}

FrameHandlerConnector represents an object that can connect/disconnect with a frame handler

type FrameHandlerPayload 

type FrameHandlerPayload struct {
	Descriptor Descriptor
	Frame      *astiav.Frame
	Node       astiencoder.Node
}

FrameHandlerPayload represents a FrameHandler payload

type FrameRestamper 

type FrameRestamper interface {
	Restamp(f *astiav.Frame)
}

FrameRestamper represents an object capable of restamping frames

func NewFrameRestamperWithFrameDuration 

func NewFrameRestamperWithFrameDuration(frameDuration int64) FrameRestamper

NewFrameRestamperWithFrameDuration creates a new frame restamper that starts timestamps from 0 and increments them of frameDuration frameDuration must be a duration in frame time base

func NewFrameRestamperWithModulo 

func NewFrameRestamperWithModulo(frameDuration int64) FrameRestamper

NewFrameRestamperWithModulo creates a new frame restamper that makes sure that PTS % frame duration = 0 frameDuration must be a duration in frame time base

type LoggerEventHandlerAdapterOptions added in v0.11.0 

type LoggerEventHandlerAdapterOptions struct {
	IgnoredLogMessages []*regexp.Regexp
}

type Muxer 

type Muxer struct {
	*astiencoder.BaseNode
	// contains filtered or unexported fields
}

Muxer represents an object capable of muxing packets into an output

func NewMuxer 

func NewMuxer(o MuxerOptions, eh *astiencoder.EventHandler, c *astikit.Closer, s *astiencoder.Stater) (m *Muxer, err error)

NewMuxer creates a new muxer

func (*Muxer) FormatContext added in v0.23.0 

func (m *Muxer) FormatContext() *astiav.FormatContext

func (*Muxer) NewPktHandler 

func (m *Muxer) NewPktHandler(o *astiav.Stream) *MuxerPktHandler

NewHandler creates

func (*Muxer) Start 

func (m *Muxer) Start(ctx context.Context, t astiencoder.CreateTaskFunc)

Start starts the muxer

type MuxerOptions 

type MuxerOptions struct {
	Format     *astiav.OutputFormat
	FormatName string
	Node       astiencoder.NodeOptions
	Restamper  PktRestamper
	URL        string
}

MuxerOptions represents muxer options

type MuxerPktHandler 

type MuxerPktHandler struct {
	*Muxer
	// contains filtered or unexported fields
}

MuxerPktHandler is an object that can handle a pkt for the muxer

func (*MuxerPktHandler) HandlePkt 

func (h *MuxerPktHandler) HandlePkt(p PktHandlerPayload)

HandlePkt implements the PktHandler interface

type OutputContexter added in v0.8.0 

type OutputContexter interface {
	OutputCtx() Context
}

type PktCond 

type PktCond interface {
	UsePkt(pkt *astiav.Packet) bool
}

PktCond represents an object that can decide whether to use a pkt

type PktDumper 

type PktDumper struct {
	*astiencoder.BaseNode
	// contains filtered or unexported fields
}

PktDumper represents an object capable of dumping packets

func NewPktDumper 

func NewPktDumper(o PktDumperOptions, eh *astiencoder.EventHandler, c *astikit.Closer, s *astiencoder.Stater) (d *PktDumper, err error)

NewPktDumper creates a new pk dumper

func (*PktDumper) HandlePkt 

func (d *PktDumper) HandlePkt(p PktHandlerPayload)

HandlePkt implements the PktHandler interface

func (*PktDumper) Start 

func (d *PktDumper) Start(ctx context.Context, t astiencoder.CreateTaskFunc)

Start starts the pkt dumper

type PktDumperHandlerArgs 

type PktDumperHandlerArgs struct {
	Pattern string
}

PktDumperHandlerArgs represents pkt dumper handler args

type PktDumperOptions 

type PktDumperOptions struct {
	Data    map[string]interface{}
	Handler func(pkt *astiav.Packet, args PktDumperHandlerArgs) error
	Node    astiencoder.NodeOptions
	Pattern string
}

PktDumperOptions represents pkt dumper options

type PktHandler 

type PktHandler interface {
	astiencoder.Node
	HandlePkt(p PktHandlerPayload)
}

PktHandler represents a node that can handle a pkt

type PktHandlerConnector 

type PktHandlerConnector interface {
	Connect(next PktHandler)
	Disconnect(next PktHandler)
}

PktHandlerConnector represents an object that can connect/disconnect with a pkt handler

type PktHandlerPayload 

type PktHandlerPayload struct {
	Descriptor Descriptor
	Node       astiencoder.Node
	Pkt        *astiav.Packet
}

PktHandlerPayload represents a PktHandler payload

type PktRestamper 

type PktRestamper interface {
	Restamp(pkt *astiav.Packet)
}

PktRestamper represents an object capable of restamping packets

type PktRestamperStartFromZero added in v0.14.0 

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

func NewPktRestamperStartFromZero 

func NewPktRestamperStartFromZero() *PktRestamperStartFromZero

NewPktRestamperStartFromZero creates a new pkt restamper that starts timestamps from 0

func (*PktRestamperStartFromZero) Restamp added in v0.14.0 

func (r *PktRestamperStartFromZero) Restamp(pkt *astiav.Packet)

Restamp implements the Restamper interface

type RateEnforcer 

type RateEnforcer struct {
	*astiencoder.BaseNode
	// contains filtered or unexported fields
}

RateEnforcer represents an object capable of enforcing rate based on PTS

func NewRateEnforcer 

func NewRateEnforcer(o RateEnforcerOptions, eh *astiencoder.EventHandler, c *astikit.Closer, s *astiencoder.Stater) (r *RateEnforcer)

NewRateEnforcer creates a new rate enforcer

func (*RateEnforcer) Connect 

func (r *RateEnforcer) Connect(h FrameHandler)

Connect implements the FrameHandlerConnector interface

func (*RateEnforcer) Disconnect 

func (r *RateEnforcer) Disconnect(h FrameHandler)

Disconnect implements the FrameHandlerConnector interface

func (*RateEnforcer) HandleFrame 

func (r *RateEnforcer) HandleFrame(p FrameHandlerPayload)

HandleFrame implements the FrameHandler interface

func (*RateEnforcer) OutputCtx added in v0.8.0 

func (r *RateEnforcer) OutputCtx() Context

OutputCtx returns the output ctx

func (*RateEnforcer) Start 

func (r *RateEnforcer) Start(ctx context.Context, t astiencoder.CreateTaskFunc)

Start starts the rate enforcer

func (*RateEnforcer) Switch 

func (r *RateEnforcer) Switch(n astiencoder.Node)

Switch switches the source

type RateEnforcerFiller added in v0.13.0 

type RateEnforcerFiller interface {
	Fill() (*astiav.Frame, astiencoder.Node)
	NoFill(*astiav.Frame, astiencoder.Node)
}

type RateEnforcerOptions 

type RateEnforcerOptions struct {
	AdaptSlotsToIncomingFrames bool
	// Expressed in number of frames in the output framerate
	Delay  uint
	Filler RateEnforcerFiller
	Node   astiencoder.NodeOptions
	// Both FrameRate and TimeBase are mandatory
	OutputCtx Context
	Restamper FrameRestamper
}

RateEnforcerOptions represents rate enforcer options

type Stream added in v0.14.0 

type Stream struct {
	CodecParameters *astiav.CodecParameters
	Ctx             Context
	ID              int
	Index           int
}

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.