dlls/mciqtz32/mciqtz.c

   1 /*
   2  * DirectShow MCI Driver
   3  *
   4  * Copyright 2009 Christian Costa
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "winuser.h"
  25 #include "mmddk.h"
  26 #include "wine/debug.h"
  27 #include "mciqtz_private.h"
  28 #include "digitalv.h"
  29 #include "wownt32.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(mciqtz);
  32
  33 static DWORD MCIQTZ_mciClose(UINT, DWORD, LPMCI_GENERIC_PARMS);
  34 static DWORD MCIQTZ_mciStop(UINT, DWORD, LPMCI_GENERIC_PARMS);
  35
  36 /*======================================================================*
  37  *                          MCI QTZ implementation                      *
  38  *======================================================================*/
  39
  40 HINSTANCE MCIQTZ_hInstance = 0;
  41
  42 /***********************************************************************
  43  *              DllMain (MCIQTZ.0)
  44  */
  45 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
  46 {
  47     switch (fdwReason) {
  48     case DLL_PROCESS_ATTACH:
  49         DisableThreadLibraryCalls(hInstDLL);
  50         MCIQTZ_hInstance = hInstDLL;
  51         break;
  52     }
  53     return TRUE;
  54 }
  55
  56 /**************************************************************************
  57  *                              MCIQTZ_mciGetOpenDev            [internal]
  58  */
  59 static WINE_MCIQTZ* MCIQTZ_mciGetOpenDev(UINT wDevID)
  60 {
  61     WINE_MCIQTZ* wma = (WINE_MCIQTZ*)mciGetDriverData(wDevID);
  62
  63     if (!wma) {
  64         WARN("Invalid wDevID=%u\n", wDevID);
  65         return NULL;
  66     }
  67     return wma;
  68 }
  69
  70 /**************************************************************************
  71  *                              MCIQTZ_drvOpen                  [internal]
  72  */
  73 static DWORD MCIQTZ_drvOpen(LPCWSTR str, LPMCI_OPEN_DRIVER_PARMSW modp)
  74 {
  75     WINE_MCIQTZ* wma;
  76
  77     TRACE("(%s, %p)\n", debugstr_w(str), modp);
  78
  79     /* session instance */
  80     if (!modp)
  81         return 0xFFFFFFFF;
  82
  83     wma = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCIQTZ));
  84     if (!wma)
  85         return 0;
  86
  87     wma->wDevID = modp->wDeviceID;
  88     mciSetDriverData(wma->wDevID, (DWORD_PTR)wma);
  89
  90     return modp->wDeviceID;
  91 }
  92
  93 /**************************************************************************
  94  *                              MCIQTZ_drvClose         [internal]
  95  */
  96 static DWORD MCIQTZ_drvClose(DWORD dwDevID)
  97 {
  98     WINE_MCIQTZ* wma;
  99
 100     TRACE("(%04x)\n", dwDevID);
 101
 102     wma = MCIQTZ_mciGetOpenDev(dwDevID);
 103
 104     if (wma) {
 105         /* finish all outstanding things */
 106         MCIQTZ_mciClose(dwDevID, MCI_WAIT, NULL);
 107
 108         mciSetDriverData(dwDevID, 0);
 109         HeapFree(GetProcessHeap(), 0, wma);
 110         return 1;
 111     }
 112
 113     return (dwDevID == 0xFFFFFFFF) ? 1 : 0;
 114 }
 115
 116 /**************************************************************************
 117  *                              MCIQTZ_drvConfigure             [internal]
 118  */
 119 static DWORD MCIQTZ_drvConfigure(DWORD dwDevID)
 120 {
 121     WINE_MCIQTZ* wma;
 122
 123     TRACE("(%04x)\n", dwDevID);
 124
 125     wma = MCIQTZ_mciGetOpenDev(dwDevID);
 126     if (!wma)
 127         return 0;
 128
 129     MCIQTZ_mciStop(dwDevID, MCI_WAIT, NULL);
 130
 131     MessageBoxA(0, "Sample QTZ Wine Driver !", "MM-Wine Driver", MB_OK);
 132
 133     return 1;
 134 }
 135
 136 /***************************************************************************
 137  *                              MCIQTZ_mciOpen                  [internal]
 138  */
 139 static DWORD MCIQTZ_mciOpen(UINT wDevID, DWORD dwFlags,
 140                             LPMCI_DGV_OPEN_PARMSW lpOpenParms)
 141 {
 142     WINE_MCIQTZ* wma;
 143     HRESULT hr;
 144
 145     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpOpenParms);
 146
 147     if (!lpOpenParms)
 148         return MCIERR_NULL_PARAMETER_BLOCK;
 149
 150     wma = MCIQTZ_mciGetOpenDev(wDevID);
 151     if (!wma)
 152         return MCIERR_INVALID_DEVICE_ID;
 153
 154     MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
 155
 156     CoInitializeEx(NULL, COINIT_MULTITHREADED);
 157
 158     hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, &IID_IGraphBuilder, (LPVOID*)&wma->pgraph);
 159     if (FAILED(hr)) {
 160         TRACE("Cannot create filtergraph (hr = %x)\n", hr);
 161         goto err;
 162     }
 163
 164     hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaControl, (LPVOID*)&wma->pmctrl);
 165     if (FAILED(hr)) {
 166         TRACE("Cannot get IMediaControl interface (hr = %x)\n", hr);
 167         goto err;
 168     }
 169
 170     if (!(dwFlags & MCI_OPEN_ELEMENT) || (dwFlags & MCI_OPEN_ELEMENT_ID)) {
 171         TRACE("Wrong dwFlags %x\n", dwFlags);
 172         goto err;
 173     }
 174
 175     if (!lpOpenParms->lpstrElementName || !lpOpenParms->lpstrElementName[0]) {
 176         TRACE("Invalid filename specified\n");
 177         goto err;
 178     }
 179
 180     TRACE("Open file %s\n", debugstr_w(lpOpenParms->lpstrElementName));
 181
 182     hr = IGraphBuilder_RenderFile(wma->pgraph, lpOpenParms->lpstrElementName, NULL);
 183     if (FAILED(hr)) {
 184         TRACE("Cannot render file (hr = %x)\n", hr);
 185         goto err;
 186     }
 187
 188     wma->opened = TRUE;
 189
 190     return 0;
 191
 192 err:
 193     if (wma->pgraph)
 194         IGraphBuilder_Release(wma->pgraph);
 195     wma->pgraph = NULL;
 196     if (wma->pmctrl)
 197         IMediaControl_Release(wma->pmctrl);
 198     wma->pmctrl = NULL;
 199
 200     CoUninitialize();
 201
 202     return MCIERR_INTERNAL;
 203 }
 204
 205 /***************************************************************************
 206  *                              MCIQTZ_mciClose                 [internal]
 207  */
 208 static DWORD MCIQTZ_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 209 {
 210     WINE_MCIQTZ* wma;
 211
 212     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 213
 214     wma = MCIQTZ_mciGetOpenDev(wDevID);
 215     if (!wma)
 216         return MCIERR_INVALID_DEVICE_ID;
 217
 218     MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
 219
 220     if (wma->opened) {
 221         IGraphBuilder_Release(wma->pgraph);
 222         IMediaControl_Release(wma->pmctrl);
 223         CoUninitialize();
 224         wma->opened = FALSE;
 225     }
 226
 227     return 0;
 228 }
 229
 230 /***************************************************************************
 231  *                              MCIQTZ_mciPlay                  [internal]
 232  */
 233 static DWORD MCIQTZ_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
 234 {
 235     WINE_MCIQTZ* wma;
 236     HRESULT hr;
 237
 238     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 239
 240     if (!lpParms)
 241         return MCIERR_NULL_PARAMETER_BLOCK;
 242
 243     wma = MCIQTZ_mciGetOpenDev(wDevID);
 244     if (!wma)
 245         return MCIERR_INVALID_DEVICE_ID;
 246
 247     hr = IMediaControl_Run(wma->pmctrl);
 248     if (FAILED(hr)) {
 249         TRACE("Cannot run filtergraph (hr = %x)\n", hr);
 250         return MCIERR_INTERNAL;
 251     }
 252
 253     wma->started = TRUE;
 254
 255     return 0;
 256 }
 257
 258 /***************************************************************************
 259  *                              MCIQTZ_mciSeek                  [internal]
 260  */
 261 static DWORD MCIQTZ_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
 262 {
 263     WINE_MCIQTZ* wma;
 264     HRESULT hr;
 265     IMediaPosition* pmpos;
 266     LONGLONG newpos;
 267
 268     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 269
 270     if (!lpParms)
 271         return MCIERR_NULL_PARAMETER_BLOCK;
 272
 273     wma = MCIQTZ_mciGetOpenDev(wDevID);
 274     if (!wma)
 275         return MCIERR_INVALID_DEVICE_ID;
 276
 277     MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
 278
 279     if (dwFlags & MCI_SEEK_TO_START) {
 280         newpos = 0;
 281     } else if (dwFlags & MCI_SEEK_TO_END) {
 282         FIXME("MCI_SEEK_TO_END not implemented yet\n");
 283         return MCIERR_INTERNAL;
 284     } else if (dwFlags & MCI_TO) {
 285         FIXME("MCI_TO not implemented yet\n");
 286         return MCIERR_INTERNAL;
 287     } else {
 288         WARN("dwFlag doesn't tell where to seek to...\n");
 289         return MCIERR_MISSING_PARAMETER;
 290     }
 291
 292     hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaPosition, (LPVOID*)&pmpos);
 293     if (FAILED(hr)) {
 294         FIXME("Cannot get IMediaPostion interface (hr = %x)\n", hr);
 295         return MCIERR_INTERNAL;
 296     }
 297
 298     hr = IMediaPosition_put_CurrentPosition(pmpos, newpos);
 299     if (FAILED(hr)) {
 300         FIXME("Cannot set position (hr = %x)\n", hr);
 301         IMediaPosition_Release(pmpos);
 302         return MCIERR_INTERNAL;
 303     }
 304
 305     IMediaPosition_Release(pmpos);
 306
 307     if (dwFlags & MCI_NOTIFY)
 308         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)), wDevID, MCI_NOTIFY_SUCCESSFUL);
 309
 310     return 0;
 311 }
 312
 313 /***************************************************************************
 314  *                              MCIQTZ_mciStop                  [internal]
 315  */
 316 static DWORD MCIQTZ_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 317 {
 318     WINE_MCIQTZ* wma;
 319     HRESULT hr;
 320
 321     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 322
 323     wma = MCIQTZ_mciGetOpenDev(wDevID);
 324     if (!wma)
 325         return MCIERR_INVALID_DEVICE_ID;
 326
 327     if (!wma->started)
 328         return 0;
 329
 330     hr = IMediaControl_Stop(wma->pmctrl);
 331     if (FAILED(hr)) {
 332         TRACE("Cannot stop filtergraph (hr = %x)\n", hr);
 333         return MCIERR_INTERNAL;
 334     }
 335
 336     wma->started = FALSE;
 337
 338     return 0;
 339 }
 340
 341 /***************************************************************************
 342  *                              MCIQTZ_mciGetDevCaps            [internal]
 343  */
 344 static DWORD MCIQTZ_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms)
 345 {
 346     WINE_MCIQTZ* wma;
 347
 348     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 349
 350     if (!lpParms)
 351         return MCIERR_NULL_PARAMETER_BLOCK;
 352
 353     wma = MCIQTZ_mciGetOpenDev(wDevID);
 354     if (!wma)
 355         return MCIERR_INVALID_DEVICE_ID;
 356
 357     if (!(dwFlags & MCI_STATUS_ITEM)) {
 358         WARN("No capability item specified\n");
 359         return MCIERR_UNRECOGNIZED_COMMAND;
 360     }
 361
 362     switch (lpParms->dwItem) {
 363         case MCI_GETDEVCAPS_CAN_RECORD:
 364             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 365             TRACE("MCI_GETDEVCAPS_CAN_RECORD = %08x\n", lpParms->dwReturn);
 366             break;
 367         case MCI_GETDEVCAPS_HAS_AUDIO:
 368             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 369             TRACE("MCI_GETDEVCAPS_HAS_AUDIO = %08x\n", lpParms->dwReturn);
 370             break;
 371         case MCI_GETDEVCAPS_HAS_VIDEO:
 372             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 373             TRACE("MCI_GETDEVCAPS_HAS_VIDEO = %08x\n", lpParms->dwReturn);
 374             break;
 375         case MCI_GETDEVCAPS_DEVICE_TYPE:
 376             lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_DIGITAL_VIDEO, MCI_DEVTYPE_DIGITAL_VIDEO);
 377             TRACE("MCI_GETDEVCAPS_DEVICE_TYPE = %08x\n", lpParms->dwReturn);
 378             break;
 379         case MCI_GETDEVCAPS_USES_FILES:
 380             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 381             TRACE("MCI_GETDEVCAPS_USES_FILES = %08x\n", lpParms->dwReturn);
 382             break;
 383         case MCI_GETDEVCAPS_COMPOUND_DEVICE:
 384             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 385             TRACE("MCI_GETDEVCAPS_COMPOUND_DEVICE = %08x\n", lpParms->dwReturn);
 386             break;
 387         case MCI_GETDEVCAPS_CAN_EJECT:
 388             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 389             TRACE("MCI_GETDEVCAPS_EJECT = %08x\n", lpParms->dwReturn);
 390             break;
 391         case MCI_GETDEVCAPS_CAN_PLAY:
 392             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 393             TRACE("MCI_GETDEVCAPS_CAN_PLAY = %08x\n", lpParms->dwReturn);
 394             break;
 395         case MCI_GETDEVCAPS_CAN_SAVE:
 396             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 397             TRACE("MCI_GETDEVCAPS_CAN_SAVE = %08x\n", lpParms->dwReturn);
 398             break;
 399         default:
 400             ERR("Unknown capability %08x\n", lpParms->dwItem);
 401             return MCIERR_UNRECOGNIZED_COMMAND;
 402     }
 403
 404     return MCI_RESOURCE_RETURNED;
 405 }
 406
 407 /***************************************************************************
 408  *                              MCIQTZ_mciSet                   [internal]
 409  */
 410 static DWORD MCIQTZ_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms)
 411 {
 412     WINE_MCIQTZ* wma;
 413
 414     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 415
 416     if (!lpParms)
 417         return MCIERR_NULL_PARAMETER_BLOCK;
 418
 419     wma = MCIQTZ_mciGetOpenDev(wDevID);
 420     if (!wma)
 421         return MCIERR_INVALID_DEVICE_ID;
 422
 423     if (dwFlags & MCI_SET_TIME_FORMAT) {
 424         switch (lpParms->dwTimeFormat) {
 425             case MCI_FORMAT_MILLISECONDS:
 426                 TRACE("MCI_SET_TIME_FORMAT = MCI_FORMAT_MILLISECONDS\n");
 427                 wma->time_format = MCI_FORMAT_MILLISECONDS;
 428                 break;
 429             case MCI_FORMAT_FRAMES:
 430                 TRACE("MCI_SET_TIME_FORMAT = MCI_FORMAT_FRAMES\n");
 431                 wma->time_format = MCI_FORMAT_FRAMES;
 432                 break;
 433             default:
 434                 WARN("Bad time format %u\n", lpParms->dwTimeFormat);
 435                 return MCIERR_BAD_TIME_FORMAT;
 436         }
 437     }
 438
 439     if (dwFlags & MCI_SET_DOOR_OPEN)
 440         FIXME("MCI_SET_DOOR_OPEN not implemented yet\n");
 441     if (dwFlags & MCI_SET_DOOR_CLOSED)
 442         FIXME("MCI_SET_DOOR_CLOSED not implemented yet\n");
 443     if (dwFlags & MCI_SET_AUDIO)
 444         FIXME("MCI_SET_AUDIO not implemented yet\n");
 445     if (dwFlags & MCI_SET_VIDEO)
 446         FIXME("MCI_SET_VIDEO not implemented yet\n");
 447     if (dwFlags & MCI_SET_ON)
 448         FIXME("MCI_SET_ON not implemented yet\n");
 449     if (dwFlags & MCI_SET_OFF)
 450         FIXME("MCI_SET_OFF not implemented yet\n");
 451     if (dwFlags & MCI_SET_AUDIO_LEFT)
 452         FIXME("MCI_SET_AUDIO_LEFT not implemented yet\n");
 453     if (dwFlags & MCI_SET_AUDIO_RIGHT)
 454         FIXME("MCI_SET_AUDIO_RIGHT not implemented yet\n");
 455
 456     if (dwFlags & ~0x7f03 /* All MCI_SET flags mask */)
 457         ERR("Unknown flags %08x\n", dwFlags & ~0x7f03);
 458
 459     return 0;
 460 }
 461
 462 /***************************************************************************
 463  *                              MCIQTZ_mciStatus                [internal]
 464  */
 465 static DWORD MCIQTZ_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpParms)
 466 {
 467     WINE_MCIQTZ* wma;
 468
 469     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 470
 471     if (!lpParms)
 472         return MCIERR_NULL_PARAMETER_BLOCK;
 473
 474     wma = MCIQTZ_mciGetOpenDev(wDevID);
 475     if (!wma)
 476         return MCIERR_INVALID_DEVICE_ID;
 477
 478     if (!(dwFlags & MCI_STATUS_ITEM)) {
 479         WARN("No status item specified\n");
 480         return MCIERR_UNRECOGNIZED_COMMAND;
 481     }
 482
 483     switch (lpParms->dwItem) {
 484         case MCI_STATUS_LENGTH:
 485             FIXME("MCI_STATUS_LENGTH not implemented yet\n");
 486             return MCIERR_UNRECOGNIZED_COMMAND;
 487         case MCI_STATUS_POSITION:
 488         {
 489             HRESULT hr;
 490             REFTIME curpos;
 491             IMediaPosition* pmpos;
 492
 493             hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaPosition, (LPVOID*)&pmpos);
 494             if (FAILED(hr)) {
 495                 FIXME("Cannot get IMediaPostion interface (hr = %x)\n", hr);
 496                 return MCIERR_INTERNAL;
 497             }
 498
 499             hr = IMediaPosition_get_CurrentPosition(pmpos, &curpos);
 500             if (FAILED(hr)) {
 501                 FIXME("Cannot get position (hr = %x)\n", hr);
 502                 IMediaPosition_Release(pmpos);
 503                 return MCIERR_INTERNAL;
 504             }
 505
 506             IMediaPosition_Release(pmpos);
 507             lpParms->dwReturn = curpos / 10000;
 508
 509             break;
 510         }
 511         case MCI_STATUS_NUMBER_OF_TRACKS:
 512             FIXME("MCI_STATUS_NUMBER_OF_TRACKS not implemented yet\n");
 513             return MCIERR_UNRECOGNIZED_COMMAND;
 514         case MCI_STATUS_MODE:
 515             FIXME("MCI_STATUS_MODE not implemented yet\n");
 516             return MCIERR_UNRECOGNIZED_COMMAND;
 517         case MCI_STATUS_MEDIA_PRESENT:
 518             FIXME("MCI_STATUS_MEDIA_PRESENT not implemented yet\n");
 519             return MCIERR_UNRECOGNIZED_COMMAND;
 520         case MCI_STATUS_TIME_FORMAT:
 521             FIXME("MCI_STATUS_TIME_FORMAT not implemented yet\n");
 522             return MCIERR_UNRECOGNIZED_COMMAND;
 523         case MCI_STATUS_READY:
 524             FIXME("MCI_STATUS_READY not implemented yet\n");
 525             return MCIERR_UNRECOGNIZED_COMMAND;
 526         case MCI_STATUS_CURRENT_TRACK:
 527             FIXME("MCI_STATUS_CURRENT_TRACK not implemented yet\n");
 528             return MCIERR_UNRECOGNIZED_COMMAND;
 529         default:
 530             FIXME("Unknown command %08X\n", lpParms->dwItem);
 531             return MCIERR_UNRECOGNIZED_COMMAND;
 532     }
 533
 534     if (dwFlags & MCI_NOTIFY)
 535         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)), wDevID, MCI_NOTIFY_SUCCESSFUL);
 536
 537     return 0;
 538 }
 539
 540 /***************************************************************************
 541  *                              MCIQTZ_mciWhere                 [internal]
 542  */
 543 static DWORD MCIQTZ_mciWhere(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
 544 {
 545     WINE_MCIQTZ* wma;
 546     IVideoWindow* pVideoWindow;
 547     HRESULT hr;
 548     HWND hWnd;
 549     RECT rc;
 550
 551     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 552
 553     if (!lpParms)
 554         return MCIERR_NULL_PARAMETER_BLOCK;
 555
 556     wma = MCIQTZ_mciGetOpenDev(wDevID);
 557     if (!wma)
 558         return MCIERR_INVALID_DEVICE_ID;
 559
 560     /* Find if there is a video stream and get the display window */
 561     hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
 562     if (FAILED(hr)) {
 563         ERR("Cannot get IVideoWindow interface (hr = %x)\n", hr);
 564         return MCIERR_INTERNAL;
 565     }
 566
 567     hr = IVideoWindow_get_Owner(pVideoWindow, (OAHWND*)&hWnd);
 568     IVideoWindow_Release(pVideoWindow);
 569     if (FAILED(hr)) {
 570         TRACE("No video stream, returning no window error\n");
 571         return MCIERR_NO_WINDOW;
 572     }
 573
 574     if (dwFlags & MCI_DGV_WHERE_SOURCE) {
 575         if (dwFlags & MCI_DGV_WHERE_MAX)
 576             FIXME("MCI_DGV_WHERE_SOURCE_MAX not supported yet\n");
 577         else
 578             FIXME("MCI_DGV_WHERE_SOURCE not supported yet\n");
 579         return MCIERR_UNRECOGNIZED_COMMAND;
 580     }
 581     if (dwFlags & MCI_DGV_WHERE_DESTINATION) {
 582         if (dwFlags & MCI_DGV_WHERE_MAX) {
 583             GetClientRect(hWnd, &rc);
 584             TRACE("MCI_DGV_WHERE_DESTINATION_MAX %s\n", wine_dbgstr_rect(&rc));
 585         } else {
 586             FIXME("MCI_DGV_WHERE_DESTINATION not supported yet\n");
 587             return MCIERR_UNRECOGNIZED_COMMAND;
 588         }
 589     }
 590     if (dwFlags & MCI_DGV_WHERE_FRAME) {
 591         if (dwFlags & MCI_DGV_WHERE_MAX)
 592             FIXME("MCI_DGV_WHERE_FRAME_MAX not supported yet\n");
 593         else
 594             FIXME("MCI_DGV_WHERE_FRAME not supported yet\n");
 595         return MCIERR_UNRECOGNIZED_COMMAND;
 596     }
 597     if (dwFlags & MCI_DGV_WHERE_VIDEO) {
 598         if (dwFlags & MCI_DGV_WHERE_MAX)
 599             FIXME("MCI_DGV_WHERE_VIDEO_MAX not supported yet\n");
 600         else
 601             FIXME("MCI_DGV_WHERE_VIDEO not supported yet\n");
 602         return MCIERR_UNRECOGNIZED_COMMAND;
 603     }
 604     if (dwFlags & MCI_DGV_WHERE_WINDOW) {
 605         if (dwFlags & MCI_DGV_WHERE_MAX) {
 606             GetWindowRect(GetDesktopWindow(), &rc);
 607             TRACE("MCI_DGV_WHERE_WINDOW_MAX %s\n", wine_dbgstr_rect(&rc));
 608         } else {
 609             GetWindowRect(hWnd, &rc);
 610             TRACE("MCI_DGV_WHERE_WINDOW %s\n", wine_dbgstr_rect(&rc));
 611         }
 612     }
 613
 614     /* In MCI, RECT structure is used differently: rc.right = width & rc.bottom = height
 615      * So convert the normal RECT into a MCI RECT before returning */
 616     lpParms->rc.left = rc.left;
 617     lpParms->rc.top = rc.right;
 618     lpParms->rc.right = rc.right - rc.left;
 619     lpParms->rc.bottom = rc.bottom - rc.top;
 620
 621     return 0;
 622 }
 623
 624 /***************************************************************************
 625  *                              MCIQTZ_mciSetAudio              [internal]
 626  */
 627 static DWORD MCIQTZ_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSW lpParms)
 628 {
 629     WINE_MCIQTZ *wma;
 630
 631     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 632
 633     if (!lpParms)
 634         return MCIERR_NULL_PARAMETER_BLOCK;
 635
 636     wma = MCIQTZ_mciGetOpenDev(wDevID);
 637     if (!wma)
 638         return MCIERR_INVALID_DEVICE_ID;
 639
 640     MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
 641
 642     return 0;
 643 }
 644
 645 /*======================================================================*
 646  *                          MCI QTZ entry points                        *
 647  *======================================================================*/
 648
 649 /**************************************************************************
 650  *                              DriverProc (MCIQTZ.@)
 651  */
 652 LRESULT CALLBACK MCIQTZ_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
 653                                    LPARAM dwParam1, LPARAM dwParam2)
 654 {
 655     TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
 656           dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 657
 658     switch (wMsg) {
 659         case DRV_LOAD:                  return 1;
 660         case DRV_FREE:                  return 1;
 661         case DRV_OPEN:                  return MCIQTZ_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
 662         case DRV_CLOSE:                 return MCIQTZ_drvClose(dwDevID);
 663         case DRV_ENABLE:                return 1;
 664         case DRV_DISABLE:               return 1;
 665         case DRV_QUERYCONFIGURE:        return 1;
 666         case DRV_CONFIGURE:             return MCIQTZ_drvConfigure(dwDevID);
 667         case DRV_INSTALL:               return DRVCNF_RESTART;
 668         case DRV_REMOVE:                return DRVCNF_RESTART;
 669     }
 670
 671     /* session instance */
 672     if (dwDevID == 0xFFFFFFFF)
 673         return 1;
 674
 675     switch (wMsg) {
 676         case MCI_OPEN_DRIVER:   return MCIQTZ_mciOpen      (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSW)     dwParam2);
 677         case MCI_CLOSE_DRIVER:  return MCIQTZ_mciClose     (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
 678         case MCI_PLAY:          return MCIQTZ_mciPlay      (dwDevID, dwParam1, (LPMCI_PLAY_PARMS)          dwParam2);
 679         case MCI_SEEK:          return MCIQTZ_mciSeek      (dwDevID, dwParam1, (LPMCI_SEEK_PARMS)          dwParam2);
 680         case MCI_STOP:          return MCIQTZ_mciStop      (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
 681         case MCI_GETDEVCAPS:    return MCIQTZ_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)    dwParam2);
 682         case MCI_SET:           return MCIQTZ_mciSet       (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS)       dwParam2);
 683         case MCI_STATUS:        return MCIQTZ_mciStatus    (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSW)   dwParam2);
 684         case MCI_WHERE:         return MCIQTZ_mciWhere     (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS)      dwParam2);
 685         /* Digital Video specific */
 686         case MCI_SETAUDIO:      return MCIQTZ_mciSetAudio  (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
 687         case MCI_RECORD:
 688         case MCI_PAUSE:
 689         case MCI_RESUME:
 690         case MCI_INFO:
 691         case MCI_PUT:
 692         case MCI_WINDOW:
 693         case MCI_LOAD:
 694         case MCI_SAVE:
 695         case MCI_FREEZE:
 696         case MCI_REALIZE:
 697         case MCI_UNFREEZE:
 698         case MCI_UPDATE:
 699         case MCI_STEP:
 700         case MCI_COPY:
 701         case MCI_CUT:
 702         case MCI_DELETE:
 703         case MCI_PASTE:
 704         case MCI_CUE:
 705         /* Digital Video specific */
 706         case MCI_CAPTURE:
 707         case MCI_MONITOR:
 708         case MCI_RESERVE:
 709         case MCI_SIGNAL:
 710         case MCI_SETVIDEO:
 711         case MCI_QUALITY:
 712         case MCI_LIST:
 713         case MCI_UNDO:
 714         case MCI_CONFIGURE:
 715         case MCI_RESTORE:
 716             FIXME("Unimplemented command [%08X]\n", wMsg);
 717             break;
 718         case MCI_SPIN:
 719         case MCI_ESCAPE:
 720             WARN("Unsupported command [%08X]\n", wMsg);
 721             break;
 722         case MCI_OPEN:
 723         case MCI_CLOSE:
 724             FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
 725             break;
 726         default:
 727             TRACE("Sending msg [%08X] to default driver proc\n", wMsg);
 728             return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 729     }
 730
 731     return MCIERR_UNRECOGNIZED_COMMAND;
 732 }