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     BaseFilter filter;
  55     const IUnknownVtbl * IInner_vtbl;
  56     IUnknown *seekthru_unk;
  57
  58     BaseInputPin *pInputPin;
  59     IUnknown * pUnkOuter;
  60     BOOL bUnkOuterValid;
  61     BOOL bAggregatable;
  62 } NullRendererImpl;
  63
  64 static HRESULT WINAPI NullRenderer_Receive(IPin *iface, IMediaSample * pSample)
  65 {
  66     BaseInputPin *pin = (BaseInputPin*)iface;
  67     NullRendererImpl *This = ((NullRendererImpl*)pin->pin.pinInfo.pFilter);
  68     HRESULT hr = S_OK;
  69     REFERENCE_TIME start, stop;
  70
  71     TRACE("%p %p\n", iface, pSample);
  72
  73     if (SUCCEEDED(IMediaSample_GetTime(pSample, &start, &stop)))
  74         MediaSeekingPassThru_RegisterMediaTime(This->seekthru_unk, start);
  75     EnterCriticalSection(&This->filter.csFilter);
  76     if (This->pInputPin->flushing || This->pInputPin->end_of_stream)
  77         hr = S_FALSE;
  78     LeaveCriticalSection(&This->filter.csFilter);
  79
  80     return hr;
  81 }
  82
  83 static HRESULT WINAPI NullRenderer_CheckMediaType(IPin *iface, const AM_MEDIA_TYPE * pmt)
  84 {
  85     TRACE("Not a stub!\n");
  86     return S_OK;
  87 }
  88
  89 HRESULT NullRenderer_create(IUnknown * pUnkOuter, LPVOID * ppv)
  90 {
  91     HRESULT hr;
  92     PIN_INFO piInput;
  93     NullRendererImpl * pNullRenderer;
  94
  95     TRACE("(%p, %p)\n", pUnkOuter, ppv);
  96
  97     *ppv = NULL;
  98
  99     pNullRenderer = CoTaskMemAlloc(sizeof(NullRendererImpl));
 100     pNullRenderer->pUnkOuter = pUnkOuter;
 101     pNullRenderer->bUnkOuterValid = FALSE;
 102     pNullRenderer->bAggregatable = FALSE;
 103     pNullRenderer->IInner_vtbl = &IInner_VTable;
 104
 105     BaseFilter_Init(&pNullRenderer->filter, &NullRenderer_Vtbl, &CLSID_NullRenderer, (DWORD_PTR)(__FILE__ ": NullRendererImpl.csFilter"));
 106
 107     /* construct input pin */
 108     piInput.dir = PINDIR_INPUT;
 109     piInput.pFilter = (IBaseFilter *)pNullRenderer;
 110     lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0]));
 111
 112     hr = BaseInputPin_Construct(&NullRenderer_InputPin_Vtbl, &piInput, NullRenderer_CheckMediaType, NullRenderer_Receive, &pNullRenderer->filter.csFilter, NULL, (IPin **)&pNullRenderer->pInputPin);
 113
 114     if (SUCCEEDED(hr))
 115     {
 116         ISeekingPassThru *passthru;
 117         hr = CoCreateInstance(&CLSID_SeekingPassThru, pUnkOuter ? pUnkOuter : (IUnknown*)&pNullRenderer->IInner_vtbl, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void**)&pNullRenderer->seekthru_unk);
 118         if (FAILED(hr)) {
 119             IUnknown_Release((IUnknown*)pNullRenderer);
 120             return hr;
 121         }
 122         IUnknown_QueryInterface(pNullRenderer->seekthru_unk, &IID_ISeekingPassThru, (void**)&passthru);
 123         ISeekingPassThru_Init(passthru, TRUE, (IPin*)pNullRenderer->pInputPin);
 124         ISeekingPassThru_Release(passthru);
 125         *ppv = pNullRenderer;
 126     }
 127     else
 128     {
 129         BaseFilterImpl_Release((IBaseFilter*)pNullRenderer);
 130         CoTaskMemFree(pNullRenderer);
 131     }
 132
 133     return hr;
 134 }
 135
 136 static HRESULT WINAPI NullRendererInner_QueryInterface(IUnknown * iface, REFIID riid, LPVOID * ppv)
 137 {
 138     ICOM_THIS_MULTI(NullRendererImpl, IInner_vtbl, iface);
 139     TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
 140
 141     if (This->bAggregatable)
 142         This->bUnkOuterValid = TRUE;
 143
 144     *ppv = NULL;
 145
 146     if (IsEqualIID(riid, &IID_IUnknown))
 147         *ppv = &This->IInner_vtbl;
 148     else if (IsEqualIID(riid, &IID_IPersist))
 149         *ppv = This;
 150     else if (IsEqualIID(riid, &IID_IMediaFilter))
 151         *ppv = This;
 152     else if (IsEqualIID(riid, &IID_IBaseFilter))
 153         *ppv = This;
 154     else if (IsEqualIID(riid, &IID_IMediaSeeking))
 155         return IUnknown_QueryInterface(This->seekthru_unk, riid, ppv);
 156
 157     if (*ppv)
 158     {
 159         IUnknown_AddRef((IUnknown *)(*ppv));
 160         return S_OK;
 161     }
 162
 163     if (!IsEqualIID(riid, &IID_IPin) && !IsEqualIID(riid, &IID_IVideoWindow))
 164         FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 165
 166     return E_NOINTERFACE;
 167 }
 168
 169 static ULONG WINAPI NullRendererInner_AddRef(IUnknown * iface)
 170 {
 171     ICOM_THIS_MULTI(NullRendererImpl, IInner_vtbl, iface);
 172     ULONG refCount = InterlockedIncrement(&This->filter.refCount);
 173
 174     TRACE("(%p/%p)->() AddRef from %d\n", This, iface, refCount - 1);
 175
 176     return refCount;
 177 }
 178
 179 static ULONG WINAPI NullRendererInner_Release(IUnknown * iface)
 180 {
 181     ICOM_THIS_MULTI(NullRendererImpl, IInner_vtbl, iface);
 182     ULONG refCount = InterlockedDecrement(&This->filter.refCount);
 183
 184     TRACE("(%p/%p)->() Release from %d\n", This, iface, refCount + 1);
 185
 186     if (!refCount)
 187     {
 188         IPin *pConnectedTo;
 189
 190         if (SUCCEEDED(IPin_ConnectedTo((IPin *)This->pInputPin, &pConnectedTo)))
 191         {
 192             IPin_Disconnect(pConnectedTo);
 193             IPin_Release(pConnectedTo);
 194         }
 195         IPin_Disconnect((IPin *)This->pInputPin);
 196         IPin_Release((IPin *)This->pInputPin);
 197
 198         This->filter.lpVtbl = NULL;
 199         if (This->seekthru_unk)
 200             IUnknown_Release(This->seekthru_unk);
 201
 202         This->filter.csFilter.DebugInfo->Spare[0] = 0;
 203         DeleteCriticalSection(&This->filter.csFilter);
 204
 205         TRACE("Destroying Null Renderer\n");
 206         CoTaskMemFree(This);
 207         return 0;
 208     }
 209     else
 210         return refCount;
 211 }
 212
 213 static const IUnknownVtbl IInner_VTable =
 214 {
 215     NullRendererInner_QueryInterface,
 216     NullRendererInner_AddRef,
 217     NullRendererInner_Release
 218 };
 219
 220 static HRESULT WINAPI NullRenderer_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
 221 {
 222     NullRendererImpl *This = (NullRendererImpl *)iface;
 223
 224     if (This->bAggregatable)
 225         This->bUnkOuterValid = TRUE;
 226
 227     if (This->pUnkOuter)
 228     {
 229         if (This->bAggregatable)
 230             return IUnknown_QueryInterface(This->pUnkOuter, riid, ppv);
 231
 232         if (IsEqualIID(riid, &IID_IUnknown))
 233         {
 234             HRESULT hr;
 235
 236             IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl));
 237             hr = IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv);
 238             IUnknown_Release((IUnknown *)&(This->IInner_vtbl));
 239             This->bAggregatable = TRUE;
 240             return hr;
 241         }
 242
 243         *ppv = NULL;
 244         return E_NOINTERFACE;
 245     }
 246
 247     return IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv);
 248 }
 249
 250 static ULONG WINAPI NullRenderer_AddRef(IBaseFilter * iface)
 251 {
 252     NullRendererImpl *This = (NullRendererImpl *)iface;
 253
 254     if (This->pUnkOuter && This->bUnkOuterValid)
 255         return IUnknown_AddRef(This->pUnkOuter);
 256     return IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl));
 257 }
 258
 259 static ULONG WINAPI NullRenderer_Release(IBaseFilter * iface)
 260 {
 261     NullRendererImpl *This = (NullRendererImpl *)iface;
 262
 263     if (This->pUnkOuter && This->bUnkOuterValid)
 264         return IUnknown_Release(This->pUnkOuter);
 265     return IUnknown_Release((IUnknown *)&(This->IInner_vtbl));
 266 }
 267
 268 /** IMediaFilter methods **/
 269
 270 static HRESULT WINAPI NullRenderer_Stop(IBaseFilter * iface)
 271 {
 272     NullRendererImpl *This = (NullRendererImpl *)iface;
 273
 274     TRACE("(%p/%p)->()\n", This, iface);
 275
 276     EnterCriticalSection(&This->filter.csFilter);
 277     {
 278         This->filter.state = State_Stopped;
 279         MediaSeekingPassThru_ResetMediaTime(This->seekthru_unk);
 280     }
 281     LeaveCriticalSection(&This->filter.csFilter);
 282
 283     return S_OK;
 284 }
 285
 286 static HRESULT WINAPI NullRenderer_Pause(IBaseFilter * iface)
 287 {
 288     NullRendererImpl *This = (NullRendererImpl *)iface;
 289
 290     TRACE("(%p/%p)->()\n", This, iface);
 291
 292     EnterCriticalSection(&This->filter.csFilter);
 293     {
 294         if (This->filter.state == State_Stopped)
 295             This->pInputPin->end_of_stream = 0;
 296         This->filter.state = State_Paused;
 297     }
 298     LeaveCriticalSection(&This->filter.csFilter);
 299
 300     return S_OK;
 301 }
 302
 303 static HRESULT WINAPI NullRenderer_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
 304 {
 305     NullRendererImpl *This = (NullRendererImpl *)iface;
 306
 307     TRACE("(%p/%p)->(%s)\n", This, iface, wine_dbgstr_longlong(tStart));
 308
 309     EnterCriticalSection(&This->filter.csFilter);
 310     {
 311         This->filter.rtStreamStart = tStart;
 312         This->filter.state = State_Running;
 313         This->pInputPin->end_of_stream = 0;
 314     }
 315     LeaveCriticalSection(&This->filter.csFilter);
 316
 317     return S_OK;
 318 }
 319
 320 /** IBaseFilter implementation **/
 321
 322 static IPin* WINAPI NullRenderer_GetPin(IBaseFilter *iface, int pos)
 323 {
 324     NullRendererImpl *This = (NullRendererImpl *)iface;
 325
 326     if (pos >= 1 || pos < 0)
 327         return NULL;
 328
 329     IPin_AddRef((IPin *)This->pInputPin);
 330     return (IPin *)This->pInputPin;
 331 }
 332
 333 static LONG WINAPI NullRenderer_GetPinCount(IBaseFilter *iface)
 334 {
 335     return 1;
 336 }
 337
 338 static LONG WINAPI NullRenderer_GetPinVersion(IBaseFilter *iface)
 339 {
 340     /* Our pins are static, not changing so setting static tick count is ok */
 341     return 0;
 342 }
 343
 344 static HRESULT WINAPI NullRenderer_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum)
 345 {
 346     NullRendererImpl *This = (NullRendererImpl *)iface;
 347
 348     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 349
 350     return EnumPins_Construct(iface, NullRenderer_GetPin, NullRenderer_GetPinCount, NullRenderer_GetPinVersion, ppEnum);
 351 }
 352
 353 static HRESULT WINAPI NullRenderer_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
 354 {
 355     NullRendererImpl *This = (NullRendererImpl *)iface;
 356
 357     TRACE("(%p/%p)->(%p,%p)\n", This, iface, debugstr_w(Id), ppPin);
 358
 359     if (!Id || !ppPin)
 360         return E_POINTER;
 361
 362     if (!lstrcmpiW(Id,wcsInputPinName) || !lstrcmpiW(Id,wcsAltInputPinName))
 363     {
 364         *ppPin = (IPin *)This->pInputPin;
 365         IPin_AddRef(*ppPin);
 366         return S_OK;
 367     }
 368     *ppPin = NULL;
 369     return VFW_E_NOT_FOUND;
 370 }
 371
 372 static const IBaseFilterVtbl NullRenderer_Vtbl =
 373 {
 374     NullRenderer_QueryInterface,
 375     NullRenderer_AddRef,
 376     NullRenderer_Release,
 377     BaseFilterImpl_GetClassID,
 378     NullRenderer_Stop,
 379     NullRenderer_Pause,
 380     NullRenderer_Run,
 381     BaseFilterImpl_GetState,
 382     BaseFilterImpl_SetSyncSource,
 383     BaseFilterImpl_GetSyncSource,
 384     NullRenderer_EnumPins,
 385     NullRenderer_FindPin,
 386     BaseFilterImpl_QueryFilterInfo,
 387     BaseFilterImpl_JoinFilterGraph,
 388     BaseFilterImpl_QueryVendorInfo
 389 };
 390
 391 static HRESULT WINAPI NullRenderer_InputPin_EndOfStream(IPin * iface)
 392 {
 393     BaseInputPin* This = (BaseInputPin*)iface;
 394     IMediaEventSink* pEventSink;
 395     NullRendererImpl *pNull;
 396     IFilterGraph *graph;
 397     HRESULT hr = S_OK;
 398
 399     TRACE("(%p/%p)->()\n", This, iface);
 400
 401     BaseInputPinImpl_EndOfStream(iface);
 402     pNull = (NullRendererImpl*)This->pin.pinInfo.pFilter;
 403     graph = pNull->filter.filterInfo.pGraph;
 404     if (graph)
 405     {
 406         hr = IFilterGraph_QueryInterface(((NullRendererImpl*)This->pin.pinInfo.pFilter)->filter.filterInfo.pGraph, &IID_IMediaEventSink, (LPVOID*)&pEventSink);
 407         if (SUCCEEDED(hr))
 408         {
 409             hr = IMediaEventSink_Notify(pEventSink, EC_COMPLETE, S_OK, 0);
 410             IMediaEventSink_Release(pEventSink);
 411         }
 412     }
 413     MediaSeekingPassThru_EOS(pNull->seekthru_unk);
 414
 415     return hr;
 416 }
 417
 418 static HRESULT WINAPI NullRenderer_InputPin_EndFlush(IPin * iface)
 419 {
 420     BaseInputPin* This = (BaseInputPin*)iface;
 421     NullRendererImpl *pNull;
 422     HRESULT hr = S_OK;
 423
 424     TRACE("(%p/%p)->()\n", This, iface);
 425
 426     hr = BaseInputPinImpl_EndOfStream(iface);
 427     pNull = (NullRendererImpl*)This->pin.pinInfo.pFilter;
 428     MediaSeekingPassThru_ResetMediaTime(pNull->seekthru_unk);
 429     return hr;
 430 }
 431
 432 static const IPinVtbl NullRenderer_InputPin_Vtbl =
 433 {
 434     BaseInputPinImpl_QueryInterface,
 435     BasePinImpl_AddRef,
 436     BaseInputPinImpl_Release,
 437     BaseInputPinImpl_Connect,
 438     BaseInputPinImpl_ReceiveConnection,
 439     BasePinImpl_Disconnect,
 440     BasePinImpl_ConnectedTo,
 441     BasePinImpl_ConnectionMediaType,
 442     BasePinImpl_QueryPinInfo,
 443     BasePinImpl_QueryDirection,
 444     BasePinImpl_QueryId,
 445     BaseInputPinImpl_QueryAccept,
 446     BasePinImpl_EnumMediaTypes,
 447     BasePinImpl_QueryInternalConnections,
 448     NullRenderer_InputPin_EndOfStream,
 449     BaseInputPinImpl_BeginFlush,
 450     NullRenderer_InputPin_EndFlush,
 451     BaseInputPinImpl_NewSegment
 452 };