public async Task SetRemoteDescription_Invalid() { const string kDummyMessage = "v=0\r\n" + "o=- 496134922022744986 2 IN IP4 127.0.0.1\r\n" + "s=-\r\n" + "t=0 0\r\n" + "a=group:BUNDLE 0\r\n" + "a=msid-semantic: WMS\r\n" + "m=application 9 DTLS/SCTP 5000\r\n" + "c=IN IP4 0.0.0.0\r\n" + "a=setup:actpass\r\n" + "a=mid:0\r\n" + "a=sctpmap:5000 webrtc-datachannel 1024\r\n"; using (var pc = new PeerConnection()) { await pc.InitializeAsync(); // Set answer without offer; SRD task enqueued, but fails when executing var message = new SdpMessage { Type = SdpMessageType.Answer, Content = kDummyMessage }; Assert.CatchAsync <InvalidOperationException>(async() => await pc.SetRemoteDescriptionAsync(message)); } }
public async void PeerConnectionDefault() { using (var pc = new PeerConnection()) { var config = new PeerConnectionConfiguration(); await pc.InitializeAsync(config); } }
public async Task SctpError() { // Setup var config = new PeerConnectionConfiguration(); var pc1 = new PeerConnection(); var pc2 = new PeerConnection(); await pc1.InitializeAsync(config); await pc2.InitializeAsync(config); pc1.LocalSdpReadytoSend += async(string type, string sdp) => { await pc2.SetRemoteDescriptionAsync(type, sdp); if (type == "offer") { pc2.CreateAnswer(); } }; pc2.LocalSdpReadytoSend += async(string type, string sdp) => { await pc1.SetRemoteDescriptionAsync(type, sdp); if (type == "offer") { pc1.CreateAnswer(); } }; pc1.IceCandidateReadytoSend += (string candidate, int sdpMlineindex, string sdpMid) => pc2.AddIceCandidate(sdpMid, sdpMlineindex, candidate); pc2.IceCandidateReadytoSend += (string candidate, int sdpMlineindex, string sdpMid) => pc1.AddIceCandidate(sdpMid, sdpMlineindex, candidate); // Connect { var c1 = new ManualResetEventSlim(false); var c2 = new ManualResetEventSlim(false); pc1.Connected += () => c1.Set(); pc2.Connected += () => c2.Set(); Assert.True(pc1.CreateOffer()); Assert.True(c1.Wait(TimeSpan.FromSeconds(60.0))); Assert.True(c2.Wait(TimeSpan.FromSeconds(60.0))); Assert.True(pc1.IsConnected); Assert.True(pc1.IsConnected); } // Try to add a data channel. This should fail because SCTP was not negotiated. Assert.ThrowsAsync <SctpNotNegotiatedException>(async() => await pc1.AddDataChannelAsync("dummy", false, false)); Assert.ThrowsAsync <SctpNotNegotiatedException>(async() => await pc1.AddDataChannelAsync(42, "dummy", false, false)); // Clean-up pc1.Close(); pc1.Dispose(); pc2.Close(); pc2.Dispose(); }
/// <summary> /// Initialize the peer connection. /// </summary> /// <returns>A task that completes once the peer connection is ready to be used.</returns> public async Task InitializePeerConnectionAsync() { Logger.Log("Initializing the peer connection..."); // Cannot run in UI thread on UWP because this will initialize the global factory // (first library call) which needs to be done on a background thread. await ThreadHelper.RunOnWorkerThread(() => Library.ShutdownOptions = Library.ShutdownOptionsFlags.LogLiveObjects); // Initialize the native peer connection object try { var config = new PeerConnectionConfiguration { SdpSemantic = _sdpSemantic, IceServers = new List <IceServer> { _iceServer } }; await _peerConnection.InitializeAsync(config); RaisePropertyChanged("IsPeerInitialized"); } catch (Exception ex) { Logger.Log($"WebRTC native plugin init failed: {ex.Message}"); throw ex; } Logger.Log("Peer connection initialized."); OnPeerInitialized(); //using (_sessionViewModel.GetNegotiationDeferral()) { //// As a convenience, add 1 audio and 1 video transceivers //// TODO - make that more flexible //AddPendingTransceiver(MediaKind.Audio, "audio_transceiver_0"); //AddPendingTransceiver(MediaKind.Video, "video_transceiver_1"); // It is CRUCIAL to add any data channel BEFORE the SDP offer is sent, if data channels are // to be used at all. Otherwise the SCTP will not be negotiated, and then all channels will // stay forever in the kConnecting state. // https://stackoverflow.com/questions/43788872/how-are-data-channels-negotiated-between-two-peers-with-webrtc await _peerConnection.AddDataChannelAsync(ChatChannelID, "chat", true, true); } //_videoPlayer.CurrentStateChanged += OnMediaStateChanged; //_videoPlayer.MediaOpened += OnMediaOpened; //_videoPlayer.MediaFailed += OnMediaFailed; //_videoPlayer.MediaEnded += OnMediaEnded; //_videoPlayer.RealTimePlayback = true; //_videoPlayer.AutoPlay = false; // Bind the XAML UI control (videoPlayerElement) to the MediaFoundation rendering pipeline (_videoPlayer) // so that the former can render in the UI the video frames produced in the background by the latter. //videoPlayerElement.SetMediaPlayer(_videoPlayer); }
protected async Task MakeICECall(PeerConnection pc1, PeerConnection pc2) { var evExchangeCompleted = new ManualResetEventSlim(initialState: false); pc1.LocalSdpReadytoSend += async(SdpMessage message) => { await pc2.SetRemoteDescriptionAsync(message); if (message.Type == SdpMessageType.Offer) { pc2.CreateAnswer(); } else { evExchangeCompleted.Set(); } }; pc2.LocalSdpReadytoSend += async(SdpMessage message) => { await pc1.SetRemoteDescriptionAsync(message); if (message.Type == SdpMessageType.Offer) { pc1.CreateAnswer(); } else { evExchangeCompleted.Set(); } }; pc1.IceCandidateReadytoSend += (string candidate, int sdpMlineindex, string sdpMid) => { pc2.AddIceCandidate(sdpMid, sdpMlineindex, candidate); }; pc2.IceCandidateReadytoSend += (string candidate, int sdpMlineindex, string sdpMid) => { pc1.AddIceCandidate(sdpMid, sdpMlineindex, candidate); }; var pcConfig = new PeerConnectionConfiguration(); await pc1.InitializeAsync(pcConfig); await pc2.InitializeAsync(pcConfig); var ev1 = new ManualResetEventSlim(initialState: false); var ev2 = new ManualResetEventSlim(initialState: false); pc1.Connected += () => ev1.Set(); pc2.Connected += () => ev2.Set(); evExchangeCompleted.Reset(); pc1.CreateOffer(); ev1.Wait(millisecondsTimeout: 5000); ev2.Wait(millisecondsTimeout: 5000); evExchangeCompleted.Wait(millisecondsTimeout: 5000); }
static async Task Main() { try { Console.WriteLine("Starting..."); ClientWebSocket ws = new ClientWebSocket(); CancellationTokenSource cts = new CancellationTokenSource(); // Set up the peer connection. var pc = new PeerConnection(); pc.LocalSdpReadytoSend += async(string type, string sdp) => { Console.WriteLine($"Local SDP ready {type}"); //Console.WriteLine(sdp); // Send out SDP offer to the remote peer. await ws.SendAsync(Encoding.UTF8.GetBytes(sdp), WebSocketMessageType.Text, true, cts.Token); }; var config = new PeerConnectionConfiguration(); await pc.InitializeAsync(config); Console.WriteLine("Peer connection initialized."); await pc.AddLocalAudioTrackAsync(); await pc.AddLocalVideoTrackAsync(new PeerConnection.LocalVideoTrackSettings()); await ws.ConnectAsync(new Uri(WEBSOCKET_SERVER_URI), cts.Token); pc.CreateOffer(); // Wait for the SDP answer to arrive from the remote peer. byte[] answerSdpBuffer = new byte[8192]; var recvRes = await ws.ReceiveAsync(answerSdpBuffer, cts.Token); string answerSdp = Encoding.UTF8.GetString(answerSdpBuffer, 0, recvRes.Count); //Console.WriteLine($"answer sdp: {answerSdp}"); pc.SetRemoteDescription("answer", answerSdp); // Don't need the web socket anymore. await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, null, cts.Token); Console.WriteLine("Press any key to exit..."); Console.ReadLine(); } catch (Exception e) { Console.WriteLine(e.Message); } }
public static async Task <PeerConnection> InitializePeerConnection() { Console.WriteLine("Initializing peer connection in thread: {0}", Thread.CurrentThread.ManagedThreadId); PeerConnection connection = new PeerConnection(); await connection.InitializeAsync(SystemConfiguration.PeerConnectionSettings); return(connection); }
public async Task LocalNoICE() { var pc1 = new PeerConnection(); var pc2 = new PeerConnection(); var evExchangeCompleted = new ManualResetEventSlim(initialState: false); pc1.LocalSdpReadytoSend += async(SdpMessage message) => { await pc2.SetRemoteDescriptionAsync(message); if (message.Type == SdpMessageType.Offer) { pc2.CreateAnswer(); } else { evExchangeCompleted.Set(); } }; pc2.LocalSdpReadytoSend += async(SdpMessage message) => { await pc1.SetRemoteDescriptionAsync(message); if (message.Type == SdpMessageType.Offer) { pc1.CreateAnswer(); } else { evExchangeCompleted.Set(); } }; var pcConfig = new PeerConnectionConfiguration(); await pc1.InitializeAsync(pcConfig); await pc2.InitializeAsync(pcConfig); var ev1 = new ManualResetEventSlim(initialState: false); pc1.Connected += () => ev1.Set(); evExchangeCompleted.Reset(); pc1.CreateOffer(); ev1.Wait(millisecondsTimeout: 5000); evExchangeCompleted.Wait(millisecondsTimeout: 5000); pc1.Close(); pc2.Close(); }
public async Task SetRemoteDescription_Null() { using (var pc = new PeerConnection()) { await pc.InitializeAsync(); // Invalid arguments; SRD not even enqueued, fails immediately while validating arguments var message = new SdpMessage { Type = SdpMessageType.Offer, Content = null }; Assert.ThrowsAsync <ArgumentException>(async() => await pc.SetRemoteDescriptionAsync(message)); message.Content = ""; Assert.ThrowsAsync <ArgumentException>(async() => await pc.SetRemoteDescriptionAsync(message)); } }
public async void PeerConnectionLocalConnect() { using (var pc1 = new PeerConnection()) { await pc1.InitializeAsync(); using (var pc2 = new PeerConnection()) { await pc2.InitializeAsync(); // Prepare SDP event handlers pc1.LocalSdpReadytoSend += async(string type, string sdp) => { await pc2.SetRemoteDescriptionAsync(type, sdp); if (type == "offer") { pc2.CreateAnswer(); } }; pc2.LocalSdpReadytoSend += async(string type, string sdp) => { await pc1.SetRemoteDescriptionAsync(type, sdp); if (type == "offer") { pc1.CreateAnswer(); } }; pc1.IceCandidateReadytoSend += (string candidate, int sdpMlineindex, string sdpMid) => pc2.AddIceCandidate(sdpMid, sdpMlineindex, candidate); pc2.IceCandidateReadytoSend += (string candidate, int sdpMlineindex, string sdpMid) => pc1.AddIceCandidate(sdpMid, sdpMlineindex, candidate); // Connect var conn1 = new ManualResetEventSlim(initialState: false); var conn2 = new ManualResetEventSlim(initialState: false); pc1.Connected += () => conn1.Set(); pc2.Connected += () => conn2.Set(); pc1.CreateOffer(); WaitForSdpExchangeCompleted(conn1, conn2); pc1.Close(); pc2.Close(); } } }
public async void PeerConnectionLocalConnect() { using (var pc1 = new PeerConnection()) { await pc1.InitializeAsync(); using (var pc2 = new PeerConnection()) { await pc2.InitializeAsync(); // Prepare SDP event handlers pc1.LocalSdpReadytoSend += async(SdpMessage message) => { await pc2.SetRemoteDescriptionAsync(message); if (message.Type == SdpMessageType.Offer) { pc2.CreateAnswer(); } }; pc2.LocalSdpReadytoSend += async(SdpMessage message) => { await pc1.SetRemoteDescriptionAsync(message); if (message.Type == SdpMessageType.Offer) { pc1.CreateAnswer(); } }; pc1.IceCandidateReadytoSend += (IceCandidate candidate) => pc2.AddIceCandidate(candidate); pc2.IceCandidateReadytoSend += (IceCandidate candidate) => pc1.AddIceCandidate(candidate); // Connect var conn1 = new ManualResetEventSlim(initialState: false); var conn2 = new ManualResetEventSlim(initialState: false); pc1.Connected += () => conn1.Set(); pc2.Connected += () => conn2.Set(); pc1.CreateOffer(); WaitForSdpExchangeCompleted(conn1, conn2); pc1.Close(); pc2.Close(); } } }
protected async Task MakeICECall(PeerConnection pc1, PeerConnection pc2) { pc1.LocalSdpReadytoSend += (string type, string sdp) => { pc2.SetRemoteDescription(type, sdp); if (type == "offer") { pc2.CreateAnswer(); } }; pc2.LocalSdpReadytoSend += (string type, string sdp) => { pc1.SetRemoteDescription(type, sdp); if (type == "offer") { pc1.CreateAnswer(); } }; pc1.IceCandidateReadytoSend += (string candidate, int sdpMlineindex, string sdpMid) => { pc2.AddIceCandidate(sdpMid, sdpMlineindex, candidate); }; pc2.IceCandidateReadytoSend += (string candidate, int sdpMlineindex, string sdpMid) => { pc1.AddIceCandidate(sdpMid, sdpMlineindex, candidate); }; var pcConfig = new PeerConnectionConfiguration(); await pc1.InitializeAsync(pcConfig); await pc2.InitializeAsync(pcConfig); var ev1 = new ManualResetEventSlim(initialState: false); var ev2 = new ManualResetEventSlim(initialState: false); pc1.Connected += () => ev1.Set(); pc2.Connected += () => ev2.Set(); pc1.CreateOffer(); ev1.Wait(millisecondsTimeout: 5000); ev2.Wait(millisecondsTimeout: 5000); }
public async void PeerConnectionLocalConnect() { using (var pc1 = new PeerConnection()) { await pc1.InitializeAsync(); using (var pc2 = new PeerConnection()) { await pc2.InitializeAsync(); // Prepare SDP event handlers var completed = new ManualResetEventSlim(initialState: false); pc1.LocalSdpReadytoSend += async(SdpMessage message) => { // Send caller offer to callee await pc2.SetRemoteDescriptionAsync(message); Assert.AreEqual(SdpMessageType.Offer, message.Type); pc2.CreateAnswer(); }; pc2.LocalSdpReadytoSend += async(SdpMessage message) => { // Send callee answer back to caller await pc1.SetRemoteDescriptionAsync(message); Assert.AreEqual(SdpMessageType.Answer, message.Type); completed.Set(); }; pc1.IceCandidateReadytoSend += (IceCandidate candidate) => pc2.AddIceCandidate(candidate); pc2.IceCandidateReadytoSend += (IceCandidate candidate) => pc1.AddIceCandidate(candidate); // Connect pc1.CreateOffer(); WaitForSdpExchangeCompleted(completed); pc1.Close(); pc2.Close(); } } }
public async Task LocalNoICE() { var pc1 = new PeerConnection(); var pc2 = new PeerConnection(); pc1.LocalSdpReadytoSend += async(string type, string sdp) => { await pc2.SetRemoteDescriptionAsync(type, sdp); if (type == "offer") { pc2.CreateAnswer(); } }; pc2.LocalSdpReadytoSend += async(string type, string sdp) => { await pc1.SetRemoteDescriptionAsync(type, sdp); if (type == "offer") { pc1.CreateAnswer(); } }; var pcConfig = new PeerConnectionConfiguration(); await pc1.InitializeAsync(pcConfig); await pc2.InitializeAsync(pcConfig); var ev1 = new ManualResetEventSlim(initialState: false); pc1.Connected += () => ev1.Set(); pc1.CreateOffer(); ev1.Wait(millisecondsTimeout: 5000); pc1.Close(); pc2.Close(); }
public void SetupConnection() { // Create the 2 peers var config = new PeerConnectionConfiguration(); pc1_ = new PeerConnection(); pc2_ = new PeerConnection(); pc1_.InitializeAsync(config).Wait(); // cannot use async/await in OneTimeSetUp pc2_.InitializeAsync(config).Wait(); // Allocate callback events connectedEvent1_ = new ManualResetEventSlim(false); connectedEvent2_ = new ManualResetEventSlim(false); iceConnectedEvent1_ = new ManualResetEventSlim(false); iceConnectedEvent2_ = new ManualResetEventSlim(false); renegotiationEvent1_ = new ManualResetEventSlim(false); renegotiationEvent2_ = new ManualResetEventSlim(false); trackAddedEvent1_ = new ManualResetEventSlim(false); trackAddedEvent2_ = new ManualResetEventSlim(false); trackRemovedEvent1_ = new ManualResetEventSlim(false); trackRemovedEvent2_ = new ManualResetEventSlim(false); // Connect all signals pc1_.Connected += OnConnected1; pc2_.Connected += OnConnected2; pc1_.LocalSdpReadytoSend += OnLocalSdpReady1; pc2_.LocalSdpReadytoSend += OnLocalSdpReady2; pc1_.IceCandidateReadytoSend += OnIceCandidateReadytoSend1; pc2_.IceCandidateReadytoSend += OnIceCandidateReadytoSend2; pc1_.IceStateChanged += OnIceStateChanged1; pc2_.IceStateChanged += OnIceStateChanged2; pc1_.RenegotiationNeeded += OnRenegotiationNeeded1; pc2_.RenegotiationNeeded += OnRenegotiationNeeded2; pc1_.TrackAdded += OnTrackAdded1; pc2_.TrackAdded += OnTrackAdded2; pc1_.TrackRemoved += OnTrackRemoved1; pc2_.TrackRemoved += OnTrackRemoved2; }
public async Task Init(IceServerModel[] iceServers) { Logger.Debug("Starting WebRTC connection."); IceServers = iceServers; PeerSession = new PeerConnection(); var iceList = IceServers.Select(x => new IceServer() { Urls = { x.Url }, TurnPassword = x.TurnPassword ?? string.Empty, TurnUserName = x.TurnUsername ?? string.Empty }).ToList(); var config = new PeerConnectionConfiguration() { IceServers = iceList }; await PeerSession.InitializeAsync(config); PeerSession.LocalSdpReadytoSend += PeerSession_LocalSdpReadytoSend;; PeerSession.Connected += PeerConnection_Connected; PeerSession.IceStateChanged += PeerConnection_IceStateChanged; PeerSession.IceCandidateReadytoSend += PeerSession_IceCandidateReadytoSend;; CaptureChannel = await PeerSession.AddDataChannelAsync("ScreenCapture", true, true); CaptureChannel.BufferingChanged += DataChannel_BufferingChanged; CaptureChannel.MessageReceived += CaptureChannel_MessageReceived; CaptureChannel.StateChanged += CaptureChannel_StateChanged; VideoSource = ExternalVideoTrackSource.CreateFromArgb32Callback(GetCaptureFrame); Transceiver = PeerSession.AddTransceiver(MediaKind.Video); PeerSession.CreateOffer(); }
static async Task Main(string[] args) { // Get a connection string to our Azure Communication resource. var connectionString = "endpoint=https://smstestapp.communication.azure.com/;accesskey=RGrzrWY80oV4a1KgTHXJ3mJAC/8V7mubH26IjYjF+LXYVtedhw1DejYxPc9wkIPC0b0vtA7oXDsmGxME2N5Ccg=="; _communicationIdentityClient = new CommunicationIdentityClient(connectionString); _communicationRelayClient = new CommunicationRelayClient(connectionString); Console.WriteLine("Get a relay configuration"); var relayConfiguration = GetRelayConfiguration(); Console.WriteLine("Get a relay configuration passing a User Identity"); GetRelayConfigurationWithIdentity(); Console.WriteLine("Get a relay configuration passing a Route Type"); GetRelayConfigurationWithNearestRouteType(); // Now we can set up a WebRTC Peer Connection using the relay configuration var config = GetPeerConnectionConfiguration(relayConfiguration); PeerConnection peerConnection = new PeerConnection(); _ = peerConnection.InitializeAsync(config); }
private async Task StartAsync() { Util.WriteLine("WebRTCSession.Run"); try { Util.WriteLine("WebRTCSession.peer.InitializeAsync"); await peer.InitializeAsync(PeerConnectionConfig.Default); Util.WriteLine("WebRTCSession.source.StartTrack"); source.StartTrack(); Util.WriteLine("WebRTCSession.peer.AddLocalAudioTrackAsync"); await peer.AddLocalAudioTrackAsync(); Initialized?.Invoke(this); Util.WriteLine("WebRTCSession.WaitForConnectionClose"); await WaitForConnectionClose(); Util.WriteLine("WebRTCSession.ConnectionClosed"); } catch (Exception e) { Util.WriteLine($"WebRTCSession.Error: {e}"); } finally { PreShutdown?.Invoke(this); Util.WriteLine("WebRTCSession.Disposing"); Dispose(); Util.WriteLine("WebRTCSession.Disposed"); } PostShutdown?.Invoke(this); }
private static async void MessageReceived(WebSocketContext context, string msg) { Console.WriteLine($"websocket recv: {msg}"); // Set up the peer connection. var pc = new PeerConnection(); var config = new PeerConnectionConfiguration(); await pc.InitializeAsync(config); // Create a new form to display the video feed from the WebRTC peer. var form = new Form(); form.AutoSize = true; form.BackgroundImageLayout = ImageLayout.Center; PictureBox picBox = null; pc.SetRemoteDescription("offer", msg); pc.LocalSdpReadytoSend += (string type, string sdp) => { Console.WriteLine($"Local SDP ready {type}"); // Send our SDP answer to the remote peer. context.WebSocket.Send(sdp); }; if (pc.CreateAnswer()) { Console.WriteLine("Peer connection answer successfully created."); } else { Console.WriteLine("Failed to create peer connection answer."); pc.Close(); } pc.ARGBRemoteVideoFrameReady += (frame) => { var width = frame.width; var height = frame.height; var stride = frame.stride; var data = frame.data; if (picBox == null) { picBox = new PictureBox { Size = new Size((int)width, (int)height), Location = new Point(0, 0), Visible = true }; form.BeginInvoke(new Action(() => { form.Controls.Add(picBox); })); } form.BeginInvoke(new Action(() => { System.Drawing.Bitmap bmpImage = new System.Drawing.Bitmap((int)width, (int)height, (int)stride, System.Drawing.Imaging.PixelFormat.Format32bppArgb, data); picBox.Image = bmpImage; })); }; Application.EnableVisualStyles(); Application.Run(form); }
/// <summary> /// Initialize the peer connection. /// </summary> /// <returns>A task that completes once the peer connection is ready to be used.</returns> public async Task InitializePeerConnectionAsync() { Logger.Log("Initializing the peer connection..."); // Cannot run in UI thread on UWP because this will initialize the global factory // (first library call) which needs to be done on a background thread. await ThreadHelper.RunOnWorkerThread(() => Library.ShutdownOptions = Library.ShutdownOptionsFlags.LogLiveObjects); // Initialize the native peer connection object try { var config = new PeerConnectionConfiguration { SdpSemantic = _sdpSemantic, IceServers = new List <IceServer> { _iceServer } }; await _peerConnection.InitializeAsync(config); RaisePropertyChanged("IsPeerInitialized"); } catch (Exception ex) { Logger.Log($"WebRTC native plugin init failed: {ex.Message}"); throw ex; } Logger.Log("Peer connection initialized."); OnPeerInitialized(); // It is CRUCIAL to add any data channel BEFORE the SDP offer is sent, if data channels are // to be used at all. Otherwise the SCTP will not be negotiated, and then all channels will // stay forever in the kConnecting state. // https://stackoverflow.com/questions/43788872/how-are-data-channels-negotiated-between-two-peers-with-webrtc await _peerConnection.AddDataChannelAsync(ChatChannelID, "chat", true, true); //_videoPlayer.CurrentStateChanged += OnMediaStateChanged; //_videoPlayer.MediaOpened += OnMediaOpened; //_videoPlayer.MediaFailed += OnMediaFailed; //_videoPlayer.MediaEnded += OnMediaEnded; //_videoPlayer.RealTimePlayback = true; //_videoPlayer.AutoPlay = false; // Bind the XAML UI control (videoPlayerElement) to the MediaFoundation rendering pipeline (_videoPlayer) // so that the former can render in the UI the video frames produced in the background by the latter. //videoPlayerElement.SetMediaPlayer(_videoPlayer); //// Uncomment to initialize local transceivers and tracks. //if (Utils.IsFirstInstance()) //{ // // Add transceivers // var transceiverA = AddTransceiver(MediaKind.Audio, // new TransceiverInitSettings { Name = "audio_transceiver" }); // var transceiverV = AddTransceiver(MediaKind.Video, // new TransceiverInitSettings { Name = "video_transceiver", }); // // Add audio track // var sourceA = await DeviceAudioTrackSource.CreateAsync(new LocalAudioDeviceInitConfig()); // var trackA = LocalAudioTrack.CreateFromSource(sourceA, // new LocalAudioTrackInitConfig { trackName = "local_audio" }); // AddAudioTrack(trackA, "Audio Device"); // // Add the track to the transceiver. // { // var transceiverVM = Transceivers.First(t => t.Transceiver == transceiverA); // var trackVM = transceiverVM.AvailableSenders.Last(); // transceiverVM.Sender = trackVM; // } // // Add video track // var sourceV = await DeviceVideoTrackSource.CreateAsync( // new LocalVideoDeviceInitConfig // { // videoDevice = new VideoCaptureDevice // { // id = @"<insert_device_id>" // }, // videoProfileId = string.Empty, // width = 640, // height = 480, // framerate = 30 // }); // // Crate the track // var trackV = LocalVideoTrack.CreateFromSource(sourceV, // new LocalVideoTrackInitConfig { trackName = "local_video" }); // AddVideoTrack(trackV, "Video Device"); // // Add the track to the transceiver. // { // var transceiverVM = Transceivers.First(t => t.Transceiver == transceiverV); // var trackVM = transceiverVM.AvailableSenders.Last(); // transceiverVM.Sender = trackVM; // } //} }
public async Task InBand() { // Setup var config = new PeerConnectionConfiguration(); var pc1 = new PeerConnection(); var pc2 = new PeerConnection(); await pc1.InitializeAsync(config); await pc2.InitializeAsync(config); pc1.LocalSdpReadytoSend += (string type, string sdp) => { pc2.SetRemoteDescription(type, sdp); if (type == "offer") { pc2.CreateAnswer(); } }; pc2.LocalSdpReadytoSend += (string type, string sdp) => { pc1.SetRemoteDescription(type, sdp); if (type == "offer") { pc1.CreateAnswer(); } }; pc1.IceCandidateReadytoSend += (string candidate, int sdpMlineindex, string sdpMid) => pc2.AddIceCandidate(sdpMid, sdpMlineindex, candidate); pc2.IceCandidateReadytoSend += (string candidate, int sdpMlineindex, string sdpMid) => pc1.AddIceCandidate(sdpMid, sdpMlineindex, candidate); // Add dummy out-of-band data channel to force SCTP negotiating. // Otherwise after connecting AddDataChannelAsync() will fail. await pc1.AddDataChannelAsync(42, "dummy", false, false); await pc2.AddDataChannelAsync(42, "dummy", false, false); // Connect { var c1 = new ManualResetEventSlim(false); var c2 = new ManualResetEventSlim(false); pc1.Connected += () => c1.Set(); pc2.Connected += () => c2.Set(); Assert.True(pc1.CreateOffer()); Assert.True(c1.Wait(TimeSpan.FromSeconds(60.0))); Assert.True(c2.Wait(TimeSpan.FromSeconds(60.0))); Assert.True(pc1.IsConnected); Assert.True(pc1.IsConnected); } // Negotiate data channel in-band DataChannel data1 = null; DataChannel data2 = null; { var c2 = new ManualResetEventSlim(false); pc2.DataChannelAdded += (DataChannel channel) => { data2 = channel; c2.Set(); }; data1 = await pc1.AddDataChannelAsync("test_data_channel", true, true); Assert.IsNotNull(data1); Assert.True(c2.Wait(TimeSpan.FromSeconds(60.0))); Assert.IsNotNull(data2); Assert.AreEqual(data1.Label, data2.Label); // Do not test DataChannel.ID; at this point for in-band channels the ID has not // been agreed upon with the remote peer yet. } // Send data { var c2 = new ManualResetEventSlim(false); string sentText = "Some sample text"; byte[] msg = Encoding.UTF8.GetBytes(sentText); data2.MessageReceived += (byte[] _msg) => { var receivedText = Encoding.UTF8.GetString(_msg); Assert.AreEqual(sentText, receivedText); c2.Set(); }; data1.SendMessage(msg); Assert.True(c2.Wait(TimeSpan.FromSeconds(60.0))); } // Clean-up pc1.Close(); pc1.Dispose(); pc2.Close(); pc2.Dispose(); }
public async Task SetupAsync(Signaler signaler, bool isServer, uint clientNodeId = 0) { await pc.InitializeAsync(new PeerConnectionConfiguration { IceServers = new List <IceServer> { new IceServer { Urls = { signaler.IceServerUrl } } } }); var tcs = new TaskCompletionSource <bool>(); // Do signaling // https://microsoft.github.io/MixedReality-WebRTC/manual/cs/cs-signaling.html // https://microsoft.github.io/MixedReality-WebRTC/manual/cs/helloworld-cs-signaling-core3.html pc.LocalSdpReadytoSend += (SdpMessage sdpMessage) => { // ここはawaitではなくWaitにしないとSocketが切れる.スレッドセーフ関係? signaler.SendSdpAsync(sdpMessage.Type == SdpMessageType.Offer, sdpMessage.Content, clientNodeId).Wait(); }; pc.IceCandidateReadytoSend += (IceCandidate candidate) => { signaler.SendIceAsync(candidate.SdpMid, candidate.SdpMlineIndex, candidate.Content, clientNodeId).Wait(); }; pc.IceStateChanged += (IceConnectionState state) => { Logger.Debug("Connection", $"ICE state changed to {state}"); // https://microsoft.github.io/MixedReality-WebRTC/versions/release/2.0/api/Microsoft.MixedReality.WebRTC.IceConnectionState.html if (state == IceConnectionState.Connected) { Connected = true; } if (state == IceConnectionState.Closed || state == IceConnectionState.Disconnected || state == IceConnectionState.Failed) { Connected = false; OnDisconnect(); } if (!isServer && state == IceConnectionState.Failed) { tcs.SetException(new ConnectionException("Failed to establish a WebRTC connection")); } }; signaler.SdpReceived += async(bool isOffer, string sdp, uint cid) => { if (isServer && cid != clientNodeId) { // ignore messages for other clients return; } await pc.SetRemoteDescriptionAsync(new SdpMessage { Type = isOffer ? SdpMessageType.Offer : SdpMessageType.Answer, Content = sdp }); if (isOffer) { pc.CreateAnswer(); } }; signaler.IceReceived += (string sdpMid, int sdpMLineIndex, string candidate, uint cid) => { if (isServer && cid != clientNodeId) { // ignore messages for other clients return; } pc.AddIceCandidate(new IceCandidate { SdpMid = sdpMid, SdpMlineIndex = sdpMLineIndex, Content = candidate }); //Logger.Write((isServer ? "Server: " : "Client: ") + $"{sdpMid} {sdpMLineIndex} {candidate}"); }; if (isServer) { TaskCompletionSource <DataChannel>[] completionSources = channelTypes.Select( _ => new TaskCompletionSource <DataChannel>() ).ToArray(); pc.DataChannelAdded += (dc) => { foreach (var type in channelTypes) { if (dc.Label == channelLabels[(int)type]) { completionSources[(int)type].SetResult(dc); } } }; Logger.Debug("Connection", "Server is ready for signaling"); await signaler.NotifyReadyAsync(clientNodeId); Logger.Debug("Connection", "Server: Waiting for DC"); foreach (var type in channelTypes) { channels[(int)type] = await completionSources[(int)type].Task; } } else { // Define channels // Sync channel (unreliable) channels[(int)ChannelType.Sync] = await pc.AddDataChannelAsync( channelLabels[(int)ChannelType.Sync], ordered : false, reliable : false); // Message channel (reliable but order is not guaranteed) channels[(int)ChannelType.Control] = await pc.AddDataChannelAsync( channelLabels[(int)ChannelType.Control], ordered : false, reliable : true); // Blob channel (reliable and ordered) channels[(int)ChannelType.Blob] = await pc.AddDataChannelAsync( channelLabels[(int)ChannelType.Blob], ordered : true, reliable : true); // Audio channel (unreliable) channels[(int)ChannelType.Audio] = await pc.AddDataChannelAsync( channelLabels[(int)ChannelType.Audio], ordered : false, reliable : false); Logger.Debug("Connection", "Client: Waiting for server ready"); await signaler.WaitReadyAsync(); pc.CreateOffer(); } foreach (var(dc, idx) in channels.Select((dc, idx) => (dc, idx))) { dc.MessageReceived += (data) => { threadChannels[idx].Writer.TryWrite(data); // Always succeeds because the Channel is unbounded }; dc.StateChanged += () => { Logger.Debug("Connection", $"DC {(ChannelType)idx} state changed to {dc.State}"); if (dc.State == DataChannel.ChannelState.Closing) { // Disconnect handling Connected = false; } }; } //await Task.Delay(5000); if (!isServer) { // FIXME: Waiting pc.Connected not work in server (cannot establish a connection to client) // In server, should wait until all DataChannels are added? pc.Connected += () => { tcs.SetResult(true); }; await tcs.Task; } }
static async Task Main(string[] args) { Transceiver audioTransceiver = null; Transceiver videoTransceiver = null; AudioTrackSource audioTrackSource = null; VideoTrackSource videoTrackSource = null; LocalAudioTrack localAudioTrack = null; LocalVideoTrack localVideoTrack = null; try { bool needVideo = Array.Exists(args, arg => (arg == "-v") || (arg == "--video")); bool needAudio = Array.Exists(args, arg => (arg == "-a") || (arg == "--audio")); // Asynchronously retrieve a list of available video capture devices (webcams). var deviceList = await PeerConnection.GetVideoCaptureDevicesAsync(); // For example, print them to the standard output foreach (var device in deviceList) { Console.WriteLine($"Found webcam {device.name} (id: {device.id})"); } // Create a new peer connection automatically disposed at the end of the program using var pc = new PeerConnection(); // Initialize the connection with a STUN server to allow remote access var config = new PeerConnectionConfiguration { IceServers = new List <IceServer> { new IceServer { Urls = { "stun:stun.l.google.com:19302" } } } }; await pc.InitializeAsync(config); Console.WriteLine("Peer connection initialized."); // Record video from local webcam, and send to remote peer if (needVideo) { Console.WriteLine("Opening local webcam..."); videoTrackSource = await DeviceVideoTrackSource.CreateAsync(); Console.WriteLine("Create local video track..."); var trackSettings = new LocalVideoTrackInitConfig { trackName = "webcam_track" }; localVideoTrack = LocalVideoTrack.CreateFromSource(videoTrackSource, trackSettings); Console.WriteLine("Create video transceiver and add webcam track..."); videoTransceiver = pc.AddTransceiver(MediaKind.Video); videoTransceiver.DesiredDirection = Transceiver.Direction.SendReceive; videoTransceiver.LocalVideoTrack = localVideoTrack; } // Record audio from local microphone, and send to remote peer if (needAudio) { Console.WriteLine("Opening local microphone..."); audioTrackSource = await DeviceAudioTrackSource.CreateAsync(); Console.WriteLine("Create local audio track..."); var trackSettings = new LocalAudioTrackInitConfig { trackName = "mic_track" }; localAudioTrack = LocalAudioTrack.CreateFromSource(audioTrackSource, trackSettings); Console.WriteLine("Create audio transceiver and add mic track..."); audioTransceiver = pc.AddTransceiver(MediaKind.Audio); audioTransceiver.DesiredDirection = Transceiver.Direction.SendReceive; audioTransceiver.LocalAudioTrack = localAudioTrack; } // Setup signaling Console.WriteLine("Starting signaling..."); var signaler = new NamedPipeSignaler.NamedPipeSignaler(pc, "testpipe"); signaler.SdpMessageReceived += async(SdpMessage message) => { await pc.SetRemoteDescriptionAsync(message); if (message.Type == SdpMessageType.Offer) { pc.CreateAnswer(); } }; signaler.IceCandidateReceived += (IceCandidate candidate) => { pc.AddIceCandidate(candidate); }; await signaler.StartAsync(); // Start peer connection pc.Connected += () => { Console.WriteLine("PeerConnection: connected."); }; pc.IceStateChanged += (IceConnectionState newState) => { Console.WriteLine($"ICE state: {newState}"); }; int numFrames = 0; pc.VideoTrackAdded += (RemoteVideoTrack track) => { track.I420AVideoFrameReady += (I420AVideoFrame frame) => { ++numFrames; if (numFrames % 60 == 0) { Console.WriteLine($"Received video frames: {numFrames}"); } }; }; if (signaler.IsClient) { Console.WriteLine("Connecting to remote peer..."); pc.CreateOffer(); } else { Console.WriteLine("Waiting for offer from remote peer..."); } Console.WriteLine("Press a key to stop recording..."); Console.ReadKey(true); signaler.Stop(); } catch (Exception e) { Console.WriteLine(e.Message); } localAudioTrack?.Dispose(); localVideoTrack?.Dispose(); Console.WriteLine("Program termined."); localAudioTrack.Dispose(); localVideoTrack.Dispose(); audioTrackSource.Dispose(); videoTrackSource.Dispose(); }
static private async Task StartStend() { var autoEvent = new AutoResetEvent(false); bool video_translator = true; bool file_created = false; FileStream file = null; Quartus quartus = Quartus.GetInstance(); Microcontroller arduino = Microcontroller.Create(); if (video_translator) { // Asynchronously retrieve a list of available video capture devices (webcams). var deviceList = await DeviceVideoTrackSource.GetCaptureDevicesAsync(); // For example, print them to the standard output foreach (var device in deviceList) { Console.WriteLine($"Found webcam {device.name} (id: {device.id})"); } } // Create a new peer connection automatically disposed at the end of the program var pc = new PeerConnection(); // Initialize the connection with a STUN server to allow remote access var config = SystemConfiguration.PeerConnectionSettings; await pc.InitializeAsync(config); Console.WriteLine("Peer connection initialized."); //var chen = await pc.AddDataChannelAsync("sendDataChannel", true, true, cancellationToken: default); Console.WriteLine("Opening local webcam..."); // pc - PeerConnection object Transceiver videoTransceiver = null; VideoTrackSource videoTrackSource = null; LocalVideoTrack localVideoTrack = null; LocalVideoDeviceInitConfig c = new LocalVideoDeviceInitConfig(); await VideoDeviceSelection(); videoTrackSource = await Camera.CreateAsync(SystemConfiguration.VideoDeviceSettings); WebSocketSharp.WebSocket signaling = new WebSocketSharp.WebSocket(CreateSignalingServerUrl(), "id_token", "alpine"); pc.LocalSdpReadytoSend += (SdpMessage message) => { //Console.WriteLine(SdpMessage.TypeToString(message.Type)); Console.WriteLine(message.Content); //Console.WriteLine(HttpUtility.JavaScriptStringEncode(message.Content)); Console.WriteLine("Sdp offer to send: {\"data\":{\"description\":{\"type\":\"" + SdpMessage.TypeToString(message.Type) + "\",\"sdp\":\"" + HttpUtility.JavaScriptStringEncode(message.Content) + "\"}}}"); signaling.Send(message.ToABJson()); }; pc.RenegotiationNeeded += () => { Console.WriteLine("Regotiation needed"); bool OfferCreated = pc.CreateOffer(); Console.WriteLine("OfferCreated? {0}", OfferCreated); }; pc.DataChannelAdded += (DataChannel channel) => { Console.WriteLine("Added data channel ID: {0}, Label: {1}; Reliable: {2}, Ordered: {3}", channel.ID, channel.Label, channel.Reliable, channel.Ordered); if (channel.Label == "sendDataChannel") { channel.MessageReceived += (byte[] mess) => { try { CTP_packet command = JsonSerializer.Deserialize <CTP_packet>(mess); Console.WriteLine(arduino.SendCTP_Command(command)); } catch (Exception e) { Console.WriteLine(e.Message); } }; } else { if (file_created == false) { file = new FileStream(channel.Label, FileMode.Append); file_created = true; } channel.MessageReceived += async(byte[] mess) => { // Console.WriteLine(System.Text.Encoding.Default.GetString(mess)); if (mess.Length == 3 && System.Text.Encoding.Default.GetString(mess) == "EOF") { string file_name = file.Name; file.Close(); string t = await quartus.RunQuartusCommandAsync($"quartus_pgm -m jtag –o \"p;{file_name}@1\""); File.Delete(file_name); file_created = false; } else { WriteFileSegment(mess, file); } }; } channel.StateChanged += () => { Console.WriteLine("State change: {0}", channel.State); }; }; pc.IceCandidateReadytoSend += (IceCandidate candidate) => { //Console.WriteLine("Content: {0}, SdpMid: {1}, SdpMlineIndex: {2}", candidate.Content, candidate.SdpMid, candidate.SdpMlineIndex); try { Console.WriteLine("Candidate to send: Content: {0}, SdpMid: {1}, SdpMlineIndex: {2}", candidate.Content, candidate.SdpMid, candidate.SdpMlineIndex); signaling.Send(candidate.ToABJson()); } catch (Exception e) { Console.WriteLine("Error to send local ice candidate"); } }; //videoTrackSource.I420AVideoFrameReady += (frame) => //{ // Console.WriteLine("Argb32 frame ready. {0} : {1}", frame.width, frame.height); // Console.WriteLine("DataA: {0}, DataU: {1}, DataV: {2}, DataY: {3}", Marshal.SizeOf(frame.dataA), // Marshal.SizeOf(frame.dataU), // Marshal.SizeOf(frame.dataV), // Marshal.SizeOf(frame.dataY)); //}; signaling.OnMessage += async(sender, message) => { (string header, string correct_message) = message.Data.DivideHeaderAndOriginalJSON(); Console.WriteLine("Correct message: {0}", correct_message); Console.WriteLine("Header: {0}", header); if (header == "{\"data\":{\"getRemoteMedia\":" && correct_message == "true") { Console.WriteLine("Create local video track..."); var trackSettings = new LocalVideoTrackInitConfig { trackName = "webcam_track" }; localVideoTrack = LocalVideoTrack.CreateFromSource(videoTrackSource, new LocalVideoTrackInitConfig { trackName = "webcam_track" }); Console.WriteLine("Create video transceiver and add webcam track..."); TransceiverInitSettings option = new TransceiverInitSettings(); option.Name = "webcam_track"; option.StreamIDs = new List <string> { "webcam_name" }; videoTransceiver = pc.AddTransceiver(MediaKind.Video, option); videoTransceiver.DesiredDirection = Transceiver.Direction.SendOnly; videoTransceiver.LocalVideoTrack = localVideoTrack; bool OfferCreated = pc.CreateOffer(); Console.WriteLine("OfferCreated? {0}", OfferCreated); } //Console.WriteLine(message.Data); if (header.IndexOf("candidate") != -1 && correct_message != "null") { try { var candidate = JsonSerializer.Deserialize <ICEJavaScriptNotation>(correct_message); Console.WriteLine("Content of ice: {0}, SdpMid: {1}, SdpMLineIndex: {2}", candidate.candidate, candidate.sdpMid, candidate.sdpMLineIndex); pc.AddIceCandidate(candidate.ToMRNetCoreNotation()); Console.WriteLine("Deserialized by ice_candidate"); //return; } catch (Exception) { Console.WriteLine("Could not deserialize as ice candidate"); } } if (header.IndexOf("description") != -1) { try { SdpMessage received_description = JsonSerializer.Deserialize <SDPJavaScriptNotation>(correct_message).ToMRNetCoreNotation(); await pc.SetRemoteDescriptionAsync(received_description); if (received_description.Type == SdpMessageType.Offer) { bool res = pc.CreateAnswer(); Console.WriteLine("Answer created? {0}", res); } Console.WriteLine("Deserialized by sdp_message"); } catch (Exception) { Console.WriteLine("Could not deserialize as sdp message"); } } }; pc.Connected += () => { Console.WriteLine("Connected"); }; pc.IceStateChanged += (IceConnectionState newState) => { if (newState == IceConnectionState.Disconnected) { Console.WriteLine("Disconected"); } }; signaling.Connect(); if (!video_translator) { signaling.Send("{\"data\":{\"getRemoteMedia\":true}}"); } //Console.WriteLine("Press a key to terminate the application..."); Console.ReadKey(true); Console.WriteLine("Program termined."); file?.Close(); pc?.Close(); signaling?.Close(); //arduino?.Close(); //(var a, var b) = ConvertString("{\"data\":{\"candidate\":null}}"); //Console.WriteLine("{0}, {1}", a, b); }
//Loaded-EventHandler of ui: executes after ui-loading private async void OnLoaded(object sender, RoutedEventArgs e) { //Request access to mic and cam MediaCaptureInitializationSettings settings = new MediaCaptureInitializationSettings(); settings.StreamingCaptureMode = StreamingCaptureMode.AudioAndVideo; MediaCapture capture = new MediaCapture(); await capture.InitializeAsync(settings); //Get list of cams camList = await PeerConnection.GetVideoCaptureDevicesAsync(); //Print list to log foreach (var cam in camList) { Debugger.Log(0, "", $"Webcam: {cam.name} (id: {cam.id})\n"); } //Ask user for ids (show MessageBox) await ShowIdInputBoxAsync(); //New PeerConnection (Access to WebRTC) peerConnection = new PeerConnection(); //Create PeerConnection-config PeerConnectionConfiguration config = new PeerConnectionConfiguration() { IceServers = new List <IceServer>() { //Using google stun server for testing new IceServer() { Urls = { "stun:stun.l.google.com:19302" } } } }; //Initialize PeerContection await peerConnection.InitializeAsync(config); //Event fires, when local video frame is captured and ready for rendering peerConnection.I420LocalVideoFrameReady += Peer_LocalI420FrameReady; //Event fires, when remote video frame is receved and ready for rendering peerConnection.I420RemoteVideoFrameReady += Peer_RemoteI420FrameReady; //Events fires, when SdpMessage is ready for sending peerConnection.LocalSdpReadytoSend += Peer_LocalSdpReadytoSend; //Event fires, when IceCandidate is ready for sending peerConnection.IceCandidateReadytoSend += Peer_IceCandidateReadytoSend; //Set DebuggingLog-messages peerConnection.Connected += () => Debugger.Log(0, "", "PeerConnection: connected\n"); peerConnection.IceStateChanged += (IceConnectionState newState) => Debugger.Log(0, "", $"ICE state: {newState}\n"); Debugger.Log(0, "", "Peer conection initialized successfully\n"); //Adds cam-tracks from standart (first) devices [add parameter to specify cam-device or -specifications] await peerConnection.AddLocalVideoTrackAsync(new PeerConnection.LocalVideoTrackSettings() { videoDevice = cam }); //Same for mic [no specifications possible: always uses the first mic in list] await peerConnection.AddLocalAudioTrackAsync(); //Initialize the signaler (Properties from MessageBox) signaler = new NodeDssSignaler() { HttpServerAddress = nodeDssServerIp, LocalPeerId = localId, RemotePeerId = remoteId }; signaler.OnMessage += (NodeDssSignaler.Message msg) => { switch (msg.MessageType) { case NodeDssSignaler.Message.WireMessageType.Offer: peerConnection.SetRemoteDescription("offer", msg.Data); peerConnection.CreateAnswer(); break; case NodeDssSignaler.Message.WireMessageType.Answer: peerConnection.SetRemoteDescription("answer", msg.Data); break; case NodeDssSignaler.Message.WireMessageType.Ice: string[] parts = msg.Data.Split(new string[] { msg.IceDataSeparator }, StringSplitOptions.RemoveEmptyEntries); //Changing order of parts string sdpMid = parts[2]; int sdpMlineindex = int.Parse(parts[1]); string candidate = parts[0]; peerConnection.AddIceCandidate(sdpMid, sdpMlineindex, candidate); break; } }; signaler.StartPollingAsync(); }
protected override async void OnMessage(MessageEventArgs e) { var msg = e.Data; var jsonMsg = JObject.Parse(msg); Util.WriteLine($"WebSocketSignaller.OnMessage {Util.PrettyPrint(msg, 20)}..."); if ((string)jsonMsg["type"] == "ice") { while (!peer.Initialized) { // This delay is needed due to an initialise bug in the Microsoft.MixedReality.WebRTC // nuget packages up to version 0.2.3. On master awaiting pc.InitializeAsync does end // up with the pc object being ready. Util.WriteLine("WebSocketSignaller.peer.NotInitialized - Sleeping for 1s while peer connection is initialising..."); await Task.Delay(1000); } Util.WriteLine("WebSocketSignaller.AddIceCandidate"); peer.AddIceCandidate((string)jsonMsg["sdpMLineindex"], (int)jsonMsg["sdpMid"], (string)jsonMsg["candidate"]); } else if ((string)jsonMsg["type"] == "sdp") { Util.WriteLine("WebSocketSignaller.OnMessage - Received SDP offer."); peer.IceCandidateReadytoSend += (string candidate, int sdpMlineindex, string sdpMid) => { var iceCandidate = new JObject { { "type", "ice" }, { "candidate", candidate }, { "sdpMLineindex", sdpMlineindex }, { "sdpMid", sdpMid } }.ToString(); Util.WriteLine($"WebSocketSignaller.SendIceCandidate - {Util.PrettyPrint(iceCandidate, 20)}"); Context.WebSocket.Send(iceCandidate); }; peer.LocalSdpReadytoSend += (string type, string sdp) => { var msgType = receivedOffer ? "answer" : "offer"; var sdpAnswer = new JObject { { "type", "sdp" }, { msgType, sdp } }.ToString(); Util.WriteLine($"WebSocketSignaller.SendSDP - {Util.PrettyPrint(sdpAnswer, 20)}"); Context.WebSocket.Send(sdpAnswer); }; if (!peer.Initialized) { Util.WriteLine($"WebSocketSignaller.peer.InitializeAsync"); await peer.InitializeAsync(PeerConnectionConfig.Default); } if (jsonMsg.ContainsKey("answer")) { var answer = (string)jsonMsg["answer"]; Util.WriteLine($"WebSocketSignaller.SetRemoteDescription - answer='{Util.PrettyPrint(answer, 20)}...'"); await peer.SetRemoteDescriptionAsync("answer", answer); } else if (jsonMsg.ContainsKey("offer")) { var offer = (string)jsonMsg["offer"]; Util.WriteLine($"WebSocketSignaller.SetRemoteDescription - offer='{Util.PrettyPrint(offer, 20)}...'"); await peer.SetRemoteDescriptionAsync("offer", offer); receivedOffer = true; Util.WriteLine($"WebSocketSignaller.CreateAnswer"); if (!peer.CreateAnswer()) { Console.WriteLine("WebSocketSignaller - Failed to create peer connection answer, closing peer connection."); Dispose(); } } else { throw new Exception("Unknown message " + msg); } Util.WriteLine("WebSocketSignaller.Complete"); } }
public void SetupConnection() { Assert.AreEqual(0, Library.ReportLiveObjects()); // Create the 2 peers var config = new PeerConnectionConfiguration(); config.SdpSemantic = sdpSemantic_; pc1_ = new PeerConnection(); pc2_ = new PeerConnection(); pc1_.InitializeAsync(config).Wait(); // cannot use async/await in OneTimeSetUp pc2_.InitializeAsync(config).Wait(); exchangePending_ = false; exchangeCompleted_ = new ManualResetEventSlim(false); // Allocate callback events connectedEvent1_ = new ManualResetEventSlim(false); connectedEvent2_ = new ManualResetEventSlim(false); remoteDescAppliedEvent1_ = new ManualResetEventSlim(false); remoteDescAppliedEvent2_ = new ManualResetEventSlim(false); iceConnectedEvent1_ = new ManualResetEventSlim(false); iceConnectedEvent2_ = new ManualResetEventSlim(false); renegotiationEvent1_ = new ManualResetEventSlim(false); renegotiationEvent2_ = new ManualResetEventSlim(false); dataChannelAddedEvent1_ = new ManualResetEventSlim(false); dataChannelAddedEvent2_ = new ManualResetEventSlim(false); dataChannelRemovedEvent1_ = new ManualResetEventSlim(false); dataChannelRemovedEvent2_ = new ManualResetEventSlim(false); audioTrackAddedEvent1_ = new ManualResetEventSlim(false); audioTrackAddedEvent2_ = new ManualResetEventSlim(false); audioTrackRemovedEvent1_ = new ManualResetEventSlim(false); audioTrackRemovedEvent2_ = new ManualResetEventSlim(false); videoTrackAddedEvent1_ = new ManualResetEventSlim(false); videoTrackAddedEvent2_ = new ManualResetEventSlim(false); videoTrackRemovedEvent1_ = new ManualResetEventSlim(false); videoTrackRemovedEvent2_ = new ManualResetEventSlim(false); // Connect all signals pc1_.Connected += OnConnected1; pc2_.Connected += OnConnected2; pc1_.LocalSdpReadytoSend += OnLocalSdpReady1; pc2_.LocalSdpReadytoSend += OnLocalSdpReady2; pc1_.IceCandidateReadytoSend += OnIceCandidateReadytoSend1; pc2_.IceCandidateReadytoSend += OnIceCandidateReadytoSend2; pc1_.IceStateChanged += OnIceStateChanged1; pc2_.IceStateChanged += OnIceStateChanged2; pc1_.RenegotiationNeeded += OnRenegotiationNeeded1; pc2_.RenegotiationNeeded += OnRenegotiationNeeded2; pc1_.DataChannelAdded += OnDataChannelAdded1; pc2_.DataChannelAdded += OnDataChannelAdded2; pc1_.DataChannelRemoved += OnDataChannelRemoved1; pc2_.DataChannelRemoved += OnDataChannelRemoved2; pc1_.AudioTrackAdded += OnAudioTrackAdded1; pc2_.AudioTrackAdded += OnAudioTrackAdded2; pc1_.AudioTrackRemoved += OnAudioTrackRemoved1; pc2_.AudioTrackRemoved += OnAudioTrackRemoved2; pc1_.VideoTrackAdded += OnVideoTrackAdded1; pc2_.VideoTrackAdded += OnVideoTrackAdded2; pc1_.VideoTrackRemoved += OnVideoTrackRemoved1; pc2_.VideoTrackRemoved += OnVideoTrackRemoved2; // Enable automatic renegotiation suspendOffer1_ = false; suspendOffer2_ = false; }
private void OnLoaded(object sender, RoutedEventArgs e) { LogMessage("Initializing the WebRTC native plugin..."); // Populate the list of video capture devices (webcams). // On UWP this uses internally the API: // Devices.Enumeration.DeviceInformation.FindAllAsync(VideoCapture) // Note that there's no API to pass a given device to WebRTC, // so there's no way to monitor and update that list if a device // gets plugged or unplugged. Even using DeviceInformation.CreateWatcher() // would yield some devices that might become unavailable by the time // WebRTC internally opens the video capture device. // This is more for demo purpose here because using the UWP API is nicer. { // Use a local list accessible from a background thread List <VideoCaptureDevice> vcds = new List <VideoCaptureDevice>(4); PeerConnection.GetVideoCaptureDevicesAsync().ContinueWith((prevTask) => { if (prevTask.Exception != null) { throw prevTask.Exception; } var devices = prevTask.Result; vcds.Capacity = devices.Count; foreach (var device in devices) { vcds.Add(new VideoCaptureDevice() { Id = device.id, DisplayName = device.name, Symbol = Symbol.Video }); } // Assign on main UI thread because of XAML binding; otherwise it fails. RunOnMainThread(() => { VideoCaptureDevices.Clear(); foreach (var vcd in vcds) { VideoCaptureDevices.Add(vcd); LogMessage($"VCD id={vcd.Id} name={vcd.DisplayName}"); } }); }); } //localVideo.TransportControls = localVideoControls; PluginInitialized = false; // Assign STUN server(s) before calling InitializeAsync() _peerConnection.Servers.Clear(); // We use only one server in this demo _peerConnection.Servers.Add("stun:" + stunServer.Text); // Ensure that the UWP app was authorized to capture audio (cap:microphone) // and video (cap:webcam), otherwise the native plugin will fail. try { MediaCapture mediaAccessRequester = new MediaCapture(); var mediaSettings = new MediaCaptureInitializationSettings { AudioDeviceId = "", VideoDeviceId = "", StreamingCaptureMode = StreamingCaptureMode.AudioAndVideo, PhotoCaptureSource = PhotoCaptureSource.VideoPreview }; var uiThreadScheduler = TaskScheduler.FromCurrentSynchronizationContext(); mediaAccessRequester.InitializeAsync(mediaSettings).AsTask() .ContinueWith((accessTask) => { if (accessTask.Exception != null) { LogMessage($"Access to A/V denied, check app permissions: {accessTask.Exception.Message}"); throw accessTask.Exception; } _peerConnection.InitializeAsync().ContinueWith((initTask) => { if (initTask.Exception != null) { LogMessage($"WebRTC native plugin init failed: {initTask.Exception.Message}"); throw initTask.Exception; } OnPluginPostInit(); }, uiThreadScheduler); // run task on caller (UI) thread }); } //< TODO - This below shouldn't do anything since exceptions are caught and stored inside Task.Exception... catch (UnauthorizedAccessException uae) { LogMessage("Access to A/V denied: " + uae.Message); } catch (Exception ex) { if (ex.InnerException is UnauthorizedAccessException uae) { LogMessage("Access to A/V denied: " + uae.Message); } else { LogMessage("Failed to initialize A/V with unknown exception: " + ex.Message); } } }
static async Task Main(string[] args) { try { bool needVideo = Array.Exists(args, arg => (arg == "-v") || (arg == "--video")); bool needAudio = Array.Exists(args, arg => (arg == "-a") || (arg == "--audio")); // Asynchronously retrieve a list of available video capture devices (webcams). var deviceList = await PeerConnection.GetVideoCaptureDevicesAsync(); // For example, print them to the standard output foreach (var device in deviceList) { Console.WriteLine($"Found webcam {device.name} (id: {device.id})"); } // Create a new peer connection automatically disposed at the end of the program using var pc = new PeerConnection(); // Initialize the connection with a STUN server to allow remote access var config = new PeerConnectionConfiguration { IceServers = new List <IceServer> { new IceServer { Urls = { "stun:stun.l.google.com:19302" } } } }; await pc.InitializeAsync(config); Console.WriteLine("Peer connection initialized."); // Record video from local webcam, and send to remote peer if (needVideo) { Console.WriteLine("Opening local webcam..."); await pc.AddLocalVideoTrackAsync(); } // Record audio from local microphone, and send to remote peer if (needAudio) { Console.WriteLine("Opening local microphone..."); await pc.AddLocalAudioTrackAsync(); } // Setup signaling Console.WriteLine("Starting signaling..."); var signaler = new NamedPipeSignaler.NamedPipeSignaler(pc, "testpipe"); signaler.SdpMessageReceived += (string type, string sdp) => { pc.SetRemoteDescription(type, sdp); if (type == "offer") { pc.CreateAnswer(); } }; signaler.IceCandidateReceived += (string sdpMid, int sdpMlineindex, string candidate) => { pc.AddIceCandidate(sdpMid, sdpMlineindex, candidate); }; await signaler.StartAsync(); // Start peer connection pc.Connected += () => { Console.WriteLine("PeerConnection: connected."); }; pc.IceStateChanged += (IceConnectionState newState) => { Console.WriteLine($"ICE state: {newState}"); }; int numFrames = 0; pc.I420RemoteVideoFrameReady += (I420AVideoFrame frame) => { ++numFrames; if (numFrames % 60 == 0) { Console.WriteLine($"Received video frames: {numFrames}"); } }; if (signaler.IsClient) { Console.WriteLine("Connecting to remote peer..."); pc.CreateOffer(); } else { Console.WriteLine("Waiting for offer from remote peer..."); } Console.WriteLine("Press a key to stop recording..."); Console.ReadKey(true); signaler.Stop(); } catch (Exception e) { Console.WriteLine(e.Message); } Console.WriteLine("Program termined."); }
private async void OnLoaded(object sender, RoutedEventArgs e) { // Request access to microphone and camera var settings = new MediaCaptureInitializationSettings(); settings.StreamingCaptureMode = StreamingCaptureMode.AudioAndVideo; var capture = new MediaCapture(); await capture.InitializeAsync(settings); // Retrieve a list of available video capture devices (webcams). List <VideoCaptureDevice> deviceList = await PeerConnection.GetVideoCaptureDevicesAsync(); // Get the device list and, for example, print them to the debugger console foreach (var device in deviceList) { // This message will show up in the Output window of Visual Studio Debugger.Log(0, "", $"Webcam {device.name} (id: {device.id})\n"); } _peerConnection = new PeerConnection(); var config = new PeerConnectionConfiguration { IceServers = new List <IceServer> { new IceServer { Urls = { "stun:stun.l.google.com:19302" } } } }; await _peerConnection.InitializeAsync(config); Debugger.Log(0, "", "Peer connection initialized successfully.\n"); await _peerConnection.AddLocalAudioTrackAsync(); if (Settings.m_showLocal) { //LocalVideoTrack _localVideoTrack; await _peerConnection.AddLocalVideoTrackAsync(); _peerConnection.I420LocalVideoFrameReady += Peer_LocalI420AFrameReady; await _peerConnection.AddLocalAudioTrackAsync(); remoteVideoPlayerElement.Visibility = Visibility.Visible; } else { _peerConnection.Connected += () => { Debugger.Log(0, "", "PeerConnection: connected.\n"); }; _peerConnection.IceStateChanged += (IceConnectionState newState) => { Debugger.Log(0, "", $"ICE state: {newState}\n"); }; _peerConnection.I420RemoteVideoFrameReady += Peer_RemoteI420AFrameReady; _peerConnection.LocalSdpReadytoSend += Peer_LocalSdpReadytoSend; _peerConnection.IceCandidateReadytoSend += Peer_IceCandidateReadytoSend; // Initialize the signaler _signaler = new NodeDssSignaler() { HttpServerAddress = "http://10.44.160.22:3000/", LocalPeerId = "DINF-D60015-43A", RemotePeerId = "HOLOLENS-RO2J0", }; _signaler.OnMessage += (NodeDssSignaler.Message msg) => { switch (msg.MessageType) { case NodeDssSignaler.Message.WireMessageType.Offer: _peerConnection.SetRemoteDescription("offer", msg.Data); _peerConnection.CreateAnswer(); break; case NodeDssSignaler.Message.WireMessageType.Answer: _peerConnection.SetRemoteDescription("answer", msg.Data); break; case NodeDssSignaler.Message.WireMessageType.Ice: var parts = msg.Data.Split(new string[] { msg.IceDataSeparator }, StringSplitOptions.RemoveEmptyEntries); // Note the inverted arguments for historical reasons. // 'candidate' is last in AddIceCandidate(), but first in the message. string sdpMid = parts[2]; int sdpMlineindex = int.Parse(parts[1]); string candidate = parts[0]; _peerConnection.AddIceCandidate(sdpMid, sdpMlineindex, candidate); break; } }; _signaler.StartPollingAsync(); } // Interactions Debug.WriteLine("[Playback::start] Waiting for a connection..."); m_dsUdpSocket = new DatagramSocket(); m_dsUdpSocket.MessageReceived += Socket_MessageReceived; // Initialization UDP communication try { await m_dsUdpSocket.ConnectAsync(new EndpointPair(new HostName(Settings.m_sIPLocalUDP), Settings.m_sPortLocalUDP, new HostName(Settings.m_sIPRemoteUDP), Settings.m_sPortRemoteUDP)); m_output = new DataWriter(m_dsUdpSocket.OutputStream); Debug.WriteLine("[Playback::start] UDP connection initialization ok"); } catch (Exception) { Debug.WriteLine("[Playback::start] Error - UDP connection initialization "); } }