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