Beispiel #1
0
 private static void CloseMidiOut()
 {
     if (midi_out_handle != 0)
     {
         Midi.MidiOutClose(midi_out_handle);
     }
 }
Beispiel #2
0
        public static bool Present()
        {
            int num_in = Midi.MidiInGetNumDevs();

            for (int i = 0; i < num_in; i++)
            {
                string s = Midi.MidiInGetName(i);
                //if(s == "FLEX 5000" || s == "FLEX-5000 Midi" || s == "FlexRadio Flex-5000" || s == "FlexRadio Flex-5000 MIDI")
                if (s.IndexOf("FLEX") >= 0 || s.IndexOf("Flex") >= 0)
                {
                    goto test_out;
                }
            }

            //log.AddLine("Midi.Present(): False (no input dev)");
            return(false);

test_out:
            int num_out = Midi.MidiOutGetNumDevs();

            for (int i = 0; i < num_out; i++)
            {
                string s = Midi.MidiOutGetName(i);
                //if(s == "FLEX 5000" || s == "2- FLEX-5000 Midi" || s == "FlexRadio Flex-5000" || s == "2- FlexRadio Flex-5000 MIDI")
                if (s.IndexOf("FLEX") >= 0 || s.IndexOf("Flex") >= 0)
                {
                    return(true);
                }
            }

            //log.AddLine("Midi.Present(): False (no output dev)");
            return(false);
        }
Beispiel #3
0
        public static int ReadADC(int chan)
        {
            int data = (int)Command.NoteOn;

            data += ((byte)Note.PAADC) << 8;
            data += ((byte)chan) << 16;
            lock (out_lock_obj)
                if (Midi.MidiOutShortMessage(midi_out_handle, data) != 0)
                {
                    Debug.WriteLine("Error in SendShortMessage");
                }

            int counter = 0;
            int id      = chan;

            while (counter++ < 20)
            {
                if (midi_in_table.ContainsKey(id))
                {
                    int val = (int)midi_in_table[id];
                    midi_in_table.Remove(id);
                    return(val);
                }
                Thread.Sleep(50);
            }

            Debug.WriteLine("Timeout waiting on return Midi message.");
            return(0);
        }
Beispiel #4
0
        private static bool OpenMidiOut()
        {
            int num_out   = Midi.MidiOutGetNumDevs();
            int out_index = -1;

            for (int i = 0; i < num_out; i++)
            {
                string s = Midi.MidiOutGetName(i);
                //if(s == "FLEX 5000" || s == "2- FLEX-5000 Midi" || s == "FlexRadio Flex-5000" || s == "2- FlexRadio Flex-5000 MIDI")
                if (s.IndexOf("FLEX") >= 0 || s.IndexOf("Flex") >= 0)
                {
                    Debug.WriteLine("Midi Out Device Name: " + s);
                    out_index = i;
                    break;
                }
            }

            if (out_index < 0)
            {
                //MessageBox.Show("Error finding Midi Out device");
                return(false);
            }

            int result = Midi.MidiOutOpen(ref midi_out_handle, out_index, IntPtr.Zero, 0, 0);

            if (result != 0)
            {
                StringBuilder error_text = new StringBuilder(64);
                Midi.MidiInGetErrorText(result, error_text, 64);
                Debug.WriteLine("MidiOutOpen Error: " + error_text);
                //MessageBox.Show("Error Opening Midi Out device");
                return(false);
            }
            return(true);
        }
Beispiel #5
0
        private static bool OpenMidiIn()
        {
            int num_in   = Midi.MidiInGetNumDevs();
            int in_index = -1;

            for (int i = 0; i < num_in; i++)
            {
                string s = Midi.MidiInGetName(i);
                //if(s == "FLEX 5000" || s == "FLEX-5000 Midi" || s == "FlexRadio Flex-5000" || s == "FlexRadio Flex-5000 MIDI")
                if (s.IndexOf("FLEX") >= 0 || s.IndexOf("Flex") >= 0)
                {
                    Debug.WriteLine("Midi In Device Name: " + s);
                    in_index = i;
                    break;
                }
            }

            if (in_index < 0)
            {
                //MessageBox.Show("Error opening Midi In device");
                return(false);
            }

            callback = new Midi.MidiInCallback(InCallback);
            int result = Midi.MidiInOpen(ref midi_in_handle, in_index, callback, 0, Midi.CALLBACK_FUNCTION);

            if (result != 0)
            {
                StringBuilder error_text = new StringBuilder(64);
                Midi.MidiInGetErrorText(result, error_text, 64);
                Debug.WriteLine("MidiInOpen Error: " + error_text);
                //MessageBox.Show("Error opening Midi In device");
                return(false);
            }

            for (int i = 0; i < 3; i++)
            {
                result = Midi.AddSysExBuffer(midi_in_handle);
                if (result != 0)
                {
                    StringBuilder error_text = new StringBuilder(64);
                    Midi.MidiInGetErrorText(result, error_text, 64);
                    Debug.WriteLine("AddSysExBuffer Error: " + error_text);
                    //MessageBox.Show("Error adding Midi In device SysEx Buffer");
                    return(false);
                }
            }

            result = Midi.MidiInStart(midi_in_handle);
            if (result != 0)
            {
                StringBuilder error_text = new StringBuilder(64);
                Midi.MidiInGetErrorText(result, error_text, 64);
                Debug.WriteLine("MidiInStart Error: " + error_text);
                //MessageBox.Show("Error starting Midi In device");
                return(false);
            }

            return(true);
        }
Beispiel #6
0
 private static void CloseMidiIn()
 {
     if (midi_in_handle != 0)
     {
         Midi.MidiInStop(midi_in_handle);
         resetting = true;
         Midi.MidiInReset(midi_in_handle);
         Midi.MidiInClose(midi_in_handle);
         midi_in_handle = 0;
         resetting      = false;
     }
 }
Beispiel #7
0
        public static void SetMOX(bool b)
        {
            int data = 0;

            data  = (b ? (int)Command.NoteOn : (int)Command.NoteOff);
            data += ((byte)Note.Mox) << 8;
            data += (127 << 16);
            lock (out_lock_obj)
                if (Midi.MidiOutShortMessage(midi_out_handle, data) != 0)
                {
                    Debug.WriteLine("Error in SendShortMessage");
                }
        }
Beispiel #8
0
        public static int AddSysExBuffer(int handle)
        {
            int        result;
            IntPtr     headerPtr;
            int        size   = Marshal.SizeOf(typeof(MidiHeader));
            MidiHeader header = new MidiHeader();

            header.bufferLength  = 64;
            header.bytesRecorded = 0;
            header.data          = Marshal.AllocHGlobal(64);
            header.flags         = 0;

            try
            {
                headerPtr = Marshal.AllocHGlobal(size);
            }
            catch (Exception)
            {
                Marshal.FreeHGlobal(header.data);
                throw;
            }

            try
            {
                Marshal.StructureToPtr(header, headerPtr, false);
            }
            catch (Exception)
            {
                Marshal.FreeHGlobal(header.data);
                Marshal.FreeHGlobal(headerPtr);

                throw;
            }

            result = Midi.MidiInPrepareHeader(handle, headerPtr, size);
            if (result != 0)
            {
                return(result);
            }

            result = Midi.MidiInAddBuffer(handle, headerPtr, size);
            if (result != 0)
            {
                return(result);
            }

            return(result);
        }
Beispiel #9
0
        public static void ReleaseBuffer(int handle, IntPtr headerPtr)
        {
            int result = MidiInUnprepareHeader(handle, headerPtr, Marshal.SizeOf(typeof(MidiHeader)));

            if (result != 0)
            {
                StringBuilder error_text = new StringBuilder(64);
                Midi.MidiInGetErrorText(result, error_text, 64);
                Debug.WriteLine("MidiInUnprepareHeader Error: " + error_text);
                return;
            }

            MidiHeader header = (MidiHeader)Marshal.PtrToStructure(headerPtr, typeof(MidiHeader));

            Marshal.FreeHGlobal(header.data);
            Marshal.FreeHGlobal(headerPtr);
        }
Beispiel #10
0
        public static void SendSetMessage(Opcode opcode, uint data1, float data2)
        {
            ushort id = msgID++;

            byte[] msg = new byte[37];
            msg[0] = 0xF0;             // start byte
            msg[1] = 0x00;             // mfc highest byte
            msg[2] = 0x00;             // mfc high byte
            msg[3] = 0x41;             // mfc low byte

            byte[] guts = new byte[16];
            byte[] temp = new byte[32];

            byte[] temp2 = BitConverter.GetBytes(id);
            temp2.CopyTo(guts, 0);

            temp2 = BitConverter.GetBytes((uint)opcode);
            temp2.CopyTo(guts, 4);

            temp2 = BitConverter.GetBytes(data1);
            temp2.CopyTo(guts, 8);

            temp2 = BitConverter.GetBytes(data2);
            temp2.CopyTo(guts, 12);

            EncodeBytes(temp, guts);

            temp.CopyTo(msg, 4);
            //DebugByte(guts);

            /*DecodeBytes(guts, temp);
             * DebugByte(guts);*/

            msg[36] = 0xF7;
            //DebugByte(msg);

            lock (out_lock_obj)
                if (Midi.SendLongMessage(midi_out_handle, msg) != 0)
                {
                    Debug.WriteLine("Error in SendLongMessage");
                }
        }
Beispiel #11
0
        private static int InCallback(int hMidiIn, int wMsg, int dwInstance, int dwParam1, int dwParam2)
        {
            //log.AddLine("Midi.InCallback("+hMidiIn.ToString("X")+", "+wMsg.ToString("X")+", "+dwInstance.ToString("X")+", "+dwParam1.ToString("X")+", "+dwParam2.ToString("X")+")");
#if (TIMING)
            lock (in_lock_obj)
            {
                if (wMsg == Midi.MIM_DATA &&
                    (Command)((byte)dwParam1) == Command.NoteOn &&
                    (Note)(byte)(dwParam1 >> 8) == Note.Dot)
                {
                    FWCMidi.SendSetMessage(Opcode.RDAL_OP_WRITE_GPIO, 0x01, 0);
                    FWCMidi.SendSetMessage(Opcode.RDAL_OP_WRITE_GPIO, 0x00, 0);
                }
            }
#else
            lock (in_lock_obj)
            {
                switch (wMsg)
                {
                case Midi.MIM_DATA:
                    Command cmd   = (Command)((byte)dwParam1);
                    byte    byte1 = (byte)(dwParam1 >> 8);
                    byte    byte2 = (byte)(dwParam1 >> 16);

                    switch (cmd)
                    {
                    case Command.NoteOn:
                        switch ((Note)byte1)
                        {
                        case Note.Dot:
                            //console.Keyer.FWCDot = true;
                            CWSensorItem.InputType type = CWSensorItem.InputType.Dot;
                            if (reverse_paddles)
                            {
                                type = CWSensorItem.InputType.Dash;
                            }

                            CWSensorItem item = new CWSensorItem(type, true);
                            CWKeyer.SensorEnqueue(item);
                            break;

                        case Note.Dash:
                            //console.Keyer.FWCDash = true;
                            type = CWSensorItem.InputType.Dash;
                            if (reverse_paddles)
                            {
                                type = CWSensorItem.InputType.Dot;
                            }

                            item = new CWSensorItem(type, true);
                            CWKeyer.SensorEnqueue(item);
                            break;

                        case Note.MicDown:
                            if (console == null)
                            {
                                return(1);
                            }
                            console.MicDown = true;
                            break;

                        case Note.MicUp:
                            if (console == null)
                            {
                                return(1);
                            }
                            console.MicUp = true;
                            break;

                        case Note.MicFast:
                            if (console == null)
                            {
                                return(1);
                            }
                            console.MicFast = !console.MicFast;
                            break;
                        }
                        break;

                    case Command.NoteOff:
                        switch ((Note)byte1)
                        {
                        case Note.Dot:
                            //console.Keyer.FWCDot = false;
                            CWSensorItem.InputType type = CWSensorItem.InputType.Dot;
                            if (reverse_paddles)
                            {
                                type = CWSensorItem.InputType.Dash;
                            }

                            CWSensorItem item = new CWSensorItem(type, false);
                            CWKeyer.SensorEnqueue(item);
                            break;

                        case Note.Dash:
                            //console.Keyer.FWCDash = false;
                            type = CWSensorItem.InputType.Dash;
                            if (reverse_paddles)
                            {
                                type = CWSensorItem.InputType.Dot;
                            }

                            item = new CWSensorItem(type, false);
                            CWKeyer.SensorEnqueue(item);
                            break;

                        case Note.MicDown:
                            if (console == null)
                            {
                                return(1);
                            }
                            console.MicDown = false;
                            break;

                        case Note.MicUp:
                            if (console == null)
                            {
                                return(1);
                            }
                            console.MicUp = false;
                            break;

                        case Note.MicFast:
                            break;
                        }
                        break;

                    case Command.Controller:
                        switch ((Controller)byte1)
                        {
                        case Controller.HoldPedal:
                            if (console == null)
                            {
                                return(1);
                            }
                            console.FWCMicPTT = (byte2 > 63);
                            break;

                        case Controller.Hold2Pedal:
                            if (console == null)
                            {
                                return(1);
                            }
                            console.FWCRCAPTT = (byte2 > 63);
                            break;
                        }
                        break;

                    case Command.Aftertouch0:
                    case Command.Aftertouch1:
                        int id   = (ushort)((((byte)cmd - (byte)Command.Aftertouch0) << 2) + (byte1 >> 5));
                        int data = (int)(((byte1 & 0x1F) << 7) + byte2);
                        if (midi_in_table.ContainsKey(id))
                        {
                            midi_in_table.Remove(id);
                        }
                        midi_in_table.Add(id, data);
                        break;
                    }
                    break;

                case Midi.MIM_LONGDATA:
                    if (!resetting && midi_in_handle != 0)                            // in case device closes, don't send anymore buffers
                    {
                        int result = Midi.AddSysExBuffer(midi_in_handle);
                        if (result != 0)
                        {
                            StringBuilder error_text = new StringBuilder(64);
                            Midi.MidiInGetErrorText(result, error_text, 64);
                            Debug.WriteLine("AddSysExBuffer Error: " + error_text);
                        }
                    }

                    IntPtr          headerPtr = new IntPtr(dwParam1);
                    Midi.MidiHeader header    = (Midi.MidiHeader)Marshal.PtrToStructure(headerPtr, typeof(Midi.MidiHeader));
                    byte[]          temp      = new byte[header.bytesRecorded];
                    for (int i = 0; i < header.bytesRecorded; i++)
                    {
                        temp[i] = Marshal.ReadByte(header.data, i);
                    }

                    if (temp.Length > 5)
                    {
                        byte[] temp2 = new byte[temp.Length - 5];
                        for (int i = 0; i < temp.Length - 5; i++)
                        {
                            temp2[i] = temp[i + 4];
                        }

                        byte[] buf = new byte[temp2.Length / 2];
                        DecodeBytes(buf, temp2);
                        if (midi_in_table.ContainsKey(BitConverter.ToUInt16(buf, 0)))
                        {
                            midi_in_table.Remove(BitConverter.ToUInt16(buf, 0));
                        }
                        midi_in_table.Add(BitConverter.ToUInt16(buf, 0), buf);
                    }

                    /*for(int i=0; i<header.bytesRecorded; i++)
                     *      Debug.Write(buf[i].ToString("X")+" ");
                     * Debug.WriteLine("");*/

                    if (midi_in_handle != 0)
                    {
                        Midi.ReleaseBuffer(midi_in_handle, headerPtr);
                    }
                    break;
                }
            }
#endif
            return(0);
        }
Beispiel #12
0
        public static float SendGetMessageFloat(Opcode opcode, uint data1, uint data2)
        {
            ushort id = msgID++;

            byte[] msg = new byte[37];
            msg[0] = 0xF0;             // start byte
            msg[1] = 0x00;             // mfc highest byte
            msg[2] = 0x00;             // mfc high byte
            msg[3] = 0x41;             // mfc low byte

            byte[] guts = new byte[16];
            byte[] temp = new byte[32];

            byte[] temp2 = BitConverter.GetBytes(id);
            temp2.CopyTo(guts, 0);

            temp2 = BitConverter.GetBytes((uint)opcode);
            temp2.CopyTo(guts, 4);

            temp2 = BitConverter.GetBytes(data1);
            temp2.CopyTo(guts, 8);

            temp2 = BitConverter.GetBytes(data2);
            temp2.CopyTo(guts, 12);

            EncodeBytes(temp, guts);

            temp.CopyTo(msg, 4);
            //DebugByte(guts);

            /*DecodeBytes(guts, temp);
             * DebugByte(guts);*/

            msg[36] = 0xF7;
            //DebugByte(msg);

            lock (out_lock_obj)
                if (Midi.SendLongMessage(midi_out_handle, msg) != 0)
                {
                    Debug.WriteLine("Error in SendLongMessage");
                }

            int counter = 0;

            while (counter++ < 100)
            {
                if (midi_in_table.ContainsKey(id))
                {
                    byte[] buf = (byte[])midi_in_table[id];
                    midi_in_table.Remove(id);
                    return(BitConverter.ToSingle(buf, 2));
                }
                Thread.Sleep(10);
            }

            Debug.WriteLine("Timeout waiting on return Midi message.");

            /*Midi.MidiInStop(midi_in_handle);
             * Midi.MidiInReset(midi_in_handle);
             * Midi.AddSysExBuffer(midi_in_handle);
             * Midi.MidiInStart(midi_in_handle);*/
            return(0);
        }
Beispiel #13
0
        private static int InCallback(int hMidiIn, int wMsg, int dwInstance, int dwParam1, int dwParam2)
        {
            lock (in_lock_obj)
            {
                switch (wMsg)
                {
                case Midi.MIM_DATA:
                    Command cmd   = (Command)((byte)dwParam1);
                    byte    byte1 = (byte)(dwParam1 >> 8);
                    byte    byte2 = (byte)(dwParam1 >> 16);

                    switch (cmd)
                    {
                    case Command.NoteOn:
                        switch ((Note)byte1)
                        {
                        case Note.Dot:
                            console.Keyer.FWCDot = true;
                            //FWC.SetMOX(true);
                            break;

                        case Note.Dash:
                            console.Keyer.FWCDash = true;
                            //FWC.SetMOX(true);
                            break;

                        case Note.MicDown:
                            break;

                        case Note.MicUp:
                            break;

                        case Note.MicFast:
                            break;
                        }
                        break;

                    case Command.NoteOff:
                        switch ((Note)byte1)
                        {
                        case Note.Dot:
                            console.Keyer.FWCDot = false;
                            //FWC.SetMOX(false);
                            break;

                        case Note.Dash:
                            console.Keyer.FWCDash = false;
                            //FWC.SetMOX(false);
                            break;

                        case Note.MicDown:
                            break;

                        case Note.MicUp:
                            break;

                        case Note.MicFast:
                            break;
                        }
                        break;

                    case Command.Controller:
                        switch ((Controller)byte1)
                        {
                        case Controller.HoldPedal:
                            console.FWCMicPTT = (byte2 > 63);
                            break;

                        case Controller.Hold2Pedal:
                            console.FWCRCAPTT = (byte2 > 63);
                            break;
                        }
                        break;

                    case Command.Aftertouch0:
                    case Command.Aftertouch1:
                        int id   = (ushort)((((byte)cmd - (byte)Command.Aftertouch0) << 2) + (byte1 >> 5));
                        int data = (int)(((byte1 & 0x1F) << 7) + byte2);
                        if (midi_in_table.ContainsKey(id))
                        {
                            midi_in_table.Remove(id);
                        }
                        midi_in_table.Add(id, data);
                        break;
                    }
                    break;

                case Midi.MIM_LONGDATA:
                    if (!resetting && midi_in_handle != 0)                            // in case device closes, don't send anymore buffers
                    {
                        int result = Midi.AddSysExBuffer(midi_in_handle);
                        if (result != 0)
                        {
                            StringBuilder error_text = new StringBuilder(64);
                            Midi.MidiInGetErrorText(result, error_text, 64);
                            Debug.WriteLine("AddSysExBuffer Error: " + error_text);
                        }
                    }

                    IntPtr          headerPtr = new IntPtr(dwParam1);
                    Midi.MidiHeader header    = (Midi.MidiHeader)Marshal.PtrToStructure(headerPtr, typeof(Midi.MidiHeader));
                    byte[]          temp      = new byte[header.bytesRecorded];
                    for (int i = 0; i < header.bytesRecorded; i++)
                    {
                        temp[i] = Marshal.ReadByte(header.data, i);
                    }

                    if (temp.Length > 5)
                    {
                        byte[] temp2 = new byte[temp.Length - 5];
                        for (int i = 0; i < temp.Length - 5; i++)
                        {
                            temp2[i] = temp[i + 4];
                        }

                        byte[] buf = new byte[temp2.Length / 2];
                        DecodeBytes(buf, temp2);
                        if (midi_in_table.ContainsKey(BitConverter.ToUInt16(buf, 0)))
                        {
                            midi_in_table.Remove(BitConverter.ToUInt16(buf, 0));
                        }
                        midi_in_table.Add(BitConverter.ToUInt16(buf, 0), buf);
                    }

                    /*for(int i=0; i<header.bytesRecorded; i++)
                     *      Debug.Write(buf[i].ToString("X")+" ");
                     * Debug.WriteLine("");*/

                    if (midi_in_handle != 0)
                    {
                        Midi.ReleaseBuffer(midi_in_handle, headerPtr);
                    }
                    break;
                }
            }

            return(0);
        }