multimedia/mcicda.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2 /*
   3  * Sample MCI CDAUDIO Wine Driver for Linux
   4  *
   5  * Copyright 1994    Martin Ayotte
   6  * Copyright 1998-99 Eric Pouech
   7  */
   8
   9 #include "winuser.h"
  10 #include "driver.h"
  11 #include "mmddk.h"
  12 #include "cdrom.h"
  13 #include "debugtools.h"
  14
  15 DEFAULT_DEBUG_CHANNEL(cdaudio)
  16
  17 typedef struct {
  18     UINT                wDevID;
  19     int                 nUseCount;          /* Incremented for each shared open */
  20     BOOL                fShareable;         /* TRUE if first open was shareable */
  21     WORD                wNotifyDeviceID;    /* MCI device ID with a pending notification */
  22     HANDLE              hCallback;          /* Callback handle for pending notification */
  23     DWORD               dwTimeFormat;
  24     WINE_CDAUDIO        wcda;
  25     int                 mciMode;
  26 } WINE_MCICDAUDIO;
  27
  28 /*-----------------------------------------------------------------------*/
  29
  30 /**************************************************************************
  31  *                              CDAUDIO_drvOpen                 [internal]
  32  */
  33 static  DWORD   CDAUDIO_drvOpen(LPSTR str, LPMCI_OPEN_DRIVER_PARMSA modp)
  34 {
  35     WINE_MCICDAUDIO*    wmcda = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,  sizeof(WINE_MCICDAUDIO));
  36
  37     if (!wmcda)
  38         return 0;
  39
  40     wmcda->wDevID = modp->wDeviceID;
  41     mciSetDriverData(wmcda->wDevID, (DWORD)wmcda);
  42     modp->wCustomCommandTable = MCI_NO_COMMAND_TABLE;
  43     modp->wType = MCI_DEVTYPE_SEQUENCER;
  44     return modp->wDeviceID;
  45 }
  46
  47 /**************************************************************************
  48  *                              CDAUDIO_drvClose                [internal]
  49  */
  50 static  DWORD   CDAUDIO_drvClose(DWORD dwDevID)
  51 {
  52     WINE_MCICDAUDIO*  wmcda = (WINE_MCICDAUDIO*)mciGetDriverData(dwDevID);
  53
  54     if (wmcda) {
  55         HeapFree(GetProcessHeap(), 0, wmcda);
  56         mciSetDriverData(dwDevID, 0);
  57     }
  58     return 0;
  59 }
  60
  61 /**************************************************************************
  62  *                              CDAUDIO_mciGetOpenDrv           [internal]
  63  */
  64 static WINE_MCICDAUDIO*  CDAUDIO_mciGetOpenDrv(UINT wDevID)
  65 {
  66     WINE_MCICDAUDIO*    wmcda = (WINE_MCICDAUDIO*)mciGetDriverData(wDevID);
  67
  68     if (wmcda == NULL || wmcda->nUseCount == 0 || wmcda->wcda.unixdev <= 0) {
  69         WARN("Invalid wDevID=%u\n", wDevID);
  70         return 0;
  71     }
  72     return wmcda;
  73 }
  74
  75 /**************************************************************************
  76  *                              CDAUDIO_mciMode                 [internal]
  77  */
  78 static  int     CDAUDIO_mciMode(int wcdaMode)
  79 {
  80     switch (wcdaMode) {
  81     case WINE_CDA_DONTKNOW:     return MCI_MODE_STOP;
  82     case WINE_CDA_NOTREADY:     return MCI_MODE_STOP;
  83     case WINE_CDA_OPEN:         return MCI_MODE_OPEN;
  84     case WINE_CDA_PLAY:         return MCI_MODE_PLAY;
  85     case WINE_CDA_STOP:         return MCI_MODE_STOP;
  86     case WINE_CDA_PAUSE:        return MCI_MODE_PAUSE;
  87     default:
  88         FIXME("Unknown mode %04x\n", wcdaMode);
  89     }
  90     return MCI_MODE_STOP;
  91 }
  92
  93 /**************************************************************************
  94  *                              CDAUDIO_mciGetError             [internal]
  95  */
  96 static  int     CDAUDIO_mciGetError(WINE_MCICDAUDIO* wmcda)
  97 {
  98     switch (wmcda->wcda.cdaMode) {
  99     case WINE_CDA_DONTKNOW:
 100     case WINE_CDA_NOTREADY:     return MCIERR_DEVICE_NOT_READY;
 101     case WINE_CDA_OPEN:         return MCIERR_DEVICE_OPEN;
 102     case WINE_CDA_PLAY:
 103     case WINE_CDA_STOP:
 104     case WINE_CDA_PAUSE:        break;
 105     default:
 106         FIXME("Unknown mode %04x\n", wmcda->wcda.cdaMode);
 107     }
 108     return MCIERR_DRIVER_INTERNAL;
 109 }
 110
 111 /**************************************************************************
 112  *                      CDAUDIO_CalcFrame                       [internal]
 113  */
 114 static DWORD CDAUDIO_CalcFrame(WINE_MCICDAUDIO* wmcda, DWORD dwTime)
 115 {
 116     DWORD       dwFrame = 0;
 117     UINT        wTrack;
 118
 119     TRACE("(%p, %08lX, %lu);\n", wmcda, wmcda->dwTimeFormat, dwTime);
 120
 121     switch (wmcda->dwTimeFormat) {
 122     case MCI_FORMAT_MILLISECONDS:
 123         dwFrame = (dwTime * CDFRAMES_PERSEC) / 1000;
 124         TRACE("MILLISECONDS %lu\n", dwFrame);
 125         break;
 126     case MCI_FORMAT_MSF:
 127         TRACE("MSF %02u:%02u:%02u\n",
 128               MCI_MSF_MINUTE(dwTime), MCI_MSF_SECOND(dwTime), MCI_MSF_FRAME(dwTime));
 129         dwFrame += CDFRAMES_PERMIN * MCI_MSF_MINUTE(dwTime);
 130         dwFrame += CDFRAMES_PERSEC * MCI_MSF_SECOND(dwTime);
 131         dwFrame += MCI_MSF_FRAME(dwTime);
 132         break;
 133     case MCI_FORMAT_TMSF:
 134     default:
 135         /* unknown format ! force TMSF ! ... */
 136         wTrack = MCI_TMSF_TRACK(dwTime);
 137         TRACE("MSF %02u-%02u:%02u:%02u\n",
 138               MCI_TMSF_TRACK(dwTime), MCI_TMSF_MINUTE(dwTime),
 139               MCI_TMSF_SECOND(dwTime), MCI_TMSF_FRAME(dwTime));
 140         TRACE("TMSF trackpos[%u]=%lu\n",
 141               wTrack, wmcda->wcda.lpdwTrackPos[wTrack - 1]);
 142         dwFrame = wmcda->wcda.lpdwTrackPos[wTrack - 1];
 143         dwFrame += CDFRAMES_PERMIN * MCI_TMSF_MINUTE(dwTime);
 144         dwFrame += CDFRAMES_PERSEC * MCI_TMSF_SECOND(dwTime);
 145         dwFrame += MCI_TMSF_FRAME(dwTime);
 146         break;
 147     }
 148     return dwFrame;
 149 }
 150
 151 /**************************************************************************
 152  *                      CDAUDIO_CalcTime                        [internal]
 153  */
 154 static DWORD CDAUDIO_CalcTime(WINE_MCICDAUDIO* wmcda, DWORD dwFrame, LPDWORD lpRet)
 155 {
 156     DWORD       dwTime = 0;
 157     UINT        wTrack;
 158     UINT        wMinutes;
 159     UINT        wSeconds;
 160     UINT        wFrames;
 161
 162     TRACE("(%p, %08lX, %lu);\n", wmcda, wmcda->dwTimeFormat, dwFrame);
 163
 164     switch (wmcda->dwTimeFormat) {
 165     case MCI_FORMAT_MILLISECONDS:
 166         dwTime = (dwFrame * 1000) / CDFRAMES_PERSEC;
 167         TRACE("MILLISECONDS %lu\n", dwTime);
 168         *lpRet = 0;
 169         break;
 170     case MCI_FORMAT_MSF:
 171         wMinutes = dwFrame / CDFRAMES_PERMIN;
 172         wSeconds = (dwFrame - CDFRAMES_PERMIN * wMinutes) / CDFRAMES_PERSEC;
 173         wFrames = dwFrame - CDFRAMES_PERMIN * wMinutes - CDFRAMES_PERSEC * wSeconds;
 174         dwTime = MCI_MAKE_MSF(wMinutes, wSeconds, wFrames);
 175         TRACE("MSF %02u:%02u:%02u -> dwTime=%lu\n",
 176               wMinutes, wSeconds, wFrames, dwTime);
 177         *lpRet = MCI_COLONIZED3_RETURN;
 178         break;
 179     case MCI_FORMAT_TMSF:
 180     default:
 181         /* unknown format ! force TMSF ! ... */
 182         for (wTrack = 0; wTrack < wmcda->wcda.nTracks; wTrack++) {
 183             /*dwTime += wmcda->lpdwTrackLen[wTrack - 1];
 184               TRACE("Adding trk#%u curpos=%u \n", dwTime);
 185               if (dwTime >= dwFrame) break; */
 186             if (wmcda->wcda.lpdwTrackPos[wTrack - 1] >= dwFrame) break;
 187         }
 188         wMinutes = dwFrame / CDFRAMES_PERMIN;
 189         wSeconds = (dwFrame - CDFRAMES_PERMIN * wMinutes) / CDFRAMES_PERSEC;
 190         wFrames = dwFrame - CDFRAMES_PERMIN * wMinutes - CDFRAMES_PERSEC * wSeconds;
 191         dwTime = MCI_MAKE_TMSF(wTrack, wMinutes, wSeconds, wFrames);
 192         TRACE("%02u-%02u:%02u:%02u\n", wTrack, wMinutes, wSeconds, wFrames);
 193         *lpRet = MCI_COLONIZED4_RETURN;
 194         break;
 195     }
 196     return dwTime;
 197 }
 198
 199 static DWORD CDAUDIO_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms);
 200 static DWORD CDAUDIO_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
 201
 202 /**************************************************************************
 203  *                              CDAUDIO_mciOpen                 [internal]
 204  */
 205 static DWORD CDAUDIO_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_OPEN_PARMSA lpOpenParms)
 206 {
 207     DWORD               dwDeviceID;
 208     WINE_MCICDAUDIO*    wmcda = (WINE_MCICDAUDIO*)mciGetDriverData(wDevID);
 209     MCI_SEEK_PARMS      seekParms;
 210
 211     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpOpenParms);
 212
 213     if (lpOpenParms == NULL)            return MCIERR_NULL_PARAMETER_BLOCK;
 214     if (wmcda == NULL)                  return MCIERR_INVALID_DEVICE_ID;
 215
 216     dwDeviceID = lpOpenParms->wDeviceID;
 217
 218     if (wmcda->nUseCount > 0) {
 219         /* The driver is already open on this channel */
 220         /* If the driver was opened shareable before and this open specifies */
 221         /* shareable then increment the use count */
 222         if (wmcda->fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
 223             ++wmcda->nUseCount;
 224         else
 225             return MCIERR_MUST_USE_SHAREABLE;
 226     } else {
 227         wmcda->nUseCount = 1;
 228         wmcda->fShareable = dwFlags & MCI_OPEN_SHAREABLE;
 229     }
 230     if (dwFlags & MCI_OPEN_ELEMENT) {
 231         TRACE("MCI_OPEN_ELEMENT !\n");
 232         /*              return MCIERR_NO_ELEMENT_ALLOWED; */
 233     }
 234
 235     wmcda->wNotifyDeviceID = dwDeviceID;
 236     if (CDAUDIO_Open(&wmcda->wcda) == -1) {
 237         --wmcda->nUseCount;
 238         return MCIERR_HARDWARE;
 239     }
 240     wmcda->mciMode = MCI_MODE_STOP;
 241     wmcda->dwTimeFormat = MCI_FORMAT_TMSF;
 242     if (!CDAUDIO_GetTracksInfo(&wmcda->wcda)) {
 243         WARN("error reading TracksInfo !\n");
 244         /*              return MCIERR_INTERNAL; */
 245     }
 246
 247     CDAUDIO_mciSeek(wDevID, MCI_SEEK_TO_START, &seekParms);
 248
 249     return 0;
 250 }
 251
 252 /**************************************************************************
 253  *                              CDAUDIO_mciClose                [internal]
 254  */
 255 static DWORD CDAUDIO_mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
 256 {
 257     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
 258
 259     TRACE("(%04X, %08lX, %p);\n", wDevID, dwParam, lpParms);
 260
 261     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
 262
 263     if (wmcda->nUseCount == 1) {
 264         /* FIXME: I don't think we have to stop CD on exit
 265          * CDAUDIO_mciStop(wDevID, 0, NULL);
 266          */
 267         CDAUDIO_Close(&wmcda->wcda);
 268     }
 269     wmcda->nUseCount--;
 270     return 0;
 271 }
 272
 273 /**************************************************************************
 274  *                              CDAUDIO_mciGetDevCaps           [internal]
 275  */
 276 static DWORD CDAUDIO_mciGetDevCaps(UINT wDevID, DWORD dwFlags,
 277                                    LPMCI_GETDEVCAPS_PARMS lpParms)
 278 {
 279     DWORD       ret = 0;
 280
 281     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
 282
 283     if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
 284
 285     if (dwFlags & MCI_GETDEVCAPS_ITEM) {
 286         TRACE("MCI_GETDEVCAPS_ITEM dwItem=%08lX;\n", lpParms->dwItem);
 287
 288         switch (lpParms->dwItem) {
 289         case MCI_GETDEVCAPS_CAN_RECORD:
 290             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 291             ret = MCI_RESOURCE_RETURNED;
 292             break;
 293         case MCI_GETDEVCAPS_HAS_AUDIO:
 294             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 295             ret = MCI_RESOURCE_RETURNED;
 296             break;
 297         case MCI_GETDEVCAPS_HAS_VIDEO:
 298             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 299             ret = MCI_RESOURCE_RETURNED;
 300             break;
 301         case MCI_GETDEVCAPS_DEVICE_TYPE:
 302             lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_CD_AUDIO, MCI_DEVTYPE_CD_AUDIO);
 303             ret = MCI_RESOURCE_RETURNED;
 304             break;
 305         case MCI_GETDEVCAPS_USES_FILES:
 306             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 307             ret = MCI_RESOURCE_RETURNED;
 308             break;
 309         case MCI_GETDEVCAPS_COMPOUND_DEVICE:
 310             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 311             ret = MCI_RESOURCE_RETURNED;
 312             break;
 313         case MCI_GETDEVCAPS_CAN_EJECT:
 314             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 315             ret = MCI_RESOURCE_RETURNED;
 316             break;
 317         case MCI_GETDEVCAPS_CAN_PLAY:
 318             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 319             ret = MCI_RESOURCE_RETURNED;
 320             break;
 321         case MCI_GETDEVCAPS_CAN_SAVE:
 322             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 323             ret = MCI_RESOURCE_RETURNED;
 324             break;
 325         default:
 326             ERR("Unsupported %lx devCaps item\n", lpParms->dwItem);
 327             return MCIERR_UNRECOGNIZED_COMMAND;
 328         }
 329     } else {
 330         TRACE("No GetDevCaps-Item !\n");
 331         return MCIERR_UNRECOGNIZED_COMMAND;
 332     }
 333     TRACE("lpParms->dwReturn=%08lX;\n", lpParms->dwReturn);
 334     return ret;
 335 }
 336
 337 /**************************************************************************
 338  *                              CDAUDIO_mciInfo                 [internal]
 339  */
 340 static DWORD CDAUDIO_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMSA lpParms)
 341 {
 342     LPSTR               str = 0;
 343     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
 344
 345     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
 346
 347     if (lpParms == NULL || lpParms->lpstrReturn == NULL)
 348         return MCIERR_NULL_PARAMETER_BLOCK;
 349     if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
 350
 351     TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
 352
 353     switch(dwFlags) {
 354     case MCI_INFO_PRODUCT:
 355         str = "Wine's audio CD";
 356         break;
 357     default:
 358         WARN("Don't know this info command (%lu)\n", dwFlags);
 359         return MCIERR_UNRECOGNIZED_COMMAND;
 360     }
 361     return MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, str);
 362 }
 363
 364 /**************************************************************************
 365  *                              CDAUDIO_mciStatus               [internal]
 366  */
 367 static DWORD CDAUDIO_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
 368 {
 369     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
 370     DWORD               ret = 0;
 371
 372     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
 373
 374     if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
 375     if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
 376
 377     if (dwFlags & MCI_NOTIFY) {
 378         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 379         mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 380                         wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 381     }
 382     if (dwFlags & MCI_STATUS_ITEM) {
 383         switch (lpParms->dwItem) {
 384         case MCI_STATUS_CURRENT_TRACK:
 385             if (!CDAUDIO_GetCDStatus(&wmcda->wcda)) {
 386                 return CDAUDIO_mciGetError(wmcda);
 387             }
 388             lpParms->dwReturn = wmcda->wcda.nCurTrack;
 389             TRACE("CURRENT_TRACK=%lu!\n", lpParms->dwReturn);
 390             break;
 391         case MCI_STATUS_LENGTH:
 392             if (wmcda->wcda.nTracks == 0) {
 393                 if (!CDAUDIO_GetTracksInfo(&wmcda->wcda)) {
 394                     WARN("error reading TracksInfo !\n");
 395                     return CDAUDIO_mciGetError(wmcda);
 396                 }
 397             }
 398             if (dwFlags & MCI_TRACK) {
 399                 TRACE("MCI_TRACK #%lu LENGTH=??? !\n", lpParms->dwTrack);
 400                 if (lpParms->dwTrack > wmcda->wcda.nTracks || lpParms->dwTrack == 0)
 401                     return MCIERR_OUTOFRANGE;
 402                 lpParms->dwReturn = wmcda->wcda.lpdwTrackLen[lpParms->dwTrack - 1];
 403             } else {
 404                 lpParms->dwReturn = wmcda->wcda.dwTotalLen;
 405             }
 406             lpParms->dwReturn = CDAUDIO_CalcTime(wmcda, lpParms->dwReturn, &ret);
 407             TRACE("LENGTH=%lu !\n", lpParms->dwReturn);
 408             break;
 409         case MCI_STATUS_MODE:
 410             if (!CDAUDIO_GetCDStatus(&wmcda->wcda))
 411                 return CDAUDIO_mciGetError(wmcda);
 412             lpParms->dwReturn = CDAUDIO_mciMode(wmcda->wcda.cdaMode);
 413             if (!lpParms->dwReturn) lpParms->dwReturn = wmcda->mciMode;
 414             TRACE("MCI_STATUS_MODE=%08lX !\n", lpParms->dwReturn);
 415             lpParms->dwReturn = MAKEMCIRESOURCE(lpParms->dwReturn, lpParms->dwReturn);
 416             ret = MCI_RESOURCE_RETURNED;
 417             break;
 418         case MCI_STATUS_MEDIA_PRESENT:
 419             if (!CDAUDIO_GetCDStatus(&wmcda->wcda))
 420                 return CDAUDIO_mciGetError(wmcda);
 421             lpParms->dwReturn = (wmcda->wcda.nTracks == 0) ?
 422                 MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 423             TRACE("MCI_STATUS_MEDIA_PRESENT =%s!\n", LOWORD(lpParms->dwReturn) ? "Y" : "N");
 424             ret = MCI_RESOURCE_RETURNED;
 425             break;
 426         case MCI_STATUS_NUMBER_OF_TRACKS:
 427             lpParms->dwReturn = CDAUDIO_GetNumberOfTracks(&wmcda->wcda);
 428             TRACE("MCI_STATUS_NUMBER_OF_TRACKS = %lu !\n", lpParms->dwReturn);
 429             if (lpParms->dwReturn == (WORD)-1)
 430                 return CDAUDIO_mciGetError(wmcda);
 431             break;
 432         case MCI_STATUS_POSITION:
 433             if (!CDAUDIO_GetCDStatus(&wmcda->wcda))
 434                 return CDAUDIO_mciGetError(wmcda);
 435             lpParms->dwReturn = wmcda->wcda.dwCurFrame;
 436             if (dwFlags & MCI_STATUS_START) {
 437                 lpParms->dwReturn = wmcda->wcda.dwFirstOffset;
 438                 TRACE("get MCI_STATUS_START !\n");
 439             }
 440             if (dwFlags & MCI_TRACK) {
 441                 if (lpParms->dwTrack > wmcda->wcda.nTracks || lpParms->dwTrack == 0)
 442                     return MCIERR_OUTOFRANGE;
 443                 lpParms->dwReturn = wmcda->wcda.lpdwTrackPos[lpParms->dwTrack - 1];
 444                 TRACE("get MCI_TRACK #%lu !\n", lpParms->dwTrack);
 445             }
 446             lpParms->dwReturn = CDAUDIO_CalcTime(wmcda, lpParms->dwReturn, &ret);
 447             TRACE("MCI_STATUS_POSITION=%08lX !\n", lpParms->dwReturn);
 448             break;
 449         case MCI_STATUS_READY:
 450             TRACE("MCI_STATUS_READY !\n");
 451             lpParms->dwReturn = (wmcda->wcda.cdaMode == WINE_CDA_DONTKNOW ||
 452                                  wmcda->wcda.cdaMode == WINE_CDA_NOTREADY) ?
 453                 MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 454             TRACE("MCI_STATUS_READY=%u!\n", LOWORD(lpParms->dwReturn));
 455             ret = MCI_RESOURCE_RETURNED;
 456             break;
 457         case MCI_STATUS_TIME_FORMAT:
 458             lpParms->dwReturn = MAKEMCIRESOURCE(wmcda->dwTimeFormat, wmcda->dwTimeFormat);
 459             TRACE("MCI_STATUS_TIME_FORMAT=%08x!\n", LOWORD(lpParms->dwReturn));
 460             ret = MCI_RESOURCE_RETURNED;
 461             break;
 462         case MCI_CDA_STATUS_TYPE_TRACK:
 463             if (!(dwFlags & MCI_TRACK))
 464                 ret = MCIERR_MISSING_PARAMETER;
 465             else if (lpParms->dwTrack > wmcda->wcda.nTracks || lpParms->dwTrack == 0)
 466                 ret = MCIERR_OUTOFRANGE;
 467             else
 468                 lpParms->dwReturn = (wmcda->wcda.lpbTrackFlags[lpParms->dwTrack - 1] &
 469                                      CDROM_DATA_TRACK) ? MCI_CDA_TRACK_OTHER : MCI_CDA_TRACK_AUDIO;
 470             TRACE("MCI_CDA_STATUS_TYPE_TRACK[%ld]=%08lx\n", lpParms->dwTrack, lpParms->dwReturn);
 471             break;
 472         default:
 473             FIXME("unknown command %08lX !\n", lpParms->dwItem);
 474             return MCIERR_UNRECOGNIZED_COMMAND;
 475         }
 476     } else {
 477         WARN("not MCI_STATUS_ITEM !\n");
 478     }
 479     return ret;
 480 }
 481
 482 /**************************************************************************
 483  *                              CDAUDIO_mciPlay                 [internal]
 484  */
 485 static DWORD CDAUDIO_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
 486 {
 487     int                 start, end;
 488     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
 489     DWORD               ret = 0;
 490
 491     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
 492
 493     if (lpParms == NULL) {
 494         ret = MCIERR_NULL_PARAMETER_BLOCK;
 495     } else if (wmcda == NULL) {
 496         ret = MCIERR_INVALID_DEVICE_ID;
 497     } else {
 498         if (wmcda->wcda.nTracks == 0) {
 499             if (!CDAUDIO_GetTracksInfo(&wmcda->wcda)) {
 500                 WARN("error reading TracksInfo !\n");
 501                 return MCIERR_DRIVER_INTERNAL;
 502             }
 503         }
 504         wmcda->wcda.nCurTrack = 1;
 505         if (dwFlags & MCI_FROM) {
 506             start = CDAUDIO_CalcFrame(wmcda, lpParms->dwFrom);
 507             TRACE("MCI_FROM=%08lX -> %u \n", lpParms->dwFrom, start);
 508         } else {
 509             if (!CDAUDIO_GetCDStatus(&wmcda->wcda)) return MCIERR_DRIVER_INTERNAL;
 510             start = wmcda->wcda.dwCurFrame;
 511         }
 512         if (dwFlags & MCI_TO) {
 513             end = CDAUDIO_CalcFrame(wmcda, lpParms->dwTo);
 514             TRACE("MCI_TO=%08lX -> %u \n", lpParms->dwTo, end);
 515         } else {
 516             end = wmcda->wcda.dwFirstOffset + wmcda->wcda.dwTotalLen;
 517         }
 518
 519         if (CDAUDIO_Play(&wmcda->wcda, start, end) == -1)
 520             return MCIERR_HARDWARE;
 521         wmcda->mciMode = MCI_MODE_PLAY;
 522         if (dwFlags & MCI_NOTIFY) {
 523             TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 524             /*
 525               mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 526               wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 527             */
 528         }
 529     }
 530     return ret;
 531 }
 532
 533 /**************************************************************************
 534  *                              CDAUDIO_mciStop                 [internal]
 535  */
 536 static DWORD CDAUDIO_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 537 {
 538     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
 539
 540     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
 541
 542     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
 543
 544     if (CDAUDIO_Stop(&wmcda->wcda) == -1)
 545         return MCIERR_HARDWARE;
 546
 547     wmcda->mciMode = MCI_MODE_STOP;
 548     if (lpParms && (dwFlags & MCI_NOTIFY)) {
 549         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 550         mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 551                         wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 552     }
 553     return 0;
 554 }
 555
 556 /**************************************************************************
 557  *                              CDAUDIO_mciPause                [internal]
 558  */
 559 static DWORD CDAUDIO_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 560 {
 561     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
 562
 563     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
 564
 565     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
 566
 567     if (CDAUDIO_Pause(&wmcda->wcda, 1) == -1)
 568         return MCIERR_HARDWARE;
 569     wmcda->mciMode = MCI_MODE_PAUSE;
 570     if (lpParms && (dwFlags & MCI_NOTIFY)) {
 571         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 572         mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 573                         wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 574     }
 575     return 0;
 576 }
 577
 578 /**************************************************************************
 579  *                              CDAUDIO_mciResume               [internal]
 580  */
 581 static DWORD CDAUDIO_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 582 {
 583     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
 584
 585     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
 586
 587     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
 588
 589     if (CDAUDIO_Pause(&wmcda->wcda, 0) == -1)
 590         return MCIERR_HARDWARE;
 591     wmcda->mciMode = MCI_MODE_STOP;
 592     if (lpParms && (dwFlags & MCI_NOTIFY)) {
 593         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 594         mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 595                           wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 596     }
 597     return 0;
 598 }
 599
 600 /**************************************************************************
 601  *                              CDAUDIO_mciSeek                 [internal]
 602  */
 603 static DWORD CDAUDIO_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
 604 {
 605     DWORD               at;
 606     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
 607
 608     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
 609
 610     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
 611     if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
 612
 613     wmcda->mciMode = MCI_MODE_SEEK;
 614     switch (dwFlags & ~(MCI_NOTIFY|MCI_WAIT)) {
 615     case MCI_SEEK_TO_START:
 616         TRACE("Seeking to start\n");
 617         at = 0;
 618         break;
 619     case MCI_SEEK_TO_END:
 620         TRACE("Seeking to end\n");
 621         at = wmcda->wcda.dwTotalLen;
 622         break;
 623     case MCI_TO:
 624         TRACE("Seeking to %lu\n", lpParms->dwTo);
 625         at = lpParms->dwTo;
 626         break;
 627     default:
 628         TRACE("Seeking to ??=%lu\n", dwFlags);
 629         return MCIERR_UNSUPPORTED_FUNCTION;
 630     }
 631     if (CDAUDIO_Seek(&wmcda->wcda, at) == -1) {
 632         return MCIERR_HARDWARE;
 633     }
 634     if (dwFlags & MCI_NOTIFY) {
 635         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 636         mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 637                           wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 638     }
 639     return 0;
 640 }
 641
 642 /**************************************************************************
 643  *                              CDAUDIO_mciSetDoor              [internal]
 644  */
 645 static DWORD    CDAUDIO_mciSetDoor(UINT wDevID, int open)
 646 {
 647     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
 648
 649     TRACE("(%04x, %s) !\n", wDevID, (open) ? "OPEN" : "CLOSE");
 650
 651     if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
 652
 653     if (CDAUDIO_SetDoor(&wmcda->wcda, open) == -1)
 654         return MCIERR_HARDWARE;
 655     wmcda->mciMode = (open) ? MCI_MODE_OPEN : MCI_MODE_STOP;
 656     return 0;
 657 }
 658
 659 /**************************************************************************
 660  *                              CDAUDIO_mciSet                  [internal]
 661  */
 662 static DWORD CDAUDIO_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
 663 {
 664     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
 665
 666     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
 667
 668     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
 669     if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;;
 670     /*
 671       TRACE("dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
 672       TRACE("dwAudio=%08lX\n", lpParms->dwAudio);
 673     */
 674     if (dwFlags & MCI_SET_TIME_FORMAT) {
 675         switch (lpParms->dwTimeFormat) {
 676         case MCI_FORMAT_MILLISECONDS:
 677             TRACE("MCI_FORMAT_MILLISECONDS !\n");
 678             break;
 679         case MCI_FORMAT_MSF:
 680             TRACE("MCI_FORMAT_MSF !\n");
 681             break;
 682         case MCI_FORMAT_TMSF:
 683             TRACE("MCI_FORMAT_TMSF !\n");
 684             break;
 685         default:
 686             WARN("bad time format !\n");
 687             return MCIERR_BAD_TIME_FORMAT;
 688         }
 689         wmcda->dwTimeFormat = lpParms->dwTimeFormat;
 690     }
 691     if (dwFlags & MCI_SET_DOOR_OPEN) {
 692         CDAUDIO_mciSetDoor(wDevID, TRUE);
 693     }
 694     if (dwFlags & MCI_SET_DOOR_CLOSED) {
 695         CDAUDIO_mciSetDoor(wDevID, FALSE);
 696     }
 697     if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION;
 698     if (dwFlags & MCI_SET_ON) return MCIERR_UNSUPPORTED_FUNCTION;
 699     if (dwFlags & MCI_SET_OFF) return MCIERR_UNSUPPORTED_FUNCTION;
 700     if (dwFlags & MCI_NOTIFY) {
 701         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n",
 702               lpParms->dwCallback);
 703         mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
 704                           wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 705     }
 706     return 0;
 707 }
 708
 709 /**************************************************************************
 710  *                      MCICDAUDIO_DriverProc                   [sample driver]
 711  */
 712 LONG CALLBACK   MCICDAUDIO_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
 713                                       DWORD dwParam1, DWORD dwParam2)
 714 {
 715     switch(wMsg) {
 716     case DRV_LOAD:              return 1;
 717     case DRV_FREE:              return 1;
 718     case DRV_OPEN:              return CDAUDIO_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
 719     case DRV_CLOSE:             return CDAUDIO_drvClose(dwDevID);
 720     case DRV_ENABLE:            return 1;
 721     case DRV_DISABLE:           return 1;
 722     case DRV_QUERYCONFIGURE:    return 1;
 723     case DRV_CONFIGURE:         MessageBoxA(0, "Sample Multimedia Driver !", "Wine Driver", MB_OK); return 1;
 724     case DRV_INSTALL:           return DRVCNF_RESTART;
 725     case DRV_REMOVE:            return DRVCNF_RESTART;
 726
 727     case MCI_OPEN_DRIVER:       return CDAUDIO_mciOpen(dwDevID, dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
 728     case MCI_CLOSE_DRIVER:      return CDAUDIO_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
 729     case MCI_GETDEVCAPS:        return CDAUDIO_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
 730     case MCI_INFO:              return CDAUDIO_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMSA)dwParam2);
 731     case MCI_STATUS:            return CDAUDIO_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
 732     case MCI_SET:               return CDAUDIO_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)dwParam2);
 733     case MCI_PLAY:              return CDAUDIO_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
 734     case MCI_STOP:              return CDAUDIO_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
 735     case MCI_PAUSE:             return CDAUDIO_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
 736     case MCI_RESUME:            return CDAUDIO_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
 737     case MCI_SEEK:              return CDAUDIO_mciSeek(dwDevID, dwParam1, (LPMCI_SEEK_PARMS)dwParam2);
 738     /* FIXME: I wonder if those two next items are really called ? */
 739     case MCI_SET_DOOR_OPEN:     return CDAUDIO_mciSetDoor(dwDevID, TRUE);
 740     case MCI_SET_DOOR_CLOSED:   return CDAUDIO_mciSetDoor(dwDevID, FALSE);
 741     /* commands that should be supported */
 742     case MCI_LOAD:
 743     case MCI_SAVE:
 744     case MCI_FREEZE:
 745     case MCI_PUT:
 746     case MCI_REALIZE:
 747     case MCI_UNFREEZE:
 748     case MCI_UPDATE:
 749     case MCI_WHERE:
 750     case MCI_STEP:
 751     case MCI_SPIN:
 752     case MCI_ESCAPE:
 753     case MCI_COPY:
 754     case MCI_CUT:
 755     case MCI_DELETE:
 756     case MCI_PASTE:
 757         FIXME("Unsupported yet command=%s\n", MCI_MessageToString(wMsg));
 758         break;
 759     /* commands that should report an error */
 760     case MCI_WINDOW:
 761         FIXME("Unsupported command=%s\n", MCI_MessageToString(wMsg));
 762         break;
 763     case MCI_OPEN:
 764     case MCI_CLOSE:
 765         ERR("Shouldn't receive a MCI_OPEN or CLOSE message\n");
 766         break;
 767     default:
 768         TRACE("Sending msg=%s to default driver proc\n", MCI_MessageToString(wMsg));
 769         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 770     }
 771     return MCIERR_UNRECOGNIZED_COMMAND;
 772 }
 773
 774 /*-----------------------------------------------------------------------*/