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 static WINE_CDAUDIO
* CDAUDIO_mciGetOpenDrv(UINT16 wDevID
)
86 if (wDevID
>= MAX_CDAUDIODRV
|| CDADev
[wDevID
].nUseCount
== 0 ||
87 CDADev
[wDevID
].unixdev
== 0) {
88 WARN(cdaudio
, "Invalid wDevID=%u\n", wDevID
);
91 return &CDADev
[wDevID
];
94 /**************************************************************************
95 * CDAUDIO_GetNumberOfTracks [internal]
97 static UINT16
CDAUDIO_GetNumberOfTracks(WINE_CDAUDIO
* wcda
)
99 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
101 struct cdrom_tochdr hdr
;
103 struct ioc_toc_header hdr
;
106 if (wcda
->nTracks
== 0) {
108 if (ioctl(wcda
->unixdev
, CDROMREADTOCHDR
, &hdr
)) {
110 if (ioctl(wcda
->unixdev
, CDIOREADTOCHEADER
, &hdr
)) {
112 WARN(cdaudio
, "(%p) -- Error occured (%d)!\n", wcda
, errno
);
116 wcda
->nTracks
= hdr
.cdth_trk1
;
118 wcda
->nTracks
= hdr
.ending_track
- hdr
.starting_track
+ 1;
121 return wcda
->nTracks
;
127 /**************************************************************************
128 * CDAUDIO_GetTracksInfo [internal]
130 static BOOL32
CDAUDIO_GetTracksInfo(WINE_CDAUDIO
* wcda
)
132 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
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
);
234 /**************************************************************************
236 * CDAUDIO_CalcFrame [internal]
238 static DWORD
CDAUDIO_CalcFrame(WINE_CDAUDIO
* wcda
, DWORD dwTime
)
241 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
244 TRACE(cdaudio
,"(%p, %08lX, %lu);\n", wcda
, wcda
->dwTimeFormat
, dwTime
);
246 switch (wcda
->dwTimeFormat
) {
247 case MCI_FORMAT_MILLISECONDS
:
248 dwFrame
= dwTime
* CDFRAMES_PERSEC
/ 1000;
249 TRACE(cdaudio
, "MILLISECONDS %lu\n", dwFrame
);
252 TRACE(cdaudio
, "MSF %02u:%02u:%02u\n",
253 MCI_MSF_MINUTE(dwTime
), MCI_MSF_SECOND(dwTime
), MCI_MSF_FRAME(dwTime
));
254 dwFrame
+= CDFRAMES_PERMIN
* MCI_MSF_MINUTE(dwTime
);
255 dwFrame
+= CDFRAMES_PERSEC
* MCI_MSF_SECOND(dwTime
);
256 dwFrame
+= MCI_MSF_FRAME(dwTime
);
258 case MCI_FORMAT_TMSF
:
260 /* unknown format ! force TMSF ! ... */
261 wTrack
= MCI_TMSF_TRACK(dwTime
);
262 TRACE(cdaudio
, "MSF %02u-%02u:%02u:%02u\n",
263 MCI_TMSF_TRACK(dwTime
), MCI_TMSF_MINUTE(dwTime
),
264 MCI_TMSF_SECOND(dwTime
), MCI_TMSF_FRAME(dwTime
));
265 TRACE(cdaudio
, "TMSF trackpos[%u]=%lu\n",
266 wTrack
, wcda
->lpdwTrackPos
[wTrack
- 1]);
267 dwFrame
= wcda
->lpdwTrackPos
[wTrack
- 1];
268 dwFrame
+= CDFRAMES_PERMIN
* MCI_TMSF_MINUTE(dwTime
);
269 dwFrame
+= CDFRAMES_PERSEC
* MCI_TMSF_SECOND(dwTime
);
270 dwFrame
+= MCI_TMSF_FRAME(dwTime
);
277 /**************************************************************************
278 * CDAUDIO_GetCDStatus [internal]
280 static BOOL32
CDAUDIO_GetCDStatus(WINE_CDAUDIO
* wcda
)
282 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
283 int oldmode
= wcda
->cdMode
;
285 wcda
->sc
.cdsc_format
= CDROM_MSF
;
287 struct ioc_read_subchannel read_sc
;
289 read_sc
.address_format
= CD_MSF_FORMAT
;
290 read_sc
.data_format
= CD_CURRENT_POSITION
;
292 read_sc
.data_len
= sizeof(wcda
->sc
);
293 read_sc
.data
= (struct cd_sub_channel_info
*)&wcda
->sc
;
296 if (ioctl(wcda
->unixdev
, CDROMSUBCHNL
, &wcda
->sc
)) {
298 if (ioctl(wcda
->unixdev
, CDIOCREADSUBCHANNEL
, &read_sc
)) {
300 TRACE(cdaudio
,"opened or no_media (%d)!\n", errno
);
301 wcda
->cdMode
= MCI_MODE_OPEN
; /* was NOT_READY */
306 wcda
->sc
.cdsc_audiostatus
308 wcda
->sc
.header
.audio_status
312 case CDROM_AUDIO_INVALID
:
314 case CD_AS_AUDIO_INVALID
:
316 WARN(cdaudio
, "device doesn't support status, using MCI status.\n");
320 case CDROM_AUDIO_NO_STATUS
:
322 case CD_AS_NO_STATUS
:
324 wcda
->cdMode
= MCI_MODE_STOP
;
325 TRACE(cdaudio
,"MCI_MODE_STOP !\n");
328 case CDROM_AUDIO_PLAY
:
330 case CD_AS_PLAY_IN_PROGRESS
:
332 wcda
->cdMode
= MCI_MODE_PLAY
;
333 TRACE(cdaudio
,"MCI_MODE_PLAY !\n");
336 case CDROM_AUDIO_PAUSED
:
338 case CD_AS_PLAY_PAUSED
:
340 wcda
->cdMode
= MCI_MODE_PAUSE
;
341 TRACE(cdaudio
,"MCI_MODE_PAUSE !\n");
345 TRACE(cdaudio
,"status=%02X !\n",
346 wcda
->sc
.cdsc_audiostatus
);
348 TRACE(cdaudio
,"status=%02X !\n",
349 wcda
->sc
.header
.audio_status
);
353 wcda
->nCurTrack
= wcda
->sc
.cdsc_trk
;
355 CDFRAMES_PERMIN
* wcda
->sc
.cdsc_absaddr
.msf
.minute
+
356 CDFRAMES_PERSEC
* wcda
->sc
.cdsc_absaddr
.msf
.second
+
357 wcda
->sc
.cdsc_absaddr
.msf
.frame
;
359 wcda
->nCurTrack
= wcda
->sc
.what
.position
.track_number
;
361 CDFRAMES_PERMIN
* wcda
->sc
.what
.position
.absaddr
.msf
.minute
+
362 CDFRAMES_PERSEC
* wcda
->sc
.what
.position
.absaddr
.msf
.second
+
363 wcda
->sc
.what
.position
.absaddr
.msf
.frame
;
366 TRACE(cdaudio
,"%02u-%02u:%02u:%02u \n",
368 wcda
->sc
.cdsc_absaddr
.msf
.minute
,
369 wcda
->sc
.cdsc_absaddr
.msf
.second
,
370 wcda
->sc
.cdsc_absaddr
.msf
.frame
);
372 TRACE(cdaudio
,"%02u-%02u:%02u:%02u \n",
373 wcda
->sc
.what
.position
.track_number
,
374 wcda
->sc
.what
.position
.absaddr
.msf
.minute
,
375 wcda
->sc
.what
.position
.absaddr
.msf
.second
,
376 wcda
->sc
.what
.position
.absaddr
.msf
.frame
);
379 if (oldmode
!= wcda
->cdMode
&& oldmode
== MCI_MODE_OPEN
) {
380 if (!CDAUDIO_GetTracksInfo(wcda
)) {
381 WARN(cdaudio
, "error updating TracksInfo !\n");
391 /**************************************************************************
392 * CDAUDIO_CalcTime [internal]
394 static DWORD
CDAUDIO_CalcTime(WINE_CDAUDIO
* wcda
, DWORD dwFrame
)
397 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
403 TRACE(cdaudio
,"(%p, %08lX, %lu);\n", wcda
, wcda
->dwTimeFormat
, dwFrame
);
405 switch (wcda
->dwTimeFormat
) {
406 case MCI_FORMAT_MILLISECONDS
:
407 dwTime
= dwFrame
/ CDFRAMES_PERSEC
* 1000;
408 TRACE(cdaudio
, "MILLISECONDS %lu\n", dwTime
);
411 wMinutes
= dwFrame
/ CDFRAMES_PERMIN
;
412 wSeconds
= (dwFrame
- CDFRAMES_PERMIN
* wMinutes
) / CDFRAMES_PERSEC
;
413 wFrames
= dwFrame
- CDFRAMES_PERMIN
* wMinutes
- CDFRAMES_PERSEC
* wSeconds
;
414 dwTime
= MCI_MAKE_MSF(wMinutes
, wSeconds
, wFrames
);
415 TRACE(cdaudio
,"MSF %02u:%02u:%02u -> dwTime=%lu\n",wMinutes
, wSeconds
, wFrames
, dwTime
);
417 case MCI_FORMAT_TMSF
:
419 /* unknown format ! force TMSF ! ... */
420 for (wTrack
= 0; wTrack
< wcda
->nTracks
; wTrack
++) {
421 /* dwTime += wcda->lpdwTrackLen[wTrack - 1];
422 TRACE(cdaudio, "Adding trk#%u curpos=%u \n", dwTime);
423 if (dwTime >= dwFrame) break; */
424 if (wcda
->lpdwTrackPos
[wTrack
- 1] >= dwFrame
) break;
426 wMinutes
= dwFrame
/ CDFRAMES_PERMIN
;
427 wSeconds
= (dwFrame
- CDFRAMES_PERMIN
* wMinutes
) / CDFRAMES_PERSEC
;
428 wFrames
= dwFrame
- CDFRAMES_PERMIN
* wMinutes
- CDFRAMES_PERSEC
* wSeconds
;
429 dwTime
= MCI_MAKE_TMSF(wTrack
, wMinutes
, wSeconds
, wFrames
);
430 TRACE(cdaudio
, "%02u-%02u:%02u:%02u\n", wTrack
, wMinutes
, wSeconds
, wFrames
);
437 static DWORD
CDAUDIO_mciSeek(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SEEK_PARMS lpParms
);
438 static DWORD
CDAUDIO_mciStop(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
);
440 /**************************************************************************
441 * CDAUDIO_mciOpen [internal]
443 static DWORD
CDAUDIO_mciOpen(UINT16 wDevID
, DWORD dwFlags
, LPMCI_OPEN_PARMS32A lpOpenParms
)
445 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
448 MCI_SEEK_PARMS seekParms
;
450 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpOpenParms
);
452 if (lpOpenParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
453 if (wDevID
> MAX_CDAUDIODRV
) return MCIERR_INVALID_DEVICE_ID
;
455 dwDeviceID
= lpOpenParms
->wDeviceID
;
457 wcda
= &CDADev
[wDevID
];
459 if (wcda
->nUseCount
> 0) {
460 /* The driver already open on this channel */
461 /* If the driver was opened shareable before and this open specifies */
462 /* shareable then increment the use count */
463 if (wcda
->fShareable
&& (dwFlags
& MCI_OPEN_SHAREABLE
))
466 return MCIERR_MUST_USE_SHAREABLE
;
469 wcda
->fShareable
= dwFlags
& MCI_OPEN_SHAREABLE
;
471 if (dwFlags
& MCI_OPEN_ELEMENT
) {
472 TRACE(cdaudio
,"MCI_OPEN_ELEMENT !\n");
473 /* return MCIERR_NO_ELEMENT_ALLOWED; */
476 wcda
->openParms
.dwCallback
= lpOpenParms
->dwCallback
;
477 wcda
->openParms
.wDeviceID
= (WORD
)lpOpenParms
->wDeviceID
;
478 wcda
->openParms
.wReserved0
= 0; /*????*/
479 wcda
->openParms
.lpstrDeviceType
= lpOpenParms
->lpstrDeviceType
;
480 wcda
->openParms
.lpstrElementName
= lpOpenParms
->lpstrElementName
;
481 wcda
->openParms
.lpstrAlias
= lpOpenParms
->lpstrAlias
;
483 wcda
->wNotifyDeviceID
= dwDeviceID
;
484 wcda
->unixdev
= open (CDAUDIO_DEV
, O_RDONLY
, 0);
485 if (wcda
->unixdev
== -1) {
486 WARN(cdaudio
,"can't open '%s'!. errno=%d\n", CDAUDIO_DEV
, errno
);
487 perror( "can't open\n");
488 return MCIERR_HARDWARE
;
491 wcda
->mciMode
= MCI_MODE_STOP
;
492 wcda
->dwTimeFormat
= MCI_FORMAT_TMSF
;
495 wcda
->dwTotalLen
= 0;
496 wcda
->dwFirstOffset
= 0;
497 wcda
->lpdwTrackLen
= NULL
;
498 wcda
->lpdwTrackPos
= NULL
;
499 wcda
->lpbTrackFlags
= NULL
;
500 if (!CDAUDIO_GetTracksInfo(&CDADev
[wDevID
])) {
501 WARN(cdaudio
,"error reading TracksInfo !\n");
502 /* return MCIERR_INTERNAL; */
505 CDAUDIO_mciSeek(wDevID
, MCI_SEEK_TO_START
, &seekParms
);
509 return MCIERR_HARDWARE
;
513 /**************************************************************************
514 * CDAUDIO_mciClose [internal]
516 static DWORD
CDAUDIO_mciClose(UINT16 wDevID
, DWORD dwParam
, LPMCI_GENERIC_PARMS lpParms
)
518 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
519 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
521 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwParam
, lpParms
);
523 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
525 if (wcda
->nUseCount
== 1) {
526 CDAUDIO_mciStop(wDevID
, 0, NULL
);
528 if (wcda
->lpdwTrackLen
!= NULL
) free(wcda
->lpdwTrackLen
);
529 if (wcda
->lpdwTrackPos
!= NULL
) free(wcda
->lpdwTrackPos
);
530 if (wcda
->lpbTrackFlags
!= NULL
) free(wcda
->lpbTrackFlags
);
531 close(wcda
->unixdev
);
538 /**************************************************************************
539 * CDAUDIO_mciGetDevCaps [internal]
541 static DWORD
CDAUDIO_mciGetDevCaps(UINT16 wDevID
, DWORD dwFlags
,
542 LPMCI_GETDEVCAPS_PARMS lpParms
)
544 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
545 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
547 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
549 if (dwFlags
& MCI_GETDEVCAPS_ITEM
) {
550 TRACE(cdaudio
, "MCI_GETDEVCAPS_ITEM dwItem=%08lX;\n", lpParms
->dwItem
);
552 switch(lpParms
->dwItem
) {
553 case MCI_GETDEVCAPS_CAN_RECORD
:
554 lpParms
->dwReturn
= FALSE
;
556 case MCI_GETDEVCAPS_HAS_AUDIO
:
557 lpParms
->dwReturn
= TRUE
;
559 case MCI_GETDEVCAPS_HAS_VIDEO
:
560 lpParms
->dwReturn
= FALSE
;
562 case MCI_GETDEVCAPS_DEVICE_TYPE
:
563 lpParms
->dwReturn
= MCI_DEVTYPE_CD_AUDIO
;
565 case MCI_GETDEVCAPS_USES_FILES
:
566 lpParms
->dwReturn
= FALSE
;
568 case MCI_GETDEVCAPS_COMPOUND_DEVICE
:
569 lpParms
->dwReturn
= FALSE
;
571 case MCI_GETDEVCAPS_CAN_EJECT
:
572 lpParms
->dwReturn
= TRUE
;
574 case MCI_GETDEVCAPS_CAN_PLAY
:
575 lpParms
->dwReturn
= TRUE
;
577 case MCI_GETDEVCAPS_CAN_SAVE
:
578 lpParms
->dwReturn
= FALSE
;
581 return MCIERR_UNRECOGNIZED_COMMAND
;
584 TRACE(cdaudio
, "lpParms->dwReturn=%08lX;\n", lpParms
->dwReturn
);
587 return MCIERR_HARDWARE
;
591 /**************************************************************************
592 * CDAUDIO_mciInfo [internal]
594 static DWORD
CDAUDIO_mciInfo(UINT16 wDevID
, DWORD dwFlags
, LPMCI_INFO_PARMS16 lpParms
)
596 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
599 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
601 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
603 if (lpParms
== NULL
|| lpParms
->lpstrReturn
== NULL
) {
604 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
605 } else if (wcda
== NULL
) {
606 ret
= MCIERR_INVALID_DEVICE_ID
;
608 TRACE(cdaudio
, "buf=%p, len=%lu\n", lpParms
->lpstrReturn
, lpParms
->dwRetSize
);
611 case MCI_INFO_PRODUCT
:
612 str
= "Wine's audio CD";
615 WARN(cdaudio
, "Don't know this info command (%lu)\n", dwFlags
);
616 ret
= MCIERR_UNRECOGNIZED_COMMAND
;
620 ret
= MCI_WriteString(lpParms
->lpstrReturn
, lpParms
->dwRetSize
, str
);
622 lpParms
->lpstrReturn
[0] = 0;
627 return MCIERR_HARDWARE
;
631 /**************************************************************************
632 * CDAUDIO_mciStatus [internal]
634 static DWORD
CDAUDIO_mciStatus(UINT16 wDevID
, DWORD dwFlags
, LPMCI_STATUS_PARMS lpParms
)
636 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
637 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
640 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
642 if (lpParms
== NULL
) {
643 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
644 } else if (wcda
== NULL
) {
645 ret
= MCIERR_INVALID_DEVICE_ID
;
647 if (dwFlags
& MCI_NOTIFY
) {
648 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
649 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
650 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
652 if (dwFlags
& MCI_STATUS_ITEM
) {
653 switch(lpParms
->dwItem
) {
654 case MCI_STATUS_CURRENT_TRACK
:
655 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
656 lpParms
->dwReturn
= wcda
->nCurTrack
;
657 TRACE(cdaudio
,"CURRENT_TRACK=%lu!\n", lpParms
->dwReturn
);
659 case MCI_STATUS_LENGTH
:
660 if (wcda
->nTracks
== 0) {
661 if (!CDAUDIO_GetTracksInfo(wcda
)) {
662 WARN(cdaudio
, "error reading TracksInfo !\n");
663 return MCIERR_DRIVER_INTERNAL
;
666 if (dwFlags
& MCI_TRACK
) {
667 TRACE(cdaudio
,"MCI_TRACK #%lu LENGTH=??? !\n", lpParms
->dwTrack
);
668 if (lpParms
->dwTrack
> wcda
->nTracks
)
669 return MCIERR_OUTOFRANGE
;
670 lpParms
->dwReturn
= wcda
->lpdwTrackLen
[lpParms
->dwTrack
- 1];
672 lpParms
->dwReturn
= wcda
->dwTotalLen
;
674 lpParms
->dwReturn
= CDAUDIO_CalcTime(wcda
, lpParms
->dwReturn
);
675 TRACE(cdaudio
,"LENGTH=%lu !\n", lpParms
->dwReturn
);
677 case MCI_STATUS_MODE
:
678 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
679 lpParms
->dwReturn
= wcda
->cdMode
;
680 if (!lpParms
->dwReturn
) lpParms
->dwReturn
= wcda
->mciMode
;
681 TRACE(cdaudio
,"MCI_STATUS_MODE=%08lX !\n", lpParms
->dwReturn
);
683 case MCI_STATUS_MEDIA_PRESENT
:
684 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
685 lpParms
->dwReturn
= (wcda
->nTracks
> 0) ? TRUE
: FALSE
;
686 TRACE(cdaudio
,"MCI_STATUS_MEDIA_PRESENT =%s!\n", lpParms
->dwReturn
? "Y" : "N");
688 case MCI_STATUS_NUMBER_OF_TRACKS
:
689 lpParms
->dwReturn
= CDAUDIO_GetNumberOfTracks(wcda
);
690 TRACE(cdaudio
,"MCI_STATUS_NUMBER_OF_TRACKS = %lu !\n", lpParms
->dwReturn
);
691 if (lpParms
->dwReturn
== (WORD
)-1) return MCIERR_DRIVER_INTERNAL
;
693 case MCI_STATUS_POSITION
:
694 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
695 lpParms
->dwReturn
= wcda
->dwCurFrame
;
696 if (dwFlags
& MCI_STATUS_START
) {
697 lpParms
->dwReturn
= wcda
->dwFirstOffset
;
698 TRACE(cdaudio
,"get MCI_STATUS_START !\n");
700 if (dwFlags
& MCI_TRACK
) {
701 if (lpParms
->dwTrack
> wcda
->nTracks
)
702 return MCIERR_OUTOFRANGE
;
703 lpParms
->dwReturn
= wcda
->lpdwTrackPos
[lpParms
->dwTrack
- 1];
704 TRACE(cdaudio
,"get MCI_TRACK #%lu !\n", lpParms
->dwTrack
);
706 lpParms
->dwReturn
= CDAUDIO_CalcTime(wcda
, lpParms
->dwReturn
);
707 TRACE(cdaudio
,"MCI_STATUS_POSITION=%08lX !\n", lpParms
->dwReturn
);
709 case MCI_STATUS_READY
:
710 TRACE(cdaudio
,"MCI_STATUS_READY !\n");
711 lpParms
->dwReturn
= TRUE
;
713 case MCI_STATUS_TIME_FORMAT
:
714 lpParms
->dwReturn
= wcda
->dwTimeFormat
;
715 TRACE(cdaudio
,"MCI_STATUS_TIME_FORMAT =%08lx!\n", lpParms
->dwReturn
);
717 /* FIXME: the constant used here are not defined in mmsystem.h */
718 /* MCI_CDA_STATUS_TYPE_TRACK is very likely to be 0x00004001 */
719 case MCI_CDA_STATUS_TYPE_TRACK
:
720 if (!(dwFlags
& MCI_TRACK
)) return MCIERR_MISSING_PARAMETER
;
721 lpParms
->dwReturn
= (wcda
->lpbTrackFlags
[lpParms
->dwTrack
- 1] &
722 CDROM_DATA_TRACK
) ? MCI_CDA_TRACK_OTHER
: MCI_CDA_TRACK_AUDIO
;
723 TRACE(cdaudio
, "MCI_CDA_STATUS_TYPE_TRACK[%ld]=%08lx\n", lpParms
->dwTrack
, lpParms
->dwReturn
);
726 WARN(cdaudio
, "unknown command %08lX !\n", lpParms
->dwItem
);
727 return MCIERR_UNRECOGNIZED_COMMAND
;
731 WARN(cdaudio
, "not MCI_STATUS_ITEM !\n");
734 return MCIERR_HARDWARE
;
738 /**************************************************************************
739 * CDAUDIO_mciPlay [internal]
741 static DWORD
CDAUDIO_mciPlay(UINT16 wDevID
, DWORD dwFlags
, LPMCI_PLAY_PARMS lpParms
)
743 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
745 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
748 struct cdrom_msf msf
;
750 struct ioc_play_msf msf
;
753 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
755 if (lpParms
== NULL
) {
756 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
757 } else if (wcda
== NULL
) {
758 ret
= MCIERR_INVALID_DEVICE_ID
;
760 end
= wcda
->dwTotalLen
;
762 if (dwFlags
& MCI_FROM
) {
763 start
= CDAUDIO_CalcFrame(wcda
, lpParms
->dwFrom
);
764 TRACE(cdaudio
,"MCI_FROM=%08lX -> %u \n", lpParms
->dwFrom
, start
);
766 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_DRIVER_INTERNAL
;
767 start
= wcda
->dwCurFrame
;
769 if (dwFlags
& MCI_TO
) {
770 end
= CDAUDIO_CalcFrame(wcda
, lpParms
->dwTo
);
771 TRACE(cdaudio
, "MCI_TO=%08lX -> %u \n", lpParms
->dwTo
, end
);
773 end
+= wcda
->dwFirstOffset
;
775 msf
.cdmsf_min0
= start
/ CDFRAMES_PERMIN
;
776 msf
.cdmsf_sec0
= (start
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
777 msf
.cdmsf_frame0
= start
% CDFRAMES_PERSEC
;
778 msf
.cdmsf_min1
= end
/ CDFRAMES_PERMIN
;
779 msf
.cdmsf_sec1
= (end
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
780 msf
.cdmsf_frame1
= end
% CDFRAMES_PERSEC
;
782 msf
.start_m
= start
/ CDFRAMES_PERMIN
;
783 msf
.start_s
= (start
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
784 msf
.start_f
= start
% CDFRAMES_PERSEC
;
785 msf
.end_m
= end
/ CDFRAMES_PERMIN
;
786 msf
.end_s
= (end
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
787 msf
.end_f
= end
% CDFRAMES_PERSEC
;
790 if (ioctl(wcda
->unixdev
, CDROMSTART
)) {
792 if (ioctl(wcda
->unixdev
, CDIOCSTART
, NULL
)) {
794 WARN(cdaudio
, "motor doesn't start !\n");
795 return MCIERR_HARDWARE
;
798 if (ioctl(wcda
->unixdev
, CDROMPLAYMSF
, &msf
)) {
800 if (ioctl(wcda
->unixdev
, CDIOCPLAYMSF
, &msf
)) {
802 WARN(cdaudio
, "device doesn't play !\n");
803 return MCIERR_HARDWARE
;
806 TRACE(cdaudio
,"msf = %d:%d:%d %d:%d:%d\n",
807 msf
.cdmsf_min0
, msf
.cdmsf_sec0
, msf
.cdmsf_frame0
,
808 msf
.cdmsf_min1
, msf
.cdmsf_sec1
, msf
.cdmsf_frame1
);
810 TRACE(cdaudio
,"msf = %d:%d:%d %d:%d:%d\n",
811 msf
.start_m
, msf
.start_s
, msf
.start_f
,
812 msf
.end_m
, msf
.end_s
, msf
.end_f
);
814 wcda
->mciMode
= MCI_MODE_PLAY
;
815 if (dwFlags
& MCI_NOTIFY
) {
816 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
818 mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
819 wcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
826 return MCIERR_HARDWARE
;
830 /**************************************************************************
831 * CDAUDIO_mciStop [internal]
833 static DWORD
CDAUDIO_mciStop(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
835 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
836 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
838 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
840 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
843 if (ioctl(wcda
->unixdev
, CDROMSTOP
))
845 if (ioctl(wcda
->unixdev
, CDIOCSTOP
, NULL
))
847 return MCIERR_HARDWARE
;
848 wcda
->mciMode
= MCI_MODE_STOP
;
849 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
850 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
851 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
852 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
856 return MCIERR_HARDWARE
;
860 /**************************************************************************
861 * CDAUDIO_mciPause [internal]
863 static DWORD
CDAUDIO_mciPause(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
865 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
866 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
868 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
870 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
873 if (ioctl(wcda
->unixdev
, CDROMPAUSE
))
875 if (ioctl(wcda
->unixdev
, CDIOCPAUSE
, NULL
))
877 return MCIERR_HARDWARE
;
878 wcda
->mciMode
= MCI_MODE_PAUSE
;
879 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
880 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
881 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
882 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
886 return MCIERR_HARDWARE
;
890 /**************************************************************************
891 * CDAUDIO_mciResume [internal]
893 static DWORD
CDAUDIO_mciResume(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
895 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
896 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
898 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
900 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
903 if (ioctl(wcda
->unixdev
, CDROMRESUME
))
905 if (ioctl(wcda
->unixdev
, CDIOCRESUME
, NULL
))
907 return MCIERR_HARDWARE
;
908 wcda
->mciMode
= MCI_MODE_STOP
;
909 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
910 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
911 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
912 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
916 return MCIERR_HARDWARE
;
920 /**************************************************************************
921 * CDAUDIO_mciSeek [internal]
923 static DWORD
CDAUDIO_mciSeek(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SEEK_PARMS lpParms
)
925 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
927 MCI_PLAY_PARMS playParms
;
929 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
931 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
933 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
934 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
936 wcda
->mciMode
= MCI_MODE_SEEK
;
937 switch (dwFlags
& ~(MCI_NOTIFY
|MCI_WAIT
)) {
938 case MCI_SEEK_TO_START
:
939 TRACE(cdaudio
, "Seeking to start\n");
940 playParms
.dwFrom
= 0;
942 case MCI_SEEK_TO_END
:
943 TRACE(cdaudio
, "Seeking to end\n");
944 playParms
.dwFrom
= wcda
->dwTotalLen
;
947 TRACE(cdaudio
, "Seeking to %lu\n", lpParms
->dwTo
);
948 playParms
.dwFrom
= lpParms
->dwTo
;
951 TRACE(cdaudio
, "Seeking to ??=%lu\n", dwFlags
);
952 return MCIERR_UNSUPPORTED_FUNCTION
;
954 dwRet
= CDAUDIO_mciPlay(wDevID
, MCI_WAIT
| MCI_FROM
, &playParms
);
955 if (dwRet
!= 0) return dwRet
;
956 dwRet
= CDAUDIO_mciStop(wDevID
, MCI_WAIT
, (LPMCI_GENERIC_PARMS
)&playParms
);
957 if (dwFlags
& MCI_NOTIFY
) {
958 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
959 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
960 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
964 return MCIERR_HARDWARE
;
968 /**************************************************************************
969 * CDAUDIO_mciSetDoor [internal]
971 static DWORD
CDAUDIO_mciSetDoor(UINT16 wDevID
, int open
)
973 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
975 TRACE(cdaudio
, "(%04x, %s) !\n", wDevID
, (open
) ? "OPEN" : "CLOSE");
977 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
981 if (ioctl(wcda
->unixdev
, CDROMEJECT
)) return MCIERR_HARDWARE
;
982 wcda
->mciMode
= MCI_MODE_OPEN
;
984 if (ioctl(wcda
->unixdev
, CDROMEJECT
, 1)) return MCIERR_HARDWARE
;
985 wcda
->mciMode
= MCI_MODE_STOP
;
988 if (ioctl(wcda
->unixdev
, CDIOCALLOW
, NULL
)) return MCIERR_HARDWARE
;
990 if (ioctl(wcda
->unixdev
, CDIOCEJECT
, NULL
)) return MCIERR_HARDWARE
;
991 wcda
->mciMode
= MCI_MODE_OPEN
;
993 if (ioctl(wcda
->unixdev
, CDIOCCLOSE
, NULL
)) return MCIERR_HARDWARE
;
994 wcda
->mciMode
= MCI_MODE_STOP
;
996 if (ioctl(wcda
->unixdev
, CDIOCPREVENT
, NULL
)) return MCIERR_HARDWARE
;
1002 /**************************************************************************
1003 * CDAUDIO_mciSet [internal]
1005 static DWORD
CDAUDIO_mciSet(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SET_PARMS lpParms
)
1007 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
1008 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
1010 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
1012 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
1013 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;;
1015 TRACE(cdaudio,"dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
1016 TRACE(cdaudio,"dwAudio=%08lX\n", lpParms->dwAudio);
1018 if (dwFlags
& MCI_SET_TIME_FORMAT
) {
1019 switch (lpParms
->dwTimeFormat
) {
1020 case MCI_FORMAT_MILLISECONDS
:
1021 TRACE(cdaudio
, "MCI_FORMAT_MILLISECONDS !\n");
1023 case MCI_FORMAT_MSF
:
1024 TRACE(cdaudio
,"MCI_FORMAT_MSF !\n");
1026 case MCI_FORMAT_TMSF
:
1027 TRACE(cdaudio
,"MCI_FORMAT_TMSF !\n");
1030 WARN(cdaudio
, "bad time format !\n");
1031 return MCIERR_BAD_TIME_FORMAT
;
1033 wcda
->dwTimeFormat
= lpParms
->dwTimeFormat
;
1035 if (dwFlags
& MCI_SET_DOOR_OPEN
) {
1036 CDAUDIO_mciSetDoor(wDevID
, TRUE
);
1038 if (dwFlags
& MCI_SET_DOOR_CLOSED
) {
1039 CDAUDIO_mciSetDoor(wDevID
, FALSE
);
1041 if (dwFlags
& MCI_SET_VIDEO
) return MCIERR_UNSUPPORTED_FUNCTION
;
1042 if (dwFlags
& MCI_SET_ON
) return MCIERR_UNSUPPORTED_FUNCTION
;
1043 if (dwFlags
& MCI_SET_OFF
) return MCIERR_UNSUPPORTED_FUNCTION
;
1044 if (dwFlags
& MCI_NOTIFY
) {
1045 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
1046 lpParms
->dwCallback
);
1047 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
1048 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
1052 return MCIERR_HARDWARE
;
1056 /**************************************************************************
1057 * MCICDAUDIO_DriverProc32 [sample driver]
1059 LONG
MCICDAUDIO_DriverProc32(DWORD dwDevID
, HDRVR16 hDriv
, DWORD wMsg
,
1060 DWORD dwParam1
, DWORD dwParam2
)
1062 #if defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__)
1064 case DRV_LOAD
: return 1;
1065 case DRV_FREE
: return 1;
1066 case DRV_OPEN
: return 1;
1067 case DRV_CLOSE
: return 1;
1068 case DRV_ENABLE
: return 1;
1069 case DRV_DISABLE
: return 1;
1070 case DRV_QUERYCONFIGURE
: return 1;
1071 case DRV_CONFIGURE
: MessageBox16(0, "Sample MultiMedia Linux Driver !", "MMLinux Driver", MB_OK
); return 1;
1072 case DRV_INSTALL
: return DRVCNF_RESTART
;
1073 case DRV_REMOVE
: return DRVCNF_RESTART
;
1075 case MCI_OPEN_DRIVER
: return CDAUDIO_mciOpen(dwDevID
, dwParam1
, (LPMCI_OPEN_PARMS32A
)dwParam2
);
1076 case MCI_CLOSE_DRIVER
: return CDAUDIO_mciClose(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1077 case MCI_GETDEVCAPS
: return CDAUDIO_mciGetDevCaps(dwDevID
, dwParam1
, (LPMCI_GETDEVCAPS_PARMS
)dwParam2
);
1078 case MCI_INFO
: return CDAUDIO_mciInfo(dwDevID
, dwParam1
, (LPMCI_INFO_PARMS16
)dwParam2
);
1079 case MCI_STATUS
: return CDAUDIO_mciStatus(dwDevID
, dwParam1
, (LPMCI_STATUS_PARMS
)dwParam2
);
1080 case MCI_SET
: return CDAUDIO_mciSet(dwDevID
, dwParam1
, (LPMCI_SET_PARMS
)dwParam2
);
1081 case MCI_PLAY
: return CDAUDIO_mciPlay(dwDevID
, dwParam1
, (LPMCI_PLAY_PARMS
)dwParam2
);
1082 case MCI_STOP
: return CDAUDIO_mciStop(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1083 case MCI_PAUSE
: return CDAUDIO_mciPause(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1084 case MCI_RESUME
: return CDAUDIO_mciResume(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1085 case MCI_SEEK
: return CDAUDIO_mciSeek(dwDevID
, dwParam1
, (LPMCI_SEEK_PARMS
)dwParam2
);
1086 /* FIXME: I wonder if those two next items are really called ? */
1087 case MCI_SET_DOOR_OPEN
: return CDAUDIO_mciSetDoor(dwDevID
, TRUE
);
1088 case MCI_SET_DOOR_CLOSED
: return CDAUDIO_mciSetDoor(dwDevID
, FALSE
);
1105 WARN(cdaudio
, "Unsupported command=%s\n", MCI_CommandToString(wMsg
));
1109 FIXME(cdaudio
, "Shouldn't receive a MCI_OPEN or CLOSE message\n");
1112 TRACE(cdaudio
, "Sending msg=%s to default driver proc\n", MCI_CommandToString(wMsg
));
1113 return DefDriverProc32(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
1115 return MCIERR_UNRECOGNIZED_COMMAND
;
1117 return MCIERR_UNRECOGNIZED_COMMAND
;
1121 /*-----------------------------------------------------------------------*/