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>
19 #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_MACHINE_SOUNDCARD_H
28 # include <machine/soundcard.h>
30 #ifdef HAVE_SYS_CDIO_H
31 # include <sys/cdio.h>
35 # define CDAUDIO_DEV "/dev/rcd0c"
37 # define CDAUDIO_DEV "/dev/cdrom"
41 # define IOCTL(a,b,c) ioctl(a,b,&c)
43 # define IOCTL(a,b,c) (c = ioctl(a,b,c) )
46 #define MAX_CDAUDIODRV (1)
47 #define MAX_CDAUDIO_TRACKS 256
49 #define CDFRAMES_PERSEC 75
50 #define CDFRAMES_PERMIN 4500
51 #define SECONDS_PERMIN 60
53 #if defined(linux) || defined(__FreeBSD__)
55 int nUseCount
; /* Incremented for each shared open */
56 BOOL16 fShareable
; /* TRUE if first open was shareable */
57 WORD wNotifyDeviceID
; /* MCI device ID with a pending notification */
58 HANDLE16 hCallback
; /* Callback handle for pending notification */
59 MCI_OPEN_PARMS16 openParms
;
63 struct cdrom_subchnl sc
;
64 #elif defined(__FreeBSD__)
65 struct cd_sub_channel_info sc
;
79 static WINE_CDAUDIO CDADev
[MAX_CDAUDIODRV
];
82 #ifndef CDROM_DATA_TRACK
83 #define CDROM_DATA_TRACK 0x04
86 /*-----------------------------------------------------------------------*/
88 /**************************************************************************
89 * CDAUDIO_mciGetOpenDrv [internal]
91 static WINE_CDAUDIO
* CDAUDIO_mciGetOpenDrv(UINT16 wDevID
)
93 if (wDevID
>= MAX_CDAUDIODRV
|| CDADev
[wDevID
].nUseCount
== 0 ||
94 CDADev
[wDevID
].unixdev
== 0) {
95 WARN(cdaudio
, "Invalid wDevID=%u\n", wDevID
);
98 return &CDADev
[wDevID
];
101 /**************************************************************************
102 * CDAUDIO_GetNumberOfTracks [internal]
104 static UINT16
CDAUDIO_GetNumberOfTracks(WINE_CDAUDIO
* wcda
)
106 #if defined(linux) || defined(__FreeBSD__)
108 struct cdrom_tochdr hdr
;
109 #elif defined(__FreeBSD__)
110 struct ioc_toc_header hdr
;
113 if (wcda
->nTracks
== 0) {
114 if (ioctl(wcda
->unixdev
,
117 #elif defined(__FreeBSD__)
121 WARN(cdaudio
, "(%p) -- Error occured !\n", wcda
);
125 wcda
->nTracks
= hdr
.cdth_trk1
;
126 #elif defined(__FreeBSD__)
127 wcda
->nTracks
= hdr
.ending_track
- hdr
.starting_track
+ 1;
130 return wcda
->nTracks
;
137 /**************************************************************************
138 * CDAUDIO_GetTracksInfo [internal]
140 static BOOL32
CDAUDIO_GetTracksInfo(WINE_CDAUDIO
* wcda
)
142 #if defined(linux) || defined(__FreeBSD__)
144 int start
, last_start
= 0;
145 int total_length
= 0;
147 struct cdrom_tocentry entry
;
148 #elif defined(__FreeBSD__)
149 struct ioc_read_toc_entry entry
;
150 struct cd_toc_entry toc_buffer
;
153 if (wcda
->nTracks
== 0) {
154 if (CDAUDIO_GetNumberOfTracks(wcda
) == (WORD
)-1) return FALSE
;
156 TRACE(cdaudio
,"nTracks=%u\n", wcda
->nTracks
);
158 if (wcda
->lpdwTrackLen
!= NULL
)
159 free(wcda
->lpdwTrackLen
);
160 wcda
->lpdwTrackLen
= (LPDWORD
)malloc((wcda
->nTracks
+ 1) * sizeof(DWORD
));
161 if (wcda
->lpdwTrackPos
!= NULL
)
162 free(wcda
->lpdwTrackPos
);
163 wcda
->lpdwTrackPos
= (LPDWORD
)malloc((wcda
->nTracks
+ 1) * sizeof(DWORD
));
164 if (wcda
->lpbTrackFlags
!= NULL
)
165 free(wcda
->lpbTrackFlags
);
166 wcda
->lpbTrackFlags
= (LPBYTE
)malloc((wcda
->nTracks
+ 1) * sizeof(BYTE
));
167 if (wcda
->lpdwTrackLen
== NULL
|| wcda
->lpdwTrackPos
== NULL
||
168 wcda
->lpbTrackFlags
== NULL
)
170 WARN(cdaudio
, "error allocating track table !\n");
173 memset(wcda
->lpdwTrackLen
, 0, (wcda
->nTracks
+ 1) * sizeof(DWORD
));
174 memset(wcda
->lpdwTrackPos
, 0, (wcda
->nTracks
+ 1) * sizeof(DWORD
));
175 memset(wcda
->lpbTrackFlags
, 0, (wcda
->nTracks
+ 1) * sizeof(BYTE
));
176 for (i
= 0; i
<= wcda
->nTracks
; i
++) {
177 if (i
== wcda
->nTracks
)
179 entry
.cdte_track
= CDROM_LEADOUT
;
180 #elif defined(__FreeBSD__)
182 entry
.starting_track
= LEADOUT
; /* XXX */
186 entry
.cdte_track
= i
+ 1;
187 #elif defined(__FreeBSD__)
188 entry
.starting_track
= i
+ 1;
191 entry
.cdte_format
= CDROM_MSF
;
192 #elif defined(__FreeBSD__)
193 bzero((char *)&toc_buffer
, sizeof(toc_buffer
));
194 entry
.address_format
= CD_MSF_FORMAT
;
195 entry
.data_len
= sizeof(toc_buffer
);
196 entry
.data
= &toc_buffer
;
198 if (ioctl(wcda
->unixdev
,
201 #elif defined(__FreeBSD__)
205 WARN(cdaudio
, "error read entry\n");
209 start
= CDFRAMES_PERSEC
* (SECONDS_PERMIN
*
210 entry
.cdte_addr
.msf
.minute
+ entry
.cdte_addr
.msf
.second
) +
211 entry
.cdte_addr
.msf
.frame
;
212 #elif defined(__FreeBSD__)
213 start
= CDFRAMES_PERSEC
* (SECONDS_PERMIN
*
214 toc_buffer
.addr
.msf
.minute
+ toc_buffer
.addr
.msf
.second
) +
215 toc_buffer
.addr
.msf
.frame
;
219 wcda
->dwFirstOffset
= start
;
220 TRACE(cdaudio
, "dwFirstOffset=%u\n", start
);
222 length
= start
- last_start
;
224 start
= last_start
- length
;
225 total_length
+= length
;
226 wcda
->lpdwTrackLen
[i
- 1] = length
;
227 wcda
->lpdwTrackPos
[i
- 1] = start
;
228 TRACE(cdaudio
, "track #%u start=%u len=%u\n", i
, start
, length
);
230 wcda
->lpbTrackFlags
[i
] =
232 (entry
.cdte_adr
<< 4) | (entry
.cdte_ctrl
& 0x0f);
233 #elif defined(__FreeBSD__)
234 (toc_buffer
.addr_type
<< 4) | (toc_buffer
.control
& 0x0f);
236 TRACE(cdaudio
, "track #%u flags=%02x\n", i
+ 1, wcda
->lpbTrackFlags
[i
]);
238 wcda
->dwTotalLen
= total_length
;
239 TRACE(cdaudio
,"total_len=%u\n", total_length
);
246 /**************************************************************************
247 * CDAUDIO_mciOpen [internal]
249 static DWORD
CDAUDIO_mciOpen(UINT16 wDevID
, DWORD dwFlags
, LPMCI_OPEN_PARMS32A lpOpenParms
)
251 #if defined(linux) || defined(__FreeBSD__)
255 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpOpenParms
);
257 if (lpOpenParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
258 if (wDevID
> MAX_CDAUDIODRV
) return MCIERR_INVALID_DEVICE_ID
;
260 dwDeviceID
= lpOpenParms
->wDeviceID
;
262 wcda
= &CDADev
[wDevID
];
264 if (wcda
->nUseCount
> 0) {
265 /* The driver already open on this channel */
266 /* If the driver was opened shareable before and this open specifies */
267 /* shareable then increment the use count */
268 if (wcda
->fShareable
&& (dwFlags
& MCI_OPEN_SHAREABLE
))
271 return MCIERR_MUST_USE_SHAREABLE
;
274 wcda
->fShareable
= dwFlags
& MCI_OPEN_SHAREABLE
;
276 if (dwFlags
& MCI_OPEN_ELEMENT
) {
277 TRACE(cdaudio
,"MCI_OPEN_ELEMENT !\n");
278 /* return MCIERR_NO_ELEMENT_ALLOWED; */
281 wcda
->openParms
.dwCallback
= lpOpenParms
->dwCallback
;
282 wcda
->openParms
.wDeviceID
= (WORD
)lpOpenParms
->wDeviceID
;
283 wcda
->openParms
.wReserved0
= 0; /*????*/
284 wcda
->openParms
.lpstrDeviceType
= lpOpenParms
->lpstrDeviceType
;
285 wcda
->openParms
.lpstrElementName
= lpOpenParms
->lpstrElementName
;
286 wcda
->openParms
.lpstrAlias
= lpOpenParms
->lpstrAlias
;
288 wcda
->wNotifyDeviceID
= dwDeviceID
;
289 wcda
->unixdev
= open (CDAUDIO_DEV
, O_RDONLY
, 0);
290 if (wcda
->unixdev
== -1) {
291 WARN(cdaudio
,"can't open '%s'!. errno=%d\n", CDAUDIO_DEV
, errno
);
292 perror( "can't open\n" );
293 return MCIERR_HARDWARE
;
296 wcda
->mciMode
= MCI_MODE_STOP
;
297 wcda
->dwTimeFormat
= MCI_FORMAT_TMSF
;
300 wcda
->dwTotalLen
= 0;
301 wcda
->dwFirstOffset
= 0;
302 wcda
->lpdwTrackLen
= NULL
;
303 wcda
->lpdwTrackPos
= NULL
;
304 wcda
->lpbTrackFlags
= NULL
;
305 if (!CDAUDIO_GetTracksInfo(&CDADev
[wDevID
])) {
306 WARN(cdaudio
,"error reading TracksInfo !\n");
307 /* return MCIERR_INTERNAL; */
311 Moved to mmsystem.c mciOpen routine
313 if (dwFlags & MCI_NOTIFY) {
314 TRACE(cdaudio, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
315 lpParms->dwCallback);
316 mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
317 wcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
322 return MCIERR_HARDWARE
;
326 /**************************************************************************
327 * CDAUDIO_mciClose [internal]
329 static DWORD
CDAUDIO_mciClose(UINT16 wDevID
, DWORD dwParam
, LPMCI_GENERIC_PARMS lpParms
)
331 #if defined(linux) || defined(__FreeBSD__)
332 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
334 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwParam
, lpParms
);
336 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
338 if (--wcda
->nUseCount
== 0) {
339 if (wcda
->lpdwTrackLen
!= NULL
) free(wcda
->lpdwTrackLen
);
340 if (wcda
->lpdwTrackPos
!= NULL
) free(wcda
->lpdwTrackPos
);
341 if (wcda
->lpbTrackFlags
!= NULL
) free(wcda
->lpbTrackFlags
);
342 close(wcda
->unixdev
);
348 /**************************************************************************
349 * CDAUDIO_mciGetDevCaps [internal]
351 static DWORD
CDAUDIO_mciGetDevCaps(UINT16 wDevID
, DWORD dwFlags
,
352 LPMCI_GETDEVCAPS_PARMS lpParms
)
354 #if defined(linux) || defined(__FreeBSD__)
355 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
357 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
359 if (dwFlags
& MCI_GETDEVCAPS_ITEM
) {
360 TRACE(cdaudio
, "MCI_GETDEVCAPS_ITEM dwItem=%08lX;\n", lpParms
->dwItem
);
362 switch(lpParms
->dwItem
) {
363 case MCI_GETDEVCAPS_CAN_RECORD
:
364 lpParms
->dwReturn
= FALSE
;
366 case MCI_GETDEVCAPS_HAS_AUDIO
:
367 lpParms
->dwReturn
= TRUE
;
369 case MCI_GETDEVCAPS_HAS_VIDEO
:
370 lpParms
->dwReturn
= FALSE
;
372 case MCI_GETDEVCAPS_DEVICE_TYPE
:
373 lpParms
->dwReturn
= MCI_DEVTYPE_CD_AUDIO
;
375 case MCI_GETDEVCAPS_USES_FILES
:
376 lpParms
->dwReturn
= FALSE
;
378 case MCI_GETDEVCAPS_COMPOUND_DEVICE
:
379 lpParms
->dwReturn
= FALSE
;
381 case MCI_GETDEVCAPS_CAN_EJECT
:
382 lpParms
->dwReturn
= TRUE
;
384 case MCI_GETDEVCAPS_CAN_PLAY
:
385 lpParms
->dwReturn
= TRUE
;
387 case MCI_GETDEVCAPS_CAN_SAVE
:
388 lpParms
->dwReturn
= FALSE
;
391 return MCIERR_UNRECOGNIZED_COMMAND
;
394 TRACE(cdaudio
, "lpParms->dwReturn=%08lX;\n", lpParms
->dwReturn
);
397 return MCIERR_INTERNAL
;
401 /**************************************************************************
402 * CDAUDIO_mciInfo [internal]
404 static DWORD
CDAUDIO_mciInfo(UINT16 wDevID
, DWORD dwFlags
, LPMCI_INFO_PARMS16 lpParms
)
406 #if defined(linux) || defined(__FreeBSD__)
409 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
411 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
413 if (lpParms
== NULL
|| lpParms
->lpstrReturn
== NULL
) {
414 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
415 } else if (wcda
== NULL
) {
416 ret
= MCIERR_INVALID_DEVICE_ID
;
418 TRACE(cdaudio
, "buf=%p, len=%lu\n", lpParms
->lpstrReturn
, lpParms
->dwRetSize
);
421 case MCI_INFO_PRODUCT
:
422 str
= "Wine's audio CDROM";
425 WARN(cdaudio
, "Don't know this info command (%lu)\n", dwFlags
);
426 ret
= MCIERR_UNRECOGNIZED_COMMAND
;
430 ret
= MCI_WriteString(lpParms
->lpstrReturn
, lpParms
->dwRetSize
, str
);
432 lpParms
->lpstrReturn
[0] = 0;
437 return MCIERR_INTERNAL
;
442 /**************************************************************************
443 * CDAUDIO_CalcFrame [internal]
445 static DWORD
CDAUDIO_CalcFrame(WINE_CDAUDIO
* wcda
, DWORD dwTime
)
448 #if defined(linux) || defined(__FreeBSD__)
451 TRACE(cdaudio
,"(%p, %08lX, %lu);\n", wcda
, wcda
->dwTimeFormat
, dwTime
);
453 switch (wcda
->dwTimeFormat
) {
454 case MCI_FORMAT_MILLISECONDS
:
455 dwFrame
= dwTime
* CDFRAMES_PERSEC
/ 1000;
456 TRACE(cdaudio
, "MILLISECONDS %lu\n", dwFrame
);
459 TRACE(cdaudio
, "MSF %02u:%02u:%02u\n",
460 MCI_MSF_MINUTE(dwTime
), MCI_MSF_SECOND(dwTime
), MCI_MSF_FRAME(dwTime
));
461 dwFrame
+= CDFRAMES_PERMIN
* MCI_MSF_MINUTE(dwTime
);
462 dwFrame
+= CDFRAMES_PERSEC
* MCI_MSF_SECOND(dwTime
);
463 dwFrame
+= MCI_MSF_FRAME(dwTime
);
465 case MCI_FORMAT_TMSF
:
467 /* unknown format ! force TMSF ! ... */
468 wTrack
= MCI_TMSF_TRACK(dwTime
);
469 TRACE(cdaudio
, "MSF %02u-%02u:%02u:%02u\n",
470 MCI_TMSF_TRACK(dwTime
), MCI_TMSF_MINUTE(dwTime
),
471 MCI_TMSF_SECOND(dwTime
), MCI_TMSF_FRAME(dwTime
));
472 TRACE(cdaudio
, "TMSF trackpos[%u]=%lu\n",
473 wTrack
, wcda
->lpdwTrackPos
[wTrack
- 1]);
474 dwFrame
= wcda
->lpdwTrackPos
[wTrack
- 1];
475 dwFrame
+= CDFRAMES_PERMIN
* MCI_TMSF_MINUTE(dwTime
);
476 dwFrame
+= CDFRAMES_PERSEC
* MCI_TMSF_SECOND(dwTime
);
477 dwFrame
+= MCI_TMSF_FRAME(dwTime
);
485 /**************************************************************************
486 * CDAUDIO_GetCDStatus [internal]
488 static BOOL32
CDAUDIO_GetCDStatus(WINE_CDAUDIO
* wcda
)
490 #if defined(linux) || defined(__FreeBSD__)
491 int oldmode
= wcda
->cdMode
;
493 struct ioc_read_subchannel read_sc
;
495 read_sc
.address_format
= CD_MSF_FORMAT
;
496 read_sc
.data_format
= CD_CURRENT_POSITION
;
498 read_sc
.data_len
= sizeof(wcda
->sc
);
499 read_sc
.data
= (struct cd_sub_channel_info
*)&wcda
->sc
;
501 wcda
->sc
.cdsc_format
= CDROM_MSF
;
503 if (ioctl(wcda
->unixdev
,
505 CDROMSUBCHNL
, &wcda
->sc
506 #elif defined(__FreeBSD__)
507 CDIOCREADSUBCHANNEL
, &read_sc
510 TRACE(cdaudio
,"opened or no_media !\n");
511 wcda
->cdMode
= MCI_MODE_OPEN
; /* was NOT_READY */
516 wcda
->sc
.cdsc_audiostatus
517 #elif defined(__FreeBSD__)
518 wcda
->sc
.header
.audio_status
522 case CDROM_AUDIO_INVALID
:
523 #elif defined(__FreeBSD__)
524 case CD_AS_AUDIO_INVALID
:
526 WARN(cdaudio
, "device doesn't support status, using MCI status.\n");
530 case CDROM_AUDIO_NO_STATUS
:
531 #elif defined(__FreeBSD__)
532 case CD_AS_NO_STATUS
:
534 wcda
->cdMode
= MCI_MODE_STOP
;
535 TRACE(cdaudio
,"MCI_MODE_STOP !\n");
538 case CDROM_AUDIO_PLAY
:
539 #elif defined(__FreeBSD__)
540 case CD_AS_PLAY_IN_PROGRESS
:
542 wcda
->cdMode
= MCI_MODE_PLAY
;
543 TRACE(cdaudio
,"MCI_MODE_PLAY !\n");
546 case CDROM_AUDIO_PAUSED
:
547 #elif defined(__FreeBSD__)
548 case CD_AS_PLAY_PAUSED
:
550 wcda
->cdMode
= MCI_MODE_PAUSE
;
551 TRACE(cdaudio
,"MCI_MODE_PAUSE !\n");
555 TRACE(cdaudio
,"status=%02X !\n",
556 wcda
->sc
.cdsc_audiostatus
);
557 #elif defined(__FreeBSD__)
558 TRACE(cdaudio
,"status=%02X !\n",
559 wcda
->sc
.header
.audio_status
);
563 wcda
->nCurTrack
= wcda
->sc
.cdsc_trk
;
565 CDFRAMES_PERMIN
* wcda
->sc
.cdsc_absaddr
.msf
.minute
+
566 CDFRAMES_PERSEC
* wcda
->sc
.cdsc_absaddr
.msf
.second
+
567 wcda
->sc
.cdsc_absaddr
.msf
.frame
;
568 #elif defined(__FreeBSD__)
569 wcda
->nCurTrack
= wcda
->sc
.what
.position
.track_number
;
571 CDFRAMES_PERMIN
* wcda
->sc
.what
.position
.absaddr
.msf
.minute
+
572 CDFRAMES_PERSEC
* wcda
->sc
.what
.position
.absaddr
.msf
.second
+
573 wcda
->sc
.what
.position
.absaddr
.msf
.frame
;
576 TRACE(cdaudio
,"%02u-%02u:%02u:%02u \n",
578 wcda
->sc
.cdsc_absaddr
.msf
.minute
,
579 wcda
->sc
.cdsc_absaddr
.msf
.second
,
580 wcda
->sc
.cdsc_absaddr
.msf
.frame
);
581 #elif defined(__FreeBSD__)
582 TRACE(cdaudio
,"%02u-%02u:%02u:%02u \n",
583 wcda
->sc
.what
.position
.track_number
,
584 wcda
->sc
.what
.position
.absaddr
.msf
.minute
,
585 wcda
->sc
.what
.position
.absaddr
.msf
.second
,
586 wcda
->sc
.what
.position
.absaddr
.msf
.frame
);
589 if (oldmode
!= wcda
->cdMode
&& oldmode
== MCI_MODE_OPEN
) {
590 if (!CDAUDIO_GetTracksInfo(wcda
)) {
591 WARN(cdaudio
, "error updating TracksInfo !\n");
592 return MCIERR_INTERNAL
;
602 /**************************************************************************
603 * CDAUDIO_CalcTime [internal]
605 static DWORD
CDAUDIO_CalcTime(WINE_CDAUDIO
* wcda
, DWORD dwFrame
)
608 #if defined(linux) || defined(__FreeBSD__)
614 TRACE(cdaudio
,"(%p, %08lX, %lu);\n", wcda
, wcda
->dwTimeFormat
, dwFrame
);
616 switch (wcda
->dwTimeFormat
) {
617 case MCI_FORMAT_MILLISECONDS
:
618 dwTime
= dwFrame
/ CDFRAMES_PERSEC
* 1000;
619 TRACE(cdaudio
, "MILLISECONDS %lu\n", dwTime
);
622 wMinutes
= dwFrame
/ CDFRAMES_PERMIN
;
623 wSeconds
= (dwFrame
- CDFRAMES_PERMIN
* wMinutes
) / CDFRAMES_PERSEC
;
624 wFrames
= dwFrame
- CDFRAMES_PERMIN
* wMinutes
- CDFRAMES_PERSEC
* wSeconds
;
625 dwTime
= MCI_MAKE_MSF(wMinutes
, wSeconds
, wFrames
);
626 TRACE(cdaudio
,"MSF %02u:%02u:%02u -> dwTime=%lu\n",wMinutes
, wSeconds
, wFrames
, dwTime
);
628 case MCI_FORMAT_TMSF
:
630 /* unknown format ! force TMSF ! ... */
631 for (wTrack
= 0; wTrack
< wcda
->nTracks
; wTrack
++) {
632 /* dwTime += wcda->lpdwTrackLen[wTrack - 1];
633 TRACE(cdaudio, "Adding trk#%u curpos=%u \n", dwTime);
634 if (dwTime >= dwFrame) break; */
635 if (wcda
->lpdwTrackPos
[wTrack
- 1] >= dwFrame
) break;
637 wMinutes
= dwFrame
/ CDFRAMES_PERMIN
;
638 wSeconds
= (dwFrame
- CDFRAMES_PERMIN
* wMinutes
) / CDFRAMES_PERSEC
;
639 wFrames
= dwFrame
- CDFRAMES_PERMIN
* wMinutes
- CDFRAMES_PERSEC
* wSeconds
;
640 dwTime
= MCI_MAKE_TMSF(wTrack
, wMinutes
, wSeconds
, wFrames
);
641 TRACE(cdaudio
, "%02u-%02u:%02u:%02u\n", wTrack
, wMinutes
, wSeconds
, wFrames
);
649 /**************************************************************************
650 * CDAUDIO_mciStatus [internal]
652 static DWORD
CDAUDIO_mciStatus(UINT16 wDevID
, DWORD dwFlags
, LPMCI_STATUS_PARMS lpParms
)
654 #if defined(linux) || defined(__FreeBSD__)
655 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
658 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
660 if (lpParms
== NULL
) {
661 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
662 } else if (wcda
== NULL
) {
663 ret
= MCIERR_INVALID_DEVICE_ID
;
665 if (dwFlags
& MCI_NOTIFY
) {
666 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
667 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
668 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
670 if (dwFlags
& MCI_STATUS_ITEM
) {
671 switch(lpParms
->dwItem
) {
672 case MCI_STATUS_CURRENT_TRACK
:
673 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_INTERNAL
;
674 lpParms
->dwReturn
= wcda
->nCurTrack
;
675 TRACE(cdaudio
,"CURRENT_TRACK=%lu!\n", lpParms
->dwReturn
);
677 case MCI_STATUS_LENGTH
:
678 if (wcda
->nTracks
== 0) {
679 if (!CDAUDIO_GetTracksInfo(wcda
)) {
680 WARN(cdaudio
, "error reading TracksInfo !\n");
681 return MCIERR_INTERNAL
;
684 if (dwFlags
& MCI_TRACK
) {
685 TRACE(cdaudio
,"MCI_TRACK #%lu LENGTH=??? !\n", lpParms
->dwTrack
);
686 if (lpParms
->dwTrack
> wcda
->nTracks
)
687 return MCIERR_OUTOFRANGE
;
688 lpParms
->dwReturn
= wcda
->lpdwTrackLen
[lpParms
->dwTrack
- 1];
690 lpParms
->dwReturn
= wcda
->dwTotalLen
;
692 lpParms
->dwReturn
= CDAUDIO_CalcTime(wcda
, lpParms
->dwReturn
);
693 TRACE(cdaudio
,"LENGTH=%lu !\n", lpParms
->dwReturn
);
695 case MCI_STATUS_MODE
:
696 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_INTERNAL
;
697 lpParms
->dwReturn
= wcda
->cdMode
;
698 if (!lpParms
->dwReturn
) lpParms
->dwReturn
= wcda
->mciMode
;
699 TRACE(cdaudio
,"MCI_STATUS_MODE=%08lX !\n", lpParms
->dwReturn
);
701 case MCI_STATUS_MEDIA_PRESENT
:
702 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_INTERNAL
;
703 lpParms
->dwReturn
= (wcda
->nTracks
> 0) ? TRUE
: FALSE
;
704 TRACE(cdaudio
,"MCI_STATUS_MEDIA_PRESENT =%s!\n", lpParms
->dwReturn
? "Y" : "N");
706 case MCI_STATUS_NUMBER_OF_TRACKS
:
707 lpParms
->dwReturn
= CDAUDIO_GetNumberOfTracks(wcda
);
708 TRACE(cdaudio
,"MCI_STATUS_NUMBER_OF_TRACKS = %lu !\n", lpParms
->dwReturn
);
709 if (lpParms
->dwReturn
== (WORD
)-1) return MCIERR_INTERNAL
;
711 case MCI_STATUS_POSITION
:
712 if (!CDAUDIO_GetCDStatus(wcda
)) return MCIERR_INTERNAL
;
713 lpParms
->dwReturn
= wcda
->dwCurFrame
;
714 if (dwFlags
& MCI_STATUS_START
) {
715 lpParms
->dwReturn
= wcda
->dwFirstOffset
;
716 TRACE(cdaudio
,"get MCI_STATUS_START !\n");
718 if (dwFlags
& MCI_TRACK
) {
719 if (lpParms
->dwTrack
> wcda
->nTracks
)
720 return MCIERR_OUTOFRANGE
;
721 lpParms
->dwReturn
= wcda
->lpdwTrackPos
[lpParms
->dwTrack
- 1];
722 TRACE(cdaudio
,"get MCI_TRACK #%lu !\n", lpParms
->dwTrack
);
724 lpParms
->dwReturn
= CDAUDIO_CalcTime(wcda
, lpParms
->dwReturn
);
725 TRACE(cdaudio
,"MCI_STATUS_POSITION=%08lX !\n", lpParms
->dwReturn
);
727 case MCI_STATUS_READY
:
728 TRACE(cdaudio
,"MCI_STATUS_READY !\n");
729 lpParms
->dwReturn
= TRUE
;
731 case MCI_STATUS_TIME_FORMAT
:
732 lpParms
->dwReturn
= wcda
->dwTimeFormat
;
733 TRACE(cdaudio
,"MCI_STATUS_TIME_FORMAT =%08lx!\n", lpParms
->dwReturn
);
735 /* FIXME: the constant used here are not defined in mmsystem.h */
736 /* MCI_CDA_STATUS_TYPE_TRACK is very likely to be 0x00004001 */
737 case MCI_CDA_STATUS_TYPE_TRACK
:
738 if (!(dwFlags
& MCI_TRACK
)) return MCIERR_MISSING_PARAMETER
;
739 lpParms
->dwReturn
= (wcda
->lpbTrackFlags
[lpParms
->dwTrack
- 1] &
740 CDROM_DATA_TRACK
) ? MCI_CDA_TRACK_OTHER
: MCI_CDA_TRACK_AUDIO
;
741 TRACE(cdaudio
, "MCI_CDA_STATUS_TYPE_TRACK[%ld]=%08lx\n", lpParms
->dwTrack
, lpParms
->dwReturn
);
744 WARN(cdaudio
, "unknown command %08lX !\n", lpParms
->dwItem
);
745 return MCIERR_UNRECOGNIZED_COMMAND
;
749 WARN(cdaudio
, "not MCI_STATUS_ITEM !\n");
752 return MMSYSERR_NOTENABLED
;
757 /**************************************************************************
758 * CDAUDIO_mciPlay [internal]
760 static DWORD
CDAUDIO_mciPlay(UINT16 wDevID
, DWORD dwFlags
, LPMCI_PLAY_PARMS lpParms
)
762 #if defined(linux) || defined(__FreeBSD__)
764 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
767 struct cdrom_msf msf
;
768 #elif defined(__FreeBSD__)
769 struct ioc_play_msf msf
;
772 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
774 if (lpParms
== NULL
) {
775 ret
= MCIERR_NULL_PARAMETER_BLOCK
;
776 } else if (wcda
== NULL
) {
777 ret
= MCIERR_INVALID_DEVICE_ID
;
780 end
= wcda
->dwTotalLen
;
782 if (dwFlags
& MCI_FROM
) {
783 start
= CDAUDIO_CalcFrame(wcda
, lpParms
->dwFrom
);
784 TRACE(cdaudio
,"MCI_FROM=%08lX -> %u \n", lpParms
->dwFrom
, start
);
786 if (dwFlags
& MCI_TO
) {
787 end
= CDAUDIO_CalcFrame(wcda
, lpParms
->dwTo
);
788 TRACE(cdaudio
, "MCI_TO=%08lX -> %u \n", lpParms
->dwTo
, end
);
790 start
+= wcda
->dwFirstOffset
;
791 end
+= wcda
->dwFirstOffset
;
793 msf
.cdmsf_min0
= start
/ CDFRAMES_PERMIN
;
794 msf
.cdmsf_sec0
= (start
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
795 msf
.cdmsf_frame0
= start
% CDFRAMES_PERSEC
;
796 msf
.cdmsf_min1
= end
/ CDFRAMES_PERMIN
;
797 msf
.cdmsf_sec1
= (end
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
798 msf
.cdmsf_frame1
= end
% CDFRAMES_PERSEC
;
799 #elif defined(__FreeBSD__)
800 msf
.start_m
= start
/ CDFRAMES_PERMIN
;
801 msf
.start_s
= (start
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
802 msf
.start_f
= start
% CDFRAMES_PERSEC
;
803 msf
.end_m
= end
/ CDFRAMES_PERMIN
;
804 msf
.end_s
= (end
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
805 msf
.end_f
= end
% CDFRAMES_PERSEC
;
807 if (ioctl(wcda
->unixdev
,
810 #elif defined(__FreeBSD__)
814 WARN(cdaudio
, "motor doesn't start !\n");
815 return MCIERR_HARDWARE
;
817 if (ioctl(wcda
->unixdev
,
820 #elif defined(__FreeBSD__)
824 WARN(cdaudio
, "device doesn't play !\n");
825 return MCIERR_HARDWARE
;
828 TRACE(cdaudio
,"msf = %d:%d:%d %d:%d:%d\n",
829 msf
.cdmsf_min0
, msf
.cdmsf_sec0
, msf
.cdmsf_frame0
,
830 msf
.cdmsf_min1
, msf
.cdmsf_sec1
, msf
.cdmsf_frame1
);
831 #elif defined(__FreeBSD__)
832 TRACE(cdaudio
,"msf = %d:%d:%d %d:%d:%d\n",
833 msf
.start_m
, msf
.start_s
, msf
.start_f
,
834 msf
.end_m
, msf
.end_s
, msf
.end_f
);
836 wcda
->mciMode
= MCI_MODE_PLAY
;
837 if (dwFlags
& MCI_NOTIFY
) {
838 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
840 mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
841 wcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
848 return MCIERR_HARDWARE
;
852 /**************************************************************************
853 * CDAUDIO_mciStop [internal]
855 static DWORD
CDAUDIO_mciStop(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
857 #if defined(linux) || defined(__FreeBSD__)
858 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
860 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
862 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
864 if (ioctl(wcda
->unixdev
,
867 #elif defined(__FreeBSD__)
870 )) return MCIERR_HARDWARE
;
871 wcda
->mciMode
= MCI_MODE_STOP
;
872 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
873 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
874 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
875 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
879 return MCIERR_HARDWARE
;
883 /**************************************************************************
884 * CDAUDIO_mciPause [internal]
886 static DWORD
CDAUDIO_mciPause(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
888 #if defined(linux) || defined(__FreeBSD__)
889 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
891 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
893 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
895 if (ioctl(wcda
->unixdev
,
898 #elif defined(__FreeBSD__)
901 )) return MCIERR_HARDWARE
;
902 wcda
->mciMode
= MCI_MODE_PAUSE
;
903 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
904 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
905 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
906 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
910 return MCIERR_HARDWARE
;
914 /**************************************************************************
915 * CDAUDIO_mciResume [internal]
917 static DWORD
CDAUDIO_mciResume(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
919 #if defined(linux) || defined(__FreeBSD__)
920 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
922 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
924 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
926 if (ioctl(wcda
->unixdev
,
929 #elif defined(__FreeBSD__)
932 )) return MCIERR_HARDWARE
;
933 wcda
->mciMode
= MCI_MODE_STOP
;
934 if (lpParms
&& (dwFlags
& MCI_NOTIFY
)) {
935 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
936 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
937 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
941 return MCIERR_HARDWARE
;
945 /**************************************************************************
946 * CDAUDIO_mciSeek [internal]
948 static DWORD
CDAUDIO_mciSeek(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SEEK_PARMS lpParms
)
950 #if defined(linux) || defined(__FreeBSD__)
952 MCI_PLAY_PARMS PlayParms
;
953 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
955 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
957 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
958 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
960 if (ioctl(wcda
->unixdev
,
963 #elif defined(__FreeBSD__)
967 perror("ioctl CDROMRESUME");
968 return MCIERR_HARDWARE
;
970 wcda
->mciMode
= MCI_MODE_SEEK
;
972 case MCI_SEEK_TO_START
:
973 PlayParms
.dwFrom
= 0;
975 case MCI_SEEK_TO_END
:
976 PlayParms
.dwFrom
= wcda
->dwTotalLen
;
979 PlayParms
.dwFrom
= lpParms
->dwTo
;
982 dwRet
= CDAUDIO_mciPlay(wDevID
, MCI_WAIT
| MCI_FROM
, &PlayParms
);
983 if (dwRet
!= 0) return dwRet
;
984 dwRet
= CDAUDIO_mciStop(wDevID
, MCI_WAIT
, (LPMCI_GENERIC_PARMS
)&PlayParms
);
985 if (dwFlags
& MCI_NOTIFY
) {
986 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
987 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
988 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
992 return MCIERR_HARDWARE
;
996 /**************************************************************************
997 * CDAUDIO_mciSetDoor [internal]
999 static DWORD
CDAUDIO_mciSetDoor(UINT16 wDevID
, int open
)
1001 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
1003 TRACE(cdaudio
, "(%04x, %s) !\n", wDevID
, (open
) ? "OPEN" : "CLOSE");
1005 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
1008 if (ioctl(wcda
->unixdev
, CDIOCALLOW
)) return MCIERR_HARDWARE
;
1010 if (ioctl(wcda
->unixdev
, CDIOCEJECT
)) return MCIERR_HARDWARE
;
1011 wcda
->mciMode
= MCI_MODE_OPEN
;
1013 if (ioctl(wcda
->unixdev
, CDIOCCLOSE
)) return MCIERR_HARDWARE
;
1014 wcda
->mciMode
= MCI_MODE_STOP
;
1016 if (ioctl(wcda
->unixdev
, CDIOCPREVENT
)) return MCIERR_HARDWARE
;
1019 if (ioctl(wcda
->unixdev
, CDROMEJECT
)) return MCIERR_HARDWARE
;
1020 wcda
->mciMode
= MCI_MODE_OPEN
;
1022 if (ioctl(wcda
->unixdev
, CDROMEJECT
, 1)) return MCIERR_HARDWARE
;
1023 wcda
->mciMode
= MCI_MODE_STOP
;
1030 /**************************************************************************
1031 * CDAUDIO_mciSet [internal]
1033 static DWORD
CDAUDIO_mciSet(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SET_PARMS lpParms
)
1035 #if defined(linux) || defined(__FreeBSD__)
1036 WINE_CDAUDIO
* wcda
= CDAUDIO_mciGetOpenDrv(wDevID
);
1038 TRACE(cdaudio
,"(%04X, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
1040 if (wcda
== NULL
) return MCIERR_INVALID_DEVICE_ID
;
1041 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;;
1043 TRACE(cdaudio,"dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
1044 TRACE(cdaudio,"dwAudio=%08lX\n", lpParms->dwAudio);
1046 if (dwFlags
& MCI_SET_TIME_FORMAT
) {
1047 switch (lpParms
->dwTimeFormat
) {
1048 case MCI_FORMAT_MILLISECONDS
:
1049 TRACE(cdaudio
, "MCI_FORMAT_MILLISECONDS !\n");
1051 case MCI_FORMAT_MSF
:
1052 TRACE(cdaudio
,"MCI_FORMAT_MSF !\n");
1054 case MCI_FORMAT_TMSF
:
1055 TRACE(cdaudio
,"MCI_FORMAT_TMSF !\n");
1058 WARN(cdaudio
, "bad time format !\n");
1059 return MCIERR_BAD_TIME_FORMAT
;
1061 wcda
->dwTimeFormat
= lpParms
->dwTimeFormat
;
1063 if (dwFlags
& MCI_SET_DOOR_OPEN
) {
1064 CDAUDIO_mciSetDoor(wDevID
, TRUE
);
1066 if (dwFlags
& MCI_SET_DOOR_CLOSED
) {
1067 CDAUDIO_mciSetDoor(wDevID
, TRUE
);
1069 if (dwFlags
& MCI_SET_VIDEO
) return MCIERR_UNSUPPORTED_FUNCTION
;
1070 if (dwFlags
& MCI_SET_ON
) return MCIERR_UNSUPPORTED_FUNCTION
;
1071 if (dwFlags
& MCI_SET_OFF
) return MCIERR_UNSUPPORTED_FUNCTION
;
1072 if (dwFlags
& MCI_NOTIFY
) {
1073 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
1074 lpParms
->dwCallback
);
1075 mciDriverNotify16((HWND16
)LOWORD(lpParms
->dwCallback
),
1076 wcda
->wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
1080 return MCIERR_HARDWARE
;
1084 /**************************************************************************
1085 * MCICDAUDIO_DriverProc32 [sample driver]
1087 LONG
MCICDAUDIO_DriverProc32(DWORD dwDevID
, HDRVR16 hDriv
, DWORD wMsg
,
1088 DWORD dwParam1
, DWORD dwParam2
)
1090 #if defined(linux) || defined(__FreeBSD__)
1092 case DRV_LOAD
: return 1;
1093 case DRV_FREE
: return 1;
1094 case DRV_OPEN
: return 1;
1095 case DRV_CLOSE
: return 1;
1096 case DRV_ENABLE
: return 1;
1097 case DRV_DISABLE
: return 1;
1098 case DRV_QUERYCONFIGURE
: return 1;
1099 case DRV_CONFIGURE
: MessageBox16(0, "Sample MultiMedia Linux Driver !", "MMLinux Driver", MB_OK
); return 1;
1100 case DRV_INSTALL
: return DRVCNF_RESTART
;
1101 case DRV_REMOVE
: return DRVCNF_RESTART
;
1104 case MCI_OPEN_DRIVER
: return CDAUDIO_mciOpen(dwDevID
, dwParam1
, (LPMCI_OPEN_PARMS32A
)dwParam2
);
1106 case MCI_CLOSE_DRIVER
: return CDAUDIO_mciClose(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1107 case MCI_GETDEVCAPS
: return CDAUDIO_mciGetDevCaps(dwDevID
, dwParam1
, (LPMCI_GETDEVCAPS_PARMS
)dwParam2
);
1108 case MCI_INFO
: return CDAUDIO_mciInfo(dwDevID
, dwParam1
, (LPMCI_INFO_PARMS16
)dwParam2
);
1109 case MCI_STATUS
: return CDAUDIO_mciStatus(dwDevID
, dwParam1
, (LPMCI_STATUS_PARMS
)dwParam2
);
1110 case MCI_SET
: return CDAUDIO_mciSet(dwDevID
, dwParam1
, (LPMCI_SET_PARMS
)dwParam2
);
1111 case MCI_PLAY
: return CDAUDIO_mciPlay(dwDevID
, dwParam1
, (LPMCI_PLAY_PARMS
)dwParam2
);
1112 case MCI_STOP
: return CDAUDIO_mciStop(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1113 case MCI_PAUSE
: return CDAUDIO_mciPause(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1114 case MCI_RESUME
: return CDAUDIO_mciResume(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1115 case MCI_SEEK
: return CDAUDIO_mciSeek(dwDevID
, dwParam1
, (LPMCI_SEEK_PARMS
)dwParam2
);
1116 /* FIXME: I wonder if those two next items are really called ? */
1117 case MCI_SET_DOOR_OPEN
: return CDAUDIO_mciSetDoor(dwDevID
, TRUE
);
1118 case MCI_SET_DOOR_CLOSED
: return CDAUDIO_mciSetDoor(dwDevID
, FALSE
);
1135 WARN(cdaudio
, "Unsupported command=%s\n", MCI_CommandToString(wMsg
));
1138 * This is incorrect according to Microsoft...
1139 * http://support.microsoft.com/support/kb/articles/q137/5/79.asp
1143 FIXME(cdaudio, "Shouldn't receive a MCI_OPEN or CLOSE message\n");
1147 TRACE(cdaudio
, "Sending msg=%s to default driver proc\n", MCI_CommandToString(wMsg
));
1148 return DefDriverProc32(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
1150 return MCIERR_UNRECOGNIZED_COMMAND
;
1152 return MCIERR_HARDWARE
;
1156 /*-----------------------------------------------------------------------*/