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