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>
17 #include "multimedia.h"
20 #ifdef HAVE_LINUX_CDROM_H
21 # include <linux/cdrom.h>
23 #ifdef HAVE_LINUX_UCDROM_H
24 # include <linux/ucdrom.h>
26 #ifdef HAVE_SYS_CDIO_H
27 # include <sys/cdio.h>
30 #if defined(__NetBSD__)
31 # define CDAUDIO_DEV "/dev/rcd0d"
32 #elif defined(__FreeBSD__)
33 # define CDAUDIO_DEV "/dev/rcd0c"
35 # define CDAUDIO_DEV "/dev/cdrom"
38 #define MAX_CDAUDIODRV (1)
39 #define MAX_CDAUDIO_TRACKS 256
41 #define CDFRAMES_PERSEC 75
42 #define CDFRAMES_PERMIN 4500
43 #define SECONDS_PERMIN 60
45 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
47 int nUseCount
; /* Incremented for each shared open */
48 BOOL16 fShareable
; /* TRUE if first open was shareable */
49 WORD wNotifyDeviceID
; /* MCI device ID with a pending notification */
50 HANDLE16 hCallback
; /* Callback handle for pending notification */
51 MCI_OPEN_PARMS16 openParms
;
55 struct cdrom_subchnl sc
;
57 struct cd_sub_channel_info sc
;
71 static WINE_CDAUDIO CDADev
[MAX_CDAUDIODRV
];
74 #ifndef CDROM_DATA_TRACK
75 #define CDROM_DATA_TRACK 0x04
78 /*-----------------------------------------------------------------------*/
80 /**************************************************************************
81 * CDAUDIO_mciGetOpenDrv [internal]
83 static WINE_CDAUDIO
* CDAUDIO_mciGetOpenDrv(UINT16 wDevID
)
85 if (wDevID
>= MAX_CDAUDIODRV
|| CDADev
[wDevID
].nUseCount
== 0 ||
86 CDADev
[wDevID
].unixdev
== 0) {
87 WARN(cdaudio
, "Invalid wDevID=%u\n", wDevID
);
90 return &CDADev
[wDevID
];
93 /**************************************************************************
94 * CDAUDIO_GetNumberOfTracks [internal]
96 static UINT16
CDAUDIO_GetNumberOfTracks(WINE_CDAUDIO
* wcda
)
98 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
100 struct cdrom_tochdr hdr
;
102 struct ioc_toc_header hdr
;
105 if (wcda
->nTracks
== 0) {
107 if (ioctl(wcda
->unixdev
, CDROMREADTOCHDR
, &hdr
)) {
109 if (ioctl(wcda
->unixdev
, CDIOREADTOCHEADER
, &hdr
)) {
111 WARN(cdaudio
, "(%p) -- Error occured (%d)!\n", wcda
, errno
);
115 wcda
->nTracks
= hdr
.cdth_trk1
;
117 wcda
->nTracks
= hdr
.ending_track
- hdr
.starting_track
+ 1;
120 return wcda
->nTracks
;
126 /**************************************************************************
127 * CDAUDIO_GetTracksInfo [internal]
129 static BOOL32
CDAUDIO_GetTracksInfo(WINE_CDAUDIO
* wcda
)
131 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
133 int start
, last_start
= 0;
134 int total_length
= 0;
136 struct cdrom_tocentry entry
;
138 struct ioc_read_toc_entry entry
;
139 struct cd_toc_entry toc_buffer
;
142 if (wcda
->nTracks
== 0) {
143 if (CDAUDIO_GetNumberOfTracks(wcda
) == (WORD
)-1) return FALSE
;
145 TRACE(cdaudio
,"nTracks=%u\n", wcda
->nTracks
);
147 if (wcda
->lpdwTrackLen
!= NULL
)
148 free(wcda
->lpdwTrackLen
);
149 wcda
->lpdwTrackLen
= (LPDWORD
)malloc((wcda
->nTracks
+ 1) * sizeof(DWORD
));
150 if (wcda
->lpdwTrackPos
!= NULL
)
151 free(wcda
->lpdwTrackPos
);
152 wcda
->lpdwTrackPos
= (LPDWORD
)malloc((wcda
->nTracks
+ 1) * sizeof(DWORD
));
153 if (wcda
->lpbTrackFlags
!= NULL
)
154 free(wcda
->lpbTrackFlags
);
155 wcda
->lpbTrackFlags
= (LPBYTE
)malloc((wcda
->nTracks
+ 1) * sizeof(BYTE
));
156 if (wcda
->lpdwTrackLen
== NULL
|| wcda
->lpdwTrackPos
== NULL
||
157 wcda
->lpbTrackFlags
== NULL
) {
158 WARN(cdaudio
, "error allocating track table !\n");
161 memset(wcda
->lpdwTrackLen
, 0, (wcda
->nTracks
+ 1) * sizeof(DWORD
));
162 memset(wcda
->lpdwTrackPos
, 0, (wcda
->nTracks
+ 1) * sizeof(DWORD
));
163 memset(wcda
->lpbTrackFlags
, 0, (wcda
->nTracks
+ 1) * sizeof(BYTE
));
164 for (i
= 0; i
<= wcda
->nTracks
; i
++) {
165 if (i
== wcda
->nTracks
)
167 entry
.cdte_track
= CDROM_LEADOUT
;
170 entry
.starting_track
= LEADOUT
; /* XXX */
174 entry
.cdte_track
= i
+ 1;
176 entry
.starting_track
= i
+ 1;
179 entry
.cdte_format
= CDROM_MSF
;
181 bzero((char *)&toc_buffer
, sizeof(toc_buffer
));
182 entry
.address_format
= CD_MSF_FORMAT
;
183 entry
.data_len
= sizeof(toc_buffer
);
184 entry
.data
= &toc_buffer
;
187 if (ioctl(wcda
->unixdev
, CDROMREADTOCENTRY
, &entry
)) {
189 if (ioctl(wcda
->unixdev
, CDIOREADTOCENTRYS
, &entry
)) {
191 WARN(cdaudio
, "error read entry (%d)\n", errno
);
195 start
= CDFRAMES_PERSEC
* (SECONDS_PERMIN
*
196 entry
.cdte_addr
.msf
.minute
+ entry
.cdte_addr
.msf
.second
) +
197 entry
.cdte_addr
.msf
.frame
;
199 start
= CDFRAMES_PERSEC
* (SECONDS_PERMIN
*
200 toc_buffer
.addr
.msf
.minute
+ toc_buffer
.addr
.msf
.second
) +
201 toc_buffer
.addr
.msf
.frame
;
205 wcda
->dwFirstOffset
= start
;
206 TRACE(cdaudio
, "dwFirstOffset=%u\n", start
);
208 length
= start
- last_start
;
210 start
= last_start
- length
;
211 total_length
+= length
;
212 wcda
->lpdwTrackLen
[i
- 1] = length
;
213 wcda
->lpdwTrackPos
[i
- 1] = start
;
214 TRACE(cdaudio
, "track #%u start=%u len=%u\n", i
, start
, length
);
217 wcda
->lpbTrackFlags
[i
] =
218 (entry
.cdte_adr
<< 4) | (entry
.cdte_ctrl
& 0x0f);
220 wcda
->lpbTrackFlags
[i
] =
221 (toc_buffer
.addr_type
<< 4) | (toc_buffer
.control
& 0x0f);
223 TRACE(cdaudio
, "track #%u flags=%02x\n", i
+ 1, wcda
->lpbTrackFlags
[i
]);
225 wcda
->dwTotalLen
= total_length
;
226 TRACE(cdaudio
,"total_len=%u\n", total_length
);
233 /**************************************************************************
235 * CDAUDIO_CalcFrame [internal]
237 static DWORD
CDAUDIO_CalcFrame(WINE_CDAUDIO
* wcda
, DWORD dwTime
)
240 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
243 TRACE(cdaudio
,"(%p, %08lX, %lu);\n", wcda
, wcda
->dwTimeFormat
, dwTime
);
245 switch (wcda
->dwTimeFormat
) {
246 case MCI_FORMAT_MILLISECONDS
:
247 dwFrame
= dwTime
* CDFRAMES_PERSEC
/ 1000;
248 TRACE(cdaudio
, "MILLISECONDS %lu\n", dwFrame
);
251 TRACE(cdaudio
, "MSF %02u:%02u:%02u\n",
252 MCI_MSF_MINUTE(dwTime
), MCI_MSF_SECOND(dwTime
), MCI_MSF_FRAME(dwTime
));
253 dwFrame
+= CDFRAMES_PERMIN
* MCI_MSF_MINUTE(dwTime
);
254 dwFrame
+= CDFRAMES_PERSEC
* MCI_MSF_SECOND(dwTime
);
255 dwFrame
+= MCI_MSF_FRAME(dwTime
);
257 case MCI_FORMAT_TMSF
:
259 /* unknown format ! force TMSF ! ... */
260 wTrack
= MCI_TMSF_TRACK(dwTime
);
261 TRACE(cdaudio
, "MSF %02u-%02u:%02u:%02u\n",
262 MCI_TMSF_TRACK(dwTime
), MCI_TMSF_MINUTE(dwTime
),
263 MCI_TMSF_SECOND(dwTime
), MCI_TMSF_FRAME(dwTime
));
264 TRACE(cdaudio
, "TMSF trackpos[%u]=%lu\n",
265 wTrack
, wcda
->lpdwTrackPos
[wTrack
- 1]);
266 dwFrame
= wcda
->lpdwTrackPos
[wTrack
- 1];
267 dwFrame
+= CDFRAMES_PERMIN
* MCI_TMSF_MINUTE(dwTime
);
268 dwFrame
+= CDFRAMES_PERSEC
* MCI_TMSF_SECOND(dwTime
);
269 dwFrame
+= MCI_TMSF_FRAME(dwTime
);
276 /**************************************************************************
277 * CDAUDIO_GetCDStatus [internal]
279 static BOOL32
CDAUDIO_GetCDStatus(WINE_CDAUDIO
* wcda
)
281 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
282 int oldmode
= wcda
->cdMode
;
284 wcda
->sc
.cdsc_format
= CDROM_MSF
;
286 struct ioc_read_subchannel read_sc
;
288 read_sc
.address_format
= CD_MSF_FORMAT
;
289 read_sc
.data_format
= CD_CURRENT_POSITION
;
291 read_sc
.data_len
= sizeof(wcda
->sc
);
292 read_sc
.data
= (struct cd_sub_channel_info
*)&wcda
->sc
;
295 if (ioctl(wcda
->unixdev
, CDROMSUBCHNL
, &wcda
->sc
)) {
297 if (ioctl(wcda
->unixdev
, CDIOCREADSUBCHANNEL
, &read_sc
)) {
299 TRACE(cdaudio
,"opened or no_media (%d)!\n", errno
);
300 wcda
->cdMode
= MCI_MODE_OPEN
; /* was NOT_READY */
305 wcda
->sc
.cdsc_audiostatus
307 wcda
->sc
.header
.audio_status
311 case CDROM_AUDIO_INVALID
:
313 case CD_AS_AUDIO_INVALID
:
315 WARN(cdaudio
, "device doesn't support status, using MCI status.\n");
319 case CDROM_AUDIO_NO_STATUS
:
321 case CD_AS_NO_STATUS
:
323 wcda
->cdMode
= MCI_MODE_STOP
;
324 TRACE(cdaudio
,"MCI_MODE_STOP !\n");
327 case CDROM_AUDIO_PLAY
:
329 case CD_AS_PLAY_IN_PROGRESS
:
331 wcda
->cdMode
= MCI_MODE_PLAY
;
332 TRACE(cdaudio
,"MCI_MODE_PLAY !\n");
335 case CDROM_AUDIO_PAUSED
:
337 case CD_AS_PLAY_PAUSED
:
339 wcda
->cdMode
= MCI_MODE_PAUSE
;
340 TRACE(cdaudio
,"MCI_MODE_PAUSE !\n");
344 TRACE(cdaudio
,"status=%02X !\n",
345 wcda
->sc
.cdsc_audiostatus
);
347 TRACE(cdaudio
,"status=%02X !\n",
348 wcda
->sc
.header
.audio_status
);
352 wcda
->nCurTrack
= wcda
->sc
.cdsc_trk
;
354 CDFRAMES_PERMIN
* wcda
->sc
.cdsc_absaddr
.msf
.minute
+
355 CDFRAMES_PERSEC
* wcda
->sc
.cdsc_absaddr
.msf
.second
+
356 wcda
->sc
.cdsc_absaddr
.msf
.frame
;
358 wcda
->nCurTrack
= wcda
->sc
.what
.position
.track_number
;
360 CDFRAMES_PERMIN
* wcda
->sc
.what
.position
.absaddr
.msf
.minute
+
361 CDFRAMES_PERSEC
* wcda
->sc
.what
.position
.absaddr
.msf
.second
+
362 wcda
->sc
.what
.position
.absaddr
.msf
.frame
;
365 TRACE(cdaudio
,"%02u-%02u:%02u:%02u \n",
367 wcda
->sc
.cdsc_absaddr
.msf
.minute
,
368 wcda
->sc
.cdsc_absaddr
.msf
.second
,
369 wcda
->sc
.cdsc_absaddr
.msf
.frame
);
371 TRACE(cdaudio
,"%02u-%02u:%02u:%02u \n",
372 wcda
->sc
.what
.position
.track_number
,
373 wcda
->sc
.what
.position
.absaddr
.msf
.minute
,
374 wcda
->sc
.what
.position
.absaddr
.msf
.second
,
375 wcda
->sc
.what
.position
.absaddr
.msf
.frame
);
378 if (oldmode
!= wcda
->cdMode
&& oldmode
== MCI_MODE_OPEN
) {
379 if (!CDAUDIO_GetTracksInfo(wcda
)) {
380 WARN(cdaudio
, "error updating TracksInfo !\n");
390 /**************************************************************************
391 * CDAUDIO_CalcTime [internal]
393 static DWORD
CDAUDIO_CalcTime(WINE_CDAUDIO
* wcda
, DWORD dwFrame
)
396 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
402 TRACE(cdaudio
,"(%p, %08lX, %lu);\n", wcda
, wcda
->dwTimeFormat
, dwFrame
);
404 switch (wcda
->dwTimeFormat
) {
405 case MCI_FORMAT_MILLISECONDS
:
406 dwTime
= dwFrame
/ CDFRAMES_PERSEC
* 1000;
407 TRACE(cdaudio
, "MILLISECONDS %lu\n", dwTime
);
410 wMinutes
= dwFrame
/ CDFRAMES_PERMIN
;
411 wSeconds
= (dwFrame
- CDFRAMES_PERMIN
* wMinutes
) / CDFRAMES_PERSEC
;
412 wFrames
= dwFrame
- CDFRAMES_PERMIN
* wMinutes
- CDFRAMES_PERSEC
* wSeconds
;
413 dwTime
= MCI_MAKE_MSF(wMinutes
, wSeconds
, wFrames
);
414 TRACE(cdaudio
,"MSF %02u:%02u:%02u -> dwTime=%lu\n",wMinutes
, wSeconds
, wFrames
, dwTime
);
416 case MCI_FORMAT_TMSF
:
418 /* unknown format ! force TMSF ! ... */
419 for (wTrack
= 0; wTrack
< wcda
->nTracks
; wTrack
++) {
420 /* dwTime += wcda->lpdwTrackLen[wTrack - 1];
421 TRACE(cdaudio, "Adding trk#%u curpos=%u \n", dwTime);
422 if (dwTime >= dwFrame) break; */
423 if (wcda
->lpdwTrackPos
[wTrack
- 1] >= dwFrame
) break;
425 wMinutes
= dwFrame
/ CDFRAMES_PERMIN
;
426 wSeconds
= (dwFrame
- CDFRAMES_PERMIN
* wMinutes
) / CDFRAMES_PERSEC
;
427 wFrames
= dwFrame
- CDFRAMES_PERMIN
* wMinutes
- CDFRAMES_PERSEC
* wSeconds
;
428 dwTime
= MCI_MAKE_TMSF(wTrack
, wMinutes
, wSeconds
, wFrames
);
429 TRACE(cdaudio
, "%02u-%02u:%02u:%02u\n", wTrack
, wMinutes
, wSeconds
, wFrames
);
436 static DWORD
CDAUDIO_mciSeek(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SEEK_PARMS lpParms
);
437 static DWORD
CDAUDIO_mciStop(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
);
439 /**************************************************************************
440 * CDAUDIO_mciOpen [internal]
442 static DWORD
CDAUDIO_mciOpen(UINT16 wDevID
, DWORD dwFlags
, LPMCI_OPEN_PARMS32A lpOpenParms
)
444 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
447 MCI_SEEK_PARMS seekParms
;
449 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpOpenParms
);
451 if (lpOpenParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
452 if (wDevID
> MAX_CDAUDIODRV
) return MCIERR_INVALID_DEVICE_ID
;
454 dwDeviceID
= lpOpenParms
->wDeviceID
;
456 wcda
= &CDADev
[wDevID
];
458 if (wcda
->nUseCount
> 0) {
459 /* The driver already open on this channel */
460 /* If the driver was opened shareable before and this open specifies */
461 /* shareable then increment the use count */
462 if (wcda
->fShareable
&& (dwFlags
& MCI_OPEN_SHAREABLE
))
465 return MCIERR_MUST_USE_SHAREABLE
;
468 wcda
->fShareable
= dwFlags
& MCI_OPEN_SHAREABLE
;
470 if (dwFlags
& MCI_OPEN_ELEMENT
) {
471 TRACE(cdaudio
,"MCI_OPEN_ELEMENT !\n");
472 /* return MCIERR_NO_ELEMENT_ALLOWED; */
475 wcda
->openParms
.dwCallback
= lpOpenParms
->dwCallback
;
476 wcda
->openParms
.wDeviceID
= (WORD
)lpOpenParms
->wDeviceID
;
477 wcda
->openParms
.wReserved0
= 0; /*????*/
478 wcda
->openParms
.lpstrDeviceType
= lpOpenParms
->lpstrDeviceType
;
479 wcda
->openParms
.lpstrElementName
= lpOpenParms
->lpstrElementName
;
480 wcda
->openParms
.lpstrAlias
= lpOpenParms
->lpstrAlias
;
482 wcda
->wNotifyDeviceID
= dwDeviceID
;
483 wcda
->unixdev
= open (CDAUDIO_DEV
, O_RDONLY
, 0);
484 if (wcda
->unixdev
== -1) {
485 WARN(cdaudio
,"can't open '%s'!. errno=%d\n", CDAUDIO_DEV
, errno
);
486 perror( "can't open\n");
487 return MCIERR_HARDWARE
;
490 wcda
->mciMode
= MCI_MODE_STOP
;
491 wcda
->dwTimeFormat
= MCI_FORMAT_TMSF
;
494 wcda
->dwTotalLen
= 0;
495 wcda
->dwFirstOffset
= 0;
496 wcda
->lpdwTrackLen
= NULL
;
497 wcda
->lpdwTrackPos
= NULL
;
498 wcda
->lpbTrackFlags
= NULL
;
499 if (!CDAUDIO_GetTracksInfo(&CDADev
[wDevID
])) {
500 WARN(cdaudio
,"error reading TracksInfo !\n");
501 /* return MCIERR_INTERNAL; */
504 CDAUDIO_mciSeek(wDevID
, MCI_SEEK_TO_START
, &seekParms
);
508 return MCIERR_HARDWARE
;
512 /**************************************************************************
513 * CDAUDIO_mciClose [internal]
515 static DWORD
CDAUDIO_mciClose(UINT16 wDevID
, DWORD dwParam
, LPMCI_GENERIC_PARMS lpParms
)
517 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
518 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
520 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwParam
, lpParms
);
522 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
524 if (wcda
->nUseCount
== 1) {
525 CDAUDIO_mciStop(wDevID
, 0, NULL
);
527 if (wcda
->lpdwTrackLen
!= NULL
) free(wcda
->lpdwTrackLen
);
528 if (wcda
->lpdwTrackPos
!= NULL
) free(wcda
->lpdwTrackPos
);
529 if (wcda
->lpbTrackFlags
!= NULL
) free(wcda
->lpbTrackFlags
);
530 close(wcda
->unixdev
);
537 /**************************************************************************
538 * CDAUDIO_mciGetDevCaps [internal]
540 static DWORD
CDAUDIO_mciGetDevCaps(UINT16 wDevID
, DWORD dwFlags
,
541 LPMCI_GETDEVCAPS_PARMS lpParms
)
543 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
544 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
546 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
548 if (dwFlags
& MCI_GETDEVCAPS_ITEM
) {
549 TRACE(cdaudio
, "MCI_GETDEVCAPS_ITEM dwItem=%08lX;\n", lpParms
->dwItem
);
551 switch(lpParms
->dwItem
) {
552 case MCI_GETDEVCAPS_CAN_RECORD
:
553 lpParms
->dwReturn
= FALSE
;
555 case MCI_GETDEVCAPS_HAS_AUDIO
:
556 lpParms
->dwReturn
= TRUE
;
558 case MCI_GETDEVCAPS_HAS_VIDEO
:
559 lpParms
->dwReturn
= FALSE
;
561 case MCI_GETDEVCAPS_DEVICE_TYPE
:
562 lpParms
->dwReturn
= MCI_DEVTYPE_CD_AUDIO
;
564 case MCI_GETDEVCAPS_USES_FILES
:
565 lpParms
->dwReturn
= FALSE
;
567 case MCI_GETDEVCAPS_COMPOUND_DEVICE
:
568 lpParms
->dwReturn
= FALSE
;
570 case MCI_GETDEVCAPS_CAN_EJECT
:
571 lpParms
->dwReturn
= TRUE
;
573 case MCI_GETDEVCAPS_CAN_PLAY
:
574 lpParms
->dwReturn
= TRUE
;
576 case MCI_GETDEVCAPS_CAN_SAVE
:
577 lpParms
->dwReturn
= FALSE
;
580 return MCIERR_UNRECOGNIZED_COMMAND
;
583 TRACE(cdaudio
, "lpParms->dwReturn=%08lX;\n", lpParms
->dwReturn
);
586 return MCIERR_HARDWARE
;
590 /**************************************************************************
591 * CDAUDIO_mciInfo [internal]
593 static DWORD
CDAUDIO_mciInfo(UINT16 wDevID
, DWORD dwFlags
, LPMCI_INFO_PARMS16 lpParms
)
595 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
598 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
600 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
602 if (lpParms
== NULL
|| lpParms
->lpstrReturn
== NULL
) {
603 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
604 } else if (wcda
== NULL
) {
605 ret
= MCIERR_INVALID_DEVICE_ID
;
607 TRACE(cdaudio
, "buf=%p, len=%lu\n", lpParms
->lpstrReturn
, lpParms
->dwRetSize
);
610 case MCI_INFO_PRODUCT
:
611 str
= "Wine's audio CD";
614 WARN(cdaudio
, "Don't know this info command (%lu)\n", dwFlags
);
615 ret
= MCIERR_UNRECOGNIZED_COMMAND
;
619 ret
= MCI_WriteString(lpParms
->lpstrReturn
, lpParms
->dwRetSize
, str
);
621 lpParms
->lpstrReturn
[0] = 0;
626 return MCIERR_HARDWARE
;
630 /**************************************************************************
631 * CDAUDIO_mciStatus [internal]
633 static DWORD
CDAUDIO_mciStatus(UINT16 wDevID
, DWORD dwFlags
, LPMCI_STATUS_PARMS lpParms
)
635 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
636 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
639 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
641 if (lpParms
== NULL
) {
642 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
643 } else if (wcda
== NULL
) {
644 ret
= MCIERR_INVALID_DEVICE_ID
;
646 if (dwFlags
& MCI_NOTIFY
) {
647 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
648 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
649 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
651 if (dwFlags
& MCI_STATUS_ITEM
) {
652 switch(lpParms
->dwItem
) {
653 case MCI_STATUS_CURRENT_TRACK
:
654 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
655 lpParms
->dwReturn
= wcda
->nCurTrack
;
656 TRACE(cdaudio
,"CURRENT_TRACK=%lu!\n", lpParms
->dwReturn
);
658 case MCI_STATUS_LENGTH
:
659 if (wcda
->nTracks
== 0) {
660 if (!CDAUDIO_GetTracksInfo(wcda
)) {
661 WARN(cdaudio
, "error reading TracksInfo !\n");
662 return MCIERR_DRIVER_INTERNAL
;
665 if (dwFlags
& MCI_TRACK
) {
666 TRACE(cdaudio
,"MCI_TRACK #%lu LENGTH=??? !\n", lpParms
->dwTrack
);
667 if (lpParms
->dwTrack
> wcda
->nTracks
)
668 return MCIERR_OUTOFRANGE
;
669 lpParms
->dwReturn
= wcda
->lpdwTrackLen
[lpParms
->dwTrack
- 1];
671 lpParms
->dwReturn
= wcda
->dwTotalLen
;
673 lpParms
->dwReturn
= CDAUDIO_CalcTime(wcda
, lpParms
->dwReturn
);
674 TRACE(cdaudio
,"LENGTH=%lu !\n", lpParms
->dwReturn
);
676 case MCI_STATUS_MODE
:
677 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
678 lpParms
->dwReturn
= wcda
->cdMode
;
679 if (!lpParms
->dwReturn
) lpParms
->dwReturn
= wcda
->mciMode
;
680 TRACE(cdaudio
,"MCI_STATUS_MODE=%08lX !\n", lpParms
->dwReturn
);
682 case MCI_STATUS_MEDIA_PRESENT
:
683 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
684 lpParms
->dwReturn
= (wcda
->nTracks
> 0) ? TRUE
: FALSE
;
685 TRACE(cdaudio
,"MCI_STATUS_MEDIA_PRESENT =%s!\n", lpParms
->dwReturn
? "Y" : "N");
687 case MCI_STATUS_NUMBER_OF_TRACKS
:
688 lpParms
->dwReturn
= CDAUDIO_GetNumberOfTracks(wcda
);
689 TRACE(cdaudio
,"MCI_STATUS_NUMBER_OF_TRACKS = %lu !\n", lpParms
->dwReturn
);
690 if (lpParms
->dwReturn
== (WORD
)-1) return MCIERR_DRIVER_INTERNAL
;
692 case MCI_STATUS_POSITION
:
693 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
694 lpParms
->dwReturn
= wcda
->dwCurFrame
;
695 if (dwFlags
& MCI_STATUS_START
) {
696 lpParms
->dwReturn
= wcda
->dwFirstOffset
;
697 TRACE(cdaudio
,"get MCI_STATUS_START !\n");
699 if (dwFlags
& MCI_TRACK
) {
700 if (lpParms
->dwTrack
> wcda
->nTracks
)
701 return MCIERR_OUTOFRANGE
;
702 lpParms
->dwReturn
= wcda
->lpdwTrackPos
[lpParms
->dwTrack
- 1];
703 TRACE(cdaudio
,"get MCI_TRACK #%lu !\n", lpParms
->dwTrack
);
705 lpParms
->dwReturn
= CDAUDIO_CalcTime(wcda
, lpParms
->dwReturn
);
706 TRACE(cdaudio
,"MCI_STATUS_POSITION=%08lX !\n", lpParms
->dwReturn
);
708 case MCI_STATUS_READY
:
709 TRACE(cdaudio
,"MCI_STATUS_READY !\n");
710 lpParms
->dwReturn
= TRUE
;
712 case MCI_STATUS_TIME_FORMAT
:
713 lpParms
->dwReturn
= wcda
->dwTimeFormat
;
714 TRACE(cdaudio
,"MCI_STATUS_TIME_FORMAT =%08lx!\n", lpParms
->dwReturn
);
716 /* FIXME: the constant used here are not defined in mmsystem.h */
717 /* MCI_CDA_STATUS_TYPE_TRACK is very likely to be 0x00004001 */
718 case MCI_CDA_STATUS_TYPE_TRACK
:
719 if (!(dwFlags
& MCI_TRACK
)) return MCIERR_MISSING_PARAMETER
;
720 lpParms
->dwReturn
= (wcda
->lpbTrackFlags
[lpParms
->dwTrack
- 1] &
721 CDROM_DATA_TRACK
) ? MCI_CDA_TRACK_OTHER
: MCI_CDA_TRACK_AUDIO
;
722 TRACE(cdaudio
, "MCI_CDA_STATUS_TYPE_TRACK[%ld]=%08lx\n", lpParms
->dwTrack
, lpParms
->dwReturn
);
725 WARN(cdaudio
, "unknown command %08lX !\n", lpParms
->dwItem
);
726 return MCIERR_UNRECOGNIZED_COMMAND
;
730 WARN(cdaudio
, "not MCI_STATUS_ITEM !\n");
733 return MCIERR_HARDWARE
;
737 /**************************************************************************
738 * CDAUDIO_mciPlay [internal]
740 static DWORD
CDAUDIO_mciPlay(UINT16 wDevID
, DWORD dwFlags
, LPMCI_PLAY_PARMS lpParms
)
742 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
744 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
747 struct cdrom_msf msf
;
749 struct ioc_play_msf msf
;
752 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
754 if (lpParms
== NULL
) {
755 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
756 } else if (wcda
== NULL
) {
757 ret
= MCIERR_INVALID_DEVICE_ID
;
759 end
= wcda
->dwTotalLen
;
761 if (dwFlags
& MCI_FROM
) {
762 start
= CDAUDIO_CalcFrame(wcda
, lpParms
->dwFrom
);
763 TRACE(cdaudio
,"MCI_FROM=%08lX -> %u \n", lpParms
->dwFrom
, start
);
765 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
766 start
= wcda
->dwCurFrame
;
768 if (dwFlags
& MCI_TO
) {
769 end
= CDAUDIO_CalcFrame(wcda
, lpParms
->dwTo
);
770 TRACE(cdaudio
, "MCI_TO=%08lX -> %u \n", lpParms
->dwTo
, end
);
772 end
+= wcda
->dwFirstOffset
;
774 msf
.cdmsf_min0
= start
/ CDFRAMES_PERMIN
;
775 msf
.cdmsf_sec0
= (start
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
776 msf
.cdmsf_frame0
= start
% CDFRAMES_PERSEC
;
777 msf
.cdmsf_min1
= end
/ CDFRAMES_PERMIN
;
778 msf
.cdmsf_sec1
= (end
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
779 msf
.cdmsf_frame1
= end
% CDFRAMES_PERSEC
;
781 msf
.start_m
= start
/ CDFRAMES_PERMIN
;
782 msf
.start_s
= (start
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
783 msf
.start_f
= start
% CDFRAMES_PERSEC
;
784 msf
.end_m
= end
/ CDFRAMES_PERMIN
;
785 msf
.end_s
= (end
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
786 msf
.end_f
= end
% CDFRAMES_PERSEC
;
789 if (ioctl(wcda
->unixdev
, CDROMSTART
)) {
791 if (ioctl(wcda
->unixdev
, CDIOCSTART
, NULL
)) {
793 WARN(cdaudio
, "motor doesn't start !\n");
794 return MCIERR_HARDWARE
;
797 if (ioctl(wcda
->unixdev
, CDROMPLAYMSF
, &msf
)) {
799 if (ioctl(wcda
->unixdev
, CDIOCPLAYMSF
, &msf
)) {
801 WARN(cdaudio
, "device doesn't play !\n");
802 return MCIERR_HARDWARE
;
805 TRACE(cdaudio
,"msf = %d:%d:%d %d:%d:%d\n",
806 msf
.cdmsf_min0
, msf
.cdmsf_sec0
, msf
.cdmsf_frame0
,
807 msf
.cdmsf_min1
, msf
.cdmsf_sec1
, msf
.cdmsf_frame1
);
809 TRACE(cdaudio
,"msf = %d:%d:%d %d:%d:%d\n",
810 msf
.start_m
, msf
.start_s
, msf
.start_f
,
811 msf
.end_m
, msf
.end_s
, msf
.end_f
);
813 wcda
->mciMode
= MCI_MODE_PLAY
;
814 if (dwFlags
& MCI_NOTIFY
) {
815 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
817 mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
818 wcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
825 return MCIERR_HARDWARE
;
829 /**************************************************************************
830 * CDAUDIO_mciStop [internal]
832 static DWORD
CDAUDIO_mciStop(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
834 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
835 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
837 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
839 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
842 if (ioctl(wcda
->unixdev
, CDROMSTOP
))
844 if (ioctl(wcda
->unixdev
, CDIOCSTOP
, NULL
))
846 return MCIERR_HARDWARE
;
847 wcda
->mciMode
= MCI_MODE_STOP
;
848 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
849 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
850 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
851 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
855 return MCIERR_HARDWARE
;
859 /**************************************************************************
860 * CDAUDIO_mciPause [internal]
862 static DWORD
CDAUDIO_mciPause(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
864 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
865 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
867 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
869 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
872 if (ioctl(wcda
->unixdev
, CDROMPAUSE
))
874 if (ioctl(wcda
->unixdev
, CDIOCPAUSE
, NULL
))
876 return MCIERR_HARDWARE
;
877 wcda
->mciMode
= MCI_MODE_PAUSE
;
878 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
879 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
880 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
881 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
885 return MCIERR_HARDWARE
;
889 /**************************************************************************
890 * CDAUDIO_mciResume [internal]
892 static DWORD
CDAUDIO_mciResume(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
894 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
895 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
897 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
899 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
902 if (ioctl(wcda
->unixdev
, CDROMRESUME
))
904 if (ioctl(wcda
->unixdev
, CDIOCRESUME
, NULL
))
906 return MCIERR_HARDWARE
;
907 wcda
->mciMode
= MCI_MODE_STOP
;
908 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
909 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
910 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
911 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
915 return MCIERR_HARDWARE
;
919 /**************************************************************************
920 * CDAUDIO_mciSeek [internal]
922 static DWORD
CDAUDIO_mciSeek(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SEEK_PARMS lpParms
)
924 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
926 MCI_PLAY_PARMS playParms
;
928 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
930 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
932 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
933 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
935 wcda
->mciMode
= MCI_MODE_SEEK
;
936 switch (dwFlags
& ~(MCI_NOTIFY
|MCI_WAIT
)) {
937 case MCI_SEEK_TO_START
:
938 TRACE(cdaudio
, "Seeking to start\n");
939 playParms
.dwFrom
= 0;
941 case MCI_SEEK_TO_END
:
942 TRACE(cdaudio
, "Seeking to end\n");
943 playParms
.dwFrom
= wcda
->dwTotalLen
;
946 TRACE(cdaudio
, "Seeking to %lu\n", lpParms
->dwTo
);
947 playParms
.dwFrom
= lpParms
->dwTo
;
950 TRACE(cdaudio
, "Seeking to ??=%lu\n", dwFlags
);
951 return MCIERR_UNSUPPORTED_FUNCTION
;
953 dwRet
= CDAUDIO_mciPlay(wDevID
, MCI_WAIT
| MCI_FROM
, &playParms
);
954 if (dwRet
!= 0) return dwRet
;
955 dwRet
= CDAUDIO_mciStop(wDevID
, MCI_WAIT
, (LPMCI_GENERIC_PARMS
)&playParms
);
956 if (dwFlags
& MCI_NOTIFY
) {
957 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
958 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
959 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
963 return MCIERR_HARDWARE
;
967 /**************************************************************************
968 * CDAUDIO_mciSetDoor [internal]
970 static DWORD
CDAUDIO_mciSetDoor(UINT16 wDevID
, int open
)
972 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
974 TRACE(cdaudio
, "(%04x, %s) !\n", wDevID
, (open
) ? "OPEN" : "CLOSE");
976 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
980 if (ioctl(wcda
->unixdev
, CDROMEJECT
)) return MCIERR_HARDWARE
;
981 wcda
->mciMode
= MCI_MODE_OPEN
;
983 if (ioctl(wcda
->unixdev
, CDROMEJECT
, 1)) return MCIERR_HARDWARE
;
984 wcda
->mciMode
= MCI_MODE_STOP
;
987 if (ioctl(wcda
->unixdev
, CDIOCALLOW
, NULL
)) return MCIERR_HARDWARE
;
989 if (ioctl(wcda
->unixdev
, CDIOCEJECT
, NULL
)) return MCIERR_HARDWARE
;
990 wcda
->mciMode
= MCI_MODE_OPEN
;
992 if (ioctl(wcda
->unixdev
, CDIOCCLOSE
, NULL
)) return MCIERR_HARDWARE
;
993 wcda
->mciMode
= MCI_MODE_STOP
;
995 if (ioctl(wcda
->unixdev
, CDIOCPREVENT
, NULL
)) return MCIERR_HARDWARE
;
1001 /**************************************************************************
1002 * CDAUDIO_mciSet [internal]
1004 static DWORD
CDAUDIO_mciSet(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SET_PARMS lpParms
)
1006 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
1007 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
1009 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
1011 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
1012 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;;
1014 TRACE(cdaudio,"dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
1015 TRACE(cdaudio,"dwAudio=%08lX\n", lpParms->dwAudio);
1017 if (dwFlags
& MCI_SET_TIME_FORMAT
) {
1018 switch (lpParms
->dwTimeFormat
) {
1019 case MCI_FORMAT_MILLISECONDS
:
1020 TRACE(cdaudio
, "MCI_FORMAT_MILLISECONDS !\n");
1022 case MCI_FORMAT_MSF
:
1023 TRACE(cdaudio
,"MCI_FORMAT_MSF !\n");
1025 case MCI_FORMAT_TMSF
:
1026 TRACE(cdaudio
,"MCI_FORMAT_TMSF !\n");
1029 WARN(cdaudio
, "bad time format !\n");
1030 return MCIERR_BAD_TIME_FORMAT
;
1032 wcda
->dwTimeFormat
= lpParms
->dwTimeFormat
;
1034 if (dwFlags
& MCI_SET_DOOR_OPEN
) {
1035 CDAUDIO_mciSetDoor(wDevID
, TRUE
);
1037 if (dwFlags
& MCI_SET_DOOR_CLOSED
) {
1038 CDAUDIO_mciSetDoor(wDevID
, FALSE
);
1040 if (dwFlags
& MCI_SET_VIDEO
) return MCIERR_UNSUPPORTED_FUNCTION
;
1041 if (dwFlags
& MCI_SET_ON
) return MCIERR_UNSUPPORTED_FUNCTION
;
1042 if (dwFlags
& MCI_SET_OFF
) return MCIERR_UNSUPPORTED_FUNCTION
;
1043 if (dwFlags
& MCI_NOTIFY
) {
1044 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
1045 lpParms
->dwCallback
);
1046 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
1047 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
1051 return MCIERR_HARDWARE
;
1055 /**************************************************************************
1056 * MCICDAUDIO_DriverProc32 [sample driver]
1058 LONG
MCICDAUDIO_DriverProc32(DWORD dwDevID
, HDRVR16 hDriv
, DWORD wMsg
,
1059 DWORD dwParam1
, DWORD dwParam2
)
1061 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
1063 case DRV_LOAD
: return 1;
1064 case DRV_FREE
: return 1;
1065 case DRV_OPEN
: return 1;
1066 case DRV_CLOSE
: return 1;
1067 case DRV_ENABLE
: return 1;
1068 case DRV_DISABLE
: return 1;
1069 case DRV_QUERYCONFIGURE
: return 1;
1070 case DRV_CONFIGURE
: MessageBox16(0, "Sample MultiMedia Linux Driver !", "MMLinux Driver", MB_OK
); return 1;
1071 case DRV_INSTALL
: return DRVCNF_RESTART
;
1072 case DRV_REMOVE
: return DRVCNF_RESTART
;
1074 case MCI_OPEN_DRIVER
: return CDAUDIO_mciOpen(dwDevID
, dwParam1
, (LPMCI_OPEN_PARMS32A
)dwParam2
);
1075 case MCI_CLOSE_DRIVER
: return CDAUDIO_mciClose(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1076 case MCI_GETDEVCAPS
: return CDAUDIO_mciGetDevCaps(dwDevID
, dwParam1
, (LPMCI_GETDEVCAPS_PARMS
)dwParam2
);
1077 case MCI_INFO
: return CDAUDIO_mciInfo(dwDevID
, dwParam1
, (LPMCI_INFO_PARMS16
)dwParam2
);
1078 case MCI_STATUS
: return CDAUDIO_mciStatus(dwDevID
, dwParam1
, (LPMCI_STATUS_PARMS
)dwParam2
);
1079 case MCI_SET
: return CDAUDIO_mciSet(dwDevID
, dwParam1
, (LPMCI_SET_PARMS
)dwParam2
);
1080 case MCI_PLAY
: return CDAUDIO_mciPlay(dwDevID
, dwParam1
, (LPMCI_PLAY_PARMS
)dwParam2
);
1081 case MCI_STOP
: return CDAUDIO_mciStop(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1082 case MCI_PAUSE
: return CDAUDIO_mciPause(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1083 case MCI_RESUME
: return CDAUDIO_mciResume(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1084 case MCI_SEEK
: return CDAUDIO_mciSeek(dwDevID
, dwParam1
, (LPMCI_SEEK_PARMS
)dwParam2
);
1085 /* FIXME: I wonder if those two next items are really called ? */
1086 case MCI_SET_DOOR_OPEN
: return CDAUDIO_mciSetDoor(dwDevID
, TRUE
);
1087 case MCI_SET_DOOR_CLOSED
: return CDAUDIO_mciSetDoor(dwDevID
, FALSE
);
1104 WARN(cdaudio
, "Unsupported command=%s\n", MCI_CommandToString(wMsg
));
1108 FIXME(cdaudio
, "Shouldn't receive a MCI_OPEN or CLOSE message\n");
1111 TRACE(cdaudio
, "Sending msg=%s to default driver proc\n", MCI_CommandToString(wMsg
));
1112 return DefDriverProc32(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
1114 return MCIERR_UNRECOGNIZED_COMMAND
;
1116 return MCIERR_UNRECOGNIZED_COMMAND
;
1120 /*-----------------------------------------------------------------------*/