/* * Generic Implementation of IPin Interface * * Copyright 2003 Robert Shearman * * 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 "quartz_private.h" #include "pin.h" #include "wine/debug.h" #include "wine/unicode.h" #include "uuids.h" #include "vfwmsgs.h" #include <assert.h> WINE_DEFAULT_DEBUG_CHANNEL(quartz); static const IPinVtbl InputPin_Vtbl; static const IPinVtbl OutputPin_Vtbl; static const IMemInputPinVtbl MemInputPin_Vtbl; static const IPinVtbl PullPin_Vtbl; #define ALIGNDOWN(value,boundary) ((value)/(boundary)*(boundary)) #define ALIGNUP(value,boundary) (ALIGNDOWN((value)+(boundary)-1, (boundary))) static inline InputPin *impl_from_IMemInputPin( IMemInputPin *iface ) { return (InputPin *)((char*)iface - FIELD_OFFSET(InputPin, lpVtblMemInput)); } static void Copy_PinInfo(PIN_INFO * pDest, const PIN_INFO * pSrc) { /* Tempting to just do a memcpy, but the name field is 128 characters long! We will probably never exceed 10 most of the time, so we are better off copying each field manually */ strcpyW(pDest->achName, pSrc->achName); pDest->dir = pSrc->dir; pDest->pFilter = pSrc->pFilter; } /* Function called as a helper to IPin_Connect */ /* specific AM_MEDIA_TYPE - it cannot be NULL */ /* NOTE: not part of standard interface */ static HRESULT OutputPin_ConnectSpecific(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt) { OutputPin *This = (OutputPin *)iface; HRESULT hr; IMemAllocator * pMemAlloc = NULL; ALLOCATOR_PROPERTIES actual; /* FIXME: should we put the actual props back in to This? */ TRACE("(%p, %p)\n", pReceivePin, pmt); dump_AM_MEDIA_TYPE(pmt); /* FIXME: call queryacceptproc */ This->pin.pConnectedTo = pReceivePin; IPin_AddRef(pReceivePin); CopyMediaType(&This->pin.mtCurrent, pmt); hr = IPin_ReceiveConnection(pReceivePin, iface, pmt); /* get the IMemInputPin interface we will use to deliver samples to the * connected pin */ if (SUCCEEDED(hr)) { This->pMemInputPin = NULL; hr = IPin_QueryInterface(pReceivePin, &IID_IMemInputPin, (LPVOID)&This->pMemInputPin); if (SUCCEEDED(hr)) { hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pMemAlloc); if (hr == VFW_E_NO_ALLOCATOR) { /* Input pin provides no allocator, use standard memory allocator */ hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC_SERVER, &IID_IMemAllocator, (LPVOID*)&pMemAlloc); if (SUCCEEDED(hr)) { hr = IMemInputPin_NotifyAllocator(This->pMemInputPin, pMemAlloc, FALSE); } } if (SUCCEEDED(hr)) hr = IMemAllocator_SetProperties(pMemAlloc, &This->allocProps, &actual); if (pMemAlloc) IMemAllocator_Release(pMemAlloc); } /* break connection if we couldn't get the allocator */ if (FAILED(hr)) { if (This->pMemInputPin) IMemInputPin_Release(This->pMemInputPin); This->pMemInputPin = NULL; IPin_Disconnect(pReceivePin); } } if (FAILED(hr)) { IPin_Release(This->pin.pConnectedTo); This->pin.pConnectedTo = NULL; FreeMediaType(&This->pin.mtCurrent); } TRACE(" -- %x\n", hr); return hr; } HRESULT InputPin_Construct(const PIN_INFO * pPinInfo, SAMPLEPROC pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, IPin ** ppPin) { InputPin * pPinImpl; *ppPin = NULL; if (pPinInfo->dir != PINDIR_INPUT) { ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir); return E_INVALIDARG; } pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl)); if (!pPinImpl) return E_OUTOFMEMORY; if (SUCCEEDED(InputPin_Init(pPinInfo, pSampleProc, pUserData, pQueryAccept, pCritSec, pPinImpl))) { pPinImpl->pin.lpVtbl = &InputPin_Vtbl; pPinImpl->lpVtblMemInput = &MemInputPin_Vtbl; *ppPin = (IPin *)(&pPinImpl->pin.lpVtbl); return S_OK; } CoTaskMemFree(pPinImpl); return E_FAIL; } /* Note that we don't init the vtables here (like C++ constructor) */ HRESULT InputPin_Init(const PIN_INFO * pPinInfo, SAMPLEPROC pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, InputPin * pPinImpl) { TRACE("\n"); /* Common attributes */ pPinImpl->pin.refCount = 1; pPinImpl->pin.pConnectedTo = NULL; pPinImpl->pin.fnQueryAccept = pQueryAccept; pPinImpl->pin.pUserData = pUserData; pPinImpl->pin.pCritSec = pCritSec; Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo); ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE)); /* Input pin attributes */ pPinImpl->fnSampleProc = pSampleProc; pPinImpl->pAllocator = NULL; pPinImpl->tStart = 0; pPinImpl->tStop = 0; pPinImpl->dRate = 0; return S_OK; } HRESULT OutputPin_Init(const PIN_INFO * pPinInfo, const ALLOCATOR_PROPERTIES * props, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, OutputPin * pPinImpl) { TRACE("\n"); /* Common attributes */ pPinImpl->pin.lpVtbl = &OutputPin_Vtbl; pPinImpl->pin.refCount = 1; pPinImpl->pin.pConnectedTo = NULL; pPinImpl->pin.fnQueryAccept = pQueryAccept; pPinImpl->pin.pUserData = pUserData; pPinImpl->pin.pCritSec = pCritSec; Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo); ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE)); /* Output pin attributes */ pPinImpl->pMemInputPin = NULL; pPinImpl->pConnectSpecific = OutputPin_ConnectSpecific; if (props) { memcpy(&pPinImpl->allocProps, props, sizeof(pPinImpl->allocProps)); if (pPinImpl->allocProps.cbAlign == 0) pPinImpl->allocProps.cbAlign = 1; } else ZeroMemory(&pPinImpl->allocProps, sizeof(pPinImpl->allocProps)); return S_OK; } HRESULT OutputPin_Construct(const PIN_INFO * pPinInfo, ALLOCATOR_PROPERTIES *props, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, IPin ** ppPin) { OutputPin * pPinImpl; *ppPin = NULL; if (pPinInfo->dir != PINDIR_OUTPUT) { ERR("Pin direction(%x) != PINDIR_OUTPUT\n", pPinInfo->dir); return E_INVALIDARG; } pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl)); if (!pPinImpl) return E_OUTOFMEMORY; if (SUCCEEDED(OutputPin_Init(pPinInfo, props, pUserData, pQueryAccept, pCritSec, pPinImpl))) { pPinImpl->pin.lpVtbl = &OutputPin_Vtbl; *ppPin = (IPin *)(&pPinImpl->pin.lpVtbl); return S_OK; } CoTaskMemFree(pPinImpl); return E_FAIL; } /*** Common pin functions ***/ ULONG WINAPI IPinImpl_AddRef(IPin * iface) { IPinImpl *This = (IPinImpl *)iface; ULONG refCount = InterlockedIncrement(&This->refCount); TRACE("(%p)->() AddRef from %d\n", iface, refCount - 1); return refCount; } HRESULT WINAPI IPinImpl_Disconnect(IPin * iface) { HRESULT hr; IPinImpl *This = (IPinImpl *)iface; TRACE("()\n"); EnterCriticalSection(This->pCritSec); { if (This->pConnectedTo) { IPin_Release(This->pConnectedTo); This->pConnectedTo = NULL; hr = S_OK; } else hr = S_FALSE; } LeaveCriticalSection(This->pCritSec); return hr; } HRESULT WINAPI IPinImpl_ConnectedTo(IPin * iface, IPin ** ppPin) { HRESULT hr; IPinImpl *This = (IPinImpl *)iface; /* TRACE("(%p)\n", ppPin);*/ EnterCriticalSection(This->pCritSec); { if (This->pConnectedTo) { *ppPin = This->pConnectedTo; IPin_AddRef(*ppPin); hr = S_OK; } else hr = VFW_E_NOT_CONNECTED; } LeaveCriticalSection(This->pCritSec); return hr; } HRESULT WINAPI IPinImpl_ConnectionMediaType(IPin * iface, AM_MEDIA_TYPE * pmt) { HRESULT hr; IPinImpl *This = (IPinImpl *)iface; TRACE("(%p/%p)->(%p)\n", This, iface, pmt); EnterCriticalSection(This->pCritSec); { if (This->pConnectedTo) { CopyMediaType(pmt, &This->mtCurrent); hr = S_OK; } else { ZeroMemory(pmt, sizeof(*pmt)); hr = VFW_E_NOT_CONNECTED; } } LeaveCriticalSection(This->pCritSec); return hr; } HRESULT WINAPI IPinImpl_QueryPinInfo(IPin * iface, PIN_INFO * pInfo) { IPinImpl *This = (IPinImpl *)iface; TRACE("(%p/%p)->(%p)\n", This, iface, pInfo); Copy_PinInfo(pInfo, &This->pinInfo); IBaseFilter_AddRef(pInfo->pFilter); return S_OK; } HRESULT WINAPI IPinImpl_QueryDirection(IPin * iface, PIN_DIRECTION * pPinDir) { IPinImpl *This = (IPinImpl *)iface; TRACE("(%p/%p)->(%p)\n", This, iface, pPinDir); *pPinDir = This->pinInfo.dir; return S_OK; } HRESULT WINAPI IPinImpl_QueryId(IPin * iface, LPWSTR * Id) { IPinImpl *This = (IPinImpl *)iface; TRACE("(%p/%p)->(%p)\n", This, iface, Id); *Id = CoTaskMemAlloc((strlenW(This->pinInfo.achName) + 1) * sizeof(WCHAR)); if (!*Id) return E_OUTOFMEMORY; strcpyW(*Id, This->pinInfo.achName); return S_OK; } HRESULT WINAPI IPinImpl_QueryAccept(IPin * iface, const AM_MEDIA_TYPE * pmt) { IPinImpl *This = (IPinImpl *)iface; TRACE("(%p/%p)->(%p)\n", This, iface, pmt); return (This->fnQueryAccept(This->pUserData, pmt) == S_OK ? S_OK : S_FALSE); } HRESULT WINAPI IPinImpl_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum) { IPinImpl *This = (IPinImpl *)iface; ENUMMEDIADETAILS emd; TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum); /* override this method to allow enumeration of your types */ emd.cMediaTypes = 0; emd.pMediaTypes = NULL; return IEnumMediaTypesImpl_Construct(&emd, ppEnum); } HRESULT WINAPI IPinImpl_QueryInternalConnections(IPin * iface, IPin ** apPin, ULONG * cPin) { IPinImpl *This = (IPinImpl *)iface; TRACE("(%p/%p)->(%p, %p)\n", This, iface, apPin, cPin); return E_NOTIMPL; /* to tell caller that all input pins connected to all output pins */ } /*** IPin implementation for an input pin ***/ HRESULT WINAPI InputPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv) { InputPin *This = (InputPin *)iface; TRACE("(%p)->(%s, %p)\n", iface, qzdebugstr_guid(riid), ppv); *ppv = NULL; if (IsEqualIID(riid, &IID_IUnknown)) *ppv = (LPVOID)iface; else if (IsEqualIID(riid, &IID_IPin)) *ppv = (LPVOID)iface; else if (IsEqualIID(riid, &IID_IMemInputPin)) *ppv = (LPVOID)&This->lpVtblMemInput; if (*ppv) { IUnknown_AddRef((IUnknown *)(*ppv)); return S_OK; } FIXME("No interface for %s!\n", qzdebugstr_guid(riid)); return E_NOINTERFACE; } ULONG WINAPI InputPin_Release(IPin * iface) { InputPin *This = (InputPin *)iface; ULONG refCount = InterlockedDecrement(&This->pin.refCount); TRACE("(%p)->() Release from %d\n", iface, refCount + 1); if (!refCount) { FreeMediaType(&This->pin.mtCurrent); if (This->pAllocator) IMemAllocator_Release(This->pAllocator); CoTaskMemFree(This); return 0; } else return refCount; } HRESULT WINAPI InputPin_Connect(IPin * iface, IPin * pConnector, const AM_MEDIA_TYPE * pmt) { ERR("Outgoing connection on an input pin! (%p, %p)\n", pConnector, pmt); return E_UNEXPECTED; } HRESULT WINAPI InputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt) { InputPin *This = (InputPin *)iface; PIN_DIRECTION pindirReceive; HRESULT hr = S_OK; TRACE("(%p, %p)\n", pReceivePin, pmt); dump_AM_MEDIA_TYPE(pmt); EnterCriticalSection(This->pin.pCritSec); { if (This->pin.pConnectedTo) hr = VFW_E_ALREADY_CONNECTED; if (SUCCEEDED(hr) && This->pin.fnQueryAccept(This->pin.pUserData, pmt) != S_OK) hr = VFW_E_TYPE_NOT_ACCEPTED; /* FIXME: shouldn't we just map common errors onto * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */ if (SUCCEEDED(hr)) { IPin_QueryDirection(pReceivePin, &pindirReceive); if (pindirReceive != PINDIR_OUTPUT) { ERR("Can't connect from non-output pin\n"); hr = VFW_E_INVALID_DIRECTION; } } if (SUCCEEDED(hr)) { CopyMediaType(&This->pin.mtCurrent, pmt); This->pin.pConnectedTo = pReceivePin; IPin_AddRef(pReceivePin); } } LeaveCriticalSection(This->pin.pCritSec); return hr; } HRESULT WINAPI InputPin_EndOfStream(IPin * iface) { TRACE("()\n"); return S_OK; } HRESULT WINAPI InputPin_BeginFlush(IPin * iface) { FIXME("()\n"); return E_NOTIMPL; } HRESULT WINAPI InputPin_EndFlush(IPin * iface) { FIXME("()\n"); return E_NOTIMPL; } HRESULT WINAPI InputPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate) { InputPin *This = (InputPin *)iface; TRACE("(%x%08x, %x%08x, %e)\n", (ULONG)(tStart >> 32), (ULONG)tStart, (ULONG)(tStop >> 32), (ULONG)tStop, dRate); This->tStart = tStart; This->tStop = tStop; This->dRate = dRate; return S_OK; } static const IPinVtbl InputPin_Vtbl = { InputPin_QueryInterface, IPinImpl_AddRef, InputPin_Release, InputPin_Connect, InputPin_ReceiveConnection, IPinImpl_Disconnect, IPinImpl_ConnectedTo, IPinImpl_ConnectionMediaType, IPinImpl_QueryPinInfo, IPinImpl_QueryDirection, IPinImpl_QueryId, IPinImpl_QueryAccept, IPinImpl_EnumMediaTypes, IPinImpl_QueryInternalConnections, InputPin_EndOfStream, InputPin_BeginFlush, InputPin_EndFlush, InputPin_NewSegment }; /*** IMemInputPin implementation ***/ HRESULT WINAPI MemInputPin_QueryInterface(IMemInputPin * iface, REFIID riid, LPVOID * ppv) { InputPin *This = impl_from_IMemInputPin(iface); return IPin_QueryInterface((IPin *)&This->pin, riid, ppv); } ULONG WINAPI MemInputPin_AddRef(IMemInputPin * iface) { InputPin *This = impl_from_IMemInputPin(iface); return IPin_AddRef((IPin *)&This->pin); } ULONG WINAPI MemInputPin_Release(IMemInputPin * iface) { InputPin *This = impl_from_IMemInputPin(iface); return IPin_Release((IPin *)&This->pin); } HRESULT WINAPI MemInputPin_GetAllocator(IMemInputPin * iface, IMemAllocator ** ppAllocator) { InputPin *This = impl_from_IMemInputPin(iface); TRACE("(%p/%p)->(%p)\n", This, iface, ppAllocator); *ppAllocator = This->pAllocator; if (*ppAllocator) IMemAllocator_AddRef(*ppAllocator); return *ppAllocator ? S_OK : VFW_E_NO_ALLOCATOR; } HRESULT WINAPI MemInputPin_NotifyAllocator(IMemInputPin * iface, IMemAllocator * pAllocator, BOOL bReadOnly) { InputPin *This = impl_from_IMemInputPin(iface); TRACE("(%p/%p)->(%p, %d)\n", This, iface, pAllocator, bReadOnly); if (This->pAllocator) IMemAllocator_Release(This->pAllocator); This->pAllocator = pAllocator; if (This->pAllocator) IMemAllocator_AddRef(This->pAllocator); return S_OK; } HRESULT WINAPI MemInputPin_GetAllocatorRequirements(IMemInputPin * iface, ALLOCATOR_PROPERTIES * pProps) { InputPin *This = impl_from_IMemInputPin(iface); TRACE("(%p/%p)->(%p)\n", This, iface, pProps); /* override this method if you have any specific requirements */ return E_NOTIMPL; } HRESULT WINAPI MemInputPin_Receive(IMemInputPin * iface, IMediaSample * pSample) { InputPin *This = impl_from_IMemInputPin(iface); /* this trace commented out for performance reasons */ /*TRACE("(%p/%p)->(%p)\n", This, iface, pSample);*/ return This->fnSampleProc(This->pin.pUserData, pSample); } HRESULT WINAPI MemInputPin_ReceiveMultiple(IMemInputPin * iface, IMediaSample ** pSamples, long nSamples, long *nSamplesProcessed) { HRESULT hr = S_OK; InputPin *This = impl_from_IMemInputPin(iface); TRACE("(%p/%p)->(%p, %ld, %p)\n", This, iface, pSamples, nSamples, nSamplesProcessed); for (*nSamplesProcessed = 0; *nSamplesProcessed < nSamples; (*nSamplesProcessed)++) { hr = IMemInputPin_Receive(iface, pSamples[*nSamplesProcessed]); if (hr != S_OK) break; } return hr; } HRESULT WINAPI MemInputPin_ReceiveCanBlock(IMemInputPin * iface) { InputPin *This = impl_from_IMemInputPin(iface); FIXME("(%p/%p)->()\n", This, iface); /* FIXME: we should check whether any output pins will block */ return S_OK; } static const IMemInputPinVtbl MemInputPin_Vtbl = { MemInputPin_QueryInterface, MemInputPin_AddRef, MemInputPin_Release, MemInputPin_GetAllocator, MemInputPin_NotifyAllocator, MemInputPin_GetAllocatorRequirements, MemInputPin_Receive, MemInputPin_ReceiveMultiple, MemInputPin_ReceiveCanBlock }; HRESULT WINAPI OutputPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv) { OutputPin *This = (OutputPin *)iface; TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv); *ppv = NULL; if (IsEqualIID(riid, &IID_IUnknown)) *ppv = (LPVOID)iface; else if (IsEqualIID(riid, &IID_IPin)) *ppv = (LPVOID)iface; if (*ppv) { IUnknown_AddRef((IUnknown *)(*ppv)); return S_OK; } FIXME("No interface for %s!\n", qzdebugstr_guid(riid)); return E_NOINTERFACE; } ULONG WINAPI OutputPin_Release(IPin * iface) { OutputPin *This = (OutputPin *)iface; ULONG refCount = InterlockedDecrement(&This->pin.refCount); TRACE("(%p)->() Release from %d\n", iface, refCount + 1); if (!refCount) { FreeMediaType(&This->pin.mtCurrent); CoTaskMemFree(This); return 0; } return refCount; } HRESULT WINAPI OutputPin_Connect(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt) { HRESULT hr; OutputPin *This = (OutputPin *)iface; TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt); dump_AM_MEDIA_TYPE(pmt); /* If we try to connect to ourself, we will definitely deadlock. * There are other cases where we could deadlock too, but this * catches the obvious case */ assert(pReceivePin != iface); EnterCriticalSection(This->pin.pCritSec); { /* if we have been a specific type to connect with, then we can either connect * with that or fail. We cannot choose different AM_MEDIA_TYPE */ if (pmt && !IsEqualGUID(&pmt->majortype, &GUID_NULL) && !IsEqualGUID(&pmt->subtype, &GUID_NULL)) hr = This->pConnectSpecific(iface, pReceivePin, pmt); else { /* negotiate media type */ IEnumMediaTypes * pEnumCandidates; AM_MEDIA_TYPE * pmtCandidate; /* Candidate media type */ if (SUCCEEDED(hr = IPin_EnumMediaTypes(iface, &pEnumCandidates))) { hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */ /* try this filter's media types first */ while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL)) { if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) && (This->pConnectSpecific(iface, pReceivePin, pmtCandidate) == S_OK)) { hr = S_OK; CoTaskMemFree(pmtCandidate); break; } CoTaskMemFree(pmtCandidate); } IEnumMediaTypes_Release(pEnumCandidates); } /* then try receiver filter's media types */ if (hr != S_OK && SUCCEEDED(hr = IPin_EnumMediaTypes(pReceivePin, &pEnumCandidates))) /* if we haven't already connected successfully */ { hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */ while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL)) { if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) && (This->pConnectSpecific(iface, pReceivePin, pmtCandidate) == S_OK)) { hr = S_OK; CoTaskMemFree(pmtCandidate); break; } CoTaskMemFree(pmtCandidate); } /* while */ IEnumMediaTypes_Release(pEnumCandidates); } /* if not found */ } /* if negotiate media type */ } /* if succeeded */ LeaveCriticalSection(This->pin.pCritSec); TRACE(" -- %x\n", hr); return hr; } HRESULT WINAPI OutputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt) { ERR("Incoming connection on an output pin! (%p, %p)\n", pReceivePin, pmt); return E_UNEXPECTED; } HRESULT WINAPI OutputPin_Disconnect(IPin * iface) { HRESULT hr; OutputPin *This = (OutputPin *)iface; TRACE("()\n"); EnterCriticalSection(This->pin.pCritSec); { if (This->pMemInputPin) { IMemInputPin_Release(This->pMemInputPin); This->pMemInputPin = NULL; } if (This->pin.pConnectedTo) { IPin_Release(This->pin.pConnectedTo); This->pin.pConnectedTo = NULL; hr = S_OK; } else hr = S_FALSE; } LeaveCriticalSection(This->pin.pCritSec); return hr; } HRESULT WINAPI OutputPin_EndOfStream(IPin * iface) { TRACE("()\n"); /* not supposed to do anything in an output pin */ return E_UNEXPECTED; } HRESULT WINAPI OutputPin_BeginFlush(IPin * iface) { TRACE("(%p)->()\n", iface); /* not supposed to do anything in an output pin */ return E_UNEXPECTED; } HRESULT WINAPI OutputPin_EndFlush(IPin * iface) { TRACE("(%p)->()\n", iface); /* not supposed to do anything in an output pin */ return E_UNEXPECTED; } HRESULT WINAPI OutputPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate) { TRACE("(%p)->(%x%08x, %x%08x, %e)\n", iface, (ULONG)(tStart >> 32), (ULONG)tStart, (ULONG)(tStop >> 32), (ULONG)tStop, dRate); /* not supposed to do anything in an output pin */ return E_UNEXPECTED; } static const IPinVtbl OutputPin_Vtbl = { OutputPin_QueryInterface, IPinImpl_AddRef, OutputPin_Release, OutputPin_Connect, OutputPin_ReceiveConnection, OutputPin_Disconnect, IPinImpl_ConnectedTo, IPinImpl_ConnectionMediaType, IPinImpl_QueryPinInfo, IPinImpl_QueryDirection, IPinImpl_QueryId, IPinImpl_QueryAccept, IPinImpl_EnumMediaTypes, IPinImpl_QueryInternalConnections, OutputPin_EndOfStream, OutputPin_BeginFlush, OutputPin_EndFlush, OutputPin_NewSegment }; HRESULT OutputPin_GetDeliveryBuffer(OutputPin * This, IMediaSample ** ppSample, REFERENCE_TIME * tStart, REFERENCE_TIME * tStop, DWORD dwFlags) { HRESULT hr; TRACE("(%p, %p, %p, %x)\n", ppSample, tStart, tStop, dwFlags); EnterCriticalSection(This->pin.pCritSec); { if (!This->pin.pConnectedTo) hr = VFW_E_NOT_CONNECTED; else { IMemAllocator * pAlloc = NULL; hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc); if (SUCCEEDED(hr)) hr = IMemAllocator_GetBuffer(pAlloc, ppSample, tStart, tStop, dwFlags); if (SUCCEEDED(hr)) hr = IMediaSample_SetTime(*ppSample, tStart, tStop); if (pAlloc) IMemAllocator_Release(pAlloc); } } LeaveCriticalSection(This->pin.pCritSec); return hr; } HRESULT OutputPin_SendSample(OutputPin * This, IMediaSample * pSample) { HRESULT hr = S_OK; IMemInputPin * pMemConnected = NULL; PIN_INFO pinInfo; EnterCriticalSection(This->pin.pCritSec); { if (!This->pin.pConnectedTo || !This->pMemInputPin) hr = VFW_E_NOT_CONNECTED; else { /* we don't have the lock held when using This->pMemInputPin, * so we need to AddRef it to stop it being deleted while we are * using it. Same with its filter. */ pMemConnected = This->pMemInputPin; IMemInputPin_AddRef(pMemConnected); hr = IPin_QueryPinInfo(This->pin.pConnectedTo, &pinInfo); } } LeaveCriticalSection(This->pin.pCritSec); if (SUCCEEDED(hr)) { /* NOTE: if we are in a critical section when Receive is called * then it causes some problems (most notably with the native Video * Renderer) if we are re-entered for whatever reason */ hr = IMemInputPin_Receive(pMemConnected, pSample); /* If the filter's destroyed, tell upstream to stop sending data */ if(IBaseFilter_Release(pinInfo.pFilter) == 0 && SUCCEEDED(hr)) hr = S_FALSE; } if (pMemConnected) IMemInputPin_Release(pMemConnected); return hr; } HRESULT OutputPin_DeliverNewSegment(OutputPin * This, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate) { HRESULT hr; EnterCriticalSection(This->pin.pCritSec); { if (!This->pin.pConnectedTo) hr = VFW_E_NOT_CONNECTED; else hr = IPin_NewSegment(This->pin.pConnectedTo, tStart, tStop, dRate); } LeaveCriticalSection(This->pin.pCritSec); return hr; } HRESULT OutputPin_CommitAllocator(OutputPin * This) { HRESULT hr; TRACE("(%p)->()\n", This); EnterCriticalSection(This->pin.pCritSec); { if (!This->pin.pConnectedTo || !This->pMemInputPin) hr = VFW_E_NOT_CONNECTED; else { IMemAllocator * pAlloc = NULL; hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc); if (SUCCEEDED(hr)) hr = IMemAllocator_Commit(pAlloc); if (pAlloc) IMemAllocator_Release(pAlloc); } } LeaveCriticalSection(This->pin.pCritSec); return hr; } HRESULT OutputPin_DeliverDisconnect(OutputPin * This) { HRESULT hr; TRACE("(%p)->()\n", This); EnterCriticalSection(This->pin.pCritSec); { if (!This->pin.pConnectedTo || !This->pMemInputPin) hr = VFW_E_NOT_CONNECTED; else { IMemAllocator * pAlloc = NULL; hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc); if (SUCCEEDED(hr)) hr = IMemAllocator_Decommit(pAlloc); if (pAlloc) IMemAllocator_Release(pAlloc); if (SUCCEEDED(hr)) hr = IPin_Disconnect(This->pin.pConnectedTo); } } LeaveCriticalSection(This->pin.pCritSec); return hr; } HRESULT PullPin_Construct(const PIN_INFO * pPinInfo, SAMPLEPROC pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, IPin ** ppPin) { PullPin * pPinImpl; *ppPin = NULL; if (pPinInfo->dir != PINDIR_INPUT) { ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir); return E_INVALIDARG; } pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl)); if (!pPinImpl) return E_OUTOFMEMORY; if (SUCCEEDED(PullPin_Init(pPinInfo, pSampleProc, pUserData, pQueryAccept, pCritSec, pPinImpl))) { pPinImpl->pin.lpVtbl = &PullPin_Vtbl; *ppPin = (IPin *)(&pPinImpl->pin.lpVtbl); return S_OK; } CoTaskMemFree(pPinImpl); return E_FAIL; } HRESULT PullPin_Init(const PIN_INFO * pPinInfo, SAMPLEPROC pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, PullPin * pPinImpl) { /* Common attributes */ pPinImpl->pin.refCount = 1; pPinImpl->pin.pConnectedTo = NULL; pPinImpl->pin.fnQueryAccept = pQueryAccept; pPinImpl->pin.pUserData = pUserData; pPinImpl->pin.pCritSec = pCritSec; Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo); ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE)); /* Input pin attributes */ pPinImpl->fnSampleProc = pSampleProc; pPinImpl->fnPreConnect = NULL; pPinImpl->pAlloc = NULL; pPinImpl->pReader = NULL; pPinImpl->hThread = NULL; pPinImpl->hEventStateChanged = CreateEventW(NULL, FALSE, TRUE, NULL); pPinImpl->rtStart = 0; pPinImpl->rtCurrent = 0; pPinImpl->rtStop = ((LONGLONG)0x7fffffff << 32) | 0xffffffff; return S_OK; } HRESULT WINAPI PullPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt) { PIN_DIRECTION pindirReceive; HRESULT hr = S_OK; PullPin *This = (PullPin *)iface; TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt); dump_AM_MEDIA_TYPE(pmt); EnterCriticalSection(This->pin.pCritSec); { if (This->pin.pConnectedTo) hr = VFW_E_ALREADY_CONNECTED; if (SUCCEEDED(hr) && (This->pin.fnQueryAccept(This->pin.pUserData, pmt) != S_OK)) hr = VFW_E_TYPE_NOT_ACCEPTED; /* FIXME: shouldn't we just map common errors onto * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */ if (SUCCEEDED(hr)) { IPin_QueryDirection(pReceivePin, &pindirReceive); if (pindirReceive != PINDIR_OUTPUT) { ERR("Can't connect from non-output pin\n"); hr = VFW_E_INVALID_DIRECTION; } } This->pReader = NULL; This->pAlloc = NULL; if (SUCCEEDED(hr)) { hr = IPin_QueryInterface(pReceivePin, &IID_IAsyncReader, (LPVOID *)&This->pReader); } if (SUCCEEDED(hr)) { ALLOCATOR_PROPERTIES props; props.cBuffers = 3; props.cbBuffer = 64 * 1024; /* 64k bytes */ props.cbAlign = 1; props.cbPrefix = 0; hr = IAsyncReader_RequestAllocator(This->pReader, NULL, &props, &This->pAlloc); } if (SUCCEEDED(hr) && This->fnPreConnect) { hr = This->fnPreConnect(iface, pReceivePin); } if (SUCCEEDED(hr)) { CopyMediaType(&This->pin.mtCurrent, pmt); This->pin.pConnectedTo = pReceivePin; IPin_AddRef(pReceivePin); } else { if (This->pReader) IAsyncReader_Release(This->pReader); This->pReader = NULL; if (This->pAlloc) IMemAllocator_Release(This->pAlloc); This->pAlloc = NULL; } } LeaveCriticalSection(This->pin.pCritSec); return hr; } HRESULT WINAPI PullPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv) { PullPin *This = (PullPin *)iface; TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv); *ppv = NULL; if (IsEqualIID(riid, &IID_IUnknown)) *ppv = (LPVOID)iface; else if (IsEqualIID(riid, &IID_IPin)) *ppv = (LPVOID)iface; if (*ppv) { IUnknown_AddRef((IUnknown *)(*ppv)); return S_OK; } FIXME("No interface for %s!\n", qzdebugstr_guid(riid)); return E_NOINTERFACE; } ULONG WINAPI PullPin_Release(IPin * iface) { PullPin *This = (PullPin *)iface; ULONG refCount = InterlockedDecrement(&This->pin.refCount); TRACE("(%p)->() Release from %d\n", This, refCount + 1); if (!refCount) { if(This->pAlloc) IMemAllocator_Release(This->pAlloc); if(This->pReader) IAsyncReader_Release(This->pReader); CloseHandle(This->hEventStateChanged); CoTaskMemFree(This); return 0; } return refCount; } static DWORD WINAPI PullPin_Thread_Main(LPVOID pv) { for (;;) SleepEx(INFINITE, TRUE); } static void CALLBACK PullPin_Thread_Process(ULONG_PTR iface) { PullPin *This = (PullPin *)iface; HRESULT hr; ALLOCATOR_PROPERTIES allocProps; CoInitializeEx(NULL, COINIT_MULTITHREADED); SetEvent(This->hEventStateChanged); hr = IMemAllocator_GetProperties(This->pAlloc, &allocProps); if (This->rtCurrent < This->rtStart) This->rtCurrent = MEDIATIME_FROM_BYTES(ALIGNDOWN(BYTES_FROM_MEDIATIME(This->rtStart), allocProps.cbAlign)); TRACE("Start\n"); while (This->rtCurrent < This->rtStop && hr == S_OK) { /* FIXME: to improve performance by quite a bit this should be changed * so that one sample is processed while one sample is fetched. However, * it is harder to debug so for the moment it will stay as it is */ IMediaSample * pSample = NULL; REFERENCE_TIME rtSampleStart; REFERENCE_TIME rtSampleStop; DWORD_PTR dwUser; TRACE("Process sample\n"); hr = IMemAllocator_GetBuffer(This->pAlloc, &pSample, NULL, NULL, 0); if (SUCCEEDED(hr)) { rtSampleStart = This->rtCurrent; rtSampleStop = rtSampleStart + MEDIATIME_FROM_BYTES(IMediaSample_GetSize(pSample)); if (rtSampleStop > This->rtStop) rtSampleStop = MEDIATIME_FROM_BYTES(ALIGNUP(BYTES_FROM_MEDIATIME(This->rtStop), allocProps.cbAlign)); hr = IMediaSample_SetTime(pSample, &rtSampleStart, &rtSampleStop); This->rtCurrent = rtSampleStop; } if (SUCCEEDED(hr)) hr = IAsyncReader_Request(This->pReader, pSample, (ULONG_PTR)0); if (SUCCEEDED(hr)) hr = IAsyncReader_WaitForNext(This->pReader, 10000, &pSample, &dwUser); if (SUCCEEDED(hr)) { rtSampleStop = rtSampleStart + MEDIATIME_FROM_BYTES(IMediaSample_GetActualDataLength(pSample)); if (rtSampleStop > This->rtStop) rtSampleStop = MEDIATIME_FROM_BYTES(ALIGNUP(BYTES_FROM_MEDIATIME(This->rtStop), allocProps.cbAlign)); hr = IMediaSample_SetTime(pSample, &rtSampleStart, &rtSampleStop); } if (SUCCEEDED(hr)) hr = This->fnSampleProc(This->pin.pUserData, pSample); else ERR("Processing error: %x\n", hr); if (pSample) IMediaSample_Release(pSample); } CoUninitialize(); TRACE("End\n"); } static void CALLBACK PullPin_Thread_Stop(ULONG_PTR iface) { PullPin *This = (PullPin *)iface; TRACE("(%p/%p)->()\n", This, (LPVOID)iface); EnterCriticalSection(This->pin.pCritSec); { HRESULT hr; CloseHandle(This->hThread); This->hThread = NULL; if (FAILED(hr = IMemAllocator_Decommit(This->pAlloc))) ERR("Allocator decommit failed with error %x. Possible memory leak\n", hr); } LeaveCriticalSection(This->pin.pCritSec); SetEvent(This->hEventStateChanged); IBaseFilter_Release(This->pin.pinInfo.pFilter); ExitThread(0); } HRESULT PullPin_InitProcessing(PullPin * This) { HRESULT hr = S_OK; TRACE("(%p)->()\n", This); assert(!This->hThread); /* if we are connected */ if (This->pAlloc) { EnterCriticalSection(This->pin.pCritSec); { DWORD dwThreadId; assert(!This->hThread); /* AddRef the filter to make sure it and it's pins will be around * as long as the thread */ IBaseFilter_AddRef(This->pin.pinInfo.pFilter); This->hThread = CreateThread(NULL, 0, PullPin_Thread_Main, NULL, 0, &dwThreadId); if (!This->hThread) { hr = HRESULT_FROM_WIN32(GetLastError()); IBaseFilter_Release(This->pin.pinInfo.pFilter); } if (SUCCEEDED(hr)) hr = IMemAllocator_Commit(This->pAlloc); } LeaveCriticalSection(This->pin.pCritSec); } TRACE(" -- %x\n", hr); return hr; } HRESULT PullPin_StartProcessing(PullPin * This) { /* if we are connected */ TRACE("(%p)->()\n", This); if(This->pAlloc) { assert(This->hThread); ResetEvent(This->hEventStateChanged); if (!QueueUserAPC(PullPin_Thread_Process, This->hThread, (ULONG_PTR)This)) return HRESULT_FROM_WIN32(GetLastError()); } return S_OK; } HRESULT PullPin_PauseProcessing(PullPin * This) { /* make the processing function exit its loop */ This->rtStop = 0; return S_OK; } HRESULT PullPin_StopProcessing(PullPin * This) { /* if we are connected */ if (This->pAlloc) { assert(This->hThread); ResetEvent(This->hEventStateChanged); PullPin_PauseProcessing(This); if (!QueueUserAPC(PullPin_Thread_Stop, This->hThread, (ULONG_PTR)This)) return HRESULT_FROM_WIN32(GetLastError()); } return S_OK; } HRESULT PullPin_WaitForStateChange(PullPin * This, DWORD dwMilliseconds) { if (WaitForSingleObject(This->hEventStateChanged, dwMilliseconds) == WAIT_TIMEOUT) return S_FALSE; return S_OK; } HRESULT PullPin_Seek(PullPin * This, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop) { FIXME("(%p)->(%x%08x, %x%08x)\n", This, (LONG)(rtStart >> 32), (LONG)rtStart, (LONG)(rtStop >> 32), (LONG)rtStop); PullPin_BeginFlush((IPin *)This); /* FIXME: need critical section? */ This->rtStart = rtStart; This->rtStop = rtStop; PullPin_EndFlush((IPin *)This); return S_OK; } HRESULT WINAPI PullPin_EndOfStream(IPin * iface) { FIXME("(%p)->()\n", iface); return E_NOTIMPL; } HRESULT WINAPI PullPin_BeginFlush(IPin * iface) { FIXME("(%p)->()\n", iface); return E_NOTIMPL; } HRESULT WINAPI PullPin_EndFlush(IPin * iface) { FIXME("(%p)->()\n", iface); return E_NOTIMPL; } HRESULT WINAPI PullPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate) { FIXME("(%p)->(%s, %s, %g)\n", iface, wine_dbgstr_longlong(tStart), wine_dbgstr_longlong(tStop), dRate); return E_NOTIMPL; } static const IPinVtbl PullPin_Vtbl = { PullPin_QueryInterface, IPinImpl_AddRef, PullPin_Release, OutputPin_Connect, PullPin_ReceiveConnection, IPinImpl_Disconnect, IPinImpl_ConnectedTo, IPinImpl_ConnectionMediaType, IPinImpl_QueryPinInfo, IPinImpl_QueryDirection, IPinImpl_QueryId, IPinImpl_QueryAccept, IPinImpl_EnumMediaTypes, IPinImpl_QueryInternalConnections, PullPin_EndOfStream, PullPin_BeginFlush, PullPin_EndFlush, PullPin_NewSegment };