static USinger LoadSinger(string path)
{
if (!Directory.Exists(path) ||
!File.Exists(Path.Combine(path, "character.txt")) ||
!File.Exists(Path.Combine(path, "oto.ini"))) return null;
USinger singer = new USinger();
singer.Path = path;
singer.FileEncoding = EncodingUtil.DetectFileEncoding(Path.Combine(singer.Path, "oto.ini"), Encoding.Default);
singer.PathEncoding = Encoding.Default;
string[] lines = File.ReadAllLines(Path.Combine(singer.Path, "oto.ini"), singer.FileEncoding);
int i = 0;
while (i < 16 && i < lines.Count())
{
if (lines[i].Contains("="))
{
string filename = lines[i].Split(new[] { '=' })[0];
var detected = DetectPathEncoding(filename, singer.Path, singer.FileEncoding);
if (singer.PathEncoding == Encoding.Default) singer.PathEncoding = detected;
i++;
}
}
if (singer.PathEncoding == null) return null;
LoadOtos(singer);
try
{
lines = File.ReadAllLines(Path.Combine(singer.Path, "character.txt"), singer.FileEncoding);
}
catch { return null; }
foreach (var line in lines){
if (line.StartsWith("name=")) singer.Name = line.Trim().Replace("name=", "");
if (line.StartsWith("image="))
{
string imagePath = line.Trim().Replace("image=", "");
Uri imagepath = new Uri(Path.Combine(singer.Path, EncodingUtil.ConvertEncoding(singer.FileEncoding, singer.PathEncoding, imagePath)));
singer.Avatar = new System.Windows.Media.Imaging.BitmapImage(imagepath);
singer.Avatar.Freeze();
}
if (line.StartsWith("author=")) singer.Author = line.Trim().Replace("author=", "");
if (line.StartsWith("web=")) singer.Website = line.Trim().Replace("web=", "");
}
LoadPrefixMap(singer);
singer.Loaded = true;
return singer;
}
public UOtoSet(OtoSet otoSet, USinger singer, string singersPath)
{
Name = otoSet.Name;
Location = Path.Combine(singersPath, Path.GetDirectoryName(otoSet.File));
Otos = new Dictionary <string, UOto>();
foreach (var oto in otoSet.Otos)
{
if (!Otos.ContainsKey(oto.Name))
{
Otos.Add(oto.Name, new UOto(oto, this));
}
else
{
Serilog.Log.Error("{0} {1} {2}", singer.Name, Name, oto.Name);
}
}
}
public TrackChangeSingerCommand(UProject project, UTrack track, USinger newSinger) { this.project = project; this.track = track; this.newSinger = newSinger; this.oldSinger = track.Singer; }
static public UProject Load(string file, Encoding encoding = null)
{
int currentNoteIndex = 0;
UstVersion version = UstVersion.Early;
UstBlock currentBlock = UstBlock.None;
string[] lines;
try
{
if (encoding == null) lines = File.ReadAllLines(file, EncodingUtil.DetectFileEncoding(file));
else lines = File.ReadAllLines(file, encoding);
}
catch (Exception e)
{
DocManager.Inst.ExecuteCmd(new UserMessageNotification(e.GetType().ToString() + "\n" + e.Message));
return null;
}
UProject project = new UProject() { Resolution = 480, FilePath = file, Saved = false };
project.RegisterExpression(new IntExpression(null, "velocity","VEL") { Data = 100, Min = 0, Max = 200});
project.RegisterExpression(new IntExpression(null, "volume","VOL") { Data = 100, Min = 0, Max = 200});
project.RegisterExpression(new IntExpression(null, "gender","GEN") { Data = 0, Min = -100, Max = 100});
project.RegisterExpression(new IntExpression(null, "lowpass","LPF") { Data = 0, Min = 0, Max = 100});
project.RegisterExpression(new IntExpression(null, "highpass", "HPF") { Data = 0, Min = 0, Max = 100 });
project.RegisterExpression(new IntExpression(null, "accent", "ACC") { Data = 100, Min = 0, Max = 200 });
project.RegisterExpression(new IntExpression(null, "decay", "DEC") { Data = 0, Min = 0, Max = 100 });
var _track = new UTrack();
project.Tracks.Add(_track);
_track.TrackNo = 0;
UVoicePart part = new UVoicePart() { TrackNo = 0, PosTick = 0 };
project.Parts.Add(part);
List<string> currentLines = new List<string>();
int currentTick = 0;
UNote currentNote = null;
foreach (string line in lines)
{
if (line.Trim().StartsWith(@"[#") && line.Trim().EndsWith(@"]"))
{
if (line.Equals(versionTag)) currentBlock = UstBlock.Version;
else if (line.Equals(settingTag)) currentBlock = UstBlock.Setting;
else
{
if (line.Equals(endTag)) currentBlock = UstBlock.Trackend;
else
{
try { currentNoteIndex = int.Parse(line.Replace("[#", "").Replace("]", "")); }
catch { DocManager.Inst.ExecuteCmd(new UserMessageNotification("Unknown ust format")); return null; }
currentBlock = UstBlock.Note;
}
if (currentLines.Count != 0)
{
currentNote = NoteFromUst(project.CreateNote(), currentLines, version);
currentNote.PosTick = currentTick;
if (!currentNote.Lyric.Replace("R", "").Replace("r", "").Equals("")) part.Notes.Add(currentNote);
currentTick += currentNote.DurTick;
currentLines.Clear();
}
}
}
else
{
if (currentBlock == UstBlock.Version) {
if (line.StartsWith("UST Version"))
{
string v = line.Trim().Replace("UST Version", "");
if (v == "1.0") version = UstVersion.V1_0;
else if (v == "1.1") version = UstVersion.V1_1;
else if (v == "1.2") version = UstVersion.V1_2;
else version = UstVersion.Unknown;
}
}
if (currentBlock == UstBlock.Setting)
{
if (line.StartsWith("Tempo="))
{
project.BPM = double.Parse(line.Trim().Replace("Tempo=", ""));
if (project.BPM == 0) project.BPM = 120;
}
if (line.StartsWith("ProjectName=")) project.Name = line.Trim().Replace("ProjectName=", "");
if (line.StartsWith("VoiceDir="))
{
string singerpath = line.Trim().Replace("VoiceDir=", "");
var singer = UtauSoundbank.GetSinger(singerpath, EncodingUtil.DetectFileEncoding(file), DocManager.Inst.Singers);
if (singer == null) singer = new USinger() { Name = "", Path = singerpath };
project.Singers.Add(singer);
project.Tracks[0].Singer = singer;
}
}
else if (currentBlock == UstBlock.Note)
{
currentLines.Add(line);
}
else if (currentBlock == UstBlock.Trackend)
{
break;
}
}
}
if (currentBlock != UstBlock.Trackend)
DocManager.Inst.ExecuteCmd(new UserMessageNotification("Unexpected ust file end"));
part.DurTick = currentTick;
return project;
}
public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
if (type == typeof(IntExpression))
{
IntExpression result = new IntExpression(null, "", dictionary["abbr"] as string)
{
Data = dictionary["data"],
Min = Convert.ToInt32(dictionary["min"]),
Max = Convert.ToInt32(dictionary["max"]),
};
return result;
}
else if (type == typeof(UTrack))
{
UTrack result = new UTrack()
{
Name = dictionary["name"] as string,
Comment = dictionary["comment"] as string,
TrackNo = Convert.ToInt32(dictionary["trackno"]),
Singer = new USinger() { Name = dictionary["singer"] as string }
};
return result;
}
else if (type == typeof(USinger))
{
USinger result = new USinger()
{
Name = dictionary["name"] as string,
Path = dictionary["path"] as string
};
return result;
}
else return null;
}
static public UProject Load(string file)
{
XmlDocument vsqx = new XmlDocument();
try
{
vsqx.Load(file);
}
catch (Exception e)
{
System.Windows.MessageBox.Show(e.GetType().ToString() + "\n" + e.Message);
return null;
}
XmlNamespaceManager nsmanager = new XmlNamespaceManager(vsqx.NameTable);
nsmanager.AddNamespace("v3", vsq3NameSpace);
nsmanager.AddNamespace("v4", vsq4NameSpace);
XmlNode root;
string nsPrefix;
// Detect vsqx version
root = vsqx.SelectSingleNode("v3:vsq3", nsmanager);
if (root != null) nsPrefix = "v3:";
else
{
root = vsqx.SelectSingleNode("v4:vsq4", nsmanager);
if (root != null) nsPrefix = "v4:";
else
{
System.Windows.MessageBox.Show("Unrecognizable VSQx file format.");
return null;
}
}
UProject uproject = new UProject();
uproject.RegisterExpression(new IntExpression(null, "velocity", "VEL") { Data = 64, Min = 0, Max = 127 });
uproject.RegisterExpression(new IntExpression(null, "volume", "VOL") { Data = 100, Min = 0, Max = 200 });
uproject.RegisterExpression(new IntExpression(null, "opening", "OPE") { Data = 127, Min = 0, Max = 127 });
uproject.RegisterExpression(new IntExpression(null, "accent", "ACC") { Data = 50, Min = 0, Max = 100 });
uproject.RegisterExpression(new IntExpression(null, "decay", "DEC") { Data = 50, Min = 0, Max = 100 });
string bpmPath = string.Format("{0}masterTrack/{0}tempo/{0}{1}", nsPrefix, nsPrefix == "v3:" ? "bpm" : "v");
string beatperbarPath = string.Format("{0}masterTrack/{0}timeSig/{0}{1}", nsPrefix, nsPrefix == "v3:" ? "nume" : "nu");
string beatunitPath = string.Format("{0}masterTrack/{0}timeSig/{0}{1}", nsPrefix, nsPrefix == "v3:" ? "denomi" : "de");
string premeasurePath = string.Format("{0}masterTrack/{0}preMeasure", nsPrefix);
string resolutionPath = string.Format("{0}masterTrack/{0}resolution", nsPrefix);
string projectnamePath = string.Format("{0}masterTrack/{0}seqName", nsPrefix);
string projectcommentPath = string.Format("{0}masterTrack/{0}comment", nsPrefix);
string trackPath = string.Format("{0}vsTrack", nsPrefix);
string tracknamePath = string.Format("{0}{1}", nsPrefix, nsPrefix == "v3:" ? "trackName" : "name");
string trackcommentPath = string.Format("{0}comment", nsPrefix);
string tracknoPath = string.Format("{0}{1}", nsPrefix, nsPrefix == "v3:" ? "vsTrackNo" : "tNo");
string partPath = string.Format("{0}{1}", nsPrefix, nsPrefix == "v3:" ? "musicalPart" : "vsPart");
string partnamePath = string.Format("{0}{1}", nsPrefix, nsPrefix == "v3:" ? "partName" : "name");
string partcommentPath = string.Format("{0}comment", nsPrefix);
string notePath = string.Format("{0}note", nsPrefix);
string postickPath = string.Format("{0}{1}", nsPrefix, nsPrefix == "v3:" ? "posTick" : "t");
string durtickPath = string.Format("{0}{1}", nsPrefix, nsPrefix == "v3:" ? "durTick" : "dur");
string notenumPath = string.Format("{0}{1}", nsPrefix, nsPrefix == "v3:" ? "noteNum" : "n");
string velocityPath = string.Format("{0}{1}", nsPrefix, nsPrefix == "v3:" ? "velocity" : "v");
string lyricPath = string.Format("{0}{1}", nsPrefix, nsPrefix == "v3:" ? "lyric" : "y");
string phonemePath = string.Format("{0}{1}", nsPrefix, nsPrefix == "v3:" ? "phnms" : "p");
string playtimePath = string.Format("{0}playTime", nsPrefix);
string partstyleattrPath = string.Format("{0}{1}/{0}{2}", nsPrefix, nsPrefix == "v3:" ? "partStyle" : "pStyle", nsPrefix == "v3:" ? "attr" : "v");
string notestyleattrPath = string.Format("{0}{1}/{0}{2}", nsPrefix, nsPrefix == "v3:" ? "noteStyle" : "nStyle", nsPrefix == "v3:" ? "attr" : "v");
uproject.BPM = Convert.ToDouble(root.SelectSingleNode(bpmPath, nsmanager).InnerText) / 100;
uproject.BeatPerBar = int.Parse(root.SelectSingleNode(beatperbarPath, nsmanager).InnerText);
uproject.BeatUnit = int.Parse(root.SelectSingleNode(beatunitPath, nsmanager).InnerText);
uproject.Resolution = int.Parse(root.SelectSingleNode(resolutionPath, nsmanager).InnerText);
uproject.FilePath = file;
uproject.Name = root.SelectSingleNode(projectnamePath, nsmanager).InnerText;
uproject.Comment = root.SelectSingleNode(projectcommentPath, nsmanager).InnerText;
int preMeasure = int.Parse(root.SelectSingleNode(premeasurePath, nsmanager).InnerText);
int partPosTickShift = -preMeasure * uproject.Resolution * uproject.BeatPerBar * 4 / uproject.BeatUnit;
USinger usinger = new USinger();
uproject.Singers.Add(usinger);
foreach (XmlNode track in root.SelectNodes(trackPath, nsmanager)) // track
{
UTrack utrack = new UTrack() { Singer = usinger, TrackNo = uproject.Tracks.Count };
uproject.Tracks.Add(utrack);
utrack.Name = track.SelectSingleNode(tracknamePath, nsmanager).InnerText;
utrack.Comment = track.SelectSingleNode(trackcommentPath, nsmanager).InnerText;
utrack.TrackNo = int.Parse(track.SelectSingleNode(tracknoPath, nsmanager).InnerText);
foreach (XmlNode part in track.SelectNodes(partPath, nsmanager)) // musical part
{
UVoicePart upart = new UVoicePart();
uproject.Parts.Add(upart);
upart.Name = part.SelectSingleNode(partnamePath, nsmanager).InnerText;
upart.Comment = part.SelectSingleNode(partcommentPath, nsmanager).InnerText;
upart.PosTick = int.Parse(part.SelectSingleNode(postickPath, nsmanager).InnerText) + partPosTickShift;
upart.DurTick = int.Parse(part.SelectSingleNode(playtimePath, nsmanager).InnerText);
upart.TrackNo = utrack.TrackNo;
foreach (XmlNode note in part.SelectNodes(notePath, nsmanager))
{
UNote unote = uproject.CreateNote();
unote.PosTick = int.Parse(note.SelectSingleNode(postickPath, nsmanager).InnerText);
unote.DurTick = int.Parse(note.SelectSingleNode(durtickPath, nsmanager).InnerText);
unote.NoteNum = int.Parse(note.SelectSingleNode(notenumPath, nsmanager).InnerText);
unote.Lyric = note.SelectSingleNode(lyricPath, nsmanager).InnerText;
unote.Phonemes[0].Phoneme = note.SelectSingleNode(phonemePath, nsmanager).InnerText;
unote.Expressions["velocity"].Data = int.Parse(note.SelectSingleNode(velocityPath, nsmanager).InnerText);
foreach (XmlNode notestyle in note.SelectNodes(notestyleattrPath, nsmanager))
{
if (notestyle.Attributes["id"].Value == "opening")
unote.Expressions["opening"].Data = int.Parse(notestyle.InnerText);
else if (notestyle.Attributes["id"].Value == "accent")
unote.Expressions["accent"].Data = int.Parse(notestyle.InnerText);
else if (notestyle.Attributes["id"].Value == "decay")
unote.Expressions["decay"].Data = int.Parse(notestyle.InnerText);
}
unote.PitchBend.Points[0].X = -uproject.TickToMillisecond(Math.Min(15, unote.DurTick / 3));
unote.PitchBend.Points[1].X = -unote.PitchBend.Points[0].X;
upart.Notes.Add(unote);
}
}
}
return uproject;
}
static void LoadPrefixMap(USinger singer)
{
string path = singer.Path;
if (File.Exists(Path.Combine(path, "prefix.map")))
{
string[] lines;
try
{
lines = File.ReadAllLines(Path.Combine(path, "prefix.map"));
}
catch
{
throw new Exception("Prefix map exists but cannot be opened for read.");
}
foreach (string line in lines)
{
var s = line.Trim().Split(new char[0], StringSplitOptions.RemoveEmptyEntries);
if (s.Count() == 2)
{
string source = s[0];
string target = s[1];
singer.PitchMap.Add(source, target);
}
}
}
}
static void LoadOto(string dirpath, string path, USinger singer)
{
string file = Path.Combine(dirpath, "oto.ini");
string relativeDir = dirpath.Replace(path, "");
while (relativeDir.StartsWith("\\")) relativeDir = relativeDir.Substring(1);
string[] lines = File.ReadAllLines(file, singer.FileEncoding);
List<string> errorLines = new List<string>();
foreach (var line in lines)
{
var s = line.Split(new[] { '=' });
if (s.Count() == 2)
{
string wavfile = s[0];
var args = s[1].Split(new[] { ',' });
if (singer.AliasMap.ContainsKey(args[0])) continue;
try
{
singer.AliasMap.Add(args[0], new UOto()
{
File = Path.Combine(relativeDir, wavfile),
Alias = args[0],
Offset = double.Parse(args[1]),
Consonant = double.Parse(args[2]),
Cutoff = double.Parse(args[3]),
Preutter = double.Parse(args[4]),
Overlap = double.Parse(args[5])
});
}
catch
{
errorLines.Add(line);
}
}
}
if (errorLines.Count > 0)
System.Diagnostics.Debug.WriteLine(string.Format(
"Oto file {0} has following errors:\n{1}", file, string.Join("\n", errorLines.ToArray())));
}
static void LoadOtos(USinger singer)
{
string path = singer.Path;
if (File.Exists(Path.Combine(path, "oto.ini"))) LoadOto(path, path, singer);
foreach (var dirpath in Directory.EnumerateDirectories(path))
if (File.Exists(Path.Combine(dirpath, "oto.ini"))) LoadOto(dirpath, path, singer);
}
