libs/strmbase/filter.c

   1 /*
   2  * Generic Implementation of IBaseFilter Interface
   3  *
   4  * Copyright 2010 Aric Stewart, CodeWeavers
   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 "strmbase_private.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  24
  25 struct enum_pins
  26 {
  27     IEnumPins IEnumPins_iface;
  28     LONG refcount;
  29
  30     unsigned int index, count;
  31     int version;
  32     struct strmbase_filter *filter;
  33 };
  34
  35 static const IEnumPinsVtbl enum_pins_vtbl;
  36
  37 static HRESULT enum_pins_create(struct strmbase_filter *filter, IEnumPins **out)
  38 {
  39     struct enum_pins *object;
  40
  41     if (!out)
  42         return E_POINTER;
  43
  44     if (!(object = heap_alloc_zero(sizeof(*object))))
  45     {
  46         *out = NULL;
  47         return E_OUTOFMEMORY;
  48     }
  49
  50     object->IEnumPins_iface.lpVtbl = &enum_pins_vtbl;
  51     object->refcount = 1;
  52     object->filter = filter;
  53     IBaseFilter_AddRef(&filter->IBaseFilter_iface);
  54     object->version = filter->pin_version;
  55
  56     while (filter->ops->filter_get_pin(filter, object->count))
  57         ++object->count;
  58
  59     TRACE("Created enumerator %p.\n", object);
  60     *out = &object->IEnumPins_iface;
  61
  62     return S_OK;
  63 }
  64
  65 static inline struct enum_pins *impl_from_IEnumPins(IEnumPins *iface)
  66 {
  67     return CONTAINING_RECORD(iface, struct enum_pins, IEnumPins_iface);
  68 }
  69
  70 static HRESULT WINAPI enum_pins_QueryInterface(IEnumPins *iface, REFIID iid, void **out)
  71 {
  72     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  73
  74     if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IEnumPins))
  75     {
  76         IEnumPins_AddRef(iface);
  77         *out = iface;
  78         return S_OK;
  79     }
  80
  81     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  82     *out = NULL;
  83     return E_NOINTERFACE;
  84 }
  85
  86 static ULONG WINAPI enum_pins_AddRef(IEnumPins *iface)
  87 {
  88     struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
  89     ULONG refcount = InterlockedIncrement(&enum_pins->refcount);
  90     TRACE("%p increasing refcount to %lu.\n", enum_pins, refcount);
  91     return refcount;
  92 }
  93
  94 static ULONG WINAPI enum_pins_Release(IEnumPins *iface)
  95 {
  96     struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
  97     ULONG refcount = InterlockedDecrement(&enum_pins->refcount);
  98
  99     TRACE("%p decreasing refcount to %lu.\n", enum_pins, refcount);
 100     if (!refcount)
 101     {
 102         IBaseFilter_Release(&enum_pins->filter->IBaseFilter_iface);
 103         heap_free(enum_pins);
 104     }
 105     return refcount;
 106 }
 107
 108 static HRESULT WINAPI enum_pins_Next(IEnumPins *iface, ULONG count, IPin **pins, ULONG *ret_count)
 109 {
 110     struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
 111     unsigned int i;
 112
 113     TRACE("iface %p, count %lu, pins %p, ret_count %p.\n", iface, count, pins, ret_count);
 114
 115     if (!pins)
 116         return E_POINTER;
 117
 118     if (count > 1 && !ret_count)
 119         return E_INVALIDARG;
 120
 121     if (ret_count)
 122         *ret_count = 0;
 123
 124     if (enum_pins->version != enum_pins->filter->pin_version)
 125         return S_FALSE;
 126
 127     for (i = 0; i < count; ++i)
 128     {
 129         struct strmbase_pin *pin = enum_pins->filter->ops->filter_get_pin(enum_pins->filter, enum_pins->index + i);
 130
 131         if (!pin)
 132             break;
 133
 134         IPin_AddRef(pins[i] = &pin->IPin_iface);
 135     }
 136
 137     if (ret_count)
 138         *ret_count = i;
 139     enum_pins->index += i;
 140     return i == count ? S_OK : S_FALSE;
 141 }
 142
 143 static HRESULT WINAPI enum_pins_Skip(IEnumPins *iface, ULONG count)
 144 {
 145     struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
 146
 147     TRACE("iface %p, count %lu.\n", iface, count);
 148
 149     if (enum_pins->version != enum_pins->filter->pin_version)
 150         return VFW_E_ENUM_OUT_OF_SYNC;
 151
 152     if (enum_pins->index + count > enum_pins->count)
 153         return S_FALSE;
 154
 155     enum_pins->index += count;
 156     return S_OK;
 157 }
 158
 159 static HRESULT WINAPI enum_pins_Reset(IEnumPins *iface)
 160 {
 161     struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
 162
 163     TRACE("iface %p.\n", iface);
 164
 165     if (enum_pins->version != enum_pins->filter->pin_version)
 166     {
 167         enum_pins->count = 0;
 168         while (enum_pins->filter->ops->filter_get_pin(enum_pins->filter, enum_pins->count))
 169             ++enum_pins->count;
 170     }
 171
 172     enum_pins->version = enum_pins->filter->pin_version;
 173     enum_pins->index = 0;
 174
 175     return S_OK;
 176 }
 177
 178 static HRESULT WINAPI enum_pins_Clone(IEnumPins *iface, IEnumPins **out)
 179 {
 180     struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
 181     HRESULT hr;
 182
 183     TRACE("iface %p, out %p.\n", iface, out);
 184
 185     if (FAILED(hr = enum_pins_create(enum_pins->filter, out)))
 186         return hr;
 187     return IEnumPins_Skip(*out, enum_pins->index);
 188 }
 189
 190 static const IEnumPinsVtbl enum_pins_vtbl =
 191 {
 192     enum_pins_QueryInterface,
 193     enum_pins_AddRef,
 194     enum_pins_Release,
 195     enum_pins_Next,
 196     enum_pins_Skip,
 197     enum_pins_Reset,
 198     enum_pins_Clone,
 199 };
 200
 201 static inline struct strmbase_filter *impl_from_IUnknown(IUnknown *iface)
 202 {
 203     return CONTAINING_RECORD(iface, struct strmbase_filter, IUnknown_inner);
 204 }
 205
 206 static HRESULT WINAPI filter_inner_QueryInterface(IUnknown *iface, REFIID iid, void **out)
 207 {
 208     struct strmbase_filter *filter = impl_from_IUnknown(iface);
 209     HRESULT hr;
 210
 211     TRACE("filter %p %s, iid %s, out %p.\n", filter, debugstr_w(filter->name), debugstr_guid(iid), out);
 212
 213     *out = NULL;
 214
 215     if (filter->ops->filter_query_interface
 216             && SUCCEEDED(hr = filter->ops->filter_query_interface(filter, iid, out)))
 217     {
 218         return hr;
 219     }
 220
 221     if (IsEqualIID(iid, &IID_IUnknown))
 222         *out = iface;
 223     else if (IsEqualIID(iid, &IID_IPersist)
 224             || IsEqualIID(iid, &IID_IMediaFilter)
 225             || IsEqualIID(iid, &IID_IBaseFilter))
 226     {
 227         *out = &filter->IBaseFilter_iface;
 228     }
 229     else
 230     {
 231         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 232         return E_NOINTERFACE;
 233     }
 234
 235     IUnknown_AddRef((IUnknown *)*out);
 236     return S_OK;
 237 }
 238
 239 static ULONG WINAPI filter_inner_AddRef(IUnknown *iface)
 240 {
 241     struct strmbase_filter *filter = impl_from_IUnknown(iface);
 242     ULONG refcount = InterlockedIncrement(&filter->refcount);
 243
 244     TRACE("%p increasing refcount to %lu.\n", filter, refcount);
 245
 246     return refcount;
 247 }
 248
 249 static ULONG WINAPI filter_inner_Release(IUnknown *iface)
 250 {
 251     struct strmbase_filter *filter = impl_from_IUnknown(iface);
 252     ULONG refcount = InterlockedDecrement(&filter->refcount);
 253
 254     TRACE("%p decreasing refcount to %lu.\n", filter, refcount);
 255
 256     if (!refcount)
 257         filter->ops->filter_destroy(filter);
 258
 259     return refcount;
 260 }
 261
 262 static const IUnknownVtbl filter_inner_vtbl =
 263 {
 264     filter_inner_QueryInterface,
 265     filter_inner_AddRef,
 266     filter_inner_Release,
 267 };
 268
 269 static inline struct strmbase_filter *impl_from_IBaseFilter(IBaseFilter *iface)
 270 {
 271     return CONTAINING_RECORD(iface, struct strmbase_filter, IBaseFilter_iface);
 272 }
 273
 274 static HRESULT WINAPI filter_QueryInterface(IBaseFilter *iface, REFIID iid, void **out)
 275 {
 276     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 277     return IUnknown_QueryInterface(filter->outer_unk, iid, out);
 278 }
 279
 280 static ULONG WINAPI filter_AddRef(IBaseFilter *iface)
 281 {
 282     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 283     return IUnknown_AddRef(filter->outer_unk);
 284 }
 285
 286 static ULONG WINAPI filter_Release(IBaseFilter *iface)
 287 {
 288     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 289     return IUnknown_Release(filter->outer_unk);
 290 }
 291
 292 static HRESULT WINAPI filter_GetClassID(IBaseFilter *iface, CLSID *clsid)
 293 {
 294     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 295
 296     TRACE("filter %p %s, clsid %p.\n", filter, debugstr_w(filter->name), clsid);
 297
 298     *clsid = filter->clsid;
 299
 300     return S_OK;
 301 }
 302
 303 static HRESULT WINAPI filter_Stop(IBaseFilter *iface)
 304 {
 305     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 306     HRESULT hr = S_OK;
 307
 308     TRACE("filter %p %s.\n", filter, debugstr_w(filter->name));
 309
 310     EnterCriticalSection(&filter->filter_cs);
 311
 312     if (filter->state == State_Running && filter->ops->filter_stop_stream)
 313         hr = filter->ops->filter_stop_stream(filter);
 314     if (SUCCEEDED(hr) && filter->ops->filter_cleanup_stream)
 315         hr = filter->ops->filter_cleanup_stream(filter);
 316     if (SUCCEEDED(hr))
 317         filter->state = State_Stopped;
 318
 319     LeaveCriticalSection(&filter->filter_cs);
 320
 321     return hr;
 322 }
 323
 324 static HRESULT WINAPI filter_Pause(IBaseFilter *iface)
 325 {
 326     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 327     HRESULT hr = S_OK;
 328
 329     TRACE("filter %p %s.\n", filter, debugstr_w(filter->name));
 330
 331     EnterCriticalSection(&filter->filter_cs);
 332
 333     if (filter->state == State_Stopped && filter->ops->filter_init_stream)
 334         hr = filter->ops->filter_init_stream(filter);
 335     else if (filter->state == State_Running && filter->ops->filter_stop_stream)
 336         hr = filter->ops->filter_stop_stream(filter);
 337     if (SUCCEEDED(hr))
 338         filter->state = State_Paused;
 339
 340     LeaveCriticalSection(&filter->filter_cs);
 341
 342     return hr;
 343 }
 344
 345 static HRESULT WINAPI filter_Run(IBaseFilter *iface, REFERENCE_TIME start)
 346 {
 347     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 348     HRESULT hr = S_OK;
 349
 350     TRACE("filter %p %s, start %s.\n", filter, debugstr_w(filter->name), debugstr_time(start));
 351
 352     EnterCriticalSection(&filter->filter_cs);
 353
 354     if (filter->state == State_Stopped && filter->ops->filter_init_stream)
 355         hr = filter->ops->filter_init_stream(filter);
 356     if (SUCCEEDED(hr) && filter->ops->filter_start_stream)
 357         hr = filter->ops->filter_start_stream(filter, start);
 358     if (SUCCEEDED(hr))
 359         filter->state = State_Running;
 360
 361     LeaveCriticalSection(&filter->filter_cs);
 362
 363     return hr;
 364 }
 365
 366 static HRESULT WINAPI filter_GetState(IBaseFilter *iface, DWORD timeout, FILTER_STATE *state)
 367 {
 368     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 369     HRESULT hr = S_OK;
 370
 371     TRACE("filter %p %s, timeout %lu, state %p.\n", filter, debugstr_w(filter->name), timeout, state);
 372
 373     EnterCriticalSection(&filter->filter_cs);
 374
 375     if (filter->ops->filter_wait_state)
 376         hr = filter->ops->filter_wait_state(filter, timeout);
 377     *state = filter->state;
 378
 379     LeaveCriticalSection(&filter->filter_cs);
 380
 381     return hr;
 382 }
 383
 384 static HRESULT WINAPI filter_SetSyncSource(IBaseFilter *iface, IReferenceClock *clock)
 385 {
 386     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 387
 388     TRACE("filter %p %s, clock %p.\n", filter, debugstr_w(filter->name), clock);
 389
 390     EnterCriticalSection(&filter->filter_cs);
 391
 392     if (filter->clock)
 393         IReferenceClock_Release(filter->clock);
 394     filter->clock = clock;
 395     if (filter->clock)
 396         IReferenceClock_AddRef(filter->clock);
 397
 398     LeaveCriticalSection(&filter->filter_cs);
 399
 400     return S_OK;
 401 }
 402
 403 static HRESULT WINAPI filter_GetSyncSource(IBaseFilter *iface, IReferenceClock **clock)
 404 {
 405     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 406
 407     TRACE("filter %p %s, clock %p.\n", filter, debugstr_w(filter->name), clock);
 408
 409     EnterCriticalSection(&filter->filter_cs);
 410
 411     *clock = filter->clock;
 412     if (filter->clock)
 413         IReferenceClock_AddRef(filter->clock);
 414
 415     LeaveCriticalSection(&filter->filter_cs);
 416
 417     return S_OK;
 418 }
 419
 420 static HRESULT WINAPI filter_EnumPins(IBaseFilter *iface, IEnumPins **enum_pins)
 421 {
 422     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 423
 424     TRACE("filter %p %s, enum_pins %p.\n", filter, debugstr_w(filter->name), enum_pins);
 425
 426     return enum_pins_create(filter, enum_pins);
 427 }
 428
 429 static HRESULT WINAPI filter_FindPin(IBaseFilter *iface, const WCHAR *id, IPin **ret)
 430 {
 431     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 432     struct strmbase_pin *pin;
 433     unsigned int i;
 434
 435     TRACE("filter %p %s, id %s, ret %p.\n", filter, debugstr_w(filter->name), debugstr_w(id), ret);
 436
 437     for (i = 0; (pin = filter->ops->filter_get_pin(filter, i)); ++i)
 438     {
 439         if (!lstrcmpW(id, pin->id))
 440         {
 441             IPin_AddRef(*ret = &pin->IPin_iface);
 442             return S_OK;
 443         }
 444     }
 445
 446     return VFW_E_NOT_FOUND;
 447 }
 448
 449 static HRESULT WINAPI filter_QueryFilterInfo(IBaseFilter *iface, FILTER_INFO *info)
 450 {
 451     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 452
 453     TRACE("filter %p %s, info %p.\n", filter, debugstr_w(filter->name), info);
 454
 455     lstrcpyW(info->achName, filter->name);
 456     info->pGraph = filter->graph;
 457
 458     if (info->pGraph)
 459         IFilterGraph_AddRef(info->pGraph);
 460
 461     return S_OK;
 462 }
 463
 464 static HRESULT WINAPI filter_JoinFilterGraph(IBaseFilter *iface, IFilterGraph *graph, const WCHAR *name)
 465 {
 466     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 467
 468     TRACE("filter %p %s, graph %p, name %s.\n", filter, debugstr_w(filter->name), graph, debugstr_w(name));
 469
 470     EnterCriticalSection(&filter->filter_cs);
 471
 472     if (name)
 473         lstrcpynW(filter->name, name, ARRAY_SIZE(filter->name));
 474     else
 475         filter->name[0] = 0;
 476     /* The graph references us, so we cannot also reference the graph. */
 477     filter->graph = graph;
 478
 479     LeaveCriticalSection(&filter->filter_cs);
 480
 481     return S_OK;
 482 }
 483
 484 static HRESULT WINAPI filter_QueryVendorInfo(IBaseFilter *iface, WCHAR **info)
 485 {
 486     struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 487
 488     TRACE("filter %p %s, info %p.\n", filter, debugstr_w(filter->name), info);
 489
 490     return E_NOTIMPL;
 491 }
 492
 493 static const IBaseFilterVtbl filter_vtbl =
 494 {
 495     filter_QueryInterface,
 496     filter_AddRef,
 497     filter_Release,
 498     filter_GetClassID,
 499     filter_Stop,
 500     filter_Pause,
 501     filter_Run,
 502     filter_GetState,
 503     filter_SetSyncSource,
 504     filter_GetSyncSource,
 505     filter_EnumPins,
 506     filter_FindPin,
 507     filter_QueryFilterInfo,
 508     filter_JoinFilterGraph,
 509     filter_QueryVendorInfo,
 510 };
 511
 512 VOID WINAPI BaseFilterImpl_IncrementPinVersion(struct strmbase_filter *filter)
 513 {
 514     InterlockedIncrement(&filter->pin_version);
 515 }
 516
 517 void strmbase_filter_init(struct strmbase_filter *filter, IUnknown *outer,
 518         const CLSID *clsid, const struct strmbase_filter_ops *ops)
 519 {
 520     memset(filter, 0, sizeof(*filter));
 521
 522     filter->IBaseFilter_iface.lpVtbl = &filter_vtbl;
 523     filter->IUnknown_inner.lpVtbl = &filter_inner_vtbl;
 524     filter->outer_unk = outer ? outer : &filter->IUnknown_inner;
 525     filter->refcount = 1;
 526
 527     InitializeCriticalSection(&filter->filter_cs);
 528     if (filter->filter_cs.DebugInfo != (RTL_CRITICAL_SECTION_DEBUG *)-1)
 529         filter->filter_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": strmbase_filter.filter_cs");
 530     InitializeCriticalSection(&filter->stream_cs);
 531     if (filter->stream_cs.DebugInfo != (RTL_CRITICAL_SECTION_DEBUG *)-1)
 532         filter->stream_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": strmbase_filter.stream_cs");
 533     filter->clsid = *clsid;
 534     filter->pin_version = 1;
 535     filter->ops = ops;
 536 }
 537
 538 void strmbase_filter_cleanup(struct strmbase_filter *filter)
 539 {
 540     if (filter->clock)
 541         IReferenceClock_Release(filter->clock);
 542
 543     filter->IBaseFilter_iface.lpVtbl = NULL;
 544     if (filter->filter_cs.DebugInfo != (RTL_CRITICAL_SECTION_DEBUG *)-1)
 545         filter->filter_cs.DebugInfo->Spare[0] = 0;
 546     DeleteCriticalSection(&filter->filter_cs);
 547     if (filter->stream_cs.DebugInfo != (RTL_CRITICAL_SECTION_DEBUG *)-1)
 548         filter->stream_cs.DebugInfo->Spare[0] = 0;
 549     DeleteCriticalSection(&filter->stream_cs);
 550 }