Visual C++ backend for rbuild (for now just a hacked mingw backend) and related compi...
[reactos.git] / dll / directx / quartz / videorenderer.c
1 /*
2 * Video Renderer (Fullscreen and Windowed using Direct Draw)
3 *
4 * Copyright 2004 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 "config.h"
22
23 #define NONAMELESSSTRUCT
24 #define NONAMELESSUNION
25 #include "quartz_private.h"
26 #include "control_private.h"
27 #include "pin.h"
28
29 #include "uuids.h"
30 #include "vfwmsgs.h"
31 #include "amvideo.h"
32 #include "windef.h"
33 #include "winbase.h"
34 #include "dshow.h"
35 #include "evcode.h"
36 #include "strmif.h"
37 #include "ddraw.h"
38 #include "dvdmedia.h"
39
40 #include <assert.h>
41 #include "wine/unicode.h"
42 #include "wine/debug.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
45
46 static BOOL wnd_class_registered = FALSE;
47
48 static const WCHAR wcsInputPinName[] = {'i','n','p','u','t',' ','p','i','n',0};
49
50 static const IBaseFilterVtbl VideoRenderer_Vtbl;
51 static const IUnknownVtbl IInner_VTable;
52 static const IBasicVideoVtbl IBasicVideo_VTable;
53 static const IVideoWindowVtbl IVideoWindow_VTable;
54 static const IPinVtbl VideoRenderer_InputPin_Vtbl;
55
56 typedef struct VideoRendererImpl
57 {
58 const IBaseFilterVtbl * lpVtbl;
59 const IBasicVideoVtbl * IBasicVideo_vtbl;
60 const IVideoWindowVtbl * IVideoWindow_vtbl;
61 const IUnknownVtbl * IInner_vtbl;
62
63 LONG refCount;
64 CRITICAL_SECTION csFilter;
65 FILTER_STATE state;
66 REFERENCE_TIME rtStreamStart;
67 IReferenceClock * pClock;
68 FILTER_INFO filterInfo;
69
70 InputPin *pInputPin;
71
72 BOOL init;
73 HANDLE hThread;
74 HANDLE blocked;
75
76 DWORD ThreadID;
77 HANDLE hEvent;
78 BOOL ThreadResult;
79 HWND hWnd;
80 HWND hWndMsgDrain;
81 BOOL AutoShow;
82 RECT SourceRect;
83 RECT DestRect;
84 RECT WindowPos;
85 long VideoWidth;
86 long VideoHeight;
87 IUnknown * pUnkOuter;
88 BOOL bUnkOuterValid;
89 BOOL bAggregatable;
90 REFERENCE_TIME rtLastStop;
91 MediaSeekingImpl mediaSeeking;
92
93 /* During pause we can hold a single sample, for use in GetCurrentImage */
94 IMediaSample *sample_held;
95 } VideoRendererImpl;
96
97 static LRESULT CALLBACK VideoWndProcA(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
98 {
99 VideoRendererImpl* pVideoRenderer = (VideoRendererImpl*)GetWindowLongA(hwnd, 0);
100 LPRECT lprect = (LPRECT)lParam;
101
102 if (pVideoRenderer && pVideoRenderer->hWndMsgDrain)
103 {
104 switch(uMsg)
105 {
106 case WM_KEYDOWN:
107 case WM_KEYUP:
108 case WM_LBUTTONDBLCLK:
109 case WM_LBUTTONDOWN:
110 case WM_LBUTTONUP:
111 case WM_MBUTTONDBLCLK:
112 case WM_MBUTTONDOWN:
113 case WM_MBUTTONUP:
114 case WM_MOUSEACTIVATE:
115 case WM_MOUSEMOVE:
116 case WM_NCLBUTTONDBLCLK:
117 case WM_NCLBUTTONDOWN:
118 case WM_NCLBUTTONUP:
119 case WM_NCMBUTTONDBLCLK:
120 case WM_NCMBUTTONDOWN:
121 case WM_NCMBUTTONUP:
122 case WM_NCMOUSEMOVE:
123 case WM_NCRBUTTONDBLCLK:
124 case WM_NCRBUTTONDOWN:
125 case WM_NCRBUTTONUP:
126 case WM_RBUTTONDBLCLK:
127 case WM_RBUTTONDOWN:
128 case WM_RBUTTONUP:
129 PostMessageA(pVideoRenderer->hWndMsgDrain, uMsg, wParam, lParam);
130 break;
131 default:
132 break;
133 }
134 }
135
136 switch(uMsg)
137 {
138 case WM_SIZING:
139 /* TRACE("WM_SIZING %d %d %d %d\n", lprect->left, lprect->top, lprect->right, lprect->bottom); */
140 SetWindowPos(hwnd, NULL, lprect->left, lprect->top, lprect->right - lprect->left, lprect->bottom - lprect->top, SWP_NOZORDER);
141 GetClientRect(hwnd, &pVideoRenderer->DestRect);
142 TRACE("WM_SIZING: DestRect=(%d,%d),(%d,%d)\n",
143 pVideoRenderer->DestRect.left,
144 pVideoRenderer->DestRect.top,
145 pVideoRenderer->DestRect.right - pVideoRenderer->DestRect.left,
146 pVideoRenderer->DestRect.bottom - pVideoRenderer->DestRect.top);
147 return TRUE;
148 case WM_SIZE:
149 TRACE("WM_SIZE %d %d\n", LOWORD(lParam), HIWORD(lParam));
150 GetClientRect(hwnd, &pVideoRenderer->DestRect);
151 TRACE("WM_SIZING: DestRect=(%d,%d),(%d,%d)\n",
152 pVideoRenderer->DestRect.left,
153 pVideoRenderer->DestRect.top,
154 pVideoRenderer->DestRect.right - pVideoRenderer->DestRect.left,
155 pVideoRenderer->DestRect.bottom - pVideoRenderer->DestRect.top);
156 return TRUE;
157 default:
158 return DefWindowProcA(hwnd, uMsg, wParam, lParam);
159 }
160 return 0;
161 }
162
163 static BOOL CreateRenderingWindow(VideoRendererImpl* This)
164 {
165 WNDCLASSA winclass;
166
167 TRACE("(%p)->()\n", This);
168
169 winclass.style = 0;
170 winclass.lpfnWndProc = VideoWndProcA;
171 winclass.cbClsExtra = 0;
172 winclass.cbWndExtra = sizeof(VideoRendererImpl*);
173 winclass.hInstance = NULL;
174 winclass.hIcon = NULL;
175 winclass.hCursor = NULL;
176 winclass.hbrBackground = GetStockObject(BLACK_BRUSH);
177 winclass.lpszMenuName = NULL;
178 winclass.lpszClassName = "Wine ActiveMovie Class";
179
180 if (!wnd_class_registered)
181 {
182 if (!RegisterClassA(&winclass))
183 {
184 ERR("Unable to register window %u\n", GetLastError());
185 return FALSE;
186 }
187 wnd_class_registered = TRUE;
188 }
189
190 This->hWnd = CreateWindowExA(0, "Wine ActiveMovie Class", "Wine ActiveMovie Window", WS_SIZEBOX,
191 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL,
192 NULL, NULL, NULL);
193
194 if (!This->hWnd)
195 {
196 ERR("Unable to create window\n");
197 return FALSE;
198 }
199
200 SetWindowLongA(This->hWnd, 0, (LONG)This);
201
202 return TRUE;
203 }
204
205 static DWORD WINAPI MessageLoop(LPVOID lpParameter)
206 {
207 VideoRendererImpl* This = (VideoRendererImpl*) lpParameter;
208 MSG msg;
209 BOOL fGotMessage;
210
211 TRACE("Starting message loop\n");
212
213 if (!CreateRenderingWindow(This))
214 {
215 This->ThreadResult = FALSE;
216 SetEvent(This->hEvent);
217 return 0;
218 }
219
220 This->ThreadResult = TRUE;
221 SetEvent(This->hEvent);
222
223 while ((fGotMessage = GetMessageA(&msg, NULL, 0, 0)) != 0 && fGotMessage != -1)
224 {
225 TranslateMessage(&msg);
226 DispatchMessageA(&msg);
227 }
228
229 TRACE("End of message loop\n");
230
231 return msg.wParam;
232 }
233
234 static BOOL CreateRenderingSubsystem(VideoRendererImpl* This)
235 {
236 This->hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
237 if (!This->hEvent)
238 return FALSE;
239
240 This->hThread = CreateThread(NULL, 0, MessageLoop, (LPVOID)This, 0, &This->ThreadID);
241 if (!This->hThread)
242 {
243 CloseHandle(This->hEvent);
244 return FALSE;
245 }
246
247 WaitForSingleObject(This->hEvent, INFINITE);
248
249 if (!This->ThreadResult)
250 {
251 CloseHandle(This->hEvent);
252 CloseHandle(This->hThread);
253 return FALSE;
254 }
255
256 return TRUE;
257 }
258
259 static const IMemInputPinVtbl MemInputPin_Vtbl =
260 {
261 MemInputPin_QueryInterface,
262 MemInputPin_AddRef,
263 MemInputPin_Release,
264 MemInputPin_GetAllocator,
265 MemInputPin_NotifyAllocator,
266 MemInputPin_GetAllocatorRequirements,
267 MemInputPin_Receive,
268 MemInputPin_ReceiveMultiple,
269 MemInputPin_ReceiveCanBlock
270 };
271
272 static DWORD VideoRenderer_SendSampleData(VideoRendererImpl* This, LPBYTE data, DWORD size)
273 {
274 AM_MEDIA_TYPE amt;
275 HRESULT hr = S_OK;
276 DDSURFACEDESC sdesc;
277 int width;
278 int height;
279 LPBYTE palette = NULL;
280 HDC hDC;
281 BITMAPINFOHEADER *bmiHeader;
282
283 TRACE("%p %p %d\n", This, data, size);
284
285 sdesc.dwSize = sizeof(sdesc);
286 hr = IPin_ConnectionMediaType((IPin *)This->pInputPin, &amt);
287 if (FAILED(hr)) {
288 ERR("Unable to retrieve media type\n");
289 return hr;
290 }
291
292 if (IsEqualIID(&amt.formattype, &FORMAT_VideoInfo))
293 {
294 bmiHeader = &((VIDEOINFOHEADER *)amt.pbFormat)->bmiHeader;
295 }
296 else if (IsEqualIID(&amt.formattype, &FORMAT_VideoInfo2))
297 {
298 bmiHeader = &((VIDEOINFOHEADER2 *)amt.pbFormat)->bmiHeader;
299 }
300 else
301 {
302 FIXME("Unknown type %s\n", debugstr_guid(&amt.subtype));
303 return VFW_E_RUNTIME_ERROR;
304 }
305
306
307 TRACE("biSize = %d\n", bmiHeader->biSize);
308 TRACE("biWidth = %d\n", bmiHeader->biWidth);
309 TRACE("biHeight = %d\n", bmiHeader->biHeight);
310 TRACE("biPlanes = %d\n", bmiHeader->biPlanes);
311 TRACE("biBitCount = %d\n", bmiHeader->biBitCount);
312 TRACE("biCompression = %s\n", debugstr_an((LPSTR)&(bmiHeader->biCompression), 4));
313 TRACE("biSizeImage = %d\n", bmiHeader->biSizeImage);
314
315 width = bmiHeader->biWidth;
316 height = bmiHeader->biHeight;
317 palette = ((LPBYTE)bmiHeader) + bmiHeader->biSize;
318
319 if (!This->init)
320 {
321 if (!This->WindowPos.right || !This->WindowPos.bottom)
322 This->WindowPos = This->SourceRect;
323
324 TRACE("WindowPos: %d %d %d %d\n", This->WindowPos.left, This->WindowPos.top, This->WindowPos.right, This->WindowPos.bottom);
325 SetWindowPos(This->hWnd, NULL,
326 This->WindowPos.left,
327 This->WindowPos.top,
328 This->WindowPos.right - This->WindowPos.left,
329 This->WindowPos.bottom - This->WindowPos.top,
330 SWP_NOZORDER|SWP_NOMOVE);
331
332 GetClientRect(This->hWnd, &This->DestRect);
333 This->init = TRUE;
334 }
335
336 hDC = GetDC(This->hWnd);
337
338 if (!hDC) {
339 ERR("Cannot get DC from window!\n");
340 return E_FAIL;
341 }
342
343 TRACE("Src Rect: %d %d %d %d\n", This->SourceRect.left, This->SourceRect.top, This->SourceRect.right, This->SourceRect.bottom);
344 TRACE("Dst Rect: %d %d %d %d\n", This->DestRect.left, This->DestRect.top, This->DestRect.right, This->DestRect.bottom);
345
346 StretchDIBits(hDC, This->DestRect.left, This->DestRect.top, This->DestRect.right -This->DestRect.left,
347 This->DestRect.bottom - This->DestRect.top, This->SourceRect.left, This->SourceRect.top,
348 This->SourceRect.right - This->SourceRect.left, This->SourceRect.bottom - This->SourceRect.top,
349 data, (BITMAPINFO *)bmiHeader, DIB_RGB_COLORS, SRCCOPY);
350
351 ReleaseDC(This->hWnd, hDC);
352 if (This->AutoShow)
353 ShowWindow(This->hWnd, SW_SHOW);
354
355 return S_OK;
356 }
357
358 static HRESULT VideoRenderer_Sample(LPVOID iface, IMediaSample * pSample)
359 {
360 VideoRendererImpl *This = (VideoRendererImpl *)iface;
361 LPBYTE pbSrcStream = NULL;
362 long cbSrcStream = 0;
363 REFERENCE_TIME tStart, tStop;
364 HRESULT hr;
365 EnterCriticalSection(&This->csFilter);
366 if (This->pInputPin->flushing || This->pInputPin->end_of_stream)
367 hr = S_FALSE;
368
369 if (This->state == State_Stopped)
370 {
371 LeaveCriticalSection(&This->csFilter);
372 return VFW_E_WRONG_STATE;
373 }
374
375 TRACE("%p %p\n", iface, pSample);
376
377 hr = IMediaSample_GetTime(pSample, &tStart, &tStop);
378 if (FAILED(hr))
379 ERR("Cannot get sample time (%x)\n", hr);
380
381 if (This->rtLastStop != tStart)
382 {
383 if (IMediaSample_IsDiscontinuity(pSample) == S_FALSE)
384 ERR("Unexpected discontinuity: Last: %u.%03u, tStart: %u.%03u\n",
385 (DWORD)(This->rtLastStop / 10000000),
386 (DWORD)((This->rtLastStop / 10000)%1000),
387 (DWORD)(tStart / 10000000), (DWORD)((tStart / 10000)%1000));
388 This->rtLastStop = tStart;
389 }
390
391 /* Preroll means the sample isn't shown, this is used for key frames and things like that */
392 if (IMediaSample_IsPreroll(pSample) == S_OK)
393 {
394 This->rtLastStop = tStop;
395 LeaveCriticalSection(&This->csFilter);
396 return S_OK;
397 }
398
399 hr = IMediaSample_GetPointer(pSample, &pbSrcStream);
400 if (FAILED(hr))
401 {
402 ERR("Cannot get pointer to sample data (%x)\n", hr);
403 LeaveCriticalSection(&This->csFilter);
404 return hr;
405 }
406
407 cbSrcStream = IMediaSample_GetActualDataLength(pSample);
408
409 TRACE("val %p %ld\n", pbSrcStream, cbSrcStream);
410
411 #if 0 /* For debugging purpose */
412 {
413 int i;
414 for(i = 0; i < cbSrcStream; i++)
415 {
416 if ((i!=0) && !(i%16))
417 TRACE("\n");
418 TRACE("%02x ", pbSrcStream[i]);
419 }
420 TRACE("\n");
421 }
422 #endif
423
424 SetEvent(This->hEvent);
425 if (This->state == State_Paused)
426 {
427 This->sample_held = pSample;
428 LeaveCriticalSection(&This->csFilter);
429 WaitForSingleObject(This->blocked, INFINITE);
430 EnterCriticalSection(&This->csFilter);
431 This->sample_held = NULL;
432 if (This->state == State_Paused)
433 {
434 /* Flushing */
435 LeaveCriticalSection(&This->csFilter);
436 return S_OK;
437 }
438 if (This->state == State_Stopped)
439 {
440 LeaveCriticalSection(&This->csFilter);
441 return VFW_E_WRONG_STATE;
442 }
443 }
444
445 if (This->pClock && This->state == State_Running)
446 {
447 REFERENCE_TIME time, trefstart, trefstop;
448 LONG delta;
449
450 /* Perhaps I <SHOULD> use the reference clock AdviseTime function here
451 * I'm not going to! When I tried, it seemed to generate lag and
452 * it caused instability.
453 */
454 IReferenceClock_GetTime(This->pClock, &time);
455
456 trefstart = This->rtStreamStart;
457 trefstop = (REFERENCE_TIME)((double)(tStop - tStart) / This->pInputPin->dRate) + This->rtStreamStart;
458 delta = (LONG)((trefstart-time)/10000);
459 This->rtStreamStart = trefstop;
460 This->rtLastStop = tStop;
461
462 if (delta > 0)
463 {
464 TRACE("Sleeping for %u ms\n", delta);
465 Sleep(delta);
466 }
467 else if (time > trefstop)
468 {
469 TRACE("Dropping sample: Time: %u.%03u ms trefstop: %u.%03u ms!\n",
470 (DWORD)(time / 10000000), (DWORD)((time / 10000)%1000),
471 (DWORD)(trefstop / 10000000), (DWORD)((trefstop / 10000)%1000) );
472 This->rtLastStop = tStop;
473 LeaveCriticalSection(&This->csFilter);
474 return S_OK;
475 }
476 }
477 This->rtLastStop = tStop;
478
479 VideoRenderer_SendSampleData(This, pbSrcStream, cbSrcStream);
480
481 LeaveCriticalSection(&This->csFilter);
482 return S_OK;
483 }
484
485 static HRESULT VideoRenderer_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt)
486 {
487 if (!IsEqualIID(&pmt->majortype, &MEDIATYPE_Video))
488 return S_FALSE;
489
490 if (IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_RGB32) ||
491 IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_RGB24) ||
492 IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_RGB565) ||
493 IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_RGB8))
494 {
495 VideoRendererImpl* This = (VideoRendererImpl*) iface;
496
497 if (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo))
498 {
499 VIDEOINFOHEADER *format = (VIDEOINFOHEADER *)pmt->pbFormat;
500 This->SourceRect.left = 0;
501 This->SourceRect.top = 0;
502 This->SourceRect.right = This->VideoWidth = format->bmiHeader.biWidth;
503 This->SourceRect.bottom = This->VideoHeight = format->bmiHeader.biHeight;
504 }
505 else if (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo2))
506 {
507 VIDEOINFOHEADER2 *format2 = (VIDEOINFOHEADER2 *)pmt->pbFormat;
508
509 This->SourceRect.left = 0;
510 This->SourceRect.top = 0;
511 This->SourceRect.right = This->VideoWidth = format2->bmiHeader.biWidth;
512 This->SourceRect.bottom = This->VideoHeight = format2->bmiHeader.biHeight;
513 }
514 else
515 {
516 WARN("Format type %s not supported\n", debugstr_guid(&pmt->formattype));
517 return S_FALSE;
518 }
519 return S_OK;
520 }
521 return S_FALSE;
522 }
523
524 static inline VideoRendererImpl *impl_from_IMediaSeeking( IMediaSeeking *iface )
525 {
526 return (VideoRendererImpl *)((char*)iface - FIELD_OFFSET(VideoRendererImpl, mediaSeeking.lpVtbl));
527 }
528
529 static HRESULT WINAPI VideoRendererImpl_Seeking_QueryInterface(IMediaSeeking * iface, REFIID riid, LPVOID * ppv)
530 {
531 VideoRendererImpl *This = impl_from_IMediaSeeking(iface);
532
533 return IUnknown_QueryInterface((IUnknown *)This, riid, ppv);
534 }
535
536 static ULONG WINAPI VideoRendererImpl_Seeking_AddRef(IMediaSeeking * iface)
537 {
538 VideoRendererImpl *This = impl_from_IMediaSeeking(iface);
539
540 return IUnknown_AddRef((IUnknown *)This);
541 }
542
543 static ULONG WINAPI VideoRendererImpl_Seeking_Release(IMediaSeeking * iface)
544 {
545 VideoRendererImpl *This = impl_from_IMediaSeeking(iface);
546
547 return IUnknown_Release((IUnknown *)This);
548 }
549
550 static const IMediaSeekingVtbl VideoRendererImpl_Seeking_Vtbl =
551 {
552 VideoRendererImpl_Seeking_QueryInterface,
553 VideoRendererImpl_Seeking_AddRef,
554 VideoRendererImpl_Seeking_Release,
555 MediaSeekingImpl_GetCapabilities,
556 MediaSeekingImpl_CheckCapabilities,
557 MediaSeekingImpl_IsFormatSupported,
558 MediaSeekingImpl_QueryPreferredFormat,
559 MediaSeekingImpl_GetTimeFormat,
560 MediaSeekingImpl_IsUsingTimeFormat,
561 MediaSeekingImpl_SetTimeFormat,
562 MediaSeekingImpl_GetDuration,
563 MediaSeekingImpl_GetStopPosition,
564 MediaSeekingImpl_GetCurrentPosition,
565 MediaSeekingImpl_ConvertTimeFormat,
566 MediaSeekingImpl_SetPositions,
567 MediaSeekingImpl_GetPositions,
568 MediaSeekingImpl_GetAvailable,
569 MediaSeekingImpl_SetRate,
570 MediaSeekingImpl_GetRate,
571 MediaSeekingImpl_GetPreroll
572 };
573
574 static HRESULT VideoRendererImpl_Change(IBaseFilter *iface)
575 {
576 TRACE("(%p)\n", iface);
577 return S_OK;
578 }
579
580 HRESULT VideoRenderer_create(IUnknown * pUnkOuter, LPVOID * ppv)
581 {
582 HRESULT hr;
583 PIN_INFO piInput;
584 VideoRendererImpl * pVideoRenderer;
585
586 TRACE("(%p, %p)\n", pUnkOuter, ppv);
587
588 *ppv = NULL;
589
590 pVideoRenderer = CoTaskMemAlloc(sizeof(VideoRendererImpl));
591 pVideoRenderer->pUnkOuter = pUnkOuter;
592 pVideoRenderer->bUnkOuterValid = FALSE;
593 pVideoRenderer->bAggregatable = FALSE;
594 pVideoRenderer->IInner_vtbl = &IInner_VTable;
595
596 pVideoRenderer->lpVtbl = &VideoRenderer_Vtbl;
597 pVideoRenderer->IBasicVideo_vtbl = &IBasicVideo_VTable;
598 pVideoRenderer->IVideoWindow_vtbl = &IVideoWindow_VTable;
599
600 pVideoRenderer->refCount = 1;
601 InitializeCriticalSection(&pVideoRenderer->csFilter);
602 pVideoRenderer->csFilter.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": VideoRendererImpl.csFilter");
603 pVideoRenderer->state = State_Stopped;
604 pVideoRenderer->pClock = NULL;
605 pVideoRenderer->init = 0;
606 pVideoRenderer->AutoShow = 1;
607 pVideoRenderer->rtLastStop = -1;
608 ZeroMemory(&pVideoRenderer->filterInfo, sizeof(FILTER_INFO));
609 ZeroMemory(&pVideoRenderer->SourceRect, sizeof(RECT));
610 ZeroMemory(&pVideoRenderer->DestRect, sizeof(RECT));
611 ZeroMemory(&pVideoRenderer->WindowPos, sizeof(RECT));
612 pVideoRenderer->hWndMsgDrain = NULL;
613
614 /* construct input pin */
615 piInput.dir = PINDIR_INPUT;
616 piInput.pFilter = (IBaseFilter *)pVideoRenderer;
617 lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0]));
618
619 hr = InputPin_Construct(&VideoRenderer_InputPin_Vtbl, &piInput, VideoRenderer_Sample, (LPVOID)pVideoRenderer, VideoRenderer_QueryAccept, NULL, &pVideoRenderer->csFilter, NULL, (IPin **)&pVideoRenderer->pInputPin);
620
621 if (SUCCEEDED(hr))
622 {
623 MediaSeekingImpl_Init((IBaseFilter*)pVideoRenderer, VideoRendererImpl_Change, VideoRendererImpl_Change, VideoRendererImpl_Change, &pVideoRenderer->mediaSeeking, &pVideoRenderer->csFilter);
624 pVideoRenderer->mediaSeeking.lpVtbl = &VideoRendererImpl_Seeking_Vtbl;
625
626 pVideoRenderer->sample_held = NULL;
627 *ppv = (LPVOID)pVideoRenderer;
628 }
629 else
630 {
631 pVideoRenderer->csFilter.DebugInfo->Spare[0] = 0;
632 DeleteCriticalSection(&pVideoRenderer->csFilter);
633 CoTaskMemFree(pVideoRenderer);
634 }
635
636 if (!CreateRenderingSubsystem(pVideoRenderer))
637 return E_FAIL;
638
639 pVideoRenderer->blocked = CreateEventW(NULL, FALSE, FALSE, NULL);
640 if (!pVideoRenderer->blocked)
641 {
642 hr = HRESULT_FROM_WIN32(GetLastError());
643 IUnknown_Release((IUnknown *)pVideoRenderer);
644 }
645
646 return hr;
647 }
648
649 HRESULT VideoRendererDefault_create(IUnknown * pUnkOuter, LPVOID * ppv)
650 {
651 /* TODO: Attempt to use the VMR-7 renderer instead when possible */
652 return VideoRenderer_create(pUnkOuter, ppv);
653 }
654
655 static HRESULT WINAPI VideoRendererInner_QueryInterface(IUnknown * iface, REFIID riid, LPVOID * ppv)
656 {
657 ICOM_THIS_MULTI(VideoRendererImpl, IInner_vtbl, iface);
658 TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
659
660 if (This->bAggregatable)
661 This->bUnkOuterValid = TRUE;
662
663 *ppv = NULL;
664
665 if (IsEqualIID(riid, &IID_IUnknown))
666 *ppv = (LPVOID)&(This->IInner_vtbl);
667 else if (IsEqualIID(riid, &IID_IPersist))
668 *ppv = (LPVOID)This;
669 else if (IsEqualIID(riid, &IID_IMediaFilter))
670 *ppv = (LPVOID)This;
671 else if (IsEqualIID(riid, &IID_IBaseFilter))
672 *ppv = (LPVOID)This;
673 else if (IsEqualIID(riid, &IID_IBasicVideo))
674 *ppv = (LPVOID)&(This->IBasicVideo_vtbl);
675 else if (IsEqualIID(riid, &IID_IVideoWindow))
676 *ppv = (LPVOID)&(This->IVideoWindow_vtbl);
677 else if (IsEqualIID(riid, &IID_IMediaSeeking))
678 *ppv = &This->mediaSeeking;
679
680 if (*ppv)
681 {
682 IUnknown_AddRef((IUnknown *)(*ppv));
683 return S_OK;
684 }
685
686 if (!IsEqualIID(riid, &IID_IPin))
687 FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
688
689 return E_NOINTERFACE;
690 }
691
692 static ULONG WINAPI VideoRendererInner_AddRef(IUnknown * iface)
693 {
694 ICOM_THIS_MULTI(VideoRendererImpl, IInner_vtbl, iface);
695 ULONG refCount = InterlockedIncrement(&This->refCount);
696
697 TRACE("(%p/%p)->() AddRef from %d\n", This, iface, refCount - 1);
698
699 return refCount;
700 }
701
702 static ULONG WINAPI VideoRendererInner_Release(IUnknown * iface)
703 {
704 ICOM_THIS_MULTI(VideoRendererImpl, IInner_vtbl, iface);
705 ULONG refCount = InterlockedDecrement(&This->refCount);
706
707 TRACE("(%p/%p)->() Release from %d\n", This, iface, refCount + 1);
708
709 if (!refCount)
710 {
711 IPin *pConnectedTo;
712
713 DestroyWindow(This->hWnd);
714 PostThreadMessageA(This->ThreadID, WM_QUIT, 0, 0);
715 WaitForSingleObject(This->hThread, INFINITE);
716 CloseHandle(This->hThread);
717 CloseHandle(This->hEvent);
718
719 if (This->pClock)
720 IReferenceClock_Release(This->pClock);
721
722 if (SUCCEEDED(IPin_ConnectedTo((IPin *)This->pInputPin, &pConnectedTo)))
723 {
724 IPin_Disconnect(pConnectedTo);
725 IPin_Release(pConnectedTo);
726 }
727 IPin_Disconnect((IPin *)This->pInputPin);
728
729 IPin_Release((IPin *)This->pInputPin);
730
731 This->lpVtbl = NULL;
732
733 This->csFilter.DebugInfo->Spare[0] = 0;
734 DeleteCriticalSection(&This->csFilter);
735
736 TRACE("Destroying Video Renderer\n");
737 CoTaskMemFree(This);
738
739 return 0;
740 }
741 else
742 return refCount;
743 }
744
745 static const IUnknownVtbl IInner_VTable =
746 {
747 VideoRendererInner_QueryInterface,
748 VideoRendererInner_AddRef,
749 VideoRendererInner_Release
750 };
751
752 static HRESULT WINAPI VideoRenderer_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
753 {
754 VideoRendererImpl *This = (VideoRendererImpl *)iface;
755
756 if (This->bAggregatable)
757 This->bUnkOuterValid = TRUE;
758
759 if (This->pUnkOuter)
760 {
761 if (This->bAggregatable)
762 return IUnknown_QueryInterface(This->pUnkOuter, riid, ppv);
763
764 if (IsEqualIID(riid, &IID_IUnknown))
765 {
766 HRESULT hr;
767
768 IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl));
769 hr = IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv);
770 IUnknown_Release((IUnknown *)&(This->IInner_vtbl));
771 This->bAggregatable = TRUE;
772 return hr;
773 }
774
775 *ppv = NULL;
776 return E_NOINTERFACE;
777 }
778
779 return IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv);
780 }
781
782 static ULONG WINAPI VideoRenderer_AddRef(IBaseFilter * iface)
783 {
784 VideoRendererImpl *This = (VideoRendererImpl *)iface;
785
786 if (This->pUnkOuter && This->bUnkOuterValid)
787 return IUnknown_AddRef(This->pUnkOuter);
788 return IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl));
789 }
790
791 static ULONG WINAPI VideoRenderer_Release(IBaseFilter * iface)
792 {
793 VideoRendererImpl *This = (VideoRendererImpl *)iface;
794
795 if (This->pUnkOuter && This->bUnkOuterValid)
796 return IUnknown_Release(This->pUnkOuter);
797 return IUnknown_Release((IUnknown *)&(This->IInner_vtbl));
798 }
799
800 /** IPersist methods **/
801
802 static HRESULT WINAPI VideoRenderer_GetClassID(IBaseFilter * iface, CLSID * pClsid)
803 {
804 VideoRendererImpl *This = (VideoRendererImpl *)iface;
805
806 TRACE("(%p/%p)->(%p)\n", This, iface, pClsid);
807
808 *pClsid = CLSID_VideoRenderer;
809
810 return S_OK;
811 }
812
813 /** IMediaFilter methods **/
814
815 static HRESULT WINAPI VideoRenderer_Stop(IBaseFilter * iface)
816 {
817 VideoRendererImpl *This = (VideoRendererImpl *)iface;
818
819 TRACE("(%p/%p)->()\n", This, iface);
820
821 EnterCriticalSection(&This->csFilter);
822 {
823 This->state = State_Stopped;
824 SetEvent(This->hEvent);
825 SetEvent(This->blocked);
826 }
827 LeaveCriticalSection(&This->csFilter);
828
829 return S_OK;
830 }
831
832 static HRESULT WINAPI VideoRenderer_Pause(IBaseFilter * iface)
833 {
834 VideoRendererImpl *This = (VideoRendererImpl *)iface;
835
836 TRACE("(%p/%p)->()\n", This, iface);
837
838 EnterCriticalSection(&This->csFilter);
839 if (This->state != State_Paused)
840 {
841 if (This->state == State_Stopped)
842 {
843 This->pInputPin->end_of_stream = 0;
844 ResetEvent(This->hEvent);
845 }
846
847 This->state = State_Paused;
848 ResetEvent(This->blocked);
849 }
850 LeaveCriticalSection(&This->csFilter);
851
852 return S_OK;
853 }
854
855 static HRESULT WINAPI VideoRenderer_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
856 {
857 VideoRendererImpl *This = (VideoRendererImpl *)iface;
858
859 TRACE("(%p/%p)->(%s)\n", This, iface, wine_dbgstr_longlong(tStart));
860
861 EnterCriticalSection(&This->csFilter);
862 if (This->state != State_Running)
863 {
864 if (This->state == State_Stopped)
865 {
866 This->pInputPin->end_of_stream = 0;
867 ResetEvent(This->hEvent);
868 }
869 SetEvent(This->blocked);
870
871 This->rtStreamStart = tStart;
872 This->state = State_Running;
873 }
874 LeaveCriticalSection(&This->csFilter);
875
876 return S_OK;
877 }
878
879 static HRESULT WINAPI VideoRenderer_GetState(IBaseFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
880 {
881 VideoRendererImpl *This = (VideoRendererImpl *)iface;
882 HRESULT hr;
883
884 TRACE("(%p/%p)->(%d, %p)\n", This, iface, dwMilliSecsTimeout, pState);
885
886 if (WaitForSingleObject(This->hEvent, dwMilliSecsTimeout) == WAIT_TIMEOUT)
887 hr = VFW_S_STATE_INTERMEDIATE;
888 else
889 hr = S_OK;
890
891 EnterCriticalSection(&This->csFilter);
892 {
893 *pState = This->state;
894 }
895 LeaveCriticalSection(&This->csFilter);
896
897 return hr;
898 }
899
900 static HRESULT WINAPI VideoRenderer_SetSyncSource(IBaseFilter * iface, IReferenceClock *pClock)
901 {
902 VideoRendererImpl *This = (VideoRendererImpl *)iface;
903
904 TRACE("(%p/%p)->(%p)\n", This, iface, pClock);
905
906 EnterCriticalSection(&This->csFilter);
907 {
908 if (This->pClock)
909 IReferenceClock_Release(This->pClock);
910 This->pClock = pClock;
911 if (This->pClock)
912 IReferenceClock_AddRef(This->pClock);
913 }
914 LeaveCriticalSection(&This->csFilter);
915
916 return S_OK;
917 }
918
919 static HRESULT WINAPI VideoRenderer_GetSyncSource(IBaseFilter * iface, IReferenceClock **ppClock)
920 {
921 VideoRendererImpl *This = (VideoRendererImpl *)iface;
922
923 TRACE("(%p/%p)->(%p)\n", This, iface, ppClock);
924
925 EnterCriticalSection(&This->csFilter);
926 {
927 *ppClock = This->pClock;
928 if (This->pClock)
929 IReferenceClock_AddRef(This->pClock);
930 }
931 LeaveCriticalSection(&This->csFilter);
932
933 return S_OK;
934 }
935
936 /** IBaseFilter implementation **/
937
938 static HRESULT VideoRenderer_GetPin(IBaseFilter *iface, ULONG pos, IPin **pin, DWORD *lastsynctick)
939 {
940 VideoRendererImpl *This = (VideoRendererImpl *)iface;
941
942 /* Our pins are static, not changing so setting static tick count is ok */
943 *lastsynctick = 0;
944
945 if (pos >= 1)
946 return S_FALSE;
947
948 *pin = (IPin *)This->pInputPin;
949 IPin_AddRef(*pin);
950 return S_OK;
951 }
952
953 static HRESULT WINAPI VideoRenderer_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum)
954 {
955 VideoRendererImpl *This = (VideoRendererImpl *)iface;
956
957 TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
958
959 return IEnumPinsImpl_Construct(ppEnum, VideoRenderer_GetPin, iface);
960 }
961
962 static HRESULT WINAPI VideoRenderer_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
963 {
964 VideoRendererImpl *This = (VideoRendererImpl *)iface;
965
966 TRACE("(%p/%p)->(%p,%p)\n", This, iface, debugstr_w(Id), ppPin);
967
968 FIXME("VideoRenderer::FindPin(...)\n");
969
970 /* FIXME: critical section */
971
972 return E_NOTIMPL;
973 }
974
975 static HRESULT WINAPI VideoRenderer_QueryFilterInfo(IBaseFilter * iface, FILTER_INFO *pInfo)
976 {
977 VideoRendererImpl *This = (VideoRendererImpl *)iface;
978
979 TRACE("(%p/%p)->(%p)\n", This, iface, pInfo);
980
981 strcpyW(pInfo->achName, This->filterInfo.achName);
982 pInfo->pGraph = This->filterInfo.pGraph;
983
984 if (pInfo->pGraph)
985 IFilterGraph_AddRef(pInfo->pGraph);
986
987 return S_OK;
988 }
989
990 static HRESULT WINAPI VideoRenderer_JoinFilterGraph(IBaseFilter * iface, IFilterGraph *pGraph, LPCWSTR pName)
991 {
992 VideoRendererImpl *This = (VideoRendererImpl *)iface;
993
994 TRACE("(%p/%p)->(%p, %s)\n", This, iface, pGraph, debugstr_w(pName));
995
996 EnterCriticalSection(&This->csFilter);
997 {
998 if (pName)
999 strcpyW(This->filterInfo.achName, pName);
1000 else
1001 *This->filterInfo.achName = '\0';
1002 This->filterInfo.pGraph = pGraph; /* NOTE: do NOT increase ref. count */
1003 }
1004 LeaveCriticalSection(&This->csFilter);
1005
1006 return S_OK;
1007 }
1008
1009 static HRESULT WINAPI VideoRenderer_QueryVendorInfo(IBaseFilter * iface, LPWSTR *pVendorInfo)
1010 {
1011 VideoRendererImpl *This = (VideoRendererImpl *)iface;
1012 TRACE("(%p/%p)->(%p)\n", This, iface, pVendorInfo);
1013 return E_NOTIMPL;
1014 }
1015
1016 static const IBaseFilterVtbl VideoRenderer_Vtbl =
1017 {
1018 VideoRenderer_QueryInterface,
1019 VideoRenderer_AddRef,
1020 VideoRenderer_Release,
1021 VideoRenderer_GetClassID,
1022 VideoRenderer_Stop,
1023 VideoRenderer_Pause,
1024 VideoRenderer_Run,
1025 VideoRenderer_GetState,
1026 VideoRenderer_SetSyncSource,
1027 VideoRenderer_GetSyncSource,
1028 VideoRenderer_EnumPins,
1029 VideoRenderer_FindPin,
1030 VideoRenderer_QueryFilterInfo,
1031 VideoRenderer_JoinFilterGraph,
1032 VideoRenderer_QueryVendorInfo
1033 };
1034
1035 static HRESULT WINAPI VideoRenderer_InputPin_EndOfStream(IPin * iface)
1036 {
1037 InputPin* This = (InputPin*)iface;
1038 IMediaEventSink* pEventSink;
1039 HRESULT hr;
1040
1041 TRACE("(%p/%p)->()\n", This, iface);
1042
1043 hr = IFilterGraph_QueryInterface(((VideoRendererImpl*)This->pin.pinInfo.pFilter)->filterInfo.pGraph, &IID_IMediaEventSink, (LPVOID*)&pEventSink);
1044 if (SUCCEEDED(hr))
1045 {
1046 hr = IMediaEventSink_Notify(pEventSink, EC_COMPLETE, S_OK, 0);
1047 IMediaEventSink_Release(pEventSink);
1048 }
1049
1050 return hr;
1051 }
1052
1053 static HRESULT WINAPI VideoRenderer_InputPin_BeginFlush(IPin * iface)
1054 {
1055 InputPin* This = (InputPin*)iface;
1056 VideoRendererImpl *pVideoRenderer = (VideoRendererImpl *)This->pin.pinInfo.pFilter;
1057 HRESULT hr;
1058
1059 TRACE("(%p/%p)->()\n", This, iface);
1060
1061 EnterCriticalSection(This->pin.pCritSec);
1062 if (pVideoRenderer->state == State_Paused)
1063 SetEvent(pVideoRenderer->blocked);
1064
1065 hr = InputPin_BeginFlush(iface);
1066 LeaveCriticalSection(This->pin.pCritSec);
1067
1068 return hr;
1069 }
1070
1071 static HRESULT WINAPI VideoRenderer_InputPin_EndFlush(IPin * iface)
1072 {
1073 InputPin* This = (InputPin*)iface;
1074 VideoRendererImpl *pVideoRenderer = (VideoRendererImpl *)This->pin.pinInfo.pFilter;
1075 HRESULT hr;
1076
1077 TRACE("(%p/%p)->()\n", This, iface);
1078
1079 EnterCriticalSection(This->pin.pCritSec);
1080 if (pVideoRenderer->state == State_Paused)
1081 ResetEvent(pVideoRenderer->blocked);
1082
1083 hr = InputPin_EndFlush(iface);
1084 LeaveCriticalSection(This->pin.pCritSec);
1085
1086 return hr;
1087 }
1088
1089 static const IPinVtbl VideoRenderer_InputPin_Vtbl =
1090 {
1091 InputPin_QueryInterface,
1092 IPinImpl_AddRef,
1093 InputPin_Release,
1094 InputPin_Connect,
1095 InputPin_ReceiveConnection,
1096 IPinImpl_Disconnect,
1097 IPinImpl_ConnectedTo,
1098 IPinImpl_ConnectionMediaType,
1099 IPinImpl_QueryPinInfo,
1100 IPinImpl_QueryDirection,
1101 IPinImpl_QueryId,
1102 IPinImpl_QueryAccept,
1103 IPinImpl_EnumMediaTypes,
1104 IPinImpl_QueryInternalConnections,
1105 VideoRenderer_InputPin_EndOfStream,
1106 VideoRenderer_InputPin_BeginFlush,
1107 VideoRenderer_InputPin_EndFlush,
1108 InputPin_NewSegment
1109 };
1110
1111 /*** IUnknown methods ***/
1112 static HRESULT WINAPI Basicvideo_QueryInterface(IBasicVideo *iface,
1113 REFIID riid,
1114 LPVOID*ppvObj) {
1115 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1116
1117 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1118
1119 return VideoRenderer_QueryInterface((IBaseFilter*)This, riid, ppvObj);
1120 }
1121
1122 static ULONG WINAPI Basicvideo_AddRef(IBasicVideo *iface) {
1123 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1124
1125 TRACE("(%p/%p)->()\n", This, iface);
1126
1127 return VideoRenderer_AddRef((IBaseFilter*)This);
1128 }
1129
1130 static ULONG WINAPI Basicvideo_Release(IBasicVideo *iface) {
1131 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1132
1133 TRACE("(%p/%p)->()\n", This, iface);
1134
1135 return VideoRenderer_Release((IBaseFilter*)This);
1136 }
1137
1138 /*** IDispatch methods ***/
1139 static HRESULT WINAPI Basicvideo_GetTypeInfoCount(IBasicVideo *iface,
1140 UINT*pctinfo) {
1141 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1142
1143 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1144
1145 return S_OK;
1146 }
1147
1148 static HRESULT WINAPI Basicvideo_GetTypeInfo(IBasicVideo *iface,
1149 UINT iTInfo,
1150 LCID lcid,
1151 ITypeInfo**ppTInfo) {
1152 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1153
1154 FIXME("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1155
1156 return S_OK;
1157 }
1158
1159 static HRESULT WINAPI Basicvideo_GetIDsOfNames(IBasicVideo *iface,
1160 REFIID riid,
1161 LPOLESTR*rgszNames,
1162 UINT cNames,
1163 LCID lcid,
1164 DISPID*rgDispId) {
1165 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1166
1167 FIXME("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
1168
1169 return S_OK;
1170 }
1171
1172 static HRESULT WINAPI Basicvideo_Invoke(IBasicVideo *iface,
1173 DISPID dispIdMember,
1174 REFIID riid,
1175 LCID lcid,
1176 WORD wFlags,
1177 DISPPARAMS*pDispParams,
1178 VARIANT*pVarResult,
1179 EXCEPINFO*pExepInfo,
1180 UINT*puArgErr) {
1181 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1182
1183 FIXME("(%p/%p)->(%d, %s (%p), %d, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
1184
1185 return S_OK;
1186 }
1187
1188 /*** IBasicVideo methods ***/
1189 static HRESULT WINAPI Basicvideo_get_AvgTimePerFrame(IBasicVideo *iface,
1190 REFTIME *pAvgTimePerFrame) {
1191 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1192
1193 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pAvgTimePerFrame);
1194
1195 return S_OK;
1196 }
1197
1198 static HRESULT WINAPI Basicvideo_get_BitRate(IBasicVideo *iface,
1199 long *pBitRate) {
1200 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1201
1202 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBitRate);
1203
1204 return S_OK;
1205 }
1206
1207 static HRESULT WINAPI Basicvideo_get_BitErrorRate(IBasicVideo *iface,
1208 long *pBitErrorRate) {
1209 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1210
1211 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBitErrorRate);
1212
1213 return S_OK;
1214 }
1215
1216 static HRESULT WINAPI Basicvideo_get_VideoWidth(IBasicVideo *iface,
1217 long *pVideoWidth) {
1218 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1219
1220 TRACE("(%p/%p)->(%p)\n", This, iface, pVideoWidth);
1221
1222 *pVideoWidth = This->VideoWidth;
1223
1224 return S_OK;
1225 }
1226
1227 static HRESULT WINAPI Basicvideo_get_VideoHeight(IBasicVideo *iface,
1228 long *pVideoHeight) {
1229 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1230
1231 TRACE("(%p/%p)->(%p)\n", This, iface, pVideoHeight);
1232
1233 *pVideoHeight = This->VideoHeight;
1234
1235 return S_OK;
1236 }
1237
1238 static HRESULT WINAPI Basicvideo_put_SourceLeft(IBasicVideo *iface,
1239 long SourceLeft) {
1240 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1241
1242 TRACE("(%p/%p)->(%ld)\n", This, iface, SourceLeft);
1243
1244 This->SourceRect.left = SourceLeft;
1245
1246 return S_OK;
1247 }
1248
1249 static HRESULT WINAPI Basicvideo_get_SourceLeft(IBasicVideo *iface,
1250 long *pSourceLeft) {
1251 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1252
1253 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceLeft);
1254
1255 *pSourceLeft = This->SourceRect.left;
1256
1257 return S_OK;
1258 }
1259
1260 static HRESULT WINAPI Basicvideo_put_SourceWidth(IBasicVideo *iface,
1261 long SourceWidth) {
1262 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1263
1264 TRACE("(%p/%p)->(%ld)\n", This, iface, SourceWidth);
1265
1266 This->SourceRect.right = This->SourceRect.left + SourceWidth;
1267
1268 return S_OK;
1269 }
1270
1271 static HRESULT WINAPI Basicvideo_get_SourceWidth(IBasicVideo *iface,
1272 long *pSourceWidth) {
1273 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1274
1275 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceWidth);
1276
1277 *pSourceWidth = This->SourceRect.right - This->SourceRect.left;
1278
1279 return S_OK;
1280 }
1281
1282 static HRESULT WINAPI Basicvideo_put_SourceTop(IBasicVideo *iface,
1283 long SourceTop) {
1284 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1285
1286 TRACE("(%p/%p)->(%ld)\n", This, iface, SourceTop);
1287
1288 This->SourceRect.top = SourceTop;
1289
1290 return S_OK;
1291 }
1292
1293 static HRESULT WINAPI Basicvideo_get_SourceTop(IBasicVideo *iface,
1294 long *pSourceTop) {
1295 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1296
1297 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceTop);
1298
1299 *pSourceTop = This->SourceRect.top;
1300
1301 return S_OK;
1302 }
1303
1304 static HRESULT WINAPI Basicvideo_put_SourceHeight(IBasicVideo *iface,
1305 long SourceHeight) {
1306 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1307
1308 TRACE("(%p/%p)->(%ld)\n", This, iface, SourceHeight);
1309
1310 This->SourceRect.bottom = This->SourceRect.top + SourceHeight;
1311
1312 return S_OK;
1313 }
1314
1315 static HRESULT WINAPI Basicvideo_get_SourceHeight(IBasicVideo *iface,
1316 long *pSourceHeight) {
1317 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1318
1319 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceHeight);
1320
1321 *pSourceHeight = This->SourceRect.bottom - This->SourceRect.top;
1322
1323 return S_OK;
1324 }
1325
1326 static HRESULT WINAPI Basicvideo_put_DestinationLeft(IBasicVideo *iface,
1327 long DestinationLeft) {
1328 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1329
1330 TRACE("(%p/%p)->(%ld)\n", This, iface, DestinationLeft);
1331
1332 This->DestRect.left = DestinationLeft;
1333
1334 return S_OK;
1335 }
1336
1337 static HRESULT WINAPI Basicvideo_get_DestinationLeft(IBasicVideo *iface,
1338 long *pDestinationLeft) {
1339 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1340
1341 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationLeft);
1342
1343 *pDestinationLeft = This->DestRect.left;
1344
1345 return S_OK;
1346 }
1347
1348 static HRESULT WINAPI Basicvideo_put_DestinationWidth(IBasicVideo *iface,
1349 long DestinationWidth) {
1350 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1351
1352 TRACE("(%p/%p)->(%ld)\n", This, iface, DestinationWidth);
1353
1354 This->DestRect.right = This->DestRect.left + DestinationWidth;
1355
1356 return S_OK;
1357 }
1358
1359 static HRESULT WINAPI Basicvideo_get_DestinationWidth(IBasicVideo *iface,
1360 long *pDestinationWidth) {
1361 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1362
1363 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationWidth);
1364
1365 *pDestinationWidth = This->DestRect.right - This->DestRect.left;
1366
1367 return S_OK;
1368 }
1369
1370 static HRESULT WINAPI Basicvideo_put_DestinationTop(IBasicVideo *iface,
1371 long DestinationTop) {
1372 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1373
1374 TRACE("(%p/%p)->(%ld)\n", This, iface, DestinationTop);
1375
1376 This->DestRect.top = DestinationTop;
1377
1378 return S_OK;
1379 }
1380
1381 static HRESULT WINAPI Basicvideo_get_DestinationTop(IBasicVideo *iface,
1382 long *pDestinationTop) {
1383 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1384
1385 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationTop);
1386
1387 *pDestinationTop = This->DestRect.top;
1388
1389 return S_OK;
1390 }
1391
1392 static HRESULT WINAPI Basicvideo_put_DestinationHeight(IBasicVideo *iface,
1393 long DestinationHeight) {
1394 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1395
1396 TRACE("(%p/%p)->(%ld)\n", This, iface, DestinationHeight);
1397
1398 This->DestRect.right = This->DestRect.left + DestinationHeight;
1399
1400 return S_OK;
1401 }
1402
1403 static HRESULT WINAPI Basicvideo_get_DestinationHeight(IBasicVideo *iface,
1404 long *pDestinationHeight) {
1405 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1406
1407 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationHeight);
1408
1409 *pDestinationHeight = This->DestRect.right - This->DestRect.left;
1410
1411 return S_OK;
1412 }
1413
1414 static HRESULT WINAPI Basicvideo_SetSourcePosition(IBasicVideo *iface,
1415 long Left,
1416 long Top,
1417 long Width,
1418 long Height) {
1419 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1420
1421 TRACE("(%p/%p)->(%ld, %ld, %ld, %ld)\n", This, iface, Left, Top, Width, Height);
1422
1423 This->SourceRect.left = Left;
1424 This->SourceRect.top = Top;
1425 This->SourceRect.right = Left + Width;
1426 This->SourceRect.bottom = Top + Height;
1427
1428 return S_OK;
1429 }
1430
1431 static HRESULT WINAPI Basicvideo_GetSourcePosition(IBasicVideo *iface,
1432 long *pLeft,
1433 long *pTop,
1434 long *pWidth,
1435 long *pHeight) {
1436 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1437
1438 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
1439
1440 *pLeft = This->SourceRect.left;
1441 *pTop = This->SourceRect.top;
1442 *pWidth = This->SourceRect.right - This->SourceRect.left;
1443 *pHeight = This->SourceRect.bottom - This->SourceRect.top;
1444
1445 return S_OK;
1446 }
1447
1448 static HRESULT WINAPI Basicvideo_SetDefaultSourcePosition(IBasicVideo *iface) {
1449 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1450
1451 TRACE("(%p/%p)->()\n", This, iface);
1452
1453 This->SourceRect.left = 0;
1454 This->SourceRect.top = 0;
1455 This->SourceRect.right = This->VideoWidth;
1456 This->SourceRect.bottom = This->VideoHeight;
1457
1458 return S_OK;
1459 }
1460
1461 static HRESULT WINAPI Basicvideo_SetDestinationPosition(IBasicVideo *iface,
1462 long Left,
1463 long Top,
1464 long Width,
1465 long Height) {
1466 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1467
1468 TRACE("(%p/%p)->(%ld, %ld, %ld, %ld)\n", This, iface, Left, Top, Width, Height);
1469
1470 This->DestRect.left = Left;
1471 This->DestRect.top = Top;
1472 This->DestRect.right = Left + Width;
1473 This->DestRect.bottom = Top + Height;
1474
1475 return S_OK;
1476 }
1477
1478 static HRESULT WINAPI Basicvideo_GetDestinationPosition(IBasicVideo *iface,
1479 long *pLeft,
1480 long *pTop,
1481 long *pWidth,
1482 long *pHeight) {
1483 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1484
1485 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
1486
1487 *pLeft = This->DestRect.left;
1488 *pTop = This->DestRect.top;
1489 *pWidth = This->DestRect.right - This->DestRect.left;
1490 *pHeight = This->DestRect.bottom - This->DestRect.top;
1491
1492 return S_OK;
1493 }
1494
1495 static HRESULT WINAPI Basicvideo_SetDefaultDestinationPosition(IBasicVideo *iface) {
1496 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1497 RECT rect;
1498
1499 TRACE("(%p/%p)->()\n", This, iface);
1500
1501 if (!GetClientRect(This->hWnd, &rect))
1502 return E_FAIL;
1503
1504 This->SourceRect.left = 0;
1505 This->SourceRect.top = 0;
1506 This->SourceRect.right = rect.right;
1507 This->SourceRect.bottom = rect.bottom;
1508
1509 return S_OK;
1510 }
1511
1512 static HRESULT WINAPI Basicvideo_GetVideoSize(IBasicVideo *iface,
1513 long *pWidth,
1514 long *pHeight) {
1515 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1516
1517 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
1518
1519 *pWidth = This->VideoWidth;
1520 *pHeight = This->VideoHeight;
1521
1522 return S_OK;
1523 }
1524
1525 static HRESULT WINAPI Basicvideo_GetVideoPaletteEntries(IBasicVideo *iface,
1526 long StartIndex,
1527 long Entries,
1528 long *pRetrieved,
1529 long *pPalette) {
1530 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1531
1532 FIXME("(%p/%p)->(%ld, %ld, %p, %p): stub !!!\n", This, iface, StartIndex, Entries, pRetrieved, pPalette);
1533
1534 return S_OK;
1535 }
1536
1537 static HRESULT WINAPI Basicvideo_GetCurrentImage(IBasicVideo *iface,
1538 long *pBufferSize,
1539 long *pDIBImage) {
1540 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1541 BITMAPINFOHEADER *bmiHeader;
1542 LONG needed_size;
1543 AM_MEDIA_TYPE *amt = &This->pInputPin->pin.mtCurrent;
1544 char *ptr;
1545
1546 EnterCriticalSection(&This->csFilter);
1547
1548 if (!This->sample_held)
1549 {
1550 LeaveCriticalSection(&This->csFilter);
1551 return (This->state == State_Paused ? E_UNEXPECTED : VFW_E_NOT_PAUSED);
1552 }
1553
1554 FIXME("(%p/%p)->(%p, %p): partial stub\n", This, iface, pBufferSize, pDIBImage);
1555
1556 if (IsEqualIID(&amt->formattype, &FORMAT_VideoInfo))
1557 {
1558 bmiHeader = &((VIDEOINFOHEADER *)amt->pbFormat)->bmiHeader;
1559 }
1560 else if (IsEqualIID(&amt->formattype, &FORMAT_VideoInfo2))
1561 {
1562 bmiHeader = &((VIDEOINFOHEADER2 *)amt->pbFormat)->bmiHeader;
1563 }
1564 else
1565 {
1566 FIXME("Unknown type %s\n", debugstr_guid(&amt->subtype));
1567 LeaveCriticalSection(&This->csFilter);
1568 return VFW_E_RUNTIME_ERROR;
1569 }
1570
1571 needed_size = bmiHeader->biSize;
1572 needed_size += IMediaSample_GetActualDataLength(This->sample_held);
1573
1574 if (!pDIBImage)
1575 {
1576 *pBufferSize = needed_size;
1577 LeaveCriticalSection(&This->csFilter);
1578 return S_OK;
1579 }
1580
1581 if (needed_size < *pBufferSize)
1582 {
1583 ERR("Buffer too small %u/%lu\n", needed_size, *pBufferSize);
1584 LeaveCriticalSection(&This->csFilter);
1585 return E_FAIL;
1586 }
1587 *pBufferSize = needed_size;
1588
1589 memcpy(pDIBImage, bmiHeader, bmiHeader->biSize);
1590 IMediaSample_GetPointer(This->sample_held, (BYTE **)&ptr);
1591 memcpy((char *)pDIBImage + bmiHeader->biSize, ptr, IMediaSample_GetActualDataLength(This->sample_held));
1592
1593 LeaveCriticalSection(&This->csFilter);
1594
1595 return S_OK;
1596 }
1597
1598 static HRESULT WINAPI Basicvideo_IsUsingDefaultSource(IBasicVideo *iface) {
1599 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1600
1601 FIXME("(%p/%p)->(): stub !!!\n", This, iface);
1602
1603 return S_OK;
1604 }
1605
1606 static HRESULT WINAPI Basicvideo_IsUsingDefaultDestination(IBasicVideo *iface) {
1607 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1608
1609 FIXME("(%p/%p)->(): stub !!!\n", This, iface);
1610
1611 return S_OK;
1612 }
1613
1614
1615 static const IBasicVideoVtbl IBasicVideo_VTable =
1616 {
1617 Basicvideo_QueryInterface,
1618 Basicvideo_AddRef,
1619 Basicvideo_Release,
1620 Basicvideo_GetTypeInfoCount,
1621 Basicvideo_GetTypeInfo,
1622 Basicvideo_GetIDsOfNames,
1623 Basicvideo_Invoke,
1624 Basicvideo_get_AvgTimePerFrame,
1625 Basicvideo_get_BitRate,
1626 Basicvideo_get_BitErrorRate,
1627 Basicvideo_get_VideoWidth,
1628 Basicvideo_get_VideoHeight,
1629 Basicvideo_put_SourceLeft,
1630 Basicvideo_get_SourceLeft,
1631 Basicvideo_put_SourceWidth,
1632 Basicvideo_get_SourceWidth,
1633 Basicvideo_put_SourceTop,
1634 Basicvideo_get_SourceTop,
1635 Basicvideo_put_SourceHeight,
1636 Basicvideo_get_SourceHeight,
1637 Basicvideo_put_DestinationLeft,
1638 Basicvideo_get_DestinationLeft,
1639 Basicvideo_put_DestinationWidth,
1640 Basicvideo_get_DestinationWidth,
1641 Basicvideo_put_DestinationTop,
1642 Basicvideo_get_DestinationTop,
1643 Basicvideo_put_DestinationHeight,
1644 Basicvideo_get_DestinationHeight,
1645 Basicvideo_SetSourcePosition,
1646 Basicvideo_GetSourcePosition,
1647 Basicvideo_SetDefaultSourcePosition,
1648 Basicvideo_SetDestinationPosition,
1649 Basicvideo_GetDestinationPosition,
1650 Basicvideo_SetDefaultDestinationPosition,
1651 Basicvideo_GetVideoSize,
1652 Basicvideo_GetVideoPaletteEntries,
1653 Basicvideo_GetCurrentImage,
1654 Basicvideo_IsUsingDefaultSource,
1655 Basicvideo_IsUsingDefaultDestination
1656 };
1657
1658
1659 /*** IUnknown methods ***/
1660 static HRESULT WINAPI Videowindow_QueryInterface(IVideoWindow *iface,
1661 REFIID riid,
1662 LPVOID*ppvObj) {
1663 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1664
1665 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1666
1667 return VideoRenderer_QueryInterface((IBaseFilter*)This, riid, ppvObj);
1668 }
1669
1670 static ULONG WINAPI Videowindow_AddRef(IVideoWindow *iface) {
1671 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1672
1673 TRACE("(%p/%p)->()\n", This, iface);
1674
1675 return VideoRenderer_AddRef((IBaseFilter*)This);
1676 }
1677
1678 static ULONG WINAPI Videowindow_Release(IVideoWindow *iface) {
1679 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1680
1681 TRACE("(%p/%p)->()\n", This, iface);
1682
1683 return VideoRenderer_Release((IBaseFilter*)This);
1684 }
1685
1686 /*** IDispatch methods ***/
1687 static HRESULT WINAPI Videowindow_GetTypeInfoCount(IVideoWindow *iface,
1688 UINT*pctinfo) {
1689 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1690
1691 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1692
1693 return S_OK;
1694 }
1695
1696 static HRESULT WINAPI Videowindow_GetTypeInfo(IVideoWindow *iface,
1697 UINT iTInfo,
1698 LCID lcid,
1699 ITypeInfo**ppTInfo) {
1700 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1701
1702 FIXME("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1703
1704 return S_OK;
1705 }
1706
1707 static HRESULT WINAPI Videowindow_GetIDsOfNames(IVideoWindow *iface,
1708 REFIID riid,
1709 LPOLESTR*rgszNames,
1710 UINT cNames,
1711 LCID lcid,
1712 DISPID*rgDispId) {
1713 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1714
1715 FIXME("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
1716
1717 return S_OK;
1718 }
1719
1720 static HRESULT WINAPI Videowindow_Invoke(IVideoWindow *iface,
1721 DISPID dispIdMember,
1722 REFIID riid,
1723 LCID lcid,
1724 WORD wFlags,
1725 DISPPARAMS*pDispParams,
1726 VARIANT*pVarResult,
1727 EXCEPINFO*pExepInfo,
1728 UINT*puArgErr) {
1729 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1730
1731 FIXME("(%p/%p)->(%d, %s (%p), %d, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
1732
1733 return S_OK;
1734 }
1735
1736 /*** IVideoWindow methods ***/
1737 static HRESULT WINAPI Videowindow_put_Caption(IVideoWindow *iface,
1738 BSTR strCaption) {
1739 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1740
1741 TRACE("(%p/%p)->(%s (%p))\n", This, iface, debugstr_w(strCaption), strCaption);
1742
1743 if (!SetWindowTextW(This->hWnd, strCaption))
1744 return E_FAIL;
1745
1746 return S_OK;
1747 }
1748
1749 static HRESULT WINAPI Videowindow_get_Caption(IVideoWindow *iface,
1750 BSTR *strCaption) {
1751 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1752
1753 TRACE("(%p/%p)->(%p)\n", This, iface, strCaption);
1754
1755 GetWindowTextW(This->hWnd, (LPWSTR)strCaption, 100);
1756
1757 return S_OK;
1758 }
1759
1760 static HRESULT WINAPI Videowindow_put_WindowStyle(IVideoWindow *iface,
1761 long WindowStyle) {
1762 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1763 LONG old;
1764
1765 old = GetWindowLongA(This->hWnd, GWL_STYLE);
1766
1767 TRACE("(%p/%p)->(%x -> %lx)\n", This, iface, old, WindowStyle);
1768
1769 if (WindowStyle & (WS_DISABLED|WS_HSCROLL|WS_ICONIC|WS_MAXIMIZE|WS_MINIMIZE|WS_VSCROLL))
1770 return E_INVALIDARG;
1771
1772 SetWindowLongA(This->hWnd, GWL_STYLE, WindowStyle);
1773
1774 return S_OK;
1775 }
1776
1777 static HRESULT WINAPI Videowindow_get_WindowStyle(IVideoWindow *iface,
1778 long *WindowStyle) {
1779 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1780
1781 TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyle);
1782
1783 *WindowStyle = GetWindowLongA(This->hWnd, GWL_STYLE);
1784
1785 return S_OK;
1786 }
1787
1788 static HRESULT WINAPI Videowindow_put_WindowStyleEx(IVideoWindow *iface,
1789 long WindowStyleEx) {
1790 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1791
1792 TRACE("(%p/%p)->(%ld)\n", This, iface, WindowStyleEx);
1793
1794 if (WindowStyleEx & (WS_DISABLED|WS_HSCROLL|WS_ICONIC|WS_MAXIMIZE|WS_MINIMIZE|WS_VSCROLL))
1795 return E_INVALIDARG;
1796
1797 if (!SetWindowLongA(This->hWnd, GWL_EXSTYLE, WindowStyleEx))
1798 return E_FAIL;
1799
1800 return S_OK;
1801 }
1802
1803 static HRESULT WINAPI Videowindow_get_WindowStyleEx(IVideoWindow *iface,
1804 long *WindowStyleEx) {
1805 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1806
1807 TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyleEx);
1808
1809 *WindowStyleEx = GetWindowLongA(This->hWnd, GWL_EXSTYLE);
1810
1811 return S_OK;
1812 }
1813
1814 static HRESULT WINAPI Videowindow_put_AutoShow(IVideoWindow *iface,
1815 long AutoShow) {
1816 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1817
1818 TRACE("(%p/%p)->(%ld)\n", This, iface, AutoShow);
1819
1820 This->AutoShow = 1; /* FXIME: Should be AutoShow */;
1821
1822 return S_OK;
1823 }
1824
1825 static HRESULT WINAPI Videowindow_get_AutoShow(IVideoWindow *iface,
1826 long *AutoShow) {
1827 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1828
1829 TRACE("(%p/%p)->(%p)\n", This, iface, AutoShow);
1830
1831 *AutoShow = This->AutoShow;
1832
1833 return S_OK;
1834 }
1835
1836 static HRESULT WINAPI Videowindow_put_WindowState(IVideoWindow *iface,
1837 long WindowState) {
1838 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1839
1840 FIXME("(%p/%p)->(%ld): stub !!!\n", This, iface, WindowState);
1841
1842 return S_OK;
1843 }
1844
1845 static HRESULT WINAPI Videowindow_get_WindowState(IVideoWindow *iface,
1846 long *WindowState) {
1847 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1848
1849 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, WindowState);
1850
1851 return S_OK;
1852 }
1853
1854 static HRESULT WINAPI Videowindow_put_BackgroundPalette(IVideoWindow *iface,
1855 long BackgroundPalette) {
1856 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1857
1858 FIXME("(%p/%p)->(%ld): stub !!!\n", This, iface, BackgroundPalette);
1859
1860 return S_OK;
1861 }
1862
1863 static HRESULT WINAPI Videowindow_get_BackgroundPalette(IVideoWindow *iface,
1864 long *pBackgroundPalette) {
1865 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1866
1867 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBackgroundPalette);
1868
1869 return S_OK;
1870 }
1871
1872 static HRESULT WINAPI Videowindow_put_Visible(IVideoWindow *iface,
1873 long Visible) {
1874 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1875
1876 TRACE("(%p/%p)->(%ld)\n", This, iface, Visible);
1877
1878 ShowWindow(This->hWnd, Visible ? SW_SHOW : SW_HIDE);
1879
1880 return S_OK;
1881 }
1882
1883 static HRESULT WINAPI Videowindow_get_Visible(IVideoWindow *iface,
1884 long *pVisible) {
1885 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1886
1887 TRACE("(%p/%p)->(%p)\n", This, iface, pVisible);
1888
1889 *pVisible = IsWindowVisible(This->hWnd);
1890
1891 return S_OK;
1892 }
1893
1894 static HRESULT WINAPI Videowindow_put_Left(IVideoWindow *iface,
1895 long Left) {
1896 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1897
1898 TRACE("(%p/%p)->(%ld)\n", This, iface, Left);
1899
1900 if (!SetWindowPos(This->hWnd, NULL, Left, This->WindowPos.top, 0, 0, SWP_NOZORDER|SWP_NOSIZE))
1901 return E_FAIL;
1902
1903 This->WindowPos.left = Left;
1904
1905 return S_OK;
1906 }
1907
1908 static HRESULT WINAPI Videowindow_get_Left(IVideoWindow *iface,
1909 long *pLeft) {
1910 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1911
1912 TRACE("(%p/%p)->(%p)\n", This, iface, pLeft);
1913
1914 *pLeft = This->WindowPos.left;
1915
1916 return S_OK;
1917 }
1918
1919 static HRESULT WINAPI Videowindow_put_Width(IVideoWindow *iface,
1920 long Width) {
1921 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1922
1923 TRACE("(%p/%p)->(%ld)\n", This, iface, Width);
1924
1925 if (!SetWindowPos(This->hWnd, NULL, 0, 0, Width, This->WindowPos.bottom-This->WindowPos.top, SWP_NOZORDER|SWP_NOMOVE))
1926 return E_FAIL;
1927
1928 This->WindowPos.right = This->WindowPos.left + Width;
1929
1930 return S_OK;
1931 }
1932
1933 static HRESULT WINAPI Videowindow_get_Width(IVideoWindow *iface,
1934 long *pWidth) {
1935 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1936
1937 TRACE("(%p/%p)->(%p)\n", This, iface, pWidth);
1938
1939 *pWidth = This->WindowPos.right - This->WindowPos.left;
1940
1941 return S_OK;
1942 }
1943
1944 static HRESULT WINAPI Videowindow_put_Top(IVideoWindow *iface,
1945 long Top) {
1946 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1947
1948 TRACE("(%p/%p)->(%ld)\n", This, iface, Top);
1949
1950 if (!SetWindowPos(This->hWnd, NULL, This->WindowPos.left, Top, 0, 0, SWP_NOZORDER|SWP_NOSIZE))
1951 return E_FAIL;
1952
1953 This->WindowPos.top = Top;
1954
1955 return S_OK;
1956 }
1957
1958 static HRESULT WINAPI Videowindow_get_Top(IVideoWindow *iface,
1959 long *pTop) {
1960 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1961
1962 TRACE("(%p/%p)->(%p)\n", This, iface, pTop);
1963
1964 *pTop = This->WindowPos.top;
1965
1966 return S_OK;
1967 }
1968
1969 static HRESULT WINAPI Videowindow_put_Height(IVideoWindow *iface,
1970 long Height) {
1971 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1972
1973 TRACE("(%p/%p)->(%ld)\n", This, iface, Height);
1974
1975 if (!SetWindowPos(This->hWnd, NULL, 0, 0, This->WindowPos.right-This->WindowPos.left, Height, SWP_NOZORDER|SWP_NOMOVE))
1976 return E_FAIL;
1977
1978 This->WindowPos.bottom = This->WindowPos.top + Height;
1979
1980 return S_OK;
1981 }
1982
1983 static HRESULT WINAPI Videowindow_get_Height(IVideoWindow *iface,
1984 long *pHeight) {
1985 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1986
1987 TRACE("(%p/%p)->(%p)\n", This, iface, pHeight);
1988
1989 *pHeight = This->WindowPos.bottom - This->WindowPos.top;
1990
1991 return S_OK;
1992 }
1993
1994 static HRESULT WINAPI Videowindow_put_Owner(IVideoWindow *iface,
1995 OAHWND Owner) {
1996 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1997
1998 TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Owner);
1999
2000 SetParent(This->hWnd, (HWND)Owner);
2001
2002 return S_OK;
2003 }
2004
2005 static HRESULT WINAPI Videowindow_get_Owner(IVideoWindow *iface,
2006 OAHWND *Owner) {
2007 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2008
2009 TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Owner);
2010
2011 *(HWND*)Owner = GetParent(This->hWnd);
2012
2013 return S_OK;
2014 }
2015
2016 static HRESULT WINAPI Videowindow_put_MessageDrain(IVideoWindow *iface,
2017 OAHWND Drain) {
2018 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2019
2020 TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Drain);
2021
2022 This->hWndMsgDrain = (HWND)Drain;
2023
2024 return S_OK;
2025 }
2026
2027 static HRESULT WINAPI Videowindow_get_MessageDrain(IVideoWindow *iface,
2028 OAHWND *Drain) {
2029 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2030
2031 TRACE("(%p/%p)->(%p)\n", This, iface, Drain);
2032
2033 *Drain = (OAHWND)This->hWndMsgDrain;
2034
2035 return S_OK;
2036 }
2037
2038 static HRESULT WINAPI Videowindow_get_BorderColor(IVideoWindow *iface,
2039 long *Color) {
2040 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2041
2042 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, Color);
2043
2044 return S_OK;
2045 }
2046
2047 static HRESULT WINAPI Videowindow_put_BorderColor(IVideoWindow *iface,
2048 long Color) {
2049 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2050
2051 FIXME("(%p/%p)->(%ld): stub !!!\n", This, iface, Color);
2052
2053 return S_OK;
2054 }
2055
2056 static HRESULT WINAPI Videowindow_get_FullScreenMode(IVideoWindow *iface,
2057 long *FullScreenMode) {
2058 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2059
2060 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, FullScreenMode);
2061
2062 return S_OK;
2063 }
2064
2065 static HRESULT WINAPI Videowindow_put_FullScreenMode(IVideoWindow *iface,
2066 long FullScreenMode) {
2067 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2068
2069 FIXME("(%p/%p)->(%ld): stub !!!\n", This, iface, FullScreenMode);
2070
2071 return S_OK;
2072 }
2073
2074 static HRESULT WINAPI Videowindow_SetWindowForeground(IVideoWindow *iface,
2075 long Focus) {
2076 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2077 BOOL ret;
2078 IPin* pPin;
2079 HRESULT hr;
2080
2081 TRACE("(%p/%p)->(%ld)\n", This, iface, Focus);
2082
2083 if ((Focus != FALSE) && (Focus != TRUE))
2084 return E_INVALIDARG;
2085
2086 hr = IPin_ConnectedTo((IPin *)This->pInputPin, &pPin);
2087 if ((hr != S_OK) || !pPin)
2088 return VFW_E_NOT_CONNECTED;
2089
2090 if (Focus)
2091 ret = SetForegroundWindow(This->hWnd);
2092 else
2093 ret = SetWindowPos(This->hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
2094
2095 if (!ret)
2096 return E_FAIL;
2097
2098 return S_OK;
2099 }
2100
2101 static HRESULT WINAPI Videowindow_NotifyOwnerMessage(IVideoWindow *iface,
2102 OAHWND hwnd,
2103 long uMsg,
2104 LONG_PTR wParam,
2105 LONG_PTR lParam) {
2106 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2107
2108 TRACE("(%p/%p)->(%08x, %ld, %08lx, %08lx)\n", This, iface, (DWORD) hwnd, uMsg, wParam, lParam);
2109
2110 if (!PostMessageA(This->hWnd, uMsg, wParam, lParam))
2111 return E_FAIL;
2112
2113 return S_OK;
2114 }
2115
2116 static HRESULT WINAPI Videowindow_SetWindowPosition(IVideoWindow *iface,
2117 long Left,
2118 long Top,
2119 long Width,
2120 long Height) {
2121 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2122
2123 TRACE("(%p/%p)->(%ld, %ld, %ld, %ld)\n", This, iface, Left, Top, Width, Height);
2124
2125 if (!SetWindowPos(This->hWnd, NULL, Left, Top, Width, Height, SWP_NOZORDER))
2126 return E_FAIL;
2127
2128 This->WindowPos.left = Left;
2129 This->WindowPos.top = Top;
2130 This->WindowPos.right = Left + Width;
2131 This->WindowPos.bottom = Top + Height;
2132
2133 return S_OK;
2134 }
2135
2136 static HRESULT WINAPI Videowindow_GetWindowPosition(IVideoWindow *iface,
2137 long *pLeft,
2138 long *pTop,
2139 long *pWidth,
2140 long *pHeight) {
2141 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2142
2143 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
2144
2145 *pLeft = This->WindowPos.left;
2146 *pTop = This->WindowPos.top;
2147 *pWidth = This->WindowPos.right - This->WindowPos.left;
2148 *pHeight = This->WindowPos.bottom - This->WindowPos.top;
2149
2150 return S_OK;
2151 }
2152
2153 static HRESULT WINAPI Videowindow_GetMinIdealImageSize(IVideoWindow *iface,
2154 long *pWidth,
2155 long *pHeight) {
2156 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2157
2158 FIXME("(%p/%p)->(%p, %p): semi stub !!!\n", This, iface, pWidth, pHeight);
2159
2160 *pWidth = This->VideoWidth;
2161 *pHeight = This->VideoHeight;
2162
2163 return S_OK;
2164 }
2165
2166 static HRESULT WINAPI Videowindow_GetMaxIdealImageSize(IVideoWindow *iface,
2167 long *pWidth,
2168 long *pHeight) {
2169 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2170
2171 FIXME("(%p/%p)->(%p, %p): semi stub !!!\n", This, iface, pWidth, pHeight);
2172
2173 *pWidth = This->VideoWidth;
2174 *pHeight = This->VideoHeight;
2175
2176 return S_OK;
2177 }
2178
2179 static HRESULT WINAPI Videowindow_GetRestorePosition(IVideoWindow *iface,
2180 long *pLeft,
2181 long *pTop,
2182 long *pWidth,
2183 long *pHeight) {
2184 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2185
2186 FIXME("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight);
2187
2188 return S_OK;
2189 }
2190
2191 static HRESULT WINAPI Videowindow_HideCursor(IVideoWindow *iface,
2192 long HideCursor) {
2193 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2194
2195 FIXME("(%p/%p)->(%ld): stub !!!\n", This, iface, HideCursor);
2196
2197 return S_OK;
2198 }
2199
2200 static HRESULT WINAPI Videowindow_IsCursorHidden(IVideoWindow *iface,
2201 long *CursorHidden) {
2202 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2203
2204 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, CursorHidden);
2205
2206 return S_OK;
2207 }
2208
2209 static const IVideoWindowVtbl IVideoWindow_VTable =
2210 {
2211 Videowindow_QueryInterface,
2212 Videowindow_AddRef,
2213 Videowindow_Release,
2214 Videowindow_GetTypeInfoCount,
2215 Videowindow_GetTypeInfo,
2216 Videowindow_GetIDsOfNames,
2217 Videowindow_Invoke,
2218 Videowindow_put_Caption,
2219 Videowindow_get_Caption,
2220 Videowindow_put_WindowStyle,
2221 Videowindow_get_WindowStyle,
2222 Videowindow_put_WindowStyleEx,
2223 Videowindow_get_WindowStyleEx,
2224 Videowindow_put_AutoShow,
2225 Videowindow_get_AutoShow,
2226 Videowindow_put_WindowState,
2227 Videowindow_get_WindowState,
2228 Videowindow_put_BackgroundPalette,
2229 Videowindow_get_BackgroundPalette,
2230 Videowindow_put_Visible,
2231 Videowindow_get_Visible,
2232 Videowindow_put_Left,
2233 Videowindow_get_Left,
2234 Videowindow_put_Width,
2235 Videowindow_get_Width,
2236 Videowindow_put_Top,
2237 Videowindow_get_Top,
2238 Videowindow_put_Height,
2239 Videowindow_get_Height,
2240 Videowindow_put_Owner,
2241 Videowindow_get_Owner,
2242 Videowindow_put_MessageDrain,
2243 Videowindow_get_MessageDrain,
2244 Videowindow_get_BorderColor,
2245 Videowindow_put_BorderColor,
2246 Videowindow_get_FullScreenMode,
2247 Videowindow_put_FullScreenMode,
2248 Videowindow_SetWindowForeground,
2249 Videowindow_NotifyOwnerMessage,
2250 Videowindow_SetWindowPosition,
2251 Videowindow_GetWindowPosition,
2252 Videowindow_GetMinIdealImageSize,
2253 Videowindow_GetMaxIdealImageSize,
2254 Videowindow_GetRestorePosition,
2255 Videowindow_HideCursor,
2256 Videowindow_IsCursorHidden
2257 };