/// <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>
/// 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>
/// 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
}
}