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