ntdll: Use the heap flags instead of debug channels to test for enabled debug features.
[wine] / 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
57     LONG refCount;
58     CRITICAL_SECTION csFilter;
59     FILTER_STATE state;
60     REFERENCE_TIME rtStreamStart;
61     IReferenceClock * pClock;
62     FILTER_INFO filterInfo;
63
64     InputPin *pInputPin;
65     IUnknown * pUnkOuter;
66     BOOL bUnkOuterValid;
67     BOOL bAggregatable;
68     MediaSeekingImpl mediaSeeking;
69 } NullRendererImpl;
70
71 static HRESULT NullRenderer_Sample(LPVOID iface, IMediaSample * pSample)
72 {
73     NullRendererImpl *This = iface;
74     HRESULT hr = S_OK;
75
76     TRACE("%p %p\n", iface, pSample);
77
78     EnterCriticalSection(&This->csFilter);
79     if (This->pInputPin->flushing || This->pInputPin->end_of_stream)
80         hr = S_FALSE;
81     LeaveCriticalSection(&This->csFilter);
82
83     return hr;
84 }
85
86 static HRESULT NullRenderer_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt)
87 {
88     TRACE("Not a stub!\n");
89     return S_OK;
90 }
91
92 static inline NullRendererImpl *impl_from_IMediaSeeking( IMediaSeeking *iface )
93 {
94     return (NullRendererImpl *)((char*)iface - FIELD_OFFSET(NullRendererImpl, mediaSeeking.lpVtbl));
95 }
96
97 static HRESULT WINAPI NullRendererImpl_Seeking_QueryInterface(IMediaSeeking * iface, REFIID riid, LPVOID * ppv)
98 {
99     NullRendererImpl *This = impl_from_IMediaSeeking(iface);
100
101     return IUnknown_QueryInterface((IUnknown *)This, riid, ppv);
102 }
103
104 static ULONG WINAPI NullRendererImpl_Seeking_AddRef(IMediaSeeking * iface)
105 {
106     NullRendererImpl *This = impl_from_IMediaSeeking(iface);
107
108     return IUnknown_AddRef((IUnknown *)This);
109 }
110
111 static ULONG WINAPI NullRendererImpl_Seeking_Release(IMediaSeeking * iface)
112 {
113     NullRendererImpl *This = impl_from_IMediaSeeking(iface);
114
115     return IUnknown_Release((IUnknown *)This);
116 }
117
118 static const IMediaSeekingVtbl TransformFilter_Seeking_Vtbl =
119 {
120     NullRendererImpl_Seeking_QueryInterface,
121     NullRendererImpl_Seeking_AddRef,
122     NullRendererImpl_Seeking_Release,
123     MediaSeekingImpl_GetCapabilities,
124     MediaSeekingImpl_CheckCapabilities,
125     MediaSeekingImpl_IsFormatSupported,
126     MediaSeekingImpl_QueryPreferredFormat,
127     MediaSeekingImpl_GetTimeFormat,
128     MediaSeekingImpl_IsUsingTimeFormat,
129     MediaSeekingImpl_SetTimeFormat,
130     MediaSeekingImpl_GetDuration,
131     MediaSeekingImpl_GetStopPosition,
132     MediaSeekingImpl_GetCurrentPosition,
133     MediaSeekingImpl_ConvertTimeFormat,
134     MediaSeekingImpl_SetPositions,
135     MediaSeekingImpl_GetPositions,
136     MediaSeekingImpl_GetAvailable,
137     MediaSeekingImpl_SetRate,
138     MediaSeekingImpl_GetRate,
139     MediaSeekingImpl_GetPreroll
140 };
141
142 static HRESULT NullRendererImpl_Change(IBaseFilter *iface)
143 {
144     TRACE("(%p)\n", iface);
145     return S_OK;
146 }
147
148 HRESULT NullRenderer_create(IUnknown * pUnkOuter, LPVOID * ppv)
149 {
150     HRESULT hr;
151     PIN_INFO piInput;
152     NullRendererImpl * pNullRenderer;
153
154     TRACE("(%p, %p)\n", pUnkOuter, ppv);
155
156     *ppv = NULL;
157
158     pNullRenderer = CoTaskMemAlloc(sizeof(NullRendererImpl));
159     pNullRenderer->pUnkOuter = pUnkOuter;
160     pNullRenderer->bUnkOuterValid = FALSE;
161     pNullRenderer->bAggregatable = FALSE;
162     pNullRenderer->IInner_vtbl = &IInner_VTable;
163
164     pNullRenderer->lpVtbl = &NullRenderer_Vtbl;
165     pNullRenderer->refCount = 1;
166     InitializeCriticalSection(&pNullRenderer->csFilter);
167     pNullRenderer->csFilter.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": NullRendererImpl.csFilter");
168     pNullRenderer->state = State_Stopped;
169     pNullRenderer->pClock = NULL;
170     ZeroMemory(&pNullRenderer->filterInfo, sizeof(FILTER_INFO));
171
172     /* construct input pin */
173     piInput.dir = PINDIR_INPUT;
174     piInput.pFilter = (IBaseFilter *)pNullRenderer;
175     lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0]));
176
177     hr = InputPin_Construct(&NullRenderer_InputPin_Vtbl, &piInput, NullRenderer_Sample, (LPVOID)pNullRenderer, NullRenderer_QueryAccept, NULL, &pNullRenderer->csFilter, NULL, (IPin **)&pNullRenderer->pInputPin);
178
179     if (SUCCEEDED(hr))
180     {
181         MediaSeekingImpl_Init((IBaseFilter*)pNullRenderer, NullRendererImpl_Change, NullRendererImpl_Change, NullRendererImpl_Change, &pNullRenderer->mediaSeeking, &pNullRenderer->csFilter);
182         pNullRenderer->mediaSeeking.lpVtbl = &TransformFilter_Seeking_Vtbl;
183
184         *ppv = pNullRenderer;
185     }
186     else
187     {
188         pNullRenderer->csFilter.DebugInfo->Spare[0] = 0;
189         DeleteCriticalSection(&pNullRenderer->csFilter);
190         CoTaskMemFree(pNullRenderer);
191     }
192
193     return hr;
194 }
195
196 static HRESULT WINAPI NullRendererInner_QueryInterface(IUnknown * iface, REFIID riid, LPVOID * ppv)
197 {
198     ICOM_THIS_MULTI(NullRendererImpl, IInner_vtbl, iface);
199     TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
200
201     if (This->bAggregatable)
202         This->bUnkOuterValid = TRUE;
203
204     *ppv = NULL;
205
206     if (IsEqualIID(riid, &IID_IUnknown))
207         *ppv = &This->IInner_vtbl;
208     else if (IsEqualIID(riid, &IID_IPersist))
209         *ppv = This;
210     else if (IsEqualIID(riid, &IID_IMediaFilter))
211         *ppv = This;
212     else if (IsEqualIID(riid, &IID_IBaseFilter))
213         *ppv = This;
214     else if (IsEqualIID(riid, &IID_IMediaSeeking))
215         *ppv = &This->mediaSeeking;
216
217     if (*ppv)
218     {
219         IUnknown_AddRef((IUnknown *)(*ppv));
220         return S_OK;
221     }
222
223     if (!IsEqualIID(riid, &IID_IPin) && !IsEqualIID(riid, &IID_IVideoWindow))
224         FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
225
226     return E_NOINTERFACE;
227 }
228
229 static ULONG WINAPI NullRendererInner_AddRef(IUnknown * iface)
230 {
231     ICOM_THIS_MULTI(NullRendererImpl, IInner_vtbl, iface);
232     ULONG refCount = InterlockedIncrement(&This->refCount);
233
234     TRACE("(%p/%p)->() AddRef from %d\n", This, iface, refCount - 1);
235
236     return refCount;
237 }
238
239 static ULONG WINAPI NullRendererInner_Release(IUnknown * iface)
240 {
241     ICOM_THIS_MULTI(NullRendererImpl, IInner_vtbl, iface);
242     ULONG refCount = InterlockedDecrement(&This->refCount);
243
244     TRACE("(%p/%p)->() Release from %d\n", This, iface, refCount + 1);
245
246     if (!refCount)
247     {
248         IPin *pConnectedTo;
249
250         if (This->pClock)
251             IReferenceClock_Release(This->pClock);
252
253         if (SUCCEEDED(IPin_ConnectedTo((IPin *)This->pInputPin, &pConnectedTo)))
254         {
255             IPin_Disconnect(pConnectedTo);
256             IPin_Release(pConnectedTo);
257         }
258         IPin_Disconnect((IPin *)This->pInputPin);
259         IPin_Release((IPin *)This->pInputPin);
260
261         This->lpVtbl = NULL;
262
263         This->csFilter.DebugInfo->Spare[0] = 0;
264         DeleteCriticalSection(&This->csFilter);
265
266         TRACE("Destroying Null Renderer\n");
267         CoTaskMemFree(This);
268         return 0;
269     }
270     else
271         return refCount;
272 }
273
274 static const IUnknownVtbl IInner_VTable =
275 {
276     NullRendererInner_QueryInterface,
277     NullRendererInner_AddRef,
278     NullRendererInner_Release
279 };
280
281 static HRESULT WINAPI NullRenderer_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
282 {
283     NullRendererImpl *This = (NullRendererImpl *)iface;
284
285     if (This->bAggregatable)
286         This->bUnkOuterValid = TRUE;
287
288     if (This->pUnkOuter)
289     {
290         if (This->bAggregatable)
291             return IUnknown_QueryInterface(This->pUnkOuter, riid, ppv);
292
293         if (IsEqualIID(riid, &IID_IUnknown))
294         {
295             HRESULT hr;
296
297             IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl));
298             hr = IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv);
299             IUnknown_Release((IUnknown *)&(This->IInner_vtbl));
300             This->bAggregatable = TRUE;
301             return hr;
302         }
303
304         *ppv = NULL;
305         return E_NOINTERFACE;
306     }
307
308     return IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv);
309 }
310
311 static ULONG WINAPI NullRenderer_AddRef(IBaseFilter * iface)
312 {
313     NullRendererImpl *This = (NullRendererImpl *)iface;
314
315     if (This->pUnkOuter && This->bUnkOuterValid)
316         return IUnknown_AddRef(This->pUnkOuter);
317     return IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl));
318 }
319
320 static ULONG WINAPI NullRenderer_Release(IBaseFilter * iface)
321 {
322     NullRendererImpl *This = (NullRendererImpl *)iface;
323
324     if (This->pUnkOuter && This->bUnkOuterValid)
325         return IUnknown_Release(This->pUnkOuter);
326     return IUnknown_Release((IUnknown *)&(This->IInner_vtbl));
327 }
328
329 /** IPersist methods **/
330
331 static HRESULT WINAPI NullRenderer_GetClassID(IBaseFilter * iface, CLSID * pClsid)
332 {
333     NullRendererImpl *This = (NullRendererImpl *)iface;
334
335     TRACE("(%p/%p)->(%p)\n", This, iface, pClsid);
336
337     *pClsid = CLSID_NullRenderer;
338
339     return S_OK;
340 }
341
342 /** IMediaFilter methods **/
343
344 static HRESULT WINAPI NullRenderer_Stop(IBaseFilter * iface)
345 {
346     NullRendererImpl *This = (NullRendererImpl *)iface;
347
348     TRACE("(%p/%p)->()\n", This, iface);
349
350     EnterCriticalSection(&This->csFilter);
351     {
352         This->state = State_Stopped;
353     }
354     LeaveCriticalSection(&This->csFilter);
355
356     return S_OK;
357 }
358
359 static HRESULT WINAPI NullRenderer_Pause(IBaseFilter * iface)
360 {
361     NullRendererImpl *This = (NullRendererImpl *)iface;
362
363     TRACE("(%p/%p)->()\n", This, iface);
364
365     EnterCriticalSection(&This->csFilter);
366     {
367         if (This->state == State_Stopped)
368             This->pInputPin->end_of_stream = 0;
369         This->state = State_Paused;
370     }
371     LeaveCriticalSection(&This->csFilter);
372
373     return S_OK;
374 }
375
376 static HRESULT WINAPI NullRenderer_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
377 {
378     NullRendererImpl *This = (NullRendererImpl *)iface;
379
380     TRACE("(%p/%p)->(%s)\n", This, iface, wine_dbgstr_longlong(tStart));
381
382     EnterCriticalSection(&This->csFilter);
383     {
384         This->rtStreamStart = tStart;
385         This->state = State_Running;
386         This->pInputPin->end_of_stream = 0;
387     }
388     LeaveCriticalSection(&This->csFilter);
389
390     return S_OK;
391 }
392
393 static HRESULT WINAPI NullRenderer_GetState(IBaseFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
394 {
395     NullRendererImpl *This = (NullRendererImpl *)iface;
396
397     TRACE("(%p/%p)->(%d, %p)\n", This, iface, dwMilliSecsTimeout, pState);
398
399     EnterCriticalSection(&This->csFilter);
400     {
401         *pState = This->state;
402     }
403     LeaveCriticalSection(&This->csFilter);
404
405     return S_OK;
406 }
407
408 static HRESULT WINAPI NullRenderer_SetSyncSource(IBaseFilter * iface, IReferenceClock *pClock)
409 {
410     NullRendererImpl *This = (NullRendererImpl *)iface;
411
412     TRACE("(%p/%p)->(%p)\n", This, iface, pClock);
413
414     EnterCriticalSection(&This->csFilter);
415     {
416         if (This->pClock)
417             IReferenceClock_Release(This->pClock);
418         This->pClock = pClock;
419         if (This->pClock)
420             IReferenceClock_AddRef(This->pClock);
421     }
422     LeaveCriticalSection(&This->csFilter);
423
424     return S_OK;
425 }
426
427 static HRESULT WINAPI NullRenderer_GetSyncSource(IBaseFilter * iface, IReferenceClock **ppClock)
428 {
429     NullRendererImpl *This = (NullRendererImpl *)iface;
430
431     TRACE("(%p/%p)->(%p)\n", This, iface, ppClock);
432
433     EnterCriticalSection(&This->csFilter);
434     {
435         *ppClock = This->pClock;
436         if (This->pClock)
437             IReferenceClock_AddRef(This->pClock);
438     }
439     LeaveCriticalSection(&This->csFilter);
440
441     return S_OK;
442 }
443
444 /** IBaseFilter implementation **/
445
446 static HRESULT NullRenderer_GetPin(IBaseFilter *iface, ULONG pos, IPin **pin, DWORD *lastsynctick)
447 {
448     NullRendererImpl *This = (NullRendererImpl *)iface;
449
450     /* Our pins are static, not changing so setting static tick count is ok */
451     *lastsynctick = 0;
452
453     if (pos >= 1)
454         return S_FALSE;
455
456     *pin = (IPin *)This->pInputPin;
457     IPin_AddRef(*pin);
458     return S_OK;
459 }
460
461 static HRESULT WINAPI NullRenderer_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum)
462 {
463     NullRendererImpl *This = (NullRendererImpl *)iface;
464
465     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
466
467     return IEnumPinsImpl_Construct(ppEnum, NullRenderer_GetPin, iface);
468 }
469
470 static HRESULT WINAPI NullRenderer_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
471 {
472     NullRendererImpl *This = (NullRendererImpl *)iface;
473
474     TRACE("(%p/%p)->(%p,%p)\n", This, iface, debugstr_w(Id), ppPin);
475
476     if (!Id || !ppPin)
477         return E_POINTER;
478
479     if (!lstrcmpiW(Id,wcsInputPinName) || !lstrcmpiW(Id,wcsAltInputPinName))
480     {
481         *ppPin = (IPin *)This->pInputPin;
482         IPin_AddRef(*ppPin);
483         return S_OK;
484     }
485     *ppPin = NULL;
486     return VFW_E_NOT_FOUND;
487 }
488
489 static HRESULT WINAPI NullRenderer_QueryFilterInfo(IBaseFilter * iface, FILTER_INFO *pInfo)
490 {
491     NullRendererImpl *This = (NullRendererImpl *)iface;
492
493     TRACE("(%p/%p)->(%p)\n", This, iface, pInfo);
494
495     strcpyW(pInfo->achName, This->filterInfo.achName);
496     pInfo->pGraph = This->filterInfo.pGraph;
497
498     if (pInfo->pGraph)
499         IFilterGraph_AddRef(pInfo->pGraph);
500
501     return S_OK;
502 }
503
504 static HRESULT WINAPI NullRenderer_JoinFilterGraph(IBaseFilter * iface, IFilterGraph *pGraph, LPCWSTR pName)
505 {
506     NullRendererImpl *This = (NullRendererImpl *)iface;
507
508     TRACE("(%p/%p)->(%p, %s)\n", This, iface, pGraph, debugstr_w(pName));
509
510     EnterCriticalSection(&This->csFilter);
511     {
512         if (pName)
513             strcpyW(This->filterInfo.achName, pName);
514         else
515             *This->filterInfo.achName = '\0';
516         This->filterInfo.pGraph = pGraph; /* NOTE: do NOT increase ref. count */
517     }
518     LeaveCriticalSection(&This->csFilter);
519
520     return S_OK;
521 }
522
523 static HRESULT WINAPI NullRenderer_QueryVendorInfo(IBaseFilter * iface, LPWSTR *pVendorInfo)
524 {
525     NullRendererImpl *This = (NullRendererImpl *)iface;
526     TRACE("(%p/%p)->(%p)\n", This, iface, pVendorInfo);
527     return E_NOTIMPL;
528 }
529
530 static const IBaseFilterVtbl NullRenderer_Vtbl =
531 {
532     NullRenderer_QueryInterface,
533     NullRenderer_AddRef,
534     NullRenderer_Release,
535     NullRenderer_GetClassID,
536     NullRenderer_Stop,
537     NullRenderer_Pause,
538     NullRenderer_Run,
539     NullRenderer_GetState,
540     NullRenderer_SetSyncSource,
541     NullRenderer_GetSyncSource,
542     NullRenderer_EnumPins,
543     NullRenderer_FindPin,
544     NullRenderer_QueryFilterInfo,
545     NullRenderer_JoinFilterGraph,
546     NullRenderer_QueryVendorInfo
547 };
548
549 static HRESULT WINAPI NullRenderer_InputPin_EndOfStream(IPin * iface)
550 {
551     InputPin* This = (InputPin*)iface;
552     IMediaEventSink* pEventSink;
553     IFilterGraph *graph;
554     HRESULT hr = S_OK;
555
556     TRACE("(%p/%p)->()\n", This, iface);
557
558     InputPin_EndOfStream(iface);
559     graph = ((NullRendererImpl*)This->pin.pinInfo.pFilter)->filterInfo.pGraph;
560     if (graph)
561     {
562         hr = IFilterGraph_QueryInterface(((NullRendererImpl*)This->pin.pinInfo.pFilter)->filterInfo.pGraph, &IID_IMediaEventSink, (LPVOID*)&pEventSink);
563         if (SUCCEEDED(hr))
564         {
565             hr = IMediaEventSink_Notify(pEventSink, EC_COMPLETE, S_OK, 0);
566             IMediaEventSink_Release(pEventSink);
567         }
568     }
569
570     return hr;
571 }
572
573 static const IPinVtbl NullRenderer_InputPin_Vtbl =
574 {
575     InputPin_QueryInterface,
576     IPinImpl_AddRef,
577     InputPin_Release,
578     InputPin_Connect,
579     InputPin_ReceiveConnection,
580     IPinImpl_Disconnect,
581     IPinImpl_ConnectedTo,
582     IPinImpl_ConnectionMediaType,
583     IPinImpl_QueryPinInfo,
584     IPinImpl_QueryDirection,
585     IPinImpl_QueryId,
586     IPinImpl_QueryAccept,
587     IPinImpl_EnumMediaTypes,
588     IPinImpl_QueryInternalConnections,
589     NullRenderer_InputPin_EndOfStream,
590     InputPin_BeginFlush,
591     InputPin_EndFlush,
592     InputPin_NewSegment
593 };