FISLib_Old/Vinno.vCloud.Common.FIS/Consultation/VideoProvider.cs

using System;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using Vinno.FIS.TRTCClient.Common.Enum;
using Vinno.IUS.Common.Log;
using Vinno.IUS.Common.Network.Leaf;
using Vinno.IUS.Common.Network.Transfer;
using Vinno.vCloud.FIS.CrossPlatform.Common;
using Vinno.vCloud.FIS.CrossPlatform.Common.Consultation.Interface;
using Vinno.vCloud.FIS.CrossPlatform.Common.Enum;
using Vinno.vCloud.FIS.CrossPlatform.Common.LiveVideo;
using Vinno.vCloud.FIS.CrossPlatform.Common.LiveVideo.Interface;
using Vinno.vCloud.Protocol.Messages.Live;

namespace Vinno.vCloud.Common.FIS.Consultation
{
    public abstract class VideoProvider : IDisposable
    {
        private readonly ConsultationVideoFrameData _consultationVideoFrameData;
        private readonly object _connectionKeeperLock = new object();

        private ConsultationConnectionKeeper _connectionKeeper;
        private string _liveServiceUrl;
        protected ConsultationMemberInfo _consultationMemberInfo;
        protected bool _disposed;

        public event EventHandler Offlined;

        public ConsultationMemberInfo ConsultationMemberInfo
        {
            get => _consultationMemberInfo;
            set
            {
                _consultationMemberInfo = value;
            }
        }

        /// <summary>
        /// Video frame arrived
        /// </summary>
        public event EventHandler<ConsultationVideoFrameData> VideoFrameArrived;

        public VideoProvider(ConsultationMemberInfo consultationMemberInfo)
        {
            _consultationMemberInfo = consultationMemberInfo;
            _consultationVideoFrameData = new ConsultationVideoFrameData(null, _consultationMemberInfo);
        }

        public abstract void Dispose();

        protected void UpdateFrame(CPVideoFrameData data)
        {
            _consultationVideoFrameData.VideoFrameData = data;
            VideoFrameArrived?.Invoke(this, _consultationVideoFrameData);
        }

        public void StartConnectionKeeper(string roomId, string userId, ClientLeaf leaf, bool isDelayStart = true)
        {
            lock (_connectionKeeperLock)
            {
                if (leaf == null)
                {
                    Logger.WriteLineError("Start video provider Chat Connection Keeper failed,the leaf is null");
                    return;
                }
                var liveServiceUrl = GetLiveServiceUrl(leaf);
                if (string.IsNullOrEmpty(liveServiceUrl))
                {
                    Logger.WriteLineError($"Start video provider Chat Connection Keeper failed,the live Service Url is null!");
                    return;
                }
                _connectionKeeper = new ConsultationConnectionKeeper(roomId, userId, liveServiceUrl);
                _connectionKeeper.Offlined += OnOfflined;
                _connectionKeeper.ClientLeafClosed += OnConnectionKeeperLeafClose;
                _connectionKeeper.Start(isDelayStart);
            }
        }

        /// <summary>
        /// Get live service url
        /// </summary>
        /// <returns></returns>
        private string GetLiveServiceUrl(ClientLeaf leaf)
        {
            try
            {
                if (string.IsNullOrEmpty(_liveServiceUrl))
                {
                    using (var request = MessagePool.GetMessage<GetLiveServiceUrlRequest>())
                    {
                        var result = leaf.Send(request);
                        if (result != null)
                        {
                            var resultMessage = GetLiveServiceUrlResult.Convert(result);
                            if (resultMessage != null)
                            {
                                _liveServiceUrl = resultMessage.Url;
                            }
                        }
                    }
                }
                return _liveServiceUrl;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Get live service url error: {ex}");
            }

            return null;
        }

        private void OnConnectionKeeperLeafClose(object sender, EventArgs e)
        {
            lock (_connectionKeeperLock)
            {
                _connectionKeeper.Offlined -= OnOfflined;
                _connectionKeeper.ClientLeafClosed -= OnConnectionKeeperLeafClose;
                _connectionKeeper.Stop();
                Offlined?.Invoke(this, e);
            }
        }

        private void OnOfflined(object sender, EventArgs e)
        {
            Offlined?.Invoke(this, e);
            Logger.WriteLineInfo($"Connection keeper offline ");
        }

        internal void StopConnectionKeeper()
        {
            if (_connectionKeeper != null)
            {
                _connectionKeeper.Offlined -= OnOfflined;
                _connectionKeeper.ClientLeafClosed -= OnConnectionKeeperLeafClose;
                _connectionKeeper?.Stop();
                _connectionKeeper = null;
            }
        }
    }

    public class RtcVideoProvider : VideoProvider
    {
        public RtcVideoProvider(ConsultationMemberInfo consultationMemberInfo) : base(consultationMemberInfo)
        {
        }

        public override void Dispose()
        {
        }
    }

    public class RtmpVideoProvider : VideoProvider
    {
        private IRtmpPlayer _smartPlayer;
        private int _videoBufferSize = 300;
        private bool _isClosed;
        private readonly object _locker = new object();

        public RtmpVideoProvider(ConsultationMemberInfo consultationMemberInfo) : base(consultationMemberInfo)
        {
            CreateSmartPlayer(consultationMemberInfo.PullRtmpUrl);
        }

        private void CreateSmartPlayer(string url)
        {
            if (!string.IsNullOrEmpty(url))
            {
                _smartPlayer = CrossPlatformHelper.Instance.RtmpPlayerCreator.CreateLivePlayer(url);
                _smartPlayer.Buffer = _videoBufferSize;
                _smartPlayer.VideoFrameReceived += OnVideoFrameReceived;
                Task.Run(async () =>
                {
                    await Task.Delay(3000);
                    lock (_locker)
                    {
                        if (!_isClosed)
                        {
                            _smartPlayer.Play();
                        }
                    }
                });
            }
        }

        private void CloseSmartPlayer()
        {
            if (_smartPlayer != null)
            {
                lock (_locker)
                {
                    _isClosed = true;
                }
                _smartPlayer.VideoFrameReceived -= OnVideoFrameReceived;
                _smartPlayer.Stop();
                _smartPlayer = null;
            }
        }

        private void OnVideoFrameReceived(object sender, CPVideoFrameData e)
        {
            UpdateFrame(e);
        }

        public override void Dispose()
        {
            if (_disposed)
                return;
            CloseSmartPlayer();
            StopConnectionKeeper();
            _disposed = true;
        }

        ~RtmpVideoProvider()
        {
        }
    }

    public class RtmpVideoPusher : VideoProvider
    {
        private IRtmpPusherV2 _smartPublisher;
        private CPVideoFrameData _videoFrameData;

        public RtmpVideoPusher(ConsultationMemberInfo consultationMemberInfo, string videoDeviceId, string micDeviceId) : base(consultationMemberInfo)
        {
            var deviceInfo = new CPVideoDeviceOutputInfo
            {
                VideoDeviceId = videoDeviceId,
                IdForServer = "",
                VideoDeviceSourceType = EnumVideoDeviceSourceType.Camera,
                OutputWidth = 640,
                OutputHeight = 480,
                Category = EnumLiveChannelCategory.Main,
            };
            _smartPublisher = CrossPlatformHelper.Instance.RtmpPusherCreator.CreateLivePusherV2(deviceInfo, consultationMemberInfo.PushUrl, micDeviceId, 640, 480);
            _smartPublisher.ImageFrameReceived += OnImageFrameReceived;
            _smartPublisher.Start();
        }

        ~RtmpVideoPusher()
        {
        }

        public override void Dispose()
        {
            if (_disposed)
                return;
            if (_smartPublisher != null)
            {
                _smartPublisher.ImageFrameReceived -= OnImageFrameReceived;
                _smartPublisher.Stop();
                _smartPublisher.Dispose();
                _smartPublisher = null;
            }
            StopConnectionKeeper();
            _disposed = true;
        }

        private void OnImageFrameReceived(object sender, ImageFrameData e)
        {
            if (_videoFrameData == null)
            {
                _videoFrameData = new CPVideoFrameData(e.Width, e.Height, new byte[e.Size]);
            }
            else if (_videoFrameData.Height != e.Height || _videoFrameData.Width != e.Width)
            {
                _videoFrameData.Height = e.Height;
                _videoFrameData.Width = e.Width;
                _videoFrameData.Data = new byte[e.Size];
            }
            Marshal.Copy(e.Data, _videoFrameData.Data, 0, e.Size);
            UpdateFrame(_videoFrameData);
        }

        public void SetMute(bool isMute)
        {
            if (_smartPublisher != null)
            {
                _smartPublisher.SetMute(isMute);
            }
        }

        public void SwitchCamera()
        {
            if (_smartPublisher != null)
            {
                //TODOFelix
            }
        }
    }
}