c# - 在 ASP.NET 中上传流和播放视频

Question

我必须制作一个界面来上传高达 30MB 的大型视频，然后将其流式传输并转换为 FLV 格式，然后在浏览器中播放...这是我网站上“视频库”模块中所必需的。我的 Web 应用程序使用 C# 和 ASP.NET。我也可以使用 jQuery。

我必须分块发送视频文件，然后在服务器上将其合并、流式传输、为视频创建缩略图然后播放。

如果有人有解决方案，请提供给我。

我找到了一些代码，但都是用 PHP 编写的。我还没有找到任何 C#、ASP.NET 代码。

我终于得到了分块上传视频文件的代码...但请帮助我做进一步的处理，比如创建它的缩略图并在浏览器中显示视频。

这是分块上传视频的代码。

点击上传按钮

 protected void btnUploadVideo_Click(object sender, EventArgs e)
        {
            UploadVideoFile obj = new UploadVideoFile();
            string FileName = fuUploadVideo.FileName;
            string DestPath = Server.MapPath("Videos");
            string strFinalFileName = Path.GetFileName(fuUploadVideo.FileName);
          long  FileLength = fuUploadVideo.PostedFile.ContentLength;
          long uploadchunklimit;
          int SizeLimit = (int)FileLength;
            if (FileLength <= 1024)
            {
                uploadchunklimit = 1;
                SizeLimit = (int)FileLength;
            }
            else if (FileLength > 10240)
            {
                uploadchunklimit = FileLength / 10240;
                SizeLimit = 10;
            }
            else if (FileLength <= 10240 && FileLength > 1024)
            {
                uploadchunklimit = FileLength / 1024;
            }
            else
            {
                uploadchunklimit = FileLength / 1024;
            }

            long lngSize = (long)SizeLimit;
            lngSize *= 1024 * 1024;
            string ext = Path.GetExtension(fuUploadVideo.PostedFile.FileName);
            string strDestFileName = Server.MapPath("videofile") + "\\" + Guid.NewGuid() + ext;
            string strSrcFile = Server.MapPath("videofile/" + Path.GetFileName(strDestFileName));
            string strDestFile = Server.MapPath("mergefile") + "//" + Path.GetFileName(strDestFileName);
            string strFinalDest = Server.MapPath("FinalFile") ;
            obj.Process(fuUploadVideo.PostedFile.FileName, strDestFileName, lngSize, fuUploadVideo.PostedFile);
            obj.MergerProcess(strSrcFile, strDestFile, strFinalDest);
        }

上传视频文件.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Web;
//using ContestBLL;

/// <summary>
/// This Class contains methods for upload chunks
/// </summary>
public class UploadVideoFile
{
    /// <summary>
    /// declaration of private members
    /// </summary>
    private FileStream fSIn, fSout;

    /// <summary>
    /// declaration of private members
    /// </summary>
    private int preDefinedCacheSize;

    /// <summary>
    /// Initializes a new instance of the Chunk class.
    /// </summary>
    public UploadChunk()
    {
        //// TODO: Add constructor logic here
    }

    /// <summary>
    ///  This method used to merge file
    /// </summary>
    /// <param name="strSrcPath">Source path of file</param>
    /// <param name="strDestPath">destination  path of file</param>
    /// <param name="strFilnalDest">Final destination path of file</param>
    public string MergerProcess(string strSrcPath, string strDestPath, string strFilnalDest)
    {
        try
        {
            string[] strFiles = Directory.GetFiles(strSrcPath, "*.part");

            this.fSout = new FileStream(strDestPath, FileMode.Create);
            BinaryWriter wFSOut = new BinaryWriter(this.fSout);
            long fileSizes = 0;
            fileSizes = this.GetSizes(strFiles);
            foreach (string a in strFiles)
            {
                this.preDefinedCacheSize = this.DefineCache();
                this.fSIn = new FileStream(strSrcPath + "\\" + this.FileName(a), FileMode.Open);
                BinaryReader rFSIn = new BinaryReader(this.fSIn);
                if (this.preDefinedCacheSize > this.fSIn.Length - this.fSIn.Position)
                {
                    this.preDefinedCacheSize = (int)this.fSIn.Length - (int)this.fSIn.Position;
                }

                byte[] buffer = new byte[this.preDefinedCacheSize];
                while (this.fSIn.Position != this.fSIn.Length)
                {
                    rFSIn.Read(buffer, 0, this.preDefinedCacheSize);
                    wFSOut.Write(buffer);
                    Thread.Sleep(1);
                }

                rFSIn.Close();
                this.fSIn.Close();
            }

            wFSOut.Close();
            this.fSout.Close();
            string strFolderToDelete = strSrcPath;
            if (Directory.Exists(strFolderToDelete))
            {
                Directory.Delete(strFolderToDelete, true);
            }

            if (File.Exists(strDestPath))
            {
                File.Copy(strDestPath, strFilnalDest + "//" + Path.GetFileName(strDestPath), false);
                File.Delete(strDestPath);
            }
            return Path.GetFileName(strDestPath);
        }
        catch (Exception ex)
        {
            object[] customval = new object[0];
            //AppError.ErrorMsg(ex.StackTrace, "UploadChunk.cs", "MergerProcess", customval);
        }
    }

    /// <summary>
    /// this method is used to ...
    /// </summary>
    /// <param name="strSrcPath"> path of the source file</param>
    /// <param name="strDestPath">destination  path of file</param>
    /// <param name="lngFileSize"> Size of file to be split</param>
    /// <param name="fsi">object of HttpPostedFile class</param>
    public void Process(string strSrcPath, string strDestPath, long lngFileSize, System.Web.HttpPostedFile fsi)
    {
        string strDirectory = string.Empty, strNewFileNames = string.Empty;
        long fileSize = 0;
        int intCounter = 0;
        try
        {
            //// Code to Check whether it is logical or not to Continue...

            ////FSIn = new FileStream(strSrcPath, FileMode.Open);
            ////BinaryReader rFSIn = new BinaryReader(FSIn);
            BinaryReader rFSIn = new BinaryReader(fsi.InputStream);
            ////FileSize = FSIn.Length;
            fileSize = fsi.ContentLength;

            strDirectory = strDestPath;

            ////split it to parts in a folder Called "FileName"
            System.IO.Directory.CreateDirectory(strDirectory);

            ////begin writing
            ////while (FSIn.Position != FSIn.Length)
            while (rFSIn.BaseStream.Position != fsi.ContentLength)
            {
                this.preDefinedCacheSize = this.DefineCache();
                byte[] buffer = new byte[this.preDefinedCacheSize];
                strNewFileNames = strDirectory + "\\" + intCounter.ToString() + ".part";
                this.fSout = new FileStream(strNewFileNames, FileMode.Create);
                BinaryWriter wFSOut = new BinaryWriter(this.fSout);
                ////while ((FSout.Position < lngFileSize) && (FSIn.Position != FSIn.Length))
                while ((this.fSout.Position < lngFileSize) && (rFSIn.BaseStream.Position != fsi.ContentLength))
                {
                    ////if (((FSIn.Length - FSIn.Position) < Math.Min(PreDefinedCacheSize, (int)lngFileSize)) && (PreDefinedCacheSize > lngFileSize))
                    if (((fsi.ContentLength - rFSIn.BaseStream.Position) < Math.Min(this.preDefinedCacheSize, (int)lngFileSize)) && (this.preDefinedCacheSize > lngFileSize))
                    {
                        this.preDefinedCacheSize = (int)fsi.ContentLength - (int)rFSIn.BaseStream.Position;
                        rFSIn.Read(buffer, 0, this.preDefinedCacheSize);
                        wFSOut.Write(buffer);
                        Thread.Sleep(1);
                    }
                    else
                    {
                        if (this.preDefinedCacheSize > lngFileSize)
                        {
                            this.preDefinedCacheSize = (int)lngFileSize;
                        }

                        rFSIn.Read(buffer, 0, this.preDefinedCacheSize);
                        wFSOut.Write(buffer);
                        Thread.Sleep(1);
                    }
                }

                wFSOut.Close();
                this.fSout.Close();
                intCounter++;
            }

            ////finish
            rFSIn.Close();
        }
        catch (Exception ex)
        {
            object[] customval = new object[0];
            //AppError.ErrorMsg(ex.StackTrace, "UploadChunk.cs", "Process", customval);
        }
    }

    /// <summary>
    /// this i sused to define cache
    /// </summary>
    /// <returns>return integer value</returns>
    private int DefineCache()
    {
        return 8192 * 2;
    }

    /// <summary>
    /// this method  gives the Filename from the long Path
    /// </summary>
    /// <param name="strString">path of file</param>
    /// <returns>return string value</returns>
    private string FileName(string strString) 
    {
        return strString.Substring(strString.LastIndexOf("\\"));
    }

    /// <summary>
    /// This method is used to get size 
    /// </summary>
    /// <param name="strFileZ">array of files</param>
    /// <returns>return long type value</returns>
    private long GetSizes(string[] strFileZ)
    {
        long intSizeToReturn = 0;
        foreach (string a in strFileZ)
        {
            FileStream tmpFS = new FileStream(a, FileMode.Open);
            intSizeToReturn += tmpFS.Length;
            tmpFS.Close();
        }

        return intSizeToReturn;
    }
}

Answer 1

我要掷骰子，你最终会回应...

假设您可以很好地处理文件上传，您可以使用 ffmpeg 将文件转换为 FLV 格式并获取缩略图。正如 Hasan 所提到的，ffmpeg 工作得很好，而且它已经有一段时间了，得到了很多支持。它是一个对参数进行操作的命令行程序，这意味着您可以在 C# 中使用它。

您需要下载 ffmpeg(exe，无需安装)。您可以使用 System.Diagnostics 来执行 ffmpeg 并向其传递参数。

将视频文件转换为FLV

System.Diagnostics.Process.Start("ffmpeg.exe",
                                 "-i SourceVideoFile.avi ConvertedVideoFile.flv");

截取缩略图

System.Diagnostics.Process.Start("ffmpeg.exe",
                                 "-i SourceVideoFile.avi -f image2 -s 320x240 thumbnail.png"); 

如果您需要更多控制、需要捕获输出等，您也可以使用 System.Diagnostics.ProcessStartInfo。

一旦你有了新的视频文件，你应该能够弄清楚如何在浏览器中播放它 :-) 如果没有，请查看 VideoJS或 Flowplayer .