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