public void RenderToFiles(UProject project)
{
FileInfo ResamplerFile = new FileInfo(PathManager.Inst.GetExportEnginePath());
IResamplerDriver driver = ResamplerDriver.ResamplerDriver.Load(ResamplerFile.FullName);
if (driver == null)
{
return;
}
StopPreRender();
Task.Run(() => {
var task = Task.Run(() => {
RenderEngine engine = new RenderEngine(project, driver, cache);
var trackMixes = engine.RenderTracks();
for (int i = 0; i < trackMixes.Count; ++i)
{
var file = PathManager.Inst.GetExportPath(project.FilePath, i + 1);
DocManager.Inst.ExecuteCmd(new ProgressBarNotification(0, $"Exporting to {file}."));
WaveFileWriter.CreateWaveFile16(file, new ExportAdapter(trackMixes[i]));
DocManager.Inst.ExecuteCmd(new ProgressBarNotification(0, $"Exported to {file}."));
}
});
try {
task.Wait();
} catch (AggregateException ae) {
foreach (var e in ae.Flatten().InnerExceptions)
{
Log.Error(e, "Failed to render.");
}
}
});
}
void Resample(RenderItem item)
{
byte[] data = null;
try {
uint hash = item.HashParameters();
data = cache.Get(hash);
if (data == null)
{
CopySourceTemp(item);
if (!resamplers.TryGetValue(item.ResamplerName, out var driver))
{
driver = this.driver;
}
data = driver.DoResampler(DriverModels.CreateInputModel(item, 0), Log.Logger);
if (data == null || data.Length == 0)
{
throw new Exception("Empty render result.");
}
cache.Put(hash, data);
Log.Information($"Sound {hash:x} {item.Oto.Alias} {item.GetResamplerExeArgs()} resampled.");
CopyBackMetaFiles(item);
}
} catch (Exception e) {
Log.Error(e, $"Failed to render item {item.SourceFile} {item.Oto.Alias} {item.GetResamplerExeArgs()}.");
} finally {
item.Data = data ?? new byte[0];
item.OnComplete?.Invoke(item.Data);
item.progress?.CompleteOne($"Resampling \"{item.phonemeName}\"");
}
}
private void Render(UProject project, int tick)
{
IResamplerDriver driver = GetPreviewDriver();
if (driver == null)
{
return;
}
StopPreRender();
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
Task.Run(() => {
RenderEngine engine = new RenderEngine(project, driver, cache, tick);
var result = engine.RenderProject(tick);
faders = result.Item2;
var source = result.Item3;
source = Interlocked.Exchange(ref playbakCancellationTokenSource, source);
if (source != null)
{
source.Cancel();
Log.Information("Cancelling previous render");
}
StartPlayback(project.TickToMillisecond(tick), result.Item1);
}).ContinueWith((task) => {
if (task.IsFaulted)
{
Log.Information($"{task.Exception}");
DocManager.Inst.ExecuteCmd(new UserMessageNotification(task.Exception.ToString()));
throw task.Exception;
}
}, CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
}
private void Render(UProject project)
{
FileInfo ResamplerFile = new FileInfo(PathManager.Inst.GetPreviewEnginePath());
IResamplerDriver driver = ResamplerDriver.ResamplerDriver.Load(ResamplerFile.FullName);
if (driver == null)
{
return;
}
Task.Run(() => {
var task = Task.Run(async() => {
RenderEngine engine = new RenderEngine(project, driver, cache);
renderTask = engine.RenderAsync();
trackSources = await renderTask;
StartPlayback();
renderTask = null;
});
try {
task.Wait();
} catch (AggregateException ae) {
foreach (var e in ae.Flatten().InnerExceptions)
{
Log.Error(e, "Failed to render.");
}
}
});
}
public static IResamplerDriver LoadEngine(string FilePath)
{
IResamplerDriver ret = null;
if (System.IO.File.Exists(FilePath))
{
if (Path.GetExtension(FilePath).ToLower() == ".exe")
{
ret = new ExeDriver(FilePath);
}
else if (Path.GetExtension(FilePath).ToLower() == ".dll")
{
CppDriver retcpp = new CppDriver(FilePath);
if (retcpp.isLegalPlugin)
{
ret = retcpp;
}
else
{
SharpDriver retnet = new SharpDriver(FilePath);
if (retnet.isLegalPlugin)
{
ret = retnet;
}
}
}
}
return(ret);
}
public void ResamplePart(UVoicePart part, UProject project, IResamplerDriver engine, Action<SequencingSampleProvider> resampleDoneCallback)
{
this.resampleDoneCallback = resampleDoneCallback;
BackgroundWorker worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.DoWork += worker_DoWork;
worker.RunWorkerCompleted += worker_RunWorkerCompleted;
worker.ProgressChanged += worker_ProgressChanged;
worker.RunWorkerAsync(new Tuple<UVoicePart, UProject, IResamplerDriver>(part, project, engine));
}
public RenderEngine(UProject project, IResamplerDriver driver, RenderCache cache, int startTick = 0)
{
this.project = project;
this.driver = driver;
this.cache = cache;
this.startTick = startTick;
resamplers = ResamplerDriver.ResamplerDriver
.Search(PathManager.Inst.GetEngineSearchPath())
.ToDictionary(resampler => resampler.GetInfo().Name, resampler => resampler);
}
public void ResamplePart(UVoicePart part, UProject project, IResamplerDriver engine, Action <SequencingSampleProvider> resampleDoneCallback)
{
this.resampleDoneCallback = resampleDoneCallback;
BackgroundWorker worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.DoWork += worker_DoWork;
worker.RunWorkerCompleted += worker_RunWorkerCompleted;
worker.ProgressChanged += worker_ProgressChanged;
worker.RunWorkerAsync(new Tuple <UVoicePart, UProject, IResamplerDriver>(part, project, engine));
}
private List<RenderItem> RenderAsync(UVoicePart part, UProject project, IResamplerDriver engine, BackgroundWorker worker)
{
List<RenderItem> renderItems = new List<RenderItem>();
System.Diagnostics.Stopwatch watch = new Stopwatch();
watch.Start();
System.Diagnostics.Debug.WriteLine("Resampling start");
lock (part)
{
string cacheDir = PathManager.Inst.GetCachePath(project.FilePath);
string[] cacheFiles = Directory.EnumerateFiles(cacheDir).ToArray();
int count = 0, i = 0;
foreach (UNote note in part.Notes) foreach (UPhoneme phoneme in note.Phonemes) count++;
foreach (UNote note in part.Notes)
{
foreach (UPhoneme phoneme in note.Phonemes)
{
RenderItem item = BuildRenderItem(phoneme, part, project);
var sound = RenderCache.Inst.Get(item.HashParameters());
if (sound == null)
{
string cachefile = Path.Combine(cacheDir, string.Format("{0:x}.wav", item.HashParameters()));
if (!cacheFiles.Contains(cachefile))
{
System.Diagnostics.Debug.WriteLine("Sound {0:x} resampling {1}", item.HashParameters(), item.GetResamplerExeArgs());
DriverModels.EngineInput engineArgs = DriverModels.CreateInputModel(item, 0);
System.IO.Stream output = engine.DoResampler(engineArgs);
sound = new CachedSound(output);
}
else
{
System.Diagnostics.Debug.WriteLine("Sound {0:x} found on disk {1}", item.HashParameters(), item.GetResamplerExeArgs());
sound = new CachedSound(cachefile);
}
RenderCache.Inst.Put(item.HashParameters(), sound, engine.GetInfo().ToString());
}
else System.Diagnostics.Debug.WriteLine("Sound {0} found in cache {1}", item.HashParameters(), item.GetResamplerExeArgs());
item.Sound = sound;
renderItems.Add(item);
worker.ReportProgress(100 * ++i / count, string.Format("Resampling \"{0}\" {1}/{2}", phoneme.Phoneme, i, count));
}
}
}
watch.Stop();
System.Diagnostics.Debug.WriteLine("Resampling end");
System.Diagnostics.Debug.WriteLine("Total cache size {0:n0} bytes", RenderCache.Inst.TotalMemSize);
System.Diagnostics.Debug.WriteLine("Total time {0} ms", watch.Elapsed.TotalMilliseconds);
return renderItems;
}
private IResamplerDriver GetPreviewDriver()
{
lock (previewDriverLockObj) {
var resamplerPath = PathManager.Inst.GetPreviewEnginePath();
if (resamplerPath == resamplerSelected)
{
return(previewDriver);
}
FileInfo resamplerFile = new FileInfo(resamplerPath);
previewDriver = ResamplerDriver.ResamplerDriver.Load(resamplerFile.FullName);
resamplerSelected = resamplerPath;
return(previewDriver);
}
}
private List <RenderItem> RenderAsync(UVoicePart part, UProject project, IResamplerDriver engine, BackgroundWorker worker)
{
var renderItems = new List <RenderItem>();
var watch = new Stopwatch();
watch.Start();
Log.Information("Resampling start.");
lock (part) {
var cacheDir = PathManager.Inst.GetCachePath(project.FilePath);
var cacheFiles = Directory.EnumerateFiles(cacheDir).ToArray();
int count = 0, i = 0;
foreach (var note in part.Notes)
{
foreach (var phoneme in note.Phonemes)
{
count++;
}
}
foreach (var note in part.Notes)
{
foreach (var phoneme in note.Phonemes)
{
if (string.IsNullOrEmpty(phoneme.Oto.File))
{
Log.Warning($"Cannot find phoneme in note {note.Lyric}");
continue;
}
var item = new RenderItem(phoneme, part, project);
//System.Diagnostics.Debug.WriteLine("Sound {0:x} resampling {1}", item.HashParameters(), item.GetResamplerExeArgs());
var engineArgs = DriverModels.CreateInputModel(item, 0);
var output = engine.DoResampler(engineArgs);
item.Sound = MemorySampleProvider.FromStream(output);
output.Dispose();
renderItems.Add(item);
worker.ReportProgress(100 * ++i / count, $"Resampling \"{phoneme.Phoneme}\" {i}/{count}");
}
}
}
watch.Stop();
Log.Information($"Resampling end, total time {watch.Elapsed}");
return(renderItems);
}
private void BuildAudio(UProject project)
{
trackSources = new List <TrackSampleProvider>();
foreach (UTrack track in project.Tracks)
{
trackSources.Add(new TrackSampleProvider()
{
Volume = DecibelToVolume(track.Volume), Pan = track.Pan
});
}
pendingParts = project.Parts.Count;
foreach (UPart part in project.Parts)
{
if (part is UWavePart)
{
lock (lockObject)
{
trackSources[part.TrackNo].AddSource(
BuildWavePartAudio(part as UWavePart, project),
TimeSpan.FromMilliseconds(project.TickToMillisecond(part.PosTick))
);
pendingParts--;
}
}
else
{
var singer = project.Tracks[part.TrackNo].Singer;
if (singer != null && singer.Loaded)
{
FileInfo ResamplerFile = new FileInfo(PathManager.Inst.GetPreviewEnginePath());
IResamplerDriver engine = ResamplerDriver.ResamplerDriver.LoadEngine(ResamplerFile.FullName);
BuildVoicePartAudio(part as UVoicePart, project, engine);
}
else
{
lock (lockObject) { pendingParts--; }
}
}
}
if (pendingParts == 0)
{
StartPlayback();
}
}
public RenderEngine(UProject project, IResamplerDriver driver)
{
this.project = project;
this.driver = driver;
}
public RenderEngine(UProject project, IResamplerDriver driver, RenderCache cache)
{
this.project = project;
this.driver = driver;
this.cache = cache;
}
private void BuildVoicePartAudio(UVoicePart part, UProject project, IResamplerDriver engine)
{
ResamplerInterface ri = new ResamplerInterface();
ri.ResamplePart(part, project, engine, (o) => { this.BuildVoicePartDone(o, part, project); });
}
private List <RenderItem> RenderAsync(UVoicePart part, UProject project, IResamplerDriver engine, BackgroundWorker worker)
{
List <RenderItem> renderItems = new List <RenderItem>();
System.Diagnostics.Stopwatch watch = new Stopwatch();
watch.Start();
System.Diagnostics.Debug.WriteLine("Resampling start");
lock (part)
{
string cacheDir = PathManager.Inst.GetCachePath(project.FilePath);
string[] cacheFiles = Directory.EnumerateFiles(cacheDir).ToArray();
int count = 0, i = 0;
foreach (UNote note in part.Notes)
{
foreach (UPhoneme phoneme in note.Phonemes)
{
count++;
}
}
foreach (UNote note in part.Notes)
{
foreach (UPhoneme phoneme in note.Phonemes)
{
RenderItem item = BuildRenderItem(phoneme, part, project);
var sound = RenderCache.Inst.Get(item.HashParameters());
if (sound == null)
{
string cachefile = Path.Combine(cacheDir, string.Format("{0:x}.wav", item.HashParameters()));
if (!cacheFiles.Contains(cachefile))
{
System.Diagnostics.Debug.WriteLine("Sound {0:x} resampling {1}", item.HashParameters(), item.GetResamplerExeArgs());
DriverModels.EngineInput engineArgs = DriverModels.CreateInputModel(item, 0);
System.IO.Stream output = engine.DoResampler(engineArgs);
sound = new CachedSound(output);
}
else
{
System.Diagnostics.Debug.WriteLine("Sound {0:x} found on disk {1}", item.HashParameters(), item.GetResamplerExeArgs());
sound = new CachedSound(cachefile);
}
RenderCache.Inst.Put(item.HashParameters(), sound, engine.GetInfo().ToString());
}
else
{
System.Diagnostics.Debug.WriteLine("Sound {0} found in cache {1}", item.HashParameters(), item.GetResamplerExeArgs());
}
item.Sound = sound;
renderItems.Add(item);
worker.ReportProgress(100 * ++i / count, string.Format("Resampling \"{0}\" {1}/{2}", phoneme.Phoneme, i, count));
}
}
}
watch.Stop();
System.Diagnostics.Debug.WriteLine("Resampling end");
System.Diagnostics.Debug.WriteLine("Total cache size {0:n0} bytes", RenderCache.Inst.TotalMemSize);
System.Diagnostics.Debug.WriteLine("Total time {0} ms", watch.Elapsed.TotalMilliseconds);
return(renderItems);
}
private void BuildVoicePartAudio(UVoicePart part, UProject project,IResamplerDriver engine)
{
ResamplerInterface ri = new ResamplerInterface();
ri.ResamplePart(part, project, engine, (o) => { this.BuildVoicePartDone(o, part, project); });
}
