dlls/quartz/parser.c

   1 /*
   2  * Parser (Base for parsers and splitters)
   3  *
   4  * Copyright 2003 Robert Shearman
   5  * Copyright 2004-2005 Christian Costa
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "quartz_private.h"
  23 #include "control_private.h"
  24 #include "pin.h"
  25
  26 #include "vfwmsgs.h"
  27 #include "amvideo.h"
  28
  29 #include "wine/unicode.h"
  30 #include "wine/debug.h"
  31
  32 #include <math.h>
  33 #include <assert.h>
  34
  35 #include "parser.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  38
  39 static const WCHAR wcsInputPinName[] = {'i','n','p','u','t',' ','p','i','n',0};
  40 static const IMediaSeekingVtbl Parser_Seeking_Vtbl;
  41 static const IPinVtbl Parser_OutputPin_Vtbl;
  42 static const IPinVtbl Parser_InputPin_Vtbl;
  43
  44 static HRESULT Parser_ChangeCurrent(IBaseFilter *iface);
  45 static HRESULT Parser_ChangeStop(IBaseFilter *iface);
  46 static HRESULT Parser_ChangeRate(IBaseFilter *iface);
  47
  48 static inline ParserImpl *impl_from_IMediaSeeking( IMediaSeeking *iface )
  49 {
  50     return (ParserImpl *)((char*)iface - FIELD_OFFSET(ParserImpl, mediaSeeking.lpVtbl));
  51 }
  52
  53
  54 HRESULT Parser_Create(ParserImpl* pParser, const IBaseFilterVtbl *Parser_Vtbl, const CLSID* pClsid, PFN_PROCESS_SAMPLE fnProcessSample, PFN_QUERY_ACCEPT fnQueryAccept, PFN_PRE_CONNECT fnPreConnect, PFN_CLEANUP fnCleanup, PFN_DISCONNECT fnDisconnect, REQUESTPROC fnRequest, STOPPROCESSPROC fnDone, CHANGEPROC stop, CHANGEPROC current, CHANGEPROC rate)
  55 {
  56     HRESULT hr;
  57     PIN_INFO piInput;
  58
  59     /* pTransformFilter is already allocated */
  60     BaseFilter_Init(&pParser->filter, Parser_Vtbl, pClsid, (DWORD_PTR)(__FILE__ ": ParserImpl.csFilter"));
  61
  62     pParser->fnDisconnect = fnDisconnect;
  63     pParser->lastpinchange = GetTickCount();
  64
  65     pParser->cStreams = 0;
  66     pParser->ppPins = CoTaskMemAlloc(1 * sizeof(IPin *));
  67
  68     /* construct input pin */
  69     piInput.dir = PINDIR_INPUT;
  70     piInput.pFilter = (IBaseFilter *)pParser;
  71     lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0]));
  72
  73     if (!current)
  74         current = Parser_ChangeCurrent;
  75
  76     if (!stop)
  77         stop = Parser_ChangeStop;
  78
  79     if (!rate)
  80         rate = Parser_ChangeRate;
  81
  82     MediaSeekingImpl_Init((IBaseFilter*)pParser, stop, current, rate, &pParser->mediaSeeking, &pParser->filter.csFilter);
  83     pParser->mediaSeeking.lpVtbl = &Parser_Seeking_Vtbl;
  84
  85     hr = PullPin_Construct(&Parser_InputPin_Vtbl, &piInput, fnProcessSample, (LPVOID)pParser, fnQueryAccept, fnCleanup, fnRequest, fnDone, &pParser->filter.csFilter, (IPin **)&pParser->pInputPin);
  86
  87     if (SUCCEEDED(hr))
  88     {
  89         pParser->ppPins[0] = (IPin *)pParser->pInputPin;
  90         pParser->pInputPin->fnPreConnect = fnPreConnect;
  91     }
  92     else
  93     {
  94         CoTaskMemFree(pParser->ppPins);
  95         BaseFilterImpl_Release((IBaseFilter*)pParser);
  96         CoTaskMemFree(pParser);
  97     }
  98
  99     return hr;
 100 }
 101
 102 HRESULT WINAPI Parser_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
 103 {
 104     ParserImpl *This = (ParserImpl *)iface;
 105     TRACE("(%s, %p)\n", qzdebugstr_guid(riid), ppv);
 106
 107     *ppv = NULL;
 108
 109     if ( IsEqualIID(riid, &IID_IUnknown)
 110       || IsEqualIID(riid, &IID_IPersist)
 111       || IsEqualIID(riid, &IID_IMediaFilter)
 112       || IsEqualIID(riid, &IID_IBaseFilter) )
 113         *ppv = This;
 114
 115     if (*ppv)
 116     {
 117         IUnknown_AddRef((IUnknown *)(*ppv));
 118         return S_OK;
 119     }
 120
 121     if (!IsEqualIID(riid, &IID_IPin) && !IsEqualIID(riid, &IID_IVideoWindow))
 122         FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 123
 124     return E_NOINTERFACE;
 125 }
 126
 127 ULONG WINAPI Parser_AddRef(IBaseFilter * iface)
 128 {
 129     return BaseFilterImpl_AddRef(iface);
 130 }
 131
 132 void Parser_Destroy(ParserImpl *This)
 133 {
 134     IPin *connected = NULL;
 135     ULONG pinref;
 136
 137     assert(!This->filter.refCount);
 138     PullPin_WaitForStateChange(This->pInputPin, INFINITE);
 139
 140     /* Don't need to clean up output pins, freeing input pin will do that */
 141     IPin_ConnectedTo((IPin *)This->pInputPin, &connected);
 142     if (connected)
 143     {
 144         assert(IPin_Disconnect(connected) == S_OK);
 145         IPin_Release(connected);
 146         assert(IPin_Disconnect((IPin *)This->pInputPin) == S_OK);
 147     }
 148     pinref = IPin_Release((IPin *)This->pInputPin);
 149     if (pinref)
 150     {
 151         /* Valgrind could find this, if I kill it here */
 152         ERR("pinref should be null, is %u, destroying anyway\n", pinref);
 153         assert((LONG)pinref > 0);
 154
 155         while (pinref)
 156             pinref = IPin_Release((IPin *)This->pInputPin);
 157     }
 158
 159     CoTaskMemFree(This->ppPins);
 160
 161     TRACE("Destroying parser\n");
 162     CoTaskMemFree(This);
 163 }
 164
 165 ULONG WINAPI Parser_Release(IBaseFilter * iface)
 166 {
 167     ParserImpl *This = (ParserImpl *)iface;
 168     ULONG refCount = BaseFilterImpl_Release(iface);
 169
 170     TRACE("(%p)->() Release from %d\n", This, refCount + 1);
 171
 172     if (!refCount)
 173         Parser_Destroy(This);
 174
 175     return refCount;
 176 }
 177
 178 /** IPersist methods **/
 179
 180 HRESULT WINAPI Parser_GetClassID(IBaseFilter * iface, CLSID * pClsid)
 181 {
 182     ParserImpl *This = (ParserImpl *)iface;
 183
 184     TRACE("(%p)\n", pClsid);
 185
 186     *pClsid = This->filter.clsid;
 187
 188     return S_OK;
 189 }
 190
 191 /** IMediaFilter methods **/
 192
 193 HRESULT WINAPI Parser_Stop(IBaseFilter * iface)
 194 {
 195     ParserImpl *This = (ParserImpl *)iface;
 196     PullPin *pin = (PullPin *)This->ppPins[0];
 197     ULONG i;
 198
 199     TRACE("()\n");
 200
 201     EnterCriticalSection(&pin->thread_lock);
 202
 203     IAsyncReader_BeginFlush(This->pInputPin->pReader);
 204     EnterCriticalSection(&This->filter.csFilter);
 205
 206     if (This->filter.state == State_Stopped)
 207     {
 208         LeaveCriticalSection(&This->filter.csFilter);
 209         IAsyncReader_EndFlush(This->pInputPin->pReader);
 210         LeaveCriticalSection(&pin->thread_lock);
 211         return S_OK;
 212     }
 213
 214     This->filter.state = State_Stopped;
 215
 216     for (i = 1; i < (This->cStreams + 1); i++)
 217     {
 218         BaseOutputPinImpl_Inactive((BaseOutputPin *)This->ppPins[i]);
 219     }
 220
 221     LeaveCriticalSection(&This->filter.csFilter);
 222
 223     PullPin_PauseProcessing(This->pInputPin);
 224     PullPin_WaitForStateChange(This->pInputPin, INFINITE);
 225     IAsyncReader_EndFlush(This->pInputPin->pReader);
 226
 227     LeaveCriticalSection(&pin->thread_lock);
 228     return S_OK;
 229 }
 230
 231 HRESULT WINAPI Parser_Pause(IBaseFilter * iface)
 232 {
 233     HRESULT hr = S_OK;
 234     ParserImpl *This = (ParserImpl *)iface;
 235     PullPin *pin = (PullPin *)This->ppPins[0];
 236
 237     TRACE("()\n");
 238
 239     EnterCriticalSection(&pin->thread_lock);
 240     EnterCriticalSection(&This->filter.csFilter);
 241
 242     if (This->filter.state == State_Paused)
 243     {
 244         LeaveCriticalSection(&This->filter.csFilter);
 245         LeaveCriticalSection(&pin->thread_lock);
 246         return S_OK;
 247     }
 248
 249     if (This->filter.state == State_Stopped)
 250     {
 251         LeaveCriticalSection(&This->filter.csFilter);
 252         hr = IBaseFilter_Run(iface, -1);
 253         EnterCriticalSection(&This->filter.csFilter);
 254     }
 255
 256     if (SUCCEEDED(hr))
 257         This->filter.state = State_Paused;
 258
 259     LeaveCriticalSection(&This->filter.csFilter);
 260     LeaveCriticalSection(&pin->thread_lock);
 261
 262     return hr;
 263 }
 264
 265 HRESULT WINAPI Parser_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
 266 {
 267     HRESULT hr = S_OK;
 268     ParserImpl *This = (ParserImpl *)iface;
 269     PullPin *pin = (PullPin *)This->ppPins[0];
 270
 271     ULONG i;
 272
 273     TRACE("(%s)\n", wine_dbgstr_longlong(tStart));
 274
 275     EnterCriticalSection(&pin->thread_lock);
 276     EnterCriticalSection(&This->filter.csFilter);
 277     {
 278         HRESULT hr_any = VFW_E_NOT_CONNECTED;
 279
 280         if (This->filter.state == State_Running || This->filter.state == State_Paused)
 281         {
 282             This->filter.state = State_Running;
 283             LeaveCriticalSection(&This->filter.csFilter);
 284             LeaveCriticalSection(&pin->thread_lock);
 285             return S_OK;
 286         }
 287
 288         This->filter.rtStreamStart = tStart;
 289
 290         for (i = 1; i < (This->cStreams + 1); i++)
 291         {
 292             hr = BaseOutputPinImpl_Active((BaseOutputPin *)This->ppPins[i]);
 293             if (SUCCEEDED(hr))
 294                 hr_any = hr;
 295         }
 296
 297         hr = hr_any;
 298         if (SUCCEEDED(hr))
 299         {
 300             LeaveCriticalSection(&This->filter.csFilter);
 301             hr = PullPin_StartProcessing(This->pInputPin);
 302             EnterCriticalSection(&This->filter.csFilter);
 303         }
 304
 305         if (SUCCEEDED(hr))
 306             This->filter.state = State_Running;
 307     }
 308     LeaveCriticalSection(&This->filter.csFilter);
 309     LeaveCriticalSection(&pin->thread_lock);
 310
 311     return hr;
 312 }
 313
 314 HRESULT WINAPI Parser_GetState(IBaseFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
 315 {
 316     ParserImpl *This = (ParserImpl *)iface;
 317     PullPin *pin = (PullPin *)This->ppPins[0];
 318     HRESULT hr = S_OK;
 319
 320     TRACE("(%d, %p)\n", dwMilliSecsTimeout, pState);
 321
 322     EnterCriticalSection(&pin->thread_lock);
 323     EnterCriticalSection(&This->filter.csFilter);
 324     {
 325         *pState = This->filter.state;
 326     }
 327     LeaveCriticalSection(&This->filter.csFilter);
 328
 329     if (This->pInputPin && (PullPin_WaitForStateChange(This->pInputPin, dwMilliSecsTimeout) == S_FALSE))
 330         hr = VFW_S_STATE_INTERMEDIATE;
 331     LeaveCriticalSection(&pin->thread_lock);
 332
 333     return hr;
 334 }
 335
 336 HRESULT WINAPI Parser_SetSyncSource(IBaseFilter * iface, IReferenceClock *pClock)
 337 {
 338     ParserImpl *This = (ParserImpl *)iface;
 339     PullPin *pin = (PullPin *)This->ppPins[0];
 340
 341     TRACE("(%p)\n", pClock);
 342
 343     EnterCriticalSection(&pin->thread_lock);
 344     BaseFilterImpl_SetSyncSource(iface,pClock);
 345     LeaveCriticalSection(&pin->thread_lock);
 346
 347     return S_OK;
 348 }
 349
 350 HRESULT WINAPI Parser_GetSyncSource(IBaseFilter * iface, IReferenceClock **ppClock)
 351 {
 352     return BaseFilterImpl_GetSyncSource(iface, ppClock);
 353 }
 354
 355 /** IBaseFilter implementation **/
 356
 357 /* FIXME: WRONG */
 358 static IPin* WINAPI Parser_GetPin(IBaseFilter *iface, int pos)
 359 {
 360     ParserImpl *This = (ParserImpl *)iface;
 361
 362     TRACE("Asking for pos %x\n", pos);
 363
 364     /* Input pin also has a pin, hence the > and not >= */
 365     if (pos > This->cStreams || pos < 0)
 366         return NULL;
 367
 368     IPin_AddRef(This->ppPins[pos]);
 369     return This->ppPins[pos];
 370 }
 371
 372 static LONG WINAPI Parser_GetPinCount(IBaseFilter *iface)
 373 {
 374     ParserImpl *This = (ParserImpl *)iface;
 375
 376     return This->cStreams;
 377 }
 378
 379 static LONG WINAPI Parser_GetPinVersion(IBaseFilter *iface)
 380 {
 381     ParserImpl *This = (ParserImpl *)iface;
 382
 383     return This->lastpinchange;
 384 }
 385
 386 HRESULT WINAPI Parser_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum)
 387 {
 388     ParserImpl *This = (ParserImpl *)iface;
 389
 390     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 391
 392     return EnumPins_Construct(iface, Parser_GetPin, Parser_GetPinCount, Parser_GetPinVersion, ppEnum);
 393 }
 394
 395 HRESULT WINAPI Parser_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
 396 {
 397     FIXME("(%p)->(%s,%p)\n", iface, debugstr_w(Id), ppPin);
 398
 399     /* FIXME: critical section */
 400
 401     return E_NOTIMPL;
 402 }
 403
 404 HRESULT WINAPI Parser_QueryFilterInfo(IBaseFilter * iface, FILTER_INFO *pInfo)
 405 {
 406     return BaseFilterImpl_QueryFilterInfo(iface, pInfo);
 407 }
 408
 409 HRESULT WINAPI Parser_JoinFilterGraph(IBaseFilter * iface, IFilterGraph *pGraph, LPCWSTR pName)
 410 {
 411     return BaseFilterImpl_JoinFilterGraph(iface, pGraph, pName);
 412 }
 413
 414 HRESULT WINAPI Parser_QueryVendorInfo(IBaseFilter * iface, LPWSTR *pVendorInfo)
 415 {
 416     return BaseFilterImpl_QueryVendorInfo(iface, pVendorInfo);
 417 }
 418
 419 HRESULT Parser_AddPin(ParserImpl * This, const PIN_INFO * piOutput, ALLOCATOR_PROPERTIES * props, const AM_MEDIA_TYPE * amt)
 420 {
 421     IPin ** ppOldPins;
 422     HRESULT hr;
 423
 424     ppOldPins = This->ppPins;
 425
 426     This->ppPins = CoTaskMemAlloc((This->cStreams + 2) * sizeof(IPin *));
 427     memcpy(This->ppPins, ppOldPins, (This->cStreams + 1) * sizeof(IPin *));
 428
 429     hr = BaseOutputPin_Construct(&Parser_OutputPin_Vtbl, sizeof(Parser_OutputPin), piOutput, props, NULL, &This->filter.csFilter, This->ppPins + (This->cStreams + 1));
 430
 431     if (SUCCEEDED(hr))
 432     {
 433         IPin *pPin = This->ppPins[This->cStreams + 1];
 434         Parser_OutputPin *pin = (Parser_OutputPin *)pPin;
 435         pin->pmt = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
 436         CopyMediaType(pin->pmt, amt);
 437         pin->dwSamplesProcessed = 0;
 438
 439         pin->pin.pin.pinInfo.pFilter = (LPVOID)This;
 440         pin->pin.custom_allocator = 1;
 441         This->cStreams++;
 442         This->lastpinchange = GetTickCount();
 443         CoTaskMemFree(ppOldPins);
 444     }
 445     else
 446     {
 447         CoTaskMemFree(This->ppPins);
 448         This->ppPins = ppOldPins;
 449         ERR("Failed with error %x\n", hr);
 450     }
 451
 452     return hr;
 453 }
 454
 455 static HRESULT Parser_RemoveOutputPins(ParserImpl * This)
 456 {
 457     /* NOTE: should be in critical section when calling this function */
 458     HRESULT hr;
 459     ULONG i;
 460     IPin ** ppOldPins = This->ppPins;
 461
 462     TRACE("(%p)\n", This);
 463
 464     /* reduce the pin array down to 1 (just our input pin) */
 465     This->ppPins = CoTaskMemAlloc(sizeof(IPin *) * 1);
 466     memcpy(This->ppPins, ppOldPins, sizeof(IPin *) * 1);
 467
 468     for (i = 0; i < This->cStreams; i++)
 469     {
 470         hr = BaseOutputPinImpl_BreakConnect((BaseOutputPin *)ppOldPins[i + 1]);
 471         TRACE("Disconnect: %08x\n", hr);
 472         IPin_Release(ppOldPins[i + 1]);
 473     }
 474
 475     This->lastpinchange = GetTickCount();
 476     This->cStreams = 0;
 477     CoTaskMemFree(ppOldPins);
 478
 479     return S_OK;
 480 }
 481
 482 static HRESULT Parser_ChangeCurrent(IBaseFilter *iface)
 483 {
 484     FIXME("(%p) filter hasn't implemented current position change!\n", iface);
 485     return S_OK;
 486 }
 487
 488 static HRESULT Parser_ChangeStop(IBaseFilter *iface)
 489 {
 490     FIXME("(%p) filter hasn't implemented stop position change!\n", iface);
 491     return S_OK;
 492 }
 493
 494 static HRESULT Parser_ChangeRate(IBaseFilter *iface)
 495 {
 496     FIXME("(%p) filter hasn't implemented rate change!\n", iface);
 497     return S_OK;
 498 }
 499
 500
 501 static HRESULT WINAPI Parser_Seeking_QueryInterface(IMediaSeeking * iface, REFIID riid, LPVOID * ppv)
 502 {
 503     ParserImpl *This = impl_from_IMediaSeeking(iface);
 504
 505     return IUnknown_QueryInterface((IUnknown *)This, riid, ppv);
 506 }
 507
 508 static ULONG WINAPI Parser_Seeking_AddRef(IMediaSeeking * iface)
 509 {
 510     ParserImpl *This = impl_from_IMediaSeeking(iface);
 511
 512     return IUnknown_AddRef((IUnknown *)This);
 513 }
 514
 515 static ULONG WINAPI Parser_Seeking_Release(IMediaSeeking * iface)
 516 {
 517     ParserImpl *This = impl_from_IMediaSeeking(iface);
 518
 519     return IUnknown_Release((IUnknown *)This);
 520 }
 521
 522 static const IMediaSeekingVtbl Parser_Seeking_Vtbl =
 523 {
 524     Parser_Seeking_QueryInterface,
 525     Parser_Seeking_AddRef,
 526     Parser_Seeking_Release,
 527     MediaSeekingImpl_GetCapabilities,
 528     MediaSeekingImpl_CheckCapabilities,
 529     MediaSeekingImpl_IsFormatSupported,
 530     MediaSeekingImpl_QueryPreferredFormat,
 531     MediaSeekingImpl_GetTimeFormat,
 532     MediaSeekingImpl_IsUsingTimeFormat,
 533     MediaSeekingImpl_SetTimeFormat,
 534     MediaSeekingImpl_GetDuration,
 535     MediaSeekingImpl_GetStopPosition,
 536     MediaSeekingImpl_GetCurrentPosition,
 537     MediaSeekingImpl_ConvertTimeFormat,
 538     MediaSeekingImpl_SetPositions,
 539     MediaSeekingImpl_GetPositions,
 540     MediaSeekingImpl_GetAvailable,
 541     MediaSeekingImpl_SetRate,
 542     MediaSeekingImpl_GetRate,
 543     MediaSeekingImpl_GetPreroll
 544 };
 545
 546 static HRESULT WINAPI Parser_OutputPin_GetMediaType(IPin *iface, int iPosition, AM_MEDIA_TYPE *pmt)
 547 {
 548     Parser_OutputPin *This = (Parser_OutputPin *)iface;
 549     if (iPosition < 0)
 550         return E_INVALIDARG;
 551     if (iPosition > 0)
 552         return VFW_S_NO_MORE_ITEMS;
 553     CopyMediaType(pmt, This->pmt);
 554     return S_OK;
 555 }
 556
 557 static HRESULT WINAPI Parser_OutputPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
 558 {
 559     Parser_OutputPin *This = (Parser_OutputPin *)iface;
 560
 561     TRACE("(%s, %p)\n", qzdebugstr_guid(riid), ppv);
 562
 563     *ppv = NULL;
 564
 565     if (IsEqualIID(riid, &IID_IUnknown))
 566         *ppv = iface;
 567     else if (IsEqualIID(riid, &IID_IPin))
 568         *ppv = iface;
 569     else if (IsEqualIID(riid, &IID_IMediaSeeking))
 570     {
 571         return IBaseFilter_QueryInterface(This->pin.pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv);
 572     }
 573
 574     if (*ppv)
 575     {
 576         IUnknown_AddRef((IUnknown *)(*ppv));
 577         return S_OK;
 578     }
 579
 580     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 581
 582     return E_NOINTERFACE;
 583 }
 584
 585 static ULONG WINAPI Parser_OutputPin_Release(IPin * iface)
 586 {
 587     Parser_OutputPin *This = (Parser_OutputPin *)iface;
 588     ULONG refCount = InterlockedDecrement(&This->pin.pin.refCount);
 589
 590     TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
 591
 592     if (!refCount)
 593     {
 594         FreeMediaType(This->pmt);
 595         CoTaskMemFree(This->pmt);
 596         FreeMediaType(&This->pin.pin.mtCurrent);
 597         CoTaskMemFree(This);
 598         return 0;
 599     }
 600     return refCount;
 601 }
 602
 603 static HRESULT WINAPI Parser_OutputPin_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum)
 604 {
 605     TRACE("(%p)\n", ppEnum);
 606
 607     /* override this method to allow enumeration of your types */
 608
 609     return EnumMediaTypes_Construct(iface, Parser_OutputPin_GetMediaType, BasePinImpl_GetMediaTypeVersion, ppEnum);
 610 }
 611
 612 static HRESULT WINAPI Parser_OutputPin_Connect(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 613 {
 614     Parser_OutputPin *This = (Parser_OutputPin *)iface;
 615     ParserImpl *parser = (ParserImpl *)This->pin.pin.pinInfo.pFilter;
 616
 617     /* Set the allocator to our input pin's */
 618     EnterCriticalSection(This->pin.pin.pCritSec);
 619     This->pin.alloc = parser->pInputPin->pAlloc;
 620     LeaveCriticalSection(This->pin.pin.pCritSec);
 621
 622     return BaseOutputPinImpl_Connect(iface, pReceivePin, pmt);
 623 }
 624
 625 static HRESULT WINAPI Parser_OutputPin_QueryAccept(IPin *iface, const AM_MEDIA_TYPE * pmt)
 626 {
 627     Parser_OutputPin *This = (Parser_OutputPin *)iface;
 628
 629     TRACE("()\n");
 630     dump_AM_MEDIA_TYPE(pmt);
 631
 632     return (memcmp(This->pmt, pmt, sizeof(AM_MEDIA_TYPE)) == 0);
 633 }
 634
 635 static const IPinVtbl Parser_OutputPin_Vtbl =
 636 {
 637     Parser_OutputPin_QueryInterface,
 638     BasePinImpl_AddRef,
 639     Parser_OutputPin_Release,
 640     Parser_OutputPin_Connect,
 641     BaseOutputPinImpl_ReceiveConnection,
 642     BaseOutputPinImpl_Disconnect,
 643     BasePinImpl_ConnectedTo,
 644     BasePinImpl_ConnectionMediaType,
 645     BasePinImpl_QueryPinInfo,
 646     BasePinImpl_QueryDirection,
 647     BasePinImpl_QueryId,
 648     Parser_OutputPin_QueryAccept,
 649     Parser_OutputPin_EnumMediaTypes,
 650     BasePinImpl_QueryInternalConnections,
 651     BaseOutputPinImpl_EndOfStream,
 652     BaseOutputPinImpl_BeginFlush,
 653     BaseOutputPinImpl_EndFlush,
 654     BaseOutputPinImpl_NewSegment
 655 };
 656
 657 static HRESULT WINAPI Parser_PullPin_Disconnect(IPin * iface)
 658 {
 659     HRESULT hr;
 660     PullPin *This = (PullPin *)iface;
 661
 662     TRACE("()\n");
 663
 664     EnterCriticalSection(&This->thread_lock);
 665     EnterCriticalSection(This->pin.pCritSec);
 666     {
 667         if (This->pin.pConnectedTo)
 668         {
 669             FILTER_STATE state;
 670             ParserImpl *Parser = (ParserImpl *)This->pin.pinInfo.pFilter;
 671
 672             LeaveCriticalSection(This->pin.pCritSec);
 673             hr = IBaseFilter_GetState(This->pin.pinInfo.pFilter, INFINITE, &state);
 674             EnterCriticalSection(This->pin.pCritSec);
 675
 676             if (SUCCEEDED(hr) && (state == State_Stopped) && SUCCEEDED(Parser->fnDisconnect(Parser)))
 677             {
 678                 LeaveCriticalSection(This->pin.pCritSec);
 679                 PullPin_Disconnect(iface);
 680                 EnterCriticalSection(This->pin.pCritSec);
 681                 hr = Parser_RemoveOutputPins((ParserImpl *)This->pin.pinInfo.pFilter);
 682             }
 683             else
 684                 hr = VFW_E_NOT_STOPPED;
 685         }
 686         else
 687             hr = S_FALSE;
 688     }
 689     LeaveCriticalSection(This->pin.pCritSec);
 690     LeaveCriticalSection(&This->thread_lock);
 691
 692     return hr;
 693 }
 694
 695 static HRESULT WINAPI Parser_PullPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 696 {
 697     HRESULT hr;
 698
 699     TRACE("()\n");
 700
 701     hr = PullPin_ReceiveConnection(iface, pReceivePin, pmt);
 702     if (FAILED(hr))
 703     {
 704         BasePin *This = (BasePin *)iface;
 705
 706         EnterCriticalSection(This->pCritSec);
 707         Parser_RemoveOutputPins((ParserImpl *)This->pinInfo.pFilter);
 708         LeaveCriticalSection(This->pCritSec);
 709     }
 710
 711     return hr;
 712 }
 713
 714 static const IPinVtbl Parser_InputPin_Vtbl =
 715 {
 716     PullPin_QueryInterface,
 717     BasePinImpl_AddRef,
 718     PullPin_Release,
 719     BaseInputPinImpl_Connect,
 720     Parser_PullPin_ReceiveConnection,
 721     Parser_PullPin_Disconnect,
 722     BasePinImpl_ConnectedTo,
 723     BasePinImpl_ConnectionMediaType,
 724     BasePinImpl_QueryPinInfo,
 725     BasePinImpl_QueryDirection,
 726     BasePinImpl_QueryId,
 727     PullPin_QueryAccept,
 728     BasePinImpl_EnumMediaTypes,
 729     BasePinImpl_QueryInternalConnections,
 730     PullPin_EndOfStream,
 731     PullPin_BeginFlush,
 732     PullPin_EndFlush,
 733     PullPin_NewSegment
 734 };