dlls/quartz/filtergraph.c

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