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