1458 lines
31 KiB
C
1458 lines
31 KiB
C
/*
|
|
* Implements IPin and IMemInputPin. (internal)
|
|
*
|
|
* Copyright (C) Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
|
|
*
|
|
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "wingdi.h"
|
|
#include "winuser.h"
|
|
#include "winerror.h"
|
|
#include "strmif.h"
|
|
#include "vfwmsgs.h"
|
|
|
|
#include "wine/debug.h"
|
|
WINE_DEFAULT_DEBUG_CHANNEL(quartz);
|
|
|
|
#include "quartz_private.h"
|
|
#include "basefilt.h"
|
|
#include "memalloc.h"
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* CPinBaseImpl
|
|
*
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnQueryInterface(IPin* iface,REFIID riid,void** ppobj)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return IUnknown_QueryInterface(This->punkControl,riid,ppobj);
|
|
}
|
|
|
|
static ULONG WINAPI
|
|
CPinBaseImpl_fnAddRef(IPin* iface)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return IUnknown_AddRef(This->punkControl);
|
|
}
|
|
|
|
static ULONG WINAPI
|
|
CPinBaseImpl_fnRelease(IPin* iface)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return IUnknown_Release(This->punkControl);
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnConnect(IPin* iface,IPin* pPin,const AM_MEDIA_TYPE* pmt)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
HRESULT hr = E_NOTIMPL;
|
|
ULONG i;
|
|
FILTER_STATE fs;
|
|
|
|
TRACE("(%p)->(%p,%p)\n",This,pPin,pmt);
|
|
|
|
if ( !This->bOutput )
|
|
{
|
|
TRACE("Connect() should not be sent to input pins\n");
|
|
return E_UNEXPECTED;
|
|
}
|
|
if ( pPin == NULL )
|
|
return E_POINTER;
|
|
|
|
TRACE("try to connect to %p\n",pPin);
|
|
|
|
EnterCriticalSection( This->pcsPin );
|
|
|
|
if ( This->pPinConnectedTo != NULL )
|
|
{
|
|
hr = VFW_E_ALREADY_CONNECTED;
|
|
goto err;
|
|
}
|
|
|
|
/* return fail if running */
|
|
hr = IBaseFilter_GetState((IBaseFilter*)(This->pFilter),0,&fs);
|
|
if ( hr != S_OK || fs != State_Stopped )
|
|
{
|
|
TRACE("not stopped\n");
|
|
hr = VFW_E_NOT_STOPPED;
|
|
goto err;
|
|
}
|
|
|
|
if ( This->pHandlers->pOnPreConnect != NULL )
|
|
{
|
|
hr = This->pHandlers->pOnPreConnect(This,pPin);
|
|
if ( FAILED(hr) )
|
|
{
|
|
TRACE("OnPreconnect() failed hr = %08lx\n",hr);
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
if ( pmt != NULL )
|
|
{
|
|
hr = IPin_QueryAccept(iface,pmt);
|
|
if ( FAILED(hr) )
|
|
goto err;
|
|
hr = IPin_ReceiveConnection(pPin,iface,pmt);
|
|
if ( FAILED(hr) )
|
|
goto err;
|
|
}
|
|
else
|
|
{
|
|
for ( i = 0; i < This->cAcceptTypes; i++ )
|
|
{
|
|
pmt = &This->pmtAcceptTypes[i];
|
|
hr = IPin_QueryAccept(iface,pmt);
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
hr = IPin_ReceiveConnection(pPin,iface,pmt);
|
|
TRACE("ReceiveConnection - %08lx\n",hr);
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
goto connected;
|
|
}
|
|
}
|
|
}
|
|
|
|
hr = VFW_E_TYPE_NOT_ACCEPTED;
|
|
goto err;
|
|
}
|
|
|
|
connected:;
|
|
This->pmtConn = QUARTZ_MediaType_Duplicate( pmt );
|
|
if ( This->pmtConn == NULL )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
IPin_Disconnect(pPin);
|
|
goto err;
|
|
}
|
|
|
|
This->pPinConnectedTo = pPin; IPin_AddRef(pPin);
|
|
hr = IPin_QueryInterface(pPin,&IID_IMemInputPin,(void**)&This->pMemInputPinConnectedTo);
|
|
if ( FAILED(hr) )
|
|
{
|
|
TRACE("no IMemInputPin\n");
|
|
IPin_Disconnect(pPin);
|
|
goto err;
|
|
}
|
|
|
|
if ( This->pHandlers->pOnPostConnect != NULL )
|
|
{
|
|
hr = This->pHandlers->pOnPostConnect(This,pPin);
|
|
if ( FAILED(hr) )
|
|
{
|
|
TRACE("OnPostConnect() failed hr = %08lx\n",hr);
|
|
IPin_Disconnect(pPin);
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
err:
|
|
if ( FAILED(hr) )
|
|
{
|
|
IPin_Disconnect(iface);
|
|
}
|
|
LeaveCriticalSection( This->pcsPin );
|
|
|
|
TRACE("return %08lx\n",hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnReceiveConnection(IPin* iface,IPin* pPin,const AM_MEDIA_TYPE* pmt)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
HRESULT hr = E_NOTIMPL;
|
|
FILTER_STATE fs;
|
|
|
|
TRACE("(%p)->(%p,%p)\n",This,pPin,pmt);
|
|
|
|
if ( This->bOutput )
|
|
{
|
|
TRACE("ReceiveConnection() should not be sent to output pins\n");
|
|
return E_UNEXPECTED;
|
|
}
|
|
if ( pPin == NULL || pmt == NULL )
|
|
return E_POINTER;
|
|
|
|
EnterCriticalSection( This->pcsPin );
|
|
|
|
if ( This->pPinConnectedTo != NULL )
|
|
{
|
|
hr = VFW_E_ALREADY_CONNECTED;
|
|
goto err;
|
|
}
|
|
|
|
/* return fail if running */
|
|
hr = IBaseFilter_GetState((IBaseFilter*)(This->pFilter),0,&fs);
|
|
if ( hr != S_OK || fs != State_Stopped )
|
|
{
|
|
TRACE("not stopped\n");
|
|
hr = VFW_E_NOT_STOPPED;
|
|
goto err;
|
|
}
|
|
|
|
if ( This->pHandlers->pOnPreConnect != NULL )
|
|
{
|
|
hr = This->pHandlers->pOnPreConnect(This,pPin);
|
|
if ( FAILED(hr) )
|
|
{
|
|
TRACE("OnPreConnect() failed hr = %08lx\n",hr);
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
hr = IPin_QueryAccept(iface,pmt);
|
|
if ( FAILED(hr) )
|
|
goto err;
|
|
|
|
This->pmtConn = QUARTZ_MediaType_Duplicate( pmt );
|
|
if ( This->pmtConn == NULL )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto err;
|
|
}
|
|
|
|
if ( This->pHandlers->pOnPostConnect != NULL )
|
|
{
|
|
hr = This->pHandlers->pOnPostConnect(This,pPin);
|
|
if ( FAILED(hr) )
|
|
{
|
|
TRACE("OnPostConnect() failed hr = %08lx\n",hr);
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
hr = S_OK;
|
|
This->pPinConnectedTo = pPin; IPin_AddRef(pPin);
|
|
|
|
err:
|
|
if ( FAILED(hr) )
|
|
IPin_Disconnect(iface);
|
|
LeaveCriticalSection( This->pcsPin );
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnDisconnect(IPin* iface)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
HRESULT hr = NOERROR;
|
|
FILTER_STATE fs;
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
EnterCriticalSection( This->pcsPin );
|
|
|
|
/* return fail if running */
|
|
hr = IBaseFilter_GetState((IBaseFilter*)(This->pFilter),0,&fs);
|
|
if ( hr != S_OK || fs != State_Stopped )
|
|
{
|
|
TRACE("not stopped\n");
|
|
hr = VFW_E_NOT_STOPPED;
|
|
goto err;
|
|
}
|
|
|
|
if ( This->pHandlers->pOnDisconnect != NULL )
|
|
hr = This->pHandlers->pOnDisconnect(This);
|
|
|
|
if ( This->pmtConn != NULL )
|
|
{
|
|
QUARTZ_MediaType_Destroy( This->pmtConn );
|
|
This->pmtConn = NULL;
|
|
}
|
|
if ( This->pMemInputPinConnectedTo != NULL )
|
|
{
|
|
IMemInputPin_Release(This->pMemInputPinConnectedTo);
|
|
This->pMemInputPinConnectedTo = NULL;
|
|
}
|
|
if ( This->pPinConnectedTo != NULL )
|
|
{
|
|
/* FIXME - cleanup */
|
|
|
|
IPin_Release(This->pPinConnectedTo);
|
|
This->pPinConnectedTo = NULL;
|
|
hr = NOERROR;
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE; /* FIXME - is this correct??? */
|
|
}
|
|
|
|
err:
|
|
LeaveCriticalSection( This->pcsPin );
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnConnectedTo(IPin* iface,IPin** ppPin)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
HRESULT hr = VFW_E_NOT_CONNECTED;
|
|
|
|
TRACE("(%p)->(%p)\n",This,ppPin);
|
|
|
|
if ( ppPin == NULL )
|
|
return E_POINTER;
|
|
|
|
EnterCriticalSection( This->pcsPin );
|
|
|
|
*ppPin = This->pPinConnectedTo;
|
|
if ( This->pPinConnectedTo != NULL )
|
|
{
|
|
IPin_AddRef(This->pPinConnectedTo);
|
|
hr = NOERROR;
|
|
}
|
|
|
|
LeaveCriticalSection( This->pcsPin );
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnConnectionMediaType(IPin* iface,AM_MEDIA_TYPE* pmt)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
HRESULT hr = E_FAIL;
|
|
|
|
TRACE("(%p)->(%p)\n",This,pmt);
|
|
|
|
if ( pmt == NULL )
|
|
return E_POINTER;
|
|
|
|
EnterCriticalSection( This->pcsPin );
|
|
|
|
if ( This->pmtConn != NULL )
|
|
{
|
|
hr = QUARTZ_MediaType_Copy( pmt, This->pmtConn );
|
|
}
|
|
else
|
|
{
|
|
ZeroMemory( pmt, sizeof(AM_MEDIA_TYPE) );
|
|
pmt->bFixedSizeSamples = TRUE;
|
|
pmt->lSampleSize = 1;
|
|
hr = VFW_E_NOT_CONNECTED;
|
|
}
|
|
|
|
LeaveCriticalSection( This->pcsPin );
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnQueryPinInfo(IPin* iface,PIN_INFO* pinfo)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
|
|
TRACE("(%p)->(%p)\n",This,pinfo);
|
|
|
|
if ( pinfo == NULL )
|
|
return E_POINTER;
|
|
|
|
EnterCriticalSection( This->pcsPin );
|
|
|
|
ZeroMemory( pinfo, sizeof(PIN_INFO) );
|
|
pinfo->pFilter = (IBaseFilter*)(This->pFilter);
|
|
if ( pinfo->pFilter != NULL )
|
|
IBaseFilter_AddRef( pinfo->pFilter );
|
|
pinfo->dir = This->bOutput ? PINDIR_OUTPUT : PINDIR_INPUT;
|
|
if ( This->cbIdLen <= sizeof(pinfo->achName) )
|
|
memcpy( pinfo->achName, This->pwszId, This->cbIdLen );
|
|
else
|
|
{
|
|
memcpy( pinfo->achName, This->pwszId, sizeof(pinfo->achName) );
|
|
pinfo->achName[sizeof(pinfo->achName)/sizeof(pinfo->achName[0])-1] = 0;
|
|
}
|
|
|
|
LeaveCriticalSection( This->pcsPin );
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnQueryDirection(IPin* iface,PIN_DIRECTION* pdir)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
|
|
TRACE("(%p)->(%p)\n",This,pdir);
|
|
|
|
if ( pdir == NULL )
|
|
return E_POINTER;
|
|
|
|
*pdir = This->bOutput ? PINDIR_OUTPUT : PINDIR_INPUT;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnQueryId(IPin* iface,LPWSTR* lpwszId)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
|
|
TRACE("(%p)->(%p)\n",This,lpwszId);
|
|
|
|
if ( lpwszId == NULL )
|
|
return E_POINTER;
|
|
|
|
*lpwszId = (WCHAR*)CoTaskMemAlloc( This->cbIdLen );
|
|
if ( *lpwszId == NULL )
|
|
return E_OUTOFMEMORY;
|
|
memcpy( *lpwszId, This->pwszId, This->cbIdLen );
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnQueryAccept(IPin* iface,const AM_MEDIA_TYPE* pmt)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(%p)\n",This,pmt);
|
|
|
|
if ( pmt == NULL )
|
|
return E_POINTER;
|
|
|
|
hr = NOERROR;
|
|
EnterCriticalSection( This->pcsPin );
|
|
if ( This->pHandlers->pCheckMediaType != NULL )
|
|
hr = This->pHandlers->pCheckMediaType(This,pmt);
|
|
LeaveCriticalSection( This->pcsPin );
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnEnumMediaTypes(IPin* iface,IEnumMediaTypes** ppenum)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(%p)\n",This,ppenum);
|
|
|
|
if ( ppenum == NULL )
|
|
return E_POINTER;
|
|
|
|
hr = E_NOTIMPL;
|
|
|
|
EnterCriticalSection( This->pcsPin );
|
|
if ( This->cAcceptTypes > 0 )
|
|
hr = QUARTZ_CreateEnumMediaTypes(
|
|
ppenum, This->pmtAcceptTypes, This->cAcceptTypes );
|
|
LeaveCriticalSection( This->pcsPin );
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnQueryInternalConnections(IPin* iface,IPin** ppPin,ULONG* pul)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
|
|
TRACE("(%p)->(%p,%p)\n",This,ppPin,pul);
|
|
|
|
/* E_NOTIMPL means 'no internal connections'. */
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnEndOfStream(IPin* iface)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
HRESULT hr = E_NOTIMPL;
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
if ( This->bOutput )
|
|
return E_UNEXPECTED;
|
|
|
|
EnterCriticalSection( This->pcsPinReceive );
|
|
if ( This->pHandlers->pEndOfStream != NULL )
|
|
hr = This->pHandlers->pEndOfStream(This);
|
|
LeaveCriticalSection( This->pcsPinReceive );
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnBeginFlush(IPin* iface)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
HRESULT hr = E_NOTIMPL;
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
if ( This->bOutput )
|
|
return E_UNEXPECTED;
|
|
|
|
EnterCriticalSection( This->pcsPin );
|
|
if ( This->pHandlers->pBeginFlush != NULL )
|
|
hr = This->pHandlers->pBeginFlush(This);
|
|
LeaveCriticalSection( This->pcsPin );
|
|
|
|
EnterCriticalSection( This->pcsPinReceive );
|
|
LeaveCriticalSection( This->pcsPinReceive );
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnEndFlush(IPin* iface)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
HRESULT hr = E_NOTIMPL;
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
if ( This->bOutput )
|
|
return E_UNEXPECTED;
|
|
|
|
EnterCriticalSection( This->pcsPin );
|
|
if ( This->pHandlers->pEndFlush != NULL )
|
|
hr = This->pHandlers->pEndFlush(This);
|
|
LeaveCriticalSection( This->pcsPin );
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CPinBaseImpl_fnNewSegment(IPin* iface,REFERENCE_TIME rtStart,REFERENCE_TIME rtStop,double rate)
|
|
{
|
|
ICOM_THIS(CPinBaseImpl,iface);
|
|
HRESULT hr = E_NOTIMPL;
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
if ( This->bOutput )
|
|
return E_UNEXPECTED;
|
|
|
|
EnterCriticalSection( This->pcsPin );
|
|
if ( This->pHandlers->pNewSegment != NULL )
|
|
hr = This->pHandlers->pNewSegment(This,rtStart,rtStop,rate);
|
|
LeaveCriticalSection( This->pcsPin );
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
static ICOM_VTABLE(IPin) ipin =
|
|
{
|
|
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
|
|
/* IUnknown fields */
|
|
CPinBaseImpl_fnQueryInterface,
|
|
CPinBaseImpl_fnAddRef,
|
|
CPinBaseImpl_fnRelease,
|
|
/* IPin fields */
|
|
CPinBaseImpl_fnConnect,
|
|
CPinBaseImpl_fnReceiveConnection,
|
|
CPinBaseImpl_fnDisconnect,
|
|
CPinBaseImpl_fnConnectedTo,
|
|
CPinBaseImpl_fnConnectionMediaType,
|
|
CPinBaseImpl_fnQueryPinInfo,
|
|
CPinBaseImpl_fnQueryDirection,
|
|
CPinBaseImpl_fnQueryId,
|
|
CPinBaseImpl_fnQueryAccept,
|
|
CPinBaseImpl_fnEnumMediaTypes,
|
|
CPinBaseImpl_fnQueryInternalConnections,
|
|
CPinBaseImpl_fnEndOfStream,
|
|
CPinBaseImpl_fnBeginFlush,
|
|
CPinBaseImpl_fnEndFlush,
|
|
CPinBaseImpl_fnNewSegment,
|
|
};
|
|
|
|
|
|
HRESULT CPinBaseImpl_InitIPin(
|
|
CPinBaseImpl* This, IUnknown* punkControl,
|
|
CRITICAL_SECTION* pcsPin,
|
|
CRITICAL_SECTION* pcsPinReceive,
|
|
CBaseFilterImpl* pFilter, LPCWSTR pwszId,
|
|
BOOL bOutput,
|
|
const CBasePinHandlers* pHandlers )
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
|
|
TRACE("(%p,%p,%p)\n",This,punkControl,pFilter);
|
|
|
|
if ( punkControl == NULL )
|
|
{
|
|
ERR( "punkControl must not be NULL\n" );
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
ICOM_VTBL(This) = &ipin;
|
|
This->punkControl = punkControl;
|
|
This->pHandlers = pHandlers;
|
|
This->cbIdLen = sizeof(WCHAR)*(lstrlenW(pwszId)+1);
|
|
This->pwszId = NULL;
|
|
This->bOutput = bOutput;
|
|
This->pmtAcceptTypes = NULL;
|
|
This->cAcceptTypes = 0;
|
|
This->pcsPin = pcsPin;
|
|
This->pcsPinReceive = pcsPinReceive;
|
|
This->pFilter = pFilter;
|
|
This->pPinConnectedTo = NULL;
|
|
This->pMemInputPinConnectedTo = NULL;
|
|
This->pmtConn = NULL;
|
|
This->pAsyncOut = NULL;
|
|
|
|
This->pwszId = (WCHAR*)QUARTZ_AllocMem( This->cbIdLen );
|
|
if ( This->pwszId == NULL )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto err;
|
|
}
|
|
memcpy( This->pwszId, pwszId, This->cbIdLen );
|
|
|
|
return NOERROR;
|
|
|
|
err:;
|
|
CPinBaseImpl_UninitIPin( This );
|
|
return hr;
|
|
}
|
|
|
|
void CPinBaseImpl_UninitIPin( CPinBaseImpl* This )
|
|
{
|
|
TRACE("(%p)\n",This);
|
|
|
|
IPin_Disconnect( (IPin*)(This) );
|
|
|
|
if ( This->pwszId != NULL )
|
|
{
|
|
QUARTZ_FreeMem( This->pwszId );
|
|
This->pwszId = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* CMemInputPinBaseImpl
|
|
*
|
|
*/
|
|
|
|
|
|
static HRESULT WINAPI
|
|
CMemInputPinBaseImpl_fnQueryInterface(IMemInputPin* iface,REFIID riid,void** ppobj)
|
|
{
|
|
ICOM_THIS(CMemInputPinBaseImpl,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return IUnknown_QueryInterface(This->punkControl,riid,ppobj);
|
|
}
|
|
|
|
static ULONG WINAPI
|
|
CMemInputPinBaseImpl_fnAddRef(IMemInputPin* iface)
|
|
{
|
|
ICOM_THIS(CMemInputPinBaseImpl,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return IUnknown_AddRef(This->punkControl);
|
|
}
|
|
|
|
static ULONG WINAPI
|
|
CMemInputPinBaseImpl_fnRelease(IMemInputPin* iface)
|
|
{
|
|
ICOM_THIS(CMemInputPinBaseImpl,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return IUnknown_Release(This->punkControl);
|
|
}
|
|
|
|
|
|
static HRESULT WINAPI
|
|
CMemInputPinBaseImpl_fnGetAllocator(IMemInputPin* iface,IMemAllocator** ppAllocator)
|
|
{
|
|
ICOM_THIS(CMemInputPinBaseImpl,iface);
|
|
HRESULT hr = NOERROR;
|
|
IUnknown* punk;
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
if ( ppAllocator == NULL )
|
|
return E_POINTER;
|
|
|
|
EnterCriticalSection( This->pPin->pcsPin );
|
|
|
|
if ( This->pAllocator == NULL )
|
|
{
|
|
hr = QUARTZ_CreateMemoryAllocator(NULL,(void**)&punk);
|
|
if ( hr == NOERROR )
|
|
{
|
|
hr = IUnknown_QueryInterface(punk,
|
|
&IID_IMemAllocator,(void**)&This->pAllocator);
|
|
IUnknown_Release(punk);
|
|
}
|
|
}
|
|
|
|
if ( hr == NOERROR )
|
|
{
|
|
*ppAllocator = This->pAllocator;
|
|
IMemAllocator_AddRef(This->pAllocator);
|
|
}
|
|
|
|
LeaveCriticalSection( This->pPin->pcsPin );
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CMemInputPinBaseImpl_fnNotifyAllocator(IMemInputPin* iface,IMemAllocator* pAllocator,BOOL bReadonly)
|
|
{
|
|
ICOM_THIS(CMemInputPinBaseImpl,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
if ( pAllocator == NULL )
|
|
return E_POINTER;
|
|
|
|
EnterCriticalSection( This->pPin->pcsPin );
|
|
|
|
if ( This->pAllocator != NULL )
|
|
{
|
|
IMemAllocator_Release(This->pAllocator);
|
|
This->pAllocator = NULL;
|
|
}
|
|
This->pAllocator = pAllocator;
|
|
IMemAllocator_AddRef(This->pAllocator);
|
|
|
|
This->bReadonly = bReadonly;
|
|
|
|
LeaveCriticalSection( This->pPin->pcsPin );
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CMemInputPinBaseImpl_fnGetAllocatorRequirements(IMemInputPin* iface,ALLOCATOR_PROPERTIES* pProp)
|
|
{
|
|
ICOM_THIS(CMemInputPinBaseImpl,iface);
|
|
|
|
TRACE("(%p)->(%p)\n",This,pProp);
|
|
|
|
if ( pProp == NULL )
|
|
return E_POINTER;
|
|
|
|
/* E_MOTIMPL means 'no requirements' */
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CMemInputPinBaseImpl_fnReceive(IMemInputPin* iface,IMediaSample* pSample)
|
|
{
|
|
ICOM_THIS(CMemInputPinBaseImpl,iface);
|
|
HRESULT hr = E_NOTIMPL;
|
|
|
|
TRACE("(%p)->(%p)\n",This,pSample);
|
|
|
|
EnterCriticalSection( This->pPin->pcsPinReceive );
|
|
if ( This->pPin->pHandlers->pReceive != NULL )
|
|
hr = This->pPin->pHandlers->pReceive(This->pPin,pSample);
|
|
LeaveCriticalSection( This->pPin->pcsPinReceive );
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CMemInputPinBaseImpl_fnReceiveMultiple(IMemInputPin* iface,IMediaSample** ppSample,long nSample,long* pnSampleProcessed)
|
|
{
|
|
ICOM_THIS(CMemInputPinBaseImpl,iface);
|
|
long n;
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
if ( ppSample == NULL || pnSampleProcessed == NULL )
|
|
return E_POINTER;
|
|
|
|
hr = NOERROR;
|
|
for ( n = 0; n < nSample; n++ )
|
|
{
|
|
hr = IMemInputPin_Receive(iface,ppSample[n]);
|
|
if ( FAILED(hr) )
|
|
break;
|
|
}
|
|
|
|
*pnSampleProcessed = n;
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CMemInputPinBaseImpl_fnReceiveCanBlock(IMemInputPin* iface)
|
|
{
|
|
ICOM_THIS(CMemInputPinBaseImpl,iface);
|
|
HRESULT hr = E_NOTIMPL;
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
EnterCriticalSection( This->pPin->pcsPin );
|
|
if ( This->pPin->pHandlers->pReceiveCanBlock != NULL )
|
|
hr = This->pPin->pHandlers->pReceiveCanBlock(This->pPin);
|
|
LeaveCriticalSection( This->pPin->pcsPin );
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
static ICOM_VTABLE(IMemInputPin) imeminputpin =
|
|
{
|
|
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
|
|
/* IUnknown fields */
|
|
CMemInputPinBaseImpl_fnQueryInterface,
|
|
CMemInputPinBaseImpl_fnAddRef,
|
|
CMemInputPinBaseImpl_fnRelease,
|
|
/* IMemInputPin fields */
|
|
CMemInputPinBaseImpl_fnGetAllocator,
|
|
CMemInputPinBaseImpl_fnNotifyAllocator,
|
|
CMemInputPinBaseImpl_fnGetAllocatorRequirements,
|
|
CMemInputPinBaseImpl_fnReceive,
|
|
CMemInputPinBaseImpl_fnReceiveMultiple,
|
|
CMemInputPinBaseImpl_fnReceiveCanBlock,
|
|
};
|
|
|
|
HRESULT CMemInputPinBaseImpl_InitIMemInputPin(
|
|
CMemInputPinBaseImpl* This, IUnknown* punkControl,
|
|
CPinBaseImpl* pPin )
|
|
{
|
|
TRACE("(%p,%p)\n",This,punkControl);
|
|
|
|
if ( punkControl == NULL )
|
|
{
|
|
ERR( "punkControl must not be NULL\n" );
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
ICOM_VTBL(This) = &imeminputpin;
|
|
This->punkControl = punkControl;
|
|
This->pPin = pPin;
|
|
This->pAllocator = NULL;
|
|
This->bReadonly = FALSE;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
void CMemInputPinBaseImpl_UninitIMemInputPin(
|
|
CMemInputPinBaseImpl* This )
|
|
{
|
|
TRACE("(%p)\n",This);
|
|
|
|
if ( This->pAllocator != NULL )
|
|
{
|
|
IMemAllocator_Release(This->pAllocator);
|
|
This->pAllocator = NULL;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
*
|
|
* CQualityControlPassThruImpl
|
|
*
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
CQualityControlPassThruImpl_fnQueryInterface(IQualityControl* iface,REFIID riid,void** ppobj)
|
|
{
|
|
ICOM_THIS(CQualityControlPassThruImpl,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return IUnknown_QueryInterface(This->punkControl,riid,ppobj);
|
|
}
|
|
|
|
static ULONG WINAPI
|
|
CQualityControlPassThruImpl_fnAddRef(IQualityControl* iface)
|
|
{
|
|
ICOM_THIS(CQualityControlPassThruImpl,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return IUnknown_AddRef(This->punkControl);
|
|
}
|
|
|
|
static ULONG WINAPI
|
|
CQualityControlPassThruImpl_fnRelease(IQualityControl* iface)
|
|
{
|
|
ICOM_THIS(CQualityControlPassThruImpl,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return IUnknown_Release(This->punkControl);
|
|
}
|
|
|
|
|
|
static HRESULT WINAPI
|
|
CQualityControlPassThruImpl_fnNotify(IQualityControl* iface,IBaseFilter* pFilter,Quality q)
|
|
{
|
|
ICOM_THIS(CQualityControlPassThruImpl,iface);
|
|
HRESULT hr = S_FALSE;
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
if ( This->pControl != NULL )
|
|
return IQualityControl_Notify( This->pControl, pFilter, q );
|
|
|
|
EnterCriticalSection( This->pPin->pcsPin );
|
|
if ( This->pPin->pHandlers->pQualityNotify != NULL )
|
|
hr = This->pPin->pHandlers->pQualityNotify(This->pPin,pFilter,q);
|
|
LeaveCriticalSection( This->pPin->pcsPin );
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
CQualityControlPassThruImpl_fnSetSink(IQualityControl* iface,IQualityControl* pControl)
|
|
{
|
|
ICOM_THIS(CQualityControlPassThruImpl,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
This->pControl = pControl; /* AddRef() must not be called */
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static ICOM_VTABLE(IQualityControl) iqualitycontrol =
|
|
{
|
|
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
|
|
/* IUnknown fields */
|
|
CQualityControlPassThruImpl_fnQueryInterface,
|
|
CQualityControlPassThruImpl_fnAddRef,
|
|
CQualityControlPassThruImpl_fnRelease,
|
|
/* IQualityControl fields */
|
|
CQualityControlPassThruImpl_fnNotify,
|
|
CQualityControlPassThruImpl_fnSetSink,
|
|
};
|
|
|
|
HRESULT CQualityControlPassThruImpl_InitIQualityControl(
|
|
CQualityControlPassThruImpl* This, IUnknown* punkControl,
|
|
CPinBaseImpl* pPin )
|
|
{
|
|
TRACE("(%p,%p)\n",This,punkControl);
|
|
|
|
if ( punkControl == NULL )
|
|
{
|
|
ERR( "punkControl must not be NULL\n" );
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
ICOM_VTBL(This) = &iqualitycontrol;
|
|
This->punkControl = punkControl;
|
|
This->pPin = pPin;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
void CQualityControlPassThruImpl_UninitIQualityControl(
|
|
CQualityControlPassThruImpl* This )
|
|
{
|
|
}
|
|
|
|
/***************************************************************************
|
|
*
|
|
* helper methods for output pins.
|
|
*
|
|
*/
|
|
|
|
HRESULT CPinBaseImpl_SendSample( CPinBaseImpl* This, IMediaSample* pSample )
|
|
{
|
|
if ( This->pHandlers->pReceive == NULL )
|
|
return E_NOTIMPL;
|
|
|
|
return This->pHandlers->pReceive( This, pSample );
|
|
}
|
|
|
|
HRESULT CPinBaseImpl_SendReceiveCanBlock( CPinBaseImpl* This )
|
|
{
|
|
if ( This->pHandlers->pReceiveCanBlock == NULL )
|
|
return E_NOTIMPL;
|
|
|
|
return This->pHandlers->pReceiveCanBlock( This );
|
|
}
|
|
|
|
HRESULT CPinBaseImpl_SendEndOfStream( CPinBaseImpl* This )
|
|
{
|
|
if ( This->pHandlers->pEndOfStream == NULL )
|
|
return E_NOTIMPL;
|
|
|
|
return This->pHandlers->pEndOfStream( This );
|
|
}
|
|
|
|
HRESULT CPinBaseImpl_SendBeginFlush( CPinBaseImpl* This )
|
|
{
|
|
if ( This->pHandlers->pBeginFlush == NULL )
|
|
return E_NOTIMPL;
|
|
|
|
return This->pHandlers->pBeginFlush( This );
|
|
}
|
|
|
|
HRESULT CPinBaseImpl_SendEndFlush( CPinBaseImpl* This )
|
|
{
|
|
if ( This->pHandlers->pEndFlush == NULL )
|
|
return E_NOTIMPL;
|
|
|
|
return This->pHandlers->pEndFlush( This );
|
|
}
|
|
|
|
HRESULT CPinBaseImpl_SendNewSegment( CPinBaseImpl* This, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop, double rate )
|
|
{
|
|
if ( This->pHandlers->pNewSegment == NULL )
|
|
return E_NOTIMPL;
|
|
|
|
return This->pHandlers->pNewSegment( This, rtStart, rtStop, rate );
|
|
}
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* handlers for output pins.
|
|
*
|
|
*/
|
|
|
|
HRESULT OutputPinSync_Receive( CPinBaseImpl* pImpl, IMediaSample* pSample )
|
|
{
|
|
if ( pImpl->pMemInputPinConnectedTo == NULL )
|
|
return NOERROR;
|
|
|
|
return IMemInputPin_Receive(pImpl->pMemInputPinConnectedTo,pSample);
|
|
}
|
|
|
|
HRESULT OutputPinSync_ReceiveCanBlock( CPinBaseImpl* pImpl )
|
|
{
|
|
if ( pImpl->pMemInputPinConnectedTo == NULL )
|
|
return S_FALSE;
|
|
|
|
return IMemInputPin_ReceiveCanBlock(pImpl->pMemInputPinConnectedTo);
|
|
}
|
|
|
|
HRESULT OutputPinSync_EndOfStream( CPinBaseImpl* pImpl )
|
|
{
|
|
if ( pImpl->pPinConnectedTo == NULL )
|
|
return NOERROR;
|
|
|
|
return IPin_EndOfStream(pImpl->pPinConnectedTo);
|
|
}
|
|
|
|
HRESULT OutputPinSync_BeginFlush( CPinBaseImpl* pImpl )
|
|
{
|
|
if ( pImpl->pPinConnectedTo == NULL )
|
|
return NOERROR;
|
|
|
|
return IPin_BeginFlush(pImpl->pPinConnectedTo);
|
|
}
|
|
|
|
HRESULT OutputPinSync_EndFlush( CPinBaseImpl* pImpl )
|
|
{
|
|
if ( pImpl->pPinConnectedTo == NULL )
|
|
return NOERROR;
|
|
|
|
return IPin_EndFlush(pImpl->pPinConnectedTo);
|
|
}
|
|
|
|
HRESULT OutputPinSync_NewSegment( CPinBaseImpl* pImpl, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop, double rate )
|
|
{
|
|
if ( pImpl->pPinConnectedTo == NULL )
|
|
return NOERROR;
|
|
|
|
return IPin_NewSegment(pImpl->pPinConnectedTo,rtStart,rtStop,rate);
|
|
}
|
|
|
|
/***************************************************************************
|
|
*
|
|
* handlers for output pins (async).
|
|
*
|
|
*/
|
|
|
|
typedef struct OutputPinTask OutputPinTask;
|
|
|
|
enum OutputPinTaskType
|
|
{
|
|
OutTask_ExitThread,
|
|
OutTask_Receive,
|
|
OutTask_EndOfStream,
|
|
OutTask_BeginFlush,
|
|
OutTask_EndFlush,
|
|
OutTask_NewSegment,
|
|
};
|
|
|
|
struct OutputPinTask
|
|
{
|
|
OutputPinTask* pNext;
|
|
enum OutputPinTaskType tasktype;
|
|
IMediaSample* pSample;
|
|
REFERENCE_TIME rtStart;
|
|
REFERENCE_TIME rtStop;
|
|
double rate;
|
|
};
|
|
|
|
struct OutputPinAsyncImpl
|
|
{
|
|
HANDLE m_hTaskThread;
|
|
HANDLE m_hTaskEvent;
|
|
IPin* m_pPin; /* connected pin */
|
|
IMemInputPin* m_pMemInputPin; /* connected pin */
|
|
CRITICAL_SECTION m_csTasks;
|
|
OutputPinTask* m_pFirst;
|
|
OutputPinTask* m_pLast;
|
|
OutputPinTask* m_pTaskExitThread;
|
|
};
|
|
|
|
static OutputPinTask* OutputPinAsync_AllocTask( enum OutputPinTaskType tasktype )
|
|
{
|
|
OutputPinTask* pTask;
|
|
|
|
pTask = (OutputPinTask*)QUARTZ_AllocMem( sizeof(OutputPinTask) );
|
|
pTask->pNext = NULL;
|
|
pTask->tasktype = tasktype;
|
|
pTask->pSample = NULL;
|
|
|
|
return pTask;
|
|
}
|
|
|
|
static void OutputPinAsync_FreeTask( OutputPinTask* pTask )
|
|
{
|
|
if ( pTask->pSample != NULL )
|
|
IMediaSample_Release( pTask->pSample );
|
|
QUARTZ_FreeMem( pTask );
|
|
}
|
|
|
|
static void OutputPinAsync_AddTask( OutputPinAsyncImpl* This, OutputPinTask* pTask, BOOL bFirst )
|
|
{
|
|
EnterCriticalSection( &This->m_csTasks );
|
|
|
|
if ( bFirst )
|
|
{
|
|
pTask->pNext = This->m_pFirst;
|
|
This->m_pFirst = pTask;
|
|
if ( This->m_pLast == NULL )
|
|
This->m_pLast = pTask;
|
|
}
|
|
else
|
|
{
|
|
if ( This->m_pLast != NULL )
|
|
This->m_pLast->pNext = pTask;
|
|
else
|
|
This->m_pFirst = pTask;
|
|
This->m_pLast = pTask;
|
|
}
|
|
|
|
LeaveCriticalSection( &This->m_csTasks );
|
|
|
|
SetEvent( This->m_hTaskEvent );
|
|
}
|
|
|
|
static OutputPinTask* OutputPinAsync_GetNextTask( OutputPinAsyncImpl* This )
|
|
{
|
|
OutputPinTask* pTask;
|
|
|
|
EnterCriticalSection( &This->m_csTasks );
|
|
pTask = This->m_pFirst;
|
|
if ( pTask != NULL )
|
|
{
|
|
This->m_pFirst = pTask->pNext;
|
|
if ( This->m_pFirst == NULL )
|
|
This->m_pLast = NULL;
|
|
else
|
|
SetEvent( This->m_hTaskEvent );
|
|
}
|
|
|
|
LeaveCriticalSection( &This->m_csTasks );
|
|
|
|
return pTask;
|
|
}
|
|
|
|
static DWORD WINAPI OutputPinAsync_ThreadEntry( LPVOID pv )
|
|
{
|
|
OutputPinAsyncImpl* This = ((CPinBaseImpl*)pv)->pAsyncOut;
|
|
OutputPinTask* pTask;
|
|
BOOL bLoop = TRUE;
|
|
BOOL bInFlush = FALSE;
|
|
HRESULT hr;
|
|
|
|
while ( bLoop )
|
|
{
|
|
WaitForSingleObject( This->m_hTaskEvent, INFINITE );
|
|
ResetEvent( This->m_hTaskEvent );
|
|
|
|
pTask = OutputPinAsync_GetNextTask( This );
|
|
if ( pTask == NULL )
|
|
continue;
|
|
|
|
hr = S_OK;
|
|
switch ( pTask->tasktype )
|
|
{
|
|
case OutTask_ExitThread:
|
|
bLoop = FALSE;
|
|
break;
|
|
case OutTask_Receive:
|
|
if ( !bInFlush )
|
|
hr = IMemInputPin_Receive( This->m_pMemInputPin, pTask->pSample );
|
|
break;
|
|
case OutTask_EndOfStream:
|
|
hr = IPin_EndOfStream( This->m_pPin );
|
|
break;
|
|
case OutTask_BeginFlush:
|
|
bInFlush = TRUE;
|
|
hr = IPin_BeginFlush( This->m_pPin );
|
|
break;
|
|
case OutTask_EndFlush:
|
|
bInFlush = FALSE;
|
|
hr = IPin_EndFlush( This->m_pPin );
|
|
break;
|
|
case OutTask_NewSegment:
|
|
hr = IPin_NewSegment( This->m_pPin, pTask->rtStart, pTask->rtStop, pTask->rate );
|
|
break;
|
|
default:
|
|
ERR( "unexpected task type %d.\n", pTask->tasktype );
|
|
bLoop = FALSE;
|
|
break;
|
|
}
|
|
|
|
OutputPinAsync_FreeTask( pTask );
|
|
|
|
if ( FAILED(hr) )
|
|
{
|
|
ERR( "hresult %08lx\n", hr );
|
|
bLoop = FALSE;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
HRESULT OutputPinAsync_OnActive( CPinBaseImpl* pImpl )
|
|
{
|
|
HRESULT hr;
|
|
DWORD dwThreadId;
|
|
|
|
FIXME("(%p)\n",pImpl);
|
|
|
|
if ( pImpl->pMemInputPinConnectedTo == NULL )
|
|
return NOERROR;
|
|
|
|
pImpl->pAsyncOut = (OutputPinAsyncImpl*)
|
|
QUARTZ_AllocMem( sizeof( OutputPinAsyncImpl ) );
|
|
if ( pImpl->pAsyncOut == NULL )
|
|
return E_OUTOFMEMORY;
|
|
|
|
InitializeCriticalSection( &pImpl->pAsyncOut->m_csTasks );
|
|
pImpl->pAsyncOut->m_hTaskThread = (HANDLE)NULL;
|
|
pImpl->pAsyncOut->m_hTaskEvent = (HANDLE)NULL;
|
|
pImpl->pAsyncOut->m_pFirst = NULL;
|
|
pImpl->pAsyncOut->m_pLast = NULL;
|
|
pImpl->pAsyncOut->m_pTaskExitThread = NULL;
|
|
pImpl->pAsyncOut->m_pPin = pImpl->pPinConnectedTo;
|
|
pImpl->pAsyncOut->m_pMemInputPin = pImpl->pMemInputPinConnectedTo;
|
|
|
|
pImpl->pAsyncOut->m_hTaskEvent =
|
|
CreateEventA( NULL, TRUE, FALSE, NULL );
|
|
if ( pImpl->pAsyncOut->m_hTaskEvent == (HANDLE)NULL )
|
|
{
|
|
hr = E_FAIL;
|
|
goto err;
|
|
}
|
|
|
|
pImpl->pAsyncOut->m_pTaskExitThread =
|
|
OutputPinAsync_AllocTask( OutTask_ExitThread );
|
|
if ( pImpl->pAsyncOut->m_pTaskExitThread == NULL )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto err;
|
|
}
|
|
|
|
pImpl->pAsyncOut->m_hTaskThread = CreateThread(
|
|
NULL, 0, OutputPinAsync_ThreadEntry, pImpl,
|
|
0, &dwThreadId );
|
|
if ( pImpl->pAsyncOut->m_hTaskThread == (HANDLE)NULL )
|
|
{
|
|
hr = E_FAIL;
|
|
goto err;
|
|
}
|
|
|
|
return NOERROR;
|
|
err:
|
|
OutputPinAsync_OnInactive( pImpl );
|
|
return hr;
|
|
}
|
|
|
|
HRESULT OutputPinAsync_OnInactive( CPinBaseImpl* pImpl )
|
|
{
|
|
OutputPinTask* pTask;
|
|
|
|
FIXME("(%p)\n",pImpl);
|
|
|
|
if ( pImpl->pAsyncOut == NULL )
|
|
return NOERROR;
|
|
|
|
if ( pImpl->pAsyncOut->m_pTaskExitThread != NULL )
|
|
{
|
|
OutputPinAsync_AddTask( pImpl->pAsyncOut, pImpl->pAsyncOut->m_pTaskExitThread, TRUE );
|
|
pImpl->pAsyncOut->m_pTaskExitThread = NULL;
|
|
}
|
|
|
|
if ( pImpl->pAsyncOut->m_hTaskThread != (HANDLE)NULL )
|
|
{
|
|
WaitForSingleObject( pImpl->pAsyncOut->m_hTaskThread, INFINITE );
|
|
CloseHandle( pImpl->pAsyncOut->m_hTaskThread );
|
|
}
|
|
if ( pImpl->pAsyncOut->m_hTaskEvent != (HANDLE)NULL )
|
|
CloseHandle( pImpl->pAsyncOut->m_hTaskEvent );
|
|
|
|
/* release all tasks. */
|
|
while ( 1 )
|
|
{
|
|
pTask = OutputPinAsync_GetNextTask( pImpl->pAsyncOut );
|
|
if ( pTask == NULL )
|
|
break;
|
|
OutputPinAsync_FreeTask( pTask );
|
|
}
|
|
|
|
DeleteCriticalSection( &pImpl->pAsyncOut->m_csTasks );
|
|
|
|
QUARTZ_FreeMem( pImpl->pAsyncOut );
|
|
pImpl->pAsyncOut = NULL;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT OutputPinAsync_Receive( CPinBaseImpl* pImpl, IMediaSample* pSample )
|
|
{
|
|
OutputPinAsyncImpl* This = pImpl->pAsyncOut;
|
|
OutputPinTask* pTask;
|
|
|
|
TRACE("(%p,%p)\n",pImpl,pSample);
|
|
|
|
if ( This == NULL )
|
|
return NOERROR;
|
|
|
|
pTask = OutputPinAsync_AllocTask( OutTask_Receive );
|
|
if ( pTask == NULL )
|
|
return E_OUTOFMEMORY;
|
|
pTask->pSample = pSample; IMediaSample_AddRef( pSample );
|
|
OutputPinAsync_AddTask( pImpl->pAsyncOut, pTask, FALSE );
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT OutputPinAsync_ReceiveCanBlock( CPinBaseImpl* pImpl )
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
HRESULT OutputPinAsync_EndOfStream( CPinBaseImpl* pImpl )
|
|
{
|
|
OutputPinAsyncImpl* This = pImpl->pAsyncOut;
|
|
OutputPinTask* pTask;
|
|
|
|
TRACE("(%p)\n",pImpl);
|
|
|
|
if ( This == NULL )
|
|
return NOERROR;
|
|
|
|
pTask = OutputPinAsync_AllocTask( OutTask_EndOfStream );
|
|
if ( pTask == NULL )
|
|
return E_OUTOFMEMORY;
|
|
OutputPinAsync_AddTask( pImpl->pAsyncOut, pTask, FALSE );
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT OutputPinAsync_BeginFlush( CPinBaseImpl* pImpl )
|
|
{
|
|
OutputPinAsyncImpl* This = pImpl->pAsyncOut;
|
|
OutputPinTask* pTask;
|
|
|
|
TRACE("(%p)\n",pImpl);
|
|
|
|
if ( This == NULL )
|
|
return NOERROR;
|
|
|
|
pTask = OutputPinAsync_AllocTask( OutTask_BeginFlush );
|
|
if ( pTask == NULL )
|
|
return E_OUTOFMEMORY;
|
|
OutputPinAsync_AddTask( pImpl->pAsyncOut, pTask, TRUE );
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT OutputPinAsync_EndFlush( CPinBaseImpl* pImpl )
|
|
{
|
|
OutputPinAsyncImpl* This = pImpl->pAsyncOut;
|
|
OutputPinTask* pTask;
|
|
|
|
TRACE("(%p)\n",pImpl);
|
|
|
|
if ( This == NULL )
|
|
return NOERROR;
|
|
|
|
pTask = OutputPinAsync_AllocTask( OutTask_EndFlush );
|
|
if ( pTask == NULL )
|
|
return E_OUTOFMEMORY;
|
|
OutputPinAsync_AddTask( pImpl->pAsyncOut, pTask, FALSE );
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT OutputPinAsync_NewSegment( CPinBaseImpl* pImpl, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop, double rate )
|
|
{
|
|
OutputPinAsyncImpl* This = pImpl->pAsyncOut;
|
|
OutputPinTask* pTask;
|
|
|
|
TRACE("(%p)\n",pImpl);
|
|
|
|
if ( This == NULL )
|
|
return NOERROR;
|
|
|
|
pTask = OutputPinAsync_AllocTask( OutTask_NewSegment );
|
|
if ( pTask == NULL )
|
|
return E_OUTOFMEMORY;
|
|
pTask->rtStart = rtStart;
|
|
pTask->rtStop = rtStop;
|
|
pTask->rate = rate;
|
|
OutputPinAsync_AddTask( pImpl->pAsyncOut, pTask, FALSE );
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|