其他分享
首页 > 其他分享> > 基于superSocket——AForge的UDP传输摄像案例——服务端

基于superSocket——AForge的UDP传输摄像案例——服务端

作者:互联网

服务端

业务逻辑

这里写图片描述

这里写图片描述

 这里打个比方,有个陌生人(摄像客户端)一直在敲你家的门,但是你没开,等到你爸(Web客户端)给你一个命令开门,你就把门打开,让陌生人进来,并进行核对信息(信息匹配),原来是隔壁老王,给你带了好吃的(UDP数据),你于是就把吃的留下来了。

准备操作:
用superSocket接受客户端发来的UDP数据,superSocket开源框架网址:https://github.com/kerryjiang/SuperSocket。
在NuGet中添加:SuperSocket,SuperSocket.Engine,SuperSocket.ProtoBase
用FFMPEG、VFW进行录入视频。
①.新建UdpTestSession继承AppSession,用于建立会话;

using SuperSocket.SocketBase;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SuperSocket.SocketBase.Protocol;

namespace Receive.udp
{
    public class UdpTestSession : AppSession<UdpTestSession, MyUdpRequestInfo>
    {
        protected override void OnSessionClosed(CloseReason reason)
        {
            base.OnSessionClosed(reason);
        }

        protected override void OnSessionStarted()
        {
            Console.WriteLine("start Session");
            base.OnSessionStarted();
        }

        protected override void HandleUnknownRequest(MyUdpRequestInfo requestInfo)
        {
            Console.WriteLine("unKnownRequest");
            base.HandleUnknownRequest(requestInfo); 
        }
    }
}

②.新建MyUdpRequestInfo,用于封装会话信息与传输的数据信息。

using Receive.udp;
using SuperSocket.ProtoBase;
using SuperSocket.SocketBase.Protocol;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Receive.udp
{

    public class MyUdpRequestInfo : UdpRequestInfo, IPackageInfo
    {
        public MyUdpRequestInfo(string key, string sessionID)
            : base(key, sessionID)
        {

        }


        public byte[] Body { get; set; }


    }

}

③.新建MyReceiveFilter,用于处理(过滤)传输的数据,封装成MyUdpRequestInfo。

其中这步中,我将客户端分为web客户端与摄像设备客户端,web 发送的数据类型 密钥+设备号+录像时间+结束标志,录像设备发送的数据 密钥+设备号+照片+结束标志。其中密钥与设备号可以设置固定长度,不足补休止符。(见下辅助类)

using System.Linq;


namespace Receive.udp
{

   public class MyReceiveFilter : SuperSocket.SocketBase.Protocol.IReceiveFilter<MyUdpRequestInfo>
    {
        public int LeftBufferSize
        {
            get { return 0; }
        }

        public SuperSocket.SocketBase.Protocol.IReceiveFilter<MyUdpRequestInfo> NextReceiveFilter
        {
            get { return this; }
        }

        public SuperSocket.SocketBase.Protocol.FilterState State
        {
            get; private set;
        }
        /// <summary>
        /// 过滤器接受信息 解析byte[]
        /// </summary>
        /// <param name="readBuffer"></param>
        /// <param name="offset"></param>
        /// <param name="length"></param>
        /// <param name="toBeCopied"></param>
        /// <param name="rest"></param>
        /// <returns></returns>
        public MyUdpRequestInfo Filter(byte[] readBuffer, int offset, int length, bool toBeCopied, out int rest)
        {
            var endFlag = HandleUdpUtils.getEndFlagStr(readBuffer, length);
            if (!endFlag.Equals(HandleUdpUtils.IMG_END_FLAG)||!endFlag.Equals(HandleUdpUtils.WEB_END_FLAG)) //判断结束标志
            {
                int endFlagSize = 2;
                string privateKey =  HandleUdpUtils.getPrivateKey(readBuffer);
                string sesssionId = HandleUdpUtils.getMachineCode(readBuffer); //machineCode 当成sessionId
                rest = 0;
                byte[] body = readBuffer.Skip(HandleUdpUtils.MACHINE_CODE_LENGTH).Take(length - HandleUdpUtils.MACHINE_CODE_LENGTH - endFlagSize).ToArray();
                return new MyUdpRequestInfo(privateKey, sesssionId) { Body = body };
            }else
            {
                rest = 0;
                return null;
            }
        }

        public void Reset()
        {

        }
    }
}

④.新建UdpAppServer

    集中处理传递的数据,根据不同的客户端请求,进行不一样的操作。web设备的请求则开启摄像,摄像设备则进行视频的录入。

using SuperSocket.SocketBase;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SuperSocket.SocketBase.Config;
using SuperSocket.SocketBase.Protocol;
using SuperSocket.ProtoBase;

using SuperSocket.SocketBase.Logging;
using System.Collections.Concurrent;
using log4net;
using System.IO;
using System.Drawing;

namespace Receive.udp
{
    class UdpAppServer : AppServer<UdpTestSession, MyUdpRequestInfo>
    {
        public static readonly log4net.ILog LOG = log4net.LogManager.GetLogger("VideoSocket");
        public static readonly string PATH = "D:\\ReadVersionD\\video";
        public static Dictionary<string, string> PRIVATE_KEY = new Dictionary<string, string>(); //deviceCode->key
        public static readonly int MIN_IMG_SIZE = 100;
        public UdpAppServer()
              : base(new DefaultReceiveFilterFactory<MyReceiveFilter, MyUdpRequestInfo>())
        {

        }

        public static ConcurrentDictionary<string, VideoPackageModel> FILE_WRITERS = new ConcurrentDictionary<string, VideoPackageModel>(); //读取文件

        protected override void OnSystemMessageReceived(string messageType, object messageData)
        {
            Console.WriteLine(messageType);
            base.OnSystemMessageReceived(messageType, messageData);
        }


        /// <summary>
        /// 过滤器后 进入该方法
        /// </summary>
        /// <param name="session"></param>
        /// <param name="requestInfo"></param>
        protected override void ExecuteCommand(UdpTestSession session, MyUdpRequestInfo requestInfo)
        {
            if (requestInfo.Key.Equals(HandleUdpUtils.WEB_SESSION_KEY))
            {
                handleWebUdpSocket(requestInfo, session);
                return;
            }
            string privateKey = "";
            if (PRIVATE_KEY.TryGetValue(requestInfo.SessionID, out privateKey) && privateKey.Equals(requestInfo.Key))
            {
                handleDeviceInfo(requestInfo);
                session.Send("receive success");
            }
            else
            {
                LOG.Error(requestInfo.SessionID + "|不存在该设备");
            }

        }





        #region WEB

        /// <summary>
        /// 发送socket 到web客户端
        /// </summary>
        /// <param name="requestInfo"></param>
        /// <param name="session"></param>
        private void handleWebUdpSocket(MyUdpRequestInfo requestInfo, UdpTestSession session)
        {
            switch (handleWebCommand(requestInfo))
            {
                case 1:
                    session.Send("addOK");
                    break;
                case 0:
                    session.Send("dataError");
                    break;
                case -1:
                    session.Send("alreadyExit");
                    break;
            }      
        }


        /// <summary>
        /// body的组成 : 5|DateType
        /// </summary>
        /// <param name="requestInfo"></param>
        private int handleWebCommand(MyUdpRequestInfo requestInfo)
        {
            var startTime = DateTime.Now;
            DateTime endTime;
            int seconds = HandleUdpUtils.getLasingTime(requestInfo.Body,out startTime,out endTime);
            if (seconds == 0)
            {
                LOG.Error(requestInfo.SessionID + "|获取录像持续时间失败!");
                return 0;
            }          
            string privateKey = "";
            PRIVATE_KEY.TryGetValue(requestInfo.SessionID,out privateKey);



            if (!addVideoPackageModel(requestInfo.SessionID,privateKey,startTime,endTime,seconds))
            {
                Console.WriteLine(requestInfo.SessionID + "|添加失败!");
                LOG.Error(requestInfo.SessionID + "|添加失败!");//TODO 存在更新的操作
                return -1;
            }
            else {
                Console.WriteLine(requestInfo.SessionID + "|添加成功!");
                LOG.Info(requestInfo.SessionID + "|添加成功!");
                return 1;
            }        
        }

        /// <summary>
        /// 添加VideoPackageModel
        /// </summary>
        /// <param name="sessionId"></param>
        /// <param name="model"></param>
        /// <returns></returns>
        private bool addVideoPackageModel(string sessionId, string privateKey,DateTime startTime,DateTime endTime ,int seconds)
        {
            VideoPackageModel oldModel;

            if(FILE_WRITERS.TryGetValue(sessionId,out oldModel))
            {
                if (oldModel.Disposed) //可能没删除
                {
                    FILE_WRITERS.TryRemove(sessionId,out oldModel);
                    VideoPackageModel model = new VideoPackageModel(privateKey, sessionId, startTime, endTime, seconds, PATH); //避免计时器出错
                    return FILE_WRITERS.TryAdd(sessionId, model);
                }
                return false;
            }else
            {
                VideoPackageModel model = new VideoPackageModel(privateKey, sessionId, startTime, endTime, seconds, PATH);
                return FILE_WRITERS.TryAdd(sessionId, model);
            }
        }


        #endregion



        #region 录像设备
        /// <summary>
        /// 处理设备发来的视频
        /// </summary>
        /// <param name="requestInfo"></param>
        private void handleDeviceInfo(MyUdpRequestInfo requestInfo)
        {
            VideoPackageModel videoModel = getVideoPackage(requestInfo.SessionID);

            if (videoModel == null || requestInfo.Body.Length< MIN_IMG_SIZE) {
                return;
            }

            MemoryStream stream = null;
            stream = new MemoryStream(requestInfo.Body);
            Bitmap img = null;
            try
            {
                img = HandleUdpUtils .BytesToBitmap(requestInfo.Body) ;
                // img.Save("D:\\JGHPCXReadVersionD\\video\\001\\test.jpg");
                 videoModel.wirteVideo(img);

            }
            catch (Exception e)
            {
                LOG.Error(requestInfo.SessionID+"|"+e.ToString());
                Console.WriteLine(requestInfo.SessionID + "|" + e.ToString());
            }finally
            {
                if(stream!=null)
                stream.Close();
                if(img!=null)
                img.Dispose();
            } 
        }

        /// <summary>
        /// getVideoPackage
        /// </summary>
        /// <param name="machineCode"></param>
        /// <returns></returns>
        private VideoPackageModel getVideoPackage(string sessionId)
        {
            VideoPackageModel video;
            if(FILE_WRITERS.TryGetValue(sessionId, out video))
            {
                LOG.Error(sessionId + "|设备未开启录像");
            }
            return video;
        }


        #endregion


    }
}

辅助类——VideoPackageModel:用于封装Video数据与操作。

using Accord.Video.FFMPEG;
using Accord.Video.VFW;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Timers;

namespace Receive.udp
{
    public  class VideoPackageModel: IDisposable
    {
        //校验码
        public string PrivateKey { get; }
        //机器码
        public string SessionId { get;}
        //录制开始时间
        public DateTime StartTime { get; }
        //录制结束时间
        public DateTime EndTime { get; }
        //视频路径
        public string VideoPath { get; }
        //计时器
        private System.Timers.Timer Timer = new System.Timers.Timer();
        //视频写入(32位的FFMPEG)
       // private VideoFileWriter Writer = new VideoFileWriter();

        //是否释放资源

        public bool  Disposed = false;
        //avi读取
        private AVIWriter aviWriter = new AVIWriter("wmv3");

        //VideoFileWriter 所需的时间戳
        DateTime _firstFrameTime;

        public VideoPackageModel(string privateKey,string sessionId,DateTime startTime,DateTime endTime,int second,string path)
        {
            SessionId = sessionId;
            PrivateKey = privateKey;
            StartTime = startTime;
            EndTime = endTime;
            _firstFrameTime = DateTime.Now;
            int width = 848;    //录制视频的宽度
            int height = 480;   //录制视频的高度
            int fps = 20;
            path = getTimeStamp(path);


            aviWriter.Open(path, Convert.ToInt32( width), Convert.ToInt32( height));
         //  Writer.Open(path, width, height, fps, VideoCodec.Default);

            int lastTime = second * 1000;
            Console.WriteLine("持续时间"+lastTime);

            Timer.Elapsed += new System.Timers.ElapsedEventHandler(endTimeEvent);   //到达时间的时候执行事件;
            Timer.AutoReset = false;   //设置是执行一次(false)还是一直执行(true);
            Timer.Interval = lastTime;//设置定时间隔(毫秒为单位)
            Timer.Enabled = true;

        }

        /// <summary>
        /// video 存储路径
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        private string  getTimeStamp(string path) {
            System.DateTime originTime = TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1));
            long timeStamp = (long)(StartTime - originTime).TotalMilliseconds;
            string filePath = path + "\\" + SessionId;
            if (!Directory.Exists(filePath))
            {
                Directory.CreateDirectory(filePath);
            }
            return filePath + "\\" + timeStamp + ".avi";
        }



        /// <summary>
        /// 结束资源
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private  void endTimeEvent(object sender, ElapsedEventArgs e)
        {
            using (this)
            {

                VideoPackageModel videoModel;
                UdpAppServer.FILE_WRITERS.TryRemove(SessionId, out videoModel);
                Console.WriteLine("endWriters");
            }
        }

        /// <summary>
        /// 写入视频
        /// </summary>
        /// <param name="img"></param>
        public void wirteVideo(Bitmap  img)
        {
            try
            {
                lock (aviWriter)
                {
                    if (aviWriter != null)
                        aviWriter.AddFrame(img);
                }


            //    if(Writer != null && Writer.IsOpen)
            //    {
            //        lock (Writer)
            //        {
            //            if (_firstFrameTime != null)
            //            {

            //                Writer.WriteVideoFrame(img, TimeSpan.FromMilliseconds(DateTime.Now.ToUniversalTime().Subtract(
            //new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)
            //).TotalMilliseconds - _firstFrameTime.ToUniversalTime().Subtract(
            //new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)
            //).TotalMilliseconds));
            //            }
            //            else
            //            {
            //                Writer.WriteVideoFrame(img);
            //                _firstFrameTime = DateTime.Now;
            //            }
            //        }
            //    }

            }
            catch (Exception e)
            {
                _firstFrameTime = DateTime.Now;
                Console.WriteLine(e.ToString());
            }

        }

        #region Dispose 操作

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        protected virtual void Dispose(bool disposing)
      {
       if (!Disposed)
       {
           if (disposing)
            {
                    if (aviWriter != null)
                    {
                        try
                        {
                            aviWriter.Close();
                            aviWriter.Dispose();
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e);

                        }
                        finally
                        {
                            aviWriter = null;
                        }


                    }
                    if(Timer!=null)
                    {
                        Timer.Dispose();
                        Timer = null;
                    }
           }
                //处理非托管
                Disposed = true;
        }
     }




     ~VideoPackageModel()
     {
        Dispose(false);
     }


        #endregion

    }
}

辅助类——字节数组操作类。

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;

namespace Receive.udp
{
    //handle byte 
    public class HandleUdpUtils
    {
        public static readonly string IMG_END_FLAG = "##"; //设备传来的结束标志

        public static readonly string WEB_END_FLAG = "**"; //WEB传来的结束标志

        public static readonly string WEB_SESSION_KEY = "f21c2a0689443179082e02f8f44079";

        public static readonly int KEY_LENGTH = 40;

        public static readonly int MACHINE_CODE_LENGTH = 80;

        public enum TimeTypeEnum { Day,Hour, Minute,Second }


        /// <summary>
        /// 读取byte[]并转化为图片
        /// </summary>
        /// <param name="bytes">byte[]</param>
        /// <returns>Image</returns>
        public static Bitmap BytesToBitmap(byte[] Bytes)
        {
            MemoryStream stream = null;
            try
            {
                stream = new MemoryStream(Bytes);
                return new Bitmap((Image)new Bitmap(stream));
            }
            catch (ArgumentNullException ex)
            {
                throw ex;
            }
            catch (ArgumentException ex)
            {
                throw ex;
            }
            finally
            {
                stream.Close();
            }
        }

        /// <summary>
        /// 得到传输来的结束标志
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static string getEndFlagStr(byte[] bytes, int length)
        {
            int begin = length - 2;
            int size = 2;
            string endFlag = Encoding.ASCII.GetString(bytes, begin, size);
            return String.IsNullOrEmpty(endFlag)?"":endFlag;
        }

        /// <summary>
        /// 根据标志判断客户端类型
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static int getClientType(byte[] bytes, int length)
        {
          var endFlagStr=  getEndFlagStr(bytes ,length);
            if (endFlagStr.Equals(WEB_END_FLAG)) //web
                return 1;
            else if (endFlagStr.Equals(IMG_END_FLAG)) //device
                return 2;
            else
                return 0;

        }

        /// <summary>
        /// 长度为40的密钥
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static string getPrivateKey(byte[] bytes)
        {
            string privateKey = "";
            if (bytes.Length <= KEY_LENGTH)
                return privateKey;
            privateKey = Encoding.ASCII.GetString(bytes, 0, KEY_LENGTH).TrimEnd('\0'); //取掉休止符

            return privateKey;
        }

       /// <summary>
       /// 得到机器码
       /// </summary>
       /// <param name="bytes"></param>
       /// <returns></returns>
        public static string getMachineCode(byte[] bytes)
        {
            string machineCode = "";
            if (bytes.Length <= MACHINE_CODE_LENGTH)
                return machineCode;
            machineCode = Encoding.ASCII.GetString(bytes, KEY_LENGTH, MACHINE_CODE_LENGTH-KEY_LENGTH).TrimEnd
                ('\0');

            return machineCode;
        }


        /// <summary>
        /// 密钥构造成字节数组 (客户端)
        /// </summary>
        /// <param name="privateKey"></param>
        /// <returns></returns>
        public static byte[] InitPrivateKeyBytes(string privateKey)
        {
            byte[] fixedBytes = new byte[40];
            if (String.IsNullOrEmpty(privateKey))
                return fixedBytes;
            var bytes = Encoding.Default.GetBytes(privateKey);

            for (int i = 0; i < bytes.Length; i++)
                fixedBytes[i] = bytes[i];


            return fixedBytes;

        }


        /// <summary>
        /// web取截止时间
        /// </summary>
        /// <param name="body"></param>
        /// <param name="endTime"></param>
        /// <returns></returns>
        public static bool StrToTime(byte[] body, out DateTime endTime)
        {
            string str = Encoding.Default.GetString(body);
            endTime = DateTime.Now;
            try
            {
                DateTime dateTime = Convert.ToDateTime(str);
                endTime = dateTime;
            }
            catch (Exception)
            {
                return false;
            }

            return true;
        }

        /// <summary>
        /// 得到计时时间
        /// </summary>
        /// <param name="body"></param>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <returns></returns>
        public static int getLasingTime(byte[] body,out DateTime startTime,out DateTime endTime)
        {

            string str = Encoding.Default.GetString(body);
            int index = str.IndexOf("|");
            startTime = DateTime.Now;
            endTime = DateTime.Now;
            if (index == -1)
                return 0;                
            var timeType = str.Substring(index+1); //5|Second
            var num = 0;
            try
            {
                num = Convert.ToInt32(str.Substring(0, index));
            }
            catch (Exception)
            {
                 return 0;
            }

            switch (timeType)
            {
                case nameof(TimeTypeEnum.Day) :
                    num *= 12 * 60 * 60;
                    break;
                case nameof(TimeTypeEnum.Hour):
                    num *= 60 * 60;
                    break;
                case nameof(TimeTypeEnum.Minute):
                    num *= 60;
                    break;
                case nameof(TimeTypeEnum.Second):

                    break;
                default:
                    num = 0;
                    break;
            }
            endTime = startTime.AddSeconds(num);
            return num;
        }
    }
}

主函数:

using Receive.udp;
using SuperSocket.SocketBase;
using SuperSocket.SocketBase.Config;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace UdpSocketServer
{
    class Program
    {
        private static IServerConfig SERVER_CONFIG;
        private static IRootConfig ROOT_CONFIG;
        public static IServerConfig DefaultServerConfig
        {
            get
            {
                return new ServerConfig
                {
                    Ip = "127.0.0.1",
                    LogCommand = true,
                    MaxConnectionNumber = 1000,
                    Mode = SocketMode.Udp,
                    Name = "Udp Test Socket Server",
                    Port = 6602,
                    ClearIdleSession = true,
                    ClearIdleSessionInterval = 1,
                    IdleSessionTimeOut = 5,
                    SendingQueueSize = 100,
                    ReceiveBufferSize = 50000
                };
            }
        }


        static void Main(string[] args)
        {
            initData();
            SERVER_CONFIG = DefaultServerConfig;
            ROOT_CONFIG = new RootConfig();
            var testServer = new UdpAppServer();
            testServer.Setup(ROOT_CONFIG, SERVER_CONFIG);
            testServer.Start();
            while (true)
            {

            }
        }

        private static void initData()
        {
            UdpAppServer.PRIVATE_KEY.Add("webSession", "f21c2a0689443179082e02f8f44079");
            UdpAppServer.PRIVATE_KEY.Add("001", "key001");
            UdpAppServer.PRIVATE_KEY.Add("002", "key002");
            UdpAppServer.PRIVATE_KEY.Add("003", "key003");
        }
    }
}

下载Demo地址:
https://download.csdn.net/download/a748448660/10559647



————————————————
版权声明:本文为CSDN博主「追风筝的摆渡人」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/a748448660/article/details/81175712

https://blog.csdn.net/a748448660/article/details/81175712

标签:UDP,return,superSocket,requestInfo,System,AForge,using,public,string
来源: https://blog.csdn.net/ba_wang_mao/article/details/115611495