private void ParsePitch(XmlElement element, Track track, Beat beat, Note note)
{
string step = null;
int semitones = 0;
int octave = 0;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "step":
step = Std.GetNodeValue(e);
break;
case "alter":
semitones = Std.ParseInt(Std.GetNodeValue(e));
break;
case "octave":
// 0-9, 4 for middle C
octave = Std.ParseInt(Std.GetNodeValue(e));
break;
}
}
});
var fullNoteName = step + octave;
var fullNoteValue = TuningParser.GetTuningForText(fullNoteName) + semitones;
ApplyNoteStringFrets(track, beat, note, fullNoteValue);
}
private void ParseScorePart(XmlElement element)
{
string id = element.GetAttribute("id");
var track = new Track();
_trackById[id] = track;
_score.AddTrack(track);
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "part-name":
track.Name = Std.GetNodeValue(c.FirstChild);
break;
case "part-abbreviation":
track.ShortName = Std.GetNodeValue(c.FirstChild);
break;
case "midi-instrument":
ParseMidiInstrument(e, track);
break;
}
}
});
if (track.Tuning == null || track.Tuning.Length == 0)
{
track.Tuning = Tuning.GetDefaultTuningFor(6).Tunings;
}
}
private void ParseClef(XmlElement element, Bar bar)
{
string sign = null;
string line = null;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "sign":
sign = Std.GetNodeValue(e);
break;
case "line":
line = Std.GetNodeValue(e);
break;
}
}
});
var clef = sign + line;
switch (clef)
{
case "G2":
bar.Clef = Clef.G2;
break;
case "F4":
bar.Clef = Clef.F4;
break;
case "C3":
bar.Clef = Clef.C3;
break;
case "C4":
bar.Clef = Clef.C4;
break;
}
}
private void ParsePartwise(XmlElement element)
{
var version = element.GetAttribute("version");
if (!string.IsNullOrEmpty(version) && version != "2.0")
{
throw new UnsupportedFormatException();
}
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "movement-title":
_score.Title = Std.GetNodeValue(c.FirstChild);
break;
case "identification":
ParseIdentification(e);
break;
case "part-list":
ParsePartList(e);
break;
case "part":
ParsePart(e);
break;
}
}
});
}
private void ParseVoice(XmlElement node)
{
var voice = new Voice();
var voiceId = node.Attributes["id"].Value;
node.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "Beats":
_beatsOfVoice[voiceId] = GetValue(c).Split(' ');
break;
}
}
});
_voiceById[voiceId] = voice;
}
private void ParseBeat(XmlElement node)
{
var beat = new Beat();
var beatId = node.Attributes["id"].Value;
node.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
XmlElement e = (XmlElement) c;
switch (c.LocalName)
{
case "Notes":
_notesOfBeat[beatId] = GetValue(c).Split(' ');
break;
case "Rhythm":
_rhythmOfBeat[beatId] = e.Attributes["ref"].Value;
break;
case "Fadding":
if (GetValue(c) == "FadeIn")
{
beat.FadeIn = true;
}
break;
case "Tremolo":
switch (GetValue(c))
{
case "1/2":
beat.TremoloSpeed = Duration.Eighth;
break;
case "1/4":
beat.TremoloSpeed = Duration.Sixteenth;
break;
case "1/8":
beat.TremoloSpeed = Duration.ThirtySecond;
break;
}
break;
case "Chord":
beat.ChordId = GetValue(c);
break;
case "Hairpin":
switch (GetValue(c))
{
case "Crescendo":
beat.Crescendo = CrescendoType.Crescendo;
break;
case "Decrescendo":
beat.Crescendo = CrescendoType.Decrescendo;
break;
}
break;
case "Arpeggio":
if (GetValue(c) == "Up")
{
beat.BrushType = BrushType.ArpeggioUp;
}
else
{
beat.BrushType = BrushType.ArpeggioDown;
}
break;
// TODO: brushDuration
case "Properties":
ParseBeatProperties(c, beat);
break;
case "FreeText":
beat.Text = GetValue(c);
break;
case "Dynamic":
switch (GetValue(c))
{
case "PPP":
beat.Dynamic = DynamicValue.PPP;
break;
case "PP":
beat.Dynamic = DynamicValue.PP;
break;
case "P":
beat.Dynamic = DynamicValue.P;
break;
case "MP":
beat.Dynamic = DynamicValue.MP;
break;
case "MF":
beat.Dynamic = DynamicValue.MF;
break;
case "F":
beat.Dynamic = DynamicValue.F;
break;
case "FF":
beat.Dynamic = DynamicValue.FF;
break;
case "FFF":
beat.Dynamic = DynamicValue.FFF;
break;
}
break;
case "GraceNotes":
switch (GetValue(c))
{
case "OnBeat":
beat.GraceType = GraceType.OnBeat;
break;
case "BeforeBeat":
beat.GraceType = GraceType.BeforeBeat;
break;
}
break;
}
}
});
_beatById[beatId] = beat;
}
private void ParseMidiInstrument(XmlElement element, Track track)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "midi-channel":
track.PlaybackInfo.PrimaryChannel = Std.ParseInt(Std.GetNodeValue(c.FirstChild));
break;
case "midi-program":
track.PlaybackInfo.Program = Std.ParseInt(Std.GetNodeValue(c.FirstChild));
break;
case "midi-volume":
track.PlaybackInfo.Volume = Std.ParseInt(Std.GetNodeValue(c.FirstChild));
break;
}
}
});
}
private void ParseRhythm(XmlElement node)
{
var rhythm = new GpxRhythm();
var rhythmId = node.Attributes["id"].Value;
node.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
XmlElement e = (XmlElement) c;
switch (c.LocalName)
{
case "NoteValue":
switch (GetValue(c))
{
// case "Long":
// case "DoubleWhole":
case "Whole":
rhythm.Value = Duration.Whole;
break;
case "Half":
rhythm.Value = Duration.Half;
break;
case "Quarter":
rhythm.Value = Duration.Quarter;
break;
case "Eighth":
rhythm.Value = Duration.Eighth;
break;
case "16th":
rhythm.Value = Duration.Sixteenth;
break;
case "32nd":
rhythm.Value = Duration.ThirtySecond;
break;
case "64th":
rhythm.Value = Duration.SixtyFourth;
// case "128th":
// case "256th":
break;
}
break;
case "PrimaryTuplet":
rhythm.TupletNumerator = Std.ParseInt(e.Attributes["num"].Value);
rhythm.TupletDenominator = Std.ParseInt(e.Attributes["den"].Value);
break;
case "AugmentationDot":
rhythm.Dots = Std.ParseInt(e.Attributes["count"].Value);
break;
}
}
});
_rhythmById[rhythmId] = rhythm;
}
private void ParseKey(XmlElement element, MasterBar masterBar)
{
int fifths = int.MinValue;
int keyStep = int.MinValue;
int keyAlter = int.MinValue;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "fifths":
fifths = Std.ParseInt(Std.GetNodeValue(e));
break;
case "key-step":
keyStep = Std.ParseInt(Std.GetNodeValue(e));
break;
case "key-alter":
keyAlter = Std.ParseInt(Std.GetNodeValue(e));
break;
}
}
});
if (fifths != int.MinValue)
{
// TODO: check if this is conrrect
masterBar.KeySignature = fifths;
}
else
{
// TODO: map keyStep/keyAlter to internal keysignature
}
}
private void ParseMeasure(XmlElement element, Track track, bool isFirstMeasure)
{
var barIndex = 0;
if (isFirstMeasure)
{
_trackFirstMeasureNumber = Std.ParseInt(element.GetAttribute("number"));
barIndex = 0;
}
else
{
barIndex = Std.ParseInt(element.GetAttribute("number")) - _trackFirstMeasureNumber;
}
// create empty bars to the current index
Bar bar = null;
MasterBar masterBar = null;
for (int i = track.Bars.Count; i <= barIndex; i++)
{
bar = new Bar();
masterBar = GetOrCreateMasterBar(barIndex);
track.AddBar(bar);
for (int j = 0; j < _maxVoices; j++)
{
var emptyVoice = new Voice();
bar.AddVoice(emptyVoice);
var emptyBeat = new Beat { IsEmpty = true };
emptyVoice.AddBeat(emptyBeat);
}
}
bool chord = false;
bool isFirstBeat = true;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "note":
chord = ParseNoteBeat(e, track, bar, chord, isFirstBeat);
isFirstBeat = false;
break;
case "forward":
break;
case "direction":
ParseDirection(e, masterBar);
break;
case "attributes":
ParseAttributes(e, bar, masterBar);
break;
case "harmony":
// TODO
break;
case "sound":
// TODO
break;
case "barline":
// TODO
break;
}
}
});
}
private void ParseIdentification(XmlElement element)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "creator":
if (e.GetAttribute("type") == "composer")
{
_score.Music = Std.GetNodeValue(c.FirstChild);
}
break;
case "rights":
_score.Artist = Std.GetNodeValue(c.FirstChild);
break;
}
}
});
}
private void ParseDynamics(XmlElement element, Beat beat)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "p":
beat.Dynamic = DynamicValue.P;
break;
case "pp":
beat.Dynamic = DynamicValue.PP;
break;
case "ppp":
beat.Dynamic = DynamicValue.PPP;
break;
case "f":
beat.Dynamic = DynamicValue.F;
break;
case "ff":
beat.Dynamic = DynamicValue.FF;
break;
case "fff":
beat.Dynamic = DynamicValue.FFF;
break;
case "mp":
beat.Dynamic = DynamicValue.MP;
break;
case "mf":
beat.Dynamic = DynamicValue.MF;
break;
}
}
});
}
private void ParseDirection(XmlElement element, MasterBar masterBar)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "sound":
var tempoAutomation = new Automation();
tempoAutomation.IsLinear = true;
tempoAutomation.Type = AutomationType.Tempo;
tempoAutomation.Value = Std.ParseInt(e.GetAttribute("tempo"));
masterBar.TempoAutomation = tempoAutomation;
break;
}
}
});
}
private void ParseTime(XmlElement element, MasterBar masterBar)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "beats":
masterBar.TimeSignatureNumerator = Std.ParseInt(Std.GetNodeValue(e));
break;
case "beats-type":
masterBar.TimeSignatureDenominator = Std.ParseInt(Std.GetNodeValue(e));
break;
}
}
});
}
private void ParseNotations(XmlElement element, Beat beat, Note note)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "tied":
ParseTied(e, note);
break;
case "slide":
if (e.GetAttribute("type") == "start")
{
note.SlideType = SlideType.Legato;
}
break;
case "dynamics":
ParseDynamics(e, beat);
break;
}
}
});
}
private void ParseTimeModification(XmlElement element, Beat beat)
{
var actualNodes = 0;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "actual-notes":
beat.TupletNumerator = Std.ParseInt(Std.GetNodeValue(e));
break;
case "normal-notes":
beat.TupletDenominator = Std.ParseInt(Std.GetNodeValue(e));
break;
//case "normal-type":
// break;
//case "normal-dot":
// break;
}
}
});
}
private bool ParseNoteBeat(XmlElement element, Track track, Bar bar, bool chord, bool isFirstBeat)
{
int voiceIndex = 0;
var voiceNodes = element.GetElementsByTagName("voice");
if (voiceNodes.Count > 0)
{
voiceIndex = Std.ParseInt(Std.GetNodeValue(voiceNodes.Item(0))) - 1;
}
Beat beat;
var voice = GetOrCreateVoice(bar, voiceIndex);
if (chord || (isFirstBeat && voice.Beats.Count == 1))
{
beat = voice.Beats[voice.Beats.Count - 1];
}
else
{
beat = new Beat();
voice.AddBeat(beat);
}
var note = new Note();
beat.AddNote(note);
beat.IsEmpty = false;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "grace":
//var slash = e.GetAttribute("slash");
//var makeTime = Std.ParseInt(e.GetAttribute("make-time"));
//var stealTimePrevious = Std.ParseInt(e.GetAttribute("steal-time-previous"));
//var stealTimeFollowing = Std.ParseInt(e.GetAttribute("steal-time-following"));
beat.GraceType = GraceType.BeforeBeat;
beat.Duration = Duration.ThirtySecond;
break;
case "duration":
beat.Duration = (Duration)Std.ParseInt(Std.GetNodeValue(e));
break;
case "tie":
ParseTied(e, note);
break;
case "cue":
// not supported
break;
case "instrument":
// not supported
break;
case "type":
switch (Std.GetNodeValue(e))
{
//case "256th":
// break;
//case "128th":
// break;
//case "breve":
// break;
//case "long":
// break;
case "64th":
beat.Duration = Duration.SixtyFourth;
break;
case "32nd":
beat.Duration = Duration.ThirtySecond;
break;
case "16th":
beat.Duration = Duration.Sixteenth;
break;
case "eighth":
beat.Duration = Duration.Eighth;
break;
case "quarter":
beat.Duration = Duration.Quarter;
break;
case "half":
beat.Duration = Duration.Half;
break;
case "whole":
beat.Duration = Duration.Whole;
break;
}
break;
case "dot":
note.IsStaccato = true;
break;
case "accidental":
ParseAccidental(e, note);
break;
case "time-modification":
ParseTimeModification(e, beat);
break;
case "stem":
// not supported
break;
case "notehead":
if (e.GetAttribute("parentheses") == "yes")
{
note.IsGhost = true;
}
break;
case "beam":
// not supported
break;
case "notations":
ParseNotations(e, beat, note);
break;
case "lyric":
// not supported
break;
// "full-note"
case "chord":
chord = true;
break;
case "pitch":
ParsePitch(e, track, beat, note);
break;
case "unpitched":
// TODO: not yet fully supported
note.String = 0;
note.Fret = 0;
break;
case "rest":
beat.IsEmpty = false;
break;
}
}
});
return chord;
}
private void ParseTrack(XmlElement node)
{
var track = new Track();
var trackId = node.Attributes["id"].Value;
node.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "Name":
track.Name = GetValue(c);
break;
case "ShortName":
track.ShortName = GetValue(c);
break;
//TODO: case "Lyrics": parseLyrics(track, c);
case "Properties":
ParseTrackProperties(track, c);
break;
case "GeneralMidi":
ParseGeneralMidi(track, c);
break;
case "PlaybackState":
var state = GetValue(c);
track.PlaybackInfo.IsSolo = state == "Solo";
track.PlaybackInfo.IsMute = state == "Mute";
break;
}
}
});
_tracksById[trackId] = track;
}
private void ParsePart(XmlElement element)
{
var id = element.GetAttribute("id");
var track = _trackById[id];
var isFirstMeasure = true;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "measure":
ParseMeasure(e, track, isFirstMeasure);
isFirstMeasure = false;
break;
}
}
});
}
private void ParseBar(XmlElement node)
{
var bar = new Bar();
var barId = node.Attributes["id"].Value;
node.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "Voices":
_voicesOfBar[barId] = GetValue(c).Split(' ');
break;
case "Clef":
switch (GetValue(c))
{
case "Neutral":
bar.Clef = Clef.Neutral;
break;
case "G2":
bar.Clef = Clef.G2;
break;
case "F4":
bar.Clef = Clef.F4;
break;
case "C4":
bar.Clef = Clef.C4;
break;
case "C3":
bar.Clef = Clef.C3;
break;
}
break;
// case "SimileMark":
}
}
});
_barsById[barId] = bar;
}
private void ParsePartList(XmlElement element)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "score-part":
ParseScorePart(e);
break;
}
}
});
}
private void ParseNote(XmlElement node)
{
var note = new Note();
var noteId = node.Attributes["id"].Value;
node.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
XmlElement e = (XmlElement) c;
switch (c.LocalName)
{
case "Properties":
ParseNoteProperties(c, note, noteId);
break;
case "AntiAccent":
if (GetValue(c).ToLower() == "normal")
{
note.IsGhost = true;
}
break;
case "LetRing":
note.IsLetRing = true;
break;
case "Trill":
note.TrillValue = Std.ParseInt(GetValue(c));
note.TrillSpeed = Duration.Sixteenth;
break;
case "Accent":
var accentFlags = Std.ParseInt(GetValue(c));
if ((accentFlags & 0x01) != 0)
note.IsStaccato = true;
if ((accentFlags & 0x04) != 0)
note.Accentuated = AccentuationType.Heavy;
if ((accentFlags & 0x08) != 0)
note.Accentuated = AccentuationType.Normal;
break;
case "Tie":
if (e.Attributes["origin"].Value.ToLower() == "true")
{
note.IsTieOrigin = true;
}
if (e.Attributes["destination"].Value.ToLower() == "true")
{
note.IsTieDestination = true;
}
break;
case "Vibrato":
switch (GetValue(c))
{
case "Slight":
note.Vibrato = VibratoType.Slight;
break;
case "Wide":
note.Vibrato = VibratoType.Wide;
break;
}
break;
}
}
});
_noteById[noteId] = note;
}
private void ParseAttributes(XmlElement element, Bar bar, MasterBar masterBar)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
var e = (XmlElement)c;
switch (c.LocalName)
{
case "key":
ParseKey(e, masterBar);
break;
case "time":
ParseTime(e, masterBar);
break;
case "clef":
ParseClef(e, bar);
break;
}
}
});
}
