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