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