mshtml: Don't create element object for document node.
[wine] / 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 };