dlls/quartz/nullrenderer.c

   1 /*
   2  * Null Renderer (Promiscuous, not rendering anything at all!)
   3  *
   4  * Copyright 2004 Christian Costa
   5  * Copyright 2008 Maarten Lankhorst
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23
  24 #define NONAMELESSSTRUCT
  25 #define NONAMELESSUNION
  26 #include "quartz_private.h"
  27 #include "control_private.h"
  28 #include "pin.h"
  29
  30 #include "uuids.h"
  31 #include "vfwmsgs.h"
  32 #include "amvideo.h"
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "dshow.h"
  36 #include "evcode.h"
  37 #include "strmif.h"
  38 #include "ddraw.h"
  39
  40 #include "wine/unicode.h"
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  44
  45 static const WCHAR wcsInputPinName[] = {'i','n','p','u','t',' ','p','i','n',0};
  46 static const WCHAR wcsAltInputPinName[] = {'I','n',0};
  47
  48 static const IBaseFilterVtbl NullRenderer_Vtbl;
  49 static const IUnknownVtbl IInner_VTable;
  50 static const IPinVtbl NullRenderer_InputPin_Vtbl;
  51
  52 typedef struct NullRendererImpl
  53 {
  54     const IBaseFilterVtbl * lpVtbl;
  55     const IUnknownVtbl * IInner_vtbl;
  56     IUnknown *seekthru_unk;
  57
  58     LONG refCount;
  59     CRITICAL_SECTION csFilter;
  60     FILTER_STATE state;
  61     REFERENCE_TIME rtStreamStart;
  62     IReferenceClock * pClock;
  63     FILTER_INFO filterInfo;
  64
  65     BaseInputPin *pInputPin;
  66     IUnknown * pUnkOuter;
  67     BOOL bUnkOuterValid;
  68     BOOL bAggregatable;
  69 } NullRendererImpl;
  70
  71 static HRESULT WINAPI NullRenderer_Receive(IPin *iface, IMediaSample * pSample)
  72 {
  73     BaseInputPin *pin = (BaseInputPin*)iface;
  74     NullRendererImpl *This = ((NullRendererImpl*)pin->pin.pinInfo.pFilter);
  75     HRESULT hr = S_OK;
  76     REFERENCE_TIME start, stop;
  77
  78     TRACE("%p %p\n", iface, pSample);
  79
  80     if (SUCCEEDED(IMediaSample_GetTime(pSample, &start, &stop)))
  81         MediaSeekingPassThru_RegisterMediaTime(This->seekthru_unk, start);
  82     EnterCriticalSection(&This->csFilter);
  83     if (This->pInputPin->flushing || This->pInputPin->end_of_stream)
  84         hr = S_FALSE;
  85     LeaveCriticalSection(&This->csFilter);
  86
  87     return hr;
  88 }
  89
  90 static HRESULT WINAPI NullRenderer_CheckMediaType(IPin *iface, const AM_MEDIA_TYPE * pmt)
  91 {
  92     TRACE("Not a stub!\n");
  93     return S_OK;
  94 }
  95
  96 HRESULT NullRenderer_create(IUnknown * pUnkOuter, LPVOID * ppv)
  97 {
  98     HRESULT hr;
  99     PIN_INFO piInput;
 100     NullRendererImpl * pNullRenderer;
 101
 102     TRACE("(%p, %p)\n", pUnkOuter, ppv);
 103
 104     *ppv = NULL;
 105
 106     pNullRenderer = CoTaskMemAlloc(sizeof(NullRendererImpl));
 107     pNullRenderer->pUnkOuter = pUnkOuter;
 108     pNullRenderer->bUnkOuterValid = FALSE;
 109     pNullRenderer->bAggregatable = FALSE;
 110     pNullRenderer->IInner_vtbl = &IInner_VTable;
 111
 112     pNullRenderer->lpVtbl = &NullRenderer_Vtbl;
 113     pNullRenderer->refCount = 1;
 114     InitializeCriticalSection(&pNullRenderer->csFilter);
 115     pNullRenderer->csFilter.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": NullRendererImpl.csFilter");
 116     pNullRenderer->state = State_Stopped;
 117     pNullRenderer->pClock = NULL;
 118     ZeroMemory(&pNullRenderer->filterInfo, sizeof(FILTER_INFO));
 119
 120     /* construct input pin */
 121     piInput.dir = PINDIR_INPUT;
 122     piInput.pFilter = (IBaseFilter *)pNullRenderer;
 123     lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0]));
 124
 125     hr = BaseInputPin_Construct(&NullRenderer_InputPin_Vtbl, &piInput, NullRenderer_CheckMediaType, NullRenderer_Receive, &pNullRenderer->csFilter, NULL, (IPin **)&pNullRenderer->pInputPin);
 126
 127     if (SUCCEEDED(hr))
 128     {
 129         ISeekingPassThru *passthru;
 130         hr = CoCreateInstance(&CLSID_SeekingPassThru, pUnkOuter ? pUnkOuter : (IUnknown*)&pNullRenderer->IInner_vtbl, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void**)&pNullRenderer->seekthru_unk);
 131         if (FAILED(hr)) {
 132             IUnknown_Release((IUnknown*)pNullRenderer);
 133             return hr;
 134         }
 135         IUnknown_QueryInterface(pNullRenderer->seekthru_unk, &IID_ISeekingPassThru, (void**)&passthru);
 136         ISeekingPassThru_Init(passthru, TRUE, (IPin*)pNullRenderer->pInputPin);
 137         ISeekingPassThru_Release(passthru);
 138         *ppv = pNullRenderer;
 139     }
 140     else
 141     {
 142         pNullRenderer->csFilter.DebugInfo->Spare[0] = 0;
 143         DeleteCriticalSection(&pNullRenderer->csFilter);
 144         CoTaskMemFree(pNullRenderer);
 145     }
 146
 147     return hr;
 148 }
 149
 150 static HRESULT WINAPI NullRendererInner_QueryInterface(IUnknown * iface, REFIID riid, LPVOID * ppv)
 151 {
 152     ICOM_THIS_MULTI(NullRendererImpl, IInner_vtbl, iface);
 153     TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
 154
 155     if (This->bAggregatable)
 156         This->bUnkOuterValid = TRUE;
 157
 158     *ppv = NULL;
 159
 160     if (IsEqualIID(riid, &IID_IUnknown))
 161         *ppv = &This->IInner_vtbl;
 162     else if (IsEqualIID(riid, &IID_IPersist))
 163         *ppv = This;
 164     else if (IsEqualIID(riid, &IID_IMediaFilter))
 165         *ppv = This;
 166     else if (IsEqualIID(riid, &IID_IBaseFilter))
 167         *ppv = This;
 168     else if (IsEqualIID(riid, &IID_IMediaSeeking))
 169         return IUnknown_QueryInterface(This->seekthru_unk, riid, ppv);
 170
 171     if (*ppv)
 172     {
 173         IUnknown_AddRef((IUnknown *)(*ppv));
 174         return S_OK;
 175     }
 176
 177     if (!IsEqualIID(riid, &IID_IPin) && !IsEqualIID(riid, &IID_IVideoWindow))
 178         FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 179
 180     return E_NOINTERFACE;
 181 }
 182
 183 static ULONG WINAPI NullRendererInner_AddRef(IUnknown * iface)
 184 {
 185     ICOM_THIS_MULTI(NullRendererImpl, IInner_vtbl, iface);
 186     ULONG refCount = InterlockedIncrement(&This->refCount);
 187
 188     TRACE("(%p/%p)->() AddRef from %d\n", This, iface, refCount - 1);
 189
 190     return refCount;
 191 }
 192
 193 static ULONG WINAPI NullRendererInner_Release(IUnknown * iface)
 194 {
 195     ICOM_THIS_MULTI(NullRendererImpl, IInner_vtbl, iface);
 196     ULONG refCount = InterlockedDecrement(&This->refCount);
 197
 198     TRACE("(%p/%p)->() Release from %d\n", This, iface, refCount + 1);
 199
 200     if (!refCount)
 201     {
 202         IPin *pConnectedTo;
 203
 204         if (This->pClock)
 205             IReferenceClock_Release(This->pClock);
 206
 207         if (SUCCEEDED(IPin_ConnectedTo((IPin *)This->pInputPin, &pConnectedTo)))
 208         {
 209             IPin_Disconnect(pConnectedTo);
 210             IPin_Release(pConnectedTo);
 211         }
 212         IPin_Disconnect((IPin *)This->pInputPin);
 213         IPin_Release((IPin *)This->pInputPin);
 214
 215         This->lpVtbl = NULL;
 216         if (This->seekthru_unk)
 217             IUnknown_Release(This->seekthru_unk);
 218
 219         This->csFilter.DebugInfo->Spare[0] = 0;
 220         DeleteCriticalSection(&This->csFilter);
 221
 222         TRACE("Destroying Null Renderer\n");
 223         CoTaskMemFree(This);
 224         return 0;
 225     }
 226     else
 227         return refCount;
 228 }
 229
 230 static const IUnknownVtbl IInner_VTable =
 231 {
 232     NullRendererInner_QueryInterface,
 233     NullRendererInner_AddRef,
 234     NullRendererInner_Release
 235 };
 236
 237 static HRESULT WINAPI NullRenderer_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
 238 {
 239     NullRendererImpl *This = (NullRendererImpl *)iface;
 240
 241     if (This->bAggregatable)
 242         This->bUnkOuterValid = TRUE;
 243
 244     if (This->pUnkOuter)
 245     {
 246         if (This->bAggregatable)
 247             return IUnknown_QueryInterface(This->pUnkOuter, riid, ppv);
 248
 249         if (IsEqualIID(riid, &IID_IUnknown))
 250         {
 251             HRESULT hr;
 252
 253             IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl));
 254             hr = IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv);
 255             IUnknown_Release((IUnknown *)&(This->IInner_vtbl));
 256             This->bAggregatable = TRUE;
 257             return hr;
 258         }
 259
 260         *ppv = NULL;
 261         return E_NOINTERFACE;
 262     }
 263
 264     return IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv);
 265 }
 266
 267 static ULONG WINAPI NullRenderer_AddRef(IBaseFilter * iface)
 268 {
 269     NullRendererImpl *This = (NullRendererImpl *)iface;
 270
 271     if (This->pUnkOuter && This->bUnkOuterValid)
 272         return IUnknown_AddRef(This->pUnkOuter);
 273     return IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl));
 274 }
 275
 276 static ULONG WINAPI NullRenderer_Release(IBaseFilter * iface)
 277 {
 278     NullRendererImpl *This = (NullRendererImpl *)iface;
 279
 280     if (This->pUnkOuter && This->bUnkOuterValid)
 281         return IUnknown_Release(This->pUnkOuter);
 282     return IUnknown_Release((IUnknown *)&(This->IInner_vtbl));
 283 }
 284
 285 /** IPersist methods **/
 286
 287 static HRESULT WINAPI NullRenderer_GetClassID(IBaseFilter * iface, CLSID * pClsid)
 288 {
 289     NullRendererImpl *This = (NullRendererImpl *)iface;
 290
 291     TRACE("(%p/%p)->(%p)\n", This, iface, pClsid);
 292
 293     *pClsid = CLSID_NullRenderer;
 294
 295     return S_OK;
 296 }
 297
 298 /** IMediaFilter methods **/
 299
 300 static HRESULT WINAPI NullRenderer_Stop(IBaseFilter * iface)
 301 {
 302     NullRendererImpl *This = (NullRendererImpl *)iface;
 303
 304     TRACE("(%p/%p)->()\n", This, iface);
 305
 306     EnterCriticalSection(&This->csFilter);
 307     {
 308         This->state = State_Stopped;
 309         MediaSeekingPassThru_ResetMediaTime(This->seekthru_unk);
 310     }
 311     LeaveCriticalSection(&This->csFilter);
 312
 313     return S_OK;
 314 }
 315
 316 static HRESULT WINAPI NullRenderer_Pause(IBaseFilter * iface)
 317 {
 318     NullRendererImpl *This = (NullRendererImpl *)iface;
 319
 320     TRACE("(%p/%p)->()\n", This, iface);
 321
 322     EnterCriticalSection(&This->csFilter);
 323     {
 324         if (This->state == State_Stopped)
 325             This->pInputPin->end_of_stream = 0;
 326         This->state = State_Paused;
 327     }
 328     LeaveCriticalSection(&This->csFilter);
 329
 330     return S_OK;
 331 }
 332
 333 static HRESULT WINAPI NullRenderer_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
 334 {
 335     NullRendererImpl *This = (NullRendererImpl *)iface;
 336
 337     TRACE("(%p/%p)->(%s)\n", This, iface, wine_dbgstr_longlong(tStart));
 338
 339     EnterCriticalSection(&This->csFilter);
 340     {
 341         This->rtStreamStart = tStart;
 342         This->state = State_Running;
 343         This->pInputPin->end_of_stream = 0;
 344     }
 345     LeaveCriticalSection(&This->csFilter);
 346
 347     return S_OK;
 348 }
 349
 350 static HRESULT WINAPI NullRenderer_GetState(IBaseFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
 351 {
 352     NullRendererImpl *This = (NullRendererImpl *)iface;
 353
 354     TRACE("(%p/%p)->(%d, %p)\n", This, iface, dwMilliSecsTimeout, pState);
 355
 356     EnterCriticalSection(&This->csFilter);
 357     {
 358         *pState = This->state;
 359     }
 360     LeaveCriticalSection(&This->csFilter);
 361
 362     return S_OK;
 363 }
 364
 365 static HRESULT WINAPI NullRenderer_SetSyncSource(IBaseFilter * iface, IReferenceClock *pClock)
 366 {
 367     NullRendererImpl *This = (NullRendererImpl *)iface;
 368
 369     TRACE("(%p/%p)->(%p)\n", This, iface, pClock);
 370
 371     EnterCriticalSection(&This->csFilter);
 372     {
 373         if (This->pClock)
 374             IReferenceClock_Release(This->pClock);
 375         This->pClock = pClock;
 376         if (This->pClock)
 377             IReferenceClock_AddRef(This->pClock);
 378     }
 379     LeaveCriticalSection(&This->csFilter);
 380
 381     return S_OK;
 382 }
 383
 384 static HRESULT WINAPI NullRenderer_GetSyncSource(IBaseFilter * iface, IReferenceClock **ppClock)
 385 {
 386     NullRendererImpl *This = (NullRendererImpl *)iface;
 387
 388     TRACE("(%p/%p)->(%p)\n", This, iface, ppClock);
 389
 390     EnterCriticalSection(&This->csFilter);
 391     {
 392         *ppClock = This->pClock;
 393         if (This->pClock)
 394             IReferenceClock_AddRef(This->pClock);
 395     }
 396     LeaveCriticalSection(&This->csFilter);
 397
 398     return S_OK;
 399 }
 400
 401 /** IBaseFilter implementation **/
 402
 403 static IPin* WINAPI NullRenderer_GetPin(IBaseFilter *iface, int pos)
 404 {
 405     NullRendererImpl *This = (NullRendererImpl *)iface;
 406
 407     if (pos >= 1 || pos < 0)
 408         return NULL;
 409
 410     IPin_AddRef((IPin *)This->pInputPin);
 411     return (IPin *)This->pInputPin;
 412 }
 413
 414 static LONG WINAPI NullRenderer_GetPinCount(IBaseFilter *iface)
 415 {
 416     return 1;
 417 }
 418
 419 static LONG WINAPI NullRenderer_GetPinVersion(IBaseFilter *iface)
 420 {
 421     /* Our pins are static, not changing so setting static tick count is ok */
 422     return 0;
 423 }
 424
 425 static HRESULT WINAPI NullRenderer_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum)
 426 {
 427     NullRendererImpl *This = (NullRendererImpl *)iface;
 428
 429     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 430
 431     return EnumPins_Construct(iface, NullRenderer_GetPin, NullRenderer_GetPinCount, NullRenderer_GetPinVersion, ppEnum);
 432 }
 433
 434 static HRESULT WINAPI NullRenderer_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
 435 {
 436     NullRendererImpl *This = (NullRendererImpl *)iface;
 437
 438     TRACE("(%p/%p)->(%p,%p)\n", This, iface, debugstr_w(Id), ppPin);
 439
 440     if (!Id || !ppPin)
 441         return E_POINTER;
 442
 443     if (!lstrcmpiW(Id,wcsInputPinName) || !lstrcmpiW(Id,wcsAltInputPinName))
 444     {
 445         *ppPin = (IPin *)This->pInputPin;
 446         IPin_AddRef(*ppPin);
 447         return S_OK;
 448     }
 449     *ppPin = NULL;
 450     return VFW_E_NOT_FOUND;
 451 }
 452
 453 static HRESULT WINAPI NullRenderer_QueryFilterInfo(IBaseFilter * iface, FILTER_INFO *pInfo)
 454 {
 455     NullRendererImpl *This = (NullRendererImpl *)iface;
 456
 457     TRACE("(%p/%p)->(%p)\n", This, iface, pInfo);
 458
 459     strcpyW(pInfo->achName, This->filterInfo.achName);
 460     pInfo->pGraph = This->filterInfo.pGraph;
 461
 462     if (pInfo->pGraph)
 463         IFilterGraph_AddRef(pInfo->pGraph);
 464
 465     return S_OK;
 466 }
 467
 468 static HRESULT WINAPI NullRenderer_JoinFilterGraph(IBaseFilter * iface, IFilterGraph *pGraph, LPCWSTR pName)
 469 {
 470     NullRendererImpl *This = (NullRendererImpl *)iface;
 471
 472     TRACE("(%p/%p)->(%p, %s)\n", This, iface, pGraph, debugstr_w(pName));
 473
 474     EnterCriticalSection(&This->csFilter);
 475     {
 476         if (pName)
 477             strcpyW(This->filterInfo.achName, pName);
 478         else
 479             *This->filterInfo.achName = '\0';
 480         This->filterInfo.pGraph = pGraph; /* NOTE: do NOT increase ref. count */
 481     }
 482     LeaveCriticalSection(&This->csFilter);
 483
 484     return S_OK;
 485 }
 486
 487 static HRESULT WINAPI NullRenderer_QueryVendorInfo(IBaseFilter * iface, LPWSTR *pVendorInfo)
 488 {
 489     NullRendererImpl *This = (NullRendererImpl *)iface;
 490     TRACE("(%p/%p)->(%p)\n", This, iface, pVendorInfo);
 491     return E_NOTIMPL;
 492 }
 493
 494 static const IBaseFilterVtbl NullRenderer_Vtbl =
 495 {
 496     NullRenderer_QueryInterface,
 497     NullRenderer_AddRef,
 498     NullRenderer_Release,
 499     NullRenderer_GetClassID,
 500     NullRenderer_Stop,
 501     NullRenderer_Pause,
 502     NullRenderer_Run,
 503     NullRenderer_GetState,
 504     NullRenderer_SetSyncSource,
 505     NullRenderer_GetSyncSource,
 506     NullRenderer_EnumPins,
 507     NullRenderer_FindPin,
 508     NullRenderer_QueryFilterInfo,
 509     NullRenderer_JoinFilterGraph,
 510     NullRenderer_QueryVendorInfo
 511 };
 512
 513 static HRESULT WINAPI NullRenderer_InputPin_EndOfStream(IPin * iface)
 514 {
 515     BaseInputPin* This = (BaseInputPin*)iface;
 516     IMediaEventSink* pEventSink;
 517     NullRendererImpl *pNull;
 518     IFilterGraph *graph;
 519     HRESULT hr = S_OK;
 520
 521     TRACE("(%p/%p)->()\n", This, iface);
 522
 523     BaseInputPinImpl_EndOfStream(iface);
 524     pNull = (NullRendererImpl*)This->pin.pinInfo.pFilter;
 525     graph = pNull->filterInfo.pGraph;
 526     if (graph)
 527     {
 528         hr = IFilterGraph_QueryInterface(((NullRendererImpl*)This->pin.pinInfo.pFilter)->filterInfo.pGraph, &IID_IMediaEventSink, (LPVOID*)&pEventSink);
 529         if (SUCCEEDED(hr))
 530         {
 531             hr = IMediaEventSink_Notify(pEventSink, EC_COMPLETE, S_OK, 0);
 532             IMediaEventSink_Release(pEventSink);
 533         }
 534     }
 535     MediaSeekingPassThru_EOS(pNull->seekthru_unk);
 536
 537     return hr;
 538 }
 539
 540 static HRESULT WINAPI NullRenderer_InputPin_EndFlush(IPin * iface)
 541 {
 542     BaseInputPin* This = (BaseInputPin*)iface;
 543     NullRendererImpl *pNull;
 544     HRESULT hr = S_OK;
 545
 546     TRACE("(%p/%p)->()\n", This, iface);
 547
 548     hr = BaseInputPinImpl_EndOfStream(iface);
 549     pNull = (NullRendererImpl*)This->pin.pinInfo.pFilter;
 550     MediaSeekingPassThru_ResetMediaTime(pNull->seekthru_unk);
 551     return hr;
 552 }
 553
 554 static const IPinVtbl NullRenderer_InputPin_Vtbl =
 555 {
 556     BaseInputPinImpl_QueryInterface,
 557     BasePinImpl_AddRef,
 558     BaseInputPinImpl_Release,
 559     BaseInputPinImpl_Connect,
 560     BaseInputPinImpl_ReceiveConnection,
 561     BasePinImpl_Disconnect,
 562     BasePinImpl_ConnectedTo,
 563     BasePinImpl_ConnectionMediaType,
 564     BasePinImpl_QueryPinInfo,
 565     BasePinImpl_QueryDirection,
 566     BasePinImpl_QueryId,
 567     BaseInputPinImpl_QueryAccept,
 568     BasePinImpl_EnumMediaTypes,
 569     BasePinImpl_QueryInternalConnections,
 570     NullRenderer_InputPin_EndOfStream,
 571     BaseInputPinImpl_BeginFlush,
 572     NullRenderer_InputPin_EndFlush,
 573     BaseInputPinImpl_NewSegment
 574 };