git.oblomov.eu Git - wine/blob - 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 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 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         pSample = NULL;
1530         hr = IAsyncReader_WaitForNext(This->pReader, 10000, &pSample, &dwUser);
1531
1532         /* Return an empty sample on error to the implementation in case it does custom parsing, so it knows it's gone */
1533         if (SUCCEEDED(hr))
1534         {
1535             hr = This->fnSampleProc(This->pin.pUserData, pSample, dwUser);
1536         }
1537         else
1538         {
1539             /* FIXME: This is not well handled yet! */
1540             ERR("Processing error: %x\n", hr);
1541             if (hr == VFW_E_TIMEOUT)
1542             {
1543                 assert(!pSample);
1544                 hr = S_OK;
1545                 continue;
1546             }
1547         }
1548
1549         if (pSample)
1550         {
1551             IMediaSample_Release(pSample);
1552             pSample = NULL;
1553         }
1554     } while (This->rtCurrent < This->rtStop && hr == S_OK && !This->stop_playback);
1555
1556     /* Sample was rejected, and we are asked to terminate */
1557     if (pSample)
1558     {
1559         IMediaSample_Release(pSample);
1560     }
1561
1562     /* Can't reset state to Sleepy here because that might race, instead PauseProcessing will do that for us
1563      * Flush remaining samples
1564      */
1565     if (This->fnDone)
1566         This->fnDone(This->pin.pUserData);
1567
1568     TRACE("End: %08x, %d\n", hr, This->stop_playback);
1569 }
1570
1571 static void PullPin_Thread_Pause(PullPin *This)
1572 {
1573     PullPin_Flush(This);
1574
1575     EnterCriticalSection(This->pin.pCritSec);
1576     This->state = Req_Sleepy;
1577     SetEvent(This->hEventStateChanged);
1578     LeaveCriticalSection(This->pin.pCritSec);
1579 }
1580
1581 static void  PullPin_Thread_Stop(PullPin *This)
1582 {
1583     TRACE("(%p)->()\n", This);
1584
1585     EnterCriticalSection(This->pin.pCritSec);
1586     {
1587         CloseHandle(This->hThread);
1588         This->hThread = NULL;
1589         SetEvent(This->hEventStateChanged);
1590     }
1591     LeaveCriticalSection(This->pin.pCritSec);
1592
1593     IBaseFilter_Release(This->pin.pinInfo.pFilter);
1594
1595     CoUninitialize();
1596     ExitThread(0);
1597 }
1598
1599 static DWORD WINAPI PullPin_Thread_Main(LPVOID pv)
1600 {
1601     PullPin *This = pv;
1602     CoInitializeEx(NULL, COINIT_MULTITHREADED);
1603
1604     PullPin_Flush(This);
1605
1606     for (;;)
1607     {
1608         WaitForSingleObject(This->thread_sleepy, INFINITE);
1609
1610         TRACE("State: %d\n", This->state);
1611
1612         switch (This->state)
1613         {
1614         case Req_Die: PullPin_Thread_Stop(This); break;
1615         case Req_Run: PullPin_Thread_Process(This); break;
1616         case Req_Pause: PullPin_Thread_Pause(This); break;
1617         case Req_Sleepy: ERR("Should not be signalled with SLEEPY!\n"); break;
1618         default: ERR("Unknown state request: %d\n", This->state); break;
1619         }
1620     }
1621     return 0;
1622 }
1623
1624 static HRESULT PullPin_InitProcessing(PullPin * This)
1625 {
1626     HRESULT hr = S_OK;
1627
1628     TRACE("(%p)->()\n", This);
1629
1630     /* if we are connected */
1631     if (This->pAlloc)
1632     {
1633         DWORD dwThreadId;
1634
1635         WaitForSingleObject(This->hEventStateChanged, INFINITE);
1636         EnterCriticalSection(This->pin.pCritSec);
1637
1638         assert(!This->hThread);
1639         assert(This->state == Req_Die);
1640         assert(This->stop_playback);
1641         assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
1642         This->state = Req_Sleepy;
1643
1644         /* AddRef the filter to make sure it and it's pins will be around
1645          * as long as the thread */
1646         IBaseFilter_AddRef(This->pin.pinInfo.pFilter);
1647
1648
1649         This->hThread = CreateThread(NULL, 0, PullPin_Thread_Main, This, 0, &dwThreadId);
1650         if (!This->hThread)
1651         {
1652             hr = HRESULT_FROM_WIN32(GetLastError());
1653             IBaseFilter_Release(This->pin.pinInfo.pFilter);
1654         }
1655
1656         if (SUCCEEDED(hr))
1657         {
1658             SetEvent(This->hEventStateChanged);
1659             /* If assert fails, that means a command was not processed before the thread previously terminated */
1660         }
1661         LeaveCriticalSection(This->pin.pCritSec);
1662     }
1663
1664     TRACE(" -- %x\n", hr);
1665
1666     return hr;
1667 }
1668
1669 HRESULT PullPin_StartProcessing(PullPin * This)
1670 {
1671     /* if we are connected */
1672     TRACE("(%p)->()\n", This);
1673     if(This->pAlloc)
1674     {
1675         assert(This->hThread);
1676
1677         PullPin_WaitForStateChange(This, INFINITE);
1678
1679         assert(This->state == Req_Sleepy);
1680
1681         /* Wake up! */
1682         assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
1683         This->state = Req_Run;
1684         This->stop_playback = 0;
1685         ResetEvent(This->hEventStateChanged);
1686         SetEvent(This->thread_sleepy);
1687     }
1688
1689     return S_OK;
1690 }
1691
1692 HRESULT PullPin_PauseProcessing(PullPin * This)
1693 {
1694     /* if we are connected */
1695     TRACE("(%p)->()\n", This);
1696     if(This->pAlloc)
1697     {
1698         assert(This->hThread);
1699
1700         PullPin_WaitForStateChange(This, INFINITE);
1701
1702         EnterCriticalSection(This->pin.pCritSec);
1703
1704         assert(!This->stop_playback);
1705         assert(This->state == Req_Run|| This->state == Req_Sleepy);
1706
1707         assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
1708         This->state = Req_Pause;
1709         This->stop_playback = 1;
1710         ResetEvent(This->hEventStateChanged);
1711         SetEvent(This->thread_sleepy);
1712
1713         LeaveCriticalSection(This->pin.pCritSec);
1714     }
1715
1716     return S_OK;
1717 }
1718
1719 static HRESULT PullPin_StopProcessing(PullPin * This)
1720 {
1721     TRACE("(%p)->()\n", This);
1722
1723     /* if we are alive */
1724     assert(This->hThread);
1725
1726     PullPin_WaitForStateChange(This, INFINITE);
1727
1728     assert(This->state == Req_Pause || This->state == Req_Sleepy);
1729
1730     This->stop_playback = 1;
1731     This->state = Req_Die;
1732     assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
1733     ResetEvent(This->hEventStateChanged);
1734     SetEvent(This->thread_sleepy);
1735     return S_OK;
1736 }
1737
1738 HRESULT PullPin_WaitForStateChange(PullPin * This, DWORD dwMilliseconds)
1739 {
1740     if (WaitForSingleObject(This->hEventStateChanged, dwMilliseconds) == WAIT_TIMEOUT)
1741         return S_FALSE;
1742     return S_OK;
1743 }
1744
1745 HRESULT WINAPI PullPin_EndOfStream(IPin * iface)
1746 {
1747     FIXME("(%p)->() stub\n", iface);
1748
1749     return SendFurther( iface, deliver_endofstream, NULL, NULL );
1750 }
1751
1752 HRESULT WINAPI PullPin_BeginFlush(IPin * iface)
1753 {
1754     PullPin *This = (PullPin *)iface;
1755     TRACE("(%p)->()\n", This);
1756
1757     EnterCriticalSection(This->pin.pCritSec);
1758     {
1759         SendFurther( iface, deliver_beginflush, NULL, NULL );
1760     }
1761     LeaveCriticalSection(This->pin.pCritSec);
1762
1763     EnterCriticalSection(&This->thread_lock);
1764     {
1765         if (This->pReader)
1766             IAsyncReader_BeginFlush(This->pReader);
1767         PullPin_WaitForStateChange(This, INFINITE);
1768
1769         if (This->hThread && This->state == Req_Run)
1770         {
1771             PullPin_PauseProcessing(This);
1772             PullPin_WaitForStateChange(This, INFINITE);
1773         }
1774     }
1775     LeaveCriticalSection(&This->thread_lock);
1776
1777     EnterCriticalSection(This->pin.pCritSec);
1778     {
1779         This->fnCleanProc(This->pin.pUserData);
1780     }
1781     LeaveCriticalSection(This->pin.pCritSec);
1782
1783     return S_OK;
1784 }
1785
1786 HRESULT WINAPI PullPin_EndFlush(IPin * iface)
1787 {
1788     PullPin *This = (PullPin *)iface;
1789
1790     TRACE("(%p)->()\n", iface);
1791
1792     /* Send further first: Else a race condition might terminate processing early */
1793     EnterCriticalSection(This->pin.pCritSec);
1794     SendFurther( iface, deliver_endflush, NULL, NULL );
1795     LeaveCriticalSection(This->pin.pCritSec);
1796
1797     EnterCriticalSection(&This->thread_lock);
1798     {
1799         FILTER_STATE state;
1800
1801         if (This->pReader)
1802             IAsyncReader_EndFlush(This->pReader);
1803
1804         IBaseFilter_GetState(This->pin.pinInfo.pFilter, INFINITE, &state);
1805
1806         if (state != State_Stopped)
1807             PullPin_StartProcessing(This);
1808
1809         PullPin_WaitForStateChange(This, INFINITE);
1810     }
1811     LeaveCriticalSection(&This->thread_lock);
1812
1813     return S_OK;
1814 }
1815
1816 HRESULT WINAPI PullPin_Disconnect(IPin *iface)
1817 {
1818     HRESULT hr;
1819     PullPin *This = (PullPin *)iface;
1820
1821     TRACE("()\n");
1822
1823     EnterCriticalSection(This->pin.pCritSec);
1824     {
1825         if (FAILED(hr = IMemAllocator_Decommit(This->pAlloc)))
1826             ERR("Allocator decommit failed with error %x. Possible memory leak\n", hr);
1827
1828         if (This->pin.pConnectedTo)
1829         {
1830             IPin_Release(This->pin.pConnectedTo);
1831             This->pin.pConnectedTo = NULL;
1832             PullPin_StopProcessing(This);
1833
1834             FreeMediaType(&This->pin.mtCurrent);
1835             ZeroMemory(&This->pin.mtCurrent, sizeof(This->pin.mtCurrent));
1836             hr = S_OK;
1837         }
1838         else
1839             hr = S_FALSE;
1840     }
1841     LeaveCriticalSection(This->pin.pCritSec);
1842
1843     return hr;
1844 }
1845
1846 HRESULT WINAPI PullPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
1847 {
1848     newsegmentargs args;
1849     FIXME("(%p)->(%s, %s, %g) stub\n", iface, wine_dbgstr_longlong(tStart), wine_dbgstr_longlong(tStop), dRate);
1850
1851     args.tStart = tStart;
1852     args.tStop = tStop;
1853     args.rate = dRate;
1854
1855     return SendFurther( iface, deliver_newsegment, &args, NULL );
1856 }
1857
1858 static const IPinVtbl PullPin_Vtbl =
1859 {
1860     PullPin_QueryInterface,
1861     IPinImpl_AddRef,
1862     PullPin_Release,
1863     InputPin_Connect,
1864     PullPin_ReceiveConnection,
1865     PullPin_Disconnect,
1866     IPinImpl_ConnectedTo,
1867     IPinImpl_ConnectionMediaType,
1868     IPinImpl_QueryPinInfo,
1869     IPinImpl_QueryDirection,
1870     IPinImpl_QueryId,
1871     IPinImpl_QueryAccept,
1872     IPinImpl_EnumMediaTypes,
1873     IPinImpl_QueryInternalConnections,
1874     PullPin_EndOfStream,
1875     PullPin_BeginFlush,
1876     PullPin_EndFlush,
1877     PullPin_NewSegment
1878 };