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