private void startServer(string a_streamsXml)
 {
     if (s == null)
     {
         s = RtmpClient.createInstance(a_streamsXml, mStreamSiteComboBox.Text);
     }
 }
        public static RtmpClient createInstance(string a_streamsXml, string a_url)
        {
            RtmpClient l_instance = null;

            try
            {
                do
                {
                    l_instance = new RtmpClient();

                    l_instance.m_handler = Connect(a_streamsXml, a_url);
                } while (false);
            }
            catch (Exception)
            {
            }

            return(l_instance);
        }
        private async void mLaunchButton_Click(object sender, RoutedEventArgs e)
        {
            if (!m_socketAccessable)
            {
                return;
            }

            mLaunchButton.IsEnabled = false;

            do
            {
                if (mLaunchButton.Content == "Stop")
                {
                    if (mISession != null)
                    {
                        await mISession.closeSessionAsync();

                        mLaunchButton.Content = "Launch";
                    }

                    mISession = null;

                    if (s != null)
                    {
                        s.disconnect();
                    }

                    s = null;

                    mLaunchButton.IsEnabled = true;

                    break;
                }


                string lxmldoc = await mCaptureManager.getCollectionOfSinksAsync();

                XmlDocument doc = new XmlDocument();

                doc.LoadXml(lxmldoc);

                var lSinkNode = doc.SelectSingleNode("SinkFactories/SinkFactory[@GUID='{3D64C48E-EDA4-4EE1-8436-58B64DD7CF13}']");

                if (lSinkNode == null)
                {
                    break;
                }

                var lContainerNode = lSinkNode.SelectSingleNode("Value.ValueParts/ValuePart[1]");

                if (lContainerNode == null)
                {
                    break;
                }

                var lReadMode = setContainerFormat(lContainerNode);

                var lSinkControl = await mCaptureManager.createSinkControlAsync();

                ISampleGrabberCallbackSinkFactoryAsync lSampleGrabberCallbackSinkFactory = await lSinkControl.createSampleGrabberCallbackSinkFactoryAsync(
                    lReadMode);

                int lIndexCount = 0;

                var lVideoStreamSourceNode = await createVideoStream(lSampleGrabberCallbackSinkFactory, lIndexCount);

                var lAudioStreamSourceNode = await createAudioStream(lSampleGrabberCallbackSinkFactory, lIndexCount);


                XmlDocument l_streamMediaTypesXml = new XmlDocument();

                XmlNode ldocNode = l_streamMediaTypesXml.CreateXmlDeclaration("1.0", "UTF-8", null);

                l_streamMediaTypesXml.AppendChild(ldocNode);

                XmlElement rootNode = l_streamMediaTypesXml.CreateElement("MediaTypes");

                l_streamMediaTypesXml.AppendChild(rootNode);


                var lAttr = l_streamMediaTypesXml.CreateAttribute("StreamName");

                lAttr.Value = mStreamNameTxtBx.Text;

                rootNode.Attributes.Append(lAttr);

                List <object> lSourceMediaNodeList = new List <object>();

                if (lVideoStreamSourceNode.Item1 != null)
                {
                    doc = new XmlDocument();

                    doc.LoadXml(lVideoStreamSourceNode.Item2);

                    var lMediaType = doc.SelectSingleNode("MediaType");

                    if (lMediaType != null)
                    {
                        rootNode.AppendChild(l_streamMediaTypesXml.ImportNode(lMediaType, true));
                    }

                    lSourceMediaNodeList.Add(lVideoStreamSourceNode.Item1);
                }

                if (lAudioStreamSourceNode.Item1 != null)
                {
                    doc = new XmlDocument();

                    doc.LoadXml(lAudioStreamSourceNode.Item2);

                    var lMediaType = doc.SelectSingleNode("MediaType");

                    if (lMediaType != null)
                    {
                        rootNode.AppendChild(l_streamMediaTypesXml.ImportNode(lMediaType, true));
                    }

                    lSourceMediaNodeList.Add(lAudioStreamSourceNode.Item1);
                }

                var lSessionControl = await mCaptureManager.createSessionControlAsync();

                if (lSessionControl == null)
                {
                    break;
                }

                mISession = await lSessionControl.createSessionAsync(
                    lSourceMediaNodeList.ToArray());

                if (mISession == null)
                {
                    break;
                }

                startServer(l_streamMediaTypesXml.InnerXml);

                await mISession.registerUpdateStateDelegateAsync(UpdateStateDelegate);

                await mISession.startSessionAsync(0, Guid.Empty);

                mLaunchButton.Content = "Stop";
            } while (false);

            mLaunchButton.IsEnabled = true;
        }
        void UpdateStateDelegate(uint aCallbackEventCode, uint aSessionDescriptor)
        {
            SessionCallbackEventCode k = (SessionCallbackEventCode)aCallbackEventCode;

            switch (k)
            {
            case SessionCallbackEventCode.Unknown:
                break;

            case SessionCallbackEventCode.Error:
                break;

            case SessionCallbackEventCode.Status_Error:
                break;

            case SessionCallbackEventCode.Execution_Error:
                break;

            case SessionCallbackEventCode.ItIsReadyToStart:
                break;

            case SessionCallbackEventCode.ItIsStarted:
                break;

            case SessionCallbackEventCode.ItIsPaused:
                break;

            case SessionCallbackEventCode.ItIsStopped:
                break;

            case SessionCallbackEventCode.ItIsEnded:
                break;

            case SessionCallbackEventCode.ItIsClosed:
            {
                Dispatcher.Invoke(
                    DispatcherPriority.Normal,
                    new Action(() => mLaunchButton.Content = "Launch"));

                Dispatcher.Invoke(
                    DispatcherPriority.Normal,
                    new Action(() =>
                    {
                        if (s != null)
                        {
                            s.disconnect();
                        }

                        s = null;
                    }
                               ));
            }
            break;

            case SessionCallbackEventCode.VideoCaptureDeviceRemoved:
            {
                Dispatcher.Invoke(
                    DispatcherPriority.Normal,
                    new Action(() => mLaunchButton_Click(null, null)));
            }
            break;

            default:
                break;
            }
        }