1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
3 * Sample MCI CDAUDIO Wine Driver for Linux
5 * Copyright 1994 Martin Ayotte
6 * Copyright 1998-99 Eric Pouech
12 #include "multimedia.h"
16 DEFAULT_DEBUG_CHANNEL(cdaudio
)
19 int nUseCount
; /* Incremented for each shared open */
20 BOOL16 fShareable
; /* TRUE if first open was shareable */
21 WORD wNotifyDeviceID
; /* MCI device ID with a pending notification */
22 HANDLE16 hCallback
; /* Callback handle for pending notification */
23 MCI_OPEN_PARMS16 openParms
;
29 #define MAX_CDAUDIODRV (1)
30 static WINE_MCICDAUDIO CDADev
[MAX_CDAUDIODRV
];
32 /*-----------------------------------------------------------------------*/
34 /**************************************************************************
35 * CDAUDIO_mciGetOpenDrv [internal]
37 static WINE_MCICDAUDIO
* CDAUDIO_mciGetOpenDrv(UINT16 wDevID
)
39 if (wDevID
>= MAX_CDAUDIODRV
|| CDADev
[wDevID
].nUseCount
== 0 ||
40 CDADev
[wDevID
].wcda
.unixdev
<= 0) {
41 WARN(cdaudio
, "Invalid wDevID=%u\n", wDevID
);
44 return &CDADev
[wDevID
];
47 /**************************************************************************
48 * CDAUDIO_mciMode [internal]
50 static int CDAUDIO_mciMode(int wcdaMode
)
53 case WINE_CDA_DONTKNOW
: return MCI_MODE_STOP
;
54 case WINE_CDA_NOTREADY
: return MCI_MODE_STOP
;
55 case WINE_CDA_OPEN
: return MCI_MODE_OPEN
;
56 case WINE_CDA_PLAY
: return MCI_MODE_PLAY
;
57 case WINE_CDA_STOP
: return MCI_MODE_STOP
;
58 case WINE_CDA_PAUSE
: return MCI_MODE_PAUSE
;
60 FIXME(cdaudio
, "Unknown mode %04x\n", wcdaMode
);
65 /**************************************************************************
66 * CDAUDIO_mciGetError [internal]
68 static int CDAUDIO_mciGetError(WINE_MCICDAUDIO
* wmcda
)
70 switch (wmcda
->wcda
.cdaMode
) {
71 case WINE_CDA_DONTKNOW
:
72 case WINE_CDA_NOTREADY
: return MCIERR_DEVICE_NOT_READY
;
73 case WINE_CDA_OPEN
: return MCIERR_DEVICE_OPEN
;
76 case WINE_CDA_PAUSE
: break;
78 FIXME(cdaudio
, "Unknown mode %04x\n", wmcda
->wcda
.cdaMode
);
80 return MCIERR_DRIVER_INTERNAL
;
83 /**************************************************************************
84 * CDAUDIO_CalcFrame [internal]
86 static DWORD
CDAUDIO_CalcFrame(WINE_MCICDAUDIO
* wmcda
, DWORD dwTime
)
91 TRACE(cdaudio
,"(%p, %08lX, %lu);\n", wmcda
, wmcda
->dwTimeFormat
, dwTime
);
93 switch (wmcda
->dwTimeFormat
) {
94 case MCI_FORMAT_MILLISECONDS
:
95 dwFrame
= (dwTime
* CDFRAMES_PERSEC
) / 1000;
96 TRACE(cdaudio
, "MILLISECONDS %lu\n", dwFrame
);
99 TRACE(cdaudio
, "MSF %02u:%02u:%02u\n",
100 MCI_MSF_MINUTE(dwTime
), MCI_MSF_SECOND(dwTime
), MCI_MSF_FRAME(dwTime
));
101 dwFrame
+= CDFRAMES_PERMIN
* MCI_MSF_MINUTE(dwTime
);
102 dwFrame
+= CDFRAMES_PERSEC
* MCI_MSF_SECOND(dwTime
);
103 dwFrame
+= MCI_MSF_FRAME(dwTime
);
105 case MCI_FORMAT_TMSF
:
107 /* unknown format ! force TMSF ! ... */
108 wTrack
= MCI_TMSF_TRACK(dwTime
);
109 TRACE(cdaudio
, "MSF %02u-%02u:%02u:%02u\n",
110 MCI_TMSF_TRACK(dwTime
), MCI_TMSF_MINUTE(dwTime
),
111 MCI_TMSF_SECOND(dwTime
), MCI_TMSF_FRAME(dwTime
));
112 TRACE(cdaudio
, "TMSF trackpos[%u]=%lu\n",
113 wTrack
, wmcda
->wcda
.lpdwTrackPos
[wTrack
- 1]);
114 dwFrame
= wmcda
->wcda
.lpdwTrackPos
[wTrack
- 1];
115 dwFrame
+= CDFRAMES_PERMIN
* MCI_TMSF_MINUTE(dwTime
);
116 dwFrame
+= CDFRAMES_PERSEC
* MCI_TMSF_SECOND(dwTime
);
117 dwFrame
+= MCI_TMSF_FRAME(dwTime
);
123 /**************************************************************************
124 * CDAUDIO_CalcTime [internal]
126 static DWORD
CDAUDIO_CalcTime(WINE_MCICDAUDIO
* wmcda
, DWORD dwFrame
)
134 TRACE(cdaudio
,"(%p, %08lX, %lu);\n", wmcda
, wmcda
->dwTimeFormat
, dwFrame
);
136 switch (wmcda
->dwTimeFormat
) {
137 case MCI_FORMAT_MILLISECONDS
:
138 dwTime
= (dwFrame
* 1000) / CDFRAMES_PERSEC
;
139 TRACE(cdaudio
, "MILLISECONDS %lu\n", dwTime
);
142 wMinutes
= dwFrame
/ CDFRAMES_PERMIN
;
143 wSeconds
= (dwFrame
- CDFRAMES_PERMIN
* wMinutes
) / CDFRAMES_PERSEC
;
144 wFrames
= dwFrame
- CDFRAMES_PERMIN
* wMinutes
- CDFRAMES_PERSEC
* wSeconds
;
145 dwTime
= MCI_MAKE_MSF(wMinutes
, wSeconds
, wFrames
);
146 TRACE(cdaudio
,"MSF %02u:%02u:%02u -> dwTime=%lu\n",wMinutes
, wSeconds
, wFrames
, dwTime
);
148 case MCI_FORMAT_TMSF
:
150 /* unknown format ! force TMSF ! ... */
151 for (wTrack
= 0; wTrack
< wmcda
->wcda
.nTracks
; wTrack
++) {
152 /* dwTime += wmcda->lpdwTrackLen[wTrack - 1];
153 TRACE(cdaudio, "Adding trk#%u curpos=%u \n", dwTime);
154 if (dwTime >= dwFrame) break; */
155 if (wmcda
->wcda
.lpdwTrackPos
[wTrack
- 1] >= dwFrame
) break;
157 wMinutes
= dwFrame
/ CDFRAMES_PERMIN
;
158 wSeconds
= (dwFrame
- CDFRAMES_PERMIN
* wMinutes
) / CDFRAMES_PERSEC
;
159 wFrames
= dwFrame
- CDFRAMES_PERMIN
* wMinutes
- CDFRAMES_PERSEC
* wSeconds
;
160 dwTime
= MCI_MAKE_TMSF(wTrack
, wMinutes
, wSeconds
, wFrames
);
161 TRACE(cdaudio
, "%02u-%02u:%02u:%02u\n", wTrack
, wMinutes
, wSeconds
, wFrames
);
167 static DWORD
CDAUDIO_mciSeek(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SEEK_PARMS lpParms
);
168 static DWORD
CDAUDIO_mciStop(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
);
170 /**************************************************************************
171 * CDAUDIO_mciOpen [internal]
173 static DWORD
CDAUDIO_mciOpen(UINT16 wDevID
, DWORD dwFlags
, LPMCI_OPEN_PARMSA lpOpenParms
)
176 WINE_MCICDAUDIO
* wmcda
;
177 MCI_SEEK_PARMS seekParms
;
179 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpOpenParms
);
181 if (lpOpenParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
182 if (wDevID
> MAX_CDAUDIODRV
) return MCIERR_INVALID_DEVICE_ID
;
184 dwDeviceID
= lpOpenParms
->wDeviceID
;
186 wmcda
= &CDADev
[wDevID
];
188 if (wmcda
->nUseCount
> 0) {
189 /* The driver is already open on this channel */
190 /* If the driver was opened shareable before and this open specifies */
191 /* shareable then increment the use count */
192 if (wmcda
->fShareable
&& (dwFlags
& MCI_OPEN_SHAREABLE
))
195 return MCIERR_MUST_USE_SHAREABLE
;
197 wmcda
->nUseCount
= 1;
198 wmcda
->fShareable
= dwFlags
& MCI_OPEN_SHAREABLE
;
200 if (dwFlags
& MCI_OPEN_ELEMENT
) {
201 TRACE(cdaudio
,"MCI_OPEN_ELEMENT !\n");
202 /* return MCIERR_NO_ELEMENT_ALLOWED; */
205 wmcda
->openParms
.dwCallback
= lpOpenParms
->dwCallback
;
206 wmcda
->openParms
.wDeviceID
= (WORD
)lpOpenParms
->wDeviceID
;
207 wmcda
->openParms
.wReserved0
= 0; /*????*/
208 wmcda
->openParms
.lpstrDeviceType
= lpOpenParms
->lpstrDeviceType
;
209 wmcda
->openParms
.lpstrElementName
= lpOpenParms
->lpstrElementName
;
210 wmcda
->openParms
.lpstrAlias
= lpOpenParms
->lpstrAlias
;
212 wmcda
->wNotifyDeviceID
= dwDeviceID
;
213 if (CDAUDIO_Open(&wmcda
->wcda
) == -1) {
215 return MCIERR_HARDWARE
;
217 wmcda
->mciMode
= MCI_MODE_STOP
;
218 wmcda
->dwTimeFormat
= MCI_FORMAT_TMSF
;
219 if (!CDAUDIO_GetTracksInfo(&wmcda
->wcda
)) {
220 WARN(cdaudio
,"error reading TracksInfo !\n");
221 /* return MCIERR_INTERNAL; */
224 CDAUDIO_mciSeek(wDevID
, MCI_SEEK_TO_START
, &seekParms
);
229 /**************************************************************************
230 * CDAUDIO_mciClose [internal]
232 static DWORD
CDAUDIO_mciClose(UINT16 wDevID
, DWORD dwParam
, LPMCI_GENERIC_PARMS lpParms
)
234 WINE_MCICDAUDIO
* wmcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
236 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwParam
, lpParms
);
238 if (wmcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
240 if (wmcda
->nUseCount
== 1) {
241 /* FIXME: I don't think we have to stop CD on exit
242 * CDAUDIO_mciStop(wDevID, 0, NULL);
244 CDAUDIO_Close(&wmcda
->wcda
);
250 /**************************************************************************
251 * CDAUDIO_mciGetDevCaps [internal]
253 static DWORD
CDAUDIO_mciGetDevCaps(UINT16 wDevID
, DWORD dwFlags
,
254 LPMCI_GETDEVCAPS_PARMS lpParms
)
256 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
258 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
260 if (dwFlags
& MCI_GETDEVCAPS_ITEM
) {
261 TRACE(cdaudio
, "MCI_GETDEVCAPS_ITEM dwItem=%08lX;\n", lpParms
->dwItem
);
263 switch(lpParms
->dwItem
) {
264 case MCI_GETDEVCAPS_CAN_RECORD
:
265 lpParms
->dwReturn
= FALSE
;
267 case MCI_GETDEVCAPS_HAS_AUDIO
:
268 lpParms
->dwReturn
= TRUE
;
270 case MCI_GETDEVCAPS_HAS_VIDEO
:
271 lpParms
->dwReturn
= FALSE
;
273 case MCI_GETDEVCAPS_DEVICE_TYPE
:
274 lpParms
->dwReturn
= MCI_DEVTYPE_CD_AUDIO
;
276 case MCI_GETDEVCAPS_USES_FILES
:
277 lpParms
->dwReturn
= FALSE
;
279 case MCI_GETDEVCAPS_COMPOUND_DEVICE
:
280 lpParms
->dwReturn
= FALSE
;
282 case MCI_GETDEVCAPS_CAN_EJECT
:
283 lpParms
->dwReturn
= TRUE
;
285 case MCI_GETDEVCAPS_CAN_PLAY
:
286 lpParms
->dwReturn
= TRUE
;
288 case MCI_GETDEVCAPS_CAN_SAVE
:
289 lpParms
->dwReturn
= FALSE
;
292 return MCIERR_UNRECOGNIZED_COMMAND
;
295 TRACE(cdaudio
, "lpParms->dwReturn=%08lX;\n", lpParms
->dwReturn
);
299 /**************************************************************************
300 * CDAUDIO_mciInfo [internal]
302 static DWORD
CDAUDIO_mciInfo(UINT16 wDevID
, DWORD dwFlags
, LPMCI_INFO_PARMS16 lpParms
)
306 WINE_MCICDAUDIO
* wmcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
308 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
310 if (lpParms
== NULL
|| lpParms
->lpstrReturn
== NULL
) {
311 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
312 } else if (wmcda
== NULL
) {
313 ret
= MCIERR_INVALID_DEVICE_ID
;
315 TRACE(cdaudio
, "buf=%p, len=%lu\n", lpParms
->lpstrReturn
, lpParms
->dwRetSize
);
318 case MCI_INFO_PRODUCT
:
319 str
= "Wine's audio CD";
322 WARN(cdaudio
, "Don't know this info command (%lu)\n", dwFlags
);
323 ret
= MCIERR_UNRECOGNIZED_COMMAND
;
327 ret
= MCI_WriteString(lpParms
->lpstrReturn
, lpParms
->dwRetSize
, str
);
329 lpParms
->lpstrReturn
[0] = 0;
335 /**************************************************************************
336 * CDAUDIO_mciStatus [internal]
338 static DWORD
CDAUDIO_mciStatus(UINT16 wDevID
, DWORD dwFlags
, LPMCI_STATUS_PARMS lpParms
)
340 WINE_MCICDAUDIO
* wmcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
343 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
345 if (lpParms
== NULL
) {
346 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
347 } else if (wmcda
== NULL
) {
348 ret
= MCIERR_INVALID_DEVICE_ID
;
350 if (dwFlags
& MCI_NOTIFY
) {
351 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
352 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
353 wmcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
355 if (dwFlags
& MCI_STATUS_ITEM
) {
356 switch (lpParms
->dwItem
) {
357 case MCI_STATUS_CURRENT_TRACK
:
358 if (!CDAUDIO_GetCDStatus(&wmcda
->wcda
)) {
359 return CDAUDIO_mciGetError(wmcda
);
361 lpParms
->dwReturn
= wmcda
->wcda
.nCurTrack
;
362 TRACE(cdaudio
,"CURRENT_TRACK=%lu!\n", lpParms
->dwReturn
);
364 case MCI_STATUS_LENGTH
:
365 if (wmcda
->wcda
.nTracks
== 0) {
366 if (!CDAUDIO_GetTracksInfo(&wmcda
->wcda
)) {
367 WARN(cdaudio
, "error reading TracksInfo !\n");
368 return CDAUDIO_mciGetError(wmcda
);
371 if (dwFlags
& MCI_TRACK
) {
372 TRACE(cdaudio
,"MCI_TRACK #%lu LENGTH=??? !\n", lpParms
->dwTrack
);
373 if (lpParms
->dwTrack
> wmcda
->wcda
.nTracks
|| lpParms
->dwTrack
== 0)
374 return MCIERR_OUTOFRANGE
;
375 lpParms
->dwReturn
= wmcda
->wcda
.lpdwTrackLen
[lpParms
->dwTrack
- 1];
377 lpParms
->dwReturn
= wmcda
->wcda
.dwTotalLen
;
379 lpParms
->dwReturn
= CDAUDIO_CalcTime(wmcda
, lpParms
->dwReturn
);
380 TRACE(cdaudio
,"LENGTH=%lu !\n", lpParms
->dwReturn
);
382 case MCI_STATUS_MODE
:
383 if (!CDAUDIO_GetCDStatus(&wmcda
->wcda
))
384 return CDAUDIO_mciGetError(wmcda
);
385 lpParms
->dwReturn
= CDAUDIO_mciMode(wmcda
->wcda
.cdaMode
);
386 if (!lpParms
->dwReturn
) lpParms
->dwReturn
= wmcda
->mciMode
;
387 TRACE(cdaudio
,"MCI_STATUS_MODE=%08lX !\n", lpParms
->dwReturn
);
389 case MCI_STATUS_MEDIA_PRESENT
:
390 if (!CDAUDIO_GetCDStatus(&wmcda
->wcda
))
391 return CDAUDIO_mciGetError(wmcda
);
392 lpParms
->dwReturn
= (wmcda
->wcda
.nTracks
> 0) ? TRUE
: FALSE
;
393 TRACE(cdaudio
,"MCI_STATUS_MEDIA_PRESENT =%s!\n", lpParms
->dwReturn
? "Y" : "N");
395 case MCI_STATUS_NUMBER_OF_TRACKS
:
396 lpParms
->dwReturn
= CDAUDIO_GetNumberOfTracks(&wmcda
->wcda
);
397 TRACE(cdaudio
,"MCI_STATUS_NUMBER_OF_TRACKS = %lu !\n", lpParms
->dwReturn
);
398 if (lpParms
->dwReturn
== (WORD
)-1)
399 return CDAUDIO_mciGetError(wmcda
);
401 case MCI_STATUS_POSITION
:
402 if (!CDAUDIO_GetCDStatus(&wmcda
->wcda
))
403 return CDAUDIO_mciGetError(wmcda
);
404 lpParms
->dwReturn
= wmcda
->wcda
.dwCurFrame
;
405 if (dwFlags
& MCI_STATUS_START
) {
406 lpParms
->dwReturn
= wmcda
->wcda
.dwFirstOffset
;
407 TRACE(cdaudio
,"get MCI_STATUS_START !\n");
409 if (dwFlags
& MCI_TRACK
) {
410 if (lpParms
->dwTrack
> wmcda
->wcda
.nTracks
|| lpParms
->dwTrack
== 0)
411 return MCIERR_OUTOFRANGE
;
412 lpParms
->dwReturn
= wmcda
->wcda
.lpdwTrackPos
[lpParms
->dwTrack
- 1];
413 TRACE(cdaudio
,"get MCI_TRACK #%lu !\n", lpParms
->dwTrack
);
415 lpParms
->dwReturn
= CDAUDIO_CalcTime(wmcda
, lpParms
->dwReturn
);
416 TRACE(cdaudio
,"MCI_STATUS_POSITION=%08lX !\n", lpParms
->dwReturn
);
418 case MCI_STATUS_READY
:
419 TRACE(cdaudio
,"MCI_STATUS_READY !\n");
420 lpParms
->dwReturn
= (wmcda
->wcda
.cdaMode
!= WINE_CDA_DONTKNOW
&& wmcda
->wcda
.cdaMode
!= WINE_CDA_NOTREADY
);
421 TRACE(cdaudio
,"MCI_STATUS_READY=%ld!\n", lpParms
->dwReturn
);
423 case MCI_STATUS_TIME_FORMAT
:
424 lpParms
->dwReturn
= wmcda
->dwTimeFormat
;
425 TRACE(cdaudio
,"MCI_STATUS_TIME_FORMAT =%08lx!\n", lpParms
->dwReturn
);
427 case MCI_CDA_STATUS_TYPE_TRACK
:
428 if (!(dwFlags
& MCI_TRACK
))
429 return MCIERR_MISSING_PARAMETER
;
430 if (lpParms
->dwTrack
> wmcda
->wcda
.nTracks
|| lpParms
->dwTrack
== 0)
431 return MCIERR_OUTOFRANGE
;
432 lpParms
->dwReturn
= (wmcda
->wcda
.lpbTrackFlags
[lpParms
->dwTrack
- 1] &
433 CDROM_DATA_TRACK
) ? MCI_CDA_TRACK_OTHER
: MCI_CDA_TRACK_AUDIO
;
434 TRACE(cdaudio
, "MCI_CDA_STATUS_TYPE_TRACK[%ld]=%08lx\n", lpParms
->dwTrack
, lpParms
->dwReturn
);
437 WARN(cdaudio
, "unknown command %08lX !\n", lpParms
->dwItem
);
438 return MCIERR_UNRECOGNIZED_COMMAND
;
442 WARN(cdaudio
, "not MCI_STATUS_ITEM !\n");
446 /**************************************************************************
447 * CDAUDIO_mciPlay [internal]
449 static DWORD
CDAUDIO_mciPlay(UINT16 wDevID
, DWORD dwFlags
, LPMCI_PLAY_PARMS lpParms
)
452 WINE_MCICDAUDIO
* wmcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
455 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
457 if (lpParms
== NULL
) {
458 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
459 } else if (wmcda
== NULL
) {
460 ret
= MCIERR_INVALID_DEVICE_ID
;
462 if (wmcda
->wcda
.nTracks
== 0) {
463 if (!CDAUDIO_GetTracksInfo(&wmcda
->wcda
)) {
464 WARN(cdaudio
, "error reading TracksInfo !\n");
465 return MCIERR_DRIVER_INTERNAL
;
468 end
= wmcda
->wcda
.dwFirstOffset
+ wmcda
->wcda
.dwTotalLen
;
469 wmcda
->wcda
.nCurTrack
= 1;
470 if (dwFlags
& MCI_FROM
) {
471 start
= CDAUDIO_CalcFrame(wmcda
, lpParms
->dwFrom
);
472 TRACE(cdaudio
,"MCI_FROM=%08lX -> %u \n", lpParms
->dwFrom
, start
);
474 if (!CDAUDIO_GetCDStatus(&wmcda
->wcda
)) return MCIERR_DRIVER_INTERNAL
;
475 start
= wmcda
->wcda
.dwCurFrame
;
477 if (dwFlags
& MCI_TO
) {
478 end
= CDAUDIO_CalcFrame(wmcda
, lpParms
->dwTo
);
479 TRACE(cdaudio
, "MCI_TO=%08lX -> %u \n", lpParms
->dwTo
, end
);
482 if (CDAUDIO_Play(&wmcda
->wcda
, start
, end
) == -1)
483 return MCIERR_HARDWARE
;
484 wmcda
->mciMode
= MCI_MODE_PLAY
;
485 if (dwFlags
& MCI_NOTIFY
) {
486 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
488 mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
489 wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
496 /**************************************************************************
497 * CDAUDIO_mciStop [internal]
499 static DWORD
CDAUDIO_mciStop(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
501 WINE_MCICDAUDIO
* wmcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
503 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
505 if (wmcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
507 if (CDAUDIO_Stop(&wmcda
->wcda
) == -1)
508 return MCIERR_HARDWARE
;
509 wmcda
->mciMode
= MCI_MODE_STOP
;
510 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
511 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
512 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
513 wmcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
518 /**************************************************************************
519 * CDAUDIO_mciPause [internal]
521 static DWORD
CDAUDIO_mciPause(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
523 WINE_MCICDAUDIO
* wmcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
525 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
527 if (wmcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
529 if (CDAUDIO_Pause(&wmcda
->wcda
, 1) == -1)
530 return MCIERR_HARDWARE
;
531 wmcda
->mciMode
= MCI_MODE_PAUSE
;
532 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
533 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
534 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
535 wmcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
540 /**************************************************************************
541 * CDAUDIO_mciResume [internal]
543 static DWORD
CDAUDIO_mciResume(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
545 WINE_MCICDAUDIO
* wmcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
547 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
549 if (wmcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
551 if (CDAUDIO_Pause(&wmcda
->wcda
, 0) == -1)
552 return MCIERR_HARDWARE
;
553 wmcda
->mciMode
= MCI_MODE_STOP
;
554 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
555 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
556 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
557 wmcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
562 /**************************************************************************
563 * CDAUDIO_mciSeek [internal]
565 static DWORD
CDAUDIO_mciSeek(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SEEK_PARMS lpParms
)
568 WINE_MCICDAUDIO
* wmcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
570 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
572 if (wmcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
573 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
575 wmcda
->mciMode
= MCI_MODE_SEEK
;
576 switch (dwFlags
& ~(MCI_NOTIFY
|MCI_WAIT
)) {
577 case MCI_SEEK_TO_START
:
578 TRACE(cdaudio
, "Seeking to start\n");
581 case MCI_SEEK_TO_END
:
582 TRACE(cdaudio
, "Seeking to end\n");
583 at
= wmcda
->wcda
.dwTotalLen
;
586 TRACE(cdaudio
, "Seeking to %lu\n", lpParms
->dwTo
);
590 TRACE(cdaudio
, "Seeking to ??=%lu\n", dwFlags
);
591 return MCIERR_UNSUPPORTED_FUNCTION
;
593 if (CDAUDIO_Seek(&wmcda
->wcda
, at
) == -1) {
594 return MCIERR_HARDWARE
;
596 if (dwFlags
& MCI_NOTIFY
) {
597 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
598 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
599 wmcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
604 /**************************************************************************
605 * CDAUDIO_mciSetDoor [internal]
607 static DWORD
CDAUDIO_mciSetDoor(UINT16 wDevID
, int open
)
609 WINE_MCICDAUDIO
* wmcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
611 TRACE(cdaudio
, "(%04x, %s) !\n", wDevID
, (open
) ? "OPEN" : "CLOSE");
613 if (wmcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
615 if (CDAUDIO_SetDoor(&wmcda
->wcda
, open
) == -1)
616 return MCIERR_HARDWARE
;
617 wmcda
->mciMode
= (open
) ? MCI_MODE_OPEN
: MCI_MODE_STOP
;
621 /**************************************************************************
622 * CDAUDIO_mciSet [internal]
624 static DWORD
CDAUDIO_mciSet(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SET_PARMS lpParms
)
626 WINE_MCICDAUDIO
* wmcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
628 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
630 if (wmcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
631 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;;
633 TRACE(cdaudio,"dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
634 TRACE(cdaudio,"dwAudio=%08lX\n", lpParms->dwAudio);
636 if (dwFlags
& MCI_SET_TIME_FORMAT
) {
637 switch (lpParms
->dwTimeFormat
) {
638 case MCI_FORMAT_MILLISECONDS
:
639 TRACE(cdaudio
, "MCI_FORMAT_MILLISECONDS !\n");
642 TRACE(cdaudio
,"MCI_FORMAT_MSF !\n");
644 case MCI_FORMAT_TMSF
:
645 TRACE(cdaudio
,"MCI_FORMAT_TMSF !\n");
648 WARN(cdaudio
, "bad time format !\n");
649 return MCIERR_BAD_TIME_FORMAT
;
651 wmcda
->dwTimeFormat
= lpParms
->dwTimeFormat
;
653 if (dwFlags
& MCI_SET_DOOR_OPEN
) {
654 CDAUDIO_mciSetDoor(wDevID
, TRUE
);
656 if (dwFlags
& MCI_SET_DOOR_CLOSED
) {
657 CDAUDIO_mciSetDoor(wDevID
, FALSE
);
659 if (dwFlags
& MCI_SET_VIDEO
) return MCIERR_UNSUPPORTED_FUNCTION
;
660 if (dwFlags
& MCI_SET_ON
) return MCIERR_UNSUPPORTED_FUNCTION
;
661 if (dwFlags
& MCI_SET_OFF
) return MCIERR_UNSUPPORTED_FUNCTION
;
662 if (dwFlags
& MCI_NOTIFY
) {
663 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
664 lpParms
->dwCallback
);
665 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
666 wmcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
671 /**************************************************************************
672 * MCICDAUDIO_DriverProc [sample driver]
674 LONG
MCICDAUDIO_DriverProc(DWORD dwDevID
, HDRVR16 hDriv
, DWORD wMsg
,
675 DWORD dwParam1
, DWORD dwParam2
)
678 case DRV_LOAD
: return 1;
679 case DRV_FREE
: return 1;
680 case DRV_OPEN
: return 1;
681 case DRV_CLOSE
: return 1;
682 case DRV_ENABLE
: return 1;
683 case DRV_DISABLE
: return 1;
684 case DRV_QUERYCONFIGURE
: return 1;
685 case DRV_CONFIGURE
: MessageBoxA(0, "Sample Multimedia Linux Driver !", "MMLinux Driver", MB_OK
); return 1;
686 case DRV_INSTALL
: return DRVCNF_RESTART
;
687 case DRV_REMOVE
: return DRVCNF_RESTART
;
689 case MCI_OPEN_DRIVER
: return CDAUDIO_mciOpen(dwDevID
, dwParam1
, (LPMCI_OPEN_PARMSA
)dwParam2
);
690 case MCI_CLOSE_DRIVER
: return CDAUDIO_mciClose(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
691 case MCI_GETDEVCAPS
: return CDAUDIO_mciGetDevCaps(dwDevID
, dwParam1
, (LPMCI_GETDEVCAPS_PARMS
)dwParam2
);
692 case MCI_INFO
: return CDAUDIO_mciInfo(dwDevID
, dwParam1
, (LPMCI_INFO_PARMS16
)dwParam2
);
693 case MCI_STATUS
: return CDAUDIO_mciStatus(dwDevID
, dwParam1
, (LPMCI_STATUS_PARMS
)dwParam2
);
694 case MCI_SET
: return CDAUDIO_mciSet(dwDevID
, dwParam1
, (LPMCI_SET_PARMS
)dwParam2
);
695 case MCI_PLAY
: return CDAUDIO_mciPlay(dwDevID
, dwParam1
, (LPMCI_PLAY_PARMS
)dwParam2
);
696 case MCI_STOP
: return CDAUDIO_mciStop(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
697 case MCI_PAUSE
: return CDAUDIO_mciPause(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
698 case MCI_RESUME
: return CDAUDIO_mciResume(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
699 case MCI_SEEK
: return CDAUDIO_mciSeek(dwDevID
, dwParam1
, (LPMCI_SEEK_PARMS
)dwParam2
);
700 /* FIXME: I wonder if those two next items are really called ? */
701 case MCI_SET_DOOR_OPEN
: return CDAUDIO_mciSetDoor(dwDevID
, TRUE
);
702 case MCI_SET_DOOR_CLOSED
: return CDAUDIO_mciSetDoor(dwDevID
, FALSE
);
719 WARN(cdaudio
, "Unsupported command=%s\n", MCI_CommandToString(wMsg
));
723 FIXME(cdaudio
, "Shouldn't receive a MCI_OPEN or CLOSE message\n");
726 TRACE(cdaudio
, "Sending msg=%s to default driver proc\n", MCI_CommandToString(wMsg
));
727 return DefDriverProc(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
729 return MCIERR_UNRECOGNIZED_COMMAND
;
732 /*-----------------------------------------------------------------------*/