d3d9: Surfaces always have resource type WINED3DRTYPE_SURFACE.
[wine] / dlls / qcap / vfwcapture.c
1 /* Video For Windows Steering structure
2  *
3  * Copyright 2005 Maarten Lankhorst
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18  *
19  */
20
21 #define NONAMELESSSTRUCT
22 #define NONAMELESSUNION
23 #define COBJMACROS
24
25 #include "config.h"
26 #include <stdarg.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wtypes.h"
31 #include "wingdi.h"
32 #include "winuser.h"
33 #include "dshow.h"
34
35 #include "qcap_main.h"
36 #include "wine/debug.h"
37
38 #include "capture.h"
39 #include "uuids.h"
40 #include "vfwmsgs.h"
41 #include "amvideo.h"
42 #include "strmif.h"
43 #include "ddraw.h"
44 #include "ocidl.h"
45 #include "oleauto.h"
46
47 WINE_DEFAULT_DEBUG_CHANNEL(qcap);
48
49 #define ICOM_THIS_MULTI(impl,field,iface) \
50     impl* const This=(impl*)((char*)(iface) - offsetof(impl,field))
51
52 static const IBaseFilterVtbl VfwCapture_Vtbl;
53 static const IAMStreamConfigVtbl IAMStreamConfig_VTable;
54 static const IAMVideoProcAmpVtbl IAMVideoProcAmp_VTable;
55 static const IPersistPropertyBagVtbl IPersistPropertyBag_VTable;
56 static const IPinVtbl VfwPin_Vtbl;
57
58 static HRESULT VfwPin_Construct( IBaseFilter *, LPCRITICAL_SECTION, IPin ** );
59
60 typedef struct VfwCapture
61 {
62     BaseFilter filter;
63     IAMStreamConfig IAMStreamConfig_iface;
64     IAMVideoProcAmp IAMVideoProcAmp_iface;
65     IPersistPropertyBag IPersistPropertyBag_iface;
66
67     BOOL init;
68     Capture *driver_info;
69
70     IPin * pOutputPin;
71 } VfwCapture;
72
73 static inline VfwCapture *impl_from_IAMStreamConfig(IAMStreamConfig *iface)
74 {
75     return CONTAINING_RECORD(iface, VfwCapture, IAMStreamConfig_iface);
76 }
77
78 static inline VfwCapture *impl_from_IAMVideoProcAmp(IAMVideoProcAmp *iface)
79 {
80     return CONTAINING_RECORD(iface, VfwCapture, IAMVideoProcAmp_iface);
81 }
82
83 static inline VfwCapture *impl_from_IPersistPropertyBag(IPersistPropertyBag *iface)
84 {
85     return CONTAINING_RECORD(iface, VfwCapture, IPersistPropertyBag_iface);
86 }
87
88 /* VfwPin implementation */
89 typedef struct VfwPinImpl
90 {
91     BaseOutputPin pin;
92     Capture *driver_info;
93     VfwCapture *parent;
94     const IKsPropertySetVtbl * KSP_VT;
95 } VfwPinImpl;
96
97 static IPin* WINAPI VfwCapture_GetPin(BaseFilter *iface, int pos)
98 {
99     VfwCapture *This = (VfwCapture *)iface;
100
101     if (pos >= 1 || pos < 0)
102         return NULL;
103
104     IPin_AddRef(This->pOutputPin);
105     return This->pOutputPin;
106 }
107
108 static LONG WINAPI VfwCapture_GetPinCount(BaseFilter *iface)
109 {
110     return 1;
111 }
112
113 static const BaseFilterFuncTable BaseFuncTable = {
114     VfwCapture_GetPin,
115     VfwCapture_GetPinCount
116 };
117
118 IUnknown * WINAPI QCAP_createVFWCaptureFilter(IUnknown *pUnkOuter, HRESULT *phr)
119 {
120     VfwCapture *pVfwCapture;
121     HRESULT hr;
122
123     TRACE("%p - %p\n", pUnkOuter, phr);
124
125     *phr = CLASS_E_NOAGGREGATION;
126     if (pUnkOuter)
127         return NULL;
128     *phr = E_OUTOFMEMORY;
129
130     pVfwCapture = CoTaskMemAlloc( sizeof(VfwCapture) );
131
132     if (!pVfwCapture)
133         return NULL;
134
135     BaseFilter_Init(&pVfwCapture->filter, &VfwCapture_Vtbl, &CLSID_VfwCapture, (DWORD_PTR)(__FILE__ ": VfwCapture.csFilter"), &BaseFuncTable);
136
137     pVfwCapture->IAMStreamConfig_iface.lpVtbl = &IAMStreamConfig_VTable;
138     pVfwCapture->IAMVideoProcAmp_iface.lpVtbl = &IAMVideoProcAmp_VTable;
139     pVfwCapture->IPersistPropertyBag_iface.lpVtbl = &IPersistPropertyBag_VTable;
140     pVfwCapture->init = FALSE;
141
142     hr = VfwPin_Construct((IBaseFilter *)&pVfwCapture->filter.lpVtbl,
143                    &pVfwCapture->filter.csFilter, &pVfwCapture->pOutputPin);
144     if (FAILED(hr))
145     {
146         CoTaskMemFree(pVfwCapture);
147         return NULL;
148     }
149     TRACE("-- created at %p\n", pVfwCapture);
150
151     ObjectRefCount(TRUE);
152     *phr = S_OK;
153     return (IUnknown *)pVfwCapture;
154 }
155
156 static HRESULT WINAPI VfwCapture_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
157 {
158     VfwCapture *This = (VfwCapture *)iface;
159     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
160     *ppv = NULL;
161
162     if (IsEqualIID(riid, &IID_IUnknown) ||
163         IsEqualIID(riid, &IID_IPersist) ||
164         IsEqualIID(riid, &IID_IMediaFilter) ||
165         IsEqualIID(riid, &IID_IBaseFilter))
166     {
167         *ppv = This;
168     }
169     else if (IsEqualIID(riid, &IID_IAMStreamConfig))
170         *ppv = &This->IAMStreamConfig_iface;
171     else if (IsEqualIID(riid, &IID_IAMVideoProcAmp))
172         *ppv = &This->IAMVideoProcAmp_iface;
173     else if (IsEqualIID(riid, &IID_IPersistPropertyBag))
174         *ppv = &This->IPersistPropertyBag_iface;
175
176     if (!IsEqualIID(riid, &IID_IUnknown) &&
177         !IsEqualIID(riid, &IID_IPersist) &&
178         !IsEqualIID(riid, &IID_IPersistPropertyBag) &&
179         !This->init)
180     {
181         FIXME("Capture system not initialised when looking for %s, "
182               "trying it on primary device now\n", debugstr_guid(riid));
183         This->driver_info = qcap_driver_init( This->pOutputPin, 0 );
184         if (!This->driver_info)
185         {
186             ERR("VfwCapture initialisation failed\n");
187             return E_UNEXPECTED;
188         }
189         This->init = TRUE;
190     }
191
192     if (*ppv)
193     {
194         TRACE("Returning %s interface\n", debugstr_guid(riid));
195         IUnknown_AddRef((IUnknown *)(*ppv));
196         return S_OK;
197     }
198
199     FIXME("No interface for %s!\n", debugstr_guid(riid));
200     return E_NOINTERFACE;
201 }
202
203 static ULONG WINAPI VfwCapture_Release(IBaseFilter * iface)
204 {
205     VfwCapture *This = (VfwCapture *)iface;
206     ULONG refCount = BaseFilterImpl_Release(iface);
207
208     TRACE("%p->() New refcount: %d\n", This, refCount);
209
210     if (!refCount)
211     {
212         BasePin *pin;
213
214         TRACE("destroying everything\n");
215         if (This->init)
216         {
217             if (This->filter.state != State_Stopped)
218                 qcap_driver_stop(This->driver_info, &This->filter.state);
219             qcap_driver_destroy(This->driver_info);
220         }
221         pin = (BasePin*) This->pOutputPin;
222         if (pin->pConnectedTo != NULL)
223         {
224             IPin_Disconnect(pin->pConnectedTo);
225             IPin_Disconnect(This->pOutputPin);
226         }
227         IPin_Release(This->pOutputPin);
228         CoTaskMemFree(This);
229         ObjectRefCount(FALSE);
230     }
231     return refCount;
232 }
233
234 /** IMediaFilter methods **/
235
236 static HRESULT WINAPI VfwCapture_Stop(IBaseFilter * iface)
237 {
238     VfwCapture *This = (VfwCapture *)iface;
239
240     TRACE("()\n");
241     return qcap_driver_stop(This->driver_info, &This->filter.state);
242 }
243
244 static HRESULT WINAPI VfwCapture_Pause(IBaseFilter * iface)
245 {
246     VfwCapture *This = (VfwCapture *)iface;
247
248     TRACE("()\n");
249     return qcap_driver_pause(This->driver_info, &This->filter.state);
250 }
251
252 static HRESULT WINAPI VfwCapture_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
253 {
254     VfwCapture *This = (VfwCapture *)iface;
255     TRACE("(%x%08x)\n", (ULONG)(tStart >> 32), (ULONG)tStart);
256     return qcap_driver_run(This->driver_info, &This->filter.state);
257 }
258
259 /** IBaseFilter methods **/
260 static HRESULT WINAPI VfwCapture_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
261 {
262     FIXME("(%s, %p) - stub\n", debugstr_w(Id), ppPin);
263     return E_NOTIMPL;
264 }
265
266 static const IBaseFilterVtbl VfwCapture_Vtbl =
267 {
268     VfwCapture_QueryInterface,
269     BaseFilterImpl_AddRef,
270     VfwCapture_Release,
271     BaseFilterImpl_GetClassID,
272     VfwCapture_Stop,
273     VfwCapture_Pause,
274     VfwCapture_Run,
275     BaseFilterImpl_GetState,
276     BaseFilterImpl_SetSyncSource,
277     BaseFilterImpl_GetSyncSource,
278     BaseFilterImpl_EnumPins,
279     VfwCapture_FindPin,
280     BaseFilterImpl_QueryFilterInfo,
281     BaseFilterImpl_JoinFilterGraph,
282     BaseFilterImpl_QueryVendorInfo
283 };
284
285 /* AMStreamConfig interface, we only need to implement {G,S}etFormat */
286 static HRESULT WINAPI
287 AMStreamConfig_QueryInterface( IAMStreamConfig * iface, REFIID riid, LPVOID * ppv )
288 {
289     VfwCapture *This = impl_from_IAMStreamConfig(iface);
290
291     TRACE("%p --> %s\n", This, debugstr_guid(riid));
292
293     if (IsEqualIID(riid, &IID_IUnknown) ||
294         IsEqualIID(riid, &IID_IAMStreamConfig))
295     {
296         IAMStreamConfig_AddRef(iface);
297         *ppv = iface;
298         return S_OK;
299     }
300
301     FIXME("No interface for iid %s\n", debugstr_guid(riid));
302     return E_NOINTERFACE;
303 }
304
305 static ULONG WINAPI AMStreamConfig_AddRef( IAMStreamConfig * iface )
306 {
307     VfwCapture *This = impl_from_IAMStreamConfig(iface);
308
309     TRACE("%p --> Forwarding to VfwCapture (%p)\n", iface, This);
310     return IUnknown_AddRef((IUnknown *)This);
311 }
312
313 static ULONG WINAPI AMStreamConfig_Release( IAMStreamConfig * iface )
314 {
315     VfwCapture *This = impl_from_IAMStreamConfig(iface);
316
317     TRACE("%p --> Forwarding to VfwCapture (%p)\n", iface, This);
318     return IUnknown_Release((IUnknown *)This);
319 }
320
321 static HRESULT WINAPI
322 AMStreamConfig_SetFormat(IAMStreamConfig *iface, AM_MEDIA_TYPE *pmt)
323 {
324     HRESULT hr;
325     VfwCapture *This = impl_from_IAMStreamConfig(iface);
326     BasePin *pin;
327
328     TRACE("(%p): %p->%p\n", iface, pmt, pmt ? pmt->pbFormat : NULL);
329
330     if (This->filter.state != State_Stopped)
331     {
332         TRACE("Returning not stopped error\n");
333         return VFW_E_NOT_STOPPED;
334     }
335
336     if (!pmt)
337     {
338         TRACE("pmt is NULL\n");
339         return E_POINTER;
340     }
341
342     dump_AM_MEDIA_TYPE(pmt);
343
344     pin = (BasePin *)This->pOutputPin;
345     if (pin->pConnectedTo != NULL)
346     {
347         hr = IPin_QueryAccept(pin->pConnectedTo, pmt);
348         TRACE("Would accept: %d\n", hr);
349         if (hr == S_FALSE)
350             return VFW_E_INVALIDMEDIATYPE;
351     }
352
353     hr = qcap_driver_set_format(This->driver_info, pmt);
354     if (SUCCEEDED(hr) && This->filter.filterInfo.pGraph && pin->pConnectedTo )
355     {
356         hr = IFilterGraph_Reconnect(This->filter.filterInfo.pGraph, This->pOutputPin);
357         if (SUCCEEDED(hr))
358             TRACE("Reconnection completed, with new media format..\n");
359     }
360     TRACE("Returning: %d\n", hr);
361     return hr;
362 }
363
364 static HRESULT WINAPI
365 AMStreamConfig_GetFormat( IAMStreamConfig *iface, AM_MEDIA_TYPE **pmt )
366 {
367     VfwCapture *This = impl_from_IAMStreamConfig(iface);
368
369     TRACE("%p -> (%p)\n", iface, pmt);
370     return qcap_driver_get_format(This->driver_info, pmt);
371 }
372
373 static HRESULT WINAPI
374 AMStreamConfig_GetNumberOfCapabilities( IAMStreamConfig *iface, int *piCount,
375                                         int *piSize )
376 {
377     FIXME("%p: %p %p - stub, intentional\n", iface, piCount, piSize);
378     return E_NOTIMPL; /* Not implemented for this interface */
379 }
380
381 static HRESULT WINAPI
382 AMStreamConfig_GetStreamCaps( IAMStreamConfig *iface, int iIndex,
383                               AM_MEDIA_TYPE **pmt, BYTE *pSCC )
384 {
385     FIXME("%p: %d %p %p - stub, intentional\n", iface, iIndex, pmt, pSCC);
386     return E_NOTIMPL; /* Not implemented for this interface */
387 }
388
389 static const IAMStreamConfigVtbl IAMStreamConfig_VTable =
390 {
391     AMStreamConfig_QueryInterface,
392     AMStreamConfig_AddRef,
393     AMStreamConfig_Release,
394     AMStreamConfig_SetFormat,
395     AMStreamConfig_GetFormat,
396     AMStreamConfig_GetNumberOfCapabilities,
397     AMStreamConfig_GetStreamCaps
398 };
399
400 static HRESULT WINAPI
401 AMVideoProcAmp_QueryInterface( IAMVideoProcAmp * iface, REFIID riid,
402                                LPVOID * ppv )
403 {
404     if (IsEqualIID(riid, &IID_IUnknown) ||
405         IsEqualIID(riid, &IID_IAMVideoProcAmp))
406     {
407         *ppv = iface;
408         IAMVideoProcAmp_AddRef( iface );
409         return S_OK;
410     }
411
412     FIXME("No interface for iid %s\n", debugstr_guid(riid));
413     return E_NOINTERFACE;
414 }
415
416 static ULONG WINAPI AMVideoProcAmp_AddRef(IAMVideoProcAmp * iface)
417 {
418     VfwCapture *This = impl_from_IAMVideoProcAmp(iface);
419
420     return IUnknown_AddRef((IUnknown *)This);
421 }
422
423 static ULONG WINAPI AMVideoProcAmp_Release(IAMVideoProcAmp * iface)
424 {
425     VfwCapture *This = impl_from_IAMVideoProcAmp(iface);
426
427     return IUnknown_Release((IUnknown *)This);
428 }
429
430 static HRESULT WINAPI
431 AMVideoProcAmp_GetRange( IAMVideoProcAmp * iface, LONG Property, LONG *pMin,
432         LONG *pMax, LONG *pSteppingDelta, LONG *pDefault, LONG *pCapsFlags )
433 {
434     VfwCapture *This = impl_from_IAMVideoProcAmp(iface);
435
436     return qcap_driver_get_prop_range( This->driver_info, Property, pMin, pMax,
437                    pSteppingDelta, pDefault, pCapsFlags );
438 }
439
440 static HRESULT WINAPI
441 AMVideoProcAmp_Set( IAMVideoProcAmp * iface, LONG Property, LONG lValue,
442                     LONG Flags )
443 {
444     VfwCapture *This = impl_from_IAMVideoProcAmp(iface);
445
446     return qcap_driver_set_prop(This->driver_info, Property, lValue, Flags);
447 }
448
449 static HRESULT WINAPI
450 AMVideoProcAmp_Get( IAMVideoProcAmp * iface, LONG Property, LONG *lValue,
451                     LONG *Flags )
452 {
453     VfwCapture *This = impl_from_IAMVideoProcAmp(iface);
454
455     return qcap_driver_get_prop(This->driver_info, Property, lValue, Flags);
456 }
457
458 static const IAMVideoProcAmpVtbl IAMVideoProcAmp_VTable =
459 {
460     AMVideoProcAmp_QueryInterface,
461     AMVideoProcAmp_AddRef,
462     AMVideoProcAmp_Release,
463     AMVideoProcAmp_GetRange,
464     AMVideoProcAmp_Set,
465     AMVideoProcAmp_Get,
466 };
467
468 static HRESULT WINAPI
469 PPB_QueryInterface( IPersistPropertyBag * iface, REFIID riid, LPVOID * ppv )
470 {
471     if (IsEqualIID(riid, &IID_IUnknown) ||
472         IsEqualIID(riid, &IID_IPersist) ||
473         IsEqualIID(riid, &IID_IPersistPropertyBag))
474     {
475         IPersistPropertyBag_AddRef(iface);
476         *ppv = iface;
477         return S_OK;
478     }
479     if (IsEqualIID(riid, &IID_IBaseFilter))
480     {
481         /* FIXME: native devenum asks for IBaseFilter, should we return it? */
482         IPersistPropertyBag_AddRef(iface);
483         *ppv = iface;
484         return S_OK;
485     }
486
487     FIXME("No interface for iid %s\n", debugstr_guid(riid));
488     return E_NOINTERFACE;
489 }
490
491 static ULONG WINAPI PPB_AddRef(IPersistPropertyBag * iface)
492 {
493     VfwCapture *This = impl_from_IPersistPropertyBag(iface);
494
495     TRACE("%p --> Forwarding to VfwCapture (%p)\n", iface, This);
496
497     return IUnknown_AddRef((IUnknown *)This);
498 }
499
500 static ULONG WINAPI PPB_Release(IPersistPropertyBag * iface)
501 {
502     VfwCapture *This = impl_from_IPersistPropertyBag(iface);
503
504     TRACE("%p --> Forwarding to VfwCapture (%p)\n", iface, This);
505
506     return IUnknown_Release((IUnknown *)This);
507 }
508
509 static HRESULT WINAPI
510 PPB_GetClassID( IPersistPropertyBag * iface, CLSID * pClassID )
511 {
512     VfwCapture *This = impl_from_IPersistPropertyBag(iface);
513
514     FIXME("%p - stub\n", This);
515
516     return E_NOTIMPL;
517 }
518
519 static HRESULT WINAPI PPB_InitNew(IPersistPropertyBag * iface)
520 {
521     VfwCapture *This = impl_from_IPersistPropertyBag(iface);
522
523     FIXME("%p - stub\n", This);
524
525     return E_NOTIMPL;
526 }
527
528 static HRESULT WINAPI
529 PPB_Load( IPersistPropertyBag * iface, IPropertyBag *pPropBag,
530           IErrorLog *pErrorLog )
531 {
532     VfwCapture *This = impl_from_IPersistPropertyBag(iface);
533     HRESULT hr;
534     VARIANT var;
535     const OLECHAR VFWIndex[] = {'V','F','W','I','n','d','e','x',0};
536
537     TRACE("%p/%p-> (%p, %p)\n", iface, This, pPropBag, pErrorLog);
538
539     V_VT(&var) = VT_I4;
540     hr = IPropertyBag_Read(pPropBag, VFWIndex, &var, pErrorLog);
541
542     if (SUCCEEDED(hr))
543     {
544         VfwPinImpl *pin;
545
546         This->driver_info = qcap_driver_init( This->pOutputPin,
547                var.__VARIANT_NAME_1.__VARIANT_NAME_2.__VARIANT_NAME_3.ulVal );
548         if (This->driver_info)
549         {
550             pin = (VfwPinImpl *)This->pOutputPin;
551             pin->driver_info = This->driver_info;
552             pin->parent = This;
553             This->init = TRUE;
554             hr = S_OK;
555         }
556         else
557             hr = E_FAIL;
558     }
559
560     return hr;
561 }
562
563 static HRESULT WINAPI
564 PPB_Save( IPersistPropertyBag * iface, IPropertyBag *pPropBag,
565           BOOL fClearDirty, BOOL fSaveAllProperties )
566 {
567     VfwCapture *This = impl_from_IPersistPropertyBag(iface);
568     FIXME("%p - stub\n", This);
569     return E_NOTIMPL;
570 }
571
572 static const IPersistPropertyBagVtbl IPersistPropertyBag_VTable =
573 {
574     PPB_QueryInterface,
575     PPB_AddRef,
576     PPB_Release,
577     PPB_GetClassID,
578     PPB_InitNew,
579     PPB_Load,
580     PPB_Save
581 };
582
583 /* IKsPropertySet interface */
584 static HRESULT WINAPI
585 KSP_QueryInterface( IKsPropertySet * iface, REFIID riid, LPVOID * ppv )
586 {
587     if (IsEqualIID(riid, &IID_IUnknown) ||
588         IsEqualIID(riid, &IID_IKsPropertySet))
589     {
590         *ppv = iface;
591         IKsPropertySet_AddRef( iface );
592         return S_OK;
593     }
594
595     FIXME("No interface for iid %s\n", debugstr_guid(riid));
596     return E_NOINTERFACE;
597 }
598
599 static ULONG WINAPI KSP_AddRef(IKsPropertySet * iface)
600 {
601     ICOM_THIS_MULTI(VfwPinImpl, KSP_VT, iface);
602
603     TRACE("%p --> Forwarding to VfwPin (%p)\n", iface, This);
604
605     return IUnknown_AddRef((IUnknown *)This);
606 }
607
608 static ULONG WINAPI KSP_Release(IKsPropertySet * iface)
609 {
610     ICOM_THIS_MULTI(VfwPinImpl, KSP_VT, iface);
611
612     TRACE("%p --> Forwarding to VfwPin (%p)\n", iface, This);
613
614     return IUnknown_Release((IUnknown *)This);
615 }
616
617 static HRESULT WINAPI
618 KSP_Set( IKsPropertySet * iface, REFGUID guidPropSet, DWORD dwPropID,
619          LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData,
620          DWORD cbPropData )
621 {
622     FIXME("%p: stub\n", iface);
623     return E_NOTIMPL;
624 }
625
626 static HRESULT WINAPI
627 KSP_Get( IKsPropertySet * iface, REFGUID guidPropSet, DWORD dwPropID,
628          LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData,
629          DWORD cbPropData, DWORD *pcbReturned )
630 {
631     LPGUID pGuid;
632
633     TRACE("()\n");
634
635     if (!IsEqualIID(guidPropSet, &AMPROPSETID_Pin))
636         return E_PROP_SET_UNSUPPORTED;
637     if (pPropData == NULL && pcbReturned == NULL)
638         return E_POINTER;
639     if (pcbReturned)
640         *pcbReturned = sizeof(GUID);
641     if (pPropData == NULL)
642         return S_OK;
643     if (cbPropData < sizeof(GUID))
644         return E_UNEXPECTED;
645     pGuid = pPropData;
646     *pGuid = PIN_CATEGORY_PREVIEW;
647     FIXME("() Not adding a pin with PIN_CATEGORY_CAPTURE\n");
648     return S_OK;
649 }
650
651 static HRESULT WINAPI
652 KSP_QuerySupported( IKsPropertySet * iface, REFGUID guidPropSet,
653                     DWORD dwPropID, DWORD *pTypeSupport )
654 {
655    FIXME("%p: stub\n", iface);
656    return E_NOTIMPL;
657 }
658
659 static const IKsPropertySetVtbl KSP_VTable =
660 {
661    KSP_QueryInterface,
662    KSP_AddRef,
663    KSP_Release,
664    KSP_Set,
665    KSP_Get,
666    KSP_QuerySupported
667 };
668
669 static HRESULT WINAPI VfwPin_GetMediaType(BasePin *iface, int iPosition, AM_MEDIA_TYPE *pmt)
670 {
671     VfwPinImpl *This = (VfwPinImpl *)iface;
672     AM_MEDIA_TYPE *vfw_pmt;
673     HRESULT hr;
674
675     if (iPosition < 0)
676         return E_INVALIDARG;
677     if (iPosition > 0)
678         return VFW_S_NO_MORE_ITEMS;
679
680     hr = qcap_driver_get_format(This->driver_info, &vfw_pmt);
681     CopyMediaType(pmt, vfw_pmt);
682     DeleteMediaType(vfw_pmt);
683
684     return hr;
685 }
686
687 LONG WINAPI VfwPin_GetMediaTypeVersion(BasePin *iface)
688 {
689     return 1;
690 }
691
692 static HRESULT WINAPI VfwPin_DecideBufferSize(BaseOutputPin *iface, IMemAllocator *pAlloc, ALLOCATOR_PROPERTIES *ppropInputRequest)
693 {
694     ALLOCATOR_PROPERTIES actual;
695
696     /* What we put here doesn't matter, the
697        driver function should override it then commit */
698     if (!ppropInputRequest->cBuffers)
699         ppropInputRequest->cBuffers = 3;
700     if (!ppropInputRequest->cbBuffer)
701         ppropInputRequest->cbBuffer = 230400;
702     if (!ppropInputRequest->cbAlign)
703         ppropInputRequest->cbAlign = 1;
704
705     return IMemAllocator_SetProperties(pAlloc, ppropInputRequest, &actual);
706 }
707
708 static const  BasePinFuncTable output_BaseFuncTable = {
709     NULL,
710     BaseOutputPinImpl_AttemptConnection,
711     VfwPin_GetMediaTypeVersion,
712     VfwPin_GetMediaType
713 };
714
715 static const BaseOutputPinFuncTable output_BaseOutputFuncTable = {
716     VfwPin_DecideBufferSize,
717     BaseOutputPinImpl_DecideAllocator,
718     BaseOutputPinImpl_BreakConnect
719 };
720
721 static HRESULT
722 VfwPin_Construct( IBaseFilter * pBaseFilter, LPCRITICAL_SECTION pCritSec,
723                   IPin ** ppPin )
724 {
725     static const WCHAR wszOutputPinName[] = { 'O','u','t','p','u','t',0 };
726     PIN_INFO piOutput;
727     HRESULT hr;
728
729     ppPin = NULL;
730
731     piOutput.dir = PINDIR_OUTPUT;
732     piOutput.pFilter = pBaseFilter;
733     lstrcpyW(piOutput.achName, wszOutputPinName);
734     ObjectRefCount(TRUE);
735
736     hr = BaseOutputPin_Construct(&VfwPin_Vtbl, sizeof(VfwPinImpl), &piOutput, &output_BaseFuncTable, &output_BaseOutputFuncTable, pCritSec, ppPin);
737
738     if (SUCCEEDED(hr))
739     {
740         VfwPinImpl *pPinImpl = (VfwPinImpl*)*ppPin;
741         pPinImpl->KSP_VT = &KSP_VTable;
742     }
743
744     return hr;
745 }
746
747 static HRESULT WINAPI VfwPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
748 {
749     VfwPinImpl *This = (VfwPinImpl *)iface;
750
751     TRACE("%s %p\n", debugstr_guid(riid), ppv);
752
753     *ppv = NULL;
754     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IPin))
755         *ppv = This;
756     else if (IsEqualIID(riid, &IID_IKsPropertySet))
757         *ppv = &(This->KSP_VT);
758     else if (IsEqualIID(riid, &IID_IAMStreamConfig))
759         return IUnknown_QueryInterface((IUnknown *)This->parent, riid, ppv);
760
761     if (*ppv)
762     {
763         IUnknown_AddRef((IUnknown *)(*ppv));
764         return S_OK;
765     }
766
767     FIXME("No interface for %s!\n", debugstr_guid(riid));
768     return E_NOINTERFACE;
769 }
770
771 static ULONG WINAPI
772 VfwPin_Release(IPin * iface)
773 {
774    VfwPinImpl *This = (VfwPinImpl *)iface;
775    ULONG refCount = InterlockedDecrement(&This->pin.pin.refCount);
776
777    TRACE("() -> new refcount: %u\n", refCount);
778
779    if (!refCount)
780    {
781       CoTaskMemFree(This);
782       ObjectRefCount(FALSE);
783    }
784    return refCount;
785 }
786
787 static HRESULT WINAPI
788 VfwPin_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum)
789 {
790     AM_MEDIA_TYPE *pmt;
791     HRESULT hr;
792
793     VfwPinImpl *This = (VfwPinImpl *)iface;
794     hr = qcap_driver_get_format(This->driver_info, &pmt);
795     if (SUCCEEDED(hr))
796         hr = BasePinImpl_EnumMediaTypes(iface, ppEnum);
797     TRACE("%p -- %x\n", This, hr);
798     DeleteMediaType(pmt);
799
800     return hr;
801 }
802
803 static HRESULT WINAPI
804 VfwPin_QueryInternalConnections(IPin * iface, IPin ** apPin, ULONG * cPin)
805 {
806     TRACE("(%p)->(%p, %p)\n", iface, apPin, cPin);
807     return E_NOTIMPL;
808 }
809
810 static const IPinVtbl VfwPin_Vtbl =
811 {
812     VfwPin_QueryInterface,
813     BasePinImpl_AddRef,
814     VfwPin_Release,
815     BaseOutputPinImpl_Connect,
816     BaseOutputPinImpl_ReceiveConnection,
817     BaseOutputPinImpl_Disconnect,
818     BasePinImpl_ConnectedTo,
819     BasePinImpl_ConnectionMediaType,
820     BasePinImpl_QueryPinInfo,
821     BasePinImpl_QueryDirection,
822     BasePinImpl_QueryId,
823     BasePinImpl_QueryAccept,
824     VfwPin_EnumMediaTypes,
825     VfwPin_QueryInternalConnections,
826     BaseOutputPinImpl_EndOfStream,
827     BaseOutputPinImpl_BeginFlush,
828     BaseOutputPinImpl_EndFlush,
829     BasePinImpl_NewSegment
830 };