无题

视频转码处理

一、将视频上传到视频文件服务器

1、实现思路分析

2、基础模型设计

这里设计了一个视频信息存储的模型VideoInfo。

public class VideoInfo : BaseEntity<long>
    {
        /// <summary>
        /// 视频的名称，非全路径
        /// </summary>
        public string? VideoName { get; set; }
        /// <summary>
        /// 文件大小（尺寸为字节）
        /// </summary>
        public long? FileSizeInBytes { get; set; }

        /// <summary>
        /// 两个文件的大小和散列值（SHA256）都相同的概率非常小。因此只要大小和SHA256相同，就认为是相同的文件。
        /// SHA256的碰撞的概率比MD5低很多。
        /// </summary>
        public string? FileSHA256Hash { get; set; }

        /// <summary>
        /// 视频转码后的存储路径
        /// </summary>
        public string? VideoPath { get; set; }

        /// <summary>
        /// 待转码的视频文件路径
        /// </summary>
        public string? SourcePath { get; set; }
        /// <summary>
        /// 视频简介
        /// </summary>
        public string? VideoContent { get; set; }

        /// <summary>
        /// 视频作者
        /// </summary>
        public string? Author { get; set; }

        /// <summary>
        /// 视频截图存储路径
        /// </summary>
        public string? ImageUrl { set; get; }
        /// <summary>
        /// 视频状态，初始值为0，当视频上传到视频文件服务器状态为1，转码成功后修改为2
        /// </summary>
        public int Status { get; set; }

    }

对以上的模型进行配置

namespace Cms.Entity
{
    public class VideoInfoConfig : IEntityTypeConfiguration<VideoInfo>
    {
        public void Configure(EntityTypeBuilder<VideoInfo> builder)
        {
            builder.ToTable("T_Videos");
            builder.Property(v => v.VideoName).HasMaxLength(200).IsRequired();
            builder.Property(v => v.Author).HasMaxLength(100).IsRequired();
            builder.Property(v => v.FileSHA256Hash).IsRequired();
            builder.Property(v => v.FileSizeInBytes).IsRequired();
            builder.Property(v => v.VideoContent).IsRequired();
            builder.Property(v => v.VideoPath).IsRequired();
        }
    }
}

在其对应的MyDbContext中添加对应的DbSet类型的属性。

public DbSet<VideoInfo> VideoInfos { get; set; }

完成对应的数据迁移操作。

注意：这里可以根据实际的业务需求，将视频信息模型与用户模型，以及视频分类模型建立相应的关系。

3、完成视频文件上传

在将视频文件传递到视频文件服务器以后，需要将对应的视频信息存储到数据表中。

所以这里需要创建对视频信息表操作的仓储接口与仓储类。

namespace Cms.IRepository
{
    public interface IVideoInfoRepository : IBaseRepository<VideoInfo>
    {
    }
}

namespace Cms.Repository
{
    public class VideoInfoRepository : BaseRepository<VideoInfo>, IVideoInfoRepository
    {
        public VideoInfoRepository(MyDbContext dbContext) : base(dbContext) { }
    }
}

同时创建服务接口以及对应的服务类IVideoInfoService.cs

namespace Cms.IService
{
    public interface IVideoInfoService : IBaseService<VideoInfo>
    {
       
    }
}

具体的业务类VideoInfoService.cs

public class VideoInfoService : BaseService<VideoInfo>, IVideoInfoService
    {
        private readonly IVideoInfoRepository videoInfoRepository;
      
        public VideoInfoService(IVideoInfoRepository videoInfoRepository, IHttpClientFactory httpClientFactory)
        {
            this.videoInfoRepository = videoInfoRepository;
            base._repository = videoInfoRepository;
           
        }
}

创建一个VideoController.cs控制器

public class VideoController : Controller
   {
       private readonly IVideoInfoService videoInfoService;
       public VideoController(IVideoInfoService videoInfoService)
       {
           this.videoInfoService = videoInfoService;

       }
       [HttpGet]//-------------呈现一个Index视图，该视图中有上传视频的表单
       public IActionResult Index()
       {
           return View();
       }
       [HttpPost]
       [RequestSizeLimit(60_000_000)]//---指定接收到的视频的大小进行限定。
       [UnitOfWork(new Type[] { typeof(MyDbContext) })]
       public async Task<IActionResult> FileUpload(IFormFile filePath)
       {
           string author = Request.Form["author"]!; // 作者
           string videoContent = Request.Form["videoContent"]!; // 视频内容
           using (Stream stream = filePath.OpenReadStream()) // 读取视频文件内容
           {
               //将视频文件流，文件名，作者，视频内容传递到业务层
              await videoInfoService.UploadVideoAsync(stream,filePath.FileName, author, videoContent);
           }
           return Content("ok");
       }
   }

Index视图，代码如下所示：

<form method="post" action="/video/fileUpload" enctype="multipart/form-data">
 <input type="file" name="filePath"/> <br/>
 作者：<input type="text" name="author" /><br/>
 内容简介：<textarea  name="videoContent" rows="10" cols="20" ></textarea><br/>
 
 <input type="submit" value="上传视频"/>
</form>

下面在业务接口IVideoInfoService中，声明方法UploadVideoAsync方法，如下所示：

public interface IVideoInfoService : IBaseService<VideoInfo>
  {
      public Task<VideoInfo> UploadVideoAsync(Stream stream, string fileName, string author, string videoContent);
  }

在VideoInfoService.cs中实现以上方法：

namespace Cms.Service
{
    public class VideoInfoService : BaseService<VideoInfo>, IVideoInfoService
    {
        private readonly IVideoInfoRepository videoInfoRepository;
        private readonly IHttpClientFactory httpClientFactory;
        public VideoInfoService(IVideoInfoRepository videoInfoRepository, IHttpClientFactory httpClientFactory)
        {
            this.videoInfoRepository = videoInfoRepository;
            base._repository = videoInfoRepository;
            this.httpClientFactory = httpClientFactory;
        }
        /// <summary>
        /// 将接收到文件传递给转码服务器
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="fileName"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<VideoInfo> UploadVideoAsync(Stream stream, string fileName, string author, string videoContent)
        {
            string hash = HashHelper.ComputeSha256Hash(stream);
            long fileSize = stream.Length;
            // 如果hash值与长度都相同，则不需要传递到转码服务器
            var videoInfo = await videoInfoRepository.LoadEntities(v => v.FileSHA256Hash == hash && v.FileSizeInBytes == fileSize).FirstOrDefaultAsync();
            if (videoInfo != null)
            {
                return videoInfo;
            }
            stream.Position = 0;
            // 
            using (MultipartFormDataContent content = new MultipartFormDataContent())
            {

                using (var fileContent = new StreamContent(stream))
                {
                    content.Add(fileContent, "file", fileName);
                    var httpClient = httpClientFactory.CreateClient();
                    Uri requestUri = new Uri("http://localhost:5034" + "/Uploader/Upload");

                    var respMsg = await httpClient.PostAsync(requestUri, content);
                    if (!respMsg.IsSuccessStatusCode)
                    {
                        string respString = await respMsg.Content.ReadAsStringAsync();
                        throw new HttpRequestException($"上传失败，状态码：{respMsg.StatusCode}，响应报文：{respString}");
                    }
                    else
                    {
                        // ---------将上传到视频文件服务器的视频信息存储到数据库中
                        VideoInfo video = new VideoInfo();
                        video.FileSHA256Hash = hash;
                        video.FileSizeInBytes = fileSize;
                        video.Author = author;
                        video.VideoContent = videoContent;
                        video.UpdateTime = DateTime.Now;
                        video.AddTime = DateTime.Now;
                        video.Status = 1;// 表示视频文件已经上到视频文件服务器了。
                        video.VideoPath = "";
                        video.SourcePath = await respMsg.Content.ReadAsStringAsync(); // 获取到视频文件服务器返回的内容
                        video.DelFlag = false;
                        video.ImageUrl = "";
                        video.VideoName = fileName;
                       await videoInfoRepository.AddEntity(video);
                        //video.ImageUrl = respMsg.
                    }
                }
            }

            return await Task.FromResult(videoInfo!);
        }
    }
}

需要注入IHttpClientFactory

builder.Services.AddSession();
builder.Services.AddHttpClient();//----注入

同时在Common类库项目中添加HashHelper.cs类，该类中的代码

namespace Cms.Common
{
    public class HashHelper
    {
        private static string ToHashString(byte[] bytes)
        {
            StringBuilder builder = new StringBuilder();
            for (int i = 0; i < bytes.Length; i++)
            {
                builder.Append(bytes[i].ToString("x2"));
            }
            return builder.ToString();
        }

        public static string ComputeSha256Hash(Stream stream)
        {
            using (SHA256 sha256Hash = SHA256.Create())
            {
                byte[] bytes = sha256Hash.ComputeHash(stream);
                return ToHashString(bytes);
            }
        }

        public static string ComputeSha256Hash(string input)
        {
            using (SHA256 sha256Hash = SHA256.Create())
            {
                byte[] bytes = sha256Hash.ComputeHash(Encoding.UTF8.GetBytes(input));
                return ToHashString(bytes);
            }
        }

        public static string ComputeMd5Hash(string input)
        {
            using (MD5 md5Hash = MD5.Create())
            {
                byte[] bytes = md5Hash.ComputeHash(Encoding.UTF8.GetBytes(input));
                return ToHashString(bytes);
            }
        }

        public static string ComputeMd5Hash(Stream input)
        {
            using (MD5 md5Hash = MD5.Create())
            {
                byte[] bytes = md5Hash.ComputeHash(input);
                return ToHashString(bytes);
            }
        }
    }
}

下面实现视频文件服务器中的代码。在创建一个MVC项目

创建一个解决方案文件夹VideoFileService,在该文件夹下面创建一个Cms.Video这个MVC项目

在该项目下面创建一个UploaderController.cs控制器。

public class UploaderController : Controller
   {
       private readonly IWebHostEnvironment hostEnv;
       private readonly FSDomainService domainService;
       public UploaderController(IWebHostEnvironment hostEnv, FSDomainService domainService)
       {
           this.hostEnv = hostEnv;
           this.domainService = domainService;
       }
       public IActionResult Index()
       {
           return View();
       }
    //-----------------接收Web服务器传递过来的视频文件
       [HttpPost]
       [RequestSizeLimit(60_000_000)]
       public async Task<IActionResult> Upload(IFormFile file)
       {
           string fileName = file.FileName;
           using (Stream stream = file.OpenReadStream())
           {
               // 调用业务中的UploadAsync方法。
             var url=  await domainService.UploadAsync(stream, fileName, hostEnv.ContentRootPath);
               return Ok(url);// 返回存储成功的视频文件的路径

           }
           
       }
   }

在VideoFileService文件夹下面创建Cms.Video.FileService类库项目，处理对应的业务。

在FSDomainService.cs类中的代码如下所示：

public class FSDomainService
    {
        private readonly IHttpContextAccessor httpContextAccessor;
        public FSDomainService(IHttpContextAccessor httpContextAccessor)
        {

            this.httpContextAccessor = httpContextAccessor;
        }
        public async Task<string> UploadAsync(Stream stream, string fileName, string contentRootPath)
        {
            string hash = HashHelper.ComputeSha256Hash(stream);
            long fileSize = stream.Length;
            DateTime today = DateTime.Today;
            //用日期把文件分散在不同文件夹存储，同时由于加上了文件hash值作为目录，又用用户上传的文件夹做文件名，
            //所以几乎不会发生不同文件冲突的可能
            //用用户上传的文件名保存文件名，这样用户查看、下载文件的时候，文件名更灵活
            string key = $"{today.Year}/{today.Month}/{today.Day}/{hash}/{fileName}";
            stream.Position = 0;
// 将视频文件存储到了wwwroot目录下面
            string workingDir = Path.Combine(contentRootPath, "wwwroot");
            string fullPath = Path.Combine(workingDir, key);
            string? fullDir = Path.GetDirectoryName(fullPath);//get the directory
            Directory.CreateDirectory(fullDir);
            if (File.Exists(fullPath))//如果已经存在，则尝试删除
            {
                File.Delete(fullPath);
            }
            using (Stream outStream = File.OpenWrite(fullPath))
            {
                await stream.CopyToAsync(outStream);
            }
            var req = httpContextAccessor.HttpContext.Request;
            string url = req.Scheme + "://" + req.Host +"/"+ key;

            return url;
        }
    }

注意：这里为了简单，没有创建对应的接口。

同时在Cms.Video这个MVC项目中的Program.cs文件中完成对应的注入操作。

// Add services to the container.
builder.Services.AddControllersWithViews();
// 将业务类添加到容器中
builder.Services.AddScoped<FSDomainService>();

builder.Services.AddHttpContextAccessor(); // 这里将IHttpContextAccessor的添加到了容器中

以上完成了将视频文件上传到了视频服务器的操作。

4、视频进行转码

视频转码的操作通过控制台程序实现。

创建一个解决方案文件夹VideoEncoderService,在该文件夹中创建Cms.VidoTransCode控制台项目。

在该项目中需要安装xFFmpeg.NET包，该包操作ffmpeg.exe程序来实现视频的转码操作。

同时，将ffmpeg.exe这个程序拷贝到Cms.VidoTransCode项目中，并且选择较新则复制。

同时，在该控制台项目中，引用了Cms.Common,Cms.EntityFrameworkCore以及数据仓储接口和对应的实现。

using Cms.Entity;
using Cms.EntityFrameworkCore;
using Cms.IRepository;
using Cms.Repository;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using System.Net;
using FFmpeg.NET;

ServiceCollection services = new ServiceCollection();
//services.AddDbContext<MyDbContext>();
services.AddDbContext<MyDbContext>(opt =>
{
    string connStr = "server=localhost;database=CmsDb4;uid=sa;pwd=123456;TrustServerCertificate=true";

    opt.UseSqlServer(connStr);
});

services.AddScoped<IVideoInfoRepository, VideoInfoRepository>();
services.AddHttpClient(); //注入 IHttpClientFactory
using (ServiceProvider sp = services.BuildServiceProvider())
{
    var videoInfoRepository = sp.GetService<IVideoInfoRepository>();
    var httpClientFactory = sp.GetRequiredService<IHttpClientFactory>();
    var dbContext = sp.GetService<MyDbContext>()!;
    await ExecuteAsync(videoInfoRepository!, httpClientFactory, dbContext);

}


//视频转码
static async Task ProcessItemAsync(VideoInfo videoInfo, IHttpClientFactory httpClientFactory, IVideoInfoRepository videoInfoRepository, MyDbContext dbContext)
{
    //分布式锁来避免两个转码服务器处理同一个转码任务的问题(后面讲解redis的时候会讲解)

    (var downloadOk, var srcFile) = await DownloadSrcAsync(videoInfo, httpClientFactory);
    if (!downloadOk)
    {
        Console.WriteLine("视频文件下载失败");
        return;
    }

    FileInfo destFile = BuildDestFileInfo();
    try
    {
        /* long fileSize = srcFile.Length;
         string srcFileHash = ComputeSha256Hash(srcFile);
         //如果之前存在过和这个文件大小、hash一样的文件，就认为重复了
         var prevInstance = await videoInfoRepository.LoadEntities(v => v.FileSizeInBytes == fileSize && v.FileSHA256Hash == srcFileHash).FirstOrDefaultAsync();
         if (prevInstance != null)
         {
             Console.WriteLine($"检查Id={videoInfo.Id}Hash值成功，发现已经存在相同大小和Hash值的旧任务Id={prevInstance.Id}，返回！");

             return;
         }*/
        //开始转码
        Console.WriteLine($"Id={videoInfo.Id}开始转码，源路径:{srcFile}，目标路径:{destFile}");
        var encodingOK = await EncodeAsync(srcFile, destFile); ;
        if (!encodingOK)
        {
            Console.WriteLine($"转码失败");
            return;
        }
        //开始上传（把转码后的视频重新上传到了视频文件服务器）
        Console.WriteLine($"Id={videoInfo.Id}转码成功，开始准备上传");
        string destUrl = await UploadFileAsync(destFile, httpClientFactory);

        // 更新数据库的操作
        var video = await videoInfoRepository.LoadEntities(v => v.Id == videoInfo.Id).FirstOrDefaultAsync();
        video!.Status = 2;//表示已经转码成功了
        video.VideoPath = destUrl;
        await dbContext.SaveChangesAsync();

    }
    finally
    {
        // 最后一定要将对应的视频文件所在的目录删除掉。
        srcFile.Delete();
        destFile.Delete();
    }

}




//将转码好的视频再重新上传回视频服务器。

static async Task<string> UploadFileAsync(FileInfo file, IHttpClientFactory httpClientFactory)
{

    using MultipartFormDataContent content = new MultipartFormDataContent();
    using var fileContent = new StreamContent(file.OpenRead());
    content.Add(fileContent, "file", file.Name);
    var httpClient = httpClientFactory.CreateClient();
    Uri requestUri = new Uri("http://localhost:5034" + "/Uploader/Upload");

    var respMsg = await httpClient.PostAsync(requestUri, content);
    if (!respMsg.IsSuccessStatusCode)
    {
        string respString = await respMsg.Content.ReadAsStringAsync();
        throw new HttpRequestException($"上传失败，状态码：{respMsg.StatusCode}，响应报文：{respString}");
    }
    else
    {
        string respString = await respMsg.Content.ReadAsStringAsync();
        return respString;
    }
}


/// <summary>
/// 对srcFile按照outputFormat格式转码
/// </summary>
/// <param name="srcFile"></param>
/// <param name="destFile"></param>
/// <param name="outputFormat"></param>
/// <param name="ct"></param>
/// <returns>转码结果</returns>
static async Task<bool> EncodeAsync(FileInfo srcFile, FileInfo destFile)
{

    try
    {
        // await encoder.EncodeAsync(srcFile, destFile, outputFormat, null, ct);
        var inputFile = new InputFile(srcFile);
        var outputFile = new OutputFile(destFile);
        string baseDir = AppContext.BaseDirectory;//程序的运行根目录
        string ffmpegPath = Path.Combine(baseDir, "ffmpeg.exe");
        var ffmpeg = new Engine(ffmpegPath);
        string? errorMsg = null;
        ffmpeg.Error += (s, e) =>
        {
            errorMsg = e.Exception.Message;
        };

        await ffmpeg.ConvertAsync(inputFile, outputFile, CancellationToken.None);//进行转码
        if (errorMsg != null)
        {
            throw new Exception(errorMsg);
        }

    }
    catch (Exception ex)
    {
        Console.WriteLine($"转码失败", ex);
        return false;
    }
    return true;
}




/// <summary>
/// 计算文件的散列值
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
/*static string ComputeSha256Hash(FileInfo file)
{
    using (FileStream streamSrc = file.OpenRead())
    {
        return HashHelper.ComputeSha256Hash(streamSrc);
    }
}*/


/// <summary>
/// 构建转码后的视频文件存放的路径
/// </summary>
/// <param name="encItem"></param>
/// <returns></returns>
static FileInfo BuildDestFileInfo()
{

    string tempDir = Path.GetTempPath();
    string destFullPath = Path.Combine(tempDir, Guid.NewGuid() + "." + "mp4");
    return new FileInfo(destFullPath);
}


static async Task ExecuteAsync(IVideoInfoRepository videoInfoRepository, IHttpClientFactory httpClientFactory, MyDbContext dbContext)
{

    while (true)
    {
        var items = await videoInfoRepository.LoadEntities(v => v.Status == 1).ToListAsync();
        foreach (var item in items)
        {
            try
            {
                await ProcessItemAsync(item, httpClientFactory, videoInfoRepository, dbContext);

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }
        await Task.Delay(5000);//暂停5s，避免没有任务的时候CPU空转
    }
}


/// <summary>
/// 下载原视频
/// </summary>
/// <param name="encItem"></param>
/// <param name="ct"></param>
/// <returns>ok表示是否下载成功，sourceFile为保存成功的本地文件</returns>
static async Task<(bool ok, FileInfo sourceFile)> DownloadSrcAsync(VideoInfo videoInfo, IHttpClientFactory httpClientFactory)
{
    //Path.GetTempPath()//返回当前用户的临时文件夹的路径。 // C:\Users\wangc\AppData\Local\Temp
    //开始下载源文件
    string tempDir = Path.Combine(Path.GetTempPath(), "MediaEncodingDir");
    //源文件的临时保存路径
    string sourceFullPath = Path.Combine(tempDir, Guid.NewGuid() + "."
        + Path.GetExtension(videoInfo.VideoName));
    FileInfo sourceFile = new FileInfo(sourceFullPath);
    long id = videoInfo.Id;
    sourceFile.Directory!.Create();//创建可能不存在的文件夹
    Console.WriteLine($"Id={id}，准备从{videoInfo.SourcePath}下载到{sourceFullPath}");
    HttpClient httpClient = httpClientFactory.CreateClient();

    //var statusCode = await httpClient.DownloadFileAsync(videoInfo.SourcePath, sourceFullPath);
    var response = await httpClient.GetAsync(videoInfo.SourcePath);

    using (var fileStream = new FileStream(sourceFullPath, FileMode.Create, FileAccess.Write, FileShare.None))
    {
        await response.Content.CopyToAsync(fileStream);
    }

    if (response.StatusCode != HttpStatusCode.OK)
    {
        Console.WriteLine($"下载Id={id}，Url={videoInfo.SourcePath}失败");
        sourceFile.Delete();
        return (false, sourceFile);
    }
    else
    {
        return (true, sourceFile);
    }
}

在测试的时候，注意需要启动对应的服务。

5、视频播放

在Web服务器所在的MVC项目中的VideoController.cs控制器中，添加如下方法

[HttpGet]
        public async Task<IActionResult> GetVideList()
        {
            // 获取所有转码后的视频的信息
            var videoList = await videoInfoService.LoadEntities(v => v.Status == 2).ToListAsync();

            return View(videoList);
        }

查询所有转码后的视频文件的信息。将其返回到视图中。

对应的GetVideList视图中的代码，如下所示：

@using Cms.Entity
@model List<VideoInfo>

    <table width="500">

        <tr>
            <th>编号</th>
            <th>视频名称</th>
            <th>作者名称</th>
            <th>详情</th>
            
        </tr>
    @{
        foreach(var item in Model)
        {
            <tr>
                <td>@item.Id</td>
                <td>@item.VideoName</td>
                   <td>@item.Author</td>
                      <td><a href="/video/showDetail?id=@item.Id">详情</a></td>
            </tr>
        }
    }
        
    </table>

这里通过表格展示转码后的视频信息。

当单击详情的时候，会将视频的编号传递到showDetail方法中，该方法接收到该编号以后，然后找到对应的视频进行播放。

[HttpGet]
       public async Task<IActionResult> ShowDetail()
       {
           int id = Convert.ToInt32(Request.Query["id"]);
           var video = await videoInfoService.LoadEntities(v => v.Id == id).FirstOrDefaultAsync();
           return View(video);
       }

对应的ShowDetail方法对应的视图中的代码，如下所示：

@using Cms.Entity
@model VideoInfo

<h1>
  视频名称：  @Model.VideoName
</h1>
<p>
    作者：@Model.Author
</p>
<p>
    内容介绍：@Model.VideoContent
</p>
<p>

    <video src="@Model.VideoPath" controls width="800" height="300"></video>
</p>

https://www.cnblogs.com/jucheap/p/17059213.html