FISLib_Old/Vinno.FIS.Sonopost/Features/Web/WebPreviewHandler.cs

using FISLib.LiveVideo;
using System;
using System.Drawing;
using System.IO;
using System.Net;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Vinno.FIS.Sonopost.Managers;
using Vinno.FIS.Sonopost.Managers.Interfaces;
using Vinno.IUS.Common.Log;

namespace Vinno.FIS.Sonopost.Features.Web
{
    internal class WebPreviewHandler
    {
        private const int PREVIEW_WIDTH = 360;
        private readonly ILiveVideoManager _liveVideoManager;
        private bool _busy = false;
        private const int FRAME_IGNORE_COUNT = 2; // 采集24帧/预览12帧 = 2
        private int _curFrameSignIndex = 0;

        public event EventHandler<byte[]> PreviewImageReceived;

        public WebPreviewHandler()
        {
            _liveVideoManager = AppManager.Instance.GetManager<ILiveVideoManager>();
            _liveVideoManager.PreviewImageReceived += OnPreviewImageReceived;
        }

        public async void HandleRequest(HttpListenerContext context)
        {
            string sessionId = Guid.NewGuid().ToString("N");
            HttpListenerWebSocketContext webSocketContext;
            try
            {
                webSocketContext = await context.AcceptWebSocketAsync(subProtocol: null);
                string remoteAddress = context.Request.RemoteEndPoint.Address.ToString();
                Logger.WriteLineInfo($"[{nameof(WebPreviewHandler)}] connected. ip: {remoteAddress}");
            }
            catch (Exception ex)
            {
                context.Response.StatusCode = 500;
                context.Response.Close();
                Logger.WriteLineError($"[{nameof(WebPreviewHandler)}] connect failed. ex: {ex}");
                return;
            }

            WebSocket webSocket = webSocketContext.WebSocket;
            object loker = new object();
            EventHandler<byte[]> action = (object sender, byte[] e) =>
            {
                if (webSocket.State == WebSocketState.Open)
                {
                    lock (loker)
                    {
                        SendMessage(webSocket, e).GetAwaiter().GetResult();
                    }
                }
            };
            PreviewImageReceived += action;
            try
            {
                byte[] receiveBuffer = new byte[1024];
                while (webSocket.State == WebSocketState.Open)
                {
                    WebSocketReceiveResult receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);
                    if (receiveResult.MessageType == WebSocketMessageType.Close)
                    {
                        await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
                        Logger.WriteLineInfo($"[{nameof(WebPreviewHandler)}] remote disconnected.");
                    }
                    else
                    {
                        byte[] data = Encoding.UTF8.GetBytes("i got u!");
                        await SendMessage(webSocket, data);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineInfo($"[{nameof(WebPreviewHandler)}]{nameof(HandleRequest)} error: ex: {ex}");
            }
            finally
            {
                PreviewImageReceived -= action;
                if (webSocket != null)
                {
                    webSocket.Dispose();
                }
            }
        }

        private unsafe void OnPreviewImageReceived(object sender, FISImageFrameData frame)
        {
            if (frame.Data == null || frame.Width == 0 || frame.Height == 0)
            {
                return;
            }
            var bitmapSize = frame.Width * frame.Height * 4;
            if (bitmapSize < frame.Size)
            {
                return;
            }
            // 跳过帧处理
            _curFrameSignIndex++;
            if (_curFrameSignIndex >= FRAME_IGNORE_COUNT)
            {
                _curFrameSignIndex = 0;
                return;
            }
            if (_busy) return;
            _busy = true;
            try
            {
                using (Bitmap source = new Bitmap(frame.Width, frame.Height, System.Drawing.Imaging.PixelFormat.Format32bppRgb))
                {
                    var locker = source.LockBits(new Rectangle(0, 0, frame.Width, frame.Height)
                                        , System.Drawing.Imaging.ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format32bppRgb);
                    Buffer.MemoryCopy(frame.Data.ToPointer(), locker.Scan0.ToPointer(), frame.Size, frame.Size);
                    source.UnlockBits(locker);

                    if (frame.Width - PREVIEW_WIDTH > 200)
                    {
                        int height = (int)(1.0f * PREVIEW_WIDTH / frame.Width * frame.Height);
                        using (Bitmap dest = new Bitmap(source, PREVIEW_WIDTH, height))
                        {
                            using (MemoryStream ms = new MemoryStream())
                            {
                                dest.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
                                PreviewImageReceived?.Invoke(null, ms.GetBuffer());
                            }
                        }
                    }
                    else
                    {
                        using (MemoryStream ms = new MemoryStream())
                        {
                            source.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
                            PreviewImageReceived?.Invoke(null, ms.GetBuffer());
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"[{nameof(WebPreviewHandler)}]{nameof(OnPreviewImageReceived)} error:{ex}");
            }
            finally
            {
                Thread.Sleep(1);
                _busy = false;
            }
        }

        private async Task SendMessage(WebSocket webSocket, byte[] data)
        {
            try
            {
                int bufferSize = 10 * 1024;
                int seek = 0;
                ArraySegment<byte> buffer;
                while (seek < data.Length && webSocket.State == WebSocketState.Open)
                {
                    int left = data.Length - seek;
                    if (left < bufferSize)
                    {
                        buffer = new ArraySegment<byte>(data, seek, left);
                        await webSocket.SendAsync(buffer, WebSocketMessageType.Binary, true, CancellationToken.None);
                    }
                    else
                    {
                        buffer = new ArraySegment<byte>(data, seek, bufferSize);
                        await webSocket.SendAsync(buffer, WebSocketMessageType.Binary, false, CancellationToken.None);
                    }
                    seek += bufferSize;
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"[{nameof(WebPreviewHandler)}]{nameof(SendMessage)} error:{ex}");
            }
        }
    }
}