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(&pVfwCapture->filter.IBaseFilter_iface,
 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 = InterlockedDecrement(&This->filter.refCount);
 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         BaseFilter_Destroy(&This->filter);
 229         CoTaskMemFree(This);
 230         ObjectRefCount(FALSE);
 231     }
 232     return refCount;
 233 }
 234
 235 /** IMediaFilter methods **/
 236
 237 static HRESULT WINAPI VfwCapture_Stop(IBaseFilter * iface)
 238 {
 239     VfwCapture *This = (VfwCapture *)iface;
 240
 241     TRACE("()\n");
 242     return qcap_driver_stop(This->driver_info, &This->filter.state);
 243 }
 244
 245 static HRESULT WINAPI VfwCapture_Pause(IBaseFilter * iface)
 246 {
 247     VfwCapture *This = (VfwCapture *)iface;
 248
 249     TRACE("()\n");
 250     return qcap_driver_pause(This->driver_info, &This->filter.state);
 251 }
 252
 253 static HRESULT WINAPI VfwCapture_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
 254 {
 255     VfwCapture *This = (VfwCapture *)iface;
 256     TRACE("(%x%08x)\n", (ULONG)(tStart >> 32), (ULONG)tStart);
 257     return qcap_driver_run(This->driver_info, &This->filter.state);
 258 }
 259
 260 /** IBaseFilter methods **/
 261 static HRESULT WINAPI VfwCapture_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
 262 {
 263     FIXME("(%s, %p) - stub\n", debugstr_w(Id), ppPin);
 264     return E_NOTIMPL;
 265 }
 266
 267 static const IBaseFilterVtbl VfwCapture_Vtbl =
 268 {
 269     VfwCapture_QueryInterface,
 270     BaseFilterImpl_AddRef,
 271     VfwCapture_Release,
 272     BaseFilterImpl_GetClassID,
 273     VfwCapture_Stop,
 274     VfwCapture_Pause,
 275     VfwCapture_Run,
 276     BaseFilterImpl_GetState,
 277     BaseFilterImpl_SetSyncSource,
 278     BaseFilterImpl_GetSyncSource,
 279     BaseFilterImpl_EnumPins,
 280     VfwCapture_FindPin,
 281     BaseFilterImpl_QueryFilterInfo,
 282     BaseFilterImpl_JoinFilterGraph,
 283     BaseFilterImpl_QueryVendorInfo
 284 };
 285
 286 /* AMStreamConfig interface, we only need to implement {G,S}etFormat */
 287 static HRESULT WINAPI
 288 AMStreamConfig_QueryInterface( IAMStreamConfig * iface, REFIID riid, LPVOID * ppv )
 289 {
 290     VfwCapture *This = impl_from_IAMStreamConfig(iface);
 291
 292     TRACE("%p --> %s\n", This, debugstr_guid(riid));
 293
 294     if (IsEqualIID(riid, &IID_IUnknown) ||
 295         IsEqualIID(riid, &IID_IAMStreamConfig))
 296     {
 297         IAMStreamConfig_AddRef(iface);
 298         *ppv = iface;
 299         return S_OK;
 300     }
 301
 302     FIXME("No interface for iid %s\n", debugstr_guid(riid));
 303     return E_NOINTERFACE;
 304 }
 305
 306 static ULONG WINAPI AMStreamConfig_AddRef( IAMStreamConfig * iface )
 307 {
 308     VfwCapture *This = impl_from_IAMStreamConfig(iface);
 309
 310     TRACE("%p --> Forwarding to VfwCapture (%p)\n", iface, This);
 311     return IUnknown_AddRef((IUnknown *)This);
 312 }
 313
 314 static ULONG WINAPI AMStreamConfig_Release( IAMStreamConfig * iface )
 315 {
 316     VfwCapture *This = impl_from_IAMStreamConfig(iface);
 317
 318     TRACE("%p --> Forwarding to VfwCapture (%p)\n", iface, This);
 319     return IUnknown_Release((IUnknown *)This);
 320 }
 321
 322 static HRESULT WINAPI
 323 AMStreamConfig_SetFormat(IAMStreamConfig *iface, AM_MEDIA_TYPE *pmt)
 324 {
 325     HRESULT hr;
 326     VfwCapture *This = impl_from_IAMStreamConfig(iface);
 327     BasePin *pin;
 328
 329     TRACE("(%p): %p->%p\n", iface, pmt, pmt ? pmt->pbFormat : NULL);
 330
 331     if (This->filter.state != State_Stopped)
 332     {
 333         TRACE("Returning not stopped error\n");
 334         return VFW_E_NOT_STOPPED;
 335     }
 336
 337     if (!pmt)
 338     {
 339         TRACE("pmt is NULL\n");
 340         return E_POINTER;
 341     }
 342
 343     dump_AM_MEDIA_TYPE(pmt);
 344
 345     pin = (BasePin *)This->pOutputPin;
 346     if (pin->pConnectedTo != NULL)
 347     {
 348         hr = IPin_QueryAccept(pin->pConnectedTo, pmt);
 349         TRACE("Would accept: %d\n", hr);
 350         if (hr == S_FALSE)
 351             return VFW_E_INVALIDMEDIATYPE;
 352     }
 353
 354     hr = qcap_driver_set_format(This->driver_info, pmt);
 355     if (SUCCEEDED(hr) && This->filter.filterInfo.pGraph && pin->pConnectedTo )
 356     {
 357         hr = IFilterGraph_Reconnect(This->filter.filterInfo.pGraph, This->pOutputPin);
 358         if (SUCCEEDED(hr))
 359             TRACE("Reconnection completed, with new media format..\n");
 360     }
 361     TRACE("Returning: %d\n", hr);
 362     return hr;
 363 }
 364
 365 static HRESULT WINAPI
 366 AMStreamConfig_GetFormat( IAMStreamConfig *iface, AM_MEDIA_TYPE **pmt )
 367 {
 368     VfwCapture *This = impl_from_IAMStreamConfig(iface);
 369
 370     TRACE("%p -> (%p)\n", iface, pmt);
 371     return qcap_driver_get_format(This->driver_info, pmt);
 372 }
 373
 374 static HRESULT WINAPI
 375 AMStreamConfig_GetNumberOfCapabilities( IAMStreamConfig *iface, int *piCount,
 376                                         int *piSize )
 377 {
 378     FIXME("%p: %p %p - stub, intentional\n", iface, piCount, piSize);
 379     return E_NOTIMPL; /* Not implemented for this interface */
 380 }
 381
 382 static HRESULT WINAPI
 383 AMStreamConfig_GetStreamCaps( IAMStreamConfig *iface, int iIndex,
 384                               AM_MEDIA_TYPE **pmt, BYTE *pSCC )
 385 {
 386     FIXME("%p: %d %p %p - stub, intentional\n", iface, iIndex, pmt, pSCC);
 387     return E_NOTIMPL; /* Not implemented for this interface */
 388 }
 389
 390 static const IAMStreamConfigVtbl IAMStreamConfig_VTable =
 391 {
 392     AMStreamConfig_QueryInterface,
 393     AMStreamConfig_AddRef,
 394     AMStreamConfig_Release,
 395     AMStreamConfig_SetFormat,
 396     AMStreamConfig_GetFormat,
 397     AMStreamConfig_GetNumberOfCapabilities,
 398     AMStreamConfig_GetStreamCaps
 399 };
 400
 401 static HRESULT WINAPI
 402 AMVideoProcAmp_QueryInterface( IAMVideoProcAmp * iface, REFIID riid,
 403                                LPVOID * ppv )
 404 {
 405     if (IsEqualIID(riid, &IID_IUnknown) ||
 406         IsEqualIID(riid, &IID_IAMVideoProcAmp))
 407     {
 408         *ppv = iface;
 409         IAMVideoProcAmp_AddRef( iface );
 410         return S_OK;
 411     }
 412
 413     FIXME("No interface for iid %s\n", debugstr_guid(riid));
 414     return E_NOINTERFACE;
 415 }
 416
 417 static ULONG WINAPI AMVideoProcAmp_AddRef(IAMVideoProcAmp * iface)
 418 {
 419     VfwCapture *This = impl_from_IAMVideoProcAmp(iface);
 420
 421     return IUnknown_AddRef((IUnknown *)This);
 422 }
 423
 424 static ULONG WINAPI AMVideoProcAmp_Release(IAMVideoProcAmp * iface)
 425 {
 426     VfwCapture *This = impl_from_IAMVideoProcAmp(iface);
 427
 428     return IUnknown_Release((IUnknown *)This);
 429 }
 430
 431 static HRESULT WINAPI
 432 AMVideoProcAmp_GetRange( IAMVideoProcAmp * iface, LONG Property, LONG *pMin,
 433         LONG *pMax, LONG *pSteppingDelta, LONG *pDefault, LONG *pCapsFlags )
 434 {
 435     VfwCapture *This = impl_from_IAMVideoProcAmp(iface);
 436
 437     return qcap_driver_get_prop_range( This->driver_info, Property, pMin, pMax,
 438                    pSteppingDelta, pDefault, pCapsFlags );
 439 }
 440
 441 static HRESULT WINAPI
 442 AMVideoProcAmp_Set( IAMVideoProcAmp * iface, LONG Property, LONG lValue,
 443                     LONG Flags )
 444 {
 445     VfwCapture *This = impl_from_IAMVideoProcAmp(iface);
 446
 447     return qcap_driver_set_prop(This->driver_info, Property, lValue, Flags);
 448 }
 449
 450 static HRESULT WINAPI
 451 AMVideoProcAmp_Get( IAMVideoProcAmp * iface, LONG Property, LONG *lValue,
 452                     LONG *Flags )
 453 {
 454     VfwCapture *This = impl_from_IAMVideoProcAmp(iface);
 455
 456     return qcap_driver_get_prop(This->driver_info, Property, lValue, Flags);
 457 }
 458
 459 static const IAMVideoProcAmpVtbl IAMVideoProcAmp_VTable =
 460 {
 461     AMVideoProcAmp_QueryInterface,
 462     AMVideoProcAmp_AddRef,
 463     AMVideoProcAmp_Release,
 464     AMVideoProcAmp_GetRange,
 465     AMVideoProcAmp_Set,
 466     AMVideoProcAmp_Get,
 467 };
 468
 469 static HRESULT WINAPI
 470 PPB_QueryInterface( IPersistPropertyBag * iface, REFIID riid, LPVOID * ppv )
 471 {
 472     if (IsEqualIID(riid, &IID_IUnknown) ||
 473         IsEqualIID(riid, &IID_IPersist) ||
 474         IsEqualIID(riid, &IID_IPersistPropertyBag))
 475     {
 476         IPersistPropertyBag_AddRef(iface);
 477         *ppv = iface;
 478         return S_OK;
 479     }
 480     if (IsEqualIID(riid, &IID_IBaseFilter))
 481     {
 482         /* FIXME: native devenum asks for IBaseFilter, should we return it? */
 483         IPersistPropertyBag_AddRef(iface);
 484         *ppv = iface;
 485         return S_OK;
 486     }
 487
 488     FIXME("No interface for iid %s\n", debugstr_guid(riid));
 489     return E_NOINTERFACE;
 490 }
 491
 492 static ULONG WINAPI PPB_AddRef(IPersistPropertyBag * iface)
 493 {
 494     VfwCapture *This = impl_from_IPersistPropertyBag(iface);
 495
 496     TRACE("%p --> Forwarding to VfwCapture (%p)\n", iface, This);
 497
 498     return IUnknown_AddRef((IUnknown *)This);
 499 }
 500
 501 static ULONG WINAPI PPB_Release(IPersistPropertyBag * iface)
 502 {
 503     VfwCapture *This = impl_from_IPersistPropertyBag(iface);
 504
 505     TRACE("%p --> Forwarding to VfwCapture (%p)\n", iface, This);
 506
 507     return IUnknown_Release((IUnknown *)This);
 508 }
 509
 510 static HRESULT WINAPI
 511 PPB_GetClassID( IPersistPropertyBag * iface, CLSID * pClassID )
 512 {
 513     VfwCapture *This = impl_from_IPersistPropertyBag(iface);
 514
 515     FIXME("%p - stub\n", This);
 516
 517     return E_NOTIMPL;
 518 }
 519
 520 static HRESULT WINAPI PPB_InitNew(IPersistPropertyBag * iface)
 521 {
 522     VfwCapture *This = impl_from_IPersistPropertyBag(iface);
 523
 524     FIXME("%p - stub\n", This);
 525
 526     return E_NOTIMPL;
 527 }
 528
 529 static HRESULT WINAPI
 530 PPB_Load( IPersistPropertyBag * iface, IPropertyBag *pPropBag,
 531           IErrorLog *pErrorLog )
 532 {
 533     VfwCapture *This = impl_from_IPersistPropertyBag(iface);
 534     HRESULT hr;
 535     VARIANT var;
 536     const OLECHAR VFWIndex[] = {'V','F','W','I','n','d','e','x',0};
 537
 538     TRACE("%p/%p-> (%p, %p)\n", iface, This, pPropBag, pErrorLog);
 539
 540     V_VT(&var) = VT_I4;
 541     hr = IPropertyBag_Read(pPropBag, VFWIndex, &var, pErrorLog);
 542
 543     if (SUCCEEDED(hr))
 544     {
 545         VfwPinImpl *pin;
 546
 547         This->driver_info = qcap_driver_init( This->pOutputPin,
 548                var.__VARIANT_NAME_1.__VARIANT_NAME_2.__VARIANT_NAME_3.ulVal );
 549         if (This->driver_info)
 550         {
 551             pin = (VfwPinImpl *)This->pOutputPin;
 552             pin->driver_info = This->driver_info;
 553             pin->parent = This;
 554             This->init = TRUE;
 555             hr = S_OK;
 556         }
 557         else
 558             hr = E_FAIL;
 559     }
 560
 561     return hr;
 562 }
 563
 564 static HRESULT WINAPI
 565 PPB_Save( IPersistPropertyBag * iface, IPropertyBag *pPropBag,
 566           BOOL fClearDirty, BOOL fSaveAllProperties )
 567 {
 568     VfwCapture *This = impl_from_IPersistPropertyBag(iface);
 569     FIXME("%p - stub\n", This);
 570     return E_NOTIMPL;
 571 }
 572
 573 static const IPersistPropertyBagVtbl IPersistPropertyBag_VTable =
 574 {
 575     PPB_QueryInterface,
 576     PPB_AddRef,
 577     PPB_Release,
 578     PPB_GetClassID,
 579     PPB_InitNew,
 580     PPB_Load,
 581     PPB_Save
 582 };
 583
 584 /* IKsPropertySet interface */
 585 static HRESULT WINAPI
 586 KSP_QueryInterface( IKsPropertySet * iface, REFIID riid, LPVOID * ppv )
 587 {
 588     if (IsEqualIID(riid, &IID_IUnknown) ||
 589         IsEqualIID(riid, &IID_IKsPropertySet))
 590     {
 591         *ppv = iface;
 592         IKsPropertySet_AddRef( iface );
 593         return S_OK;
 594     }
 595
 596     FIXME("No interface for iid %s\n", debugstr_guid(riid));
 597     return E_NOINTERFACE;
 598 }
 599
 600 static ULONG WINAPI KSP_AddRef(IKsPropertySet * iface)
 601 {
 602     ICOM_THIS_MULTI(VfwPinImpl, KSP_VT, iface);
 603
 604     TRACE("%p --> Forwarding to VfwPin (%p)\n", iface, This);
 605
 606     return IUnknown_AddRef((IUnknown *)This);
 607 }
 608
 609 static ULONG WINAPI KSP_Release(IKsPropertySet * iface)
 610 {
 611     ICOM_THIS_MULTI(VfwPinImpl, KSP_VT, iface);
 612
 613     TRACE("%p --> Forwarding to VfwPin (%p)\n", iface, This);
 614
 615     return IUnknown_Release((IUnknown *)This);
 616 }
 617
 618 static HRESULT WINAPI
 619 KSP_Set( IKsPropertySet * iface, REFGUID guidPropSet, DWORD dwPropID,
 620          LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData,
 621          DWORD cbPropData )
 622 {
 623     FIXME("%p: stub\n", iface);
 624     return E_NOTIMPL;
 625 }
 626
 627 static HRESULT WINAPI
 628 KSP_Get( IKsPropertySet * iface, REFGUID guidPropSet, DWORD dwPropID,
 629          LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData,
 630          DWORD cbPropData, DWORD *pcbReturned )
 631 {
 632     LPGUID pGuid;
 633
 634     TRACE("()\n");
 635
 636     if (!IsEqualIID(guidPropSet, &AMPROPSETID_Pin))
 637         return E_PROP_SET_UNSUPPORTED;
 638     if (pPropData == NULL && pcbReturned == NULL)
 639         return E_POINTER;
 640     if (pcbReturned)
 641         *pcbReturned = sizeof(GUID);
 642     if (pPropData == NULL)
 643         return S_OK;
 644     if (cbPropData < sizeof(GUID))
 645         return E_UNEXPECTED;
 646     pGuid = pPropData;
 647     *pGuid = PIN_CATEGORY_PREVIEW;
 648     FIXME("() Not adding a pin with PIN_CATEGORY_CAPTURE\n");
 649     return S_OK;
 650 }
 651
 652 static HRESULT WINAPI
 653 KSP_QuerySupported( IKsPropertySet * iface, REFGUID guidPropSet,
 654                     DWORD dwPropID, DWORD *pTypeSupport )
 655 {
 656    FIXME("%p: stub\n", iface);
 657    return E_NOTIMPL;
 658 }
 659
 660 static const IKsPropertySetVtbl KSP_VTable =
 661 {
 662    KSP_QueryInterface,
 663    KSP_AddRef,
 664    KSP_Release,
 665    KSP_Set,
 666    KSP_Get,
 667    KSP_QuerySupported
 668 };
 669
 670 static HRESULT WINAPI VfwPin_GetMediaType(BasePin *iface, int iPosition, AM_MEDIA_TYPE *pmt)
 671 {
 672     VfwPinImpl *This = (VfwPinImpl *)iface;
 673     AM_MEDIA_TYPE *vfw_pmt;
 674     HRESULT hr;
 675
 676     if (iPosition < 0)
 677         return E_INVALIDARG;
 678     if (iPosition > 0)
 679         return VFW_S_NO_MORE_ITEMS;
 680
 681     hr = qcap_driver_get_format(This->driver_info, &vfw_pmt);
 682     if (SUCCEEDED(hr)) {
 683         CopyMediaType(pmt, vfw_pmt);
 684         DeleteMediaType(vfw_pmt);
 685     }
 686     return hr;
 687 }
 688
 689 static LONG WINAPI VfwPin_GetMediaTypeVersion(BasePin *iface)
 690 {
 691     return 1;
 692 }
 693
 694 static HRESULT WINAPI VfwPin_DecideBufferSize(BaseOutputPin *iface, IMemAllocator *pAlloc, ALLOCATOR_PROPERTIES *ppropInputRequest)
 695 {
 696     ALLOCATOR_PROPERTIES actual;
 697
 698     /* What we put here doesn't matter, the
 699        driver function should override it then commit */
 700     if (!ppropInputRequest->cBuffers)
 701         ppropInputRequest->cBuffers = 3;
 702     if (!ppropInputRequest->cbBuffer)
 703         ppropInputRequest->cbBuffer = 230400;
 704     if (!ppropInputRequest->cbAlign)
 705         ppropInputRequest->cbAlign = 1;
 706
 707     return IMemAllocator_SetProperties(pAlloc, ppropInputRequest, &actual);
 708 }
 709
 710 static const BaseOutputPinFuncTable output_BaseOutputFuncTable = {
 711     {
 712         NULL,
 713         BaseOutputPinImpl_AttemptConnection,
 714         VfwPin_GetMediaTypeVersion,
 715         VfwPin_GetMediaType
 716     },
 717     VfwPin_DecideBufferSize,
 718     BaseOutputPinImpl_DecideAllocator,
 719     BaseOutputPinImpl_BreakConnect
 720 };
 721
 722 static HRESULT
 723 VfwPin_Construct( IBaseFilter * pBaseFilter, LPCRITICAL_SECTION pCritSec,
 724                   IPin ** ppPin )
 725 {
 726     static const WCHAR wszOutputPinName[] = { 'O','u','t','p','u','t',0 };
 727     PIN_INFO piOutput;
 728     HRESULT hr;
 729
 730     *ppPin = NULL;
 731
 732     piOutput.dir = PINDIR_OUTPUT;
 733     piOutput.pFilter = pBaseFilter;
 734     lstrcpyW(piOutput.achName, wszOutputPinName);
 735
 736     hr = BaseOutputPin_Construct(&VfwPin_Vtbl, sizeof(VfwPinImpl), &piOutput, &output_BaseOutputFuncTable, pCritSec, ppPin);
 737
 738     if (SUCCEEDED(hr))
 739     {
 740         VfwPinImpl *pPinImpl = (VfwPinImpl*)*ppPin;
 741         pPinImpl->KSP_VT = &KSP_VTable;
 742         ObjectRefCount(TRUE);
 743     }
 744
 745     return hr;
 746 }
 747
 748 static HRESULT WINAPI VfwPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
 749 {
 750     VfwPinImpl *This = (VfwPinImpl *)iface;
 751
 752     TRACE("%s %p\n", debugstr_guid(riid), ppv);
 753
 754     *ppv = NULL;
 755     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IPin))
 756         *ppv = This;
 757     else if (IsEqualIID(riid, &IID_IKsPropertySet))
 758         *ppv = &(This->KSP_VT);
 759     else if (IsEqualIID(riid, &IID_IAMStreamConfig))
 760         return IUnknown_QueryInterface((IUnknown *)This->parent, riid, ppv);
 761
 762     if (*ppv)
 763     {
 764         IUnknown_AddRef((IUnknown *)(*ppv));
 765         return S_OK;
 766     }
 767
 768     FIXME("No interface for %s!\n", debugstr_guid(riid));
 769     return E_NOINTERFACE;
 770 }
 771
 772 static ULONG WINAPI
 773 VfwPin_Release(IPin * iface)
 774 {
 775    VfwPinImpl *This = (VfwPinImpl *)iface;
 776    ULONG refCount = InterlockedDecrement(&This->pin.pin.refCount);
 777
 778    TRACE("() -> new refcount: %u\n", refCount);
 779
 780    if (!refCount)
 781    {
 782       BaseOutputPin_Destroy(&This->pin);
 783       ObjectRefCount(FALSE);
 784    }
 785    return refCount;
 786 }
 787
 788 static HRESULT WINAPI
 789 VfwPin_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum)
 790 {
 791     AM_MEDIA_TYPE *pmt;
 792     HRESULT hr;
 793
 794     VfwPinImpl *This = (VfwPinImpl *)iface;
 795     hr = qcap_driver_get_format(This->driver_info, &pmt);
 796     if (SUCCEEDED(hr)) {
 797         hr = BasePinImpl_EnumMediaTypes(iface, ppEnum);
 798         DeleteMediaType(pmt);
 799     }
 800     TRACE("%p -- %x\n", This, hr);
 801     return hr;
 802 }
 803
 804 static HRESULT WINAPI
 805 VfwPin_QueryInternalConnections(IPin * iface, IPin ** apPin, ULONG * cPin)
 806 {
 807     TRACE("(%p)->(%p, %p)\n", iface, apPin, cPin);
 808     return E_NOTIMPL;
 809 }
 810
 811 static const IPinVtbl VfwPin_Vtbl =
 812 {
 813     VfwPin_QueryInterface,
 814     BasePinImpl_AddRef,
 815     VfwPin_Release,
 816     BaseOutputPinImpl_Connect,
 817     BaseOutputPinImpl_ReceiveConnection,
 818     BaseOutputPinImpl_Disconnect,
 819     BasePinImpl_ConnectedTo,
 820     BasePinImpl_ConnectionMediaType,
 821     BasePinImpl_QueryPinInfo,
 822     BasePinImpl_QueryDirection,
 823     BasePinImpl_QueryId,
 824     BasePinImpl_QueryAccept,
 825     VfwPin_EnumMediaTypes,
 826     VfwPin_QueryInternalConnections,
 827     BaseOutputPinImpl_EndOfStream,
 828     BaseOutputPinImpl_BeginFlush,
 829     BaseOutputPinImpl_EndFlush,
 830     BasePinImpl_NewSegment
 831 };