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