Skip to main content

Overview

RTPTransceiver represents a combination of an RTPSender and an RTPReceiver that share a common mid. It manages the bidirectional flow of media data in a WebRTC connection.

Type Definition

type RTPTransceiver struct {
    mid                    atomic.Value // string
    sender                 atomic.Value // *RTPSender
    receiver               atomic.Value // *RTPReceiver
    direction              atomic.Value // RTPTransceiverDirection
    currentDirection       atomic.Value // RTPTransceiverDirection
    currentRemoteDirection atomic.Value // RTPTransceiverDirection
    codecs                 []RTPCodecParameters
    kind                   RTPCodecType
    api                    *API
    mu                     sync.RWMutex
}

Methods

SetCodecPreferences

Sets the preferred list of supported codecs. If codecs is empty or nil, resets to default from MediaEngine.
func (t *RTPTransceiver) SetCodecPreferences(codecs []RTPCodecParameters) error
codecs
[]RTPCodecParameters
List of codec parameters to set as preferences. Pass empty slice or nil to reset to defaults.
error
error
Returns error if codec is not supported by the MediaEngine
// Set H.264 as the preferred video codec
codecs := []webrtc.RTPCodecParameters{
    {
        RTPCodecCapability: webrtc.RTPCodecCapability{
            MimeType:  webrtc.MimeTypeH264,
            ClockRate: 90000,
        },
        PayloadType: 102,
    },
}

err := transceiver.SetCodecPreferences(codecs)
if err != nil {
    panic(err)
}

Sender

Returns the RTPTransceiver’s RTPSender if it has one.
func (t *RTPTransceiver) Sender() *RTPSender
sender
*RTPSender
The associated RTPSender, or nil if none exists

SetSender

Sets the RTPSender and Track to the current transceiver.
func (t *RTPTransceiver) SetSender(s *RTPSender, track TrackLocal) error
s
*RTPSender
required
The RTPSender to associate with this transceiver
track
TrackLocal
required
The local track to send

Receiver

Returns the RTPTransceiver’s RTPReceiver if it has one.
func (t *RTPTransceiver) Receiver() *RTPReceiver
receiver
*RTPReceiver
The associated RTPReceiver, or nil if none exists

SetMid

Sets the RTPTransceiver’s mid. If it was already set, returns an error.
func (t *RTPTransceiver) SetMid(mid string) error
mid
string
required
The media ID to set for this transceiver
error
error
Returns error if mid is already set

Mid

Gets the Transceiver’s mid value. When not already set, this value will be set in CreateOffer or CreateAnswer.
func (t *RTPTransceiver) Mid() string
mid
string
The media ID, or empty string if not yet set

Kind

Returns the RTPTransceiver’s kind (audio or video).
func (t *RTPTransceiver) Kind() RTPCodecType
kind
RTPCodecType
The codec type (RTPCodecTypeAudio or RTPCodecTypeVideo)

Direction

Returns the RTPTransceiver’s current direction.
func (t *RTPTransceiver) Direction() RTPTransceiverDirection
direction
RTPTransceiverDirection
The current direction (sendrecv, sendonly, recvonly, or inactive)

Stop

Irreversibly stops the RTPTransceiver.
func (t *RTPTransceiver) Stop() error
error
error
Returns error if stopping the sender or receiver fails
transceiver := pc.AddTransceiverFromKind(webrtc.RTPCodecTypeVideo)

// Later...
if err := transceiver.Stop(); err != nil {
    panic(err)
}
After calling Stop(), the transceiver’s direction is set to inactive and cannot be changed.

Usage Examples

Creating and Configuring a Transceiver

// Add a transceiver for video
transceiver, err := pc.AddTransceiverFromKind(webrtc.RTPCodecTypeVideo, webrtc.RTPTransceiverInit{
    Direction: webrtc.RTPTransceiverDirectionSendrecv,
})
if err != nil {
    panic(err)
}

// Check the transceiver properties
fmt.Println("Mid:", transceiver.Mid())
fmt.Println("Kind:", transceiver.Kind())
fmt.Println("Direction:", transceiver.Direction())

Setting Codec Preferences

// Prefer VP8 over other video codecs
codecs := []webrtc.RTPCodecParameters{
    {
        RTPCodecCapability: webrtc.RTPCodecCapability{
            MimeType:  webrtc.MimeTypeVP8,
            ClockRate: 90000,
        },
        PayloadType: 96,
    },
}

if err := transceiver.SetCodecPreferences(codecs); err != nil {
    panic(err)
}

Accessing Sender and Receiver

// Get the sender
sender := transceiver.Sender()
if sender != nil {
    track := sender.Track()
    fmt.Println("Sender track:", track)
}

// Get the receiver
receiver := transceiver.Receiver()
if receiver != nil {
    track := receiver.Track()
    fmt.Println("Receiver track:", track)
}

See Also

Build docs developers (and LLMs) love