/// <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; }