?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don't return from overlapped ReadFile on EAGAIN and other non-fatal
[wine/gsoc_dplay.git] / dlls / winmm / mciseq / mcimidi.c
blob247c93ced41c96b83057e8529b6c8287171e4c2d
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4 * Sample MIDI Wine Driver for Linux
5 *
6 * Copyright 1994 Martin Ayotte
7 * 1999 Eric Pouech
8 */
9
10 /*
11 * Eric POUECH :
12 * 98/7 changes for making this MIDI driver work on OSS
13 * current support is limited to MIDI ports of OSS systems
14 * 98/9 rewriting MCI code for MIDI
15 * 98/11 splitted in midi.c and mcimidi.c
16 */
17
18 #include <stdlib.h>
19 #include <stdio.h>
20 #include <string.h>
21
22 #include "windef.h"
23 #include "winbase.h"
24 #include "wingdi.h"
25 #include "winuser.h"
26 #include "mmddk.h"
27 #include "debugtools.h"
28
29 DEFAULT_DEBUG_CHANNEL(mcimidi);
30
31 #define MIDI_NOTEOFF 0x80
32 #define MIDI_NOTEON 0x90
33
34 typedef struct {
35 DWORD dwFirst; /* offset in file of track */
36 DWORD dwLast; /* number of bytes in file of track */
37 DWORD dwIndex; /* current index in file (dwFirst <= dwIndex < dwLast) */
38 DWORD dwLength; /* number of pulses in this track */
39 DWORD dwEventPulse; /* current pulse # (event) pointed by dwIndex */
40 DWORD dwEventData; /* current data (event) pointed by dwIndex */
41 WORD wEventLength; /* current length (event) pointed by dwIndex */
42 WORD wStatus : 1, /* 1 : playing, 0 : done */
43 wTrackNr : 7,
44 wLastCommand : 8; /* last MIDI command on track */
45 } MCI_MIDITRACK;
46
47 typedef struct tagWINE_MCIMIDI {
48 UINT wDevID; /* the MCI one */
49 HMIDI hMidi;
50 int nUseCount; /* Incremented for each shared open */
51 WORD wNotifyDeviceID; /* MCI device ID with a pending notification */
52 HANDLE hCallback; /* Callback handle for pending notification */
53 HMMIO hFile; /* mmio file handle open as Element */
54 LPSTR lpstrElementName; /* Name of file */
55 LPSTR lpstrCopyright;
56 LPSTR lpstrName;
57 WORD dwStatus; /* one from MCI_MODE_xxxx */
58 DWORD dwMciTimeFormat; /* One of the supported MCI_FORMAT_xxxx */
59 WORD wFormat; /* Format of MIDI hFile (0, 1 or 2) */
60 WORD nTracks; /* Number of tracks in hFile */
61 WORD nDivision; /* Number of division in hFile PPQN or SMPTE */
62 WORD wStartedPlaying;
63 DWORD dwTempo; /* Tempo (# of 1/4 note per second */
64 MCI_MIDITRACK* tracks; /* Content of each track */
65 DWORD dwPulse;
66 DWORD dwPositionMS;
67 DWORD dwStartTicks;
68 } WINE_MCIMIDI;
69
70 /* ===================================================================
71 * ===================================================================
72 * FIXME: should be using the new mmThreadXXXX functions from WINMM
73 * instead of those
74 * it would require to add a wine internal flag to mmThreadCreate
75 * in order to pass a 32 bit function instead of a 16 bit
76 * ===================================================================
77 * =================================================================== */
78
79 struct SCA {
80 UINT wDevID;
81 UINT wMsg;
82 DWORD dwParam1;
83 DWORD dwParam2;
84 };
85
86 /* EPP DWORD WINAPI mciSendCommandA(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2); */
87
88 /**************************************************************************
89 * MCI_SCAStarter [internal]
90 */
91 static DWORD CALLBACK MCI_SCAStarter(LPVOID arg)
92 {
93 struct SCA* sca = (struct SCA*)arg;
94 DWORD ret;
95
96 TRACE("In thread before async command (%08x,%u,%08lx,%08lx)\n",
97 sca->wDevID, sca->wMsg, sca->dwParam1, sca->dwParam2);
98 ret = mciSendCommandA(sca->wDevID, sca->wMsg, sca->dwParam1 | MCI_WAIT, sca->dwParam2);
99 TRACE("In thread after async command (%08x,%u,%08lx,%08lx)\n",
100 sca->wDevID, sca->wMsg, sca->dwParam1, sca->dwParam2);
101 HeapFree(GetProcessHeap(), 0, sca);
102 ExitThread(ret);
103 WARN("Should not happen ? what's wrong \n");
104 /* should not go after this point */
105 return ret;
106 }
107
108 /**************************************************************************
109 * MCI_SendCommandAsync [internal]
110 */
111 static DWORD MCI_SendCommandAsync(UINT wDevID, UINT wMsg, DWORD dwParam1,
112 DWORD dwParam2, UINT size)
113 {
114 struct SCA* sca = HeapAlloc(GetProcessHeap(), 0, sizeof(struct SCA) + size);
115
116 if (sca == 0)
117 return MCIERR_OUT_OF_MEMORY;
118
119 sca->wDevID = wDevID;
120 sca->wMsg = wMsg;
121 sca->dwParam1 = dwParam1;
122
123 if (size && dwParam2) {
124 sca->dwParam2 = (DWORD)sca + sizeof(struct SCA);
125 /* copy structure passed by program in dwParam2 to be sure
126 * we can still use it whatever the program does
127 */
128 memcpy((LPVOID)sca->dwParam2, (LPVOID)dwParam2, size);
129 } else {
130 sca->dwParam2 = dwParam2;
131 }
132
133 if (CreateThread(NULL, 0, MCI_SCAStarter, sca, 0, NULL) == 0) {
134 WARN("Couldn't allocate thread for async command handling, sending synchonously\n");
135 return MCI_SCAStarter(&sca);
136 }
137 return 0;
138 }
139
140 /*======================================================================*
141 * MCI MIDI implemantation *
142 *======================================================================*/
143
144 static DWORD MIDI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
145
146 /**************************************************************************
147 * MIDI_drvOpen [internal]
148 */
149 static DWORD MIDI_drvOpen(LPSTR str, LPMCI_OPEN_DRIVER_PARMSA modp)
150 {
151 WINE_MCIMIDI* wmm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCIMIDI));
152
153 if (!wmm)
154 return 0;
155
156 wmm->wDevID = modp->wDeviceID;
157 mciSetDriverData(wmm->wDevID, (DWORD)wmm);
158 modp->wCustomCommandTable = MCI_NO_COMMAND_TABLE;
159 modp->wType = MCI_DEVTYPE_SEQUENCER;
160 return modp->wDeviceID;
161 }
162
163 /**************************************************************************
164 * MCIMIDI_drvClose [internal]
165 */
166 static DWORD MIDI_drvClose(DWORD dwDevID)
167 {
168 WINE_MCIMIDI* wmm = (WINE_MCIMIDI*)mciGetDriverData(dwDevID);
169
170 if (wmm) {
171 HeapFree(GetProcessHeap(), 0, wmm);
172 mciSetDriverData(dwDevID, 0);
173 return 1;
174 }
175 return 0;
176 }
177
178 /**************************************************************************
179 * MIDI_mciGetOpenDev [internal]
180 */
181 static WINE_MCIMIDI* MIDI_mciGetOpenDev(UINT wDevID)
182 {
183 WINE_MCIMIDI* wmm = (WINE_MCIMIDI*)mciGetDriverData(wDevID);
184
185 if (wmm == NULL || wmm->nUseCount == 0) {
186 WARN("Invalid wDevID=%u\n", wDevID);
187 return 0;
188 }
189 return wmm;
190 }
191
192 /**************************************************************************
193 * MIDI_mciReadByte [internal]
194 */
195 static DWORD MIDI_mciReadByte(WINE_MCIMIDI* wmm, BYTE *lpbyt)
196 {
197 DWORD ret = 0;
198
199 if (lpbyt == NULL ||
200 mmioRead(wmm->hFile, (HPSTR)lpbyt, sizeof(BYTE)) != (long)sizeof(BYTE)) {
201 WARN("Error reading wmm=%p\n", wmm);
202 ret = MCIERR_INVALID_FILE;
203 }
204
205 return ret;
206 }
207
208 /**************************************************************************
209 * MIDI_mciReadWord [internal]
210 */
211 static DWORD MIDI_mciReadWord(WINE_MCIMIDI* wmm, LPWORD lpw)
212 {
213 BYTE hibyte, lobyte;
214 DWORD ret = MCIERR_INVALID_FILE;
215
216 if (lpw != NULL &&
217 MIDI_mciReadByte(wmm, &hibyte) == 0 &&
218 MIDI_mciReadByte(wmm, &lobyte) == 0) {
219 *lpw = ((WORD)hibyte << 8) + lobyte;
220 ret = 0;
221 }
222 return ret;
223 }
224
225 /**************************************************************************
226 * MIDI_mciReadLong [internal]
227 */
228 static DWORD MIDI_mciReadLong(WINE_MCIMIDI* wmm, LPDWORD lpdw)
229 {
230 WORD hiword, loword;
231 DWORD ret = MCIERR_INVALID_FILE;
232
233 if (lpdw != NULL &&
234 MIDI_mciReadWord(wmm, &hiword) == 0 &&
235 MIDI_mciReadWord(wmm, &loword) == 0) {
236 *lpdw = MAKELONG(loword, hiword);
237 ret = 0;
238 }
239 return ret;
240 }
241
242 /**************************************************************************
243 * MIDI_mciReadVaryLen [internal]
244 */
245 static WORD MIDI_mciReadVaryLen(WINE_MCIMIDI* wmm, LPDWORD lpdw)
246 {
247 BYTE byte;
248 DWORD value = 0;
249 WORD ret = 0;
250
251 if (lpdw == NULL) {
252 ret = MCIERR_INVALID_FILE;
253 } else {
254 do {
255 if (MIDI_mciReadByte(wmm, &byte) != 0) {
256 return 0;
257 }
258 value = (value << 7) + (byte & 0x7F);
259 ret++;
260 } while (byte & 0x80);
261 *lpdw = value;
262 /*
263 TRACE("val=%08lX \n", value);
264 */
265 }
266 return ret;
267 }
268
269 /**************************************************************************
270 * MIDI_mciReadNextEvent [internal]
271 */
272 static DWORD MIDI_mciReadNextEvent(WINE_MCIMIDI* wmm, MCI_MIDITRACK* mmt)
273 {
274 BYTE b1, b2 = 0, b3;
275 WORD hw = 0;
276 DWORD evtPulse;
277 DWORD evtLength;
278 DWORD tmp;
279
280 if (mmioSeek(wmm->hFile, mmt->dwIndex, SEEK_SET) != mmt->dwIndex) {
281 WARN("Can't seek at %08lX \n", mmt->dwIndex);
282 return MCIERR_INVALID_FILE;
283 }
284 evtLength = MIDI_mciReadVaryLen(wmm, &evtPulse) + 1; /* > 0 */
285 MIDI_mciReadByte(wmm, &b1);
286 switch (b1) {
287 case 0xF0:
288 case 0xF7:
289 evtLength += MIDI_mciReadVaryLen(wmm, &tmp);
290 evtLength += tmp;
291 break;
292 case 0xFF:
293 MIDI_mciReadByte(wmm, &b2); evtLength++;
294
295 evtLength += MIDI_mciReadVaryLen(wmm, &tmp);
296 if (evtLength >= 0x10000u) {
297 /* this limitation shouldn't be a problem */
298 WARN("Ouch !! Implementation limitation to 64k bytes for a MIDI event is overflowed\n");
299 hw = 0xFFFF;
300 } else {
301 hw = LOWORD(evtLength);
302 }
303 evtLength += tmp;
304 break;
305 default:
306 if (b1 & 0x80) { /* use running status ? */
307 mmt->wLastCommand = b1;
308 MIDI_mciReadByte(wmm, &b2); evtLength++;
309 } else {
310 b2 = b1;
311 b1 = mmt->wLastCommand;
312 }
313 switch ((b1 >> 4) & 0x07) {
314 case 0: case 1: case 2: case 3: case 6:
315 MIDI_mciReadByte(wmm, &b3); evtLength++;
316 hw = b3;
317 break;
318 case 4: case 5:
319 break;
320 case 7:
321 WARN("Strange indeed b1=0x%02x\n", b1);
322 }
323 break;
324 }
325 if (mmt->dwIndex + evtLength > mmt->dwLast)
326 return MCIERR_INTERNAL;
327
328 mmt->dwEventPulse += evtPulse;
329 mmt->dwEventData = (hw << 16) + (b2 << 8) + b1;
330 mmt->wEventLength = evtLength;
331
332 /*
333 TRACE("[%u] => pulse=%08lx(%08lx), data=%08lx, length=%u\n",
334 mmt->wTrackNr, mmt->dwEventPulse, evtPulse,
335 mmt->dwEventData, mmt->wEventLength);
336 */
337 return 0;
338 }
339
340 /**************************************************************************
341 * MIDI_mciReadMTrk [internal]
342 */
343 static DWORD MIDI_mciReadMTrk(WINE_MCIMIDI* wmm, MCI_MIDITRACK* mmt)
344 {
345 DWORD toberead;
346 FOURCC fourcc;
347
348 if (mmioRead(wmm->hFile, (HPSTR)&fourcc, (long)sizeof(FOURCC)) !=
349 (long)sizeof(FOURCC)) {
350 return MCIERR_INVALID_FILE;
351 }
352
353 if (fourcc != mmioFOURCC('M', 'T', 'r', 'k')) {
354 WARN("Can't synchronize on 'MTrk' !\n");
355 return MCIERR_INVALID_FILE;
356 }
357
358 if (MIDI_mciReadLong(wmm, &toberead) != 0) {
359 return MCIERR_INVALID_FILE;
360 }
361 mmt->dwFirst = mmioSeek(wmm->hFile, 0, SEEK_CUR); /* >= 0 */
362 mmt->dwLast = mmt->dwFirst + toberead;
363
364 /* compute # of pulses in this track */
365 mmt->dwIndex = mmt->dwFirst;
366 mmt->dwEventPulse = 0;
367
368 while (MIDI_mciReadNextEvent(wmm, mmt) == 0 && LOWORD(mmt->dwEventData) != 0x2FFF) {
369 char buf[1024];
370 WORD len;
371
372 mmt->dwIndex += mmt->wEventLength;
373
374 switch (LOWORD(mmt->dwEventData)) {
375 case 0x02FF:
376 case 0x03FF:
377 /* position after meta data header */
378 mmioSeek(wmm->hFile, mmt->dwIndex + HIWORD(mmt->dwEventData), SEEK_SET);
379 len = mmt->wEventLength - HIWORD(mmt->dwEventData);
380
381 if (len >= sizeof(buf)) {
382 WARN("Buffer for text is too small (%d bytes, when %u are needed)\n", sizeof(buf) - 1, len);
383 len = sizeof(buf) - 1;
384 }
385 if (mmioRead(wmm->hFile, (HPSTR)buf, len) == len) {
386 buf[len] = 0; /* end string in case */
387 switch (HIBYTE(LOWORD(mmt->dwEventData))) {
388 case 0x02:
389 if (wmm->lpstrCopyright) {
390 WARN("Two copyright notices (%s|%s)\n", wmm->lpstrCopyright, buf);
391 } else {
392 wmm->lpstrCopyright = HeapAlloc( GetProcessHeap(), 0, strlen(buf)+1 );
393 strcpy( wmm->lpstrCopyright, buf );
394 }
395 break;
396 case 0x03:
397 if (wmm->lpstrName) {
398 WARN("Two names (%s|%s)\n", wmm->lpstrName, buf);
399 } else {
400 wmm->lpstrName = HeapAlloc( GetProcessHeap(), 0, strlen(buf)+1 );
401 strcpy( wmm->lpstrName, buf );
402 }
403 break;
404 }
405 }
406 break;
407 }
408 }
409 mmt->dwLength = mmt->dwEventPulse;
410
411 TRACE("Track %u has %lu bytes and %lu pulses\n", mmt->wTrackNr, toberead, mmt->dwLength);
412
413 /* reset track data */
414 mmt->wStatus = 1; /* ok, playing */
415 mmt->dwIndex = mmt->dwFirst;
416 mmt->dwEventPulse = 0;
417
418 if (mmioSeek(wmm->hFile, 0, SEEK_CUR) != mmt->dwLast) {
419 WARN("Ouch, out of sync seek=%lu track=%lu\n",
420 mmioSeek(wmm->hFile, 0, SEEK_CUR), mmt->dwLast);
421 /* position at end of this track, to be ready to read next track */
422 mmioSeek(wmm->hFile, mmt->dwLast, SEEK_SET);
423 }
424
425 return 0;
426 }
427
428 /**************************************************************************
429 * MIDI_mciReadMThd [internal]
430 */
431 static DWORD MIDI_mciReadMThd(WINE_MCIMIDI* wmm, DWORD dwOffset)
432 {
433 DWORD toberead;
434 FOURCC fourcc;
435 WORD nt;
436
437 TRACE("(%p, %08lX);\n", wmm, dwOffset);
438
439 if (mmioSeek(wmm->hFile, dwOffset, SEEK_SET) != dwOffset) {
440 WARN("Can't seek at %08lX begin of 'MThd' \n", dwOffset);
441 return MCIERR_INVALID_FILE;
442 }
443 if (mmioRead(wmm->hFile, (HPSTR)&fourcc,
444 (long) sizeof(FOURCC)) != (long) sizeof(FOURCC))
445 return MCIERR_INVALID_FILE;
446
447 if (fourcc != mmioFOURCC('M', 'T', 'h', 'd')) {
448 WARN("Can't synchronize on 'MThd' !\n");
449 return MCIERR_INVALID_FILE;
450 }
451
452 if (MIDI_mciReadLong(wmm, &toberead) != 0 || toberead < 3 * sizeof(WORD))
453 return MCIERR_INVALID_FILE;
454
455 if (MIDI_mciReadWord(wmm, &wmm->wFormat) != 0 ||
456 MIDI_mciReadWord(wmm, &wmm->nTracks) != 0 ||
457 MIDI_mciReadWord(wmm, &wmm->nDivision) != 0) {
458 return MCIERR_INVALID_FILE;
459 }
460
461 TRACE("toberead=0x%08lX, wFormat=0x%04X nTracks=0x%04X nDivision=0x%04X\n",
462 toberead, wmm->wFormat, wmm->nTracks, wmm->nDivision);
463
464 /* MS doc says that the MIDI MCI time format must be put by default to the format
465 * stored in the MIDI file...
466 */
467 if (wmm->nDivision > 0x8000) {
468 /* eric.pouech@lemel.fr 98/11
469 * In did not check this very code (pulses are expressed as SMPTE sub-frames).
470 * In about 40 MB of MIDI files I have, none was SMPTE based...
471 * I'm just wondering if this is widely used :-). So, if someone has one of
472 * these files, I'd like to know about.
473 */
474 FIXME("Handling SMPTE time in MIDI files has not been tested\n"
475 "Please report to comp.emulators.ms-windows.wine with MIDI file !\n");
476
477 switch (HIBYTE(wmm->nDivision)) {
478 case 0xE8: wmm->dwMciTimeFormat = MCI_FORMAT_SMPTE_24; break; /* -24 */
479 case 0xE7: wmm->dwMciTimeFormat = MCI_FORMAT_SMPTE_25; break; /* -25 */
480 case 0xE3: wmm->dwMciTimeFormat = MCI_FORMAT_SMPTE_30DROP; break; /* -29 */ /* is the MCI constant correct ? */
481 case 0xE2: wmm->dwMciTimeFormat = MCI_FORMAT_SMPTE_30; break; /* -30 */
482 default:
483 WARN("Unsupported number of frames %d\n", -(char)HIBYTE(wmm->nDivision));
484 return MCIERR_INVALID_FILE;
485 }
486 switch (LOBYTE(wmm->nDivision)) {
487 case 4: /* MIDI Time Code */
488 case 8:
489 case 10:
490 case 80: /* SMPTE bit resolution */
491 case 100:
492 default:
493 WARN("Unsupported number of sub-frames %d\n", LOBYTE(wmm->nDivision));
494 return MCIERR_INVALID_FILE;
495 }
496 } else if (wmm->nDivision == 0) {
497 WARN("Number of division is 0, can't support that !!\n");
498 return MCIERR_INVALID_FILE;
499 } else {
500 wmm->dwMciTimeFormat = MCI_FORMAT_MILLISECONDS;
501 }
502
503 switch (wmm->wFormat) {
504 case 0:
505 if (wmm->nTracks != 1) {
506 WARN("Got type 0 file whose number of track is not 1. Setting it to 1\n");
507 wmm->nTracks = 1;
508 }
509 break;
510 case 1:
511 case 2:
512 break;
513 default:
514 WARN("Handling MIDI files which format = %d is not (yet) supported\n"
515 "Please report with MIDI file !\n", wmm->wFormat);
516 return MCIERR_INVALID_FILE;
517 }
518
519 if (wmm->nTracks & 0x8000) {
520 /* this shouldn't be a problem... */
521 WARN("Ouch !! Implementation limitation to 32k tracks per MIDI file is overflowed\n");
522 wmm->nTracks = 0x7FFF;
523 }
524
525 if ((wmm->tracks = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_MIDITRACK) * wmm->nTracks)) == NULL) {
526 return MCIERR_OUT_OF_MEMORY;
527 }
528
529 toberead -= 3 * sizeof(WORD);
530 if (toberead > 0) {
531 TRACE("Size of MThd > 6, skipping %ld extra bytes\n", toberead);
532 mmioSeek(wmm->hFile, toberead, SEEK_CUR);
533 }
534
535 for (nt = 0; nt < wmm->nTracks; nt++) {
536 wmm->tracks[nt].wTrackNr = nt;
537 if (MIDI_mciReadMTrk(wmm, &wmm->tracks[nt]) != 0) {
538 WARN("Can't read 'MTrk' header \n");
539 return MCIERR_INVALID_FILE;
540 }
541 }
542
543 wmm->dwTempo = 500000;
544
545 return 0;
546 }
547
548 /**************************************************************************
549 * MIDI_ConvertPulseToMS [internal]
550 */
551 static DWORD MIDI_ConvertPulseToMS(WINE_MCIMIDI* wmm, DWORD pulse)
552 {
553 DWORD ret = 0;
554
555 /* FIXME: this function may return false values since the tempo (wmm->dwTempo)
556 * may change during file playing
557 */
558 if (wmm->nDivision == 0) {
559 FIXME("Shouldn't happen. wmm->nDivision = 0\n");
560 } else if (wmm->nDivision > 0x8000) { /* SMPTE, unchecked FIXME? */
561 int nf = -(char)HIBYTE(wmm->nDivision); /* number of frames */
562 int nsf = LOBYTE(wmm->nDivision); /* number of sub-frames */
563 ret = (pulse * 1000) / (nf * nsf);
564 } else {
565 ret = (DWORD)((double)pulse * ((double)wmm->dwTempo / 1000) /
566 (double)wmm->nDivision);
567 }
568
569 /*
570 TRACE("pulse=%lu tempo=%lu division=%u=0x%04x => ms=%lu\n",
571 pulse, wmm->dwTempo, wmm->nDivision, wmm->nDivision, ret);
572 */
573
574 return ret;
575 }
576
577 #define TIME_MS_IN_ONE_HOUR (60*60*1000)
578 #define TIME_MS_IN_ONE_MINUTE (60*1000)
579 #define TIME_MS_IN_ONE_SECOND (1000)
580
581 /**************************************************************************
582 * MIDI_ConvertTimeFormatToMS [internal]
583 */
584 static DWORD MIDI_ConvertTimeFormatToMS(WINE_MCIMIDI* wmm, DWORD val)
585 {
586 DWORD ret = 0;
587
588 switch (wmm->dwMciTimeFormat) {
589 case MCI_FORMAT_MILLISECONDS:
590 ret = val;
591 break;
592 case MCI_FORMAT_SMPTE_24:
593 ret =
594 (HIBYTE(HIWORD(val)) * 125) / 3 + LOBYTE(HIWORD(val)) * TIME_MS_IN_ONE_SECOND +
595 HIBYTE(LOWORD(val)) * TIME_MS_IN_ONE_MINUTE + LOBYTE(LOWORD(val)) * TIME_MS_IN_ONE_HOUR;
596 break;
597 case MCI_FORMAT_SMPTE_25:
598 ret =
599 HIBYTE(HIWORD(val)) * 40 + LOBYTE(HIWORD(val)) * TIME_MS_IN_ONE_SECOND +
600 HIBYTE(LOWORD(val)) * TIME_MS_IN_ONE_MINUTE + LOBYTE(LOWORD(val)) * TIME_MS_IN_ONE_HOUR;
601 break;
602 case MCI_FORMAT_SMPTE_30:
603 ret =
604 (HIBYTE(HIWORD(val)) * 100) / 3 + LOBYTE(HIWORD(val)) * TIME_MS_IN_ONE_SECOND +
605 HIBYTE(LOWORD(val)) * TIME_MS_IN_ONE_MINUTE + LOBYTE(LOWORD(val)) * TIME_MS_IN_ONE_HOUR;
606 break;
607 default:
608 WARN("Bad time format %lu!\n", wmm->dwMciTimeFormat);
609 }
610 /*
611 TRACE("val=%lu=0x%08lx [tf=%lu] => ret=%lu\n", val, val, wmm->dwMciTimeFormat, ret);
612 */
613 return ret;
614 }
615
616 /**************************************************************************
617 * MIDI_ConvertMSToTimeFormat [internal]
618 */
619 static DWORD MIDI_ConvertMSToTimeFormat(WINE_MCIMIDI* wmm, DWORD _val)
620 {
621 DWORD ret = 0, val = _val;
622 DWORD h, m, s, f;
623
624 switch (wmm->dwMciTimeFormat) {
625 case MCI_FORMAT_MILLISECONDS:
626 ret = val;
627 break;
628 case MCI_FORMAT_SMPTE_24:
629 case MCI_FORMAT_SMPTE_25:
630 case MCI_FORMAT_SMPTE_30:
631 h = val / TIME_MS_IN_ONE_HOUR;
632 m = (val -= h * TIME_MS_IN_ONE_HOUR) / TIME_MS_IN_ONE_MINUTE;
633 s = (val -= m * TIME_MS_IN_ONE_MINUTE) / TIME_MS_IN_ONE_SECOND;
634 switch (wmm->dwMciTimeFormat) {
635 case MCI_FORMAT_SMPTE_24:
636 /* one frame is 1000/24 val long, 1000/24 == 125/3 */
637 f = (val * 3) / 125; val -= (f * 125) / 3;
638 break;
639 case MCI_FORMAT_SMPTE_25:
640 /* one frame is 1000/25 ms long, 1000/25 == 40 */
641 f = val / 40; val -= f * 40;
642 break;
643 case MCI_FORMAT_SMPTE_30:
644 /* one frame is 1000/30 ms long, 1000/30 == 100/3 */
645 f = (val * 3) / 100; val -= (f * 100) / 3;
646 break;
647 default:
648 FIXME("There must be some bad bad programmer\n");
649 f = 0;
650 }
651 /* val contains the number of ms which cannot make a complete frame */
652 /* FIXME: is this correct ? programs seem to be happy with that */
653 ret = (f << 24) | (s << 16) | (m << 8) | (h << 0);
654 break;
655 default:
656 WARN("Bad time format %lu!\n", wmm->dwMciTimeFormat);
657 }
658 /*
659 TRACE("val=%lu [tf=%lu] => ret=%lu=0x%08lx\n", _val, wmm->dwMciTimeFormat, ret, ret);
660 */
661 return ret;
662 }
663
664 /**************************************************************************
665 * MIDI_GetMThdLengthMS [internal]
666 */
667 static DWORD MIDI_GetMThdLengthMS(WINE_MCIMIDI* wmm)
668 {
669 WORD nt;
670 DWORD ret = 0;
671
672 for (nt = 0; nt < wmm->nTracks; nt++) {
673 if (wmm->wFormat == 2) {
674 ret += wmm->tracks[nt].dwLength;
675 } else if (wmm->tracks[nt].dwLength > ret) {
676 ret = wmm->tracks[nt].dwLength;
677 }
678 }
679 /* FIXME: this is wrong if there is a tempo change inside the file */
680 return MIDI_ConvertPulseToMS(wmm, ret);
681 }
682
683 /**************************************************************************
684 * MIDI_mciOpen [internal]
685 */
686 static DWORD MIDI_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_OPEN_PARMSA lpParms)
687 {
688 DWORD dwRet = 0;
689 DWORD dwDeviceID;
690 WINE_MCIMIDI* wmm = (WINE_MCIMIDI*)mciGetDriverData(wDevID);
691
692 TRACE("(%04x, %08lX, %p)\n", wDevID, dwFlags, lpParms);
693
694 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
695 if (wmm == NULL) return MCIERR_INVALID_DEVICE_ID;
696 if (dwFlags & MCI_OPEN_SHAREABLE)
697 return MCIERR_HARDWARE;
698
699 if (wmm->nUseCount > 0) {
700 /* The driver is already opened on this channel
701 * MIDI sequencer cannot be shared
702 */
703 return MCIERR_DEVICE_OPEN;
704 }
705 wmm->nUseCount++;
706
707 wmm->hFile = 0;
708 wmm->hMidi = 0;
709 dwDeviceID = lpParms->wDeviceID;
710
711 TRACE("wDevID=%04X (lpParams->wDeviceID=%08lX)\n", wDevID, dwDeviceID);
712 /* lpParms->wDeviceID = wDevID;*/
713
714 if (dwFlags & MCI_OPEN_ELEMENT) {
715 TRACE("MCI_OPEN_ELEMENT '%s' !\n", lpParms->lpstrElementName);
716 if (lpParms->lpstrElementName && strlen(lpParms->lpstrElementName) > 0) {
717 wmm->hFile = mmioOpenA(lpParms->lpstrElementName, NULL,
718 MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
719 if (wmm->hFile == 0) {
720 WARN("Can't find file '%s' !\n", lpParms->lpstrElementName);
721 wmm->nUseCount--;
722 return MCIERR_FILE_NOT_FOUND;
723 }
724 } else {
725 wmm->hFile = 0;
726 }
727 }
728 TRACE("hFile=%u\n", wmm->hFile);
729
730 /* FIXME: should I get a strdup() of it instead? */
731 wmm->lpstrElementName = HeapAlloc( GetProcessHeap(), 0, strlen(lpParms->lpstrElementName)+1 );
732 strcpy( wmm->lpstrElementName, lpParms->lpstrElementName );
733 wmm->lpstrCopyright = NULL;
734 wmm->lpstrName = NULL;
735
736 wmm->wNotifyDeviceID = dwDeviceID;
737 wmm->dwStatus = MCI_MODE_NOT_READY; /* while loading file contents */
738 /* spec says it should be the default format from the MIDI file... */
739 wmm->dwMciTimeFormat = MCI_FORMAT_MILLISECONDS;
740
741 if (wmm->hFile != 0) {
742 MMCKINFO ckMainRIFF;
743 MMCKINFO mmckInfo;
744 DWORD dwOffset = 0;
745
746 if (mmioDescend(wmm->hFile, &ckMainRIFF, NULL, 0) != 0) {
747 dwRet = MCIERR_INVALID_FILE;
748 } else {
749 TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
750 (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize);
751
752 if (ckMainRIFF.ckid == FOURCC_RIFF && ckMainRIFF.fccType == mmioFOURCC('R', 'M', 'I', 'D')) {
753 mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
754 mmioSeek(wmm->hFile, ckMainRIFF.dwDataOffset + ((ckMainRIFF.cksize + 1) & ~1), SEEK_SET);
755 if (mmioDescend(wmm->hFile, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0) {
756 TRACE("... is a 'RMID' file \n");
757 dwOffset = mmckInfo.dwDataOffset;
758 } else {
759 dwRet = MCIERR_INVALID_FILE;
760 }
761 }
762 if (dwRet == 0 && MIDI_mciReadMThd(wmm, dwOffset) != 0) {
763 WARN("Can't read 'MThd' header \n");
764 dwRet = MCIERR_INVALID_FILE;
765 }
766 }
767 } else {
768 TRACE("hFile==0, setting #tracks to 0; is this correct ?\n");
769 wmm->nTracks = 0;
770 wmm->wFormat = 0;
771 wmm->nDivision = 1;
772 }
773 if (dwRet != 0) {
774 wmm->nUseCount--;
775 if (wmm->hFile != 0)
776 mmioClose(wmm->hFile, 0);
777 wmm->hFile = 0;
778 } else {
779 wmm->dwPositionMS = 0;
780 wmm->dwStatus = MCI_MODE_STOP;
781 }
782 return dwRet;
783 }
784
785 /**************************************************************************
786 * MIDI_mciStop [internal]
787 */
788 static DWORD MIDI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
789 {
790 WINE_MCIMIDI* wmm = MIDI_mciGetOpenDev(wDevID);
791 DWORD dwRet = 0;
792
793 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
794
795 if (wmm == NULL) return MCIERR_INVALID_DEVICE_ID;
796
797 if (wmm->dwStatus != MCI_MODE_STOP) {
798 int oldstat = wmm->dwStatus;
799
800 wmm->dwStatus = MCI_MODE_NOT_READY;
801 if (oldstat == MCI_MODE_PAUSE)
802 dwRet = midiOutReset(wmm->hMidi);
803
804 while (wmm->dwStatus != MCI_MODE_STOP)
805 Sleep(10);
806 }
807
808 /* sanitiy reset */
809 wmm->dwStatus = MCI_MODE_STOP;
810
811 TRACE("wmm->dwStatus=%d\n", wmm->dwStatus);
812
813 if (lpParms && (dwFlags & MCI_NOTIFY)) {
814 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
815 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
816 wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
817 }
818 return 0;
819 }
820
821 /**************************************************************************
822 * MIDI_mciClose [internal]
823 */
824 static DWORD MIDI_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
825 {
826 WINE_MCIMIDI* wmm = MIDI_mciGetOpenDev(wDevID);
827
828 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
829
830 if (wmm == NULL) return MCIERR_INVALID_DEVICE_ID;
831
832 if (wmm->dwStatus != MCI_MODE_STOP) {
833 MIDI_mciStop(wDevID, MCI_WAIT, lpParms);
834 }
835
836 wmm->nUseCount--;
837 if (wmm->nUseCount == 0) {
838 if (wmm->hFile != 0) {
839 mmioClose(wmm->hFile, 0);
840 wmm->hFile = 0;
841 TRACE("hFile closed !\n");
842 }
843 HeapFree(GetProcessHeap(), 0, wmm->tracks);
844 HeapFree(GetProcessHeap(), 0, (LPSTR)wmm->lpstrElementName);
845 HeapFree(GetProcessHeap(), 0, (LPSTR)wmm->lpstrCopyright);
846 HeapFree(GetProcessHeap(), 0, (LPSTR)wmm->lpstrName);
847 } else {
848 TRACE("Shouldn't happen... nUseCount=%d\n", wmm->nUseCount);
849 return MCIERR_INTERNAL;
850 }
851
852 if (lpParms && (dwFlags & MCI_NOTIFY)) {
853 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
854 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
855 wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
856 }
857 return 0;
858 }
859
860 /**************************************************************************
861 * MIDI_mciFindNextEvent [internal]
862 */
863 static MCI_MIDITRACK* MIDI_mciFindNextEvent(WINE_MCIMIDI* wmm, LPDWORD hiPulse)
864 {
865 WORD cnt, nt;
866 MCI_MIDITRACK* mmt;
867
868 *hiPulse = 0xFFFFFFFFul;
869 cnt = 0xFFFFu;
870 for (nt = 0; nt < wmm->nTracks; nt++) {
871 mmt = &wmm->tracks[nt];
872
873 if (mmt->wStatus == 0)
874 continue;
875 if (mmt->dwEventPulse < *hiPulse) {
876 *hiPulse = mmt->dwEventPulse;
877 cnt = nt;
878 }
879 }
880 return (cnt == 0xFFFFu) ? 0 /* no more event on all tracks */
881 : &wmm->tracks[cnt];
882 }
883
884 /**************************************************************************
885 * MIDI_mciPlay [internal]
886 */
887 static DWORD MIDI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
888 {
889 DWORD dwStartMS, dwEndMS;
890 DWORD dwRet = 0;
891 WORD doPlay, nt;
892 MCI_MIDITRACK* mmt;
893 DWORD hiPulse;
894 WINE_MCIMIDI* wmm = MIDI_mciGetOpenDev(wDevID);
895
896 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
897
898 if (wmm == NULL) return MCIERR_INVALID_DEVICE_ID;
899
900 if (wmm->hFile == 0) {
901 WARN("Can't play: no file '%s' !\n", wmm->lpstrElementName);
902 return MCIERR_FILE_NOT_FOUND;
903 }
904
905 if (wmm->dwStatus != MCI_MODE_STOP) {
906 if (wmm->dwStatus == MCI_MODE_PAUSE) {
907 /* FIXME: parameters (start/end) in lpParams may not be used */
908 return MIDI_mciResume(wDevID, dwFlags, (LPMCI_GENERIC_PARMS)lpParms);
909 }
910 WARN("Can't play: device is not stopped !\n");
911 return MCIERR_INTERNAL;
912 }
913
914 if (!(dwFlags & MCI_WAIT)) {
915 /** FIXME: I'm not 100% sure that wNotifyDeviceID is the right value in all cases ??? */
916 return MCI_SendCommandAsync(wmm->wNotifyDeviceID, MCI_PLAY, dwFlags, (DWORD)lpParms, sizeof(LPMCI_PLAY_PARMS));
917 }
918
919 if (lpParms && (dwFlags & MCI_FROM)) {
920 dwStartMS = MIDI_ConvertTimeFormatToMS(wmm, lpParms->dwFrom);
921 } else {
922 dwStartMS = wmm->dwPositionMS;
923 }
924
925 if (lpParms && (dwFlags & MCI_TO)) {
926 dwEndMS = MIDI_ConvertTimeFormatToMS(wmm, lpParms->dwTo);
927 } else {
928 dwEndMS = 0xFFFFFFFFul;
929 }
930
931 TRACE("Playing from %lu to %lu\n", dwStartMS, dwEndMS);
932
933 /* init tracks */
934 for (nt = 0; nt < wmm->nTracks; nt++) {
935 mmt = &wmm->tracks[nt];
936
937 mmt->wStatus = 1; /* ok, playing */
938 mmt->dwIndex = mmt->dwFirst;
939 if (wmm->wFormat == 2 && nt > 0) {
940 mmt->dwEventPulse = wmm->tracks[nt - 1].dwLength;
941 } else {
942 mmt->dwEventPulse = 0;
943 }
944 MIDI_mciReadNextEvent(wmm, mmt); /* FIXME == 0 */
945 }
946
947 wmm->dwPulse = 0;
948 wmm->dwTempo = 500000;
949 wmm->dwStatus = MCI_MODE_PLAY;
950 wmm->dwPositionMS = 0;
951 wmm->wStartedPlaying = FALSE;
952
953 dwRet = midiOutOpen(&wmm->hMidi, MIDIMAPPER, 0L, 0L, CALLBACK_NULL);
954 /* dwRet = midiInOpen(&wmm->hMidi, MIDIMAPPER, 0L, 0L, CALLBACK_NULL);*/
955
956 while (wmm->dwStatus != MCI_MODE_STOP && wmm->dwStatus != MCI_MODE_NOT_READY) {
957 /* it seems that in case of multi-threading, gcc is optimizing just a little bit
958 * too much. Tell gcc not to optimize status value using volatile.
959 */
960 while (((volatile WINE_MCIMIDI*)wmm)->dwStatus == MCI_MODE_PAUSE);
961
962 doPlay = (wmm->dwPositionMS >= dwStartMS && wmm->dwPositionMS <= dwEndMS);
963
964 TRACE("wmm->dwStatus=%d, doPlay=%c\n", wmm->dwStatus, doPlay ? 'T' : 'F');
965
966 if ((mmt = MIDI_mciFindNextEvent(wmm, &hiPulse)) == NULL)
967 break; /* no more event on tracks */
968
969 /* if starting playing, then set StartTicks to the value it would have had
970 * if play had started at position 0
971 */
972 if (doPlay && !wmm->wStartedPlaying) {
973 wmm->dwStartTicks = GetTickCount() - MIDI_ConvertPulseToMS(wmm, wmm->dwPulse);
974 wmm->wStartedPlaying = TRUE;
975 TRACE("Setting dwStartTicks to %lu\n", wmm->dwStartTicks);
976 }
977
978 if (hiPulse > wmm->dwPulse) {
979 wmm->dwPositionMS += MIDI_ConvertPulseToMS(wmm, hiPulse - wmm->dwPulse);
980 if (doPlay) {
981 DWORD togo = wmm->dwStartTicks + wmm->dwPositionMS;
982 DWORD tc = GetTickCount();
983
984 TRACE("Pulses hi=0x%08lx <> cur=0x%08lx\n", hiPulse, wmm->dwPulse);
985 TRACE("Wait until %lu => %lu ms\n",
986 tc - wmm->dwStartTicks, togo - wmm->dwStartTicks);
987 if (tc < togo)
988 Sleep(togo - tc);
989 }
990 wmm->dwPulse = hiPulse;
991 }
992
993 switch (LOBYTE(LOWORD(mmt->dwEventData))) {
994 case 0xF0:
995 case 0xF7: /* sysex events */
996 {
997 FIXME("Not handling SysEx events (yet)\n");
998 }
999 break;
1000 case 0xFF:
1001 /* position after meta data header */
1002 mmioSeek(wmm->hFile, mmt->dwIndex + HIWORD(mmt->dwEventData), SEEK_SET);
1003 switch (HIBYTE(LOWORD(mmt->dwEventData))) {
1004 case 0x00: /* 16-bit sequence number */
1005 if (TRACE_ON(mcimidi)) {
1006 WORD twd;
1007
1008 MIDI_mciReadWord(wmm, &twd); /* == 0 */
1009 TRACE("Got sequence number %u\n", twd);
1010 }
1011 break;
1012 case 0x01: /* any text */
1013 case 0x02: /* Copyright Message text */
1014 case 0x03: /* Sequence/Track Name text */
1015 case 0x04: /* Instrument Name text */
1016 case 0x05: /* Lyric text */
1017 case 0x06: /* Marker text */
1018 case 0x07: /* Cue-point text */
1019 if (TRACE_ON(mcimidi)) {
1020 char buf[1024];
1021 WORD len = mmt->wEventLength - HIWORD(mmt->dwEventData);
1022 static char* info[8] = {"", "Text", "Copyright", "Seq/Trk name",
1023 "Instrument", "Lyric", "Marker", "Cue-point"};
1024 WORD idx = HIBYTE(LOWORD(mmt->dwEventData));
1025
1026 if (len >= sizeof(buf)) {
1027 WARN("Buffer for text is too small (%d bytes, when %u are needed)\n", sizeof(buf) - 1, len);
1028 len = sizeof(buf) - 1;
1029 }
1030 if (mmioRead(wmm->hFile, (HPSTR)buf, len) == len) {
1031 buf[len] = 0; /* end string in case */
1032 TRACE("%s => \"%s\"\n", (idx < 8 ) ? info[idx] : "", buf);
1033 } else {
1034 WARN("Couldn't read data for %s\n", (idx < 8) ? info[idx] : "");
1035 }
1036 }
1037 break;
1038 case 0x20:
1039 /* MIDI channel (cc) */
1040 if (FIXME_ON(mcimidi)) {
1041 BYTE bt;
1042
1043 MIDI_mciReadByte(wmm, &bt); /* == 0 */
1044 FIXME("NIY: MIDI channel=%u, track=%u\n", bt, mmt->wTrackNr);
1045 }
1046 break;
1047 case 0x21:
1048 /* MIDI port (pp) */
1049 if (FIXME_ON(mcimidi)) {
1050 BYTE bt;
1051
1052 MIDI_mciReadByte(wmm, &bt); /* == 0 */
1053 FIXME("NIY: MIDI port=%u, track=%u\n", bt, mmt->wTrackNr);
1054 }
1055 break;
1056 case 0x2F: /* end of track */
1057 mmt->wStatus = 0;
1058 break;
1059 case 0x51:/* set tempo */
1060 /* Tempo is expressed in µ-seconds per midi quarter note
1061 * for format 1 MIDI files, this can only be present on track #0
1062 */
1063 if (mmt->wTrackNr != 0 && wmm->wFormat == 1) {
1064 WARN("For format #1 MIDI files, tempo can only be changed on track #0 (%u)\n", mmt->wTrackNr);
1065 } else {
1066 BYTE tbt;
1067 DWORD value = 0;
1068
1069 MIDI_mciReadByte(wmm, &tbt); value = ((DWORD)tbt) << 16;
1070 MIDI_mciReadByte(wmm, &tbt); value |= ((DWORD)tbt) << 8;
1071 MIDI_mciReadByte(wmm, &tbt); value |= ((DWORD)tbt) << 0;
1072 TRACE("Setting tempo to %ld (BPM=%ld)\n", wmm->dwTempo, (value) ? (60000000l / value) : 0);
1073 wmm->dwTempo = value;
1074 }
1075 break;
1076 case 0x54: /* (hour) (min) (second) (frame) (fractional-frame) - SMPTE track start */
1077 if (mmt->wTrackNr != 0 && wmm->wFormat == 1) {
1078 WARN("For format #1 MIDI files, SMPTE track start can only be expressed on track #0 (%u)\n", mmt->wTrackNr);
1079 } if (mmt->dwEventPulse != 0) {
1080 WARN("SMPTE track start can only be expressed at start of track (%lu)\n", mmt->dwEventPulse);
1081 } else {
1082 BYTE h, m, s, f, ff;
1083
1084 MIDI_mciReadByte(wmm, &h);
1085 MIDI_mciReadByte(wmm, &m);
1086 MIDI_mciReadByte(wmm, &s);
1087 MIDI_mciReadByte(wmm, &f);
1088 MIDI_mciReadByte(wmm, &ff);
1089 FIXME("NIY: SMPTE track start %u:%u:%u %u.%u\n", h, m, s, f, ff);
1090 }
1091 break;
1092 case 0x58: /* file rythm */
1093 if (TRACE_ON(mcimidi)) {
1094 BYTE num, den, cpmc, _32npqn;
1095
1096 MIDI_mciReadByte(wmm, &num);
1097 MIDI_mciReadByte(wmm, &den); /* to notate e.g. 6/8 */
1098 MIDI_mciReadByte(wmm, &cpmc); /* number of MIDI clocks per metronome click */
1099 MIDI_mciReadByte(wmm, &_32npqn); /* number of notated 32nd notes per MIDI quarter note */
1100
1101 TRACE("%u/%u, clock per metronome click=%u, 32nd notes by 1/4 note=%u\n", num, 1 << den, cpmc, _32npqn);
1102 }
1103 break;
1104 case 0x59: /* key signature */
1105 if (TRACE_ON(mcimidi)) {
1106 BYTE sf, mm;
1107
1108 MIDI_mciReadByte(wmm, &sf);
1109 MIDI_mciReadByte(wmm, &mm);
1110
1111 if (sf >= 0x80) TRACE("%d flats\n", -(char)sf);
1112 else if (sf > 0) TRACE("%d sharps\n", (char)sf);
1113 else TRACE("Key of C\n");
1114 TRACE("Mode: %s\n", (mm = 0) ? "major" : "minor");
1115 }
1116 break;
1117 default:
1118 WARN("Unknown MIDI meta event %02x. Skipping...\n", HIBYTE(LOWORD(mmt->dwEventData)));
1119 break;
1120 }
1121 break;
1122 default:
1123 if (doPlay) {
1124 dwRet = midiOutShortMsg(wmm->hMidi, mmt->dwEventData);
1125 } else {
1126 switch (LOBYTE(LOWORD(mmt->dwEventData)) & 0xF0) {
1127 case MIDI_NOTEON:
1128 case MIDI_NOTEOFF:
1129 dwRet = 0;
1130 break;
1131 default:
1132 dwRet = midiOutShortMsg(wmm->hMidi, mmt->dwEventData);
1133 }
1134 }
1135 }
1136 mmt->dwIndex += mmt->wEventLength;
1137 if (mmt->dwIndex < mmt->dwFirst || mmt->dwIndex >= mmt->dwLast) {
1138 mmt->wStatus = 0;
1139 }
1140 if (mmt->wStatus) {
1141 MIDI_mciReadNextEvent(wmm, mmt);
1142 }
1143 }
1144
1145 midiOutReset(wmm->hMidi);
1146
1147 dwRet = midiOutClose(wmm->hMidi);
1148 /* to restart playing at beginning when it's over */
1149 wmm->dwPositionMS = 0;
1150
1151 if (lpParms && (dwFlags & MCI_NOTIFY)) {
1152 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
1153 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
1154 wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
1155 }
1156
1157 wmm->dwStatus = MCI_MODE_STOP;
1158 return dwRet;
1159 }
1160
1161 /**************************************************************************
1162 * MIDI_mciRecord [internal]
1163 */
1164 static DWORD MIDI_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms)
1165 {
1166 int start, end;
1167 MIDIHDR midiHdr;
1168 DWORD dwRet;
1169 WINE_MCIMIDI* wmm = MIDI_mciGetOpenDev(wDevID);
1170
1171 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1172
1173 if (wmm == 0) return MCIERR_INVALID_DEVICE_ID;
1174
1175 if (wmm->hFile == 0) {
1176 WARN("Can't find file='%s' !\n", wmm->lpstrElementName);
1177 return MCIERR_FILE_NOT_FOUND;
1178 }
1179 start = 1; end = 99999;
1180 if (lpParms && (dwFlags & MCI_FROM)) {
1181 start = lpParms->dwFrom;
1182 TRACE("MCI_FROM=%d \n", start);
1183 }
1184 if (lpParms && (dwFlags & MCI_TO)) {
1185 end = lpParms->dwTo;
1186 TRACE("MCI_TO=%d \n", end);
1187 }
1188 midiHdr.lpData = (LPSTR) HeapAlloc(GetProcessHeap(), 0, 1200);
1189 if (!midiHdr.lpData)
1190 return MCIERR_OUT_OF_MEMORY;
1191 midiHdr.dwBufferLength = 1024;
1192 midiHdr.dwUser = 0L;
1193 midiHdr.dwFlags = 0L;
1194 dwRet = midiInPrepareHeader(wmm->hMidi, &midiHdr, sizeof(MIDIHDR));
1195 TRACE("After MIDM_PREPARE \n");
1196 wmm->dwStatus = MCI_MODE_RECORD;
1197 /* FIXME: there is no buffer added */
1198 while (wmm->dwStatus != MCI_MODE_STOP) {
1199 TRACE("wmm->dwStatus=%p %d\n",
1200 &wmm->dwStatus, wmm->dwStatus);
1201 midiHdr.dwBytesRecorded = 0;
1202 dwRet = midiInStart(wmm->hMidi);
1203 TRACE("midiInStart => dwBytesRecorded=%lu\n", midiHdr.dwBytesRecorded);
1204 if (midiHdr.dwBytesRecorded == 0) break;
1205 }
1206 TRACE("Before MIDM_UNPREPARE \n");
1207 dwRet = midiInUnprepareHeader(wmm->hMidi, &midiHdr, sizeof(MIDIHDR));
1208 TRACE("After MIDM_UNPREPARE \n");
1209 if (midiHdr.lpData != NULL) {
1210 HeapFree(GetProcessHeap(), 0, midiHdr.lpData);
1211 midiHdr.lpData = NULL;
1212 }
1213 wmm->dwStatus = MCI_MODE_STOP;
1214 if (lpParms && (dwFlags & MCI_NOTIFY)) {
1215 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
1216 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
1217 wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
1218 }
1219 return 0;
1220 }
1221
1222 /**************************************************************************
1223 * MIDI_mciPause [internal]
1224 */
1225 static DWORD MIDI_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
1226 {
1227 WINE_MCIMIDI* wmm = MIDI_mciGetOpenDev(wDevID);
1228
1229 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1230
1231 if (wmm == NULL) return MCIERR_INVALID_DEVICE_ID;
1232
1233 if (wmm->dwStatus == MCI_MODE_PLAY) {
1234 /* stop all notes */
1235 unsigned chn;
1236 for (chn = 0; chn < 16; chn++)
1237 midiOutShortMsg(wmm->hMidi, 0x78B0 | chn);
1238 wmm->dwStatus = MCI_MODE_PAUSE;
1239 }
1240 if (lpParms && (dwFlags & MCI_NOTIFY)) {
1241 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
1242 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
1243 wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
1244 }
1245
1246 return 0;
1247 }
1248
1249 /**************************************************************************
1250 * MIDI_mciResume [internal]
1251 */
1252 static DWORD MIDI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
1253 {
1254 WINE_MCIMIDI* wmm = MIDI_mciGetOpenDev(wDevID);
1255
1256 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1257
1258 if (wmm == NULL) return MCIERR_INVALID_DEVICE_ID;
1259
1260 if (wmm->dwStatus == MCI_MODE_PAUSE) {
1261 wmm->wStartedPlaying = FALSE;
1262 wmm->dwStatus = MCI_MODE_PLAY;
1263 }
1264 if (lpParms && (dwFlags & MCI_NOTIFY)) {
1265 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
1266 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
1267 wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
1268 }
1269 return 0;
1270 }
1271
1272 /**************************************************************************
1273 * MIDI_mciSet [internal]
1274 */
1275 static DWORD MIDI_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
1276 {
1277 WINE_MCIMIDI* wmm = MIDI_mciGetOpenDev(wDevID);
1278
1279 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1280
1281 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1282 if (wmm == NULL) return MCIERR_INVALID_DEVICE_ID;
1283
1284 if (dwFlags & MCI_SET_TIME_FORMAT) {
1285 switch (lpParms->dwTimeFormat) {
1286 case MCI_FORMAT_MILLISECONDS:
1287 TRACE("MCI_FORMAT_MILLISECONDS !\n");
1288 wmm->dwMciTimeFormat = MCI_FORMAT_MILLISECONDS;
1289 break;
1290 case MCI_FORMAT_SMPTE_24:
1291 TRACE("MCI_FORMAT_SMPTE_24 !\n");
1292 wmm->dwMciTimeFormat = MCI_FORMAT_SMPTE_24;
1293 break;
1294 case MCI_FORMAT_SMPTE_25:
1295 TRACE("MCI_FORMAT_SMPTE_25 !\n");
1296 wmm->dwMciTimeFormat = MCI_FORMAT_SMPTE_25;
1297 break;
1298 case MCI_FORMAT_SMPTE_30:
1299 TRACE("MCI_FORMAT_SMPTE_30 !\n");
1300 wmm->dwMciTimeFormat = MCI_FORMAT_SMPTE_30;
1301 break;
1302 default:
1303 WARN("Bad time format %lu!\n", lpParms->dwTimeFormat);
1304 return MCIERR_BAD_TIME_FORMAT;
1305 }
1306 }
1307 if (dwFlags & MCI_SET_VIDEO) {
1308 TRACE("No support for video !\n");
1309 return MCIERR_UNSUPPORTED_FUNCTION;
1310 }
1311 if (dwFlags & MCI_SET_DOOR_OPEN) {
1312 TRACE("No support for door open !\n");
1313 return MCIERR_UNSUPPORTED_FUNCTION;
1314 }
1315 if (dwFlags & MCI_SET_DOOR_CLOSED) {
1316 TRACE("No support for door close !\n");
1317 return MCIERR_UNSUPPORTED_FUNCTION;
1318 }
1319 if (dwFlags & MCI_SET_AUDIO) {
1320 if (dwFlags & MCI_SET_ON) {
1321 TRACE("MCI_SET_ON audio !\n");
1322 } else if (dwFlags & MCI_SET_OFF) {
1323 TRACE("MCI_SET_OFF audio !\n");
1324 } else {
1325 WARN("MCI_SET_AUDIO without SET_ON or SET_OFF\n");
1326 return MCIERR_BAD_INTEGER;
1327 }
1328
1329 if (lpParms->dwAudio & MCI_SET_AUDIO_ALL)
1330 TRACE("MCI_SET_AUDIO_ALL !\n");
1331 if (lpParms->dwAudio & MCI_SET_AUDIO_LEFT)
1332 TRACE("MCI_SET_AUDIO_LEFT !\n");
1333 if (lpParms->dwAudio & MCI_SET_AUDIO_RIGHT)
1334 TRACE("MCI_SET_AUDIO_RIGHT !\n");
1335 }
1336
1337 if (dwFlags & MCI_SEQ_SET_MASTER)
1338 TRACE("MCI_SEQ_SET_MASTER !\n");
1339 if (dwFlags & MCI_SEQ_SET_SLAVE)
1340 TRACE("MCI_SEQ_SET_SLAVE !\n");
1341 if (dwFlags & MCI_SEQ_SET_OFFSET)
1342 TRACE("MCI_SEQ_SET_OFFSET !\n");
1343 if (dwFlags & MCI_SEQ_SET_PORT)
1344 TRACE("MCI_SEQ_SET_PORT !\n");
1345 if (dwFlags & MCI_SEQ_SET_TEMPO)
1346 TRACE("MCI_SEQ_SET_TEMPO !\n");
1347 return 0;
1348 }
1349
1350 /**************************************************************************
1351 * MIDI_mciStatus [internal]
1352 */
1353 static DWORD MIDI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
1354 {
1355 WINE_MCIMIDI* wmm = MIDI_mciGetOpenDev(wDevID);
1356 DWORD ret = 0;
1357
1358 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1359
1360 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1361 if (wmm == NULL) return MCIERR_INVALID_DEVICE_ID;
1362
1363 if (dwFlags & MCI_STATUS_ITEM) {
1364 switch (lpParms->dwItem) {
1365 case MCI_STATUS_CURRENT_TRACK:
1366 /* FIXME in Format 2 */
1367 lpParms->dwReturn = 1;
1368 TRACE("MCI_STATUS_CURRENT_TRACK => %lu\n", lpParms->dwReturn);
1369 break;
1370 case MCI_STATUS_LENGTH:
1371 if ((dwFlags & MCI_TRACK) && wmm->wFormat == 2) {
1372 if (lpParms->dwTrack >= wmm->nTracks)
1373 return MCIERR_BAD_INTEGER;
1374 /* FIXME: this is wrong if there is a tempo change inside the file */
1375 lpParms->dwReturn = MIDI_ConvertPulseToMS(wmm, wmm->tracks[lpParms->dwTrack].dwLength);
1376 } else {
1377 lpParms->dwReturn = MIDI_GetMThdLengthMS(wmm);
1378 }
1379 lpParms->dwReturn = MIDI_ConvertMSToTimeFormat(wmm, lpParms->dwReturn);
1380 TRACE("MCI_STATUS_LENGTH => %lu\n", lpParms->dwReturn);
1381 break;
1382 case MCI_STATUS_MODE:
1383 TRACE("MCI_STATUS_MODE => %u\n", wmm->dwStatus);
1384 lpParms->dwReturn = MAKEMCIRESOURCE(wmm->dwStatus, wmm->dwStatus);
1385 ret = MCI_RESOURCE_RETURNED;
1386 break;
1387 case MCI_STATUS_MEDIA_PRESENT:
1388 TRACE("MCI_STATUS_MEDIA_PRESENT => TRUE\n");
1389 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1390 ret = MCI_RESOURCE_RETURNED;
1391 break;
1392 case MCI_STATUS_NUMBER_OF_TRACKS:
1393 lpParms->dwReturn = (wmm->wFormat == 2) ? wmm->nTracks : 1;
1394 TRACE("MCI_STATUS_NUMBER_OF_TRACKS => %lu\n", lpParms->dwReturn);
1395 break;
1396 case MCI_STATUS_POSITION:
1397 /* FIXME: do I need to use MCI_TRACK ? */
1398 lpParms->dwReturn = MIDI_ConvertMSToTimeFormat(wmm,
1399 (dwFlags & MCI_STATUS_START) ? 0 : wmm->dwPositionMS);
1400 TRACE("MCI_STATUS_POSITION %s => %lu\n",
1401 (dwFlags & MCI_STATUS_START) ? "start" : "current", lpParms->dwReturn);
1402 break;
1403 case MCI_STATUS_READY:
1404 lpParms->dwReturn = (wmm->dwStatus == MCI_MODE_NOT_READY) ?
1405 MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1406 ret = MCI_RESOURCE_RETURNED;
1407 TRACE("MCI_STATUS_READY = %u\n", LOWORD(lpParms->dwReturn));
1408 break;
1409 case MCI_STATUS_TIME_FORMAT:
1410 lpParms->dwReturn = MAKEMCIRESOURCE(wmm->dwMciTimeFormat, wmm->dwMciTimeFormat);
1411 TRACE("MCI_STATUS_TIME_FORMAT => %u\n", LOWORD(lpParms->dwReturn));
1412 ret = MCI_RESOURCE_RETURNED;
1413 break;
1414 case MCI_SEQ_STATUS_DIVTYPE:
1415 TRACE("MCI_SEQ_STATUS_DIVTYPE !\n");
1416 if (wmm->nDivision > 0x8000) {
1417 switch (wmm->nDivision) {
1418 case 0xE8: lpParms->dwReturn = MCI_SEQ_DIV_SMPTE_24; break; /* -24 */
1419 case 0xE7: lpParms->dwReturn = MCI_SEQ_DIV_SMPTE_25; break; /* -25 */
1420 case 0xE3: lpParms->dwReturn = MCI_SEQ_DIV_SMPTE_30DROP; break; /* -29 */ /* is the MCI constant correct ? */
1421 case 0xE2: lpParms->dwReturn = MCI_SEQ_DIV_SMPTE_30; break; /* -30 */
1422 default: FIXME("There is a bad bad programmer\n");
1423 }
1424 } else {
1425 lpParms->dwReturn = MCI_SEQ_DIV_PPQN;
1426 }
1427 lpParms->dwReturn = MAKEMCIRESOURCE(lpParms->dwReturn,lpParms->dwReturn);
1428 ret = MCI_RESOURCE_RETURNED;
1429 break;
1430 case MCI_SEQ_STATUS_MASTER:
1431 TRACE("MCI_SEQ_STATUS_MASTER !\n");
1432 lpParms->dwReturn = 0;
1433 break;
1434 case MCI_SEQ_STATUS_SLAVE:
1435 TRACE("MCI_SEQ_STATUS_SLAVE !\n");
1436 lpParms->dwReturn = 0;
1437 break;
1438 case MCI_SEQ_STATUS_OFFSET:
1439 TRACE("MCI_SEQ_STATUS_OFFSET !\n");
1440 lpParms->dwReturn = 0;
1441 break;
1442 case MCI_SEQ_STATUS_PORT:
1443 TRACE("MCI_SEQ_STATUS_PORT (%u)!\n", wmm->wDevID);
1444 lpParms->dwReturn = MIDI_MAPPER;
1445 break;
1446 case MCI_SEQ_STATUS_TEMPO:
1447 TRACE("MCI_SEQ_STATUS_TEMPO !\n");
1448 lpParms->dwReturn = wmm->dwTempo;
1449 break;
1450 default:
1451 FIXME("Unknowm command %08lX !\n", lpParms->dwItem);
1452 return MCIERR_UNRECOGNIZED_COMMAND;
1453 }
1454 } else {
1455 WARN("No Status-Item!\n");
1456 return MCIERR_UNRECOGNIZED_COMMAND;
1457 }
1458 if (dwFlags & MCI_NOTIFY) {
1459 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
1460 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
1461 wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
1462 }
1463 return ret;
1464 }
1465
1466 /**************************************************************************
1467 * MIDI_mciGetDevCaps [internal]
1468 */
1469 static DWORD MIDI_mciGetDevCaps(UINT wDevID, DWORD dwFlags,
1470 LPMCI_GETDEVCAPS_PARMS lpParms)
1471 {
1472 WINE_MCIMIDI* wmm = MIDI_mciGetOpenDev(wDevID);
1473 DWORD ret;
1474
1475 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1476
1477 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1478 if (wmm == NULL) return MCIERR_INVALID_DEVICE_ID;
1479
1480 if (dwFlags & MCI_GETDEVCAPS_ITEM) {
1481 switch (lpParms->dwItem) {
1482 case MCI_GETDEVCAPS_DEVICE_TYPE:
1483 TRACE("MCI_GETDEVCAPS_DEVICE_TYPE !\n");
1484 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_SEQUENCER, MCI_DEVTYPE_SEQUENCER);
1485 ret = MCI_RESOURCE_RETURNED;
1486 break;
1487 case MCI_GETDEVCAPS_HAS_AUDIO:
1488 TRACE("MCI_GETDEVCAPS_HAS_AUDIO !\n");
1489 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1490 ret = MCI_RESOURCE_RETURNED;
1491 break;
1492 case MCI_GETDEVCAPS_HAS_VIDEO:
1493 TRACE("MCI_GETDEVCAPS_HAS_VIDEO !\n");
1494 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
1495 ret = MCI_RESOURCE_RETURNED;
1496 break;
1497 case MCI_GETDEVCAPS_USES_FILES:
1498 TRACE("MCI_GETDEVCAPS_USES_FILES !\n");
1499 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1500 ret = MCI_RESOURCE_RETURNED;
1501 break;
1502 case MCI_GETDEVCAPS_COMPOUND_DEVICE:
1503 TRACE("MCI_GETDEVCAPS_COMPOUND_DEVICE !\n");
1504 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1505 ret = MCI_RESOURCE_RETURNED;
1506 break;
1507 case MCI_GETDEVCAPS_CAN_EJECT:
1508 TRACE("MCI_GETDEVCAPS_CAN_EJECT !\n");
1509 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
1510 ret = MCI_RESOURCE_RETURNED;
1511 break;
1512 case MCI_GETDEVCAPS_CAN_PLAY:
1513 TRACE("MCI_GETDEVCAPS_CAN_PLAY !\n");
1514 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1515 ret = MCI_RESOURCE_RETURNED;
1516 break;
1517 case MCI_GETDEVCAPS_CAN_RECORD:
1518 TRACE("MCI_GETDEVCAPS_CAN_RECORD !\n");
1519 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1520 ret = MCI_RESOURCE_RETURNED;
1521 break;
1522 case MCI_GETDEVCAPS_CAN_SAVE:
1523 TRACE("MCI_GETDEVCAPS_CAN_SAVE !\n");
1524 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
1525 ret = MCI_RESOURCE_RETURNED;
1526 break;
1527 default:
1528 FIXME("Unknown capability (%08lx) !\n", lpParms->dwItem);
1529 return MCIERR_UNRECOGNIZED_COMMAND;
1530 }
1531 } else {
1532 WARN("No GetDevCaps-Item !\n");
1533 return MCIERR_UNRECOGNIZED_COMMAND;
1534 }
1535 return ret;
1536 }
1537
1538 /**************************************************************************
1539 * MIDI_mciInfo [internal]
1540 */
1541 static DWORD MIDI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMSA lpParms)
1542 {
1543 LPCSTR str = 0;
1544 WINE_MCIMIDI* wmm = MIDI_mciGetOpenDev(wDevID);
1545 DWORD ret = 0;
1546
1547 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1548
1549 if (lpParms == NULL || lpParms->lpstrReturn == NULL)
1550 return MCIERR_NULL_PARAMETER_BLOCK;
1551 if (wmm == NULL) return MCIERR_INVALID_DEVICE_ID;
1552
1553 TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
1554
1555 switch (dwFlags & ~(MCI_WAIT|MCI_NOTIFY)) {
1556 case MCI_INFO_PRODUCT:
1557 str = "Wine's MIDI sequencer";
1558 break;
1559 case MCI_INFO_FILE:
1560 str = wmm->lpstrElementName;
1561 break;
1562 case MCI_INFO_COPYRIGHT:
1563 str = wmm->lpstrCopyright;
1564 break;
1565 case MCI_INFO_NAME:
1566 str = wmm->lpstrName;
1567 break;
1568 default:
1569 WARN("Don't know this info command (%lu)\n", dwFlags);
1570 return MCIERR_UNRECOGNIZED_COMMAND;
1571 }
1572 if (str) {
1573 if (lpParms->dwRetSize <= strlen(str)) {
1574 lstrcpynA(lpParms->lpstrReturn, str, lpParms->dwRetSize - 1);
1575 ret = MCIERR_PARAM_OVERFLOW;
1576 } else {
1577 strcpy(lpParms->lpstrReturn, str);
1578 }
1579 } else {
1580 *lpParms->lpstrReturn = 0;
1581 }
1582 return ret;
1583 }
1584
1585 /**************************************************************************
1586 * MIDI_mciSeek [internal]
1587 */
1588 static DWORD MIDI_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
1589 {
1590 DWORD ret = 0;
1591 WINE_MCIMIDI* wmm = MIDI_mciGetOpenDev(wDevID);
1592
1593 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1594
1595 if (lpParms == NULL) {
1596 ret = MCIERR_NULL_PARAMETER_BLOCK;
1597 } else if (wmm == NULL) {
1598 ret = MCIERR_INVALID_DEVICE_ID;
1599 } else {
1600 MIDI_mciStop(wDevID, MCI_WAIT, 0);
1601
1602 if (dwFlags & MCI_SEEK_TO_START) {
1603 wmm->dwPositionMS = 0;
1604 } else if (dwFlags & MCI_SEEK_TO_END) {
1605 wmm->dwPositionMS = 0xFFFFFFFF; /* fixme */
1606 } else if (dwFlags & MCI_TO) {
1607 wmm->dwPositionMS = MIDI_ConvertTimeFormatToMS(wmm, lpParms->dwTo);
1608 } else {
1609 WARN("dwFlag doesn't tell where to seek to...\n");
1610 return MCIERR_MISSING_PARAMETER;
1611 }
1612
1613 TRACE("Seeking to position=%lu ms\n", wmm->dwPositionMS);
1614
1615 if (dwFlags & MCI_NOTIFY) {
1616 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
1617 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
1618 wmm->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
1619 }
1620 }
1621 return ret;
1622 }
1623
1624 /*======================================================================*
1625 * MIDI entry points *
1626 *======================================================================*/
1627
1628 /**************************************************************************
1629 * DriverProc (MCISEQ.@)
1630 */
1631 LONG CALLBACK MCIMIDI_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
1632 DWORD dwParam1, DWORD dwParam2)
1633 {
1634 switch (wMsg) {
1635 case DRV_LOAD: return 1;
1636 case DRV_FREE: return 1;
1637 case DRV_ENABLE: return 1;
1638 case DRV_DISABLE: return 1;
1639 case DRV_QUERYCONFIGURE: return 1;
1640 case DRV_CONFIGURE: MessageBoxA(0, "Sample Midi Driver !", "OSS Driver", MB_OK); return 1;
1641 case DRV_INSTALL: return DRVCNF_RESTART;
1642 case DRV_REMOVE: return DRVCNF_RESTART;
1643 case DRV_OPEN: return MIDI_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
1644 case DRV_CLOSE: return MIDI_drvClose(dwDevID);
1645 case MCI_OPEN_DRIVER: return MIDI_mciOpen (dwDevID, dwParam1, (LPMCI_OPEN_PARMSA) dwParam2);
1646 case MCI_CLOSE_DRIVER: return MIDI_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1647 case MCI_PLAY: return MIDI_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
1648 case MCI_RECORD: return MIDI_mciRecord (dwDevID, dwParam1, (LPMCI_RECORD_PARMS) dwParam2);
1649 case MCI_STOP: return MIDI_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1650 case MCI_SET: return MIDI_mciSet (dwDevID, dwParam1, (LPMCI_SET_PARMS) dwParam2);
1651 case MCI_PAUSE: return MIDI_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1652 case MCI_RESUME: return MIDI_mciResume (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1653 case MCI_STATUS: return MIDI_mciStatus (dwDevID, dwParam1, (LPMCI_STATUS_PARMS) dwParam2);
1654 case MCI_GETDEVCAPS: return MIDI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
1655 case MCI_INFO: return MIDI_mciInfo (dwDevID, dwParam1, (LPMCI_INFO_PARMSA) dwParam2);
1656 case MCI_SEEK: return MIDI_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
1657 /* commands that should be supported */
1658 case MCI_LOAD:
1659 case MCI_SAVE:
1660 case MCI_FREEZE:
1661 case MCI_PUT:
1662 case MCI_REALIZE:
1663 case MCI_UNFREEZE:
1664 case MCI_UPDATE:
1665 case MCI_WHERE:
1666 case MCI_STEP:
1667 case MCI_SPIN:
1668 case MCI_ESCAPE:
1669 case MCI_COPY:
1670 case MCI_CUT:
1671 case MCI_DELETE:
1672 case MCI_PASTE:
1673 WARN("Unsupported command [%lu]\n", wMsg);
1674 break;
1675 /* commands that should report an error */
1676 case MCI_WINDOW:
1677 TRACE("Unsupported command [%lu]\n", wMsg);
1678 break;
1679 case MCI_OPEN:
1680 case MCI_CLOSE:
1681 FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1682 break;
1683 default:
1684 TRACE("Sending msg [%lu] to default driver proc\n", wMsg);
1685 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1686 }
1687 return MCIERR_UNRECOGNIZED_COMMAND;
1688 }
1689
1690
DirectPlay implementation for GSoC