public void AddMetaData()
{
//create metadata track
Track t = new Track();
byte[] tempo = new byte[3];
int ms_per_min = 60000000;
int ms_per_quarternote = ms_per_min / FBPM;
tempo[0] = (byte)((ms_per_quarternote >> 16) & byte.MaxValue);
tempo[1] = (byte)((ms_per_quarternote >> 8) & byte.MaxValue);
tempo[2] = (byte)(ms_per_quarternote & byte.MaxValue);
TempoChangeBuilder tcBuilder = new TempoChangeBuilder(new MetaMessage(MetaType.Tempo, tempo));
tcBuilder.Build();
t.Insert(1, tcBuilder.Result);
byte[] timesignature = new byte[4];
timesignature[0] = FTimeSignature.Numerator;
timesignature[1] = (byte)Math.Log(FTimeSignature.Denominator, 2);
timesignature[2] = FTimeSignature.MetronomePulse;
timesignature[3] = FTimeSignature.NumberOf32nds;
TimeSignatureBuilder tsBuilder = new TimeSignatureBuilder(new MetaMessage(MetaType.TimeSignature, timesignature));
tsBuilder.Build();
t.Insert(2, tsBuilder.Result);
FSequence.Add(t);
}
private void addTimeSignature(TimeSignature timeSignature)
{
if (currentTimeSignature == timeSignature || timeSignature == null)
{
if (currentTimeSignature == null)
{
addTimeSignature(new TimeSignature()
{
NumberOfBeats = 4, TimeOfBeats = 4
});
}
return;
}
else
{
currentTimeSignature = timeSignature;
}
TimeSignatureBuilder timeSignatureBuilder = new TimeSignatureBuilder();
timeSignatureBuilder.Numerator = (byte)currentTimeSignature.NumberOfBeats;
if (IsPowerOfTwo(currentTimeSignature.TimeOfBeats))
{
timeSignatureBuilder.Denominator = 8;
}
else
{
timeSignatureBuilder.Denominator = (byte)currentTimeSignature.TimeOfBeats;
}
timeSignatureBuilder.ClocksPerMetronomeClick = 24;
timeSignatureBuilder.ThirtySecondNotesPerQuarterNote = 8;
timeSignatureBuilder.Build();
sequence[0].Insert(currentTick, timeSignatureBuilder.Result);
}
public static MetaMessage BuildMessage(int numerator = 4, int denominator = 4, int clocksPerMetronomeClick = 24, int thirtySecondNotesPerQuarterNote = 8)
{
var sb = new TimeSignatureBuilder();
sb.Numerator = (byte)numerator;
sb.Denominator = (byte)denominator;
sb.ClocksPerMetronomeClick = (byte)clocksPerMetronomeClick;
sb.ThirtySecondNotesPerQuarterNote = (byte)thirtySecondNotesPerQuarterNote;
sb.Build();
return(sb.Result);
}
private Sequence CreateSequence()
{
if (tunes == null || tunes.Count < 2)
{
return(null);
}
selectedTune = 1;
SetDefaultValues();
nextNote = TimeSpan.Zero;
SetHeaderValues();
SetHeaderValues(selectedTune, true);
StartMeasure();
sequence = new Sequence(Ppqn);
sequence.Format = 1;
metaTrack = new Track();
mainTrack = new Track();
sequence.Add(metaTrack);
TempoChangeBuilder tempoBuilder = new TempoChangeBuilder();
tempoBuilder.Tempo = Tempo;
tempoBuilder.Build();
metaTrack.Insert(0, tempoBuilder.Result);
TimeSignatureBuilder timeBuilder = new TimeSignatureBuilder();
timeBuilder.Numerator = timeSigNumerator;
timeBuilder.Denominator = timeSigDenominator;
timeBuilder.Build();
metaTrack.Insert(0, timeBuilder.Result);
sequence.Add(mainTrack);
MetaTextBuilder textBuilder = new MetaTextBuilder();
textBuilder.Type = MetaType.TrackName;
textBuilder.Text = "Tempo Track";
textBuilder.Build();
metaTrack.Insert(0, textBuilder.Result);
textBuilder = new MetaTextBuilder();
textBuilder.Type = MetaType.TrackName;
textBuilder.Text = "Tune 1";
textBuilder.Build();
mainTrack.Insert(0, textBuilder.Result);
while (tokenIndex < tokens.Count)
{
AddNextNote();
}
return(sequence);
}
/// <summary>
/// Adds a MIDI message which sets the time signature
/// </summary>
/// <param name="numerator"></param>
/// <param name="denominator"></param>
public void SetTimeSignature(byte numerator, byte denominator)
{
TimeSignatureBuilder builder = new TimeSignatureBuilder
{
Numerator = numerator,
Denominator = denominator,
ClocksPerMetronomeClick = MetronomePulse,
ThirtySecondNotesPerQuarterNote = ThirtySecondNotesPerQuarterNote
};
builder.Build();
QueueMessage(builder.Result);
}
public Token Convert(LilypondTokenEnumerator enumerator)
{
enumerator.Next();
var signature = enumerator.Current;
string[] parts = signature.TokenText.Split('/');
var builder = new TimeSignatureBuilder();
if (int.TryParse(parts[0], out int count) && int.TryParse(parts[1], out int denominator))
{
builder.WithCount(count);
builder.WithDenominator(denominator);
}
return(builder.Build());
}