在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);
        }

UploadVideofile.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;
    }
}

- Radhi

---

有没有人能帮我解决这个问题？？？ - Radhi

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。

- Nimrod

Answer 2

这里是我的类似问题。大多数建议使用FFMPEG，这也是我使用的。它运行良好，只需要exe文件。

- HasanG