?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Reimplement Ellipse in paths to avoid calling imprecise arc helper functions.
[wine.git] / dlls / mciqtz32 / mciqtz.c
blob4c9074b0c86c1cf8c362b88a5dc9e98290717e70
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_mciResume [internal]
543 */
544 static DWORD MCIQTZ_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
545 {
546 WINE_MCIQTZ* wma;
547 HRESULT hr;
548
549 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
550
551 wma = MCIQTZ_mciGetOpenDev(wDevID);
552 if (!wma)
553 return MCIERR_INVALID_DEVICE_ID;
554
555 hr = IMediaControl_Run(wma->pmctrl);
556 if (FAILED(hr)) {
557 TRACE("Cannot run filtergraph (hr = %x)\n", hr);
558 return MCIERR_INTERNAL;
559 }
560
561 return 0;
562 }
563
564 /***************************************************************************
565 * MCIQTZ_mciGetDevCaps [internal]
566 */
567 static DWORD MCIQTZ_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms)
568 {
569 WINE_MCIQTZ* wma;
570
571 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
572
573 if(!lpParms)
574 return MCIERR_NULL_PARAMETER_BLOCK;
575
576 wma = MCIQTZ_mciGetOpenDev(wDevID);
577 if (!wma)
578 return MCIERR_INVALID_DEVICE_ID;
579
580 if (!(dwFlags & MCI_GETDEVCAPS_ITEM))
581 return MCIERR_MISSING_PARAMETER;
582
583 switch (lpParms->dwItem) {
584 case MCI_GETDEVCAPS_CAN_RECORD:
585 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
586 TRACE("MCI_GETDEVCAPS_CAN_RECORD = %08x\n", lpParms->dwReturn);
587 break;
588 case MCI_GETDEVCAPS_HAS_AUDIO:
589 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
590 TRACE("MCI_GETDEVCAPS_HAS_AUDIO = %08x\n", lpParms->dwReturn);
591 break;
592 case MCI_GETDEVCAPS_HAS_VIDEO:
593 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
594 TRACE("MCI_GETDEVCAPS_HAS_VIDEO = %08x\n", lpParms->dwReturn);
595 break;
596 case MCI_GETDEVCAPS_DEVICE_TYPE:
597 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_DIGITAL_VIDEO, MCI_DEVTYPE_DIGITAL_VIDEO);
598 TRACE("MCI_GETDEVCAPS_DEVICE_TYPE = %08x\n", lpParms->dwReturn);
599 break;
600 case MCI_GETDEVCAPS_USES_FILES:
601 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
602 TRACE("MCI_GETDEVCAPS_USES_FILES = %08x\n", lpParms->dwReturn);
603 break;
604 case MCI_GETDEVCAPS_COMPOUND_DEVICE:
605 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
606 TRACE("MCI_GETDEVCAPS_COMPOUND_DEVICE = %08x\n", lpParms->dwReturn);
607 break;
608 case MCI_GETDEVCAPS_CAN_EJECT:
609 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
610 TRACE("MCI_GETDEVCAPS_EJECT = %08x\n", lpParms->dwReturn);
611 break;
612 case MCI_GETDEVCAPS_CAN_PLAY:
613 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
614 TRACE("MCI_GETDEVCAPS_CAN_PLAY = %08x\n", lpParms->dwReturn);
615 break;
616 case MCI_GETDEVCAPS_CAN_SAVE:
617 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
618 TRACE("MCI_GETDEVCAPS_CAN_SAVE = %08x\n", lpParms->dwReturn);
619 break;
620 case MCI_DGV_GETDEVCAPS_CAN_REVERSE:
621 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
622 TRACE("MCI_DGV_GETDEVCAPS_CAN_REVERSE = %08x\n", lpParms->dwReturn);
623 break;
624 case MCI_DGV_GETDEVCAPS_CAN_STRETCH:
625 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
626 TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH = %08x\n", lpParms->dwReturn);
627 break;
628 case MCI_DGV_GETDEVCAPS_CAN_LOCK:
629 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
630 TRACE("MCI_DGV_GETDEVCAPS_CAN_LOCK = %08x\n", lpParms->dwReturn);
631 break;
632 case MCI_DGV_GETDEVCAPS_CAN_FREEZE:
633 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
634 TRACE("MCI_DGV_GETDEVCAPS_CAN_FREEZE = %08x\n", lpParms->dwReturn);
635 break;
636 case MCI_DGV_GETDEVCAPS_CAN_STR_IN:
637 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
638 TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH_INPUT = %08x\n", lpParms->dwReturn);
639 break;
640 case MCI_DGV_GETDEVCAPS_HAS_STILL:
641 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
642 TRACE("MCI_DGV_GETDEVCAPS_HAS_STILL = %08x\n", lpParms->dwReturn);
643 break;
644 case MCI_DGV_GETDEVCAPS_CAN_TEST:
645 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
646 TRACE("MCI_DGV_GETDEVCAPS_CAN_TEST = %08x\n", lpParms->dwReturn);
647 break;
648 case MCI_DGV_GETDEVCAPS_MAX_WINDOWS:
649 lpParms->dwReturn = 1;
650 TRACE("MCI_DGV_GETDEVCAPS_MAX_WINDOWS = %u\n", lpParms->dwReturn);
651 return 0;
652 default:
653 WARN("Unknown capability %08x\n", lpParms->dwItem);
654 /* Fall through */
655 case MCI_DGV_GETDEVCAPS_MAXIMUM_RATE: /* unknown to w2k */
656 case MCI_DGV_GETDEVCAPS_MINIMUM_RATE: /* unknown to w2k */
657 return MCIERR_UNSUPPORTED_FUNCTION;
658 }
659
660 return MCI_RESOURCE_RETURNED;
661 }
662
663 /***************************************************************************
664 * MCIQTZ_mciSet [internal]
665 */
666 static DWORD MCIQTZ_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms)
667 {
668 WINE_MCIQTZ* wma;
669
670 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
671
672 if(!lpParms)
673 return MCIERR_NULL_PARAMETER_BLOCK;
674
675 wma = MCIQTZ_mciGetOpenDev(wDevID);
676 if (!wma)
677 return MCIERR_INVALID_DEVICE_ID;
678
679 if (dwFlags & MCI_SET_TIME_FORMAT) {
680 switch (lpParms->dwTimeFormat) {
681 case MCI_FORMAT_MILLISECONDS:
682 TRACE("MCI_SET_TIME_FORMAT = MCI_FORMAT_MILLISECONDS\n");
683 wma->time_format = MCI_FORMAT_MILLISECONDS;
684 break;
685 case MCI_FORMAT_FRAMES:
686 TRACE("MCI_SET_TIME_FORMAT = MCI_FORMAT_FRAMES\n");
687 wma->time_format = MCI_FORMAT_FRAMES;
688 break;
689 default:
690 WARN("Bad time format %u\n", lpParms->dwTimeFormat);
691 return MCIERR_BAD_TIME_FORMAT;
692 }
693 }
694
695 if (dwFlags & MCI_SET_DOOR_OPEN)
696 FIXME("MCI_SET_DOOR_OPEN not implemented yet\n");
697 if (dwFlags & MCI_SET_DOOR_CLOSED)
698 FIXME("MCI_SET_DOOR_CLOSED not implemented yet\n");
699 if (dwFlags & MCI_SET_AUDIO)
700 FIXME("MCI_SET_AUDIO not implemented yet\n");
701 if (dwFlags & MCI_SET_VIDEO)
702 FIXME("MCI_SET_VIDEO not implemented yet\n");
703 if (dwFlags & MCI_SET_ON)
704 FIXME("MCI_SET_ON not implemented yet\n");
705 if (dwFlags & MCI_SET_OFF)
706 FIXME("MCI_SET_OFF not implemented yet\n");
707 if (dwFlags & MCI_SET_AUDIO_LEFT)
708 FIXME("MCI_SET_AUDIO_LEFT not implemented yet\n");
709 if (dwFlags & MCI_SET_AUDIO_RIGHT)
710 FIXME("MCI_SET_AUDIO_RIGHT not implemented yet\n");
711
712 if (dwFlags & ~0x7f03 /* All MCI_SET flags mask */)
713 ERR("Unknown flags %08x\n", dwFlags & ~0x7f03);
714
715 return 0;
716 }
717
718 /***************************************************************************
719 * MCIQTZ_mciStatus [internal]
720 */
721 static DWORD MCIQTZ_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpParms)
722 {
723 WINE_MCIQTZ* wma;
724 HRESULT hr;
725 DWORD ret = MCI_INTEGER_RETURNED;
726
727 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
728
729 if(!lpParms)
730 return MCIERR_NULL_PARAMETER_BLOCK;
731
732 wma = MCIQTZ_mciGetOpenDev(wDevID);
733 if (!wma)
734 return MCIERR_INVALID_DEVICE_ID;
735
736 if (!(dwFlags & MCI_STATUS_ITEM)) {
737 WARN("No status item specified\n");
738 return MCIERR_UNRECOGNIZED_COMMAND;
739 }
740
741 switch (lpParms->dwItem) {
742 case MCI_STATUS_LENGTH: {
743 LONGLONG duration = -1;
744 GUID format;
745 switch (wma->time_format) {
746 case MCI_FORMAT_MILLISECONDS: format = TIME_FORMAT_MEDIA_TIME; break;
747 case MCI_FORMAT_FRAMES: format = TIME_FORMAT_FRAME; break;
748 default: ERR("Unhandled format %x\n", wma->time_format); break;
749 }
750 hr = IMediaSeeking_SetTimeFormat(wma->seek, &format);
751 if (FAILED(hr)) {
752 FIXME("Cannot set time format (hr = %x)\n", hr);
753 lpParms->dwReturn = 0;
754 break;
755 }
756 hr = IMediaSeeking_GetDuration(wma->seek, &duration);
757 if (FAILED(hr) || duration < 0) {
758 FIXME("Cannot read duration (hr = %x)\n", hr);
759 lpParms->dwReturn = 0;
760 } else if (wma->time_format != MCI_FORMAT_MILLISECONDS)
761 lpParms->dwReturn = duration;
762 else
763 lpParms->dwReturn = duration / 10000;
764 break;
765 }
766 case MCI_STATUS_POSITION: {
767 REFERENCE_TIME curpos;
768
769 hr = IMediaSeeking_GetCurrentPosition(wma->seek, &curpos);
770 if (FAILED(hr)) {
771 FIXME("Cannot get position (hr = %x)\n", hr);
772 return MCIERR_INTERNAL;
773 }
774 lpParms->dwReturn = curpos / 10000;
775 break;
776 }
777 case MCI_STATUS_NUMBER_OF_TRACKS:
778 FIXME("MCI_STATUS_NUMBER_OF_TRACKS not implemented yet\n");
779 return MCIERR_UNRECOGNIZED_COMMAND;
780 case MCI_STATUS_MODE: {
781 LONG state = State_Stopped;
782 IMediaControl_GetState(wma->pmctrl, -1, &state);
783 if (state == State_Stopped)
784 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_MODE_STOP, MCI_MODE_STOP);
785 else if (state == State_Running) {
786 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_MODE_PLAY, MCI_MODE_PLAY);
787 if (!wma->thread || WaitForSingleObject(wma->thread, 0) == WAIT_OBJECT_0)
788 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_MODE_STOP, MCI_MODE_STOP);
789 } else if (state == State_Paused)
790 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_MODE_PAUSE, MCI_MODE_PAUSE);
791 ret = MCI_RESOURCE_RETURNED;
792 break;
793 }
794 case MCI_STATUS_MEDIA_PRESENT:
795 FIXME("MCI_STATUS_MEDIA_PRESENT not implemented yet\n");
796 return MCIERR_UNRECOGNIZED_COMMAND;
797 case MCI_STATUS_TIME_FORMAT:
798 lpParms->dwReturn = MAKEMCIRESOURCE(wma->time_format,
799 MCI_FORMAT_RETURN_BASE + wma->time_format);
800 ret = MCI_RESOURCE_RETURNED;
801 break;
802 case MCI_STATUS_READY:
803 FIXME("MCI_STATUS_READY not implemented yet\n");
804 return MCIERR_UNRECOGNIZED_COMMAND;
805 case MCI_STATUS_CURRENT_TRACK:
806 FIXME("MCI_STATUS_CURRENT_TRACK not implemented yet\n");
807 return MCIERR_UNRECOGNIZED_COMMAND;
808 default:
809 FIXME("Unknown command %08X\n", lpParms->dwItem);
810 return MCIERR_UNRECOGNIZED_COMMAND;
811 }
812
813 if (dwFlags & MCI_NOTIFY)
814 MCIQTZ_mciNotify(lpParms->dwCallback, wma, MCI_NOTIFY_SUCCESSFUL);
815
816 return ret;
817 }
818
819 /***************************************************************************
820 * MCIQTZ_mciWhere [internal]
821 */
822 static DWORD MCIQTZ_mciWhere(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
823 {
824 WINE_MCIQTZ* wma;
825 HRESULT hr;
826 HWND hWnd;
827 RECT rc;
828 DWORD ret = MCIERR_UNRECOGNIZED_COMMAND;
829
830 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
831
832 if(!lpParms)
833 return MCIERR_NULL_PARAMETER_BLOCK;
834
835 wma = MCIQTZ_mciGetOpenDev(wDevID);
836 if (!wma)
837 return MCIERR_INVALID_DEVICE_ID;
838
839 hr = IVideoWindow_get_Owner(wma->vidwin, (OAHWND*)&hWnd);
840 if (FAILED(hr)) {
841 TRACE("No video stream, returning no window error\n");
842 return MCIERR_NO_WINDOW;
843 }
844
845 if (dwFlags & MCI_DGV_WHERE_SOURCE) {
846 if (dwFlags & MCI_DGV_WHERE_MAX)
847 FIXME("MCI_DGV_WHERE_SOURCE_MAX stub\n");
848 IBasicVideo_GetSourcePosition(wma->vidbasic, &rc.left, &rc.top, &rc.right, &rc.bottom);
849 TRACE("MCI_DGV_WHERE_SOURCE %s\n", wine_dbgstr_rect(&rc));
850 }
851 if (dwFlags & MCI_DGV_WHERE_DESTINATION) {
852 if (dwFlags & MCI_DGV_WHERE_MAX)
853 FIXME("MCI_DGV_WHERE_DESTINATION_MAX stub\n");
854 IBasicVideo_GetDestinationPosition(wma->vidbasic, &rc.left, &rc.top, &rc.right, &rc.bottom);
855 TRACE("MCI_DGV_WHERE_DESTINATION %s\n", wine_dbgstr_rect(&rc));
856 }
857 if (dwFlags & MCI_DGV_WHERE_FRAME) {
858 if (dwFlags & MCI_DGV_WHERE_MAX)
859 FIXME("MCI_DGV_WHERE_FRAME_MAX not supported yet\n");
860 else
861 FIXME("MCI_DGV_WHERE_FRAME not supported yet\n");
862 goto out;
863 }
864 if (dwFlags & MCI_DGV_WHERE_VIDEO) {
865 if (dwFlags & MCI_DGV_WHERE_MAX)
866 FIXME("MCI_DGV_WHERE_VIDEO_MAX not supported yet\n");
867 else
868 FIXME("MCI_DGV_WHERE_VIDEO not supported yet\n");
869 goto out;
870 }
871 if (dwFlags & MCI_DGV_WHERE_WINDOW) {
872 if (dwFlags & MCI_DGV_WHERE_MAX) {
873 GetWindowRect(GetDesktopWindow(), &rc);
874 rc.right -= rc.left;
875 rc.bottom -= rc.top;
876 TRACE("MCI_DGV_WHERE_WINDOW_MAX %s\n", wine_dbgstr_rect(&rc));
877 } else {
878 IVideoWindow_GetWindowPosition(wma->vidwin, &rc.left, &rc.top, &rc.right, &rc.bottom);
879 TRACE("MCI_DGV_WHERE_WINDOW %s\n", wine_dbgstr_rect(&rc));
880 }
881 }
882 ret = 0;
883 out:
884 lpParms->rc = rc;
885 return ret;
886 }
887
888 /***************************************************************************
889 * MCIQTZ_mciWindow [internal]
890 */
891 static DWORD MCIQTZ_mciWindow(UINT wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSW lpParms)
892 {
893 WINE_MCIQTZ *wma = MCIQTZ_mciGetOpenDev(wDevID);
894
895 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
896
897 if(!lpParms)
898 return MCIERR_NULL_PARAMETER_BLOCK;
899
900 if (!wma)
901 return MCIERR_INVALID_DEVICE_ID;
902 if (dwFlags & MCI_TEST)
903 return 0;
904
905 if (dwFlags & MCI_DGV_WINDOW_HWND && (IsWindow(lpParms->hWnd) || !lpParms->hWnd)) {
906 LONG visible = OATRUE;
907 LONG style = 0;
908 TRACE("Setting hWnd to %p\n", lpParms->hWnd);
909 IVideoWindow_get_Visible(wma->vidwin, &visible);
910 IVideoWindow_put_Visible(wma->vidwin, OAFALSE);
911 IVideoWindow_get_WindowStyle(wma->vidwin, &style);
912 style &= ~WS_CHILD;
913 if (lpParms->hWnd)
914 IVideoWindow_put_WindowStyle(wma->vidwin, style|WS_CHILD);
915 else
916 IVideoWindow_put_WindowStyle(wma->vidwin, style);
917 IVideoWindow_put_Owner(wma->vidwin, (OAHWND)lpParms->hWnd);
918 IVideoWindow_put_MessageDrain(wma->vidwin, (OAHWND)lpParms->hWnd);
919 IVideoWindow_put_Visible(wma->vidwin, visible);
920 wma->parent = lpParms->hWnd;
921 }
922 if (dwFlags & MCI_DGV_WINDOW_STATE) {
923 TRACE("Setting nCmdShow to %d\n", lpParms->nCmdShow);
924 IVideoWindow_put_WindowState(wma->vidwin, lpParms->nCmdShow);
925 }
926 if (dwFlags & MCI_DGV_WINDOW_TEXT) {
927 TRACE("Setting caption to %s\n", debugstr_w(lpParms->lpstrText));
928 IVideoWindow_put_Caption(wma->vidwin, lpParms->lpstrText);
929 }
930 return 0;
931 }
932
933 /***************************************************************************
934 * MCIQTZ_mciPut [internal]
935 */
936 static DWORD MCIQTZ_mciPut(UINT wDevID, DWORD dwFlags, MCI_GENERIC_PARMS *lpParms)
937 {
938 WINE_MCIQTZ *wma = MCIQTZ_mciGetOpenDev(wDevID);
939 MCI_DGV_RECT_PARMS *rectparms;
940 HRESULT hr;
941
942 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
943
944 if(!lpParms)
945 return MCIERR_NULL_PARAMETER_BLOCK;
946
947 if (!wma)
948 return MCIERR_INVALID_DEVICE_ID;
949
950 if (!(dwFlags & MCI_DGV_RECT)) {
951 FIXME("No support for non-RECT MCI_PUT\n");
952 return 1;
953 }
954
955 if (dwFlags & MCI_TEST)
956 return 0;
957
958 dwFlags &= ~MCI_DGV_RECT;
959 rectparms = (MCI_DGV_RECT_PARMS*)lpParms;
960
961 if (dwFlags & MCI_DGV_PUT_DESTINATION) {
962 hr = IVideoWindow_SetWindowPosition(wma->vidwin,
963 rectparms->rc.left, rectparms->rc.top,
964 rectparms->rc.right - rectparms->rc.left,
965 rectparms->rc.bottom - rectparms->rc.top);
966 if(FAILED(hr))
967 WARN("IVideoWindow_SetWindowPosition failed: 0x%x\n", hr);
968
969 dwFlags &= ~MCI_DGV_PUT_DESTINATION;
970 }
971
972 if (dwFlags & MCI_NOTIFY) {
973 MCIQTZ_mciNotify(lpParms->dwCallback, wma, MCI_NOTIFY_SUCCESSFUL);
974 dwFlags &= ~MCI_NOTIFY;
975 }
976
977 if (dwFlags)
978 FIXME("No support for some flags: 0x%x\n", dwFlags);
979
980 return 0;
981 }
982
983 /******************************************************************************
984 * MCIAVI_mciUpdate [internal]
985 */
986 static DWORD MCIQTZ_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
987 {
988 WINE_MCIQTZ *wma;
989 DWORD res = 0;
990
991 TRACE("%04x, %08x, %p\n", wDevID, dwFlags, lpParms);
992
993 if(!lpParms)
994 return MCIERR_NULL_PARAMETER_BLOCK;
995
996 wma = MCIQTZ_mciGetOpenDev(wDevID);
997 if (!wma)
998 return MCIERR_INVALID_DEVICE_ID;
999
1000 if (dwFlags & MCI_DGV_UPDATE_HDC) {
1001 LONG state, size;
1002 BYTE *data;
1003 BITMAPINFO *info;
1004 HRESULT hr;
1005 RECT src, dest;
1006 LONG visible = OATRUE;
1007
1008 res = MCIERR_INTERNAL;
1009 IMediaControl_GetState(wma->pmctrl, -1, &state);
1010 if (state == State_Running)
1011 return MCIERR_UNSUPPORTED_FUNCTION;
1012 /* If in stopped state, nothing has been drawn to screen
1013 * moving to pause, which is needed for the old dib renderer, will result
1014 * in a single frame drawn, so hide the window here */
1015 IVideoWindow_get_Visible(wma->vidwin, &visible);
1016 if (wma->parent)
1017 IVideoWindow_put_Visible(wma->vidwin, OAFALSE);
1018 /* FIXME: Should we check the original state and restore it? */
1019 IMediaControl_Pause(wma->pmctrl);
1020 IMediaControl_GetState(wma->pmctrl, -1, &state);
1021 if (FAILED(hr = IBasicVideo_GetCurrentImage(wma->vidbasic, &size, NULL))) {
1022 WARN("Could not get image size (hr = %x)\n", hr);
1023 goto out;
1024 }
1025 data = HeapAlloc(GetProcessHeap(), 0, size);
1026 info = (BITMAPINFO*)data;
1027 IBasicVideo_GetCurrentImage(wma->vidbasic, &size, (LONG*)data);
1028 data += info->bmiHeader.biSize;
1029
1030 IBasicVideo_GetSourcePosition(wma->vidbasic, &src.left, &src.top, &src.right, &src.bottom);
1031 IBasicVideo_GetDestinationPosition(wma->vidbasic, &dest.left, &dest.top, &dest.right, &dest.bottom);
1032 StretchDIBits(lpParms->hDC,
1033 dest.left, dest.top, dest.right + dest.left, dest.bottom + dest.top,
1034 src.left, src.top, src.right + src.left, src.bottom + src.top,
1035 data, info, DIB_RGB_COLORS, SRCCOPY);
1036 HeapFree(GetProcessHeap(), 0, data);
1037 res = 0;
1038 out:
1039 if (wma->parent)
1040 IVideoWindow_put_Visible(wma->vidwin, visible);
1041 }
1042 else if (dwFlags)
1043 FIXME("Unhandled flags %x\n", dwFlags);
1044 return res;
1045 }
1046
1047 /***************************************************************************
1048 * MCIQTZ_mciSetAudio [internal]
1049 */
1050 static DWORD MCIQTZ_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSW lpParms)
1051 {
1052 WINE_MCIQTZ *wma;
1053 DWORD ret = 0;
1054
1055 TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms);
1056
1057 if(!lpParms)
1058 return MCIERR_NULL_PARAMETER_BLOCK;
1059
1060 wma = MCIQTZ_mciGetOpenDev(wDevID);
1061 if (!wma)
1062 return MCIERR_INVALID_DEVICE_ID;
1063
1064 if (!(dwFlags & MCI_DGV_SETAUDIO_ITEM)) {
1065 FIXME("Unknown flags (%08x)\n", dwFlags);
1066 return 0;
1067 }
1068
1069 if (dwFlags & MCI_DGV_SETAUDIO_ITEM) {
1070 switch (lpParms->dwItem) {
1071 case MCI_DGV_SETAUDIO_VOLUME:
1072 if (dwFlags & MCI_DGV_SETAUDIO_VALUE) {
1073 long vol = -10000;
1074 HRESULT hr;
1075 if (lpParms->dwValue > 1000) {
1076 ret = MCIERR_OUTOFRANGE;
1077 break;
1078 }
1079 if (dwFlags & MCI_TEST)
1080 break;
1081 vol += (long)lpParms->dwValue * 10;
1082 hr = IBasicAudio_put_Volume(wma->audio, vol);
1083 if (FAILED(hr)) {
1084 WARN("Cannot set volume (hr = %x)\n", hr);
1085 ret = MCIERR_INTERNAL;
1086 }
1087 }
1088 break;
1089 default:
1090 FIXME("Unknown item %08x\n", lpParms->dwItem);
1091 break;
1092 }
1093 }
1094
1095 return ret;
1096 }
1097
1098 /*======================================================================*
1099 * MCI QTZ entry points *
1100 *======================================================================*/
1101
1102 /**************************************************************************
1103 * DriverProc (MCIQTZ.@)
1104 */
1105 LRESULT CALLBACK MCIQTZ_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
1106 LPARAM dwParam1, LPARAM dwParam2)
1107 {
1108 TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
1109 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1110
1111 switch (wMsg) {
1112 case DRV_LOAD: return 1;
1113 case DRV_FREE: return 1;
1114 case DRV_OPEN: return MCIQTZ_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
1115 case DRV_CLOSE: return MCIQTZ_drvClose(dwDevID);
1116 case DRV_ENABLE: return 1;
1117 case DRV_DISABLE: return 1;
1118 case DRV_QUERYCONFIGURE: return 1;
1119 case DRV_CONFIGURE: return MCIQTZ_drvConfigure(dwDevID);
1120 case DRV_INSTALL: return DRVCNF_RESTART;
1121 case DRV_REMOVE: return DRVCNF_RESTART;
1122 }
1123
1124 /* session instance */
1125 if (dwDevID == 0xFFFFFFFF)
1126 return 1;
1127
1128 switch (wMsg) {
1129 case MCI_OPEN_DRIVER: return MCIQTZ_mciOpen (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSW) dwParam2);
1130 case MCI_CLOSE_DRIVER: return MCIQTZ_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1131 case MCI_PLAY: return MCIQTZ_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
1132 case MCI_SEEK: return MCIQTZ_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
1133 case MCI_STOP: return MCIQTZ_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1134 case MCI_PAUSE: return MCIQTZ_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1135 case MCI_RESUME: return MCIQTZ_mciResume (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1136 case MCI_GETDEVCAPS: return MCIQTZ_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
1137 case MCI_SET: return MCIQTZ_mciSet (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS) dwParam2);
1138 case MCI_STATUS: return MCIQTZ_mciStatus (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSW) dwParam2);
1139 case MCI_WHERE: return MCIQTZ_mciWhere (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
1140 /* Digital Video specific */
1141 case MCI_SETAUDIO: return MCIQTZ_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
1142 case MCI_UPDATE:
1143 return MCIQTZ_mciUpdate(dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS)dwParam2);
1144 case MCI_WINDOW:
1145 return MCIQTZ_mciWindow(dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSW)dwParam2);
1146 case MCI_PUT:
1147 return MCIQTZ_mciPut(dwDevID, dwParam1, (MCI_GENERIC_PARMS*)dwParam2);
1148 case MCI_RECORD:
1149 case MCI_INFO:
1150 case MCI_LOAD:
1151 case MCI_SAVE:
1152 case MCI_FREEZE:
1153 case MCI_REALIZE:
1154 case MCI_UNFREEZE:
1155 case MCI_STEP:
1156 case MCI_COPY:
1157 case MCI_CUT:
1158 case MCI_DELETE:
1159 case MCI_PASTE:
1160 case MCI_CUE:
1161 /* Digital Video specific */
1162 case MCI_CAPTURE:
1163 case MCI_MONITOR:
1164 case MCI_RESERVE:
1165 case MCI_SIGNAL:
1166 case MCI_SETVIDEO:
1167 case MCI_QUALITY:
1168 case MCI_LIST:
1169 case MCI_UNDO:
1170 case MCI_CONFIGURE:
1171 case MCI_RESTORE:
1172 FIXME("Unimplemented command [%08X]\n", wMsg);
1173 break;
1174 case MCI_SPIN:
1175 case MCI_ESCAPE:
1176 WARN("Unsupported command [%08X]\n", wMsg);
1177 break;
1178 case MCI_OPEN:
1179 case MCI_CLOSE:
1180 FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1181 break;
1182 default:
1183 TRACE("Sending msg [%08X] to default driver proc\n", wMsg);
1184 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1185 }
1186
1187 return MCIERR_UNRECOGNIZED_COMMAND;
1188 }
Windows API implementation