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