2 * Generic Implementation of IPin Interface
4 * Copyright 2003 Robert Shearman
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #include "quartz_private.h"
24 #include "wine/debug.h"
25 #include "wine/unicode.h"
30 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
32 static const IPinVtbl PullPin_Vtbl;
34 #define ALIGNDOWN(value,boundary) ((value)/(boundary)*(boundary))
35 #define ALIGNUP(value,boundary) (ALIGNDOWN((value)+(boundary)-1, (boundary)))
37 typedef HRESULT (*SendPinFunc)( IPin *to, LPVOID arg );
39 /** Helper function, there are a lot of places where the error code is inherited
40 * The following rules apply:
42 * Return the first received error code (E_NOTIMPL is ignored)
43 * If no errors occur: return the first received non-error-code that isn't S_OK
45 static HRESULT updatehres( HRESULT original, HRESULT new )
47 if (FAILED( original ) || new == E_NOTIMPL)
50 if (FAILED( new ) || original == S_OK)
56 /** Sends a message from a pin further to other, similar pins
57 * fnMiddle is called on each pin found further on the stream.
58 * fnEnd (can be NULL) is called when the message can't be sent any further (this is a renderer or source)
60 * If the pin given is an input pin, the message will be sent downstream to other input pins
61 * If the pin given is an output pin, the message will be sent upstream to other output pins
63 static HRESULT SendFurther( IPin *from, SendPinFunc fnMiddle, LPVOID arg, SendPinFunc fnEnd )
68 HRESULT hr_return = S_OK;
69 IEnumPins *enumpins = NULL;
71 PIN_DIRECTION from_dir;
73 IPin_QueryDirection( from, &from_dir );
75 hr = IPin_QueryInternalConnections( from, NULL, &amount );
76 if (hr != E_NOTIMPL && amount)
77 FIXME("Use QueryInternalConnections!\n");
80 pin_info.pFilter = NULL;
81 hr = IPin_QueryPinInfo( from, &pin_info );
85 hr = IBaseFilter_EnumPins( pin_info.pFilter, &enumpins );
89 hr = IEnumPins_Reset( enumpins );
92 hr = IEnumPins_Next( enumpins, 1, &pin, NULL );
93 if (hr == VFW_E_ENUM_OUT_OF_SYNC)
95 hr = IEnumPins_Reset( enumpins );
102 IPin_QueryDirection( pin, &dir );
105 IPin *connected = NULL;
108 IPin_ConnectedTo( pin, &connected );
113 hr_local = fnMiddle( connected, arg );
114 hr_return = updatehres( hr_return, hr_local );
115 IPin_Release(connected);
132 hr_local = fnEnd( from, arg );
133 hr_return = updatehres( hr_return, hr_local );
137 if (pin_info.pFilter)
138 IBaseFilter_Release( pin_info.pFilter );
143 static void Copy_PinInfo(PIN_INFO * pDest, const PIN_INFO * pSrc)
145 /* Tempting to just do a memcpy, but the name field is
146 128 characters long! We will probably never exceed 10
147 most of the time, so we are better off copying
148 each field manually */
149 strcpyW(pDest->achName, pSrc->achName);
150 pDest->dir = pSrc->dir;
151 pDest->pFilter = pSrc->pFilter;
154 static HRESULT deliver_endofstream(IPin* pin, LPVOID unused)
156 return IPin_EndOfStream( pin );
159 static HRESULT deliver_beginflush(IPin* pin, LPVOID unused)
161 return IPin_BeginFlush( pin );
164 static HRESULT deliver_endflush(IPin* pin, LPVOID unused)
166 return IPin_EndFlush( pin );
169 typedef struct newsegmentargs
171 REFERENCE_TIME tStart, tStop;
175 static HRESULT deliver_newsegment(IPin *pin, LPVOID data)
177 newsegmentargs *args = data;
178 return IPin_NewSegment(pin, args->tStart, args->tStop, args->rate);
181 /*** PullPin implementation ***/
183 static HRESULT PullPin_Init(const IPinVtbl *PullPin_Vtbl, const PIN_INFO * pPinInfo, SAMPLEPROC_PULL pSampleProc, LPVOID pUserData,
184 QUERYACCEPTPROC pQueryAccept, CLEANUPPROC pCleanUp, REQUESTPROC pCustomRequest, STOPPROCESSPROC pDone, LPCRITICAL_SECTION pCritSec, PullPin * pPinImpl)
186 /* Common attributes */
187 pPinImpl->pin.lpVtbl = PullPin_Vtbl;
188 pPinImpl->pin.refCount = 1;
189 pPinImpl->pin.pConnectedTo = NULL;
190 pPinImpl->pin.pCritSec = pCritSec;
191 Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
192 ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE));
194 /* Input pin attributes */
195 pPinImpl->pUserData = pUserData;
196 pPinImpl->fnQueryAccept = pQueryAccept;
197 pPinImpl->fnSampleProc = pSampleProc;
198 pPinImpl->fnCleanProc = pCleanUp;
199 pPinImpl->fnDone = pDone;
200 pPinImpl->fnPreConnect = NULL;
201 pPinImpl->pAlloc = NULL;
202 pPinImpl->prefAlloc = NULL;
203 pPinImpl->pReader = NULL;
204 pPinImpl->hThread = NULL;
205 pPinImpl->hEventStateChanged = CreateEventW(NULL, TRUE, TRUE, NULL);
206 pPinImpl->thread_sleepy = CreateEventW(NULL, FALSE, FALSE, NULL);
208 pPinImpl->rtStart = 0;
209 pPinImpl->rtCurrent = 0;
210 pPinImpl->rtStop = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
211 pPinImpl->dRate = 1.0;
212 pPinImpl->state = Req_Die;
213 pPinImpl->fnCustomRequest = pCustomRequest;
214 pPinImpl->stop_playback = 1;
216 InitializeCriticalSection(&pPinImpl->thread_lock);
217 pPinImpl->thread_lock.DebugInfo->Spare[0] = (DWORD_PTR)( __FILE__ ": PullPin.thread_lock");
222 HRESULT PullPin_Construct(const IPinVtbl *PullPin_Vtbl, const PIN_INFO * pPinInfo, SAMPLEPROC_PULL pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, CLEANUPPROC pCleanUp, REQUESTPROC pCustomRequest, STOPPROCESSPROC pDone, LPCRITICAL_SECTION pCritSec, IPin ** ppPin)
228 if (pPinInfo->dir != PINDIR_INPUT)
230 ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir);
234 pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl));
237 return E_OUTOFMEMORY;
239 if (SUCCEEDED(PullPin_Init(PullPin_Vtbl, pPinInfo, pSampleProc, pUserData, pQueryAccept, pCleanUp, pCustomRequest, pDone, pCritSec, pPinImpl)))
241 *ppPin = (IPin *)(&pPinImpl->pin.lpVtbl);
245 CoTaskMemFree(pPinImpl);
249 static HRESULT PullPin_InitProcessing(PullPin * This);
251 HRESULT WINAPI PullPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
253 PIN_DIRECTION pindirReceive;
255 PullPin *This = (PullPin *)iface;
257 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt);
258 dump_AM_MEDIA_TYPE(pmt);
260 EnterCriticalSection(This->pin.pCritSec);
261 if (!This->pin.pConnectedTo)
263 ALLOCATOR_PROPERTIES props;
266 props.cbBuffer = 64 * 1024; /* 64k bytes */
270 if (SUCCEEDED(hr) && (This->fnQueryAccept(This->pUserData, pmt) != S_OK))
271 hr = VFW_E_TYPE_NOT_ACCEPTED; /* FIXME: shouldn't we just map common errors onto
272 * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */
276 IPin_QueryDirection(pReceivePin, &pindirReceive);
278 if (pindirReceive != PINDIR_OUTPUT)
280 ERR("Can't connect from non-output pin\n");
281 hr = VFW_E_INVALID_DIRECTION;
285 This->pReader = NULL;
287 This->prefAlloc = NULL;
290 hr = IPin_QueryInterface(pReceivePin, &IID_IAsyncReader, (LPVOID *)&This->pReader);
293 if (SUCCEEDED(hr) && This->fnPreConnect)
295 hr = This->fnPreConnect(iface, pReceivePin, &props);
299 * Some custom filters (such as the one used by Fallout 3
300 * and Fallout: New Vegas) expect to be passed a non-NULL
301 * preferred allocator.
305 hr = StdMemAllocator_create(NULL, (LPVOID *) &This->prefAlloc);
310 hr = IAsyncReader_RequestAllocator(This->pReader, This->prefAlloc, &props, &This->pAlloc);
315 CopyMediaType(&This->pin.mtCurrent, pmt);
316 This->pin.pConnectedTo = pReceivePin;
317 IPin_AddRef(pReceivePin);
318 hr = IMemAllocator_Commit(This->pAlloc);
322 hr = PullPin_InitProcessing(This);
327 IAsyncReader_Release(This->pReader);
328 This->pReader = NULL;
330 IMemAllocator_Release(This->prefAlloc);
331 This->prefAlloc = NULL;
333 IMemAllocator_Release(This->pAlloc);
338 hr = VFW_E_ALREADY_CONNECTED;
339 LeaveCriticalSection(This->pin.pCritSec);
343 HRESULT WINAPI PullPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
345 PullPin *This = (PullPin *)iface;
347 TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
351 if (IsEqualIID(riid, &IID_IUnknown))
353 else if (IsEqualIID(riid, &IID_IPin))
355 else if (IsEqualIID(riid, &IID_IMediaSeeking) ||
356 IsEqualIID(riid, &IID_IQualityControl))
358 return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, riid, ppv);
363 IUnknown_AddRef((IUnknown *)(*ppv));
367 FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
369 return E_NOINTERFACE;
372 ULONG WINAPI PullPin_Release(IPin *iface)
374 PullPin *This = (PullPin *)iface;
375 ULONG refCount = InterlockedDecrement(&This->pin.refCount);
377 TRACE("(%p)->() Release from %d\n", This, refCount + 1);
381 WaitForSingleObject(This->hEventStateChanged, INFINITE);
382 assert(!This->hThread);
385 IMemAllocator_Release(This->prefAlloc);
387 IMemAllocator_Release(This->pAlloc);
389 IAsyncReader_Release(This->pReader);
390 CloseHandle(This->thread_sleepy);
391 CloseHandle(This->hEventStateChanged);
392 This->thread_lock.DebugInfo->Spare[0] = 0;
393 DeleteCriticalSection(&This->thread_lock);
400 static void PullPin_Flush(PullPin *This)
402 IMediaSample *pSample;
403 TRACE("Flushing!\n");
407 /* Do not allow state to change while flushing */
408 EnterCriticalSection(This->pin.pCritSec);
410 /* Flush outstanding samples */
411 IAsyncReader_BeginFlush(This->pReader);
417 IAsyncReader_WaitForNext(This->pReader, 0, &pSample, &dwUser);
422 assert(!IMediaSample_GetActualDataLength(pSample));
424 IMediaSample_Release(pSample);
427 IAsyncReader_EndFlush(This->pReader);
429 LeaveCriticalSection(This->pin.pCritSec);
433 static void PullPin_Thread_Process(PullPin *This)
436 IMediaSample * pSample = NULL;
437 ALLOCATOR_PROPERTIES allocProps;
439 hr = IMemAllocator_GetProperties(This->pAlloc, &allocProps);
441 This->cbAlign = allocProps.cbAlign;
443 if (This->rtCurrent < This->rtStart)
444 This->rtCurrent = MEDIATIME_FROM_BYTES(ALIGNDOWN(BYTES_FROM_MEDIATIME(This->rtStart), This->cbAlign));
448 if (This->rtCurrent >= This->rtStop)
450 IPin_EndOfStream((IPin *)This);
454 /* There is no sample in our buffer */
455 hr = This->fnCustomRequest(This->pUserData);
458 ERR("Request error: %x\n", hr);
460 EnterCriticalSection(This->pin.pCritSec);
461 SetEvent(This->hEventStateChanged);
462 LeaveCriticalSection(This->pin.pCritSec);
469 TRACE("Process sample\n");
472 hr = IAsyncReader_WaitForNext(This->pReader, 10000, &pSample, &dwUser);
474 /* Return an empty sample on error to the implementation in case it does custom parsing, so it knows it's gone */
477 hr = This->fnSampleProc(This->pUserData, pSample, dwUser);
481 /* FIXME: This is not well handled yet! */
482 ERR("Processing error: %x\n", hr);
483 if (hr == VFW_E_TIMEOUT)
493 IMediaSample_Release(pSample);
496 } while (This->rtCurrent < This->rtStop && hr == S_OK && !This->stop_playback);
499 * Sample was rejected, and we are asked to terminate. When there is more than one buffer
500 * it is possible for a filter to have several queued samples, making it necessary to
501 * release all of these pending samples.
503 if (This->stop_playback || FAILED(hr))
510 IMediaSample_Release(pSample);
512 IAsyncReader_WaitForNext(This->pReader, 0, &pSample, &dwUser);
516 /* Can't reset state to Sleepy here because that might race, instead PauseProcessing will do that for us
517 * Flush remaining samples
520 This->fnDone(This->pUserData);
522 TRACE("End: %08x, %d\n", hr, This->stop_playback);
525 static void PullPin_Thread_Pause(PullPin *This)
529 EnterCriticalSection(This->pin.pCritSec);
530 This->state = Req_Sleepy;
531 SetEvent(This->hEventStateChanged);
532 LeaveCriticalSection(This->pin.pCritSec);
535 static void PullPin_Thread_Stop(PullPin *This)
537 TRACE("(%p)->()\n", This);
539 EnterCriticalSection(This->pin.pCritSec);
541 CloseHandle(This->hThread);
542 This->hThread = NULL;
543 SetEvent(This->hEventStateChanged);
545 LeaveCriticalSection(This->pin.pCritSec);
547 IBaseFilter_Release(This->pin.pinInfo.pFilter);
553 static DWORD WINAPI PullPin_Thread_Main(LPVOID pv)
556 CoInitializeEx(NULL, COINIT_MULTITHREADED);
562 WaitForSingleObject(This->thread_sleepy, INFINITE);
564 TRACE("State: %d\n", This->state);
568 case Req_Die: PullPin_Thread_Stop(This); break;
569 case Req_Run: PullPin_Thread_Process(This); break;
570 case Req_Pause: PullPin_Thread_Pause(This); break;
571 case Req_Sleepy: ERR("Should not be signalled with SLEEPY!\n"); break;
572 default: ERR("Unknown state request: %d\n", This->state); break;
578 static HRESULT PullPin_InitProcessing(PullPin * This)
582 TRACE("(%p)->()\n", This);
584 /* if we are connected */
589 WaitForSingleObject(This->hEventStateChanged, INFINITE);
590 EnterCriticalSection(This->pin.pCritSec);
592 assert(!This->hThread);
593 assert(This->state == Req_Die);
594 assert(This->stop_playback);
595 assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
596 This->state = Req_Sleepy;
598 /* AddRef the filter to make sure it and it's pins will be around
599 * as long as the thread */
600 IBaseFilter_AddRef(This->pin.pinInfo.pFilter);
603 This->hThread = CreateThread(NULL, 0, PullPin_Thread_Main, This, 0, &dwThreadId);
606 hr = HRESULT_FROM_WIN32(GetLastError());
607 IBaseFilter_Release(This->pin.pinInfo.pFilter);
612 SetEvent(This->hEventStateChanged);
613 /* If assert fails, that means a command was not processed before the thread previously terminated */
615 LeaveCriticalSection(This->pin.pCritSec);
618 TRACE(" -- %x\n", hr);
623 HRESULT PullPin_StartProcessing(PullPin * This)
625 /* if we are connected */
626 TRACE("(%p)->()\n", This);
629 assert(This->hThread);
631 PullPin_WaitForStateChange(This, INFINITE);
633 assert(This->state == Req_Sleepy);
636 assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
637 This->state = Req_Run;
638 This->stop_playback = 0;
639 ResetEvent(This->hEventStateChanged);
640 SetEvent(This->thread_sleepy);
646 HRESULT PullPin_PauseProcessing(PullPin * This)
648 /* if we are connected */
649 TRACE("(%p)->()\n", This);
652 assert(This->hThread);
654 PullPin_WaitForStateChange(This, INFINITE);
656 EnterCriticalSection(This->pin.pCritSec);
658 assert(!This->stop_playback);
659 assert(This->state == Req_Run|| This->state == Req_Sleepy);
661 assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
663 This->state = Req_Pause;
664 This->stop_playback = 1;
665 ResetEvent(This->hEventStateChanged);
666 SetEvent(This->thread_sleepy);
668 /* Release any outstanding samples */
671 IMediaSample *pSample;
677 IAsyncReader_WaitForNext(This->pReader, 0, &pSample, &dwUser);
679 IMediaSample_Release(pSample);
683 LeaveCriticalSection(This->pin.pCritSec);
689 static HRESULT PullPin_StopProcessing(PullPin * This)
691 TRACE("(%p)->()\n", This);
693 /* if we are alive */
694 assert(This->hThread);
696 PullPin_WaitForStateChange(This, INFINITE);
698 assert(This->state == Req_Pause || This->state == Req_Sleepy);
700 This->stop_playback = 1;
701 This->state = Req_Die;
702 assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
703 ResetEvent(This->hEventStateChanged);
704 SetEvent(This->thread_sleepy);
708 HRESULT PullPin_WaitForStateChange(PullPin * This, DWORD dwMilliseconds)
710 if (WaitForSingleObject(This->hEventStateChanged, dwMilliseconds) == WAIT_TIMEOUT)
715 HRESULT WINAPI PullPin_QueryAccept(IPin * iface, const AM_MEDIA_TYPE * pmt)
717 PullPin *This = (PullPin *)iface;
719 TRACE("(%p/%p)->(%p)\n", This, iface, pmt);
721 return (This->fnQueryAccept(This->pUserData, pmt) == S_OK ? S_OK : S_FALSE);
724 HRESULT WINAPI PullPin_EndOfStream(IPin * iface)
726 FIXME("(%p)->() stub\n", iface);
728 return SendFurther( iface, deliver_endofstream, NULL, NULL );
731 HRESULT WINAPI PullPin_BeginFlush(IPin * iface)
733 PullPin *This = (PullPin *)iface;
734 TRACE("(%p)->()\n", This);
736 EnterCriticalSection(This->pin.pCritSec);
738 SendFurther( iface, deliver_beginflush, NULL, NULL );
740 LeaveCriticalSection(This->pin.pCritSec);
742 EnterCriticalSection(&This->thread_lock);
745 IAsyncReader_BeginFlush(This->pReader);
746 PullPin_WaitForStateChange(This, INFINITE);
748 if (This->hThread && This->state == Req_Run)
750 PullPin_PauseProcessing(This);
751 PullPin_WaitForStateChange(This, INFINITE);
754 LeaveCriticalSection(&This->thread_lock);
756 EnterCriticalSection(This->pin.pCritSec);
758 This->fnCleanProc(This->pUserData);
760 LeaveCriticalSection(This->pin.pCritSec);
765 HRESULT WINAPI PullPin_EndFlush(IPin * iface)
767 PullPin *This = (PullPin *)iface;
769 TRACE("(%p)->()\n", iface);
771 /* Send further first: Else a race condition might terminate processing early */
772 EnterCriticalSection(This->pin.pCritSec);
773 SendFurther( iface, deliver_endflush, NULL, NULL );
774 LeaveCriticalSection(This->pin.pCritSec);
776 EnterCriticalSection(&This->thread_lock);
781 IAsyncReader_EndFlush(This->pReader);
783 IBaseFilter_GetState(This->pin.pinInfo.pFilter, INFINITE, &state);
785 if (state != State_Stopped)
786 PullPin_StartProcessing(This);
788 PullPin_WaitForStateChange(This, INFINITE);
790 LeaveCriticalSection(&This->thread_lock);
795 HRESULT WINAPI PullPin_Disconnect(IPin *iface)
798 PullPin *This = (PullPin *)iface;
802 EnterCriticalSection(This->pin.pCritSec);
804 if (FAILED(hr = IMemAllocator_Decommit(This->pAlloc)))
805 ERR("Allocator decommit failed with error %x. Possible memory leak\n", hr);
807 if (This->pin.pConnectedTo)
809 IPin_Release(This->pin.pConnectedTo);
810 This->pin.pConnectedTo = NULL;
811 PullPin_StopProcessing(This);
813 FreeMediaType(&This->pin.mtCurrent);
814 ZeroMemory(&This->pin.mtCurrent, sizeof(This->pin.mtCurrent));
820 LeaveCriticalSection(This->pin.pCritSec);
825 HRESULT WINAPI PullPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
828 FIXME("(%p)->(%s, %s, %g) stub\n", iface, wine_dbgstr_longlong(tStart), wine_dbgstr_longlong(tStop), dRate);
830 args.tStart = tStart;
834 return SendFurther( iface, deliver_newsegment, &args, NULL );
837 static const IPinVtbl PullPin_Vtbl =
839 PullPin_QueryInterface,
842 BaseInputPinImpl_Connect,
843 PullPin_ReceiveConnection,
845 BasePinImpl_ConnectedTo,
846 BasePinImpl_ConnectionMediaType,
847 BasePinImpl_QueryPinInfo,
848 BasePinImpl_QueryDirection,
851 BasePinImpl_EnumMediaTypes,
852 BasePinImpl_QueryInternalConnections,