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