mirror of
https://github.com/pion/webrtc.git
synced 2025-09-27 03:25:58 +08:00
6ef2888a26
Add nil pointer check when calling SetReadDeadline. I don't believe this can happen with WebRTC, but is possible with `ortc`. A future improvement would be to cache the `SetReadDeadline` call. At this time the complexity seems to outweight the reward. Resolves #2889
561 lines
16 KiB
Go
561 lines
16 KiB
Go
// SPDX-FileCopyrightText: 2023 The Pion community <https://pion.ly>
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
//go:build !js
|
|
// +build !js
|
|
|
|
package webrtc
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/pion/interceptor"
|
|
"github.com/pion/transport/v3/test"
|
|
"github.com/pion/webrtc/v4/pkg/media"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func Test_RTPSender_ReplaceTrack(t *testing.T) { //nolint:cyclop
|
|
lim := test.TimeOut(time.Second * 10)
|
|
defer lim.Stop()
|
|
|
|
report := test.CheckRoutines(t)
|
|
defer report()
|
|
|
|
s := SettingEngine{}
|
|
s.DisableSRTPReplayProtection(true)
|
|
|
|
sender, receiver, err := NewAPI(WithSettingEngine(s)).newPair(Configuration{})
|
|
assert.NoError(t, err)
|
|
|
|
trackA, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
trackB, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeH264}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err := sender.AddTrack(trackA)
|
|
assert.NoError(t, err)
|
|
|
|
seenPacketA, seenPacketACancel := context.WithCancel(context.Background())
|
|
seenPacketB, seenPacketBCancel := context.WithCancel(context.Background())
|
|
|
|
var onTrackCount uint64
|
|
receiver.OnTrack(func(track *TrackRemote, _ *RTPReceiver) {
|
|
assert.Equal(t, uint64(1), atomic.AddUint64(&onTrackCount, 1))
|
|
|
|
for {
|
|
pkt, _, err := track.ReadRTP()
|
|
if err != nil {
|
|
assert.True(t, errors.Is(err, io.EOF))
|
|
|
|
return
|
|
}
|
|
|
|
switch {
|
|
case pkt.Payload[len(pkt.Payload)-1] == 0xAA:
|
|
assert.Equal(t, track.Codec().MimeType, MimeTypeVP8)
|
|
seenPacketACancel()
|
|
case pkt.Payload[len(pkt.Payload)-1] == 0xBB:
|
|
assert.Equal(t, track.Codec().MimeType, MimeTypeH264)
|
|
seenPacketBCancel()
|
|
default:
|
|
assert.Failf(t, "Unexpected RTP", "Data % 02x", pkt.Payload[len(pkt.Payload)-1])
|
|
}
|
|
}
|
|
})
|
|
|
|
assert.NoError(t, signalPair(sender, receiver))
|
|
|
|
// Block Until packet with 0xAA has been seen
|
|
func() {
|
|
for range time.Tick(time.Millisecond * 20) {
|
|
select {
|
|
case <-seenPacketA.Done():
|
|
return
|
|
default:
|
|
assert.NoError(t, trackA.WriteSample(media.Sample{Data: []byte{0xAA}, Duration: time.Second}))
|
|
}
|
|
}
|
|
}()
|
|
|
|
assert.NoError(t, rtpSender.ReplaceTrack(trackB))
|
|
|
|
// Block Until packet with 0xBB has been seen
|
|
func() {
|
|
for range time.Tick(time.Millisecond * 20) {
|
|
select {
|
|
case <-seenPacketB.Done():
|
|
return
|
|
default:
|
|
assert.NoError(t, trackB.WriteSample(media.Sample{Data: []byte{0xBB}, Duration: time.Second}))
|
|
}
|
|
}
|
|
}()
|
|
|
|
closePairNow(t, sender, receiver)
|
|
}
|
|
|
|
func Test_RTPSender_GetParameters(t *testing.T) {
|
|
lim := test.TimeOut(time.Second * 10)
|
|
defer lim.Stop()
|
|
|
|
report := test.CheckRoutines(t)
|
|
defer report()
|
|
|
|
offerer, answerer, err := newPair()
|
|
assert.NoError(t, err)
|
|
|
|
rtpTransceiver, err := offerer.AddTransceiverFromKind(RTPCodecTypeVideo)
|
|
assert.NoError(t, err)
|
|
|
|
assert.NoError(t, signalPair(offerer, answerer))
|
|
|
|
parameters := rtpTransceiver.Sender().GetParameters()
|
|
assert.NotEqual(t, 0, len(parameters.Codecs))
|
|
assert.Equal(t, 1, len(parameters.Encodings))
|
|
assert.Equal(t, rtpTransceiver.Sender().trackEncodings[0].ssrc, parameters.Encodings[0].SSRC)
|
|
assert.Equal(t, "", parameters.Encodings[0].RID)
|
|
|
|
closePairNow(t, offerer, answerer)
|
|
}
|
|
|
|
func Test_RTPSender_GetParameters_WithRID(t *testing.T) {
|
|
lim := test.TimeOut(time.Second * 10)
|
|
defer lim.Stop()
|
|
|
|
report := test.CheckRoutines(t)
|
|
defer report()
|
|
|
|
offerer, answerer, err := newPair()
|
|
assert.NoError(t, err)
|
|
|
|
rtpTransceiver, err := offerer.AddTransceiverFromKind(RTPCodecTypeVideo)
|
|
assert.NoError(t, err)
|
|
|
|
assert.NoError(t, signalPair(offerer, answerer))
|
|
|
|
track, err := NewTrackLocalStaticSample(
|
|
RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion", WithRTPStreamID("moo"),
|
|
)
|
|
assert.NoError(t, err)
|
|
|
|
err = rtpTransceiver.setSendingTrack(track)
|
|
assert.NoError(t, err)
|
|
|
|
parameters := rtpTransceiver.Sender().GetParameters()
|
|
assert.Equal(t, track.RID(), parameters.Encodings[0].RID)
|
|
|
|
closePairNow(t, offerer, answerer)
|
|
}
|
|
|
|
func Test_RTPSender_SetReadDeadline(t *testing.T) {
|
|
lim := test.TimeOut(time.Second * 30)
|
|
defer lim.Stop()
|
|
|
|
report := test.CheckRoutines(t)
|
|
defer report()
|
|
|
|
sender, receiver, wan := createVNetPair(t, &interceptor.Registry{})
|
|
|
|
track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err := sender.AddTrack(track)
|
|
assert.NoError(t, err)
|
|
|
|
peerConnectionsConnected := untilConnectionState(PeerConnectionStateConnected, sender, receiver)
|
|
|
|
assert.NoError(t, signalPair(sender, receiver))
|
|
|
|
peerConnectionsConnected.Wait()
|
|
|
|
assert.NoError(t, rtpSender.SetReadDeadline(time.Now().Add(1*time.Second)))
|
|
_, _, err = rtpSender.ReadRTCP()
|
|
assert.Error(t, err)
|
|
|
|
assert.NoError(t, wan.Stop())
|
|
closePairNow(t, sender, receiver)
|
|
}
|
|
|
|
func Test_RTPSender_ReplaceTrack_InvalidTrackKindChange(t *testing.T) {
|
|
lim := test.TimeOut(time.Second * 10)
|
|
defer lim.Stop()
|
|
|
|
report := test.CheckRoutines(t)
|
|
defer report()
|
|
|
|
sender, receiver, err := newPair()
|
|
assert.NoError(t, err)
|
|
|
|
trackA, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
trackB, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeOpus}, "audio", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err := sender.AddTrack(trackA)
|
|
assert.NoError(t, err)
|
|
|
|
assert.NoError(t, signalPair(sender, receiver))
|
|
|
|
seenPacket, seenPacketCancel := context.WithCancel(context.Background())
|
|
receiver.OnTrack(func(_ *TrackRemote, _ *RTPReceiver) {
|
|
seenPacketCancel()
|
|
})
|
|
|
|
func() {
|
|
for range time.Tick(time.Millisecond * 20) {
|
|
select {
|
|
case <-seenPacket.Done():
|
|
return
|
|
default:
|
|
assert.NoError(t, trackA.WriteSample(media.Sample{Data: []byte{0xAA}, Duration: time.Second}))
|
|
}
|
|
}
|
|
}()
|
|
|
|
assert.True(t, errors.Is(rtpSender.ReplaceTrack(trackB), ErrRTPSenderNewTrackHasIncorrectKind))
|
|
|
|
closePairNow(t, sender, receiver)
|
|
}
|
|
|
|
func Test_RTPSender_ReplaceTrack_InvalidCodecChange(t *testing.T) {
|
|
lim := test.TimeOut(time.Second * 10)
|
|
defer lim.Stop()
|
|
|
|
report := test.CheckRoutines(t)
|
|
defer report()
|
|
|
|
sender, receiver, err := newPair()
|
|
assert.NoError(t, err)
|
|
|
|
trackA, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
trackB, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP9}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err := sender.AddTrack(trackA)
|
|
assert.NoError(t, err)
|
|
|
|
err = rtpSender.rtpTransceiver.SetCodecPreferences([]RTPCodecParameters{{
|
|
RTPCodecCapability: RTPCodecCapability{MimeType: MimeTypeVP8},
|
|
PayloadType: 96,
|
|
}})
|
|
assert.NoError(t, err)
|
|
|
|
assert.NoError(t, signalPair(sender, receiver))
|
|
|
|
seenPacket, seenPacketCancel := context.WithCancel(context.Background())
|
|
receiver.OnTrack(func(_ *TrackRemote, _ *RTPReceiver) {
|
|
seenPacketCancel()
|
|
})
|
|
|
|
func() {
|
|
for range time.Tick(time.Millisecond * 20) {
|
|
select {
|
|
case <-seenPacket.Done():
|
|
return
|
|
default:
|
|
assert.NoError(t, trackA.WriteSample(media.Sample{Data: []byte{0xAA}, Duration: time.Second}))
|
|
}
|
|
}
|
|
}()
|
|
|
|
assert.True(t, errors.Is(rtpSender.ReplaceTrack(trackB), ErrUnsupportedCodec))
|
|
|
|
closePairNow(t, sender, receiver)
|
|
}
|
|
|
|
func Test_RTPSender_GetParameters_NilTrack(t *testing.T) {
|
|
track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
peerConnection, err := NewPeerConnection(Configuration{})
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err := peerConnection.AddTrack(track)
|
|
assert.NoError(t, err)
|
|
|
|
assert.NoError(t, rtpSender.ReplaceTrack(nil))
|
|
rtpSender.GetParameters()
|
|
|
|
assert.NoError(t, peerConnection.Close())
|
|
}
|
|
|
|
func Test_RTPSender_Send(t *testing.T) {
|
|
track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
peerConnection, err := NewPeerConnection(Configuration{})
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err := peerConnection.AddTrack(track)
|
|
assert.NoError(t, err)
|
|
|
|
parameter := rtpSender.GetParameters()
|
|
err = rtpSender.Send(parameter)
|
|
<-rtpSender.sendCalled
|
|
assert.NoError(t, err)
|
|
|
|
assert.NoError(t, peerConnection.Close())
|
|
}
|
|
|
|
func Test_RTPSender_Send_Called_Once(t *testing.T) {
|
|
track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
peerConnection, err := NewPeerConnection(Configuration{})
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err := peerConnection.AddTrack(track)
|
|
assert.NoError(t, err)
|
|
|
|
parameter := rtpSender.GetParameters()
|
|
err = rtpSender.Send(parameter)
|
|
<-rtpSender.sendCalled
|
|
assert.NoError(t, err)
|
|
|
|
err = rtpSender.Send(parameter)
|
|
assert.Equal(t, errRTPSenderSendAlreadyCalled, err)
|
|
|
|
assert.NoError(t, peerConnection.Close())
|
|
}
|
|
|
|
func Test_RTPSender_Send_Track_Removed(t *testing.T) {
|
|
track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
peerConnection, err := NewPeerConnection(Configuration{})
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err := peerConnection.AddTrack(track)
|
|
assert.NoError(t, err)
|
|
|
|
parameter := rtpSender.GetParameters()
|
|
assert.NoError(t, peerConnection.RemoveTrack(rtpSender))
|
|
assert.Equal(t, errRTPSenderTrackRemoved, rtpSender.Send(parameter))
|
|
|
|
assert.NoError(t, peerConnection.Close())
|
|
}
|
|
|
|
func Test_RTPSender_Add_Encoding(t *testing.T) {
|
|
track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
peerConnection, err := NewPeerConnection(Configuration{})
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err := peerConnection.AddTrack(track)
|
|
assert.NoError(t, err)
|
|
|
|
assert.Equal(t, errRTPSenderTrackNil, rtpSender.AddEncoding(nil))
|
|
|
|
track1, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, errRTPSenderRidNil, rtpSender.AddEncoding(track1))
|
|
|
|
track1, err = NewTrackLocalStaticSample(
|
|
RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion", WithRTPStreamID("h"),
|
|
)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, errRTPSenderNoBaseEncoding, rtpSender.AddEncoding(track1))
|
|
|
|
track, err = NewTrackLocalStaticSample(
|
|
RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion", WithRTPStreamID("q"),
|
|
)
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err = peerConnection.AddTrack(track)
|
|
assert.NoError(t, err)
|
|
|
|
track1, err = NewTrackLocalStaticSample(
|
|
RTPCodecCapability{MimeType: MimeTypeVP8}, "video1", "pion", WithRTPStreamID("h"),
|
|
)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, errRTPSenderBaseEncodingMismatch, rtpSender.AddEncoding(track1))
|
|
|
|
track1, err = NewTrackLocalStaticSample(
|
|
RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion1", WithRTPStreamID("h"),
|
|
)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, errRTPSenderBaseEncodingMismatch, rtpSender.AddEncoding(track1))
|
|
|
|
track1, err = NewTrackLocalStaticSample(
|
|
RTPCodecCapability{MimeType: MimeTypeOpus}, "video", "pion", WithRTPStreamID("h"),
|
|
)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, errRTPSenderBaseEncodingMismatch, rtpSender.AddEncoding(track1))
|
|
|
|
track1, err = NewTrackLocalStaticSample(
|
|
RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion", WithRTPStreamID("q"),
|
|
)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, errRTPSenderRIDCollision, rtpSender.AddEncoding(track1))
|
|
|
|
track1, err = NewTrackLocalStaticSample(
|
|
RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion", WithRTPStreamID("h"),
|
|
)
|
|
assert.NoError(t, err)
|
|
assert.NoError(t, rtpSender.AddEncoding(track1))
|
|
|
|
err = rtpSender.Send(rtpSender.GetParameters())
|
|
assert.NoError(t, err)
|
|
|
|
track1, err = NewTrackLocalStaticSample(
|
|
RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion", WithRTPStreamID("f"),
|
|
)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, errRTPSenderSendAlreadyCalled, rtpSender.AddEncoding(track1))
|
|
|
|
err = rtpSender.Stop()
|
|
assert.NoError(t, err)
|
|
|
|
assert.Equal(t, errRTPSenderStopped, rtpSender.AddEncoding(track1))
|
|
|
|
assert.NoError(t, peerConnection.Close())
|
|
}
|
|
|
|
// nolint: dupl
|
|
func Test_RTPSender_FEC_Support(t *testing.T) {
|
|
t.Run("FEC disabled by default", func(t *testing.T) {
|
|
track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
peerConnection, err := NewPeerConnection(Configuration{})
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err := peerConnection.AddTrack(track)
|
|
assert.NoError(t, err)
|
|
|
|
assert.Zero(t, rtpSender.GetParameters().Encodings[0].FEC.SSRC)
|
|
assert.NoError(t, peerConnection.Close())
|
|
})
|
|
|
|
t.Run("FEC can be enabled", func(t *testing.T) {
|
|
mediaEngine := MediaEngine{}
|
|
assert.NoError(t, mediaEngine.RegisterCodec(RTPCodecParameters{
|
|
RTPCodecCapability: RTPCodecCapability{MimeTypeVP8, 90000, 0, "", nil},
|
|
PayloadType: 94,
|
|
}, RTPCodecTypeVideo))
|
|
assert.NoError(t, mediaEngine.RegisterCodec(RTPCodecParameters{
|
|
RTPCodecCapability: RTPCodecCapability{MimeTypeFlexFEC, 90000, 0, "", nil},
|
|
PayloadType: 95,
|
|
}, RTPCodecTypeVideo))
|
|
|
|
api := NewAPI(WithMediaEngine(&mediaEngine))
|
|
|
|
track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
peerConnection, err := api.NewPeerConnection(Configuration{})
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err := peerConnection.AddTrack(track)
|
|
assert.NoError(t, err)
|
|
|
|
assert.NotZero(t, rtpSender.GetParameters().Encodings[0].FEC.SSRC)
|
|
assert.NoError(t, peerConnection.Close())
|
|
})
|
|
}
|
|
|
|
// nolint: dupl
|
|
func Test_RTPSender_RTX_Support(t *testing.T) {
|
|
t.Run("RTX SSRC by Default", func(t *testing.T) {
|
|
track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
peerConnection, err := NewPeerConnection(Configuration{})
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err := peerConnection.AddTrack(track)
|
|
assert.NoError(t, err)
|
|
|
|
assert.NotZero(t, rtpSender.GetParameters().Encodings[0].RTX.SSRC)
|
|
assert.NoError(t, peerConnection.Close())
|
|
})
|
|
|
|
t.Run("RTX can be disabled", func(t *testing.T) {
|
|
mediaEngine := MediaEngine{}
|
|
assert.NoError(t, mediaEngine.RegisterCodec(RTPCodecParameters{
|
|
RTPCodecCapability: RTPCodecCapability{MimeTypeVP8, 90000, 0, "", nil},
|
|
PayloadType: 94,
|
|
}, RTPCodecTypeVideo))
|
|
api := NewAPI(WithMediaEngine(&mediaEngine))
|
|
|
|
track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
peerConnection, err := api.NewPeerConnection(Configuration{})
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err := peerConnection.AddTrack(track)
|
|
assert.NoError(t, err)
|
|
|
|
assert.Zero(t, rtpSender.GetParameters().Encodings[0].RTX.SSRC)
|
|
|
|
assert.NoError(t, peerConnection.Close())
|
|
})
|
|
}
|
|
|
|
type TrackLocalCheckRTCPReaderOnBind struct {
|
|
*TrackLocalStaticSample
|
|
t *testing.T
|
|
bindCalled chan struct{}
|
|
}
|
|
|
|
func (s *TrackLocalCheckRTCPReaderOnBind) Bind(ctx TrackLocalContext) (RTPCodecParameters, error) {
|
|
assert.NotNil(s.t, ctx.RTCPReader())
|
|
p, err := s.TrackLocalStaticSample.Bind(ctx)
|
|
close(s.bindCalled)
|
|
|
|
return p, err
|
|
}
|
|
|
|
func Test_RTPSender_RTCPReader_Bind_Not_Nil(t *testing.T) {
|
|
track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
peerConnection, err := NewPeerConnection(Configuration{})
|
|
assert.NoError(t, err)
|
|
|
|
bindCalled := make(chan struct{})
|
|
rtpSender, err := peerConnection.AddTrack(&TrackLocalCheckRTCPReaderOnBind{
|
|
t: t,
|
|
TrackLocalStaticSample: track,
|
|
bindCalled: bindCalled,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
parameter := rtpSender.GetParameters()
|
|
err = rtpSender.Send(parameter)
|
|
<-rtpSender.sendCalled
|
|
<-bindCalled
|
|
assert.NoError(t, err)
|
|
|
|
assert.NoError(t, peerConnection.Close())
|
|
}
|
|
|
|
func Test_RTPSender_SetReadDeadline_Crash(t *testing.T) {
|
|
stackA, stackB, err := newORTCPair()
|
|
assert.NoError(t, err)
|
|
|
|
assert.NoError(t, signalORTCPair(stackA, stackB))
|
|
|
|
track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion")
|
|
assert.NoError(t, err)
|
|
|
|
rtpSender, err := stackA.api.NewRTPSender(track, stackA.dtls)
|
|
assert.NoError(t, err)
|
|
|
|
assert.Error(t, rtpSender.SetReadDeadline(time.Time{}), errRTPSenderSendNotCalled)
|
|
assert.NoError(t, stackA.close())
|
|
assert.NoError(t, stackB.close())
|
|
}
|