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