Recherche avancée

Sur d’autres sites (9208)

• Play video using mse (media source extension) in google chrome

  23 août 2019, par liyuqihxc

  I’m working on a project that convert rtsp stream (ffmpeg) and play it on the web page (signalr + mse).

  So far it works pretty much as I expected on the latest version of edge and firefox, but not chrome.

  here’s the code

  public class WebmMediaStreamContext
  
  {
  
      private Process _ffProcess;
  
      private readonly string _cmd;
  
      private byte[] _initSegment;
  
      private Task _readMediaStreamTask;
  
      private CancellationTokenSource _cancellationTokenSource;
  
  
  
      private const string _CmdTemplate = "-i {0} -c:v libvpx -tile-columns 4 -frame-parallel 1 -keyint_min 90 -g 90 -f webm -dash 1 pipe:";
  
  
  
      public static readonly byte[] ClusterStart = { 0x1F, 0x43, 0xB6, 0x75, 0x01, 0x00, 0x00, 0x00 };
  
  
  
      public event EventHandler<clusterreadyeventargs> ClusterReadyEvent;
  
  
  
      public WebmMediaStreamContext(string rtspFeed)
  
      {
  
          _cmd = string.Format(_CmdTemplate, rtspFeed);
  
      }
  
  
  
      public async Task StartConverting()
  
      {
  
          if (_ffProcess != null)
  
              throw new InvalidOperationException();
  
  
  
          _ffProcess = new Process();
  
          _ffProcess.StartInfo = new ProcessStartInfo
  
          {
  
              FileName = "ffmpeg/ffmpeg.exe",
  
              Arguments = _cmd,
  
              UseShellExecute = false,
  
              CreateNoWindow = true,
  
              RedirectStandardOutput = true
  
          };
  
          _ffProcess.Start();
  
  
  
          _initSegment = await ParseInitSegmentAndStartReadMediaStream();
  
      }
  
  
  
      public byte[] GetInitSegment()
  
      {
  
          return _initSegment;
  
      }
  
  
  
      // Find the first cluster， and everything before it is the InitSegment
  
      private async Task ParseInitSegmentAndStartReadMediaStream()
  
      {
  
          Memory<byte> buffer = new byte[10 * 1024];
  
          int length = 0;
  
          while (length != buffer.Length)
  
          {
  
              length += await _ffProcess.StandardOutput.BaseStream.ReadAsync(buffer.Slice(length));
  
              int cluster = buffer.Span.IndexOf(ClusterStart);
  
              if (cluster >= 0)
  
              {
  
                  _cancellationTokenSource = new CancellationTokenSource();
  
                  _readMediaStreamTask = new Task(() => ReadMediaStreamProc(buffer.Slice(cluster, length - cluster).ToArray(), _cancellationTokenSource.Token), _cancellationTokenSource.Token, TaskCreationOptions.LongRunning);
  
                  _readMediaStreamTask.Start();
  
                  return buffer.Slice(0, cluster).ToArray();
  
              }
  
          }
  
  
  
          throw new InvalidOperationException();
  
      }
  
  
  
      private void ReadMoreBytes(Span<byte> buffer)
  
      {
  
          int size = buffer.Length;
  
          while (size > 0)
  
          {
  
              int len = _ffProcess.StandardOutput.BaseStream.Read(buffer.Slice(buffer.Length - size));
  
              size -= len;
  
          }
  
      }
  
  
  
      // Parse every single cluster and fire ClusterReadyEvent
  
      private void ReadMediaStreamProc(byte[] bytesRead, CancellationToken cancel)
  
      {
  
          Span<byte> buffer = new byte[5 * 1024 * 1024];
  
          bytesRead.CopyTo(buffer);
  
          int bufferEmptyIndex = bytesRead.Length;
  
  
  
          do
  
          {
  
              if (bufferEmptyIndex &lt; ClusterStart.Length + 4)
  
              {
  
                  ReadMoreBytes(buffer.Slice(bufferEmptyIndex, 1024));
  
                  bufferEmptyIndex += 1024;
  
              }
  
  
  
              int clusterDataSize = BitConverter.ToInt32(
  
                  buffer.Slice(ClusterStart.Length, 4)
  
                  .ToArray()
  
                  .Reverse()
  
                  .ToArray()
  
              );
  
              int clusterSize = ClusterStart.Length + 4 + clusterDataSize;
  
              if (clusterSize > buffer.Length)
  
              {
  
                  byte[] newBuffer = new byte[clusterSize];
  
                  buffer.Slice(0, bufferEmptyIndex).CopyTo(newBuffer);
  
                  buffer = newBuffer;
  
              }
  
  
  
              if (bufferEmptyIndex &lt; clusterSize)
  
              {
  
                  ReadMoreBytes(buffer.Slice(bufferEmptyIndex, clusterSize - bufferEmptyIndex));
  
                  bufferEmptyIndex = clusterSize;
  
              }
  
  
  
              ClusterReadyEvent?.Invoke(this, new ClusterReadyEventArgs(buffer.Slice(0, bufferEmptyIndex).ToArray()));
  
  
  
              bufferEmptyIndex = 0;
  
          } while (!cancel.IsCancellationRequested);
  
      }
  
  }
  
  </byte></byte></byte></clusterreadyeventargs>

  I use ffmpeg to convert the rtsp stream to vp8 WEBM byte stream and parse it to "Init Segment" (ebml head、info、tracks...) and "Media Segment" (cluster)， then send it to browser via signalR

  $(function () {
  
  
  
      var mediaSource = new MediaSource();
  
      var mimeCodec = 'video/webm; codecs="vp8"';
  
  
  
      var video = document.getElementById('video');
  
  
  
      mediaSource.addEventListener('sourceopen', callback, false);
  
      function callback(e) {
  
          var sourceBuffer = mediaSource.addSourceBuffer(mimeCodec);
  
          var queue = [];
  
  
  
          sourceBuffer.addEventListener('updateend', function () {
  
              if (queue.length === 0) {
  
                  return;
  
              }
  
  
  
              var base64 = queue[0];
  
              if (base64.length === 0) {
  
                  mediaSource.endOfStream();
  
                  queue.shift();
  
                  return;
  
              } else {
  
                  var buffer = new Uint8Array(atob(base64).split("").map(function (c) {
  
                      return c.charCodeAt(0);
  
                  }));
  
                  sourceBuffer.appendBuffer(buffer);
  
                  queue.shift();
  
              }
  
          }, false);
  
  
  
          var connection = new signalR.HubConnectionBuilder()
  
              .withUrl("/signalr-video")
  
              .configureLogging(signalR.LogLevel.Information)
  
              .build();
  
          connection.start().then(function () {
  
              connection.stream("InitVideoReceive")
  
                  .subscribe({
  
                      next: function(item) {
  
                          if (queue.length === 0 && !!!sourceBuffer.updating) {
  
                              var buffer = new Uint8Array(atob(item).split("").map(function (c) {
  
                                  return c.charCodeAt(0);
  
                              }));
  
                              sourceBuffer.appendBuffer(buffer);
  
                              console.log(blockindex++ + " : " + buffer.byteLength);
  
                          } else {
  
                              queue.push(item);
  
                          }
  
                      },
  
                      complete: function () {
  
                          queue.push('');
  
                      },
  
                      error: function (err) {
  
                          console.error(err);
  
                      }
  
                  });
  
          });
  
      }
  
      video.src = window.URL.createObjectURL(mediaSource);
  
  })

  chrome just play the video for 3 5 seconds and then stop for buffering, even though there are plenty of cluster transfered and inserted into SourceBuffer.

  here’s the information in chrome ://media-internals/

  Player Properties :

  render_id: 217
  
  player_id: 1
  
  origin_url: http://localhost:52531/
  
  frame_url: http://localhost:52531/
  
  frame_title: Home Page
  
  url: blob:http://localhost:52531/dcb25d89-9830-40a5-ba88-33c13b5c03eb
  
  info: Selected FFmpegVideoDecoder for video decoding, config: codec: vp8 format: 1 profile: vp8 coded size: [1280,720] visible rect: [0,0,1280,720] natural size: [1280,720] has extra data? false encryption scheme: Unencrypted rotation: 0°
  
  pipeline_state: kSuspended
  
  found_video_stream: true
  
  video_codec_name: vp8
  
  video_dds: false
  
  video_decoder: FFmpegVideoDecoder
  
  duration: unknown
  
  height: 720
  
  width: 1280
  
  video_buffering_state: BUFFERING_HAVE_NOTHING
  
  for_suspended_start: false
  
  pipeline_buffering_state: BUFFERING_HAVE_NOTHING
  
  event: PAUSE

  Log

  Timestamp       Property            Value
  
  00:00:00 00     origin_url          http://localhost:52531/
  
  00:00:00 00     frame_url           http://localhost:52531/
  
  00:00:00 00     frame_title         Home Page
  
  00:00:00 00     url                 blob:http://localhost:52531/dcb25d89-9830-40a5-ba88-33c13b5c03eb
  
  00:00:00 00     info                ChunkDemuxer: buffering by DTS
  
  00:00:00 35     pipeline_state      kStarting
  
  00:00:15 213    found_video_stream  true
  
  00:00:15 213    video_codec_name    vp8
  
  00:00:15 216    video_dds           false
  
  00:00:15 216    video_decoder       FFmpegVideoDecoder
  
  00:00:15 216    info                Selected FFmpegVideoDecoder for video decoding, config: codec: vp8 format: 1 profile: vp8 coded size: [1280,720] visible rect: [0,0,1280,720] natural size: [1280,720] has extra data? false encryption scheme: Unencrypted rotation: 0°
  
  00:00:15 216    pipeline_state      kPlaying
  
  00:00:15 213    duration            unknown
  
  00:00:16 661    height              720
  
  00:00:16 661    width               1280
  
  00:00:16 665    video_buffering_state       BUFFERING_HAVE_ENOUGH
  
  00:00:16 665    for_suspended_start         false
  
  00:00:16 665    pipeline_buffering_state    BUFFERING_HAVE_ENOUGH
  
  00:00:16 667    pipeline_state      kSuspending
  
  00:00:16 670    pipeline_state      kSuspended
  
  00:00:52 759    info                Effective playback rate changed from 0 to 1
  
  00:00:52 759    event               PLAY
  
  00:00:52 759    pipeline_state      kResuming
  
  00:00:52 760    video_dds           false
  
  00:00:52 760    video_decoder       FFmpegVideoDecoder
  
  00:00:52 760    info                Selected FFmpegVideoDecoder for video decoding, config: codec: vp8 format: 1 profile: vp8 coded size: [1280,720] visible rect: [0,0,1280,720] natural size: [1280,720] has extra data? false encryption scheme: Unencrypted rotation: 0°
  
  00:00:52 760    pipeline_state      kPlaying
  
  00:00:52 793    height              720
  
  00:00:52 793    width               1280
  
  00:00:52 798    video_buffering_state       BUFFERING_HAVE_ENOUGH
  
  00:00:52 798    for_suspended_start         false
  
  00:00:52 798    pipeline_buffering_state    BUFFERING_HAVE_ENOUGH
  
  00:00:56 278    video_buffering_state       BUFFERING_HAVE_NOTHING
  
  00:00:56 295    for_suspended_start         false
  
  00:00:56 295    pipeline_buffering_state    BUFFERING_HAVE_NOTHING
  
  00:01:20 717    event               PAUSE
  
  00:01:33 538    event               PLAY
  
  00:01:35 94     event               PAUSE
  
  00:01:55 561    pipeline_state      kSuspending
  
  00:01:55 563    pipeline_state      kSuspended

  Can someone tell me what’s wrong with my code, or dose chrome require some magic configuration to work ?

  Thanks 

  Please excuse my english :)

• Issues with processing media on windows Azure

  23 septembre 2015, par Ahmed Mujtaba

  I have a website built on ASP.NET web forms that works as a media portal for users to upload videos. I’m using ffmpeg encoders to produce video contents to be streamed in the browser. I’m using the web deploy method to publish the site on the Azure server. The website get’s deployed properly however I get following issues in the live site.

  1. Video never get’s encoded and published. I get some sort of error.

  2. Video get’s published but the process of uploading and encoding the video is way too slow on the web server.

  My project solution contains upload.ashx that handles the upload requests and makes the call to encode.ashx which is responsible for the encoding and publishing of the videos. I tried to remotely debug the site but the debugger never get’s to encode.ashx.

  I was wondering if these issues can be resolved by having the website deployed with a VM ?

  Script that uploads the video file :

   var filesuploaded = 0;
  
      var faileduploaded = 0;
  
  
  
      $(function () {
  
          var uploader = new plupload.Uploader({
  
              runtimes: 'gears,html5,flash,silverlight,browserplus',
  
              browse_button: '<%= pickfiles.ClientID %>',
  
              container: 'container',
  
              max_file_size: '<%= MaxMediaSize %>mb',
  
              url: '<%=Config.GetUrl() %>videos/upload/upload.ashx',
  
              flash_swf_url: '<%=Config.GetUrl() %>plupload/js/plupload.flash.swf',
  
              silverlight_xap_url: '<%=Config.GetUrl() %>plupload/js/plupload.silverlight.xap',
  
              chunk_size: '4mb',
  
              <%= UniqueNames %>
  
              filters: [
  
              { title: '<%= AllowedFormatsDisplay %>', extensions: '<%= AllowedFormats %>'}],
  
              headers: { UName: '<%=UserName %>', MTP: '<%= MediaType %>' }
  
          });
  
          //uploader.bind('Init', function (up, params) {
  
          //    $('#filelist').html("<div>Current runtime: " + params.runtime + "</div>");
  
          //});
  
  
  
          uploader.init();
  
  
  
          $('#uploadfiles').click(function (e) {
  
              uploader.start();
  
              e.preventDefault();
  
              $("#uploadfiles").hide();
  
              $("#&lt;%= embd.ClientID %>").hide();
  
          });
  
  
  
          uploader.bind('FilesAdded', function (up, files) {
  
              $("#uploadfiles").show();
  
              $("#&lt;%= msg.ClientID %>").html("");
  
              var count=0;
  
              $.each(files, function (i, file) {
  
                  $('#filelist').append(
  
                      '<div class="item_pad_4 bx_br_bt">' + (count + 1) + ': ' + file.name + ' (' + plupload.formatSize(file.size) + ')  <b></b></div>' );
  
                  count++;
  
              });
  
              var maxupload = &lt;%= MaxVideoUploads %>;
  
              if(count > maxupload) 
  
              {               
  
                  $.each(files, function(i, file) {
  
                      uploader.removeFile(file);
  
                  });
  
  
  
                  $('#filelist').html("");
  
                  $("#uploadfiles").hide();
  
                  Display_Message("#&lt;%= msg.ClientID %>", "Can't upload more than " + maxupload + " records at once!", 1, 1);
  
                  return false;
  
              }
  
              else {
  
                  $("#tfiles").html(count);
  
                  $("#uploadfiles").removeClass("disabled");
  
                  $("#&lt;%= pickfiles.ClientID %>").hide();
  
              }
  
              up.refresh(); // Reposition Flash/Silverlight
  
          });
  
  
  
          uploader.bind('UploadProgress', function (up, file) {
  
              $('#' + file.id + " b").html(file.percent + "%");
  
          });
  
  
  
          uploader.bind('Error', function (up, err) {
  
              $('#filelist').append("<div>Error: " + err.code +
  
                  ", Message: " + err.message +
  
                  (err.file ? ", File: " + err.file.name : "") +
  
                  "</div>"
  
              );
  
              up.refresh(); // Reposition Flash/Silverlight
  
          });
  
  
  
          var failedstatus = 0;
  
          uploader.bind('FileUploaded', function (up, file, info) {
  
              // encode started
  
              if (info.response != "failed" &amp;&amp; info.response != "") {
  
                  EncodeVD(file.id, info.response, file.size);
  
                  Display_Message('#' + file.id, "Please wait for final processing", 0, 1);
  
                  if (failedstatus == 0)
  
                      Redirect(info.response);
  
                  filesuploaded++;
  
              }
  
              else {
  
                  Display_Message('#' + file.id, "Response is: " + info.response, 0, 1);
  
              }
  
          });
  
      });
  
      var redcnt = 0;
  
      function Redirect(filename) {
  
          var IntervalID = setInterval(function () {
  
              redcnt++;
  
              if (redcnt > 2) {
  
                  clearInterval(IntervalID);
  
                  var tfiles = $("#tfiles").html();
  
                  if(tfiles == faileduploaded) { // break further processing all videos failed to upload
  
                  }
  
                  else if (filesuploaded >= tfiles) {
  
                      document.location = "&lt;%=ConfirmPageUrl %>?fn=" + filename + "&amp;gid=&lt;%=GalleryID %>&amp;uvids=" + $("#tfiles").html() + "&amp;mpid=" + $("#maxpid").html().trim() + "&lt;%=GroupParam %>";
  
                  }
  
          }
  
          }, 2000);
  
  }
  
  function EncodeVD(mid, mfile, msize) {
  
      var params = '&lt;%= EncodingParams %>&amp;fn=' + mfile;
  
          $.ajax({
  
              type: 'GET',
  
              url: '&lt;%= Encoding_Handler_Path %>',
  
              data: params,
  
              async: true,
  
              success: function (msg) {
  
                  if (msg == "Success" || msg == "") {
  
                      $('#' + mid).html('<strong>Uploading Completed Successfully - Wait for Processing.');
  
                  }
  
                  else {
  
                      failedstatus = 1;
  
                      faileduploaded++;
  
                      Display_Message('#' + mid, "Response is: " + msg, 0, 1);
  
                  }
  
              }
  
          });
  
      }
  
  </strong>

  Server side code for processing the file upload :

   private int MediaType = 0; // 0 : video, 1: audio
  
  
  
      public void ProcessRequest (HttpContext context) {
  
          try
  
          {
  
              context.Response.ContentType = "text/plain";
  
              context.Response.Write(ProcessMedia(context));
  
          }
  
          catch (Exception ex)
  
          {
  
              context.Response.Write("error|" + ex.Message);
  
          }
  
      }
  
  
  
      public string ProcessMedia(HttpContext context)
  
      {
  
          if (context.Request.Files.Count > 0)
  
          {
  
              int chunk = context.Request["chunk"] != null ? int.Parse(context.Request["chunk"]) : 0;
  
              string fileName = context.Request["name"] != null ? context.Request["name"] : string.Empty;
  
              //string _fileName = fileName.Remove(fileName.LastIndexOf(".")) + "-" + Guid.NewGuid().ToString().Substring(0, 6) + "" + fileName.Remove(0, fileName.LastIndexOf("."));
  
              HttpPostedFile fileUpload = context.Request.Files[0];
  
  
  
              string upath = "";
  
              if (context.Request.Headers["UName"] != null)
  
                  upath = context.Request.Headers["UName"].ToString();
  
  
  
              //if (CloudSettings.EnableCloudStorage && upath != "")
  
              //    _fileName = upath.Substring(0, 3) + "-" + _fileName; // avoid duplication in cloud storage
  
  
  
              if (context.Request.Headers["MTP"] != null)
  
                  MediaType = Convert.ToInt32(context.Request.Headers["MTP"]);
  
  
  
              //string extensions = "";
  
              //if (MediaType == 0)
  
              //    extensions = Site_Settings.Video_Allowed_Formats;
  
              //else
  
              //    extensions = Site_Settings.Audio_Allowed_Formats;
  
  
  
              //bool sts = UtilityBLL.Check_File_Extension(extensions, fileName.ToLower());
  
              //if (sts == false)
  
              //{
  
              //    return "Invalid format, please upload proper video!"; // Invalid video format, please upload proper video
  
              //}
  
  
  
              int allowable_size_mb = 0;
  
              if (MediaType == 0)
  
              {
  
                  allowable_size_mb = Site_Settings.Video_Max_Size;
  
              }
  
              else
  
              {
  
                  allowable_size_mb = Site_Settings.Audio_Max_Size;
  
              }
  
              int UploadSize = allowable_size_mb * 1000000;
  
              if (fileUpload.ContentLength > UploadSize)
  
              {
  
                  return "Video Limit Exceeds";
  
              }
  
  
  
              string uploadPath = "";
  
              // check whether audio / mp3 encoding enabled
  
              if (this.MediaType == 1)
  
              {
  
                  // audio encoding
  
                  if (fileName.EndsWith(".mp3"))
  
                  {
  
                      // upload mp3 directly in mp3 path instead of default path
  
                      if (upath == "")
  
                          uploadPath = UrlConfig.MP3_Path(); // source video path
  
                      else
  
                          uploadPath = UrlConfig.MP3_Path(upath); // source video path
  
                  }
  
                  else
  
                  {
  
                      // default path
  
                      if (upath == "")
  
                          uploadPath = UrlConfig.Source_Video_Path(); // source video path
  
                      else
  
                          uploadPath = UrlConfig.Source_Video_Path(upath); // source video path
  
                  }
  
              }
  
              else
  
              {//azure
  
                  // default path
  
                  if (upath == "")
  
                      uploadPath = UrlConfig.Source_Video_Path(); // source video path
  
                  else
  
                      uploadPath = UrlConfig.Source_Video_Path(upath); // source video path
  
              }
  
  
  
              FileStream fs;
  
              using (fs = new FileStream(Path.Combine(uploadPath, fileName), chunk == 0 ? FileMode.Create : FileMode.Append))
  
              {
  
                  byte[] buffer = new byte[fileUpload.InputStream.Length];
  
                  fileUpload.InputStream.Read(buffer, 0, buffer.Length);
  
  
  
                  fs.Write(buffer, 0, buffer.Length);
  
              }
  
              return fileName; // "Success";
  
          }
  
          else
  
          {
  
              return "failed";
  
          }
  
  
  
          return "";
  
      }
  
      public bool IsReusable {
  
          get {
  
              return false;
  
          }
  
      }

  code in encode.aspx responsible for encoding the video :

  private string EncodeMedia(HttpContext context)
  
  {
  
      string sourcepath = "";
  
      string publishedpath = "";
  
      string mp3path = "";
  
      string thumbpath = "";
  
      if (this.UserName != "")
  
      {//azure
  
          sourcepath = UrlConfig.Source_Video_Path(this.UserName);
  
          publishedpath = UrlConfig.Published_Video_Path(this.UserName);
  
          mp3path = UrlConfig.MP3_Path(this.UserName);
  
          thumbpath = UrlConfig.Thumbs_Path(this.UserName);
  
      }
  
      else
  
      {
  
          sourcepath = UrlConfig.Source_Video_Path();
  
          publishedpath = UrlConfig.Published_Video_Path();
  
          mp3path = UrlConfig.MP3_Path();
  
          thumbpath = UrlConfig.Thumbs_Path();
  
      }
  
      if (this.FileName.EndsWith(".mp3") && this.MediaType == 1)
  
      {
  
          // mp3 and audio format
  
          if (!File.Exists(mp3path + "/" + this.FileName))
  
          {
  
              return "Audio file not found!";
  
          }
  
      }
  
      else
  
      {
  
          // rest normal video and audio encoding
  
          if (!File.Exists(sourcepath + "/" + this.FileName))
  
          {
  
              return "Source file not found!";
  
          }
  
      }
  
  
  
      if (CloudSettings.EnableCloudStorage && this.UserName != "")
  
          this.FileName = this.UserName.Substring(0, 3) + "-" + this.FileName; // avoid duplication in cloud storage
  
  
  
  
  
      //double f_contentlength = 0;
  
      //if (Site_Settings.Feature_Packages == 1)
  
      //{
  
      //    if (Config.GetMembershipAccountUpgradeType() != 1)
  
      //    {
  
      //        // Check whether user have enough space to upload content
  
      //        // Restriction only for normal or premium users
  
      //        f_contentlength = (double)fileUpload.ContentLength / 1000000;
  
      //        string media_field_name = "space_video";
  
      //        if (MediaType == 1)
  
      //            media_field_name = "space_audio";
  
      //        if (!User_PackagesBLL.Check_User_Space_Status(upath, media_field_name, f_contentlength) && !isAdmin)
  
      //        {
  
      //            // insufficient credits to upload content
  
      //            return "Insufficient credits to upload media file"; //   Response.Redirect(Config.GetUrl("myaccount/packages.aspx?status=" + media_field_name), true);
  
      //        }
  
      //    }
  
      //}
  
  
  
      this.backgroundpublishing = true; // should be true on direct encoding
  
      // Video Processing
  
      string flv_filename = "";
  
      string original_filename = "";
  
      string thumb_filename = "";
  
      string duration = "";
  
      int duration_sec = 0;
  
  
  
      // set video actions : 1 -> on, 0 -> off
  
      int isenabled = 1;
  
      int ispublished = 1;
  
      int isreviewed = 1;
  
      int isresponse = 0;
  
      if (Response_VideoID > 0)
  
          isresponse = 1;
  
  
  
      string flv_url = "none";
  
      string thumb_url = "none";
  
      string org_url = "none";
  
      string _embed = "";
  
  
  
      string errorcode = "0";
  
      VideoInfo info = null;
  
  
  
      if (Site_Settings.Content_Approval == 0)
  
          isreviewed = 0;
  
  
  
  
  
      // check whether audio / mp3 encoding enabled
  
      if (this.FileName.EndsWith(".mp3") && this.MediaType==1)
  
      {
  
          // audio encoding
  
          // mp3 file already
  
          // so no encoding happens
  
          MediaHandler _minfo = new MediaHandler();
  
          _minfo.FFMPEGPath = Encoding_Settings.FFMPEGPATH;
  
          _minfo.FileName = FileName;
  
          _minfo.InputPath = mp3path;
  
          info = _minfo.Get_Info();
  
  
  
          flv_filename = FileName;
  
          original_filename = FileName;
  
          duration = info.Duration;
  
          duration_sec = info.Duration_Sec;
  
          isenabled = 1; // enabled
  
      }
  
      else if (this.directpublishing)
  
      {            
  
  
  
          // publish video
  
          ArrayList itags = new ArrayList();
  
          MHPEncoder encoder = new MHPEncoder();
  
          //if (this.FileName.EndsWith(".mpeg") || this.FileName.EndsWith(".mpg")) // use mpg compatible ffmpeg encoder
  
          //    encoder.FfmpegPath = HttpContext.Current.Server.MapPath(HttpContext.Current.Request.ApplicationPath) + "\\ffmpeg\\ffmpegbk\\ffmpeg.exe";
  
              //encoder.ThumbFfmpegPath = Encoding_Settings.FFMPEGPATH; // use normal ffmpeg encoder for thumbs processing
  
  
  
          //azure
  
          encoder.FfmpegPath = Encoding_Settings.FFMPEGPATH; // use normal ffmpeg encoder
  
          encoder.FlvToolPath = Encoding_Settings.FLVTOOLPATH; // set meta information for flv videos
  
          encoder.Mp4BoxPath = Encoding_Settings.MP4BoxPath; // set meta information for mp4 videos
  
          encoder.SourcePath = sourcepath;
  
          encoder.SourceFileName = this.FileName;
  
  
  
          // No cloud storage on direct encoding
  
          //if (CloudSettings.EnableCloudStorage)
  
          //    encoder.EnableCloudStorage = true;
  
  
  
  
  
          if (MediaType == 1)
  
          {
  
              // audio encoding
  
              itags.Add("14");
  
              encoder.iTags = itags;
  
              encoder.GrabThumbs = false;
  
              encoder.PublishedPath = mp3path;
  
  
  
              //_vprocess.OutputPath = this.MP3Path;
  
              //_vprocess.isAudio = true;
  
          }
  
          else
  
          {
  
              // video encoding
  
              itags.Add(EncoderSettings.DefaultITagValue.ToString()); // 5 for 360p mp4 encoding    
  
              //itags.Add(7);   // this will call 7 case settings to publish next video ending with _7.mp4 instead of _5.mp4
  
              // so there will be 2 videos with different resoultions published at the end of the process?
  
              // yesmake sure use proper settings first test it directly via command.     
  
              //okay i got it. But i'm gonna have to use a different media players to incroporate those settings
  
              // once published you can load different videos for different user by checking _7.mp4 (end) va
  
             //okay got it.
  
  
  
              //azure
  
              encoder.PublishedPath = publishedpath;
  
              encoder.iTags = itags;
  
              encoder.ThumbsDirectory = thumbpath;
  
              encoder.TotalThumbs = 15;
  
  
  
              //_vprocess.ThumbPath = this.ThumbPath;
  
              //_vprocess.OutputPath = this.FLVPath;
  
              //if (Config.isPostWaterMark())
  
              //{
  
              //    // script for posting watermark on video
  
              //    _vprocess.WaterMarkPath = Server.MapPath(Request.ApplicationPath) + "\\contents\\watermark";
  
              //    _vprocess.WaterMarkImage = "watermark.gif";
  
  
  
              //}
  
          }
  
          int deleteoption = Site_Settings.Video_Delete_Original;
  
          if (deleteoption == 1)
  
          {
  
              encoder.DeleteSource = true;
  
          }
  
          // background processing
  
          if (this.backgroundpublishing && this.MediaType==0)
  
          {
  
              encoder.BackgroundProcessing = true;
  
              // get information from source video in order to store it in database
  
              MediaHandler _minfo = new MediaHandler();
  
              //if (this.FileName.EndsWith(".mpeg") || this.FileName.EndsWith(".mpg")) // use mpg compatible ffmpeg encoder
  
              //    encoder.FfmpegPath = HttpContext.Current.Server.MapPath(HttpContext.Current.Request.ApplicationPath) + "\\ffmpeg\\ffmpegbk\\ffmpeg.exe";
  
              //else
  
                  _minfo.FFMPEGPath = Encoding_Settings.FFMPEGPATH;
  
  
  
              _minfo.FileName = FileName;
  
              _minfo.InputPath = sourcepath;
  
              info = _minfo.Get_Info();
  
          }
  
          // encode video processing
  
          Video_Information vinfo = encoder.Process();
  
          if (vinfo.ErrorCode > 0)
  
          {
  
              errorcode = vinfo.ErrorCode.ToString();
  
              ErrorLgBLL.Add_Log("Encoding Failed Log", "", "encoding error: " + vinfo.ErrorCode.ToString() + "<br />Description: " + vinfo.ErrorDescription.ToString());
  
               //return vinfo.ErrorDescription;
  
          }
  
          // Double check validation
  
          // if published video exist
  
          // if thumb exist
  
          // then proceed further
  
  
  
          if (MediaType == 0)
  
          {
  
              if (!File.Exists(encoder.PublishedPath + "/" + vinfo.FLVVideoName))
  
              {
  
                  return "Video failed to published properly.";
  
              }
  
              if (!File.Exists(encoder.ThumbsDirectory + "/" + vinfo.ThumbFileName))
  
              {
  
                  return "Thumbs failed to grab from video properly.";
  
              }
  
          }
  
          else
  
          {
  
              if (vinfo.FLVVideoName == "")
  
              {
  
                  vinfo.FLVVideoName = this.FileName.Remove(this.FileName.LastIndexOf(".")) + "_14.mp3"; // mp3 file path name
  
              }
  
              if (!File.Exists(encoder.PublishedPath + "/" + vinfo.FLVVideoName))
  
              {
  
                  return "Audio failed to published properly.";
  
              }
  
          }
  
          // Now thumbs and video published, procceed for data processing
  
          // get information from vinfo object
  
          if (this.backgroundpublishing &amp;&amp; this.MediaType == 0)
  
          {
  
              string OutputFileName = this.FileName.Remove(this.FileName.LastIndexOf("."));
  
              flv_filename = OutputFileName + "_" + EncoderSettings.DefaultITagValue + "." + EncoderSettings.Return_Output_Extension(EncoderSettings.DefaultITagValue);
  
              original_filename = vinfo.OriginalVideoName;
  
              thumb_filename = OutputFileName + "_008.jpg"; // info.ThumbFileName;
  
              duration = info.Duration;
  
              duration_sec = info.Duration_Sec;
  
          }
  
          else
  
          {
  
              flv_filename = vinfo.FLVVideoName;
  
              original_filename = vinfo.OriginalVideoName;
  
              thumb_filename = vinfo.ThumbFileName;
  
              duration = vinfo.Duration;
  
              duration_sec = vinfo.Duration_Sec;
  
              isenabled = vinfo.isEnabled;
  
          }
  
  
  
          // No cloud storage on direct encoding.
  
          // Note cloude storage only works if background processing is disabled
  
          // Or works in cased of sheduled processing
  
          if (CloudSettings.EnableCloudStorage &amp;&amp; errorcode == "0")
  
          {
  
              flv_url = "amazon";
  
              org_url = "https://s3.amazonaws.com/" + CloudSettings.OriginalVideoBucketName + "/" + this.FileName;
  
              thumb_url = "https://s3.amazonaws.com/" + CloudSettings.ThumbsBucketName + "/" + thumb_filename;
  
  
  
          }
  
  
  
      }
  
      else
  
      {
  
          // set publishing status off.
  
          ispublished = 0;
  
          original_filename = this.FileName;
  
      }
  
  
  
      // Store video information in database
  
      string ipaddress = context.Request.ServerVariables["REMOTE_ADDR"].ToString();
  
  
  
      // Store media information in database
  
      Video_Struct vd = new Video_Struct();
  
      vd.CategoryID = 0; // store categoryname or term instead of category id
  
      vd.Categories = Categories;
  
      vd.UserName = UserName;
  
      vd.Title = "";
  
      vd.Description = "";
  
      vd.Tags = Tags;
  
      vd.Duration = duration;
  
      vd.Duration_Sec = duration_sec;
  
      vd.OriginalVideoFileName = original_filename;
  
      vd.VideoFileName = flv_filename;
  
      vd.ThumbFileName = thumb_filename;
  
      vd.isPrivate = Privacy;
  
      vd.AuthKey = PAuth;
  
      vd.isEnabled = isenabled;
  
      vd.Response_VideoID = Response_VideoID; // video responses
  
      vd.isResponse = isresponse;
  
      vd.isPublished = ispublished;
  
      vd.isReviewed = isreviewed;
  
      vd.FLV_Url = flv_url;
  
      vd.Thumb_Url = thumb_url;
  
      vd.Org_Url = org_url;
  
      vd.Embed_Script = _embed;
  
      vd.isExternal = 0; // website own video, 1: embed video
  
      vd.IPAddress = ipaddress;
  
      vd.Type = MediaType;
  
      vd.YoutubeID = "";
  
      vd.isTagsreViewed = 1;
  
      vd.Mode = 0; // filter videos based on website sections
  
      //vd.ContentLength = f_contentlength;
  
      vd.GalleryID = GID;
  
      vd.ErrorCode = Convert.ToInt32(errorcode);
  
      long videoid = VideoBLL.Process_Info(vd, false);
  
  
  
      // Process tags
  
      if (Tags != "")
  
      {
  
          int tag_type = 0; // represent videos
  
          if (MediaType == 1)
  
              tag_type = 4; // represent audio file
  
          TagsBLL.Process_Tags(Tags, tag_type, 0);
  
      }
  
  
  
      if (Response_VideoID > 0)
  
      {
  
          VideoBLL.Update_Responses(Response_VideoID);
  
      }
  
  
  
      return "Success";
  
  }

• ffmpeg : replace "flush Media" with "flush_media" in benchmark_all output

  27 janvier 2016, par Stefano Sabatini

  ffmpeg : replace "flush Media" with "flush_media" in benchmark_all output
  Simplify parsing and consistency.
  

  • [DH] ffmpeg.c