rtp

package
v0.0.0-...-88258bf Latest Latest
Warning

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

 Go to latest Published: May 20, 2026 License: Apache-2.0 Imports: 21 Imported by: 21

Documentation

Index

Constants

View Source 
const (
	// DefClockRate is a default clock rate at which RTP timestamps increment.
	DefClockRate = 8000
	// DefFrameDur is a default duration of an audio frame.
	DefFrameDur = media.DefFrameDur
	// DefFramesPerSec is a default number of audio frames per second.
	DefFramesPerSec = media.DefFramesPerSec
)
View Source 
const (
	MTUSize = 1500
)

Variables

View Source 
var ErrListenFailed = errors.New("failed to listen on udp port")

Functions

func CodecByPayloadType 

func CodecByPayloadType(typ byte) media.Codec

func EncodePCM 

func EncodePCM(w *Stream, c media.AudioCodec) media.PCM16Writer

func HandleLoop 

func HandleLoop(r Reader, h HandlerCloser) error

func ListenUDPPortRange 

func ListenUDPPortRange(portMin, portMax int, ip netip.Addr) (*net.UDPConn, error)

func ListenUDPPortRangeWithConfig 

func ListenUDPPortRangeWithConfig(portMin, portMax int, ip netip.Addr, lc *net.ListenConfig) (*net.UDPConn, error)

func WriteAudio 

func WriteAudio[S BytesFrame](w *Stream, c media.AudioFrameCodec[S]) media.WriteCloser[S]

Types

type Buffer 

type Buffer []*Packet

Buffer is a Writer that clones and appends RTP packets into a slice.

func (*Buffer) String 

func (b *Buffer) String() string

func (*Buffer) WriteRTP 

func (b *Buffer) WriteRTP(h *rtp.Header, payload []byte) (int, error)

type BytesFrame 

type BytesFrame interface {
	media.BytesFrame
}

type Event 

type Event struct {
	Type      byte
	Timestamp uint32
	Payload   []byte
	Marker    bool
}

type Handler 

type Handler interface {
	String() string
	HandleRTP(h *rtp.Header, payload []byte) error
}

type HandlerCloser 

type HandlerCloser interface {
	Handler
	Close()
}

func DecodePCM 

func DecodePCM(w media.PCM16Writer, c media.AudioCodec, typ byte) HandlerCloser

func HandleAudio 

func HandleAudio[S BytesFrame](w media.WriteCloser[S], c media.AudioFrameCodec[S], typ byte) HandlerCloser

func HandleJitter 

func HandleJitter(h HandlerCloser, opts ...jitter.Option) HandlerCloser

func HandlePayload 

func HandlePayload(w media.BytesWriter, typ byte) HandlerCloser

func NewNopCloser 

func NewNopCloser(h Handler) HandlerCloser

type HandlerFunc 

type HandlerFunc func(h *rtp.Header, payload []byte) error

func (HandlerFunc) HandleRTP 

func (fnc HandlerFunc) HandleRTP(h *rtp.Header, payload []byte) error

func (HandlerFunc) String 

func (fnc HandlerFunc) String() string
type Header = rtp.Header

type MediaStreamIn 

type MediaStreamIn[T BytesFrame] struct {
	Writer media.Writer[T]
}

func NewMediaStreamIn 

func NewMediaStreamIn[T BytesFrame](w media.Writer[T]) *MediaStreamIn[T]

func (*MediaStreamIn[T]) HandleRTP 

func (s *MediaStreamIn[T]) HandleRTP(_ *rtp.Header, payload []byte) error

func (*MediaStreamIn[T]) String 

func (s *MediaStreamIn[T]) String() string

type MediaStreamOut 

type MediaStreamOut[T BytesFrame] struct {
	// contains filtered or unexported fields
}

func NewMediaStreamOut 

func NewMediaStreamOut[T BytesFrame](s *Stream, sampleRate int) *MediaStreamOut[T]

func (*MediaStreamOut[T]) Close 

func (s *MediaStreamOut[T]) Close() error

func (*MediaStreamOut[T]) SampleRate 

func (s *MediaStreamOut[T]) SampleRate() int

func (*MediaStreamOut[T]) String 

func (s *MediaStreamOut[T]) String() string

func (*MediaStreamOut[T]) WriteSample 

func (s *MediaStreamOut[T]) WriteSample(sample T) error

type Mux 

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

func NewMux 

func NewMux(def Handler) *Mux

NewMux creates an RTP handler mux that selects a Handler based on RTP payload type. See Mux.HandleRTP for details.

func (*Mux) HandleRTP 

func (m *Mux) HandleRTP(h *rtp.Header, payload []byte) error

HandleRTP selects a Handler based on payload type. Types can be registered with Register. If no handler is set, a default one will be used.

func (*Mux) Register 

func (m *Mux) Register(typ byte, h Handler)

Register RTP handler for a payload type. Setting nil removes the handler.

func (*Mux) SetDefault 

func (m *Mux) SetDefault(h Handler)

SetDefault sets a default RTP handler. Setting nil will drop packets with unregistered type.

func (*Mux) String 

func (m *Mux) String() string

type Packet 

type Packet = rtp.Packet

type ReadStream 

type ReadStream interface {
	// ReadRTP reads RTP packet and its header from the connection.
	ReadRTP(h *rtp.Header, payload []byte) (int, error)
}

type Reader 

type Reader interface {
	ReadRTP() (*rtp.Packet, interceptor.Attributes, error)
}

type SeqWriter 

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

func NewSeqWriter 

func NewSeqWriter(w Writer) *SeqWriter

NewSeqWriter creates an RTP writer that automatically increments the sequence number.

func (*SeqWriter) CurTS 

func (s *SeqWriter) CurTS(ts, inc uint32) uint32

CurTS requests a timestamp from the stream, using ts as a reference. The function may return timestamp as-is or may adjust it to catch up with other active streams.

func (*SeqWriter) NewStream 

func (s *SeqWriter) NewStream(typ byte, clockRate int) *Stream

NewStream creates a new media stream in RTP and tracks timestamps associated with it.

func (*SeqWriter) NewStreamWithDur 

func (s *SeqWriter) NewStreamWithDur(typ byte, packetDur uint32) *Stream

func (*SeqWriter) String 

func (s *SeqWriter) String() string

func (*SeqWriter) WriteEvent 

func (s *SeqWriter) WriteEvent(ev *Event) error

type Session 

type Session interface {
	OpenWriteStream() (WriteStream, error)
	AcceptStream() (ReadStream, uint32, error)
	Close() error
}

func NewSession 

func NewSession(log logger.Logger, conn net.Conn) Session

type Stream 

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

func (*Stream) Close 

func (s *Stream) Close() error

func (*Stream) Delay 

func (s *Stream) Delay(dur uint32)

Delay advances the timestamp of the next frame. Typically used in combination with WritePayloadAtCurrent.

func (*Stream) DelayN 

func (s *Stream) DelayN(n int)

DelayN is similar to Delay, but it increments time in multiples of the frame durations.

func (*Stream) GetCurrentTimestamp 

func (s *Stream) GetCurrentTimestamp() uint32

func (*Stream) ResetTimestamp 

func (s *Stream) ResetTimestamp(ts uint32)

func (*Stream) String 

func (s *Stream) String() string

func (*Stream) WritePayload 

func (s *Stream) WritePayload(data []byte, marker bool) error

WritePayload writes the payload to RTP and increments the timestamp.

func (*Stream) WritePayloadAtCurrent 

func (s *Stream) WritePayloadAtCurrent(data []byte, marker bool) error

WritePayloadAtCurrent writes the payload to RTP at the current timestamp. This allows to emit multiple different payloads with the same timestamp in this stream (e.g. DTMF). The caller is expected to call Delay or DelayN at some point to advances the timestamp.

func (*Stream) WriteRaw 

func (s *Stream) WriteRaw(data []byte) error

type WriteStream 

type WriteStream interface {
	String() string
	// WriteRTP writes RTP packet to the connection.
	WriteRTP(h *rtp.Header, payload []byte) (int, error)
}

type Writer 

type Writer interface {
	String() string
	WriteRTP(h *rtp.Header, payload []byte) (int, error)
}

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.