750752e733e331af376e26349c16d52978b73716
[reactos.git] / reactos / lib / 3rdparty / strmbase / pin.c
1 /*
2 * Generic Implementation of IPin Interface
3 *
4 * Copyright 2003 Robert Shearman
5 * Copyright 2010 Aric Stewart, CodeWeavers
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #define COBJMACROS
23
24 #include "dshow.h"
25 #include "wine/debug.h"
26 #include "wine/unicode.h"
27 #include "wine/strmbase.h"
28 #include "uuids.h"
29 #include "vfwmsgs.h"
30 #include <assert.h>
31
32 WINE_DEFAULT_DEBUG_CHANNEL(strmbase);
33
34 static const IPinVtbl InputPin_Vtbl;
35 static const IPinVtbl OutputPin_Vtbl;
36 static const IMemInputPinVtbl MemInputPin_Vtbl;
37
38 typedef HRESULT (*SendPinFunc)( IPin *to, LPVOID arg );
39
40 static inline BasePin *impl_from_IPin( IPin *iface )
41 {
42 return CONTAINING_RECORD(iface, BasePin, IPin_iface);
43 }
44
45 /** Helper function, there are a lot of places where the error code is inherited
46 * The following rules apply:
47 *
48 * Return the first received error code (E_NOTIMPL is ignored)
49 * If no errors occur: return the first received non-error-code that isn't S_OK
50 */
51 static HRESULT updatehres( HRESULT original, HRESULT new )
52 {
53 if (FAILED( original ) || new == E_NOTIMPL)
54 return original;
55
56 if (FAILED( new ) || original == S_OK)
57 return new;
58
59 return original;
60 }
61
62 /** Sends a message from a pin further to other, similar pins
63 * fnMiddle is called on each pin found further on the stream.
64 * fnEnd (can be NULL) is called when the message can't be sent any further (this is a renderer or source)
65 *
66 * If the pin given is an input pin, the message will be sent downstream to other input pins
67 * If the pin given is an output pin, the message will be sent upstream to other output pins
68 */
69 static HRESULT SendFurther( IPin *from, SendPinFunc fnMiddle, LPVOID arg, SendPinFunc fnEnd )
70 {
71 PIN_INFO pin_info;
72 ULONG amount = 0;
73 HRESULT hr = S_OK;
74 HRESULT hr_return = S_OK;
75 IEnumPins *enumpins = NULL;
76 BOOL foundend = TRUE;
77 PIN_DIRECTION from_dir;
78
79 IPin_QueryDirection( from, &from_dir );
80
81 hr = IPin_QueryInternalConnections( from, NULL, &amount );
82 if (hr != E_NOTIMPL && amount)
83 FIXME("Use QueryInternalConnections!\n");
84 hr = S_OK;
85
86 pin_info.pFilter = NULL;
87 hr = IPin_QueryPinInfo( from, &pin_info );
88 if (FAILED(hr))
89 goto out;
90
91 hr = IBaseFilter_EnumPins( pin_info.pFilter, &enumpins );
92 if (FAILED(hr))
93 goto out;
94
95 hr = IEnumPins_Reset( enumpins );
96 while (hr == S_OK) {
97 IPin *pin = NULL;
98 hr = IEnumPins_Next( enumpins, 1, &pin, NULL );
99 if (hr == VFW_E_ENUM_OUT_OF_SYNC)
100 {
101 hr = IEnumPins_Reset( enumpins );
102 continue;
103 }
104 if (pin)
105 {
106 PIN_DIRECTION dir;
107
108 IPin_QueryDirection( pin, &dir );
109 if (dir != from_dir)
110 {
111 IPin *connected = NULL;
112
113 foundend = FALSE;
114 IPin_ConnectedTo( pin, &connected );
115 if (connected)
116 {
117 HRESULT hr_local;
118
119 hr_local = fnMiddle( connected, arg );
120 hr_return = updatehres( hr_return, hr_local );
121 IPin_Release(connected);
122 }
123 }
124 IPin_Release( pin );
125 }
126 else
127 {
128 hr = S_OK;
129 break;
130 }
131 }
132
133 if (!foundend)
134 hr = hr_return;
135 else if (fnEnd) {
136 HRESULT hr_local;
137
138 hr_local = fnEnd( from, arg );
139 hr_return = updatehres( hr_return, hr_local );
140 }
141 IEnumPins_Release(enumpins);
142
143 out:
144 if (pin_info.pFilter)
145 IBaseFilter_Release( pin_info.pFilter );
146 return hr;
147 }
148
149 static void Copy_PinInfo(PIN_INFO * pDest, const PIN_INFO * pSrc)
150 {
151 /* Tempting to just do a memcpy, but the name field is
152 128 characters long! We will probably never exceed 10
153 most of the time, so we are better off copying
154 each field manually */
155 strcpyW(pDest->achName, pSrc->achName);
156 pDest->dir = pSrc->dir;
157 pDest->pFilter = pSrc->pFilter;
158 }
159
160 static void dump_AM_MEDIA_TYPE(const AM_MEDIA_TYPE * pmt)
161 {
162 if (!pmt)
163 return;
164 TRACE("\t%s\n\t%s\n\t...\n\t%s\n", debugstr_guid(&pmt->majortype), debugstr_guid(&pmt->subtype), debugstr_guid(&pmt->formattype));
165 }
166
167 static BOOL CompareMediaTypes(const AM_MEDIA_TYPE * pmt1, const AM_MEDIA_TYPE * pmt2, BOOL bWildcards)
168 {
169 TRACE("pmt1: ");
170 dump_AM_MEDIA_TYPE(pmt1);
171 TRACE("pmt2: ");
172 dump_AM_MEDIA_TYPE(pmt2);
173 return (((bWildcards && (IsEqualGUID(&pmt1->majortype, &GUID_NULL) || IsEqualGUID(&pmt2->majortype, &GUID_NULL))) || IsEqualGUID(&pmt1->majortype, &pmt2->majortype)) &&
174 ((bWildcards && (IsEqualGUID(&pmt1->subtype, &GUID_NULL) || IsEqualGUID(&pmt2->subtype, &GUID_NULL))) || IsEqualGUID(&pmt1->subtype, &pmt2->subtype)));
175 }
176
177 /*** Common Base Pin function */
178 HRESULT WINAPI BasePinImpl_GetMediaType(BasePin *iface, int iPosition, AM_MEDIA_TYPE *pmt)
179 {
180 if (iPosition < 0)
181 return E_INVALIDARG;
182 return VFW_S_NO_MORE_ITEMS;
183 }
184
185 LONG WINAPI BasePinImpl_GetMediaTypeVersion(BasePin *iface)
186 {
187 return 1;
188 }
189
190 ULONG WINAPI BasePinImpl_AddRef(IPin * iface)
191 {
192 BasePin *This = impl_from_IPin(iface);
193 ULONG refCount = InterlockedIncrement(&This->refCount);
194
195 TRACE("(%p)->() AddRef from %d\n", iface, refCount - 1);
196
197 return refCount;
198 }
199
200 HRESULT WINAPI BasePinImpl_Disconnect(IPin * iface)
201 {
202 HRESULT hr;
203 BasePin *This = impl_from_IPin(iface);
204
205 TRACE("()\n");
206
207 EnterCriticalSection(This->pCritSec);
208 {
209 if (This->pConnectedTo)
210 {
211 IPin_Release(This->pConnectedTo);
212 This->pConnectedTo = NULL;
213 FreeMediaType(&This->mtCurrent);
214 ZeroMemory(&This->mtCurrent, sizeof(This->mtCurrent));
215 hr = S_OK;
216 }
217 else
218 hr = S_FALSE;
219 }
220 LeaveCriticalSection(This->pCritSec);
221
222 return hr;
223 }
224
225 HRESULT WINAPI BasePinImpl_ConnectedTo(IPin * iface, IPin ** ppPin)
226 {
227 HRESULT hr;
228 BasePin *This = impl_from_IPin(iface);
229
230 TRACE("(%p)\n", ppPin);
231
232 EnterCriticalSection(This->pCritSec);
233 {
234 if (This->pConnectedTo)
235 {
236 *ppPin = This->pConnectedTo;
237 IPin_AddRef(*ppPin);
238 hr = S_OK;
239 }
240 else
241 {
242 hr = VFW_E_NOT_CONNECTED;
243 *ppPin = NULL;
244 }
245 }
246 LeaveCriticalSection(This->pCritSec);
247
248 return hr;
249 }
250
251 HRESULT WINAPI BasePinImpl_ConnectionMediaType(IPin * iface, AM_MEDIA_TYPE * pmt)
252 {
253 HRESULT hr;
254 BasePin *This = impl_from_IPin(iface);
255
256 TRACE("(%p/%p)->(%p)\n", This, iface, pmt);
257
258 EnterCriticalSection(This->pCritSec);
259 {
260 if (This->pConnectedTo)
261 {
262 CopyMediaType(pmt, &This->mtCurrent);
263 hr = S_OK;
264 }
265 else
266 {
267 ZeroMemory(pmt, sizeof(*pmt));
268 hr = VFW_E_NOT_CONNECTED;
269 }
270 }
271 LeaveCriticalSection(This->pCritSec);
272
273 return hr;
274 }
275
276 HRESULT WINAPI BasePinImpl_QueryPinInfo(IPin * iface, PIN_INFO * pInfo)
277 {
278 BasePin *This = impl_from_IPin(iface);
279
280 TRACE("(%p/%p)->(%p)\n", This, iface, pInfo);
281
282 Copy_PinInfo(pInfo, &This->pinInfo);
283 IBaseFilter_AddRef(pInfo->pFilter);
284
285 return S_OK;
286 }
287
288 HRESULT WINAPI BasePinImpl_QueryDirection(IPin * iface, PIN_DIRECTION * pPinDir)
289 {
290 BasePin *This = impl_from_IPin(iface);
291
292 TRACE("(%p/%p)->(%p)\n", This, iface, pPinDir);
293
294 *pPinDir = This->pinInfo.dir;
295
296 return S_OK;
297 }
298
299 HRESULT WINAPI BasePinImpl_QueryId(IPin * iface, LPWSTR * Id)
300 {
301 BasePin *This = impl_from_IPin(iface);
302
303 TRACE("(%p/%p)->(%p)\n", This, iface, Id);
304
305 *Id = CoTaskMemAlloc((strlenW(This->pinInfo.achName) + 1) * sizeof(WCHAR));
306 if (!*Id)
307 return E_OUTOFMEMORY;
308
309 strcpyW(*Id, This->pinInfo.achName);
310
311 return S_OK;
312 }
313
314 HRESULT WINAPI BasePinImpl_QueryAccept(IPin * iface, const AM_MEDIA_TYPE * pmt)
315 {
316 TRACE("(%p)->(%p)\n", iface, pmt);
317
318 return S_OK;
319 }
320
321 HRESULT WINAPI BasePinImpl_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum)
322 {
323 BasePin *This = impl_from_IPin(iface);
324
325 TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
326
327 /* override this method to allow enumeration of your types */
328
329 return EnumMediaTypes_Construct(This, This->pFuncsTable->pfnGetMediaType, This->pFuncsTable->pfnGetMediaTypeVersion , ppEnum);
330 }
331
332 HRESULT WINAPI BasePinImpl_QueryInternalConnections(IPin * iface, IPin ** apPin, ULONG * cPin)
333 {
334 BasePin *This = impl_from_IPin(iface);
335
336 TRACE("(%p/%p)->(%p, %p)\n", This, iface, apPin, cPin);
337
338 return E_NOTIMPL; /* to tell caller that all input pins connected to all output pins */
339 }
340
341 HRESULT WINAPI BasePinImpl_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
342 {
343 BasePin *This = impl_from_IPin(iface);
344
345 TRACE("(%x%08x, %x%08x, %e)\n", (ULONG)(tStart >> 32), (ULONG)tStart, (ULONG)(tStop >> 32), (ULONG)tStop, dRate);
346
347 This->tStart = tStart;
348 This->tStop = tStop;
349 This->dRate = dRate;
350
351 return S_OK;
352 }
353
354 /*** OutputPin implementation ***/
355
356 static inline BaseOutputPin *impl_BaseOutputPin_from_IPin( IPin *iface )
357 {
358 return CONTAINING_RECORD(iface, BaseOutputPin, pin.IPin_iface);
359 }
360
361 static inline BaseOutputPin *impl_BaseOutputPin_from_BasePin( BasePin *iface )
362 {
363 return CONTAINING_RECORD(iface, BaseOutputPin, pin);
364 }
365
366 HRESULT WINAPI BaseOutputPinImpl_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
367 {
368 BaseOutputPin *This = impl_BaseOutputPin_from_IPin(iface);
369
370 TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppv);
371
372 *ppv = NULL;
373
374 if (IsEqualIID(riid, &IID_IUnknown))
375 *ppv = iface;
376 else if (IsEqualIID(riid, &IID_IPin))
377 *ppv = iface;
378 else if (IsEqualIID(riid, &IID_IMediaSeeking) ||
379 IsEqualIID(riid, &IID_IQualityControl))
380 {
381 return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, riid, ppv);
382 }
383
384 if (*ppv)
385 {
386 IUnknown_AddRef((IUnknown *)(*ppv));
387 return S_OK;
388 }
389
390 FIXME("No interface for %s!\n", debugstr_guid(riid));
391
392 return E_NOINTERFACE;
393 }
394
395 ULONG WINAPI BaseOutputPinImpl_Release(IPin * iface)
396 {
397 BaseOutputPin *This = impl_BaseOutputPin_from_IPin(iface);
398 ULONG refCount = InterlockedDecrement(&This->pin.refCount);
399
400 TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
401
402 if (!refCount)
403 {
404 FreeMediaType(&This->pin.mtCurrent);
405 if (This->pAllocator)
406 IMemAllocator_Release(This->pAllocator);
407 This->pAllocator = NULL;
408 CoTaskMemFree(This);
409 return 0;
410 }
411 return refCount;
412 }
413
414 HRESULT WINAPI BaseOutputPinImpl_Connect(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
415 {
416 HRESULT hr;
417 BaseOutputPin *This = impl_BaseOutputPin_from_IPin(iface);
418
419 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt);
420 dump_AM_MEDIA_TYPE(pmt);
421
422 /* If we try to connect to ourselves, we will definitely deadlock.
423 * There are other cases where we could deadlock too, but this
424 * catches the obvious case */
425 assert(pReceivePin != iface);
426
427 EnterCriticalSection(This->pin.pCritSec);
428 {
429 /* if we have been a specific type to connect with, then we can either connect
430 * with that or fail. We cannot choose different AM_MEDIA_TYPE */
431 if (pmt && !IsEqualGUID(&pmt->majortype, &GUID_NULL) && !IsEqualGUID(&pmt->subtype, &GUID_NULL))
432 hr = This->pin.pFuncsTable->pfnAttemptConnection(&This->pin, pReceivePin, pmt);
433 else
434 {
435 /* negotiate media type */
436
437 IEnumMediaTypes * pEnumCandidates;
438 AM_MEDIA_TYPE * pmtCandidate = NULL; /* Candidate media type */
439
440 if (SUCCEEDED(hr = IPin_EnumMediaTypes(iface, &pEnumCandidates)))
441 {
442 hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */
443
444 /* try this filter's media types first */
445 while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL))
446 {
447 assert(pmtCandidate);
448 dump_AM_MEDIA_TYPE(pmtCandidate);
449 if (!IsEqualGUID(&FORMAT_None, &pmtCandidate->formattype)
450 && !IsEqualGUID(&GUID_NULL, &pmtCandidate->formattype))
451 assert(pmtCandidate->pbFormat);
452 if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) &&
453 (This->pin.pFuncsTable->pfnAttemptConnection(&This->pin, pReceivePin, pmtCandidate) == S_OK))
454 {
455 hr = S_OK;
456 DeleteMediaType(pmtCandidate);
457 break;
458 }
459 DeleteMediaType(pmtCandidate);
460 pmtCandidate = NULL;
461 }
462 IEnumMediaTypes_Release(pEnumCandidates);
463 }
464
465 /* then try receiver filter's media types */
466 if (hr != S_OK && SUCCEEDED(hr = IPin_EnumMediaTypes(pReceivePin, &pEnumCandidates))) /* if we haven't already connected successfully */
467 {
468 hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */
469
470 while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL))
471 {
472 assert(pmtCandidate);
473 dump_AM_MEDIA_TYPE(pmtCandidate);
474 if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) &&
475 (This->pin.pFuncsTable->pfnAttemptConnection(&This->pin, pReceivePin, pmtCandidate) == S_OK))
476 {
477 hr = S_OK;
478 DeleteMediaType(pmtCandidate);
479 break;
480 }
481 DeleteMediaType(pmtCandidate);
482 pmtCandidate = NULL;
483 } /* while */
484 IEnumMediaTypes_Release(pEnumCandidates);
485 } /* if not found */
486 } /* if negotiate media type */
487 } /* if succeeded */
488 LeaveCriticalSection(This->pin.pCritSec);
489
490 TRACE(" -- %x\n", hr);
491 return hr;
492 }
493
494 HRESULT WINAPI BaseOutputPinImpl_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
495 {
496 ERR("Incoming connection on an output pin! (%p, %p)\n", pReceivePin, pmt);
497
498 return E_UNEXPECTED;
499 }
500
501 HRESULT WINAPI BaseOutputPinImpl_Disconnect(IPin * iface)
502 {
503 HRESULT hr;
504 BaseOutputPin *This = impl_BaseOutputPin_from_IPin(iface);
505
506 TRACE("()\n");
507
508 EnterCriticalSection(This->pin.pCritSec);
509 {
510 if (This->pMemInputPin)
511 {
512 IMemInputPin_Release(This->pMemInputPin);
513 This->pMemInputPin = NULL;
514 }
515 if (This->pin.pConnectedTo)
516 {
517 IPin_Release(This->pin.pConnectedTo);
518 This->pin.pConnectedTo = NULL;
519 FreeMediaType(&This->pin.mtCurrent);
520 ZeroMemory(&This->pin.mtCurrent, sizeof(This->pin.mtCurrent));
521 hr = S_OK;
522 }
523 else
524 hr = S_FALSE;
525 }
526 LeaveCriticalSection(This->pin.pCritSec);
527
528 return hr;
529 }
530
531 HRESULT WINAPI BaseOutputPinImpl_EndOfStream(IPin * iface)
532 {
533 TRACE("()\n");
534
535 /* not supposed to do anything in an output pin */
536
537 return E_UNEXPECTED;
538 }
539
540 HRESULT WINAPI BaseOutputPinImpl_BeginFlush(IPin * iface)
541 {
542 TRACE("(%p)->()\n", iface);
543
544 /* not supposed to do anything in an output pin */
545
546 return E_UNEXPECTED;
547 }
548
549 HRESULT WINAPI BaseOutputPinImpl_EndFlush(IPin * iface)
550 {
551 TRACE("(%p)->()\n", iface);
552
553 /* not supposed to do anything in an output pin */
554
555 return E_UNEXPECTED;
556 }
557
558 static const IPinVtbl OutputPin_Vtbl =
559 {
560 BaseOutputPinImpl_QueryInterface,
561 BasePinImpl_AddRef,
562 BaseOutputPinImpl_Release,
563 BaseOutputPinImpl_Connect,
564 BaseOutputPinImpl_ReceiveConnection,
565 BaseOutputPinImpl_Disconnect,
566 BasePinImpl_ConnectedTo,
567 BasePinImpl_ConnectionMediaType,
568 BasePinImpl_QueryPinInfo,
569 BasePinImpl_QueryDirection,
570 BasePinImpl_QueryId,
571 BasePinImpl_QueryAccept,
572 BasePinImpl_EnumMediaTypes,
573 BasePinImpl_QueryInternalConnections,
574 BaseOutputPinImpl_EndOfStream,
575 BaseOutputPinImpl_BeginFlush,
576 BaseOutputPinImpl_EndFlush,
577 BasePinImpl_NewSegment
578 };
579
580 HRESULT WINAPI BaseOutputPinImpl_GetDeliveryBuffer(BaseOutputPin *This, IMediaSample ** ppSample, REFERENCE_TIME * tStart, REFERENCE_TIME * tStop, DWORD dwFlags)
581 {
582 HRESULT hr;
583
584 TRACE("(%p, %p, %p, %x)\n", ppSample, tStart, tStop, dwFlags);
585
586 if (!This->pin.pConnectedTo)
587 hr = VFW_E_NOT_CONNECTED;
588 else
589 {
590 hr = IMemAllocator_GetBuffer(This->pAllocator, ppSample, tStart, tStop, dwFlags);
591
592 if (SUCCEEDED(hr))
593 hr = IMediaSample_SetTime(*ppSample, tStart, tStop);
594 }
595
596 return hr;
597 }
598
599 /* replaces OutputPin_SendSample */
600 HRESULT WINAPI BaseOutputPinImpl_Deliver(BaseOutputPin *This, IMediaSample * pSample)
601 {
602 HRESULT hr = S_OK;
603 IMemInputPin * pMemConnected = NULL;
604 PIN_INFO pinInfo;
605
606 EnterCriticalSection(This->pin.pCritSec);
607 {
608 if (!This->pin.pConnectedTo || !This->pMemInputPin)
609 hr = VFW_E_NOT_CONNECTED;
610 else
611 {
612 /* we don't have the lock held when using This->pMemInputPin,
613 * so we need to AddRef it to stop it being deleted while we are
614 * using it. Same with its filter. */
615 pMemConnected = This->pMemInputPin;
616 IMemInputPin_AddRef(pMemConnected);
617 hr = IPin_QueryPinInfo(This->pin.pConnectedTo, &pinInfo);
618 }
619 }
620 LeaveCriticalSection(This->pin.pCritSec);
621
622 if (SUCCEEDED(hr))
623 {
624 /* NOTE: if we are in a critical section when Receive is called
625 * then it causes some problems (most notably with the native Video
626 * Renderer) if we are re-entered for whatever reason */
627 hr = IMemInputPin_Receive(pMemConnected, pSample);
628
629 /* If the filter's destroyed, tell upstream to stop sending data */
630 if(IBaseFilter_Release(pinInfo.pFilter) == 0 && SUCCEEDED(hr))
631 hr = S_FALSE;
632 }
633 if (pMemConnected)
634 IMemInputPin_Release(pMemConnected);
635
636 return hr;
637 }
638
639 /* replaces OutputPin_CommitAllocator */
640 HRESULT WINAPI BaseOutputPinImpl_Active(BaseOutputPin *This)
641 {
642 HRESULT hr = S_OK;
643
644 TRACE("(%p)->()\n", This);
645
646 EnterCriticalSection(This->pin.pCritSec);
647 {
648 if (!This->pin.pConnectedTo || !This->pMemInputPin)
649 hr = VFW_E_NOT_CONNECTED;
650 else
651 hr = IMemAllocator_Commit(This->pAllocator);
652 }
653 LeaveCriticalSection(This->pin.pCritSec);
654
655 TRACE("--> %08x\n", hr);
656 return hr;
657 }
658
659 /* replaces OutputPin_DecommitAllocator */
660 HRESULT WINAPI BaseOutputPinImpl_Inactive(BaseOutputPin *This)
661 {
662 HRESULT hr = S_OK;
663
664 TRACE("(%p)->()\n", This);
665
666 EnterCriticalSection(This->pin.pCritSec);
667 {
668 if (!This->pin.pConnectedTo || !This->pMemInputPin)
669 hr = VFW_E_NOT_CONNECTED;
670 else
671 hr = IMemAllocator_Decommit(This->pAllocator);
672 }
673 LeaveCriticalSection(This->pin.pCritSec);
674
675 TRACE("--> %08x\n", hr);
676 return hr;
677 }
678
679 /* replaces OutputPin_DeliverDisconnect */
680 HRESULT WINAPI BaseOutputPinImpl_BreakConnect(BaseOutputPin *This)
681 {
682 HRESULT hr;
683
684 TRACE("(%p)->()\n", This);
685
686 EnterCriticalSection(This->pin.pCritSec);
687 {
688 if (!This->pin.pConnectedTo || !This->pMemInputPin)
689 hr = VFW_E_NOT_CONNECTED;
690 else
691 {
692 hr = IMemAllocator_Decommit(This->pAllocator);
693
694 if (SUCCEEDED(hr))
695 hr = IPin_Disconnect(This->pin.pConnectedTo);
696 }
697 IPin_Disconnect(&This->pin.IPin_iface);
698 }
699 LeaveCriticalSection(This->pin.pCritSec);
700
701 return hr;
702 }
703
704 HRESULT WINAPI BaseOutputPinImpl_InitAllocator(BaseOutputPin *This, IMemAllocator **pMemAlloc)
705 {
706 return CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC_SERVER, &IID_IMemAllocator, (LPVOID*)pMemAlloc);
707 }
708
709 HRESULT WINAPI BaseOutputPinImpl_DecideAllocator(BaseOutputPin *This, IMemInputPin *pPin, IMemAllocator **pAlloc)
710 {
711 HRESULT hr;
712
713 hr = IMemInputPin_GetAllocator(pPin, pAlloc);
714
715 if (hr == VFW_E_NO_ALLOCATOR)
716 /* Input pin provides no allocator, use standard memory allocator */
717 hr = BaseOutputPinImpl_InitAllocator(This, pAlloc);
718
719 if (SUCCEEDED(hr))
720 {
721 ALLOCATOR_PROPERTIES rProps;
722 ZeroMemory(&rProps, sizeof(ALLOCATOR_PROPERTIES));
723
724 IMemInputPin_GetAllocatorRequirements(pPin, &rProps);
725 hr = This->pFuncsTable->pfnDecideBufferSize(This, *pAlloc, &rProps);
726 }
727
728 if (SUCCEEDED(hr))
729 hr = IMemInputPin_NotifyAllocator(pPin, *pAlloc, FALSE);
730
731 return hr;
732 }
733
734 /*** The Construct functions ***/
735
736 /* Function called as a helper to IPin_Connect */
737 /* specific AM_MEDIA_TYPE - it cannot be NULL */
738 HRESULT WINAPI BaseOutputPinImpl_AttemptConnection(BasePin* iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
739 {
740 BaseOutputPin *This = impl_BaseOutputPin_from_BasePin(iface);
741 HRESULT hr;
742 IMemAllocator * pMemAlloc = NULL;
743
744 TRACE("(%p, %p)\n", pReceivePin, pmt);
745 dump_AM_MEDIA_TYPE(pmt);
746
747 /* FIXME: call queryacceptproc */
748
749 This->pin.pConnectedTo = pReceivePin;
750 IPin_AddRef(pReceivePin);
751 CopyMediaType(&This->pin.mtCurrent, pmt);
752
753 hr = IPin_ReceiveConnection(pReceivePin, &iface->IPin_iface, pmt);
754
755 /* get the IMemInputPin interface we will use to deliver samples to the
756 * connected pin */
757 if (SUCCEEDED(hr))
758 {
759 This->pMemInputPin = NULL;
760 hr = IPin_QueryInterface(pReceivePin, &IID_IMemInputPin, (LPVOID)&This->pMemInputPin);
761
762 if (SUCCEEDED(hr))
763 {
764 hr = This->pFuncsTable->pfnDecideAllocator(This, This->pMemInputPin, &pMemAlloc);
765 if (SUCCEEDED(hr))
766 This->pAllocator = pMemAlloc;
767 else if (pMemAlloc)
768 IMemAllocator_Release(pMemAlloc);
769 }
770
771 /* break connection if we couldn't get the allocator */
772 if (FAILED(hr))
773 {
774 if (This->pMemInputPin)
775 IMemInputPin_Release(This->pMemInputPin);
776 This->pMemInputPin = NULL;
777
778 IPin_Disconnect(pReceivePin);
779 }
780 }
781
782 if (FAILED(hr))
783 {
784 IPin_Release(This->pin.pConnectedTo);
785 This->pin.pConnectedTo = NULL;
786 FreeMediaType(&This->pin.mtCurrent);
787 }
788
789 TRACE(" -- %x\n", hr);
790 return hr;
791 }
792
793 static HRESULT OutputPin_Init(const IPinVtbl *OutputPin_Vtbl, const PIN_INFO * pPinInfo, const BasePinFuncTable* pBaseFuncsTable, const BaseOutputPinFuncTable* pBaseOutputFuncsTable, LPCRITICAL_SECTION pCritSec, BaseOutputPin * pPinImpl)
794 {
795 TRACE("\n");
796
797 /* Common attributes */
798 pPinImpl->pin.IPin_iface.lpVtbl = OutputPin_Vtbl;
799 pPinImpl->pin.refCount = 1;
800 pPinImpl->pin.pConnectedTo = NULL;
801 pPinImpl->pin.pCritSec = pCritSec;
802 pPinImpl->pin.tStart = 0;
803 pPinImpl->pin.tStop = 0;
804 pPinImpl->pin.dRate = 1.0;
805 Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
806 pPinImpl->pin.pFuncsTable = pBaseFuncsTable;
807 ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE));
808
809 /* Output pin attributes */
810 pPinImpl->pMemInputPin = NULL;
811 pPinImpl->pAllocator = NULL;
812 pPinImpl->pFuncsTable = pBaseOutputFuncsTable;
813
814 return S_OK;
815 }
816
817 HRESULT WINAPI BaseOutputPin_Construct(const IPinVtbl *OutputPin_Vtbl, LONG outputpin_size, const PIN_INFO * pPinInfo, const BasePinFuncTable* pBaseFuncsTable, const BaseOutputPinFuncTable* pBaseOutputFuncsTable, LPCRITICAL_SECTION pCritSec, IPin ** ppPin)
818 {
819 BaseOutputPin * pPinImpl;
820
821 *ppPin = NULL;
822
823 if (pPinInfo->dir != PINDIR_OUTPUT)
824 {
825 ERR("Pin direction(%x) != PINDIR_OUTPUT\n", pPinInfo->dir);
826 return E_INVALIDARG;
827 }
828
829 assert(outputpin_size >= sizeof(BaseOutputPin));
830 assert(pBaseFuncsTable->pfnAttemptConnection);
831
832 pPinImpl = CoTaskMemAlloc(outputpin_size);
833
834 if (!pPinImpl)
835 return E_OUTOFMEMORY;
836
837 if (SUCCEEDED(OutputPin_Init(OutputPin_Vtbl, pPinInfo, pBaseFuncsTable, pBaseOutputFuncsTable, pCritSec, pPinImpl)))
838 {
839 *ppPin = &pPinImpl->pin.IPin_iface;
840 return S_OK;
841 }
842
843 CoTaskMemFree(pPinImpl);
844 return E_FAIL;
845 }
846
847 /*** Input Pin implementation ***/
848
849 static inline BaseInputPin *impl_BaseInputPin_from_IPin( IPin *iface )
850 {
851 return CONTAINING_RECORD(iface, BaseInputPin, pin.IPin_iface);
852 }
853
854 static inline BaseInputPin *impl_BaseInputPin_from_BasePin( BasePin *iface )
855 {
856 return CONTAINING_RECORD(iface, BaseInputPin, pin);
857 }
858
859 HRESULT WINAPI BaseInputPinImpl_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
860 {
861 BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
862
863 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
864
865 *ppv = NULL;
866
867 if (IsEqualIID(riid, &IID_IUnknown))
868 *ppv = iface;
869 else if (IsEqualIID(riid, &IID_IPin))
870 *ppv = iface;
871 else if (IsEqualIID(riid, &IID_IMemInputPin))
872 *ppv = &This->IMemInputPin_iface;
873 else if (IsEqualIID(riid, &IID_IMediaSeeking))
874 {
875 return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv);
876 }
877
878 if (*ppv)
879 {
880 IUnknown_AddRef((IUnknown *)(*ppv));
881 return S_OK;
882 }
883
884 FIXME("No interface for %s!\n", debugstr_guid(riid));
885
886 return E_NOINTERFACE;
887 }
888
889 ULONG WINAPI BaseInputPinImpl_Release(IPin * iface)
890 {
891 BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
892 ULONG refCount = InterlockedDecrement(&This->pin.refCount);
893
894 TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
895
896 if (!refCount)
897 {
898 FreeMediaType(&This->pin.mtCurrent);
899 if (This->pAllocator)
900 IMemAllocator_Release(This->pAllocator);
901 This->pAllocator = NULL;
902 This->pin.IPin_iface.lpVtbl = NULL;
903 CoTaskMemFree(This);
904 return 0;
905 }
906 else
907 return refCount;
908 }
909
910 HRESULT WINAPI BaseInputPinImpl_Connect(IPin * iface, IPin * pConnector, const AM_MEDIA_TYPE * pmt)
911 {
912 ERR("Outgoing connection on an input pin! (%p, %p)\n", pConnector, pmt);
913
914 return E_UNEXPECTED;
915 }
916
917
918 HRESULT WINAPI BaseInputPinImpl_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
919 {
920 BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
921 PIN_DIRECTION pindirReceive;
922 HRESULT hr = S_OK;
923
924 TRACE("(%p, %p)\n", pReceivePin, pmt);
925 dump_AM_MEDIA_TYPE(pmt);
926
927 EnterCriticalSection(This->pin.pCritSec);
928 {
929 if (This->pin.pConnectedTo)
930 hr = VFW_E_ALREADY_CONNECTED;
931
932 if (SUCCEEDED(hr) && This->pin.pFuncsTable->pfnCheckMediaType(&This->pin, pmt) != S_OK)
933 hr = VFW_E_TYPE_NOT_ACCEPTED; /* FIXME: shouldn't we just map common errors onto
934 * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */
935
936 if (SUCCEEDED(hr))
937 {
938 IPin_QueryDirection(pReceivePin, &pindirReceive);
939
940 if (pindirReceive != PINDIR_OUTPUT)
941 {
942 ERR("Can't connect from non-output pin\n");
943 hr = VFW_E_INVALID_DIRECTION;
944 }
945 }
946
947 if (SUCCEEDED(hr))
948 {
949 CopyMediaType(&This->pin.mtCurrent, pmt);
950 This->pin.pConnectedTo = pReceivePin;
951 IPin_AddRef(pReceivePin);
952 }
953 }
954 LeaveCriticalSection(This->pin.pCritSec);
955
956 return hr;
957 }
958
959 static HRESULT deliver_endofstream(IPin* pin, LPVOID unused)
960 {
961 return IPin_EndOfStream( pin );
962 }
963
964 HRESULT WINAPI BaseInputPinImpl_QueryAccept(IPin * iface, const AM_MEDIA_TYPE * pmt)
965 {
966 BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
967
968 TRACE("(%p/%p)->(%p)\n", This, iface, pmt);
969
970 return (This->pin.pFuncsTable->pfnCheckMediaType(&This->pin, pmt) == S_OK ? S_OK : S_FALSE);
971 }
972
973 HRESULT WINAPI BaseInputPinImpl_EndOfStream(IPin * iface)
974 {
975 HRESULT hr = S_OK;
976 BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
977
978 TRACE("(%p)\n", This);
979
980 EnterCriticalSection(This->pin.pCritSec);
981 if (This->flushing)
982 hr = S_FALSE;
983 else
984 This->end_of_stream = 1;
985 LeaveCriticalSection(This->pin.pCritSec);
986
987 if (hr == S_OK)
988 hr = SendFurther( iface, deliver_endofstream, NULL, NULL );
989 return hr;
990 }
991
992 static HRESULT deliver_beginflush(IPin* pin, LPVOID unused)
993 {
994 return IPin_BeginFlush( pin );
995 }
996
997 HRESULT WINAPI BaseInputPinImpl_BeginFlush(IPin * iface)
998 {
999 BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
1000 HRESULT hr;
1001 TRACE("() semi-stub\n");
1002
1003 EnterCriticalSection(This->pin.pCritSec);
1004 This->flushing = 1;
1005
1006 hr = SendFurther( iface, deliver_beginflush, NULL, NULL );
1007 LeaveCriticalSection(This->pin.pCritSec);
1008
1009 return hr;
1010 }
1011
1012 static HRESULT deliver_endflush(IPin* pin, LPVOID unused)
1013 {
1014 return IPin_EndFlush( pin );
1015 }
1016
1017 HRESULT WINAPI BaseInputPinImpl_EndFlush(IPin * iface)
1018 {
1019 BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
1020 HRESULT hr;
1021 TRACE("(%p)\n", This);
1022
1023 EnterCriticalSection(This->pin.pCritSec);
1024 This->flushing = This->end_of_stream = 0;
1025
1026 hr = SendFurther( iface, deliver_endflush, NULL, NULL );
1027 LeaveCriticalSection(This->pin.pCritSec);
1028
1029 return hr;
1030 }
1031
1032 typedef struct newsegmentargs
1033 {
1034 REFERENCE_TIME tStart, tStop;
1035 double rate;
1036 } newsegmentargs;
1037
1038 static HRESULT deliver_newsegment(IPin *pin, LPVOID data)
1039 {
1040 newsegmentargs *args = data;
1041 return IPin_NewSegment(pin, args->tStart, args->tStop, args->rate);
1042 }
1043
1044 HRESULT WINAPI BaseInputPinImpl_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
1045 {
1046 BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
1047 newsegmentargs args;
1048
1049 TRACE("(%x%08x, %x%08x, %e)\n", (ULONG)(tStart >> 32), (ULONG)tStart, (ULONG)(tStop >> 32), (ULONG)tStop, dRate);
1050
1051 args.tStart = This->pin.tStart = tStart;
1052 args.tStop = This->pin.tStop = tStop;
1053 args.rate = This->pin.dRate = dRate;
1054
1055 return SendFurther( iface, deliver_newsegment, &args, NULL );
1056 }
1057
1058 static const IPinVtbl InputPin_Vtbl =
1059 {
1060 BaseInputPinImpl_QueryInterface,
1061 BasePinImpl_AddRef,
1062 BaseInputPinImpl_Release,
1063 BaseInputPinImpl_Connect,
1064 BaseInputPinImpl_ReceiveConnection,
1065 BasePinImpl_Disconnect,
1066 BasePinImpl_ConnectedTo,
1067 BasePinImpl_ConnectionMediaType,
1068 BasePinImpl_QueryPinInfo,
1069 BasePinImpl_QueryDirection,
1070 BasePinImpl_QueryId,
1071 BaseInputPinImpl_QueryAccept,
1072 BasePinImpl_EnumMediaTypes,
1073 BasePinImpl_QueryInternalConnections,
1074 BaseInputPinImpl_EndOfStream,
1075 BaseInputPinImpl_BeginFlush,
1076 BaseInputPinImpl_EndFlush,
1077 BaseInputPinImpl_NewSegment
1078 };
1079
1080 /*** IMemInputPin implementation ***/
1081
1082 static inline BaseInputPin *impl_from_IMemInputPin( IMemInputPin *iface )
1083 {
1084 return CONTAINING_RECORD(iface, BaseInputPin, IMemInputPin_iface);
1085 }
1086
1087 static HRESULT WINAPI MemInputPin_QueryInterface(IMemInputPin * iface, REFIID riid, LPVOID * ppv)
1088 {
1089 BaseInputPin *This = impl_from_IMemInputPin(iface);
1090
1091 return IPin_QueryInterface(&This->pin.IPin_iface, riid, ppv);
1092 }
1093
1094 static ULONG WINAPI MemInputPin_AddRef(IMemInputPin * iface)
1095 {
1096 BaseInputPin *This = impl_from_IMemInputPin(iface);
1097
1098 return IPin_AddRef(&This->pin.IPin_iface);
1099 }
1100
1101 static ULONG WINAPI MemInputPin_Release(IMemInputPin * iface)
1102 {
1103 BaseInputPin *This = impl_from_IMemInputPin(iface);
1104
1105 return IPin_Release(&This->pin.IPin_iface);
1106 }
1107
1108 static HRESULT WINAPI MemInputPin_GetAllocator(IMemInputPin * iface, IMemAllocator ** ppAllocator)
1109 {
1110 BaseInputPin *This = impl_from_IMemInputPin(iface);
1111
1112 TRACE("(%p/%p)->(%p)\n", This, iface, ppAllocator);
1113
1114 *ppAllocator = This->pAllocator;
1115 if (*ppAllocator)
1116 IMemAllocator_AddRef(*ppAllocator);
1117
1118 return *ppAllocator ? S_OK : VFW_E_NO_ALLOCATOR;
1119 }
1120
1121 static HRESULT WINAPI MemInputPin_NotifyAllocator(IMemInputPin * iface, IMemAllocator * pAllocator, BOOL bReadOnly)
1122 {
1123 BaseInputPin *This = impl_from_IMemInputPin(iface);
1124
1125 TRACE("(%p/%p)->(%p, %d)\n", This, iface, pAllocator, bReadOnly);
1126
1127 if (bReadOnly)
1128 FIXME("Read only flag not handled yet!\n");
1129
1130 /* FIXME: Should we release the allocator on disconnection? */
1131 if (!pAllocator)
1132 {
1133 WARN("Null allocator\n");
1134 return E_POINTER;
1135 }
1136
1137 if (This->preferred_allocator && pAllocator != This->preferred_allocator)
1138 return E_FAIL;
1139
1140 if (This->pAllocator)
1141 IMemAllocator_Release(This->pAllocator);
1142 This->pAllocator = pAllocator;
1143 if (This->pAllocator)
1144 IMemAllocator_AddRef(This->pAllocator);
1145
1146 return S_OK;
1147 }
1148
1149 static HRESULT WINAPI MemInputPin_GetAllocatorRequirements(IMemInputPin * iface, ALLOCATOR_PROPERTIES * pProps)
1150 {
1151 BaseInputPin *This = impl_from_IMemInputPin(iface);
1152
1153 TRACE("(%p/%p)->(%p)\n", This, iface, pProps);
1154
1155 /* override this method if you have any specific requirements */
1156
1157 return E_NOTIMPL;
1158 }
1159
1160 static HRESULT WINAPI MemInputPin_Receive(IMemInputPin * iface, IMediaSample * pSample)
1161 {
1162 BaseInputPin *This = impl_from_IMemInputPin(iface);
1163 HRESULT hr = S_FALSE;
1164
1165 /* this trace commented out for performance reasons */
1166 /*TRACE("(%p/%p)->(%p)\n", This, iface, pSample);*/
1167 if (This->pFuncsTable->pfnReceive)
1168 hr = This->pFuncsTable->pfnReceive(This, pSample);
1169 return hr;
1170 }
1171
1172 static HRESULT WINAPI MemInputPin_ReceiveMultiple(IMemInputPin * iface, IMediaSample ** pSamples, LONG nSamples, LONG *nSamplesProcessed)
1173 {
1174 HRESULT hr = S_OK;
1175 BaseInputPin *This = impl_from_IMemInputPin(iface);
1176
1177 TRACE("(%p/%p)->(%p, %d, %p)\n", This, iface, pSamples, nSamples, nSamplesProcessed);
1178
1179 for (*nSamplesProcessed = 0; *nSamplesProcessed < nSamples; (*nSamplesProcessed)++)
1180 {
1181 hr = IMemInputPin_Receive(iface, pSamples[*nSamplesProcessed]);
1182 if (hr != S_OK)
1183 break;
1184 }
1185
1186 return hr;
1187 }
1188
1189 static HRESULT WINAPI MemInputPin_ReceiveCanBlock(IMemInputPin * iface)
1190 {
1191 BaseInputPin *This = impl_from_IMemInputPin(iface);
1192
1193 TRACE("(%p/%p)->()\n", This, iface);
1194
1195 return S_OK;
1196 }
1197
1198 static const IMemInputPinVtbl MemInputPin_Vtbl =
1199 {
1200 MemInputPin_QueryInterface,
1201 MemInputPin_AddRef,
1202 MemInputPin_Release,
1203 MemInputPin_GetAllocator,
1204 MemInputPin_NotifyAllocator,
1205 MemInputPin_GetAllocatorRequirements,
1206 MemInputPin_Receive,
1207 MemInputPin_ReceiveMultiple,
1208 MemInputPin_ReceiveCanBlock
1209 };
1210
1211 static HRESULT InputPin_Init(const IPinVtbl *InputPin_Vtbl, const PIN_INFO * pPinInfo,
1212 const BasePinFuncTable* pBaseFuncsTable, const BaseInputPinFuncTable* pBaseInputFuncsTable,
1213 LPCRITICAL_SECTION pCritSec, IMemAllocator *allocator, BaseInputPin * pPinImpl)
1214 {
1215 TRACE("\n");
1216
1217 /* Common attributes */
1218 pPinImpl->pin.refCount = 1;
1219 pPinImpl->pin.pConnectedTo = NULL;
1220 pPinImpl->pin.pCritSec = pCritSec;
1221 pPinImpl->pin.tStart = 0;
1222 pPinImpl->pin.tStop = 0;
1223 pPinImpl->pin.dRate = 1.0;
1224 Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
1225 ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE));
1226 pPinImpl->pin.pFuncsTable = pBaseFuncsTable;
1227
1228 /* Input pin attributes */
1229 pPinImpl->pFuncsTable = pBaseInputFuncsTable;
1230 pPinImpl->pAllocator = pPinImpl->preferred_allocator = allocator;
1231 if (pPinImpl->preferred_allocator)
1232 IMemAllocator_AddRef(pPinImpl->preferred_allocator);
1233 pPinImpl->pin.IPin_iface.lpVtbl = InputPin_Vtbl;
1234 pPinImpl->IMemInputPin_iface.lpVtbl = &MemInputPin_Vtbl;
1235 pPinImpl->flushing = pPinImpl->end_of_stream = 0;
1236
1237 return S_OK;
1238 }
1239
1240 HRESULT BaseInputPin_Construct(const IPinVtbl *InputPin_Vtbl, const PIN_INFO * pPinInfo,
1241 const BasePinFuncTable* pBaseFuncsTable, const BaseInputPinFuncTable* pBaseInputFuncsTable,
1242 LPCRITICAL_SECTION pCritSec, IMemAllocator *allocator, IPin ** ppPin)
1243 {
1244 BaseInputPin * pPinImpl;
1245
1246 *ppPin = NULL;
1247
1248 assert(pBaseFuncsTable->pfnCheckMediaType);
1249
1250 if (pPinInfo->dir != PINDIR_INPUT)
1251 {
1252 ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir);
1253 return E_INVALIDARG;
1254 }
1255
1256 pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl));
1257
1258 if (!pPinImpl)
1259 return E_OUTOFMEMORY;
1260
1261 if (SUCCEEDED(InputPin_Init(InputPin_Vtbl, pPinInfo, pBaseFuncsTable, pBaseInputFuncsTable, pCritSec, allocator, pPinImpl)))
1262 {
1263 *ppPin = (IPin *)pPinImpl;
1264 return S_OK;
1265 }
1266
1267 CoTaskMemFree(pPinImpl);
1268 return E_FAIL;
1269 }