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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 "strmif.h"
  35 #include "vfwmsgs.h"
  36 #include "evcode.h"
  37 #include "wine/unicode.h"
  38
  39 #include "quartz_private.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  42
  43 typedef struct {
  44     HWND hWnd;      /* Target window */
  45     long msg;       /* User window message */
  46     long instance;  /* User data */
  47     int  disabled;  /* Disabled messages posting */
  48 } WndNotify;
  49
  50 typedef struct {
  51     long lEventCode;   /* Event code */
  52     LONG_PTR lParam1;  /* Param1 */
  53     LONG_PTR lParam2;  /* Param2 */
  54 } Event;
  55
  56 /* messages ring implementation for queuing events (taken from winmm) */
  57 #define EVENTS_RING_BUFFER_INCREMENT      64
  58 typedef struct {
  59     Event* messages;
  60     int ring_buffer_size;
  61     int msg_tosave;
  62     int msg_toget;
  63     CRITICAL_SECTION msg_crst;
  64     HANDLE msg_event; /* Signaled for no empty queue */
  65 } EventsQueue;
  66
  67 static int EventsQueue_Init(EventsQueue* omr)
  68 {
  69     omr->msg_toget = 0;
  70     omr->msg_tosave = 0;
  71     omr->msg_event = CreateEventW(NULL, TRUE, FALSE, NULL);
  72     omr->ring_buffer_size = EVENTS_RING_BUFFER_INCREMENT;
  73     omr->messages = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,omr->ring_buffer_size * sizeof(Event));
  74
  75     InitializeCriticalSection(&omr->msg_crst);
  76     return TRUE;
  77 }
  78
  79 static int EventsQueue_Destroy(EventsQueue* omr)
  80 {
  81     CloseHandle(omr->msg_event);
  82     HeapFree(GetProcessHeap(),0,omr->messages);
  83     DeleteCriticalSection(&omr->msg_crst);
  84     return TRUE;
  85 }
  86
  87 static int EventsQueue_PutEvent(EventsQueue* omr, Event* evt)
  88 {
  89     EnterCriticalSection(&omr->msg_crst);
  90     if ((omr->msg_toget == ((omr->msg_tosave + 1) % omr->ring_buffer_size)))
  91     {
  92         int old_ring_buffer_size = omr->ring_buffer_size;
  93         omr->ring_buffer_size += EVENTS_RING_BUFFER_INCREMENT;
  94         TRACE("omr->ring_buffer_size=%d\n",omr->ring_buffer_size);
  95         omr->messages = HeapReAlloc(GetProcessHeap(),0,omr->messages, omr->ring_buffer_size * sizeof(Event));
  96         /* Now we need to rearrange the ring buffer so that the new
  97            buffers just allocated are in between omr->msg_tosave and
  98            omr->msg_toget.
  99         */
 100         if (omr->msg_tosave < omr->msg_toget)
 101         {
 102             memmove(&(omr->messages[omr->msg_toget + EVENTS_RING_BUFFER_INCREMENT]),
 103                     &(omr->messages[omr->msg_toget]),
 104                     sizeof(Event)*(old_ring_buffer_size - omr->msg_toget)
 105                     );
 106             omr->msg_toget += EVENTS_RING_BUFFER_INCREMENT;
 107         }
 108     }
 109     omr->messages[omr->msg_tosave] = *evt;
 110     SetEvent(omr->msg_event);
 111     omr->msg_tosave = (omr->msg_tosave + 1) % omr->ring_buffer_size;
 112     LeaveCriticalSection(&omr->msg_crst);
 113     return TRUE;
 114 }
 115
 116 static int EventsQueue_GetEvent(EventsQueue* omr, Event* evt, long msTimeOut)
 117 {
 118     if (WaitForSingleObject(omr->msg_event, msTimeOut) != WAIT_OBJECT_0)
 119         return FALSE;
 120
 121     EnterCriticalSection(&omr->msg_crst);
 122
 123     if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
 124     {
 125         LeaveCriticalSection(&omr->msg_crst);
 126         return FALSE;
 127     }
 128
 129     *evt = omr->messages[omr->msg_toget];
 130     omr->msg_toget = (omr->msg_toget + 1) % omr->ring_buffer_size;
 131
 132     /* Mark the buffer as empty if needed */
 133     if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
 134         ResetEvent(omr->msg_event);
 135
 136     LeaveCriticalSection(&omr->msg_crst);
 137     return TRUE;
 138 }
 139
 140 typedef struct _IFilterGraphImpl {
 141     IGraphBuilderVtbl *IGraphBuilder_vtbl;
 142     IMediaControlVtbl *IMediaControl_vtbl;
 143     IMediaSeekingVtbl *IMediaSeeking_vtbl;
 144     IBasicAudioVtbl *IBasicAudio_vtbl;
 145     IBasicVideoVtbl *IBasicVideo_vtbl;
 146     IVideoWindowVtbl *IVideoWindow_vtbl;
 147     IMediaEventExVtbl *IMediaEventEx_vtbl;
 148     IMediaFilterVtbl *IMediaFilter_vtbl;
 149     IMediaEventSinkVtbl *IMediaEventSink_vtbl;
 150     /* IAMGraphStreams */
 151     /* IAMStats */
 152     /* IBasicVideo2 */
 153     /* IFilterChain */
 154     /* IFilterGraph2 */
 155     /* IFilterMapper2 */
 156     /* IGraphConfig */
 157     /* IGraphVersion */
 158     /* IMediaPosition */
 159     /* IQueueCommand */
 160     /* IRegisterServiceProvider */
 161     /* IResourceMananger */
 162     /* IServiceProvider */
 163     /* IVideoFrameStep */
 164
 165     ULONG ref;
 166     IBaseFilter ** ppFiltersInGraph;
 167     LPWSTR * pFilterNames;
 168     int nFilters;
 169     int filterCapacity;
 170     long nameIndex;
 171     EventsQueue evqueue;
 172     HANDLE hEventCompletion;
 173     int CompletionStatus;
 174     WndNotify notif;
 175     int nRenderers;
 176     int EcCompleteCount;
 177     int HandleEcComplete;
 178     int HandleEcRepaint;
 179 } IFilterGraphImpl;
 180
 181
 182 static HRESULT Filtergraph_QueryInterface(IFilterGraphImpl *This,
 183                                           REFIID riid,
 184                                           LPVOID *ppvObj) {
 185     TRACE("(%p)->(%s (%p), %p)\n", This, debugstr_guid(riid), riid, ppvObj);
 186
 187     if (IsEqualGUID(&IID_IUnknown, riid) ||
 188         IsEqualGUID(&IID_IFilterGraph, riid) ||
 189         IsEqualGUID(&IID_IGraphBuilder, riid)) {
 190         *ppvObj = &(This->IGraphBuilder_vtbl);
 191         TRACE("   returning IGraphBuilder interface (%p)\n", *ppvObj);
 192     } else if (IsEqualGUID(&IID_IMediaControl, riid)) {
 193         *ppvObj = &(This->IMediaControl_vtbl);
 194         TRACE("   returning IMediaControl interface (%p)\n", *ppvObj);
 195     } else if (IsEqualGUID(&IID_IMediaSeeking, riid)) {
 196         *ppvObj = &(This->IMediaSeeking_vtbl);
 197         TRACE("   returning IMediaSeeking interface (%p)\n", *ppvObj);
 198     } else if (IsEqualGUID(&IID_IBasicAudio, riid)) {
 199         *ppvObj = &(This->IBasicAudio_vtbl);
 200         TRACE("   returning IBasicAudio interface (%p)\n", *ppvObj);
 201     } else if (IsEqualGUID(&IID_IBasicVideo, riid)) {
 202         *ppvObj = &(This->IBasicVideo_vtbl);
 203         TRACE("   returning IBasicVideo interface (%p)\n", *ppvObj);
 204     } else if (IsEqualGUID(&IID_IVideoWindow, riid)) {
 205         *ppvObj = &(This->IVideoWindow_vtbl);
 206         TRACE("   returning IVideoWindow interface (%p)\n", *ppvObj);
 207     } else if (IsEqualGUID(&IID_IMediaEvent, riid) ||
 208            IsEqualGUID(&IID_IMediaEventEx, riid)) {
 209         *ppvObj = &(This->IMediaEventEx_vtbl);
 210         TRACE("   returning IMediaEvent(Ex) interface (%p)\n", *ppvObj);
 211     } else if (IsEqualGUID(&IID_IMediaFilter, riid) ||
 212           IsEqualGUID(&IID_IPersist, riid)) {
 213         *ppvObj = &(This->IMediaFilter_vtbl);
 214         TRACE("   returning IMediaFilter interface (%p)\n", *ppvObj);
 215     } else if (IsEqualGUID(&IID_IMediaEventSink, riid)) {
 216         *ppvObj = &(This->IMediaEventSink_vtbl);
 217         TRACE("   returning IMediaEventSink interface (%p)\n", *ppvObj);
 218     } else {
 219         *ppvObj = NULL;
 220         FIXME("unknown interface %s\n", debugstr_guid(riid));
 221         return E_NOINTERFACE;
 222     }
 223
 224     This->ref++;
 225     return S_OK;
 226 }
 227
 228 static ULONG Filtergraph_AddRef(IFilterGraphImpl *This) {
 229     TRACE("(%p)->(): new ref = %ld\n", This, This->ref + 1);
 230
 231     return ++This->ref;
 232 }
 233
 234 static ULONG Filtergraph_Release(IFilterGraphImpl *This) {
 235     static ULONG ref;
 236
 237     TRACE("(%p)->(): new ref = %ld\n", This, This->ref - 1);
 238
 239     ref = --This->ref;
 240     if (ref == 0) {
 241         CloseHandle(This->hEventCompletion);
 242         EventsQueue_Destroy(&This->evqueue);
 243         HeapFree(GetProcessHeap(), 0, This->ppFiltersInGraph);
 244         HeapFree(GetProcessHeap(), 0, This->pFilterNames);
 245         HeapFree(GetProcessHeap(), 0, This);
 246     }
 247     return ref;
 248 }
 249
 250
 251 /*** IUnknown methods ***/
 252 static HRESULT WINAPI Graphbuilder_QueryInterface(IGraphBuilder *iface,
 253                                                   REFIID riid,
 254                                                   LPVOID*ppvObj) {
 255     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 256
 257     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
 258     return Filtergraph_QueryInterface(This, riid, ppvObj);
 259 }
 260
 261 static ULONG WINAPI Graphbuilder_AddRef(IGraphBuilder *iface) {
 262     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 263
 264     TRACE("(%p/%p)->() calling FilterGraph AddRef\n", This, iface);
 265
 266     return Filtergraph_AddRef(This);
 267 }
 268
 269 static ULONG WINAPI Graphbuilder_Release(IGraphBuilder *iface) {
 270     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 271
 272     TRACE("(%p/%p)->() calling FilterGraph Release\n", This, iface);
 273
 274     return Filtergraph_Release(This);
 275 }
 276
 277 /*** IFilterGraph methods ***/
 278 static HRESULT WINAPI Graphbuilder_AddFilter(IGraphBuilder *iface,
 279                                              IBaseFilter *pFilter,
 280                                              LPCWSTR pName) {
 281     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 282     HRESULT hr;
 283     int i,j;
 284     WCHAR* wszFilterName = NULL;
 285     int duplicate_name = FALSE;
 286
 287     TRACE("(%p/%p)->(%p, %s (%p))\n", This, iface, pFilter, debugstr_w(pName), pName);
 288
 289     wszFilterName = (WCHAR*) CoTaskMemAlloc( (pName ? strlenW(pName) + 6 : 5) * sizeof(WCHAR) );
 290
 291     if (pName)
 292     {
 293         /* Check if name already exists */
 294         for(i = 0; i < This->nFilters; i++)
 295             if (!strcmpW(This->pFilterNames[i], pName))
 296             {
 297                 duplicate_name = TRUE;
 298                 break;
 299             }
 300     }
 301
 302     /* If no name given or name already existing, generate one */
 303     if (!pName || duplicate_name)
 304     {
 305         static const WCHAR wszFmt1[] = {'%','s',' ','%','0','4','d',0};
 306         static const WCHAR wszFmt2[] = {'%','0','4','d',0};
 307
 308         for (j = 0; j < 10000 ; j++)
 309         {
 310             /* Create name */
 311             if (pName)
 312                 sprintfW(wszFilterName, wszFmt1, pName, This->nameIndex);
 313             else
 314                 sprintfW(wszFilterName, wszFmt2, This->nameIndex);
 315             TRACE("Generated name %s\n", debugstr_w(wszFilterName));
 316
 317             /* Check if the generated name already exists */
 318             for(i = 0; i < This->nFilters; i++)
 319                 if (!strcmpW(This->pFilterNames[i], pName))
 320                     break;
 321
 322             /* Compute next index and exit if generated name is suitable */
 323             if (This->nameIndex++ == 10000)
 324                 This->nameIndex = 1;
 325             if (i == This->nFilters)
 326                 break;
 327         }
 328         /* Unable to find a suitable name */
 329         if (j == 10000)
 330         {
 331             CoTaskMemFree(wszFilterName);
 332             return VFW_E_DUPLICATE_NAME;
 333         }
 334     }
 335     else
 336         memcpy(wszFilterName, pName, (strlenW(pName) + 1) * sizeof(WCHAR));
 337
 338
 339     if (This->nFilters + 1 > This->filterCapacity)
 340     {
 341         int newCapacity = 2*This->filterCapacity;
 342         IBaseFilter ** ppNewFilters = CoTaskMemAlloc(newCapacity * sizeof(IBaseFilter*));
 343         LPWSTR * pNewNames = CoTaskMemAlloc(newCapacity * sizeof(LPWSTR));
 344         memcpy(ppNewFilters, This->ppFiltersInGraph, This->nFilters * sizeof(IBaseFilter*));
 345         memcpy(pNewNames, This->pFilterNames, This->nFilters * sizeof(LPWSTR));
 346         CoTaskMemFree(This->ppFiltersInGraph);
 347         CoTaskMemFree(This->pFilterNames);
 348         This->ppFiltersInGraph = ppNewFilters;
 349         This->pFilterNames = pNewNames;
 350         This->filterCapacity = newCapacity;
 351     }
 352
 353     hr = IBaseFilter_JoinFilterGraph(pFilter, (IFilterGraph *)This, wszFilterName);
 354
 355     if (SUCCEEDED(hr))
 356     {
 357         IBaseFilter_AddRef(pFilter);
 358         This->ppFiltersInGraph[This->nFilters] = pFilter;
 359         This->pFilterNames[This->nFilters] = wszFilterName;
 360         This->nFilters++;
 361     }
 362     else
 363         CoTaskMemFree(wszFilterName);
 364
 365     if (SUCCEEDED(hr) && duplicate_name)
 366         return VFW_S_DUPLICATE_NAME;
 367
 368     return hr;
 369 }
 370
 371 static HRESULT WINAPI Graphbuilder_RemoveFilter(IGraphBuilder *iface,
 372                                                 IBaseFilter *pFilter) {
 373     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 374     int i;
 375     HRESULT hr = E_FAIL;
 376
 377     TRACE("(%p/%p)->(%p)\n", This, iface, pFilter);
 378
 379     /* FIXME: check graph is stopped */
 380
 381     for (i = 0; i < This->nFilters; i++)
 382     {
 383         if (This->ppFiltersInGraph[i] == pFilter)
 384         {
 385             /* FIXME: disconnect pins */
 386             hr = IBaseFilter_JoinFilterGraph(pFilter, NULL, This->pFilterNames[i]);
 387             if (SUCCEEDED(hr))
 388             {
 389                 IPin_Release(pFilter);
 390                 CoTaskMemFree(This->pFilterNames[i]);
 391                 memmove(This->ppFiltersInGraph+i, This->ppFiltersInGraph+i+1, sizeof(IBaseFilter*)*(This->nFilters - 1 - i));
 392                 memmove(This->pFilterNames+i, This->pFilterNames+i+1, sizeof(LPWSTR)*(This->nFilters - 1 - i));
 393                 This->nFilters--;
 394                 return S_OK;
 395             }
 396             break;
 397         }
 398     }
 399
 400     return hr; /* FIXME: check this error code */
 401 }
 402
 403 static HRESULT WINAPI Graphbuilder_EnumFilters(IGraphBuilder *iface,
 404                                               IEnumFilters **ppEnum) {
 405     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 406
 407     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 408
 409     return IEnumFiltersImpl_Construct(This->ppFiltersInGraph, This->nFilters, ppEnum);
 410 }
 411
 412 static HRESULT WINAPI Graphbuilder_FindFilterByName(IGraphBuilder *iface,
 413                                                     LPCWSTR pName,
 414                                                     IBaseFilter **ppFilter) {
 415     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 416     int i;
 417
 418     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_w(pName), pName, ppFilter);
 419
 420     *ppFilter = NULL;
 421
 422     for (i = 0; i < This->nFilters; i++)
 423     {
 424         if (!strcmpW(pName, This->pFilterNames[i]))
 425         {
 426             *ppFilter = This->ppFiltersInGraph[i];
 427             IBaseFilter_AddRef(*ppFilter);
 428             return S_OK;
 429         }
 430     }
 431
 432     return E_FAIL; /* FIXME: check this error code */
 433 }
 434
 435 /* NOTE: despite the implication, it doesn't matter which
 436  * way round you put in the input and output pins */
 437 static HRESULT WINAPI Graphbuilder_ConnectDirect(IGraphBuilder *iface,
 438                                                  IPin *ppinIn,
 439                                                  IPin *ppinOut,
 440                                                  const AM_MEDIA_TYPE *pmt) {
 441     PIN_DIRECTION dir;
 442     HRESULT hr;
 443
 444     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 445
 446     TRACE("(%p/%p)->(%p, %p, %p)\n", This, iface, ppinIn, ppinOut, pmt);
 447
 448     /* FIXME: check pins are in graph */
 449
 450     hr = IPin_QueryDirection(ppinIn, &dir);
 451     if (SUCCEEDED(hr))
 452     {
 453         if (dir == PINDIR_INPUT)
 454             hr = IPin_Connect(ppinOut, ppinIn, pmt);
 455         else
 456             hr = IPin_Connect(ppinIn, ppinOut, pmt);
 457     }
 458
 459     return hr;
 460 }
 461
 462 static HRESULT WINAPI Graphbuilder_Reconnect(IGraphBuilder *iface,
 463                                              IPin *ppin) {
 464     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 465
 466     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppin);
 467
 468     return S_OK;
 469 }
 470
 471 static HRESULT WINAPI Graphbuilder_Disconnect(IGraphBuilder *iface,
 472                                               IPin *ppin) {
 473     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 474
 475     TRACE("(%p/%p)->(%p)\n", This, iface, ppin);
 476
 477     return IPin_Disconnect(ppin);
 478 }
 479
 480 static HRESULT WINAPI Graphbuilder_SetDefaultSyncSource(IGraphBuilder *iface) {
 481     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 482
 483     TRACE("(%p/%p)->(): stub !!!\n", iface, This);
 484
 485     return S_OK;
 486 }
 487
 488 /*** IGraphBuilder methods ***/
 489 static HRESULT WINAPI Graphbuilder_Connect(IGraphBuilder *iface,
 490                                            IPin *ppinOut,
 491                                            IPin *ppinIn) {
 492     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 493
 494     TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, ppinOut, ppinIn);
 495
 496     return S_OK;
 497 }
 498
 499 static HRESULT WINAPI Graphbuilder_Render(IGraphBuilder *iface,
 500                                           IPin *ppinOut) {
 501     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 502
 503     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppinOut);
 504
 505     return S_OK;
 506 }
 507
 508 static HRESULT WINAPI Graphbuilder_RenderFile(IGraphBuilder *iface,
 509                                               LPCWSTR lpcwstrFile,
 510                                               LPCWSTR lpcwstrPlayList) {
 511     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 512
 513     TRACE("(%p/%p)->(%s (%p), %s (%p)): stub !!!\n", This, iface, debugstr_w(lpcwstrFile), lpcwstrFile, debugstr_w(lpcwstrPlayList), lpcwstrPlayList);
 514
 515     return S_OK;
 516 }
 517
 518 static HRESULT WINAPI Graphbuilder_AddSourceFilter(IGraphBuilder *iface,
 519                                                    LPCWSTR lpcwstrFileName,
 520                                                    LPCWSTR lpcwstrFilterName,
 521                                                    IBaseFilter **ppFilter) {
 522     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 523
 524     TRACE("(%p/%p)->(%s (%p), %s (%p), %p): stub !!!\n", This, iface, debugstr_w(lpcwstrFileName), lpcwstrFileName, debugstr_w(lpcwstrFilterName), lpcwstrFilterName, ppFilter);
 525
 526     return S_OK;
 527 }
 528
 529 static HRESULT WINAPI Graphbuilder_SetLogFile(IGraphBuilder *iface,
 530                                               DWORD_PTR hFile) {
 531     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 532
 533     TRACE("(%p/%p)->(%08lx): stub !!!\n", This, iface, (DWORD) hFile);
 534
 535     return S_OK;
 536 }
 537
 538 static HRESULT WINAPI Graphbuilder_Abort(IGraphBuilder *iface) {
 539     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 540
 541     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
 542
 543     return S_OK;
 544 }
 545
 546 static HRESULT WINAPI Graphbuilder_ShouldOperationContinue(IGraphBuilder *iface) {
 547     ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
 548
 549     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
 550
 551     return S_OK;
 552 }
 553
 554
 555 static IGraphBuilderVtbl IGraphBuilder_VTable =
 556 {
 557     Graphbuilder_QueryInterface,
 558     Graphbuilder_AddRef,
 559     Graphbuilder_Release,
 560     Graphbuilder_AddFilter,
 561     Graphbuilder_RemoveFilter,
 562     Graphbuilder_EnumFilters,
 563     Graphbuilder_FindFilterByName,
 564     Graphbuilder_ConnectDirect,
 565     Graphbuilder_Reconnect,
 566     Graphbuilder_Disconnect,
 567     Graphbuilder_SetDefaultSyncSource,
 568     Graphbuilder_Connect,
 569     Graphbuilder_Render,
 570     Graphbuilder_RenderFile,
 571     Graphbuilder_AddSourceFilter,
 572     Graphbuilder_SetLogFile,
 573     Graphbuilder_Abort,
 574     Graphbuilder_ShouldOperationContinue
 575 };
 576
 577 /*** IUnknown methods ***/
 578 static HRESULT WINAPI Mediacontrol_QueryInterface(IMediaControl *iface,
 579                                                   REFIID riid,
 580                                                   LPVOID*ppvObj) {
 581     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 582
 583     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
 584
 585     return Filtergraph_QueryInterface(This, riid, ppvObj);
 586 }
 587
 588 static ULONG WINAPI Mediacontrol_AddRef(IMediaControl *iface) {
 589     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 590
 591     TRACE("(%p/%p)->()\n", This, iface);
 592
 593     return Filtergraph_AddRef(This);
 594 }
 595
 596 static ULONG WINAPI Mediacontrol_Release(IMediaControl *iface) {
 597     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 598
 599     TRACE("(%p/%p)->()\n", This, iface);
 600
 601     return Filtergraph_Release(This);
 602
 603 }
 604
 605 /*** IDispatch methods ***/
 606 static HRESULT WINAPI Mediacontrol_GetTypeInfoCount(IMediaControl *iface,
 607                                                     UINT*pctinfo) {
 608     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 609
 610     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
 611
 612     return S_OK;
 613 }
 614
 615 static HRESULT WINAPI Mediacontrol_GetTypeInfo(IMediaControl *iface,
 616                                                UINT iTInfo,
 617                                                LCID lcid,
 618                                                ITypeInfo**ppTInfo) {
 619     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 620
 621     TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
 622
 623     return S_OK;
 624 }
 625
 626 static HRESULT WINAPI Mediacontrol_GetIDsOfNames(IMediaControl *iface,
 627                                                  REFIID riid,
 628                                                  LPOLESTR*rgszNames,
 629                                                  UINT cNames,
 630                                                  LCID lcid,
 631                                                  DISPID*rgDispId) {
 632     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 633
 634     TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
 635
 636     return S_OK;
 637 }
 638
 639 static HRESULT WINAPI Mediacontrol_Invoke(IMediaControl *iface,
 640                                           DISPID dispIdMember,
 641                                           REFIID riid,
 642                                           LCID lcid,
 643                                           WORD wFlags,
 644                                           DISPPARAMS*pDispParams,
 645                                           VARIANT*pVarResult,
 646                                           EXCEPINFO*pExepInfo,
 647                                           UINT*puArgErr) {
 648     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 649
 650     TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
 651
 652     return S_OK;
 653 }
 654
 655 /*** IMediaControl methods ***/
 656 static HRESULT WINAPI Mediacontrol_Run(IMediaControl *iface) {
 657     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 658
 659     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
 660
 661     ResetEvent(This->hEventCompletion);
 662
 663     return S_OK;
 664 }
 665
 666 static HRESULT WINAPI Mediacontrol_Pause(IMediaControl *iface) {
 667     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 668
 669     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
 670
 671     return S_OK;
 672 }
 673
 674 static HRESULT WINAPI Mediacontrol_Stop(IMediaControl *iface) {
 675     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 676
 677     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
 678
 679     return S_OK;
 680 }
 681
 682 static HRESULT WINAPI Mediacontrol_GetState(IMediaControl *iface,
 683                                             LONG msTimeout,
 684                                             OAFilterState *pfs) {
 685     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 686
 687     TRACE("(%p/%p)->(%ld, %p): stub !!!\n", This, iface, msTimeout, pfs);
 688
 689     return S_OK;
 690 }
 691
 692 static HRESULT WINAPI Mediacontrol_RenderFile(IMediaControl *iface,
 693                                               BSTR strFilename) {
 694     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 695
 696     TRACE("(%p/%p)->(%s (%p)): stub !!!\n", This, iface, debugstr_w(strFilename), strFilename);
 697
 698     return S_OK;
 699 }
 700
 701 static HRESULT WINAPI Mediacontrol_AddSourceFilter(IMediaControl *iface,
 702                                                    BSTR strFilename,
 703                                                    IDispatch **ppUnk) {
 704     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 705
 706     TRACE("(%p/%p)->(%s (%p), %p): stub !!!\n", This, iface, debugstr_w(strFilename), strFilename, ppUnk);
 707
 708     return S_OK;
 709 }
 710
 711 static HRESULT WINAPI Mediacontrol_get_FilterCollection(IMediaControl *iface,
 712                                                         IDispatch **ppUnk) {
 713     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 714
 715     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk);
 716
 717     return S_OK;
 718 }
 719
 720 static HRESULT WINAPI Mediacontrol_get_RegFilterCollection(IMediaControl *iface,
 721                                                            IDispatch **ppUnk) {
 722     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 723
 724     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk);
 725
 726     return S_OK;
 727 }
 728
 729 static HRESULT WINAPI Mediacontrol_StopWhenReady(IMediaControl *iface) {
 730     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
 731
 732     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
 733
 734     return S_OK;
 735 }
 736
 737
 738 static IMediaControlVtbl IMediaControl_VTable =
 739 {
 740     Mediacontrol_QueryInterface,
 741     Mediacontrol_AddRef,
 742     Mediacontrol_Release,
 743     Mediacontrol_GetTypeInfoCount,
 744     Mediacontrol_GetTypeInfo,
 745     Mediacontrol_GetIDsOfNames,
 746     Mediacontrol_Invoke,
 747     Mediacontrol_Run,
 748     Mediacontrol_Pause,
 749     Mediacontrol_Stop,
 750     Mediacontrol_GetState,
 751     Mediacontrol_RenderFile,
 752     Mediacontrol_AddSourceFilter,
 753     Mediacontrol_get_FilterCollection,
 754     Mediacontrol_get_RegFilterCollection,
 755     Mediacontrol_StopWhenReady
 756 };
 757
 758
 759 /*** IUnknown methods ***/
 760 static HRESULT WINAPI Mediaseeking_QueryInterface(IMediaSeeking *iface,
 761                                                   REFIID riid,
 762                                                   LPVOID*ppvObj) {
 763     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 764
 765     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
 766
 767     return Filtergraph_QueryInterface(This, riid, ppvObj);
 768 }
 769
 770 static ULONG WINAPI Mediaseeking_AddRef(IMediaSeeking *iface) {
 771     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 772
 773     TRACE("(%p/%p)->()\n", This, iface);
 774
 775     return Filtergraph_AddRef(This);
 776 }
 777
 778 static ULONG WINAPI Mediaseeking_Release(IMediaSeeking *iface) {
 779     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 780
 781     TRACE("(%p/%p)->()\n", This, iface);
 782
 783     return Filtergraph_Release(This);
 784 }
 785
 786 /*** IMediaSeeking methods ***/
 787 static HRESULT WINAPI Mediaseeking_GetCapabilities(IMediaSeeking *iface,
 788                                                    DWORD *pCapabilities) {
 789     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 790
 791     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pCapabilities);
 792
 793     return S_OK;
 794 }
 795
 796 static HRESULT WINAPI Mediaseeking_CheckCapabilities(IMediaSeeking *iface,
 797                                                      DWORD *pCapabilities) {
 798     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 799
 800     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pCapabilities);
 801
 802     return S_OK;
 803 }
 804
 805 static HRESULT WINAPI Mediaseeking_IsFormatSupported(IMediaSeeking *iface,
 806                                                      const GUID *pFormat) {
 807     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 808
 809     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
 810
 811     return S_OK;
 812 }
 813
 814 static HRESULT WINAPI Mediaseeking_QueryPreferredFormat(IMediaSeeking *iface,
 815                                                         GUID *pFormat) {
 816     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 817
 818     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
 819
 820     return S_OK;
 821 }
 822
 823 static HRESULT WINAPI Mediaseeking_GetTimeFormat(IMediaSeeking *iface,
 824                                                  GUID *pFormat) {
 825     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 826
 827     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
 828
 829     return S_OK;
 830 }
 831
 832 static HRESULT WINAPI Mediaseeking_IsUsingTimeFormat(IMediaSeeking *iface,
 833                                                      const GUID *pFormat) {
 834     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 835
 836     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
 837
 838     return S_OK;
 839 }
 840
 841 static HRESULT WINAPI Mediaseeking_SetTimeFormat(IMediaSeeking *iface,
 842                                                  const GUID *pFormat) {
 843     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 844
 845     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
 846
 847     return S_OK;
 848 }
 849
 850 static HRESULT WINAPI Mediaseeking_GetDuration(IMediaSeeking *iface,
 851                                                LONGLONG *pDuration) {
 852     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 853
 854     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDuration);
 855
 856     return S_OK;
 857 }
 858
 859 static HRESULT WINAPI Mediaseeking_GetStopPosition(IMediaSeeking *iface,
 860                                                    LONGLONG *pStop) {
 861     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 862
 863     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pStop);
 864
 865     return S_OK;
 866 }
 867
 868 static HRESULT WINAPI Mediaseeking_GetCurrentPosition(IMediaSeeking *iface,
 869                                                       LONGLONG *pCurrent) {
 870     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 871
 872     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pCurrent);
 873
 874     return S_OK;
 875 }
 876
 877 static HRESULT WINAPI Mediaseeking_ConvertTimeFormat(IMediaSeeking *iface,
 878                                                      LONGLONG *pTarget,
 879                                                      const GUID *pTargetFormat,
 880                                                      LONGLONG Source,
 881                                                      const GUID *pSourceFormat) {
 882     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 883
 884     TRACE("(%p/%p)->(%p, %p, %lld, %p): stub !!!\n", This, iface, pTarget, pTargetFormat, Source, pSourceFormat);
 885
 886     return S_OK;
 887 }
 888
 889 static HRESULT WINAPI Mediaseeking_SetPositions(IMediaSeeking *iface,
 890                                                 LONGLONG *pCurrent,
 891                                                 DWORD dwCurrentFlags,
 892                                                 LONGLONG *pStop,
 893                                                 DWORD dwStopFlags) {
 894     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 895
 896     TRACE("(%p/%p)->(%p, %08lx, %p, %08lx): stub !!!\n", This, iface, pCurrent, dwCurrentFlags, pStop, dwStopFlags);
 897
 898     return S_OK;
 899 }
 900
 901 static HRESULT WINAPI Mediaseeking_GetPositions(IMediaSeeking *iface,
 902                                                 LONGLONG *pCurrent,
 903                                                 LONGLONG *pStop) {
 904     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 905
 906     TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pCurrent, pStop);
 907
 908     return S_OK;
 909 }
 910
 911 static HRESULT WINAPI Mediaseeking_GetAvailable(IMediaSeeking *iface,
 912                                                 LONGLONG *pEarliest,
 913                                                 LONGLONG *pLatest) {
 914     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 915
 916     TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pEarliest, pLatest);
 917
 918     return S_OK;
 919 }
 920
 921 static HRESULT WINAPI Mediaseeking_SetRate(IMediaSeeking *iface,
 922                                            double dRate) {
 923     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 924
 925     TRACE("(%p/%p)->(%f): stub !!!\n", This, iface, dRate);
 926
 927     return S_OK;
 928 }
 929
 930 static HRESULT WINAPI Mediaseeking_GetRate(IMediaSeeking *iface,
 931                                            double *pdRate) {
 932     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 933
 934     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pdRate);
 935
 936     return S_OK;
 937 }
 938
 939 static HRESULT WINAPI Mediaseeking_GetPreroll(IMediaSeeking *iface,
 940                                               LONGLONG *pllPreroll) {
 941     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
 942
 943     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pllPreroll);
 944
 945     return S_OK;
 946 }
 947
 948
 949 static IMediaSeekingVtbl IMediaSeeking_VTable =
 950 {
 951     Mediaseeking_QueryInterface,
 952     Mediaseeking_AddRef,
 953     Mediaseeking_Release,
 954     Mediaseeking_GetCapabilities,
 955     Mediaseeking_CheckCapabilities,
 956     Mediaseeking_IsFormatSupported,
 957     Mediaseeking_QueryPreferredFormat,
 958     Mediaseeking_GetTimeFormat,
 959     Mediaseeking_IsUsingTimeFormat,
 960     Mediaseeking_SetTimeFormat,
 961     Mediaseeking_GetDuration,
 962     Mediaseeking_GetStopPosition,
 963     Mediaseeking_GetCurrentPosition,
 964     Mediaseeking_ConvertTimeFormat,
 965     Mediaseeking_SetPositions,
 966     Mediaseeking_GetPositions,
 967     Mediaseeking_GetAvailable,
 968     Mediaseeking_SetRate,
 969     Mediaseeking_GetRate,
 970     Mediaseeking_GetPreroll
 971 };
 972
 973 /*** IUnknown methods ***/
 974 static HRESULT WINAPI Basicaudio_QueryInterface(IBasicAudio *iface,
 975                                                 REFIID riid,
 976                                                 LPVOID*ppvObj) {
 977     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
 978
 979     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
 980
 981     return Filtergraph_QueryInterface(This, riid, ppvObj);
 982 }
 983
 984 static ULONG WINAPI Basicaudio_AddRef(IBasicAudio *iface) {
 985     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
 986
 987     TRACE("(%p/%p)->()\n", This, iface);
 988
 989     return Filtergraph_AddRef(This);
 990 }
 991
 992 static ULONG WINAPI Basicaudio_Release(IBasicAudio *iface) {
 993     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
 994
 995     TRACE("(%p/%p)->()\n", This, iface);
 996
 997     return Filtergraph_Release(This);
 998 }
 999
1000 /*** IDispatch methods ***/
1001 static HRESULT WINAPI Basicaudio_GetTypeInfoCount(IBasicAudio *iface,
1002                                                   UINT*pctinfo) {
1003     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1004
1005     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1006
1007     return S_OK;
1008 }
1009
1010 static HRESULT WINAPI Basicaudio_GetTypeInfo(IBasicAudio *iface,
1011                                              UINT iTInfo,
1012                                              LCID lcid,
1013                                              ITypeInfo**ppTInfo) {
1014     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1015
1016     TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1017
1018     return S_OK;
1019 }
1020
1021 static HRESULT WINAPI Basicaudio_GetIDsOfNames(IBasicAudio *iface,
1022                                                REFIID riid,
1023                                                LPOLESTR*rgszNames,
1024                                                UINT cNames,
1025                                                LCID lcid,
1026                                                DISPID*rgDispId) {
1027     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1028
1029     TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
1030
1031     return S_OK;
1032 }
1033
1034 static HRESULT WINAPI Basicaudio_Invoke(IBasicAudio *iface,
1035                                         DISPID dispIdMember,
1036                                         REFIID riid,
1037                                         LCID lcid,
1038                                         WORD wFlags,
1039                                         DISPPARAMS*pDispParams,
1040                                         VARIANT*pVarResult,
1041                                         EXCEPINFO*pExepInfo,
1042                                         UINT*puArgErr) {
1043     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1044
1045     TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
1046
1047     return S_OK;
1048 }
1049
1050 /*** IBasicAudio methods ***/
1051 static HRESULT WINAPI Basicaudio_put_Volume(IBasicAudio *iface,
1052                                             long lVolume) {
1053     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1054
1055     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, lVolume);
1056
1057     return S_OK;
1058 }
1059
1060 static HRESULT WINAPI Basicaudio_get_Volume(IBasicAudio *iface,
1061                                             long *plVolume) {
1062     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1063
1064     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, plVolume);
1065
1066     return S_OK;
1067 }
1068
1069 static HRESULT WINAPI Basicaudio_put_Balance(IBasicAudio *iface,
1070                                              long lBalance) {
1071     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1072
1073     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, lBalance);
1074
1075     return S_OK;
1076 }
1077
1078 static HRESULT WINAPI Basicaudio_get_Balance(IBasicAudio *iface,
1079                                              long *plBalance) {
1080     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1081
1082     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, plBalance);
1083
1084     return S_OK;
1085 }
1086
1087 static IBasicAudioVtbl IBasicAudio_VTable =
1088 {
1089     Basicaudio_QueryInterface,
1090     Basicaudio_AddRef,
1091     Basicaudio_Release,
1092     Basicaudio_GetTypeInfoCount,
1093     Basicaudio_GetTypeInfo,
1094     Basicaudio_GetIDsOfNames,
1095     Basicaudio_Invoke,
1096     Basicaudio_put_Volume,
1097     Basicaudio_get_Volume,
1098     Basicaudio_put_Balance,
1099     Basicaudio_get_Balance
1100 };
1101
1102 /*** IUnknown methods ***/
1103 static HRESULT WINAPI Basicvideo_QueryInterface(IBasicVideo *iface,
1104                                                 REFIID riid,
1105                                                 LPVOID*ppvObj) {
1106     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1107
1108     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1109
1110     return Filtergraph_QueryInterface(This, riid, ppvObj);
1111 }
1112
1113 static ULONG WINAPI Basicvideo_AddRef(IBasicVideo *iface) {
1114     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1115
1116     TRACE("(%p/%p)->()\n", This, iface);
1117
1118     return Filtergraph_AddRef(This);
1119 }
1120
1121 static ULONG WINAPI Basicvideo_Release(IBasicVideo *iface) {
1122     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1123
1124     TRACE("(%p/%p)->()\n", This, iface);
1125
1126     return Filtergraph_Release(This);
1127 }
1128
1129 /*** IDispatch methods ***/
1130 static HRESULT WINAPI Basicvideo_GetTypeInfoCount(IBasicVideo *iface,
1131                                                   UINT*pctinfo) {
1132     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1133
1134     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1135
1136     return S_OK;
1137 }
1138
1139 static HRESULT WINAPI Basicvideo_GetTypeInfo(IBasicVideo *iface,
1140                                              UINT iTInfo,
1141                                              LCID lcid,
1142                                              ITypeInfo**ppTInfo) {
1143     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1144
1145     TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1146
1147     return S_OK;
1148 }
1149
1150 static HRESULT WINAPI Basicvideo_GetIDsOfNames(IBasicVideo *iface,
1151                                                REFIID riid,
1152                                                LPOLESTR*rgszNames,
1153                                                UINT cNames,
1154                                                LCID lcid,
1155                                                DISPID*rgDispId) {
1156     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1157
1158     TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
1159
1160     return S_OK;
1161 }
1162
1163 static HRESULT WINAPI Basicvideo_Invoke(IBasicVideo *iface,
1164                                         DISPID dispIdMember,
1165                                         REFIID riid,
1166                                         LCID lcid,
1167                                         WORD wFlags,
1168                                         DISPPARAMS*pDispParams,
1169                                         VARIANT*pVarResult,
1170                                         EXCEPINFO*pExepInfo,
1171                                         UINT*puArgErr) {
1172     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1173
1174     TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
1175
1176     return S_OK;
1177 }
1178
1179 /*** IBasicVideo methods ***/
1180 static HRESULT WINAPI Basicvideo_get_AvgTimePerFrame(IBasicVideo *iface,
1181                                                      REFTIME *pAvgTimePerFrame) {
1182     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1183
1184     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pAvgTimePerFrame);
1185
1186     return S_OK;
1187 }
1188
1189 static HRESULT WINAPI Basicvideo_get_BitRate(IBasicVideo *iface,
1190                                              long *pBitRate) {
1191     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1192
1193     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pBitRate);
1194
1195     return S_OK;
1196 }
1197
1198 static HRESULT WINAPI Basicvideo_get_BitErrorRate(IBasicVideo *iface,
1199                                                   long *pBitErrorRate) {
1200     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1201
1202     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pBitErrorRate);
1203
1204     return S_OK;
1205 }
1206
1207 static HRESULT WINAPI Basicvideo_get_VideoWidth(IBasicVideo *iface,
1208                                                 long *pVideoWidth) {
1209     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1210
1211     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pVideoWidth);
1212
1213     return S_OK;
1214 }
1215
1216 static HRESULT WINAPI Basicvideo_get_VideoHeight(IBasicVideo *iface,
1217                                                  long *pVideoHeight) {
1218     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1219
1220     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pVideoHeight);
1221
1222     return S_OK;
1223 }
1224
1225 static HRESULT WINAPI Basicvideo_put_SourceLeft(IBasicVideo *iface,
1226                                                 long SourceLeft) {
1227     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1228
1229     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, SourceLeft);
1230
1231     return S_OK;
1232 }
1233
1234 static HRESULT WINAPI Basicvideo_get_SourceLeft(IBasicVideo *iface,
1235                                                 long *pSourceLeft) {
1236     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1237
1238     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pSourceLeft);
1239
1240     return S_OK;
1241 }
1242
1243 static HRESULT WINAPI Basicvideo_put_SourceWidth(IBasicVideo *iface,
1244                                                  long SourceWidth) {
1245     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1246
1247     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, SourceWidth);
1248
1249     return S_OK;
1250 }
1251
1252 static HRESULT WINAPI Basicvideo_get_SourceWidth(IBasicVideo *iface,
1253                                                  long *pSourceWidth) {
1254     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1255
1256     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pSourceWidth);
1257
1258     return S_OK;
1259 }
1260
1261 static HRESULT WINAPI Basicvideo_put_SourceTop(IBasicVideo *iface,
1262                                                long SourceTop) {
1263     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1264
1265     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, SourceTop);
1266
1267     return S_OK;
1268 }
1269
1270 static HRESULT WINAPI Basicvideo_get_SourceTop(IBasicVideo *iface,
1271                                                long *pSourceTop) {
1272     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1273
1274     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pSourceTop);
1275
1276     return S_OK;
1277 }
1278
1279 static HRESULT WINAPI Basicvideo_put_SourceHeight(IBasicVideo *iface,
1280                                                   long SourceHeight) {
1281     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1282
1283     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, SourceHeight);
1284
1285     return S_OK;
1286 }
1287
1288 static HRESULT WINAPI Basicvideo_get_SourceHeight(IBasicVideo *iface,
1289                                                   long *pSourceHeight) {
1290     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1291
1292     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pSourceHeight);
1293
1294     return S_OK;
1295 }
1296
1297 static HRESULT WINAPI Basicvideo_put_DestinationLeft(IBasicVideo *iface,
1298                                                      long DestinationLeft) {
1299     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1300
1301     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, DestinationLeft);
1302
1303     return S_OK;
1304 }
1305
1306 static HRESULT WINAPI Basicvideo_get_DestinationLeft(IBasicVideo *iface,
1307                                                      long *pDestinationLeft) {
1308     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1309
1310     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDestinationLeft);
1311
1312     return S_OK;
1313 }
1314
1315 static HRESULT WINAPI Basicvideo_put_DestinationWidth(IBasicVideo *iface,
1316                                                       long DestinationWidth) {
1317     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1318
1319     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, DestinationWidth);
1320
1321     return S_OK;
1322 }
1323
1324 static HRESULT WINAPI Basicvideo_get_DestinationWidth(IBasicVideo *iface,
1325                                                       long *pDestinationWidth) {
1326     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1327
1328     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDestinationWidth);
1329
1330     return S_OK;
1331 }
1332
1333 static HRESULT WINAPI Basicvideo_put_DestinationTop(IBasicVideo *iface,
1334                                                     long DestinationTop) {
1335     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1336
1337     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, DestinationTop);
1338
1339     return S_OK;
1340 }
1341
1342 static HRESULT WINAPI Basicvideo_get_DestinationTop(IBasicVideo *iface,
1343                                                     long *pDestinationTop) {
1344     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1345
1346     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDestinationTop);
1347
1348     return S_OK;
1349 }
1350
1351 static HRESULT WINAPI Basicvideo_put_DestinationHeight(IBasicVideo *iface,
1352                                                        long DestinationHeight) {
1353     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1354
1355     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, DestinationHeight);
1356
1357     return S_OK;
1358 }
1359
1360 static HRESULT WINAPI Basicvideo_get_DestinationHeight(IBasicVideo *iface,
1361                                                        long *pDestinationHeight) {
1362     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1363
1364     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDestinationHeight);
1365
1366     return S_OK;
1367 }
1368
1369 static HRESULT WINAPI Basicvideo_SetSourcePosition(IBasicVideo *iface,
1370                                                    long Left,
1371                                                    long Top,
1372                                                    long Width,
1373                                                    long Height) {
1374     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1375
1376     TRACE("(%p/%p)->(%ld, %ld, %ld, %ld): stub !!!\n", This, iface, Left, Top, Width, Height);
1377
1378     return S_OK;
1379 }
1380
1381 static HRESULT WINAPI Basicvideo_GetSourcePosition(IBasicVideo *iface,
1382                                                    long *pLeft,
1383                                                    long *pTop,
1384                                                    long *pWidth,
1385                                                    long *pHeight) {
1386     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1387
1388     TRACE("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight);
1389
1390     return S_OK;
1391 }
1392
1393 static HRESULT WINAPI Basicvideo_SetDefaultSourcePosition(IBasicVideo *iface) {
1394     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1395
1396     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1397
1398     return S_OK;
1399 }
1400
1401 static HRESULT WINAPI Basicvideo_SetDestinationPosition(IBasicVideo *iface,
1402                                                         long Left,
1403                                                         long Top,
1404                                                         long Width,
1405                                                         long Height) {
1406     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1407
1408     TRACE("(%p/%p)->(%ld, %ld, %ld, %ld): stub !!!\n", This, iface, Left, Top, Width, Height);
1409
1410     return S_OK;
1411 }
1412
1413 static HRESULT WINAPI Basicvideo_GetDestinationPosition(IBasicVideo *iface,
1414                                                         long *pLeft,
1415                                                         long *pTop,
1416                                                         long *pWidth,
1417                                                         long *pHeight) {
1418     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1419
1420     TRACE("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight);
1421
1422     return S_OK;
1423 }
1424
1425 static HRESULT WINAPI Basicvideo_SetDefaultDestinationPosition(IBasicVideo *iface) {
1426     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1427
1428     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1429
1430     return S_OK;
1431 }
1432
1433 static HRESULT WINAPI Basicvideo_GetVideoSize(IBasicVideo *iface,
1434                                               long *pWidth,
1435                                               long *pHeight) {
1436     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1437
1438     TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pWidth, pHeight);
1439
1440     return S_OK;
1441 }
1442
1443 static HRESULT WINAPI Basicvideo_GetVideoPaletteEntries(IBasicVideo *iface,
1444                                                         long StartIndex,
1445                                                         long Entries,
1446                                                         long *pRetrieved,
1447                                                         long *pPalette) {
1448     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1449
1450     TRACE("(%p/%p)->(%ld, %ld, %p, %p): stub !!!\n", This, iface, StartIndex, Entries, pRetrieved, pPalette);
1451
1452     return S_OK;
1453 }
1454
1455 static HRESULT WINAPI Basicvideo_GetCurrentImage(IBasicVideo *iface,
1456                                                  long *pBufferSize,
1457                                                  long *pDIBImage) {
1458     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1459
1460     TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pBufferSize, pDIBImage);
1461
1462     return S_OK;
1463 }
1464
1465 static HRESULT WINAPI Basicvideo_IsUsingDefaultSource(IBasicVideo *iface) {
1466     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1467
1468     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1469
1470     return S_OK;
1471 }
1472
1473 static HRESULT WINAPI Basicvideo_IsUsingDefaultDestination(IBasicVideo *iface) {
1474     ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1475
1476     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1477
1478     return S_OK;
1479 }
1480
1481
1482 static IBasicVideoVtbl IBasicVideo_VTable =
1483 {
1484     Basicvideo_QueryInterface,
1485     Basicvideo_AddRef,
1486     Basicvideo_Release,
1487     Basicvideo_GetTypeInfoCount,
1488     Basicvideo_GetTypeInfo,
1489     Basicvideo_GetIDsOfNames,
1490     Basicvideo_Invoke,
1491     Basicvideo_get_AvgTimePerFrame,
1492     Basicvideo_get_BitRate,
1493     Basicvideo_get_BitErrorRate,
1494     Basicvideo_get_VideoWidth,
1495     Basicvideo_get_VideoHeight,
1496     Basicvideo_put_SourceLeft,
1497     Basicvideo_get_SourceLeft,
1498     Basicvideo_put_SourceWidth,
1499     Basicvideo_get_SourceWidth,
1500     Basicvideo_put_SourceTop,
1501     Basicvideo_get_SourceTop,
1502     Basicvideo_put_SourceHeight,
1503     Basicvideo_get_SourceHeight,
1504     Basicvideo_put_DestinationLeft,
1505     Basicvideo_get_DestinationLeft,
1506     Basicvideo_put_DestinationWidth,
1507     Basicvideo_get_DestinationWidth,
1508     Basicvideo_put_DestinationTop,
1509     Basicvideo_get_DestinationTop,
1510     Basicvideo_put_DestinationHeight,
1511     Basicvideo_get_DestinationHeight,
1512     Basicvideo_SetSourcePosition,
1513     Basicvideo_GetSourcePosition,
1514     Basicvideo_SetDefaultSourcePosition,
1515     Basicvideo_SetDestinationPosition,
1516     Basicvideo_GetDestinationPosition,
1517     Basicvideo_SetDefaultDestinationPosition,
1518     Basicvideo_GetVideoSize,
1519     Basicvideo_GetVideoPaletteEntries,
1520     Basicvideo_GetCurrentImage,
1521     Basicvideo_IsUsingDefaultSource,
1522     Basicvideo_IsUsingDefaultDestination
1523 };
1524
1525
1526 /*** IUnknown methods ***/
1527 static HRESULT WINAPI Videowindow_QueryInterface(IVideoWindow *iface,
1528                                                  REFIID riid,
1529                                                  LPVOID*ppvObj) {
1530     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1531
1532     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1533
1534     return Filtergraph_QueryInterface(This, riid, ppvObj);
1535 }
1536
1537 static ULONG WINAPI Videowindow_AddRef(IVideoWindow *iface) {
1538     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1539
1540     TRACE("(%p/%p)->()\n", This, iface);
1541
1542     return Filtergraph_AddRef(This);
1543 }
1544
1545 static ULONG WINAPI Videowindow_Release(IVideoWindow *iface) {
1546     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1547
1548     TRACE("(%p/%p)->()\n", This, iface);
1549
1550     return Filtergraph_Release(This);
1551 }
1552
1553 /*** IDispatch methods ***/
1554 static HRESULT WINAPI Videowindow_GetTypeInfoCount(IVideoWindow *iface,
1555                                                    UINT*pctinfo) {
1556     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1557
1558     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1559
1560     return S_OK;
1561 }
1562
1563 static HRESULT WINAPI Videowindow_GetTypeInfo(IVideoWindow *iface,
1564                                               UINT iTInfo,
1565                                               LCID lcid,
1566                                               ITypeInfo**ppTInfo) {
1567     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1568
1569     TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1570
1571     return S_OK;
1572 }
1573
1574 static HRESULT WINAPI Videowindow_GetIDsOfNames(IVideoWindow *iface,
1575                                                 REFIID riid,
1576                                                 LPOLESTR*rgszNames,
1577                                                 UINT cNames,
1578                                                 LCID lcid,
1579                                                 DISPID*rgDispId) {
1580     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1581
1582     TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
1583
1584     return S_OK;
1585 }
1586
1587 static HRESULT WINAPI Videowindow_Invoke(IVideoWindow *iface,
1588                                          DISPID dispIdMember,
1589                                          REFIID riid,
1590                                          LCID lcid,
1591                                          WORD wFlags,
1592                                          DISPPARAMS*pDispParams,
1593                                          VARIANT*pVarResult,
1594                                          EXCEPINFO*pExepInfo,
1595                                          UINT*puArgErr) {
1596     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1597
1598     TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
1599
1600     return S_OK;
1601 }
1602
1603 /*** IVideoWindow methods ***/
1604 static HRESULT WINAPI Videowindow_put_Caption(IVideoWindow *iface,
1605                                               BSTR strCaption) {
1606     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1607
1608     TRACE("(%p/%p)->(%s (%p)): stub !!!\n", This, iface, debugstr_w(strCaption), strCaption);
1609
1610     return S_OK;
1611 }
1612
1613 static HRESULT WINAPI Videowindow_get_Caption(IVideoWindow *iface,
1614                                               BSTR *strCaption) {
1615     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1616
1617     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, strCaption);
1618
1619     return S_OK;
1620 }
1621
1622 static HRESULT WINAPI Videowindow_put_WindowStyle(IVideoWindow *iface,
1623                                                   long WindowStyle) {
1624     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1625
1626     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, WindowStyle);
1627
1628     return S_OK;
1629 }
1630
1631 static HRESULT WINAPI Videowindow_get_WindowStyle(IVideoWindow *iface,
1632                                                   long *WindowStyle) {
1633     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1634
1635     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, WindowStyle);
1636
1637     return S_OK;
1638 }
1639
1640 static HRESULT WINAPI Videowindow_put_WindowStyleEx(IVideoWindow *iface,
1641                                                     long WindowStyleEx) {
1642     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1643
1644     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, WindowStyleEx);
1645
1646     return S_OK;
1647 }
1648
1649 static HRESULT WINAPI Videowindow_get_WindowStyleEx(IVideoWindow *iface,
1650                                                     long *WindowStyleEx) {
1651     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1652
1653     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, WindowStyleEx);
1654
1655     return S_OK;
1656 }
1657
1658 static HRESULT WINAPI Videowindow_put_AutoShow(IVideoWindow *iface,
1659                                                long AutoShow) {
1660     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1661
1662     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, AutoShow);
1663
1664     return S_OK;
1665 }
1666
1667 static HRESULT WINAPI Videowindow_get_AutoShow(IVideoWindow *iface,
1668                                                long *AutoShow) {
1669     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1670
1671     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, AutoShow);
1672
1673     return S_OK;
1674 }
1675
1676 static HRESULT WINAPI Videowindow_put_WindowState(IVideoWindow *iface,
1677                                                   long WindowState) {
1678     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1679
1680     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, WindowState);
1681
1682     return S_OK;
1683 }
1684
1685 static HRESULT WINAPI Videowindow_get_WindowState(IVideoWindow *iface,
1686                                                   long *WindowState) {
1687     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1688
1689     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, WindowState);
1690
1691     return S_OK;
1692 }
1693
1694 static HRESULT WINAPI Videowindow_put_BackgroundPalette(IVideoWindow *iface,
1695                                                         long BackgroundPalette) {
1696     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1697
1698     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, BackgroundPalette);
1699
1700     return S_OK;
1701 }
1702
1703 static HRESULT WINAPI Videowindow_get_BackgroundPalette(IVideoWindow *iface,
1704                                                         long *pBackgroundPalette) {
1705     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1706
1707     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pBackgroundPalette);
1708
1709     return S_OK;
1710 }
1711
1712 static HRESULT WINAPI Videowindow_put_Visible(IVideoWindow *iface,
1713                                               long Visible) {
1714     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1715
1716     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Visible);
1717
1718     return S_OK;
1719 }
1720
1721 static HRESULT WINAPI Videowindow_get_Visible(IVideoWindow *iface,
1722                                               long *pVisible) {
1723     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1724
1725     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pVisible);
1726
1727     return S_OK;
1728 }
1729
1730 static HRESULT WINAPI Videowindow_put_Left(IVideoWindow *iface,
1731                                            long Left) {
1732     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1733
1734     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Left);
1735
1736     return S_OK;
1737 }
1738
1739 static HRESULT WINAPI Videowindow_get_Left(IVideoWindow *iface,
1740                                            long *pLeft) {
1741     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1742
1743     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pLeft);
1744
1745     return S_OK;
1746 }
1747
1748 static HRESULT WINAPI Videowindow_put_Width(IVideoWindow *iface,
1749                                             long Width) {
1750     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1751
1752     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Width);
1753
1754     return S_OK;
1755 }
1756
1757 static HRESULT WINAPI Videowindow_get_Width(IVideoWindow *iface,
1758                                             long *pWidth) {
1759     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1760
1761     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pWidth);
1762
1763     return S_OK;
1764 }
1765
1766 static HRESULT WINAPI Videowindow_put_Top(IVideoWindow *iface,
1767                                           long Top) {
1768     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1769
1770     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Top);
1771
1772     return S_OK;
1773 }
1774
1775 static HRESULT WINAPI Videowindow_get_Top(IVideoWindow *iface,
1776                                           long *pTop) {
1777     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1778
1779     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pTop);
1780
1781     return S_OK;
1782 }
1783
1784 static HRESULT WINAPI Videowindow_put_Height(IVideoWindow *iface,
1785                                              long Height) {
1786     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1787
1788     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Height);
1789
1790     return S_OK;
1791 }
1792
1793 static HRESULT WINAPI Videowindow_get_Height(IVideoWindow *iface,
1794                                              long *pHeight) {
1795     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1796
1797     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pHeight);
1798
1799     return S_OK;
1800 }
1801
1802 static HRESULT WINAPI Videowindow_put_Owner(IVideoWindow *iface,
1803                                             OAHWND Owner) {
1804     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1805
1806     TRACE("(%p/%p)->(%08lx): stub !!!\n", This, iface, (DWORD) Owner);
1807
1808     return S_OK;
1809 }
1810
1811 static HRESULT WINAPI Videowindow_get_Owner(IVideoWindow *iface,
1812                                             OAHWND *Owner) {
1813     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1814
1815     TRACE("(%p/%p)->(%08lx): stub !!!\n", This, iface, (DWORD) Owner);
1816
1817     return S_OK;
1818 }
1819
1820 static HRESULT WINAPI Videowindow_put_MessageDrain(IVideoWindow *iface,
1821                                                    OAHWND Drain) {
1822     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1823
1824     TRACE("(%p/%p)->(%08lx): stub !!!\n", This, iface, (DWORD) Drain);
1825
1826     return S_OK;
1827 }
1828
1829 static HRESULT WINAPI Videowindow_get_MessageDrain(IVideoWindow *iface,
1830                                                    OAHWND *Drain) {
1831     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1832
1833     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, Drain);
1834
1835     return S_OK;
1836 }
1837
1838 static HRESULT WINAPI Videowindow_get_BorderColor(IVideoWindow *iface,
1839                                                   long *Color) {
1840     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1841
1842     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, Color);
1843
1844     return S_OK;
1845 }
1846
1847 static HRESULT WINAPI Videowindow_put_BorderColor(IVideoWindow *iface,
1848                                                   long Color) {
1849     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1850
1851     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Color);
1852
1853     return S_OK;
1854 }
1855
1856 static HRESULT WINAPI Videowindow_get_FullScreenMode(IVideoWindow *iface,
1857                                                      long *FullScreenMode) {
1858     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1859
1860     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, FullScreenMode);
1861
1862     return S_OK;
1863 }
1864
1865 static HRESULT WINAPI Videowindow_put_FullScreenMode(IVideoWindow *iface,
1866                                                      long FullScreenMode) {
1867     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1868
1869     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, FullScreenMode);
1870
1871     return S_OK;
1872 }
1873
1874 static HRESULT WINAPI Videowindow_SetWindowForeground(IVideoWindow *iface,
1875                                                       long Focus) {
1876     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1877
1878     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Focus);
1879
1880     return S_OK;
1881 }
1882
1883 static HRESULT WINAPI Videowindow_NotifyOwnerMessage(IVideoWindow *iface,
1884                                                      OAHWND hwnd,
1885                                                      long uMsg,
1886                                                      LONG_PTR wParam,
1887                                                      LONG_PTR lParam) {
1888     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1889
1890     TRACE("(%p/%p)->(%08lx, %ld, %08lx, %08lx): stub !!!\n", This, iface, (DWORD) hwnd, uMsg, wParam, lParam);
1891
1892     return S_OK;
1893 }
1894
1895 static HRESULT WINAPI Videowindow_SetWindowPosition(IVideoWindow *iface,
1896                                                     long Left,
1897                                                     long Top,
1898                                                     long Width,
1899                                                     long Height) {
1900     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1901
1902     TRACE("(%p/%p)->(%ld, %ld, %ld, %ld): stub !!!\n", This, iface, Left, Top, Width, Height);
1903
1904     return S_OK;
1905 }
1906
1907 static HRESULT WINAPI Videowindow_GetWindowPosition(IVideoWindow *iface,
1908                                                     long *pLeft,
1909                                                     long *pTop,
1910                                                     long *pWidth,
1911                                                     long *pHeight) {
1912     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1913
1914     TRACE("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight);
1915
1916     return S_OK;
1917 }
1918
1919 static HRESULT WINAPI Videowindow_GetMinIdealImageSize(IVideoWindow *iface,
1920                                                        long *pWidth,
1921                                                        long *pHeight) {
1922     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1923
1924     TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pWidth, pHeight);
1925
1926     return S_OK;
1927 }
1928
1929 static HRESULT WINAPI Videowindow_GetMaxIdealImageSize(IVideoWindow *iface,
1930                                                        long *pWidth,
1931                                                        long *pHeight) {
1932     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1933
1934     TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pWidth, pHeight);
1935
1936     return S_OK;
1937 }
1938
1939 static HRESULT WINAPI Videowindow_GetRestorePosition(IVideoWindow *iface,
1940                                                      long *pLeft,
1941                                                      long *pTop,
1942                                                      long *pWidth,
1943                                                      long *pHeight) {
1944     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1945
1946     TRACE("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight);
1947
1948     return S_OK;
1949 }
1950
1951 static HRESULT WINAPI Videowindow_HideCursor(IVideoWindow *iface,
1952                                              long HideCursor) {
1953     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1954
1955     TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, HideCursor);
1956
1957     return S_OK;
1958 }
1959
1960 static HRESULT WINAPI Videowindow_IsCursorHidden(IVideoWindow *iface,
1961                                                  long *CursorHidden) {
1962     ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
1963
1964     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, CursorHidden);
1965
1966     return S_OK;
1967 }
1968
1969
1970 static IVideoWindowVtbl IVideoWindow_VTable =
1971 {
1972     Videowindow_QueryInterface,
1973     Videowindow_AddRef,
1974     Videowindow_Release,
1975     Videowindow_GetTypeInfoCount,
1976     Videowindow_GetTypeInfo,
1977     Videowindow_GetIDsOfNames,
1978     Videowindow_Invoke,
1979     Videowindow_put_Caption,
1980     Videowindow_get_Caption,
1981     Videowindow_put_WindowStyle,
1982     Videowindow_get_WindowStyle,
1983     Videowindow_put_WindowStyleEx,
1984     Videowindow_get_WindowStyleEx,
1985     Videowindow_put_AutoShow,
1986     Videowindow_get_AutoShow,
1987     Videowindow_put_WindowState,
1988     Videowindow_get_WindowState,
1989     Videowindow_put_BackgroundPalette,
1990     Videowindow_get_BackgroundPalette,
1991     Videowindow_put_Visible,
1992     Videowindow_get_Visible,
1993     Videowindow_put_Left,
1994     Videowindow_get_Left,
1995     Videowindow_put_Width,
1996     Videowindow_get_Width,
1997     Videowindow_put_Top,
1998     Videowindow_get_Top,
1999     Videowindow_put_Height,
2000     Videowindow_get_Height,
2001     Videowindow_put_Owner,
2002     Videowindow_get_Owner,
2003     Videowindow_put_MessageDrain,
2004     Videowindow_get_MessageDrain,
2005     Videowindow_get_BorderColor,
2006     Videowindow_put_BorderColor,
2007     Videowindow_get_FullScreenMode,
2008     Videowindow_put_FullScreenMode,
2009     Videowindow_SetWindowForeground,
2010     Videowindow_NotifyOwnerMessage,
2011     Videowindow_SetWindowPosition,
2012     Videowindow_GetWindowPosition,
2013     Videowindow_GetMinIdealImageSize,
2014     Videowindow_GetMaxIdealImageSize,
2015     Videowindow_GetRestorePosition,
2016     Videowindow_HideCursor,
2017     Videowindow_IsCursorHidden
2018 };
2019
2020
2021 /*** IUnknown methods ***/
2022 static HRESULT WINAPI Mediaevent_QueryInterface(IMediaEventEx *iface,
2023                                                 REFIID riid,
2024                                                 LPVOID*ppvObj) {
2025     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2026
2027     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
2028
2029     return Filtergraph_QueryInterface(This, riid, ppvObj);
2030 }
2031
2032 static ULONG WINAPI Mediaevent_AddRef(IMediaEventEx *iface) {
2033     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2034
2035     TRACE("(%p/%p)->()\n", This, iface);
2036
2037     return Filtergraph_AddRef(This);
2038 }
2039
2040 static ULONG WINAPI Mediaevent_Release(IMediaEventEx *iface) {
2041     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2042
2043     TRACE("(%p/%p)->()\n", This, iface);
2044
2045     return Filtergraph_Release(This);
2046 }
2047
2048 /*** IDispatch methods ***/
2049 static HRESULT WINAPI Mediaevent_GetTypeInfoCount(IMediaEventEx *iface,
2050                                                   UINT*pctinfo) {
2051     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2052
2053     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
2054
2055     return S_OK;
2056 }
2057
2058 static HRESULT WINAPI Mediaevent_GetTypeInfo(IMediaEventEx *iface,
2059                                              UINT iTInfo,
2060                                              LCID lcid,
2061                                              ITypeInfo**ppTInfo) {
2062     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2063
2064     TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
2065
2066     return S_OK;
2067 }
2068
2069 static HRESULT WINAPI Mediaevent_GetIDsOfNames(IMediaEventEx *iface,
2070                                                REFIID riid,
2071                                                LPOLESTR*rgszNames,
2072                                                UINT cNames,
2073                                                LCID lcid,
2074                                                DISPID*rgDispId) {
2075     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2076
2077     TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
2078
2079     return S_OK;
2080 }
2081
2082 static HRESULT WINAPI Mediaevent_Invoke(IMediaEventEx *iface,
2083                                         DISPID dispIdMember,
2084                                         REFIID riid,
2085                                         LCID lcid,
2086                                         WORD wFlags,
2087                                         DISPPARAMS*pDispParams,
2088                                         VARIANT*pVarResult,
2089                                         EXCEPINFO*pExepInfo,
2090                                         UINT*puArgErr) {
2091     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2092
2093     TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
2094
2095     return S_OK;
2096 }
2097
2098 /*** IMediaEvent methods ***/
2099 static HRESULT WINAPI Mediaevent_GetEventHandle(IMediaEventEx *iface,
2100                                                 OAEVENT *hEvent) {
2101     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2102
2103     TRACE("(%p/%p)->(%p)\n", This, iface, hEvent);
2104
2105     *hEvent = (OAEVENT)This->evqueue.msg_event;
2106
2107     return S_OK;
2108 }
2109
2110 static HRESULT WINAPI Mediaevent_GetEvent(IMediaEventEx *iface,
2111                                           long *lEventCode,
2112                                           LONG_PTR *lParam1,
2113                                           LONG_PTR *lParam2,
2114                                           long msTimeout) {
2115     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2116     Event evt;
2117
2118     TRACE("(%p/%p)->(%p, %p, %p, %ld)\n", This, iface, lEventCode, lParam1, lParam2, msTimeout);
2119
2120     if (EventsQueue_GetEvent(&This->evqueue, &evt, msTimeout))
2121     {
2122         *lEventCode = evt.lEventCode;
2123         *lParam1 = evt.lParam1;
2124         *lParam2 = evt.lParam2;
2125         return S_OK;
2126     }
2127
2128     *lEventCode = 0;
2129     return E_ABORT;
2130 }
2131
2132 static HRESULT WINAPI Mediaevent_WaitForCompletion(IMediaEventEx *iface,
2133                                                    long msTimeout,
2134                                                    long *pEvCode) {
2135     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2136
2137     TRACE("(%p/%p)->(%ld, %p)\n", This, iface, msTimeout, pEvCode);
2138
2139     if (WaitForSingleObject(This->hEventCompletion, msTimeout) == WAIT_OBJECT_0)
2140     {
2141         *pEvCode = This->CompletionStatus;
2142         return S_OK;
2143     }
2144
2145     *pEvCode = 0;
2146     return E_ABORT;
2147 }
2148
2149 static HRESULT WINAPI Mediaevent_CancelDefaultHandling(IMediaEventEx *iface,
2150                                                        long lEvCode) {
2151     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2152
2153     TRACE("(%p/%p)->(%ld)\n", This, iface, lEvCode);
2154
2155     if (lEvCode == EC_COMPLETE)
2156         This->HandleEcComplete = FALSE;
2157     else if (lEvCode == EC_REPAINT)
2158         This->HandleEcRepaint = FALSE;
2159     else
2160         return S_FALSE;
2161
2162     return S_OK;
2163 }
2164
2165 static HRESULT WINAPI Mediaevent_RestoreDefaultHandling(IMediaEventEx *iface,
2166                                                         long lEvCode) {
2167     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2168
2169     TRACE("(%p/%p)->(%ld)\n", This, iface, lEvCode);
2170
2171     if (lEvCode == EC_COMPLETE)
2172         This->HandleEcComplete = TRUE;
2173     else if (lEvCode == EC_REPAINT)
2174         This->HandleEcRepaint = TRUE;
2175     else
2176         return S_FALSE;
2177
2178     return S_OK;
2179 }
2180
2181 static HRESULT WINAPI Mediaevent_FreeEventParams(IMediaEventEx *iface,
2182                                                  long lEvCode,
2183                                                  LONG_PTR lParam1,
2184                                                  LONG_PTR lParam2) {
2185     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2186
2187     TRACE("(%p/%p)->(%ld, %08lx, %08lx): stub !!!\n", This, iface, lEvCode, lParam1, lParam2);
2188
2189     return S_OK;
2190 }
2191
2192 /*** IMediaEventEx methods ***/
2193 static HRESULT WINAPI Mediaevent_SetNotifyWindow(IMediaEventEx *iface,
2194                                                  OAHWND hwnd,
2195                                                  long lMsg,
2196                                                  LONG_PTR lInstanceData) {
2197     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2198
2199     TRACE("(%p/%p)->(%08lx, %ld, %08lx)\n", This, iface, (DWORD) hwnd, lMsg, lInstanceData);
2200
2201     This->notif.hWnd = (HWND)hwnd;
2202     This->notif.msg = lMsg;
2203     This->notif.instance = (long) lInstanceData;
2204
2205     return S_OK;
2206 }
2207
2208 static HRESULT WINAPI Mediaevent_SetNotifyFlags(IMediaEventEx *iface,
2209                                                 long lNoNotifyFlags) {
2210     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2211
2212     TRACE("(%p/%p)->(%ld)\n", This, iface, lNoNotifyFlags);
2213
2214     if ((lNoNotifyFlags != 0) || (lNoNotifyFlags != 1))
2215         return E_INVALIDARG;
2216
2217     This->notif.disabled = lNoNotifyFlags;
2218
2219     return S_OK;
2220 }
2221
2222 static HRESULT WINAPI Mediaevent_GetNotifyFlags(IMediaEventEx *iface,
2223                                                 long *lplNoNotifyFlags) {
2224     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2225
2226     TRACE("(%p/%p)->(%p)\n", This, iface, lplNoNotifyFlags);
2227
2228     if (!lplNoNotifyFlags)
2229         return E_POINTER;
2230
2231     *lplNoNotifyFlags = This->notif.disabled;
2232
2233     return S_OK;
2234 }
2235
2236
2237 static IMediaEventExVtbl IMediaEventEx_VTable =
2238 {
2239     Mediaevent_QueryInterface,
2240     Mediaevent_AddRef,
2241     Mediaevent_Release,
2242     Mediaevent_GetTypeInfoCount,
2243     Mediaevent_GetTypeInfo,
2244     Mediaevent_GetIDsOfNames,
2245     Mediaevent_Invoke,
2246     Mediaevent_GetEventHandle,
2247     Mediaevent_GetEvent,
2248     Mediaevent_WaitForCompletion,
2249     Mediaevent_CancelDefaultHandling,
2250     Mediaevent_RestoreDefaultHandling,
2251     Mediaevent_FreeEventParams,
2252     Mediaevent_SetNotifyWindow,
2253     Mediaevent_SetNotifyFlags,
2254     Mediaevent_GetNotifyFlags
2255 };
2256
2257
2258 static HRESULT WINAPI MediaFilter_QueryInterface(IMediaFilter *iface, REFIID riid, LPVOID *ppv)
2259 {
2260     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2261
2262     return Filtergraph_QueryInterface(This, riid, ppv);
2263 }
2264
2265 static ULONG WINAPI MediaFilter_AddRef(IMediaFilter *iface)
2266 {
2267     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2268
2269     return Filtergraph_AddRef(This);
2270 }
2271
2272 static ULONG WINAPI MediaFilter_Release(IMediaFilter *iface)
2273 {
2274     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2275
2276     return Filtergraph_Release(This);
2277 }
2278
2279 static HRESULT WINAPI MediaFilter_GetClassID(IMediaFilter *iface, CLSID * pClassID)
2280 {
2281     FIXME("(%p): stub\n", pClassID);
2282
2283     return E_NOTIMPL;
2284 }
2285
2286 static HRESULT WINAPI MediaFilter_Stop(IMediaFilter *iface)
2287 {
2288     FIXME("(): stub\n");
2289
2290     return E_NOTIMPL;
2291 }
2292
2293 static HRESULT WINAPI MediaFilter_Pause(IMediaFilter *iface)
2294 {
2295     FIXME("(): stub\n");
2296
2297     return E_NOTIMPL;
2298 }
2299
2300 static HRESULT WINAPI MediaFilter_Run(IMediaFilter *iface, REFERENCE_TIME tStart)
2301 {
2302     FIXME("(%lld): stub\n", tStart);
2303
2304     return E_NOTIMPL;
2305 }
2306
2307 static HRESULT WINAPI MediaFilter_GetState(IMediaFilter *iface, DWORD dwMsTimeout, FILTER_STATE * pState)
2308 {
2309     FIXME("(%ld, %p): stub\n", dwMsTimeout, pState);
2310
2311     return E_NOTIMPL;
2312 }
2313
2314 static HRESULT WINAPI MediaFilter_SetSyncSource(IMediaFilter *iface, IReferenceClock *pClock)
2315 {
2316     FIXME("(%p): stub\n", pClock);
2317
2318     return E_NOTIMPL;
2319 }
2320
2321 static HRESULT WINAPI MediaFilter_GetSyncSource(IMediaFilter *iface, IReferenceClock **ppClock)
2322 {
2323     FIXME("(%p): stub\n", ppClock);
2324
2325     return E_NOTIMPL;
2326 }
2327
2328 static IMediaFilterVtbl IMediaFilter_VTable =
2329 {
2330     MediaFilter_QueryInterface,
2331     MediaFilter_AddRef,
2332     MediaFilter_Release,
2333     MediaFilter_GetClassID,
2334     MediaFilter_Stop,
2335     MediaFilter_Pause,
2336     MediaFilter_Run,
2337     MediaFilter_GetState,
2338     MediaFilter_SetSyncSource,
2339     MediaFilter_GetSyncSource
2340 };
2341
2342 static HRESULT WINAPI MediaEventSink_QueryInterface(IMediaEventSink *iface, REFIID riid, LPVOID *ppv)
2343 {
2344     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventSink_vtbl, iface);
2345
2346     return Filtergraph_QueryInterface(This, riid, ppv);
2347 }
2348
2349 static ULONG WINAPI MediaEventSink_AddRef(IMediaEventSink *iface)
2350 {
2351     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventSink_vtbl, iface);
2352
2353     return Filtergraph_AddRef(This);
2354 }
2355
2356 static ULONG WINAPI MediaEventSink_Release(IMediaEventSink *iface)
2357 {
2358     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventSink_vtbl, iface);
2359
2360     return Filtergraph_Release(This);
2361 }
2362
2363 static HRESULT WINAPI MediaEventSink_Notify(IMediaEventSink *iface, long EventCode, LONG_PTR EventParam1, LONG_PTR EventParam2)
2364 {
2365     ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventSink_vtbl, iface);
2366     Event evt;
2367
2368     TRACE("(%p/%p)->(%ld, %ld, %ld)\n", This, iface, EventCode, EventParam1, EventParam2);
2369
2370     /* We need thread safety here, let's use the events queue's one */
2371     EnterCriticalSection(&This->evqueue.msg_crst);
2372
2373     if ((EventCode == EC_COMPLETE) && This->HandleEcComplete)
2374     {
2375         if (++This->EcCompleteCount == This->nRenderers)
2376         {
2377             evt.lEventCode = EC_COMPLETE;
2378             evt.lParam1 = S_OK;
2379             evt.lParam2 = 0;
2380             EventsQueue_PutEvent(&This->evqueue, &evt);
2381             if (!This->notif.disabled && This->notif.hWnd)
2382                 PostMessageW(This->notif.hWnd, This->notif.msg, 0, This->notif.instance);
2383             This->CompletionStatus = EC_COMPLETE;
2384             SetEvent(This->hEventCompletion);
2385         }
2386     }
2387     else if ((EventCode == EC_REPAINT) && This->HandleEcRepaint)
2388     {
2389         /* FIXME: Not handled yet */
2390     }
2391     else
2392     {
2393         evt.lEventCode = EventCode;
2394         evt.lParam1 = EventParam1;
2395         evt.lParam2 = EventParam2;
2396         EventsQueue_PutEvent(&This->evqueue, &evt);
2397         if (!This->notif.disabled && This->notif.hWnd)
2398             PostMessageW(This->notif.hWnd, This->notif.msg, 0, This->notif.instance);
2399     }
2400
2401     LeaveCriticalSection(&This->evqueue.msg_crst);
2402     return S_OK;
2403 }
2404
2405 static IMediaEventSinkVtbl IMediaEventSink_VTable =
2406 {
2407     MediaEventSink_QueryInterface,
2408     MediaEventSink_AddRef,
2409     MediaEventSink_Release,
2410     MediaEventSink_Notify
2411 };
2412
2413 /* This is the only function that actually creates a FilterGraph class... */
2414 HRESULT FILTERGRAPH_create(IUnknown *pUnkOuter, LPVOID *ppObj) {
2415     IFilterGraphImpl *fimpl;
2416
2417     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
2418
2419     fimpl = (IFilterGraphImpl *) HeapAlloc(GetProcessHeap(), 0, sizeof(*fimpl));
2420     fimpl->IGraphBuilder_vtbl = &IGraphBuilder_VTable;
2421     fimpl->IMediaControl_vtbl = &IMediaControl_VTable;
2422     fimpl->IMediaSeeking_vtbl = &IMediaSeeking_VTable;
2423     fimpl->IBasicAudio_vtbl = &IBasicAudio_VTable;
2424     fimpl->IBasicVideo_vtbl = &IBasicVideo_VTable;
2425     fimpl->IVideoWindow_vtbl = &IVideoWindow_VTable;
2426     fimpl->IMediaEventEx_vtbl = &IMediaEventEx_VTable;
2427     fimpl->IMediaFilter_vtbl = &IMediaFilter_VTable;
2428     fimpl->IMediaEventSink_vtbl = &IMediaEventSink_VTable;
2429     fimpl->ref = 1;
2430     fimpl->ppFiltersInGraph = NULL;
2431     fimpl->pFilterNames = NULL;
2432     fimpl->nFilters = 0;
2433     fimpl->filterCapacity = 0;
2434     fimpl->nameIndex = 1;
2435     fimpl->hEventCompletion = CreateEventW(0, TRUE, FALSE,0);
2436     fimpl->HandleEcComplete = TRUE;
2437     fimpl->HandleEcRepaint = TRUE;
2438     fimpl->notif.hWnd = 0;
2439     fimpl->notif.disabled = TRUE;
2440     fimpl->nRenderers = 0;
2441     fimpl->EcCompleteCount = 0;
2442     EventsQueue_Init(&fimpl->evqueue);
2443
2444     *ppObj = fimpl;
2445     return S_OK;
2446 }