git.oblomov.eu Git - wine/blob - dlls/mcicda/mcicda.c

   1 /*
   2  * MCI driver for audio CD (MCICDA)
   3  *
   4  * Copyright 1994    Martin Ayotte
   5  * Copyright 1998-99 Eric Pouech
   6  * Copyright 2000    Andreas Mohr
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27
  28 #define WIN32_NO_STATUS
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "wingdi.h"
  32 #include "winuser.h"
  33 #include "wownt32.h"
  34 #include "mmddk.h"
  35 #include "winioctl.h"
  36 #include "ntddcdrm.h"
  37 #include "winternl.h"
  38 #include "wine/debug.h"
  39 #include "wine/unicode.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(mcicda);
  42
  43 #define CDFRAMES_PERSEC                 75
  44 #define CDFRAMES_PERMIN                 (CDFRAMES_PERSEC * 60)
  45 #define FRAME_OF_ADDR(a) ((a)[1] * CDFRAMES_PERMIN + (a)[2] * CDFRAMES_PERSEC + (a)[3])
  46 #define FRAME_OF_TOC(toc, idx)  FRAME_OF_ADDR((toc).TrackData[idx - (toc).FirstTrack].Address)
  47
  48 typedef struct {
  49     UINT                wDevID;
  50     int                 nUseCount;          /* Incremented for each shared open */
  51     BOOL                fShareable;         /* TRUE if first open was shareable */
  52     WORD                wNotifyDeviceID;    /* MCI device ID with a pending notification */
  53     HANDLE              hCallback;          /* Callback handle for pending notification */
  54     DWORD               dwTimeFormat;
  55     HANDLE              handle;
  56 } WINE_MCICDAUDIO;
  57
  58 /*-----------------------------------------------------------------------*/
  59
  60 /**************************************************************************
  61  *                              MCICDA_drvOpen                  [internal]
  62  */
  63 static  DWORD   MCICDA_drvOpen(LPCWSTR str, LPMCI_OPEN_DRIVER_PARMSW modp)
  64 {
  65     WINE_MCICDAUDIO*    wmcda;
  66
  67     if (!modp) return 0xFFFFFFFF;
  68
  69     wmcda = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCICDAUDIO));
  70
  71     if (!wmcda)
  72         return 0;
  73
  74     wmcda->wDevID = modp->wDeviceID;
  75     mciSetDriverData(wmcda->wDevID, (DWORD_PTR)wmcda);
  76     modp->wCustomCommandTable = MCI_NO_COMMAND_TABLE;
  77     modp->wType = MCI_DEVTYPE_CD_AUDIO;
  78     return modp->wDeviceID;
  79 }
  80
  81 /**************************************************************************
  82  *                              MCICDA_drvClose                 [internal]
  83  */
  84 static  DWORD   MCICDA_drvClose(DWORD dwDevID)
  85 {
  86     WINE_MCICDAUDIO*  wmcda = (WINE_MCICDAUDIO*)mciGetDriverData(dwDevID);
  87
  88     if (wmcda) {
  89         HeapFree(GetProcessHeap(), 0, wmcda);
  90         mciSetDriverData(dwDevID, 0);
  91     }
  92     return (dwDevID == 0xFFFFFFFF) ? 1 : 0;
  93 }
  94
  95 /**************************************************************************
  96  *                              MCICDA_GetOpenDrv               [internal]
  97  */
  98 static WINE_MCICDAUDIO*  MCICDA_GetOpenDrv(UINT wDevID)
  99 {
 100     WINE_MCICDAUDIO*    wmcda = (WINE_MCICDAUDIO*)mciGetDriverData(wDevID);
 101
 102     if (wmcda == NULL || wmcda->nUseCount == 0) {
 103         WARN("Invalid wDevID=%u\n", wDevID);
 104         return 0;
 105     }
 106     return wmcda;
 107 }
 108
 109 /**************************************************************************
 110  *                              MCICDA_GetStatus                [internal]
 111  */
 112 static  DWORD    MCICDA_GetStatus(WINE_MCICDAUDIO* wmcda)
 113 {
 114     CDROM_SUB_Q_DATA_FORMAT     fmt;
 115     SUB_Q_CHANNEL_DATA          data;
 116     DWORD                       br;
 117     DWORD                       mode = MCI_MODE_NOT_READY;
 118
 119     fmt.Format = IOCTL_CDROM_CURRENT_POSITION;
 120     if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_Q_CHANNEL, &fmt, sizeof(fmt),
 121                          &data, sizeof(data), &br, NULL)) {
 122         if (GetLastError() == ERROR_NOT_READY) mode = MCI_MODE_OPEN;
 123     } else {
 124         switch (data.CurrentPosition.Header.AudioStatus)
 125         {
 126         case AUDIO_STATUS_IN_PROGRESS:          mode = MCI_MODE_PLAY;   break;
 127         case AUDIO_STATUS_PAUSED:               mode = MCI_MODE_PAUSE;  break;
 128         case AUDIO_STATUS_NO_STATUS:
 129         case AUDIO_STATUS_PLAY_COMPLETE:        mode = MCI_MODE_STOP;   break;
 130         case AUDIO_STATUS_PLAY_ERROR:
 131         case AUDIO_STATUS_NOT_SUPPORTED:
 132         default:
 133             break;
 134         }
 135     }
 136     return mode;
 137 }
 138
 139 /**************************************************************************
 140  *                              MCICDA_GetError                 [internal]
 141  */
 142 static  int     MCICDA_GetError(WINE_MCICDAUDIO* wmcda)
 143 {
 144     switch (GetLastError())
 145     {
 146     case ERROR_NOT_READY:     return MCIERR_DEVICE_NOT_READY;
 147     case ERROR_IO_DEVICE:     return MCIERR_HARDWARE;
 148     default:
 149         FIXME("Unknown mode %u\n", GetLastError());
 150     }
 151     return MCIERR_DRIVER_INTERNAL;
 152 }
 153
 154 /**************************************************************************
 155  *                      MCICDA_CalcFrame                        [internal]
 156  */
 157 static DWORD MCICDA_CalcFrame(WINE_MCICDAUDIO* wmcda, DWORD dwTime)
 158 {
 159     DWORD       dwFrame = 0;
 160     UINT        wTrack;
 161     CDROM_TOC   toc;
 162     DWORD       br;
 163     BYTE*       addr;
 164
 165     TRACE("(%p, %08X, %u);\n", wmcda, wmcda->dwTimeFormat, dwTime);
 166
 167     switch (wmcda->dwTimeFormat) {
 168     case MCI_FORMAT_MILLISECONDS:
 169         dwFrame = ((dwTime - 1) * CDFRAMES_PERSEC + 500) / 1000;
 170         TRACE("MILLISECONDS %u\n", dwFrame);
 171         break;
 172     case MCI_FORMAT_MSF:
 173         TRACE("MSF %02u:%02u:%02u\n",
 174               MCI_MSF_MINUTE(dwTime), MCI_MSF_SECOND(dwTime), MCI_MSF_FRAME(dwTime));
 175         dwFrame += CDFRAMES_PERMIN * MCI_MSF_MINUTE(dwTime);
 176         dwFrame += CDFRAMES_PERSEC * MCI_MSF_SECOND(dwTime);
 177         dwFrame += MCI_MSF_FRAME(dwTime);
 178         break;
 179     case MCI_FORMAT_TMSF:
 180     default: /* unknown format ! force TMSF ! ... */
 181         wTrack = MCI_TMSF_TRACK(dwTime);
 182         if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_TOC, NULL, 0,
 183                              &toc, sizeof(toc), &br, NULL))
 184             return 0;
 185         if (wTrack < toc.FirstTrack || wTrack > toc.LastTrack)
 186             return 0;
 187         TRACE("MSF %02u-%02u:%02u:%02u\n",
 188               MCI_TMSF_TRACK(dwTime), MCI_TMSF_MINUTE(dwTime),
 189               MCI_TMSF_SECOND(dwTime), MCI_TMSF_FRAME(dwTime));
 190         addr = toc.TrackData[wTrack - toc.FirstTrack].Address;
 191         TRACE("TMSF trackpos[%u]=%d:%d:%d\n",
 192               wTrack, addr[1], addr[2], addr[3]);
 193         dwFrame = CDFRAMES_PERMIN * (addr[1] + MCI_TMSF_MINUTE(dwTime)) +
 194             CDFRAMES_PERSEC * (addr[2] + MCI_TMSF_SECOND(dwTime)) +
 195             addr[3] + MCI_TMSF_FRAME(dwTime);
 196         break;
 197     }
 198     return dwFrame;
 199 }
 200
 201 /**************************************************************************
 202  *                      MCICDA_CalcTime                         [internal]
 203  */
 204 static DWORD MCICDA_CalcTime(WINE_MCICDAUDIO* wmcda, DWORD tf, DWORD dwFrame, LPDWORD lpRet)
 205 {
 206     DWORD       dwTime = 0;
 207     UINT        wTrack;
 208     UINT        wMinutes;
 209     UINT        wSeconds;
 210     UINT        wFrames;
 211     CDROM_TOC   toc;
 212     DWORD       br;
 213
 214     TRACE("(%p, %08X, %u);\n", wmcda, tf, dwFrame);
 215
 216     switch (tf) {
 217     case MCI_FORMAT_MILLISECONDS:
 218         dwTime = (dwFrame * 1000) / CDFRAMES_PERSEC + 1;
 219         TRACE("MILLISECONDS %u\n", dwTime);
 220         *lpRet = 0;
 221         break;
 222     case MCI_FORMAT_MSF:
 223         wMinutes = dwFrame / CDFRAMES_PERMIN;
 224         wSeconds = (dwFrame - CDFRAMES_PERMIN * wMinutes) / CDFRAMES_PERSEC;
 225         wFrames = dwFrame - CDFRAMES_PERMIN * wMinutes - CDFRAMES_PERSEC * wSeconds;
 226         dwTime = MCI_MAKE_MSF(wMinutes, wSeconds, wFrames);
 227         TRACE("MSF %02u:%02u:%02u -> dwTime=%u\n",
 228               wMinutes, wSeconds, wFrames, dwTime);
 229         *lpRet = MCI_COLONIZED3_RETURN;
 230         break;
 231     case MCI_FORMAT_TMSF:
 232     default:    /* unknown format ! force TMSF ! ... */
 233         if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_TOC, NULL, 0,
 234                              &toc, sizeof(toc), &br, NULL))
 235             return 0;
 236         if (dwFrame < FRAME_OF_TOC(toc, toc.FirstTrack) ||
 237             dwFrame > FRAME_OF_TOC(toc, toc.LastTrack + 1)) {
 238             ERR("Out of range value %u [%u,%u]\n",
 239                 dwFrame, FRAME_OF_TOC(toc, toc.FirstTrack),
 240                 FRAME_OF_TOC(toc, toc.LastTrack + 1));
 241             *lpRet = 0;
 242             return 0;
 243         }
 244         for (wTrack = toc.FirstTrack; wTrack <= toc.LastTrack; wTrack++) {
 245             if (FRAME_OF_TOC(toc, wTrack) > dwFrame)
 246                 break;
 247         }
 248         wTrack--;
 249         dwFrame -= FRAME_OF_TOC(toc, wTrack);
 250         wMinutes = dwFrame / CDFRAMES_PERMIN;
 251         wSeconds = (dwFrame - CDFRAMES_PERMIN * wMinutes) / CDFRAMES_PERSEC;
 252         wFrames = dwFrame - CDFRAMES_PERMIN * wMinutes - CDFRAMES_PERSEC * wSeconds;
 253         dwTime = MCI_MAKE_TMSF(wTrack, wMinutes, wSeconds, wFrames);
 254         TRACE("%02u-%02u:%02u:%02u\n", wTrack, wMinutes, wSeconds, wFrames);
 255         *lpRet = MCI_COLONIZED4_RETURN;
 256         break;
 257     }
 258     return dwTime;
 259 }
 260
 261 static DWORD MCICDA_Seek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms);
 262 static DWORD MCICDA_Stop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
 263
 264 /**************************************************************************
 265  *                              MCICDA_Open                     [internal]
 266  */
 267 static DWORD MCICDA_Open(UINT wDevID, DWORD dwFlags, LPMCI_OPEN_PARMSW lpOpenParms)
 268 {
 269     DWORD               dwDeviceID;
 270     DWORD               ret = MCIERR_HARDWARE;
 271     WINE_MCICDAUDIO*    wmcda = (WINE_MCICDAUDIO*)mciGetDriverData(wDevID);
 272     WCHAR               root[7], drive = 0;
 273     int                 count;
 274
 275     TRACE("(%04X, %08X, %p);\n", wDevID, dwFlags, lpOpenParms);
 276
 277     if (lpOpenParms == NULL)            return MCIERR_NULL_PARAMETER_BLOCK;
 278     if (wmcda == NULL)                  return MCIERR_INVALID_DEVICE_ID;
 279
 280     dwDeviceID = lpOpenParms->wDeviceID;
 281
 282     if (wmcda->nUseCount > 0) {
 283         /* The driver is already open on this channel */
 284         /* If the driver was opened shareable before and this open specifies */
 285         /* shareable then increment the use count */
 286         if (wmcda->fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
 287             ++wmcda->nUseCount;
 288         else
 289             return MCIERR_MUST_USE_SHAREABLE;
 290     } else {
 291         wmcda->nUseCount = 1;
 292         wmcda->fShareable = dwFlags & MCI_OPEN_SHAREABLE;
 293     }
 294     if (dwFlags & MCI_OPEN_ELEMENT) {
 295         if (dwFlags & MCI_OPEN_ELEMENT_ID) {
 296             WARN("MCI_OPEN_ELEMENT_ID %p! Abort\n", lpOpenParms->lpstrElementName);
 297             return MCIERR_NO_ELEMENT_ALLOWED;
 298         }
 299         TRACE("MCI_OPEN_ELEMENT element name: %s\n", debugstr_w(lpOpenParms->lpstrElementName));
 300         if (!isalpha(lpOpenParms->lpstrElementName[0]) || lpOpenParms->lpstrElementName[1] != ':' ||
 301             (lpOpenParms->lpstrElementName[2] && lpOpenParms->lpstrElementName[2] != '\\'))
 302         {
 303             WARN("MCI_OPEN_ELEMENT unsupported format: %s\n",
 304                  debugstr_w(lpOpenParms->lpstrElementName));
 305             ret = MCIERR_NO_ELEMENT_ALLOWED;
 306             goto the_error;
 307         }
 308         drive = toupper(lpOpenParms->lpstrElementName[0]);
 309         root[0] = drive; root[1] = ':'; root[2] = '\\'; root[3] = '\0';
 310         if (GetDriveTypeW(root) != DRIVE_CDROM)
 311         {
 312             ret = MCIERR_INVALID_DEVICE_NAME;
 313             goto the_error;
 314         }
 315     }
 316     else
 317     {
 318         /* drive letter isn't passed... get the dwDeviceID'th cdrom in the system */
 319         root[0] = 'A'; root[1] = ':'; root[2] = '\\'; root[3] = '\0';
 320         for (count = 0; root[0] <= 'Z'; root[0]++)
 321         {
 322             if (GetDriveTypeW(root) == DRIVE_CDROM && ++count >= dwDeviceID)
 323             {
 324                 drive = root[0];
 325                 break;
 326             }
 327         }
 328         if (!drive)
 329         {
 330             ret = MCIERR_INVALID_DEVICE_ID;
 331             goto the_error;
 332         }
 333     }
 334
 335     wmcda->wNotifyDeviceID = dwDeviceID;
 336     wmcda->dwTimeFormat = MCI_FORMAT_MSF;
 337
 338     /* now, open the handle */
 339     root[0] = root[1] = '\\'; root[2] = '.'; root[3] = '\\'; root[4] = drive; root[5] = ':'; root[6] = '\0';
 340     wmcda->handle = CreateFileW(root, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
 341     if (wmcda->handle != INVALID_HANDLE_VALUE)
 342         return 0;
 343
 344  the_error:
 345     --wmcda->nUseCount;
 346     return ret;
 347 }
 348
 349 /**************************************************************************
 350  *                              MCICDA_Close                    [internal]
 351  */
 352 static DWORD MCICDA_Close(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
 353 {
 354     WINE_MCICDAUDIO*    wmcda = MCICDA_GetOpenDrv(wDevID);
 355
 356     TRACE("(%04X, %08X, %p);\n", wDevID, dwParam, lpParms);
 357
 358     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
 359
 360     if (--wmcda->nUseCount == 0) {
 361         CloseHandle(wmcda->handle);
 362     }
 363     return 0;
 364 }
 365
 366 /**************************************************************************
 367  *                              MCICDA_GetDevCaps               [internal]
 368  */
 369 static DWORD MCICDA_GetDevCaps(UINT wDevID, DWORD dwFlags,
 370                                    LPMCI_GETDEVCAPS_PARMS lpParms)
 371 {
 372     DWORD       ret = 0;
 373
 374     TRACE("(%04X, %08X, %p);\n", wDevID, dwFlags, lpParms);
 375
 376     if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
 377
 378     if (dwFlags & MCI_GETDEVCAPS_ITEM) {
 379         TRACE("MCI_GETDEVCAPS_ITEM dwItem=%08X;\n", lpParms->dwItem);
 380
 381         switch (lpParms->dwItem) {
 382         case MCI_GETDEVCAPS_CAN_RECORD:
 383             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 384             ret = MCI_RESOURCE_RETURNED;
 385             break;
 386         case MCI_GETDEVCAPS_HAS_AUDIO:
 387             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 388             ret = MCI_RESOURCE_RETURNED;
 389             break;
 390         case MCI_GETDEVCAPS_HAS_VIDEO:
 391             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 392             ret = MCI_RESOURCE_RETURNED;
 393             break;
 394         case MCI_GETDEVCAPS_DEVICE_TYPE:
 395             lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_CD_AUDIO, MCI_DEVTYPE_CD_AUDIO);
 396             ret = MCI_RESOURCE_RETURNED;
 397             break;
 398         case MCI_GETDEVCAPS_USES_FILES:
 399             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 400             ret = MCI_RESOURCE_RETURNED;
 401             break;
 402         case MCI_GETDEVCAPS_COMPOUND_DEVICE:
 403             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 404             ret = MCI_RESOURCE_RETURNED;
 405             break;
 406         case MCI_GETDEVCAPS_CAN_EJECT:
 407             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 408             ret = MCI_RESOURCE_RETURNED;
 409             break;
 410         case MCI_GETDEVCAPS_CAN_PLAY:
 411             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 412             ret = MCI_RESOURCE_RETURNED;
 413             break;
 414         case MCI_GETDEVCAPS_CAN_SAVE:
 415             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 416             ret = MCI_RESOURCE_RETURNED;
 417             break;
 418         default:
 419             ERR("Unsupported %x devCaps item\n", lpParms->dwItem);
 420             return MCIERR_UNRECOGNIZED_COMMAND;
 421         }
 422     } else {
 423         TRACE("No GetDevCaps-Item !\n");
 424         return MCIERR_UNRECOGNIZED_COMMAND;
 425     }
 426     TRACE("lpParms->dwReturn=%08X;\n", lpParms->dwReturn);
 427     return ret;
 428 }
 429
 430 static DWORD CDROM_Audio_GetSerial(CDROM_TOC* toc)
 431 {
 432     unsigned long serial = 0;
 433     int i;
 434     WORD wMagic;
 435     DWORD dwStart, dwEnd;
 436
 437     /*
 438      * wMagic collects the wFrames from track 1
 439      * dwStart, dwEnd collect the beginning and end of the disc respectively, in
 440      * frames.
 441      * There it is collected for correcting the serial when there are less than
 442      * 3 tracks.
 443      */
 444     wMagic = toc->TrackData[0].Address[3];
 445     dwStart = FRAME_OF_TOC(*toc, toc->FirstTrack);
 446
 447     for (i = 0; i <= toc->LastTrack - toc->FirstTrack; i++) {
 448         serial += (toc->TrackData[i].Address[1] << 16) |
 449             (toc->TrackData[i].Address[2] << 8) | toc->TrackData[i].Address[3];
 450     }
 451     dwEnd = FRAME_OF_TOC(*toc, toc->LastTrack + 1);
 452
 453     if (toc->LastTrack - toc->FirstTrack + 1 < 3)
 454         serial += wMagic + (dwEnd - dwStart);
 455
 456     return serial;
 457 }
 458
 459
 460 /**************************************************************************
 461  *                              MCICDA_Info                     [internal]
 462  */
 463 static DWORD MCICDA_Info(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMSW lpParms)
 464 {
 465     LPCWSTR             str = NULL;
 466     WINE_MCICDAUDIO*    wmcda = MCICDA_GetOpenDrv(wDevID);
 467     DWORD               ret = 0;
 468     WCHAR               buffer[16];
 469
 470     TRACE("(%04X, %08X, %p);\n", wDevID, dwFlags, lpParms);
 471
 472     if (lpParms == NULL || lpParms->lpstrReturn == NULL)
 473         return MCIERR_NULL_PARAMETER_BLOCK;
 474     if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
 475
 476     TRACE("buf=%p, len=%u\n", lpParms->lpstrReturn, lpParms->dwRetSize);
 477
 478     if (dwFlags & MCI_INFO_PRODUCT) {
 479         static const WCHAR wszAudioCd[] = {'W','i','n','e','\'','s',' ','a','u','d','i','o',' ','C','D',0};
 480         str = wszAudioCd;
 481     } else if (dwFlags & MCI_INFO_MEDIA_UPC) {
 482         ret = MCIERR_NO_IDENTITY;
 483     } else if (dwFlags & MCI_INFO_MEDIA_IDENTITY) {
 484         DWORD       res = 0;
 485         CDROM_TOC   toc;
 486         DWORD       br;
 487         static const WCHAR wszLu[] = {'%','l','u',0};
 488
 489         if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_TOC, NULL, 0,
 490                              &toc, sizeof(toc), &br, NULL)) {
 491             return MCICDA_GetError(wmcda);
 492         }
 493
 494         res = CDROM_Audio_GetSerial(&toc);
 495         sprintfW(buffer, wszLu, res);
 496         str = buffer;
 497     } else {
 498         WARN("Don't know this info command (%u)\n", dwFlags);
 499         ret = MCIERR_UNRECOGNIZED_COMMAND;
 500     }
 501     if (str) {
 502         if (lpParms->dwRetSize <= strlenW(str)) {
 503             lstrcpynW(lpParms->lpstrReturn, str, lpParms->dwRetSize - 1);
 504             ret = MCIERR_PARAM_OVERFLOW;
 505         } else {
 506             strcpyW(lpParms->lpstrReturn, str);
 507         }
 508     } else {
 509         *lpParms->lpstrReturn = 0;
 510     }
 511     TRACE("=> %s (%d)\n", debugstr_w(lpParms->lpstrReturn), ret);
 512     return ret;
 513 }
 514
 515 /**************************************************************************
 516  *                              MCICDA_Status                   [internal]
 517  */
 518 static DWORD MCICDA_Status(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
 519 {
 520     WINE_MCICDAUDIO*            wmcda = MCICDA_GetOpenDrv(wDevID);
 521     DWORD                       ret = 0;
 522     CDROM_SUB_Q_DATA_FORMAT     fmt;
 523     SUB_Q_CHANNEL_DATA          data;
 524     CDROM_TOC                   toc;
 525     DWORD                       br;
 526
 527     TRACE("(%04X, %08X, %p);\n", wDevID, dwFlags, lpParms);
 528
 529     if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
 530     if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
 531
 532     if (dwFlags & MCI_NOTIFY) {
 533         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 534         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 535                         wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 536     }
 537     if (dwFlags & MCI_STATUS_ITEM) {
 538         TRACE("dwItem = %x\n", lpParms->dwItem);
 539         switch (lpParms->dwItem) {
 540         case MCI_STATUS_CURRENT_TRACK:
 541             fmt.Format = IOCTL_CDROM_CURRENT_POSITION;
 542             if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_Q_CHANNEL, &fmt, sizeof(fmt),
 543                                  &data, sizeof(data), &br, NULL))
 544             {
 545                 return MCICDA_GetError(wmcda);
 546             }
 547             lpParms->dwReturn = data.CurrentPosition.TrackNumber;
 548             TRACE("CURRENT_TRACK=%u!\n", lpParms->dwReturn);
 549             break;
 550         case MCI_STATUS_LENGTH:
 551             if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_TOC, NULL, 0,
 552                                  &toc, sizeof(toc), &br, NULL)) {
 553                 WARN("error reading TOC !\n");
 554                 return MCICDA_GetError(wmcda);
 555             }
 556             if (dwFlags & MCI_TRACK) {
 557                 TRACE("MCI_TRACK #%u LENGTH=??? !\n", lpParms->dwTrack);
 558                 if (lpParms->dwTrack < toc.FirstTrack || lpParms->dwTrack > toc.LastTrack)
 559                     return MCIERR_OUTOFRANGE;
 560                 lpParms->dwReturn = FRAME_OF_TOC(toc, lpParms->dwTrack + 1) -
 561                     FRAME_OF_TOC(toc, lpParms->dwTrack);
 562                 /* Windows returns one frame less than the total track length for the
 563                    last track on the CD.  See CDDB HOWTO.  Verified on Win95OSR2. */
 564                 if (lpParms->dwTrack == toc.LastTrack)
 565                     lpParms->dwReturn--;
 566             } else {
 567                 /* Sum of the lengths of all of the tracks.  Inherits the
 568                    'off by one frame' behavior from the length of the last track.
 569                    See above comment. */
 570                 lpParms->dwReturn = FRAME_OF_TOC(toc, toc.LastTrack + 1) -
 571                     FRAME_OF_TOC(toc, toc.FirstTrack) - 1;
 572             }
 573             lpParms->dwReturn = MCICDA_CalcTime(wmcda,
 574                                                  (wmcda->dwTimeFormat == MCI_FORMAT_TMSF)
 575                                                     ? MCI_FORMAT_MSF : wmcda->dwTimeFormat,
 576                                                  lpParms->dwReturn,
 577                                                  &ret);
 578             TRACE("LENGTH=%u !\n", lpParms->dwReturn);
 579             break;
 580         case MCI_STATUS_MODE:
 581             lpParms->dwReturn = MCICDA_GetStatus(wmcda);
 582             TRACE("MCI_STATUS_MODE=%08X !\n", lpParms->dwReturn);
 583             lpParms->dwReturn = MAKEMCIRESOURCE(lpParms->dwReturn, lpParms->dwReturn);
 584             ret = MCI_RESOURCE_RETURNED;
 585             break;
 586         case MCI_STATUS_MEDIA_PRESENT:
 587             lpParms->dwReturn = (MCICDA_GetStatus(wmcda) == MCI_MODE_OPEN) ?
 588                 MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 589             TRACE("MCI_STATUS_MEDIA_PRESENT =%c!\n", LOWORD(lpParms->dwReturn) ? 'Y' : 'N');
 590             ret = MCI_RESOURCE_RETURNED;
 591             break;
 592         case MCI_STATUS_NUMBER_OF_TRACKS:
 593             if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_TOC, NULL, 0,
 594                                  &toc, sizeof(toc), &br, NULL)) {
 595                 WARN("error reading TOC !\n");
 596                 return MCICDA_GetError(wmcda);
 597             }
 598             lpParms->dwReturn = toc.LastTrack - toc.FirstTrack + 1;
 599             TRACE("MCI_STATUS_NUMBER_OF_TRACKS = %u !\n", lpParms->dwReturn);
 600             if (lpParms->dwReturn == (WORD)-1)
 601                 return MCICDA_GetError(wmcda);
 602             break;
 603         case MCI_STATUS_POSITION:
 604             if (dwFlags & MCI_STATUS_START) {
 605                 if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_TOC, NULL, 0,
 606                                      &toc, sizeof(toc), &br, NULL)) {
 607                     WARN("error reading TOC !\n");
 608                     return MCICDA_GetError(wmcda);
 609                 }
 610                 lpParms->dwReturn = FRAME_OF_TOC(toc, toc.FirstTrack);
 611                 TRACE("get MCI_STATUS_START !\n");
 612             } else if (dwFlags & MCI_TRACK) {
 613                 if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_TOC, NULL, 0,
 614                                      &toc, sizeof(toc), &br, NULL)) {
 615                     WARN("error reading TOC !\n");
 616                     return MCICDA_GetError(wmcda);
 617                 }
 618                 if (lpParms->dwTrack < toc.FirstTrack || lpParms->dwTrack > toc.LastTrack)
 619                     return MCIERR_OUTOFRANGE;
 620                 lpParms->dwReturn = FRAME_OF_TOC(toc, lpParms->dwTrack);
 621                 TRACE("get MCI_TRACK #%u !\n", lpParms->dwTrack);
 622             } else {
 623                 fmt.Format = IOCTL_CDROM_CURRENT_POSITION;
 624                 if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_Q_CHANNEL, &fmt, sizeof(fmt),
 625                                      &data, sizeof(data), &br, NULL)) {
 626                     return MCICDA_GetError(wmcda);
 627                 }
 628                 lpParms->dwReturn = FRAME_OF_ADDR(data.CurrentPosition.AbsoluteAddress);
 629             }
 630             lpParms->dwReturn = MCICDA_CalcTime(wmcda, wmcda->dwTimeFormat, lpParms->dwReturn, &ret);
 631             TRACE("MCI_STATUS_POSITION=%08X !\n", lpParms->dwReturn);
 632             break;
 633         case MCI_STATUS_READY:
 634             TRACE("MCI_STATUS_READY !\n");
 635             switch (MCICDA_GetStatus(wmcda))
 636             {
 637             case MCI_MODE_NOT_READY:
 638             case MCI_MODE_OPEN:
 639                 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 640                 break;
 641             default:
 642                 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 643                 break;
 644             }
 645             TRACE("MCI_STATUS_READY=%u!\n", LOWORD(lpParms->dwReturn));
 646             ret = MCI_RESOURCE_RETURNED;
 647             break;
 648         case MCI_STATUS_TIME_FORMAT:
 649             lpParms->dwReturn = MAKEMCIRESOURCE(wmcda->dwTimeFormat, MCI_FORMAT_RETURN_BASE + wmcda->dwTimeFormat);
 650             TRACE("MCI_STATUS_TIME_FORMAT=%08x!\n", LOWORD(lpParms->dwReturn));
 651             ret = MCI_RESOURCE_RETURNED;
 652             break;
 653         case 4001: /* FIXME: for bogus FullCD */
 654         case MCI_CDA_STATUS_TYPE_TRACK:
 655             if (!(dwFlags & MCI_TRACK))
 656                 ret = MCIERR_MISSING_PARAMETER;
 657             else {
 658                 if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_TOC, NULL, 0,
 659                                      &toc, sizeof(toc), &br, NULL)) {
 660                     WARN("error reading TOC !\n");
 661                     return MCICDA_GetError(wmcda);
 662                 }
 663                 if (lpParms->dwTrack < toc.FirstTrack || lpParms->dwTrack > toc.LastTrack)
 664                     ret = MCIERR_OUTOFRANGE;
 665                 else
 666                     lpParms->dwReturn = (toc.TrackData[lpParms->dwTrack - toc.FirstTrack].Control & 0x04) ?
 667                                          MCI_CDA_TRACK_OTHER : MCI_CDA_TRACK_AUDIO;
 668             }
 669             TRACE("MCI_CDA_STATUS_TYPE_TRACK[%d]=%d\n", lpParms->dwTrack, lpParms->dwReturn);
 670             break;
 671         default:
 672             FIXME("unknown command %08X !\n", lpParms->dwItem);
 673             return MCIERR_UNRECOGNIZED_COMMAND;
 674         }
 675     } else {
 676         WARN("not MCI_STATUS_ITEM !\n");
 677     }
 678     return ret;
 679 }
 680
 681 /**************************************************************************
 682  *                              MCICDA_SkipDataTracks           [internal]
 683  */
 684 static DWORD MCICDA_SkipDataTracks(WINE_MCICDAUDIO* wmcda,DWORD *frame)
 685 {
 686   int i;
 687   DWORD br;
 688   CDROM_TOC toc;
 689   if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_TOC, NULL, 0,
 690                       &toc, sizeof(toc), &br, NULL)) {
 691     WARN("error reading TOC !\n");
 692     return MCICDA_GetError(wmcda);
 693   }
 694   /* Locate first track whose starting frame is bigger than frame */
 695   for(i=toc.FirstTrack;i<=toc.LastTrack+1;i++)
 696     if ( FRAME_OF_TOC(toc, i) > *frame ) break;
 697   if (i <= toc.FirstTrack && i>toc.LastTrack+1) {
 698     i = 0; /* requested address is out of range: go back to start */
 699     *frame = FRAME_OF_TOC(toc,toc.FirstTrack);
 700   }
 701   else
 702     i--;
 703   /* i points to last track whose start address is not greater than frame.
 704    * Now skip non-audio tracks */
 705   for(;i<=toc.LastTrack+1;i++)
 706     if ( ! (toc.TrackData[i-toc.FirstTrack].Control & 4) )
 707       break;
 708   /* The frame will be an address in the next audio track or
 709    * address of lead-out. */
 710   if ( FRAME_OF_TOC(toc, i) > *frame )
 711     *frame = FRAME_OF_TOC(toc, i);
 712   return 0;
 713 }
 714
 715 /**************************************************************************
 716  *                              MCICDA_Play                     [internal]
 717  */
 718 static DWORD MCICDA_Play(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
 719 {
 720     WINE_MCICDAUDIO*            wmcda = MCICDA_GetOpenDrv(wDevID);
 721     DWORD                       ret = 0, start, end;
 722     DWORD                       br;
 723     CDROM_PLAY_AUDIO_MSF        play;
 724     CDROM_SUB_Q_DATA_FORMAT     fmt;
 725     SUB_Q_CHANNEL_DATA          data;
 726     CDROM_TOC                   toc;
 727
 728     TRACE("(%04X, %08X, %p);\n", wDevID, dwFlags, lpParms);
 729
 730     if (lpParms == NULL)
 731         return MCIERR_NULL_PARAMETER_BLOCK;
 732
 733     if (wmcda == NULL)
 734         return MCIERR_INVALID_DEVICE_ID;
 735
 736     if (dwFlags & MCI_FROM) {
 737         start = MCICDA_CalcFrame(wmcda, lpParms->dwFrom);
 738         if ( (ret=MCICDA_SkipDataTracks(wmcda, &start)) )
 739           return ret;
 740         TRACE("MCI_FROM=%08X -> %u\n", lpParms->dwFrom, start);
 741     } else {
 742         fmt.Format = IOCTL_CDROM_CURRENT_POSITION;
 743         if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_Q_CHANNEL, &fmt, sizeof(fmt),
 744                              &data, sizeof(data), &br, NULL)) {
 745             return MCICDA_GetError(wmcda);
 746         }
 747         start = FRAME_OF_ADDR(data.CurrentPosition.AbsoluteAddress);
 748         if ( (ret=MCICDA_SkipDataTracks(wmcda, &start)) )
 749           return ret;
 750     }
 751     if (dwFlags & MCI_TO) {
 752         end = MCICDA_CalcFrame(wmcda, lpParms->dwTo);
 753         TRACE("MCI_TO=%08X -> %u\n", lpParms->dwTo, end);
 754     } else {
 755         if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_TOC, NULL, 0,
 756                              &toc, sizeof(toc), &br, NULL)) {
 757             WARN("error reading TOC !\n");
 758             return MCICDA_GetError(wmcda);
 759         }
 760         end = FRAME_OF_TOC(toc, toc.LastTrack + 1) - 1;
 761     }
 762     TRACE("Playing from %u to %u\n", start, end);
 763     play.StartingM = start / CDFRAMES_PERMIN;
 764     play.StartingS = (start / CDFRAMES_PERSEC) % 60;
 765     play.StartingF = start % CDFRAMES_PERSEC;
 766     play.EndingM   = end / CDFRAMES_PERMIN;
 767     play.EndingS   = (end / CDFRAMES_PERSEC) % 60;
 768     play.EndingF   = end % CDFRAMES_PERSEC;
 769     if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_PLAY_AUDIO_MSF, &play, sizeof(play),
 770                          NULL, 0, &br, NULL)) {
 771         ret = MCIERR_HARDWARE;
 772     } else if (dwFlags & MCI_NOTIFY) {
 773         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 774         /*
 775           mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 776           wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 777         */
 778     }
 779     return ret;
 780 }
 781
 782 /**************************************************************************
 783  *                              MCICDA_Stop                     [internal]
 784  */
 785 static DWORD MCICDA_Stop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 786 {
 787     WINE_MCICDAUDIO*    wmcda = MCICDA_GetOpenDrv(wDevID);
 788     DWORD               br;
 789
 790     TRACE("(%04X, %08X, %p);\n", wDevID, dwFlags, lpParms);
 791
 792     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
 793
 794     if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_STOP_AUDIO, NULL, 0, NULL, 0, &br, NULL))
 795         return MCIERR_HARDWARE;
 796
 797     if (lpParms && (dwFlags & MCI_NOTIFY)) {
 798         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 799         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 800                         wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 801     }
 802     return 0;
 803 }
 804
 805 /**************************************************************************
 806  *                              MCICDA_Pause                    [internal]
 807  */
 808 static DWORD MCICDA_Pause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 809 {
 810     WINE_MCICDAUDIO*    wmcda = MCICDA_GetOpenDrv(wDevID);
 811     DWORD               br;
 812
 813     TRACE("(%04X, %08X, %p);\n", wDevID, dwFlags, lpParms);
 814
 815     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
 816
 817     if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_PAUSE_AUDIO, NULL, 0, NULL, 0, &br, NULL))
 818         return MCIERR_HARDWARE;
 819
 820     if (lpParms && (dwFlags & MCI_NOTIFY)) {
 821         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 822         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 823                         wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 824     }
 825     return 0;
 826 }
 827
 828 /**************************************************************************
 829  *                              MCICDA_Resume                   [internal]
 830  */
 831 static DWORD MCICDA_Resume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 832 {
 833     WINE_MCICDAUDIO*    wmcda = MCICDA_GetOpenDrv(wDevID);
 834     DWORD               br;
 835
 836     TRACE("(%04X, %08X, %p);\n", wDevID, dwFlags, lpParms);
 837
 838     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
 839
 840     if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_RESUME_AUDIO, NULL, 0, NULL, 0, &br, NULL))
 841         return MCIERR_HARDWARE;
 842
 843     if (lpParms && (dwFlags & MCI_NOTIFY)) {
 844         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 845         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 846                         wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 847     }
 848     return 0;
 849 }
 850
 851 /**************************************************************************
 852  *                              MCICDA_Seek                     [internal]
 853  */
 854 static DWORD MCICDA_Seek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
 855 {
 856     DWORD                       at;
 857     WINE_MCICDAUDIO*            wmcda = MCICDA_GetOpenDrv(wDevID);
 858     CDROM_SEEK_AUDIO_MSF        seek;
 859     DWORD                       br, ret;
 860     CDROM_TOC                   toc;
 861
 862     TRACE("(%04X, %08X, %p);\n", wDevID, dwFlags, lpParms);
 863
 864     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
 865     if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
 866
 867     if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_TOC, NULL, 0,
 868                          &toc, sizeof(toc), &br, NULL)) {
 869         WARN("error reading TOC !\n");
 870         return MCICDA_GetError(wmcda);
 871     }
 872     switch (dwFlags & ~(MCI_NOTIFY|MCI_WAIT)) {
 873     case MCI_SEEK_TO_START:
 874         TRACE("Seeking to start\n");
 875         at = FRAME_OF_TOC(toc,toc.FirstTrack);
 876         if ( (ret=MCICDA_SkipDataTracks(wmcda, &at)) )
 877           return ret;
 878         break;
 879     case MCI_SEEK_TO_END:
 880         TRACE("Seeking to end\n");
 881         at = FRAME_OF_TOC(toc, toc.LastTrack + 1) - 1;
 882         if ( (ret=MCICDA_SkipDataTracks(wmcda, &at)) )
 883           return ret;
 884         break;
 885     case MCI_TO:
 886         TRACE("Seeking to %u\n", lpParms->dwTo);
 887         at = MCICDA_CalcFrame(wmcda, lpParms->dwTo);
 888         if ( (ret=MCICDA_SkipDataTracks(wmcda, &at)) )
 889           return ret;
 890         break;
 891     default:
 892         TRACE("Unknown seek action %08lX\n",
 893               (dwFlags & ~(MCI_NOTIFY|MCI_WAIT)));
 894         return MCIERR_UNSUPPORTED_FUNCTION;
 895     }
 896     seek.M = at / CDFRAMES_PERMIN;
 897     seek.S = (at / CDFRAMES_PERSEC) % 60;
 898     seek.F = at % CDFRAMES_PERSEC;
 899     if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_SEEK_AUDIO_MSF, &seek, sizeof(seek),
 900                          NULL, 0, &br, NULL))
 901         return MCIERR_HARDWARE;
 902
 903     if (dwFlags & MCI_NOTIFY) {
 904         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 905         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 906                           wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 907     }
 908     return 0;
 909 }
 910
 911 /**************************************************************************
 912  *                              MCICDA_SetDoor                  [internal]
 913  */
 914 static DWORD    MCICDA_SetDoor(UINT wDevID, BOOL open)
 915 {
 916     WINE_MCICDAUDIO*    wmcda = MCICDA_GetOpenDrv(wDevID);
 917     DWORD               br;
 918
 919     TRACE("(%04x, %s) !\n", wDevID, (open) ? "OPEN" : "CLOSE");
 920
 921     if (wmcda == NULL) return MCIERR_INVALID_DEVICE_ID;
 922
 923     if (!DeviceIoControl(wmcda->handle,
 924                          (open) ? IOCTL_STORAGE_EJECT_MEDIA : IOCTL_STORAGE_LOAD_MEDIA,
 925                          NULL, 0, NULL, 0, &br, NULL))
 926         return MCIERR_HARDWARE;
 927
 928     return 0;
 929 }
 930
 931 /**************************************************************************
 932  *                              MCICDA_Set                      [internal]
 933  */
 934 static DWORD MCICDA_Set(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
 935 {
 936     WINE_MCICDAUDIO*    wmcda = MCICDA_GetOpenDrv(wDevID);
 937
 938     TRACE("(%04X, %08X, %p);\n", wDevID, dwFlags, lpParms);
 939
 940     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
 941
 942     if (dwFlags & MCI_SET_DOOR_OPEN) {
 943         MCICDA_SetDoor(wDevID, TRUE);
 944     }
 945     if (dwFlags & MCI_SET_DOOR_CLOSED) {
 946         MCICDA_SetDoor(wDevID, FALSE);
 947     }
 948
 949     /* only functions which require valid lpParms below this line ! */
 950     if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
 951     /*
 952       TRACE("dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
 953       TRACE("dwAudio=%08lX\n", lpParms->dwAudio);
 954     */
 955     if (dwFlags & MCI_SET_TIME_FORMAT) {
 956         switch (lpParms->dwTimeFormat) {
 957         case MCI_FORMAT_MILLISECONDS:
 958             TRACE("MCI_FORMAT_MILLISECONDS !\n");
 959             break;
 960         case MCI_FORMAT_MSF:
 961             TRACE("MCI_FORMAT_MSF !\n");
 962             break;
 963         case MCI_FORMAT_TMSF:
 964             TRACE("MCI_FORMAT_TMSF !\n");
 965             break;
 966         default:
 967             WARN("bad time format !\n");
 968             return MCIERR_BAD_TIME_FORMAT;
 969         }
 970         wmcda->dwTimeFormat = lpParms->dwTimeFormat;
 971     }
 972     if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION;
 973     if (dwFlags & MCI_SET_ON) return MCIERR_UNSUPPORTED_FUNCTION;
 974     if (dwFlags & MCI_SET_OFF) return MCIERR_UNSUPPORTED_FUNCTION;
 975     if (dwFlags & MCI_NOTIFY) {
 976         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n",
 977               lpParms->dwCallback);
 978         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 979                         wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 980     }
 981     return 0;
 982 }
 983
 984 /**************************************************************************
 985  *                      DriverProc (MCICDA.@)
 986  */
 987 LRESULT CALLBACK MCICDA_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
 988                                    LPARAM dwParam1, LPARAM dwParam2)
 989 {
 990     switch(wMsg) {
 991     case DRV_LOAD:              return 1;
 992     case DRV_FREE:              return 1;
 993     case DRV_OPEN:              return MCICDA_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
 994     case DRV_CLOSE:             return MCICDA_drvClose(dwDevID);
 995     case DRV_ENABLE:            return 1;
 996     case DRV_DISABLE:           return 1;
 997     case DRV_QUERYCONFIGURE:    return 1;
 998     case DRV_CONFIGURE:         MessageBoxA(0, "MCI audio CD driver !", "Wine Driver", MB_OK); return 1;
 999     case DRV_INSTALL:           return DRVCNF_RESTART;
1000     case DRV_REMOVE:            return DRVCNF_RESTART;
1001     }
1002
1003     if (dwDevID == 0xFFFFFFFF) return MCIERR_UNSUPPORTED_FUNCTION;
1004
1005     switch (wMsg) {
1006     case MCI_OPEN_DRIVER:       return MCICDA_Open(dwDevID, dwParam1, (LPMCI_OPEN_PARMSW)dwParam2);
1007     case MCI_CLOSE_DRIVER:      return MCICDA_Close(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
1008     case MCI_GETDEVCAPS:        return MCICDA_GetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
1009     case MCI_INFO:              return MCICDA_Info(dwDevID, dwParam1, (LPMCI_INFO_PARMSW)dwParam2);
1010     case MCI_STATUS:            return MCICDA_Status(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
1011     case MCI_SET:               return MCICDA_Set(dwDevID, dwParam1, (LPMCI_SET_PARMS)dwParam2);
1012     case MCI_PLAY:              return MCICDA_Play(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
1013     case MCI_STOP:              return MCICDA_Stop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
1014     case MCI_PAUSE:             return MCICDA_Pause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
1015     case MCI_RESUME:            return MCICDA_Resume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
1016     case MCI_SEEK:              return MCICDA_Seek(dwDevID, dwParam1, (LPMCI_SEEK_PARMS)dwParam2);
1017     /* commands that should report an error as they are not supported in
1018      * the native version */
1019     case MCI_SET_DOOR_CLOSED:
1020     case MCI_SET_DOOR_OPEN:
1021     case MCI_LOAD:
1022     case MCI_SAVE:
1023     case MCI_FREEZE:
1024     case MCI_PUT:
1025     case MCI_REALIZE:
1026     case MCI_UNFREEZE:
1027     case MCI_UPDATE:
1028     case MCI_WHERE:
1029     case MCI_STEP:
1030     case MCI_SPIN:
1031     case MCI_ESCAPE:
1032     case MCI_COPY:
1033     case MCI_CUT:
1034     case MCI_DELETE:
1035     case MCI_PASTE:
1036     case MCI_WINDOW:
1037         TRACE("Unsupported command [0x%x]\n", wMsg);
1038         break;
1039     case MCI_OPEN:
1040     case MCI_CLOSE:
1041         ERR("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1042         break;
1043     default:
1044         TRACE("Sending msg [0x%x] to default driver proc\n", wMsg);
1045         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1046     }
1047     return MCIERR_UNRECOGNIZED_COMMAND;
1048 }
1049
1050 /*-----------------------------------------------------------------------*/