?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Use a separate STATE_VDECL state handler in the GLSL pipeline.
[wine/multimedia.git] / dlls / mciqtz32 / mciqtz.c
bloba1c34505d2a5bb18952e67f62c8bd7ce70fbd52e
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 static 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 static const WCHAR mciAviWStr[] = {'M','C','I','A','V','I',0};
77
78 TRACE("(%s, %p)\n", debugstr_w(str), modp);
79
80 /* session instance */
81 if (!modp)
82 return 0xFFFFFFFF;
83
84 wma = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCIQTZ));
85 if (!wma)
86 return 0;
87
88 wma->stop_event = CreateEventW(NULL, FALSE, FALSE, NULL);
89 modp->wType = MCI_DEVTYPE_DIGITAL_VIDEO;
90 wma->wDevID = modp->wDeviceID;
91 modp->wCustomCommandTable = wma->command_table = mciLoadCommandResource(MCIQTZ_hInstance, mciAviWStr, 0);
92 mciSetDriverData(wma->wDevID, (DWORD_PTR)wma);
93
94 return modp->wDeviceID;
95 }
96
97 /**************************************************************************
98 * MCIQTZ_drvClose [internal]
99 */
100 static DWORD MCIQTZ_drvClose(DWORD dwDevID)
101 {
102 WINE_MCIQTZ* wma;
103
104 TRACE("(%04x)\n", dwDevID);
105
106 wma = MCIQTZ_mciGetOpenDev(dwDevID);
107
108 if (wma) {
109 /* finish all outstanding things */
110 MCIQTZ_mciClose(dwDevID, MCI_WAIT, NULL);
111
112 mciFreeCommandResource(wma->command_table);
113 mciSetDriverData(dwDevID, 0);
114 CloseHandle(wma->stop_event);
115 HeapFree(GetProcessHeap(), 0, wma);
116 return 1;
117 }
118
119 return (dwDevID == 0xFFFFFFFF) ? 1 : 0;
120 }
121
122 /**************************************************************************
123 * MCIQTZ_drvConfigure [internal]
124 */
125 static DWORD MCIQTZ_drvConfigure(DWORD dwDevID)
126 {
127 WINE_MCIQTZ* wma;
128
129 TRACE("(%04x)\n", dwDevID);
130
131 wma = MCIQTZ_mciGetOpenDev(dwDevID);
132 if (!wma)
133 return 0;
134
135 MCIQTZ_mciStop(dwDevID, MCI_WAIT, NULL);
136
137 MessageBoxA(0, "Sample QTZ Wine Driver !", "MM-Wine Driver", MB_OK);
138
139 return 1;
140 }
141
142 /**************************************************************************
143 * MCIQTZ_mciNotify [internal]
144 *
145 * Notifications in MCI work like a 1-element queue.
146 * Each new notification request supersedes the previous one.
147 */
148 static void MCIQTZ_mciNotify(DWORD_PTR hWndCallBack, WINE_MCIQTZ* wma, UINT wStatus)
149 {
150 MCIDEVICEID wDevID = wma->notify_devid;
151 HANDLE old = InterlockedExchangePointer(&wma->callback, NULL);
152 if (old) mciDriverNotify(old, wDevID, MCI_NOTIFY_SUPERSEDED);
153 mciDriverNotify(HWND_32(LOWORD(hWndCallBack)), wDevID, wStatus);
154 }
155
156 /***************************************************************************
157 * MCIQTZ_mciOpen [internal]
158 */
159 static DWORD MCIQTZ_mciOpen(UINT wDevID, DWORD dwFlags,
160 LPMCI_DGV_OPEN_PARMSW lpOpenParms)
161 {
162 WINE_MCIQTZ* wma;
163 HRESULT hr;
164 DWORD style = 0;
165 RECT rc = { 0, 0, 0, 0 };
166
167 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpOpenParms);
168
169 if (!lpOpenParms)
170 return MCIERR_NULL_PARAMETER_BLOCK;
171
172 wma = MCIQTZ_mciGetOpenDev(wDevID);
173 if (!wma)
174 return MCIERR_INVALID_DEVICE_ID;
175
176 MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
177
178 hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
179 wma->uninit = SUCCEEDED(hr);
180
181 hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, &IID_IGraphBuilder, (LPVOID*)&wma->pgraph);
182 if (FAILED(hr)) {
183 TRACE("Cannot create filtergraph (hr = %x)\n", hr);
184 goto err;
185 }
186
187 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaControl, (LPVOID*)&wma->pmctrl);
188 if (FAILED(hr)) {
189 TRACE("Cannot get IMediaControl interface (hr = %x)\n", hr);
190 goto err;
191 }
192
193 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaSeeking, (void**)&wma->seek);
194 if (FAILED(hr)) {
195 TRACE("Cannot get IMediaSeeking interface (hr = %x)\n", hr);
196 goto err;
197 }
198
199 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaEvent, (void**)&wma->mevent);
200 if (FAILED(hr)) {
201 TRACE("Cannot get IMediaEvent interface (hr = %x)\n", hr);
202 goto err;
203 }
204
205 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IVideoWindow, (void**)&wma->vidwin);
206 if (FAILED(hr)) {
207 TRACE("Cannot get IVideoWindow interface (hr = %x)\n", hr);
208 goto err;
209 }
210
211 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IBasicVideo, (void**)&wma->vidbasic);
212 if (FAILED(hr)) {
213 TRACE("Cannot get IBasicVideo interface (hr = %x)\n", hr);
214 goto err;
215 }
216
217 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IBasicAudio, (void**)&wma->audio);
218 if (FAILED(hr)) {
219 TRACE("Cannot get IBasicAudio interface (hr = %x)\n", hr);
220 goto err;
221 }
222
223 if (!(dwFlags & MCI_OPEN_ELEMENT) || (dwFlags & MCI_OPEN_ELEMENT_ID)) {
224 TRACE("Wrong dwFlags %x\n", dwFlags);
225 goto err;
226 }
227
228 if (!lpOpenParms->lpstrElementName || !lpOpenParms->lpstrElementName[0]) {
229 TRACE("Invalid filename specified\n");
230 goto err;
231 }
232
233 TRACE("Open file %s\n", debugstr_w(lpOpenParms->lpstrElementName));
234
235 hr = IGraphBuilder_RenderFile(wma->pgraph, lpOpenParms->lpstrElementName, NULL);
236 if (FAILED(hr)) {
237 TRACE("Cannot render file (hr = %x)\n", hr);
238 goto err;
239 }
240
241 IVideoWindow_put_AutoShow(wma->vidwin, OAFALSE);
242 IVideoWindow_put_Visible(wma->vidwin, OAFALSE);
243 if (dwFlags & MCI_DGV_OPEN_WS)
244 style = lpOpenParms->dwStyle;
245 if (dwFlags & MCI_DGV_OPEN_PARENT) {
246 IVideoWindow_put_MessageDrain(wma->vidwin, (OAHWND)lpOpenParms->hWndParent);
247 IVideoWindow_put_WindowState(wma->vidwin, SW_HIDE);
248 IVideoWindow_put_WindowStyle(wma->vidwin, style|WS_CHILD);
249 IVideoWindow_put_Owner(wma->vidwin, (OAHWND)lpOpenParms->hWndParent);
250 GetClientRect(lpOpenParms->hWndParent, &rc);
251 IVideoWindow_SetWindowPosition(wma->vidwin, rc.left, rc.top, rc.right - rc.top, rc.bottom - rc.top);
252 wma->parent = (HWND)lpOpenParms->hWndParent;
253 }
254 else if (style)
255 IVideoWindow_put_WindowStyle(wma->vidwin, style);
256 IBasicVideo_GetVideoSize(wma->vidbasic, &rc.right, &rc.bottom);
257 wma->opened = TRUE;
258
259 if (dwFlags & MCI_NOTIFY)
260 mciDriverNotify(HWND_32(LOWORD(lpOpenParms->dwCallback)), wDevID, MCI_NOTIFY_SUCCESSFUL);
261
262 return 0;
263
264 err:
265 if (wma->audio)
266 IBasicAudio_Release(wma->audio);
267 wma->audio = NULL;
268 if (wma->vidbasic)
269 IBasicVideo_Release(wma->vidbasic);
270 wma->vidbasic = NULL;
271 if (wma->seek)
272 IMediaSeeking_Release(wma->seek);
273 wma->seek = NULL;
274 if (wma->vidwin)
275 IVideoWindow_Release(wma->vidwin);
276 wma->vidwin = NULL;
277 if (wma->pgraph)
278 IGraphBuilder_Release(wma->pgraph);
279 wma->pgraph = NULL;
280 if (wma->mevent)
281 IMediaEvent_Release(wma->mevent);
282 wma->mevent = NULL;
283 if (wma->pmctrl)
284 IMediaControl_Release(wma->pmctrl);
285 wma->pmctrl = NULL;
286
287 if (wma->uninit)
288 CoUninitialize();
289 wma->uninit = FALSE;
290
291 return MCIERR_INTERNAL;
292 }
293
294 /***************************************************************************
295 * MCIQTZ_mciClose [internal]
296 */
297 static DWORD MCIQTZ_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
298 {
299 WINE_MCIQTZ* wma;
300
301 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
302
303 wma = MCIQTZ_mciGetOpenDev(wDevID);
304 if (!wma)
305 return MCIERR_INVALID_DEVICE_ID;
306
307 MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
308
309 if (wma->opened) {
310 IVideoWindow_Release(wma->vidwin);
311 IBasicVideo_Release(wma->vidbasic);
312 IBasicAudio_Release(wma->audio);
313 IMediaSeeking_Release(wma->seek);
314 IMediaEvent_Release(wma->mevent);
315 IGraphBuilder_Release(wma->pgraph);
316 IMediaControl_Release(wma->pmctrl);
317 if (wma->uninit)
318 CoUninitialize();
319 wma->opened = FALSE;
320 }
321
322 return 0;
323 }
324
325 /***************************************************************************
326 * MCIQTZ_notifyThread [internal]
327 */
328 static DWORD CALLBACK MCIQTZ_notifyThread(LPVOID parm)
329 {
330 WINE_MCIQTZ* wma = (WINE_MCIQTZ *)parm;
331 HRESULT hr;
332 HANDLE handle[2];
333 DWORD n = 0, ret = 0;
334
335 handle[n++] = wma->stop_event;
336 IMediaEvent_GetEventHandle(wma->mevent, (OAEVENT *)&handle[n++]);
337
338 for (;;) {
339 DWORD r;
340 HANDLE old;
341
342 r = WaitForMultipleObjects(n, handle, FALSE, INFINITE);
343 if (r == WAIT_OBJECT_0) {
344 TRACE("got stop event\n");
345 old = InterlockedExchangePointer(&wma->callback, NULL);
346 if (old)
347 mciDriverNotify(old, wma->notify_devid, MCI_NOTIFY_ABORTED);
348 break;
349 }
350 else if (r == WAIT_OBJECT_0+1) {
351 LONG event_code;
352 LONG_PTR p1, p2;
353 do {
354 hr = IMediaEvent_GetEvent(wma->mevent, &event_code, &p1, &p2, 0);
355 if (SUCCEEDED(hr)) {
356 TRACE("got event_code = 0x%02x\n", event_code);
357 IMediaEvent_FreeEventParams(wma->mevent, event_code, p1, p2);
358 }
359 } while (hr == S_OK && event_code != EC_COMPLETE);
360 if (hr == S_OK && event_code == EC_COMPLETE) {
361 old = InterlockedExchangePointer(&wma->callback, NULL);
362 if (old)
363 mciDriverNotify(old, wma->notify_devid, MCI_NOTIFY_SUCCESSFUL);
364 break;
365 }
366 }
367 else {
368 TRACE("Unknown error (%d)\n", (int)r);
369 break;
370 }
371 }
372
373 hr = IMediaControl_Stop(wma->pmctrl);
374 if (FAILED(hr)) {
375 TRACE("Cannot stop filtergraph (hr = %x)\n", hr);
376 ret = MCIERR_INTERNAL;
377 }
378
379 return ret;
380 }
381
382 /***************************************************************************
383 * MCIQTZ_mciPlay [internal]
384 */
385 static DWORD MCIQTZ_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
386 {
387 WINE_MCIQTZ* wma;
388 HRESULT hr;
389 REFERENCE_TIME time1 = 0, time2 = 0;
390 GUID format;
391 DWORD pos1;
392
393 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
394
395 if (!lpParms)
396 return MCIERR_NULL_PARAMETER_BLOCK;
397
398 wma = MCIQTZ_mciGetOpenDev(wDevID);
399 if (!wma)
400 return MCIERR_INVALID_DEVICE_ID;
401
402 ResetEvent(wma->stop_event);
403 if (dwFlags & MCI_NOTIFY) {
404 HANDLE old;
405 old = InterlockedExchangePointer(&wma->callback, HWND_32(LOWORD(lpParms->dwCallback)));
406 if (old)
407 mciDriverNotify(old, wma->notify_devid, MCI_NOTIFY_ABORTED);
408 }
409
410 IMediaSeeking_GetTimeFormat(wma->seek, &format);
411 if (dwFlags & MCI_FROM) {
412 if (IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME))
413 time1 = lpParms->dwFrom * 10000;
414 else
415 time1 = lpParms->dwFrom;
416 pos1 = AM_SEEKING_AbsolutePositioning;
417 } else
418 pos1 = AM_SEEKING_NoPositioning;
419 if (dwFlags & MCI_TO) {
420 if (IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME))
421 time2 = lpParms->dwTo * 10000;
422 else
423 time2 = lpParms->dwTo;
424 } else
425 IMediaSeeking_GetDuration(wma->seek, &time2);
426 IMediaSeeking_SetPositions(wma->seek, &time1, pos1, &time2, AM_SEEKING_AbsolutePositioning);
427
428 hr = IMediaControl_Run(wma->pmctrl);
429 if (FAILED(hr)) {
430 TRACE("Cannot run filtergraph (hr = %x)\n", hr);
431 return MCIERR_INTERNAL;
432 }
433
434 IVideoWindow_put_Visible(wma->vidwin, OATRUE);
435
436 wma->thread = CreateThread(NULL, 0, MCIQTZ_notifyThread, wma, 0, NULL);
437 if (!wma->thread) {
438 TRACE("Can't create thread\n");
439 return MCIERR_INTERNAL;
440 }
441 return 0;
442 }
443
444 /***************************************************************************
445 * MCIQTZ_mciSeek [internal]
446 */
447 static DWORD MCIQTZ_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
448 {
449 WINE_MCIQTZ* wma;
450 HRESULT hr;
451 LONGLONG newpos;
452
453 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
454
455 if (!lpParms)
456 return MCIERR_NULL_PARAMETER_BLOCK;
457
458 wma = MCIQTZ_mciGetOpenDev(wDevID);
459 if (!wma)
460 return MCIERR_INVALID_DEVICE_ID;
461
462 MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
463
464 if (dwFlags & MCI_SEEK_TO_START) {
465 newpos = 0;
466 } else if (dwFlags & MCI_SEEK_TO_END) {
467 FIXME("MCI_SEEK_TO_END not implemented yet\n");
468 return MCIERR_INTERNAL;
469 } else if (dwFlags & MCI_TO) {
470 FIXME("MCI_TO not implemented yet\n");
471 return MCIERR_INTERNAL;
472 } else {
473 WARN("dwFlag doesn't tell where to seek to...\n");
474 return MCIERR_MISSING_PARAMETER;
475 }
476
477 hr = IMediaSeeking_SetPositions(wma->seek, &newpos, AM_SEEKING_AbsolutePositioning, NULL, AM_SEEKING_NoPositioning);
478 if (FAILED(hr)) {
479 FIXME("Cannot set position (hr = %x)\n", hr);
480 return MCIERR_INTERNAL;
481 }
482
483 if (dwFlags & MCI_NOTIFY)
484 MCIQTZ_mciNotify(lpParms->dwCallback, wma, MCI_NOTIFY_SUCCESSFUL);
485
486 return 0;
487 }
488
489 /***************************************************************************
490 * MCIQTZ_mciStop [internal]
491 */
492 static DWORD MCIQTZ_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
493 {
494 WINE_MCIQTZ* wma;
495
496 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
497
498 wma = MCIQTZ_mciGetOpenDev(wDevID);
499 if (!wma)
500 return MCIERR_INVALID_DEVICE_ID;
501
502 if (!wma->opened)
503 return 0;
504
505 if (wma->thread) {
506 SetEvent(wma->stop_event);
507 WaitForSingleObject(wma->thread, INFINITE);
508 CloseHandle(wma->thread);
509 wma->thread = NULL;
510 }
511
512 if (!wma->parent)
513 IVideoWindow_put_Visible(wma->vidwin, OAFALSE);
514
515 return 0;
516 }
517
518 /***************************************************************************
519 * MCIQTZ_mciPause [internal]
520 */
521 static DWORD MCIQTZ_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
522 {
523 WINE_MCIQTZ* wma;
524 HRESULT hr;
525
526 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
527
528 wma = MCIQTZ_mciGetOpenDev(wDevID);
529 if (!wma)
530 return MCIERR_INVALID_DEVICE_ID;
531
532 hr = IMediaControl_Pause(wma->pmctrl);
533 if (FAILED(hr)) {
534 TRACE("Cannot pause filtergraph (hr = %x)\n", hr);
535 return MCIERR_INTERNAL;
536 }
537
538 return 0;
539 }
540
541 /***************************************************************************
542 * MCIQTZ_mciGetDevCaps [internal]
543 */
544 static DWORD MCIQTZ_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms)
545 {
546 WINE_MCIQTZ* wma;
547
548 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
549
550 if (!lpParms)
551 return MCIERR_NULL_PARAMETER_BLOCK;
552
553 wma = MCIQTZ_mciGetOpenDev(wDevID);
554 if (!wma)
555 return MCIERR_INVALID_DEVICE_ID;
556
557 if (!(dwFlags & MCI_GETDEVCAPS_ITEM))
558 return MCIERR_MISSING_PARAMETER;
559
560 switch (lpParms->dwItem) {
561 case MCI_GETDEVCAPS_CAN_RECORD:
562 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
563 TRACE("MCI_GETDEVCAPS_CAN_RECORD = %08x\n", lpParms->dwReturn);
564 break;
565 case MCI_GETDEVCAPS_HAS_AUDIO:
566 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
567 TRACE("MCI_GETDEVCAPS_HAS_AUDIO = %08x\n", lpParms->dwReturn);
568 break;
569 case MCI_GETDEVCAPS_HAS_VIDEO:
570 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
571 TRACE("MCI_GETDEVCAPS_HAS_VIDEO = %08x\n", lpParms->dwReturn);
572 break;
573 case MCI_GETDEVCAPS_DEVICE_TYPE:
574 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_DIGITAL_VIDEO, MCI_DEVTYPE_DIGITAL_VIDEO);
575 TRACE("MCI_GETDEVCAPS_DEVICE_TYPE = %08x\n", lpParms->dwReturn);
576 break;
577 case MCI_GETDEVCAPS_USES_FILES:
578 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
579 TRACE("MCI_GETDEVCAPS_USES_FILES = %08x\n", lpParms->dwReturn);
580 break;
581 case MCI_GETDEVCAPS_COMPOUND_DEVICE:
582 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
583 TRACE("MCI_GETDEVCAPS_COMPOUND_DEVICE = %08x\n", lpParms->dwReturn);
584 break;
585 case MCI_GETDEVCAPS_CAN_EJECT:
586 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
587 TRACE("MCI_GETDEVCAPS_EJECT = %08x\n", lpParms->dwReturn);
588 break;
589 case MCI_GETDEVCAPS_CAN_PLAY:
590 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
591 TRACE("MCI_GETDEVCAPS_CAN_PLAY = %08x\n", lpParms->dwReturn);
592 break;
593 case MCI_GETDEVCAPS_CAN_SAVE:
594 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
595 TRACE("MCI_GETDEVCAPS_CAN_SAVE = %08x\n", lpParms->dwReturn);
596 break;
597 case MCI_DGV_GETDEVCAPS_CAN_REVERSE:
598 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
599 TRACE("MCI_DGV_GETDEVCAPS_CAN_REVERSE = %08x\n", lpParms->dwReturn);
600 break;
601 case MCI_DGV_GETDEVCAPS_CAN_STRETCH:
602 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
603 TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH = %08x\n", lpParms->dwReturn);
604 break;
605 case MCI_DGV_GETDEVCAPS_CAN_LOCK:
606 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
607 TRACE("MCI_DGV_GETDEVCAPS_CAN_LOCK = %08x\n", lpParms->dwReturn);
608 break;
609 case MCI_DGV_GETDEVCAPS_CAN_FREEZE:
610 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
611 TRACE("MCI_DGV_GETDEVCAPS_CAN_FREEZE = %08x\n", lpParms->dwReturn);
612 break;
613 case MCI_DGV_GETDEVCAPS_CAN_STR_IN:
614 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
615 TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH_INPUT = %08x\n", lpParms->dwReturn);
616 break;
617 case MCI_DGV_GETDEVCAPS_HAS_STILL:
618 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
619 TRACE("MCI_DGV_GETDEVCAPS_HAS_STILL = %08x\n", lpParms->dwReturn);
620 break;
621 case MCI_DGV_GETDEVCAPS_CAN_TEST:
622 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
623 TRACE("MCI_DGV_GETDEVCAPS_CAN_TEST = %08x\n", lpParms->dwReturn);
624 break;
625 case MCI_DGV_GETDEVCAPS_MAX_WINDOWS:
626 lpParms->dwReturn = 1;
627 TRACE("MCI_DGV_GETDEVCAPS_MAX_WINDOWS = %u\n", lpParms->dwReturn);
628 return 0;
629 default:
630 WARN("Unknown capability %08x\n", lpParms->dwItem);
631 /* Fall through */
632 case MCI_DGV_GETDEVCAPS_MAXIMUM_RATE: /* unknown to w2k */
633 case MCI_DGV_GETDEVCAPS_MINIMUM_RATE: /* unknown to w2k */
634 return MCIERR_UNSUPPORTED_FUNCTION;
635 }
636
637 return MCI_RESOURCE_RETURNED;
638 }
639
640 /***************************************************************************
641 * MCIQTZ_mciSet [internal]
642 */
643 static DWORD MCIQTZ_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms)
644 {
645 WINE_MCIQTZ* wma;
646
647 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
648
649 if (!lpParms)
650 return MCIERR_NULL_PARAMETER_BLOCK;
651
652 wma = MCIQTZ_mciGetOpenDev(wDevID);
653 if (!wma)
654 return MCIERR_INVALID_DEVICE_ID;
655
656 if (dwFlags & MCI_SET_TIME_FORMAT) {
657 switch (lpParms->dwTimeFormat) {
658 case MCI_FORMAT_MILLISECONDS:
659 TRACE("MCI_SET_TIME_FORMAT = MCI_FORMAT_MILLISECONDS\n");
660 wma->time_format = MCI_FORMAT_MILLISECONDS;
661 break;
662 case MCI_FORMAT_FRAMES:
663 TRACE("MCI_SET_TIME_FORMAT = MCI_FORMAT_FRAMES\n");
664 wma->time_format = MCI_FORMAT_FRAMES;
665 break;
666 default:
667 WARN("Bad time format %u\n", lpParms->dwTimeFormat);
668 return MCIERR_BAD_TIME_FORMAT;
669 }
670 }
671
672 if (dwFlags & MCI_SET_DOOR_OPEN)
673 FIXME("MCI_SET_DOOR_OPEN not implemented yet\n");
674 if (dwFlags & MCI_SET_DOOR_CLOSED)
675 FIXME("MCI_SET_DOOR_CLOSED not implemented yet\n");
676 if (dwFlags & MCI_SET_AUDIO)
677 FIXME("MCI_SET_AUDIO not implemented yet\n");
678 if (dwFlags & MCI_SET_VIDEO)
679 FIXME("MCI_SET_VIDEO not implemented yet\n");
680 if (dwFlags & MCI_SET_ON)
681 FIXME("MCI_SET_ON not implemented yet\n");
682 if (dwFlags & MCI_SET_OFF)
683 FIXME("MCI_SET_OFF not implemented yet\n");
684 if (dwFlags & MCI_SET_AUDIO_LEFT)
685 FIXME("MCI_SET_AUDIO_LEFT not implemented yet\n");
686 if (dwFlags & MCI_SET_AUDIO_RIGHT)
687 FIXME("MCI_SET_AUDIO_RIGHT not implemented yet\n");
688
689 if (dwFlags & ~0x7f03 /* All MCI_SET flags mask */)
690 ERR("Unknown flags %08x\n", dwFlags & ~0x7f03);
691
692 return 0;
693 }
694
695 /***************************************************************************
696 * MCIQTZ_mciStatus [internal]
697 */
698 static DWORD MCIQTZ_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpParms)
699 {
700 WINE_MCIQTZ* wma;
701 HRESULT hr;
702 DWORD ret = MCI_INTEGER_RETURNED;
703
704 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
705
706 if (!lpParms)
707 return MCIERR_NULL_PARAMETER_BLOCK;
708
709 wma = MCIQTZ_mciGetOpenDev(wDevID);
710 if (!wma)
711 return MCIERR_INVALID_DEVICE_ID;
712
713 if (!(dwFlags & MCI_STATUS_ITEM)) {
714 WARN("No status item specified\n");
715 return MCIERR_UNRECOGNIZED_COMMAND;
716 }
717
718 switch (lpParms->dwItem) {
719 case MCI_STATUS_LENGTH: {
720 LONGLONG duration = -1;
721 GUID format;
722 switch (wma->time_format) {
723 case MCI_FORMAT_MILLISECONDS: format = TIME_FORMAT_MEDIA_TIME; break;
724 case MCI_FORMAT_FRAMES: format = TIME_FORMAT_FRAME; break;
725 default: ERR("Unhandled format %x\n", wma->time_format); break;
726 }
727 hr = IMediaSeeking_SetTimeFormat(wma->seek, &format);
728 if (FAILED(hr)) {
729 FIXME("Cannot set time format (hr = %x)\n", hr);
730 lpParms->dwReturn = 0;
731 break;
732 }
733 hr = IMediaSeeking_GetDuration(wma->seek, &duration);
734 if (FAILED(hr) || duration < 0) {
735 FIXME("Cannot read duration (hr = %x)\n", hr);
736 lpParms->dwReturn = 0;
737 } else if (wma->time_format != MCI_FORMAT_MILLISECONDS)
738 lpParms->dwReturn = duration;
739 else
740 lpParms->dwReturn = duration / 10000;
741 break;
742 }
743 case MCI_STATUS_POSITION: {
744 REFERENCE_TIME curpos;
745
746 hr = IMediaSeeking_GetCurrentPosition(wma->seek, &curpos);
747 if (FAILED(hr)) {
748 FIXME("Cannot get position (hr = %x)\n", hr);
749 return MCIERR_INTERNAL;
750 }
751 lpParms->dwReturn = curpos / 10000;
752 break;
753 }
754 case MCI_STATUS_NUMBER_OF_TRACKS:
755 FIXME("MCI_STATUS_NUMBER_OF_TRACKS not implemented yet\n");
756 return MCIERR_UNRECOGNIZED_COMMAND;
757 case MCI_STATUS_MODE: {
758 LONG state = State_Stopped;
759 IMediaControl_GetState(wma->pmctrl, -1, &state);
760 if (state == State_Stopped)
761 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_MODE_STOP, MCI_MODE_STOP);
762 else if (state == State_Running) {
763 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_MODE_PLAY, MCI_MODE_PLAY);
764 if (!wma->thread || WaitForSingleObject(wma->thread, 0) == WAIT_OBJECT_0)
765 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_MODE_STOP, MCI_MODE_STOP);
766 } else if (state == State_Paused)
767 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_MODE_PAUSE, MCI_MODE_PAUSE);
768 ret = MCI_RESOURCE_RETURNED;
769 break;
770 }
771 case MCI_STATUS_MEDIA_PRESENT:
772 FIXME("MCI_STATUS_MEDIA_PRESENT not implemented yet\n");
773 return MCIERR_UNRECOGNIZED_COMMAND;
774 case MCI_STATUS_TIME_FORMAT:
775 lpParms->dwReturn = MAKEMCIRESOURCE(wma->time_format,
776 MCI_FORMAT_RETURN_BASE + wma->time_format);
777 ret = MCI_RESOURCE_RETURNED;
778 break;
779 case MCI_STATUS_READY:
780 FIXME("MCI_STATUS_READY not implemented yet\n");
781 return MCIERR_UNRECOGNIZED_COMMAND;
782 case MCI_STATUS_CURRENT_TRACK:
783 FIXME("MCI_STATUS_CURRENT_TRACK not implemented yet\n");
784 return MCIERR_UNRECOGNIZED_COMMAND;
785 default:
786 FIXME("Unknown command %08X\n", lpParms->dwItem);
787 return MCIERR_UNRECOGNIZED_COMMAND;
788 }
789
790 if (dwFlags & MCI_NOTIFY)
791 MCIQTZ_mciNotify(lpParms->dwCallback, wma, MCI_NOTIFY_SUCCESSFUL);
792
793 return ret;
794 }
795
796 /***************************************************************************
797 * MCIQTZ_mciWhere [internal]
798 */
799 static DWORD MCIQTZ_mciWhere(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
800 {
801 WINE_MCIQTZ* wma;
802 HRESULT hr;
803 HWND hWnd;
804 RECT rc;
805 DWORD ret = MCIERR_UNRECOGNIZED_COMMAND;
806
807 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
808
809 if (!lpParms)
810 return MCIERR_NULL_PARAMETER_BLOCK;
811
812 wma = MCIQTZ_mciGetOpenDev(wDevID);
813 if (!wma)
814 return MCIERR_INVALID_DEVICE_ID;
815
816 hr = IVideoWindow_get_Owner(wma->vidwin, (OAHWND*)&hWnd);
817 if (FAILED(hr)) {
818 TRACE("No video stream, returning no window error\n");
819 return MCIERR_NO_WINDOW;
820 }
821
822 if (dwFlags & MCI_DGV_WHERE_SOURCE) {
823 if (dwFlags & MCI_DGV_WHERE_MAX)
824 FIXME("MCI_DGV_WHERE_SOURCE_MAX stub\n");
825 IBasicVideo_GetSourcePosition(wma->vidbasic, &rc.left, &rc.top, &rc.right, &rc.bottom);
826 TRACE("MCI_DGV_WHERE_SOURCE %s\n", wine_dbgstr_rect(&rc));
827 }
828 if (dwFlags & MCI_DGV_WHERE_DESTINATION) {
829 if (dwFlags & MCI_DGV_WHERE_MAX)
830 FIXME("MCI_DGV_WHERE_DESTINATION_MAX stub\n");
831 IBasicVideo_GetDestinationPosition(wma->vidbasic, &rc.left, &rc.top, &rc.right, &rc.bottom);
832 TRACE("MCI_DGV_WHERE_DESTINATION %s\n", wine_dbgstr_rect(&rc));
833 }
834 if (dwFlags & MCI_DGV_WHERE_FRAME) {
835 if (dwFlags & MCI_DGV_WHERE_MAX)
836 FIXME("MCI_DGV_WHERE_FRAME_MAX not supported yet\n");
837 else
838 FIXME("MCI_DGV_WHERE_FRAME not supported yet\n");
839 goto out;
840 }
841 if (dwFlags & MCI_DGV_WHERE_VIDEO) {
842 if (dwFlags & MCI_DGV_WHERE_MAX)
843 FIXME("MCI_DGV_WHERE_VIDEO_MAX not supported yet\n");
844 else
845 FIXME("MCI_DGV_WHERE_VIDEO not supported yet\n");
846 goto out;
847 }
848 if (dwFlags & MCI_DGV_WHERE_WINDOW) {
849 if (dwFlags & MCI_DGV_WHERE_MAX) {
850 GetWindowRect(GetDesktopWindow(), &rc);
851 rc.right -= rc.left;
852 rc.bottom -= rc.top;
853 TRACE("MCI_DGV_WHERE_WINDOW_MAX %s\n", wine_dbgstr_rect(&rc));
854 } else {
855 IVideoWindow_GetWindowPosition(wma->vidwin, &rc.left, &rc.top, &rc.right, &rc.bottom);
856 TRACE("MCI_DGV_WHERE_WINDOW %s\n", wine_dbgstr_rect(&rc));
857 }
858 }
859 ret = 0;
860 out:
861 lpParms->rc = rc;
862 return ret;
863 }
864
865 /***************************************************************************
866 * MCIQTZ_mciWindow [internal]
867 */
868 static DWORD MCIQTZ_mciWindow(UINT wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSW lpParms)
869 {
870 WINE_MCIQTZ *wma = MCIQTZ_mciGetOpenDev(wDevID);
871
872 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
873
874 if (!lpParms)
875 return MCIERR_NULL_PARAMETER_BLOCK;
876 if (!wma)
877 return MCIERR_INVALID_DEVICE_ID;
878 if (dwFlags & MCI_TEST)
879 return 0;
880
881 if (dwFlags & MCI_DGV_WINDOW_HWND && (IsWindow(lpParms->hWnd) || !lpParms->hWnd)) {
882 LONG visible = OATRUE;
883 LONG style = 0;
884 TRACE("Setting hWnd to %p\n", lpParms->hWnd);
885 IVideoWindow_get_Visible(wma->vidwin, &visible);
886 IVideoWindow_put_Visible(wma->vidwin, OAFALSE);
887 IVideoWindow_get_WindowStyle(wma->vidwin, &style);
888 style &= ~WS_CHILD;
889 if (lpParms->hWnd)
890 IVideoWindow_put_WindowStyle(wma->vidwin, style|WS_CHILD);
891 else
892 IVideoWindow_put_WindowStyle(wma->vidwin, style);
893 IVideoWindow_put_Owner(wma->vidwin, (OAHWND)lpParms->hWnd);
894 IVideoWindow_put_MessageDrain(wma->vidwin, (OAHWND)lpParms->hWnd);
895 IVideoWindow_put_Visible(wma->vidwin, visible);
896 wma->parent = lpParms->hWnd;
897 }
898 if (dwFlags & MCI_DGV_WINDOW_STATE) {
899 TRACE("Setting nCmdShow to %d\n", lpParms->nCmdShow);
900 IVideoWindow_put_WindowState(wma->vidwin, lpParms->nCmdShow);
901 }
902 if (dwFlags & MCI_DGV_WINDOW_TEXT) {
903 TRACE("Setting caption to %s\n", debugstr_w(lpParms->lpstrText));
904 IVideoWindow_put_Caption(wma->vidwin, lpParms->lpstrText);
905 }
906 return 0;
907 }
908
909 /******************************************************************************
910 * MCIAVI_mciUpdate [internal]
911 */
912 static DWORD MCIQTZ_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
913 {
914 WINE_MCIQTZ *wma;
915 DWORD res = 0;
916
917 TRACE("%04x, %08x, %p\n", wDevID, dwFlags, lpParms);
918
919 if (!lpParms)
920 return MCIERR_NULL_PARAMETER_BLOCK;
921
922 wma = MCIQTZ_mciGetOpenDev(wDevID);
923 if (!wma)
924 return MCIERR_INVALID_DEVICE_ID;
925
926 if (dwFlags & MCI_DGV_UPDATE_HDC) {
927 LONG state, size;
928 BYTE *data;
929 BITMAPINFO *info;
930 HRESULT hr;
931 RECT src, dest;
932 LONG visible = OATRUE;
933
934 res = MCIERR_INTERNAL;
935 IMediaControl_GetState(wma->pmctrl, -1, &state);
936 if (state == State_Running)
937 return MCIERR_UNSUPPORTED_FUNCTION;
938 /* If in stopped state, nothing has been drawn to screen
939 * moving to pause, which is needed for the old dib renderer, will result
940 * in a single frame drawn, so hide the window here */
941 IVideoWindow_get_Visible(wma->vidwin, &visible);
942 if (wma->parent)
943 IVideoWindow_put_Visible(wma->vidwin, OAFALSE);
944 /* FIXME: Should we check the original state and restore it? */
945 IMediaControl_Pause(wma->pmctrl);
946 IMediaControl_GetState(wma->pmctrl, -1, &state);
947 if (FAILED(hr = IBasicVideo_GetCurrentImage(wma->vidbasic, &size, NULL))) {
948 WARN("Could not get image size (hr = %x)\n", hr);
949 goto out;
950 }
951 data = HeapAlloc(GetProcessHeap(), 0, size);
952 info = (BITMAPINFO*)data;
953 IBasicVideo_GetCurrentImage(wma->vidbasic, &size, (LONG*)data);
954 data += info->bmiHeader.biSize;
955
956 IBasicVideo_GetSourcePosition(wma->vidbasic, &src.left, &src.top, &src.right, &src.bottom);
957 IBasicVideo_GetDestinationPosition(wma->vidbasic, &dest.left, &dest.top, &dest.right, &dest.bottom);
958 StretchDIBits(lpParms->hDC,
959 dest.left, dest.top, dest.right + dest.left, dest.bottom + dest.top,
960 src.left, src.top, src.right + src.left, src.bottom + src.top,
961 data, info, DIB_RGB_COLORS, SRCCOPY);
962 HeapFree(GetProcessHeap(), 0, data);
963 res = 0;
964 out:
965 if (wma->parent)
966 IVideoWindow_put_Visible(wma->vidwin, visible);
967 }
968 else if (dwFlags)
969 FIXME("Unhandled flags %x\n", dwFlags);
970 return res;
971 }
972
973 /***************************************************************************
974 * MCIQTZ_mciSetAudio [internal]
975 */
976 static DWORD MCIQTZ_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSW lpParms)
977 {
978 WINE_MCIQTZ *wma;
979 DWORD ret = 0;
980
981 TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms);
982
983 if (!lpParms)
984 return MCIERR_NULL_PARAMETER_BLOCK;
985
986 wma = MCIQTZ_mciGetOpenDev(wDevID);
987 if (!wma)
988 return MCIERR_INVALID_DEVICE_ID;
989
990 if (!(dwFlags & MCI_DGV_SETAUDIO_ITEM)) {
991 FIXME("Unknown flags (%08x)\n", dwFlags);
992 return 0;
993 }
994
995 if (dwFlags & MCI_DGV_SETAUDIO_ITEM) {
996 switch (lpParms->dwItem) {
997 case MCI_DGV_SETAUDIO_VOLUME:
998 if (dwFlags & MCI_DGV_SETAUDIO_VALUE) {
999 long vol = -10000;
1000 HRESULT hr;
1001 if (lpParms->dwValue > 1000) {
1002 ret = MCIERR_OUTOFRANGE;
1003 break;
1004 }
1005 if (dwFlags & MCI_TEST)
1006 break;
1007 vol += (long)lpParms->dwValue * 10;
1008 hr = IBasicAudio_put_Volume(wma->audio, vol);
1009 if (FAILED(hr)) {
1010 WARN("Cannot set volume (hr = %x)\n", hr);
1011 ret = MCIERR_INTERNAL;
1012 }
1013 }
1014 break;
1015 default:
1016 FIXME("Unknown item %08x\n", lpParms->dwItem);
1017 break;
1018 }
1019 }
1020
1021 return ret;
1022 }
1023
1024 /*======================================================================*
1025 * MCI QTZ entry points *
1026 *======================================================================*/
1027
1028 /**************************************************************************
1029 * DriverProc (MCIQTZ.@)
1030 */
1031 LRESULT CALLBACK MCIQTZ_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
1032 LPARAM dwParam1, LPARAM dwParam2)
1033 {
1034 TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
1035 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1036
1037 switch (wMsg) {
1038 case DRV_LOAD: return 1;
1039 case DRV_FREE: return 1;
1040 case DRV_OPEN: return MCIQTZ_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
1041 case DRV_CLOSE: return MCIQTZ_drvClose(dwDevID);
1042 case DRV_ENABLE: return 1;
1043 case DRV_DISABLE: return 1;
1044 case DRV_QUERYCONFIGURE: return 1;
1045 case DRV_CONFIGURE: return MCIQTZ_drvConfigure(dwDevID);
1046 case DRV_INSTALL: return DRVCNF_RESTART;
1047 case DRV_REMOVE: return DRVCNF_RESTART;
1048 }
1049
1050 /* session instance */
1051 if (dwDevID == 0xFFFFFFFF)
1052 return 1;
1053
1054 switch (wMsg) {
1055 case MCI_OPEN_DRIVER: return MCIQTZ_mciOpen (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSW) dwParam2);
1056 case MCI_CLOSE_DRIVER: return MCIQTZ_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1057 case MCI_PLAY: return MCIQTZ_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
1058 case MCI_SEEK: return MCIQTZ_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
1059 case MCI_STOP: return MCIQTZ_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1060 case MCI_PAUSE: return MCIQTZ_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1061 case MCI_GETDEVCAPS: return MCIQTZ_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
1062 case MCI_SET: return MCIQTZ_mciSet (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS) dwParam2);
1063 case MCI_STATUS: return MCIQTZ_mciStatus (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSW) dwParam2);
1064 case MCI_WHERE: return MCIQTZ_mciWhere (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
1065 /* Digital Video specific */
1066 case MCI_SETAUDIO: return MCIQTZ_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
1067 case MCI_UPDATE:
1068 return MCIQTZ_mciUpdate(dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS)dwParam2);
1069 case MCI_WINDOW:
1070 return MCIQTZ_mciWindow(dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSW)dwParam2);
1071 case MCI_PUT:
1072 case MCI_RECORD:
1073 case MCI_RESUME:
1074 case MCI_INFO:
1075 case MCI_LOAD:
1076 case MCI_SAVE:
1077 case MCI_FREEZE:
1078 case MCI_REALIZE:
1079 case MCI_UNFREEZE:
1080 case MCI_STEP:
1081 case MCI_COPY:
1082 case MCI_CUT:
1083 case MCI_DELETE:
1084 case MCI_PASTE:
1085 case MCI_CUE:
1086 /* Digital Video specific */
1087 case MCI_CAPTURE:
1088 case MCI_MONITOR:
1089 case MCI_RESERVE:
1090 case MCI_SIGNAL:
1091 case MCI_SETVIDEO:
1092 case MCI_QUALITY:
1093 case MCI_LIST:
1094 case MCI_UNDO:
1095 case MCI_CONFIGURE:
1096 case MCI_RESTORE:
1097 FIXME("Unimplemented command [%08X]\n", wMsg);
1098 break;
1099 case MCI_SPIN:
1100 case MCI_ESCAPE:
1101 WARN("Unsupported command [%08X]\n", wMsg);
1102 break;
1103 case MCI_OPEN:
1104 case MCI_CLOSE:
1105 FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1106 break;
1107 default:
1108 TRACE("Sending msg [%08X] to default driver proc\n", wMsg);
1109 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1110 }
1111
1112 return MCIERR_UNRECOGNIZED_COMMAND;
1113 }
Maarten's multimedia branch