| /* |
| * SmartTeeFilter tests |
| * |
| * Copyright 2015 Damjan Jovanovic |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include <stdarg.h> |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winuser.h" |
| #define COBJMACROS |
| #include <dshow.h> |
| #include <guiddef.h> |
| #include <devguid.h> |
| #include <stdio.h> |
| |
| #include "wine/strmbase.h" |
| #include "wine/test.h" |
| |
| static HANDLE event; |
| |
| typedef struct { |
| IBaseFilter IBaseFilter_iface; |
| LONG ref; |
| BOOL isCapture; |
| DWORD receiveThreadId; |
| IPin IPin_iface; |
| IMemInputPin IMemInputPin_iface; |
| IMemAllocator *allocator; |
| IBaseFilter *nullRenderer; |
| IPin *nullRendererPin; |
| IMemInputPin *nullRendererMemInputPin; |
| } SinkFilter; |
| |
| typedef struct { |
| IEnumPins IEnumPins_iface; |
| LONG ref; |
| ULONG index; |
| SinkFilter *filter; |
| } SinkEnumPins; |
| |
| static SinkEnumPins* create_SinkEnumPins(SinkFilter *filter); |
| |
| static inline SinkFilter* impl_from_SinkFilter_IBaseFilter(IBaseFilter *iface) |
| { |
| return CONTAINING_RECORD(iface, SinkFilter, IBaseFilter_iface); |
| } |
| |
| static inline SinkFilter* impl_from_SinkFilter_IPin(IPin *iface) |
| { |
| return CONTAINING_RECORD(iface, SinkFilter, IPin_iface); |
| } |
| |
| static inline SinkFilter* impl_from_SinkFilter_IMemInputPin(IMemInputPin *iface) |
| { |
| return CONTAINING_RECORD(iface, SinkFilter, IMemInputPin_iface); |
| } |
| |
| static inline SinkEnumPins* impl_from_SinkFilter_IEnumPins(IEnumPins *iface) |
| { |
| return CONTAINING_RECORD(iface, SinkEnumPins, IEnumPins_iface); |
| } |
| |
| static HRESULT WINAPI SinkFilter_QueryInterface(IBaseFilter *iface, REFIID riid, void **ppv) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| if(IsEqualIID(riid, &IID_IUnknown)) { |
| *ppv = &This->IBaseFilter_iface; |
| } else if(IsEqualIID(riid, &IID_IPersist)) { |
| *ppv = &This->IBaseFilter_iface; |
| } else if(IsEqualIID(riid, &IID_IMediaFilter)) { |
| *ppv = &This->IBaseFilter_iface; |
| } else if(IsEqualIID(riid, &IID_IBaseFilter)) { |
| *ppv = &This->IBaseFilter_iface; |
| } else { |
| trace("no interface for %s\n", wine_dbgstr_guid(riid)); |
| *ppv = NULL; |
| return E_NOINTERFACE; |
| } |
| IUnknown_AddRef((IUnknown*)*ppv); |
| return S_OK; |
| } |
| |
| static ULONG WINAPI SinkFilter_AddRef(IBaseFilter *iface) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| return InterlockedIncrement(&This->ref); |
| } |
| |
| static ULONG WINAPI SinkFilter_Release(IBaseFilter *iface) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| ULONG ref = InterlockedDecrement(&This->ref); |
| if(!ref) { |
| if (This->allocator) |
| IMemAllocator_Release(This->allocator); |
| IMemInputPin_Release(This->nullRendererMemInputPin); |
| IPin_Release(This->nullRendererPin); |
| IBaseFilter_Release(This->nullRenderer); |
| CoTaskMemFree(This); |
| } |
| return ref; |
| } |
| |
| static HRESULT WINAPI SinkFilter_GetClassID(IBaseFilter *iface, CLSID *pClassID) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| return IBaseFilter_GetClassID(This->nullRenderer, pClassID); |
| } |
| |
| static HRESULT WINAPI SinkFilter_Stop(IBaseFilter *iface) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| return IBaseFilter_Stop(This->nullRenderer); |
| } |
| |
| static HRESULT WINAPI SinkFilter_Pause(IBaseFilter *iface) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| return IBaseFilter_Pause(This->nullRenderer); |
| } |
| |
| static HRESULT WINAPI SinkFilter_Run(IBaseFilter *iface, REFERENCE_TIME tStart) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| return IBaseFilter_Run(This->nullRenderer, tStart); |
| } |
| |
| static HRESULT WINAPI SinkFilter_GetState(IBaseFilter *iface, DWORD dwMilliSecsTimeout, FILTER_STATE *state) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| return IBaseFilter_GetState(This->nullRenderer, dwMilliSecsTimeout, state); |
| } |
| |
| static HRESULT WINAPI SinkFilter_SetSyncSource(IBaseFilter *iface, IReferenceClock *pClock) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| return IBaseFilter_SetSyncSource(This->nullRenderer, pClock); |
| } |
| |
| static HRESULT WINAPI SinkFilter_GetSyncSource(IBaseFilter *iface, IReferenceClock **ppClock) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| return IBaseFilter_GetSyncSource(This->nullRenderer, ppClock); |
| } |
| |
| static HRESULT WINAPI SinkFilter_EnumPins(IBaseFilter *iface, IEnumPins **ppEnum) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| SinkEnumPins *sinkEnumPins = create_SinkEnumPins(This); |
| if (sinkEnumPins) { |
| *ppEnum = &sinkEnumPins->IEnumPins_iface; |
| return S_OK; |
| } |
| else |
| return E_OUTOFMEMORY; |
| } |
| |
| static HRESULT WINAPI SinkFilter_FindPin(IBaseFilter *iface, LPCWSTR id, IPin **ppPin) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| HRESULT hr = IBaseFilter_FindPin(This->nullRenderer, id, ppPin); |
| if (SUCCEEDED(hr)) { |
| IPin_Release(*ppPin); |
| *ppPin = &This->IPin_iface; |
| IPin_AddRef(&This->IPin_iface); |
| } |
| return hr; |
| } |
| |
| static HRESULT WINAPI SinkFilter_QueryFilterInfo(IBaseFilter *iface, FILTER_INFO *pInfo) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| return IBaseFilter_QueryFilterInfo(This->nullRenderer, pInfo); |
| } |
| |
| static HRESULT WINAPI SinkFilter_JoinFilterGraph(IBaseFilter *iface, IFilterGraph *pGraph, LPCWSTR pName) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| return IBaseFilter_JoinFilterGraph(This->nullRenderer, pGraph, pName); |
| } |
| |
| static HRESULT WINAPI SinkFilter_QueryVendorInfo(IBaseFilter *iface, LPWSTR *pVendorInfo) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IBaseFilter(iface); |
| return IBaseFilter_QueryVendorInfo(This->nullRenderer, pVendorInfo); |
| } |
| |
| static const IBaseFilterVtbl SinkFilterVtbl = { |
| SinkFilter_QueryInterface, |
| SinkFilter_AddRef, |
| SinkFilter_Release, |
| SinkFilter_GetClassID, |
| SinkFilter_Stop, |
| SinkFilter_Pause, |
| SinkFilter_Run, |
| SinkFilter_GetState, |
| SinkFilter_SetSyncSource, |
| SinkFilter_GetSyncSource, |
| SinkFilter_EnumPins, |
| SinkFilter_FindPin, |
| SinkFilter_QueryFilterInfo, |
| SinkFilter_JoinFilterGraph, |
| SinkFilter_QueryVendorInfo |
| }; |
| |
| static HRESULT WINAPI SinkEnumPins_QueryInterface(IEnumPins *iface, REFIID riid, void **ppv) |
| { |
| SinkEnumPins *This = impl_from_SinkFilter_IEnumPins(iface); |
| if(IsEqualIID(riid, &IID_IUnknown)) { |
| *ppv = &This->IEnumPins_iface; |
| } else if(IsEqualIID(riid, &IID_IEnumPins)) { |
| *ppv = &This->IEnumPins_iface; |
| } else { |
| trace("no interface for %s\n", wine_dbgstr_guid(riid)); |
| *ppv = NULL; |
| return E_NOINTERFACE; |
| } |
| IUnknown_AddRef((IUnknown*)*ppv); |
| return S_OK; |
| } |
| |
| static ULONG WINAPI SinkEnumPins_AddRef(IEnumPins *iface) |
| { |
| SinkEnumPins *This = impl_from_SinkFilter_IEnumPins(iface); |
| return InterlockedIncrement(&This->ref); |
| } |
| |
| static ULONG WINAPI SinkEnumPins_Release(IEnumPins *iface) |
| { |
| SinkEnumPins *This = impl_from_SinkFilter_IEnumPins(iface); |
| ULONG ref; |
| ref = InterlockedDecrement(&This->ref); |
| if (ref == 0) |
| { |
| IBaseFilter_Release(&This->filter->IBaseFilter_iface); |
| CoTaskMemFree(This); |
| } |
| return ref; |
| } |
| |
| static HRESULT WINAPI SinkEnumPins_Next(IEnumPins *iface, ULONG cPins, IPin **ppPins, ULONG *pcFetched) |
| { |
| SinkEnumPins *This = impl_from_SinkFilter_IEnumPins(iface); |
| if (!ppPins) |
| return E_POINTER; |
| if (cPins > 1 && !pcFetched) |
| return E_INVALIDARG; |
| if (pcFetched) |
| *pcFetched = 0; |
| if (cPins == 0) |
| return S_OK; |
| if (This->index == 0) { |
| ppPins[0] = &This->filter->IPin_iface; |
| IPin_AddRef(&This->filter->IPin_iface); |
| ++This->index; |
| if (pcFetched) |
| *pcFetched = 1; |
| return S_OK; |
| } |
| return S_FALSE; |
| } |
| |
| static HRESULT WINAPI SinkEnumPins_Skip(IEnumPins *iface, ULONG cPins) |
| { |
| SinkEnumPins *This = impl_from_SinkFilter_IEnumPins(iface); |
| if (This->index + cPins >= 1) |
| return S_FALSE; |
| This->index += cPins; |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SinkEnumPins_Reset(IEnumPins *iface) |
| { |
| SinkEnumPins *This = impl_from_SinkFilter_IEnumPins(iface); |
| This->index = 0; |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SinkEnumPins_Clone(IEnumPins *iface, IEnumPins **ppEnum) |
| { |
| SinkEnumPins *This = impl_from_SinkFilter_IEnumPins(iface); |
| SinkEnumPins *clone = create_SinkEnumPins(This->filter); |
| if (clone == NULL) |
| return E_OUTOFMEMORY; |
| clone->index = This->index; |
| return S_OK; |
| } |
| |
| static const IEnumPinsVtbl SinkEnumPinsVtbl = { |
| SinkEnumPins_QueryInterface, |
| SinkEnumPins_AddRef, |
| SinkEnumPins_Release, |
| SinkEnumPins_Next, |
| SinkEnumPins_Skip, |
| SinkEnumPins_Reset, |
| SinkEnumPins_Clone |
| }; |
| |
| static SinkEnumPins* create_SinkEnumPins(SinkFilter *filter) |
| { |
| SinkEnumPins *This; |
| This = CoTaskMemAlloc(sizeof(*This)); |
| if (This == NULL) { |
| return NULL; |
| } |
| This->IEnumPins_iface.lpVtbl = &SinkEnumPinsVtbl; |
| This->ref = 1; |
| This->index = 0; |
| This->filter = filter; |
| IBaseFilter_AddRef(&filter->IBaseFilter_iface); |
| return This; |
| } |
| |
| static HRESULT WINAPI SinkPin_QueryInterface(IPin *iface, REFIID riid, void **ppv) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| if(IsEqualIID(riid, &IID_IUnknown)) { |
| *ppv = &This->IPin_iface; |
| } else if(IsEqualIID(riid, &IID_IPin)) { |
| *ppv = &This->IPin_iface; |
| } else if(IsEqualIID(riid, &IID_IMemInputPin)) { |
| *ppv = &This->IMemInputPin_iface; |
| } else { |
| trace("no interface for %s\n", wine_dbgstr_guid(riid)); |
| *ppv = NULL; |
| return E_NOINTERFACE; |
| } |
| IUnknown_AddRef((IUnknown*)*ppv); |
| return S_OK; |
| } |
| |
| static ULONG WINAPI SinkPin_AddRef(IPin *iface) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IBaseFilter_AddRef(&This->IBaseFilter_iface); |
| } |
| |
| static ULONG WINAPI SinkPin_Release(IPin *iface) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IBaseFilter_Release(&This->IBaseFilter_iface); |
| } |
| |
| static HRESULT WINAPI SinkPin_Connect(IPin *iface, IPin *pReceivePin, const AM_MEDIA_TYPE *pmt) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IPin_Connect(This->nullRendererPin, pReceivePin, pmt); |
| } |
| |
| static HRESULT WINAPI SinkPin_ReceiveConnection(IPin *iface, IPin *connector, const AM_MEDIA_TYPE *pmt) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IPin_ReceiveConnection(This->nullRendererPin, connector, pmt); |
| } |
| |
| static HRESULT WINAPI SinkPin_Disconnect(IPin *iface) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IPin_Disconnect(This->nullRendererPin); |
| } |
| |
| static HRESULT WINAPI SinkPin_ConnectedTo(IPin *iface, IPin **pPin) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IPin_ConnectedTo(This->nullRendererPin, pPin); |
| } |
| |
| static HRESULT WINAPI SinkPin_ConnectionMediaType(IPin *iface, AM_MEDIA_TYPE *pmt) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IPin_ConnectionMediaType(This->nullRendererPin, pmt); |
| } |
| |
| static HRESULT WINAPI SinkPin_QueryPinInfo(IPin *iface, PIN_INFO *pInfo) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| HRESULT hr = IPin_QueryPinInfo(This->nullRendererPin, pInfo); |
| if (SUCCEEDED(hr)) { |
| IBaseFilter_Release(pInfo->pFilter); |
| pInfo->pFilter = &This->IBaseFilter_iface; |
| IBaseFilter_AddRef(&This->IBaseFilter_iface); |
| } |
| return hr; |
| } |
| |
| static HRESULT WINAPI SinkPin_QueryDirection(IPin *iface, PIN_DIRECTION *pPinDir) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IPin_QueryDirection(This->nullRendererPin, pPinDir); |
| } |
| |
| static HRESULT WINAPI SinkPin_QueryId(IPin *iface, LPWSTR *id) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IPin_QueryId(This->nullRendererPin, id); |
| } |
| |
| static HRESULT WINAPI SinkPin_QueryAccept(IPin *iface, const AM_MEDIA_TYPE *pmt) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IPin_QueryAccept(This->nullRendererPin, pmt); |
| } |
| |
| static HRESULT WINAPI SinkPin_EnumMediaTypes(IPin *iface, IEnumMediaTypes **ppEnum) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IPin_EnumMediaTypes(This->nullRendererPin, ppEnum); |
| } |
| |
| static HRESULT WINAPI SinkPin_QueryInternalConnections(IPin *iface, IPin **apPin, ULONG *nPin) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IPin_QueryInternalConnections(This->nullRendererPin, apPin, nPin); |
| } |
| |
| static HRESULT WINAPI SinkPin_EndOfStream(IPin *iface) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IPin_EndOfStream(This->nullRendererPin); |
| } |
| |
| static HRESULT WINAPI SinkPin_BeginFlush(IPin *iface) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IPin_BeginFlush(This->nullRendererPin); |
| } |
| |
| static HRESULT WINAPI SinkPin_EndFlush(IPin *iface) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IPin_EndFlush(This->nullRendererPin); |
| } |
| |
| static HRESULT WINAPI SinkPin_NewSegment(IPin *iface, REFERENCE_TIME tStart, |
| REFERENCE_TIME tStop, double dRate) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IPin(iface); |
| return IPin_NewSegment(This->nullRendererPin, tStart, tStop, dRate); |
| } |
| |
| static const IPinVtbl SinkPinVtbl = { |
| SinkPin_QueryInterface, |
| SinkPin_AddRef, |
| SinkPin_Release, |
| SinkPin_Connect, |
| SinkPin_ReceiveConnection, |
| SinkPin_Disconnect, |
| SinkPin_ConnectedTo, |
| SinkPin_ConnectionMediaType, |
| SinkPin_QueryPinInfo, |
| SinkPin_QueryDirection, |
| SinkPin_QueryId, |
| SinkPin_QueryAccept, |
| SinkPin_EnumMediaTypes, |
| SinkPin_QueryInternalConnections, |
| SinkPin_EndOfStream, |
| SinkPin_BeginFlush, |
| SinkPin_EndFlush, |
| SinkPin_NewSegment |
| }; |
| |
| static HRESULT WINAPI SinkMemInputPin_QueryInterface(IMemInputPin *iface, REFIID riid, void **ppv) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IMemInputPin(iface); |
| return IPin_QueryInterface(&This->IPin_iface, riid, ppv); |
| } |
| |
| static ULONG WINAPI SinkMemInputPin_AddRef(IMemInputPin *iface) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IMemInputPin(iface); |
| return IBaseFilter_AddRef(&This->IBaseFilter_iface); |
| } |
| |
| static ULONG WINAPI SinkMemInputPin_Release(IMemInputPin *iface) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IMemInputPin(iface); |
| return IBaseFilter_Release(&This->IBaseFilter_iface); |
| } |
| |
| static HRESULT WINAPI SinkMemInputPin_GetAllocator(IMemInputPin *iface, IMemAllocator **ppAllocator) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IMemInputPin(iface); |
| ok(0, "SmartTeeFilter never calls IMemInputPin_GetAllocator()\n"); |
| return IMemInputPin_GetAllocator(This->nullRendererMemInputPin, ppAllocator); |
| } |
| |
| static HRESULT WINAPI SinkMemInputPin_NotifyAllocator(IMemInputPin *iface, IMemAllocator *pAllocator, |
| BOOL bReadOnly) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IMemInputPin(iface); |
| This->allocator = pAllocator; |
| IMemAllocator_AddRef(This->allocator); |
| ok(bReadOnly, "bReadOnly isn't supposed to be FALSE\n"); |
| return IMemInputPin_NotifyAllocator(This->nullRendererMemInputPin, pAllocator, bReadOnly); |
| } |
| |
| static HRESULT WINAPI SinkMemInputPin_GetAllocatorRequirements(IMemInputPin *iface, |
| ALLOCATOR_PROPERTIES *pProps) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IMemInputPin(iface); |
| ok(0, "SmartTeeFilter never calls IMemInputPin_GetAllocatorRequirements()\n"); |
| return IMemInputPin_GetAllocatorRequirements(This->nullRendererMemInputPin, pProps); |
| } |
| |
| static HRESULT WINAPI SinkMemInputPin_Receive(IMemInputPin *iface, IMediaSample *pSample) |
| { |
| LONG samplesProcessed; |
| todo_wine ok(0, "SmartTeeFilter never calls IMemInputPin_Receive(), only IMemInputPin_ReceiveMultiple()\n"); |
| return IMemInputPin_ReceiveMultiple(iface, &pSample, 1, &samplesProcessed); |
| } |
| |
| static HRESULT WINAPI SinkMemInputPin_ReceiveMultiple(IMemInputPin *iface, IMediaSample **pSamples, |
| LONG nSamples, LONG *nSamplesProcessed) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IMemInputPin(iface); |
| IMediaSample *pSample; |
| REFERENCE_TIME startTime, endTime; |
| HRESULT hr; |
| ok(nSamples == 1, "expected 1 sample, got %d\n", nSamples); |
| pSample = pSamples[0]; |
| hr = IMediaSample_GetTime(pSample, &startTime, &endTime); |
| if (This->isCapture) |
| ok(SUCCEEDED(hr), "IMediaSample_GetTime() from Capture pin failed, hr=0x%08x\n", hr); |
| else |
| ok(hr == VFW_E_SAMPLE_TIME_NOT_SET, "IMediaSample_GetTime() from Preview pin returned hr=0x%08x\n", hr); |
| This->receiveThreadId = GetCurrentThreadId(); |
| SetEvent(event); |
| return IMemInputPin_ReceiveMultiple(This->nullRendererMemInputPin, pSamples, |
| nSamples, nSamplesProcessed); |
| } |
| |
| static HRESULT WINAPI SinkMemInputPin_ReceiveCanBlock(IMemInputPin *iface) |
| { |
| SinkFilter *This = impl_from_SinkFilter_IMemInputPin(iface); |
| return IMemInputPin_ReceiveCanBlock(This->nullRendererMemInputPin); |
| } |
| |
| static const IMemInputPinVtbl SinkMemInputPinVtbl = { |
| SinkMemInputPin_QueryInterface, |
| SinkMemInputPin_AddRef, |
| SinkMemInputPin_Release, |
| SinkMemInputPin_GetAllocator, |
| SinkMemInputPin_NotifyAllocator, |
| SinkMemInputPin_GetAllocatorRequirements, |
| SinkMemInputPin_Receive, |
| SinkMemInputPin_ReceiveMultiple, |
| SinkMemInputPin_ReceiveCanBlock |
| }; |
| |
| static SinkFilter* create_SinkFilter(BOOL isCapture) |
| { |
| SinkFilter *This = NULL; |
| HRESULT hr; |
| This = CoTaskMemAlloc(sizeof(*This)); |
| if (This) { |
| memset(This, 0, sizeof(*This)); |
| This->IBaseFilter_iface.lpVtbl = &SinkFilterVtbl; |
| This->ref = 1; |
| This->isCapture = isCapture; |
| This->IPin_iface.lpVtbl = &SinkPinVtbl; |
| This->IMemInputPin_iface.lpVtbl = &SinkMemInputPinVtbl; |
| hr = CoCreateInstance(&CLSID_NullRenderer, NULL, CLSCTX_INPROC_SERVER, |
| &IID_IBaseFilter, (LPVOID*)&This->nullRenderer); |
| if (SUCCEEDED(hr)) { |
| IEnumPins *enumPins = NULL; |
| hr = IBaseFilter_EnumPins(This->nullRenderer, &enumPins); |
| if (SUCCEEDED(hr)) { |
| hr = IEnumPins_Next(enumPins, 1, &This->nullRendererPin, NULL); |
| IEnumPins_Release(enumPins); |
| if (SUCCEEDED(hr)) { |
| hr = IPin_QueryInterface(This->nullRendererPin, &IID_IMemInputPin, |
| (LPVOID*)&This->nullRendererMemInputPin); |
| if (SUCCEEDED(hr)) |
| return This; |
| IPin_Release(This->nullRendererPin); |
| } |
| } |
| IBaseFilter_Release(This->nullRenderer); |
| } |
| CoTaskMemFree(This); |
| } |
| return NULL; |
| } |
| |
| typedef struct { |
| IBaseFilter IBaseFilter_iface; |
| LONG ref; |
| IPin IPin_iface; |
| IKsPropertySet IKsPropertySet_iface; |
| CRITICAL_SECTION cs; |
| FILTER_STATE state; |
| IReferenceClock *referenceClock; |
| FILTER_INFO filterInfo; |
| AM_MEDIA_TYPE mediaType; |
| VIDEOINFOHEADER videoInfo; |
| WAVEFORMATEX audioInfo; |
| IPin *connectedTo; |
| IMemInputPin *memInputPin; |
| IMemAllocator *allocator; |
| DWORD mediaThreadId; |
| } SourceFilter; |
| |
| typedef struct { |
| IEnumPins IEnumPins_iface; |
| LONG ref; |
| ULONG index; |
| SourceFilter *filter; |
| } SourceEnumPins; |
| |
| typedef struct { |
| IEnumMediaTypes IEnumMediaTypes_iface; |
| LONG ref; |
| ULONG index; |
| SourceFilter *filter; |
| } SourceEnumMediaTypes; |
| |
| static const WCHAR sourcePinName[] = {'C','a','p','t','u','r','e',0}; |
| |
| static SourceEnumPins* create_SourceEnumPins(SourceFilter *filter); |
| static SourceEnumMediaTypes* create_SourceEnumMediaTypes(SourceFilter *filter); |
| |
| static inline SourceFilter* impl_from_SourceFilter_IBaseFilter(IBaseFilter *iface) |
| { |
| return CONTAINING_RECORD(iface, SourceFilter, IBaseFilter_iface); |
| } |
| |
| static inline SourceFilter* impl_from_SourceFilter_IPin(IPin *iface) |
| { |
| return CONTAINING_RECORD(iface, SourceFilter, IPin_iface); |
| } |
| |
| static inline SourceFilter* impl_from_SourceFilter_IKsPropertySet(IKsPropertySet *iface) |
| { |
| return CONTAINING_RECORD(iface, SourceFilter, IKsPropertySet_iface); |
| } |
| |
| static inline SourceEnumPins* impl_from_SourceFilter_IEnumPins(IEnumPins *iface) |
| { |
| return CONTAINING_RECORD(iface, SourceEnumPins, IEnumPins_iface); |
| } |
| |
| static inline SourceEnumMediaTypes* impl_from_SourceFilter_IEnumMediaTypes(IEnumMediaTypes *iface) |
| { |
| return CONTAINING_RECORD(iface, SourceEnumMediaTypes, IEnumMediaTypes_iface); |
| } |
| |
| static HRESULT WINAPI SourceFilter_QueryInterface(IBaseFilter *iface, REFIID riid, void **ppv) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IBaseFilter(iface); |
| if(IsEqualIID(riid, &IID_IUnknown)) { |
| *ppv = &This->IBaseFilter_iface; |
| } else if(IsEqualIID(riid, &IID_IPersist)) { |
| *ppv = &This->IBaseFilter_iface; |
| } else if(IsEqualIID(riid, &IID_IMediaFilter)) { |
| *ppv = &This->IBaseFilter_iface; |
| } else if(IsEqualIID(riid, &IID_IBaseFilter)) { |
| *ppv = &This->IBaseFilter_iface; |
| } else { |
| trace("no interface for %s\n", wine_dbgstr_guid(riid)); |
| *ppv = NULL; |
| return E_NOINTERFACE; |
| } |
| IUnknown_AddRef((IUnknown*)*ppv); |
| return S_OK; |
| } |
| |
| static ULONG WINAPI SourceFilter_AddRef(IBaseFilter *iface) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IBaseFilter(iface); |
| return InterlockedIncrement(&This->ref); |
| } |
| |
| static ULONG WINAPI SourceFilter_Release(IBaseFilter *iface) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IBaseFilter(iface); |
| ULONG ref = InterlockedDecrement(&This->ref); |
| if(!ref) { |
| if (This->referenceClock) |
| IReferenceClock_Release(This->referenceClock); |
| if (This->connectedTo) |
| IPin_Disconnect(&This->IPin_iface); |
| DeleteCriticalSection(&This->cs); |
| CoTaskMemFree(This); |
| } |
| return ref; |
| } |
| |
| static HRESULT WINAPI SourceFilter_GetClassID(IBaseFilter *iface, CLSID *pClassID) |
| { |
| *pClassID = CLSID_VfwCapture; |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SourceFilter_Stop(IBaseFilter *iface) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IBaseFilter(iface); |
| EnterCriticalSection(&This->cs); |
| IMemAllocator_Decommit(This->allocator); |
| This->state = State_Stopped; |
| LeaveCriticalSection(&This->cs); |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SourceFilter_Pause(IBaseFilter *iface) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IBaseFilter(iface); |
| EnterCriticalSection(&This->cs); |
| This->state = State_Paused; |
| LeaveCriticalSection(&This->cs); |
| return S_OK; |
| } |
| |
| static DWORD WINAPI media_thread(LPVOID param) |
| { |
| SourceFilter *This = (SourceFilter*) param; |
| HRESULT hr; |
| IMediaSample *sample = NULL; |
| REFERENCE_TIME startTime; |
| REFERENCE_TIME endTime; |
| BYTE *buffer; |
| |
| hr = IMemAllocator_GetBuffer(This->allocator, &sample, NULL, NULL, 0); |
| ok(SUCCEEDED(hr), "IMemAllocator_GetBuffer() failed, hr=0x%08x\n", hr); |
| if (SUCCEEDED(hr)) { |
| startTime = 10; |
| endTime = 20; |
| hr = IMediaSample_SetTime(sample, &startTime, &endTime); |
| ok(SUCCEEDED(hr), "IMediaSample_SetTime() failed, hr=0x%08x\n", hr); |
| hr = IMediaSample_SetMediaType(sample, &This->mediaType); |
| ok(SUCCEEDED(hr), "IMediaSample_SetMediaType() failed, hr=0x%08x\n", hr); |
| |
| hr = IMediaSample_GetPointer(sample, &buffer); |
| ok(SUCCEEDED(hr), "IMediaSample_GetPointer() failed, hr=0x%08x\n", hr); |
| if (SUCCEEDED(hr)) { |
| /* 10 by 10 pixel 32 RGB */ |
| int i; |
| for (i = 0; i < 100; i++) |
| buffer[4*i] = i; |
| } |
| |
| hr = IMemInputPin_Receive(This->memInputPin, sample); |
| ok(SUCCEEDED(hr), "delivering sample to SmartTeeFilter's Input pin failed, hr=0x%08x\n", hr); |
| |
| IMediaSample_Release(sample); |
| } |
| return 0; |
| } |
| |
| static HRESULT WINAPI SourceFilter_Run(IBaseFilter *iface, REFERENCE_TIME tStart) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IBaseFilter(iface); |
| HRESULT hr; |
| EnterCriticalSection(&This->cs); |
| hr = IMemAllocator_Commit(This->allocator); |
| if (SUCCEEDED(hr)) { |
| HANDLE thread = CreateThread(NULL, 0, media_thread, This, 0, &This->mediaThreadId); |
| ok(thread != NULL, "couldn't create media thread, GetLastError()=%u\n", GetLastError()); |
| if (thread != NULL) { |
| CloseHandle(thread); |
| This->state = State_Running; |
| } else { |
| IMemAllocator_Decommit(This->allocator); |
| hr = E_FAIL; |
| } |
| } |
| LeaveCriticalSection(&This->cs); |
| return hr; |
| } |
| |
| static HRESULT WINAPI SourceFilter_GetState(IBaseFilter *iface, DWORD dwMilliSecsTimeout, FILTER_STATE *state) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IBaseFilter(iface); |
| EnterCriticalSection(&This->cs); |
| *state = This->state; |
| LeaveCriticalSection(&This->cs); |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SourceFilter_SetSyncSource(IBaseFilter *iface, IReferenceClock *pClock) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IBaseFilter(iface); |
| EnterCriticalSection(&This->cs); |
| if (This->referenceClock) |
| IReferenceClock_Release(This->referenceClock); |
| This->referenceClock = pClock; |
| if (This->referenceClock) |
| IReferenceClock_AddRef(This->referenceClock); |
| LeaveCriticalSection(&This->cs); |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SourceFilter_GetSyncSource(IBaseFilter *iface, IReferenceClock **ppClock) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IBaseFilter(iface); |
| EnterCriticalSection(&This->cs); |
| *ppClock = This->referenceClock; |
| if (This->referenceClock) |
| IReferenceClock_AddRef(This->referenceClock); |
| LeaveCriticalSection(&This->cs); |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SourceFilter_EnumPins(IBaseFilter *iface, IEnumPins **ppEnum) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IBaseFilter(iface); |
| SourceEnumPins *sourceEnumPins = create_SourceEnumPins(This); |
| if (sourceEnumPins) { |
| *ppEnum = &sourceEnumPins->IEnumPins_iface; |
| return S_OK; |
| } |
| else |
| return E_OUTOFMEMORY; |
| } |
| |
| static HRESULT WINAPI SourceFilter_FindPin(IBaseFilter *iface, LPCWSTR id, IPin **ppPin) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IBaseFilter(iface); |
| if (ppPin == NULL) |
| return E_POINTER; |
| *ppPin = NULL; |
| if (lstrcmpW(id, sourcePinName) == 0) { |
| *ppPin = &This->IPin_iface; |
| IPin_AddRef(&This->IPin_iface); |
| return S_OK; |
| } |
| return VFW_E_NOT_FOUND; |
| } |
| |
| static HRESULT WINAPI SourceFilter_QueryFilterInfo(IBaseFilter *iface, FILTER_INFO *pInfo) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IBaseFilter(iface); |
| if (!pInfo) |
| return E_POINTER; |
| EnterCriticalSection(&This->cs); |
| *pInfo = This->filterInfo; |
| if (This->filterInfo.pGraph) |
| IFilterGraph_AddRef(This->filterInfo.pGraph); |
| LeaveCriticalSection(&This->cs); |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SourceFilter_JoinFilterGraph(IBaseFilter *iface, IFilterGraph *pGraph, LPCWSTR pName) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IBaseFilter(iface); |
| EnterCriticalSection(&This->cs); |
| if (pName) |
| lstrcpyW(This->filterInfo.achName, pName); |
| else |
| This->filterInfo.achName[0] = 0; |
| This->filterInfo.pGraph = pGraph; |
| LeaveCriticalSection(&This->cs); |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SourceFilter_QueryVendorInfo(IBaseFilter *iface, LPWSTR *pVendorInfo) |
| { |
| return E_NOTIMPL; |
| } |
| |
| static const IBaseFilterVtbl SourceFilterVtbl = { |
| SourceFilter_QueryInterface, |
| SourceFilter_AddRef, |
| SourceFilter_Release, |
| SourceFilter_GetClassID, |
| SourceFilter_Stop, |
| SourceFilter_Pause, |
| SourceFilter_Run, |
| SourceFilter_GetState, |
| SourceFilter_SetSyncSource, |
| SourceFilter_GetSyncSource, |
| SourceFilter_EnumPins, |
| SourceFilter_FindPin, |
| SourceFilter_QueryFilterInfo, |
| SourceFilter_JoinFilterGraph, |
| SourceFilter_QueryVendorInfo |
| }; |
| |
| static HRESULT WINAPI SourceEnumPins_QueryInterface(IEnumPins *iface, REFIID riid, void **ppv) |
| { |
| SourceEnumPins *This = impl_from_SourceFilter_IEnumPins(iface); |
| if(IsEqualIID(riid, &IID_IUnknown)) { |
| *ppv = &This->IEnumPins_iface; |
| } else if(IsEqualIID(riid, &IID_IEnumPins)) { |
| *ppv = &This->IEnumPins_iface; |
| } else { |
| trace("no interface for %s\n", wine_dbgstr_guid(riid)); |
| *ppv = NULL; |
| return E_NOINTERFACE; |
| } |
| IUnknown_AddRef((IUnknown*)*ppv); |
| return S_OK; |
| } |
| |
| static ULONG WINAPI SourceEnumPins_AddRef(IEnumPins *iface) |
| { |
| SourceEnumPins *This = impl_from_SourceFilter_IEnumPins(iface); |
| return InterlockedIncrement(&This->ref); |
| } |
| |
| static ULONG WINAPI SourceEnumPins_Release(IEnumPins *iface) |
| { |
| SourceEnumPins *This = impl_from_SourceFilter_IEnumPins(iface); |
| ULONG ref; |
| ref = InterlockedDecrement(&This->ref); |
| if (ref == 0) |
| { |
| IBaseFilter_Release(&This->filter->IBaseFilter_iface); |
| CoTaskMemFree(This); |
| } |
| return ref; |
| } |
| |
| static HRESULT WINAPI SourceEnumPins_Next(IEnumPins *iface, ULONG cPins, IPin **ppPins, ULONG *pcFetched) |
| { |
| SourceEnumPins *This = impl_from_SourceFilter_IEnumPins(iface); |
| if (!ppPins) |
| return E_POINTER; |
| if (cPins > 1 && !pcFetched) |
| return E_INVALIDARG; |
| if (pcFetched) |
| *pcFetched = 0; |
| if (cPins == 0) |
| return S_OK; |
| if (This->index == 0) { |
| ppPins[0] = &This->filter->IPin_iface; |
| IPin_AddRef(&This->filter->IPin_iface); |
| ++This->index; |
| if (pcFetched) |
| *pcFetched = 1; |
| return S_OK; |
| } |
| return S_FALSE; |
| } |
| |
| static HRESULT WINAPI SourceEnumPins_Skip(IEnumPins *iface, ULONG cPins) |
| { |
| SourceEnumPins *This = impl_from_SourceFilter_IEnumPins(iface); |
| if (This->index + cPins >= 1) |
| return S_FALSE; |
| This->index += cPins; |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SourceEnumPins_Reset(IEnumPins *iface) |
| { |
| SourceEnumPins *This = impl_from_SourceFilter_IEnumPins(iface); |
| This->index = 0; |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SourceEnumPins_Clone(IEnumPins *iface, IEnumPins **ppEnum) |
| { |
| SourceEnumPins *This = impl_from_SourceFilter_IEnumPins(iface); |
| SourceEnumPins *clone = create_SourceEnumPins(This->filter); |
| if (clone == NULL) |
| return E_OUTOFMEMORY; |
| clone->index = This->index; |
| return S_OK; |
| } |
| |
| static const IEnumPinsVtbl SourceEnumPinsVtbl = { |
| SourceEnumPins_QueryInterface, |
| SourceEnumPins_AddRef, |
| SourceEnumPins_Release, |
| SourceEnumPins_Next, |
| SourceEnumPins_Skip, |
| SourceEnumPins_Reset, |
| SourceEnumPins_Clone |
| }; |
| |
| static SourceEnumPins* create_SourceEnumPins(SourceFilter *filter) |
| { |
| SourceEnumPins *This; |
| This = CoTaskMemAlloc(sizeof(*This)); |
| if (This == NULL) { |
| return NULL; |
| } |
| This->IEnumPins_iface.lpVtbl = &SourceEnumPinsVtbl; |
| This->ref = 1; |
| This->index = 0; |
| This->filter = filter; |
| IBaseFilter_AddRef(&filter->IBaseFilter_iface); |
| return This; |
| } |
| |
| static HRESULT WINAPI SourceEnumMediaTypes_QueryInterface(IEnumMediaTypes *iface, REFIID riid, void **ppv) |
| { |
| SourceEnumMediaTypes *This = impl_from_SourceFilter_IEnumMediaTypes(iface); |
| if(IsEqualIID(riid, &IID_IUnknown)) { |
| *ppv = &This->IEnumMediaTypes_iface; |
| } else if(IsEqualIID(riid, &IID_IEnumMediaTypes)) { |
| *ppv = &This->IEnumMediaTypes_iface; |
| } else { |
| trace("no interface for %s\n", wine_dbgstr_guid(riid)); |
| *ppv = NULL; |
| return E_NOINTERFACE; |
| } |
| IUnknown_AddRef((IUnknown*)*ppv); |
| return S_OK; |
| } |
| |
| static ULONG WINAPI SourceEnumMediaTypes_AddRef(IEnumMediaTypes *iface) |
| { |
| SourceEnumMediaTypes *This = impl_from_SourceFilter_IEnumMediaTypes(iface); |
| return InterlockedIncrement(&This->ref); |
| } |
| |
| static ULONG WINAPI SourceEnumMediaTypes_Release(IEnumMediaTypes *iface) |
| { |
| SourceEnumMediaTypes *This = impl_from_SourceFilter_IEnumMediaTypes(iface); |
| ULONG ref; |
| ref = InterlockedDecrement(&This->ref); |
| if (ref == 0) |
| { |
| IBaseFilter_Release(&This->filter->IBaseFilter_iface); |
| CoTaskMemFree(This); |
| } |
| return ref; |
| } |
| |
| static HRESULT WINAPI SourceEnumMediaTypes_Next(IEnumMediaTypes *iface, ULONG cMediaTypes, AM_MEDIA_TYPE **ppMediaTypes, ULONG *pcFetched) |
| { |
| SourceEnumMediaTypes *This = impl_from_SourceFilter_IEnumMediaTypes(iface); |
| if (!ppMediaTypes) |
| return E_POINTER; |
| if (cMediaTypes > 1 && !pcFetched) |
| return E_INVALIDARG; |
| if (pcFetched) |
| *pcFetched = 0; |
| if (cMediaTypes == 0) |
| return S_OK; |
| if (This->index == 0) { |
| ppMediaTypes[0] = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE)); |
| if (ppMediaTypes[0]) { |
| *ppMediaTypes[0] = This->filter->mediaType; |
| ppMediaTypes[0]->pbFormat = CoTaskMemAlloc(This->filter->mediaType.cbFormat); |
| if (ppMediaTypes[0]->pbFormat) { |
| memcpy(ppMediaTypes[0]->pbFormat, This->filter->mediaType.pbFormat, This->filter->mediaType.cbFormat); |
| ++This->index; |
| if (pcFetched) |
| *pcFetched = 1; |
| return S_OK; |
| } |
| CoTaskMemFree(ppMediaTypes[0]); |
| } |
| return E_OUTOFMEMORY; |
| } |
| return S_FALSE; |
| } |
| |
| static HRESULT WINAPI SourceEnumMediaTypes_Skip(IEnumMediaTypes *iface, ULONG cMediaTypes) |
| { |
| SourceEnumMediaTypes *This = impl_from_SourceFilter_IEnumMediaTypes(iface); |
| This->index += cMediaTypes; |
| if (This->index >= 1) |
| return S_FALSE; |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SourceEnumMediaTypes_Reset(IEnumMediaTypes *iface) |
| { |
| SourceEnumMediaTypes *This = impl_from_SourceFilter_IEnumMediaTypes(iface); |
| This->index = 0; |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SourceEnumMediaTypes_Clone(IEnumMediaTypes *iface, IEnumMediaTypes **ppEnum) |
| { |
| SourceEnumMediaTypes *This = impl_from_SourceFilter_IEnumMediaTypes(iface); |
| SourceEnumMediaTypes *clone = create_SourceEnumMediaTypes(This->filter); |
| if (clone == NULL) |
| return E_OUTOFMEMORY; |
| clone->index = This->index; |
| return S_OK; |
| } |
| |
| static const IEnumMediaTypesVtbl SourceEnumMediaTypesVtbl = { |
| SourceEnumMediaTypes_QueryInterface, |
| SourceEnumMediaTypes_AddRef, |
| SourceEnumMediaTypes_Release, |
| SourceEnumMediaTypes_Next, |
| SourceEnumMediaTypes_Skip, |
| SourceEnumMediaTypes_Reset, |
| SourceEnumMediaTypes_Clone |
| }; |
| |
| static SourceEnumMediaTypes* create_SourceEnumMediaTypes(SourceFilter *filter) |
| { |
| SourceEnumMediaTypes *This; |
| This = CoTaskMemAlloc(sizeof(*This)); |
| if (This == NULL) { |
| return NULL; |
| } |
| This->IEnumMediaTypes_iface.lpVtbl = &SourceEnumMediaTypesVtbl; |
| This->ref = 1; |
| This->index = 0; |
| This->filter = filter; |
| IBaseFilter_AddRef(&filter->IBaseFilter_iface); |
| return This; |
| } |
| |
| static HRESULT WINAPI SourcePin_QueryInterface(IPin *iface, REFIID riid, void **ppv) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IPin(iface); |
| if(IsEqualIID(riid, &IID_IUnknown)) { |
| *ppv = &This->IPin_iface; |
| } else if(IsEqualIID(riid, &IID_IPin)) { |
| *ppv = &This->IPin_iface; |
| } else if(IsEqualIID(riid, &IID_IKsPropertySet)) { |
| *ppv = &This->IKsPropertySet_iface; |
| } else { |
| trace("no interface for %s\n", wine_dbgstr_guid(riid)); |
| *ppv = NULL; |
| return E_NOINTERFACE; |
| } |
| IUnknown_AddRef((IUnknown*)*ppv); |
| return S_OK; |
| } |
| |
| static ULONG WINAPI SourcePin_AddRef(IPin *iface) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IPin(iface); |
| return IBaseFilter_AddRef(&This->IBaseFilter_iface); |
| } |
| |
| static ULONG WINAPI SourcePin_Release(IPin *iface) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IPin(iface); |
| return IBaseFilter_Release(&This->IBaseFilter_iface); |
| } |
| |
| static HRESULT WINAPI SourcePin_Connect(IPin *iface, IPin *pReceivePin, const AM_MEDIA_TYPE *pmt) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IPin(iface); |
| HRESULT hr; |
| |
| if (pmt && !IsEqualGUID(&pmt->majortype, &GUID_NULL) && !IsEqualGUID(&pmt->majortype, &MEDIATYPE_Video)) |
| return VFW_E_TYPE_NOT_ACCEPTED; |
| if (pmt && !IsEqualGUID(&pmt->subtype, &GUID_NULL) && !IsEqualGUID(&pmt->subtype, &MEDIASUBTYPE_RGB32)) |
| return VFW_E_TYPE_NOT_ACCEPTED; |
| if (pmt && !IsEqualGUID(&pmt->formattype, &GUID_NULL)) |
| return VFW_E_TYPE_NOT_ACCEPTED; |
| hr = IPin_ReceiveConnection(pReceivePin, &This->IPin_iface, &This->mediaType); |
| ok(SUCCEEDED(hr), "SmartTeeFilter's Input pin's IPin_ReceiveConnection() failed with 0x%08x\n", hr); |
| if (SUCCEEDED(hr)) { |
| EnterCriticalSection(&This->cs); |
| hr = IPin_QueryInterface(pReceivePin, &IID_IMemInputPin, (void**)&This->memInputPin); |
| if (SUCCEEDED(hr)) { |
| hr = IMemInputPin_GetAllocator(This->memInputPin, &This->allocator); |
| ok(SUCCEEDED(hr), "couldn't get allocator from SmartTeeFilter, hr=0x%08x\n", hr); |
| if (SUCCEEDED(hr)) { |
| ALLOCATOR_PROPERTIES requested, actual; |
| ZeroMemory(&requested, sizeof(ALLOCATOR_PROPERTIES)); |
| IMemInputPin_GetAllocatorRequirements(This->memInputPin, &requested); |
| if (requested.cBuffers < 3) requested.cBuffers = 3; |
| if (requested.cbBuffer < 4096) requested.cbBuffer = 4096; |
| if (requested.cbAlign < 1) requested.cbAlign = 1; |
| if (requested.cbPrefix < 0) requested.cbPrefix = 0; |
| hr = IMemAllocator_SetProperties(This->allocator, &requested, &actual); |
| if (SUCCEEDED(hr)) { |
| hr = IMemInputPin_NotifyAllocator(This->memInputPin, This->allocator, FALSE); |
| if (SUCCEEDED(hr)) { |
| This->connectedTo = pReceivePin; |
| IPin_AddRef(pReceivePin); |
| } |
| } |
| if (FAILED(hr)) { |
| IMemAllocator_Release(This->allocator); |
| This->allocator = NULL; |
| } |
| } |
| if (FAILED(hr)) { |
| IMemInputPin_Release(This->memInputPin); |
| This->memInputPin = NULL; |
| } |
| } |
| LeaveCriticalSection(&This->cs); |
| |
| if (FAILED(hr)) |
| IPin_Disconnect(pReceivePin); |
| } |
| return hr; |
| } |
| |
| static HRESULT WINAPI SourcePin_ReceiveConnection(IPin *iface, IPin *connector, const AM_MEDIA_TYPE *pmt) |
| { |
| return E_UNEXPECTED; |
| } |
| |
| static HRESULT WINAPI SourcePin_Disconnect(IPin *iface) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IPin(iface); |
| HRESULT hr; |
| EnterCriticalSection(&This->cs); |
| if (This->connectedTo) { |
| if (This->state == State_Stopped) { |
| IMemAllocator_Release(This->allocator); |
| This->allocator = NULL; |
| IMemInputPin_Release(This->memInputPin); |
| This->memInputPin = NULL; |
| IPin_Release(This->connectedTo); |
| This->connectedTo = NULL; |
| hr = S_OK; |
| } |
| else |
| hr = VFW_E_NOT_STOPPED; |
| } else |
| hr = S_FALSE; |
| LeaveCriticalSection(&This->cs); |
| return hr; |
| } |
| |
| static HRESULT WINAPI SourcePin_ConnectedTo(IPin *iface, IPin **pPin) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IPin(iface); |
| HRESULT hr; |
| if (!pPin) |
| return E_POINTER; |
| EnterCriticalSection(&This->cs); |
| if (This->connectedTo) { |
| *pPin = This->connectedTo; |
| IPin_AddRef(This->connectedTo); |
| hr = S_OK; |
| } else |
| hr = VFW_E_NOT_CONNECTED; |
| LeaveCriticalSection(&This->cs); |
| return hr; |
| } |
| |
| static HRESULT WINAPI SourcePin_ConnectionMediaType(IPin *iface, AM_MEDIA_TYPE *pmt) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IPin(iface); |
| HRESULT hr; |
| if (!pmt) |
| return E_POINTER; |
| EnterCriticalSection(&This->cs); |
| if (This->connectedTo) { |
| *pmt = This->mediaType; |
| pmt->pbFormat = CoTaskMemAlloc(sizeof(This->videoInfo)); |
| if (pmt->pbFormat) { |
| memcpy(pmt->pbFormat, &This->videoInfo, sizeof(This->videoInfo)); |
| hr = S_OK; |
| } else { |
| memset(pmt, 0, sizeof(*pmt)); |
| hr = E_OUTOFMEMORY; |
| } |
| } else { |
| memset(pmt, 0, sizeof(*pmt)); |
| hr = VFW_E_NOT_CONNECTED; |
| } |
| LeaveCriticalSection(&This->cs); |
| return hr; |
| } |
| |
| static HRESULT WINAPI SourcePin_QueryPinInfo(IPin *iface, PIN_INFO *pInfo) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IPin(iface); |
| if (!pInfo) |
| return E_POINTER; |
| lstrcpyW(pInfo->achName, sourcePinName); |
| pInfo->dir = PINDIR_OUTPUT; |
| pInfo->pFilter = &This->IBaseFilter_iface; |
| IBaseFilter_AddRef(&This->IBaseFilter_iface); |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SourcePin_QueryDirection(IPin *iface, PIN_DIRECTION *pPinDir) |
| { |
| if (!pPinDir) |
| return E_POINTER; |
| *pPinDir = PINDIR_OUTPUT; |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SourcePin_QueryId(IPin *iface, LPWSTR *id) |
| { |
| if (!id) |
| return E_POINTER; |
| *id = CoTaskMemAlloc((lstrlenW(sourcePinName) + 1)*sizeof(WCHAR)); |
| if (*id) { |
| lstrcpyW(*id, sourcePinName); |
| return S_OK; |
| } |
| return E_OUTOFMEMORY; |
| } |
| |
| static HRESULT WINAPI SourcePin_QueryAccept(IPin *iface, const AM_MEDIA_TYPE *pmt) |
| { |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI SourcePin_EnumMediaTypes(IPin *iface, IEnumMediaTypes **ppEnum) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IPin(iface); |
| SourceEnumMediaTypes *sourceEnumMediaTypes = create_SourceEnumMediaTypes(This); |
| if (sourceEnumMediaTypes) { |
| *ppEnum = &sourceEnumMediaTypes->IEnumMediaTypes_iface; |
| return S_OK; |
| } |
| else |
| return E_OUTOFMEMORY; |
| } |
| |
| static HRESULT WINAPI SourcePin_QueryInternalConnections(IPin *iface, IPin **apPin, ULONG *nPin) |
| { |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI SourcePin_EndOfStream(IPin *iface) |
| { |
| return E_UNEXPECTED; |
| } |
| |
| static HRESULT WINAPI SourcePin_BeginFlush(IPin *iface) |
| { |
| return E_UNEXPECTED; |
| } |
| |
| static HRESULT WINAPI SourcePin_EndFlush(IPin *iface) |
| { |
| return E_UNEXPECTED; |
| } |
| |
| static HRESULT WINAPI SourcePin_NewSegment(IPin *iface, REFERENCE_TIME tStart, |
| REFERENCE_TIME tStop, double dRate) |
| { |
| return S_OK; |
| } |
| |
| static const IPinVtbl SourcePinVtbl = { |
| SourcePin_QueryInterface, |
| SourcePin_AddRef, |
| SourcePin_Release, |
| SourcePin_Connect, |
| SourcePin_ReceiveConnection, |
| SourcePin_Disconnect, |
| SourcePin_ConnectedTo, |
| SourcePin_ConnectionMediaType, |
| SourcePin_QueryPinInfo, |
| SourcePin_QueryDirection, |
| SourcePin_QueryId, |
| SourcePin_QueryAccept, |
| SourcePin_EnumMediaTypes, |
| SourcePin_QueryInternalConnections, |
| SourcePin_EndOfStream, |
| SourcePin_BeginFlush, |
| SourcePin_EndFlush, |
| SourcePin_NewSegment |
| }; |
| |
| static HRESULT WINAPI SourceKSP_QueryInterface(IKsPropertySet *iface, REFIID riid, LPVOID *ppv) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IKsPropertySet(iface); |
| return IPin_QueryInterface(&This->IPin_iface, riid, ppv); |
| } |
| |
| static ULONG WINAPI SourceKSP_AddRef(IKsPropertySet *iface) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IKsPropertySet(iface); |
| return IBaseFilter_AddRef(&This->IBaseFilter_iface); |
| } |
| |
| static ULONG WINAPI SourceKSP_Release(IKsPropertySet *iface) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IKsPropertySet(iface); |
| return IBaseFilter_Release(&This->IBaseFilter_iface); |
| } |
| |
| static HRESULT WINAPI SourceKSP_Set(IKsPropertySet *iface, REFGUID guidPropSet, DWORD dwPropID, |
| LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IKsPropertySet(iface); |
| trace("(%p)->(%s, %u, %p, %u, %p, %u): stub\n", This, wine_dbgstr_guid(guidPropSet), |
| dwPropID, pInstanceData, cbInstanceData, pPropData, cbPropData); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI SourceKSP_Get(IKsPropertySet *iface, REFGUID guidPropSet, DWORD dwPropID, |
| LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, |
| DWORD cbPropData, DWORD *pcbReturned) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IKsPropertySet(iface); |
| trace("(%p)->(%s, %u, %p, %u, %p, %u, %p)\n", This, wine_dbgstr_guid(guidPropSet), |
| dwPropID, pInstanceData, cbInstanceData, pPropData, cbPropData, pcbReturned); |
| if (IsEqualIID(guidPropSet, &ROPSETID_Pin)) { |
| if (pcbReturned) |
| *pcbReturned = sizeof(GUID); |
| if (pPropData) { |
| LPGUID guid = pPropData; |
| if (cbPropData >= sizeof(GUID)) |
| *guid = PIN_CATEGORY_CAPTURE; |
| } else { |
| if (!pcbReturned) |
| return E_POINTER; |
| } |
| return S_OK; |
| } |
| return E_PROP_SET_UNSUPPORTED; |
| } |
| |
| static HRESULT WINAPI SourceKSP_QuerySupported(IKsPropertySet *iface, REFGUID guidPropSet, |
| DWORD dwPropID, DWORD *pTypeSupport) |
| { |
| SourceFilter *This = impl_from_SourceFilter_IKsPropertySet(iface); |
| trace("(%p)->(%s, %u, %p): stub\n", This, wine_dbgstr_guid(guidPropSet), |
| dwPropID, pTypeSupport); |
| return E_NOTIMPL; |
| } |
| |
| static const IKsPropertySetVtbl SourceKSPVtbl = |
| { |
| SourceKSP_QueryInterface, |
| SourceKSP_AddRef, |
| SourceKSP_Release, |
| SourceKSP_Set, |
| SourceKSP_Get, |
| SourceKSP_QuerySupported |
| }; |
| |
| static SourceFilter* create_SourceFilter(void) |
| { |
| SourceFilter *This = NULL; |
| This = CoTaskMemAlloc(sizeof(*This)); |
| if (This) { |
| memset(This, 0, sizeof(*This)); |
| This->IBaseFilter_iface.lpVtbl = &SourceFilterVtbl; |
| This->ref = 1; |
| This->IPin_iface.lpVtbl = &SourcePinVtbl; |
| This->IKsPropertySet_iface.lpVtbl = &SourceKSPVtbl; |
| InitializeCriticalSection(&This->cs); |
| return This; |
| } |
| return NULL; |
| } |
| |
| static SourceFilter* create_video_SourceFilter(void) |
| { |
| SourceFilter *This = create_SourceFilter(); |
| if (!This) |
| return NULL; |
| This->mediaType.majortype = MEDIATYPE_Video; |
| This->mediaType.subtype = MEDIASUBTYPE_RGB32; |
| This->mediaType.bFixedSizeSamples = FALSE; |
| This->mediaType.bTemporalCompression = FALSE; |
| This->mediaType.lSampleSize = 0; |
| This->mediaType.formattype = FORMAT_VideoInfo; |
| This->mediaType.pUnk = NULL; |
| This->mediaType.cbFormat = sizeof(VIDEOINFOHEADER); |
| This->mediaType.pbFormat = (BYTE*) &This->videoInfo; |
| This->videoInfo.dwBitRate = 1000000; |
| This->videoInfo.dwBitErrorRate = 0; |
| This->videoInfo.AvgTimePerFrame = 400000; |
| This->videoInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); |
| This->videoInfo.bmiHeader.biWidth = 10; |
| This->videoInfo.bmiHeader.biHeight = 10; |
| This->videoInfo.bmiHeader.biPlanes = 1; |
| This->videoInfo.bmiHeader.biBitCount = 32; |
| This->videoInfo.bmiHeader.biCompression = BI_RGB; |
| This->videoInfo.bmiHeader.biSizeImage = 0; |
| This->videoInfo.bmiHeader.biXPelsPerMeter = 96; |
| This->videoInfo.bmiHeader.biYPelsPerMeter = 96; |
| This->videoInfo.bmiHeader.biClrUsed = 0; |
| This->videoInfo.bmiHeader.biClrImportant = 0; |
| return This; |
| } |
| |
| static SourceFilter* create_audio_SourceFilter(void) |
| { |
| SourceFilter *This = create_SourceFilter(); |
| if (!This) |
| return NULL; |
| This->mediaType.majortype = MEDIATYPE_Audio; |
| This->mediaType.subtype = MEDIASUBTYPE_PCM; |
| This->mediaType.bFixedSizeSamples = FALSE; |
| This->mediaType.bTemporalCompression = FALSE; |
| This->mediaType.lSampleSize = 0; |
| This->mediaType.formattype = FORMAT_WaveFormatEx; |
| This->mediaType.pUnk = NULL; |
| This->mediaType.cbFormat = sizeof(WAVEFORMATEX); |
| This->mediaType.pbFormat = (BYTE*) &This->audioInfo; |
| This->audioInfo.wFormatTag = WAVE_FORMAT_PCM; |
| This->audioInfo.nChannels = 1; |
| This->audioInfo.nSamplesPerSec = 8000; |
| This->audioInfo.nAvgBytesPerSec = 16000; |
| This->audioInfo.nBlockAlign = 2; |
| This->audioInfo.wBitsPerSample = 16; |
| This->audioInfo.cbSize = 0; |
| return This; |
| } |
| |
| static BOOL has_interface(IUnknown *unknown, REFIID uuid) |
| { |
| HRESULT hr; |
| IUnknown *iface = NULL; |
| |
| hr = IUnknown_QueryInterface(unknown, uuid, (void**)&iface); |
| if (SUCCEEDED(hr)) |
| { |
| IUnknown_Release(iface); |
| return TRUE; |
| } |
| else |
| return FALSE; |
| } |
| |
| static void test_smart_tee_filter_in_graph(IBaseFilter *smartTeeFilter, IPin *inputPin, |
| IPin *capturePin, IPin *previewPin) |
| { |
| HRESULT hr; |
| IGraphBuilder *graphBuilder = NULL; |
| IMediaControl *mediaControl = NULL; |
| SourceFilter *sourceFilter = NULL; |
| SinkFilter *captureSinkFilter = NULL; |
| SinkFilter *previewSinkFilter = NULL; |
| DWORD endTime; |
| |
| hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, &IID_IGraphBuilder, |
| (LPVOID*)&graphBuilder); |
| ok(SUCCEEDED(hr), "couldn't create graph builder, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| hr = IGraphBuilder_AddFilter(graphBuilder, smartTeeFilter, NULL); |
| ok(SUCCEEDED(hr), "couldn't add smart tee filter to graph, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| captureSinkFilter = create_SinkFilter(TRUE); |
| if (captureSinkFilter == NULL) { |
| skip("couldn't create capture sink filter\n"); |
| goto end; |
| } |
| hr = IGraphBuilder_AddFilter(graphBuilder, &captureSinkFilter->IBaseFilter_iface, NULL); |
| if (FAILED(hr)) { |
| skip("couldn't add capture sink filter to graph, hr=0x%08x\n", hr); |
| goto end; |
| } |
| |
| previewSinkFilter = create_SinkFilter(FALSE); |
| if (previewSinkFilter == NULL) { |
| skip("couldn't create preview sink filter\n"); |
| goto end; |
| } |
| hr = IGraphBuilder_AddFilter(graphBuilder, &previewSinkFilter->IBaseFilter_iface, NULL); |
| if (FAILED(hr)) { |
| skip("couldn't add preview sink filter to graph, hr=0x%08x\n", hr); |
| goto end; |
| } |
| |
| hr = IGraphBuilder_Connect(graphBuilder, capturePin, &captureSinkFilter->IPin_iface); |
| ok(hr == VFW_E_NOT_CONNECTED, "connecting Capture pin without first connecting Input pin returned 0x%08x\n", hr); |
| hr = IGraphBuilder_Connect(graphBuilder, previewPin, &previewSinkFilter->IPin_iface); |
| ok(hr == VFW_E_NOT_CONNECTED, "connecting Preview pin without first connecting Input pin returned 0x%08x\n", hr); |
| |
| sourceFilter = create_video_SourceFilter(); |
| if (sourceFilter == NULL) { |
| skip("couldn't create source filter\n"); |
| goto end; |
| } |
| hr = IGraphBuilder_AddFilter(graphBuilder, &sourceFilter->IBaseFilter_iface, NULL); |
| ok(SUCCEEDED(hr), "couldn't add source filter to graph, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| hr = IGraphBuilder_Connect(graphBuilder, &sourceFilter->IPin_iface, inputPin); |
| ok(SUCCEEDED(hr), "couldn't connect source filter to Input pin, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| hr = IGraphBuilder_Connect(graphBuilder, capturePin, &captureSinkFilter->IPin_iface); |
| ok(SUCCEEDED(hr), "couldn't connect Capture pin to sink, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| hr = IGraphBuilder_Connect(graphBuilder, previewPin, &previewSinkFilter->IPin_iface); |
| ok(SUCCEEDED(hr), "couldn't connect Preview pin to sink, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| ok(sourceFilter->allocator == captureSinkFilter->allocator, "input and capture allocators don't match\n"); |
| ok(sourceFilter->allocator == previewSinkFilter->allocator, "input and preview allocators don't match\n"); |
| |
| hr = IGraphBuilder_QueryInterface(graphBuilder, &IID_IMediaControl, (void**)&mediaControl); |
| ok(SUCCEEDED(hr), "couldn't get IMediaControl interface from IGraphBuilder, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| hr = IMediaControl_Run(mediaControl); |
| ok(SUCCEEDED(hr), "IMediaControl_Run() failed, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| endTime = GetTickCount() + 5000; |
| while (previewSinkFilter->receiveThreadId == 0 || captureSinkFilter->receiveThreadId == 0) { |
| DWORD now = GetTickCount(); |
| if (now < endTime) |
| WaitForSingleObject(event, endTime - now); |
| else |
| break; |
| } |
| if (previewSinkFilter->receiveThreadId != 0 && captureSinkFilter->receiveThreadId != 0) { |
| todo_wine ok(sourceFilter->mediaThreadId != captureSinkFilter->receiveThreadId, |
| "sending thread should != capture receiving thread\n"); |
| todo_wine ok(sourceFilter->mediaThreadId != previewSinkFilter->receiveThreadId, |
| "sending thread should != preview receiving thread\n"); |
| todo_wine ok(captureSinkFilter->receiveThreadId != previewSinkFilter->receiveThreadId, |
| "capture receiving thread should != preview receiving thread\n"); |
| } else { |
| ok(0, "timeout: threads did not receive sample in time\n"); |
| } |
| |
| IMediaControl_Stop(mediaControl); |
| |
| end: |
| if (mediaControl) |
| IMediaControl_Release(mediaControl); |
| if (graphBuilder) |
| IGraphBuilder_Release(graphBuilder); |
| if (sourceFilter) |
| IBaseFilter_Release(&sourceFilter->IBaseFilter_iface); |
| if (captureSinkFilter) |
| IBaseFilter_Release(&captureSinkFilter->IBaseFilter_iface); |
| if (previewSinkFilter) |
| IBaseFilter_Release(&previewSinkFilter->IBaseFilter_iface); |
| } |
| |
| static void test_smart_tee_filter(void) |
| { |
| HRESULT hr; |
| IBaseFilter *smartTeeFilter = NULL; |
| IEnumPins *enumPins = NULL; |
| IPin *pin; |
| IPin *inputPin = NULL; |
| IPin *capturePin = NULL; |
| IPin *previewPin = NULL; |
| FILTER_INFO filterInfo; |
| int pinNumber = 0; |
| IMemInputPin *memInputPin = NULL; |
| IEnumMediaTypes *enumMediaTypes = NULL; |
| ULONG nPin = 0; |
| |
| hr = CoCreateInstance(&CLSID_SmartTee, NULL, CLSCTX_INPROC_SERVER, |
| &IID_IBaseFilter, (void**)&smartTeeFilter); |
| ok(SUCCEEDED(hr), "couldn't create smart tee filter, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| hr = IBaseFilter_QueryFilterInfo(smartTeeFilter, &filterInfo); |
| ok(SUCCEEDED(hr), "QueryFilterInfo failed, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| ok(lstrlenW(filterInfo.achName) == 0, |
| "filter's name is meant to be empty but it's %s\n", wine_dbgstr_w(filterInfo.achName)); |
| |
| hr = IBaseFilter_EnumPins(smartTeeFilter, &enumPins); |
| ok(SUCCEEDED(hr), "cannot enum filter pins, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| while (IEnumPins_Next(enumPins, 1, &pin, NULL) == S_OK) |
| { |
| LPWSTR id = NULL; |
| PIN_INFO pinInfo; |
| memset(&pinInfo, 0, sizeof(pinInfo)); |
| hr = IPin_QueryPinInfo(pin, &pinInfo); |
| ok(SUCCEEDED(hr), "QueryPinInfo failed, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto endwhile; |
| |
| ok(pinInfo.pFilter == smartTeeFilter, "pin's filter isn't the filter owning the pin\n"); |
| if (pinNumber == 0) |
| { |
| static const WCHAR wszInput[] = {'I','n','p','u','t',0}; |
| ok(pinInfo.dir == PINDIR_INPUT, "pin 0 isn't an input pin\n"); |
| ok(!lstrcmpW(pinInfo.achName, wszInput), "pin 0 is called %s, not 'Input'\n", wine_dbgstr_w(pinInfo.achName)); |
| hr = IPin_QueryId(pin, &id); |
| ok(SUCCEEDED(hr), "IPin_QueryId() failed with 0x%08x\n", hr); |
| ok(!lstrcmpW(id, wszInput), "pin 0's id is %s, not 'Input'\n", wine_dbgstr_w(id)); |
| inputPin = pin; |
| IPin_AddRef(inputPin); |
| } |
| else if (pinNumber == 1) |
| { |
| static const WCHAR wszCapture[] = {'C','a','p','t','u','r','e',0}; |
| ok(pinInfo.dir == PINDIR_OUTPUT, "pin 1 isn't an output pin\n"); |
| ok(!lstrcmpW(pinInfo.achName, wszCapture), "pin 1 is called %s, not 'Capture'\n", wine_dbgstr_w(pinInfo.achName)); |
| hr = IPin_QueryId(pin, &id); |
| ok(SUCCEEDED(hr), "IPin_QueryId() failed with 0x%08x\n", hr); |
| ok(!lstrcmpW(id, wszCapture), "pin 1's id is %s, not 'Capture'\n", wine_dbgstr_w(id)); |
| capturePin = pin; |
| IPin_AddRef(capturePin); |
| } |
| else if (pinNumber == 2) |
| { |
| static const WCHAR wszPreview[] = {'P','r','e','v','i','e','w',0}; |
| ok(pinInfo.dir == PINDIR_OUTPUT, "pin 2 isn't an output pin\n"); |
| ok(!lstrcmpW(pinInfo.achName, wszPreview), "pin 2 is called %s, not 'Preview'\n", wine_dbgstr_w(pinInfo.achName)); |
| hr = IPin_QueryId(pin, &id); |
| ok(SUCCEEDED(hr), "IPin_QueryId() failed with 0x%08x\n", hr); |
| ok(!lstrcmpW(id, wszPreview), "pin 2's id is %s, not 'Preview'\n", wine_dbgstr_w(id)); |
| previewPin = pin; |
| IPin_AddRef(previewPin); |
| } |
| else |
| ok(0, "pin %d isn't supposed to exist\n", pinNumber); |
| |
| endwhile: |
| if (pinInfo.pFilter) |
| IBaseFilter_Release(pinInfo.pFilter); |
| if (id) |
| CoTaskMemFree(id); |
| IPin_Release(pin); |
| pinNumber++; |
| } |
| |
| ok(inputPin && capturePin && previewPin, "couldn't find all pins\n"); |
| if (!(inputPin && capturePin && previewPin)) |
| goto end; |
| |
| ok(has_interface((IUnknown*)inputPin, &IID_IUnknown), "IUnknown should exist on the input pin\n"); |
| ok(has_interface((IUnknown*)inputPin, &IID_IMemInputPin), "IMemInputPin should exist the input pin\n"); |
| ok(!has_interface((IUnknown*)inputPin, &IID_IKsPropertySet), "IKsPropertySet shouldn't exist on the input pin\n"); |
| ok(!has_interface((IUnknown*)inputPin, &IID_IAMStreamConfig), "IAMStreamConfig shouldn't exist on the input pin\n"); |
| ok(!has_interface((IUnknown*)inputPin, &IID_IAMStreamControl), "IAMStreamControl shouldn't exist on the input pin\n"); |
| ok(!has_interface((IUnknown*)inputPin, &IID_IPropertyBag), "IPropertyBag shouldn't exist on the input pin\n"); |
| todo_wine ok(has_interface((IUnknown*)inputPin, &IID_IQualityControl), "IQualityControl should exist on the input pin\n"); |
| |
| ok(has_interface((IUnknown*)capturePin, &IID_IUnknown), "IUnknown should exist on the capture pin\n"); |
| ok(!has_interface((IUnknown*)capturePin, &IID_IAsyncReader), "IAsyncReader shouldn't exist on the capture pin\n"); |
| ok(!has_interface((IUnknown*)capturePin, &IID_IKsPropertySet), "IKsPropertySet shouldn't exist on the capture pin\n"); |
| ok(!has_interface((IUnknown*)capturePin, &IID_IAMStreamConfig), "IAMStreamConfig shouldn't exist on the capture pin\n"); |
| todo_wine ok(has_interface((IUnknown*)capturePin, &IID_IAMStreamControl), "IAMStreamControl should exist on the capture pin\n"); |
| ok(!has_interface((IUnknown*)capturePin, &IID_IPropertyBag), "IPropertyBag shouldn't exist on the capture pin\n"); |
| todo_wine ok(has_interface((IUnknown*)capturePin, &IID_IQualityControl), "IQualityControl should exist on the capture pin\n"); |
| |
| ok(has_interface((IUnknown*)previewPin, &IID_IUnknown), "IUnknown should exist on the preview pin\n"); |
| ok(!has_interface((IUnknown*)previewPin, &IID_IAsyncReader), "IAsyncReader shouldn't exist on the preview pin\n"); |
| ok(!has_interface((IUnknown*)previewPin, &IID_IKsPropertySet), "IKsPropertySet shouldn't exist on the preview pin\n"); |
| ok(!has_interface((IUnknown*)previewPin, &IID_IAMStreamConfig), "IAMStreamConfig shouldn't exist on the preview pin\n"); |
| todo_wine ok(has_interface((IUnknown*)capturePin, &IID_IAMStreamControl), "IAMStreamControl should exist on the preview pin\n"); |
| ok(!has_interface((IUnknown*)previewPin, &IID_IPropertyBag), "IPropertyBag shouldn't exist on the preview pin\n"); |
| todo_wine ok(has_interface((IUnknown*)previewPin, &IID_IQualityControl), "IQualityControl should exist on the preview pin\n"); |
| |
| hr = IPin_QueryInterface(inputPin, &IID_IMemInputPin, (void**)&memInputPin); |
| ok(SUCCEEDED(hr), "couldn't get mem input pin, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| hr = IMemInputPin_ReceiveCanBlock(memInputPin); |
| ok(hr == S_OK, "unexpected IMemInputPin_ReceiveCanBlock() = 0x%08x\n", hr); |
| |
| hr = IPin_EnumMediaTypes(inputPin, &enumMediaTypes); |
| ok(SUCCEEDED(hr), "IPin_EnumMediaTypes() failed, hr=0x%08x\n", hr); |
| if (SUCCEEDED(hr)) { |
| AM_MEDIA_TYPE *mediaType = NULL; |
| hr = IEnumMediaTypes_Next(enumMediaTypes, 1, &mediaType, NULL); |
| ok(hr == S_FALSE, "the media types are non-empty\n"); |
| } |
| IEnumMediaTypes_Release(enumMediaTypes); |
| enumMediaTypes = NULL; |
| hr = IPin_EnumMediaTypes(capturePin, &enumMediaTypes); |
| ok(hr == VFW_E_NOT_CONNECTED, "IPin_EnumMediaTypes() failed, hr=0x%08x\n", hr); |
| hr = IPin_EnumMediaTypes(previewPin, &enumMediaTypes); |
| ok(hr == VFW_E_NOT_CONNECTED, "IPin_EnumMediaTypes() failed, hr=0x%08x\n", hr); |
| |
| hr = IPin_QueryInternalConnections(inputPin, NULL, &nPin); |
| ok(hr == E_NOTIMPL, "IPin_QueryInternalConnections() returned hr=0x%08x\n", hr); |
| hr = IPin_QueryInternalConnections(capturePin, NULL, &nPin); |
| ok(hr == E_NOTIMPL, "IPin_QueryInternalConnections() returned hr=0x%08x\n", hr); |
| hr = IPin_QueryInternalConnections(previewPin, NULL, &nPin); |
| ok(hr == E_NOTIMPL, "IPin_QueryInternalConnections() returned hr=0x%08x\n", hr); |
| |
| test_smart_tee_filter_in_graph(smartTeeFilter, inputPin, capturePin, previewPin); |
| |
| end: |
| if (inputPin) |
| IPin_Release(inputPin); |
| if (capturePin) |
| IPin_Release(capturePin); |
| if (previewPin) |
| IPin_Release(previewPin); |
| if (smartTeeFilter) |
| IBaseFilter_Release(smartTeeFilter); |
| if (enumPins) |
| IEnumPins_Release(enumPins); |
| if (memInputPin) |
| IMemInputPin_Release(memInputPin); |
| if (enumMediaTypes) |
| IEnumMediaTypes_Release(enumMediaTypes); |
| } |
| |
| static void test_smart_tee_filter_aggregation(void) |
| { |
| SourceFilter *sourceFilter = create_video_SourceFilter(); |
| if (sourceFilter) { |
| IUnknown *unknown = NULL; |
| HRESULT hr = CoCreateInstance(&CLSID_SmartTee, (IUnknown*)&sourceFilter->IBaseFilter_iface, |
| CLSCTX_INPROC_SERVER, &IID_IUnknown, (void**)&unknown); |
| ok(SUCCEEDED(hr), "SmartTee filter doesn't support aggregation, hr=0x%08x\n", hr); |
| if (unknown) |
| IUnknown_Release(unknown); |
| IBaseFilter_Release(&sourceFilter->IBaseFilter_iface); |
| } else |
| ok(0, "out of memory allocating SourceFilter for test\n"); |
| } |
| |
| static HRESULT get_connected_filter_classid(IPin *pin, GUID *guid) |
| { |
| IPin *connectedPin = NULL; |
| PIN_INFO connectedPinInfo; |
| HRESULT hr = IPin_ConnectedTo(pin, &connectedPin); |
| ok(SUCCEEDED(hr), "IPin_ConnectedTo() failed, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| hr = IPin_QueryPinInfo(connectedPin, &connectedPinInfo); |
| ok(SUCCEEDED(hr), "IPin_QueryPinInfo() failed, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| if (connectedPinInfo.pFilter) { |
| hr = IBaseFilter_GetClassID(connectedPinInfo.pFilter, guid); |
| ok(SUCCEEDED(hr), "IBaseFilter_GetClassID() failed, hr=0x%08x\n", hr); |
| IBaseFilter_Release(connectedPinInfo.pFilter); |
| } |
| end: |
| if (connectedPin) |
| IPin_Release(connectedPin); |
| return hr; |
| } |
| |
| static void test_audio_preview(ICaptureGraphBuilder2 *captureGraphBuilder, IGraphBuilder *graphBuilder, |
| SourceFilter *audioSource, IBaseFilter *nullRenderer) |
| { |
| GUID clsid; |
| HRESULT hr = ICaptureGraphBuilder2_RenderStream(captureGraphBuilder, &PIN_CATEGORY_PREVIEW, &MEDIATYPE_Audio, |
| (IUnknown*)&audioSource->IBaseFilter_iface, NULL, nullRenderer); |
| ok(hr == VFW_S_NOPREVIEWPIN, "ICaptureGraphBuilder2_RenderStream() returned hr=0x%08x\n", hr); |
| hr = get_connected_filter_classid(&audioSource->IPin_iface, &clsid); |
| if (FAILED(hr)) |
| return; |
| ok(IsEqualIID(&clsid, &CLSID_SmartTee), "unexpected connected filter %s\n", |
| wine_dbgstr_guid(&clsid)); |
| } |
| |
| static void test_audio_capture(ICaptureGraphBuilder2 *captureGraphBuilder, IGraphBuilder *graphBuilder, |
| SourceFilter *audioSource, IBaseFilter *nullRenderer) |
| { |
| GUID clsid; |
| HRESULT hr = ICaptureGraphBuilder2_RenderStream(captureGraphBuilder, &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Audio, |
| (IUnknown*)&audioSource->IBaseFilter_iface, NULL, nullRenderer); |
| ok(hr == S_OK, "ICaptureGraphBuilder2_RenderStream() returned hr=0x%08x\n", hr); |
| hr = get_connected_filter_classid(&audioSource->IPin_iface, &clsid); |
| if (FAILED(hr)) |
| return; |
| ok(IsEqualIID(&clsid, &CLSID_SmartTee), "unexpected connected filter %s\n", |
| wine_dbgstr_guid(&clsid)); |
| } |
| |
| static void test_video_preview(ICaptureGraphBuilder2 *captureGraphBuilder, IGraphBuilder *graphBuilder, |
| SourceFilter *videoSource, IBaseFilter *nullRenderer) |
| { |
| GUID clsid; |
| HRESULT hr = ICaptureGraphBuilder2_RenderStream(captureGraphBuilder, &PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video, |
| (IUnknown*)&videoSource->IBaseFilter_iface, NULL, nullRenderer); |
| ok(hr == VFW_S_NOPREVIEWPIN, "ICaptureGraphBuilder2_RenderStream() failed, hr=0x%08x\n", hr); |
| hr = get_connected_filter_classid(&videoSource->IPin_iface, &clsid); |
| if (FAILED(hr)) |
| return; |
| ok(IsEqualIID(&clsid, &CLSID_SmartTee), "unexpected connected filter %s\n", |
| wine_dbgstr_guid(&clsid)); |
| } |
| |
| static void test_video_capture(ICaptureGraphBuilder2 *captureGraphBuilder, IGraphBuilder *graphBuilder, |
| SourceFilter *videoSource, IBaseFilter *nullRenderer) |
| { |
| GUID clsid; |
| HRESULT hr = ICaptureGraphBuilder2_RenderStream(captureGraphBuilder, &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, |
| (IUnknown*)&videoSource->IBaseFilter_iface, NULL, nullRenderer); |
| ok(hr == S_OK, "ICaptureGraphBuilder2_RenderStream() failed, hr=0x%08x\n", hr); |
| hr = get_connected_filter_classid(&videoSource->IPin_iface, &clsid); |
| if (FAILED(hr)) |
| return; |
| ok(IsEqualIID(&clsid, &CLSID_SmartTee), "unexpected connected filter %s\n", |
| wine_dbgstr_guid(&clsid)); |
| } |
| |
| static void test_audio_smart_tee_filter_auto_insertion( |
| void (*test_function)(ICaptureGraphBuilder2 *cgb, IGraphBuilder *gb, |
| SourceFilter *audioSource, IBaseFilter *nullRenderer)) |
| { |
| HRESULT hr; |
| ICaptureGraphBuilder2 *captureGraphBuilder = NULL; |
| IGraphBuilder *graphBuilder = NULL; |
| IBaseFilter *nullRenderer = NULL; |
| SourceFilter *audioSource = NULL; |
| |
| hr = CoCreateInstance(&CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER, |
| &IID_ICaptureGraphBuilder2, (void**)&captureGraphBuilder); |
| ok(SUCCEEDED(hr), "couldn't create capture graph builder, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, &IID_IGraphBuilder, |
| (LPVOID*)&graphBuilder); |
| ok(SUCCEEDED(hr), "couldn't create graph builder, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| hr = ICaptureGraphBuilder2_SetFiltergraph(captureGraphBuilder, graphBuilder); |
| ok(SUCCEEDED(hr), "ICaptureGraphBuilder2_SetFilterGraph() failed, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| hr = CoCreateInstance(&CLSID_NullRenderer, NULL, CLSCTX_INPROC_SERVER, |
| &IID_IBaseFilter, (LPVOID*)&nullRenderer); |
| ok(SUCCEEDED(hr) || |
| /* Windows 2008: http://stackoverflow.com/questions/29410348/initialize-nullrender-failed-with-error-regdb-e-classnotreg-on-win2008-r2 */ |
| broken(hr == REGDB_E_CLASSNOTREG), "couldn't create NullRenderer, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| hr = IGraphBuilder_AddFilter(graphBuilder, nullRenderer, NULL); |
| ok(SUCCEEDED(hr), "IGraphBuilder_AddFilter() failed, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| audioSource = create_audio_SourceFilter(); |
| ok(audioSource != NULL, "couldn't create audio source\n"); |
| if (audioSource == NULL) |
| goto end; |
| hr = IGraphBuilder_AddFilter(graphBuilder, &audioSource->IBaseFilter_iface, NULL); |
| ok(SUCCEEDED(hr), "IGraphBuilder_AddFilter() failed, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| test_function(captureGraphBuilder, graphBuilder, audioSource, nullRenderer); |
| |
| end: |
| if (nullRenderer) |
| IBaseFilter_Release(nullRenderer); |
| if (audioSource) |
| IBaseFilter_Release(&audioSource->IBaseFilter_iface); |
| if (captureGraphBuilder) |
| ICaptureGraphBuilder2_Release(captureGraphBuilder); |
| if (graphBuilder) |
| IGraphBuilder_Release(graphBuilder); |
| } |
| |
| static void test_video_smart_tee_filter_auto_insertion( |
| void (*test_function)(ICaptureGraphBuilder2 *cgb, IGraphBuilder *gb, |
| SourceFilter *videoSource, IBaseFilter *nullRenderer)) |
| { |
| HRESULT hr; |
| ICaptureGraphBuilder2 *captureGraphBuilder = NULL; |
| IGraphBuilder *graphBuilder = NULL; |
| IBaseFilter *nullRenderer = NULL; |
| SourceFilter *videoSource = NULL; |
| |
| hr = CoCreateInstance(&CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER, |
| &IID_ICaptureGraphBuilder2, (void**)&captureGraphBuilder); |
| ok(SUCCEEDED(hr), "couldn't create capture graph builder, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, &IID_IGraphBuilder, |
| (LPVOID*)&graphBuilder); |
| ok(SUCCEEDED(hr), "couldn't create graph builder, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| hr = ICaptureGraphBuilder2_SetFiltergraph(captureGraphBuilder, graphBuilder); |
| ok(SUCCEEDED(hr), "ICaptureGraphBuilder2_SetFilterGraph() failed, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| hr = CoCreateInstance(&CLSID_NullRenderer, NULL, CLSCTX_INPROC_SERVER, |
| &IID_IBaseFilter, (LPVOID*)&nullRenderer); |
| ok(SUCCEEDED(hr) || |
| /* Windows 2008: http://stackoverflow.com/questions/29410348/initialize-nullrender-failed-with-error-regdb-e-classnotreg-on-win2008-r2 */ |
| broken(hr == REGDB_E_CLASSNOTREG), "couldn't create NullRenderer, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| hr = IGraphBuilder_AddFilter(graphBuilder, nullRenderer, NULL); |
| ok(SUCCEEDED(hr), "IGraphBuilder_AddFilter() failed, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| videoSource = create_video_SourceFilter(); |
| ok(videoSource != NULL, "couldn't create audio source\n"); |
| if (videoSource == NULL) |
| goto end; |
| hr = IGraphBuilder_AddFilter(graphBuilder, &videoSource->IBaseFilter_iface, NULL); |
| ok(SUCCEEDED(hr), "IGraphBuilder_AddFilter() failed, hr=0x%08x\n", hr); |
| if (FAILED(hr)) |
| goto end; |
| |
| test_function(captureGraphBuilder, graphBuilder, videoSource, nullRenderer); |
| |
| end: |
| if (nullRenderer) |
| IBaseFilter_Release(nullRenderer); |
| if (videoSource) |
| IBaseFilter_Release(&videoSource->IBaseFilter_iface); |
| if (captureGraphBuilder) |
| ICaptureGraphBuilder2_Release(captureGraphBuilder); |
| if (graphBuilder) |
| IGraphBuilder_Release(graphBuilder); |
| } |
| |
| START_TEST(smartteefilter) |
| { |
| if (SUCCEEDED(CoInitialize(NULL))) |
| { |
| event = CreateEventW(NULL, FALSE, FALSE, NULL); |
| if (event) { |
| test_smart_tee_filter_aggregation(); |
| test_smart_tee_filter(); |
| |
| test_audio_smart_tee_filter_auto_insertion(test_audio_preview); |
| test_audio_smart_tee_filter_auto_insertion(test_audio_capture); |
| |
| test_video_smart_tee_filter_auto_insertion(test_video_preview); |
| test_video_smart_tee_filter_auto_insertion(test_video_capture); |
| |
| CloseHandle(event); |
| } else |
| skip("CreateEvent failed, error=%u\n", GetLastError()); |
| |
| CoUninitialize(); |
| } |
| else |
| skip("CoInitialize failed\n"); |
| } |