dlls/amstream/filter.c

   1 /*
   2  * Implementation of MediaStream Filter
   3  *
   4  * Copyright 2008, 2012 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 #define COBJMACROS
  22 #include "amstream_private.h"
  23 #include "wine/debug.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(amstream);
  26
  27 struct enum_pins
  28 {
  29     IEnumPins IEnumPins_iface;
  30     LONG refcount;
  31
  32     IPin **pins;
  33     unsigned int count, index;
  34 };
  35
  36 static const IEnumPinsVtbl enum_pins_vtbl;
  37
  38 static struct enum_pins *impl_from_IEnumPins(IEnumPins *iface)
  39 {
  40     return CONTAINING_RECORD(iface, struct enum_pins, IEnumPins_iface);
  41 }
  42
  43 static HRESULT WINAPI enum_pins_QueryInterface(IEnumPins *iface, REFIID iid, void **out)
  44 {
  45     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  46
  47     if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IEnumPins))
  48     {
  49         IEnumPins_AddRef(iface);
  50         *out = iface;
  51         return S_OK;
  52     }
  53
  54     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  55     *out = NULL;
  56     return E_NOINTERFACE;
  57 }
  58
  59 static ULONG WINAPI enum_pins_AddRef(IEnumPins *iface)
  60 {
  61     struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
  62     ULONG refcount = InterlockedIncrement(&enum_pins->refcount);
  63     TRACE("%p increasing refcount to %u.\n", enum_pins, refcount);
  64     return refcount;
  65 }
  66
  67 static ULONG WINAPI enum_pins_Release(IEnumPins *iface)
  68 {
  69     struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
  70     ULONG refcount = InterlockedDecrement(&enum_pins->refcount);
  71     unsigned int i;
  72
  73     TRACE("%p decreasing refcount to %u.\n", enum_pins, refcount);
  74     if (!refcount)
  75     {
  76         for (i = 0; i < enum_pins->count; ++i)
  77             IPin_Release(enum_pins->pins[i]);
  78         heap_free(enum_pins->pins);
  79         heap_free(enum_pins);
  80     }
  81     return refcount;
  82 }
  83
  84 static HRESULT WINAPI enum_pins_Next(IEnumPins *iface, ULONG count, IPin **pins, ULONG *ret_count)
  85 {
  86     struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
  87     unsigned int i;
  88
  89     TRACE("iface %p, count %u, pins %p, ret_count %p.\n", iface, count, pins, ret_count);
  90
  91     if (!pins || (count > 1 && !ret_count))
  92         return E_POINTER;
  93
  94     for (i = 0; i < count && enum_pins->index < enum_pins->count; ++i)
  95     {
  96         IPin_AddRef(pins[i] = enum_pins->pins[i]);
  97         enum_pins->index++;
  98     }
  99
 100     if (ret_count) *ret_count = i;
 101     return i == count ? S_OK : S_FALSE;
 102 }
 103
 104 static HRESULT WINAPI enum_pins_Skip(IEnumPins *iface, ULONG count)
 105 {
 106     struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
 107
 108     TRACE("iface %p, count %u.\n", iface, count);
 109
 110     enum_pins->index += count;
 111
 112     return enum_pins->index >= enum_pins->count ? S_FALSE : S_OK;
 113 }
 114
 115 static HRESULT WINAPI enum_pins_Reset(IEnumPins *iface)
 116 {
 117     struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
 118
 119     TRACE("iface %p.\n", iface);
 120
 121     enum_pins->index = 0;
 122     return S_OK;
 123 }
 124
 125 static HRESULT WINAPI enum_pins_Clone(IEnumPins *iface, IEnumPins **out)
 126 {
 127     struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
 128     struct enum_pins *object;
 129     unsigned int i;
 130
 131     TRACE("iface %p, out %p.\n", iface, out);
 132
 133     if (!(object = heap_alloc(sizeof(*object))))
 134         return E_OUTOFMEMORY;
 135
 136     object->IEnumPins_iface.lpVtbl = &enum_pins_vtbl;
 137     object->refcount = 1;
 138     object->count = enum_pins->count;
 139     object->index = enum_pins->index;
 140     if (!(object->pins = heap_alloc(enum_pins->count * sizeof(*object->pins))))
 141     {
 142         heap_free(object);
 143         return E_OUTOFMEMORY;
 144     }
 145     for (i = 0; i < enum_pins->count; ++i)
 146         IPin_AddRef(object->pins[i] = enum_pins->pins[i]);
 147
 148     *out = &object->IEnumPins_iface;
 149     return S_OK;
 150 }
 151
 152 static const IEnumPinsVtbl enum_pins_vtbl =
 153 {
 154     enum_pins_QueryInterface,
 155     enum_pins_AddRef,
 156     enum_pins_Release,
 157     enum_pins_Next,
 158     enum_pins_Skip,
 159     enum_pins_Reset,
 160     enum_pins_Clone,
 161 };
 162
 163 struct filter
 164 {
 165     IMediaStreamFilter IMediaStreamFilter_iface;
 166     IMediaSeeking IMediaSeeking_iface;
 167     LONG refcount;
 168     CRITICAL_SECTION cs;
 169
 170     IReferenceClock *clock;
 171     WCHAR name[128];
 172     IFilterGraph *graph;
 173     ULONG nb_streams;
 174     IAMMediaStream **streams;
 175     IAMMediaStream *seekable_stream;
 176     FILTER_STATE state;
 177 };
 178
 179 static inline struct filter *impl_from_IMediaStreamFilter(IMediaStreamFilter *iface)
 180 {
 181     return CONTAINING_RECORD(iface, struct filter, IMediaStreamFilter_iface);
 182 }
 183
 184 static HRESULT WINAPI filter_QueryInterface(IMediaStreamFilter *iface, REFIID iid, void **out)
 185 {
 186     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 187
 188     TRACE("filter %p, iid %s, out %p.\n", filter, debugstr_guid(iid), out);
 189
 190     *out = NULL;
 191
 192     if (IsEqualGUID(iid, &IID_IUnknown)
 193             || IsEqualGUID(iid, &IID_IPersist)
 194             || IsEqualGUID(iid, &IID_IMediaFilter)
 195             || IsEqualGUID(iid, &IID_IBaseFilter)
 196             || IsEqualGUID(iid, &IID_IMediaStreamFilter))
 197         *out = iface;
 198     else if (IsEqualGUID(iid, &IID_IMediaSeeking) && filter->seekable_stream)
 199         *out = &filter->IMediaSeeking_iface;
 200     else
 201         return E_NOINTERFACE;
 202
 203     IUnknown_AddRef((IUnknown *)*out);
 204     return S_OK;
 205 }
 206
 207 static ULONG WINAPI filter_AddRef(IMediaStreamFilter *iface)
 208 {
 209     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 210     ULONG refcount = InterlockedIncrement(&filter->refcount);
 211
 212     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 213
 214     return refcount;
 215 }
 216
 217 static ULONG WINAPI filter_Release(IMediaStreamFilter *iface)
 218 {
 219     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 220     ULONG refcount = InterlockedDecrement(&filter->refcount);
 221     unsigned int i;
 222
 223     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 224
 225     if (!refcount)
 226     {
 227         for (i = 0; i < filter->nb_streams; ++i)
 228         {
 229             IAMMediaStream_JoinFilter(filter->streams[i], NULL);
 230             IAMMediaStream_Release(filter->streams[i]);
 231         }
 232         heap_free(filter->streams);
 233         if (filter->clock)
 234             IReferenceClock_Release(filter->clock);
 235         DeleteCriticalSection(&filter->cs);
 236         heap_free(filter);
 237     }
 238
 239     return refcount;
 240 }
 241
 242 static HRESULT WINAPI filter_GetClassID(IMediaStreamFilter *iface, CLSID *clsid)
 243 {
 244     *clsid = CLSID_MediaStreamFilter;
 245     return S_OK;
 246 }
 247
 248 static void set_state(struct filter *filter, FILTER_STATE state)
 249 {
 250     if (filter->state != state)
 251     {
 252         ULONG i;
 253
 254         for (i = 0; i < filter->nb_streams; ++i)
 255             IAMMediaStream_SetState(filter->streams[i], state);
 256         filter->state = state;
 257     }
 258 }
 259
 260 static HRESULT WINAPI filter_Stop(IMediaStreamFilter *iface)
 261 {
 262     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 263
 264     TRACE("iface %p.\n", iface);
 265
 266     EnterCriticalSection(&filter->cs);
 267
 268     set_state(filter, State_Stopped);
 269
 270     LeaveCriticalSection(&filter->cs);
 271
 272     return S_OK;
 273 }
 274
 275 static HRESULT WINAPI filter_Pause(IMediaStreamFilter *iface)
 276 {
 277     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 278
 279     TRACE("iface %p.\n", iface);
 280
 281     EnterCriticalSection(&filter->cs);
 282
 283     set_state(filter, State_Paused);
 284
 285     LeaveCriticalSection(&filter->cs);
 286
 287     return S_OK;
 288 }
 289
 290 static HRESULT WINAPI filter_Run(IMediaStreamFilter *iface, REFERENCE_TIME start)
 291 {
 292     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 293
 294     TRACE("iface %p, start %s.\n", iface, wine_dbgstr_longlong(start));
 295
 296     EnterCriticalSection(&filter->cs);
 297
 298     set_state(filter, State_Running);
 299
 300     LeaveCriticalSection(&filter->cs);
 301
 302     return S_OK;
 303 }
 304
 305 static HRESULT WINAPI filter_GetState(IMediaStreamFilter *iface, DWORD timeout, FILTER_STATE *state)
 306 {
 307     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 308
 309     TRACE("iface %p, timeout %u, state %p.\n", iface, timeout, state);
 310
 311     if (!state)
 312         return E_POINTER;
 313
 314     EnterCriticalSection(&filter->cs);
 315
 316     *state = filter->state;
 317
 318     LeaveCriticalSection(&filter->cs);
 319
 320     return S_OK;
 321 }
 322
 323 static HRESULT WINAPI filter_SetSyncSource(IMediaStreamFilter *iface, IReferenceClock *clock)
 324 {
 325     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 326
 327     TRACE("iface %p, clock %p.\n", iface, clock);
 328
 329     EnterCriticalSection(&filter->cs);
 330
 331     if (clock)
 332         IReferenceClock_AddRef(clock);
 333     if (filter->clock)
 334         IReferenceClock_Release(filter->clock);
 335     filter->clock = clock;
 336
 337     LeaveCriticalSection(&filter->cs);
 338
 339     return S_OK;
 340 }
 341
 342 static HRESULT WINAPI filter_GetSyncSource(IMediaStreamFilter *iface, IReferenceClock **clock)
 343 {
 344     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 345
 346     TRACE("iface %p, clock %p.\n", iface, clock);
 347
 348     EnterCriticalSection(&filter->cs);
 349
 350     if (filter->clock)
 351         IReferenceClock_AddRef(filter->clock);
 352     *clock = filter->clock;
 353
 354     LeaveCriticalSection(&filter->cs);
 355
 356     return S_OK;
 357 }
 358
 359 static HRESULT WINAPI filter_EnumPins(IMediaStreamFilter *iface, IEnumPins **enum_pins)
 360 {
 361     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 362     struct enum_pins *object;
 363     unsigned int i;
 364
 365     TRACE("iface %p, enum_pins %p.\n", iface, enum_pins);
 366
 367     if (!enum_pins)
 368         return E_POINTER;
 369
 370     if (!(object = heap_alloc(sizeof(*object))))
 371         return E_OUTOFMEMORY;
 372
 373     EnterCriticalSection(&filter->cs);
 374
 375     object->IEnumPins_iface.lpVtbl = &enum_pins_vtbl;
 376     object->refcount = 1;
 377     object->count = filter->nb_streams;
 378     object->index = 0;
 379     if (!(object->pins = heap_alloc(filter->nb_streams * sizeof(*object->pins))))
 380     {
 381         heap_free(object);
 382         LeaveCriticalSection(&filter->cs);
 383         return E_OUTOFMEMORY;
 384     }
 385     for (i = 0; i < filter->nb_streams; ++i)
 386     {
 387         if (FAILED(IAMMediaStream_QueryInterface(filter->streams[i], &IID_IPin, (void **)&object->pins[i])))
 388             WARN("Stream %p does not support IPin.\n", filter->streams[i]);
 389     }
 390
 391     LeaveCriticalSection(&filter->cs);
 392
 393     *enum_pins = &object->IEnumPins_iface;
 394     return S_OK;
 395 }
 396
 397 static HRESULT WINAPI filter_FindPin(IMediaStreamFilter *iface, const WCHAR *id, IPin **out)
 398 {
 399     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 400     unsigned int i;
 401     WCHAR *ret_id;
 402     IPin *pin;
 403
 404     TRACE("iface %p, id %s, out %p.\n", iface, debugstr_w(id), out);
 405
 406     EnterCriticalSection(&filter->cs);
 407
 408     for (i = 0; i < filter->nb_streams; ++i)
 409     {
 410         if (FAILED(IAMMediaStream_QueryInterface(filter->streams[i], &IID_IPin, (void **)&pin)))
 411         {
 412             WARN("Stream %p does not support IPin.\n", filter->streams[i]);
 413             continue;
 414         }
 415
 416         if (SUCCEEDED(IPin_QueryId(pin, &ret_id)))
 417         {
 418             if (!wcscmp(id, ret_id))
 419             {
 420                 CoTaskMemFree(ret_id);
 421                 *out = pin;
 422                 LeaveCriticalSection(&filter->cs);
 423                 return S_OK;
 424             }
 425             CoTaskMemFree(ret_id);
 426         }
 427         IPin_Release(pin);
 428     }
 429
 430     LeaveCriticalSection(&filter->cs);
 431
 432     return VFW_E_NOT_FOUND;
 433 }
 434
 435 static HRESULT WINAPI filter_QueryFilterInfo(IMediaStreamFilter *iface, FILTER_INFO *info)
 436 {
 437     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 438
 439     TRACE("iface %p, info %p.\n", iface, info);
 440
 441     EnterCriticalSection(&filter->cs);
 442
 443     wcscpy(info->achName, filter->name);
 444     if (filter->graph)
 445         IFilterGraph_AddRef(filter->graph);
 446     info->pGraph = filter->graph;
 447
 448     LeaveCriticalSection(&filter->cs);
 449
 450     return S_OK;
 451 }
 452
 453 static HRESULT WINAPI filter_JoinFilterGraph(IMediaStreamFilter *iface,
 454         IFilterGraph *graph, const WCHAR *name)
 455 {
 456     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 457
 458     TRACE("iface %p, graph %p, name.%s.\n", iface, graph, debugstr_w(name));
 459
 460     EnterCriticalSection(&filter->cs);
 461
 462     if (name)
 463         wcsncpy(filter->name, name, ARRAY_SIZE(filter->name));
 464     else
 465         filter->name[0] = 0;
 466     filter->graph = graph;
 467
 468     LeaveCriticalSection(&filter->cs);
 469
 470     return S_OK;
 471 }
 472
 473 static HRESULT WINAPI filter_QueryVendorInfo(IMediaStreamFilter *iface, LPWSTR *vendor_info)
 474 {
 475     WARN("iface %p, vendor_info %p, stub!\n", iface, vendor_info);
 476     return E_NOTIMPL;
 477 }
 478
 479 /*** IMediaStreamFilter methods ***/
 480
 481 static HRESULT WINAPI filter_AddMediaStream(IMediaStreamFilter *iface, IAMMediaStream *pAMMediaStream)
 482 {
 483     struct filter *This = impl_from_IMediaStreamFilter(iface);
 484     IAMMediaStream** streams;
 485     HRESULT hr;
 486
 487     TRACE("(%p)->(%p)\n", iface, pAMMediaStream);
 488
 489     streams = CoTaskMemRealloc(This->streams, (This->nb_streams + 1) * sizeof(IAMMediaStream*));
 490     if (!streams)
 491         return E_OUTOFMEMORY;
 492     This->streams = streams;
 493
 494     hr = IAMMediaStream_JoinFilter(pAMMediaStream, iface);
 495     if (FAILED(hr))
 496         return hr;
 497
 498     This->streams[This->nb_streams] = pAMMediaStream;
 499     This->nb_streams++;
 500
 501     IAMMediaStream_AddRef(pAMMediaStream);
 502
 503     return S_OK;
 504 }
 505
 506 static HRESULT WINAPI filter_GetMediaStream(IMediaStreamFilter *iface, REFMSPID idPurpose, IMediaStream **ppMediaStream)
 507 {
 508     struct filter *This = impl_from_IMediaStreamFilter(iface);
 509     MSPID purpose_id;
 510     unsigned int i;
 511
 512     TRACE("(%p)->(%s,%p)\n", iface, debugstr_guid(idPurpose), ppMediaStream);
 513
 514     for (i = 0; i < This->nb_streams; i++)
 515     {
 516         IAMMediaStream_GetInformation(This->streams[i], &purpose_id, NULL);
 517         if (IsEqualIID(&purpose_id, idPurpose))
 518         {
 519             *ppMediaStream = (IMediaStream *)This->streams[i];
 520             IMediaStream_AddRef(*ppMediaStream);
 521             return S_OK;
 522         }
 523     }
 524
 525     return MS_E_NOSTREAM;
 526 }
 527
 528 static HRESULT WINAPI filter_EnumMediaStreams(IMediaStreamFilter *iface, LONG index, IMediaStream **stream)
 529 {
 530     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 531
 532     TRACE("filter %p, index %d, stream %p.\n", filter, index, stream);
 533
 534     if (index >= filter->nb_streams)
 535         return S_FALSE;
 536
 537     if (!stream)
 538         return E_POINTER;
 539
 540     IMediaStream_AddRef(*stream = (IMediaStream *)filter->streams[index]);
 541     return S_OK;
 542 }
 543
 544 static IMediaSeeking *get_seeking(IAMMediaStream *stream)
 545 {
 546     IMediaSeeking *seeking;
 547     IPin *pin, *peer;
 548     HRESULT hr;
 549
 550     if (FAILED(IAMMediaStream_QueryInterface(stream, &IID_IPin, (void **)&pin)))
 551     {
 552         WARN("Stream %p does not support IPin.\n", stream);
 553         return NULL;
 554     }
 555
 556     hr = IPin_ConnectedTo(pin, &peer);
 557     IPin_Release(pin);
 558     if (FAILED(hr))
 559         return NULL;
 560
 561     hr = IPin_QueryInterface(peer, &IID_IMediaSeeking, (void **)&seeking);
 562     IPin_Release(peer);
 563     if (FAILED(hr))
 564         return NULL;
 565
 566     return seeking;
 567 }
 568
 569 static HRESULT WINAPI filter_SupportSeeking(IMediaStreamFilter *iface, BOOL renderer)
 570 {
 571     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 572     unsigned int i;
 573
 574     TRACE("filter %p, renderer %d\n", iface, renderer);
 575
 576     if (!renderer)
 577         FIXME("Non-renderer filter support is not yet implemented.\n");
 578
 579     EnterCriticalSection(&filter->cs);
 580
 581     if (filter->seekable_stream)
 582     {
 583         LeaveCriticalSection(&filter->cs);
 584         return HRESULT_FROM_WIN32(ERROR_ALREADY_INITIALIZED);
 585     }
 586
 587     for (i = 0; i < filter->nb_streams; ++i)
 588     {
 589         IMediaSeeking *seeking = get_seeking(filter->streams[i]);
 590         LONGLONG duration;
 591
 592         if (!seeking)
 593             continue;
 594
 595         if (SUCCEEDED(IMediaSeeking_GetDuration(seeking, &duration)))
 596         {
 597             filter->seekable_stream = filter->streams[i];
 598             IMediaSeeking_Release(seeking);
 599             LeaveCriticalSection(&filter->cs);
 600             return S_OK;
 601         }
 602
 603         IMediaSeeking_Release(seeking);
 604     }
 605
 606     LeaveCriticalSection(&filter->cs);
 607     return E_NOINTERFACE;
 608 }
 609
 610 static HRESULT WINAPI filter_ReferenceTimeToStreamTime(IMediaStreamFilter *iface, REFERENCE_TIME *pTime)
 611 {
 612     FIXME("(%p)->(%p): Stub!\n", iface, pTime);
 613
 614     return E_NOTIMPL;
 615 }
 616
 617 static HRESULT WINAPI filter_GetCurrentStreamTime(IMediaStreamFilter *iface, REFERENCE_TIME *pCurrentStreamTime)
 618 {
 619     FIXME("(%p)->(%p): Stub!\n", iface, pCurrentStreamTime);
 620
 621     return E_NOTIMPL;
 622 }
 623
 624 static HRESULT WINAPI filter_WaitUntil(IMediaStreamFilter *iface, REFERENCE_TIME WaitStreamTime)
 625 {
 626     FIXME("(%p)->(%s): Stub!\n", iface, wine_dbgstr_longlong(WaitStreamTime));
 627
 628     return E_NOTIMPL;
 629 }
 630
 631 static HRESULT WINAPI filter_Flush(IMediaStreamFilter *iface, BOOL bCancelEOS)
 632 {
 633     FIXME("(%p)->(%d): Stub!\n", iface, bCancelEOS);
 634
 635     return E_NOTIMPL;
 636 }
 637
 638 static HRESULT WINAPI filter_EndOfStream(IMediaStreamFilter *iface)
 639 {
 640     FIXME("(%p)->(): Stub!\n",  iface);
 641
 642     return E_NOTIMPL;
 643 }
 644
 645 static const IMediaStreamFilterVtbl filter_vtbl =
 646 {
 647     filter_QueryInterface,
 648     filter_AddRef,
 649     filter_Release,
 650     filter_GetClassID,
 651     filter_Stop,
 652     filter_Pause,
 653     filter_Run,
 654     filter_GetState,
 655     filter_SetSyncSource,
 656     filter_GetSyncSource,
 657     filter_EnumPins,
 658     filter_FindPin,
 659     filter_QueryFilterInfo,
 660     filter_JoinFilterGraph,
 661     filter_QueryVendorInfo,
 662     filter_AddMediaStream,
 663     filter_GetMediaStream,
 664     filter_EnumMediaStreams,
 665     filter_SupportSeeking,
 666     filter_ReferenceTimeToStreamTime,
 667     filter_GetCurrentStreamTime,
 668     filter_WaitUntil,
 669     filter_Flush,
 670     filter_EndOfStream
 671 };
 672
 673 static inline struct filter *impl_from_IMediaSeeking(IMediaSeeking *iface)
 674 {
 675     return CONTAINING_RECORD(iface, struct filter, IMediaSeeking_iface);
 676 }
 677
 678 static HRESULT WINAPI filter_seeking_QueryInterface(IMediaSeeking *iface, REFIID iid, void **out)
 679 {
 680     struct filter *filter = impl_from_IMediaSeeking(iface);
 681     return IMediaStreamFilter_QueryInterface(&filter->IMediaStreamFilter_iface, iid, out);
 682 }
 683
 684 static ULONG WINAPI filter_seeking_AddRef(IMediaSeeking *iface)
 685 {
 686     struct filter *filter = impl_from_IMediaSeeking(iface);
 687     return IMediaStreamFilter_AddRef(&filter->IMediaStreamFilter_iface);
 688 }
 689
 690 static ULONG WINAPI filter_seeking_Release(IMediaSeeking *iface)
 691 {
 692     struct filter *filter = impl_from_IMediaSeeking(iface);
 693     return IMediaStreamFilter_Release(&filter->IMediaStreamFilter_iface);
 694 }
 695
 696 static HRESULT WINAPI filter_seeking_GetCapabilities(IMediaSeeking *iface, DWORD *capabilities)
 697 {
 698     FIXME("iface %p, capabilities %p, stub!\n", iface, capabilities);
 699
 700     return E_NOTIMPL;
 701 }
 702
 703 static HRESULT WINAPI filter_seeking_CheckCapabilities(IMediaSeeking *iface, DWORD *capabilities)
 704 {
 705     FIXME("iface %p, capabilities %p, stub!\n", iface, capabilities);
 706
 707     return E_NOTIMPL;
 708 }
 709
 710 static HRESULT WINAPI filter_seeking_IsFormatSupported(IMediaSeeking *iface, const GUID *format)
 711 {
 712     FIXME("iface %p, format %s, stub!\n", iface, debugstr_guid(format));
 713
 714     return E_NOTIMPL;
 715 }
 716
 717 static HRESULT WINAPI filter_seeking_QueryPreferredFormat(IMediaSeeking *iface, GUID *format)
 718 {
 719     FIXME("iface %p, format %p, stub!\n", iface, format);
 720
 721     return E_NOTIMPL;
 722 }
 723
 724 static HRESULT WINAPI filter_seeking_GetTimeFormat(IMediaSeeking *iface, GUID *format)
 725 {
 726     FIXME("iface %p, format %p, stub!\n", iface, format);
 727
 728     return E_NOTIMPL;
 729 }
 730
 731 static HRESULT WINAPI filter_seeking_IsUsingTimeFormat(IMediaSeeking *iface, const GUID *format)
 732 {
 733     FIXME("iface %p, format %s, stub!\n", iface, debugstr_guid(format));
 734
 735     return E_NOTIMPL;
 736 }
 737
 738 static HRESULT WINAPI filter_seeking_SetTimeFormat(IMediaSeeking *iface, const GUID *format)
 739 {
 740     FIXME("iface %p, format %s, stub!\n", iface, debugstr_guid(format));
 741
 742     return E_NOTIMPL;
 743 }
 744
 745 static HRESULT WINAPI filter_seeking_GetDuration(IMediaSeeking *iface, LONGLONG *duration)
 746 {
 747     FIXME("iface %p, duration %p, stub!\n", iface, duration);
 748
 749     return E_NOTIMPL;
 750 }
 751
 752 static HRESULT WINAPI filter_seeking_GetStopPosition(IMediaSeeking *iface, LONGLONG *stop)
 753 {
 754     FIXME("iface %p, stop %p, stub!\n", iface, stop);
 755
 756     return E_NOTIMPL;
 757 }
 758
 759 static HRESULT WINAPI filter_seeking_GetCurrentPosition(IMediaSeeking *iface, LONGLONG *current)
 760 {
 761     FIXME("iface %p, current %p, stub!\n", iface, current);
 762
 763     return E_NOTIMPL;
 764 }
 765
 766 static HRESULT WINAPI filter_seeking_ConvertTimeFormat(IMediaSeeking *iface, LONGLONG *target,
 767         const GUID *target_format, LONGLONG source, const GUID *source_format)
 768 {
 769     FIXME("iface %p, target %p, target_format %s, source 0x%s, source_format %s, stub!\n", iface, target, debugstr_guid(target_format),
 770             wine_dbgstr_longlong(source), debugstr_guid(source_format));
 771
 772     return E_NOTIMPL;
 773 }
 774
 775 static HRESULT WINAPI filter_seeking_SetPositions(IMediaSeeking *iface, LONGLONG *current_ptr, DWORD current_flags,
 776         LONGLONG *stop_ptr, DWORD stop_flags)
 777 {
 778     FIXME("iface %p, current %s, current_flags %#x, stop %s, stop_flags %#x, stub!\n", iface,
 779             current_ptr ? wine_dbgstr_longlong(*current_ptr) : "<null>", current_flags,
 780             stop_ptr ? wine_dbgstr_longlong(*stop_ptr): "<null>", stop_flags);
 781
 782     return E_NOTIMPL;
 783 }
 784
 785 static HRESULT WINAPI filter_seeking_GetPositions(IMediaSeeking *iface, LONGLONG *current, LONGLONG *stop)
 786 {
 787     FIXME("iface %p, current %p, stop %p, stub!\n", iface, current, stop);
 788
 789     return E_NOTIMPL;
 790 }
 791
 792 static HRESULT WINAPI filter_seeking_GetAvailable(IMediaSeeking *iface, LONGLONG *earliest, LONGLONG *latest)
 793 {
 794     FIXME("iface %p, earliest %p, latest %p, stub!\n", iface, earliest, latest);
 795
 796     return E_NOTIMPL;
 797 }
 798
 799 static HRESULT WINAPI filter_seeking_SetRate(IMediaSeeking *iface, double rate)
 800 {
 801     FIXME("iface %p, rate %f, stub!\n", iface, rate);
 802
 803     return E_NOTIMPL;
 804 }
 805
 806 static HRESULT WINAPI filter_seeking_GetRate(IMediaSeeking *iface, double *rate)
 807 {
 808     FIXME("iface %p, rate %p, stub!\n", iface, rate);
 809
 810     return E_NOTIMPL;
 811 }
 812
 813 static HRESULT WINAPI filter_seeking_GetPreroll(IMediaSeeking *iface, LONGLONG *preroll)
 814 {
 815     FIXME("iface %p, preroll %p, stub!\n", iface, preroll);
 816
 817     return E_NOTIMPL;
 818 }
 819
 820 static const IMediaSeekingVtbl filter_seeking_vtbl =
 821 {
 822     filter_seeking_QueryInterface,
 823     filter_seeking_AddRef,
 824     filter_seeking_Release,
 825     filter_seeking_GetCapabilities,
 826     filter_seeking_CheckCapabilities,
 827     filter_seeking_IsFormatSupported,
 828     filter_seeking_QueryPreferredFormat,
 829     filter_seeking_GetTimeFormat,
 830     filter_seeking_IsUsingTimeFormat,
 831     filter_seeking_SetTimeFormat,
 832     filter_seeking_GetDuration,
 833     filter_seeking_GetStopPosition,
 834     filter_seeking_GetCurrentPosition,
 835     filter_seeking_ConvertTimeFormat,
 836     filter_seeking_SetPositions,
 837     filter_seeking_GetPositions,
 838     filter_seeking_GetAvailable,
 839     filter_seeking_SetRate,
 840     filter_seeking_GetRate,
 841     filter_seeking_GetPreroll,
 842 };
 843
 844 HRESULT filter_create(IUnknown *outer, void **out)
 845 {
 846     struct filter *object;
 847
 848     TRACE("outer %p, out %p.\n", outer, out);
 849
 850     if (outer)
 851         return CLASS_E_NOAGGREGATION;
 852
 853     if (!(object = heap_alloc_zero(sizeof(*object))))
 854         return E_OUTOFMEMORY;
 855
 856     object->IMediaStreamFilter_iface.lpVtbl = &filter_vtbl;
 857     object->IMediaSeeking_iface.lpVtbl = &filter_seeking_vtbl;
 858     object->refcount = 1;
 859     InitializeCriticalSection(&object->cs);
 860     object->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": MediaStreamFilter.cs");
 861
 862     TRACE("Created media stream filter %p.\n", object);
 863     *out = &object->IMediaStreamFilter_iface;
 864     return S_OK;
 865 }