astilibav

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

type AdaptiveDelayerOptions struct {
	LookBehind      time.Duration
	MarginGoingDown time.Duration
	MarginGoingUp   time.Duration
	Minimum         time.Duration
	Step            time.Duration
	StepsCount      uint
}

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

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
}

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

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

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

type Delayer interface {
	Apply(t time.Time) time.Time
	Delay() time.Duration
	HandleFrame(delay time.Duration, n astiencoder.Node)
}

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

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
}

type DemuxerLoopOptions struct {
	Enabled bool
}

type DemuxerOptions struct {
	// String content of the demuxer as you would use in ffmpeg
	Dictionary *Dictionary
	// Emulate rate options
	EmulateRate DemuxerEmulateRateOptions
	// If true, flushes internal data on start
	FlushOnStart bool
	// 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
}

type DemuxerProbeInfo struct {
	FirstPTS DemuxerProbeInfoFirstPTS
}

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 func(d *Demuxer, err error) (stop, handled bool)

type DemuxerStats struct {
	BytesRead         uint64
	PacketsAllocated  uint64
	PacketsDispatched uint64
}

type Descriptor interface {
	TimeBase() astiav.Rational
}

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

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

type EncoderOptions struct {
	Ctx  Context
	Node astiencoder.NodeOptions
}

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

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

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

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

type FiltererFrameHandlerStrategy string

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

type FiltererInputContextChanges map[astiencoder.Node]FiltererInputContextChange

type FiltererOnInputContextChangesFunc func(cs FiltererInputContextChanges, f *Filterer) (ignore bool)

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

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

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

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

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

type FrameAdapter func(f *astiav.Frame) error

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

type FrameFillerFallbackFrameOptions struct {
	Frame        *astiav.Frame
	FrameAdapter FrameAdapter
	Node         astiencoder.Node
}

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

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

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

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

type FrameInterceptorHandler func(f *astiav.Frame, i *FrameInterceptor) error

type FrameInterceptorOptions struct {
	Handler   FrameInterceptorHandler
	Node      astiencoder.NodeOptions
	OutputCtx Context
}

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

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

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

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

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

type FrameRestamperOffseter interface {
	Offset(f *astiav.Frame, frameDuration int64, timeBase astiav.Rational) int64
}

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

type FrameRestamperStartPTSFunc func() int64

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

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

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

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

type OutputContexter interface {
	OutputCtx() Context
}

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

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

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

type PktDumperHandlerArgs struct {
	Pattern string
}

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

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

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

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

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

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

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

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

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

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

type RateEnforcerOptions struct {
	Delayer     Delayer
	FrameFiller *FrameFiller
	Node        astiencoder.NodeOptions
	// Both FrameRate and TimeBase are mandatory
	OutputCtx    Context
	PTSReference *PTSReference
	Restamper    FrameRestamper
}

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

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

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

type SwitcherOptions struct {
	FrameDuration int64
	FrameTimeout  time.Duration
	Node          astiencoder.NodeOptions
	OutputCtx     Context
}

type SwitcherStats struct {
	FramesAllocated  uint64
	FramesDispatched uint64
	FramesProcessed  uint64
	FramesReceived   uint64
	WorkDuration     time.Duration
}