2e24d520667dfa71e0d5e15530dd49f19ae12b2c
[reactos.git] / reactos / dll / directx / quartz / pin.c
1 /*
2 * Generic Implementation of IPin Interface
3 *
4 * Copyright 2003 Robert Shearman
5 *
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.
10 *
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.
15 *
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
19 */
20
21 #include "quartz_private.h"
22 #include "pin.h"
23
24 #include "wine/debug.h"
25 #include "wine/unicode.h"
26 #include "uuids.h"
27 #include "vfwmsgs.h"
28 #include <assert.h>
29
30 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
31
32 static const IPinVtbl InputPin_Vtbl;
33 static const IPinVtbl OutputPin_Vtbl;
34 static const IMemInputPinVtbl MemInputPin_Vtbl;
35 static const IPinVtbl PullPin_Vtbl;
36
37 #define ALIGNDOWN(value,boundary) ((value)/(boundary)*(boundary))
38 #define ALIGNUP(value,boundary) (ALIGNDOWN((value)+(boundary)-1, (boundary)))
39
40 typedef HRESULT (*SendPinFunc)( IPin *to, LPVOID arg );
41
42 /** Helper function, there are a lot of places where the error code is inherited
43 * The following rules apply:
44 *
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
47 */
48 HRESULT updatehres( HRESULT original, HRESULT new )
49 {
50 if (FAILED( original ) || new == E_NOTIMPL)
51 return original;
52
53 if (FAILED( new ) || original == S_OK)
54 return new;
55
56 return original;
57 }
58
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)
62 *
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
65 */
66 static HRESULT SendFurther( IPin *from, SendPinFunc fnMiddle, LPVOID arg, SendPinFunc fnEnd )
67 {
68 PIN_INFO pin_info;
69 ULONG amount = 0;
70 HRESULT hr = S_OK;
71 HRESULT hr_return = S_OK;
72 IEnumPins *enumpins = NULL;
73 BOOL foundend = TRUE;
74 PIN_DIRECTION from_dir;
75
76 IPin_QueryDirection( from, &from_dir );
77
78 hr = IPin_QueryInternalConnections( from, NULL, &amount );
79 if (hr != E_NOTIMPL && amount)
80 FIXME("Use QueryInternalConnections!\n");
81 hr = S_OK;
82
83 pin_info.pFilter = NULL;
84 hr = IPin_QueryPinInfo( from, &pin_info );
85 if (FAILED(hr))
86 goto out;
87
88 hr = IBaseFilter_EnumPins( pin_info.pFilter, &enumpins );
89 if (FAILED(hr))
90 goto out;
91
92 hr = IEnumPins_Reset( enumpins );
93 while (hr == S_OK) {
94 IPin *pin = NULL;
95 hr = IEnumPins_Next( enumpins, 1, &pin, NULL );
96 if (hr == VFW_E_ENUM_OUT_OF_SYNC)
97 {
98 hr = IEnumPins_Reset( enumpins );
99 continue;
100 }
101 if (pin)
102 {
103 PIN_DIRECTION dir;
104
105 IPin_QueryDirection( pin, &dir );
106 if (dir != from_dir)
107 {
108 IPin *connected = NULL;
109
110 foundend = FALSE;
111 IPin_ConnectedTo( pin, &connected );
112 if (connected)
113 {
114 HRESULT hr_local;
115
116 hr_local = fnMiddle( connected, arg );
117 hr_return = updatehres( hr_return, hr_local );
118 IPin_Release(connected);
119 }
120 }
121 IPin_Release( pin );
122 }
123 else
124 {
125 hr = S_OK;
126 break;
127 }
128 }
129
130 if (!foundend)
131 hr = hr_return;
132 else if (fnEnd) {
133 HRESULT hr_local;
134
135 hr_local = fnEnd( from, arg );
136 hr_return = updatehres( hr_return, hr_local );
137 }
138
139 out:
140 if (pin_info.pFilter)
141 IBaseFilter_Release( pin_info.pFilter );
142 return hr;
143 }
144
145
146 static void Copy_PinInfo(PIN_INFO * pDest, const PIN_INFO * pSrc)
147 {
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;
155 }
156
157 /*** Common pin functions ***/
158
159 ULONG WINAPI IPinImpl_AddRef(IPin * iface)
160 {
161 IPinImpl *This = (IPinImpl *)iface;
162 ULONG refCount = InterlockedIncrement(&This->refCount);
163
164 TRACE("(%p)->() AddRef from %d\n", iface, refCount - 1);
165
166 return refCount;
167 }
168
169 HRESULT WINAPI IPinImpl_Disconnect(IPin * iface)
170 {
171 HRESULT hr;
172 IPinImpl *This = (IPinImpl *)iface;
173
174 TRACE("()\n");
175
176 EnterCriticalSection(This->pCritSec);
177 {
178 if (This->pConnectedTo)
179 {
180 IPin_Release(This->pConnectedTo);
181 This->pConnectedTo = NULL;
182 FreeMediaType(&This->mtCurrent);
183 ZeroMemory(&This->mtCurrent, sizeof(This->mtCurrent));
184 hr = S_OK;
185 }
186 else
187 hr = S_FALSE;
188 }
189 LeaveCriticalSection(This->pCritSec);
190
191 return hr;
192 }
193
194 HRESULT WINAPI IPinImpl_ConnectedTo(IPin * iface, IPin ** ppPin)
195 {
196 HRESULT hr;
197 IPinImpl *This = (IPinImpl *)iface;
198
199 TRACE("(%p)\n", ppPin);
200
201 EnterCriticalSection(This->pCritSec);
202 {
203 if (This->pConnectedTo)
204 {
205 *ppPin = This->pConnectedTo;
206 IPin_AddRef(*ppPin);
207 hr = S_OK;
208 }
209 else
210 {
211 hr = VFW_E_NOT_CONNECTED;
212 *ppPin = NULL;
213 }
214 }
215 LeaveCriticalSection(This->pCritSec);
216
217 return hr;
218 }
219
220 HRESULT WINAPI IPinImpl_ConnectionMediaType(IPin * iface, AM_MEDIA_TYPE * pmt)
221 {
222 HRESULT hr;
223 IPinImpl *This = (IPinImpl *)iface;
224
225 TRACE("(%p/%p)->(%p)\n", This, iface, pmt);
226
227 EnterCriticalSection(This->pCritSec);
228 {
229 if (This->pConnectedTo)
230 {
231 CopyMediaType(pmt, &This->mtCurrent);
232 hr = S_OK;
233 }
234 else
235 {
236 ZeroMemory(pmt, sizeof(*pmt));
237 hr = VFW_E_NOT_CONNECTED;
238 }
239 }
240 LeaveCriticalSection(This->pCritSec);
241
242 return hr;
243 }
244
245 HRESULT WINAPI IPinImpl_QueryPinInfo(IPin * iface, PIN_INFO * pInfo)
246 {
247 IPinImpl *This = (IPinImpl *)iface;
248
249 TRACE("(%p/%p)->(%p)\n", This, iface, pInfo);
250
251 Copy_PinInfo(pInfo, &This->pinInfo);
252 IBaseFilter_AddRef(pInfo->pFilter);
253
254 return S_OK;
255 }
256
257 HRESULT WINAPI IPinImpl_QueryDirection(IPin * iface, PIN_DIRECTION * pPinDir)
258 {
259 IPinImpl *This = (IPinImpl *)iface;
260
261 TRACE("(%p/%p)->(%p)\n", This, iface, pPinDir);
262
263 *pPinDir = This->pinInfo.dir;
264
265 return S_OK;
266 }
267
268 HRESULT WINAPI IPinImpl_QueryId(IPin * iface, LPWSTR * Id)
269 {
270 IPinImpl *This = (IPinImpl *)iface;
271
272 TRACE("(%p/%p)->(%p)\n", This, iface, Id);
273
274 *Id = CoTaskMemAlloc((strlenW(This->pinInfo.achName) + 1) * sizeof(WCHAR));
275 if (!*Id)
276 return E_OUTOFMEMORY;
277
278 strcpyW(*Id, This->pinInfo.achName);
279
280 return S_OK;
281 }
282
283 HRESULT WINAPI IPinImpl_QueryAccept(IPin * iface, const AM_MEDIA_TYPE * pmt)
284 {
285 IPinImpl *This = (IPinImpl *)iface;
286
287 TRACE("(%p/%p)->(%p)\n", This, iface, pmt);
288
289 return (This->fnQueryAccept(This->pUserData, pmt) == S_OK ? S_OK : S_FALSE);
290 }
291
292 HRESULT WINAPI IPinImpl_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum)
293 {
294 IPinImpl *This = (IPinImpl *)iface;
295 ENUMMEDIADETAILS emd;
296
297 TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
298
299 /* override this method to allow enumeration of your types */
300 emd.cMediaTypes = 0;
301 emd.pMediaTypes = NULL;
302
303 return IEnumMediaTypesImpl_Construct(&emd, ppEnum);
304 }
305
306 HRESULT WINAPI IPinImpl_QueryInternalConnections(IPin * iface, IPin ** apPin, ULONG * cPin)
307 {
308 IPinImpl *This = (IPinImpl *)iface;
309
310 TRACE("(%p/%p)->(%p, %p)\n", This, iface, apPin, cPin);
311
312 return E_NOTIMPL; /* to tell caller that all input pins connected to all output pins */
313 }
314
315 /*** IPin implementation for an input pin ***/
316
317 HRESULT WINAPI InputPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
318 {
319 InputPin *This = (InputPin *)iface;
320
321 TRACE("(%p)->(%s, %p)\n", iface, qzdebugstr_guid(riid), ppv);
322
323 *ppv = NULL;
324
325 if (IsEqualIID(riid, &IID_IUnknown))
326 *ppv = iface;
327 else if (IsEqualIID(riid, &IID_IPin))
328 *ppv = iface;
329 else if (IsEqualIID(riid, &IID_IMemInputPin))
330 *ppv = &This->lpVtblMemInput;
331 else if (IsEqualIID(riid, &IID_IMediaSeeking))
332 {
333 return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv);
334 }
335
336 if (*ppv)
337 {
338 IUnknown_AddRef((IUnknown *)(*ppv));
339 return S_OK;
340 }
341
342 FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
343
344 return E_NOINTERFACE;
345 }
346
347 ULONG WINAPI InputPin_Release(IPin * iface)
348 {
349 InputPin *This = (InputPin *)iface;
350 ULONG refCount = InterlockedDecrement(&This->pin.refCount);
351
352 TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
353
354 if (!refCount)
355 {
356 FreeMediaType(&This->pin.mtCurrent);
357 if (This->pAllocator)
358 IMemAllocator_Release(This->pAllocator);
359 This->pAllocator = NULL;
360 This->pin.lpVtbl = NULL;
361 CoTaskMemFree(This);
362 return 0;
363 }
364 else
365 return refCount;
366 }
367
368 HRESULT WINAPI InputPin_Connect(IPin * iface, IPin * pConnector, const AM_MEDIA_TYPE * pmt)
369 {
370 ERR("Outgoing connection on an input pin! (%p, %p)\n", pConnector, pmt);
371
372 return E_UNEXPECTED;
373 }
374
375
376 HRESULT WINAPI InputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
377 {
378 InputPin *This = (InputPin *)iface;
379 PIN_DIRECTION pindirReceive;
380 HRESULT hr = S_OK;
381
382 TRACE("(%p, %p)\n", pReceivePin, pmt);
383 dump_AM_MEDIA_TYPE(pmt);
384
385 EnterCriticalSection(This->pin.pCritSec);
386 {
387 if (This->pin.pConnectedTo)
388 hr = VFW_E_ALREADY_CONNECTED;
389
390 if (SUCCEEDED(hr) && This->pin.fnQueryAccept(This->pin.pUserData, pmt) != S_OK)
391 hr = VFW_E_TYPE_NOT_ACCEPTED; /* FIXME: shouldn't we just map common errors onto
392 * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */
393
394 if (SUCCEEDED(hr))
395 {
396 IPin_QueryDirection(pReceivePin, &pindirReceive);
397
398 if (pindirReceive != PINDIR_OUTPUT)
399 {
400 ERR("Can't connect from non-output pin\n");
401 hr = VFW_E_INVALID_DIRECTION;
402 }
403 }
404
405 if (SUCCEEDED(hr))
406 {
407 CopyMediaType(&This->pin.mtCurrent, pmt);
408 This->pin.pConnectedTo = pReceivePin;
409 IPin_AddRef(pReceivePin);
410 }
411 }
412 LeaveCriticalSection(This->pin.pCritSec);
413
414 return hr;
415 }
416
417 static HRESULT deliver_endofstream(IPin* pin, LPVOID unused)
418 {
419 return IPin_EndOfStream( pin );
420 }
421
422 HRESULT WINAPI InputPin_EndOfStream(IPin * iface)
423 {
424 HRESULT hr = S_OK;
425 InputPin *This = (InputPin *)iface;
426
427 TRACE("(%p)\n", This);
428
429 EnterCriticalSection(This->pin.pCritSec);
430 if (This->flushing)
431 hr = S_FALSE;
432 else
433 This->end_of_stream = 1;
434 LeaveCriticalSection(This->pin.pCritSec);
435
436 if (hr == S_OK)
437 hr = SendFurther( iface, deliver_endofstream, NULL, NULL );
438 return hr;
439 }
440
441 static HRESULT deliver_beginflush(IPin* pin, LPVOID unused)
442 {
443 return IPin_BeginFlush( pin );
444 }
445
446 HRESULT WINAPI InputPin_BeginFlush(IPin * iface)
447 {
448 InputPin *This = (InputPin *)iface;
449 HRESULT hr;
450 TRACE("() semi-stub\n");
451
452 EnterCriticalSection(This->pin.pCritSec);
453 This->flushing = 1;
454
455 if (This->fnCleanProc)
456 This->fnCleanProc(This->pin.pUserData);
457
458 hr = SendFurther( iface, deliver_beginflush, NULL, NULL );
459 LeaveCriticalSection(This->pin.pCritSec);
460
461 return hr;
462 }
463
464 static HRESULT deliver_endflush(IPin* pin, LPVOID unused)
465 {
466 return IPin_EndFlush( pin );
467 }
468
469 HRESULT WINAPI InputPin_EndFlush(IPin * iface)
470 {
471 InputPin *This = (InputPin *)iface;
472 HRESULT hr;
473 TRACE("(%p)\n", This);
474
475 EnterCriticalSection(This->pin.pCritSec);
476 This->flushing = This->end_of_stream = 0;
477
478 hr = SendFurther( iface, deliver_endflush, NULL, NULL );
479 LeaveCriticalSection(This->pin.pCritSec);
480
481 return hr;
482 }
483
484 typedef struct newsegmentargs
485 {
486 REFERENCE_TIME tStart, tStop;
487 double rate;
488 } newsegmentargs;
489
490 static HRESULT deliver_newsegment(IPin *pin, LPVOID data)
491 {
492 newsegmentargs *args = data;
493 return IPin_NewSegment(pin, args->tStart, args->tStop, args->rate);
494 }
495
496 HRESULT WINAPI InputPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
497 {
498 InputPin *This = (InputPin *)iface;
499 newsegmentargs args;
500
501 TRACE("(%x%08x, %x%08x, %e)\n", (ULONG)(tStart >> 32), (ULONG)tStart, (ULONG)(tStop >> 32), (ULONG)tStop, dRate);
502
503 args.tStart = This->tStart = tStart;
504 args.tStop = This->tStop = tStop;
505 args.rate = This->dRate = dRate;
506
507 return SendFurther( iface, deliver_newsegment, &args, NULL );
508 }
509
510 static const IPinVtbl InputPin_Vtbl =
511 {
512 InputPin_QueryInterface,
513 IPinImpl_AddRef,
514 InputPin_Release,
515 InputPin_Connect,
516 InputPin_ReceiveConnection,
517 IPinImpl_Disconnect,
518 IPinImpl_ConnectedTo,
519 IPinImpl_ConnectionMediaType,
520 IPinImpl_QueryPinInfo,
521 IPinImpl_QueryDirection,
522 IPinImpl_QueryId,
523 IPinImpl_QueryAccept,
524 IPinImpl_EnumMediaTypes,
525 IPinImpl_QueryInternalConnections,
526 InputPin_EndOfStream,
527 InputPin_BeginFlush,
528 InputPin_EndFlush,
529 InputPin_NewSegment
530 };
531
532 /*** IMemInputPin implementation ***/
533
534 static inline InputPin *impl_from_IMemInputPin( IMemInputPin *iface )
535 {
536 return (InputPin *)((char*)iface - FIELD_OFFSET(InputPin, lpVtblMemInput));
537 }
538
539 static HRESULT WINAPI MemInputPin_QueryInterface(IMemInputPin * iface, REFIID riid, LPVOID * ppv)
540 {
541 InputPin *This = impl_from_IMemInputPin(iface);
542
543 return IPin_QueryInterface((IPin *)&This->pin, riid, ppv);
544 }
545
546 static ULONG WINAPI MemInputPin_AddRef(IMemInputPin * iface)
547 {
548 InputPin *This = impl_from_IMemInputPin(iface);
549
550 return IPin_AddRef((IPin *)&This->pin);
551 }
552
553 static ULONG WINAPI MemInputPin_Release(IMemInputPin * iface)
554 {
555 InputPin *This = impl_from_IMemInputPin(iface);
556
557 return IPin_Release((IPin *)&This->pin);
558 }
559
560 static HRESULT WINAPI MemInputPin_GetAllocator(IMemInputPin * iface, IMemAllocator ** ppAllocator)
561 {
562 InputPin *This = impl_from_IMemInputPin(iface);
563
564 TRACE("(%p/%p)->(%p)\n", This, iface, ppAllocator);
565
566 *ppAllocator = This->pAllocator;
567 if (*ppAllocator)
568 IMemAllocator_AddRef(*ppAllocator);
569
570 return *ppAllocator ? S_OK : VFW_E_NO_ALLOCATOR;
571 }
572
573 static HRESULT WINAPI MemInputPin_NotifyAllocator(IMemInputPin * iface, IMemAllocator * pAllocator, BOOL bReadOnly)
574 {
575 InputPin *This = impl_from_IMemInputPin(iface);
576
577 TRACE("(%p/%p)->(%p, %d)\n", This, iface, pAllocator, bReadOnly);
578
579 if (bReadOnly)
580 FIXME("Read only flag not handled yet!\n");
581
582 /* FIXME: Should we release the allocator on disconnection? */
583 if (!pAllocator)
584 {
585 WARN("Null allocator\n");
586 return E_POINTER;
587 }
588
589 if (This->preferred_allocator && pAllocator != This->preferred_allocator)
590 return E_FAIL;
591
592 if (This->pAllocator)
593 IMemAllocator_Release(This->pAllocator);
594 This->pAllocator = pAllocator;
595 if (This->pAllocator)
596 IMemAllocator_AddRef(This->pAllocator);
597
598 return S_OK;
599 }
600
601 static HRESULT WINAPI MemInputPin_GetAllocatorRequirements(IMemInputPin * iface, ALLOCATOR_PROPERTIES * pProps)
602 {
603 InputPin *This = impl_from_IMemInputPin(iface);
604
605 TRACE("(%p/%p)->(%p)\n", This, iface, pProps);
606
607 /* override this method if you have any specific requirements */
608
609 return E_NOTIMPL;
610 }
611
612 static HRESULT WINAPI MemInputPin_Receive(IMemInputPin * iface, IMediaSample * pSample)
613 {
614 InputPin *This = impl_from_IMemInputPin(iface);
615 HRESULT hr;
616
617 /* this trace commented out for performance reasons */
618 /*TRACE("(%p/%p)->(%p)\n", This, iface, pSample);*/
619 hr = This->fnSampleProc(This->pin.pUserData, pSample);
620 return hr;
621 }
622
623 static HRESULT WINAPI MemInputPin_ReceiveMultiple(IMemInputPin * iface, IMediaSample ** pSamples, LONG nSamples, LONG *nSamplesProcessed)
624 {
625 HRESULT hr = S_OK;
626 InputPin *This = impl_from_IMemInputPin(iface);
627
628 TRACE("(%p/%p)->(%p, %d, %p)\n", This, iface, pSamples, nSamples, nSamplesProcessed);
629
630 for (*nSamplesProcessed = 0; *nSamplesProcessed < nSamples; (*nSamplesProcessed)++)
631 {
632 hr = IMemInputPin_Receive(iface, pSamples[*nSamplesProcessed]);
633 if (hr != S_OK)
634 break;
635 }
636
637 return hr;
638 }
639
640 static HRESULT WINAPI MemInputPin_ReceiveCanBlock(IMemInputPin * iface)
641 {
642 InputPin *This = impl_from_IMemInputPin(iface);
643
644 TRACE("(%p/%p)->()\n", This, iface);
645
646 return S_OK;
647 }
648
649 static const IMemInputPinVtbl MemInputPin_Vtbl =
650 {
651 MemInputPin_QueryInterface,
652 MemInputPin_AddRef,
653 MemInputPin_Release,
654 MemInputPin_GetAllocator,
655 MemInputPin_NotifyAllocator,
656 MemInputPin_GetAllocatorRequirements,
657 MemInputPin_Receive,
658 MemInputPin_ReceiveMultiple,
659 MemInputPin_ReceiveCanBlock
660 };
661
662 /*** OutputPin implementation ***/
663
664 HRESULT WINAPI OutputPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
665 {
666 OutputPin *This = (OutputPin *)iface;
667
668 TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
669
670 *ppv = NULL;
671
672 if (IsEqualIID(riid, &IID_IUnknown))
673 *ppv = iface;
674 else if (IsEqualIID(riid, &IID_IPin))
675 *ppv = iface;
676 else if (IsEqualIID(riid, &IID_IMediaSeeking))
677 {
678 return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv);
679 }
680
681 if (*ppv)
682 {
683 IUnknown_AddRef((IUnknown *)(*ppv));
684 return S_OK;
685 }
686
687 FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
688
689 return E_NOINTERFACE;
690 }
691
692 ULONG WINAPI OutputPin_Release(IPin * iface)
693 {
694 OutputPin *This = (OutputPin *)iface;
695 ULONG refCount = InterlockedDecrement(&This->pin.refCount);
696
697 TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
698
699 if (!refCount)
700 {
701 FreeMediaType(&This->pin.mtCurrent);
702 CoTaskMemFree(This);
703 return 0;
704 }
705 return refCount;
706 }
707
708 HRESULT WINAPI OutputPin_Connect(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
709 {
710 HRESULT hr;
711 OutputPin *This = (OutputPin *)iface;
712
713 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt);
714 dump_AM_MEDIA_TYPE(pmt);
715
716 /* If we try to connect to ourself, we will definitely deadlock.
717 * There are other cases where we could deadlock too, but this
718 * catches the obvious case */
719 assert(pReceivePin != iface);
720
721 EnterCriticalSection(This->pin.pCritSec);
722 {
723 /* if we have been a specific type to connect with, then we can either connect
724 * with that or fail. We cannot choose different AM_MEDIA_TYPE */
725 if (pmt && !IsEqualGUID(&pmt->majortype, &GUID_NULL) && !IsEqualGUID(&pmt->subtype, &GUID_NULL))
726 hr = This->pConnectSpecific(iface, pReceivePin, pmt);
727 else
728 {
729 /* negotiate media type */
730
731 IEnumMediaTypes * pEnumCandidates;
732 AM_MEDIA_TYPE * pmtCandidate = NULL; /* Candidate media type */
733
734 if (SUCCEEDED(hr = IPin_EnumMediaTypes(iface, &pEnumCandidates)))
735 {
736 hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */
737
738 /* try this filter's media types first */
739 while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL))
740 {
741 assert(pmtCandidate);
742 dump_AM_MEDIA_TYPE(pmtCandidate);
743 if (!IsEqualGUID(&FORMAT_None, &pmtCandidate->formattype)
744 && !IsEqualGUID(&GUID_NULL, &pmtCandidate->formattype))
745 assert(pmtCandidate->pbFormat);
746 if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) &&
747 (This->pConnectSpecific(iface, pReceivePin, pmtCandidate) == S_OK))
748 {
749 hr = S_OK;
750 DeleteMediaType(pmtCandidate);
751 break;
752 }
753 DeleteMediaType(pmtCandidate);
754 pmtCandidate = NULL;
755 }
756 IEnumMediaTypes_Release(pEnumCandidates);
757 }
758
759 /* then try receiver filter's media types */
760 if (hr != S_OK && SUCCEEDED(hr = IPin_EnumMediaTypes(pReceivePin, &pEnumCandidates))) /* if we haven't already connected successfully */
761 {
762 hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */
763
764 while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL))
765 {
766 assert(pmtCandidate);
767 dump_AM_MEDIA_TYPE(pmtCandidate);
768 if (!IsEqualGUID(&FORMAT_None, &pmtCandidate->formattype)
769 && !IsEqualGUID(&GUID_NULL, &pmtCandidate->formattype))
770 assert(pmtCandidate->pbFormat);
771 if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) &&
772 (This->pConnectSpecific(iface, pReceivePin, pmtCandidate) == S_OK))
773 {
774 hr = S_OK;
775 DeleteMediaType(pmtCandidate);
776 break;
777 }
778 DeleteMediaType(pmtCandidate);
779 pmtCandidate = NULL;
780 } /* while */
781 IEnumMediaTypes_Release(pEnumCandidates);
782 } /* if not found */
783 } /* if negotiate media type */
784 } /* if succeeded */
785 LeaveCriticalSection(This->pin.pCritSec);
786
787 TRACE(" -- %x\n", hr);
788 return hr;
789 }
790
791 HRESULT WINAPI OutputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
792 {
793 ERR("Incoming connection on an output pin! (%p, %p)\n", pReceivePin, pmt);
794
795 return E_UNEXPECTED;
796 }
797
798 HRESULT WINAPI OutputPin_Disconnect(IPin * iface)
799 {
800 HRESULT hr;
801 OutputPin *This = (OutputPin *)iface;
802
803 TRACE("()\n");
804
805 EnterCriticalSection(This->pin.pCritSec);
806 {
807 if (This->pMemInputPin)
808 {
809 IMemInputPin_Release(This->pMemInputPin);
810 This->pMemInputPin = NULL;
811 }
812 if (This->pin.pConnectedTo)
813 {
814 IPin_Release(This->pin.pConnectedTo);
815 This->pin.pConnectedTo = NULL;
816 FreeMediaType(&This->pin.mtCurrent);
817 ZeroMemory(&This->pin.mtCurrent, sizeof(This->pin.mtCurrent));
818 hr = S_OK;
819 }
820 else
821 hr = S_FALSE;
822 }
823 LeaveCriticalSection(This->pin.pCritSec);
824
825 return hr;
826 }
827
828 HRESULT WINAPI OutputPin_EndOfStream(IPin * iface)
829 {
830 TRACE("()\n");
831
832 /* not supposed to do anything in an output pin */
833
834 return E_UNEXPECTED;
835 }
836
837 HRESULT WINAPI OutputPin_BeginFlush(IPin * iface)
838 {
839 TRACE("(%p)->()\n", iface);
840
841 /* not supposed to do anything in an output pin */
842
843 return E_UNEXPECTED;
844 }
845
846 HRESULT WINAPI OutputPin_EndFlush(IPin * iface)
847 {
848 TRACE("(%p)->()\n", iface);
849
850 /* not supposed to do anything in an output pin */
851
852 return E_UNEXPECTED;
853 }
854
855 HRESULT WINAPI OutputPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
856 {
857 TRACE("(%p)->(%x%08x, %x%08x, %e)\n", iface, (ULONG)(tStart >> 32), (ULONG)tStart, (ULONG)(tStop >> 32), (ULONG)tStop, dRate);
858
859 /* not supposed to do anything in an output pin */
860
861 return E_UNEXPECTED;
862 }
863
864 static const IPinVtbl OutputPin_Vtbl =
865 {
866 OutputPin_QueryInterface,
867 IPinImpl_AddRef,
868 OutputPin_Release,
869 OutputPin_Connect,
870 OutputPin_ReceiveConnection,
871 OutputPin_Disconnect,
872 IPinImpl_ConnectedTo,
873 IPinImpl_ConnectionMediaType,
874 IPinImpl_QueryPinInfo,
875 IPinImpl_QueryDirection,
876 IPinImpl_QueryId,
877 IPinImpl_QueryAccept,
878 IPinImpl_EnumMediaTypes,
879 IPinImpl_QueryInternalConnections,
880 OutputPin_EndOfStream,
881 OutputPin_BeginFlush,
882 OutputPin_EndFlush,
883 OutputPin_NewSegment
884 };
885
886 HRESULT OutputPin_GetDeliveryBuffer(OutputPin * This, IMediaSample ** ppSample, REFERENCE_TIME * tStart, REFERENCE_TIME * tStop, DWORD dwFlags)
887 {
888 HRESULT hr;
889
890 TRACE("(%p, %p, %p, %x)\n", ppSample, tStart, tStop, dwFlags);
891
892 EnterCriticalSection(This->pin.pCritSec);
893 {
894 if (!This->pin.pConnectedTo)
895 hr = VFW_E_NOT_CONNECTED;
896 else
897 {
898 IMemAllocator * pAlloc = NULL;
899
900 hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc);
901
902 if (SUCCEEDED(hr))
903 hr = IMemAllocator_GetBuffer(pAlloc, ppSample, tStart, tStop, dwFlags);
904
905 if (SUCCEEDED(hr))
906 hr = IMediaSample_SetTime(*ppSample, tStart, tStop);
907
908 if (pAlloc)
909 IMemAllocator_Release(pAlloc);
910 }
911 }
912 LeaveCriticalSection(This->pin.pCritSec);
913
914 return hr;
915 }
916
917 HRESULT OutputPin_SendSample(OutputPin * This, IMediaSample * pSample)
918 {
919 HRESULT hr = S_OK;
920 IMemInputPin * pMemConnected = NULL;
921 PIN_INFO pinInfo;
922
923 EnterCriticalSection(This->pin.pCritSec);
924 {
925 if (!This->pin.pConnectedTo || !This->pMemInputPin)
926 hr = VFW_E_NOT_CONNECTED;
927 else
928 {
929 /* we don't have the lock held when using This->pMemInputPin,
930 * so we need to AddRef it to stop it being deleted while we are
931 * using it. Same with its filter. */
932 pMemConnected = This->pMemInputPin;
933 IMemInputPin_AddRef(pMemConnected);
934 hr = IPin_QueryPinInfo(This->pin.pConnectedTo, &pinInfo);
935 }
936 }
937 LeaveCriticalSection(This->pin.pCritSec);
938
939 if (SUCCEEDED(hr))
940 {
941 /* NOTE: if we are in a critical section when Receive is called
942 * then it causes some problems (most notably with the native Video
943 * Renderer) if we are re-entered for whatever reason */
944 hr = IMemInputPin_Receive(pMemConnected, pSample);
945
946 /* If the filter's destroyed, tell upstream to stop sending data */
947 if(IBaseFilter_Release(pinInfo.pFilter) == 0 && SUCCEEDED(hr))
948 hr = S_FALSE;
949 }
950 if (pMemConnected)
951 IMemInputPin_Release(pMemConnected);
952
953 return hr;
954 }
955
956 HRESULT OutputPin_CommitAllocator(OutputPin * This)
957 {
958 HRESULT hr = S_OK;
959
960 TRACE("(%p)->()\n", This);
961
962 EnterCriticalSection(This->pin.pCritSec);
963 {
964 if (!This->pin.pConnectedTo || !This->pMemInputPin)
965 hr = VFW_E_NOT_CONNECTED;
966 else
967 {
968 IMemAllocator * pAlloc = NULL;
969
970 hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc);
971
972 if (SUCCEEDED(hr))
973 hr = IMemAllocator_Commit(pAlloc);
974
975 if (pAlloc)
976 IMemAllocator_Release(pAlloc);
977 }
978 }
979 LeaveCriticalSection(This->pin.pCritSec);
980
981 TRACE("--> %08x\n", hr);
982 return hr;
983 }
984
985 HRESULT OutputPin_DecommitAllocator(OutputPin * This)
986 {
987 HRESULT hr = S_OK;
988
989 TRACE("(%p)->()\n", This);
990
991 EnterCriticalSection(This->pin.pCritSec);
992 {
993 if (!This->pin.pConnectedTo || !This->pMemInputPin)
994 hr = VFW_E_NOT_CONNECTED;
995 else
996 {
997 IMemAllocator * pAlloc = NULL;
998
999 hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc);
1000
1001 if (SUCCEEDED(hr))
1002 hr = IMemAllocator_Decommit(pAlloc);
1003
1004 if (pAlloc)
1005 IMemAllocator_Release(pAlloc);
1006 }
1007 }
1008 LeaveCriticalSection(This->pin.pCritSec);
1009
1010 TRACE("--> %08x\n", hr);
1011 return hr;
1012 }
1013
1014 HRESULT OutputPin_DeliverDisconnect(OutputPin * This)
1015 {
1016 HRESULT hr;
1017
1018 TRACE("(%p)->()\n", This);
1019
1020 EnterCriticalSection(This->pin.pCritSec);
1021 {
1022 if (!This->pin.pConnectedTo || !This->pMemInputPin)
1023 hr = VFW_E_NOT_CONNECTED;
1024 else if (!This->custom_allocator)
1025 {
1026 IMemAllocator * pAlloc = NULL;
1027
1028 hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc);
1029
1030 if (SUCCEEDED(hr))
1031 hr = IMemAllocator_Decommit(pAlloc);
1032
1033 if (pAlloc)
1034 IMemAllocator_Release(pAlloc);
1035
1036 if (SUCCEEDED(hr))
1037 hr = IPin_Disconnect(This->pin.pConnectedTo);
1038 }
1039 else /* Kill the allocator! */
1040 {
1041 hr = IPin_Disconnect(This->pin.pConnectedTo);
1042 }
1043 IPin_Disconnect((IPin *)This);
1044 }
1045 LeaveCriticalSection(This->pin.pCritSec);
1046
1047 return hr;
1048 }
1049
1050 /*** PullPin implementation ***/
1051
1052 static HRESULT PullPin_Init(const IPinVtbl *PullPin_Vtbl, const PIN_INFO * pPinInfo, SAMPLEPROC_PULL pSampleProc, LPVOID pUserData,
1053 QUERYACCEPTPROC pQueryAccept, CLEANUPPROC pCleanUp, REQUESTPROC pCustomRequest, STOPPROCESSPROC pDone, LPCRITICAL_SECTION pCritSec, PullPin * pPinImpl)
1054 {
1055 /* Common attributes */
1056 pPinImpl->pin.lpVtbl = PullPin_Vtbl;
1057 pPinImpl->pin.refCount = 1;
1058 pPinImpl->pin.pConnectedTo = NULL;
1059 pPinImpl->pin.fnQueryAccept = pQueryAccept;
1060 pPinImpl->pin.pUserData = pUserData;
1061 pPinImpl->pin.pCritSec = pCritSec;
1062 Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
1063 ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE));
1064
1065 /* Input pin attributes */
1066 pPinImpl->fnSampleProc = pSampleProc;
1067 pPinImpl->fnCleanProc = pCleanUp;
1068 pPinImpl->fnDone = pDone;
1069 pPinImpl->fnPreConnect = NULL;
1070 pPinImpl->pAlloc = NULL;
1071 pPinImpl->pReader = NULL;
1072 pPinImpl->hThread = NULL;
1073 pPinImpl->hEventStateChanged = CreateEventW(NULL, TRUE, TRUE, NULL);
1074 pPinImpl->thread_sleepy = CreateEventW(NULL, FALSE, FALSE, NULL);
1075
1076 pPinImpl->rtStart = 0;
1077 pPinImpl->rtCurrent = 0;
1078 pPinImpl->rtStop = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
1079 pPinImpl->dRate = 1.0;
1080 pPinImpl->state = Req_Die;
1081 pPinImpl->fnCustomRequest = pCustomRequest;
1082 pPinImpl->stop_playback = 1;
1083
1084 InitializeCriticalSection(&pPinImpl->thread_lock);
1085 pPinImpl->thread_lock.DebugInfo->Spare[0] = (DWORD_PTR)( __FILE__ ": PullPin.thread_lock");
1086
1087 return S_OK;
1088 }
1089
1090 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)
1091 {
1092 PullPin * pPinImpl;
1093
1094 *ppPin = NULL;
1095
1096 if (pPinInfo->dir != PINDIR_INPUT)
1097 {
1098 ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir);
1099 return E_INVALIDARG;
1100 }
1101
1102 pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl));
1103
1104 if (!pPinImpl)
1105 return E_OUTOFMEMORY;
1106
1107 if (SUCCEEDED(PullPin_Init(PullPin_Vtbl, pPinInfo, pSampleProc, pUserData, pQueryAccept, pCleanUp, pCustomRequest, pDone, pCritSec, pPinImpl)))
1108 {
1109 *ppPin = (IPin *)(&pPinImpl->pin.lpVtbl);
1110 return S_OK;
1111 }
1112
1113 CoTaskMemFree(pPinImpl);
1114 return E_FAIL;
1115 }
1116
1117 static HRESULT PullPin_InitProcessing(PullPin * This);
1118
1119 HRESULT WINAPI PullPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
1120 {
1121 PIN_DIRECTION pindirReceive;
1122 HRESULT hr = S_OK;
1123 PullPin *This = (PullPin *)iface;
1124
1125 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt);
1126 dump_AM_MEDIA_TYPE(pmt);
1127
1128 EnterCriticalSection(This->pin.pCritSec);
1129 if (!This->pin.pConnectedTo)
1130 {
1131 ALLOCATOR_PROPERTIES props;
1132
1133 props.cBuffers = 3;
1134 props.cbBuffer = 64 * 1024; /* 64k bytes */
1135 props.cbAlign = 1;
1136 props.cbPrefix = 0;
1137
1138 if (SUCCEEDED(hr) && (This->pin.fnQueryAccept(This->pin.pUserData, pmt) != S_OK))
1139 hr = VFW_E_TYPE_NOT_ACCEPTED; /* FIXME: shouldn't we just map common errors onto
1140 * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */
1141
1142 if (SUCCEEDED(hr))
1143 {
1144 IPin_QueryDirection(pReceivePin, &pindirReceive);
1145
1146 if (pindirReceive != PINDIR_OUTPUT)
1147 {
1148 ERR("Can't connect from non-output pin\n");
1149 hr = VFW_E_INVALID_DIRECTION;
1150 }
1151 }
1152
1153 This->pReader = NULL;
1154 This->pAlloc = NULL;
1155 if (SUCCEEDED(hr))
1156 {
1157 hr = IPin_QueryInterface(pReceivePin, &IID_IAsyncReader, (LPVOID *)&This->pReader);
1158 }
1159
1160 if (SUCCEEDED(hr) && This->fnPreConnect)
1161 {
1162 hr = This->fnPreConnect(iface, pReceivePin, &props);
1163 }
1164
1165 if (SUCCEEDED(hr))
1166 {
1167 hr = IAsyncReader_RequestAllocator(This->pReader, NULL, &props, &This->pAlloc);
1168 }
1169
1170 if (SUCCEEDED(hr))
1171 {
1172 CopyMediaType(&This->pin.mtCurrent, pmt);
1173 This->pin.pConnectedTo = pReceivePin;
1174 IPin_AddRef(pReceivePin);
1175 hr = IMemAllocator_Commit(This->pAlloc);
1176 }
1177
1178 if (SUCCEEDED(hr))
1179 hr = PullPin_InitProcessing(This);
1180
1181 if (FAILED(hr))
1182 {
1183 if (This->pReader)
1184 IAsyncReader_Release(This->pReader);
1185 This->pReader = NULL;
1186 if (This->pAlloc)
1187 IMemAllocator_Release(This->pAlloc);
1188 This->pAlloc = NULL;
1189 }
1190 }
1191 else
1192 hr = VFW_E_ALREADY_CONNECTED;
1193 LeaveCriticalSection(This->pin.pCritSec);
1194 return hr;
1195 }
1196
1197 HRESULT WINAPI PullPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
1198 {
1199 PullPin *This = (PullPin *)iface;
1200
1201 TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
1202
1203 *ppv = NULL;
1204
1205 if (IsEqualIID(riid, &IID_IUnknown))
1206 *ppv = iface;
1207 else if (IsEqualIID(riid, &IID_IPin))
1208 *ppv = iface;
1209 else if (IsEqualIID(riid, &IID_IMediaSeeking))
1210 {
1211 return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv);
1212 }
1213
1214 if (*ppv)
1215 {
1216 IUnknown_AddRef((IUnknown *)(*ppv));
1217 return S_OK;
1218 }
1219
1220 FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
1221
1222 return E_NOINTERFACE;
1223 }
1224
1225 ULONG WINAPI PullPin_Release(IPin *iface)
1226 {
1227 PullPin *This = (PullPin *)iface;
1228 ULONG refCount = InterlockedDecrement(&This->pin.refCount);
1229
1230 TRACE("(%p)->() Release from %d\n", This, refCount + 1);
1231
1232 if (!refCount)
1233 {
1234 WaitForSingleObject(This->hEventStateChanged, INFINITE);
1235 assert(!This->hThread);
1236
1237 if(This->pAlloc)
1238 IMemAllocator_Release(This->pAlloc);
1239 if(This->pReader)
1240 IAsyncReader_Release(This->pReader);
1241 CloseHandle(This->thread_sleepy);
1242 CloseHandle(This->hEventStateChanged);
1243 This->thread_lock.DebugInfo->Spare[0] = 0;
1244 DeleteCriticalSection(&This->thread_lock);
1245 CoTaskMemFree(This);
1246 return 0;
1247 }
1248 return refCount;
1249 }
1250
1251 static void PullPin_Flush(PullPin *This)
1252 {
1253 IMediaSample *pSample;
1254 TRACE("Flushing!\n");
1255
1256 if (This->pReader)
1257 {
1258 /* Flush outstanding samples */
1259 IAsyncReader_BeginFlush(This->pReader);
1260
1261 for (;;)
1262 {
1263 DWORD_PTR dwUser;
1264
1265 IAsyncReader_WaitForNext(This->pReader, 0, &pSample, &dwUser);
1266
1267 if (!pSample)
1268 break;
1269
1270 assert(!IMediaSample_GetActualDataLength(pSample));
1271
1272 IMediaSample_Release(pSample);
1273 }
1274
1275 IAsyncReader_EndFlush(This->pReader);
1276 }
1277 }
1278
1279 static void PullPin_Thread_Process(PullPin *This)
1280 {
1281 HRESULT hr;
1282 IMediaSample * pSample = NULL;
1283 ALLOCATOR_PROPERTIES allocProps;
1284
1285 hr = IMemAllocator_GetProperties(This->pAlloc, &allocProps);
1286
1287 This->cbAlign = allocProps.cbAlign;
1288
1289 if (This->rtCurrent < This->rtStart)
1290 This->rtCurrent = MEDIATIME_FROM_BYTES(ALIGNDOWN(BYTES_FROM_MEDIATIME(This->rtStart), This->cbAlign));
1291
1292 TRACE("Start\n");
1293
1294 if (This->rtCurrent >= This->rtStop)
1295 {
1296 IPin_EndOfStream((IPin *)This);
1297 return;
1298 }
1299
1300 /* There is no sample in our buffer */
1301 hr = This->fnCustomRequest(This->pin.pUserData);
1302
1303 if (FAILED(hr))
1304 ERR("Request error: %x\n", hr);
1305
1306 EnterCriticalSection(This->pin.pCritSec);
1307 SetEvent(This->hEventStateChanged);
1308 LeaveCriticalSection(This->pin.pCritSec);
1309
1310 if (SUCCEEDED(hr))
1311 do
1312 {
1313 DWORD_PTR dwUser;
1314
1315 TRACE("Process sample\n");
1316
1317 pSample = NULL;
1318 hr = IAsyncReader_WaitForNext(This->pReader, 10000, &pSample, &dwUser);
1319
1320 /* Return an empty sample on error to the implementation in case it does custom parsing, so it knows it's gone */
1321 if (SUCCEEDED(hr))
1322 {
1323 hr = This->fnSampleProc(This->pin.pUserData, pSample, dwUser);
1324 }
1325 else
1326 {
1327 /* FIXME: This is not well handled yet! */
1328 ERR("Processing error: %x\n", hr);
1329 if (hr == VFW_E_TIMEOUT)
1330 {
1331 assert(!pSample);
1332 hr = S_OK;
1333 continue;
1334 }
1335 }
1336
1337 if (pSample)
1338 {
1339 IMediaSample_Release(pSample);
1340 pSample = NULL;
1341 }
1342 } while (This->rtCurrent < This->rtStop && hr == S_OK && !This->stop_playback);
1343
1344 /* Sample was rejected, and we are asked to terminate */
1345 if (pSample)
1346 {
1347 IMediaSample_Release(pSample);
1348 }
1349
1350 /* Can't reset state to Sleepy here because that might race, instead PauseProcessing will do that for us
1351 * Flush remaining samples
1352 */
1353 if (This->fnDone)
1354 This->fnDone(This->pin.pUserData);
1355
1356 TRACE("End: %08x, %d\n", hr, This->stop_playback);
1357 }
1358
1359 static void PullPin_Thread_Pause(PullPin *This)
1360 {
1361 PullPin_Flush(This);
1362
1363 EnterCriticalSection(This->pin.pCritSec);
1364 This->state = Req_Sleepy;
1365 SetEvent(This->hEventStateChanged);
1366 LeaveCriticalSection(This->pin.pCritSec);
1367 }
1368
1369 static void PullPin_Thread_Stop(PullPin *This)
1370 {
1371 TRACE("(%p)->()\n", This);
1372
1373 EnterCriticalSection(This->pin.pCritSec);
1374 {
1375 CloseHandle(This->hThread);
1376 This->hThread = NULL;
1377 SetEvent(This->hEventStateChanged);
1378 }
1379 LeaveCriticalSection(This->pin.pCritSec);
1380
1381 IBaseFilter_Release(This->pin.pinInfo.pFilter);
1382
1383 CoUninitialize();
1384 ExitThread(0);
1385 }
1386
1387 static DWORD WINAPI PullPin_Thread_Main(LPVOID pv)
1388 {
1389 PullPin *This = pv;
1390 CoInitializeEx(NULL, COINIT_MULTITHREADED);
1391
1392 PullPin_Flush(This);
1393
1394 for (;;)
1395 {
1396 WaitForSingleObject(This->thread_sleepy, INFINITE);
1397
1398 TRACE("State: %d\n", This->state);
1399
1400 switch (This->state)
1401 {
1402 case Req_Die: PullPin_Thread_Stop(This); break;
1403 case Req_Run: PullPin_Thread_Process(This); break;
1404 case Req_Pause: PullPin_Thread_Pause(This); break;
1405 case Req_Sleepy: ERR("Should not be signalled with SLEEPY!\n"); break;
1406 default: ERR("Unknown state request: %d\n", This->state); break;
1407 }
1408 }
1409 return 0;
1410 }
1411
1412 static HRESULT PullPin_InitProcessing(PullPin * This)
1413 {
1414 HRESULT hr = S_OK;
1415
1416 TRACE("(%p)->()\n", This);
1417
1418 /* if we are connected */
1419 if (This->pAlloc)
1420 {
1421 DWORD dwThreadId;
1422
1423 WaitForSingleObject(This->hEventStateChanged, INFINITE);
1424 EnterCriticalSection(This->pin.pCritSec);
1425
1426 assert(!This->hThread);
1427 assert(This->state == Req_Die);
1428 assert(This->stop_playback);
1429 assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
1430 This->state = Req_Sleepy;
1431
1432 /* AddRef the filter to make sure it and it's pins will be around
1433 * as long as the thread */
1434 IBaseFilter_AddRef(This->pin.pinInfo.pFilter);
1435
1436
1437 This->hThread = CreateThread(NULL, 0, PullPin_Thread_Main, This, 0, &dwThreadId);
1438 if (!This->hThread)
1439 {
1440 hr = HRESULT_FROM_WIN32(GetLastError());
1441 IBaseFilter_Release(This->pin.pinInfo.pFilter);
1442 }
1443
1444 if (SUCCEEDED(hr))
1445 {
1446 SetEvent(This->hEventStateChanged);
1447 /* If assert fails, that means a command was not processed before the thread previously terminated */
1448 }
1449 LeaveCriticalSection(This->pin.pCritSec);
1450 }
1451
1452 TRACE(" -- %x\n", hr);
1453
1454 return hr;
1455 }
1456
1457 HRESULT PullPin_StartProcessing(PullPin * This)
1458 {
1459 /* if we are connected */
1460 TRACE("(%p)->()\n", This);
1461 if(This->pAlloc)
1462 {
1463 assert(This->hThread);
1464
1465 PullPin_WaitForStateChange(This, INFINITE);
1466
1467 assert(This->state == Req_Sleepy);
1468
1469 /* Wake up! */
1470 assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
1471 This->state = Req_Run;
1472 This->stop_playback = 0;
1473 ResetEvent(This->hEventStateChanged);
1474 SetEvent(This->thread_sleepy);
1475 }
1476
1477 return S_OK;
1478 }
1479
1480 HRESULT PullPin_PauseProcessing(PullPin * This)
1481 {
1482 /* if we are connected */
1483 TRACE("(%p)->()\n", This);
1484 if(This->pAlloc)
1485 {
1486 assert(This->hThread);
1487
1488 PullPin_WaitForStateChange(This, INFINITE);
1489
1490 EnterCriticalSection(This->pin.pCritSec);
1491
1492 assert(!This->stop_playback);
1493 assert(This->state == Req_Run|| This->state == Req_Sleepy);
1494
1495 assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
1496 This->state = Req_Pause;
1497 This->stop_playback = 1;
1498 ResetEvent(This->hEventStateChanged);
1499 SetEvent(This->thread_sleepy);
1500
1501 LeaveCriticalSection(This->pin.pCritSec);
1502 }
1503
1504 return S_OK;
1505 }
1506
1507 static HRESULT PullPin_StopProcessing(PullPin * This)
1508 {
1509 TRACE("(%p)->()\n", This);
1510
1511 /* if we are alive */
1512 assert(This->hThread);
1513
1514 PullPin_WaitForStateChange(This, INFINITE);
1515
1516 assert(This->state == Req_Pause || This->state == Req_Sleepy);
1517
1518 This->stop_playback = 1;
1519 This->state = Req_Die;
1520 assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
1521 ResetEvent(This->hEventStateChanged);
1522 SetEvent(This->thread_sleepy);
1523 return S_OK;
1524 }
1525
1526 HRESULT PullPin_WaitForStateChange(PullPin * This, DWORD dwMilliseconds)
1527 {
1528 if (WaitForSingleObject(This->hEventStateChanged, dwMilliseconds) == WAIT_TIMEOUT)
1529 return S_FALSE;
1530 return S_OK;
1531 }
1532
1533 HRESULT WINAPI PullPin_EndOfStream(IPin * iface)
1534 {
1535 FIXME("(%p)->() stub\n", iface);
1536
1537 return SendFurther( iface, deliver_endofstream, NULL, NULL );
1538 }
1539
1540 HRESULT WINAPI PullPin_BeginFlush(IPin * iface)
1541 {
1542 PullPin *This = (PullPin *)iface;
1543 TRACE("(%p)->()\n", This);
1544
1545 EnterCriticalSection(This->pin.pCritSec);
1546 {
1547 SendFurther( iface, deliver_beginflush, NULL, NULL );
1548 }
1549 LeaveCriticalSection(This->pin.pCritSec);
1550
1551 EnterCriticalSection(&This->thread_lock);
1552 {
1553 if (This->pReader)
1554 IAsyncReader_BeginFlush(This->pReader);
1555 PullPin_WaitForStateChange(This, INFINITE);
1556
1557 if (This->hThread && This->state == Req_Run)
1558 {
1559 PullPin_PauseProcessing(This);
1560 PullPin_WaitForStateChange(This, INFINITE);
1561 }
1562 }
1563 LeaveCriticalSection(&This->thread_lock);
1564
1565 EnterCriticalSection(This->pin.pCritSec);
1566 {
1567 This->fnCleanProc(This->pin.pUserData);
1568 }
1569 LeaveCriticalSection(This->pin.pCritSec);
1570
1571 return S_OK;
1572 }
1573
1574 HRESULT WINAPI PullPin_EndFlush(IPin * iface)
1575 {
1576 PullPin *This = (PullPin *)iface;
1577
1578 TRACE("(%p)->()\n", iface);
1579
1580 /* Send further first: Else a race condition might terminate processing early */
1581 EnterCriticalSection(This->pin.pCritSec);
1582 SendFurther( iface, deliver_endflush, NULL, NULL );
1583 LeaveCriticalSection(This->pin.pCritSec);
1584
1585 EnterCriticalSection(&This->thread_lock);
1586 {
1587 FILTER_STATE state;
1588
1589 if (This->pReader)
1590 IAsyncReader_EndFlush(This->pReader);
1591
1592 IBaseFilter_GetState(This->pin.pinInfo.pFilter, INFINITE, &state);
1593
1594 if (state != State_Stopped)
1595 PullPin_StartProcessing(This);
1596
1597 PullPin_WaitForStateChange(This, INFINITE);
1598 }
1599 LeaveCriticalSection(&This->thread_lock);
1600
1601 return S_OK;
1602 }
1603
1604 HRESULT WINAPI PullPin_Disconnect(IPin *iface)
1605 {
1606 HRESULT hr;
1607 PullPin *This = (PullPin *)iface;
1608
1609 TRACE("()\n");
1610
1611 EnterCriticalSection(This->pin.pCritSec);
1612 {
1613 if (FAILED(hr = IMemAllocator_Decommit(This->pAlloc)))
1614 ERR("Allocator decommit failed with error %x. Possible memory leak\n", hr);
1615
1616 if (This->pin.pConnectedTo)
1617 {
1618 IPin_Release(This->pin.pConnectedTo);
1619 This->pin.pConnectedTo = NULL;
1620 PullPin_StopProcessing(This);
1621
1622 FreeMediaType(&This->pin.mtCurrent);
1623 ZeroMemory(&This->pin.mtCurrent, sizeof(This->pin.mtCurrent));
1624 hr = S_OK;
1625 }
1626 else
1627 hr = S_FALSE;
1628 }
1629 LeaveCriticalSection(This->pin.pCritSec);
1630
1631 return hr;
1632 }
1633
1634 HRESULT WINAPI PullPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
1635 {
1636 newsegmentargs args;
1637 FIXME("(%p)->(%s, %s, %g) stub\n", iface, wine_dbgstr_longlong(tStart), wine_dbgstr_longlong(tStop), dRate);
1638
1639 args.tStart = tStart;
1640 args.tStop = tStop;
1641 args.rate = dRate;
1642
1643 return SendFurther( iface, deliver_newsegment, &args, NULL );
1644 }
1645
1646 static const IPinVtbl PullPin_Vtbl =
1647 {
1648 PullPin_QueryInterface,
1649 IPinImpl_AddRef,
1650 PullPin_Release,
1651 InputPin_Connect,
1652 PullPin_ReceiveConnection,
1653 PullPin_Disconnect,
1654 IPinImpl_ConnectedTo,
1655 IPinImpl_ConnectionMediaType,
1656 IPinImpl_QueryPinInfo,
1657 IPinImpl_QueryDirection,
1658 IPinImpl_QueryId,
1659 IPinImpl_QueryAccept,
1660 IPinImpl_EnumMediaTypes,
1661 IPinImpl_QueryInternalConnections,
1662 PullPin_EndOfStream,
1663 PullPin_BeginFlush,
1664 PullPin_EndFlush,
1665 PullPin_NewSegment
1666 };
1667
1668 /*** The Construct functions ***/
1669
1670 /* Function called as a helper to IPin_Connect */
1671 /* specific AM_MEDIA_TYPE - it cannot be NULL */
1672 /* NOTE: not part of standard interface */
1673 static HRESULT OutputPin_ConnectSpecific(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
1674 {
1675 OutputPin *This = (OutputPin *)iface;
1676 HRESULT hr;
1677 IMemAllocator * pMemAlloc = NULL;
1678 ALLOCATOR_PROPERTIES actual; /* FIXME: should we put the actual props back in to This? */
1679
1680 TRACE("(%p, %p)\n", pReceivePin, pmt);
1681 dump_AM_MEDIA_TYPE(pmt);
1682
1683 /* FIXME: call queryacceptproc */
1684
1685 This->pin.pConnectedTo = pReceivePin;
1686 IPin_AddRef(pReceivePin);
1687 CopyMediaType(&This->pin.mtCurrent, pmt);
1688
1689 hr = IPin_ReceiveConnection(pReceivePin, iface, pmt);
1690
1691 /* get the IMemInputPin interface we will use to deliver samples to the
1692 * connected pin */
1693 if (SUCCEEDED(hr))
1694 {
1695 This->pMemInputPin = NULL;
1696 hr = IPin_QueryInterface(pReceivePin, &IID_IMemInputPin, (LPVOID)&This->pMemInputPin);
1697
1698 if (SUCCEEDED(hr) && !This->custom_allocator)
1699 {
1700 hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pMemAlloc);
1701
1702 if (hr == VFW_E_NO_ALLOCATOR)
1703 /* Input pin provides no allocator, use standard memory allocator */
1704 hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC_SERVER, &IID_IMemAllocator, (LPVOID*)&pMemAlloc);
1705
1706 if (SUCCEEDED(hr))
1707 hr = IMemAllocator_SetProperties(pMemAlloc, &This->allocProps, &actual);
1708
1709 if (SUCCEEDED(hr))
1710 hr = IMemInputPin_NotifyAllocator(This->pMemInputPin, pMemAlloc, This->readonly);
1711
1712 if (pMemAlloc)
1713 IMemAllocator_Release(pMemAlloc);
1714 }
1715 else if (SUCCEEDED(hr))
1716 {
1717 if (This->alloc)
1718 {
1719 hr = IMemInputPin_NotifyAllocator(This->pMemInputPin, This->alloc, This->readonly);
1720 }
1721 else
1722 hr = VFW_E_NO_ALLOCATOR;
1723 }
1724
1725 /* break connection if we couldn't get the allocator */
1726 if (FAILED(hr))
1727 {
1728 if (This->pMemInputPin)
1729 IMemInputPin_Release(This->pMemInputPin);
1730 This->pMemInputPin = NULL;
1731
1732 IPin_Disconnect(pReceivePin);
1733 }
1734 }
1735
1736 if (FAILED(hr))
1737 {
1738 IPin_Release(This->pin.pConnectedTo);
1739 This->pin.pConnectedTo = NULL;
1740 FreeMediaType(&This->pin.mtCurrent);
1741 }
1742
1743 TRACE(" -- %x\n", hr);
1744 return hr;
1745 }
1746
1747 static HRESULT InputPin_Init(const IPinVtbl *InputPin_Vtbl, const PIN_INFO * pPinInfo, SAMPLEPROC_PUSH pSampleProc, LPVOID pUserData,
1748 QUERYACCEPTPROC pQueryAccept, CLEANUPPROC pCleanUp, LPCRITICAL_SECTION pCritSec, IMemAllocator *allocator, InputPin * pPinImpl)
1749 {
1750 TRACE("\n");
1751
1752 /* Common attributes */
1753 pPinImpl->pin.refCount = 1;
1754 pPinImpl->pin.pConnectedTo = NULL;
1755 pPinImpl->pin.fnQueryAccept = pQueryAccept;
1756 pPinImpl->pin.pUserData = pUserData;
1757 pPinImpl->pin.pCritSec = pCritSec;
1758 Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
1759 ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE));
1760
1761 /* Input pin attributes */
1762 pPinImpl->fnSampleProc = pSampleProc;
1763 pPinImpl->fnCleanProc = pCleanUp;
1764 pPinImpl->pAllocator = pPinImpl->preferred_allocator = allocator;
1765 if (pPinImpl->preferred_allocator)
1766 IMemAllocator_AddRef(pPinImpl->preferred_allocator);
1767 pPinImpl->tStart = 0;
1768 pPinImpl->tStop = 0;
1769 pPinImpl->dRate = 1.0;
1770 pPinImpl->pin.lpVtbl = InputPin_Vtbl;
1771 pPinImpl->lpVtblMemInput = &MemInputPin_Vtbl;
1772 pPinImpl->flushing = pPinImpl->end_of_stream = 0;
1773
1774 return S_OK;
1775 }
1776
1777 static HRESULT OutputPin_Init(const IPinVtbl *OutputPin_Vtbl, const PIN_INFO * pPinInfo, const ALLOCATOR_PROPERTIES * props, LPVOID pUserData,
1778 QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, OutputPin * pPinImpl)
1779 {
1780 TRACE("\n");
1781
1782 /* Common attributes */
1783 pPinImpl->pin.lpVtbl = OutputPin_Vtbl;
1784 pPinImpl->pin.refCount = 1;
1785 pPinImpl->pin.pConnectedTo = NULL;
1786 pPinImpl->pin.fnQueryAccept = pQueryAccept;
1787 pPinImpl->pin.pUserData = pUserData;
1788 pPinImpl->pin.pCritSec = pCritSec;
1789 Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
1790 ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE));
1791
1792 /* Output pin attributes */
1793 pPinImpl->pMemInputPin = NULL;
1794 pPinImpl->pConnectSpecific = OutputPin_ConnectSpecific;
1795 /* If custom_allocator is set, you will need to specify an allocator
1796 * in the alloc member of the struct before an output pin can connect
1797 */
1798 pPinImpl->custom_allocator = 0;
1799 pPinImpl->alloc = NULL;
1800 pPinImpl->readonly = FALSE;
1801 if (props)
1802 {
1803 pPinImpl->allocProps = *props;
1804 if (pPinImpl->allocProps.cbAlign == 0)
1805 pPinImpl->allocProps.cbAlign = 1;
1806 }
1807 else
1808 ZeroMemory(&pPinImpl->allocProps, sizeof(pPinImpl->allocProps));
1809
1810 return S_OK;
1811 }
1812
1813 HRESULT InputPin_Construct(const IPinVtbl *InputPin_Vtbl, const PIN_INFO * pPinInfo, SAMPLEPROC_PUSH pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, CLEANUPPROC pCleanUp, LPCRITICAL_SECTION pCritSec, IMemAllocator *allocator, IPin ** ppPin)
1814 {
1815 InputPin * pPinImpl;
1816
1817 *ppPin = NULL;
1818
1819 if (pPinInfo->dir != PINDIR_INPUT)
1820 {
1821 ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir);
1822 return E_INVALIDARG;
1823 }
1824
1825 pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl));
1826
1827 if (!pPinImpl)
1828 return E_OUTOFMEMORY;
1829
1830 if (SUCCEEDED(InputPin_Init(InputPin_Vtbl, pPinInfo, pSampleProc, pUserData, pQueryAccept, pCleanUp, pCritSec, allocator, pPinImpl)))
1831 {
1832 *ppPin = (IPin *)pPinImpl;
1833 return S_OK;
1834 }
1835
1836 CoTaskMemFree(pPinImpl);
1837 return E_FAIL;
1838 }
1839
1840 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)
1841 {
1842 OutputPin * pPinImpl;
1843
1844 *ppPin = NULL;
1845
1846 if (pPinInfo->dir != PINDIR_OUTPUT)
1847 {
1848 ERR("Pin direction(%x) != PINDIR_OUTPUT\n", pPinInfo->dir);
1849 return E_INVALIDARG;
1850 }
1851
1852 assert(outputpin_size >= sizeof(OutputPin));
1853
1854 pPinImpl = CoTaskMemAlloc(outputpin_size);
1855
1856 if (!pPinImpl)
1857 return E_OUTOFMEMORY;
1858
1859 if (SUCCEEDED(OutputPin_Init(OutputPin_Vtbl, pPinInfo, props, pUserData, pQueryAccept, pCritSec, pPinImpl)))
1860 {
1861 *ppPin = (IPin *)(&pPinImpl->pin.lpVtbl);
1862 return S_OK;
1863 }
1864
1865 CoTaskMemFree(pPinImpl);
1866 return E_FAIL;
1867 }