Example #1
0
        /// <summary>
        /// Sets up the WebRTC connection by starting a new <see cref="System.Threading.Task"/>.
        /// </summary>
        /// <param name="session">Created session for the client.</param>
        /// <param name="context">Context of the user connection.</param>
        /// <param name="jsonMessage">Retrieved WebSocket message as Json.</param>
        private void SetupWebRTCConnection(WebRtcSession session, IWebSocketConnection context, JsonData jsonMessage)
        {
            using (ManualResetEvent manualResetEvent = new ManualResetEvent(false))
            {
                Task task = Task.Factory.StartNew(() =>
                {
                    WebRtcNative.InitializeSSL();

                    using (session.WebRtc)
                    {
                        foreach (string stunServer in stunServers)
                        {
                            session.WebRtc.AddServerConfig(stunServer, string.Empty, string.Empty);
                        }

                        if (session.WebRtc.InitializePeerConnection())
                        {
                            manualResetEvent.Set();

                            while (!session.Cancel.Token.IsCancellationRequested &&
                                   session.WebRtc.ProcessMessages(1000))
                            {
                                //UnityEngine.Debug.Log(".");
                            }
                            session.WebRtc.ProcessMessages(1000);
                        }
                        else
                        {
                            context.Close();
                        }
                    }
                }, session.Cancel.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);

                if (manualResetEvent.WaitOne(9999))
                {
                    InitWebRTCCallbacks(session, context, jsonMessage);
                }
            }
        }
Example #2
0
        /// <summary>
        /// Initial WebRtc Component
        /// </summary>
        protected void RtcInitial()
        {
            try
            {
                WebRtcNative.InitializeSSL();
                ServerUrls.GetStunUrls().ForEach(url =>
                {
                    // Set Stun Servers
                    _WebRtc.AddServerConfig(url, string.Empty, string.Empty);
                });

                // Get audio control
                _WebRtc.SetAudio(true);
                _WebRtc.OpenVideoCaptureDevice("");
                // Set Video Capturer
                {
                    IVedioCaptureInfo cptr = new ScreenCaptureInfo();
                    _WebRtc.SetVideoCapturer(cptr.Width, cptr.Height, cptr.CaptureFps);
                }
                // Relative Connection callback
                {
                    // Be triggered On Success to generate Offer
                    _WebRtc.OnSuccessOffer += (sdp) =>
                    {
                        OfferSpdMsg msg = new OfferSpdMsg
                        {
                            Command = SocketMessage.OfferSpd,
                            SDP     = sdp
                        };
                        _SocketClient.Send(JsonConvert.SerializeObject(msg));
                    };

                    // Be triggered On Success to generate ICE
                    _WebRtc.OnIceCandidate += (sdp_mid, sdp_mline_index, sdp) =>
                    {
                        IceCandidateMsg msg = new IceCandidateMsg
                        {
                            Command       = SocketMessage.OnIceCandidate,
                            SDP           = sdp,
                            SdpMid        = sdp_mid,
                            SdpMlineIndex = sdp_mline_index,
                        };
                        _SocketClient.Send(JsonConvert.SerializeObject(msg));
                    };

                    // Be triggered On OfferRequest
                    _WebRtc.OnSuccessAnswer += (sdp) =>
                    {
                        SuccessAnswerMsg msg = new SuccessAnswerMsg
                        {
                            Command = SocketMessage.OnSuccessAnswer,
                            SDP     = sdp
                        };
                        _SocketClient.Send(JsonConvert.SerializeObject(msg));
                    };
                }
                // Set Local and Remote callback
                {
                    _WebRtc.OnRenderLocal  += _OnRenderLocalCallback;
                    _WebRtc.OnRenderRemote += _OnRenderRemoteCallback;
                }
                // Set Other callback
                {
                    _WebRtc.OnSuccessAnswer     += (sdp) => { Debug.WriteLine($"Success Get SDP:{sdp}"); };
                    _WebRtc.OnFailure           += (failure) => { Debug.WriteLine($"Failure Msg:{failure}"); };
                    _WebRtc.OnError             += (error) => { Debug.WriteLine($"Error Msg:{error}"); };
                    _WebRtc.OnDataMessage       += (dmsg) => { Debug.WriteLine($"OnDataMessage: {dmsg}"); };
                    _WebRtc.OnDataBinaryMessage += (dmsg) => { Debug.WriteLine($"OnDataBinaryMessage: {dmsg.Length}"); };
                }
            }
            catch (Exception ex) { }
        }
Example #3
0
        private void OnReceive(IWebSocketConnection context, string msg)
        {
            Debug.WriteLine($"OnReceive {context.ConnectionInfo.Id}: {msg}");

            if (!msg.Contains("command"))
            {
                return;
            }

            if (UserList.ContainsKey(context.ConnectionInfo.Id))
            {
                JsonData msgJson = JsonMapper.ToObject(msg);
                string   command = msgJson["command"].ToString();

                switch (command)
                {
                case offer:
                {
                    if (UserList.Count <= ClientLimit && !Streams.ContainsKey(context.ConnectionInfo.Id))
                    {
                        var session = Streams[context.ConnectionInfo.Id] = new WebRtcSession();
                        {
                            using (var go = new ManualResetEvent(false))
                            {
                                var t = Task.Factory.StartNew(() =>
                                    {
                                        WebRtcNative.InitializeSSL();

                                        using (session.WebRtc)
                                        {
                                            session.WebRtc.AddServerConfig("stun:stun.l.google.com:19302", string.Empty, string.Empty);
                                            session.WebRtc.AddServerConfig("stun:stun.anyfirewall.com:3478", string.Empty, string.Empty);
                                            session.WebRtc.AddServerConfig("stun:stun.stunprotocol.org:3478", string.Empty, string.Empty);
                                            session.WebRtc.OnSuccessOffer += WebRtc_OnSuccessOffer;
                                            //session.WebRtc.AddServerConfig("turn:192.168.0.100:3478", "test", "test");

                                            //session.WebRtc.SetAudio(MainForm.audio);

                                            //if (!Form.checkBoxVirtualCam.Checked)
                                            //{
                                            //    if (!string.IsNullOrEmpty(Form.videoDevice))
                                            //    {
                                            //        var vok = session.WebRtc.OpenVideoCaptureDevice(Form.videoDevice);
                                            //        Trace.WriteLine($"OpenVideoCaptureDevice: {vok}, {Form.videoDevice}");
                                            //        if (!vok)
                                            //        {
                                            //            return;
                                            //        }
                                            //    }
                                            //}
                                            //else
                                            //{
                                            //    session.WebRtc.SetVideoCapturer(MainForm.screenWidth,
                                            //                                    MainForm.screenHeight,
                                            //                                    MainForm.captureFps);
                                            //}

                                            var ok = session.WebRtc.InitializePeerConnection();
                                            if (ok)
                                            {
                                                go.Set();

                                                // javascript side makes the offer in this demo
                                                session.WebRtc.CreateDataChannel("msgDataChannel");
                                                session.WebRtc.CreateOffer();

                                                while (!session.Cancel.Token.IsCancellationRequested &&
                                                       session.WebRtc.ProcessMessages(1000))
                                                {
                                                    Debug.Write(".");
                                                }
                                                session.WebRtc.ProcessMessages(1000);
                                            }
                                            else
                                            {
                                                Trace.WriteLine("InitializePeerConnection failed");
                                                context.Close();
                                            }
                                        }
                                    }, session.Cancel.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);

                                if (go.WaitOne(9999))
                                {
                                    session.WebRtc.OnIceCandidate += delegate(string sdp_mid, int sdp_mline_index, string sdp)
                                    {
                                        if (context.IsAvailable)
                                        {
                                            JsonData j = new JsonData();
                                            j["command"]         = "OnIceCandidate";
                                            j["sdp_mid"]         = sdp_mid;
                                            j["sdp_mline_index"] = sdp_mline_index;
                                            j["sdp"]             = sdp;
                                            context.Send(j.ToJson());
                                        }
                                    };

                                    session.WebRtc.OnSuccessAnswer += delegate(string sdp)
                                    {
                                        if (context.IsAvailable)
                                        {
                                            JsonData j = new JsonData();
                                            j["command"] = "OnSuccessAnswer";
                                            j["sdp"]     = sdp;
                                            context.Send(j.ToJson());
                                        }
                                    };

                                    session.WebRtc.OnFailure += delegate(string error)
                                    {
                                        Trace.WriteLine($"OnFailure: {error}");
                                    };

                                    session.WebRtc.OnError += delegate(string error)
                                    {
                                        Trace.WriteLine($"OnError: {error}");
                                    };

                                    session.WebRtc.OnDataMessage += delegate(string dmsg)
                                    {
                                        Trace.WriteLine($"OnDataMessage: {dmsg}");
                                    };

                                    session.WebRtc.OnDataBinaryMessage += delegate(byte [] dmsg)
                                    {
                                        Trace.WriteLine($"OnDataBinaryMessage: {dmsg.Length}");
                                    };

                                    Form.ResetRemote();
                                    session.WebRtc.OnRenderRemote += delegate(IntPtr BGR24, uint w, uint h)
                                    {
                                        OnRenderRemote(BGR24, w, h);
                                    };

                                    Form.ResetLocal();
                                    session.WebRtc.OnRenderLocal += delegate(IntPtr BGR24, uint w, uint h)
                                    {
                                        OnRenderLocal(BGR24, w, h);
                                    };

                                    var d = msgJson["desc"];
                                    var s = d["sdp"].ToString();

                                    //session.WebRtc.OnOfferRequest(s);
                                }
                            }
                        }
                    }
                }
                break;

                case onicecandidate:
                {
                    var c = msgJson["candidate"];

                    var sdpMLineIndex = (int)c["sdpMLineIndex"];
                    var sdpMid        = c["sdpMid"].ToString();
                    var candidate     = c["candidate"].ToString();

                    var session = Streams[context.ConnectionInfo.Id];
                    {
                        session.WebRtc.AddIceCandidate(sdpMid, sdpMLineIndex, candidate);
                    }
                }
                break;
                }
            }
        }