astilibav

package
v0.40.0 Latest Latest
Warning

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

 Go to latest Published: Apr 3, 2023 License: MIT Imports: 16 Imported by: 0

Documentation

Index

Constants

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

Event names

View Source 
const (
	StatNameAllocatedFrames  = "astilibav.allocated.frames"
	StatNameAllocatedPackets = "astilibav.allocated.packets"
	StatNameAverageDelay     = "astilibav.average.delay"
	StatNameFilledRate       = "astilibav.filled.rate"
	StatNameIncomingRate     = "astilibav.incoming.rate"
	StatNameOutgoingRate     = "astilibav.outgoing.rate"
	StatNameProcessedRate    = "astilibav.processed.rate"
	StatNameReadRate         = "astilibav.read.rate"
	StatNameWrittenRate      = "astilibav.written.rate"
)

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 EventHandlerLogAdapter added in v0.33.1 

func EventHandlerLogAdapter(o EventHandlerLogAdapterOptions) astiencoder.EventHandlerLogAdapter

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
	FrameSize     int
	SampleFormat  astiav.SampleFormat
	SampleRate    int

	// Video
	ColorRange        astiav.ColorRange
	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

func (*Decoder) Stats added in v0.36.0 

func (d *Decoder) Stats() DecoderStats

type DecoderOptions 

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

DecoderOptions represents decoder options

type DecoderStats added in v0.36.0 

type DecoderStats struct {
	BytesReceived    uint64
	FramesAllocated  uint64
	FramesDispached  uint64
	PacketsAllocated uint64
	PacketsProcessed uint64
	PacketsReceived  uint64
	WorkDuration     time.Duration
}

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) ProbeInfo added in v0.32.0 

func (d *Demuxer) ProbeInfo() *DemuxerProbeInfo

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) Stats added in v0.36.0 

func (d *Demuxer) Stats() DemuxerStats

func (*Demuxer) Streams added in v0.14.0 

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

Streams returns the streams ordered by index

type DemuxerEmulateRateOptions added in v0.32.0 

type DemuxerEmulateRateOptions struct {
	// BufferDuration represents the duration of packets with positive PTS dispatched at the
	// start without sleeping.
	// Defaults to 1s
	BufferDuration time.Duration
	Enabled        bool
}

Demuxer will start by dispatching without sleeping all packets with negative PTS followed by n seconds of packets so that next nodes (e.g. the decoder) have a sufficient buffer to do their work properly (e.g. decoders don't output frames until their PTS is positive). After that, Demuxer sleeps between packets based on their DTS.

type DemuxerLoopOptions added in v0.32.0 

type DemuxerLoopOptions struct {
	Enabled bool
}

Demuxer will seek back to the start of the input when eof is reached In this case the packets are restamped

type DemuxerOptions 

type DemuxerOptions struct {
	// String content of the demuxer as you would use in ffmpeg
	Dictionary *Dictionary
	// Emulate rate options
	EmulateRate DemuxerEmulateRateOptions
	// Exact input format
	Format *astiav.InputFormat
	// Loop options
	Loop DemuxerLoopOptions
	// Basic node options
	Node astiencoder.NodeOptions
	// Context used to cancel probing
	ProbeCtx context.Context
	// In order to emulate rate or loop properly, Demuxer needs to probe data.
	// ProbeDuration represents the duration the Demuxer will probe.
	// Defaults to 1s
	ProbeDuration time.Duration
	// 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 DemuxerProbeInfo added in v0.32.0 

type DemuxerProbeInfo struct {
	FirstPTS DemuxerProbeInfoFirstPTS
}

func (DemuxerProbeInfo) PTSReference added in v0.32.0 

func (i DemuxerProbeInfo) PTSReference() *PTSReference

type DemuxerProbeInfoFirstPTS added in v0.32.0 

type DemuxerProbeInfoFirstPTS struct {
	// Streams whose first pts is the same as the overall first pts.
	// Indexed by stream index
	Streams  map[int]bool
	Timebase astiav.Rational
	Value    int64
}

type DemuxerReadFrameErrorHandler added in v0.14.0 

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

type DemuxerStats added in v0.36.0 

type DemuxerStats struct {
	BytesRead         uint64
	PacketsAllocated  uint64
	PacketsDispatched uint64
}

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

func (*Encoder) Stats added in v0.36.0 

func (e *Encoder) Stats() EncoderStats

type EncoderOptions 

type EncoderOptions struct {
	Ctx  Context
	Node astiencoder.NodeOptions
}

EncoderOptions represents encoder options

type EncoderStats added in v0.36.0 

type EncoderStats struct {
	FramesAllocated  uint64
	FramesProcessed  uint64
	FramesReceived   uint64
	PacketsAllocated uint64
	PacketsDispached uint64
	WorkDuration     time.Duration
}

type EventHandlerLogAdapterOptions added in v0.33.1 

type EventHandlerLogAdapterOptions struct {
	LogLevel        astiav.LogLevel
	LoggerLevelFunc func(l astiav.LogLevel) (ll astikit.LoggerLevel, processed, stop bool)
}

type EventLog added in v0.11.0 

type EventLog struct {
	Format 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

func (*Filterer) Stats added in v0.36.0 

func (f *Filterer) Stats() FiltererStats

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 FiltererStats added in v0.36.0 

type FiltererStats struct {
	FramesAllocated uint64
	FramesDispached uint64
	FramesProcessed uint64
	FramesReceived  uint64
	WorkDuration    time.Duration
}

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

func (*Forwarder) Stats added in v0.36.0 

func (f *Forwarder) Stats() ForwarderStats

type ForwarderOptions 

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

ForwarderOptions represents forwarder options

type ForwarderStats added in v0.36.0 

type ForwarderStats struct {
	FramesAllocated uint64
	FramesDispached uint64
	FramesProcessed uint64
	FramesReceived  uint64
	WorkDuration    time.Duration
}

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 FrameRateEmulator added in v0.32.0 

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

func NewFrameRateEmulator added in v0.32.0 

func NewFrameRateEmulator(o FrameRateEmulatorOptions, eh *astiencoder.EventHandler, c *astikit.Closer, s *astiencoder.Stater) (r *FrameRateEmulator)

func (*FrameRateEmulator) Connect added in v0.32.0 

func (r *FrameRateEmulator) Connect(h FrameHandler)

Connect implements the FrameHandlerConnector interface

func (*FrameRateEmulator) Disconnect added in v0.32.0 

func (r *FrameRateEmulator) Disconnect(h FrameHandler)

Disconnect implements the FrameHandlerConnector interface

func (*FrameRateEmulator) HandleFrame added in v0.32.0 

func (r *FrameRateEmulator) HandleFrame(p FrameHandlerPayload)

HandleFrame implements the FrameHandler interface

func (*FrameRateEmulator) OutputCtx added in v0.32.0 

func (r *FrameRateEmulator) OutputCtx() Context

OutputCtx returns the output ctx

func (*FrameRateEmulator) SetFlushOnStop added in v0.32.1 

func (r *FrameRateEmulator) SetFlushOnStop(flushOnStop bool)

func (*FrameRateEmulator) Start added in v0.32.0 

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

Start starts the frame rate emulator

func (*FrameRateEmulator) Stats added in v0.36.0 

func (r *FrameRateEmulator) Stats() FrameRateEmulatorStats

type FrameRateEmulatorOptions added in v0.32.0 

type FrameRateEmulatorOptions struct {
	FlushOnStop  bool
	Node         astiencoder.NodeOptions
	OutputCtx    Context
	PTSReference *PTSReference
}

type FrameRateEmulatorStats added in v0.36.0 

type FrameRateEmulatorStats struct {
	FramesAllocated uint64
	FramesDispached uint64
	FramesProcessed uint64
	FramesReceived  uint64
	WorkDuration    time.Duration
}

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

func (*Muxer) Stats added in v0.36.0 

func (m *Muxer) Stats() MuxerStats

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 MuxerStats added in v0.36.0 

type MuxerStats struct {
	BytesWritten     uint64
	PacketsAllocated uint64
	PacketsProcessed uint64
	PacketsReceived  uint64
	WorkDuration     time.Duration
}

type OutputContexter added in v0.8.0 

type OutputContexter interface {
	OutputCtx() Context
}

type PTSReference added in v0.32.0 

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

func NewPTSReference added in v0.39.0 

func NewPTSReference() *PTSReference

func (PTSReference) PTSFromTime added in v0.39.0 

func (r PTSReference) PTSFromTime(t time.Time, timeBase astiav.Rational) int64

func (PTSReference) TimeFromPTS added in v0.39.0 

func (r PTSReference) TimeFromPTS(pts int64, timeBase astiav.Rational) time.Time

func (*PTSReference) Update added in v0.39.0 

func (r *PTSReference) Update(pts int64, t time.Time, timeBase astiav.Rational) *PTSReference

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

func (*PktDumper) Stats added in v0.36.0 

func (d *PktDumper) Stats() PktDumperStats

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 PktDumperStats added in v0.36.0 

type PktDumperStats struct {
	PacketsAllocated uint64
	PacketsProcessed uint64
	PacketsReceived  uint64
	WorkDuration     time.Duration
}

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 PktPiper added in v0.28.0 

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

PktPiper represents an object capable of piping pkts

func NewPktPiper added in v0.28.0 

func NewPktPiper(o PktPiperOptions, eh *astiencoder.EventHandler, c *astikit.Closer, s *astiencoder.Stater) (p *PktPiper)

NewPktPiper creates a new pkt piper

func (*PktPiper) Connect added in v0.28.0 

func (p *PktPiper) Connect(h PktHandler)

Connect implements the PktHandlerConnector interface

func (*PktPiper) Disconnect added in v0.28.0 

func (p *PktPiper) Disconnect(h PktHandler)

Disconnect implements the PktHandlerConnector interface

func (*PktPiper) OutputCtx added in v0.28.0 

func (p *PktPiper) OutputCtx() Context

OutputCtx returns the output ctx

func (*PktPiper) Pipe added in v0.28.0 

func (p *PktPiper) Pipe(data []byte)

func (*PktPiper) Start added in v0.28.0 

func (p *PktPiper) Start(ctx context.Context, t astiencoder.CreateTaskFunc)

Start starts the piper

func (*PktPiper) Stats added in v0.36.0 

func (p *PktPiper) Stats() PktPiperStats

type PktPiperOptions added in v0.28.0 

type PktPiperOptions struct {
	Node      astiencoder.NodeOptions
	OutputCtx Context
	Restamper PktRestamper
}

PktPiperOptions represents pkt piper options

type PktPiperStats added in v0.36.0 

type PktPiperStats struct {
	PacketsAllocated  uint64
	PacketsDispatched uint64
	PacketsProcessed  uint64
	PacketsReceived   uint64
	WorkDuration      time.Duration
}

type PktRestamper 

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

PktRestamper represents an object capable of restamping packets

func NewPktRestamperStartFromZero 

func NewPktRestamperStartFromZero() PktRestamper

NewPktRestamperStartFromZero creates a new pkt restamper that starts timestamps from 0

func NewPktRestamperWithTime added in v0.28.0 

func NewPktRestamperWithTime(fillGaps bool, frameDuration int64, timeBase astiav.Rational) PktRestamper

NewPktRestamperWithTime creates a new pkt restamper that computes timestamps based on the time at which restamping was requested "fillGaps" option allows to:

  • assign the current pkt to the previous DTS if previous DTS was never assigned
  • assign the current pkt to the next DTS if current DTS is the same as previous DTS

"frameDuration" must be a duration in frame time base

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) Stats added in v0.36.0 

func (r *RateEnforcer) Stats() RateEnforcerStats

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 {
	Delay  time.Duration
	Filler RateEnforcerFiller
	Node   astiencoder.NodeOptions
	// Both FrameRate and TimeBase are mandatory
	OutputCtx     Context
	PTSReferences map[astiencoder.Node]*PTSReference
	Restamper     FrameRestamper
}

RateEnforcerOptions represents rate enforcer options

type RateEnforcerStats added in v0.36.0 

type RateEnforcerStats struct {
	FramesAllocated uint64
	FramesDelay     time.Duration
	FramesDispached uint64
	FramesFilled    uint64
	FramesProcessed uint64
	FramesReceived  uint64
	WorkDuration    time.Duration
}

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.