?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Accept MCI_OPEN and MCI_CLOSE messages in MCICDAUDIO_DriverProc32().
[wine/multimedia.git] / multimedia / mcicda.c
blob7c3127da0d496c7c297e5e41ab3e54a502c169a2
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2 /*
3 * Sample MCI CDAUDIO Wine Driver for Linux
4 *
5 * Copyright 1994 Martin Ayotte
6 */
7
8 #include <errno.h>
9 #include <stdlib.h>
10 #include <unistd.h>
11 #include <string.h>
12 #include <fcntl.h>
13 #include <sys/ioctl.h>
14 #include "windows.h"
15 #include "user.h"
16 #include "driver.h"
17 #include "mmsystem.h"
18 #include "debug.h"
19 #include "multimedia.h"
20
21 #ifdef HAVE_LINUX_CDROM_H
22 # include <linux/cdrom.h>
23 #endif
24 #ifdef HAVE_LINUX_UCDROM_H
25 # include <linux/ucdrom.h>
26 #endif
27 #ifdef HAVE_MACHINE_SOUNDCARD_H
28 # include <machine/soundcard.h>
29 #endif
30 #ifdef HAVE_SYS_CDIO_H
31 # include <sys/cdio.h>
32 #endif
33
34 #ifdef __FreeBSD__
35 # define CDAUDIO_DEV "/dev/rcd0c"
36 #else
37 # define CDAUDIO_DEV "/dev/cdrom"
38 #endif
39
40 #ifdef SOUND_VERSION
41 # define IOCTL(a,b,c) ioctl(a,b,&c)
42 #else
43 # define IOCTL(a,b,c) (c = ioctl(a,b,c) )
44 #endif
45
46 #define MAX_CDAUDIODRV (1)
47 #define MAX_CDAUDIO_TRACKS 256
48
49 #define CDFRAMES_PERSEC 75
50 #define CDFRAMES_PERMIN 4500
51 #define SECONDS_PERMIN 60
52
53 #if defined(linux) || defined(__FreeBSD__)
54 typedef struct {
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;
60 DWORD dwTimeFormat;
61 int unixdev;
62 #ifdef linux
63 struct cdrom_subchnl sc;
64 #elif defined(__FreeBSD__)
65 struct cd_sub_channel_info sc;
66 #endif
67 int cdMode;
68 int mciMode;
69 UINT16 nCurTrack;
70 DWORD dwCurFrame;
71 UINT16 nTracks;
72 DWORD dwTotalLen;
73 LPDWORD lpdwTrackLen;
74 LPDWORD lpdwTrackPos;
75 LPBYTE lpbTrackFlags;
76 DWORD dwFirstOffset;
77 } WINE_CDAUDIO;
78
79 static WINE_CDAUDIO CDADev[MAX_CDAUDIODRV];
80 #endif
81
82 #ifndef CDROM_DATA_TRACK
83 #define CDROM_DATA_TRACK 0x04
84 #endif
85
86 /*-----------------------------------------------------------------------*/
87
88 /**************************************************************************
89 * CDAUDIO_mciGetOpenDrv [internal]
90 */
91 static WINE_CDAUDIO* CDAUDIO_mciGetOpenDrv(UINT16 wDevID)
92 {
93 if (wDevID >= MAX_CDAUDIODRV || CDADev[wDevID].nUseCount == 0 ||
94 CDADev[wDevID].unixdev == 0) {
95 WARN(cdaudio, "Invalid wDevID=%u\n", wDevID);
96 return 0;
97 }
98 return &CDADev[wDevID];
99 }
100
101 /**************************************************************************
102 * CDAUDIO_GetNumberOfTracks [internal]
103 */
104 static UINT16 CDAUDIO_GetNumberOfTracks(WINE_CDAUDIO* wcda)
105 {
106 #if defined(linux) || defined(__FreeBSD__)
107 #ifdef linux
108 struct cdrom_tochdr hdr;
109 #elif defined(__FreeBSD__)
110 struct ioc_toc_header hdr;
111 #endif
112
113 if (wcda->nTracks == 0) {
114 if (ioctl(wcda->unixdev,
115 #ifdef linux
116 CDROMREADTOCHDR
117 #elif defined(__FreeBSD__)
118 CDIOREADTOCHEADER
119 #endif
120 , &hdr)) {
121 WARN(cdaudio, "(%p) -- Error occured !\n", wcda);
122 return (WORD)-1;
123 }
124 #ifdef linux
125 wcda->nTracks = hdr.cdth_trk1;
126 #elif defined(__FreeBSD__)
127 wcda->nTracks = hdr.ending_track - hdr.starting_track + 1;
128 #endif
129 }
130 return wcda->nTracks;
131 #else
132 return (WORD)-1;
133 #endif
134 }
135
136
137 /**************************************************************************
138 * CDAUDIO_GetTracksInfo [internal]
139 */
140 static BOOL32 CDAUDIO_GetTracksInfo(WINE_CDAUDIO* wcda)
141 {
142 #if defined(linux) || defined(__FreeBSD__)
143 int i, length;
144 int start, last_start = 0;
145 int total_length = 0;
146 #ifdef linux
147 struct cdrom_tocentry entry;
148 #elif defined(__FreeBSD__)
149 struct ioc_read_toc_entry entry;
150 struct cd_toc_entry toc_buffer;
151 #endif
152
153 if (wcda->nTracks == 0) {
154 if (CDAUDIO_GetNumberOfTracks(wcda) == (WORD)-1) return FALSE;
155 }
156 TRACE(cdaudio,"nTracks=%u\n", wcda->nTracks);
157
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)
169 {
170 WARN(cdaudio, "error allocating track table !\n");
171 return FALSE;
172 }
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)
178 #ifdef linux
179 entry.cdte_track = CDROM_LEADOUT;
180 #elif defined(__FreeBSD__)
181 #define LEADOUT 0xaa
182 entry.starting_track = LEADOUT; /* XXX */
183 #endif
184 else
185 #ifdef linux
186 entry.cdte_track = i + 1;
187 #elif defined(__FreeBSD__)
188 entry.starting_track = i + 1;
189 #endif
190 #ifdef linux
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;
197 #endif
198 if (ioctl(wcda->unixdev,
199 #ifdef linux
200 CDROMREADTOCENTRY
201 #elif defined(__FreeBSD__)
202 CDIOREADTOCENTRYS
203 #endif
204 , &entry)) {
205 WARN(cdaudio, "error read entry\n");
206 return FALSE;
207 }
208 #ifdef linux
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;
216 #endif
217 if (i == 0) {
218 last_start = start;
219 wcda->dwFirstOffset = start;
220 TRACE(cdaudio, "dwFirstOffset=%u\n", start);
221 } else {
222 length = start - last_start;
223 last_start = 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);
229 }
230 wcda->lpbTrackFlags[i] =
231 #ifdef linux
232 (entry.cdte_adr << 4) | (entry.cdte_ctrl & 0x0f);
233 #elif defined(__FreeBSD__)
234 (toc_buffer.addr_type << 4) | (toc_buffer.control & 0x0f);
235 #endif
236 TRACE(cdaudio, "track #%u flags=%02x\n", i + 1, wcda->lpbTrackFlags[i]);
237 }
238 wcda->dwTotalLen = total_length;
239 TRACE(cdaudio,"total_len=%u\n", total_length);
240 return TRUE;
241 #else
242 return FALSE;
243 #endif
244 }
245
246 /**************************************************************************
247 * CDAUDIO_mciOpen [internal]
248 */
249 static DWORD CDAUDIO_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS32A lpOpenParms)
250 {
251 #if defined(linux) || defined(__FreeBSD__)
252 DWORD dwDeviceID;
253 WINE_CDAUDIO* wcda;
254
255 TRACE(cdaudio,"(%04X, %08lX, %p);\n", wDevID, dwFlags, lpOpenParms);
256
257 if (lpOpenParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
258 if (wDevID > MAX_CDAUDIODRV) return MCIERR_INVALID_DEVICE_ID;
259
260 dwDeviceID = lpOpenParms->wDeviceID;
261
262 wcda = &CDADev[wDevID];
263
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))
269 ++wcda->nUseCount;
270 else
271 return MCIERR_MUST_USE_SHAREABLE;
272 } else {
273 wcda->nUseCount = 1;
274 wcda->fShareable = dwFlags & MCI_OPEN_SHAREABLE;
275 }
276 if (dwFlags & MCI_OPEN_ELEMENT) {
277 TRACE(cdaudio,"MCI_OPEN_ELEMENT !\n");
278 /* return MCIERR_NO_ELEMENT_ALLOWED; */
279 }
280
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;
287
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;
294 }
295 wcda->cdMode = 0;
296 wcda->mciMode = MCI_MODE_STOP;
297 wcda->dwTimeFormat = MCI_FORMAT_TMSF;
298 wcda->nCurTrack = 0;
299 wcda->nTracks = 0;
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; */
308 }
309
310 /*
311 Moved to mmsystem.c mciOpen routine
312
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);
318 }
319 */
320 return 0;
321 #else
322 return MCIERR_HARDWARE;
323 #endif
324 }
325
326 /**************************************************************************
327 * CDAUDIO_mciClose [internal]
328 */
329 static DWORD CDAUDIO_mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
330 {
331 #if defined(linux) || defined(__FreeBSD__)
332 WINE_CDAUDIO* wcda = CDAUDIO_mciGetOpenDrv(wDevID);
333
334 TRACE(cdaudio,"(%04X, %08lX, %p);\n", wDevID, dwParam, lpParms);
335
336 if (wcda == NULL) return MCIERR_INVALID_DEVICE_ID;
337
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);
343 }
344 #endif
345 return 0;
346 }
347
348 /**************************************************************************
349 * CDAUDIO_mciGetDevCaps [internal]
350 */
351 static DWORD CDAUDIO_mciGetDevCaps(UINT16 wDevID, DWORD dwFlags,
352 LPMCI_GETDEVCAPS_PARMS lpParms)
353 {
354 #if defined(linux) || defined(__FreeBSD__)
355 TRACE(cdaudio,"(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
356
357 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
358
359 if (dwFlags & MCI_GETDEVCAPS_ITEM) {
360 TRACE(cdaudio, "MCI_GETDEVCAPS_ITEM dwItem=%08lX;\n", lpParms->dwItem);
361
362 switch(lpParms->dwItem) {
363 case MCI_GETDEVCAPS_CAN_RECORD:
364 lpParms->dwReturn = FALSE;
365 break;
366 case MCI_GETDEVCAPS_HAS_AUDIO:
367 lpParms->dwReturn = TRUE;
368 break;
369 case MCI_GETDEVCAPS_HAS_VIDEO:
370 lpParms->dwReturn = FALSE;
371 break;
372 case MCI_GETDEVCAPS_DEVICE_TYPE:
373 lpParms->dwReturn = MCI_DEVTYPE_CD_AUDIO;
374 break;
375 case MCI_GETDEVCAPS_USES_FILES:
376 lpParms->dwReturn = FALSE;
377 break;
378 case MCI_GETDEVCAPS_COMPOUND_DEVICE:
379 lpParms->dwReturn = FALSE;
380 break;
381 case MCI_GETDEVCAPS_CAN_EJECT:
382 lpParms->dwReturn = TRUE;
383 break;
384 case MCI_GETDEVCAPS_CAN_PLAY:
385 lpParms->dwReturn = TRUE;
386 break;
387 case MCI_GETDEVCAPS_CAN_SAVE:
388 lpParms->dwReturn = FALSE;
389 break;
390 default:
391 return MCIERR_UNRECOGNIZED_COMMAND;
392 }
393 }
394 TRACE(cdaudio, "lpParms->dwReturn=%08lX;\n", lpParms->dwReturn);
395 return 0;
396 #else
397 return MCIERR_INTERNAL;
398 #endif
399 }
400
401 /**************************************************************************
402 * CDAUDIO_mciInfo [internal]
403 */
404 static DWORD CDAUDIO_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_INFO_PARMS16 lpParms)
405 {
406 #if defined(linux) || defined(__FreeBSD__)
407 DWORD ret = 0;
408 LPSTR str = 0;
409 WINE_CDAUDIO* wcda = CDAUDIO_mciGetOpenDrv(wDevID);
410
411 TRACE(cdaudio,"(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
412
413 if (lpParms == NULL || lpParms->lpstrReturn == NULL) {
414 ret = MCIERR_NULL_PARAMETER_BLOCK;
415 } else if (wcda == NULL) {
416 ret = MCIERR_INVALID_DEVICE_ID;
417 } else {
418 TRACE(cdaudio, "buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
419
420 switch(dwFlags) {
421 case MCI_INFO_PRODUCT:
422 str = "Wine's audio CDROM";
423 break;
424 default:
425 WARN(cdaudio, "Don't know this info command (%lu)\n", dwFlags);
426 ret = MCIERR_UNRECOGNIZED_COMMAND;
427 }
428 }
429 if (str) {
430 ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, str);
431 } else {
432 lpParms->lpstrReturn[0] = 0;
433 }
434
435 return ret;
436 #else
437 return MCIERR_INTERNAL;
438 #endif
439 }
440
441
442 /**************************************************************************
443 * CDAUDIO_CalcFrame [internal]
444 */
445 static DWORD CDAUDIO_CalcFrame(WINE_CDAUDIO* wcda, DWORD dwTime)
446 {
447 DWORD dwFrame = 0;
448 #if defined(linux) || defined(__FreeBSD__)
449 UINT16 wTrack;
450
451 TRACE(cdaudio,"(%p, %08lX, %lu);\n", wcda, wcda->dwTimeFormat, dwTime);
452
453 switch (wcda->dwTimeFormat) {
454 case MCI_FORMAT_MILLISECONDS:
455 dwFrame = dwTime * CDFRAMES_PERSEC / 1000;
456 TRACE(cdaudio, "MILLISECONDS %lu\n", dwFrame);
457 break;
458 case MCI_FORMAT_MSF:
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);
464 break;
465 case MCI_FORMAT_TMSF:
466 default:
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);
478 break;
479 }
480 #endif
481 return dwFrame;
482 }
483
484
485 /**************************************************************************
486 * CDAUDIO_GetCDStatus [internal]
487 */
488 static BOOL32 CDAUDIO_GetCDStatus(WINE_CDAUDIO* wcda)
489 {
490 #if defined(linux) || defined(__FreeBSD__)
491 int oldmode = wcda->cdMode;
492 #ifdef __FreeBSD__
493 struct ioc_read_subchannel read_sc;
494
495 read_sc.address_format = CD_MSF_FORMAT;
496 read_sc.data_format = CD_CURRENT_POSITION;
497 read_sc.track = 0;
498 read_sc.data_len = sizeof(wcda->sc);
499 read_sc.data = (struct cd_sub_channel_info *)&wcda->sc;
500 #elif linux
501 wcda->sc.cdsc_format = CDROM_MSF;
502 #endif
503 if (ioctl(wcda->unixdev,
504 #ifdef linux
505 CDROMSUBCHNL, &wcda->sc
506 #elif defined(__FreeBSD__)
507 CDIOCREADSUBCHANNEL, &read_sc
508 #endif
509 )) {
510 TRACE(cdaudio,"opened or no_media !\n");
511 wcda->cdMode = MCI_MODE_OPEN; /* was NOT_READY */
512 return TRUE;
513 }
514 switch (
515 #ifdef linux
516 wcda->sc.cdsc_audiostatus
517 #elif defined(__FreeBSD__)
518 wcda->sc.header.audio_status
519 #endif
520 ) {
521 #ifdef linux
522 case CDROM_AUDIO_INVALID:
523 #elif defined(__FreeBSD__)
524 case CD_AS_AUDIO_INVALID:
525 #endif
526 WARN(cdaudio, "device doesn't support status, using MCI status.\n");
527 wcda->cdMode = 0;
528 break;
529 #ifdef linux
530 case CDROM_AUDIO_NO_STATUS:
531 #elif defined(__FreeBSD__)
532 case CD_AS_NO_STATUS:
533 #endif
534 wcda->cdMode = MCI_MODE_STOP;
535 TRACE(cdaudio,"MCI_MODE_STOP !\n");
536 break;
537 #ifdef linux
538 case CDROM_AUDIO_PLAY:
539 #elif defined(__FreeBSD__)
540 case CD_AS_PLAY_IN_PROGRESS:
541 #endif
542 wcda->cdMode = MCI_MODE_PLAY;
543 TRACE(cdaudio,"MCI_MODE_PLAY !\n");
544 break;
545 #ifdef linux
546 case CDROM_AUDIO_PAUSED:
547 #elif defined(__FreeBSD__)
548 case CD_AS_PLAY_PAUSED:
549 #endif
550 wcda->cdMode = MCI_MODE_PAUSE;
551 TRACE(cdaudio,"MCI_MODE_PAUSE !\n");
552 break;
553 default:
554 #ifdef linux
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);
560 #endif
561 }
562 #ifdef linux
563 wcda->nCurTrack = wcda->sc.cdsc_trk;
564 wcda->dwCurFrame =
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;
570 wcda->dwCurFrame =
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;
574 #endif
575 #ifdef linux
576 TRACE(cdaudio,"%02u-%02u:%02u:%02u \n",
577 wcda->sc.cdsc_trk,
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);
587 #endif
588
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;
593 }
594 }
595 return TRUE;
596 #else
597 return FALSE;
598 #endif
599 }
600
601
602 /**************************************************************************
603 * CDAUDIO_CalcTime [internal]
604 */
605 static DWORD CDAUDIO_CalcTime(WINE_CDAUDIO* wcda, DWORD dwFrame)
606 {
607 DWORD dwTime = 0;
608 #if defined(linux) || defined(__FreeBSD__)
609 UINT16 wTrack;
610 UINT16 wMinutes;
611 UINT16 wSeconds;
612 UINT16 wFrames;
613
614 TRACE(cdaudio,"(%p, %08lX, %lu);\n", wcda, wcda->dwTimeFormat, dwFrame);
615
616 switch (wcda->dwTimeFormat) {
617 case MCI_FORMAT_MILLISECONDS:
618 dwTime = dwFrame / CDFRAMES_PERSEC * 1000;
619 TRACE(cdaudio, "MILLISECONDS %lu\n", dwTime);
620 break;
621 case MCI_FORMAT_MSF:
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);
627 break;
628 case MCI_FORMAT_TMSF:
629 default:
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;
636 }
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);
642 break;
643 }
644 #endif
645 return dwTime;
646 }
647
648
649 /**************************************************************************
650 * CDAUDIO_mciStatus [internal]
651 */
652 static DWORD CDAUDIO_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
653 {
654 #if defined(linux) || defined(__FreeBSD__)
655 WINE_CDAUDIO* wcda = CDAUDIO_mciGetOpenDrv(wDevID);
656 DWORD ret = 0;
657
658 TRACE(cdaudio,"(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
659
660 if (lpParms == NULL) {
661 ret = MCIERR_NULL_PARAMETER_BLOCK;
662 } else if (wcda == NULL) {
663 ret = MCIERR_INVALID_DEVICE_ID;
664 } else {
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);
669 }
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);
676 return 0;
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;
682 }
683 }
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];
689 } else {
690 lpParms->dwReturn = wcda->dwTotalLen;
691 }
692 lpParms->dwReturn = CDAUDIO_CalcTime(wcda, lpParms->dwReturn);
693 TRACE(cdaudio,"LENGTH=%lu !\n", lpParms->dwReturn);
694 return 0;
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);
700 return 0;
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");
705 return 0;
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;
710 return 0;
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");
717 }
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);
723 }
724 lpParms->dwReturn = CDAUDIO_CalcTime(wcda, lpParms->dwReturn);
725 TRACE(cdaudio,"MCI_STATUS_POSITION=%08lX !\n", lpParms->dwReturn);
726 return 0;
727 case MCI_STATUS_READY:
728 TRACE(cdaudio,"MCI_STATUS_READY !\n");
729 lpParms->dwReturn = TRUE;
730 return 0;
731 case MCI_STATUS_TIME_FORMAT:
732 lpParms->dwReturn = wcda->dwTimeFormat;
733 TRACE(cdaudio,"MCI_STATUS_TIME_FORMAT =%08lx!\n", lpParms->dwReturn);
734 return 0;
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);
742 return 0;
743 default:
744 WARN(cdaudio, "unknown command %08lX !\n", lpParms->dwItem);
745 return MCIERR_UNRECOGNIZED_COMMAND;
746 }
747 }
748 }
749 WARN(cdaudio, "not MCI_STATUS_ITEM !\n");
750 return 0;
751 #else
752 return MMSYSERR_NOTENABLED;
753 #endif
754 }
755
756
757 /**************************************************************************
758 * CDAUDIO_mciPlay [internal]
759 */
760 static DWORD CDAUDIO_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
761 {
762 #if defined(linux) || defined(__FreeBSD__)
763 int start, end;
764 WINE_CDAUDIO* wcda = CDAUDIO_mciGetOpenDrv(wDevID);
765 DWORD ret = 0;
766 #ifdef linux
767 struct cdrom_msf msf;
768 #elif defined(__FreeBSD__)
769 struct ioc_play_msf msf;
770 #endif
771
772 TRACE(cdaudio,"(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
773
774 if (lpParms == NULL) {
775 ret = MCIERR_NULL_PARAMETER_BLOCK;
776 } else if (wcda == NULL) {
777 ret = MCIERR_INVALID_DEVICE_ID;
778 } else {
779 start = 0;
780 end = wcda->dwTotalLen;
781 wcda->nCurTrack = 1;
782 if (dwFlags & MCI_FROM) {
783 start = CDAUDIO_CalcFrame(wcda, lpParms->dwFrom);
784 TRACE(cdaudio,"MCI_FROM=%08lX -> %u \n", lpParms->dwFrom, start);
785 }
786 if (dwFlags & MCI_TO) {
787 end = CDAUDIO_CalcFrame(wcda, lpParms->dwTo);
788 TRACE(cdaudio, "MCI_TO=%08lX -> %u \n", lpParms->dwTo, end);
789 }
790 start += wcda->dwFirstOffset;
791 end += wcda->dwFirstOffset;
792 #ifdef linux
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;
806 #endif
807 if (ioctl(wcda->unixdev,
808 #ifdef linux
809 CDROMSTART
810 #elif defined(__FreeBSD__)
811 CDIOCSTART
812 #endif
813 )) {
814 WARN(cdaudio, "motor doesn't start !\n");
815 return MCIERR_HARDWARE;
816 }
817 if (ioctl(wcda->unixdev,
818 #ifdef linux
819 CDROMPLAYMSF
820 #elif defined(__FreeBSD__)
821 CDIOCPLAYMSF
822 #endif
823 , &msf)) {
824 WARN(cdaudio, "device doesn't play !\n");
825 return MCIERR_HARDWARE;
826 }
827 #ifdef linux
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);
835 #endif
836 wcda->mciMode = MCI_MODE_PLAY;
837 if (dwFlags & MCI_NOTIFY) {
838 TRACE(cdaudio, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
839 /*
840 mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
841 wcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
842 */
843 }
844 }
845 return ret;
846
847 #else
848 return MCIERR_HARDWARE;
849 #endif
850 }
851
852 /**************************************************************************
853 * CDAUDIO_mciStop [internal]
854 */
855 static DWORD CDAUDIO_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
856 {
857 #if defined(linux) || defined(__FreeBSD__)
858 WINE_CDAUDIO* wcda = CDAUDIO_mciGetOpenDrv(wDevID);
859
860 TRACE(cdaudio,"(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
861
862 if (wcda == NULL) return MCIERR_INVALID_DEVICE_ID;
863
864 if (ioctl(wcda->unixdev,
865 #ifdef linux
866 CDROMSTOP
867 #elif defined(__FreeBSD__)
868 CDIOCSTOP
869 #endif
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);
876 }
877 return 0;
878 #else
879 return MCIERR_HARDWARE;
880 #endif
881 }
882
883 /**************************************************************************
884 * CDAUDIO_mciPause [internal]
885 */
886 static DWORD CDAUDIO_mciPause(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
887 {
888 #if defined(linux) || defined(__FreeBSD__)
889 WINE_CDAUDIO* wcda = CDAUDIO_mciGetOpenDrv(wDevID);
890
891 TRACE(cdaudio,"(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
892
893 if (wcda == NULL) return MCIERR_INVALID_DEVICE_ID;
894
895 if (ioctl(wcda->unixdev,
896 #ifdef linux
897 CDROMPAUSE
898 #elif defined(__FreeBSD__)
899 CDIOCPAUSE
900 #endif
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);
907 }
908 return 0;
909 #else
910 return MCIERR_HARDWARE;
911 #endif
912 }
913
914 /**************************************************************************
915 * CDAUDIO_mciResume [internal]
916 */
917 static DWORD CDAUDIO_mciResume(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
918 {
919 #if defined(linux) || defined(__FreeBSD__)
920 WINE_CDAUDIO* wcda = CDAUDIO_mciGetOpenDrv(wDevID);
921
922 TRACE(cdaudio,"(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
923
924 if (wcda == NULL) return MCIERR_INVALID_DEVICE_ID;
925
926 if (ioctl(wcda->unixdev,
927 #ifdef linux
928 CDROMRESUME
929 #elif defined(__FreeBSD__)
930 CDIOCRESUME
931 #endif
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);
938 }
939 return 0;
940 #else
941 return MCIERR_HARDWARE;
942 #endif
943 }
944
945 /**************************************************************************
946 * CDAUDIO_mciSeek [internal]
947 */
948 static DWORD CDAUDIO_mciSeek(UINT16 wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
949 {
950 #if defined(linux) || defined(__FreeBSD__)
951 DWORD dwRet;
952 MCI_PLAY_PARMS PlayParms;
953 WINE_CDAUDIO* wcda = CDAUDIO_mciGetOpenDrv(wDevID);
954
955 TRACE(cdaudio,"(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
956
957 if (wcda == NULL) return MCIERR_INVALID_DEVICE_ID;
958 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
959
960 if (ioctl(wcda->unixdev,
961 #ifdef linux
962 CDROMRESUME
963 #elif defined(__FreeBSD__)
964 CDIOCRESUME
965 #endif
966 )) {
967 perror("ioctl CDROMRESUME");
968 return MCIERR_HARDWARE;
969 }
970 wcda->mciMode = MCI_MODE_SEEK;
971 switch(dwFlags) {
972 case MCI_SEEK_TO_START:
973 PlayParms.dwFrom = 0;
974 break;
975 case MCI_SEEK_TO_END:
976 PlayParms.dwFrom = wcda->dwTotalLen;
977 break;
978 case MCI_TO:
979 PlayParms.dwFrom = lpParms->dwTo;
980 break;
981 }
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);
989 }
990 return dwRet;
991 #else
992 return MCIERR_HARDWARE;
993 #endif
994 }
995
996 /**************************************************************************
997 * CDAUDIO_mciSetDoor [internal]
998 */
999 static DWORD CDAUDIO_mciSetDoor(UINT16 wDevID, int open)
1000 {
1001 WINE_CDAUDIO* wcda = CDAUDIO_mciGetOpenDrv(wDevID);
1002
1003 TRACE(cdaudio, "(%04x, %s) !\n", wDevID, (open) ? "OPEN" : "CLOSE");
1004
1005 if (wcda == NULL) return MCIERR_INVALID_DEVICE_ID;
1006
1007 #ifdef __FreeBSD__
1008 if (ioctl(wcda->unixdev, CDIOCALLOW)) return MCIERR_HARDWARE;
1009 if (open) {
1010 if (ioctl(wcda->unixdev, CDIOCEJECT)) return MCIERR_HARDWARE;
1011 wcda->mciMode = MCI_MODE_OPEN;
1012 } else {
1013 if (ioctl(wcda->unixdev, CDIOCCLOSE)) return MCIERR_HARDWARE;
1014 wcda->mciMode = MCI_MODE_STOP;
1015 }
1016 if (ioctl(wcda->unixdev, CDIOCPREVENT)) return MCIERR_HARDWARE;
1017 #elif linux
1018 if (open) {
1019 if (ioctl(wcda->unixdev, CDROMEJECT)) return MCIERR_HARDWARE;
1020 wcda->mciMode = MCI_MODE_OPEN;
1021 } else {
1022 if (ioctl(wcda->unixdev, CDROMEJECT, 1)) return MCIERR_HARDWARE;
1023 wcda->mciMode = MCI_MODE_STOP;
1024 }
1025 #endif
1026 wcda->nTracks = 0;
1027 return 0;
1028 }
1029
1030 /**************************************************************************
1031 * CDAUDIO_mciSet [internal]
1032 */
1033 static DWORD CDAUDIO_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
1034 {
1035 #if defined(linux) || defined(__FreeBSD__)
1036 WINE_CDAUDIO* wcda = CDAUDIO_mciGetOpenDrv(wDevID);
1037
1038 TRACE(cdaudio,"(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1039
1040 if (wcda == NULL) return MCIERR_INVALID_DEVICE_ID;
1041 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;;
1042 /*
1043 TRACE(cdaudio,"dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
1044 TRACE(cdaudio,"dwAudio=%08lX\n", lpParms->dwAudio);
1045 */
1046 if (dwFlags & MCI_SET_TIME_FORMAT) {
1047 switch (lpParms->dwTimeFormat) {
1048 case MCI_FORMAT_MILLISECONDS:
1049 TRACE(cdaudio, "MCI_FORMAT_MILLISECONDS !\n");
1050 break;
1051 case MCI_FORMAT_MSF:
1052 TRACE(cdaudio,"MCI_FORMAT_MSF !\n");
1053 break;
1054 case MCI_FORMAT_TMSF:
1055 TRACE(cdaudio,"MCI_FORMAT_TMSF !\n");
1056 break;
1057 default:
1058 WARN(cdaudio, "bad time format !\n");
1059 return MCIERR_BAD_TIME_FORMAT;
1060 }
1061 wcda->dwTimeFormat = lpParms->dwTimeFormat;
1062 }
1063 if (dwFlags & MCI_SET_DOOR_OPEN) {
1064 CDAUDIO_mciSetDoor(wDevID, TRUE);
1065 }
1066 if (dwFlags & MCI_SET_DOOR_CLOSED) {
1067 CDAUDIO_mciSetDoor(wDevID, TRUE);
1068 }
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);
1077 }
1078 return 0;
1079 #else
1080 return MCIERR_HARDWARE;
1081 #endif
1082 }
1083
1084 /**************************************************************************
1085 * MCICDAUDIO_DriverProc32 [sample driver]
1086 */
1087 LONG MCICDAUDIO_DriverProc32(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
1088 DWORD dwParam1, DWORD dwParam2)
1089 {
1090 #if defined(linux) || defined(__FreeBSD__)
1091 switch(wMsg) {
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;
1102
1103 case MCI_OPEN:
1104 case MCI_OPEN_DRIVER: return CDAUDIO_mciOpen(dwDevID, dwParam1, (LPMCI_OPEN_PARMS32A)dwParam2);
1105 case MCI_CLOSE:
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);
1119 case MCI_LOAD:
1120 case MCI_SAVE:
1121 case MCI_FREEZE:
1122 case MCI_PUT:
1123 case MCI_REALIZE:
1124 case MCI_UNFREEZE:
1125 case MCI_UPDATE:
1126 case MCI_WHERE:
1127 case MCI_WINDOW:
1128 case MCI_STEP:
1129 case MCI_SPIN:
1130 case MCI_ESCAPE:
1131 case MCI_COPY:
1132 case MCI_CUT:
1133 case MCI_DELETE:
1134 case MCI_PASTE:
1135 WARN(cdaudio, "Unsupported command=%s\n", MCI_CommandToString(wMsg));
1136 break;
1137 /*
1138 * This is incorrect according to Microsoft...
1139 * http://support.microsoft.com/support/kb/articles/q137/5/79.asp
1140 *
1141 case MCI_OPEN:
1142 case MCI_CLOSE:
1143 FIXME(cdaudio, "Shouldn't receive a MCI_OPEN or CLOSE message\n");
1144 break;
1145 */
1146 default:
1147 TRACE(cdaudio, "Sending msg=%s to default driver proc\n", MCI_CommandToString(wMsg));
1148 return DefDriverProc32(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1149 }
1150 return MCIERR_UNRECOGNIZED_COMMAND;
1151 #else
1152 return MCIERR_HARDWARE;
1153 #endif
1154 }
1155
1156 /*-----------------------------------------------------------------------*/
Maarten's multimedia branch