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