private async Task <bool> DoExport(IProgress <ExportProgressStatus> progress)
{
var exportProgressStatus = new ExportProgressStatus();
var overallProgressSteps = _data.ActiveProfile.SequenceFiles.Count * 2d; //There are basically 2 steps for each. Render and export.
var overallProgressStep = 0;
exportProgressStatus.OverallProgressMessage = "Overall Progress";
progress.Report(exportProgressStatus);
await Task.Run(async() =>
{
foreach (var sequenceFile in _data.ActiveProfile.SequenceFiles)
{
if (_cancelled)
{
break;
}
exportProgressStatus.TaskProgressMessage = string.Format("Loading {0}", Path.GetFileNameWithoutExtension(sequenceFile));;
progress.Report(exportProgressStatus);
//Load our sequence
var sequence = SequenceService.Instance.Load(sequenceFile);
exportProgressStatus.TaskProgressMessage = string.Format("Loading any media for {0}", sequence.Name);
progress.Report(exportProgressStatus);
//Load it's media
LoadMedia(sequence);
//Render it
RenderSequence(sequence, progress);
//Update over all progress with next step
overallProgressStep++;
exportProgressStatus.OverallProgressValue = (int)(overallProgressStep / overallProgressSteps * 100);
exportProgressStatus.TaskProgressMessage = string.Format("Exporting {0}", sequence.Name);
progress.Report(exportProgressStatus);
//Begin export step.
await Export(sequence, progress);
overallProgressStep++;
exportProgressStatus.OverallProgressValue = (int)(overallProgressStep / overallProgressSteps * 100);
progress.Report(exportProgressStatus);
}
await CreateUniverseFile();
exportProgressStatus.TaskProgressMessage = "";
exportProgressStatus.TaskProgressValue = 0;
exportProgressStatus.OverallProgressMessage = "Completed";
progress.Report(exportProgressStatus);
});
return(true);
}
private void ReportProgress(ExportProgressStatus progressStatus)
{
switch (progressStatus.StatusType)
{
case ExportProgressStatus.ProgressType.Both:
UpdateTaskProgress(progressStatus);
UpdateOverallProgress(progressStatus);
break;
case ExportProgressStatus.ProgressType.Task:
UpdateTaskProgress(progressStatus);
break;
case ExportProgressStatus.ProgressType.Overall:
UpdateOverallProgress(progressStatus);
break;
}
}
private bool RenderSequence(ISequence sequence, IProgress <ExportProgressStatus> progress)
{
double count = sequence.SequenceData.EffectData.Count();
long index = 1;
var p = new ExportProgressStatus(ExportProgressStatus.ProgressType.Task)
{
TaskProgressMessage = string.Format("Rendering {0}", sequence.Name)
};
foreach (var effectNode in sequence.SequenceData.EffectData.Cast <IEffectNode>())
{
RenderEffect(effectNode);
p.TaskProgressValue = (int)(index / count * 100);
progress.Report(p);
index++;
}
return(true);
}
private void UpdateTaskProgress(ExportProgressStatus progressStatus)
{
taskProgress.Value = progressStatus.TaskProgressValue;
lblTaskProgress.Text = progressStatus.TaskProgressMessage;
}
private void UpdateOverallProgress(ExportProgressStatus progressStatus)
{
overallProgress.Value = progressStatus.OverallProgressValue;
lblOverallProgress.Text = progressStatus.OverallProgressMessage;
}
private void ReportExportProgress(ExportProgressStatus exportProgressStatus)
{
exportProgressBar.Value = exportProgressStatus.TaskProgressValue;
currentTimeLabel.Text = string.Format("{0}%", exportProgressStatus.TaskProgressValue);
}
private async Task <bool> DoImport(IProgress <ExportProgressStatus> progress)
{
var exportProgressStatus = new ExportProgressStatus();
//Progress steps per sequence
//1 Extract Sequence
//2 Load Sequence
//3 Remap Sequence
//4 Save Sequence to sequence folder
//5 Add media to Module Data folder
//6 Add Audio to Media folder
//Progress for Element Tree is one to create and one to archive
var stepsPerSequence = 6d;
var overallProgressSteps = (_data.Sequences.Count * stepsPerSequence);
var overallProgressStep = 0;
exportProgressStatus.OverallProgressMessage = "Overall Progress";
progress.Report(exportProgressStatus);
await Task.Run(async() =>
{
ModelPersistenceService <ElementMap> ems = new ModelPersistenceService <ElementMap>();
var map = await ems.LoadModelAsync(_data.MapFile);
foreach (var sequenceFile in _data.Sequences.Where(s => s.Value).Select(x => x.Key))
{
if (_cancelled)
{
break;
}
//Progress step 1 Extract Sequence
exportProgressStatus.TaskProgressValue = 0;
exportProgressStatus.TaskProgressMessage = $"Extracting {sequenceFile} from package";;
progress.Report(exportProgressStatus);
//var n = Path.GetFileNameWithoutExtension(Path.GetRandomFileName()) + ".tim";
//var sequenceTemp = Path.Combine(Path.GetTempPath(), n);
var sequenceDestination = Path.Combine(SequenceService.SequenceDirectory,
sequenceFile + TimedSequence.Extension);
if (File.Exists(sequenceDestination))
{
var overwrite = ShowSequenceExistsMessage(sequenceFile);
if (!overwrite)
{
var target = GetFileName();
if (!string.IsNullOrEmpty(target))
{
sequenceDestination = target;
}
else
{
continue;
}
}
}
ExtractSequence(_data.InputFile, sequenceFile, sequenceDestination);
//End step 1
//Progress step 2 Load Sequence
exportProgressStatus.TaskProgressValue = (int)(1 / stepsPerSequence * 100);
overallProgressStep++;
exportProgressStatus.OverallProgressValue = (int)(overallProgressStep / overallProgressSteps * 100);
exportProgressStatus.TaskProgressMessage = $"Loading {sequenceFile}";
progress.Report(exportProgressStatus);
var sequence = await LoadSequence(sequenceDestination);
//try to clean up any sequence migration files becasue they are not relevant anyway.
var escapedFile = Regex.Escape(sequenceFile + TimedSequence.Extension);
Regex filter = new Regex($@"^.*{escapedFile}\.\d*$");
try
{
foreach (string f in Directory.EnumerateFiles(Path.GetDirectoryName(sequenceDestination), "*.*", SearchOption.TopDirectoryOnly)
.Where(x => filter.IsMatch(x)))
{
File.Delete(f);
}
}
catch (Exception e)
{
Logging.Error(e, "An error occured trying to remove sequence migration files.");
}
//End step 2
//Progress step 3 Remap Sequence
exportProgressStatus.TaskProgressValue = (int)(2 / stepsPerSequence * 100);
overallProgressStep++;
exportProgressStatus.OverallProgressValue = (int)(overallProgressStep / overallProgressSteps * 100);
exportProgressStatus.TaskProgressMessage = $"Remapping {sequenceFile}";
progress.Report(exportProgressStatus);
MapSequence(sequence, map);
//End step 3
exportProgressStatus.TaskProgressValue = (int)(3 / stepsPerSequence * 100);
overallProgressStep++;
exportProgressStatus.OverallProgressValue = (int)(overallProgressStep / overallProgressSteps * 100);
exportProgressStatus.TaskProgressMessage = $"Saving mapped sequence {sequenceFile}";
progress.Report(exportProgressStatus);
//Progress step 4 Save Sequence to sequence folder
await SaveSequence(sequence, Path.Combine(SequenceService.SequenceDirectory, sequenceDestination));
//End step 4
//Progress step 5 Add media to Module Data folder
exportProgressStatus.TaskProgressValue = (int)(4 / stepsPerSequence * 100);
overallProgressStep++;
exportProgressStatus.OverallProgressValue = (int)(overallProgressStep / overallProgressSteps * 100);
exportProgressStatus.TaskProgressMessage = $"Extracting module data for {sequenceFile}";
progress.Report(exportProgressStatus);
ExtractModuleData(_data.InputFile, sequenceFile);
//End step 5
//Progress step 6 Add Audio to Media folder
exportProgressStatus.TaskProgressValue = (int)(5 / stepsPerSequence * 100);
overallProgressStep++;
exportProgressStatus.OverallProgressValue = (int)(overallProgressStep / overallProgressSteps * 100);
exportProgressStatus.TaskProgressMessage = $"Extracting media/audio for {sequenceFile}";
progress.Report(exportProgressStatus);
ExtractMedia(_data.InputFile, sequenceFile);
exportProgressStatus.TaskProgressValue = 100;
overallProgressStep++;
exportProgressStatus.OverallProgressValue = (int)(overallProgressStep / overallProgressSteps * 100);
progress.Report(exportProgressStatus);
}
exportProgressStatus.TaskProgressMessage = "";
exportProgressStatus.TaskProgressValue = 100;
exportProgressStatus.OverallProgressValue = 100;
exportProgressStatus.OverallProgressMessage = "Completed";
progress.Report(exportProgressStatus);
});
return(true);
}
private async Task <bool> DoExport(IProgress <ExportProgressStatus> progress)
{
var exportProgressStatus = new ExportProgressStatus();
//Progress steps per sequence
//Add sequence to zip
//Discover media
//Add media to zip
//Add audio to zip
//Progress for Element Tree is one to create and one to archive
var overallProgressSteps = (_data.ExportSequenceFiles.Count * 4d) + 2;
var overallProgressStep = 0;
var moduleDataFolder = Path.GetFileName(Path.GetFullPath(Paths.ModuleDataFilesPath).TrimEnd(Path.DirectorySeparatorChar));
var mediaFolder = Path.GetFileName(Path.GetFullPath(MediaService.MediaDirectory).TrimEnd(Path.DirectorySeparatorChar));
exportProgressStatus.OverallProgressMessage = "Overall Progress";
progress.Report(exportProgressStatus);
bool create = true;
if (File.Exists(_data.ExportOutputFile))
{
if (ShowExportArchiveExistsMessage(Path.GetFileName(_data.ExportOutputFile)))
{
try
{
File.Delete(_data.ExportOutputFile);
}
catch (Exception e)
{
ShowErrorMessage($"An error occurred overwriting the existing package.\n\r {e.Message}");
return(false);
}
}
else
{
return(false);
}
}
await Task.Run(async() =>
{
foreach (var sequenceFile in _data.ExportSequenceFiles)
{
if (_cancelled)
{
break;
}
var name = Path.GetFileNameWithoutExtension(sequenceFile);
//Progress step Add sequence to zip
exportProgressStatus.TaskProgressValue = 0;
exportProgressStatus.TaskProgressMessage = $"Packaging {name}";;
progress.Report(exportProgressStatus);
Archive(_data.ExportOutputFile, new List <Tuple <string, string> > {
new Tuple <string, string>(sequenceFile, Path.Combine("Sequence", Path.GetFileName(sequenceFile)))
},
create?ZipArchiveMode.Create:ZipArchiveMode.Update);
create = false;
//Progress step Discover sequence effect media
exportProgressStatus.TaskProgressValue = 25;
overallProgressStep++;
exportProgressStatus.OverallProgressValue = (int)(overallProgressStep / overallProgressSteps * 100);
exportProgressStatus.TaskProgressMessage = $"Discovering any media for {name}";
progress.Report(exportProgressStatus);
var effectSupportingFiles = new List <Tuple <string, string> >();
var mediaSupportingFiles = new List <Tuple <string, string> >();
try
{
var seq = XDocument.Load(sequenceFile);
var fileElements = seq.Descendants().Where(x => x.Name.LocalName.Equals(@"FileName") ||
x.Name.LocalName.Equals(@"Movie_DataPath") ||
x.Name.LocalName.Equals(@"Picture_FileName") ||
x.Name.LocalName.Equals(@"Glediator_FileName"));
foreach (var xElement in fileElements)
{
if (_cancelled)
{
break;
}
if (!string.IsNullOrEmpty(xElement.Value))
{
var effectFiles = Directory.GetFiles(Paths.ModuleDataFilesPath, xElement.Value,
SearchOption.AllDirectories);
if (xElement.Name.LocalName.Equals(@"Movie_DataPath"))
{
var nutcrackerMovieDirectories =
Directory.GetDirectories(Paths.ModuleDataFilesPath, xElement.Value, SearchOption.AllDirectories);
if (nutcrackerMovieDirectories.Any())
{
var nutcrackerMovieFiles = new List <string>();
foreach (var nutcrackerMovieDirectory in nutcrackerMovieDirectories)
{
var movieFiles = Directory.GetFiles(nutcrackerMovieDirectory);
nutcrackerMovieFiles.AddRange(movieFiles);
}
var temp = effectFiles.ToList();
temp.AddRange(nutcrackerMovieFiles);
effectFiles = temp.ToArray();
}
}
var mediaFiles = Directory.GetFiles(MediaService.MediaDirectory, xElement.Value,
SearchOption.TopDirectoryOnly);
if (effectFiles.Any())
{
foreach (var file in effectFiles)
{
effectSupportingFiles.Add(
new Tuple <string, string>(file,
Path.Combine(Path.Combine(Constants.PackageSequenceDataFolder, name), moduleDataFolder, file.Replace(Paths.ModuleDataFilesPath, "").TrimStart(Path.DirectorySeparatorChar))));
}
}
if (mediaFiles.Any())
{
foreach (var file in mediaFiles)
{
mediaSupportingFiles.Add(
new Tuple <string, string>(file,
Path.Combine(Path.Combine(Constants.PackageSequenceDataFolder, name), mediaFolder, file.Replace(MediaService.MediaDirectory, "").TrimStart(Path.DirectorySeparatorChar))));
}
}
}
}
}
catch (Exception e)
{
Logging.Error(e, $"Exception occured parsing the sequence {sequenceFile} for media/audio file names");
}
//Add media to zip
exportProgressStatus.TaskProgressValue = 50;
overallProgressStep++;
exportProgressStatus.OverallProgressValue = (int)(overallProgressStep / overallProgressSteps * 100);
exportProgressStatus.TaskProgressMessage = $"Packaging effect media for {name}";
progress.Report(exportProgressStatus);
if (effectSupportingFiles.Any())
{
Archive(_data.ExportOutputFile, effectSupportingFiles);
}
//Add audio to zip
exportProgressStatus.TaskProgressValue = 75;
overallProgressStep++;
exportProgressStatus.OverallProgressValue = (int)(overallProgressStep / overallProgressSteps * 100);
exportProgressStatus.TaskProgressMessage = $"Packaging audio for {name}";
progress.Report(exportProgressStatus);
if (_data.ExportIncludeAudio && mediaSupportingFiles.Any())
{
Archive(_data.ExportOutputFile, mediaSupportingFiles);
}
exportProgressStatus.TaskProgressValue = 100;
overallProgressStep++;
exportProgressStatus.OverallProgressValue = (int)(overallProgressStep / overallProgressSteps * 100);
progress.Report(exportProgressStatus);
}
if (_cancelled)
{
return;
}
exportProgressStatus.TaskProgressValue = 0;
overallProgressStep++;
exportProgressStatus.OverallProgressValue = (int)(overallProgressStep / overallProgressSteps * 100);
exportProgressStatus.TaskProgressMessage = "Creating Profile Element Map";
progress.Report(exportProgressStatus);
var tempFile = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
await VixenSystem.Nodes.ExportElementNodeProxy(tempFile);
if (_cancelled)
{
return;
}
exportProgressStatus.TaskProgressValue = 50;
overallProgressStep++;
exportProgressStatus.OverallProgressValue = (int)(overallProgressStep / overallProgressSteps * 100);
exportProgressStatus.TaskProgressMessage = "Archiving Profile Element Map";
progress.Report(exportProgressStatus);
Archive(_data.ExportOutputFile, new List <Tuple <string, string> > {
new Tuple <string, string>(tempFile, Path.Combine("ProfileInfo", "ElementTree.v3e"))
});
try
{
File.Delete(tempFile);
}
catch (Exception e)
{
Logging.Error(e, "An error occured trying to delete the temp file.");
}
exportProgressStatus.TaskProgressMessage = "";
exportProgressStatus.TaskProgressValue = 100;
exportProgressStatus.OverallProgressValue = 100;
exportProgressStatus.OverallProgressMessage = "Completed";
progress.Report(exportProgressStatus);
});
return(true);
}
