2 * Sample MCI CDAUDIO Wine Driver for Linux
4 * Copyright 1994 Martin Ayotte
12 #include <sys/ioctl.h>
20 #include <linux/soundcard.h>
21 #include <linux/cdrom.h>
23 #include <machine/soundcard.h>
28 #define CDAUDIO_DEV "/dev/rcd0c"
30 #define CDAUDIO_DEV "/dev/cdrom"
34 #define IOCTL(a,b,c) ioctl(a,b,&c)
36 #define IOCTL(a,b,c) (c = ioctl(a,b,c) )
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__)
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
;
70 static LINUX_CDAUDIO CDADev
[MAX_CDAUDIODRV
];
74 /*-----------------------------------------------------------------------*/
77 /**************************************************************************
78 * CDAUDIO_GetNumberOfTracks [internal]
80 static UINT16
CDAUDIO_GetNumberOfTracks(UINT16 wDevID
)
82 #if defined(linux) || defined(__FreeBSD__)
84 struct cdrom_tochdr hdr
;
86 struct ioc_toc_header hdr
;
89 if (CDADev
[wDevID
].nTracks
== 0) {
90 if (ioctl(CDADev
[wDevID
].unixdev
,
97 WARN(cdaudio
, "(%04X) -- Error occured !\n",
102 CDADev
[wDevID
].nTracks
= hdr
.cdth_trk1
;
104 CDADev
[wDevID
].nTracks
= hdr
.ending_track
- hdr
.starting_track
+ 1;
107 return CDADev
[wDevID
].nTracks
;
114 /**************************************************************************
115 * CDAUDIO_GetTracksInfo [internal]
117 static BOOL32
CDAUDIO_GetTracksInfo(UINT16 wDevID
)
119 #if defined(linux) || defined(__FreeBSD__)
121 int start
, last_start
= 0;
122 int total_length
= 0;
124 struct cdrom_tocentry entry
;
126 struct ioc_read_toc_entry entry
;
127 struct cd_toc_entry toc_buffer
;
130 if (CDADev
[wDevID
].nTracks
== 0) {
131 if (CDAUDIO_GetNumberOfTracks(wDevID
) == (WORD
)-1) return FALSE
;
133 TRACE(cdaudio
,"nTracks=%u\n",
134 CDADev
[wDevID
].nTracks
);
135 if (CDADev
[wDevID
].lpdwTrackLen
!= NULL
)
136 free(CDADev
[wDevID
].lpdwTrackLen
);
137 CDADev
[wDevID
].lpdwTrackLen
= (LPDWORD
)malloc(
138 (CDADev
[wDevID
].nTracks
+ 1) * sizeof(DWORD
));
139 if (CDADev
[wDevID
].lpdwTrackPos
!= NULL
)
140 free(CDADev
[wDevID
].lpdwTrackPos
);
141 CDADev
[wDevID
].lpdwTrackPos
= (LPDWORD
)malloc(
142 (CDADev
[wDevID
].nTracks
+ 1) * sizeof(DWORD
));
143 if (CDADev
[wDevID
].lpdwTrackLen
== NULL
||
144 CDADev
[wDevID
].lpdwTrackPos
== NULL
) {
145 WARN(cdaudio
, "error allocating track table !\n");
148 memset(CDADev
[wDevID
].lpdwTrackLen
, 0,
149 (CDADev
[wDevID
].nTracks
+ 1) * sizeof(DWORD
));
150 memset(CDADev
[wDevID
].lpdwTrackPos
, 0,
151 (CDADev
[wDevID
].nTracks
+ 1) * sizeof(DWORD
));
152 for (i
= 0; i
<= CDADev
[wDevID
].nTracks
; i
++) {
153 if (i
== CDADev
[wDevID
].nTracks
)
155 entry
.cdte_track
= CDROM_LEADOUT
;
158 entry
.starting_track
= LEADOUT
; /* XXX */
162 entry
.cdte_track
= i
+ 1;
164 entry
.starting_track
= i
+ 1;
167 entry
.cdte_format
= CDROM_MSF
;
169 bzero((char *)&toc_buffer
, sizeof(toc_buffer
));
170 entry
.address_format
= CD_MSF_FORMAT
;
171 entry
.data_len
= sizeof(toc_buffer
);
172 entry
.data
= &toc_buffer
;
174 if (ioctl(CDADev
[wDevID
].unixdev
,
181 WARN(cdaudio
, "error read entry\n");
185 start
= CDFRAMES_PERSEC
* (SECONDS_PERMIN
*
186 entry
.cdte_addr
.msf
.minute
+ entry
.cdte_addr
.msf
.second
) +
187 entry
.cdte_addr
.msf
.frame
;
189 start
= CDFRAMES_PERSEC
* (SECONDS_PERMIN
*
190 toc_buffer
.addr
.msf
.minute
+ toc_buffer
.addr
.msf
.second
) +
191 toc_buffer
.addr
.msf
.frame
;
195 CDADev
[wDevID
].dwFirstOffset
= start
;
196 TRACE(cdaudio
, "dwFirstOffset=%u\n",
200 length
= start
- last_start
;
202 start
= last_start
- length
;
203 total_length
+= length
;
204 CDADev
[wDevID
].lpdwTrackLen
[i
- 1] = length
;
205 CDADev
[wDevID
].lpdwTrackPos
[i
- 1] = start
;
206 TRACE(cdaudio
, "track #%u start=%u len=%u\n",
210 CDADev
[wDevID
].dwTotalLen
= total_length
;
211 TRACE(cdaudio
,"total_len=%u\n",
220 /**************************************************************************
221 * CDAUDIO_mciOpen [internal]
223 static DWORD
CDAUDIO_mciOpen(UINT16 wDevID
, DWORD dwFlags
, LPMCI_OPEN_PARMS16 lpParms
)
225 #if defined(linux) || defined(__FreeBSD__)
226 TRACE(cdaudio
,"(%04X, %08lX, %p);\n",
227 wDevID
, dwFlags
, lpParms
);
228 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
230 if (CDADev
[wDevID
].nUseCount
> 0) {
231 /* The driver already open on this channel */
232 /* If the driver was opened shareable before and this open specifies */
233 /* shareable then increment the use count */
234 if (CDADev
[wDevID
].fShareable
&& (dwFlags
& MCI_OPEN_SHAREABLE
))
235 ++CDADev
[wDevID
].nUseCount
;
237 return MCIERR_MUST_USE_SHAREABLE
;
240 CDADev
[wDevID
].nUseCount
= 1;
241 CDADev
[wDevID
].fShareable
= dwFlags
& MCI_OPEN_SHAREABLE
;
243 if (dwFlags
& MCI_OPEN_ELEMENT
) {
244 TRACE(cdaudio
,"MCI_OPEN_ELEMENT !\n");
245 /* return MCIERR_NO_ELEMENT_ALLOWED; */
247 memcpy(&CDADev
[wDevID
].openParms
, lpParms
, sizeof(MCI_OPEN_PARMS16
));
248 CDADev
[wDevID
].wNotifyDeviceID
= lpParms
->wDeviceID
;
249 CDADev
[wDevID
].unixdev
= open (CDAUDIO_DEV
, O_RDONLY
, 0);
250 if (CDADev
[wDevID
].unixdev
== -1) {
251 WARN(cdaudio
,"can't open '%s' !\n", CDAUDIO_DEV
);
252 return MCIERR_HARDWARE
;
254 CDADev
[wDevID
].mode
= 0;
255 CDADev
[wDevID
].dwTimeFormat
= MCI_FORMAT_TMSF
;
256 CDADev
[wDevID
].nCurTrack
= 0;
257 CDADev
[wDevID
].nTracks
= 0;
258 CDADev
[wDevID
].dwTotalLen
= 0;
259 CDADev
[wDevID
].dwFirstOffset
= 0;
260 CDADev
[wDevID
].lpdwTrackLen
= NULL
;
261 CDADev
[wDevID
].lpdwTrackPos
= NULL
;
262 if (!CDAUDIO_GetTracksInfo(wDevID
)) {
263 WARN(cdaudio
,"error reading TracksInfo !\n");
264 /* return MCIERR_INTERNAL; */
268 Moved to mmsystem.c mciOpen routine
270 if (dwFlags & MCI_NOTIFY) {
271 TRACE(cdaudio, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
272 lpParms->dwCallback);
273 mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
274 CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
279 return MCIERR_HARDWARE
;
283 /**************************************************************************
284 * CDAUDIO_mciClose [internal]
286 static DWORD
CDAUDIO_mciClose(UINT16 wDevID
, DWORD dwParam
, LPMCI_GENERIC_PARMS lpParms
)
288 #if defined(linux) || defined(__FreeBSD__)
289 TRACE(cdaudio
,"(%04X, %08lX, %p);\n",
290 wDevID
, dwParam
, lpParms
);
291 if (CDADev
[wDevID
].lpdwTrackLen
!= NULL
) free(CDADev
[wDevID
].lpdwTrackLen
);
292 if (CDADev
[wDevID
].lpdwTrackPos
!= NULL
) free(CDADev
[wDevID
].lpdwTrackPos
);
293 close(CDADev
[wDevID
].unixdev
);
298 /**************************************************************************
299 * CDAUDIO_mciGetDevCaps [internal]
301 static DWORD
CDAUDIO_mciGetDevCaps(UINT16 wDevID
, DWORD dwFlags
,
302 LPMCI_GETDEVCAPS_PARMS lpParms
)
304 #if defined(linux) || defined(__FreeBSD__)
305 TRACE(cdaudio
,"(%04X, %08lX, %p);\n",
306 wDevID
, dwFlags
, lpParms
);
307 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
308 if (dwFlags
& MCI_GETDEVCAPS_ITEM
) {
309 TRACE(cdaudio
, "MCI_GETDEVCAPS_ITEM dwItem=%08lX;\n",
311 switch(lpParms
->dwItem
) {
312 case MCI_GETDEVCAPS_CAN_RECORD
:
313 lpParms
->dwReturn
= FALSE
;
315 case MCI_GETDEVCAPS_HAS_AUDIO
:
316 lpParms
->dwReturn
= TRUE
;
318 case MCI_GETDEVCAPS_HAS_VIDEO
:
319 lpParms
->dwReturn
= FALSE
;
321 case MCI_GETDEVCAPS_DEVICE_TYPE
:
322 lpParms
->dwReturn
= MCI_DEVTYPE_CD_AUDIO
;
324 case MCI_GETDEVCAPS_USES_FILES
:
325 lpParms
->dwReturn
= FALSE
;
327 case MCI_GETDEVCAPS_COMPOUND_DEVICE
:
328 lpParms
->dwReturn
= FALSE
;
330 case MCI_GETDEVCAPS_CAN_EJECT
:
331 lpParms
->dwReturn
= TRUE
;
333 case MCI_GETDEVCAPS_CAN_PLAY
:
334 lpParms
->dwReturn
= TRUE
;
336 case MCI_GETDEVCAPS_CAN_SAVE
:
337 lpParms
->dwReturn
= FALSE
;
340 return MCIERR_UNRECOGNIZED_COMMAND
;
343 TRACE(cdaudio
, "lpParms->dwReturn=%08lX;\n",
347 return MCIERR_INTERNAL
;
351 /**************************************************************************
352 * CDAUDIO_mciInfo [internal]
354 static DWORD
CDAUDIO_mciInfo(UINT16 wDevID
, DWORD dwFlags
, LPMCI_INFO_PARMS16 lpParms
)
356 #if defined(linux) || defined(__FreeBSD__)
357 TRACE(cdaudio
,"(%04X, %08lX, %p);\n",
358 wDevID
, dwFlags
, lpParms
);
359 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
360 lpParms
->lpstrReturn
= NULL
;
362 case MCI_INFO_PRODUCT
:
363 lpParms
->lpstrReturn
= "Linux CDROM 0.5";
366 return MCIERR_UNRECOGNIZED_COMMAND
;
368 if (lpParms
->lpstrReturn
!= NULL
)
369 lpParms
->dwRetSize
= strlen(lpParms
->lpstrReturn
);
371 lpParms
->dwRetSize
= 0;
374 return MCIERR_INTERNAL
;
379 /**************************************************************************
380 * CDAUDIO_CalcFrame [internal]
382 static DWORD
CDAUDIO_CalcFrame(UINT16 wDevID
, DWORD dwFormatType
, DWORD dwTime
)
385 #if defined(linux) || defined(__FreeBSD__)
388 TRACE(cdaudio
,"(%04X, %08lX, %lu);\n",
389 wDevID
, dwFormatType
, dwTime
);
391 switch (dwFormatType
) {
392 case MCI_FORMAT_MILLISECONDS
:
393 dwFrame
= dwTime
* CDFRAMES_PERSEC
/ 1000;
394 TRACE(cdaudio
, "MILLISECONDS %lu\n",
398 TRACE(cdaudio
, "MSF %02u:%02u:%02u\n",
399 MCI_MSF_MINUTE(dwTime
), MCI_MSF_SECOND(dwTime
),
400 MCI_MSF_FRAME(dwTime
));
401 dwFrame
+= CDFRAMES_PERMIN
* MCI_MSF_MINUTE(dwTime
);
402 dwFrame
+= CDFRAMES_PERSEC
* MCI_MSF_SECOND(dwTime
);
403 dwFrame
+= MCI_MSF_FRAME(dwTime
);
406 /* unknown format ! force TMSF ! ... */
407 dwFormatType
= MCI_FORMAT_TMSF
;
408 case MCI_FORMAT_TMSF
:
409 wTrack
= MCI_TMSF_TRACK(dwTime
);
410 TRACE(cdaudio
, "MSF %02u-%02u:%02u:%02u\n",
411 MCI_TMSF_TRACK(dwTime
), MCI_TMSF_MINUTE(dwTime
),
412 MCI_TMSF_SECOND(dwTime
), MCI_TMSF_FRAME(dwTime
));
413 TRACE(cdaudio
, "TMSF trackpos[%u]=%lu\n",
414 wTrack
, CDADev
[wDevID
].lpdwTrackPos
[wTrack
- 1]);
415 dwFrame
= CDADev
[wDevID
].lpdwTrackPos
[wTrack
- 1];
416 dwFrame
+= CDFRAMES_PERMIN
* MCI_TMSF_MINUTE(dwTime
);
417 dwFrame
+= CDFRAMES_PERSEC
* MCI_TMSF_SECOND(dwTime
);
418 dwFrame
+= MCI_TMSF_FRAME(dwTime
);
426 /**************************************************************************
427 * CDAUDIO_GetCDStatus [internal]
429 static BOOL32
CDAUDIO_GetCDStatus(UINT16 wDevID
)
431 #if defined(linux) || defined(__FreeBSD__)
432 int oldmode
= CDADev
[wDevID
].mode
;
434 struct ioc_read_subchannel read_sc
;
436 read_sc
.address_format
= CD_MSF_FORMAT
;
437 read_sc
.data_format
= CD_CURRENT_POSITION
;
439 read_sc
.data_len
= sizeof(CDADev
[wDevID
].sc
);
440 read_sc
.data
= (struct cd_sub_channel_info
*)&CDADev
[wDevID
].sc
;
442 CDADev
[wDevID
].sc
.cdsc_format
= CDROM_MSF
;
444 if (ioctl(CDADev
[wDevID
].unixdev
,
446 CDROMSUBCHNL
, &CDADev
[wDevID
].sc
448 CDIOCREADSUBCHANNEL
, &read_sc
451 TRACE(cdaudio
,"opened or no_media !\n");
452 CDADev
[wDevID
].mode
= MCI_MODE_NOT_READY
;
457 CDADev
[wDevID
].sc
.cdsc_audiostatus
459 CDADev
[wDevID
].sc
.header
.audio_status
463 case CDROM_AUDIO_INVALID
:
465 case CD_AS_AUDIO_INVALID
:
467 WARN(cdaudio
, "device doesn't support status, returning NOT_READY.\n");
469 CDADev
[wDevID
].mode
= MCI_MODE_NOT_READY
;
471 CDADev
[wDevID
].mode
= MCI_MODE_STOP
;
475 case CDROM_AUDIO_NO_STATUS
:
477 case CD_AS_NO_STATUS
:
479 CDADev
[wDevID
].mode
= MCI_MODE_STOP
;
480 TRACE(cdaudio
,"MCI_MODE_STOP !\n");
483 case CDROM_AUDIO_PLAY
:
485 case CD_AS_PLAY_IN_PROGRESS
:
487 CDADev
[wDevID
].mode
= MCI_MODE_PLAY
;
488 TRACE(cdaudio
,"MCI_MODE_PLAY !\n");
491 case CDROM_AUDIO_PAUSED
:
493 case CD_AS_PLAY_PAUSED
:
495 CDADev
[wDevID
].mode
= MCI_MODE_PAUSE
;
496 TRACE(cdaudio
,"MCI_MODE_PAUSE !\n");
500 TRACE(cdaudio
,"status=%02X !\n",
501 CDADev
[wDevID
].sc
.cdsc_audiostatus
);
503 TRACE(cdaudio
,"status=%02X !\n",
504 CDADev
[wDevID
].sc
.header
.audio_status
);
508 CDADev
[wDevID
].nCurTrack
= CDADev
[wDevID
].sc
.cdsc_trk
;
509 CDADev
[wDevID
].dwCurFrame
=
510 CDFRAMES_PERMIN
* CDADev
[wDevID
].sc
.cdsc_absaddr
.msf
.minute
+
511 CDFRAMES_PERSEC
* CDADev
[wDevID
].sc
.cdsc_absaddr
.msf
.second
+
512 CDADev
[wDevID
].sc
.cdsc_absaddr
.msf
.frame
;
514 CDADev
[wDevID
].nCurTrack
= CDADev
[wDevID
].sc
.what
.position
.track_number
;
515 CDADev
[wDevID
].dwCurFrame
=
516 CDFRAMES_PERMIN
* CDADev
[wDevID
].sc
.what
.position
.absaddr
.msf
.minute
+
517 CDFRAMES_PERSEC
* CDADev
[wDevID
].sc
.what
.position
.absaddr
.msf
.second
+
518 CDADev
[wDevID
].sc
.what
.position
.absaddr
.msf
.frame
;
521 TRACE(cdaudio
,"%02u-%02u:%02u:%02u \n",
522 CDADev
[wDevID
].sc
.cdsc_trk
,
523 CDADev
[wDevID
].sc
.cdsc_absaddr
.msf
.minute
,
524 CDADev
[wDevID
].sc
.cdsc_absaddr
.msf
.second
,
525 CDADev
[wDevID
].sc
.cdsc_absaddr
.msf
.frame
);
527 TRACE(cdaudio
,"%02u-%02u:%02u:%02u \n",
528 CDADev
[wDevID
].sc
.what
.position
.track_number
,
529 CDADev
[wDevID
].sc
.what
.position
.absaddr
.msf
.minute
,
530 CDADev
[wDevID
].sc
.what
.position
.absaddr
.msf
.second
,
531 CDADev
[wDevID
].sc
.what
.position
.absaddr
.msf
.frame
);
534 if (oldmode
!= CDADev
[wDevID
].mode
&& oldmode
== MCI_MODE_OPEN
) {
535 if (!CDAUDIO_GetTracksInfo(wDevID
)) {
536 WARN(cdaudio
, "error updating TracksInfo !\n");
537 return MCIERR_INTERNAL
;
547 /**************************************************************************
548 * CDAUDIO_CalcTime [internal]
550 static DWORD
CDAUDIO_CalcTime(UINT16 wDevID
, DWORD dwFormatType
, DWORD dwFrame
)
553 #if defined(linux) || defined(__FreeBSD__)
559 TRACE(cdaudio
,"(%04X, %08lX, %lu);\n",
560 wDevID
, dwFormatType
, dwFrame
);
562 switch (dwFormatType
) {
563 case MCI_FORMAT_MILLISECONDS
:
564 dwTime
= dwFrame
/ CDFRAMES_PERSEC
* 1000;
565 TRACE(cdaudio
, "MILLISECONDS %lu\n",
569 wMinutes
= dwFrame
/ CDFRAMES_PERMIN
;
570 wSeconds
= (dwFrame
- CDFRAMES_PERMIN
* wMinutes
) / CDFRAMES_PERSEC
;
571 wFrames
= dwFrame
- CDFRAMES_PERMIN
* wMinutes
-
572 CDFRAMES_PERSEC
* wSeconds
;
573 dwTime
= MCI_MAKE_MSF(wMinutes
, wSeconds
, wFrames
);
574 TRACE(cdaudio
,"MSF %02u:%02u:%02u -> dwTime=%lu\n",
575 wMinutes
, wSeconds
, wFrames
, dwTime
);
578 /* unknown format ! force TMSF ! ... */
579 dwFormatType
= MCI_FORMAT_TMSF
;
580 case MCI_FORMAT_TMSF
:
581 for (wTrack
= 0; wTrack
< CDADev
[wDevID
].nTracks
; wTrack
++) {
582 /* dwTime += CDADev[wDevID].lpdwTrackLen[wTrack - 1];
583 printf("Adding trk#%u curpos=%u \n", dwTime);
584 if (dwTime >= dwFrame) break; */
585 if (CDADev
[wDevID
].lpdwTrackPos
[wTrack
- 1] >= dwFrame
) break;
587 wMinutes
= dwFrame
/ CDFRAMES_PERMIN
;
588 wSeconds
= (dwFrame
- CDFRAMES_PERMIN
* wMinutes
) / CDFRAMES_PERSEC
;
589 wFrames
= dwFrame
- CDFRAMES_PERMIN
* wMinutes
-
590 CDFRAMES_PERSEC
* wSeconds
;
591 dwTime
= MCI_MAKE_TMSF(wTrack
, wMinutes
, wSeconds
, wFrames
);
592 TRACE(cdaudio
, "%02u-%02u:%02u:%02u\n",
593 wTrack
, wMinutes
, wSeconds
, wFrames
);
601 /**************************************************************************
602 * CDAUDIO_mciStatus [internal]
604 static DWORD
CDAUDIO_mciStatus(UINT16 wDevID
, DWORD dwFlags
, LPMCI_STATUS_PARMS lpParms
)
606 #if defined(linux) || defined(__FreeBSD__)
607 TRACE(cdaudio
,"(%04X, %08lX, %p);\n",
608 wDevID
, dwFlags
, lpParms
);
609 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
610 if (CDADev
[wDevID
].unixdev
== 0) return MMSYSERR_NOTENABLED
;
611 if (dwFlags
& MCI_NOTIFY
) {
612 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
613 lpParms
->dwCallback
);
614 mciDriverNotify((HWND16
)LOWORD(lpParms
->dwCallback
),
615 CDADev
[wDevID
].wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
617 if (dwFlags
& MCI_STATUS_ITEM
) {
618 switch(lpParms
->dwItem
) {
619 case MCI_STATUS_CURRENT_TRACK
:
620 if (!CDAUDIO_GetCDStatus(wDevID
)) return MCIERR_INTERNAL
;
621 lpParms
->dwReturn
= CDADev
[wDevID
].nCurTrack
;
622 TRACE(cdaudio
,"CURRENT_TRACK=%lu!\n", lpParms
->dwReturn
);
624 case MCI_STATUS_LENGTH
:
625 if (CDADev
[wDevID
].nTracks
== 0) {
626 if (!CDAUDIO_GetTracksInfo(wDevID
)) {
627 WARN(cdaudio
, "error reading TracksInfo !\n");
628 return MCIERR_INTERNAL
;
631 if (dwFlags
& MCI_TRACK
) {
632 TRACE(cdaudio
,"MCI_TRACK #%lu LENGTH=??? !\n",
634 if (lpParms
->dwTrack
> CDADev
[wDevID
].nTracks
)
635 return MCIERR_OUTOFRANGE
;
636 lpParms
->dwReturn
= CDADev
[wDevID
].lpdwTrackLen
[lpParms
->dwTrack
];
639 lpParms
->dwReturn
= CDADev
[wDevID
].dwTotalLen
;
640 lpParms
->dwReturn
= CDAUDIO_CalcTime(wDevID
,
641 CDADev
[wDevID
].dwTimeFormat
, lpParms
->dwReturn
);
642 TRACE(cdaudio
,"LENGTH=%lu !\n", lpParms
->dwReturn
);
644 case MCI_STATUS_MODE
:
645 if (!CDAUDIO_GetCDStatus(wDevID
)) return MCIERR_INTERNAL
;
646 lpParms
->dwReturn
= CDADev
[wDevID
].mode
;
647 TRACE(cdaudio
,"MCI_STATUS_MODE=%08lX !\n",
650 case MCI_STATUS_MEDIA_PRESENT
:
651 lpParms
->dwReturn
= (CDADev
[wDevID
].nTracks
> 0) ? TRUE
: FALSE
;
652 if (lpParms
->dwReturn
== FALSE
)
653 TRACE(cdaudio
,"MEDIA_NOT_PRESENT !\n");
655 TRACE(cdaudio
,"MCI_STATUS_MEDIA_PRESENT !\n");
657 case MCI_STATUS_NUMBER_OF_TRACKS
:
658 lpParms
->dwReturn
= CDAUDIO_GetNumberOfTracks(wDevID
);
659 TRACE(cdaudio
,"MCI_STATUS_NUMBER_OF_TRACKS = %lu !\n",
661 if (lpParms
->dwReturn
== (WORD
)-1) return MCIERR_INTERNAL
;
663 case MCI_STATUS_POSITION
:
664 if (!CDAUDIO_GetCDStatus(wDevID
)) return MCIERR_INTERNAL
;
665 lpParms
->dwReturn
= CDADev
[wDevID
].dwCurFrame
;
666 if (dwFlags
& MCI_STATUS_START
) {
667 lpParms
->dwReturn
= CDADev
[wDevID
].dwFirstOffset
;
668 TRACE(cdaudio
,"get MCI_STATUS_START !\n");
670 if (dwFlags
& MCI_TRACK
) {
671 if (lpParms
->dwTrack
> CDADev
[wDevID
].nTracks
)
672 return MCIERR_OUTOFRANGE
;
673 lpParms
->dwReturn
= CDADev
[wDevID
].lpdwTrackPos
[lpParms
->dwTrack
- 1];
674 TRACE(cdaudio
,"get MCI_TRACK #%lu !\n", lpParms
->dwTrack
);
676 lpParms
->dwReturn
= CDAUDIO_CalcTime(wDevID
,
677 CDADev
[wDevID
].dwTimeFormat
, lpParms
->dwReturn
);
678 TRACE(cdaudio
,"MCI_STATUS_POSITION=%08lX !\n",
681 case MCI_STATUS_READY
:
682 TRACE(cdaudio
,"MCI_STATUS_READY !\n");
683 lpParms
->dwReturn
= TRUE
;
685 case MCI_STATUS_TIME_FORMAT
:
686 TRACE(cdaudio
,"MCI_STATUS_TIME_FORMAT !\n");
687 lpParms
->dwReturn
= CDADev
[wDevID
].dwTimeFormat
;
690 WARN(cdaudio
, "unknown command %08lX !\n", lpParms
->dwItem
);
691 return MCIERR_UNRECOGNIZED_COMMAND
;
694 WARN(cdaudio
, "not MCI_STATUS_ITEM !\n");
697 return MMSYSERR_NOTENABLED
;
702 /**************************************************************************
703 * CDAUDIO_mciPlay [internal]
705 static DWORD
CDAUDIO_mciPlay(UINT16 wDevID
, DWORD dwFlags
, LPMCI_PLAY_PARMS lpParms
)
707 #if defined(linux) || defined(__FreeBSD__)
710 struct cdrom_msf msf
;
712 struct ioc_play_msf msf
;
715 TRACE(cdaudio
,"(%04X, %08lX, %p);\n",
716 wDevID
, dwFlags
, lpParms
);
717 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
718 if (CDADev
[wDevID
].unixdev
== 0) return MMSYSERR_NOTENABLED
;
719 start
= 0; end
= CDADev
[wDevID
].dwTotalLen
;
720 CDADev
[wDevID
].nCurTrack
= 1;
721 if (dwFlags
& MCI_FROM
) {
722 start
= CDAUDIO_CalcFrame(wDevID
,
723 CDADev
[wDevID
].dwTimeFormat
, lpParms
->dwFrom
);
724 TRACE(cdaudio
,"MCI_FROM=%08lX -> %u \n",
725 lpParms
->dwFrom
, start
);
727 if (dwFlags
& MCI_TO
) {
728 end
= CDAUDIO_CalcFrame(wDevID
,
729 CDADev
[wDevID
].dwTimeFormat
, lpParms
->dwTo
);
730 TRACE(cdaudio
, "MCI_TO=%08lX -> %u \n",
733 start
+= CDADev
[wDevID
].dwFirstOffset
;
734 end
+= CDADev
[wDevID
].dwFirstOffset
;
736 msf
.cdmsf_min0
= start
/ CDFRAMES_PERMIN
;
737 msf
.cdmsf_sec0
= (start
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
738 msf
.cdmsf_frame0
= start
% CDFRAMES_PERSEC
;
739 msf
.cdmsf_min1
= end
/ CDFRAMES_PERMIN
;
740 msf
.cdmsf_sec1
= (end
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
741 msf
.cdmsf_frame1
= end
% CDFRAMES_PERSEC
;
743 msf
.start_m
= start
/ CDFRAMES_PERMIN
;
744 msf
.start_s
= (start
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
745 msf
.start_f
= start
% CDFRAMES_PERSEC
;
746 msf
.end_m
= end
/ CDFRAMES_PERMIN
;
747 msf
.end_s
= (end
% CDFRAMES_PERMIN
) / CDFRAMES_PERSEC
;
748 msf
.end_f
= end
% CDFRAMES_PERSEC
;
750 if (ioctl(CDADev
[wDevID
].unixdev
,
757 WARN(cdaudio
, "motor doesn't start !\n");
758 return MCIERR_HARDWARE
;
760 if (ioctl(CDADev
[wDevID
].unixdev
,
767 WARN(cdaudio
, "device doesn't play !\n");
768 return MCIERR_HARDWARE
;
771 TRACE(cdaudio
,"msf = %d:%d:%d %d:%d:%d\n",
772 msf
.cdmsf_min0
, msf
.cdmsf_sec0
, msf
.cdmsf_frame0
,
773 msf
.cdmsf_min1
, msf
.cdmsf_sec1
, msf
.cdmsf_frame1
);
775 TRACE(cdaudio
,"msf = %d:%d:%d %d:%d:%d\n",
776 msf
.start_m
, msf
.start_s
, msf
.start_f
,
777 msf
.end_m
, msf
.end_s
, msf
.end_f
);
779 CDADev
[wDevID
].mode
= MCI_MODE_PLAY
;
780 if (dwFlags
& MCI_NOTIFY
) {
781 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
782 lpParms
->dwCallback
);
784 mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
785 CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
790 return MCIERR_HARDWARE
;
794 /**************************************************************************
795 * CDAUDIO_mciStop [internal]
797 static DWORD
CDAUDIO_mciStop(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
799 #if defined(linux) || defined(__FreeBSD__)
800 TRACE(cdaudio
,"(%04X, %08lX, %p);\n",
801 wDevID
, dwFlags
, lpParms
);
802 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
803 if (ioctl(CDADev
[wDevID
].unixdev
,
809 )) return MCIERR_HARDWARE
;
810 CDADev
[wDevID
].mode
= MCI_MODE_STOP
;
811 if (dwFlags
& MCI_NOTIFY
) {
812 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
813 lpParms
->dwCallback
);
814 mciDriverNotify((HWND16
)LOWORD(lpParms
->dwCallback
),
815 CDADev
[wDevID
].wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
819 return MCIERR_HARDWARE
;
823 /**************************************************************************
824 * CDAUDIO_mciPause [internal]
826 static DWORD
CDAUDIO_mciPause(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
828 #if defined(linux) || defined(__FreeBSD__)
829 TRACE(cdaudio
,"(%04X, %08lX, %p);\n",
830 wDevID
, dwFlags
, lpParms
);
831 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
832 if (ioctl(CDADev
[wDevID
].unixdev
,
838 )) return MCIERR_HARDWARE
;
839 CDADev
[wDevID
].mode
= MCI_MODE_PAUSE
;
840 if (dwFlags
& MCI_NOTIFY
) {
841 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
842 lpParms
->dwCallback
);
843 mciDriverNotify((HWND16
)LOWORD(lpParms
->dwCallback
),
844 CDADev
[wDevID
].wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
848 return MCIERR_HARDWARE
;
852 /**************************************************************************
853 * CDAUDIO_mciResume [internal]
855 static DWORD
CDAUDIO_mciResume(UINT16 wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
857 #if defined(linux) || defined(__FreeBSD__)
858 TRACE(cdaudio
,"(%04X, %08lX, %p);\n",
859 wDevID
, dwFlags
, lpParms
);
860 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
861 if (ioctl(CDADev
[wDevID
].unixdev
,
867 )) return MCIERR_HARDWARE
;
868 CDADev
[wDevID
].mode
= MCI_MODE_STOP
;
869 if (dwFlags
& MCI_NOTIFY
) {
870 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
871 lpParms
->dwCallback
);
872 mciDriverNotify((HWND16
)LOWORD(lpParms
->dwCallback
),
873 CDADev
[wDevID
].wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
877 return MCIERR_HARDWARE
;
881 /**************************************************************************
882 * CDAUDIO_mciSeek [internal]
884 static DWORD
CDAUDIO_mciSeek(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SEEK_PARMS lpParms
)
886 #if defined(linux) || defined(__FreeBSD__)
888 MCI_PLAY_PARMS PlayParms
;
889 TRACE(cdaudio
,"(%04X, %08lX, %p);\n",
890 wDevID
, dwFlags
, lpParms
);
891 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
892 if (ioctl(CDADev
[wDevID
].unixdev
,
899 perror("ioctl CDROMRESUME");
900 return MCIERR_HARDWARE
;
902 CDADev
[wDevID
].mode
= MCI_MODE_SEEK
;
904 case MCI_SEEK_TO_START
:
905 PlayParms
.dwFrom
= 0;
907 case MCI_SEEK_TO_END
:
908 PlayParms
.dwFrom
= CDADev
[wDevID
].dwTotalLen
;
911 PlayParms
.dwFrom
= lpParms
->dwTo
;
914 dwRet
= CDAUDIO_mciPlay(wDevID
, MCI_WAIT
| MCI_FROM
, &PlayParms
);
915 if (dwRet
!= 0) return dwRet
;
916 dwRet
= CDAUDIO_mciStop(wDevID
, MCI_WAIT
, (LPMCI_GENERIC_PARMS
)&PlayParms
);
917 if (dwFlags
& MCI_NOTIFY
) {
918 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
919 lpParms
->dwCallback
);
920 mciDriverNotify((HWND16
)LOWORD(lpParms
->dwCallback
),
921 CDADev
[wDevID
].wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
925 return MCIERR_HARDWARE
;
930 /**************************************************************************
931 * CDAUDIO_mciSet [internal]
933 static DWORD
CDAUDIO_mciSet(UINT16 wDevID
, DWORD dwFlags
, LPMCI_SET_PARMS lpParms
)
935 #if defined(linux) || defined(__FreeBSD__)
936 TRACE(cdaudio
,"(%04X, %08lX, %p);\n",
937 wDevID
, dwFlags
, lpParms
);
938 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
940 printf("CDAUDIO_mciSet // dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
941 printf("CDAUDIO_mciSet // dwAudio=%08lX\n", lpParms->dwAudio);
943 if (dwFlags
& MCI_SET_TIME_FORMAT
) {
944 switch (lpParms
->dwTimeFormat
) {
945 case MCI_FORMAT_MILLISECONDS
:
946 TRACE(cdaudio
, "MCI_FORMAT_MILLISECONDS !\n");
949 TRACE(cdaudio
,"MCI_FORMAT_MSF !\n");
951 case MCI_FORMAT_TMSF
:
952 TRACE(cdaudio
,"MCI_FORMAT_TMSF !\n");
955 WARN(cdaudio
, "bad time format !\n");
956 return MCIERR_BAD_TIME_FORMAT
;
958 CDADev
[wDevID
].dwTimeFormat
= lpParms
->dwTimeFormat
;
960 if (dwFlags
& MCI_SET_DOOR_OPEN
) {
961 TRACE(cdaudio
, "MCI_SET_DOOR_OPEN !\n");
963 if (ioctl(CDADev
[wDevID
].unixdev
, CDIOCALLOW
)) return MCIERR_HARDWARE
;
964 if (ioctl(CDADev
[wDevID
].unixdev
, CDIOCEJECT
)) return MCIERR_HARDWARE
;
965 if (ioctl(CDADev
[wDevID
].unixdev
, CDIOCPREVENT
)) return MCIERR_HARDWARE
;
967 if (ioctl(CDADev
[wDevID
].unixdev
, CDROMEJECT
)) return MCIERR_HARDWARE
;
969 CDADev
[wDevID
].nTracks
= 0;
971 if (dwFlags
& MCI_SET_DOOR_CLOSED
) {
972 TRACE(cdaudio
, "MCI_SET_DOOR_CLOSED !\n");
974 if (ioctl(CDADev
[wDevID
].unixdev
, CDIOCALLOW
)) return MCIERR_HARDWARE
;
975 if (ioctl(CDADev
[wDevID
].unixdev
, CDIOCCLOSE
)) return MCIERR_HARDWARE
;
976 if (ioctl(CDADev
[wDevID
].unixdev
, CDIOCPREVENT
)) return MCIERR_HARDWARE
;
978 if (ioctl(CDADev
[wDevID
].unixdev
, CDROMEJECT
)) return MCIERR_HARDWARE
;
979 /* XXX should it be ",1" ??? */
981 CDADev
[wDevID
].nTracks
= 0;
983 if (dwFlags
& MCI_SET_VIDEO
) return MCIERR_UNSUPPORTED_FUNCTION
;
984 if (dwFlags
& MCI_SET_ON
) return MCIERR_UNSUPPORTED_FUNCTION
;
985 if (dwFlags
& MCI_SET_OFF
) return MCIERR_UNSUPPORTED_FUNCTION
;
986 if (dwFlags
& MCI_NOTIFY
) {
987 TRACE(cdaudio
, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
988 lpParms
->dwCallback
);
989 mciDriverNotify((HWND16
)LOWORD(lpParms
->dwCallback
),
990 CDADev
[wDevID
].wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
994 return MCIERR_HARDWARE
;
999 /**************************************************************************
1000 * CDAUDIO_DriverProc [sample driver]
1002 LONG
CDAUDIO_DriverProc(DWORD dwDevID
, HDRVR16 hDriv
, WORD wMsg
,
1003 DWORD dwParam1
, DWORD dwParam2
)
1005 #if defined(linux) || defined(__FreeBSD__)
1012 case MCI_OPEN_DRIVER
:
1014 return CDAUDIO_mciOpen(dwDevID
, dwParam1
, (LPMCI_OPEN_PARMS16
)PTR_SEG_TO_LIN(dwParam2
));
1016 case MCI_CLOSE_DRIVER
:
1018 return CDAUDIO_mciClose(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)PTR_SEG_TO_LIN(dwParam2
));
1023 case DRV_QUERYCONFIGURE
:
1026 MessageBox16(0, "Sample MultiMedia Linux Driver !",
1027 "MMLinux Driver", MB_OK
);
1030 return DRVCNF_RESTART
;
1032 return DRVCNF_RESTART
;
1033 case MCI_GETDEVCAPS
:
1034 return CDAUDIO_mciGetDevCaps(dwDevID
, dwParam1
,
1035 (LPMCI_GETDEVCAPS_PARMS
)PTR_SEG_TO_LIN(dwParam2
));
1037 return CDAUDIO_mciInfo(dwDevID
, dwParam1
,
1038 (LPMCI_INFO_PARMS16
)PTR_SEG_TO_LIN(dwParam2
));
1040 return CDAUDIO_mciStatus(dwDevID
, dwParam1
,
1041 (LPMCI_STATUS_PARMS
)PTR_SEG_TO_LIN(dwParam2
));
1043 return CDAUDIO_mciSet(dwDevID
, dwParam1
,
1044 (LPMCI_SET_PARMS
)PTR_SEG_TO_LIN(dwParam2
));
1046 return CDAUDIO_mciPlay(dwDevID
, dwParam1
,
1047 (LPMCI_PLAY_PARMS
)PTR_SEG_TO_LIN(dwParam2
));
1049 return CDAUDIO_mciStop(dwDevID
, dwParam1
,
1050 (LPMCI_GENERIC_PARMS
)PTR_SEG_TO_LIN(dwParam2
));
1052 return CDAUDIO_mciPause(dwDevID
, dwParam1
,
1053 (LPMCI_GENERIC_PARMS
)PTR_SEG_TO_LIN(dwParam2
));
1055 return CDAUDIO_mciResume(dwDevID
, dwParam1
,
1056 (LPMCI_GENERIC_PARMS
)PTR_SEG_TO_LIN(dwParam2
));
1058 return CDAUDIO_mciSeek(dwDevID
, dwParam1
,
1059 (LPMCI_SEEK_PARMS
)PTR_SEG_TO_LIN(dwParam2
));
1060 case MCI_SET_DOOR_OPEN
:
1061 TRACE(cdaudio
, "MCI_SET_DOOR_OPEN !\n");
1063 if (ioctl(CDADev
[dwDevID
].unixdev
, CDIOCALLOW
)) return MCIERR_HARDWARE
;
1064 if (ioctl(CDADev
[dwDevID
].unixdev
, CDIOCEJECT
)) return MCIERR_HARDWARE
;
1065 if (ioctl(CDADev
[dwDevID
].unixdev
, CDIOCPREVENT
)) return MCIERR_HARDWARE
;
1067 if (ioctl(CDADev
[dwDevID
].unixdev
, CDROMEJECT
)) return MCIERR_HARDWARE
;
1069 CDADev
[dwDevID
].nTracks
= 0;
1071 case MCI_SET_DOOR_CLOSED
:
1072 TRACE(cdaudio
,"MCI_SET_DOOR_CLOSED !\n");
1074 if (ioctl(CDADev
[dwDevID
].unixdev
, CDIOCALLOW
)) return MCIERR_HARDWARE
;
1075 if (ioctl(CDADev
[dwDevID
].unixdev
, CDIOCCLOSE
)) return MCIERR_HARDWARE
;
1076 if (ioctl(CDADev
[dwDevID
].unixdev
, CDIOCPREVENT
)) return MCIERR_HARDWARE
;
1078 if (ioctl(CDADev
[dwDevID
].unixdev
, CDROMEJECT
, 1)) return MCIERR_HARDWARE
;
1080 CDADev
[dwDevID
].nTracks
= 0;
1083 return DefDriverProc(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
1086 return MCIERR_HARDWARE
;
1091 /*-----------------------------------------------------------------------*/