dlls/winmm/mciavi/mciavi.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * Digital video MCI Wine Driver
   5  *
   6  * Copyright 1999 Eric POUECH
   7  */
   8
   9 #include <string.h>
  10 #include "windef.h"
  11 #include "wingdi.h"
  12 #include "winuser.h"
  13 #include "mmddk.h"
  14 #include "user.h"
  15 #include "digitalv.h"
  16 #include "debugtools.h"
  17
  18 DEFAULT_DEBUG_CHANNEL(mciavi)
  19
  20 typedef struct {
  21     UINT                wDevID;
  22     int                 nUseCount;              /* Incremented for each shared open          */
  23     BOOL16              fShareable;             /* TRUE if first open was shareable          */
  24     WORD                wNotifyDeviceID;        /* MCI device ID with a pending notification */
  25     HANDLE16            hCallback;              /* Callback handle for pending notification  */
  26     HMMIO               hFile;                  /* mmio file handle open as Element          */
  27     WORD                wStatus;                /* One of MCI_MODE_XXX                       */
  28     MCI_OPEN_PARMSA     openParms;
  29     DWORD               dwTimeFormat;
  30 } WINE_MCIAVI;
  31
  32 /*======================================================================*
  33  *                          MCI AVI implemantation                      *
  34  *======================================================================*/
  35
  36 /**************************************************************************
  37  *                              AVI_drvOpen                     [internal]
  38  */
  39 static  DWORD   AVI_drvOpen(LPSTR str, LPMCI_OPEN_DRIVER_PARMSA modp)
  40 {
  41     WINE_MCIAVI*        wma = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCIAVI));
  42
  43     if (!wma)
  44         return 0;
  45
  46     wma->wDevID = modp->wDeviceID;
  47     mciSetDriverData(wma->wDevID, (DWORD)wma);
  48     modp->wCustomCommandTable = MCI_NO_COMMAND_TABLE;
  49     modp->wType = MCI_DEVTYPE_DIGITAL_VIDEO;
  50     return modp->wDeviceID;
  51 }
  52
  53 /**************************************************************************
  54  *                              MCIAVI_drvClose         [internal]
  55  */
  56 static  DWORD   AVI_drvClose(DWORD dwDevID)
  57 {
  58     WINE_MCIAVI*  wma = (WINE_MCIAVI*)mciGetDriverData(dwDevID);
  59
  60     if (wma) {
  61         HeapFree(GetProcessHeap(), 0, wma);
  62         mciSetDriverData(dwDevID, 0);
  63         return 1;
  64     }
  65     return 0;
  66 }
  67
  68 /**************************************************************************
  69  *                              AVI_mciGetOpenDev               [internal]
  70  */
  71 static WINE_MCIAVI*  AVI_mciGetOpenDev(UINT16 wDevID)
  72 {
  73     WINE_MCIAVI*        wma = (WINE_MCIAVI*)mciGetDriverData(wDevID);
  74
  75     if (wma == NULL || wma->nUseCount == 0) {
  76         WARN("Invalid wDevID=%u\n", wDevID);
  77         return 0;
  78     }
  79     return wma;
  80 }
  81
  82 static  DWORD   AVI_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
  83
  84 /***************************************************************************
  85  *                              AVI_mciOpen                     [internal]
  86  */
  87 static  DWORD   AVI_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_OPEN_PARMSA lpParms)
  88 {
  89     WINE_MCIAVI*        wma = (WINE_MCIAVI*)mciGetDriverData(wDevID);
  90
  91     TRACE("(%04x, %08lX, %p) : semi-stub\n", wDevID, dwFlags, lpParms);
  92
  93     if (lpParms == NULL)                return MCIERR_NULL_PARAMETER_BLOCK;
  94     if (wma == NULL)                    return MCIERR_INVALID_DEVICE_ID;
  95
  96     if (wma->nUseCount > 0) {
  97         /* The driver is already open on this channel */
  98         /* If the driver was opened shareable before and this open specifies */
  99         /* shareable then increment the use count */
 100         if (wma->fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
 101             ++wma->nUseCount;
 102         else
 103             return MCIERR_MUST_USE_SHAREABLE;
 104     } else {
 105         wma->nUseCount = 1;
 106         wma->fShareable = dwFlags & MCI_OPEN_SHAREABLE;
 107     }
 108     if (dwFlags & MCI_OPEN_ELEMENT) {
 109         TRACE("MCI_OPEN_ELEMENT !\n");
 110         /*              return MCIERR_NO_ELEMENT_ALLOWED; */
 111     }
 112
 113     wma->openParms.dwCallback = lpParms->dwCallback;
 114     wma->openParms.wDeviceID  = (WORD)lpParms->wDeviceID;
 115     wma->openParms.lpstrDeviceType = lpParms->lpstrDeviceType;
 116     wma->openParms.lpstrElementName = lpParms->lpstrElementName;
 117     wma->openParms.lpstrAlias = lpParms->lpstrAlias;
 118
 119     wma->wNotifyDeviceID = lpParms->wDeviceID;
 120     /* FIXME: do real open */
 121     wma->wStatus = MCI_MODE_STOP;
 122     wma->dwTimeFormat = MCI_FORMAT_TMSF;
 123
 124     return 0;
 125
 126 }
 127
 128 /***************************************************************************
 129  *                              AVI_mciClose                    [internal]
 130  */
 131 static  DWORD   AVI_mciClose(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 132 {
 133     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 134
 135     TRACE("(%04x, %08lX, %p) : semi-stub\n", wDevID, dwFlags, lpParms);
 136
 137     if (wma == NULL)    return MCIERR_INVALID_DEVICE_ID;
 138
 139     if (wma->nUseCount == 1) {
 140         AVI_mciStop(wDevID, 0, NULL);
 141         /* FIXME: do real closing */
 142     }
 143     wma->nUseCount--;
 144     return 0;
 145 }
 146
 147 /***************************************************************************
 148  *                              AVI_mciPlay                     [internal]
 149  */
 150 static  DWORD   AVI_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
 151 {
 152     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 153
 154     TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
 155
 156     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 157     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 158
 159     wma->wStatus = MCI_MODE_PLAY;
 160     if (lpParms && (dwFlags & MCI_NOTIFY)) {
 161         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 162         mciDriverNotify16((HWND16)LOWORD(lpParms->dwCallback),
 163                           wma->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 164     }
 165     return 0;
 166 }
 167
 168 /***************************************************************************
 169  *                              AVI_mciRecord                   [internal]
 170  */
 171 static  DWORD   AVI_mciRecord(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_RECORD_PARMS lpParms)
 172 {
 173     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 174
 175     TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
 176
 177     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 178     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 179
 180     wma->wStatus = MCI_MODE_RECORD;
 181     return 0;
 182 }
 183
 184 /***************************************************************************
 185  *                              AVI_mciStop                     [internal]
 186  */
 187 static  DWORD   AVI_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 188 {
 189     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 190
 191     TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
 192
 193     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 194     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 195
 196     wma->wStatus = MCI_MODE_STOP;
 197     return 0;
 198 }
 199
 200 /***************************************************************************
 201  *                              AVI_mciPause                    [internal]
 202  */
 203 static  DWORD   AVI_mciPause(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 204 {
 205     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 206
 207     TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
 208
 209     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 210     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 211
 212     wma->wStatus = MCI_MODE_PAUSE;
 213     return 0;
 214 }
 215
 216 /***************************************************************************
 217  *                              AVI_mciResume                   [internal]
 218  */
 219 static  DWORD   AVI_mciResume(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 220 {
 221     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 222
 223     TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
 224
 225     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 226     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 227
 228     wma->wStatus = MCI_MODE_PLAY;
 229     return 0;
 230 }
 231
 232 /***************************************************************************
 233  *                              AVI_mciSeek                     [internal]
 234  */
 235 static  DWORD   AVI_mciSeek(UINT16 wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
 236 {
 237     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 238
 239     TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
 240
 241     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 242     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 243
 244     return 0;
 245 }
 246
 247 /***************************************************************************
 248  *                              AVI_mciSet                      [internal]
 249  */
 250 static  DWORD   AVI_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms)
 251 {
 252     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 253
 254     TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
 255
 256     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 257     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 258
 259     if (dwFlags & MCI_SET_TIME_FORMAT) {
 260         switch (lpParms->dwTimeFormat) {
 261         case MCI_FORMAT_MILLISECONDS:
 262             TRACE("MCI_FORMAT_MILLISECONDS !\n");
 263             wma->dwTimeFormat = MCI_FORMAT_MILLISECONDS;
 264             break;
 265         case MCI_FORMAT_FRAMES:
 266             TRACE("MCI_FORMAT_FRAMES !\n");
 267             wma->dwTimeFormat = MCI_FORMAT_FRAMES;
 268             break;
 269         default:
 270             WARN("Bad time format %lu!\n", lpParms->dwTimeFormat);
 271             return MCIERR_BAD_TIME_FORMAT;
 272         }
 273     }
 274
 275     if (dwFlags & MCI_SET_DOOR_OPEN) {
 276         TRACE("No support for door open !\n");
 277         return MCIERR_UNSUPPORTED_FUNCTION;
 278     }
 279     if (dwFlags & MCI_SET_DOOR_CLOSED) {
 280         TRACE("No support for door close !\n");
 281         return MCIERR_UNSUPPORTED_FUNCTION;
 282     }
 283     if (dwFlags & MCI_SET_ON) {
 284         char    buffer[256];
 285
 286         strcpy(buffer, "MCI_SET_ON:");
 287
 288         if (dwFlags & MCI_SET_VIDEO) {
 289             strncat(buffer, " video", sizeof(buffer));
 290         }
 291         if (dwFlags & MCI_SET_AUDIO) {
 292             strncat(buffer, " audio", sizeof(buffer));
 293             if (lpParms->dwAudio & MCI_SET_AUDIO_ALL)
 294                 strncat(buffer, " all", sizeof(buffer));
 295             if (lpParms->dwAudio & MCI_SET_AUDIO_LEFT)
 296                 strncat(buffer, " left", sizeof(buffer));
 297             if (lpParms->dwAudio & MCI_SET_AUDIO_RIGHT)
 298                 strncat(buffer, " right", sizeof(buffer));
 299         }
 300         if (dwFlags & MCI_DGV_SET_SEEK_EXACTLY) {
 301             strncat(buffer, " seek_exactly", sizeof(buffer));
 302         }
 303         TRACE("%s\n", buffer);
 304     }
 305
 306     if (dwFlags & MCI_SET_OFF) {
 307         char    buffer[256];
 308
 309         strcpy(buffer, "MCI_SET_OFF:");
 310         if (dwFlags & MCI_SET_VIDEO) {
 311             strncat(buffer, " video", sizeof(buffer));
 312         }
 313         if (dwFlags & MCI_SET_AUDIO) {
 314             strncat(buffer, " audio", sizeof(buffer));
 315             if (lpParms->dwAudio & MCI_SET_AUDIO_ALL)
 316                 strncat(buffer, " all", sizeof(buffer));
 317             if (lpParms->dwAudio & MCI_SET_AUDIO_LEFT)
 318                 strncat(buffer, " left", sizeof(buffer));
 319             if (lpParms->dwAudio & MCI_SET_AUDIO_RIGHT)
 320                 strncat(buffer, " right", sizeof(buffer));
 321         }
 322         if (dwFlags & MCI_DGV_SET_SEEK_EXACTLY) {
 323             strncat(buffer, " seek_exactly", sizeof(buffer));
 324         }
 325         TRACE("%s\n", buffer);
 326     }
 327     if (dwFlags & MCI_DGV_SET_FILEFORMAT) {
 328         LPSTR   str = "save";
 329         if (dwFlags & MCI_DGV_SET_STILL)
 330             str = "capture";
 331
 332         switch (lpParms->dwFileFormat) {
 333         case MCI_DGV_FF_AVI:    TRACE("Setting file format (%s) to 'AVI'\n", str);      break;
 334         case MCI_DGV_FF_AVSS:   TRACE("Setting file format (%s) to 'AVSS'\n", str);     break;
 335         case MCI_DGV_FF_DIB:    TRACE("Setting file format (%s) to 'DIB'\n", str);      break;
 336         case MCI_DGV_FF_JFIF:   TRACE("Setting file format (%s) to 'JFIF'\n", str);     break;
 337         case MCI_DGV_FF_JPEG:   TRACE("Setting file format (%s) to 'JPEG'\n", str);     break;
 338         case MCI_DGV_FF_MPEG:   TRACE("Setting file format (%s) to 'MPEG'\n", str);     break;
 339         case MCI_DGV_FF_RDIB:   TRACE("Setting file format (%s) to 'RLE DIB'\n", str);  break;
 340         case MCI_DGV_FF_RJPEG:  TRACE("Setting file format (%s) to 'RJPEG'\n", str);    break;
 341         default:                TRACE("Setting unknown file format (%s): %ld\n", str, lpParms->dwFileFormat);
 342         }
 343     }
 344
 345     if (dwFlags & MCI_DGV_SET_SPEED) {
 346         TRACE("Setting speed to %ld\n", lpParms->dwSpeed);
 347     }
 348
 349     return 0;
 350 }
 351
 352 /***************************************************************************
 353  *                              AVI_mciStatus                   [internal]
 354  */
 355 static  DWORD   AVI_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSA lpParms)
 356 {
 357     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 358     DWORD               ret = 0;
 359
 360     TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
 361
 362     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 363     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 364
 365     if (dwFlags & MCI_STATUS_ITEM) {
 366         switch (lpParms->dwItem) {
 367         case MCI_STATUS_CURRENT_TRACK:
 368             lpParms->dwReturn = 1;
 369             TRACE("MCI_STATUS_CURRENT_TRACK => %lu\n", lpParms->dwReturn);
 370             break;
 371         case MCI_STATUS_LENGTH:
 372             if (dwFlags & MCI_TRACK) {
 373                 /* lpParms->dwTrack contains track # */
 374                 lpParms->dwReturn = 0x1234;
 375             } else {
 376                 lpParms->dwReturn = 0x4321;
 377             }
 378             TRACE("MCI_STATUS_LENGTH => %lu\n", lpParms->dwReturn);
 379             break;
 380         case MCI_STATUS_MODE:
 381             lpParms->dwReturn = MAKEMCIRESOURCE(wma->wStatus, wma->wStatus);
 382             ret = MCI_RESOURCE_RETURNED;
 383             TRACE("MCI_STATUS_MODE => %u\n", LOWORD(lpParms->dwReturn));
 384             break;
 385         case MCI_STATUS_MEDIA_PRESENT:
 386             TRACE("MCI_STATUS_MEDIA_PRESENT => TRUE\n");
 387             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 388             ret = MCI_RESOURCE_RETURNED;
 389             break;
 390         case MCI_STATUS_NUMBER_OF_TRACKS:
 391             lpParms->dwReturn = 3;
 392             TRACE("MCI_STATUS_NUMBER_OF_TRACKS => %lu\n", lpParms->dwReturn);
 393             break;
 394         case MCI_STATUS_POSITION:
 395             /* FIXME: do I need to use MCI_TRACK ? */
 396             lpParms->dwReturn = 0x0123;
 397             TRACE("MCI_STATUS_POSITION %s => %lu\n",
 398                   (dwFlags & MCI_STATUS_START) ? "start" : "current", lpParms->dwReturn);
 399             break;
 400         case MCI_STATUS_READY:
 401             lpParms->dwReturn = (wma->wStatus == MCI_MODE_NOT_READY) ?
 402                 MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 403             ret = MCI_RESOURCE_RETURNED;
 404             TRACE("MCI_STATUS_READY = %u\n", LOWORD(lpParms->dwReturn));
 405             break;
 406         case MCI_STATUS_TIME_FORMAT:
 407             lpParms->dwReturn = MAKEMCIRESOURCE(wma->dwTimeFormat, wma->dwTimeFormat);
 408             TRACE("MCI_STATUS_TIME_FORMAT => %u\n", LOWORD(lpParms->dwReturn));
 409             ret = MCI_RESOURCE_RETURNED;
 410             break;
 411         default:
 412             FIXME("Unknowm command %08lX !\n", lpParms->dwItem);
 413             return MCIERR_UNRECOGNIZED_COMMAND;
 414         }
 415     } else {
 416         WARN("No Status-Item!\n");
 417         return MCIERR_UNRECOGNIZED_COMMAND;
 418     }
 419     if (dwFlags & MCI_NOTIFY) {
 420         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 421         mciDriverNotify16((HWND16)LOWORD(lpParms->dwCallback),
 422                           wma->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
 423     }
 424
 425     return ret;
 426 }
 427
 428 /***************************************************************************
 429  *                              AVI_mciGetDevCaps                       [internal]
 430  */
 431 static  DWORD   AVI_mciGetDevCaps(UINT16 wDevID, DWORD dwFlags,  LPMCI_GETDEVCAPS_PARMS lpParms)
 432 {
 433     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 434     DWORD               ret;
 435
 436     TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
 437
 438     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 439     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 440
 441     if (dwFlags & MCI_GETDEVCAPS_ITEM) {
 442         switch (lpParms->dwItem) {
 443         case MCI_GETDEVCAPS_DEVICE_TYPE:
 444             TRACE("MCI_GETDEVCAPS_DEVICE_TYPE !\n");
 445             lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_DIGITAL_VIDEO, MCI_DEVTYPE_DIGITAL_VIDEO);
 446             ret = MCI_RESOURCE_RETURNED;
 447             break;
 448         case MCI_GETDEVCAPS_HAS_AUDIO:
 449             TRACE("MCI_GETDEVCAPS_HAS_AUDIO !\n");
 450             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 451             ret = MCI_RESOURCE_RETURNED;
 452             break;
 453         case MCI_GETDEVCAPS_HAS_VIDEO:
 454             TRACE("MCI_GETDEVCAPS_HAS_VIDEO !\n");
 455             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 456             ret = MCI_RESOURCE_RETURNED;
 457             break;
 458         case MCI_GETDEVCAPS_USES_FILES:
 459             TRACE("MCI_GETDEVCAPS_USES_FILES !\n");
 460             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 461             ret = MCI_RESOURCE_RETURNED;
 462             break;
 463         case MCI_GETDEVCAPS_COMPOUND_DEVICE:
 464             TRACE("MCI_GETDEVCAPS_COMPOUND_DEVICE !\n");
 465             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 466             ret = MCI_RESOURCE_RETURNED;
 467             break;
 468         case MCI_GETDEVCAPS_CAN_EJECT:
 469             TRACE("MCI_GETDEVCAPS_CAN_EJECT !\n");
 470             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 471             ret = MCI_RESOURCE_RETURNED;
 472             break;
 473         case MCI_GETDEVCAPS_CAN_PLAY:
 474             TRACE("MCI_GETDEVCAPS_CAN_PLAY !\n");
 475             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 476             ret = MCI_RESOURCE_RETURNED;
 477             break;
 478         case MCI_GETDEVCAPS_CAN_RECORD:
 479             TRACE("MCI_GETDEVCAPS_CAN_RECORD !\n");
 480             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 481             ret = MCI_RESOURCE_RETURNED;
 482             break;
 483         case MCI_GETDEVCAPS_CAN_SAVE:
 484             TRACE("MCI_GETDEVCAPS_CAN_SAVE !\n");
 485             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 486             ret = MCI_RESOURCE_RETURNED;
 487             break;
 488         default:
 489             FIXME("Unknown capability (%08lx) !\n", lpParms->dwItem);
 490             return MCIERR_UNRECOGNIZED_COMMAND;
 491         }
 492     } else {
 493         WARN("No GetDevCaps-Item !\n");
 494         return MCIERR_UNRECOGNIZED_COMMAND;
 495     }
 496     return ret;
 497 }
 498
 499 /***************************************************************************
 500  *                              AVI_mciInfo                     [internal]
 501  */
 502 static  DWORD   AVI_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_INFO_PARMSA lpParms)
 503 {
 504     LPSTR               str = 0;
 505     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 506     DWORD               ret = 0;
 507
 508     TRACE("(%04X, %08lX, %p) : stub;\n", wDevID, dwFlags, lpParms);
 509
 510     if (lpParms == NULL || lpParms->lpstrReturn == NULL)
 511         return MCIERR_NULL_PARAMETER_BLOCK;
 512     if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
 513
 514     TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
 515
 516     switch (dwFlags) {
 517     case MCI_INFO_PRODUCT:
 518         str = "Wine's AVI player";
 519         break;
 520     case MCI_INFO_FILE:
 521         str = "";
 522         break;
 523 #if 0
 524         /* FIXME: the following manifest constants are not defined in <WINE>/include/mmsystem.h */
 525     case MCI_INFO_COPYRIGHT:
 526         break;
 527     case MCI_INFO_NAME:
 528         break;
 529 #endif
 530     default:
 531         WARN("Don't know this info command (%lu)\n", dwFlags);
 532         return MCIERR_UNRECOGNIZED_COMMAND;
 533     }
 534     if (str) {
 535         if (lpParms->dwRetSize <= strlen(str)) {
 536             lstrcpynA(lpParms->lpstrReturn, str, lpParms->dwRetSize - 1);
 537             ret = MCIERR_PARAM_OVERFLOW;
 538         } else {
 539             strcpy(lpParms->lpstrReturn, str);
 540         }
 541     } else {
 542         *lpParms->lpstrReturn = 0;
 543     }
 544     return ret;
 545 }
 546
 547 /***************************************************************************
 548  *                              AVI_mciPut                      [internal]
 549  */
 550 static  DWORD   AVI_mciPut(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_PUT_PARMS lpParms)
 551 {
 552     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 553     RECT                rc;
 554     char                buffer[256];
 555
 556     TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
 557
 558     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 559     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 560
 561     if (dwFlags & MCI_DGV_RECT) {
 562         rc = lpParms->rc;
 563     } else {
 564         SetRectEmpty(&rc);
 565     }
 566
 567     *buffer = 0;
 568     if (dwFlags & MCI_DGV_PUT_CLIENT) {
 569         strncat(buffer, "PUT_CLIENT", sizeof(buffer));
 570     }
 571     if (dwFlags & MCI_DGV_PUT_DESTINATION) {
 572         strncat(buffer, "PUT_DESTINATION", sizeof(buffer));
 573     }
 574     if (dwFlags & MCI_DGV_PUT_FRAME) {
 575         strncat(buffer, "PUT_FRAME", sizeof(buffer));
 576     }
 577     if (dwFlags & MCI_DGV_PUT_SOURCE) {
 578         strncat(buffer, "PUT_SOURCE", sizeof(buffer));
 579     }
 580     if (dwFlags & MCI_DGV_PUT_VIDEO) {
 581         strncat(buffer, "PUT_VIDEO", sizeof(buffer));
 582     }
 583     if (dwFlags & MCI_DGV_PUT_WINDOW) {
 584         strncat(buffer, "PUT_WINDOW", sizeof(buffer));
 585     }
 586     TRACE("%s (%d,%d,%d,%d)\n", buffer, rc.left, rc.top, rc.right, rc.bottom);
 587
 588     return 0;
 589 }
 590
 591 /***************************************************************************
 592  *                              AVI_mciWindow                   [internal]
 593  */
 594 static  DWORD   AVI_mciWindow(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSA lpParms)
 595 {
 596     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 597
 598     TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
 599
 600     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 601     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 602
 603     if (dwFlags & MCI_DGV_WINDOW_HWND) {
 604         TRACE("Setting hWnd to %08lx\n", (DWORD)lpParms->hWnd);
 605     }
 606     if (dwFlags & MCI_DGV_WINDOW_STATE) {
 607         TRACE("Setting nCmdShow to %d\n", lpParms->nCmdShow);
 608     }
 609     if (dwFlags & MCI_DGV_WINDOW_TEXT) {
 610         TRACE("Setting caption to '%s'\n", lpParms->lpstrText);
 611     }
 612
 613     return 0;
 614 }
 615
 616 /*****************************************************************************
 617  *                              AVI_mciLoad                     [internal]
 618  */
 619 static DWORD    AVI_mciLoad(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_LOAD_PARMSA lpParms)
 620 {
 621     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 622
 623     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 624
 625     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 626     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 627
 628     return 0;
 629 }
 630
 631 /******************************************************************************
 632  *                              AVI_mciSave                     [internal]
 633  */
 634 static  DWORD   AVI_mciSave(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_SAVE_PARMSA lpParms)
 635 {
 636     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 637
 638     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 639
 640     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 641     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 642
 643     return 0;
 644 }
 645
 646 /******************************************************************************
 647  *                              AVI_mciFreeze                   [internal]
 648  */
 649 static  DWORD   AVI_mciFreeze(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
 650 {
 651     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 652
 653     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 654
 655     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 656     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 657
 658     return 0;
 659 }
 660
 661 /******************************************************************************
 662  *                              AVI_mciRealize                  [internal]
 663  */
 664 static  DWORD   AVI_mciRealize(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 665 {
 666     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 667
 668     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 669
 670     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 671     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 672
 673     return 0;
 674 }
 675
 676 /******************************************************************************
 677  *                              AVI_mciUnFreeze                 [internal]
 678  */
 679 static  DWORD   AVI_mciUnFreeze(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
 680 {
 681     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 682
 683     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 684
 685     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 686     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 687
 688     return 0;
 689 }
 690
 691 /******************************************************************************
 692  *                              AVI_mciUpdate                   [internal]
 693  */
 694 static  DWORD   AVI_mciUpdate(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
 695 {
 696     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 697
 698     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 699
 700     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 701     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 702
 703     return 0;
 704 }
 705
 706 /******************************************************************************
 707  *                              AVI_mciWhere                    [internal]
 708  */
 709 static  DWORD   AVI_mciWhere(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
 710 {
 711     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 712
 713     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 714
 715     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 716     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 717
 718     return 0;
 719 }
 720
 721 /******************************************************************************
 722  *                              AVI_mciStep                     [internal]
 723  */
 724 static  DWORD   AVI_mciStep(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_STEP_PARMS lpParms)
 725 {
 726     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 727
 728     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 729
 730     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 731     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 732
 733     return 0;
 734 }
 735
 736 /******************************************************************************
 737  *                              AVI_mciCopy                     [internal]
 738  */
 739 static  DWORD   AVI_mciCopy(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_COPY_PARMS lpParms)
 740 {
 741     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 742
 743     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 744
 745     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 746     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 747
 748     return 0;
 749 }
 750
 751 /******************************************************************************
 752  *                              AVI_mciCut                      [internal]
 753  */
 754 static  DWORD   AVI_mciCut(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_CUT_PARMS lpParms)
 755 {
 756     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 757
 758     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 759
 760     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 761     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 762
 763     return 0;
 764 }
 765
 766 /******************************************************************************
 767  *                              AVI_mciDelete                   [internal]
 768  */
 769 static  DWORD   AVI_mciDelete(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_DELETE_PARMS lpParms)
 770 {
 771     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 772
 773     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 774
 775     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 776     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 777
 778     return 0;
 779 }
 780
 781 /******************************************************************************
 782  *                              AVI_mciPaste                    [internal]
 783  */
 784 static  DWORD   AVI_mciPaste(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_PASTE_PARMS lpParms)
 785 {
 786     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 787
 788     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 789
 790     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 791     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 792
 793     return 0;
 794 }
 795
 796 /******************************************************************************
 797  *                              AVI_mciCue                      [internal]
 798  */
 799 static  DWORD   AVI_mciCue(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_CUE_PARMS lpParms)
 800 {
 801     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 802
 803     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 804
 805     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 806     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 807
 808     return 0;
 809 }
 810
 811 /******************************************************************************
 812  *                              AVI_mciCapture                  [internal]
 813  */
 814 static  DWORD   AVI_mciCapture(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_CAPTURE_PARMSA lpParms)
 815 {
 816     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 817
 818     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 819
 820     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 821     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 822
 823     return 0;
 824 }
 825
 826 /******************************************************************************
 827  *                              AVI_mciMonitor                  [internal]
 828  */
 829 static  DWORD   AVI_mciMonitor(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_MONITOR_PARMS lpParms)
 830 {
 831     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 832
 833     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 834
 835     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 836     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 837
 838     return 0;
 839 }
 840
 841 /******************************************************************************
 842  *                              AVI_mciReserve                  [internal]
 843  */
 844 static  DWORD   AVI_mciReserve(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_RESERVE_PARMSA lpParms)
 845 {
 846     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 847
 848     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 849
 850     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 851     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 852
 853     return 0;
 854 }
 855
 856 /******************************************************************************
 857  *                              AVI_mciSetAudio                 [internal]
 858  */
 859 static  DWORD   AVI_mciSetAudio(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSA lpParms)
 860 {
 861     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 862
 863     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 864
 865     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 866     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 867
 868     return 0;
 869 }
 870
 871 /******************************************************************************
 872  *                              AVI_mciSignal                   [internal]
 873  */
 874 static  DWORD   AVI_mciSignal(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_SIGNAL_PARMS lpParms)
 875 {
 876     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 877
 878     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 879
 880     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 881     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 882
 883     return 0;
 884 }
 885
 886 /******************************************************************************
 887  *                              AVI_mciSetVideo                 [internal]
 888  */
 889 static  DWORD   AVI_mciSetVideo(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_SETVIDEO_PARMSA lpParms)
 890 {
 891     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 892
 893     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 894
 895     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 896     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 897
 898     return 0;
 899 }
 900
 901 /******************************************************************************
 902  *                              AVI_mciQuality                  [internal]
 903  */
 904 static  DWORD   AVI_mciQuality(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_QUALITY_PARMSA lpParms)
 905 {
 906     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 907
 908     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 909
 910     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 911     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 912
 913     return 0;
 914 }
 915
 916 /******************************************************************************
 917  *                              AVI_mciList                     [internal]
 918  */
 919 static  DWORD   AVI_mciList(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_LIST_PARMSA lpParms)
 920 {
 921     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 922
 923     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 924
 925     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 926     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 927
 928     return 0;
 929 }
 930
 931 /******************************************************************************
 932  *                              AVI_mciUndo                     [internal]
 933  */
 934 static  DWORD   AVI_mciUndo(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 935 {
 936     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 937
 938     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 939
 940     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 941     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 942
 943     return 0;
 944 }
 945
 946 /******************************************************************************
 947  *                              AVI_mciConfigure                        [internal]
 948  */
 949 static  DWORD   AVI_mciConfigure(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 950 {
 951     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 952
 953     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 954
 955     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 956     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 957
 958     return 0;
 959 }
 960
 961 /******************************************************************************
 962  *                              AVI_mciRestore                  [internal]
 963  */
 964 static  DWORD   AVI_mciRestore(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_RESTORE_PARMSA lpParms)
 965 {
 966     WINE_MCIAVI*        wma = AVI_mciGetOpenDev(wDevID);
 967
 968     TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
 969
 970     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 971     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 972
 973     return 0;
 974 }
 975
 976 /*======================================================================*
 977  *                          MCI AVI entry points                        *
 978  *======================================================================*/
 979
 980 /**************************************************************************
 981  *                              MCIAVI_DriverProc       [sample driver]
 982  */
 983 LONG CALLBACK   MCIAVI_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
 984                                   DWORD dwParam1, DWORD dwParam2)
 985 {
 986     switch (wMsg) {
 987     case DRV_LOAD:              return 1;
 988     case DRV_FREE:              return 1;
 989     case DRV_OPEN:              return AVI_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
 990     case DRV_CLOSE:             return AVI_drvClose(dwDevID);
 991     case DRV_ENABLE:            return 1;
 992     case DRV_DISABLE:           return 1;
 993     case DRV_QUERYCONFIGURE:    return 1;
 994     case DRV_CONFIGURE:         MessageBoxA(0, "Sample AVI Wine Driver !", "MM-Wine Driver", MB_OK); return 1;
 995     case DRV_INSTALL:           return DRVCNF_RESTART;
 996     case DRV_REMOVE:            return DRVCNF_RESTART;
 997
 998     case MCI_OPEN_DRIVER:       return AVI_mciOpen      (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSA)     dwParam2);
 999     case MCI_CLOSE_DRIVER:      return AVI_mciClose     (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
1000     case MCI_PLAY:              return AVI_mciPlay      (dwDevID, dwParam1, (LPMCI_PLAY_PARMS)          dwParam2);
1001     case MCI_RECORD:            return AVI_mciRecord    (dwDevID, dwParam1, (LPMCI_DGV_RECORD_PARMS)    dwParam2);
1002     case MCI_STOP:              return AVI_mciStop      (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
1003     case MCI_SET:               return AVI_mciSet       (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS)       dwParam2);
1004     case MCI_PAUSE:             return AVI_mciPause     (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
1005     case MCI_RESUME:            return AVI_mciResume    (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
1006     case MCI_STATUS:            return AVI_mciStatus    (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSA)   dwParam2);
1007     case MCI_GETDEVCAPS:        return AVI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)    dwParam2);
1008     case MCI_INFO:              return AVI_mciInfo      (dwDevID, dwParam1, (LPMCI_DGV_INFO_PARMSA)     dwParam2);
1009     case MCI_SEEK:              return AVI_mciSeek      (dwDevID, dwParam1, (LPMCI_SEEK_PARMS)          dwParam2);
1010     case MCI_PUT:               return AVI_mciPut       (dwDevID, dwParam1, (LPMCI_DGV_PUT_PARMS)       dwParam2);
1011     case MCI_WINDOW:            return AVI_mciWindow    (dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSA)   dwParam2);
1012     case MCI_LOAD:              return AVI_mciLoad      (dwDevID, dwParam1, (LPMCI_DGV_LOAD_PARMSA)     dwParam2);
1013     case MCI_SAVE:              return AVI_mciSave      (dwDevID, dwParam1, (LPMCI_DGV_SAVE_PARMSA)     dwParam2);
1014     case MCI_FREEZE:            return AVI_mciFreeze    (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS)      dwParam2);
1015     case MCI_REALIZE:           return AVI_mciRealize   (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
1016     case MCI_UNFREEZE:          return AVI_mciUnFreeze  (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS)      dwParam2);
1017     case MCI_UPDATE:            return AVI_mciUpdate    (dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS)    dwParam2);
1018     case MCI_WHERE:             return AVI_mciWhere     (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS)      dwParam2);
1019     case MCI_STEP:              return AVI_mciStep      (dwDevID, dwParam1, (LPMCI_DGV_STEP_PARMS)      dwParam2);
1020     case MCI_COPY:              return AVI_mciCopy      (dwDevID, dwParam1, (LPMCI_DGV_COPY_PARMS)      dwParam2);
1021     case MCI_CUT:               return AVI_mciCut       (dwDevID, dwParam1, (LPMCI_DGV_CUT_PARMS)       dwParam2);
1022     case MCI_DELETE:            return AVI_mciDelete    (dwDevID, dwParam1, (LPMCI_DGV_DELETE_PARMS)    dwParam2);
1023     case MCI_PASTE:             return AVI_mciPaste     (dwDevID, dwParam1, (LPMCI_DGV_PASTE_PARMS)     dwParam2);
1024     case MCI_CUE:               return AVI_mciCue       (dwDevID, dwParam1, (LPMCI_DGV_CUE_PARMS)       dwParam2);
1025         /* Digital Video specific */
1026     case MCI_CAPTURE:           return AVI_mciCapture   (dwDevID, dwParam1, (LPMCI_DGV_CAPTURE_PARMSA)  dwParam2);
1027     case MCI_MONITOR:           return AVI_mciMonitor   (dwDevID, dwParam1, (LPMCI_DGV_MONITOR_PARMS)   dwParam2);
1028     case MCI_RESERVE:           return AVI_mciReserve   (dwDevID, dwParam1, (LPMCI_DGV_RESERVE_PARMSA)  dwParam2);
1029     case MCI_SETAUDIO:          return AVI_mciSetAudio  (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSA) dwParam2);
1030     case MCI_SIGNAL:            return AVI_mciSignal    (dwDevID, dwParam1, (LPMCI_DGV_SIGNAL_PARMS)    dwParam2);
1031     case MCI_SETVIDEO:          return AVI_mciSetVideo  (dwDevID, dwParam1, (LPMCI_DGV_SETVIDEO_PARMSA) dwParam2);
1032     case MCI_QUALITY:           return AVI_mciQuality   (dwDevID, dwParam1, (LPMCI_DGV_QUALITY_PARMSA)  dwParam2);
1033     case MCI_LIST:              return AVI_mciList      (dwDevID, dwParam1, (LPMCI_DGV_LIST_PARMSA)     dwParam2);
1034     case MCI_UNDO:              return AVI_mciUndo      (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
1035     case MCI_CONFIGURE:         return AVI_mciConfigure (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
1036     case MCI_RESTORE:           return AVI_mciRestore   (dwDevID, dwParam1, (LPMCI_DGV_RESTORE_PARMSA)  dwParam2);
1037
1038     case MCI_SPIN:
1039     case MCI_ESCAPE:
1040         WARN("Unsupported command [%lu]\n", wMsg);
1041         break;
1042     case MCI_OPEN:
1043     case MCI_CLOSE:
1044         FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1045         break;
1046     default:
1047         TRACE("Sending msg [%lu] to default driver proc\n", wMsg);
1048         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1049     }
1050     return MCIERR_UNRECOGNIZED_COMMAND;
1051 }
1052
1053