/* * Parser (Base for parsers and splitters) * * Copyright 2003 Robert Shearman * Copyright 2004-2005 Christian Costa * * 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 "control_private.h" #include "pin.h" #include "vfwmsgs.h" #include "amvideo.h" #include "wine/unicode.h" #include "wine/debug.h" #include <math.h> #include <assert.h> #include "parser.h" WINE_DEFAULT_DEBUG_CHANNEL(quartz); static const WCHAR wcsInputPinName[] = {'i','n','p','u','t',' ','p','i','n',0}; static const IMediaSeekingVtbl Parser_Seeking_Vtbl; static const IPinVtbl Parser_OutputPin_Vtbl; static const IPinVtbl Parser_InputPin_Vtbl; static HRESULT Parser_OutputPin_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt); static HRESULT Parser_ChangeCurrent(IBaseFilter *iface); static HRESULT Parser_ChangeStop(IBaseFilter *iface); static HRESULT Parser_ChangeRate(IBaseFilter *iface); static inline ParserImpl *impl_from_IMediaSeeking( IMediaSeeking *iface ) { return (ParserImpl *)((char*)iface - FIELD_OFFSET(ParserImpl, mediaSeeking.lpVtbl)); } HRESULT Parser_Create(ParserImpl* pParser, const IBaseFilterVtbl *Parser_Vtbl, const CLSID* pClsid, PFN_PROCESS_SAMPLE fnProcessSample, PFN_QUERY_ACCEPT fnQueryAccept, PFN_PRE_CONNECT fnPreConnect, PFN_CLEANUP fnCleanup, PFN_DISCONNECT fnDisconnect, REQUESTPROC fnRequest, STOPPROCESSPROC fnDone, CHANGEPROC stop, CHANGEPROC current, CHANGEPROC rate) { HRESULT hr; PIN_INFO piInput; /* pTransformFilter is already allocated */ pParser->clsid = *pClsid; pParser->lpVtbl = Parser_Vtbl; pParser->refCount = 1; InitializeCriticalSection(&pParser->csFilter); pParser->csFilter.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ParserImpl.csFilter"); pParser->state = State_Stopped; pParser->pClock = NULL; pParser->fnDisconnect = fnDisconnect; ZeroMemory(&pParser->filterInfo, sizeof(FILTER_INFO)); pParser->lastpinchange = GetTickCount(); pParser->cStreams = 0; pParser->ppPins = CoTaskMemAlloc(1 * sizeof(IPin *)); /* construct input pin */ piInput.dir = PINDIR_INPUT; piInput.pFilter = (IBaseFilter *)pParser; lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0])); if (!current) current = Parser_ChangeCurrent; if (!stop) stop = Parser_ChangeStop; if (!rate) rate = Parser_ChangeRate; MediaSeekingImpl_Init((IBaseFilter*)pParser, stop, current, rate, &pParser->mediaSeeking, &pParser->csFilter); pParser->mediaSeeking.lpVtbl = &Parser_Seeking_Vtbl; hr = PullPin_Construct(&Parser_InputPin_Vtbl, &piInput, fnProcessSample, (LPVOID)pParser, fnQueryAccept, fnCleanup, fnRequest, fnDone, &pParser->csFilter, (IPin **)&pParser->pInputPin); if (SUCCEEDED(hr)) { pParser->ppPins[0] = (IPin *)pParser->pInputPin; pParser->pInputPin->fnPreConnect = fnPreConnect; } else { CoTaskMemFree(pParser->ppPins); pParser->csFilter.DebugInfo->Spare[0] = 0; DeleteCriticalSection(&pParser->csFilter); CoTaskMemFree(pParser); } return hr; } HRESULT WINAPI Parser_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv) { ParserImpl *This = (ParserImpl *)iface; TRACE("(%s, %p)\n", qzdebugstr_guid(riid), ppv); *ppv = NULL; if (IsEqualIID(riid, &IID_IUnknown)) *ppv = This; else if (IsEqualIID(riid, &IID_IPersist)) *ppv = This; else if (IsEqualIID(riid, &IID_IMediaFilter)) *ppv = This; else if (IsEqualIID(riid, &IID_IBaseFilter)) *ppv = This; else if (IsEqualIID(riid, &IID_IMediaSeeking)) *ppv = &This->mediaSeeking; if (*ppv) { IUnknown_AddRef((IUnknown *)(*ppv)); return S_OK; } if (!IsEqualIID(riid, &IID_IPin) && !IsEqualIID(riid, &IID_IVideoWindow)) FIXME("No interface for %s!\n", qzdebugstr_guid(riid)); return E_NOINTERFACE; } ULONG WINAPI Parser_AddRef(IBaseFilter * iface) { ParserImpl *This = (ParserImpl *)iface; ULONG refCount = InterlockedIncrement(&This->refCount); TRACE("(%p/%p)->() AddRef from %d\n", This, iface, refCount - 1); return refCount; } void Parser_Destroy(ParserImpl *This) { IPin *connected = NULL; ULONG pinref; assert(!This->refCount); PullPin_WaitForStateChange(This->pInputPin, INFINITE); if (This->pClock) IReferenceClock_Release(This->pClock); /* Don't need to clean up output pins, freeing input pin will do that */ IPin_ConnectedTo((IPin *)This->pInputPin, &connected); if (connected) { assert(IPin_Disconnect(connected) == S_OK); IPin_Release(connected); assert(IPin_Disconnect((IPin *)This->pInputPin) == S_OK); } pinref = IPin_Release((IPin *)This->pInputPin); if (pinref) { /* Valgrind could find this, if I kill it here */ ERR("pinref should be null, is %u, destroying anyway\n", pinref); assert((LONG)pinref > 0); while (pinref) pinref = IPin_Release((IPin *)This->pInputPin); } CoTaskMemFree(This->ppPins); This->lpVtbl = NULL; This->csFilter.DebugInfo->Spare[0] = 0; DeleteCriticalSection(&This->csFilter); TRACE("Destroying parser\n"); CoTaskMemFree(This); } ULONG WINAPI Parser_Release(IBaseFilter * iface) { ParserImpl *This = (ParserImpl *)iface; ULONG refCount = InterlockedDecrement(&This->refCount); TRACE("(%p)->() Release from %d\n", This, refCount + 1); if (!refCount) Parser_Destroy(This); return refCount; } /** IPersist methods **/ HRESULT WINAPI Parser_GetClassID(IBaseFilter * iface, CLSID * pClsid) { ParserImpl *This = (ParserImpl *)iface; TRACE("(%p)\n", pClsid); *pClsid = This->clsid; return S_OK; } /** IMediaFilter methods **/ HRESULT WINAPI Parser_Stop(IBaseFilter * iface) { ParserImpl *This = (ParserImpl *)iface; PullPin *pin = (PullPin *)This->ppPins[0]; ULONG i; TRACE("()\n"); EnterCriticalSection(&pin->thread_lock); IAsyncReader_BeginFlush(This->pInputPin->pReader); EnterCriticalSection(&This->csFilter); if (This->state == State_Stopped) { LeaveCriticalSection(&This->csFilter); IAsyncReader_EndFlush(This->pInputPin->pReader); LeaveCriticalSection(&pin->thread_lock); return S_OK; } This->state = State_Stopped; for (i = 1; i < (This->cStreams + 1); i++) { OutputPin_DecommitAllocator((OutputPin *)This->ppPins[i]); } LeaveCriticalSection(&This->csFilter); PullPin_PauseProcessing(This->pInputPin); PullPin_WaitForStateChange(This->pInputPin, INFINITE); IAsyncReader_EndFlush(This->pInputPin->pReader); LeaveCriticalSection(&pin->thread_lock); return S_OK; } HRESULT WINAPI Parser_Pause(IBaseFilter * iface) { HRESULT hr = S_OK; ParserImpl *This = (ParserImpl *)iface; PullPin *pin = (PullPin *)This->ppPins[0]; TRACE("()\n"); EnterCriticalSection(&pin->thread_lock); EnterCriticalSection(&This->csFilter); if (This->state == State_Paused) { LeaveCriticalSection(&This->csFilter); LeaveCriticalSection(&pin->thread_lock); return S_OK; } if (This->state == State_Stopped) { LeaveCriticalSection(&This->csFilter); hr = IBaseFilter_Run(iface, -1); EnterCriticalSection(&This->csFilter); } if (SUCCEEDED(hr)) This->state = State_Paused; LeaveCriticalSection(&This->csFilter); LeaveCriticalSection(&pin->thread_lock); return hr; } HRESULT WINAPI Parser_Run(IBaseFilter * iface, REFERENCE_TIME tStart) { HRESULT hr = S_OK; ParserImpl *This = (ParserImpl *)iface; PullPin *pin = (PullPin *)This->ppPins[0]; ULONG i; TRACE("(%s)\n", wine_dbgstr_longlong(tStart)); EnterCriticalSection(&pin->thread_lock); EnterCriticalSection(&This->csFilter); { HRESULT hr_any = VFW_E_NOT_CONNECTED; if (This->state == State_Running || This->state == State_Paused) { This->state = State_Running; LeaveCriticalSection(&This->csFilter); LeaveCriticalSection(&pin->thread_lock); return S_OK; } This->rtStreamStart = tStart; for (i = 1; i < (This->cStreams + 1); i++) { hr = OutputPin_CommitAllocator((OutputPin *)This->ppPins[i]); if (SUCCEEDED(hr)) hr_any = hr; } hr = hr_any; if (SUCCEEDED(hr)) { LeaveCriticalSection(&This->csFilter); hr = PullPin_StartProcessing(This->pInputPin); EnterCriticalSection(&This->csFilter); } if (SUCCEEDED(hr)) This->state = State_Running; } LeaveCriticalSection(&This->csFilter); LeaveCriticalSection(&pin->thread_lock); return hr; } HRESULT WINAPI Parser_GetState(IBaseFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState) { ParserImpl *This = (ParserImpl *)iface; PullPin *pin = (PullPin *)This->ppPins[0]; HRESULT hr = S_OK; TRACE("(%d, %p)\n", dwMilliSecsTimeout, pState); EnterCriticalSection(&pin->thread_lock); EnterCriticalSection(&This->csFilter); { *pState = This->state; } LeaveCriticalSection(&This->csFilter); if (This->pInputPin && (PullPin_WaitForStateChange(This->pInputPin, dwMilliSecsTimeout) == S_FALSE)) hr = VFW_S_STATE_INTERMEDIATE; LeaveCriticalSection(&pin->thread_lock); return hr; } HRESULT WINAPI Parser_SetSyncSource(IBaseFilter * iface, IReferenceClock *pClock) { ParserImpl *This = (ParserImpl *)iface; PullPin *pin = (PullPin *)This->ppPins[0]; TRACE("(%p)\n", pClock); EnterCriticalSection(&pin->thread_lock); EnterCriticalSection(&This->csFilter); { if (This->pClock) IReferenceClock_Release(This->pClock); This->pClock = pClock; if (This->pClock) IReferenceClock_AddRef(This->pClock); } LeaveCriticalSection(&This->csFilter); LeaveCriticalSection(&pin->thread_lock); return S_OK; } HRESULT WINAPI Parser_GetSyncSource(IBaseFilter * iface, IReferenceClock **ppClock) { ParserImpl *This = (ParserImpl *)iface; TRACE("(%p)\n", ppClock); EnterCriticalSection(&This->csFilter); { *ppClock = This->pClock; if (This->pClock) IReferenceClock_AddRef(This->pClock); } LeaveCriticalSection(&This->csFilter); return S_OK; } /** IBaseFilter implementation **/ /* FIXME: WRONG */ static HRESULT Parser_GetPin(IBaseFilter *iface, ULONG pos, IPin **pin, DWORD *lastsynctick) { ParserImpl *This = (ParserImpl *)iface; *lastsynctick = This->lastpinchange; TRACE("Asking for pos %x\n", pos); /* Input pin also has a pin, hence the > and not >= */ if (pos > This->cStreams) return S_FALSE; *pin = This->ppPins[pos]; IPin_AddRef(*pin); return S_OK; } HRESULT WINAPI Parser_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum) { ParserImpl *This = (ParserImpl *)iface; TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum); return IEnumPinsImpl_Construct(ppEnum, Parser_GetPin, iface); } HRESULT WINAPI Parser_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin) { FIXME("(%p)->(%s,%p)\n", iface, debugstr_w(Id), ppPin); /* FIXME: critical section */ return E_NOTIMPL; } HRESULT WINAPI Parser_QueryFilterInfo(IBaseFilter * iface, FILTER_INFO *pInfo) { ParserImpl *This = (ParserImpl *)iface; TRACE("(%p)\n", pInfo); strcpyW(pInfo->achName, This->filterInfo.achName); pInfo->pGraph = This->filterInfo.pGraph; if (pInfo->pGraph) IFilterGraph_AddRef(pInfo->pGraph); return S_OK; } HRESULT WINAPI Parser_JoinFilterGraph(IBaseFilter * iface, IFilterGraph *pGraph, LPCWSTR pName) { HRESULT hr = S_OK; ParserImpl *This = (ParserImpl *)iface; TRACE("(%p, %s)\n", pGraph, debugstr_w(pName)); EnterCriticalSection(&This->csFilter); { if (pName) strcpyW(This->filterInfo.achName, pName); else *This->filterInfo.achName = '\0'; This->filterInfo.pGraph = pGraph; /* NOTE: do NOT increase ref. count */ } LeaveCriticalSection(&This->csFilter); return hr; } HRESULT WINAPI Parser_QueryVendorInfo(IBaseFilter * iface, LPWSTR *pVendorInfo) { TRACE("(%p)\n", pVendorInfo); return E_NOTIMPL; } HRESULT Parser_AddPin(ParserImpl * This, const PIN_INFO * piOutput, ALLOCATOR_PROPERTIES * props, const AM_MEDIA_TYPE * amt) { IPin ** ppOldPins; HRESULT hr; ppOldPins = This->ppPins; This->ppPins = CoTaskMemAlloc((This->cStreams + 2) * sizeof(IPin *)); memcpy(This->ppPins, ppOldPins, (This->cStreams + 1) * sizeof(IPin *)); hr = OutputPin_Construct(&Parser_OutputPin_Vtbl, sizeof(Parser_OutputPin), piOutput, props, NULL, Parser_OutputPin_QueryAccept, &This->csFilter, This->ppPins + (This->cStreams + 1)); if (SUCCEEDED(hr)) { IPin *pPin = This->ppPins[This->cStreams + 1]; Parser_OutputPin *pin = (Parser_OutputPin *)pPin; pin->pmt = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE)); CopyMediaType(pin->pmt, amt); pin->dwSamplesProcessed = 0; pin->pin.pin.pUserData = This->ppPins[This->cStreams + 1]; pin->pin.pin.pinInfo.pFilter = (LPVOID)This; pin->pin.custom_allocator = 1; This->cStreams++; This->lastpinchange = GetTickCount(); CoTaskMemFree(ppOldPins); } else { CoTaskMemFree(This->ppPins); This->ppPins = ppOldPins; ERR("Failed with error %x\n", hr); } return hr; } static HRESULT Parser_RemoveOutputPins(ParserImpl * This) { /* NOTE: should be in critical section when calling this function */ HRESULT hr; ULONG i; IPin ** ppOldPins = This->ppPins; TRACE("(%p)\n", This); /* reduce the pin array down to 1 (just our input pin) */ This->ppPins = CoTaskMemAlloc(sizeof(IPin *) * 1); memcpy(This->ppPins, ppOldPins, sizeof(IPin *) * 1); for (i = 0; i < This->cStreams; i++) { hr = OutputPin_DeliverDisconnect((OutputPin *)ppOldPins[i + 1]); TRACE("Disconnect: %08x\n", hr); IPin_Release(ppOldPins[i + 1]); } This->lastpinchange = GetTickCount(); This->cStreams = 0; CoTaskMemFree(ppOldPins); return S_OK; } static HRESULT Parser_ChangeCurrent(IBaseFilter *iface) { FIXME("(%p) filter hasn't implemented current position change!\n", iface); return S_OK; } static HRESULT Parser_ChangeStop(IBaseFilter *iface) { FIXME("(%p) filter hasn't implemented stop position change!\n", iface); return S_OK; } static HRESULT Parser_ChangeRate(IBaseFilter *iface) { FIXME("(%p) filter hasn't implemented rate change!\n", iface); return S_OK; } static HRESULT WINAPI Parser_Seeking_QueryInterface(IMediaSeeking * iface, REFIID riid, LPVOID * ppv) { ParserImpl *This = impl_from_IMediaSeeking(iface); return IUnknown_QueryInterface((IUnknown *)This, riid, ppv); } static ULONG WINAPI Parser_Seeking_AddRef(IMediaSeeking * iface) { ParserImpl *This = impl_from_IMediaSeeking(iface); return IUnknown_AddRef((IUnknown *)This); } static ULONG WINAPI Parser_Seeking_Release(IMediaSeeking * iface) { ParserImpl *This = impl_from_IMediaSeeking(iface); return IUnknown_Release((IUnknown *)This); } static const IMediaSeekingVtbl Parser_Seeking_Vtbl = { Parser_Seeking_QueryInterface, Parser_Seeking_AddRef, Parser_Seeking_Release, MediaSeekingImpl_GetCapabilities, MediaSeekingImpl_CheckCapabilities, MediaSeekingImpl_IsFormatSupported, MediaSeekingImpl_QueryPreferredFormat, MediaSeekingImpl_GetTimeFormat, MediaSeekingImpl_IsUsingTimeFormat, MediaSeekingImpl_SetTimeFormat, MediaSeekingImpl_GetDuration, MediaSeekingImpl_GetStopPosition, MediaSeekingImpl_GetCurrentPosition, MediaSeekingImpl_ConvertTimeFormat, MediaSeekingImpl_SetPositions, MediaSeekingImpl_GetPositions, MediaSeekingImpl_GetAvailable, MediaSeekingImpl_SetRate, MediaSeekingImpl_GetRate, MediaSeekingImpl_GetPreroll }; static HRESULT WINAPI Parser_OutputPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv) { Parser_OutputPin *This = (Parser_OutputPin *)iface; TRACE("(%s, %p)\n", qzdebugstr_guid(riid), ppv); *ppv = NULL; if (IsEqualIID(riid, &IID_IUnknown)) *ppv = iface; else if (IsEqualIID(riid, &IID_IPin)) *ppv = iface; else if (IsEqualIID(riid, &IID_IMediaSeeking)) { return IBaseFilter_QueryInterface(This->pin.pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv); } if (*ppv) { IUnknown_AddRef((IUnknown *)(*ppv)); return S_OK; } FIXME("No interface for %s!\n", qzdebugstr_guid(riid)); return E_NOINTERFACE; } static ULONG WINAPI Parser_OutputPin_Release(IPin * iface) { Parser_OutputPin *This = (Parser_OutputPin *)iface; ULONG refCount = InterlockedDecrement(&This->pin.pin.refCount); TRACE("(%p)->() Release from %d\n", iface, refCount + 1); if (!refCount) { FreeMediaType(This->pmt); CoTaskMemFree(This->pmt); FreeMediaType(&This->pin.pin.mtCurrent); CoTaskMemFree(This); return 0; } return refCount; } static HRESULT WINAPI Parser_OutputPin_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum) { ENUMMEDIADETAILS emd; Parser_OutputPin *This = (Parser_OutputPin *)iface; TRACE("(%p)\n", ppEnum); /* override this method to allow enumeration of your types */ emd.cMediaTypes = 1; emd.pMediaTypes = This->pmt; return IEnumMediaTypesImpl_Construct(&emd, ppEnum); } static HRESULT WINAPI Parser_OutputPin_Connect(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt) { Parser_OutputPin *This = (Parser_OutputPin *)iface; ParserImpl *parser = (ParserImpl *)This->pin.pin.pinInfo.pFilter; /* Set the allocator to our input pin's */ EnterCriticalSection(This->pin.pin.pCritSec); This->pin.alloc = parser->pInputPin->pAlloc; LeaveCriticalSection(This->pin.pin.pCritSec); return OutputPin_Connect(iface, pReceivePin, pmt); } static HRESULT Parser_OutputPin_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt) { Parser_OutputPin *This = iface; TRACE("()\n"); dump_AM_MEDIA_TYPE(pmt); return (memcmp(This->pmt, pmt, sizeof(AM_MEDIA_TYPE)) == 0); } static const IPinVtbl Parser_OutputPin_Vtbl = { Parser_OutputPin_QueryInterface, IPinImpl_AddRef, Parser_OutputPin_Release, Parser_OutputPin_Connect, OutputPin_ReceiveConnection, OutputPin_Disconnect, IPinImpl_ConnectedTo, IPinImpl_ConnectionMediaType, IPinImpl_QueryPinInfo, IPinImpl_QueryDirection, IPinImpl_QueryId, IPinImpl_QueryAccept, Parser_OutputPin_EnumMediaTypes, IPinImpl_QueryInternalConnections, OutputPin_EndOfStream, OutputPin_BeginFlush, OutputPin_EndFlush, OutputPin_NewSegment }; static HRESULT WINAPI Parser_PullPin_Disconnect(IPin * iface) { HRESULT hr; PullPin *This = (PullPin *)iface; TRACE("()\n"); EnterCriticalSection(&This->thread_lock); EnterCriticalSection(This->pin.pCritSec); { if (This->pin.pConnectedTo) { FILTER_STATE state; ParserImpl *Parser = (ParserImpl *)This->pin.pinInfo.pFilter; LeaveCriticalSection(This->pin.pCritSec); hr = IBaseFilter_GetState(This->pin.pinInfo.pFilter, INFINITE, &state); EnterCriticalSection(This->pin.pCritSec); if (SUCCEEDED(hr) && (state == State_Stopped) && SUCCEEDED(Parser->fnDisconnect(Parser))) { LeaveCriticalSection(This->pin.pCritSec); PullPin_Disconnect(iface); EnterCriticalSection(This->pin.pCritSec); hr = Parser_RemoveOutputPins((ParserImpl *)This->pin.pinInfo.pFilter); } else hr = VFW_E_NOT_STOPPED; } else hr = S_FALSE; } LeaveCriticalSection(This->pin.pCritSec); LeaveCriticalSection(&This->thread_lock); return hr; } static HRESULT WINAPI Parser_PullPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt) { HRESULT hr; TRACE("()\n"); hr = PullPin_ReceiveConnection(iface, pReceivePin, pmt); if (FAILED(hr)) { IPinImpl *This = (IPinImpl *)iface; EnterCriticalSection(This->pCritSec); Parser_RemoveOutputPins((ParserImpl *)This->pinInfo.pFilter); LeaveCriticalSection(This->pCritSec); } return hr; } static const IPinVtbl Parser_InputPin_Vtbl = { PullPin_QueryInterface, IPinImpl_AddRef, PullPin_Release, InputPin_Connect, Parser_PullPin_ReceiveConnection, Parser_PullPin_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 };