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 InputPin_Vtbl
;
33 static const IPinVtbl OutputPin_Vtbl
;
34 static const IMemInputPinVtbl MemInputPin_Vtbl
;
35 static const IPinVtbl PullPin_Vtbl
;
37 #define ALIGNDOWN(value,boundary) ((value)/(boundary)*(boundary))
38 #define ALIGNUP(value,boundary) (ALIGNDOWN((value)+(boundary)-1, (boundary)))
40 typedef HRESULT (*SendPinFunc
)( IPin
*to
, LPVOID arg
);
42 /** Helper function, there are a lot of places where the error code is inherited
43 * The following rules apply:
45 * Return the first received error code (E_NOTIMPL is ignored)
46 * If no errors occur: return the first received non-error-code that isn't S_OK
48 HRESULT
updatehres( HRESULT original
, HRESULT
new )
50 if (FAILED( original
) || new == E_NOTIMPL
)
53 if (FAILED( new ) || original
== S_OK
)
59 /** Sends a message from a pin further to other, similar pins
60 * fnMiddle is called on each pin found further on the stream.
61 * fnEnd (can be NULL) is called when the message can't be sent any further (this is a renderer or source)
63 * If the pin given is an input pin, the message will be sent downstream to other input pins
64 * If the pin given is an output pin, the message will be sent upstream to other output pins
66 static HRESULT
SendFurther( IPin
*from
, SendPinFunc fnMiddle
, LPVOID arg
, SendPinFunc fnEnd
)
71 HRESULT hr_return
= S_OK
;
72 IEnumPins
*enumpins
= NULL
;
74 PIN_DIRECTION from_dir
;
76 IPin_QueryDirection( from
, &from_dir
);
78 hr
= IPin_QueryInternalConnections( from
, NULL
, &amount
);
79 if (hr
!= E_NOTIMPL
&& amount
)
80 FIXME("Use QueryInternalConnections!\n");
83 pin_info
.pFilter
= NULL
;
84 hr
= IPin_QueryPinInfo( from
, &pin_info
);
88 hr
= IBaseFilter_EnumPins( pin_info
.pFilter
, &enumpins
);
92 hr
= IEnumPins_Reset( enumpins
);
95 hr
= IEnumPins_Next( enumpins
, 1, &pin
, NULL
);
96 if (hr
== VFW_E_ENUM_OUT_OF_SYNC
)
98 hr
= IEnumPins_Reset( enumpins
);
105 IPin_QueryDirection( pin
, &dir
);
108 IPin
*connected
= NULL
;
111 IPin_ConnectedTo( pin
, &connected
);
116 hr_local
= fnMiddle( connected
, arg
);
117 hr_return
= updatehres( hr_return
, hr_local
);
118 IPin_Release(connected
);
130 hr_local
= fnEnd( from
, arg
);
131 hr_return
= updatehres( hr_return
, hr_local
);
135 if (pin_info
.pFilter
)
136 IBaseFilter_Release( pin_info
.pFilter
);
140 static inline InputPin
*impl_from_IMemInputPin( IMemInputPin
*iface
)
142 return (InputPin
*)((char*)iface
- FIELD_OFFSET(InputPin
, lpVtblMemInput
));
146 static void Copy_PinInfo(PIN_INFO
* pDest
, const PIN_INFO
* pSrc
)
148 /* Tempting to just do a memcpy, but the name field is
149 128 characters long! We will probably never exceed 10
150 most of the time, so we are better off copying
151 each field manually */
152 strcpyW(pDest
->achName
, pSrc
->achName
);
153 pDest
->dir
= pSrc
->dir
;
154 pDest
->pFilter
= pSrc
->pFilter
;
157 /* Function called as a helper to IPin_Connect */
158 /* specific AM_MEDIA_TYPE - it cannot be NULL */
159 /* NOTE: not part of standard interface */
160 static HRESULT
OutputPin_ConnectSpecific(IPin
* iface
, IPin
* pReceivePin
, const AM_MEDIA_TYPE
* pmt
)
162 OutputPin
*This
= (OutputPin
*)iface
;
164 IMemAllocator
* pMemAlloc
= NULL
;
165 ALLOCATOR_PROPERTIES actual
; /* FIXME: should we put the actual props back in to This? */
167 TRACE("(%p, %p)\n", pReceivePin
, pmt
);
168 dump_AM_MEDIA_TYPE(pmt
);
170 /* FIXME: call queryacceptproc */
172 This
->pin
.pConnectedTo
= pReceivePin
;
173 IPin_AddRef(pReceivePin
);
174 CopyMediaType(&This
->pin
.mtCurrent
, pmt
);
176 hr
= IPin_ReceiveConnection(pReceivePin
, iface
, pmt
);
178 /* get the IMemInputPin interface we will use to deliver samples to the
182 This
->pMemInputPin
= NULL
;
183 hr
= IPin_QueryInterface(pReceivePin
, &IID_IMemInputPin
, (LPVOID
)&This
->pMemInputPin
);
185 if (SUCCEEDED(hr
) && !This
->custom_allocator
)
187 hr
= IMemInputPin_GetAllocator(This
->pMemInputPin
, &pMemAlloc
);
189 if (hr
== VFW_E_NO_ALLOCATOR
)
191 /* Input pin provides no allocator, use standard memory allocator */
192 hr
= CoCreateInstance(&CLSID_MemoryAllocator
, NULL
, CLSCTX_INPROC_SERVER
, &IID_IMemAllocator
, (LPVOID
*)&pMemAlloc
);
196 hr
= IMemInputPin_NotifyAllocator(This
->pMemInputPin
, pMemAlloc
, This
->readonly
);
201 hr
= IMemAllocator_SetProperties(pMemAlloc
, &This
->allocProps
, &actual
);
204 IMemAllocator_Release(pMemAlloc
);
206 else if (SUCCEEDED(hr
))
210 hr
= IMemInputPin_NotifyAllocator(This
->pMemInputPin
, This
->alloc
, This
->readonly
);
213 hr
= VFW_E_NO_ALLOCATOR
;
216 /* break connection if we couldn't get the allocator */
219 if (This
->pMemInputPin
)
220 IMemInputPin_Release(This
->pMemInputPin
);
221 This
->pMemInputPin
= NULL
;
223 IPin_Disconnect(pReceivePin
);
229 IPin_Release(This
->pin
.pConnectedTo
);
230 This
->pin
.pConnectedTo
= NULL
;
231 FreeMediaType(&This
->pin
.mtCurrent
);
234 TRACE(" -- %x\n", hr
);
238 static HRESULT
InputPin_Init(const IPinVtbl
*InputPin_Vtbl
, const PIN_INFO
* pPinInfo
, SAMPLEPROC_PUSH pSampleProc
, LPVOID pUserData
,
239 QUERYACCEPTPROC pQueryAccept
, CLEANUPPROC pCleanUp
, LPCRITICAL_SECTION pCritSec
, InputPin
* pPinImpl
)
243 /* Common attributes */
244 pPinImpl
->pin
.refCount
= 1;
245 pPinImpl
->pin
.pConnectedTo
= NULL
;
246 pPinImpl
->pin
.fnQueryAccept
= pQueryAccept
;
247 pPinImpl
->pin
.pUserData
= pUserData
;
248 pPinImpl
->pin
.pCritSec
= pCritSec
;
249 Copy_PinInfo(&pPinImpl
->pin
.pinInfo
, pPinInfo
);
250 ZeroMemory(&pPinImpl
->pin
.mtCurrent
, sizeof(AM_MEDIA_TYPE
));
252 /* Input pin attributes */
253 pPinImpl
->fnSampleProc
= pSampleProc
;
254 pPinImpl
->fnCleanProc
= pCleanUp
;
255 pPinImpl
->pAllocator
= NULL
;
256 pPinImpl
->tStart
= 0;
258 pPinImpl
->dRate
= 1.0;
259 pPinImpl
->pin
.lpVtbl
= InputPin_Vtbl
;
260 pPinImpl
->lpVtblMemInput
= &MemInputPin_Vtbl
;
261 pPinImpl
->flushing
= pPinImpl
->end_of_stream
= 0;
266 static HRESULT
OutputPin_Init(const IPinVtbl
*OutputPin_Vtbl
, const PIN_INFO
* pPinInfo
, const ALLOCATOR_PROPERTIES
* props
, LPVOID pUserData
,
267 QUERYACCEPTPROC pQueryAccept
, LPCRITICAL_SECTION pCritSec
, OutputPin
* pPinImpl
)
271 /* Common attributes */
272 pPinImpl
->pin
.lpVtbl
= OutputPin_Vtbl
;
273 pPinImpl
->pin
.refCount
= 1;
274 pPinImpl
->pin
.pConnectedTo
= NULL
;
275 pPinImpl
->pin
.fnQueryAccept
= pQueryAccept
;
276 pPinImpl
->pin
.pUserData
= pUserData
;
277 pPinImpl
->pin
.pCritSec
= pCritSec
;
278 Copy_PinInfo(&pPinImpl
->pin
.pinInfo
, pPinInfo
);
279 ZeroMemory(&pPinImpl
->pin
.mtCurrent
, sizeof(AM_MEDIA_TYPE
));
281 /* Output pin attributes */
282 pPinImpl
->pMemInputPin
= NULL
;
283 pPinImpl
->pConnectSpecific
= OutputPin_ConnectSpecific
;
284 /* If custom_allocator is set, you will need to specify an allocator
285 * in the alloc member of the struct before an output pin can connect
287 pPinImpl
->custom_allocator
= 0;
288 pPinImpl
->alloc
= NULL
;
289 pPinImpl
->readonly
= FALSE
;
292 pPinImpl
->allocProps
= *props
;
293 if (pPinImpl
->allocProps
.cbAlign
== 0)
294 pPinImpl
->allocProps
.cbAlign
= 1;
297 ZeroMemory(&pPinImpl
->allocProps
, sizeof(pPinImpl
->allocProps
));
302 HRESULT
InputPin_Construct(const IPinVtbl
*InputPin_Vtbl
, const PIN_INFO
* pPinInfo
, SAMPLEPROC_PUSH pSampleProc
, LPVOID pUserData
, QUERYACCEPTPROC pQueryAccept
, CLEANUPPROC pCleanUp
, LPCRITICAL_SECTION pCritSec
, IPin
** ppPin
)
308 if (pPinInfo
->dir
!= PINDIR_INPUT
)
310 ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo
->dir
);
314 pPinImpl
= CoTaskMemAlloc(sizeof(*pPinImpl
));
317 return E_OUTOFMEMORY
;
319 if (SUCCEEDED(InputPin_Init(InputPin_Vtbl
, pPinInfo
, pSampleProc
, pUserData
, pQueryAccept
, pCleanUp
, pCritSec
, pPinImpl
)))
321 *ppPin
= (IPin
*)pPinImpl
;
325 CoTaskMemFree(pPinImpl
);
329 HRESULT
OutputPin_Construct(const IPinVtbl
*OutputPin_Vtbl
, long outputpin_size
, const PIN_INFO
* pPinInfo
, ALLOCATOR_PROPERTIES
*props
, LPVOID pUserData
, QUERYACCEPTPROC pQueryAccept
, LPCRITICAL_SECTION pCritSec
, IPin
** ppPin
)
331 OutputPin
* pPinImpl
;
335 if (pPinInfo
->dir
!= PINDIR_OUTPUT
)
337 ERR("Pin direction(%x) != PINDIR_OUTPUT\n", pPinInfo
->dir
);
341 assert(outputpin_size
>= sizeof(OutputPin
));
343 pPinImpl
= CoTaskMemAlloc(outputpin_size
);
346 return E_OUTOFMEMORY
;
348 if (SUCCEEDED(OutputPin_Init(OutputPin_Vtbl
, pPinInfo
, props
, pUserData
, pQueryAccept
, pCritSec
, pPinImpl
)))
350 *ppPin
= (IPin
*)(&pPinImpl
->pin
.lpVtbl
);
354 CoTaskMemFree(pPinImpl
);
358 /*** Common pin functions ***/
360 ULONG WINAPI
IPinImpl_AddRef(IPin
* iface
)
362 IPinImpl
*This
= (IPinImpl
*)iface
;
363 ULONG refCount
= InterlockedIncrement(&This
->refCount
);
365 TRACE("(%p)->() AddRef from %d\n", iface
, refCount
- 1);
370 HRESULT WINAPI
IPinImpl_Disconnect(IPin
* iface
)
373 IPinImpl
*This
= (IPinImpl
*)iface
;
377 EnterCriticalSection(This
->pCritSec
);
379 if (This
->pConnectedTo
)
381 IPin_Release(This
->pConnectedTo
);
382 This
->pConnectedTo
= NULL
;
388 LeaveCriticalSection(This
->pCritSec
);
393 HRESULT WINAPI
IPinImpl_ConnectedTo(IPin
* iface
, IPin
** ppPin
)
396 IPinImpl
*This
= (IPinImpl
*)iface
;
398 TRACE("(%p)\n", ppPin
);
400 EnterCriticalSection(This
->pCritSec
);
402 if (This
->pConnectedTo
)
404 *ppPin
= This
->pConnectedTo
;
409 hr
= VFW_E_NOT_CONNECTED
;
411 LeaveCriticalSection(This
->pCritSec
);
416 HRESULT WINAPI
IPinImpl_ConnectionMediaType(IPin
* iface
, AM_MEDIA_TYPE
* pmt
)
419 IPinImpl
*This
= (IPinImpl
*)iface
;
421 TRACE("(%p/%p)->(%p)\n", This
, iface
, pmt
);
423 EnterCriticalSection(This
->pCritSec
);
425 if (This
->pConnectedTo
)
427 CopyMediaType(pmt
, &This
->mtCurrent
);
432 ZeroMemory(pmt
, sizeof(*pmt
));
433 hr
= VFW_E_NOT_CONNECTED
;
436 LeaveCriticalSection(This
->pCritSec
);
441 HRESULT WINAPI
IPinImpl_QueryPinInfo(IPin
* iface
, PIN_INFO
* pInfo
)
443 IPinImpl
*This
= (IPinImpl
*)iface
;
445 TRACE("(%p/%p)->(%p)\n", This
, iface
, pInfo
);
447 Copy_PinInfo(pInfo
, &This
->pinInfo
);
448 IBaseFilter_AddRef(pInfo
->pFilter
);
453 HRESULT WINAPI
IPinImpl_QueryDirection(IPin
* iface
, PIN_DIRECTION
* pPinDir
)
455 IPinImpl
*This
= (IPinImpl
*)iface
;
457 TRACE("(%p/%p)->(%p)\n", This
, iface
, pPinDir
);
459 *pPinDir
= This
->pinInfo
.dir
;
464 HRESULT WINAPI
IPinImpl_QueryId(IPin
* iface
, LPWSTR
* Id
)
466 IPinImpl
*This
= (IPinImpl
*)iface
;
468 TRACE("(%p/%p)->(%p)\n", This
, iface
, Id
);
470 *Id
= CoTaskMemAlloc((strlenW(This
->pinInfo
.achName
) + 1) * sizeof(WCHAR
));
472 return E_OUTOFMEMORY
;
474 strcpyW(*Id
, This
->pinInfo
.achName
);
479 HRESULT WINAPI
IPinImpl_QueryAccept(IPin
* iface
, const AM_MEDIA_TYPE
* pmt
)
481 IPinImpl
*This
= (IPinImpl
*)iface
;
483 TRACE("(%p/%p)->(%p)\n", This
, iface
, pmt
);
485 return (This
->fnQueryAccept(This
->pUserData
, pmt
) == S_OK
? S_OK
: S_FALSE
);
488 HRESULT WINAPI
IPinImpl_EnumMediaTypes(IPin
* iface
, IEnumMediaTypes
** ppEnum
)
490 IPinImpl
*This
= (IPinImpl
*)iface
;
491 ENUMMEDIADETAILS emd
;
493 TRACE("(%p/%p)->(%p)\n", This
, iface
, ppEnum
);
495 /* override this method to allow enumeration of your types */
497 emd
.pMediaTypes
= NULL
;
499 return IEnumMediaTypesImpl_Construct(&emd
, ppEnum
);
502 HRESULT WINAPI
IPinImpl_QueryInternalConnections(IPin
* iface
, IPin
** apPin
, ULONG
* cPin
)
504 IPinImpl
*This
= (IPinImpl
*)iface
;
506 TRACE("(%p/%p)->(%p, %p)\n", This
, iface
, apPin
, cPin
);
508 return E_NOTIMPL
; /* to tell caller that all input pins connected to all output pins */
511 /*** IPin implementation for an input pin ***/
513 HRESULT WINAPI
InputPin_QueryInterface(IPin
* iface
, REFIID riid
, LPVOID
* ppv
)
515 InputPin
*This
= (InputPin
*)iface
;
517 TRACE("(%p)->(%s, %p)\n", iface
, qzdebugstr_guid(riid
), ppv
);
521 if (IsEqualIID(riid
, &IID_IUnknown
))
522 *ppv
= (LPVOID
)iface
;
523 else if (IsEqualIID(riid
, &IID_IPin
))
524 *ppv
= (LPVOID
)iface
;
525 else if (IsEqualIID(riid
, &IID_IMemInputPin
))
526 *ppv
= (LPVOID
)&This
->lpVtblMemInput
;
527 else if (IsEqualIID(riid
, &IID_IMediaSeeking
))
529 return IBaseFilter_QueryInterface(This
->pin
.pinInfo
.pFilter
, &IID_IMediaSeeking
, ppv
);
534 IUnknown_AddRef((IUnknown
*)(*ppv
));
538 FIXME("No interface for %s!\n", qzdebugstr_guid(riid
));
540 return E_NOINTERFACE
;
543 ULONG WINAPI
InputPin_Release(IPin
* iface
)
545 InputPin
*This
= (InputPin
*)iface
;
546 ULONG refCount
= InterlockedDecrement(&This
->pin
.refCount
);
548 TRACE("(%p)->() Release from %d\n", iface
, refCount
+ 1);
552 FreeMediaType(&This
->pin
.mtCurrent
);
553 if (This
->pAllocator
)
554 IMemAllocator_Release(This
->pAllocator
);
562 HRESULT WINAPI
InputPin_Connect(IPin
* iface
, IPin
* pConnector
, const AM_MEDIA_TYPE
* pmt
)
564 ERR("Outgoing connection on an input pin! (%p, %p)\n", pConnector
, pmt
);
570 HRESULT WINAPI
InputPin_ReceiveConnection(IPin
* iface
, IPin
* pReceivePin
, const AM_MEDIA_TYPE
* pmt
)
572 InputPin
*This
= (InputPin
*)iface
;
573 PIN_DIRECTION pindirReceive
;
576 TRACE("(%p, %p)\n", pReceivePin
, pmt
);
577 dump_AM_MEDIA_TYPE(pmt
);
579 EnterCriticalSection(This
->pin
.pCritSec
);
581 if (This
->pin
.pConnectedTo
)
582 hr
= VFW_E_ALREADY_CONNECTED
;
584 if (SUCCEEDED(hr
) && This
->pin
.fnQueryAccept(This
->pin
.pUserData
, pmt
) != S_OK
)
585 hr
= VFW_E_TYPE_NOT_ACCEPTED
; /* FIXME: shouldn't we just map common errors onto
586 * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */
590 IPin_QueryDirection(pReceivePin
, &pindirReceive
);
592 if (pindirReceive
!= PINDIR_OUTPUT
)
594 ERR("Can't connect from non-output pin\n");
595 hr
= VFW_E_INVALID_DIRECTION
;
601 CopyMediaType(&This
->pin
.mtCurrent
, pmt
);
602 This
->pin
.pConnectedTo
= pReceivePin
;
603 IPin_AddRef(pReceivePin
);
606 LeaveCriticalSection(This
->pin
.pCritSec
);
611 static HRESULT
deliver_endofstream(IPin
* pin
, LPVOID unused
)
613 return IPin_EndOfStream( pin
);
616 HRESULT WINAPI
InputPin_EndOfStream(IPin
* iface
)
618 InputPin
*This
= (InputPin
*)iface
;
619 TRACE("(%p)\n", This
);
621 This
->end_of_stream
= 1;
623 return SendFurther( iface
, deliver_endofstream
, NULL
, NULL
);
626 static HRESULT
deliver_beginflush(IPin
* pin
, LPVOID unused
)
628 return IPin_BeginFlush( pin
);
631 HRESULT WINAPI
InputPin_BeginFlush(IPin
* iface
)
633 InputPin
*This
= (InputPin
*)iface
;
635 TRACE("() semi-stub\n");
637 EnterCriticalSection(This
->pin
.pCritSec
);
640 if (This
->fnCleanProc
)
641 This
->fnCleanProc(This
->pin
.pUserData
);
643 hr
= SendFurther( iface
, deliver_beginflush
, NULL
, NULL
);
644 LeaveCriticalSection(This
->pin
.pCritSec
);
649 static HRESULT
deliver_endflush(IPin
* pin
, LPVOID unused
)
651 return IPin_EndFlush( pin
);
654 HRESULT WINAPI
InputPin_EndFlush(IPin
* iface
)
656 InputPin
*This
= (InputPin
*)iface
;
658 TRACE("(%p)\n", This
);
660 EnterCriticalSection(This
->pin
.pCritSec
);
663 hr
= SendFurther( iface
, deliver_endflush
, NULL
, NULL
);
664 LeaveCriticalSection(This
->pin
.pCritSec
);
669 typedef struct newsegmentargs
671 REFERENCE_TIME tStart
, tStop
;
675 static HRESULT
deliver_newsegment(IPin
*pin
, LPVOID data
)
677 newsegmentargs
*args
= data
;
678 return IPin_NewSegment(pin
, args
->tStart
, args
->tStop
, args
->rate
);
681 HRESULT WINAPI
InputPin_NewSegment(IPin
* iface
, REFERENCE_TIME tStart
, REFERENCE_TIME tStop
, double dRate
)
683 InputPin
*This
= (InputPin
*)iface
;
686 TRACE("(%x%08x, %x%08x, %e)\n", (ULONG
)(tStart
>> 32), (ULONG
)tStart
, (ULONG
)(tStop
>> 32), (ULONG
)tStop
, dRate
);
688 args
.tStart
= This
->tStart
= tStart
;
689 args
.tStop
= This
->tStop
= tStop
;
690 args
.rate
= This
->dRate
= dRate
;
692 return SendFurther( iface
, deliver_newsegment
, &args
, NULL
);
695 static const IPinVtbl InputPin_Vtbl
=
697 InputPin_QueryInterface
,
701 InputPin_ReceiveConnection
,
703 IPinImpl_ConnectedTo
,
704 IPinImpl_ConnectionMediaType
,
705 IPinImpl_QueryPinInfo
,
706 IPinImpl_QueryDirection
,
708 IPinImpl_QueryAccept
,
709 IPinImpl_EnumMediaTypes
,
710 IPinImpl_QueryInternalConnections
,
711 InputPin_EndOfStream
,
717 /*** IMemInputPin implementation ***/
719 HRESULT WINAPI
MemInputPin_QueryInterface(IMemInputPin
* iface
, REFIID riid
, LPVOID
* ppv
)
721 InputPin
*This
= impl_from_IMemInputPin(iface
);
723 return IPin_QueryInterface((IPin
*)&This
->pin
, riid
, ppv
);
726 ULONG WINAPI
MemInputPin_AddRef(IMemInputPin
* iface
)
728 InputPin
*This
= impl_from_IMemInputPin(iface
);
730 return IPin_AddRef((IPin
*)&This
->pin
);
733 ULONG WINAPI
MemInputPin_Release(IMemInputPin
* iface
)
735 InputPin
*This
= impl_from_IMemInputPin(iface
);
737 return IPin_Release((IPin
*)&This
->pin
);
740 HRESULT WINAPI
MemInputPin_GetAllocator(IMemInputPin
* iface
, IMemAllocator
** ppAllocator
)
742 InputPin
*This
= impl_from_IMemInputPin(iface
);
744 TRACE("(%p/%p)->(%p)\n", This
, iface
, ppAllocator
);
746 *ppAllocator
= This
->pAllocator
;
748 IMemAllocator_AddRef(*ppAllocator
);
750 return *ppAllocator
? S_OK
: VFW_E_NO_ALLOCATOR
;
753 HRESULT WINAPI
MemInputPin_NotifyAllocator(IMemInputPin
* iface
, IMemAllocator
* pAllocator
, BOOL bReadOnly
)
755 InputPin
*This
= impl_from_IMemInputPin(iface
);
757 TRACE("(%p/%p)->(%p, %d)\n", This
, iface
, pAllocator
, bReadOnly
);
760 FIXME("Read only flag not handled yet!\n");
762 if (This
->pAllocator
)
763 IMemAllocator_Release(This
->pAllocator
);
764 This
->pAllocator
= pAllocator
;
765 if (This
->pAllocator
)
766 IMemAllocator_AddRef(This
->pAllocator
);
771 HRESULT WINAPI
MemInputPin_GetAllocatorRequirements(IMemInputPin
* iface
, ALLOCATOR_PROPERTIES
* pProps
)
773 InputPin
*This
= impl_from_IMemInputPin(iface
);
775 TRACE("(%p/%p)->(%p)\n", This
, iface
, pProps
);
777 /* override this method if you have any specific requirements */
782 HRESULT WINAPI
MemInputPin_Receive(IMemInputPin
* iface
, IMediaSample
* pSample
)
784 InputPin
*This
= impl_from_IMemInputPin(iface
);
787 /* this trace commented out for performance reasons */
788 /*TRACE("(%p/%p)->(%p)\n", This, iface, pSample);*/
790 EnterCriticalSection(This
->pin
.pCritSec
);
791 if (!This
->end_of_stream
&& !This
->flushing
)
792 hr
= This
->fnSampleProc(This
->pin
.pUserData
, pSample
);
795 LeaveCriticalSection(This
->pin
.pCritSec
);
799 HRESULT WINAPI
MemInputPin_ReceiveMultiple(IMemInputPin
* iface
, IMediaSample
** pSamples
, long nSamples
, long *nSamplesProcessed
)
802 InputPin
*This
= impl_from_IMemInputPin(iface
);
804 TRACE("(%p/%p)->(%p, %ld, %p)\n", This
, iface
, pSamples
, nSamples
, nSamplesProcessed
);
806 for (*nSamplesProcessed
= 0; *nSamplesProcessed
< nSamples
; (*nSamplesProcessed
)++)
808 hr
= IMemInputPin_Receive(iface
, pSamples
[*nSamplesProcessed
]);
816 HRESULT WINAPI
MemInputPin_ReceiveCanBlock(IMemInputPin
* iface
)
818 InputPin
*This
= impl_from_IMemInputPin(iface
);
820 FIXME("(%p/%p)->()\n", This
, iface
);
822 /* FIXME: we should check whether any output pins will block */
827 static const IMemInputPinVtbl MemInputPin_Vtbl
=
829 MemInputPin_QueryInterface
,
832 MemInputPin_GetAllocator
,
833 MemInputPin_NotifyAllocator
,
834 MemInputPin_GetAllocatorRequirements
,
836 MemInputPin_ReceiveMultiple
,
837 MemInputPin_ReceiveCanBlock
840 HRESULT WINAPI
OutputPin_QueryInterface(IPin
* iface
, REFIID riid
, LPVOID
* ppv
)
842 OutputPin
*This
= (OutputPin
*)iface
;
844 TRACE("(%p/%p)->(%s, %p)\n", This
, iface
, qzdebugstr_guid(riid
), ppv
);
848 if (IsEqualIID(riid
, &IID_IUnknown
))
849 *ppv
= (LPVOID
)iface
;
850 else if (IsEqualIID(riid
, &IID_IPin
))
851 *ppv
= (LPVOID
)iface
;
852 else if (IsEqualIID(riid
, &IID_IMediaSeeking
))
854 return IBaseFilter_QueryInterface(This
->pin
.pinInfo
.pFilter
, &IID_IMediaSeeking
, ppv
);
859 IUnknown_AddRef((IUnknown
*)(*ppv
));
863 FIXME("No interface for %s!\n", qzdebugstr_guid(riid
));
865 return E_NOINTERFACE
;
868 ULONG WINAPI
OutputPin_Release(IPin
* iface
)
870 OutputPin
*This
= (OutputPin
*)iface
;
871 ULONG refCount
= InterlockedDecrement(&This
->pin
.refCount
);
873 TRACE("(%p)->() Release from %d\n", iface
, refCount
+ 1);
877 FreeMediaType(&This
->pin
.mtCurrent
);
884 HRESULT WINAPI
OutputPin_Connect(IPin
* iface
, IPin
* pReceivePin
, const AM_MEDIA_TYPE
* pmt
)
887 OutputPin
*This
= (OutputPin
*)iface
;
889 TRACE("(%p/%p)->(%p, %p)\n", This
, iface
, pReceivePin
, pmt
);
890 dump_AM_MEDIA_TYPE(pmt
);
892 /* If we try to connect to ourself, we will definitely deadlock.
893 * There are other cases where we could deadlock too, but this
894 * catches the obvious case */
895 assert(pReceivePin
!= iface
);
897 EnterCriticalSection(This
->pin
.pCritSec
);
899 /* if we have been a specific type to connect with, then we can either connect
900 * with that or fail. We cannot choose different AM_MEDIA_TYPE */
901 if (pmt
&& !IsEqualGUID(&pmt
->majortype
, &GUID_NULL
) && !IsEqualGUID(&pmt
->subtype
, &GUID_NULL
))
902 hr
= This
->pConnectSpecific(iface
, pReceivePin
, pmt
);
905 /* negotiate media type */
907 IEnumMediaTypes
* pEnumCandidates
;
908 AM_MEDIA_TYPE
* pmtCandidate
; /* Candidate media type */
910 if (SUCCEEDED(hr
= IPin_EnumMediaTypes(iface
, &pEnumCandidates
)))
912 hr
= VFW_E_NO_ACCEPTABLE_TYPES
; /* Assume the worst, but set to S_OK if connected successfully */
914 /* try this filter's media types first */
915 while (S_OK
== IEnumMediaTypes_Next(pEnumCandidates
, 1, &pmtCandidate
, NULL
))
917 if (( !pmt
|| CompareMediaTypes(pmt
, pmtCandidate
, TRUE
) ) &&
918 (This
->pConnectSpecific(iface
, pReceivePin
, pmtCandidate
) == S_OK
))
921 CoTaskMemFree(pmtCandidate
);
924 CoTaskMemFree(pmtCandidate
);
926 IEnumMediaTypes_Release(pEnumCandidates
);
929 /* then try receiver filter's media types */
930 if (hr
!= S_OK
&& SUCCEEDED(hr
= IPin_EnumMediaTypes(pReceivePin
, &pEnumCandidates
))) /* if we haven't already connected successfully */
932 hr
= VFW_E_NO_ACCEPTABLE_TYPES
; /* Assume the worst, but set to S_OK if connected successfully */
934 while (S_OK
== IEnumMediaTypes_Next(pEnumCandidates
, 1, &pmtCandidate
, NULL
))
936 if (( !pmt
|| CompareMediaTypes(pmt
, pmtCandidate
, TRUE
) ) &&
937 (This
->pConnectSpecific(iface
, pReceivePin
, pmtCandidate
) == S_OK
))
940 CoTaskMemFree(pmtCandidate
);
943 CoTaskMemFree(pmtCandidate
);
945 IEnumMediaTypes_Release(pEnumCandidates
);
947 } /* if negotiate media type */
949 LeaveCriticalSection(This
->pin
.pCritSec
);
951 TRACE(" -- %x\n", hr
);
955 HRESULT WINAPI
OutputPin_ReceiveConnection(IPin
* iface
, IPin
* pReceivePin
, const AM_MEDIA_TYPE
* pmt
)
957 ERR("Incoming connection on an output pin! (%p, %p)\n", pReceivePin
, pmt
);
962 HRESULT WINAPI
OutputPin_Disconnect(IPin
* iface
)
965 OutputPin
*This
= (OutputPin
*)iface
;
969 EnterCriticalSection(This
->pin
.pCritSec
);
971 if (This
->pMemInputPin
)
973 IMemInputPin_Release(This
->pMemInputPin
);
974 This
->pMemInputPin
= NULL
;
976 if (This
->pin
.pConnectedTo
)
978 IPin_Release(This
->pin
.pConnectedTo
);
979 This
->pin
.pConnectedTo
= NULL
;
985 LeaveCriticalSection(This
->pin
.pCritSec
);
990 HRESULT WINAPI
OutputPin_EndOfStream(IPin
* iface
)
994 /* not supposed to do anything in an output pin */
999 HRESULT WINAPI
OutputPin_BeginFlush(IPin
* iface
)
1001 TRACE("(%p)->()\n", iface
);
1003 /* not supposed to do anything in an output pin */
1005 return E_UNEXPECTED
;
1008 HRESULT WINAPI
OutputPin_EndFlush(IPin
* iface
)
1010 TRACE("(%p)->()\n", iface
);
1012 /* not supposed to do anything in an output pin */
1014 return E_UNEXPECTED
;
1017 HRESULT WINAPI
OutputPin_NewSegment(IPin
* iface
, REFERENCE_TIME tStart
, REFERENCE_TIME tStop
, double dRate
)
1019 TRACE("(%p)->(%x%08x, %x%08x, %e)\n", iface
, (ULONG
)(tStart
>> 32), (ULONG
)tStart
, (ULONG
)(tStop
>> 32), (ULONG
)tStop
, dRate
);
1021 /* not supposed to do anything in an output pin */
1023 return E_UNEXPECTED
;
1026 static const IPinVtbl OutputPin_Vtbl
=
1028 OutputPin_QueryInterface
,
1032 OutputPin_ReceiveConnection
,
1033 OutputPin_Disconnect
,
1034 IPinImpl_ConnectedTo
,
1035 IPinImpl_ConnectionMediaType
,
1036 IPinImpl_QueryPinInfo
,
1037 IPinImpl_QueryDirection
,
1039 IPinImpl_QueryAccept
,
1040 IPinImpl_EnumMediaTypes
,
1041 IPinImpl_QueryInternalConnections
,
1042 OutputPin_EndOfStream
,
1043 OutputPin_BeginFlush
,
1045 OutputPin_NewSegment
1048 HRESULT
OutputPin_GetDeliveryBuffer(OutputPin
* This
, IMediaSample
** ppSample
, REFERENCE_TIME
* tStart
, REFERENCE_TIME
* tStop
, DWORD dwFlags
)
1052 TRACE("(%p, %p, %p, %x)\n", ppSample
, tStart
, tStop
, dwFlags
);
1054 EnterCriticalSection(This
->pin
.pCritSec
);
1056 if (!This
->pin
.pConnectedTo
)
1057 hr
= VFW_E_NOT_CONNECTED
;
1060 IMemAllocator
* pAlloc
= NULL
;
1062 hr
= IMemInputPin_GetAllocator(This
->pMemInputPin
, &pAlloc
);
1065 hr
= IMemAllocator_GetBuffer(pAlloc
, ppSample
, tStart
, tStop
, dwFlags
);
1068 hr
= IMediaSample_SetTime(*ppSample
, tStart
, tStop
);
1071 IMemAllocator_Release(pAlloc
);
1074 LeaveCriticalSection(This
->pin
.pCritSec
);
1079 HRESULT
OutputPin_SendSample(OutputPin
* This
, IMediaSample
* pSample
)
1082 IMemInputPin
* pMemConnected
= NULL
;
1085 EnterCriticalSection(This
->pin
.pCritSec
);
1087 if (!This
->pin
.pConnectedTo
|| !This
->pMemInputPin
)
1088 hr
= VFW_E_NOT_CONNECTED
;
1091 /* we don't have the lock held when using This->pMemInputPin,
1092 * so we need to AddRef it to stop it being deleted while we are
1093 * using it. Same with its filter. */
1094 pMemConnected
= This
->pMemInputPin
;
1095 IMemInputPin_AddRef(pMemConnected
);
1096 hr
= IPin_QueryPinInfo(This
->pin
.pConnectedTo
, &pinInfo
);
1099 LeaveCriticalSection(This
->pin
.pCritSec
);
1103 /* NOTE: if we are in a critical section when Receive is called
1104 * then it causes some problems (most notably with the native Video
1105 * Renderer) if we are re-entered for whatever reason */
1106 hr
= IMemInputPin_Receive(pMemConnected
, pSample
);
1108 /* If the filter's destroyed, tell upstream to stop sending data */
1109 if(IBaseFilter_Release(pinInfo
.pFilter
) == 0 && SUCCEEDED(hr
))
1113 IMemInputPin_Release(pMemConnected
);
1118 HRESULT
OutputPin_DeliverNewSegment(OutputPin
* This
, REFERENCE_TIME tStart
, REFERENCE_TIME tStop
, double dRate
)
1122 EnterCriticalSection(This
->pin
.pCritSec
);
1124 if (!This
->pin
.pConnectedTo
)
1125 hr
= VFW_E_NOT_CONNECTED
;
1127 hr
= IPin_NewSegment(This
->pin
.pConnectedTo
, tStart
, tStop
, dRate
);
1129 LeaveCriticalSection(This
->pin
.pCritSec
);
1134 HRESULT
OutputPin_CommitAllocator(OutputPin
* This
)
1138 TRACE("(%p)->()\n", This
);
1140 EnterCriticalSection(This
->pin
.pCritSec
);
1141 if (!This
->custom_allocator
)
1143 if (!This
->pin
.pConnectedTo
|| !This
->pMemInputPin
)
1144 hr
= VFW_E_NOT_CONNECTED
;
1147 IMemAllocator
* pAlloc
= NULL
;
1149 hr
= IMemInputPin_GetAllocator(This
->pMemInputPin
, &pAlloc
);
1152 hr
= IMemAllocator_Commit(pAlloc
);
1155 IMemAllocator_Release(pAlloc
);
1158 LeaveCriticalSection(This
->pin
.pCritSec
);
1163 HRESULT
OutputPin_DeliverDisconnect(OutputPin
* This
)
1167 TRACE("(%p)->()\n", This
);
1169 EnterCriticalSection(This
->pin
.pCritSec
);
1171 if (!This
->pin
.pConnectedTo
|| !This
->pMemInputPin
)
1172 hr
= VFW_E_NOT_CONNECTED
;
1173 else if (!This
->custom_allocator
)
1175 IMemAllocator
* pAlloc
= NULL
;
1177 hr
= IMemInputPin_GetAllocator(This
->pMemInputPin
, &pAlloc
);
1180 hr
= IMemAllocator_Decommit(pAlloc
);
1183 IMemAllocator_Release(pAlloc
);
1186 hr
= IPin_Disconnect(This
->pin
.pConnectedTo
);
1188 else /* Kill the allocator! */
1190 hr
= IMemInputPin_NotifyAllocator(This
->pMemInputPin
, NULL
, 0);
1192 hr
= IPin_Disconnect(This
->pin
.pConnectedTo
);
1196 LeaveCriticalSection(This
->pin
.pCritSec
);
1202 static HRESULT
PullPin_Init(const IPinVtbl
*PullPin_Vtbl
, const PIN_INFO
* pPinInfo
, SAMPLEPROC_PULL pSampleProc
, LPVOID pUserData
,
1203 QUERYACCEPTPROC pQueryAccept
, CLEANUPPROC pCleanUp
, REQUESTPROC pCustomRequest
, LPCRITICAL_SECTION pCritSec
, PullPin
* pPinImpl
)
1205 /* Common attributes */
1206 pPinImpl
->pin
.lpVtbl
= PullPin_Vtbl
;
1207 pPinImpl
->pin
.refCount
= 1;
1208 pPinImpl
->pin
.pConnectedTo
= NULL
;
1209 pPinImpl
->pin
.fnQueryAccept
= pQueryAccept
;
1210 pPinImpl
->pin
.pUserData
= pUserData
;
1211 pPinImpl
->pin
.pCritSec
= pCritSec
;
1212 Copy_PinInfo(&pPinImpl
->pin
.pinInfo
, pPinInfo
);
1213 ZeroMemory(&pPinImpl
->pin
.mtCurrent
, sizeof(AM_MEDIA_TYPE
));
1215 /* Input pin attributes */
1216 pPinImpl
->fnSampleProc
= pSampleProc
;
1217 pPinImpl
->fnCleanProc
= pCleanUp
;
1218 pPinImpl
->fnPreConnect
= NULL
;
1219 pPinImpl
->pAlloc
= NULL
;
1220 pPinImpl
->pReader
= NULL
;
1221 pPinImpl
->hThread
= NULL
;
1222 pPinImpl
->hEventStateChanged
= CreateEventW(NULL
, TRUE
, TRUE
, NULL
);
1223 pPinImpl
->thread_sleepy
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
1225 pPinImpl
->rtStart
= 0;
1226 pPinImpl
->rtCurrent
= 0;
1227 pPinImpl
->rtStop
= ((LONGLONG
)0x7fffffff << 32) | 0xffffffff;
1228 pPinImpl
->dRate
= 1.0;
1229 pPinImpl
->state
= Req_Die
;
1230 pPinImpl
->fnCustomRequest
= pCustomRequest
;
1231 pPinImpl
->stop_playback
= 1;
1233 InitializeCriticalSection(&pPinImpl
->thread_lock
);
1234 pPinImpl
->thread_lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)( __FILE__
": PullPin.thread_lock");
1239 HRESULT
PullPin_Construct(const IPinVtbl
*PullPin_Vtbl
, const PIN_INFO
* pPinInfo
, SAMPLEPROC_PULL pSampleProc
, LPVOID pUserData
, QUERYACCEPTPROC pQueryAccept
, CLEANUPPROC pCleanUp
, REQUESTPROC pCustomRequest
, LPCRITICAL_SECTION pCritSec
, IPin
** ppPin
)
1245 if (pPinInfo
->dir
!= PINDIR_INPUT
)
1247 ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo
->dir
);
1248 return E_INVALIDARG
;
1251 pPinImpl
= CoTaskMemAlloc(sizeof(*pPinImpl
));
1254 return E_OUTOFMEMORY
;
1256 if (SUCCEEDED(PullPin_Init(PullPin_Vtbl
, pPinInfo
, pSampleProc
, pUserData
, pQueryAccept
, pCleanUp
, pCustomRequest
, pCritSec
, pPinImpl
)))
1258 *ppPin
= (IPin
*)(&pPinImpl
->pin
.lpVtbl
);
1262 CoTaskMemFree(pPinImpl
);
1266 HRESULT WINAPI
PullPin_ReceiveConnection(IPin
* iface
, IPin
* pReceivePin
, const AM_MEDIA_TYPE
* pmt
)
1268 PIN_DIRECTION pindirReceive
;
1270 PullPin
*This
= (PullPin
*)iface
;
1272 TRACE("(%p/%p)->(%p, %p)\n", This
, iface
, pReceivePin
, pmt
);
1273 dump_AM_MEDIA_TYPE(pmt
);
1275 EnterCriticalSection(This
->pin
.pCritSec
);
1277 ALLOCATOR_PROPERTIES props
;
1280 props
.cbBuffer
= 64 * 1024; /* 64k bytes */
1284 if (This
->pin
.pConnectedTo
)
1285 hr
= VFW_E_ALREADY_CONNECTED
;
1287 if (SUCCEEDED(hr
) && (This
->pin
.fnQueryAccept(This
->pin
.pUserData
, pmt
) != S_OK
))
1288 hr
= VFW_E_TYPE_NOT_ACCEPTED
; /* FIXME: shouldn't we just map common errors onto
1289 * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */
1293 IPin_QueryDirection(pReceivePin
, &pindirReceive
);
1295 if (pindirReceive
!= PINDIR_OUTPUT
)
1297 ERR("Can't connect from non-output pin\n");
1298 hr
= VFW_E_INVALID_DIRECTION
;
1302 This
->pReader
= NULL
;
1303 This
->pAlloc
= NULL
;
1306 hr
= IPin_QueryInterface(pReceivePin
, &IID_IAsyncReader
, (LPVOID
*)&This
->pReader
);
1309 if (SUCCEEDED(hr
) && This
->fnPreConnect
)
1311 hr
= This
->fnPreConnect(iface
, pReceivePin
, &props
);
1316 hr
= IAsyncReader_RequestAllocator(This
->pReader
, NULL
, &props
, &This
->pAlloc
);
1321 CopyMediaType(&This
->pin
.mtCurrent
, pmt
);
1322 This
->pin
.pConnectedTo
= pReceivePin
;
1323 IPin_AddRef(pReceivePin
);
1324 hr
= IMemAllocator_Commit(This
->pAlloc
);
1331 IAsyncReader_Release(This
->pReader
);
1332 This
->pReader
= NULL
;
1334 IMemAllocator_Release(This
->pAlloc
);
1335 This
->pAlloc
= NULL
;
1338 LeaveCriticalSection(This
->pin
.pCritSec
);
1342 HRESULT WINAPI
PullPin_QueryInterface(IPin
* iface
, REFIID riid
, LPVOID
* ppv
)
1344 PullPin
*This
= (PullPin
*)iface
;
1346 TRACE("(%p/%p)->(%s, %p)\n", This
, iface
, qzdebugstr_guid(riid
), ppv
);
1350 if (IsEqualIID(riid
, &IID_IUnknown
))
1351 *ppv
= (LPVOID
)iface
;
1352 else if (IsEqualIID(riid
, &IID_IPin
))
1353 *ppv
= (LPVOID
)iface
;
1354 else if (IsEqualIID(riid
, &IID_IMediaSeeking
))
1356 return IBaseFilter_QueryInterface(This
->pin
.pinInfo
.pFilter
, &IID_IMediaSeeking
, ppv
);
1361 IUnknown_AddRef((IUnknown
*)(*ppv
));
1365 FIXME("No interface for %s!\n", qzdebugstr_guid(riid
));
1367 return E_NOINTERFACE
;
1370 ULONG WINAPI
PullPin_Release(IPin
*iface
)
1372 PullPin
*This
= (PullPin
*)iface
;
1373 ULONG refCount
= InterlockedDecrement(&This
->pin
.refCount
);
1375 TRACE("(%p)->() Release from %d\n", This
, refCount
+ 1);
1380 IMemAllocator_Release(This
->pAlloc
);
1382 IAsyncReader_Release(This
->pReader
);
1383 CloseHandle(This
->thread_sleepy
);
1384 CloseHandle(This
->hEventStateChanged
);
1385 This
->thread_lock
.DebugInfo
->Spare
[0] = 0;
1386 DeleteCriticalSection(&This
->thread_lock
);
1387 CoTaskMemFree(This
);
1393 static HRESULT
PullPin_Standard_Request(PullPin
*This
, BOOL start
)
1395 REFERENCE_TIME rtSampleStart
;
1396 REFERENCE_TIME rtSampleStop
;
1397 IMediaSample
*sample
= NULL
;
1400 TRACE("Requesting sample!\n");
1403 This
->rtNext
= This
->rtCurrent
;
1405 if (This
->rtNext
>= This
->rtStop
)
1406 /* Last sample has already been queued, request nothing more */
1409 hr
= IMemAllocator_GetBuffer(This
->pAlloc
, &sample
, NULL
, NULL
, 0);
1413 rtSampleStart
= This
->rtNext
;
1414 rtSampleStop
= rtSampleStart
+ MEDIATIME_FROM_BYTES(IMediaSample_GetSize(sample
));
1415 if (rtSampleStop
> This
->rtStop
)
1416 rtSampleStop
= MEDIATIME_FROM_BYTES(ALIGNUP(BYTES_FROM_MEDIATIME(This
->rtStop
), This
->cbAlign
));
1417 hr
= IMediaSample_SetTime(sample
, &rtSampleStart
, &rtSampleStop
);
1419 This
->rtCurrent
= This
->rtNext
;
1420 This
->rtNext
= rtSampleStop
;
1423 hr
= IAsyncReader_Request(This
->pReader
, sample
, 0);
1426 FIXME("Failed to queue sample : %08x\n", hr
);
1431 static void CALLBACK
PullPin_Flush(PullPin
*This
)
1433 IMediaSample
*pSample
;
1434 TRACE("Flushing!\n");
1436 EnterCriticalSection(This
->pin
.pCritSec
);
1439 /* Flush outstanding samples */
1440 IAsyncReader_BeginFlush(This
->pReader
);
1445 IAsyncReader_WaitForNext(This
->pReader
, 0, &pSample
, &dwUser
);
1450 assert(!IMediaSample_GetActualDataLength(pSample
));
1451 if (This
->fnCustomRequest
)
1452 This
->fnSampleProc(This
->pin
.pUserData
, pSample
, dwUser
);
1454 IMediaSample_Release(pSample
);
1457 IAsyncReader_EndFlush(This
->pReader
);
1459 LeaveCriticalSection(This
->pin
.pCritSec
);
1462 static void CALLBACK
PullPin_Thread_Process(PullPin
*This
)
1465 IMediaSample
* pSample
= NULL
;
1466 ALLOCATOR_PROPERTIES allocProps
;
1468 EnterCriticalSection(This
->pin
.pCritSec
);
1469 SetEvent(This
->hEventStateChanged
);
1470 LeaveCriticalSection(This
->pin
.pCritSec
);
1472 hr
= IMemAllocator_GetProperties(This
->pAlloc
, &allocProps
);
1474 This
->cbAlign
= allocProps
.cbAlign
;
1476 if (This
->rtCurrent
< This
->rtStart
)
1477 This
->rtCurrent
= MEDIATIME_FROM_BYTES(ALIGNDOWN(BYTES_FROM_MEDIATIME(This
->rtStart
), This
->cbAlign
));
1481 if (This
->rtCurrent
>= This
->rtStop
)
1483 IPin_EndOfStream((IPin
*)This
);
1487 /* There is no sample in our buffer */
1488 if (!This
->fnCustomRequest
)
1489 hr
= PullPin_Standard_Request(This
, TRUE
);
1491 hr
= This
->fnCustomRequest(This
->pin
.pUserData
);
1494 ERR("Request error: %x\n", hr
);
1500 TRACE("Process sample\n");
1502 hr
= IAsyncReader_WaitForNext(This
->pReader
, 10000, &pSample
, &dwUser
);
1504 /* Calling fnCustomRequest is not specifically useful here: It can be handled inside fnSampleProc */
1505 if (pSample
&& !This
->fnCustomRequest
)
1506 hr
= PullPin_Standard_Request(This
, FALSE
);
1508 /* Return an empty sample on error to the implementation in case it does custom parsing, so it knows it's gone */
1509 if (SUCCEEDED(hr
) || (This
->fnCustomRequest
&& pSample
))
1511 REFERENCE_TIME rtStart
, rtStop
;
1514 IMediaSample_GetTime(pSample
, &rtStart
, &rtStop
);
1518 hr
= This
->fnSampleProc(This
->pin
.pUserData
, pSample
, dwUser
);
1520 if (This
->fnCustomRequest
)
1524 if (This
->rtCurrent
== rtStart
)
1529 /* Maybe it's transient? */
1531 /* rtNext = rtCurrent, because the next sample is already queued */
1532 else if (rtStop
!= This
->rtCurrent
&& rtStop
< This
->rtStop
)
1534 WARN("Position changed! rtStop: %u, rtCurrent: %u\n", (DWORD
)BYTES_FROM_MEDIATIME(rtStop
), (DWORD
)BYTES_FROM_MEDIATIME(This
->rtCurrent
));
1535 PullPin_Flush(This
);
1536 hr
= PullPin_Standard_Request(This
, TRUE
);
1538 } while (rejected
&& (This
->rtCurrent
< This
->rtStop
&& hr
== S_OK
&& !This
->stop_playback
));
1542 /* FIXME: This is not well handled yet! */
1543 ERR("Processing error: %x\n", hr
);
1548 IMediaSample_Release(pSample
);
1551 } while (This
->rtCurrent
< This
->rtStop
&& hr
== S_OK
&& !This
->stop_playback
);
1553 /* Sample was rejected, and we are asked to terminate */
1556 IMediaSample_Release(pSample
);
1559 /* Can't reset state to Sleepy here because that might race, instead PauseProcessing will do that for us
1560 * Flush remaining samples
1562 PullPin_Flush(This
);
1564 TRACE("End: %08x, %d\n", hr
, This
->stop_playback
);
1567 static void CALLBACK
PullPin_Thread_Pause(PullPin
*This
)
1569 TRACE("(%p)->()\n", This
);
1571 EnterCriticalSection(This
->pin
.pCritSec
);
1573 This
->state
= Req_Sleepy
;
1574 SetEvent(This
->hEventStateChanged
);
1576 LeaveCriticalSection(This
->pin
.pCritSec
);
1579 static void CALLBACK
PullPin_Thread_Stop(PullPin
*This
)
1581 TRACE("(%p)->()\n", This
);
1583 EnterCriticalSection(This
->pin
.pCritSec
);
1585 CloseHandle(This
->hThread
);
1586 This
->hThread
= NULL
;
1587 SetEvent(This
->hEventStateChanged
);
1589 LeaveCriticalSection(This
->pin
.pCritSec
);
1591 IBaseFilter_Release(This
->pin
.pinInfo
.pFilter
);
1597 static DWORD WINAPI
PullPin_Thread_Main(LPVOID pv
)
1600 CoInitializeEx(NULL
, COINIT_MULTITHREADED
);
1604 WaitForSingleObject(This
->thread_sleepy
, INFINITE
);
1606 TRACE("State: %d\n", This
->state
);
1608 switch (This
->state
)
1610 case Req_Die
: PullPin_Thread_Stop(This
); break;
1611 case Req_Run
: PullPin_Thread_Process(This
); break;
1612 case Req_Pause
: PullPin_Thread_Pause(This
); break;
1613 case Req_Sleepy
: ERR("Should not be signalled with SLEEPY!\n"); break;
1614 default: ERR("Unknown state request: %d\n", This
->state
); break;
1619 HRESULT
PullPin_InitProcessing(PullPin
* This
)
1623 TRACE("(%p)->()\n", This
);
1625 /* if we are connected */
1630 WaitForSingleObject(This
->hEventStateChanged
, INFINITE
);
1631 EnterCriticalSection(This
->pin
.pCritSec
);
1633 assert(!This
->hThread
);
1634 assert(This
->state
== Req_Die
);
1635 assert(This
->stop_playback
);
1636 assert(WaitForSingleObject(This
->thread_sleepy
, 0) == WAIT_TIMEOUT
);
1637 This
->state
= Req_Sleepy
;
1639 /* AddRef the filter to make sure it and it's pins will be around
1640 * as long as the thread */
1641 IBaseFilter_AddRef(This
->pin
.pinInfo
.pFilter
);
1644 This
->hThread
= CreateThread(NULL
, 0, PullPin_Thread_Main
, This
, 0, &dwThreadId
);
1647 hr
= HRESULT_FROM_WIN32(GetLastError());
1648 IBaseFilter_Release(This
->pin
.pinInfo
.pFilter
);
1653 SetEvent(This
->hEventStateChanged
);
1654 /* If assert fails, that means a command was not processed before the thread previously terminated */
1656 LeaveCriticalSection(This
->pin
.pCritSec
);
1659 TRACE(" -- %x\n", hr
);
1664 HRESULT
PullPin_StartProcessing(PullPin
* This
)
1666 /* if we are connected */
1667 TRACE("(%p)->()\n", This
);
1670 assert(This
->hThread
);
1672 PullPin_WaitForStateChange(This
, INFINITE
);
1674 assert(This
->state
== Req_Sleepy
);
1677 assert(WaitForSingleObject(This
->thread_sleepy
, 0) == WAIT_TIMEOUT
);
1678 This
->state
= Req_Run
;
1679 This
->stop_playback
= 0;
1680 ResetEvent(This
->hEventStateChanged
);
1681 SetEvent(This
->thread_sleepy
);
1687 HRESULT
PullPin_PauseProcessing(PullPin
* This
)
1689 /* if we are connected */
1690 TRACE("(%p)->()\n", This
);
1693 assert(This
->hThread
);
1695 PullPin_WaitForStateChange(This
, INFINITE
);
1697 EnterCriticalSection(This
->pin
.pCritSec
);
1698 assert(!This
->stop_playback
);
1699 assert(This
->state
== Req_Run
|| This
->state
== Req_Sleepy
);
1701 assert(WaitForSingleObject(This
->thread_sleepy
, 0) == WAIT_TIMEOUT
);
1702 This
->state
= Req_Pause
;
1703 This
->stop_playback
= 1;
1704 ResetEvent(This
->hEventStateChanged
);
1705 SetEvent(This
->thread_sleepy
);
1707 LeaveCriticalSection(This
->pin
.pCritSec
);
1713 HRESULT
PullPin_StopProcessing(PullPin
* This
)
1715 TRACE("(%p)->()\n", This
);
1717 /* if we are alive */
1718 assert(This
->hThread
);
1720 PullPin_WaitForStateChange(This
, INFINITE
);
1722 assert(This
->state
== Req_Pause
|| This
->state
== Req_Sleepy
);
1724 This
->stop_playback
= 1;
1725 This
->state
= Req_Die
;
1726 assert(WaitForSingleObject(This
->thread_sleepy
, 0) == WAIT_TIMEOUT
);
1727 ResetEvent(This
->hEventStateChanged
);
1728 SetEvent(This
->thread_sleepy
);
1733 HRESULT
PullPin_WaitForStateChange(PullPin
* This
, DWORD dwMilliseconds
)
1735 if (WaitForSingleObject(This
->hEventStateChanged
, dwMilliseconds
) == WAIT_TIMEOUT
)
1740 HRESULT WINAPI
PullPin_EndOfStream(IPin
* iface
)
1742 FIXME("(%p)->() stub\n", iface
);
1744 return SendFurther( iface
, deliver_endofstream
, NULL
, NULL
);
1747 HRESULT WINAPI
PullPin_BeginFlush(IPin
* iface
)
1749 PullPin
*This
= (PullPin
*)iface
;
1750 TRACE("(%p)->()\n", This
);
1752 EnterCriticalSection(This
->pin
.pCritSec
);
1754 SendFurther( iface
, deliver_beginflush
, NULL
, NULL
);
1756 LeaveCriticalSection(This
->pin
.pCritSec
);
1758 EnterCriticalSection(&This
->thread_lock
);
1760 PullPin_WaitForStateChange(This
, INFINITE
);
1762 if (This
->hThread
&& !This
->stop_playback
)
1764 PullPin_PauseProcessing(This
);
1765 PullPin_WaitForStateChange(This
, INFINITE
);
1768 LeaveCriticalSection(&This
->thread_lock
);
1770 EnterCriticalSection(This
->pin
.pCritSec
);
1772 This
->fnCleanProc(This
->pin
.pUserData
);
1774 LeaveCriticalSection(This
->pin
.pCritSec
);
1779 HRESULT WINAPI
PullPin_EndFlush(IPin
* iface
)
1781 PullPin
*This
= (PullPin
*)iface
;
1783 TRACE("(%p)->()\n", iface
);
1785 EnterCriticalSection(&This
->thread_lock
);
1788 IBaseFilter_GetState(This
->pin
.pinInfo
.pFilter
, INFINITE
, &state
);
1790 if (This
->stop_playback
&& state
== State_Running
)
1791 PullPin_StartProcessing(This
);
1793 PullPin_WaitForStateChange(This
, INFINITE
);
1795 LeaveCriticalSection(&This
->thread_lock
);
1797 EnterCriticalSection(This
->pin
.pCritSec
);
1798 SendFurther( iface
, deliver_endflush
, NULL
, NULL
);
1799 LeaveCriticalSection(This
->pin
.pCritSec
);
1804 HRESULT WINAPI
PullPin_Disconnect(IPin
*iface
)
1807 PullPin
*This
= (PullPin
*)iface
;
1811 EnterCriticalSection(This
->pin
.pCritSec
);
1813 if (FAILED(hr
= IMemAllocator_Decommit(This
->pAlloc
)))
1814 ERR("Allocator decommit failed with error %x. Possible memory leak\n", hr
);
1816 if (This
->pin
.pConnectedTo
)
1818 IPin_Release(This
->pin
.pConnectedTo
);
1819 This
->pin
.pConnectedTo
= NULL
;
1825 LeaveCriticalSection(This
->pin
.pCritSec
);
1830 HRESULT WINAPI
PullPin_NewSegment(IPin
* iface
, REFERENCE_TIME tStart
, REFERENCE_TIME tStop
, double dRate
)
1832 newsegmentargs args
;
1833 FIXME("(%p)->(%s, %s, %g) stub\n", iface
, wine_dbgstr_longlong(tStart
), wine_dbgstr_longlong(tStop
), dRate
);
1835 args
.tStart
= tStart
;
1839 return SendFurther( iface
, deliver_newsegment
, &args
, NULL
);
1842 static const IPinVtbl PullPin_Vtbl
=
1844 PullPin_QueryInterface
,
1848 PullPin_ReceiveConnection
,
1850 IPinImpl_ConnectedTo
,
1851 IPinImpl_ConnectionMediaType
,
1852 IPinImpl_QueryPinInfo
,
1853 IPinImpl_QueryDirection
,
1855 IPinImpl_QueryAccept
,
1856 IPinImpl_EnumMediaTypes
,
1857 IPinImpl_QueryInternalConnections
,
1858 PullPin_EndOfStream
,