advapi32: Make rpcrt4 a delayed import to work around circular dependencies with...
[wine/testsucceed.git] / dlls / quartz / videorenderer.c
blob268373f188858944ff2c7d53ef686ba32b42922d
1 /*
2 * Video Renderer (Fullscreen and Windowed using Direct Draw)
4 * Copyright 2004 Christian Costa
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.
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.
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
21 #include "config.h"
23 #define NONAMELESSSTRUCT
24 #define NONAMELESSUNION
25 #include "quartz_private.h"
26 #include "control_private.h"
27 #include "pin.h"
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"
40 #include <assert.h>
41 #include "wine/unicode.h"
42 #include "wine/debug.h"
44 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
46 static BOOL wnd_class_registered = FALSE;
48 static const WCHAR wcsInputPinName[] = {'i','n','p','u','t',' ','p','i','n',0};
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;
56 typedef struct VideoRendererImpl
58 const IBaseFilterVtbl * lpVtbl;
59 const IBasicVideoVtbl * IBasicVideo_vtbl;
60 const IVideoWindowVtbl * IVideoWindow_vtbl;
61 const IUnknownVtbl * IInner_vtbl;
63 LONG refCount;
64 CRITICAL_SECTION csFilter;
65 FILTER_STATE state;
66 REFERENCE_TIME rtStreamStart;
67 IReferenceClock * pClock;
68 FILTER_INFO filterInfo;
70 InputPin *pInputPin;
72 BOOL init;
73 HANDLE hThread;
74 HANDLE blocked;
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;
93 /* During pause we can hold a single sample, for use in GetCurrentImage */
94 IMediaSample *sample_held;
95 } VideoRendererImpl;
97 static LRESULT CALLBACK VideoWndProcA(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
99 VideoRendererImpl* pVideoRenderer = (VideoRendererImpl*)GetWindowLongPtrW(hwnd, 0);
100 LPRECT lprect = (LPRECT)lParam;
102 if (pVideoRenderer && pVideoRenderer->hWndMsgDrain)
104 switch(uMsg)
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;
136 switch(uMsg)
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);
160 return 0;
163 static BOOL CreateRenderingWindow(VideoRendererImpl* This)
165 WNDCLASSA winclass;
167 TRACE("(%p)->()\n", This);
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";
180 if (!wnd_class_registered)
182 if (!RegisterClassA(&winclass))
184 ERR("Unable to register window %u\n", GetLastError());
185 return FALSE;
187 wnd_class_registered = TRUE;
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);
194 if (!This->hWnd)
196 ERR("Unable to create window\n");
197 return FALSE;
200 SetWindowLongPtrW(This->hWnd, 0, (LONG_PTR)This);
202 return TRUE;
205 static DWORD WINAPI MessageLoop(LPVOID lpParameter)
207 VideoRendererImpl* This = lpParameter;
208 MSG msg;
209 BOOL fGotMessage;
211 TRACE("Starting message loop\n");
213 if (!CreateRenderingWindow(This))
215 This->ThreadResult = FALSE;
216 SetEvent(This->hEvent);
217 return 0;
220 This->ThreadResult = TRUE;
221 SetEvent(This->hEvent);
223 while ((fGotMessage = GetMessageA(&msg, NULL, 0, 0)) != 0 && fGotMessage != -1)
225 TranslateMessage(&msg);
226 DispatchMessageA(&msg);
229 TRACE("End of message loop\n");
231 return msg.wParam;
234 static BOOL CreateRenderingSubsystem(VideoRendererImpl* This)
236 This->hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
237 if (!This->hEvent)
238 return FALSE;
240 This->hThread = CreateThread(NULL, 0, MessageLoop, This, 0, &This->ThreadID);
241 if (!This->hThread)
243 CloseHandle(This->hEvent);
244 return FALSE;
247 WaitForSingleObject(This->hEvent, INFINITE);
249 if (!This->ThreadResult)
251 CloseHandle(This->hEvent);
252 CloseHandle(This->hThread);
253 return FALSE;
256 return TRUE;
259 static DWORD VideoRenderer_SendSampleData(VideoRendererImpl* This, LPBYTE data, DWORD size)
261 AM_MEDIA_TYPE amt;
262 HRESULT hr = S_OK;
263 DDSURFACEDESC sdesc;
264 HDC hDC;
265 BITMAPINFOHEADER *bmiHeader;
267 TRACE("(%p)->(%p, %d)\n", This, data, size);
269 sdesc.dwSize = sizeof(sdesc);
270 hr = IPin_ConnectionMediaType((IPin *)This->pInputPin, &amt);
271 if (FAILED(hr)) {
272 ERR("Unable to retrieve media type\n");
273 return hr;
276 if (IsEqualIID(&amt.formattype, &FORMAT_VideoInfo))
278 bmiHeader = &((VIDEOINFOHEADER *)amt.pbFormat)->bmiHeader;
280 else if (IsEqualIID(&amt.formattype, &FORMAT_VideoInfo2))
282 bmiHeader = &((VIDEOINFOHEADER2 *)amt.pbFormat)->bmiHeader;
284 else
286 FIXME("Unknown type %s\n", debugstr_guid(&amt.subtype));
287 return VFW_E_RUNTIME_ERROR;
290 TRACE("biSize = %d\n", bmiHeader->biSize);
291 TRACE("biWidth = %d\n", bmiHeader->biWidth);
292 TRACE("biHeight = %d\n", bmiHeader->biHeight);
293 TRACE("biPlanes = %d\n", bmiHeader->biPlanes);
294 TRACE("biBitCount = %d\n", bmiHeader->biBitCount);
295 TRACE("biCompression = %s\n", debugstr_an((LPSTR)&(bmiHeader->biCompression), 4));
296 TRACE("biSizeImage = %d\n", bmiHeader->biSizeImage);
298 if (!This->init)
300 DWORD style = GetWindowLongW(This->hWnd, GWL_STYLE);
301 DWORD style_ex = GetWindowLongW(This->hWnd, GWL_EXSTYLE);
303 if (!This->WindowPos.right || !This->WindowPos.bottom)
304 This->WindowPos = This->SourceRect;
306 AdjustWindowRectEx(&This->WindowPos, style, TRUE, style_ex);
308 TRACE("WindowPos: %d %d %d %d\n", This->WindowPos.left, This->WindowPos.top, This->WindowPos.right, This->WindowPos.bottom);
309 SetWindowPos(This->hWnd, NULL,
310 This->WindowPos.left,
311 This->WindowPos.top,
312 This->WindowPos.right - This->WindowPos.left,
313 This->WindowPos.bottom - This->WindowPos.top,
314 SWP_NOZORDER|SWP_NOMOVE);
316 GetClientRect(This->hWnd, &This->DestRect);
317 This->init = TRUE;
320 hDC = GetDC(This->hWnd);
322 if (!hDC) {
323 ERR("Cannot get DC from window!\n");
324 return E_FAIL;
327 TRACE("Src Rect: %d %d %d %d\n", This->SourceRect.left, This->SourceRect.top, This->SourceRect.right, This->SourceRect.bottom);
328 TRACE("Dst Rect: %d %d %d %d\n", This->DestRect.left, This->DestRect.top, This->DestRect.right, This->DestRect.bottom);
330 StretchDIBits(hDC, This->DestRect.left, This->DestRect.top, This->DestRect.right -This->DestRect.left,
331 This->DestRect.bottom - This->DestRect.top, This->SourceRect.left, This->SourceRect.top,
332 This->SourceRect.right - This->SourceRect.left, This->SourceRect.bottom - This->SourceRect.top,
333 data, (BITMAPINFO *)bmiHeader, DIB_RGB_COLORS, SRCCOPY);
335 ReleaseDC(This->hWnd, hDC);
336 if (This->AutoShow)
337 ShowWindow(This->hWnd, SW_SHOW);
339 return S_OK;
342 static HRESULT VideoRenderer_Sample(LPVOID iface, IMediaSample * pSample)
344 VideoRendererImpl *This = iface;
345 LPBYTE pbSrcStream = NULL;
346 LONG cbSrcStream = 0;
347 REFERENCE_TIME tStart, tStop;
348 HRESULT hr;
350 TRACE("(%p)->(%p)\n", iface, pSample);
352 EnterCriticalSection(&This->csFilter);
354 if (This->pInputPin->flushing || This->pInputPin->end_of_stream)
356 LeaveCriticalSection(&This->csFilter);
357 return S_FALSE;
360 if (This->state == State_Stopped)
362 LeaveCriticalSection(&This->csFilter);
363 return VFW_E_WRONG_STATE;
366 hr = IMediaSample_GetTime(pSample, &tStart, &tStop);
367 if (FAILED(hr))
368 ERR("Cannot get sample time (%x)\n", hr);
370 if (This->rtLastStop != tStart)
372 if (IMediaSample_IsDiscontinuity(pSample) == S_FALSE)
373 ERR("Unexpected discontinuity: Last: %u.%03u, tStart: %u.%03u\n",
374 (DWORD)(This->rtLastStop / 10000000),
375 (DWORD)((This->rtLastStop / 10000)%1000),
376 (DWORD)(tStart / 10000000), (DWORD)((tStart / 10000)%1000));
377 This->rtLastStop = tStart;
380 /* Preroll means the sample isn't shown, this is used for key frames and things like that */
381 if (IMediaSample_IsPreroll(pSample) == S_OK)
383 This->rtLastStop = tStop;
384 LeaveCriticalSection(&This->csFilter);
385 return S_OK;
388 hr = IMediaSample_GetPointer(pSample, &pbSrcStream);
389 if (FAILED(hr))
391 ERR("Cannot get pointer to sample data (%x)\n", hr);
392 LeaveCriticalSection(&This->csFilter);
393 return hr;
396 cbSrcStream = IMediaSample_GetActualDataLength(pSample);
398 TRACE("val %p %d\n", pbSrcStream, cbSrcStream);
400 #if 0 /* For debugging purpose */
402 int i;
403 for(i = 0; i < cbSrcStream; i++)
405 if ((i!=0) && !(i%16))
406 TRACE("\n");
407 TRACE("%02x ", pbSrcStream[i]);
409 TRACE("\n");
411 #endif
413 SetEvent(This->hEvent);
414 if (This->state == State_Paused)
416 This->sample_held = pSample;
417 LeaveCriticalSection(&This->csFilter);
418 WaitForSingleObject(This->blocked, INFINITE);
419 EnterCriticalSection(&This->csFilter);
420 This->sample_held = NULL;
421 if (This->state == State_Paused)
423 /* Flushing */
424 LeaveCriticalSection(&This->csFilter);
425 return S_OK;
427 if (This->state == State_Stopped)
429 LeaveCriticalSection(&This->csFilter);
430 return VFW_E_WRONG_STATE;
434 if (This->pClock && This->state == State_Running)
436 REFERENCE_TIME time, trefstart, trefstop;
437 LONG delta;
439 /* Perhaps I <SHOULD> use the reference clock AdviseTime function here
440 * I'm not going to! When I tried, it seemed to generate lag and
441 * it caused instability.
443 IReferenceClock_GetTime(This->pClock, &time);
445 trefstart = This->rtStreamStart;
446 trefstop = (REFERENCE_TIME)((double)(tStop - tStart) / This->pInputPin->dRate) + This->rtStreamStart;
447 delta = (LONG)((trefstart-time)/10000);
448 This->rtStreamStart = trefstop;
449 This->rtLastStop = tStop;
451 if (delta > 0)
453 TRACE("Sleeping for %u ms\n", delta);
454 Sleep(delta);
456 else if (time > trefstop)
458 TRACE("Dropping sample: Time: %u.%03u ms trefstop: %u.%03u ms!\n",
459 (DWORD)(time / 10000000), (DWORD)((time / 10000)%1000),
460 (DWORD)(trefstop / 10000000), (DWORD)((trefstop / 10000)%1000) );
461 This->rtLastStop = tStop;
462 LeaveCriticalSection(&This->csFilter);
463 return S_OK;
466 This->rtLastStop = tStop;
468 VideoRenderer_SendSampleData(This, pbSrcStream, cbSrcStream);
470 LeaveCriticalSection(&This->csFilter);
471 return S_OK;
474 static HRESULT VideoRenderer_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt)
476 if (!IsEqualIID(&pmt->majortype, &MEDIATYPE_Video))
477 return S_FALSE;
479 if (IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_RGB32) ||
480 IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_RGB24) ||
481 IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_RGB565) ||
482 IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_RGB8))
484 VideoRendererImpl* This = iface;
485 LONG height;
487 if (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo))
489 VIDEOINFOHEADER *format = (VIDEOINFOHEADER *)pmt->pbFormat;
490 This->SourceRect.left = 0;
491 This->SourceRect.top = 0;
492 This->SourceRect.right = This->VideoWidth = format->bmiHeader.biWidth;
493 height = format->bmiHeader.biHeight;
494 if (height < 0)
495 This->SourceRect.bottom = This->VideoHeight = -height;
496 else
497 This->SourceRect.bottom = This->VideoHeight = height;
499 else if (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo2))
501 VIDEOINFOHEADER2 *format2 = (VIDEOINFOHEADER2 *)pmt->pbFormat;
503 This->SourceRect.left = 0;
504 This->SourceRect.top = 0;
505 This->SourceRect.right = This->VideoWidth = format2->bmiHeader.biWidth;
506 height = format2->bmiHeader.biHeight;
507 if (height < 0)
508 This->SourceRect.bottom = This->VideoHeight = -height;
509 else
510 This->SourceRect.bottom = This->VideoHeight = height;
512 else
514 WARN("Format type %s not supported\n", debugstr_guid(&pmt->formattype));
515 return S_FALSE;
517 return S_OK;
519 return S_FALSE;
522 static inline VideoRendererImpl *impl_from_IMediaSeeking( IMediaSeeking *iface )
524 return (VideoRendererImpl *)((char*)iface - FIELD_OFFSET(VideoRendererImpl, mediaSeeking.lpVtbl));
527 static HRESULT WINAPI VideoRendererImpl_Seeking_QueryInterface(IMediaSeeking * iface, REFIID riid, LPVOID * ppv)
529 VideoRendererImpl *This = impl_from_IMediaSeeking(iface);
531 return IUnknown_QueryInterface((IUnknown *)This, riid, ppv);
534 static ULONG WINAPI VideoRendererImpl_Seeking_AddRef(IMediaSeeking * iface)
536 VideoRendererImpl *This = impl_from_IMediaSeeking(iface);
538 return IUnknown_AddRef((IUnknown *)This);
541 static ULONG WINAPI VideoRendererImpl_Seeking_Release(IMediaSeeking * iface)
543 VideoRendererImpl *This = impl_from_IMediaSeeking(iface);
545 return IUnknown_Release((IUnknown *)This);
548 static const IMediaSeekingVtbl VideoRendererImpl_Seeking_Vtbl =
550 VideoRendererImpl_Seeking_QueryInterface,
551 VideoRendererImpl_Seeking_AddRef,
552 VideoRendererImpl_Seeking_Release,
553 MediaSeekingImpl_GetCapabilities,
554 MediaSeekingImpl_CheckCapabilities,
555 MediaSeekingImpl_IsFormatSupported,
556 MediaSeekingImpl_QueryPreferredFormat,
557 MediaSeekingImpl_GetTimeFormat,
558 MediaSeekingImpl_IsUsingTimeFormat,
559 MediaSeekingImpl_SetTimeFormat,
560 MediaSeekingImpl_GetDuration,
561 MediaSeekingImpl_GetStopPosition,
562 MediaSeekingImpl_GetCurrentPosition,
563 MediaSeekingImpl_ConvertTimeFormat,
564 MediaSeekingImpl_SetPositions,
565 MediaSeekingImpl_GetPositions,
566 MediaSeekingImpl_GetAvailable,
567 MediaSeekingImpl_SetRate,
568 MediaSeekingImpl_GetRate,
569 MediaSeekingImpl_GetPreroll
572 static HRESULT VideoRendererImpl_Change(IBaseFilter *iface)
574 TRACE("(%p)->()\n", iface);
575 return S_OK;
578 HRESULT VideoRenderer_create(IUnknown * pUnkOuter, LPVOID * ppv)
580 HRESULT hr;
581 PIN_INFO piInput;
582 VideoRendererImpl * pVideoRenderer;
584 TRACE("(%p, %p)\n", pUnkOuter, ppv);
586 *ppv = NULL;
588 pVideoRenderer = CoTaskMemAlloc(sizeof(VideoRendererImpl));
589 pVideoRenderer->pUnkOuter = pUnkOuter;
590 pVideoRenderer->bUnkOuterValid = FALSE;
591 pVideoRenderer->bAggregatable = FALSE;
592 pVideoRenderer->IInner_vtbl = &IInner_VTable;
594 pVideoRenderer->lpVtbl = &VideoRenderer_Vtbl;
595 pVideoRenderer->IBasicVideo_vtbl = &IBasicVideo_VTable;
596 pVideoRenderer->IVideoWindow_vtbl = &IVideoWindow_VTable;
598 pVideoRenderer->refCount = 1;
599 InitializeCriticalSection(&pVideoRenderer->csFilter);
600 pVideoRenderer->csFilter.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": VideoRendererImpl.csFilter");
601 pVideoRenderer->state = State_Stopped;
602 pVideoRenderer->pClock = NULL;
603 pVideoRenderer->init = 0;
604 pVideoRenderer->AutoShow = 1;
605 pVideoRenderer->rtLastStop = -1;
606 ZeroMemory(&pVideoRenderer->filterInfo, sizeof(FILTER_INFO));
607 ZeroMemory(&pVideoRenderer->SourceRect, sizeof(RECT));
608 ZeroMemory(&pVideoRenderer->DestRect, sizeof(RECT));
609 ZeroMemory(&pVideoRenderer->WindowPos, sizeof(RECT));
610 pVideoRenderer->hWndMsgDrain = NULL;
612 /* construct input pin */
613 piInput.dir = PINDIR_INPUT;
614 piInput.pFilter = (IBaseFilter *)pVideoRenderer;
615 lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0]));
617 hr = InputPin_Construct(&VideoRenderer_InputPin_Vtbl, &piInput, VideoRenderer_Sample, (LPVOID)pVideoRenderer, VideoRenderer_QueryAccept, NULL, &pVideoRenderer->csFilter, NULL, (IPin **)&pVideoRenderer->pInputPin);
619 if (SUCCEEDED(hr))
621 MediaSeekingImpl_Init((IBaseFilter*)pVideoRenderer, VideoRendererImpl_Change, VideoRendererImpl_Change, VideoRendererImpl_Change, &pVideoRenderer->mediaSeeking, &pVideoRenderer->csFilter);
622 pVideoRenderer->mediaSeeking.lpVtbl = &VideoRendererImpl_Seeking_Vtbl;
624 pVideoRenderer->sample_held = NULL;
625 *ppv = pVideoRenderer;
627 else
629 pVideoRenderer->csFilter.DebugInfo->Spare[0] = 0;
630 DeleteCriticalSection(&pVideoRenderer->csFilter);
631 CoTaskMemFree(pVideoRenderer);
634 if (!CreateRenderingSubsystem(pVideoRenderer))
635 return E_FAIL;
637 pVideoRenderer->blocked = CreateEventW(NULL, FALSE, FALSE, NULL);
638 if (!pVideoRenderer->blocked)
640 hr = HRESULT_FROM_WIN32(GetLastError());
641 IUnknown_Release((IUnknown *)pVideoRenderer);
644 return hr;
647 HRESULT VideoRendererDefault_create(IUnknown * pUnkOuter, LPVOID * ppv)
649 /* TODO: Attempt to use the VMR-7 renderer instead when possible */
650 return VideoRenderer_create(pUnkOuter, ppv);
653 static HRESULT WINAPI VideoRendererInner_QueryInterface(IUnknown * iface, REFIID riid, LPVOID * ppv)
655 ICOM_THIS_MULTI(VideoRendererImpl, IInner_vtbl, iface);
656 TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
658 if (This->bAggregatable)
659 This->bUnkOuterValid = TRUE;
661 *ppv = NULL;
663 if (IsEqualIID(riid, &IID_IUnknown))
664 *ppv = &This->IInner_vtbl;
665 else if (IsEqualIID(riid, &IID_IPersist))
666 *ppv = This;
667 else if (IsEqualIID(riid, &IID_IMediaFilter))
668 *ppv = This;
669 else if (IsEqualIID(riid, &IID_IBaseFilter))
670 *ppv = This;
671 else if (IsEqualIID(riid, &IID_IBasicVideo))
672 *ppv = &This->IBasicVideo_vtbl;
673 else if (IsEqualIID(riid, &IID_IVideoWindow))
674 *ppv = &This->IVideoWindow_vtbl;
675 else if (IsEqualIID(riid, &IID_IMediaSeeking))
676 *ppv = &This->mediaSeeking;
678 if (*ppv)
680 IUnknown_AddRef((IUnknown *)(*ppv));
681 return S_OK;
684 if (!IsEqualIID(riid, &IID_IPin))
685 FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
687 return E_NOINTERFACE;
690 static ULONG WINAPI VideoRendererInner_AddRef(IUnknown * iface)
692 ICOM_THIS_MULTI(VideoRendererImpl, IInner_vtbl, iface);
693 ULONG refCount = InterlockedIncrement(&This->refCount);
695 TRACE("(%p/%p)->() AddRef from %d\n", This, iface, refCount - 1);
697 return refCount;
700 static ULONG WINAPI VideoRendererInner_Release(IUnknown * iface)
702 ICOM_THIS_MULTI(VideoRendererImpl, IInner_vtbl, iface);
703 ULONG refCount = InterlockedDecrement(&This->refCount);
705 TRACE("(%p/%p)->() Release from %d\n", This, iface, refCount + 1);
707 if (!refCount)
709 IPin *pConnectedTo;
711 DestroyWindow(This->hWnd);
712 PostThreadMessageA(This->ThreadID, WM_QUIT, 0, 0);
713 WaitForSingleObject(This->hThread, INFINITE);
714 CloseHandle(This->hThread);
715 CloseHandle(This->hEvent);
717 if (This->pClock)
718 IReferenceClock_Release(This->pClock);
720 if (SUCCEEDED(IPin_ConnectedTo((IPin *)This->pInputPin, &pConnectedTo)))
722 IPin_Disconnect(pConnectedTo);
723 IPin_Release(pConnectedTo);
725 IPin_Disconnect((IPin *)This->pInputPin);
727 IPin_Release((IPin *)This->pInputPin);
729 This->lpVtbl = NULL;
731 This->csFilter.DebugInfo->Spare[0] = 0;
732 DeleteCriticalSection(&This->csFilter);
734 TRACE("Destroying Video Renderer\n");
735 CoTaskMemFree(This);
737 return 0;
739 else
740 return refCount;
743 static const IUnknownVtbl IInner_VTable =
745 VideoRendererInner_QueryInterface,
746 VideoRendererInner_AddRef,
747 VideoRendererInner_Release
750 static HRESULT WINAPI VideoRenderer_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
752 VideoRendererImpl *This = (VideoRendererImpl *)iface;
754 if (This->bAggregatable)
755 This->bUnkOuterValid = TRUE;
757 if (This->pUnkOuter)
759 if (This->bAggregatable)
760 return IUnknown_QueryInterface(This->pUnkOuter, riid, ppv);
762 if (IsEqualIID(riid, &IID_IUnknown))
764 HRESULT hr;
766 IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl));
767 hr = IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv);
768 IUnknown_Release((IUnknown *)&(This->IInner_vtbl));
769 This->bAggregatable = TRUE;
770 return hr;
773 *ppv = NULL;
774 return E_NOINTERFACE;
777 return IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv);
780 static ULONG WINAPI VideoRenderer_AddRef(IBaseFilter * iface)
782 VideoRendererImpl *This = (VideoRendererImpl *)iface;
784 if (This->pUnkOuter && This->bUnkOuterValid)
785 return IUnknown_AddRef(This->pUnkOuter);
786 return IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl));
789 static ULONG WINAPI VideoRenderer_Release(IBaseFilter * iface)
791 VideoRendererImpl *This = (VideoRendererImpl *)iface;
793 if (This->pUnkOuter && This->bUnkOuterValid)
794 return IUnknown_Release(This->pUnkOuter);
795 return IUnknown_Release((IUnknown *)&(This->IInner_vtbl));
798 /** IPersist methods **/
800 static HRESULT WINAPI VideoRenderer_GetClassID(IBaseFilter * iface, CLSID * pClsid)
802 VideoRendererImpl *This = (VideoRendererImpl *)iface;
804 TRACE("(%p/%p)->(%p)\n", This, iface, pClsid);
806 *pClsid = CLSID_VideoRenderer;
808 return S_OK;
811 /** IMediaFilter methods **/
813 static HRESULT WINAPI VideoRenderer_Stop(IBaseFilter * iface)
815 VideoRendererImpl *This = (VideoRendererImpl *)iface;
817 TRACE("(%p/%p)->()\n", This, iface);
819 EnterCriticalSection(&This->csFilter);
821 This->state = State_Stopped;
822 SetEvent(This->hEvent);
823 SetEvent(This->blocked);
825 LeaveCriticalSection(&This->csFilter);
827 return S_OK;
830 static HRESULT WINAPI VideoRenderer_Pause(IBaseFilter * iface)
832 VideoRendererImpl *This = (VideoRendererImpl *)iface;
834 TRACE("(%p/%p)->()\n", This, iface);
836 EnterCriticalSection(&This->csFilter);
837 if (This->state != State_Paused)
839 if (This->state == State_Stopped)
841 This->pInputPin->end_of_stream = 0;
842 ResetEvent(This->hEvent);
845 This->state = State_Paused;
846 ResetEvent(This->blocked);
848 LeaveCriticalSection(&This->csFilter);
850 return S_OK;
853 static HRESULT WINAPI VideoRenderer_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
855 VideoRendererImpl *This = (VideoRendererImpl *)iface;
857 TRACE("(%p/%p)->(%s)\n", This, iface, wine_dbgstr_longlong(tStart));
859 EnterCriticalSection(&This->csFilter);
860 if (This->state != State_Running)
862 if (This->state == State_Stopped)
864 This->pInputPin->end_of_stream = 0;
865 ResetEvent(This->hEvent);
867 SetEvent(This->blocked);
869 This->rtStreamStart = tStart;
870 This->state = State_Running;
872 LeaveCriticalSection(&This->csFilter);
874 return S_OK;
877 static HRESULT WINAPI VideoRenderer_GetState(IBaseFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
879 VideoRendererImpl *This = (VideoRendererImpl *)iface;
880 HRESULT hr;
882 TRACE("(%p/%p)->(%d, %p)\n", This, iface, dwMilliSecsTimeout, pState);
884 if (WaitForSingleObject(This->hEvent, dwMilliSecsTimeout) == WAIT_TIMEOUT)
885 hr = VFW_S_STATE_INTERMEDIATE;
886 else
887 hr = S_OK;
889 EnterCriticalSection(&This->csFilter);
891 *pState = This->state;
893 LeaveCriticalSection(&This->csFilter);
895 return hr;
898 static HRESULT WINAPI VideoRenderer_SetSyncSource(IBaseFilter * iface, IReferenceClock *pClock)
900 VideoRendererImpl *This = (VideoRendererImpl *)iface;
902 TRACE("(%p/%p)->(%p)\n", This, iface, pClock);
904 EnterCriticalSection(&This->csFilter);
906 if (This->pClock)
907 IReferenceClock_Release(This->pClock);
908 This->pClock = pClock;
909 if (This->pClock)
910 IReferenceClock_AddRef(This->pClock);
912 LeaveCriticalSection(&This->csFilter);
914 return S_OK;
917 static HRESULT WINAPI VideoRenderer_GetSyncSource(IBaseFilter * iface, IReferenceClock **ppClock)
919 VideoRendererImpl *This = (VideoRendererImpl *)iface;
921 TRACE("(%p/%p)->(%p)\n", This, iface, ppClock);
923 EnterCriticalSection(&This->csFilter);
925 *ppClock = This->pClock;
926 if (This->pClock)
927 IReferenceClock_AddRef(This->pClock);
929 LeaveCriticalSection(&This->csFilter);
931 return S_OK;
934 /** IBaseFilter implementation **/
936 static HRESULT VideoRenderer_GetPin(IBaseFilter *iface, ULONG pos, IPin **pin, DWORD *lastsynctick)
938 VideoRendererImpl *This = (VideoRendererImpl *)iface;
940 /* Our pins are static, not changing so setting static tick count is ok */
941 *lastsynctick = 0;
943 if (pos >= 1)
944 return S_FALSE;
946 *pin = (IPin *)This->pInputPin;
947 IPin_AddRef(*pin);
948 return S_OK;
951 static HRESULT WINAPI VideoRenderer_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum)
953 VideoRendererImpl *This = (VideoRendererImpl *)iface;
955 TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
957 return IEnumPinsImpl_Construct(ppEnum, VideoRenderer_GetPin, iface);
960 static HRESULT WINAPI VideoRenderer_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
962 VideoRendererImpl *This = (VideoRendererImpl *)iface;
964 FIXME("(%p/%p)->(%p,%p): stub !!!\n", This, iface, debugstr_w(Id), ppPin);
966 /* FIXME: critical section */
968 return E_NOTIMPL;
971 static HRESULT WINAPI VideoRenderer_QueryFilterInfo(IBaseFilter * iface, FILTER_INFO *pInfo)
973 VideoRendererImpl *This = (VideoRendererImpl *)iface;
975 TRACE("(%p/%p)->(%p)\n", This, iface, pInfo);
977 strcpyW(pInfo->achName, This->filterInfo.achName);
978 pInfo->pGraph = This->filterInfo.pGraph;
980 if (pInfo->pGraph)
981 IFilterGraph_AddRef(pInfo->pGraph);
983 return S_OK;
986 static HRESULT WINAPI VideoRenderer_JoinFilterGraph(IBaseFilter * iface, IFilterGraph *pGraph, LPCWSTR pName)
988 VideoRendererImpl *This = (VideoRendererImpl *)iface;
990 TRACE("(%p/%p)->(%p, %s)\n", This, iface, pGraph, debugstr_w(pName));
992 EnterCriticalSection(&This->csFilter);
994 if (pName)
995 strcpyW(This->filterInfo.achName, pName);
996 else
997 *This->filterInfo.achName = '\0';
998 This->filterInfo.pGraph = pGraph; /* NOTE: do NOT increase ref. count */
1000 LeaveCriticalSection(&This->csFilter);
1002 return S_OK;
1005 static HRESULT WINAPI VideoRenderer_QueryVendorInfo(IBaseFilter * iface, LPWSTR *pVendorInfo)
1007 VideoRendererImpl *This = (VideoRendererImpl *)iface;
1008 TRACE("(%p/%p)->(%p)\n", This, iface, pVendorInfo);
1009 return E_NOTIMPL;
1012 static const IBaseFilterVtbl VideoRenderer_Vtbl =
1014 VideoRenderer_QueryInterface,
1015 VideoRenderer_AddRef,
1016 VideoRenderer_Release,
1017 VideoRenderer_GetClassID,
1018 VideoRenderer_Stop,
1019 VideoRenderer_Pause,
1020 VideoRenderer_Run,
1021 VideoRenderer_GetState,
1022 VideoRenderer_SetSyncSource,
1023 VideoRenderer_GetSyncSource,
1024 VideoRenderer_EnumPins,
1025 VideoRenderer_FindPin,
1026 VideoRenderer_QueryFilterInfo,
1027 VideoRenderer_JoinFilterGraph,
1028 VideoRenderer_QueryVendorInfo
1031 static HRESULT WINAPI VideoRenderer_InputPin_EndOfStream(IPin * iface)
1033 InputPin* This = (InputPin*)iface;
1034 IMediaEventSink* pEventSink;
1035 HRESULT hr;
1037 TRACE("(%p/%p)->()\n", This, iface);
1039 hr = IFilterGraph_QueryInterface(((VideoRendererImpl*)This->pin.pinInfo.pFilter)->filterInfo.pGraph, &IID_IMediaEventSink, (LPVOID*)&pEventSink);
1040 if (SUCCEEDED(hr))
1042 hr = IMediaEventSink_Notify(pEventSink, EC_COMPLETE, S_OK, 0);
1043 IMediaEventSink_Release(pEventSink);
1046 return hr;
1049 static HRESULT WINAPI VideoRenderer_InputPin_BeginFlush(IPin * iface)
1051 InputPin* This = (InputPin*)iface;
1052 VideoRendererImpl *pVideoRenderer = (VideoRendererImpl *)This->pin.pinInfo.pFilter;
1053 HRESULT hr;
1055 TRACE("(%p/%p)->()\n", This, iface);
1057 EnterCriticalSection(This->pin.pCritSec);
1058 if (pVideoRenderer->state == State_Paused)
1059 SetEvent(pVideoRenderer->blocked);
1061 hr = InputPin_BeginFlush(iface);
1062 LeaveCriticalSection(This->pin.pCritSec);
1064 return hr;
1067 static HRESULT WINAPI VideoRenderer_InputPin_EndFlush(IPin * iface)
1069 InputPin* This = (InputPin*)iface;
1070 VideoRendererImpl *pVideoRenderer = (VideoRendererImpl *)This->pin.pinInfo.pFilter;
1071 HRESULT hr;
1073 TRACE("(%p/%p)->()\n", This, iface);
1075 EnterCriticalSection(This->pin.pCritSec);
1076 if (pVideoRenderer->state == State_Paused)
1077 ResetEvent(pVideoRenderer->blocked);
1079 hr = InputPin_EndFlush(iface);
1080 LeaveCriticalSection(This->pin.pCritSec);
1082 return hr;
1085 static const IPinVtbl VideoRenderer_InputPin_Vtbl =
1087 InputPin_QueryInterface,
1088 IPinImpl_AddRef,
1089 InputPin_Release,
1090 InputPin_Connect,
1091 InputPin_ReceiveConnection,
1092 IPinImpl_Disconnect,
1093 IPinImpl_ConnectedTo,
1094 IPinImpl_ConnectionMediaType,
1095 IPinImpl_QueryPinInfo,
1096 IPinImpl_QueryDirection,
1097 IPinImpl_QueryId,
1098 IPinImpl_QueryAccept,
1099 IPinImpl_EnumMediaTypes,
1100 IPinImpl_QueryInternalConnections,
1101 VideoRenderer_InputPin_EndOfStream,
1102 VideoRenderer_InputPin_BeginFlush,
1103 VideoRenderer_InputPin_EndFlush,
1104 InputPin_NewSegment
1107 /*** IUnknown methods ***/
1108 static HRESULT WINAPI Basicvideo_QueryInterface(IBasicVideo *iface,
1109 REFIID riid,
1110 LPVOID*ppvObj) {
1111 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1113 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1115 return VideoRenderer_QueryInterface((IBaseFilter*)This, riid, ppvObj);
1118 static ULONG WINAPI Basicvideo_AddRef(IBasicVideo *iface) {
1119 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1121 TRACE("(%p/%p)->()\n", This, iface);
1123 return VideoRenderer_AddRef((IBaseFilter*)This);
1126 static ULONG WINAPI Basicvideo_Release(IBasicVideo *iface) {
1127 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1129 TRACE("(%p/%p)->()\n", This, iface);
1131 return VideoRenderer_Release((IBaseFilter*)This);
1134 /*** IDispatch methods ***/
1135 static HRESULT WINAPI Basicvideo_GetTypeInfoCount(IBasicVideo *iface,
1136 UINT*pctinfo) {
1137 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1139 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1141 return S_OK;
1144 static HRESULT WINAPI Basicvideo_GetTypeInfo(IBasicVideo *iface,
1145 UINT iTInfo,
1146 LCID lcid,
1147 ITypeInfo**ppTInfo) {
1148 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1150 FIXME("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1152 return S_OK;
1155 static HRESULT WINAPI Basicvideo_GetIDsOfNames(IBasicVideo *iface,
1156 REFIID riid,
1157 LPOLESTR*rgszNames,
1158 UINT cNames,
1159 LCID lcid,
1160 DISPID*rgDispId) {
1161 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1163 FIXME("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
1165 return S_OK;
1168 static HRESULT WINAPI Basicvideo_Invoke(IBasicVideo *iface,
1169 DISPID dispIdMember,
1170 REFIID riid,
1171 LCID lcid,
1172 WORD wFlags,
1173 DISPPARAMS*pDispParams,
1174 VARIANT*pVarResult,
1175 EXCEPINFO*pExepInfo,
1176 UINT*puArgErr) {
1177 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1179 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);
1181 return S_OK;
1184 /*** IBasicVideo methods ***/
1185 static HRESULT WINAPI Basicvideo_get_AvgTimePerFrame(IBasicVideo *iface,
1186 REFTIME *pAvgTimePerFrame) {
1187 AM_MEDIA_TYPE *pmt;
1188 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1190 if (!This->pInputPin->pin.pConnectedTo)
1191 return VFW_E_NOT_CONNECTED;
1193 TRACE("(%p/%p)->(%p)\n", This, iface, pAvgTimePerFrame);
1195 pmt = &This->pInputPin->pin.mtCurrent;
1196 if (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo)) {
1197 VIDEOINFOHEADER *vih = (VIDEOINFOHEADER*)pmt->pbFormat;
1198 *pAvgTimePerFrame = vih->AvgTimePerFrame;
1199 } else if (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo2)) {
1200 VIDEOINFOHEADER2 *vih = (VIDEOINFOHEADER2*)pmt->pbFormat;
1201 *pAvgTimePerFrame = vih->AvgTimePerFrame;
1202 } else {
1203 ERR("Unknown format type %s\n", qzdebugstr_guid(&pmt->formattype));
1204 *pAvgTimePerFrame = 0;
1206 return S_OK;
1209 static HRESULT WINAPI Basicvideo_get_BitRate(IBasicVideo *iface,
1210 LONG *pBitRate) {
1211 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1213 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBitRate);
1215 return S_OK;
1218 static HRESULT WINAPI Basicvideo_get_BitErrorRate(IBasicVideo *iface,
1219 LONG *pBitErrorRate) {
1220 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1222 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBitErrorRate);
1224 return S_OK;
1227 static HRESULT WINAPI Basicvideo_get_VideoWidth(IBasicVideo *iface,
1228 LONG *pVideoWidth) {
1229 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1231 TRACE("(%p/%p)->(%p)\n", This, iface, pVideoWidth);
1233 *pVideoWidth = This->VideoWidth;
1235 return S_OK;
1238 static HRESULT WINAPI Basicvideo_get_VideoHeight(IBasicVideo *iface,
1239 LONG *pVideoHeight) {
1240 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1242 TRACE("(%p/%p)->(%p)\n", This, iface, pVideoHeight);
1244 *pVideoHeight = This->VideoHeight;
1246 return S_OK;
1249 static HRESULT WINAPI Basicvideo_put_SourceLeft(IBasicVideo *iface,
1250 LONG SourceLeft) {
1251 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1253 TRACE("(%p/%p)->(%d)\n", This, iface, SourceLeft);
1255 This->SourceRect.left = SourceLeft;
1257 return S_OK;
1260 static HRESULT WINAPI Basicvideo_get_SourceLeft(IBasicVideo *iface,
1261 LONG *pSourceLeft) {
1262 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1264 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceLeft);
1266 *pSourceLeft = This->SourceRect.left;
1268 return S_OK;
1271 static HRESULT WINAPI Basicvideo_put_SourceWidth(IBasicVideo *iface,
1272 LONG SourceWidth) {
1273 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1275 TRACE("(%p/%p)->(%d)\n", This, iface, SourceWidth);
1277 This->SourceRect.right = This->SourceRect.left + SourceWidth;
1279 return S_OK;
1282 static HRESULT WINAPI Basicvideo_get_SourceWidth(IBasicVideo *iface,
1283 LONG *pSourceWidth) {
1284 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1286 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceWidth);
1288 *pSourceWidth = This->SourceRect.right - This->SourceRect.left;
1290 return S_OK;
1293 static HRESULT WINAPI Basicvideo_put_SourceTop(IBasicVideo *iface,
1294 LONG SourceTop) {
1295 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1297 TRACE("(%p/%p)->(%d)\n", This, iface, SourceTop);
1299 This->SourceRect.top = SourceTop;
1301 return S_OK;
1304 static HRESULT WINAPI Basicvideo_get_SourceTop(IBasicVideo *iface,
1305 LONG *pSourceTop) {
1306 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1308 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceTop);
1310 *pSourceTop = This->SourceRect.top;
1312 return S_OK;
1315 static HRESULT WINAPI Basicvideo_put_SourceHeight(IBasicVideo *iface,
1316 LONG SourceHeight) {
1317 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1319 TRACE("(%p/%p)->(%d)\n", This, iface, SourceHeight);
1321 This->SourceRect.bottom = This->SourceRect.top + SourceHeight;
1323 return S_OK;
1326 static HRESULT WINAPI Basicvideo_get_SourceHeight(IBasicVideo *iface,
1327 LONG *pSourceHeight) {
1328 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1330 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceHeight);
1332 *pSourceHeight = This->SourceRect.bottom - This->SourceRect.top;
1334 return S_OK;
1337 static HRESULT WINAPI Basicvideo_put_DestinationLeft(IBasicVideo *iface,
1338 LONG DestinationLeft) {
1339 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1341 TRACE("(%p/%p)->(%d)\n", This, iface, DestinationLeft);
1343 This->DestRect.left = DestinationLeft;
1345 return S_OK;
1348 static HRESULT WINAPI Basicvideo_get_DestinationLeft(IBasicVideo *iface,
1349 LONG *pDestinationLeft) {
1350 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1352 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationLeft);
1354 *pDestinationLeft = This->DestRect.left;
1356 return S_OK;
1359 static HRESULT WINAPI Basicvideo_put_DestinationWidth(IBasicVideo *iface,
1360 LONG DestinationWidth) {
1361 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1363 TRACE("(%p/%p)->(%d)\n", This, iface, DestinationWidth);
1365 This->DestRect.right = This->DestRect.left + DestinationWidth;
1367 return S_OK;
1370 static HRESULT WINAPI Basicvideo_get_DestinationWidth(IBasicVideo *iface,
1371 LONG *pDestinationWidth) {
1372 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1374 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationWidth);
1376 *pDestinationWidth = This->DestRect.right - This->DestRect.left;
1378 return S_OK;
1381 static HRESULT WINAPI Basicvideo_put_DestinationTop(IBasicVideo *iface,
1382 LONG DestinationTop) {
1383 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1385 TRACE("(%p/%p)->(%d)\n", This, iface, DestinationTop);
1387 This->DestRect.top = DestinationTop;
1389 return S_OK;
1392 static HRESULT WINAPI Basicvideo_get_DestinationTop(IBasicVideo *iface,
1393 LONG *pDestinationTop) {
1394 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1396 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationTop);
1398 *pDestinationTop = This->DestRect.top;
1400 return S_OK;
1403 static HRESULT WINAPI Basicvideo_put_DestinationHeight(IBasicVideo *iface,
1404 LONG DestinationHeight) {
1405 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1407 TRACE("(%p/%p)->(%d)\n", This, iface, DestinationHeight);
1409 This->DestRect.right = This->DestRect.left + DestinationHeight;
1411 return S_OK;
1414 static HRESULT WINAPI Basicvideo_get_DestinationHeight(IBasicVideo *iface,
1415 LONG *pDestinationHeight) {
1416 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1418 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationHeight);
1420 *pDestinationHeight = This->DestRect.right - This->DestRect.left;
1422 return S_OK;
1425 static HRESULT WINAPI Basicvideo_SetSourcePosition(IBasicVideo *iface,
1426 LONG Left,
1427 LONG Top,
1428 LONG Width,
1429 LONG Height) {
1430 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1432 TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
1434 This->SourceRect.left = Left;
1435 This->SourceRect.top = Top;
1436 This->SourceRect.right = Left + Width;
1437 This->SourceRect.bottom = Top + Height;
1439 return S_OK;
1442 static HRESULT WINAPI Basicvideo_GetSourcePosition(IBasicVideo *iface,
1443 LONG *pLeft,
1444 LONG *pTop,
1445 LONG *pWidth,
1446 LONG *pHeight) {
1447 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1449 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
1451 *pLeft = This->SourceRect.left;
1452 *pTop = This->SourceRect.top;
1453 *pWidth = This->SourceRect.right - This->SourceRect.left;
1454 *pHeight = This->SourceRect.bottom - This->SourceRect.top;
1456 return S_OK;
1459 static HRESULT WINAPI Basicvideo_SetDefaultSourcePosition(IBasicVideo *iface) {
1460 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1462 TRACE("(%p/%p)->()\n", This, iface);
1464 This->SourceRect.left = 0;
1465 This->SourceRect.top = 0;
1466 This->SourceRect.right = This->VideoWidth;
1467 This->SourceRect.bottom = This->VideoHeight;
1469 return S_OK;
1472 static HRESULT WINAPI Basicvideo_SetDestinationPosition(IBasicVideo *iface,
1473 LONG Left,
1474 LONG Top,
1475 LONG Width,
1476 LONG Height) {
1477 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1479 TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
1481 This->DestRect.left = Left;
1482 This->DestRect.top = Top;
1483 This->DestRect.right = Left + Width;
1484 This->DestRect.bottom = Top + Height;
1486 return S_OK;
1489 static HRESULT WINAPI Basicvideo_GetDestinationPosition(IBasicVideo *iface,
1490 LONG *pLeft,
1491 LONG *pTop,
1492 LONG *pWidth,
1493 LONG *pHeight) {
1494 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1496 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
1498 *pLeft = This->DestRect.left;
1499 *pTop = This->DestRect.top;
1500 *pWidth = This->DestRect.right - This->DestRect.left;
1501 *pHeight = This->DestRect.bottom - This->DestRect.top;
1503 return S_OK;
1506 static HRESULT WINAPI Basicvideo_SetDefaultDestinationPosition(IBasicVideo *iface) {
1507 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1508 RECT rect;
1510 TRACE("(%p/%p)->()\n", This, iface);
1512 if (!GetClientRect(This->hWnd, &rect))
1513 return E_FAIL;
1515 This->SourceRect.left = 0;
1516 This->SourceRect.top = 0;
1517 This->SourceRect.right = rect.right;
1518 This->SourceRect.bottom = rect.bottom;
1520 return S_OK;
1523 static HRESULT WINAPI Basicvideo_GetVideoSize(IBasicVideo *iface,
1524 LONG *pWidth,
1525 LONG *pHeight) {
1526 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1528 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
1530 *pWidth = This->VideoWidth;
1531 *pHeight = This->VideoHeight;
1533 return S_OK;
1536 static HRESULT WINAPI Basicvideo_GetVideoPaletteEntries(IBasicVideo *iface,
1537 LONG StartIndex,
1538 LONG Entries,
1539 LONG *pRetrieved,
1540 LONG *pPalette) {
1541 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1543 FIXME("(%p/%p)->(%d, %d, %p, %p): stub !!!\n", This, iface, StartIndex, Entries, pRetrieved, pPalette);
1545 return S_OK;
1548 static HRESULT WINAPI Basicvideo_GetCurrentImage(IBasicVideo *iface,
1549 LONG *pBufferSize,
1550 LONG *pDIBImage) {
1551 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1552 BITMAPINFOHEADER *bmiHeader;
1553 LONG needed_size;
1554 AM_MEDIA_TYPE *amt = &This->pInputPin->pin.mtCurrent;
1555 char *ptr;
1557 FIXME("(%p/%p)->(%p, %p): partial stub\n", This, iface, pBufferSize, pDIBImage);
1559 EnterCriticalSection(&This->csFilter);
1561 if (!This->sample_held)
1563 LeaveCriticalSection(&This->csFilter);
1564 return (This->state == State_Paused ? E_UNEXPECTED : VFW_E_NOT_PAUSED);
1567 if (IsEqualIID(&amt->formattype, &FORMAT_VideoInfo))
1569 bmiHeader = &((VIDEOINFOHEADER *)amt->pbFormat)->bmiHeader;
1571 else if (IsEqualIID(&amt->formattype, &FORMAT_VideoInfo2))
1573 bmiHeader = &((VIDEOINFOHEADER2 *)amt->pbFormat)->bmiHeader;
1575 else
1577 FIXME("Unknown type %s\n", debugstr_guid(&amt->subtype));
1578 LeaveCriticalSection(&This->csFilter);
1579 return VFW_E_RUNTIME_ERROR;
1582 needed_size = bmiHeader->biSize;
1583 needed_size += IMediaSample_GetActualDataLength(This->sample_held);
1585 if (!pDIBImage)
1587 *pBufferSize = needed_size;
1588 LeaveCriticalSection(&This->csFilter);
1589 return S_OK;
1592 if (needed_size < *pBufferSize)
1594 ERR("Buffer too small %u/%u\n", needed_size, *pBufferSize);
1595 LeaveCriticalSection(&This->csFilter);
1596 return E_FAIL;
1598 *pBufferSize = needed_size;
1600 memcpy(pDIBImage, bmiHeader, bmiHeader->biSize);
1601 IMediaSample_GetPointer(This->sample_held, (BYTE **)&ptr);
1602 memcpy((char *)pDIBImage + bmiHeader->biSize, ptr, IMediaSample_GetActualDataLength(This->sample_held));
1604 LeaveCriticalSection(&This->csFilter);
1606 return S_OK;
1609 static HRESULT WINAPI Basicvideo_IsUsingDefaultSource(IBasicVideo *iface) {
1610 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1612 FIXME("(%p/%p)->(): stub !!!\n", This, iface);
1614 return S_OK;
1617 static HRESULT WINAPI Basicvideo_IsUsingDefaultDestination(IBasicVideo *iface) {
1618 ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1620 FIXME("(%p/%p)->(): stub !!!\n", This, iface);
1622 return S_OK;
1626 static const IBasicVideoVtbl IBasicVideo_VTable =
1628 Basicvideo_QueryInterface,
1629 Basicvideo_AddRef,
1630 Basicvideo_Release,
1631 Basicvideo_GetTypeInfoCount,
1632 Basicvideo_GetTypeInfo,
1633 Basicvideo_GetIDsOfNames,
1634 Basicvideo_Invoke,
1635 Basicvideo_get_AvgTimePerFrame,
1636 Basicvideo_get_BitRate,
1637 Basicvideo_get_BitErrorRate,
1638 Basicvideo_get_VideoWidth,
1639 Basicvideo_get_VideoHeight,
1640 Basicvideo_put_SourceLeft,
1641 Basicvideo_get_SourceLeft,
1642 Basicvideo_put_SourceWidth,
1643 Basicvideo_get_SourceWidth,
1644 Basicvideo_put_SourceTop,
1645 Basicvideo_get_SourceTop,
1646 Basicvideo_put_SourceHeight,
1647 Basicvideo_get_SourceHeight,
1648 Basicvideo_put_DestinationLeft,
1649 Basicvideo_get_DestinationLeft,
1650 Basicvideo_put_DestinationWidth,
1651 Basicvideo_get_DestinationWidth,
1652 Basicvideo_put_DestinationTop,
1653 Basicvideo_get_DestinationTop,
1654 Basicvideo_put_DestinationHeight,
1655 Basicvideo_get_DestinationHeight,
1656 Basicvideo_SetSourcePosition,
1657 Basicvideo_GetSourcePosition,
1658 Basicvideo_SetDefaultSourcePosition,
1659 Basicvideo_SetDestinationPosition,
1660 Basicvideo_GetDestinationPosition,
1661 Basicvideo_SetDefaultDestinationPosition,
1662 Basicvideo_GetVideoSize,
1663 Basicvideo_GetVideoPaletteEntries,
1664 Basicvideo_GetCurrentImage,
1665 Basicvideo_IsUsingDefaultSource,
1666 Basicvideo_IsUsingDefaultDestination
1670 /*** IUnknown methods ***/
1671 static HRESULT WINAPI Videowindow_QueryInterface(IVideoWindow *iface,
1672 REFIID riid,
1673 LPVOID*ppvObj) {
1674 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1676 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1678 return VideoRenderer_QueryInterface((IBaseFilter*)This, riid, ppvObj);
1681 static ULONG WINAPI Videowindow_AddRef(IVideoWindow *iface) {
1682 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1684 TRACE("(%p/%p)->()\n", This, iface);
1686 return VideoRenderer_AddRef((IBaseFilter*)This);
1689 static ULONG WINAPI Videowindow_Release(IVideoWindow *iface) {
1690 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1692 TRACE("(%p/%p)->()\n", This, iface);
1694 return VideoRenderer_Release((IBaseFilter*)This);
1697 /*** IDispatch methods ***/
1698 static HRESULT WINAPI Videowindow_GetTypeInfoCount(IVideoWindow *iface,
1699 UINT*pctinfo) {
1700 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1702 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1704 return S_OK;
1707 static HRESULT WINAPI Videowindow_GetTypeInfo(IVideoWindow *iface,
1708 UINT iTInfo,
1709 LCID lcid,
1710 ITypeInfo**ppTInfo) {
1711 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1713 FIXME("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1715 return S_OK;
1718 static HRESULT WINAPI Videowindow_GetIDsOfNames(IVideoWindow *iface,
1719 REFIID riid,
1720 LPOLESTR*rgszNames,
1721 UINT cNames,
1722 LCID lcid,
1723 DISPID*rgDispId) {
1724 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1726 FIXME("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
1728 return S_OK;
1731 static HRESULT WINAPI Videowindow_Invoke(IVideoWindow *iface,
1732 DISPID dispIdMember,
1733 REFIID riid,
1734 LCID lcid,
1735 WORD wFlags,
1736 DISPPARAMS*pDispParams,
1737 VARIANT*pVarResult,
1738 EXCEPINFO*pExepInfo,
1739 UINT*puArgErr) {
1740 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1742 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);
1744 return S_OK;
1747 /*** IVideoWindow methods ***/
1748 static HRESULT WINAPI Videowindow_put_Caption(IVideoWindow *iface,
1749 BSTR strCaption) {
1750 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1752 TRACE("(%p/%p)->(%s (%p))\n", This, iface, debugstr_w(strCaption), strCaption);
1754 if (!SetWindowTextW(This->hWnd, strCaption))
1755 return E_FAIL;
1757 return S_OK;
1760 static HRESULT WINAPI Videowindow_get_Caption(IVideoWindow *iface,
1761 BSTR *strCaption) {
1762 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1764 TRACE("(%p/%p)->(%p)\n", This, iface, strCaption);
1766 GetWindowTextW(This->hWnd, (LPWSTR)strCaption, 100);
1768 return S_OK;
1771 static HRESULT WINAPI Videowindow_put_WindowStyle(IVideoWindow *iface,
1772 LONG WindowStyle) {
1773 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1774 LONG old;
1776 old = GetWindowLongA(This->hWnd, GWL_STYLE);
1778 TRACE("(%p/%p)->(%x -> %x)\n", This, iface, old, WindowStyle);
1780 if (WindowStyle & (WS_DISABLED|WS_HSCROLL|WS_ICONIC|WS_MAXIMIZE|WS_MINIMIZE|WS_VSCROLL))
1781 return E_INVALIDARG;
1783 SetWindowLongA(This->hWnd, GWL_STYLE, WindowStyle);
1785 return S_OK;
1788 static HRESULT WINAPI Videowindow_get_WindowStyle(IVideoWindow *iface,
1789 LONG *WindowStyle) {
1790 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1792 TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyle);
1794 *WindowStyle = GetWindowLongA(This->hWnd, GWL_STYLE);
1796 return S_OK;
1799 static HRESULT WINAPI Videowindow_put_WindowStyleEx(IVideoWindow *iface,
1800 LONG WindowStyleEx) {
1801 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1803 TRACE("(%p/%p)->(%d)\n", This, iface, WindowStyleEx);
1805 if (!SetWindowLongA(This->hWnd, GWL_EXSTYLE, WindowStyleEx))
1806 return E_FAIL;
1808 return S_OK;
1811 static HRESULT WINAPI Videowindow_get_WindowStyleEx(IVideoWindow *iface,
1812 LONG *WindowStyleEx) {
1813 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1815 TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyleEx);
1817 *WindowStyleEx = GetWindowLongA(This->hWnd, GWL_EXSTYLE);
1819 return S_OK;
1822 static HRESULT WINAPI Videowindow_put_AutoShow(IVideoWindow *iface,
1823 LONG AutoShow) {
1824 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1826 TRACE("(%p/%p)->(%d)\n", This, iface, AutoShow);
1828 This->AutoShow = AutoShow;
1830 return S_OK;
1833 static HRESULT WINAPI Videowindow_get_AutoShow(IVideoWindow *iface,
1834 LONG *AutoShow) {
1835 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1837 TRACE("(%p/%p)->(%p)\n", This, iface, AutoShow);
1839 *AutoShow = This->AutoShow;
1841 return S_OK;
1844 static HRESULT WINAPI Videowindow_put_WindowState(IVideoWindow *iface,
1845 LONG WindowState) {
1846 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1848 TRACE("(%p/%p)->(%d)\n", This, iface, WindowState);
1849 ShowWindow(This->hWnd, WindowState);
1850 return S_OK;
1853 static HRESULT WINAPI Videowindow_get_WindowState(IVideoWindow *iface,
1854 LONG *WindowState) {
1855 WINDOWPLACEMENT place;
1856 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1858 place.length = sizeof(place);
1859 GetWindowPlacement(This->hWnd, &place);
1860 TRACE("(%p/%p)->(%p)\n", This, iface, WindowState);
1861 *WindowState = place.showCmd;
1863 return S_OK;
1866 static HRESULT WINAPI Videowindow_put_BackgroundPalette(IVideoWindow *iface,
1867 LONG BackgroundPalette) {
1868 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1870 FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, BackgroundPalette);
1872 return S_OK;
1875 static HRESULT WINAPI Videowindow_get_BackgroundPalette(IVideoWindow *iface,
1876 LONG *pBackgroundPalette) {
1877 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1879 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBackgroundPalette);
1881 return S_OK;
1884 static HRESULT WINAPI Videowindow_put_Visible(IVideoWindow *iface,
1885 LONG Visible) {
1886 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1888 TRACE("(%p/%p)->(%d)\n", This, iface, Visible);
1890 ShowWindow(This->hWnd, Visible ? SW_SHOW : SW_HIDE);
1892 return S_OK;
1895 static HRESULT WINAPI Videowindow_get_Visible(IVideoWindow *iface,
1896 LONG *pVisible) {
1897 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1899 TRACE("(%p/%p)->(%p)\n", This, iface, pVisible);
1901 *pVisible = IsWindowVisible(This->hWnd);
1903 return S_OK;
1906 static HRESULT WINAPI Videowindow_put_Left(IVideoWindow *iface,
1907 LONG Left) {
1908 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1910 TRACE("(%p/%p)->(%d)\n", This, iface, Left);
1912 if (!SetWindowPos(This->hWnd, NULL, Left, This->WindowPos.top, 0, 0, SWP_NOZORDER|SWP_NOSIZE))
1913 return E_FAIL;
1915 This->WindowPos.left = Left;
1917 return S_OK;
1920 static HRESULT WINAPI Videowindow_get_Left(IVideoWindow *iface,
1921 LONG *pLeft) {
1922 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1924 TRACE("(%p/%p)->(%p)\n", This, iface, pLeft);
1926 *pLeft = This->WindowPos.left;
1928 return S_OK;
1931 static HRESULT WINAPI Videowindow_put_Width(IVideoWindow *iface,
1932 LONG Width) {
1933 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1935 TRACE("(%p/%p)->(%d)\n", This, iface, Width);
1937 if (!SetWindowPos(This->hWnd, NULL, 0, 0, Width, This->WindowPos.bottom-This->WindowPos.top, SWP_NOZORDER|SWP_NOMOVE))
1938 return E_FAIL;
1940 This->WindowPos.right = This->WindowPos.left + Width;
1942 return S_OK;
1945 static HRESULT WINAPI Videowindow_get_Width(IVideoWindow *iface,
1946 LONG *pWidth) {
1947 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1949 TRACE("(%p/%p)->(%p)\n", This, iface, pWidth);
1951 *pWidth = This->WindowPos.right - This->WindowPos.left;
1953 return S_OK;
1956 static HRESULT WINAPI Videowindow_put_Top(IVideoWindow *iface,
1957 LONG Top) {
1958 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1960 TRACE("(%p/%p)->(%d)\n", This, iface, Top);
1962 if (!SetWindowPos(This->hWnd, NULL, This->WindowPos.left, Top, 0, 0, SWP_NOZORDER|SWP_NOSIZE))
1963 return E_FAIL;
1965 This->WindowPos.top = Top;
1967 return S_OK;
1970 static HRESULT WINAPI Videowindow_get_Top(IVideoWindow *iface,
1971 LONG *pTop) {
1972 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1974 TRACE("(%p/%p)->(%p)\n", This, iface, pTop);
1976 *pTop = This->WindowPos.top;
1978 return S_OK;
1981 static HRESULT WINAPI Videowindow_put_Height(IVideoWindow *iface,
1982 LONG Height) {
1983 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1985 TRACE("(%p/%p)->(%d)\n", This, iface, Height);
1987 if (!SetWindowPos(This->hWnd, NULL, 0, 0, This->WindowPos.right-This->WindowPos.left, Height, SWP_NOZORDER|SWP_NOMOVE))
1988 return E_FAIL;
1990 This->WindowPos.bottom = This->WindowPos.top + Height;
1992 return S_OK;
1995 static HRESULT WINAPI Videowindow_get_Height(IVideoWindow *iface,
1996 LONG *pHeight) {
1997 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1999 TRACE("(%p/%p)->(%p)\n", This, iface, pHeight);
2001 *pHeight = This->WindowPos.bottom - This->WindowPos.top;
2003 return S_OK;
2006 static HRESULT WINAPI Videowindow_put_Owner(IVideoWindow *iface,
2007 OAHWND Owner) {
2008 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2010 TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Owner);
2012 SetParent(This->hWnd, (HWND)Owner);
2014 return S_OK;
2017 static HRESULT WINAPI Videowindow_get_Owner(IVideoWindow *iface,
2018 OAHWND *Owner) {
2019 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2021 TRACE("(%p/%p)->(%p)\n", This, iface, Owner);
2023 *(HWND*)Owner = GetParent(This->hWnd);
2025 return S_OK;
2028 static HRESULT WINAPI Videowindow_put_MessageDrain(IVideoWindow *iface,
2029 OAHWND Drain) {
2030 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2032 TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Drain);
2034 This->hWndMsgDrain = (HWND)Drain;
2036 return S_OK;
2039 static HRESULT WINAPI Videowindow_get_MessageDrain(IVideoWindow *iface,
2040 OAHWND *Drain) {
2041 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2043 TRACE("(%p/%p)->(%p)\n", This, iface, Drain);
2045 *Drain = (OAHWND)This->hWndMsgDrain;
2047 return S_OK;
2050 static HRESULT WINAPI Videowindow_get_BorderColor(IVideoWindow *iface,
2051 LONG *Color) {
2052 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2054 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, Color);
2056 return S_OK;
2059 static HRESULT WINAPI Videowindow_put_BorderColor(IVideoWindow *iface,
2060 LONG Color) {
2061 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2063 FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, Color);
2065 return S_OK;
2068 static HRESULT WINAPI Videowindow_get_FullScreenMode(IVideoWindow *iface,
2069 LONG *FullScreenMode) {
2070 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2072 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, FullScreenMode);
2074 return S_OK;
2077 static HRESULT WINAPI Videowindow_put_FullScreenMode(IVideoWindow *iface,
2078 LONG FullScreenMode) {
2079 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2081 FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, FullScreenMode);
2083 return S_OK;
2086 static HRESULT WINAPI Videowindow_SetWindowForeground(IVideoWindow *iface,
2087 LONG Focus) {
2088 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2089 BOOL ret;
2090 IPin* pPin;
2091 HRESULT hr;
2093 TRACE("(%p/%p)->(%d)\n", This, iface, Focus);
2095 if ((Focus != FALSE) && (Focus != TRUE))
2096 return E_INVALIDARG;
2098 hr = IPin_ConnectedTo((IPin *)This->pInputPin, &pPin);
2099 if ((hr != S_OK) || !pPin)
2100 return VFW_E_NOT_CONNECTED;
2102 if (Focus)
2103 ret = SetForegroundWindow(This->hWnd);
2104 else
2105 ret = SetWindowPos(This->hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
2107 if (!ret)
2108 return E_FAIL;
2110 return S_OK;
2113 static HRESULT WINAPI Videowindow_NotifyOwnerMessage(IVideoWindow *iface,
2114 OAHWND hwnd,
2115 LONG uMsg,
2116 LONG_PTR wParam,
2117 LONG_PTR lParam) {
2118 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2120 TRACE("(%p/%p)->(%08lx, %d, %08lx, %08lx)\n", This, iface, hwnd, uMsg, wParam, lParam);
2122 if (!PostMessageA(This->hWnd, uMsg, wParam, lParam))
2123 return E_FAIL;
2125 return S_OK;
2128 static HRESULT WINAPI Videowindow_SetWindowPosition(IVideoWindow *iface,
2129 LONG Left,
2130 LONG Top,
2131 LONG Width,
2132 LONG Height) {
2133 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2135 TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
2137 if (!SetWindowPos(This->hWnd, NULL, Left, Top, Width, Height, SWP_NOZORDER))
2138 return E_FAIL;
2140 This->WindowPos.left = Left;
2141 This->WindowPos.top = Top;
2142 This->WindowPos.right = Left + Width;
2143 This->WindowPos.bottom = Top + Height;
2145 return S_OK;
2148 static HRESULT WINAPI Videowindow_GetWindowPosition(IVideoWindow *iface,
2149 LONG *pLeft,
2150 LONG *pTop,
2151 LONG *pWidth,
2152 LONG *pHeight) {
2153 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2155 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
2157 *pLeft = This->WindowPos.left;
2158 *pTop = This->WindowPos.top;
2159 *pWidth = This->WindowPos.right - This->WindowPos.left;
2160 *pHeight = This->WindowPos.bottom - This->WindowPos.top;
2162 return S_OK;
2165 static HRESULT WINAPI Videowindow_GetMinIdealImageSize(IVideoWindow *iface,
2166 LONG *pWidth,
2167 LONG *pHeight) {
2168 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2170 FIXME("(%p/%p)->(%p, %p): semi stub !!!\n", This, iface, pWidth, pHeight);
2172 *pWidth = This->VideoWidth;
2173 *pHeight = This->VideoHeight;
2175 return S_OK;
2178 static HRESULT WINAPI Videowindow_GetMaxIdealImageSize(IVideoWindow *iface,
2179 LONG *pWidth,
2180 LONG *pHeight) {
2181 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2183 FIXME("(%p/%p)->(%p, %p): semi stub !!!\n", This, iface, pWidth, pHeight);
2185 *pWidth = This->VideoWidth;
2186 *pHeight = This->VideoHeight;
2188 return S_OK;
2191 static HRESULT WINAPI Videowindow_GetRestorePosition(IVideoWindow *iface,
2192 LONG *pLeft,
2193 LONG *pTop,
2194 LONG *pWidth,
2195 LONG *pHeight) {
2196 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2198 FIXME("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight);
2200 return S_OK;
2203 static HRESULT WINAPI Videowindow_HideCursor(IVideoWindow *iface,
2204 LONG HideCursor) {
2205 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2207 FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, HideCursor);
2209 return S_OK;
2212 static HRESULT WINAPI Videowindow_IsCursorHidden(IVideoWindow *iface,
2213 LONG *CursorHidden) {
2214 ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2216 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, CursorHidden);
2218 return S_OK;
2221 static const IVideoWindowVtbl IVideoWindow_VTable =
2223 Videowindow_QueryInterface,
2224 Videowindow_AddRef,
2225 Videowindow_Release,
2226 Videowindow_GetTypeInfoCount,
2227 Videowindow_GetTypeInfo,
2228 Videowindow_GetIDsOfNames,
2229 Videowindow_Invoke,
2230 Videowindow_put_Caption,
2231 Videowindow_get_Caption,
2232 Videowindow_put_WindowStyle,
2233 Videowindow_get_WindowStyle,
2234 Videowindow_put_WindowStyleEx,
2235 Videowindow_get_WindowStyleEx,
2236 Videowindow_put_AutoShow,
2237 Videowindow_get_AutoShow,
2238 Videowindow_put_WindowState,
2239 Videowindow_get_WindowState,
2240 Videowindow_put_BackgroundPalette,
2241 Videowindow_get_BackgroundPalette,
2242 Videowindow_put_Visible,
2243 Videowindow_get_Visible,
2244 Videowindow_put_Left,
2245 Videowindow_get_Left,
2246 Videowindow_put_Width,
2247 Videowindow_get_Width,
2248 Videowindow_put_Top,
2249 Videowindow_get_Top,
2250 Videowindow_put_Height,
2251 Videowindow_get_Height,
2252 Videowindow_put_Owner,
2253 Videowindow_get_Owner,
2254 Videowindow_put_MessageDrain,
2255 Videowindow_get_MessageDrain,
2256 Videowindow_get_BorderColor,
2257 Videowindow_put_BorderColor,
2258 Videowindow_get_FullScreenMode,
2259 Videowindow_put_FullScreenMode,
2260 Videowindow_SetWindowForeground,
2261 Videowindow_NotifyOwnerMessage,
2262 Videowindow_SetWindowPosition,
2263 Videowindow_GetWindowPosition,
2264 Videowindow_GetMinIdealImageSize,
2265 Videowindow_GetMaxIdealImageSize,
2266 Videowindow_GetRestorePosition,
2267 Videowindow_HideCursor,
2268 Videowindow_IsCursorHidden