/// <summary> /// Initializes a new instance of the <see cref="QueueTask"/> class. /// </summary> /// <param name="task"> /// The task. /// </param> /// <param name="configuration"> /// The configuration. /// </param> /// <param name="scannedSourcePath"> /// The scanned Source Path. /// </param> public QueueTask(EncodeTask task, HBConfiguration configuration, string scannedSourcePath) { this.Task = task; this.Configuration = configuration; this.Status = QueueItemStatus.Waiting; this.ScannedSourcePath = scannedSourcePath; }
/// <summary> /// Generate a Query for a Preview Encode /// </summary> /// <param name="task"> /// The task. /// </param> /// <param name="configuration"> /// The configuration. /// </param> /// <param name="duration"> /// The duration. /// </param> /// <param name="startAtPreview"> /// The start At Preview. /// </param> /// <returns> /// A Cli query suitable for generating a preview video. /// </returns> public static string GeneratePreviewQuery(EncodeTask task, HBConfiguration configuration, int duration, string startAtPreview) { string query = string.Empty; query += SourceQuery(task, duration, startAtPreview, configuration.PreviewScanCount); query += DestinationQuery(task); query += GenerateTabbedComponentsQuery(task, true, configuration.Verbosity, configuration.IsDvdNavDisabled, configuration.DisableQuickSyncDecoding, false, false); return query; }
/// <summary> /// The export preset. /// </summary> /// <param name="export"> /// The export. /// </param> /// <param name="config"> /// HandBrakes configuration options. /// </param> /// <returns> /// The <see cref="Preset"/>. /// </returns> public static PresetTransportContainer ExportPreset(Preset export, HBConfiguration config) { PresetTransportContainer container = new PresetTransportContainer(); container.VersionMajor = "0"; container.VersionMinor = "10"; container.VersionMicro = "2"; container.PresetList = new List<HBPreset> { CreateHbPreset(export, config) }; return container; }
/// <summary> /// Generate a CLI Query for an EncodeTask Model object /// </summary> /// <param name="task"> /// The task. /// </param> /// <param name="configuration"> /// The configuration. /// </param> /// <returns> /// A Cli Query /// </returns> public static string GenerateQuery(EncodeTask task, HBConfiguration configuration) { if (string.IsNullOrEmpty(task.Source)) { return "No source selected"; } string query = string.Empty; query += SourceQuery(task, null, null, configuration.PreviewScanCount); query += DestinationQuery(task); query += GenerateTabbedComponentsQuery(task, true, configuration.Verbosity, configuration.IsDvdNavDisabled, configuration.DisableQuickSyncDecoding, configuration.EnableDxva, configuration.ScalingMode == VideoScaler.BicubicCl); return query; }
/// <summary> /// For a givent set of tasks, return the Queue JSON that can be used for the CLI. /// </summary> /// <param name="tasks"> /// The tasks. /// </param> /// <param name="configuration"> /// The configuration. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> public static string GetQueueJson(List<EncodeTask> tasks, HBConfiguration configuration) { JsonSerializerSettings settings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, }; List<Task> queueJobs = new List<Task>(); foreach (var item in tasks) { Task task = new Task { Job = EncodeFactory.Create(item, configuration) }; queueJobs.Add(task); } return JsonConvert.SerializeObject(queueJobs, Formatting.Indented, settings); }
/// <summary> /// Start with a LibHb EncodeJob Object /// </summary> /// <param name="task"> /// The task. /// </param> /// <param name="configuration"> /// The configuration. /// </param> public void Start(EncodeTask task, HBConfiguration configuration) { try { // Sanity Checking and Setup if (this.IsEncoding) { throw new GeneralApplicationException("HandBrake is already encoding a file.", "Please stop the current encode. If the problem persists, please restart HandBrake.", null); } // Setup this.startTime = DateTime.Now; this.currentTask = task; this.currentConfiguration = configuration; // Create a new HandBrake instance // Setup the HandBrake Instance HandBrakeUtils.MessageLogged += this.HandBrakeInstanceMessageLogged; HandBrakeUtils.ErrorLogged += this.HandBrakeInstanceErrorLogged; this.instance = task.IsPreviewEncode ? HandBrakeInstanceManager.GetPreviewInstance(configuration.Verbosity) : HandBrakeInstanceManager.GetEncodeInstance(configuration.Verbosity); this.instance.EncodeCompleted += this.InstanceEncodeCompleted; this.instance.EncodeProgress += this.InstanceEncodeProgress; this.IsEncoding = true; this.isPreviewInstance = task.IsPreviewEncode; this.SetupLogging(task.IsPreviewEncode); // Verify the Destination Path Exists, and if not, create it. this.VerifyEncodeDestinationPath(task); this.ServiceLogMessage("Starting Encode ..."); // Get an EncodeJob object for the Interop Library this.instance.StartEncode(EncodeFactory.Create(task, configuration)); // Fire the Encode Started Event this.InvokeEncodeStarted(System.EventArgs.Empty); } catch (Exception exc) { this.IsEncoding = false; this.ServiceLogMessage("Failed to start encoding ..." + Environment.NewLine + exc); this.InvokeEncodeCompleted(new HandBrakeWPF.Services.Encode.EventArgs.EncodeCompletedEventArgs(false, exc, "Unable to start encoding", task.Source)); } }
/// <summary> /// The create. /// </summary> /// <returns> /// The <see cref="HBConfiguration"/>. /// </returns> public static HBConfiguration Create() { HBConfiguration config = new HBConfiguration { IsDvdNavDisabled = UserSettingService.GetUserSetting<bool>(UserSettingConstants.DisableLibDvdNav), DisableQuickSyncDecoding = UserSettingService.GetUserSetting<bool>(UserSettingConstants.DisableQuickSyncDecoding), ScalingMode = UserSettingService.GetUserSetting<VideoScaler>(UserSettingConstants.ScalingMode), PreviewScanCount = UserSettingService.GetUserSetting<int>(UserSettingConstants.PreviewScanCount), Verbosity = UserSettingService.GetUserSetting<int>(UserSettingConstants.Verbosity), MinScanDuration = UserSettingService.GetUserSetting<int>(UserSettingConstants.MinScanDuration), SaveLogToCopyDirectory = UserSettingService.GetUserSetting<bool>(UserSettingConstants.SaveLogToCopyDirectory), SaveLogWithVideo = UserSettingService.GetUserSetting<bool>(UserSettingConstants.SaveLogWithVideo), SaveLogCopyDirectory = UserSettingService.GetUserSetting<string>(UserSettingConstants.SaveLogCopyDirectory), }; return config; }
/// <summary> /// The create. /// </summary> /// <param name="job"> /// The encode job. /// </param> /// <param name="configuration"> /// The configuration. /// </param> /// <returns> /// The <see cref="JsonEncodeObject"/>. /// </returns> internal static JsonEncodeObject Create(EncodeTask job, HBConfiguration configuration) { JsonEncodeObject encode = new JsonEncodeObject { SequenceID = 0, Audio = CreateAudio(job), Destination = CreateDestination(job), Filters = CreateFilters(job), PAR = CreatePAR(job), Metadata = CreateMetadata(job), Source = CreateSource(job, configuration), Subtitle = CreateSubtitle(job), Video = CreateVideo(job, configuration) }; return encode; }
/// <summary> /// The create hb preset. /// </summary> /// <param name="export"> /// The export. /// </param> /// <param name="config">HandBrakes current configuration</param> /// <returns> /// The <see cref="HBPreset"/>. /// </returns> public static HBPreset CreateHbPreset(Preset export, HBConfiguration config) { HBPreset preset = new HBPreset(); // Preset preset.PresetDescription = export.Description; preset.PresetName = export.Name; preset.Type = export.IsBuildIn ? 0 : 1; preset.UsesPictureSettings = (int)export.PictureSettingsMode; preset.Default = export.IsDefault; // Audio preset.AudioCopyMask = export.Task.AllowedPassthruOptions.AllowedPassthruOptions.Select(EnumHelper<AudioEncoder>.GetShortName).ToList(); preset.AudioEncoderFallback = EnumHelper<AudioEncoder>.GetShortName(export.Task.AllowedPassthruOptions.AudioEncoderFallback); preset.AudioLanguageList = LanguageUtilities.GetLanguageCodes(export.AudioTrackBehaviours.SelectedLangauges); preset.AudioTrackSelectionBehavior = EnumHelper<AudioBehaviourModes>.GetShortName(export.AudioTrackBehaviours.SelectedBehaviour); preset.AudioSecondaryEncoderMode = export.AudioTrackBehaviours.SelectedTrackDefaultBehaviour == AudioTrackDefaultsMode.FirstTrack; // TODO -> We don't support AllTracks yet in other GUIs. preset.AudioList = new List<AudioList>(); foreach (var item in export.Task.AudioTracks) { AudioList track = new AudioList { AudioBitrate = item.Bitrate, AudioCompressionLevel = 0, // TODO AudioDitherMethod = null, // TODO AudioEncoder = EnumHelper<AudioEncoder>.GetShortName(item.Encoder), AudioMixdown = EnumHelper<Mixdown>.GetShortName(item.MixDown), AudioNormalizeMixLevel = false, // TODO AudioSamplerate = item.SampleRate == 0 ? "auto" : item.SampleRate.ToString(), // TODO check formatting. AudioTrackDRCSlider = item.DRC, AudioTrackGainSlider = item.Gain, AudioTrackQuality = item.Quality ?? 0, AudioTrackQualityEnable = item.Quality.HasValue && item.IsQualityVisible }; preset.AudioList.Add(track); } // Subtitles preset.SubtitleAddCC = export.SubtitleTrackBehaviours.AddClosedCaptions; preset.SubtitleAddForeignAudioSearch = export.SubtitleTrackBehaviours.AddForeignAudioScanTrack; preset.SubtitleBurnBDSub = false; // TODO not supported yet. preset.SubtitleBurnDVDSub = false; // TODO not supported yet. preset.SubtitleBurnBehavior = EnumHelper<SubtitleBurnInBehaviourModes>.GetShortName(export.SubtitleTrackBehaviours.SelectedBurnInBehaviour); preset.SubtitleLanguageList = LanguageUtilities.GetLanguageCodes(export.SubtitleTrackBehaviours.SelectedLangauges); preset.SubtitleTrackSelectionBehavior = EnumHelper<SubtitleBehaviourModes>.GetShortName(export.SubtitleTrackBehaviours.SelectedBehaviour); // Chapters preset.ChapterMarkers = export.Task.IncludeChapterMarkers; // Output Settings preset.FileFormat = EnumHelper<OutputFormat>.GetShortName(export.Task.OutputFormat); preset.Mp4HttpOptimize = export.Task.OptimizeMP4; preset.Mp4iPodCompatible = export.Task.IPod5GSupport; // Picture Settings preset.PictureForceHeight = 0; // TODO preset.PictureForceWidth = 0; // TODO preset.PictureHeight = preset.UsesPictureSettings >= 1 ? export.Task.MaxHeight : 0; // TODO; // TODO preset.PictureItuPAR = false; // TODO Not supported Yet preset.PictureKeepRatio = export.Task.KeepDisplayAspect; preset.PictureLeftCrop = export.Task.Cropping.Left; preset.PictureLooseCrop = false; // TODO Not Supported Yet preset.PictureModulus = export.Task.Modulus ?? 16; preset.PicturePAR = EnumHelper<Anamorphic>.GetShortName(export.Task.Anamorphic); preset.PicturePARHeight = export.Task.PixelAspectY; preset.PicturePARWidth = export.Task.PixelAspectX; preset.PictureRightCrop = export.Task.Cropping.Right; preset.PictureRotate = string.Format("{0}:{1}", export.Task.Rotation, export.Task.FlipVideo ? "1" : "0"); preset.PictureTopCrop = export.Task.Cropping.Top; preset.PictureWidth = preset.UsesPictureSettings >= 1 ? export.Task.MaxWidth : 0; // TODO preset.PictureDARWidth = export.Task.DisplayWidth.HasValue ? (int)export.Task.DisplayWidth.Value : 0; preset.PictureAutoCrop = !export.Task.HasCropping; preset.PictureBottomCrop = export.Task.Cropping.Bottom; // Filters preset.PictureDeblock = export.Task.Deblock; preset.PictureDeinterlaceFilter = export.Task.DeinterlaceFilter == DeinterlaceFilter.Decomb ? "decomb" : export.Task.DeinterlaceFilter == DeinterlaceFilter.Deinterlace ? "deinterlace" : "off"; preset.PictureDeinterlacePreset = export.Task.DeinterlaceFilter == DeinterlaceFilter.Decomb ? EnumHelper<Decomb>.GetShortName(export.Task.Decomb) : export.Task.DeinterlaceFilter == DeinterlaceFilter.Deinterlace ? EnumHelper<Deinterlace>.GetShortName(export.Task.Deinterlace) : string.Empty; preset.PictureDeinterlaceCustom = export.Task.DeinterlaceFilter == DeinterlaceFilter.Decomb ? export.Task.CustomDecomb : export.Task.DeinterlaceFilter == DeinterlaceFilter.Deinterlace ? export.Task.CustomDeinterlace : string.Empty; preset.PictureDeinterlaceCustom = export.Task.CustomDeinterlace; preset.PictureDenoiseCustom = export.Task.CustomDenoise; preset.PictureDenoiseFilter = EnumHelper<Denoise>.GetShortName(export.Task.Denoise); preset.PictureDenoisePreset = EnumHelper<DenoisePreset>.GetShortName(export.Task.DenoisePreset); preset.PictureDenoiseTune = EnumHelper<DenoiseTune>.GetShortName(export.Task.DenoiseTune); preset.PictureDetelecine = EnumHelper<Detelecine>.GetShortName(export.Task.Detelecine); preset.PictureDetelecineCustom = export.Task.CustomDetelecine; // Video preset.VideoEncoder = EnumHelper<VideoEncoder>.GetShortName(export.Task.VideoEncoder); preset.VideoFramerate = export.Task.Framerate.ToString(); preset.VideoFramerateMode = EnumHelper<FramerateMode>.GetShortName(export.Task.FramerateMode); preset.VideoGrayScale = export.Task.Grayscale; preset.VideoHWDecode = false; preset.VideoLevel = export.Task.VideoLevel.ShortName; preset.VideoOptionExtra = export.Task.ExtraAdvancedArguments; preset.VideoPreset = export.Task.VideoPreset.ShortName; preset.VideoProfile = export.Task.VideoProfile.ShortName; preset.VideoQSVAsyncDepth = 4; // Defaulted to 4 for now. preset.VideoQSVDecode = !config.DisableQuickSyncDecoding; preset.VideoQualitySlider = export.Task.Quality.HasValue ? export.Task.Quality.Value : 0; preset.VideoQualityType = (int)export.Task.VideoEncodeRateType; preset.VideoScaler = EnumHelper<VideoScaler>.GetShortName(config.ScalingMode); preset.VideoTune = export.Task.VideoTunes.Aggregate(string.Empty, (current, item) => !string.IsNullOrEmpty(current) ? string.Format("{0}, {1}", current, item.ShortName) : item.ShortName); preset.VideoAvgBitrate = export.Task.VideoBitrate ?? 0; preset.VideoColorMatrixCode = 0; // TODO not supported. preset.VideoTurboTwoPass = export.Task.TurboFirstPass; preset.VideoTwoPass = export.Task.TwoPass; // Advanced preset.x264Option = export.Task.AdvancedEncoderOptions; preset.x264UseAdvancedOptions = export.Task.ShowAdvancedTab; // Unknown preset.ChildrenArray = new List<object>(); // We don't support nested presets. preset.Folder = false; // TODO preset.FolderOpen = false; // TODO return preset; }
/// <summary> /// Export a list of Presets. /// </summary> /// <param name="exportList">A list of presets to export</param> /// <param name="config">HB's configuration</param> /// <returns>A list of JSON object presets.</returns> public static PresetTransportContainer ExportPresets(IEnumerable<Preset> exportList, HBConfiguration config) { PresetTransportContainer container = new PresetTransportContainer(); container.VersionMajor = Constants.PresetVersionMajor; container.VersionMinor = Constants.PresetVersionMinor; container.VersionMicro = Constants.PresetVersionMicro; List<HBPreset> presets = exportList.Select(item => CreateHbPreset(item, config)).ToList(); container.PresetList = new List<object>(); container.PresetList.AddRange(presets); return container; }
/// <summary> /// The export preset. /// </summary> /// <param name="export"> /// The export. /// </param> /// <param name="config"> /// HandBrakes configuration options. /// </param> /// <returns> /// The <see cref="Preset"/>. /// </returns> public static PresetTransportContainer ExportPreset(Preset export, HBConfiguration config) { PresetTransportContainer container = new PresetTransportContainer(); container.VersionMajor = Constants.PresetVersionMajor; container.VersionMinor = Constants.PresetVersionMinor; container.VersionMicro = Constants.PresetVersionMicro; container.PresetList = new List<object> { CreateHbPreset(export, config) }; return container; }
/// <summary> /// Initializes a new instance of the <see cref="QueueTask"/> class. /// </summary> /// <param name="task"> /// The task. /// </param> /// <param name="configuration"> /// The configuration. /// </param> public QueueTask(EncodeTask task, HBConfiguration configuration) { this.Task = task; this.Configuration = configuration; this.Status = QueueItemStatus.Waiting; }
/// <summary> /// The export. /// </summary> /// <param name="filename"> /// The filename. /// </param> /// <param name="preset"> /// The preset. /// </param> /// <param name="configuration"> /// The configuration. /// </param> public void Export(string filename, Preset preset, HBConfiguration configuration) { // TODO Add support for multiple export PresetTransportContainer container = JsonPresetFactory.ExportPreset(preset, configuration); HandBrakePresetService.ExportPreset(filename, container); }
/// <summary> /// Start a scan for a given source path and title /// </summary> /// <param name="sourcePath"> /// Path to the source file /// </param> /// <param name="title"> /// the title number to look at /// </param> /// <param name="previewCount"> /// The preview Count. /// </param> /// <param name="configuraiton"> /// The configuraiton. /// </param> private void ScanSource(object sourcePath, int title, int previewCount, HBConfiguration configuraiton) { try { this.logging.Clear(); string source = sourcePath.ToString().EndsWith("\\") ? string.Format("\"{0}\\\\\"", sourcePath.ToString().TrimEnd('\\')) : "\"" + sourcePath + "\""; this.currentSourceScanPath = source; this.IsScanning = true; TimeSpan minDuration = TimeSpan.FromSeconds(configuraiton.MinScanDuration); HandBrakeUtils.SetDvdNav(!configuraiton.IsDvdNavDisabled); this.ServiceLogMessage("Starting Scan ..."); this.instance.StartScan(sourcePath.ToString(), previewCount, minDuration, title != 0 ? title : 0); if (this.ScanStarted != null) this.ScanStarted(this, System.EventArgs.Empty); } catch (Exception exc) { this.ServiceLogMessage("Scan Failed ..." + Environment.NewLine + exc); this.Stop(); if (this.ScanCompleted != null) this.ScanCompleted(this, new ScanCompletedEventArgs(false, exc, "An Error has occured in ScanService.ScanSource()", null)); } }
/// <summary> /// Get a Preview image for the current job and preview number. /// </summary> /// <param name="job"> /// The job. /// </param> /// <param name="preview"> /// The preview. /// </param> /// <param name="configuraiton"> /// The configuraiton. /// </param> /// <returns> /// The <see cref="BitmapImage"/>. /// </returns> public BitmapImage GetPreview(EncodeTask job, int preview, HBConfiguration configuraiton) { if (this.instance == null) { return null; } BitmapImage bitmapImage = null; try { PreviewSettings settings = new PreviewSettings(job); bitmapImage = this.instance.GetPreview(settings, preview); } catch (AccessViolationException e) { Console.WriteLine(e); } return bitmapImage; }
/// <summary> /// Get a Preview image for the current job and preview number. /// </summary> /// <param name="job"> /// The job. /// </param> /// <param name="preview"> /// The preview. /// </param> /// <param name="configuraiton"> /// The configuraiton. /// </param> /// <returns> /// The <see cref="BitmapImage"/>. /// </returns> public BitmapImage GetPreview(EncodeTask job, int preview, HBConfiguration configuraiton) { if (this.instance == null) { return null; } BitmapImage bitmapImage = null; try { PreviewSettings settings = new PreviewSettings { Cropping = new Cropping(job.Cropping), MaxWidth = job.MaxWidth ?? 0, MaxHeight = job.MaxHeight ?? 0, KeepDisplayAspect = job.KeepDisplayAspect, TitleNumber = job.Title, Anamorphic = job.Anamorphic, Modulus = job.Modulus, Width = job.Width ?? 0, Height = job.Height ?? 0, PixelAspectX = job.PixelAspectX, PixelAspectY = job.PixelAspectY }; bitmapImage = this.instance.GetPreview(settings, preview); } catch (AccessViolationException e) { Console.WriteLine(e); } return bitmapImage; }
/// <summary> /// Start with a LibHb EncodeJob Object /// </summary> /// <param name="task"> /// The task. /// </param> /// <param name="configuration"> /// The configuration. /// </param> public void Start(EncodeTask task, HBConfiguration configuration) { try { // Setup this.startTime = DateTime.Now; this.currentTask = task; this.currentConfiguration = configuration; // Create a new HandBrake instance // Setup the HandBrake Instance HandBrakeUtils.MessageLogged += this.HandBrakeInstanceMessageLogged; HandBrakeUtils.ErrorLogged += this.HandBrakeInstanceErrorLogged; this.instance = HandBrakeInstanceManager.GetEncodeInstance(configuration.Verbosity); this.instance.EncodeCompleted += this.InstanceEncodeCompleted; this.instance.EncodeProgress += this.InstanceEncodeProgress; // Sanity Checking and Setup if (this.IsEncoding) { throw new Exception("HandBrake is already encoding."); } this.IsEncoding = true; this.SetupLogging(); // Verify the Destination Path Exists, and if not, create it. this.VerifyEncodeDestinationPath(task); ServiceLogMessage("Starting Encode ..."); // Get an EncodeJob object for the Interop Library instance.StartEncode(EncodeFactory.Create(task, configuration)); // Fire the Encode Started Event this.InvokeEncodeStarted(System.EventArgs.Empty); // Set the Process Priority switch (configuration.ProcessPriority) { case "Realtime": Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.RealTime; break; case "High": Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High; break; case "Above Normal": Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.AboveNormal; break; case "Normal": Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.Normal; break; case "Low": Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.Idle; break; default: Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.BelowNormal; break; } } catch (Exception exc) { this.IsEncoding = false; ServiceLogMessage("Failed to start encoding ..." + Environment.NewLine + exc); this.InvokeEncodeCompleted(new EventArgs.EncodeCompletedEventArgs(false, exc, "Unable to start encoding", task.Source)); } }
/// <summary> /// Scan a Source Path. /// Title 0: scan all /// </summary> /// <param name="sourcePath"> /// Path to the file to scan /// </param> /// <param name="title"> /// int title number. 0 for scan all /// </param> /// <param name="postAction"> /// The post Action. /// </param> /// <param name="configuraiton"> /// The configuraiton. /// </param> public void Scan(string sourcePath, int title, Action<bool> postAction, HBConfiguration configuraiton) { // Try to cleanup any previous scan instances. if (instance != null) { try { this.scanLog.Close(); this.scanLog.Dispose(); instance.Dispose(); } catch (Exception) { // Do Nothing } } // Clear down the logging this.logging.Clear(); try { // Make we don't pick up a stale last_scan_log_xyz.txt (and that we have rights to the file) if (File.Exists(dvdInfoPath)) { File.Delete(dvdInfoPath); } } catch (Exception) { // Do nothing. } if (!Directory.Exists(Path.GetDirectoryName(dvdInfoPath))) { Directory.CreateDirectory(Path.GetDirectoryName(dvdInfoPath)); } // Create a new scan log. scanLog = new StreamWriter(dvdInfoPath); // Create a new HandBrake Instance. instance = new HandBrakeInstance(); instance.Initialize(1); instance.ScanProgress += this.InstanceScanProgress; instance.ScanCompleted += this.InstanceScanCompleted; // Start the scan on a back this.ScanSource(sourcePath, title, configuraiton.PreviewScanCount, configuraiton); }
/// <summary> /// Copy the log file to the desired destinations /// </summary> /// <param name="destination"> /// The destination. /// </param> /// <param name="configuration"> /// The configuration. /// </param> public void ProcessLogs(string destination, HBConfiguration configuration) { this.encodeService.ProcessLogs(destination, configuration); }
/// <summary> /// Scan a Source Path. /// Title 0: scan all /// </summary> /// <param name="sourcePath"> /// Path to the file to scan /// </param> /// <param name="title"> /// int title number. 0 for scan all /// </param> /// <param name="postAction"> /// The post Action. /// </param> /// <param name="configuraiton"> /// The configuraiton. /// </param> public void Scan(string sourcePath, int title, Action<bool, Source> postAction, HBConfiguration configuraiton) { // Try to cleanup any previous scan instances. if (this.instance != null) { try { this.instance.Dispose(); } catch (Exception) { // Do Nothing } } // Handle the post scan operation. this.postScanOperation = postAction; // Create a new HandBrake Instance. this.instance = HandBrakeInstanceManager.GetScanInstance(configuraiton.Verbosity); this.instance.ScanProgress += this.InstanceScanProgress; this.instance.ScanCompleted += this.InstanceScanCompleted; // Start the scan on a back this.ScanSource(sourcePath, title, configuraiton.PreviewScanCount, configuraiton); }
/// <summary> /// The create source. /// </summary> /// <param name="job"> /// The job. /// </param> /// <param name="configuration"> /// The configuration. /// </param> /// <returns> /// The <see cref="Source"/>. /// </returns> private static Source CreateSource(EncodeTask job, HBConfiguration configuration) { Range range = new Range(); switch (job.PointToPointMode) { case PointToPointMode.Chapters: range.Type = "chapter"; range.Start = job.StartPoint; range.End = job.EndPoint; break; case PointToPointMode.Seconds: range.Type = "time"; range.Start = job.StartPoint * 90000; range.End = (job.EndPoint - job.StartPoint) * 90000; break; case PointToPointMode.Frames: range.Type = "frame"; range.Start = job.StartPoint; range.End = job.EndPoint; break; case PointToPointMode.Preview: range.Type = "preview"; range.Start = job.PreviewEncodeStartAt; range.SeekPoints = configuration.PreviewScanCount; range.End = job.PreviewEncodeDuration * 90000; break; } Source source = new Source { Title = job.Title, Range = range, Angle = job.Angle, Path = job.Source, }; return source; }
/// <summary> /// Scan a Source Path. /// Title 0: scan all /// </summary> /// <param name="sourcePath"> /// Path to the file to scan /// </param> /// <param name="title"> /// int title number. 0 for scan all /// </param> /// <param name="postAction"> /// The post Action. /// </param> /// <param name="configuraiton"> /// The configuraiton. /// </param> public void Scan(string sourcePath, int title, Action<bool, Source> postAction, HBConfiguration configuraiton) { // Try to cleanup any previous scan instances. if (this.instance != null) { try { lock (LogLock) { this.scanLog.Close(); this.scanLog.Dispose(); this.scanLog = null; } this.instance.Dispose(); } catch (Exception) { // Do Nothing } } // Handle the post scan operation. this.postScanOperation = postAction; // Clear down the logging this.logging.Clear(); try { // Make we don't pick up a stale last_scan_log_xyz.txt (and that we have rights to the file) if (File.Exists(this.dvdInfoPath)) { File.Delete(this.dvdInfoPath); } } catch (Exception exc) { Debug.WriteLine(exc); } if (!Directory.Exists(Path.GetDirectoryName(this.dvdInfoPath))) { Directory.CreateDirectory(Path.GetDirectoryName(this.dvdInfoPath)); } // Create a new scan log. this.scanLog = new StreamWriter(this.dvdInfoPath); // Create a new HandBrake Instance. HandBrakeUtils.MessageLogged += this.HandBrakeInstanceMessageLogged; HandBrakeUtils.ErrorLogged += this.HandBrakeInstanceErrorLogged; this.instance = HandBrakeInstanceManager.GetScanInstance(configuraiton.Verbosity); this.instance.ScanProgress += this.InstanceScanProgress; this.instance.ScanCompleted += this.InstanceScanCompleted; // Start the scan on a back this.ScanSource(sourcePath, title, configuraiton.PreviewScanCount, configuraiton); }
/// <summary> /// The create video. /// </summary> /// <param name="job"> /// The job. /// </param> /// <param name="configuration"> /// The configuration. /// </param> /// <returns> /// The <see cref="Video"/>. /// </returns> private static Video CreateVideo(EncodeTask job, HBConfiguration configuration) { Video video = new Video(); HBVideoEncoder videoEncoder = HandBrakeEncoderHelpers.VideoEncoders.FirstOrDefault(e => e.ShortName == EnumHelper<VideoEncoder>.GetShortName(job.VideoEncoder)); Validate.NotNull(videoEncoder, "Video encoder " + job.VideoEncoder + " not recognized."); if (videoEncoder != null) { video.Encoder = videoEncoder.Id; } string advancedOptions = job.ShowAdvancedTab ? job.AdvancedEncoderOptions : string.Empty; if (!string.IsNullOrEmpty(advancedOptions)) { video.Options = advancedOptions; } else { video.Level = job.VideoLevel != null ? job.VideoLevel.ShortName : null; video.Options = job.ExtraAdvancedArguments; video.Preset = job.VideoPreset != null ? job.VideoPreset.ShortName : null; video.Profile = job.VideoProfile != null ? job.VideoProfile.ShortName : null; if (job.VideoTunes != null && job.VideoTunes.Count > 0) { foreach (var item in job.VideoTunes) { video.Tune += string.IsNullOrEmpty(video.Tune) ? item.ShortName : "," + item.ShortName; } } } if (job.VideoEncodeRateType == VideoEncodeRateType.ConstantQuality) video.Quality = job.Quality; if (job.VideoEncodeRateType == VideoEncodeRateType.AverageBitrate) { video.Bitrate = job.VideoBitrate; video.TwoPass = job.TwoPass; video.Turbo = job.TurboFirstPass; } video.OpenCL = configuration.ScalingMode == VideoScaler.BicubicCl; video.QSV.Decode = SystemInfo.IsQsvAvailable && !configuration.DisableQuickSyncDecoding; return video; }
/// <summary> /// Copy the log file to the desired destinations /// </summary> /// <param name="destination"> /// The destination. /// </param> /// <param name="configuration"> /// The configuration. /// </param> public void ProcessLogs(string destination, HBConfiguration configuration) { ThreadPool.QueueUserWorkItem(delegate { this.Service.ProcessEncodeLogs(destination, configuration); }); }
/// <summary> /// Save a copy of the log to the users desired location or a default location /// if this feature is enabled in options. /// </summary> /// <param name="destination"> /// The Destination File Path /// </param> /// <param name="configuration"> /// The configuration. /// </param> public void ProcessLogs(string destination, HBConfiguration configuration) { try { string logDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\HandBrake\\logs"; string tempLogFile = Path.Combine(logDir, string.Format("last_encode_log{0}.txt", GeneralUtilities.ProcessId)); string encodeDestinationPath = Path.GetDirectoryName(destination); string destinationFile = Path.GetFileName(destination); string encodeLogFile = destinationFile + " " + DateTime.Now.ToString().Replace("/", "-").Replace(":", "-") + ".txt"; // Make sure the log directory exists. if (!Directory.Exists(logDir)) { Directory.CreateDirectory(logDir); } // Copy the Log to HandBrakes log folder in the users applciation data folder. File.Copy(tempLogFile, Path.Combine(logDir, encodeLogFile)); // Save a copy of the log file in the same location as the enocde. if (configuration.SaveLogWithVideo) { File.Copy(tempLogFile, Path.Combine(encodeDestinationPath, encodeLogFile)); } // Save a copy of the log file to a user specified location if (Directory.Exists(configuration.SaveLogCopyDirectory) && configuration.SaveLogToCopyDirectory) { File.Copy( tempLogFile, Path.Combine(configuration.SaveLogCopyDirectory, encodeLogFile)); } } catch (Exception exc) { Debug.WriteLine(exc); // This exception doesn't warrent user interaction, but it should be logged } }
/// <summary> /// Save a copy of the log to the users desired location or a default location /// if this feature is enabled in options. /// </summary> /// <param name="destination"> /// The Destination File Path /// </param> /// <param name="isPreview"> /// The is Preview. /// </param> /// <param name="configuration"> /// The configuration. /// </param> public void ProcessLogs(string destination, bool isPreview, HBConfiguration configuration) { try { string logDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\HandBrake\\logs"; string encodeDestinationPath = Path.GetDirectoryName(destination); string destinationFile = Path.GetFileName(destination); string encodeLogFile = destinationFile + " " + DateTime.Now.ToString(CultureInfo.InvariantCulture).Replace("/", "-").Replace(":", "-") + ".txt"; ILog log = LogService.GetLogger(); string logContent = log.ActivityLog; // Make sure the log directory exists. if (!Directory.Exists(logDir)) { Directory.CreateDirectory(logDir); } // Copy the Log to HandBrakes log folder in the users applciation data folder. this.WriteFile(logContent, Path.Combine(logDir, encodeLogFile)); // Save a copy of the log file in the same location as the enocde. if (configuration.SaveLogWithVideo) { this.WriteFile(logContent, Path.Combine(encodeDestinationPath, encodeLogFile)); } // Save a copy of the log file to a user specified location if (Directory.Exists(configuration.SaveLogCopyDirectory) && configuration.SaveLogToCopyDirectory) { this.WriteFile(logContent, Path.Combine(configuration.SaveLogCopyDirectory, encodeLogFile)); } } catch (Exception exc) { Debug.WriteLine(exc); // This exception doesn't warrent user interaction, but it should be logged } }