public static void LoadProject(string file)
{
ProjectFormats format = DetectProjectFormat(file);
UProject project = null;
if (format == ProjectFormats.Ustx)
{
project = USTx.Load(file);
}
else if (format == ProjectFormats.Vsq3 || format == ProjectFormats.Vsq4)
{
project = VSQx.Load(file);
}
else if (format == ProjectFormats.Ust)
{
project = Ust.Load(file);
}
else
{
System.Windows.MessageBox.Show("Unknown file format");
}
if (project != null)
{
DocManager.Inst.ExecuteCmd(new LoadProjectNotification(project));
}
}
public UnrealEngineInstance(UnrealItemDescription unrealItem)
{
BuildType = UnrealEngineBuildType.Source;
unrealItem = UnrealItemDescription.RequireUnrealItem(unrealItem.RootPath, UnrealItemType.Project, UnrealItemType.Engine);
if (unrealItem.Type == UnrealItemType.Project)
{
var availableBuilds = FindAvailableBuilds();
var Configuration = unrealItem.SanitizeConfiguration(unrealItem.ReadConfiguration <ProjectConfiguration>());
if (!(Configuration?.UE4RootPath).IsNullOrWhiteSpace())
{
RootPath = Configuration.UE4RootPath;
Uuid = "<Engine Not Registered>";
foreach (var(uuid, path) in availableBuilds)
{
if (Path.GetFullPath(path.Item1) == RootPath)
{
Uuid = uuid;
BuildType = path.Item2;
break;
}
}
}
else
{
UProject project = UProject.Load(unrealItem.FullPath);
if (!availableBuilds.TryGetValue(project.EngineAssociation, out var item))
{
throw new UEIdNotFound(project.EngineAssociation);
}
Uuid = project.EngineAssociation;
RootPath = Path.GetFullPath(item.Item1);
BuildType = item.Item2;
}
}
else if (unrealItem.Type == UnrealItemType.Engine)
{
RootPath = Path.GetFullPath(unrealItem.RootPath);
var availableBuilds = FindAvailableBuilds();
foreach (var pair in availableBuilds)
{
if (RootPath.StartsWith(Path.GetFullPath(pair.Value.Item1)))
{
RootPath = pair.Value.Item1;
BuildType = pair.Value.Item2;
Uuid = pair.Key;
break;
}
}
}
Version = JsonConvert.DeserializeObject <Version>(
File.ReadAllText(Path.Combine(BuildPath, "Build.version")));
}
private RenderItem BuildRenderItem(UPhoneme phoneme, UVoicePart part, UProject project)
{
USinger singer = project.Tracks[part.TrackNo].Singer;
string rawfile = Lib.EncodingUtil.ConvertEncoding(singer.FileEncoding, singer.PathEncoding, phoneme.Oto.File);
rawfile = Path.Combine(singer.Path, rawfile);
double strechRatio = Math.Pow(2, 1.0 - (double)(int)phoneme.Parent.Expressions["velocity"].Data / 100);
double length = phoneme.Oto.Preutter * strechRatio + phoneme.Envelope.Points[4].X;
double requiredLength = Math.Ceiling(length / 50 + 1) * 50;
double lengthAdjustment = phoneme.TailIntrude == 0 ? phoneme.Preutter : phoneme.Preutter - phoneme.TailIntrude + phoneme.TailOverlap;
RenderItem item = new RenderItem()
{
// For resampler
RawFile = rawfile,
NoteNum = phoneme.Parent.NoteNum,
Velocity = (int)phoneme.Parent.Expressions["velocity"].Data,
Volume = (int)phoneme.Parent.Expressions["volume"].Data,
StrFlags = phoneme.Parent.GetResamplerFlags(),
PitchData = BuildPitchData(phoneme, part, project),
RequiredLength = (int)requiredLength,
Oto = phoneme.Oto,
Tempo = project.BPM,
// For connector
SkipOver = phoneme.Oto.Preutter * strechRatio - phoneme.Preutter,
PosMs = project.TickToMillisecond(part.PosTick + phoneme.Parent.PosTick + phoneme.PosTick) - phoneme.Preutter,
DurMs = project.TickToMillisecond(phoneme.DurTick) + lengthAdjustment,
Envelope = phoneme.Envelope.Points
};
return(item);
}
public static List <UNote> WriteNotes(UProject project, UVoicePart part, IEnumerable <UNote> notes, string filePath)
{
List <UNote> sequence = new List <UNote>();
using (var writer = new StreamWriter(filePath, false, ShiftJIS)) {
WriteHeader(project, part, writer);
int position = 0;
foreach (var note in notes)
{
if (note.position != position)
{
writer.WriteLine($"[#{sequence.Count:D4}]");
var spacer = UNote.Create();
spacer.position = position;
spacer.duration = note.position - position;
spacer.lyric = "R";
spacer.tone = 60;
sequence.Add(spacer);
WriteNoteBody(project, spacer, writer);
}
writer.WriteLine($"[#{sequence.Count:D4}]");
WriteNoteBody(project, note, writer);
position = note.End;
sequence.Add(note);
}
WriteFooter(writer);
}
return(sequence);
}
public void Play(UProject project)
{
if (renderTask != null)
{
if (renderTask.IsCompleted)
{
renderTask = null;
}
else
{
return;
}
}
if (outDevice != null)
{
if (outDevice.PlaybackState == PlaybackState.Playing)
{
return;
}
if (outDevice.PlaybackState == PlaybackState.Paused)
{
outDevice.Play();
return;
}
outDevice.Dispose();
}
Render(project);
}
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 TrackChangePhonemizerCommand(UProject project, UTrack track, Phonemizer newPhonemizer)
{
this.project = project;
this.track = track;
this.newPhonemizer = newPhonemizer;
this.oldPhonemizer = track.Phonemizer;
}
static public List <UVoicePart> Load(string file, UProject project)
{
List <UVoicePart> resultParts = new List <UVoicePart>();
MidiFile midi = new MidiFile(file);
for (int i = 0; i < midi.Tracks; i++)
{
Dictionary <int, UVoicePart> parts = new Dictionary <int, UVoicePart>();
foreach (var e in midi.Events.GetTrackEvents(i))
{
if (e is NoteOnEvent)
{
var _e = e as NoteOnEvent;
if (!parts.ContainsKey(_e.Channel))
{
parts.Add(_e.Channel, new UVoicePart());
}
var note = project.CreateNote(
_e.NoteNumber,
(int)_e.AbsoluteTime * project.Resolution / midi.DeltaTicksPerQuarterNote,
_e.NoteLength * project.Resolution / midi.DeltaTicksPerQuarterNote);
parts[e.Channel].Notes.Add(note);
}
}
foreach (var pair in parts)
{
pair.Value.DurTick = pair.Value.GetMinDurTick(project);
resultParts.Add(pair.Value);
}
}
return(resultParts);
}
public TrackChangeSingerCommand(UProject project, UTrack track, USinger newSinger)
{
this.project = project;
this.track = track;
this.newSinger = newSinger;
this.oldSinger = track.Singer;
}
public static UProject Load(StreamReader reader, string file)
{
var project = new UProject()
{
resolution = 480, FilePath = file, Saved = false
};
Ustx.AddDefaultExpressions(project);
project.tracks.Add(new UTrack {
TrackNo = 0,
});
var part = new UVoicePart()
{
trackNo = 0,
position = 0,
name = Path.GetFileNameWithoutExtension(file),
};
project.parts.Add(part);
var blocks = ReadBlocks(reader, file);
ParsePart(project, part, blocks);
part.Duration = part.notes.Select(note => note.End).Max() + project.resolution;
return(project);
}
public ConfigureExpressionsCommand(
UProject project,
UExpressionDescriptor[] descriptors) : base(project)
{
oldDescriptors = project.expressions.Values.ToArray();
newDescriptors = descriptors;
}
public MovePartCommand(UProject project, UPart part, int position, int trackNo) : base(project, part)
{
newPos = position;
newTrackNo = trackNo;
oldPos = part.position;
oldTrackNo = part.trackNo;
}
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.");
}
}
});
}
public TimeSignatureCommand(UProject project, int beatPerBar, int beatUnit) : base(project)
{
oldBeatPerBar = project.beatPerBar;
oldBeatUnit = project.beatUnit;
newBeatPerBar = beatPerBar;
newBeatUnit = beatUnit;
}
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);
}
public RenderItem(UPhoneme phoneme, UVoicePart part, UProject project)
{
var singer = project.Tracks[part.TrackNo].Singer;
SourceFile = phoneme.Oto.File;
SourceFile = Path.Combine(PathManager.Inst.InstalledSingersPath, SourceFile);
var strechRatio = Math.Pow(2, 1.0 - (double)(int)phoneme.Parent.Expressions["velocity"].Data / 100);
var length = phoneme.Oto.Preutter * strechRatio + phoneme.Envelope.Points[4].X;
var requiredLength = Math.Ceiling(length / 50 + 1) * 50;
var lengthAdjustment = phoneme.TailIntrude == 0 ? phoneme.Preutter : phoneme.Preutter - phoneme.TailIntrude + phoneme.TailOverlap;
NoteNum = phoneme.Parent.NoteNum;
Velocity = (int)phoneme.Parent.Expressions["velocity"].Data;
Volume = (int)phoneme.Parent.Expressions["volume"].Data;
StrFlags = phoneme.Parent.GetResamplerFlags();
PitchData = BuildPitchData(phoneme, part, project);
RequiredLength = (int)requiredLength;
Oto = phoneme.Oto;
Tempo = project.BPM;
SkipOver = phoneme.Oto.Preutter * strechRatio - phoneme.Preutter;
PosMs = project.TickToMillisecond(part.PosTick + phoneme.Parent.PosTick + phoneme.PosTick) - phoneme.Preutter;
DurMs = project.TickToMillisecond(phoneme.DurTick) + lengthAdjustment;
Envelope = phoneme.Envelope.Points;
phonemeName = phoneme.Phoneme;
}
async Task <SequencingSampleProvider> RenderPartAsync(UVoicePart part, UProject project, string cacheDir)
{
var singer = project.Tracks[part.TrackNo].Singer;
if (singer == null || !singer.Loaded)
{
return(null);
}
var tasks = new List <Task <RenderItem> >();
var progress = new Progress(part.Notes.Sum(note => note.Phonemes.Count));
progress.Clear();
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);
item.progress = progress;
tasks.Add(Task <RenderItem> .Factory.StartNew(ResamplePhonemeAsync, item, cancellationTokenSource.Token));
}
}
await Task.WhenAll(tasks.ToArray());
progress.Clear();
return(new SequencingSampleProvider(tasks.Select(task => new RenderItemSampleProvider(task.Result))));
}
public static void Save(string file, UProject project)
{
JavaScriptSerializer jss = new JavaScriptSerializer();
jss.RegisterConverters(
new List <JavaScriptConverter>()
{
new UProjectConvertor(),
new MiscConvertor(),
new UPartConvertor(),
new UNoteConvertor(),
new UPhonemeConverter()
});
StringBuilder str = new StringBuilder();
try
{
jss.Serialize(project, str);
var f_out = new StreamWriter(file);
f_out.Write(str.ToString());
f_out.Close();
project.Saved = true;
project.FilePath = file;
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.ToString());
}
}
public static void AddBuiltInExpressions(UProject project)
{
project.RegisterExpression(new UExpressionDescriptor("velocity", "vel", 0, 200, 100));
project.RegisterExpression(new UExpressionDescriptor("volume", "vol", 0, 200, 100));
project.RegisterExpression(new UExpressionDescriptor("attack", "atk", 0, 200, 100));
project.RegisterExpression(new UExpressionDescriptor("decay", "dec", 0, 100, 0));
}
public static UProject Load(string filePath)
{
string text = File.ReadAllText(filePath, Encoding.UTF8);
UProject project = text.StartsWith("{")
? JsonConvert.DeserializeObject <UProject>(text, new VersionConverter(), new UPartConverter())
: Yaml.DefaultDeserializer.Deserialize <UProject>(text);
AddDefaultExpressions(project);
project.FilePath = filePath;
project.Saved = true;
project.AfterLoad();
project.Validate();
if (project.ustxVersion < kUstxVersion)
{
Log.Information($"Upgrading project from {project.ustxVersion} to {kUstxVersion}");
}
if (project.ustxVersion == new Version(0, 1))
{
project.parts
.Where(part => part is UVoicePart)
.Select(part => part as UVoicePart)
.SelectMany(part => part.notes)
.ToList()
.ForEach(note => {
foreach (var kv in note.expressions)
{
if (kv.Value != null)
{
foreach (var phoneme in note.phonemes)
{
phoneme.SetExpression(project, kv.Key, (float)kv.Value.Value);
}
}
}
note.expressions = null;
});
}
if (project.ustxVersion < new Version(0, 4))
{
if (project.expressions.TryGetValue("acc", out var exp) && exp.name == "accent")
{
project.expressions.Remove("acc");
exp.abbr = "atk";
exp.name = "attack";
project.expressions["atk"] = exp;
project.parts
.Where(part => part is UVoicePart)
.Select(part => part as UVoicePart)
.SelectMany(part => part.notes)
.SelectMany(note => note.phonemeExpressions)
.Where(exp => exp.abbr == "acc")
.ToList()
.ForEach(exp => exp.abbr = "atk");
project.Validate();
}
}
project.ustxVersion = kUstxVersion;
return(project);
}
public SetPhonemeExpressionCommand(UProject project, UPhoneme phoneme, string abbr, float value)
{
this.project = project;
this.phoneme = phoneme;
Key = abbr;
newValue = value;
oldValue = phoneme.GetExpression(project, abbr).Item1;
}
private ISampleProvider BuildWavePartAudio(UWavePart part, UProject project)
{
AudioFileReader stream;
try { stream = new AudioFileReader(part.FilePath); }
catch { return(null); }
return(new WaveToSampleProvider(stream));
}
IEnumerable <RenderItem> PrepareTrack(UTrack track, UProject project, int startTick)
{
return(project.parts
.Where(part => part.trackNo == track.TrackNo)
.Where(part => part is UVoicePart)
.Select(part => part as UVoicePart)
.SelectMany(part => PreparePart(part, track, project, startTick)));
}
public MovePartCommand(UProject project, UPart part, int newPos, int newTrackNo)
{
this.project = project;
this.part = part;
this.newPos = newPos;
this.newTrackNo = newTrackNo;
this.oldPos = part.PosTick;
this.oldTrackNo = part.TrackNo;
}
public static void Save(string filePath, UProject project)
{
project.ustxVersion = kUstxVersion;
project.FilePath = filePath;
project.BeforeSave();
File.WriteAllText(filePath, Yaml.DefaultSerializer.Serialize(project), Encoding.UTF8);
project.Saved = true;
project.AfterSave();
}
IEnumerable <RenderItem> PreparePart(UVoicePart part, UTrack track, UProject project, int startTick)
{
return(part.notes
.Where(note => !note.OverlapError)
.SelectMany(note => note.phonemes)
.Where(phoneme => !phoneme.Error)
.Where(phoneme => part.position + phoneme.Parent.position + phoneme.End > startTick)
.Select(phoneme => new RenderItem(phoneme, part, track, project, driver.GetInfo().Name)));
}
public static void AddDefaultExpressions(UProject project)
{
AddBuiltInExpressions(project);
project.RegisterExpression(new UExpressionDescriptor("gender", "gen", -100, 100, 0, "g"));
project.RegisterExpression(new UExpressionDescriptor("breath", "bre", 0, 100, 0, "B"));
project.RegisterExpression(new UExpressionDescriptor("lowpass", "lpf", 0, 100, 0, "H"));
project.RegisterExpression(new UExpressionDescriptor("modulation", "mod", 0, 100, 0));
project.RegisterExpression(new UExpressionDescriptor("resampler engine", "eng", false, new string[] { "", "resampler.exe" }));
}
public void Play(UProject project, int tick)
{
if (AudioOutput.PlaybackState == PlaybackState.Paused)
{
AudioOutput.Play();
return;
}
AudioOutput.Stop();
Render(project, tick);
}
private void LoadPart(UPart part, UProject project)
{
if (!(part is UVoicePart))
{
return;
}
UnloadPart();
Part = part as UVoicePart;
OnPartModified();
}
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);
}
