msi: Free the column info data when updating the table column info.
[wine] / dlls / 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 }