git.oblomov.eu Git - wine/blob - 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 IBaseFilterVtbl Parser_Vtbl;
  41 static const IMediaSeekingVtbl Parser_Seeking_Vtbl;
  42 static const IPinVtbl Parser_OutputPin_Vtbl;
  43 static const IPinVtbl Parser_InputPin_Vtbl;
  44
  45 static HRESULT Parser_OutputPin_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt);
  46 static HRESULT Parser_ChangeStart(LPVOID iface);
  47 static HRESULT Parser_ChangeStop(LPVOID iface);
  48 static HRESULT Parser_ChangeRate(LPVOID iface);
  49
  50 static HRESULT Parser_InputPin_Construct(const PIN_INFO * pPinInfo, SAMPLEPROC pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, IPin ** ppPin);
  51
  52 static inline Parser_OutputPin *impl_from_IMediaSeeking( IMediaSeeking *iface )
  53 {
  54     return (Parser_OutputPin *)((char*)iface - FIELD_OFFSET(Parser_OutputPin, mediaSeeking.lpVtbl));
  55 }
  56
  57
  58 HRESULT Parser_Create(ParserImpl* pParser, const CLSID* pClsid, PFN_PROCESS_SAMPLE fnProcessSample, PFN_QUERY_ACCEPT fnQueryAccept, PFN_PRE_CONNECT fnPreConnect, PFN_CLEANUP fnCleanup)
  59 {
  60     HRESULT hr;
  61     PIN_INFO piInput;
  62
  63     /* pTransformFilter is already allocated */
  64     pParser->clsid = *pClsid;
  65
  66     pParser->lpVtbl = &Parser_Vtbl;
  67     pParser->refCount = 1;
  68     InitializeCriticalSection(&pParser->csFilter);
  69     pParser->csFilter.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ParserImpl.csFilter");
  70     pParser->state = State_Stopped;
  71     pParser->pClock = NULL;
  72     pParser->fnCleanup = fnCleanup;
  73     ZeroMemory(&pParser->filterInfo, sizeof(FILTER_INFO));
  74
  75     pParser->cStreams = 0;
  76     pParser->ppPins = CoTaskMemAlloc(1 * sizeof(IPin *));
  77
  78     /* construct input pin */
  79     piInput.dir = PINDIR_INPUT;
  80     piInput.pFilter = (IBaseFilter *)pParser;
  81     lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0]));
  82
  83     hr = Parser_InputPin_Construct(&piInput, fnProcessSample, (LPVOID)pParser, fnQueryAccept, &pParser->csFilter, (IPin **)&pParser->pInputPin);
  84
  85     if (SUCCEEDED(hr))
  86     {
  87         pParser->ppPins[0] = (IPin *)pParser->pInputPin;
  88         pParser->pInputPin->fnPreConnect = fnPreConnect;
  89     }
  90     else
  91     {
  92         CoTaskMemFree(pParser->ppPins);
  93         pParser->csFilter.DebugInfo->Spare[0] = 0;
  94         DeleteCriticalSection(&pParser->csFilter);
  95         CoTaskMemFree(pParser);
  96     }
  97
  98     return hr;
  99 }
 100
 101 static HRESULT Parser_OutputPin_Init(const PIN_INFO * pPinInfo, ALLOCATOR_PROPERTIES * props, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, const AM_MEDIA_TYPE * pmt, float fSamplesPerSec, LPCRITICAL_SECTION pCritSec, Parser_OutputPin * pPinImpl)
 102 {
 103     pPinImpl->pmt = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
 104     CopyMediaType(pPinImpl->pmt, pmt);
 105     pPinImpl->dwSamplesProcessed = 0;
 106     pPinImpl->dwSampleSize = 0;
 107     pPinImpl->fSamplesPerSec = fSamplesPerSec;
 108
 109     MediaSeekingImpl_Init((LPVOID)pPinInfo->pFilter, Parser_ChangeStop, Parser_ChangeStart, Parser_ChangeRate, &pPinImpl->mediaSeeking);
 110     pPinImpl->mediaSeeking.lpVtbl = &Parser_Seeking_Vtbl;
 111
 112     return OutputPin_Init(pPinInfo, props, pUserData, pQueryAccept, pCritSec, &pPinImpl->pin);
 113 }
 114
 115 static HRESULT Parser_OutputPin_Construct(const PIN_INFO * pPinInfo, ALLOCATOR_PROPERTIES * props, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, const AM_MEDIA_TYPE * pmt, float fSamplesPerSec, LPCRITICAL_SECTION pCritSec, IPin ** ppPin)
 116 {
 117     Parser_OutputPin * pPinImpl;
 118
 119     *ppPin = NULL;
 120
 121     assert(pPinInfo->dir == PINDIR_OUTPUT);
 122
 123     pPinImpl = CoTaskMemAlloc(sizeof(Parser_OutputPin));
 124
 125     if (!pPinImpl)
 126         return E_OUTOFMEMORY;
 127
 128     if (SUCCEEDED(Parser_OutputPin_Init(pPinInfo, props, pUserData, pQueryAccept, pmt, fSamplesPerSec, pCritSec, pPinImpl)))
 129     {
 130         pPinImpl->pin.pin.lpVtbl = &Parser_OutputPin_Vtbl;
 131
 132         *ppPin = (IPin *)pPinImpl;
 133         return S_OK;
 134     }
 135     return E_FAIL;
 136 }
 137
 138 static HRESULT WINAPI Parser_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
 139 {
 140     ParserImpl *This = (ParserImpl *)iface;
 141     TRACE("(%s, %p)\n", qzdebugstr_guid(riid), ppv);
 142
 143     *ppv = NULL;
 144
 145     if (IsEqualIID(riid, &IID_IUnknown))
 146         *ppv = (LPVOID)This;
 147     else if (IsEqualIID(riid, &IID_IPersist))
 148         *ppv = (LPVOID)This;
 149     else if (IsEqualIID(riid, &IID_IMediaFilter))
 150         *ppv = (LPVOID)This;
 151     else if (IsEqualIID(riid, &IID_IBaseFilter))
 152         *ppv = (LPVOID)This;
 153
 154     if (*ppv)
 155     {
 156         IUnknown_AddRef((IUnknown *)(*ppv));
 157         return S_OK;
 158     }
 159
 160     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 161
 162     return E_NOINTERFACE;
 163 }
 164
 165 static ULONG WINAPI Parser_AddRef(IBaseFilter * iface)
 166 {
 167     ParserImpl *This = (ParserImpl *)iface;
 168     ULONG refCount = InterlockedIncrement(&This->refCount);
 169
 170     TRACE("(%p/%p)->() AddRef from %d\n", This, iface, refCount - 1);
 171
 172     return refCount;
 173 }
 174
 175 static ULONG WINAPI Parser_Release(IBaseFilter * iface)
 176 {
 177     ParserImpl *This = (ParserImpl *)iface;
 178     ULONG refCount = InterlockedDecrement(&This->refCount);
 179
 180     TRACE("(%p)->() Release from %d\n", This, refCount + 1);
 181
 182     if (!refCount)
 183     {
 184         ULONG i;
 185
 186         if (This->fnCleanup)
 187             This->fnCleanup(This);
 188
 189         if (This->pClock)
 190             IReferenceClock_Release(This->pClock);
 191
 192         for (i = 0; i < This->cStreams + 1; i++)
 193         {
 194             IPin *pConnectedTo;
 195
 196             if (SUCCEEDED(IPin_ConnectedTo(This->ppPins[i], &pConnectedTo)))
 197             {
 198                 IPin_Disconnect(pConnectedTo);
 199                 IPin_Release(pConnectedTo);
 200             }
 201             IPin_Disconnect(This->ppPins[i]);
 202
 203             IPin_Release(This->ppPins[i]);
 204         }
 205
 206         CoTaskMemFree(This->ppPins);
 207         This->lpVtbl = NULL;
 208
 209         This->csFilter.DebugInfo->Spare[0] = 0;
 210         DeleteCriticalSection(&This->csFilter);
 211
 212         TRACE("Destroying parser\n");
 213         CoTaskMemFree(This);
 214
 215         return 0;
 216     }
 217     else
 218         return refCount;
 219 }
 220
 221 /** IPersist methods **/
 222
 223 static HRESULT WINAPI Parser_GetClassID(IBaseFilter * iface, CLSID * pClsid)
 224 {
 225     ParserImpl *This = (ParserImpl *)iface;
 226
 227     TRACE("(%p)\n", pClsid);
 228
 229     *pClsid = This->clsid;
 230
 231     return S_OK;
 232 }
 233
 234 /** IMediaFilter methods **/
 235
 236 static HRESULT WINAPI Parser_Stop(IBaseFilter * iface)
 237 {
 238     HRESULT hr;
 239     ParserImpl *This = (ParserImpl *)iface;
 240
 241     TRACE("()\n");
 242
 243     EnterCriticalSection(&This->csFilter);
 244     {
 245         if (This->state == State_Stopped)
 246         {
 247             LeaveCriticalSection(&This->csFilter);
 248             return S_OK;
 249         }
 250         hr = PullPin_StopProcessing(This->pInputPin);
 251         This->state = State_Stopped;
 252     }
 253     LeaveCriticalSection(&This->csFilter);
 254
 255     return hr;
 256 }
 257
 258 static HRESULT WINAPI Parser_Pause(IBaseFilter * iface)
 259 {
 260     HRESULT hr = S_OK;
 261     BOOL bInit;
 262     ParserImpl *This = (ParserImpl *)iface;
 263
 264     TRACE("()\n");
 265
 266     EnterCriticalSection(&This->csFilter);
 267     {
 268         if (This->state == State_Paused)
 269         {
 270             LeaveCriticalSection(&This->csFilter);
 271             return S_OK;
 272         }
 273         bInit = (This->state == State_Stopped);
 274         This->state = State_Paused;
 275     }
 276     LeaveCriticalSection(&This->csFilter);
 277
 278     if (bInit)
 279     {
 280         unsigned int i;
 281
 282         hr = PullPin_Seek(This->pInputPin, 0, ((LONGLONG)0x7fffffff << 32) | 0xffffffff);
 283
 284         if (SUCCEEDED(hr))
 285             hr = PullPin_InitProcessing(This->pInputPin);
 286
 287         if (SUCCEEDED(hr))
 288         {
 289             for (i = 1; i < This->cStreams + 1; i++)
 290             {
 291                 Parser_OutputPin* StreamPin = (Parser_OutputPin *)This->ppPins[i];
 292                 OutputPin_DeliverNewSegment((OutputPin *)This->ppPins[i], 0, (LONGLONG)ceil(10000000.0 * (float)StreamPin->dwLength / StreamPin->fSamplesPerSec), 1.0);
 293                 StreamPin->mediaSeeking.llDuration = (LONGLONG)ceil(10000000.0 * (float)StreamPin->dwLength / StreamPin->fSamplesPerSec);
 294                 StreamPin->mediaSeeking.llStop = (LONGLONG)ceil(10000000.0 * (float)StreamPin->dwLength / StreamPin->fSamplesPerSec);
 295                 OutputPin_CommitAllocator((OutputPin *)This->ppPins[i]);
 296             }
 297
 298             /* FIXME: this is a little hacky: we have to deliver (at least?) one sample
 299              * to each renderer before they will complete their transitions. We should probably
 300              * seek through the stream for the first of each, rather than do it this way which is
 301              * probably a bit prone to deadlocking */
 302             hr = PullPin_StartProcessing(This->pInputPin);
 303         }
 304     }
 305     /* FIXME: else pause thread */
 306
 307     if (SUCCEEDED(hr))
 308         hr = PullPin_PauseProcessing(This->pInputPin);
 309
 310     return hr;
 311 }
 312
 313 static HRESULT WINAPI Parser_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
 314 {
 315     HRESULT hr = S_OK;
 316     ParserImpl *This = (ParserImpl *)iface;
 317     int i;
 318
 319     TRACE("(%s)\n", wine_dbgstr_longlong(tStart));
 320
 321     EnterCriticalSection(&This->csFilter);
 322     {
 323         if (This->state == State_Running)
 324         {
 325             LeaveCriticalSection(&This->csFilter);
 326             return S_OK;
 327         }
 328
 329         This->rtStreamStart = tStart;
 330
 331         hr = PullPin_Seek(This->pInputPin, tStart, ((LONGLONG)0x7fffffff << 32) | 0xffffffff);
 332
 333         if (SUCCEEDED(hr) && (This->state == State_Stopped))
 334         {
 335             hr = PullPin_InitProcessing(This->pInputPin);
 336
 337             if (SUCCEEDED(hr))
 338             {
 339                 for (i = 1; i < (This->cStreams + 1); i++)
 340                 {
 341                     OutputPin_CommitAllocator((OutputPin *)This->ppPins[i]);
 342                 }
 343             }
 344         }
 345
 346         if (SUCCEEDED(hr))
 347             hr = PullPin_StartProcessing(This->pInputPin);
 348
 349         if (SUCCEEDED(hr))
 350             This->state = State_Running;
 351     }
 352     LeaveCriticalSection(&This->csFilter);
 353
 354     return hr;
 355 }
 356
 357 static HRESULT WINAPI Parser_GetState(IBaseFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
 358 {
 359     ParserImpl *This = (ParserImpl *)iface;
 360
 361     TRACE("(%d, %p)\n", dwMilliSecsTimeout, pState);
 362
 363     EnterCriticalSection(&This->csFilter);
 364     {
 365         *pState = This->state;
 366     }
 367     LeaveCriticalSection(&This->csFilter);
 368
 369     /* FIXME: this is a little bit unsafe, but I don't see that we can do this
 370      * while in the critical section. Maybe we could copy the pointer and addref in the
 371      * critical section and then release after this.
 372      */
 373     if (This->pInputPin && (PullPin_WaitForStateChange(This->pInputPin, dwMilliSecsTimeout) == S_FALSE))
 374         return VFW_S_STATE_INTERMEDIATE;
 375
 376     return S_OK;
 377 }
 378
 379 static HRESULT WINAPI Parser_SetSyncSource(IBaseFilter * iface, IReferenceClock *pClock)
 380 {
 381     ParserImpl *This = (ParserImpl *)iface;
 382
 383     TRACE("(%p)\n", pClock);
 384
 385     EnterCriticalSection(&This->csFilter);
 386     {
 387         if (This->pClock)
 388             IReferenceClock_Release(This->pClock);
 389         This->pClock = pClock;
 390         if (This->pClock)
 391             IReferenceClock_AddRef(This->pClock);
 392     }
 393     LeaveCriticalSection(&This->csFilter);
 394
 395     return S_OK;
 396 }
 397
 398 static HRESULT WINAPI Parser_GetSyncSource(IBaseFilter * iface, IReferenceClock **ppClock)
 399 {
 400     ParserImpl *This = (ParserImpl *)iface;
 401
 402     TRACE("(%p)\n", ppClock);
 403
 404     EnterCriticalSection(&This->csFilter);
 405     {
 406         *ppClock = This->pClock;
 407         if (This->pClock)
 408             IReferenceClock_AddRef(This->pClock);
 409     }
 410     LeaveCriticalSection(&This->csFilter);
 411
 412     return S_OK;
 413 }
 414
 415 /** IBaseFilter implementation **/
 416
 417 static HRESULT WINAPI Parser_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum)
 418 {
 419     ENUMPINDETAILS epd;
 420     ParserImpl *This = (ParserImpl *)iface;
 421
 422     TRACE("(%p)\n", ppEnum);
 423
 424     epd.cPins = This->cStreams + 1; /* +1 for input pin */
 425     epd.ppPins = This->ppPins;
 426     return IEnumPinsImpl_Construct(&epd, ppEnum);
 427 }
 428
 429 static HRESULT WINAPI Parser_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
 430 {
 431     FIXME("(%p)->(%s,%p)\n", iface, debugstr_w(Id), ppPin);
 432
 433     /* FIXME: critical section */
 434
 435     return E_NOTIMPL;
 436 }
 437
 438 static HRESULT WINAPI Parser_QueryFilterInfo(IBaseFilter * iface, FILTER_INFO *pInfo)
 439 {
 440     ParserImpl *This = (ParserImpl *)iface;
 441
 442     TRACE("(%p)\n", pInfo);
 443
 444     strcpyW(pInfo->achName, This->filterInfo.achName);
 445     pInfo->pGraph = This->filterInfo.pGraph;
 446
 447     if (pInfo->pGraph)
 448         IFilterGraph_AddRef(pInfo->pGraph);
 449
 450     return S_OK;
 451 }
 452
 453 static HRESULT WINAPI Parser_JoinFilterGraph(IBaseFilter * iface, IFilterGraph *pGraph, LPCWSTR pName)
 454 {
 455     HRESULT hr = S_OK;
 456     ParserImpl *This = (ParserImpl *)iface;
 457
 458     TRACE("(%p, %s)\n", pGraph, debugstr_w(pName));
 459
 460     EnterCriticalSection(&This->csFilter);
 461     {
 462         if (pName)
 463             strcpyW(This->filterInfo.achName, pName);
 464         else
 465             *This->filterInfo.achName = '\0';
 466         This->filterInfo.pGraph = pGraph; /* NOTE: do NOT increase ref. count */
 467     }
 468     LeaveCriticalSection(&This->csFilter);
 469
 470     return hr;
 471 }
 472
 473 static HRESULT WINAPI Parser_QueryVendorInfo(IBaseFilter * iface, LPWSTR *pVendorInfo)
 474 {
 475     TRACE("(%p)\n", pVendorInfo);
 476     return E_NOTIMPL;
 477 }
 478
 479 static const IBaseFilterVtbl Parser_Vtbl =
 480 {
 481     Parser_QueryInterface,
 482     Parser_AddRef,
 483     Parser_Release,
 484     Parser_GetClassID,
 485     Parser_Stop,
 486     Parser_Pause,
 487     Parser_Run,
 488     Parser_GetState,
 489     Parser_SetSyncSource,
 490     Parser_GetSyncSource,
 491     Parser_EnumPins,
 492     Parser_FindPin,
 493     Parser_QueryFilterInfo,
 494     Parser_JoinFilterGraph,
 495     Parser_QueryVendorInfo
 496 };
 497
 498 HRESULT Parser_AddPin(ParserImpl * This, const PIN_INFO * piOutput, ALLOCATOR_PROPERTIES * props,
 499                       const AM_MEDIA_TYPE * amt, float fSamplesPerSec, DWORD dwSampleSize, DWORD dwLength)
 500 {
 501     IPin ** ppOldPins;
 502     HRESULT hr;
 503
 504     ppOldPins = This->ppPins;
 505
 506     This->ppPins = CoTaskMemAlloc((This->cStreams + 2) * sizeof(IPin *));
 507     memcpy(This->ppPins, ppOldPins, (This->cStreams + 1) * sizeof(IPin *));
 508
 509     hr = Parser_OutputPin_Construct(piOutput, props, NULL, Parser_OutputPin_QueryAccept, amt, fSamplesPerSec, &This->csFilter, This->ppPins + This->cStreams + 1);
 510
 511     if (SUCCEEDED(hr))
 512     {
 513         ((Parser_OutputPin *)(This->ppPins[This->cStreams + 1]))->dwSampleSize = dwSampleSize;
 514         ((Parser_OutputPin *)(This->ppPins[This->cStreams + 1]))->dwLength = dwLength;
 515         ((Parser_OutputPin *)(This->ppPins[This->cStreams + 1]))->pin.pin.pUserData = (LPVOID)This->ppPins[This->cStreams + 1];
 516         This->cStreams++;
 517         CoTaskMemFree(ppOldPins);
 518     }
 519     else
 520     {
 521         CoTaskMemFree(This->ppPins);
 522         This->ppPins = ppOldPins;
 523         ERR("Failed with error %x\n", hr);
 524     }
 525
 526     return hr;
 527 }
 528
 529 static HRESULT Parser_RemoveOutputPins(ParserImpl * This)
 530 {
 531     /* NOTE: should be in critical section when calling this function */
 532
 533     ULONG i;
 534     IPin ** ppOldPins = This->ppPins;
 535
 536     /* reduce the pin array down to 1 (just our input pin) */
 537     This->ppPins = CoTaskMemAlloc(sizeof(IPin *) * 1);
 538     memcpy(This->ppPins, ppOldPins, sizeof(IPin *) * 1);
 539
 540     for (i = 0; i < This->cStreams; i++)
 541     {
 542         OutputPin_DeliverDisconnect((OutputPin *)ppOldPins[i + 1]);
 543         IPin_Release(ppOldPins[i + 1]);
 544     }
 545
 546     This->cStreams = 0;
 547     CoTaskMemFree(ppOldPins);
 548
 549     return S_OK;
 550 }
 551
 552 static HRESULT Parser_ChangeStart(LPVOID iface)
 553 {
 554     FIXME("(%p)\n", iface);
 555     return S_OK;
 556 }
 557
 558 static HRESULT Parser_ChangeStop(LPVOID iface)
 559 {
 560     FIXME("(%p)\n", iface);
 561     return S_OK;
 562 }
 563
 564 static HRESULT Parser_ChangeRate(LPVOID iface)
 565 {
 566     FIXME("(%p)\n", iface);
 567     return S_OK;
 568 }
 569
 570
 571 static HRESULT WINAPI Parser_Seeking_QueryInterface(IMediaSeeking * iface, REFIID riid, LPVOID * ppv)
 572 {
 573     Parser_OutputPin *This = impl_from_IMediaSeeking(iface);
 574
 575     return IUnknown_QueryInterface((IUnknown *)This, riid, ppv);
 576 }
 577
 578 static ULONG WINAPI Parser_Seeking_AddRef(IMediaSeeking * iface)
 579 {
 580     Parser_OutputPin *This = impl_from_IMediaSeeking(iface);
 581
 582     return IUnknown_AddRef((IUnknown *)This);
 583 }
 584
 585 static ULONG WINAPI Parser_Seeking_Release(IMediaSeeking * iface)
 586 {
 587     Parser_OutputPin *This = impl_from_IMediaSeeking(iface);
 588
 589     return IUnknown_Release((IUnknown *)This);
 590 }
 591
 592 static const IMediaSeekingVtbl Parser_Seeking_Vtbl =
 593 {
 594     Parser_Seeking_QueryInterface,
 595     Parser_Seeking_AddRef,
 596     Parser_Seeking_Release,
 597     MediaSeekingImpl_GetCapabilities,
 598     MediaSeekingImpl_CheckCapabilities,
 599     MediaSeekingImpl_IsFormatSupported,
 600     MediaSeekingImpl_QueryPreferredFormat,
 601     MediaSeekingImpl_GetTimeFormat,
 602     MediaSeekingImpl_IsUsingTimeFormat,
 603     MediaSeekingImpl_SetTimeFormat,
 604     MediaSeekingImpl_GetDuration,
 605     MediaSeekingImpl_GetStopPosition,
 606     MediaSeekingImpl_GetCurrentPosition,
 607     MediaSeekingImpl_ConvertTimeFormat,
 608     MediaSeekingImpl_SetPositions,
 609     MediaSeekingImpl_GetPositions,
 610     MediaSeekingImpl_GetAvailable,
 611     MediaSeekingImpl_SetRate,
 612     MediaSeekingImpl_GetRate,
 613     MediaSeekingImpl_GetPreroll
 614 };
 615
 616 static HRESULT WINAPI Parser_OutputPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
 617 {
 618     Parser_OutputPin *This = (Parser_OutputPin *)iface;
 619
 620     TRACE("(%s, %p)\n", qzdebugstr_guid(riid), ppv);
 621
 622     *ppv = NULL;
 623
 624     if (IsEqualIID(riid, &IID_IUnknown))
 625         *ppv = (LPVOID)iface;
 626     else if (IsEqualIID(riid, &IID_IPin))
 627         *ppv = (LPVOID)iface;
 628     else if (IsEqualIID(riid, &IID_IMediaSeeking))
 629         *ppv = (LPVOID)&This->mediaSeeking;
 630
 631     if (*ppv)
 632     {
 633         IUnknown_AddRef((IUnknown *)(*ppv));
 634         return S_OK;
 635     }
 636
 637     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 638
 639     return E_NOINTERFACE;
 640 }
 641
 642 static ULONG WINAPI Parser_OutputPin_Release(IPin * iface)
 643 {
 644     Parser_OutputPin *This = (Parser_OutputPin *)iface;
 645     ULONG refCount = InterlockedDecrement(&This->pin.pin.refCount);
 646
 647     TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
 648
 649     if (!refCount)
 650     {
 651         FreeMediaType(This->pmt);
 652         CoTaskMemFree(This->pmt);
 653         FreeMediaType(&This->pin.pin.mtCurrent);
 654         CoTaskMemFree(This);
 655         return 0;
 656     }
 657     return refCount;
 658 }
 659
 660 static HRESULT WINAPI Parser_OutputPin_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum)
 661 {
 662     ENUMMEDIADETAILS emd;
 663     Parser_OutputPin *This = (Parser_OutputPin *)iface;
 664
 665     TRACE("(%p)\n", ppEnum);
 666
 667     /* override this method to allow enumeration of your types */
 668     emd.cMediaTypes = 1;
 669     emd.pMediaTypes = This->pmt;
 670
 671     return IEnumMediaTypesImpl_Construct(&emd, ppEnum);
 672 }
 673
 674 static HRESULT Parser_OutputPin_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt)
 675 {
 676     Parser_OutputPin *This = (Parser_OutputPin *)iface;
 677
 678     TRACE("()\n");
 679     dump_AM_MEDIA_TYPE(pmt);
 680
 681     return (memcmp(This->pmt, pmt, sizeof(AM_MEDIA_TYPE)) == 0);
 682 }
 683
 684 static const IPinVtbl Parser_OutputPin_Vtbl =
 685 {
 686     Parser_OutputPin_QueryInterface,
 687     IPinImpl_AddRef,
 688     Parser_OutputPin_Release,
 689     OutputPin_Connect,
 690     OutputPin_ReceiveConnection,
 691     OutputPin_Disconnect,
 692     IPinImpl_ConnectedTo,
 693     IPinImpl_ConnectionMediaType,
 694     IPinImpl_QueryPinInfo,
 695     IPinImpl_QueryDirection,
 696     IPinImpl_QueryId,
 697     IPinImpl_QueryAccept,
 698     Parser_OutputPin_EnumMediaTypes,
 699     IPinImpl_QueryInternalConnections,
 700     OutputPin_EndOfStream,
 701     OutputPin_BeginFlush,
 702     OutputPin_EndFlush,
 703     OutputPin_NewSegment
 704 };
 705
 706 static HRESULT Parser_InputPin_Construct(const PIN_INFO * pPinInfo, SAMPLEPROC pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, IPin ** ppPin)
 707 {
 708     PullPin * pPinImpl;
 709
 710     *ppPin = NULL;
 711
 712     if (pPinInfo->dir != PINDIR_INPUT)
 713     {
 714         ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir);
 715         return E_INVALIDARG;
 716     }
 717
 718     pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl));
 719
 720     if (!pPinImpl)
 721         return E_OUTOFMEMORY;
 722
 723     if (SUCCEEDED(PullPin_Init(pPinInfo, pSampleProc, pUserData, pQueryAccept, pCritSec, pPinImpl)))
 724     {
 725         pPinImpl->pin.lpVtbl = &Parser_InputPin_Vtbl;
 726
 727         *ppPin = (IPin *)(&pPinImpl->pin.lpVtbl);
 728         return S_OK;
 729     }
 730     return E_FAIL;
 731 }
 732
 733 static HRESULT WINAPI Parser_InputPin_Disconnect(IPin * iface)
 734 {
 735     HRESULT hr;
 736     IPinImpl *This = (IPinImpl *)iface;
 737
 738     TRACE("()\n");
 739
 740     EnterCriticalSection(This->pCritSec);
 741     {
 742         if (This->pConnectedTo)
 743         {
 744             FILTER_STATE state;
 745
 746             hr = IBaseFilter_GetState(This->pinInfo.pFilter, 0, &state);
 747
 748             if (SUCCEEDED(hr) && (state == State_Stopped))
 749             {
 750                 IPin_Release(This->pConnectedTo);
 751                 This->pConnectedTo = NULL;
 752                 hr = Parser_RemoveOutputPins((ParserImpl *)This->pinInfo.pFilter);
 753             }
 754             else
 755                 hr = VFW_E_NOT_STOPPED;
 756         }
 757         else
 758             hr = S_FALSE;
 759     }
 760     LeaveCriticalSection(This->pCritSec);
 761
 762     return hr;
 763 }
 764
 765 HRESULT WINAPI Parser_PullPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 766 {
 767     HRESULT hr;
 768
 769     TRACE("()\n");
 770
 771     hr = PullPin_ReceiveConnection(iface, pReceivePin, pmt);
 772     if (FAILED(hr))
 773     {
 774         IPinImpl *This = (IPinImpl *)iface;
 775
 776         EnterCriticalSection(This->pCritSec);
 777         Parser_RemoveOutputPins((ParserImpl *)This->pinInfo.pFilter);
 778         LeaveCriticalSection(This->pCritSec);
 779     }
 780
 781     return hr;
 782 }
 783
 784 static const IPinVtbl Parser_InputPin_Vtbl =
 785 {
 786     PullPin_QueryInterface,
 787     IPinImpl_AddRef,
 788     PullPin_Release,
 789     OutputPin_Connect,
 790     Parser_PullPin_ReceiveConnection,
 791     Parser_InputPin_Disconnect,
 792     IPinImpl_ConnectedTo,
 793     IPinImpl_ConnectionMediaType,
 794     IPinImpl_QueryPinInfo,
 795     IPinImpl_QueryDirection,
 796     IPinImpl_QueryId,
 797     IPinImpl_QueryAccept,
 798     IPinImpl_EnumMediaTypes,
 799     IPinImpl_QueryInternalConnections,
 800     PullPin_EndOfStream,
 801     PullPin_BeginFlush,
 802     PullPin_EndFlush,
 803     PullPin_NewSegment
 804 };