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