public IEnumerator InitializeReceiver()
{
const int width = 256;
const int height = 256;
var peer = new RTCPeerConnection();
var transceiver = peer.AddTransceiver(TrackKind.Video);
Assert.That(transceiver, Is.Not.Null);
RTCRtpReceiver receiver = transceiver.Receiver;
Assert.That(receiver, Is.Not.Null);
MediaStreamTrack track = receiver.Track;
Assert.That(track, Is.Not.Null);
Assert.AreEqual(TrackKind.Video, track.Kind);
Assert.That(track.Kind, Is.EqualTo(TrackKind.Video));
var videoTrack = track as VideoStreamTrack;
Assert.That(videoTrack, Is.Not.Null);
var rt = videoTrack.InitializeReceiver(width, height);
Assert.That(videoTrack.IsDecoderInitialized, Is.True);
videoTrack.Dispose();
// wait for disposing video track.
yield return(0);
peer.Dispose();
Object.DestroyImmediate(rt);
}
public IEnumerator InitializeReceiver()
{
var peer = new RTCPeerConnection();
var transceiver = peer.AddTransceiver(TrackKind.Video);
Assert.NotNull(transceiver);
RTCRtpReceiver receiver = transceiver.Receiver;
Assert.NotNull(receiver);
MediaStreamTrack track = receiver.Track;
Assert.NotNull(track);
Assert.AreEqual(TrackKind.Video, track.Kind);
var videoTrack = track as VideoStreamTrack;
Assert.NotNull(videoTrack);
var rt = videoTrack.InitializeReceiver(640, 320);
Assert.True(videoTrack.IsDecoderInitialized);
videoTrack.Dispose();
// wait for disposing video track.
yield return(0);
peer.Dispose();
Object.DestroyImmediate(rt);
}
private void OnAddReceiver(string connectionId, RTCRtpReceiver receiver)
{
var data = new SignalingEventData(EventSystem.current)
{
connectionId = connectionId,
receiver = receiver
};
ExecuteEventToAllTargets(data, ExecuteSignalingEvents.addReceiverHandler);
}
/// <summary>
///
/// </summary>
/// <param name="track"></param>
public virtual void SetReceiver(string connectionId, RTCRtpReceiver receiver)
{
m_receiver = receiver;
Track = m_receiver?.Track;
if (m_receiver == null)
{
OnStoppedStream?.Invoke(connectionId);
}
else
{
OnStartedStream?.Invoke(connectionId);
}
}
static bool CheckVideoCodecCapabilities()
{
var capabilitiesSender = RTCRtpSender.GetCapabilities(TrackKind.Video);
if (!capabilitiesSender.codecs.Any())
{
return(false);
}
var capabilitiesReceiver = RTCRtpReceiver.GetCapabilities(TrackKind.Video);
if (!capabilitiesReceiver.codecs.Any())
{
return(false);
}
return(true);
}
public static bool CheckVideoSendRecvCodecSupport(EncoderType encoderType)
{
WebRTC.Initialize(encoderType);
var capabilitiesSenderCodec = RTCRtpSender.GetCapabilities(TrackKind.Video)
.codecs
.Select(x => x.mimeType)
.Except(excludeCodecMimeType);
var capabilitiesReceiverCodec = RTCRtpReceiver.GetCapabilities(TrackKind.Video)
.codecs
.Select(x => x.mimeType)
.Except(excludeCodecMimeType);
var isSupported = capabilitiesSenderCodec.Any(x => capabilitiesReceiverCodec.Contains(x));
WebRTC.Dispose();
return(isSupported);
}
public void AddTransceiverTrackKindVideo()
{
var peer = new RTCPeerConnection();
var transceiver = peer.AddTransceiver(TrackKind.Video);
Assert.NotNull(transceiver);
Assert.IsNull(transceiver.CurrentDirection);
RTCRtpReceiver receiver = transceiver.Receiver;
Assert.NotNull(receiver);
MediaStreamTrack track = receiver.Track;
Assert.NotNull(track);
Assert.AreEqual(TrackKind.Video, track.Kind);
Assert.True(track is VideoStreamTrack);
Assert.AreEqual(1, peer.GetTransceivers().Count());
Assert.NotNull(peer.GetTransceivers().First());
}
public void AddTransceiverTrackKindAudio()
{
var peer = new RTCPeerConnection();
var transceiver = peer.AddTransceiver(TrackKind.Audio);
Assert.NotNull(transceiver);
Assert.That(() => Assert.NotNull(transceiver.CurrentDirection), Throws.InvalidOperationException);
RTCRtpReceiver receiver = transceiver.Receiver;
Assert.NotNull(receiver);
MediaStreamTrack track = receiver.Track;
Assert.NotNull(track);
Assert.AreEqual(TrackKind.Audio, track.Kind);
Assert.True(track is AudioStreamTrack);
Assert.AreEqual(1, peer.GetTransceivers().Count());
Assert.NotNull(peer.GetTransceivers().First());
}
public void ReceiverGetAudioCapabilities()
{
RTCRtpCapabilities capabilities = RTCRtpReceiver.GetCapabilities(TrackKind.Audio);
Assert.NotNull(capabilities);
Assert.NotNull(capabilities.codecs);
Assert.IsNotEmpty(capabilities.codecs);
Assert.NotNull(capabilities.headerExtensions);
Assert.IsNotEmpty(capabilities.headerExtensions);
foreach (var codec in capabilities.codecs)
{
Assert.NotNull(codec);
Assert.IsNotEmpty(codec.mimeType);
}
foreach (var extensions in capabilities.headerExtensions)
{
Assert.NotNull(extensions);
Assert.IsNotEmpty(extensions.uri);
}
}
public void AddTransceiverTrackKindVideo()
{
var peer = new RTCPeerConnection();
var transceiver = peer.AddTransceiver(TrackKind.Video);
Assert.That(transceiver, Is.Not.Null);
Assert.That(transceiver.CurrentDirection, Is.Null);
RTCRtpReceiver receiver = transceiver.Receiver;
Assert.That(receiver, Is.Not.Null);
MediaStreamTrack track = receiver.Track;
Assert.That(track, Is.Not.Null);
Assert.That(track.Kind, Is.EqualTo(TrackKind.Video));
Assert.That(track, Is.TypeOf <VideoStreamTrack>());
Assert.That(receiver.Streams, Has.Count.EqualTo(0));
Assert.That(peer.GetTransceivers(), Has.Count.EqualTo(1));
Assert.That(peer.GetTransceivers(), Has.All.Not.Null);
peer.Dispose();
}
public void ReceiverGetTrackReturnsAudioTrack()
{
var peer = new RTCPeerConnection();
var transceiver = peer.AddTransceiver(TrackKind.Audio);
Assert.That(transceiver, Is.Not.Null);
Assert.That(transceiver.CurrentDirection, Is.Null);
// The receiver has a audio track
RTCRtpReceiver receiver = transceiver.Receiver;
Assert.That(receiver, Is.Not.Null);
Assert.That(receiver.Track, Is.Not.Null);
Assert.That(receiver.Track, Is.TypeOf <AudioStreamTrack>());
// The receiver has no track
RTCRtpSender sender = transceiver.Sender;
Assert.That(sender, Is.Not.Null);
Assert.That(sender.Track, Is.Null);
peer.Dispose();
}
public static bool CheckVideoSendRecvCodecSupport(EncoderType encoderType)
{
// hardware encoder is not supported
if (encoderType == EncoderType.Hardware &&
!NativeMethods.GetHardwareEncoderSupport())
{
return(false);
}
WebRTC.Initialize(encoderType);
var capabilitiesSenderCodec = RTCRtpSender.GetCapabilities(TrackKind.Video)
.codecs
.Select(x => x.mimeType)
.Except(excludeCodecMimeType);
var capabilitiesReceiverCodec = RTCRtpReceiver.GetCapabilities(TrackKind.Video)
.codecs
.Select(x => x.mimeType)
.Except(excludeCodecMimeType);
var isSupported = capabilitiesSenderCodec.Any(x => capabilitiesReceiverCodec.Contains(x));
WebRTC.Dispose();
return(isSupported);
}
public void RaiseOnAddReceiver(string connectionId, RTCRtpReceiver receiver)
{
onAddReceiver?.Invoke(connectionId, receiver);
}