private void HandlePresetListsForSave(List <Preset> processList, Dictionary <string, HBPresetCategory> presetCategories, List <HBPreset> uncategorisedPresets)
{
foreach (Preset item in processList)
{
if (string.IsNullOrEmpty(item.Category))
{
uncategorisedPresets.Add(JsonPresetFactory.CreateHbPreset(item, HBConfigurationFactory.Create()));
}
else
{
HBPreset preset = JsonPresetFactory.CreateHbPreset(item, HBConfigurationFactory.Create());
if (presetCategories.ContainsKey(item.Category))
{
presetCategories[item.Category].ChildrenArray.Add(preset);
}
else
{
presetCategories[item.Category] = new HBPresetCategory
{
ChildrenArray = new List <HBPreset> {
preset
},
Folder = true,
PresetName = item.Category,
Type = item.IsBuildIn ? 0 : 1
};
}
}
}
}
private Preset ConvertHbPreset(HBPreset hbPreset)
{
Preset preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = UserPresetCatgoryName; // TODO can we get this from the preset?
return(preset);
}
private Preset ConvertHbPreset(HBPreset hbPreset, string categoryName)
{
Preset preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = !string.IsNullOrEmpty(categoryName) ? categoryName : UserPresetCategoryName;
return(preset);
}
private void ProcessPresetList(PresetTransportContainer container, bool ignoreOldBuiltIn)
{
// The presets file loaded was OK, so process it.
foreach (var item in container.PresetList)
{
object deserialisedItem = JsonConvert.DeserializeObject <PresetCategory>(item.ToString());
// Handle Categorised Presets.
PresetCategory category = deserialisedItem as PresetCategory;
if (category != null && category.Folder)
{
foreach (HBPreset hbpreset in category.ChildrenArray)
{
Preset preset = JsonPresetFactory.ImportPreset(hbpreset);
if (preset.IsBuildIn && ignoreOldBuiltIn)
{
continue;
}
// Migration
preset.Category = category.PresetName == "User Presets" ? UserPresetCatgoryName : category.PresetName;
preset.IsBuildIn = hbpreset.Type == 0;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
this.Add(preset, true);
}
}
// Uncategorised Presets
deserialisedItem = JsonConvert.DeserializeObject <HBPreset>(item.ToString());
HBPreset hbPreset = deserialisedItem as HBPreset;
if (hbPreset != null && !hbPreset.Folder)
{
Preset preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = UserPresetCatgoryName;
preset.IsBuildIn = hbPreset.Type == 1;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
this.Add(preset, true);
}
}
}
/// <summary>
/// The import.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
public void Import(string filename)
{
if (!string.IsNullOrEmpty(filename))
{
PresetTransportContainer container = null;
try
{
container = HandBrakePresetService.GetPresetFromFile(filename);
}
catch (Exception exc)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, exc);
return;
}
if (container?.PresetList == null || container.PresetList.Count == 0)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, Resources.NoAdditionalInformation);
return;
}
// HBPreset Handling
if (container.PresetList != null)
{
foreach (var objectPreset in container.PresetList)
{
PresetCategory category = JsonConvert.DeserializeObject <PresetCategory>(objectPreset.ToString());
if (category != null && category.ChildrenArray != null && category.ChildrenArray.Count > 0)
{
foreach (HBPreset hbPreset in category.ChildrenArray)
{
Preset preset = this.ConvertHbPreset(hbPreset);
if (preset != null)
{
this.AddOrUpdateImportedPreset(preset);
}
}
}
else
{
HBPreset hbPreset = JsonConvert.DeserializeObject <HBPreset>(objectPreset.ToString());
if (hbPreset != null)
{
Preset preset = this.ConvertHbPreset(hbPreset);
if (preset != null)
{
this.AddOrUpdateImportedPreset(preset);
}
}
}
}
}
}
}
private Preset ConvertHbPreset(HBPreset hbPreset)
{
Preset preset = null;
preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = UserPresetCatgoryName; // TODO can we get this from the preset?
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
return(preset);
}
private void ProcessPresetList(PresetTransportContainer container)
{
// The presets file loaded was OK, so process it.
foreach (var item in container.PresetList)
{
object deserializedItem = JsonSerializer.Deserialize <HBPresetCategory>(item.ToString(), JsonSettings.Options);
// Handle Categorised Presets.
HBPresetCategory category = deserializedItem as HBPresetCategory;
if (category != null && category.Folder)
{
foreach (HBPreset hbpreset in category.ChildrenArray)
{
Preset preset = JsonPresetFactory.ImportPreset(hbpreset);
// Migration
preset.Category = category.PresetName == "User Presets" ? UserPresetCategoryName : category.PresetName;
preset.IsBuildIn = hbpreset.Type == 0;
preset.IsPresetDisabled = this.IsPresetDisabled(preset);
this.Add(preset, true);
}
}
// Uncategorised Presets
deserializedItem = JsonSerializer.Deserialize <HBPreset>(item.ToString(), JsonSettings.Options);
HBPreset hbPreset = deserializedItem as HBPreset;
if (hbPreset != null && !hbPreset.Folder)
{
Preset preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = UserPresetCategoryName;
preset.IsBuildIn = hbPreset.Type == 0;
preset.IsPresetDisabled = this.IsPresetDisabled(preset);
this.Add(preset, true);
}
}
}
public void Import(string filename)
{
if (!string.IsNullOrEmpty(filename))
{
PresetTransportContainer container;
try
{
container = HandBrakePresetService.GetPresetsFromFile(filename);
}
catch (Exception exc)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, exc);
return;
}
if (container?.PresetList == null || container.PresetList.Count == 0)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, Resources.NoAdditionalInformation);
return;
}
// HBPreset Handling
if (container.PresetList != null)
{
bool containsBuildInPreset = false;
foreach (var objectPreset in container.PresetList)
{
HBPresetCategory category = JsonSerializer.Deserialize <HBPresetCategory>(objectPreset.ToString(), JsonSettings.Options);
if (category != null && category.ChildrenArray != null && category.ChildrenArray.Count > 0)
{
foreach (HBPreset hbPreset in category.ChildrenArray)
{
Preset preset = this.ConvertHbPreset(hbPreset, category.PresetName);
preset.IsPresetDisabled = this.IsPresetDisabled(preset);
preset.IsDefault = false; // When importing, force the user to reset default manually. This prevents conflicts.
if (!preset.IsBuildIn)
{
this.AddOrUpdateImportedPreset(preset);
}
else
{
containsBuildInPreset = true;
}
}
}
else
{
HBPreset hbPreset = JsonSerializer.Deserialize <HBPreset>(objectPreset.ToString(), JsonSettings.Options);
if (hbPreset != null)
{
Preset preset = this.ConvertHbPreset(hbPreset, null);
preset.IsDefault = false; // When importing, force the user to reset default manually. This prevents conflicts.
preset.IsPresetDisabled = this.IsPresetDisabled(preset);
if (!preset.IsBuildIn)
{
this.AddOrUpdateImportedPreset(preset);
}
else
{
containsBuildInPreset = true;
}
}
}
}
if (containsBuildInPreset)
{
this.errorService.ShowMessageBox(
Properties.Resources.PresetService_ImportingBuiltInWarning,
Properties.Resources.Warning,
MessageBoxButton.OK,
MessageBoxImage.Warning);
}
}
}
}
/// <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.AudioTrackBehaviours.BehaviourTracks)
{
AudioList track = new AudioList
{
AudioBitrate = item.Bitrate,
AudioCompressionLevel = 0, // TODO
AudioDitherMethod = null, // TODO
AudioEncoder = EnumHelper <AudioEncoder> .GetShortName(item.Encoder),
AudioMixdown = item.MixDown != null ? item.MixDown.ShortName : "dpl2",
AudioNormalizeMixLevel = false, // TODO
AudioSamplerate = item.SampleRate == 0 ? "auto" : item.SampleRate.ToString(CultureInfo.InvariantCulture), // 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.Yadif ? "yadif" : "off";
preset.PictureDeinterlacePreset = export.Task.DeinterlaceFilter == DeinterlaceFilter.Decomb
? EnumHelper <Decomb> .GetShortName(export.Task.Decomb)
: export.Task.DeinterlaceFilter == DeinterlaceFilter.Yadif ? EnumHelper <Deinterlace> .GetShortName(export.Task.Deinterlace) : string.Empty;
preset.PictureDeinterlaceCustom = export.Task.DeinterlaceFilter == DeinterlaceFilter.Decomb
? export.Task.CustomDecomb
: export.Task.DeinterlaceFilter == DeinterlaceFilter.Yadif ? 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;
preset.PictureCombDetectPreset = EnumHelper <CombDetect> .GetShortName(export.Task.CombDetect);
preset.PictureCombDetectCustom = export.Task.CustomCombDetect;
// 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.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>
/// The create preset.
/// </summary>
/// <param name="importedPreset">
/// The preset.
/// </param>
/// <returns>
/// The <see cref="Preset"/>.
/// </returns>
public static Preset ImportPreset(HBPreset importedPreset)
{
Preset preset = new Preset();
preset.Name = importedPreset.PresetName;
preset.Description = importedPreset.PresetDescription;
preset.Task = new EncodeTask();
preset.IsDefault = importedPreset.Default;
preset.IsBuildIn = importedPreset.Type == 0;
// Step 1, Create the EncodeTask Object that can be loaded into the UI.
/* Output Settings */
preset.Task.OptimizeMP4 = importedPreset.Mp4HttpOptimize;
preset.Task.IPod5GSupport = importedPreset.Mp4iPodCompatible;
preset.Task.OutputFormat = GetFileFormat(importedPreset.FileFormat.Replace("file", string.Empty).Trim()); // TOOD null check.
/* Picture Settings */
preset.PictureSettingsMode = (PresetPictureSettingsMode)importedPreset.UsesPictureSettings;
preset.Task.MaxWidth = importedPreset.PictureWidth.HasValue && importedPreset.PictureWidth.Value > 0 ? importedPreset.PictureWidth.Value : (int?)null;
preset.Task.MaxHeight = importedPreset.PictureHeight.HasValue && importedPreset.PictureHeight.Value > 0 ? importedPreset.PictureHeight.Value : (int?)null;
preset.Task.Cropping = new Cropping(importedPreset.PictureTopCrop, importedPreset.PictureBottomCrop, importedPreset.PictureLeftCrop, importedPreset.PictureRightCrop);
preset.Task.HasCropping = !importedPreset.PictureAutoCrop;
preset.Task.Modulus = importedPreset.PictureModulus;
preset.Task.KeepDisplayAspect = importedPreset.PictureKeepRatio;
switch (importedPreset.PicturePAR)
{
case "custom":
preset.Task.Anamorphic = Anamorphic.Custom;
preset.Task.DisplayWidth = importedPreset.PictureDARWidth;
break;
case "loose":
preset.Task.Anamorphic = Anamorphic.Loose;
break;
case "auto":
preset.Task.Anamorphic = Anamorphic.Automatic;
break;
default:
preset.Task.Anamorphic = Anamorphic.None;
break;
}
/* Filter Settings */
preset.Task.Grayscale = importedPreset.VideoGrayScale;
preset.Task.Deblock = importedPreset.PictureDeblock;
switch (importedPreset.PictureDeinterlaceFilter)
{
case "decomb":
preset.Task.Decomb = Decomb.Default;
preset.Task.Deinterlace = Deinterlace.Default;
preset.Task.DeinterlaceFilter = DeinterlaceFilter.Decomb;
break;
case "deinterlace":
preset.Task.Decomb = Decomb.Default;
preset.Task.Deinterlace = Deinterlace.Default;
preset.Task.DeinterlaceFilter = DeinterlaceFilter.Yadif;
break;
default:
preset.Task.Decomb = Decomb.Default;
preset.Task.Deinterlace = Deinterlace.Default;
preset.Task.DeinterlaceFilter = DeinterlaceFilter.Off;
break;
}
if (preset.Task.DeinterlaceFilter == DeinterlaceFilter.Decomb)
{
switch (importedPreset.PictureDeinterlaceFilter)
{
case "custom":
preset.Task.Decomb = Decomb.Custom;
break;
case "default":
preset.Task.Decomb = Decomb.Default;
break;
case "bob":
preset.Task.Decomb = Decomb.Bob;
break;
case "eedi2":
preset.Task.Decomb = Decomb.EEDI2;
break;
case "eedi2bob":
preset.Task.Decomb = Decomb.EEDI2Bob;
break;
default:
preset.Task.Decomb = Decomb.Default;
break;
}
if (preset.Task.Decomb == Decomb.Custom)
{
preset.Task.CustomDecomb = importedPreset.PictureDeinterlaceCustom;
}
}
if (preset.Task.DeinterlaceFilter == DeinterlaceFilter.Yadif)
{
switch (importedPreset.PictureDeinterlaceFilter)
{
case "custom":
preset.Task.Deinterlace = Deinterlace.Custom;
break;
case "bob":
preset.Task.Deinterlace = Deinterlace.Bob;
break;
case "skip-spatial":
preset.Task.Deinterlace = Deinterlace.SkipSpatialCheck;
break;
case "default":
preset.Task.Deinterlace = Deinterlace.Default;
break;
default:
preset.Task.Deinterlace = Deinterlace.Default;
break;
}
if (preset.Task.Deinterlace == Deinterlace.Custom)
{
preset.Task.CustomDecomb = importedPreset.PictureDeinterlaceCustom;
}
}
if (preset.Task.DeinterlaceFilter == DeinterlaceFilter.Yadif || preset.Task.DeinterlaceFilter == DeinterlaceFilter.Decomb)
{
switch (importedPreset.PictureCombDetectPreset)
{
case "off":
preset.Task.CombDetect = CombDetect.Off;
break;
case "custom":
preset.Task.CombDetect = CombDetect.Custom;
break;
case "default":
preset.Task.CombDetect = CombDetect.Default;
break;
case "permissive":
preset.Task.CombDetect = CombDetect.LessSensitive;
break;
case "fast":
preset.Task.CombDetect = CombDetect.Fast;
break;
default:
preset.Task.CombDetect = CombDetect.Off;
break;
}
}
preset.Task.CustomDeinterlace = importedPreset.PictureDetelecineCustom;
preset.Task.CustomDenoise = importedPreset.PictureDenoiseCustom;
preset.Task.CustomDetelecine = importedPreset.PictureDetelecineCustom;
preset.Task.CustomCombDetect = importedPreset.PictureCombDetectCustom;
switch (importedPreset.PictureDetelecine)
{
case "custom":
preset.Task.Detelecine = Detelecine.Custom;
break;
case "default":
preset.Task.Detelecine = Detelecine.Default;
break;
default:
preset.Task.Detelecine = Detelecine.Off;
break;
}
switch (importedPreset.PictureDenoiseFilter)
{
case "nlmeans":
preset.Task.Denoise = Denoise.NLMeans;
break;
case "hqdn3d":
preset.Task.Denoise = Denoise.hqdn3d;
break;
default:
preset.Task.Denoise = Denoise.Off;
break;
}
switch (importedPreset.PictureDenoisePreset)
{
case "custom":
preset.Task.DenoisePreset = DenoisePreset.Custom;
break;
case "light":
preset.Task.DenoisePreset = DenoisePreset.Light;
break;
case "medium":
preset.Task.DenoisePreset = DenoisePreset.Medium;
break;
case "strong":
preset.Task.DenoisePreset = DenoisePreset.Strong;
break;
case "ultralight":
preset.Task.DenoisePreset = DenoisePreset.Ultralight;
break;
case "weak":
preset.Task.DenoisePreset = DenoisePreset.Weak;
break;
}
switch (importedPreset.PictureDenoiseTune)
{
case "animation":
preset.Task.DenoiseTune = DenoiseTune.Animation;
break;
case "film":
preset.Task.DenoiseTune = DenoiseTune.Film;
break;
case "grain":
preset.Task.DenoiseTune = DenoiseTune.Grain;
break;
case "highnotion":
preset.Task.DenoiseTune = DenoiseTune.HighMotion;
break;
default:
preset.Task.DenoiseTune = DenoiseTune.None;
break;
}
// Rotation and Flip
if (!string.IsNullOrEmpty(importedPreset.PictureRotate))
{
string[] rotation = importedPreset.PictureRotate.Split(':');
if (rotation.Length == 2)
{
int rotate;
if (int.TryParse(rotation[0], out rotate))
{
preset.Task.Rotation = int.Parse(rotation[0]);
preset.Task.FlipVideo = rotation[1] == "1";
}
}
}
/* Video Settings */
preset.Task.VideoEncoder = EnumHelper <VideoEncoder> .GetValue(importedPreset.VideoEncoder);
preset.Task.VideoBitrate = importedPreset.VideoAvgBitrate;
preset.Task.TwoPass = importedPreset.VideoTwoPass;
preset.Task.TurboFirstPass = importedPreset.VideoTurboTwoPass;
preset.Task.ExtraAdvancedArguments = importedPreset.VideoOptionExtra;
preset.Task.Quality = double.Parse(importedPreset.VideoQualitySlider.ToString(CultureInfo.InvariantCulture), CultureInfo.InvariantCulture);
preset.Task.VideoEncodeRateType = (VideoEncodeRateType)importedPreset.VideoQualityType;
preset.Task.VideoLevel = new VideoLevel(importedPreset.VideoLevel, importedPreset.VideoLevel);
preset.Task.VideoPreset = new VideoPreset(importedPreset.VideoPreset, importedPreset.VideoPreset);
preset.Task.VideoProfile = new VideoProfile(importedPreset.VideoProfile, importedPreset.VideoProfile);
if (!string.IsNullOrEmpty(importedPreset.VideoTune))
{
string[] split = importedPreset.VideoTune.Split(',');
foreach (var item in split)
{
preset.Task.VideoTunes.Add(new VideoTune(item, item));
}
}
preset.Task.Framerate = importedPreset.VideoFramerate == "auto" || string.IsNullOrEmpty(importedPreset.VideoFramerate)
? (double?)null
: double.Parse(importedPreset.VideoFramerate, CultureInfo.InvariantCulture);
string parsedValue = importedPreset.VideoFramerateMode;
switch (parsedValue)
{
case "vfr":
preset.Task.FramerateMode = FramerateMode.VFR;
break;
case "cfr":
preset.Task.FramerateMode = FramerateMode.CFR;
break;
default:
preset.Task.FramerateMode = FramerateMode.PFR;
break;
}
/* Audio Settings */
preset.AudioTrackBehaviours = new AudioBehaviours();
preset.Task.AllowedPassthruOptions.AudioEncoderFallback = EnumHelper <AudioEncoder> .GetValue(importedPreset.AudioEncoderFallback);
preset.AudioTrackBehaviours.SelectedBehaviour = importedPreset.AudioTrackSelectionBehavior == "all"
? AudioBehaviourModes.AllMatching
: AudioBehaviourModes.FirstMatch;
// TODO - The other GUI's don't support All Tracks yet. So for now we can only load / Save first track.
if (importedPreset.AudioSecondaryEncoderMode)
{
preset.AudioTrackBehaviours.SelectedTrackDefaultBehaviour = AudioTrackDefaultsMode.FirstTrack;
}
else
{
preset.AudioTrackBehaviours.SelectedTrackDefaultBehaviour = AudioTrackDefaultsMode.None;
}
if (importedPreset.AudioCopyMask != null)
{
preset.Task.AllowedPassthruOptions.SetFalse();
foreach (var item in importedPreset.AudioCopyMask)
{
AudioEncoder encoder = EnumHelper <AudioEncoder> .GetValue(item);
switch (encoder)
{
case AudioEncoder.AacPassthru:
preset.Task.AllowedPassthruOptions.AudioAllowAACPass = true;
break;
case AudioEncoder.Ac3Passthrough:
preset.Task.AllowedPassthruOptions.AudioAllowAC3Pass = true;
break;
case AudioEncoder.EAc3Passthrough:
preset.Task.AllowedPassthruOptions.AudioAllowEAC3Pass = true;
break;
case AudioEncoder.DtsHDPassthrough:
preset.Task.AllowedPassthruOptions.AudioAllowDTSHDPass = true;
break;
case AudioEncoder.DtsPassthrough:
preset.Task.AllowedPassthruOptions.AudioAllowDTSPass = true;
break;
case AudioEncoder.FlacPassthru:
preset.Task.AllowedPassthruOptions.AudioAllowFlacPass = true;
break;
case AudioEncoder.Mp3Passthru:
preset.Task.AllowedPassthruOptions.AudioAllowMP3Pass = true;
break;
case AudioEncoder.TrueHDPassthrough:
preset.Task.AllowedPassthruOptions.AudioAllowTrueHDPass = true;
break;
}
}
}
if (importedPreset.AudioLanguageList != null)
{
IList <string> names = LanguageUtilities.GetLanguageNames(importedPreset.AudioLanguageList);
foreach (var name in names)
{
preset.AudioTrackBehaviours.SelectedLangauges.Add(name);
}
}
preset.Task.AudioTracks = new ObservableCollection <AudioTrack>();
if (importedPreset.AudioList != null)
{
foreach (var audioTrack in importedPreset.AudioList)
{
AudioBehaviourTrack track = new AudioBehaviourTrack();
track.Bitrate = audioTrack.AudioBitrate;
// track.CompressionLevel = audioTrack.AudioCompressionLevel;
// track.AudioDitherMethod = audioTrack.AudioDitherMethod;
track.Encoder = EnumHelper <AudioEncoder> .GetValue(audioTrack.AudioEncoder);
track.MixDown = HandBrakeEncoderHelpers.GetMixdown(audioTrack.AudioMixdown);
// track.AudioNormalizeMixLevel = audioTrack.AudioNormalizeMixLevel;
track.SampleRate = audioTrack.AudioSamplerate == "auto" ? 0 : double.Parse(audioTrack.AudioSamplerate);
track.EncoderRateType = audioTrack.AudioTrackQualityEnable ? AudioEncoderRateType.Quality : AudioEncoderRateType.Bitrate;
track.Quality = audioTrack.AudioTrackQuality;
track.Gain = (int)audioTrack.AudioTrackGainSlider;
track.DRC = audioTrack.AudioTrackDRCSlider;
preset.AudioTrackBehaviours.BehaviourTracks.Add(track);
}
}
/* Subtitle Settings */
preset.SubtitleTrackBehaviours = new SubtitleBehaviours();
preset.SubtitleTrackBehaviours.SelectedBehaviour = EnumHelper <SubtitleBehaviourModes> .GetValue(importedPreset.SubtitleTrackSelectionBehavior);
preset.SubtitleTrackBehaviours.SelectedBurnInBehaviour = EnumHelper <SubtitleBurnInBehaviourModes> .GetValue(importedPreset.SubtitleBurnBehavior);
preset.SubtitleTrackBehaviours.AddClosedCaptions = importedPreset.SubtitleAddCC;
preset.SubtitleTrackBehaviours.AddForeignAudioScanTrack = importedPreset.SubtitleAddForeignAudioSearch;
if (importedPreset.SubtitleLanguageList != null)
{
IList <string> names = LanguageUtilities.GetLanguageNames(importedPreset.SubtitleLanguageList);
foreach (var name in names)
{
preset.SubtitleTrackBehaviours.SelectedLangauges.Add(name);
}
}
/* Chapter Marker Settings */
preset.Task.IncludeChapterMarkers = importedPreset.ChapterMarkers;
/* Advanced Settings */
preset.Task.ShowAdvancedTab = importedPreset.x264UseAdvancedOptions;
preset.Task.AdvancedEncoderOptions = importedPreset.x264Option;
/* Not Supported Yet */
// public int VideoColorMatrixCode { get; set; }
// public bool VideoHWDecode { get; set; }
// public string VideoScaler { get; set; }
// public bool VideoQSVDecode { get; set; }
// public int VideoQSVAsyncDepth { get; set; }
// public bool SubtitleAddForeignAudioSubtitle { get; set; }
// public bool SubtitleBurnBDSub { get; set; }
// public bool SubtitleBurnDVDSub { get; set; }
// public bool PictureItuPAR { get; set; }
// public bool PictureLooseCrop { get; set; }
// public int PicturePARWidth { get; set; }
// public int PicturePARHeight { get; set; }
// public int PictureForceHeight { get; set; }
// public int PictureForceWidth { get; set; }
// public List<object> ChildrenArray { get; set; }
// public bool Folder { get; set; }
// public bool FolderOpen { get; set; }
// public int Type { get; set; }
return(preset);
}
/// <summary>
/// Update the preset files
/// </summary>
private void SavePresetFiles()
{
try
{
// Verify Directories.
string directory = Path.GetDirectoryName(this.presetFile);
if (directory != null && !Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
// Organise the Presets list into Json Equivalent objects.
Dictionary <string, PresetCategory> presetCategories = new Dictionary <string, PresetCategory>();
List <HBPreset> uncategorisedPresets = new List <HBPreset>();
// Handle User Presets first.
foreach (Preset item in this.flatPresetList.Values.OrderBy(o => o.IsBuildIn))
{
if (string.IsNullOrEmpty(item.Category))
{
uncategorisedPresets.Add(JsonPresetFactory.CreateHbPreset(item, HBConfigurationFactory.Create()));
}
else
{
HBPreset preset = JsonPresetFactory.CreateHbPreset(item, HBConfigurationFactory.Create());
if (presetCategories.ContainsKey(item.Category))
{
presetCategories[item.Category].ChildrenArray.Add(preset);
}
else
{
presetCategories[item.Category] = new PresetCategory
{
ChildrenArray = new List <HBPreset> {
preset
},
Folder = true,
PresetName = item.Category,
Type = item.IsBuildIn ? 0 : 1
};
}
}
}
// Wrap the categories in a container.
JsonSerializerSettings settings = new JsonSerializerSettings {
MissingMemberHandling = MissingMemberHandling.Ignore
};
PresetTransportContainer container = new PresetTransportContainer(
Constants.PresetVersionMajor,
Constants.PresetVersionMinor,
Constants.PresetVersionMicro)
{
PresetList = new List <object>()
};
container.PresetList.AddRange(presetCategories.Values);
container.PresetList.AddRange(uncategorisedPresets);
// Write the preset container out to file.
using (FileStream strm = new FileStream(this.presetFile, FileMode.Create, FileAccess.Write))
{
string presetsJson = JsonConvert.SerializeObject(container, Formatting.Indented, settings);
using (StreamWriter writer = new StreamWriter(strm))
{
writer.WriteLine(presetsJson);
}
}
}
catch (Exception exc)
{
Debug.WriteLine(exc);
throw new GeneralApplicationException("Unable to write to the presets file.", "The details section below may indicate why this error has occurred.", exc);
}
}
/// <summary>
/// The import.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
public void Import(string filename)
{
if (!string.IsNullOrEmpty(filename))
{
PresetTransportContainer container = HandBrakePresetService.GetPresetFromFile(filename);
if (container?.PresetList == null || container.PresetList.Count == 0)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, string.Empty);
return;
}
// HBPreset Handling
if (container.PresetList != null)
{
foreach (var objectPreset in container.PresetList)
{
HBPreset hbPreset = JsonConvert.DeserializeObject <HBPreset>(objectPreset.ToString());
Preset preset = null;
try
{
preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = UserPresetCatgoryName;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
}
catch (Exception exc)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, exc);
}
if (preset == null)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, string.Empty);
return;
}
if (this.CheckIfPresetExists(preset.Name))
{
if (!this.CanUpdatePreset(preset.Name))
{
MessageBox.Show(Resources.Main_PresetErrorBuiltInName, Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
MessageBoxResult result = MessageBox.Show(Resources.Main_PresetOverwriteWarning, Resources.Overwrite, MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (result == MessageBoxResult.Yes)
{
this.Update(preset);
}
}
else
{
this.Add(preset);
}
}
}
// Category Handling.
// TODO maybe for a future release.
}
}
/// <summary>
/// The create preset.
/// </summary>
/// <param name="importedPreset">
/// The preset.
/// </param>
/// <returns>
/// The <see cref="Preset"/>.
/// </returns>
public static Preset ImportPreset(HBPreset importedPreset)
{
Preset preset = new Preset();
preset.Name = importedPreset.PresetName;
preset.Description = importedPreset.PresetDescription;
preset.Task = new EncodeTask();
preset.IsDefault = importedPreset.Default;
preset.IsBuildIn = importedPreset.Type == 0;
// Step 1, Create the EncodeTask Object that can be loaded into the UI.
/* Output Settings */
preset.Task.OptimizeMP4 = importedPreset.Mp4HttpOptimize;
preset.Task.IPod5GSupport = importedPreset.Mp4iPodCompatible;
preset.Task.OutputFormat = GetFileFormat(importedPreset.FileFormat.Replace("file", string.Empty).Trim()); // TOOD null check.
preset.Task.AlignAVStart = importedPreset.AlignAVStart;
/* Picture Settings */
preset.PictureSettingsMode = (PresetPictureSettingsMode)importedPreset.UsesPictureSettings;
preset.Task.MaxWidth = importedPreset.PictureWidth.HasValue && importedPreset.PictureWidth.Value > 0 ? importedPreset.PictureWidth.Value : (int?)null;
preset.Task.MaxHeight = importedPreset.PictureHeight.HasValue && importedPreset.PictureHeight.Value > 0 ? importedPreset.PictureHeight.Value : (int?)null;
preset.Task.Cropping = new Cropping(importedPreset.PictureTopCrop, importedPreset.PictureBottomCrop, importedPreset.PictureLeftCrop, importedPreset.PictureRightCrop);
preset.Task.HasCropping = !importedPreset.PictureAutoCrop;
preset.Task.Modulus = importedPreset.PictureModulus;
preset.Task.KeepDisplayAspect = importedPreset.PictureKeepRatio;
switch (importedPreset.PicturePAR)
{
case "custom":
preset.Task.Anamorphic = Anamorphic.Custom;
preset.Task.DisplayWidth = importedPreset.PictureDARWidth;
break;
case "loose":
preset.Task.Anamorphic = Anamorphic.Loose;
break;
case "auto":
preset.Task.Anamorphic = Anamorphic.Automatic;
break;
default:
preset.Task.Anamorphic = Anamorphic.None;
break;
}
/* Filter Settings */
preset.Task.Grayscale = importedPreset.VideoGrayScale;
preset.Task.DeblockPreset = new FilterPreset(HandBrakeFilterHelpers.GetFilterPresets((int)hb_filter_ids.HB_FILTER_DEBLOCK).FirstOrDefault(s => s.ShortName == importedPreset.PictureDeblockPreset));
preset.Task.DeblockTune = new FilterTune(HandBrakeFilterHelpers.GetFilterTunes((int)hb_filter_ids.HB_FILTER_DEBLOCK).FirstOrDefault(s => s.ShortName == importedPreset.PictureDeblockTune));
preset.Task.CustomDeblock = importedPreset.PictureDeblockCustom;
if (importedPreset.PictureSharpenFilter != null)
{
preset.Task.Sharpen = EnumHelper <Sharpen> .GetValue(importedPreset.PictureSharpenFilter);
hb_filter_ids filterId = hb_filter_ids.HB_FILTER_INVALID;
switch (preset.Task.Sharpen)
{
case Sharpen.LapSharp:
filterId = hb_filter_ids.HB_FILTER_LAPSHARP;
break;
case Sharpen.UnSharp:
filterId = hb_filter_ids.HB_FILTER_UNSHARP;
break;
}
if (filterId != hb_filter_ids.HB_FILTER_INVALID)
{
preset.Task.SharpenPreset = new FilterPreset(HandBrakeFilterHelpers.GetFilterPresets((int)filterId).FirstOrDefault(s => s.ShortName == importedPreset.PictureSharpenPreset));
preset.Task.SharpenTune = new FilterTune(HandBrakeFilterHelpers.GetFilterTunes((int)filterId).FirstOrDefault(s => s.ShortName == importedPreset.PictureSharpenTune));
preset.Task.SharpenCustom = importedPreset.PictureSharpenCustom;
}
else
{
// Default Values.
preset.Task.SharpenPreset = new FilterPreset("Medium", "medium");
preset.Task.SharpenTune = new FilterTune("None", "none");
preset.Task.SharpenCustom = string.Empty;
}
}
switch (importedPreset.PictureDeinterlaceFilter)
{
case "decomb":
preset.Task.DeinterlaceFilter = DeinterlaceFilter.Decomb;
break;
case "yadif":
preset.Task.DeinterlaceFilter = DeinterlaceFilter.Yadif;
break;
default:
preset.Task.DeinterlaceFilter = DeinterlaceFilter.Off;
break;
}
if (preset.Task.DeinterlaceFilter == DeinterlaceFilter.Decomb)
{
List <HBPresetTune> filterPresets = HandBrakeFilterHelpers.GetFilterPresets((int)hb_filter_ids.HB_FILTER_DECOMB);
HBPresetTune presetTune = filterPresets.FirstOrDefault(f => f.ShortName == importedPreset.PictureDeinterlacePreset);
preset.Task.DeinterlacePreset = presetTune ?? new HBPresetTune("Default", "default");
preset.Task.CustomDeinterlaceSettings = importedPreset.PictureDeinterlaceCustom;
}
if (preset.Task.DeinterlaceFilter == DeinterlaceFilter.Yadif)
{
List <HBPresetTune> filterPresets = HandBrakeFilterHelpers.GetFilterPresets((int)hb_filter_ids.HB_FILTER_DEINTERLACE);
HBPresetTune presetTune = filterPresets.FirstOrDefault(f => f.ShortName == importedPreset.PictureDeinterlacePreset);
preset.Task.DeinterlacePreset = presetTune ?? new HBPresetTune("Default", "default");
preset.Task.CustomDeinterlaceSettings = importedPreset.PictureDeinterlaceCustom;
}
if (preset.Task.DeinterlaceFilter == DeinterlaceFilter.Yadif || preset.Task.DeinterlaceFilter == DeinterlaceFilter.Decomb)
{
switch (importedPreset.PictureCombDetectPreset)
{
case "off":
preset.Task.CombDetect = CombDetect.Off;
break;
case "custom":
preset.Task.CombDetect = CombDetect.Custom;
break;
case "default":
preset.Task.CombDetect = CombDetect.Default;
break;
case "permissive":
preset.Task.CombDetect = CombDetect.LessSensitive;
break;
case "fast":
preset.Task.CombDetect = CombDetect.Fast;
break;
default:
preset.Task.CombDetect = CombDetect.Off;
break;
}
}
preset.Task.CustomDenoise = importedPreset.PictureDenoiseCustom;
preset.Task.CustomDetelecine = importedPreset.PictureDetelecineCustom;
preset.Task.CustomCombDetect = importedPreset.PictureCombDetectCustom;
switch (importedPreset.PictureDetelecine)
{
case "custom":
preset.Task.Detelecine = Detelecine.Custom;
break;
case "default":
preset.Task.Detelecine = Detelecine.Default;
break;
default:
preset.Task.Detelecine = Detelecine.Off;
break;
}
switch (importedPreset.PictureDenoiseFilter)
{
case "nlmeans":
preset.Task.Denoise = Denoise.NLMeans;
break;
case "hqdn3d":
preset.Task.Denoise = Denoise.hqdn3d;
break;
default:
preset.Task.Denoise = Denoise.Off;
break;
}
switch (importedPreset.PictureDenoisePreset)
{
case "custom":
preset.Task.DenoisePreset = DenoisePreset.Custom;
break;
case "light":
preset.Task.DenoisePreset = DenoisePreset.Light;
break;
case "medium":
preset.Task.DenoisePreset = DenoisePreset.Medium;
break;
case "strong":
preset.Task.DenoisePreset = DenoisePreset.Strong;
break;
case "ultralight":
preset.Task.DenoisePreset = DenoisePreset.Ultralight;
break;
case "weak":
preset.Task.DenoisePreset = DenoisePreset.Weak;
break;
}
switch (importedPreset.PictureDenoiseTune)
{
case "animation":
preset.Task.DenoiseTune = DenoiseTune.Animation;
break;
case "film":
preset.Task.DenoiseTune = DenoiseTune.Film;
break;
case "grain":
preset.Task.DenoiseTune = DenoiseTune.Grain;
break;
case "highmotion":
preset.Task.DenoiseTune = DenoiseTune.HighMotion;
break;
case "tape":
preset.Task.DenoiseTune = DenoiseTune.Tape;
break;
case "sprite":
preset.Task.DenoiseTune = DenoiseTune.Sprite;
break;
default:
preset.Task.DenoiseTune = DenoiseTune.None;
break;
}
// Rotation and Flip
if (!string.IsNullOrEmpty(importedPreset.PictureRotate))
{
string[] rotation = importedPreset.PictureRotate.Split(':');
if (rotation.Length == 2)
{
int rotate;
if (int.TryParse(rotation[0], out rotate))
{
preset.Task.Rotation = int.Parse(rotation[0]);
preset.Task.FlipVideo = rotation[1] == "1";
}
}
}
/* Video Settings */
preset.Task.VideoEncoder = EnumHelper <VideoEncoder> .GetValue(importedPreset.VideoEncoder);
preset.Task.VideoBitrate = importedPreset.VideoAvgBitrate;
preset.Task.TwoPass = importedPreset.VideoTwoPass;
preset.Task.TurboFirstPass = importedPreset.VideoTurboTwoPass;
preset.Task.ExtraAdvancedArguments = importedPreset.VideoOptionExtra;
preset.Task.Quality = double.Parse(importedPreset.VideoQualitySlider.ToString(CultureInfo.InvariantCulture), CultureInfo.InvariantCulture);
preset.Task.VideoEncodeRateType = (VideoEncodeRateType)importedPreset.VideoQualityType;
preset.Task.VideoLevel = new VideoLevel(importedPreset.VideoLevel, importedPreset.VideoLevel);
preset.Task.VideoPreset = new VideoPreset(importedPreset.VideoPreset, importedPreset.VideoPreset);
preset.Task.VideoProfile = new VideoProfile(importedPreset.VideoProfile, importedPreset.VideoProfile);
if (!string.IsNullOrEmpty(importedPreset.VideoTune))
{
string[] split = importedPreset.VideoTune.Split(',');
foreach (var item in split)
{
preset.Task.VideoTunes.Add(new VideoTune(item, item));
}
}
if (importedPreset.VideoFramerate == "auto" || importedPreset.VideoFramerate == "Same as source" || string.IsNullOrEmpty(importedPreset.VideoFramerate))
{
preset.Task.Framerate = null;
}
else
{
double parsedFramerate;
if (double.TryParse(importedPreset.VideoFramerate, NumberStyles.Any, CultureInfo.CurrentCulture, out parsedFramerate) || double.TryParse(importedPreset.VideoFramerate, NumberStyles.Any, CultureInfo.InvariantCulture, out parsedFramerate))
{
preset.Task.Framerate = parsedFramerate;
}
}
string parsedValue = importedPreset.VideoFramerateMode;
switch (parsedValue)
{
case "vfr":
preset.Task.FramerateMode = FramerateMode.VFR;
break;
case "cfr":
preset.Task.FramerateMode = FramerateMode.CFR;
break;
default:
preset.Task.FramerateMode = FramerateMode.PFR;
break;
}
/* Audio Settings */
preset.AudioTrackBehaviours = new AudioBehaviours();
preset.Task.AllowedPassthruOptions.AudioEncoderFallback = EnumHelper <AudioEncoder> .GetValue(importedPreset.AudioEncoderFallback);
preset.AudioTrackBehaviours.SelectedBehaviour = importedPreset.AudioTrackSelectionBehavior == "all"
? AudioBehaviourModes.AllMatching
: AudioBehaviourModes.FirstMatch;
preset.AudioTrackBehaviours.SelectedTrackDefaultBehaviour = importedPreset.AudioSecondaryEncoderMode ? AudioTrackDefaultsMode.FirstTrack : AudioTrackDefaultsMode.AllTracks;
if (importedPreset.AudioCopyMask != null)
{
preset.Task.AllowedPassthruOptions.SetFalse();
foreach (var item in importedPreset.AudioCopyMask)
{
AudioEncoder encoder = EnumHelper <AudioEncoder> .GetValue(item);
switch (encoder)
{
case AudioEncoder.AacPassthru:
preset.Task.AllowedPassthruOptions.AudioAllowAACPass = true;
break;
case AudioEncoder.Ac3Passthrough:
preset.Task.AllowedPassthruOptions.AudioAllowAC3Pass = true;
break;
case AudioEncoder.EAc3Passthrough:
preset.Task.AllowedPassthruOptions.AudioAllowEAC3Pass = true;
break;
case AudioEncoder.DtsHDPassthrough:
preset.Task.AllowedPassthruOptions.AudioAllowDTSHDPass = true;
break;
case AudioEncoder.DtsPassthrough:
preset.Task.AllowedPassthruOptions.AudioAllowDTSPass = true;
break;
case AudioEncoder.FlacPassthru:
preset.Task.AllowedPassthruOptions.AudioAllowFlacPass = true;
break;
case AudioEncoder.Mp3Passthru:
preset.Task.AllowedPassthruOptions.AudioAllowMP3Pass = true;
break;
case AudioEncoder.TrueHDPassthrough:
preset.Task.AllowedPassthruOptions.AudioAllowTrueHDPass = true;
break;
}
}
}
if (importedPreset.AudioLanguageList != null)
{
IList <string> names = LanguageUtilities.GetLanguageNames(importedPreset.AudioLanguageList);
foreach (var name in names)
{
preset.AudioTrackBehaviours.SelectedLangauges.Add(name);
}
}
preset.Task.AudioTracks = new ObservableCollection <AudioTrack>();
if (importedPreset.AudioList != null)
{
foreach (var audioTrack in importedPreset.AudioList)
{
AudioBehaviourTrack track = new AudioBehaviourTrack();
// track.CompressionLevel = audioTrack.AudioCompressionLevel;
// track.AudioDitherMethod = audioTrack.AudioDitherMethod;
if (audioTrack.AudioEncoder == "ca_aac")
{
audioTrack.AudioEncoder = "av_aac"; // No Core Audio support on windows.
}
track.Encoder = EnumHelper <AudioEncoder> .GetValue(audioTrack.AudioEncoder);
track.MixDown = HandBrakeEncoderHelpers.GetMixdown(audioTrack.AudioMixdown);
track.Bitrate = audioTrack.AudioBitrate;
// track.AudioNormalizeMixLevel = audioTrack.AudioNormalizeMixLevel;
if ("auto".Equals(audioTrack.AudioSamplerate))
{
track.SampleRate = 0;
}
else if (!string.IsNullOrEmpty(audioTrack.AudioSamplerate))
{
double sampleRate = 0;
if (double.TryParse(audioTrack.AudioSamplerate, NumberStyles.Any, CultureInfo.InvariantCulture, out sampleRate))
{
track.SampleRate = sampleRate;
}
}
track.EncoderRateType = audioTrack.AudioTrackQualityEnable ? AudioEncoderRateType.Quality : AudioEncoderRateType.Bitrate;
track.Quality = audioTrack.AudioTrackQuality;
track.Gain = (int)audioTrack.AudioTrackGainSlider;
track.DRC = audioTrack.AudioTrackDRCSlider;
preset.AudioTrackBehaviours.BehaviourTracks.Add(track);
}
}
/* Subtitle Settings */
preset.SubtitleTrackBehaviours = new SubtitleBehaviours();
preset.SubtitleTrackBehaviours.SelectedBehaviour = EnumHelper <SubtitleBehaviourModes> .GetValue(importedPreset.SubtitleTrackSelectionBehavior);
preset.SubtitleTrackBehaviours.SelectedBurnInBehaviour = EnumHelper <SubtitleBurnInBehaviourModes> .GetValue(importedPreset.SubtitleBurnBehavior);
preset.SubtitleTrackBehaviours.AddClosedCaptions = importedPreset.SubtitleAddCC;
preset.SubtitleTrackBehaviours.AddForeignAudioScanTrack = importedPreset.SubtitleAddForeignAudioSearch;
if (importedPreset.SubtitleLanguageList != null)
{
IList <string> names = LanguageUtilities.GetLanguageNames(importedPreset.SubtitleLanguageList);
foreach (var name in names)
{
preset.SubtitleTrackBehaviours.SelectedLangauges.Add(name);
}
}
/* Chapter Marker Settings */
preset.Task.IncludeChapterMarkers = importedPreset.ChapterMarkers;
/* Not Supported Yet */
// public int VideoColorMatrixCode { get; set; }
// public string VideoScaler { get; set; }
// public bool VideoQSVDecode { get; set; }
// public int VideoQSVAsyncDepth { get; set; }
// public bool SubtitleAddForeignAudioSubtitle { get; set; }
// public bool SubtitleBurnBDSub { get; set; }
// public bool SubtitleBurnDVDSub { get; set; }
// public bool PictureItuPAR { get; set; }
// public bool PictureLooseCrop { get; set; }
// public int PicturePARWidth { get; set; }
// public int PicturePARHeight { get; set; }
// public int PictureForceHeight { get; set; }
// public int PictureForceWidth { get; set; }
// public List<object> ChildrenArray { get; set; }
// public bool Folder { get; set; }
// public bool FolderOpen { get; set; }
// public int Type { get; set; }
return(preset);
}
public static Preset ConvertHandBrakePresetToVC(HBPreset hbPreset)
{
var profile = new VCProfile();
// Container
profile.ContainerName = hbPreset.FileFormat;
profile.PreferredExtension = VCOutputExtension.Mp4;
profile.IncludeChapterMarkers = hbPreset.ChapterMarkers;
profile.AlignAVStart = hbPreset.AlignAVStart;
profile.Optimize = hbPreset.Mp4HttpOptimize;
profile.IPod5GSupport = hbPreset.Mp4iPodCompatible;
// Sizing
profile.Cropping = new VCCropping(hbPreset.PictureTopCrop, hbPreset.PictureBottomCrop, hbPreset.PictureLeftCrop, hbPreset.PictureRightCrop);
profile.CroppingType = hbPreset.PictureAutoCrop ? VCCroppingType.Automatic : VCCroppingType.Custom;
profile.SizingMode = VCSizingMode.Automatic;
profile.ScalingMode = VCScalingMode.DownscaleOnly;
profile.UseAnamorphic = hbPreset.PicturePAR != "off";
profile.PixelAspectX = 1;
profile.PixelAspectY = 1;
profile.Width = hbPreset.PictureWidth ?? 0;
profile.Height = hbPreset.PictureHeight ?? 0;
profile.PaddingMode = VCPaddingMode.None;
profile.Modulus = hbPreset.PictureModulus;
profile.Rotation = VCPictureRotation.None;
profile.FlipHorizontal = false;
profile.FlipVertical = false;
// Video filters
profile.Grayscale = hbPreset.VideoGrayScale;
profile.Detelecine = hbPreset.PictureDetelecine;
profile.CustomDetelecine = hbPreset.PictureDetelecineCustom;
switch (hbPreset.PictureDeinterlaceFilter)
{
case "yadif":
profile.DeinterlaceType = VCDeinterlace.Yadif;
break;
case "decomb":
profile.DeinterlaceType = VCDeinterlace.Decomb;
break;
case "off":
default:
profile.DeinterlaceType = VCDeinterlace.Off;
break;
}
profile.DeinterlacePreset = hbPreset.PictureDeinterlacePreset;
profile.CustomDeinterlace = hbPreset.PictureDeinterlaceCustom;
profile.CombDetect = hbPreset.PictureCombDetectPreset;
profile.CustomCombDetect = hbPreset.PictureCombDetectCustom;
// Video encoding
profile.VideoEncoder = hbPreset.VideoEncoder;
profile.VideoProfile = hbPreset.VideoProfile;
profile.VideoPreset = hbPreset.VideoPreset;
profile.VideoLevel = hbPreset.VideoLevel;
profile.VideoTunes = new List <string>();
if (!string.IsNullOrEmpty(hbPreset.VideoTune))
{
profile.VideoTunes.Add(hbPreset.VideoTune);
}
profile.VideoOptions = hbPreset.VideoOptionExtra;
profile.TwoPass = hbPreset.VideoTwoPass;
profile.TurboFirstPass = hbPreset.VideoTurboTwoPass;
profile.Quality = hbPreset.VideoQualitySlider;
profile.VideoBitrate = hbPreset.VideoAvgBitrate ?? 0;
profile.QsvDecode = false;
switch (hbPreset.VideoQualityType)
{
case 0:
profile.VideoEncodeRateType = VCVideoEncodeRateType.TargetSize;
break;
case 1:
profile.VideoEncodeRateType = VCVideoEncodeRateType.AverageBitrate;
break;
case 2:
default:
profile.VideoEncodeRateType = VCVideoEncodeRateType.ConstantQuality;
break;
}
double parsedFramerate;
double.TryParse(hbPreset.VideoFramerate, out parsedFramerate);
switch (hbPreset.VideoFramerateMode)
{
case "cfr":
profile.ConstantFramerate = true;
profile.Framerate = parsedFramerate;
break;
case "pfr":
profile.ConstantFramerate = false;
profile.Framerate = parsedFramerate;
break;
case "vfr":
default:
profile.ConstantFramerate = false;
profile.Framerate = 0;
break;
}
profile.TargetSize = 0;
// Audio
profile.AudioCopyMask = new List <CopyMaskChoice>();
foreach (string audioCodec in hbPreset.AudioCopyMask)
{
string codec;
if (audioCodec.StartsWith("copy:", StringComparison.Ordinal))
{
codec = audioCodec.Substring(5);
}
else
{
codec = audioCodec;
}
profile.AudioCopyMask.Add(new CopyMaskChoice {
Codec = codec, Enabled = true
});
}
profile.AudioEncoderFallback = hbPreset.AudioEncoderFallback;
profile.AudioEncodings = new List <AudioEncoding>();
foreach (var hbAudio in hbPreset.AudioList)
{
var audioEncoding = new AudioEncoding();
audioEncoding.InputNumber = 0;
audioEncoding.Encoder = hbAudio.AudioEncoder;
audioEncoding.Bitrate = hbAudio.AudioBitrate;
audioEncoding.PassthroughIfPossible = false;
audioEncoding.Mixdown = hbAudio.AudioMixdown;
audioEncoding.Quality = (float)hbAudio.AudioTrackQuality;
audioEncoding.EncodeRateType = hbAudio.AudioTrackQualityEnable ? AudioEncodeRateType.Quality : AudioEncodeRateType.Bitrate;
audioEncoding.Compression = (float)hbAudio.AudioCompressionLevel;
if (hbAudio.AudioSamplerate == "auto")
{
audioEncoding.SampleRateRaw = 0;
}
else
{
double parsedSampleRate;
if (double.TryParse(hbAudio.AudioSamplerate, out parsedSampleRate))
{
audioEncoding.SampleRateRaw = (int)(parsedSampleRate * 1000);
}
else
{
audioEncoding.SampleRateRaw = 0;
}
}
audioEncoding.Gain = (int)hbAudio.AudioTrackGainSlider;
audioEncoding.Drc = hbAudio.AudioTrackDRCSlider;
profile.AudioEncodings.Add(audioEncoding);
}
return(new Preset
{
Name = hbPreset.PresetName,
EncodingProfile = profile,
IsBuiltIn = true,
});
}
/// <summary>
/// Load in the Built-in and User presets into the collection
/// </summary>
private void LoadPresets()
{
// First clear the Presets arraylists
this.presets.Clear();
// Load the presets file.
try
{
// If we don't have a presets file. Create one for first load.
if (!File.Exists(this.presetFile))
{
this.UpdateBuiltInPresets();
return;
}
// Otherwise, we already have a file, so lets try load it.
bool versionCheckChange = false;
using (StreamReader reader = new StreamReader(this.presetFile))
{
// New Preset Format.
PresetTransportContainer container = null;
try
{
container = JsonConvert.DeserializeObject <PresetTransportContainer>(reader.ReadToEnd());
}
catch (Exception)
{
// ignored
}
// Sanity Check. Did the container deserialise.
if (container?.PresetList == null)
{
// Close and Dispose of early.
reader.Close();
reader.Dispose();
string filename = this.RecoverFromCorruptedPresetFile(this.presetFile);
this.errorService.ShowMessageBox(
Resources.PresetService_UnableToLoadPresets + filename,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Exclamation);
this.UpdateBuiltInPresets();
return;
}
// Version Check
// If we have old presets, or the container wasn't parseable, or we have a version mismatch, backup the user preset file
// incase something goes wrong.
if (container.VersionMajor != Constants.PresetVersionMajor || container.VersionMinor != Constants.PresetVersionMinor || container.VersionMicro != Constants.PresetVersionMicro)
{
string fileName = this.ArchivePresetFile(this.presetFile);
this.errorService.ShowMessageBox(
Resources.PresetService_PresetsOutOfDate
+ Environment.NewLine + Environment.NewLine + Resources.PresetService_ArchiveFile + fileName,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Exclamation);
versionCheckChange = true;
}
// Process the presets.
foreach (var item in container.PresetList)
{
object deserialisedItem = JsonConvert.DeserializeObject <PresetCategory>(item.ToString());;
// Handle Categorised Presets.
PresetCategory category = deserialisedItem as PresetCategory;
if (category != null && category.Folder)
{
foreach (HBPreset hbpreset in category.ChildrenArray)
{
Preset preset = JsonPresetFactory.ImportPreset(hbpreset);
preset.Category = category.PresetName;
preset.IsBuildIn = hbpreset.Type == 0;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
this.presets.Add(preset);
}
}
// Uncategorised Presets
deserialisedItem = JsonConvert.DeserializeObject <HBPreset>(item.ToString());
HBPreset hbPreset = deserialisedItem as HBPreset;
if (hbPreset != null && !hbPreset.Folder)
{
Preset preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = UserPresetCatgoryName;
preset.IsBuildIn = hbPreset.Type == 1;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
this.presets.Add(preset);
}
}
}
// Resave the presets if we failed the version check to update the container
if (versionCheckChange)
{
this.SavePresetFiles();
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
this.RecoverFromCorruptedPresetFile(this.presetFile);
this.UpdateBuiltInPresets();
}
}
public static HBPreset CreateHbPreset(Preset export)
{
HBPreset preset = new HBPreset();
// Preset
preset.PresetDescription = export.Description;
preset.PresetName = export.Name;
preset.Type = export.IsBuildIn ? 0 : 1;
preset.Default = export.IsDefault;
// Audio
preset.AudioCopyMask = export.AudioTrackBehaviours.AllowedPassthruOptions.AllowedPassthruOptions.Select(EnumHelper <AudioEncoder> .GetShortName).ToList();
preset.AudioEncoderFallback = EnumHelper <AudioEncoder> .GetShortName(export.AudioTrackBehaviours.AllowedPassthruOptions.AudioEncoderFallback);
preset.AudioLanguageList = LanguageUtilities.GetLanguageCodes(export.AudioTrackBehaviours.SelectedLanguages);
preset.AudioTrackSelectionBehavior = EnumHelper <AudioBehaviourModes> .GetShortName(export.AudioTrackBehaviours.SelectedBehaviour);
preset.AudioSecondaryEncoderMode = export.AudioTrackBehaviours.SelectedTrackDefaultBehaviour == AudioTrackDefaultsMode.FirstTrack; // 1 = First Track, 0 = All
preset.AudioList = new List <AudioList>();
foreach (var item in export.AudioTrackBehaviours.BehaviourTracks)
{
AudioList track = new AudioList
{
AudioBitrate = item.Bitrate,
AudioCompressionLevel = 0, // TODO
AudioDitherMethod = null, // TODO
AudioEncoder = EnumHelper <AudioEncoder> .GetShortName(item.Encoder),
AudioMixdown = item.MixDown != null ? item.MixDown.ShortName : "dpl2",
AudioNormalizeMixLevel = false, // TODO
AudioSamplerate = item.SampleRate == 0 ? "auto" : item.SampleRate.ToString(CultureInfo.InvariantCulture), // 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.SelectedLanguages);
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;
preset.AlignAVStart = export.Task.AlignAVStart;
preset.MetadataPassthrough = export.Task.MetaData?.PassthruMetadataEnabled ?? false;
// Picture Settings
preset.PictureForceHeight = 0; // TODO
preset.PictureForceWidth = 0; // TODO
preset.PictureHeight = export.Task.MaxHeight;
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.PicturePAR = EnumHelper <Anamorphic> .GetShortName(export.Task.Anamorphic);
preset.PicturePARHeight = export.Task.PixelAspectY;
preset.PicturePARWidth = export.Task.PixelAspectX;
preset.PictureRightCrop = export.Task.Cropping.Right;
preset.PicturePadMode = export.Task.Padding.Mode;
preset.PicturePadTop = export.Task.Padding.Y;
preset.PicturePadBottom = export.Task.Padding.Bottom;
preset.PicturePadLeft = export.Task.Padding.X;
preset.PicturePadRight = export.Task.Padding.Right;
preset.PicturePadColor = export.Task.Padding.Color;
preset.PictureUseMaximumSize = export.Task.OptimalSize;
preset.PictureAllowUpscaling = export.Task.AllowUpscaling;
if (export.Task.Rotation != 0 || export.Task.FlipVideo)
{
preset.PictureRotate = string.Format("{0}:{1}", export.Task.Rotation, export.Task.FlipVideo ? "1" : "0");
}
preset.PictureTopCrop = export.Task.Cropping.Top;
preset.PictureWidth = export.Task.MaxWidth;
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.PictureDeblockPreset = export.Task.DeblockPreset?.Key;
preset.PictureDeblockTune = export.Task.DeblockTune?.Key;
preset.PictureDeblockCustom = export.Task.CustomDeblock;
preset.PictureDeinterlaceFilter = export.Task.DeinterlaceFilter == DeinterlaceFilter.Decomb ? "decomb"
: export.Task.DeinterlaceFilter == DeinterlaceFilter.Yadif ? "yadif"
: export.Task.DeinterlaceFilter == DeinterlaceFilter.Bwdif ? "bwdif" : "off";
preset.PictureDeinterlacePreset = export.Task.DeinterlacePreset?.ShortName;
preset.PictureDeinterlaceCustom = export.Task.CustomDeinterlaceSettings;
preset.PictureCombDetectPreset = EnumHelper <CombDetect> .GetShortName(export.Task.CombDetect);
preset.PictureCombDetectCustom = export.Task.CustomCombDetect;
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;
preset.PictureSharpenFilter = EnumHelper <Sharpen> .GetShortName(export.Task.Sharpen);
preset.PictureSharpenPreset = export.Task.SharpenPreset != null ? export.Task.SharpenPreset.Key : string.Empty;
preset.PictureSharpenTune = export.Task.SharpenTune != null ? export.Task.SharpenTune.Key : string.Empty;
preset.PictureSharpenCustom = export.Task.SharpenCustom;
preset.PictureColorspacePreset = export.Task.Colourspace?.Key;
preset.PictureColorspaceCustom = export.Task.CustomColourspace;
preset.PictureChromaSmoothPreset = export.Task.ChromaSmooth?.Key;
preset.PictureChromaSmoothTune = export.Task.ChromaSmoothTune?.Key;
preset.PictureChromaSmoothCustom = export.Task.CustomChromaSmooth;
// Video
preset.VideoEncoder = EnumHelper <VideoEncoder> .GetShortName(export.Task.VideoEncoder);
preset.VideoFramerate = export.Task.Framerate.HasValue ? export.Task.Framerate.ToString() : null;
preset.VideoFramerateMode = EnumHelper <FramerateMode> .GetShortName(export.Task.FramerateMode);
preset.VideoGrayScale = export.Task.Grayscale;
preset.VideoLevel = export.Task.VideoLevel != null ? export.Task.VideoLevel.ShortName : null;
preset.VideoOptionExtra = export.Task.ExtraAdvancedArguments;
preset.VideoPreset = export.Task.VideoPreset != null ? export.Task.VideoPreset.ShortName : null;
preset.VideoProfile = export.Task.VideoProfile != null ? export.Task.VideoProfile.ShortName : null;
preset.VideoQualitySlider = export.Task.Quality.HasValue ? export.Task.Quality.Value : 0;
preset.VideoQualityType = (int)export.Task.VideoEncodeRateType;
preset.VideoScaler = EnumHelper <VideoScaler> .GetShortName(VideoScaler.Lanczos);
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;
// Unknown
preset.ChildrenArray = new List <object>();
preset.Folder = false;
preset.FolderOpen = false;
return(preset);
}
/// <summary>
/// Load in the Built-in and User presets into the collection
/// </summary>
private void LoadPresets()
{
// First clear the Presets arraylists
this.presets.Clear();
// Load the presets file.
try
{
// If we don't have a presets file. Create one for first load.
if (!File.Exists(this.presetFile))
{
// If this is a nightly, and we don't have a presets file, try port the main version if it exists.
string releasePresetFile = Path.Combine(DirectoryUtilities.GetUserStoragePath(false), "presets.json");
if (VersionHelper.IsNightly() && File.Exists(releasePresetFile))
{
File.Copy(releasePresetFile, DirectoryUtilities.GetUserStoragePath(true));
}
else
{
this.UpdateBuiltInPresets();
return; // Update built-in presets stores the presets locally, so just return.
}
}
// Otherwise, we already have a file, so lets try load it.
PresetTransportContainer container = null;
using (StreamReader reader = new StreamReader(this.presetFile))
{
try
{
container = JsonConvert.DeserializeObject <PresetTransportContainer>(reader.ReadToEnd());
}
catch (Exception exc)
{
Debug.WriteLine("Failed to parse presets file: " + exc);
}
}
// Sanity Check. Did the container deserialise.
if (container == null || container.PresetList == null)
{
string filename = this.RecoverFromCorruptedPresetFile(this.presetFile);
this.errorService.ShowMessageBox(
Resources.PresetService_UnableToLoadPresets + filename,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Exclamation);
this.UpdateBuiltInPresets();
return; // Update built-in presets stores the presets locally, so just return.
}
// Version Check
// If we have old presets, or the container wasn't parseable, or we have a version mismatch, backup the user preset file
// incase something goes wrong and reset built-in presets, then re-save.
if (container.VersionMajor != Constants.PresetVersionMajor || container.VersionMinor != Constants.PresetVersionMinor || container.VersionMicro != Constants.PresetVersionMicro)
{
string fileName = this.ArchivePresetFile(this.presetFile);
this.errorService.ShowMessageBox(
Resources.PresetService_PresetsOutOfDate
+ Environment.NewLine + Environment.NewLine + Resources.PresetService_ArchiveFile + fileName,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Exclamation);
this.UpdateBuiltInPresets(); // Update built-in presets stores the presets locally, so just return.
return;
}
// Force Upgrade of presets
if (this.userSettingService.GetUserSetting <int>(UserSettingConstants.ForcePresetReset) < ForcePresetReset)
{
this.userSettingService.SetUserSetting(UserSettingConstants.ForcePresetReset, ForcePresetReset);
string fileName = this.ArchivePresetFile(this.presetFile);
this.errorService.ShowMessageBox(
Resources.Presets_PresetForceReset
+ Environment.NewLine + Environment.NewLine + Resources.PresetService_ArchiveFile + fileName,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Exclamation);
this.UpdateBuiltInPresets(); // Update built-in presets stores the presets locally, so just return.
return;
}
// The presets file loaded was OK, so process it.
foreach (var item in container.PresetList)
{
object deserialisedItem = JsonConvert.DeserializeObject <PresetCategory>(item.ToString());
// Handle Categorised Presets.
PresetCategory category = deserialisedItem as PresetCategory;
if (category != null && category.Folder)
{
foreach (HBPreset hbpreset in category.ChildrenArray)
{
Preset preset = JsonPresetFactory.ImportPreset(hbpreset);
// Migration
if (category.PresetName == "User Presets")
{
preset.Category = UserPresetCatgoryName;
}
else
{
preset.Category = category.PresetName;
}
preset.IsBuildIn = hbpreset.Type == 0;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
this.Add(preset, true);
}
}
// Uncategorised Presets
deserialisedItem = JsonConvert.DeserializeObject <HBPreset>(item.ToString());
HBPreset hbPreset = deserialisedItem as HBPreset;
if (hbPreset != null && !hbPreset.Folder)
{
Preset preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = UserPresetCatgoryName;
preset.IsBuildIn = hbPreset.Type == 1;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
this.Add(preset, true);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
this.RecoverFromCorruptedPresetFile(this.presetFile);
this.UpdateBuiltInPresets();
}
}
/// <summary>
/// The import.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
public void Import(string filename)
{
// TODO needs a tidy up but will do for now.
if (!string.IsNullOrEmpty(filename))
{
PresetTransportContainer container = HandBrakePresetService.GetPresetFromFile(filename);
if (container == null || container.PresetList == null || container.PresetList.Count == 0)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, string.Empty);
return;
}
HBPreset hbPreset = container.PresetList.FirstOrDefault();
Preset preset = null;
try
{
preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = UserPresetCatgoryName;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
}
catch (Exception exc)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, exc);
}
if (preset == null)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, string.Empty);
return;
}
// TODO Better version checking.
if (this.CheckIfPresetExists(preset.Name))
{
if (!CanUpdatePreset(preset.Name))
{
MessageBox.Show(Resources.Main_PresetErrorBuiltInName, Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
MessageBoxResult result = MessageBox.Show(Resources.Main_PresetOverwriteWarning, Resources.Overwrite, MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (result == MessageBoxResult.Yes)
{
Update(preset);
}
}
else
{
Add(preset);
}
}
}
