public override void CheckSetup(Preset preset, Table table)
{
preset.CardCards[this] = new CardCollection();
// Grab all of the Black Market Supply cards and stick them into the CardCards for Black Market
foreach (Type cardType in table.SpecialPiles[TypeClass.BlackMarketSupply].CardTypes)
preset.CardCards[this].Add(Card.CreateInstance(cardType));
}
/// <summary>
/// Encodes a video and audio file.
/// </summary>
/// <param name="id">An ID used to track the item being encoded.</param>
/// <param name="preset">The preset used to encode the given file.</param>
/// <param name="file">The location of the file to encode.</param>
/// <param name="command">The command used to tell Handbrake how to encode the video.</param>
/// <param name="progress">The callback function fired when progress of a file's encoding is updated. The action is given the percentage complete.</param>
/// <param name="complete">The callback function fired when encoding is complete. The action is given the location of the encoded file.</param>
/// <returns>An ID used to track the item being encoded.</returns>
public void Encode(Guid id, Preset preset, string file, string command, Action<EncodingMovieTask, double> progress, Action<EncodingMovieTask> complete)
{
if (string.IsNullOrEmpty(file))
throw new ArgumentNullException("file");
if (!System.IO.File.Exists(file))
throw new FileNotFoundException(file);
command = string.Format(command, "\"" + file + "\"", id.ToString("N") + ".mp4" + PresetIndicator.Get(preset));
var task = new EncodingMovieTask {ID = id, File = file, PercentComplete = 0};
Logger.Info("Beginning encoding: " + command);
new Thread(() => {
var process = new Process();
process.StartInfo.FileName = @"c:\Code\showveoservice\ShowveoService.MVCApplication\Resources\HandbrakeCLI.exe";
process.StartInfo.Arguments = command;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.UseShellExecute = false;
process.OutputDataReceived += (sender, args) => OnDataReceived(progress, task, args);
process.ErrorDataReceived += (sender, args) => OnErrorReceived(args);
process.Exited += (sender, args) => complete.Invoke(task);
process.Start();
process.BeginOutputReadLine();
while (!process.HasExited) {}
}).Start();
}
public LightPresets(LightConfiguration l)
{
lc = l;
/*Preset p1 = new Preset();
p1.p_name = "LightPresets.Inside";
p1.l_intensity = 0.2f;
p1.s_blur = 3f;
p1.s_power = 0.9f;
p1.r_id = 1;
p1.r_rate = 0;
p1.imgBackground_r = 128;
p1.imgBackground_g = 128;
p1.imgBackground_b = 128;
p1.id = 0;*/
Preset p2 = new Preset();
p2.p_name = "LightPresets.LightingOutdoor";
p2.l_intensity = 0.3f;
p2.s_blur = 2.8f;
p2.s_power = 0.4f;
p2.r_id = 6;
p2.r_rate = 0;
p2.imgBackground_r = 128;
p2.imgBackground_g = 128;
p2.imgBackground_b = 128;
p2.id = 1;
Preset p3 = new Preset();
p3.p_name = "LightPresets.CloudyOutdoor";
p3.l_intensity = 0.2f;
p3.s_blur = 6f;
p3.s_power = 0.8f;
p3.r_id = 6;
p3.r_rate = 0;
p3.imgBackground_r = 128;
p3.imgBackground_g = 128;
p3.imgBackground_b = 128;
p3.id = 2;
Preset p4 = new Preset();
p4.p_name = "LightPresets.Night";
p4.l_intensity = 0.05f;
p4.s_blur = 6f;
p4.s_power = 1.0f;
p4.r_id = 6;
p4.r_rate = 0;
p4.imgBackground_r = 33;
p4.imgBackground_g = 44;
p4.imgBackground_b = 80;
p4.id = 3;
//presetsList.Add(p1);
presetsList.Add(p2);
presetsList.Add(p3);
presetsList.Add(p4);
}
public void DisablePreset(Preset preset)
{
foreach (var mod in preset)
{
modManager.DisableMod(mod);
}
preset.IsEnabled = false;
UpdatePreset(preset);
}
public void EnablePreset(Preset preset)
{
foreach (var mod in preset)
{
modManager.EnableMod(mod);
}
preset.IsEnabled = true;
UpdatePreset(preset);
}
/// <summary>Creates a new preset view model.</summary>
public PresetViewModel(Preset preset, ModManager modManager, PresetManager presetManager)
{
this.modManager = modManager;
this.presetManager = presetManager;
Preset = preset;
RenameCommand = new Command(Rename);
DisbandCommand = new Command(Disband);
}
/// <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>
/// Creates an encoder based on a preset.
/// </summary>
/// <param name="preset">The preset used to generate the appropriate encoder.</param>
/// <returns>The created encoder.</returns>
public IEncoder Create(Preset preset)
{
switch (preset)
{
case Preset.Phone: return new PhoneHandbrakeEncoder(_configuration);
case Preset.TV: return new TVHandbrakeEncoder(_configuration);
case Preset.Tablet: return new TabletHandbrakeEncoder(_configuration);
}
throw new ArgumentException("The preset " + preset + " has no implementation.");
}
public static string Get(Preset preset)
{
switch (preset)
{
case Preset.Phone: return ".phone";
case Preset.Tablet: return ".tablet";
case Preset.TV: return ".tv";
}
throw new InvalidOperationException("No indicator exists for preset \"" + preset + "\".");
}
//
void SetPresetSettings(Preset p)
{
HighlightingBase hb = FindObjectOfType<HighlightingBase>();
if (hb == null) { return; }
hb.downsampleFactor = p.downsampleFactor;
hb.iterations = p.iterations;
hb.blurMinSpread = p.blurMinSpread;
hb.blurSpread = p.blurSpread;
hb.blurIntensity = p.blurIntensity;
}
void ApplyPreset( Preset ps )
{
m_idTexture = ps.m_idTexture;
m_idMask = ps.m_idMask;
GetComponent<Renderer>().material.SetTexture("_MainTex", m_textureList[m_idTexture]);
GetComponent<Renderer>().material.SetTexture("_MaskTex", m_maskList[m_idMask]);
GetComponent<Renderer>().material.SetFloat( "_Emission", ps.m_Emission );
GetComponent<Renderer>().material.SetFloat( "_Alpha", ps.m_Alpha );
GetComponent<Renderer>().material.SetFloat( "_AlphaCutOffMask", ps.m_AlphaCutOffMask );
GetComponent<Renderer>().material.SetFloat( "_AlphaCutOffSmooth", ps.m_AlphaCutOffSmooth );
GetComponent<Renderer>().material.SetFloat( "_AlphaMask", ps.m_AlphaMask );
}
public void AddModToPreset(Mod mod, Preset preset)
{
if (!ModIsInAPreset(mod))
{
preset.Add(mod);
if (mod.IsEnabled != preset.IsEnabled)
{
modManager.ToggleEnabled(mod);
}
SavePreset(preset);
LoadModsBuffer();
}
}
public void SetForce(float max, float min)
{
if (max == preset.maxForce && min == preset.minForce) return;
Preset newP = new Preset();
newP.in_curve = preset.in_curve;
newP.out_curve = preset.out_curve;
newP.in_time = preset.in_time;
newP.out_time = preset.out_time;
newP.maxForce = max;
newP.minForce = min;
ChangePreset(newP);
}
protected void btnSave_Click(object sender, EventArgs e)
{
var p = new Preset
{
ID = 0,
Name = txtCropName.Text,
IdealTemperature = Convert.ToInt32(txtIdealTemp.Text),
TemperatureThreshold = Convert.ToInt32(txtTempRange.Text),
IdealLightIntensity = Convert.ToInt32(txtLightRange.Text),
LightIntensityThreshold = Convert.ToInt32(txtLightRange.Text),
IdealHumidity = Convert.ToInt32(txtHumidity.Text),
HumidityThreshold = Convert.ToInt32(txtHumidityRange.Text),
IdealWaterLevel = Convert.ToInt32(txtWaterLevel.Text),
WaterLevelThreshold = Convert.ToInt32(txtWaterThreshold.Text)
};
p.Save();
}
public void AssignChanges(Preset preset)
{
foreach (KeyValuePair<PawnData, Preset> pair in PresetDatabase.assignedPresets)
{
if (!pawns.Exists(pawn => pawn.ThingID == pair.Key.ID))
{
PresetDatabase.assignedPresets.Remove(pair.Key);
}
else if (pair.Value.Name == preset.Name)
{
foreach (WorkTypeDef job in VisibleWorkTypeDefsInPriorityOrder)
{
pawns.Find(pawn => pawn.ThingID == pair.Key.ID);
if (!pawns.Find(pawn => pawn.ThingID == pair.Key.ID).story.WorkTypeIsDisabled(job))
pawns.Find(pawn => pawn.ThingID == pair.Key.ID).workSettings.SetPriority(job, preset.priorities[job]);
}
}
}
}
private void btnAddPreset_Click(object sender, EventArgs e)
{
try
{
MouseClicker.InputBox iBox = new MouseClicker.InputBox("Define preset name", "My preset");
if (iBox.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
Preset p = new Preset(iBox.Value, "", "", "");
_presets.Add(p);
DisplayPresets();
cboPresets.SelectedItem = p;
SavePresets();
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
protected override void OnRenderImage(RenderTexture source, RenderTexture destination)
{
if (Palette != m_CurrentPreset)
{
m_CurrentPreset = Palette;
if (Palette == Preset.None)
LookupTexture = null;
else
LookupTexture = Resources.Load<Texture2D>("LoFiPalettes/" + Palette.ToString());
}
if (LookupTexture == null || Amount <= 0f)
{
Graphics.Blit(source, destination);
return;
}
if (m_Use2DLut || ForceCompatibility)
RenderLut2D(source, destination);
else
RenderLut3D(source, destination);
}
protected override void OnRenderImage(RenderTexture source, RenderTexture destination)
{
if (Palette != m_CurrentPreset)
{
m_CurrentPreset = Palette;
if (Palette == Preset.None)
LookupTexture = null;
else
LookupTexture = Resources.Load<Texture2D>("LoFiPalettes/" + Palette.ToString());
}
if (LookupTexture == null)
{
Graphics.Blit(source, destination);
return;
}
if (LookupTexture.name != m_BaseTextureName)
ConvertBaseTexture();
if (m_Lut3D == null)
SetIdentityLut();
m_Lut3D.filterMode = FilterMode.Point;
Material.SetTexture("_LookupTex", m_Lut3D);
float lutSize = (float)m_Lut3D.width;
Material.SetVector("_Params", new Vector4(
(lutSize - 1f) / (1f * lutSize),
1f / (2f * lutSize),
Amount,
PixelSize
));
int pass = (Pixelize ? 2 : 0) + (CLib.IsLinearColorSpace() ? 1 : 0);
Graphics.Blit(source, destination, Material, pass);
}
/// <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 "strict":
preset.Task.Anamorphic = Anamorphic.Strict;
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.Fast;
preset.Task.DeinterlaceFilter = DeinterlaceFilter.Decomb;
break;
case "deinterlace":
preset.Task.Decomb = Decomb.Default;
preset.Task.Deinterlace = Deinterlace.Fast;
preset.Task.DeinterlaceFilter = DeinterlaceFilter.Deinterlace;
break;
default:
preset.Task.Decomb = Decomb.Default;
preset.Task.Deinterlace = Deinterlace.Fast;
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 "fast":
preset.Task.Decomb = Decomb.Fast;
break;
default:
preset.Task.Decomb = Decomb.Default;
break;
}
if (preset.Task.Decomb == Decomb.Custom)
{
preset.Task.CustomDecomb = importedPreset.PictureDeinterlaceCustom;
}
}
if (preset.Task.DeinterlaceFilter == DeinterlaceFilter.Deinterlace)
{
switch (importedPreset.PictureDeinterlaceFilter)
{
case "custom":
preset.Task.Deinterlace = Deinterlace.Custom;
break;
case "bob":
preset.Task.Deinterlace = Deinterlace.Bob;
break;
case "fast":
preset.Task.Deinterlace = Deinterlace.Fast;
break;
case "slow":
preset.Task.Deinterlace = Deinterlace.Slow;
break;
case "slower":
preset.Task.Deinterlace = Deinterlace.Slower;
break;
default:
preset.Task.Deinterlace = Deinterlace.Fast;
break;
}
if (preset.Task.Deinterlace == Deinterlace.Custom)
{
preset.Task.CustomDecomb = importedPreset.PictureDeinterlaceCustom;
}
}
preset.Task.CustomDeinterlace = importedPreset.PictureDetelecineCustom;
preset.Task.CustomDenoise = importedPreset.PictureDenoiseCustom;
preset.Task.CustomDetelecine = importedPreset.PictureDetelecineCustom;
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)
{
foreach (var item in importedPreset.AudioCopyMask)
{
AudioEncoder encoder = EnumHelper<AudioEncoder>.GetValue(item.ToString());
switch (encoder)
{
case AudioEncoder.AacPassthru:
preset.Task.AllowedPassthruOptions.AudioAllowAACPass = true;
break;
case AudioEncoder.Ac3Passthrough:
preset.Task.AllowedPassthruOptions.AudioAllowAACPass = true;
break;
case AudioEncoder.EAc3Passthrough:
preset.Task.AllowedPassthruOptions.AudioAllowAACPass = true;
break;
case AudioEncoder.DtsHDPassthrough:
preset.Task.AllowedPassthruOptions.AudioAllowAACPass = true;
break;
case AudioEncoder.DtsPassthrough:
preset.Task.AllowedPassthruOptions.AudioAllowAACPass = true;
break;
case AudioEncoder.FlacPassthru:
preset.Task.AllowedPassthruOptions.AudioAllowAACPass = true;
break;
case AudioEncoder.Mp3Passthru:
preset.Task.AllowedPassthruOptions.AudioAllowAACPass = 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)
{
AudioTrack track = new AudioTrack();
track.Bitrate = audioTrack.AudioBitrate;
// track.CompressionLevel = audioTrack.AudioCompressionLevel;
// track.AudioDitherMethod = audioTrack.AudioDitherMethod;
track.Encoder = EnumHelper<AudioEncoder>.GetValue(audioTrack.AudioEncoder);
track.MixDown = EnumHelper<Mixdown>.GetValue(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.Task.AudioTracks.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;
}
private static Tuple<double, double>[] GetPreset(Preset preset, int count)
{
switch (preset)
{
case Preset.Simple_Up:
#region Simple_Up
return GetXs(count).
Select(o => Tuple.Create(o, o)).
ToArray();
#endregion
case Preset.Simple_Down:
#region Simple_Down
return ReverseY(GetPreset(Preset.Simple_Up, count));
#endregion
case Preset.Cube_Up:
#region Cube
return GetXs(count).
Select(o => Tuple.Create(o, o * o * o)).
ToArray();
#endregion
case Preset.Cube_Down:
#region Cube_Down
return ReverseX(GetPreset(Preset.Cube_Up, count));
#endregion
case Preset.CubeRoot_Up:
#region CubeRoot
return ReverseX(GetPreset(Preset.CubeRoot_Down, count));
#endregion
case Preset.CubeRoot_Down:
#region CubeRoot_Down
return ReverseY(GetPreset(Preset.Cube_Up, count));
#endregion
case Preset.S_Curve_Up:
#region S_Curve_Up
return GetXs(count).
Select(o => Tuple.Create(o, (-Math.Cos(o * Math.PI) * .5) + .5)).
ToArray();
#endregion
case Preset.S_Curve_Down:
#region S_Curve_Down
return ReverseY(GetPreset(Preset.S_Curve_Up, count));
#endregion
default:
throw new ApplicationException("Unknown Preset: " + preset.ToString());
}
}
/// <summary>
/// Setup this window for a new source
/// </summary>
/// <param name="source">
/// The source.
/// </param>
/// <param name="title">
/// The title.
/// </param>
/// <param name="preset">
/// The preset.
/// </param>
/// <param name="task">
/// The task.
/// </param>
public void SetSource(Source source, Title title, Preset preset, EncodeTask task)
{
this.Task = task;
this.NotifyOfPropertyChange(() => this.AdvancedOptionsString);
}
/// <summary>
/// Update a preset
/// </summary>
/// <param name="update">
/// The updated preset
/// </param>
public void Update(Preset update)
{
// TODO - Change this to be a lookup
foreach (Preset preset in this.presets)
{
if (preset.Name == update.Name)
{
preset.Task = update.Task;
preset.PictureSettingsMode = update.PictureSettingsMode;
preset.Category = update.Category;
preset.Description = update.Description;
preset.AudioTrackBehaviours = update.AudioTrackBehaviours;
preset.SubtitleTrackBehaviours = update.SubtitleTrackBehaviours;
// Update the presets file
this.SavePresetFiles();
break;
}
}
}
/// <summary>
/// Remove a preset with a given name from either the built in or user preset list.
/// </summary>
/// <param name="preset">
/// The Preset to remove
/// </param>
public void Remove(Preset preset)
{
if (preset == null || preset.IsDefault)
{
return;
}
this.presets.Remove(preset);
this.SavePresetFiles();
}
/// <summary>
/// Setup this window for a new source
/// </summary>
/// <param name="source">
/// The source.
/// </param>
/// <param name="title">
/// The title.
/// </param>
/// <param name="preset">
/// The preset.
/// </param>
/// <param name="task">
/// The task.
/// </param>
public void SetSource(Source source, Title title, Preset preset, EncodeTask task)
{
this.currentTitle = title;
this.Task = task;
this.scannedSource = source;
if (title != null)
{
// Set cached info
this.sourceParValues = title.ParVal;
this.sourceResolution = title.Resolution;
// Update the cropping values, preffering those in the presets.
if (!preset.Task.HasCropping)
{
this.Task.Cropping.Top = title.AutoCropDimensions.Top;
this.Task.Cropping.Bottom = title.AutoCropDimensions.Bottom;
this.Task.Cropping.Left = title.AutoCropDimensions.Left;
this.Task.Cropping.Right = title.AutoCropDimensions.Right;
this.IsCustomCrop = false;
}
else
{
this.Task.Cropping.Left = preset.Task.Cropping.Left;
this.Task.Cropping.Right = preset.Task.Cropping.Right;
this.Task.Cropping.Top = preset.Task.Cropping.Top;
this.Task.Cropping.Bottom = preset.Task.Cropping.Bottom;
this.IsCustomCrop = true;
}
if (preset.PictureSettingsMode == PresetPictureSettingsMode.None)
{
// We have no instructions, so simply set it to the source.
this.Task.Width = this.GetModulusValue(this.sourceResolution.Width - this.CropLeft - this.CropRight);
this.MaintainAspectRatio = true;
}
else
{
// Set the Max Width / Height available to the user controls
if (this.sourceResolution.Width < this.MaxWidth)
{
this.MaxWidth = this.sourceResolution.Width;
}
else if (this.sourceResolution.Width > this.MaxWidth)
{
this.MaxWidth = preset.Task.MaxWidth ?? this.sourceResolution.Width;
}
if (this.sourceResolution.Height < this.MaxHeight)
{
this.MaxHeight = this.sourceResolution.Height;
}
else if (this.sourceResolution.Height > this.MaxHeight)
{
this.MaxHeight = preset.Task.MaxHeight ?? this.sourceResolution.Height;
}
// Set the Width, and Maintain Aspect ratio. That should calc the Height for us.
if (this.SelectedAnamorphicMode == Anamorphic.None)
{
this.Task.Width = preset.Task.Width ?? (this.MaxWidth - this.CropLeft - this.CropRight);
// Note: This will be auto-corrected in the property if it's too large.
}
else
{
this.Task.Width = preset.Task.Width ?? this.MaxWidth;
int cropHeight = this.Task.Cropping.Top + this.Task.Cropping.Bottom;
this.Task.Height = (preset.Task.Height ?? this.MaxHeight) - cropHeight;
}
// If our height is too large, let it downscale the width for us by setting the height to the lower value.
if (!this.MaintainAspectRatio && this.Height > this.MaxHeight)
{
this.Task.Height = this.MaxHeight;
}
}
// Set Screen Controls
this.SourceInfo = string.Format(
"{0}x{1}, PAR: {2}/{3}",
title.Resolution.Width,
title.Resolution.Height,
title.ParVal.Width,
title.ParVal.Height);
this.RecaulcatePictureSettingsProperties(ChangedPictureField.Width);
}
this.NotifyOfPropertyChange(() => this.Task);
}
/// <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;
if (!string.IsNullOrEmpty(importedPreset.PictureDeblockPreset))
{
preset.Task.DeblockPreset = new FilterPreset(HandBrakeFilterHelpers.GetFilterPresets((int)hb_filter_ids.HB_FILTER_DEBLOCK).FirstOrDefault(s => s.ShortName == importedPreset.PictureDeblockPreset));
}
else
{
preset.Task.DeblockPreset = new FilterPreset("Off", "off");
}
if (!string.IsNullOrEmpty(importedPreset.PictureDeblockTune))
{
preset.Task.DeblockTune = new FilterTune(HandBrakeFilterHelpers.GetFilterTunes((int)hb_filter_ids.HB_FILTER_DEBLOCK).FirstOrDefault(s => s.ShortName == importedPreset.PictureDeblockTune));
}
else
{
preset.Task.DeblockTune = new FilterTune("Off", "off");
}
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 ShaderAdapterBuilder SetProperties(Preset preset)
{
_preset = preset;
return(this);
}
public void SetSource(Source source, Title title, Preset preset, EncodeTask task)
{
this.CurrentTask = task;
}
public EmulationSlot(uint slotNumber, XboxGamepad gamepad, Keyboard keyboard, Mouse mouse, Preset preset)
: base(slotNumber, gamepad, keyboard, mouse, preset)
{
this.InitializeComponent();
if (gamepad.Exsists)
{
this.InvalidateReason = SlotInvalidationReason.Controller_Already_Plugged_In;
}
}
public IEnumerator Export(string path, Preset presetAsset, bool buildZip, bool exportPBRMaterials, bool exportAnimation = true, bool doConvertImages = false, bool halfSpotAngle = true, bool quadraticAttenuation = true)
{
writer = new GlTF_Writer();
writer.Init();
done = false;
bool debugRightHandedScale = false;
GlTF_Writer.exportedFiles.Clear();
if (debugRightHandedScale)
{
GlTF_Writer.convertRightHanded = false;
}
writer.extraString.Add("exporterVersion", GlTF_Writer.exporterVersion);
// Create rootNode
GlTF_Node correctionNode = new GlTF_Node();
correctionNode.id = "root";
correctionNode.uuid = GlTF_Node.GetIDFromObject(correctionNode);
correctionNode.name = "root";
GlTF_Writer.nodes.Add(correctionNode);
GlTF_Writer.nodeIDs.Add(correctionNode.uuid);
GlTF_Writer.rootNodes.Add(correctionNode);
//path = toGlTFname(path);
savedPath = Path.GetDirectoryName(path);
// Temp list to keep track of skeletons
Dictionary <string, GlTF_Skin> parsedSkins = new Dictionary <string, GlTF_Skin>();
parsedSkins.Clear();
// first, collect objects in the scene, add to lists
Transform[] transforms = Selection.GetTransforms(SelectionMode.Deep);
List <Transform> trs = new List <Transform>(transforms);
// Prefilter selected nodes and look for skinning in order to list "bones" nodes
//FIXME: improve this
List <Transform> bones = new List <Transform>();
foreach (Transform tr in trs)
{
if (!tr.gameObject.activeSelf)
{
continue;
}
SkinnedMeshRenderer skin = tr.GetComponent <SkinnedMeshRenderer>();
if (skin)
{
foreach (Transform bone in skin.bones)
{
bones.Add(bone);
}
}
}
nbSelectedObjects = trs.Count;
int nbDisabledObjects = 0;
foreach (Transform tr in trs)
{
if (tr.gameObject.activeInHierarchy == false)
{
nbDisabledObjects++;
continue;
}
// Initialize the node
GlTF_Node node = new GlTF_Node();
node.id = GlTF_Node.GetNameFromObject(tr);
node.uuid = GlTF_Node.GetIDFromObject(tr);
node.name = GlTF_Writer.cleanNonAlphanumeric(tr.name);
if (tr.GetComponent <Camera>() != null)
{
GlTF_Camera cam = parseUnityCamera(tr);
node.cameraIndex = GlTF_Writer.cameras.IndexOf(cam);
}
if (tr.GetComponent <Light>() != null)
{
GlTF_Light l = parseUnityLight(tr, halfSpotAngle, quadraticAttenuation);
node.lightName = GlTF_Writer.cleanNonAlphanumeric(tr.name);
node.lightIndex = GlTF_Writer.lights.IndexOf(l);
}
Mesh m = GetMesh(tr);
if (m != null)
{
GlTF_Mesh mesh = new GlTF_Mesh();
mesh.name = GlTF_Writer.cleanNonAlphanumeric(GlTF_Mesh.GetNameFromObject(m) + tr.name);
GlTF_Accessor positionAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "position"), GlTF_Accessor.Type.VEC3, GlTF_Accessor.ComponentType.FLOAT);
positionAccessor.bufferView = GlTF_Writer.vec3BufferView;
GlTF_Writer.accessors.Add(positionAccessor);
GlTF_Accessor normalAccessor = null;
if (m.normals.Length > 0)
{
normalAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "normal"), GlTF_Accessor.Type.VEC3, GlTF_Accessor.ComponentType.FLOAT);
normalAccessor.bufferView = GlTF_Writer.vec3BufferView;
GlTF_Writer.accessors.Add(normalAccessor);
}
GlTF_Accessor colorAccessor = null;
if (m.colors.Length > 0)
{
colorAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "color"), GlTF_Accessor.Type.VEC4, GlTF_Accessor.ComponentType.FLOAT);
colorAccessor.bufferView = GlTF_Writer.vec4BufferView;
GlTF_Writer.accessors.Add(colorAccessor);
}
GlTF_Accessor uv0Accessor = null;
if (m.uv.Length > 0)
{
uv0Accessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv0"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
uv0Accessor.bufferView = GlTF_Writer.vec2BufferView;
GlTF_Writer.accessors.Add(uv0Accessor);
}
GlTF_Accessor uv1Accessor = null;
if (m.uv2.Length > 0)
{
// check if object is affected by a lightmap
uv1Accessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv1"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
uv1Accessor.bufferView = GlTF_Writer.vec2BufferView;
GlTF_Writer.accessors.Add(uv1Accessor);
}
GlTF_Accessor uv2Accessor = null;
if (m.uv3.Length > 0)
{
uv2Accessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv2"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
uv2Accessor.bufferView = GlTF_Writer.vec2BufferView;
GlTF_Writer.accessors.Add(uv2Accessor);
}
GlTF_Accessor uv3Accessor = null;
if (m.uv4.Length > 0)
{
uv3Accessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv3"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
uv3Accessor.bufferView = GlTF_Writer.vec2BufferView;
GlTF_Writer.accessors.Add(uv3Accessor);
}
GlTF_Accessor jointAccessor = null;
if (exportAnimation && m.boneWeights.Length > 0)
{
jointAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "joints"), GlTF_Accessor.Type.VEC4, GlTF_Accessor.ComponentType.USHORT);
jointAccessor.bufferView = GlTF_Writer.vec4UshortBufferView;
GlTF_Writer.accessors.Add(jointAccessor);
}
GlTF_Accessor weightAccessor = null;
if (exportAnimation && m.boneWeights.Length > 0)
{
weightAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "weights"), GlTF_Accessor.Type.VEC4, GlTF_Accessor.ComponentType.FLOAT);
weightAccessor.bufferView = GlTF_Writer.vec4BufferView;
GlTF_Writer.accessors.Add(weightAccessor);
}
GlTF_Accessor tangentAccessor = null;
if (m.tangents.Length > 0)
{
tangentAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "tangents"), GlTF_Accessor.Type.VEC4, GlTF_Accessor.ComponentType.FLOAT);
tangentAccessor.bufferView = GlTF_Writer.vec4BufferView;
GlTF_Writer.accessors.Add(tangentAccessor);
}
var smCount = m.subMeshCount;
for (var i = 0; i < smCount; ++i)
{
GlTF_Primitive primitive = new GlTF_Primitive();
primitive.name = GlTF_Primitive.GetNameFromObject(m, i);
primitive.index = i;
GlTF_Attributes attributes = new GlTF_Attributes();
attributes.positionAccessor = positionAccessor;
attributes.normalAccessor = normalAccessor;
attributes.colorAccessor = colorAccessor;
attributes.texCoord0Accessor = uv0Accessor;
attributes.texCoord1Accessor = uv1Accessor;
attributes.texCoord2Accessor = uv2Accessor;
attributes.texCoord3Accessor = uv3Accessor;
attributes.jointAccessor = jointAccessor;
attributes.weightAccessor = weightAccessor;
attributes.tangentAccessor = tangentAccessor;
primitive.attributes = attributes;
GlTF_Accessor indexAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "indices_" + i), GlTF_Accessor.Type.SCALAR, GlTF_Accessor.ComponentType.USHORT);
indexAccessor.bufferView = GlTF_Writer.ushortBufferView;
GlTF_Writer.accessors.Add(indexAccessor);
primitive.indices = indexAccessor;
var mr = GetRenderer(tr);
var sm = mr.sharedMaterials;
if (i < sm.Length)
{
var mat = sm[i];
var matName = GlTF_Material.GetNameFromObject(mat);
if (GlTF_Writer.materialNames.Contains(matName))
{
primitive.materialIndex = GlTF_Writer.materialNames.IndexOf(matName); // THIS INDIRECTION CAN BE REMOVED!
}
else
{
GlTF_Material material = new GlTF_Material();
material.name = GlTF_Writer.cleanNonAlphanumeric(mat.name);
primitive.materialIndex = GlTF_Writer.materials.Count;
GlTF_Writer.materialNames.Add(matName);
GlTF_Writer.materials.Add(material);
//technique
var s = mat.shader;
var techName = GlTF_Technique.GetNameFromObject(s);
if (GlTF_Writer.techniqueNames.Contains(techName))
{
material.instanceTechniqueIndex = GlTF_Writer.techniqueNames.IndexOf(techName);// THIS INDIRECTION CAN BE REMOVED!
}
else
{
GlTF_Technique tech = new GlTF_Technique();
tech.name = techName;
GlTF_Technique.Parameter tParam = new GlTF_Technique.Parameter();
tParam.name = "position";
tParam.type = GlTF_Technique.Type.FLOAT_VEC3;
tParam.semantic = GlTF_Technique.Semantic.POSITION;
tech.parameters.Add(tParam);
GlTF_Technique.Attribute tAttr = new GlTF_Technique.Attribute();
tAttr.name = "a_position";
tAttr.param = tParam.name;
tech.attributes.Add(tAttr);
if (normalAccessor != null)
{
tParam = new GlTF_Technique.Parameter();
tParam.name = "normal";
tParam.type = GlTF_Technique.Type.FLOAT_VEC3;
tParam.semantic = GlTF_Technique.Semantic.NORMAL;
tech.parameters.Add(tParam);
tAttr = new GlTF_Technique.Attribute();
tAttr.name = "a_normal";
tAttr.param = tParam.name;
tech.attributes.Add(tAttr);
}
if (uv0Accessor != null)
{
tParam = new GlTF_Technique.Parameter();
tParam.name = "texcoord0";
tParam.type = GlTF_Technique.Type.FLOAT_VEC2;
tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_0;
tech.parameters.Add(tParam);
tAttr = new GlTF_Technique.Attribute();
tAttr.name = "a_texcoord0";
tAttr.param = tParam.name;
tech.attributes.Add(tAttr);
}
if (uv1Accessor != null)
{
tParam = new GlTF_Technique.Parameter();
tParam.name = "texcoord1";
tParam.type = GlTF_Technique.Type.FLOAT_VEC2;
tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_1;
tech.parameters.Add(tParam);
tAttr = new GlTF_Technique.Attribute();
tAttr.name = "a_texcoord1";
tAttr.param = tParam.name;
tech.attributes.Add(tAttr);
}
if (uv2Accessor != null)
{
tParam = new GlTF_Technique.Parameter();
tParam.name = "texcoord2";
tParam.type = GlTF_Technique.Type.FLOAT_VEC2;
tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_2;
tech.parameters.Add(tParam);
tAttr = new GlTF_Technique.Attribute();
tAttr.name = "a_texcoord2";
tAttr.param = tParam.name;
tech.attributes.Add(tAttr);
}
if (uv3Accessor != null)
{
tParam = new GlTF_Technique.Parameter();
tParam.name = "texcoord3";
tParam.type = GlTF_Technique.Type.FLOAT_VEC2;
tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_3;
tech.parameters.Add(tParam);
tAttr = new GlTF_Technique.Attribute();
tAttr.name = "a_texcoord3";
tAttr.param = tParam.name;
tech.attributes.Add(tAttr);
}
tech.AddDefaultUniforms();
// Populate technique with shader data
GlTF_Writer.techniqueNames.Add(techName);
GlTF_Writer.techniques.Add(tech);
// create program
GlTF_Program program = new GlTF_Program();
program.name = GlTF_Program.GetNameFromObject(s);
tech.program = program.name;
foreach (var attr in tech.attributes)
{
program.attributes.Add(attr.name);
}
GlTF_Writer.programs.Add(program);
}
unityToPBRMaterial(mat, ref material);
}
}
mesh.primitives.Add(primitive);
}
// If gameobject having SkinnedMeshRenderer component has been transformed,
// the mesh would need to be baked here.
mesh.Populate(m);
GlTF_Writer.meshes.Add(mesh);
node.meshIndex = GlTF_Writer.meshes.IndexOf(mesh);
}
// Parse animations
if (exportAnimation)
{
Animator a = tr.GetComponent <Animator>();
if (a != null)
{
AnimationClip[] clips = AnimationUtility.GetAnimationClips(tr.gameObject);
for (int i = 0; i < clips.Length; i++)
{
//FIXME It seems not good to generate one animation per animator.
GlTF_Animation anim = new GlTF_Animation(GlTF_Writer.cleanNonAlphanumeric(clips[i].name));
anim.Populate(clips[i], tr, GlTF_Writer.bakeAnimation);
if (anim.channels.Count > 0)
{
GlTF_Writer.animations.Add(anim);
}
}
}
Animation animation = tr.GetComponent <Animation>();
if (animation != null)
{
AnimationClip clip = animation.clip;
//FIXME It seems not good to generate one animation per animator.
GlTF_Animation anim = new GlTF_Animation(GlTF_Writer.cleanNonAlphanumeric(animation.name));
anim.Populate(clip, tr, GlTF_Writer.bakeAnimation);
if (anim.channels.Count > 0)
{
GlTF_Writer.animations.Add(anim);
}
}
}
// Parse transform
if (tr.parent == null)
{
Matrix4x4 mat = Matrix4x4.identity;
if (debugRightHandedScale)
{
mat.m22 = -1;
}
mat = mat * Matrix4x4.TRS(tr.localPosition, tr.localRotation, tr.localScale);
node.matrix = new GlTF_Matrix(mat, true, tr.GetComponent <Light>() != null);
}
// Use good transform if parent object is not in selection
else if (!trs.Contains(tr.parent))
{
node.hasParent = false;
Matrix4x4 mat = Matrix4x4.identity;
if (debugRightHandedScale)
{
mat.m22 = -1;
}
mat = mat * tr.localToWorldMatrix;
node.matrix = new GlTF_Matrix(mat, true, tr.GetComponent <Light>() != null);
}
else
{
node.hasParent = true;
if (tr.localPosition != Vector3.zero)
{
node.translation = new GlTF_Translation(tr.localPosition);
}
if (tr.localScale != Vector3.one)
{
node.scale = new GlTF_Scale(tr.localScale);
}
if (tr.localRotation != Quaternion.identity)
{
node.rotation = new GlTF_Rotation(tr.localRotation);
}
}
if (!node.hasParent)
{
correctionNode.childrenIDs.Add(node.uuid);
}
if (tr.GetComponent <Camera>() != null)
{
node.cameraName = GlTF_Writer.cleanNonAlphanumeric(tr.name);
}
// Parse node's skin data
GlTF_Accessor invBindMatrixAccessor = null;
SkinnedMeshRenderer skinMesh = tr.GetComponent <SkinnedMeshRenderer>();
if (exportAnimation && skinMesh != null && skinMesh.enabled && checkSkinValidity(skinMesh, trs) && skinMesh.rootBone != null)
{
GlTF_Skin skin = new GlTF_Skin();
skin.name = GlTF_Writer.cleanNonAlphanumeric(skinMesh.rootBone.name) + "_skeleton_" + GlTF_Writer.cleanNonAlphanumeric(node.name) + tr.GetInstanceID();
// Create invBindMatrices accessor
invBindMatrixAccessor = new GlTF_Accessor(skin.name + "invBindMatrices", GlTF_Accessor.Type.MAT4, GlTF_Accessor.ComponentType.FLOAT);
invBindMatrixAccessor.bufferView = GlTF_Writer.mat4BufferView;
GlTF_Writer.accessors.Add(invBindMatrixAccessor);
// Generate skin data
skin.Populate(tr, ref invBindMatrixAccessor, GlTF_Writer.accessors.Count - 1);
GlTF_Writer.skins.Add(skin);
node.skinIndex = GlTF_Writer.skins.IndexOf(skin);
}
foreach (Transform t in tr.transform)
{
if (t.gameObject.activeInHierarchy)
{
node.childrenIDs.Add(GlTF_Node.GetIDFromObject(t));
}
}
GlTF_Writer.nodeIDs.Add(node.uuid);
GlTF_Writer.nodes.Add(node);
}
if (GlTF_Writer.meshes.Count == 0)
{
Debug.Log("No visible objects have been exported. Aboring export");
yield return(false);
}
writer.OpenFiles(path);
writer.Write();
writer.CloseFiles();
if (nbDisabledObjects > 0)
{
Debug.Log(nbDisabledObjects + " disabled object ignored during export");
}
Debug.Log("Scene has been exported to " + path);
if (buildZip)
{
ZipFile zip = new ZipFile();
Debug.Log(GlTF_Writer.exportedFiles.Count + " files generated");
string zipName = Path.GetFileNameWithoutExtension(path) + ".zip";
foreach (string originFilePath in GlTF_Writer.exportedFiles.Keys)
{
zip.AddFile(originFilePath, GlTF_Writer.exportedFiles[originFilePath]);
}
zip.Save(savedPath + "/" + zipName);
// Remove all files
foreach (string pa in GlTF_Writer.exportedFiles.Keys)
{
if (System.IO.File.Exists(pa))
{
System.IO.File.Delete(pa);
}
}
Debug.Log("Files have been cleaned");
}
done = true;
yield return(true);
}
public void ExportCoroutine(string path, Preset presetAsset, bool buildZip, bool exportPBRMaterials, bool exportAnimation = true, bool doConvertImages = true, bool halfSpotAngle = true, bool quadraticAttenuation = true)
{
StartCoroutine(Export(path, presetAsset, buildZip, exportPBRMaterials, exportAnimation, doConvertImages, halfSpotAngle, quadraticAttenuation));
}
public PresetDataViewModel(Preset preset, PresetDataPersisterService presetDataPersisterService, DeveloperService developerService) : base(preset)
{
_developerService = developerService;
_presetDataPersisterService = presetDataPersisterService;
OpenWithHexEditor = new Command(OnOpenWithHexEditor);
}
private void AddToNewPreset()
{
if (Mod.IsInOriginalInstallation())
{
MessageBox.Show("This mod cannot be added to a preset, as it is part of the core of Cortex Command.", "Notice", MessageBoxButton.OK, MessageBoxImage.Exclamation);
return;
}
var addPresetWindow = new AddPresetWindow();
addPresetWindow.Owner = Global.MainWindow;
addPresetWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
var result = (bool)addPresetWindow.ShowDialog();
if (result)
{
var presetName = addPresetWindow.PresetName;
var preset = new Preset(presetName, Mod.IsEnabled);
preset.Add(Mod);
presetManager.SavePreset(preset);
if (OnAddedToPreset != null)
OnAddedToPreset(preset);
}
}
public void OverrideValues(Preset p)
{
p.bloom.intensity.value = intensity;
p.bloom.scatter.value = scatter;
p.bloom.threshold.value = threshold;
}
public QueueTask(EncodeTask task, HBConfiguration configuration, string scannedSourcePath, Preset currentPreset, bool isPresetModified)
{
this.Task = task;
this.Configuration = configuration;
this.Status = QueueItemStatus.Waiting;
this.ScannedSourcePath = scannedSourcePath;
if (currentPreset != null)
{
this.presetKey = currentPreset.Name;
if (isPresetModified)
{
this.presetKey = this.presetKey + " (Modified)";
}
}
id = id + 1;
this.Id = string.Format("{0}.{1}", GeneralUtilities.ProcessId, id);
this.Statistics = new QueueStats();
}
/// <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>
/// 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; // 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.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;
preset.AlignAVStart = export.Task.AlignAVStart;
// 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;
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 = 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.UsesPictureFilters = true;
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" : "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;
// 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.VideoQSVAsyncDepth = 4; // Defaulted to 4 for now.
preset.VideoQSVDecode = config.EnableQuickSyncDecoding;
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;
// Unknown
preset.ChildrenArray = new List <object>(); // We don't support nested presets.
preset.Folder = false; // TODO
preset.FolderOpen = false; // TODO
return(preset);
}
/// <summary>
/// Set Default Preset
/// </summary>
/// <param name="name">
/// The name.
/// </param>
public void SetDefault(Preset name)
{
foreach (Preset preset in this.presets)
{
preset.IsDefault = false;
}
name.IsDefault = true;
this.SavePresetFiles();
}
public void Init(Preset preset, CameraStand cameraStand)
{
Init(preset, cameraStand, m_Preset.m_DebugColor);
}
/// <summary>
/// Setup this tab for the specified preset.
/// </summary>
/// <param name="preset">
/// The preset.
/// </param>
/// <param name="task">
/// The task.
/// </param>
public void SetPreset(Preset preset, EncodeTask task)
{
this.Task.PropertyChanged -= this.Task_PropertyChanged;
this.Task = task;
this.Task.PropertyChanged += this.Task_PropertyChanged;
this.AdvancedOptionsString = preset.Task.AdvancedEncoderOptions;
if (task.ShowAdvancedTab && task.VideoEncoder == VideoEncoder.X264)
{
this.ShowX264AdvancedOptions = true;
this.NotifyOfPropertyChange(() => ShowX264AdvancedOptions);
}
}
//
protected void CommonGUI()
{
#if UNITY_IPHONE || UNITY_ANDROID || UNITY_WP8 || UNITY_BLACKBERRY
if (!PlayerSettings.use32BitDisplayBuffer)
{
EditorGUILayout.HelpBox("Highlighting System requires 32-bit display buffer. Set the 'Use 32-bit Display Buffer' checkbox under the 'Resolution and Presentation' section of Player Settings.", MessageType.Error);
}
#endif
EditorGUILayout.HelpBox("Depth Offset properties should be used only when Dynamic Batching is enabled in Player Settings. Otherwise set them to 0's to avoid rendering artifacts.", MessageType.Info);
EditorGUI.BeginChangeCheck();
hb.offsetFactor = EditorGUILayout.Slider("Depth Offset Factor:", hb.offsetFactor, -1f, 0f);
hb.offsetUnits = EditorGUILayout.Slider("Depth Offset Units:", hb.offsetUnits, -100f, 0f);
if (EditorGUI.EndChangeCheck())
{
EditorUtility.SetDirty(hb);
}
EditorGUILayout.Space();
EditorGUILayout.LabelField("Preset:");
int oldIndex = presetIndex;
int newIndex = EditorGUILayout.Popup(presetIndex, presetNames);
if (oldIndex != newIndex)
{
SetPresetSettings(newIndex);
presetIndex = newIndex;
}
Preset currentPreset = new Preset();
if (presetIndex >= 0)
{
currentPreset = presets[presetIndex];
}
EditorGUI.BeginChangeCheck();
SetBoldDefaultFont(presetIndex < 0 || hb.downsampleFactor != currentPreset.downsampleFactor);
hb.downsampleFactor = _downsampleSet[EditorGUILayout.Popup("Downsampling:", _downsampleGet[hb.downsampleFactor], downsampleOptions)];
SetBoldDefaultFont(presetIndex < 0 || hb.iterations != currentPreset.iterations);
hb.iterations = Mathf.Clamp(EditorGUILayout.IntField("Iterations:", hb.iterations), 0, 50);
SetBoldDefaultFont(presetIndex < 0 || hb.blurMinSpread != currentPreset.blurMinSpread);
hb.blurMinSpread = EditorGUILayout.Slider("Min Spread:", hb.blurMinSpread, 0f, 3f);
SetBoldDefaultFont(presetIndex < 0 || hb.blurSpread != currentPreset.blurSpread);
hb.blurSpread = EditorGUILayout.Slider("Spread:", hb.blurSpread, 0f, 3f);
SetBoldDefaultFont(presetIndex < 0 || hb.blurIntensity != currentPreset.blurIntensity);
hb.blurIntensity = EditorGUILayout.Slider("Intensity:", hb.blurIntensity, 0f, 1f);
SetBoldDefaultFont(false);
if (EditorGUI.EndChangeCheck())
{
// If settings have changed when default preset has been selected
if (presetIndex < defaultPresets.Count)
{
presetIndex = -1;
}
EditorUtility.SetDirty(hb);
}
int customPresetIndex = presetIndex - defaultPresets.Count;
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Save Preset"))
{
string defaultName;
if (customPresetIndex < 0)
{
defaultName = "My Preset";
}
else
{
defaultName = customPresets[customPresetIndex].name;
}
window = SavePresetWindow.Init(defaultName, SavePresetAs);
}
if (presetIndex < defaultPresets.Count)
{
GUI.enabled = false;
}
if (GUILayout.Button(GUI.enabled ? removeButtonContent : removeButtonContentDisabled))
{
bool delete = EditorUtility.DisplayDialog("Removing Preset", "Are you sure - you want to remove Preset '" + customPresets[customPresetIndex].name + "'?", "Yes", "No");
if (delete)
{
customPresets.RemoveAt(customPresetIndex);
SavePresets();
LoadPresets();
SetPresetSettings(0);
presetIndex = 0;
}
}
GUI.enabled = true;
EditorGUILayout.EndHorizontal();
}
/// <summary>
/// Setup this tab for the specified preset.
/// </summary>
/// <param name="preset">
/// The preset.
/// </param>
/// <param name="task">
/// The task.
/// </param>
public void SetPreset(Preset preset, EncodeTask task)
{
this.Task = task;
// Handle built-in presets.
if (preset.IsBuildIn)
{
preset.PictureSettingsMode = PresetPictureSettingsMode.Custom;
}
// Setup the Picture Sizes
switch (preset.PictureSettingsMode)
{
default:
case PresetPictureSettingsMode.Custom:
case PresetPictureSettingsMode.SourceMaximum:
// Anamorphic Mode
this.SelectedAnamorphicMode = preset.Task.Anamorphic;
// Modulus
if (preset.Task.Modulus.HasValue)
{
this.SelectedModulus = preset.Task.Modulus;
}
// Set the Maintain Aspect ratio.
this.MaintainAspectRatio = preset.Task.KeepDisplayAspect;
// Set the Maximum so libhb can correctly manage the size.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
this.MaxWidth = this.sourceResolution.Width;
this.MaxHeight = this.sourceResolution.Height;
}
else
{
this.MaxWidth = preset.Task.MaxWidth ?? this.sourceResolution.Width;
this.MaxHeight = preset.Task.MaxHeight ?? this.sourceResolution.Height;
}
// Set the width, then check the height doesn't breach the max height and correct if necessary.
int width = this.GetModulusValue(this.GetRes((this.sourceResolution.Width - this.CropLeft - this.CropRight), preset.Task.MaxWidth));
this.Width = width;
// If we have a max height, make sure we havn't breached it.
int height = this.GetModulusValue(this.GetRes((this.sourceResolution.Height - this.CropTop - this.CropBottom), preset.Task.MaxHeight));
if (preset.Task.MaxHeight.HasValue && this.Height > preset.Task.MaxHeight.Value)
{
this.Height = height;
}
break;
case PresetPictureSettingsMode.None:
// Do Nothing except reset the Max Width/Height
this.MaxWidth = this.sourceResolution.Width;
this.MaxHeight = this.sourceResolution.Height;
this.SelectedAnamorphicMode = preset.Task.Anamorphic;
break;
}
// Custom Anamorphic
if (preset.Task.Anamorphic == Anamorphic.Custom)
{
this.DisplayWidth = preset.Task.DisplayWidth != null?int.Parse(preset.Task.DisplayWidth.ToString()) : 0;
this.ParWidth = preset.Task.PixelAspectX;
this.ParHeight = preset.Task.PixelAspectY;
}
// Cropping
if (preset.Task.HasCropping)
{
this.IsCustomCrop = true;
this.CropLeft = preset.Task.Cropping.Left;
this.CropRight = preset.Task.Cropping.Right;
this.CropTop = preset.Task.Cropping.Top;
this.CropBottom = preset.Task.Cropping.Bottom;
}
else
{
this.IsCustomCrop = false;
}
this.NotifyOfPropertyChange(() => this.Task);
this.UpdateVisibileControls();
}
//
protected virtual PresetSaveResult SavePresetAs(string name, bool overwrite)
{
window = null;
if (string.IsNullOrEmpty(name))
{
return(PresetSaveResult.Null);
}
int customPresetIndex = -1;
for (int i = 0, imax = presets.Count; i < imax; i++)
{
if (presets[i].name == name)
{
if (i < defaultPresets.Count)
{
// Overwriting default presets is not allowed
return(PresetSaveResult.Default);
}
else if (!overwrite)
{
// Preset with this name already exists
return(PresetSaveResult.Exists);
}
else
{
// Overwrite custom preset with this name
customPresetIndex = i - defaultPresets.Count;
break;
}
}
}
Preset p = new Preset();
p.name = name;
p.downsampleFactor = hb.downsampleFactor;
p.iterations = hb.iterations;
p.blurMinSpread = hb.blurMinSpread;
p.blurSpread = hb.blurSpread;
p.blurIntensity = hb.blurIntensity;
int newIndex = -1;
if (overwrite && customPresetIndex >= 0)
{
customPresets[customPresetIndex] = p;
newIndex = customPresetIndex + defaultPresets.Count;
}
else
{
customPresets.Add(p);
newIndex = customPresets.Count + defaultPresets.Count - 1;
}
SavePresets();
LoadPresets();
presetIndex = newIndex;
EditorUtility.SetDirty(hb);
return(PresetSaveResult.Success);
}
/// <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;
}
abstract public void OnChangeSelectedPreset(Preset preset);
/// <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>
/// If the specified transform exists, get that transform.
/// If the it does not exist, creates a new transform with the specified output.
/// In this case, the output is set to encode a video using one of the built-in encoding presets.
/// </summary>
/// <param name="client">The Media Services client.</param>
/// <param name="resourceGroupName">The name of the resource group within the Azure subscription.</param>
/// <param name="accountName"> The Media Services account name.</param>
/// <param name="transformName">The name of the transform.</param>
/// <returns></returns>
private static Transform EnsureTransformExists(IAzureMediaServicesClient client, string resourceGroupName, string accountName, string transformName, Preset preset)
{
// Does a Transform already exist with the desired name? Assume that an existing Transform with the desired name
// also uses the same recipe or Preset for processing content.
Transform transform = client.Transforms.Get(resourceGroupName, accountName, transformName);
if (transform == null)
{
// Start by defining the desired outputs.
TransformOutput[] outputs = new TransformOutput[]
{
new TransformOutput(preset),
};
// Create the Transform with the output defined above
transform = client.Transforms.CreateOrUpdate(resourceGroupName, accountName, transformName, outputs);
}
return(transform);
}
private void AddToPreset(Preset preset)
{
if (Mod.IsInOriginalInstallation())
{
MessageBox.Show("This mod cannot be added to a preset, as it is part of the core of Cortex Command.", "Notice", MessageBoxButton.OK, MessageBoxImage.Exclamation);
return;
}
presetManager.AddModToPreset(Mod, preset);
if (OnAddedToPreset != null)
OnAddedToPreset(preset);
}
public static (string exefile, string args) Build(string param, string input, string output, Preset preset, bool useHdr, string originInput, string extra)
{
var exeFileName = TaskArgBuilder.GetBaseEncoderFile(preset);
string ioargs = TaskArgBuilder.GetIOArgs(input, output, preset);
string gargs = TaskArgBuilder.GenericArgumentBuilder(preset, useHdr);
var addArgs = new List <string>
{
preset.Decoder switch
{
Presets.Decoder.AVSW => "--avsw",
Presets.Decoder.AVHW => "--avhw",
}
};
if (preset.IsSetOutputRes)
{
addArgs.Add("--output-res");
addArgs.Add($"{preset.OutputResWidth}x{preset.OUtputResHeight}");
}
if (preset.IsSetAvSync && preset.AudioEncode != AudioEncode.None)
{
addArgs.Add("--avsync");
addArgs.Add(preset.AVSync switch
{
AVSync.Cfr => "cfr",
AVSync.ForceCfr => "forcecfr",
AVSync.Vfr => "vfr",
});
