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     LONG refcount;
 167     CRITICAL_SECTION cs;
 168
 169     IReferenceClock *clock;
 170     WCHAR name[128];
 171     IFilterGraph *graph;
 172     ULONG nb_streams;
 173     IAMMediaStream **streams;
 174     FILTER_STATE state;
 175 };
 176
 177 static inline struct filter *impl_from_IMediaStreamFilter(IMediaStreamFilter *iface)
 178 {
 179     return CONTAINING_RECORD(iface, struct filter, IMediaStreamFilter_iface);
 180 }
 181
 182 static HRESULT WINAPI filter_QueryInterface(IMediaStreamFilter *iface, REFIID riid, void **ret_iface)
 183 {
 184     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ret_iface);
 185
 186     *ret_iface = NULL;
 187
 188     if (IsEqualIID(riid, &IID_IUnknown) ||
 189         IsEqualIID(riid, &IID_IPersist) ||
 190         IsEqualIID(riid, &IID_IMediaFilter) ||
 191         IsEqualIID(riid, &IID_IBaseFilter) ||
 192         IsEqualIID(riid, &IID_IMediaStreamFilter))
 193         *ret_iface = iface;
 194
 195     if (*ret_iface)
 196     {
 197         IMediaStreamFilter_AddRef(*ret_iface);
 198         return S_OK;
 199     }
 200
 201     return E_NOINTERFACE;
 202 }
 203
 204 static ULONG WINAPI filter_AddRef(IMediaStreamFilter *iface)
 205 {
 206     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 207     ULONG refcount = InterlockedIncrement(&filter->refcount);
 208
 209     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 210
 211     return refcount;
 212 }
 213
 214 static ULONG WINAPI filter_Release(IMediaStreamFilter *iface)
 215 {
 216     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 217     ULONG refcount = InterlockedDecrement(&filter->refcount);
 218     unsigned int i;
 219
 220     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 221
 222     if (!refcount)
 223     {
 224         for (i = 0; i < filter->nb_streams; ++i)
 225         {
 226             IAMMediaStream_JoinFilter(filter->streams[i], NULL);
 227             IAMMediaStream_Release(filter->streams[i]);
 228         }
 229         heap_free(filter->streams);
 230         if (filter->clock)
 231             IReferenceClock_Release(filter->clock);
 232         DeleteCriticalSection(&filter->cs);
 233         heap_free(filter);
 234     }
 235
 236     return refcount;
 237 }
 238
 239 static HRESULT WINAPI filter_GetClassID(IMediaStreamFilter *iface, CLSID *clsid)
 240 {
 241     *clsid = CLSID_MediaStreamFilter;
 242     return S_OK;
 243 }
 244
 245 static HRESULT WINAPI filter_Stop(IMediaStreamFilter *iface)
 246 {
 247     FIXME("(%p)->(): Stub!\n", iface);
 248
 249     return E_NOTIMPL;
 250 }
 251
 252 static HRESULT WINAPI filter_Pause(IMediaStreamFilter *iface)
 253 {
 254     FIXME("(%p)->(): Stub!\n", iface);
 255
 256     return E_NOTIMPL;
 257 }
 258
 259 static HRESULT WINAPI filter_Run(IMediaStreamFilter *iface, REFERENCE_TIME start)
 260 {
 261     FIXME("(%p)->(%s): Stub!\n", iface, wine_dbgstr_longlong(start));
 262
 263     return E_NOTIMPL;
 264 }
 265
 266 static HRESULT WINAPI filter_GetState(IMediaStreamFilter *iface, DWORD timeout, FILTER_STATE *state)
 267 {
 268     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 269
 270     TRACE("iface %p, timeout %u, state %p.\n", iface, timeout, state);
 271
 272     if (!state)
 273         return E_POINTER;
 274
 275     EnterCriticalSection(&filter->cs);
 276
 277     *state = filter->state;
 278
 279     LeaveCriticalSection(&filter->cs);
 280
 281     return S_OK;
 282 }
 283
 284 static HRESULT WINAPI filter_SetSyncSource(IMediaStreamFilter *iface, IReferenceClock *clock)
 285 {
 286     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 287
 288     TRACE("iface %p, clock %p.\n", iface, clock);
 289
 290     EnterCriticalSection(&filter->cs);
 291
 292     if (clock)
 293         IReferenceClock_AddRef(clock);
 294     if (filter->clock)
 295         IReferenceClock_Release(filter->clock);
 296     filter->clock = clock;
 297
 298     LeaveCriticalSection(&filter->cs);
 299
 300     return S_OK;
 301 }
 302
 303 static HRESULT WINAPI filter_GetSyncSource(IMediaStreamFilter *iface, IReferenceClock **clock)
 304 {
 305     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 306
 307     TRACE("iface %p, clock %p.\n", iface, clock);
 308
 309     EnterCriticalSection(&filter->cs);
 310
 311     if (filter->clock)
 312         IReferenceClock_AddRef(filter->clock);
 313     *clock = filter->clock;
 314
 315     LeaveCriticalSection(&filter->cs);
 316
 317     return S_OK;
 318 }
 319
 320 static HRESULT WINAPI filter_EnumPins(IMediaStreamFilter *iface, IEnumPins **enum_pins)
 321 {
 322     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 323     struct enum_pins *object;
 324     unsigned int i;
 325
 326     TRACE("iface %p, enum_pins %p.\n", iface, enum_pins);
 327
 328     EnterCriticalSection(&filter->cs);
 329
 330     if (!enum_pins)
 331         return E_POINTER;
 332
 333     if (!(object = heap_alloc(sizeof(*object))))
 334         return E_OUTOFMEMORY;
 335
 336     object->IEnumPins_iface.lpVtbl = &enum_pins_vtbl;
 337     object->refcount = 1;
 338     object->count = filter->nb_streams;
 339     object->index = 0;
 340     if (!(object->pins = heap_alloc(filter->nb_streams * sizeof(*object->pins))))
 341     {
 342         heap_free(object);
 343         return E_OUTOFMEMORY;
 344     }
 345     for (i = 0; i < filter->nb_streams; ++i)
 346     {
 347         if (FAILED(IAMMediaStream_QueryInterface(filter->streams[i], &IID_IPin, (void **)&object->pins[i])))
 348             WARN("Stream %p does not support IPin.\n", filter->streams[i]);
 349     }
 350
 351     LeaveCriticalSection(&filter->cs);
 352
 353     *enum_pins = &object->IEnumPins_iface;
 354     return S_OK;
 355 }
 356
 357 static HRESULT WINAPI filter_FindPin(IMediaStreamFilter *iface, const WCHAR *id, IPin **out)
 358 {
 359     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 360     unsigned int i;
 361     WCHAR *ret_id;
 362     IPin *pin;
 363
 364     TRACE("iface %p, id %s, out %p.\n", iface, debugstr_w(id), out);
 365
 366     EnterCriticalSection(&filter->cs);
 367
 368     for (i = 0; i < filter->nb_streams; ++i)
 369     {
 370         if (FAILED(IAMMediaStream_QueryInterface(filter->streams[i], &IID_IPin, (void **)&pin)))
 371         {
 372             WARN("Stream %p does not support IPin.\n", filter->streams[i]);
 373             continue;
 374         }
 375
 376         if (SUCCEEDED(IPin_QueryId(pin, &ret_id)))
 377         {
 378             if (!wcscmp(id, ret_id))
 379             {
 380                 CoTaskMemFree(ret_id);
 381                 *out = pin;
 382                 LeaveCriticalSection(&filter->cs);
 383                 return S_OK;
 384             }
 385             CoTaskMemFree(ret_id);
 386         }
 387         IPin_Release(pin);
 388     }
 389
 390     LeaveCriticalSection(&filter->cs);
 391
 392     return VFW_E_NOT_FOUND;
 393 }
 394
 395 static HRESULT WINAPI filter_QueryFilterInfo(IMediaStreamFilter *iface, FILTER_INFO *info)
 396 {
 397     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 398
 399     TRACE("iface %p, info %p.\n", iface, info);
 400
 401     EnterCriticalSection(&filter->cs);
 402
 403     wcscpy(info->achName, filter->name);
 404     if (filter->graph)
 405         IFilterGraph_AddRef(filter->graph);
 406     info->pGraph = filter->graph;
 407
 408     LeaveCriticalSection(&filter->cs);
 409
 410     return S_OK;
 411 }
 412
 413 static HRESULT WINAPI filter_JoinFilterGraph(IMediaStreamFilter *iface,
 414         IFilterGraph *graph, const WCHAR *name)
 415 {
 416     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 417
 418     TRACE("iface %p, graph %p, name.%s.\n", iface, graph, debugstr_w(name));
 419
 420     EnterCriticalSection(&filter->cs);
 421
 422     if (name)
 423         wcsncpy(filter->name, name, ARRAY_SIZE(filter->name));
 424     else
 425         filter->name[0] = 0;
 426     filter->graph = graph;
 427
 428     LeaveCriticalSection(&filter->cs);
 429
 430     return S_OK;
 431 }
 432
 433 static HRESULT WINAPI filter_QueryVendorInfo(IMediaStreamFilter *iface, LPWSTR *vendor_info)
 434 {
 435     WARN("iface %p, vendor_info %p, stub!\n", iface, vendor_info);
 436     return E_NOTIMPL;
 437 }
 438
 439 /*** IMediaStreamFilter methods ***/
 440
 441 static HRESULT WINAPI filter_AddMediaStream(IMediaStreamFilter *iface, IAMMediaStream *pAMMediaStream)
 442 {
 443     struct filter *This = impl_from_IMediaStreamFilter(iface);
 444     IAMMediaStream** streams;
 445     HRESULT hr;
 446
 447     TRACE("(%p)->(%p)\n", iface, pAMMediaStream);
 448
 449     streams = CoTaskMemRealloc(This->streams, (This->nb_streams + 1) * sizeof(IAMMediaStream*));
 450     if (!streams)
 451         return E_OUTOFMEMORY;
 452     This->streams = streams;
 453
 454     hr = IAMMediaStream_JoinFilter(pAMMediaStream, iface);
 455     if (FAILED(hr))
 456         return hr;
 457
 458     This->streams[This->nb_streams] = pAMMediaStream;
 459     This->nb_streams++;
 460
 461     IAMMediaStream_AddRef(pAMMediaStream);
 462
 463     return S_OK;
 464 }
 465
 466 static HRESULT WINAPI filter_GetMediaStream(IMediaStreamFilter *iface, REFMSPID idPurpose, IMediaStream **ppMediaStream)
 467 {
 468     struct filter *This = impl_from_IMediaStreamFilter(iface);
 469     MSPID purpose_id;
 470     unsigned int i;
 471
 472     TRACE("(%p)->(%s,%p)\n", iface, debugstr_guid(idPurpose), ppMediaStream);
 473
 474     for (i = 0; i < This->nb_streams; i++)
 475     {
 476         IAMMediaStream_GetInformation(This->streams[i], &purpose_id, NULL);
 477         if (IsEqualIID(&purpose_id, idPurpose))
 478         {
 479             *ppMediaStream = (IMediaStream *)This->streams[i];
 480             IMediaStream_AddRef(*ppMediaStream);
 481             return S_OK;
 482         }
 483     }
 484
 485     return MS_E_NOSTREAM;
 486 }
 487
 488 static HRESULT WINAPI filter_EnumMediaStreams(IMediaStreamFilter *iface, LONG index, IMediaStream **stream)
 489 {
 490     struct filter *filter = impl_from_IMediaStreamFilter(iface);
 491
 492     TRACE("filter %p, index %d, stream %p.\n", filter, index, stream);
 493
 494     if (index >= filter->nb_streams)
 495         return S_FALSE;
 496
 497     if (!stream)
 498         return E_POINTER;
 499
 500     IMediaStream_AddRef(*stream = (IMediaStream *)filter->streams[index]);
 501     return S_OK;
 502 }
 503
 504 static HRESULT WINAPI filter_SupportSeeking(IMediaStreamFilter *iface, BOOL bRenderer)
 505 {
 506     FIXME("(%p)->(%d): Stub!\n", iface, bRenderer);
 507
 508     return E_NOTIMPL;
 509 }
 510
 511 static HRESULT WINAPI filter_ReferenceTimeToStreamTime(IMediaStreamFilter *iface, REFERENCE_TIME *pTime)
 512 {
 513     FIXME("(%p)->(%p): Stub!\n", iface, pTime);
 514
 515     return E_NOTIMPL;
 516 }
 517
 518 static HRESULT WINAPI filter_GetCurrentStreamTime(IMediaStreamFilter *iface, REFERENCE_TIME *pCurrentStreamTime)
 519 {
 520     FIXME("(%p)->(%p): Stub!\n", iface, pCurrentStreamTime);
 521
 522     return E_NOTIMPL;
 523 }
 524
 525 static HRESULT WINAPI filter_WaitUntil(IMediaStreamFilter *iface, REFERENCE_TIME WaitStreamTime)
 526 {
 527     FIXME("(%p)->(%s): Stub!\n", iface, wine_dbgstr_longlong(WaitStreamTime));
 528
 529     return E_NOTIMPL;
 530 }
 531
 532 static HRESULT WINAPI filter_Flush(IMediaStreamFilter *iface, BOOL bCancelEOS)
 533 {
 534     FIXME("(%p)->(%d): Stub!\n", iface, bCancelEOS);
 535
 536     return E_NOTIMPL;
 537 }
 538
 539 static HRESULT WINAPI filter_EndOfStream(IMediaStreamFilter *iface)
 540 {
 541     FIXME("(%p)->(): Stub!\n",  iface);
 542
 543     return E_NOTIMPL;
 544 }
 545
 546 static const IMediaStreamFilterVtbl filter_vtbl =
 547 {
 548     filter_QueryInterface,
 549     filter_AddRef,
 550     filter_Release,
 551     filter_GetClassID,
 552     filter_Stop,
 553     filter_Pause,
 554     filter_Run,
 555     filter_GetState,
 556     filter_SetSyncSource,
 557     filter_GetSyncSource,
 558     filter_EnumPins,
 559     filter_FindPin,
 560     filter_QueryFilterInfo,
 561     filter_JoinFilterGraph,
 562     filter_QueryVendorInfo,
 563     filter_AddMediaStream,
 564     filter_GetMediaStream,
 565     filter_EnumMediaStreams,
 566     filter_SupportSeeking,
 567     filter_ReferenceTimeToStreamTime,
 568     filter_GetCurrentStreamTime,
 569     filter_WaitUntil,
 570     filter_Flush,
 571     filter_EndOfStream
 572 };
 573
 574 HRESULT filter_create(IUnknown *outer, void **out)
 575 {
 576     struct filter *object;
 577
 578     TRACE("outer %p, out %p.\n", outer, out);
 579
 580     if (outer)
 581         return CLASS_E_NOAGGREGATION;
 582
 583     if (!(object = heap_alloc_zero(sizeof(*object))))
 584         return E_OUTOFMEMORY;
 585
 586     object->IMediaStreamFilter_iface.lpVtbl = &filter_vtbl;
 587     object->refcount = 1;
 588     InitializeCriticalSection(&object->cs);
 589     object->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": MediaStreamFilter.cs");
 590
 591     TRACE("Created media stream filter %p.\n", object);
 592     *out = &object->IMediaStreamFilter_iface;
 593     return S_OK;
 594 }