1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
3 * Sample MCI CDAUDIO Wine Driver for Linux
5 * Copyright 1994 Martin Ayotte
13 #include <sys/ioctl.h>
15 #include "wine/winuser16.h"
18 #include "multimedia.h"
21 #ifdef HAVE_LINUX_CDROM_H
22 # include <linux/cdrom.h>
24 #ifdef HAVE_LINUX_UCDROM_H
25 # include <linux/ucdrom.h>
27 #ifdef HAVE_SYS_CDIO_H
28 # include <sys/cdio.h>
31 #if defined(__NetBSD__)
32 # define CDAUDIO_DEV "/dev/rcd0d"
33 #elif defined(__FreeBSD__)
34 # define CDAUDIO_DEV "/dev/rcd0c"
36 # define CDAUDIO_DEV "/dev/cdrom"
39 #define MAX_CDAUDIODRV (1)
40 #define MAX_CDAUDIO_TRACKS 256
42 #define CDFRAMES_PERSEC 75
43 #define CDFRAMES_PERMIN 4500
44 #define SECONDS_PERMIN 60
46 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
48 int nUseCount
; /* Incremented for each shared open */
49 BOOL16 fShareable
; /* TRUE if first open was shareable */
50 WORD wNotifyDeviceID
; /* MCI device ID with a pending notification */
51 HANDLE16 hCallback
; /* Callback handle for pending notification */
52 MCI_OPEN_PARMS16 openParms
;
56 struct cdrom_subchnl sc
;
58 struct cd_sub_channel_info sc
;
72 static WINE_CDAUDIO CDADev
[MAX_CDAUDIODRV
];
75 #ifndef CDROM_DATA_TRACK
76 #define CDROM_DATA_TRACK 0x04
79 /*-----------------------------------------------------------------------*/
81 /**************************************************************************
82 * CDAUDIO_mciGetOpenDrv [internal]
84 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
85 static WINE_CDAUDIO
* CDAUDIO_mciGetOpenDrv(UINT16 wDevID
)
87 if (wDevID
>= MAX_CDAUDIODRV
|| CDADev
[wDevID
].nUseCount
== 0 ||
88 CDADev
[wDevID
].unixdev
== 0) {
89 WARN(cdaudio
, "Invalid wDevID=%u\n", wDevID
);
92 return &CDADev
[wDevID
];
96 /**************************************************************************
97 * CDAUDIO_GetNumberOfTracks [internal]
99 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
100 static UINT16
CDAUDIO_GetNumberOfTracks(WINE_CDAUDIO
* wcda
)
103 struct cdrom_tochdr hdr
;
105 struct ioc_toc_header hdr
;
108 if (wcda
->nTracks
== 0) {
110 if (ioctl(wcda
->unixdev
, CDROMREADTOCHDR
, &hdr
)) {
112 if (ioctl(wcda
->unixdev
, CDIOREADTOCHEADER
, &hdr
)) {
114 WARN(cdaudio
, "(%p) -- Error occured (%d)!\n", wcda
, errno
);
118 wcda
->nTracks
= hdr
.cdth_trk1
;
120 wcda
->nTracks
= hdr
.ending_track
- hdr
.starting_track
+ 1;
123 return wcda
->nTracks
;
127 /**************************************************************************
128 * CDAUDIO_GetTracksInfo [internal]
130 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
131 static BOOL32
CDAUDIO_GetTracksInfo(WINE_CDAUDIO
* wcda
)
134 int start
, last_start
= 0;
135 int total_length
= 0;
137 struct cdrom_tocentry entry
;
139 struct ioc_read_toc_entry entry
;
140 struct cd_toc_entry toc_buffer
;
143 if (wcda
->nTracks
== 0) {
144 if (CDAUDIO_GetNumberOfTracks(wcda
) == (WORD
)-1) return FALSE
;
146 TRACE(cdaudio
,"nTracks=%u\n", wcda
->nTracks
);
148 if (wcda
->lpdwTrackLen
!= NULL
)
149 free(wcda
->lpdwTrackLen
);
150 wcda
->lpdwTrackLen
= (LPDWORD
)malloc((wcda
->nTracks
+ 1) * sizeof(DWORD
));
151 if (wcda
->lpdwTrackPos
!= NULL
)
152 free(wcda
->lpdwTrackPos
);
153 wcda
->lpdwTrackPos
= (LPDWORD
)malloc((wcda
->nTracks
+ 1) * sizeof(DWORD
));
154 if (wcda
->lpbTrackFlags
!= NULL
)
155 free(wcda
->lpbTrackFlags
);
156 wcda
->lpbTrackFlags
= (LPBYTE
)malloc((wcda
->nTracks
+ 1) * sizeof(BYTE
));
157 if (wcda
->lpdwTrackLen
== NULL
|| wcda
->lpdwTrackPos
== NULL
||
158 wcda
->lpbTrackFlags
== NULL
) {
159 WARN(cdaudio
, "error allocating track table !\n");
162 memset(wcda
->lpdwTrackLen
, 0, (wcda
->nTracks
+ 1) * sizeof(DWORD
));
163 memset(wcda
->lpdwTrackPos
, 0, (wcda
->nTracks
+ 1) * sizeof(DWORD
));
164 memset(wcda
->lpbTrackFlags
, 0, (wcda
->nTracks
+ 1) * sizeof(BYTE
));
165 for (i
= 0; i
<= wcda
->nTracks
; i
++) {
166 if (i
== wcda
->nTracks
)
168 entry
.cdte_track
= CDROM_LEADOUT
;
171 entry
.starting_track
= LEADOUT
; /* XXX */
175 entry
.cdte_track
= i
+ 1;
177 entry
.starting_track
= i
+ 1;
180 entry
.cdte_format
= CDROM_MSF
;
182 bzero((char *)&toc_buffer
, sizeof(toc_buffer
));
183 entry
.address_format
= CD_MSF_FORMAT
;
184 entry
.data_len
= sizeof(toc_buffer
);
185 entry
.data
= &toc_buffer
;
188 if (ioctl(wcda
->unixdev
, CDROMREADTOCENTRY
, &entry
)) {
190 if (ioctl(wcda
->unixdev
, CDIOREADTOCENTRYS
, &entry
)) {
192 WARN(cdaudio
, "error read entry (%d)\n", errno
);
196 start
= CDFRAMES_PERSEC
* (SECONDS_PERMIN
*
197 entry
.cdte_addr
.msf
.minute
+ entry
.cdte_addr
.msf
.second
) +
198 entry
.cdte_addr
.msf
.frame
;
200 start
= CDFRAMES_PERSEC
* (SECONDS_PERMIN
*
201 toc_buffer
.addr
.msf
.minute
+ toc_buffer
.addr
.msf
.second
) +
202 toc_buffer
.addr
.msf
.frame
;
206 wcda
->dwFirstOffset
= start
;
207 TRACE(cdaudio
, "dwFirstOffset=%u\n", start
);
209 length
= start
- last_start
;
211 start
= last_start
- length
;
212 total_length
+= length
;
213 wcda
->lpdwTrackLen
[i
- 1] = length
;
214 wcda
->lpdwTrackPos
[i
- 1] = start
;
215 TRACE(cdaudio
, "track #%u start=%u len=%u\n", i
, start
, length
);
218 wcda
->lpbTrackFlags
[i
] =
219 (entry
.cdte_adr
<< 4) | (entry
.cdte_ctrl
& 0x0f);
221 wcda
->lpbTrackFlags
[i
] =
222 (toc_buffer
.addr_type
<< 4) | (toc_buffer
.control
& 0x0f);
224 TRACE(cdaudio
, "track #%u flags=%02x\n", i
+ 1, wcda
->lpbTrackFlags
[i
]);
226 wcda
->dwTotalLen
= total_length
;
227 TRACE(cdaudio
,"total_len=%u\n", total_length
);
232 /**************************************************************************
234 * CDAUDIO_CalcFrame [internal]
236 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
237 static DWORD
CDAUDIO_CalcFrame(WINE_CDAUDIO
* wcda
, DWORD dwTime
)
242 TRACE(cdaudio
,"(%p, %08lX, %lu);\n", wcda
, wcda
->dwTimeFormat
, dwTime
);
244 switch (wcda
->dwTimeFormat
) {
245 case MCI_FORMAT_MILLISECONDS
:
246 dwFrame
= dwTime
* CDFRAMES_PERSEC
/ 1000;
247 TRACE(cdaudio
, "MILLISECONDS %lu\n", dwFrame
);
250 TRACE(cdaudio
, "MSF %02u:%02u:%02u\n",
251 MCI_MSF_MINUTE(dwTime
), MCI_MSF_SECOND(dwTime
), MCI_MSF_FRAME(dwTime
));
252 dwFrame
+= CDFRAMES_PERMIN
* MCI_MSF_MINUTE(dwTime
);
253 dwFrame
+= CDFRAMES_PERSEC
* MCI_MSF_SECOND(dwTime
);
254 dwFrame
+= MCI_MSF_FRAME(dwTime
);
256 case MCI_FORMAT_TMSF
:
258 /* unknown format ! force TMSF ! ... */
259 wTrack
= MCI_TMSF_TRACK(dwTime
);
260 TRACE(cdaudio
, "MSF %02u-%02u:%02u:%02u\n",
261 MCI_TMSF_TRACK(dwTime
), MCI_TMSF_MINUTE(dwTime
),
262 MCI_TMSF_SECOND(dwTime
), MCI_TMSF_FRAME(dwTime
));
263 TRACE(cdaudio
, "TMSF trackpos[%u]=%lu\n",
264 wTrack
, wcda
->lpdwTrackPos
[wTrack
- 1]);
265 dwFrame
= wcda
->lpdwTrackPos
[wTrack
- 1];
266 dwFrame
+= CDFRAMES_PERMIN
* MCI_TMSF_MINUTE(dwTime
);
267 dwFrame
+= CDFRAMES_PERSEC
* MCI_TMSF_SECOND(dwTime
);
268 dwFrame
+= MCI_TMSF_FRAME(dwTime
);
275 /**************************************************************************
276 * CDAUDIO_GetCDStatus [internal]
278 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
279 static BOOL32
CDAUDIO_GetCDStatus(WINE_CDAUDIO
* wcda
)
281 int oldmode
= wcda
->cdMode
;
283 wcda
->sc
.cdsc_format
= CDROM_MSF
;
285 struct ioc_read_subchannel read_sc
;
287 read_sc
.address_format
= CD_MSF_FORMAT
;
288 read_sc
.data_format
= CD_CURRENT_POSITION
;
290 read_sc
.data_len
= sizeof(wcda
->sc
);
291 read_sc
.data
= (struct cd_sub_channel_info
*)&wcda
->sc
;
294 if (ioctl(wcda
->unixdev
, CDROMSUBCHNL
, &wcda
->sc
)) {
296 if (ioctl(wcda
->unixdev
, CDIOCREADSUBCHANNEL
, &read_sc
)) {
298 TRACE(cdaudio
,"opened or no_media (%d)!\n", errno
);
299 wcda
->cdMode
= MCI_MODE_OPEN
; /* was NOT_READY */
304 wcda
->sc
.cdsc_audiostatus
306 wcda
->sc
.header
.audio_status
310 case CDROM_AUDIO_INVALID
:
312 case CD_AS_AUDIO_INVALID
:
314 WARN(cdaudio
, "device doesn't support status, using MCI status.\n");
318 case CDROM_AUDIO_NO_STATUS
:
320 case CD_AS_NO_STATUS
:
322 wcda
->cdMode
= MCI_MODE_STOP
;
323 TRACE(cdaudio
,"MCI_MODE_STOP !\n");
326 case CDROM_AUDIO_PLAY
:
328 case CD_AS_PLAY_IN_PROGRESS
:
330 wcda
->cdMode
= MCI_MODE_PLAY
;
331 TRACE(cdaudio
,"MCI_MODE_PLAY !\n");
334 case CDROM_AUDIO_PAUSED
:
336 case CD_AS_PLAY_PAUSED
:
338 wcda
->cdMode
= MCI_MODE_PAUSE
;
339 TRACE(cdaudio
,"MCI_MODE_PAUSE !\n");
343 TRACE(cdaudio
,"status=%02X !\n",
344 wcda
->sc
.cdsc_audiostatus
);
346 TRACE(cdaudio
,"status=%02X !\n",
347 wcda
->sc
.header
.audio_status
);
351 wcda
->nCurTrack
= wcda
->sc
.cdsc_trk
;
353 CDFRAMES_PERMIN
* wcda
->sc
.cdsc_absaddr
.msf
.minute
+
354 CDFRAMES_PERSEC
* wcda
->sc
.cdsc_absaddr
.msf
.second
+
355 wcda
->sc
.cdsc_absaddr
.msf
.frame
;
357 wcda
->nCurTrack
= wcda
->sc
.what
.position
.track_number
;
359 CDFRAMES_PERMIN
* wcda
->sc
.what
.position
.absaddr
.msf
.minute
+
360 CDFRAMES_PERSEC
* wcda
->sc
.what
.position
.absaddr
.msf
.second
+
361 wcda
->sc
.what
.position
.absaddr
.msf
.frame
;
364 TRACE(cdaudio
,"%02u-%02u:%02u:%02u \n",
366 wcda
->sc
.cdsc_absaddr
.msf
.minute
,
367 wcda
->sc
.cdsc_absaddr
.msf
.second
,
368 wcda
->sc
.cdsc_absaddr
.msf
.frame
);
370 TRACE(cdaudio
,"%02u-%02u:%02u:%02u \n",
371 wcda
->sc
.what
.position
.track_number
,
372 wcda
->sc
.what
.position
.absaddr
.msf
.minute
,
373 wcda
->sc
.what
.position
.absaddr
.msf
.second
,
374 wcda
->sc
.what
.position
.absaddr
.msf
.frame
);
377 if (oldmode
!= wcda
->cdMode
&& oldmode
== MCI_MODE_OPEN
) {
378 if (!CDAUDIO_GetTracksInfo(wcda
)) {
379 WARN(cdaudio
, "error updating TracksInfo !\n");
387 /**************************************************************************
388 * CDAUDIO_CalcTime [internal]
390 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
391 static DWORD
CDAUDIO_CalcTime(WINE_CDAUDIO
* wcda
, DWORD dwFrame
)
399 TRACE(cdaudio
,"(%p, %08lX, %lu);\n", wcda
, wcda
->dwTimeFormat
, dwFrame
);
401 switch (wcda
->dwTimeFormat
) {
402 case MCI_FORMAT_MILLISECONDS
:
403 dwTime
= dwFrame
/ CDFRAMES_PERSEC
* 1000;
404 TRACE(cdaudio
, "MILLISECONDS %lu\n", dwTime
);
407 wMinutes
= dwFrame
/ CDFRAMES_PERMIN
;
408 wSeconds
= (dwFrame
- CDFRAMES_PERMIN
* wMinutes
) / CDFRAMES_PERSEC
;
409 wFrames
= dwFrame
- CDFRAMES_PERMIN
* wMinutes
- CDFRAMES_PERSEC
* wSeconds
;
410 dwTime
= MCI_MAKE_MSF(wMinutes
, wSeconds
, wFrames
);
411 TRACE(cdaudio
,"MSF %02u:%02u:%02u -> dwTime=%lu\n",wMinutes
, wSeconds
, wFrames
, dwTime
);
413 case MCI_FORMAT_TMSF
:
415 /* unknown format ! force TMSF ! ... */
416 for (wTrack
= 0; wTrack
< wcda
->nTracks
; wTrack
++) {
417 /* dwTime += wcda->lpdwTrackLen[wTrack - 1];
418 TRACE(cdaudio, "Adding trk#%u curpos=%u \n", dwTime);
419 if (dwTime >= dwFrame) break; */
420 if (wcda
->lpdwTrackPos
[wTrack
- 1] >= dwFrame
) break;
422 wMinutes
= dwFrame
/ CDFRAMES_PERMIN
;
423 wSeconds
= (dwFrame
- CDFRAMES_PERMIN
* wMinutes
) / CDFRAMES_PERSEC
;
424 wFrames
= dwFrame
- CDFRAMES_PERMIN
* wMinutes
- CDFRAMES_PERSEC
* wSeconds
;
425 dwTime
= MCI_MAKE_TMSF(wTrack
, wMinutes
, wSeconds
, wFrames
);
426 TRACE(cdaudio
, "%02u-%02u:%02u:%02u\n", wTrack
, wMinutes
, wSeconds
, wFrames
);
433 static DWORD
CDAUDIO_mciSeek(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SEEK_PARMS lpParms
);
434 static DWORD
CDAUDIO_mciStop(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
);
436 /**************************************************************************
437 * CDAUDIO_mciOpen [internal]
439 static DWORD
CDAUDIO_mciOpen(UINT16 wDevID
, DWORD dwFlags
, LPMCI_OPEN_PARMS32A lpOpenParms
)
441 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
444 MCI_SEEK_PARMS seekParms
;
446 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpOpenParms
);
448 if (lpOpenParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
449 if (wDevID
> MAX_CDAUDIODRV
) return MCIERR_INVALID_DEVICE_ID
;
451 dwDeviceID
= lpOpenParms
->wDeviceID
;
453 wcda
= &CDADev
[wDevID
];
455 if (wcda
->nUseCount
> 0) {
456 /* The driver already open on this channel */
457 /* If the driver was opened shareable before and this open specifies */
458 /* shareable then increment the use count */
459 if (wcda
->fShareable
&& (dwFlags
& MCI_OPEN_SHAREABLE
))
462 return MCIERR_MUST_USE_SHAREABLE
;
465 wcda
->fShareable
= dwFlags
& MCI_OPEN_SHAREABLE
;
467 if (dwFlags
& MCI_OPEN_ELEMENT
) {
468 TRACE(cdaudio
,"MCI_OPEN_ELEMENT !\n");
469 /* return MCIERR_NO_ELEMENT_ALLOWED; */
472 wcda
->openParms
.dwCallback
= lpOpenParms
->dwCallback
;
473 wcda
->openParms
.wDeviceID
= (WORD
)lpOpenParms
->wDeviceID
;
474 wcda
->openParms
.wReserved0
= 0; /*????*/
475 wcda
->openParms
.lpstrDeviceType
= lpOpenParms
->lpstrDeviceType
;
476 wcda
->openParms
.lpstrElementName
= lpOpenParms
->lpstrElementName
;
477 wcda
->openParms
.lpstrAlias
= lpOpenParms
->lpstrAlias
;
479 wcda
->wNotifyDeviceID
= dwDeviceID
;
480 wcda
->unixdev
= open (CDAUDIO_DEV
, O_RDONLY
, 0);
481 if (wcda
->unixdev
== -1) {
482 WARN(cdaudio
,"can't open '%s'!. errno=%d\n", CDAUDIO_DEV
, errno
);
483 perror( "can't open\n");
484 return MCIERR_HARDWARE
;
487 wcda
->mciMode
= MCI_MODE_STOP
;
488 wcda
->dwTimeFormat
= MCI_FORMAT_TMSF
;
491 wcda
->dwTotalLen
= 0;
492 wcda
->dwFirstOffset
= 0;
493 wcda
->lpdwTrackLen
= NULL
;
494 wcda
->lpdwTrackPos
= NULL
;
495 wcda
->lpbTrackFlags
= NULL
;
496 if (!CDAUDIO_GetTracksInfo(&CDADev
[wDevID
])) {
497 WARN(cdaudio
,"error reading TracksInfo !\n");
498 /* return MCIERR_INTERNAL; */
501 CDAUDIO_mciSeek(wDevID
, MCI_SEEK_TO_START
, &seekParms
);
505 return MCIERR_HARDWARE
;
509 /**************************************************************************
510 * CDAUDIO_mciClose [internal]
512 static DWORD
CDAUDIO_mciClose(UINT16 wDevID
, DWORD dwParam
, LPMCI_GENERIC_PARMS lpParms
)
514 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
515 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
517 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwParam
, lpParms
);
519 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
521 if (wcda
->nUseCount
== 1) {
522 CDAUDIO_mciStop(wDevID
, 0, NULL
);
524 if (wcda
->lpdwTrackLen
!= NULL
) free(wcda
->lpdwTrackLen
);
525 if (wcda
->lpdwTrackPos
!= NULL
) free(wcda
->lpdwTrackPos
);
526 if (wcda
->lpbTrackFlags
!= NULL
) free(wcda
->lpbTrackFlags
);
527 close(wcda
->unixdev
);
534 /**************************************************************************
535 * CDAUDIO_mciGetDevCaps [internal]
537 static DWORD
CDAUDIO_mciGetDevCaps(UINT16 wDevID
, DWORD dwFlags
,
538 LPMCI_GETDEVCAPS_PARMS lpParms
)
540 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
541 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
543 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
545 if (dwFlags
& MCI_GETDEVCAPS_ITEM
) {
546 TRACE(cdaudio
, "MCI_GETDEVCAPS_ITEM dwItem=%08lX;\n", lpParms
->dwItem
);
548 switch(lpParms
->dwItem
) {
549 case MCI_GETDEVCAPS_CAN_RECORD
:
550 lpParms
->dwReturn
= FALSE
;
552 case MCI_GETDEVCAPS_HAS_AUDIO
:
553 lpParms
->dwReturn
= TRUE
;
555 case MCI_GETDEVCAPS_HAS_VIDEO
:
556 lpParms
->dwReturn
= FALSE
;
558 case MCI_GETDEVCAPS_DEVICE_TYPE
:
559 lpParms
->dwReturn
= MCI_DEVTYPE_CD_AUDIO
;
561 case MCI_GETDEVCAPS_USES_FILES
:
562 lpParms
->dwReturn
= FALSE
;
564 case MCI_GETDEVCAPS_COMPOUND_DEVICE
:
565 lpParms
->dwReturn
= FALSE
;
567 case MCI_GETDEVCAPS_CAN_EJECT
:
568 lpParms
->dwReturn
= TRUE
;
570 case MCI_GETDEVCAPS_CAN_PLAY
:
571 lpParms
->dwReturn
= TRUE
;
573 case MCI_GETDEVCAPS_CAN_SAVE
:
574 lpParms
->dwReturn
= FALSE
;
577 return MCIERR_UNRECOGNIZED_COMMAND
;
580 TRACE(cdaudio
, "lpParms->dwReturn=%08lX;\n", lpParms
->dwReturn
);
583 return MCIERR_HARDWARE
;
587 /**************************************************************************
588 * CDAUDIO_mciInfo [internal]
590 static DWORD
CDAUDIO_mciInfo(UINT16 wDevID
, DWORD dwFlags
, LPMCI_INFO_PARMS16 lpParms
)
592 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
595 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
597 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
599 if (lpParms
== NULL
|| lpParms
->lpstrReturn
== NULL
) {
600 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
601 } else if (wcda
== NULL
) {
602 ret
= MCIERR_INVALID_DEVICE_ID
;
604 TRACE(cdaudio
, "buf=%p, len=%lu\n", lpParms
->lpstrReturn
, lpParms
->dwRetSize
);
607 case MCI_INFO_PRODUCT
:
608 str
= "Wine's audio CD";
611 WARN(cdaudio
, "Don't know this info command (%lu)\n", dwFlags
);
612 ret
= MCIERR_UNRECOGNIZED_COMMAND
;
616 ret
= MCI_WriteString(lpParms
->lpstrReturn
, lpParms
->dwRetSize
, str
);
618 lpParms
->lpstrReturn
[0] = 0;
623 return MCIERR_HARDWARE
;
627 /**************************************************************************
628 * CDAUDIO_mciStatus [internal]
630 static DWORD
CDAUDIO_mciStatus(UINT16 wDevID
, DWORD dwFlags
, LPMCI_STATUS_PARMS lpParms
)
632 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
633 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
636 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
638 if (lpParms
== NULL
) {
639 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
640 } else if (wcda
== NULL
) {
641 ret
= MCIERR_INVALID_DEVICE_ID
;
643 if (dwFlags
& MCI_NOTIFY
) {
644 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
645 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
646 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
648 if (dwFlags
& MCI_STATUS_ITEM
) {
649 switch(lpParms
->dwItem
) {
650 case MCI_STATUS_CURRENT_TRACK
:
651 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
652 lpParms
->dwReturn
= wcda
->nCurTrack
;
653 TRACE(cdaudio
,"CURRENT_TRACK=%lu!\n", lpParms
->dwReturn
);
655 case MCI_STATUS_LENGTH
:
656 if (wcda
->nTracks
== 0) {
657 if (!CDAUDIO_GetTracksInfo(wcda
)) {
658 WARN(cdaudio
, "error reading TracksInfo !\n");
659 return MCIERR_DRIVER_INTERNAL
;
662 if (dwFlags
& MCI_TRACK
) {
663 TRACE(cdaudio
,"MCI_TRACK #%lu LENGTH=??? !\n", lpParms
->dwTrack
);
664 if (lpParms
->dwTrack
> wcda
->nTracks
)
665 return MCIERR_OUTOFRANGE
;
666 lpParms
->dwReturn
= wcda
->lpdwTrackLen
[lpParms
->dwTrack
- 1];
668 lpParms
->dwReturn
= wcda
->dwTotalLen
;
670 lpParms
->dwReturn
= CDAUDIO_CalcTime(wcda
, lpParms
->dwReturn
);
671 TRACE(cdaudio
,"LENGTH=%lu !\n", lpParms
->dwReturn
);
673 case MCI_STATUS_MODE
:
674 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
675 lpParms
->dwReturn
= wcda
->cdMode
;
676 if (!lpParms
->dwReturn
) lpParms
->dwReturn
= wcda
->mciMode
;
677 TRACE(cdaudio
,"MCI_STATUS_MODE=%08lX !\n", lpParms
->dwReturn
);
679 case MCI_STATUS_MEDIA_PRESENT
:
680 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
681 lpParms
->dwReturn
= (wcda
->nTracks
> 0) ? TRUE
: FALSE
;
682 TRACE(cdaudio
,"MCI_STATUS_MEDIA_PRESENT =%s!\n", lpParms
->dwReturn
? "Y" : "N");
684 case MCI_STATUS_NUMBER_OF_TRACKS
:
685 lpParms
->dwReturn
= CDAUDIO_GetNumberOfTracks(wcda
);
686 TRACE(cdaudio
,"MCI_STATUS_NUMBER_OF_TRACKS = %lu !\n", lpParms
->dwReturn
);
687 if (lpParms
->dwReturn
== (WORD
)-1) return MCIERR_DRIVER_INTERNAL
;
689 case MCI_STATUS_POSITION
:
690 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
691 lpParms
->dwReturn
= wcda
->dwCurFrame
;
692 if (dwFlags
& MCI_STATUS_START
) {
693 lpParms
->dwReturn
= wcda
->dwFirstOffset
;
694 TRACE(cdaudio
,"get MCI_STATUS_START !\n");
696 if (dwFlags
& MCI_TRACK
) {
697 if (lpParms
->dwTrack
> wcda
->nTracks
)
698 return MCIERR_OUTOFRANGE
;
699 lpParms
->dwReturn
= wcda
->lpdwTrackPos
[lpParms
->dwTrack
- 1];
700 TRACE(cdaudio
,"get MCI_TRACK #%lu !\n", lpParms
->dwTrack
);
702 lpParms
->dwReturn
= CDAUDIO_CalcTime(wcda
, lpParms
->dwReturn
);
703 TRACE(cdaudio
,"MCI_STATUS_POSITION=%08lX !\n", lpParms
->dwReturn
);
705 case MCI_STATUS_READY
:
706 TRACE(cdaudio
,"MCI_STATUS_READY !\n");
707 lpParms
->dwReturn
= TRUE
;
709 case MCI_STATUS_TIME_FORMAT
:
710 lpParms
->dwReturn
= wcda
->dwTimeFormat
;
711 TRACE(cdaudio
,"MCI_STATUS_TIME_FORMAT =%08lx!\n", lpParms
->dwReturn
);
713 /* FIXME: the constant used here are not defined in mmsystem.h */
714 /* MCI_CDA_STATUS_TYPE_TRACK is very likely to be 0x00004001 */
715 case MCI_CDA_STATUS_TYPE_TRACK
:
716 if (!(dwFlags
& MCI_TRACK
)) return MCIERR_MISSING_PARAMETER
;
717 lpParms
->dwReturn
= (wcda
->lpbTrackFlags
[lpParms
->dwTrack
- 1] &
718 CDROM_DATA_TRACK
) ? MCI_CDA_TRACK_OTHER
: MCI_CDA_TRACK_AUDIO
;
719 TRACE(cdaudio
, "MCI_CDA_STATUS_TYPE_TRACK[%ld]=%08lx\n", lpParms
->dwTrack
, lpParms
->dwReturn
);
722 WARN(cdaudio
, "unknown command %08lX !\n", lpParms
->dwItem
);
723 return MCIERR_UNRECOGNIZED_COMMAND
;
727 WARN(cdaudio
, "not MCI_STATUS_ITEM !\n");
730 return MCIERR_HARDWARE
;
734 /**************************************************************************
735 * CDAUDIO_mciPlay [internal]
737 static DWORD
CDAUDIO_mciPlay(UINT16 wDevID
, DWORD dwFlags
, LPMCI_PLAY_PARMS lpParms
)
739 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
741 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
744 struct cdrom_msf msf
;
746 struct ioc_play_msf msf
;
749 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
751 if (lpParms
== NULL
) {
752 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
753 } else if (wcda
== NULL
) {
754 ret
= MCIERR_INVALID_DEVICE_ID
;
756 if (wcda
->nTracks
== 0) {
757 if (!CDAUDIO_GetTracksInfo(wcda
)) {
758 WARN(cdaudio
, "error reading TracksInfo !\n");
759 return MCIERR_DRIVER_INTERNAL
;
762 end
= wcda
->dwTotalLen
;
764 if (dwFlags
& MCI_FROM
) {
765 start
= CDAUDIO_CalcFrame(wcda
, lpParms
->dwFrom
);
766 TRACE(cdaudio
,"MCI_FROM=%08lX -> %u \n", lpParms
->dwFrom
, start
);
768 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
769 start
= wcda
->dwCurFrame
;
771 if (dwFlags
& MCI_TO
) {
772 end
= CDAUDIO_CalcFrame(wcda
, lpParms
->dwTo
);
773 TRACE(cdaudio
, "MCI_TO=%08lX -> %u \n", lpParms
->dwTo
, end
);
775 end
+= wcda
->dwFirstOffset
;
777 msf
.cdmsf_min0
= start
/ CDFRAMES_PERMIN
;
778 msf
.cdmsf_sec0
= (start
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
779 msf
.cdmsf_frame0
= start
% CDFRAMES_PERSEC
;
780 msf
.cdmsf_min1
= end
/ CDFRAMES_PERMIN
;
781 msf
.cdmsf_sec1
= (end
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
782 msf
.cdmsf_frame1
= end
% CDFRAMES_PERSEC
;
784 msf
.start_m
= start
/ CDFRAMES_PERMIN
;
785 msf
.start_s
= (start
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
786 msf
.start_f
= start
% CDFRAMES_PERSEC
;
787 msf
.end_m
= end
/ CDFRAMES_PERMIN
;
788 msf
.end_s
= (end
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
789 msf
.end_f
= end
% CDFRAMES_PERSEC
;
792 if (ioctl(wcda
->unixdev
, CDROMSTART
)) {
794 if (ioctl(wcda
->unixdev
, CDIOCSTART
, NULL
)) {
796 WARN(cdaudio
, "motor doesn't start !\n");
797 return MCIERR_HARDWARE
;
800 if (ioctl(wcda
->unixdev
, CDROMPLAYMSF
, &msf
)) {
802 if (ioctl(wcda
->unixdev
, CDIOCPLAYMSF
, &msf
)) {
804 WARN(cdaudio
, "device doesn't play !\n");
805 return MCIERR_HARDWARE
;
808 TRACE(cdaudio
,"msf = %d:%d:%d %d:%d:%d\n",
809 msf
.cdmsf_min0
, msf
.cdmsf_sec0
, msf
.cdmsf_frame0
,
810 msf
.cdmsf_min1
, msf
.cdmsf_sec1
, msf
.cdmsf_frame1
);
812 TRACE(cdaudio
,"msf = %d:%d:%d %d:%d:%d\n",
813 msf
.start_m
, msf
.start_s
, msf
.start_f
,
814 msf
.end_m
, msf
.end_s
, msf
.end_f
);
816 wcda
->mciMode
= MCI_MODE_PLAY
;
817 if (dwFlags
& MCI_NOTIFY
) {
818 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
820 mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
821 wcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
828 return MCIERR_HARDWARE
;
832 /**************************************************************************
833 * CDAUDIO_mciStop [internal]
835 static DWORD
CDAUDIO_mciStop(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
837 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
838 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
840 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
842 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
845 if (ioctl(wcda
->unixdev
, CDROMSTOP
))
847 if (ioctl(wcda
->unixdev
, CDIOCSTOP
, NULL
))
849 return MCIERR_HARDWARE
;
850 wcda
->mciMode
= MCI_MODE_STOP
;
851 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
852 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
853 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
854 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
858 return MCIERR_HARDWARE
;
862 /**************************************************************************
863 * CDAUDIO_mciPause [internal]
865 static DWORD
CDAUDIO_mciPause(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
867 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
868 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
870 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
872 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
875 if (ioctl(wcda
->unixdev
, CDROMPAUSE
))
877 if (ioctl(wcda
->unixdev
, CDIOCPAUSE
, NULL
))
879 return MCIERR_HARDWARE
;
880 wcda
->mciMode
= MCI_MODE_PAUSE
;
881 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
882 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
883 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
884 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
888 return MCIERR_HARDWARE
;
892 /**************************************************************************
893 * CDAUDIO_mciResume [internal]
895 static DWORD
CDAUDIO_mciResume(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
897 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
898 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
900 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
902 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
905 if (ioctl(wcda
->unixdev
, CDROMRESUME
))
907 if (ioctl(wcda
->unixdev
, CDIOCRESUME
, NULL
))
909 return MCIERR_HARDWARE
;
910 wcda
->mciMode
= MCI_MODE_STOP
;
911 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
912 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
913 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
914 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
918 return MCIERR_HARDWARE
;
922 /**************************************************************************
923 * CDAUDIO_mciSeek [internal]
925 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
926 static DWORD
CDAUDIO_mciSeek(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SEEK_PARMS lpParms
)
929 MCI_PLAY_PARMS playParms
;
931 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
933 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
935 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
936 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
938 wcda
->mciMode
= MCI_MODE_SEEK
;
939 switch (dwFlags
& ~(MCI_NOTIFY
|MCI_WAIT
)) {
940 case MCI_SEEK_TO_START
:
941 TRACE(cdaudio
, "Seeking to start\n");
942 playParms
.dwFrom
= 0;
944 case MCI_SEEK_TO_END
:
945 TRACE(cdaudio
, "Seeking to end\n");
946 playParms
.dwFrom
= wcda
->dwTotalLen
;
949 TRACE(cdaudio
, "Seeking to %lu\n", lpParms
->dwTo
);
950 playParms
.dwFrom
= lpParms
->dwTo
;
953 TRACE(cdaudio
, "Seeking to ??=%lu\n", dwFlags
);
954 return MCIERR_UNSUPPORTED_FUNCTION
;
956 dwRet
= CDAUDIO_mciPlay(wDevID
, MCI_WAIT
| MCI_FROM
, &playParms
);
957 if (dwRet
!= 0) return dwRet
;
958 dwRet
= CDAUDIO_mciStop(wDevID
, MCI_WAIT
, (LPMCI_GENERIC_PARMS
)&playParms
);
959 if (dwFlags
& MCI_NOTIFY
) {
960 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
961 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
962 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
968 /**************************************************************************
969 * CDAUDIO_mciSetDoor [internal]
971 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
972 static DWORD
CDAUDIO_mciSetDoor(UINT16 wDevID
, int open
)
974 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
976 TRACE(cdaudio
, "(%04x, %s) !\n", wDevID
, (open
) ? "OPEN" : "CLOSE");
978 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
982 if (ioctl(wcda
->unixdev
, CDROMEJECT
)) return MCIERR_HARDWARE
;
983 wcda
->mciMode
= MCI_MODE_OPEN
;
985 if (ioctl(wcda
->unixdev
, CDROMEJECT
, 1)) return MCIERR_HARDWARE
;
986 wcda
->mciMode
= MCI_MODE_STOP
;
989 if (ioctl(wcda
->unixdev
, CDIOCALLOW
, NULL
)) return MCIERR_HARDWARE
;
991 if (ioctl(wcda
->unixdev
, CDIOCEJECT
, NULL
)) return MCIERR_HARDWARE
;
992 wcda
->mciMode
= MCI_MODE_OPEN
;
994 if (ioctl(wcda
->unixdev
, CDIOCCLOSE
, NULL
)) return MCIERR_HARDWARE
;
995 wcda
->mciMode
= MCI_MODE_STOP
;
997 if (ioctl(wcda
->unixdev
, CDIOCPREVENT
, NULL
)) return MCIERR_HARDWARE
;
1004 /**************************************************************************
1005 * CDAUDIO_mciSet [internal]
1007 static DWORD
CDAUDIO_mciSet(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SET_PARMS lpParms
)
1009 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
1010 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
1012 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
1014 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
1015 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;;
1017 TRACE(cdaudio,"dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
1018 TRACE(cdaudio,"dwAudio=%08lX\n", lpParms->dwAudio);
1020 if (dwFlags
& MCI_SET_TIME_FORMAT
) {
1021 switch (lpParms
->dwTimeFormat
) {
1022 case MCI_FORMAT_MILLISECONDS
:
1023 TRACE(cdaudio
, "MCI_FORMAT_MILLISECONDS !\n");
1025 case MCI_FORMAT_MSF
:
1026 TRACE(cdaudio
,"MCI_FORMAT_MSF !\n");
1028 case MCI_FORMAT_TMSF
:
1029 TRACE(cdaudio
,"MCI_FORMAT_TMSF !\n");
1032 WARN(cdaudio
, "bad time format !\n");
1033 return MCIERR_BAD_TIME_FORMAT
;
1035 wcda
->dwTimeFormat
= lpParms
->dwTimeFormat
;
1037 if (dwFlags
& MCI_SET_DOOR_OPEN
) {
1038 CDAUDIO_mciSetDoor(wDevID
, TRUE
);
1040 if (dwFlags
& MCI_SET_DOOR_CLOSED
) {
1041 CDAUDIO_mciSetDoor(wDevID
, FALSE
);
1043 if (dwFlags
& MCI_SET_VIDEO
) return MCIERR_UNSUPPORTED_FUNCTION
;
1044 if (dwFlags
& MCI_SET_ON
) return MCIERR_UNSUPPORTED_FUNCTION
;
1045 if (dwFlags
& MCI_SET_OFF
) return MCIERR_UNSUPPORTED_FUNCTION
;
1046 if (dwFlags
& MCI_NOTIFY
) {
1047 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
1048 lpParms
->dwCallback
);
1049 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
1050 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
1054 return MCIERR_HARDWARE
;
1058 /**************************************************************************
1059 * MCICDAUDIO_DriverProc32 [sample driver]
1061 LONG
MCICDAUDIO_DriverProc32(DWORD dwDevID
, HDRVR16 hDriv
, DWORD wMsg
,
1062 DWORD dwParam1
, DWORD dwParam2
)
1064 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
1066 case DRV_LOAD
: return 1;
1067 case DRV_FREE
: return 1;
1068 case DRV_OPEN
: return 1;
1069 case DRV_CLOSE
: return 1;
1070 case DRV_ENABLE
: return 1;
1071 case DRV_DISABLE
: return 1;
1072 case DRV_QUERYCONFIGURE
: return 1;
1073 case DRV_CONFIGURE
: MessageBox16(0, "Sample MultiMedia Linux Driver !", "MMLinux Driver", MB_OK
); return 1;
1074 case DRV_INSTALL
: return DRVCNF_RESTART
;
1075 case DRV_REMOVE
: return DRVCNF_RESTART
;
1077 case MCI_OPEN_DRIVER
: return CDAUDIO_mciOpen(dwDevID
, dwParam1
, (LPMCI_OPEN_PARMS32A
)dwParam2
);
1078 case MCI_CLOSE_DRIVER
: return CDAUDIO_mciClose(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1079 case MCI_GETDEVCAPS
: return CDAUDIO_mciGetDevCaps(dwDevID
, dwParam1
, (LPMCI_GETDEVCAPS_PARMS
)dwParam2
);
1080 case MCI_INFO
: return CDAUDIO_mciInfo(dwDevID
, dwParam1
, (LPMCI_INFO_PARMS16
)dwParam2
);
1081 case MCI_STATUS
: return CDAUDIO_mciStatus(dwDevID
, dwParam1
, (LPMCI_STATUS_PARMS
)dwParam2
);
1082 case MCI_SET
: return CDAUDIO_mciSet(dwDevID
, dwParam1
, (LPMCI_SET_PARMS
)dwParam2
);
1083 case MCI_PLAY
: return CDAUDIO_mciPlay(dwDevID
, dwParam1
, (LPMCI_PLAY_PARMS
)dwParam2
);
1084 case MCI_STOP
: return CDAUDIO_mciStop(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1085 case MCI_PAUSE
: return CDAUDIO_mciPause(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1086 case MCI_RESUME
: return CDAUDIO_mciResume(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1087 case MCI_SEEK
: return CDAUDIO_mciSeek(dwDevID
, dwParam1
, (LPMCI_SEEK_PARMS
)dwParam2
);
1088 /* FIXME: I wonder if those two next items are really called ? */
1089 case MCI_SET_DOOR_OPEN
: return CDAUDIO_mciSetDoor(dwDevID
, TRUE
);
1090 case MCI_SET_DOOR_CLOSED
: return CDAUDIO_mciSetDoor(dwDevID
, FALSE
);
1107 WARN(cdaudio
, "Unsupported command=%s\n", MCI_CommandToString(wMsg
));
1111 FIXME(cdaudio
, "Shouldn't receive a MCI_OPEN or CLOSE message\n");
1114 TRACE(cdaudio
, "Sending msg=%s to default driver proc\n", MCI_CommandToString(wMsg
));
1115 return DefDriverProc32(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
1117 return MCIERR_UNRECOGNIZED_COMMAND
;
1119 return MCIERR_UNRECOGNIZED_COMMAND
;
1123 /*-----------------------------------------------------------------------*/