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     } while (hr == S_OK);
 124     if (!foundend)
 125         hr = hr_return;
 126     else if (fnEnd) {
 127         HRESULT hr_local;
 128
 129         hr_local = fnEnd( from, arg );
 130         hr_return = updatehres( hr_return, hr_local );
 131     }
 132
 133 out:
 134     if (pin_info.pFilter)
 135         IBaseFilter_Release( pin_info.pFilter );
 136     return hr;
 137 }
 138
 139 static inline InputPin *impl_from_IMemInputPin( IMemInputPin *iface )
 140 {
 141     return (InputPin *)((char*)iface - FIELD_OFFSET(InputPin, lpVtblMemInput));
 142 }
 143
 144
 145 static void Copy_PinInfo(PIN_INFO * pDest, const PIN_INFO * pSrc)
 146 {
 147     /* Tempting to just do a memcpy, but the name field is
 148        128 characters long! We will probably never exceed 10
 149        most of the time, so we are better off copying
 150        each field manually */
 151     strcpyW(pDest->achName, pSrc->achName);
 152     pDest->dir = pSrc->dir;
 153     pDest->pFilter = pSrc->pFilter;
 154 }
 155
 156 /* Function called as a helper to IPin_Connect */
 157 /* specific AM_MEDIA_TYPE - it cannot be NULL */
 158 /* NOTE: not part of standard interface */
 159 static HRESULT OutputPin_ConnectSpecific(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 160 {
 161     OutputPin *This = (OutputPin *)iface;
 162     HRESULT hr;
 163     IMemAllocator * pMemAlloc = NULL;
 164     ALLOCATOR_PROPERTIES actual; /* FIXME: should we put the actual props back in to This? */
 165
 166     TRACE("(%p, %p)\n", pReceivePin, pmt);
 167     dump_AM_MEDIA_TYPE(pmt);
 168
 169     /* FIXME: call queryacceptproc */
 170
 171     This->pin.pConnectedTo = pReceivePin;
 172     IPin_AddRef(pReceivePin);
 173     CopyMediaType(&This->pin.mtCurrent, pmt);
 174
 175     hr = IPin_ReceiveConnection(pReceivePin, iface, pmt);
 176
 177     /* get the IMemInputPin interface we will use to deliver samples to the
 178      * connected pin */
 179     if (SUCCEEDED(hr))
 180     {
 181         This->pMemInputPin = NULL;
 182         hr = IPin_QueryInterface(pReceivePin, &IID_IMemInputPin, (LPVOID)&This->pMemInputPin);
 183
 184         if (SUCCEEDED(hr))
 185         {
 186             hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pMemAlloc);
 187
 188             if (hr == VFW_E_NO_ALLOCATOR)
 189             {
 190                 /* Input pin provides no allocator, use standard memory allocator */
 191                 hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC_SERVER, &IID_IMemAllocator, (LPVOID*)&pMemAlloc);
 192
 193                 if (SUCCEEDED(hr))
 194                 {
 195                     hr = IMemInputPin_NotifyAllocator(This->pMemInputPin, pMemAlloc, FALSE);
 196                 }
 197             }
 198
 199             if (SUCCEEDED(hr))
 200                 hr = IMemAllocator_SetProperties(pMemAlloc, &This->allocProps, &actual);
 201
 202             if (pMemAlloc)
 203                 IMemAllocator_Release(pMemAlloc);
 204         }
 205
 206         /* break connection if we couldn't get the allocator */
 207         if (FAILED(hr))
 208         {
 209             if (This->pMemInputPin)
 210                 IMemInputPin_Release(This->pMemInputPin);
 211             This->pMemInputPin = NULL;
 212
 213             IPin_Disconnect(pReceivePin);
 214         }
 215     }
 216
 217     if (FAILED(hr))
 218     {
 219         IPin_Release(This->pin.pConnectedTo);
 220         This->pin.pConnectedTo = NULL;
 221         FreeMediaType(&This->pin.mtCurrent);
 222     }
 223
 224     TRACE(" -- %x\n", hr);
 225     return hr;
 226 }
 227
 228 static HRESULT InputPin_Init(const IPinVtbl *InputPin_Vtbl, const PIN_INFO * pPinInfo, SAMPLEPROC pSampleProc, LPVOID pUserData,
 229                              QUERYACCEPTPROC pQueryAccept, CLEANUPPROC pCleanUp, LPCRITICAL_SECTION pCritSec, InputPin * pPinImpl)
 230 {
 231     TRACE("\n");
 232
 233     /* Common attributes */
 234     pPinImpl->pin.refCount = 1;
 235     pPinImpl->pin.pConnectedTo = NULL;
 236     pPinImpl->pin.fnQueryAccept = pQueryAccept;
 237     pPinImpl->pin.pUserData = pUserData;
 238     pPinImpl->pin.pCritSec = pCritSec;
 239     Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
 240     ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE));
 241
 242     /* Input pin attributes */
 243     pPinImpl->fnSampleProc = pSampleProc;
 244     pPinImpl->fnCleanProc = pCleanUp;
 245     pPinImpl->pAllocator = NULL;
 246     pPinImpl->tStart = 0;
 247     pPinImpl->tStop = 0;
 248     pPinImpl->dRate = 0;
 249     pPinImpl->pin.lpVtbl = InputPin_Vtbl;
 250     pPinImpl->lpVtblMemInput = &MemInputPin_Vtbl;
 251     pPinImpl->flushing = pPinImpl->end_of_stream = 0;
 252
 253     return S_OK;
 254 }
 255
 256 static HRESULT OutputPin_Init(const IPinVtbl *OutputPin_Vtbl, const PIN_INFO * pPinInfo, const ALLOCATOR_PROPERTIES * props, LPVOID pUserData,
 257                               QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, OutputPin * pPinImpl)
 258 {
 259     TRACE("\n");
 260
 261     /* Common attributes */
 262     pPinImpl->pin.lpVtbl = OutputPin_Vtbl;
 263     pPinImpl->pin.refCount = 1;
 264     pPinImpl->pin.pConnectedTo = NULL;
 265     pPinImpl->pin.fnQueryAccept = pQueryAccept;
 266     pPinImpl->pin.pUserData = pUserData;
 267     pPinImpl->pin.pCritSec = pCritSec;
 268     Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
 269     ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE));
 270
 271     /* Output pin attributes */
 272     pPinImpl->pMemInputPin = NULL;
 273     pPinImpl->pConnectSpecific = OutputPin_ConnectSpecific;
 274     if (props)
 275     {
 276         pPinImpl->allocProps = *props;
 277         if (pPinImpl->allocProps.cbAlign == 0)
 278             pPinImpl->allocProps.cbAlign = 1;
 279     }
 280     else
 281         ZeroMemory(&pPinImpl->allocProps, sizeof(pPinImpl->allocProps));
 282
 283     return S_OK;
 284 }
 285
 286 HRESULT InputPin_Construct(const IPinVtbl *InputPin_Vtbl, const PIN_INFO * pPinInfo, SAMPLEPROC pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, CLEANUPPROC pCleanUp, LPCRITICAL_SECTION pCritSec, IPin ** ppPin)
 287 {
 288     InputPin * pPinImpl;
 289
 290     *ppPin = NULL;
 291
 292     if (pPinInfo->dir != PINDIR_INPUT)
 293     {
 294         ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir);
 295         return E_INVALIDARG;
 296     }
 297
 298     pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl));
 299
 300     if (!pPinImpl)
 301         return E_OUTOFMEMORY;
 302
 303     if (SUCCEEDED(InputPin_Init(InputPin_Vtbl, pPinInfo, pSampleProc, pUserData, pQueryAccept, pCleanUp, pCritSec, pPinImpl)))
 304     {
 305         *ppPin = (IPin *)pPinImpl;
 306         return S_OK;
 307     }
 308
 309     CoTaskMemFree(pPinImpl);
 310     return E_FAIL;
 311 }
 312
 313 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)
 314 {
 315     OutputPin * pPinImpl;
 316
 317     *ppPin = NULL;
 318
 319     if (pPinInfo->dir != PINDIR_OUTPUT)
 320     {
 321         ERR("Pin direction(%x) != PINDIR_OUTPUT\n", pPinInfo->dir);
 322         return E_INVALIDARG;
 323     }
 324
 325     assert(outputpin_size >= sizeof(OutputPin));
 326
 327     pPinImpl = CoTaskMemAlloc(outputpin_size);
 328
 329     if (!pPinImpl)
 330         return E_OUTOFMEMORY;
 331
 332     if (SUCCEEDED(OutputPin_Init(OutputPin_Vtbl, pPinInfo, props, pUserData, pQueryAccept, pCritSec, pPinImpl)))
 333     {
 334         *ppPin = (IPin *)(&pPinImpl->pin.lpVtbl);
 335         return S_OK;
 336     }
 337
 338     CoTaskMemFree(pPinImpl);
 339     return E_FAIL;
 340 }
 341
 342 /*** Common pin functions ***/
 343
 344 ULONG WINAPI IPinImpl_AddRef(IPin * iface)
 345 {
 346     IPinImpl *This = (IPinImpl *)iface;
 347     ULONG refCount = InterlockedIncrement(&This->refCount);
 348
 349     TRACE("(%p)->() AddRef from %d\n", iface, refCount - 1);
 350
 351     return refCount;
 352 }
 353
 354 HRESULT WINAPI IPinImpl_Disconnect(IPin * iface)
 355 {
 356     HRESULT hr;
 357     IPinImpl *This = (IPinImpl *)iface;
 358
 359     TRACE("()\n");
 360
 361     EnterCriticalSection(This->pCritSec);
 362     {
 363         if (This->pConnectedTo)
 364         {
 365             IPin_Release(This->pConnectedTo);
 366             This->pConnectedTo = NULL;
 367             hr = S_OK;
 368         }
 369         else
 370             hr = S_FALSE;
 371     }
 372     LeaveCriticalSection(This->pCritSec);
 373
 374     return hr;
 375 }
 376
 377 HRESULT WINAPI IPinImpl_ConnectedTo(IPin * iface, IPin ** ppPin)
 378 {
 379     HRESULT hr;
 380     IPinImpl *This = (IPinImpl *)iface;
 381
 382     TRACE("(%p)\n", ppPin);
 383
 384     EnterCriticalSection(This->pCritSec);
 385     {
 386         if (This->pConnectedTo)
 387         {
 388             *ppPin = This->pConnectedTo;
 389             IPin_AddRef(*ppPin);
 390             hr = S_OK;
 391         }
 392         else
 393             hr = VFW_E_NOT_CONNECTED;
 394     }
 395     LeaveCriticalSection(This->pCritSec);
 396
 397     return hr;
 398 }
 399
 400 HRESULT WINAPI IPinImpl_ConnectionMediaType(IPin * iface, AM_MEDIA_TYPE * pmt)
 401 {
 402     HRESULT hr;
 403     IPinImpl *This = (IPinImpl *)iface;
 404
 405     TRACE("(%p/%p)->(%p)\n", This, iface, pmt);
 406
 407     EnterCriticalSection(This->pCritSec);
 408     {
 409         if (This->pConnectedTo)
 410         {
 411             CopyMediaType(pmt, &This->mtCurrent);
 412             hr = S_OK;
 413         }
 414         else
 415         {
 416             ZeroMemory(pmt, sizeof(*pmt));
 417             hr = VFW_E_NOT_CONNECTED;
 418         }
 419     }
 420     LeaveCriticalSection(This->pCritSec);
 421
 422     return hr;
 423 }
 424
 425 HRESULT WINAPI IPinImpl_QueryPinInfo(IPin * iface, PIN_INFO * pInfo)
 426 {
 427     IPinImpl *This = (IPinImpl *)iface;
 428
 429     TRACE("(%p/%p)->(%p)\n", This, iface, pInfo);
 430
 431     Copy_PinInfo(pInfo, &This->pinInfo);
 432     IBaseFilter_AddRef(pInfo->pFilter);
 433
 434     return S_OK;
 435 }
 436
 437 HRESULT WINAPI IPinImpl_QueryDirection(IPin * iface, PIN_DIRECTION * pPinDir)
 438 {
 439     IPinImpl *This = (IPinImpl *)iface;
 440
 441     TRACE("(%p/%p)->(%p)\n", This, iface, pPinDir);
 442
 443     *pPinDir = This->pinInfo.dir;
 444
 445     return S_OK;
 446 }
 447
 448 HRESULT WINAPI IPinImpl_QueryId(IPin * iface, LPWSTR * Id)
 449 {
 450     IPinImpl *This = (IPinImpl *)iface;
 451
 452     TRACE("(%p/%p)->(%p)\n", This, iface, Id);
 453
 454     *Id = CoTaskMemAlloc((strlenW(This->pinInfo.achName) + 1) * sizeof(WCHAR));
 455     if (!*Id)
 456         return E_OUTOFMEMORY;
 457
 458     strcpyW(*Id, This->pinInfo.achName);
 459
 460     return S_OK;
 461 }
 462
 463 HRESULT WINAPI IPinImpl_QueryAccept(IPin * iface, const AM_MEDIA_TYPE * pmt)
 464 {
 465     IPinImpl *This = (IPinImpl *)iface;
 466
 467     TRACE("(%p/%p)->(%p)\n", This, iface, pmt);
 468
 469     return (This->fnQueryAccept(This->pUserData, pmt) == S_OK ? S_OK : S_FALSE);
 470 }
 471
 472 HRESULT WINAPI IPinImpl_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum)
 473 {
 474     IPinImpl *This = (IPinImpl *)iface;
 475     ENUMMEDIADETAILS emd;
 476
 477     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 478
 479     /* override this method to allow enumeration of your types */
 480     emd.cMediaTypes = 0;
 481     emd.pMediaTypes = NULL;
 482
 483     return IEnumMediaTypesImpl_Construct(&emd, ppEnum);
 484 }
 485
 486 HRESULT WINAPI IPinImpl_QueryInternalConnections(IPin * iface, IPin ** apPin, ULONG * cPin)
 487 {
 488     IPinImpl *This = (IPinImpl *)iface;
 489
 490     TRACE("(%p/%p)->(%p, %p)\n", This, iface, apPin, cPin);
 491
 492     return E_NOTIMPL; /* to tell caller that all input pins connected to all output pins */
 493 }
 494
 495 /*** IPin implementation for an input pin ***/
 496
 497 HRESULT WINAPI InputPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
 498 {
 499     InputPin *This = (InputPin *)iface;
 500
 501     TRACE("(%p)->(%s, %p)\n", iface, qzdebugstr_guid(riid), ppv);
 502
 503     *ppv = NULL;
 504
 505     if (IsEqualIID(riid, &IID_IUnknown))
 506         *ppv = (LPVOID)iface;
 507     else if (IsEqualIID(riid, &IID_IPin))
 508         *ppv = (LPVOID)iface;
 509     else if (IsEqualIID(riid, &IID_IMemInputPin))
 510         *ppv = (LPVOID)&This->lpVtblMemInput;
 511     else if (IsEqualIID(riid, &IID_IMediaSeeking))
 512     {
 513         return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv);
 514     }
 515
 516     if (*ppv)
 517     {
 518         IUnknown_AddRef((IUnknown *)(*ppv));
 519         return S_OK;
 520     }
 521
 522     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 523
 524     return E_NOINTERFACE;
 525 }
 526
 527 ULONG WINAPI InputPin_Release(IPin * iface)
 528 {
 529     InputPin *This = (InputPin *)iface;
 530     ULONG refCount = InterlockedDecrement(&This->pin.refCount);
 531
 532     TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
 533
 534     if (!refCount)
 535     {
 536         FreeMediaType(&This->pin.mtCurrent);
 537         if (This->pAllocator)
 538             IMemAllocator_Release(This->pAllocator);
 539         CoTaskMemFree(This);
 540         return 0;
 541     }
 542     else
 543         return refCount;
 544 }
 545
 546 HRESULT WINAPI InputPin_Connect(IPin * iface, IPin * pConnector, const AM_MEDIA_TYPE * pmt)
 547 {
 548     ERR("Outgoing connection on an input pin! (%p, %p)\n", pConnector, pmt);
 549
 550     return E_UNEXPECTED;
 551 }
 552
 553
 554 HRESULT WINAPI InputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 555 {
 556     InputPin *This = (InputPin *)iface;
 557     PIN_DIRECTION pindirReceive;
 558     HRESULT hr = S_OK;
 559
 560     TRACE("(%p, %p)\n", pReceivePin, pmt);
 561     dump_AM_MEDIA_TYPE(pmt);
 562
 563     EnterCriticalSection(This->pin.pCritSec);
 564     {
 565         if (This->pin.pConnectedTo)
 566             hr = VFW_E_ALREADY_CONNECTED;
 567
 568         if (SUCCEEDED(hr) && This->pin.fnQueryAccept(This->pin.pUserData, pmt) != S_OK)
 569             hr = VFW_E_TYPE_NOT_ACCEPTED; /* FIXME: shouldn't we just map common errors onto
 570                                            * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */
 571
 572         if (SUCCEEDED(hr))
 573         {
 574             IPin_QueryDirection(pReceivePin, &pindirReceive);
 575
 576             if (pindirReceive != PINDIR_OUTPUT)
 577             {
 578                 ERR("Can't connect from non-output pin\n");
 579                 hr = VFW_E_INVALID_DIRECTION;
 580             }
 581         }
 582
 583         if (SUCCEEDED(hr))
 584         {
 585             CopyMediaType(&This->pin.mtCurrent, pmt);
 586             This->pin.pConnectedTo = pReceivePin;
 587             IPin_AddRef(pReceivePin);
 588         }
 589     }
 590     LeaveCriticalSection(This->pin.pCritSec);
 591
 592     return hr;
 593 }
 594
 595 static HRESULT deliver_endofstream(IPin* pin, LPVOID unused)
 596 {
 597     return IPin_EndOfStream( pin );
 598 }
 599
 600 HRESULT WINAPI InputPin_EndOfStream(IPin * iface)
 601 {
 602     InputPin *This = (InputPin *)iface;
 603     TRACE("(%p)\n", This);
 604
 605     This->end_of_stream = 1;
 606
 607     return SendFurther( iface, deliver_endofstream, NULL, NULL );
 608 }
 609
 610 static HRESULT deliver_beginflush(IPin* pin, LPVOID unused)
 611 {
 612     return IPin_BeginFlush( pin );
 613 }
 614
 615 HRESULT WINAPI InputPin_BeginFlush(IPin * iface)
 616 {
 617     InputPin *This = (InputPin *)iface;
 618     HRESULT hr;
 619     TRACE("() semi-stub\n");
 620
 621     /* Assign this outside the critical section so that _Receive loops can be broken */
 622     This->flushing = 1;
 623
 624     EnterCriticalSection(This->pin.pCritSec);
 625
 626     if (This->fnCleanProc)
 627         This->fnCleanProc(This->pin.pUserData);
 628
 629     hr = SendFurther( iface, deliver_beginflush, NULL, NULL );
 630     LeaveCriticalSection(This->pin.pCritSec);
 631     return hr;
 632 }
 633
 634 static HRESULT deliver_endflush(IPin* pin, LPVOID unused)
 635 {
 636     return IPin_EndFlush( pin );
 637 }
 638
 639 HRESULT WINAPI InputPin_EndFlush(IPin * iface)
 640 {
 641     InputPin *This = (InputPin *)iface;
 642     HRESULT hr;
 643     TRACE("(%p)\n", This);
 644
 645     EnterCriticalSection(This->pin.pCritSec);
 646     This->flushing = 0;
 647
 648     hr = SendFurther( iface, deliver_endflush, NULL, NULL );
 649     LeaveCriticalSection(This->pin.pCritSec);
 650
 651     return hr;
 652 }
 653
 654 typedef struct newsegmentargs
 655 {
 656     REFERENCE_TIME tStart, tStop;
 657     double rate;
 658 } newsegmentargs;
 659
 660 static HRESULT deliver_newsegment(IPin *pin, LPVOID data)
 661 {
 662     newsegmentargs *args = data;
 663     return IPin_NewSegment(pin, args->tStart, args->tStop, args->rate);
 664 }
 665
 666 HRESULT WINAPI InputPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
 667 {
 668     InputPin *This = (InputPin *)iface;
 669     newsegmentargs args;
 670
 671     TRACE("(%x%08x, %x%08x, %e)\n", (ULONG)(tStart >> 32), (ULONG)tStart, (ULONG)(tStop >> 32), (ULONG)tStop, dRate);
 672
 673     args.tStart = This->tStart = tStart;
 674     args.tStop = This->tStop = tStop;
 675     args.rate = This->dRate = dRate;
 676
 677     return SendFurther( iface, deliver_newsegment, &args, NULL );
 678 }
 679
 680 static const IPinVtbl InputPin_Vtbl =
 681 {
 682     InputPin_QueryInterface,
 683     IPinImpl_AddRef,
 684     InputPin_Release,
 685     InputPin_Connect,
 686     InputPin_ReceiveConnection,
 687     IPinImpl_Disconnect,
 688     IPinImpl_ConnectedTo,
 689     IPinImpl_ConnectionMediaType,
 690     IPinImpl_QueryPinInfo,
 691     IPinImpl_QueryDirection,
 692     IPinImpl_QueryId,
 693     IPinImpl_QueryAccept,
 694     IPinImpl_EnumMediaTypes,
 695     IPinImpl_QueryInternalConnections,
 696     InputPin_EndOfStream,
 697     InputPin_BeginFlush,
 698     InputPin_EndFlush,
 699     InputPin_NewSegment
 700 };
 701
 702 /*** IMemInputPin implementation ***/
 703
 704 HRESULT WINAPI MemInputPin_QueryInterface(IMemInputPin * iface, REFIID riid, LPVOID * ppv)
 705 {
 706     InputPin *This = impl_from_IMemInputPin(iface);
 707
 708     return IPin_QueryInterface((IPin *)&This->pin, riid, ppv);
 709 }
 710
 711 ULONG WINAPI MemInputPin_AddRef(IMemInputPin * iface)
 712 {
 713     InputPin *This = impl_from_IMemInputPin(iface);
 714
 715     return IPin_AddRef((IPin *)&This->pin);
 716 }
 717
 718 ULONG WINAPI MemInputPin_Release(IMemInputPin * iface)
 719 {
 720     InputPin *This = impl_from_IMemInputPin(iface);
 721
 722     return IPin_Release((IPin *)&This->pin);
 723 }
 724
 725 HRESULT WINAPI MemInputPin_GetAllocator(IMemInputPin * iface, IMemAllocator ** ppAllocator)
 726 {
 727     InputPin *This = impl_from_IMemInputPin(iface);
 728
 729     TRACE("(%p/%p)->(%p)\n", This, iface, ppAllocator);
 730
 731     *ppAllocator = This->pAllocator;
 732     if (*ppAllocator)
 733         IMemAllocator_AddRef(*ppAllocator);
 734
 735     return *ppAllocator ? S_OK : VFW_E_NO_ALLOCATOR;
 736 }
 737
 738 HRESULT WINAPI MemInputPin_NotifyAllocator(IMemInputPin * iface, IMemAllocator * pAllocator, BOOL bReadOnly)
 739 {
 740     InputPin *This = impl_from_IMemInputPin(iface);
 741
 742     TRACE("(%p/%p)->(%p, %d)\n", This, iface, pAllocator, bReadOnly);
 743
 744     if (This->pAllocator)
 745         IMemAllocator_Release(This->pAllocator);
 746     This->pAllocator = pAllocator;
 747     if (This->pAllocator)
 748         IMemAllocator_AddRef(This->pAllocator);
 749
 750     return S_OK;
 751 }
 752
 753 HRESULT WINAPI MemInputPin_GetAllocatorRequirements(IMemInputPin * iface, ALLOCATOR_PROPERTIES * pProps)
 754 {
 755     InputPin *This = impl_from_IMemInputPin(iface);
 756
 757     TRACE("(%p/%p)->(%p)\n", This, iface, pProps);
 758
 759     /* override this method if you have any specific requirements */
 760
 761     return E_NOTIMPL;
 762 }
 763
 764 HRESULT WINAPI MemInputPin_Receive(IMemInputPin * iface, IMediaSample * pSample)
 765 {
 766     InputPin *This = impl_from_IMemInputPin(iface);
 767     HRESULT hr;
 768
 769     /* this trace commented out for performance reasons */
 770     /*TRACE("(%p/%p)->(%p)\n", This, iface, pSample);*/
 771
 772     EnterCriticalSection(This->pin.pCritSec);
 773     if (!This->end_of_stream && !This->flushing && !This->end_of_stream)
 774         hr = This->fnSampleProc(This->pin.pUserData, pSample);
 775     else
 776         hr = S_FALSE;
 777     LeaveCriticalSection(This->pin.pCritSec);
 778     return hr;
 779 }
 780
 781 HRESULT WINAPI MemInputPin_ReceiveMultiple(IMemInputPin * iface, IMediaSample ** pSamples, long nSamples, long *nSamplesProcessed)
 782 {
 783     HRESULT hr = S_OK;
 784     InputPin *This = impl_from_IMemInputPin(iface);
 785
 786     TRACE("(%p/%p)->(%p, %ld, %p)\n", This, iface, pSamples, nSamples, nSamplesProcessed);
 787
 788     for (*nSamplesProcessed = 0; *nSamplesProcessed < nSamples; (*nSamplesProcessed)++)
 789     {
 790         hr = IMemInputPin_Receive(iface, pSamples[*nSamplesProcessed]);
 791         if (hr != S_OK)
 792             break;
 793     }
 794
 795     return hr;
 796 }
 797
 798 HRESULT WINAPI MemInputPin_ReceiveCanBlock(IMemInputPin * iface)
 799 {
 800     InputPin *This = impl_from_IMemInputPin(iface);
 801
 802     FIXME("(%p/%p)->()\n", This, iface);
 803
 804     /* FIXME: we should check whether any output pins will block */
 805
 806     return S_OK;
 807 }
 808
 809 static const IMemInputPinVtbl MemInputPin_Vtbl =
 810 {
 811     MemInputPin_QueryInterface,
 812     MemInputPin_AddRef,
 813     MemInputPin_Release,
 814     MemInputPin_GetAllocator,
 815     MemInputPin_NotifyAllocator,
 816     MemInputPin_GetAllocatorRequirements,
 817     MemInputPin_Receive,
 818     MemInputPin_ReceiveMultiple,
 819     MemInputPin_ReceiveCanBlock
 820 };
 821
 822 HRESULT WINAPI OutputPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
 823 {
 824     OutputPin *This = (OutputPin *)iface;
 825
 826     TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
 827
 828     *ppv = NULL;
 829
 830     if (IsEqualIID(riid, &IID_IUnknown))
 831         *ppv = (LPVOID)iface;
 832     else if (IsEqualIID(riid, &IID_IPin))
 833         *ppv = (LPVOID)iface;
 834     else if (IsEqualIID(riid, &IID_IMediaSeeking))
 835     {
 836         return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv);
 837     }
 838
 839     if (*ppv)
 840     {
 841         IUnknown_AddRef((IUnknown *)(*ppv));
 842         return S_OK;
 843     }
 844
 845     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 846
 847     return E_NOINTERFACE;
 848 }
 849
 850 ULONG WINAPI OutputPin_Release(IPin * iface)
 851 {
 852     OutputPin *This = (OutputPin *)iface;
 853     ULONG refCount = InterlockedDecrement(&This->pin.refCount);
 854
 855     TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
 856
 857     if (!refCount)
 858     {
 859         FreeMediaType(&This->pin.mtCurrent);
 860         CoTaskMemFree(This);
 861         return 0;
 862     }
 863     return refCount;
 864 }
 865
 866 HRESULT WINAPI OutputPin_Connect(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 867 {
 868     HRESULT hr;
 869     OutputPin *This = (OutputPin *)iface;
 870
 871     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt);
 872     dump_AM_MEDIA_TYPE(pmt);
 873
 874     /* If we try to connect to ourself, we will definitely deadlock.
 875      * There are other cases where we could deadlock too, but this
 876      * catches the obvious case */
 877     assert(pReceivePin != iface);
 878
 879     EnterCriticalSection(This->pin.pCritSec);
 880     {
 881         /* if we have been a specific type to connect with, then we can either connect
 882          * with that or fail. We cannot choose different AM_MEDIA_TYPE */
 883         if (pmt && !IsEqualGUID(&pmt->majortype, &GUID_NULL) && !IsEqualGUID(&pmt->subtype, &GUID_NULL))
 884             hr = This->pConnectSpecific(iface, pReceivePin, pmt);
 885         else
 886         {
 887             /* negotiate media type */
 888
 889             IEnumMediaTypes * pEnumCandidates;
 890             AM_MEDIA_TYPE * pmtCandidate; /* Candidate media type */
 891
 892             if (SUCCEEDED(hr = IPin_EnumMediaTypes(iface, &pEnumCandidates)))
 893             {
 894                 hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */
 895
 896                 /* try this filter's media types first */
 897                 while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL))
 898                 {
 899                     if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) &&
 900                         (This->pConnectSpecific(iface, pReceivePin, pmtCandidate) == S_OK))
 901                     {
 902                         hr = S_OK;
 903                         CoTaskMemFree(pmtCandidate);
 904                         break;
 905                     }
 906                     CoTaskMemFree(pmtCandidate);
 907                 }
 908                 IEnumMediaTypes_Release(pEnumCandidates);
 909             }
 910
 911             /* then try receiver filter's media types */
 912             if (hr != S_OK && SUCCEEDED(hr = IPin_EnumMediaTypes(pReceivePin, &pEnumCandidates))) /* if we haven't already connected successfully */
 913             {
 914                 hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */
 915
 916                 while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL))
 917                 {
 918                     if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) &&
 919                         (This->pConnectSpecific(iface, pReceivePin, pmtCandidate) == S_OK))
 920                     {
 921                         hr = S_OK;
 922                         CoTaskMemFree(pmtCandidate);
 923                         break;
 924                     }
 925                     CoTaskMemFree(pmtCandidate);
 926                 } /* while */
 927                 IEnumMediaTypes_Release(pEnumCandidates);
 928             } /* if not found */
 929         } /* if negotiate media type */
 930     } /* if succeeded */
 931     LeaveCriticalSection(This->pin.pCritSec);
 932
 933     TRACE(" -- %x\n", hr);
 934     return hr;
 935 }
 936
 937 HRESULT WINAPI OutputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 938 {
 939     ERR("Incoming connection on an output pin! (%p, %p)\n", pReceivePin, pmt);
 940
 941     return E_UNEXPECTED;
 942 }
 943
 944 HRESULT WINAPI OutputPin_Disconnect(IPin * iface)
 945 {
 946     HRESULT hr;
 947     OutputPin *This = (OutputPin *)iface;
 948
 949     TRACE("()\n");
 950
 951     EnterCriticalSection(This->pin.pCritSec);
 952     {
 953         if (This->pMemInputPin)
 954         {
 955             IMemInputPin_Release(This->pMemInputPin);
 956             This->pMemInputPin = NULL;
 957         }
 958         if (This->pin.pConnectedTo)
 959         {
 960             IPin_Release(This->pin.pConnectedTo);
 961             This->pin.pConnectedTo = NULL;
 962             hr = S_OK;
 963         }
 964         else
 965             hr = S_FALSE;
 966     }
 967     LeaveCriticalSection(This->pin.pCritSec);
 968
 969     return hr;
 970 }
 971
 972 HRESULT WINAPI OutputPin_EndOfStream(IPin * iface)
 973 {
 974     TRACE("()\n");
 975
 976     /* not supposed to do anything in an output pin */
 977
 978     return E_UNEXPECTED;
 979 }
 980
 981 HRESULT WINAPI OutputPin_BeginFlush(IPin * iface)
 982 {
 983     TRACE("(%p)->()\n", iface);
 984
 985     /* not supposed to do anything in an output pin */
 986
 987     return E_UNEXPECTED;
 988 }
 989
 990 HRESULT WINAPI OutputPin_EndFlush(IPin * iface)
 991 {
 992     TRACE("(%p)->()\n", iface);
 993
 994     /* not supposed to do anything in an output pin */
 995
 996     return E_UNEXPECTED;
 997 }
 998
 999 HRESULT WINAPI OutputPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
1000 {
1001     TRACE("(%p)->(%x%08x, %x%08x, %e)\n", iface, (ULONG)(tStart >> 32), (ULONG)tStart, (ULONG)(tStop >> 32), (ULONG)tStop, dRate);
1002
1003     /* not supposed to do anything in an output pin */
1004
1005     return E_UNEXPECTED;
1006 }
1007
1008 static const IPinVtbl OutputPin_Vtbl =
1009 {
1010     OutputPin_QueryInterface,
1011     IPinImpl_AddRef,
1012     OutputPin_Release,
1013     OutputPin_Connect,
1014     OutputPin_ReceiveConnection,
1015     OutputPin_Disconnect,
1016     IPinImpl_ConnectedTo,
1017     IPinImpl_ConnectionMediaType,
1018     IPinImpl_QueryPinInfo,
1019     IPinImpl_QueryDirection,
1020     IPinImpl_QueryId,
1021     IPinImpl_QueryAccept,
1022     IPinImpl_EnumMediaTypes,
1023     IPinImpl_QueryInternalConnections,
1024     OutputPin_EndOfStream,
1025     OutputPin_BeginFlush,
1026     OutputPin_EndFlush,
1027     OutputPin_NewSegment
1028 };
1029
1030 HRESULT OutputPin_GetDeliveryBuffer(OutputPin * This, IMediaSample ** ppSample, REFERENCE_TIME * tStart, REFERENCE_TIME * tStop, DWORD dwFlags)
1031 {
1032     HRESULT hr;
1033
1034     TRACE("(%p, %p, %p, %x)\n", ppSample, tStart, tStop, dwFlags);
1035
1036     EnterCriticalSection(This->pin.pCritSec);
1037     {
1038         if (!This->pin.pConnectedTo)
1039             hr = VFW_E_NOT_CONNECTED;
1040         else
1041         {
1042             IMemAllocator * pAlloc = NULL;
1043
1044             hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc);
1045
1046             if (SUCCEEDED(hr))
1047                 hr = IMemAllocator_GetBuffer(pAlloc, ppSample, tStart, tStop, dwFlags);
1048
1049             if (SUCCEEDED(hr))
1050                 hr = IMediaSample_SetTime(*ppSample, tStart, tStop);
1051
1052             if (pAlloc)
1053                 IMemAllocator_Release(pAlloc);
1054         }
1055     }
1056     LeaveCriticalSection(This->pin.pCritSec);
1057
1058     return hr;
1059 }
1060
1061 HRESULT OutputPin_SendSample(OutputPin * This, IMediaSample * pSample)
1062 {
1063     HRESULT hr = S_OK;
1064     IMemInputPin * pMemConnected = NULL;
1065     PIN_INFO pinInfo;
1066
1067     EnterCriticalSection(This->pin.pCritSec);
1068     {
1069         if (!This->pin.pConnectedTo || !This->pMemInputPin)
1070             hr = VFW_E_NOT_CONNECTED;
1071         else
1072         {
1073             /* we don't have the lock held when using This->pMemInputPin,
1074              * so we need to AddRef it to stop it being deleted while we are
1075              * using it. Same with its filter. */
1076             pMemConnected = This->pMemInputPin;
1077             IMemInputPin_AddRef(pMemConnected);
1078             hr = IPin_QueryPinInfo(This->pin.pConnectedTo, &pinInfo);
1079         }
1080     }
1081     LeaveCriticalSection(This->pin.pCritSec);
1082
1083     if (SUCCEEDED(hr))
1084     {
1085         /* NOTE: if we are in a critical section when Receive is called
1086          * then it causes some problems (most notably with the native Video
1087          * Renderer) if we are re-entered for whatever reason */
1088         hr = IMemInputPin_Receive(pMemConnected, pSample);
1089
1090         /* If the filter's destroyed, tell upstream to stop sending data */
1091         if(IBaseFilter_Release(pinInfo.pFilter) == 0 && SUCCEEDED(hr))
1092             hr = S_FALSE;
1093     }
1094     if (pMemConnected)
1095         IMemInputPin_Release(pMemConnected);
1096
1097     return hr;
1098 }
1099
1100 HRESULT OutputPin_DeliverNewSegment(OutputPin * This, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
1101 {
1102     HRESULT hr;
1103
1104     EnterCriticalSection(This->pin.pCritSec);
1105     {
1106         if (!This->pin.pConnectedTo)
1107             hr = VFW_E_NOT_CONNECTED;
1108         else
1109             hr = IPin_NewSegment(This->pin.pConnectedTo, tStart, tStop, dRate);
1110     }
1111     LeaveCriticalSection(This->pin.pCritSec);
1112
1113     return hr;
1114 }
1115
1116 HRESULT OutputPin_CommitAllocator(OutputPin * This)
1117 {
1118     HRESULT hr;
1119
1120     TRACE("(%p)->()\n", This);
1121
1122     EnterCriticalSection(This->pin.pCritSec);
1123     {
1124         if (!This->pin.pConnectedTo || !This->pMemInputPin)
1125             hr = VFW_E_NOT_CONNECTED;
1126         else
1127         {
1128             IMemAllocator * pAlloc = NULL;
1129
1130             hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc);
1131
1132             if (SUCCEEDED(hr))
1133                 hr = IMemAllocator_Commit(pAlloc);
1134
1135             if (pAlloc)
1136                 IMemAllocator_Release(pAlloc);
1137         }
1138     }
1139     LeaveCriticalSection(This->pin.pCritSec);
1140
1141     return hr;
1142 }
1143
1144 HRESULT OutputPin_DeliverDisconnect(OutputPin * This)
1145 {
1146     HRESULT hr;
1147
1148     TRACE("(%p)->()\n", This);
1149
1150     EnterCriticalSection(This->pin.pCritSec);
1151     {
1152         if (!This->pin.pConnectedTo || !This->pMemInputPin)
1153             hr = VFW_E_NOT_CONNECTED;
1154         else
1155         {
1156             IMemAllocator * pAlloc = NULL;
1157
1158             hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc);
1159
1160             if (SUCCEEDED(hr))
1161                 hr = IMemAllocator_Decommit(pAlloc);
1162
1163             if (pAlloc)
1164                 IMemAllocator_Release(pAlloc);
1165
1166             if (SUCCEEDED(hr))
1167                 hr = IPin_Disconnect(This->pin.pConnectedTo);
1168         }
1169     }
1170     LeaveCriticalSection(This->pin.pCritSec);
1171
1172     return hr;
1173 }
1174
1175
1176 static HRESULT PullPin_Init(const IPinVtbl *PullPin_Vtbl, const PIN_INFO * pPinInfo, SAMPLEPROC pSampleProc, LPVOID pUserData,
1177                             QUERYACCEPTPROC pQueryAccept, CLEANUPPROC pCleanUp, LPCRITICAL_SECTION pCritSec, PullPin * pPinImpl)
1178 {
1179     /* Common attributes */
1180     pPinImpl->pin.lpVtbl = PullPin_Vtbl;
1181     pPinImpl->pin.refCount = 1;
1182     pPinImpl->pin.pConnectedTo = NULL;
1183     pPinImpl->pin.fnQueryAccept = pQueryAccept;
1184     pPinImpl->pin.pUserData = pUserData;
1185     pPinImpl->pin.pCritSec = pCritSec;
1186     Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
1187     ZeroMemory(&pPinImpl->pin.mtCurrent, sizeof(AM_MEDIA_TYPE));
1188
1189     /* Input pin attributes */
1190     pPinImpl->fnSampleProc = pSampleProc;
1191     pPinImpl->fnCleanProc = pCleanUp;
1192     pPinImpl->fnPreConnect = NULL;
1193     pPinImpl->pAlloc = NULL;
1194     pPinImpl->pReader = NULL;
1195     pPinImpl->hThread = NULL;
1196     pPinImpl->hEventStateChanged = CreateEventW(NULL, TRUE, TRUE, NULL);
1197
1198     pPinImpl->rtStart = 0;
1199     pPinImpl->rtCurrent = 0;
1200     pPinImpl->rtStop = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
1201     pPinImpl->state = State_Stopped;
1202
1203     return S_OK;
1204 }
1205
1206 HRESULT PullPin_Construct(const IPinVtbl *PullPin_Vtbl, const PIN_INFO * pPinInfo, SAMPLEPROC pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, CLEANUPPROC pCleanUp, LPCRITICAL_SECTION pCritSec, IPin ** ppPin)
1207 {
1208     PullPin * pPinImpl;
1209
1210     *ppPin = NULL;
1211
1212     if (pPinInfo->dir != PINDIR_INPUT)
1213     {
1214         ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir);
1215         return E_INVALIDARG;
1216     }
1217
1218     pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl));
1219
1220     if (!pPinImpl)
1221         return E_OUTOFMEMORY;
1222
1223     if (SUCCEEDED(PullPin_Init(PullPin_Vtbl, pPinInfo, pSampleProc, pUserData, pQueryAccept, pCleanUp, pCritSec, pPinImpl)))
1224     {
1225         *ppPin = (IPin *)(&pPinImpl->pin.lpVtbl);
1226         return S_OK;
1227     }
1228
1229     CoTaskMemFree(pPinImpl);
1230     return E_FAIL;
1231 }
1232
1233 HRESULT WINAPI PullPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
1234 {
1235     PIN_DIRECTION pindirReceive;
1236     HRESULT hr = S_OK;
1237     PullPin *This = (PullPin *)iface;
1238
1239     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt);
1240     dump_AM_MEDIA_TYPE(pmt);
1241
1242     EnterCriticalSection(This->pin.pCritSec);
1243     {
1244         if (This->pin.pConnectedTo)
1245             hr = VFW_E_ALREADY_CONNECTED;
1246
1247         if (SUCCEEDED(hr) && (This->pin.fnQueryAccept(This->pin.pUserData, pmt) != S_OK))
1248             hr = VFW_E_TYPE_NOT_ACCEPTED; /* FIXME: shouldn't we just map common errors onto
1249                                            * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */
1250
1251         if (SUCCEEDED(hr))
1252         {
1253             IPin_QueryDirection(pReceivePin, &pindirReceive);
1254
1255             if (pindirReceive != PINDIR_OUTPUT)
1256             {
1257                 ERR("Can't connect from non-output pin\n");
1258                 hr = VFW_E_INVALID_DIRECTION;
1259             }
1260         }
1261
1262         This->pReader = NULL;
1263         This->pAlloc = NULL;
1264         if (SUCCEEDED(hr))
1265         {
1266             hr = IPin_QueryInterface(pReceivePin, &IID_IAsyncReader, (LPVOID *)&This->pReader);
1267         }
1268
1269         if (SUCCEEDED(hr))
1270         {
1271             ALLOCATOR_PROPERTIES props;
1272             props.cBuffers = 3;
1273             props.cbBuffer = 64 * 1024; /* 64k bytes */
1274             props.cbAlign = 1;
1275             props.cbPrefix = 0;
1276             hr = IAsyncReader_RequestAllocator(This->pReader, NULL, &props, &This->pAlloc);
1277         }
1278
1279         if (SUCCEEDED(hr) && This->fnPreConnect)
1280         {
1281             hr = This->fnPreConnect(iface, pReceivePin);
1282         }
1283
1284         if (SUCCEEDED(hr))
1285         {
1286             CopyMediaType(&This->pin.mtCurrent, pmt);
1287             This->pin.pConnectedTo = pReceivePin;
1288             IPin_AddRef(pReceivePin);
1289         }
1290         else
1291         {
1292              if (This->pReader)
1293                  IAsyncReader_Release(This->pReader);
1294              This->pReader = NULL;
1295              if (This->pAlloc)
1296                  IMemAllocator_Release(This->pAlloc);
1297              This->pAlloc = NULL;
1298         }
1299     }
1300     LeaveCriticalSection(This->pin.pCritSec);
1301     return hr;
1302 }
1303
1304 HRESULT WINAPI PullPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
1305 {
1306     PullPin *This = (PullPin *)iface;
1307
1308     TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
1309
1310     *ppv = NULL;
1311
1312     if (IsEqualIID(riid, &IID_IUnknown))
1313         *ppv = (LPVOID)iface;
1314     else if (IsEqualIID(riid, &IID_IPin))
1315         *ppv = (LPVOID)iface;
1316     else if (IsEqualIID(riid, &IID_IMediaSeeking))
1317     {
1318         return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv);
1319     }
1320
1321     if (*ppv)
1322     {
1323         IUnknown_AddRef((IUnknown *)(*ppv));
1324         return S_OK;
1325     }
1326
1327     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
1328
1329     return E_NOINTERFACE;
1330 }
1331
1332 ULONG WINAPI PullPin_Release(IPin * iface)
1333 {
1334     PullPin *This = (PullPin *)iface;
1335     ULONG refCount = InterlockedDecrement(&This->pin.refCount);
1336
1337     TRACE("(%p)->() Release from %d\n", This, refCount + 1);
1338
1339     if (!refCount)
1340     {
1341         if(This->pAlloc)
1342             IMemAllocator_Release(This->pAlloc);
1343         if(This->pReader)
1344             IAsyncReader_Release(This->pReader);
1345         CloseHandle(This->hEventStateChanged);
1346         CoTaskMemFree(This);
1347         return 0;
1348     }
1349     return refCount;
1350 }
1351
1352 static DWORD WINAPI PullPin_Thread_Main(LPVOID pv)
1353 {
1354     for (;;)
1355         SleepEx(INFINITE, TRUE);
1356 }
1357
1358 static void CALLBACK PullPin_Thread_Process(ULONG_PTR iface)
1359 {
1360     PullPin *This = (PullPin *)iface;
1361     HRESULT hr;
1362
1363     ALLOCATOR_PROPERTIES allocProps;
1364
1365     CoInitializeEx(NULL, COINIT_MULTITHREADED);
1366
1367     EnterCriticalSection(This->pin.pCritSec);
1368     SetEvent(This->hEventStateChanged);
1369     This->state = State_Running;
1370     LeaveCriticalSection(This->pin.pCritSec);
1371
1372     hr = IMemAllocator_GetProperties(This->pAlloc, &allocProps);
1373
1374     if (This->rtCurrent < This->rtStart)
1375         This->rtCurrent = MEDIATIME_FROM_BYTES(ALIGNDOWN(BYTES_FROM_MEDIATIME(This->rtStart), allocProps.cbAlign));
1376
1377     TRACE("Start\n");
1378
1379     while (This->rtCurrent < This->rtStop && hr == S_OK && !This->stop_playback)
1380     {
1381         /* FIXME: to improve performance by quite a bit this should be changed
1382          * so that one sample is processed while one sample is fetched. However,
1383          * it is harder to debug so for the moment it will stay as it is */
1384         IMediaSample * pSample = NULL;
1385         REFERENCE_TIME rtSampleStart;
1386         REFERENCE_TIME rtSampleStop;
1387         DWORD_PTR dwUser;
1388
1389         TRACE("Process sample\n");
1390
1391         hr = IMemAllocator_GetBuffer(This->pAlloc, &pSample, NULL, NULL, 0);
1392
1393         if (SUCCEEDED(hr))
1394         {
1395             rtSampleStart = This->rtCurrent;
1396             rtSampleStop = rtSampleStart + MEDIATIME_FROM_BYTES(IMediaSample_GetSize(pSample));
1397             if (rtSampleStop > This->rtStop)
1398                 rtSampleStop = MEDIATIME_FROM_BYTES(ALIGNUP(BYTES_FROM_MEDIATIME(This->rtStop), allocProps.cbAlign));
1399             hr = IMediaSample_SetTime(pSample, &rtSampleStart, &rtSampleStop);
1400             This->rtCurrent = rtSampleStop;
1401         }
1402
1403         if (SUCCEEDED(hr))
1404             hr = IAsyncReader_Request(This->pReader, pSample, (ULONG_PTR)0);
1405
1406         if (SUCCEEDED(hr))
1407             hr = IAsyncReader_WaitForNext(This->pReader, 1000, &pSample, &dwUser);
1408
1409         if (SUCCEEDED(hr))
1410         {
1411             rtSampleStop = rtSampleStart + MEDIATIME_FROM_BYTES(IMediaSample_GetActualDataLength(pSample));
1412             if (rtSampleStop > This->rtStop)
1413                 rtSampleStop = MEDIATIME_FROM_BYTES(ALIGNUP(BYTES_FROM_MEDIATIME(This->rtStop), allocProps.cbAlign));
1414             hr = IMediaSample_SetTime(pSample, &rtSampleStart, &rtSampleStop);
1415         }
1416
1417         if (SUCCEEDED(hr))
1418             hr = This->fnSampleProc(This->pin.pUserData, pSample);
1419         else
1420             ERR("Processing error: %x\n", hr);
1421
1422         if (pSample)
1423             IMediaSample_Release(pSample);
1424     }
1425
1426     CoUninitialize();
1427     EnterCriticalSection(This->pin.pCritSec);
1428     This->state = State_Paused;
1429     LeaveCriticalSection(This->pin.pCritSec);
1430     TRACE("End\n");
1431 }
1432
1433 static void CALLBACK PullPin_Thread_Pause(ULONG_PTR iface)
1434 {
1435     PullPin *This = (PullPin *)iface;
1436
1437     TRACE("(%p/%p)->()\n", This, (LPVOID)iface);
1438
1439     EnterCriticalSection(This->pin.pCritSec);
1440     {
1441         This->state = State_Paused;
1442         SetEvent(This->hEventStateChanged);
1443     }
1444     LeaveCriticalSection(This->pin.pCritSec);
1445 }
1446
1447
1448 static void CALLBACK PullPin_Thread_Stop(ULONG_PTR iface)
1449 {
1450     PullPin *This = (PullPin *)iface;
1451
1452     TRACE("(%p/%p)->()\n", This, (LPVOID)iface);
1453
1454     EnterCriticalSection(This->pin.pCritSec);
1455     {
1456         HRESULT hr;
1457
1458         CloseHandle(This->hThread);
1459         This->hThread = NULL;
1460         if (FAILED(hr = IMemAllocator_Decommit(This->pAlloc)))
1461             ERR("Allocator decommit failed with error %x. Possible memory leak\n", hr);
1462
1463         SetEvent(This->hEventStateChanged);
1464         This->state = State_Stopped;
1465     }
1466     LeaveCriticalSection(This->pin.pCritSec);
1467
1468     IBaseFilter_Release(This->pin.pinInfo.pFilter);
1469
1470     ExitThread(0);
1471 }
1472
1473 HRESULT PullPin_InitProcessing(PullPin * This)
1474 {
1475     HRESULT hr = S_OK;
1476
1477     TRACE("(%p)->()\n", This);
1478
1479     /* if we are connected */
1480     if (This->pAlloc)
1481     {
1482         WaitForSingleObject(This->hEventStateChanged, INFINITE);
1483         EnterCriticalSection(This->pin.pCritSec);
1484         if (This->state == State_Stopped)
1485         {
1486             DWORD dwThreadId;
1487             assert(!This->hThread);
1488
1489             /* AddRef the filter to make sure it and it's pins will be around
1490              * as long as the thread */
1491             IBaseFilter_AddRef(This->pin.pinInfo.pFilter);
1492
1493             This->hThread = CreateThread(NULL, 0, PullPin_Thread_Main, NULL, 0, &dwThreadId);
1494             if (!This->hThread)
1495             {
1496                 hr = HRESULT_FROM_WIN32(GetLastError());
1497                 IBaseFilter_Release(This->pin.pinInfo.pFilter);
1498             }
1499
1500             if (SUCCEEDED(hr))
1501             {
1502                 hr = IMemAllocator_Commit(This->pAlloc);
1503                 This->state = State_Paused;
1504                 SetEvent(This->hEventStateChanged);
1505             }
1506         }
1507         else assert(This->hThread);
1508         LeaveCriticalSection(This->pin.pCritSec);
1509     }
1510
1511     TRACE(" -- %x\n", hr);
1512
1513     return hr;
1514 }
1515
1516 HRESULT PullPin_StartProcessing(PullPin * This)
1517 {
1518     /* if we are connected */
1519     TRACE("(%p)->()\n", This);
1520     if(This->pAlloc)
1521     {
1522         assert(This->hThread);
1523
1524         PullPin_WaitForStateChange(This, INFINITE);
1525         ResetEvent(This->hEventStateChanged);
1526         This->stop_playback = 0;
1527
1528         if (!QueueUserAPC(PullPin_Thread_Process, This->hThread, (ULONG_PTR)This))
1529             return HRESULT_FROM_WIN32(GetLastError());
1530     }
1531
1532     return S_OK;
1533 }
1534
1535 HRESULT PullPin_PauseProcessing(PullPin * This)
1536 {
1537     /* if we are connected */
1538     TRACE("(%p)->()\n", This);
1539     if(This->pAlloc)
1540     {
1541         assert(This->hThread);
1542
1543         PullPin_WaitForStateChange(This, INFINITE);
1544         EnterCriticalSection(This->pin.pCritSec);
1545         This->stop_playback = 1;
1546         LeaveCriticalSection(This->pin.pCritSec);
1547         ResetEvent(This->hEventStateChanged);
1548
1549         if (!QueueUserAPC(PullPin_Thread_Pause, This->hThread, (ULONG_PTR)This))
1550             return HRESULT_FROM_WIN32(GetLastError());
1551     }
1552
1553     return S_OK;
1554 }
1555
1556 HRESULT PullPin_StopProcessing(PullPin * This)
1557 {
1558     /* if we are connected */
1559     if (This->pAlloc && This->hThread)
1560     {
1561         PullPin_WaitForStateChange(This, INFINITE);
1562
1563         This->stop_playback = 1;
1564         ResetEvent(This->hEventStateChanged);
1565
1566         if (!QueueUserAPC(PullPin_Thread_Stop, This->hThread, (ULONG_PTR)This))
1567             return HRESULT_FROM_WIN32(GetLastError());
1568     }
1569
1570     return S_OK;
1571 }
1572
1573 HRESULT PullPin_WaitForStateChange(PullPin * This, DWORD dwMilliseconds)
1574 {
1575     if (WaitForSingleObject(This->hEventStateChanged, dwMilliseconds) == WAIT_TIMEOUT)
1576         return S_FALSE;
1577     return S_OK;
1578 }
1579
1580 HRESULT WINAPI PullPin_EndOfStream(IPin * iface)
1581 {
1582     FIXME("(%p)->() stub\n", iface);
1583
1584     return SendFurther( iface, deliver_endofstream, NULL, NULL );
1585 }
1586
1587 HRESULT WINAPI PullPin_BeginFlush(IPin * iface)
1588 {
1589     PullPin *This = (PullPin *)iface;
1590     FIXME("(%p)->() stub\n", iface);
1591
1592     SendFurther( iface, deliver_beginflush, NULL, NULL );
1593
1594     if (This->state == State_Running)
1595         return PullPin_PauseProcessing(This);
1596     return S_OK;
1597 }
1598
1599 HRESULT WINAPI PullPin_EndFlush(IPin * iface)
1600 {
1601     FILTER_STATE state;
1602     PullPin *This = (PullPin *)iface;
1603
1604     FIXME("(%p)->() stub\n", iface);
1605     SendFurther( iface, deliver_endflush, NULL, NULL );
1606
1607     return IBaseFilter_GetState(This->pin.pinInfo.pFilter, INFINITE, &state);
1608 }
1609
1610 HRESULT WINAPI PullPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
1611 {
1612     newsegmentargs args;
1613     FIXME("(%p)->(%s, %s, %g) stub\n", iface, wine_dbgstr_longlong(tStart), wine_dbgstr_longlong(tStop), dRate);
1614
1615     args.tStart = tStart;
1616     args.tStop = tStop;
1617     args.rate = dRate;
1618
1619     return SendFurther( iface, deliver_newsegment, &args, NULL );
1620 }
1621
1622 static const IPinVtbl PullPin_Vtbl =
1623 {
1624     PullPin_QueryInterface,
1625     IPinImpl_AddRef,
1626     PullPin_Release,
1627     OutputPin_Connect,
1628     PullPin_ReceiveConnection,
1629     IPinImpl_Disconnect,
1630     IPinImpl_ConnectedTo,
1631     IPinImpl_ConnectionMediaType,
1632     IPinImpl_QueryPinInfo,
1633     IPinImpl_QueryDirection,
1634     IPinImpl_QueryId,
1635     IPinImpl_QueryAccept,
1636     IPinImpl_EnumMediaTypes,
1637     IPinImpl_QueryInternalConnections,
1638     PullPin_EndOfStream,
1639     PullPin_BeginFlush,
1640     PullPin_EndFlush,
1641     PullPin_NewSegment
1642 };