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 #include "qcap_private.h"
  22 #include "winternl.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  25
  26 static unixlib_handle_t v4l_handle;
  27
  28 #define V4L_CALL( func, params ) __wine_unix_call( v4l_handle, unix_ ## func, params )
  29
  30 struct vfw_capture
  31 {
  32     struct strmbase_filter filter;
  33     IAMStreamConfig IAMStreamConfig_iface;
  34     IAMVideoControl IAMVideoControl_iface;
  35     IAMVideoProcAmp IAMVideoProcAmp_iface;
  36     IAMFilterMiscFlags IAMFilterMiscFlags_iface;
  37     IPersistPropertyBag IPersistPropertyBag_iface;
  38     BOOL init;
  39
  40     struct strmbase_source source;
  41     IKsPropertySet IKsPropertySet_iface;
  42
  43     video_capture_device_t device;
  44
  45     /* FIXME: It would be nice to avoid duplicating this variable with strmbase.
  46      * However, synchronization is tricky; we need access to be protected by a
  47      * separate lock. */
  48     FILTER_STATE state;
  49     CONDITION_VARIABLE state_cv;
  50     CRITICAL_SECTION state_cs;
  51
  52     HANDLE thread;
  53 };
  54
  55 static inline struct vfw_capture *impl_from_strmbase_filter(struct strmbase_filter *iface)
  56 {
  57     return CONTAINING_RECORD(iface, struct vfw_capture, filter);
  58 }
  59
  60 static inline struct vfw_capture *impl_from_IAMStreamConfig(IAMStreamConfig *iface)
  61 {
  62     return CONTAINING_RECORD(iface, struct vfw_capture, IAMStreamConfig_iface);
  63 }
  64
  65 static inline struct vfw_capture *impl_from_IAMVideoControl(IAMVideoControl *iface)
  66 {
  67     return CONTAINING_RECORD(iface, struct vfw_capture, IAMVideoControl_iface);
  68 }
  69
  70 static inline struct vfw_capture *impl_from_IAMVideoProcAmp(IAMVideoProcAmp *iface)
  71 {
  72     return CONTAINING_RECORD(iface, struct vfw_capture, IAMVideoProcAmp_iface);
  73 }
  74
  75 static inline struct vfw_capture *impl_from_IAMFilterMiscFlags(IAMFilterMiscFlags *iface)
  76 {
  77     return CONTAINING_RECORD(iface, struct vfw_capture, IAMFilterMiscFlags_iface);
  78 }
  79
  80 static inline struct vfw_capture *impl_from_IPersistPropertyBag(IPersistPropertyBag *iface)
  81 {
  82     return CONTAINING_RECORD(iface, struct vfw_capture, IPersistPropertyBag_iface);
  83 }
  84
  85 static struct strmbase_pin *vfw_capture_get_pin(struct strmbase_filter *iface, unsigned int index)
  86 {
  87     struct vfw_capture *filter = impl_from_strmbase_filter(iface);
  88
  89     if (index >= 1)
  90         return NULL;
  91
  92     return &filter->source.pin;
  93 }
  94
  95 static void vfw_capture_destroy(struct strmbase_filter *iface)
  96 {
  97     struct vfw_capture *filter = impl_from_strmbase_filter(iface);
  98
  99     if (filter->init)
 100     {
 101         struct destroy_params params = { filter->device };
 102         V4L_CALL( destroy, &params );
 103     }
 104
 105     if (filter->source.pin.peer)
 106     {
 107         IPin_Disconnect(filter->source.pin.peer);
 108         IPin_Disconnect(&filter->source.pin.IPin_iface);
 109     }
 110     filter->state_cs.DebugInfo->Spare[0] = 0;
 111     DeleteCriticalSection(&filter->state_cs);
 112     strmbase_source_cleanup(&filter->source);
 113     strmbase_filter_cleanup(&filter->filter);
 114     free(filter);
 115 }
 116
 117 static HRESULT vfw_capture_query_interface(struct strmbase_filter *iface, REFIID iid, void **out)
 118 {
 119     struct vfw_capture *filter = impl_from_strmbase_filter(iface);
 120
 121     if (IsEqualGUID(iid, &IID_IPersistPropertyBag))
 122         *out = &filter->IPersistPropertyBag_iface;
 123     else if (IsEqualGUID(iid, &IID_IAMVideoControl))
 124         *out = &filter->IAMVideoControl_iface;
 125     else if (IsEqualGUID(iid, &IID_IAMVideoProcAmp))
 126         *out = &filter->IAMVideoProcAmp_iface;
 127     else if (IsEqualGUID(iid, &IID_IAMFilterMiscFlags))
 128         *out = &filter->IAMFilterMiscFlags_iface;
 129     else
 130         return E_NOINTERFACE;
 131
 132     IUnknown_AddRef((IUnknown *)*out);
 133     return S_OK;
 134 }
 135
 136 static unsigned int get_image_size(struct vfw_capture *filter)
 137 {
 138     const VIDEOINFOHEADER *format = (const VIDEOINFOHEADER *)filter->source.pin.mt.pbFormat;
 139
 140     return format->bmiHeader.biWidth * format->bmiHeader.biHeight * format->bmiHeader.biBitCount / 8;
 141 }
 142
 143 static DWORD WINAPI stream_thread(void *arg)
 144 {
 145     struct vfw_capture *filter = arg;
 146     const unsigned int image_size = get_image_size(filter);
 147     struct read_frame_params params;
 148
 149     for (;;)
 150     {
 151         IMediaSample *sample;
 152         HRESULT hr;
 153         BYTE *data;
 154
 155         EnterCriticalSection(&filter->state_cs);
 156
 157         while (filter->state == State_Paused)
 158             SleepConditionVariableCS(&filter->state_cv, &filter->state_cs, INFINITE);
 159
 160         if (filter->state == State_Stopped)
 161         {
 162             LeaveCriticalSection(&filter->state_cs);
 163             break;
 164         }
 165
 166         LeaveCriticalSection(&filter->state_cs);
 167
 168         if (FAILED(hr = IMemAllocator_GetBuffer(filter->source.pAllocator, &sample, NULL, NULL, 0)))
 169         {
 170             ERR("Failed to get sample, hr %#x.\n", hr);
 171             break;
 172         }
 173
 174         IMediaSample_SetActualDataLength(sample, image_size);
 175         IMediaSample_GetPointer(sample, &data);
 176
 177         params.device = filter->device;
 178         params.data = data;
 179         if (!V4L_CALL( read_frame, &params ))
 180         {
 181             IMediaSample_Release(sample);
 182             break;
 183         }
 184
 185         hr = IMemInputPin_Receive(filter->source.pMemInputPin, sample);
 186         IMediaSample_Release(sample);
 187         if (FAILED(hr))
 188         {
 189             ERR("IMemInputPin::Receive() returned %#x.\n", hr);
 190             break;
 191         }
 192     }
 193
 194     return 0;
 195 }
 196
 197 static HRESULT vfw_capture_init_stream(struct strmbase_filter *iface)
 198 {
 199     struct vfw_capture *filter = impl_from_strmbase_filter(iface);
 200     HRESULT hr;
 201
 202     if (!filter->source.pin.peer)
 203         return S_OK;
 204
 205     if (FAILED(hr = IMemAllocator_Commit(filter->source.pAllocator)))
 206         ERR("Failed to commit allocator, hr %#x.\n", hr);
 207
 208     EnterCriticalSection(&filter->state_cs);
 209     filter->state = State_Paused;
 210     LeaveCriticalSection(&filter->state_cs);
 211
 212     filter->thread = CreateThread(NULL, 0, stream_thread, filter, 0, NULL);
 213
 214     return S_OK;
 215 }
 216
 217 static HRESULT vfw_capture_start_stream(struct strmbase_filter *iface, REFERENCE_TIME time)
 218 {
 219     struct vfw_capture *filter = impl_from_strmbase_filter(iface);
 220
 221     if (!filter->source.pin.peer)
 222         return S_OK;
 223
 224     EnterCriticalSection(&filter->state_cs);
 225     filter->state = State_Running;
 226     LeaveCriticalSection(&filter->state_cs);
 227     WakeConditionVariable(&filter->state_cv);
 228     return S_OK;
 229 }
 230
 231 static HRESULT vfw_capture_stop_stream(struct strmbase_filter *iface)
 232 {
 233     struct vfw_capture *filter = impl_from_strmbase_filter(iface);
 234
 235     if (!filter->source.pin.peer)
 236         return S_OK;
 237
 238     EnterCriticalSection(&filter->state_cs);
 239     filter->state = State_Paused;
 240     LeaveCriticalSection(&filter->state_cs);
 241     return S_OK;
 242 }
 243
 244 static HRESULT vfw_capture_cleanup_stream(struct strmbase_filter *iface)
 245 {
 246     struct vfw_capture *filter = impl_from_strmbase_filter(iface);
 247     HRESULT hr;
 248
 249     if (!filter->source.pin.peer)
 250         return S_OK;
 251
 252     EnterCriticalSection(&filter->state_cs);
 253     filter->state = State_Stopped;
 254     LeaveCriticalSection(&filter->state_cs);
 255     WakeConditionVariable(&filter->state_cv);
 256
 257     WaitForSingleObject(filter->thread, INFINITE);
 258     CloseHandle(filter->thread);
 259     filter->thread = NULL;
 260
 261     hr = IMemAllocator_Decommit(filter->source.pAllocator);
 262     if (hr != S_OK && hr != VFW_E_NOT_COMMITTED)
 263         ERR("Failed to decommit allocator, hr %#x.\n", hr);
 264
 265     return S_OK;
 266 }
 267
 268 static HRESULT vfw_capture_wait_state(struct strmbase_filter *iface, DWORD timeout)
 269 {
 270     struct vfw_capture *filter = impl_from_strmbase_filter(iface);
 271
 272     if (filter->source.pin.peer && filter->filter.state == State_Paused)
 273         return VFW_S_CANT_CUE;
 274     return S_OK;
 275 }
 276
 277 static const struct strmbase_filter_ops filter_ops =
 278 {
 279     .filter_get_pin = vfw_capture_get_pin,
 280     .filter_destroy = vfw_capture_destroy,
 281     .filter_query_interface = vfw_capture_query_interface,
 282     .filter_init_stream = vfw_capture_init_stream,
 283     .filter_start_stream = vfw_capture_start_stream,
 284     .filter_stop_stream = vfw_capture_stop_stream,
 285     .filter_cleanup_stream = vfw_capture_cleanup_stream,
 286     .filter_wait_state = vfw_capture_wait_state,
 287 };
 288
 289 static HRESULT WINAPI AMStreamConfig_QueryInterface(IAMStreamConfig *iface, REFIID iid, void **out)
 290 {
 291     struct vfw_capture *filter = impl_from_IAMStreamConfig(iface);
 292     return IPin_QueryInterface(&filter->source.pin.IPin_iface, iid, out);
 293 }
 294
 295 static ULONG WINAPI AMStreamConfig_AddRef(IAMStreamConfig *iface)
 296 {
 297     struct vfw_capture *filter = impl_from_IAMStreamConfig(iface);
 298     return IPin_AddRef(&filter->source.pin.IPin_iface);
 299 }
 300
 301 static ULONG WINAPI AMStreamConfig_Release(IAMStreamConfig *iface)
 302 {
 303     struct vfw_capture *filter = impl_from_IAMStreamConfig(iface);
 304     return IPin_Release(&filter->source.pin.IPin_iface);
 305 }
 306
 307 static HRESULT WINAPI
 308 AMStreamConfig_SetFormat(IAMStreamConfig *iface, AM_MEDIA_TYPE *pmt)
 309 {
 310     struct vfw_capture *This = impl_from_IAMStreamConfig(iface);
 311     struct set_format_params params;
 312     HRESULT hr;
 313
 314     TRACE("filter %p, mt %p.\n", This, pmt);
 315     strmbase_dump_media_type(pmt);
 316
 317     if (This->filter.state != State_Stopped)
 318     {
 319         TRACE("Returning not stopped error\n");
 320         return VFW_E_NOT_STOPPED;
 321     }
 322
 323     if (!pmt)
 324     {
 325         TRACE("pmt is NULL\n");
 326         return E_POINTER;
 327     }
 328
 329     if (!IsEqualGUID(&pmt->majortype, &MEDIATYPE_Video))
 330         return E_FAIL;
 331
 332     if (This->source.pin.peer)
 333     {
 334         hr = IPin_QueryAccept(This->source.pin.peer, pmt);
 335         TRACE("Would accept: %d\n", hr);
 336         if (hr == S_FALSE)
 337             return VFW_E_INVALIDMEDIATYPE;
 338     }
 339
 340     params.device = This->device;
 341     params.mt = pmt;
 342     hr = V4L_CALL( set_format, &params );
 343     if (SUCCEEDED(hr) && This->filter.graph && This->source.pin.peer)
 344     {
 345         hr = IFilterGraph_Reconnect(This->filter.graph, &This->source.pin.IPin_iface);
 346         if (SUCCEEDED(hr))
 347             TRACE("Reconnection completed, with new media format..\n");
 348     }
 349     TRACE("Returning: %d\n", hr);
 350     return hr;
 351 }
 352
 353 static HRESULT WINAPI AMStreamConfig_GetFormat(IAMStreamConfig *iface, AM_MEDIA_TYPE **mt)
 354 {
 355     struct vfw_capture *filter = impl_from_IAMStreamConfig(iface);
 356     VIDEOINFOHEADER *format;
 357     HRESULT hr;
 358
 359     TRACE("filter %p, mt %p.\n", filter, mt);
 360
 361     if (!(*mt = CoTaskMemAlloc(sizeof(**mt))))
 362         return E_OUTOFMEMORY;
 363
 364     EnterCriticalSection(&filter->filter.filter_cs);
 365
 366     if (filter->source.pin.peer)
 367     {
 368         hr = CopyMediaType(*mt, &filter->source.pin.mt);
 369     }
 370     else
 371     {
 372         if ((format = CoTaskMemAlloc(sizeof(VIDEOINFOHEADER))))
 373         {
 374             struct get_format_params params = { filter->device, *mt, format };
 375             V4L_CALL( get_format, &params );
 376             (*mt)->cbFormat = sizeof(VIDEOINFOHEADER);
 377             (*mt)->pbFormat = (BYTE *)format;
 378             hr = S_OK;
 379         }
 380         else
 381         {
 382             hr = E_OUTOFMEMORY;
 383         }
 384     }
 385
 386     LeaveCriticalSection(&filter->filter.filter_cs);
 387
 388     if (SUCCEEDED(hr))
 389         strmbase_dump_media_type(*mt);
 390     else
 391         CoTaskMemFree(*mt);
 392     return hr;
 393 }
 394
 395 static HRESULT WINAPI AMStreamConfig_GetNumberOfCapabilities(IAMStreamConfig *iface,
 396         int *count, int *size)
 397 {
 398     struct vfw_capture *filter = impl_from_IAMStreamConfig(iface);
 399     struct get_caps_count_params params = { filter->device, count };
 400
 401     TRACE("filter %p, count %p, size %p.\n", filter, count, size);
 402
 403     if (!count || !size)
 404         return E_POINTER;
 405
 406     V4L_CALL( get_caps_count, &params );
 407     *size = sizeof(VIDEO_STREAM_CONFIG_CAPS);
 408
 409     return S_OK;
 410 }
 411
 412 static HRESULT WINAPI AMStreamConfig_GetStreamCaps(IAMStreamConfig *iface,
 413         int index, AM_MEDIA_TYPE **pmt, BYTE *vscc)
 414 {
 415     struct vfw_capture *filter = impl_from_IAMStreamConfig(iface);
 416     VIDEOINFOHEADER *format;
 417     AM_MEDIA_TYPE *mt;
 418     int count;
 419     struct get_caps_count_params count_params = { filter->device, &count };
 420     struct get_caps_params caps_params;
 421
 422     TRACE("filter %p, index %d, pmt %p, vscc %p.\n", filter, index, pmt, vscc);
 423
 424     V4L_CALL( get_caps_count, &count_params );
 425     if (index > count)
 426         return S_FALSE;
 427
 428     if (!(mt = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE))))
 429         return E_OUTOFMEMORY;
 430
 431     if (!(format = CoTaskMemAlloc(sizeof(VIDEOINFOHEADER))))
 432     {
 433         CoTaskMemFree(mt);
 434         return E_OUTOFMEMORY;
 435     }
 436
 437     caps_params.device = filter->device;
 438     caps_params.index  = index;
 439     caps_params.mt     = mt;
 440     caps_params.format = format;
 441     caps_params.caps   = (VIDEO_STREAM_CONFIG_CAPS *)vscc;
 442     V4L_CALL( get_caps, &caps_params );
 443     mt->cbFormat = sizeof(VIDEOINFOHEADER);
 444     mt->pbFormat = (BYTE *)format;
 445     *pmt = mt;
 446     return S_OK;
 447 }
 448
 449 static const IAMStreamConfigVtbl IAMStreamConfig_VTable =
 450 {
 451     AMStreamConfig_QueryInterface,
 452     AMStreamConfig_AddRef,
 453     AMStreamConfig_Release,
 454     AMStreamConfig_SetFormat,
 455     AMStreamConfig_GetFormat,
 456     AMStreamConfig_GetNumberOfCapabilities,
 457     AMStreamConfig_GetStreamCaps
 458 };
 459
 460 static HRESULT WINAPI AMVideoProcAmp_QueryInterface(IAMVideoProcAmp *iface, REFIID iid, void **out)
 461 {
 462     struct vfw_capture *filter = impl_from_IAMVideoProcAmp(iface);
 463     return IUnknown_QueryInterface(filter->filter.outer_unk, iid, out);
 464 }
 465
 466 static ULONG WINAPI AMVideoProcAmp_AddRef(IAMVideoProcAmp * iface)
 467 {
 468     struct vfw_capture *filter = impl_from_IAMVideoProcAmp(iface);
 469     return IUnknown_AddRef(filter->filter.outer_unk);
 470 }
 471
 472 static ULONG WINAPI AMVideoProcAmp_Release(IAMVideoProcAmp * iface)
 473 {
 474     struct vfw_capture *filter = impl_from_IAMVideoProcAmp(iface);
 475     return IUnknown_Release(filter->filter.outer_unk);
 476 }
 477
 478 static HRESULT WINAPI AMVideoProcAmp_GetRange(IAMVideoProcAmp *iface, LONG property,
 479         LONG *min, LONG *max, LONG *step, LONG *default_value, LONG *flags)
 480 {
 481     struct vfw_capture *filter = impl_from_IAMVideoProcAmp(iface);
 482     struct get_prop_range_params params = { filter->device, property, min, max, step, default_value, flags };
 483
 484     TRACE("filter %p, property %#x, min %p, max %p, step %p, default_value %p, flags %p.\n",
 485             filter, property, min, max, step, default_value, flags);
 486
 487     return V4L_CALL( get_prop_range, &params );
 488 }
 489
 490 static HRESULT WINAPI AMVideoProcAmp_Set(IAMVideoProcAmp *iface, LONG property,
 491         LONG value, LONG flags)
 492 {
 493     struct vfw_capture *filter = impl_from_IAMVideoProcAmp(iface);
 494     struct set_prop_params params = { filter->device, property, value, flags };
 495
 496     TRACE("filter %p, property %#x, value %d, flags %#x.\n", filter, property, value, flags);
 497
 498     return V4L_CALL( set_prop, &params );
 499 }
 500
 501 static HRESULT WINAPI AMVideoProcAmp_Get(IAMVideoProcAmp *iface, LONG property,
 502         LONG *value, LONG *flags)
 503 {
 504     struct vfw_capture *filter = impl_from_IAMVideoProcAmp(iface);
 505     struct get_prop_params params = { filter->device, property, value, flags };
 506
 507     TRACE("filter %p, property %#x, value %p, flags %p.\n", filter, property, value, flags);
 508
 509     return V4L_CALL( get_prop, &params );
 510 }
 511
 512 static const IAMVideoProcAmpVtbl IAMVideoProcAmp_VTable =
 513 {
 514     AMVideoProcAmp_QueryInterface,
 515     AMVideoProcAmp_AddRef,
 516     AMVideoProcAmp_Release,
 517     AMVideoProcAmp_GetRange,
 518     AMVideoProcAmp_Set,
 519     AMVideoProcAmp_Get,
 520 };
 521
 522 static HRESULT WINAPI PPB_QueryInterface(IPersistPropertyBag *iface, REFIID iid, void **out)
 523 {
 524     struct vfw_capture *filter = impl_from_IPersistPropertyBag(iface);
 525     return IUnknown_QueryInterface(filter->filter.outer_unk, iid, out);
 526 }
 527
 528 static ULONG WINAPI PPB_AddRef(IPersistPropertyBag * iface)
 529 {
 530     struct vfw_capture *filter = impl_from_IPersistPropertyBag(iface);
 531     return IUnknown_AddRef(filter->filter.outer_unk);
 532 }
 533
 534 static ULONG WINAPI PPB_Release(IPersistPropertyBag * iface)
 535 {
 536     struct vfw_capture *filter = impl_from_IPersistPropertyBag(iface);
 537     return IUnknown_Release(filter->filter.outer_unk);
 538 }
 539
 540 static HRESULT WINAPI
 541 PPB_GetClassID( IPersistPropertyBag * iface, CLSID * pClassID )
 542 {
 543     struct vfw_capture *This = impl_from_IPersistPropertyBag(iface);
 544
 545     FIXME("%p - stub\n", This);
 546
 547     return E_NOTIMPL;
 548 }
 549
 550 static HRESULT WINAPI PPB_InitNew(IPersistPropertyBag * iface)
 551 {
 552     struct vfw_capture *This = impl_from_IPersistPropertyBag(iface);
 553
 554     FIXME("%p - stub\n", This);
 555
 556     return E_NOTIMPL;
 557 }
 558
 559 static HRESULT WINAPI PPB_Load(IPersistPropertyBag *iface, IPropertyBag *bag, IErrorLog *error_log)
 560 {
 561     struct vfw_capture *filter = impl_from_IPersistPropertyBag(iface);
 562     struct create_params params;
 563     HRESULT hr;
 564     VARIANT var;
 565
 566     TRACE("filter %p, bag %p, error_log %p.\n", filter, bag, error_log);
 567
 568     V_VT(&var) = VT_I4;
 569     if (FAILED(hr = IPropertyBag_Read(bag, L"VFWIndex", &var, error_log)))
 570         return hr;
 571
 572     params.index = V_I4(&var);
 573     params.device = &filter->device;
 574     hr = V4L_CALL( create, &params );
 575
 576     if (SUCCEEDED(hr)) filter->init = TRUE;
 577     return hr;
 578 }
 579
 580 static HRESULT WINAPI
 581 PPB_Save( IPersistPropertyBag * iface, IPropertyBag *pPropBag,
 582           BOOL fClearDirty, BOOL fSaveAllProperties )
 583 {
 584     struct vfw_capture *This = impl_from_IPersistPropertyBag(iface);
 585     FIXME("%p - stub\n", This);
 586     return E_NOTIMPL;
 587 }
 588
 589 static const IPersistPropertyBagVtbl IPersistPropertyBag_VTable =
 590 {
 591     PPB_QueryInterface,
 592     PPB_AddRef,
 593     PPB_Release,
 594     PPB_GetClassID,
 595     PPB_InitNew,
 596     PPB_Load,
 597     PPB_Save
 598 };
 599
 600 /* IKsPropertySet interface */
 601 static inline struct vfw_capture *impl_from_IKsPropertySet(IKsPropertySet *iface)
 602 {
 603     return CONTAINING_RECORD(iface, struct vfw_capture, IKsPropertySet_iface);
 604 }
 605
 606 static HRESULT WINAPI KSP_QueryInterface(IKsPropertySet *iface, REFIID iid, void **out)
 607 {
 608     struct vfw_capture *filter = impl_from_IKsPropertySet(iface);
 609     return IPin_QueryInterface(&filter->source.pin.IPin_iface, iid, out);
 610 }
 611
 612 static ULONG WINAPI KSP_AddRef(IKsPropertySet * iface)
 613 {
 614     struct vfw_capture *filter = impl_from_IKsPropertySet(iface);
 615     return IPin_AddRef(&filter->source.pin.IPin_iface);
 616 }
 617
 618 static ULONG WINAPI KSP_Release(IKsPropertySet * iface)
 619 {
 620     struct vfw_capture *filter = impl_from_IKsPropertySet(iface);
 621     return IPin_Release(&filter->source.pin.IPin_iface);
 622 }
 623
 624 static HRESULT WINAPI
 625 KSP_Set( IKsPropertySet * iface, REFGUID guidPropSet, DWORD dwPropID,
 626          LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData,
 627          DWORD cbPropData )
 628 {
 629     FIXME("%p: stub\n", iface);
 630     return E_NOTIMPL;
 631 }
 632
 633 static HRESULT WINAPI
 634 KSP_Get( IKsPropertySet * iface, REFGUID guidPropSet, DWORD dwPropID,
 635          LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData,
 636          DWORD cbPropData, DWORD *pcbReturned )
 637 {
 638     LPGUID pGuid;
 639
 640     TRACE("()\n");
 641
 642     if (!IsEqualIID(guidPropSet, &AMPROPSETID_Pin))
 643         return E_PROP_SET_UNSUPPORTED;
 644     if (pPropData == NULL && pcbReturned == NULL)
 645         return E_POINTER;
 646     if (pcbReturned)
 647         *pcbReturned = sizeof(GUID);
 648     if (pPropData == NULL)
 649         return S_OK;
 650     if (cbPropData < sizeof(GUID))
 651         return E_UNEXPECTED;
 652     pGuid = pPropData;
 653     *pGuid = PIN_CATEGORY_CAPTURE;
 654     FIXME("() Not adding a pin with PIN_CATEGORY_PREVIEW\n");
 655     return S_OK;
 656 }
 657
 658 static HRESULT WINAPI
 659 KSP_QuerySupported( IKsPropertySet * iface, REFGUID guidPropSet,
 660                     DWORD dwPropID, DWORD *pTypeSupport )
 661 {
 662    FIXME("%p: stub\n", iface);
 663    return E_NOTIMPL;
 664 }
 665
 666 static const IKsPropertySetVtbl IKsPropertySet_VTable =
 667 {
 668    KSP_QueryInterface,
 669    KSP_AddRef,
 670    KSP_Release,
 671    KSP_Set,
 672    KSP_Get,
 673    KSP_QuerySupported
 674 };
 675
 676 static inline struct vfw_capture *impl_from_strmbase_pin(struct strmbase_pin *pin)
 677 {
 678     return CONTAINING_RECORD(pin, struct vfw_capture, source.pin);
 679 }
 680
 681 static HRESULT source_query_accept(struct strmbase_pin *pin, const AM_MEDIA_TYPE *mt)
 682 {
 683     struct vfw_capture *filter = impl_from_strmbase_pin(pin);
 684     struct check_format_params params = { filter->device, mt };
 685
 686     if (!mt) return E_POINTER;
 687     return V4L_CALL( check_format, &params );
 688 }
 689
 690 static HRESULT source_get_media_type(struct strmbase_pin *pin,
 691         unsigned int index, AM_MEDIA_TYPE *mt)
 692 {
 693     struct vfw_capture *filter = impl_from_strmbase_pin(pin);
 694     struct get_media_type_params params;
 695     VIDEOINFOHEADER *format;
 696     HRESULT hr;
 697
 698     if (!(format = CoTaskMemAlloc(sizeof(*format))))
 699         return E_OUTOFMEMORY;
 700
 701     params.device = filter->device;
 702     params.index  = index;
 703     params.mt     = mt;
 704     params.format = format;
 705     if ((hr = V4L_CALL( get_media_type, &params )) != S_OK)
 706     {
 707         CoTaskMemFree(format);
 708         return hr;
 709     }
 710     mt->cbFormat = sizeof(VIDEOINFOHEADER);
 711     mt->pbFormat = (BYTE *)format;
 712     return S_OK;
 713 }
 714
 715 static HRESULT source_query_interface(struct strmbase_pin *iface, REFIID iid, void **out)
 716 {
 717     struct vfw_capture *filter = impl_from_strmbase_pin(iface);
 718
 719     if (IsEqualGUID(iid, &IID_IKsPropertySet))
 720         *out = &filter->IKsPropertySet_iface;
 721     else if (IsEqualGUID(iid, &IID_IAMStreamConfig))
 722         *out = &filter->IAMStreamConfig_iface;
 723     else
 724         return E_NOINTERFACE;
 725
 726     IUnknown_AddRef((IUnknown *)*out);
 727     return S_OK;
 728 }
 729
 730 static HRESULT WINAPI VfwPin_DecideBufferSize(struct strmbase_source *iface,
 731         IMemAllocator *allocator, ALLOCATOR_PROPERTIES *req_props)
 732 {
 733     struct vfw_capture *filter = impl_from_strmbase_pin(&iface->pin);
 734     ALLOCATOR_PROPERTIES ret_props;
 735
 736     if (!req_props->cBuffers)
 737         req_props->cBuffers = 3;
 738     if (!req_props->cbBuffer)
 739         req_props->cbBuffer = get_image_size(filter);
 740     if (!req_props->cbAlign)
 741         req_props->cbAlign = 1;
 742
 743     return IMemAllocator_SetProperties(allocator, req_props, &ret_props);
 744 }
 745
 746 static const struct strmbase_source_ops source_ops =
 747 {
 748     .base.pin_query_accept = source_query_accept,
 749     .base.pin_get_media_type = source_get_media_type,
 750     .base.pin_query_interface = source_query_interface,
 751     .pfnAttemptConnection = BaseOutputPinImpl_AttemptConnection,
 752     .pfnDecideBufferSize = VfwPin_DecideBufferSize,
 753     .pfnDecideAllocator = BaseOutputPinImpl_DecideAllocator,
 754 };
 755
 756 static HRESULT WINAPI misc_flags_QueryInterface(IAMFilterMiscFlags *iface, REFIID riid, void **ppv)
 757 {
 758     struct vfw_capture *filter = impl_from_IAMFilterMiscFlags(iface);
 759     return IUnknown_QueryInterface(filter->filter.outer_unk, riid, ppv);
 760 }
 761
 762 static ULONG WINAPI misc_flags_AddRef(IAMFilterMiscFlags *iface)
 763 {
 764     struct vfw_capture *filter = impl_from_IAMFilterMiscFlags(iface);
 765     return IUnknown_AddRef(filter->filter.outer_unk);
 766 }
 767
 768 static ULONG WINAPI misc_flags_Release(IAMFilterMiscFlags *iface)
 769 {
 770     struct vfw_capture *filter = impl_from_IAMFilterMiscFlags(iface);
 771     return IUnknown_Release(filter->filter.outer_unk);
 772 }
 773
 774 static ULONG WINAPI misc_flags_GetMiscFlags(IAMFilterMiscFlags *iface)
 775 {
 776     return AM_FILTER_MISC_FLAGS_IS_SOURCE;
 777 }
 778
 779 static const IAMFilterMiscFlagsVtbl IAMFilterMiscFlags_VTable =
 780 {
 781     misc_flags_QueryInterface,
 782     misc_flags_AddRef,
 783     misc_flags_Release,
 784     misc_flags_GetMiscFlags
 785 };
 786
 787 static HRESULT WINAPI video_control_QueryInterface(IAMVideoControl *iface, REFIID riid, void **ppv)
 788 {
 789     struct vfw_capture *filter = impl_from_IAMVideoControl(iface);
 790     return IUnknown_QueryInterface(filter->filter.outer_unk, riid, ppv);
 791 }
 792
 793 static ULONG WINAPI video_control_AddRef(IAMVideoControl *iface)
 794 {
 795     struct vfw_capture *filter = impl_from_IAMVideoControl(iface);
 796     return IUnknown_AddRef(filter->filter.outer_unk);
 797 }
 798
 799 static ULONG WINAPI video_control_Release(IAMVideoControl *iface)
 800 {
 801     struct vfw_capture *filter = impl_from_IAMVideoControl(iface);
 802     return IUnknown_Release(filter->filter.outer_unk);
 803 }
 804
 805 static HRESULT WINAPI video_control_GetCaps(IAMVideoControl *iface, IPin *pin, LONG *flags)
 806 {
 807     struct vfw_capture *filter = impl_from_IAMVideoControl(iface);
 808
 809     FIXME("filter %p, pin %p, flags %p: stub.\n", filter, pin, flags);
 810
 811     return E_NOTIMPL;
 812 }
 813
 814 static HRESULT WINAPI video_control_SetMode(IAMVideoControl *iface, IPin *pin, LONG mode)
 815 {
 816     struct vfw_capture *filter = impl_from_IAMVideoControl(iface);
 817
 818     FIXME("filter %p, pin %p, mode %d: stub.\n", filter, pin, mode);
 819
 820     return E_NOTIMPL;
 821 }
 822
 823 static HRESULT WINAPI video_control_GetMode(IAMVideoControl *iface, IPin *pin, LONG *mode)
 824 {
 825     struct vfw_capture *filter = impl_from_IAMVideoControl(iface);
 826
 827     FIXME("filter %p, pin %p, mode %p: stub.\n", filter, pin, mode);
 828
 829     return E_NOTIMPL;
 830 }
 831
 832 static HRESULT WINAPI video_control_GetCurrentActualFrameRate(IAMVideoControl *iface, IPin *pin,
 833         LONGLONG *frame_rate)
 834 {
 835     struct vfw_capture *filter = impl_from_IAMVideoControl(iface);
 836
 837     FIXME("filter %p, pin %p, frame rate %p: stub.\n", filter, pin, frame_rate);
 838
 839     return E_NOTIMPL;
 840 }
 841
 842 static HRESULT WINAPI video_control_GetMaxAvailableFrameRate(IAMVideoControl *iface, IPin *pin,
 843         LONG index, SIZE dimensions, LONGLONG *frame_rate)
 844 {
 845     struct vfw_capture *filter = impl_from_IAMVideoControl(iface);
 846
 847     FIXME("filter %p, pin %p, index %d, dimensions (%dx%d), frame rate %p: stub.\n",
 848             filter, pin, index, dimensions.cx, dimensions.cy, frame_rate);
 849
 850     return E_NOTIMPL;
 851 }
 852
 853 static HRESULT WINAPI video_control_GetFrameRateList(IAMVideoControl *iface, IPin *pin, LONG index,
 854         SIZE dimensions, LONG *list_size, LONGLONG **frame_rate)
 855 {
 856     struct vfw_capture *filter = impl_from_IAMVideoControl(iface);
 857
 858     FIXME("filter %p, pin %p, index %d, dimensions (%dx%d), list size %p, frame rate: %p: stub.\n",
 859             filter, pin, index, dimensions.cx, dimensions.cy, list_size, frame_rate);
 860
 861     return E_NOTIMPL;
 862 }
 863
 864 static const IAMVideoControlVtbl IAMVideoControl_VTable =
 865 {
 866     video_control_QueryInterface,
 867     video_control_AddRef,
 868     video_control_Release,
 869     video_control_GetCaps,
 870     video_control_SetMode,
 871     video_control_GetMode,
 872     video_control_GetCurrentActualFrameRate,
 873     video_control_GetMaxAvailableFrameRate,
 874     video_control_GetFrameRateList
 875 };
 876
 877 static BOOL WINAPI load_capture_funcs(INIT_ONCE *once, void *param, void **context)
 878 {
 879     NtQueryVirtualMemory( GetCurrentProcess(), qcap_instance, MemoryWineUnixFuncs,
 880                           &v4l_handle, sizeof(v4l_handle), NULL );
 881     return TRUE;
 882 }
 883
 884 static INIT_ONCE init_once = INIT_ONCE_STATIC_INIT;
 885
 886 HRESULT vfw_capture_create(IUnknown *outer, IUnknown **out)
 887 {
 888     struct vfw_capture *object;
 889
 890     if (!InitOnceExecuteOnce(&init_once, load_capture_funcs, NULL, NULL) || !v4l_handle)
 891         return E_FAIL;
 892
 893     if (!(object = calloc(1, sizeof(*object))))
 894         return E_OUTOFMEMORY;
 895
 896     strmbase_filter_init(&object->filter, outer, &CLSID_VfwCapture, &filter_ops);
 897
 898     object->IAMStreamConfig_iface.lpVtbl = &IAMStreamConfig_VTable;
 899     object->IAMVideoControl_iface.lpVtbl = &IAMVideoControl_VTable;
 900     object->IAMVideoProcAmp_iface.lpVtbl = &IAMVideoProcAmp_VTable;
 901     object->IAMFilterMiscFlags_iface.lpVtbl = &IAMFilterMiscFlags_VTable;
 902     object->IPersistPropertyBag_iface.lpVtbl = &IPersistPropertyBag_VTable;
 903
 904     strmbase_source_init(&object->source, &object->filter, L"Output", &source_ops);
 905
 906     object->IKsPropertySet_iface.lpVtbl = &IKsPropertySet_VTable;
 907
 908     object->state = State_Stopped;
 909     InitializeConditionVariable(&object->state_cv);
 910     InitializeCriticalSection(&object->state_cs);
 911     object->state_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": vfw_capture.state_cs");
 912
 913     TRACE("Created VFW capture filter %p.\n", object);
 914     *out = &object->filter.IUnknown_inner;
 915     return S_OK;
 916 }