private void PollEncodeProgress() { IntPtr json = HBFunctions.hb_get_state_json(this.hbHandle); string statusJson = Marshal.PtrToStringAnsi(json); this.log.LogMessage(statusJson, LogMessageType.Progress, LogLevel.Trace); JsonState state = JsonConvert.DeserializeObject <JsonState>(statusJson); if (state != null && state.State == NativeConstants.HB_STATE_WORKING) { if (this.EncodeProgress != null) { var progressEventArgs = new EncodeProgressEventArgs(state.Working.Progress, state.Working.Rate, state.Working.RateAvg, new TimeSpan(state.Working.Hours, state.Working.Minutes, state.Working.Seconds), state.Working.PassID, state.Working.Pass, state.Working.PassCount); this.EncodeProgress(this, progressEventArgs); } } else if (state != null && state.State == NativeConstants.HB_STATE_WORKDONE) { this.encodePollTimer.Stop(); if (this.EncodeCompleted != null) { this.EncodeCompleted( this, new EncodeCompletedEventArgs(state.WorkDone.Error != (int)hb_error_code.HB_ERROR_NONE)); } } }
/// <summary> /// Displays the Encode status in the GUI /// </summary> /// <param name="sender">The sender</param> /// <param name="currentTask">The current task</param> /// <param name="taskCount">Number of tasks</param> /// <param name="percentComplete">Percent complete</param> /// <param name="currentFps">Current encode speed in fps</param> /// <param name="avg">Avg encode speed</param> /// <param name="timeRemaining">Time Left</param> private void EncodeOnEncodeProgress(object sender, int currentTask, int taskCount, float percentComplete, float currentFps, float avg, string timeRemaining) { EncodeProgressEventArgs eventArgs = new EncodeProgressEventArgs { AverageFrameRate = avg, CurrentFrameRate = currentFps, EstimatedTimeLeft = Converters.EncodeToTimespan(timeRemaining), PercentComplete = percentComplete, Task = currentTask, TaskCount = taskCount }; if (this.EncodeStatusChanged != null) { this.EncodeStatusChanged(this, eventArgs); } if (windowsSeven.IsWindowsSeven) { int percent; int.TryParse(Math.Round(percentComplete).ToString(), out percent); windowsSeven.SetTaskBarProgress(percent); } }
private void PollEncodeProgress() { IntPtr json = hbFunctions.hb_get_state_json(this.Handle); string statusJson = Marshal.PtrToStringAnsi(json); JsonState state = JsonConvert.DeserializeObject <JsonState>(statusJson); TaskState taskState = state != null?TaskState.FromRepositoryValue(state.State) : null; if (taskState != null && (taskState == TaskState.Working || taskState == TaskState.Muxing || taskState == TaskState.Searching)) { if (this.EncodeProgress != null) { TimeSpan eta = TimeSpan.FromSeconds(state.Working.ETASeconds); var progressEventArgs = new EncodeProgressEventArgs(state.Working.Progress, state.Working.Rate, state.Working.RateAvg, eta, state.Working.PassID, state.Working.Pass, state.Working.PassCount, taskState.Code); this.EncodeProgress(this, progressEventArgs); } } else if (taskState != null && taskState == TaskState.WorkDone) { this.encodePollTimer.Stop(); if (this.EncodeCompleted != null) { this.EncodeCompleted( this, new EncodeCompletedEventArgs(state.WorkDone.Error != (int)hb_error_code.HB_ERROR_NONE)); } } }
private void j_encodeProgress(object sender, EncodeProgressEventArgs e) { string status = string.Format("{0:F1}%", e.Progress); toolStripLabel1.Text = e.CurrentPass + "/2 " + status; Refresh(); }
/// <summary> /// The encode service_ encode status changed. /// </summary> /// <param name="sender"> /// The sender. /// </param> /// <param name="e"> /// The EncodeProgressEventArgs. /// </param> private void EncodeServiceEncodeStatusChanged(object sender, EncodeProgressEventArgs e) { if (EncodeStatusChanged != null) { this.EncodeStatusChanged(sender, e); } }
private void ExecuteCopy(string inFile, string outFile) { using (FileStream fromStream = new FileStream(inFile, FileMode.Open), toStream = new FileStream(outFile, FileMode.CreateNew)) { var reportTime = DateTime.Now; var totalFile = fromStream.Length; long current = 0; var buffer = new byte[1048576]; // 1 mbyte buffer var secRemaining = 0; do { var read = fromStream.Read(buffer, 0, buffer.Length); toStream.Write(buffer, 0, read); current += read; _totalCopied += read; var progress = (float)_totalCopied / _fileSizeToCopy * 100f; var elapsedTime = DateTime.Now - _startTime; var remainingSize = _fileSizeToCopy - _totalCopied; var speed = 0d; if (elapsedTime.TotalSeconds > 0) { speed = _totalCopied / elapsedTime.TotalSeconds; } if (speed > 0) { secRemaining = (int)Math.Floor(remainingSize / speed); } var remainingTime = TimeSpan.FromSeconds(secRemaining); if (reportTime.AddSeconds(1) > DateTime.Now) { continue; } var eventArgs = new EncodeProgressEventArgs { AverageFrameRate = 0, CurrentFrameRate = 0, EstimatedTimeLeft = remainingTime, PercentComplete = progress, ElapsedTime = elapsedTime, }; InvokeEncodeStatusChanged(eventArgs); reportTime = DateTime.Now; } while (totalFile != current); } // handle temp files if (_currentTask.NextStep == EncodingStep.MoveOutFile) { _currentTask.TempFiles.Add(inFile); } }
private void OnVideoEncodeProgress(object sender, EncodeProgressEventArgs e) { this.DoOnProgress(this, new ProgressEventArgs( (int)(((e.CurrentPass - 1) * 100 + e.Progress) / e.TotalPasses), -1, this.GetNumFiles(), e.CurrentItem.SourceFileName)); }
private void j_encodeProgress(object sender, EncodeProgressEventArgs e) { string status = string.Format("{0:F1}%", e.Progress); label1.Text = "Step: " + e.CurrentPass + "/2 " + status; progressBar1.Value = Convert.ToInt16(e.Progress); Refresh(); }
/// <summary> /// Invoke the Encode Status Changed Event. /// </summary> /// <param name="e"> /// The EncodeProgressEventArgs. /// </param> public void InvokeEncodeStatusChanged(EncodeProgressEventArgs e) { EncodeProgessStatus handler = this.EncodeStatusChanged; if (handler != null) { handler(this, e); } }
/// <summary> /// The encode progress callback. /// </summary> /// <param name="eventArgs"> /// The event args. /// </param> public override void EncodeProgressCallback(EncodeProgressEventArgs eventArgs) { if (this.EncodeStatusChanged != null) { ThreadPool.QueueUserWorkItem(delegate { this.EncodeStatusChanged(this, eventArgs); }); } base.EncodeProgressCallback(eventArgs); }
/// <summary> /// Encode Status has changed, update log window /// </summary> /// <param name="sender"> /// The sender. /// </param> /// <param name="e"> /// The e. /// </param> private void EncodeServiceEncodeStatusChanged(object sender, EncodeProgressEventArgs e) { if (encodeLogIndex != this.encodeService.LogIndex || this.encodeService.LogIndex == -1) { this.NotifyOfPropertyChange(() => this.EncodeLog); } encodeLogIndex = this.encodeService.LogIndex; }
void OnEncodeStatusChanged(object sender, EncodeProgressEventArgs e) { Dispatcher.BeginInvoke(() => { if (this.encodingQueue.IsEncoding) { PercentComplete = e.PercentComplete; ETA = String.Format( "{0}% Complete. ETA: {1}", Math.Round(e.PercentComplete), e.EstimatedTimeLeft); } }); }
/// <summary> /// Pase the CLI status output (from standard output) /// </summary> /// <param name="encodeStatus"> /// The encode Status. /// </param> /// <param name="startTime"> /// The start Time. /// </param> /// <returns> /// The <see cref="EncodeProgressEventArgs"/>. /// </returns> public EncodeProgressEventArgs ReadEncodeStatus(string encodeStatus, DateTime startTime) { try { Match m = Regex.Match( encodeStatus, @"^Encoding: task ([0-9]*) of ([0-9]*), ([0-9]*\.[0-9]*) %( \(([0-9]*\.[0-9]*) fps, avg ([0-9]*\.[0-9]*) fps, ETA ([0-9]{2})h([0-9]{2})m([0-9]{2})s\))?"); if (m.Success) { int currentTask = int.Parse(m.Groups[1].Value); int totalTasks = int.Parse(m.Groups[2].Value); float percent = float.Parse(m.Groups[3].Value, CultureInfo.InvariantCulture); float currentFps = m.Groups[5].Value == string.Empty ? 0.0F : float.Parse(m.Groups[5].Value, CultureInfo.InvariantCulture); float avgFps = m.Groups[6].Value == string.Empty ? 0.0F : float.Parse(m.Groups[6].Value, CultureInfo.InvariantCulture); string remaining = string.Empty; if (m.Groups[7].Value != string.Empty) { remaining = m.Groups[7].Value + ":" + m.Groups[8].Value + ":" + m.Groups[9].Value; } if (string.IsNullOrEmpty(remaining)) { remaining = "Calculating ..."; } EncodeProgressEventArgs eventArgs = new EncodeProgressEventArgs { AverageFrameRate = avgFps, CurrentFrameRate = currentFps, EstimatedTimeLeft = Converters.EncodeToTimespan( remaining), PercentComplete = percent, Task = currentTask, TaskCount = totalTasks, ElapsedTime = DateTime.Now - startTime, }; return(eventArgs); } return(null); } catch (Exception exc) { return(null); } }
/// <summary> /// The encode service_ encode status changed. /// </summary> /// <param name="sender"> /// The sender. /// </param> /// <param name="e"> /// The e. /// </param> private void EncodeService_EncodeStatusChanged(object sender, EncodeProgressEventArgs e) { this.Task = queueProcessor.LastProcessedJob.ScannedSourcePath; // {0:00.00}% FPS: {1:000.0} Avg FPS: {2:000.0} Time Remaining: {3} Elapsed: {4:hh\:mm\:ss} this.Progress = string.Format( Resources.MainViewModel_EncodeStatusChanged_StatusLabel, e.PercentComplete, e.CurrentFrameRate, e.AverageFrameRate, e.EstimatedTimeLeft, e.ElapsedTime); }
/// <summary> /// Pase the CLI status output (from standard output) /// </summary> /// <param name="encodeStatus"> /// The encode Status. /// </param> /// <param name="startTime"> /// The start Time. /// </param> /// <returns> /// The <see cref="EncodeProgressEventArgs"/>. /// </returns> public EncodeProgressEventArgs ReadEncodeStatus(string encodeStatus, DateTime startTime) { var eventArgs = new EncodeProgressEventArgs { AverageFrameRate = 0, CurrentFrameRate = 0, EstimatedTimeLeft = new TimeSpan(), PercentComplete = 0, ElapsedTime = DateTime.Now.TimeOfDay, }; return(eventArgs); }
private async void PollEncodeProgress() { ServerResponse response = null; try { response = await this.MakeHttpGetRequest("PollEncodeProgress"); } catch (Exception e) { if (this.encodePollTimer != null) { this.encodePollTimer.Stop(); } } if (response == null || !response.WasSuccessful) { return; } string statusJson = response.JsonResponse; JsonState state = JsonConvert.DeserializeObject <JsonState>(statusJson); TaskState taskState = state != null?TaskState.FromRepositoryValue(state.State) : null; if (taskState != null && (taskState == TaskState.Working || taskState == TaskState.Muxing || taskState == TaskState.Searching)) { if (this.EncodeProgress != null) { var progressEventArgs = new EncodeProgressEventArgs( fractionComplete: state.Working.Progress, currentFrameRate: state.Working.Rate, averageFrameRate: state.Working.RateAvg, estimatedTimeLeft: TimeSpan.FromSeconds(state.Working.ETASeconds), passId: state.Working.PassID, pass: state.Working.Pass, passCount: state.Working.PassCount, stateCode: taskState.Code); this.EncodeProgress(this, progressEventArgs); } } else if (taskState != null && taskState == TaskState.WorkDone) { this.encodePollTimer.Stop(); this.EncodeCompleted?.Invoke(sender: this, e: new EncodeCompletedEventArgs(state.WorkDone.Error != 0)); } }
private void ProcessLogMessage(string line) { if (string.IsNullOrEmpty(line)) { return; } var result = _demuxReg.Match(line); double processingSpeed = 0f; var secRemaining = 0; if (result.Success) { TimeSpan streamPosition; TimeSpan.TryParseExact(result.Groups[2].Value, @"hh\:mm\:ss\.ff", _appConfig.CInfo, out streamPosition); var secDemux = streamPosition.TotalSeconds; var remainingStreamTime = _currentTask.VideoStream.Length - secDemux; var elapsedTime = DateTime.Now - _startTime; if (elapsedTime.TotalSeconds > 0) { processingSpeed = secDemux / elapsedTime.TotalSeconds; } if (processingSpeed > 0) { secRemaining = (int)Math.Round(remainingStreamTime / processingSpeed, MidpointRounding.ToEven); } var remainingTime = new TimeSpan(0, 0, secRemaining); var progress = (float)Math.Round(secDemux / _currentTask.VideoStream.Length * 100d); var eventArgs = new EncodeProgressEventArgs { AverageFrameRate = 0, CurrentFrameRate = 0, EstimatedTimeLeft = remainingTime, PercentComplete = progress, ElapsedTime = elapsedTime, }; InvokeEncodeStatusChanged(eventArgs); } else { Log.Info($"ffmpeg: {line}"); } }
/// <summary> /// Encode Progress Event Handler /// </summary> /// <param name="sender"> /// The sender. /// </param> /// <param name="e"> /// The Interop.EncodeProgressEventArgs. /// </param> private void InstanceEncodeProgress(object sender, EncodeProgressEventArgs e) { EventArgs.EncodeProgressEventArgs args = new EventArgs.EncodeProgressEventArgs { AverageFrameRate = e.AverageFrameRate, CurrentFrameRate = e.CurrentFrameRate, EstimatedTimeLeft = e.EstimatedTimeLeft, PercentComplete = e.FractionComplete * 100, Task = e.Pass, ElapsedTime = DateTime.Now - this.startTime, }; this.InvokeEncodeStatusChanged(args); }
/// <summary> /// Handle the Encode Status Changed Event. /// </summary> /// <param name="sender"> /// The sender. /// </param> /// <param name="e"> /// The EncodeProgressEventArgs. /// </param> private void EncodeService_EncodeStatusChanged( object sender, EncodeProgressEventArgs e) { this.JobStatus = string.Format( "Encoding: Pass {0} of {1}, {2:00.00}%, FPS: {3:000.0}, Avg FPS: {4:000.0}, Time Remaining: {5}, Elapsed: {6:hh\\:mm\\:ss}", e.Task, e.TaskCount, e.PercentComplete, e.CurrentFrameRate, e.AverageFrameRate, e.EstimatedTimeLeft, e.ElapsedTime); }
/// <summary> /// The Encode Status has changed Handler /// </summary> /// <param name="sender"> /// The Sender /// </param> /// <param name="e"> /// The Encode Progress Event Args /// </param> private void EncodeStatusChanged(object sender, EncodeProgressEventArgs e) { int percent; int.TryParse(Math.Round(e.PercentComplete).ToString(CultureInfo.InvariantCulture), out percent); Execute.OnUIThread( () => { if (this.queueProcessor.EncodeService.IsEncoding) { string josPending = string.Empty; if (!AppArguments.IsInstantHandBrake) { josPending = ", Pending Jobs {5}"; } this.ProgramStatusLabel = string.Format( "{0:00.00}%, FPS: {1:000.0}, Avg FPS: {2:000.0}, Time Remaining: {3}, Elapsed: {4:hh\\:mm\\:ss}" + josPending, e.PercentComplete, e.CurrentFrameRate, e.AverageFrameRate, e.EstimatedTimeLeft, e.ElapsedTime, this.queueProcessor.Count); if (this.lastEncodePercentage != percent && this.windowsSeven.IsWindowsSeven) { this.windowsSeven.SetTaskBarProgress(percent); } this.lastEncodePercentage = percent; this.ProgressPercentage = percent; this.NotifyOfPropertyChange(() => this.ProgressPercentage); } else { this.ProgramStatusLabel = "Queue Finished"; this.IsEncoding = false; if (this.windowsSeven.IsWindowsSeven) { this.windowsSeven.SetTaskBarProgressToNoProgress(); } } }); }
/// <summary> /// Handle the Encode Status Changed Event. /// </summary> /// <param name="sender"> /// The sender. /// </param> /// <param name="e"> /// The EncodeProgressEventArgs. /// </param> private void EncodeService_EncodeStatusChanged(object sender, EncodeProgressEventArgs e) { Execute.OnUIThread(() => { this.JobStatus = string.Format( Resources.QueueViewModel_QueueStatusDisplay, e.Task, e.TaskCount, e.PercentComplete, e.CurrentFrameRate, e.AverageFrameRate, e.EstimatedTimeLeft, e.ElapsedTime); }); }
/// <summary> /// The encode service_ encode status changed. /// </summary> /// <param name="sender"> /// The sender. /// </param> /// <param name="e"> /// The e. /// </param> private void encodeService_EncodeStatusChanged(object sender, EncodeProgressEventArgs e) { Subscribers.ForEach( delegate(IHbServiceCallback callback) { if (((ICommunicationObject)callback).State == CommunicationState.Opened) { Console.WriteLine("Encode Status Callback"); callback.EncodeProgressCallback(e); } else { Subscribers.Remove(callback); } }); }
private void ProcessLogMessage(string line) { if (string.IsNullOrEmpty(line)) { return; } var result = _tsMuxerRegex.Match(line); if (result.Success) { float progress; float.TryParse(result.Groups[1].Value, NumberStyles.Number, _appConfig.CInfo, out progress); double processingSpeed = 0f; var secRemaining = 0; double remaining = 100 - progress; var elapsedTime = DateTime.Now.Subtract(_startTime); if (elapsedTime.TotalSeconds > 0) { processingSpeed = progress / elapsedTime.TotalSeconds; } if (processingSpeed > 0) { secRemaining = (int)Math.Round(remaining / processingSpeed, MidpointRounding.ToEven); } var remainingTime = new TimeSpan(0, 0, secRemaining); var eventArgs = new EncodeProgressEventArgs { AverageFrameRate = 0, CurrentFrameRate = 0, EstimatedTimeLeft = remainingTime, PercentComplete = progress, ElapsedTime = elapsedTime, }; InvokeEncodeStatusChanged(eventArgs); } else { Log.Info($"tsMuxer: {line}"); } }
private void ProcessLogMessage(string line) { if (string.IsNullOrEmpty(line)) { return; } var elapsedTime = DateTime.Now - _startTime; var result = _regObj.Match(line); if (result.Success) { float progress = Convert.ToInt32(result.Groups[1].Value); var progressLeft = 100f - progress; double speed = 0f; if (elapsedTime.TotalSeconds > 0) { speed = progress / elapsedTime.TotalSeconds; } long secLeft = 0; if (speed > 0) { secLeft = (int)Math.Floor(progressLeft * speed); } var remainingTime = TimeSpan.FromSeconds(secLeft); var eventArgs = new EncodeProgressEventArgs { AverageFrameRate = 0, CurrentFrameRate = 0, EstimatedTimeLeft = remainingTime, PercentComplete = progress, ElapsedTime = elapsedTime, }; InvokeEncodeStatusChanged(eventArgs); } else { Log.Info($"ffmsindex: {line}"); } }
/// <summary> /// The hb process output data received. /// </summary> /// <param name="sender"> /// The sender. /// </param> /// <param name="e"> /// The e. /// </param> private void HbProcess_OutputDataReceived(object sender, DataReceivedEventArgs e) { if (!String.IsNullOrEmpty(e.Data) && this.IsEncoding) { EncodeProgressEventArgs eventArgs = this.ReadEncodeStatus(e.Data, this.startTime); if (eventArgs != null) { if (!this.IsEncoding) { // We can get events out of order since the CLI progress is monitored on a background thread. // So make sure we don't send a status update after an encode complete event. return; } this.InvokeEncodeStatusChanged(eventArgs); } } }
private void InstanceEncodeProgress(object sender, EncodeProgressEventArgs e) { EventArgs.EncodeProgressEventArgs args = new EventArgs.EncodeProgressEventArgs { AverageFrameRate = e.AverageFrameRate, CurrentFrameRate = e.CurrentFrameRate, EstimatedTimeLeft = e.EstimatedTimeLeft, PercentComplete = e.FractionComplete * 100, Task = e.Pass, TaskCount = e.PassCount, ElapsedTime = DateTime.Now - this.startTime, PassId = e.PassId, IsMuxing = e.StateCode == TaskState.Muxing.Code, IsSearching = e.StateCode == TaskState.Searching.Code }; this.InvokeEncodeStatusChanged(args); }
private void EncoderProgressStatus(object sender, EncodeProgressEventArgs args) { var totalPercent = (_finishedSteps * _fullTaskPercent) + (_fullTaskPercent * args.PercentComplete / 100d); InvokeQueueStatusChanged(new QueueProgressEventArgs { JobName = string.Empty, AverageFrameRate = args.AverageFrameRate, CurrentFrameRate = args.CurrentFrameRate, CurrentFrame = args.CurrentFrame, TotalFrames = args.TotalFrames, ElapsedTime = args.ElapsedTime, EstimatedTimeLeft = args.EstimatedTimeLeft, PercentComplete = args.PercentComplete, TotalPercentComplete = totalPercent, Pass = args.Pass, }); }
private void PollEncodeProgress() { IntPtr json = HBFunctions.hb_get_state_json(this.hbHandle); string statusJson = Marshal.PtrToStringAnsi(json); LogHelper.LogMessage(new LogMessage(statusJson, LogMessageType.progressJson, LogLevel.debug)); JsonState state = JsonConvert.DeserializeObject <JsonState>(statusJson); if (state != null && state.State == NativeConstants.HB_STATE_WORKING) { if (this.EncodeProgress != null) { var progressEventArgs = new EncodeProgressEventArgs { FractionComplete = state.Working.Progress, CurrentFrameRate = state.Working.Rate, AverageFrameRate = state.Working.RateAvg, EstimatedTimeLeft = new TimeSpan(state.Working.Hours, state.Working.Minutes, state.Working.Seconds), PassId = state.Working.PassID, Pass = state.Working.Pass, PassCount = state.Working.PassCount }; this.EncodeProgress(this, progressEventArgs); } } else if (state != null && state.State == NativeConstants.HB_STATE_WORKDONE) { this.encodePollTimer.Stop(); if (this.EncodeCompleted != null) { this.EncodeCompleted(this, new EncodeCompletedEventArgs { Error = state.WorkDone.Error != (int)hb_error_code.HB_ERROR_NONE }); } } }
private void PollEncodeProgress() { IntPtr json = HBFunctions.hb_get_state_json(this.Handle); string statusJson = Marshal.PtrToStringAnsi(json); JsonState state = JsonSerializer.Deserialize <JsonState>(statusJson, JsonSettings.Options); TaskState taskState = state != null?TaskState.FromRepositoryValue(state.State) : null; if (taskState != null && (taskState == TaskState.Working || taskState == TaskState.Muxing || taskState == TaskState.Searching)) { if (this.EncodeProgress != null) { TimeSpan eta = TimeSpan.FromSeconds(state?.Working?.ETASeconds ?? 0); var progressEventArgs = new EncodeProgressEventArgs(0, 0, 0, TimeSpan.MinValue, 0, 0, 0, taskState.Code); if (taskState == TaskState.Muxing || state.Working == null) { progressEventArgs = new EncodeProgressEventArgs(100, 0, 0, TimeSpan.MinValue, 0, 0, 0, taskState.Code); } else { progressEventArgs = new EncodeProgressEventArgs(state.Working.Progress, state.Working.Rate, state.Working.RateAvg, eta, state.Working.PassID, state.Working.Pass, state.Working.PassCount, taskState.Code); } this.EncodeProgress(this, progressEventArgs); } } else if (taskState != null && taskState == TaskState.WorkDone) { this.encodePollTimer.Stop(); if (this.EncodeCompleted != null) { this.EncodeCompleted( this, new EncodeCompletedEventArgs(state.WorkDone.Error)); } } }
private void j_EncodeProgress(object sender, EncodeProgressEventArgs e) { string Status = String.Format("{0:F1}%", e.Progress); int progressValue = Convert.ToInt16(e.Progress); progressBar1.Value = progressValue; lblValue.Text = Status; if (e.CurrentPass == 2) { if (progressValue >= 100) { lblValue.Visible = false; lblStage.Visible = false; label5.Visible = false; label3.Text = "Encoded Successfully"; } lblStage.Text = "2 Of 2"; lblStage.Refresh(); } progressBar1.Refresh(); lblValue.Refresh(); }
static void OnProgress(object sender, EncodeProgressEventArgs e) { Console.Write("\b\b\b\b\b\b\b\b"); Console.Write("{0:F2}%", e.Progress); }
/// <summary> /// update log with encoding status /// </summary> /// <param name="sender">the Expression.Encoder.Job doing this encoding</param> /// <param name="args">progress information</param> private void Job_EncodeProgress (object sender, EncodeProgressEventArgs args) { // only write progress to log at a max frequency of once every so many seconds to reduce log size if (DateTime.Now - this.timeLastLogProgressWrite > TimeSpan.FromSeconds (EncoderFolderWatcherService.WatcherSettings.Default.progressUpdateIntervalSeconds)) { if (this.JobLog != null) { if (args.TotalPasses > 1) { this.JobLog.Write (String.Format (CultureInfo.CurrentCulture, "Progress:{0:#.##}% Pass:{1}/{2}\r\n", args.Progress, args.CurrentPass, args.TotalPasses)); } else { this.JobLog.Write (String.Format (CultureInfo.CurrentCulture, "Progress:{0:#.##}%\r\n", args.Progress)); } } this.timeLastLogProgressWrite = DateTime.Now; } args.Cancel = this.Stop; if (this.Stop) { this.JobLog.Write ("Encode stopped."); } }
private static void OnProgress(object sender, EncodeProgressEventArgs e) { Job EncoderJob = sender as Job; List<String> Names = new List<string> (); foreach (MediaItem Item in EncoderJob.MediaItems) { Names.Add (Path.GetFileName(Item.SourceFileName)); } String NewTitle = String.Join ("; ", Names.ToArray ()) + " - wird seit " + StartTime.ToShortTimeString () + " konvertiert"; if (Console.Title != NewTitle) Console.Title = NewTitle; double UsedProgress = e.Progress; if (e.Progress < 1) UsedProgress = 1; TimeSpan RemainingTime = TimeSpan.FromSeconds (((DateTime.Now - StartTime).TotalSeconds / UsedProgress) * (100 - UsedProgress)); Console.Write ("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b{0:F1}% noch {1:F1} Minuten", e.Progress, RemainingTime.TotalMinutes); }
private void OnEncodeProgress(object sender, EncodeProgressEventArgs e) { if (this.EncodeQueue.Count == 0) { return; } VCJob currentJob = this.EncodeQueue[0].Job; double passCost = currentJob.Length.TotalSeconds; double scanPassCost = passCost / EncodeJobViewModel.SubtitleScanCostFactor; double currentJobCompletedWork = 0.0; if (this.EncodeQueue[0].SubtitleScan) { switch (e.Pass) { case -1: currentJobCompletedWork += scanPassCost * e.FractionComplete; break; case 1: currentJobCompletedWork += scanPassCost; currentJobCompletedWork += passCost * e.FractionComplete; break; case 2: currentJobCompletedWork += scanPassCost; currentJobCompletedWork += passCost; currentJobCompletedWork += passCost * e.FractionComplete; break; default: break; } } else { switch (e.Pass) { case 1: currentJobCompletedWork += passCost * e.FractionComplete; break; case 2: currentJobCompletedWork += passCost; currentJobCompletedWork += passCost * e.FractionComplete; break; default: break; } } double totalCompletedWork = this.completedQueueWork + currentJobCompletedWork; this.OverallEncodeProgressFraction = totalCompletedWork / this.totalQueueCost; double overallWorkCompletionRate = totalCompletedWork / this.elapsedQueueEncodeTime.Elapsed.TotalSeconds; // Only update encode time every 5th update. if (Interlocked.Increment(ref this.pollCount) % 5 == 1) { if (this.elapsedQueueEncodeTime != null && this.elapsedQueueEncodeTime.Elapsed.TotalSeconds > 0.5 && this.OverallEncodeProgressFraction != 0.0) { if (this.OverallEncodeProgressFraction == 1.0) { this.EstimatedTimeRemaining = Utilities.FormatTimeSpan(TimeSpan.Zero); } else { try { this.overallEtaSpan = TimeSpan.FromSeconds((long) (((1.0 - this.OverallEncodeProgressFraction) * this.elapsedQueueEncodeTime.Elapsed.TotalSeconds) / this.OverallEncodeProgressFraction)); } catch (OverflowException) { this.overallEtaSpan = TimeSpan.MaxValue; } this.EstimatedTimeRemaining = Utilities.FormatTimeSpan(this.overallEtaSpan); } double currentJobRemainingWork = this.EncodeQueue[0].Cost - currentJobCompletedWork; try { this.currentJobEta = TimeSpan.FromSeconds(currentJobRemainingWork / overallWorkCompletionRate); } catch (OverflowException) { this.currentJobEta = TimeSpan.MaxValue; } this.EncodeQueue[0].Eta = this.currentJobEta; } } double currentJobFractionComplete = currentJobCompletedWork / this.EncodeQueue[0].Cost; this.EncodeQueue[0].PercentComplete = (int)(currentJobFractionComplete * 100.0); if (e.EstimatedTimeLeft >= TimeSpan.Zero) { this.CurrentFps = Math.Round(e.CurrentFrameRate, 1); this.AverageFps = Math.Round(e.AverageFrameRate, 1); this.EncodeSpeedDetailsAvailable = true; } VCProfile currentProfile = currentJob.EncodingProfile; var progressChangedMessage = new ProgressChangedMessage { Encoding = true, OverallProgressFraction = this.OverallEncodeProgressFraction, TaskNumber = this.taskNumber, TotalTasks = this.totalTasks, OverallElapsedTime = this.elapsedQueueEncodeTime.Elapsed, OverallEta = this.overallEtaSpan, FileName = Path.GetFileName(currentJob.OutputPath), FileProgressFraction = currentJobFractionComplete, FileElapsedTime = this.CurrentJob.EncodeTime, FileEta = this.currentJobEta, HasScanPass = this.CurrentJob.SubtitleScan, TwoPass = currentProfile.VideoEncodeRateType != VCVideoEncodeRateType.ConstantQuality && currentProfile.TwoPass, CurrentPass = e.Pass, PassProgressFraction = e.FractionComplete, EncodeSpeedDetailsAvailable = this.EncodeSpeedDetailsAvailable, CurrentFps = this.CurrentFps, AverageFps = this.AverageFps }; try { var outputFileInfo = new FileInfo(currentJob.OutputPath); progressChangedMessage.FileSizeBytes = outputFileInfo.Length; } catch (IOException) { } catch (UnauthorizedAccessException) { } Messenger.Default.Send(progressChangedMessage); }
/// <summary> /// Checks the status of the ongoing encode. /// </summary> private void PollEncodeProgress() { hb_state_s state = new hb_state_s(); HBFunctions.hb_get_state(this.hbHandle, ref state); if (state.state == NativeConstants.HB_STATE_WORKING) { if (this.EncodeProgress != null) { int pass = 1; int rawJobNumber = state.param.working.job_cur; if (this.currentJob.EncodingProfile.TwoPass) { if (this.subtitleScan) { switch (rawJobNumber) { case 1: pass = -1; break; case 2: pass = 1; break; case 3: pass = 2; break; default: break; } } else { switch (rawJobNumber) { case 1: pass = 1; break; case 2: pass = 2; break; default: break; } } } else { if (this.subtitleScan) { switch (rawJobNumber) { case 1: pass = -1; break; case 2: pass = 1; break; default: break; } } else { pass = 1; } } var progressEventArgs = new EncodeProgressEventArgs { FractionComplete = state.param.working.progress, CurrentFrameRate = state.param.working.rate_cur, AverageFrameRate = state.param.working.rate_avg, EstimatedTimeLeft = new TimeSpan(state.param.working.hours, state.param.working.minutes, state.param.working.seconds), Pass = pass }; this.EncodeProgress(this, progressEventArgs); } } else if (state.state == NativeConstants.HB_STATE_WORKDONE) { InteropUtilities.FreeMemory(this.encodeAllocatedMemory); this.encodePollTimer.Stop(); if (this.EncodeCompleted != null) { this.EncodeCompleted(this, new EncodeCompletedEventArgs { Error = state.param.workdone.error != hb_error_code.HB_ERROR_NONE }); } } }