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