git.oblomov.eu Git - wine/blob - 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     AM_MEDIA_TYPE *pmt;
1180     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1181
1182     if (!This->pInputPin->pin.pConnectedTo)
1183         return VFW_E_NOT_CONNECTED;
1184
1185     TRACE("(%p/%p)->(%p)\n", This, iface, pAvgTimePerFrame);
1186
1187     pmt = &This->pInputPin->pin.mtCurrent;
1188     if (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo)) {
1189         VIDEOINFOHEADER *vih = (VIDEOINFOHEADER*)pmt->pbFormat;
1190         *pAvgTimePerFrame = vih->AvgTimePerFrame;
1191     } else if (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo2)) {
1192         VIDEOINFOHEADER2 *vih = (VIDEOINFOHEADER2*)pmt->pbFormat;
1193         *pAvgTimePerFrame = vih->AvgTimePerFrame;
1194     } else {
1195         ERR("Unknown format type %s\n", qzdebugstr_guid(&pmt->formattype));
1196         *pAvgTimePerFrame = 0;
1197     }
1198     return S_OK;
1199 }
1200
1201 static HRESULT WINAPI Basicvideo_get_BitRate(IBasicVideo *iface,
1202                                              LONG *pBitRate) {
1203     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1204
1205     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBitRate);
1206
1207     return S_OK;
1208 }
1209
1210 static HRESULT WINAPI Basicvideo_get_BitErrorRate(IBasicVideo *iface,
1211                                                   LONG *pBitErrorRate) {
1212     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1213
1214     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBitErrorRate);
1215
1216     return S_OK;
1217 }
1218
1219 static HRESULT WINAPI Basicvideo_get_VideoWidth(IBasicVideo *iface,
1220                                                 LONG *pVideoWidth) {
1221     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1222
1223     TRACE("(%p/%p)->(%p)\n", This, iface, pVideoWidth);
1224
1225     *pVideoWidth = This->VideoWidth;
1226
1227     return S_OK;
1228 }
1229
1230 static HRESULT WINAPI Basicvideo_get_VideoHeight(IBasicVideo *iface,
1231                                                  LONG *pVideoHeight) {
1232     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1233
1234     TRACE("(%p/%p)->(%p)\n", This, iface, pVideoHeight);
1235
1236     *pVideoHeight = This->VideoHeight;
1237
1238     return S_OK;
1239 }
1240
1241 static HRESULT WINAPI Basicvideo_put_SourceLeft(IBasicVideo *iface,
1242                                                 LONG SourceLeft) {
1243     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1244
1245     TRACE("(%p/%p)->(%d)\n", This, iface, SourceLeft);
1246
1247     This->SourceRect.left = SourceLeft;
1248
1249     return S_OK;
1250 }
1251
1252 static HRESULT WINAPI Basicvideo_get_SourceLeft(IBasicVideo *iface,
1253                                                 LONG *pSourceLeft) {
1254     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1255
1256     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceLeft);
1257
1258     *pSourceLeft = This->SourceRect.left;
1259
1260     return S_OK;
1261 }
1262
1263 static HRESULT WINAPI Basicvideo_put_SourceWidth(IBasicVideo *iface,
1264                                                  LONG SourceWidth) {
1265     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1266
1267     TRACE("(%p/%p)->(%d)\n", This, iface, SourceWidth);
1268
1269     This->SourceRect.right = This->SourceRect.left + SourceWidth;
1270
1271     return S_OK;
1272 }
1273
1274 static HRESULT WINAPI Basicvideo_get_SourceWidth(IBasicVideo *iface,
1275                                                  LONG *pSourceWidth) {
1276     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1277
1278     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceWidth);
1279
1280     *pSourceWidth = This->SourceRect.right - This->SourceRect.left;
1281
1282     return S_OK;
1283 }
1284
1285 static HRESULT WINAPI Basicvideo_put_SourceTop(IBasicVideo *iface,
1286                                                LONG SourceTop) {
1287     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1288
1289     TRACE("(%p/%p)->(%d)\n", This, iface, SourceTop);
1290
1291     This->SourceRect.top = SourceTop;
1292
1293     return S_OK;
1294 }
1295
1296 static HRESULT WINAPI Basicvideo_get_SourceTop(IBasicVideo *iface,
1297                                                LONG *pSourceTop) {
1298     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1299
1300     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceTop);
1301
1302     *pSourceTop = This->SourceRect.top;
1303
1304     return S_OK;
1305 }
1306
1307 static HRESULT WINAPI Basicvideo_put_SourceHeight(IBasicVideo *iface,
1308                                                   LONG SourceHeight) {
1309     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1310
1311     TRACE("(%p/%p)->(%d)\n", This, iface, SourceHeight);
1312
1313     This->SourceRect.bottom = This->SourceRect.top + SourceHeight;
1314
1315     return S_OK;
1316 }
1317
1318 static HRESULT WINAPI Basicvideo_get_SourceHeight(IBasicVideo *iface,
1319                                                   LONG *pSourceHeight) {
1320     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1321
1322     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceHeight);
1323
1324     *pSourceHeight = This->SourceRect.bottom - This->SourceRect.top;
1325
1326     return S_OK;
1327 }
1328
1329 static HRESULT WINAPI Basicvideo_put_DestinationLeft(IBasicVideo *iface,
1330                                                      LONG DestinationLeft) {
1331     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1332
1333     TRACE("(%p/%p)->(%d)\n", This, iface, DestinationLeft);
1334
1335     This->DestRect.left = DestinationLeft;
1336
1337     return S_OK;
1338 }
1339
1340 static HRESULT WINAPI Basicvideo_get_DestinationLeft(IBasicVideo *iface,
1341                                                      LONG *pDestinationLeft) {
1342     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1343
1344     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationLeft);
1345
1346     *pDestinationLeft = This->DestRect.left;
1347
1348     return S_OK;
1349 }
1350
1351 static HRESULT WINAPI Basicvideo_put_DestinationWidth(IBasicVideo *iface,
1352                                                       LONG DestinationWidth) {
1353     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1354
1355     TRACE("(%p/%p)->(%d)\n", This, iface, DestinationWidth);
1356
1357     This->DestRect.right = This->DestRect.left + DestinationWidth;
1358
1359     return S_OK;
1360 }
1361
1362 static HRESULT WINAPI Basicvideo_get_DestinationWidth(IBasicVideo *iface,
1363                                                       LONG *pDestinationWidth) {
1364     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1365
1366     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationWidth);
1367
1368     *pDestinationWidth = This->DestRect.right - This->DestRect.left;
1369
1370     return S_OK;
1371 }
1372
1373 static HRESULT WINAPI Basicvideo_put_DestinationTop(IBasicVideo *iface,
1374                                                     LONG DestinationTop) {
1375     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1376
1377     TRACE("(%p/%p)->(%d)\n", This, iface, DestinationTop);
1378
1379     This->DestRect.top = DestinationTop;
1380
1381     return S_OK;
1382 }
1383
1384 static HRESULT WINAPI Basicvideo_get_DestinationTop(IBasicVideo *iface,
1385                                                     LONG *pDestinationTop) {
1386     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1387
1388     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationTop);
1389
1390     *pDestinationTop = This->DestRect.top;
1391
1392     return S_OK;
1393 }
1394
1395 static HRESULT WINAPI Basicvideo_put_DestinationHeight(IBasicVideo *iface,
1396                                                        LONG DestinationHeight) {
1397     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1398
1399     TRACE("(%p/%p)->(%d)\n", This, iface, DestinationHeight);
1400
1401     This->DestRect.right = This->DestRect.left + DestinationHeight;
1402
1403     return S_OK;
1404 }
1405
1406 static HRESULT WINAPI Basicvideo_get_DestinationHeight(IBasicVideo *iface,
1407                                                        LONG *pDestinationHeight) {
1408     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1409
1410     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationHeight);
1411
1412     *pDestinationHeight = This->DestRect.right - This->DestRect.left;
1413
1414     return S_OK;
1415 }
1416
1417 static HRESULT WINAPI Basicvideo_SetSourcePosition(IBasicVideo *iface,
1418                                                    LONG Left,
1419                                                    LONG Top,
1420                                                    LONG Width,
1421                                                    LONG Height) {
1422     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1423
1424     TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
1425
1426     This->SourceRect.left = Left;
1427     This->SourceRect.top = Top;
1428     This->SourceRect.right = Left + Width;
1429     This->SourceRect.bottom = Top + Height;
1430
1431     return S_OK;
1432 }
1433
1434 static HRESULT WINAPI Basicvideo_GetSourcePosition(IBasicVideo *iface,
1435                                                    LONG *pLeft,
1436                                                    LONG *pTop,
1437                                                    LONG *pWidth,
1438                                                    LONG *pHeight) {
1439     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1440
1441     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
1442
1443     *pLeft = This->SourceRect.left;
1444     *pTop = This->SourceRect.top;
1445     *pWidth = This->SourceRect.right - This->SourceRect.left;
1446     *pHeight = This->SourceRect.bottom - This->SourceRect.top;
1447
1448     return S_OK;
1449 }
1450
1451 static HRESULT WINAPI Basicvideo_SetDefaultSourcePosition(IBasicVideo *iface) {
1452     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1453
1454     TRACE("(%p/%p)->()\n", This, iface);
1455
1456     This->SourceRect.left = 0;
1457     This->SourceRect.top = 0;
1458     This->SourceRect.right = This->VideoWidth;
1459     This->SourceRect.bottom = This->VideoHeight;
1460
1461     return S_OK;
1462 }
1463
1464 static HRESULT WINAPI Basicvideo_SetDestinationPosition(IBasicVideo *iface,
1465                                                         LONG Left,
1466                                                         LONG Top,
1467                                                         LONG Width,
1468                                                         LONG Height) {
1469     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1470
1471     TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
1472
1473     This->DestRect.left = Left;
1474     This->DestRect.top = Top;
1475     This->DestRect.right = Left + Width;
1476     This->DestRect.bottom = Top + Height;
1477
1478     return S_OK;
1479 }
1480
1481 static HRESULT WINAPI Basicvideo_GetDestinationPosition(IBasicVideo *iface,
1482                                                         LONG *pLeft,
1483                                                         LONG *pTop,
1484                                                         LONG *pWidth,
1485                                                         LONG *pHeight) {
1486     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1487
1488     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
1489
1490     *pLeft = This->DestRect.left;
1491     *pTop = This->DestRect.top;
1492     *pWidth = This->DestRect.right - This->DestRect.left;
1493     *pHeight = This->DestRect.bottom - This->DestRect.top;
1494
1495     return S_OK;
1496 }
1497
1498 static HRESULT WINAPI Basicvideo_SetDefaultDestinationPosition(IBasicVideo *iface) {
1499     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1500     RECT rect;
1501
1502     TRACE("(%p/%p)->()\n", This, iface);
1503
1504     if (!GetClientRect(This->hWnd, &rect))
1505         return E_FAIL;
1506
1507     This->SourceRect.left = 0;
1508     This->SourceRect.top = 0;
1509     This->SourceRect.right = rect.right;
1510     This->SourceRect.bottom = rect.bottom;
1511
1512     return S_OK;
1513 }
1514
1515 static HRESULT WINAPI Basicvideo_GetVideoSize(IBasicVideo *iface,
1516                                               LONG *pWidth,
1517                                               LONG *pHeight) {
1518     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1519
1520     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
1521
1522     *pWidth = This->VideoWidth;
1523     *pHeight = This->VideoHeight;
1524
1525     return S_OK;
1526 }
1527
1528 static HRESULT WINAPI Basicvideo_GetVideoPaletteEntries(IBasicVideo *iface,
1529                                                         LONG StartIndex,
1530                                                         LONG Entries,
1531                                                         LONG *pRetrieved,
1532                                                         LONG *pPalette) {
1533     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1534
1535     FIXME("(%p/%p)->(%d, %d, %p, %p): stub !!!\n", This, iface, StartIndex, Entries, pRetrieved, pPalette);
1536
1537     return S_OK;
1538 }
1539
1540 static HRESULT WINAPI Basicvideo_GetCurrentImage(IBasicVideo *iface,
1541                                                  LONG *pBufferSize,
1542                                                  LONG *pDIBImage) {
1543     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1544     BITMAPINFOHEADER *bmiHeader;
1545     LONG needed_size;
1546     AM_MEDIA_TYPE *amt = &This->pInputPin->pin.mtCurrent;
1547     char *ptr;
1548
1549     FIXME("(%p/%p)->(%p, %p): partial stub\n", This, iface, pBufferSize, pDIBImage);
1550
1551     EnterCriticalSection(&This->csFilter);
1552
1553     if (!This->sample_held)
1554     {
1555          LeaveCriticalSection(&This->csFilter);
1556          return (This->state == State_Paused ? E_UNEXPECTED : VFW_E_NOT_PAUSED);
1557     }
1558
1559     if (IsEqualIID(&amt->formattype, &FORMAT_VideoInfo))
1560     {
1561         bmiHeader = &((VIDEOINFOHEADER *)amt->pbFormat)->bmiHeader;
1562     }
1563     else if (IsEqualIID(&amt->formattype, &FORMAT_VideoInfo2))
1564     {
1565         bmiHeader = &((VIDEOINFOHEADER2 *)amt->pbFormat)->bmiHeader;
1566     }
1567     else
1568     {
1569         FIXME("Unknown type %s\n", debugstr_guid(&amt->subtype));
1570         LeaveCriticalSection(&This->csFilter);
1571         return VFW_E_RUNTIME_ERROR;
1572     }
1573
1574     needed_size = bmiHeader->biSize;
1575     needed_size += IMediaSample_GetActualDataLength(This->sample_held);
1576
1577     if (!pDIBImage)
1578     {
1579         *pBufferSize = needed_size;
1580         LeaveCriticalSection(&This->csFilter);
1581         return S_OK;
1582     }
1583
1584     if (needed_size < *pBufferSize)
1585     {
1586         ERR("Buffer too small %u/%u\n", needed_size, *pBufferSize);
1587         LeaveCriticalSection(&This->csFilter);
1588         return E_FAIL;
1589     }
1590     *pBufferSize = needed_size;
1591
1592     memcpy(pDIBImage, bmiHeader, bmiHeader->biSize);
1593     IMediaSample_GetPointer(This->sample_held, (BYTE **)&ptr);
1594     memcpy((char *)pDIBImage + bmiHeader->biSize, ptr, IMediaSample_GetActualDataLength(This->sample_held));
1595
1596     LeaveCriticalSection(&This->csFilter);
1597
1598     return S_OK;
1599 }
1600
1601 static HRESULT WINAPI Basicvideo_IsUsingDefaultSource(IBasicVideo *iface) {
1602     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1603
1604     FIXME("(%p/%p)->(): stub !!!\n", This, iface);
1605
1606     return S_OK;
1607 }
1608
1609 static HRESULT WINAPI Basicvideo_IsUsingDefaultDestination(IBasicVideo *iface) {
1610     ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface);
1611
1612     FIXME("(%p/%p)->(): stub !!!\n", This, iface);
1613
1614     return S_OK;
1615 }
1616
1617
1618 static const IBasicVideoVtbl IBasicVideo_VTable =
1619 {
1620     Basicvideo_QueryInterface,
1621     Basicvideo_AddRef,
1622     Basicvideo_Release,
1623     Basicvideo_GetTypeInfoCount,
1624     Basicvideo_GetTypeInfo,
1625     Basicvideo_GetIDsOfNames,
1626     Basicvideo_Invoke,
1627     Basicvideo_get_AvgTimePerFrame,
1628     Basicvideo_get_BitRate,
1629     Basicvideo_get_BitErrorRate,
1630     Basicvideo_get_VideoWidth,
1631     Basicvideo_get_VideoHeight,
1632     Basicvideo_put_SourceLeft,
1633     Basicvideo_get_SourceLeft,
1634     Basicvideo_put_SourceWidth,
1635     Basicvideo_get_SourceWidth,
1636     Basicvideo_put_SourceTop,
1637     Basicvideo_get_SourceTop,
1638     Basicvideo_put_SourceHeight,
1639     Basicvideo_get_SourceHeight,
1640     Basicvideo_put_DestinationLeft,
1641     Basicvideo_get_DestinationLeft,
1642     Basicvideo_put_DestinationWidth,
1643     Basicvideo_get_DestinationWidth,
1644     Basicvideo_put_DestinationTop,
1645     Basicvideo_get_DestinationTop,
1646     Basicvideo_put_DestinationHeight,
1647     Basicvideo_get_DestinationHeight,
1648     Basicvideo_SetSourcePosition,
1649     Basicvideo_GetSourcePosition,
1650     Basicvideo_SetDefaultSourcePosition,
1651     Basicvideo_SetDestinationPosition,
1652     Basicvideo_GetDestinationPosition,
1653     Basicvideo_SetDefaultDestinationPosition,
1654     Basicvideo_GetVideoSize,
1655     Basicvideo_GetVideoPaletteEntries,
1656     Basicvideo_GetCurrentImage,
1657     Basicvideo_IsUsingDefaultSource,
1658     Basicvideo_IsUsingDefaultDestination
1659 };
1660
1661
1662 /*** IUnknown methods ***/
1663 static HRESULT WINAPI Videowindow_QueryInterface(IVideoWindow *iface,
1664                                                  REFIID riid,
1665                                                  LPVOID*ppvObj) {
1666     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1667
1668     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1669
1670     return VideoRenderer_QueryInterface((IBaseFilter*)This, riid, ppvObj);
1671 }
1672
1673 static ULONG WINAPI Videowindow_AddRef(IVideoWindow *iface) {
1674     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1675
1676     TRACE("(%p/%p)->()\n", This, iface);
1677
1678     return VideoRenderer_AddRef((IBaseFilter*)This);
1679 }
1680
1681 static ULONG WINAPI Videowindow_Release(IVideoWindow *iface) {
1682     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1683
1684     TRACE("(%p/%p)->()\n", This, iface);
1685
1686     return VideoRenderer_Release((IBaseFilter*)This);
1687 }
1688
1689 /*** IDispatch methods ***/
1690 static HRESULT WINAPI Videowindow_GetTypeInfoCount(IVideoWindow *iface,
1691                                                    UINT*pctinfo) {
1692     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1693
1694     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1695
1696     return S_OK;
1697 }
1698
1699 static HRESULT WINAPI Videowindow_GetTypeInfo(IVideoWindow *iface,
1700                                               UINT iTInfo,
1701                                               LCID lcid,
1702                                               ITypeInfo**ppTInfo) {
1703     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1704
1705     FIXME("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1706
1707     return S_OK;
1708 }
1709
1710 static HRESULT WINAPI Videowindow_GetIDsOfNames(IVideoWindow *iface,
1711                                                 REFIID riid,
1712                                                 LPOLESTR*rgszNames,
1713                                                 UINT cNames,
1714                                                 LCID lcid,
1715                                                 DISPID*rgDispId) {
1716     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1717
1718     FIXME("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
1719
1720     return S_OK;
1721 }
1722
1723 static HRESULT WINAPI Videowindow_Invoke(IVideoWindow *iface,
1724                                          DISPID dispIdMember,
1725                                          REFIID riid,
1726                                          LCID lcid,
1727                                          WORD wFlags,
1728                                          DISPPARAMS*pDispParams,
1729                                          VARIANT*pVarResult,
1730                                          EXCEPINFO*pExepInfo,
1731                                          UINT*puArgErr) {
1732     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1733
1734     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);
1735
1736     return S_OK;
1737 }
1738
1739 /*** IVideoWindow methods ***/
1740 static HRESULT WINAPI Videowindow_put_Caption(IVideoWindow *iface,
1741                                               BSTR strCaption) {
1742     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1743
1744     TRACE("(%p/%p)->(%s (%p))\n", This, iface, debugstr_w(strCaption), strCaption);
1745
1746     if (!SetWindowTextW(This->hWnd, strCaption))
1747         return E_FAIL;
1748
1749     return S_OK;
1750 }
1751
1752 static HRESULT WINAPI Videowindow_get_Caption(IVideoWindow *iface,
1753                                               BSTR *strCaption) {
1754     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1755
1756     TRACE("(%p/%p)->(%p)\n", This, iface, strCaption);
1757
1758     GetWindowTextW(This->hWnd, (LPWSTR)strCaption, 100);
1759
1760     return S_OK;
1761 }
1762
1763 static HRESULT WINAPI Videowindow_put_WindowStyle(IVideoWindow *iface,
1764                                                   LONG WindowStyle) {
1765     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1766     LONG old;
1767
1768     old = GetWindowLongA(This->hWnd, GWL_STYLE);
1769
1770     TRACE("(%p/%p)->(%x -> %x)\n", This, iface, old, WindowStyle);
1771
1772     if (WindowStyle & (WS_DISABLED|WS_HSCROLL|WS_ICONIC|WS_MAXIMIZE|WS_MINIMIZE|WS_VSCROLL))
1773         return E_INVALIDARG;
1774
1775     SetWindowLongA(This->hWnd, GWL_STYLE, WindowStyle);
1776
1777     return S_OK;
1778 }
1779
1780 static HRESULT WINAPI Videowindow_get_WindowStyle(IVideoWindow *iface,
1781                                                   LONG *WindowStyle) {
1782     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1783
1784     TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyle);
1785
1786     *WindowStyle = GetWindowLongA(This->hWnd, GWL_STYLE);
1787
1788     return S_OK;
1789 }
1790
1791 static HRESULT WINAPI Videowindow_put_WindowStyleEx(IVideoWindow *iface,
1792                                                     LONG WindowStyleEx) {
1793     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1794
1795     TRACE("(%p/%p)->(%d)\n", This, iface, WindowStyleEx);
1796
1797     if (WindowStyleEx & (WS_DISABLED|WS_HSCROLL|WS_ICONIC|WS_MAXIMIZE|WS_MINIMIZE|WS_VSCROLL))
1798         return E_INVALIDARG;
1799
1800     if (!SetWindowLongA(This->hWnd, GWL_EXSTYLE, WindowStyleEx))
1801         return E_FAIL;
1802
1803     return S_OK;
1804 }
1805
1806 static HRESULT WINAPI Videowindow_get_WindowStyleEx(IVideoWindow *iface,
1807                                                     LONG *WindowStyleEx) {
1808     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1809
1810     TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyleEx);
1811
1812     *WindowStyleEx = GetWindowLongA(This->hWnd, GWL_EXSTYLE);
1813
1814     return S_OK;
1815 }
1816
1817 static HRESULT WINAPI Videowindow_put_AutoShow(IVideoWindow *iface,
1818                                                LONG AutoShow) {
1819     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1820
1821     TRACE("(%p/%p)->(%d)\n", This, iface, AutoShow);
1822
1823     This->AutoShow = 1; /* FIXME: Should be AutoShow */;
1824
1825     return S_OK;
1826 }
1827
1828 static HRESULT WINAPI Videowindow_get_AutoShow(IVideoWindow *iface,
1829                                                LONG *AutoShow) {
1830     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1831
1832     TRACE("(%p/%p)->(%p)\n", This, iface, AutoShow);
1833
1834     *AutoShow = This->AutoShow;
1835
1836     return S_OK;
1837 }
1838
1839 static HRESULT WINAPI Videowindow_put_WindowState(IVideoWindow *iface,
1840                                                   LONG WindowState) {
1841     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1842
1843     TRACE("(%p/%p)->(%d)\n", This, iface, WindowState);
1844     ShowWindow(This->hWnd, WindowState);
1845     return S_OK;
1846 }
1847
1848 static HRESULT WINAPI Videowindow_get_WindowState(IVideoWindow *iface,
1849                                                   LONG *WindowState) {
1850     WINDOWPLACEMENT place;
1851     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1852
1853     place.length = sizeof(place);
1854     GetWindowPlacement(This->hWnd, &place);
1855     TRACE("(%p/%p)->(%p)\n", This, iface, WindowState);
1856     *WindowState = place.showCmd;
1857
1858     return S_OK;
1859 }
1860
1861 static HRESULT WINAPI Videowindow_put_BackgroundPalette(IVideoWindow *iface,
1862                                                         LONG BackgroundPalette) {
1863     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1864
1865     FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, BackgroundPalette);
1866
1867     return S_OK;
1868 }
1869
1870 static HRESULT WINAPI Videowindow_get_BackgroundPalette(IVideoWindow *iface,
1871                                                         LONG *pBackgroundPalette) {
1872     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1873
1874     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBackgroundPalette);
1875
1876     return S_OK;
1877 }
1878
1879 static HRESULT WINAPI Videowindow_put_Visible(IVideoWindow *iface,
1880                                               LONG Visible) {
1881     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1882
1883     TRACE("(%p/%p)->(%d)\n", This, iface, Visible);
1884
1885     ShowWindow(This->hWnd, Visible ? SW_SHOW : SW_HIDE);
1886
1887     return S_OK;
1888 }
1889
1890 static HRESULT WINAPI Videowindow_get_Visible(IVideoWindow *iface,
1891                                               LONG *pVisible) {
1892     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1893
1894     TRACE("(%p/%p)->(%p)\n", This, iface, pVisible);
1895
1896     *pVisible = IsWindowVisible(This->hWnd);
1897
1898     return S_OK;
1899 }
1900
1901 static HRESULT WINAPI Videowindow_put_Left(IVideoWindow *iface,
1902                                            LONG Left) {
1903     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1904
1905     TRACE("(%p/%p)->(%d)\n", This, iface, Left);
1906
1907     if (!SetWindowPos(This->hWnd, NULL, Left, This->WindowPos.top, 0, 0, SWP_NOZORDER|SWP_NOSIZE))
1908         return E_FAIL;
1909
1910     This->WindowPos.left = Left;
1911
1912     return S_OK;
1913 }
1914
1915 static HRESULT WINAPI Videowindow_get_Left(IVideoWindow *iface,
1916                                            LONG *pLeft) {
1917     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1918
1919     TRACE("(%p/%p)->(%p)\n", This, iface, pLeft);
1920
1921     *pLeft = This->WindowPos.left;
1922
1923     return S_OK;
1924 }
1925
1926 static HRESULT WINAPI Videowindow_put_Width(IVideoWindow *iface,
1927                                             LONG Width) {
1928     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1929
1930     TRACE("(%p/%p)->(%d)\n", This, iface, Width);
1931
1932     if (!SetWindowPos(This->hWnd, NULL, 0, 0, Width, This->WindowPos.bottom-This->WindowPos.top, SWP_NOZORDER|SWP_NOMOVE))
1933         return E_FAIL;
1934
1935     This->WindowPos.right = This->WindowPos.left + Width;
1936
1937     return S_OK;
1938 }
1939
1940 static HRESULT WINAPI Videowindow_get_Width(IVideoWindow *iface,
1941                                             LONG *pWidth) {
1942     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1943
1944     TRACE("(%p/%p)->(%p)\n", This, iface, pWidth);
1945
1946     *pWidth = This->WindowPos.right - This->WindowPos.left;
1947
1948     return S_OK;
1949 }
1950
1951 static HRESULT WINAPI Videowindow_put_Top(IVideoWindow *iface,
1952                                           LONG Top) {
1953     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1954
1955     TRACE("(%p/%p)->(%d)\n", This, iface, Top);
1956
1957     if (!SetWindowPos(This->hWnd, NULL, This->WindowPos.left, Top, 0, 0, SWP_NOZORDER|SWP_NOSIZE))
1958         return E_FAIL;
1959
1960     This->WindowPos.top = Top;
1961
1962     return S_OK;
1963 }
1964
1965 static HRESULT WINAPI Videowindow_get_Top(IVideoWindow *iface,
1966                                           LONG *pTop) {
1967     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1968
1969     TRACE("(%p/%p)->(%p)\n", This, iface, pTop);
1970
1971     *pTop = This->WindowPos.top;
1972
1973     return S_OK;
1974 }
1975
1976 static HRESULT WINAPI Videowindow_put_Height(IVideoWindow *iface,
1977                                              LONG Height) {
1978     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1979
1980     TRACE("(%p/%p)->(%d)\n", This, iface, Height);
1981
1982     if (!SetWindowPos(This->hWnd, NULL, 0, 0, This->WindowPos.right-This->WindowPos.left, Height, SWP_NOZORDER|SWP_NOMOVE))
1983         return E_FAIL;
1984
1985     This->WindowPos.bottom = This->WindowPos.top + Height;
1986
1987     return S_OK;
1988 }
1989
1990 static HRESULT WINAPI Videowindow_get_Height(IVideoWindow *iface,
1991                                              LONG *pHeight) {
1992     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
1993
1994     TRACE("(%p/%p)->(%p)\n", This, iface, pHeight);
1995
1996     *pHeight = This->WindowPos.bottom - This->WindowPos.top;
1997
1998     return S_OK;
1999 }
2000
2001 static HRESULT WINAPI Videowindow_put_Owner(IVideoWindow *iface,
2002                                             OAHWND Owner) {
2003     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2004
2005     TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Owner);
2006
2007     SetParent(This->hWnd, (HWND)Owner);
2008
2009     return S_OK;
2010 }
2011
2012 static HRESULT WINAPI Videowindow_get_Owner(IVideoWindow *iface,
2013                                             OAHWND *Owner) {
2014     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2015
2016     TRACE("(%p/%p)->(%p)\n", This, iface, Owner);
2017
2018     *(HWND*)Owner = GetParent(This->hWnd);
2019
2020     return S_OK;
2021 }
2022
2023 static HRESULT WINAPI Videowindow_put_MessageDrain(IVideoWindow *iface,
2024                                                    OAHWND Drain) {
2025     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2026
2027     TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Drain);
2028
2029     This->hWndMsgDrain = (HWND)Drain;
2030
2031     return S_OK;
2032 }
2033
2034 static HRESULT WINAPI Videowindow_get_MessageDrain(IVideoWindow *iface,
2035                                                    OAHWND *Drain) {
2036     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2037
2038     TRACE("(%p/%p)->(%p)\n", This, iface, Drain);
2039
2040     *Drain = (OAHWND)This->hWndMsgDrain;
2041
2042     return S_OK;
2043 }
2044
2045 static HRESULT WINAPI Videowindow_get_BorderColor(IVideoWindow *iface,
2046                                                   LONG *Color) {
2047     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2048
2049     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, Color);
2050
2051     return S_OK;
2052 }
2053
2054 static HRESULT WINAPI Videowindow_put_BorderColor(IVideoWindow *iface,
2055                                                   LONG Color) {
2056     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2057
2058     FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, Color);
2059
2060     return S_OK;
2061 }
2062
2063 static HRESULT WINAPI Videowindow_get_FullScreenMode(IVideoWindow *iface,
2064                                                      LONG *FullScreenMode) {
2065     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2066
2067     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, FullScreenMode);
2068
2069     return S_OK;
2070 }
2071
2072 static HRESULT WINAPI Videowindow_put_FullScreenMode(IVideoWindow *iface,
2073                                                      LONG FullScreenMode) {
2074     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2075
2076     FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, FullScreenMode);
2077
2078     return S_OK;
2079 }
2080
2081 static HRESULT WINAPI Videowindow_SetWindowForeground(IVideoWindow *iface,
2082                                                       LONG Focus) {
2083     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2084     BOOL ret;
2085     IPin* pPin;
2086     HRESULT hr;
2087
2088     TRACE("(%p/%p)->(%d)\n", This, iface, Focus);
2089
2090     if ((Focus != FALSE) && (Focus != TRUE))
2091         return E_INVALIDARG;
2092
2093     hr = IPin_ConnectedTo((IPin *)This->pInputPin, &pPin);
2094     if ((hr != S_OK) || !pPin)
2095         return VFW_E_NOT_CONNECTED;
2096
2097     if (Focus)
2098         ret = SetForegroundWindow(This->hWnd);
2099     else
2100         ret = SetWindowPos(This->hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
2101
2102     if (!ret)
2103         return E_FAIL;
2104
2105     return S_OK;
2106 }
2107
2108 static HRESULT WINAPI Videowindow_NotifyOwnerMessage(IVideoWindow *iface,
2109                                                      OAHWND hwnd,
2110                                                      LONG uMsg,
2111                                                      LONG_PTR wParam,
2112                                                      LONG_PTR lParam) {
2113     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2114
2115     TRACE("(%p/%p)->(%08lx, %d, %08lx, %08lx)\n", This, iface, hwnd, uMsg, wParam, lParam);
2116
2117     if (!PostMessageA(This->hWnd, uMsg, wParam, lParam))
2118         return E_FAIL;
2119
2120     return S_OK;
2121 }
2122
2123 static HRESULT WINAPI Videowindow_SetWindowPosition(IVideoWindow *iface,
2124                                                     LONG Left,
2125                                                     LONG Top,
2126                                                     LONG Width,
2127                                                     LONG Height) {
2128     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2129
2130     TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
2131
2132     if (!SetWindowPos(This->hWnd, NULL, Left, Top, Width, Height, SWP_NOZORDER))
2133         return E_FAIL;
2134
2135     This->WindowPos.left = Left;
2136     This->WindowPos.top = Top;
2137     This->WindowPos.right = Left + Width;
2138     This->WindowPos.bottom = Top + Height;
2139
2140     return S_OK;
2141 }
2142
2143 static HRESULT WINAPI Videowindow_GetWindowPosition(IVideoWindow *iface,
2144                                                     LONG *pLeft,
2145                                                     LONG *pTop,
2146                                                     LONG *pWidth,
2147                                                     LONG *pHeight) {
2148     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2149
2150     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
2151
2152     *pLeft = This->WindowPos.left;
2153     *pTop = This->WindowPos.top;
2154     *pWidth = This->WindowPos.right - This->WindowPos.left;
2155     *pHeight = This->WindowPos.bottom - This->WindowPos.top;
2156
2157     return S_OK;
2158 }
2159
2160 static HRESULT WINAPI Videowindow_GetMinIdealImageSize(IVideoWindow *iface,
2161                                                        LONG *pWidth,
2162                                                        LONG *pHeight) {
2163     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2164
2165     FIXME("(%p/%p)->(%p, %p): semi stub !!!\n", This, iface, pWidth, pHeight);
2166
2167     *pWidth = This->VideoWidth;
2168     *pHeight = This->VideoHeight;
2169
2170     return S_OK;
2171 }
2172
2173 static HRESULT WINAPI Videowindow_GetMaxIdealImageSize(IVideoWindow *iface,
2174                                                        LONG *pWidth,
2175                                                        LONG *pHeight) {
2176     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2177
2178     FIXME("(%p/%p)->(%p, %p): semi stub !!!\n", This, iface, pWidth, pHeight);
2179
2180     *pWidth = This->VideoWidth;
2181     *pHeight = This->VideoHeight;
2182
2183     return S_OK;
2184 }
2185
2186 static HRESULT WINAPI Videowindow_GetRestorePosition(IVideoWindow *iface,
2187                                                      LONG *pLeft,
2188                                                      LONG *pTop,
2189                                                      LONG *pWidth,
2190                                                      LONG *pHeight) {
2191     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2192
2193     FIXME("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight);
2194
2195     return S_OK;
2196 }
2197
2198 static HRESULT WINAPI Videowindow_HideCursor(IVideoWindow *iface,
2199                                              LONG HideCursor) {
2200     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2201
2202     FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, HideCursor);
2203
2204     return S_OK;
2205 }
2206
2207 static HRESULT WINAPI Videowindow_IsCursorHidden(IVideoWindow *iface,
2208                                                  LONG *CursorHidden) {
2209     ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface);
2210
2211     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, CursorHidden);
2212
2213     return S_OK;
2214 }
2215
2216 static const IVideoWindowVtbl IVideoWindow_VTable =
2217 {
2218     Videowindow_QueryInterface,
2219     Videowindow_AddRef,
2220     Videowindow_Release,
2221     Videowindow_GetTypeInfoCount,
2222     Videowindow_GetTypeInfo,
2223     Videowindow_GetIDsOfNames,
2224     Videowindow_Invoke,
2225     Videowindow_put_Caption,
2226     Videowindow_get_Caption,
2227     Videowindow_put_WindowStyle,
2228     Videowindow_get_WindowStyle,
2229     Videowindow_put_WindowStyleEx,
2230     Videowindow_get_WindowStyleEx,
2231     Videowindow_put_AutoShow,
2232     Videowindow_get_AutoShow,
2233     Videowindow_put_WindowState,
2234     Videowindow_get_WindowState,
2235     Videowindow_put_BackgroundPalette,
2236     Videowindow_get_BackgroundPalette,
2237     Videowindow_put_Visible,
2238     Videowindow_get_Visible,
2239     Videowindow_put_Left,
2240     Videowindow_get_Left,
2241     Videowindow_put_Width,
2242     Videowindow_get_Width,
2243     Videowindow_put_Top,
2244     Videowindow_get_Top,
2245     Videowindow_put_Height,
2246     Videowindow_get_Height,
2247     Videowindow_put_Owner,
2248     Videowindow_get_Owner,
2249     Videowindow_put_MessageDrain,
2250     Videowindow_get_MessageDrain,
2251     Videowindow_get_BorderColor,
2252     Videowindow_put_BorderColor,
2253     Videowindow_get_FullScreenMode,
2254     Videowindow_put_FullScreenMode,
2255     Videowindow_SetWindowForeground,
2256     Videowindow_NotifyOwnerMessage,
2257     Videowindow_SetWindowPosition,
2258     Videowindow_GetWindowPosition,
2259     Videowindow_GetMinIdealImageSize,
2260     Videowindow_GetMaxIdealImageSize,
2261     Videowindow_GetRestorePosition,
2262     Videowindow_HideCursor,
2263     Videowindow_IsCursorHidden
2264 };