projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[CMAKE]
[reactos.git] / dll / win32 / 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 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 modp->wType = MCI_DEVTYPE_DIGITAL_VIDEO;
89 wma->wDevID = modp->wDeviceID;
90 modp->wCustomCommandTable = wma->command_table = mciLoadCommandResource(MCIQTZ_hInstance, mciAviWStr, 0);
91 mciSetDriverData(wma->wDevID, (DWORD_PTR)wma);
92
93 return modp->wDeviceID;
94 }
95
96 /**************************************************************************
97 * MCIQTZ_drvClose [internal]
98 */
99 static DWORD MCIQTZ_drvClose(DWORD dwDevID)
100 {
101 WINE_MCIQTZ* wma;
102
103 TRACE("(%04x)\n", dwDevID);
104
105 wma = MCIQTZ_mciGetOpenDev(dwDevID);
106
107 if (wma) {
108 /* finish all outstanding things */
109 MCIQTZ_mciClose(dwDevID, MCI_WAIT, NULL);
110
111 mciFreeCommandResource(wma->command_table);
112 mciSetDriverData(dwDevID, 0);
113 HeapFree(GetProcessHeap(), 0, wma);
114 return 1;
115 }
116
117 return (dwDevID == 0xFFFFFFFF) ? 1 : 0;
118 }
119
120 /**************************************************************************
121 * MCIQTZ_drvConfigure [internal]
122 */
123 static DWORD MCIQTZ_drvConfigure(DWORD dwDevID)
124 {
125 WINE_MCIQTZ* wma;
126
127 TRACE("(%04x)\n", dwDevID);
128
129 wma = MCIQTZ_mciGetOpenDev(dwDevID);
130 if (!wma)
131 return 0;
132
133 MCIQTZ_mciStop(dwDevID, MCI_WAIT, NULL);
134
135 MessageBoxA(0, "Sample QTZ Wine Driver !", "MM-Wine Driver", MB_OK);
136
137 return 1;
138 }
139
140 /***************************************************************************
141 * MCIQTZ_mciOpen [internal]
142 */
143 static DWORD MCIQTZ_mciOpen(UINT wDevID, DWORD dwFlags,
144 LPMCI_DGV_OPEN_PARMSW lpOpenParms)
145 {
146 WINE_MCIQTZ* wma;
147 HRESULT hr;
148 IBasicVideo *vidbasic;
149 IVideoWindow *vidwin;
150
151 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpOpenParms);
152
153 if (!lpOpenParms)
154 return MCIERR_NULL_PARAMETER_BLOCK;
155
156 wma = MCIQTZ_mciGetOpenDev(wDevID);
157 if (!wma)
158 return MCIERR_INVALID_DEVICE_ID;
159
160 MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
161
162 hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
163 wma->uninit = SUCCEEDED(hr);
164
165 hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, &IID_IGraphBuilder, (LPVOID*)&wma->pgraph);
166 if (FAILED(hr)) {
167 TRACE("Cannot create filtergraph (hr = %x)\n", hr);
168 goto err;
169 }
170
171 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaControl, (LPVOID*)&wma->pmctrl);
172 if (FAILED(hr)) {
173 TRACE("Cannot get IMediaControl interface (hr = %x)\n", hr);
174 goto err;
175 }
176
177 if (!(dwFlags & MCI_OPEN_ELEMENT) || (dwFlags & MCI_OPEN_ELEMENT_ID)) {
178 TRACE("Wrong dwFlags %x\n", dwFlags);
179 goto err;
180 }
181
182 if (!lpOpenParms->lpstrElementName || !lpOpenParms->lpstrElementName[0]) {
183 TRACE("Invalid filename specified\n");
184 goto err;
185 }
186
187 TRACE("Open file %s\n", debugstr_w(lpOpenParms->lpstrElementName));
188
189 hr = IGraphBuilder_RenderFile(wma->pgraph, lpOpenParms->lpstrElementName, NULL);
190 if (FAILED(hr)) {
191 TRACE("Cannot render file (hr = %x)\n", hr);
192 goto err;
193 }
194
195 hr = IFilterGraph2_QueryInterface(wma->pgraph, &IID_IVideoWindow, (void**)&vidwin);
196 if (SUCCEEDED(hr))
197 hr = IFilterGraph2_QueryInterface(wma->pgraph, &IID_IBasicVideo, (void**)&vidbasic);
198 if (SUCCEEDED(hr)) {
199 DWORD style;
200 RECT rc = { 0, 0, 0, 0 };
201 IVideoWindow_put_AutoShow(vidwin, OAFALSE);
202 IVideoWindow_put_Visible(vidwin, OAFALSE);
203 style = 0;
204 if (dwFlags & MCI_DGV_OPEN_WS)
205 style |= lpOpenParms->dwStyle;
206 if (dwFlags & MCI_DGV_OPEN_PARENT) {
207 IVideoWindow_put_MessageDrain(vidwin, (OAHWND)lpOpenParms->hWndParent);
208 IVideoWindow_put_WindowState(vidwin, SW_HIDE);
209 IVideoWindow_put_WindowStyle(vidwin, WS_CHILD);
210 IVideoWindow_put_Owner(vidwin, (OAHWND)lpOpenParms->hWndParent);
211 wma->parent = (HWND)lpOpenParms->hWndParent;
212 }
213 else if (style)
214 IVideoWindow_put_WindowStyle(vidwin, style);
215 IBasicVideo_GetVideoSize(vidbasic, &rc.right, &rc.bottom);
216 IVideoWindow_SetWindowPosition(vidwin, rc.left, rc.top, rc.right, rc.bottom);
217 IBasicVideo_Release(vidbasic);
218 }
219 if (vidwin)
220 IVideoWindow_Release(vidwin);
221
222 wma->opened = TRUE;
223
224 if (dwFlags & MCI_NOTIFY)
225 mciDriverNotify(HWND_32(LOWORD(lpOpenParms->dwCallback)), wDevID, MCI_NOTIFY_SUCCESSFUL);
226
227 return 0;
228
229 err:
230 if (wma->pgraph)
231 IGraphBuilder_Release(wma->pgraph);
232 wma->pgraph = NULL;
233 if (wma->pmctrl)
234 IMediaControl_Release(wma->pmctrl);
235 wma->pmctrl = NULL;
236
237 if (wma->uninit)
238 CoUninitialize();
239
240 return MCIERR_INTERNAL;
241 }
242
243 /***************************************************************************
244 * MCIQTZ_mciClose [internal]
245 */
246 static DWORD MCIQTZ_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
247 {
248 WINE_MCIQTZ* wma;
249
250 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
251
252 wma = MCIQTZ_mciGetOpenDev(wDevID);
253 if (!wma)
254 return MCIERR_INVALID_DEVICE_ID;
255
256 MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
257
258 if (wma->opened) {
259 IGraphBuilder_Release(wma->pgraph);
260 IMediaControl_Release(wma->pmctrl);
261 if (wma->uninit)
262 CoUninitialize();
263 wma->opened = FALSE;
264 }
265
266 return 0;
267 }
268
269 /***************************************************************************
270 * MCIQTZ_mciPlay [internal]
271 */
272 static DWORD MCIQTZ_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
273 {
274 WINE_MCIQTZ* wma;
275 HRESULT hr;
276
277 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
278
279 if (!lpParms)
280 return MCIERR_NULL_PARAMETER_BLOCK;
281
282 wma = MCIQTZ_mciGetOpenDev(wDevID);
283 if (!wma)
284 return MCIERR_INVALID_DEVICE_ID;
285
286 hr = IMediaControl_Run(wma->pmctrl);
287 if (FAILED(hr)) {
288 TRACE("Cannot run filtergraph (hr = %x)\n", hr);
289 return MCIERR_INTERNAL;
290 }
291
292 if (!wma->parent) {
293 IVideoWindow *vidwin;
294 IFilterGraph2_QueryInterface(wma->pgraph, &IID_IVideoWindow, (void**)&vidwin);
295 if (vidwin) {
296 IVideoWindow_put_Visible(vidwin, OATRUE);
297 IVideoWindow_Release(vidwin);
298 }
299 }
300
301 return 0;
302 }
303
304 /***************************************************************************
305 * MCIQTZ_mciSeek [internal]
306 */
307 static DWORD MCIQTZ_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
308 {
309 WINE_MCIQTZ* wma;
310 HRESULT hr;
311 IMediaPosition* pmpos;
312 LONGLONG newpos;
313
314 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
315
316 if (!lpParms)
317 return MCIERR_NULL_PARAMETER_BLOCK;
318
319 wma = MCIQTZ_mciGetOpenDev(wDevID);
320 if (!wma)
321 return MCIERR_INVALID_DEVICE_ID;
322
323 MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
324
325 if (dwFlags & MCI_SEEK_TO_START) {
326 newpos = 0;
327 } else if (dwFlags & MCI_SEEK_TO_END) {
328 FIXME("MCI_SEEK_TO_END not implemented yet\n");
329 return MCIERR_INTERNAL;
330 } else if (dwFlags & MCI_TO) {
331 FIXME("MCI_TO not implemented yet\n");
332 return MCIERR_INTERNAL;
333 } else {
334 WARN("dwFlag doesn't tell where to seek to...\n");
335 return MCIERR_MISSING_PARAMETER;
336 }
337
338 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaPosition, (LPVOID*)&pmpos);
339 if (FAILED(hr)) {
340 FIXME("Cannot get IMediaPostion interface (hr = %x)\n", hr);
341 return MCIERR_INTERNAL;
342 }
343
344 hr = IMediaPosition_put_CurrentPosition(pmpos, newpos);
345 if (FAILED(hr)) {
346 FIXME("Cannot set position (hr = %x)\n", hr);
347 IMediaPosition_Release(pmpos);
348 return MCIERR_INTERNAL;
349 }
350
351 IMediaPosition_Release(pmpos);
352
353 if (dwFlags & MCI_NOTIFY)
354 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)), wDevID, MCI_NOTIFY_SUCCESSFUL);
355
356 return 0;
357 }
358
359 /***************************************************************************
360 * MCIQTZ_mciStop [internal]
361 */
362 static DWORD MCIQTZ_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
363 {
364 WINE_MCIQTZ* wma;
365 HRESULT hr;
366
367 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
368
369 wma = MCIQTZ_mciGetOpenDev(wDevID);
370 if (!wma)
371 return MCIERR_INVALID_DEVICE_ID;
372
373 if (!wma->opened)
374 return 0;
375
376 hr = IMediaControl_Stop(wma->pmctrl);
377 if (FAILED(hr)) {
378 TRACE("Cannot stop filtergraph (hr = %x)\n", hr);
379 return MCIERR_INTERNAL;
380 }
381
382 if (!wma->parent) {
383 IVideoWindow *vidwin;
384 IFilterGraph2_QueryInterface(wma->pgraph, &IID_IVideoWindow, (void**)&vidwin);
385 if (vidwin) {
386 IVideoWindow_put_Visible(vidwin, OAFALSE);
387 IVideoWindow_Release(vidwin);
388 }
389 }
390
391 return 0;
392 }
393
394 /***************************************************************************
395 * MCIQTZ_mciPause [internal]
396 */
397 static DWORD MCIQTZ_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
398 {
399 WINE_MCIQTZ* wma;
400 HRESULT hr;
401
402 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
403
404 wma = MCIQTZ_mciGetOpenDev(wDevID);
405 if (!wma)
406 return MCIERR_INVALID_DEVICE_ID;
407
408 hr = IMediaControl_Pause(wma->pmctrl);
409 if (FAILED(hr)) {
410 TRACE("Cannot pause filtergraph (hr = %x)\n", hr);
411 return MCIERR_INTERNAL;
412 }
413
414 return 0;
415 }
416
417 /***************************************************************************
418 * MCIQTZ_mciGetDevCaps [internal]
419 */
420 static DWORD MCIQTZ_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms)
421 {
422 WINE_MCIQTZ* wma;
423
424 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
425
426 if (!lpParms)
427 return MCIERR_NULL_PARAMETER_BLOCK;
428
429 wma = MCIQTZ_mciGetOpenDev(wDevID);
430 if (!wma)
431 return MCIERR_INVALID_DEVICE_ID;
432
433 if (!(dwFlags & MCI_GETDEVCAPS_ITEM))
434 return MCIERR_MISSING_PARAMETER;
435
436 switch (lpParms->dwItem) {
437 case MCI_GETDEVCAPS_CAN_RECORD:
438 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
439 TRACE("MCI_GETDEVCAPS_CAN_RECORD = %08x\n", lpParms->dwReturn);
440 break;
441 case MCI_GETDEVCAPS_HAS_AUDIO:
442 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
443 TRACE("MCI_GETDEVCAPS_HAS_AUDIO = %08x\n", lpParms->dwReturn);
444 break;
445 case MCI_GETDEVCAPS_HAS_VIDEO:
446 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
447 TRACE("MCI_GETDEVCAPS_HAS_VIDEO = %08x\n", lpParms->dwReturn);
448 break;
449 case MCI_GETDEVCAPS_DEVICE_TYPE:
450 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_DIGITAL_VIDEO, MCI_DEVTYPE_DIGITAL_VIDEO);
451 TRACE("MCI_GETDEVCAPS_DEVICE_TYPE = %08x\n", lpParms->dwReturn);
452 break;
453 case MCI_GETDEVCAPS_USES_FILES:
454 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
455 TRACE("MCI_GETDEVCAPS_USES_FILES = %08x\n", lpParms->dwReturn);
456 break;
457 case MCI_GETDEVCAPS_COMPOUND_DEVICE:
458 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
459 TRACE("MCI_GETDEVCAPS_COMPOUND_DEVICE = %08x\n", lpParms->dwReturn);
460 break;
461 case MCI_GETDEVCAPS_CAN_EJECT:
462 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
463 TRACE("MCI_GETDEVCAPS_EJECT = %08x\n", lpParms->dwReturn);
464 break;
465 case MCI_GETDEVCAPS_CAN_PLAY:
466 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
467 TRACE("MCI_GETDEVCAPS_CAN_PLAY = %08x\n", lpParms->dwReturn);
468 break;
469 case MCI_GETDEVCAPS_CAN_SAVE:
470 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
471 TRACE("MCI_GETDEVCAPS_CAN_SAVE = %08x\n", lpParms->dwReturn);
472 break;
473 case MCI_DGV_GETDEVCAPS_CAN_REVERSE:
474 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
475 TRACE("MCI_DGV_GETDEVCAPS_CAN_REVERSE = %08x\n", lpParms->dwReturn);
476 break;
477 case MCI_DGV_GETDEVCAPS_CAN_STRETCH:
478 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
479 TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH = %08x\n", lpParms->dwReturn);
480 break;
481 case MCI_DGV_GETDEVCAPS_CAN_LOCK:
482 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
483 TRACE("MCI_DGV_GETDEVCAPS_CAN_LOCK = %08x\n", lpParms->dwReturn);
484 break;
485 case MCI_DGV_GETDEVCAPS_CAN_FREEZE:
486 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
487 TRACE("MCI_DGV_GETDEVCAPS_CAN_FREEZE = %08x\n", lpParms->dwReturn);
488 break;
489 case MCI_DGV_GETDEVCAPS_CAN_STR_IN:
490 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
491 TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH_INPUT = %08x\n", lpParms->dwReturn);
492 break;
493 case MCI_DGV_GETDEVCAPS_HAS_STILL:
494 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
495 TRACE("MCI_DGV_GETDEVCAPS_HAS_STILL = %08x\n", lpParms->dwReturn);
496 break;
497 case MCI_DGV_GETDEVCAPS_CAN_TEST:
498 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
499 TRACE("MCI_DGV_GETDEVCAPS_CAN_TEST = %08x\n", lpParms->dwReturn);
500 break;
501 case MCI_DGV_GETDEVCAPS_MAX_WINDOWS:
502 lpParms->dwReturn = 1;
503 TRACE("MCI_DGV_GETDEVCAPS_MAX_WINDOWS = %u\n", lpParms->dwReturn);
504 return 0;
505 default:
506 WARN("Unknown capability %08x\n", lpParms->dwItem);
507 /* Fall through */
508 case MCI_DGV_GETDEVCAPS_MAXIMUM_RATE: /* unknown to w2k */
509 case MCI_DGV_GETDEVCAPS_MINIMUM_RATE: /* unknown to w2k */
510 return MCIERR_UNSUPPORTED_FUNCTION;
511 }
512
513 return MCI_RESOURCE_RETURNED;
514 }
515
516 /***************************************************************************
517 * MCIQTZ_mciSet [internal]
518 */
519 static DWORD MCIQTZ_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms)
520 {
521 WINE_MCIQTZ* wma;
522
523 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
524
525 if (!lpParms)
526 return MCIERR_NULL_PARAMETER_BLOCK;
527
528 wma = MCIQTZ_mciGetOpenDev(wDevID);
529 if (!wma)
530 return MCIERR_INVALID_DEVICE_ID;
531
532 if (dwFlags & MCI_SET_TIME_FORMAT) {
533 switch (lpParms->dwTimeFormat) {
534 case MCI_FORMAT_MILLISECONDS:
535 TRACE("MCI_SET_TIME_FORMAT = MCI_FORMAT_MILLISECONDS\n");
536 wma->time_format = MCI_FORMAT_MILLISECONDS;
537 break;
538 case MCI_FORMAT_FRAMES:
539 TRACE("MCI_SET_TIME_FORMAT = MCI_FORMAT_FRAMES\n");
540 wma->time_format = MCI_FORMAT_FRAMES;
541 break;
542 default:
543 WARN("Bad time format %u\n", lpParms->dwTimeFormat);
544 return MCIERR_BAD_TIME_FORMAT;
545 }
546 }
547
548 if (dwFlags & MCI_SET_DOOR_OPEN)
549 FIXME("MCI_SET_DOOR_OPEN not implemented yet\n");
550 if (dwFlags & MCI_SET_DOOR_CLOSED)
551 FIXME("MCI_SET_DOOR_CLOSED not implemented yet\n");
552 if (dwFlags & MCI_SET_AUDIO)
553 FIXME("MCI_SET_AUDIO not implemented yet\n");
554 if (dwFlags & MCI_SET_VIDEO)
555 FIXME("MCI_SET_VIDEO not implemented yet\n");
556 if (dwFlags & MCI_SET_ON)
557 FIXME("MCI_SET_ON not implemented yet\n");
558 if (dwFlags & MCI_SET_OFF)
559 FIXME("MCI_SET_OFF not implemented yet\n");
560 if (dwFlags & MCI_SET_AUDIO_LEFT)
561 FIXME("MCI_SET_AUDIO_LEFT not implemented yet\n");
562 if (dwFlags & MCI_SET_AUDIO_RIGHT)
563 FIXME("MCI_SET_AUDIO_RIGHT not implemented yet\n");
564
565 if (dwFlags & ~0x7f03 /* All MCI_SET flags mask */)
566 ERR("Unknown flags %08x\n", dwFlags & ~0x7f03);
567
568 return 0;
569 }
570
571 /***************************************************************************
572 * MCIQTZ_mciStatus [internal]
573 */
574 static DWORD MCIQTZ_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpParms)
575 {
576 WINE_MCIQTZ* wma;
577 HRESULT hr;
578
579 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
580
581 if (!lpParms)
582 return MCIERR_NULL_PARAMETER_BLOCK;
583
584 wma = MCIQTZ_mciGetOpenDev(wDevID);
585 if (!wma)
586 return MCIERR_INVALID_DEVICE_ID;
587
588 if (!(dwFlags & MCI_STATUS_ITEM)) {
589 WARN("No status item specified\n");
590 return MCIERR_UNRECOGNIZED_COMMAND;
591 }
592
593 switch (lpParms->dwItem) {
594 case MCI_STATUS_LENGTH: {
595 IMediaSeeking *seek;
596 LONGLONG duration = -1;
597 GUID format;
598 switch (wma->time_format) {
599 case MCI_FORMAT_MILLISECONDS: format = TIME_FORMAT_MEDIA_TIME; break;
600 case MCI_FORMAT_FRAMES: format = TIME_FORMAT_FRAME; break;
601 default: ERR("Unhandled format %x\n", wma->time_format); break;
602 }
603 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaSeeking, (void**)&seek);
604 if (FAILED(hr)) {
605 FIXME("Cannot get IMediaPostion interface (hr = %x)\n", hr);
606 return MCIERR_INTERNAL;
607 }
608 hr = IMediaSeeking_SetTimeFormat(seek, &format);
609 if (FAILED(hr)) {
610 IMediaSeeking_Release(seek);
611 FIXME("Cannot set time format (hr = %x)\n", hr);
612 lpParms->dwReturn = 0;
613 break;
614 }
615 hr = IMediaSeeking_GetDuration(seek, &duration);
616 IMediaSeeking_Release(seek);
617 if (FAILED(hr) || duration < 0) {
618 FIXME("Cannot read duration (hr = %x)\n", hr);
619 lpParms->dwReturn = 0;
620 } else if (wma->time_format != MCI_FORMAT_MILLISECONDS)
621 lpParms->dwReturn = duration;
622 else
623 lpParms->dwReturn = duration / 10000;
624 break;
625 }
626 case MCI_STATUS_POSITION: {
627 IMediaPosition* pmpos;
628 REFTIME curpos;
629
630 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaPosition, (LPVOID*)&pmpos);
631 if (FAILED(hr)) {
632 FIXME("Cannot get IMediaPostion interface (hr = %x)\n", hr);
633 return MCIERR_INTERNAL;
634 }
635
636 hr = IMediaPosition_get_CurrentPosition(pmpos, &curpos);
637 if (FAILED(hr)) {
638 FIXME("Cannot get position (hr = %x)\n", hr);
639 IMediaPosition_Release(pmpos);
640 return MCIERR_INTERNAL;
641 }
642
643 IMediaPosition_Release(pmpos);
644 lpParms->dwReturn = curpos / 10000;
645
646 break;
647 }
648 case MCI_STATUS_NUMBER_OF_TRACKS:
649 FIXME("MCI_STATUS_NUMBER_OF_TRACKS not implemented yet\n");
650 return MCIERR_UNRECOGNIZED_COMMAND;
651 case MCI_STATUS_MODE:
652 FIXME("MCI_STATUS_MODE not implemented yet\n");
653 return MCIERR_UNRECOGNIZED_COMMAND;
654 case MCI_STATUS_MEDIA_PRESENT:
655 FIXME("MCI_STATUS_MEDIA_PRESENT not implemented yet\n");
656 return MCIERR_UNRECOGNIZED_COMMAND;
657 case MCI_STATUS_TIME_FORMAT:
658 lpParms->dwReturn = wma->time_format;
659 break;
660 case MCI_STATUS_READY:
661 FIXME("MCI_STATUS_READY not implemented yet\n");
662 return MCIERR_UNRECOGNIZED_COMMAND;
663 case MCI_STATUS_CURRENT_TRACK:
664 FIXME("MCI_STATUS_CURRENT_TRACK not implemented yet\n");
665 return MCIERR_UNRECOGNIZED_COMMAND;
666 default:
667 FIXME("Unknown command %08X\n", lpParms->dwItem);
668 return MCIERR_UNRECOGNIZED_COMMAND;
669 }
670
671 if (dwFlags & MCI_NOTIFY)
672 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)), wDevID, MCI_NOTIFY_SUCCESSFUL);
673
674 return 0;
675 }
676
677 /***************************************************************************
678 * MCIQTZ_mciWhere [internal]
679 */
680 static DWORD MCIQTZ_mciWhere(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
681 {
682 WINE_MCIQTZ* wma;
683 IVideoWindow* pVideoWindow;
684 IBasicVideo *pBasicVideo;
685 HRESULT hr;
686 HWND hWnd;
687 RECT rc;
688 DWORD ret = MCIERR_UNRECOGNIZED_COMMAND;
689
690 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
691
692 if (!lpParms)
693 return MCIERR_NULL_PARAMETER_BLOCK;
694
695 wma = MCIQTZ_mciGetOpenDev(wDevID);
696 if (!wma)
697 return MCIERR_INVALID_DEVICE_ID;
698
699 /* Find if there is a video stream and get the display window */
700 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
701 if (FAILED(hr)) {
702 ERR("Cannot get IVideoWindow interface (hr = %x)\n", hr);
703 return MCIERR_INTERNAL;
704 }
705
706 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
707 if (FAILED(hr)) {
708 ERR("Cannot get IBasicVideo interface (hr = %x)\n", hr);
709 IUnknown_Release(pVideoWindow);
710 return MCIERR_INTERNAL;
711 }
712
713 hr = IVideoWindow_get_Owner(pVideoWindow, (OAHWND*)&hWnd);
714 if (FAILED(hr)) {
715 TRACE("No video stream, returning no window error\n");
716 IUnknown_Release(pVideoWindow);
717 return MCIERR_NO_WINDOW;
718 }
719
720 if (dwFlags & MCI_DGV_WHERE_SOURCE) {
721 if (dwFlags & MCI_DGV_WHERE_MAX)
722 FIXME("MCI_DGV_WHERE_SOURCE_MAX stub %s\n", wine_dbgstr_rect(&rc));
723 IBasicVideo_get_SourceLeft(pBasicVideo, &rc.left);
724 IBasicVideo_get_SourceTop(pBasicVideo, &rc.top);
725 IBasicVideo_get_SourceWidth(pBasicVideo, &rc.right);
726 IBasicVideo_get_SourceHeight(pBasicVideo, &rc.bottom);
727 /* Undo conversion done below */
728 rc.right += rc.left;
729 rc.bottom += rc.top;
730 TRACE("MCI_DGV_WHERE_SOURCE %s\n", wine_dbgstr_rect(&rc));
731 }
732 if (dwFlags & MCI_DGV_WHERE_DESTINATION) {
733 if (dwFlags & MCI_DGV_WHERE_MAX) {
734 GetClientRect(hWnd, &rc);
735 TRACE("MCI_DGV_WHERE_DESTINATION_MAX %s\n", wine_dbgstr_rect(&rc));
736 } else {
737 FIXME("MCI_DGV_WHERE_DESTINATION not supported yet\n");
738 goto out;
739 }
740 }
741 if (dwFlags & MCI_DGV_WHERE_FRAME) {
742 if (dwFlags & MCI_DGV_WHERE_MAX)
743 FIXME("MCI_DGV_WHERE_FRAME_MAX not supported yet\n");
744 else
745 FIXME("MCI_DGV_WHERE_FRAME not supported yet\n");
746 goto out;
747 }
748 if (dwFlags & MCI_DGV_WHERE_VIDEO) {
749 if (dwFlags & MCI_DGV_WHERE_MAX)
750 FIXME("MCI_DGV_WHERE_VIDEO_MAX not supported yet\n");
751 else
752 FIXME("MCI_DGV_WHERE_VIDEO not supported yet\n");
753 goto out;
754 }
755 if (dwFlags & MCI_DGV_WHERE_WINDOW) {
756 if (dwFlags & MCI_DGV_WHERE_MAX) {
757 GetWindowRect(GetDesktopWindow(), &rc);
758 TRACE("MCI_DGV_WHERE_WINDOW_MAX %s\n", wine_dbgstr_rect(&rc));
759 } else {
760 GetWindowRect(hWnd, &rc);
761 TRACE("MCI_DGV_WHERE_WINDOW %s\n", wine_dbgstr_rect(&rc));
762 }
763 }
764 ret = 0;
765
766 out:
767 /* In MCI, RECT structure is used differently: rc.right = width & rc.bottom = height
768 * So convert the normal RECT into a MCI RECT before returning */
769 IVideoWindow_Release(pVideoWindow);
770 IBasicVideo_Release(pBasicVideo);
771 lpParms->rc.left = rc.left;
772 lpParms->rc.top = rc.top;
773 lpParms->rc.right = rc.right - rc.left;
774 lpParms->rc.bottom = rc.bottom - rc.top;
775
776 return ret;
777 }
778
779 /******************************************************************************
780 * MCIAVI_mciUpdate [internal]
781 */
782 static DWORD MCIQTZ_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
783 {
784 WINE_MCIQTZ *wma;
785 DWORD res = 0;
786
787 TRACE("%04x, %08x, %p\n", wDevID, dwFlags, lpParms);
788
789 if (!lpParms)
790 return MCIERR_NULL_PARAMETER_BLOCK;
791
792 wma = MCIQTZ_mciGetOpenDev(wDevID);
793 if (!wma)
794 return MCIERR_INVALID_DEVICE_ID;
795
796 if (dwFlags & MCI_DGV_UPDATE_HDC) {
797 IBasicVideo *vidbasic;
798 IVideoWindow *vidwin;
799 res = MCIERR_INTERNAL;
800 IFilterGraph2_QueryInterface(wma->pgraph, &IID_IVideoWindow, (void**)&vidwin);
801 IFilterGraph2_QueryInterface(wma->pgraph, &IID_IBasicVideo, (void**)&vidbasic);
802 if (vidbasic && vidwin) {
803 LONG state, size;
804 BYTE *data;
805 BITMAPINFO *info;
806 HRESULT hr;
807 RECT src, dest;
808
809 /* If in stopped state, nothing has been drawn to screen
810 * moving to pause, which is needed for the old dib renderer, will result
811 * in a single frame drawn, so hide the window here */
812 IVideoWindow_put_Visible(vidwin, OAFALSE);
813 /* FIXME: Should we check the original state and restore it? */
814 IMediaControl_Pause(wma->pmctrl);
815 IMediaControl_GetState(wma->pmctrl, -1, &state);
816 if (FAILED(hr = IBasicVideo_GetCurrentImage(vidbasic, &size, NULL))) {
817 WARN("Could not get image size (hr = %x)\n", hr);
818 goto out;
819 }
820 data = HeapAlloc(GetProcessHeap(), 0, size);
821 info = (BITMAPINFO*)data;
822 IBasicVideo_GetCurrentImage(vidbasic, &size, (LONG*)data);
823 data += info->bmiHeader.biSize;
824
825 IBasicVideo_GetSourcePosition(vidbasic, &src.left, &src.top, &src.right, &src.bottom);
826 IBasicVideo_GetDestinationPosition(vidbasic, &dest.left, &dest.top, &dest.right, &dest.bottom);
827 StretchDIBits(lpParms->hDC,
828 dest.left, dest.top, dest.right + dest.left, dest.bottom + dest.top,
829 src.left, src.top, src.right + src.left, src.bottom + src.top,
830 data, info, DIB_RGB_COLORS, SRCCOPY);
831 HeapFree(GetProcessHeap(), 0, data);
832 }
833 res = 0;
834 out:
835 if (vidbasic)
836 IBasicVideo_Release(vidbasic);
837 if (vidwin) {
838 if (wma->parent)
839 IVideoWindow_put_Visible(vidwin, OATRUE);
840 IVideoWindow_Release(vidwin);
841 }
842 }
843 else if (dwFlags)
844 FIXME("Unhandled flags %x\n", dwFlags);
845 return res;
846 }
847
848 /***************************************************************************
849 * MCIQTZ_mciSetAudio [internal]
850 */
851 static DWORD MCIQTZ_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSW lpParms)
852 {
853 WINE_MCIQTZ *wma;
854
855 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
856
857 if (!lpParms)
858 return MCIERR_NULL_PARAMETER_BLOCK;
859
860 wma = MCIQTZ_mciGetOpenDev(wDevID);
861 if (!wma)
862 return MCIERR_INVALID_DEVICE_ID;
863
864 MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
865
866 return 0;
867 }
868
869 /*======================================================================*
870 * MCI QTZ entry points *
871 *======================================================================*/
872
873 /**************************************************************************
874 * DriverProc (MCIQTZ.@)
875 */
876 LRESULT CALLBACK MCIQTZ_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
877 LPARAM dwParam1, LPARAM dwParam2)
878 {
879 TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
880 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
881
882 switch (wMsg) {
883 case DRV_LOAD: return 1;
884 case DRV_FREE: return 1;
885 case DRV_OPEN: return MCIQTZ_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
886 case DRV_CLOSE: return MCIQTZ_drvClose(dwDevID);
887 case DRV_ENABLE: return 1;
888 case DRV_DISABLE: return 1;
889 case DRV_QUERYCONFIGURE: return 1;
890 case DRV_CONFIGURE: return MCIQTZ_drvConfigure(dwDevID);
891 case DRV_INSTALL: return DRVCNF_RESTART;
892 case DRV_REMOVE: return DRVCNF_RESTART;
893 }
894
895 /* session instance */
896 if (dwDevID == 0xFFFFFFFF)
897 return 1;
898
899 switch (wMsg) {
900 case MCI_OPEN_DRIVER: return MCIQTZ_mciOpen (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSW) dwParam2);
901 case MCI_CLOSE_DRIVER: return MCIQTZ_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
902 case MCI_PLAY: return MCIQTZ_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
903 case MCI_SEEK: return MCIQTZ_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
904 case MCI_STOP: return MCIQTZ_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
905 case MCI_PAUSE: return MCIQTZ_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
906 case MCI_GETDEVCAPS: return MCIQTZ_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
907 case MCI_SET: return MCIQTZ_mciSet (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS) dwParam2);
908 case MCI_STATUS: return MCIQTZ_mciStatus (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSW) dwParam2);
909 case MCI_WHERE: return MCIQTZ_mciWhere (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
910 /* Digital Video specific */
911 case MCI_SETAUDIO: return MCIQTZ_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
912 case MCI_UPDATE:
913 return MCIQTZ_mciUpdate(dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS)dwParam2);
914 case MCI_RECORD:
915 case MCI_RESUME:
916 case MCI_INFO:
917 case MCI_PUT:
918 case MCI_WINDOW:
919 case MCI_LOAD:
920 case MCI_SAVE:
921 case MCI_FREEZE:
922 case MCI_REALIZE:
923 case MCI_UNFREEZE:
924 case MCI_STEP:
925 case MCI_COPY:
926 case MCI_CUT:
927 case MCI_DELETE:
928 case MCI_PASTE:
929 case MCI_CUE:
930 /* Digital Video specific */
931 case MCI_CAPTURE:
932 case MCI_MONITOR:
933 case MCI_RESERVE:
934 case MCI_SIGNAL:
935 case MCI_SETVIDEO:
936 case MCI_QUALITY:
937 case MCI_LIST:
938 case MCI_UNDO:
939 case MCI_CONFIGURE:
940 case MCI_RESTORE:
941 FIXME("Unimplemented command [%08X]\n", wMsg);
942 break;
943 case MCI_SPIN:
944 case MCI_ESCAPE:
945 WARN("Unsupported command [%08X]\n", wMsg);
946 break;
947 case MCI_OPEN:
948 case MCI_CLOSE:
949 FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
950 break;
951 default:
952 TRACE("Sending msg [%08X] to default driver proc\n", wMsg);
953 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
954 }
955
956 return MCIERR_UNRECOGNIZED_COMMAND;
957 }
A free Windows-compatible Operating System