/// <summary>
/// Builds the tempo change MetaMessage.
/// </summary>
public void Build()
{
// If the tempo has been changed since the last time the message
// was built.
if (changed)
{
byte[] data = new byte[MetaMessage.TempoLength];
// If this platform uses little endian byte order.
if (BitConverter.IsLittleEndian)
{
int d = data.Length - 1;
// Unpack tempo.
for (int i = 0; i < data.Length; i++)
{
data[d] = (byte)(tempo >> (Shift * i));
d--;
}
}
// Else this platform uses big endian byte order.
else
{
// Unpack tempo.
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(tempo >> (Shift * i));
}
}
changed = false;
result = new MetaMessage(MetaType.Tempo, data);
}
}
public void Process(MetaMessage message)
{
#region Require
if (message == null)
{
throw new ArgumentNullException("message");
}
#endregion
#region Guard
if (message.MetaType != MetaType.Tempo)
{
return;
}
#endregion
TempoChangeBuilder builder = new TempoChangeBuilder(message);
// Set the new tempo.
Tempo = builder.Tempo;
}
private void Write(int deltaTicks, MetaMessage message)
{
if (message.MetaType == MetaType.Tempo)
{
// Delta time.
events.AddRange(BitConverter.GetBytes(deltaTicks + offsetTicks));
// Stream ID.
events.AddRange(streamID);
TempoChangeBuilder builder = new TempoChangeBuilder(message);
byte[] t = BitConverter.GetBytes(builder.Tempo);
t[t.Length - 1] = MEVT_SHORTMSG | MEVT_TEMPO;
// Event code.
events.AddRange(t);
offsetTicks = 0;
}
else
{
offsetTicks += deltaTicks;
}
}
private void Write(MetaMessage message)
{
trackData.Add((byte)message.Status);
trackData.Add((byte)message.MetaType);
WriteVariableLengthValue(message.Length);
trackData.AddRange(message.GetBytes());
}
/// <summary>
/// Builds the time signature MetaMessage.
/// </summary>
public void Build()
{
// If any of the properties have changed since the last time the
// message was built.
if (changed)
{
result = new MetaMessage(MetaType.TimeSignature, data);
changed = false;
}
}
/// <summary>
/// Initializes the TimeSignatureBuilder with the specified MetaMessage.
/// </summary>
/// <param name="message">
/// The MetaMessage to use for initializing the TimeSignatureBuilder.
/// </param>
/// <exception cref="ArgumentException">
/// If the specified MetaMessage is not a time signature type.
/// </exception>
public void Initialize(MetaMessage message)
{
#region Require
if (message.MetaType != MetaType.TimeSignature)
{
throw new ArgumentException("Wrong meta event type.", "message");
}
#endregion
data = message.GetBytes();
}
/// <summary>
/// Builds the text MetaMessage.
/// </summary>
public void Build()
{
// If the text has changed since the last time this method was
// called.
if (changed)
{
//
// Build text MetaMessage.
//
ASCIIEncoding encoding = new ASCIIEncoding();
byte[] data = encoding.GetBytes(text);
result = new MetaMessage(Type, data);
changed = false;
}
}
/// <summary>
/// Initializes the MetaMessageTextBuilder with the specified MetaMessage.
/// </summary>
/// <param name="message">
/// The MetaMessage to use for initializing the MetaMessageTextBuilder.
/// </param>
/// <exception cref="ArgumentException">
/// If the MetaMessage is not a text based type.
/// </exception>
public void Initialize(MetaMessage message)
{
#region Require
if (!IsTextType(message.MetaType))
{
throw new ArgumentException("Not text based meta message.",
"message");
}
#endregion
ASCIIEncoding encoding = new ASCIIEncoding();
text = encoding.GetString(message.GetBytes());
this.type = message.MetaType;
}
/// <summary>
/// Initializes the TempoChangeBuilder with the specified MetaMessage.
/// </summary>
/// <param name="message">
/// The MetaMessage to use for initializing the TempoChangeBuilder.
/// </param>
/// <exception cref="ArgumentException">
/// If the specified MetaMessage is not a tempo type.
/// </exception>
public void Initialize(MetaMessage e)
{
#region Require
if (e == null)
{
throw new ArgumentNullException("e");
}
else if (e.MetaType != MetaType.Tempo)
{
throw new ArgumentException("Wrong meta message type.", "e");
}
#endregion
int t = 0;
// If this platform uses little endian byte order.
if (BitConverter.IsLittleEndian)
{
int d = e.Length - 1;
// Pack tempo.
for (int i = 0; i < e.Length; i++)
{
t |= e[d] << (Shift * i);
d--;
}
}
// Else this platform uses big endian byte order.
else
{
// Pack tempo.
for (int i = 0; i < e.Length; i++)
{
t |= e[i] << (Shift * i);
}
}
tempo = t;
}
/// <summary>
/// Determines whether two MetaMessage instances are equal.
/// </summary>
/// <param name="obj">
/// The MetaMessage to compare with the current MetaMessage.
/// </param>
/// <returns>
/// <b>true</b> if the specified MetaMessage is equal to the current
/// MetaMessage; otherwise, <b>false</b>.
/// </returns>
public override bool Equals(object obj)
{
#region Guard
if (!(obj is MetaMessage))
{
return(false);
}
#endregion
bool equal = true;
MetaMessage message = (MetaMessage)obj;
// If the types do not match.
if (MetaType != message.MetaType)
{
// The messages are not equal
equal = false;
}
// If the message lengths are not equal.
if (equal && Length != message.Length)
{
// The message are not equal.
equal = false;
}
// Check to see if the data is equal.
for (int i = 0; i < Length && equal; i++)
{
// If a data value does not match.
if (this[i] != message[i])
{
// The messages are not equal.
equal = false;
}
}
return(equal);
}
/// <summary>
/// Indicates whether or not the specified MetaType is a text based
/// type.
/// </summary>
/// <param name="type">
/// The MetaType to test.
/// </param>
/// <returns>
/// <b>true</b> if the MetaType is a text based type;
/// otherwise, <b>false</b>.
/// </returns>
private bool IsTextType(MetaType type)
{
bool result;
if (type == MetaType.Copyright ||
type == MetaType.CuePoint ||
type == MetaType.DeviceName ||
type == MetaType.InstrumentName ||
type == MetaType.Lyric ||
type == MetaType.Marker ||
type == MetaType.ProgramName ||
type == MetaType.Text ||
type == MetaType.TrackName)
{
result = true;
}
else
{
result = false;
}
return(result);
}
/// <summary>
/// Builds the key signature MetaMessage.
/// </summary>
public void Build()
{
byte[] data = new byte[MetaMessage.KeySigLength];
unchecked
{
switch (Key)
{
case Key.CFlatMajor:
data[0] = (byte)-7;
data[1] = 0;
break;
case Key.GFlatMajor:
data[0] = (byte)-6;
data[1] = 0;
break;
case Key.DFlatMajor:
data[0] = (byte)-5;
data[1] = 0;
break;
case Key.AFlatMajor:
data[0] = (byte)-4;
data[1] = 0;
break;
case Key.EFlatMajor:
data[0] = (byte)-3;
data[1] = 0;
break;
case Key.BFlatMajor:
data[0] = (byte)-2;
data[1] = 0;
break;
case Key.FMajor:
data[0] = (byte)-1;
data[1] = 0;
break;
case Key.CMajor:
data[0] = 0;
data[1] = 0;
break;
case Key.GMajor:
data[0] = 1;
data[1] = 0;
break;
case Key.DMajor:
data[0] = 2;
data[1] = 0;
break;
case Key.AMajor:
data[0] = 3;
data[1] = 0;
break;
case Key.EMajor:
data[0] = 4;
data[1] = 0;
break;
case Key.BMajor:
data[0] = 5;
data[1] = 0;
break;
case Key.FSharpMajor:
data[0] = 6;
data[1] = 0;
break;
case Key.CSharpMajor:
data[0] = 7;
data[1] = 0;
break;
case Key.AFlatMinor:
data[0] = (byte)-7;
data[1] = 1;
break;
case Key.EFlatMinor:
data[0] = (byte)-6;
data[1] = 1;
break;
case Key.BFlatMinor:
data[0] = (byte)-5;
data[1] = 1;
break;
case Key.FMinor:
data[0] = (byte)-4;
data[1] = 1;
break;
case Key.CMinor:
data[0] = (byte)-3;
data[1] = 1;
break;
case Key.GMinor:
data[0] = (byte)-2;
data[1] = 1;
break;
case Key.DMinor:
data[0] = (byte)-1;
data[1] = 1;
break;
case Key.AMinor:
data[0] = 1;
data[1] = 0;
break;
case Key.EMinor:
data[0] = 1;
data[1] = 1;
break;
case Key.BMinor:
data[0] = 2;
data[1] = 1;
break;
case Key.FSharpMinor:
data[0] = 3;
data[1] = 1;
break;
case Key.CSharpMinor:
data[0] = 4;
data[1] = 1;
break;
case Key.GSharpMinor:
data[0] = 5;
data[1] = 1;
break;
case Key.DSharpMinor:
data[0] = 6;
data[1] = 1;
break;
case Key.ASharpMinor:
data[0] = 7;
data[1] = 1;
break;
}
}
result = new MetaMessage(MetaType.KeySignature, data);
}
/// <summary>
/// Initializes a new instance of the MetaMessageTextBuilder class with the
/// specified MetaMessage.
/// </summary>
/// <param name="message">
/// The MetaMessage to use for initializing the MetaMessageTextBuilder.
/// </param>
/// <exception cref="ArgumentException">
/// If the MetaMessage is not a text based type.
/// </exception>
/// <remarks>
/// The MetaMessage must be one of the following text based types:
/// <list>
/// <item>
/// Copyright
/// </item>
/// <item>
/// Cuepoint
/// </item>
/// <item>
/// DeviceName
/// </item>
/// <item>
/// InstrumentName
/// </item>
/// <item>
/// Lyric
/// </item>
/// <item>
/// Marker
/// </item>
/// <item>
/// ProgramName
/// </item>
/// <item>
/// Text
/// </item>
/// <item>
/// TrackName
/// </item>
/// </list>
/// If the MetaMessage is not a text based type, an exception will be
/// thrown.
/// </remarks>
public MetaTextBuilder(MetaMessage message)
{
Initialize(message);
}
/// <summary>
/// Initialize a new instance of the TempoChangeBuilder class with the
/// specified MetaMessage.
/// </summary>
/// <param name="message">
/// The MetaMessage to use for initializing the TempoChangeBuilder class.
/// </param>
/// <exception cref="ArgumentException">
/// If the specified MetaMessage is not a tempo type.
/// </exception>
/// <remarks>
/// The TempoChangeBuilder uses the specified MetaMessage to initialize
/// its property values.
/// </remarks>
public TempoChangeBuilder(MetaMessage e)
{
Initialize(e);
}
/// <summary>
/// Initializes a new instance of the TimeSignatureBuilder class with the
/// specified MetaMessage.
/// </summary>
/// <param name="message">
/// The MetaMessage to use for initializing the TimeSignatureBuilder class.
/// </param>
/// <exception cref="ArgumentException">
/// If the specified MetaMessage is not a time signature type.
/// </exception>
/// <remarks>
/// The TimeSignatureBuilder uses the specified MetaMessage to
/// initialize its property values.
/// </remarks>
public TimeSignatureBuilder(MetaMessage message)
{
Initialize(message);
}
/// <summary>
/// Initializes the KeySignatureBuilder with the specified MetaMessage.
/// </summary>
/// <param name="message">
/// The key signature MetaMessage to use for initializing the
/// KeySignatureBuilder.
/// </param>
public void Initialize(MetaMessage message)
{
#region Require
if (message == null)
{
throw new ArgumentNullException("message");
}
else if (message.MetaType != MetaType.KeySignature)
{
throw new ArgumentException("Wrong meta event type.", "messaege");
}
#endregion
sbyte b = (sbyte)message[0];
// If the key is major.
if (message[1] == 0)
{
switch (b)
{
case -7:
key = Key.CFlatMajor;
break;
case -6:
key = Key.GFlatMajor;
break;
case -5:
key = Key.DFlatMajor;
break;
case -4:
key = Key.AFlatMajor;
break;
case -3:
key = Key.EFlatMajor;
break;
case -2:
key = Key.BFlatMajor;
break;
case -1:
key = Key.FMajor;
break;
case 0:
key = Key.CMajor;
break;
case 1:
key = Key.GMajor;
break;
case 2:
key = Key.DMajor;
break;
case 3:
key = Key.AMajor;
break;
case 4:
key = Key.EMajor;
break;
case 5:
key = Key.BMajor;
break;
case 6:
key = Key.FSharpMajor;
break;
case 7:
key = Key.CSharpMajor;
break;
}
}
// Else the key is minor.
else
{
switch (b)
{
case -7:
key = Key.AFlatMinor;
break;
case -6:
key = Key.EFlatMinor;
break;
case -5:
key = Key.BFlatMinor;
break;
case -4:
key = Key.FMinor;
break;
case -3:
key = Key.CMinor;
break;
case -2:
key = Key.GMinor;
break;
case -1:
key = Key.DMinor;
break;
case 0:
key = Key.AMinor;
break;
case 1:
key = Key.EMinor;
break;
case 2:
key = Key.BMinor;
break;
case 3:
key = Key.FSharpMinor;
break;
case 4:
key = Key.CSharpMinor;
break;
case 5:
key = Key.GSharpMinor;
break;
case 6:
key = Key.DSharpMinor;
break;
case 7:
key = Key.ASharpMinor;
break;
}
}
}
public MetaMessageEventArgs(MetaMessage message)
{
this.message = message;
}
