dlls/quartz/filtergraph.c

   1 /*              DirectShow FilterGraph object (QUARTZ.DLL)
   2  *
   3  * Copyright 2002 Lionel Ulmer
   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 #include <stdarg.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "winreg.h"
  30 #include "shlwapi.h"
  31 #include "dshow.h"
  32 #include "wine/debug.h"
  33 #include "quartz_private.h"
  34 #include "ole2.h"
  35 #include "olectl.h"
  36 #include "strmif.h"
  37 #include "vfwmsgs.h"
  38 #include "evcode.h"
  39 #include "wine/unicode.h"
  40
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  43
  44 typedef struct {
  45     HWND     hWnd;      /* Target window */
  46     UINT     msg;       /* User window message */
  47     LONG_PTR instance;  /* User data */
  48     int      disabled;  /* Disabled messages posting */
  49 } WndNotify;
  50
  51 typedef struct {
  52     LONG lEventCode;   /* Event code */
  53     LONG_PTR lParam1;  /* Param1 */
  54     LONG_PTR lParam2;  /* Param2 */
  55 } Event;
  56
  57 /* messages ring implementation for queuing events (taken from winmm) */
  58 #define EVENTS_RING_BUFFER_INCREMENT      64
  59 typedef struct {
  60     Event* messages;
  61     int ring_buffer_size;
  62     int msg_tosave;
  63     int msg_toget;
  64     CRITICAL_SECTION msg_crst;
  65     HANDLE msg_event; /* Signaled for no empty queue */
  66 } EventsQueue;
  67
  68 static int EventsQueue_Init(EventsQueue* omr)
  69 {
  70     omr->msg_toget = 0;
  71     omr->msg_tosave = 0;
  72     omr->msg_event = CreateEventW(NULL, TRUE, FALSE, NULL);
  73     omr->ring_buffer_size = EVENTS_RING_BUFFER_INCREMENT;
  74     omr->messages = CoTaskMemAlloc(omr->ring_buffer_size * sizeof(Event));
  75     ZeroMemory(omr->messages, omr->ring_buffer_size * sizeof(Event));
  76
  77     InitializeCriticalSection(&omr->msg_crst);
  78     omr->msg_crst.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": EventsQueue.msg_crst");
  79     return TRUE;
  80 }
  81
  82 static int EventsQueue_Destroy(EventsQueue* omr)
  83 {
  84     CloseHandle(omr->msg_event);
  85     CoTaskMemFree(omr->messages);
  86     omr->msg_crst.DebugInfo->Spare[0] = 0;
  87     DeleteCriticalSection(&omr->msg_crst);
  88     return TRUE;
  89 }
  90
  91 static BOOL EventsQueue_PutEvent(EventsQueue* omr, const Event* evt)
  92 {
  93     EnterCriticalSection(&omr->msg_crst);
  94     if (omr->msg_toget == ((omr->msg_tosave + 1) % omr->ring_buffer_size))
  95     {
  96         int old_ring_buffer_size = omr->ring_buffer_size;
  97         omr->ring_buffer_size += EVENTS_RING_BUFFER_INCREMENT;
  98         TRACE("omr->ring_buffer_size=%d\n",omr->ring_buffer_size);
  99         omr->messages = CoTaskMemRealloc(omr->messages, omr->ring_buffer_size * sizeof(Event));
 100         /* Now we need to rearrange the ring buffer so that the new
 101            buffers just allocated are in between omr->msg_tosave and
 102            omr->msg_toget.
 103         */
 104         if (omr->msg_tosave < omr->msg_toget)
 105         {
 106             memmove(&(omr->messages[omr->msg_toget + EVENTS_RING_BUFFER_INCREMENT]),
 107                     &(omr->messages[omr->msg_toget]),
 108                     sizeof(Event)*(old_ring_buffer_size - omr->msg_toget)
 109                     );
 110             omr->msg_toget += EVENTS_RING_BUFFER_INCREMENT;
 111         }
 112     }
 113     omr->messages[omr->msg_tosave] = *evt;
 114     SetEvent(omr->msg_event);
 115     omr->msg_tosave = (omr->msg_tosave + 1) % omr->ring_buffer_size;
 116     LeaveCriticalSection(&omr->msg_crst);
 117     return TRUE;
 118 }
 119
 120 static BOOL EventsQueue_GetEvent(EventsQueue* omr, Event* evt, LONG msTimeOut)
 121 {
 122     if (WaitForSingleObject(omr->msg_event, msTimeOut) != WAIT_OBJECT_0)
 123         return FALSE;
 124
 125     EnterCriticalSection(&omr->msg_crst);
 126
 127     if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
 128     {
 129         LeaveCriticalSection(&omr->msg_crst);
 130         return FALSE;
 131     }
 132
 133     *evt = omr->messages[omr->msg_toget];
 134     omr->msg_toget = (omr->msg_toget + 1) % omr->ring_buffer_size;
 135
 136     /* Mark the buffer as empty if needed */
 137     if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
 138         ResetEvent(omr->msg_event);
 139
 140     LeaveCriticalSection(&omr->msg_crst);
 141     return TRUE;
 142 }
 143
 144 #define MAX_ITF_CACHE_ENTRIES 3
 145 typedef struct _ITF_CACHE_ENTRY {
 146    const IID* riid;
 147    IBaseFilter* filter;
 148    IUnknown* iface;
 149 } ITF_CACHE_ENTRY;
 150
 151 typedef struct _IFilterGraphImpl {
 152     IUnknown IUnknown_inner;
 153     IFilterGraph2 IFilterGraph2_iface;
 154     IMediaControl IMediaControl_iface;
 155     IMediaSeeking IMediaSeeking_iface;
 156     IBasicAudio IBasicAudio_iface;
 157     IBasicVideo2 IBasicVideo2_iface;
 158     IVideoWindow IVideoWindow_iface;
 159     IMediaEventEx IMediaEventEx_iface;
 160     IMediaFilter IMediaFilter_iface;
 161     IMediaEventSink IMediaEventSink_iface;
 162     IGraphConfig IGraphConfig_iface;
 163     IMediaPosition IMediaPosition_iface;
 164     IObjectWithSite IObjectWithSite_iface;
 165     IGraphVersion IGraphVersion_iface;
 166     /* IAMGraphStreams */
 167     /* IAMStats */
 168     /* IFilterChain */
 169     /* IFilterMapper2 */
 170     /* IQueueCommand */
 171     /* IRegisterServiceProvider */
 172     /* IResourceMananger */
 173     /* IServiceProvider */
 174     /* IVideoFrameStep */
 175
 176     IUnknown *outer_unk;
 177     LONG ref;
 178     IUnknown *punkFilterMapper2;
 179     IBaseFilter ** ppFiltersInGraph;
 180     LPWSTR * pFilterNames;
 181     ULONG nFilters;
 182     int filterCapacity;
 183     LONG nameIndex;
 184     IReferenceClock *refClock;
 185     IBaseFilter *refClockProvider;
 186     EventsQueue evqueue;
 187     HANDLE hEventCompletion;
 188     int CompletionStatus;
 189     WndNotify notif;
 190     int nRenderers;
 191     int EcCompleteCount;
 192     int HandleEcComplete;
 193     int HandleEcRepaint;
 194     int HandleEcClockChanged;
 195     OAFilterState state;
 196     CRITICAL_SECTION cs;
 197     ITF_CACHE_ENTRY ItfCacheEntries[MAX_ITF_CACHE_ENTRIES];
 198     int nItfCacheEntries;
 199     BOOL defaultclock;
 200     GUID timeformatseek;
 201     REFERENCE_TIME start_time;
 202     REFERENCE_TIME pause_time;
 203     LONGLONG stop_position;
 204     LONG recursioncount;
 205     IUnknown *pSite;
 206     LONG version;
 207 } IFilterGraphImpl;
 208
 209 static inline IFilterGraphImpl *impl_from_IUnknown(IUnknown *iface)
 210 {
 211     return CONTAINING_RECORD(iface, IFilterGraphImpl, IUnknown_inner);
 212 }
 213
 214 static HRESULT WINAPI FilterGraphInner_QueryInterface(IUnknown *iface, REFIID riid, void **ppvObj)
 215 {
 216     IFilterGraphImpl *This = impl_from_IUnknown(iface);
 217     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObj);
 218
 219     if (IsEqualGUID(&IID_IUnknown, riid)) {
 220         *ppvObj = &This->IUnknown_inner;
 221         TRACE("   returning IUnknown interface (%p)\n", *ppvObj);
 222     } else if (IsEqualGUID(&IID_IFilterGraph, riid) ||
 223         IsEqualGUID(&IID_IFilterGraph2, riid) ||
 224         IsEqualGUID(&IID_IGraphBuilder, riid)) {
 225         *ppvObj = &This->IFilterGraph2_iface;
 226         TRACE("   returning IGraphBuilder interface (%p)\n", *ppvObj);
 227     } else if (IsEqualGUID(&IID_IMediaControl, riid)) {
 228         *ppvObj = &This->IMediaControl_iface;
 229         TRACE("   returning IMediaControl interface (%p)\n", *ppvObj);
 230     } else if (IsEqualGUID(&IID_IMediaSeeking, riid)) {
 231         *ppvObj = &This->IMediaSeeking_iface;
 232         TRACE("   returning IMediaSeeking interface (%p)\n", *ppvObj);
 233     } else if (IsEqualGUID(&IID_IBasicAudio, riid)) {
 234         *ppvObj = &This->IBasicAudio_iface;
 235         TRACE("   returning IBasicAudio interface (%p)\n", *ppvObj);
 236     } else if (IsEqualGUID(&IID_IBasicVideo, riid) ||
 237                IsEqualGUID(&IID_IBasicVideo2, riid)) {
 238         *ppvObj = &This->IBasicVideo2_iface;
 239         TRACE("   returning IBasicVideo2 interface (%p)\n", *ppvObj);
 240     } else if (IsEqualGUID(&IID_IVideoWindow, riid)) {
 241         *ppvObj = &This->IVideoWindow_iface;
 242         TRACE("   returning IVideoWindow interface (%p)\n", *ppvObj);
 243     } else if (IsEqualGUID(&IID_IMediaEvent, riid) ||
 244            IsEqualGUID(&IID_IMediaEventEx, riid)) {
 245         *ppvObj = &This->IMediaEventEx_iface;
 246         TRACE("   returning IMediaEvent(Ex) interface (%p)\n", *ppvObj);
 247     } else if (IsEqualGUID(&IID_IMediaFilter, riid) ||
 248           IsEqualGUID(&IID_IPersist, riid)) {
 249         *ppvObj = &This->IMediaFilter_iface;
 250         TRACE("   returning IMediaFilter interface (%p)\n", *ppvObj);
 251     } else if (IsEqualGUID(&IID_IMediaEventSink, riid)) {
 252         *ppvObj = &This->IMediaEventSink_iface;
 253         TRACE("   returning IMediaEventSink interface (%p)\n", *ppvObj);
 254     } else if (IsEqualGUID(&IID_IGraphConfig, riid)) {
 255         *ppvObj = &This->IGraphConfig_iface;
 256         TRACE("   returning IGraphConfig interface (%p)\n", *ppvObj);
 257     } else if (IsEqualGUID(&IID_IMediaPosition, riid)) {
 258         *ppvObj = &This->IMediaPosition_iface;
 259         TRACE("   returning IMediaPosition interface (%p)\n", *ppvObj);
 260     } else if (IsEqualGUID(&IID_IObjectWithSite, riid)) {
 261         *ppvObj = &This->IObjectWithSite_iface;
 262         TRACE("   returning IObjectWithSite interface (%p)\n", *ppvObj);
 263     } else if (IsEqualGUID(&IID_IFilterMapper, riid)) {
 264         TRACE("   requesting IFilterMapper interface from aggregated filtermapper (%p)\n", *ppvObj);
 265         return IUnknown_QueryInterface(This->punkFilterMapper2, riid, ppvObj);
 266     } else if (IsEqualGUID(&IID_IFilterMapper2, riid)) {
 267         TRACE("   returning IFilterMapper2 interface from aggregated filtermapper (%p)\n", *ppvObj);
 268         return IUnknown_QueryInterface(This->punkFilterMapper2, riid, ppvObj);
 269     } else if (IsEqualGUID(&IID_IFilterMapper3, riid)) {
 270         TRACE("   returning IFilterMapper3 interface from aggregated filtermapper (%p)\n", *ppvObj);
 271         return IUnknown_QueryInterface(This->punkFilterMapper2, riid, ppvObj);
 272     } else if (IsEqualGUID(&IID_IGraphVersion, riid)) {
 273         *ppvObj = &This->IGraphConfig_iface;
 274         TRACE("   returning IGraphConfig interface (%p)\n", *ppvObj);
 275     } else {
 276         *ppvObj = NULL;
 277         FIXME("unknown interface %s\n", debugstr_guid(riid));
 278         return E_NOINTERFACE;
 279     }
 280
 281     IUnknown_AddRef((IUnknown *)*ppvObj);
 282     return S_OK;
 283 }
 284
 285 static ULONG WINAPI FilterGraphInner_AddRef(IUnknown *iface)
 286 {
 287     IFilterGraphImpl *This = impl_from_IUnknown(iface);
 288     ULONG ref = InterlockedIncrement(&This->ref);
 289
 290     TRACE("(%p)->(): new ref = %d\n", This, ref);
 291
 292     return ref;
 293 }
 294
 295 static ULONG WINAPI FilterGraphInner_Release(IUnknown *iface)
 296 {
 297     IFilterGraphImpl *This = impl_from_IUnknown(iface);
 298     ULONG ref = InterlockedDecrement(&This->ref);
 299
 300     TRACE("(%p)->(): new ref = %d\n", This, ref);
 301
 302     if (ref == 0) {
 303         int i;
 304
 305         This->ref = 1; /* guard against reentrancy (aggregation). */
 306
 307         IMediaControl_Stop(&This->IMediaControl_iface);
 308
 309         while (This->nFilters)
 310             IFilterGraph2_RemoveFilter(&This->IFilterGraph2_iface, This->ppFiltersInGraph[0]);
 311
 312         if (This->refClock)
 313             IReferenceClock_Release(This->refClock);
 314
 315         for (i = 0; i < This->nItfCacheEntries; i++)
 316         {
 317             if (This->ItfCacheEntries[i].iface)
 318                 IUnknown_Release(This->ItfCacheEntries[i].iface);
 319         }
 320
 321         IUnknown_Release(This->punkFilterMapper2);
 322
 323         if (This->pSite) IUnknown_Release(This->pSite);
 324
 325         CloseHandle(This->hEventCompletion);
 326         EventsQueue_Destroy(&This->evqueue);
 327         This->cs.DebugInfo->Spare[0] = 0;
 328         DeleteCriticalSection(&This->cs);
 329         CoTaskMemFree(This->ppFiltersInGraph);
 330         CoTaskMemFree(This->pFilterNames);
 331         CoTaskMemFree(This);
 332     }
 333     return ref;
 334 }
 335
 336 static inline IFilterGraphImpl *impl_from_IFilterGraph2(IFilterGraph2 *iface)
 337 {
 338     return CONTAINING_RECORD(iface, IFilterGraphImpl, IFilterGraph2_iface);
 339 }
 340
 341 static HRESULT WINAPI FilterGraph2_QueryInterface(IFilterGraph2 *iface, REFIID riid, void **ppvObj)
 342 {
 343     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 344
 345     TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
 346
 347     return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
 348 }
 349
 350 static ULONG WINAPI FilterGraph2_AddRef(IFilterGraph2 *iface)
 351 {
 352     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 353
 354     TRACE("(%p/%p)->()\n", This, iface);
 355
 356     return IUnknown_AddRef(This->outer_unk);
 357 }
 358
 359 static ULONG WINAPI FilterGraph2_Release(IFilterGraph2 *iface)
 360 {
 361     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 362
 363     TRACE("(%p/%p)->()\n", This, iface);
 364
 365     return IUnknown_Release(This->outer_unk);
 366 }
 367
 368 /*** IFilterGraph methods ***/
 369 static HRESULT WINAPI FilterGraph2_AddFilter(IFilterGraph2 *iface, IBaseFilter *pFilter,
 370         LPCWSTR pName)
 371 {
 372     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 373     HRESULT hr;
 374     int i,j;
 375     WCHAR* wszFilterName = NULL;
 376     BOOL duplicate_name = FALSE;
 377
 378     TRACE("(%p/%p)->(%p, %s (%p))\n", This, iface, pFilter, debugstr_w(pName), pName);
 379
 380     if (!pFilter)
 381         return E_POINTER;
 382
 383     wszFilterName = CoTaskMemAlloc( (pName ? strlenW(pName) + 6 : 5) * sizeof(WCHAR) );
 384
 385     if (pName)
 386     {
 387         /* Check if name already exists */
 388         for(i = 0; i < This->nFilters; i++)
 389             if (!strcmpW(This->pFilterNames[i], pName))
 390             {
 391                 duplicate_name = TRUE;
 392                 break;
 393             }
 394     }
 395
 396     /* If no name given or name already existing, generate one */
 397     if (!pName || duplicate_name)
 398     {
 399         static const WCHAR wszFmt1[] = {'%','s',' ','%','0','4','d',0};
 400         static const WCHAR wszFmt2[] = {'%','0','4','d',0};
 401
 402         for (j = 0; j < 10000 ; j++)
 403         {
 404             /* Create name */
 405             if (pName)
 406                 sprintfW(wszFilterName, wszFmt1, pName, This->nameIndex);
 407             else
 408                 sprintfW(wszFilterName, wszFmt2, This->nameIndex);
 409             TRACE("Generated name %s\n", debugstr_w(wszFilterName));
 410
 411             /* Check if the generated name already exists */
 412             for(i = 0; i < This->nFilters; i++)
 413                 if (!strcmpW(This->pFilterNames[i], wszFilterName))
 414                     break;
 415
 416             /* Compute next index and exit if generated name is suitable */
 417             if (This->nameIndex++ == 10000)
 418                 This->nameIndex = 1;
 419             if (i == This->nFilters)
 420                 break;
 421         }
 422         /* Unable to find a suitable name */
 423         if (j == 10000)
 424         {
 425             CoTaskMemFree(wszFilterName);
 426             return VFW_E_DUPLICATE_NAME;
 427         }
 428     }
 429     else
 430         memcpy(wszFilterName, pName, (strlenW(pName) + 1) * sizeof(WCHAR));
 431
 432     if (This->nFilters + 1 > This->filterCapacity)
 433     {
 434         int newCapacity = This->filterCapacity ? 2 * This->filterCapacity : 1;
 435         IBaseFilter ** ppNewFilters = CoTaskMemAlloc(newCapacity * sizeof(IBaseFilter*));
 436         LPWSTR * pNewNames = CoTaskMemAlloc(newCapacity * sizeof(LPWSTR));
 437         memcpy(ppNewFilters, This->ppFiltersInGraph, This->nFilters * sizeof(IBaseFilter*));
 438         memcpy(pNewNames, This->pFilterNames, This->nFilters * sizeof(LPWSTR));
 439         if (This->filterCapacity)
 440         {
 441             CoTaskMemFree(This->ppFiltersInGraph);
 442             CoTaskMemFree(This->pFilterNames);
 443         }
 444         This->ppFiltersInGraph = ppNewFilters;
 445         This->pFilterNames = pNewNames;
 446         This->filterCapacity = newCapacity;
 447     }
 448
 449     hr = IBaseFilter_JoinFilterGraph(pFilter, (IFilterGraph *)&This->IFilterGraph2_iface, wszFilterName);
 450
 451     if (SUCCEEDED(hr))
 452     {
 453         IBaseFilter_AddRef(pFilter);
 454         This->ppFiltersInGraph[This->nFilters] = pFilter;
 455         This->pFilterNames[This->nFilters] = wszFilterName;
 456         This->nFilters++;
 457         This->version++;
 458         IBaseFilter_SetSyncSource(pFilter, This->refClock);
 459     }
 460     else
 461         CoTaskMemFree(wszFilterName);
 462
 463     if (SUCCEEDED(hr) && duplicate_name)
 464         return VFW_S_DUPLICATE_NAME;
 465
 466     return hr;
 467 }
 468
 469 static HRESULT WINAPI FilterGraph2_RemoveFilter(IFilterGraph2 *iface, IBaseFilter *pFilter)
 470 {
 471     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 472     int i;
 473     HRESULT hr = E_FAIL;
 474
 475     TRACE("(%p/%p)->(%p)\n", This, iface, pFilter);
 476
 477     /* FIXME: check graph is stopped */
 478
 479     for (i = 0; i < This->nFilters; i++)
 480     {
 481         if (This->ppFiltersInGraph[i] == pFilter)
 482         {
 483             IEnumPins *penumpins = NULL;
 484             FILTER_STATE state;
 485
 486             if (This->defaultclock && This->refClockProvider == pFilter)
 487             {
 488                 IMediaFilter_SetSyncSource(&This->IMediaFilter_iface, NULL);
 489                 This->defaultclock = TRUE;
 490             }
 491
 492             TRACE("Removing filter %s\n", debugstr_w(This->pFilterNames[i]));
 493             IBaseFilter_GetState(pFilter, 0, &state);
 494             if (state == State_Running)
 495                 IBaseFilter_Pause(pFilter);
 496             if (state != State_Stopped)
 497                 IBaseFilter_Stop(pFilter);
 498
 499             hr = IBaseFilter_EnumPins(pFilter, &penumpins);
 500             if (SUCCEEDED(hr)) {
 501                 IPin *ppin;
 502                 while(IEnumPins_Next(penumpins, 1, &ppin, NULL) == S_OK)
 503                 {
 504                     IPin *victim = NULL;
 505                     HRESULT h;
 506                     IPin_ConnectedTo(ppin, &victim);
 507                     if (victim)
 508                     {
 509                         h = IPin_Disconnect(victim);
 510                         TRACE("Disconnect other side: %08x\n", h);
 511                         if (h == VFW_E_NOT_STOPPED)
 512                         {
 513                             PIN_INFO pinfo;
 514                             IPin_QueryPinInfo(victim, &pinfo);
 515
 516                             IBaseFilter_GetState(pinfo.pFilter, 0, &state);
 517                             if (state == State_Running)
 518                                 IBaseFilter_Pause(pinfo.pFilter);
 519                             IBaseFilter_Stop(pinfo.pFilter);
 520                             IBaseFilter_Release(pinfo.pFilter);
 521                             h = IPin_Disconnect(victim);
 522                             TRACE("Disconnect retry: %08x\n", h);
 523                         }
 524                         IPin_Release(victim);
 525                     }
 526                     h = IPin_Disconnect(ppin);
 527                     TRACE("Disconnect 2: %08x\n", h);
 528
 529                     IPin_Release(ppin);
 530                 }
 531                 IEnumPins_Release(penumpins);
 532             }
 533
 534             hr = IBaseFilter_JoinFilterGraph(pFilter, NULL, This->pFilterNames[i]);
 535             if (SUCCEEDED(hr))
 536             {
 537                 IBaseFilter_SetSyncSource(pFilter, NULL);
 538                 IBaseFilter_Release(pFilter);
 539                 CoTaskMemFree(This->pFilterNames[i]);
 540                 memmove(This->ppFiltersInGraph+i, This->ppFiltersInGraph+i+1, sizeof(IBaseFilter*)*(This->nFilters - 1 - i));
 541                 memmove(This->pFilterNames+i, This->pFilterNames+i+1, sizeof(LPWSTR)*(This->nFilters - 1 - i));
 542                 This->nFilters--;
 543                 This->version++;
 544                 /* Invalidate interfaces in the cache */
 545                 for (i = 0; i < This->nItfCacheEntries; i++)
 546                     if (pFilter == This->ItfCacheEntries[i].filter)
 547                     {
 548                         IUnknown_Release(This->ItfCacheEntries[i].iface);
 549                         This->ItfCacheEntries[i].iface = NULL;
 550                         This->ItfCacheEntries[i].filter = NULL;
 551                     }
 552                 return S_OK;
 553             }
 554             break;
 555         }
 556     }
 557
 558     return hr; /* FIXME: check this error code */
 559 }
 560
 561 static HRESULT WINAPI FilterGraph2_EnumFilters(IFilterGraph2 *iface, IEnumFilters **ppEnum)
 562 {
 563     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 564
 565     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 566
 567     return IEnumFiltersImpl_Construct(&This->IGraphVersion_iface, &This->ppFiltersInGraph, &This->nFilters, ppEnum);
 568 }
 569
 570 static HRESULT WINAPI FilterGraph2_FindFilterByName(IFilterGraph2 *iface, LPCWSTR pName,
 571         IBaseFilter **ppFilter)
 572 {
 573     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 574     int i;
 575
 576     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_w(pName), pName, ppFilter);
 577
 578     if (!ppFilter)
 579         return E_POINTER;
 580
 581     for (i = 0; i < This->nFilters; i++)
 582     {
 583         if (!strcmpW(pName, This->pFilterNames[i]))
 584         {
 585             *ppFilter = This->ppFiltersInGraph[i];
 586             IBaseFilter_AddRef(*ppFilter);
 587             return S_OK;
 588         }
 589     }
 590
 591     *ppFilter = NULL;
 592     return VFW_E_NOT_FOUND;
 593 }
 594
 595 /* Don't allow a circular connection to form, return VFW_E_CIRCULAR_GRAPH if this would be the case.
 596  * A circular connection will be formed if from the filter of the output pin, the input pin can be reached
 597  */
 598 static HRESULT CheckCircularConnection(IFilterGraphImpl *This, IPin *out, IPin *in)
 599 {
 600 #if 1
 601     HRESULT hr;
 602     PIN_INFO info_out, info_in;
 603
 604     hr = IPin_QueryPinInfo(out, &info_out);
 605     if (FAILED(hr))
 606         return hr;
 607     if (info_out.dir != PINDIR_OUTPUT)
 608     {
 609         IBaseFilter_Release(info_out.pFilter);
 610         return VFW_E_CANNOT_CONNECT;
 611     }
 612
 613     hr = IPin_QueryPinInfo(in, &info_in);
 614     if (SUCCEEDED(hr))
 615         IBaseFilter_Release(info_in.pFilter);
 616     if (FAILED(hr))
 617         goto out;
 618     if (info_in.dir != PINDIR_INPUT)
 619     {
 620         hr = VFW_E_CANNOT_CONNECT;
 621         goto out;
 622     }
 623
 624     if (info_out.pFilter == info_in.pFilter)
 625         hr = VFW_E_CIRCULAR_GRAPH;
 626     else
 627     {
 628         IEnumPins *enumpins;
 629         IPin *test;
 630
 631         hr = IBaseFilter_EnumPins(info_out.pFilter, &enumpins);
 632         if (FAILED(hr))
 633             goto out;
 634
 635         IEnumPins_Reset(enumpins);
 636         while ((hr = IEnumPins_Next(enumpins, 1, &test, NULL)) == S_OK)
 637         {
 638             PIN_DIRECTION dir = PINDIR_OUTPUT;
 639             IPin_QueryDirection(test, &dir);
 640             if (dir == PINDIR_INPUT)
 641             {
 642                 IPin *victim = NULL;
 643                 IPin_ConnectedTo(test, &victim);
 644                 if (victim)
 645                 {
 646                     hr = CheckCircularConnection(This, victim, in);
 647                     IPin_Release(victim);
 648                     if (FAILED(hr))
 649                     {
 650                         IPin_Release(test);
 651                         break;
 652                     }
 653                 }
 654             }
 655             IPin_Release(test);
 656         }
 657         IEnumPins_Release(enumpins);
 658     }
 659
 660 out:
 661     IBaseFilter_Release(info_out.pFilter);
 662     if (FAILED(hr))
 663         ERR("Checking filtergraph returned %08x, something's not right!\n", hr);
 664     return hr;
 665 #else
 666     /* Debugging filtergraphs not enabled */
 667     return S_OK;
 668 #endif
 669 }
 670
 671
 672 /* NOTE: despite the implication, it doesn't matter which
 673  * way round you put in the input and output pins */
 674 static HRESULT WINAPI FilterGraph2_ConnectDirect(IFilterGraph2 *iface, IPin *ppinIn, IPin *ppinOut,
 675         const AM_MEDIA_TYPE *pmt)
 676 {
 677     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 678     PIN_DIRECTION dir;
 679     HRESULT hr;
 680
 681     TRACE("(%p/%p)->(%p, %p, %p)\n", This, iface, ppinIn, ppinOut, pmt);
 682
 683     /* FIXME: check pins are in graph */
 684
 685     if (TRACE_ON(quartz))
 686     {
 687         PIN_INFO PinInfo;
 688
 689         hr = IPin_QueryPinInfo(ppinIn, &PinInfo);
 690         if (FAILED(hr))
 691             return hr;
 692
 693         TRACE("Filter owning first pin => %p\n", PinInfo.pFilter);
 694         IBaseFilter_Release(PinInfo.pFilter);
 695
 696         hr = IPin_QueryPinInfo(ppinOut, &PinInfo);
 697         if (FAILED(hr))
 698             return hr;
 699
 700         TRACE("Filter owning second pin => %p\n", PinInfo.pFilter);
 701         IBaseFilter_Release(PinInfo.pFilter);
 702     }
 703
 704     hr = IPin_QueryDirection(ppinIn, &dir);
 705     if (SUCCEEDED(hr))
 706     {
 707         if (dir == PINDIR_INPUT)
 708         {
 709             hr = CheckCircularConnection(This, ppinOut, ppinIn);
 710             if (SUCCEEDED(hr))
 711                 hr = IPin_Connect(ppinOut, ppinIn, pmt);
 712         }
 713         else
 714         {
 715             hr = CheckCircularConnection(This, ppinIn, ppinOut);
 716             if (SUCCEEDED(hr))
 717                 hr = IPin_Connect(ppinIn, ppinOut, pmt);
 718         }
 719     }
 720
 721     return hr;
 722 }
 723
 724 static HRESULT WINAPI FilterGraph2_Reconnect(IFilterGraph2 *iface, IPin *ppin)
 725 {
 726     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 727     IPin *pConnectedTo = NULL;
 728     HRESULT hr;
 729     PIN_DIRECTION pindir;
 730
 731     IPin_QueryDirection(ppin, &pindir);
 732     hr = IPin_ConnectedTo(ppin, &pConnectedTo);
 733     if (FAILED(hr)) {
 734         TRACE("Querying connected to failed: %x\n", hr);
 735         return hr;
 736     }
 737     IPin_Disconnect(ppin);
 738     IPin_Disconnect(pConnectedTo);
 739     if (pindir == PINDIR_INPUT)
 740         hr = IPin_Connect(pConnectedTo, ppin, NULL);
 741     else
 742         hr = IPin_Connect(ppin, pConnectedTo, NULL);
 743     IPin_Release(pConnectedTo);
 744     if (FAILED(hr))
 745         WARN("Reconnecting pins failed, pins are not connected now..\n");
 746     TRACE("(%p->%p) -- %p %p -> %x\n", iface, This, ppin, pConnectedTo, hr);
 747     return hr;
 748 }
 749
 750 static HRESULT WINAPI FilterGraph2_Disconnect(IFilterGraph2 *iface, IPin *ppin)
 751 {
 752     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 753
 754     TRACE("(%p/%p)->(%p)\n", This, iface, ppin);
 755
 756     if (!ppin)
 757        return E_POINTER;
 758
 759     return IPin_Disconnect(ppin);
 760 }
 761
 762 static HRESULT WINAPI FilterGraph2_SetDefaultSyncSource(IFilterGraph2 *iface)
 763 {
 764     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 765     IReferenceClock *pClock = NULL;
 766     HRESULT hr = S_OK;
 767     int i;
 768
 769     TRACE("(%p/%p)->() live sources not handled properly!\n", iface, This);
 770
 771     EnterCriticalSection(&This->cs);
 772
 773     for (i = 0; i < This->nFilters; ++i)
 774     {
 775         DWORD miscflags;
 776         IAMFilterMiscFlags *flags = NULL;
 777         IBaseFilter_QueryInterface(This->ppFiltersInGraph[i], &IID_IAMFilterMiscFlags, (void**)&flags);
 778         if (!flags)
 779             continue;
 780         miscflags = IAMFilterMiscFlags_GetMiscFlags(flags);
 781         IAMFilterMiscFlags_Release(flags);
 782         if (miscflags == AM_FILTER_MISC_FLAGS_IS_RENDERER)
 783             IBaseFilter_QueryInterface(This->ppFiltersInGraph[i], &IID_IReferenceClock, (void**)&pClock);
 784         if (pClock)
 785             break;
 786     }
 787
 788     if (!pClock)
 789     {
 790         hr = CoCreateInstance(&CLSID_SystemClock, NULL, CLSCTX_INPROC_SERVER, &IID_IReferenceClock, (LPVOID*)&pClock);
 791         This->refClockProvider = NULL;
 792     }
 793     else
 794         This->refClockProvider = This->ppFiltersInGraph[i];
 795
 796     if (SUCCEEDED(hr))
 797     {
 798         hr = IMediaFilter_SetSyncSource(&This->IMediaFilter_iface, pClock);
 799         This->defaultclock = TRUE;
 800         IReferenceClock_Release(pClock);
 801     }
 802     LeaveCriticalSection(&This->cs);
 803
 804     return hr;
 805 }
 806
 807 static HRESULT GetFilterInfo(IMoniker* pMoniker, VARIANT* pvar)
 808 {
 809     static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
 810     IPropertyBag * pPropBagCat = NULL;
 811     HRESULT hr;
 812
 813     VariantInit(pvar);
 814
 815     hr = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (LPVOID*)&pPropBagCat);
 816
 817     if (SUCCEEDED(hr))
 818         hr = IPropertyBag_Read(pPropBagCat, wszFriendlyName, pvar, NULL);
 819
 820     if (SUCCEEDED(hr))
 821         TRACE("Moniker = %s\n", debugstr_w(V_BSTR(pvar)));
 822
 823     if (pPropBagCat)
 824         IPropertyBag_Release(pPropBagCat);
 825
 826     return hr;
 827 }
 828
 829 static HRESULT GetInternalConnections(IBaseFilter* pfilter, IPin* pinputpin, IPin*** pppins, ULONG* pnb)
 830 {
 831     HRESULT hr;
 832     ULONG nb = 0;
 833
 834     TRACE("(%p, %p, %p, %p)\n", pfilter, pinputpin, pppins, pnb);
 835     hr = IPin_QueryInternalConnections(pinputpin, NULL, &nb);
 836     if (hr == S_OK) {
 837         /* Rendered input */
 838     } else if (hr == S_FALSE) {
 839         *pppins = CoTaskMemAlloc(sizeof(IPin*)*nb);
 840         hr = IPin_QueryInternalConnections(pinputpin, *pppins, &nb);
 841         if (hr != S_OK) {
 842             WARN("Error (%x)\n", hr);
 843         }
 844     } else if (hr == E_NOTIMPL) {
 845         /* Input connected to all outputs */
 846         IEnumPins* penumpins;
 847         IPin* ppin;
 848         int i = 0;
 849         TRACE("E_NOTIMPL\n");
 850         hr = IBaseFilter_EnumPins(pfilter, &penumpins);
 851         if (FAILED(hr)) {
 852             WARN("filter Enumpins failed (%x)\n", hr);
 853             return hr;
 854         }
 855         i = 0;
 856         /* Count output pins */
 857         while(IEnumPins_Next(penumpins, 1, &ppin, &nb) == S_OK) {
 858             PIN_DIRECTION pindir;
 859             IPin_QueryDirection(ppin, &pindir);
 860             if (pindir == PINDIR_OUTPUT)
 861                 i++;
 862             IPin_Release(ppin);
 863         }
 864         *pppins = CoTaskMemAlloc(sizeof(IPin*)*i);
 865         /* Retrieve output pins */
 866         IEnumPins_Reset(penumpins);
 867         i = 0;
 868         while(IEnumPins_Next(penumpins, 1, &ppin, &nb) == S_OK) {
 869             PIN_DIRECTION pindir;
 870             IPin_QueryDirection(ppin, &pindir);
 871             if (pindir == PINDIR_OUTPUT)
 872                 (*pppins)[i++] = ppin;
 873             else
 874                 IPin_Release(ppin);
 875         }
 876         IEnumPins_Release(penumpins);
 877         nb = i;
 878         if (FAILED(hr)) {
 879             WARN("Next failed (%x)\n", hr);
 880             return hr;
 881         }
 882     } else if (FAILED(hr)) {
 883         WARN("Cannot get internal connection (%x)\n", hr);
 884         return hr;
 885     }
 886
 887     *pnb = nb;
 888     return S_OK;
 889 }
 890
 891 /*** IGraphBuilder methods ***/
 892 static HRESULT WINAPI FilterGraph2_Connect(IFilterGraph2 *iface, IPin *ppinOut, IPin *ppinIn)
 893 {
 894     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 895     HRESULT hr;
 896     AM_MEDIA_TYPE* mt = NULL;
 897     IEnumMediaTypes* penummt = NULL;
 898     ULONG nbmt;
 899     IEnumPins* penumpins;
 900     IEnumMoniker* pEnumMoniker;
 901     GUID tab[2];
 902     ULONG nb = 0;
 903     IMoniker* pMoniker;
 904     ULONG pin;
 905     PIN_INFO PinInfo;
 906     CLSID FilterCLSID;
 907     PIN_DIRECTION dir;
 908     unsigned int i = 0;
 909     IFilterMapper2 *pFilterMapper2 = NULL;
 910
 911     TRACE("(%p/%p)->(%p, %p)\n", This, iface, ppinOut, ppinIn);
 912
 913     if(!ppinOut || !ppinIn)
 914         return E_POINTER;
 915
 916     if (TRACE_ON(quartz))
 917     {
 918         hr = IPin_QueryPinInfo(ppinIn, &PinInfo);
 919         if (FAILED(hr))
 920             return hr;
 921
 922         TRACE("Filter owning first pin => %p\n", PinInfo.pFilter);
 923         IBaseFilter_Release(PinInfo.pFilter);
 924
 925         hr = IPin_QueryPinInfo(ppinOut, &PinInfo);
 926         if (FAILED(hr))
 927             return hr;
 928
 929         TRACE("Filter owning second pin => %p\n", PinInfo.pFilter);
 930         IBaseFilter_Release(PinInfo.pFilter);
 931     }
 932
 933     EnterCriticalSection(&This->cs);
 934     ++This->recursioncount;
 935     if (This->recursioncount >= 5)
 936     {
 937         WARN("Recursion count has reached %d\n", This->recursioncount);
 938         hr = VFW_E_CANNOT_CONNECT;
 939         goto out;
 940     }
 941
 942     hr = IPin_QueryDirection(ppinOut, &dir);
 943     if (FAILED(hr))
 944         goto out;
 945
 946     if (dir == PINDIR_INPUT)
 947     {
 948         IPin *temp;
 949
 950         temp = ppinIn;
 951         ppinIn = ppinOut;
 952         ppinOut = temp;
 953     }
 954
 955     hr = CheckCircularConnection(This, ppinOut, ppinIn);
 956     if (FAILED(hr))
 957         goto out;
 958
 959     /* Try direct connection first */
 960     hr = IPin_Connect(ppinOut, ppinIn, NULL);
 961     if (SUCCEEDED(hr))
 962         goto out;
 963
 964     TRACE("Direct connection failed, trying to render using extra filters\n");
 965
 966     hr = IPin_QueryPinInfo(ppinIn, &PinInfo);
 967     if (FAILED(hr))
 968         goto out;
 969
 970     hr = IBaseFilter_GetClassID(PinInfo.pFilter, &FilterCLSID);
 971     IBaseFilter_Release(PinInfo.pFilter);
 972     if (FAILED(hr))
 973         goto out;
 974
 975     /* Find the appropriate transform filter than can transform the minor media type of output pin of the upstream
 976      * filter to the minor mediatype of input pin of the renderer */
 977     hr = IPin_EnumMediaTypes(ppinOut, &penummt);
 978     if (FAILED(hr))
 979     {
 980         WARN("EnumMediaTypes (%x)\n", hr);
 981         goto out;
 982     }
 983
 984     hr = IEnumMediaTypes_Next(penummt, 1, &mt, &nbmt);
 985     if (FAILED(hr)) {
 986         WARN("IEnumMediaTypes_Next (%x)\n", hr);
 987         goto out;
 988     }
 989
 990     if (!nbmt)
 991     {
 992         WARN("No media type found!\n");
 993         hr = VFW_E_INVALIDMEDIATYPE;
 994         goto out;
 995     }
 996     TRACE("MajorType %s\n", debugstr_guid(&mt->majortype));
 997     TRACE("SubType %s\n", debugstr_guid(&mt->subtype));
 998
 999     hr = IUnknown_QueryInterface(This->punkFilterMapper2, &IID_IFilterMapper2, (void**)&pFilterMapper2);
1000     if (FAILED(hr)) {
1001         WARN("Unable to get IFilterMapper2 (%x)\n", hr);
1002         goto out;
1003     }
1004
1005     /* Try to find a suitable filter that can connect to the pin to render */
1006     tab[0] = mt->majortype;
1007     tab[1] = mt->subtype;
1008     hr = IFilterMapper2_EnumMatchingFilters(pFilterMapper2, &pEnumMoniker, 0, FALSE, MERIT_UNLIKELY, TRUE, 1, tab, NULL, NULL, FALSE, FALSE, 0, NULL, NULL, NULL);
1009     if (FAILED(hr)) {
1010         WARN("Unable to enum filters (%x)\n", hr);
1011         goto out;
1012     }
1013
1014     hr = VFW_E_CANNOT_RENDER;
1015     while(IEnumMoniker_Next(pEnumMoniker, 1, &pMoniker, &nb) == S_OK)
1016     {
1017         VARIANT var;
1018         GUID clsid;
1019         IPin** ppins = NULL;
1020         IPin* ppinfilter = NULL;
1021         IBaseFilter* pfilter = NULL;
1022         IAMGraphBuilderCallback *callback = NULL;
1023
1024         hr = GetFilterInfo(pMoniker, &var);
1025         if (FAILED(hr)) {
1026             WARN("Unable to retrieve filter info (%x)\n", hr);
1027             goto error;
1028         }
1029
1030         hr = IMoniker_BindToObject(pMoniker, NULL, NULL, &IID_IBaseFilter, (LPVOID*)&pfilter);
1031         IMoniker_Release(pMoniker);
1032         if (FAILED(hr)) {
1033             WARN("Unable to create filter (%x), trying next one\n", hr);
1034             goto error;
1035         }
1036
1037         hr = IBaseFilter_GetClassID(pfilter, &clsid);
1038         if (FAILED(hr))
1039         {
1040             IBaseFilter_Release(pfilter);
1041             goto error;
1042         }
1043
1044         if (IsEqualGUID(&clsid, &FilterCLSID)) {
1045             /* Skip filter (same as the one the output pin belongs to) */
1046             IBaseFilter_Release(pfilter);
1047             goto error;
1048         }
1049
1050         if (This->pSite)
1051         {
1052             IUnknown_QueryInterface(This->pSite, &IID_IAMGraphBuilderCallback, (LPVOID*)&callback);
1053             if (callback)
1054             {
1055                 HRESULT rc;
1056                 rc = IAMGraphBuilderCallback_SelectedFilter(callback, pMoniker);
1057                 if (FAILED(rc))
1058                 {
1059                     TRACE("Filter rejected by IAMGraphBuilderCallback_SelectedFilter\n");
1060                     IAMGraphBuilderCallback_Release(callback);
1061                     goto error;
1062                 }
1063             }
1064         }
1065
1066         if (callback)
1067         {
1068             HRESULT rc;
1069             rc = IAMGraphBuilderCallback_CreatedFilter(callback, pfilter);
1070             IAMGraphBuilderCallback_Release(callback);
1071             if (FAILED(rc))
1072             {
1073                 IBaseFilter_Release(pfilter);
1074                 pfilter = NULL;
1075                 TRACE("Filter rejected by IAMGraphBuilderCallback_CreatedFilter\n");
1076                 goto error;
1077             }
1078         }
1079
1080         hr = IFilterGraph2_AddFilter(iface, pfilter, V_BSTR(&var));
1081         if (FAILED(hr)) {
1082             WARN("Unable to add filter (%x)\n", hr);
1083             IBaseFilter_Release(pfilter);
1084             pfilter = NULL;
1085             goto error;
1086         }
1087
1088         VariantClear(&var);
1089
1090         hr = IBaseFilter_EnumPins(pfilter, &penumpins);
1091         if (FAILED(hr)) {
1092             WARN("Enumpins (%x)\n", hr);
1093             goto error;
1094         }
1095
1096         hr = IEnumPins_Next(penumpins, 1, &ppinfilter, &pin);
1097         IEnumPins_Release(penumpins);
1098
1099         if (FAILED(hr)) {
1100             WARN("Obtaining next pin: (%x)\n", hr);
1101             goto error;
1102         }
1103         if (pin == 0) {
1104             WARN("Cannot use this filter: no pins\n");
1105             goto error;
1106         }
1107
1108         hr = IPin_Connect(ppinOut, ppinfilter, NULL);
1109         if (FAILED(hr)) {
1110             TRACE("Cannot connect to filter (%x), trying next one\n", hr);
1111             goto error;
1112         }
1113         TRACE("Successfully connected to filter, follow chain...\n");
1114
1115         /* Render all output pins of the filter by calling IFilterGraph2_Connect on each of them */
1116         hr = GetInternalConnections(pfilter, ppinfilter, &ppins, &nb);
1117
1118         if (SUCCEEDED(hr)) {
1119             if (nb == 0) {
1120                 IPin_Disconnect(ppinfilter);
1121                 IPin_Disconnect(ppinOut);
1122                 goto error;
1123             }
1124             TRACE("pins to consider: %d\n", nb);
1125             for(i = 0; i < nb; i++)
1126             {
1127                 LPWSTR pinname = NULL;
1128
1129                 TRACE("Processing pin %u\n", i);
1130
1131                 hr = IPin_QueryId(ppins[i], &pinname);
1132                 if (SUCCEEDED(hr))
1133                 {
1134                     if (pinname[0] == '~')
1135                     {
1136                         TRACE("Pinname=%s, skipping\n", debugstr_w(pinname));
1137                         hr = E_FAIL;
1138                     }
1139                     else
1140                         hr = IFilterGraph2_Connect(iface, ppins[i], ppinIn);
1141                     CoTaskMemFree(pinname);
1142                 }
1143
1144                 if (FAILED(hr)) {
1145                    TRACE("Cannot connect pin %p (%x)\n", ppinfilter, hr);
1146                 }
1147                 IPin_Release(ppins[i]);
1148                 if (SUCCEEDED(hr)) break;
1149             }
1150             while (++i < nb) IPin_Release(ppins[i]);
1151             CoTaskMemFree(ppins);
1152             IPin_Release(ppinfilter);
1153             IBaseFilter_Release(pfilter);
1154             if (FAILED(hr))
1155             {
1156                 IPin_Disconnect(ppinfilter);
1157                 IPin_Disconnect(ppinOut);
1158                 IFilterGraph2_RemoveFilter(iface, pfilter);
1159                 continue;
1160             }
1161             break;
1162         }
1163
1164 error:
1165         VariantClear(&var);
1166         if (ppinfilter) IPin_Release(ppinfilter);
1167         if (pfilter) {
1168             IFilterGraph2_RemoveFilter(iface, pfilter);
1169             IBaseFilter_Release(pfilter);
1170         }
1171         while (++i < nb) IPin_Release(ppins[i]);
1172         CoTaskMemFree(ppins);
1173     }
1174
1175     IEnumMoniker_Release(pEnumMoniker);
1176
1177 out:
1178     if (pFilterMapper2)
1179         IFilterMapper2_Release(pFilterMapper2);
1180     if (penummt)
1181         IEnumMediaTypes_Release(penummt);
1182     if (mt)
1183         DeleteMediaType(mt);
1184     --This->recursioncount;
1185     LeaveCriticalSection(&This->cs);
1186     TRACE("--> %08x\n", hr);
1187     return SUCCEEDED(hr) ? S_OK : hr;
1188 }
1189
1190 static HRESULT FilterGraph2_RenderRecurse(IFilterGraphImpl *This, IPin *ppinOut)
1191 {
1192     /* This pin has been connected now, try to call render on all pins that aren't connected */
1193     IPin *to = NULL;
1194     PIN_INFO info;
1195     IEnumPins *enumpins = NULL;
1196     BOOL renderany = FALSE;
1197     BOOL renderall = TRUE;
1198
1199     IPin_QueryPinInfo(ppinOut, &info);
1200
1201     IBaseFilter_EnumPins(info.pFilter, &enumpins);
1202     /* Don't need to hold a reference, IEnumPins does */
1203     IBaseFilter_Release(info.pFilter);
1204
1205     IEnumPins_Reset(enumpins);
1206     while (IEnumPins_Next(enumpins, 1, &to, NULL) == S_OK)
1207     {
1208         PIN_DIRECTION dir = PINDIR_INPUT;
1209
1210         IPin_QueryDirection(to, &dir);
1211
1212         if (dir == PINDIR_OUTPUT)
1213         {
1214             IPin *out = NULL;
1215
1216             IPin_ConnectedTo(to, &out);
1217             if (!out)
1218             {
1219                 HRESULT hr;
1220                 hr = IFilterGraph2_Render(&This->IFilterGraph2_iface, to);
1221                 if (SUCCEEDED(hr))
1222                     renderany = TRUE;
1223                 else
1224                     renderall = FALSE;
1225             }
1226             else
1227                 IPin_Release(out);
1228         }
1229
1230         IPin_Release(to);
1231     }
1232
1233     IEnumPins_Release(enumpins);
1234
1235     if (renderall)
1236         return S_OK;
1237
1238     if (renderany)
1239         return VFW_S_PARTIAL_RENDER;
1240
1241     return VFW_E_CANNOT_RENDER;
1242 }
1243
1244 /* Ogg hates me if I create a direct rendering method
1245  *
1246  * It can only connect to a pin properly once, so use a recursive method that does
1247  *
1248  *  +----+ --- (PIN 1) (Render is called on this pin)
1249  *  |    |
1250  *  +----+ --- (PIN 2)
1251  *
1252  *  Enumerate possible renderers that EXACTLY match the requested type
1253  *
1254  *  If none is available, try to add intermediate filters that can connect to the input pin
1255  *  then call Render on that intermediate pin's output pins
1256  *  if it succeeds: Render returns success, if it doesn't, the intermediate filter is removed,
1257  *  and another filter that can connect to the input pin is tried
1258  *  if we run out of filters that can, give up and return VFW_E_CANNOT_RENDER
1259  *  It's recursive, but fun!
1260  */
1261
1262 static HRESULT WINAPI FilterGraph2_Render(IFilterGraph2 *iface, IPin *ppinOut)
1263 {
1264     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1265     IEnumMediaTypes* penummt;
1266     AM_MEDIA_TYPE* mt;
1267     ULONG nbmt;
1268     HRESULT hr;
1269
1270     IEnumMoniker* pEnumMoniker;
1271     GUID tab[4];
1272     ULONG nb;
1273     IMoniker* pMoniker;
1274     INT x;
1275     IFilterMapper2 *pFilterMapper2 = NULL;
1276
1277     TRACE("(%p/%p)->(%p)\n", This, iface, ppinOut);
1278
1279     if (TRACE_ON(quartz))
1280     {
1281         PIN_INFO PinInfo;
1282
1283         hr = IPin_QueryPinInfo(ppinOut, &PinInfo);
1284         if (FAILED(hr))
1285             return hr;
1286
1287         TRACE("Filter owning pin => %p\n", PinInfo.pFilter);
1288         IBaseFilter_Release(PinInfo.pFilter);
1289     }
1290
1291     /* Try to find out if there is a renderer for the specified subtype already, and use that
1292      */
1293     EnterCriticalSection(&This->cs);
1294     for (x = 0; x < This->nFilters; ++x)
1295     {
1296         IEnumPins *enumpins = NULL;
1297         IPin *pin = NULL;
1298
1299         hr = IBaseFilter_EnumPins(This->ppFiltersInGraph[x], &enumpins);
1300
1301         if (FAILED(hr) || !enumpins)
1302             continue;
1303
1304         IEnumPins_Reset(enumpins);
1305         while (IEnumPins_Next(enumpins, 1, &pin, NULL) == S_OK)
1306         {
1307             IPin *to = NULL;
1308             PIN_DIRECTION dir = PINDIR_OUTPUT;
1309
1310             IPin_QueryDirection(pin, &dir);
1311             if (dir != PINDIR_INPUT)
1312             {
1313                 IPin_Release(pin);
1314                 continue;
1315             }
1316             IPin_ConnectedTo(pin, &to);
1317
1318             if (to == NULL)
1319             {
1320                 hr = FilterGraph2_ConnectDirect(iface, ppinOut, pin, NULL);
1321                 if (SUCCEEDED(hr))
1322                 {
1323                     TRACE("Connected successfully %p/%p, %08x look if we should render more!\n", ppinOut, pin, hr);
1324                     IPin_Release(pin);
1325
1326                     hr = FilterGraph2_RenderRecurse(This, pin);
1327                     if (FAILED(hr))
1328                     {
1329                         IPin_Disconnect(ppinOut);
1330                         IPin_Disconnect(pin);
1331                         continue;
1332                     }
1333                     IEnumPins_Release(enumpins);
1334                     LeaveCriticalSection(&This->cs);
1335                     return hr;
1336                 }
1337                 WARN("Could not connect!\n");
1338             }
1339             else
1340                 IPin_Release(to);
1341
1342             IPin_Release(pin);
1343         }
1344         IEnumPins_Release(enumpins);
1345     }
1346
1347     LeaveCriticalSection(&This->cs);
1348
1349     hr = IPin_EnumMediaTypes(ppinOut, &penummt);
1350     if (FAILED(hr)) {
1351         WARN("EnumMediaTypes (%x)\n", hr);
1352         return hr;
1353     }
1354
1355     IEnumMediaTypes_Reset(penummt);
1356
1357     /* Looks like no existing renderer of the kind exists
1358      * Try adding new ones
1359      */
1360     tab[0] = tab[1] = GUID_NULL;
1361     while (SUCCEEDED(hr))
1362     {
1363         hr = IEnumMediaTypes_Next(penummt, 1, &mt, &nbmt);
1364         if (FAILED(hr)) {
1365             WARN("IEnumMediaTypes_Next (%x)\n", hr);
1366             break;
1367         }
1368         if (!nbmt)
1369         {
1370             hr = VFW_E_CANNOT_RENDER;
1371             break;
1372         }
1373         else
1374         {
1375             TRACE("MajorType %s\n", debugstr_guid(&mt->majortype));
1376             TRACE("SubType %s\n", debugstr_guid(&mt->subtype));
1377
1378             /* Only enumerate once, this doesn't account for all previous ones, but this should be enough nonetheless */
1379             if (IsEqualIID(&tab[0], &mt->majortype) && IsEqualIID(&tab[1], &mt->subtype))
1380             {
1381                 DeleteMediaType(mt);
1382                 continue;
1383             }
1384
1385             if (pFilterMapper2 == NULL)
1386             {
1387                 hr = IUnknown_QueryInterface(This->punkFilterMapper2, &IID_IFilterMapper2, (void**)&pFilterMapper2);
1388                 if (FAILED(hr))
1389                 {
1390                     WARN("Unable to query IFilterMapper2 (%x)\n", hr);
1391                     break;
1392                 }
1393             }
1394
1395             /* Try to find a suitable renderer with the same media type */
1396             tab[0] = mt->majortype;
1397             tab[1] = mt->subtype;
1398             hr = IFilterMapper2_EnumMatchingFilters(pFilterMapper2, &pEnumMoniker, 0, FALSE, MERIT_UNLIKELY, TRUE, 1, tab, NULL, NULL, FALSE, FALSE, 0, NULL, NULL, NULL);
1399             if (FAILED(hr))
1400             {
1401                 WARN("Unable to enum filters (%x)\n", hr);
1402                 break;
1403             }
1404         }
1405         hr = E_FAIL;
1406
1407         while (IEnumMoniker_Next(pEnumMoniker, 1, &pMoniker, &nb) == S_OK)
1408         {
1409             VARIANT var;
1410             IPin* ppinfilter;
1411             IBaseFilter* pfilter = NULL;
1412             IEnumPins* penumpins = NULL;
1413             ULONG pin;
1414
1415             hr = GetFilterInfo(pMoniker, &var);
1416             if (FAILED(hr)) {
1417                 WARN("Unable to retrieve filter info (%x)\n", hr);
1418                 goto error;
1419             }
1420
1421             hr = IMoniker_BindToObject(pMoniker, NULL, NULL, &IID_IBaseFilter, (LPVOID*)&pfilter);
1422             IMoniker_Release(pMoniker);
1423             if (FAILED(hr))
1424             {
1425                 WARN("Unable to create filter (%x), trying next one\n", hr);
1426                 goto error;
1427             }
1428
1429             hr = IFilterGraph2_AddFilter(iface, pfilter, V_BSTR(&var));
1430             if (FAILED(hr)) {
1431                 WARN("Unable to add filter (%x)\n", hr);
1432                 IBaseFilter_Release(pfilter);
1433                 pfilter = NULL;
1434                 goto error;
1435             }
1436
1437             hr = IBaseFilter_EnumPins(pfilter, &penumpins);
1438             if (FAILED(hr)) {
1439                 WARN("Splitter Enumpins (%x)\n", hr);
1440                 goto error;
1441             }
1442
1443             while ((hr = IEnumPins_Next(penumpins, 1, &ppinfilter, &pin)) == S_OK)
1444             {
1445                 PIN_DIRECTION dir;
1446
1447                 if (pin == 0) {
1448                     WARN("No Pin\n");
1449                     hr = E_FAIL;
1450                     goto error;
1451                 }
1452
1453                 hr = IPin_QueryDirection(ppinfilter, &dir);
1454                 if (FAILED(hr)) {
1455                     IPin_Release(ppinfilter);
1456                     WARN("QueryDirection failed (%x)\n", hr);
1457                     goto error;
1458                 }
1459                 if (dir != PINDIR_INPUT) {
1460                     IPin_Release(ppinfilter);
1461                     continue; /* Wrong direction */
1462                 }
1463
1464                 /* Connect the pin to the "Renderer" */
1465                 hr = IPin_Connect(ppinOut, ppinfilter, NULL);
1466                 IPin_Release(ppinfilter);
1467
1468                 if (FAILED(hr)) {
1469                     WARN("Unable to connect %s to renderer (%x)\n", debugstr_w(V_BSTR(&var)), hr);
1470                     goto error;
1471                 }
1472                 TRACE("Connected, recursing %s\n",  debugstr_w(V_BSTR(&var)));
1473
1474                 VariantClear(&var);
1475
1476                 hr = FilterGraph2_RenderRecurse(This, ppinfilter);
1477                 if (FAILED(hr)) {
1478                     WARN("Unable to connect recursively (%x)\n", hr);
1479                     goto error;
1480                 }
1481                 IBaseFilter_Release(pfilter);
1482                 break;
1483             }
1484             if (SUCCEEDED(hr)) {
1485                 IEnumPins_Release(penumpins);
1486                 break; /* out of IEnumMoniker_Next loop */
1487             }
1488
1489             /* IEnumPins_Next failed, all other failure case caught by goto error */
1490             WARN("IEnumPins_Next (%x)\n", hr);
1491             /* goto error */
1492
1493 error:
1494             VariantClear(&var);
1495             if (penumpins)
1496                 IEnumPins_Release(penumpins);
1497             if (pfilter) {
1498                 IFilterGraph2_RemoveFilter(iface, pfilter);
1499                 IBaseFilter_Release(pfilter);
1500             }
1501             if (SUCCEEDED(hr)) DebugBreak();
1502         }
1503
1504         IEnumMoniker_Release(pEnumMoniker);
1505         if (nbmt)
1506             DeleteMediaType(mt);
1507         if (SUCCEEDED(hr))
1508             break;
1509         hr = S_OK;
1510     }
1511
1512     if (pFilterMapper2)
1513         IFilterMapper2_Release(pFilterMapper2);
1514
1515     IEnumMediaTypes_Release(penummt);
1516     return hr;
1517 }
1518
1519 static HRESULT WINAPI FilterGraph2_RenderFile(IFilterGraph2 *iface, LPCWSTR lpcwstrFile,
1520         LPCWSTR lpcwstrPlayList)
1521 {
1522     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1523     static const WCHAR string[] = {'R','e','a','d','e','r',0};
1524     IBaseFilter* preader = NULL;
1525     IPin* ppinreader = NULL;
1526     IEnumPins* penumpins = NULL;
1527     HRESULT hr;
1528     BOOL partial = FALSE;
1529     BOOL any = FALSE;
1530
1531     TRACE("(%p/%p)->(%s, %s)\n", This, iface, debugstr_w(lpcwstrFile), debugstr_w(lpcwstrPlayList));
1532
1533     if (lpcwstrPlayList != NULL)
1534         return E_INVALIDARG;
1535
1536     hr = IFilterGraph2_AddSourceFilter(iface, lpcwstrFile, string, &preader);
1537     if (FAILED(hr))
1538         return hr;
1539
1540     if (SUCCEEDED(hr))
1541         hr = IBaseFilter_EnumPins(preader, &penumpins);
1542     if (SUCCEEDED(hr))
1543     {
1544         while (IEnumPins_Next(penumpins, 1, &ppinreader, NULL) == S_OK)
1545         {
1546             PIN_DIRECTION dir;
1547
1548             IPin_QueryDirection(ppinreader, &dir);
1549             if (dir == PINDIR_OUTPUT)
1550             {
1551                 INT i;
1552
1553                 hr = IFilterGraph2_Render(iface, ppinreader);
1554                 TRACE("Render %08x\n", hr);
1555
1556                 for (i = 0; i < This->nFilters; ++i)
1557                     TRACE("Filters in chain: %s\n", debugstr_w(This->pFilterNames[i]));
1558
1559                 if (SUCCEEDED(hr))
1560                     any = TRUE;
1561                 if (hr != S_OK)
1562                     partial = TRUE;
1563             }
1564             IPin_Release(ppinreader);
1565         }
1566         IEnumPins_Release(penumpins);
1567
1568         if (!any)
1569             hr = VFW_E_CANNOT_RENDER;
1570         else if (partial)
1571             hr = VFW_S_PARTIAL_RENDER;
1572         else
1573             hr = S_OK;
1574     }
1575     IBaseFilter_Release(preader);
1576
1577     TRACE("--> %08x\n", hr);
1578     return hr;
1579 }
1580
1581 static HRESULT CreateFilterInstanceAndLoadFile(GUID* clsid, LPCOLESTR pszFileName, IBaseFilter **filter)
1582 {
1583     IFileSourceFilter *source = NULL;
1584     HRESULT hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)filter);
1585     TRACE("CLSID: %s\n", debugstr_guid(clsid));
1586     if (FAILED(hr))
1587         return hr;
1588
1589     hr = IBaseFilter_QueryInterface(*filter, &IID_IFileSourceFilter, (LPVOID*)&source);
1590     if (FAILED(hr))
1591     {
1592         IBaseFilter_Release(*filter);
1593         return hr;
1594     }
1595
1596     /* Load the file in the file source filter */
1597     hr = IFileSourceFilter_Load(source, pszFileName, NULL);
1598     IFileSourceFilter_Release(source);
1599     if (FAILED(hr)) {
1600         WARN("Load (%x)\n", hr);
1601         IBaseFilter_Release(*filter);
1602         return hr;
1603     }
1604
1605     return hr;
1606 }
1607
1608 /* Some filters implement their own asynchronous reader (Theoretically they all should, try to load it first */
1609 static HRESULT GetFileSourceFilter(LPCOLESTR pszFileName, IBaseFilter **filter)
1610 {
1611     HRESULT hr;
1612     GUID clsid;
1613     IAsyncReader * pReader = NULL;
1614     IFileSourceFilter* pSource = NULL;
1615     IPin * pOutputPin = NULL;
1616     static const WCHAR wszOutputPinName[] = { 'O','u','t','p','u','t',0 };
1617
1618     /* Try to find a match without reading the file first */
1619     hr = GetClassMediaFile(NULL, pszFileName, NULL, NULL, &clsid);
1620
1621     if (hr == S_OK)
1622         return CreateFilterInstanceAndLoadFile(&clsid, pszFileName, filter);
1623
1624     /* Now create a AyncReader instance, to check for signature bytes in the file */
1625     hr = CoCreateInstance(&CLSID_AsyncReader, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)filter);
1626     if (FAILED(hr))
1627         return hr;
1628
1629     hr = IBaseFilter_QueryInterface(*filter, &IID_IFileSourceFilter, (LPVOID *)&pSource);
1630     if (FAILED(hr))
1631     {
1632         IBaseFilter_Release(*filter);
1633         return hr;
1634     }
1635
1636     hr = IFileSourceFilter_Load(pSource, pszFileName, NULL);
1637     IFileSourceFilter_Release(pSource);
1638     if (FAILED(hr))
1639     {
1640         IBaseFilter_Release(*filter);
1641         return hr;
1642     }
1643
1644     hr = IBaseFilter_FindPin(*filter, wszOutputPinName, &pOutputPin);
1645     if (FAILED(hr))
1646     {
1647         IBaseFilter_Release(*filter);
1648         return hr;
1649     }
1650
1651     hr = IPin_QueryInterface(pOutputPin, &IID_IAsyncReader, (LPVOID *)&pReader);
1652     IPin_Release(pOutputPin);
1653     if (FAILED(hr))
1654     {
1655         IBaseFilter_Release(*filter);
1656         return hr;
1657     }
1658
1659     /* Try again find a match */
1660     hr = GetClassMediaFile(pReader, pszFileName, NULL, NULL, &clsid);
1661     IAsyncReader_Release(pReader);
1662
1663     if (hr == S_OK)
1664     {
1665         /* Release the AsyncReader filter and create the matching one */
1666         IBaseFilter_Release(*filter);
1667         return CreateFilterInstanceAndLoadFile(&clsid, pszFileName, filter);
1668     }
1669
1670     /* Return the AsyncReader filter */
1671     return S_OK;
1672 }
1673
1674 static HRESULT WINAPI FilterGraph2_AddSourceFilter(IFilterGraph2 *iface, LPCWSTR lpcwstrFileName,
1675         LPCWSTR lpcwstrFilterName, IBaseFilter **ppFilter)
1676 {
1677     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1678     HRESULT hr;
1679     IBaseFilter* preader;
1680     IFileSourceFilter* pfile = NULL;
1681     AM_MEDIA_TYPE mt;
1682     WCHAR* filename;
1683
1684     TRACE("(%p/%p)->(%s, %s, %p)\n", This, iface, debugstr_w(lpcwstrFileName), debugstr_w(lpcwstrFilterName), ppFilter);
1685
1686     /* Try from file name first, then fall back to default asynchronous reader */
1687     hr = GetFileSourceFilter(lpcwstrFileName, &preader);
1688     if (FAILED(hr)) {
1689         WARN("Unable to create file source filter (%x)\n", hr);
1690         return hr;
1691     }
1692
1693     hr = IFilterGraph2_AddFilter(iface, preader, lpcwstrFilterName);
1694     if (FAILED(hr)) {
1695         WARN("Unable add filter (%x)\n", hr);
1696         IBaseFilter_Release(preader);
1697         return hr;
1698     }
1699
1700     hr = IBaseFilter_QueryInterface(preader, &IID_IFileSourceFilter, (LPVOID*)&pfile);
1701     if (FAILED(hr)) {
1702         WARN("Unable to get IFileSourceInterface (%x)\n", hr);
1703         goto error;
1704     }
1705
1706     /* The file has been already loaded */
1707     hr = IFileSourceFilter_GetCurFile(pfile, &filename, &mt);
1708     if (FAILED(hr)) {
1709         WARN("GetCurFile (%x)\n", hr);
1710         goto error;
1711     }
1712
1713     TRACE("File %s\n", debugstr_w(filename));
1714     TRACE("MajorType %s\n", debugstr_guid(&mt.majortype));
1715     TRACE("SubType %s\n", debugstr_guid(&mt.subtype));
1716
1717     if (ppFilter)
1718         *ppFilter = preader;
1719     IFileSourceFilter_Release(pfile);
1720
1721     return S_OK;
1722
1723 error:
1724     if (pfile)
1725         IFileSourceFilter_Release(pfile);
1726     IFilterGraph2_RemoveFilter(iface, preader);
1727     IBaseFilter_Release(preader);
1728
1729     return hr;
1730 }
1731
1732 static HRESULT WINAPI FilterGraph2_SetLogFile(IFilterGraph2 *iface, DWORD_PTR hFile)
1733 {
1734     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1735
1736     TRACE("(%p/%p)->(%08x): stub !!!\n", This, iface, (DWORD) hFile);
1737
1738     return S_OK;
1739 }
1740
1741 static HRESULT WINAPI FilterGraph2_Abort(IFilterGraph2 *iface)
1742 {
1743     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1744
1745     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1746
1747     return S_OK;
1748 }
1749
1750 static HRESULT WINAPI FilterGraph2_ShouldOperationContinue(IFilterGraph2 *iface)
1751 {
1752     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1753
1754     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1755
1756     return S_OK;
1757 }
1758
1759 /*** IFilterGraph2 methods ***/
1760 static HRESULT WINAPI FilterGraph2_AddSourceFilterForMoniker(IFilterGraph2 *iface,
1761         IMoniker *pMoniker, IBindCtx *pCtx, LPCWSTR lpcwstrFilterName, IBaseFilter **ppFilter)
1762 {
1763     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1764     HRESULT hr;
1765     IBaseFilter* pfilter;
1766
1767     TRACE("(%p/%p)->(%p %p %s %p)\n", This, iface, pMoniker, pCtx, debugstr_w(lpcwstrFilterName), ppFilter);
1768
1769     hr = IMoniker_BindToObject(pMoniker, pCtx, NULL, &IID_IBaseFilter, (void**)&pfilter);
1770     if(FAILED(hr)) {
1771         WARN("Unable to bind moniker to filter object (%x)\n", hr);
1772         return hr;
1773     }
1774
1775     hr = IFilterGraph2_AddFilter(iface, pfilter, lpcwstrFilterName);
1776     if (FAILED(hr)) {
1777         WARN("Unable to add filter (%x)\n", hr);
1778         IBaseFilter_Release(pfilter);
1779         return hr;
1780     }
1781
1782     if(ppFilter)
1783         *ppFilter = pfilter;
1784     else IBaseFilter_Release(pfilter);
1785
1786     return S_OK;
1787 }
1788
1789 static HRESULT WINAPI FilterGraph2_ReconnectEx(IFilterGraph2 *iface, IPin *ppin,
1790         const AM_MEDIA_TYPE *pmt)
1791 {
1792     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1793
1794     TRACE("(%p/%p)->(%p %p): stub !!!\n", This, iface, ppin, pmt);
1795
1796     return S_OK;
1797 }
1798
1799 static HRESULT WINAPI FilterGraph2_RenderEx(IFilterGraph2 *iface, IPin *pPinOut, DWORD dwFlags,
1800         DWORD *pvContext)
1801 {
1802     IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1803
1804     TRACE("(%p/%p)->(%p %08x %p): stub !!!\n", This, iface, pPinOut, dwFlags, pvContext);
1805
1806     return S_OK;
1807 }
1808
1809
1810 static const IFilterGraph2Vtbl IFilterGraph2_VTable =
1811 {
1812     FilterGraph2_QueryInterface,
1813     FilterGraph2_AddRef,
1814     FilterGraph2_Release,
1815     FilterGraph2_AddFilter,
1816     FilterGraph2_RemoveFilter,
1817     FilterGraph2_EnumFilters,
1818     FilterGraph2_FindFilterByName,
1819     FilterGraph2_ConnectDirect,
1820     FilterGraph2_Reconnect,
1821     FilterGraph2_Disconnect,
1822     FilterGraph2_SetDefaultSyncSource,
1823     FilterGraph2_Connect,
1824     FilterGraph2_Render,
1825     FilterGraph2_RenderFile,
1826     FilterGraph2_AddSourceFilter,
1827     FilterGraph2_SetLogFile,
1828     FilterGraph2_Abort,
1829     FilterGraph2_ShouldOperationContinue,
1830     FilterGraph2_AddSourceFilterForMoniker,
1831     FilterGraph2_ReconnectEx,
1832     FilterGraph2_RenderEx
1833 };
1834
1835 static inline IFilterGraphImpl *impl_from_IMediaControl(IMediaControl *iface)
1836 {
1837     return CONTAINING_RECORD(iface, IFilterGraphImpl, IMediaControl_iface);
1838 }
1839
1840 static HRESULT WINAPI MediaControl_QueryInterface(IMediaControl *iface, REFIID riid, void **ppvObj)
1841 {
1842     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1843
1844     TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
1845
1846     return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
1847 }
1848
1849 static ULONG WINAPI MediaControl_AddRef(IMediaControl *iface)
1850 {
1851     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1852
1853     TRACE("(%p/%p)->()\n", This, iface);
1854
1855     return IUnknown_AddRef(This->outer_unk);
1856 }
1857
1858 static ULONG WINAPI MediaControl_Release(IMediaControl *iface)
1859 {
1860     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1861
1862     TRACE("(%p/%p)->()\n", This, iface);
1863
1864     return IUnknown_Release(This->outer_unk);
1865
1866 }
1867
1868 /*** IDispatch methods ***/
1869 static HRESULT WINAPI MediaControl_GetTypeInfoCount(IMediaControl *iface, UINT *pctinfo)
1870 {
1871     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1872
1873     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1874
1875     return S_OK;
1876 }
1877
1878 static HRESULT WINAPI MediaControl_GetTypeInfo(IMediaControl *iface, UINT iTInfo, LCID lcid,
1879         ITypeInfo **ppTInfo)
1880 {
1881     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1882
1883     TRACE("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1884
1885     return S_OK;
1886 }
1887
1888 static HRESULT WINAPI MediaControl_GetIDsOfNames(IMediaControl *iface, REFIID riid,
1889         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1890 {
1891     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1892
1893     TRACE("(%p/%p)->(%s, %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), rgszNames,
1894             cNames, lcid, rgDispId);
1895
1896     return S_OK;
1897 }
1898
1899 static HRESULT WINAPI MediaControl_Invoke(IMediaControl *iface, DISPID dispIdMember, REFIID riid,
1900         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo,
1901         UINT *puArgErr)
1902 {
1903     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1904
1905     TRACE("(%p/%p)->(%d, %s, %d, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember,
1906             debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
1907
1908     return S_OK;
1909 }
1910
1911 typedef HRESULT(WINAPI *fnFoundFilter)(IBaseFilter *, DWORD_PTR data);
1912
1913 static HRESULT ExploreGraph(IFilterGraphImpl* pGraph, IPin* pOutputPin, fnFoundFilter FoundFilter, DWORD_PTR data)
1914 {
1915     HRESULT hr;
1916     IPin* pInputPin;
1917     IPin** ppPins;
1918     ULONG nb;
1919     ULONG i;
1920     PIN_INFO PinInfo;
1921
1922     TRACE("%p %p\n", pGraph, pOutputPin);
1923     PinInfo.pFilter = NULL;
1924
1925     hr = IPin_ConnectedTo(pOutputPin, &pInputPin);
1926
1927     if (SUCCEEDED(hr))
1928     {
1929         hr = IPin_QueryPinInfo(pInputPin, &PinInfo);
1930         if (SUCCEEDED(hr))
1931             hr = GetInternalConnections(PinInfo.pFilter, pInputPin, &ppPins, &nb);
1932         IPin_Release(pInputPin);
1933     }
1934
1935     if (SUCCEEDED(hr))
1936     {
1937         if (nb == 0)
1938         {
1939             TRACE("Reached a renderer\n");
1940             /* Count renderers for end of stream notification */
1941             pGraph->nRenderers++;
1942         }
1943         else
1944         {
1945             for(i = 0; i < nb; i++)
1946             {
1947                 /* Explore the graph downstream from this pin
1948                  * FIXME: We should prevent exploring from a pin more than once. This can happens when
1949                  * several input pins are connected to the same output (a MUX for instance). */
1950                 ExploreGraph(pGraph, ppPins[i], FoundFilter, data);
1951                 IPin_Release(ppPins[i]);
1952             }
1953
1954             CoTaskMemFree(ppPins);
1955         }
1956         TRACE("Doing stuff with filter %p\n", PinInfo.pFilter);
1957
1958         FoundFilter(PinInfo.pFilter, data);
1959     }
1960
1961     if (PinInfo.pFilter) IBaseFilter_Release(PinInfo.pFilter);
1962     return hr;
1963 }
1964
1965 static HRESULT WINAPI SendRun(IBaseFilter *pFilter, DWORD_PTR data)
1966 {
1967     REFERENCE_TIME time = *(REFERENCE_TIME*)data;
1968     return IBaseFilter_Run(pFilter, time);
1969 }
1970
1971 static HRESULT WINAPI SendPause(IBaseFilter *pFilter, DWORD_PTR data)
1972 {
1973     return IBaseFilter_Pause(pFilter);
1974 }
1975
1976 static HRESULT WINAPI SendStop(IBaseFilter *pFilter, DWORD_PTR data)
1977 {
1978     return IBaseFilter_Stop(pFilter);
1979 }
1980
1981 static HRESULT WINAPI SendGetState(IBaseFilter *pFilter, DWORD_PTR data)
1982 {
1983     FILTER_STATE state;
1984     DWORD time_end = data;
1985     DWORD time_now = GetTickCount();
1986     LONG wait;
1987
1988     if (time_end == INFINITE)
1989     {
1990         wait = INFINITE;
1991     }
1992     else if (time_end > time_now)
1993     {
1994         wait = time_end - time_now;
1995     }
1996     else
1997         wait = 0;
1998
1999     return IBaseFilter_GetState(pFilter, wait, &state);
2000 }
2001
2002
2003 static HRESULT SendFilterMessage(IFilterGraphImpl *This, fnFoundFilter FoundFilter, DWORD_PTR data)
2004 {
2005     int i;
2006     IBaseFilter* pfilter;
2007     IEnumPins* pEnum;
2008     HRESULT hr;
2009     IPin* pPin;
2010     DWORD dummy;
2011     PIN_DIRECTION dir;
2012
2013     TRACE("(%p)->()\n", This);
2014
2015     /* Explorer the graph from source filters to renderers, determine renderers
2016      * number and run filters from renderers to source filters */
2017     This->nRenderers = 0;
2018     ResetEvent(This->hEventCompletion);
2019
2020     for(i = 0; i < This->nFilters; i++)
2021     {
2022         BOOL source = TRUE;
2023         pfilter = This->ppFiltersInGraph[i];
2024         hr = IBaseFilter_EnumPins(pfilter, &pEnum);
2025         if (hr != S_OK)
2026         {
2027             WARN("Enum pins failed %x\n", hr);
2028             continue;
2029         }
2030         /* Check if it is a source filter */
2031         while(IEnumPins_Next(pEnum, 1, &pPin, &dummy) == S_OK)
2032         {
2033             IPin_QueryDirection(pPin, &dir);
2034             IPin_Release(pPin);
2035             if (dir == PINDIR_INPUT)
2036             {
2037                 source = FALSE;
2038                 break;
2039             }
2040         }
2041         if (source)
2042         {
2043             TRACE("Found a source filter %p\n", pfilter);
2044             IEnumPins_Reset(pEnum);
2045             while(IEnumPins_Next(pEnum, 1, &pPin, &dummy) == S_OK)
2046             {
2047                 /* Explore the graph downstream from this pin */
2048                 ExploreGraph(This, pPin, FoundFilter, data);
2049                 IPin_Release(pPin);
2050             }
2051             FoundFilter(pfilter, data);
2052         }
2053         IEnumPins_Release(pEnum);
2054     }
2055
2056     return S_FALSE;
2057 }
2058
2059 /*** IMediaControl methods ***/
2060 static HRESULT WINAPI MediaControl_Run(IMediaControl *iface)
2061 {
2062     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2063
2064     TRACE("(%p/%p)->()\n", This, iface);
2065
2066     EnterCriticalSection(&This->cs);
2067     if (This->state == State_Running)
2068         goto out;
2069     This->EcCompleteCount = 0;
2070
2071     if (This->defaultclock && !This->refClock)
2072         IFilterGraph2_SetDefaultSyncSource(&This->IFilterGraph2_iface);
2073
2074     if (This->refClock)
2075     {
2076         REFERENCE_TIME now;
2077         IReferenceClock_GetTime(This->refClock, &now);
2078         if (This->state == State_Stopped)
2079             This->start_time = now + 500000;
2080         else if (This->pause_time >= 0)
2081             This->start_time += now - This->pause_time;
2082         else
2083             This->start_time = now;
2084     }
2085     else This->start_time = 0;
2086
2087     SendFilterMessage(This, SendRun, (DWORD_PTR)&This->start_time);
2088     This->state = State_Running;
2089 out:
2090     LeaveCriticalSection(&This->cs);
2091     return S_FALSE;
2092 }
2093
2094 static HRESULT WINAPI MediaControl_Pause(IMediaControl *iface)
2095 {
2096     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2097
2098     TRACE("(%p/%p)->()\n", This, iface);
2099
2100     EnterCriticalSection(&This->cs);
2101     if (This->state == State_Paused)
2102         goto out;
2103
2104     if (This->state == State_Running && This->refClock && This->start_time >= 0)
2105         IReferenceClock_GetTime(This->refClock, &This->pause_time);
2106     else
2107         This->pause_time = -1;
2108
2109     SendFilterMessage(This, SendPause, 0);
2110     This->state = State_Paused;
2111 out:
2112     LeaveCriticalSection(&This->cs);
2113     return S_FALSE;
2114 }
2115
2116 static HRESULT WINAPI MediaControl_Stop(IMediaControl *iface)
2117 {
2118     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2119
2120     TRACE("(%p/%p)->()\n", This, iface);
2121
2122     if (This->state == State_Stopped) return S_OK;
2123
2124     EnterCriticalSection(&This->cs);
2125     if (This->state == State_Running) SendFilterMessage(This, SendPause, 0);
2126     SendFilterMessage(This, SendStop, 0);
2127     This->state = State_Stopped;
2128     LeaveCriticalSection(&This->cs);
2129     return S_OK;
2130 }
2131
2132 static HRESULT WINAPI MediaControl_GetState(IMediaControl *iface, LONG msTimeout,
2133         OAFilterState *pfs)
2134 {
2135     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2136     DWORD end;
2137
2138     TRACE("(%p/%p)->(%d, %p)\n", This, iface, msTimeout, pfs);
2139
2140     if (!pfs)
2141         return E_POINTER;
2142
2143     EnterCriticalSection(&This->cs);
2144
2145     *pfs = This->state;
2146     if (msTimeout > 0)
2147     {
2148         end = GetTickCount() + msTimeout;
2149     }
2150     else if (msTimeout < 0)
2151     {
2152         end = INFINITE;
2153     }
2154     else
2155     {
2156         end = 0;
2157     }
2158     if (end)
2159         SendFilterMessage(This, SendGetState, end);
2160
2161     LeaveCriticalSection(&This->cs);
2162
2163     return S_OK;
2164 }
2165
2166 static HRESULT WINAPI MediaControl_RenderFile(IMediaControl *iface, BSTR strFilename)
2167 {
2168     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2169
2170     TRACE("(%p/%p)->(%s (%p))\n", This, iface, debugstr_w(strFilename), strFilename);
2171
2172     return IFilterGraph2_RenderFile(&This->IFilterGraph2_iface, strFilename, NULL);
2173 }
2174
2175 static HRESULT WINAPI MediaControl_AddSourceFilter(IMediaControl *iface, BSTR strFilename,
2176         IDispatch **ppUnk)
2177 {
2178     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2179
2180     FIXME("(%p/%p)->(%s (%p), %p): stub !!!\n", This, iface, debugstr_w(strFilename), strFilename, ppUnk);
2181
2182     return S_OK;
2183 }
2184
2185 static HRESULT WINAPI MediaControl_get_FilterCollection(IMediaControl *iface, IDispatch **ppUnk)
2186 {
2187     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2188
2189     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk);
2190
2191     return S_OK;
2192 }
2193
2194 static HRESULT WINAPI MediaControl_get_RegFilterCollection(IMediaControl *iface, IDispatch **ppUnk)
2195 {
2196     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2197
2198     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk);
2199
2200     return S_OK;
2201 }
2202
2203 static HRESULT WINAPI MediaControl_StopWhenReady(IMediaControl *iface)
2204 {
2205     IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2206
2207     FIXME("(%p/%p)->(): stub !!!\n", This, iface);
2208
2209     return S_OK;
2210 }
2211
2212
2213 static const IMediaControlVtbl IMediaControl_VTable =
2214 {
2215     MediaControl_QueryInterface,
2216     MediaControl_AddRef,
2217     MediaControl_Release,
2218     MediaControl_GetTypeInfoCount,
2219     MediaControl_GetTypeInfo,
2220     MediaControl_GetIDsOfNames,
2221     MediaControl_Invoke,
2222     MediaControl_Run,
2223     MediaControl_Pause,
2224     MediaControl_Stop,
2225     MediaControl_GetState,
2226     MediaControl_RenderFile,
2227     MediaControl_AddSourceFilter,
2228     MediaControl_get_FilterCollection,
2229     MediaControl_get_RegFilterCollection,
2230     MediaControl_StopWhenReady
2231 };
2232
2233 static inline IFilterGraphImpl *impl_from_IMediaSeeking(IMediaSeeking *iface)
2234 {
2235     return CONTAINING_RECORD(iface, IFilterGraphImpl, IMediaSeeking_iface);
2236 }
2237
2238 static HRESULT WINAPI MediaSeeking_QueryInterface(IMediaSeeking *iface, REFIID riid, void **ppvObj)
2239 {
2240     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2241
2242     TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
2243
2244     return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
2245 }
2246
2247 static ULONG WINAPI MediaSeeking_AddRef(IMediaSeeking *iface)
2248 {
2249     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2250
2251     TRACE("(%p/%p)->()\n", This, iface);
2252
2253     return IUnknown_AddRef(This->outer_unk);
2254 }
2255
2256 static ULONG WINAPI MediaSeeking_Release(IMediaSeeking *iface)
2257 {
2258     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2259
2260     TRACE("(%p/%p)->()\n", This, iface);
2261
2262     return IUnknown_Release(This->outer_unk);
2263 }
2264
2265 typedef HRESULT (WINAPI *fnFoundSeek)(IFilterGraphImpl *This, IMediaSeeking*, DWORD_PTR arg);
2266
2267 static HRESULT all_renderers_seek(IFilterGraphImpl *This, fnFoundSeek FoundSeek, DWORD_PTR arg) {
2268     BOOL allnotimpl = TRUE;
2269     int i;
2270     HRESULT hr, hr_return = S_OK;
2271
2272     TRACE("(%p)->(%p %08lx)\n", This, FoundSeek, arg);
2273     /* Send a message to all renderers, they are responsible for broadcasting it further */
2274
2275     for(i = 0; i < This->nFilters; i++)
2276     {
2277         IMediaSeeking *seek = NULL;
2278         IBaseFilter* pfilter = This->ppFiltersInGraph[i];
2279         IAMFilterMiscFlags *flags = NULL;
2280         ULONG filterflags;
2281         IBaseFilter_QueryInterface(pfilter, &IID_IAMFilterMiscFlags, (void**)&flags);
2282         if (!flags)
2283             continue;
2284         filterflags = IAMFilterMiscFlags_GetMiscFlags(flags);
2285         IAMFilterMiscFlags_Release(flags);
2286         if (filterflags != AM_FILTER_MISC_FLAGS_IS_RENDERER)
2287             continue;
2288
2289         IBaseFilter_QueryInterface(pfilter, &IID_IMediaSeeking, (void**)&seek);
2290         if (!seek)
2291             continue;
2292         hr = FoundSeek(This, seek, arg);
2293         IMediaSeeking_Release(seek);
2294         if (hr_return != E_NOTIMPL)
2295             allnotimpl = FALSE;
2296         if (hr_return == S_OK || (FAILED(hr) && hr != E_NOTIMPL && SUCCEEDED(hr_return)))
2297             hr_return = hr;
2298     }
2299
2300     if (allnotimpl)
2301         return E_NOTIMPL;
2302     return hr_return;
2303 }
2304
2305 static HRESULT WINAPI FoundCapabilities(IFilterGraphImpl *This, IMediaSeeking *seek, DWORD_PTR pcaps)
2306 {
2307     HRESULT hr;
2308     DWORD caps = 0;
2309
2310     hr = IMediaSeeking_GetCapabilities(seek, &caps);
2311     if (FAILED(hr))
2312         return hr;
2313
2314     /* Only add common capabilities everything supports */
2315     *(DWORD*)pcaps &= caps;
2316
2317     return hr;
2318 }
2319
2320 /*** IMediaSeeking methods ***/
2321 static HRESULT WINAPI MediaSeeking_GetCapabilities(IMediaSeeking *iface, DWORD *pCapabilities)
2322 {
2323     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2324     HRESULT hr;
2325
2326     TRACE("(%p/%p)->(%p)\n", This, iface, pCapabilities);
2327
2328     if (!pCapabilities)
2329         return E_POINTER;
2330
2331     EnterCriticalSection(&This->cs);
2332     *pCapabilities = 0xffffffff;
2333
2334     hr = all_renderers_seek(This, FoundCapabilities, (DWORD_PTR)pCapabilities);
2335     LeaveCriticalSection(&This->cs);
2336
2337     return hr;
2338 }
2339
2340 static HRESULT WINAPI MediaSeeking_CheckCapabilities(IMediaSeeking *iface, DWORD *pCapabilities)
2341 {
2342     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2343     DWORD originalcaps;
2344     HRESULT hr;
2345
2346     TRACE("(%p/%p)->(%p)\n", This, iface, pCapabilities);
2347
2348     if (!pCapabilities)
2349         return E_POINTER;
2350
2351     EnterCriticalSection(&This->cs);
2352     originalcaps = *pCapabilities;
2353     hr = all_renderers_seek(This, FoundCapabilities, (DWORD_PTR)pCapabilities);
2354     LeaveCriticalSection(&This->cs);
2355
2356     if (FAILED(hr))
2357         return hr;
2358
2359     if (!*pCapabilities)
2360         return E_FAIL;
2361     if (*pCapabilities != originalcaps)
2362         return S_FALSE;
2363     return S_OK;
2364 }
2365
2366 static HRESULT WINAPI MediaSeeking_IsFormatSupported(IMediaSeeking *iface, const GUID *pFormat)
2367 {
2368     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2369
2370     if (!pFormat)
2371         return E_POINTER;
2372
2373     TRACE("(%p/%p)->(%s)\n", This, iface, debugstr_guid(pFormat));
2374
2375     if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, pFormat))
2376     {
2377         FIXME("Unhandled time format %s\n", debugstr_guid(pFormat));
2378         return S_FALSE;
2379     }
2380
2381     return S_OK;
2382 }
2383
2384 static HRESULT WINAPI MediaSeeking_QueryPreferredFormat(IMediaSeeking *iface, GUID *pFormat)
2385 {
2386     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2387
2388     if (!pFormat)
2389         return E_POINTER;
2390
2391     FIXME("(%p/%p)->(%p): semi-stub !!!\n", This, iface, pFormat);
2392     memcpy(pFormat, &TIME_FORMAT_MEDIA_TIME, sizeof(GUID));
2393
2394     return S_OK;
2395 }
2396
2397 static HRESULT WINAPI MediaSeeking_GetTimeFormat(IMediaSeeking *iface, GUID *pFormat)
2398 {
2399     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2400
2401     if (!pFormat)
2402         return E_POINTER;
2403
2404     TRACE("(%p/%p)->(%p)\n", This, iface, pFormat);
2405     memcpy(pFormat, &This->timeformatseek, sizeof(GUID));
2406
2407     return S_OK;
2408 }
2409
2410 static HRESULT WINAPI MediaSeeking_IsUsingTimeFormat(IMediaSeeking *iface, const GUID *pFormat)
2411 {
2412     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2413
2414     TRACE("(%p/%p)->(%p)\n", This, iface, pFormat);
2415     if (!pFormat)
2416         return E_POINTER;
2417
2418     if (memcmp(pFormat, &This->timeformatseek, sizeof(GUID)))
2419         return S_FALSE;
2420
2421     return S_OK;
2422 }
2423
2424 static HRESULT WINAPI MediaSeeking_SetTimeFormat(IMediaSeeking *iface, const GUID *pFormat)
2425 {
2426     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2427
2428     if (!pFormat)
2429         return E_POINTER;
2430
2431     TRACE("(%p/%p)->(%s)\n", This, iface, debugstr_guid(pFormat));
2432
2433     if (This->state != State_Stopped)
2434         return VFW_E_WRONG_STATE;
2435
2436     if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, pFormat))
2437     {
2438         FIXME("Unhandled time format %s\n", debugstr_guid(pFormat));
2439         return E_INVALIDARG;
2440     }
2441
2442     return S_OK;
2443 }
2444
2445 static HRESULT WINAPI FoundDuration(IFilterGraphImpl *This, IMediaSeeking *seek, DWORD_PTR pduration)
2446 {
2447     HRESULT hr;
2448     LONGLONG duration = 0, *pdur = (LONGLONG*)pduration;
2449
2450     hr = IMediaSeeking_GetDuration(seek, &duration);
2451     if (FAILED(hr))
2452         return hr;
2453
2454     if (*pdur < duration)
2455         *pdur = duration;
2456     return hr;
2457 }
2458
2459 static HRESULT WINAPI MediaSeeking_GetDuration(IMediaSeeking *iface, LONGLONG *pDuration)
2460 {
2461     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2462     HRESULT hr;
2463
2464     TRACE("(%p/%p)->(%p)\n", This, iface, pDuration);
2465
2466     if (!pDuration)
2467         return E_POINTER;
2468
2469     EnterCriticalSection(&This->cs);
2470     *pDuration = 0;
2471     hr = all_renderers_seek(This, FoundDuration, (DWORD_PTR)pDuration);
2472     LeaveCriticalSection(&This->cs);
2473
2474     TRACE("--->%08x\n", hr);
2475     return hr;
2476 }
2477
2478 static HRESULT WINAPI MediaSeeking_GetStopPosition(IMediaSeeking *iface, LONGLONG *pStop)
2479 {
2480     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2481     HRESULT hr = S_OK;
2482
2483     TRACE("(%p/%p)->(%p)\n", This, iface, pStop);
2484
2485     if (!pStop)
2486         return E_POINTER;
2487
2488     EnterCriticalSection(&This->cs);
2489     if (This->stop_position < 0)
2490         /* Stop position not set, use duration instead */
2491         hr = IMediaSeeking_GetDuration(iface, pStop);
2492     else
2493         *pStop = This->stop_position;
2494     LeaveCriticalSection(&This->cs);
2495
2496     return hr;
2497 }
2498
2499 static HRESULT WINAPI MediaSeeking_GetCurrentPosition(IMediaSeeking *iface, LONGLONG *pCurrent)
2500 {
2501     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2502     LONGLONG time = 0;
2503
2504     if (!pCurrent)
2505         return E_POINTER;
2506
2507     EnterCriticalSection(&This->cs);
2508     if (This->state == State_Running && This->refClock && This->start_time >= 0)
2509     {
2510         IReferenceClock_GetTime(This->refClock, &time);
2511         if (time)
2512             time -= This->start_time;
2513     }
2514     if (This->pause_time > 0)
2515         time += This->pause_time;
2516     *pCurrent = time;
2517     LeaveCriticalSection(&This->cs);
2518
2519     TRACE("Time: %u.%03u\n", (DWORD)(*pCurrent / 10000000), (DWORD)((*pCurrent / 10000)%1000));
2520
2521     return S_OK;
2522 }
2523
2524 static HRESULT WINAPI MediaSeeking_ConvertTimeFormat(IMediaSeeking *iface, LONGLONG *pTarget,
2525         const GUID *pTargetFormat, LONGLONG Source, const GUID *pSourceFormat)
2526 {
2527     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2528
2529     TRACE("(%p/%p)->(%p, %s, 0x%s, %s)\n", This, iface, pTarget,
2530         debugstr_guid(pTargetFormat), wine_dbgstr_longlong(Source), debugstr_guid(pSourceFormat));
2531
2532     if (!pSourceFormat)
2533         pSourceFormat = &This->timeformatseek;
2534
2535     if (!pTargetFormat)
2536         pTargetFormat = &This->timeformatseek;
2537
2538     if (IsEqualGUID(pTargetFormat, pSourceFormat))
2539         *pTarget = Source;
2540     else
2541         FIXME("conversion %s->%s not supported\n", debugstr_guid(pSourceFormat), debugstr_guid(pTargetFormat));
2542
2543     return S_OK;
2544 }
2545
2546 struct pos_args {
2547     LONGLONG* current, *stop;
2548     DWORD curflags, stopflags;
2549 };
2550
2551 static HRESULT WINAPI found_setposition(IFilterGraphImpl *This, IMediaSeeking *seek, DWORD_PTR pargs)
2552 {
2553     struct pos_args *args = (void*)pargs;
2554
2555     return IMediaSeeking_SetPositions(seek, args->current, args->curflags, args->stop, args->stopflags);
2556 }
2557
2558 static HRESULT WINAPI MediaSeeking_SetPositions(IMediaSeeking *iface, LONGLONG *pCurrent,
2559         DWORD dwCurrentFlags, LONGLONG *pStop, DWORD dwStopFlags)
2560 {
2561     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2562     HRESULT hr = S_OK;
2563     FILTER_STATE state;
2564     struct pos_args args;
2565
2566     TRACE("(%p/%p)->(%p, %08x, %p, %08x)\n", This, iface, pCurrent, dwCurrentFlags, pStop, dwStopFlags);
2567
2568     EnterCriticalSection(&This->cs);
2569     state = This->state;
2570     TRACE("State: %s\n", state == State_Running ? "Running" : (state == State_Paused ? "Paused" : (state == State_Stopped ? "Stopped" : "UNKNOWN")));
2571
2572     if ((dwCurrentFlags & 0x7) != AM_SEEKING_AbsolutePositioning &&
2573         (dwCurrentFlags & 0x7) != AM_SEEKING_NoPositioning)
2574         FIXME("Adjust method %x not handled yet!\n", dwCurrentFlags & 0x7);
2575
2576     if ((dwStopFlags & 0x7) == AM_SEEKING_AbsolutePositioning)
2577         This->stop_position = *pStop;
2578     else if ((dwStopFlags & 0x7) != AM_SEEKING_NoPositioning)
2579         FIXME("Stop position not handled yet!\n");
2580
2581     if (state == State_Running && !(dwCurrentFlags & AM_SEEKING_NoFlush))
2582         IMediaControl_Pause(&This->IMediaControl_iface);
2583     args.current = pCurrent;
2584     args.stop = pStop;
2585     args.curflags = dwCurrentFlags;
2586     args.stopflags = dwStopFlags;
2587     hr = all_renderers_seek(This, found_setposition, (DWORD_PTR)&args);
2588
2589     if ((dwCurrentFlags & 0x7) != AM_SEEKING_NoPositioning)
2590         This->pause_time = This->start_time = -1;
2591     if (state == State_Running && !(dwCurrentFlags & AM_SEEKING_NoFlush))
2592         IMediaControl_Run(&This->IMediaControl_iface);
2593     LeaveCriticalSection(&This->cs);
2594
2595     return hr;
2596 }
2597
2598 static HRESULT WINAPI MediaSeeking_GetPositions(IMediaSeeking *iface, LONGLONG *pCurrent,
2599         LONGLONG *pStop)
2600 {
2601     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2602     HRESULT hr;
2603
2604     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pCurrent, pStop);
2605     hr = IMediaSeeking_GetCurrentPosition(iface, pCurrent);
2606     if (SUCCEEDED(hr))
2607         hr = IMediaSeeking_GetStopPosition(iface, pStop);
2608
2609     return hr;
2610 }
2611
2612 static HRESULT WINAPI MediaSeeking_GetAvailable(IMediaSeeking *iface, LONGLONG *pEarliest,
2613         LONGLONG *pLatest)
2614 {
2615     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2616
2617     FIXME("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pEarliest, pLatest);
2618
2619     return S_OK;
2620 }
2621
2622 static HRESULT WINAPI MediaSeeking_SetRate(IMediaSeeking *iface, double dRate)
2623 {
2624     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2625
2626     FIXME("(%p/%p)->(%f): stub !!!\n", This, iface, dRate);
2627
2628     return S_OK;
2629 }
2630
2631 static HRESULT WINAPI MediaSeeking_GetRate(IMediaSeeking *iface, double *pdRate)
2632 {
2633     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2634
2635     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pdRate);
2636
2637     if (!pdRate)
2638         return E_POINTER;
2639
2640     *pdRate = 1.0;
2641
2642     return S_OK;
2643 }
2644
2645 static HRESULT WINAPI MediaSeeking_GetPreroll(IMediaSeeking *iface, LONGLONG *pllPreroll)
2646 {
2647     IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2648
2649     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pllPreroll);
2650
2651     return S_OK;
2652 }
2653
2654
2655 static const IMediaSeekingVtbl IMediaSeeking_VTable =
2656 {
2657     MediaSeeking_QueryInterface,
2658     MediaSeeking_AddRef,
2659     MediaSeeking_Release,
2660     MediaSeeking_GetCapabilities,
2661     MediaSeeking_CheckCapabilities,
2662     MediaSeeking_IsFormatSupported,
2663     MediaSeeking_QueryPreferredFormat,
2664     MediaSeeking_GetTimeFormat,
2665     MediaSeeking_IsUsingTimeFormat,
2666     MediaSeeking_SetTimeFormat,
2667     MediaSeeking_GetDuration,
2668     MediaSeeking_GetStopPosition,
2669     MediaSeeking_GetCurrentPosition,
2670     MediaSeeking_ConvertTimeFormat,
2671     MediaSeeking_SetPositions,
2672     MediaSeeking_GetPositions,
2673     MediaSeeking_GetAvailable,
2674     MediaSeeking_SetRate,
2675     MediaSeeking_GetRate,
2676     MediaSeeking_GetPreroll
2677 };
2678
2679 static inline IFilterGraphImpl *impl_from_IMediaPosition(IMediaPosition *iface)
2680 {
2681     return CONTAINING_RECORD(iface, IFilterGraphImpl, IMediaPosition_iface);
2682 }
2683
2684 /*** IUnknown methods ***/
2685 static HRESULT WINAPI MediaPosition_QueryInterface(IMediaPosition* iface, REFIID riid, void** ppvObj)
2686 {
2687     IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2688
2689     TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
2690
2691     return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
2692 }
2693
2694 static ULONG WINAPI MediaPosition_AddRef(IMediaPosition *iface)
2695 {
2696     IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2697
2698     TRACE("(%p/%p)->()\n", This, iface);
2699
2700     return IUnknown_AddRef(This->outer_unk);
2701 }
2702
2703 static ULONG WINAPI MediaPosition_Release(IMediaPosition *iface)
2704 {
2705     IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2706
2707     TRACE("(%p/%p)->()\n", This, iface);
2708
2709     return IUnknown_Release(This->outer_unk);
2710 }
2711
2712 /*** IDispatch methods ***/
2713 static HRESULT WINAPI MediaPosition_GetTypeInfoCount(IMediaPosition *iface, UINT* pctinfo)
2714 {
2715     FIXME("(%p) stub!\n", iface);
2716     return E_NOTIMPL;
2717 }
2718
2719 static HRESULT WINAPI MediaPosition_GetTypeInfo(IMediaPosition *iface, UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
2720 {
2721     FIXME("(%p) stub!\n", iface);
2722     return E_NOTIMPL;
2723 }
2724
2725 static HRESULT WINAPI MediaPosition_GetIDsOfNames(IMediaPosition* iface, REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId)
2726 {
2727     FIXME("(%p) stub!\n", iface);
2728     return E_NOTIMPL;
2729 }
2730
2731 static HRESULT WINAPI MediaPosition_Invoke(IMediaPosition* iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
2732 {
2733     FIXME("(%p) stub!\n", iface);
2734     return E_NOTIMPL;
2735 }
2736
2737 static HRESULT ConvertFromREFTIME(IMediaSeeking *seek, REFTIME time_in, LONGLONG *time_out)
2738 {
2739     GUID time_format;
2740     HRESULT hr;
2741
2742     hr = MediaSeeking_GetTimeFormat(seek, &time_format);
2743     if (FAILED(hr))
2744         return hr;
2745     if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, &time_format))
2746     {
2747         FIXME("Unsupported time format.\n");
2748         return E_NOTIMPL;
2749     }
2750
2751     *time_out = (LONGLONG) (time_in * 10000000); /* convert from 1 second intervals to 100 ns intervals */
2752     return S_OK;
2753 }
2754
2755 static HRESULT ConvertToREFTIME(IMediaSeeking *seek, LONGLONG time_in, REFTIME *time_out)
2756 {
2757     GUID time_format;
2758     HRESULT hr;
2759
2760     hr = MediaSeeking_GetTimeFormat(seek, &time_format);
2761     if (FAILED(hr))
2762         return hr;
2763     if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, &time_format))
2764     {
2765         FIXME("Unsupported time format.\n");
2766         return E_NOTIMPL;
2767     }
2768
2769     *time_out = (REFTIME)time_in / 10000000; /* convert from 100 ns intervals to 1 second intervals */
2770     return S_OK;
2771 }
2772
2773 /*** IMediaPosition methods ***/
2774 static HRESULT WINAPI MediaPosition_get_Duration(IMediaPosition * iface, REFTIME *plength)
2775 {
2776     LONGLONG duration;
2777     IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2778     HRESULT hr = IMediaSeeking_GetDuration(&This->IMediaSeeking_iface, &duration);
2779     if (FAILED(hr))
2780         return hr;
2781     return ConvertToREFTIME(&This->IMediaSeeking_iface, duration, plength);
2782 }
2783
2784 static HRESULT WINAPI MediaPosition_put_CurrentPosition(IMediaPosition * iface, REFTIME llTime)
2785 {
2786     IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2787     LONGLONG reftime;
2788     HRESULT hr;
2789
2790     hr = ConvertFromREFTIME(&This->IMediaSeeking_iface, llTime, &reftime);
2791     if (FAILED(hr))
2792         return hr;
2793     return IMediaSeeking_SetPositions(&This->IMediaSeeking_iface, &reftime,
2794             AM_SEEKING_AbsolutePositioning, NULL, AM_SEEKING_NoPositioning);
2795 }
2796
2797 static HRESULT WINAPI MediaPosition_get_CurrentPosition(IMediaPosition * iface, REFTIME *pllTime)
2798 {
2799     IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2800     LONGLONG pos;
2801     HRESULT hr;
2802
2803     hr = IMediaSeeking_GetCurrentPosition(&This->IMediaSeeking_iface, &pos);
2804     if (FAILED(hr))
2805         return hr;
2806     return ConvertToREFTIME(&This->IMediaSeeking_iface, pos, pllTime);
2807 }
2808
2809 static HRESULT WINAPI MediaPosition_get_StopTime(IMediaPosition * iface, REFTIME *pllTime)
2810 {
2811     IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2812     LONGLONG pos;
2813     HRESULT hr = IMediaSeeking_GetStopPosition(&This->IMediaSeeking_iface, &pos);
2814     if (FAILED(hr))
2815         return hr;
2816     return ConvertToREFTIME(&This->IMediaSeeking_iface, pos, pllTime);
2817 }
2818
2819 static HRESULT WINAPI MediaPosition_put_StopTime(IMediaPosition * iface, REFTIME llTime)
2820 {
2821     IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2822     LONGLONG reftime;
2823     HRESULT hr;
2824
2825     hr = ConvertFromREFTIME(&This->IMediaSeeking_iface, llTime, &reftime);
2826     if (FAILED(hr))
2827         return hr;
2828     return IMediaSeeking_SetPositions(&This->IMediaSeeking_iface, NULL, AM_SEEKING_NoPositioning,
2829             &reftime, AM_SEEKING_AbsolutePositioning);
2830 }
2831
2832 static HRESULT WINAPI MediaPosition_get_PrerollTime(IMediaPosition * iface, REFTIME *pllTime)
2833 {
2834     FIXME("(%p)->(%p) stub!\n", iface, pllTime);
2835     return E_NOTIMPL;
2836 }
2837
2838 static HRESULT WINAPI MediaPosition_put_PrerollTime(IMediaPosition * iface, REFTIME llTime)
2839 {
2840     FIXME("(%p)->(%f) stub!\n", iface, llTime);
2841     return E_NOTIMPL;
2842 }
2843
2844 static HRESULT WINAPI MediaPosition_put_Rate(IMediaPosition * iface, double dRate)
2845 {
2846     IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2847     return IMediaSeeking_SetRate(&This->IMediaSeeking_iface, dRate);
2848 }
2849
2850 static HRESULT WINAPI MediaPosition_get_Rate(IMediaPosition * iface, double *pdRate)
2851 {
2852     IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2853     return IMediaSeeking_GetRate(&This->IMediaSeeking_iface, pdRate);
2854 }
2855
2856 static HRESULT WINAPI MediaPosition_CanSeekForward(IMediaPosition * iface, LONG *pCanSeekForward)
2857 {
2858     FIXME("(%p)->(%p) stub!\n", iface, pCanSeekForward);
2859     return E_NOTIMPL;
2860 }
2861
2862 static HRESULT WINAPI MediaPosition_CanSeekBackward(IMediaPosition * iface, LONG *pCanSeekBackward)
2863 {
2864     FIXME("(%p)->(%p) stub!\n", iface, pCanSeekBackward);
2865     return E_NOTIMPL;
2866 }
2867
2868
2869 static const IMediaPositionVtbl IMediaPosition_VTable =
2870 {
2871     MediaPosition_QueryInterface,
2872     MediaPosition_AddRef,
2873     MediaPosition_Release,
2874     MediaPosition_GetTypeInfoCount,
2875     MediaPosition_GetTypeInfo,
2876     MediaPosition_GetIDsOfNames,
2877     MediaPosition_Invoke,
2878     MediaPosition_get_Duration,
2879     MediaPosition_put_CurrentPosition,
2880     MediaPosition_get_CurrentPosition,
2881     MediaPosition_get_StopTime,
2882     MediaPosition_put_StopTime,
2883     MediaPosition_get_PrerollTime,
2884     MediaPosition_put_PrerollTime,
2885     MediaPosition_put_Rate,
2886     MediaPosition_get_Rate,
2887     MediaPosition_CanSeekForward,
2888     MediaPosition_CanSeekBackward
2889 };
2890
2891 static inline IFilterGraphImpl *impl_from_IObjectWithSite(IObjectWithSite *iface)
2892 {
2893     return CONTAINING_RECORD(iface, IFilterGraphImpl, IObjectWithSite_iface);
2894 }
2895
2896 /*** IUnknown methods ***/
2897 static HRESULT WINAPI ObjectWithSite_QueryInterface(IObjectWithSite* iface, REFIID riid, void** ppvObj)
2898 {
2899     IFilterGraphImpl *This = impl_from_IObjectWithSite( iface );
2900
2901     TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
2902
2903     return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
2904 }
2905
2906 static ULONG WINAPI ObjectWithSite_AddRef(IObjectWithSite *iface)
2907 {
2908     IFilterGraphImpl *This = impl_from_IObjectWithSite( iface );
2909
2910     TRACE("(%p/%p)->()\n", This, iface);
2911
2912     return IUnknown_AddRef(This->outer_unk);
2913 }
2914
2915 static ULONG WINAPI ObjectWithSite_Release(IObjectWithSite *iface)
2916 {
2917     IFilterGraphImpl *This = impl_from_IObjectWithSite( iface );
2918
2919     TRACE("(%p/%p)->()\n", This, iface);
2920
2921     return IUnknown_Release(This->outer_unk);
2922 }
2923
2924 /*** IObjectWithSite methods ***/
2925
2926 static HRESULT WINAPI ObjectWithSite_SetSite(IObjectWithSite *iface, IUnknown *pUnkSite)
2927 {
2928     IFilterGraphImpl *This = impl_from_IObjectWithSite( iface );
2929
2930     TRACE("(%p/%p)->()\n", This, iface);
2931     if (This->pSite) IUnknown_Release(This->pSite);
2932     This->pSite = pUnkSite;
2933     IUnknown_AddRef(This->pSite);
2934     return S_OK;
2935 }
2936
2937 static HRESULT WINAPI ObjectWithSite_GetSite(IObjectWithSite *iface, REFIID riid, PVOID *ppvSite)
2938 {
2939     IFilterGraphImpl *This = impl_from_IObjectWithSite( iface );
2940
2941     TRACE("(%p/%p)->(%s)\n", This, iface,debugstr_guid(riid));
2942
2943     *ppvSite = NULL;
2944     if (!This->pSite)
2945         return E_FAIL;
2946     else
2947         return IUnknown_QueryInterface(This->pSite, riid, ppvSite);
2948 }
2949
2950 static const IObjectWithSiteVtbl IObjectWithSite_VTable =
2951 {
2952     ObjectWithSite_QueryInterface,
2953     ObjectWithSite_AddRef,
2954     ObjectWithSite_Release,
2955     ObjectWithSite_SetSite,
2956     ObjectWithSite_GetSite,
2957 };
2958
2959 static HRESULT GetTargetInterface(IFilterGraphImpl* pGraph, REFIID riid, LPVOID* ppvObj)
2960 {
2961     HRESULT hr = E_NOINTERFACE;
2962     int i;
2963     int entry;
2964
2965     /* Check if the interface type is already registered */
2966     for (entry = 0; entry < pGraph->nItfCacheEntries; entry++)
2967         if (riid == pGraph->ItfCacheEntries[entry].riid)
2968         {
2969             if (pGraph->ItfCacheEntries[entry].iface)
2970             {
2971                 /* Return the interface if available */
2972                 *ppvObj = pGraph->ItfCacheEntries[entry].iface;
2973                 return S_OK;
2974             }
2975             break;
2976         }
2977
2978     if (entry >= MAX_ITF_CACHE_ENTRIES)
2979     {
2980         FIXME("Not enough space to store interface in the cache\n");
2981         return E_OUTOFMEMORY;
2982     }
2983
2984     /* Find a filter supporting the requested interface */
2985     for (i = 0; i < pGraph->nFilters; i++)
2986     {
2987         hr = IBaseFilter_QueryInterface(pGraph->ppFiltersInGraph[i], riid, ppvObj);
2988         if (hr == S_OK)
2989         {
2990             pGraph->ItfCacheEntries[entry].riid = riid;
2991             pGraph->ItfCacheEntries[entry].filter = pGraph->ppFiltersInGraph[i];
2992             pGraph->ItfCacheEntries[entry].iface = *ppvObj;
2993             if (entry >= pGraph->nItfCacheEntries)
2994                 pGraph->nItfCacheEntries++;
2995             return S_OK;
2996         }
2997         if (hr != E_NOINTERFACE)
2998             return hr;
2999     }
3000
3001     return hr;
3002 }
3003
3004 static inline IFilterGraphImpl *impl_from_IBasicAudio(IBasicAudio *iface)
3005 {
3006     return CONTAINING_RECORD(iface, IFilterGraphImpl, IBasicAudio_iface);
3007 }
3008
3009 static HRESULT WINAPI BasicAudio_QueryInterface(IBasicAudio *iface, REFIID riid, void **ppvObj)
3010 {
3011     IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3012
3013     TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
3014
3015     return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
3016 }
3017
3018 static ULONG WINAPI BasicAudio_AddRef(IBasicAudio *iface)
3019 {
3020     IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3021
3022     TRACE("(%p/%p)->()\n", This, iface);
3023
3024     return IUnknown_AddRef(This->outer_unk);
3025 }
3026
3027 static ULONG WINAPI BasicAudio_Release(IBasicAudio *iface)
3028 {
3029     IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3030
3031     TRACE("(%p/%p)->()\n", This, iface);
3032
3033     return IUnknown_Release(This->outer_unk);
3034 }
3035
3036 /*** IDispatch methods ***/
3037 static HRESULT WINAPI BasicAudio_GetTypeInfoCount(IBasicAudio *iface, UINT *pctinfo)
3038 {
3039     IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3040     IBasicAudio* pBasicAudio;
3041     HRESULT hr;
3042
3043     TRACE("(%p/%p)->(%p)\n", This, iface, pctinfo);
3044
3045     EnterCriticalSection(&This->cs);
3046
3047     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3048
3049     if (hr == S_OK)
3050         hr = IBasicAudio_GetTypeInfoCount(pBasicAudio, pctinfo);
3051
3052     LeaveCriticalSection(&This->cs);
3053
3054     return hr;
3055 }
3056
3057 static HRESULT WINAPI BasicAudio_GetTypeInfo(IBasicAudio *iface, UINT iTInfo, LCID lcid,
3058         ITypeInfo **ppTInfo)
3059 {
3060     IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3061     IBasicAudio* pBasicAudio;
3062     HRESULT hr;
3063
3064     TRACE("(%p/%p)->(%d, %d, %p)\n", This, iface, iTInfo, lcid, ppTInfo);
3065
3066     EnterCriticalSection(&This->cs);
3067
3068     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3069
3070     if (hr == S_OK)
3071         hr = IBasicAudio_GetTypeInfo(pBasicAudio, iTInfo, lcid, ppTInfo);
3072
3073     LeaveCriticalSection(&This->cs);
3074
3075     return hr;
3076 }
3077
3078 static HRESULT WINAPI BasicAudio_GetIDsOfNames(IBasicAudio *iface, REFIID riid, LPOLESTR *rgszNames,
3079         UINT cNames, LCID lcid, DISPID *rgDispId)
3080 {
3081     IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3082     IBasicAudio* pBasicAudio;
3083     HRESULT hr;
3084
3085     TRACE("(%p/%p)->(%s, %p, %d, %d, %p)\n", This, iface, debugstr_guid(riid), rgszNames, cNames,
3086             lcid, rgDispId);
3087
3088     EnterCriticalSection(&This->cs);
3089
3090     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3091
3092     if (hr == S_OK)
3093         hr = IBasicAudio_GetIDsOfNames(pBasicAudio, riid, rgszNames, cNames, lcid, rgDispId);
3094
3095     LeaveCriticalSection(&This->cs);
3096
3097     return hr;
3098 }
3099
3100 static HRESULT WINAPI BasicAudio_Invoke(IBasicAudio *iface, DISPID dispIdMember, REFIID riid,
3101         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo,
3102         UINT *puArgErr)
3103 {
3104     IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3105     IBasicAudio* pBasicAudio;
3106     HRESULT hr;
3107
3108     TRACE("(%p/%p)->(%d, %s, %d, %04x, %p, %p, %p, %p)\n", This, iface, dispIdMember,
3109             debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
3110
3111     EnterCriticalSection(&This->cs);
3112
3113     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3114
3115     if (hr == S_OK)
3116         hr = IBasicAudio_Invoke(pBasicAudio, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
3117
3118     LeaveCriticalSection(&This->cs);
3119
3120     return hr;
3121 }
3122
3123 /*** IBasicAudio methods ***/
3124 static HRESULT WINAPI BasicAudio_put_Volume(IBasicAudio *iface, LONG lVolume)
3125 {
3126     IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3127     IBasicAudio* pBasicAudio;
3128     HRESULT hr;
3129
3130     TRACE("(%p/%p)->(%d)\n", This, iface, lVolume);
3131
3132     EnterCriticalSection(&This->cs);
3133
3134     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3135
3136     if (hr == S_OK)
3137         hr = IBasicAudio_put_Volume(pBasicAudio, lVolume);
3138
3139     LeaveCriticalSection(&This->cs);
3140
3141     return hr;
3142 }
3143
3144 static HRESULT WINAPI BasicAudio_get_Volume(IBasicAudio *iface, LONG *plVolume)
3145 {
3146     IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3147     IBasicAudio* pBasicAudio;
3148     HRESULT hr;
3149
3150     TRACE("(%p/%p)->(%p)\n", This, iface, plVolume);
3151
3152     EnterCriticalSection(&This->cs);
3153
3154     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3155
3156     if (hr == S_OK)
3157         hr = IBasicAudio_get_Volume(pBasicAudio, plVolume);
3158
3159     LeaveCriticalSection(&This->cs);
3160
3161     return hr;
3162 }
3163
3164 static HRESULT WINAPI BasicAudio_put_Balance(IBasicAudio *iface, LONG lBalance)
3165 {
3166     IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3167     IBasicAudio* pBasicAudio;
3168     HRESULT hr;
3169
3170     TRACE("(%p/%p)->(%d)\n", This, iface, lBalance);
3171
3172     EnterCriticalSection(&This->cs);
3173
3174     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3175
3176     if (hr == S_OK)
3177         hr = IBasicAudio_put_Balance(pBasicAudio, lBalance);
3178
3179     LeaveCriticalSection(&This->cs);
3180
3181     return hr;
3182 }
3183
3184 static HRESULT WINAPI BasicAudio_get_Balance(IBasicAudio *iface, LONG *plBalance)
3185 {
3186     IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3187     IBasicAudio* pBasicAudio;
3188     HRESULT hr;
3189
3190     TRACE("(%p/%p)->(%p)\n", This, iface, plBalance);
3191
3192     EnterCriticalSection(&This->cs);
3193
3194     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3195
3196     if (hr == S_OK)
3197         hr = IBasicAudio_get_Balance(pBasicAudio, plBalance);
3198
3199     LeaveCriticalSection(&This->cs);
3200
3201     return hr;
3202 }
3203
3204 static const IBasicAudioVtbl IBasicAudio_VTable =
3205 {
3206     BasicAudio_QueryInterface,
3207     BasicAudio_AddRef,
3208     BasicAudio_Release,
3209     BasicAudio_GetTypeInfoCount,
3210     BasicAudio_GetTypeInfo,
3211     BasicAudio_GetIDsOfNames,
3212     BasicAudio_Invoke,
3213     BasicAudio_put_Volume,
3214     BasicAudio_get_Volume,
3215     BasicAudio_put_Balance,
3216     BasicAudio_get_Balance
3217 };
3218
3219 static inline IFilterGraphImpl *impl_from_IBasicVideo2(IBasicVideo2 *iface)
3220 {
3221     return CONTAINING_RECORD(iface, IFilterGraphImpl, IBasicVideo2_iface);
3222 }
3223
3224 static HRESULT WINAPI BasicVideo_QueryInterface(IBasicVideo2 *iface, REFIID riid, void **ppvObj)
3225 {
3226     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3227
3228     TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
3229
3230     return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
3231 }
3232
3233 static ULONG WINAPI BasicVideo_AddRef(IBasicVideo2 *iface)
3234 {
3235     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3236
3237     TRACE("(%p/%p)->()\n", This, iface);
3238
3239     return IUnknown_AddRef(This->outer_unk);
3240 }
3241
3242 static ULONG WINAPI BasicVideo_Release(IBasicVideo2 *iface)
3243 {
3244     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3245
3246     TRACE("(%p/%p)->()\n", This, iface);
3247
3248     return IUnknown_Release(This->outer_unk);
3249 }
3250
3251 /*** IDispatch methods ***/
3252 static HRESULT WINAPI BasicVideo_GetTypeInfoCount(IBasicVideo2 *iface, UINT *pctinfo)
3253 {
3254     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3255     IBasicVideo *pBasicVideo;
3256     HRESULT hr;
3257
3258     TRACE("(%p/%p)->(%p)\n", This, iface, pctinfo);
3259
3260     EnterCriticalSection(&This->cs);
3261
3262     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3263
3264     if (hr == S_OK)
3265         hr = IBasicVideo_GetTypeInfoCount(pBasicVideo, pctinfo);
3266
3267     LeaveCriticalSection(&This->cs);
3268
3269     return hr;
3270 }
3271
3272 static HRESULT WINAPI BasicVideo_GetTypeInfo(IBasicVideo2 *iface, UINT iTInfo, LCID lcid,
3273         ITypeInfo **ppTInfo)
3274 {
3275     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3276     IBasicVideo *pBasicVideo;
3277     HRESULT hr;
3278
3279     TRACE("(%p/%p)->(%d, %d, %p)\n", This, iface, iTInfo, lcid, ppTInfo);
3280
3281     EnterCriticalSection(&This->cs);
3282
3283     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3284
3285     if (hr == S_OK)
3286         hr = IBasicVideo_GetTypeInfo(pBasicVideo, iTInfo, lcid, ppTInfo);
3287
3288     LeaveCriticalSection(&This->cs);
3289
3290     return hr;
3291 }
3292
3293 static HRESULT WINAPI BasicVideo_GetIDsOfNames(IBasicVideo2 *iface, REFIID riid,
3294         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
3295 {
3296     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3297     IBasicVideo *pBasicVideo;
3298     HRESULT hr;
3299
3300     TRACE("(%p/%p)->(%s, %p, %d, %d, %p)\n", This, iface, debugstr_guid(riid), rgszNames, cNames,
3301             lcid, rgDispId);
3302
3303     EnterCriticalSection(&This->cs);
3304
3305     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3306
3307     if (hr == S_OK)
3308         hr = IBasicVideo_GetIDsOfNames(pBasicVideo, riid, rgszNames, cNames, lcid, rgDispId);
3309
3310     LeaveCriticalSection(&This->cs);
3311
3312     return hr;
3313 }
3314
3315 static HRESULT WINAPI BasicVideo_Invoke(IBasicVideo2 *iface, DISPID dispIdMember, REFIID riid,
3316         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo,
3317         UINT *puArgErr)
3318 {
3319     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3320     IBasicVideo *pBasicVideo;
3321     HRESULT hr;
3322
3323     TRACE("(%p/%p)->(%d, %s, %d, %04x, %p, %p, %p, %p)\n", This, iface, dispIdMember,
3324             debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
3325
3326     EnterCriticalSection(&This->cs);
3327
3328     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3329
3330     if (hr == S_OK)
3331         hr = IBasicVideo_Invoke(pBasicVideo, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
3332
3333     LeaveCriticalSection(&This->cs);
3334
3335     return hr;
3336 }
3337
3338 /*** IBasicVideo methods ***/
3339 static HRESULT WINAPI BasicVideo_get_AvgTimePerFrame(IBasicVideo2 *iface, REFTIME *pAvgTimePerFrame)
3340 {
3341     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3342     IBasicVideo *pBasicVideo;
3343     HRESULT hr;
3344
3345     TRACE("(%p/%p)->(%p)\n", This, iface, pAvgTimePerFrame);
3346
3347     EnterCriticalSection(&This->cs);
3348
3349     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3350
3351     if (hr == S_OK)
3352         hr = IBasicVideo_get_AvgTimePerFrame(pBasicVideo, pAvgTimePerFrame);
3353
3354     LeaveCriticalSection(&This->cs);
3355
3356     return hr;
3357 }
3358
3359 static HRESULT WINAPI BasicVideo_get_BitRate(IBasicVideo2 *iface, LONG *pBitRate)
3360 {
3361     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3362     IBasicVideo *pBasicVideo;
3363     HRESULT hr;
3364
3365     TRACE("(%p/%p)->(%p)\n", This, iface, pBitRate);
3366
3367     EnterCriticalSection(&This->cs);
3368
3369     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3370
3371     if (hr == S_OK)
3372         hr = IBasicVideo_get_BitRate(pBasicVideo, pBitRate);
3373
3374     LeaveCriticalSection(&This->cs);
3375
3376     return hr;
3377 }
3378
3379 static HRESULT WINAPI BasicVideo_get_BitErrorRate(IBasicVideo2 *iface, LONG *pBitErrorRate)
3380 {
3381     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3382     IBasicVideo *pBasicVideo;
3383     HRESULT hr;
3384
3385     TRACE("(%p/%p)->(%p)\n", This, iface, pBitErrorRate);
3386
3387     EnterCriticalSection(&This->cs);
3388
3389     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3390
3391     if (hr == S_OK)
3392         hr = IBasicVideo_get_BitErrorRate(pBasicVideo, pBitErrorRate);
3393
3394     LeaveCriticalSection(&This->cs);
3395
3396     return hr;
3397 }
3398
3399 static HRESULT WINAPI BasicVideo_get_VideoWidth(IBasicVideo2 *iface, LONG *pVideoWidth)
3400 {
3401     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3402     IBasicVideo *pBasicVideo;
3403     HRESULT hr;
3404
3405     TRACE("(%p/%p)->(%p)\n", This, iface, pVideoWidth);
3406
3407     EnterCriticalSection(&This->cs);
3408
3409     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3410
3411     if (hr == S_OK)
3412         hr = IBasicVideo_get_VideoWidth(pBasicVideo, pVideoWidth);
3413
3414     LeaveCriticalSection(&This->cs);
3415
3416     return hr;
3417 }
3418
3419 static HRESULT WINAPI BasicVideo_get_VideoHeight(IBasicVideo2 *iface, LONG *pVideoHeight)
3420 {
3421     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3422     IBasicVideo *pBasicVideo;
3423     HRESULT hr;
3424
3425     TRACE("(%p/%p)->(%p)\n", This, iface, pVideoHeight);
3426
3427     EnterCriticalSection(&This->cs);
3428
3429     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3430
3431     if (hr == S_OK)
3432         hr = IBasicVideo_get_VideoHeight(pBasicVideo, pVideoHeight);
3433
3434     LeaveCriticalSection(&This->cs);
3435
3436     return hr;
3437 }
3438
3439 static HRESULT WINAPI BasicVideo_put_SourceLeft(IBasicVideo2 *iface, LONG SourceLeft)
3440 {
3441     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3442     IBasicVideo *pBasicVideo;
3443     HRESULT hr;
3444
3445     TRACE("(%p/%p)->(%d)\n", This, iface, SourceLeft);
3446
3447     EnterCriticalSection(&This->cs);
3448
3449     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3450
3451     if (hr == S_OK)
3452         hr = IBasicVideo_put_SourceLeft(pBasicVideo, SourceLeft);
3453
3454     LeaveCriticalSection(&This->cs);
3455
3456     return hr;
3457 }
3458
3459 static HRESULT WINAPI BasicVideo_get_SourceLeft(IBasicVideo2 *iface, LONG *pSourceLeft)
3460 {
3461     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3462     IBasicVideo *pBasicVideo;
3463     HRESULT hr;
3464
3465     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceLeft);
3466
3467     EnterCriticalSection(&This->cs);
3468
3469     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3470
3471     if (hr == S_OK)
3472         hr = IBasicVideo_get_SourceLeft(pBasicVideo, pSourceLeft);
3473
3474     LeaveCriticalSection(&This->cs);
3475
3476     return hr;
3477 }
3478
3479 static HRESULT WINAPI BasicVideo_put_SourceWidth(IBasicVideo2 *iface, LONG SourceWidth)
3480 {
3481     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3482     IBasicVideo *pBasicVideo;
3483     HRESULT hr;
3484
3485     TRACE("(%p/%p)->(%d)\n", This, iface, SourceWidth);
3486
3487     EnterCriticalSection(&This->cs);
3488
3489     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3490
3491     if (hr == S_OK)
3492         hr = IBasicVideo_put_SourceWidth(pBasicVideo, SourceWidth);
3493
3494     LeaveCriticalSection(&This->cs);
3495
3496     return hr;
3497 }
3498
3499 static HRESULT WINAPI BasicVideo_get_SourceWidth(IBasicVideo2 *iface, LONG *pSourceWidth)
3500 {
3501     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3502     IBasicVideo *pBasicVideo;
3503     HRESULT hr;
3504
3505     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceWidth);
3506
3507     EnterCriticalSection(&This->cs);
3508
3509     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3510
3511     if (hr == S_OK)
3512         hr = IBasicVideo_get_SourceWidth(pBasicVideo, pSourceWidth);
3513
3514     LeaveCriticalSection(&This->cs);
3515
3516     return hr;
3517 }
3518
3519 static HRESULT WINAPI BasicVideo_put_SourceTop(IBasicVideo2 *iface, LONG SourceTop)
3520 {
3521     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3522     IBasicVideo *pBasicVideo;
3523     HRESULT hr;
3524
3525     TRACE("(%p/%p)->(%d)\n", This, iface, SourceTop);
3526
3527     EnterCriticalSection(&This->cs);
3528
3529     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3530
3531     if (hr == S_OK)
3532         hr = IBasicVideo_put_SourceTop(pBasicVideo, SourceTop);
3533
3534     LeaveCriticalSection(&This->cs);
3535
3536     return hr;
3537 }
3538
3539 static HRESULT WINAPI BasicVideo_get_SourceTop(IBasicVideo2 *iface, LONG *pSourceTop)
3540 {
3541     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3542     IBasicVideo *pBasicVideo;
3543     HRESULT hr;
3544
3545     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceTop);
3546
3547     EnterCriticalSection(&This->cs);
3548
3549     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3550
3551     if (hr == S_OK)
3552         hr = IBasicVideo_get_SourceTop(pBasicVideo, pSourceTop);
3553
3554     LeaveCriticalSection(&This->cs);
3555
3556     return hr;
3557 }
3558
3559 static HRESULT WINAPI BasicVideo_put_SourceHeight(IBasicVideo2 *iface, LONG SourceHeight)
3560 {
3561     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3562     IBasicVideo *pBasicVideo;
3563     HRESULT hr;
3564
3565     TRACE("(%p/%p)->(%d)\n", This, iface, SourceHeight);
3566
3567     EnterCriticalSection(&This->cs);
3568
3569     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3570
3571     if (hr == S_OK)
3572         hr = IBasicVideo_put_SourceHeight(pBasicVideo, SourceHeight);
3573
3574     LeaveCriticalSection(&This->cs);
3575
3576     return hr;
3577 }
3578
3579 static HRESULT WINAPI BasicVideo_get_SourceHeight(IBasicVideo2 *iface, LONG *pSourceHeight)
3580 {
3581     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3582     IBasicVideo *pBasicVideo;
3583     HRESULT hr;
3584
3585     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceHeight);
3586
3587     EnterCriticalSection(&This->cs);
3588
3589     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3590
3591     if (hr == S_OK)
3592         hr = IBasicVideo_get_SourceHeight(pBasicVideo, pSourceHeight);
3593
3594     LeaveCriticalSection(&This->cs);
3595
3596     return hr;
3597 }
3598
3599 static HRESULT WINAPI BasicVideo_put_DestinationLeft(IBasicVideo2 *iface, LONG DestinationLeft)
3600 {
3601     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3602     IBasicVideo *pBasicVideo;
3603     HRESULT hr;
3604
3605     TRACE("(%p/%p)->(%d)\n", This, iface, DestinationLeft);
3606
3607     EnterCriticalSection(&This->cs);
3608
3609     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3610
3611     if (hr == S_OK)
3612         hr = IBasicVideo_put_DestinationLeft(pBasicVideo, DestinationLeft);
3613
3614     LeaveCriticalSection(&This->cs);
3615
3616     return hr;
3617 }
3618
3619 static HRESULT WINAPI BasicVideo_get_DestinationLeft(IBasicVideo2 *iface, LONG *pDestinationLeft)
3620 {
3621     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3622     IBasicVideo *pBasicVideo;
3623     HRESULT hr;
3624
3625     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationLeft);
3626
3627     EnterCriticalSection(&This->cs);
3628
3629     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3630
3631     if (hr == S_OK)
3632         hr = IBasicVideo_get_DestinationLeft(pBasicVideo, pDestinationLeft);
3633
3634     LeaveCriticalSection(&This->cs);
3635
3636     return hr;
3637 }
3638
3639 static HRESULT WINAPI BasicVideo_put_DestinationWidth(IBasicVideo2 *iface, LONG DestinationWidth)
3640 {
3641     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3642     IBasicVideo *pBasicVideo;
3643     HRESULT hr;
3644
3645     TRACE("(%p/%p)->(%d)\n", This, iface, DestinationWidth);
3646
3647     EnterCriticalSection(&This->cs);
3648
3649     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3650
3651     if (hr == S_OK)
3652         hr = IBasicVideo_put_DestinationWidth(pBasicVideo, DestinationWidth);
3653
3654     LeaveCriticalSection(&This->cs);
3655
3656     return hr;
3657 }
3658
3659 static HRESULT WINAPI BasicVideo_get_DestinationWidth(IBasicVideo2 *iface, LONG *pDestinationWidth)
3660 {
3661     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3662     IBasicVideo *pBasicVideo;
3663     HRESULT hr;
3664
3665     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationWidth);
3666
3667     EnterCriticalSection(&This->cs);
3668
3669     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3670
3671     if (hr == S_OK)
3672         hr = IBasicVideo_get_DestinationWidth(pBasicVideo, pDestinationWidth);
3673
3674     LeaveCriticalSection(&This->cs);
3675
3676     return hr;
3677 }
3678
3679 static HRESULT WINAPI BasicVideo_put_DestinationTop(IBasicVideo2 *iface, LONG DestinationTop)
3680 {
3681     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3682     IBasicVideo *pBasicVideo;
3683     HRESULT hr;
3684
3685     TRACE("(%p/%p)->(%d)\n", This, iface, DestinationTop);
3686
3687     EnterCriticalSection(&This->cs);
3688
3689     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3690
3691     if (hr == S_OK)
3692         hr = IBasicVideo_put_DestinationTop(pBasicVideo, DestinationTop);
3693
3694     LeaveCriticalSection(&This->cs);
3695
3696     return hr;
3697 }
3698
3699 static HRESULT WINAPI BasicVideo_get_DestinationTop(IBasicVideo2 *iface, LONG *pDestinationTop)
3700 {
3701     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3702     IBasicVideo *pBasicVideo;
3703     HRESULT hr;
3704
3705     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationTop);
3706
3707     EnterCriticalSection(&This->cs);
3708
3709     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3710
3711     if (hr == S_OK)
3712         hr = IBasicVideo_get_DestinationTop(pBasicVideo, pDestinationTop);
3713
3714     LeaveCriticalSection(&This->cs);
3715
3716     return hr;
3717 }
3718
3719 static HRESULT WINAPI BasicVideo_put_DestinationHeight(IBasicVideo2 *iface, LONG DestinationHeight)
3720 {
3721     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3722     IBasicVideo *pBasicVideo;
3723     HRESULT hr;
3724
3725     TRACE("(%p/%p)->(%d)\n", This, iface, DestinationHeight);
3726
3727     EnterCriticalSection(&This->cs);
3728
3729     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3730
3731     if (hr == S_OK)
3732         hr = IBasicVideo_put_DestinationHeight(pBasicVideo, DestinationHeight);
3733
3734     LeaveCriticalSection(&This->cs);
3735
3736     return hr;
3737 }
3738
3739 static HRESULT WINAPI BasicVideo_get_DestinationHeight(IBasicVideo2 *iface,
3740         LONG *pDestinationHeight)
3741 {
3742     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3743     IBasicVideo *pBasicVideo;
3744     HRESULT hr;
3745
3746     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationHeight);
3747
3748     EnterCriticalSection(&This->cs);
3749
3750     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3751
3752     if (hr == S_OK)
3753         hr = IBasicVideo_get_DestinationHeight(pBasicVideo, pDestinationHeight);
3754
3755     LeaveCriticalSection(&This->cs);
3756
3757     return hr;
3758 }
3759
3760 static HRESULT WINAPI BasicVideo_SetSourcePosition(IBasicVideo2 *iface, LONG Left, LONG Top,
3761         LONG Width, LONG Height)
3762 {
3763     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3764     IBasicVideo *pBasicVideo;
3765     HRESULT hr;
3766
3767     TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
3768
3769     EnterCriticalSection(&This->cs);
3770
3771     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3772
3773     if (hr == S_OK)
3774         hr = IBasicVideo_SetSourcePosition(pBasicVideo, Left, Top, Width, Height);
3775
3776     LeaveCriticalSection(&This->cs);
3777
3778     return hr;
3779 }
3780
3781 static HRESULT WINAPI BasicVideo_GetSourcePosition(IBasicVideo2 *iface, LONG *pLeft, LONG *pTop,
3782         LONG *pWidth, LONG *pHeight)
3783 {
3784     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3785     IBasicVideo *pBasicVideo;
3786     HRESULT hr;
3787
3788     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
3789
3790     EnterCriticalSection(&This->cs);
3791
3792     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3793
3794     if (hr == S_OK)
3795         hr = IBasicVideo_GetSourcePosition(pBasicVideo, pLeft, pTop, pWidth, pHeight);
3796
3797     LeaveCriticalSection(&This->cs);
3798
3799     return hr;
3800 }
3801
3802 static HRESULT WINAPI BasicVideo_SetDefaultSourcePosition(IBasicVideo2 *iface)
3803 {
3804     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3805     IBasicVideo *pBasicVideo;
3806     HRESULT hr;
3807
3808     TRACE("(%p/%p)->()\n", This, iface);
3809
3810     EnterCriticalSection(&This->cs);
3811
3812     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3813
3814     if (hr == S_OK)
3815         hr = IBasicVideo_SetDefaultSourcePosition(pBasicVideo);
3816
3817     LeaveCriticalSection(&This->cs);
3818
3819     return hr;
3820 }
3821
3822 static HRESULT WINAPI BasicVideo_SetDestinationPosition(IBasicVideo2 *iface, LONG Left, LONG Top,
3823         LONG Width, LONG Height)
3824 {
3825     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3826     IBasicVideo *pBasicVideo;
3827     HRESULT hr;
3828
3829     TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
3830
3831     EnterCriticalSection(&This->cs);
3832
3833     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3834
3835     if (hr == S_OK)
3836         hr = IBasicVideo_SetDestinationPosition(pBasicVideo, Left, Top, Width, Height);
3837
3838     LeaveCriticalSection(&This->cs);
3839
3840     return hr;
3841 }
3842
3843 static HRESULT WINAPI BasicVideo_GetDestinationPosition(IBasicVideo2 *iface, LONG *pLeft,
3844         LONG *pTop, LONG *pWidth, LONG *pHeight)
3845 {
3846     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3847     IBasicVideo *pBasicVideo;
3848     HRESULT hr;
3849
3850     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
3851
3852     EnterCriticalSection(&This->cs);
3853
3854     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3855
3856     if (hr == S_OK)
3857         hr = IBasicVideo_GetDestinationPosition(pBasicVideo, pLeft, pTop, pWidth, pHeight);
3858
3859     LeaveCriticalSection(&This->cs);
3860
3861     return hr;
3862 }
3863
3864 static HRESULT WINAPI BasicVideo_SetDefaultDestinationPosition(IBasicVideo2 *iface)
3865 {
3866     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3867     IBasicVideo *pBasicVideo;
3868     HRESULT hr;
3869
3870     TRACE("(%p/%p)->()\n", This, iface);
3871
3872     EnterCriticalSection(&This->cs);
3873
3874     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3875
3876     if (hr == S_OK)
3877         hr = IBasicVideo_SetDefaultDestinationPosition(pBasicVideo);
3878
3879     LeaveCriticalSection(&This->cs);
3880
3881     return hr;
3882 }
3883
3884 static HRESULT WINAPI BasicVideo_GetVideoSize(IBasicVideo2 *iface, LONG *pWidth, LONG *pHeight)
3885 {
3886     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3887     IBasicVideo *pBasicVideo;
3888     HRESULT hr;
3889
3890     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
3891
3892     EnterCriticalSection(&This->cs);
3893
3894     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3895
3896     if (hr == S_OK)
3897         hr = IBasicVideo_GetVideoSize(pBasicVideo, pWidth, pHeight);
3898
3899     LeaveCriticalSection(&This->cs);
3900
3901     return hr;
3902 }
3903
3904 static HRESULT WINAPI BasicVideo_GetVideoPaletteEntries(IBasicVideo2 *iface, LONG StartIndex,
3905         LONG Entries, LONG *pRetrieved, LONG *pPalette)
3906 {
3907     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3908     IBasicVideo *pBasicVideo;
3909     HRESULT hr;
3910
3911     TRACE("(%p/%p)->(%d, %d, %p, %p)\n", This, iface, StartIndex, Entries, pRetrieved, pPalette);
3912
3913     EnterCriticalSection(&This->cs);
3914
3915     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3916
3917     if (hr == S_OK)
3918         hr = IBasicVideo_GetVideoPaletteEntries(pBasicVideo, StartIndex, Entries, pRetrieved, pPalette);
3919
3920     LeaveCriticalSection(&This->cs);
3921
3922     return hr;
3923 }
3924
3925 static HRESULT WINAPI BasicVideo_GetCurrentImage(IBasicVideo2 *iface, LONG *pBufferSize,
3926         LONG *pDIBImage)
3927 {
3928     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3929     IBasicVideo *pBasicVideo;
3930     HRESULT hr;
3931
3932     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pBufferSize, pDIBImage);
3933
3934     EnterCriticalSection(&This->cs);
3935
3936     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3937
3938     if (hr == S_OK)
3939         hr = IBasicVideo_GetCurrentImage(pBasicVideo, pBufferSize, pDIBImage);
3940
3941     LeaveCriticalSection(&This->cs);
3942
3943     return hr;
3944 }
3945
3946 static HRESULT WINAPI BasicVideo_IsUsingDefaultSource(IBasicVideo2 *iface)
3947 {
3948     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3949     IBasicVideo *pBasicVideo;
3950     HRESULT hr;
3951
3952     TRACE("(%p/%p)->()\n", This, iface);
3953
3954     EnterCriticalSection(&This->cs);
3955
3956     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3957
3958     if (hr == S_OK)
3959         hr = IBasicVideo_IsUsingDefaultSource(pBasicVideo);
3960
3961     LeaveCriticalSection(&This->cs);
3962
3963     return hr;
3964 }
3965
3966 static HRESULT WINAPI BasicVideo_IsUsingDefaultDestination(IBasicVideo2 *iface)
3967 {
3968     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3969     IBasicVideo *pBasicVideo;
3970     HRESULT hr;
3971
3972     TRACE("(%p/%p)->()\n", This, iface);
3973
3974     EnterCriticalSection(&This->cs);
3975
3976     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3977
3978     if (hr == S_OK)
3979         hr = IBasicVideo_IsUsingDefaultDestination(pBasicVideo);
3980
3981     LeaveCriticalSection(&This->cs);
3982
3983     return hr;
3984 }
3985
3986 static HRESULT WINAPI BasicVideo2_GetPreferredAspectRatio(IBasicVideo2 *iface, LONG *plAspectX,
3987         LONG *plAspectY)
3988 {
3989     IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3990     IBasicVideo2 *pBasicVideo2;
3991     HRESULT hr;
3992
3993     TRACE("(%p/%p)->()\n", This, iface);
3994
3995     EnterCriticalSection(&This->cs);
3996
3997     hr = GetTargetInterface(This, &IID_IBasicVideo2, (LPVOID*)&pBasicVideo2);
3998
3999     if (hr == S_OK)
4000         hr = BasicVideo2_GetPreferredAspectRatio(iface, plAspectX, plAspectY);
4001
4002     LeaveCriticalSection(&This->cs);
4003
4004     return hr;
4005 }
4006
4007 static const IBasicVideo2Vtbl IBasicVideo_VTable =
4008 {
4009     BasicVideo_QueryInterface,
4010     BasicVideo_AddRef,
4011     BasicVideo_Release,
4012     BasicVideo_GetTypeInfoCount,
4013     BasicVideo_GetTypeInfo,
4014     BasicVideo_GetIDsOfNames,
4015     BasicVideo_Invoke,
4016     BasicVideo_get_AvgTimePerFrame,
4017     BasicVideo_get_BitRate,
4018     BasicVideo_get_BitErrorRate,
4019     BasicVideo_get_VideoWidth,
4020     BasicVideo_get_VideoHeight,
4021     BasicVideo_put_SourceLeft,
4022     BasicVideo_get_SourceLeft,
4023     BasicVideo_put_SourceWidth,
4024     BasicVideo_get_SourceWidth,
4025     BasicVideo_put_SourceTop,
4026     BasicVideo_get_SourceTop,
4027     BasicVideo_put_SourceHeight,
4028     BasicVideo_get_SourceHeight,
4029     BasicVideo_put_DestinationLeft,
4030     BasicVideo_get_DestinationLeft,
4031     BasicVideo_put_DestinationWidth,
4032     BasicVideo_get_DestinationWidth,
4033     BasicVideo_put_DestinationTop,
4034     BasicVideo_get_DestinationTop,
4035     BasicVideo_put_DestinationHeight,
4036     BasicVideo_get_DestinationHeight,
4037     BasicVideo_SetSourcePosition,
4038     BasicVideo_GetSourcePosition,
4039     BasicVideo_SetDefaultSourcePosition,
4040     BasicVideo_SetDestinationPosition,
4041     BasicVideo_GetDestinationPosition,
4042     BasicVideo_SetDefaultDestinationPosition,
4043     BasicVideo_GetVideoSize,
4044     BasicVideo_GetVideoPaletteEntries,
4045     BasicVideo_GetCurrentImage,
4046     BasicVideo_IsUsingDefaultSource,
4047     BasicVideo_IsUsingDefaultDestination,
4048     BasicVideo2_GetPreferredAspectRatio
4049 };
4050
4051 static inline IFilterGraphImpl *impl_from_IVideoWindow(IVideoWindow *iface)
4052 {
4053     return CONTAINING_RECORD(iface, IFilterGraphImpl, IVideoWindow_iface);
4054 }
4055
4056 static HRESULT WINAPI VideoWindow_QueryInterface(IVideoWindow *iface, REFIID riid, void **ppvObj)
4057 {
4058     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4059
4060     TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
4061
4062     return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
4063 }
4064
4065 static ULONG WINAPI VideoWindow_AddRef(IVideoWindow *iface)
4066 {
4067     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4068
4069     TRACE("(%p/%p)->()\n", This, iface);
4070
4071     return IUnknown_AddRef(This->outer_unk);
4072 }
4073
4074 static ULONG WINAPI VideoWindow_Release(IVideoWindow *iface)
4075 {
4076     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4077
4078     TRACE("(%p/%p)->()\n", This, iface);
4079
4080     return IUnknown_Release(This->outer_unk);
4081 }
4082
4083 /*** IDispatch methods ***/
4084 static HRESULT WINAPI VideoWindow_GetTypeInfoCount(IVideoWindow *iface, UINT *pctinfo)
4085 {
4086     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4087     IVideoWindow *pVideoWindow;
4088     HRESULT hr;
4089
4090     TRACE("(%p/%p)->(%p)\n", This, iface, pctinfo);
4091
4092     EnterCriticalSection(&This->cs);
4093
4094     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4095
4096     if (hr == S_OK)
4097         hr = IVideoWindow_GetTypeInfoCount(pVideoWindow, pctinfo);
4098
4099     LeaveCriticalSection(&This->cs);
4100
4101     return hr;
4102 }
4103
4104 static HRESULT WINAPI VideoWindow_GetTypeInfo(IVideoWindow *iface, UINT iTInfo, LCID lcid,
4105         ITypeInfo **ppTInfo)
4106 {
4107     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4108     IVideoWindow *pVideoWindow;
4109     HRESULT hr;
4110
4111     TRACE("(%p/%p)->(%d, %d, %p)\n", This, iface, iTInfo, lcid, ppTInfo);
4112
4113     EnterCriticalSection(&This->cs);
4114
4115     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4116
4117     if (hr == S_OK)
4118         hr = IVideoWindow_GetTypeInfo(pVideoWindow, iTInfo, lcid, ppTInfo);
4119
4120     LeaveCriticalSection(&This->cs);
4121
4122     return hr;
4123 }
4124
4125 static HRESULT WINAPI VideoWindow_GetIDsOfNames(IVideoWindow *iface, REFIID riid,
4126         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4127 {
4128     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4129     IVideoWindow *pVideoWindow;
4130     HRESULT hr;
4131
4132     TRACE("(%p/%p)->(%s, %p, %d, %d, %p)\n", This, iface, debugstr_guid(riid), rgszNames, cNames,
4133             lcid, rgDispId);
4134
4135     EnterCriticalSection(&This->cs);
4136
4137     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4138
4139     if (hr == S_OK)
4140         hr = IVideoWindow_GetIDsOfNames(pVideoWindow, riid, rgszNames, cNames, lcid, rgDispId);
4141
4142     LeaveCriticalSection(&This->cs);
4143
4144     return hr;
4145 }
4146
4147 static HRESULT WINAPI VideoWindow_Invoke(IVideoWindow *iface, DISPID dispIdMember, REFIID riid,
4148         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo,
4149         UINT*puArgErr)
4150 {
4151     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4152     IVideoWindow *pVideoWindow;
4153     HRESULT hr;
4154
4155     TRACE("(%p/%p)->(%d, %s, %d, %04x, %p, %p, %p, %p)\n", This, iface, dispIdMember,
4156             debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
4157
4158     EnterCriticalSection(&This->cs);
4159
4160     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4161
4162     if (hr == S_OK)
4163         hr = IVideoWindow_Invoke(pVideoWindow, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
4164
4165     LeaveCriticalSection(&This->cs);
4166
4167     return hr;
4168 }
4169
4170
4171 /*** IVideoWindow methods ***/
4172 static HRESULT WINAPI VideoWindow_put_Caption(IVideoWindow *iface, BSTR strCaption)
4173 {
4174     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4175     IVideoWindow *pVideoWindow;
4176     HRESULT hr;
4177
4178     TRACE("(%p/%p)->(%s (%p))\n", This, iface, debugstr_w(strCaption), strCaption);
4179
4180     EnterCriticalSection(&This->cs);
4181
4182     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4183
4184     if (hr == S_OK)
4185         hr = IVideoWindow_put_Caption(pVideoWindow, strCaption);
4186
4187     LeaveCriticalSection(&This->cs);
4188
4189     return hr;
4190 }
4191
4192 static HRESULT WINAPI VideoWindow_get_Caption(IVideoWindow *iface, BSTR *strCaption)
4193 {
4194     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4195     IVideoWindow *pVideoWindow;
4196     HRESULT hr;
4197
4198     TRACE("(%p/%p)->(%p)\n", This, iface, strCaption);
4199
4200     EnterCriticalSection(&This->cs);
4201
4202     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4203
4204     if (hr == S_OK)
4205         hr = IVideoWindow_get_Caption(pVideoWindow, strCaption);
4206
4207     LeaveCriticalSection(&This->cs);
4208
4209     return hr;
4210 }
4211
4212 static HRESULT WINAPI VideoWindow_put_WindowStyle(IVideoWindow *iface, LONG WindowStyle)
4213 {
4214     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4215     IVideoWindow *pVideoWindow;
4216     HRESULT hr;
4217
4218     TRACE("(%p/%p)->(%d)\n", This, iface, WindowStyle);
4219
4220     EnterCriticalSection(&This->cs);
4221
4222     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4223
4224     if (hr == S_OK)
4225         hr = IVideoWindow_put_WindowStyle(pVideoWindow, WindowStyle);
4226
4227     LeaveCriticalSection(&This->cs);
4228
4229     return hr;
4230 }
4231
4232 static HRESULT WINAPI VideoWindow_get_WindowStyle(IVideoWindow *iface, LONG *WindowStyle)
4233 {
4234     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4235     IVideoWindow *pVideoWindow;
4236     HRESULT hr;
4237
4238     TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyle);
4239
4240     EnterCriticalSection(&This->cs);
4241
4242     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4243
4244     if (hr == S_OK)
4245         hr = IVideoWindow_get_WindowStyle(pVideoWindow, WindowStyle);
4246
4247     LeaveCriticalSection(&This->cs);
4248
4249     return hr;
4250 }
4251
4252 static HRESULT WINAPI VideoWindow_put_WindowStyleEx(IVideoWindow *iface, LONG WindowStyleEx)
4253 {
4254     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4255     IVideoWindow *pVideoWindow;
4256     HRESULT hr;
4257
4258     TRACE("(%p/%p)->(%d)\n", This, iface, WindowStyleEx);
4259
4260     EnterCriticalSection(&This->cs);
4261
4262     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4263
4264     if (hr == S_OK)
4265         hr = IVideoWindow_put_WindowStyleEx(pVideoWindow, WindowStyleEx);
4266
4267     LeaveCriticalSection(&This->cs);
4268
4269     return hr;
4270 }
4271
4272 static HRESULT WINAPI VideoWindow_get_WindowStyleEx(IVideoWindow *iface, LONG *WindowStyleEx)
4273 {
4274     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4275     IVideoWindow *pVideoWindow;
4276     HRESULT hr;
4277
4278     TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyleEx);
4279
4280     EnterCriticalSection(&This->cs);
4281
4282     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4283
4284     if (hr == S_OK)
4285         hr = IVideoWindow_get_WindowStyleEx(pVideoWindow, WindowStyleEx);
4286
4287     LeaveCriticalSection(&This->cs);
4288
4289     return hr;
4290 }
4291
4292 static HRESULT WINAPI VideoWindow_put_AutoShow(IVideoWindow *iface, LONG AutoShow)
4293 {
4294     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4295     IVideoWindow *pVideoWindow;
4296     HRESULT hr;
4297
4298     TRACE("(%p/%p)->(%d)\n", This, iface, AutoShow);
4299
4300     EnterCriticalSection(&This->cs);
4301
4302     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4303
4304     if (hr == S_OK)
4305         hr = IVideoWindow_put_AutoShow(pVideoWindow, AutoShow);
4306
4307     LeaveCriticalSection(&This->cs);
4308
4309     return hr;
4310 }
4311
4312 static HRESULT WINAPI VideoWindow_get_AutoShow(IVideoWindow *iface, LONG *AutoShow)
4313 {
4314     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4315     IVideoWindow *pVideoWindow;
4316     HRESULT hr;
4317
4318     TRACE("(%p/%p)->(%p)\n", This, iface, AutoShow);
4319
4320     EnterCriticalSection(&This->cs);
4321
4322     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4323
4324     if (hr == S_OK)
4325         hr = IVideoWindow_get_AutoShow(pVideoWindow, AutoShow);
4326
4327     LeaveCriticalSection(&This->cs);
4328
4329     return hr;
4330 }
4331
4332 static HRESULT WINAPI VideoWindow_put_WindowState(IVideoWindow *iface, LONG WindowState)
4333 {
4334     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4335     IVideoWindow *pVideoWindow;
4336     HRESULT hr;
4337
4338     TRACE("(%p/%p)->(%d)\n", This, iface, WindowState);
4339
4340     EnterCriticalSection(&This->cs);
4341
4342     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4343
4344     if (hr == S_OK)
4345         hr = IVideoWindow_put_WindowState(pVideoWindow, WindowState);
4346
4347     LeaveCriticalSection(&This->cs);
4348
4349     return hr;
4350 }
4351
4352 static HRESULT WINAPI VideoWindow_get_WindowState(IVideoWindow *iface, LONG *WindowState)
4353 {
4354     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4355     IVideoWindow *pVideoWindow;
4356     HRESULT hr;
4357
4358     TRACE("(%p/%p)->(%p)\n", This, iface, WindowState);
4359
4360     EnterCriticalSection(&This->cs);
4361
4362     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4363
4364     if (hr == S_OK)
4365         hr = IVideoWindow_get_WindowState(pVideoWindow, WindowState);
4366
4367     LeaveCriticalSection(&This->cs);
4368
4369     return hr;
4370 }
4371
4372 static HRESULT WINAPI VideoWindow_put_BackgroundPalette(IVideoWindow *iface, LONG BackgroundPalette)
4373 {
4374     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4375     IVideoWindow *pVideoWindow;
4376     HRESULT hr;
4377
4378     TRACE("(%p/%p)->(%d)\n", This, iface, BackgroundPalette);
4379
4380     EnterCriticalSection(&This->cs);
4381
4382     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4383
4384     if (hr == S_OK)
4385         hr = IVideoWindow_put_BackgroundPalette(pVideoWindow, BackgroundPalette);
4386
4387     LeaveCriticalSection(&This->cs);
4388
4389     return hr;
4390 }
4391
4392 static HRESULT WINAPI VideoWindow_get_BackgroundPalette(IVideoWindow *iface,
4393         LONG *pBackgroundPalette)
4394 {
4395     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4396     IVideoWindow *pVideoWindow;
4397     HRESULT hr;
4398
4399     TRACE("(%p/%p)->(%p)\n", This, iface, pBackgroundPalette);
4400
4401     EnterCriticalSection(&This->cs);
4402
4403     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4404
4405     if (hr == S_OK)
4406         hr = IVideoWindow_get_BackgroundPalette(pVideoWindow, pBackgroundPalette);
4407
4408     LeaveCriticalSection(&This->cs);
4409
4410     return hr;
4411 }
4412
4413 static HRESULT WINAPI VideoWindow_put_Visible(IVideoWindow *iface, LONG Visible)
4414 {
4415     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4416     IVideoWindow *pVideoWindow;
4417     HRESULT hr;
4418
4419     TRACE("(%p/%p)->(%d)\n", This, iface, Visible);
4420
4421     EnterCriticalSection(&This->cs);
4422
4423     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4424
4425     if (hr == S_OK)
4426         hr = IVideoWindow_put_Visible(pVideoWindow, Visible);
4427
4428     LeaveCriticalSection(&This->cs);
4429
4430     return hr;
4431 }
4432
4433 static HRESULT WINAPI VideoWindow_get_Visible(IVideoWindow *iface, LONG *pVisible)
4434 {
4435     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4436     IVideoWindow *pVideoWindow;
4437     HRESULT hr;
4438
4439     TRACE("(%p/%p)->(%p)\n", This, iface, pVisible);
4440
4441     EnterCriticalSection(&This->cs);
4442
4443     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4444
4445     if (hr == S_OK)
4446         hr = IVideoWindow_get_Visible(pVideoWindow, pVisible);
4447
4448     LeaveCriticalSection(&This->cs);
4449
4450     return hr;
4451 }
4452
4453 static HRESULT WINAPI VideoWindow_put_Left(IVideoWindow *iface, LONG Left)
4454 {
4455     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4456     IVideoWindow *pVideoWindow;
4457     HRESULT hr;
4458
4459     TRACE("(%p/%p)->(%d)\n", This, iface, Left);
4460
4461     EnterCriticalSection(&This->cs);
4462
4463     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4464
4465     if (hr == S_OK)
4466         hr = IVideoWindow_put_Left(pVideoWindow, Left);
4467
4468     LeaveCriticalSection(&This->cs);
4469
4470     return hr;
4471 }
4472
4473 static HRESULT WINAPI VideoWindow_get_Left(IVideoWindow *iface, LONG *pLeft)
4474 {
4475     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4476     IVideoWindow *pVideoWindow;
4477     HRESULT hr;
4478
4479     TRACE("(%p/%p)->(%p)\n", This, iface, pLeft);
4480
4481     EnterCriticalSection(&This->cs);
4482
4483     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4484
4485     if (hr == S_OK)
4486         hr = IVideoWindow_get_Left(pVideoWindow, pLeft);
4487
4488     LeaveCriticalSection(&This->cs);
4489
4490     return hr;
4491 }
4492
4493 static HRESULT WINAPI VideoWindow_put_Width(IVideoWindow *iface, LONG Width)
4494 {
4495     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4496     IVideoWindow *pVideoWindow;
4497     HRESULT hr;
4498
4499     TRACE("(%p/%p)->(%d)\n", This, iface, Width);
4500
4501     EnterCriticalSection(&This->cs);
4502
4503     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4504
4505     if (hr == S_OK)
4506         hr = IVideoWindow_put_Width(pVideoWindow, Width);
4507
4508     LeaveCriticalSection(&This->cs);
4509
4510     return hr;
4511 }
4512
4513 static HRESULT WINAPI VideoWindow_get_Width(IVideoWindow *iface, LONG *pWidth)
4514 {
4515     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4516     IVideoWindow *pVideoWindow;
4517     HRESULT hr;
4518
4519     TRACE("(%p/%p)->(%p)\n", This, iface, pWidth);
4520
4521     EnterCriticalSection(&This->cs);
4522
4523     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4524
4525     if (hr == S_OK)
4526         hr = IVideoWindow_get_Width(pVideoWindow, pWidth);
4527
4528     LeaveCriticalSection(&This->cs);
4529
4530     return hr;
4531 }
4532
4533 static HRESULT WINAPI VideoWindow_put_Top(IVideoWindow *iface, LONG Top)
4534 {
4535     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4536     IVideoWindow *pVideoWindow;
4537     HRESULT hr;
4538
4539     TRACE("(%p/%p)->(%d)\n", This, iface, Top);
4540
4541     EnterCriticalSection(&This->cs);
4542
4543     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4544
4545     if (hr == S_OK)
4546         hr = IVideoWindow_put_Top(pVideoWindow, Top);
4547
4548     LeaveCriticalSection(&This->cs);
4549
4550     return hr;
4551 }
4552
4553 static HRESULT WINAPI VideoWindow_get_Top(IVideoWindow *iface, LONG *pTop)
4554 {
4555     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4556     IVideoWindow *pVideoWindow;
4557     HRESULT hr;
4558
4559     TRACE("(%p/%p)->(%p)\n", This, iface, pTop);
4560
4561     EnterCriticalSection(&This->cs);
4562
4563     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4564
4565     if (hr == S_OK)
4566         hr = IVideoWindow_get_Top(pVideoWindow, pTop);
4567
4568     LeaveCriticalSection(&This->cs);
4569
4570     return hr;
4571 }
4572
4573 static HRESULT WINAPI VideoWindow_put_Height(IVideoWindow *iface, LONG Height)
4574 {
4575     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4576     IVideoWindow *pVideoWindow;
4577     HRESULT hr;
4578
4579     TRACE("(%p/%p)->(%d)\n", This, iface, Height);
4580
4581     EnterCriticalSection(&This->cs);
4582
4583     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4584
4585     if (hr == S_OK)
4586         hr = IVideoWindow_put_Height(pVideoWindow, Height);
4587
4588     LeaveCriticalSection(&This->cs);
4589
4590     return hr;
4591 }
4592
4593 static HRESULT WINAPI VideoWindow_get_Height(IVideoWindow *iface, LONG *pHeight)
4594 {
4595     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4596     IVideoWindow *pVideoWindow;
4597     HRESULT hr;
4598
4599     TRACE("(%p/%p)->(%p)\n", This, iface, pHeight);
4600
4601     EnterCriticalSection(&This->cs);
4602
4603     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4604
4605     if (hr == S_OK)
4606         hr = IVideoWindow_get_Height(pVideoWindow, pHeight);
4607
4608     LeaveCriticalSection(&This->cs);
4609
4610     return hr;
4611 }
4612
4613 static HRESULT WINAPI VideoWindow_put_Owner(IVideoWindow *iface, OAHWND Owner)
4614 {
4615     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4616     IVideoWindow *pVideoWindow;
4617     HRESULT hr;
4618
4619     TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Owner);
4620
4621     EnterCriticalSection(&This->cs);
4622
4623     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4624
4625     if (hr == S_OK)
4626         hr = IVideoWindow_put_Owner(pVideoWindow, Owner);
4627
4628     LeaveCriticalSection(&This->cs);
4629
4630     return hr;
4631 }
4632
4633 static HRESULT WINAPI VideoWindow_get_Owner(IVideoWindow *iface, OAHWND *Owner)
4634 {
4635     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4636     IVideoWindow *pVideoWindow;
4637     HRESULT hr;
4638
4639     TRACE("(%p/%p)->(%p)\n", This, iface, Owner);
4640
4641     EnterCriticalSection(&This->cs);
4642
4643     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4644
4645     if (hr == S_OK)
4646         hr = IVideoWindow_get_Owner(pVideoWindow, Owner);
4647
4648     LeaveCriticalSection(&This->cs);
4649
4650     return hr;
4651 }
4652
4653 static HRESULT WINAPI VideoWindow_put_MessageDrain(IVideoWindow *iface, OAHWND Drain)
4654 {
4655     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4656     IVideoWindow *pVideoWindow;
4657     HRESULT hr;
4658
4659     TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Drain);
4660
4661     EnterCriticalSection(&This->cs);
4662
4663     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4664
4665     if (hr == S_OK)
4666         hr = IVideoWindow_put_MessageDrain(pVideoWindow, Drain);
4667
4668     LeaveCriticalSection(&This->cs);
4669
4670     return hr;
4671 }
4672
4673 static HRESULT WINAPI VideoWindow_get_MessageDrain(IVideoWindow *iface, OAHWND *Drain)
4674 {
4675     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4676     IVideoWindow *pVideoWindow;
4677     HRESULT hr;
4678
4679     TRACE("(%p/%p)->(%p)\n", This, iface, Drain);
4680
4681     EnterCriticalSection(&This->cs);
4682
4683     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4684
4685     if (hr == S_OK)
4686         hr = IVideoWindow_get_MessageDrain(pVideoWindow, Drain);
4687
4688     LeaveCriticalSection(&This->cs);
4689
4690     return hr;
4691 }
4692
4693 static HRESULT WINAPI VideoWindow_get_BorderColor(IVideoWindow *iface, LONG *Color)
4694 {
4695     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4696     IVideoWindow *pVideoWindow;
4697     HRESULT hr;
4698
4699     TRACE("(%p/%p)->(%p)\n", This, iface, Color);
4700
4701     EnterCriticalSection(&This->cs);
4702
4703     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4704
4705     if (hr == S_OK)
4706         hr = IVideoWindow_get_BorderColor(pVideoWindow, Color);
4707
4708     LeaveCriticalSection(&This->cs);
4709
4710     return hr;
4711 }
4712
4713 static HRESULT WINAPI VideoWindow_put_BorderColor(IVideoWindow *iface, LONG Color)
4714 {
4715     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4716     IVideoWindow *pVideoWindow;
4717     HRESULT hr;
4718
4719     TRACE("(%p/%p)->(%d)\n", This, iface, Color);
4720
4721     EnterCriticalSection(&This->cs);
4722
4723     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4724
4725     if (hr == S_OK)
4726         hr = IVideoWindow_put_BorderColor(pVideoWindow, Color);
4727
4728     LeaveCriticalSection(&This->cs);
4729
4730     return hr;
4731 }
4732
4733 static HRESULT WINAPI VideoWindow_get_FullScreenMode(IVideoWindow *iface, LONG *FullScreenMode)
4734 {
4735     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4736     IVideoWindow *pVideoWindow;
4737     HRESULT hr;
4738
4739     TRACE("(%p/%p)->(%p)\n", This, iface, FullScreenMode);
4740
4741     EnterCriticalSection(&This->cs);
4742
4743     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4744
4745     if (hr == S_OK)
4746         hr = IVideoWindow_get_FullScreenMode(pVideoWindow, FullScreenMode);
4747
4748     LeaveCriticalSection(&This->cs);
4749
4750     return hr;
4751 }
4752
4753 static HRESULT WINAPI VideoWindow_put_FullScreenMode(IVideoWindow *iface, LONG FullScreenMode)
4754 {
4755     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4756     IVideoWindow *pVideoWindow;
4757     HRESULT hr;
4758
4759     TRACE("(%p/%p)->(%d)\n", This, iface, FullScreenMode);
4760
4761     EnterCriticalSection(&This->cs);
4762
4763     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4764
4765     if (hr == S_OK)
4766         hr = IVideoWindow_put_FullScreenMode(pVideoWindow, FullScreenMode);
4767
4768     LeaveCriticalSection(&This->cs);
4769
4770     return hr;
4771 }
4772
4773 static HRESULT WINAPI VideoWindow_SetWindowForeground(IVideoWindow *iface, LONG Focus)
4774 {
4775     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4776     IVideoWindow *pVideoWindow;
4777     HRESULT hr;
4778
4779     TRACE("(%p/%p)->(%d)\n", This, iface, Focus);
4780
4781     EnterCriticalSection(&This->cs);
4782
4783     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4784
4785     if (hr == S_OK)
4786         hr = IVideoWindow_SetWindowForeground(pVideoWindow, Focus);
4787
4788     LeaveCriticalSection(&This->cs);
4789
4790     return hr;
4791 }
4792
4793 static HRESULT WINAPI VideoWindow_NotifyOwnerMessage(IVideoWindow *iface, OAHWND hwnd, LONG uMsg,
4794         LONG_PTR wParam, LONG_PTR lParam)
4795 {
4796     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4797     IVideoWindow *pVideoWindow;
4798     HRESULT hr;
4799
4800     TRACE("(%p/%p)->(%08lx, %d, %08lx, %08lx)\n", This, iface, hwnd, uMsg, wParam, lParam);
4801
4802     EnterCriticalSection(&This->cs);
4803
4804     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4805
4806     if (hr == S_OK)
4807         hr = IVideoWindow_NotifyOwnerMessage(pVideoWindow, hwnd, uMsg, wParam, lParam);
4808
4809     LeaveCriticalSection(&This->cs);
4810
4811     return hr;
4812 }
4813
4814 static HRESULT WINAPI VideoWindow_SetWindowPosition(IVideoWindow *iface, LONG Left, LONG Top,
4815         LONG Width, LONG Height)
4816 {
4817     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4818     IVideoWindow *pVideoWindow;
4819     HRESULT hr;
4820
4821     TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
4822
4823     EnterCriticalSection(&This->cs);
4824
4825     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4826
4827     if (hr == S_OK)
4828         hr = IVideoWindow_SetWindowPosition(pVideoWindow, Left, Top, Width, Height);
4829
4830     LeaveCriticalSection(&This->cs);
4831
4832     return hr;
4833 }
4834
4835 static HRESULT WINAPI VideoWindow_GetWindowPosition(IVideoWindow *iface, LONG *pLeft, LONG *pTop,
4836         LONG *pWidth, LONG *pHeight)
4837 {
4838     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4839     IVideoWindow *pVideoWindow;
4840     HRESULT hr;
4841
4842     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
4843
4844     EnterCriticalSection(&This->cs);
4845
4846     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4847
4848     if (hr == S_OK)
4849         hr = IVideoWindow_GetWindowPosition(pVideoWindow, pLeft, pTop, pWidth, pHeight);
4850
4851     LeaveCriticalSection(&This->cs);
4852
4853     return hr;
4854 }
4855
4856 static HRESULT WINAPI VideoWindow_GetMinIdealImageSize(IVideoWindow *iface, LONG *pWidth,
4857         LONG *pHeight)
4858 {
4859     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4860     IVideoWindow *pVideoWindow;
4861     HRESULT hr;
4862
4863     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
4864
4865     EnterCriticalSection(&This->cs);
4866
4867     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4868
4869     if (hr == S_OK)
4870         hr = IVideoWindow_GetMinIdealImageSize(pVideoWindow, pWidth, pHeight);
4871
4872     LeaveCriticalSection(&This->cs);
4873
4874     return hr;
4875 }
4876
4877 static HRESULT WINAPI VideoWindow_GetMaxIdealImageSize(IVideoWindow *iface, LONG *pWidth,
4878         LONG *pHeight)
4879 {
4880     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4881     IVideoWindow *pVideoWindow;
4882     HRESULT hr;
4883
4884     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
4885
4886     EnterCriticalSection(&This->cs);
4887
4888     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4889
4890     if (hr == S_OK)
4891         hr = IVideoWindow_GetMaxIdealImageSize(pVideoWindow, pWidth, pHeight);
4892
4893     LeaveCriticalSection(&This->cs);
4894
4895     return hr;
4896 }
4897
4898 static HRESULT WINAPI VideoWindow_GetRestorePosition(IVideoWindow *iface, LONG *pLeft, LONG *pTop,
4899         LONG *pWidth, LONG *pHeight)
4900 {
4901     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4902     IVideoWindow *pVideoWindow;
4903     HRESULT hr;
4904
4905     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
4906
4907     EnterCriticalSection(&This->cs);
4908
4909     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4910
4911     if (hr == S_OK)
4912         hr = IVideoWindow_GetRestorePosition(pVideoWindow, pLeft, pTop, pWidth, pHeight);
4913
4914     LeaveCriticalSection(&This->cs);
4915
4916     return hr;
4917 }
4918
4919 static HRESULT WINAPI VideoWindow_HideCursor(IVideoWindow *iface, LONG HideCursor)
4920 {
4921     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4922     IVideoWindow *pVideoWindow;
4923     HRESULT hr;
4924
4925     TRACE("(%p/%p)->(%d)\n", This, iface, HideCursor);
4926
4927     EnterCriticalSection(&This->cs);
4928
4929     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4930
4931     if (hr == S_OK)
4932         hr = IVideoWindow_HideCursor(pVideoWindow, HideCursor);
4933
4934     LeaveCriticalSection(&This->cs);
4935
4936     return hr;
4937 }
4938
4939 static HRESULT WINAPI VideoWindow_IsCursorHidden(IVideoWindow *iface, LONG *CursorHidden)
4940 {
4941     IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4942     IVideoWindow *pVideoWindow;
4943     HRESULT hr;
4944
4945     TRACE("(%p/%p)->(%p)\n", This, iface, CursorHidden);
4946
4947     EnterCriticalSection(&This->cs);
4948
4949     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4950
4951     if (hr == S_OK)
4952         hr = IVideoWindow_IsCursorHidden(pVideoWindow, CursorHidden);
4953
4954     LeaveCriticalSection(&This->cs);
4955
4956     return hr;
4957 }
4958
4959
4960 static const IVideoWindowVtbl IVideoWindow_VTable =
4961 {
4962     VideoWindow_QueryInterface,
4963     VideoWindow_AddRef,
4964     VideoWindow_Release,
4965     VideoWindow_GetTypeInfoCount,
4966     VideoWindow_GetTypeInfo,
4967     VideoWindow_GetIDsOfNames,
4968     VideoWindow_Invoke,
4969     VideoWindow_put_Caption,
4970     VideoWindow_get_Caption,
4971     VideoWindow_put_WindowStyle,
4972     VideoWindow_get_WindowStyle,
4973     VideoWindow_put_WindowStyleEx,
4974     VideoWindow_get_WindowStyleEx,
4975     VideoWindow_put_AutoShow,
4976     VideoWindow_get_AutoShow,
4977     VideoWindow_put_WindowState,
4978     VideoWindow_get_WindowState,
4979     VideoWindow_put_BackgroundPalette,
4980     VideoWindow_get_BackgroundPalette,
4981     VideoWindow_put_Visible,
4982     VideoWindow_get_Visible,
4983     VideoWindow_put_Left,
4984     VideoWindow_get_Left,
4985     VideoWindow_put_Width,
4986     VideoWindow_get_Width,
4987     VideoWindow_put_Top,
4988     VideoWindow_get_Top,
4989     VideoWindow_put_Height,
4990     VideoWindow_get_Height,
4991     VideoWindow_put_Owner,
4992     VideoWindow_get_Owner,
4993     VideoWindow_put_MessageDrain,
4994     VideoWindow_get_MessageDrain,
4995     VideoWindow_get_BorderColor,
4996     VideoWindow_put_BorderColor,
4997     VideoWindow_get_FullScreenMode,
4998     VideoWindow_put_FullScreenMode,
4999     VideoWindow_SetWindowForeground,
5000     VideoWindow_NotifyOwnerMessage,
5001     VideoWindow_SetWindowPosition,
5002     VideoWindow_GetWindowPosition,
5003     VideoWindow_GetMinIdealImageSize,
5004     VideoWindow_GetMaxIdealImageSize,
5005     VideoWindow_GetRestorePosition,
5006     VideoWindow_HideCursor,
5007     VideoWindow_IsCursorHidden
5008 };
5009
5010 static inline IFilterGraphImpl *impl_from_IMediaEventEx(IMediaEventEx *iface)
5011 {
5012     return CONTAINING_RECORD(iface, IFilterGraphImpl, IMediaEventEx_iface);
5013 }
5014
5015 static HRESULT WINAPI MediaEvent_QueryInterface(IMediaEventEx *iface, REFIID riid, void **ppvObj)
5016 {
5017     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5018
5019     TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
5020
5021     return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
5022 }
5023
5024 static ULONG WINAPI MediaEvent_AddRef(IMediaEventEx *iface)
5025 {
5026     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5027
5028     TRACE("(%p/%p)->()\n", This, iface);
5029
5030     return IUnknown_AddRef(This->outer_unk);
5031 }
5032
5033 static ULONG WINAPI MediaEvent_Release(IMediaEventEx *iface)
5034 {
5035     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5036
5037     TRACE("(%p/%p)->()\n", This, iface);
5038
5039     return IUnknown_Release(This->outer_unk);
5040 }
5041
5042 /*** IDispatch methods ***/
5043 static HRESULT WINAPI MediaEvent_GetTypeInfoCount(IMediaEventEx *iface, UINT *pctinfo)
5044 {
5045     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5046
5047     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
5048
5049     return S_OK;
5050 }
5051
5052 static HRESULT WINAPI MediaEvent_GetTypeInfo(IMediaEventEx *iface, UINT iTInfo, LCID lcid,
5053         ITypeInfo **ppTInfo)
5054 {
5055     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5056
5057     TRACE("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
5058
5059     return S_OK;
5060 }
5061
5062 static HRESULT WINAPI MediaEvent_GetIDsOfNames(IMediaEventEx *iface, REFIID riid,
5063         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
5064 {
5065     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5066
5067     TRACE("(%p/%p)->(%s, %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), rgszNames,
5068             cNames, lcid, rgDispId);
5069
5070     return S_OK;
5071 }
5072
5073 static HRESULT WINAPI MediaEvent_Invoke(IMediaEventEx *iface, DISPID dispIdMember, REFIID riid,
5074         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo,
5075         UINT *puArgErr)
5076 {
5077     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5078
5079     TRACE("(%p/%p)->(%d, %s, %d, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember,
5080             debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
5081
5082     return S_OK;
5083 }
5084
5085 /*** IMediaEvent methods ***/
5086 static HRESULT WINAPI MediaEvent_GetEventHandle(IMediaEventEx *iface, OAEVENT *hEvent)
5087 {
5088     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5089
5090     TRACE("(%p/%p)->(%p)\n", This, iface, hEvent);
5091
5092     *hEvent = (OAEVENT)This->evqueue.msg_event;
5093
5094     return S_OK;
5095 }
5096
5097 static HRESULT WINAPI MediaEvent_GetEvent(IMediaEventEx *iface, LONG *lEventCode, LONG_PTR *lParam1,
5098         LONG_PTR *lParam2, LONG msTimeout)
5099 {
5100     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5101     Event evt;
5102
5103     TRACE("(%p/%p)->(%p, %p, %p, %d)\n", This, iface, lEventCode, lParam1, lParam2, msTimeout);
5104
5105     if (EventsQueue_GetEvent(&This->evqueue, &evt, msTimeout))
5106     {
5107         *lEventCode = evt.lEventCode;
5108         *lParam1 = evt.lParam1;
5109         *lParam2 = evt.lParam2;
5110         return S_OK;
5111     }
5112
5113     *lEventCode = 0;
5114     return E_ABORT;
5115 }
5116
5117 static HRESULT WINAPI MediaEvent_WaitForCompletion(IMediaEventEx *iface, LONG msTimeout,
5118         LONG *pEvCode)
5119 {
5120     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5121
5122     TRACE("(%p/%p)->(%d, %p)\n", This, iface, msTimeout, pEvCode);
5123
5124     if (This->state != State_Running)
5125         return VFW_E_WRONG_STATE;
5126
5127     if (WaitForSingleObject(This->hEventCompletion, msTimeout) == WAIT_OBJECT_0)
5128     {
5129         *pEvCode = This->CompletionStatus;
5130         return S_OK;
5131     }
5132
5133     *pEvCode = 0;
5134     return E_ABORT;
5135 }
5136
5137 static HRESULT WINAPI MediaEvent_CancelDefaultHandling(IMediaEventEx *iface, LONG lEvCode)
5138 {
5139     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5140
5141     TRACE("(%p/%p)->(%d)\n", This, iface, lEvCode);
5142
5143     if (lEvCode == EC_COMPLETE)
5144         This->HandleEcComplete = FALSE;
5145     else if (lEvCode == EC_REPAINT)
5146         This->HandleEcRepaint = FALSE;
5147     else if (lEvCode == EC_CLOCK_CHANGED)
5148         This->HandleEcClockChanged = FALSE;
5149     else
5150         return S_FALSE;
5151
5152     return S_OK;
5153 }
5154
5155 static HRESULT WINAPI MediaEvent_RestoreDefaultHandling(IMediaEventEx *iface, LONG lEvCode)
5156 {
5157     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5158
5159     TRACE("(%p/%p)->(%d)\n", This, iface, lEvCode);
5160
5161     if (lEvCode == EC_COMPLETE)
5162         This->HandleEcComplete = TRUE;
5163     else if (lEvCode == EC_REPAINT)
5164         This->HandleEcRepaint = TRUE;
5165     else if (lEvCode == EC_CLOCK_CHANGED)
5166         This->HandleEcClockChanged = TRUE;
5167     else
5168         return S_FALSE;
5169
5170     return S_OK;
5171 }
5172
5173 static HRESULT WINAPI MediaEvent_FreeEventParams(IMediaEventEx *iface, LONG lEvCode,
5174         LONG_PTR lParam1, LONG_PTR lParam2)
5175 {
5176     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5177
5178     TRACE("(%p/%p)->(%d, %08lx, %08lx): stub !!!\n", This, iface, lEvCode, lParam1, lParam2);
5179
5180     return S_OK;
5181 }
5182
5183 /*** IMediaEventEx methods ***/
5184 static HRESULT WINAPI MediaEvent_SetNotifyWindow(IMediaEventEx *iface, OAHWND hwnd, LONG lMsg,
5185         LONG_PTR lInstanceData)
5186 {
5187     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5188
5189     TRACE("(%p/%p)->(%08lx, %d, %08lx)\n", This, iface, hwnd, lMsg, lInstanceData);
5190
5191     This->notif.hWnd = (HWND)hwnd;
5192     This->notif.msg = lMsg;
5193     This->notif.instance = lInstanceData;
5194
5195     return S_OK;
5196 }
5197
5198 static HRESULT WINAPI MediaEvent_SetNotifyFlags(IMediaEventEx *iface, LONG lNoNotifyFlags)
5199 {
5200     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5201
5202     TRACE("(%p/%p)->(%d)\n", This, iface, lNoNotifyFlags);
5203
5204     if ((lNoNotifyFlags != 0) && (lNoNotifyFlags != 1))
5205         return E_INVALIDARG;
5206
5207     This->notif.disabled = lNoNotifyFlags;
5208
5209     return S_OK;
5210 }
5211
5212 static HRESULT WINAPI MediaEvent_GetNotifyFlags(IMediaEventEx *iface, LONG *lplNoNotifyFlags)
5213 {
5214     IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5215
5216     TRACE("(%p/%p)->(%p)\n", This, iface, lplNoNotifyFlags);
5217
5218     if (!lplNoNotifyFlags)
5219         return E_POINTER;
5220
5221     *lplNoNotifyFlags = This->notif.disabled;
5222
5223     return S_OK;
5224 }
5225
5226
5227 static const IMediaEventExVtbl IMediaEventEx_VTable =
5228 {
5229     MediaEvent_QueryInterface,
5230     MediaEvent_AddRef,
5231     MediaEvent_Release,
5232     MediaEvent_GetTypeInfoCount,
5233     MediaEvent_GetTypeInfo,
5234     MediaEvent_GetIDsOfNames,
5235     MediaEvent_Invoke,
5236     MediaEvent_GetEventHandle,
5237     MediaEvent_GetEvent,
5238     MediaEvent_WaitForCompletion,
5239     MediaEvent_CancelDefaultHandling,
5240     MediaEvent_RestoreDefaultHandling,
5241     MediaEvent_FreeEventParams,
5242     MediaEvent_SetNotifyWindow,
5243     MediaEvent_SetNotifyFlags,
5244     MediaEvent_GetNotifyFlags
5245 };
5246
5247
5248 static inline IFilterGraphImpl *impl_from_IMediaFilter(IMediaFilter *iface)
5249 {
5250     return CONTAINING_RECORD(iface, IFilterGraphImpl, IMediaFilter_iface);
5251 }
5252
5253 static HRESULT WINAPI MediaFilter_QueryInterface(IMediaFilter *iface, REFIID riid, void **ppv)
5254 {
5255     IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5256
5257     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
5258 }
5259
5260 static ULONG WINAPI MediaFilter_AddRef(IMediaFilter *iface)
5261 {
5262     IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5263
5264     return IUnknown_AddRef(This->outer_unk);
5265 }
5266
5267 static ULONG WINAPI MediaFilter_Release(IMediaFilter *iface)
5268 {
5269     IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5270
5271     return IUnknown_Release(This->outer_unk);
5272 }
5273
5274 static HRESULT WINAPI MediaFilter_GetClassID(IMediaFilter *iface, CLSID * pClassID)
5275 {
5276     FIXME("(%p): stub\n", pClassID);
5277
5278     return E_NOTIMPL;
5279 }
5280
5281 static HRESULT WINAPI MediaFilter_Stop(IMediaFilter *iface)
5282 {
5283     IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5284
5285     return MediaControl_Stop(&This->IMediaControl_iface);
5286 }
5287
5288 static HRESULT WINAPI MediaFilter_Pause(IMediaFilter *iface)
5289 {
5290     IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5291
5292     return MediaControl_Pause(&This->IMediaControl_iface);
5293 }
5294
5295 static HRESULT WINAPI MediaFilter_Run(IMediaFilter *iface, REFERENCE_TIME tStart)
5296 {
5297     IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5298
5299     if (tStart)
5300         FIXME("Run called with non-null tStart: %x%08x\n",
5301               (int)(tStart>>32), (int)tStart);
5302
5303     return MediaControl_Run(&This->IMediaControl_iface);
5304 }
5305
5306 static HRESULT WINAPI MediaFilter_GetState(IMediaFilter *iface, DWORD dwMsTimeout,
5307         FILTER_STATE *pState)
5308 {
5309     IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5310
5311     return MediaControl_GetState(&This->IMediaControl_iface, dwMsTimeout, (OAFilterState*)pState);
5312 }
5313
5314 static HRESULT WINAPI MediaFilter_SetSyncSource(IMediaFilter *iface, IReferenceClock *pClock)
5315 {
5316     IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5317     HRESULT hr = S_OK;
5318     int i;
5319
5320     TRACE("(%p/%p)->(%p)\n", iface, This, pClock);
5321
5322     EnterCriticalSection(&This->cs);
5323     {
5324         for (i = 0;i < This->nFilters;i++)
5325         {
5326             hr = IBaseFilter_SetSyncSource(This->ppFiltersInGraph[i], pClock);
5327             if (FAILED(hr))
5328                 break;
5329         }
5330
5331         if (FAILED(hr))
5332         {
5333             for(;i >= 0;i--)
5334                 IBaseFilter_SetSyncSource(This->ppFiltersInGraph[i], This->refClock);
5335         }
5336         else
5337         {
5338             if (This->refClock)
5339                 IReferenceClock_Release(This->refClock);
5340             This->refClock = pClock;
5341             if (This->refClock)
5342                 IReferenceClock_AddRef(This->refClock);
5343             This->defaultclock = FALSE;
5344
5345             if (This->HandleEcClockChanged)
5346             {
5347                 IMediaEventSink *pEventSink;
5348                 HRESULT eshr;
5349
5350                 eshr = IMediaFilter_QueryInterface(iface, &IID_IMediaEventSink, (void **)&pEventSink);
5351                 if (SUCCEEDED(eshr))
5352                 {
5353                     IMediaEventSink_Notify(pEventSink, EC_CLOCK_CHANGED, 0, 0);
5354                     IMediaEventSink_Release(pEventSink);
5355                 }
5356             }
5357         }
5358     }
5359     LeaveCriticalSection(&This->cs);
5360
5361     return hr;
5362 }
5363
5364 static HRESULT WINAPI MediaFilter_GetSyncSource(IMediaFilter *iface, IReferenceClock **ppClock)
5365 {
5366     IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5367
5368     TRACE("(%p/%p)->(%p)\n", iface, This, ppClock);
5369
5370     if (!ppClock)
5371         return E_POINTER;
5372
5373     EnterCriticalSection(&This->cs);
5374     {
5375         *ppClock = This->refClock;
5376         if (*ppClock)
5377             IReferenceClock_AddRef(*ppClock);
5378     }
5379     LeaveCriticalSection(&This->cs);
5380
5381     return S_OK;
5382 }
5383
5384 static const IMediaFilterVtbl IMediaFilter_VTable =
5385 {
5386     MediaFilter_QueryInterface,
5387     MediaFilter_AddRef,
5388     MediaFilter_Release,
5389     MediaFilter_GetClassID,
5390     MediaFilter_Stop,
5391     MediaFilter_Pause,
5392     MediaFilter_Run,
5393     MediaFilter_GetState,
5394     MediaFilter_SetSyncSource,
5395     MediaFilter_GetSyncSource
5396 };
5397
5398 static inline IFilterGraphImpl *impl_from_IMediaEventSink(IMediaEventSink *iface)
5399 {
5400     return CONTAINING_RECORD(iface, IFilterGraphImpl, IMediaEventSink_iface);
5401 }
5402
5403 static HRESULT WINAPI MediaEventSink_QueryInterface(IMediaEventSink *iface, REFIID riid, void **ppv)
5404 {
5405     IFilterGraphImpl *This = impl_from_IMediaEventSink(iface);
5406
5407     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
5408 }
5409
5410 static ULONG WINAPI MediaEventSink_AddRef(IMediaEventSink *iface)
5411 {
5412     IFilterGraphImpl *This = impl_from_IMediaEventSink(iface);
5413
5414     return IUnknown_AddRef(This->outer_unk);
5415 }
5416
5417 static ULONG WINAPI MediaEventSink_Release(IMediaEventSink *iface)
5418 {
5419     IFilterGraphImpl *This = impl_from_IMediaEventSink(iface);
5420
5421     return IUnknown_Release(This->outer_unk);
5422 }
5423
5424 static HRESULT WINAPI MediaEventSink_Notify(IMediaEventSink *iface, LONG EventCode,
5425         LONG_PTR EventParam1, LONG_PTR EventParam2)
5426 {
5427     IFilterGraphImpl *This = impl_from_IMediaEventSink(iface);
5428     Event evt;
5429
5430     TRACE("(%p/%p)->(%d, %ld, %ld)\n", This, iface, EventCode, EventParam1, EventParam2);
5431
5432     /* We need thread safety here, let's use the events queue's one */
5433     EnterCriticalSection(&This->evqueue.msg_crst);
5434
5435     if ((EventCode == EC_COMPLETE) && This->HandleEcComplete)
5436     {
5437         TRACE("Process EC_COMPLETE notification\n");
5438         if (++This->EcCompleteCount == This->nRenderers)
5439         {
5440             evt.lEventCode = EC_COMPLETE;
5441             evt.lParam1 = S_OK;
5442             evt.lParam2 = 0;
5443             TRACE("Send EC_COMPLETE to app\n");
5444             EventsQueue_PutEvent(&This->evqueue, &evt);
5445             if (!This->notif.disabled && This->notif.hWnd)
5446             {
5447                 TRACE("Send Window message\n");
5448                 PostMessageW(This->notif.hWnd, This->notif.msg, 0, This->notif.instance);
5449             }
5450             This->CompletionStatus = EC_COMPLETE;
5451             SetEvent(This->hEventCompletion);
5452         }
5453     }
5454     else if ((EventCode == EC_REPAINT) && This->HandleEcRepaint)
5455     {
5456         /* FIXME: Not handled yet */
5457     }
5458     else
5459     {
5460         evt.lEventCode = EventCode;
5461         evt.lParam1 = EventParam1;
5462         evt.lParam2 = EventParam2;
5463         EventsQueue_PutEvent(&This->evqueue, &evt);
5464         if (!This->notif.disabled && This->notif.hWnd)
5465             PostMessageW(This->notif.hWnd, This->notif.msg, 0, This->notif.instance);
5466     }
5467
5468     LeaveCriticalSection(&This->evqueue.msg_crst);
5469     return S_OK;
5470 }
5471
5472 static const IMediaEventSinkVtbl IMediaEventSink_VTable =
5473 {
5474     MediaEventSink_QueryInterface,
5475     MediaEventSink_AddRef,
5476     MediaEventSink_Release,
5477     MediaEventSink_Notify
5478 };
5479
5480 static inline IFilterGraphImpl *impl_from_IGraphConfig(IGraphConfig *iface)
5481 {
5482     return CONTAINING_RECORD(iface, IFilterGraphImpl, IGraphConfig_iface);
5483 }
5484
5485 static HRESULT WINAPI GraphConfig_QueryInterface(IGraphConfig *iface, REFIID riid, void **ppv)
5486 {
5487     IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5488
5489     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
5490 }
5491
5492 static ULONG WINAPI GraphConfig_AddRef(IGraphConfig *iface)
5493 {
5494     IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5495
5496     return IUnknown_AddRef(This->outer_unk);
5497 }
5498
5499 static ULONG WINAPI GraphConfig_Release(IGraphConfig *iface)
5500 {
5501     IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5502
5503     return IUnknown_Release(This->outer_unk);
5504 }
5505
5506 static HRESULT WINAPI GraphConfig_Reconnect(IGraphConfig *iface, IPin *pOutputPin, IPin *pInputPin,
5507         const AM_MEDIA_TYPE *pmtFirstConnection, IBaseFilter *pUsingFilter, HANDLE hAbortEvent,
5508         DWORD dwFlags)
5509 {
5510     IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5511
5512     FIXME("(%p)->(%p, %p, %p, %p, %p, %x): stub!\n", This, pOutputPin, pInputPin, pmtFirstConnection, pUsingFilter, hAbortEvent, dwFlags);
5513
5514     return E_NOTIMPL;
5515 }
5516
5517 static HRESULT WINAPI GraphConfig_Reconfigure(IGraphConfig *iface, IGraphConfigCallback *pCallback,
5518         void *pvContext, DWORD dwFlags, HANDLE hAbortEvent)
5519 {
5520     IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5521     HRESULT hr;
5522
5523     WARN("(%p)->(%p, %p, %x, %p): partial stub!\n", This, pCallback, pvContext, dwFlags, hAbortEvent);
5524
5525     if (hAbortEvent)
5526         FIXME("The parameter hAbortEvent is not handled!\n");
5527
5528     EnterCriticalSection(&This->cs);
5529
5530     hr = IGraphConfigCallback_Reconfigure(pCallback, pvContext, dwFlags);
5531
5532     LeaveCriticalSection(&This->cs);
5533
5534     return hr;
5535 }
5536
5537 static HRESULT WINAPI GraphConfig_AddFilterToCache(IGraphConfig *iface, IBaseFilter *pFilter)
5538 {
5539     IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5540
5541     FIXME("(%p)->(%p): stub!\n", This, pFilter);
5542
5543     return E_NOTIMPL;
5544 }
5545
5546 static HRESULT WINAPI GraphConfig_EnumCacheFilter(IGraphConfig *iface, IEnumFilters **pEnum)
5547 {
5548     IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5549
5550     FIXME("(%p)->(%p): stub!\n", This, pEnum);
5551
5552     return E_NOTIMPL;
5553 }
5554
5555 static HRESULT WINAPI GraphConfig_RemoveFilterFromCache(IGraphConfig *iface, IBaseFilter *pFilter)
5556 {
5557     IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5558
5559     FIXME("(%p)->(%p): stub!\n", This, pFilter);
5560
5561     return E_NOTIMPL;
5562 }
5563
5564 static HRESULT WINAPI GraphConfig_GetStartTime(IGraphConfig *iface, REFERENCE_TIME *prtStart)
5565 {
5566     IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5567
5568     FIXME("(%p)->(%p): stub!\n", This, prtStart);
5569
5570     return E_NOTIMPL;
5571 }
5572
5573 static HRESULT WINAPI GraphConfig_PushThroughData(IGraphConfig *iface, IPin *pOutputPin,
5574         IPinConnection *pConnection, HANDLE hEventAbort)
5575 {
5576     IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5577
5578     FIXME("(%p)->(%p, %p, %p): stub!\n", This, pOutputPin, pConnection, hEventAbort);
5579
5580     return E_NOTIMPL;
5581 }
5582
5583 static HRESULT WINAPI GraphConfig_SetFilterFlags(IGraphConfig *iface, IBaseFilter *pFilter,
5584         DWORD dwFlags)
5585 {
5586     IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5587
5588     FIXME("(%p)->(%p, %x): stub!\n", This, pFilter, dwFlags);
5589
5590     return E_NOTIMPL;
5591 }
5592
5593 static HRESULT WINAPI GraphConfig_GetFilterFlags(IGraphConfig *iface, IBaseFilter *pFilter,
5594         DWORD *dwFlags)
5595 {
5596     IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5597
5598     FIXME("(%p)->(%p, %p): stub!\n", This, pFilter, dwFlags);
5599
5600     return E_NOTIMPL;
5601 }
5602
5603 static HRESULT WINAPI GraphConfig_RemoveFilterEx(IGraphConfig *iface, IBaseFilter *pFilter,
5604         DWORD dwFlags)
5605 {
5606     IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5607
5608     FIXME("(%p)->(%p, %x): stub!\n", This, pFilter, dwFlags);
5609
5610     return E_NOTIMPL;
5611 }
5612
5613 static const IGraphConfigVtbl IGraphConfig_VTable =
5614 {
5615     GraphConfig_QueryInterface,
5616     GraphConfig_AddRef,
5617     GraphConfig_Release,
5618     GraphConfig_Reconnect,
5619     GraphConfig_Reconfigure,
5620     GraphConfig_AddFilterToCache,
5621     GraphConfig_EnumCacheFilter,
5622     GraphConfig_RemoveFilterFromCache,
5623     GraphConfig_GetStartTime,
5624     GraphConfig_PushThroughData,
5625     GraphConfig_SetFilterFlags,
5626     GraphConfig_GetFilterFlags,
5627     GraphConfig_RemoveFilterEx
5628 };
5629
5630 static inline IFilterGraphImpl *impl_from_IGraphVersion(IGraphVersion *iface)
5631 {
5632     return CONTAINING_RECORD(iface, IFilterGraphImpl, IGraphVersion_iface);
5633 }
5634
5635 static HRESULT WINAPI GraphVersion_QueryInterface(IGraphVersion *iface, REFIID riid, void **ppv)
5636 {
5637     IFilterGraphImpl *This = impl_from_IGraphVersion(iface);
5638
5639     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
5640 }
5641
5642 static ULONG WINAPI GraphVersion_AddRef(IGraphVersion *iface)
5643 {
5644     IFilterGraphImpl *This = impl_from_IGraphVersion(iface);
5645
5646     return IUnknown_AddRef(This->outer_unk);
5647 }
5648
5649 static ULONG WINAPI GraphVersion_Release(IGraphVersion *iface)
5650 {
5651     IFilterGraphImpl *This = impl_from_IGraphVersion(iface);
5652
5653     return IUnknown_Release(This->outer_unk);
5654 }
5655
5656 static HRESULT WINAPI GraphVersion_QueryVersion(IGraphVersion *iface, LONG *pVersion)
5657 {
5658     IFilterGraphImpl *This = impl_from_IGraphVersion(iface);
5659
5660     if(!pVersion)
5661         return E_POINTER;
5662
5663     TRACE("(%p)->(%p): current version %i\n", This, pVersion, This->version);
5664
5665     *pVersion = This->version;
5666     return S_OK;
5667 }
5668
5669 static const IGraphVersionVtbl IGraphVersion_VTable =
5670 {
5671     GraphVersion_QueryInterface,
5672     GraphVersion_AddRef,
5673     GraphVersion_Release,
5674     GraphVersion_QueryVersion,
5675 };
5676
5677 static const IUnknownVtbl IInner_VTable =
5678 {
5679     FilterGraphInner_QueryInterface,
5680     FilterGraphInner_AddRef,
5681     FilterGraphInner_Release
5682 };
5683
5684 /* This is the only function that actually creates a FilterGraph class... */
5685 HRESULT FilterGraph_create(IUnknown *pUnkOuter, LPVOID *ppObj)
5686 {
5687     IFilterGraphImpl *fimpl;
5688     HRESULT hr;
5689
5690     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
5691
5692     *ppObj = NULL;
5693
5694     fimpl = CoTaskMemAlloc(sizeof(*fimpl));
5695     fimpl->defaultclock = TRUE;
5696     fimpl->IUnknown_inner.lpVtbl = &IInner_VTable;
5697     fimpl->IFilterGraph2_iface.lpVtbl = &IFilterGraph2_VTable;
5698     fimpl->IMediaControl_iface.lpVtbl = &IMediaControl_VTable;
5699     fimpl->IMediaSeeking_iface.lpVtbl = &IMediaSeeking_VTable;
5700     fimpl->IBasicAudio_iface.lpVtbl = &IBasicAudio_VTable;
5701     fimpl->IBasicVideo2_iface.lpVtbl = &IBasicVideo_VTable;
5702     fimpl->IVideoWindow_iface.lpVtbl = &IVideoWindow_VTable;
5703     fimpl->IMediaEventEx_iface.lpVtbl = &IMediaEventEx_VTable;
5704     fimpl->IMediaFilter_iface.lpVtbl = &IMediaFilter_VTable;
5705     fimpl->IMediaEventSink_iface.lpVtbl = &IMediaEventSink_VTable;
5706     fimpl->IGraphConfig_iface.lpVtbl = &IGraphConfig_VTable;
5707     fimpl->IMediaPosition_iface.lpVtbl = &IMediaPosition_VTable;
5708     fimpl->IObjectWithSite_iface.lpVtbl = &IObjectWithSite_VTable;
5709     fimpl->IGraphVersion_iface.lpVtbl = &IGraphVersion_VTable;
5710     fimpl->ref = 1;
5711     fimpl->ppFiltersInGraph = NULL;
5712     fimpl->pFilterNames = NULL;
5713     fimpl->nFilters = 0;
5714     fimpl->filterCapacity = 0;
5715     fimpl->nameIndex = 1;
5716     fimpl->refClock = NULL;
5717     fimpl->hEventCompletion = CreateEventW(0, TRUE, FALSE, 0);
5718     fimpl->HandleEcComplete = TRUE;
5719     fimpl->HandleEcRepaint = TRUE;
5720     fimpl->HandleEcClockChanged = TRUE;
5721     fimpl->notif.hWnd = 0;
5722     fimpl->notif.disabled = FALSE;
5723     fimpl->nRenderers = 0;
5724     fimpl->EcCompleteCount = 0;
5725     fimpl->refClockProvider = NULL;
5726     fimpl->state = State_Stopped;
5727     fimpl->pSite = NULL;
5728     EventsQueue_Init(&fimpl->evqueue);
5729     InitializeCriticalSection(&fimpl->cs);
5730     fimpl->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": IFilterGraphImpl.cs");
5731     fimpl->nItfCacheEntries = 0;
5732     memcpy(&fimpl->timeformatseek, &TIME_FORMAT_MEDIA_TIME, sizeof(GUID));
5733     fimpl->start_time = fimpl->pause_time = 0;
5734     fimpl->stop_position = -1;
5735     fimpl->punkFilterMapper2 = NULL;
5736     fimpl->recursioncount = 0;
5737     fimpl->version = 0;
5738
5739     if (pUnkOuter)
5740         fimpl->outer_unk = pUnkOuter;
5741     else
5742         fimpl->outer_unk = &fimpl->IUnknown_inner;
5743
5744     /* create Filtermapper aggregated. */
5745     hr = CoCreateInstance(&CLSID_FilterMapper2, fimpl->outer_unk, CLSCTX_INPROC_SERVER,
5746             &IID_IUnknown, (void**)&fimpl->punkFilterMapper2);
5747
5748     if (FAILED(hr)) {
5749         ERR("Unable to create filter mapper (%x)\n", hr);
5750         if (fimpl->punkFilterMapper2) IUnknown_Release(fimpl->punkFilterMapper2);
5751         CloseHandle(fimpl->hEventCompletion);
5752         EventsQueue_Destroy(&fimpl->evqueue);
5753         fimpl->cs.DebugInfo->Spare[0] = 0;
5754         DeleteCriticalSection(&fimpl->cs);
5755         CoTaskMemFree(fimpl);
5756         return hr;
5757     }
5758
5759     *ppObj = &fimpl->IUnknown_inner;
5760     return S_OK;
5761 }
5762
5763 HRESULT FilterGraphNoThread_create(IUnknown *pUnkOuter, LPVOID *ppObj)
5764 {
5765     FIXME("CLSID_FilterGraphNoThread partially implemented - Forwarding to CLSID_FilterGraph\n");
5766     return FilterGraph_create(pUnkOuter, ppObj);
5767 }