dlls/quartz/filtergraph.c

   1 /*              DirectShow FilterGraph object (QUARTZ.DLL)
   2  *
   3  * Copyright 2002 Lionel Ulmer
   4  * Copyright 2004 Christian Costa
   5  *
   6  * This file contains the (internal) driver registration functions,
   7  * driver enumeration APIs and DirectDraw creation functions.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25 #include <stdarg.h>
  26
  27 #define COBJMACROS
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winuser.h"
  32 #include "dshow.h"
  33 #include "wine/debug.h"
  34 #include "quartz_private.h"
  35 #include "ole2.h"
  36 #include "olectl.h"
  37 #include "strmif.h"
  38 #include "vfwmsgs.h"
  39 #include "evcode.h"
  40 #include "wine/unicode.h"
  41
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  44
  45 typedef struct {
  46     HWND hWnd;      /* Target window */
  47     long msg;       /* User window message */
  48     long instance;  /* User data */
  49     int  disabled;  /* Disabled messages posting */
  50 } WndNotify;
  51
  52 typedef struct {
  53     long lEventCode;   /* Event code */
  54     LONG_PTR lParam1;  /* Param1 */
  55     LONG_PTR lParam2;  /* Param2 */
  56 } Event;
  57
  58 /* messages ring implementation for queuing events (taken from winmm) */
  59 #define EVENTS_RING_BUFFER_INCREMENT      64
  60 typedef struct {
  61     Event* messages;
  62     int ring_buffer_size;
  63     int msg_tosave;
  64     int msg_toget;
  65     CRITICAL_SECTION msg_crst;
  66     HANDLE msg_event; /* Signaled for no empty queue */
  67 } EventsQueue;
  68
  69 static int EventsQueue_Init(EventsQueue* omr)
  70 {
  71     omr->msg_toget = 0;
  72     omr->msg_tosave = 0;
  73     omr->msg_event = CreateEventW(NULL, TRUE, FALSE, NULL);
  74     omr->ring_buffer_size = EVENTS_RING_BUFFER_INCREMENT;
  75     omr->messages = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,omr->ring_buffer_size * sizeof(Event));
  76
  77     InitializeCriticalSection(&omr->msg_crst);
  78     return TRUE;
  79 }
  80
  81 static int EventsQueue_Destroy(EventsQueue* omr)
  82 {
  83     CloseHandle(omr->msg_event);
  84     HeapFree(GetProcessHeap(),0,omr->messages);
  85     DeleteCriticalSection(&omr->msg_crst);
  86     return TRUE;
  87 }
  88
  89 static int EventsQueue_PutEvent(EventsQueue* omr, Event* evt)
  90 {
  91     EnterCriticalSection(&omr->msg_crst);
  92     if ((omr->msg_toget == ((omr->msg_tosave + 1) % omr->ring_buffer_size)))
  93     {
  94         int old_ring_buffer_size = omr->ring_buffer_size;
  95         omr->ring_buffer_size += EVENTS_RING_BUFFER_INCREMENT;
  96         TRACE("omr->ring_buffer_size=%d\n",omr->ring_buffer_size);
  97         omr->messages = HeapReAlloc(GetProcessHeap(),0,omr->messages, omr->ring_buffer_size * sizeof(Event));
  98         /* Now we need to rearrange the ring buffer so that the new
  99            buffers just allocated are in between omr->msg_tosave and
 100            omr->msg_toget.
 101         */
 102         if (omr->msg_tosave < omr->msg_toget)
 103         {
 104             memmove(&(omr->messages[omr->msg_toget + EVENTS_RING_BUFFER_INCREMENT]),
 105                     &(omr->messages[omr->msg_toget]),
 106                     sizeof(Event)*(old_ring_buffer_size - omr->msg_toget)
 107                     );
 108             omr->msg_toget += EVENTS_RING_BUFFER_INCREMENT;
 109         }
 110     }
 111     omr->messages[omr->msg_tosave] = *evt;
 112     SetEvent(omr->msg_event);
 113     omr->msg_tosave = (omr->msg_tosave + 1) % omr->ring_buffer_size;
 114     LeaveCriticalSection(&omr->msg_crst);
 115     return TRUE;
 116 }
 117
 118 static int EventsQueue_GetEvent(EventsQueue* omr, Event* evt, long msTimeOut)
 119 {
 120     if (WaitForSingleObject(omr->msg_event, msTimeOut) != WAIT_OBJECT_0)
 121         return FALSE;
 122
 123     EnterCriticalSection(&omr->msg_crst);
 124
 125     if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
 126     {
 127         LeaveCriticalSection(&omr->msg_crst);
 128         return FALSE;
 129     }
 130
 131     *evt = omr->messages[omr->msg_toget];
 132     omr->msg_toget = (omr->msg_toget + 1) % omr->ring_buffer_size;
 133
 134     /* Mark the buffer as empty if needed */
 135     if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
 136         ResetEvent(omr->msg_event);
 137
 138     LeaveCriticalSection(&omr->msg_crst);
 139     return TRUE;
 140 }
 141
 142 #define MAX_ITF_CACHE_ENTRIES 3
 143 typedef struct _ITF_CACHE_ENTRY {
 144    const IID* riid;
 145    IBaseFilter* filter;
 146    IUnknown* iface;
 147 } ITF_CACHE_ENTRY;
 148
 149 typedef struct _IFilterGraphImpl {
 150     const IGraphBuilderVtbl *IGraphBuilder_vtbl;
 151     const IMediaControlVtbl *IMediaControl_vtbl;
 152     const IMediaSeekingVtbl *IMediaSeeking_vtbl;
 153     const IBasicAudioVtbl *IBasicAudio_vtbl;
 154     const IBasicVideoVtbl *IBasicVideo_vtbl;
 155     const IVideoWindowVtbl *IVideoWindow_vtbl;
 156     const IMediaEventExVtbl *IMediaEventEx_vtbl;
 157     const IMediaFilterVtbl *IMediaFilter_vtbl;
 158     const IMediaEventSinkVtbl *IMediaEventSink_vtbl;
 159     const IGraphConfigVtbl *IGraphConfig_vtbl;
 160     const IMediaPositionVtbl *IMediaPosition_vtbl;
 161     /* IAMGraphStreams */
 162     /* IAMStats */
 163     /* IBasicVideo2 */
 164     /* IFilterChain */
 165     /* IFilterGraph2 */
 166     /* IFilterMapper2 */
 167     /* IGraphVersion */
 168     /* IQueueCommand */
 169     /* IRegisterServiceProvider */
 170     /* IResourceMananger */
 171     /* IServiceProvider */
 172     /* IVideoFrameStep */
 173
 174     LONG ref;
 175     IFilterMapper2 * pFilterMapper2;
 176     IBaseFilter ** ppFiltersInGraph;
 177     LPWSTR * pFilterNames;
 178     int nFilters;
 179     int filterCapacity;
 180     long nameIndex;
 181     EventsQueue evqueue;
 182     HANDLE hEventCompletion;
 183     int CompletionStatus;
 184     WndNotify notif;
 185     int nRenderers;
 186     int EcCompleteCount;
 187     int HandleEcComplete;
 188     int HandleEcRepaint;
 189     OAFilterState state;
 190     CRITICAL_SECTION cs;
 191     ITF_CACHE_ENTRY ItfCacheEntries[MAX_ITF_CACHE_ENTRIES];
 192     int nItfCacheEntries;
 193 } IFilterGraphImpl;
 194
 195
 196 static HRESULT Filtergraph_QueryInterface(IFilterGraphImpl *This,
 197                                           REFIID riid,
 198                                           LPVOID *ppvObj) {
 199     TRACE("(%p)->(%s (%p), %p)\n", This, debugstr_guid(riid), riid, ppvObj);
 200
 201     if (IsEqualGUID(&IID_IUnknown, riid) ||
 202         IsEqualGUID(&IID_IFilterGraph, riid) ||
 203         IsEqualGUID(&IID_IGraphBuilder, riid)) {
 204         *ppvObj = &(This->IGraphBuilder_vtbl);
 205         TRACE("   returning IGraphBuilder interface (%p)\n", *ppvObj);
 206     } else if (IsEqualGUID(&IID_IMediaControl, riid)) {
 207         *ppvObj = &(This->IMediaControl_vtbl);
 208         TRACE("   returning IMediaControl interface (%p)\n", *ppvObj);
 209     } else if (IsEqualGUID(&IID_IMediaSeeking, riid)) {
 210         *ppvObj = &(This->IMediaSeeking_vtbl);
 211         TRACE("   returning IMediaSeeking interface (%p)\n", *ppvObj);
 212     } else if (IsEqualGUID(&IID_IBasicAudio, riid)) {
 213         *ppvObj = &(This->IBasicAudio_vtbl);
 214         TRACE("   returning IBasicAudio interface (%p)\n", *ppvObj);
 215     } else if (IsEqualGUID(&IID_IBasicVideo, riid)) {
 216         *ppvObj = &(This->IBasicVideo_vtbl);
 217         TRACE("   returning IBasicVideo interface (%p)\n", *ppvObj);
 218     } else if (IsEqualGUID(&IID_IVideoWindow, riid)) {
 219         *ppvObj = &(This->IVideoWindow_vtbl);
 220         TRACE("   returning IVideoWindow interface (%p)\n", *ppvObj);
 221     } else if (IsEqualGUID(&IID_IMediaEvent, riid) ||
 222            IsEqualGUID(&IID_IMediaEventEx, riid)) {
 223         *ppvObj = &(This->IMediaEventEx_vtbl);
 224         TRACE("   returning IMediaEvent(Ex) interface (%p)\n", *ppvObj);
 225     } else if (IsEqualGUID(&IID_IMediaFilter, riid) ||
 226           IsEqualGUID(&IID_IPersist, riid)) {
 227         *ppvObj = &(This->IMediaFilter_vtbl);
 228         TRACE("   returning IMediaFilter interface (%p)\n", *ppvObj);
 229     } else if (IsEqualGUID(&IID_IMediaEventSink, riid)) {
 230         *ppvObj = &(This->IMediaEventSink_vtbl);
 231         TRACE("   returning IMediaEventSink interface (%p)\n", *ppvObj);
 232     } else if (IsEqualGUID(&IID_IGraphConfig, riid)) {
 233         *ppvObj = &(This->IGraphConfig_vtbl);
 234         TRACE("   returning IGraphConfig interface (%p)\n", *ppvObj);
 235     } else if (IsEqualGUID(&IID_IMediaPosition, riid)) {
 236         *ppvObj = &(This->IMediaPosition_vtbl);
 237         TRACE("   returning IMediaPosition interface (%p)\n", *ppvObj);
 238     } else {
 239         *ppvObj = NULL;
 240         FIXME("unknown interface %s\n", debugstr_guid(riid));
 241         return E_NOINTERFACE;
 242     }
 243
 244     InterlockedIncrement(&This->ref);
 245     return S_OK;
 246 }
 247
 248 static ULONG Filtergraph_AddRef(IFilterGraphImpl *This) {
 249     ULONG ref = InterlockedIncrement(&This->ref);
 250
 251     TRACE("(%p)->(): new ref = %d\n", This, ref);
 252
 253     return ref;
 254 }
 255
 256 static ULONG Filtergraph_Release(IFilterGraphImpl *This) {
 257     ULONG ref = InterlockedDecrement(&This->ref);
 258
 259     TRACE("(%p)->(): new ref = %d\n", This, ref);
 260
 261     if (ref == 0) {
 262         int i;
 263         for (i = 0; i < This->nFilters; i++)
 264             IBaseFilter_Release(This->ppFiltersInGraph[i]);
 265         for (i = 0; i < This->nItfCacheEntries; i++)
 266             IUnknown_Release(This->ItfCacheEntries[i].iface);
 267         IFilterMapper2_Release(This->pFilterMapper2);
 268         CloseHandle(This->hEventCompletion);
 269         EventsQueue_Destroy(&This->evqueue);
 270         DeleteCriticalSection(&This->cs);
 271         HeapFree(GetProcessHeap(), 0, This->ppFiltersInGraph);
 272         HeapFree(GetProcessHeap(), 0, This->pFilterNames);
 273         HeapFree(GetProcessHeap(), 0, This);
 274     }
 275     return ref;
 276 }
 277
 278
 279 /*** IUnknown methods ***/
 280 static HRESULT WINAPI GraphBuilder_QueryInterface(IGraphBuilder *iface,
 281                                                   REFIID riid,
 282                                                   LPVOID*ppvObj) {
 283     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 284
 285     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
 286     return Filtergraph_QueryInterface(This, riid, ppvObj);
 287 }
 288
 289 static ULONG WINAPI GraphBuilder_AddRef(IGraphBuilder *iface) {
 290     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 291
 292     TRACE("(%p/%p)->() calling FilterGraph AddRef\n", This, iface);
 293
 294     return Filtergraph_AddRef(This);
 295 }
 296
 297 static ULONG WINAPI GraphBuilder_Release(IGraphBuilder *iface) {
 298     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 299
 300     TRACE("(%p/%p)->() calling FilterGraph Release\n", This, iface);
 301
 302     return Filtergraph_Release(This);
 303 }
 304
 305 /*** IFilterGraph methods ***/
 306 static HRESULT WINAPI GraphBuilder_AddFilter(IGraphBuilder *iface,
 307                                              IBaseFilter *pFilter,
 308                                              LPCWSTR pName) {
 309     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 310     HRESULT hr;
 311     int i,j;
 312     WCHAR* wszFilterName = NULL;
 313     int duplicate_name = FALSE;
 314
 315     TRACE("(%p/%p)->(%p, %s (%p))\n", This, iface, pFilter, debugstr_w(pName), pName);
 316
 317     wszFilterName = (WCHAR*) CoTaskMemAlloc( (pName ? strlenW(pName) + 6 : 5) * sizeof(WCHAR) );
 318
 319     if (pName)
 320     {
 321         /* Check if name already exists */
 322         for(i = 0; i < This->nFilters; i++)
 323             if (!strcmpW(This->pFilterNames[i], pName))
 324             {
 325                 duplicate_name = TRUE;
 326                 break;
 327             }
 328     }
 329
 330     /* If no name given or name already existing, generate one */
 331     if (!pName || duplicate_name)
 332     {
 333         static const WCHAR wszFmt1[] = {'%','s',' ','%','0','4','d',0};
 334         static const WCHAR wszFmt2[] = {'%','0','4','d',0};
 335
 336         for (j = 0; j < 10000 ; j++)
 337         {
 338             /* Create name */
 339             if (pName)
 340                 sprintfW(wszFilterName, wszFmt1, pName, This->nameIndex);
 341             else
 342                 sprintfW(wszFilterName, wszFmt2, This->nameIndex);
 343             TRACE("Generated name %s\n", debugstr_w(wszFilterName));
 344
 345             /* Check if the generated name already exists */
 346             for(i = 0; i < This->nFilters; i++)
 347                 if (!strcmpW(This->pFilterNames[i], wszFilterName))
 348                     break;
 349
 350             /* Compute next index and exit if generated name is suitable */
 351             if (This->nameIndex++ == 10000)
 352                 This->nameIndex = 1;
 353             if (i == This->nFilters)
 354                 break;
 355         }
 356         /* Unable to find a suitable name */
 357         if (j == 10000)
 358         {
 359             CoTaskMemFree(wszFilterName);
 360             return VFW_E_DUPLICATE_NAME;
 361         }
 362     }
 363     else
 364         memcpy(wszFilterName, pName, (strlenW(pName) + 1) * sizeof(WCHAR));
 365
 366     if (This->nFilters + 1 > This->filterCapacity)
 367     {
 368         int newCapacity = This->filterCapacity ? 2 * This->filterCapacity : 1;
 369         IBaseFilter ** ppNewFilters = CoTaskMemAlloc(newCapacity * sizeof(IBaseFilter*));
 370         LPWSTR * pNewNames = CoTaskMemAlloc(newCapacity * sizeof(LPWSTR));
 371         memcpy(ppNewFilters, This->ppFiltersInGraph, This->nFilters * sizeof(IBaseFilter*));
 372         memcpy(pNewNames, This->pFilterNames, This->nFilters * sizeof(LPWSTR));
 373         if (!This->filterCapacity)
 374         {
 375             CoTaskMemFree(This->ppFiltersInGraph);
 376             CoTaskMemFree(This->pFilterNames);
 377         }
 378         This->ppFiltersInGraph = ppNewFilters;
 379         This->pFilterNames = pNewNames;
 380         This->filterCapacity = newCapacity;
 381     }
 382
 383     hr = IBaseFilter_JoinFilterGraph(pFilter, (IFilterGraph *)This, wszFilterName);
 384
 385     if (SUCCEEDED(hr))
 386     {
 387         IBaseFilter_AddRef(pFilter);
 388         This->ppFiltersInGraph[This->nFilters] = pFilter;
 389         This->pFilterNames[This->nFilters] = wszFilterName;
 390         This->nFilters++;
 391     }
 392     else
 393         CoTaskMemFree(wszFilterName);
 394
 395     if (SUCCEEDED(hr) && duplicate_name)
 396         return VFW_S_DUPLICATE_NAME;
 397
 398     return hr;
 399 }
 400
 401 static HRESULT WINAPI GraphBuilder_RemoveFilter(IGraphBuilder *iface,
 402                                                 IBaseFilter *pFilter) {
 403     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 404     int i;
 405     HRESULT hr = E_FAIL;
 406
 407     TRACE("(%p/%p)->(%p)\n", This, iface, pFilter);
 408
 409     /* FIXME: check graph is stopped */
 410
 411     for (i = 0; i < This->nFilters; i++)
 412     {
 413         if (This->ppFiltersInGraph[i] == pFilter)
 414         {
 415             /* FIXME: disconnect pins */
 416             hr = IBaseFilter_JoinFilterGraph(pFilter, NULL, This->pFilterNames[i]);
 417             if (SUCCEEDED(hr))
 418             {
 419                 IPin_Release(pFilter);
 420                 CoTaskMemFree(This->pFilterNames[i]);
 421                 memmove(This->ppFiltersInGraph+i, This->ppFiltersInGraph+i+1, sizeof(IBaseFilter*)*(This->nFilters - 1 - i));
 422                 memmove(This->pFilterNames+i, This->pFilterNames+i+1, sizeof(LPWSTR)*(This->nFilters - 1 - i));
 423                 This->nFilters--;
 424                 /* Invalidate interfaces in the cache */
 425                 for (i = 0; i < This->nItfCacheEntries; i++)
 426                     if (pFilter == This->ItfCacheEntries[i].filter)
 427                     {
 428                         IUnknown_Release(This->ItfCacheEntries[i].iface);
 429                         This->ItfCacheEntries[i].iface = NULL;
 430                         This->ItfCacheEntries[i].filter = NULL;
 431                     }
 432                 return S_OK;
 433             }
 434             break;
 435         }
 436     }
 437
 438     return hr; /* FIXME: check this error code */
 439 }
 440
 441 static HRESULT WINAPI GraphBuilder_EnumFilters(IGraphBuilder *iface,
 442                                               IEnumFilters **ppEnum) {
 443     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 444
 445     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 446
 447     return IEnumFiltersImpl_Construct(This->ppFiltersInGraph, This->nFilters, ppEnum);
 448 }
 449
 450 static HRESULT WINAPI GraphBuilder_FindFilterByName(IGraphBuilder *iface,
 451                                                     LPCWSTR pName,
 452                                                     IBaseFilter **ppFilter) {
 453     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 454     int i;
 455
 456     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_w(pName), pName, ppFilter);
 457
 458     *ppFilter = NULL;
 459
 460     for (i = 0; i < This->nFilters; i++)
 461     {
 462         if (!strcmpW(pName, This->pFilterNames[i]))
 463         {
 464             *ppFilter = This->ppFiltersInGraph[i];
 465             IBaseFilter_AddRef(*ppFilter);
 466             return S_OK;
 467         }
 468     }
 469
 470     return E_FAIL; /* FIXME: check this error code */
 471 }
 472
 473 /* NOTE: despite the implication, it doesn't matter which
 474  * way round you put in the input and output pins */
 475 static HRESULT WINAPI GraphBuilder_ConnectDirect(IGraphBuilder *iface,
 476                                                  IPin *ppinIn,
 477                                                  IPin *ppinOut,
 478                                                  const AM_MEDIA_TYPE *pmt) {
 479     PIN_DIRECTION dir;
 480     HRESULT hr;
 481
 482     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 483
 484     TRACE("(%p/%p)->(%p, %p, %p)\n", This, iface, ppinIn, ppinOut, pmt);
 485
 486     /* FIXME: check pins are in graph */
 487
 488     if (TRACE_ON(quartz))
 489     {
 490         PIN_INFO PinInfo;
 491
 492         hr = IPin_QueryPinInfo(ppinIn, &PinInfo);
 493         if (FAILED(hr))
 494             return hr;
 495
 496         TRACE("Filter owning first pin => %p\n", PinInfo.pFilter);
 497         IBaseFilter_Release(PinInfo.pFilter);
 498
 499         hr = IPin_QueryPinInfo(ppinOut, &PinInfo);
 500         if (FAILED(hr))
 501             return hr;
 502
 503         TRACE("Filter owning second pin => %p\n", PinInfo.pFilter);
 504         IBaseFilter_Release(PinInfo.pFilter);
 505     }
 506
 507     hr = IPin_QueryDirection(ppinIn, &dir);
 508     if (SUCCEEDED(hr))
 509     {
 510         if (dir == PINDIR_INPUT)
 511             hr = IPin_Connect(ppinOut, ppinIn, pmt);
 512         else
 513             hr = IPin_Connect(ppinIn, ppinOut, pmt);
 514     }
 515
 516     return hr;
 517 }
 518
 519 static HRESULT WINAPI GraphBuilder_Reconnect(IGraphBuilder *iface,
 520                                              IPin *ppin) {
 521     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 522     IPin *pConnectedTo = NULL;
 523     HRESULT hr;
 524     PIN_DIRECTION pindir;
 525
 526     IPin_QueryDirection(ppin, &pindir);
 527     hr = IPin_ConnectedTo(ppin, &pConnectedTo);
 528     if (FAILED(hr)) {
 529         TRACE("Querying connected to failed: %x\n", hr);
 530         return hr;
 531     }
 532     IPin_Disconnect(ppin);
 533     IPin_Disconnect(pConnectedTo);
 534     if (pindir == PINDIR_INPUT)
 535         hr = IPin_Connect(pConnectedTo, ppin, NULL);
 536     else
 537         hr = IPin_Connect(ppin, pConnectedTo, NULL);
 538     IPin_Release(pConnectedTo);
 539     if (FAILED(hr))
 540         ERR("Reconnecting pins failed, pins are not connected now..\n");
 541     TRACE("(%p->%p) -- %p %p -> %x\n", iface, This, ppin, pConnectedTo, hr);
 542     return hr;
 543 }
 544
 545 static HRESULT WINAPI GraphBuilder_Disconnect(IGraphBuilder *iface,
 546                                               IPin *ppin) {
 547     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 548
 549     TRACE("(%p/%p)->(%p)\n", This, iface, ppin);
 550
 551     return IPin_Disconnect(ppin);
 552 }
 553
 554 static HRESULT WINAPI GraphBuilder_SetDefaultSyncSource(IGraphBuilder *iface) {
 555     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 556
 557     TRACE("(%p/%p)->(): stub !!!\n", iface, This);
 558
 559     return S_OK;
 560 }
 561
 562 static HRESULT GetFilterInfo(IMoniker* pMoniker, GUID* pclsid, VARIANT* pvar)
 563 {
 564     static const WCHAR wszClsidName[] = {'C','L','S','I','D',0};
 565     static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
 566     IPropertyBag * pPropBagCat = NULL;
 567     HRESULT hr;
 568
 569     VariantInit(pvar);
 570     V_VT(pvar) = VT_BSTR;
 571
 572     hr = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (LPVOID*)&pPropBagCat);
 573
 574     if (SUCCEEDED(hr))
 575         hr = IPropertyBag_Read(pPropBagCat, wszClsidName, pvar, NULL);
 576
 577     if (SUCCEEDED(hr))
 578         hr = CLSIDFromString(V_UNION(pvar, bstrVal), pclsid);
 579
 580     if (SUCCEEDED(hr))
 581         hr = IPropertyBag_Read(pPropBagCat, wszFriendlyName, pvar, NULL);
 582
 583     if (SUCCEEDED(hr))
 584         TRACE("Moniker = %s - %s\n", debugstr_guid(pclsid), debugstr_w(V_UNION(pvar, bstrVal)));
 585
 586     if (pPropBagCat)
 587         IPropertyBag_Release(pPropBagCat);
 588
 589     return hr;
 590 }
 591
 592 static HRESULT GetInternalConnections(IBaseFilter* pfilter, IPin* pinputpin, IPin*** pppins, ULONG* pnb)
 593 {
 594     HRESULT hr;
 595     ULONG nb = 0;
 596
 597     TRACE("(%p, %p, %p, %p)\n", pfilter, pinputpin, pppins, pnb);
 598     hr = IPin_QueryInternalConnections(pinputpin, NULL, &nb);
 599     if (hr == S_OK) {
 600         /* Rendered input */
 601     } else if (hr == S_FALSE) {
 602         *pppins = CoTaskMemAlloc(sizeof(IPin*)*nb);
 603         hr = IPin_QueryInternalConnections(pinputpin, *pppins, &nb);
 604         if (hr != S_OK) {
 605             ERR("Error (%x)\n", hr);
 606         }
 607     } else if (hr == E_NOTIMPL) {
 608         /* Input connected to all outputs */
 609         IEnumPins* penumpins;
 610         IPin* ppin;
 611         int i = 0;
 612         TRACE("E_NOTIMPL\n");
 613         hr = IBaseFilter_EnumPins(pfilter, &penumpins);
 614         if (FAILED(hr)) {
 615             ERR("filter Enumpins failed (%x)\n", hr);
 616             return hr;
 617         }
 618         i = 0;
 619         /* Count output pins */
 620         while(IEnumPins_Next(penumpins, 1, &ppin, &nb) == S_OK) {
 621             PIN_DIRECTION pindir;
 622             IPin_QueryDirection(ppin, &pindir);
 623             if (pindir == PINDIR_OUTPUT)
 624                 i++;
 625             IPin_Release(ppin);
 626         }
 627         *pppins = CoTaskMemAlloc(sizeof(IPin*)*i);
 628         /* Retrieve output pins */
 629         IEnumPins_Reset(penumpins);
 630         i = 0;
 631         while(IEnumPins_Next(penumpins, 1, &ppin, &nb) == S_OK) {
 632             PIN_DIRECTION pindir;
 633             IPin_QueryDirection(ppin, &pindir);
 634             if (pindir == PINDIR_OUTPUT)
 635                 (*pppins)[i++] = ppin;
 636             else
 637                 IPin_Release(ppin);
 638         }
 639         nb = i;
 640         if (FAILED(hr)) {
 641             ERR("Next failed (%x)\n", hr);
 642             return hr;
 643         }
 644         IEnumPins_Release(penumpins);
 645     } else if (FAILED(hr)) {
 646         ERR("Cannot get internal connection (%x)\n", hr);
 647         return hr;
 648     }
 649
 650     *pnb = nb;
 651     return S_OK;
 652 }
 653
 654 /*** IGraphBuilder methods ***/
 655 static HRESULT WINAPI GraphBuilder_Connect(IGraphBuilder *iface,
 656                                            IPin *ppinOut,
 657                                            IPin *ppinIn) {
 658     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 659     HRESULT hr;
 660     AM_MEDIA_TYPE* mt;
 661     IEnumMediaTypes* penummt;
 662     ULONG nbmt;
 663     IEnumPins* penumpins;
 664     IEnumMoniker* pEnumMoniker;
 665     GUID tab[2];
 666     ULONG nb;
 667     IMoniker* pMoniker;
 668     ULONG pin;
 669     PIN_INFO PinInfo;
 670     CLSID FilterCLSID;
 671
 672     TRACE("(%p/%p)->(%p, %p)\n", This, iface, ppinOut, ppinIn);
 673
 674     if (TRACE_ON(quartz))
 675     {
 676         hr = IPin_QueryPinInfo(ppinIn, &PinInfo);
 677         if (FAILED(hr))
 678             return hr;
 679
 680         TRACE("Filter owning first pin => %p\n", PinInfo.pFilter);
 681         IBaseFilter_Release(PinInfo.pFilter);
 682
 683         hr = IPin_QueryPinInfo(ppinOut, &PinInfo);
 684         if (FAILED(hr))
 685             return hr;
 686
 687         TRACE("Filter owning second pin => %p\n", PinInfo.pFilter);
 688         IBaseFilter_Release(PinInfo.pFilter);
 689     }
 690
 691     /* Try direct connection first */
 692     hr = IPin_Connect(ppinOut, ppinIn, NULL);
 693     if (SUCCEEDED(hr)) {
 694         return S_OK;
 695     }
 696     TRACE("Direct connection failed, trying to insert other filters\n");
 697
 698     hr = IPin_QueryPinInfo(ppinIn, &PinInfo);
 699     if (FAILED(hr))
 700        return hr;
 701
 702     hr = IBaseFilter_GetClassID(PinInfo.pFilter, &FilterCLSID);
 703     if (FAILED(hr))
 704        return hr;
 705
 706     IBaseFilter_Release(PinInfo.pFilter);
 707
 708     /* Find the appropriate transform filter than can transform the minor media type of output pin of the upstream
 709      * filter to the minor mediatype of input pin of the renderer */
 710     hr = IPin_EnumMediaTypes(ppinOut, &penummt);
 711     if (FAILED(hr)) {
 712         ERR("EnumMediaTypes (%x)\n", hr);
 713         return hr;
 714     }
 715
 716     hr = IEnumMediaTypes_Next(penummt, 1, &mt, &nbmt);
 717     if (FAILED(hr)) {
 718         ERR("IEnumMediaTypes_Next (%x)\n", hr);
 719         return hr;
 720     }
 721
 722     if (!nbmt) {
 723         ERR("No media type found!\n");
 724         return S_OK;
 725     }
 726     TRACE("MajorType %s\n", debugstr_guid(&mt->majortype));
 727     TRACE("SubType %s\n", debugstr_guid(&mt->subtype));
 728
 729     /* Try to find a suitable filter that can connect to the pin to render */
 730     tab[0] = mt->majortype;
 731     tab[1] = mt->subtype;
 732     hr = IFilterMapper2_EnumMatchingFilters(This->pFilterMapper2, &pEnumMoniker, 0, FALSE, 0, TRUE, 1, tab, NULL, NULL, FALSE, FALSE, 0, NULL, NULL, NULL);
 733     if (FAILED(hr)) {
 734         ERR("Unable to enum filters (%x)\n", hr);
 735         return hr;
 736     }
 737
 738     while(IEnumMoniker_Next(pEnumMoniker, 1, &pMoniker, &nb) == S_OK)
 739     {
 740         VARIANT var;
 741         GUID clsid;
 742         IPin** ppins;
 743         IPin* ppinfilter = NULL;
 744         IBaseFilter* pfilter = NULL;
 745
 746         hr = GetFilterInfo(pMoniker, &clsid, &var);
 747         IMoniker_Release(pMoniker);
 748         if (FAILED(hr)) {
 749             ERR("Unable to retrieve filter info (%x)\n", hr);
 750             goto error;
 751         }
 752
 753         if (IsEqualGUID(&clsid, &FilterCLSID)) {
 754             /* Skip filter (same as the one the output pin belongs to) */
 755             goto error;
 756         }
 757
 758         hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&pfilter);
 759         if (FAILED(hr)) {
 760             ERR("Unable to create filter (%x), trying next one\n", hr);
 761             goto error;
 762         }
 763
 764         hr = IGraphBuilder_AddFilter(iface, pfilter, NULL);
 765         if (FAILED(hr)) {
 766             ERR("Unable to add filter (%x)\n", hr);
 767             IBaseFilter_Release(pfilter);
 768             pfilter = NULL;
 769             goto error;
 770         }
 771
 772         hr = IBaseFilter_EnumPins(pfilter, &penumpins);
 773         if (FAILED(hr)) {
 774             ERR("Enumpins (%x)\n", hr);
 775             goto error;
 776         }
 777
 778         hr = IEnumPins_Next(penumpins, 1, &ppinfilter, &pin);
 779         IEnumPins_Release(penumpins);
 780
 781         if (FAILED(hr)) {
 782             ERR("Next (%x)\n", hr);
 783             goto error;
 784         }
 785         if (pin == 0) {
 786             ERR("No Pin\n");
 787             goto error;
 788         }
 789
 790         hr = IPin_Connect(ppinOut, ppinfilter, NULL);
 791         if (FAILED(hr)) {
 792             TRACE("Cannot connect to filter (%x), trying next one\n", hr);
 793             goto error;
 794         }
 795         TRACE("Successfully connected to filter, follow chain...\n");
 796
 797         /* Render all output pins of the filter by calling IGraphBuilder_Render on each of them */
 798         hr = GetInternalConnections(pfilter, ppinfilter, &ppins, &nb);
 799
 800         if (SUCCEEDED(hr)) {
 801             int i;
 802             if (nb == 0) {
 803                 IPin_Disconnect(ppinOut);
 804                 goto error;
 805             }
 806             TRACE("pins to consider: %d\n", nb);
 807             for(i = 0; i < nb; i++) {
 808                 TRACE("Processing pin %d\n", i);
 809                 hr = IGraphBuilder_Connect(iface, ppins[i], ppinIn);
 810                 if (FAILED(hr)) {
 811                    TRACE("Cannot render pin %p (%x)\n", ppinfilter, hr);
 812                 }
 813                 IPin_Release(ppins[i]);
 814                 if (SUCCEEDED(hr)) break;
 815             }
 816             while (++i < nb) IPin_Release(ppins[i]);
 817             CoTaskMemFree(ppins);
 818             IPin_Release(ppinfilter);
 819             break;
 820         }
 821
 822 error:
 823         if (ppinfilter) IPin_Release(ppinfilter);
 824         if (pfilter) {
 825             IGraphBuilder_RemoveFilter(iface, pfilter);
 826             IBaseFilter_Release(pfilter);
 827         }
 828     }
 829
 830     IEnumMediaTypes_Release(penummt);
 831     DeleteMediaType(mt);
 832
 833     return S_OK;
 834 }
 835
 836 static HRESULT WINAPI GraphBuilder_Render(IGraphBuilder *iface,
 837                                           IPin *ppinOut) {
 838     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 839     IEnumMediaTypes* penummt;
 840     AM_MEDIA_TYPE* mt;
 841     ULONG nbmt;
 842     HRESULT hr;
 843
 844     IEnumMoniker* pEnumMoniker;
 845     GUID tab[2];
 846     ULONG nb;
 847     IMoniker* pMoniker;
 848
 849     TRACE("(%p/%p)->(%p)\n", This, iface, ppinOut);
 850
 851     if (TRACE_ON(quartz))
 852     {
 853         PIN_INFO PinInfo;
 854
 855         hr = IPin_QueryPinInfo(ppinOut, &PinInfo);
 856         if (FAILED(hr))
 857             return hr;
 858
 859         TRACE("Filter owning pin => %p\n", PinInfo.pFilter);
 860         IBaseFilter_Release(PinInfo.pFilter);
 861     }
 862
 863     hr = IPin_EnumMediaTypes(ppinOut, &penummt);
 864     if (FAILED(hr)) {
 865         ERR("EnumMediaTypes (%x)\n", hr);
 866         return hr;
 867     }
 868
 869     while(1)
 870     {
 871         hr = IEnumMediaTypes_Next(penummt, 1, &mt, &nbmt);
 872         if (FAILED(hr)) {
 873             ERR("IEnumMediaTypes_Next (%x)\n", hr);
 874             return hr;
 875         }
 876         if (!nbmt)
 877             break;
 878         TRACE("MajorType %s\n", debugstr_guid(&mt->majortype));
 879         TRACE("SubType %s\n", debugstr_guid(&mt->subtype));
 880
 881         /* Try to find a suitable renderer with the same media type */
 882         tab[0] = mt->majortype;
 883         tab[1] = GUID_NULL;
 884         hr = IFilterMapper2_EnumMatchingFilters(This->pFilterMapper2, &pEnumMoniker, 0, FALSE, 0, TRUE, 1, tab, NULL, NULL, TRUE, FALSE, 0, NULL, NULL, NULL);
 885         if (FAILED(hr)) {
 886             ERR("Unable to enum filters (%x)\n", hr);
 887             return hr;
 888         }
 889
 890         while(IEnumMoniker_Next(pEnumMoniker, 1, &pMoniker, &nb) == S_OK)
 891         {
 892             VARIANT var;
 893             GUID clsid;
 894             IPin* ppinfilter;
 895             IBaseFilter* pfilter = NULL;
 896             IEnumPins* penumpins;
 897             ULONG pin;
 898
 899             hr = GetFilterInfo(pMoniker, &clsid, &var);
 900             IMoniker_Release(pMoniker);
 901             if (FAILED(hr)) {
 902                 ERR("Unable to retrieve filter info (%x)\n", hr);
 903                 goto error;
 904             }
 905
 906             hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&pfilter);
 907             if (FAILED(hr)) {
 908                ERR("Unable to create filter (%x), trying next one\n", hr);
 909                goto error;
 910             }
 911
 912             hr = IGraphBuilder_AddFilter(iface, pfilter, NULL);
 913             if (FAILED(hr)) {
 914                 ERR("Unable to add filter (%x)\n", hr);
 915                 pfilter = NULL;
 916                 goto error;
 917             }
 918
 919             hr = IBaseFilter_EnumPins(pfilter, &penumpins);
 920             if (FAILED(hr)) {
 921                 ERR("Splitter Enumpins (%x)\n", hr);
 922                 goto error;
 923             }
 924             hr = IEnumPins_Next(penumpins, 1, &ppinfilter, &pin);
 925             if (FAILED(hr)) {
 926                ERR("Next (%x)\n", hr);
 927                goto error;
 928             }
 929             if (pin == 0) {
 930                ERR("No Pin\n");
 931                goto error;
 932             }
 933             IEnumPins_Release(penumpins);
 934
 935             /* Connect the pin to render to the renderer */
 936             hr = IGraphBuilder_Connect(iface, ppinOut, ppinfilter);
 937             if (FAILED(hr)) {
 938                 TRACE("Unable to connect to renderer (%x)\n", hr);
 939                 goto error;
 940             }
 941             break;
 942
 943 error:
 944             if (pfilter) {
 945                 IGraphBuilder_RemoveFilter(iface, pfilter);
 946                 IBaseFilter_Release(pfilter);
 947             }
 948         }
 949
 950         DeleteMediaType(mt);
 951         break;
 952     }
 953
 954     IEnumMediaTypes_Release(penummt);
 955
 956     return S_OK;
 957 }
 958
 959 static HRESULT WINAPI GraphBuilder_RenderFile(IGraphBuilder *iface,
 960                                               LPCWSTR lpcwstrFile,
 961                                               LPCWSTR lpcwstrPlayList) {
 962     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 963     static const WCHAR string[] = {'R','e','a','d','e','r',0};
 964     IBaseFilter* preader = NULL;
 965     IBaseFilter* psplitter = NULL;
 966     IPin* ppinreader;
 967     IPin* ppinsplitter;
 968     IEnumPins* penumpins;
 969     ULONG pin;
 970     HRESULT hr;
 971     IEnumMoniker* pEnumMoniker = NULL;
 972     GUID tab[2];
 973     IPin** ppins = NULL;
 974     ULONG nb;
 975     IMoniker* pMoniker;
 976     IFileSourceFilter* pfile = NULL;
 977     AM_MEDIA_TYPE mt;
 978     WCHAR* filename;
 979
 980     TRACE("(%p/%p)->(%s, %s)\n", This, iface, debugstr_w(lpcwstrFile), debugstr_w(lpcwstrPlayList));
 981
 982     if (lpcwstrPlayList != NULL)
 983         return E_INVALIDARG;
 984
 985     hr = IGraphBuilder_AddSourceFilter(iface, lpcwstrFile, string, &preader);
 986
 987     /* Retrieve file media type */
 988     if (SUCCEEDED(hr))
 989         hr = IBaseFilter_QueryInterface(preader, &IID_IFileSourceFilter, (LPVOID*)&pfile);
 990     if (SUCCEEDED(hr)) {
 991         hr = IFileSourceFilter_GetCurFile(pfile, &filename, &mt);
 992         IFileSourceFilter_Release(pfile);
 993     }
 994
 995     if (SUCCEEDED(hr))
 996         hr = IBaseFilter_EnumPins(preader, &penumpins);
 997     if (SUCCEEDED(hr)) {
 998         hr = IEnumPins_Next(penumpins, 1, &ppinreader, &pin);
 999         IEnumPins_Release(penumpins);
1000     }
1001
1002     if (SUCCEEDED(hr)) {
1003         tab[0] = mt.majortype;
1004         tab[1] = mt.subtype;
1005         hr = IFilterMapper2_EnumMatchingFilters(This->pFilterMapper2, &pEnumMoniker, 0, FALSE, 0, TRUE, 1, tab, NULL, NULL, FALSE, FALSE, 0, NULL, NULL, NULL);
1006     }
1007
1008     if (FAILED(hr))
1009     {
1010         if (pEnumMoniker)
1011             IEnumMoniker_Release(pEnumMoniker);
1012         if (preader) {
1013              IGraphBuilder_RemoveFilter(iface, preader);
1014              IBaseFilter_Release(preader);
1015         }
1016         return hr;
1017     }
1018
1019     hr = VFW_E_CANNOT_RENDER;
1020     while(IEnumMoniker_Next(pEnumMoniker, 1, &pMoniker, &nb) == S_OK)
1021     {
1022         VARIANT var;
1023         GUID clsid;
1024
1025         hr = GetFilterInfo(pMoniker, &clsid, &var);
1026         IMoniker_Release(pMoniker);
1027         if (FAILED(hr)) {
1028             ERR("Unable to retrieve filter info (%x)\n", hr);
1029             continue;
1030         }
1031
1032         hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&psplitter);
1033         if (FAILED(hr)) {
1034            ERR("Unable to create filter (%x), trying next one\n", hr);
1035            continue;
1036         }
1037
1038         hr = IGraphBuilder_AddFilter(iface, psplitter, NULL);
1039         if (FAILED(hr)) {
1040             ERR("Unable add filter (%x)\n", hr);
1041             IBaseFilter_Release(psplitter);
1042             continue;
1043         }
1044
1045         /* Connect file source and splitter filters together */
1046         /* Make the splitter analyze incoming data */
1047
1048         hr = IBaseFilter_EnumPins(psplitter, &penumpins);
1049         if (SUCCEEDED(hr)) {
1050             hr = IEnumPins_Next(penumpins, 1, &ppinsplitter, &pin);
1051             IEnumPins_Release(penumpins);
1052         }
1053
1054         if (SUCCEEDED(hr))
1055             hr = IPin_Connect(ppinreader, ppinsplitter, NULL);
1056
1057         /* Make sure there's some output pins in the filter */
1058         if (SUCCEEDED(hr))
1059             hr = GetInternalConnections(psplitter, ppinsplitter, &ppins, &nb);
1060         if (SUCCEEDED(hr)) {
1061             if(nb == 0) {
1062                 IPin_Disconnect(ppinreader);
1063                 TRACE("No output pins found in filter\n");
1064                 hr = VFW_E_CANNOT_RENDER;
1065             }
1066         }
1067
1068         IPin_Release(ppinsplitter);
1069         ppinsplitter = NULL;
1070
1071         if (SUCCEEDED(hr)) {
1072             TRACE("Successfully connected to filter\n");
1073             break;
1074         }
1075
1076         TRACE("Cannot connect to filter (%x), trying next one\n", hr);
1077
1078         if (ppins) {
1079             CoTaskMemFree(ppins);
1080             ppins = NULL;
1081         }
1082         IGraphBuilder_RemoveFilter(iface, psplitter);
1083         IBaseFilter_Release(psplitter);
1084         psplitter = NULL;
1085     }
1086
1087     /* Render all output pin of the splitter by calling IGraphBuilder_Render on each of them */
1088     if (SUCCEEDED(hr)) {
1089         int partial = 0;
1090         int i;
1091         TRACE("pins to consider: %d\n", nb);
1092         for(i = 0; i < nb; i++) {
1093             TRACE("Processing pin %d\n", i);
1094             hr = IGraphBuilder_Render(iface, ppins[i]);
1095             if (FAILED(hr)) {
1096                 ERR("Cannot render pin %p (%x)\n", ppins[i], hr);
1097                 partial = 1;
1098             }
1099             IPin_Release(ppins[i]);
1100         }
1101         CoTaskMemFree(ppins);
1102
1103         hr = (partial ? VFW_S_PARTIAL_RENDER : S_OK);
1104     }
1105
1106     return hr;
1107 }
1108
1109 static HRESULT WINAPI GraphBuilder_AddSourceFilter(IGraphBuilder *iface,
1110                                                    LPCWSTR lpcwstrFileName,
1111                                                    LPCWSTR lpcwstrFilterName,
1112                                                    IBaseFilter **ppFilter) {
1113     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
1114     HRESULT hr;
1115     IBaseFilter* preader;
1116     IFileSourceFilter* pfile = NULL;
1117     AM_MEDIA_TYPE mt;
1118     WCHAR* filename;
1119
1120     TRACE("(%p/%p)->(%s, %s, %p)\n", This, iface, debugstr_w(lpcwstrFileName), debugstr_w(lpcwstrFilterName), ppFilter);
1121
1122     /* Instantiate a file source filter */
1123     hr = CoCreateInstance(&CLSID_AsyncReader, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&preader);
1124     if (FAILED(hr)) {
1125         ERR("Unable to create file source filter (%x)\n", hr);
1126         return hr;
1127     }
1128
1129     hr = IGraphBuilder_AddFilter(iface, preader, lpcwstrFilterName);
1130     if (FAILED(hr)) {
1131         ERR("Unable add filter (%x)\n", hr);
1132         IBaseFilter_Release(preader);
1133         return hr;
1134     }
1135
1136     hr = IBaseFilter_QueryInterface(preader, &IID_IFileSourceFilter, (LPVOID*)&pfile);
1137     if (FAILED(hr)) {
1138         ERR("Unable to get IFileSourceInterface (%x)\n", hr);
1139         goto error;
1140     }
1141
1142     /* Load the file in the file source filter */
1143     hr = IFileSourceFilter_Load(pfile, lpcwstrFileName, NULL);
1144     if (FAILED(hr)) {
1145         ERR("Load (%x)\n", hr);
1146         goto error;
1147     }
1148
1149     IFileSourceFilter_GetCurFile(pfile, &filename, &mt);
1150     if (FAILED(hr)) {
1151         ERR("GetCurFile (%x)\n", hr);
1152         goto error;
1153     }
1154     TRACE("File %s\n", debugstr_w(filename));
1155     TRACE("MajorType %s\n", debugstr_guid(&mt.majortype));
1156     TRACE("SubType %s\n", debugstr_guid(&mt.subtype));
1157
1158     if (ppFilter)
1159         *ppFilter = preader;
1160
1161     return S_OK;
1162
1163 error:
1164     if (pfile)
1165         IFileSourceFilter_Release(pfile);
1166     IGraphBuilder_RemoveFilter(iface, preader);
1167     IBaseFilter_Release(preader);
1168
1169     return hr;
1170 }
1171
1172 static HRESULT WINAPI GraphBuilder_SetLogFile(IGraphBuilder *iface,
1173                                               DWORD_PTR hFile) {
1174     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
1175
1176     TRACE("(%p/%p)->(%08x): stub !!!\n", This, iface, (DWORD) hFile);
1177
1178     return S_OK;
1179 }
1180
1181 static HRESULT WINAPI GraphBuilder_Abort(IGraphBuilder *iface) {
1182     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
1183
1184     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1185
1186     return S_OK;
1187 }
1188
1189 static HRESULT WINAPI GraphBuilder_ShouldOperationContinue(IGraphBuilder *iface) {
1190     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
1191
1192     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1193
1194     return S_OK;
1195 }
1196
1197
1198 static const IGraphBuilderVtbl IGraphBuilder_VTable =
1199 {
1200     GraphBuilder_QueryInterface,
1201     GraphBuilder_AddRef,
1202     GraphBuilder_Release,
1203     GraphBuilder_AddFilter,
1204     GraphBuilder_RemoveFilter,
1205     GraphBuilder_EnumFilters,
1206     GraphBuilder_FindFilterByName,
1207     GraphBuilder_ConnectDirect,
1208     GraphBuilder_Reconnect,
1209     GraphBuilder_Disconnect,
1210     GraphBuilder_SetDefaultSyncSource,
1211     GraphBuilder_Connect,
1212     GraphBuilder_Render,
1213     GraphBuilder_RenderFile,
1214     GraphBuilder_AddSourceFilter,
1215     GraphBuilder_SetLogFile,
1216     GraphBuilder_Abort,
1217     GraphBuilder_ShouldOperationContinue
1218 };
1219
1220 /*** IUnknown methods ***/
1221 static HRESULT WINAPI MediaControl_QueryInterface(IMediaControl *iface,
1222                                                   REFIID riid,
1223                                                   LPVOID*ppvObj) {
1224     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1225
1226     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1227
1228     return Filtergraph_QueryInterface(This, riid, ppvObj);
1229 }
1230
1231 static ULONG WINAPI MediaControl_AddRef(IMediaControl *iface) {
1232     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1233
1234     TRACE("(%p/%p)->()\n", This, iface);
1235
1236     return Filtergraph_AddRef(This);
1237 }
1238
1239 static ULONG WINAPI MediaControl_Release(IMediaControl *iface) {
1240     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1241
1242     TRACE("(%p/%p)->()\n", This, iface);
1243
1244     return Filtergraph_Release(This);
1245
1246 }
1247
1248 /*** IDispatch methods ***/
1249 static HRESULT WINAPI MediaControl_GetTypeInfoCount(IMediaControl *iface,
1250                                                     UINT*pctinfo) {
1251     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1252
1253     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1254
1255     return S_OK;
1256 }
1257
1258 static HRESULT WINAPI MediaControl_GetTypeInfo(IMediaControl *iface,
1259                                                UINT iTInfo,
1260                                                LCID lcid,
1261                                                ITypeInfo**ppTInfo) {
1262     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1263
1264     TRACE("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1265
1266     return S_OK;
1267 }
1268
1269 static HRESULT WINAPI MediaControl_GetIDsOfNames(IMediaControl *iface,
1270                                                  REFIID riid,
1271                                                  LPOLESTR*rgszNames,
1272                                                  UINT cNames,
1273                                                  LCID lcid,
1274                                                  DISPID*rgDispId) {
1275     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1276
1277     TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
1278
1279     return S_OK;
1280 }
1281
1282 static HRESULT WINAPI MediaControl_Invoke(IMediaControl *iface,
1283                                           DISPID dispIdMember,
1284                                           REFIID riid,
1285                                           LCID lcid,
1286                                           WORD wFlags,
1287                                           DISPPARAMS*pDispParams,
1288                                           VARIANT*pVarResult,
1289                                           EXCEPINFO*pExepInfo,
1290                                           UINT*puArgErr) {
1291     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1292
1293     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);
1294
1295     return S_OK;
1296 }
1297
1298 typedef HRESULT(WINAPI *fnFoundFilter)(IBaseFilter *);
1299
1300 static HRESULT ExploreGraph(IFilterGraphImpl* pGraph, IPin* pOutputPin, fnFoundFilter FoundFilter)
1301 {
1302     HRESULT hr;
1303     IPin* pInputPin;
1304     IPin** ppPins;
1305     ULONG nb;
1306     ULONG i;
1307     PIN_INFO PinInfo;
1308
1309     TRACE("%p %p\n", pGraph, pOutputPin);
1310     PinInfo.pFilter = NULL;
1311
1312     hr = IPin_ConnectedTo(pOutputPin, &pInputPin);
1313
1314     if (SUCCEEDED(hr))
1315         hr = IPin_QueryPinInfo(pInputPin, &PinInfo);
1316
1317     if (SUCCEEDED(hr))
1318         hr = GetInternalConnections(PinInfo.pFilter, pInputPin, &ppPins, &nb);
1319
1320     if (SUCCEEDED(hr))
1321     {
1322         if (nb == 0)
1323         {
1324             TRACE("Reached a renderer\n");
1325             /* Count renderers for end of stream notification */
1326             pGraph->nRenderers++;
1327         }
1328         else
1329         {
1330             for(i = 0; i < nb; i++)
1331             {
1332                 /* Explore the graph downstream from this pin
1333                  * FIXME: We should prevent exploring from a pin more than once. This can happens when
1334                  * several input pins are connected to the same output (a MUX for instance). */
1335                 ExploreGraph(pGraph, ppPins[i], FoundFilter);
1336                 IPin_Release(ppPins[i]);
1337             }
1338
1339             CoTaskMemFree(ppPins);
1340         }
1341         TRACE("Doing stuff with filter %p\n", PinInfo.pFilter);
1342         FoundFilter(PinInfo.pFilter);
1343     }
1344
1345     if (PinInfo.pFilter) IBaseFilter_Release(PinInfo.pFilter);
1346     return hr;
1347 }
1348
1349 static HRESULT WINAPI SendRun(IBaseFilter *pFilter) {
1350    return IBaseFilter_Run(pFilter, 0);
1351 }
1352
1353 static HRESULT WINAPI SendPause(IBaseFilter *pFilter) {
1354    return IBaseFilter_Pause(pFilter);
1355 }
1356
1357 static HRESULT WINAPI SendStop(IBaseFilter *pFilter) {
1358    return IBaseFilter_Stop(pFilter);
1359 }
1360
1361 static HRESULT SendFilterMessage(IMediaControl *iface, fnFoundFilter FoundFilter) {
1362     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1363     int i;
1364     IBaseFilter* pfilter;
1365     IEnumPins* pEnum;
1366     HRESULT hr;
1367     IPin* pPin;
1368     DWORD dummy;
1369     PIN_DIRECTION dir;
1370     TRACE("(%p/%p)->()\n", This, iface);
1371
1372     /* Explorer the graph from source filters to renderers, determine renderers
1373      * number and run filters from renderers to source filters */
1374     This->nRenderers = 0;
1375     ResetEvent(This->hEventCompletion);
1376
1377     for(i = 0; i < This->nFilters; i++)
1378     {
1379         BOOL source = TRUE;
1380         pfilter = This->ppFiltersInGraph[i];
1381         hr = IBaseFilter_EnumPins(pfilter, &pEnum);
1382         if (hr != S_OK)
1383         {
1384             ERR("Enum pins failed %x\n", hr);
1385             continue;
1386         }
1387         /* Check if it is a source filter */
1388         while(IEnumPins_Next(pEnum, 1, &pPin, &dummy) == S_OK)
1389         {
1390             IPin_QueryDirection(pPin, &dir);
1391             IPin_Release(pPin);
1392             if (dir == PINDIR_INPUT)
1393             {
1394                 source = FALSE;
1395                 break;
1396             }
1397         }
1398         if (source)
1399         {
1400             TRACE("Found a source filter %p\n", pfilter);
1401             IEnumPins_Reset(pEnum);
1402             while(IEnumPins_Next(pEnum, 1, &pPin, &dummy) == S_OK)
1403             {
1404                 /* Explore the graph downstream from this pin */
1405                 ExploreGraph(This, pPin, FoundFilter);
1406                 IPin_Release(pPin);
1407             }
1408             FoundFilter(pfilter);
1409         }
1410         IEnumPins_Release(pEnum);
1411     }
1412
1413     return S_FALSE;
1414 }
1415
1416 /*** IMediaControl methods ***/
1417 static HRESULT WINAPI MediaControl_Run(IMediaControl *iface) {
1418     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1419     TRACE("(%p/%p)->()\n", This, iface);
1420
1421     if (This->state == State_Running) return S_OK;
1422
1423     EnterCriticalSection(&This->cs);
1424     SendFilterMessage(iface, SendRun);
1425     This->state = State_Running;
1426     LeaveCriticalSection(&This->cs);
1427     return S_FALSE;
1428 }
1429
1430 static HRESULT WINAPI MediaControl_Pause(IMediaControl *iface) {
1431     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1432     TRACE("(%p/%p)->()\n", This, iface);
1433
1434     if (This->state == State_Paused) return S_OK;
1435
1436     EnterCriticalSection(&This->cs);
1437     SendFilterMessage(iface, SendPause);
1438     This->state = State_Paused;
1439     LeaveCriticalSection(&This->cs);
1440     return S_FALSE;
1441 }
1442
1443 static HRESULT WINAPI MediaControl_Stop(IMediaControl *iface) {
1444     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1445     TRACE("(%p/%p)->()\n", This, iface);
1446
1447     if (This->state == State_Stopped) return S_OK;
1448
1449     EnterCriticalSection(&This->cs);
1450     if (This->state == State_Running) SendFilterMessage(iface, SendPause);
1451     SendFilterMessage(iface, SendStop);
1452     This->state = State_Stopped;
1453     LeaveCriticalSection(&This->cs);
1454     return S_FALSE;
1455 }
1456
1457 static HRESULT WINAPI MediaControl_GetState(IMediaControl *iface,
1458                                             LONG msTimeout,
1459                                             OAFilterState *pfs) {
1460     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1461
1462     TRACE("(%p/%p)->(%d, %p): semi-stub !!!\n", This, iface, msTimeout, pfs);
1463
1464     EnterCriticalSection(&This->cs);
1465
1466     *pfs = This->state;
1467
1468     LeaveCriticalSection(&This->cs);
1469
1470     return S_OK;
1471 }
1472
1473 static HRESULT WINAPI MediaControl_RenderFile(IMediaControl *iface,
1474                                               BSTR strFilename) {
1475     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1476
1477     TRACE("(%p/%p)->(%s (%p)): stub !!!\n", This, iface, debugstr_w(strFilename), strFilename);
1478
1479     return S_OK;
1480 }
1481
1482 static HRESULT WINAPI MediaControl_AddSourceFilter(IMediaControl *iface,
1483                                                    BSTR strFilename,
1484                                                    IDispatch **ppUnk) {
1485     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1486
1487     TRACE("(%p/%p)->(%s (%p), %p): stub !!!\n", This, iface, debugstr_w(strFilename), strFilename, ppUnk);
1488
1489     return S_OK;
1490 }
1491
1492 static HRESULT WINAPI MediaControl_get_FilterCollection(IMediaControl *iface,
1493                                                         IDispatch **ppUnk) {
1494     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1495
1496     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk);
1497
1498     return S_OK;
1499 }
1500
1501 static HRESULT WINAPI MediaControl_get_RegFilterCollection(IMediaControl *iface,
1502                                                            IDispatch **ppUnk) {
1503     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1504
1505     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk);
1506
1507     return S_OK;
1508 }
1509
1510 static HRESULT WINAPI MediaControl_StopWhenReady(IMediaControl *iface) {
1511     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1512
1513     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1514
1515     return S_OK;
1516 }
1517
1518
1519 static const IMediaControlVtbl IMediaControl_VTable =
1520 {
1521     MediaControl_QueryInterface,
1522     MediaControl_AddRef,
1523     MediaControl_Release,
1524     MediaControl_GetTypeInfoCount,
1525     MediaControl_GetTypeInfo,
1526     MediaControl_GetIDsOfNames,
1527     MediaControl_Invoke,
1528     MediaControl_Run,
1529     MediaControl_Pause,
1530     MediaControl_Stop,
1531     MediaControl_GetState,
1532     MediaControl_RenderFile,
1533     MediaControl_AddSourceFilter,
1534     MediaControl_get_FilterCollection,
1535     MediaControl_get_RegFilterCollection,
1536     MediaControl_StopWhenReady
1537 };
1538
1539
1540 /*** IUnknown methods ***/
1541 static HRESULT WINAPI MediaSeeking_QueryInterface(IMediaSeeking *iface,
1542                                                   REFIID riid,
1543                                                   LPVOID*ppvObj) {
1544     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1545
1546     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1547
1548     return Filtergraph_QueryInterface(This, riid, ppvObj);
1549 }
1550
1551 static ULONG WINAPI MediaSeeking_AddRef(IMediaSeeking *iface) {
1552     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1553
1554     TRACE("(%p/%p)->()\n", This, iface);
1555
1556     return Filtergraph_AddRef(This);
1557 }
1558
1559 static ULONG WINAPI MediaSeeking_Release(IMediaSeeking *iface) {
1560     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1561
1562     TRACE("(%p/%p)->()\n", This, iface);
1563
1564     return Filtergraph_Release(This);
1565 }
1566
1567 /*** IMediaSeeking methods ***/
1568 static HRESULT WINAPI MediaSeeking_GetCapabilities(IMediaSeeking *iface,
1569                                                    DWORD *pCapabilities) {
1570     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1571
1572     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pCapabilities);
1573
1574     return S_OK;
1575 }
1576
1577 static HRESULT WINAPI MediaSeeking_CheckCapabilities(IMediaSeeking *iface,
1578                                                      DWORD *pCapabilities) {
1579     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1580
1581     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pCapabilities);
1582
1583     return S_OK;
1584 }
1585
1586 static HRESULT WINAPI MediaSeeking_IsFormatSupported(IMediaSeeking *iface,
1587                                                      const GUID *pFormat) {
1588     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1589
1590     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
1591
1592     return S_OK;
1593 }
1594
1595 static HRESULT WINAPI MediaSeeking_QueryPreferredFormat(IMediaSeeking *iface,
1596                                                         GUID *pFormat) {
1597     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1598
1599     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
1600
1601     return S_OK;
1602 }
1603
1604 static HRESULT WINAPI MediaSeeking_GetTimeFormat(IMediaSeeking *iface,
1605                                                  GUID *pFormat) {
1606     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1607
1608     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
1609
1610     return S_OK;
1611 }
1612
1613 static HRESULT WINAPI MediaSeeking_IsUsingTimeFormat(IMediaSeeking *iface,
1614                                                      const GUID *pFormat) {
1615     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1616
1617     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
1618
1619     return S_OK;
1620 }
1621
1622 static HRESULT WINAPI MediaSeeking_SetTimeFormat(IMediaSeeking *iface,
1623                                                  const GUID *pFormat) {
1624     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1625
1626     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
1627
1628     return S_OK;
1629 }
1630
1631 static HRESULT WINAPI MediaSeeking_GetDuration(IMediaSeeking *iface,
1632                                                LONGLONG *pDuration) {
1633     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1634
1635     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDuration);
1636
1637     return S_OK;
1638 }
1639
1640 static HRESULT WINAPI MediaSeeking_GetStopPosition(IMediaSeeking *iface,
1641                                                    LONGLONG *pStop) {
1642     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1643
1644     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pStop);
1645
1646     return S_OK;
1647 }
1648
1649 static HRESULT WINAPI MediaSeeking_GetCurrentPosition(IMediaSeeking *iface,
1650                                                       LONGLONG *pCurrent) {
1651     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1652
1653     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pCurrent);
1654
1655     return S_OK;
1656 }
1657
1658 static HRESULT WINAPI MediaSeeking_ConvertTimeFormat(IMediaSeeking *iface,
1659                                                      LONGLONG *pTarget,
1660                                                      const GUID *pTargetFormat,
1661                                                      LONGLONG Source,
1662                                                      const GUID *pSourceFormat) {
1663     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1664
1665     TRACE("(%p/%p)->(%p, %p, 0x%s, %p): stub !!!\n", This, iface, pTarget,
1666         pTargetFormat, wine_dbgstr_longlong(Source), pSourceFormat);
1667
1668     return S_OK;
1669 }
1670
1671 static HRESULT WINAPI MediaSeeking_SetPositions(IMediaSeeking *iface,
1672                                                 LONGLONG *pCurrent,
1673                                                 DWORD dwCurrentFlags,
1674                                                 LONGLONG *pStop,
1675                                                 DWORD dwStopFlags) {
1676     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1677
1678     TRACE("(%p/%p)->(%p, %08x, %p, %08x): stub !!!\n", This, iface, pCurrent, dwCurrentFlags, pStop, dwStopFlags);
1679
1680     return S_OK;
1681 }
1682
1683 static HRESULT WINAPI MediaSeeking_GetPositions(IMediaSeeking *iface,
1684                                                 LONGLONG *pCurrent,
1685                                                 LONGLONG *pStop) {
1686     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1687
1688     TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pCurrent, pStop);
1689
1690     return S_OK;
1691 }
1692
1693 static HRESULT WINAPI MediaSeeking_GetAvailable(IMediaSeeking *iface,
1694                                                 LONGLONG *pEarliest,
1695                                                 LONGLONG *pLatest) {
1696     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1697
1698     TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pEarliest, pLatest);
1699
1700     return S_OK;
1701 }
1702
1703 static HRESULT WINAPI MediaSeeking_SetRate(IMediaSeeking *iface,
1704                                            double dRate) {
1705     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1706
1707     TRACE("(%p/%p)->(%f): stub !!!\n", This, iface, dRate);
1708
1709     return S_OK;
1710 }
1711
1712 static HRESULT WINAPI MediaSeeking_GetRate(IMediaSeeking *iface,
1713                                            double *pdRate) {
1714     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1715
1716     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pdRate);
1717
1718     return S_OK;
1719 }
1720
1721 static HRESULT WINAPI MediaSeeking_GetPreroll(IMediaSeeking *iface,
1722                                               LONGLONG *pllPreroll) {
1723     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1724
1725     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pllPreroll);
1726
1727     return S_OK;
1728 }
1729
1730
1731 static const IMediaSeekingVtbl IMediaSeeking_VTable =
1732 {
1733     MediaSeeking_QueryInterface,
1734     MediaSeeking_AddRef,
1735     MediaSeeking_Release,
1736     MediaSeeking_GetCapabilities,
1737     MediaSeeking_CheckCapabilities,
1738     MediaSeeking_IsFormatSupported,
1739     MediaSeeking_QueryPreferredFormat,
1740     MediaSeeking_GetTimeFormat,
1741     MediaSeeking_IsUsingTimeFormat,
1742     MediaSeeking_SetTimeFormat,
1743     MediaSeeking_GetDuration,
1744     MediaSeeking_GetStopPosition,
1745     MediaSeeking_GetCurrentPosition,
1746     MediaSeeking_ConvertTimeFormat,
1747     MediaSeeking_SetPositions,
1748     MediaSeeking_GetPositions,
1749     MediaSeeking_GetAvailable,
1750     MediaSeeking_SetRate,
1751     MediaSeeking_GetRate,
1752     MediaSeeking_GetPreroll
1753 };
1754
1755 /*** IUnknown methods ***/
1756 static HRESULT WINAPI MediaPosition_QueryInterface(IMediaPosition* iface, REFIID riid, void** ppvObject){
1757     FIXME("(%p) stub!\n", iface);
1758     return E_NOTIMPL;
1759 }
1760
1761 static ULONG WINAPI MediaPosition_AddRef(IMediaPosition *iface){
1762     FIXME("(%p) stub!\n", iface);
1763     return E_NOTIMPL;
1764 }
1765
1766 static ULONG WINAPI MediaPosition_Release(IMediaPosition *iface){
1767     FIXME("(%p) stub!\n", iface);
1768     return E_NOTIMPL;
1769 }
1770
1771 /*** IDispatch methods ***/
1772 static HRESULT WINAPI MediaPosition_GetTypeInfoCount(IMediaPosition *iface, UINT* pctinfo){
1773     FIXME("(%p) stub!\n", iface);
1774     return E_NOTIMPL;
1775 }
1776
1777 static HRESULT WINAPI MediaPosition_GetTypeInfo(IMediaPosition *iface, UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo){
1778     FIXME("(%p) stub!\n", iface);
1779     return E_NOTIMPL;
1780 }
1781
1782 static HRESULT WINAPI MediaPosition_GetIDsOfNames(IMediaPosition* iface, REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId){
1783     FIXME("(%p) stub!\n", iface);
1784     return E_NOTIMPL;
1785 }
1786
1787 static HRESULT WINAPI MediaPosition_Invoke(IMediaPosition* iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr){
1788     FIXME("(%p) stub!\n", iface);
1789     return E_NOTIMPL;
1790 }
1791
1792 /*** IMediaPosition methods ***/
1793 static HRESULT WINAPI MediaPosition_get_Duration(IMediaPosition * iface, REFTIME *plength){
1794     FIXME("(%p)->(%p) stub!\n", iface, plength);
1795     return E_NOTIMPL;
1796 }
1797
1798 static HRESULT WINAPI MediaPosition_put_CurrentPosition(IMediaPosition * iface, REFTIME llTime){
1799     FIXME("(%p)->(%f) stub!\n", iface, llTime);
1800     return E_NOTIMPL;
1801 }
1802
1803 static HRESULT WINAPI MediaPosition_get_CurrentPosition(IMediaPosition * iface, REFTIME *pllTime){
1804     FIXME("(%p)->(%p) stub!\n", iface, pllTime);
1805     return E_NOTIMPL;
1806 }
1807
1808 static HRESULT WINAPI MediaPosition_get_StopTime(IMediaPosition * iface, REFTIME *pllTime){
1809     FIXME("(%p)->(%p) stub!\n", iface, pllTime);
1810     return E_NOTIMPL;
1811 }
1812
1813 static HRESULT WINAPI MediaPosition_put_StopTime(IMediaPosition * iface, REFTIME llTime){
1814     FIXME("(%p)->(%f) stub!\n", iface, llTime);
1815     return E_NOTIMPL;
1816 }
1817
1818 static HRESULT WINAPI MediaPosition_get_PrerollTime(IMediaPosition * iface, REFTIME *pllTime){
1819     FIXME("(%p)->(%p) stub!\n", iface, pllTime);
1820     return E_NOTIMPL;
1821 }
1822
1823 static HRESULT WINAPI MediaPosition_put_PrerollTime(IMediaPosition * iface, REFTIME llTime){
1824     FIXME("(%p)->(%f) stub!\n", iface, llTime);
1825     return E_NOTIMPL;
1826 }
1827
1828 static HRESULT WINAPI MediaPosition_put_Rate(IMediaPosition * iface, double dRate){
1829     FIXME("(%p)->(%f) stub!\n", iface, dRate);
1830     return E_NOTIMPL;
1831 }
1832
1833 static HRESULT WINAPI MediaPosition_get_Rate(IMediaPosition * iface, double *pdRate){
1834     FIXME("(%p)->(%p) stub!\n", iface, pdRate);
1835     return E_NOTIMPL;
1836 }
1837
1838 static HRESULT WINAPI MediaPosition_CanSeekForward(IMediaPosition * iface, LONG *pCanSeekForward){
1839     FIXME("(%p)->(%p) stub!\n", iface, pCanSeekForward);
1840     return E_NOTIMPL;
1841 }
1842
1843 static HRESULT WINAPI MediaPosition_CanSeekBackward(IMediaPosition * iface, LONG *pCanSeekBackward){
1844     FIXME("(%p)->(%p) stub!\n", iface, pCanSeekBackward);
1845     return E_NOTIMPL;
1846 }
1847
1848
1849 static const IMediaPositionVtbl IMediaPosition_VTable =
1850 {
1851     MediaPosition_QueryInterface,
1852     MediaPosition_AddRef,
1853     MediaPosition_Release,
1854     MediaPosition_GetTypeInfoCount,
1855     MediaPosition_GetTypeInfo,
1856     MediaPosition_GetIDsOfNames,
1857     MediaPosition_Invoke,
1858     MediaPosition_get_Duration,
1859     MediaPosition_put_CurrentPosition,
1860     MediaPosition_get_CurrentPosition,
1861     MediaPosition_get_StopTime,
1862     MediaPosition_put_StopTime,
1863     MediaPosition_get_PrerollTime,
1864     MediaPosition_put_PrerollTime,
1865     MediaPosition_put_Rate,
1866     MediaPosition_get_Rate,
1867     MediaPosition_CanSeekForward,
1868     MediaPosition_CanSeekBackward
1869 };
1870
1871 static HRESULT GetTargetInterface(IFilterGraphImpl* pGraph, REFIID riid, LPVOID* ppvObj)
1872 {
1873     HRESULT hr = E_NOINTERFACE;
1874     int i;
1875     int entry;
1876
1877     /* Check if the interface type is already registered */
1878     for (entry = 0; entry < pGraph->nItfCacheEntries; entry++)
1879         if (riid == pGraph->ItfCacheEntries[entry].riid)
1880         {
1881             if (pGraph->ItfCacheEntries[entry].iface)
1882             {
1883                 /* Return the interface if available */
1884                 *ppvObj = pGraph->ItfCacheEntries[entry].iface;
1885                 return S_OK;
1886             }
1887             break;
1888         }
1889
1890     if (entry >= MAX_ITF_CACHE_ENTRIES)
1891     {
1892         FIXME("Not enough space to store interface in the cache\n");
1893         return E_OUTOFMEMORY;
1894     }
1895
1896     /* Find a filter supporting the requested interface */
1897     for (i = 0; i < pGraph->nFilters; i++)
1898     {
1899         hr = IBaseFilter_QueryInterface(pGraph->ppFiltersInGraph[i], riid, ppvObj);
1900         if (hr == S_OK)
1901         {
1902             pGraph->ItfCacheEntries[entry].riid = riid;
1903             pGraph->ItfCacheEntries[entry].filter = pGraph->ppFiltersInGraph[i];
1904             pGraph->ItfCacheEntries[entry].iface = (IUnknown*)*ppvObj;
1905             if (entry >= pGraph->nItfCacheEntries)
1906                 pGraph->nItfCacheEntries++;
1907             return S_OK;
1908         }
1909         if (hr != E_NOINTERFACE)
1910             return hr;
1911     }
1912
1913     return hr;
1914 }
1915
1916 /*** IUnknown methods ***/
1917 static HRESULT WINAPI BasicAudio_QueryInterface(IBasicAudio *iface,
1918                                                 REFIID riid,
1919                                                 LPVOID*ppvObj) {
1920     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1921
1922     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1923
1924     return Filtergraph_QueryInterface(This, riid, ppvObj);
1925 }
1926
1927 static ULONG WINAPI BasicAudio_AddRef(IBasicAudio *iface) {
1928     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1929
1930     TRACE("(%p/%p)->()\n", This, iface);
1931
1932     return Filtergraph_AddRef(This);
1933 }
1934
1935 static ULONG WINAPI BasicAudio_Release(IBasicAudio *iface) {
1936     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1937
1938     TRACE("(%p/%p)->()\n", This, iface);
1939
1940     return Filtergraph_Release(This);
1941 }
1942
1943 /*** IDispatch methods ***/
1944 static HRESULT WINAPI BasicAudio_GetTypeInfoCount(IBasicAudio *iface,
1945                                                   UINT*pctinfo) {
1946     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1947     IBasicAudio* pBasicAudio;
1948     HRESULT hr;
1949
1950     TRACE("(%p/%p)->(%p)\n", This, iface, pctinfo);
1951
1952     EnterCriticalSection(&This->cs);
1953
1954     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
1955
1956     if (hr == S_OK)
1957         hr = IBasicAudio_GetTypeInfoCount(pBasicAudio, pctinfo);
1958
1959     LeaveCriticalSection(&This->cs);
1960
1961     return hr;
1962 }
1963
1964 static HRESULT WINAPI BasicAudio_GetTypeInfo(IBasicAudio *iface,
1965                                              UINT iTInfo,
1966                                              LCID lcid,
1967                                              ITypeInfo**ppTInfo) {
1968     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1969     IBasicAudio* pBasicAudio;
1970     HRESULT hr;
1971
1972     TRACE("(%p/%p)->(%d, %d, %p)\n", This, iface, iTInfo, lcid, ppTInfo);
1973
1974     EnterCriticalSection(&This->cs);
1975
1976     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
1977
1978     if (hr == S_OK)
1979         hr = IBasicAudio_GetTypeInfo(pBasicAudio, iTInfo, lcid, ppTInfo);
1980
1981     LeaveCriticalSection(&This->cs);
1982
1983     return hr;
1984 }
1985
1986 static HRESULT WINAPI BasicAudio_GetIDsOfNames(IBasicAudio *iface,
1987                                                REFIID riid,
1988                                                LPOLESTR*rgszNames,
1989                                                UINT cNames,
1990                                                LCID lcid,
1991                                                DISPID*rgDispId) {
1992     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1993     IBasicAudio* pBasicAudio;
1994     HRESULT hr;
1995
1996     TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p)\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
1997
1998     EnterCriticalSection(&This->cs);
1999
2000     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
2001
2002     if (hr == S_OK)
2003         hr = IBasicAudio_GetIDsOfNames(pBasicAudio, riid, rgszNames, cNames, lcid, rgDispId);
2004
2005     LeaveCriticalSection(&This->cs);
2006
2007     return hr;
2008 }
2009
2010 static HRESULT WINAPI BasicAudio_Invoke(IBasicAudio *iface,
2011                                         DISPID dispIdMember,
2012                                         REFIID riid,
2013                                         LCID lcid,
2014                                         WORD wFlags,
2015                                         DISPPARAMS*pDispParams,
2016                                         VARIANT*pVarResult,
2017                                         EXCEPINFO*pExepInfo,
2018                                         UINT*puArgErr) {
2019     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
2020     IBasicAudio* pBasicAudio;
2021     HRESULT hr;
2022
2023     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);
2024
2025     EnterCriticalSection(&This->cs);
2026
2027     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
2028
2029     if (hr == S_OK)
2030         hr = IBasicAudio_Invoke(pBasicAudio, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
2031
2032     LeaveCriticalSection(&This->cs);
2033
2034     return hr;
2035 }
2036
2037 /*** IBasicAudio methods ***/
2038 static HRESULT WINAPI BasicAudio_put_Volume(IBasicAudio *iface,
2039                                             long lVolume) {
2040     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
2041     IBasicAudio* pBasicAudio;
2042     HRESULT hr;
2043
2044     TRACE("(%p/%p)->(%ld)\n", This, iface, lVolume);
2045
2046     EnterCriticalSection(&This->cs);
2047
2048     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
2049
2050     if (hr == S_OK)
2051         hr = IBasicAudio_put_Volume(pBasicAudio, lVolume);
2052
2053     LeaveCriticalSection(&This->cs);
2054
2055     return hr;
2056 }
2057
2058 static HRESULT WINAPI BasicAudio_get_Volume(IBasicAudio *iface,
2059                                             long *plVolume) {
2060     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
2061     IBasicAudio* pBasicAudio;
2062     HRESULT hr;
2063
2064     TRACE("(%p/%p)->(%p)\n", This, iface, plVolume);
2065
2066     EnterCriticalSection(&This->cs);
2067
2068     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
2069
2070     if (hr == S_OK)
2071         hr = IBasicAudio_get_Volume(pBasicAudio, plVolume);
2072
2073     LeaveCriticalSection(&This->cs);
2074
2075     return hr;
2076 }
2077
2078 static HRESULT WINAPI BasicAudio_put_Balance(IBasicAudio *iface,
2079                                              long lBalance) {
2080     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
2081     IBasicAudio* pBasicAudio;
2082     HRESULT hr;
2083
2084     TRACE("(%p/%p)->(%ld)\n", This, iface, lBalance);
2085
2086     EnterCriticalSection(&This->cs);
2087
2088     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
2089
2090     if (hr == S_OK)
2091         hr = IBasicAudio_put_Balance(pBasicAudio, lBalance);
2092
2093     LeaveCriticalSection(&This->cs);
2094
2095     return hr;
2096 }
2097
2098 static HRESULT WINAPI BasicAudio_get_Balance(IBasicAudio *iface,
2099                                              long *plBalance) {
2100     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
2101     IBasicAudio* pBasicAudio;
2102     HRESULT hr;
2103
2104     TRACE("(%p/%p)->(%p)\n", This, iface, plBalance);
2105
2106     EnterCriticalSection(&This->cs);
2107
2108     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
2109
2110     if (hr == S_OK)
2111         hr = IBasicAudio_get_Balance(pBasicAudio, plBalance);
2112
2113     LeaveCriticalSection(&This->cs);
2114
2115     return hr;
2116 }
2117
2118 static const IBasicAudioVtbl IBasicAudio_VTable =
2119 {
2120     BasicAudio_QueryInterface,
2121     BasicAudio_AddRef,
2122     BasicAudio_Release,
2123     BasicAudio_GetTypeInfoCount,
2124     BasicAudio_GetTypeInfo,
2125     BasicAudio_GetIDsOfNames,
2126     BasicAudio_Invoke,
2127     BasicAudio_put_Volume,
2128     BasicAudio_get_Volume,
2129     BasicAudio_put_Balance,
2130     BasicAudio_get_Balance
2131 };
2132
2133 /*** IUnknown methods ***/
2134 static HRESULT WINAPI BasicVideo_QueryInterface(IBasicVideo *iface,
2135                                                 REFIID riid,
2136                                                 LPVOID*ppvObj) {
2137     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2138
2139     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
2140
2141     return Filtergraph_QueryInterface(This, riid, ppvObj);
2142 }
2143
2144 static ULONG WINAPI BasicVideo_AddRef(IBasicVideo *iface) {
2145     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2146
2147     TRACE("(%p/%p)->()\n", This, iface);
2148
2149     return Filtergraph_AddRef(This);
2150 }
2151
2152 static ULONG WINAPI BasicVideo_Release(IBasicVideo *iface) {
2153     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2154
2155     TRACE("(%p/%p)->()\n", This, iface);
2156
2157     return Filtergraph_Release(This);
2158 }
2159
2160 /*** IDispatch methods ***/
2161 static HRESULT WINAPI BasicVideo_GetTypeInfoCount(IBasicVideo *iface,
2162                                                   UINT*pctinfo) {
2163     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2164     IBasicVideo* pBasicVideo;
2165     HRESULT hr;
2166
2167     TRACE("(%p/%p)->(%p)\n", This, iface, pctinfo);
2168
2169     EnterCriticalSection(&This->cs);
2170
2171     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2172
2173     if (hr == S_OK)
2174         hr = IBasicVideo_GetTypeInfoCount(pBasicVideo, pctinfo);
2175
2176     LeaveCriticalSection(&This->cs);
2177
2178     return hr;
2179 }
2180
2181 static HRESULT WINAPI BasicVideo_GetTypeInfo(IBasicVideo *iface,
2182                                              UINT iTInfo,
2183                                              LCID lcid,
2184                                              ITypeInfo**ppTInfo) {
2185     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2186     IBasicVideo* pBasicVideo;
2187     HRESULT hr;
2188
2189     TRACE("(%p/%p)->(%d, %d, %p)\n", This, iface, iTInfo, lcid, ppTInfo);
2190
2191     EnterCriticalSection(&This->cs);
2192
2193     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2194
2195     if (hr == S_OK)
2196         hr = IBasicVideo_GetTypeInfo(pBasicVideo, iTInfo, lcid, ppTInfo);
2197
2198     LeaveCriticalSection(&This->cs);
2199
2200     return hr;
2201 }
2202
2203 static HRESULT WINAPI BasicVideo_GetIDsOfNames(IBasicVideo *iface,
2204                                                REFIID riid,
2205                                                LPOLESTR*rgszNames,
2206                                                UINT cNames,
2207                                                LCID lcid,
2208                                                DISPID*rgDispId) {
2209     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2210     IBasicVideo* pBasicVideo;
2211     HRESULT hr;
2212
2213     TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p)\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
2214
2215     EnterCriticalSection(&This->cs);
2216
2217     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2218
2219     if (hr == S_OK)
2220         hr = IBasicVideo_GetIDsOfNames(pBasicVideo, riid, rgszNames, cNames, lcid, rgDispId);
2221
2222     LeaveCriticalSection(&This->cs);
2223
2224     return hr;
2225 }
2226
2227 static HRESULT WINAPI BasicVideo_Invoke(IBasicVideo *iface,
2228                                         DISPID dispIdMember,
2229                                         REFIID riid,
2230                                         LCID lcid,
2231                                         WORD wFlags,
2232                                         DISPPARAMS*pDispParams,
2233                                         VARIANT*pVarResult,
2234                                         EXCEPINFO*pExepInfo,
2235                                         UINT*puArgErr) {
2236     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2237     IBasicVideo* pBasicVideo;
2238     HRESULT hr;
2239
2240     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);
2241
2242     EnterCriticalSection(&This->cs);
2243
2244     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2245
2246     if (hr == S_OK)
2247         hr = IBasicVideo_Invoke(pBasicVideo, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
2248
2249     LeaveCriticalSection(&This->cs);
2250
2251     return hr;
2252 }
2253
2254 /*** IBasicVideo methods ***/
2255 static HRESULT WINAPI BasicVideo_get_AvgTimePerFrame(IBasicVideo *iface,
2256                                                      REFTIME *pAvgTimePerFrame) {
2257     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2258     IBasicVideo* pBasicVideo;
2259     HRESULT hr;
2260
2261     TRACE("(%p/%p)->(%p)\n", This, iface, pAvgTimePerFrame);
2262
2263     EnterCriticalSection(&This->cs);
2264
2265     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2266
2267     if (hr == S_OK)
2268         hr = IBasicVideo_get_AvgTimePerFrame(pBasicVideo, pAvgTimePerFrame);
2269
2270     LeaveCriticalSection(&This->cs);
2271
2272     return hr;
2273 }
2274
2275 static HRESULT WINAPI BasicVideo_get_BitRate(IBasicVideo *iface,
2276                                              long *pBitRate) {
2277     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2278     IBasicVideo* pBasicVideo;
2279     HRESULT hr;
2280
2281     TRACE("(%p/%p)->(%p)\n", This, iface, pBitRate);
2282
2283     EnterCriticalSection(&This->cs);
2284
2285     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2286
2287     if (hr == S_OK)
2288         hr = IBasicVideo_get_BitRate(pBasicVideo, pBitRate);
2289
2290     LeaveCriticalSection(&This->cs);
2291
2292     return hr;
2293 }
2294
2295 static HRESULT WINAPI BasicVideo_get_BitErrorRate(IBasicVideo *iface,
2296                                                   long *pBitErrorRate) {
2297     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2298     IBasicVideo* pBasicVideo;
2299     HRESULT hr;
2300
2301     TRACE("(%p/%p)->(%p)\n", This, iface, pBitErrorRate);
2302
2303     EnterCriticalSection(&This->cs);
2304
2305     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2306
2307     if (hr == S_OK)
2308         hr = IBasicVideo_get_BitErrorRate(pBasicVideo, pBitErrorRate);
2309
2310     LeaveCriticalSection(&This->cs);
2311
2312     return hr;
2313 }
2314
2315 static HRESULT WINAPI BasicVideo_get_VideoWidth(IBasicVideo *iface,
2316                                                 long *pVideoWidth) {
2317     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2318     IBasicVideo* pBasicVideo;
2319     HRESULT hr;
2320
2321     TRACE("(%p/%p)->(%p)\n", This, iface, pVideoWidth);
2322
2323     EnterCriticalSection(&This->cs);
2324
2325     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2326
2327     if (hr == S_OK)
2328         hr = IBasicVideo_get_VideoWidth(pBasicVideo, pVideoWidth);
2329
2330     LeaveCriticalSection(&This->cs);
2331
2332     return hr;
2333 }
2334
2335 static HRESULT WINAPI BasicVideo_get_VideoHeight(IBasicVideo *iface,
2336                                                  long *pVideoHeight) {
2337     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2338     IBasicVideo* pBasicVideo;
2339     HRESULT hr;
2340
2341     TRACE("(%p/%p)->(%p)\n", This, iface, pVideoHeight);
2342
2343     EnterCriticalSection(&This->cs);
2344
2345     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2346
2347     if (hr == S_OK)
2348         hr = IBasicVideo_get_VideoHeight(pBasicVideo, pVideoHeight);
2349
2350     LeaveCriticalSection(&This->cs);
2351
2352     return hr;
2353 }
2354
2355 static HRESULT WINAPI BasicVideo_put_SourceLeft(IBasicVideo *iface,
2356                                                 long SourceLeft) {
2357     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2358     IBasicVideo* pBasicVideo;
2359     HRESULT hr;
2360
2361     TRACE("(%p/%p)->(%ld)\n", This, iface, SourceLeft);
2362
2363     EnterCriticalSection(&This->cs);
2364
2365     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2366
2367     if (hr == S_OK)
2368         hr = IBasicVideo_put_SourceLeft(pBasicVideo, SourceLeft);
2369
2370     LeaveCriticalSection(&This->cs);
2371
2372     return hr;
2373 }
2374
2375 static HRESULT WINAPI BasicVideo_get_SourceLeft(IBasicVideo *iface,
2376                                                 long *pSourceLeft) {
2377     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2378     IBasicVideo* pBasicVideo;
2379     HRESULT hr;
2380
2381     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceLeft);
2382
2383     EnterCriticalSection(&This->cs);
2384
2385     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2386
2387     if (hr == S_OK)
2388         hr = IBasicVideo_get_SourceLeft(pBasicVideo, pSourceLeft);
2389
2390     LeaveCriticalSection(&This->cs);
2391
2392     return hr;
2393 }
2394
2395 static HRESULT WINAPI BasicVideo_put_SourceWidth(IBasicVideo *iface,
2396                                                  long SourceWidth) {
2397     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2398     IBasicVideo* pBasicVideo;
2399     HRESULT hr;
2400
2401     TRACE("(%p/%p)->(%ld)\n", This, iface, SourceWidth);
2402
2403     EnterCriticalSection(&This->cs);
2404
2405     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2406
2407     if (hr == S_OK)
2408         hr = IBasicVideo_put_SourceWidth(pBasicVideo, SourceWidth);
2409
2410     LeaveCriticalSection(&This->cs);
2411
2412     return hr;
2413 }
2414
2415 static HRESULT WINAPI BasicVideo_get_SourceWidth(IBasicVideo *iface,
2416                                                  long *pSourceWidth) {
2417     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2418     IBasicVideo* pBasicVideo;
2419     HRESULT hr;
2420
2421     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceWidth);
2422
2423     EnterCriticalSection(&This->cs);
2424
2425     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2426
2427     if (hr == S_OK)
2428         hr = IBasicVideo_get_SourceWidth(pBasicVideo, pSourceWidth);
2429
2430     LeaveCriticalSection(&This->cs);
2431
2432     return hr;
2433 }
2434
2435 static HRESULT WINAPI BasicVideo_put_SourceTop(IBasicVideo *iface,
2436                                                long SourceTop) {
2437     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2438     IBasicVideo* pBasicVideo;
2439     HRESULT hr;
2440
2441     TRACE("(%p/%p)->(%ld)\n", This, iface, SourceTop);
2442
2443     EnterCriticalSection(&This->cs);
2444
2445     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2446
2447     if (hr == S_OK)
2448         hr = IBasicVideo_put_SourceTop(pBasicVideo, SourceTop);
2449
2450     LeaveCriticalSection(&This->cs);
2451
2452     return hr;
2453 }
2454
2455 static HRESULT WINAPI BasicVideo_get_SourceTop(IBasicVideo *iface,
2456                                                long *pSourceTop) {
2457     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2458     IBasicVideo* pBasicVideo;
2459     HRESULT hr;
2460
2461     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceTop);
2462
2463     EnterCriticalSection(&This->cs);
2464
2465     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2466
2467     if (hr == S_OK)
2468         hr = IBasicVideo_get_SourceTop(pBasicVideo, pSourceTop);
2469
2470     LeaveCriticalSection(&This->cs);
2471
2472     return hr;
2473 }
2474
2475 static HRESULT WINAPI BasicVideo_put_SourceHeight(IBasicVideo *iface,
2476                                                   long SourceHeight) {
2477     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2478     IBasicVideo* pBasicVideo;
2479     HRESULT hr;
2480
2481     TRACE("(%p/%p)->(%ld)\n", This, iface, SourceHeight);
2482
2483     EnterCriticalSection(&This->cs);
2484
2485     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2486
2487     if (hr == S_OK)
2488         hr = IBasicVideo_put_SourceHeight(pBasicVideo, SourceHeight);
2489
2490     LeaveCriticalSection(&This->cs);
2491
2492     return hr;
2493 }
2494
2495 static HRESULT WINAPI BasicVideo_get_SourceHeight(IBasicVideo *iface,
2496                                                   long *pSourceHeight) {
2497     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2498     IBasicVideo* pBasicVideo;
2499     HRESULT hr;
2500
2501     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceHeight);
2502
2503     EnterCriticalSection(&This->cs);
2504
2505     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2506
2507     if (hr == S_OK)
2508         hr = IBasicVideo_get_SourceHeight(pBasicVideo, pSourceHeight);
2509
2510     LeaveCriticalSection(&This->cs);
2511
2512     return hr;
2513 }
2514
2515 static HRESULT WINAPI BasicVideo_put_DestinationLeft(IBasicVideo *iface,
2516                                                      long DestinationLeft) {
2517     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2518     IBasicVideo* pBasicVideo;
2519     HRESULT hr;
2520
2521     TRACE("(%p/%p)->(%ld)\n", This, iface, DestinationLeft);
2522
2523     EnterCriticalSection(&This->cs);
2524
2525     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2526
2527     if (hr == S_OK)
2528         hr = IBasicVideo_put_DestinationLeft(pBasicVideo, DestinationLeft);
2529
2530     LeaveCriticalSection(&This->cs);
2531
2532     return hr;
2533 }
2534
2535 static HRESULT WINAPI BasicVideo_get_DestinationLeft(IBasicVideo *iface,
2536                                                      long *pDestinationLeft) {
2537     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2538     IBasicVideo* pBasicVideo;
2539     HRESULT hr;
2540
2541     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationLeft);
2542
2543     EnterCriticalSection(&This->cs);
2544
2545     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2546
2547     if (hr == S_OK)
2548         hr = IBasicVideo_get_DestinationLeft(pBasicVideo, pDestinationLeft);
2549
2550     LeaveCriticalSection(&This->cs);
2551
2552     return hr;
2553 }
2554
2555 static HRESULT WINAPI BasicVideo_put_DestinationWidth(IBasicVideo *iface,
2556                                                       long DestinationWidth) {
2557     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2558     IBasicVideo* pBasicVideo;
2559     HRESULT hr;
2560
2561     TRACE("(%p/%p)->(%ld)\n", This, iface, DestinationWidth);
2562
2563     EnterCriticalSection(&This->cs);
2564
2565     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2566
2567     if (hr == S_OK)
2568         hr = IBasicVideo_put_DestinationWidth(pBasicVideo, DestinationWidth);
2569
2570     LeaveCriticalSection(&This->cs);
2571
2572     return hr;
2573 }
2574
2575 static HRESULT WINAPI BasicVideo_get_DestinationWidth(IBasicVideo *iface,
2576                                                       long *pDestinationWidth) {
2577     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2578     IBasicVideo* pBasicVideo;
2579     HRESULT hr;
2580
2581     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationWidth);
2582
2583     EnterCriticalSection(&This->cs);
2584
2585     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2586
2587     if (hr == S_OK)
2588         hr = IBasicVideo_get_DestinationWidth(pBasicVideo, pDestinationWidth);
2589
2590     LeaveCriticalSection(&This->cs);
2591
2592     return hr;
2593 }
2594
2595 static HRESULT WINAPI BasicVideo_put_DestinationTop(IBasicVideo *iface,
2596                                                     long DestinationTop) {
2597     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2598     IBasicVideo* pBasicVideo;
2599     HRESULT hr;
2600
2601     TRACE("(%p/%p)->(%ld)\n", This, iface, DestinationTop);
2602
2603     EnterCriticalSection(&This->cs);
2604
2605     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2606
2607     if (hr == S_OK)
2608         hr = IBasicVideo_put_DestinationTop(pBasicVideo, DestinationTop);
2609
2610     LeaveCriticalSection(&This->cs);
2611
2612     return hr;
2613 }
2614
2615 static HRESULT WINAPI BasicVideo_get_DestinationTop(IBasicVideo *iface,
2616                                                     long *pDestinationTop) {
2617     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2618     IBasicVideo* pBasicVideo;
2619     HRESULT hr;
2620
2621     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationTop);
2622
2623     EnterCriticalSection(&This->cs);
2624
2625     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2626
2627     if (hr == S_OK)
2628         hr = IBasicVideo_get_DestinationTop(pBasicVideo, pDestinationTop);
2629
2630     LeaveCriticalSection(&This->cs);
2631
2632     return hr;
2633 }
2634
2635 static HRESULT WINAPI BasicVideo_put_DestinationHeight(IBasicVideo *iface,
2636                                                        long DestinationHeight) {
2637     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2638     IBasicVideo* pBasicVideo;
2639     HRESULT hr;
2640
2641     TRACE("(%p/%p)->(%ld)\n", This, iface, DestinationHeight);
2642
2643     EnterCriticalSection(&This->cs);
2644
2645     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2646
2647     if (hr == S_OK)
2648         hr = IBasicVideo_put_DestinationHeight(pBasicVideo, DestinationHeight);
2649
2650     LeaveCriticalSection(&This->cs);
2651
2652     return hr;
2653 }
2654
2655 static HRESULT WINAPI BasicVideo_get_DestinationHeight(IBasicVideo *iface,
2656                                                        long *pDestinationHeight) {
2657     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2658     IBasicVideo* pBasicVideo;
2659     HRESULT hr;
2660
2661     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationHeight);
2662
2663     EnterCriticalSection(&This->cs);
2664
2665     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2666
2667     if (hr == S_OK)
2668         hr = IBasicVideo_get_DestinationHeight(pBasicVideo, pDestinationHeight);
2669
2670     LeaveCriticalSection(&This->cs);
2671
2672     return hr;
2673 }
2674
2675 static HRESULT WINAPI BasicVideo_SetSourcePosition(IBasicVideo *iface,
2676                                                    long Left,
2677                                                    long Top,
2678                                                    long Width,
2679                                                    long Height) {
2680     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2681     IBasicVideo* pBasicVideo;
2682     HRESULT hr;
2683
2684     TRACE("(%p/%p)->(%ld, %ld, %ld, %ld)\n", This, iface, Left, Top, Width, Height);
2685
2686     EnterCriticalSection(&This->cs);
2687
2688     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2689
2690     if (hr == S_OK)
2691         hr = IBasicVideo_SetSourcePosition(pBasicVideo, Left, Top, Width, Height);
2692
2693     LeaveCriticalSection(&This->cs);
2694
2695     return hr;
2696 }
2697
2698 static HRESULT WINAPI BasicVideo_GetSourcePosition(IBasicVideo *iface,
2699                                                    long *pLeft,
2700                                                    long *pTop,
2701                                                    long *pWidth,
2702                                                    long *pHeight) {
2703     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2704     IBasicVideo* pBasicVideo;
2705     HRESULT hr;
2706
2707     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
2708
2709     EnterCriticalSection(&This->cs);
2710
2711     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2712
2713     if (hr == S_OK)
2714         hr = IBasicVideo_GetSourcePosition(pBasicVideo, pLeft, pTop, pWidth, pHeight);
2715
2716     LeaveCriticalSection(&This->cs);
2717
2718     return hr;
2719 }
2720
2721 static HRESULT WINAPI BasicVideo_SetDefaultSourcePosition(IBasicVideo *iface) {
2722     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2723     IBasicVideo* pBasicVideo;
2724     HRESULT hr;
2725
2726     TRACE("(%p/%p)->()\n", This, iface);
2727
2728     EnterCriticalSection(&This->cs);
2729
2730     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2731
2732     if (hr == S_OK)
2733         hr = IBasicVideo_SetDefaultSourcePosition(pBasicVideo);
2734
2735     LeaveCriticalSection(&This->cs);
2736
2737     return hr;
2738 }
2739
2740 static HRESULT WINAPI BasicVideo_SetDestinationPosition(IBasicVideo *iface,
2741                                                         long Left,
2742                                                         long Top,
2743                                                         long Width,
2744                                                         long Height) {
2745     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2746     IBasicVideo* pBasicVideo;
2747     HRESULT hr;
2748
2749     TRACE("(%p/%p)->(%ld, %ld, %ld, %ld)\n", This, iface, Left, Top, Width, Height);
2750
2751     EnterCriticalSection(&This->cs);
2752
2753     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2754
2755     if (hr == S_OK)
2756         hr = IBasicVideo_SetDestinationPosition(pBasicVideo, Left, Top, Width, Height);
2757
2758     LeaveCriticalSection(&This->cs);
2759
2760     return hr;
2761 }
2762
2763 static HRESULT WINAPI BasicVideo_GetDestinationPosition(IBasicVideo *iface,
2764                                                         long *pLeft,
2765                                                         long *pTop,
2766                                                         long *pWidth,
2767                                                         long *pHeight) {
2768     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2769     IBasicVideo* pBasicVideo;
2770     HRESULT hr;
2771
2772     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
2773
2774     EnterCriticalSection(&This->cs);
2775
2776     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2777
2778     if (hr == S_OK)
2779         hr = IBasicVideo_GetDestinationPosition(pBasicVideo, pLeft, pTop, pWidth, pHeight);
2780
2781     LeaveCriticalSection(&This->cs);
2782
2783     return hr;
2784 }
2785
2786 static HRESULT WINAPI BasicVideo_SetDefaultDestinationPosition(IBasicVideo *iface) {
2787     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2788     IBasicVideo* pBasicVideo;
2789     HRESULT hr;
2790
2791     TRACE("(%p/%p)->()\n", This, iface);
2792
2793     EnterCriticalSection(&This->cs);
2794
2795     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2796
2797     if (hr == S_OK)
2798         hr = IBasicVideo_SetDefaultDestinationPosition(pBasicVideo);
2799
2800     LeaveCriticalSection(&This->cs);
2801
2802     return hr;
2803 }
2804
2805 static HRESULT WINAPI BasicVideo_GetVideoSize(IBasicVideo *iface,
2806                                               long *pWidth,
2807                                               long *pHeight) {
2808     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2809     IBasicVideo* pBasicVideo;
2810     HRESULT hr;
2811
2812     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
2813
2814     EnterCriticalSection(&This->cs);
2815
2816     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2817
2818     if (hr == S_OK)
2819         hr = IBasicVideo_GetVideoSize(pBasicVideo, pWidth, pHeight);
2820
2821     LeaveCriticalSection(&This->cs);
2822
2823     return hr;
2824 }
2825
2826 static HRESULT WINAPI BasicVideo_GetVideoPaletteEntries(IBasicVideo *iface,
2827                                                         long StartIndex,
2828                                                         long Entries,
2829                                                         long *pRetrieved,
2830                                                         long *pPalette) {
2831     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2832     IBasicVideo* pBasicVideo;
2833     HRESULT hr;
2834
2835     TRACE("(%p/%p)->(%ld, %ld, %p, %p)\n", This, iface, StartIndex, Entries, pRetrieved, pPalette);
2836
2837     EnterCriticalSection(&This->cs);
2838
2839     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2840
2841     if (hr == S_OK)
2842         hr = IBasicVideo_GetVideoPaletteEntries(pBasicVideo, StartIndex, Entries, pRetrieved, pPalette);
2843
2844     LeaveCriticalSection(&This->cs);
2845
2846     return hr;
2847 }
2848
2849 static HRESULT WINAPI BasicVideo_GetCurrentImage(IBasicVideo *iface,
2850                                                  long *pBufferSize,
2851                                                  long *pDIBImage) {
2852     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2853     IBasicVideo* pBasicVideo;
2854     HRESULT hr;
2855
2856     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pBufferSize, pDIBImage);
2857
2858     EnterCriticalSection(&This->cs);
2859
2860     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2861
2862     if (hr == S_OK)
2863         hr = IBasicVideo_GetCurrentImage(pBasicVideo, pBufferSize, pDIBImage);
2864
2865     LeaveCriticalSection(&This->cs);
2866
2867     return hr;
2868 }
2869
2870 static HRESULT WINAPI BasicVideo_IsUsingDefaultSource(IBasicVideo *iface) {
2871     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2872     IBasicVideo* pBasicVideo;
2873     HRESULT hr;
2874
2875     TRACE("(%p/%p)->()\n", This, iface);
2876
2877     EnterCriticalSection(&This->cs);
2878
2879     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2880
2881     if (hr == S_OK)
2882         hr = IBasicVideo_IsUsingDefaultSource(pBasicVideo);
2883
2884     LeaveCriticalSection(&This->cs);
2885
2886     return hr;
2887 }
2888
2889 static HRESULT WINAPI BasicVideo_IsUsingDefaultDestination(IBasicVideo *iface) {
2890     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2891     IBasicVideo* pBasicVideo;
2892     HRESULT hr;
2893
2894     TRACE("(%p/%p)->()\n", This, iface);
2895
2896     EnterCriticalSection(&This->cs);
2897
2898     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
2899
2900     if (hr == S_OK)
2901         hr = IBasicVideo_IsUsingDefaultDestination(pBasicVideo);
2902
2903     LeaveCriticalSection(&This->cs);
2904
2905     return hr;
2906 }
2907
2908
2909 static const IBasicVideoVtbl IBasicVideo_VTable =
2910 {
2911     BasicVideo_QueryInterface,
2912     BasicVideo_AddRef,
2913     BasicVideo_Release,
2914     BasicVideo_GetTypeInfoCount,
2915     BasicVideo_GetTypeInfo,
2916     BasicVideo_GetIDsOfNames,
2917     BasicVideo_Invoke,
2918     BasicVideo_get_AvgTimePerFrame,
2919     BasicVideo_get_BitRate,
2920     BasicVideo_get_BitErrorRate,
2921     BasicVideo_get_VideoWidth,
2922     BasicVideo_get_VideoHeight,
2923     BasicVideo_put_SourceLeft,
2924     BasicVideo_get_SourceLeft,
2925     BasicVideo_put_SourceWidth,
2926     BasicVideo_get_SourceWidth,
2927     BasicVideo_put_SourceTop,
2928     BasicVideo_get_SourceTop,
2929     BasicVideo_put_SourceHeight,
2930     BasicVideo_get_SourceHeight,
2931     BasicVideo_put_DestinationLeft,
2932     BasicVideo_get_DestinationLeft,
2933     BasicVideo_put_DestinationWidth,
2934     BasicVideo_get_DestinationWidth,
2935     BasicVideo_put_DestinationTop,
2936     BasicVideo_get_DestinationTop,
2937     BasicVideo_put_DestinationHeight,
2938     BasicVideo_get_DestinationHeight,
2939     BasicVideo_SetSourcePosition,
2940     BasicVideo_GetSourcePosition,
2941     BasicVideo_SetDefaultSourcePosition,
2942     BasicVideo_SetDestinationPosition,
2943     BasicVideo_GetDestinationPosition,
2944     BasicVideo_SetDefaultDestinationPosition,
2945     BasicVideo_GetVideoSize,
2946     BasicVideo_GetVideoPaletteEntries,
2947     BasicVideo_GetCurrentImage,
2948     BasicVideo_IsUsingDefaultSource,
2949     BasicVideo_IsUsingDefaultDestination
2950 };
2951
2952
2953 /*** IUnknown methods ***/
2954 static HRESULT WINAPI VideoWindow_QueryInterface(IVideoWindow *iface,
2955                                                  REFIID riid,
2956                                                  LPVOID*ppvObj) {
2957     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2958
2959     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
2960
2961     return Filtergraph_QueryInterface(This, riid, ppvObj);
2962 }
2963
2964 static ULONG WINAPI VideoWindow_AddRef(IVideoWindow *iface) {
2965     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2966
2967     TRACE("(%p/%p)->()\n", This, iface);
2968
2969     return Filtergraph_AddRef(This);
2970 }
2971
2972 static ULONG WINAPI VideoWindow_Release(IVideoWindow *iface) {
2973     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2974
2975     TRACE("(%p/%p)->()\n", This, iface);
2976
2977     return Filtergraph_Release(This);
2978 }
2979
2980 /*** IDispatch methods ***/
2981 static HRESULT WINAPI VideoWindow_GetTypeInfoCount(IVideoWindow *iface,
2982                                                    UINT*pctinfo) {
2983     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2984     IVideoWindow* pVideoWindow;
2985     HRESULT hr;
2986
2987     TRACE("(%p/%p)->(%p)\n", This, iface, pctinfo);
2988
2989     EnterCriticalSection(&This->cs);
2990
2991     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
2992
2993     if (hr == S_OK)
2994         hr = IVideoWindow_GetTypeInfoCount(pVideoWindow, pctinfo);
2995
2996     LeaveCriticalSection(&This->cs);
2997
2998     return hr;
2999 }
3000
3001 static HRESULT WINAPI VideoWindow_GetTypeInfo(IVideoWindow *iface,
3002                                               UINT iTInfo,
3003                                               LCID lcid,
3004                                               ITypeInfo**ppTInfo) {
3005     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3006     IVideoWindow* pVideoWindow;
3007     HRESULT hr;
3008
3009     TRACE("(%p/%p)->(%d, %d, %p)\n", This, iface, iTInfo, lcid, ppTInfo);
3010
3011     EnterCriticalSection(&This->cs);
3012
3013     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3014
3015     if (hr == S_OK)
3016         hr = IVideoWindow_GetTypeInfo(pVideoWindow, iTInfo, lcid, ppTInfo);
3017
3018     LeaveCriticalSection(&This->cs);
3019
3020     return hr;
3021 }
3022
3023 static HRESULT WINAPI VideoWindow_GetIDsOfNames(IVideoWindow *iface,
3024                                                 REFIID riid,
3025                                                 LPOLESTR*rgszNames,
3026                                                 UINT cNames,
3027                                                 LCID lcid,
3028                                                 DISPID*rgDispId) {
3029     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3030     IVideoWindow* pVideoWindow;
3031     HRESULT hr;
3032
3033     TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p)\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
3034
3035     EnterCriticalSection(&This->cs);
3036
3037     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3038
3039     if (hr == S_OK)
3040         hr = IVideoWindow_GetIDsOfNames(pVideoWindow, riid, rgszNames, cNames, lcid, rgDispId);
3041
3042     LeaveCriticalSection(&This->cs);
3043
3044     return hr;
3045 }
3046
3047 static HRESULT WINAPI VideoWindow_Invoke(IVideoWindow *iface,
3048                                          DISPID dispIdMember,
3049                                          REFIID riid,
3050                                          LCID lcid,
3051                                          WORD wFlags,
3052                                          DISPPARAMS*pDispParams,
3053                                          VARIANT*pVarResult,
3054                                          EXCEPINFO*pExepInfo,
3055                                          UINT*puArgErr) {
3056     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3057     IVideoWindow* pVideoWindow;
3058     HRESULT hr;
3059
3060     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);
3061
3062     EnterCriticalSection(&This->cs);
3063
3064     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3065
3066     if (hr == S_OK)
3067         hr = IVideoWindow_Invoke(pVideoWindow, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
3068
3069     LeaveCriticalSection(&This->cs);
3070
3071     return hr;
3072 }
3073
3074
3075 /*** IVideoWindow methods ***/
3076 static HRESULT WINAPI VideoWindow_put_Caption(IVideoWindow *iface,
3077                                               BSTR strCaption) {
3078     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3079     IVideoWindow* pVideoWindow;
3080     HRESULT hr;
3081
3082     TRACE("(%p/%p)->(%s (%p))\n", This, iface, debugstr_w(strCaption), strCaption);
3083
3084     EnterCriticalSection(&This->cs);
3085
3086     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3087
3088     if (hr == S_OK)
3089         hr = IVideoWindow_put_Caption(pVideoWindow, strCaption);
3090
3091     LeaveCriticalSection(&This->cs);
3092
3093     return hr;
3094 }
3095
3096 static HRESULT WINAPI VideoWindow_get_Caption(IVideoWindow *iface,
3097                                               BSTR *strCaption) {
3098     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3099     IVideoWindow* pVideoWindow;
3100     HRESULT hr;
3101
3102     TRACE("(%p/%p)->(%p)\n", This, iface, strCaption);
3103
3104     EnterCriticalSection(&This->cs);
3105
3106     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3107
3108     if (hr == S_OK)
3109         hr = IVideoWindow_get_Caption(pVideoWindow, strCaption);
3110
3111     LeaveCriticalSection(&This->cs);
3112
3113     return hr;
3114 }
3115
3116 static HRESULT WINAPI VideoWindow_put_WindowStyle(IVideoWindow *iface,
3117                                                   long WindowStyle) {
3118     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3119     IVideoWindow* pVideoWindow;
3120     HRESULT hr;
3121
3122     TRACE("(%p/%p)->(%ld)\n", This, iface, WindowStyle);
3123
3124     EnterCriticalSection(&This->cs);
3125
3126     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3127
3128     if (hr == S_OK)
3129         hr = IVideoWindow_put_WindowStyle(pVideoWindow, WindowStyle);
3130
3131     LeaveCriticalSection(&This->cs);
3132
3133     return hr;
3134 }
3135
3136 static HRESULT WINAPI VideoWindow_get_WindowStyle(IVideoWindow *iface,
3137                                                   long *WindowStyle) {
3138     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3139     IVideoWindow* pVideoWindow;
3140     HRESULT hr;
3141
3142     TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyle);
3143
3144     EnterCriticalSection(&This->cs);
3145
3146     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3147
3148     if (hr == S_OK)
3149         hr = IVideoWindow_get_WindowStyle(pVideoWindow, WindowStyle);
3150
3151     LeaveCriticalSection(&This->cs);
3152
3153     return hr;
3154 }
3155
3156 static HRESULT WINAPI VideoWindow_put_WindowStyleEx(IVideoWindow *iface,
3157                                                     long WindowStyleEx) {
3158     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3159     IVideoWindow* pVideoWindow;
3160     HRESULT hr;
3161
3162     TRACE("(%p/%p)->(%ld)\n", This, iface, WindowStyleEx);
3163
3164     EnterCriticalSection(&This->cs);
3165
3166     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3167
3168     if (hr == S_OK)
3169         hr = IVideoWindow_put_WindowStyleEx(pVideoWindow, WindowStyleEx);
3170
3171     LeaveCriticalSection(&This->cs);
3172
3173     return hr;
3174 }
3175
3176 static HRESULT WINAPI VideoWindow_get_WindowStyleEx(IVideoWindow *iface,
3177                                                     long *WindowStyleEx) {
3178     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3179     IVideoWindow* pVideoWindow;
3180     HRESULT hr;
3181
3182     TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyleEx);
3183
3184     EnterCriticalSection(&This->cs);
3185
3186     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3187
3188     if (hr == S_OK)
3189         hr = IVideoWindow_get_WindowStyleEx(pVideoWindow, WindowStyleEx);
3190
3191     LeaveCriticalSection(&This->cs);
3192
3193     return hr;
3194 }
3195
3196 static HRESULT WINAPI VideoWindow_put_AutoShow(IVideoWindow *iface,
3197                                                long AutoShow) {
3198     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3199     IVideoWindow* pVideoWindow;
3200     HRESULT hr;
3201
3202     TRACE("(%p/%p)->(%ld)\n", This, iface, AutoShow);
3203
3204     EnterCriticalSection(&This->cs);
3205
3206     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3207
3208     if (hr == S_OK)
3209         hr = IVideoWindow_put_AutoShow(pVideoWindow, AutoShow);
3210
3211     LeaveCriticalSection(&This->cs);
3212
3213     return hr;
3214 }
3215
3216 static HRESULT WINAPI VideoWindow_get_AutoShow(IVideoWindow *iface,
3217                                                long *AutoShow) {
3218     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3219     IVideoWindow* pVideoWindow;
3220     HRESULT hr;
3221
3222     TRACE("(%p/%p)->(%p)\n", This, iface, AutoShow);
3223
3224     EnterCriticalSection(&This->cs);
3225
3226     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3227
3228     if (hr == S_OK)
3229         hr = IVideoWindow_get_AutoShow(pVideoWindow, AutoShow);
3230
3231     LeaveCriticalSection(&This->cs);
3232
3233     return hr;
3234 }
3235
3236 static HRESULT WINAPI VideoWindow_put_WindowState(IVideoWindow *iface,
3237                                                   long WindowState) {
3238     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3239     IVideoWindow* pVideoWindow;
3240     HRESULT hr;
3241
3242     TRACE("(%p/%p)->(%ld)\n", This, iface, WindowState);
3243
3244     EnterCriticalSection(&This->cs);
3245
3246     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3247
3248     if (hr == S_OK)
3249         hr = IVideoWindow_put_WindowState(pVideoWindow, WindowState);
3250
3251     LeaveCriticalSection(&This->cs);
3252
3253     return hr;
3254 }
3255
3256 static HRESULT WINAPI VideoWindow_get_WindowState(IVideoWindow *iface,
3257                                                   long *WindowState) {
3258     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3259     IVideoWindow* pVideoWindow;
3260     HRESULT hr;
3261
3262     TRACE("(%p/%p)->(%p)\n", This, iface, WindowState);
3263
3264     EnterCriticalSection(&This->cs);
3265
3266     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3267
3268     if (hr == S_OK)
3269         hr = IVideoWindow_get_WindowState(pVideoWindow, WindowState);
3270
3271     LeaveCriticalSection(&This->cs);
3272
3273     return hr;
3274 }
3275
3276 static HRESULT WINAPI VideoWindow_put_BackgroundPalette(IVideoWindow *iface,
3277                                                         long BackgroundPalette) {
3278     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3279     IVideoWindow* pVideoWindow;
3280     HRESULT hr;
3281
3282     TRACE("(%p/%p)->(%ld)\n", This, iface, BackgroundPalette);
3283
3284     EnterCriticalSection(&This->cs);
3285
3286     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3287
3288     if (hr == S_OK)
3289         hr = IVideoWindow_put_BackgroundPalette(pVideoWindow, BackgroundPalette);
3290
3291     LeaveCriticalSection(&This->cs);
3292
3293     return hr;
3294 }
3295
3296 static HRESULT WINAPI VideoWindow_get_BackgroundPalette(IVideoWindow *iface,
3297                                                         long *pBackgroundPalette) {
3298     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3299     IVideoWindow* pVideoWindow;
3300     HRESULT hr;
3301
3302     TRACE("(%p/%p)->(%p)\n", This, iface, pBackgroundPalette);
3303
3304     EnterCriticalSection(&This->cs);
3305
3306     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3307
3308     if (hr == S_OK)
3309         hr = IVideoWindow_get_BackgroundPalette(pVideoWindow, pBackgroundPalette);
3310
3311     LeaveCriticalSection(&This->cs);
3312
3313     return hr;
3314 }
3315
3316 static HRESULT WINAPI VideoWindow_put_Visible(IVideoWindow *iface,
3317                                               long Visible) {
3318     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3319     IVideoWindow* pVideoWindow;
3320     HRESULT hr;
3321
3322     TRACE("(%p/%p)->(%ld)\n", This, iface, Visible);
3323
3324     EnterCriticalSection(&This->cs);
3325
3326     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3327
3328     if (hr == S_OK)
3329         hr = IVideoWindow_put_Visible(pVideoWindow, Visible);
3330
3331     LeaveCriticalSection(&This->cs);
3332
3333     return hr;
3334 }
3335
3336 static HRESULT WINAPI VideoWindow_get_Visible(IVideoWindow *iface,
3337                                               long *pVisible) {
3338     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3339     IVideoWindow* pVideoWindow;
3340     HRESULT hr;
3341
3342     TRACE("(%p/%p)->(%p)\n", This, iface, pVisible);
3343
3344     EnterCriticalSection(&This->cs);
3345
3346     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3347
3348     if (hr == S_OK)
3349         hr = IVideoWindow_get_Visible(pVideoWindow, pVisible);
3350
3351     LeaveCriticalSection(&This->cs);
3352
3353     return hr;
3354 }
3355
3356 static HRESULT WINAPI VideoWindow_put_Left(IVideoWindow *iface,
3357                                            long Left) {
3358     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3359     IVideoWindow* pVideoWindow;
3360     HRESULT hr;
3361
3362     TRACE("(%p/%p)->(%ld)\n", This, iface, Left);
3363
3364     EnterCriticalSection(&This->cs);
3365
3366     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3367
3368     if (hr == S_OK)
3369         hr = IVideoWindow_put_Left(pVideoWindow, Left);
3370
3371     LeaveCriticalSection(&This->cs);
3372
3373     return hr;
3374 }
3375
3376 static HRESULT WINAPI VideoWindow_get_Left(IVideoWindow *iface,
3377                                            long *pLeft) {
3378     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3379     IVideoWindow* pVideoWindow;
3380     HRESULT hr;
3381
3382     TRACE("(%p/%p)->(%p)\n", This, iface, pLeft);
3383
3384     EnterCriticalSection(&This->cs);
3385
3386     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3387
3388     if (hr == S_OK)
3389         hr = IVideoWindow_get_Left(pVideoWindow, pLeft);
3390
3391     LeaveCriticalSection(&This->cs);
3392
3393     return hr;
3394 }
3395
3396 static HRESULT WINAPI VideoWindow_put_Width(IVideoWindow *iface,
3397                                             long Width) {
3398     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3399     IVideoWindow* pVideoWindow;
3400     HRESULT hr;
3401
3402     TRACE("(%p/%p)->(%ld)\n", This, iface, Width);
3403
3404     EnterCriticalSection(&This->cs);
3405
3406     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3407
3408     if (hr == S_OK)
3409         hr = IVideoWindow_put_Width(pVideoWindow, Width);
3410
3411     LeaveCriticalSection(&This->cs);
3412
3413     return hr;
3414 }
3415
3416 static HRESULT WINAPI VideoWindow_get_Width(IVideoWindow *iface,
3417                                             long *pWidth) {
3418     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3419     IVideoWindow* pVideoWindow;
3420     HRESULT hr;
3421
3422     TRACE("(%p/%p)->(%p)\n", This, iface, pWidth);
3423
3424     EnterCriticalSection(&This->cs);
3425
3426     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3427
3428     if (hr == S_OK)
3429         hr = IVideoWindow_get_Width(pVideoWindow, pWidth);
3430
3431     LeaveCriticalSection(&This->cs);
3432
3433     return hr;
3434 }
3435
3436 static HRESULT WINAPI VideoWindow_put_Top(IVideoWindow *iface,
3437                                           long Top) {
3438     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3439     IVideoWindow* pVideoWindow;
3440     HRESULT hr;
3441
3442     TRACE("(%p/%p)->(%ld)\n", This, iface, Top);
3443
3444     EnterCriticalSection(&This->cs);
3445
3446     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3447
3448     if (hr == S_OK)
3449         hr = IVideoWindow_put_Top(pVideoWindow, Top);
3450
3451     LeaveCriticalSection(&This->cs);
3452
3453     return hr;
3454 }
3455
3456 static HRESULT WINAPI VideoWindow_get_Top(IVideoWindow *iface,
3457                                           long *pTop) {
3458     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3459     IVideoWindow* pVideoWindow;
3460     HRESULT hr;
3461
3462     TRACE("(%p/%p)->(%p)\n", This, iface, pTop);
3463
3464     EnterCriticalSection(&This->cs);
3465
3466     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3467
3468     if (hr == S_OK)
3469         hr = IVideoWindow_get_Top(pVideoWindow, pTop);
3470
3471     LeaveCriticalSection(&This->cs);
3472
3473     return hr;
3474 }
3475
3476 static HRESULT WINAPI VideoWindow_put_Height(IVideoWindow *iface,
3477                                              long Height) {
3478     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3479     IVideoWindow* pVideoWindow;
3480     HRESULT hr;
3481
3482     TRACE("(%p/%p)->(%ld)\n", This, iface, Height);
3483
3484     EnterCriticalSection(&This->cs);
3485
3486     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3487
3488     if (hr == S_OK)
3489         hr = IVideoWindow_put_Height(pVideoWindow, Height);
3490
3491     LeaveCriticalSection(&This->cs);
3492
3493     return hr;
3494 }
3495
3496 static HRESULT WINAPI VideoWindow_get_Height(IVideoWindow *iface,
3497                                              long *pHeight) {
3498     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3499     IVideoWindow* pVideoWindow;
3500     HRESULT hr;
3501
3502     TRACE("(%p/%p)->(%p)\n", This, iface, pHeight);
3503
3504     EnterCriticalSection(&This->cs);
3505
3506     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3507
3508     if (hr == S_OK)
3509         hr = IVideoWindow_get_Height(pVideoWindow, pHeight);
3510
3511     LeaveCriticalSection(&This->cs);
3512
3513     return hr;
3514 }
3515
3516 static HRESULT WINAPI VideoWindow_put_Owner(IVideoWindow *iface,
3517                                             OAHWND Owner) {
3518     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3519     IVideoWindow* pVideoWindow;
3520     HRESULT hr;
3521
3522     TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Owner);
3523
3524     EnterCriticalSection(&This->cs);
3525
3526     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3527
3528     if (hr == S_OK)
3529         hr = IVideoWindow_put_Owner(pVideoWindow, Owner);
3530
3531     LeaveCriticalSection(&This->cs);
3532
3533     return hr;
3534 }
3535
3536 static HRESULT WINAPI VideoWindow_get_Owner(IVideoWindow *iface,
3537                                             OAHWND *Owner) {
3538     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3539     IVideoWindow* pVideoWindow;
3540     HRESULT hr;
3541
3542     TRACE("(%p/%p)->(%p)\n", This, iface, Owner);
3543
3544     EnterCriticalSection(&This->cs);
3545
3546     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3547
3548     if (hr == S_OK)
3549         hr = IVideoWindow_get_Owner(pVideoWindow, Owner);
3550
3551     LeaveCriticalSection(&This->cs);
3552
3553     return hr;
3554 }
3555
3556 static HRESULT WINAPI VideoWindow_put_MessageDrain(IVideoWindow *iface,
3557                                                    OAHWND Drain) {
3558     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3559     IVideoWindow* pVideoWindow;
3560     HRESULT hr;
3561
3562     TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Drain);
3563
3564     EnterCriticalSection(&This->cs);
3565
3566     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3567
3568     if (hr == S_OK)
3569         hr = IVideoWindow_put_MessageDrain(pVideoWindow, Drain);
3570
3571     LeaveCriticalSection(&This->cs);
3572
3573     return hr;
3574 }
3575
3576 static HRESULT WINAPI VideoWindow_get_MessageDrain(IVideoWindow *iface,
3577                                                    OAHWND *Drain) {
3578     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3579     IVideoWindow* pVideoWindow;
3580     HRESULT hr;
3581
3582     TRACE("(%p/%p)->(%p)\n", This, iface, Drain);
3583
3584     EnterCriticalSection(&This->cs);
3585
3586     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3587
3588     if (hr == S_OK)
3589         hr = IVideoWindow_get_MessageDrain(pVideoWindow, Drain);
3590
3591     LeaveCriticalSection(&This->cs);
3592
3593     return hr;
3594 }
3595
3596 static HRESULT WINAPI VideoWindow_get_BorderColor(IVideoWindow *iface,
3597                                                   long *Color) {
3598     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3599     IVideoWindow* pVideoWindow;
3600     HRESULT hr;
3601
3602     TRACE("(%p/%p)->(%p)\n", This, iface, Color);
3603
3604     EnterCriticalSection(&This->cs);
3605
3606     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3607
3608     if (hr == S_OK)
3609         hr = IVideoWindow_get_BorderColor(pVideoWindow, Color);
3610
3611     LeaveCriticalSection(&This->cs);
3612
3613     return hr;
3614 }
3615
3616 static HRESULT WINAPI VideoWindow_put_BorderColor(IVideoWindow *iface,
3617                                                   long Color) {
3618     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3619     IVideoWindow* pVideoWindow;
3620     HRESULT hr;
3621
3622     TRACE("(%p/%p)->(%ld)\n", This, iface, Color);
3623
3624     EnterCriticalSection(&This->cs);
3625
3626     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3627
3628     if (hr == S_OK)
3629         hr = IVideoWindow_put_BorderColor(pVideoWindow, Color);
3630
3631     LeaveCriticalSection(&This->cs);
3632
3633     return hr;
3634 }
3635
3636 static HRESULT WINAPI VideoWindow_get_FullScreenMode(IVideoWindow *iface,
3637                                                      long *FullScreenMode) {
3638     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3639     IVideoWindow* pVideoWindow;
3640     HRESULT hr;
3641
3642     TRACE("(%p/%p)->(%p)\n", This, iface, FullScreenMode);
3643
3644     EnterCriticalSection(&This->cs);
3645
3646     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3647
3648     if (hr == S_OK)
3649         hr = IVideoWindow_get_FullScreenMode(pVideoWindow, FullScreenMode);
3650
3651     LeaveCriticalSection(&This->cs);
3652
3653     return hr;
3654 }
3655
3656 static HRESULT WINAPI VideoWindow_put_FullScreenMode(IVideoWindow *iface,
3657                                                      long FullScreenMode) {
3658     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3659     IVideoWindow* pVideoWindow;
3660     HRESULT hr;
3661
3662     TRACE("(%p/%p)->(%ld)\n", This, iface, FullScreenMode);
3663
3664     EnterCriticalSection(&This->cs);
3665
3666     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3667
3668     if (hr == S_OK)
3669         hr = IVideoWindow_put_FullScreenMode(pVideoWindow, FullScreenMode);
3670
3671     LeaveCriticalSection(&This->cs);
3672
3673     return hr;
3674 }
3675
3676 static HRESULT WINAPI VideoWindow_SetWindowForeground(IVideoWindow *iface,
3677                                                       long Focus) {
3678     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3679     IVideoWindow* pVideoWindow;
3680     HRESULT hr;
3681
3682     TRACE("(%p/%p)->(%ld)\n", This, iface, Focus);
3683
3684     EnterCriticalSection(&This->cs);
3685
3686     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3687
3688     if (hr == S_OK)
3689         hr = IVideoWindow_SetWindowForeground(pVideoWindow, Focus);
3690
3691     LeaveCriticalSection(&This->cs);
3692
3693     return hr;
3694 }
3695
3696 static HRESULT WINAPI VideoWindow_NotifyOwnerMessage(IVideoWindow *iface,
3697                                                      OAHWND hwnd,
3698                                                      long uMsg,
3699                                                      LONG_PTR wParam,
3700                                                      LONG_PTR lParam) {
3701     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3702     IVideoWindow* pVideoWindow;
3703     HRESULT hr;
3704
3705     TRACE("(%p/%p)->(%08x, %ld, %08lx, %08lx)\n", This, iface, (DWORD) hwnd, uMsg, wParam, lParam);
3706
3707     EnterCriticalSection(&This->cs);
3708
3709     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3710
3711     if (hr == S_OK)
3712         hr = IVideoWindow_NotifyOwnerMessage(pVideoWindow, hwnd, uMsg, wParam, lParam);
3713
3714     LeaveCriticalSection(&This->cs);
3715
3716     return hr;
3717 }
3718
3719 static HRESULT WINAPI VideoWindow_SetWindowPosition(IVideoWindow *iface,
3720                                                     long Left,
3721                                                     long Top,
3722                                                     long Width,
3723                                                     long Height) {
3724     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3725     IVideoWindow* pVideoWindow;
3726     HRESULT hr;
3727
3728     TRACE("(%p/%p)->(%ld, %ld, %ld, %ld)\n", This, iface, Left, Top, Width, Height);
3729
3730     EnterCriticalSection(&This->cs);
3731
3732     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3733
3734     if (hr == S_OK)
3735         hr = IVideoWindow_SetWindowPosition(pVideoWindow, Left, Top, Width, Height);
3736
3737     LeaveCriticalSection(&This->cs);
3738
3739     return hr;
3740 }
3741
3742 static HRESULT WINAPI VideoWindow_GetWindowPosition(IVideoWindow *iface,
3743                                                     long *pLeft,
3744                                                     long *pTop,
3745                                                     long *pWidth,
3746                                                     long *pHeight) {
3747     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3748     IVideoWindow* pVideoWindow;
3749     HRESULT hr;
3750
3751     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
3752
3753     EnterCriticalSection(&This->cs);
3754
3755     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3756
3757     if (hr == S_OK)
3758         hr = IVideoWindow_GetWindowPosition(pVideoWindow, pLeft, pTop, pWidth, pHeight);
3759
3760     LeaveCriticalSection(&This->cs);
3761
3762     return hr;
3763 }
3764
3765 static HRESULT WINAPI VideoWindow_GetMinIdealImageSize(IVideoWindow *iface,
3766                                                        long *pWidth,
3767                                                        long *pHeight) {
3768     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3769     IVideoWindow* pVideoWindow;
3770     HRESULT hr;
3771
3772     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
3773
3774     EnterCriticalSection(&This->cs);
3775
3776     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3777
3778     if (hr == S_OK)
3779         hr = IVideoWindow_GetMinIdealImageSize(pVideoWindow, pWidth, pHeight);
3780
3781     LeaveCriticalSection(&This->cs);
3782
3783     return hr;
3784 }
3785
3786 static HRESULT WINAPI VideoWindow_GetMaxIdealImageSize(IVideoWindow *iface,
3787                                                        long *pWidth,
3788                                                        long *pHeight) {
3789     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3790     IVideoWindow* pVideoWindow;
3791     HRESULT hr;
3792
3793     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
3794
3795     EnterCriticalSection(&This->cs);
3796
3797     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3798
3799     if (hr == S_OK)
3800         hr = IVideoWindow_GetMaxIdealImageSize(pVideoWindow, pWidth, pHeight);
3801
3802     LeaveCriticalSection(&This->cs);
3803
3804     return hr;
3805 }
3806
3807 static HRESULT WINAPI VideoWindow_GetRestorePosition(IVideoWindow *iface,
3808                                                      long *pLeft,
3809                                                      long *pTop,
3810                                                      long *pWidth,
3811                                                      long *pHeight) {
3812     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3813     IVideoWindow* pVideoWindow;
3814     HRESULT hr;
3815
3816     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
3817
3818     EnterCriticalSection(&This->cs);
3819
3820     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3821
3822     if (hr == S_OK)
3823         hr = IVideoWindow_GetRestorePosition(pVideoWindow, pLeft, pTop, pWidth, pHeight);
3824
3825     LeaveCriticalSection(&This->cs);
3826
3827     return hr;
3828 }
3829
3830 static HRESULT WINAPI VideoWindow_HideCursor(IVideoWindow *iface,
3831                                              long HideCursor) {
3832     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3833     IVideoWindow* pVideoWindow;
3834     HRESULT hr;
3835
3836     TRACE("(%p/%p)->(%ld)\n", This, iface, HideCursor);
3837
3838     EnterCriticalSection(&This->cs);
3839
3840     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3841
3842     if (hr == S_OK)
3843         hr = IVideoWindow_HideCursor(pVideoWindow, HideCursor);
3844
3845     LeaveCriticalSection(&This->cs);
3846
3847     return hr;
3848 }
3849
3850 static HRESULT WINAPI VideoWindow_IsCursorHidden(IVideoWindow *iface,
3851                                                  long *CursorHidden) {
3852     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
3853     IVideoWindow* pVideoWindow;
3854     HRESULT hr;
3855
3856     TRACE("(%p/%p)->(%p)\n", This, iface, CursorHidden);
3857
3858     EnterCriticalSection(&This->cs);
3859
3860     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3861
3862     if (hr == S_OK)
3863         hr = IVideoWindow_IsCursorHidden(pVideoWindow, CursorHidden);
3864
3865     LeaveCriticalSection(&This->cs);
3866
3867     return hr;
3868 }
3869
3870
3871 static const IVideoWindowVtbl IVideoWindow_VTable =
3872 {
3873     VideoWindow_QueryInterface,
3874     VideoWindow_AddRef,
3875     VideoWindow_Release,
3876     VideoWindow_GetTypeInfoCount,
3877     VideoWindow_GetTypeInfo,
3878     VideoWindow_GetIDsOfNames,
3879     VideoWindow_Invoke,
3880     VideoWindow_put_Caption,
3881     VideoWindow_get_Caption,
3882     VideoWindow_put_WindowStyle,
3883     VideoWindow_get_WindowStyle,
3884     VideoWindow_put_WindowStyleEx,
3885     VideoWindow_get_WindowStyleEx,
3886     VideoWindow_put_AutoShow,
3887     VideoWindow_get_AutoShow,
3888     VideoWindow_put_WindowState,
3889     VideoWindow_get_WindowState,
3890     VideoWindow_put_BackgroundPalette,
3891     VideoWindow_get_BackgroundPalette,
3892     VideoWindow_put_Visible,
3893     VideoWindow_get_Visible,
3894     VideoWindow_put_Left,
3895     VideoWindow_get_Left,
3896     VideoWindow_put_Width,
3897     VideoWindow_get_Width,
3898     VideoWindow_put_Top,
3899     VideoWindow_get_Top,
3900     VideoWindow_put_Height,
3901     VideoWindow_get_Height,
3902     VideoWindow_put_Owner,
3903     VideoWindow_get_Owner,
3904     VideoWindow_put_MessageDrain,
3905     VideoWindow_get_MessageDrain,
3906     VideoWindow_get_BorderColor,
3907     VideoWindow_put_BorderColor,
3908     VideoWindow_get_FullScreenMode,
3909     VideoWindow_put_FullScreenMode,
3910     VideoWindow_SetWindowForeground,
3911     VideoWindow_NotifyOwnerMessage,
3912     VideoWindow_SetWindowPosition,
3913     VideoWindow_GetWindowPosition,
3914     VideoWindow_GetMinIdealImageSize,
3915     VideoWindow_GetMaxIdealImageSize,
3916     VideoWindow_GetRestorePosition,
3917     VideoWindow_HideCursor,
3918     VideoWindow_IsCursorHidden
3919 };
3920
3921
3922 /*** IUnknown methods ***/
3923 static HRESULT WINAPI MediaEvent_QueryInterface(IMediaEventEx *iface,
3924                                                 REFIID riid,
3925                                                 LPVOID*ppvObj) {
3926     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
3927
3928     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
3929
3930     return Filtergraph_QueryInterface(This, riid, ppvObj);
3931 }
3932
3933 static ULONG WINAPI MediaEvent_AddRef(IMediaEventEx *iface) {
3934     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
3935
3936     TRACE("(%p/%p)->()\n", This, iface);
3937
3938     return Filtergraph_AddRef(This);
3939 }
3940
3941 static ULONG WINAPI MediaEvent_Release(IMediaEventEx *iface) {
3942     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
3943
3944     TRACE("(%p/%p)->()\n", This, iface);
3945
3946     return Filtergraph_Release(This);
3947 }
3948
3949 /*** IDispatch methods ***/
3950 static HRESULT WINAPI MediaEvent_GetTypeInfoCount(IMediaEventEx *iface,
3951                                                   UINT*pctinfo) {
3952     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
3953
3954     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
3955
3956     return S_OK;
3957 }
3958
3959 static HRESULT WINAPI MediaEvent_GetTypeInfo(IMediaEventEx *iface,
3960                                              UINT iTInfo,
3961                                              LCID lcid,
3962                                              ITypeInfo**ppTInfo) {
3963     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
3964
3965     TRACE("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
3966
3967     return S_OK;
3968 }
3969
3970 static HRESULT WINAPI MediaEvent_GetIDsOfNames(IMediaEventEx *iface,
3971                                                REFIID riid,
3972                                                LPOLESTR*rgszNames,
3973                                                UINT cNames,
3974                                                LCID lcid,
3975                                                DISPID*rgDispId) {
3976     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
3977
3978     TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
3979
3980     return S_OK;
3981 }
3982
3983 static HRESULT WINAPI MediaEvent_Invoke(IMediaEventEx *iface,
3984                                         DISPID dispIdMember,
3985                                         REFIID riid,
3986                                         LCID lcid,
3987                                         WORD wFlags,
3988                                         DISPPARAMS*pDispParams,
3989                                         VARIANT*pVarResult,
3990                                         EXCEPINFO*pExepInfo,
3991                                         UINT*puArgErr) {
3992     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
3993
3994     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);
3995
3996     return S_OK;
3997 }
3998
3999 /*** IMediaEvent methods ***/
4000 static HRESULT WINAPI MediaEvent_GetEventHandle(IMediaEventEx *iface,
4001                                                 OAEVENT *hEvent) {
4002     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
4003
4004     TRACE("(%p/%p)->(%p)\n", This, iface, hEvent);
4005
4006     *hEvent = (OAEVENT)This->evqueue.msg_event;
4007
4008     return S_OK;
4009 }
4010
4011 static HRESULT WINAPI MediaEvent_GetEvent(IMediaEventEx *iface,
4012                                           long *lEventCode,
4013                                           LONG_PTR *lParam1,
4014                                           LONG_PTR *lParam2,
4015                                           long msTimeout) {
4016     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
4017     Event evt;
4018
4019     TRACE("(%p/%p)->(%p, %p, %p, %ld)\n", This, iface, lEventCode, lParam1, lParam2, msTimeout);
4020
4021     if (EventsQueue_GetEvent(&This->evqueue, &evt, msTimeout))
4022     {
4023         *lEventCode = evt.lEventCode;
4024         *lParam1 = evt.lParam1;
4025         *lParam2 = evt.lParam2;
4026         return S_OK;
4027     }
4028
4029     *lEventCode = 0;
4030     return E_ABORT;
4031 }
4032
4033 static HRESULT WINAPI MediaEvent_WaitForCompletion(IMediaEventEx *iface,
4034                                                    long msTimeout,
4035                                                    long *pEvCode) {
4036     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
4037
4038     TRACE("(%p/%p)->(%ld, %p)\n", This, iface, msTimeout, pEvCode);
4039
4040     if (WaitForSingleObject(This->hEventCompletion, msTimeout) == WAIT_OBJECT_0)
4041     {
4042         *pEvCode = This->CompletionStatus;
4043         return S_OK;
4044     }
4045
4046     *pEvCode = 0;
4047     return E_ABORT;
4048 }
4049
4050 static HRESULT WINAPI MediaEvent_CancelDefaultHandling(IMediaEventEx *iface,
4051                                                        long lEvCode) {
4052     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
4053
4054     TRACE("(%p/%p)->(%ld)\n", This, iface, lEvCode);
4055
4056     if (lEvCode == EC_COMPLETE)
4057         This->HandleEcComplete = FALSE;
4058     else if (lEvCode == EC_REPAINT)
4059         This->HandleEcRepaint = FALSE;
4060     else
4061         return S_FALSE;
4062
4063     return S_OK;
4064 }
4065
4066 static HRESULT WINAPI MediaEvent_RestoreDefaultHandling(IMediaEventEx *iface,
4067                                                         long lEvCode) {
4068     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
4069
4070     TRACE("(%p/%p)->(%ld)\n", This, iface, lEvCode);
4071
4072     if (lEvCode == EC_COMPLETE)
4073         This->HandleEcComplete = TRUE;
4074     else if (lEvCode == EC_REPAINT)
4075         This->HandleEcRepaint = TRUE;
4076     else
4077         return S_FALSE;
4078
4079     return S_OK;
4080 }
4081
4082 static HRESULT WINAPI MediaEvent_FreeEventParams(IMediaEventEx *iface,
4083                                                  long lEvCode,
4084                                                  LONG_PTR lParam1,
4085                                                  LONG_PTR lParam2) {
4086     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
4087
4088     TRACE("(%p/%p)->(%ld, %08lx, %08lx): stub !!!\n", This, iface, lEvCode, lParam1, lParam2);
4089
4090     return S_OK;
4091 }
4092
4093 /*** IMediaEventEx methods ***/
4094 static HRESULT WINAPI MediaEvent_SetNotifyWindow(IMediaEventEx *iface,
4095                                                  OAHWND hwnd,
4096                                                  long lMsg,
4097                                                  LONG_PTR lInstanceData) {
4098     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
4099
4100     TRACE("(%p/%p)->(%08x, %ld, %08lx)\n", This, iface, (DWORD) hwnd, lMsg, lInstanceData);
4101
4102     This->notif.hWnd = (HWND)hwnd;
4103     This->notif.msg = lMsg;
4104     This->notif.instance = (long) lInstanceData;
4105
4106     return S_OK;
4107 }
4108
4109 static HRESULT WINAPI MediaEvent_SetNotifyFlags(IMediaEventEx *iface,
4110                                                 long lNoNotifyFlags) {
4111     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
4112
4113     TRACE("(%p/%p)->(%ld)\n", This, iface, lNoNotifyFlags);
4114
4115     if ((lNoNotifyFlags != 0) && (lNoNotifyFlags != 1))
4116         return E_INVALIDARG;
4117
4118     This->notif.disabled = lNoNotifyFlags;
4119
4120     return S_OK;
4121 }
4122
4123 static HRESULT WINAPI MediaEvent_GetNotifyFlags(IMediaEventEx *iface,
4124                                                 long *lplNoNotifyFlags) {
4125     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
4126
4127     TRACE("(%p/%p)->(%p)\n", This, iface, lplNoNotifyFlags);
4128
4129     if (!lplNoNotifyFlags)
4130         return E_POINTER;
4131
4132     *lplNoNotifyFlags = This->notif.disabled;
4133
4134     return S_OK;
4135 }
4136
4137
4138 static const IMediaEventExVtbl IMediaEventEx_VTable =
4139 {
4140     MediaEvent_QueryInterface,
4141     MediaEvent_AddRef,
4142     MediaEvent_Release,
4143     MediaEvent_GetTypeInfoCount,
4144     MediaEvent_GetTypeInfo,
4145     MediaEvent_GetIDsOfNames,
4146     MediaEvent_Invoke,
4147     MediaEvent_GetEventHandle,
4148     MediaEvent_GetEvent,
4149     MediaEvent_WaitForCompletion,
4150     MediaEvent_CancelDefaultHandling,
4151     MediaEvent_RestoreDefaultHandling,
4152     MediaEvent_FreeEventParams,
4153     MediaEvent_SetNotifyWindow,
4154     MediaEvent_SetNotifyFlags,
4155     MediaEvent_GetNotifyFlags
4156 };
4157
4158
4159 static HRESULT WINAPI MediaFilter_QueryInterface(IMediaFilter *iface, REFIID riid, LPVOID *ppv)
4160 {
4161     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
4162
4163     return Filtergraph_QueryInterface(This, riid, ppv);
4164 }
4165
4166 static ULONG WINAPI MediaFilter_AddRef(IMediaFilter *iface)
4167 {
4168     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
4169
4170     return Filtergraph_AddRef(This);
4171 }
4172
4173 static ULONG WINAPI MediaFilter_Release(IMediaFilter *iface)
4174 {
4175     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
4176
4177     return Filtergraph_Release(This);
4178 }
4179
4180 static HRESULT WINAPI MediaFilter_GetClassID(IMediaFilter *iface, CLSID * pClassID)
4181 {
4182     FIXME("(%p): stub\n", pClassID);
4183
4184     return E_NOTIMPL;
4185 }
4186
4187 static HRESULT WINAPI MediaFilter_Stop(IMediaFilter *iface)
4188 {
4189     FIXME("(): stub\n");
4190
4191     return E_NOTIMPL;
4192 }
4193
4194 static HRESULT WINAPI MediaFilter_Pause(IMediaFilter *iface)
4195 {
4196     FIXME("(): stub\n");
4197
4198     return E_NOTIMPL;
4199 }
4200
4201 static HRESULT WINAPI MediaFilter_Run(IMediaFilter *iface, REFERENCE_TIME tStart)
4202 {
4203     FIXME("(0x%s): stub\n", wine_dbgstr_longlong(tStart));
4204
4205     return E_NOTIMPL;
4206 }
4207
4208 static HRESULT WINAPI MediaFilter_GetState(IMediaFilter *iface, DWORD dwMsTimeout, FILTER_STATE * pState)
4209 {
4210     FIXME("(%d, %p): stub\n", dwMsTimeout, pState);
4211
4212     return E_NOTIMPL;
4213 }
4214
4215 static HRESULT WINAPI MediaFilter_SetSyncSource(IMediaFilter *iface, IReferenceClock *pClock)
4216 {
4217     FIXME("(%p): stub\n", pClock);
4218
4219     return E_NOTIMPL;
4220 }
4221
4222 static HRESULT WINAPI MediaFilter_GetSyncSource(IMediaFilter *iface, IReferenceClock **ppClock)
4223 {
4224     FIXME("(%p): stub\n", ppClock);
4225
4226     return E_NOTIMPL;
4227 }
4228
4229 static const IMediaFilterVtbl IMediaFilter_VTable =
4230 {
4231     MediaFilter_QueryInterface,
4232     MediaFilter_AddRef,
4233     MediaFilter_Release,
4234     MediaFilter_GetClassID,
4235     MediaFilter_Stop,
4236     MediaFilter_Pause,
4237     MediaFilter_Run,
4238     MediaFilter_GetState,
4239     MediaFilter_SetSyncSource,
4240     MediaFilter_GetSyncSource
4241 };
4242
4243 static HRESULT WINAPI MediaEventSink_QueryInterface(IMediaEventSink *iface, REFIID riid, LPVOID *ppv)
4244 {
4245     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventSink_vtbl, iface);
4246
4247     return Filtergraph_QueryInterface(This, riid, ppv);
4248 }
4249
4250 static ULONG WINAPI MediaEventSink_AddRef(IMediaEventSink *iface)
4251 {
4252     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventSink_vtbl, iface);
4253
4254     return Filtergraph_AddRef(This);
4255 }
4256
4257 static ULONG WINAPI MediaEventSink_Release(IMediaEventSink *iface)
4258 {
4259     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventSink_vtbl, iface);
4260
4261     return Filtergraph_Release(This);
4262 }
4263
4264 static HRESULT WINAPI MediaEventSink_Notify(IMediaEventSink *iface, long EventCode, LONG_PTR EventParam1, LONG_PTR EventParam2)
4265 {
4266     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventSink_vtbl, iface);
4267     Event evt;
4268
4269     TRACE("(%p/%p)->(%ld, %ld, %ld)\n", This, iface, EventCode, EventParam1, EventParam2);
4270
4271     /* We need thread safety here, let's use the events queue's one */
4272     EnterCriticalSection(&This->evqueue.msg_crst);
4273
4274     if ((EventCode == EC_COMPLETE) && This->HandleEcComplete)
4275     {
4276         TRACE("Process EC_COMPLETE notification\n");
4277         if (++This->EcCompleteCount == This->nRenderers)
4278         {
4279             evt.lEventCode = EC_COMPLETE;
4280             evt.lParam1 = S_OK;
4281             evt.lParam2 = 0;
4282             TRACE("Send EC_COMPLETE to app\n");
4283             EventsQueue_PutEvent(&This->evqueue, &evt);
4284             if (!This->notif.disabled && This->notif.hWnd)
4285             {
4286                 TRACE("Send Window message\n");
4287                 PostMessageW(This->notif.hWnd, This->notif.msg, 0, This->notif.instance);
4288             }
4289             This->CompletionStatus = EC_COMPLETE;
4290             SetEvent(This->hEventCompletion);
4291         }
4292     }
4293     else if ((EventCode == EC_REPAINT) && This->HandleEcRepaint)
4294     {
4295         /* FIXME: Not handled yet */
4296     }
4297     else
4298     {
4299         evt.lEventCode = EventCode;
4300         evt.lParam1 = EventParam1;
4301         evt.lParam2 = EventParam2;
4302         EventsQueue_PutEvent(&This->evqueue, &evt);
4303         if (!This->notif.disabled && This->notif.hWnd)
4304             PostMessageW(This->notif.hWnd, This->notif.msg, 0, This->notif.instance);
4305     }
4306
4307     LeaveCriticalSection(&This->evqueue.msg_crst);
4308     return S_OK;
4309 }
4310
4311 static const IMediaEventSinkVtbl IMediaEventSink_VTable =
4312 {
4313     MediaEventSink_QueryInterface,
4314     MediaEventSink_AddRef,
4315     MediaEventSink_Release,
4316     MediaEventSink_Notify
4317 };
4318
4319 static HRESULT WINAPI GraphConfig_QueryInterface(IGraphConfig *iface, REFIID riid, LPVOID *ppv)
4320 {
4321     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphConfig_vtbl, iface);
4322
4323     return Filtergraph_QueryInterface(This, riid, ppv);
4324 }
4325
4326 static ULONG WINAPI GraphConfig_AddRef(IGraphConfig *iface)
4327 {
4328     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventSink_vtbl, iface);
4329
4330     return Filtergraph_AddRef(This);
4331 }
4332
4333 static ULONG WINAPI GraphConfig_Release(IGraphConfig *iface)
4334 {
4335     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphConfig_vtbl, iface);
4336
4337     return Filtergraph_Release(This);
4338 }
4339
4340 static HRESULT WINAPI GraphConfig_Reconnect(IGraphConfig *iface,
4341                                             IPin* pOutputPin,
4342                                             IPin* pInputPin,
4343                                             const AM_MEDIA_TYPE* pmtFirstConnection,
4344                                             IBaseFilter* pUsingFilter,
4345                                             HANDLE hAbortEvent,
4346                                             DWORD dwFlags)
4347 {
4348     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphConfig_vtbl, iface);
4349
4350     FIXME("(%p)->(%p, %p, %p, %p, %p, %x): stub!\n", This, pOutputPin, pInputPin, pmtFirstConnection, pUsingFilter, hAbortEvent, dwFlags);
4351
4352     return E_NOTIMPL;
4353 }
4354
4355 static HRESULT WINAPI GraphConfig_Reconfigure(IGraphConfig *iface,
4356                                               IGraphConfigCallback* pCallback,
4357                                               PVOID pvContext,
4358                                               DWORD dwFlags,
4359                                               HANDLE hAbortEvent)
4360 {
4361     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphConfig_vtbl, iface);
4362
4363     FIXME("(%p)->(%p, %p, %x, %p): stub!\n", This, pCallback, pvContext, dwFlags, hAbortEvent);
4364
4365     return E_NOTIMPL;
4366 }
4367
4368 static HRESULT WINAPI GraphConfig_AddFilterToCache(IGraphConfig *iface,
4369                                                    IBaseFilter* pFilter)
4370 {
4371     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphConfig_vtbl, iface);
4372
4373     FIXME("(%p)->(%p): stub!\n", This, pFilter);
4374
4375     return E_NOTIMPL;
4376 }
4377
4378 static HRESULT WINAPI GraphConfig_EnumCacheFilter(IGraphConfig *iface,
4379                                                   IEnumFilters** pEnum)
4380 {
4381     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphConfig_vtbl, iface);
4382
4383     FIXME("(%p)->(%p): stub!\n", This, pEnum);
4384
4385     return E_NOTIMPL;
4386 }
4387
4388 static HRESULT WINAPI GraphConfig_RemoveFilterFromCache(IGraphConfig *iface,
4389                                                         IBaseFilter* pFilter)
4390 {
4391     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphConfig_vtbl, iface);
4392
4393     FIXME("(%p)->(%p): stub!\n", This, pFilter);
4394
4395     return E_NOTIMPL;
4396 }
4397
4398 static HRESULT WINAPI GraphConfig_GetStartTime(IGraphConfig *iface,
4399                                                REFERENCE_TIME* prtStart)
4400 {
4401     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphConfig_vtbl, iface);
4402
4403     FIXME("(%p)->(%p): stub!\n", This, prtStart);
4404
4405     return E_NOTIMPL;
4406 }
4407
4408 static HRESULT WINAPI GraphConfig_PushThroughData(IGraphConfig *iface,
4409                                                   IPin* pOutputPin,
4410                                                   IPinConnection* pConnection,
4411                                                   HANDLE hEventAbort)
4412 {
4413     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphConfig_vtbl, iface);
4414
4415     FIXME("(%p)->(%p, %p, %p): stub!\n", This, pOutputPin, pConnection, hEventAbort);
4416
4417     return E_NOTIMPL;
4418 }
4419
4420 static HRESULT WINAPI GraphConfig_SetFilterFlags(IGraphConfig *iface,
4421                                                  IBaseFilter* pFilter,
4422                                                  DWORD dwFlags)
4423 {
4424     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphConfig_vtbl, iface);
4425
4426     FIXME("(%p)->(%p, %x): stub!\n", This, pFilter, dwFlags);
4427
4428     return E_NOTIMPL;
4429 }
4430
4431 static HRESULT WINAPI GraphConfig_GetFilterFlags(IGraphConfig *iface,
4432                                                  IBaseFilter* pFilter,
4433                                                  DWORD* dwFlags)
4434 {
4435     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphConfig_vtbl, iface);
4436
4437     FIXME("(%p)->(%p, %p): stub!\n", This, pFilter, dwFlags);
4438
4439     return E_NOTIMPL;
4440 }
4441
4442 static HRESULT WINAPI GraphConfig_RemoveFilterEx(IGraphConfig *iface,
4443                                                  IBaseFilter* pFilter,
4444                                                  DWORD dwFlags)
4445 {
4446     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphConfig_vtbl, iface);
4447
4448     FIXME("(%p)->(%p, %x): stub!\n", This, pFilter, dwFlags);
4449
4450     return E_NOTIMPL;
4451 }
4452
4453 static const IGraphConfigVtbl IGraphConfig_VTable =
4454 {
4455     GraphConfig_QueryInterface,
4456     GraphConfig_AddRef,
4457     GraphConfig_Release,
4458     GraphConfig_Reconnect,
4459     GraphConfig_Reconfigure,
4460     GraphConfig_AddFilterToCache,
4461     GraphConfig_EnumCacheFilter,
4462     GraphConfig_RemoveFilterFromCache,
4463     GraphConfig_GetStartTime,
4464     GraphConfig_PushThroughData,
4465     GraphConfig_SetFilterFlags,
4466     GraphConfig_GetFilterFlags,
4467     GraphConfig_RemoveFilterEx
4468 };
4469
4470 /* This is the only function that actually creates a FilterGraph class... */
4471 HRESULT FilterGraph_create(IUnknown *pUnkOuter, LPVOID *ppObj)
4472 {
4473     IFilterGraphImpl *fimpl;
4474     HRESULT hr;
4475
4476     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
4477
4478     if( pUnkOuter )
4479         return CLASS_E_NOAGGREGATION;
4480
4481     fimpl = HeapAlloc(GetProcessHeap(), 0, sizeof(*fimpl));
4482     fimpl->IGraphBuilder_vtbl = &IGraphBuilder_VTable;
4483     fimpl->IMediaControl_vtbl = &IMediaControl_VTable;
4484     fimpl->IMediaSeeking_vtbl = &IMediaSeeking_VTable;
4485     fimpl->IBasicAudio_vtbl = &IBasicAudio_VTable;
4486     fimpl->IBasicVideo_vtbl = &IBasicVideo_VTable;
4487     fimpl->IVideoWindow_vtbl = &IVideoWindow_VTable;
4488     fimpl->IMediaEventEx_vtbl = &IMediaEventEx_VTable;
4489     fimpl->IMediaFilter_vtbl = &IMediaFilter_VTable;
4490     fimpl->IMediaEventSink_vtbl = &IMediaEventSink_VTable;
4491     fimpl->IGraphConfig_vtbl = &IGraphConfig_VTable;
4492     fimpl->IMediaPosition_vtbl = &IMediaPosition_VTable;
4493     fimpl->ref = 1;
4494     fimpl->ppFiltersInGraph = NULL;
4495     fimpl->pFilterNames = NULL;
4496     fimpl->nFilters = 0;
4497     fimpl->filterCapacity = 0;
4498     fimpl->nameIndex = 1;
4499     fimpl->hEventCompletion = CreateEventW(0, TRUE, FALSE, 0);
4500     fimpl->HandleEcComplete = TRUE;
4501     fimpl->HandleEcRepaint = TRUE;
4502     fimpl->notif.hWnd = 0;
4503     fimpl->notif.disabled = FALSE;
4504     fimpl->nRenderers = 0;
4505     fimpl->EcCompleteCount = 0;
4506     fimpl->state = State_Stopped;
4507     EventsQueue_Init(&fimpl->evqueue);
4508     InitializeCriticalSection(&fimpl->cs);
4509     fimpl->nItfCacheEntries = 0;
4510
4511     hr = CoCreateInstance(&CLSID_FilterMapper, NULL, CLSCTX_INPROC_SERVER, &IID_IFilterMapper2, (LPVOID*)&fimpl->pFilterMapper2);
4512     if (FAILED(hr)) {
4513         ERR("Unable to create filter mapper (%x)\n", hr);
4514         return hr;
4515     }
4516
4517     *ppObj = fimpl;
4518     return S_OK;
4519 }
4520
4521 HRESULT FilterGraphNoThread_create(IUnknown *pUnkOuter, LPVOID *ppObj)
4522 {
4523     FIXME("CLSID_FilterGraphNoThread partially implemented - Forwarding to CLSID_FilterGraph\n");
4524     return FilterGraph_create(pUnkOuter, ppObj);
4525 }