git.oblomov.eu Git - wine/blob - dlls/quartz/filtergraph.c

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