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 "pin.h"
  24
  25 #include "vfwmsgs.h"
  26 #include "amvideo.h"
  27
  28 #include "wine/unicode.h"
  29 #include "wine/debug.h"
  30
  31 #include <math.h>
  32 #include <assert.h>
  33
  34 #include "parser.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  37
  38 static const WCHAR wcsInputPinName[] = {'i','n','p','u','t',' ','p','i','n',0};
  39 static const IMediaSeekingVtbl Parser_Seeking_Vtbl;
  40 static const IPinVtbl Parser_OutputPin_Vtbl;
  41 static const IPinVtbl Parser_InputPin_Vtbl;
  42
  43 static HRESULT WINAPI Parser_ChangeStart(IMediaSeeking *iface);
  44 static HRESULT WINAPI Parser_ChangeStop(IMediaSeeking *iface);
  45 static HRESULT WINAPI Parser_ChangeRate(IMediaSeeking *iface);
  46 static HRESULT WINAPI Parser_OutputPin_DecideBufferSize(BaseOutputPin *iface, IMemAllocator *pAlloc, ALLOCATOR_PROPERTIES *ppropInputRequest);
  47 static HRESULT WINAPI Parser_OutputPin_GetMediaType(BasePin *iface, int iPosition, AM_MEDIA_TYPE *pmt);
  48 static HRESULT WINAPI Parser_OutputPin_DecideAllocator(BaseOutputPin *This, IMemInputPin *pPin, IMemAllocator **pAlloc);
  49 static HRESULT WINAPI Parser_OutputPin_BreakConnect(BaseOutputPin *This);
  50
  51 static inline ParserImpl *impl_from_IMediaSeeking( IMediaSeeking *iface )
  52 {
  53     return CONTAINING_RECORD(iface, ParserImpl, sourceSeeking.IMediaSeeking_iface);
  54 }
  55
  56 static inline ParserImpl *impl_from_IBaseFilter( IBaseFilter *iface )
  57 {
  58     return CONTAINING_RECORD(iface, ParserImpl, filter.IBaseFilter_iface);
  59 }
  60
  61 static inline ParserImpl *impl_from_BaseFilter( BaseFilter *iface )
  62 {
  63     return CONTAINING_RECORD(iface, ParserImpl, filter);
  64 }
  65
  66 /* FIXME: WRONG */
  67 static IPin* WINAPI Parser_GetPin(BaseFilter *iface, int pos)
  68 {
  69     ParserImpl *This = impl_from_BaseFilter(iface);
  70
  71     TRACE("Asking for pos %x\n", pos);
  72
  73     /* Input pin also has a pin, hence the > and not >= */
  74     if (pos > This->cStreams || pos < 0)
  75         return NULL;
  76
  77     IPin_AddRef(This->ppPins[pos]);
  78     return This->ppPins[pos];
  79 }
  80
  81 static LONG WINAPI Parser_GetPinCount(BaseFilter *iface)
  82 {
  83     ParserImpl *This = impl_from_BaseFilter(iface);
  84
  85     return This->cStreams;
  86 }
  87
  88 static const BaseFilterFuncTable BaseFuncTable = {
  89     Parser_GetPin,
  90     Parser_GetPinCount
  91 };
  92
  93 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, SourceSeeking_ChangeStop stop, SourceSeeking_ChangeStart start, SourceSeeking_ChangeRate rate)
  94 {
  95     HRESULT hr;
  96     PIN_INFO piInput;
  97
  98     /* pTransformFilter is already allocated */
  99     BaseFilter_Init(&pParser->filter, Parser_Vtbl, pClsid, (DWORD_PTR)(__FILE__ ": ParserImpl.csFilter"), &BaseFuncTable);
 100
 101     pParser->fnDisconnect = fnDisconnect;
 102
 103     pParser->cStreams = 0;
 104     pParser->ppPins = CoTaskMemAlloc(1 * sizeof(IPin *));
 105
 106     /* construct input pin */
 107     piInput.dir = PINDIR_INPUT;
 108     piInput.pFilter = &pParser->filter.IBaseFilter_iface;
 109     lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0]));
 110
 111     if (!start)
 112         start = Parser_ChangeStart;
 113
 114     if (!stop)
 115         stop = Parser_ChangeStop;
 116
 117     if (!rate)
 118         rate = Parser_ChangeRate;
 119
 120     SourceSeeking_Init(&pParser->sourceSeeking, &Parser_Seeking_Vtbl, stop, start, rate,  &pParser->filter.csFilter);
 121
 122     hr = PullPin_Construct(&Parser_InputPin_Vtbl, &piInput, fnProcessSample, (LPVOID)pParser, fnQueryAccept, fnCleanup, fnRequest, fnDone, &pParser->filter.csFilter, (IPin **)&pParser->pInputPin);
 123
 124     if (SUCCEEDED(hr))
 125     {
 126         pParser->ppPins[0] = &pParser->pInputPin->pin.IPin_iface;
 127         pParser->pInputPin->fnPreConnect = fnPreConnect;
 128     }
 129     else
 130     {
 131         CoTaskMemFree(pParser->ppPins);
 132         BaseFilterImpl_Release(&pParser->filter.IBaseFilter_iface);
 133         CoTaskMemFree(pParser);
 134     }
 135
 136     return hr;
 137 }
 138
 139 HRESULT WINAPI Parser_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
 140 {
 141     ParserImpl *This = impl_from_IBaseFilter(iface);
 142     TRACE("(%s, %p)\n", qzdebugstr_guid(riid), ppv);
 143
 144     *ppv = NULL;
 145
 146     if ( IsEqualIID(riid, &IID_IUnknown)
 147       || IsEqualIID(riid, &IID_IPersist)
 148       || IsEqualIID(riid, &IID_IMediaFilter)
 149       || IsEqualIID(riid, &IID_IBaseFilter) )
 150         *ppv = This;
 151
 152     if (*ppv)
 153     {
 154         IUnknown_AddRef((IUnknown *)(*ppv));
 155         return S_OK;
 156     }
 157
 158     if (!IsEqualIID(riid, &IID_IPin) && !IsEqualIID(riid, &IID_IVideoWindow))
 159         FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 160
 161     return E_NOINTERFACE;
 162 }
 163
 164 ULONG WINAPI Parser_AddRef(IBaseFilter * iface)
 165 {
 166     return BaseFilterImpl_AddRef(iface);
 167 }
 168
 169 void Parser_Destroy(ParserImpl *This)
 170 {
 171     IPin *connected = NULL;
 172     ULONG pinref;
 173
 174     assert(!This->filter.refCount);
 175     PullPin_WaitForStateChange(This->pInputPin, INFINITE);
 176
 177     /* Don't need to clean up output pins, freeing input pin will do that */
 178     IPin_ConnectedTo(&This->pInputPin->pin.IPin_iface, &connected);
 179     if (connected)
 180     {
 181         assert(IPin_Disconnect(connected) == S_OK);
 182         IPin_Release(connected);
 183         assert(IPin_Disconnect(&This->pInputPin->pin.IPin_iface) == S_OK);
 184     }
 185     pinref = IPin_Release(&This->pInputPin->pin.IPin_iface);
 186     if (pinref)
 187     {
 188         /* Valgrind could find this, if I kill it here */
 189         ERR("pinref should be null, is %u, destroying anyway\n", pinref);
 190         assert((LONG)pinref > 0);
 191
 192         while (pinref)
 193             pinref = IPin_Release(&This->pInputPin->pin.IPin_iface);
 194     }
 195
 196     CoTaskMemFree(This->ppPins);
 197
 198     TRACE("Destroying parser\n");
 199     CoTaskMemFree(This);
 200 }
 201
 202 ULONG WINAPI Parser_Release(IBaseFilter * iface)
 203 {
 204     ParserImpl *This = impl_from_IBaseFilter(iface);
 205     ULONG refCount = BaseFilterImpl_Release(iface);
 206
 207     TRACE("(%p)->() Release from %d\n", This, refCount + 1);
 208
 209     if (!refCount)
 210         Parser_Destroy(This);
 211
 212     return refCount;
 213 }
 214
 215 /** IPersist methods **/
 216
 217 HRESULT WINAPI Parser_GetClassID(IBaseFilter * iface, CLSID * pClsid)
 218 {
 219     ParserImpl *This = impl_from_IBaseFilter(iface);
 220
 221     TRACE("(%p)\n", pClsid);
 222
 223     *pClsid = This->filter.clsid;
 224
 225     return S_OK;
 226 }
 227
 228 /** IMediaFilter methods **/
 229
 230 HRESULT WINAPI Parser_Stop(IBaseFilter * iface)
 231 {
 232     ParserImpl *This = impl_from_IBaseFilter(iface);
 233     PullPin *pin = impl_PullPin_from_IPin(This->ppPins[0]);
 234     ULONG i;
 235
 236     TRACE("()\n");
 237
 238     EnterCriticalSection(&pin->thread_lock);
 239
 240     IAsyncReader_BeginFlush(This->pInputPin->pReader);
 241     EnterCriticalSection(&This->filter.csFilter);
 242
 243     if (This->filter.state == State_Stopped)
 244     {
 245         LeaveCriticalSection(&This->filter.csFilter);
 246         IAsyncReader_EndFlush(This->pInputPin->pReader);
 247         LeaveCriticalSection(&pin->thread_lock);
 248         return S_OK;
 249     }
 250
 251     This->filter.state = State_Stopped;
 252
 253     for (i = 1; i < (This->cStreams + 1); i++)
 254     {
 255         BaseOutputPinImpl_Inactive((BaseOutputPin *)This->ppPins[i]);
 256     }
 257
 258     LeaveCriticalSection(&This->filter.csFilter);
 259
 260     PullPin_PauseProcessing(This->pInputPin);
 261     PullPin_WaitForStateChange(This->pInputPin, INFINITE);
 262     IAsyncReader_EndFlush(This->pInputPin->pReader);
 263
 264     LeaveCriticalSection(&pin->thread_lock);
 265     return S_OK;
 266 }
 267
 268 HRESULT WINAPI Parser_Pause(IBaseFilter * iface)
 269 {
 270     HRESULT hr = S_OK;
 271     ParserImpl *This = impl_from_IBaseFilter(iface);
 272     PullPin *pin = impl_PullPin_from_IPin(This->ppPins[0]);
 273
 274     TRACE("()\n");
 275
 276     EnterCriticalSection(&pin->thread_lock);
 277     EnterCriticalSection(&This->filter.csFilter);
 278
 279     if (This->filter.state == State_Paused)
 280     {
 281         LeaveCriticalSection(&This->filter.csFilter);
 282         LeaveCriticalSection(&pin->thread_lock);
 283         return S_OK;
 284     }
 285
 286     if (This->filter.state == State_Stopped)
 287     {
 288         LeaveCriticalSection(&This->filter.csFilter);
 289         hr = IBaseFilter_Run(iface, -1);
 290         EnterCriticalSection(&This->filter.csFilter);
 291     }
 292
 293     if (SUCCEEDED(hr))
 294         This->filter.state = State_Paused;
 295
 296     LeaveCriticalSection(&This->filter.csFilter);
 297     LeaveCriticalSection(&pin->thread_lock);
 298
 299     return hr;
 300 }
 301
 302 HRESULT WINAPI Parser_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
 303 {
 304     HRESULT hr = S_OK;
 305     ParserImpl *This = impl_from_IBaseFilter(iface);
 306     PullPin *pin = impl_PullPin_from_IPin(This->ppPins[0]);
 307
 308     ULONG i;
 309
 310     TRACE("(%s)\n", wine_dbgstr_longlong(tStart));
 311
 312     EnterCriticalSection(&pin->thread_lock);
 313     EnterCriticalSection(&This->filter.csFilter);
 314     {
 315         HRESULT hr_any = VFW_E_NOT_CONNECTED;
 316
 317         This->filter.rtStreamStart = tStart;
 318         if (This->filter.state == State_Running || This->filter.state == State_Paused)
 319         {
 320             This->filter.state = State_Running;
 321             LeaveCriticalSection(&This->filter.csFilter);
 322             LeaveCriticalSection(&pin->thread_lock);
 323             return S_OK;
 324         }
 325
 326         for (i = 1; i < (This->cStreams + 1); i++)
 327         {
 328             hr = BaseOutputPinImpl_Active((BaseOutputPin *)This->ppPins[i]);
 329             if (SUCCEEDED(hr))
 330                 hr_any = hr;
 331         }
 332
 333         hr = hr_any;
 334         if (SUCCEEDED(hr))
 335         {
 336             LeaveCriticalSection(&This->filter.csFilter);
 337             hr = PullPin_StartProcessing(This->pInputPin);
 338             EnterCriticalSection(&This->filter.csFilter);
 339         }
 340
 341         if (SUCCEEDED(hr))
 342             This->filter.state = State_Running;
 343     }
 344     LeaveCriticalSection(&This->filter.csFilter);
 345     LeaveCriticalSection(&pin->thread_lock);
 346
 347     return hr;
 348 }
 349
 350 HRESULT WINAPI Parser_GetState(IBaseFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
 351 {
 352     ParserImpl *This = impl_from_IBaseFilter(iface);
 353     PullPin *pin = impl_PullPin_from_IPin(This->ppPins[0]);
 354     HRESULT hr = S_OK;
 355
 356     TRACE("(%d, %p)\n", dwMilliSecsTimeout, pState);
 357
 358     EnterCriticalSection(&pin->thread_lock);
 359     EnterCriticalSection(&This->filter.csFilter);
 360     {
 361         *pState = This->filter.state;
 362     }
 363     LeaveCriticalSection(&This->filter.csFilter);
 364
 365     if (This->pInputPin && (PullPin_WaitForStateChange(This->pInputPin, dwMilliSecsTimeout) == S_FALSE))
 366         hr = VFW_S_STATE_INTERMEDIATE;
 367     LeaveCriticalSection(&pin->thread_lock);
 368
 369     return hr;
 370 }
 371
 372 HRESULT WINAPI Parser_SetSyncSource(IBaseFilter * iface, IReferenceClock *pClock)
 373 {
 374     ParserImpl *This = impl_from_IBaseFilter(iface);
 375     PullPin *pin = impl_PullPin_from_IPin(This->ppPins[0]);
 376
 377     TRACE("(%p)\n", pClock);
 378
 379     EnterCriticalSection(&pin->thread_lock);
 380     BaseFilterImpl_SetSyncSource(iface,pClock);
 381     LeaveCriticalSection(&pin->thread_lock);
 382
 383     return S_OK;
 384 }
 385
 386 HRESULT WINAPI Parser_GetSyncSource(IBaseFilter * iface, IReferenceClock **ppClock)
 387 {
 388     return BaseFilterImpl_GetSyncSource(iface, ppClock);
 389 }
 390
 391 /** IBaseFilter implementation **/
 392
 393 HRESULT WINAPI Parser_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum)
 394 {
 395     return BaseFilterImpl_EnumPins(iface,ppEnum);
 396 }
 397
 398 HRESULT WINAPI Parser_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
 399 {
 400     FIXME("(%p)->(%s,%p)\n", iface, debugstr_w(Id), ppPin);
 401
 402     /* FIXME: critical section */
 403
 404     return E_NOTIMPL;
 405 }
 406
 407 HRESULT WINAPI Parser_QueryFilterInfo(IBaseFilter * iface, FILTER_INFO *pInfo)
 408 {
 409     return BaseFilterImpl_QueryFilterInfo(iface, pInfo);
 410 }
 411
 412 HRESULT WINAPI Parser_JoinFilterGraph(IBaseFilter * iface, IFilterGraph *pGraph, LPCWSTR pName)
 413 {
 414     return BaseFilterImpl_JoinFilterGraph(iface, pGraph, pName);
 415 }
 416
 417 HRESULT WINAPI Parser_QueryVendorInfo(IBaseFilter * iface, LPWSTR *pVendorInfo)
 418 {
 419     return BaseFilterImpl_QueryVendorInfo(iface, pVendorInfo);
 420 }
 421
 422 static const BaseOutputPinFuncTable output_BaseOutputFuncTable = {
 423     {
 424         NULL,
 425         BaseOutputPinImpl_AttemptConnection,
 426         BasePinImpl_GetMediaTypeVersion,
 427         Parser_OutputPin_GetMediaType
 428     },
 429     Parser_OutputPin_DecideBufferSize,
 430     Parser_OutputPin_DecideAllocator,
 431     Parser_OutputPin_BreakConnect
 432 };
 433
 434 HRESULT Parser_AddPin(ParserImpl * This, const PIN_INFO * piOutput, ALLOCATOR_PROPERTIES * props, const AM_MEDIA_TYPE * amt)
 435 {
 436     IPin ** ppOldPins;
 437     HRESULT hr;
 438
 439     ppOldPins = This->ppPins;
 440
 441     This->ppPins = CoTaskMemAlloc((This->cStreams + 2) * sizeof(IPin *));
 442     memcpy(This->ppPins, ppOldPins, (This->cStreams + 1) * sizeof(IPin *));
 443
 444     hr = BaseOutputPin_Construct(&Parser_OutputPin_Vtbl, sizeof(Parser_OutputPin), piOutput, &output_BaseOutputFuncTable, &This->filter.csFilter, This->ppPins + (This->cStreams + 1));
 445
 446     if (SUCCEEDED(hr))
 447     {
 448         IPin *pPin = This->ppPins[This->cStreams + 1];
 449         Parser_OutputPin *pin = unsafe_impl_Parser_OutputPin_from_IPin(pPin);
 450         pin->pmt = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
 451         CopyMediaType(pin->pmt, amt);
 452         pin->dwSamplesProcessed = 0;
 453
 454         pin->pin.pin.pinInfo.pFilter = (LPVOID)This;
 455         pin->allocProps = *props;
 456         This->cStreams++;
 457         BaseFilterImpl_IncrementPinVersion(&This->filter);
 458         CoTaskMemFree(ppOldPins);
 459     }
 460     else
 461     {
 462         CoTaskMemFree(This->ppPins);
 463         This->ppPins = ppOldPins;
 464         ERR("Failed with error %x\n", hr);
 465     }
 466
 467     return hr;
 468 }
 469
 470 static HRESULT Parser_RemoveOutputPins(ParserImpl * This)
 471 {
 472     /* NOTE: should be in critical section when calling this function */
 473     HRESULT hr;
 474     ULONG i;
 475     IPin ** ppOldPins = This->ppPins;
 476
 477     TRACE("(%p)\n", This);
 478
 479     /* reduce the pin array down to 1 (just our input pin) */
 480     This->ppPins = CoTaskMemAlloc(sizeof(IPin *) * 1);
 481     memcpy(This->ppPins, ppOldPins, sizeof(IPin *) * 1);
 482
 483     for (i = 0; i < This->cStreams; i++)
 484     {
 485         hr = ((BaseOutputPin *)ppOldPins[i + 1])->pFuncsTable->pfnBreakConnect((BaseOutputPin *)ppOldPins[i + 1]);
 486         TRACE("Disconnect: %08x\n", hr);
 487         IPin_Release(ppOldPins[i + 1]);
 488     }
 489
 490     BaseFilterImpl_IncrementPinVersion(&This->filter);
 491     This->cStreams = 0;
 492     CoTaskMemFree(ppOldPins);
 493
 494     return S_OK;
 495 }
 496
 497 static HRESULT WINAPI Parser_ChangeStart(IMediaSeeking *iface)
 498 {
 499     FIXME("(%p) filter hasn't implemented start position change!\n", iface);
 500     return S_OK;
 501 }
 502
 503 static HRESULT WINAPI Parser_ChangeStop(IMediaSeeking *iface)
 504 {
 505     FIXME("(%p) filter hasn't implemented stop position change!\n", iface);
 506     return S_OK;
 507 }
 508
 509 static HRESULT WINAPI Parser_ChangeRate(IMediaSeeking *iface)
 510 {
 511     FIXME("(%p) filter hasn't implemented rate change!\n", iface);
 512     return S_OK;
 513 }
 514
 515
 516 static HRESULT WINAPI Parser_Seeking_QueryInterface(IMediaSeeking * iface, REFIID riid, LPVOID * ppv)
 517 {
 518     ParserImpl *This = impl_from_IMediaSeeking(iface);
 519
 520     return IUnknown_QueryInterface((IUnknown *)This, riid, ppv);
 521 }
 522
 523 static ULONG WINAPI Parser_Seeking_AddRef(IMediaSeeking * iface)
 524 {
 525     ParserImpl *This = impl_from_IMediaSeeking(iface);
 526
 527     return IUnknown_AddRef((IUnknown *)This);
 528 }
 529
 530 static ULONG WINAPI Parser_Seeking_Release(IMediaSeeking * iface)
 531 {
 532     ParserImpl *This = impl_from_IMediaSeeking(iface);
 533
 534     return IUnknown_Release((IUnknown *)This);
 535 }
 536
 537 static const IMediaSeekingVtbl Parser_Seeking_Vtbl =
 538 {
 539     Parser_Seeking_QueryInterface,
 540     Parser_Seeking_AddRef,
 541     Parser_Seeking_Release,
 542     SourceSeekingImpl_GetCapabilities,
 543     SourceSeekingImpl_CheckCapabilities,
 544     SourceSeekingImpl_IsFormatSupported,
 545     SourceSeekingImpl_QueryPreferredFormat,
 546     SourceSeekingImpl_GetTimeFormat,
 547     SourceSeekingImpl_IsUsingTimeFormat,
 548     SourceSeekingImpl_SetTimeFormat,
 549     SourceSeekingImpl_GetDuration,
 550     SourceSeekingImpl_GetStopPosition,
 551     SourceSeekingImpl_GetCurrentPosition,
 552     SourceSeekingImpl_ConvertTimeFormat,
 553     SourceSeekingImpl_SetPositions,
 554     SourceSeekingImpl_GetPositions,
 555     SourceSeekingImpl_GetAvailable,
 556     SourceSeekingImpl_SetRate,
 557     SourceSeekingImpl_GetRate,
 558     SourceSeekingImpl_GetPreroll
 559 };
 560
 561 static HRESULT WINAPI Parser_OutputPin_DecideBufferSize(BaseOutputPin *iface, IMemAllocator *pAlloc, ALLOCATOR_PROPERTIES *ppropInputRequest)
 562 {
 563     Parser_OutputPin *This = (Parser_OutputPin*)iface;
 564     ALLOCATOR_PROPERTIES actual;
 565
 566     if (ppropInputRequest->cbAlign && ppropInputRequest->cbAlign != This->allocProps.cbAlign)
 567         FIXME("Requested Buffer cbAlign mismatch %i,%i\n",This->allocProps.cbAlign, ppropInputRequest->cbAlign);
 568     if (ppropInputRequest->cbPrefix)
 569         FIXME("Requested Buffer cbPrefix mismatch %i,%i\n",This->allocProps.cbPrefix, ppropInputRequest->cbPrefix);
 570     if (ppropInputRequest->cbBuffer)
 571         FIXME("Requested Buffer cbBuffer mismatch %i,%i\n",This->allocProps.cbBuffer, ppropInputRequest->cbBuffer);
 572     if (ppropInputRequest->cBuffers)
 573         FIXME("Requested Buffer cBuffers mismatch %i,%i\n",This->allocProps.cBuffers, ppropInputRequest->cBuffers);
 574
 575     return IMemAllocator_SetProperties(pAlloc, &This->allocProps, &actual);
 576 }
 577
 578 static HRESULT WINAPI Parser_OutputPin_GetMediaType(BasePin *iface, int iPosition, AM_MEDIA_TYPE *pmt)
 579 {
 580     Parser_OutputPin *This = (Parser_OutputPin*)iface;
 581     if (iPosition < 0)
 582         return E_INVALIDARG;
 583     if (iPosition > 0)
 584         return VFW_S_NO_MORE_ITEMS;
 585     CopyMediaType(pmt, This->pmt);
 586     return S_OK;
 587 }
 588
 589 static HRESULT WINAPI Parser_OutputPin_DecideAllocator(BaseOutputPin *iface, IMemInputPin *pPin, IMemAllocator **pAlloc)
 590 {
 591     Parser_OutputPin *This = (Parser_OutputPin*)iface;
 592     HRESULT hr;
 593
 594     *pAlloc = NULL;
 595
 596     if (This->alloc)
 597     {
 598         hr = IMemInputPin_NotifyAllocator(pPin, This->alloc, This->readonly);
 599         if (SUCCEEDED(hr))
 600         {
 601             *pAlloc = This->alloc;
 602             IMemAllocator_AddRef(*pAlloc);
 603         }
 604     }
 605     else
 606         hr = VFW_E_NO_ALLOCATOR;
 607
 608     return hr;
 609 }
 610
 611 static HRESULT WINAPI Parser_OutputPin_BreakConnect(BaseOutputPin *This)
 612 {
 613     HRESULT hr;
 614
 615     TRACE("(%p)->()\n", This);
 616
 617     EnterCriticalSection(This->pin.pCritSec);
 618     if (!This->pin.pConnectedTo || !This->pMemInputPin)
 619         hr = VFW_E_NOT_CONNECTED;
 620     else
 621     {
 622         hr = IPin_Disconnect(This->pin.pConnectedTo);
 623         IPin_Disconnect(&This->pin.IPin_iface);
 624     }
 625     LeaveCriticalSection(This->pin.pCritSec);
 626
 627     return hr;
 628 }
 629
 630
 631 static HRESULT WINAPI Parser_OutputPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
 632 {
 633     Parser_OutputPin *This = unsafe_impl_Parser_OutputPin_from_IPin(iface);
 634
 635     TRACE("(%s, %p)\n", qzdebugstr_guid(riid), ppv);
 636
 637     *ppv = NULL;
 638
 639     if (IsEqualIID(riid, &IID_IUnknown))
 640         *ppv = iface;
 641     else if (IsEqualIID(riid, &IID_IPin))
 642         *ppv = iface;
 643     /* The Parser filter does not support querying IMediaSeeking, return it directly */
 644     else if (IsEqualIID(riid, &IID_IMediaSeeking))
 645         *ppv = &impl_from_IBaseFilter(This->pin.pin.pinInfo.pFilter)->sourceSeeking;
 646
 647     if (*ppv)
 648     {
 649         IUnknown_AddRef((IUnknown *)(*ppv));
 650         return S_OK;
 651     }
 652
 653     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 654
 655     return E_NOINTERFACE;
 656 }
 657
 658 static ULONG WINAPI Parser_OutputPin_Release(IPin * iface)
 659 {
 660     Parser_OutputPin *This = unsafe_impl_Parser_OutputPin_from_IPin(iface);
 661     ULONG refCount = InterlockedDecrement(&This->pin.pin.refCount);
 662
 663     TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
 664
 665     if (!refCount)
 666     {
 667         FreeMediaType(This->pmt);
 668         CoTaskMemFree(This->pmt);
 669         FreeMediaType(&This->pin.pin.mtCurrent);
 670         if (This->pin.pAllocator)
 671             IMemAllocator_Release(This->pin.pAllocator);
 672         CoTaskMemFree(This);
 673         return 0;
 674     }
 675     return refCount;
 676 }
 677
 678 static HRESULT WINAPI Parser_OutputPin_Connect(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 679 {
 680     Parser_OutputPin *This = unsafe_impl_Parser_OutputPin_from_IPin(iface);
 681     ParserImpl *parser = impl_from_IBaseFilter(This->pin.pin.pinInfo.pFilter);
 682
 683     /* Set the allocator to our input pin's */
 684     EnterCriticalSection(This->pin.pin.pCritSec);
 685     This->alloc = parser->pInputPin->pAlloc;
 686     LeaveCriticalSection(This->pin.pin.pCritSec);
 687
 688     return BaseOutputPinImpl_Connect(iface, pReceivePin, pmt);
 689 }
 690
 691 static HRESULT WINAPI Parser_OutputPin_QueryAccept(IPin *iface, const AM_MEDIA_TYPE * pmt)
 692 {
 693     Parser_OutputPin *This = unsafe_impl_Parser_OutputPin_from_IPin(iface);
 694
 695     TRACE("()\n");
 696     dump_AM_MEDIA_TYPE(pmt);
 697
 698     return (memcmp(This->pmt, pmt, sizeof(AM_MEDIA_TYPE)) == 0);
 699 }
 700
 701 static const IPinVtbl Parser_OutputPin_Vtbl =
 702 {
 703     Parser_OutputPin_QueryInterface,
 704     BasePinImpl_AddRef,
 705     Parser_OutputPin_Release,
 706     Parser_OutputPin_Connect,
 707     BaseOutputPinImpl_ReceiveConnection,
 708     BaseOutputPinImpl_Disconnect,
 709     BasePinImpl_ConnectedTo,
 710     BasePinImpl_ConnectionMediaType,
 711     BasePinImpl_QueryPinInfo,
 712     BasePinImpl_QueryDirection,
 713     BasePinImpl_QueryId,
 714     Parser_OutputPin_QueryAccept,
 715     BasePinImpl_EnumMediaTypes,
 716     BasePinImpl_QueryInternalConnections,
 717     BaseOutputPinImpl_EndOfStream,
 718     BaseOutputPinImpl_BeginFlush,
 719     BaseOutputPinImpl_EndFlush,
 720     BasePinImpl_NewSegment
 721 };
 722
 723 static HRESULT WINAPI Parser_PullPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
 724 {
 725     PullPin *This = impl_PullPin_from_IPin(iface);
 726
 727     TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
 728
 729     *ppv = NULL;
 730
 731     /*
 732      * It is important to capture the request for the IMediaSeeking interface before it is passed
 733      * on to PullPin_QueryInterface, this is necessary since the Parser filter does not support
 734      * querying IMediaSeeking
 735      */
 736     if (IsEqualIID(riid, &IID_IMediaSeeking))
 737         *ppv = &impl_from_IBaseFilter(This->pin.pinInfo.pFilter)->sourceSeeking;
 738
 739     if (*ppv)
 740     {
 741         IUnknown_AddRef((IUnknown *)(*ppv));
 742         return S_OK;
 743     }
 744
 745     return PullPin_QueryInterface(iface, riid, ppv);
 746 }
 747
 748 static HRESULT WINAPI Parser_PullPin_Disconnect(IPin * iface)
 749 {
 750     HRESULT hr;
 751     PullPin *This = impl_PullPin_from_IPin(iface);
 752
 753     TRACE("()\n");
 754
 755     EnterCriticalSection(&This->thread_lock);
 756     EnterCriticalSection(This->pin.pCritSec);
 757     {
 758         if (This->pin.pConnectedTo)
 759         {
 760             FILTER_STATE state;
 761             ParserImpl *Parser = impl_from_IBaseFilter(This->pin.pinInfo.pFilter);
 762
 763             LeaveCriticalSection(This->pin.pCritSec);
 764             hr = IBaseFilter_GetState(This->pin.pinInfo.pFilter, INFINITE, &state);
 765             EnterCriticalSection(This->pin.pCritSec);
 766
 767             if (SUCCEEDED(hr) && (state == State_Stopped) && SUCCEEDED(Parser->fnDisconnect(Parser)))
 768             {
 769                 LeaveCriticalSection(This->pin.pCritSec);
 770                 PullPin_Disconnect(iface);
 771                 EnterCriticalSection(This->pin.pCritSec);
 772                 hr = Parser_RemoveOutputPins(impl_from_IBaseFilter(This->pin.pinInfo.pFilter));
 773             }
 774             else
 775                 hr = VFW_E_NOT_STOPPED;
 776         }
 777         else
 778             hr = S_FALSE;
 779     }
 780     LeaveCriticalSection(This->pin.pCritSec);
 781     LeaveCriticalSection(&This->thread_lock);
 782
 783     return hr;
 784 }
 785
 786 static HRESULT WINAPI Parser_PullPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 787 {
 788     HRESULT hr;
 789
 790     TRACE("()\n");
 791
 792     hr = PullPin_ReceiveConnection(iface, pReceivePin, pmt);
 793     if (FAILED(hr))
 794     {
 795         BasePin *This = (BasePin *)iface;
 796
 797         EnterCriticalSection(This->pCritSec);
 798         Parser_RemoveOutputPins(impl_from_IBaseFilter(This->pinInfo.pFilter));
 799         LeaveCriticalSection(This->pCritSec);
 800     }
 801
 802     return hr;
 803 }
 804
 805 static HRESULT WINAPI Parser_PullPin_EnumMediaTypes(IPin *iface, IEnumMediaTypes **ppEnum)
 806 {
 807     BasePin *This = (BasePin *)iface;
 808
 809     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 810
 811     return EnumMediaTypes_Construct(This, BasePinImpl_GetMediaType, BasePinImpl_GetMediaTypeVersion, ppEnum);
 812 }
 813
 814 static const IPinVtbl Parser_InputPin_Vtbl =
 815 {
 816     Parser_PullPin_QueryInterface,
 817     BasePinImpl_AddRef,
 818     PullPin_Release,
 819     BaseInputPinImpl_Connect,
 820     Parser_PullPin_ReceiveConnection,
 821     Parser_PullPin_Disconnect,
 822     BasePinImpl_ConnectedTo,
 823     BasePinImpl_ConnectionMediaType,
 824     BasePinImpl_QueryPinInfo,
 825     BasePinImpl_QueryDirection,
 826     BasePinImpl_QueryId,
 827     PullPin_QueryAccept,
 828     Parser_PullPin_EnumMediaTypes,
 829     BasePinImpl_QueryInternalConnections,
 830     PullPin_EndOfStream,
 831     PullPin_BeginFlush,
 832     PullPin_EndFlush,
 833     PullPin_NewSegment
 834 };