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