?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Ignore MCI_OPEN_ELEMENT in CDAUDIO_mciOpen.
[wine/gsoc_dplay.git] / dlls / winmm / mcicda / mcicda.c
bloba4a2f4da7d2ac9f5119d3a325be6cb7135298a87
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2 /*
3 * Sample MCI CDAUDIO Wine Driver for Linux
4 *
5 * Copyright 1994 Martin Ayotte
6 * Copyright 1998-99 Eric Pouech
7 */
8
9 #include "winuser.h"
10 #include "driver.h"
11 #include "mmddk.h"
12 #include "cdrom.h"
13 #include "debugtools.h"
14
15 DEFAULT_DEBUG_CHANNEL(cdaudio)
16
17 typedef struct {
18 UINT wDevID;
19 int nUseCount; /* Incremented for each shared open */
20 BOOL fShareable; /* TRUE if first open was shareable */
21 WORD wNotifyDeviceID; /* MCI device ID with a pending notification */
22 HANDLE hCallback; /* Callback handle for pending notification */
23 DWORD dwTimeFormat;
24 WINE_CDAUDIO wcda;
25 int mciMode;
26 } WINE_MCICDAUDIO;
27
28 /*-----------------------------------------------------------------------*/
29
30 /**************************************************************************
31 * CDAUDIO_drvOpen [internal]
32 */
33 static DWORD CDAUDIO_drvOpen(LPSTR str, LPMCI_OPEN_DRIVER_PARMSA modp)
34 {
35 WINE_MCICDAUDIO* wmcda = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCICDAUDIO));
36
37 if (!wmcda)
38 return 0;
39
40 wmcda->wDevID = modp->wDeviceID;
41 mciSetDriverData(wmcda->wDevID, (DWORD)wmcda);
42 modp->wCustomCommandTable = MCI_NO_COMMAND_TABLE;
43 modp->wType = MCI_DEVTYPE_CD_AUDIO;
44 return modp->wDeviceID;
45 }
46
47 /**************************************************************************
48 * CDAUDIO_drvClose [internal]
49 */
50 static DWORD CDAUDIO_drvClose(DWORD dwDevID)
51 {
52 WINE_MCICDAUDIO* wmcda = (WINE_MCICDAUDIO*)mciGetDriverData(dwDevID);
53
54 if (wmcda) {
55 HeapFree(GetProcessHeap(), 0, wmcda);
56 mciSetDriverData(dwDevID, 0);
57 }
58 return 0;
59 }
60
61 /**************************************************************************
62 * CDAUDIO_mciGetOpenDrv [internal]
63 */
64 static WINE_MCICDAUDIO* CDAUDIO_mciGetOpenDrv(UINT wDevID)
65 {
66 WINE_MCICDAUDIO* wmcda = (WINE_MCICDAUDIO*)mciGetDriverData(wDevID);
67
68 if (wmcda == NULL || wmcda->nUseCount == 0 || wmcda->wcda.unixdev <= 0) {
69 WARN("Invalid wDevID=%u\n", wDevID);
70 return 0;
71 }
72 return wmcda;
73 }
74
75 /**************************************************************************
76 * CDAUDIO_mciMode [internal]
77 */
78 static int CDAUDIO_mciMode(int wcdaMode)
79 {
80 switch (wcdaMode) {
81 case WINE_CDA_DONTKNOW: return MCI_MODE_STOP;
82 case WINE_CDA_NOTREADY: return MCI_MODE_STOP;
83 case WINE_CDA_OPEN: return MCI_MODE_OPEN;
84 case WINE_CDA_PLAY: return MCI_MODE_PLAY;
85 case WINE_CDA_STOP: return MCI_MODE_STOP;
86 case WINE_CDA_PAUSE: return MCI_MODE_PAUSE;
87 default:
88 FIXME("Unknown mode %04x\n", wcdaMode);
89 }
90 return MCI_MODE_STOP;
91 }
92
93 /**************************************************************************
94 * CDAUDIO_mciGetError [internal]
95 */
96 static int CDAUDIO_mciGetError(WINE_MCICDAUDIO* wmcda)
97 {
98 switch (wmcda->wcda.cdaMode) {
99 case WINE_CDA_DONTKNOW:
100 case WINE_CDA_NOTREADY: return MCIERR_DEVICE_NOT_READY;
101 case WINE_CDA_OPEN: return MCIERR_DEVICE_OPEN;
102 case WINE_CDA_PLAY:
103 case WINE_CDA_STOP:
104 case WINE_CDA_PAUSE: break;
105 default:
106 FIXME("Unknown mode %04x\n", wmcda->wcda.cdaMode);
107 }
108 return MCIERR_DRIVER_INTERNAL;
109 }
110
111 /**************************************************************************
112 * CDAUDIO_CalcFrame [internal]
113 */
114 static DWORD CDAUDIO_CalcFrame(WINE_MCICDAUDIO* wmcda, DWORD dwTime)
115 {
116 DWORD dwFrame = 0;
117 UINT wTrack;
118
119 TRACE("(%p, %08lX, %lu);\n", wmcda, wmcda->dwTimeFormat, dwTime);
120
121 switch (wmcda->dwTimeFormat) {
122 case MCI_FORMAT_MILLISECONDS:
123 dwFrame = (dwTime * CDFRAMES_PERSEC) / 1000;
124 TRACE("MILLISECONDS %lu\n", dwFrame);
125 break;
126 case MCI_FORMAT_MSF:
127 TRACE("MSF %02u:%02u:%02u\n",
128 MCI_MSF_MINUTE(dwTime), MCI_MSF_SECOND(dwTime), MCI_MSF_FRAME(dwTime));
129 dwFrame += CDFRAMES_PERMIN * MCI_MSF_MINUTE(dwTime);
130 dwFrame += CDFRAMES_PERSEC * MCI_MSF_SECOND(dwTime);
131 dwFrame += MCI_MSF_FRAME(dwTime);
132 break;
133 case MCI_FORMAT_TMSF:
134 default:
135 /* unknown format ! force TMSF ! ... */
136 wTrack = MCI_TMSF_TRACK(dwTime);
137 TRACE("MSF %02u-%02u:%02u:%02u\n",
138 MCI_TMSF_TRACK(dwTime), MCI_TMSF_MINUTE(dwTime),
139 MCI_TMSF_SECOND(dwTime), MCI_TMSF_FRAME(dwTime));
140 TRACE("TMSF trackpos[%u]=%lu\n",
141 wTrack, wmcda->wcda.lpdwTrackPos[wTrack - 1]);
142 dwFrame = wmcda->wcda.lpdwTrackPos[wTrack - 1];
143 dwFrame += CDFRAMES_PERMIN * MCI_TMSF_MINUTE(dwTime);
144 dwFrame += CDFRAMES_PERSEC * MCI_TMSF_SECOND(dwTime);
145 dwFrame += MCI_TMSF_FRAME(dwTime);
146 break;
147 }
148 return dwFrame;
149 }
150
151 /**************************************************************************
152 * CDAUDIO_CalcTime [internal]
153 */
154 static DWORD CDAUDIO_CalcTime(WINE_MCICDAUDIO* wmcda, DWORD dwFrame, LPDWORD lpRet)
155 {
156 DWORD dwTime = 0;
157 UINT wTrack;
158 UINT wMinutes;
159 UINT wSeconds;
160 UINT wFrames;
161
162 TRACE("(%p, %08lX, %lu);\n", wmcda, wmcda->dwTimeFormat, dwFrame);
163
164 switch (wmcda->dwTimeFormat) {
165 case MCI_FORMAT_MILLISECONDS:
166 dwTime = (dwFrame * 1000) / CDFRAMES_PERSEC;
167 TRACE("MILLISECONDS %lu\n", dwTime);
168 *lpRet = 0;
169 break;
170 case MCI_FORMAT_MSF:
171 wMinutes = dwFrame / CDFRAMES_PERMIN;
172 wSeconds = (dwFrame - CDFRAMES_PERMIN * wMinutes) / CDFRAMES_PERSEC;
173 wFrames = dwFrame - CDFRAMES_PERMIN * wMinutes - CDFRAMES_PERSEC * wSeconds;
174 dwTime = MCI_MAKE_MSF(wMinutes, wSeconds, wFrames);
175 TRACE("MSF %02u:%02u:%02u -> dwTime=%lu\n",
176 wMinutes, wSeconds, wFrames, dwTime);
177 *lpRet = MCI_COLONIZED3_RETURN;
178 break;
179 case MCI_FORMAT_TMSF:
180 default:
181 /* unknown format ! force TMSF ! ... */
182 for (wTrack = 0; wTrack < wmcda->wcda.nTracks; wTrack++) {
183 /*dwTime += wmcda->lpdwTrackLen[wTrack - 1];
184 TRACE("Adding trk#%u curpos=%u \n", dwTime);
185 if (dwTime >= dwFrame) break; */
186 if (wmcda->wcda.lpdwTrackPos[wTrack - 1] >= dwFrame) break;
187 }
188 wMinutes = dwFrame / CDFRAMES_PERMIN;
189 wSeconds = (dwFrame - CDFRAMES_PERMIN * wMinutes) / CDFRAMES_PERSEC;
190 wFrames = dwFrame - CDFRAMES_PERMIN * wMinutes - CDFRAMES_PERSEC * wSeconds;
191 dwTime = MCI_MAKE_TMSF(wTrack, wMinutes, wSeconds, wFrames);
192 TRACE("%02u-%02u:%02u:%02u\n", wTrack, wMinutes, wSeconds, wFrames);
193 *lpRet = MCI_COLONIZED4_RETURN;
194 break;
195 }
196 return dwTime;
197 }
198
199 static DWORD CDAUDIO_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms);
200 static DWORD CDAUDIO_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
201
202 /**************************************************************************
203 * CDAUDIO_mciOpen [internal]
204 */
205 static DWORD CDAUDIO_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_OPEN_PARMSA lpOpenParms)
206 {
207 DWORD dwDeviceID;
208 WINE_MCICDAUDIO* wmcda = (WINE_MCICDAUDIO*)mciGetDriverData(wDevID);
209 MCI_SEEK_PARMS seekParms;
210
211 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpOpenParms);
212
213 if (lpOpenParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
214 if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
215
216 dwDeviceID = lpOpenParms->wDeviceID;
217
218 if (wmcda->nUseCount > 0) {
219 /* The driver is already open on this channel */
220 /* If the driver was opened shareable before and this open specifies */
221 /* shareable then increment the use count */
222 if (wmcda->fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
223 ++wmcda->nUseCount;
224 else
225 return MCIERR_MUST_USE_SHAREABLE;
226 } else {
227 wmcda->nUseCount = 1;
228 wmcda->fShareable = dwFlags & MCI_OPEN_SHAREABLE;
229 }
230 if (dwFlags & MCI_OPEN_ELEMENT) {
231 if (dwFlags & MCI_OPEN_ELEMENT_ID) {
232 WARN("MCI_OPEN_ELEMENT_ID %8lx ! Abort", (DWORD)lpOpenParms->lpstrElementName);
233 return MCIERR_NO_ELEMENT_ALLOWED;
234 }
235 WARN("MCI_OPEN_ELEMENT %s ignored\n",lpOpenParms->lpstrElementName);
236 /*return MCIERR_NO_ELEMENT_ALLOWED;
237 bon 19991106 allows cdplayer.exe to run*/
238 }
239
240 wmcda->wNotifyDeviceID = dwDeviceID;
241 if (CDAUDIO_Open(&wmcda->wcda) == -1) {
242 --wmcda->nUseCount;
243 return MCIERR_HARDWARE;
244 }
245 wmcda->mciMode = MCI_MODE_STOP;
246 wmcda->dwTimeFormat = MCI_FORMAT_TMSF;
247 if (!CDAUDIO_GetTracksInfo(&wmcda->wcda)) {
248 WARN("error reading TracksInfo !\n");
249 return MCIERR_INTERNAL;
250 }
251
252 CDAUDIO_mciSeek(wDevID, MCI_SEEK_TO_START, &seekParms);
253
254 return 0;
255 }
256
257 /**************************************************************************
258 * CDAUDIO_mciClose [internal]
259 */
260 static DWORD CDAUDIO_mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
261 {
262 WINE_MCICDAUDIO* wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
263
264 TRACE("(%04X, %08lX, %p);\n", wDevID, dwParam, lpParms);
265
266 if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
267
268 if (wmcda->nUseCount == 1) {
269 CDAUDIO_Close(&wmcda->wcda);
270 }
271 wmcda->nUseCount--;
272 return 0;
273 }
274
275 /**************************************************************************
276 * CDAUDIO_mciGetDevCaps [internal]
277 */
278 static DWORD CDAUDIO_mciGetDevCaps(UINT wDevID, DWORD dwFlags,
279 LPMCI_GETDEVCAPS_PARMS lpParms)
280 {
281 DWORD ret = 0;
282
283 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
284
285 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
286
287 if (dwFlags & MCI_GETDEVCAPS_ITEM) {
288 TRACE("MCI_GETDEVCAPS_ITEM dwItem=%08lX;\n", lpParms->dwItem);
289
290 switch (lpParms->dwItem) {
291 case MCI_GETDEVCAPS_CAN_RECORD:
292 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
293 ret = MCI_RESOURCE_RETURNED;
294 break;
295 case MCI_GETDEVCAPS_HAS_AUDIO:
296 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
297 ret = MCI_RESOURCE_RETURNED;
298 break;
299 case MCI_GETDEVCAPS_HAS_VIDEO:
300 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
301 ret = MCI_RESOURCE_RETURNED;
302 break;
303 case MCI_GETDEVCAPS_DEVICE_TYPE:
304 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_CD_AUDIO, MCI_DEVTYPE_CD_AUDIO);
305 ret = MCI_RESOURCE_RETURNED;
306 break;
307 case MCI_GETDEVCAPS_USES_FILES:
308 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
309 ret = MCI_RESOURCE_RETURNED;
310 break;
311 case MCI_GETDEVCAPS_COMPOUND_DEVICE:
312 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
313 ret = MCI_RESOURCE_RETURNED;
314 break;
315 case MCI_GETDEVCAPS_CAN_EJECT:
316 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
317 ret = MCI_RESOURCE_RETURNED;
318 break;
319 case MCI_GETDEVCAPS_CAN_PLAY:
320 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
321 ret = MCI_RESOURCE_RETURNED;
322 break;
323 case MCI_GETDEVCAPS_CAN_SAVE:
324 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
325 ret = MCI_RESOURCE_RETURNED;
326 break;
327 default:
328 ERR("Unsupported %lx devCaps item\n", lpParms->dwItem);
329 return MCIERR_UNRECOGNIZED_COMMAND;
330 }
331 } else {
332 TRACE("No GetDevCaps-Item !\n");
333 return MCIERR_UNRECOGNIZED_COMMAND;
334 }
335 TRACE("lpParms->dwReturn=%08lX;\n", lpParms->dwReturn);
336 return ret;
337 }
338
339 /**************************************************************************
340 * CDAUDIO_mciInfo [internal]
341 */
342 static DWORD CDAUDIO_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMSA lpParms)
343 {
344 LPSTR str = 0;
345 WINE_MCICDAUDIO* wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
346 DWORD ret = 0;
347
348 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
349
350 if (lpParms == NULL || lpParms->lpstrReturn == NULL)
351 return MCIERR_NULL_PARAMETER_BLOCK;
352 if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
353
354 TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
355
356 switch(dwFlags) {
357 case MCI_INFO_PRODUCT:
358 str = "Wine's audio CD";
359 break;
360 default:
361 WARN("Don't know this info command (%lu)\n", dwFlags);
362 return MCIERR_UNRECOGNIZED_COMMAND;
363 }
364 if (str) {
365 if (lpParms->dwRetSize <= strlen(str)) {
366 lstrcpynA(lpParms->lpstrReturn, str, lpParms->dwRetSize - 1);
367 ret = MCIERR_PARAM_OVERFLOW;
368 } else {
369 strcpy(lpParms->lpstrReturn, str);
370 }
371 } else {
372 *lpParms->lpstrReturn = 0;
373 }
374 return ret;
375 }
376
377 /**************************************************************************
378 * CDAUDIO_mciStatus [internal]
379 */
380 static DWORD CDAUDIO_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
381 {
382 WINE_MCICDAUDIO* wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
383 DWORD ret = 0;
384
385 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
386
387 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
388 if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
389
390 if (dwFlags & MCI_NOTIFY) {
391 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
392 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
393 wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
394 }
395 if (dwFlags & MCI_STATUS_ITEM) {
396 switch (lpParms->dwItem) {
397 case MCI_STATUS_CURRENT_TRACK:
398 if (!CDAUDIO_GetCDStatus(&wmcda->wcda)) {
399 return CDAUDIO_mciGetError(wmcda);
400 }
401 lpParms->dwReturn = wmcda->wcda.nCurTrack;
402 TRACE("CURRENT_TRACK=%lu!\n", lpParms->dwReturn);
403 break;
404 case MCI_STATUS_LENGTH:
405 if (wmcda->wcda.nTracks == 0) {
406 if (!CDAUDIO_GetTracksInfo(&wmcda->wcda)) {
407 WARN("error reading TracksInfo !\n");
408 return CDAUDIO_mciGetError(wmcda);
409 }
410 }
411 if (dwFlags & MCI_TRACK) {
412 TRACE("MCI_TRACK #%lu LENGTH=??? !\n", lpParms->dwTrack);
413 if (lpParms->dwTrack > wmcda->wcda.nTracks || lpParms->dwTrack == 0)
414 return MCIERR_OUTOFRANGE;
415 lpParms->dwReturn = wmcda->wcda.lpdwTrackLen[lpParms->dwTrack - 1];
416 } else {
417 lpParms->dwReturn = wmcda->wcda.dwTotalLen;
418 }
419 lpParms->dwReturn = CDAUDIO_CalcTime(wmcda, lpParms->dwReturn, &ret);
420 TRACE("LENGTH=%lu !\n", lpParms->dwReturn);
421 break;
422 case MCI_STATUS_MODE:
423 if (!CDAUDIO_GetCDStatus(&wmcda->wcda))
424 return CDAUDIO_mciGetError(wmcda);
425 lpParms->dwReturn = CDAUDIO_mciMode(wmcda->wcda.cdaMode);
426 if (!lpParms->dwReturn) lpParms->dwReturn = wmcda->mciMode;
427 TRACE("MCI_STATUS_MODE=%08lX !\n", lpParms->dwReturn);
428 lpParms->dwReturn = MAKEMCIRESOURCE(lpParms->dwReturn, lpParms->dwReturn);
429 ret = MCI_RESOURCE_RETURNED;
430 break;
431 case MCI_STATUS_MEDIA_PRESENT:
432 if (!CDAUDIO_GetCDStatus(&wmcda->wcda))
433 return CDAUDIO_mciGetError(wmcda);
434 lpParms->dwReturn = (wmcda->wcda.nTracks == 0) ?
435 MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
436 TRACE("MCI_STATUS_MEDIA_PRESENT =%c!\n", LOWORD(lpParms->dwReturn) ? 'Y' : 'N');
437 ret = MCI_RESOURCE_RETURNED;
438 break;
439 case MCI_STATUS_NUMBER_OF_TRACKS:
440 lpParms->dwReturn = CDAUDIO_GetNumberOfTracks(&wmcda->wcda);
441 TRACE("MCI_STATUS_NUMBER_OF_TRACKS = %lu !\n", lpParms->dwReturn);
442 if (lpParms->dwReturn == (WORD)-1)
443 return CDAUDIO_mciGetError(wmcda);
444 break;
445 case MCI_STATUS_POSITION:
446 if (!CDAUDIO_GetCDStatus(&wmcda->wcda))
447 return CDAUDIO_mciGetError(wmcda);
448 lpParms->dwReturn = wmcda->wcda.dwCurFrame;
449 if (dwFlags & MCI_STATUS_START) {
450 lpParms->dwReturn = wmcda->wcda.dwFirstOffset;
451 TRACE("get MCI_STATUS_START !\n");
452 }
453 if (dwFlags & MCI_TRACK) {
454 if (lpParms->dwTrack > wmcda->wcda.nTracks || lpParms->dwTrack == 0)
455 return MCIERR_OUTOFRANGE;
456 lpParms->dwReturn = wmcda->wcda.lpdwTrackPos[lpParms->dwTrack - 1];
457 TRACE("get MCI_TRACK #%lu !\n", lpParms->dwTrack);
458 }
459 lpParms->dwReturn = CDAUDIO_CalcTime(wmcda, lpParms->dwReturn, &ret);
460 TRACE("MCI_STATUS_POSITION=%08lX !\n", lpParms->dwReturn);
461 break;
462 case MCI_STATUS_READY:
463 TRACE("MCI_STATUS_READY !\n");
464 lpParms->dwReturn = (wmcda->wcda.cdaMode == WINE_CDA_DONTKNOW ||
465 wmcda->wcda.cdaMode == WINE_CDA_NOTREADY) ?
466 MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
467 TRACE("MCI_STATUS_READY=%u!\n", LOWORD(lpParms->dwReturn));
468 ret = MCI_RESOURCE_RETURNED;
469 break;
470 case MCI_STATUS_TIME_FORMAT:
471 lpParms->dwReturn = MAKEMCIRESOURCE(wmcda->dwTimeFormat, wmcda->dwTimeFormat);
472 TRACE("MCI_STATUS_TIME_FORMAT=%08x!\n", LOWORD(lpParms->dwReturn));
473 ret = MCI_RESOURCE_RETURNED;
474 break;
475 case MCI_CDA_STATUS_TYPE_TRACK:
476 if (!(dwFlags & MCI_TRACK))
477 ret = MCIERR_MISSING_PARAMETER;
478 else if (lpParms->dwTrack > wmcda->wcda.nTracks || lpParms->dwTrack == 0)
479 ret = MCIERR_OUTOFRANGE;
480 else
481 lpParms->dwReturn = (wmcda->wcda.lpbTrackFlags[lpParms->dwTrack - 1] &
482 CDROM_DATA_TRACK) ? MCI_CDA_TRACK_OTHER : MCI_CDA_TRACK_AUDIO;
483 TRACE("MCI_CDA_STATUS_TYPE_TRACK[%ld]=%08lx\n", lpParms->dwTrack, lpParms->dwReturn);
484 break;
485 default:
486 FIXME("unknown command %08lX !\n", lpParms->dwItem);
487 return MCIERR_UNRECOGNIZED_COMMAND;
488 }
489 } else {
490 WARN("not MCI_STATUS_ITEM !\n");
491 }
492 return ret;
493 }
494
495 /**************************************************************************
496 * CDAUDIO_mciPlay [internal]
497 */
498 static DWORD CDAUDIO_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
499 {
500 int start, end;
501 WINE_MCICDAUDIO* wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
502 DWORD ret = 0;
503
504 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
505
506 if (lpParms == NULL) {
507 ret = MCIERR_NULL_PARAMETER_BLOCK;
508 } else if (wmcda == NULL) {
509 ret = MCIERR_INVALID_DEVICE_ID;
510 } else {
511 if (wmcda->wcda.nTracks == 0) {
512 if (!CDAUDIO_GetTracksInfo(&wmcda->wcda)) {
513 WARN("error reading TracksInfo !\n");
514 return MCIERR_DRIVER_INTERNAL;
515 }
516 }
517 wmcda->wcda.nCurTrack = 1;
518 if (dwFlags & MCI_FROM) {
519 start = CDAUDIO_CalcFrame(wmcda, lpParms->dwFrom);
520 TRACE("MCI_FROM=%08lX -> %u \n", lpParms->dwFrom, start);
521 } else {
522 if (!CDAUDIO_GetCDStatus(&wmcda->wcda)) return MCIERR_DRIVER_INTERNAL;
523 start = wmcda->wcda.dwCurFrame;
524 }
525 if (dwFlags & MCI_TO) {
526 end = CDAUDIO_CalcFrame(wmcda, lpParms->dwTo);
527 TRACE("MCI_TO=%08lX -> %u \n", lpParms->dwTo, end);
528 } else {
529 end = wmcda->wcda.dwFirstOffset + wmcda->wcda.dwTotalLen;
530 }
531
532 if (CDAUDIO_Play(&wmcda->wcda, start, end) == -1)
533 return MCIERR_HARDWARE;
534 wmcda->mciMode = MCI_MODE_PLAY;
535 if (dwFlags & MCI_NOTIFY) {
536 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
537 /*
538 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
539 wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
540 */
541 }
542 }
543 return ret;
544 }
545
546 /**************************************************************************
547 * CDAUDIO_mciStop [internal]
548 */
549 static DWORD CDAUDIO_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
550 {
551 WINE_MCICDAUDIO* wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
552
553 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
554
555 if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
556
557 if (CDAUDIO_Stop(&wmcda->wcda) == -1)
558 return MCIERR_HARDWARE;
559
560 wmcda->mciMode = MCI_MODE_STOP;
561 if (lpParms && (dwFlags & MCI_NOTIFY)) {
562 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
563 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
564 wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
565 }
566 return 0;
567 }
568
569 /**************************************************************************
570 * CDAUDIO_mciPause [internal]
571 */
572 static DWORD CDAUDIO_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
573 {
574 WINE_MCICDAUDIO* wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
575
576 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
577
578 if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
579
580 if (CDAUDIO_Pause(&wmcda->wcda, 1) == -1)
581 return MCIERR_HARDWARE;
582 wmcda->mciMode = MCI_MODE_PAUSE;
583 if (lpParms && (dwFlags & MCI_NOTIFY)) {
584 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
585 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
586 wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
587 }
588 return 0;
589 }
590
591 /**************************************************************************
592 * CDAUDIO_mciResume [internal]
593 */
594 static DWORD CDAUDIO_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
595 {
596 WINE_MCICDAUDIO* wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
597
598 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
599
600 if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
601
602 if (CDAUDIO_Pause(&wmcda->wcda, 0) == -1)
603 return MCIERR_HARDWARE;
604 wmcda->mciMode = MCI_MODE_STOP;
605 if (lpParms && (dwFlags & MCI_NOTIFY)) {
606 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
607 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
608 wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
609 }
610 return 0;
611 }
612
613 /**************************************************************************
614 * CDAUDIO_mciSeek [internal]
615 */
616 static DWORD CDAUDIO_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
617 {
618 DWORD at;
619 WINE_MCICDAUDIO* wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
620
621 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
622
623 if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
624 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
625
626 wmcda->mciMode = MCI_MODE_SEEK;
627 switch (dwFlags & ~(MCI_NOTIFY|MCI_WAIT)) {
628 case MCI_SEEK_TO_START:
629 TRACE("Seeking to start\n");
630 at = 0;
631 break;
632 case MCI_SEEK_TO_END:
633 TRACE("Seeking to end\n");
634 at = wmcda->wcda.dwTotalLen;
635 break;
636 case MCI_TO:
637 TRACE("Seeking to %lu\n", lpParms->dwTo);
638 at = lpParms->dwTo;
639 break;
640 default:
641 TRACE("Seeking to ??=%lu\n", dwFlags);
642 return MCIERR_UNSUPPORTED_FUNCTION;
643 }
644 if (CDAUDIO_Seek(&wmcda->wcda, at) == -1) {
645 return MCIERR_HARDWARE;
646 }
647 if (dwFlags & MCI_NOTIFY) {
648 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
649 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
650 wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
651 }
652 return 0;
653 }
654
655 /**************************************************************************
656 * CDAUDIO_mciSetDoor [internal]
657 */
658 static DWORD CDAUDIO_mciSetDoor(UINT wDevID, int open)
659 {
660 WINE_MCICDAUDIO* wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
661
662 TRACE("(%04x, %s) !\n", wDevID, (open) ? "OPEN" : "CLOSE");
663
664 if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
665
666 if (CDAUDIO_SetDoor(&wmcda->wcda, open) == -1)
667 return MCIERR_HARDWARE;
668 wmcda->mciMode = (open) ? MCI_MODE_OPEN : MCI_MODE_STOP;
669 return 0;
670 }
671
672 /**************************************************************************
673 * CDAUDIO_mciSet [internal]
674 */
675 static DWORD CDAUDIO_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
676 {
677 WINE_MCICDAUDIO* wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
678
679 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
680
681 if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
682 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;;
683 /*
684 TRACE("dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
685 TRACE("dwAudio=%08lX\n", lpParms->dwAudio);
686 */
687 if (dwFlags & MCI_SET_TIME_FORMAT) {
688 switch (lpParms->dwTimeFormat) {
689 case MCI_FORMAT_MILLISECONDS:
690 TRACE("MCI_FORMAT_MILLISECONDS !\n");
691 break;
692 case MCI_FORMAT_MSF:
693 TRACE("MCI_FORMAT_MSF !\n");
694 break;
695 case MCI_FORMAT_TMSF:
696 TRACE("MCI_FORMAT_TMSF !\n");
697 break;
698 default:
699 WARN("bad time format !\n");
700 return MCIERR_BAD_TIME_FORMAT;
701 }
702 wmcda->dwTimeFormat = lpParms->dwTimeFormat;
703 }
704 if (dwFlags & MCI_SET_DOOR_OPEN) {
705 CDAUDIO_mciSetDoor(wDevID, TRUE);
706 }
707 if (dwFlags & MCI_SET_DOOR_CLOSED) {
708 CDAUDIO_mciSetDoor(wDevID, FALSE);
709 }
710 if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION;
711 if (dwFlags & MCI_SET_ON) return MCIERR_UNSUPPORTED_FUNCTION;
712 if (dwFlags & MCI_SET_OFF) return MCIERR_UNSUPPORTED_FUNCTION;
713 if (dwFlags & MCI_NOTIFY) {
714 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n",
715 lpParms->dwCallback);
716 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
717 wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
718 }
719 return 0;
720 }
721
722 /**************************************************************************
723 * MCICDAUDIO_DriverProc [sample driver]
724 */
725 LONG CALLBACK MCICDAUDIO_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
726 DWORD dwParam1, DWORD dwParam2)
727 {
728 switch(wMsg) {
729 case DRV_LOAD: return 1;
730 case DRV_FREE: return 1;
731 case DRV_OPEN: return CDAUDIO_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
732 case DRV_CLOSE: return CDAUDIO_drvClose(dwDevID);
733 case DRV_ENABLE: return 1;
734 case DRV_DISABLE: return 1;
735 case DRV_QUERYCONFIGURE: return 1;
736 case DRV_CONFIGURE: MessageBoxA(0, "Sample Multimedia Driver !", "Wine Driver", MB_OK); return 1;
737 case DRV_INSTALL: return DRVCNF_RESTART;
738 case DRV_REMOVE: return DRVCNF_RESTART;
739
740 case MCI_OPEN_DRIVER: return CDAUDIO_mciOpen(dwDevID, dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
741 case MCI_CLOSE_DRIVER: return CDAUDIO_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
742 case MCI_GETDEVCAPS: return CDAUDIO_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
743 case MCI_INFO: return CDAUDIO_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMSA)dwParam2);
744 case MCI_STATUS: return CDAUDIO_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
745 case MCI_SET: return CDAUDIO_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)dwParam2);
746 case MCI_PLAY: return CDAUDIO_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
747 case MCI_STOP: return CDAUDIO_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
748 case MCI_PAUSE: return CDAUDIO_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
749 case MCI_RESUME: return CDAUDIO_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
750 case MCI_SEEK: return CDAUDIO_mciSeek(dwDevID, dwParam1, (LPMCI_SEEK_PARMS)dwParam2);
751 /* FIXME: I wonder if those two next items are really called ? */
752 case MCI_SET_DOOR_OPEN: return CDAUDIO_mciSetDoor(dwDevID, TRUE);
753 case MCI_SET_DOOR_CLOSED: return CDAUDIO_mciSetDoor(dwDevID, FALSE);
754 /* commands that should be supported */
755 case MCI_LOAD:
756 case MCI_SAVE:
757 case MCI_FREEZE:
758 case MCI_PUT:
759 case MCI_REALIZE:
760 case MCI_UNFREEZE:
761 case MCI_UPDATE:
762 case MCI_WHERE:
763 case MCI_STEP:
764 case MCI_SPIN:
765 case MCI_ESCAPE:
766 case MCI_COPY:
767 case MCI_CUT:
768 case MCI_DELETE:
769 case MCI_PASTE:
770 FIXME("Unsupported yet command [%lu]\n", wMsg);
771 break;
772 /* commands that should report an error */
773 case MCI_WINDOW:
774 FIXME("Unsupported command [%lu]\n", wMsg);
775 break;
776 case MCI_OPEN:
777 case MCI_CLOSE:
778 ERR("Shouldn't receive a MCI_OPEN or CLOSE message\n");
779 break;
780 default:
781 TRACE("Sending msg [%lu] to default driver proc\n", wMsg);
782 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
783 }
784 return MCIERR_UNRECOGNIZED_COMMAND;
785 }
786
787 /*-----------------------------------------------------------------------*/
DirectPlay implementation for GSoC