C#实现通过ffmpeg拉取海康摄像头rtsp流转m3u8，并在前端播放的解决方案。

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.ServiceProcess;
using System.Threading;

namespace HlsService
{
    public partial class HlsService : ServiceBase
    {
        public class ReceiveInfo
        {
            public string OnlineRootAddress { get; set; }//外网ip+端口路径 

            public int IsStartCheck { get; set; }   //是否开启定时检查

            public int IsRecordLog { get; set; }    //重启拉流是否记录日志

            //WaitTimeBeforeCheck / LoopPeriodSeconds / OutdateSecends 需要根据服务器cpu等性能 适当调节，电脑配置高可以小点，配置低调大点

            //开启服务 多少秒后开启定时检查 摄像头比较多需要所有的都开启了拉流 才进行检查
            public int WaitTimeBeforeCheck { get; set; }
            //定时器循环周期 (秒) 摄像头拉流需要一定时间 否则时间太断 在进行重启检查时  在拉到流之前 文件永远都是过期
            public int LoopPeriodSeconds { get; set; }
　　　　　　　
　　　　　　　//判断过期的文件名　
            public string JudgeFileName { get; set; }

            //判断文件过期时间 (秒) 切片3秒1个 30个切片 2分钟足够判断过期
            public int OutdateSecends { get; set; } 
　　　　　　　
　　　　　　　//摄像头配置信息　
            public List ConfigInfos { get; set; }
        }

        public class ConfigInfo
        {
            public int CameraId { get; set; }       //摄像头id 从1开始递增
            public string CameraName { get; set; }  //摄像头名称 (对应视频监控添加 标题)
            public string OutDirName { get; set; }  //摄像头推流生成的m3u8文件存放目录名
            public string MacAddress { get; set; }  //通过mac地址到时候可以方便摄像头所连接的wifi ip
            public string RtspPath { get; set; }    //摄像头rtsp地址
            public int ProcessId { get; set; }      //摄像头对应的 ffmpeg推流进程ID
            public string PlayUrl { get; set; }     //可播放的m3u8 http地址 (对应视频监控添加 url)           
        }

        public static string OnlineRootAddress= "";//"test.kingnen.com:12400/";外网ip端口

        public static string COnfigFileName= "config.json";//摄像头配置文件名称

        public static string BasePath = AppDomain.CurrentDomain.BaseDirectory;//HLSTransfer所在文件夹路径

        public static string M3u8FileBaseDir = "FileDir";   //m3u8文件存放 根目录

        public static string M3u8FileName = "play.m3u8";    //名称统一为play.m3u8        

        public static ReceiveInfo receiveInfo = null;       //配置文件接收类

        public static System.Threading.Timer timer;         //定时器

        public HlsService()
        {
            InitializeComponent();
            base.ServiceName = "HlsService";
        }

        protected override void OnStart(string[] args)
        {
            MainStart();
        }

        protected override void OnStop()
        {
            timer?.Dispose();
            StopAllProcess();
        }

        /// 

        /// 主方法
        /// 
        /// 
        static void MainStart()
        {
            if (!ReadConfigFile(BasePath + ConfigFileName))
                return;
            StopAllProcess(); //首先关闭之前所有的拉流

            OnlineRootAddress = receiveInfo.OnlineRootAddress;//设置外网ip 端口
            foreach (var item in receiveInfo.ConfigInfos)
            {
                item.ProcessId = 0;
                item.PlayUrl = "";
                item.ProcessId = StartPull(item); //重启推流
                item.PlayUrl = item.ProcessId > 0 ? (OnlineRootAddress + M3u8FileBaseDir + "/" + item.OutDirName + "/" + M3u8FileName) : "";

                WriteLog("start cameraId:" + item.CameraId + " ok!, processId:" + item.ProcessId);
            }

            //写回配置文件
            JsonWriteBack();

            if (receiveInfo.IsStartCheck == 1)
            {
　　　　　　　　　　//先保证启动第一次拉流成功，拉流需要时间，所以需要等待一会然后再开启定时任务
                Thread.Sleep(receiveInfo.WaitTimeBeforeCheck * 1000);
                timer = new Timer(p => TaskCheck(), null, 0, receiveInfo.LoopPeriodSeconds*1000);//启动定时任务每 LoopPeriodSeconds启动一次
            }
        }

        /// 

        /// 读取配置文件
        /// 
        /// 
        /// 
        public static bool ReadConfigFile(string path)
        {
            using (StreamReader fileRead = new StreamReader(path))
            {
                string strRead = fileRead.ReadToEnd();
                if (string.IsNullOrEmpty(strRead))
                {
                    WriteLog("read config.json error!");
                    return false;
                }

                try
                {
                    receiveInfo = JsonConvert.DeserializeObject(strRead);
                    if (receiveInfo == null || receiveInfo.COnfigInfos== null || receiveInfo.ConfigInfos.Count <= 0)
                    {
                        WriteLog("read config.json error!");
                        return false;
                    }
                }
                catch (Exception)
                {
                    WriteLog("read config.json error!");
                    return false;
                }
            }

            return true;
        }

        /// 

        /// 拉流后 将配置重新写回配置文件
        /// 
        /// 
        public static void JsonWriteBack()
        {
            if (receiveInfo == null || receiveInfo.COnfigInfos== null || receiveInfo.ConfigInfos.Count <= 0)
            {
                WriteLog("JsonWriteBack() receiveInfo == null ...");
                return;
            }
            try
            {
                //将配置文件重新写回
                using (StreamWriter fileWriter = new StreamWriter(BasePath + ConfigFileName, false))
                {
                    //fileWriter.WriteAsync(JsonConvert.SerializeObject(receiveInfo));
                    fileWriter.Write(JsonConvert.SerializeObject(receiveInfo));
                }
            }
            catch (Exception e)
            {
                WriteLog("JsonWriteBack() error：" + e.Message);
            }
        }

        /// 

        /// 定时检查拉流进程
        /// 
        public static void TaskCheck()
        {
            //重新读取配置文件
            if (!ReadConfigFile(BasePath + ConfigFileName))
                return;
            //重新设置外网ip 端口 
            OnlineRootAddress= receiveInfo.OnlineRootAddress;

            bool isRestart = true;
            int changeCount = 0;
            Process[] processArr = Process.GetProcessesByName("ffmpeg");
            List<int> pIdList = (processArr != null && processArr.Length > 0) ? processArr.Select(m => m.Id).ToList() : new List<int>();

            foreach (var item in receiveInfo.ConfigInfos)
            {
                isRestart = true; //该摄像头对应进程是否需要重启
                //进程id存在且m3u8文件未过期
                if (pIdList.Contains(item.ProcessId) && item.ProcessId > 0)
                {
                    string tsFilePath = BasePath+ M3u8FileBaseDir + "/" + item.OutDirName + "/" + receiveInfo.JudgeFileName;
                    if (File.Exists(tsFilePath))
                    {
                        FileInfo fi = new FileInfo(tsFilePath);                        
                        if ((DateTime.Now - fi.LastWriteTime).TotalSeconds //文件未过期 一直在拉流
                        {
                            isRestart = false;
                        }
                    }
                    else
                    {
                        //覆盖文件时，会存在 JudgeFileName 刚好不存在的情况(ffmpeg会先删除文件然后再生成，所以必须要保证第一次开启所有的摄像头都能生成m3u8文件)
                        isRestart = false;
                    }
                }

                //重启进程                
                if (isRestart)
                {
                    string str = "Restart CameraId:" + item.CameraId + ", ProcessId:" + item.ProcessId + " -> ";

                    if (pIdList.Contains(item.ProcessId))
                    {
                        processArr.FirstOrDefault(p => p.Id == item.ProcessId)?.Kill();
                    }

                    item.ProcessId = 0;
                    item.PlayUrl = "";
                    item.ProcessId = StartPull(item); //重启推流
                    if (item.ProcessId > 0)
                    {
                        changeCount++;
                        item.PlayUrl = OnlineRootAddress + M3u8FileBaseDir + "/" + item.OutDirName + "/" + M3u8FileName;
                    }

                    //是否记录日志
                    if (receiveInfo.IsRecordLog == 1)
                    {
                        WriteLog(str + item.ProcessId);
                    }
                }
            }

            //写回配置文件
            if (changeCount > 0)
            {
                JsonWriteBack();
            }
        }

        /// 

        /// 开启拉流 
        /// 
        /// 
        /// 
        public static int StartPull(ConfigInfo item)
        {
            if (item == null) return 0;

            if (!Directory.Exists(BasePath + M3u8FileBaseDir + "\\" + item.OutDirName))
            {
                Directory.CreateDirectory(BasePath + M3u8FileBaseDir + "\\" + item.OutDirName);
            }

            Process p = null;
            try
            {
                var startInfo = new ProcessStartInfo();
                startInfo.FileName = "ffmpeg.exe"; //需提前配置环境变量
                startInfo.Arguments = " -rtsp_transport tcp -i " + item.RtspPath + " -s 640x480 -force_key_frames \"expr: gte(t, n_forced * 3)\" ";
                startInfo.Arguments += " -c:v libx264 -hls_time 3  -hls_list_size 30 -hls_wrap 30 -f hls ";
                startInfo.Arguments += (BasePath + M3u8FileBaseDir + "\\" + item.OutDirName + "\\" + M3u8FileName);

                startInfo.CreateNoWindow = true;
                startInfo.UseShellExecute = false;
                startInfo.Verb = "RunAs";//以管理员身份运行
                p = Process.Start(startInfo);

                return p != null ? p.Id : 0;
            }
            catch (Exception ex)
            {
                WriteLog("restart cameraId:" + item.CameraId + " error,"+ ex.Message);
                p?.Close();

                return 0;
            }
        }

        /// 

        /// 结束掉所有的推流进程
        /// 
        public static void StopAllProcess()
        {
            WriteLog("StopAllProcess() start..");
            //结束掉所有的进程 ffmpeg进程
            List processList = Process.GetProcessesByName("ffmpeg").ToList();
            if (processList != null && processList.Count > 0)
            {
                processList.ForEach(p =>
                {
                    WriteLog("processId:" + p.Id + " be killed;"); 
                    p.Kill();
                });
            }

            //将ProcessId,PlayUrl 清空 
            receiveInfo.ConfigInfos.ForEach(p => { p.ProcessId = 0; p.PlayUrl = ""; });

            JsonWriteBack();

            processList = Process.GetProcessesByName("CrashServerDamon").ToList();
            if (processList != null && processList.Count > 0)
                processList.ForEach(p => { p.Kill(); });
        }

        /// 

        /// 写日志
        /// 
        /// 
        public static void WriteLog(string msg)
        {
            string path = BasePath + "Log" + "\\" + DateTime.Now.ToString("yyyyMMdd") + ".txt";

            if (!File.Exists(path))                                       
            {
                using (File.Create(path))//释放文件流
                {

                }
            }

            using (StreamWriter fileWriter = new StreamWriter(path, true))
            {
                fileWriter.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ") + "-" + msg);
            }
        }
    }
}