drivers/midi/MidiInputDeviceMme.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 - 2007 Christian Schoenebeck                       *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#include "MidiInputDeviceMme.h"
#include "MidiInputDeviceFactory.h"


namespace LinuxSampler {

void CALLBACK MidiInputDeviceMme::MidiInputPortMme::win32_midiin_callback(HMIDIIN handle, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) {
    MidiInputDeviceMme::MidiInputPortMme* p = (MidiInputDeviceMme::MidiInputPortMme*)dwInstance;
    p->MmeCallbackDispatcher(handle, uMsg, dwParam1, dwParam2);
}


// *************** ParameterPort ***************
// *

    MidiInputDeviceMme::MidiInputPortMme::ParameterPort::ParameterPort(MidiInputPortMme* pPort)
        : DeviceRuntimeParameterString("") {
        this->pPort = pPort;
    }

    String MidiInputDeviceMme::MidiInputPortMme::ParameterPort::Description() {
        return "MME Destination MIDI Port";
    }

    bool MidiInputDeviceMme::MidiInputPortMme::ParameterPort::Fix() {
        return false;
    }

    std::vector<String> MidiInputDeviceMme::MidiInputPortMme::ParameterPort::PossibilitiesAsString() {
        // returns a list of the available MME Input MIDI ports you can connect to
        std::vector<String> ports;
        MIDIINCAPS midiincaps;

        int NumDevs = midiInGetNumDevs();

        for(int i=0;i<NumDevs;i++) {
            int res = midiInGetDevCaps(i, &midiincaps, sizeof(MIDIINCAPS));
            if(res == MMSYSERR_NOERROR) {
                ports.push_back( (String)midiincaps.szPname);
            }
        }

        return ports;
}

    void MidiInputDeviceMme::MidiInputPortMme::ParameterPort::OnSetValue(String s) {
        pPort->ConnectToMmeMidiSource(s.c_str());
    }


// *************** MidiInputPortMme ***************
// *

    MidiInputDeviceMme::MidiInputPortMme::MidiInputPortMme(MidiInputDeviceMme* pDevice) throw (MidiInputException)
        : MidiInputPort(pDevice, ((DeviceCreationParameterInt*)pDevice->Parameters["PORTS"])->ValueAsInt() - 1)
    {
        this->pDevice = pDevice;
        MidiInOpened = false;
        SysExBuf = new char[MME_MAX_SYSEX_BUF_SIZE];
        TmpSysExBuf = new char[MME_MAX_SYSEX_BUF_SIZE];
        ExitFlag = false;
        FirstSysExBlock = true;
        SysExMsgComplete = false;
        dmsg(3,("created MME port %d\n", this->portNumber));
        Parameters["PORT"] = new ParameterPort(this);
    }

    MidiInputDeviceMme::MidiInputPortMme::~MidiInputPortMme() {
        delete TmpSysExBuf;
        delete SysExBuf;
    }


    /***
     * Closes the MME MIDI Input port in a safe way
     */
void MidiInputDeviceMme::MidiInputPortMme::CloseMmeMidiPort(void) {
    int res;
    if (MidiInOpened == true) {
        ExitFlag = true;
        midiInReset(MidiInHandle);
        while ((res = midiInClose(MidiInHandle)) == MIDIERR_STILLPLAYING) Sleep(100);
        midiInUnprepareHeader(MidiInHandle, &midiHdr, sizeof(MIDIHDR));
        MidiInOpened = false;
    }
}

    /**
     * Connects the port with the MME Midi Input port
     *
     * @param Name of the MME Midi Input port  e.g. "MAUDIO MIDI IN"
     * @throws MidiInputException  if connection cannot be established
     */

void MidiInputDeviceMme::MidiInputPortMme::ConnectToMmeMidiSource(const char* MidiSource) {

    // close the old MIDI Input port if it was already opened
    CloseMmeMidiPort();

    MIDIINCAPS midiincaps;
    int NumDevs = midiInGetNumDevs();

    int FoundMidiInDeviceId = -1;
    for(int i=0;i<NumDevs;i++) {
        int res = midiInGetDevCaps(i, &midiincaps, sizeof(MIDIINCAPS));
        if(res == MMSYSERR_NOERROR) {
            if(!strcmp(midiincaps.szPname, MidiSource)) {
                FoundMidiInDeviceId = i;
                break;
            }
        }
    }

    if(FoundMidiInDeviceId == -1) throw MidiInputException("MIDI port connect failed");

    int res;
    res = midiInOpen(&MidiInHandle, FoundMidiInDeviceId, (DWORD)win32_midiin_callback, (DWORD)this, CALLBACK_FUNCTION);
    if(res != MMSYSERR_NOERROR) {
        throw MidiInputException("MIDI port connect failed. midiInOpen error");
    }
    
    MidiInOpened = true;

    /* Store pointer to our input buffer for System Exclusive messages in MIDIHDR */
    midiHdr.lpData = &TmpSysExBuf[0];

    /* Store its size in the MIDIHDR */
    midiHdr.dwBufferLength = MME_MAX_SYSEX_BUF_SIZE;

    /* Flags must be set to 0 */
    midiHdr.dwFlags = 0;

    /* Prepare the buffer and MIDIHDR */
    res = midiInPrepareHeader(MidiInHandle, &midiHdr, sizeof(MIDIHDR));
    if(res != MMSYSERR_NOERROR) {
        CloseMmeMidiPort();
        throw MidiInputException("MIDI port connect failed. midiInPrepareHeader error");
    }
                
    /* Queue MIDI input buffer */
    res = midiInAddBuffer(MidiInHandle, &midiHdr, sizeof(MIDIHDR));
    if(res != MMSYSERR_NOERROR) {
        CloseMmeMidiPort();
        throw MidiInputException("MIDI port connect failed. midiInAddBuffer error");
    }

 
    res = midiInStart(MidiInHandle);
    if(res != MMSYSERR_NOERROR) {
        CloseMmeMidiPort();
        throw MidiInputException("MIDI port connect failed, midiInStart failed.");
    }

}
        
void MidiInputDeviceMme::MidiInputPortMme::MmeCallbackDispatcher(HMIDIIN handle, UINT uMsg, DWORD dwParam1, DWORD dwParam2) {

    unsigned char *DataPtr; // pointer to SysEx data
    unsigned char *data;  // pointer to standard MIDI messages which are not sysex data(max 3 bytes long)

    data = (unsigned char *)&dwParam1;

    switch(uMsg) {
        case MIM_DATA:
            switch(data[0] & 0xF0) { // status byte

                case 0xB0:
                    if (data[1] == 0)
                        DispatchBankSelectMsb(data[2], data[0] & 0x0F);
                    else if (data[1] == 32)
                        DispatchBankSelectLsb(data[2], data[0] & 0x0F);
                    else
                        DispatchControlChange(data[1], data[2], data[0] & 0x0F);
                    break;

                case 0xD0:
                        DispatchControlChange(128, data[1], data[0] & 0x0F);
                    break;

                case 0xE0:
                        DispatchPitchbend(data[1], data[0] & 0x0F);
                    break;

                case 0x90:
                    if (data[1] < 0x80) {
                        if (data[2] > 0){
                            DispatchNoteOn(data[1], data[2], data[0] & 0x0F);
                        }else{
                            DispatchNoteOff(data[1], data[2], data[0] & 0x0F);
                        }
                    }
                    break;

                case 0x80:
                    if (data[1] < 0x80) {
                        DispatchNoteOff(data[1], data[2], data[0] & 0x0F);
                    }
                    break;

                case 0xC0:
                    if (data[1] < 0x80) {
                        DispatchProgramChange(data[1], data[0] & 0x0F);
                    }
                    break;
            }
                
            break;
                        
        case MIM_LONGDATA:
            if(!ExitFlag) {
                LPMIDIHDR lpMIDIHeader = (LPMIDIHDR)dwParam1;
                DataPtr = (unsigned char *)(lpMIDIHeader->lpData);
                if(lpMIDIHeader->dwBytesRecorded == 0) break;

                if(FirstSysExBlock) {
                    SysExOffset = 0;
                    FirstSysExBlock = false;
                }

                if( DataPtr[lpMIDIHeader->dwBytesRecorded - 1] == 0xF7) {
                        SysExMsgComplete = true;
                        FirstSysExBlock = true;
                }
                else {
                        SysExMsgComplete = false;
                }

                if(SysExOffset + lpMIDIHeader->dwBytesRecorded <= MME_MAX_SYSEX_BUF_SIZE) {
                    memcpy(&SysExBuf[SysExOffset], DataPtr, lpMIDIHeader->dwBytesRecorded);
                    SysExOffset += lpMIDIHeader->dwBytesRecorded;
                }

                if(SysExMsgComplete) DispatchSysex(SysExBuf, SysExOffset);

                /* Queue the MIDIHDR for more input, only if ExitFlag was not set otherwise we risk an infinite loop   
                because when we call midiInReset() below, Windows will send a final  MIM_LONGDATA message to that callback.
    */
                midiInAddBuffer(MidiInHandle, lpMIDIHeader, sizeof(MIDIHDR));                   
            }           
            break;
    }

}


// *************** MidiInputDeviceMme ***************
// *

    MidiInputDeviceMme::MidiInputDeviceMme(std::map<String,DeviceCreationParameter*> Parameters, void* pSampler) : MidiInputDevice(Parameters, pSampler) {
        AcquirePorts(((DeviceCreationParameterInt*)Parameters["PORTS"])->ValueAsInt());
        if (((DeviceCreationParameterBool*)Parameters["ACTIVE"])->ValueAsBool()) {
            Listen();
        }
    }

    MidiInputDeviceMme::~MidiInputDeviceMme() {
        // free the midi ports (we can't let the base class do this,
        // as the MidiInputPortMme destructors need access to
        // hAlsaSeq)
        for (std::map<int,MidiInputPort*>::iterator iter = Ports.begin(); iter != Ports.end() ; iter++) {
            delete static_cast<MidiInputPortMme*>(iter->second);
        }
        Ports.clear();
    }

    MidiInputDeviceMme::MidiInputPortMme* MidiInputDeviceMme::CreateMidiPort() {
        dmsg(1,("foo\n"));
        return new MidiInputPortMme(this);
    }

    String MidiInputDeviceMme::Name() {
        return "MME";
    }

    String MidiInputDeviceMme::Driver() {
        return Name();
    }

    void MidiInputDeviceMme::Listen() {
        //TODO: ...
    }

    void MidiInputDeviceMme::StopListen() {
        //TODO: ...
    }

    String MidiInputDeviceMme::Description() {
        return "MultiMedia Extensions";
    }

    String MidiInputDeviceMme::Version() {
        String s = "$Revision: 1.1 $";
        return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
    }

        
} // namespace LinuxSampler
1	/***************************************************************************
2	* *
3	* LinuxSampler - modular, streaming capable sampler *
4	* *
5	* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	* Copyright (C) 2005 - 2007 Christian Schoenebeck *
7	* *
8	* This program is free software; you can redistribute it and/or modify *
9	* it under the terms of the GNU General Public License as published by *
10	* the Free Software Foundation; either version 2 of the License, or *
11	* (at your option) any later version. *
12	* *
13	* This program is distributed in the hope that it will be useful, *
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16	* GNU General Public License for more details. *
17	* *
18	* You should have received a copy of the GNU General Public License *
19	* along with this program; if not, write to the Free Software *
20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21	* MA 02111-1307 USA *
22	***************************************************************************/
23
24	#include "MidiInputDeviceMme.h"
25	#include "MidiInputDeviceFactory.h"
26
27
28
29
30	namespace LinuxSampler {
31
32	void CALLBACK MidiInputDeviceMme::MidiInputPortMme::win32_midiin_callback(HMIDIIN handle, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) {
33	MidiInputDeviceMme::MidiInputPortMme* p = (MidiInputDeviceMme::MidiInputPortMme*)dwInstance;
34	p->MmeCallbackDispatcher(handle, uMsg, dwParam1, dwParam2);
35	}
36
37
38
39
40	// ************* ParameterPort *************
41	// *
42
43	MidiInputDeviceMme::MidiInputPortMme::ParameterPort::ParameterPort(MidiInputPortMme* pPort)
44	: DeviceRuntimeParameterString("") {
45	this->pPort = pPort;
46	}
47
48	String MidiInputDeviceMme::MidiInputPortMme::ParameterPort::Description() {
49	return "MME Destination MIDI Port";
50	}
51
52	bool MidiInputDeviceMme::MidiInputPortMme::ParameterPort::Fix() {
53	return false;
54	}
55
56	std::vector<String> MidiInputDeviceMme::MidiInputPortMme::ParameterPort::PossibilitiesAsString() {
57	// returns a list of the available MME Input MIDI ports you can connect to
58	std::vector<String> ports;
59	MIDIINCAPS midiincaps;
60
61	int NumDevs = midiInGetNumDevs();
62
63	for(int i=0;i<NumDevs;i++) {
64	int res = midiInGetDevCaps(i, &midiincaps, sizeof(MIDIINCAPS));
65	if(res == MMSYSERR_NOERROR) {
66	ports.push_back( (String)midiincaps.szPname);
67	}
68	}
69
70	return ports;
71	}
72
73	void MidiInputDeviceMme::MidiInputPortMme::ParameterPort::OnSetValue(String s) {
74	pPort->ConnectToMmeMidiSource(s.c_str());
75	}
76
77
78
79	// ************* MidiInputPortMme *************
80	// *
81
82	MidiInputDeviceMme::MidiInputPortMme::MidiInputPortMme(MidiInputDeviceMme* pDevice) throw (MidiInputException)
83	: MidiInputPort(pDevice, ((DeviceCreationParameterInt*)pDevice->Parameters["PORTS"])->ValueAsInt() - 1)
84	{
85	this->pDevice = pDevice;
86	MidiInOpened = false;
87	SysExBuf = new char[MME_MAX_SYSEX_BUF_SIZE];
88	TmpSysExBuf = new char[MME_MAX_SYSEX_BUF_SIZE];
89	ExitFlag = false;
90	FirstSysExBlock = true;
91	SysExMsgComplete = false;
92	dmsg(3,("created MME port %d\n", this->portNumber));
93	Parameters["PORT"] = new ParameterPort(this);
94	}
95
96	MidiInputDeviceMme::MidiInputPortMme::~MidiInputPortMme() {
97	delete TmpSysExBuf;
98	delete SysExBuf;
99	}
100
101
102	/***
103	* Closes the MME MIDI Input port in a safe way
104	*/
105	void MidiInputDeviceMme::MidiInputPortMme::CloseMmeMidiPort(void) {
106	int res;
107	if (MidiInOpened == true) {
108	ExitFlag = true;
109	midiInReset(MidiInHandle);
110	while ((res = midiInClose(MidiInHandle)) == MIDIERR_STILLPLAYING) Sleep(100);
111	midiInUnprepareHeader(MidiInHandle, &midiHdr, sizeof(MIDIHDR));
112	MidiInOpened = false;
113	}
114	}
115
116	/**
117	* Connects the port with the MME Midi Input port
118	*
119	* @param Name of the MME Midi Input port e.g. "MAUDIO MIDI IN"
120	* @throws MidiInputException if connection cannot be established
121	*/
122
123	void MidiInputDeviceMme::MidiInputPortMme::ConnectToMmeMidiSource(const char* MidiSource) {
124
125	// close the old MIDI Input port if it was already opened
126	CloseMmeMidiPort();
127
128	MIDIINCAPS midiincaps;
129	int NumDevs = midiInGetNumDevs();
130
131	int FoundMidiInDeviceId = -1;
132	for(int i=0;i<NumDevs;i++) {
133	int res = midiInGetDevCaps(i, &midiincaps, sizeof(MIDIINCAPS));
134	if(res == MMSYSERR_NOERROR) {
135	if(!strcmp(midiincaps.szPname, MidiSource)) {
136	FoundMidiInDeviceId = i;
137	break;
138	}
139	}
140	}
141
142	if(FoundMidiInDeviceId == -1) throw MidiInputException("MIDI port connect failed");
143
144	int res;
145	res = midiInOpen(&MidiInHandle, FoundMidiInDeviceId, (DWORD)win32_midiin_callback, (DWORD)this, CALLBACK_FUNCTION);
146	if(res != MMSYSERR_NOERROR) {
147	throw MidiInputException("MIDI port connect failed. midiInOpen error");
148	}
149
150	MidiInOpened = true;
151
152	/* Store pointer to our input buffer for System Exclusive messages in MIDIHDR */
153	midiHdr.lpData = &TmpSysExBuf[0];
154
155	/* Store its size in the MIDIHDR */
156	midiHdr.dwBufferLength = MME_MAX_SYSEX_BUF_SIZE;
157
158	/* Flags must be set to 0 */
159	midiHdr.dwFlags = 0;
160
161	/* Prepare the buffer and MIDIHDR */
162	res = midiInPrepareHeader(MidiInHandle, &midiHdr, sizeof(MIDIHDR));
163	if(res != MMSYSERR_NOERROR) {
164	CloseMmeMidiPort();
165	throw MidiInputException("MIDI port connect failed. midiInPrepareHeader error");
166	}
167
168	/* Queue MIDI input buffer */
169	res = midiInAddBuffer(MidiInHandle, &midiHdr, sizeof(MIDIHDR));
170	if(res != MMSYSERR_NOERROR) {
171	CloseMmeMidiPort();
172	throw MidiInputException("MIDI port connect failed. midiInAddBuffer error");
173	}
174
175
176	res = midiInStart(MidiInHandle);
177	if(res != MMSYSERR_NOERROR) {
178	CloseMmeMidiPort();
179	throw MidiInputException("MIDI port connect failed, midiInStart failed.");
180	}
181
182	}
183
184	void MidiInputDeviceMme::MidiInputPortMme::MmeCallbackDispatcher(HMIDIIN handle, UINT uMsg, DWORD dwParam1, DWORD dwParam2) {
185
186	unsigned char *DataPtr; // pointer to SysEx data
187	unsigned char *data; // pointer to standard MIDI messages which are not sysex data(max 3 bytes long)
188
189	data = (unsigned char *)&dwParam1;
190
191	switch(uMsg) {
192	case MIM_DATA:
193	switch(data[0] & 0xF0) { // status byte
194
195	case 0xB0:
196	if (data[1] == 0)
197	DispatchBankSelectMsb(data[2], data[0] & 0x0F);
198	else if (data[1] == 32)
199	DispatchBankSelectLsb(data[2], data[0] & 0x0F);
200	else
201	DispatchControlChange(data[1], data[2], data[0] & 0x0F);
202	break;
203
204	case 0xD0:
205	DispatchControlChange(128, data[1], data[0] & 0x0F);
206	break;
207
208	case 0xE0:
209	DispatchPitchbend(data[1], data[0] & 0x0F);
210	break;
211
212	case 0x90:
213	if (data[1] < 0x80) {
214	if (data[2] > 0){
215	DispatchNoteOn(data[1], data[2], data[0] & 0x0F);
216	}else{
217	DispatchNoteOff(data[1], data[2], data[0] & 0x0F);
218	}
219	}
220	break;
221
222	case 0x80:
223	if (data[1] < 0x80) {
224	DispatchNoteOff(data[1], data[2], data[0] & 0x0F);
225	}
226	break;
227
228	case 0xC0:
229	if (data[1] < 0x80) {
230	DispatchProgramChange(data[1], data[0] & 0x0F);
231	}
232	break;
233	}
234
235	break;
236
237	case MIM_LONGDATA:
238	if(!ExitFlag) {
239	LPMIDIHDR lpMIDIHeader = (LPMIDIHDR)dwParam1;
240	DataPtr = (unsigned char *)(lpMIDIHeader->lpData);
241	if(lpMIDIHeader->dwBytesRecorded == 0) break;
242
243	if(FirstSysExBlock) {
244	SysExOffset = 0;
245	FirstSysExBlock = false;
246	}
247
248	if( DataPtr[lpMIDIHeader->dwBytesRecorded - 1] == 0xF7) {
249	SysExMsgComplete = true;
250	FirstSysExBlock = true;
251	}
252	else {
253	SysExMsgComplete = false;
254	}
255
256	if(SysExOffset + lpMIDIHeader->dwBytesRecorded <= MME_MAX_SYSEX_BUF_SIZE) {
257	memcpy(&SysExBuf[SysExOffset], DataPtr, lpMIDIHeader->dwBytesRecorded);
258	SysExOffset += lpMIDIHeader->dwBytesRecorded;
259	}
260
261	if(SysExMsgComplete) DispatchSysex(SysExBuf, SysExOffset);
262
263	/* Queue the MIDIHDR for more input, only if ExitFlag was not set otherwise we risk an infinite loop
264	because when we call midiInReset() below, Windows will send a final MIM_LONGDATA message to that callback.
265	*/
266	midiInAddBuffer(MidiInHandle, lpMIDIHeader, sizeof(MIDIHDR));
267	}
268	break;
269	}
270
271	}
272
273
274
275
276	// ************* MidiInputDeviceMme *************
277	// *
278
279	MidiInputDeviceMme::MidiInputDeviceMme(std::map<String,DeviceCreationParameter> Parameters, void pSampler) : MidiInputDevice(Parameters, pSampler) {
280	AcquirePorts(((DeviceCreationParameterInt*)Parameters["PORTS"])->ValueAsInt());
281	if (((DeviceCreationParameterBool*)Parameters["ACTIVE"])->ValueAsBool()) {
282	Listen();
283	}
284	}
285
286	MidiInputDeviceMme::~MidiInputDeviceMme() {
287	// free the midi ports (we can't let the base class do this,
288	// as the MidiInputPortMme destructors need access to
289	// hAlsaSeq)
290	for (std::map<int,MidiInputPort*>::iterator iter = Ports.begin(); iter != Ports.end() ; iter++) {
291	delete static_cast<MidiInputPortMme*>(iter->second);
292	}
293	Ports.clear();
294	}
295
296	MidiInputDeviceMme::MidiInputPortMme* MidiInputDeviceMme::CreateMidiPort() {
297	dmsg(1,("foo\n"));
298	return new MidiInputPortMme(this);
299	}
300
301	String MidiInputDeviceMme::Name() {
302	return "MME";
303	}
304
305	String MidiInputDeviceMme::Driver() {
306	return Name();
307	}
308
309	void MidiInputDeviceMme::Listen() {
310	//TODO: ...
311	}
312
313	void MidiInputDeviceMme::StopListen() {
314	//TODO: ...
315	}
316
317	String MidiInputDeviceMme::Description() {
318	return "MultiMedia Extensions";
319	}
320
321	String MidiInputDeviceMme::Version() {
322	String s = "$Revision: 1.1 $";
323	return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
324	}
325
326
327
328	} // namespace LinuxSampler