dlls/quartz/filtergraph.c

   1 /*              DirectShow FilterGraph object (QUARTZ.DLL)
   2  *
   3  * Copyright 2002 Lionel Ulmer
   4  * Copyright 2004 Christian Costa
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <assert.h>
  22 #include <stdarg.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "winreg.h"
  30 #include "shlwapi.h"
  31 #include "dshow.h"
  32 #include "wine/debug.h"
  33 #include "quartz_private.h"
  34 #include "ole2.h"
  35 #include "olectl.h"
  36 #include "strmif.h"
  37 #include "vfwmsgs.h"
  38 #include "evcode.h"
  39 #include "wine/heap.h"
  40 #include "wine/list.h"
  41
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  44
  45 struct media_event
  46 {
  47     struct list entry;
  48     LONG code;
  49     LONG_PTR param1, param2;
  50 };
  51
  52 #define MAX_ITF_CACHE_ENTRIES 3
  53 typedef struct _ITF_CACHE_ENTRY {
  54    const IID* riid;
  55    IBaseFilter* filter;
  56    IUnknown* iface;
  57 } ITF_CACHE_ENTRY;
  58
  59 struct filter
  60 {
  61     struct list entry;
  62     IBaseFilter *filter;
  63     IMediaSeeking *seeking;
  64     WCHAR *name;
  65     BOOL sorting;
  66 };
  67
  68 struct filter_graph
  69 {
  70     IUnknown IUnknown_inner;
  71     IFilterGraph2 IFilterGraph2_iface;
  72     IMediaControl IMediaControl_iface;
  73     IMediaSeeking IMediaSeeking_iface;
  74     IBasicAudio IBasicAudio_iface;
  75     IBasicVideo2 IBasicVideo2_iface;
  76     IVideoWindow IVideoWindow_iface;
  77     IMediaEventEx IMediaEventEx_iface;
  78     IMediaFilter IMediaFilter_iface;
  79     IMediaEventSink IMediaEventSink_iface;
  80     IGraphConfig IGraphConfig_iface;
  81     IMediaPosition IMediaPosition_iface;
  82     IObjectWithSite IObjectWithSite_iface;
  83     IGraphVersion IGraphVersion_iface;
  84     /* IAMGraphStreams */
  85     /* IAMStats */
  86     /* IFilterChain */
  87     /* IFilterMapper2 */
  88     /* IQueueCommand */
  89     /* IRegisterServiceProvider */
  90     /* IResourceManager */
  91     /* IServiceProvider */
  92     IVideoFrameStep IVideoFrameStep_iface;
  93
  94     IUnknown *outer_unk;
  95     LONG ref;
  96     IUnknown *punkFilterMapper2;
  97
  98     struct list filters;
  99     unsigned int name_index;
 100
 101     OAFilterState state;
 102     TP_WORK *async_run_work;
 103
 104     IReferenceClock *refClock;
 105     IBaseFilter *refClockProvider;
 106
 107     /* We may indirectly wait for streaming threads while holding graph->cs in
 108      * IMediaFilter::Stop() or IMediaSeeking::SetPositions(). Since streaming
 109      * threads call IMediaEventSink::Notify() to queue EC_COMPLETE, we must
 110      * use a separate lock to avoid them deadlocking on graph->cs. */
 111     CRITICAL_SECTION event_cs;
 112     struct list media_events;
 113     HANDLE media_event_handle;
 114     HWND media_event_window;
 115     UINT media_event_message;
 116     LPARAM media_event_lparam;
 117     HANDLE hEventCompletion;
 118     int CompletionStatus;
 119     int nRenderers;
 120     int EcCompleteCount;
 121     int HandleEcComplete;
 122     int HandleEcRepaint;
 123     int HandleEcClockChanged;
 124     unsigned int got_ec_complete : 1;
 125     unsigned int media_events_disabled : 1;
 126
 127     CRITICAL_SECTION cs;
 128     ITF_CACHE_ENTRY ItfCacheEntries[MAX_ITF_CACHE_ENTRIES];
 129     int nItfCacheEntries;
 130     BOOL defaultclock;
 131     GUID timeformatseek;
 132     IUnknown *pSite;
 133     LONG version;
 134
 135     HANDLE message_thread, message_thread_ret;
 136     DWORD message_thread_id;
 137
 138     /* Respectively: the last timestamp at which we started streaming, and the
 139      * current offset within the stream. */
 140     REFERENCE_TIME stream_start, stream_elapsed;
 141     REFERENCE_TIME stream_stop;
 142     LONGLONG current_pos;
 143
 144     unsigned int needs_async_run : 1;
 145 };
 146
 147 struct enum_filters
 148 {
 149     IEnumFilters IEnumFilters_iface;
 150     LONG ref;
 151     struct filter_graph *graph;
 152     LONG version;
 153     struct list *cursor;
 154 };
 155
 156 static HRESULT create_enum_filters(struct filter_graph *graph, struct list *cursor, IEnumFilters **out);
 157
 158 static inline struct enum_filters *impl_from_IEnumFilters(IEnumFilters *iface)
 159 {
 160     return CONTAINING_RECORD(iface, struct enum_filters, IEnumFilters_iface);
 161 }
 162
 163 static HRESULT WINAPI EnumFilters_QueryInterface(IEnumFilters *iface, REFIID iid, void **out)
 164 {
 165     struct enum_filters *enum_filters = impl_from_IEnumFilters(iface);
 166     TRACE("enum_filters %p, iid %s, out %p.\n", enum_filters, qzdebugstr_guid(iid), out);
 167
 168     if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IEnumFilters))
 169     {
 170         IEnumFilters_AddRef(*out = iface);
 171         return S_OK;
 172     }
 173
 174     WARN("%s not implemented, returning E_NOINTERFACE.\n", qzdebugstr_guid(iid));
 175     *out = NULL;
 176     return E_NOINTERFACE;
 177 }
 178
 179 static ULONG WINAPI EnumFilters_AddRef(IEnumFilters *iface)
 180 {
 181     struct enum_filters *enum_filters = impl_from_IEnumFilters(iface);
 182     ULONG ref = InterlockedIncrement(&enum_filters->ref);
 183
 184     TRACE("%p increasing refcount to %u.\n", enum_filters, ref);
 185
 186     return ref;
 187 }
 188
 189 static ULONG WINAPI EnumFilters_Release(IEnumFilters *iface)
 190 {
 191     struct enum_filters *enum_filters = impl_from_IEnumFilters(iface);
 192     ULONG ref = InterlockedDecrement(&enum_filters->ref);
 193
 194     TRACE("%p decreasing refcount to %u.\n", enum_filters, ref);
 195
 196     if (!ref)
 197     {
 198         IUnknown_Release(enum_filters->graph->outer_unk);
 199         heap_free(enum_filters);
 200     }
 201
 202     return ref;
 203 }
 204
 205 static HRESULT WINAPI EnumFilters_Next(IEnumFilters *iface, ULONG count,
 206         IBaseFilter **filters, ULONG *fetched)
 207 {
 208     struct enum_filters *enum_filters = impl_from_IEnumFilters(iface);
 209     unsigned int i = 0;
 210
 211     TRACE("enum_filters %p, count %u, filters %p, fetched %p.\n",
 212             enum_filters, count, filters, fetched);
 213
 214     if (enum_filters->version != enum_filters->graph->version)
 215         return VFW_E_ENUM_OUT_OF_SYNC;
 216
 217     if (!filters)
 218         return E_POINTER;
 219
 220     for (i = 0; i < count; ++i)
 221     {
 222         struct filter *filter = LIST_ENTRY(enum_filters->cursor, struct filter, entry);
 223
 224         if (!enum_filters->cursor)
 225             break;
 226
 227         IBaseFilter_AddRef(filters[i] = filter->filter);
 228         enum_filters->cursor = list_next(&enum_filters->graph->filters, enum_filters->cursor);
 229     }
 230
 231     if (fetched)
 232         *fetched = i;
 233
 234     return (i == count) ? S_OK : S_FALSE;
 235 }
 236
 237 static HRESULT WINAPI EnumFilters_Skip(IEnumFilters *iface, ULONG count)
 238 {
 239     struct enum_filters *enum_filters = impl_from_IEnumFilters(iface);
 240
 241     TRACE("enum_filters %p, count %u.\n", enum_filters, count);
 242
 243     if (enum_filters->version != enum_filters->graph->version)
 244         return VFW_E_ENUM_OUT_OF_SYNC;
 245
 246     if (!enum_filters->cursor)
 247         return E_INVALIDARG;
 248
 249     while (count--)
 250     {
 251         if (!(enum_filters->cursor = list_next(&enum_filters->graph->filters, enum_filters->cursor)))
 252             return count ? S_FALSE : S_OK;
 253     }
 254
 255     return S_OK;
 256 }
 257
 258 static HRESULT WINAPI EnumFilters_Reset(IEnumFilters *iface)
 259 {
 260     struct enum_filters *enum_filters = impl_from_IEnumFilters(iface);
 261
 262     TRACE("enum_filters %p.\n", enum_filters);
 263
 264     enum_filters->cursor = list_head(&enum_filters->graph->filters);
 265     enum_filters->version = enum_filters->graph->version;
 266     return S_OK;
 267 }
 268
 269 static HRESULT WINAPI EnumFilters_Clone(IEnumFilters *iface, IEnumFilters **out)
 270 {
 271     struct enum_filters *enum_filters = impl_from_IEnumFilters(iface);
 272
 273     TRACE("enum_filters %p, out %p.\n", enum_filters, out);
 274
 275     return create_enum_filters(enum_filters->graph, enum_filters->cursor, out);
 276 }
 277
 278 static const IEnumFiltersVtbl EnumFilters_vtbl =
 279 {
 280     EnumFilters_QueryInterface,
 281     EnumFilters_AddRef,
 282     EnumFilters_Release,
 283     EnumFilters_Next,
 284     EnumFilters_Skip,
 285     EnumFilters_Reset,
 286     EnumFilters_Clone,
 287 };
 288
 289 static HRESULT create_enum_filters(struct filter_graph *graph, struct list *cursor, IEnumFilters **out)
 290 {
 291     struct enum_filters *enum_filters;
 292
 293     if (!(enum_filters = heap_alloc(sizeof(*enum_filters))))
 294         return E_OUTOFMEMORY;
 295
 296     enum_filters->IEnumFilters_iface.lpVtbl = &EnumFilters_vtbl;
 297     enum_filters->ref = 1;
 298     enum_filters->cursor = cursor;
 299     enum_filters->graph = graph;
 300     IUnknown_AddRef(graph->outer_unk);
 301     enum_filters->version = graph->version;
 302
 303     *out = &enum_filters->IEnumFilters_iface;
 304     return S_OK;
 305 }
 306
 307 static BOOL queue_media_event(struct filter_graph *graph, LONG code,
 308         LONG_PTR param1, LONG_PTR param2)
 309 {
 310     struct media_event *event;
 311
 312     if (!(event = malloc(sizeof(*event))))
 313         return FALSE;
 314
 315     event->code = code;
 316     event->param1 = param1;
 317     event->param2 = param2;
 318     list_add_tail(&graph->media_events, &event->entry);
 319
 320     SetEvent(graph->media_event_handle);
 321     if (graph->media_event_window)
 322         PostMessageW(graph->media_event_window, graph->media_event_message, 0, graph->media_event_lparam);
 323
 324     return TRUE;
 325 }
 326
 327 static void flush_media_events(struct filter_graph *graph)
 328 {
 329     struct list *cursor;
 330
 331     while ((cursor = list_head(&graph->media_events)))
 332     {
 333         struct media_event *event = LIST_ENTRY(cursor, struct media_event, entry);
 334
 335         list_remove(&event->entry);
 336         free(event);
 337     }
 338 }
 339
 340 static struct filter_graph *impl_from_IUnknown(IUnknown *iface)
 341 {
 342     return CONTAINING_RECORD(iface, struct filter_graph, IUnknown_inner);
 343 }
 344
 345 static HRESULT WINAPI FilterGraphInner_QueryInterface(IUnknown *iface, REFIID riid, void **ppvObj)
 346 {
 347     struct filter_graph *This = impl_from_IUnknown(iface);
 348     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObj);
 349
 350     if (IsEqualGUID(&IID_IUnknown, riid)) {
 351         *ppvObj = &This->IUnknown_inner;
 352         TRACE("   returning IUnknown interface (%p)\n", *ppvObj);
 353     } else if (IsEqualGUID(&IID_IFilterGraph, riid) ||
 354         IsEqualGUID(&IID_IFilterGraph2, riid) ||
 355         IsEqualGUID(&IID_IGraphBuilder, riid)) {
 356         *ppvObj = &This->IFilterGraph2_iface;
 357         TRACE("   returning IGraphBuilder interface (%p)\n", *ppvObj);
 358     } else if (IsEqualGUID(&IID_IMediaControl, riid)) {
 359         *ppvObj = &This->IMediaControl_iface;
 360         TRACE("   returning IMediaControl interface (%p)\n", *ppvObj);
 361     } else if (IsEqualGUID(&IID_IMediaSeeking, riid)) {
 362         *ppvObj = &This->IMediaSeeking_iface;
 363         TRACE("   returning IMediaSeeking interface (%p)\n", *ppvObj);
 364     } else if (IsEqualGUID(&IID_IBasicAudio, riid)) {
 365         *ppvObj = &This->IBasicAudio_iface;
 366         TRACE("   returning IBasicAudio interface (%p)\n", *ppvObj);
 367     } else if (IsEqualGUID(&IID_IBasicVideo, riid) ||
 368                IsEqualGUID(&IID_IBasicVideo2, riid)) {
 369         *ppvObj = &This->IBasicVideo2_iface;
 370         TRACE("   returning IBasicVideo2 interface (%p)\n", *ppvObj);
 371     } else if (IsEqualGUID(&IID_IVideoWindow, riid)) {
 372         *ppvObj = &This->IVideoWindow_iface;
 373         TRACE("   returning IVideoWindow interface (%p)\n", *ppvObj);
 374     } else if (IsEqualGUID(&IID_IMediaEvent, riid) ||
 375            IsEqualGUID(&IID_IMediaEventEx, riid)) {
 376         *ppvObj = &This->IMediaEventEx_iface;
 377         TRACE("   returning IMediaEvent(Ex) interface (%p)\n", *ppvObj);
 378     } else if (IsEqualGUID(&IID_IMediaFilter, riid) ||
 379           IsEqualGUID(&IID_IPersist, riid)) {
 380         *ppvObj = &This->IMediaFilter_iface;
 381         TRACE("   returning IMediaFilter interface (%p)\n", *ppvObj);
 382     } else if (IsEqualGUID(&IID_IMediaEventSink, riid)) {
 383         *ppvObj = &This->IMediaEventSink_iface;
 384         TRACE("   returning IMediaEventSink interface (%p)\n", *ppvObj);
 385     } else if (IsEqualGUID(&IID_IGraphConfig, riid)) {
 386         *ppvObj = &This->IGraphConfig_iface;
 387         TRACE("   returning IGraphConfig interface (%p)\n", *ppvObj);
 388     } else if (IsEqualGUID(&IID_IMediaPosition, riid)) {
 389         *ppvObj = &This->IMediaPosition_iface;
 390         TRACE("   returning IMediaPosition interface (%p)\n", *ppvObj);
 391     } else if (IsEqualGUID(&IID_IObjectWithSite, riid)) {
 392         *ppvObj = &This->IObjectWithSite_iface;
 393         TRACE("   returning IObjectWithSite interface (%p)\n", *ppvObj);
 394     } else if (IsEqualGUID(&IID_IFilterMapper, riid)) {
 395         TRACE("   requesting IFilterMapper interface from aggregated filtermapper (%p)\n", *ppvObj);
 396         return IUnknown_QueryInterface(This->punkFilterMapper2, riid, ppvObj);
 397     } else if (IsEqualGUID(&IID_IFilterMapper2, riid)) {
 398         TRACE("   returning IFilterMapper2 interface from aggregated filtermapper (%p)\n", *ppvObj);
 399         return IUnknown_QueryInterface(This->punkFilterMapper2, riid, ppvObj);
 400     } else if (IsEqualGUID(&IID_IFilterMapper3, riid)) {
 401         TRACE("   returning IFilterMapper3 interface from aggregated filtermapper (%p)\n", *ppvObj);
 402         return IUnknown_QueryInterface(This->punkFilterMapper2, riid, ppvObj);
 403     } else if (IsEqualGUID(&IID_IGraphVersion, riid)) {
 404         *ppvObj = &This->IGraphVersion_iface;
 405         TRACE("   returning IGraphVersion interface (%p)\n", *ppvObj);
 406     } else if (IsEqualGUID(&IID_IVideoFrameStep, riid)) {
 407         *ppvObj = &This->IVideoFrameStep_iface;
 408         TRACE("   returning IVideoFrameStep interface (%p)\n", *ppvObj);
 409     } else {
 410         *ppvObj = NULL;
 411         FIXME("unknown interface %s\n", debugstr_guid(riid));
 412         return E_NOINTERFACE;
 413     }
 414
 415     IUnknown_AddRef((IUnknown *)*ppvObj);
 416     return S_OK;
 417 }
 418
 419 static ULONG WINAPI FilterGraphInner_AddRef(IUnknown *iface)
 420 {
 421     struct filter_graph *This = impl_from_IUnknown(iface);
 422     ULONG ref = InterlockedIncrement(&This->ref);
 423
 424     TRACE("(%p)->(): new ref = %d\n", This, ref);
 425
 426     return ref;
 427 }
 428
 429 static ULONG WINAPI FilterGraphInner_Release(IUnknown *iface)
 430 {
 431     struct filter_graph *This = impl_from_IUnknown(iface);
 432     ULONG ref = InterlockedDecrement(&This->ref);
 433     struct list *cursor;
 434
 435     TRACE("(%p)->(): new ref = %d\n", This, ref);
 436
 437     if (ref == 0) {
 438         int i;
 439
 440         This->ref = 1; /* guard against reentrancy (aggregation). */
 441
 442         IMediaControl_Stop(&This->IMediaControl_iface);
 443
 444         while ((cursor = list_head(&This->filters)))
 445         {
 446             struct filter *filter = LIST_ENTRY(cursor, struct filter, entry);
 447
 448             IFilterGraph2_RemoveFilter(&This->IFilterGraph2_iface, filter->filter);
 449         }
 450
 451         if (This->refClock)
 452             IReferenceClock_Release(This->refClock);
 453
 454         for (i = 0; i < This->nItfCacheEntries; i++)
 455         {
 456             if (This->ItfCacheEntries[i].iface)
 457                 IUnknown_Release(This->ItfCacheEntries[i].iface);
 458         }
 459
 460         IUnknown_Release(This->punkFilterMapper2);
 461
 462         if (This->pSite) IUnknown_Release(This->pSite);
 463
 464         flush_media_events(This);
 465         CloseHandle(This->media_event_handle);
 466
 467         This->cs.DebugInfo->Spare[0] = 0;
 468         if (This->message_thread)
 469         {
 470             PostThreadMessageW(This->message_thread_id, WM_USER + 1, 0, 0);
 471             WaitForSingleObject(This->message_thread, INFINITE);
 472             CloseHandle(This->message_thread);
 473             CloseHandle(This->message_thread_ret);
 474         }
 475         DeleteCriticalSection(&This->event_cs);
 476         DeleteCriticalSection(&This->cs);
 477         free(This);
 478
 479         InterlockedDecrement(&object_locks);
 480     }
 481     return ref;
 482 }
 483
 484 static struct filter_graph *impl_from_IFilterGraph2(IFilterGraph2 *iface)
 485 {
 486     return CONTAINING_RECORD(iface, struct filter_graph, IFilterGraph2_iface);
 487 }
 488
 489 static HRESULT WINAPI FilterGraph2_QueryInterface(IFilterGraph2 *iface, REFIID iid, void **out)
 490 {
 491     struct filter_graph *graph = impl_from_IFilterGraph2(iface);
 492     return IUnknown_QueryInterface(graph->outer_unk, iid, out);
 493 }
 494
 495 static ULONG WINAPI FilterGraph2_AddRef(IFilterGraph2 *iface)
 496 {
 497     struct filter_graph *graph = impl_from_IFilterGraph2(iface);
 498     return IUnknown_AddRef(graph->outer_unk);
 499 }
 500
 501 static ULONG WINAPI FilterGraph2_Release(IFilterGraph2 *iface)
 502 {
 503     struct filter_graph *graph = impl_from_IFilterGraph2(iface);
 504     return IUnknown_Release(graph->outer_unk);
 505 }
 506
 507 static IBaseFilter *find_filter_by_name(struct filter_graph *graph, const WCHAR *name)
 508 {
 509     struct filter *filter;
 510
 511     LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
 512     {
 513         if (!wcscmp(filter->name, name))
 514             return filter->filter;
 515     }
 516
 517     return NULL;
 518 }
 519
 520 static BOOL has_output_pins(IBaseFilter *filter)
 521 {
 522     IEnumPins *enumpins;
 523     PIN_DIRECTION dir;
 524     IPin *pin;
 525
 526     if (FAILED(IBaseFilter_EnumPins(filter, &enumpins)))
 527         return FALSE;
 528
 529     while (IEnumPins_Next(enumpins, 1, &pin, NULL) == S_OK)
 530     {
 531         IPin_QueryDirection(pin, &dir);
 532         IPin_Release(pin);
 533         if (dir == PINDIR_OUTPUT)
 534         {
 535             IEnumPins_Release(enumpins);
 536             return TRUE;
 537         }
 538     }
 539
 540     IEnumPins_Release(enumpins);
 541     return FALSE;
 542 }
 543
 544 static void update_seeking(struct filter *filter)
 545 {
 546     IMediaSeeking *seeking;
 547
 548     if (!filter->seeking)
 549     {
 550         /* The Legend of Heroes: Trails of Cold Steel II destroys its filter when
 551          * its IMediaSeeking interface is released, so cache the interface instead
 552          * of querying for it every time.
 553          * Some filters (e.g. MediaStreamFilter) can become seekable when they are
 554          * already in the graph, so always try to query IMediaSeeking if it's not
 555          * cached yet. */
 556         if (SUCCEEDED(IBaseFilter_QueryInterface(filter->filter, &IID_IMediaSeeking, (void **)&seeking)))
 557         {
 558             if (IMediaSeeking_IsFormatSupported(seeking, &TIME_FORMAT_MEDIA_TIME) == S_OK)
 559                 filter->seeking = seeking;
 560             else
 561                 IMediaSeeking_Release(seeking);
 562         }
 563     }
 564 }
 565
 566 static BOOL is_renderer(struct filter *filter)
 567 {
 568     IMediaPosition *media_position;
 569     IAMFilterMiscFlags *flags;
 570     BOOL ret = FALSE;
 571
 572     if (SUCCEEDED(IBaseFilter_QueryInterface(filter->filter, &IID_IAMFilterMiscFlags, (void **)&flags)))
 573     {
 574         if (IAMFilterMiscFlags_GetMiscFlags(flags) & AM_FILTER_MISC_FLAGS_IS_RENDERER)
 575             ret = TRUE;
 576         IAMFilterMiscFlags_Release(flags);
 577     }
 578     else if (SUCCEEDED(IBaseFilter_QueryInterface(filter->filter, &IID_IMediaPosition, (void **)&media_position)))
 579     {
 580         if (!has_output_pins(filter->filter))
 581             ret = TRUE;
 582         IMediaPosition_Release(media_position);
 583     }
 584     else
 585     {
 586         update_seeking(filter);
 587         if (filter->seeking && !has_output_pins(filter->filter))
 588             ret = TRUE;
 589     }
 590     return ret;
 591 }
 592
 593 /*** IFilterGraph methods ***/
 594 static HRESULT WINAPI FilterGraph2_AddFilter(IFilterGraph2 *iface,
 595         IBaseFilter *filter, const WCHAR *name)
 596 {
 597     struct filter_graph *graph = impl_from_IFilterGraph2(iface);
 598     BOOL duplicate_name = FALSE;
 599     struct filter *entry;
 600     unsigned int i;
 601     HRESULT hr;
 602
 603     TRACE("graph %p, filter %p, name %s.\n", graph, filter, debugstr_w(name));
 604
 605     if (!filter)
 606         return E_POINTER;
 607
 608     if (!(entry = heap_alloc(sizeof(*entry))))
 609         return E_OUTOFMEMORY;
 610
 611     if (!(entry->name = CoTaskMemAlloc((name ? wcslen(name) + 6 : 5) * sizeof(WCHAR))))
 612     {
 613         heap_free(entry);
 614         return E_OUTOFMEMORY;
 615     }
 616
 617     if (name && find_filter_by_name(graph, name))
 618         duplicate_name = TRUE;
 619
 620     if (!name || duplicate_name)
 621     {
 622         for (i = 0; i < 10000 ; ++i)
 623         {
 624             if (name)
 625                 swprintf(entry->name, name ? wcslen(name) + 6 : 5, L"%s %04u", name, graph->name_index);
 626             else
 627                 swprintf(entry->name, name ? wcslen(name) + 6 : 5, L"%04u", graph->name_index);
 628
 629             graph->name_index = (graph->name_index + 1) % 10000;
 630
 631             if (!find_filter_by_name(graph, entry->name))
 632                 break;
 633         }
 634
 635         if (i == 10000)
 636         {
 637             CoTaskMemFree(entry->name);
 638             heap_free(entry);
 639             return VFW_E_DUPLICATE_NAME;
 640         }
 641     }
 642     else
 643         wcscpy(entry->name, name);
 644
 645     if (FAILED(hr = IBaseFilter_JoinFilterGraph(filter,
 646             (IFilterGraph *)&graph->IFilterGraph2_iface, entry->name)))
 647     {
 648         CoTaskMemFree(entry->name);
 649         heap_free(entry);
 650         return hr;
 651     }
 652
 653     IBaseFilter_AddRef(entry->filter = filter);
 654
 655     list_add_head(&graph->filters, &entry->entry);
 656     entry->sorting = FALSE;
 657     entry->seeking = NULL;
 658     ++graph->version;
 659
 660     return duplicate_name ? VFW_S_DUPLICATE_NAME : hr;
 661 }
 662
 663 static HRESULT WINAPI FilterGraph2_RemoveFilter(IFilterGraph2 *iface, IBaseFilter *pFilter)
 664 {
 665     struct filter_graph *This = impl_from_IFilterGraph2(iface);
 666     struct filter *entry;
 667     int i;
 668     HRESULT hr = E_FAIL;
 669
 670     TRACE("(%p/%p)->(%p)\n", This, iface, pFilter);
 671
 672     LIST_FOR_EACH_ENTRY(entry, &This->filters, struct filter, entry)
 673     {
 674         if (entry->filter == pFilter)
 675         {
 676             IEnumPins *penumpins = NULL;
 677
 678             if (This->defaultclock && This->refClockProvider == pFilter)
 679             {
 680                 IMediaFilter_SetSyncSource(&This->IMediaFilter_iface, NULL);
 681                 This->defaultclock = TRUE;
 682             }
 683
 684             TRACE("Removing filter %s.\n", debugstr_w(entry->name));
 685
 686             hr = IBaseFilter_EnumPins(pFilter, &penumpins);
 687             if (SUCCEEDED(hr)) {
 688                 IPin *ppin;
 689                 while(IEnumPins_Next(penumpins, 1, &ppin, NULL) == S_OK)
 690                 {
 691                     IPin *peer = NULL;
 692                     HRESULT hr;
 693
 694                     IPin_ConnectedTo(ppin, &peer);
 695                     if (peer)
 696                     {
 697                         if (FAILED(hr = IPin_Disconnect(peer)))
 698                         {
 699                             WARN("Failed to disconnect peer %p, hr %#x.\n", peer, hr);
 700                             IPin_Release(peer);
 701                             IPin_Release(ppin);
 702                             IEnumPins_Release(penumpins);
 703                             return hr;
 704                         }
 705                         IPin_Release(peer);
 706
 707                         if (FAILED(hr = IPin_Disconnect(ppin)))
 708                         {
 709                             WARN("Failed to disconnect pin %p, hr %#x.\n", ppin, hr);
 710                             IPin_Release(ppin);
 711                             IEnumPins_Release(penumpins);
 712                             return hr;
 713                         }
 714                     }
 715                     IPin_Release(ppin);
 716                 }
 717                 IEnumPins_Release(penumpins);
 718             }
 719
 720             hr = IBaseFilter_JoinFilterGraph(pFilter, NULL, NULL);
 721             if (SUCCEEDED(hr))
 722             {
 723                 IBaseFilter_SetSyncSource(pFilter, NULL);
 724                 IBaseFilter_Release(pFilter);
 725                 if (entry->seeking)
 726                     IMediaSeeking_Release(entry->seeking);
 727                 list_remove(&entry->entry);
 728                 CoTaskMemFree(entry->name);
 729                 heap_free(entry);
 730                 This->version++;
 731                 /* Invalidate interfaces in the cache */
 732                 for (i = 0; i < This->nItfCacheEntries; i++)
 733                     if (pFilter == This->ItfCacheEntries[i].filter)
 734                     {
 735                         IUnknown_Release(This->ItfCacheEntries[i].iface);
 736                         This->ItfCacheEntries[i].iface = NULL;
 737                         This->ItfCacheEntries[i].filter = NULL;
 738                     }
 739                 return S_OK;
 740             }
 741             break;
 742         }
 743     }
 744
 745     return hr; /* FIXME: check this error code */
 746 }
 747
 748 static HRESULT WINAPI FilterGraph2_EnumFilters(IFilterGraph2 *iface, IEnumFilters **out)
 749 {
 750     struct filter_graph *graph = impl_from_IFilterGraph2(iface);
 751
 752     TRACE("graph %p, out %p.\n", graph, out);
 753
 754     return create_enum_filters(graph, list_head(&graph->filters), out);
 755 }
 756
 757 static HRESULT WINAPI FilterGraph2_FindFilterByName(IFilterGraph2 *iface,
 758         const WCHAR *name, IBaseFilter **filter)
 759 {
 760     struct filter_graph *graph = impl_from_IFilterGraph2(iface);
 761
 762     TRACE("graph %p, name %s, filter %p.\n", graph, debugstr_w(name), filter);
 763
 764     if (!filter)
 765         return E_POINTER;
 766
 767     if ((*filter = find_filter_by_name(graph, name)))
 768     {
 769         IBaseFilter_AddRef(*filter);
 770         return S_OK;
 771     }
 772
 773     return VFW_E_NOT_FOUND;
 774 }
 775
 776 /* Don't allow a circular connection to form, return VFW_E_CIRCULAR_GRAPH if this would be the case.
 777  * A circular connection will be formed if from the filter of the output pin, the input pin can be reached
 778  */
 779 static HRESULT CheckCircularConnection(struct filter_graph *This, IPin *out, IPin *in)
 780 {
 781 #if 1
 782     HRESULT hr;
 783     PIN_INFO info_out, info_in;
 784
 785     hr = IPin_QueryPinInfo(out, &info_out);
 786     if (FAILED(hr))
 787         return hr;
 788     if (info_out.dir != PINDIR_OUTPUT)
 789     {
 790         IBaseFilter_Release(info_out.pFilter);
 791         return VFW_E_CANNOT_CONNECT;
 792     }
 793
 794     hr = IPin_QueryPinInfo(in, &info_in);
 795     if (SUCCEEDED(hr))
 796         IBaseFilter_Release(info_in.pFilter);
 797     if (FAILED(hr))
 798         goto out;
 799     if (info_in.dir != PINDIR_INPUT)
 800     {
 801         hr = VFW_E_CANNOT_CONNECT;
 802         goto out;
 803     }
 804
 805     if (info_out.pFilter == info_in.pFilter)
 806         hr = VFW_E_CIRCULAR_GRAPH;
 807     else
 808     {
 809         IEnumPins *enumpins;
 810         IPin *test;
 811
 812         hr = IBaseFilter_EnumPins(info_out.pFilter, &enumpins);
 813         if (FAILED(hr))
 814             goto out;
 815
 816         IEnumPins_Reset(enumpins);
 817         while ((hr = IEnumPins_Next(enumpins, 1, &test, NULL)) == S_OK)
 818         {
 819             PIN_DIRECTION dir = PINDIR_OUTPUT;
 820             IPin_QueryDirection(test, &dir);
 821             if (dir == PINDIR_INPUT)
 822             {
 823                 IPin *victim = NULL;
 824                 IPin_ConnectedTo(test, &victim);
 825                 if (victim)
 826                 {
 827                     hr = CheckCircularConnection(This, victim, in);
 828                     IPin_Release(victim);
 829                     if (FAILED(hr))
 830                     {
 831                         IPin_Release(test);
 832                         break;
 833                     }
 834                 }
 835             }
 836             IPin_Release(test);
 837         }
 838         IEnumPins_Release(enumpins);
 839     }
 840
 841 out:
 842     IBaseFilter_Release(info_out.pFilter);
 843     if (FAILED(hr))
 844         ERR("Checking filtergraph returned %08x, something's not right!\n", hr);
 845     return hr;
 846 #else
 847     /* Debugging filtergraphs not enabled */
 848     return S_OK;
 849 #endif
 850 }
 851
 852 static struct filter *find_sorted_filter(struct filter_graph *graph, IBaseFilter *iface)
 853 {
 854     struct filter *filter;
 855
 856     LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
 857     {
 858         if (filter->filter == iface)
 859             return filter;
 860     }
 861
 862     return NULL;
 863 }
 864
 865 static void sort_filter_recurse(struct filter_graph *graph, struct filter *filter, struct list *sorted)
 866 {
 867     struct filter *peer_filter;
 868     IEnumPins *enumpins;
 869     PIN_DIRECTION dir;
 870     IPin *pin, *peer;
 871     PIN_INFO info;
 872
 873     TRACE("Sorting filter %p.\n", filter->filter);
 874
 875     /* Cyclic connections should be caught by CheckCircularConnection(). */
 876     assert(!filter->sorting);
 877
 878     filter->sorting = TRUE;
 879
 880     IBaseFilter_EnumPins(filter->filter, &enumpins);
 881     while (IEnumPins_Next(enumpins, 1, &pin, NULL) == S_OK)
 882     {
 883         IPin_QueryDirection(pin, &dir);
 884
 885         if (dir == PINDIR_INPUT && IPin_ConnectedTo(pin, &peer) == S_OK)
 886         {
 887             IPin_QueryPinInfo(peer, &info);
 888             /* Note that the filter may have already been sorted. */
 889             if ((peer_filter = find_sorted_filter(graph, info.pFilter)))
 890                 sort_filter_recurse(graph, peer_filter, sorted);
 891             IBaseFilter_Release(info.pFilter);
 892             IPin_Release(peer);
 893         }
 894         IPin_Release(pin);
 895     }
 896     IEnumPins_Release(enumpins);
 897
 898     filter->sorting = FALSE;
 899
 900     list_remove(&filter->entry);
 901     list_add_head(sorted, &filter->entry);
 902 }
 903
 904 static void sort_filters(struct filter_graph *graph)
 905 {
 906     struct list sorted = LIST_INIT(sorted), *cursor;
 907
 908     while ((cursor = list_head(&graph->filters)))
 909     {
 910         struct filter *filter = LIST_ENTRY(cursor, struct filter, entry);
 911         sort_filter_recurse(graph, filter, &sorted);
 912     }
 913
 914     list_move_tail(&graph->filters, &sorted);
 915 }
 916
 917 /* NOTE: despite the implication, it doesn't matter which
 918  * way round you put in the input and output pins */
 919 static HRESULT WINAPI FilterGraph2_ConnectDirect(IFilterGraph2 *iface, IPin *ppinIn, IPin *ppinOut,
 920         const AM_MEDIA_TYPE *pmt)
 921 {
 922     struct filter_graph *This = impl_from_IFilterGraph2(iface);
 923     PIN_DIRECTION dir;
 924     HRESULT hr;
 925
 926     TRACE("(%p/%p)->(%p, %p, %p)\n", This, iface, ppinIn, ppinOut, pmt);
 927     strmbase_dump_media_type(pmt);
 928
 929     /* FIXME: check pins are in graph */
 930
 931     if (TRACE_ON(quartz))
 932     {
 933         PIN_INFO PinInfo;
 934
 935         hr = IPin_QueryPinInfo(ppinIn, &PinInfo);
 936         if (FAILED(hr))
 937             return hr;
 938
 939         TRACE("Filter owning ppinIn(%p) => %p\n", ppinIn, PinInfo.pFilter);
 940         IBaseFilter_Release(PinInfo.pFilter);
 941
 942         hr = IPin_QueryPinInfo(ppinOut, &PinInfo);
 943         if (FAILED(hr))
 944             return hr;
 945
 946         TRACE("Filter owning ppinOut(%p) => %p\n", ppinOut, PinInfo.pFilter);
 947         IBaseFilter_Release(PinInfo.pFilter);
 948     }
 949
 950     hr = IPin_QueryDirection(ppinIn, &dir);
 951     if (SUCCEEDED(hr))
 952     {
 953         if (dir == PINDIR_INPUT)
 954         {
 955             hr = CheckCircularConnection(This, ppinOut, ppinIn);
 956             if (SUCCEEDED(hr))
 957                 hr = IPin_Connect(ppinOut, ppinIn, pmt);
 958         }
 959         else
 960         {
 961             hr = CheckCircularConnection(This, ppinIn, ppinOut);
 962             if (SUCCEEDED(hr))
 963                 hr = IPin_Connect(ppinIn, ppinOut, pmt);
 964         }
 965     }
 966
 967     return hr;
 968 }
 969
 970 static HRESULT WINAPI FilterGraph2_Reconnect(IFilterGraph2 *iface, IPin *pin)
 971 {
 972     struct filter_graph *graph = impl_from_IFilterGraph2(iface);
 973
 974     TRACE("graph %p, pin %p.\n", graph, pin);
 975
 976     return IFilterGraph2_ReconnectEx(iface, pin, NULL);
 977 }
 978
 979 static HRESULT WINAPI FilterGraph2_Disconnect(IFilterGraph2 *iface, IPin *ppin)
 980 {
 981     struct filter_graph *This = impl_from_IFilterGraph2(iface);
 982
 983     TRACE("(%p/%p)->(%p)\n", This, iface, ppin);
 984
 985     if (!ppin)
 986        return E_POINTER;
 987
 988     return IPin_Disconnect(ppin);
 989 }
 990
 991 static HRESULT WINAPI FilterGraph2_SetDefaultSyncSource(IFilterGraph2 *iface)
 992 {
 993     struct filter_graph *This = impl_from_IFilterGraph2(iface);
 994     IReferenceClock *pClock = NULL;
 995     struct filter *filter;
 996     HRESULT hr = S_OK;
 997
 998     TRACE("(%p/%p)->() live sources not handled properly!\n", This, iface);
 999
1000     EnterCriticalSection(&This->cs);
1001
1002     LIST_FOR_EACH_ENTRY(filter, &This->filters, struct filter, entry)
1003     {
1004         if (IBaseFilter_QueryInterface(filter->filter, &IID_IReferenceClock, (void **)&pClock) == S_OK)
1005             break;
1006     }
1007
1008     if (!pClock)
1009     {
1010         hr = CoCreateInstance(&CLSID_SystemClock, NULL, CLSCTX_INPROC_SERVER, &IID_IReferenceClock, (LPVOID*)&pClock);
1011         This->refClockProvider = NULL;
1012     }
1013     else
1014     {
1015         filter = LIST_ENTRY(list_tail(&This->filters), struct filter, entry);
1016         This->refClockProvider = filter->filter;
1017     }
1018
1019     if (SUCCEEDED(hr))
1020     {
1021         hr = IMediaFilter_SetSyncSource(&This->IMediaFilter_iface, pClock);
1022         This->defaultclock = TRUE;
1023         IReferenceClock_Release(pClock);
1024     }
1025     LeaveCriticalSection(&This->cs);
1026
1027     return hr;
1028 }
1029
1030 struct filter_create_params
1031 {
1032     HRESULT hr;
1033     IMoniker *moniker;
1034     IBaseFilter *filter;
1035 };
1036
1037 static DWORD WINAPI message_thread_run(void *ctx)
1038 {
1039     struct filter_graph *graph = ctx;
1040     MSG msg;
1041
1042     /* Make sure we have a message queue. */
1043     PeekMessageW(&msg, NULL, 0, 0, PM_NOREMOVE);
1044     SetEvent(graph->message_thread_ret);
1045
1046     CoInitializeEx(NULL, COINIT_MULTITHREADED);
1047
1048     for (;;)
1049     {
1050         GetMessageW(&msg, NULL, 0, 0);
1051
1052         if (!msg.hwnd && msg.message == WM_USER)
1053         {
1054             struct filter_create_params *params = (struct filter_create_params *)msg.wParam;
1055
1056             params->hr = IMoniker_BindToObject(params->moniker, NULL, NULL,
1057                     &IID_IBaseFilter, (void **)&params->filter);
1058             SetEvent(graph->message_thread_ret);
1059         }
1060         else if (!msg.hwnd && msg.message == WM_USER + 1)
1061         {
1062             break;
1063         }
1064         else
1065         {
1066             TranslateMessage(&msg);
1067             DispatchMessageW(&msg);
1068         }
1069     }
1070
1071     CoUninitialize();
1072     return 0;
1073 }
1074
1075 static HRESULT create_filter(struct filter_graph *graph, IMoniker *moniker, IBaseFilter **filter)
1076 {
1077     if (graph->message_thread)
1078     {
1079         struct filter_create_params params;
1080
1081         params.moniker = moniker;
1082         PostThreadMessageW(graph->message_thread_id, WM_USER, (WPARAM)&params, 0);
1083         WaitForSingleObject(graph->message_thread_ret, INFINITE);
1084         *filter = params.filter;
1085         return params.hr;
1086     }
1087     else
1088         return IMoniker_BindToObject(moniker, NULL, NULL, &IID_IBaseFilter, (void **)filter);
1089 }
1090
1091 static HRESULT autoplug(struct filter_graph *graph, IPin *source, IPin *sink,
1092         BOOL render_to_existing, unsigned int recursion_depth);
1093
1094 static HRESULT autoplug_through_sink(struct filter_graph *graph, IPin *source,
1095         IBaseFilter *filter, IPin *middle_sink, IPin *sink,
1096         BOOL render_to_existing, unsigned int recursion_depth)
1097 {
1098     BOOL any = FALSE, all = TRUE;
1099     IPin *middle_source, *peer;
1100     IEnumPins *source_enum;
1101     PIN_DIRECTION dir;
1102     PIN_INFO info;
1103     HRESULT hr;
1104
1105     TRACE("Trying to autoplug %p to %p through %p.\n", source, sink, middle_sink);
1106
1107     IPin_QueryDirection(middle_sink, &dir);
1108     if (dir != PINDIR_INPUT)
1109         return E_FAIL;
1110
1111     if (IPin_ConnectedTo(middle_sink, &peer) == S_OK)
1112     {
1113         IPin_Release(peer);
1114         return E_FAIL;
1115     }
1116
1117     if (FAILED(hr = IFilterGraph2_ConnectDirect(&graph->IFilterGraph2_iface, source, middle_sink, NULL)))
1118         return E_FAIL;
1119
1120     if (FAILED(hr = IBaseFilter_EnumPins(filter, &source_enum)))
1121         goto err;
1122
1123     while (IEnumPins_Next(source_enum, 1, &middle_source, NULL) == S_OK)
1124     {
1125         IPin_QueryPinInfo(middle_source, &info);
1126         IBaseFilter_Release(info.pFilter);
1127         if (info.dir != PINDIR_OUTPUT)
1128         {
1129             IPin_Release(middle_source);
1130             continue;
1131         }
1132         if (info.achName[0] == '~')
1133         {
1134             TRACE("Skipping non-rendered pin %s.\n", debugstr_w(info.achName));
1135             IPin_Release(middle_source);
1136             continue;
1137         }
1138         if (IPin_ConnectedTo(middle_source, &peer) == S_OK)
1139         {
1140             IPin_Release(peer);
1141             IPin_Release(middle_source);
1142             continue;
1143         }
1144
1145         hr = autoplug(graph, middle_source, sink, render_to_existing, recursion_depth + 1);
1146         IPin_Release(middle_source);
1147         if (SUCCEEDED(hr) && sink)
1148         {
1149             IEnumPins_Release(source_enum);
1150             return hr;
1151         }
1152         if (SUCCEEDED(hr))
1153             any = TRUE;
1154         if (hr != S_OK)
1155             all = FALSE;
1156     }
1157     IEnumPins_Release(source_enum);
1158
1159     if (!sink)
1160     {
1161         if (all)
1162             return S_OK;
1163         if (any)
1164             return VFW_S_PARTIAL_RENDER;
1165     }
1166
1167 err:
1168     IFilterGraph2_Disconnect(&graph->IFilterGraph2_iface, source);
1169     IFilterGraph2_Disconnect(&graph->IFilterGraph2_iface, middle_sink);
1170     return E_FAIL;
1171 }
1172
1173 static HRESULT autoplug_through_filter(struct filter_graph *graph, IPin *source,
1174         IBaseFilter *filter, IPin *sink, BOOL render_to_existing,
1175         unsigned int recursion_depth)
1176 {
1177     IEnumPins *sink_enum;
1178     IPin *filter_sink;
1179     HRESULT hr;
1180
1181     TRACE("Trying to autoplug %p to %p through %p.\n", source, sink, filter);
1182
1183     if (FAILED(hr = IBaseFilter_EnumPins(filter, &sink_enum)))
1184         return hr;
1185
1186     while (IEnumPins_Next(sink_enum, 1, &filter_sink, NULL) == S_OK)
1187     {
1188         hr = autoplug_through_sink(graph, source, filter, filter_sink, sink,
1189                 render_to_existing, recursion_depth);
1190         IPin_Release(filter_sink);
1191         if (SUCCEEDED(hr))
1192         {
1193             IEnumPins_Release(sink_enum);
1194             return hr;
1195         }
1196     }
1197     IEnumPins_Release(sink_enum);
1198     return VFW_E_CANNOT_CONNECT;
1199 }
1200
1201 /* Common helper for IGraphBuilder::Connect() and IGraphBuilder::Render(), which
1202  * share most of the same code. Render() calls this with a NULL sink. */
1203 static HRESULT autoplug(struct filter_graph *graph, IPin *source, IPin *sink,
1204         BOOL render_to_existing, unsigned int recursion_depth)
1205 {
1206     IAMGraphBuilderCallback *callback = NULL;
1207     IEnumMediaTypes *enummt;
1208     IFilterMapper2 *mapper;
1209     struct filter *filter;
1210     AM_MEDIA_TYPE *mt;
1211     HRESULT hr;
1212
1213     TRACE("Trying to autoplug %p to %p, recursion depth %u.\n", source, sink, recursion_depth);
1214
1215     if (recursion_depth >= 5)
1216     {
1217         WARN("Recursion depth has reached 5; aborting.\n");
1218         return VFW_E_CANNOT_CONNECT;
1219     }
1220
1221     if (sink)
1222     {
1223         /* Try to connect directly to this sink. */
1224         hr = IFilterGraph2_ConnectDirect(&graph->IFilterGraph2_iface, source, sink, NULL);
1225
1226         /* If direct connection succeeded, we should propagate that return value.
1227          * If it returned VFW_E_NOT_CONNECTED or VFW_E_NO_AUDIO_HARDWARE, then don't
1228          * even bother trying intermediate filters, since they won't succeed. */
1229         if (SUCCEEDED(hr) || hr == VFW_E_NOT_CONNECTED || hr == VFW_E_NO_AUDIO_HARDWARE)
1230             return hr;
1231     }
1232
1233     /* Always prefer filters in the graph. */
1234     LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
1235     {
1236         if (SUCCEEDED(hr = autoplug_through_filter(graph, source, filter->filter,
1237                 sink, render_to_existing, recursion_depth)))
1238             return hr;
1239     }
1240
1241     IUnknown_QueryInterface(graph->punkFilterMapper2, &IID_IFilterMapper2, (void **)&mapper);
1242
1243     if (FAILED(hr = IPin_EnumMediaTypes(source, &enummt)))
1244     {
1245         IFilterMapper2_Release(mapper);
1246         return hr;
1247     }
1248
1249     if (graph->pSite)
1250         IUnknown_QueryInterface(graph->pSite, &IID_IAMGraphBuilderCallback, (void **)&callback);
1251
1252     while (IEnumMediaTypes_Next(enummt, 1, &mt, NULL) == S_OK)
1253     {
1254         GUID types[2] = {mt->majortype, mt->subtype};
1255         IEnumMoniker *enummoniker;
1256         IBaseFilter *filter;
1257         IMoniker *moniker;
1258
1259         DeleteMediaType(mt);
1260
1261         if (FAILED(hr = IFilterMapper2_EnumMatchingFilters(mapper, &enummoniker,
1262                 0, FALSE, MERIT_UNLIKELY, TRUE, 1, types, NULL, NULL, FALSE,
1263                 render_to_existing, 0, NULL, NULL, NULL)))
1264             goto out;
1265
1266         while (IEnumMoniker_Next(enummoniker, 1, &moniker, NULL) == S_OK)
1267         {
1268             IPropertyBag *bag;
1269             VARIANT var;
1270
1271             VariantInit(&var);
1272             IMoniker_BindToStorage(moniker, NULL, NULL, &IID_IPropertyBag, (void **)&bag);
1273             hr = IPropertyBag_Read(bag, L"FriendlyName", &var, NULL);
1274             IPropertyBag_Release(bag);
1275             if (FAILED(hr))
1276             {
1277                 IMoniker_Release(moniker);
1278                 continue;
1279             }
1280
1281             if (callback && FAILED(hr = IAMGraphBuilderCallback_SelectedFilter(callback, moniker)))
1282             {
1283                 TRACE("Filter rejected by IAMGraphBuilderCallback::SelectedFilter(), hr %#x.\n", hr);
1284                 IMoniker_Release(moniker);
1285                 continue;
1286             }
1287
1288             hr = create_filter(graph, moniker, &filter);
1289             IMoniker_Release(moniker);
1290             if (FAILED(hr))
1291             {
1292                 ERR("Failed to create filter for %s, hr %#x.\n", debugstr_w(V_BSTR(&var)), hr);
1293                 VariantClear(&var);
1294                 continue;
1295             }
1296
1297             if (callback && FAILED(hr = IAMGraphBuilderCallback_CreatedFilter(callback, filter)))
1298             {
1299                 TRACE("Filter rejected by IAMGraphBuilderCallback::CreatedFilter(), hr %#x.\n", hr);
1300                 IBaseFilter_Release(filter);
1301                 continue;
1302             }
1303
1304             hr = IFilterGraph2_AddFilter(&graph->IFilterGraph2_iface, filter, V_BSTR(&var));
1305             VariantClear(&var);
1306             if (FAILED(hr))
1307             {
1308                 ERR("Failed to add filter, hr %#x.\n", hr);
1309                 IBaseFilter_Release(filter);
1310                 continue;
1311             }
1312
1313             hr = autoplug_through_filter(graph, source, filter, sink, render_to_existing, recursion_depth);
1314             if (SUCCEEDED(hr))
1315             {
1316                 IBaseFilter_Release(filter);
1317                 goto out;
1318             }
1319
1320             IFilterGraph2_RemoveFilter(&graph->IFilterGraph2_iface, filter);
1321             IBaseFilter_Release(filter);
1322         }
1323         IEnumMoniker_Release(enummoniker);
1324     }
1325
1326     hr = VFW_E_CANNOT_CONNECT;
1327
1328 out:
1329     if (callback) IAMGraphBuilderCallback_Release(callback);
1330     IEnumMediaTypes_Release(enummt);
1331     IFilterMapper2_Release(mapper);
1332     return hr;
1333 }
1334
1335 static HRESULT WINAPI FilterGraph2_Connect(IFilterGraph2 *iface, IPin *source, IPin *sink)
1336 {
1337     struct filter_graph *graph = impl_from_IFilterGraph2(iface);
1338     PIN_DIRECTION dir;
1339     HRESULT hr;
1340
1341     TRACE("graph %p, source %p, sink %p.\n", graph, source, sink);
1342
1343     if (!source || !sink)
1344         return E_POINTER;
1345
1346     if (FAILED(hr = IPin_QueryDirection(source, &dir)))
1347         return hr;
1348
1349     if (dir == PINDIR_INPUT)
1350     {
1351         IPin *temp;
1352
1353         TRACE("Directions seem backwards, swapping pins\n");
1354
1355         temp = sink;
1356         sink = source;
1357         source = temp;
1358     }
1359
1360     EnterCriticalSection(&graph->cs);
1361
1362     hr = autoplug(graph, source, sink, TRUE, 0);
1363
1364     LeaveCriticalSection(&graph->cs);
1365
1366     TRACE("Returning %#x.\n", hr);
1367     return hr;
1368 }
1369
1370 static HRESULT WINAPI FilterGraph2_Render(IFilterGraph2 *iface, IPin *source)
1371 {
1372     struct filter_graph *graph = impl_from_IFilterGraph2(iface);
1373     HRESULT hr;
1374
1375     TRACE("graph %p, source %p.\n", graph, source);
1376
1377     EnterCriticalSection(&graph->cs);
1378     hr = autoplug(graph, source, NULL, FALSE, 0);
1379     LeaveCriticalSection(&graph->cs);
1380     if (hr == VFW_E_CANNOT_CONNECT)
1381         hr = VFW_E_CANNOT_RENDER;
1382
1383     TRACE("Returning %#x.\n", hr);
1384     return hr;
1385 }
1386
1387 static HRESULT WINAPI FilterGraph2_RenderFile(IFilterGraph2 *iface, LPCWSTR lpcwstrFile,
1388         LPCWSTR lpcwstrPlayList)
1389 {
1390     struct filter_graph *This = impl_from_IFilterGraph2(iface);
1391     IBaseFilter* preader = NULL;
1392     IPin* ppinreader = NULL;
1393     IEnumPins* penumpins = NULL;
1394     struct filter *filter;
1395     HRESULT hr;
1396     BOOL partial = FALSE;
1397     BOOL any = FALSE;
1398
1399     TRACE("(%p/%p)->(%s, %s)\n", This, iface, debugstr_w(lpcwstrFile), debugstr_w(lpcwstrPlayList));
1400
1401     if (lpcwstrPlayList != NULL)
1402         return E_INVALIDARG;
1403
1404     hr = IFilterGraph2_AddSourceFilter(iface, lpcwstrFile, L"Reader", &preader);
1405     if (FAILED(hr))
1406         return hr;
1407
1408     hr = IBaseFilter_EnumPins(preader, &penumpins);
1409     if (SUCCEEDED(hr))
1410     {
1411         while (IEnumPins_Next(penumpins, 1, &ppinreader, NULL) == S_OK)
1412         {
1413             PIN_DIRECTION dir;
1414
1415             IPin_QueryDirection(ppinreader, &dir);
1416             if (dir == PINDIR_OUTPUT)
1417             {
1418                 hr = IFilterGraph2_Render(iface, ppinreader);
1419
1420                 TRACE("Filters in chain:\n");
1421                 LIST_FOR_EACH_ENTRY(filter, &This->filters, struct filter, entry)
1422                     TRACE("- %s.\n", debugstr_w(filter->name));
1423
1424                 if (SUCCEEDED(hr))
1425                     any = TRUE;
1426                 if (hr != S_OK)
1427                     partial = TRUE;
1428             }
1429             IPin_Release(ppinreader);
1430         }
1431         IEnumPins_Release(penumpins);
1432
1433         if (!any)
1434         {
1435             if (FAILED(hr = IFilterGraph2_RemoveFilter(iface, preader)))
1436                 ERR("Failed to remove source filter, hr %#x.\n", hr);
1437             hr = VFW_E_CANNOT_RENDER;
1438         }
1439         else if (partial)
1440         {
1441             hr = VFW_S_PARTIAL_RENDER;
1442         }
1443         else
1444         {
1445             hr = S_OK;
1446         }
1447     }
1448     IBaseFilter_Release(preader);
1449
1450     TRACE("--> %08x\n", hr);
1451     return hr;
1452 }
1453
1454 static HRESULT WINAPI FilterGraph2_AddSourceFilter(IFilterGraph2 *iface,
1455         const WCHAR *filename, const WCHAR *filter_name, IBaseFilter **ret_filter)
1456 {
1457     struct filter_graph *graph = impl_from_IFilterGraph2(iface);
1458     IFileSourceFilter *filesource;
1459     IBaseFilter *filter;
1460     HRESULT hr;
1461     GUID clsid;
1462
1463     TRACE("graph %p, filename %s, filter_name %s, ret_filter %p.\n",
1464             graph, debugstr_w(filename), debugstr_w(filter_name), ret_filter);
1465
1466     if (!get_media_type(filename, NULL, NULL, &clsid))
1467         clsid = CLSID_AsyncReader;
1468     TRACE("Using source filter %s.\n", debugstr_guid(&clsid));
1469
1470     if (FAILED(hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER,
1471             &IID_IBaseFilter, (void **)&filter)))
1472     {
1473         WARN("Failed to create filter, hr %#x.\n", hr);
1474         return hr;
1475     }
1476
1477     if (FAILED(hr = IBaseFilter_QueryInterface(filter, &IID_IFileSourceFilter, (void **)&filesource)))
1478     {
1479         WARN("Failed to get IFileSourceFilter, hr %#x.\n", hr);
1480         IBaseFilter_Release(filter);
1481         return hr;
1482     }
1483
1484     hr = IFileSourceFilter_Load(filesource, filename, NULL);
1485     IFileSourceFilter_Release(filesource);
1486     if (FAILED(hr))
1487     {
1488         WARN("Failed to load file, hr %#x.\n", hr);
1489         return hr;
1490     }
1491
1492     if (FAILED(hr = IFilterGraph2_AddFilter(iface, filter, filter_name)))
1493     {
1494         IBaseFilter_Release(filter);
1495         return hr;
1496     }
1497
1498     if (ret_filter)
1499         *ret_filter = filter;
1500     return S_OK;
1501 }
1502
1503 static HRESULT WINAPI FilterGraph2_SetLogFile(IFilterGraph2 *iface, DWORD_PTR hFile)
1504 {
1505     struct filter_graph *This = impl_from_IFilterGraph2(iface);
1506
1507     TRACE("(%p/%p)->(%08x): stub !!!\n", This, iface, (DWORD) hFile);
1508
1509     return S_OK;
1510 }
1511
1512 static HRESULT WINAPI FilterGraph2_Abort(IFilterGraph2 *iface)
1513 {
1514     struct filter_graph *This = impl_from_IFilterGraph2(iface);
1515
1516     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1517
1518     return S_OK;
1519 }
1520
1521 static HRESULT WINAPI FilterGraph2_ShouldOperationContinue(IFilterGraph2 *iface)
1522 {
1523     struct filter_graph *This = impl_from_IFilterGraph2(iface);
1524
1525     TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1526
1527     return S_OK;
1528 }
1529
1530 /*** IFilterGraph2 methods ***/
1531 static HRESULT WINAPI FilterGraph2_AddSourceFilterForMoniker(IFilterGraph2 *iface,
1532         IMoniker *pMoniker, IBindCtx *pCtx, LPCWSTR lpcwstrFilterName, IBaseFilter **ppFilter)
1533 {
1534     struct filter_graph *This = impl_from_IFilterGraph2(iface);
1535     HRESULT hr;
1536     IBaseFilter* pfilter;
1537
1538     TRACE("(%p/%p)->(%p %p %s %p)\n", This, iface, pMoniker, pCtx, debugstr_w(lpcwstrFilterName), ppFilter);
1539
1540     hr = IMoniker_BindToObject(pMoniker, pCtx, NULL, &IID_IBaseFilter, (void**)&pfilter);
1541     if(FAILED(hr)) {
1542         WARN("Unable to bind moniker to filter object (%x)\n", hr);
1543         return hr;
1544     }
1545
1546     hr = IFilterGraph2_AddFilter(iface, pfilter, lpcwstrFilterName);
1547     if (FAILED(hr)) {
1548         WARN("Unable to add filter (%x)\n", hr);
1549         IBaseFilter_Release(pfilter);
1550         return hr;
1551     }
1552
1553     if(ppFilter)
1554         *ppFilter = pfilter;
1555     else IBaseFilter_Release(pfilter);
1556
1557     return S_OK;
1558 }
1559
1560 static HRESULT WINAPI FilterGraph2_ReconnectEx(IFilterGraph2 *iface, IPin *pin, const AM_MEDIA_TYPE *mt)
1561 {
1562     struct filter_graph *graph = impl_from_IFilterGraph2(iface);
1563     PIN_DIRECTION dir;
1564     HRESULT hr;
1565     IPin *peer;
1566
1567     TRACE("graph %p, pin %p, mt %p.\n", graph, pin, mt);
1568
1569     if (FAILED(hr = IPin_ConnectedTo(pin, &peer)))
1570         return hr;
1571
1572     IPin_QueryDirection(pin, &dir);
1573     IFilterGraph2_Disconnect(iface, peer);
1574     IFilterGraph2_Disconnect(iface, pin);
1575
1576     if (dir == PINDIR_INPUT)
1577         hr = IFilterGraph2_ConnectDirect(iface, peer, pin, mt);
1578     else
1579         hr = IFilterGraph2_ConnectDirect(iface, pin, peer, mt);
1580
1581     IPin_Release(peer);
1582     return hr;
1583 }
1584
1585 static HRESULT WINAPI FilterGraph2_RenderEx(IFilterGraph2 *iface, IPin *source, DWORD flags, DWORD *context)
1586 {
1587     struct filter_graph *graph = impl_from_IFilterGraph2(iface);
1588     HRESULT hr;
1589
1590     TRACE("graph %p, source %p, flags %#x, context %p.\n", graph, source, flags, context);
1591
1592     if (flags & ~AM_RENDEREX_RENDERTOEXISTINGRENDERERS)
1593         FIXME("Unknown flags %#x.\n", flags);
1594
1595     EnterCriticalSection(&graph->cs);
1596     hr = autoplug(graph, source, NULL, !!(flags & AM_RENDEREX_RENDERTOEXISTINGRENDERERS), 0);
1597     LeaveCriticalSection(&graph->cs);
1598     if (hr == VFW_E_CANNOT_CONNECT)
1599         hr = VFW_E_CANNOT_RENDER;
1600
1601     TRACE("Returning %#x.\n", hr);
1602     return hr;
1603 }
1604
1605
1606 static const IFilterGraph2Vtbl IFilterGraph2_VTable =
1607 {
1608     FilterGraph2_QueryInterface,
1609     FilterGraph2_AddRef,
1610     FilterGraph2_Release,
1611     FilterGraph2_AddFilter,
1612     FilterGraph2_RemoveFilter,
1613     FilterGraph2_EnumFilters,
1614     FilterGraph2_FindFilterByName,
1615     FilterGraph2_ConnectDirect,
1616     FilterGraph2_Reconnect,
1617     FilterGraph2_Disconnect,
1618     FilterGraph2_SetDefaultSyncSource,
1619     FilterGraph2_Connect,
1620     FilterGraph2_Render,
1621     FilterGraph2_RenderFile,
1622     FilterGraph2_AddSourceFilter,
1623     FilterGraph2_SetLogFile,
1624     FilterGraph2_Abort,
1625     FilterGraph2_ShouldOperationContinue,
1626     FilterGraph2_AddSourceFilterForMoniker,
1627     FilterGraph2_ReconnectEx,
1628     FilterGraph2_RenderEx
1629 };
1630
1631 static struct filter_graph *impl_from_IMediaControl(IMediaControl *iface)
1632 {
1633     return CONTAINING_RECORD(iface, struct filter_graph, IMediaControl_iface);
1634 }
1635
1636 static HRESULT WINAPI MediaControl_QueryInterface(IMediaControl *iface, REFIID iid, void **out)
1637 {
1638     struct filter_graph *graph = impl_from_IMediaControl(iface);
1639     return IUnknown_QueryInterface(graph->outer_unk, iid, out);
1640 }
1641
1642 static ULONG WINAPI MediaControl_AddRef(IMediaControl *iface)
1643 {
1644     struct filter_graph *graph = impl_from_IMediaControl(iface);
1645     return IUnknown_AddRef(graph->outer_unk);
1646 }
1647
1648 static ULONG WINAPI MediaControl_Release(IMediaControl *iface)
1649 {
1650     struct filter_graph *graph = impl_from_IMediaControl(iface);
1651     return IUnknown_Release(graph->outer_unk);
1652
1653 }
1654
1655 /*** IDispatch methods ***/
1656 static HRESULT WINAPI MediaControl_GetTypeInfoCount(IMediaControl *iface, UINT *pctinfo)
1657 {
1658     struct filter_graph *This = impl_from_IMediaControl(iface);
1659
1660     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1661
1662     return S_OK;
1663 }
1664
1665 static HRESULT WINAPI MediaControl_GetTypeInfo(IMediaControl *iface, UINT iTInfo, LCID lcid,
1666         ITypeInfo **ppTInfo)
1667 {
1668     struct filter_graph *This = impl_from_IMediaControl(iface);
1669
1670     TRACE("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1671
1672     return S_OK;
1673 }
1674
1675 static HRESULT WINAPI MediaControl_GetIDsOfNames(IMediaControl *iface, REFIID riid,
1676         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1677 {
1678     struct filter_graph *This = impl_from_IMediaControl(iface);
1679
1680     TRACE("(%p/%p)->(%s, %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), rgszNames,
1681             cNames, lcid, rgDispId);
1682
1683     return S_OK;
1684 }
1685
1686 static HRESULT WINAPI MediaControl_Invoke(IMediaControl *iface, DISPID dispIdMember, REFIID riid,
1687         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo,
1688         UINT *puArgErr)
1689 {
1690     struct filter_graph *This = impl_from_IMediaControl(iface);
1691
1692     TRACE("(%p/%p)->(%d, %s, %d, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember,
1693             debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
1694
1695     return S_OK;
1696 }
1697
1698 static void update_render_count(struct filter_graph *graph)
1699 {
1700     /* Some filters (e.g. MediaStreamFilter) can become renderers when they are
1701      * already in the graph. */
1702     struct filter *filter;
1703     graph->nRenderers = 0;
1704     LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
1705     {
1706         if (is_renderer(filter))
1707             ++graph->nRenderers;
1708     }
1709 }
1710
1711 /* Perform the paused -> running transition. The caller must hold graph->cs. */
1712 static HRESULT graph_start(struct filter_graph *graph, REFERENCE_TIME stream_start)
1713 {
1714     struct media_event *event, *next;
1715     REFERENCE_TIME stream_stop;
1716     struct filter *filter;
1717     HRESULT hr = S_OK;
1718
1719     EnterCriticalSection(&graph->event_cs);
1720     graph->EcCompleteCount = 0;
1721     update_render_count(graph);
1722     LeaveCriticalSection(&graph->event_cs);
1723
1724     LIST_FOR_EACH_ENTRY_SAFE(event, next, &graph->media_events, struct media_event, entry)
1725     {
1726         if (event->code == EC_COMPLETE)
1727         {
1728             list_remove(&event->entry);
1729             free(event);
1730         }
1731     }
1732     if (list_empty(&graph->media_events))
1733         ResetEvent(graph->media_event_handle);
1734
1735     if (graph->defaultclock && !graph->refClock)
1736         IFilterGraph2_SetDefaultSyncSource(&graph->IFilterGraph2_iface);
1737
1738     if (!stream_start && graph->refClock)
1739     {
1740         IReferenceClock_GetTime(graph->refClock, &graph->stream_start);
1741         stream_start = graph->stream_start - graph->stream_elapsed;
1742         /* Delay presentation time by 200 ms, to give filters time to
1743          * initialize. */
1744         stream_start += 200 * 10000;
1745     }
1746
1747     if (SUCCEEDED(IMediaSeeking_GetStopPosition(&graph->IMediaSeeking_iface, &stream_stop)))
1748         graph->stream_stop = stream_stop;
1749
1750     LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
1751     {
1752         HRESULT filter_hr = IBaseFilter_Run(filter->filter, stream_start);
1753         if (hr == S_OK)
1754             hr = filter_hr;
1755         TRACE("Filter %p returned %#x.\n", filter->filter, filter_hr);
1756     }
1757
1758     if (FAILED(hr))
1759         WARN("Failed to start stream, hr %#x.\n", hr);
1760
1761     return hr;
1762 }
1763
1764 static void CALLBACK async_run_cb(TP_CALLBACK_INSTANCE *instance, void *context, TP_WORK *work)
1765 {
1766     struct filter_graph *graph = context;
1767     struct filter *filter;
1768     FILTER_STATE state;
1769     HRESULT hr;
1770
1771     TRACE("Performing asynchronous state change.\n");
1772
1773     /* We can't just call GetState(), since that will return State_Running and
1774      * VFW_S_STATE_INTERMEDIATE regardless of whether we're done pausing yet.
1775      * Instead replicate it here. */
1776
1777     for (;;)
1778     {
1779         IBaseFilter *async_filter = NULL;
1780
1781         hr = S_OK;
1782
1783         EnterCriticalSection(&graph->cs);
1784
1785         if (!graph->needs_async_run)
1786             break;
1787
1788         LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
1789         {
1790             hr = IBaseFilter_GetState(filter->filter, 0, &state);
1791
1792             if (hr == VFW_S_STATE_INTERMEDIATE)
1793                 async_filter = filter->filter;
1794
1795             if (SUCCEEDED(hr) && state != State_Paused)
1796                 ERR("Filter %p reported incorrect state %u.\n", filter->filter, state);
1797
1798             if (hr != S_OK)
1799                 break;
1800         }
1801
1802         if (hr != VFW_S_STATE_INTERMEDIATE)
1803             break;
1804
1805         LeaveCriticalSection(&graph->cs);
1806
1807         IBaseFilter_GetState(async_filter, 10, &state);
1808     }
1809
1810     if (hr == S_OK && graph->needs_async_run)
1811     {
1812         sort_filters(graph);
1813         graph_start(graph, 0);
1814         graph->needs_async_run = 0;
1815     }
1816
1817     LeaveCriticalSection(&graph->cs);
1818 }
1819
1820 static HRESULT WINAPI MediaControl_Run(IMediaControl *iface)
1821 {
1822     struct filter_graph *graph = impl_from_IMediaControl(iface);
1823     BOOL need_async_run = TRUE;
1824     struct filter *filter;
1825     FILTER_STATE state;
1826     HRESULT hr = S_OK;
1827
1828     TRACE("graph %p.\n", graph);
1829
1830     EnterCriticalSection(&graph->cs);
1831
1832     if (graph->state == State_Running)
1833     {
1834         LeaveCriticalSection(&graph->cs);
1835         return S_OK;
1836     }
1837
1838     sort_filters(graph);
1839
1840     EnterCriticalSection(&graph->event_cs);
1841     update_render_count(graph);
1842     LeaveCriticalSection(&graph->event_cs);
1843
1844     if (graph->state == State_Stopped)
1845     {
1846         if (graph->defaultclock && !graph->refClock)
1847             IFilterGraph2_SetDefaultSyncSource(&graph->IFilterGraph2_iface);
1848
1849         LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
1850         {
1851             HRESULT filter_hr = IBaseFilter_Pause(filter->filter);
1852             if (hr == S_OK)
1853                 hr = filter_hr;
1854             TRACE("Filter %p returned %#x.\n", filter->filter, filter_hr);
1855
1856             /* If a filter returns VFW_S_CANT_CUE, we shouldn't wait for a
1857              * paused state. */
1858             filter_hr = IBaseFilter_GetState(filter->filter, 0, &state);
1859             if (filter_hr != S_OK && filter_hr != VFW_S_STATE_INTERMEDIATE)
1860                 need_async_run = FALSE;
1861         }
1862
1863         if (FAILED(hr))
1864         {
1865             LeaveCriticalSection(&graph->cs);
1866             WARN("Failed to pause, hr %#x.\n", hr);
1867             return hr;
1868         }
1869     }
1870
1871     graph->state = State_Running;
1872
1873     if (SUCCEEDED(hr))
1874     {
1875         if (hr != S_OK && need_async_run)
1876         {
1877             if (!graph->async_run_work)
1878                 graph->async_run_work = CreateThreadpoolWork(async_run_cb, graph, NULL);
1879             graph->needs_async_run = 1;
1880             SubmitThreadpoolWork(graph->async_run_work);
1881         }
1882         else
1883         {
1884             graph_start(graph, 0);
1885         }
1886     }
1887
1888     LeaveCriticalSection(&graph->cs);
1889     return hr;
1890 }
1891
1892 static HRESULT WINAPI MediaControl_Pause(IMediaControl *iface)
1893 {
1894     struct filter_graph *graph = impl_from_IMediaControl(iface);
1895
1896     TRACE("graph %p.\n", graph);
1897
1898     return IMediaFilter_Pause(&graph->IMediaFilter_iface);
1899 }
1900
1901 static HRESULT WINAPI MediaControl_Stop(IMediaControl *iface)
1902 {
1903     struct filter_graph *graph = impl_from_IMediaControl(iface);
1904
1905     TRACE("graph %p.\n", graph);
1906
1907     return IMediaFilter_Stop(&graph->IMediaFilter_iface);
1908 }
1909
1910 static HRESULT WINAPI MediaControl_GetState(IMediaControl *iface, LONG timeout, OAFilterState *state)
1911 {
1912     struct filter_graph *graph = impl_from_IMediaControl(iface);
1913
1914     TRACE("graph %p, timeout %u, state %p.\n", graph, timeout, state);
1915
1916     if (timeout < 0) timeout = INFINITE;
1917
1918     return IMediaFilter_GetState(&graph->IMediaFilter_iface, timeout, (FILTER_STATE *)state);
1919 }
1920
1921 static HRESULT WINAPI MediaControl_RenderFile(IMediaControl *iface, BSTR strFilename)
1922 {
1923     struct filter_graph *This = impl_from_IMediaControl(iface);
1924
1925     TRACE("(%p/%p)->(%s (%p))\n", This, iface, debugstr_w(strFilename), strFilename);
1926
1927     return IFilterGraph2_RenderFile(&This->IFilterGraph2_iface, strFilename, NULL);
1928 }
1929
1930 static HRESULT WINAPI MediaControl_AddSourceFilter(IMediaControl *iface, BSTR strFilename,
1931         IDispatch **ppUnk)
1932 {
1933     struct filter_graph *This = impl_from_IMediaControl(iface);
1934
1935     FIXME("(%p/%p)->(%s (%p), %p): stub !!!\n", This, iface, debugstr_w(strFilename), strFilename, ppUnk);
1936
1937     return S_OK;
1938 }
1939
1940 static HRESULT WINAPI MediaControl_get_FilterCollection(IMediaControl *iface, IDispatch **ppUnk)
1941 {
1942     struct filter_graph *This = impl_from_IMediaControl(iface);
1943
1944     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk);
1945
1946     return S_OK;
1947 }
1948
1949 static HRESULT WINAPI MediaControl_get_RegFilterCollection(IMediaControl *iface, IDispatch **ppUnk)
1950 {
1951     struct filter_graph *This = impl_from_IMediaControl(iface);
1952
1953     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk);
1954
1955     return S_OK;
1956 }
1957
1958 static void CALLBACK wait_pause_cb(TP_CALLBACK_INSTANCE *instance, void *context)
1959 {
1960     IMediaControl *control = context;
1961     OAFilterState state;
1962     HRESULT hr;
1963
1964     if ((hr = IMediaControl_GetState(control, INFINITE, &state)) != S_OK)
1965         ERR("Failed to get paused state, hr %#x.\n", hr);
1966
1967     if (FAILED(hr = IMediaControl_Stop(control)))
1968         ERR("Failed to stop, hr %#x.\n", hr);
1969
1970     if ((hr = IMediaControl_GetState(control, INFINITE, &state)) != S_OK)
1971         ERR("Failed to get paused state, hr %#x.\n", hr);
1972
1973     IMediaControl_Release(control);
1974 }
1975
1976 static void CALLBACK wait_stop_cb(TP_CALLBACK_INSTANCE *instance, void *context)
1977 {
1978     IMediaControl *control = context;
1979     OAFilterState state;
1980     HRESULT hr;
1981
1982     if ((hr = IMediaControl_GetState(control, INFINITE, &state)) != S_OK)
1983         ERR("Failed to get state, hr %#x.\n", hr);
1984
1985     IMediaControl_Release(control);
1986 }
1987
1988 static HRESULT WINAPI MediaControl_StopWhenReady(IMediaControl *iface)
1989 {
1990     struct filter_graph *graph = impl_from_IMediaControl(iface);
1991     HRESULT hr;
1992
1993     TRACE("graph %p.\n", graph);
1994
1995     /* Even if we are already stopped, we still pause. */
1996     hr = IMediaControl_Pause(iface);
1997     if (FAILED(hr))
1998         return hr;
1999     else if (hr == S_FALSE)
2000     {
2001         IMediaControl_AddRef(iface);
2002         TrySubmitThreadpoolCallback(wait_pause_cb, iface, NULL);
2003         return S_FALSE;
2004     }
2005
2006     hr = IMediaControl_Stop(iface);
2007     if (FAILED(hr))
2008         return hr;
2009     else if (hr == S_FALSE)
2010     {
2011         IMediaControl_AddRef(iface);
2012         TrySubmitThreadpoolCallback(wait_stop_cb, iface, NULL);
2013         return S_FALSE;
2014     }
2015
2016     return S_OK;
2017 }
2018
2019
2020 static const IMediaControlVtbl IMediaControl_VTable =
2021 {
2022     MediaControl_QueryInterface,
2023     MediaControl_AddRef,
2024     MediaControl_Release,
2025     MediaControl_GetTypeInfoCount,
2026     MediaControl_GetTypeInfo,
2027     MediaControl_GetIDsOfNames,
2028     MediaControl_Invoke,
2029     MediaControl_Run,
2030     MediaControl_Pause,
2031     MediaControl_Stop,
2032     MediaControl_GetState,
2033     MediaControl_RenderFile,
2034     MediaControl_AddSourceFilter,
2035     MediaControl_get_FilterCollection,
2036     MediaControl_get_RegFilterCollection,
2037     MediaControl_StopWhenReady
2038 };
2039
2040 static struct filter_graph *impl_from_IMediaSeeking(IMediaSeeking *iface)
2041 {
2042     return CONTAINING_RECORD(iface, struct filter_graph, IMediaSeeking_iface);
2043 }
2044
2045 static HRESULT WINAPI MediaSeeking_QueryInterface(IMediaSeeking *iface, REFIID iid, void **out)
2046 {
2047     struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2048     return IUnknown_QueryInterface(graph->outer_unk, iid, out);
2049 }
2050
2051 static ULONG WINAPI MediaSeeking_AddRef(IMediaSeeking *iface)
2052 {
2053     struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2054     return IUnknown_AddRef(graph->outer_unk);
2055 }
2056
2057 static ULONG WINAPI MediaSeeking_Release(IMediaSeeking *iface)
2058 {
2059     struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2060     return IUnknown_Release(graph->outer_unk);
2061 }
2062
2063 typedef HRESULT (WINAPI *fnFoundSeek)(struct filter_graph *This, IMediaSeeking*, DWORD_PTR arg);
2064
2065 static HRESULT all_renderers_seek(struct filter_graph *This, fnFoundSeek FoundSeek, DWORD_PTR arg) {
2066     BOOL allnotimpl = TRUE;
2067     HRESULT hr, hr_return = S_OK;
2068     struct filter *filter;
2069
2070     TRACE("(%p)->(%p %08lx)\n", This, FoundSeek, arg);
2071     /* Send a message to all renderers, they are responsible for broadcasting it further */
2072
2073     LIST_FOR_EACH_ENTRY(filter, &This->filters, struct filter, entry)
2074     {
2075         update_seeking(filter);
2076         if (!filter->seeking)
2077             continue;
2078         hr = FoundSeek(This, filter->seeking, arg);
2079         if (hr_return != E_NOTIMPL)
2080             allnotimpl = FALSE;
2081         if (hr_return == S_OK || (FAILED(hr) && hr != E_NOTIMPL && SUCCEEDED(hr_return)))
2082             hr_return = hr;
2083     }
2084
2085     if (allnotimpl)
2086         return E_NOTIMPL;
2087     return hr_return;
2088 }
2089
2090 static HRESULT WINAPI FoundCapabilities(struct filter_graph *This, IMediaSeeking *seek, DWORD_PTR pcaps)
2091 {
2092     HRESULT hr;
2093     DWORD caps = 0;
2094
2095     hr = IMediaSeeking_GetCapabilities(seek, &caps);
2096     if (FAILED(hr))
2097         return hr;
2098
2099     /* Only add common capabilities everything supports */
2100     *(DWORD*)pcaps &= caps;
2101
2102     return hr;
2103 }
2104
2105 /*** IMediaSeeking methods ***/
2106 static HRESULT WINAPI MediaSeeking_GetCapabilities(IMediaSeeking *iface, DWORD *pCapabilities)
2107 {
2108     struct filter_graph *This = impl_from_IMediaSeeking(iface);
2109     HRESULT hr;
2110
2111     TRACE("(%p/%p)->(%p)\n", This, iface, pCapabilities);
2112
2113     if (!pCapabilities)
2114         return E_POINTER;
2115
2116     EnterCriticalSection(&This->cs);
2117     *pCapabilities = 0xffffffff;
2118
2119     hr = all_renderers_seek(This, FoundCapabilities, (DWORD_PTR)pCapabilities);
2120     LeaveCriticalSection(&This->cs);
2121
2122     return hr;
2123 }
2124
2125 static HRESULT WINAPI MediaSeeking_CheckCapabilities(IMediaSeeking *iface, DWORD *pCapabilities)
2126 {
2127     struct filter_graph *This = impl_from_IMediaSeeking(iface);
2128     DWORD originalcaps;
2129     HRESULT hr;
2130
2131     TRACE("(%p/%p)->(%p)\n", This, iface, pCapabilities);
2132
2133     if (!pCapabilities)
2134         return E_POINTER;
2135
2136     EnterCriticalSection(&This->cs);
2137     originalcaps = *pCapabilities;
2138     hr = all_renderers_seek(This, FoundCapabilities, (DWORD_PTR)pCapabilities);
2139     LeaveCriticalSection(&This->cs);
2140
2141     if (FAILED(hr))
2142         return hr;
2143
2144     if (!*pCapabilities)
2145         return E_FAIL;
2146     if (*pCapabilities != originalcaps)
2147         return S_FALSE;
2148     return S_OK;
2149 }
2150
2151 static HRESULT WINAPI MediaSeeking_IsFormatSupported(IMediaSeeking *iface, const GUID *pFormat)
2152 {
2153     struct filter_graph *This = impl_from_IMediaSeeking(iface);
2154
2155     if (!pFormat)
2156         return E_POINTER;
2157
2158     TRACE("(%p/%p)->(%s)\n", This, iface, debugstr_guid(pFormat));
2159
2160     if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, pFormat))
2161     {
2162         WARN("Unhandled time format %s\n", debugstr_guid(pFormat));
2163         return S_FALSE;
2164     }
2165
2166     return S_OK;
2167 }
2168
2169 static HRESULT WINAPI MediaSeeking_QueryPreferredFormat(IMediaSeeking *iface, GUID *pFormat)
2170 {
2171     struct filter_graph *This = impl_from_IMediaSeeking(iface);
2172
2173     if (!pFormat)
2174         return E_POINTER;
2175
2176     FIXME("(%p/%p)->(%p): semi-stub !!!\n", This, iface, pFormat);
2177     memcpy(pFormat, &TIME_FORMAT_MEDIA_TIME, sizeof(GUID));
2178
2179     return S_OK;
2180 }
2181
2182 static HRESULT WINAPI MediaSeeking_GetTimeFormat(IMediaSeeking *iface, GUID *pFormat)
2183 {
2184     struct filter_graph *This = impl_from_IMediaSeeking(iface);
2185
2186     if (!pFormat)
2187         return E_POINTER;
2188
2189     TRACE("(%p/%p)->(%p)\n", This, iface, pFormat);
2190     memcpy(pFormat, &This->timeformatseek, sizeof(GUID));
2191
2192     return S_OK;
2193 }
2194
2195 static HRESULT WINAPI MediaSeeking_IsUsingTimeFormat(IMediaSeeking *iface, const GUID *pFormat)
2196 {
2197     struct filter_graph *This = impl_from_IMediaSeeking(iface);
2198
2199     TRACE("(%p/%p)->(%p)\n", This, iface, pFormat);
2200     if (!pFormat)
2201         return E_POINTER;
2202
2203     if (memcmp(pFormat, &This->timeformatseek, sizeof(GUID)))
2204         return S_FALSE;
2205
2206     return S_OK;
2207 }
2208
2209 static HRESULT WINAPI MediaSeeking_SetTimeFormat(IMediaSeeking *iface, const GUID *pFormat)
2210 {
2211     struct filter_graph *This = impl_from_IMediaSeeking(iface);
2212
2213     if (!pFormat)
2214         return E_POINTER;
2215
2216     TRACE("(%p/%p)->(%s)\n", This, iface, debugstr_guid(pFormat));
2217
2218     if (This->state != State_Stopped)
2219         return VFW_E_WRONG_STATE;
2220
2221     if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, pFormat))
2222     {
2223         FIXME("Unhandled time format %s\n", debugstr_guid(pFormat));
2224         return E_INVALIDARG;
2225     }
2226
2227     return S_OK;
2228 }
2229
2230 static HRESULT WINAPI MediaSeeking_GetDuration(IMediaSeeking *iface, LONGLONG *duration)
2231 {
2232     struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2233     HRESULT hr = E_NOTIMPL, filter_hr;
2234     LONGLONG filter_duration;
2235     struct filter *filter;
2236
2237     TRACE("graph %p, duration %p.\n", graph, duration);
2238
2239     if (!duration)
2240         return E_POINTER;
2241
2242     *duration = 0;
2243
2244     EnterCriticalSection(&graph->cs);
2245
2246     LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
2247     {
2248         update_seeking(filter);
2249         if (!filter->seeking)
2250             continue;
2251
2252         filter_hr = IMediaSeeking_GetDuration(filter->seeking, &filter_duration);
2253         if (SUCCEEDED(filter_hr))
2254         {
2255             hr = S_OK;
2256             *duration = max(*duration, filter_duration);
2257         }
2258         else if (filter_hr != E_NOTIMPL)
2259         {
2260             LeaveCriticalSection(&graph->cs);
2261             return filter_hr;
2262         }
2263     }
2264
2265     LeaveCriticalSection(&graph->cs);
2266
2267     TRACE("Returning hr %#x, duration %s (%s seconds).\n", hr,
2268             wine_dbgstr_longlong(*duration), debugstr_time(*duration));
2269     return hr;
2270 }
2271
2272 static HRESULT WINAPI MediaSeeking_GetStopPosition(IMediaSeeking *iface, LONGLONG *stop)
2273 {
2274     struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2275     HRESULT hr = E_NOTIMPL, filter_hr;
2276     struct filter *filter;
2277     LONGLONG filter_stop;
2278
2279     TRACE("graph %p, stop %p.\n", graph, stop);
2280
2281     if (!stop)
2282         return E_POINTER;
2283
2284     *stop = 0;
2285
2286     EnterCriticalSection(&graph->cs);
2287
2288     LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
2289     {
2290         update_seeking(filter);
2291         if (!filter->seeking)
2292             continue;
2293
2294         filter_hr = IMediaSeeking_GetStopPosition(filter->seeking, &filter_stop);
2295         if (SUCCEEDED(filter_hr))
2296         {
2297             hr = S_OK;
2298             *stop = max(*stop, filter_stop);
2299         }
2300         else if (filter_hr != E_NOTIMPL)
2301         {
2302             LeaveCriticalSection(&graph->cs);
2303             return filter_hr;
2304         }
2305     }
2306
2307     LeaveCriticalSection(&graph->cs);
2308
2309     TRACE("Returning %s (%s seconds).\n", wine_dbgstr_longlong(*stop), debugstr_time(*stop));
2310     return hr;
2311 }
2312
2313 static HRESULT WINAPI MediaSeeking_GetCurrentPosition(IMediaSeeking *iface, LONGLONG *current)
2314 {
2315     struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2316     LONGLONG ret = graph->current_pos;
2317
2318     TRACE("graph %p, current %p.\n", graph, current);
2319
2320     if (!current)
2321         return E_POINTER;
2322
2323     EnterCriticalSection(&graph->cs);
2324
2325     if (graph->got_ec_complete)
2326     {
2327         ret = graph->stream_stop;
2328     }
2329     else if (graph->state == State_Running && !graph->needs_async_run && graph->refClock)
2330     {
2331         REFERENCE_TIME time;
2332         IReferenceClock_GetTime(graph->refClock, &time);
2333         if (time)
2334             ret += time - graph->stream_start;
2335     }
2336
2337     LeaveCriticalSection(&graph->cs);
2338
2339     TRACE("Returning %s (%s seconds).\n", wine_dbgstr_longlong(ret), debugstr_time(ret));
2340     *current = ret;
2341
2342     return S_OK;
2343 }
2344
2345 static HRESULT WINAPI MediaSeeking_ConvertTimeFormat(IMediaSeeking *iface, LONGLONG *pTarget,
2346         const GUID *pTargetFormat, LONGLONG Source, const GUID *pSourceFormat)
2347 {
2348     struct filter_graph *This = impl_from_IMediaSeeking(iface);
2349
2350     TRACE("(%p/%p)->(%p, %s, 0x%s, %s)\n", This, iface, pTarget,
2351         debugstr_guid(pTargetFormat), wine_dbgstr_longlong(Source), debugstr_guid(pSourceFormat));
2352
2353     if (!pSourceFormat)
2354         pSourceFormat = &This->timeformatseek;
2355
2356     if (!pTargetFormat)
2357         pTargetFormat = &This->timeformatseek;
2358
2359     if (IsEqualGUID(pTargetFormat, pSourceFormat))
2360         *pTarget = Source;
2361     else
2362         FIXME("conversion %s->%s not supported\n", debugstr_guid(pSourceFormat), debugstr_guid(pTargetFormat));
2363
2364     return S_OK;
2365 }
2366
2367 static HRESULT WINAPI MediaSeeking_SetPositions(IMediaSeeking *iface, LONGLONG *current_ptr,
2368         DWORD current_flags, LONGLONG *stop_ptr, DWORD stop_flags)
2369 {
2370     struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2371     HRESULT hr = E_NOTIMPL, filter_hr;
2372     struct filter *filter;
2373     FILTER_STATE state;
2374
2375     TRACE("graph %p, current %s, current_flags %#x, stop %s, stop_flags %#x.\n", graph,
2376             current_ptr ? wine_dbgstr_longlong(*current_ptr) : "<null>", current_flags,
2377             stop_ptr ? wine_dbgstr_longlong(*stop_ptr): "<null>", stop_flags);
2378     if (current_ptr)
2379         TRACE("Setting current position to %s (%s seconds).\n",
2380                 wine_dbgstr_longlong(*current_ptr), debugstr_time(*current_ptr));
2381     if (stop_ptr)
2382         TRACE("Setting stop position to %s (%s seconds).\n",
2383                 wine_dbgstr_longlong(*stop_ptr), debugstr_time(*stop_ptr));
2384
2385     if ((current_flags & 0x7) != AM_SEEKING_AbsolutePositioning
2386             && (current_flags & 0x7) != AM_SEEKING_NoPositioning)
2387         FIXME("Unhandled current_flags %#x.\n", current_flags & 0x7);
2388
2389     if ((stop_flags & 0x7) != AM_SEEKING_NoPositioning
2390             && (stop_flags & 0x7) != AM_SEEKING_AbsolutePositioning)
2391         FIXME("Unhandled stop_flags %#x.\n", stop_flags & 0x7);
2392
2393     EnterCriticalSection(&graph->cs);
2394
2395     state = graph->state;
2396     if (state == State_Running && !graph->needs_async_run)
2397         IMediaControl_Pause(&graph->IMediaControl_iface);
2398
2399     LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
2400     {
2401         LONGLONG current = current_ptr ? *current_ptr : 0, stop = stop_ptr ? *stop_ptr : 0;
2402
2403         update_seeking(filter);
2404         if (!filter->seeking)
2405             continue;
2406
2407         filter_hr = IMediaSeeking_SetPositions(filter->seeking, &current,
2408                 current_flags | AM_SEEKING_ReturnTime, &stop, stop_flags);
2409         if (SUCCEEDED(filter_hr))
2410         {
2411             hr = S_OK;
2412
2413             if (current_ptr && (current_flags & AM_SEEKING_ReturnTime))
2414                 *current_ptr = current;
2415             if (stop_ptr && (stop_flags & AM_SEEKING_ReturnTime))
2416                 *stop_ptr = stop;
2417             graph->current_pos = current;
2418         }
2419         else if (filter_hr != E_NOTIMPL)
2420         {
2421             LeaveCriticalSection(&graph->cs);
2422             return filter_hr;
2423         }
2424     }
2425
2426     if ((current_flags & 0x7) != AM_SEEKING_NoPositioning && graph->refClock)
2427     {
2428         IReferenceClock_GetTime(graph->refClock, &graph->stream_start);
2429         graph->stream_elapsed = 0;
2430     }
2431
2432     if (state == State_Running && !graph->needs_async_run)
2433         IMediaControl_Run(&graph->IMediaControl_iface);
2434
2435     LeaveCriticalSection(&graph->cs);
2436     return hr;
2437 }
2438
2439 static HRESULT WINAPI MediaSeeking_GetPositions(IMediaSeeking *iface,
2440         LONGLONG *current, LONGLONG *stop)
2441 {
2442     struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2443     HRESULT hr = S_OK;
2444
2445     TRACE("graph %p, current %p, stop %p.\n", graph, current, stop);
2446
2447     if (current)
2448         hr = IMediaSeeking_GetCurrentPosition(iface, current);
2449     if (SUCCEEDED(hr) && stop)
2450         hr = IMediaSeeking_GetStopPosition(iface, stop);
2451
2452     return hr;
2453 }
2454
2455 static HRESULT WINAPI MediaSeeking_GetAvailable(IMediaSeeking *iface, LONGLONG *pEarliest,
2456         LONGLONG *pLatest)
2457 {
2458     struct filter_graph *This = impl_from_IMediaSeeking(iface);
2459
2460     FIXME("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pEarliest, pLatest);
2461
2462     return S_OK;
2463 }
2464
2465 static HRESULT WINAPI MediaSeeking_SetRate(IMediaSeeking *iface, double dRate)
2466 {
2467     struct filter_graph *This = impl_from_IMediaSeeking(iface);
2468
2469     FIXME("(%p/%p)->(%f): stub !!!\n", This, iface, dRate);
2470
2471     return S_OK;
2472 }
2473
2474 static HRESULT WINAPI MediaSeeking_GetRate(IMediaSeeking *iface, double *pdRate)
2475 {
2476     struct filter_graph *This = impl_from_IMediaSeeking(iface);
2477
2478     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pdRate);
2479
2480     if (!pdRate)
2481         return E_POINTER;
2482
2483     *pdRate = 1.0;
2484
2485     return S_OK;
2486 }
2487
2488 static HRESULT WINAPI MediaSeeking_GetPreroll(IMediaSeeking *iface, LONGLONG *pllPreroll)
2489 {
2490     struct filter_graph *This = impl_from_IMediaSeeking(iface);
2491
2492     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pllPreroll);
2493
2494     return S_OK;
2495 }
2496
2497
2498 static const IMediaSeekingVtbl IMediaSeeking_VTable =
2499 {
2500     MediaSeeking_QueryInterface,
2501     MediaSeeking_AddRef,
2502     MediaSeeking_Release,
2503     MediaSeeking_GetCapabilities,
2504     MediaSeeking_CheckCapabilities,
2505     MediaSeeking_IsFormatSupported,
2506     MediaSeeking_QueryPreferredFormat,
2507     MediaSeeking_GetTimeFormat,
2508     MediaSeeking_IsUsingTimeFormat,
2509     MediaSeeking_SetTimeFormat,
2510     MediaSeeking_GetDuration,
2511     MediaSeeking_GetStopPosition,
2512     MediaSeeking_GetCurrentPosition,
2513     MediaSeeking_ConvertTimeFormat,
2514     MediaSeeking_SetPositions,
2515     MediaSeeking_GetPositions,
2516     MediaSeeking_GetAvailable,
2517     MediaSeeking_SetRate,
2518     MediaSeeking_GetRate,
2519     MediaSeeking_GetPreroll
2520 };
2521
2522 static struct filter_graph *impl_from_IMediaPosition(IMediaPosition *iface)
2523 {
2524     return CONTAINING_RECORD(iface, struct filter_graph, IMediaPosition_iface);
2525 }
2526
2527 /*** IUnknown methods ***/
2528 static HRESULT WINAPI MediaPosition_QueryInterface(IMediaPosition *iface, REFIID iid, void **out)
2529 {
2530     struct filter_graph *graph = impl_from_IMediaPosition(iface);
2531     return IUnknown_QueryInterface(graph->outer_unk, iid, out);
2532 }
2533
2534 static ULONG WINAPI MediaPosition_AddRef(IMediaPosition *iface)
2535 {
2536     struct filter_graph *graph = impl_from_IMediaPosition(iface);
2537     return IUnknown_AddRef(graph->outer_unk);
2538 }
2539
2540 static ULONG WINAPI MediaPosition_Release(IMediaPosition *iface)
2541 {
2542     struct filter_graph *graph = impl_from_IMediaPosition(iface);
2543     return IUnknown_Release(graph->outer_unk);
2544 }
2545
2546 /*** IDispatch methods ***/
2547 static HRESULT WINAPI MediaPosition_GetTypeInfoCount(IMediaPosition *iface, UINT* pctinfo)
2548 {
2549     FIXME("(%p) stub!\n", iface);
2550     return E_NOTIMPL;
2551 }
2552
2553 static HRESULT WINAPI MediaPosition_GetTypeInfo(IMediaPosition *iface, UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
2554 {
2555     FIXME("(%p) stub!\n", iface);
2556     return E_NOTIMPL;
2557 }
2558
2559 static HRESULT WINAPI MediaPosition_GetIDsOfNames(IMediaPosition* iface, REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId)
2560 {
2561     FIXME("(%p) stub!\n", iface);
2562     return E_NOTIMPL;
2563 }
2564
2565 static HRESULT WINAPI MediaPosition_Invoke(IMediaPosition* iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
2566 {
2567     FIXME("(%p) stub!\n", iface);
2568     return E_NOTIMPL;
2569 }
2570
2571 static HRESULT ConvertFromREFTIME(IMediaSeeking *seek, REFTIME time_in, LONGLONG *time_out)
2572 {
2573     GUID time_format;
2574     HRESULT hr;
2575
2576     hr = MediaSeeking_GetTimeFormat(seek, &time_format);
2577     if (FAILED(hr))
2578         return hr;
2579     if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, &time_format))
2580     {
2581         FIXME("Unsupported time format.\n");
2582         return E_NOTIMPL;
2583     }
2584
2585     *time_out = (LONGLONG) (time_in * 10000000); /* convert from 1 second intervals to 100 ns intervals */
2586     return S_OK;
2587 }
2588
2589 static HRESULT ConvertToREFTIME(IMediaSeeking *seek, LONGLONG time_in, REFTIME *time_out)
2590 {
2591     GUID time_format;
2592     HRESULT hr;
2593
2594     hr = MediaSeeking_GetTimeFormat(seek, &time_format);
2595     if (FAILED(hr))
2596         return hr;
2597     if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, &time_format))
2598     {
2599         FIXME("Unsupported time format.\n");
2600         return E_NOTIMPL;
2601     }
2602
2603     *time_out = (REFTIME)time_in / 10000000; /* convert from 100 ns intervals to 1 second intervals */
2604     return S_OK;
2605 }
2606
2607 /*** IMediaPosition methods ***/
2608 static HRESULT WINAPI MediaPosition_get_Duration(IMediaPosition * iface, REFTIME *plength)
2609 {
2610     LONGLONG duration;
2611     struct filter_graph *This = impl_from_IMediaPosition( iface );
2612     HRESULT hr = IMediaSeeking_GetDuration(&This->IMediaSeeking_iface, &duration);
2613     if (FAILED(hr))
2614         return hr;
2615     return ConvertToREFTIME(&This->IMediaSeeking_iface, duration, plength);
2616 }
2617
2618 static HRESULT WINAPI MediaPosition_put_CurrentPosition(IMediaPosition * iface, REFTIME llTime)
2619 {
2620     struct filter_graph *This = impl_from_IMediaPosition( iface );
2621     LONGLONG reftime;
2622     HRESULT hr;
2623
2624     hr = ConvertFromREFTIME(&This->IMediaSeeking_iface, llTime, &reftime);
2625     if (FAILED(hr))
2626         return hr;
2627     return IMediaSeeking_SetPositions(&This->IMediaSeeking_iface, &reftime,
2628             AM_SEEKING_AbsolutePositioning, NULL, AM_SEEKING_NoPositioning);
2629 }
2630
2631 static HRESULT WINAPI MediaPosition_get_CurrentPosition(IMediaPosition * iface, REFTIME *pllTime)
2632 {
2633     struct filter_graph *This = impl_from_IMediaPosition( iface );
2634     LONGLONG pos;
2635     HRESULT hr;
2636
2637     hr = IMediaSeeking_GetCurrentPosition(&This->IMediaSeeking_iface, &pos);
2638     if (FAILED(hr))
2639         return hr;
2640     return ConvertToREFTIME(&This->IMediaSeeking_iface, pos, pllTime);
2641 }
2642
2643 static HRESULT WINAPI MediaPosition_get_StopTime(IMediaPosition * iface, REFTIME *pllTime)
2644 {
2645     struct filter_graph *This = impl_from_IMediaPosition( iface );
2646     LONGLONG pos;
2647     HRESULT hr = IMediaSeeking_GetStopPosition(&This->IMediaSeeking_iface, &pos);
2648     if (FAILED(hr))
2649         return hr;
2650     return ConvertToREFTIME(&This->IMediaSeeking_iface, pos, pllTime);
2651 }
2652
2653 static HRESULT WINAPI MediaPosition_put_StopTime(IMediaPosition * iface, REFTIME llTime)
2654 {
2655     struct filter_graph *This = impl_from_IMediaPosition( iface );
2656     LONGLONG reftime;
2657     HRESULT hr;
2658
2659     hr = ConvertFromREFTIME(&This->IMediaSeeking_iface, llTime, &reftime);
2660     if (FAILED(hr))
2661         return hr;
2662     return IMediaSeeking_SetPositions(&This->IMediaSeeking_iface, NULL, AM_SEEKING_NoPositioning,
2663             &reftime, AM_SEEKING_AbsolutePositioning);
2664 }
2665
2666 static HRESULT WINAPI MediaPosition_get_PrerollTime(IMediaPosition * iface, REFTIME *pllTime)
2667 {
2668     FIXME("(%p)->(%p) stub!\n", iface, pllTime);
2669     return E_NOTIMPL;
2670 }
2671
2672 static HRESULT WINAPI MediaPosition_put_PrerollTime(IMediaPosition * iface, REFTIME llTime)
2673 {
2674     FIXME("(%p)->(%f) stub!\n", iface, llTime);
2675     return E_NOTIMPL;
2676 }
2677
2678 static HRESULT WINAPI MediaPosition_put_Rate(IMediaPosition * iface, double dRate)
2679 {
2680     struct filter_graph *This = impl_from_IMediaPosition( iface );
2681     return IMediaSeeking_SetRate(&This->IMediaSeeking_iface, dRate);
2682 }
2683
2684 static HRESULT WINAPI MediaPosition_get_Rate(IMediaPosition * iface, double *pdRate)
2685 {
2686     struct filter_graph *This = impl_from_IMediaPosition( iface );
2687     return IMediaSeeking_GetRate(&This->IMediaSeeking_iface, pdRate);
2688 }
2689
2690 static HRESULT WINAPI MediaPosition_CanSeekForward(IMediaPosition * iface, LONG *pCanSeekForward)
2691 {
2692     FIXME("(%p)->(%p) stub!\n", iface, pCanSeekForward);
2693     return E_NOTIMPL;
2694 }
2695
2696 static HRESULT WINAPI MediaPosition_CanSeekBackward(IMediaPosition * iface, LONG *pCanSeekBackward)
2697 {
2698     FIXME("(%p)->(%p) stub!\n", iface, pCanSeekBackward);
2699     return E_NOTIMPL;
2700 }
2701
2702
2703 static const IMediaPositionVtbl IMediaPosition_VTable =
2704 {
2705     MediaPosition_QueryInterface,
2706     MediaPosition_AddRef,
2707     MediaPosition_Release,
2708     MediaPosition_GetTypeInfoCount,
2709     MediaPosition_GetTypeInfo,
2710     MediaPosition_GetIDsOfNames,
2711     MediaPosition_Invoke,
2712     MediaPosition_get_Duration,
2713     MediaPosition_put_CurrentPosition,
2714     MediaPosition_get_CurrentPosition,
2715     MediaPosition_get_StopTime,
2716     MediaPosition_put_StopTime,
2717     MediaPosition_get_PrerollTime,
2718     MediaPosition_put_PrerollTime,
2719     MediaPosition_put_Rate,
2720     MediaPosition_get_Rate,
2721     MediaPosition_CanSeekForward,
2722     MediaPosition_CanSeekBackward
2723 };
2724
2725 static struct filter_graph *impl_from_IObjectWithSite(IObjectWithSite *iface)
2726 {
2727     return CONTAINING_RECORD(iface, struct filter_graph, IObjectWithSite_iface);
2728 }
2729
2730 /*** IUnknown methods ***/
2731 static HRESULT WINAPI ObjectWithSite_QueryInterface(IObjectWithSite *iface, REFIID iid, void **out)
2732 {
2733     struct filter_graph *graph = impl_from_IObjectWithSite(iface);
2734     return IUnknown_QueryInterface(graph->outer_unk, iid, out);
2735 }
2736
2737 static ULONG WINAPI ObjectWithSite_AddRef(IObjectWithSite *iface)
2738 {
2739     struct filter_graph *graph = impl_from_IObjectWithSite(iface);
2740     return IUnknown_AddRef(graph->outer_unk);
2741 }
2742
2743 static ULONG WINAPI ObjectWithSite_Release(IObjectWithSite *iface)
2744 {
2745     struct filter_graph *graph = impl_from_IObjectWithSite(iface);
2746     return IUnknown_Release(graph->outer_unk);
2747 }
2748
2749 /*** IObjectWithSite methods ***/
2750
2751 static HRESULT WINAPI ObjectWithSite_SetSite(IObjectWithSite *iface, IUnknown *pUnkSite)
2752 {
2753     struct filter_graph *This = impl_from_IObjectWithSite( iface );
2754
2755     TRACE("(%p/%p)->()\n", This, iface);
2756     if (This->pSite) IUnknown_Release(This->pSite);
2757     This->pSite = pUnkSite;
2758     IUnknown_AddRef(This->pSite);
2759     return S_OK;
2760 }
2761
2762 static HRESULT WINAPI ObjectWithSite_GetSite(IObjectWithSite *iface, REFIID riid, PVOID *ppvSite)
2763 {
2764     struct filter_graph *This = impl_from_IObjectWithSite( iface );
2765
2766     TRACE("(%p/%p)->(%s)\n", This, iface,debugstr_guid(riid));
2767
2768     *ppvSite = NULL;
2769     if (!This->pSite)
2770         return E_FAIL;
2771     else
2772         return IUnknown_QueryInterface(This->pSite, riid, ppvSite);
2773 }
2774
2775 static const IObjectWithSiteVtbl IObjectWithSite_VTable =
2776 {
2777     ObjectWithSite_QueryInterface,
2778     ObjectWithSite_AddRef,
2779     ObjectWithSite_Release,
2780     ObjectWithSite_SetSite,
2781     ObjectWithSite_GetSite,
2782 };
2783
2784 static HRESULT GetTargetInterface(struct filter_graph* pGraph, REFIID riid, LPVOID* ppvObj)
2785 {
2786     struct filter *filter;
2787     HRESULT hr;
2788     int entry;
2789
2790     /* Check if the interface type is already registered */
2791     for (entry = 0; entry < pGraph->nItfCacheEntries; entry++)
2792         if (riid == pGraph->ItfCacheEntries[entry].riid)
2793         {
2794             if (pGraph->ItfCacheEntries[entry].iface)
2795             {
2796                 /* Return the interface if available */
2797                 *ppvObj = pGraph->ItfCacheEntries[entry].iface;
2798                 return S_OK;
2799             }
2800             break;
2801         }
2802
2803     if (entry >= MAX_ITF_CACHE_ENTRIES)
2804     {
2805         FIXME("Not enough space to store interface in the cache\n");
2806         return E_OUTOFMEMORY;
2807     }
2808
2809     /* Find a filter supporting the requested interface */
2810     LIST_FOR_EACH_ENTRY(filter, &pGraph->filters, struct filter, entry)
2811     {
2812         hr = IBaseFilter_QueryInterface(filter->filter, riid, ppvObj);
2813         if (hr == S_OK)
2814         {
2815             pGraph->ItfCacheEntries[entry].riid = riid;
2816             pGraph->ItfCacheEntries[entry].filter = filter->filter;
2817             pGraph->ItfCacheEntries[entry].iface = *ppvObj;
2818             if (entry >= pGraph->nItfCacheEntries)
2819                 pGraph->nItfCacheEntries++;
2820             return S_OK;
2821         }
2822         if (hr != E_NOINTERFACE)
2823             return hr;
2824     }
2825
2826     return IsEqualGUID(riid, &IID_IBasicAudio) ? E_NOTIMPL : E_NOINTERFACE;
2827 }
2828
2829 static struct filter_graph *impl_from_IBasicAudio(IBasicAudio *iface)
2830 {
2831     return CONTAINING_RECORD(iface, struct filter_graph, IBasicAudio_iface);
2832 }
2833
2834 static HRESULT WINAPI BasicAudio_QueryInterface(IBasicAudio *iface, REFIID iid, void **out)
2835 {
2836     struct filter_graph *graph = impl_from_IBasicAudio(iface);
2837     return IUnknown_QueryInterface(graph->outer_unk, iid, out);
2838 }
2839
2840 static ULONG WINAPI BasicAudio_AddRef(IBasicAudio *iface)
2841 {
2842     struct filter_graph *graph = impl_from_IBasicAudio(iface);
2843     return IUnknown_AddRef(graph->outer_unk);
2844 }
2845
2846 static ULONG WINAPI BasicAudio_Release(IBasicAudio *iface)
2847 {
2848     struct filter_graph *graph = impl_from_IBasicAudio(iface);
2849     return IUnknown_Release(graph->outer_unk);
2850 }
2851
2852 static HRESULT WINAPI BasicAudio_GetTypeInfoCount(IBasicAudio *iface, UINT *count)
2853 {
2854     TRACE("iface %p, count %p.\n", iface, count);
2855     *count = 1;
2856     return S_OK;
2857 }
2858
2859 static HRESULT WINAPI BasicAudio_GetTypeInfo(IBasicAudio *iface, UINT index,
2860         LCID lcid, ITypeInfo **typeinfo)
2861 {
2862     TRACE("iface %p, index %u, lcid %#x, typeinfo %p.\n", iface, index, lcid, typeinfo);
2863     return strmbase_get_typeinfo(IBasicAudio_tid, typeinfo);
2864 }
2865
2866 static HRESULT WINAPI BasicAudio_GetIDsOfNames(IBasicAudio *iface, REFIID iid,
2867         LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
2868 {
2869     ITypeInfo *typeinfo;
2870     HRESULT hr;
2871
2872     TRACE("iface %p, iid %s, names %p, count %u, lcid %#x, ids %p.\n",
2873             iface, debugstr_guid(iid), names, count, lcid, ids);
2874
2875     if (SUCCEEDED(hr = strmbase_get_typeinfo(IBasicAudio_tid, &typeinfo)))
2876     {
2877         hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, ids);
2878         ITypeInfo_Release(typeinfo);
2879     }
2880     return hr;
2881 }
2882
2883 static HRESULT WINAPI BasicAudio_Invoke(IBasicAudio *iface, DISPID id, REFIID iid, LCID lcid,
2884         WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
2885 {
2886     ITypeInfo *typeinfo;
2887     HRESULT hr;
2888
2889     TRACE("iface %p, id %d, iid %s, lcid %#x, flags %#x, params %p, result %p, excepinfo %p, error_arg %p.\n",
2890             iface, id, debugstr_guid(iid), lcid, flags, params, result, excepinfo, error_arg);
2891
2892     if (SUCCEEDED(hr = strmbase_get_typeinfo(IBasicAudio_tid, &typeinfo)))
2893     {
2894         hr = ITypeInfo_Invoke(typeinfo, iface, id, flags, params, result, excepinfo, error_arg);
2895         ITypeInfo_Release(typeinfo);
2896     }
2897     return hr;
2898 }
2899
2900 /*** IBasicAudio methods ***/
2901 static HRESULT WINAPI BasicAudio_put_Volume(IBasicAudio *iface, LONG lVolume)
2902 {
2903     struct filter_graph *This = impl_from_IBasicAudio(iface);
2904     IBasicAudio* pBasicAudio;
2905     HRESULT hr;
2906
2907     TRACE("(%p/%p)->(%d)\n", This, iface, lVolume);
2908
2909     EnterCriticalSection(&This->cs);
2910
2911     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
2912
2913     if (hr == S_OK)
2914         hr = IBasicAudio_put_Volume(pBasicAudio, lVolume);
2915
2916     LeaveCriticalSection(&This->cs);
2917
2918     return hr;
2919 }
2920
2921 static HRESULT WINAPI BasicAudio_get_Volume(IBasicAudio *iface, LONG *plVolume)
2922 {
2923     struct filter_graph *This = impl_from_IBasicAudio(iface);
2924     IBasicAudio* pBasicAudio;
2925     HRESULT hr;
2926
2927     TRACE("(%p/%p)->(%p)\n", This, iface, plVolume);
2928
2929     EnterCriticalSection(&This->cs);
2930
2931     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
2932
2933     if (hr == S_OK)
2934         hr = IBasicAudio_get_Volume(pBasicAudio, plVolume);
2935
2936     LeaveCriticalSection(&This->cs);
2937
2938     return hr;
2939 }
2940
2941 static HRESULT WINAPI BasicAudio_put_Balance(IBasicAudio *iface, LONG lBalance)
2942 {
2943     struct filter_graph *This = impl_from_IBasicAudio(iface);
2944     IBasicAudio* pBasicAudio;
2945     HRESULT hr;
2946
2947     TRACE("(%p/%p)->(%d)\n", This, iface, lBalance);
2948
2949     EnterCriticalSection(&This->cs);
2950
2951     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
2952
2953     if (hr == S_OK)
2954         hr = IBasicAudio_put_Balance(pBasicAudio, lBalance);
2955
2956     LeaveCriticalSection(&This->cs);
2957
2958     return hr;
2959 }
2960
2961 static HRESULT WINAPI BasicAudio_get_Balance(IBasicAudio *iface, LONG *plBalance)
2962 {
2963     struct filter_graph *This = impl_from_IBasicAudio(iface);
2964     IBasicAudio* pBasicAudio;
2965     HRESULT hr;
2966
2967     TRACE("(%p/%p)->(%p)\n", This, iface, plBalance);
2968
2969     EnterCriticalSection(&This->cs);
2970
2971     hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
2972
2973     if (hr == S_OK)
2974         hr = IBasicAudio_get_Balance(pBasicAudio, plBalance);
2975
2976     LeaveCriticalSection(&This->cs);
2977
2978     return hr;
2979 }
2980
2981 static const IBasicAudioVtbl IBasicAudio_VTable =
2982 {
2983     BasicAudio_QueryInterface,
2984     BasicAudio_AddRef,
2985     BasicAudio_Release,
2986     BasicAudio_GetTypeInfoCount,
2987     BasicAudio_GetTypeInfo,
2988     BasicAudio_GetIDsOfNames,
2989     BasicAudio_Invoke,
2990     BasicAudio_put_Volume,
2991     BasicAudio_get_Volume,
2992     BasicAudio_put_Balance,
2993     BasicAudio_get_Balance
2994 };
2995
2996 static struct filter_graph *impl_from_IBasicVideo2(IBasicVideo2 *iface)
2997 {
2998     return CONTAINING_RECORD(iface, struct filter_graph, IBasicVideo2_iface);
2999 }
3000
3001 static HRESULT WINAPI BasicVideo_QueryInterface(IBasicVideo2 *iface, REFIID iid, void **out)
3002 {
3003     struct filter_graph *graph = impl_from_IBasicVideo2(iface);
3004     return IUnknown_QueryInterface(graph->outer_unk, iid, out);
3005 }
3006
3007 static ULONG WINAPI BasicVideo_AddRef(IBasicVideo2 *iface)
3008 {
3009     struct filter_graph *graph = impl_from_IBasicVideo2(iface);
3010     return IUnknown_AddRef(graph->outer_unk);
3011 }
3012
3013 static ULONG WINAPI BasicVideo_Release(IBasicVideo2 *iface)
3014 {
3015     struct filter_graph *graph = impl_from_IBasicVideo2(iface);
3016     return IUnknown_Release(graph->outer_unk);
3017 }
3018
3019 static HRESULT WINAPI BasicVideo_GetTypeInfoCount(IBasicVideo2 *iface, UINT *count)
3020 {
3021     TRACE("iface %p, count %p.\n", iface, count);
3022     *count = 1;
3023     return S_OK;
3024 }
3025
3026 static HRESULT WINAPI BasicVideo_GetTypeInfo(IBasicVideo2 *iface, UINT index,
3027         LCID lcid, ITypeInfo **typeinfo)
3028 {
3029     TRACE("iface %p, index %u, lcid %#x, typeinfo %p.\n", iface, index, lcid, typeinfo);
3030     return strmbase_get_typeinfo(IBasicVideo_tid, typeinfo);
3031 }
3032
3033 static HRESULT WINAPI BasicVideo_GetIDsOfNames(IBasicVideo2 *iface, REFIID iid,
3034         LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
3035 {
3036     ITypeInfo *typeinfo;
3037     HRESULT hr;
3038
3039     TRACE("iface %p, iid %s, names %p, count %u, lcid %#x, ids %p.\n",
3040             iface, debugstr_guid(iid), names, count, lcid, ids);
3041
3042     if (SUCCEEDED(hr = strmbase_get_typeinfo(IBasicVideo_tid, &typeinfo)))
3043     {
3044         hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, ids);
3045         ITypeInfo_Release(typeinfo);
3046     }
3047     return hr;
3048 }
3049
3050 static HRESULT WINAPI BasicVideo_Invoke(IBasicVideo2 *iface, DISPID id, REFIID iid, LCID lcid,
3051         WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
3052 {
3053     ITypeInfo *typeinfo;
3054     HRESULT hr;
3055
3056     TRACE("iface %p, id %d, iid %s, lcid %#x, flags %#x, params %p, result %p, excepinfo %p, error_arg %p.\n",
3057             iface, id, debugstr_guid(iid), lcid, flags, params, result, excepinfo, error_arg);
3058
3059     if (SUCCEEDED(hr = strmbase_get_typeinfo(IBasicVideo_tid, &typeinfo)))
3060     {
3061         hr = ITypeInfo_Invoke(typeinfo, iface, id, flags, params, result, excepinfo, error_arg);
3062         ITypeInfo_Release(typeinfo);
3063     }
3064     return hr;
3065 }
3066
3067 /*** IBasicVideo methods ***/
3068 static HRESULT WINAPI BasicVideo_get_AvgTimePerFrame(IBasicVideo2 *iface, REFTIME *pAvgTimePerFrame)
3069 {
3070     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3071     IBasicVideo *pBasicVideo;
3072     HRESULT hr;
3073
3074     TRACE("(%p/%p)->(%p)\n", This, iface, pAvgTimePerFrame);
3075
3076     EnterCriticalSection(&This->cs);
3077
3078     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3079
3080     if (hr == S_OK)
3081         hr = IBasicVideo_get_AvgTimePerFrame(pBasicVideo, pAvgTimePerFrame);
3082
3083     LeaveCriticalSection(&This->cs);
3084
3085     return hr;
3086 }
3087
3088 static HRESULT WINAPI BasicVideo_get_BitRate(IBasicVideo2 *iface, LONG *pBitRate)
3089 {
3090     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3091     IBasicVideo *pBasicVideo;
3092     HRESULT hr;
3093
3094     TRACE("(%p/%p)->(%p)\n", This, iface, pBitRate);
3095
3096     EnterCriticalSection(&This->cs);
3097
3098     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3099
3100     if (hr == S_OK)
3101         hr = IBasicVideo_get_BitRate(pBasicVideo, pBitRate);
3102
3103     LeaveCriticalSection(&This->cs);
3104
3105     return hr;
3106 }
3107
3108 static HRESULT WINAPI BasicVideo_get_BitErrorRate(IBasicVideo2 *iface, LONG *pBitErrorRate)
3109 {
3110     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3111     IBasicVideo *pBasicVideo;
3112     HRESULT hr;
3113
3114     TRACE("(%p/%p)->(%p)\n", This, iface, pBitErrorRate);
3115
3116     EnterCriticalSection(&This->cs);
3117
3118     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3119
3120     if (hr == S_OK)
3121         hr = IBasicVideo_get_BitErrorRate(pBasicVideo, pBitErrorRate);
3122
3123     LeaveCriticalSection(&This->cs);
3124
3125     return hr;
3126 }
3127
3128 static HRESULT WINAPI BasicVideo_get_VideoWidth(IBasicVideo2 *iface, LONG *pVideoWidth)
3129 {
3130     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3131     IBasicVideo *pBasicVideo;
3132     HRESULT hr;
3133
3134     TRACE("(%p/%p)->(%p)\n", This, iface, pVideoWidth);
3135
3136     EnterCriticalSection(&This->cs);
3137
3138     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3139
3140     if (hr == S_OK)
3141         hr = IBasicVideo_get_VideoWidth(pBasicVideo, pVideoWidth);
3142
3143     LeaveCriticalSection(&This->cs);
3144
3145     return hr;
3146 }
3147
3148 static HRESULT WINAPI BasicVideo_get_VideoHeight(IBasicVideo2 *iface, LONG *pVideoHeight)
3149 {
3150     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3151     IBasicVideo *pBasicVideo;
3152     HRESULT hr;
3153
3154     TRACE("(%p/%p)->(%p)\n", This, iface, pVideoHeight);
3155
3156     EnterCriticalSection(&This->cs);
3157
3158     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3159
3160     if (hr == S_OK)
3161         hr = IBasicVideo_get_VideoHeight(pBasicVideo, pVideoHeight);
3162
3163     LeaveCriticalSection(&This->cs);
3164
3165     return hr;
3166 }
3167
3168 static HRESULT WINAPI BasicVideo_put_SourceLeft(IBasicVideo2 *iface, LONG SourceLeft)
3169 {
3170     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3171     IBasicVideo *pBasicVideo;
3172     HRESULT hr;
3173
3174     TRACE("(%p/%p)->(%d)\n", This, iface, SourceLeft);
3175
3176     EnterCriticalSection(&This->cs);
3177
3178     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3179
3180     if (hr == S_OK)
3181         hr = IBasicVideo_put_SourceLeft(pBasicVideo, SourceLeft);
3182
3183     LeaveCriticalSection(&This->cs);
3184
3185     return hr;
3186 }
3187
3188 static HRESULT WINAPI BasicVideo_get_SourceLeft(IBasicVideo2 *iface, LONG *pSourceLeft)
3189 {
3190     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3191     IBasicVideo *pBasicVideo;
3192     HRESULT hr;
3193
3194     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceLeft);
3195
3196     EnterCriticalSection(&This->cs);
3197
3198     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3199
3200     if (hr == S_OK)
3201         hr = IBasicVideo_get_SourceLeft(pBasicVideo, pSourceLeft);
3202
3203     LeaveCriticalSection(&This->cs);
3204
3205     return hr;
3206 }
3207
3208 static HRESULT WINAPI BasicVideo_put_SourceWidth(IBasicVideo2 *iface, LONG SourceWidth)
3209 {
3210     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3211     IBasicVideo *pBasicVideo;
3212     HRESULT hr;
3213
3214     TRACE("(%p/%p)->(%d)\n", This, iface, SourceWidth);
3215
3216     EnterCriticalSection(&This->cs);
3217
3218     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3219
3220     if (hr == S_OK)
3221         hr = IBasicVideo_put_SourceWidth(pBasicVideo, SourceWidth);
3222
3223     LeaveCriticalSection(&This->cs);
3224
3225     return hr;
3226 }
3227
3228 static HRESULT WINAPI BasicVideo_get_SourceWidth(IBasicVideo2 *iface, LONG *pSourceWidth)
3229 {
3230     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3231     IBasicVideo *pBasicVideo;
3232     HRESULT hr;
3233
3234     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceWidth);
3235
3236     EnterCriticalSection(&This->cs);
3237
3238     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3239
3240     if (hr == S_OK)
3241         hr = IBasicVideo_get_SourceWidth(pBasicVideo, pSourceWidth);
3242
3243     LeaveCriticalSection(&This->cs);
3244
3245     return hr;
3246 }
3247
3248 static HRESULT WINAPI BasicVideo_put_SourceTop(IBasicVideo2 *iface, LONG SourceTop)
3249 {
3250     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3251     IBasicVideo *pBasicVideo;
3252     HRESULT hr;
3253
3254     TRACE("(%p/%p)->(%d)\n", This, iface, SourceTop);
3255
3256     EnterCriticalSection(&This->cs);
3257
3258     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3259
3260     if (hr == S_OK)
3261         hr = IBasicVideo_put_SourceTop(pBasicVideo, SourceTop);
3262
3263     LeaveCriticalSection(&This->cs);
3264
3265     return hr;
3266 }
3267
3268 static HRESULT WINAPI BasicVideo_get_SourceTop(IBasicVideo2 *iface, LONG *pSourceTop)
3269 {
3270     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3271     IBasicVideo *pBasicVideo;
3272     HRESULT hr;
3273
3274     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceTop);
3275
3276     EnterCriticalSection(&This->cs);
3277
3278     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3279
3280     if (hr == S_OK)
3281         hr = IBasicVideo_get_SourceTop(pBasicVideo, pSourceTop);
3282
3283     LeaveCriticalSection(&This->cs);
3284
3285     return hr;
3286 }
3287
3288 static HRESULT WINAPI BasicVideo_put_SourceHeight(IBasicVideo2 *iface, LONG SourceHeight)
3289 {
3290     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3291     IBasicVideo *pBasicVideo;
3292     HRESULT hr;
3293
3294     TRACE("(%p/%p)->(%d)\n", This, iface, SourceHeight);
3295
3296     EnterCriticalSection(&This->cs);
3297
3298     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3299
3300     if (hr == S_OK)
3301         hr = IBasicVideo_put_SourceHeight(pBasicVideo, SourceHeight);
3302
3303     LeaveCriticalSection(&This->cs);
3304
3305     return hr;
3306 }
3307
3308 static HRESULT WINAPI BasicVideo_get_SourceHeight(IBasicVideo2 *iface, LONG *pSourceHeight)
3309 {
3310     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3311     IBasicVideo *pBasicVideo;
3312     HRESULT hr;
3313
3314     TRACE("(%p/%p)->(%p)\n", This, iface, pSourceHeight);
3315
3316     EnterCriticalSection(&This->cs);
3317
3318     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3319
3320     if (hr == S_OK)
3321         hr = IBasicVideo_get_SourceHeight(pBasicVideo, pSourceHeight);
3322
3323     LeaveCriticalSection(&This->cs);
3324
3325     return hr;
3326 }
3327
3328 static HRESULT WINAPI BasicVideo_put_DestinationLeft(IBasicVideo2 *iface, LONG DestinationLeft)
3329 {
3330     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3331     IBasicVideo *pBasicVideo;
3332     HRESULT hr;
3333
3334     TRACE("(%p/%p)->(%d)\n", This, iface, DestinationLeft);
3335
3336     EnterCriticalSection(&This->cs);
3337
3338     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3339
3340     if (hr == S_OK)
3341         hr = IBasicVideo_put_DestinationLeft(pBasicVideo, DestinationLeft);
3342
3343     LeaveCriticalSection(&This->cs);
3344
3345     return hr;
3346 }
3347
3348 static HRESULT WINAPI BasicVideo_get_DestinationLeft(IBasicVideo2 *iface, LONG *pDestinationLeft)
3349 {
3350     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3351     IBasicVideo *pBasicVideo;
3352     HRESULT hr;
3353
3354     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationLeft);
3355
3356     EnterCriticalSection(&This->cs);
3357
3358     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3359
3360     if (hr == S_OK)
3361         hr = IBasicVideo_get_DestinationLeft(pBasicVideo, pDestinationLeft);
3362
3363     LeaveCriticalSection(&This->cs);
3364
3365     return hr;
3366 }
3367
3368 static HRESULT WINAPI BasicVideo_put_DestinationWidth(IBasicVideo2 *iface, LONG DestinationWidth)
3369 {
3370     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3371     IBasicVideo *pBasicVideo;
3372     HRESULT hr;
3373
3374     TRACE("(%p/%p)->(%d)\n", This, iface, DestinationWidth);
3375
3376     EnterCriticalSection(&This->cs);
3377
3378     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3379
3380     if (hr == S_OK)
3381         hr = IBasicVideo_put_DestinationWidth(pBasicVideo, DestinationWidth);
3382
3383     LeaveCriticalSection(&This->cs);
3384
3385     return hr;
3386 }
3387
3388 static HRESULT WINAPI BasicVideo_get_DestinationWidth(IBasicVideo2 *iface, LONG *pDestinationWidth)
3389 {
3390     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3391     IBasicVideo *pBasicVideo;
3392     HRESULT hr;
3393
3394     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationWidth);
3395
3396     EnterCriticalSection(&This->cs);
3397
3398     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3399
3400     if (hr == S_OK)
3401         hr = IBasicVideo_get_DestinationWidth(pBasicVideo, pDestinationWidth);
3402
3403     LeaveCriticalSection(&This->cs);
3404
3405     return hr;
3406 }
3407
3408 static HRESULT WINAPI BasicVideo_put_DestinationTop(IBasicVideo2 *iface, LONG DestinationTop)
3409 {
3410     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3411     IBasicVideo *pBasicVideo;
3412     HRESULT hr;
3413
3414     TRACE("(%p/%p)->(%d)\n", This, iface, DestinationTop);
3415
3416     EnterCriticalSection(&This->cs);
3417
3418     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3419
3420     if (hr == S_OK)
3421         hr = IBasicVideo_put_DestinationTop(pBasicVideo, DestinationTop);
3422
3423     LeaveCriticalSection(&This->cs);
3424
3425     return hr;
3426 }
3427
3428 static HRESULT WINAPI BasicVideo_get_DestinationTop(IBasicVideo2 *iface, LONG *pDestinationTop)
3429 {
3430     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3431     IBasicVideo *pBasicVideo;
3432     HRESULT hr;
3433
3434     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationTop);
3435
3436     EnterCriticalSection(&This->cs);
3437
3438     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3439
3440     if (hr == S_OK)
3441         hr = IBasicVideo_get_DestinationTop(pBasicVideo, pDestinationTop);
3442
3443     LeaveCriticalSection(&This->cs);
3444
3445     return hr;
3446 }
3447
3448 static HRESULT WINAPI BasicVideo_put_DestinationHeight(IBasicVideo2 *iface, LONG DestinationHeight)
3449 {
3450     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3451     IBasicVideo *pBasicVideo;
3452     HRESULT hr;
3453
3454     TRACE("(%p/%p)->(%d)\n", This, iface, DestinationHeight);
3455
3456     EnterCriticalSection(&This->cs);
3457
3458     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3459
3460     if (hr == S_OK)
3461         hr = IBasicVideo_put_DestinationHeight(pBasicVideo, DestinationHeight);
3462
3463     LeaveCriticalSection(&This->cs);
3464
3465     return hr;
3466 }
3467
3468 static HRESULT WINAPI BasicVideo_get_DestinationHeight(IBasicVideo2 *iface,
3469         LONG *pDestinationHeight)
3470 {
3471     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3472     IBasicVideo *pBasicVideo;
3473     HRESULT hr;
3474
3475     TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationHeight);
3476
3477     EnterCriticalSection(&This->cs);
3478
3479     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3480
3481     if (hr == S_OK)
3482         hr = IBasicVideo_get_DestinationHeight(pBasicVideo, pDestinationHeight);
3483
3484     LeaveCriticalSection(&This->cs);
3485
3486     return hr;
3487 }
3488
3489 static HRESULT WINAPI BasicVideo_SetSourcePosition(IBasicVideo2 *iface, LONG Left, LONG Top,
3490         LONG Width, LONG Height)
3491 {
3492     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3493     IBasicVideo *pBasicVideo;
3494     HRESULT hr;
3495
3496     TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
3497
3498     EnterCriticalSection(&This->cs);
3499
3500     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3501
3502     if (hr == S_OK)
3503         hr = IBasicVideo_SetSourcePosition(pBasicVideo, Left, Top, Width, Height);
3504
3505     LeaveCriticalSection(&This->cs);
3506
3507     return hr;
3508 }
3509
3510 static HRESULT WINAPI BasicVideo_GetSourcePosition(IBasicVideo2 *iface, LONG *pLeft, LONG *pTop,
3511         LONG *pWidth, LONG *pHeight)
3512 {
3513     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3514     IBasicVideo *pBasicVideo;
3515     HRESULT hr;
3516
3517     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
3518
3519     EnterCriticalSection(&This->cs);
3520
3521     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3522
3523     if (hr == S_OK)
3524         hr = IBasicVideo_GetSourcePosition(pBasicVideo, pLeft, pTop, pWidth, pHeight);
3525
3526     LeaveCriticalSection(&This->cs);
3527
3528     return hr;
3529 }
3530
3531 static HRESULT WINAPI BasicVideo_SetDefaultSourcePosition(IBasicVideo2 *iface)
3532 {
3533     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3534     IBasicVideo *pBasicVideo;
3535     HRESULT hr;
3536
3537     TRACE("(%p/%p)->()\n", This, iface);
3538
3539     EnterCriticalSection(&This->cs);
3540
3541     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3542
3543     if (hr == S_OK)
3544         hr = IBasicVideo_SetDefaultSourcePosition(pBasicVideo);
3545
3546     LeaveCriticalSection(&This->cs);
3547
3548     return hr;
3549 }
3550
3551 static HRESULT WINAPI BasicVideo_SetDestinationPosition(IBasicVideo2 *iface, LONG Left, LONG Top,
3552         LONG Width, LONG Height)
3553 {
3554     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3555     IBasicVideo *pBasicVideo;
3556     HRESULT hr;
3557
3558     TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
3559
3560     EnterCriticalSection(&This->cs);
3561
3562     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3563
3564     if (hr == S_OK)
3565         hr = IBasicVideo_SetDestinationPosition(pBasicVideo, Left, Top, Width, Height);
3566
3567     LeaveCriticalSection(&This->cs);
3568
3569     return hr;
3570 }
3571
3572 static HRESULT WINAPI BasicVideo_GetDestinationPosition(IBasicVideo2 *iface, LONG *pLeft,
3573         LONG *pTop, LONG *pWidth, LONG *pHeight)
3574 {
3575     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3576     IBasicVideo *pBasicVideo;
3577     HRESULT hr;
3578
3579     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
3580
3581     EnterCriticalSection(&This->cs);
3582
3583     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3584
3585     if (hr == S_OK)
3586         hr = IBasicVideo_GetDestinationPosition(pBasicVideo, pLeft, pTop, pWidth, pHeight);
3587
3588     LeaveCriticalSection(&This->cs);
3589
3590     return hr;
3591 }
3592
3593 static HRESULT WINAPI BasicVideo_SetDefaultDestinationPosition(IBasicVideo2 *iface)
3594 {
3595     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3596     IBasicVideo *pBasicVideo;
3597     HRESULT hr;
3598
3599     TRACE("(%p/%p)->()\n", This, iface);
3600
3601     EnterCriticalSection(&This->cs);
3602
3603     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3604
3605     if (hr == S_OK)
3606         hr = IBasicVideo_SetDefaultDestinationPosition(pBasicVideo);
3607
3608     LeaveCriticalSection(&This->cs);
3609
3610     return hr;
3611 }
3612
3613 static HRESULT WINAPI BasicVideo_GetVideoSize(IBasicVideo2 *iface, LONG *pWidth, LONG *pHeight)
3614 {
3615     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3616     IBasicVideo *pBasicVideo;
3617     HRESULT hr;
3618
3619     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
3620
3621     EnterCriticalSection(&This->cs);
3622
3623     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3624
3625     if (hr == S_OK)
3626         hr = IBasicVideo_GetVideoSize(pBasicVideo, pWidth, pHeight);
3627
3628     LeaveCriticalSection(&This->cs);
3629
3630     return hr;
3631 }
3632
3633 static HRESULT WINAPI BasicVideo_GetVideoPaletteEntries(IBasicVideo2 *iface, LONG StartIndex,
3634         LONG Entries, LONG *pRetrieved, LONG *pPalette)
3635 {
3636     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3637     IBasicVideo *pBasicVideo;
3638     HRESULT hr;
3639
3640     TRACE("(%p/%p)->(%d, %d, %p, %p)\n", This, iface, StartIndex, Entries, pRetrieved, pPalette);
3641
3642     EnterCriticalSection(&This->cs);
3643
3644     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3645
3646     if (hr == S_OK)
3647         hr = IBasicVideo_GetVideoPaletteEntries(pBasicVideo, StartIndex, Entries, pRetrieved, pPalette);
3648
3649     LeaveCriticalSection(&This->cs);
3650
3651     return hr;
3652 }
3653
3654 static HRESULT WINAPI BasicVideo_GetCurrentImage(IBasicVideo2 *iface, LONG *pBufferSize,
3655         LONG *pDIBImage)
3656 {
3657     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3658     IBasicVideo *pBasicVideo;
3659     HRESULT hr;
3660
3661     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pBufferSize, pDIBImage);
3662
3663     EnterCriticalSection(&This->cs);
3664
3665     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3666
3667     if (hr == S_OK)
3668         hr = IBasicVideo_GetCurrentImage(pBasicVideo, pBufferSize, pDIBImage);
3669
3670     LeaveCriticalSection(&This->cs);
3671
3672     return hr;
3673 }
3674
3675 static HRESULT WINAPI BasicVideo_IsUsingDefaultSource(IBasicVideo2 *iface)
3676 {
3677     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3678     IBasicVideo *pBasicVideo;
3679     HRESULT hr;
3680
3681     TRACE("(%p/%p)->()\n", This, iface);
3682
3683     EnterCriticalSection(&This->cs);
3684
3685     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3686
3687     if (hr == S_OK)
3688         hr = IBasicVideo_IsUsingDefaultSource(pBasicVideo);
3689
3690     LeaveCriticalSection(&This->cs);
3691
3692     return hr;
3693 }
3694
3695 static HRESULT WINAPI BasicVideo_IsUsingDefaultDestination(IBasicVideo2 *iface)
3696 {
3697     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3698     IBasicVideo *pBasicVideo;
3699     HRESULT hr;
3700
3701     TRACE("(%p/%p)->()\n", This, iface);
3702
3703     EnterCriticalSection(&This->cs);
3704
3705     hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3706
3707     if (hr == S_OK)
3708         hr = IBasicVideo_IsUsingDefaultDestination(pBasicVideo);
3709
3710     LeaveCriticalSection(&This->cs);
3711
3712     return hr;
3713 }
3714
3715 static HRESULT WINAPI BasicVideo2_GetPreferredAspectRatio(IBasicVideo2 *iface, LONG *plAspectX,
3716         LONG *plAspectY)
3717 {
3718     struct filter_graph *This = impl_from_IBasicVideo2(iface);
3719     IBasicVideo2 *pBasicVideo2;
3720     HRESULT hr;
3721
3722     TRACE("(%p/%p)->()\n", This, iface);
3723
3724     EnterCriticalSection(&This->cs);
3725
3726     hr = GetTargetInterface(This, &IID_IBasicVideo2, (LPVOID*)&pBasicVideo2);
3727
3728     if (hr == S_OK)
3729         hr = BasicVideo2_GetPreferredAspectRatio(iface, plAspectX, plAspectY);
3730
3731     LeaveCriticalSection(&This->cs);
3732
3733     return hr;
3734 }
3735
3736 static const IBasicVideo2Vtbl IBasicVideo_VTable =
3737 {
3738     BasicVideo_QueryInterface,
3739     BasicVideo_AddRef,
3740     BasicVideo_Release,
3741     BasicVideo_GetTypeInfoCount,
3742     BasicVideo_GetTypeInfo,
3743     BasicVideo_GetIDsOfNames,
3744     BasicVideo_Invoke,
3745     BasicVideo_get_AvgTimePerFrame,
3746     BasicVideo_get_BitRate,
3747     BasicVideo_get_BitErrorRate,
3748     BasicVideo_get_VideoWidth,
3749     BasicVideo_get_VideoHeight,
3750     BasicVideo_put_SourceLeft,
3751     BasicVideo_get_SourceLeft,
3752     BasicVideo_put_SourceWidth,
3753     BasicVideo_get_SourceWidth,
3754     BasicVideo_put_SourceTop,
3755     BasicVideo_get_SourceTop,
3756     BasicVideo_put_SourceHeight,
3757     BasicVideo_get_SourceHeight,
3758     BasicVideo_put_DestinationLeft,
3759     BasicVideo_get_DestinationLeft,
3760     BasicVideo_put_DestinationWidth,
3761     BasicVideo_get_DestinationWidth,
3762     BasicVideo_put_DestinationTop,
3763     BasicVideo_get_DestinationTop,
3764     BasicVideo_put_DestinationHeight,
3765     BasicVideo_get_DestinationHeight,
3766     BasicVideo_SetSourcePosition,
3767     BasicVideo_GetSourcePosition,
3768     BasicVideo_SetDefaultSourcePosition,
3769     BasicVideo_SetDestinationPosition,
3770     BasicVideo_GetDestinationPosition,
3771     BasicVideo_SetDefaultDestinationPosition,
3772     BasicVideo_GetVideoSize,
3773     BasicVideo_GetVideoPaletteEntries,
3774     BasicVideo_GetCurrentImage,
3775     BasicVideo_IsUsingDefaultSource,
3776     BasicVideo_IsUsingDefaultDestination,
3777     BasicVideo2_GetPreferredAspectRatio
3778 };
3779
3780 static struct filter_graph *impl_from_IVideoWindow(IVideoWindow *iface)
3781 {
3782     return CONTAINING_RECORD(iface, struct filter_graph, IVideoWindow_iface);
3783 }
3784
3785 static HRESULT WINAPI VideoWindow_QueryInterface(IVideoWindow *iface, REFIID iid, void **out)
3786 {
3787     struct filter_graph *graph = impl_from_IVideoWindow(iface);
3788     return IUnknown_QueryInterface(graph->outer_unk, iid, out);
3789 }
3790
3791 static ULONG WINAPI VideoWindow_AddRef(IVideoWindow *iface)
3792 {
3793     struct filter_graph *graph = impl_from_IVideoWindow(iface);
3794     return IUnknown_AddRef(graph->outer_unk);
3795 }
3796
3797 static ULONG WINAPI VideoWindow_Release(IVideoWindow *iface)
3798 {
3799     struct filter_graph *graph = impl_from_IVideoWindow(iface);
3800     return IUnknown_Release(graph->outer_unk);
3801 }
3802
3803 HRESULT WINAPI VideoWindow_GetTypeInfoCount(IVideoWindow *iface, UINT *count)
3804 {
3805     TRACE("iface %p, count %p.\n", iface, count);
3806     *count = 1;
3807     return S_OK;
3808 }
3809
3810 HRESULT WINAPI VideoWindow_GetTypeInfo(IVideoWindow *iface, UINT index,
3811         LCID lcid, ITypeInfo **typeinfo)
3812 {
3813     TRACE("iface %p, index %u, lcid %#x, typeinfo %p.\n", iface, index, lcid, typeinfo);
3814     return strmbase_get_typeinfo(IVideoWindow_tid, typeinfo);
3815 }
3816
3817 HRESULT WINAPI VideoWindow_GetIDsOfNames(IVideoWindow *iface, REFIID iid,
3818         LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
3819 {
3820     ITypeInfo *typeinfo;
3821     HRESULT hr;
3822
3823     TRACE("iface %p, iid %s, names %p, count %u, lcid %#x, ids %p.\n",
3824             iface, debugstr_guid(iid), names, count, lcid, ids);
3825
3826     if (SUCCEEDED(hr = strmbase_get_typeinfo(IVideoWindow_tid, &typeinfo)))
3827     {
3828         hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, ids);
3829         ITypeInfo_Release(typeinfo);
3830     }
3831     return hr;
3832 }
3833
3834 static HRESULT WINAPI VideoWindow_Invoke(IVideoWindow *iface, DISPID id, REFIID iid, LCID lcid,
3835         WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
3836 {
3837     ITypeInfo *typeinfo;
3838     HRESULT hr;
3839
3840     TRACE("iface %p, id %d, iid %s, lcid %#x, flags %#x, params %p, result %p, excepinfo %p, error_arg %p.\n",
3841             iface, id, debugstr_guid(iid), lcid, flags, params, result, excepinfo, error_arg);
3842
3843     if (SUCCEEDED(hr = strmbase_get_typeinfo(IVideoWindow_tid, &typeinfo)))
3844     {
3845         hr = ITypeInfo_Invoke(typeinfo, iface, id, flags, params, result, excepinfo, error_arg);
3846         ITypeInfo_Release(typeinfo);
3847     }
3848     return hr;
3849 }
3850
3851 /*** IVideoWindow methods ***/
3852 static HRESULT WINAPI VideoWindow_put_Caption(IVideoWindow *iface, BSTR strCaption)
3853 {
3854     struct filter_graph *This = impl_from_IVideoWindow(iface);
3855     IVideoWindow *pVideoWindow;
3856     HRESULT hr;
3857
3858     TRACE("(%p/%p)->(%s (%p))\n", This, iface, debugstr_w(strCaption), strCaption);
3859
3860     EnterCriticalSection(&This->cs);
3861
3862     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3863
3864     if (hr == S_OK)
3865         hr = IVideoWindow_put_Caption(pVideoWindow, strCaption);
3866
3867     LeaveCriticalSection(&This->cs);
3868
3869     return hr;
3870 }
3871
3872 static HRESULT WINAPI VideoWindow_get_Caption(IVideoWindow *iface, BSTR *strCaption)
3873 {
3874     struct filter_graph *This = impl_from_IVideoWindow(iface);
3875     IVideoWindow *pVideoWindow;
3876     HRESULT hr;
3877
3878     TRACE("(%p/%p)->(%p)\n", This, iface, strCaption);
3879
3880     EnterCriticalSection(&This->cs);
3881
3882     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3883
3884     if (hr == S_OK)
3885         hr = IVideoWindow_get_Caption(pVideoWindow, strCaption);
3886
3887     LeaveCriticalSection(&This->cs);
3888
3889     return hr;
3890 }
3891
3892 static HRESULT WINAPI VideoWindow_put_WindowStyle(IVideoWindow *iface, LONG WindowStyle)
3893 {
3894     struct filter_graph *This = impl_from_IVideoWindow(iface);
3895     IVideoWindow *pVideoWindow;
3896     HRESULT hr;
3897
3898     TRACE("(%p/%p)->(%d)\n", This, iface, WindowStyle);
3899
3900     EnterCriticalSection(&This->cs);
3901
3902     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3903
3904     if (hr == S_OK)
3905         hr = IVideoWindow_put_WindowStyle(pVideoWindow, WindowStyle);
3906
3907     LeaveCriticalSection(&This->cs);
3908
3909     return hr;
3910 }
3911
3912 static HRESULT WINAPI VideoWindow_get_WindowStyle(IVideoWindow *iface, LONG *WindowStyle)
3913 {
3914     struct filter_graph *This = impl_from_IVideoWindow(iface);
3915     IVideoWindow *pVideoWindow;
3916     HRESULT hr;
3917
3918     TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyle);
3919
3920     EnterCriticalSection(&This->cs);
3921
3922     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3923
3924     if (hr == S_OK)
3925         hr = IVideoWindow_get_WindowStyle(pVideoWindow, WindowStyle);
3926
3927     LeaveCriticalSection(&This->cs);
3928
3929     return hr;
3930 }
3931
3932 static HRESULT WINAPI VideoWindow_put_WindowStyleEx(IVideoWindow *iface, LONG WindowStyleEx)
3933 {
3934     struct filter_graph *This = impl_from_IVideoWindow(iface);
3935     IVideoWindow *pVideoWindow;
3936     HRESULT hr;
3937
3938     TRACE("(%p/%p)->(%d)\n", This, iface, WindowStyleEx);
3939
3940     EnterCriticalSection(&This->cs);
3941
3942     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3943
3944     if (hr == S_OK)
3945         hr = IVideoWindow_put_WindowStyleEx(pVideoWindow, WindowStyleEx);
3946
3947     LeaveCriticalSection(&This->cs);
3948
3949     return hr;
3950 }
3951
3952 static HRESULT WINAPI VideoWindow_get_WindowStyleEx(IVideoWindow *iface, LONG *WindowStyleEx)
3953 {
3954     struct filter_graph *This = impl_from_IVideoWindow(iface);
3955     IVideoWindow *pVideoWindow;
3956     HRESULT hr;
3957
3958     TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyleEx);
3959
3960     EnterCriticalSection(&This->cs);
3961
3962     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3963
3964     if (hr == S_OK)
3965         hr = IVideoWindow_get_WindowStyleEx(pVideoWindow, WindowStyleEx);
3966
3967     LeaveCriticalSection(&This->cs);
3968
3969     return hr;
3970 }
3971
3972 static HRESULT WINAPI VideoWindow_put_AutoShow(IVideoWindow *iface, LONG AutoShow)
3973 {
3974     struct filter_graph *This = impl_from_IVideoWindow(iface);
3975     IVideoWindow *pVideoWindow;
3976     HRESULT hr;
3977
3978     TRACE("(%p/%p)->(%d)\n", This, iface, AutoShow);
3979
3980     EnterCriticalSection(&This->cs);
3981
3982     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3983
3984     if (hr == S_OK)
3985         hr = IVideoWindow_put_AutoShow(pVideoWindow, AutoShow);
3986
3987     LeaveCriticalSection(&This->cs);
3988
3989     return hr;
3990 }
3991
3992 static HRESULT WINAPI VideoWindow_get_AutoShow(IVideoWindow *iface, LONG *AutoShow)
3993 {
3994     struct filter_graph *This = impl_from_IVideoWindow(iface);
3995     IVideoWindow *pVideoWindow;
3996     HRESULT hr;
3997
3998     TRACE("(%p/%p)->(%p)\n", This, iface, AutoShow);
3999
4000     EnterCriticalSection(&This->cs);
4001
4002     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4003
4004     if (hr == S_OK)
4005         hr = IVideoWindow_get_AutoShow(pVideoWindow, AutoShow);
4006
4007     LeaveCriticalSection(&This->cs);
4008
4009     return hr;
4010 }
4011
4012 static HRESULT WINAPI VideoWindow_put_WindowState(IVideoWindow *iface, LONG WindowState)
4013 {
4014     struct filter_graph *This = impl_from_IVideoWindow(iface);
4015     IVideoWindow *pVideoWindow;
4016     HRESULT hr;
4017
4018     TRACE("(%p/%p)->(%d)\n", This, iface, WindowState);
4019
4020     EnterCriticalSection(&This->cs);
4021
4022     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4023
4024     if (hr == S_OK)
4025         hr = IVideoWindow_put_WindowState(pVideoWindow, WindowState);
4026
4027     LeaveCriticalSection(&This->cs);
4028
4029     return hr;
4030 }
4031
4032 static HRESULT WINAPI VideoWindow_get_WindowState(IVideoWindow *iface, LONG *WindowState)
4033 {
4034     struct filter_graph *This = impl_from_IVideoWindow(iface);
4035     IVideoWindow *pVideoWindow;
4036     HRESULT hr;
4037
4038     TRACE("(%p/%p)->(%p)\n", This, iface, WindowState);
4039
4040     EnterCriticalSection(&This->cs);
4041
4042     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4043
4044     if (hr == S_OK)
4045         hr = IVideoWindow_get_WindowState(pVideoWindow, WindowState);
4046
4047     LeaveCriticalSection(&This->cs);
4048
4049     return hr;
4050 }
4051
4052 static HRESULT WINAPI VideoWindow_put_BackgroundPalette(IVideoWindow *iface, LONG BackgroundPalette)
4053 {
4054     struct filter_graph *This = impl_from_IVideoWindow(iface);
4055     IVideoWindow *pVideoWindow;
4056     HRESULT hr;
4057
4058     TRACE("(%p/%p)->(%d)\n", This, iface, BackgroundPalette);
4059
4060     EnterCriticalSection(&This->cs);
4061
4062     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4063
4064     if (hr == S_OK)
4065         hr = IVideoWindow_put_BackgroundPalette(pVideoWindow, BackgroundPalette);
4066
4067     LeaveCriticalSection(&This->cs);
4068
4069     return hr;
4070 }
4071
4072 static HRESULT WINAPI VideoWindow_get_BackgroundPalette(IVideoWindow *iface,
4073         LONG *pBackgroundPalette)
4074 {
4075     struct filter_graph *This = impl_from_IVideoWindow(iface);
4076     IVideoWindow *pVideoWindow;
4077     HRESULT hr;
4078
4079     TRACE("(%p/%p)->(%p)\n", This, iface, pBackgroundPalette);
4080
4081     EnterCriticalSection(&This->cs);
4082
4083     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4084
4085     if (hr == S_OK)
4086         hr = IVideoWindow_get_BackgroundPalette(pVideoWindow, pBackgroundPalette);
4087
4088     LeaveCriticalSection(&This->cs);
4089
4090     return hr;
4091 }
4092
4093 static HRESULT WINAPI VideoWindow_put_Visible(IVideoWindow *iface, LONG Visible)
4094 {
4095     struct filter_graph *This = impl_from_IVideoWindow(iface);
4096     IVideoWindow *pVideoWindow;
4097     HRESULT hr;
4098
4099     TRACE("(%p/%p)->(%d)\n", This, iface, Visible);
4100
4101     EnterCriticalSection(&This->cs);
4102
4103     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4104
4105     if (hr == S_OK)
4106         hr = IVideoWindow_put_Visible(pVideoWindow, Visible);
4107
4108     LeaveCriticalSection(&This->cs);
4109
4110     return hr;
4111 }
4112
4113 static HRESULT WINAPI VideoWindow_get_Visible(IVideoWindow *iface, LONG *pVisible)
4114 {
4115     struct filter_graph *This = impl_from_IVideoWindow(iface);
4116     IVideoWindow *pVideoWindow;
4117     HRESULT hr;
4118
4119     TRACE("(%p/%p)->(%p)\n", This, iface, pVisible);
4120
4121     EnterCriticalSection(&This->cs);
4122
4123     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4124
4125     if (hr == S_OK)
4126         hr = IVideoWindow_get_Visible(pVideoWindow, pVisible);
4127
4128     LeaveCriticalSection(&This->cs);
4129
4130     return hr;
4131 }
4132
4133 static HRESULT WINAPI VideoWindow_put_Left(IVideoWindow *iface, LONG Left)
4134 {
4135     struct filter_graph *This = impl_from_IVideoWindow(iface);
4136     IVideoWindow *pVideoWindow;
4137     HRESULT hr;
4138
4139     TRACE("(%p/%p)->(%d)\n", This, iface, Left);
4140
4141     EnterCriticalSection(&This->cs);
4142
4143     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4144
4145     if (hr == S_OK)
4146         hr = IVideoWindow_put_Left(pVideoWindow, Left);
4147
4148     LeaveCriticalSection(&This->cs);
4149
4150     return hr;
4151 }
4152
4153 static HRESULT WINAPI VideoWindow_get_Left(IVideoWindow *iface, LONG *pLeft)
4154 {
4155     struct filter_graph *This = impl_from_IVideoWindow(iface);
4156     IVideoWindow *pVideoWindow;
4157     HRESULT hr;
4158
4159     TRACE("(%p/%p)->(%p)\n", This, iface, pLeft);
4160
4161     EnterCriticalSection(&This->cs);
4162
4163     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4164
4165     if (hr == S_OK)
4166         hr = IVideoWindow_get_Left(pVideoWindow, pLeft);
4167
4168     LeaveCriticalSection(&This->cs);
4169
4170     return hr;
4171 }
4172
4173 static HRESULT WINAPI VideoWindow_put_Width(IVideoWindow *iface, LONG Width)
4174 {
4175     struct filter_graph *This = impl_from_IVideoWindow(iface);
4176     IVideoWindow *pVideoWindow;
4177     HRESULT hr;
4178
4179     TRACE("(%p/%p)->(%d)\n", This, iface, Width);
4180
4181     EnterCriticalSection(&This->cs);
4182
4183     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4184
4185     if (hr == S_OK)
4186         hr = IVideoWindow_put_Width(pVideoWindow, Width);
4187
4188     LeaveCriticalSection(&This->cs);
4189
4190     return hr;
4191 }
4192
4193 static HRESULT WINAPI VideoWindow_get_Width(IVideoWindow *iface, LONG *pWidth)
4194 {
4195     struct filter_graph *This = impl_from_IVideoWindow(iface);
4196     IVideoWindow *pVideoWindow;
4197     HRESULT hr;
4198
4199     TRACE("(%p/%p)->(%p)\n", This, iface, pWidth);
4200
4201     EnterCriticalSection(&This->cs);
4202
4203     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4204
4205     if (hr == S_OK)
4206         hr = IVideoWindow_get_Width(pVideoWindow, pWidth);
4207
4208     LeaveCriticalSection(&This->cs);
4209
4210     return hr;
4211 }
4212
4213 static HRESULT WINAPI VideoWindow_put_Top(IVideoWindow *iface, LONG Top)
4214 {
4215     struct filter_graph *This = impl_from_IVideoWindow(iface);
4216     IVideoWindow *pVideoWindow;
4217     HRESULT hr;
4218
4219     TRACE("(%p/%p)->(%d)\n", This, iface, Top);
4220
4221     EnterCriticalSection(&This->cs);
4222
4223     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4224
4225     if (hr == S_OK)
4226         hr = IVideoWindow_put_Top(pVideoWindow, Top);
4227
4228     LeaveCriticalSection(&This->cs);
4229
4230     return hr;
4231 }
4232
4233 static HRESULT WINAPI VideoWindow_get_Top(IVideoWindow *iface, LONG *pTop)
4234 {
4235     struct filter_graph *This = impl_from_IVideoWindow(iface);
4236     IVideoWindow *pVideoWindow;
4237     HRESULT hr;
4238
4239     TRACE("(%p/%p)->(%p)\n", This, iface, pTop);
4240
4241     EnterCriticalSection(&This->cs);
4242
4243     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4244
4245     if (hr == S_OK)
4246         hr = IVideoWindow_get_Top(pVideoWindow, pTop);
4247
4248     LeaveCriticalSection(&This->cs);
4249
4250     return hr;
4251 }
4252
4253 static HRESULT WINAPI VideoWindow_put_Height(IVideoWindow *iface, LONG Height)
4254 {
4255     struct filter_graph *This = impl_from_IVideoWindow(iface);
4256     IVideoWindow *pVideoWindow;
4257     HRESULT hr;
4258
4259     TRACE("(%p/%p)->(%d)\n", This, iface, Height);
4260
4261     EnterCriticalSection(&This->cs);
4262
4263     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4264
4265     if (hr == S_OK)
4266         hr = IVideoWindow_put_Height(pVideoWindow, Height);
4267
4268     LeaveCriticalSection(&This->cs);
4269
4270     return hr;
4271 }
4272
4273 static HRESULT WINAPI VideoWindow_get_Height(IVideoWindow *iface, LONG *pHeight)
4274 {
4275     struct filter_graph *This = impl_from_IVideoWindow(iface);
4276     IVideoWindow *pVideoWindow;
4277     HRESULT hr;
4278
4279     TRACE("(%p/%p)->(%p)\n", This, iface, pHeight);
4280
4281     EnterCriticalSection(&This->cs);
4282
4283     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4284
4285     if (hr == S_OK)
4286         hr = IVideoWindow_get_Height(pVideoWindow, pHeight);
4287
4288     LeaveCriticalSection(&This->cs);
4289
4290     return hr;
4291 }
4292
4293 static HRESULT WINAPI VideoWindow_put_Owner(IVideoWindow *iface, OAHWND Owner)
4294 {
4295     struct filter_graph *This = impl_from_IVideoWindow(iface);
4296     IVideoWindow *pVideoWindow;
4297     HRESULT hr;
4298
4299     TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Owner);
4300
4301     EnterCriticalSection(&This->cs);
4302
4303     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4304
4305     if (hr == S_OK)
4306         hr = IVideoWindow_put_Owner(pVideoWindow, Owner);
4307
4308     LeaveCriticalSection(&This->cs);
4309
4310     return hr;
4311 }
4312
4313 static HRESULT WINAPI VideoWindow_get_Owner(IVideoWindow *iface, OAHWND *Owner)
4314 {
4315     struct filter_graph *This = impl_from_IVideoWindow(iface);
4316     IVideoWindow *pVideoWindow;
4317     HRESULT hr;
4318
4319     TRACE("(%p/%p)->(%p)\n", This, iface, Owner);
4320
4321     EnterCriticalSection(&This->cs);
4322
4323     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4324
4325     if (hr == S_OK)
4326         hr = IVideoWindow_get_Owner(pVideoWindow, Owner);
4327
4328     LeaveCriticalSection(&This->cs);
4329
4330     return hr;
4331 }
4332
4333 static HRESULT WINAPI VideoWindow_put_MessageDrain(IVideoWindow *iface, OAHWND Drain)
4334 {
4335     struct filter_graph *This = impl_from_IVideoWindow(iface);
4336     IVideoWindow *pVideoWindow;
4337     HRESULT hr;
4338
4339     TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Drain);
4340
4341     EnterCriticalSection(&This->cs);
4342
4343     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4344
4345     if (hr == S_OK)
4346         hr = IVideoWindow_put_MessageDrain(pVideoWindow, Drain);
4347
4348     LeaveCriticalSection(&This->cs);
4349
4350     return hr;
4351 }
4352
4353 static HRESULT WINAPI VideoWindow_get_MessageDrain(IVideoWindow *iface, OAHWND *Drain)
4354 {
4355     struct filter_graph *This = impl_from_IVideoWindow(iface);
4356     IVideoWindow *pVideoWindow;
4357     HRESULT hr;
4358
4359     TRACE("(%p/%p)->(%p)\n", This, iface, Drain);
4360
4361     EnterCriticalSection(&This->cs);
4362
4363     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4364
4365     if (hr == S_OK)
4366         hr = IVideoWindow_get_MessageDrain(pVideoWindow, Drain);
4367
4368     LeaveCriticalSection(&This->cs);
4369
4370     return hr;
4371 }
4372
4373 static HRESULT WINAPI VideoWindow_get_BorderColor(IVideoWindow *iface, LONG *Color)
4374 {
4375     struct filter_graph *This = impl_from_IVideoWindow(iface);
4376     IVideoWindow *pVideoWindow;
4377     HRESULT hr;
4378
4379     TRACE("(%p/%p)->(%p)\n", This, iface, Color);
4380
4381     EnterCriticalSection(&This->cs);
4382
4383     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4384
4385     if (hr == S_OK)
4386         hr = IVideoWindow_get_BorderColor(pVideoWindow, Color);
4387
4388     LeaveCriticalSection(&This->cs);
4389
4390     return hr;
4391 }
4392
4393 static HRESULT WINAPI VideoWindow_put_BorderColor(IVideoWindow *iface, LONG Color)
4394 {
4395     struct filter_graph *This = impl_from_IVideoWindow(iface);
4396     IVideoWindow *pVideoWindow;
4397     HRESULT hr;
4398
4399     TRACE("(%p/%p)->(%d)\n", This, iface, Color);
4400
4401     EnterCriticalSection(&This->cs);
4402
4403     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4404
4405     if (hr == S_OK)
4406         hr = IVideoWindow_put_BorderColor(pVideoWindow, Color);
4407
4408     LeaveCriticalSection(&This->cs);
4409
4410     return hr;
4411 }
4412
4413 static HRESULT WINAPI VideoWindow_get_FullScreenMode(IVideoWindow *iface, LONG *FullScreenMode)
4414 {
4415     struct filter_graph *This = impl_from_IVideoWindow(iface);
4416     IVideoWindow *pVideoWindow;
4417     HRESULT hr;
4418
4419     TRACE("(%p/%p)->(%p)\n", This, iface, FullScreenMode);
4420
4421     EnterCriticalSection(&This->cs);
4422
4423     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4424
4425     if (hr == S_OK)
4426         hr = IVideoWindow_get_FullScreenMode(pVideoWindow, FullScreenMode);
4427
4428     LeaveCriticalSection(&This->cs);
4429
4430     return hr;
4431 }
4432
4433 static HRESULT WINAPI VideoWindow_put_FullScreenMode(IVideoWindow *iface, LONG FullScreenMode)
4434 {
4435     struct filter_graph *This = impl_from_IVideoWindow(iface);
4436     IVideoWindow *pVideoWindow;
4437     HRESULT hr;
4438
4439     TRACE("(%p/%p)->(%d)\n", This, iface, FullScreenMode);
4440
4441     EnterCriticalSection(&This->cs);
4442
4443     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4444
4445     if (hr == S_OK)
4446         hr = IVideoWindow_put_FullScreenMode(pVideoWindow, FullScreenMode);
4447
4448     LeaveCriticalSection(&This->cs);
4449
4450     return hr;
4451 }
4452
4453 static HRESULT WINAPI VideoWindow_SetWindowForeground(IVideoWindow *iface, LONG Focus)
4454 {
4455     struct filter_graph *This = impl_from_IVideoWindow(iface);
4456     IVideoWindow *pVideoWindow;
4457     HRESULT hr;
4458
4459     TRACE("(%p/%p)->(%d)\n", This, iface, Focus);
4460
4461     EnterCriticalSection(&This->cs);
4462
4463     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4464
4465     if (hr == S_OK)
4466         hr = IVideoWindow_SetWindowForeground(pVideoWindow, Focus);
4467
4468     LeaveCriticalSection(&This->cs);
4469
4470     return hr;
4471 }
4472
4473 static HRESULT WINAPI VideoWindow_NotifyOwnerMessage(IVideoWindow *iface, OAHWND hwnd, LONG uMsg,
4474         LONG_PTR wParam, LONG_PTR lParam)
4475 {
4476     struct filter_graph *This = impl_from_IVideoWindow(iface);
4477     IVideoWindow *pVideoWindow;
4478     HRESULT hr;
4479
4480     TRACE("(%p/%p)->(%08lx, %d, %08lx, %08lx)\n", This, iface, hwnd, uMsg, wParam, lParam);
4481
4482     EnterCriticalSection(&This->cs);
4483
4484     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4485
4486     if (hr == S_OK)
4487         hr = IVideoWindow_NotifyOwnerMessage(pVideoWindow, hwnd, uMsg, wParam, lParam);
4488
4489     LeaveCriticalSection(&This->cs);
4490
4491     return hr;
4492 }
4493
4494 static HRESULT WINAPI VideoWindow_SetWindowPosition(IVideoWindow *iface, LONG Left, LONG Top,
4495         LONG Width, LONG Height)
4496 {
4497     struct filter_graph *This = impl_from_IVideoWindow(iface);
4498     IVideoWindow *pVideoWindow;
4499     HRESULT hr;
4500
4501     TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
4502
4503     EnterCriticalSection(&This->cs);
4504
4505     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4506
4507     if (hr == S_OK)
4508         hr = IVideoWindow_SetWindowPosition(pVideoWindow, Left, Top, Width, Height);
4509
4510     LeaveCriticalSection(&This->cs);
4511
4512     return hr;
4513 }
4514
4515 static HRESULT WINAPI VideoWindow_GetWindowPosition(IVideoWindow *iface, LONG *pLeft, LONG *pTop,
4516         LONG *pWidth, LONG *pHeight)
4517 {
4518     struct filter_graph *This = impl_from_IVideoWindow(iface);
4519     IVideoWindow *pVideoWindow;
4520     HRESULT hr;
4521
4522     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
4523
4524     EnterCriticalSection(&This->cs);
4525
4526     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4527
4528     if (hr == S_OK)
4529         hr = IVideoWindow_GetWindowPosition(pVideoWindow, pLeft, pTop, pWidth, pHeight);
4530
4531     LeaveCriticalSection(&This->cs);
4532
4533     return hr;
4534 }
4535
4536 static HRESULT WINAPI VideoWindow_GetMinIdealImageSize(IVideoWindow *iface, LONG *pWidth,
4537         LONG *pHeight)
4538 {
4539     struct filter_graph *This = impl_from_IVideoWindow(iface);
4540     IVideoWindow *pVideoWindow;
4541     HRESULT hr;
4542
4543     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
4544
4545     EnterCriticalSection(&This->cs);
4546
4547     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4548
4549     if (hr == S_OK)
4550         hr = IVideoWindow_GetMinIdealImageSize(pVideoWindow, pWidth, pHeight);
4551
4552     LeaveCriticalSection(&This->cs);
4553
4554     return hr;
4555 }
4556
4557 static HRESULT WINAPI VideoWindow_GetMaxIdealImageSize(IVideoWindow *iface, LONG *pWidth,
4558         LONG *pHeight)
4559 {
4560     struct filter_graph *This = impl_from_IVideoWindow(iface);
4561     IVideoWindow *pVideoWindow;
4562     HRESULT hr;
4563
4564     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
4565
4566     EnterCriticalSection(&This->cs);
4567
4568     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4569
4570     if (hr == S_OK)
4571         hr = IVideoWindow_GetMaxIdealImageSize(pVideoWindow, pWidth, pHeight);
4572
4573     LeaveCriticalSection(&This->cs);
4574
4575     return hr;
4576 }
4577
4578 static HRESULT WINAPI VideoWindow_GetRestorePosition(IVideoWindow *iface, LONG *pLeft, LONG *pTop,
4579         LONG *pWidth, LONG *pHeight)
4580 {
4581     struct filter_graph *This = impl_from_IVideoWindow(iface);
4582     IVideoWindow *pVideoWindow;
4583     HRESULT hr;
4584
4585     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
4586
4587     EnterCriticalSection(&This->cs);
4588
4589     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4590
4591     if (hr == S_OK)
4592         hr = IVideoWindow_GetRestorePosition(pVideoWindow, pLeft, pTop, pWidth, pHeight);
4593
4594     LeaveCriticalSection(&This->cs);
4595
4596     return hr;
4597 }
4598
4599 static HRESULT WINAPI VideoWindow_HideCursor(IVideoWindow *iface, LONG HideCursor)
4600 {
4601     struct filter_graph *This = impl_from_IVideoWindow(iface);
4602     IVideoWindow *pVideoWindow;
4603     HRESULT hr;
4604
4605     TRACE("(%p/%p)->(%d)\n", This, iface, HideCursor);
4606
4607     EnterCriticalSection(&This->cs);
4608
4609     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4610
4611     if (hr == S_OK)
4612         hr = IVideoWindow_HideCursor(pVideoWindow, HideCursor);
4613
4614     LeaveCriticalSection(&This->cs);
4615
4616     return hr;
4617 }
4618
4619 static HRESULT WINAPI VideoWindow_IsCursorHidden(IVideoWindow *iface, LONG *CursorHidden)
4620 {
4621     struct filter_graph *This = impl_from_IVideoWindow(iface);
4622     IVideoWindow *pVideoWindow;
4623     HRESULT hr;
4624
4625     TRACE("(%p/%p)->(%p)\n", This, iface, CursorHidden);
4626
4627     EnterCriticalSection(&This->cs);
4628
4629     hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4630
4631     if (hr == S_OK)
4632         hr = IVideoWindow_IsCursorHidden(pVideoWindow, CursorHidden);
4633
4634     LeaveCriticalSection(&This->cs);
4635
4636     return hr;
4637 }
4638
4639
4640 static const IVideoWindowVtbl IVideoWindow_VTable =
4641 {
4642     VideoWindow_QueryInterface,
4643     VideoWindow_AddRef,
4644     VideoWindow_Release,
4645     VideoWindow_GetTypeInfoCount,
4646     VideoWindow_GetTypeInfo,
4647     VideoWindow_GetIDsOfNames,
4648     VideoWindow_Invoke,
4649     VideoWindow_put_Caption,
4650     VideoWindow_get_Caption,
4651     VideoWindow_put_WindowStyle,
4652     VideoWindow_get_WindowStyle,
4653     VideoWindow_put_WindowStyleEx,
4654     VideoWindow_get_WindowStyleEx,
4655     VideoWindow_put_AutoShow,
4656     VideoWindow_get_AutoShow,
4657     VideoWindow_put_WindowState,
4658     VideoWindow_get_WindowState,
4659     VideoWindow_put_BackgroundPalette,
4660     VideoWindow_get_BackgroundPalette,
4661     VideoWindow_put_Visible,
4662     VideoWindow_get_Visible,
4663     VideoWindow_put_Left,
4664     VideoWindow_get_Left,
4665     VideoWindow_put_Width,
4666     VideoWindow_get_Width,
4667     VideoWindow_put_Top,
4668     VideoWindow_get_Top,
4669     VideoWindow_put_Height,
4670     VideoWindow_get_Height,
4671     VideoWindow_put_Owner,
4672     VideoWindow_get_Owner,
4673     VideoWindow_put_MessageDrain,
4674     VideoWindow_get_MessageDrain,
4675     VideoWindow_get_BorderColor,
4676     VideoWindow_put_BorderColor,
4677     VideoWindow_get_FullScreenMode,
4678     VideoWindow_put_FullScreenMode,
4679     VideoWindow_SetWindowForeground,
4680     VideoWindow_NotifyOwnerMessage,
4681     VideoWindow_SetWindowPosition,
4682     VideoWindow_GetWindowPosition,
4683     VideoWindow_GetMinIdealImageSize,
4684     VideoWindow_GetMaxIdealImageSize,
4685     VideoWindow_GetRestorePosition,
4686     VideoWindow_HideCursor,
4687     VideoWindow_IsCursorHidden
4688 };
4689
4690 static struct filter_graph *impl_from_IMediaEventEx(IMediaEventEx *iface)
4691 {
4692     return CONTAINING_RECORD(iface, struct filter_graph, IMediaEventEx_iface);
4693 }
4694
4695 static HRESULT WINAPI MediaEvent_QueryInterface(IMediaEventEx *iface, REFIID iid, void **out)
4696 {
4697     struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4698     return IUnknown_QueryInterface(graph->outer_unk, iid, out);
4699 }
4700
4701 static ULONG WINAPI MediaEvent_AddRef(IMediaEventEx *iface)
4702 {
4703     struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4704     return IUnknown_AddRef(graph->outer_unk);
4705 }
4706
4707 static ULONG WINAPI MediaEvent_Release(IMediaEventEx *iface)
4708 {
4709     struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4710     return IUnknown_Release(graph->outer_unk);
4711 }
4712
4713 /*** IDispatch methods ***/
4714 static HRESULT WINAPI MediaEvent_GetTypeInfoCount(IMediaEventEx *iface, UINT *pctinfo)
4715 {
4716     struct filter_graph *This = impl_from_IMediaEventEx(iface);
4717
4718     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
4719
4720     return S_OK;
4721 }
4722
4723 static HRESULT WINAPI MediaEvent_GetTypeInfo(IMediaEventEx *iface, UINT iTInfo, LCID lcid,
4724         ITypeInfo **ppTInfo)
4725 {
4726     struct filter_graph *This = impl_from_IMediaEventEx(iface);
4727
4728     TRACE("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
4729
4730     return S_OK;
4731 }
4732
4733 static HRESULT WINAPI MediaEvent_GetIDsOfNames(IMediaEventEx *iface, REFIID riid,
4734         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4735 {
4736     struct filter_graph *This = impl_from_IMediaEventEx(iface);
4737
4738     TRACE("(%p/%p)->(%s, %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), rgszNames,
4739             cNames, lcid, rgDispId);
4740
4741     return S_OK;
4742 }
4743
4744 static HRESULT WINAPI MediaEvent_Invoke(IMediaEventEx *iface, DISPID dispIdMember, REFIID riid,
4745         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo,
4746         UINT *puArgErr)
4747 {
4748     struct filter_graph *This = impl_from_IMediaEventEx(iface);
4749
4750     TRACE("(%p/%p)->(%d, %s, %d, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember,
4751             debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
4752
4753     return S_OK;
4754 }
4755
4756 /*** IMediaEvent methods ***/
4757 static HRESULT WINAPI MediaEvent_GetEventHandle(IMediaEventEx *iface, OAEVENT *event)
4758 {
4759     struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4760
4761     TRACE("graph %p, event %p.\n", graph, event);
4762
4763     *event = (OAEVENT)graph->media_event_handle;
4764     return S_OK;
4765 }
4766
4767 static HRESULT WINAPI MediaEvent_GetEvent(IMediaEventEx *iface, LONG *code,
4768         LONG_PTR *param1, LONG_PTR *param2, LONG timeout)
4769 {
4770     struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4771     struct media_event *event;
4772     struct list *entry;
4773
4774     TRACE("graph %p, code %p, param1 %p, param2 %p, timeout %d.\n", graph, code, param1, param2, timeout);
4775
4776     *code = 0;
4777
4778     if (WaitForSingleObject(graph->media_event_handle, timeout))
4779         return E_ABORT;
4780
4781     EnterCriticalSection(&graph->event_cs);
4782
4783     if (!(entry = list_head(&graph->media_events)))
4784     {
4785         ResetEvent(graph->media_event_handle);
4786         LeaveCriticalSection(&graph->event_cs);
4787         return E_ABORT;
4788     }
4789     event = LIST_ENTRY(entry, struct media_event, entry);
4790     list_remove(&event->entry);
4791     *code = event->code;
4792     *param1 = event->param1;
4793     *param2 = event->param2;
4794     free(event);
4795
4796     LeaveCriticalSection(&graph->event_cs);
4797     return S_OK;
4798 }
4799
4800 static HRESULT WINAPI MediaEvent_WaitForCompletion(IMediaEventEx *iface, LONG msTimeout,
4801         LONG *pEvCode)
4802 {
4803     struct filter_graph *This = impl_from_IMediaEventEx(iface);
4804
4805     TRACE("(%p/%p)->(%d, %p)\n", This, iface, msTimeout, pEvCode);
4806
4807     if (This->state != State_Running)
4808         return VFW_E_WRONG_STATE;
4809
4810     if (WaitForSingleObject(This->hEventCompletion, msTimeout) == WAIT_OBJECT_0)
4811     {
4812         *pEvCode = This->CompletionStatus;
4813         return S_OK;
4814     }
4815
4816     *pEvCode = 0;
4817     return E_ABORT;
4818 }
4819
4820 static HRESULT WINAPI MediaEvent_CancelDefaultHandling(IMediaEventEx *iface, LONG lEvCode)
4821 {
4822     struct filter_graph *This = impl_from_IMediaEventEx(iface);
4823
4824     TRACE("(%p/%p)->(%d)\n", This, iface, lEvCode);
4825
4826     if (lEvCode == EC_COMPLETE)
4827         This->HandleEcComplete = FALSE;
4828     else if (lEvCode == EC_REPAINT)
4829         This->HandleEcRepaint = FALSE;
4830     else if (lEvCode == EC_CLOCK_CHANGED)
4831         This->HandleEcClockChanged = FALSE;
4832     else
4833         return S_FALSE;
4834
4835     return S_OK;
4836 }
4837
4838 static HRESULT WINAPI MediaEvent_RestoreDefaultHandling(IMediaEventEx *iface, LONG lEvCode)
4839 {
4840     struct filter_graph *This = impl_from_IMediaEventEx(iface);
4841
4842     TRACE("(%p/%p)->(%d)\n", This, iface, lEvCode);
4843
4844     if (lEvCode == EC_COMPLETE)
4845         This->HandleEcComplete = TRUE;
4846     else if (lEvCode == EC_REPAINT)
4847         This->HandleEcRepaint = TRUE;
4848     else if (lEvCode == EC_CLOCK_CHANGED)
4849         This->HandleEcClockChanged = TRUE;
4850     else
4851         return S_FALSE;
4852
4853     return S_OK;
4854 }
4855
4856 static HRESULT WINAPI MediaEvent_FreeEventParams(IMediaEventEx *iface, LONG lEvCode,
4857         LONG_PTR lParam1, LONG_PTR lParam2)
4858 {
4859     struct filter_graph *This = impl_from_IMediaEventEx(iface);
4860
4861     TRACE("(%p/%p)->(%d, %08lx, %08lx): stub !!!\n", This, iface, lEvCode, lParam1, lParam2);
4862
4863     return S_OK;
4864 }
4865
4866 /*** IMediaEventEx methods ***/
4867 static HRESULT WINAPI MediaEvent_SetNotifyWindow(IMediaEventEx *iface,
4868         OAHWND window, LONG message, LONG_PTR lparam)
4869 {
4870     struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4871
4872     TRACE("graph %p, window %#Ix, message %#x, lparam %#Ix.\n", graph, window, message, lparam);
4873
4874     graph->media_event_window = (HWND)window;
4875     graph->media_event_message = message;
4876     graph->media_event_lparam = lparam;
4877
4878     return S_OK;
4879 }
4880
4881 static HRESULT WINAPI MediaEvent_SetNotifyFlags(IMediaEventEx *iface, LONG flags)
4882 {
4883     struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4884
4885     TRACE("graph %p, flags %#x.\n", graph, flags);
4886
4887     if (flags & ~AM_MEDIAEVENT_NONOTIFY)
4888     {
4889         WARN("Invalid flags %#x, returning E_INVALIDARG.\n", flags);
4890         return E_INVALIDARG;
4891     }
4892
4893     graph->media_events_disabled = flags;
4894
4895     if (flags)
4896     {
4897         flush_media_events(graph);
4898         ResetEvent(graph->media_event_handle);
4899     }
4900
4901     return S_OK;
4902 }
4903
4904 static HRESULT WINAPI MediaEvent_GetNotifyFlags(IMediaEventEx *iface, LONG *flags)
4905 {
4906     struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4907
4908     TRACE("graph %p, flags %p.\n", graph, flags);
4909
4910     if (!flags)
4911         return E_POINTER;
4912
4913     *flags = graph->media_events_disabled;
4914
4915     return S_OK;
4916 }
4917
4918
4919 static const IMediaEventExVtbl IMediaEventEx_VTable =
4920 {
4921     MediaEvent_QueryInterface,
4922     MediaEvent_AddRef,
4923     MediaEvent_Release,
4924     MediaEvent_GetTypeInfoCount,
4925     MediaEvent_GetTypeInfo,
4926     MediaEvent_GetIDsOfNames,
4927     MediaEvent_Invoke,
4928     MediaEvent_GetEventHandle,
4929     MediaEvent_GetEvent,
4930     MediaEvent_WaitForCompletion,
4931     MediaEvent_CancelDefaultHandling,
4932     MediaEvent_RestoreDefaultHandling,
4933     MediaEvent_FreeEventParams,
4934     MediaEvent_SetNotifyWindow,
4935     MediaEvent_SetNotifyFlags,
4936     MediaEvent_GetNotifyFlags
4937 };
4938
4939
4940 static struct filter_graph *impl_from_IMediaFilter(IMediaFilter *iface)
4941 {
4942     return CONTAINING_RECORD(iface, struct filter_graph, IMediaFilter_iface);
4943 }
4944
4945 static HRESULT WINAPI MediaFilter_QueryInterface(IMediaFilter *iface, REFIID iid, void **out)
4946 {
4947     struct filter_graph *graph = impl_from_IMediaFilter(iface);
4948
4949     return IUnknown_QueryInterface(graph->outer_unk, iid, out);
4950 }
4951
4952 static ULONG WINAPI MediaFilter_AddRef(IMediaFilter *iface)
4953 {
4954     struct filter_graph *graph = impl_from_IMediaFilter(iface);
4955
4956     return IUnknown_AddRef(graph->outer_unk);
4957 }
4958
4959 static ULONG WINAPI MediaFilter_Release(IMediaFilter *iface)
4960 {
4961     struct filter_graph *graph = impl_from_IMediaFilter(iface);
4962
4963     return IUnknown_Release(graph->outer_unk);
4964 }
4965
4966 static HRESULT WINAPI MediaFilter_GetClassID(IMediaFilter *iface, CLSID * pClassID)
4967 {
4968     FIXME("(%p): stub\n", pClassID);
4969
4970     return E_NOTIMPL;
4971 }
4972
4973 static HRESULT WINAPI MediaFilter_Stop(IMediaFilter *iface)
4974 {
4975     struct filter_graph *graph = impl_from_IMediaFilter(iface);
4976     HRESULT hr = S_OK, filter_hr;
4977     struct filter *filter;
4978     TP_WORK *work;
4979
4980     TRACE("graph %p.\n", graph);
4981
4982     EnterCriticalSection(&graph->cs);
4983
4984     if (graph->state == State_Stopped)
4985     {
4986         LeaveCriticalSection(&graph->cs);
4987         return S_OK;
4988     }
4989
4990     sort_filters(graph);
4991
4992     if (graph->state == State_Running)
4993     {
4994         LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
4995         {
4996             filter_hr = IBaseFilter_Pause(filter->filter);
4997             if (hr == S_OK)
4998                 hr = filter_hr;
4999         }
5000     }
5001
5002     LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
5003     {
5004         filter_hr = IBaseFilter_Stop(filter->filter);
5005         if (hr == S_OK)
5006             hr = filter_hr;
5007     }
5008
5009     graph->state = State_Stopped;
5010     graph->needs_async_run = 0;
5011     work = graph->async_run_work;
5012     graph->got_ec_complete = 0;
5013
5014     /* Update the current position, probably to synchronize multiple streams. */
5015     IMediaSeeking_SetPositions(&graph->IMediaSeeking_iface, &graph->current_pos,
5016             AM_SEEKING_AbsolutePositioning, NULL, AM_SEEKING_NoPositioning);
5017
5018     LeaveCriticalSection(&graph->cs);
5019
5020     if (work)
5021         WaitForThreadpoolWorkCallbacks(work, TRUE);
5022
5023     return hr;
5024 }
5025
5026 static HRESULT WINAPI MediaFilter_Pause(IMediaFilter *iface)
5027 {
5028     struct filter_graph *graph = impl_from_IMediaFilter(iface);
5029     HRESULT hr = S_OK, filter_hr;
5030     struct filter *filter;
5031     TP_WORK *work;
5032
5033     TRACE("graph %p.\n", graph);
5034
5035     EnterCriticalSection(&graph->cs);
5036
5037     if (graph->state == State_Paused)
5038     {
5039         LeaveCriticalSection(&graph->cs);
5040         return S_OK;
5041     }
5042
5043     sort_filters(graph);
5044
5045     EnterCriticalSection(&graph->event_cs);
5046     update_render_count(graph);
5047     LeaveCriticalSection(&graph->event_cs);
5048
5049     if (graph->defaultclock && !graph->refClock)
5050         IFilterGraph2_SetDefaultSyncSource(&graph->IFilterGraph2_iface);
5051
5052     if (graph->state == State_Running && graph->refClock)
5053     {
5054         REFERENCE_TIME time;
5055         IReferenceClock_GetTime(graph->refClock, &time);
5056         graph->stream_elapsed += time - graph->stream_start;
5057         graph->current_pos += graph->stream_elapsed;
5058     }
5059
5060     LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
5061     {
5062         filter_hr = IBaseFilter_Pause(filter->filter);
5063         if (hr == S_OK)
5064             hr = filter_hr;
5065     }
5066
5067     graph->state = State_Paused;
5068     graph->needs_async_run = 0;
5069     work = graph->async_run_work;
5070
5071     LeaveCriticalSection(&graph->cs);
5072
5073     if (work)
5074         WaitForThreadpoolWorkCallbacks(work, TRUE);
5075
5076     return hr;
5077 }
5078
5079 static HRESULT WINAPI MediaFilter_Run(IMediaFilter *iface, REFERENCE_TIME start)
5080 {
5081     struct filter_graph *graph = impl_from_IMediaFilter(iface);
5082     HRESULT hr;
5083
5084     TRACE("graph %p, start %s.\n", graph, debugstr_time(start));
5085
5086     EnterCriticalSection(&graph->cs);
5087
5088     if (graph->state == State_Running)
5089     {
5090         LeaveCriticalSection(&graph->cs);
5091         return S_OK;
5092     }
5093
5094     sort_filters(graph);
5095
5096     hr = graph_start(graph, start);
5097
5098     graph->state = State_Running;
5099     graph->needs_async_run = 0;
5100
5101     LeaveCriticalSection(&graph->cs);
5102     return hr;
5103 }
5104
5105 static HRESULT WINAPI MediaFilter_GetState(IMediaFilter *iface, DWORD timeout, FILTER_STATE *state)
5106 {
5107     struct filter_graph *graph = impl_from_IMediaFilter(iface);
5108     DWORD end = GetTickCount() + timeout;
5109     HRESULT hr;
5110
5111     TRACE("graph %p, timeout %u, state %p.\n", graph, timeout, state);
5112
5113     if (!state)
5114         return E_POINTER;
5115
5116     /* Thread safety is a little tricky here. GetState() shouldn't block other
5117      * functions from being called on the filter graph. However, we can't just
5118      * call IBaseFilter::GetState() in one loop and drop the lock on every
5119      * iteration, since the filter list might change beneath us. So instead we
5120      * do what native does, and poll for it every 10 ms. */
5121
5122     EnterCriticalSection(&graph->cs);
5123     *state = graph->state;
5124
5125     for (;;)
5126     {
5127         IBaseFilter *async_filter = NULL;
5128         FILTER_STATE filter_state;
5129         struct filter *filter;
5130
5131         hr = S_OK;
5132
5133         LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
5134         {
5135             HRESULT filter_hr = IBaseFilter_GetState(filter->filter, 0, &filter_state);
5136
5137             TRACE("Filter %p returned hr %#x, state %u.\n", filter->filter, filter_hr, filter_state);
5138
5139             if (filter_hr == VFW_S_STATE_INTERMEDIATE)
5140                 async_filter = filter->filter;
5141
5142             if (hr == S_OK && filter_hr == VFW_S_STATE_INTERMEDIATE)
5143                 hr = VFW_S_STATE_INTERMEDIATE;
5144             else if (filter_hr != S_OK && filter_hr != VFW_S_STATE_INTERMEDIATE)
5145                 hr = filter_hr;
5146
5147             if (hr == S_OK && filter_state == State_Paused && graph->state != State_Paused)
5148             {
5149                 async_filter = filter->filter;
5150                 hr = VFW_S_STATE_INTERMEDIATE;
5151             }
5152             else if (filter_state != graph->state && filter_state != State_Paused)
5153                 hr = E_FAIL;
5154
5155             if (graph->needs_async_run)
5156             {
5157                 if (filter_state != State_Paused && filter_state != State_Running)
5158                     ERR("Filter %p reported incorrect state %u (expected %u or %u).\n",
5159                             filter->filter, filter_state, State_Paused, State_Running);
5160             }
5161             else
5162             {
5163                 if (filter_state != graph->state)
5164                     ERR("Filter %p reported incorrect state %u (expected %u).\n",
5165                             filter->filter, filter_state, graph->state);
5166             }
5167         }
5168
5169         LeaveCriticalSection(&graph->cs);
5170
5171         if (hr != VFW_S_STATE_INTERMEDIATE || (timeout != INFINITE && GetTickCount() >= end))
5172             break;
5173
5174         IBaseFilter_GetState(async_filter, 10, &filter_state);
5175
5176         EnterCriticalSection(&graph->cs);
5177     }
5178
5179     TRACE("Returning %#x, state %u.\n", hr, *state);
5180     return hr;
5181 }
5182
5183 static HRESULT WINAPI MediaFilter_SetSyncSource(IMediaFilter *iface, IReferenceClock *pClock)
5184 {
5185     struct filter_graph *This = impl_from_IMediaFilter(iface);
5186     struct filter *filter;
5187     HRESULT hr = S_OK;
5188
5189     TRACE("(%p/%p)->(%p)\n", This, iface, pClock);
5190
5191     EnterCriticalSection(&This->cs);
5192     {
5193         LIST_FOR_EACH_ENTRY(filter, &This->filters, struct filter, entry)
5194         {
5195             hr = IBaseFilter_SetSyncSource(filter->filter, pClock);
5196             if (FAILED(hr))
5197                 break;
5198         }
5199
5200         if (FAILED(hr))
5201         {
5202             LIST_FOR_EACH_ENTRY(filter, &This->filters, struct filter, entry)
5203                 IBaseFilter_SetSyncSource(filter->filter, This->refClock);
5204         }
5205         else
5206         {
5207             if (This->refClock)
5208                 IReferenceClock_Release(This->refClock);
5209             This->refClock = pClock;
5210             if (This->refClock)
5211                 IReferenceClock_AddRef(This->refClock);
5212             This->defaultclock = FALSE;
5213
5214             if (This->HandleEcClockChanged)
5215             {
5216                 IMediaEventSink *pEventSink;
5217                 HRESULT eshr;
5218
5219                 eshr = IMediaFilter_QueryInterface(iface, &IID_IMediaEventSink, (void **)&pEventSink);
5220                 if (SUCCEEDED(eshr))
5221                 {
5222                     IMediaEventSink_Notify(pEventSink, EC_CLOCK_CHANGED, 0, 0);
5223                     IMediaEventSink_Release(pEventSink);
5224                 }
5225             }
5226         }
5227     }
5228     LeaveCriticalSection(&This->cs);
5229
5230     return hr;
5231 }
5232
5233 static HRESULT WINAPI MediaFilter_GetSyncSource(IMediaFilter *iface, IReferenceClock **ppClock)
5234 {
5235     struct filter_graph *This = impl_from_IMediaFilter(iface);
5236
5237     TRACE("(%p/%p)->(%p)\n", This, iface, ppClock);
5238
5239     if (!ppClock)
5240         return E_POINTER;
5241
5242     EnterCriticalSection(&This->cs);
5243     {
5244         *ppClock = This->refClock;
5245         if (*ppClock)
5246             IReferenceClock_AddRef(*ppClock);
5247     }
5248     LeaveCriticalSection(&This->cs);
5249
5250     return S_OK;
5251 }
5252
5253 static const IMediaFilterVtbl IMediaFilter_VTable =
5254 {
5255     MediaFilter_QueryInterface,
5256     MediaFilter_AddRef,
5257     MediaFilter_Release,
5258     MediaFilter_GetClassID,
5259     MediaFilter_Stop,
5260     MediaFilter_Pause,
5261     MediaFilter_Run,
5262     MediaFilter_GetState,
5263     MediaFilter_SetSyncSource,
5264     MediaFilter_GetSyncSource
5265 };
5266
5267 static struct filter_graph *impl_from_IMediaEventSink(IMediaEventSink *iface)
5268 {
5269     return CONTAINING_RECORD(iface, struct filter_graph, IMediaEventSink_iface);
5270 }
5271
5272 static HRESULT WINAPI MediaEventSink_QueryInterface(IMediaEventSink *iface, REFIID iid, void **out)
5273 {
5274     struct filter_graph *graph = impl_from_IMediaEventSink(iface);
5275
5276     return IUnknown_QueryInterface(graph->outer_unk, iid, out);
5277 }
5278
5279 static ULONG WINAPI MediaEventSink_AddRef(IMediaEventSink *iface)
5280 {
5281     struct filter_graph *graph = impl_from_IMediaEventSink(iface);
5282
5283     return IUnknown_AddRef(graph->outer_unk);
5284 }
5285
5286 static ULONG WINAPI MediaEventSink_Release(IMediaEventSink *iface)
5287 {
5288     struct filter_graph *graph = impl_from_IMediaEventSink(iface);
5289
5290     return IUnknown_Release(graph->outer_unk);
5291 }
5292
5293 static HRESULT WINAPI MediaEventSink_Notify(IMediaEventSink *iface, LONG code,
5294         LONG_PTR param1, LONG_PTR param2)
5295 {
5296     struct filter_graph *graph = impl_from_IMediaEventSink(iface);
5297
5298     TRACE("graph %p, code %#x, param1 %#Ix, param2 %#Ix.\n", graph, code, param1, param2);
5299
5300     EnterCriticalSection(&graph->event_cs);
5301
5302     if (code == EC_COMPLETE && graph->HandleEcComplete)
5303     {
5304         if (++graph->EcCompleteCount == graph->nRenderers)
5305         {
5306             if (graph->media_events_disabled)
5307                 SetEvent(graph->media_event_handle);
5308             else
5309                 queue_media_event(graph, EC_COMPLETE, S_OK, 0);
5310             graph->CompletionStatus = EC_COMPLETE;
5311             graph->got_ec_complete = 1;
5312             SetEvent(graph->hEventCompletion);
5313         }
5314     }
5315     else if ((code == EC_REPAINT) && graph->HandleEcRepaint)
5316     {
5317         FIXME("EC_REPAINT is not handled.\n");
5318     }
5319     else if (!graph->media_events_disabled)
5320     {
5321         queue_media_event(graph, code, param1, param2);
5322     }
5323
5324     LeaveCriticalSection(&graph->event_cs);
5325     return S_OK;
5326 }
5327
5328 static const IMediaEventSinkVtbl IMediaEventSink_VTable =
5329 {
5330     MediaEventSink_QueryInterface,
5331     MediaEventSink_AddRef,
5332     MediaEventSink_Release,
5333     MediaEventSink_Notify
5334 };
5335
5336 static struct filter_graph *impl_from_IGraphConfig(IGraphConfig *iface)
5337 {
5338     return CONTAINING_RECORD(iface, struct filter_graph, IGraphConfig_iface);
5339 }
5340
5341 static HRESULT WINAPI GraphConfig_QueryInterface(IGraphConfig *iface, REFIID iid, void **out)
5342 {
5343     struct filter_graph *graph = impl_from_IGraphConfig(iface);
5344
5345     return IUnknown_QueryInterface(graph->outer_unk, iid, out);
5346 }
5347
5348 static ULONG WINAPI GraphConfig_AddRef(IGraphConfig *iface)
5349 {
5350     struct filter_graph *graph = impl_from_IGraphConfig(iface);
5351
5352     return IUnknown_AddRef(graph->outer_unk);
5353 }
5354
5355 static ULONG WINAPI GraphConfig_Release(IGraphConfig *iface)
5356 {
5357     struct filter_graph *graph = impl_from_IGraphConfig(iface);
5358
5359     return IUnknown_Release(graph->outer_unk);
5360 }
5361
5362 static HRESULT WINAPI GraphConfig_Reconnect(IGraphConfig *iface, IPin *pOutputPin, IPin *pInputPin,
5363         const AM_MEDIA_TYPE *pmtFirstConnection, IBaseFilter *pUsingFilter, HANDLE hAbortEvent,
5364         DWORD dwFlags)
5365 {
5366     struct filter_graph *This = impl_from_IGraphConfig(iface);
5367
5368     FIXME("(%p)->(%p, %p, %p, %p, %p, %x): stub!\n", This, pOutputPin, pInputPin, pmtFirstConnection, pUsingFilter, hAbortEvent, dwFlags);
5369     strmbase_dump_media_type(pmtFirstConnection);
5370
5371     return E_NOTIMPL;
5372 }
5373
5374 static HRESULT WINAPI GraphConfig_Reconfigure(IGraphConfig *iface, IGraphConfigCallback *pCallback,
5375         void *pvContext, DWORD dwFlags, HANDLE hAbortEvent)
5376 {
5377     struct filter_graph *This = impl_from_IGraphConfig(iface);
5378     HRESULT hr;
5379
5380     WARN("(%p)->(%p, %p, %x, %p): partial stub!\n", This, pCallback, pvContext, dwFlags, hAbortEvent);
5381
5382     if (hAbortEvent)
5383         FIXME("The parameter hAbortEvent is not handled!\n");
5384
5385     EnterCriticalSection(&This->cs);
5386
5387     hr = IGraphConfigCallback_Reconfigure(pCallback, pvContext, dwFlags);
5388
5389     LeaveCriticalSection(&This->cs);
5390
5391     return hr;
5392 }
5393
5394 static HRESULT WINAPI GraphConfig_AddFilterToCache(IGraphConfig *iface, IBaseFilter *pFilter)
5395 {
5396     struct filter_graph *This = impl_from_IGraphConfig(iface);
5397
5398     FIXME("(%p)->(%p): stub!\n", This, pFilter);
5399
5400     return E_NOTIMPL;
5401 }
5402
5403 static HRESULT WINAPI GraphConfig_EnumCacheFilter(IGraphConfig *iface, IEnumFilters **pEnum)
5404 {
5405     struct filter_graph *This = impl_from_IGraphConfig(iface);
5406
5407     FIXME("(%p)->(%p): stub!\n", This, pEnum);
5408
5409     return E_NOTIMPL;
5410 }
5411
5412 static HRESULT WINAPI GraphConfig_RemoveFilterFromCache(IGraphConfig *iface, IBaseFilter *pFilter)
5413 {
5414     struct filter_graph *This = impl_from_IGraphConfig(iface);
5415
5416     FIXME("(%p)->(%p): stub!\n", This, pFilter);
5417
5418     return E_NOTIMPL;
5419 }
5420
5421 static HRESULT WINAPI GraphConfig_GetStartTime(IGraphConfig *iface, REFERENCE_TIME *prtStart)
5422 {
5423     struct filter_graph *This = impl_from_IGraphConfig(iface);
5424
5425     FIXME("(%p)->(%p): stub!\n", This, prtStart);
5426
5427     return E_NOTIMPL;
5428 }
5429
5430 static HRESULT WINAPI GraphConfig_PushThroughData(IGraphConfig *iface, IPin *pOutputPin,
5431         IPinConnection *pConnection, HANDLE hEventAbort)
5432 {
5433     struct filter_graph *This = impl_from_IGraphConfig(iface);
5434
5435     FIXME("(%p)->(%p, %p, %p): stub!\n", This, pOutputPin, pConnection, hEventAbort);
5436
5437     return E_NOTIMPL;
5438 }
5439
5440 static HRESULT WINAPI GraphConfig_SetFilterFlags(IGraphConfig *iface, IBaseFilter *pFilter,
5441         DWORD dwFlags)
5442 {
5443     struct filter_graph *This = impl_from_IGraphConfig(iface);
5444
5445     FIXME("(%p)->(%p, %x): stub!\n", This, pFilter, dwFlags);
5446
5447     return E_NOTIMPL;
5448 }
5449
5450 static HRESULT WINAPI GraphConfig_GetFilterFlags(IGraphConfig *iface, IBaseFilter *pFilter,
5451         DWORD *dwFlags)
5452 {
5453     struct filter_graph *This = impl_from_IGraphConfig(iface);
5454
5455     FIXME("(%p)->(%p, %p): stub!\n", This, pFilter, dwFlags);
5456
5457     return E_NOTIMPL;
5458 }
5459
5460 static HRESULT WINAPI GraphConfig_RemoveFilterEx(IGraphConfig *iface, IBaseFilter *pFilter,
5461         DWORD dwFlags)
5462 {
5463     struct filter_graph *This = impl_from_IGraphConfig(iface);
5464
5465     FIXME("(%p)->(%p, %x): stub!\n", This, pFilter, dwFlags);
5466
5467     return E_NOTIMPL;
5468 }
5469
5470 static const IGraphConfigVtbl IGraphConfig_VTable =
5471 {
5472     GraphConfig_QueryInterface,
5473     GraphConfig_AddRef,
5474     GraphConfig_Release,
5475     GraphConfig_Reconnect,
5476     GraphConfig_Reconfigure,
5477     GraphConfig_AddFilterToCache,
5478     GraphConfig_EnumCacheFilter,
5479     GraphConfig_RemoveFilterFromCache,
5480     GraphConfig_GetStartTime,
5481     GraphConfig_PushThroughData,
5482     GraphConfig_SetFilterFlags,
5483     GraphConfig_GetFilterFlags,
5484     GraphConfig_RemoveFilterEx
5485 };
5486
5487 static struct filter_graph *impl_from_IGraphVersion(IGraphVersion *iface)
5488 {
5489     return CONTAINING_RECORD(iface, struct filter_graph, IGraphVersion_iface);
5490 }
5491
5492 static HRESULT WINAPI GraphVersion_QueryInterface(IGraphVersion *iface, REFIID iid, void **out)
5493 {
5494     struct filter_graph *graph = impl_from_IGraphVersion(iface);
5495
5496     return IUnknown_QueryInterface(graph->outer_unk, iid, out);
5497 }
5498
5499 static ULONG WINAPI GraphVersion_AddRef(IGraphVersion *iface)
5500 {
5501     struct filter_graph *graph = impl_from_IGraphVersion(iface);
5502
5503     return IUnknown_AddRef(graph->outer_unk);
5504 }
5505
5506 static ULONG WINAPI GraphVersion_Release(IGraphVersion *iface)
5507 {
5508     struct filter_graph *graph = impl_from_IGraphVersion(iface);
5509
5510     return IUnknown_Release(graph->outer_unk);
5511 }
5512
5513 static HRESULT WINAPI GraphVersion_QueryVersion(IGraphVersion *iface, LONG *pVersion)
5514 {
5515     struct filter_graph *This = impl_from_IGraphVersion(iface);
5516
5517     if(!pVersion)
5518         return E_POINTER;
5519
5520     TRACE("(%p)->(%p): current version %i\n", This, pVersion, This->version);
5521
5522     *pVersion = This->version;
5523     return S_OK;
5524 }
5525
5526 static const IGraphVersionVtbl IGraphVersion_VTable =
5527 {
5528     GraphVersion_QueryInterface,
5529     GraphVersion_AddRef,
5530     GraphVersion_Release,
5531     GraphVersion_QueryVersion,
5532 };
5533
5534 static struct filter_graph *impl_from_IVideoFrameStep(IVideoFrameStep *iface)
5535 {
5536     return CONTAINING_RECORD(iface, struct filter_graph, IVideoFrameStep_iface);
5537 }
5538
5539 static HRESULT WINAPI VideoFrameStep_QueryInterface(IVideoFrameStep *iface, REFIID iid, void **out)
5540 {
5541     struct filter_graph *graph = impl_from_IVideoFrameStep(iface);
5542     return IUnknown_QueryInterface(graph->outer_unk, iid, out);
5543 }
5544
5545 static ULONG WINAPI VideoFrameStep_AddRef(IVideoFrameStep *iface)
5546 {
5547     struct filter_graph *graph = impl_from_IVideoFrameStep(iface);
5548     return IUnknown_AddRef(graph->outer_unk);
5549 }
5550
5551 static ULONG WINAPI VideoFrameStep_Release(IVideoFrameStep *iface)
5552 {
5553     struct filter_graph *graph = impl_from_IVideoFrameStep(iface);
5554     return IUnknown_Release(graph->outer_unk);
5555 }
5556
5557 static HRESULT WINAPI VideoFrameStep_Step(IVideoFrameStep *iface, DWORD frame_count, IUnknown *filter)
5558 {
5559     FIXME("iface %p, frame_count %u, filter %p, stub!\n", iface, frame_count, filter);
5560     return E_NOTIMPL;
5561 }
5562
5563 static HRESULT WINAPI VideoFrameStep_CanStep(IVideoFrameStep *iface, LONG multiple, IUnknown *filter)
5564 {
5565     FIXME("iface %p, multiple %d, filter %p, stub!\n", iface, multiple, filter);
5566     return E_NOTIMPL;
5567 }
5568
5569 static HRESULT WINAPI VideoFrameStep_CancelStep(IVideoFrameStep *iface)
5570 {
5571     FIXME("iface %p, stub!\n", iface);
5572     return E_NOTIMPL;
5573 }
5574
5575 static const IVideoFrameStepVtbl VideoFrameStep_vtbl =
5576 {
5577     VideoFrameStep_QueryInterface,
5578     VideoFrameStep_AddRef,
5579     VideoFrameStep_Release,
5580     VideoFrameStep_Step,
5581     VideoFrameStep_CanStep,
5582     VideoFrameStep_CancelStep
5583 };
5584
5585 static const IUnknownVtbl IInner_VTable =
5586 {
5587     FilterGraphInner_QueryInterface,
5588     FilterGraphInner_AddRef,
5589     FilterGraphInner_Release
5590 };
5591
5592 static HRESULT filter_graph_common_create(IUnknown *outer, IUnknown **out, BOOL threaded)
5593 {
5594     struct filter_graph *object;
5595     HRESULT hr;
5596
5597     *out = NULL;
5598
5599     if (!(object = calloc(1, sizeof(*object))))
5600         return E_OUTOFMEMORY;
5601
5602     object->IBasicAudio_iface.lpVtbl = &IBasicAudio_VTable;
5603     object->IBasicVideo2_iface.lpVtbl = &IBasicVideo_VTable;
5604     object->IFilterGraph2_iface.lpVtbl = &IFilterGraph2_VTable;
5605     object->IGraphConfig_iface.lpVtbl = &IGraphConfig_VTable;
5606     object->IGraphVersion_iface.lpVtbl = &IGraphVersion_VTable;
5607     object->IMediaControl_iface.lpVtbl = &IMediaControl_VTable;
5608     object->IMediaEventEx_iface.lpVtbl = &IMediaEventEx_VTable;
5609     object->IMediaEventSink_iface.lpVtbl = &IMediaEventSink_VTable;
5610     object->IMediaFilter_iface.lpVtbl = &IMediaFilter_VTable;
5611     object->IMediaPosition_iface.lpVtbl = &IMediaPosition_VTable;
5612     object->IMediaSeeking_iface.lpVtbl = &IMediaSeeking_VTable;
5613     object->IObjectWithSite_iface.lpVtbl = &IObjectWithSite_VTable;
5614     object->IUnknown_inner.lpVtbl = &IInner_VTable;
5615     object->IVideoFrameStep_iface.lpVtbl = &VideoFrameStep_vtbl;
5616     object->IVideoWindow_iface.lpVtbl = &IVideoWindow_VTable;
5617     object->ref = 1;
5618     object->outer_unk = outer ? outer : &object->IUnknown_inner;
5619
5620     if (FAILED(hr = CoCreateInstance(&CLSID_FilterMapper2, object->outer_unk,
5621             CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)&object->punkFilterMapper2)))
5622     {
5623         ERR("Failed to create filter mapper, hr %#x.\n", hr);
5624         free(object);
5625         return hr;
5626     }
5627
5628     InitializeCriticalSection(&object->cs);
5629     object->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": filter_graph.cs");
5630     InitializeCriticalSection(&object->event_cs);
5631     object->event_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": filter_graph.event_cs");
5632
5633     object->defaultclock = TRUE;
5634
5635     object->media_event_handle = CreateEventW(NULL, TRUE, FALSE, NULL);
5636     list_init(&object->media_events);
5637     list_init(&object->filters);
5638     object->HandleEcClockChanged = TRUE;
5639     object->HandleEcComplete = TRUE;
5640     object->HandleEcRepaint = TRUE;
5641     object->hEventCompletion = CreateEventW(0, TRUE, FALSE, 0);
5642
5643     object->name_index = 1;
5644     object->timeformatseek = TIME_FORMAT_MEDIA_TIME;
5645
5646     if (threaded)
5647     {
5648         object->message_thread_ret = CreateEventW(NULL, FALSE, FALSE, NULL);
5649         object->message_thread = CreateThread(NULL, 0, message_thread_run, object, 0, &object->message_thread_id);
5650         WaitForSingleObject(object->message_thread_ret, INFINITE);
5651     }
5652     else
5653         object->message_thread = NULL;
5654
5655     TRACE("Created %sthreaded filter graph %p.\n", threaded ? "" : "non-", object);
5656     *out = &object->IUnknown_inner;
5657     return S_OK;
5658 }
5659
5660 HRESULT filter_graph_create(IUnknown *outer, IUnknown **out)
5661 {
5662     return filter_graph_common_create(outer, out, TRUE);
5663 }
5664
5665 HRESULT filter_graph_no_thread_create(IUnknown *outer, IUnknown **out)
5666 {
5667     return filter_graph_common_create(outer, out, FALSE);
5668 }