Exemple #1
0
        public void StartScan(string path)
        {
            this.Instance = new HandBrakeInstance();
            this.Instance.Initialize(this.PassedVerbosity, noHardware: false);
            this.Instance.ScanProgress += (o, e) =>
            {
                this.MakeOneWayCallback(c => c.OnScanProgress((float)e.Progress));
            };
            this.Instance.ScanCompleted += async(o, e) =>
            {
                try
                {
                    await this.CallbackInvoker.InvokeAsync(c => c.OnScanComplete(this.Instance.TitlesJson));
                }
                catch (Exception exception)
                {
                    WorkerErrorLogger.LogError("Got exception when reporting completion: " + exception, isError: true);
                }
                finally
                {
                    this.CleanUpAndSignalCompletion();
                }
            };

            this.Instance.StartScan(path, this.PassedPreviewCount, TimeSpan.FromSeconds(this.PassedMinTitleDurationSeconds), 0);
        }
Exemple #2
0
        public void StartScan(string path)
        {
            this.instance = new HandBrakeInstance();
            this.instance.Initialize(this.passedVerbosity);
            this.instance.ScanProgress += (o, e) =>
            {
                this.callback.OnScanProgress((float)e.Progress);
            };
            this.instance.ScanCompleted += (o, e) =>
            {
                try
                {
                    this.callback.OnScanComplete(this.instance.TitlesJson);
                }
                catch (Exception exception)
                {
                    WorkerErrorLogger.LogError("Got exception when reporting completion: " + exception, isError: true);
                }
                finally
                {
                    this.CleanUpAndSignalCompletion();
                }
            };

            this.instance.StartScan(path, this.passedPreviewCount, TimeSpan.FromSeconds(this.passedMinTitleDurationSeconds), 0);
        }
Exemple #3
0
        // Executes a callback operation and stops the encode when a communication exception occurs.
        private void StopOnException(Action action)
        {
            try
            {
                action();
            }
            catch (CommunicationException exception)
            {
                WorkerErrorLogger.LogError("Got exception: " + exception, isError: true);

                this.StopEncodeIfPossible();
            }
        }
        // Executes a callback operation and stops the encode when an exception occurs.
        private async void StopOnException(Func <Task> action)
        {
            try
            {
                await action();
            }
            catch (Exception exception)
            {
                WorkerErrorLogger.LogError("Got exception: " + exception, isError: true);

                this.StopEncodeIfPossible();
            }
        }
Exemple #5
0
        private static async void StartService(HandBrakeWorkerAction action)
        {
            try
            {
                IPipeServer server;
                if (action == HandBrakeWorkerAction.Encode)
                {
                    PipeServerWithCallback <IHandBrakeEncodeWorkerCallback, IHandBrakeEncodeWorker> encodeServer = null;
                    Lazy <IHandBrakeEncodeWorker> lazyEncodeWorker = new Lazy <IHandBrakeEncodeWorker>(() => new HandBrakeEncodeWorker(encodeServer.Invoker));
                    encodeServer = new PipeServerWithCallback <IHandBrakeEncodeWorkerCallback, IHandBrakeEncodeWorker>(PipeName, () => lazyEncodeWorker.Value);
#if DEBUG
                    encodeServer.SetLogger(message => System.Diagnostics.Debug.WriteLine(message));
#endif
                    server = encodeServer;
                }
                else if (action == HandBrakeWorkerAction.Scan)
                {
                    PipeServerWithCallback <IHandBrakeScanWorkerCallback, IHandBrakeScanWorker> scanServer = null;
                    Lazy <IHandBrakeScanWorker> lazyScanWorker = new Lazy <IHandBrakeScanWorker>(() => new HandBrakeScanWorker(scanServer.Invoker));
                    scanServer = new PipeServerWithCallback <IHandBrakeScanWorkerCallback, IHandBrakeScanWorker>(PipeName, () => lazyScanWorker.Value);
#if DEBUG
                    scanServer.SetLogger(message => System.Diagnostics.Debug.WriteLine(message));
#endif
                    server = scanServer;
                }
                else
                {
                    throw new ArgumentException("Unrecognized action: " + action, nameof(action));
                }

                Task connectionTask = server.WaitForConnectionAsync();

                // Write a line to let the client know we are ready for connections
                Console.WriteLine($"Pipe '{PipeName}' is open");

                await connectionTask.ConfigureAwait(false);

                await server.WaitForRemotePipeCloseAsync().ConfigureAwait(false);
            }
            catch (Exception exception)
            {
                WorkerErrorLogger.LogError("Exception in StartService: " + exception, isError: true);
            }
        }
Exemple #6
0
        /// <summary>
        /// Starts an encode.
        /// </summary>
        /// <param name="scanPath">The path to scan.</param>
        /// <param name="titleNumber">The title number to scan.</param>
        /// <param name="jsonFunc">A function to pick the encode JSON given the scan.</param>
        private void StartEncodeInternal(string scanPath, int titleNumber, Func <JsonScanObject, string> jsonFunc)
        {
            try
            {
                this.instance = new HandBrakeInstance();
                this.instance.Initialize(this.passedVerbosity);

                this.instance.ScanCompleted += (o, e) =>
                {
                    try
                    {
                        string encodeJson = jsonFunc(this.instance.Titles);
                        if (encodeJson != null)
                        {
                            lock (this.encodeLock)
                            {
                                this.instance.StartEncode(encodeJson);
                                this.callback.OnEncodeStarted();
                                this.state = EncodeState.Encoding;
                            }
                        }
                        else
                        {
                            this.callback.OnEncodeComplete(error: true);
                            this.CleanUpAndSignalCompletion();
                        }
                    }
                    catch (Exception exception)
                    {
                        this.callback.OnException(exception.ToString());
                        this.CleanUpAndSignalCompletion();
                    }
                };

                this.instance.EncodeProgress += (o, e) =>
                {
                    this.StopOnException(() =>
                    {
                        this.callback.OnEncodeProgress((float)e.AverageFrameRate, (float)e.CurrentFrameRate, e.EstimatedTimeLeft, (float)e.FractionComplete, e.PassId, e.Pass, e.PassCount);
                    });
                };

                this.instance.EncodeCompleted += (o, e) =>
                {
                    this.state = EncodeState.Finished;

                    try
                    {
                        this.callback.OnEncodeComplete(e.Error);
                    }
                    catch (CommunicationException exception)
                    {
                        WorkerErrorLogger.LogError("Got exception when reporting completion: " + exception, isError: true);
                    }
                    finally
                    {
                        this.CleanUpAndSignalCompletion();
                    }
                };


                this.instance.StartScan(scanPath, this.passedPreviewCount, TimeSpan.FromSeconds(this.passedMinTitleDurationSeconds), titleNumber);
                this.state = EncodeState.Scanning;
            }
            catch (Exception exception)
            {
                this.callback.OnException(exception.ToString());
                throw;
            }
        }
        /// <summary>
        /// Starts an encode.
        /// </summary>
        /// <param name="scanPath">The path to scan.</param>
        /// <param name="titleNumber">The title number to scan.</param>
        /// <param name="jsonFunc">A function to pick the encode JSON given the scan.</param>
        private void StartEncodeInternal(string scanPath, int titleNumber, Func <JsonScanObject, string> jsonFunc)
        {
            try
            {
                this.Instance = new HandBrakeInstance();
                this.Instance.Initialize(this.PassedVerbosity, noHardware: false);

                this.Instance.ScanCompleted += (o, e) =>
                {
                    try
                    {
                        string encodeJson = jsonFunc(this.Instance.Titles);
                        if (encodeJson != null)
                        {
                            lock (this.encodeLock)
                            {
                                this.Instance.StartEncode(encodeJson);
                                this.MakeOneWayCallback(c => c.OnEncodeStarted());
                                this.state = EncodeState.Encoding;
                            }
                        }
                        else
                        {
                            this.MakeOneWayCallback(c => c.OnEncodeComplete(true));
                            this.CleanUpAndSignalCompletion();
                        }
                    }
                    catch (Exception exception)
                    {
                        this.MakeOneWayCallback(c => c.OnException(exception.ToString()));
                        this.CleanUpAndSignalCompletion();
                    }
                };

                this.Instance.EncodeProgress += (o, e) =>
                {
                    this.StopOnException(() =>
                    {
                        if (e.PassId > this.lastSetAffinityPassId && e.FractionComplete > 0)
                        {
                            this.ApplyCpuThrottling();
                            this.lastSetAffinityPassId = e.PassId;
                        }

                        this.MakeOneWayCallback(c => c.OnEncodeProgress(
                                                    (float)e.AverageFrameRate,
                                                    (float)e.CurrentFrameRate,
                                                    e.EstimatedTimeLeft,
                                                    (float)e.FractionComplete,
                                                    e.PassId,
                                                    e.Pass,
                                                    e.PassCount,
                                                    e.StateCode));

                        return(Task.CompletedTask);
                    });
                };

                this.Instance.EncodeCompleted += async(o, e) =>
                {
                    this.state = EncodeState.Finished;

                    try
                    {
                        await this.SendPendingLogMessagesAsync().ConfigureAwait(false);

                        await this.CallbackInvoker.InvokeAsync(c => c.OnEncodeComplete(e.Error)).ConfigureAwait(false);
                    }
                    catch (Exception exception)
                    {
                        WorkerErrorLogger.LogError("Got exception when reporting completion: " + exception, isError: true);
                    }
                    finally
                    {
                        this.CleanUpAndSignalCompletion();
                    }
                };


                this.Instance.StartScan(scanPath, this.PassedPreviewCount, TimeSpan.FromSeconds(this.PassedMinTitleDurationSeconds), titleNumber);
                this.state = EncodeState.Scanning;
            }
            catch (Exception exception)
            {
                this.MakeOneWayCallback(c => c.OnException(exception.ToString()));
                throw;
            }
        }
Exemple #8
0
        static async Task Main(string[] args)
        {
            try
            {
                ////Debugger.Launch();

                if (args.Length < 3)
                {
                    PrintUsage();
                    return;
                }

                int parentProcId;
                if (!int.TryParse(args[0], out parentProcId))
                {
                    PrintUsage();
                    return;
                }

                JsonSettings.SetDefaultSerializationSettings();

                PipeName = args[1];

                var action = (HandBrakeWorkerAction)Enum.Parse(typeof(HandBrakeWorkerAction), args[2]);

                parentCheckTimer           = new System.Timers.Timer();
                parentCheckTimer.Interval  = ParentCheckInterval;
                parentCheckTimer.AutoReset = true;
                parentCheckTimer.Elapsed  += (o, e) =>
                {
                    try
                    {
                        if (!ProcessExists(parentProcId))
                        {
                            if (action == HandBrakeWorkerAction.Encode && HandBrakeEncodeWorker.CurrentWorker != null && HandBrakeEncodeWorker.CurrentWorker.StopEncodeIfPossible())
                            {
                                // If we are able to stop the encode, we will do so. Cleanup should
                                // happen with the encode complete callback.
                                Console.WriteLine("Parent no longer exists, stopping encode.");
                            }
                        }
                    }
                    catch (Exception exception)
                    {
                        WorkerErrorLogger.LogError("Exception in parentCheckTimer. Elapsed: " + exception.ToString(), isError: true);
                        throw;
                    }
                };

                parentCheckTimer.Start();

                StartService(action);

                encodeComplete = new SemaphoreSlim(0, 1);
                await encodeComplete.WaitAsync().ConfigureAwait(false);
            }
            catch (Exception exception)
            {
                WorkerErrorLogger.LogError("Exception in Main: " + exception, isError: true);
                throw;
            }
        }
Exemple #9
0
        static void Main(string[] args)
        {
            try
            {
                if (args.Length < 2)
                {
                    PrintUsage();
                    return;
                }

                int parentProcId;
                if (!int.TryParse(args[0], out parentProcId))
                {
                    PrintUsage();
                    return;
                }

                JsonSettings.SetDefaultSerializationSettings();

                PipeName = args[1];

                parentCheckTimer           = new System.Timers.Timer();
                parentCheckTimer.Interval  = ParentCheckInterval;
                parentCheckTimer.AutoReset = true;
                parentCheckTimer.Elapsed  += (o, e) =>
                {
                    try
                    {
                        if (!ProcessExists(parentProcId))
                        {
                            // If we couldn't stop the process, just wait until next tick. May have not started yet or may
                            // already be in the process of closing.
                            if (HandBrakeWorker.CurrentWorker != null && HandBrakeWorker.CurrentWorker.StopEncodeIfPossible())
                            {
                                // If we are able to stop the encode, we will do so. Cleanup should
                                // happen with the encode complete callback.
                                Console.WriteLine("Parent no longer exists, stopping encode.");
                            }
                        }
                    }
                    catch (Exception exception)
                    {
                        WorkerErrorLogger.LogError("Exception in parentCheckTimer.Elapsed: " + exception.ToString(), isError: true);
                        throw;
                    }
                };

                parentCheckTimer.Start();

                ServiceHost host = null;
                try
                {
                    host = new ServiceHost(typeof(HandBrakeWorker));

                    host.AddServiceEndpoint(
                        typeof(IHandBrakeWorker),
                        new NetNamedPipeBinding(),
                        "net.pipe://localhost/" + PipeName);

                    host.Open();

                    encodeComplete = new ManualResetEventSlim(false);
                    Console.WriteLine("Service state is " + host.State + " on pipe " + PipeName);
                    encodeComplete.Wait();

                    host.Close();
                }
                catch (CommunicationException exception)
                {
                    WorkerErrorLogger.LogError("Exception when trying to establish pipe service: " + exception, isError: true);
                    if (host != null)
                    {
                        host.Abort();
                    }
                }
                catch (TimeoutException exception)
                {
                    WorkerErrorLogger.LogError("Exception when trying to establish pipe service: " + exception, isError: true);
                    if (host != null)
                    {
                        host.Abort();
                    }
                }
                catch (Exception)
                {
                    if (host != null)
                    {
                        host.Abort();
                    }

                    throw;
                }
            }
            catch (Exception exception)
            {
                WorkerErrorLogger.LogError("Exception in Main: " + exception, isError: true);
                throw;
            }
        }