dlls/qedit/samplegrabber.c

   1 /*              DirectShow Sample Grabber object (QEDIT.DLL)
   2  *
   3  * Copyright 2009 Paul Chitescu
   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 #include <assert.h>
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #include "ole2.h"
  29
  30 #include "qedit_private.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(qedit);
  34
  35 static WCHAR const vendor_name[] = { 'W', 'i', 'n', 'e', 0 };
  36 static WCHAR const pin_in_name[] = { 'I', 'n', 0 };
  37 static WCHAR const pin_out_name[] = { 'O', 'u', 't', 0 };
  38
  39 static IEnumPins *pinsenum_create(IBaseFilter *filter, IPin **pins, ULONG pinCount);
  40 static IEnumMediaTypes *mediaenum_create(const AM_MEDIA_TYPE *mtype);
  41
  42 /* Fixed pins enumerator, holds filter referenced */
  43 typedef struct _PE_Impl {
  44     IEnumPins pe;
  45     IBaseFilter *filter;
  46     LONG refCount;
  47     ULONG numPins;
  48     ULONG index;
  49     IPin *pins[0];
  50 } PE_Impl;
  51
  52
  53 /* IEnumPins interface implementation */
  54
  55 /* IUnknown */
  56 static ULONG WINAPI
  57 Fixed_IEnumPins_AddRef(IEnumPins *iface)
  58 {
  59     PE_Impl *This = (PE_Impl *)iface;
  60     ULONG refCount = InterlockedIncrement(&This->refCount);
  61     TRACE("(%p) new ref = %u\n", This, refCount);
  62     return refCount;
  63 }
  64
  65 /* IUnknown */
  66 static ULONG WINAPI
  67 Fixed_IEnumPins_Release(IEnumPins *iface)
  68 {
  69     PE_Impl *This = (PE_Impl *)iface;
  70     ULONG refCount = InterlockedDecrement(&This->refCount);
  71     TRACE("(%p) new ref = %u\n", This, refCount);
  72     if (refCount == 0)
  73     {
  74         IBaseFilter_Release(This->filter);
  75         CoTaskMemFree(This);
  76         return 0;
  77     }
  78     return refCount;
  79 }
  80
  81 /* IUnknown */
  82 static HRESULT WINAPI
  83 Fixed_IEnumPins_QueryInterface(IEnumPins *iface, REFIID riid, void **ppvObject)
  84 {
  85     PE_Impl *This = (PE_Impl *)iface;
  86     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
  87
  88     if (IsEqualIID(riid, &IID_IUnknown) ||
  89         IsEqualIID(riid, &IID_IEnumPins)) {
  90         Fixed_IEnumPins_AddRef(iface);
  91         *ppvObject = &(This->pins);
  92         return S_OK;
  93     }
  94     *ppvObject = NULL;
  95     WARN("(%p, %s,%p): not found\n", This, debugstr_guid(riid), ppvObject);
  96     return E_NOINTERFACE;
  97 }
  98
  99 /* IEnumPins */
 100 static HRESULT WINAPI
 101 Fixed_IEnumPins_Next(IEnumPins *iface, ULONG nPins, IPin **pins, ULONG *fetched)
 102 {
 103     PE_Impl *This = (PE_Impl *)iface;
 104     ULONG count = 0;
 105     TRACE("(%p)->(%u, %p, %p) index = %u\n", This, nPins, pins, fetched, This->index);
 106     if (!nPins)
 107         return E_INVALIDARG;
 108     if (!pins || ((nPins != 1) && !fetched))
 109         return E_POINTER;
 110     while ((count < nPins) && (This->index < This->numPins)) {
 111         IPin *pin = This->pins[This->index++];
 112         IPin_AddRef(pin);
 113         pins[count++] = pin;
 114     }
 115     if (fetched)
 116         *fetched = count;
 117     return (count == nPins) ? S_OK : S_FALSE;
 118 }
 119
 120 /* IEnumPins */
 121 static HRESULT WINAPI
 122 Fixed_IEnumPins_Skip(IEnumPins *iface, ULONG nPins)
 123 {
 124     PE_Impl *This = (PE_Impl *)iface;
 125     TRACE("(%p)->(%u) index = %u\n", This, nPins, This->index);
 126     nPins += This->index;
 127     if (nPins >= This->numPins) {
 128         This->index = This->numPins;
 129         return S_FALSE;
 130     }
 131     This->index = nPins;
 132     return S_OK;
 133 }
 134
 135 /* IEnumPins */
 136 static HRESULT WINAPI
 137 Fixed_IEnumPins_Reset(IEnumPins *iface)
 138 {
 139     PE_Impl *This = (PE_Impl *)iface;
 140     TRACE("(%p)->() index = %u\n", This, This->index);
 141     This->index = 0;
 142     return S_OK;
 143 }
 144
 145 /* IEnumPins */
 146 static HRESULT WINAPI
 147 Fixed_IEnumPins_Clone(IEnumPins *iface, IEnumPins **pins)
 148 {
 149     PE_Impl *This = (PE_Impl *)iface;
 150     TRACE("(%p)->(%p) index = %u\n", This, pins, This->index);
 151     if (!pins)
 152         return E_POINTER;
 153     *pins = pinsenum_create(This->filter, This->pins, This->numPins);
 154     if (!*pins)
 155         return E_OUTOFMEMORY;
 156     ((PE_Impl *)*pins)->index = This->index;
 157     return S_OK;
 158 }
 159
 160
 161 /* Virtual tables and constructor */
 162
 163 static const IEnumPinsVtbl IEnumPins_VTable =
 164 {
 165     Fixed_IEnumPins_QueryInterface,
 166     Fixed_IEnumPins_AddRef,
 167     Fixed_IEnumPins_Release,
 168     Fixed_IEnumPins_Next,
 169     Fixed_IEnumPins_Skip,
 170     Fixed_IEnumPins_Reset,
 171     Fixed_IEnumPins_Clone,
 172 };
 173
 174 static IEnumPins *pinsenum_create(IBaseFilter *filter, IPin **pins, ULONG pinCount)
 175 {
 176     ULONG len = sizeof(PE_Impl) + (pinCount * sizeof(IPin *));
 177     PE_Impl *obj = CoTaskMemAlloc(len);
 178     if (obj) {
 179         ULONG i;
 180         ZeroMemory(obj, len);
 181         obj->pe.lpVtbl = &IEnumPins_VTable;
 182         obj->refCount = 1;
 183         obj->filter = filter;
 184         obj->numPins = pinCount;
 185         obj->index = 0;
 186         for (i=0; i<pinCount; i++)
 187             obj->pins[i] = pins[i];
 188         IBaseFilter_AddRef(filter);
 189     }
 190     return &obj->pe;
 191 }
 192
 193
 194 /* Single media type enumerator */
 195 typedef struct _ME_Impl {
 196     IEnumMediaTypes me;
 197     LONG refCount;
 198     BOOL past;
 199     AM_MEDIA_TYPE mtype;
 200 } ME_Impl;
 201
 202
 203 /* IEnumMediaTypes interface implementation */
 204
 205 /* IUnknown */
 206 static ULONG WINAPI
 207 Single_IEnumMediaTypes_AddRef(IEnumMediaTypes *iface)
 208 {
 209     ME_Impl *This = (ME_Impl *)iface;
 210     ULONG refCount = InterlockedIncrement(&This->refCount);
 211     TRACE("(%p) new ref = %u\n", This, refCount);
 212     return refCount;
 213 }
 214
 215 /* IUnknown */
 216 static ULONG WINAPI
 217 Single_IEnumMediaTypes_Release(IEnumMediaTypes *iface)
 218 {
 219     ME_Impl *This = (ME_Impl *)iface;
 220     ULONG refCount = InterlockedDecrement(&This->refCount);
 221     TRACE("(%p) new ref = %u\n", This, refCount);
 222     if (refCount == 0)
 223     {
 224         if (This->mtype.pbFormat)
 225             CoTaskMemFree(This->mtype.pbFormat);
 226         CoTaskMemFree(This);
 227         return 0;
 228     }
 229     return refCount;
 230 }
 231
 232 /* IUnknown */
 233 static HRESULT WINAPI
 234 Single_IEnumMediaTypes_QueryInterface(IEnumMediaTypes *iface, REFIID riid, void **ppvObject)
 235 {
 236     ME_Impl *This = (ME_Impl *)iface;
 237     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
 238
 239     if (IsEqualIID(riid, &IID_IUnknown) ||
 240         IsEqualIID(riid, &IID_IEnumMediaTypes)) {
 241         Single_IEnumMediaTypes_AddRef(iface);
 242         *ppvObject = &(This->me);
 243         return S_OK;
 244     }
 245     *ppvObject = NULL;
 246     WARN("(%p, %s,%p): not found\n", This, debugstr_guid(riid), ppvObject);
 247     return E_NOINTERFACE;
 248 }
 249
 250 /* IEnumMediaTypes */
 251 static HRESULT WINAPI
 252 Single_IEnumMediaTypes_Next(IEnumMediaTypes *iface, ULONG nTypes, AM_MEDIA_TYPE **types, ULONG *fetched)
 253 {
 254     ME_Impl *This = (ME_Impl *)iface;
 255     ULONG count = 0;
 256     TRACE("(%p)->(%u, %p, %p)\n", This, nTypes, types, fetched);
 257     if (!nTypes)
 258         return E_INVALIDARG;
 259     if (!types || ((nTypes != 1) && !fetched))
 260         return E_POINTER;
 261     if (!This->past && !IsEqualGUID(&This->mtype.majortype,&GUID_NULL)) {
 262         AM_MEDIA_TYPE *mtype = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
 263         *mtype = This->mtype;
 264         if (mtype->cbFormat) {
 265             mtype->pbFormat = CoTaskMemAlloc(mtype->cbFormat);
 266             CopyMemory(mtype->pbFormat, This->mtype.pbFormat, mtype->cbFormat);
 267         }
 268         *types = mtype;
 269         This->past = TRUE;
 270         count = 1;
 271     }
 272     if (fetched)
 273         *fetched = count;
 274     return (count == nTypes) ? S_OK : S_FALSE;
 275 }
 276
 277 /* IEnumMediaTypes */
 278 static HRESULT WINAPI
 279 Single_IEnumMediaTypes_Skip(IEnumMediaTypes *iface, ULONG nTypes)
 280 {
 281     ME_Impl *This = (ME_Impl *)iface;
 282     TRACE("(%p)->(%u)\n", This, nTypes);
 283     if (nTypes)
 284         This->past = TRUE;
 285     return This->past ? S_FALSE : S_OK;
 286 }
 287
 288 /* IEnumMediaTypes */
 289 static HRESULT WINAPI
 290 Single_IEnumMediaTypes_Reset(IEnumMediaTypes *iface)
 291 {
 292     ME_Impl *This = (ME_Impl *)iface;
 293     TRACE("(%p)->()\n", This);
 294     This->past = FALSE;
 295     return S_OK;
 296 }
 297
 298 /* IEnumMediaTypes */
 299 static HRESULT WINAPI
 300 Single_IEnumMediaTypes_Clone(IEnumMediaTypes *iface, IEnumMediaTypes **me)
 301 {
 302     ME_Impl *This = (ME_Impl *)iface;
 303     TRACE("(%p)->(%p)\n", This, me);
 304     if (!me)
 305         return E_POINTER;
 306     *me = mediaenum_create(&This->mtype);
 307     if (!*me)
 308         return E_OUTOFMEMORY;
 309     ((ME_Impl *)*me)->past = This->past;
 310     return S_OK;
 311 }
 312
 313
 314 /* Virtual tables and constructor */
 315
 316 static const IEnumMediaTypesVtbl IEnumMediaTypes_VTable =
 317 {
 318     Single_IEnumMediaTypes_QueryInterface,
 319     Single_IEnumMediaTypes_AddRef,
 320     Single_IEnumMediaTypes_Release,
 321     Single_IEnumMediaTypes_Next,
 322     Single_IEnumMediaTypes_Skip,
 323     Single_IEnumMediaTypes_Reset,
 324     Single_IEnumMediaTypes_Clone,
 325 };
 326
 327 static IEnumMediaTypes *mediaenum_create(const AM_MEDIA_TYPE *mtype)
 328 {
 329     ME_Impl *obj = CoTaskMemAlloc(sizeof(ME_Impl));
 330     if (obj) {
 331         ZeroMemory(obj, sizeof(ME_Impl));
 332         obj->me.lpVtbl = &IEnumMediaTypes_VTable;
 333         obj->refCount = 1;
 334         obj->past = FALSE;
 335         if (mtype) {
 336             obj->mtype = *mtype;
 337             obj->mtype.pUnk = NULL;
 338             if (mtype->cbFormat) {
 339                 obj->mtype.pbFormat = CoTaskMemAlloc(mtype->cbFormat);
 340                 CopyMemory(obj->mtype.pbFormat, mtype->pbFormat, mtype->cbFormat);
 341             }
 342             else
 343                 obj->mtype.pbFormat = NULL;
 344         }
 345         else
 346             obj->mtype.majortype = GUID_NULL;
 347     }
 348     return &obj->me;
 349 }
 350
 351
 352 /* Sample Grabber pin implementation */
 353 typedef struct _SG_Pin {
 354     const IPinVtbl* lpVtbl;
 355     PIN_DIRECTION dir;
 356     WCHAR const *name;
 357     struct _SG_Impl *sg;
 358     IPin *pair;
 359 } SG_Pin;
 360
 361 /* Sample Grabber filter implementation */
 362 typedef struct _SG_Impl {
 363     const IBaseFilterVtbl* IBaseFilter_Vtbl;
 364     const ISampleGrabberVtbl* ISampleGrabber_Vtbl;
 365     const IMemInputPinVtbl* IMemInputPin_Vtbl;
 366     /* TODO: IMediaPosition, IMediaSeeking, IQualityControl */
 367     LONG refCount;
 368     CRITICAL_SECTION critSect;
 369     FILTER_INFO info;
 370     FILTER_STATE state;
 371     AM_MEDIA_TYPE mtype;
 372     SG_Pin pin_in;
 373     SG_Pin pin_out;
 374     IMemAllocator *allocator;
 375     IReferenceClock *refClock;
 376     IMemInputPin *memOutput;
 377     ISampleGrabberCB *grabberIface;
 378     LONG grabberMethod;
 379     LONG oneShot;
 380     LONG bufferLen;
 381     void* bufferData;
 382 } SG_Impl;
 383
 384 enum {
 385     OneShot_None,
 386     OneShot_Wait,
 387     OneShot_Past,
 388 };
 389
 390 /* Get the SampleGrabber implementation This pointer from various interface pointers */
 391 static inline SG_Impl *impl_from_IBaseFilter(IBaseFilter *iface)
 392 {
 393     return (SG_Impl *)((char*)iface - FIELD_OFFSET(SG_Impl, IBaseFilter_Vtbl));
 394 }
 395
 396 static inline SG_Impl *impl_from_ISampleGrabber(ISampleGrabber *iface)
 397 {
 398     return (SG_Impl *)((char*)iface - FIELD_OFFSET(SG_Impl, ISampleGrabber_Vtbl));
 399 }
 400
 401 static inline SG_Impl *impl_from_IMemInputPin(IMemInputPin *iface)
 402 {
 403     return (SG_Impl *)((char*)iface - FIELD_OFFSET(SG_Impl, IMemInputPin_Vtbl));
 404 }
 405
 406
 407 /* Cleanup at end of life */
 408 static void SampleGrabber_cleanup(SG_Impl *This)
 409 {
 410     TRACE("(%p)\n", This);
 411     if (This->info.pGraph)
 412         WARN("(%p) still joined to filter graph %p\n", This, This->info.pGraph);
 413     if (This->allocator)
 414         IMemAllocator_Release(This->allocator);
 415     if (This->refClock)
 416         IReferenceClock_Release(This->refClock);
 417     if (This->memOutput)
 418         IMemInputPin_Release(This->memOutput);
 419     if (This->grabberIface)
 420         ISampleGrabberCB_Release(This->grabberIface);
 421     if (This->mtype.pbFormat)
 422         CoTaskMemFree(This->mtype.pbFormat);
 423     if (This->bufferData)
 424         CoTaskMemFree(This->bufferData);
 425     This->critSect.DebugInfo->Spare[0] = 0;
 426     DeleteCriticalSection(&This->critSect);
 427 }
 428
 429 /* Common helper AddRef called from all interfaces */
 430 static ULONG SampleGrabber_addref(SG_Impl *This)
 431 {
 432     ULONG refCount = InterlockedIncrement(&This->refCount);
 433     TRACE("(%p) new ref = %u\n", This, refCount);
 434     return refCount;
 435 }
 436
 437 /* Common helper Release called from all interfaces */
 438 static ULONG SampleGrabber_release(SG_Impl *This)
 439 {
 440     ULONG refCount = InterlockedDecrement(&This->refCount);
 441     TRACE("(%p) new ref = %u\n", This, refCount);
 442     if (refCount == 0)
 443     {
 444         SampleGrabber_cleanup(This);
 445         CoTaskMemFree(This);
 446         return 0;
 447     }
 448     return refCount;
 449 }
 450
 451 /* Common helper QueryInterface called from all interfaces */
 452 static HRESULT SampleGrabber_query(SG_Impl *This, REFIID riid, void **ppvObject)
 453 {
 454     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
 455
 456     if (IsEqualIID(riid, &IID_IUnknown) ||
 457         IsEqualIID(riid, &IID_IPersist) ||
 458         IsEqualIID(riid, &IID_IMediaFilter) ||
 459         IsEqualIID(riid, &IID_IBaseFilter)) {
 460         SampleGrabber_addref(This);
 461         *ppvObject = &(This->IBaseFilter_Vtbl);
 462         return S_OK;
 463     }
 464     else if (IsEqualIID(riid, &IID_ISampleGrabber)) {
 465         SampleGrabber_addref(This);
 466         *ppvObject = &(This->ISampleGrabber_Vtbl);
 467         return S_OK;
 468     }
 469     else if (IsEqualIID(riid, &IID_IMemInputPin)) {
 470         SampleGrabber_addref(This);
 471         *ppvObject = &(This->IMemInputPin_Vtbl);
 472         return S_OK;
 473     }
 474     else if (IsEqualIID(riid, &IID_IMediaPosition))
 475         FIXME("IMediaPosition not implemented\n");
 476     else if (IsEqualIID(riid, &IID_IMediaSeeking))
 477         FIXME("IMediaSeeking not implemented\n");
 478     else if (IsEqualIID(riid, &IID_IQualityControl))
 479         FIXME("IQualityControl not implemented\n");
 480     *ppvObject = NULL;
 481     WARN("(%p, %s,%p): not found\n", This, debugstr_guid(riid), ppvObject);
 482     return E_NOINTERFACE;
 483 }
 484
 485 /* Helper that buffers data and/or calls installed sample callbacks */
 486 static void SampleGrabber_callback(SG_Impl *This, IMediaSample *sample)
 487 {
 488     double time = 0.0;
 489     REFERENCE_TIME tStart, tEnd;
 490     if (This->bufferLen >= 0) {
 491         BYTE *data = 0;
 492         LONG size = IMediaSample_GetActualDataLength(sample);
 493         if (size >= 0 && SUCCEEDED(IMediaSample_GetPointer(sample, &data))) {
 494             if (!data)
 495                 size = 0;
 496             EnterCriticalSection(&This->critSect);
 497             if (This->bufferLen != size) {
 498                 if (This->bufferData)
 499                     CoTaskMemFree(This->bufferData);
 500                 This->bufferData = size ? CoTaskMemAlloc(size) : NULL;
 501                 This->bufferLen = size;
 502             }
 503             if (size)
 504                 CopyMemory(This->bufferData, data, size);
 505             LeaveCriticalSection(&This->critSect);
 506         }
 507     }
 508     if (!This->grabberIface)
 509         return;
 510     if (SUCCEEDED(IMediaSample_GetTime(sample, &tStart, &tEnd)))
 511         time = 1e-7 * tStart;
 512     switch (This->grabberMethod) {
 513         case 0:
 514             {
 515                 ULONG ref = IMediaSample_AddRef(sample);
 516                 ISampleGrabberCB_SampleCB(This->grabberIface, time, sample);
 517                 ref = IMediaSample_Release(sample) + 1 - ref;
 518                 if (ref)
 519                 {
 520                     ERR("(%p) Callback referenced sample %p by %u\n", This, sample, ref);
 521                     /* ugly as hell but some apps are sooo buggy */
 522                     while (ref--)
 523                         IMediaSample_Release(sample);
 524                 }
 525             }
 526             break;
 527         case 1:
 528             {
 529                 BYTE *data = 0;
 530                 LONG size = IMediaSample_GetActualDataLength(sample);
 531                 if (size && SUCCEEDED(IMediaSample_GetPointer(sample, &data)) && data)
 532                     ISampleGrabberCB_BufferCB(This->grabberIface, time, data, size);
 533             }
 534             break;
 535         case -1:
 536             break;
 537         default:
 538             FIXME("unsupported method %d\n", This->grabberMethod);
 539             /* do not bother us again */
 540             This->grabberMethod = -1;
 541     }
 542 }
 543
 544
 545 /* SampleGrabber implementation of IBaseFilter interface */
 546
 547 /* IUnknown */
 548 static HRESULT WINAPI
 549 SampleGrabber_IBaseFilter_QueryInterface(IBaseFilter *iface, REFIID riid, void **ppvObject)
 550 {
 551     return SampleGrabber_query(impl_from_IBaseFilter(iface), riid, ppvObject);
 552 }
 553
 554 /* IUnknown */
 555 static ULONG WINAPI
 556 SampleGrabber_IBaseFilter_AddRef(IBaseFilter *iface)
 557 {
 558     return SampleGrabber_addref(impl_from_IBaseFilter(iface));
 559 }
 560
 561 /* IUnknown */
 562 static ULONG WINAPI
 563 SampleGrabber_IBaseFilter_Release(IBaseFilter *iface)
 564 {
 565     return SampleGrabber_release(impl_from_IBaseFilter(iface));
 566 }
 567
 568 /* IPersist */
 569 static HRESULT WINAPI
 570 SampleGrabber_IBaseFilter_GetClassID(IBaseFilter *iface, CLSID *pClassID)
 571 {
 572     TRACE("(%p)\n", pClassID);
 573     if (!pClassID)
 574         return E_POINTER;
 575     *pClassID = CLSID_SampleGrabber;
 576     return S_OK;
 577 }
 578
 579 /* IMediaFilter */
 580 static HRESULT WINAPI
 581 SampleGrabber_IBaseFilter_Stop(IBaseFilter *iface)
 582 {
 583     SG_Impl *This = impl_from_IBaseFilter(iface);
 584     TRACE("(%p)\n", This);
 585     This->state = State_Stopped;
 586     return S_OK;
 587 }
 588
 589 /* IMediaFilter */
 590 static HRESULT WINAPI
 591 SampleGrabber_IBaseFilter_Pause(IBaseFilter *iface)
 592 {
 593     SG_Impl *This = impl_from_IBaseFilter(iface);
 594     TRACE("(%p)\n", This);
 595     This->state = State_Paused;
 596     return S_OK;
 597 }
 598
 599 /* IMediaFilter */
 600 static HRESULT WINAPI
 601 SampleGrabber_IBaseFilter_Run(IBaseFilter *iface, REFERENCE_TIME tStart)
 602 {
 603     SG_Impl *This = impl_from_IBaseFilter(iface);
 604     TRACE("(%p)\n", This);
 605     This->state = State_Running;
 606     return S_OK;
 607 }
 608
 609 /* IMediaFilter */
 610 static HRESULT WINAPI
 611 SampleGrabber_IBaseFilter_GetState(IBaseFilter *iface, DWORD msTout, FILTER_STATE *state)
 612 {
 613     SG_Impl *This = impl_from_IBaseFilter(iface);
 614     TRACE("(%p)->(%u, %p)\n", This, msTout, state);
 615     if (!state)
 616         return E_POINTER;
 617     *state = This->state;
 618     return S_OK;
 619 }
 620
 621 /* IMediaFilter */
 622 static HRESULT WINAPI
 623 SampleGrabber_IBaseFilter_SetSyncSource(IBaseFilter *iface, IReferenceClock *clock)
 624 {
 625     SG_Impl *This = impl_from_IBaseFilter(iface);
 626     TRACE("(%p)->(%p)\n", This, clock);
 627     if (clock != This->refClock)
 628     {
 629         if (clock)
 630             IReferenceClock_AddRef(clock);
 631         if (This->refClock)
 632             IReferenceClock_Release(This->refClock);
 633         This->refClock = clock;
 634     }
 635     return S_OK;
 636 }
 637
 638 /* IMediaFilter */
 639 static HRESULT WINAPI
 640 SampleGrabber_IBaseFilter_GetSyncSource(IBaseFilter *iface, IReferenceClock **clock)
 641 {
 642     SG_Impl *This = impl_from_IBaseFilter(iface);
 643     TRACE("(%p)->(%p)\n", This, clock);
 644     if (!clock)
 645         return E_POINTER;
 646     if (This->refClock)
 647         IReferenceClock_AddRef(This->refClock);
 648     *clock = This->refClock;
 649     return S_OK;
 650 }
 651
 652 /* IBaseFilter */
 653 static HRESULT WINAPI
 654 SampleGrabber_IBaseFilter_EnumPins(IBaseFilter *iface, IEnumPins **pins)
 655 {
 656     SG_Impl *This = impl_from_IBaseFilter(iface);
 657     IPin *pin[2];
 658     TRACE("(%p)->(%p)\n", This, pins);
 659     if (!pins)
 660         return E_POINTER;
 661     pin[0] = (IPin*)&This->pin_in.lpVtbl;
 662     pin[1] = (IPin*)&This->pin_out.lpVtbl;
 663     *pins = pinsenum_create(iface, pin, 2);
 664     return *pins ? S_OK : E_OUTOFMEMORY;
 665 }
 666
 667 /* IBaseFilter */
 668 static HRESULT WINAPI
 669 SampleGrabber_IBaseFilter_FindPin(IBaseFilter *iface, LPCWSTR id, IPin **pin)
 670 {
 671     SG_Impl *This = impl_from_IBaseFilter(iface);
 672     TRACE("(%p)->(%s, %p)\n", This, debugstr_w(id), pin);
 673     if (!id || !pin)
 674         return E_POINTER;
 675     if (!lstrcmpiW(id,pin_in_name))
 676     {
 677         SampleGrabber_addref(This);
 678         *pin = (IPin*)&(This->pin_in.lpVtbl);
 679         return S_OK;
 680     }
 681     else if (!lstrcmpiW(id,pin_out_name))
 682     {
 683         SampleGrabber_addref(This);
 684         *pin = (IPin*)&(This->pin_out.lpVtbl);
 685         return S_OK;
 686     }
 687     *pin = NULL;
 688     return VFW_E_NOT_FOUND;
 689 }
 690
 691 /* IBaseFilter */
 692 static HRESULT WINAPI
 693 SampleGrabber_IBaseFilter_QueryFilterInfo(IBaseFilter *iface, FILTER_INFO *info)
 694 {
 695     SG_Impl *This = impl_from_IBaseFilter(iface);
 696     TRACE("(%p)->(%p)\n", This, info);
 697     if (!info)
 698         return E_POINTER;
 699     if (This->info.pGraph)
 700         IFilterGraph_AddRef(This->info.pGraph);
 701     *info = This->info;
 702     return S_OK;
 703 }
 704
 705 /* IBaseFilter */
 706 static HRESULT WINAPI
 707 SampleGrabber_IBaseFilter_JoinFilterGraph(IBaseFilter *iface, IFilterGraph *graph, LPCWSTR name)
 708 {
 709     SG_Impl *This = impl_from_IBaseFilter(iface);
 710     TRACE("(%p)->(%p, %s)\n", This, graph, debugstr_w(name));
 711     This->info.pGraph = graph;
 712     if (name)
 713         lstrcpynW(This->info.achName,name,MAX_FILTER_NAME);
 714     This->oneShot = OneShot_None;
 715     return S_OK;
 716 }
 717
 718 /* IBaseFilter */
 719 static HRESULT WINAPI
 720 SampleGrabber_IBaseFilter_QueryVendorInfo(IBaseFilter *iface, LPWSTR *vendor)
 721 {
 722     TRACE("(%p)\n", vendor);
 723     if (!vendor)
 724         return E_POINTER;
 725     *vendor = CoTaskMemAlloc(sizeof(vendor_name));
 726     CopyMemory(*vendor, vendor_name, sizeof(vendor_name));
 727     return S_OK;
 728 }
 729
 730
 731 /* SampleGrabber implementation of ISampleGrabber interface */
 732
 733 /* IUnknown */
 734 static HRESULT WINAPI
 735 SampleGrabber_ISampleGrabber_QueryInterface(ISampleGrabber *iface, REFIID riid, void **ppvObject)
 736 {
 737     return SampleGrabber_query(impl_from_ISampleGrabber(iface), riid, ppvObject);
 738 }
 739
 740 /* IUnknown */
 741 static ULONG WINAPI
 742 SampleGrabber_ISampleGrabber_AddRef(ISampleGrabber *iface)
 743 {
 744     return SampleGrabber_addref(impl_from_ISampleGrabber(iface));
 745 }
 746
 747 /* IUnknown */
 748 static ULONG WINAPI
 749 SampleGrabber_ISampleGrabber_Release(ISampleGrabber *iface)
 750 {
 751     return SampleGrabber_release(impl_from_ISampleGrabber(iface));
 752 }
 753
 754 /* ISampleGrabber */
 755 static HRESULT WINAPI
 756 SampleGrabber_ISampleGrabber_SetOneShot(ISampleGrabber *iface, BOOL oneShot)
 757 {
 758     SG_Impl *This = impl_from_ISampleGrabber(iface);
 759     TRACE("(%p)->(%u)\n", This, oneShot);
 760     This->oneShot = oneShot ? OneShot_Wait : OneShot_None;
 761     return S_OK;
 762 }
 763
 764 /* ISampleGrabber */
 765 static HRESULT WINAPI
 766 SampleGrabber_ISampleGrabber_SetMediaType(ISampleGrabber *iface, const AM_MEDIA_TYPE *type)
 767 {
 768     SG_Impl *This = impl_from_ISampleGrabber(iface);
 769     TRACE("(%p)->(%p)\n", This, type);
 770     if (!type)
 771         return E_POINTER;
 772     TRACE("Media type: %s/%s ssize: %u format: %s (%u bytes)\n",
 773         debugstr_guid(&type->majortype), debugstr_guid(&type->subtype),
 774         type->lSampleSize,
 775         debugstr_guid(&type->formattype), type->cbFormat);
 776     if (This->mtype.pbFormat)
 777         CoTaskMemFree(This->mtype.pbFormat);
 778     This->mtype = *type;
 779     This->mtype.pUnk = NULL;
 780     if (type->cbFormat) {
 781         This->mtype.pbFormat = CoTaskMemAlloc(type->cbFormat);
 782         CopyMemory(This->mtype.pbFormat, type->pbFormat, type->cbFormat);
 783     }
 784     else
 785         This->mtype.pbFormat = NULL;
 786     return S_OK;
 787 }
 788
 789 /* ISampleGrabber */
 790 static HRESULT WINAPI
 791 SampleGrabber_ISampleGrabber_GetConnectedMediaType(ISampleGrabber *iface, AM_MEDIA_TYPE *type)
 792 {
 793     SG_Impl *This = impl_from_ISampleGrabber(iface);
 794     TRACE("(%p)->(%p)\n", This, type);
 795     if (!type)
 796         return E_POINTER;
 797     if (!This->pin_in.pair)
 798         return VFW_E_NOT_CONNECTED;
 799     *type = This->mtype;
 800     if (type->cbFormat) {
 801         type->pbFormat = CoTaskMemAlloc(type->cbFormat);
 802         CopyMemory(type->pbFormat, This->mtype.pbFormat, type->cbFormat);
 803     }
 804     return S_OK;
 805 }
 806
 807 /* ISampleGrabber */
 808 static HRESULT WINAPI
 809 SampleGrabber_ISampleGrabber_SetBufferSamples(ISampleGrabber *iface, BOOL bufferEm)
 810 {
 811     SG_Impl *This = impl_from_ISampleGrabber(iface);
 812     TRACE("(%p)->(%u)\n", This, bufferEm);
 813     EnterCriticalSection(&This->critSect);
 814     if (bufferEm) {
 815         if (This->bufferLen < 0)
 816             This->bufferLen = 0;
 817     }
 818     else
 819         This->bufferLen = -1;
 820     LeaveCriticalSection(&This->critSect);
 821     return S_OK;
 822 }
 823
 824 /* ISampleGrabber */
 825 static HRESULT WINAPI
 826 SampleGrabber_ISampleGrabber_GetCurrentBuffer(ISampleGrabber *iface, LONG *bufSize, LONG *buffer)
 827 {
 828     SG_Impl *This = impl_from_ISampleGrabber(iface);
 829     HRESULT ret = S_OK;
 830     TRACE("(%p)->(%p, %p)\n", This, bufSize, buffer);
 831     if (!bufSize)
 832         return E_POINTER;
 833     EnterCriticalSection(&This->critSect);
 834     if (!This->pin_in.pair)
 835         ret = VFW_E_NOT_CONNECTED;
 836     else if (This->bufferLen < 0)
 837         ret = E_INVALIDARG;
 838     else if (This->bufferLen == 0)
 839         ret = VFW_E_WRONG_STATE;
 840     else {
 841         if (buffer) {
 842             if (*bufSize >= This->bufferLen)
 843                 CopyMemory(buffer, This->bufferData, This->bufferLen);
 844             else
 845                 ret = E_OUTOFMEMORY;
 846         }
 847         *bufSize = This->bufferLen;
 848     }
 849     LeaveCriticalSection(&This->critSect);
 850     return ret;
 851 }
 852
 853 /* ISampleGrabber */
 854 static HRESULT WINAPI
 855 SampleGrabber_ISampleGrabber_GetCurrentSample(ISampleGrabber *iface, IMediaSample **sample)
 856 {
 857     /* MS doesn't implement it either, no one should call it */
 858     WARN("(%p): not implemented\n", sample);
 859     return E_NOTIMPL;
 860 }
 861
 862 /* ISampleGrabber */
 863 static HRESULT WINAPI
 864 SampleGrabber_ISampleGrabber_SetCallback(ISampleGrabber *iface, ISampleGrabberCB *cb, LONG whichMethod)
 865 {
 866     SG_Impl *This = impl_from_ISampleGrabber(iface);
 867     TRACE("(%p)->(%p, %u)\n", This, cb, whichMethod);
 868     if (This->grabberIface)
 869         ISampleGrabberCB_Release(This->grabberIface);
 870     This->grabberIface = cb;
 871     This->grabberMethod = whichMethod;
 872     if (cb)
 873         ISampleGrabberCB_AddRef(cb);
 874     return S_OK;
 875 }
 876
 877
 878 /* SampleGrabber implementation of IMemInputPin interface */
 879
 880 /* IUnknown */
 881 static HRESULT WINAPI
 882 SampleGrabber_IMemInputPin_QueryInterface(IMemInputPin *iface, REFIID riid, void **ppvObject)
 883 {
 884     return SampleGrabber_query(impl_from_IMemInputPin(iface), riid, ppvObject);
 885 }
 886
 887 /* IUnknown */
 888 static ULONG WINAPI
 889 SampleGrabber_IMemInputPin_AddRef(IMemInputPin *iface)
 890 {
 891     return SampleGrabber_addref(impl_from_IMemInputPin(iface));
 892 }
 893
 894 /* IUnknown */
 895 static ULONG WINAPI
 896 SampleGrabber_IMemInputPin_Release(IMemInputPin *iface)
 897 {
 898     return SampleGrabber_release(impl_from_IMemInputPin(iface));
 899 }
 900
 901 /* IMemInputPin */
 902 static HRESULT WINAPI
 903 SampleGrabber_IMemInputPin_GetAllocator(IMemInputPin *iface, IMemAllocator **allocator)
 904 {
 905     SG_Impl *This = impl_from_IMemInputPin(iface);
 906     TRACE("(%p)->(%p) allocator = %p\n", This, allocator, This->allocator);
 907     if (!allocator)
 908         return E_POINTER;
 909     *allocator = This->allocator;
 910     if (!*allocator)
 911         return VFW_E_NO_ALLOCATOR;
 912     IMemAllocator_AddRef(*allocator);
 913     return S_OK;
 914 }
 915
 916 /* IMemInputPin */
 917 static HRESULT WINAPI
 918 SampleGrabber_IMemInputPin_NotifyAllocator(IMemInputPin *iface, IMemAllocator *allocator, BOOL readOnly)
 919 {
 920     SG_Impl *This = impl_from_IMemInputPin(iface);
 921     TRACE("(%p)->(%p, %u) allocator = %p\n", This, allocator, readOnly, This->allocator);
 922     if (This->allocator == allocator)
 923         return S_OK;
 924     if (This->allocator)
 925         IMemAllocator_Release(This->allocator);
 926     This->allocator = allocator;
 927     if (allocator)
 928         IMemAllocator_AddRef(allocator);
 929     return S_OK;
 930 }
 931
 932 /* IMemInputPin */
 933 static HRESULT WINAPI
 934 SampleGrabber_IMemInputPin_GetAllocatorRequirements(IMemInputPin *iface, ALLOCATOR_PROPERTIES *props)
 935 {
 936     SG_Impl *This = impl_from_IMemInputPin(iface);
 937     FIXME("(%p)->(%p): semi-stub\n", This, props);
 938     if (!props)
 939         return E_POINTER;
 940     return This->memOutput ? IMemInputPin_GetAllocatorRequirements(This->memOutput, props) : E_NOTIMPL;
 941 }
 942
 943 /* IMemInputPin */
 944 static HRESULT WINAPI
 945 SampleGrabber_IMemInputPin_Receive(IMemInputPin *iface, IMediaSample *sample)
 946 {
 947     SG_Impl *This = impl_from_IMemInputPin(iface);
 948     HRESULT hr;
 949     TRACE("(%p)->(%p) output = %p, grabber = %p\n", This, sample, This->memOutput, This->grabberIface);
 950     if (!sample)
 951         return E_POINTER;
 952     if ((This->state != State_Running) || (This->oneShot == OneShot_Past))
 953         return S_FALSE;
 954     SampleGrabber_callback(This, sample);
 955     hr = This->memOutput ? IMemInputPin_Receive(This->memOutput, sample) : S_OK;
 956     if (This->oneShot == OneShot_Wait) {
 957         This->oneShot = OneShot_Past;
 958         hr = S_FALSE;
 959         if (This->pin_out.pair)
 960             IPin_EndOfStream(This->pin_out.pair);
 961     }
 962     return hr;
 963 }
 964
 965 /* IMemInputPin */
 966 static HRESULT WINAPI
 967 SampleGrabber_IMemInputPin_ReceiveMultiple(IMemInputPin *iface, IMediaSample **samples, LONG nSamples, LONG *nProcessed)
 968 {
 969     SG_Impl *This = impl_from_IMemInputPin(iface);
 970     LONG idx;
 971     TRACE("(%p)->(%p, %u, %p) output = %p, grabber = %p\n", This, samples, nSamples, nProcessed, This->memOutput, This->grabberIface);
 972     if (!samples || !nProcessed)
 973         return E_POINTER;
 974     if ((This->state != State_Running) || (This->oneShot == OneShot_Past))
 975         return S_FALSE;
 976     for (idx = 0; idx < nSamples; idx++)
 977         SampleGrabber_callback(This, samples[idx]);
 978     return This->memOutput ? IMemInputPin_ReceiveMultiple(This->memOutput, samples, nSamples, nProcessed) : S_OK;
 979 }
 980
 981 /* IMemInputPin */
 982 static HRESULT WINAPI
 983 SampleGrabber_IMemInputPin_ReceiveCanBlock(IMemInputPin *iface)
 984 {
 985     SG_Impl *This = impl_from_IMemInputPin(iface);
 986     TRACE("(%p)\n", This);
 987     return This->memOutput ? IMemInputPin_ReceiveCanBlock(This->memOutput) : S_OK;
 988 }
 989
 990
 991 /* SampleGrabber member pin implementation */
 992
 993 /* IUnknown */
 994 static ULONG WINAPI
 995 SampleGrabber_IPin_AddRef(IPin *iface)
 996 {
 997     return SampleGrabber_addref(((SG_Pin *)iface)->sg);
 998 }
 999
1000 /* IUnknown */
1001 static ULONG WINAPI
1002 SampleGrabber_IPin_Release(IPin *iface)
1003 {
1004     return SampleGrabber_release(((SG_Pin *)iface)->sg);
1005 }
1006
1007 /* IUnknown */
1008 static HRESULT WINAPI
1009 SampleGrabber_IPin_QueryInterface(IPin *iface, REFIID riid, void **ppvObject)
1010 {
1011     SG_Pin *This = (SG_Pin *)iface;
1012     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
1013
1014     if (IsEqualIID(riid, &IID_IUnknown) ||
1015         IsEqualIID(riid, &IID_IPin)) {
1016         SampleGrabber_addref(This->sg);
1017         *ppvObject = This;
1018         return S_OK;
1019     }
1020     else if (IsEqualIID(riid, &IID_IMemInputPin)) {
1021         SampleGrabber_addref(This->sg);
1022         *ppvObject = &(This->sg->IMemInputPin_Vtbl);
1023         return S_OK;
1024     }
1025     *ppvObject = NULL;
1026     WARN("(%p, %s,%p): not found\n", This, debugstr_guid(riid), ppvObject);
1027     return E_NOINTERFACE;
1028 }
1029
1030 /* IPin - input pin */
1031 static HRESULT WINAPI
1032 SampleGrabber_In_IPin_Connect(IPin *iface, IPin *receiver, const AM_MEDIA_TYPE *mtype)
1033 {
1034     WARN("(%p, %p): unexpected\n", receiver, mtype);
1035     return E_UNEXPECTED;
1036 }
1037
1038 /* IPin - output pin */
1039 static HRESULT WINAPI
1040 SampleGrabber_Out_IPin_Connect(IPin *iface, IPin *receiver, const AM_MEDIA_TYPE *type)
1041 {
1042     SG_Pin *This = (SG_Pin *)iface;
1043     HRESULT hr;
1044     TRACE("(%p)->(%p, %p)\n", This, receiver, type);
1045     if (!receiver)
1046         return E_POINTER;
1047     if (This->pair)
1048         return VFW_E_ALREADY_CONNECTED;
1049     if (This->sg->state != State_Stopped)
1050         return VFW_E_NOT_STOPPED;
1051     if (type) {
1052         TRACE("Media type: %s/%s ssize: %u format: %s (%u bytes)\n",
1053             debugstr_guid(&type->majortype), debugstr_guid(&type->subtype),
1054             type->lSampleSize,
1055             debugstr_guid(&type->formattype), type->cbFormat);
1056         if (!IsEqualGUID(&This->sg->mtype.majortype,&GUID_NULL) &&
1057             !IsEqualGUID(&This->sg->mtype.majortype,&type->majortype))
1058             return VFW_E_TYPE_NOT_ACCEPTED;
1059         if (!IsEqualGUID(&This->sg->mtype.subtype,&MEDIASUBTYPE_None) &&
1060             !IsEqualGUID(&This->sg->mtype.subtype,&type->subtype))
1061             return VFW_E_TYPE_NOT_ACCEPTED;
1062         if (!IsEqualGUID(&This->sg->mtype.formattype,&GUID_NULL) &&
1063             !IsEqualGUID(&This->sg->mtype.formattype,&FORMAT_None) &&
1064             !IsEqualGUID(&This->sg->mtype.formattype,&type->formattype))
1065             return VFW_E_TYPE_NOT_ACCEPTED;
1066     }
1067     else
1068         type = &This->sg->mtype;
1069     if (!IsEqualGUID(&type->formattype, &FORMAT_None) &&
1070         !IsEqualGUID(&type->formattype, &GUID_NULL) &&
1071         !type->pbFormat)
1072         return VFW_E_TYPE_NOT_ACCEPTED;
1073     hr = IPin_ReceiveConnection(receiver,(IPin*)&This->lpVtbl,type);
1074     if (FAILED(hr))
1075         return hr;
1076     This->pair = receiver;
1077     if (This->sg->memOutput) {
1078         IMemInputPin_Release(This->sg->memOutput);
1079         This->sg->memOutput = NULL;
1080     }
1081     IPin_QueryInterface(receiver,&IID_IMemInputPin,(void **)&(This->sg->memOutput));
1082     TRACE("(%p) Accepted IPin %p, IMemInputPin %p\n", This, receiver, This->sg->memOutput);
1083     return S_OK;
1084 }
1085
1086 /* IPin - input pin */
1087 static HRESULT WINAPI
1088 SampleGrabber_In_IPin_ReceiveConnection(IPin *iface, IPin *connector, const AM_MEDIA_TYPE *type)
1089 {
1090     SG_Pin *This = (SG_Pin *)iface;
1091     TRACE("(%p)->(%p, %p)\n", This, connector, type);
1092     if (!connector)
1093         return E_POINTER;
1094     if (This->pair)
1095         return VFW_E_ALREADY_CONNECTED;
1096     if (This->sg->state != State_Stopped)
1097         return VFW_E_NOT_STOPPED;
1098     if (type) {
1099         TRACE("Media type: %s/%s ssize: %u format: %s (%u bytes)\n",
1100             debugstr_guid(&type->majortype), debugstr_guid(&type->subtype),
1101             type->lSampleSize,
1102             debugstr_guid(&type->formattype), type->cbFormat);
1103         if (!IsEqualGUID(&type->formattype, &FORMAT_None) &&
1104             !IsEqualGUID(&type->formattype, &GUID_NULL) &&
1105             !type->pbFormat)
1106             return VFW_E_INVALIDMEDIATYPE;
1107         if (!IsEqualGUID(&This->sg->mtype.majortype,&GUID_NULL) &&
1108             !IsEqualGUID(&This->sg->mtype.majortype,&type->majortype))
1109             return VFW_E_TYPE_NOT_ACCEPTED;
1110         if (!IsEqualGUID(&This->sg->mtype.subtype,&MEDIASUBTYPE_None) &&
1111             !IsEqualGUID(&This->sg->mtype.subtype,&type->subtype))
1112             return VFW_E_TYPE_NOT_ACCEPTED;
1113         if (!IsEqualGUID(&This->sg->mtype.formattype,&GUID_NULL) &&
1114             !IsEqualGUID(&This->sg->mtype.formattype,&FORMAT_None) &&
1115             !IsEqualGUID(&This->sg->mtype.formattype,&type->formattype))
1116             return VFW_E_TYPE_NOT_ACCEPTED;
1117         if (This->sg->mtype.pbFormat)
1118             CoTaskMemFree(This->sg->mtype.pbFormat);
1119         This->sg->mtype = *type;
1120         This->sg->mtype.pUnk = NULL;
1121         if (type->cbFormat) {
1122             This->sg->mtype.pbFormat = CoTaskMemAlloc(type->cbFormat);
1123             CopyMemory(This->sg->mtype.pbFormat, type->pbFormat, type->cbFormat);
1124         }
1125         else
1126             This->sg->mtype.pbFormat = NULL;
1127     }
1128     This->pair = connector;
1129     TRACE("(%p) Accepted IPin %p\n", This, connector);
1130     return S_OK;
1131 }
1132
1133 /* IPin - output pin */
1134 static HRESULT WINAPI
1135 SampleGrabber_Out_IPin_ReceiveConnection(IPin *iface, IPin *connector, const AM_MEDIA_TYPE *mtype)
1136 {
1137     WARN("(%p, %p): unexpected\n", connector, mtype);
1138     return E_UNEXPECTED;
1139 }
1140
1141 /* IPin - input pin */
1142 static HRESULT WINAPI
1143 SampleGrabber_In_IPin_Disconnect(IPin *iface)
1144 {
1145     SG_Pin *This = (SG_Pin *)iface;
1146     TRACE("(%p)->() pair = %p\n", This, This->pair);
1147     if (This->sg->state != State_Stopped)
1148         return VFW_E_NOT_STOPPED;
1149     if (This->pair) {
1150         This->pair = NULL;
1151         return S_OK;
1152     }
1153     return S_FALSE;
1154 }
1155
1156 /* IPin - output pin */
1157 static HRESULT WINAPI
1158 SampleGrabber_Out_IPin_Disconnect(IPin *iface)
1159 {
1160     SG_Pin *This = (SG_Pin *)iface;
1161     TRACE("(%p)->() pair = %p\n", This, This->pair);
1162     if (This->sg->state != State_Stopped)
1163         return VFW_E_NOT_STOPPED;
1164     if (This->pair) {
1165         This->pair = NULL;
1166         if (This->sg->memOutput) {
1167             IMemInputPin_Release(This->sg->memOutput);
1168             This->sg->memOutput = NULL;
1169         }
1170         return S_OK;
1171     }
1172     return S_FALSE;
1173 }
1174
1175 /* IPin */
1176 static HRESULT WINAPI
1177 SampleGrabber_IPin_ConnectedTo(IPin *iface, IPin **pin)
1178 {
1179     SG_Pin *This = (SG_Pin *)iface;
1180     TRACE("(%p)->(%p) pair = %p\n", This, pin, This->pair);
1181     if (!pin)
1182         return E_POINTER;
1183     *pin = This->pair;
1184     if (*pin) {
1185         IPin_AddRef(*pin);
1186         return S_OK;
1187     }
1188     return VFW_E_NOT_CONNECTED;
1189 }
1190
1191 /* IPin */
1192 static HRESULT WINAPI
1193 SampleGrabber_IPin_ConnectionMediaType(IPin *iface, AM_MEDIA_TYPE *mtype)
1194 {
1195     SG_Pin *This = (SG_Pin *)iface;
1196     TRACE("(%p)->(%p)\n", This, mtype);
1197     if (!mtype)
1198         return E_POINTER;
1199     if (!This->pair)
1200         return VFW_E_NOT_CONNECTED;
1201     *mtype = This->sg->mtype;
1202     if (mtype->cbFormat) {
1203         mtype->pbFormat = CoTaskMemAlloc(mtype->cbFormat);
1204         CopyMemory(mtype->pbFormat, This->sg->mtype.pbFormat, mtype->cbFormat);
1205     }
1206     return S_OK;
1207 }
1208
1209 /* IPin */
1210 static HRESULT WINAPI
1211 SampleGrabber_IPin_QueryPinInfo(IPin *iface, PIN_INFO *info)
1212 {
1213     SG_Pin *This = (SG_Pin *)iface;
1214     TRACE("(%p)->(%p)\n", This, info);
1215     if (!info)
1216         return E_POINTER;
1217     SampleGrabber_addref(This->sg);
1218     info->pFilter = (IBaseFilter *)This->sg;
1219     info->dir = This->dir;
1220     lstrcpynW(info->achName,This->name,MAX_PIN_NAME);
1221     return S_OK;
1222 }
1223
1224 /* IPin */
1225 static HRESULT WINAPI
1226 SampleGrabber_IPin_QueryDirection(IPin *iface, PIN_DIRECTION *dir)
1227 {
1228     SG_Pin *This = (SG_Pin *)iface;
1229     TRACE("(%p)->(%p)\n", This, dir);
1230     if (!dir)
1231         return E_POINTER;
1232     *dir = This->dir;
1233     return S_OK;
1234 }
1235
1236 /* IPin */
1237 static HRESULT WINAPI
1238 SampleGrabber_IPin_QueryId(IPin *iface, LPWSTR *id)
1239 {
1240     SG_Pin *This = (SG_Pin *)iface;
1241     int len;
1242     TRACE("(%p)->(%p)\n", This, id);
1243     if (!id)
1244         return E_POINTER;
1245     len = sizeof(WCHAR)*(1+lstrlenW(This->name));
1246     *id = CoTaskMemAlloc(len);
1247     CopyMemory(*id, This->name, len);
1248     return S_OK;
1249 }
1250
1251 /* IPin */
1252 static HRESULT WINAPI
1253 SampleGrabber_IPin_QueryAccept(IPin *iface, const AM_MEDIA_TYPE *mtype)
1254 {
1255     TRACE("(%p)\n", mtype);
1256     return S_OK;
1257 }
1258
1259 /* IPin */
1260 static HRESULT WINAPI
1261 SampleGrabber_IPin_EnumMediaTypes(IPin *iface, IEnumMediaTypes **mtypes)
1262 {
1263     SG_Pin *This = (SG_Pin *)iface;
1264     TRACE("(%p)->(%p)\n", This, mtypes);
1265     if (!mtypes)
1266         return E_POINTER;
1267     *mtypes = mediaenum_create(This->sg->pin_in.pair ? &This->sg->mtype : NULL);
1268     return *mtypes ? S_OK : E_OUTOFMEMORY;
1269 }
1270
1271 /* IPin - input pin */
1272 static HRESULT WINAPI
1273 SampleGrabber_In_IPin_QueryInternalConnections(IPin *iface, IPin **pins, ULONG *nPins)
1274 {
1275     SG_Pin *This = (SG_Pin *)iface;
1276     TRACE("(%p)->(%p, %p) size = %u\n", This, pins, nPins, (nPins ? *nPins : 0));
1277     if (!nPins)
1278         return E_POINTER;
1279     if (*nPins) {
1280         if (!pins)
1281             return E_POINTER;
1282         IPin_AddRef((IPin*)&This->sg->pin_out.lpVtbl);
1283         *pins = (IPin*)&This->sg->pin_out.lpVtbl;
1284         *nPins = 1;
1285         return S_OK;
1286     }
1287     *nPins = 1;
1288     return S_FALSE;
1289 }
1290
1291 /* IPin - output pin */
1292 static HRESULT WINAPI
1293 SampleGrabber_Out_IPin_QueryInternalConnections(IPin *iface, IPin **pins, ULONG *nPins)
1294 {
1295     WARN("(%p, %p): unexpected\n", pins, nPins);
1296     if (nPins)
1297         *nPins = 0;
1298     return E_NOTIMPL;
1299 }
1300
1301 /* IPin */
1302 static HRESULT WINAPI
1303 SampleGrabber_IPin_EndOfStream(IPin *iface)
1304 {
1305     FIXME(": stub\n");
1306     return S_OK;
1307 }
1308
1309 /* IPin */
1310 static HRESULT WINAPI
1311 SampleGrabber_IPin_BeginFlush(IPin *iface)
1312 {
1313     FIXME(": stub\n");
1314     return S_OK;
1315 }
1316
1317 /* IPin */
1318 static HRESULT WINAPI
1319 SampleGrabber_IPin_EndFlush(IPin *iface)
1320 {
1321     FIXME(": stub\n");
1322     return S_OK;
1323 }
1324
1325 /* IPin */
1326 static HRESULT WINAPI
1327 SampleGrabber_IPin_NewSegment(IPin *iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double rate)
1328 {
1329     FIXME(": stub\n");
1330     return S_OK;
1331 }
1332
1333
1334 /* SampleGrabber vtables and constructor */
1335
1336 static const IBaseFilterVtbl IBaseFilter_VTable =
1337 {
1338     SampleGrabber_IBaseFilter_QueryInterface,
1339     SampleGrabber_IBaseFilter_AddRef,
1340     SampleGrabber_IBaseFilter_Release,
1341     SampleGrabber_IBaseFilter_GetClassID,
1342     SampleGrabber_IBaseFilter_Stop,
1343     SampleGrabber_IBaseFilter_Pause,
1344     SampleGrabber_IBaseFilter_Run,
1345     SampleGrabber_IBaseFilter_GetState,
1346     SampleGrabber_IBaseFilter_SetSyncSource,
1347     SampleGrabber_IBaseFilter_GetSyncSource,
1348     SampleGrabber_IBaseFilter_EnumPins,
1349     SampleGrabber_IBaseFilter_FindPin,
1350     SampleGrabber_IBaseFilter_QueryFilterInfo,
1351     SampleGrabber_IBaseFilter_JoinFilterGraph,
1352     SampleGrabber_IBaseFilter_QueryVendorInfo,
1353 };
1354
1355 static const ISampleGrabberVtbl ISampleGrabber_VTable =
1356 {
1357     SampleGrabber_ISampleGrabber_QueryInterface,
1358     SampleGrabber_ISampleGrabber_AddRef,
1359     SampleGrabber_ISampleGrabber_Release,
1360     SampleGrabber_ISampleGrabber_SetOneShot,
1361     SampleGrabber_ISampleGrabber_SetMediaType,
1362     SampleGrabber_ISampleGrabber_GetConnectedMediaType,
1363     SampleGrabber_ISampleGrabber_SetBufferSamples,
1364     SampleGrabber_ISampleGrabber_GetCurrentBuffer,
1365     SampleGrabber_ISampleGrabber_GetCurrentSample,
1366     SampleGrabber_ISampleGrabber_SetCallback,
1367 };
1368
1369 static const IMemInputPinVtbl IMemInputPin_VTable =
1370 {
1371     SampleGrabber_IMemInputPin_QueryInterface,
1372     SampleGrabber_IMemInputPin_AddRef,
1373     SampleGrabber_IMemInputPin_Release,
1374     SampleGrabber_IMemInputPin_GetAllocator,
1375     SampleGrabber_IMemInputPin_NotifyAllocator,
1376     SampleGrabber_IMemInputPin_GetAllocatorRequirements,
1377     SampleGrabber_IMemInputPin_Receive,
1378     SampleGrabber_IMemInputPin_ReceiveMultiple,
1379     SampleGrabber_IMemInputPin_ReceiveCanBlock,
1380 };
1381
1382 static const IPinVtbl IPin_In_VTable =
1383 {
1384     SampleGrabber_IPin_QueryInterface,
1385     SampleGrabber_IPin_AddRef,
1386     SampleGrabber_IPin_Release,
1387     SampleGrabber_In_IPin_Connect,
1388     SampleGrabber_In_IPin_ReceiveConnection,
1389     SampleGrabber_In_IPin_Disconnect,
1390     SampleGrabber_IPin_ConnectedTo,
1391     SampleGrabber_IPin_ConnectionMediaType,
1392     SampleGrabber_IPin_QueryPinInfo,
1393     SampleGrabber_IPin_QueryDirection,
1394     SampleGrabber_IPin_QueryId,
1395     SampleGrabber_IPin_QueryAccept,
1396     SampleGrabber_IPin_EnumMediaTypes,
1397     SampleGrabber_In_IPin_QueryInternalConnections,
1398     SampleGrabber_IPin_EndOfStream,
1399     SampleGrabber_IPin_BeginFlush,
1400     SampleGrabber_IPin_EndFlush,
1401     SampleGrabber_IPin_NewSegment,
1402 };
1403
1404 static const IPinVtbl IPin_Out_VTable =
1405 {
1406     SampleGrabber_IPin_QueryInterface,
1407     SampleGrabber_IPin_AddRef,
1408     SampleGrabber_IPin_Release,
1409     SampleGrabber_Out_IPin_Connect,
1410     SampleGrabber_Out_IPin_ReceiveConnection,
1411     SampleGrabber_Out_IPin_Disconnect,
1412     SampleGrabber_IPin_ConnectedTo,
1413     SampleGrabber_IPin_ConnectionMediaType,
1414     SampleGrabber_IPin_QueryPinInfo,
1415     SampleGrabber_IPin_QueryDirection,
1416     SampleGrabber_IPin_QueryId,
1417     SampleGrabber_IPin_QueryAccept,
1418     SampleGrabber_IPin_EnumMediaTypes,
1419     SampleGrabber_Out_IPin_QueryInternalConnections,
1420     SampleGrabber_IPin_EndOfStream,
1421     SampleGrabber_IPin_BeginFlush,
1422     SampleGrabber_IPin_EndFlush,
1423     SampleGrabber_IPin_NewSegment,
1424 };
1425
1426 HRESULT SampleGrabber_create(IUnknown *pUnkOuter, LPVOID *ppv)
1427 {
1428     SG_Impl* obj = NULL;
1429
1430     TRACE("(%p,%p)\n", ppv, pUnkOuter);
1431
1432     if (pUnkOuter)
1433         return CLASS_E_NOAGGREGATION;
1434
1435     obj = CoTaskMemAlloc(sizeof(SG_Impl));
1436     if (NULL == obj) {
1437         *ppv = NULL;
1438         return E_OUTOFMEMORY;
1439     }
1440     ZeroMemory(obj, sizeof(SG_Impl));
1441
1442     obj->refCount = 1;
1443     obj->IBaseFilter_Vtbl = &IBaseFilter_VTable;
1444     obj->ISampleGrabber_Vtbl = &ISampleGrabber_VTable;
1445     obj->IMemInputPin_Vtbl = &IMemInputPin_VTable;
1446     obj->pin_in.lpVtbl = &IPin_In_VTable;
1447     obj->pin_in.dir = PINDIR_INPUT;
1448     obj->pin_in.name = pin_in_name;
1449     obj->pin_in.sg = obj;
1450     obj->pin_in.pair = NULL;
1451     obj->pin_out.lpVtbl = &IPin_Out_VTable;
1452     obj->pin_out.dir = PINDIR_OUTPUT;
1453     obj->pin_out.name = pin_out_name;
1454     obj->pin_out.sg = obj;
1455     obj->pin_out.pair = NULL;
1456     InitializeCriticalSection(&obj->critSect);
1457     obj->critSect.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": SG_Impl.critSect");
1458     obj->info.achName[0] = 0;
1459     obj->info.pGraph = NULL;
1460     obj->state = State_Stopped;
1461     obj->mtype.majortype = GUID_NULL;
1462     obj->mtype.subtype = MEDIASUBTYPE_None;
1463     obj->mtype.formattype = FORMAT_None;
1464     obj->allocator = NULL;
1465     obj->refClock = NULL;
1466     obj->memOutput = NULL;
1467     obj->grabberIface = NULL;
1468     obj->grabberMethod = -1;
1469     obj->oneShot = OneShot_None;
1470     obj->bufferLen = -1;
1471     obj->bufferData = NULL;
1472     *ppv = obj;
1473
1474     return S_OK;
1475 }