* Sync up to trunk head (r65120).
[reactos.git] / dll / win32 / mmdrv / midi.c
1 /*
2 *
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS Multimedia
5 * FILE: lib/mmdrv/midi.c
6 * PURPOSE: Multimedia User Mode Driver
7 * PROGRAMMER: Andrew Greenwood
8 * UPDATE HISTORY:
9 * Jan 30, 2004: Imported into ReactOS tree
10 */
11
12 #include "mmdrv.h"
13
14 #define NDEBUG
15 #include <debug.h>
16
17 #include "wave.h"
18
19 // MIDI device instance information
20 //
21 #define LOCAL_DATA_SIZE 20
22 typedef struct _LOCALMIDIHDR {
23 OVERLAPPED Ovl;
24 DWORD BytesReturned;
25 struct _LOCALMIDIHDR *lpNext;
26 BOOL Done;
27 PVOID pClient;
28 // MIDI_DD_INPUT_DATA MidiData;
29 BYTE ExtraData[LOCAL_DATA_SIZE - sizeof(ULONG)];
30
31 } LOCALMIDIHDR, *PLOCALMIDIHDR;
32
33 #define LOCAL_MIDI_BUFFERS 8
34
35 typedef struct {
36
37 BOOL fMidiInStarted;
38 DWORD dwMsg;
39 DWORD dwCurData;
40 BYTE status;
41 BOOLEAN fSysex;
42 BOOLEAN Bad;
43 BYTE bBytesLeft;
44 BYTE bBytePos;
45 DWORD dwCurTime;
46 DWORD dwMsgTime;
47
48
49 PLOCALMIDIHDR DeviceQueue;
50
51 LOCALMIDIHDR
52 Bufs[LOCAL_MIDI_BUFFERS];
53
54
55 } LOCALMIDIDATA, *PLOCALMIDIDATA;
56
57
58 typedef struct tag_MIDIALLOC {
59 struct tag_MIDIALLOC *Next; // Chain of devices
60 UINT DeviceNumber; // Number of device
61 UINT DeviceType; // MidiInput or MidiOutput
62 DWORD dwCallback; // client's callback
63 DWORD dwInstance; // client's instance data
64 HMIDI hMidi; // handle for stream
65 HANDLE DeviceHandle; // Midi device handle
66 LPMIDIHDR lpMIQueue; // Buffers sent to device
67 // This is only required so that
68 // CLOSE knows when things have
69 // really finished.
70 // notify. This is only accessed
71 // on the device thread and its
72 // apcs so does not need any
73 // synchronized access.
74 HANDLE Event; // Event for driver syncrhonization
75 // and notification of auxiliary
76 // task operation completion.
77 // MIDITHREADFUNCTION AuxFunction; // Function for thread to perform
78 union {
79 LPMIDIHDR pHdr; // Buffer to pass in aux task
80 ULONG State; // State to set
81 struct {
82 ULONG Function; // IOCTL to use
83 PBYTE pData; // Data to set or get
84 ULONG DataLen; // Length of data
85 } GetSetData;
86
87 } AuxParam;
88 // 0 means terminate task.
89 HANDLE ThreadHandle; // Handle for termination ONLY
90 HANDLE AuxEvent1; // Aux thread waits on this
91 HANDLE AuxEvent2; // Aux thread caller waits on this
92 DWORD AuxReturnCode; // Return code from Aux task
93 DWORD dwFlags; // Open flags
94 PLOCALMIDIDATA Mid; // Extra midi input structures
95 int l; // Helper global for modMidiLength
96
97 } MIDIALLOC, *PMIDIALLOC;
98
99 PMIDIALLOC MidiHandleList; // Our chain of wave handles
100
101
102
103 static DWORD OpenMidiDevice(UINT DeviceType, DWORD ID, DWORD User, DWORD Param1, DWORD Param2)
104 {
105 PMIDIALLOC pClient = NULL;
106 MMRESULT Result = MMSYSERR_NOERROR;
107
108 // Check ID?
109 DPRINT("OpenMidiDevice()\n");
110
111 switch(DeviceType)
112 {
113 case MidiOutDevice :
114 pClient = (PMIDIALLOC) HeapAlloc(Heap, 0, sizeof(MIDIALLOC));
115 if ( pClient ) memset(pClient, 0, sizeof(MIDIALLOC));
116 break;
117
118 case MidiInDevice :
119 pClient = (PMIDIALLOC) HeapAlloc(Heap, 0, sizeof(MIDIALLOC) + sizeof(LOCALMIDIDATA));
120 if ( pClient ) memset(pClient, 0, sizeof(MIDIALLOC) + sizeof(LOCALMIDIDATA));
121 break;
122 };
123
124 if ( !pClient )
125 return MMSYSERR_NOMEM;
126
127 if (DeviceType == MidiInDevice)
128 {
129 int i;
130 pClient->Mid = (PLOCALMIDIDATA)(pClient + 1);
131 for (i = 0 ;i < LOCAL_MIDI_BUFFERS ; i++)
132 {
133 pClient->Mid->Bufs[i].pClient = pClient;
134 }
135 }
136
137 pClient->DeviceType = DeviceType;
138 pClient->dwCallback = ((LPMIDIOPENDESC)Param1)->dwCallback;
139 pClient->dwInstance = ((LPMIDIOPENDESC)Param1)->dwInstance;
140 pClient->hMidi = ((LPMIDIOPENDESC)Param1)->hMidi;
141 pClient->dwFlags = Param2;
142
143 Result = OpenDevice(DeviceType, ID, &pClient->DeviceHandle, (GENERIC_READ | GENERIC_WRITE));
144
145 if ( Result != MMSYSERR_NOERROR )
146 {
147 // cleanup
148 return Result;
149 }
150
151 pClient->Event = CreateEvent(NULL, FALSE, FALSE, NULL);
152
153 if ( !pClient->Event )
154 {
155 // cleanup
156 return MMSYSERR_NOMEM;
157 }
158
159 if (DeviceType == MidiInDevice)
160 {
161
162 pClient->AuxEvent1 = CreateEvent(NULL, FALSE, FALSE, NULL);
163 if (pClient->AuxEvent1 == NULL)
164 {
165 // cleanup
166 return MMSYSERR_NOMEM;
167 }
168
169 pClient->AuxEvent2 = CreateEvent(NULL, FALSE, FALSE, NULL);
170 if (pClient->AuxEvent2 == NULL)
171 {
172 // cleanup
173 return MMSYSERR_NOMEM;
174 }
175
176
177 // TaskCreate
178
179
180 WaitForSingleObject(pClient->AuxEvent2, INFINITE);
181 }
182
183 PMIDIALLOC *pUserHandle;
184 pUserHandle = (PMIDIALLOC*) User;
185 *pUserHandle = pClient;
186
187 // callback
188
189 return MMSYSERR_NOERROR;
190 }
191
192
193
194 static DWORD WriteMidi(PBYTE pData, ULONG Length, PMIDIALLOC pClient)
195 {
196 DWORD BytesReturned;
197
198 DPRINT("IOCTL_MIDI_PLAY == %d [%x]\n", IOCTL_MIDI_PLAY, IOCTL_MIDI_PLAY);
199
200 if ( !DeviceIoControl(pClient->DeviceHandle, IOCTL_MIDI_PLAY, (PVOID)pData,
201 Length, NULL, 0, &BytesReturned, NULL))
202 return TranslateStatus();
203
204 return MMSYSERR_NOERROR;
205 }
206
207
208 static int GetMidiLength(PMIDIALLOC pClient, BYTE b)
209 {
210 if (b >= 0xF8)
211 {
212 // Realtime message - leave running status
213 return 1; // Write one byte
214 }
215
216 switch (b)
217 {
218 case 0xF0: case 0xF4: case 0xF5: case 0xF6: case 0xF7:
219 pClient->l = 1;
220 return pClient->l;
221
222 case 0xF1: case 0xF3:
223 pClient->l = 2;
224 return pClient->l;
225
226 case 0xF2:
227 pClient->l = 3;
228 return pClient->l;
229 }
230
231 switch (b & 0xF0)
232 {
233 case 0x80: case 0x90: case 0xA0: case 0xB0: case 0xE0:
234 pClient->l = 3;
235 return pClient->l;
236
237 case 0xC0: case 0xD0:
238 pClient->l = 2;
239 return pClient->l;
240 }
241
242 return (pClient->l - 1); // uses previous value if data byte (running status)
243 }
244
245
246
247 /* ----------------------------------------------------------------------------
248 Exported functions
249 ----------------------------------------------------------------------------- */
250
251 APIENTRY DWORD midMessage(DWORD dwId, DWORD dwMessage, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
252 {
253 DPRINT("midMessage\n");
254 return MMSYSERR_NOERROR;
255
256 switch (dwMessage) {
257 case MIDM_GETNUMDEVS:
258 DPRINT("MIDM_GETNUMDEVS");
259 return GetDeviceCount(MidiInDevice);
260
261 case MIDM_GETDEVCAPS:
262 DPRINT("MIDM_GETDEVCAPS");
263 return GetDeviceCapabilities(dwId, MidiInDevice, (LPBYTE)dwParam1, (DWORD)dwParam2);
264
265 case MIDM_OPEN:
266 DPRINT("MIDM_OPEN");
267 return MMSYSERR_NOERROR;
268
269 case MIDM_CLOSE:
270 DPRINT("MIDM_CLOSE");
271 return MMSYSERR_NOERROR;
272
273 case MIDM_ADDBUFFER:
274 DPRINT("MIDM_ADDBUFFER");
275 return MMSYSERR_NOERROR;
276
277 case MIDM_STOP:
278 DPRINT("MIDM_PAUSE");
279 return MMSYSERR_NOERROR;
280
281 case MIDM_START:
282 DPRINT("MIDM_RESTART");
283 return MMSYSERR_NOERROR;
284
285 case MIDM_RESET:
286 DPRINT("MIDM_RESET");
287 return MMSYSERR_NOERROR;
288
289 default:
290 return MMSYSERR_NOTSUPPORTED;
291 }
292
293 // the function should never get to this point
294 //FIXME: Would it be wise to assert here?
295 return MMSYSERR_NOTSUPPORTED;
296 }
297
298 APIENTRY DWORD modMessage(DWORD ID, DWORD Message, DWORD User, DWORD Param1, DWORD Param2)
299 {
300 DPRINT("modMessage\n");
301
302 switch(Message)
303 {
304 case MODM_GETNUMDEVS:
305 DPRINT("MODM_GETNUMDEVS == %d\n", (int)GetDeviceCount(MidiOutDevice));
306 return GetDeviceCount(MidiOutDevice);
307
308 case MODM_GETDEVCAPS:
309 DPRINT("MODM_GETDEVCAPS");
310 return GetDeviceCapabilities(ID, MidiOutDevice, (LPBYTE)Param1, (DWORD)Param2);
311
312 case MODM_OPEN :
313 return OpenMidiDevice(MidiOutDevice, ID, User, Param1, Param2);
314
315 case MODM_CLOSE:
316 DPRINT("MODM_CLOSE");
317 return MMSYSERR_NOTSUPPORTED;
318
319 case MODM_DATA:
320 DPRINT("MODM_DATA");
321
322 int i;
323 BYTE b[4];
324 for (i = 0; i < 4; i ++) {
325 b[i] = (BYTE)(Param1 % 256);
326 Param1 /= 256;
327 }
328 return WriteMidi(b, GetMidiLength((PMIDIALLOC)User, b[0]),
329 (PMIDIALLOC)User);
330
331 case MODM_LONGDATA:
332 DPRINT("MODM_LONGDATA");
333 return MMSYSERR_NOTSUPPORTED;
334
335 case MODM_RESET:
336 DPRINT("MODM_RESET");
337 return MMSYSERR_NOTSUPPORTED;
338
339 case MODM_SETVOLUME:
340 DPRINT("MODM_SETVOLUME");
341 return MMSYSERR_NOTSUPPORTED;
342
343 case MODM_GETVOLUME:
344 DPRINT("MODM_GETVOLUME");
345 return MMSYSERR_NOTSUPPORTED;
346
347 case MODM_CACHEPATCHES:
348 DPRINT("MODM_CACHEPATCHES");
349 return MMSYSERR_NOTSUPPORTED;
350
351 case MODM_CACHEDRUMPATCHES:
352 DPRINT("MODM_CACHEDRUMPATCHES");
353 return MMSYSERR_NOTSUPPORTED;
354
355 };
356
357 return MMSYSERR_NOTSUPPORTED;
358 }