dlls/quartz/filtergraph.c

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