dlls/strmbase/pin.c

   1 /*
   2  * Generic Implementation of IPin Interface
   3  *
   4  * Copyright 2003 Robert Shearman
   5  * Copyright 2010 Aric Stewart, CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define COBJMACROS
  23
  24 #include "dshow.h"
  25 #include "wine/debug.h"
  26 #include "wine/unicode.h"
  27 #include "wine/strmbase.h"
  28 #include "uuids.h"
  29 #include "vfwmsgs.h"
  30 #include <assert.h>
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(strmbase);
  33
  34 static const IPinVtbl InputPin_Vtbl;
  35 static const IPinVtbl OutputPin_Vtbl;
  36 static const IMemInputPinVtbl MemInputPin_Vtbl;
  37
  38 typedef HRESULT (*SendPinFunc)( IPin *to, LPVOID arg );
  39
  40 static inline BasePin *impl_from_IPin( IPin *iface )
  41 {
  42     return CONTAINING_RECORD(iface, BasePin, IPin_iface);
  43 }
  44
  45 /** Helper function, there are a lot of places where the error code is inherited
  46  * The following rules apply:
  47  *
  48  * Return the first received error code (E_NOTIMPL is ignored)
  49  * If no errors occur: return the first received non-error-code that isn't S_OK
  50  */
  51 static HRESULT updatehres( HRESULT original, HRESULT new )
  52 {
  53     if (FAILED( original ) || new == E_NOTIMPL)
  54         return original;
  55
  56     if (FAILED( new ) || original == S_OK)
  57         return new;
  58
  59     return original;
  60 }
  61
  62 /** Sends a message from a pin further to other, similar pins
  63  * fnMiddle is called on each pin found further on the stream.
  64  * fnEnd (can be NULL) is called when the message can't be sent any further (this is a renderer or source)
  65  *
  66  * If the pin given is an input pin, the message will be sent downstream to other input pins
  67  * If the pin given is an output pin, the message will be sent upstream to other output pins
  68  */
  69 static HRESULT SendFurther( IPin *from, SendPinFunc fnMiddle, LPVOID arg, SendPinFunc fnEnd )
  70 {
  71     PIN_INFO pin_info;
  72     ULONG amount = 0;
  73     HRESULT hr = S_OK;
  74     HRESULT hr_return = S_OK;
  75     IEnumPins *enumpins = NULL;
  76     BOOL foundend = TRUE;
  77     PIN_DIRECTION from_dir;
  78
  79     IPin_QueryDirection( from, &from_dir );
  80
  81     hr = IPin_QueryInternalConnections( from, NULL, &amount );
  82     if (hr != E_NOTIMPL && amount)
  83         FIXME("Use QueryInternalConnections!\n");
  84      hr = S_OK;
  85
  86     pin_info.pFilter = NULL;
  87     hr = IPin_QueryPinInfo( from, &pin_info );
  88     if (FAILED(hr))
  89         goto out;
  90
  91     hr = IBaseFilter_EnumPins( pin_info.pFilter, &enumpins );
  92     if (FAILED(hr))
  93         goto out;
  94
  95     hr = IEnumPins_Reset( enumpins );
  96     while (hr == S_OK) {
  97         IPin *pin = NULL;
  98         hr = IEnumPins_Next( enumpins, 1, &pin, NULL );
  99         if (hr == VFW_E_ENUM_OUT_OF_SYNC)
 100         {
 101             hr = IEnumPins_Reset( enumpins );
 102             continue;
 103         }
 104         if (pin)
 105         {
 106             PIN_DIRECTION dir;
 107
 108             IPin_QueryDirection( pin, &dir );
 109             if (dir != from_dir)
 110             {
 111                 IPin *connected = NULL;
 112
 113                 foundend = FALSE;
 114                 IPin_ConnectedTo( pin, &connected );
 115                 if (connected)
 116                 {
 117                     HRESULT hr_local;
 118
 119                     hr_local = fnMiddle( connected, arg );
 120                     hr_return = updatehres( hr_return, hr_local );
 121                     IPin_Release(connected);
 122                 }
 123             }
 124             IPin_Release( pin );
 125         }
 126         else
 127         {
 128             hr = S_OK;
 129             break;
 130         }
 131     }
 132
 133     if (!foundend)
 134         hr = hr_return;
 135     else if (fnEnd) {
 136         HRESULT hr_local;
 137
 138         hr_local = fnEnd( from, arg );
 139         hr_return = updatehres( hr_return, hr_local );
 140     }
 141     IEnumPins_Release(enumpins);
 142
 143 out:
 144     if (pin_info.pFilter)
 145         IBaseFilter_Release( pin_info.pFilter );
 146     return hr;
 147 }
 148
 149 static void Copy_PinInfo(PIN_INFO * pDest, const PIN_INFO * pSrc)
 150 {
 151     /* Tempting to just do a memcpy, but the name field is
 152        128 characters long! We will probably never exceed 10
 153        most of the time, so we are better off copying
 154        each field manually */
 155     strcpyW(pDest->achName, pSrc->achName);
 156     pDest->dir = pSrc->dir;
 157     pDest->pFilter = pSrc->pFilter;
 158 }
 159
 160 static void dump_AM_MEDIA_TYPE(const AM_MEDIA_TYPE * pmt)
 161 {
 162     if (!pmt)
 163         return;
 164     TRACE("\t%s\n\t%s\n\t...\n\t%s\n", debugstr_guid(&pmt->majortype), debugstr_guid(&pmt->subtype), debugstr_guid(&pmt->formattype));
 165 }
 166
 167 static BOOL CompareMediaTypes(const AM_MEDIA_TYPE * pmt1, const AM_MEDIA_TYPE * pmt2, BOOL bWildcards)
 168 {
 169     TRACE("pmt1: ");
 170     dump_AM_MEDIA_TYPE(pmt1);
 171     TRACE("pmt2: ");
 172     dump_AM_MEDIA_TYPE(pmt2);
 173     return (((bWildcards && (IsEqualGUID(&pmt1->majortype, &GUID_NULL) || IsEqualGUID(&pmt2->majortype, &GUID_NULL))) || IsEqualGUID(&pmt1->majortype, &pmt2->majortype)) &&
 174             ((bWildcards && (IsEqualGUID(&pmt1->subtype, &GUID_NULL)   || IsEqualGUID(&pmt2->subtype, &GUID_NULL)))   || IsEqualGUID(&pmt1->subtype, &pmt2->subtype)));
 175 }
 176
 177 /*** Common Base Pin function */
 178 HRESULT WINAPI BasePinImpl_GetMediaType(BasePin *iface, int iPosition, AM_MEDIA_TYPE *pmt)
 179 {
 180     if (iPosition < 0)
 181         return E_INVALIDARG;
 182     return VFW_S_NO_MORE_ITEMS;
 183 }
 184
 185 LONG WINAPI BasePinImpl_GetMediaTypeVersion(BasePin *iface)
 186 {
 187     return 1;
 188 }
 189
 190 ULONG WINAPI BasePinImpl_AddRef(IPin * iface)
 191 {
 192     BasePin *This = impl_from_IPin(iface);
 193     ULONG refCount = InterlockedIncrement(&This->refCount);
 194
 195     TRACE("(%p)->() AddRef from %d\n", iface, refCount - 1);
 196
 197     return refCount;
 198 }
 199
 200 HRESULT WINAPI BasePinImpl_Disconnect(IPin * iface)
 201 {
 202     HRESULT hr;
 203     BasePin *This = impl_from_IPin(iface);
 204
 205     TRACE("()\n");
 206
 207     EnterCriticalSection(This->pCritSec);
 208     {
 209         if (This->pConnectedTo)
 210         {
 211             IPin_Release(This->pConnectedTo);
 212             This->pConnectedTo = NULL;
 213             FreeMediaType(&This->mtCurrent);
 214             ZeroMemory(&This->mtCurrent, sizeof(This->mtCurrent));
 215             hr = S_OK;
 216         }
 217         else
 218             hr = S_FALSE;
 219     }
 220     LeaveCriticalSection(This->pCritSec);
 221
 222     return hr;
 223 }
 224
 225 HRESULT WINAPI BasePinImpl_ConnectedTo(IPin * iface, IPin ** ppPin)
 226 {
 227     HRESULT hr;
 228     BasePin *This = impl_from_IPin(iface);
 229
 230     TRACE("(%p)\n", ppPin);
 231
 232     EnterCriticalSection(This->pCritSec);
 233     {
 234         if (This->pConnectedTo)
 235         {
 236             *ppPin = This->pConnectedTo;
 237             IPin_AddRef(*ppPin);
 238             hr = S_OK;
 239         }
 240         else
 241         {
 242             hr = VFW_E_NOT_CONNECTED;
 243             *ppPin = NULL;
 244         }
 245     }
 246     LeaveCriticalSection(This->pCritSec);
 247
 248     return hr;
 249 }
 250
 251 HRESULT WINAPI BasePinImpl_ConnectionMediaType(IPin * iface, AM_MEDIA_TYPE * pmt)
 252 {
 253     HRESULT hr;
 254     BasePin *This = impl_from_IPin(iface);
 255
 256     TRACE("(%p/%p)->(%p)\n", This, iface, pmt);
 257
 258     EnterCriticalSection(This->pCritSec);
 259     {
 260         if (This->pConnectedTo)
 261         {
 262             CopyMediaType(pmt, &This->mtCurrent);
 263             hr = S_OK;
 264         }
 265         else
 266         {
 267             ZeroMemory(pmt, sizeof(*pmt));
 268             hr = VFW_E_NOT_CONNECTED;
 269         }
 270     }
 271     LeaveCriticalSection(This->pCritSec);
 272
 273     return hr;
 274 }
 275
 276 HRESULT WINAPI BasePinImpl_QueryPinInfo(IPin * iface, PIN_INFO * pInfo)
 277 {
 278     BasePin *This = impl_from_IPin(iface);
 279
 280     TRACE("(%p/%p)->(%p)\n", This, iface, pInfo);
 281
 282     Copy_PinInfo(pInfo, &This->pinInfo);
 283     IBaseFilter_AddRef(pInfo->pFilter);
 284
 285     return S_OK;
 286 }
 287
 288 HRESULT WINAPI BasePinImpl_QueryDirection(IPin * iface, PIN_DIRECTION * pPinDir)
 289 {
 290     BasePin *This = impl_from_IPin(iface);
 291
 292     TRACE("(%p/%p)->(%p)\n", This, iface, pPinDir);
 293
 294     *pPinDir = This->pinInfo.dir;
 295
 296     return S_OK;
 297 }
 298
 299 HRESULT WINAPI BasePinImpl_QueryId(IPin * iface, LPWSTR * Id)
 300 {
 301     BasePin *This = impl_from_IPin(iface);
 302
 303     TRACE("(%p/%p)->(%p)\n", This, iface, Id);
 304
 305     *Id = CoTaskMemAlloc((strlenW(This->pinInfo.achName) + 1) * sizeof(WCHAR));
 306     if (!*Id)
 307         return E_OUTOFMEMORY;
 308
 309     strcpyW(*Id, This->pinInfo.achName);
 310
 311     return S_OK;
 312 }
 313
 314 HRESULT WINAPI BasePinImpl_QueryAccept(IPin * iface, const AM_MEDIA_TYPE * pmt)
 315 {
 316     TRACE("(%p)->(%p)\n", iface, pmt);
 317
 318     return S_OK;
 319 }
 320
 321 HRESULT WINAPI BasePinImpl_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum)
 322 {
 323     BasePin *This = impl_from_IPin(iface);
 324
 325     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 326
 327     /* override this method to allow enumeration of your types */
 328
 329     return EnumMediaTypes_Construct(This, This->pFuncsTable->pfnGetMediaType, This->pFuncsTable->pfnGetMediaTypeVersion , ppEnum);
 330 }
 331
 332 HRESULT WINAPI BasePinImpl_QueryInternalConnections(IPin * iface, IPin ** apPin, ULONG * cPin)
 333 {
 334     BasePin *This = impl_from_IPin(iface);
 335
 336     TRACE("(%p/%p)->(%p, %p)\n", This, iface, apPin, cPin);
 337
 338     return E_NOTIMPL; /* to tell caller that all input pins connected to all output pins */
 339 }
 340
 341 HRESULT WINAPI BasePinImpl_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
 342 {
 343     BasePin *This = impl_from_IPin(iface);
 344
 345     TRACE("(%x%08x, %x%08x, %e)\n", (ULONG)(tStart >> 32), (ULONG)tStart, (ULONG)(tStop >> 32), (ULONG)tStop, dRate);
 346
 347     This->tStart = tStart;
 348     This->tStop = tStop;
 349     This->dRate = dRate;
 350
 351     return S_OK;
 352 }
 353
 354 /*** OutputPin implementation ***/
 355
 356 static inline BaseOutputPin *impl_BaseOutputPin_from_IPin( IPin *iface )
 357 {
 358     return CONTAINING_RECORD(iface, BaseOutputPin, pin.IPin_iface);
 359 }
 360
 361 static inline BaseOutputPin *impl_BaseOutputPin_from_BasePin( BasePin *iface )
 362 {
 363     return CONTAINING_RECORD(iface, BaseOutputPin, pin);
 364 }
 365
 366 HRESULT WINAPI BaseOutputPinImpl_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
 367 {
 368     BaseOutputPin *This = impl_BaseOutputPin_from_IPin(iface);
 369
 370     TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppv);
 371
 372     *ppv = NULL;
 373
 374     if (IsEqualIID(riid, &IID_IUnknown))
 375         *ppv = iface;
 376     else if (IsEqualIID(riid, &IID_IPin))
 377         *ppv = iface;
 378     else if (IsEqualIID(riid, &IID_IMediaSeeking) ||
 379              IsEqualIID(riid, &IID_IQualityControl))
 380     {
 381         return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, riid, ppv);
 382     }
 383
 384     if (*ppv)
 385     {
 386         IUnknown_AddRef((IUnknown *)(*ppv));
 387         return S_OK;
 388     }
 389
 390     FIXME("No interface for %s!\n", debugstr_guid(riid));
 391
 392     return E_NOINTERFACE;
 393 }
 394
 395 ULONG WINAPI BaseOutputPinImpl_Release(IPin * iface)
 396 {
 397     BaseOutputPin *This = impl_BaseOutputPin_from_IPin(iface);
 398     ULONG refCount = InterlockedDecrement(&This->pin.refCount);
 399
 400     TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
 401
 402     if (!refCount)
 403     {
 404         BaseOutputPin_Destroy(This);
 405         return 0;
 406     }
 407     return refCount;
 408 }
 409
 410 HRESULT WINAPI BaseOutputPinImpl_Connect(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 411 {
 412     HRESULT hr;
 413     BaseOutputPin *This = impl_BaseOutputPin_from_IPin(iface);
 414
 415     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt);
 416     dump_AM_MEDIA_TYPE(pmt);
 417
 418     if (!pReceivePin)
 419         return E_POINTER;
 420
 421     /* If we try to connect to ourselves, we will definitely deadlock.
 422      * There are other cases where we could deadlock too, but this
 423      * catches the obvious case */
 424     assert(pReceivePin != iface);
 425
 426     EnterCriticalSection(This->pin.pCritSec);
 427     {
 428         /* if we have been a specific type to connect with, then we can either connect
 429          * with that or fail. We cannot choose different AM_MEDIA_TYPE */
 430         if (pmt && !IsEqualGUID(&pmt->majortype, &GUID_NULL) && !IsEqualGUID(&pmt->subtype, &GUID_NULL))
 431             hr = This->pin.pFuncsTable->pfnAttemptConnection(&This->pin, pReceivePin, pmt);
 432         else
 433         {
 434             /* negotiate media type */
 435
 436             IEnumMediaTypes * pEnumCandidates;
 437             AM_MEDIA_TYPE * pmtCandidate = NULL; /* Candidate media type */
 438
 439             if (SUCCEEDED(hr = IPin_EnumMediaTypes(iface, &pEnumCandidates)))
 440             {
 441                 hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */
 442
 443                 /* try this filter's media types first */
 444                 while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL))
 445                 {
 446                     assert(pmtCandidate);
 447                     dump_AM_MEDIA_TYPE(pmtCandidate);
 448                     if (!IsEqualGUID(&FORMAT_None, &pmtCandidate->formattype)
 449                         && !IsEqualGUID(&GUID_NULL, &pmtCandidate->formattype))
 450                         assert(pmtCandidate->pbFormat);
 451                     if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) &&
 452                         (This->pin.pFuncsTable->pfnAttemptConnection(&This->pin, pReceivePin, pmtCandidate) == S_OK))
 453                     {
 454                         hr = S_OK;
 455                         DeleteMediaType(pmtCandidate);
 456                         break;
 457                     }
 458                     DeleteMediaType(pmtCandidate);
 459                     pmtCandidate = NULL;
 460                 }
 461                 IEnumMediaTypes_Release(pEnumCandidates);
 462             }
 463
 464             /* then try receiver filter's media types */
 465             if (hr != S_OK && SUCCEEDED(hr = IPin_EnumMediaTypes(pReceivePin, &pEnumCandidates))) /* if we haven't already connected successfully */
 466             {
 467                 ULONG fetched;
 468
 469                 hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */
 470
 471                 while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, &fetched))
 472                 {
 473                     assert(pmtCandidate);
 474                     dump_AM_MEDIA_TYPE(pmtCandidate);
 475                     if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) &&
 476                         (This->pin.pFuncsTable->pfnAttemptConnection(&This->pin, pReceivePin, pmtCandidate) == S_OK))
 477                     {
 478                         hr = S_OK;
 479                         DeleteMediaType(pmtCandidate);
 480                         break;
 481                     }
 482                     DeleteMediaType(pmtCandidate);
 483                     pmtCandidate = NULL;
 484                 } /* while */
 485                 IEnumMediaTypes_Release(pEnumCandidates);
 486             } /* if not found */
 487         } /* if negotiate media type */
 488     } /* if succeeded */
 489     LeaveCriticalSection(This->pin.pCritSec);
 490
 491     TRACE(" -- %x\n", hr);
 492     return hr;
 493 }
 494
 495 HRESULT WINAPI BaseOutputPinImpl_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 496 {
 497     ERR("Incoming connection on an output pin! (%p, %p)\n", pReceivePin, pmt);
 498
 499     return E_UNEXPECTED;
 500 }
 501
 502 HRESULT WINAPI BaseOutputPinImpl_Disconnect(IPin * iface)
 503 {
 504     HRESULT hr;
 505     BaseOutputPin *This = impl_BaseOutputPin_from_IPin(iface);
 506
 507     TRACE("()\n");
 508
 509     EnterCriticalSection(This->pin.pCritSec);
 510     {
 511         if (This->pMemInputPin)
 512         {
 513             IMemInputPin_Release(This->pMemInputPin);
 514             This->pMemInputPin = NULL;
 515         }
 516         if (This->pin.pConnectedTo)
 517         {
 518             IPin_Release(This->pin.pConnectedTo);
 519             This->pin.pConnectedTo = NULL;
 520             FreeMediaType(&This->pin.mtCurrent);
 521             ZeroMemory(&This->pin.mtCurrent, sizeof(This->pin.mtCurrent));
 522             hr = S_OK;
 523         }
 524         else
 525             hr = S_FALSE;
 526     }
 527     LeaveCriticalSection(This->pin.pCritSec);
 528
 529     return hr;
 530 }
 531
 532 HRESULT WINAPI BaseOutputPinImpl_EndOfStream(IPin * iface)
 533 {
 534     TRACE("()\n");
 535
 536     /* not supposed to do anything in an output pin */
 537
 538     return E_UNEXPECTED;
 539 }
 540
 541 HRESULT WINAPI BaseOutputPinImpl_BeginFlush(IPin * iface)
 542 {
 543     TRACE("(%p)->()\n", iface);
 544
 545     /* not supposed to do anything in an output pin */
 546
 547     return E_UNEXPECTED;
 548 }
 549
 550 HRESULT WINAPI BaseOutputPinImpl_EndFlush(IPin * iface)
 551 {
 552     TRACE("(%p)->()\n", iface);
 553
 554     /* not supposed to do anything in an output pin */
 555
 556     return E_UNEXPECTED;
 557 }
 558
 559 static const IPinVtbl OutputPin_Vtbl =
 560 {
 561     BaseOutputPinImpl_QueryInterface,
 562     BasePinImpl_AddRef,
 563     BaseOutputPinImpl_Release,
 564     BaseOutputPinImpl_Connect,
 565     BaseOutputPinImpl_ReceiveConnection,
 566     BaseOutputPinImpl_Disconnect,
 567     BasePinImpl_ConnectedTo,
 568     BasePinImpl_ConnectionMediaType,
 569     BasePinImpl_QueryPinInfo,
 570     BasePinImpl_QueryDirection,
 571     BasePinImpl_QueryId,
 572     BasePinImpl_QueryAccept,
 573     BasePinImpl_EnumMediaTypes,
 574     BasePinImpl_QueryInternalConnections,
 575     BaseOutputPinImpl_EndOfStream,
 576     BaseOutputPinImpl_BeginFlush,
 577     BaseOutputPinImpl_EndFlush,
 578     BasePinImpl_NewSegment
 579 };
 580
 581 HRESULT WINAPI BaseOutputPinImpl_GetDeliveryBuffer(BaseOutputPin *This, IMediaSample ** ppSample, REFERENCE_TIME * tStart, REFERENCE_TIME * tStop, DWORD dwFlags)
 582 {
 583     HRESULT hr;
 584
 585     TRACE("(%p, %p, %p, %x)\n", ppSample, tStart, tStop, dwFlags);
 586
 587     if (!This->pin.pConnectedTo)
 588         hr = VFW_E_NOT_CONNECTED;
 589     else
 590     {
 591         hr = IMemAllocator_GetBuffer(This->pAllocator, ppSample, tStart, tStop, dwFlags);
 592
 593         if (SUCCEEDED(hr))
 594             hr = IMediaSample_SetTime(*ppSample, tStart, tStop);
 595     }
 596
 597     return hr;
 598 }
 599
 600 /* replaces OutputPin_SendSample */
 601 HRESULT WINAPI BaseOutputPinImpl_Deliver(BaseOutputPin *This, IMediaSample * pSample)
 602 {
 603     HRESULT hr = S_OK;
 604     IMemInputPin * pMemConnected = NULL;
 605     PIN_INFO pinInfo;
 606
 607     EnterCriticalSection(This->pin.pCritSec);
 608     {
 609         if (!This->pin.pConnectedTo || !This->pMemInputPin)
 610             hr = VFW_E_NOT_CONNECTED;
 611         else
 612         {
 613             /* we don't have the lock held when using This->pMemInputPin,
 614              * so we need to AddRef it to stop it being deleted while we are
 615              * using it. Same with its filter. */
 616             pMemConnected = This->pMemInputPin;
 617             IMemInputPin_AddRef(pMemConnected);
 618             hr = IPin_QueryPinInfo(This->pin.pConnectedTo, &pinInfo);
 619         }
 620     }
 621     LeaveCriticalSection(This->pin.pCritSec);
 622
 623     if (SUCCEEDED(hr))
 624     {
 625         /* NOTE: if we are in a critical section when Receive is called
 626          * then it causes some problems (most notably with the native Video
 627          * Renderer) if we are re-entered for whatever reason */
 628         hr = IMemInputPin_Receive(pMemConnected, pSample);
 629
 630         /* If the filter's destroyed, tell upstream to stop sending data */
 631         if(IBaseFilter_Release(pinInfo.pFilter) == 0 && SUCCEEDED(hr))
 632             hr = S_FALSE;
 633     }
 634     if (pMemConnected)
 635         IMemInputPin_Release(pMemConnected);
 636
 637     return hr;
 638 }
 639
 640 /* replaces OutputPin_CommitAllocator */
 641 HRESULT WINAPI BaseOutputPinImpl_Active(BaseOutputPin *This)
 642 {
 643     HRESULT hr = S_OK;
 644
 645     TRACE("(%p)->()\n", This);
 646
 647     EnterCriticalSection(This->pin.pCritSec);
 648     {
 649         if (!This->pin.pConnectedTo || !This->pMemInputPin)
 650             hr = VFW_E_NOT_CONNECTED;
 651         else
 652             hr = IMemAllocator_Commit(This->pAllocator);
 653     }
 654     LeaveCriticalSection(This->pin.pCritSec);
 655
 656     TRACE("--> %08x\n", hr);
 657     return hr;
 658 }
 659
 660 /* replaces OutputPin_DecommitAllocator */
 661 HRESULT WINAPI BaseOutputPinImpl_Inactive(BaseOutputPin *This)
 662 {
 663     HRESULT hr = S_OK;
 664
 665     TRACE("(%p)->()\n", This);
 666
 667     EnterCriticalSection(This->pin.pCritSec);
 668     {
 669         if (!This->pin.pConnectedTo || !This->pMemInputPin)
 670             hr = VFW_E_NOT_CONNECTED;
 671         else
 672             hr = IMemAllocator_Decommit(This->pAllocator);
 673     }
 674     LeaveCriticalSection(This->pin.pCritSec);
 675
 676     TRACE("--> %08x\n", hr);
 677     return hr;
 678 }
 679
 680 /* replaces OutputPin_DeliverDisconnect */
 681 HRESULT WINAPI BaseOutputPinImpl_BreakConnect(BaseOutputPin *This)
 682 {
 683     HRESULT hr;
 684
 685     TRACE("(%p)->()\n", This);
 686
 687     EnterCriticalSection(This->pin.pCritSec);
 688     {
 689         if (!This->pin.pConnectedTo || !This->pMemInputPin)
 690             hr = VFW_E_NOT_CONNECTED;
 691         else
 692         {
 693             hr = IMemAllocator_Decommit(This->pAllocator);
 694
 695             if (SUCCEEDED(hr))
 696                 hr = IPin_Disconnect(This->pin.pConnectedTo);
 697         }
 698         IPin_Disconnect(&This->pin.IPin_iface);
 699     }
 700     LeaveCriticalSection(This->pin.pCritSec);
 701
 702     return hr;
 703 }
 704
 705 HRESULT WINAPI BaseOutputPinImpl_InitAllocator(BaseOutputPin *This, IMemAllocator **pMemAlloc)
 706 {
 707     return CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC_SERVER, &IID_IMemAllocator, (LPVOID*)pMemAlloc);
 708 }
 709
 710 HRESULT WINAPI BaseOutputPinImpl_DecideAllocator(BaseOutputPin *This, IMemInputPin *pPin, IMemAllocator **pAlloc)
 711 {
 712     HRESULT hr;
 713
 714     hr = IMemInputPin_GetAllocator(pPin, pAlloc);
 715
 716     if (hr == VFW_E_NO_ALLOCATOR)
 717         /* Input pin provides no allocator, use standard memory allocator */
 718         hr = BaseOutputPinImpl_InitAllocator(This, pAlloc);
 719
 720     if (SUCCEEDED(hr))
 721     {
 722         ALLOCATOR_PROPERTIES rProps;
 723         ZeroMemory(&rProps, sizeof(ALLOCATOR_PROPERTIES));
 724
 725         IMemInputPin_GetAllocatorRequirements(pPin, &rProps);
 726         hr = This->pFuncsTable->pfnDecideBufferSize(This, *pAlloc, &rProps);
 727     }
 728
 729     if (SUCCEEDED(hr))
 730         hr = IMemInputPin_NotifyAllocator(pPin, *pAlloc, FALSE);
 731
 732     return hr;
 733 }
 734
 735 /*** The Construct functions ***/
 736
 737 /* Function called as a helper to IPin_Connect */
 738 /* specific AM_MEDIA_TYPE - it cannot be NULL */
 739 HRESULT WINAPI BaseOutputPinImpl_AttemptConnection(BasePin* iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 740 {
 741     BaseOutputPin *This = impl_BaseOutputPin_from_BasePin(iface);
 742     HRESULT hr;
 743     IMemAllocator * pMemAlloc = NULL;
 744
 745     TRACE("(%p, %p)\n", pReceivePin, pmt);
 746     dump_AM_MEDIA_TYPE(pmt);
 747
 748     /* FIXME: call queryacceptproc */
 749
 750     This->pin.pConnectedTo = pReceivePin;
 751     IPin_AddRef(pReceivePin);
 752     CopyMediaType(&This->pin.mtCurrent, pmt);
 753
 754     hr = IPin_ReceiveConnection(pReceivePin, &iface->IPin_iface, pmt);
 755
 756     /* get the IMemInputPin interface we will use to deliver samples to the
 757      * connected pin */
 758     if (SUCCEEDED(hr))
 759     {
 760         This->pMemInputPin = NULL;
 761         hr = IPin_QueryInterface(pReceivePin, &IID_IMemInputPin, (LPVOID)&This->pMemInputPin);
 762
 763         if (SUCCEEDED(hr))
 764         {
 765             hr = This->pFuncsTable->pfnDecideAllocator(This, This->pMemInputPin, &pMemAlloc);
 766             if (SUCCEEDED(hr))
 767                 This->pAllocator = pMemAlloc;
 768             else if (pMemAlloc)
 769                 IMemAllocator_Release(pMemAlloc);
 770         }
 771
 772         /* break connection if we couldn't get the allocator */
 773         if (FAILED(hr))
 774         {
 775             if (This->pMemInputPin)
 776                 IMemInputPin_Release(This->pMemInputPin);
 777             This->pMemInputPin = NULL;
 778
 779             IPin_Disconnect(pReceivePin);
 780         }
 781     }
 782
 783     if (FAILED(hr))
 784     {
 785         IPin_Release(This->pin.pConnectedTo);
 786         This->pin.pConnectedTo = NULL;
 787         FreeMediaType(&This->pin.mtCurrent);
 788     }
 789
 790     TRACE(" -- %x\n", hr);
 791     return hr;
 792 }
 793
 794 static HRESULT OutputPin_Init(const IPinVtbl *OutputPin_Vtbl, const PIN_INFO * pPinInfo, const BaseOutputPinFuncTable* vtbl,  LPCRITICAL_SECTION pCritSec, BaseOutputPin * pPinImpl)
 795 {
 796     TRACE("\n");
 797
 798     /* Common attributes */
 799     pPinImpl->pin.IPin_iface.lpVtbl = OutputPin_Vtbl;
 800     pPinImpl->pin.refCount = 1;
 801     pPinImpl->pin.pConnectedTo = NULL;
 802     pPinImpl->pin.pCritSec = pCritSec;
 803     pPinImpl->pin.tStart = 0;
 804     pPinImpl->pin.tStop = 0;
 805     pPinImpl->pin.dRate = 1.0;
 806     Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
 807     pPinImpl->pin.pFuncsTable = &vtbl->base;
 808     ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE));
 809
 810     /* Output pin attributes */
 811     pPinImpl->pMemInputPin = NULL;
 812     pPinImpl->pAllocator = NULL;
 813     pPinImpl->pFuncsTable = vtbl;
 814
 815     return S_OK;
 816 }
 817
 818 HRESULT WINAPI BaseOutputPin_Construct(const IPinVtbl *OutputPin_Vtbl, LONG outputpin_size, const PIN_INFO * pPinInfo, const BaseOutputPinFuncTable* vtbl, LPCRITICAL_SECTION pCritSec, IPin ** ppPin)
 819 {
 820     BaseOutputPin * pPinImpl;
 821
 822     *ppPin = NULL;
 823
 824     if (pPinInfo->dir != PINDIR_OUTPUT)
 825     {
 826         ERR("Pin direction(%x) != PINDIR_OUTPUT\n", pPinInfo->dir);
 827         return E_INVALIDARG;
 828     }
 829
 830     assert(outputpin_size >= sizeof(BaseOutputPin));
 831     assert(vtbl->base.pfnAttemptConnection);
 832
 833     pPinImpl = CoTaskMemAlloc(outputpin_size);
 834
 835     if (!pPinImpl)
 836         return E_OUTOFMEMORY;
 837
 838     if (SUCCEEDED(OutputPin_Init(OutputPin_Vtbl, pPinInfo, vtbl, pCritSec, pPinImpl)))
 839     {
 840         *ppPin = &pPinImpl->pin.IPin_iface;
 841         return S_OK;
 842     }
 843
 844     CoTaskMemFree(pPinImpl);
 845     return E_FAIL;
 846 }
 847
 848 HRESULT WINAPI BaseOutputPin_Destroy(BaseOutputPin *This)
 849 {
 850     FreeMediaType(&This->pin.mtCurrent);
 851     if (This->pAllocator)
 852         IMemAllocator_Release(This->pAllocator);
 853     This->pAllocator = NULL;
 854     CoTaskMemFree(This);
 855     return S_OK;
 856 }
 857
 858 /*** Input Pin implementation ***/
 859
 860 static inline BaseInputPin *impl_BaseInputPin_from_IPin( IPin *iface )
 861 {
 862     return CONTAINING_RECORD(iface, BaseInputPin, pin.IPin_iface);
 863 }
 864
 865 static inline BaseInputPin *impl_BaseInputPin_from_BasePin( BasePin *iface )
 866 {
 867     return CONTAINING_RECORD(iface, BaseInputPin, pin);
 868 }
 869
 870 HRESULT WINAPI BaseInputPinImpl_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
 871 {
 872     BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
 873
 874     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 875
 876     *ppv = NULL;
 877
 878     if (IsEqualIID(riid, &IID_IUnknown))
 879         *ppv = iface;
 880     else if (IsEqualIID(riid, &IID_IPin))
 881         *ppv = iface;
 882     else if (IsEqualIID(riid, &IID_IMemInputPin))
 883         *ppv = &This->IMemInputPin_iface;
 884     else if (IsEqualIID(riid, &IID_IMediaSeeking))
 885     {
 886         return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv);
 887     }
 888
 889     if (*ppv)
 890     {
 891         IUnknown_AddRef((IUnknown *)(*ppv));
 892         return S_OK;
 893     }
 894
 895     FIXME("No interface for %s!\n", debugstr_guid(riid));
 896
 897     return E_NOINTERFACE;
 898 }
 899
 900 ULONG WINAPI BaseInputPinImpl_Release(IPin * iface)
 901 {
 902     BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
 903     ULONG refCount = InterlockedDecrement(&This->pin.refCount);
 904
 905     TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
 906
 907     if (!refCount)
 908     {
 909         BaseInputPin_Destroy(This);
 910         return 0;
 911     }
 912     else
 913         return refCount;
 914 }
 915
 916 HRESULT WINAPI BaseInputPinImpl_Connect(IPin * iface, IPin * pConnector, const AM_MEDIA_TYPE * pmt)
 917 {
 918     ERR("Outgoing connection on an input pin! (%p, %p)\n", pConnector, pmt);
 919
 920     return E_UNEXPECTED;
 921 }
 922
 923
 924 HRESULT WINAPI BaseInputPinImpl_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 925 {
 926     BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
 927     PIN_DIRECTION pindirReceive;
 928     HRESULT hr = S_OK;
 929
 930     TRACE("(%p, %p)\n", pReceivePin, pmt);
 931     dump_AM_MEDIA_TYPE(pmt);
 932
 933     EnterCriticalSection(This->pin.pCritSec);
 934     {
 935         if (This->pin.pConnectedTo)
 936             hr = VFW_E_ALREADY_CONNECTED;
 937
 938         if (SUCCEEDED(hr) && This->pin.pFuncsTable->pfnCheckMediaType(&This->pin, pmt) != S_OK)
 939             hr = VFW_E_TYPE_NOT_ACCEPTED; /* FIXME: shouldn't we just map common errors onto
 940                                            * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */
 941
 942         if (SUCCEEDED(hr))
 943         {
 944             IPin_QueryDirection(pReceivePin, &pindirReceive);
 945
 946             if (pindirReceive != PINDIR_OUTPUT)
 947             {
 948                 ERR("Can't connect from non-output pin\n");
 949                 hr = VFW_E_INVALID_DIRECTION;
 950             }
 951         }
 952
 953         if (SUCCEEDED(hr))
 954         {
 955             CopyMediaType(&This->pin.mtCurrent, pmt);
 956             This->pin.pConnectedTo = pReceivePin;
 957             IPin_AddRef(pReceivePin);
 958         }
 959     }
 960     LeaveCriticalSection(This->pin.pCritSec);
 961
 962     return hr;
 963 }
 964
 965 static HRESULT deliver_endofstream(IPin* pin, LPVOID unused)
 966 {
 967     return IPin_EndOfStream( pin );
 968 }
 969
 970 HRESULT WINAPI BaseInputPinImpl_QueryAccept(IPin * iface, const AM_MEDIA_TYPE * pmt)
 971 {
 972     BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
 973
 974     TRACE("(%p/%p)->(%p)\n", This, iface, pmt);
 975
 976     return (This->pin.pFuncsTable->pfnCheckMediaType(&This->pin, pmt) == S_OK ? S_OK : S_FALSE);
 977 }
 978
 979 HRESULT WINAPI BaseInputPinImpl_EndOfStream(IPin * iface)
 980 {
 981     HRESULT hr = S_OK;
 982     BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
 983
 984     TRACE("(%p)\n", This);
 985
 986     EnterCriticalSection(This->pin.pCritSec);
 987     if (This->flushing)
 988         hr = S_FALSE;
 989     else
 990         This->end_of_stream = TRUE;
 991     LeaveCriticalSection(This->pin.pCritSec);
 992
 993     if (hr == S_OK)
 994         hr = SendFurther( iface, deliver_endofstream, NULL, NULL );
 995     return hr;
 996 }
 997
 998 static HRESULT deliver_beginflush(IPin* pin, LPVOID unused)
 999 {
1000     return IPin_BeginFlush( pin );
1001 }
1002
1003 HRESULT WINAPI BaseInputPinImpl_BeginFlush(IPin * iface)
1004 {
1005     BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
1006     HRESULT hr;
1007     TRACE("() semi-stub\n");
1008
1009     EnterCriticalSection(This->pin.pCritSec);
1010     This->flushing = TRUE;
1011
1012     hr = SendFurther( iface, deliver_beginflush, NULL, NULL );
1013     LeaveCriticalSection(This->pin.pCritSec);
1014
1015     return hr;
1016 }
1017
1018 static HRESULT deliver_endflush(IPin* pin, LPVOID unused)
1019 {
1020     return IPin_EndFlush( pin );
1021 }
1022
1023 HRESULT WINAPI BaseInputPinImpl_EndFlush(IPin * iface)
1024 {
1025     BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
1026     HRESULT hr;
1027     TRACE("(%p)\n", This);
1028
1029     EnterCriticalSection(This->pin.pCritSec);
1030     This->flushing = This->end_of_stream = FALSE;
1031
1032     hr = SendFurther( iface, deliver_endflush, NULL, NULL );
1033     LeaveCriticalSection(This->pin.pCritSec);
1034
1035     return hr;
1036 }
1037
1038 typedef struct newsegmentargs
1039 {
1040     REFERENCE_TIME tStart, tStop;
1041     double rate;
1042 } newsegmentargs;
1043
1044 static HRESULT deliver_newsegment(IPin *pin, LPVOID data)
1045 {
1046     newsegmentargs *args = data;
1047     return IPin_NewSegment(pin, args->tStart, args->tStop, args->rate);
1048 }
1049
1050 HRESULT WINAPI BaseInputPinImpl_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
1051 {
1052     BaseInputPin *This = impl_BaseInputPin_from_IPin(iface);
1053     newsegmentargs args;
1054
1055     TRACE("(%x%08x, %x%08x, %e)\n", (ULONG)(tStart >> 32), (ULONG)tStart, (ULONG)(tStop >> 32), (ULONG)tStop, dRate);
1056
1057     args.tStart = This->pin.tStart = tStart;
1058     args.tStop = This->pin.tStop = tStop;
1059     args.rate = This->pin.dRate = dRate;
1060
1061     return SendFurther( iface, deliver_newsegment, &args, NULL );
1062 }
1063
1064 static const IPinVtbl InputPin_Vtbl =
1065 {
1066     BaseInputPinImpl_QueryInterface,
1067     BasePinImpl_AddRef,
1068     BaseInputPinImpl_Release,
1069     BaseInputPinImpl_Connect,
1070     BaseInputPinImpl_ReceiveConnection,
1071     BasePinImpl_Disconnect,
1072     BasePinImpl_ConnectedTo,
1073     BasePinImpl_ConnectionMediaType,
1074     BasePinImpl_QueryPinInfo,
1075     BasePinImpl_QueryDirection,
1076     BasePinImpl_QueryId,
1077     BaseInputPinImpl_QueryAccept,
1078     BasePinImpl_EnumMediaTypes,
1079     BasePinImpl_QueryInternalConnections,
1080     BaseInputPinImpl_EndOfStream,
1081     BaseInputPinImpl_BeginFlush,
1082     BaseInputPinImpl_EndFlush,
1083     BaseInputPinImpl_NewSegment
1084 };
1085
1086 /*** IMemInputPin implementation ***/
1087
1088 static inline BaseInputPin *impl_from_IMemInputPin( IMemInputPin *iface )
1089 {
1090     return CONTAINING_RECORD(iface, BaseInputPin, IMemInputPin_iface);
1091 }
1092
1093 static HRESULT WINAPI MemInputPin_QueryInterface(IMemInputPin * iface, REFIID riid, LPVOID * ppv)
1094 {
1095     BaseInputPin *This = impl_from_IMemInputPin(iface);
1096
1097     return IPin_QueryInterface(&This->pin.IPin_iface, riid, ppv);
1098 }
1099
1100 static ULONG WINAPI MemInputPin_AddRef(IMemInputPin * iface)
1101 {
1102     BaseInputPin *This = impl_from_IMemInputPin(iface);
1103
1104     return IPin_AddRef(&This->pin.IPin_iface);
1105 }
1106
1107 static ULONG WINAPI MemInputPin_Release(IMemInputPin * iface)
1108 {
1109     BaseInputPin *This = impl_from_IMemInputPin(iface);
1110
1111     return IPin_Release(&This->pin.IPin_iface);
1112 }
1113
1114 static HRESULT WINAPI MemInputPin_GetAllocator(IMemInputPin * iface, IMemAllocator ** ppAllocator)
1115 {
1116     BaseInputPin *This = impl_from_IMemInputPin(iface);
1117
1118     TRACE("(%p/%p)->(%p)\n", This, iface, ppAllocator);
1119
1120     *ppAllocator = This->pAllocator;
1121     if (*ppAllocator)
1122         IMemAllocator_AddRef(*ppAllocator);
1123
1124     return *ppAllocator ? S_OK : VFW_E_NO_ALLOCATOR;
1125 }
1126
1127 static HRESULT WINAPI MemInputPin_NotifyAllocator(IMemInputPin * iface, IMemAllocator * pAllocator, BOOL bReadOnly)
1128 {
1129     BaseInputPin *This = impl_from_IMemInputPin(iface);
1130
1131     TRACE("(%p/%p)->(%p, %d)\n", This, iface, pAllocator, bReadOnly);
1132
1133     if (bReadOnly)
1134         FIXME("Read only flag not handled yet!\n");
1135
1136     /* FIXME: Should we release the allocator on disconnection? */
1137     if (!pAllocator)
1138     {
1139         WARN("Null allocator\n");
1140         return E_POINTER;
1141     }
1142
1143     if (This->preferred_allocator && pAllocator != This->preferred_allocator)
1144         return E_FAIL;
1145
1146     if (This->pAllocator)
1147         IMemAllocator_Release(This->pAllocator);
1148     This->pAllocator = pAllocator;
1149     if (This->pAllocator)
1150         IMemAllocator_AddRef(This->pAllocator);
1151
1152     return S_OK;
1153 }
1154
1155 static HRESULT WINAPI MemInputPin_GetAllocatorRequirements(IMemInputPin * iface, ALLOCATOR_PROPERTIES * pProps)
1156 {
1157     BaseInputPin *This = impl_from_IMemInputPin(iface);
1158
1159     TRACE("(%p/%p)->(%p)\n", This, iface, pProps);
1160
1161     /* override this method if you have any specific requirements */
1162
1163     return E_NOTIMPL;
1164 }
1165
1166 static HRESULT WINAPI MemInputPin_Receive(IMemInputPin * iface, IMediaSample * pSample)
1167 {
1168     BaseInputPin *This = impl_from_IMemInputPin(iface);
1169     HRESULT hr = S_FALSE;
1170
1171     /* this trace commented out for performance reasons */
1172     /*TRACE("(%p/%p)->(%p)\n", This, iface, pSample);*/
1173     if (This->pFuncsTable->pfnReceive)
1174         hr = This->pFuncsTable->pfnReceive(This, pSample);
1175     return hr;
1176 }
1177
1178 static HRESULT WINAPI MemInputPin_ReceiveMultiple(IMemInputPin * iface, IMediaSample ** pSamples, LONG nSamples, LONG *nSamplesProcessed)
1179 {
1180     HRESULT hr = S_OK;
1181     BaseInputPin *This = impl_from_IMemInputPin(iface);
1182
1183     TRACE("(%p/%p)->(%p, %d, %p)\n", This, iface, pSamples, nSamples, nSamplesProcessed);
1184
1185     for (*nSamplesProcessed = 0; *nSamplesProcessed < nSamples; (*nSamplesProcessed)++)
1186     {
1187         hr = IMemInputPin_Receive(iface, pSamples[*nSamplesProcessed]);
1188         if (hr != S_OK)
1189             break;
1190     }
1191
1192     return hr;
1193 }
1194
1195 static HRESULT WINAPI MemInputPin_ReceiveCanBlock(IMemInputPin * iface)
1196 {
1197     BaseInputPin *This = impl_from_IMemInputPin(iface);
1198
1199     TRACE("(%p/%p)->()\n", This, iface);
1200
1201     return S_OK;
1202 }
1203
1204 static const IMemInputPinVtbl MemInputPin_Vtbl =
1205 {
1206     MemInputPin_QueryInterface,
1207     MemInputPin_AddRef,
1208     MemInputPin_Release,
1209     MemInputPin_GetAllocator,
1210     MemInputPin_NotifyAllocator,
1211     MemInputPin_GetAllocatorRequirements,
1212     MemInputPin_Receive,
1213     MemInputPin_ReceiveMultiple,
1214     MemInputPin_ReceiveCanBlock
1215 };
1216
1217 static HRESULT InputPin_Init(const IPinVtbl *InputPin_Vtbl, const PIN_INFO * pPinInfo,
1218                              const BaseInputPinFuncTable* vtbl,
1219                              LPCRITICAL_SECTION pCritSec, IMemAllocator *allocator, BaseInputPin * pPinImpl)
1220 {
1221     TRACE("\n");
1222
1223     /* Common attributes */
1224     pPinImpl->pin.refCount = 1;
1225     pPinImpl->pin.pConnectedTo = NULL;
1226     pPinImpl->pin.pCritSec = pCritSec;
1227     pPinImpl->pin.tStart = 0;
1228     pPinImpl->pin.tStop = 0;
1229     pPinImpl->pin.dRate = 1.0;
1230     Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
1231     ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE));
1232     pPinImpl->pin.pFuncsTable = &vtbl->base;
1233
1234     /* Input pin attributes */
1235     pPinImpl->pFuncsTable = vtbl;
1236     pPinImpl->pAllocator = pPinImpl->preferred_allocator = allocator;
1237     if (pPinImpl->preferred_allocator)
1238         IMemAllocator_AddRef(pPinImpl->preferred_allocator);
1239     pPinImpl->pin.IPin_iface.lpVtbl = InputPin_Vtbl;
1240     pPinImpl->IMemInputPin_iface.lpVtbl = &MemInputPin_Vtbl;
1241     pPinImpl->flushing = pPinImpl->end_of_stream = FALSE;
1242
1243     return S_OK;
1244 }
1245
1246 HRESULT BaseInputPin_Construct(const IPinVtbl *InputPin_Vtbl, LONG inputpin_size, const PIN_INFO * pPinInfo,
1247                                const BaseInputPinFuncTable* vtbl,
1248                                LPCRITICAL_SECTION pCritSec, IMemAllocator *allocator, IPin ** ppPin)
1249 {
1250     BaseInputPin * pPinImpl;
1251
1252     *ppPin = NULL;
1253
1254     assert(inputpin_size >= sizeof(BaseInputPin));
1255     assert(vtbl->base.pfnCheckMediaType);
1256
1257     if (pPinInfo->dir != PINDIR_INPUT)
1258     {
1259         ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir);
1260         return E_INVALIDARG;
1261     }
1262
1263     pPinImpl = CoTaskMemAlloc(inputpin_size);
1264
1265     if (!pPinImpl)
1266         return E_OUTOFMEMORY;
1267
1268     if (SUCCEEDED(InputPin_Init(InputPin_Vtbl, pPinInfo, vtbl, pCritSec, allocator, pPinImpl)))
1269     {
1270         *ppPin = (IPin *)pPinImpl;
1271         return S_OK;
1272     }
1273
1274     CoTaskMemFree(pPinImpl);
1275     return E_FAIL;
1276 }
1277
1278 HRESULT WINAPI BaseInputPin_Destroy(BaseInputPin *This)
1279 {
1280     FreeMediaType(&This->pin.mtCurrent);
1281     if (This->pAllocator)
1282         IMemAllocator_Release(This->pAllocator);
1283     This->pAllocator = NULL;
1284     This->pin.IPin_iface.lpVtbl = NULL;
1285     CoTaskMemFree(This);
1286     return S_OK;
1287 }