dlls/quartz/pin.c

   1 /*
   2  * Generic Implementation of IPin Interface
   3  *
   4  * Copyright 2003 Robert Shearman
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "quartz_private.h"
  22 #include "pin.h"
  23
  24 #include "wine/debug.h"
  25 #include "wine/unicode.h"
  26 #include "uuids.h"
  27 #include "vfwmsgs.h"
  28 #include <assert.h>
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  31
  32 static const IPinVtbl InputPin_Vtbl;
  33 static const IPinVtbl OutputPin_Vtbl;
  34 static const IMemInputPinVtbl MemInputPin_Vtbl;
  35 static const IPinVtbl PullPin_Vtbl;
  36
  37 #define ALIGNDOWN(value,boundary) ((value)/(boundary)*(boundary))
  38 #define ALIGNUP(value,boundary) (ALIGNDOWN((value)+(boundary)-1, (boundary)))
  39
  40 typedef HRESULT (*SendPinFunc)( IPin *to, LPVOID arg );
  41
  42 /** Helper function, there are a lot of places where the error code is inherited
  43  * The following rules apply:
  44  *
  45  * Return the first received error code (E_NOTIMPL is ignored)
  46  * If no errors occur: return the first received non-error-code that isn't S_OK
  47  */
  48 HRESULT updatehres( HRESULT original, HRESULT new )
  49 {
  50     if (FAILED( original ) || new == E_NOTIMPL)
  51         return original;
  52
  53     if (FAILED( new ) || original == S_OK)
  54         return new;
  55
  56     return original;
  57 }
  58
  59 /** Sends a message from a pin further to other, similar pins
  60  * fnMiddle is called on each pin found further on the stream.
  61  * fnEnd (can be NULL) is called when the message can't be sent any further (this is a renderer or source)
  62  *
  63  * If the pin given is an input pin, the message will be sent downstream to other input pins
  64  * If the pin given is an output pin, the message will be sent upstream to other output pins
  65  */
  66 static HRESULT SendFurther( IPin *from, SendPinFunc fnMiddle, LPVOID arg, SendPinFunc fnEnd )
  67 {
  68     PIN_INFO pin_info;
  69     ULONG amount = 0;
  70     HRESULT hr = S_OK;
  71     HRESULT hr_return = S_OK;
  72     IEnumPins *enumpins = NULL;
  73     BOOL foundend = TRUE;
  74     PIN_DIRECTION from_dir;
  75
  76     IPin_QueryDirection( from, &from_dir );
  77
  78     hr = IPin_QueryInternalConnections( from, NULL, &amount );
  79     if (hr != E_NOTIMPL && amount)
  80         FIXME("Use QueryInternalConnections!\n");
  81      hr = S_OK;
  82
  83     pin_info.pFilter = NULL;
  84     hr = IPin_QueryPinInfo( from, &pin_info );
  85     if (FAILED(hr))
  86         goto out;
  87
  88     hr = IBaseFilter_EnumPins( pin_info.pFilter, &enumpins );
  89     if (FAILED(hr))
  90         goto out;
  91
  92     hr = IEnumPins_Reset( enumpins );
  93     while (hr == S_OK) {
  94         IPin *pin = NULL;
  95         hr = IEnumPins_Next( enumpins, 1, &pin, NULL );
  96         if (hr == VFW_E_ENUM_OUT_OF_SYNC)
  97         {
  98             hr = IEnumPins_Reset( enumpins );
  99             continue;
 100         }
 101         if (pin)
 102         {
 103             PIN_DIRECTION dir;
 104
 105             IPin_QueryDirection( pin, &dir );
 106             if (dir != from_dir)
 107             {
 108                 IPin *connected = NULL;
 109
 110                 foundend = FALSE;
 111                 IPin_ConnectedTo( pin, &connected );
 112                 if (connected)
 113                 {
 114                     HRESULT hr_local;
 115
 116                     hr_local = fnMiddle( connected, arg );
 117                     hr_return = updatehres( hr_return, hr_local );
 118                     IPin_Release(connected);
 119                 }
 120             }
 121             IPin_Release( pin );
 122         }
 123         else
 124         {
 125             hr = S_OK;
 126             break;
 127         }
 128     }
 129
 130     if (!foundend)
 131         hr = hr_return;
 132     else if (fnEnd) {
 133         HRESULT hr_local;
 134
 135         hr_local = fnEnd( from, arg );
 136         hr_return = updatehres( hr_return, hr_local );
 137     }
 138
 139 out:
 140     if (pin_info.pFilter)
 141         IBaseFilter_Release( pin_info.pFilter );
 142     return hr;
 143 }
 144
 145 static inline InputPin *impl_from_IMemInputPin( IMemInputPin *iface )
 146 {
 147     return (InputPin *)((char*)iface - FIELD_OFFSET(InputPin, lpVtblMemInput));
 148 }
 149
 150
 151 static void Copy_PinInfo(PIN_INFO * pDest, const PIN_INFO * pSrc)
 152 {
 153     /* Tempting to just do a memcpy, but the name field is
 154        128 characters long! We will probably never exceed 10
 155        most of the time, so we are better off copying
 156        each field manually */
 157     strcpyW(pDest->achName, pSrc->achName);
 158     pDest->dir = pSrc->dir;
 159     pDest->pFilter = pSrc->pFilter;
 160 }
 161
 162 /* Function called as a helper to IPin_Connect */
 163 /* specific AM_MEDIA_TYPE - it cannot be NULL */
 164 /* NOTE: not part of standard interface */
 165 static HRESULT OutputPin_ConnectSpecific(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 166 {
 167     OutputPin *This = (OutputPin *)iface;
 168     HRESULT hr;
 169     IMemAllocator * pMemAlloc = NULL;
 170     ALLOCATOR_PROPERTIES actual; /* FIXME: should we put the actual props back in to This? */
 171
 172     TRACE("(%p, %p)\n", pReceivePin, pmt);
 173     dump_AM_MEDIA_TYPE(pmt);
 174
 175     /* FIXME: call queryacceptproc */
 176
 177     This->pin.pConnectedTo = pReceivePin;
 178     IPin_AddRef(pReceivePin);
 179     CopyMediaType(&This->pin.mtCurrent, pmt);
 180
 181     hr = IPin_ReceiveConnection(pReceivePin, iface, pmt);
 182
 183     /* get the IMemInputPin interface we will use to deliver samples to the
 184      * connected pin */
 185     if (SUCCEEDED(hr))
 186     {
 187         This->pMemInputPin = NULL;
 188         hr = IPin_QueryInterface(pReceivePin, &IID_IMemInputPin, (LPVOID)&This->pMemInputPin);
 189
 190         if (SUCCEEDED(hr) && !This->custom_allocator)
 191         {
 192             hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pMemAlloc);
 193
 194             if (hr == VFW_E_NO_ALLOCATOR)
 195                 /* Input pin provides no allocator, use standard memory allocator */
 196                 hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC_SERVER, &IID_IMemAllocator, (LPVOID*)&pMemAlloc);
 197
 198             if (SUCCEEDED(hr))
 199                 hr = IMemAllocator_SetProperties(pMemAlloc, &This->allocProps, &actual);
 200
 201             if (SUCCEEDED(hr))
 202                 hr = IMemInputPin_NotifyAllocator(This->pMemInputPin, pMemAlloc, This->readonly);
 203
 204             if (pMemAlloc)
 205                 IMemAllocator_Release(pMemAlloc);
 206         }
 207         else if (SUCCEEDED(hr))
 208         {
 209             if (This->alloc)
 210             {
 211                 hr = IMemInputPin_NotifyAllocator(This->pMemInputPin, This->alloc, This->readonly);
 212             }
 213             else
 214                 hr = VFW_E_NO_ALLOCATOR;
 215         }
 216
 217         /* break connection if we couldn't get the allocator */
 218         if (FAILED(hr))
 219         {
 220             if (This->pMemInputPin)
 221                 IMemInputPin_Release(This->pMemInputPin);
 222             This->pMemInputPin = NULL;
 223
 224             IPin_Disconnect(pReceivePin);
 225         }
 226     }
 227
 228     if (FAILED(hr))
 229     {
 230         IPin_Release(This->pin.pConnectedTo);
 231         This->pin.pConnectedTo = NULL;
 232         FreeMediaType(&This->pin.mtCurrent);
 233     }
 234
 235     TRACE(" -- %x\n", hr);
 236     return hr;
 237 }
 238
 239 static HRESULT InputPin_Init(const IPinVtbl *InputPin_Vtbl, const PIN_INFO * pPinInfo, SAMPLEPROC_PUSH pSampleProc, LPVOID pUserData,
 240                              QUERYACCEPTPROC pQueryAccept, CLEANUPPROC pCleanUp, LPCRITICAL_SECTION pCritSec, IMemAllocator *allocator, InputPin * pPinImpl)
 241 {
 242     TRACE("\n");
 243
 244     /* Common attributes */
 245     pPinImpl->pin.refCount = 1;
 246     pPinImpl->pin.pConnectedTo = NULL;
 247     pPinImpl->pin.fnQueryAccept = pQueryAccept;
 248     pPinImpl->pin.pUserData = pUserData;
 249     pPinImpl->pin.pCritSec = pCritSec;
 250     Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
 251     ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE));
 252
 253     /* Input pin attributes */
 254     pPinImpl->fnSampleProc = pSampleProc;
 255     pPinImpl->fnCleanProc = pCleanUp;
 256     pPinImpl->pAllocator = pPinImpl->preferred_allocator = allocator;
 257     if (pPinImpl->preferred_allocator)
 258         IMemAllocator_AddRef(pPinImpl->preferred_allocator);
 259     pPinImpl->tStart = 0;
 260     pPinImpl->tStop = 0;
 261     pPinImpl->dRate = 1.0;
 262     pPinImpl->pin.lpVtbl = InputPin_Vtbl;
 263     pPinImpl->lpVtblMemInput = &MemInputPin_Vtbl;
 264     pPinImpl->flushing = pPinImpl->end_of_stream = 0;
 265
 266     return S_OK;
 267 }
 268
 269 static HRESULT OutputPin_Init(const IPinVtbl *OutputPin_Vtbl, const PIN_INFO * pPinInfo, const ALLOCATOR_PROPERTIES * props, LPVOID pUserData,
 270                               QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, OutputPin * pPinImpl)
 271 {
 272     TRACE("\n");
 273
 274     /* Common attributes */
 275     pPinImpl->pin.lpVtbl = OutputPin_Vtbl;
 276     pPinImpl->pin.refCount = 1;
 277     pPinImpl->pin.pConnectedTo = NULL;
 278     pPinImpl->pin.fnQueryAccept = pQueryAccept;
 279     pPinImpl->pin.pUserData = pUserData;
 280     pPinImpl->pin.pCritSec = pCritSec;
 281     Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
 282     ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE));
 283
 284     /* Output pin attributes */
 285     pPinImpl->pMemInputPin = NULL;
 286     pPinImpl->pConnectSpecific = OutputPin_ConnectSpecific;
 287     /* If custom_allocator is set, you will need to specify an allocator
 288      * in the alloc member of the struct before an output pin can connect
 289      */
 290     pPinImpl->custom_allocator = 0;
 291     pPinImpl->alloc = NULL;
 292     pPinImpl->readonly = FALSE;
 293     if (props)
 294     {
 295         pPinImpl->allocProps = *props;
 296         if (pPinImpl->allocProps.cbAlign == 0)
 297             pPinImpl->allocProps.cbAlign = 1;
 298     }
 299     else
 300         ZeroMemory(&pPinImpl->allocProps, sizeof(pPinImpl->allocProps));
 301
 302     return S_OK;
 303 }
 304
 305 HRESULT InputPin_Construct(const IPinVtbl *InputPin_Vtbl, const PIN_INFO * pPinInfo, SAMPLEPROC_PUSH pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, CLEANUPPROC pCleanUp, LPCRITICAL_SECTION pCritSec, IMemAllocator *allocator, IPin ** ppPin)
 306 {
 307     InputPin * pPinImpl;
 308
 309     *ppPin = NULL;
 310
 311     if (pPinInfo->dir != PINDIR_INPUT)
 312     {
 313         ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir);
 314         return E_INVALIDARG;
 315     }
 316
 317     pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl));
 318
 319     if (!pPinImpl)
 320         return E_OUTOFMEMORY;
 321
 322     if (SUCCEEDED(InputPin_Init(InputPin_Vtbl, pPinInfo, pSampleProc, pUserData, pQueryAccept, pCleanUp, pCritSec, allocator, pPinImpl)))
 323     {
 324         *ppPin = (IPin *)pPinImpl;
 325         return S_OK;
 326     }
 327
 328     CoTaskMemFree(pPinImpl);
 329     return E_FAIL;
 330 }
 331
 332 HRESULT OutputPin_Construct(const IPinVtbl *OutputPin_Vtbl, long outputpin_size, const PIN_INFO * pPinInfo, ALLOCATOR_PROPERTIES *props, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, IPin ** ppPin)
 333 {
 334     OutputPin * pPinImpl;
 335
 336     *ppPin = NULL;
 337
 338     if (pPinInfo->dir != PINDIR_OUTPUT)
 339     {
 340         ERR("Pin direction(%x) != PINDIR_OUTPUT\n", pPinInfo->dir);
 341         return E_INVALIDARG;
 342     }
 343
 344     assert(outputpin_size >= sizeof(OutputPin));
 345
 346     pPinImpl = CoTaskMemAlloc(outputpin_size);
 347
 348     if (!pPinImpl)
 349         return E_OUTOFMEMORY;
 350
 351     if (SUCCEEDED(OutputPin_Init(OutputPin_Vtbl, pPinInfo, props, pUserData, pQueryAccept, pCritSec, pPinImpl)))
 352     {
 353         *ppPin = (IPin *)(&pPinImpl->pin.lpVtbl);
 354         return S_OK;
 355     }
 356
 357     CoTaskMemFree(pPinImpl);
 358     return E_FAIL;
 359 }
 360
 361 /*** Common pin functions ***/
 362
 363 ULONG WINAPI IPinImpl_AddRef(IPin * iface)
 364 {
 365     IPinImpl *This = (IPinImpl *)iface;
 366     ULONG refCount = InterlockedIncrement(&This->refCount);
 367
 368     TRACE("(%p)->() AddRef from %d\n", iface, refCount - 1);
 369
 370     return refCount;
 371 }
 372
 373 HRESULT WINAPI IPinImpl_Disconnect(IPin * iface)
 374 {
 375     HRESULT hr;
 376     IPinImpl *This = (IPinImpl *)iface;
 377
 378     TRACE("()\n");
 379
 380     EnterCriticalSection(This->pCritSec);
 381     {
 382         if (This->pConnectedTo)
 383         {
 384             IPin_Release(This->pConnectedTo);
 385             This->pConnectedTo = NULL;
 386             FreeMediaType(&This->mtCurrent);
 387             ZeroMemory(&This->mtCurrent, sizeof(This->mtCurrent));
 388             hr = S_OK;
 389         }
 390         else
 391             hr = S_FALSE;
 392     }
 393     LeaveCriticalSection(This->pCritSec);
 394
 395     return hr;
 396 }
 397
 398 HRESULT WINAPI IPinImpl_ConnectedTo(IPin * iface, IPin ** ppPin)
 399 {
 400     HRESULT hr;
 401     IPinImpl *This = (IPinImpl *)iface;
 402
 403     TRACE("(%p)\n", ppPin);
 404
 405     EnterCriticalSection(This->pCritSec);
 406     {
 407         if (This->pConnectedTo)
 408         {
 409             *ppPin = This->pConnectedTo;
 410             IPin_AddRef(*ppPin);
 411             hr = S_OK;
 412         }
 413         else
 414         {
 415             hr = VFW_E_NOT_CONNECTED;
 416             *ppPin = NULL;
 417         }
 418     }
 419     LeaveCriticalSection(This->pCritSec);
 420
 421     return hr;
 422 }
 423
 424 HRESULT WINAPI IPinImpl_ConnectionMediaType(IPin * iface, AM_MEDIA_TYPE * pmt)
 425 {
 426     HRESULT hr;
 427     IPinImpl *This = (IPinImpl *)iface;
 428
 429     TRACE("(%p/%p)->(%p)\n", This, iface, pmt);
 430
 431     EnterCriticalSection(This->pCritSec);
 432     {
 433         if (This->pConnectedTo)
 434         {
 435             CopyMediaType(pmt, &This->mtCurrent);
 436             hr = S_OK;
 437         }
 438         else
 439         {
 440             ZeroMemory(pmt, sizeof(*pmt));
 441             hr = VFW_E_NOT_CONNECTED;
 442         }
 443     }
 444     LeaveCriticalSection(This->pCritSec);
 445
 446     return hr;
 447 }
 448
 449 HRESULT WINAPI IPinImpl_QueryPinInfo(IPin * iface, PIN_INFO * pInfo)
 450 {
 451     IPinImpl *This = (IPinImpl *)iface;
 452
 453     TRACE("(%p/%p)->(%p)\n", This, iface, pInfo);
 454
 455     Copy_PinInfo(pInfo, &This->pinInfo);
 456     IBaseFilter_AddRef(pInfo->pFilter);
 457
 458     return S_OK;
 459 }
 460
 461 HRESULT WINAPI IPinImpl_QueryDirection(IPin * iface, PIN_DIRECTION * pPinDir)
 462 {
 463     IPinImpl *This = (IPinImpl *)iface;
 464
 465     TRACE("(%p/%p)->(%p)\n", This, iface, pPinDir);
 466
 467     *pPinDir = This->pinInfo.dir;
 468
 469     return S_OK;
 470 }
 471
 472 HRESULT WINAPI IPinImpl_QueryId(IPin * iface, LPWSTR * Id)
 473 {
 474     IPinImpl *This = (IPinImpl *)iface;
 475
 476     TRACE("(%p/%p)->(%p)\n", This, iface, Id);
 477
 478     *Id = CoTaskMemAlloc((strlenW(This->pinInfo.achName) + 1) * sizeof(WCHAR));
 479     if (!*Id)
 480         return E_OUTOFMEMORY;
 481
 482     strcpyW(*Id, This->pinInfo.achName);
 483
 484     return S_OK;
 485 }
 486
 487 HRESULT WINAPI IPinImpl_QueryAccept(IPin * iface, const AM_MEDIA_TYPE * pmt)
 488 {
 489     IPinImpl *This = (IPinImpl *)iface;
 490
 491     TRACE("(%p/%p)->(%p)\n", This, iface, pmt);
 492
 493     return (This->fnQueryAccept(This->pUserData, pmt) == S_OK ? S_OK : S_FALSE);
 494 }
 495
 496 HRESULT WINAPI IPinImpl_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum)
 497 {
 498     IPinImpl *This = (IPinImpl *)iface;
 499     ENUMMEDIADETAILS emd;
 500
 501     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 502
 503     /* override this method to allow enumeration of your types */
 504     emd.cMediaTypes = 0;
 505     emd.pMediaTypes = NULL;
 506
 507     return IEnumMediaTypesImpl_Construct(&emd, ppEnum);
 508 }
 509
 510 HRESULT WINAPI IPinImpl_QueryInternalConnections(IPin * iface, IPin ** apPin, ULONG * cPin)
 511 {
 512     IPinImpl *This = (IPinImpl *)iface;
 513
 514     TRACE("(%p/%p)->(%p, %p)\n", This, iface, apPin, cPin);
 515
 516     return E_NOTIMPL; /* to tell caller that all input pins connected to all output pins */
 517 }
 518
 519 /*** IPin implementation for an input pin ***/
 520
 521 HRESULT WINAPI InputPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
 522 {
 523     InputPin *This = (InputPin *)iface;
 524
 525     TRACE("(%p)->(%s, %p)\n", iface, qzdebugstr_guid(riid), ppv);
 526
 527     *ppv = NULL;
 528
 529     if (IsEqualIID(riid, &IID_IUnknown))
 530         *ppv = (LPVOID)iface;
 531     else if (IsEqualIID(riid, &IID_IPin))
 532         *ppv = (LPVOID)iface;
 533     else if (IsEqualIID(riid, &IID_IMemInputPin))
 534         *ppv = (LPVOID)&This->lpVtblMemInput;
 535     else if (IsEqualIID(riid, &IID_IMediaSeeking))
 536     {
 537         return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv);
 538     }
 539
 540     if (*ppv)
 541     {
 542         IUnknown_AddRef((IUnknown *)(*ppv));
 543         return S_OK;
 544     }
 545
 546     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 547
 548     return E_NOINTERFACE;
 549 }
 550
 551 ULONG WINAPI InputPin_Release(IPin * iface)
 552 {
 553     InputPin *This = (InputPin *)iface;
 554     ULONG refCount = InterlockedDecrement(&This->pin.refCount);
 555
 556     TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
 557
 558     if (!refCount)
 559     {
 560         FreeMediaType(&This->pin.mtCurrent);
 561         if (This->pAllocator)
 562             IMemAllocator_Release(This->pAllocator);
 563         This->pAllocator = NULL;
 564         This->pin.lpVtbl = NULL;
 565         CoTaskMemFree(This);
 566         return 0;
 567     }
 568     else
 569         return refCount;
 570 }
 571
 572 HRESULT WINAPI InputPin_Connect(IPin * iface, IPin * pConnector, const AM_MEDIA_TYPE * pmt)
 573 {
 574     ERR("Outgoing connection on an input pin! (%p, %p)\n", pConnector, pmt);
 575
 576     return E_UNEXPECTED;
 577 }
 578
 579
 580 HRESULT WINAPI InputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 581 {
 582     InputPin *This = (InputPin *)iface;
 583     PIN_DIRECTION pindirReceive;
 584     HRESULT hr = S_OK;
 585
 586     TRACE("(%p, %p)\n", pReceivePin, pmt);
 587     dump_AM_MEDIA_TYPE(pmt);
 588
 589     EnterCriticalSection(This->pin.pCritSec);
 590     {
 591         if (This->pin.pConnectedTo)
 592             hr = VFW_E_ALREADY_CONNECTED;
 593
 594         if (SUCCEEDED(hr) && This->pin.fnQueryAccept(This->pin.pUserData, pmt) != S_OK)
 595             hr = VFW_E_TYPE_NOT_ACCEPTED; /* FIXME: shouldn't we just map common errors onto
 596                                            * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */
 597
 598         if (SUCCEEDED(hr))
 599         {
 600             IPin_QueryDirection(pReceivePin, &pindirReceive);
 601
 602             if (pindirReceive != PINDIR_OUTPUT)
 603             {
 604                 ERR("Can't connect from non-output pin\n");
 605                 hr = VFW_E_INVALID_DIRECTION;
 606             }
 607         }
 608
 609         if (SUCCEEDED(hr))
 610         {
 611             CopyMediaType(&This->pin.mtCurrent, pmt);
 612             This->pin.pConnectedTo = pReceivePin;
 613             IPin_AddRef(pReceivePin);
 614         }
 615     }
 616     LeaveCriticalSection(This->pin.pCritSec);
 617
 618     return hr;
 619 }
 620
 621 static HRESULT deliver_endofstream(IPin* pin, LPVOID unused)
 622 {
 623     return IPin_EndOfStream( pin );
 624 }
 625
 626 HRESULT WINAPI InputPin_EndOfStream(IPin * iface)
 627 {
 628     HRESULT hr = S_OK;
 629     InputPin *This = (InputPin *)iface;
 630
 631     TRACE("(%p)\n", This);
 632
 633     EnterCriticalSection(This->pin.pCritSec);
 634     if (This->flushing)
 635         hr = S_FALSE;
 636     else
 637         This->end_of_stream = 1;
 638     LeaveCriticalSection(This->pin.pCritSec);
 639
 640     if (hr == S_OK)
 641         hr = SendFurther( iface, deliver_endofstream, NULL, NULL );
 642     return hr;
 643 }
 644
 645 static HRESULT deliver_beginflush(IPin* pin, LPVOID unused)
 646 {
 647     return IPin_BeginFlush( pin );
 648 }
 649
 650 HRESULT WINAPI InputPin_BeginFlush(IPin * iface)
 651 {
 652     InputPin *This = (InputPin *)iface;
 653     HRESULT hr;
 654     TRACE("() semi-stub\n");
 655
 656     EnterCriticalSection(This->pin.pCritSec);
 657     This->flushing = 1;
 658
 659     if (This->fnCleanProc)
 660         This->fnCleanProc(This->pin.pUserData);
 661
 662     hr = SendFurther( iface, deliver_beginflush, NULL, NULL );
 663     LeaveCriticalSection(This->pin.pCritSec);
 664
 665     return hr;
 666 }
 667
 668 static HRESULT deliver_endflush(IPin* pin, LPVOID unused)
 669 {
 670     return IPin_EndFlush( pin );
 671 }
 672
 673 HRESULT WINAPI InputPin_EndFlush(IPin * iface)
 674 {
 675     InputPin *This = (InputPin *)iface;
 676     HRESULT hr;
 677     TRACE("(%p)\n", This);
 678
 679     EnterCriticalSection(This->pin.pCritSec);
 680     This->flushing = This->end_of_stream = 0;
 681
 682     hr = SendFurther( iface, deliver_endflush, NULL, NULL );
 683     LeaveCriticalSection(This->pin.pCritSec);
 684
 685     return hr;
 686 }
 687
 688 typedef struct newsegmentargs
 689 {
 690     REFERENCE_TIME tStart, tStop;
 691     double rate;
 692 } newsegmentargs;
 693
 694 static HRESULT deliver_newsegment(IPin *pin, LPVOID data)
 695 {
 696     newsegmentargs *args = data;
 697     return IPin_NewSegment(pin, args->tStart, args->tStop, args->rate);
 698 }
 699
 700 HRESULT WINAPI InputPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
 701 {
 702     InputPin *This = (InputPin *)iface;
 703     newsegmentargs args;
 704
 705     TRACE("(%x%08x, %x%08x, %e)\n", (ULONG)(tStart >> 32), (ULONG)tStart, (ULONG)(tStop >> 32), (ULONG)tStop, dRate);
 706
 707     args.tStart = This->tStart = tStart;
 708     args.tStop = This->tStop = tStop;
 709     args.rate = This->dRate = dRate;
 710
 711     return SendFurther( iface, deliver_newsegment, &args, NULL );
 712 }
 713
 714 static const IPinVtbl InputPin_Vtbl =
 715 {
 716     InputPin_QueryInterface,
 717     IPinImpl_AddRef,
 718     InputPin_Release,
 719     InputPin_Connect,
 720     InputPin_ReceiveConnection,
 721     IPinImpl_Disconnect,
 722     IPinImpl_ConnectedTo,
 723     IPinImpl_ConnectionMediaType,
 724     IPinImpl_QueryPinInfo,
 725     IPinImpl_QueryDirection,
 726     IPinImpl_QueryId,
 727     IPinImpl_QueryAccept,
 728     IPinImpl_EnumMediaTypes,
 729     IPinImpl_QueryInternalConnections,
 730     InputPin_EndOfStream,
 731     InputPin_BeginFlush,
 732     InputPin_EndFlush,
 733     InputPin_NewSegment
 734 };
 735
 736 /*** IMemInputPin implementation ***/
 737
 738 HRESULT WINAPI MemInputPin_QueryInterface(IMemInputPin * iface, REFIID riid, LPVOID * ppv)
 739 {
 740     InputPin *This = impl_from_IMemInputPin(iface);
 741
 742     return IPin_QueryInterface((IPin *)&This->pin, riid, ppv);
 743 }
 744
 745 ULONG WINAPI MemInputPin_AddRef(IMemInputPin * iface)
 746 {
 747     InputPin *This = impl_from_IMemInputPin(iface);
 748
 749     return IPin_AddRef((IPin *)&This->pin);
 750 }
 751
 752 ULONG WINAPI MemInputPin_Release(IMemInputPin * iface)
 753 {
 754     InputPin *This = impl_from_IMemInputPin(iface);
 755
 756     return IPin_Release((IPin *)&This->pin);
 757 }
 758
 759 HRESULT WINAPI MemInputPin_GetAllocator(IMemInputPin * iface, IMemAllocator ** ppAllocator)
 760 {
 761     InputPin *This = impl_from_IMemInputPin(iface);
 762
 763     TRACE("(%p/%p)->(%p)\n", This, iface, ppAllocator);
 764
 765     *ppAllocator = This->pAllocator;
 766     if (*ppAllocator)
 767         IMemAllocator_AddRef(*ppAllocator);
 768
 769     return *ppAllocator ? S_OK : VFW_E_NO_ALLOCATOR;
 770 }
 771
 772 HRESULT WINAPI MemInputPin_NotifyAllocator(IMemInputPin * iface, IMemAllocator * pAllocator, BOOL bReadOnly)
 773 {
 774     InputPin *This = impl_from_IMemInputPin(iface);
 775
 776     TRACE("(%p/%p)->(%p, %d)\n", This, iface, pAllocator, bReadOnly);
 777
 778     if (bReadOnly)
 779         FIXME("Read only flag not handled yet!\n");
 780
 781     /* FIXME: Should we release the allocator on disconnection? */
 782     if (!pAllocator)
 783     {
 784         WARN("Null allocator\n");
 785         return E_POINTER;
 786     }
 787
 788     if (This->preferred_allocator && pAllocator != This->preferred_allocator)
 789         return E_FAIL;
 790
 791     if (This->pAllocator)
 792         IMemAllocator_Release(This->pAllocator);
 793     This->pAllocator = pAllocator;
 794     if (This->pAllocator)
 795         IMemAllocator_AddRef(This->pAllocator);
 796
 797     return S_OK;
 798 }
 799
 800 HRESULT WINAPI MemInputPin_GetAllocatorRequirements(IMemInputPin * iface, ALLOCATOR_PROPERTIES * pProps)
 801 {
 802     InputPin *This = impl_from_IMemInputPin(iface);
 803
 804     TRACE("(%p/%p)->(%p)\n", This, iface, pProps);
 805
 806     /* override this method if you have any specific requirements */
 807
 808     return E_NOTIMPL;
 809 }
 810
 811 HRESULT WINAPI MemInputPin_Receive(IMemInputPin * iface, IMediaSample * pSample)
 812 {
 813     InputPin *This = impl_from_IMemInputPin(iface);
 814     HRESULT hr;
 815
 816     /* this trace commented out for performance reasons */
 817     /*TRACE("(%p/%p)->(%p)\n", This, iface, pSample);*/
 818     hr = This->fnSampleProc(This->pin.pUserData, pSample);
 819     return hr;
 820 }
 821
 822 HRESULT WINAPI MemInputPin_ReceiveMultiple(IMemInputPin * iface, IMediaSample ** pSamples, long nSamples, long *nSamplesProcessed)
 823 {
 824     HRESULT hr = S_OK;
 825     InputPin *This = impl_from_IMemInputPin(iface);
 826
 827     TRACE("(%p/%p)->(%p, %ld, %p)\n", This, iface, pSamples, nSamples, nSamplesProcessed);
 828
 829     for (*nSamplesProcessed = 0; *nSamplesProcessed < nSamples; (*nSamplesProcessed)++)
 830     {
 831         hr = IMemInputPin_Receive(iface, pSamples[*nSamplesProcessed]);
 832         if (hr != S_OK)
 833             break;
 834     }
 835
 836     return hr;
 837 }
 838
 839 HRESULT WINAPI MemInputPin_ReceiveCanBlock(IMemInputPin * iface)
 840 {
 841     InputPin *This = impl_from_IMemInputPin(iface);
 842
 843     TRACE("(%p/%p)->()\n", This, iface);
 844
 845     return S_OK;
 846 }
 847
 848 static const IMemInputPinVtbl MemInputPin_Vtbl =
 849 {
 850     MemInputPin_QueryInterface,
 851     MemInputPin_AddRef,
 852     MemInputPin_Release,
 853     MemInputPin_GetAllocator,
 854     MemInputPin_NotifyAllocator,
 855     MemInputPin_GetAllocatorRequirements,
 856     MemInputPin_Receive,
 857     MemInputPin_ReceiveMultiple,
 858     MemInputPin_ReceiveCanBlock
 859 };
 860
 861 HRESULT WINAPI OutputPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
 862 {
 863     OutputPin *This = (OutputPin *)iface;
 864
 865     TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
 866
 867     *ppv = NULL;
 868
 869     if (IsEqualIID(riid, &IID_IUnknown))
 870         *ppv = (LPVOID)iface;
 871     else if (IsEqualIID(riid, &IID_IPin))
 872         *ppv = (LPVOID)iface;
 873     else if (IsEqualIID(riid, &IID_IMediaSeeking))
 874     {
 875         return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv);
 876     }
 877
 878     if (*ppv)
 879     {
 880         IUnknown_AddRef((IUnknown *)(*ppv));
 881         return S_OK;
 882     }
 883
 884     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 885
 886     return E_NOINTERFACE;
 887 }
 888
 889 ULONG WINAPI OutputPin_Release(IPin * iface)
 890 {
 891     OutputPin *This = (OutputPin *)iface;
 892     ULONG refCount = InterlockedDecrement(&This->pin.refCount);
 893
 894     TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
 895
 896     if (!refCount)
 897     {
 898         FreeMediaType(&This->pin.mtCurrent);
 899         CoTaskMemFree(This);
 900         return 0;
 901     }
 902     return refCount;
 903 }
 904
 905 HRESULT WINAPI OutputPin_Connect(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 906 {
 907     HRESULT hr;
 908     OutputPin *This = (OutputPin *)iface;
 909
 910     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt);
 911     dump_AM_MEDIA_TYPE(pmt);
 912
 913     /* If we try to connect to ourself, we will definitely deadlock.
 914      * There are other cases where we could deadlock too, but this
 915      * catches the obvious case */
 916     assert(pReceivePin != iface);
 917
 918     EnterCriticalSection(This->pin.pCritSec);
 919     {
 920         /* if we have been a specific type to connect with, then we can either connect
 921          * with that or fail. We cannot choose different AM_MEDIA_TYPE */
 922         if (pmt && !IsEqualGUID(&pmt->majortype, &GUID_NULL) && !IsEqualGUID(&pmt->subtype, &GUID_NULL))
 923             hr = This->pConnectSpecific(iface, pReceivePin, pmt);
 924         else
 925         {
 926             /* negotiate media type */
 927
 928             IEnumMediaTypes * pEnumCandidates;
 929             AM_MEDIA_TYPE * pmtCandidate = NULL; /* Candidate media type */
 930
 931             if (SUCCEEDED(hr = IPin_EnumMediaTypes(iface, &pEnumCandidates)))
 932             {
 933                 hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */
 934
 935                 /* try this filter's media types first */
 936                 while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL))
 937                 {
 938                     assert(pmtCandidate);
 939                     dump_AM_MEDIA_TYPE(pmtCandidate);
 940                     if (!IsEqualGUID(&FORMAT_None, &pmtCandidate->formattype)
 941                         && !IsEqualGUID(&GUID_NULL, &pmtCandidate->formattype))
 942                         assert(pmtCandidate->pbFormat);
 943                     if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) &&
 944                         (This->pConnectSpecific(iface, pReceivePin, pmtCandidate) == S_OK))
 945                     {
 946                         hr = S_OK;
 947                         DeleteMediaType(pmtCandidate);
 948                         break;
 949                     }
 950                     DeleteMediaType(pmtCandidate);
 951                     pmtCandidate = NULL;
 952                 }
 953                 IEnumMediaTypes_Release(pEnumCandidates);
 954             }
 955
 956             /* then try receiver filter's media types */
 957             if (hr != S_OK && SUCCEEDED(hr = IPin_EnumMediaTypes(pReceivePin, &pEnumCandidates))) /* if we haven't already connected successfully */
 958             {
 959                 hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */
 960
 961                 while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL))
 962                 {
 963                     assert(pmtCandidate);
 964                     dump_AM_MEDIA_TYPE(pmtCandidate);
 965                     if (!IsEqualGUID(&FORMAT_None, &pmtCandidate->formattype)
 966                         && !IsEqualGUID(&GUID_NULL, &pmtCandidate->formattype))
 967                         assert(pmtCandidate->pbFormat);
 968                     if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) &&
 969                         (This->pConnectSpecific(iface, pReceivePin, pmtCandidate) == S_OK))
 970                     {
 971                         hr = S_OK;
 972                         DeleteMediaType(pmtCandidate);
 973                         break;
 974                     }
 975                     DeleteMediaType(pmtCandidate);
 976                     pmtCandidate = NULL;
 977                 } /* while */
 978                 IEnumMediaTypes_Release(pEnumCandidates);
 979             } /* if not found */
 980         } /* if negotiate media type */
 981     } /* if succeeded */
 982     LeaveCriticalSection(This->pin.pCritSec);
 983
 984     TRACE(" -- %x\n", hr);
 985     return hr;
 986 }
 987
 988 HRESULT WINAPI OutputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 989 {
 990     ERR("Incoming connection on an output pin! (%p, %p)\n", pReceivePin, pmt);
 991
 992     return E_UNEXPECTED;
 993 }
 994
 995 HRESULT WINAPI OutputPin_Disconnect(IPin * iface)
 996 {
 997     HRESULT hr;
 998     OutputPin *This = (OutputPin *)iface;
 999
1000     TRACE("()\n");
1001
1002     EnterCriticalSection(This->pin.pCritSec);
1003     {
1004         if (This->pMemInputPin)
1005         {
1006             IMemInputPin_Release(This->pMemInputPin);
1007             This->pMemInputPin = NULL;
1008         }
1009         if (This->pin.pConnectedTo)
1010         {
1011             IPin_Release(This->pin.pConnectedTo);
1012             This->pin.pConnectedTo = NULL;
1013             FreeMediaType(&This->pin.mtCurrent);
1014             ZeroMemory(&This->pin.mtCurrent, sizeof(This->pin.mtCurrent));
1015             hr = S_OK;
1016         }
1017         else
1018             hr = S_FALSE;
1019     }
1020     LeaveCriticalSection(This->pin.pCritSec);
1021
1022     return hr;
1023 }
1024
1025 HRESULT WINAPI OutputPin_EndOfStream(IPin * iface)
1026 {
1027     TRACE("()\n");
1028
1029     /* not supposed to do anything in an output pin */
1030
1031     return E_UNEXPECTED;
1032 }
1033
1034 HRESULT WINAPI OutputPin_BeginFlush(IPin * iface)
1035 {
1036     TRACE("(%p)->()\n", iface);
1037
1038     /* not supposed to do anything in an output pin */
1039
1040     return E_UNEXPECTED;
1041 }
1042
1043 HRESULT WINAPI OutputPin_EndFlush(IPin * iface)
1044 {
1045     TRACE("(%p)->()\n", iface);
1046
1047     /* not supposed to do anything in an output pin */
1048
1049     return E_UNEXPECTED;
1050 }
1051
1052 HRESULT WINAPI OutputPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
1053 {
1054     TRACE("(%p)->(%x%08x, %x%08x, %e)\n", iface, (ULONG)(tStart >> 32), (ULONG)tStart, (ULONG)(tStop >> 32), (ULONG)tStop, dRate);
1055
1056     /* not supposed to do anything in an output pin */
1057
1058     return E_UNEXPECTED;
1059 }
1060
1061 static const IPinVtbl OutputPin_Vtbl =
1062 {
1063     OutputPin_QueryInterface,
1064     IPinImpl_AddRef,
1065     OutputPin_Release,
1066     OutputPin_Connect,
1067     OutputPin_ReceiveConnection,
1068     OutputPin_Disconnect,
1069     IPinImpl_ConnectedTo,
1070     IPinImpl_ConnectionMediaType,
1071     IPinImpl_QueryPinInfo,
1072     IPinImpl_QueryDirection,
1073     IPinImpl_QueryId,
1074     IPinImpl_QueryAccept,
1075     IPinImpl_EnumMediaTypes,
1076     IPinImpl_QueryInternalConnections,
1077     OutputPin_EndOfStream,
1078     OutputPin_BeginFlush,
1079     OutputPin_EndFlush,
1080     OutputPin_NewSegment
1081 };
1082
1083 HRESULT OutputPin_GetDeliveryBuffer(OutputPin * This, IMediaSample ** ppSample, REFERENCE_TIME * tStart, REFERENCE_TIME * tStop, DWORD dwFlags)
1084 {
1085     HRESULT hr;
1086
1087     TRACE("(%p, %p, %p, %x)\n", ppSample, tStart, tStop, dwFlags);
1088
1089     EnterCriticalSection(This->pin.pCritSec);
1090     {
1091         if (!This->pin.pConnectedTo)
1092             hr = VFW_E_NOT_CONNECTED;
1093         else
1094         {
1095             IMemAllocator * pAlloc = NULL;
1096
1097             hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc);
1098
1099             if (SUCCEEDED(hr))
1100                 hr = IMemAllocator_GetBuffer(pAlloc, ppSample, tStart, tStop, dwFlags);
1101
1102             if (SUCCEEDED(hr))
1103                 hr = IMediaSample_SetTime(*ppSample, tStart, tStop);
1104
1105             if (pAlloc)
1106                 IMemAllocator_Release(pAlloc);
1107         }
1108     }
1109     LeaveCriticalSection(This->pin.pCritSec);
1110
1111     return hr;
1112 }
1113
1114 HRESULT OutputPin_SendSample(OutputPin * This, IMediaSample * pSample)
1115 {
1116     HRESULT hr = S_OK;
1117     IMemInputPin * pMemConnected = NULL;
1118     PIN_INFO pinInfo;
1119
1120     EnterCriticalSection(This->pin.pCritSec);
1121     {
1122         if (!This->pin.pConnectedTo || !This->pMemInputPin)
1123             hr = VFW_E_NOT_CONNECTED;
1124         else
1125         {
1126             /* we don't have the lock held when using This->pMemInputPin,
1127              * so we need to AddRef it to stop it being deleted while we are
1128              * using it. Same with its filter. */
1129             pMemConnected = This->pMemInputPin;
1130             IMemInputPin_AddRef(pMemConnected);
1131             hr = IPin_QueryPinInfo(This->pin.pConnectedTo, &pinInfo);
1132         }
1133     }
1134     LeaveCriticalSection(This->pin.pCritSec);
1135
1136     if (SUCCEEDED(hr))
1137     {
1138         /* NOTE: if we are in a critical section when Receive is called
1139          * then it causes some problems (most notably with the native Video
1140          * Renderer) if we are re-entered for whatever reason */
1141         hr = IMemInputPin_Receive(pMemConnected, pSample);
1142
1143         /* If the filter's destroyed, tell upstream to stop sending data */
1144         if(IBaseFilter_Release(pinInfo.pFilter) == 0 && SUCCEEDED(hr))
1145             hr = S_FALSE;
1146     }
1147     if (pMemConnected)
1148         IMemInputPin_Release(pMemConnected);
1149
1150     return hr;
1151 }
1152
1153 HRESULT OutputPin_DeliverNewSegment(OutputPin * This, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
1154 {
1155     HRESULT hr;
1156
1157     EnterCriticalSection(This->pin.pCritSec);
1158     {
1159         if (!This->pin.pConnectedTo)
1160             hr = VFW_E_NOT_CONNECTED;
1161         else
1162             hr = IPin_NewSegment(This->pin.pConnectedTo, tStart, tStop, dRate);
1163     }
1164     LeaveCriticalSection(This->pin.pCritSec);
1165
1166     return hr;
1167 }
1168
1169 HRESULT OutputPin_CommitAllocator(OutputPin * This)
1170 {
1171     HRESULT hr = S_OK;
1172
1173     TRACE("(%p)->()\n", This);
1174
1175     EnterCriticalSection(This->pin.pCritSec);
1176     {
1177         if (!This->pin.pConnectedTo || !This->pMemInputPin)
1178             hr = VFW_E_NOT_CONNECTED;
1179         else
1180         {
1181             IMemAllocator * pAlloc = NULL;
1182
1183             hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc);
1184
1185             if (SUCCEEDED(hr))
1186                 hr = IMemAllocator_Commit(pAlloc);
1187
1188             if (pAlloc)
1189                 IMemAllocator_Release(pAlloc);
1190         }
1191     }
1192     LeaveCriticalSection(This->pin.pCritSec);
1193
1194     TRACE("--> %08x\n", hr);
1195     return hr;
1196 }
1197
1198 HRESULT OutputPin_DecommitAllocator(OutputPin * This)
1199 {
1200     HRESULT hr = S_OK;
1201
1202     TRACE("(%p)->()\n", This);
1203
1204     EnterCriticalSection(This->pin.pCritSec);
1205     {
1206         if (!This->pin.pConnectedTo || !This->pMemInputPin)
1207             hr = VFW_E_NOT_CONNECTED;
1208         else
1209         {
1210             IMemAllocator * pAlloc = NULL;
1211
1212             hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc);
1213
1214             if (SUCCEEDED(hr))
1215                 hr = IMemAllocator_Decommit(pAlloc);
1216
1217             if (pAlloc)
1218                 IMemAllocator_Release(pAlloc);
1219         }
1220     }
1221     LeaveCriticalSection(This->pin.pCritSec);
1222
1223     TRACE("--> %08x\n", hr);
1224     return hr;
1225 }
1226
1227 HRESULT OutputPin_DeliverDisconnect(OutputPin * This)
1228 {
1229     HRESULT hr;
1230
1231     TRACE("(%p)->()\n", This);
1232
1233     EnterCriticalSection(This->pin.pCritSec);
1234     {
1235         if (!This->pin.pConnectedTo || !This->pMemInputPin)
1236             hr = VFW_E_NOT_CONNECTED;
1237         else if (!This->custom_allocator)
1238         {
1239             IMemAllocator * pAlloc = NULL;
1240
1241             hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc);
1242
1243             if (SUCCEEDED(hr))
1244                 hr = IMemAllocator_Decommit(pAlloc);
1245
1246             if (pAlloc)
1247                 IMemAllocator_Release(pAlloc);
1248
1249             if (SUCCEEDED(hr))
1250                 hr = IPin_Disconnect(This->pin.pConnectedTo);
1251         }
1252         else /* Kill the allocator! */
1253         {
1254             hr = IPin_Disconnect(This->pin.pConnectedTo);
1255         }
1256         IPin_Disconnect((IPin *)This);
1257     }
1258     LeaveCriticalSection(This->pin.pCritSec);
1259
1260     return hr;
1261 }
1262
1263
1264 static HRESULT PullPin_Init(const IPinVtbl *PullPin_Vtbl, const PIN_INFO * pPinInfo, SAMPLEPROC_PULL pSampleProc, LPVOID pUserData,
1265                             QUERYACCEPTPROC pQueryAccept, CLEANUPPROC pCleanUp, REQUESTPROC pCustomRequest, STOPPROCESSPROC pDone, LPCRITICAL_SECTION pCritSec, PullPin * pPinImpl)
1266 {
1267     /* Common attributes */
1268     pPinImpl->pin.lpVtbl = PullPin_Vtbl;
1269     pPinImpl->pin.refCount = 1;
1270     pPinImpl->pin.pConnectedTo = NULL;
1271     pPinImpl->pin.fnQueryAccept = pQueryAccept;
1272     pPinImpl->pin.pUserData = pUserData;
1273     pPinImpl->pin.pCritSec = pCritSec;
1274     Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
1275     ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE));
1276
1277     /* Input pin attributes */
1278     pPinImpl->fnSampleProc = pSampleProc;
1279     pPinImpl->fnCleanProc = pCleanUp;
1280     pPinImpl->fnDone = pDone;
1281     pPinImpl->fnPreConnect = NULL;
1282     pPinImpl->pAlloc = NULL;
1283     pPinImpl->pReader = NULL;
1284     pPinImpl->hThread = NULL;
1285     pPinImpl->hEventStateChanged = CreateEventW(NULL, TRUE, TRUE, NULL);
1286     pPinImpl->thread_sleepy = CreateEventW(NULL, FALSE, FALSE, NULL);
1287
1288     pPinImpl->rtStart = 0;
1289     pPinImpl->rtCurrent = 0;
1290     pPinImpl->rtStop = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
1291     pPinImpl->dRate = 1.0;
1292     pPinImpl->state = Req_Die;
1293     pPinImpl->fnCustomRequest = pCustomRequest;
1294     pPinImpl->stop_playback = 1;
1295
1296     InitializeCriticalSection(&pPinImpl->thread_lock);
1297     pPinImpl->thread_lock.DebugInfo->Spare[0] = (DWORD_PTR)( __FILE__ ": PullPin.thread_lock");
1298
1299     return S_OK;
1300 }
1301
1302 HRESULT PullPin_Construct(const IPinVtbl *PullPin_Vtbl, const PIN_INFO * pPinInfo, SAMPLEPROC_PULL pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, CLEANUPPROC pCleanUp, REQUESTPROC pCustomRequest, STOPPROCESSPROC pDone, LPCRITICAL_SECTION pCritSec, IPin ** ppPin)
1303 {
1304     PullPin * pPinImpl;
1305
1306     *ppPin = NULL;
1307
1308     if (pPinInfo->dir != PINDIR_INPUT)
1309     {
1310         ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir);
1311         return E_INVALIDARG;
1312     }
1313
1314     pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl));
1315
1316     if (!pPinImpl)
1317         return E_OUTOFMEMORY;
1318
1319     if (SUCCEEDED(PullPin_Init(PullPin_Vtbl, pPinInfo, pSampleProc, pUserData, pQueryAccept, pCleanUp, pCustomRequest, pDone, pCritSec, pPinImpl)))
1320     {
1321         *ppPin = (IPin *)(&pPinImpl->pin.lpVtbl);
1322         return S_OK;
1323     }
1324
1325     CoTaskMemFree(pPinImpl);
1326     return E_FAIL;
1327 }
1328
1329 static HRESULT PullPin_InitProcessing(PullPin * This);
1330
1331 HRESULT WINAPI PullPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
1332 {
1333     PIN_DIRECTION pindirReceive;
1334     HRESULT hr = S_OK;
1335     PullPin *This = (PullPin *)iface;
1336
1337     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt);
1338     dump_AM_MEDIA_TYPE(pmt);
1339
1340     EnterCriticalSection(This->pin.pCritSec);
1341     if (!This->pin.pConnectedTo)
1342     {
1343         ALLOCATOR_PROPERTIES props;
1344
1345         props.cBuffers = 3;
1346         props.cbBuffer = 64 * 1024; /* 64k bytes */
1347         props.cbAlign = 1;
1348         props.cbPrefix = 0;
1349
1350         if (SUCCEEDED(hr) && (This->pin.fnQueryAccept(This->pin.pUserData, pmt) != S_OK))
1351             hr = VFW_E_TYPE_NOT_ACCEPTED; /* FIXME: shouldn't we just map common errors onto
1352                                            * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */
1353
1354         if (SUCCEEDED(hr))
1355         {
1356             IPin_QueryDirection(pReceivePin, &pindirReceive);
1357
1358             if (pindirReceive != PINDIR_OUTPUT)
1359             {
1360                 ERR("Can't connect from non-output pin\n");
1361                 hr = VFW_E_INVALID_DIRECTION;
1362             }
1363         }
1364
1365         This->pReader = NULL;
1366         This->pAlloc = NULL;
1367         if (SUCCEEDED(hr))
1368         {
1369             hr = IPin_QueryInterface(pReceivePin, &IID_IAsyncReader, (LPVOID *)&This->pReader);
1370         }
1371
1372         if (SUCCEEDED(hr) && This->fnPreConnect)
1373         {
1374             hr = This->fnPreConnect(iface, pReceivePin, &props);
1375         }
1376
1377         if (SUCCEEDED(hr))
1378         {
1379             hr = IAsyncReader_RequestAllocator(This->pReader, NULL, &props, &This->pAlloc);
1380         }
1381
1382         if (SUCCEEDED(hr))
1383         {
1384             CopyMediaType(&This->pin.mtCurrent, pmt);
1385             This->pin.pConnectedTo = pReceivePin;
1386             IPin_AddRef(pReceivePin);
1387             hr = IMemAllocator_Commit(This->pAlloc);
1388         }
1389
1390         if (SUCCEEDED(hr))
1391             hr = PullPin_InitProcessing(This);
1392
1393         if (FAILED(hr))
1394         {
1395              if (This->pReader)
1396                  IAsyncReader_Release(This->pReader);
1397              This->pReader = NULL;
1398              if (This->pAlloc)
1399                  IMemAllocator_Release(This->pAlloc);
1400              This->pAlloc = NULL;
1401         }
1402     }
1403     else
1404         hr = VFW_E_ALREADY_CONNECTED;
1405     LeaveCriticalSection(This->pin.pCritSec);
1406     return hr;
1407 }
1408
1409 HRESULT WINAPI PullPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
1410 {
1411     PullPin *This = (PullPin *)iface;
1412
1413     TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
1414
1415     *ppv = NULL;
1416
1417     if (IsEqualIID(riid, &IID_IUnknown))
1418         *ppv = (LPVOID)iface;
1419     else if (IsEqualIID(riid, &IID_IPin))
1420         *ppv = (LPVOID)iface;
1421     else if (IsEqualIID(riid, &IID_IMediaSeeking))
1422     {
1423         return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv);
1424     }
1425
1426     if (*ppv)
1427     {
1428         IUnknown_AddRef((IUnknown *)(*ppv));
1429         return S_OK;
1430     }
1431
1432     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
1433
1434     return E_NOINTERFACE;
1435 }
1436
1437 ULONG WINAPI PullPin_Release(IPin *iface)
1438 {
1439     PullPin *This = (PullPin *)iface;
1440     ULONG refCount = InterlockedDecrement(&This->pin.refCount);
1441
1442     TRACE("(%p)->() Release from %d\n", This, refCount + 1);
1443
1444     if (!refCount)
1445     {
1446         WaitForSingleObject(This->hEventStateChanged, INFINITE);
1447         assert(!This->hThread);
1448
1449         if(This->pAlloc)
1450             IMemAllocator_Release(This->pAlloc);
1451         if(This->pReader)
1452             IAsyncReader_Release(This->pReader);
1453         CloseHandle(This->thread_sleepy);
1454         CloseHandle(This->hEventStateChanged);
1455         This->thread_lock.DebugInfo->Spare[0] = 0;
1456         DeleteCriticalSection(&This->thread_lock);
1457         CoTaskMemFree(This);
1458         return 0;
1459     }
1460     return refCount;
1461 }
1462
1463 static void CALLBACK PullPin_Flush(PullPin *This)
1464 {
1465     IMediaSample *pSample;
1466     TRACE("Flushing!\n");
1467
1468     if (This->pReader)
1469     {
1470         /* Flush outstanding samples */
1471         IAsyncReader_BeginFlush(This->pReader);
1472
1473         for (;;)
1474         {
1475             DWORD_PTR dwUser;
1476
1477             IAsyncReader_WaitForNext(This->pReader, 0, &pSample, &dwUser);
1478
1479             if (!pSample)
1480                 break;
1481
1482             assert(!IMediaSample_GetActualDataLength(pSample));
1483
1484             IMediaSample_Release(pSample);
1485         }
1486
1487         IAsyncReader_EndFlush(This->pReader);
1488     }
1489 }
1490
1491 static void CALLBACK PullPin_Thread_Process(PullPin *This)
1492 {
1493     HRESULT hr;
1494     IMediaSample * pSample = NULL;
1495     ALLOCATOR_PROPERTIES allocProps;
1496
1497     hr = IMemAllocator_GetProperties(This->pAlloc, &allocProps);
1498
1499     This->cbAlign = allocProps.cbAlign;
1500
1501     if (This->rtCurrent < This->rtStart)
1502         This->rtCurrent = MEDIATIME_FROM_BYTES(ALIGNDOWN(BYTES_FROM_MEDIATIME(This->rtStart), This->cbAlign));
1503
1504     TRACE("Start\n");
1505
1506     if (This->rtCurrent >= This->rtStop)
1507     {
1508         IPin_EndOfStream((IPin *)This);
1509         return;
1510     }
1511
1512     /* There is no sample in our buffer */
1513     hr = This->fnCustomRequest(This->pin.pUserData);
1514
1515     if (FAILED(hr))
1516         ERR("Request error: %x\n", hr);
1517
1518     EnterCriticalSection(This->pin.pCritSec);
1519     SetEvent(This->hEventStateChanged);
1520     LeaveCriticalSection(This->pin.pCritSec);
1521
1522     if (SUCCEEDED(hr))
1523     do
1524     {
1525         DWORD_PTR dwUser;
1526
1527         TRACE("Process sample\n");
1528
1529         hr = IAsyncReader_WaitForNext(This->pReader, 10000, &pSample, &dwUser);
1530
1531         /* Return an empty sample on error to the implementation in case it does custom parsing, so it knows it's gone */
1532         if (SUCCEEDED(hr))
1533         {
1534             hr = This->fnSampleProc(This->pin.pUserData, pSample, dwUser);
1535         }
1536         else
1537         {
1538             /* FIXME: This is not well handled yet! */
1539             ERR("Processing error: %x\n", hr);
1540         }
1541
1542         if (pSample)
1543         {
1544             IMediaSample_Release(pSample);
1545             pSample = NULL;
1546         }
1547     } while (This->rtCurrent < This->rtStop && hr == S_OK && !This->stop_playback);
1548
1549     /* Sample was rejected, and we are asked to terminate */
1550     if (pSample)
1551     {
1552         IMediaSample_Release(pSample);
1553     }
1554
1555     /* Can't reset state to Sleepy here because that might race, instead PauseProcessing will do that for us
1556      * Flush remaining samples
1557      */
1558     if (This->fnDone)
1559         This->fnDone(This->pin.pUserData);
1560
1561     TRACE("End: %08x, %d\n", hr, This->stop_playback);
1562 }
1563
1564 static void CALLBACK PullPin_Thread_Pause(PullPin *This)
1565 {
1566     PullPin_Flush(This);
1567
1568     EnterCriticalSection(This->pin.pCritSec);
1569     This->state = Req_Sleepy;
1570     SetEvent(This->hEventStateChanged);
1571     LeaveCriticalSection(This->pin.pCritSec);
1572 }
1573
1574 static void CALLBACK PullPin_Thread_Stop(PullPin *This)
1575 {
1576     TRACE("(%p)->()\n", This);
1577
1578     EnterCriticalSection(This->pin.pCritSec);
1579     {
1580         CloseHandle(This->hThread);
1581         This->hThread = NULL;
1582         SetEvent(This->hEventStateChanged);
1583     }
1584     LeaveCriticalSection(This->pin.pCritSec);
1585
1586     IBaseFilter_Release(This->pin.pinInfo.pFilter);
1587
1588     CoUninitialize();
1589     ExitThread(0);
1590 }
1591
1592 static DWORD WINAPI PullPin_Thread_Main(LPVOID pv)
1593 {
1594     PullPin *This = pv;
1595     CoInitializeEx(NULL, COINIT_MULTITHREADED);
1596
1597     PullPin_Flush(This);
1598
1599     for (;;)
1600     {
1601         WaitForSingleObject(This->thread_sleepy, INFINITE);
1602
1603         TRACE("State: %d\n", This->state);
1604
1605         switch (This->state)
1606         {
1607         case Req_Die: PullPin_Thread_Stop(This); break;
1608         case Req_Run: PullPin_Thread_Process(This); break;
1609         case Req_Pause: PullPin_Thread_Pause(This); break;
1610         case Req_Sleepy: ERR("Should not be signalled with SLEEPY!\n"); break;
1611         default: ERR("Unknown state request: %d\n", This->state); break;
1612         }
1613     }
1614 }
1615
1616 static HRESULT PullPin_InitProcessing(PullPin * This)
1617 {
1618     HRESULT hr = S_OK;
1619
1620     TRACE("(%p)->()\n", This);
1621
1622     /* if we are connected */
1623     if (This->pAlloc)
1624     {
1625         DWORD dwThreadId;
1626
1627         WaitForSingleObject(This->hEventStateChanged, INFINITE);
1628         EnterCriticalSection(This->pin.pCritSec);
1629
1630         assert(!This->hThread);
1631         assert(This->state == Req_Die);
1632         assert(This->stop_playback);
1633         assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
1634         This->state = Req_Sleepy;
1635
1636         /* AddRef the filter to make sure it and it's pins will be around
1637          * as long as the thread */
1638         IBaseFilter_AddRef(This->pin.pinInfo.pFilter);
1639
1640
1641         This->hThread = CreateThread(NULL, 0, PullPin_Thread_Main, This, 0, &dwThreadId);
1642         if (!This->hThread)
1643         {
1644             hr = HRESULT_FROM_WIN32(GetLastError());
1645             IBaseFilter_Release(This->pin.pinInfo.pFilter);
1646         }
1647
1648         if (SUCCEEDED(hr))
1649         {
1650             SetEvent(This->hEventStateChanged);
1651             /* If assert fails, that means a command was not processed before the thread previously terminated */
1652         }
1653         LeaveCriticalSection(This->pin.pCritSec);
1654     }
1655
1656     TRACE(" -- %x\n", hr);
1657
1658     return hr;
1659 }
1660
1661 HRESULT PullPin_StartProcessing(PullPin * This)
1662 {
1663     /* if we are connected */
1664     TRACE("(%p)->()\n", This);
1665     if(This->pAlloc)
1666     {
1667         assert(This->hThread);
1668
1669         PullPin_WaitForStateChange(This, INFINITE);
1670
1671         assert(This->state == Req_Sleepy);
1672
1673         /* Wake up! */
1674         assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
1675         This->state = Req_Run;
1676         This->stop_playback = 0;
1677         ResetEvent(This->hEventStateChanged);
1678         SetEvent(This->thread_sleepy);
1679     }
1680
1681     return S_OK;
1682 }
1683
1684 HRESULT PullPin_PauseProcessing(PullPin * This)
1685 {
1686     /* if we are connected */
1687     TRACE("(%p)->()\n", This);
1688     if(This->pAlloc)
1689     {
1690         assert(This->hThread);
1691
1692         PullPin_WaitForStateChange(This, INFINITE);
1693
1694         EnterCriticalSection(This->pin.pCritSec);
1695
1696         assert(!This->stop_playback);
1697         assert(This->state == Req_Run|| This->state == Req_Sleepy);
1698
1699         assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
1700         This->state = Req_Pause;
1701         This->stop_playback = 1;
1702         ResetEvent(This->hEventStateChanged);
1703         SetEvent(This->thread_sleepy);
1704
1705         LeaveCriticalSection(This->pin.pCritSec);
1706     }
1707
1708     return S_OK;
1709 }
1710
1711 static HRESULT PullPin_StopProcessing(PullPin * This)
1712 {
1713     TRACE("(%p)->()\n", This);
1714
1715     /* if we are alive */
1716     assert(This->hThread);
1717
1718     PullPin_WaitForStateChange(This, INFINITE);
1719
1720     assert(This->state == Req_Pause || This->state == Req_Sleepy);
1721
1722     This->stop_playback = 1;
1723     This->state = Req_Die;
1724     assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
1725     ResetEvent(This->hEventStateChanged);
1726     SetEvent(This->thread_sleepy);
1727     return S_OK;
1728 }
1729
1730 HRESULT PullPin_WaitForStateChange(PullPin * This, DWORD dwMilliseconds)
1731 {
1732     if (WaitForSingleObject(This->hEventStateChanged, dwMilliseconds) == WAIT_TIMEOUT)
1733         return S_FALSE;
1734     return S_OK;
1735 }
1736
1737 HRESULT WINAPI PullPin_EndOfStream(IPin * iface)
1738 {
1739     FIXME("(%p)->() stub\n", iface);
1740
1741     return SendFurther( iface, deliver_endofstream, NULL, NULL );
1742 }
1743
1744 HRESULT WINAPI PullPin_BeginFlush(IPin * iface)
1745 {
1746     PullPin *This = (PullPin *)iface;
1747     TRACE("(%p)->()\n", This);
1748
1749     EnterCriticalSection(This->pin.pCritSec);
1750     {
1751         SendFurther( iface, deliver_beginflush, NULL, NULL );
1752     }
1753     LeaveCriticalSection(This->pin.pCritSec);
1754
1755     EnterCriticalSection(&This->thread_lock);
1756     {
1757         if (This->pReader)
1758             IAsyncReader_BeginFlush(This->pReader);
1759         PullPin_WaitForStateChange(This, INFINITE);
1760
1761         if (This->hThread && This->state == Req_Run)
1762         {
1763             PullPin_PauseProcessing(This);
1764             PullPin_WaitForStateChange(This, INFINITE);
1765         }
1766     }
1767     LeaveCriticalSection(&This->thread_lock);
1768
1769     EnterCriticalSection(This->pin.pCritSec);
1770     {
1771         This->fnCleanProc(This->pin.pUserData);
1772     }
1773     LeaveCriticalSection(This->pin.pCritSec);
1774
1775     return S_OK;
1776 }
1777
1778 HRESULT WINAPI PullPin_EndFlush(IPin * iface)
1779 {
1780     PullPin *This = (PullPin *)iface;
1781
1782     TRACE("(%p)->()\n", iface);
1783
1784     /* Send further first: Else a race condition might terminate processing early */
1785     EnterCriticalSection(This->pin.pCritSec);
1786     SendFurther( iface, deliver_endflush, NULL, NULL );
1787     LeaveCriticalSection(This->pin.pCritSec);
1788
1789     EnterCriticalSection(&This->thread_lock);
1790     {
1791         FILTER_STATE state;
1792         IBaseFilter_GetState(This->pin.pinInfo.pFilter, INFINITE, &state);
1793
1794         if (state != State_Stopped)
1795             PullPin_StartProcessing(This);
1796
1797         PullPin_WaitForStateChange(This, INFINITE);
1798     }
1799     LeaveCriticalSection(&This->thread_lock);
1800
1801     return S_OK;
1802 }
1803
1804 HRESULT WINAPI PullPin_Disconnect(IPin *iface)
1805 {
1806     HRESULT hr;
1807     PullPin *This = (PullPin *)iface;
1808
1809     TRACE("()\n");
1810
1811     EnterCriticalSection(This->pin.pCritSec);
1812     {
1813         if (FAILED(hr = IMemAllocator_Decommit(This->pAlloc)))
1814             ERR("Allocator decommit failed with error %x. Possible memory leak\n", hr);
1815
1816         if (This->pin.pConnectedTo)
1817         {
1818             IPin_Release(This->pin.pConnectedTo);
1819             This->pin.pConnectedTo = NULL;
1820             PullPin_StopProcessing(This);
1821
1822             FreeMediaType(&This->pin.mtCurrent);
1823             ZeroMemory(&This->pin.mtCurrent, sizeof(This->pin.mtCurrent));
1824             hr = S_OK;
1825         }
1826         else
1827             hr = S_FALSE;
1828     }
1829     LeaveCriticalSection(This->pin.pCritSec);
1830
1831     return hr;
1832 }
1833
1834 HRESULT WINAPI PullPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
1835 {
1836     newsegmentargs args;
1837     FIXME("(%p)->(%s, %s, %g) stub\n", iface, wine_dbgstr_longlong(tStart), wine_dbgstr_longlong(tStop), dRate);
1838
1839     args.tStart = tStart;
1840     args.tStop = tStop;
1841     args.rate = dRate;
1842
1843     return SendFurther( iface, deliver_newsegment, &args, NULL );
1844 }
1845
1846 static const IPinVtbl PullPin_Vtbl =
1847 {
1848     PullPin_QueryInterface,
1849     IPinImpl_AddRef,
1850     PullPin_Release,
1851     InputPin_Connect,
1852     PullPin_ReceiveConnection,
1853     PullPin_Disconnect,
1854     IPinImpl_ConnectedTo,
1855     IPinImpl_ConnectionMediaType,
1856     IPinImpl_QueryPinInfo,
1857     IPinImpl_QueryDirection,
1858     IPinImpl_QueryId,
1859     IPinImpl_QueryAccept,
1860     IPinImpl_EnumMediaTypes,
1861     IPinImpl_QueryInternalConnections,
1862     PullPin_EndOfStream,
1863     PullPin_BeginFlush,
1864     PullPin_EndFlush,
1865     PullPin_NewSegment
1866 };