Пример #1
0
 /// <summary>
 /// Constructs a MidiEvent from a BinaryStream
 /// </summary>
 /// <param name="br">The binary stream of MIDI data</param>
 /// <param name="previous">The previous MIDI event (pass null for first event)</param>
 /// <returns>A new MidiEvent</returns>
 public static MidiEvent ReadNextEvent(BinaryReader br, MidiEvent previous) 
 {
     int deltaTime = MidiEvent.ReadVarInt(br);
     MidiCommandCode commandCode;
     int channel = 1;
     byte b = br.ReadByte();
     if((b & 0x80) == 0) 
     {
         // a running command - command & channel are same as previous
         commandCode = previous.CommandCode;
         channel = previous.Channel;
         br.BaseStream.Position--; // need to push this back
     }
     else 
     {
         if((b & 0xF0) == 0xF0) 
         {
             // both bytes are used for command code in this case
             commandCode = (MidiCommandCode) b;
         }
         else 
         {
             commandCode = (MidiCommandCode) (b & 0xF0);
             channel = (b & 0x0F) + 1;
         }
     }
     
     MidiEvent me;
     switch(commandCode) 
     {
     case MidiCommandCode.NoteOn:
         me = new NoteOnEvent(br);
         break;
     case MidiCommandCode.NoteOff:
     case MidiCommandCode.KeyAfterTouch:
         me = new NoteEvent(br);
         break;
     case MidiCommandCode.ControlChange:
         me = new ControlChangeEvent(br);
         break;
     case MidiCommandCode.PatchChange:
         me = new PatchChangeEvent(br);
         break;
     case MidiCommandCode.ChannelAfterTouch:
         me = new ChannelAfterTouchEvent(br);
         break;
     case MidiCommandCode.PitchWheelChange:
         me = new PitchWheelChangeEvent(br);
         break;
     case MidiCommandCode.TimingClock:
     case MidiCommandCode.StartSequence:
     case MidiCommandCode.ContinueSequence:
     case MidiCommandCode.StopSequence:
         me = new MidiEvent();
         break;
     case MidiCommandCode.Sysex:
         me = SysexEvent.ReadSysexEvent(br);
         break;
     case MidiCommandCode.MetaEvent:
         me = MetaEvent.ReadMetaEvent(br);
         break;
     default:
         throw new FormatException(String.Format("Unsupported MIDI Command Code {0:X2}",(byte) commandCode));
     }
     me.channel = channel;
     me.deltaTime = deltaTime;
     me.commandCode = commandCode;
     return me;
 }
Пример #2
0
 /// <summary>
 /// Determines if this is an end track event
 /// </summary>
 public static bool IsEndTrack(MidiEvent midiEvent)
 {
     if (midiEvent != null)
     {
         MetaEvent me = midiEvent as MetaEvent;
         if (me != null)
         {
             return me.MetaEventType == MetaEventType.EndTrack;
         }
     }
     return false;
 }
Пример #3
0
        /// <summary>
        /// Creates a MidiEvent from a raw message received using
        /// the MME MIDI In APIs
        /// </summary>
        /// <param name="rawMessage">The short MIDI message</param>
        /// <returns>A new MIDI Event</returns>
        public static MidiEvent FromRawMessage(int rawMessage)
        {
            long absoluteTime = 0;
            int b = rawMessage & 0xFF;
            int data1 = (rawMessage >> 8) & 0xFF;
            int data2 = (rawMessage >> 16) & 0xFF;
            MidiCommandCode commandCode;
            int channel = 1;

            if ((b & 0xF0) == 0xF0)
            {
                // both bytes are used for command code in this case
                commandCode = (MidiCommandCode)b;
            }
            else
            {
                commandCode = (MidiCommandCode)(b & 0xF0);
                channel = (b & 0x0F) + 1;
            }

            MidiEvent me;
            switch (commandCode)
            {
                case MidiCommandCode.NoteOn:
                case MidiCommandCode.NoteOff:
                case MidiCommandCode.KeyAfterTouch:
                    if (data2 > 0 && commandCode == MidiCommandCode.NoteOn)
                    {
                        me = new NoteOnEvent(absoluteTime, channel, data1, data2, 0);
                    }
                    else
                    {
                        me = new NoteEvent(absoluteTime, channel, commandCode, data1, data2);
                    }
                    break;
                case MidiCommandCode.ControlChange:
                    me = new ControlChangeEvent(absoluteTime,channel,(MidiController)data1,data2);
                    break;
                case MidiCommandCode.PatchChange:
                    me = new PatchChangeEvent(absoluteTime,channel,data1);
                    break;
                case MidiCommandCode.ChannelAfterTouch:
                    me = new ChannelAfterTouchEvent(absoluteTime,channel,data1);
                    break;
                case MidiCommandCode.PitchWheelChange:
                    me = new PitchWheelChangeEvent(absoluteTime, channel, data1 + (data2 << 7));
                    break;
                case MidiCommandCode.TimingClock:
                case MidiCommandCode.StartSequence:
                case MidiCommandCode.ContinueSequence:
                case MidiCommandCode.StopSequence:
                case MidiCommandCode.AutoSensing:
                    me = new MidiEvent(absoluteTime,channel,commandCode);
                    break;
                case MidiCommandCode.MetaEvent:
                case MidiCommandCode.Sysex:
                default:
                    throw new FormatException(String.Format("Unsupported MIDI Command Code for Raw Message {0}", commandCode));
            }
            return me;

        }
Пример #4
0
 /// <summary>
 /// Whether this is a note on event
 /// </summary>
 public static bool IsNoteOn(MidiEvent midiEvent)
 {
     if (midiEvent != null)
     {
         if (midiEvent.CommandCode == MidiCommandCode.NoteOn)
         {
             NoteEvent ne = (NoteEvent)midiEvent;
             return (ne.Velocity > 0);
         }
     }
     return false;
 }
Пример #5
0
        /// <summary>
        /// Opens a MIDI file for reading
        /// </summary>
        /// <param name="filename">Name of MIDI file</param>
        /// <param name="strictChecking">If true will error on non-paired note events</param>
        public MidiFile(string filename, bool strictChecking)
        {
            this.strictChecking = strictChecking;

            var br = new BinaryReader(File.OpenRead(filename));

            using (br)
            {
                string chunkHeader = Encoding.UTF8.GetString(br.ReadBytes(4));
                if (chunkHeader != "MThd")
                {
                    throw new FormatException("Not a MIDI file - header chunk missing");
                }
                uint chunkSize = SwapUInt32(br.ReadUInt32());

                if (chunkSize != 6)
                {
                    throw new FormatException("Unexpected header chunk length");
                }
                // 0 = single track, 1 = multi-track synchronous, 2 = multi-track asynchronous
                fileFormat = SwapUInt16(br.ReadUInt16());
                int tracks = SwapUInt16(br.ReadUInt16());
                deltaTicksPerQuarterNote = SwapUInt16(br.ReadUInt16());

                events = new MidiEventCollection((fileFormat == 0) ? 0 : 1, deltaTicksPerQuarterNote);
                for (int n = 0; n < tracks; n++)
                {
                    events.AddTrack();
                }

                long absoluteTime = 0;

                for (int track = 0; track < tracks; track++)
                {
                    if (fileFormat == 1)
                    {
                        absoluteTime = 0;
                    }
                    chunkHeader = Encoding.UTF8.GetString(br.ReadBytes(4));
                    if (chunkHeader != "MTrk")
                    {
                        throw new FormatException("Invalid chunk header");
                    }
                    chunkSize = SwapUInt32(br.ReadUInt32());

                    long      startPos           = br.BaseStream.Position;
                    MidiEvent me                 = null;
                    var       outstandingNoteOns = new List <NoteOnEvent>();
                    while (br.BaseStream.Position < startPos + chunkSize)
                    {
                        me              = MidiEvent.ReadNextEvent(br, me);
                        absoluteTime   += me.DeltaTime;
                        me.AbsoluteTime = absoluteTime;
                        events[track].Add(me);
                        if (me.CommandCode == MidiCommandCode.NoteOn)
                        {
                            NoteEvent ne = (NoteEvent)me;
                            if (ne.Velocity > 0)
                            {
                                outstandingNoteOns.Add((NoteOnEvent)ne);
                            }
                            else
                            {
                                // don't remove the note offs, even though
                                // they are annoying
                                // events[track].Remove(me);
                                FindNoteOn(ne, outstandingNoteOns);
                            }
                        }
                        else if (me.CommandCode == MidiCommandCode.NoteOff)
                        {
                            FindNoteOn((NoteEvent)me, outstandingNoteOns);
                        }
                        else if (me.CommandCode == MidiCommandCode.MetaEvent)
                        {
                            MetaEvent metaEvent = (MetaEvent)me;
                            if (metaEvent.MetaEventType == MetaEventType.EndTrack)
                            {
                                //break;
                                // some dodgy MIDI files have an event after end track
                                if (strictChecking)
                                {
                                    if (br.BaseStream.Position < startPos + chunkSize)
                                    {
                                        throw new FormatException(String.Format("End Track event was not the last MIDI event on track {0}", track));
                                    }
                                }
                            }
                        }
                    }
                    if (outstandingNoteOns.Count > 0)
                    {
                        if (strictChecking)
                        {
                            throw new FormatException(String.Format("Note ons without note offs {0} (file format {1})", outstandingNoteOns.Count, fileFormat));
                        }
                    }
                    if (br.BaseStream.Position != startPos + chunkSize)
                    {
                        throw new FormatException(String.Format("Read too far {0}+{1}!={2}", chunkSize, startPos, br.BaseStream.Position));
                    }
                }
            }
        }