1 /* DirectShow FilterGraph object (QUARTZ.DLL)
3 * Copyright 2002 Lionel Ulmer
4 * Copyright 2004 Christian Costa
6 * This file contains the (internal) driver registration functions,
7 * driver enumeration APIs and DirectDraw creation functions.
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
35 #include "wine/debug.h"
36 #include "quartz_private.h"
42 #include "wine/unicode.h"
45 WINE_DEFAULT_DEBUG_CHANNEL(quartz
);
48 HWND hWnd
; /* Target window */
49 long msg
; /* User window message */
50 long instance
; /* User data */
51 int disabled
; /* Disabled messages posting */
55 long lEventCode
; /* Event code */
56 LONG_PTR lParam1
; /* Param1 */
57 LONG_PTR lParam2
; /* Param2 */
60 /* messages ring implementation for queuing events (taken from winmm) */
61 #define EVENTS_RING_BUFFER_INCREMENT 64
67 CRITICAL_SECTION msg_crst
;
68 HANDLE msg_event
; /* Signaled for no empty queue */
71 static int EventsQueue_Init(EventsQueue
* omr
)
75 omr
->msg_event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
76 omr
->ring_buffer_size
= EVENTS_RING_BUFFER_INCREMENT
;
77 omr
->messages
= CoTaskMemAlloc(omr
->ring_buffer_size
* sizeof(Event
));
78 ZeroMemory(omr
->messages
, omr
->ring_buffer_size
* sizeof(Event
));
80 InitializeCriticalSection(&omr
->msg_crst
);
81 omr
->msg_crst
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": EventsQueue.msg_crst");
85 static int EventsQueue_Destroy(EventsQueue
* omr
)
87 CloseHandle(omr
->msg_event
);
88 CoTaskMemFree(omr
->messages
);
89 omr
->msg_crst
.DebugInfo
->Spare
[0] = 0;
90 DeleteCriticalSection(&omr
->msg_crst
);
94 static int EventsQueue_PutEvent(EventsQueue
* omr
, const Event
* evt
)
96 EnterCriticalSection(&omr
->msg_crst
);
97 if ((omr
->msg_toget
== ((omr
->msg_tosave
+ 1) % omr
->ring_buffer_size
)))
99 int old_ring_buffer_size
= omr
->ring_buffer_size
;
100 omr
->ring_buffer_size
+= EVENTS_RING_BUFFER_INCREMENT
;
101 TRACE("omr->ring_buffer_size=%d\n",omr
->ring_buffer_size
);
102 omr
->messages
= HeapReAlloc(GetProcessHeap(),0,omr
->messages
, omr
->ring_buffer_size
* sizeof(Event
));
103 /* Now we need to rearrange the ring buffer so that the new
104 buffers just allocated are in between omr->msg_tosave and
107 if (omr
->msg_tosave
< omr
->msg_toget
)
109 memmove(&(omr
->messages
[omr
->msg_toget
+ EVENTS_RING_BUFFER_INCREMENT
]),
110 &(omr
->messages
[omr
->msg_toget
]),
111 sizeof(Event
)*(old_ring_buffer_size
- omr
->msg_toget
)
113 omr
->msg_toget
+= EVENTS_RING_BUFFER_INCREMENT
;
116 omr
->messages
[omr
->msg_tosave
] = *evt
;
117 SetEvent(omr
->msg_event
);
118 omr
->msg_tosave
= (omr
->msg_tosave
+ 1) % omr
->ring_buffer_size
;
119 LeaveCriticalSection(&omr
->msg_crst
);
123 static int EventsQueue_GetEvent(EventsQueue
* omr
, Event
* evt
, long msTimeOut
)
125 if (WaitForSingleObject(omr
->msg_event
, msTimeOut
) != WAIT_OBJECT_0
)
128 EnterCriticalSection(&omr
->msg_crst
);
130 if (omr
->msg_toget
== omr
->msg_tosave
) /* buffer empty ? */
132 LeaveCriticalSection(&omr
->msg_crst
);
136 *evt
= omr
->messages
[omr
->msg_toget
];
137 omr
->msg_toget
= (omr
->msg_toget
+ 1) % omr
->ring_buffer_size
;
139 /* Mark the buffer as empty if needed */
140 if (omr
->msg_toget
== omr
->msg_tosave
) /* buffer empty ? */
141 ResetEvent(omr
->msg_event
);
143 LeaveCriticalSection(&omr
->msg_crst
);
147 #define MAX_ITF_CACHE_ENTRIES 3
148 typedef struct _ITF_CACHE_ENTRY
{
154 typedef struct _IFilterGraphImpl
{
155 const IFilterGraph2Vtbl
*IFilterGraph2_vtbl
;
156 const IMediaControlVtbl
*IMediaControl_vtbl
;
157 const IMediaSeekingVtbl
*IMediaSeeking_vtbl
;
158 const IBasicAudioVtbl
*IBasicAudio_vtbl
;
159 const IBasicVideo2Vtbl
*IBasicVideo_vtbl
;
160 const IVideoWindowVtbl
*IVideoWindow_vtbl
;
161 const IMediaEventExVtbl
*IMediaEventEx_vtbl
;
162 const IMediaFilterVtbl
*IMediaFilter_vtbl
;
163 const IMediaEventSinkVtbl
*IMediaEventSink_vtbl
;
164 const IGraphConfigVtbl
*IGraphConfig_vtbl
;
165 const IMediaPositionVtbl
*IMediaPosition_vtbl
;
166 const IUnknownVtbl
* IInner_vtbl
;
167 /* IAMGraphStreams */
173 /* IRegisterServiceProvider */
174 /* IResourceMananger */
175 /* IServiceProvider */
176 /* IVideoFrameStep */
179 IUnknown
*punkFilterMapper2
;
180 IFilterMapper2
* pFilterMapper2
;
181 IBaseFilter
** ppFiltersInGraph
;
182 LPWSTR
* pFilterNames
;
186 IReferenceClock
*refClock
;
188 HANDLE hEventCompletion
;
189 int CompletionStatus
;
193 int HandleEcComplete
;
195 int HandleEcClockChanged
;
198 ITF_CACHE_ENTRY ItfCacheEntries
[MAX_ITF_CACHE_ENTRIES
];
199 int nItfCacheEntries
;
200 IUnknown
* pUnkOuter
;
206 LONGLONG stop_position
;
209 static HRESULT WINAPI
Filtergraph_QueryInterface(IFilterGraphImpl
*This
,
210 REFIID riid
, LPVOID
* ppv
);
211 static ULONG WINAPI
Filtergraph_AddRef(IFilterGraphImpl
*This
);
212 static ULONG WINAPI
Filtergraph_Release(IFilterGraphImpl
*This
);
214 static HRESULT WINAPI
FilterGraphInner_QueryInterface(IUnknown
* iface
,
217 ICOM_THIS_MULTI(IFilterGraphImpl
, IInner_vtbl
, iface
);
218 TRACE("(%p)->(%s (%p), %p)\n", This
, debugstr_guid(riid
), riid
, ppvObj
);
220 if (This
->bAggregatable
)
221 This
->bUnkOuterValid
= TRUE
;
223 if (IsEqualGUID(&IID_IUnknown
, riid
)) {
224 *ppvObj
= &(This
->IInner_vtbl
);
225 TRACE(" returning IUnknown interface (%p)\n", *ppvObj
);
226 } else if (IsEqualGUID(&IID_IFilterGraph
, riid
) ||
227 IsEqualGUID(&IID_IFilterGraph2
, riid
) ||
228 IsEqualGUID(&IID_IGraphBuilder
, riid
)) {
229 *ppvObj
= &(This
->IFilterGraph2_vtbl
);
230 TRACE(" returning IGraphBuilder interface (%p)\n", *ppvObj
);
231 } else if (IsEqualGUID(&IID_IMediaControl
, riid
)) {
232 *ppvObj
= &(This
->IMediaControl_vtbl
);
233 TRACE(" returning IMediaControl interface (%p)\n", *ppvObj
);
234 } else if (IsEqualGUID(&IID_IMediaSeeking
, riid
)) {
235 *ppvObj
= &(This
->IMediaSeeking_vtbl
);
236 TRACE(" returning IMediaSeeking interface (%p)\n", *ppvObj
);
237 } else if (IsEqualGUID(&IID_IBasicAudio
, riid
)) {
238 *ppvObj
= &(This
->IBasicAudio_vtbl
);
239 TRACE(" returning IBasicAudio interface (%p)\n", *ppvObj
);
240 } else if (IsEqualGUID(&IID_IBasicVideo
, riid
) ||
241 IsEqualGUID(&IID_IBasicVideo2
, riid
)) {
242 *ppvObj
= &(This
->IBasicVideo_vtbl
);
243 TRACE(" returning IBasicVideo2 interface (%p)\n", *ppvObj
);
244 } else if (IsEqualGUID(&IID_IVideoWindow
, riid
)) {
245 *ppvObj
= &(This
->IVideoWindow_vtbl
);
246 TRACE(" returning IVideoWindow interface (%p)\n", *ppvObj
);
247 } else if (IsEqualGUID(&IID_IMediaEvent
, riid
) ||
248 IsEqualGUID(&IID_IMediaEventEx
, riid
)) {
249 *ppvObj
= &(This
->IMediaEventEx_vtbl
);
250 TRACE(" returning IMediaEvent(Ex) interface (%p)\n", *ppvObj
);
251 } else if (IsEqualGUID(&IID_IMediaFilter
, riid
) ||
252 IsEqualGUID(&IID_IPersist
, riid
)) {
253 *ppvObj
= &(This
->IMediaFilter_vtbl
);
254 TRACE(" returning IMediaFilter interface (%p)\n", *ppvObj
);
255 } else if (IsEqualGUID(&IID_IMediaEventSink
, riid
)) {
256 *ppvObj
= &(This
->IMediaEventSink_vtbl
);
257 TRACE(" returning IMediaEventSink interface (%p)\n", *ppvObj
);
258 } else if (IsEqualGUID(&IID_IGraphConfig
, riid
)) {
259 *ppvObj
= &(This
->IGraphConfig_vtbl
);
260 TRACE(" returning IGraphConfig interface (%p)\n", *ppvObj
);
261 } else if (IsEqualGUID(&IID_IMediaPosition
, riid
)) {
262 *ppvObj
= &(This
->IMediaPosition_vtbl
);
263 TRACE(" returning IMediaPosition interface (%p)\n", *ppvObj
);
264 } else if (IsEqualGUID(&IID_IFilterMapper
, riid
)) {
265 TRACE(" requesting IFilterMapper interface from aggregated filtermapper (%p)\n", *ppvObj
);
266 return IUnknown_QueryInterface(This
->punkFilterMapper2
, riid
, ppvObj
);
267 } else if (IsEqualGUID(&IID_IFilterMapper2
, riid
)) {
268 *ppvObj
= This
->pFilterMapper2
;
269 TRACE(" returning IFilterMapper2 interface from aggregated filtermapper (%p)\n", *ppvObj
);
272 FIXME("unknown interface %s\n", debugstr_guid(riid
));
273 return E_NOINTERFACE
;
276 IUnknown_AddRef((IUnknown
*)(*ppvObj
));
280 static ULONG WINAPI
FilterGraphInner_AddRef(IUnknown
* iface
) {
281 ICOM_THIS_MULTI(IFilterGraphImpl
, IInner_vtbl
, iface
);
282 ULONG ref
= InterlockedIncrement(&This
->ref
);
284 TRACE("(%p)->(): new ref = %d\n", This
, ref
);
289 static ULONG WINAPI
FilterGraphInner_Release(IUnknown
* iface
)
291 ICOM_THIS_MULTI(IFilterGraphImpl
, IInner_vtbl
, iface
);
292 ULONG ref
= InterlockedDecrement(&This
->ref
);
294 TRACE("(%p)->(): new ref = %d\n", This
, ref
);
299 This
->ref
= 1; /* guard against reentrancy (aggregation). */
301 IMediaControl_Stop((IMediaControl
*)&(This
->IMediaControl_vtbl
));
303 while (This
->nFilters
)
304 IFilterGraph2_RemoveFilter((IFilterGraph2
*)This
, This
->ppFiltersInGraph
[0]);
307 IReferenceClock_Release(This
->refClock
);
309 for (i
= 0; i
< This
->nItfCacheEntries
; i
++)
311 if (This
->ItfCacheEntries
[i
].iface
)
312 IUnknown_Release(This
->ItfCacheEntries
[i
].iface
);
315 /* AddRef on controlling IUnknown, to compensate for Release of cached IFilterMapper2 interface below.
317 * NOTE: Filtergraph_AddRef isn't suitable, because bUnkOuterValid may be FALSE but punkOuter non-NULL
318 * and already passed as punkOuter to filtermapper in FilterGraph_create - this will happen in case of
319 * CoCreateInstance of filtergraph with non-null pUnkOuter and REFIID other than IID_Unknown that is
320 * cleaning up after error. */
321 if (This
->pUnkOuter
) IUnknown_AddRef(This
->pUnkOuter
);
322 else IUnknown_AddRef((IUnknown
*)&This
->IInner_vtbl
);
324 IFilterMapper2_Release(This
->pFilterMapper2
);
325 IUnknown_Release(This
->punkFilterMapper2
);
327 CloseHandle(This
->hEventCompletion
);
328 EventsQueue_Destroy(&This
->evqueue
);
329 This
->cs
.DebugInfo
->Spare
[0] = 0;
330 DeleteCriticalSection(&This
->cs
);
331 CoTaskMemFree(This
->ppFiltersInGraph
);
332 CoTaskMemFree(This
->pFilterNames
);
339 /*** IUnknown methods ***/
340 static HRESULT WINAPI
FilterGraph2_QueryInterface(IFilterGraph2
*iface
,
343 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
345 TRACE("(%p/%p)->(%s (%p), %p)\n", This
, iface
, debugstr_guid(riid
), riid
, ppvObj
);
346 return Filtergraph_QueryInterface(This
, riid
, ppvObj
);
349 static ULONG WINAPI
FilterGraph2_AddRef(IFilterGraph2
*iface
) {
350 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
352 TRACE("(%p/%p)->() calling FilterGraph AddRef\n", This
, iface
);
354 return Filtergraph_AddRef(This
);
357 static ULONG WINAPI
FilterGraph2_Release(IFilterGraph2
*iface
) {
358 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
360 TRACE("(%p/%p)->() calling FilterGraph Release\n", This
, iface
);
362 return Filtergraph_Release(This
);
365 /*** IFilterGraph methods ***/
366 static HRESULT WINAPI
FilterGraph2_AddFilter(IFilterGraph2
*iface
,
367 IBaseFilter
*pFilter
,
369 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
372 WCHAR
* wszFilterName
= NULL
;
373 int duplicate_name
= FALSE
;
375 TRACE("(%p/%p)->(%p, %s (%p))\n", This
, iface
, pFilter
, debugstr_w(pName
), pName
);
380 wszFilterName
= CoTaskMemAlloc( (pName
? strlenW(pName
) + 6 : 5) * sizeof(WCHAR
) );
384 /* Check if name already exists */
385 for(i
= 0; i
< This
->nFilters
; i
++)
386 if (!strcmpW(This
->pFilterNames
[i
], pName
))
388 duplicate_name
= TRUE
;
393 /* If no name given or name already existing, generate one */
394 if (!pName
|| duplicate_name
)
396 static const WCHAR wszFmt1
[] = {'%','s',' ','%','0','4','d',0};
397 static const WCHAR wszFmt2
[] = {'%','0','4','d',0};
399 for (j
= 0; j
< 10000 ; j
++)
403 sprintfW(wszFilterName
, wszFmt1
, pName
, This
->nameIndex
);
405 sprintfW(wszFilterName
, wszFmt2
, This
->nameIndex
);
406 TRACE("Generated name %s\n", debugstr_w(wszFilterName
));
408 /* Check if the generated name already exists */
409 for(i
= 0; i
< This
->nFilters
; i
++)
410 if (!strcmpW(This
->pFilterNames
[i
], wszFilterName
))
413 /* Compute next index and exit if generated name is suitable */
414 if (This
->nameIndex
++ == 10000)
416 if (i
== This
->nFilters
)
419 /* Unable to find a suitable name */
422 CoTaskMemFree(wszFilterName
);
423 return VFW_E_DUPLICATE_NAME
;
427 memcpy(wszFilterName
, pName
, (strlenW(pName
) + 1) * sizeof(WCHAR
));
429 if (This
->nFilters
+ 1 > This
->filterCapacity
)
431 int newCapacity
= This
->filterCapacity
? 2 * This
->filterCapacity
: 1;
432 IBaseFilter
** ppNewFilters
= CoTaskMemAlloc(newCapacity
* sizeof(IBaseFilter
*));
433 LPWSTR
* pNewNames
= CoTaskMemAlloc(newCapacity
* sizeof(LPWSTR
));
434 memcpy(ppNewFilters
, This
->ppFiltersInGraph
, This
->nFilters
* sizeof(IBaseFilter
*));
435 memcpy(pNewNames
, This
->pFilterNames
, This
->nFilters
* sizeof(LPWSTR
));
436 if (This
->filterCapacity
)
438 CoTaskMemFree(This
->ppFiltersInGraph
);
439 CoTaskMemFree(This
->pFilterNames
);
441 This
->ppFiltersInGraph
= ppNewFilters
;
442 This
->pFilterNames
= pNewNames
;
443 This
->filterCapacity
= newCapacity
;
446 hr
= IBaseFilter_JoinFilterGraph(pFilter
, (IFilterGraph
*)This
, wszFilterName
);
450 IBaseFilter_AddRef(pFilter
);
451 This
->ppFiltersInGraph
[This
->nFilters
] = pFilter
;
452 This
->pFilterNames
[This
->nFilters
] = wszFilterName
;
454 IBaseFilter_SetSyncSource(pFilter
, This
->refClock
);
457 CoTaskMemFree(wszFilterName
);
459 if (SUCCEEDED(hr
) && duplicate_name
)
460 return VFW_S_DUPLICATE_NAME
;
465 static HRESULT WINAPI
FilterGraph2_RemoveFilter(IFilterGraph2
*iface
, IBaseFilter
*pFilter
)
467 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
471 TRACE("(%p/%p)->(%p)\n", This
, iface
, pFilter
);
473 /* FIXME: check graph is stopped */
475 for (i
= 0; i
< This
->nFilters
; i
++)
477 if (This
->ppFiltersInGraph
[i
] == pFilter
)
479 IEnumPins
*penumpins
= NULL
;
482 TRACE("Removing filter %s\n", debugstr_w(This
->pFilterNames
[i
]));
483 IBaseFilter_GetState(pFilter
, 0, &state
);
484 if (state
== State_Running
)
485 IBaseFilter_Pause(pFilter
);
486 if (state
!= State_Stopped
)
487 IBaseFilter_Stop(pFilter
);
489 hr
= IBaseFilter_EnumPins(pFilter
, &penumpins
);
492 while(IEnumPins_Next(penumpins
, 1, &ppin
, NULL
) == S_OK
)
496 IPin_ConnectedTo(ppin
, &victim
);
499 h
= IPin_Disconnect(victim
);
500 TRACE("Disconnect other side: %08x\n", h
);
501 if (h
== VFW_E_NOT_STOPPED
)
504 IPin_QueryPinInfo(victim
, &pinfo
);
506 IBaseFilter_GetState(pinfo
.pFilter
, 0, &state
);
507 if (state
== State_Running
)
508 IBaseFilter_Pause(pinfo
.pFilter
);
509 IBaseFilter_Stop(pinfo
.pFilter
);
510 IBaseFilter_Release(pinfo
.pFilter
);
511 h
= IPin_Disconnect(victim
);
512 TRACE("Disconnect retry: %08x\n", h
);
514 IPin_Release(victim
);
516 h
= IPin_Disconnect(ppin
);
517 TRACE("Disconnect 2: %08x\n", h
);
521 IEnumPins_Release(penumpins
);
524 hr
= IBaseFilter_JoinFilterGraph(pFilter
, NULL
, This
->pFilterNames
[i
]);
527 IBaseFilter_SetSyncSource(pFilter
, NULL
);
528 IBaseFilter_Release(pFilter
);
529 CoTaskMemFree(This
->pFilterNames
[i
]);
530 memmove(This
->ppFiltersInGraph
+i
, This
->ppFiltersInGraph
+i
+1, sizeof(IBaseFilter
*)*(This
->nFilters
- 1 - i
));
531 memmove(This
->pFilterNames
+i
, This
->pFilterNames
+i
+1, sizeof(LPWSTR
)*(This
->nFilters
- 1 - i
));
533 /* Invalidate interfaces in the cache */
534 for (i
= 0; i
< This
->nItfCacheEntries
; i
++)
535 if (pFilter
== This
->ItfCacheEntries
[i
].filter
)
537 IUnknown_Release(This
->ItfCacheEntries
[i
].iface
);
538 This
->ItfCacheEntries
[i
].iface
= NULL
;
539 This
->ItfCacheEntries
[i
].filter
= NULL
;
547 return hr
; /* FIXME: check this error code */
550 static HRESULT WINAPI
FilterGraph2_EnumFilters(IFilterGraph2
*iface
,
551 IEnumFilters
**ppEnum
) {
552 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
554 TRACE("(%p/%p)->(%p)\n", This
, iface
, ppEnum
);
556 return IEnumFiltersImpl_Construct(This
->ppFiltersInGraph
, This
->nFilters
, ppEnum
);
559 static HRESULT WINAPI
FilterGraph2_FindFilterByName(IFilterGraph2
*iface
,
561 IBaseFilter
**ppFilter
) {
562 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
565 TRACE("(%p/%p)->(%s (%p), %p)\n", This
, iface
, debugstr_w(pName
), pName
, ppFilter
);
570 for (i
= 0; i
< This
->nFilters
; i
++)
572 if (!strcmpW(pName
, This
->pFilterNames
[i
]))
574 *ppFilter
= This
->ppFiltersInGraph
[i
];
575 IBaseFilter_AddRef(*ppFilter
);
581 return VFW_E_NOT_FOUND
;
584 /* Don't allow a circular connection to form, return VFW_E_CIRCULAR_GRAPH if this would be the case.
585 * A circular connection will be formed if from the filter of the output pin, the input pin can be reached
587 static HRESULT WINAPI
CheckCircularConnection(IFilterGraphImpl
*This
, IPin
*out
, IPin
*in
)
591 PIN_INFO info_out
, info_in
;
593 hr
= IPin_QueryPinInfo(out
, &info_out
);
596 if (info_out
.dir
!= PINDIR_OUTPUT
)
598 IBaseFilter_Release(info_out
.pFilter
);
602 hr
= IPin_QueryPinInfo(in
, &info_in
);
604 IBaseFilter_Release(info_in
.pFilter
);
607 if (info_in
.dir
!= PINDIR_INPUT
)
613 if (info_out
.pFilter
== info_in
.pFilter
)
614 hr
= VFW_E_CIRCULAR_GRAPH
;
620 hr
= IBaseFilter_EnumPins(info_out
.pFilter
, &enumpins
);
624 IEnumPins_Reset(enumpins
);
625 while ((hr
= IEnumPins_Next(enumpins
, 1, &test
, NULL
)) == S_OK
)
627 PIN_DIRECTION dir
= PINDIR_OUTPUT
;
628 IPin_QueryDirection(test
, &dir
);
629 if (dir
== PINDIR_INPUT
)
632 IPin_ConnectedTo(test
, &victim
);
635 hr
= CheckCircularConnection(This
, victim
, in
);
636 IPin_Release(victim
);
646 IEnumPins_Release(enumpins
);
650 IBaseFilter_Release(info_out
.pFilter
);
652 ERR("Checking filtergraph returned %08x, something's not right!\n", hr
);
655 /* Debugging filtergraphs not enabled */
661 /* NOTE: despite the implication, it doesn't matter which
662 * way round you put in the input and output pins */
663 static HRESULT WINAPI
FilterGraph2_ConnectDirect(IFilterGraph2
*iface
,
666 const AM_MEDIA_TYPE
*pmt
) {
670 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
672 TRACE("(%p/%p)->(%p, %p, %p)\n", This
, iface
, ppinIn
, ppinOut
, pmt
);
674 /* FIXME: check pins are in graph */
676 if (TRACE_ON(quartz
))
680 hr
= IPin_QueryPinInfo(ppinIn
, &PinInfo
);
684 TRACE("Filter owning first pin => %p\n", PinInfo
.pFilter
);
685 IBaseFilter_Release(PinInfo
.pFilter
);
687 hr
= IPin_QueryPinInfo(ppinOut
, &PinInfo
);
691 TRACE("Filter owning second pin => %p\n", PinInfo
.pFilter
);
692 IBaseFilter_Release(PinInfo
.pFilter
);
695 hr
= IPin_QueryDirection(ppinIn
, &dir
);
698 if (dir
== PINDIR_INPUT
)
700 hr
= CheckCircularConnection(This
, ppinOut
, ppinIn
);
702 hr
= IPin_Connect(ppinOut
, ppinIn
, pmt
);
706 hr
= CheckCircularConnection(This
, ppinIn
, ppinOut
);
708 hr
= IPin_Connect(ppinIn
, ppinOut
, pmt
);
715 static HRESULT WINAPI
FilterGraph2_Reconnect(IFilterGraph2
*iface
,
717 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
718 IPin
*pConnectedTo
= NULL
;
720 PIN_DIRECTION pindir
;
722 IPin_QueryDirection(ppin
, &pindir
);
723 hr
= IPin_ConnectedTo(ppin
, &pConnectedTo
);
725 TRACE("Querying connected to failed: %x\n", hr
);
728 IPin_Disconnect(ppin
);
729 IPin_Disconnect(pConnectedTo
);
730 if (pindir
== PINDIR_INPUT
)
731 hr
= IPin_Connect(pConnectedTo
, ppin
, NULL
);
733 hr
= IPin_Connect(ppin
, pConnectedTo
, NULL
);
734 IPin_Release(pConnectedTo
);
736 WARN("Reconnecting pins failed, pins are not connected now..\n");
737 TRACE("(%p->%p) -- %p %p -> %x\n", iface
, This
, ppin
, pConnectedTo
, hr
);
741 static HRESULT WINAPI
FilterGraph2_Disconnect(IFilterGraph2
*iface
, IPin
*ppin
)
743 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
745 TRACE("(%p/%p)->(%p)\n", This
, iface
, ppin
);
747 return IPin_Disconnect(ppin
);
750 static HRESULT WINAPI
FilterGraph2_SetDefaultSyncSource(IFilterGraph2
*iface
) {
751 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
752 IReferenceClock
*pClock
= NULL
;
755 TRACE("(%p/%p)->() semi-stub\n", iface
, This
);
757 hr
= CoCreateInstance(&CLSID_SystemClock
, NULL
, CLSCTX_INPROC_SERVER
, &IID_IReferenceClock
, (LPVOID
*)&pClock
);
761 hr
= IMediaFilter_SetSyncSource((IMediaFilter
*)&(This
->IMediaFilter_vtbl
), pClock
);
762 IReferenceClock_Release(pClock
);
768 static HRESULT
GetFilterInfo(IMoniker
* pMoniker
, GUID
* pclsid
, VARIANT
* pvar
)
770 static const WCHAR wszClsidName
[] = {'C','L','S','I','D',0};
771 static const WCHAR wszFriendlyName
[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
772 IPropertyBag
* pPropBagCat
= NULL
;
777 hr
= IMoniker_BindToStorage(pMoniker
, NULL
, NULL
, &IID_IPropertyBag
, (LPVOID
*)&pPropBagCat
);
780 hr
= IPropertyBag_Read(pPropBagCat
, wszClsidName
, pvar
, NULL
);
783 hr
= CLSIDFromString(V_UNION(pvar
, bstrVal
), pclsid
);
788 hr
= IPropertyBag_Read(pPropBagCat
, wszFriendlyName
, pvar
, NULL
);
791 TRACE("Moniker = %s - %s\n", debugstr_guid(pclsid
), debugstr_w(V_UNION(pvar
, bstrVal
)));
794 IPropertyBag_Release(pPropBagCat
);
799 static HRESULT
GetInternalConnections(IBaseFilter
* pfilter
, IPin
* pinputpin
, IPin
*** pppins
, ULONG
* pnb
)
804 TRACE("(%p, %p, %p, %p)\n", pfilter
, pinputpin
, pppins
, pnb
);
805 hr
= IPin_QueryInternalConnections(pinputpin
, NULL
, &nb
);
808 } else if (hr
== S_FALSE
) {
809 *pppins
= CoTaskMemAlloc(sizeof(IPin
*)*nb
);
810 hr
= IPin_QueryInternalConnections(pinputpin
, *pppins
, &nb
);
812 WARN("Error (%x)\n", hr
);
814 } else if (hr
== E_NOTIMPL
) {
815 /* Input connected to all outputs */
816 IEnumPins
* penumpins
;
819 TRACE("E_NOTIMPL\n");
820 hr
= IBaseFilter_EnumPins(pfilter
, &penumpins
);
822 WARN("filter Enumpins failed (%x)\n", hr
);
826 /* Count output pins */
827 while(IEnumPins_Next(penumpins
, 1, &ppin
, &nb
) == S_OK
) {
828 PIN_DIRECTION pindir
;
829 IPin_QueryDirection(ppin
, &pindir
);
830 if (pindir
== PINDIR_OUTPUT
)
834 *pppins
= CoTaskMemAlloc(sizeof(IPin
*)*i
);
835 /* Retrieve output pins */
836 IEnumPins_Reset(penumpins
);
838 while(IEnumPins_Next(penumpins
, 1, &ppin
, &nb
) == S_OK
) {
839 PIN_DIRECTION pindir
;
840 IPin_QueryDirection(ppin
, &pindir
);
841 if (pindir
== PINDIR_OUTPUT
)
842 (*pppins
)[i
++] = ppin
;
846 IEnumPins_Release(penumpins
);
849 WARN("Next failed (%x)\n", hr
);
852 } else if (FAILED(hr
)) {
853 WARN("Cannot get internal connection (%x)\n", hr
);
861 /*** IGraphBuilder methods ***/
862 static HRESULT WINAPI
FilterGraph2_Connect(IFilterGraph2
*iface
, IPin
*ppinOut
, IPin
*ppinIn
)
864 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
867 IEnumMediaTypes
* penummt
;
869 IEnumPins
* penumpins
;
870 IEnumMoniker
* pEnumMoniker
;
879 TRACE("(%p/%p)->(%p, %p)\n", This
, iface
, ppinOut
, ppinIn
);
881 if (TRACE_ON(quartz
))
883 hr
= IPin_QueryPinInfo(ppinIn
, &PinInfo
);
887 TRACE("Filter owning first pin => %p\n", PinInfo
.pFilter
);
888 IBaseFilter_Release(PinInfo
.pFilter
);
890 hr
= IPin_QueryPinInfo(ppinOut
, &PinInfo
);
894 TRACE("Filter owning second pin => %p\n", PinInfo
.pFilter
);
895 IBaseFilter_Release(PinInfo
.pFilter
);
898 hr
= IPin_QueryDirection(ppinOut
, &dir
);
902 if (dir
== PINDIR_INPUT
)
911 hr
= CheckCircularConnection(This
, ppinOut
, ppinIn
);
915 /* Try direct connection first */
916 hr
= IPin_Connect(ppinOut
, ppinIn
, NULL
);
920 TRACE("Direct connection failed, trying to render using extra filters\n");
922 hr
= IPin_QueryPinInfo(ppinIn
, &PinInfo
);
926 hr
= IBaseFilter_GetClassID(PinInfo
.pFilter
, &FilterCLSID
);
927 IBaseFilter_Release(PinInfo
.pFilter
);
931 /* Find the appropriate transform filter than can transform the minor media type of output pin of the upstream
932 * filter to the minor mediatype of input pin of the renderer */
933 hr
= IPin_EnumMediaTypes(ppinOut
, &penummt
);
935 WARN("EnumMediaTypes (%x)\n", hr
);
939 hr
= IEnumMediaTypes_Next(penummt
, 1, &mt
, &nbmt
);
941 WARN("IEnumMediaTypes_Next (%x)\n", hr
);
947 WARN("No media type found!\n");
950 TRACE("MajorType %s\n", debugstr_guid(&mt
->majortype
));
951 TRACE("SubType %s\n", debugstr_guid(&mt
->subtype
));
953 /* Try to find a suitable filter that can connect to the pin to render */
954 tab
[0] = mt
->majortype
;
955 tab
[1] = mt
->subtype
;
956 hr
= IFilterMapper2_EnumMatchingFilters(This
->pFilterMapper2
, &pEnumMoniker
, 0, FALSE
, MERIT_UNLIKELY
, TRUE
, 1, tab
, NULL
, NULL
, FALSE
, FALSE
, 0, NULL
, NULL
, NULL
);
958 WARN("Unable to enum filters (%x)\n", hr
);
962 hr
= VFW_E_CANNOT_RENDER
;
963 while(IEnumMoniker_Next(pEnumMoniker
, 1, &pMoniker
, &nb
) == S_OK
)
968 IPin
* ppinfilter
= NULL
;
969 IBaseFilter
* pfilter
= NULL
;
971 hr
= GetFilterInfo(pMoniker
, &clsid
, &var
);
972 IMoniker_Release(pMoniker
);
974 WARN("Unable to retrieve filter info (%x)\n", hr
);
978 if (IsEqualGUID(&clsid
, &FilterCLSID
)) {
979 /* Skip filter (same as the one the output pin belongs to) */
983 hr
= CoCreateInstance(&clsid
, NULL
, CLSCTX_INPROC_SERVER
, &IID_IBaseFilter
, (LPVOID
*)&pfilter
);
985 WARN("Unable to create filter (%x), trying next one\n", hr
);
989 hr
= IFilterGraph2_AddFilter(iface
, pfilter
, V_UNION(&var
, bstrVal
));
991 WARN("Unable to add filter (%x)\n", hr
);
992 IBaseFilter_Release(pfilter
);
999 hr
= IBaseFilter_EnumPins(pfilter
, &penumpins
);
1001 WARN("Enumpins (%x)\n", hr
);
1005 hr
= IEnumPins_Next(penumpins
, 1, &ppinfilter
, &pin
);
1006 IEnumPins_Release(penumpins
);
1009 WARN("Obtaining next pin: (%x)\n", hr
);
1013 WARN("Cannot use this filter: no pins\n");
1017 hr
= IPin_Connect(ppinOut
, ppinfilter
, NULL
);
1019 TRACE("Cannot connect to filter (%x), trying next one\n", hr
);
1022 TRACE("Successfully connected to filter, follow chain...\n");
1024 /* Render all output pins of the filter by calling IFilterGraph2_Connect on each of them */
1025 hr
= GetInternalConnections(pfilter
, ppinfilter
, &ppins
, &nb
);
1027 if (SUCCEEDED(hr
)) {
1030 IPin_Disconnect(ppinfilter
);
1031 IPin_Disconnect(ppinOut
);
1034 TRACE("pins to consider: %d\n", nb
);
1035 for(i
= 0; i
< nb
; i
++)
1037 LPWSTR pinname
= NULL
;
1039 TRACE("Processing pin %d\n", i
);
1041 hr
= IPin_QueryId(ppins
[i
], &pinname
);
1044 if (pinname
[0] == '~')
1046 TRACE("Pinname=%s, skipping\n", debugstr_w(pinname
));
1050 hr
= IFilterGraph2_Connect(iface
, ppins
[i
], ppinIn
);
1051 CoTaskMemFree(pinname
);
1055 TRACE("Cannot connect pin %p (%x)\n", ppinfilter
, hr
);
1057 IPin_Release(ppins
[i
]);
1058 if (SUCCEEDED(hr
)) break;
1060 while (++i
< nb
) IPin_Release(ppins
[i
]);
1061 CoTaskMemFree(ppins
);
1062 IPin_Release(ppinfilter
);
1063 IBaseFilter_Release(pfilter
);
1066 IPin_Disconnect(ppinfilter
);
1067 IPin_Disconnect(ppinOut
);
1068 IFilterGraph2_RemoveFilter(iface
, pfilter
);
1076 if (ppinfilter
) IPin_Release(ppinfilter
);
1078 IFilterGraph2_RemoveFilter(iface
, pfilter
);
1079 IBaseFilter_Release(pfilter
);
1083 IEnumMediaTypes_Release(penummt
);
1084 DeleteMediaType(mt
);
1086 TRACE("--> %08x\n", hr
);
1087 return SUCCEEDED(hr
) ? S_OK
: hr
;
1090 static HRESULT WINAPI
FilterGraph2_RenderRecurse(IFilterGraphImpl
*This
, IPin
*ppinOut
)
1092 /* This pin has been connected now, try to call render on all pins that aren't connected */
1095 IEnumPins
*enumpins
= NULL
;
1096 BOOL renderany
= FALSE
;
1097 BOOL renderall
= TRUE
;
1099 IPin_QueryPinInfo(ppinOut
, &info
);
1101 IBaseFilter_EnumPins(info
.pFilter
, &enumpins
);
1102 /* Don't need to hold a reference, IEnumPins does */
1103 IBaseFilter_Release(info
.pFilter
);
1105 IEnumPins_Reset(enumpins
);
1106 while (IEnumPins_Next(enumpins
, 1, &to
, NULL
) == S_OK
)
1108 PIN_DIRECTION dir
= PINDIR_INPUT
;
1110 IPin_QueryDirection(to
, &dir
);
1112 if (dir
== PINDIR_OUTPUT
)
1116 IPin_ConnectedTo(to
, &out
);
1120 hr
= IFilterGraph2_Render((IFilterGraph2
*)&This
->IFilterGraph2_vtbl
, to
);
1133 IEnumPins_Release(enumpins
);
1139 return VFW_S_PARTIAL_RENDER
;
1141 return VFW_E_CANNOT_RENDER
;
1144 /* Ogg hates me if I create a direct rendering method
1146 * It can only connect to a pin properly once, so use a recursive method that does
1148 * +----+ --- (PIN 1) (Render is called on this pin)
1150 * +----+ --- (PIN 2)
1152 * Enumerate possible renderers that EXACTLY match the requested type
1154 * If none is available, try to add intermediate filters that can connect to the input pin
1155 * then call Render on that intermediate pin's output pins
1156 * if it succeeds: Render returns success, if it doesn't, the intermediate filter is removed,
1157 * and another filter that can connect to the input pin is tried
1158 * if we run out of filters that can, give up and return VFW_E_CANNOT_RENDER
1159 * It's recursive, but fun!
1162 static HRESULT WINAPI
FilterGraph2_Render(IFilterGraph2
*iface
, IPin
*ppinOut
)
1164 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
1165 IEnumMediaTypes
* penummt
;
1170 IEnumMoniker
* pEnumMoniker
;
1176 TRACE("(%p/%p)->(%p)\n", This
, iface
, ppinOut
);
1178 if (TRACE_ON(quartz
))
1182 hr
= IPin_QueryPinInfo(ppinOut
, &PinInfo
);
1186 TRACE("Filter owning pin => %p\n", PinInfo
.pFilter
);
1187 IBaseFilter_Release(PinInfo
.pFilter
);
1190 /* Try to find out if there is a renderer for the specified subtype already, and use that
1192 EnterCriticalSection(&This
->cs
);
1193 for (x
= 0; x
< This
->nFilters
; ++x
)
1195 IEnumPins
*enumpins
= NULL
;
1198 hr
= IBaseFilter_EnumPins(This
->ppFiltersInGraph
[x
], &enumpins
);
1200 if (FAILED(hr
) || !enumpins
)
1203 IEnumPins_Reset(enumpins
);
1204 while (IEnumPins_Next(enumpins
, 1, &pin
, NULL
) == S_OK
)
1207 PIN_DIRECTION dir
= PINDIR_OUTPUT
;
1209 IPin_QueryDirection(pin
, &dir
);
1210 if (dir
!= PINDIR_INPUT
)
1215 IPin_ConnectedTo(pin
, &to
);
1219 hr
= IPin_Connect(ppinOut
, pin
, NULL
);
1222 TRACE("Connected successfully %p/%p, %08x look if we should render more!\n", ppinOut
, pin
, hr
);
1225 hr
= FilterGraph2_RenderRecurse(This
, pin
);
1228 IPin_Disconnect(ppinOut
);
1229 IPin_Disconnect(pin
);
1232 IEnumPins_Release(enumpins
);
1233 LeaveCriticalSection(&This
->cs
);
1236 WARN("Could not connect!\n");
1243 IEnumPins_Release(enumpins
);
1246 LeaveCriticalSection(&This
->cs
);
1248 hr
= IPin_EnumMediaTypes(ppinOut
, &penummt
);
1250 WARN("EnumMediaTypes (%x)\n", hr
);
1254 IEnumMediaTypes_Reset(penummt
);
1256 /* Looks like no existing renderer of the kind exists
1257 * Try adding new ones
1259 tab
[0] = tab
[1] = GUID_NULL
;
1260 while (SUCCEEDED(hr
))
1262 hr
= IEnumMediaTypes_Next(penummt
, 1, &mt
, &nbmt
);
1264 WARN("IEnumMediaTypes_Next (%x)\n", hr
);
1269 hr
= VFW_E_CANNOT_RENDER
;
1274 TRACE("MajorType %s\n", debugstr_guid(&mt
->majortype
));
1275 TRACE("SubType %s\n", debugstr_guid(&mt
->subtype
));
1277 /* Only enumerate once, this doesn't account for all previous ones, but this should be enough nonetheless */
1278 if (IsEqualIID(&tab
[0], &mt
->majortype
) && IsEqualIID(&tab
[1], &mt
->subtype
))
1280 DeleteMediaType(mt
);
1284 /* Try to find a suitable renderer with the same media type */
1285 tab
[0] = mt
->majortype
;
1286 tab
[1] = mt
->subtype
;
1287 hr
= IFilterMapper2_EnumMatchingFilters(This
->pFilterMapper2
, &pEnumMoniker
, 0, FALSE
, MERIT_UNLIKELY
, TRUE
, 1, tab
, NULL
, NULL
, FALSE
, FALSE
, 0, NULL
, NULL
, NULL
);
1290 WARN("Unable to enum filters (%x)\n", hr
);
1296 while (IEnumMoniker_Next(pEnumMoniker
, 1, &pMoniker
, &nb
) == S_OK
)
1301 IBaseFilter
* pfilter
= NULL
;
1302 IEnumPins
* penumpins
;
1305 hr
= GetFilterInfo(pMoniker
, &clsid
, &var
);
1306 IMoniker_Release(pMoniker
);
1308 WARN("Unable to retrieve filter info (%x)\n", hr
);
1312 hr
= CoCreateInstance(&clsid
, NULL
, CLSCTX_INPROC_SERVER
, &IID_IBaseFilter
, (LPVOID
*)&pfilter
);
1315 WARN("Unable to create filter (%x), trying next one\n", hr
);
1319 hr
= IFilterGraph2_AddFilter(iface
, pfilter
, V_UNION(&var
, bstrVal
));
1321 WARN("Unable to add filter (%x)\n", hr
);
1322 IBaseFilter_Release(pfilter
);
1327 hr
= IBaseFilter_EnumPins(pfilter
, &penumpins
);
1329 WARN("Splitter Enumpins (%x)\n", hr
);
1332 hr
= IEnumPins_Next(penumpins
, 1, &ppinfilter
, &pin
);
1333 IEnumPins_Release(penumpins
);
1335 WARN("Next (%x)\n", hr
);
1344 /* Connect the pin to the "Renderer" */
1345 hr
= IPin_Connect(ppinOut
, ppinfilter
, NULL
);
1346 IPin_Release(ppinfilter
);
1349 WARN("Unable to connect %s to renderer (%x)\n", debugstr_w(V_UNION(&var
, bstrVal
)), hr
);
1352 TRACE("Connected, recursing %s\n", debugstr_w(V_UNION(&var
, bstrVal
)));
1356 hr
= FilterGraph2_RenderRecurse(This
, ppinfilter
);
1358 WARN("Unable to connect recursively (%x)\n", hr
);
1361 IBaseFilter_Release(pfilter
);
1367 IFilterGraph2_RemoveFilter(iface
, pfilter
);
1368 IBaseFilter_Release(pfilter
);
1370 if (!FAILED(hr
)) DebugBreak();
1373 IEnumMoniker_Release(pEnumMoniker
);
1375 DeleteMediaType(mt
);
1381 IEnumMediaTypes_Release(penummt
);
1385 static HRESULT WINAPI
FilterGraph2_RenderFile(IFilterGraph2
*iface
,
1386 LPCWSTR lpcwstrFile
,
1387 LPCWSTR lpcwstrPlayList
)
1389 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
1390 static const WCHAR string
[] = {'R','e','a','d','e','r',0};
1391 IBaseFilter
* preader
= NULL
;
1392 IPin
* ppinreader
= NULL
;
1393 IEnumPins
* penumpins
= NULL
;
1395 BOOL partial
= FALSE
;
1396 HRESULT any
= FALSE
;
1398 TRACE("(%p/%p)->(%s, %s)\n", This
, iface
, debugstr_w(lpcwstrFile
), debugstr_w(lpcwstrPlayList
));
1400 if (lpcwstrPlayList
!= NULL
)
1401 return E_INVALIDARG
;
1403 hr
= IFilterGraph2_AddSourceFilter(iface
, lpcwstrFile
, string
, &preader
);
1408 hr
= IBaseFilter_EnumPins(preader
, &penumpins
);
1411 while (IEnumPins_Next(penumpins
, 1, &ppinreader
, NULL
) == S_OK
)
1415 IPin_QueryDirection(ppinreader
, &dir
);
1416 if (dir
== PINDIR_OUTPUT
)
1420 hr
= IFilterGraph2_Render(iface
, ppinreader
);
1421 TRACE("Render %08x\n", hr
);
1423 for (i
= 0; i
< This
->nFilters
; ++i
)
1424 TRACE("Filters in chain: %s\n", debugstr_w(This
->pFilterNames
[i
]));
1431 IPin_Release(ppinreader
);
1433 IEnumPins_Release(penumpins
);
1436 hr
= VFW_E_CANNOT_RENDER
;
1438 hr
= VFW_S_PARTIAL_RENDER
;
1442 IBaseFilter_Release(preader
);
1444 TRACE("--> %08x\n", hr
);
1448 /* Some filters implement their own asynchronous reader (Theoretically they all should, try to load it first */
1449 static HRESULT
GetFileSourceFilter(LPCOLESTR pszFileName
, IBaseFilter
**filter
)
1451 static const WCHAR wszReg
[] = {'M','e','d','i','a',' ','T','y','p','e','\\','E','x','t','e','n','s','i','o','n','s',0};
1456 lRet
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, wszReg
, 0, KEY_READ
, &extkey
);
1457 hr
= HRESULT_FROM_WIN32(lRet
);
1461 static const WCHAR filtersource
[] = {'S','o','u','r','c','e',' ','F','i','l','t','e','r',0};
1462 WCHAR
*ext
= PathFindExtensionW(pszFileName
);
1463 WCHAR clsid_key
[39];
1465 DWORD size
= sizeof(clsid_key
);
1470 CloseHandle(extkey
);
1474 lRet
= RegOpenKeyExW(extkey
, ext
, 0, KEY_READ
, &pathkey
);
1475 hr
= HRESULT_FROM_WIN32(lRet
);
1476 CloseHandle(extkey
);
1480 lRet
= RegQueryValueExW(pathkey
, filtersource
, NULL
, NULL
, (LPBYTE
)clsid_key
, &size
);
1481 hr
= HRESULT_FROM_WIN32(lRet
);
1482 CloseHandle(pathkey
);
1486 CLSIDFromString(clsid_key
, &clsid
);
1488 TRACE("CLSID: %s\n", debugstr_guid(&clsid
));
1489 hr
= CoCreateInstance(&clsid
, NULL
, CLSCTX_INPROC_SERVER
, &IID_IBaseFilter
, (LPVOID
*)filter
);
1492 IFileSourceFilter
*source
= NULL
;
1493 hr
= IBaseFilter_QueryInterface(*filter
, &IID_IFileSourceFilter
, (LPVOID
*)&source
);
1495 IFileSourceFilter_Release(source
);
1497 IBaseFilter_Release(*filter
);
1505 static HRESULT WINAPI
FilterGraph2_AddSourceFilter(IFilterGraph2
*iface
,
1506 LPCWSTR lpcwstrFileName
,
1507 LPCWSTR lpcwstrFilterName
,
1508 IBaseFilter
**ppFilter
) {
1509 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
1511 IBaseFilter
* preader
;
1512 IFileSourceFilter
* pfile
= NULL
;
1516 TRACE("(%p/%p)->(%s, %s, %p)\n", This
, iface
, debugstr_w(lpcwstrFileName
), debugstr_w(lpcwstrFilterName
), ppFilter
);
1518 /* Try from file name first, then fall back to default asynchronous reader */
1519 hr
= GetFileSourceFilter(lpcwstrFileName
, &preader
);
1522 hr
= CoCreateInstance(&CLSID_AsyncReader
, NULL
, CLSCTX_INPROC_SERVER
, &IID_IBaseFilter
, (LPVOID
*)&preader
);
1524 WARN("Unable to create file source filter (%x)\n", hr
);
1528 hr
= IFilterGraph2_AddFilter(iface
, preader
, lpcwstrFilterName
);
1530 WARN("Unable add filter (%x)\n", hr
);
1531 IBaseFilter_Release(preader
);
1535 hr
= IBaseFilter_QueryInterface(preader
, &IID_IFileSourceFilter
, (LPVOID
*)&pfile
);
1537 WARN("Unable to get IFileSourceInterface (%x)\n", hr
);
1541 /* Load the file in the file source filter */
1542 hr
= IFileSourceFilter_Load(pfile
, lpcwstrFileName
, NULL
);
1544 WARN("Load (%x)\n", hr
);
1548 IFileSourceFilter_GetCurFile(pfile
, &filename
, &mt
);
1550 WARN("GetCurFile (%x)\n", hr
);
1554 TRACE("File %s\n", debugstr_w(filename
));
1555 TRACE("MajorType %s\n", debugstr_guid(&mt
.majortype
));
1556 TRACE("SubType %s\n", debugstr_guid(&mt
.subtype
));
1559 *ppFilter
= preader
;
1560 IFileSourceFilter_Release(pfile
);
1566 IFileSourceFilter_Release(pfile
);
1567 IFilterGraph2_RemoveFilter(iface
, preader
);
1568 IBaseFilter_Release(preader
);
1573 static HRESULT WINAPI
FilterGraph2_SetLogFile(IFilterGraph2
*iface
,
1575 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
1577 TRACE("(%p/%p)->(%08x): stub !!!\n", This
, iface
, (DWORD
) hFile
);
1582 static HRESULT WINAPI
FilterGraph2_Abort(IFilterGraph2
*iface
) {
1583 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
1585 TRACE("(%p/%p)->(): stub !!!\n", This
, iface
);
1590 static HRESULT WINAPI
FilterGraph2_ShouldOperationContinue(IFilterGraph2
*iface
) {
1591 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
1593 TRACE("(%p/%p)->(): stub !!!\n", This
, iface
);
1598 /*** IFilterGraph2 methods ***/
1599 static HRESULT WINAPI
FilterGraph2_AddSourceFilterForMoniker(IFilterGraph2
*iface
,
1602 LPCWSTR lpcwstrFilterName
,
1603 IBaseFilter
**ppFilter
) {
1604 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
1606 TRACE("(%p/%p)->(%p %p %s %p): stub !!!\n", This
, iface
, pMoniker
, pCtx
, debugstr_w(lpcwstrFilterName
), ppFilter
);
1611 static HRESULT WINAPI
FilterGraph2_ReconnectEx(IFilterGraph2
*iface
,
1613 const AM_MEDIA_TYPE
*pmt
) {
1614 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
1616 TRACE("(%p/%p)->(%p %p): stub !!!\n", This
, iface
, ppin
, pmt
);
1621 static HRESULT WINAPI
FilterGraph2_RenderEx(IFilterGraph2
*iface
,
1625 ICOM_THIS_MULTI(IFilterGraphImpl
, IFilterGraph2_vtbl
, iface
);
1627 TRACE("(%p/%p)->(%p %08x %p): stub !!!\n", This
, iface
, pPinOut
, dwFlags
, pvContext
);
1633 static const IFilterGraph2Vtbl IFilterGraph2_VTable
=
1635 FilterGraph2_QueryInterface
,
1636 FilterGraph2_AddRef
,
1637 FilterGraph2_Release
,
1638 FilterGraph2_AddFilter
,
1639 FilterGraph2_RemoveFilter
,
1640 FilterGraph2_EnumFilters
,
1641 FilterGraph2_FindFilterByName
,
1642 FilterGraph2_ConnectDirect
,
1643 FilterGraph2_Reconnect
,
1644 FilterGraph2_Disconnect
,
1645 FilterGraph2_SetDefaultSyncSource
,
1646 FilterGraph2_Connect
,
1647 FilterGraph2_Render
,
1648 FilterGraph2_RenderFile
,
1649 FilterGraph2_AddSourceFilter
,
1650 FilterGraph2_SetLogFile
,
1652 FilterGraph2_ShouldOperationContinue
,
1653 FilterGraph2_AddSourceFilterForMoniker
,
1654 FilterGraph2_ReconnectEx
,
1655 FilterGraph2_RenderEx
1658 /*** IUnknown methods ***/
1659 static HRESULT WINAPI
MediaControl_QueryInterface(IMediaControl
*iface
,
1662 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
1664 TRACE("(%p/%p)->(%s (%p), %p)\n", This
, iface
, debugstr_guid(riid
), riid
, ppvObj
);
1666 return Filtergraph_QueryInterface(This
, riid
, ppvObj
);
1669 static ULONG WINAPI
MediaControl_AddRef(IMediaControl
*iface
) {
1670 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
1672 TRACE("(%p/%p)->()\n", This
, iface
);
1674 return Filtergraph_AddRef(This
);
1677 static ULONG WINAPI
MediaControl_Release(IMediaControl
*iface
) {
1678 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
1680 TRACE("(%p/%p)->()\n", This
, iface
);
1682 return Filtergraph_Release(This
);
1686 /*** IDispatch methods ***/
1687 static HRESULT WINAPI
MediaControl_GetTypeInfoCount(IMediaControl
*iface
,
1689 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
1691 TRACE("(%p/%p)->(%p): stub !!!\n", This
, iface
, pctinfo
);
1696 static HRESULT WINAPI
MediaControl_GetTypeInfo(IMediaControl
*iface
,
1699 ITypeInfo
**ppTInfo
) {
1700 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
1702 TRACE("(%p/%p)->(%d, %d, %p): stub !!!\n", This
, iface
, iTInfo
, lcid
, ppTInfo
);
1707 static HRESULT WINAPI
MediaControl_GetIDsOfNames(IMediaControl
*iface
,
1713 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
1715 TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This
, iface
, debugstr_guid(riid
), riid
, rgszNames
, cNames
, lcid
, rgDispId
);
1720 static HRESULT WINAPI
MediaControl_Invoke(IMediaControl
*iface
,
1721 DISPID dispIdMember
,
1725 DISPPARAMS
*pDispParams
,
1727 EXCEPINFO
*pExepInfo
,
1729 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
1731 TRACE("(%p/%p)->(%d, %s (%p), %d, %04x, %p, %p, %p, %p): stub !!!\n", This
, iface
, dispIdMember
, debugstr_guid(riid
), riid
, lcid
, wFlags
, pDispParams
, pVarResult
, pExepInfo
, puArgErr
);
1736 typedef HRESULT(WINAPI
*fnFoundFilter
)(IBaseFilter
*, DWORD_PTR data
);
1738 static HRESULT
ExploreGraph(IFilterGraphImpl
* pGraph
, IPin
* pOutputPin
, fnFoundFilter FoundFilter
, DWORD_PTR data
)
1747 TRACE("%p %p\n", pGraph
, pOutputPin
);
1748 PinInfo
.pFilter
= NULL
;
1750 hr
= IPin_ConnectedTo(pOutputPin
, &pInputPin
);
1754 hr
= IPin_QueryPinInfo(pInputPin
, &PinInfo
);
1756 hr
= GetInternalConnections(PinInfo
.pFilter
, pInputPin
, &ppPins
, &nb
);
1757 IPin_Release(pInputPin
);
1764 TRACE("Reached a renderer\n");
1765 /* Count renderers for end of stream notification */
1766 pGraph
->nRenderers
++;
1770 for(i
= 0; i
< nb
; i
++)
1772 /* Explore the graph downstream from this pin
1773 * FIXME: We should prevent exploring from a pin more than once. This can happens when
1774 * several input pins are connected to the same output (a MUX for instance). */
1775 ExploreGraph(pGraph
, ppPins
[i
], FoundFilter
, data
);
1776 IPin_Release(ppPins
[i
]);
1779 CoTaskMemFree(ppPins
);
1781 TRACE("Doing stuff with filter %p\n", PinInfo
.pFilter
);
1783 FoundFilter(PinInfo
.pFilter
, data
);
1786 if (PinInfo
.pFilter
) IBaseFilter_Release(PinInfo
.pFilter
);
1790 static HRESULT WINAPI
SendRun(IBaseFilter
*pFilter
, DWORD_PTR data
)
1793 IReferenceClock
*clock
= NULL
;
1795 IBaseFilter_GetSyncSource(pFilter
, &clock
);
1798 IReferenceClock_GetTime(clock
, &time
);
1804 IReferenceClock_Release(clock
);
1807 return IBaseFilter_Run(pFilter
, time
);
1810 static HRESULT WINAPI
SendPause(IBaseFilter
*pFilter
, DWORD_PTR data
)
1812 return IBaseFilter_Pause(pFilter
);
1815 static HRESULT WINAPI
SendStop(IBaseFilter
*pFilter
, DWORD_PTR data
)
1817 return IBaseFilter_Stop(pFilter
);
1820 static HRESULT WINAPI
SendGetState(IBaseFilter
*pFilter
, DWORD_PTR data
)
1823 DWORD time_end
= data
;
1824 DWORD time_now
= GetTickCount();
1827 if (time_end
== INFINITE
)
1831 else if (time_end
> time_now
)
1833 wait
= time_end
- time_now
;
1838 return IBaseFilter_GetState(pFilter
, wait
, &state
);
1842 static HRESULT
SendFilterMessage(IMediaControl
*iface
, fnFoundFilter FoundFilter
, DWORD_PTR data
)
1844 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
1846 IBaseFilter
* pfilter
;
1852 TRACE("(%p/%p)->()\n", This
, iface
);
1854 /* Explorer the graph from source filters to renderers, determine renderers
1855 * number and run filters from renderers to source filters */
1856 This
->nRenderers
= 0;
1857 ResetEvent(This
->hEventCompletion
);
1859 for(i
= 0; i
< This
->nFilters
; i
++)
1862 pfilter
= This
->ppFiltersInGraph
[i
];
1863 hr
= IBaseFilter_EnumPins(pfilter
, &pEnum
);
1866 WARN("Enum pins failed %x\n", hr
);
1869 /* Check if it is a source filter */
1870 while(IEnumPins_Next(pEnum
, 1, &pPin
, &dummy
) == S_OK
)
1872 IPin_QueryDirection(pPin
, &dir
);
1874 if (dir
== PINDIR_INPUT
)
1882 TRACE("Found a source filter %p\n", pfilter
);
1883 IEnumPins_Reset(pEnum
);
1884 while(IEnumPins_Next(pEnum
, 1, &pPin
, &dummy
) == S_OK
)
1886 /* Explore the graph downstream from this pin */
1887 ExploreGraph(This
, pPin
, FoundFilter
, data
);
1890 FoundFilter(pfilter
, data
);
1892 IEnumPins_Release(pEnum
);
1898 /*** IMediaControl methods ***/
1899 static HRESULT WINAPI
MediaControl_Run(IMediaControl
*iface
) {
1900 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
1901 TRACE("(%p/%p)->()\n", This
, iface
);
1903 if (This
->state
== State_Running
) return S_OK
;
1905 EnterCriticalSection(&This
->cs
);
1906 if (This
->state
== State_Stopped
)
1907 This
->EcCompleteCount
= 0;
1911 IReferenceClock_GetTime(This
->refClock
, &This
->start_time
);
1912 This
->start_time
+= 500000;
1914 else This
->position
= This
->start_time
= 0;
1916 SendFilterMessage(iface
, SendRun
, 0);
1917 This
->state
= State_Running
;
1918 LeaveCriticalSection(&This
->cs
);
1922 static HRESULT WINAPI
MediaControl_Pause(IMediaControl
*iface
) {
1923 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
1924 TRACE("(%p/%p)->()\n", This
, iface
);
1926 if (This
->state
== State_Paused
) return S_OK
;
1928 EnterCriticalSection(&This
->cs
);
1929 if (This
->state
== State_Stopped
)
1930 This
->EcCompleteCount
= 0;
1932 if (This
->state
== State_Running
&& This
->refClock
)
1934 LONGLONG time
= This
->start_time
;
1935 IReferenceClock_GetTime(This
->refClock
, &time
);
1936 This
->position
+= time
- This
->start_time
;
1939 SendFilterMessage(iface
, SendPause
, 0);
1940 This
->state
= State_Paused
;
1941 LeaveCriticalSection(&This
->cs
);
1945 static HRESULT WINAPI
MediaControl_Stop(IMediaControl
*iface
) {
1946 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
1947 TRACE("(%p/%p)->()\n", This
, iface
);
1949 if (This
->state
== State_Stopped
) return S_OK
;
1951 EnterCriticalSection(&This
->cs
);
1952 if (This
->state
== State_Running
&& This
->refClock
)
1954 LONGLONG time
= This
->start_time
;
1955 IReferenceClock_GetTime(This
->refClock
, &time
);
1956 This
->position
+= time
- This
->start_time
;
1959 if (This
->state
== State_Running
) SendFilterMessage(iface
, SendPause
, 0);
1960 SendFilterMessage(iface
, SendStop
, 0);
1961 This
->state
= State_Stopped
;
1962 LeaveCriticalSection(&This
->cs
);
1966 static HRESULT WINAPI
MediaControl_GetState(IMediaControl
*iface
,
1968 OAFilterState
*pfs
) {
1969 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
1972 TRACE("(%p/%p)->(%d, %p)\n", This
, iface
, msTimeout
, pfs
);
1977 EnterCriticalSection(&This
->cs
);
1982 end
= GetTickCount() + msTimeout
;
1984 else if (msTimeout
< 0)
1993 SendFilterMessage(iface
, SendGetState
, end
);
1995 LeaveCriticalSection(&This
->cs
);
2000 static HRESULT WINAPI
MediaControl_RenderFile(IMediaControl
*iface
,
2002 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
2004 FIXME("(%p/%p)->(%s (%p)): stub !!!\n", This
, iface
, debugstr_w(strFilename
), strFilename
);
2009 static HRESULT WINAPI
MediaControl_AddSourceFilter(IMediaControl
*iface
,
2011 IDispatch
**ppUnk
) {
2012 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
2014 FIXME("(%p/%p)->(%s (%p), %p): stub !!!\n", This
, iface
, debugstr_w(strFilename
), strFilename
, ppUnk
);
2019 static HRESULT WINAPI
MediaControl_get_FilterCollection(IMediaControl
*iface
,
2020 IDispatch
**ppUnk
) {
2021 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
2023 FIXME("(%p/%p)->(%p): stub !!!\n", This
, iface
, ppUnk
);
2028 static HRESULT WINAPI
MediaControl_get_RegFilterCollection(IMediaControl
*iface
,
2029 IDispatch
**ppUnk
) {
2030 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
2032 FIXME("(%p/%p)->(%p): stub !!!\n", This
, iface
, ppUnk
);
2037 static HRESULT WINAPI
MediaControl_StopWhenReady(IMediaControl
*iface
) {
2038 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaControl_vtbl
, iface
);
2040 FIXME("(%p/%p)->(): stub !!!\n", This
, iface
);
2046 static const IMediaControlVtbl IMediaControl_VTable
=
2048 MediaControl_QueryInterface
,
2049 MediaControl_AddRef
,
2050 MediaControl_Release
,
2051 MediaControl_GetTypeInfoCount
,
2052 MediaControl_GetTypeInfo
,
2053 MediaControl_GetIDsOfNames
,
2054 MediaControl_Invoke
,
2058 MediaControl_GetState
,
2059 MediaControl_RenderFile
,
2060 MediaControl_AddSourceFilter
,
2061 MediaControl_get_FilterCollection
,
2062 MediaControl_get_RegFilterCollection
,
2063 MediaControl_StopWhenReady
2067 /*** IUnknown methods ***/
2068 static HRESULT WINAPI
MediaSeeking_QueryInterface(IMediaSeeking
*iface
,
2071 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2073 TRACE("(%p/%p)->(%s (%p), %p)\n", This
, iface
, debugstr_guid(riid
), riid
, ppvObj
);
2075 return Filtergraph_QueryInterface(This
, riid
, ppvObj
);
2078 static ULONG WINAPI
MediaSeeking_AddRef(IMediaSeeking
*iface
) {
2079 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2081 TRACE("(%p/%p)->()\n", This
, iface
);
2083 return Filtergraph_AddRef(This
);
2086 static ULONG WINAPI
MediaSeeking_Release(IMediaSeeking
*iface
) {
2087 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2089 TRACE("(%p/%p)->()\n", This
, iface
);
2091 return Filtergraph_Release(This
);
2094 typedef HRESULT
WINAPI (*fnFoundSeek
)(IFilterGraphImpl
*This
, IMediaSeeking
*, DWORD_PTR arg
);
2096 static HRESULT
all_renderers_seek(IFilterGraphImpl
*This
, fnFoundSeek FoundSeek
, DWORD_PTR arg
) {
2097 BOOL allnotimpl
= TRUE
;
2099 IBaseFilter
* pfilter
;
2101 HRESULT hr
, hr_return
= S_OK
;
2106 TRACE("(%p)->(%p %08lx)\n", This
, FoundSeek
, arg
);
2107 /* Send a message to all renderers, they are responsible for broadcasting it further */
2109 for(i
= 0; i
< This
->nFilters
; i
++)
2111 BOOL renderer
= TRUE
;
2112 pfilter
= This
->ppFiltersInGraph
[i
];
2113 hr
= IBaseFilter_EnumPins(pfilter
, &pEnum
);
2116 WARN("Enum pins failed %x\n", hr
);
2119 /* Check if it is a source filter */
2120 while(IEnumPins_Next(pEnum
, 1, &pPin
, &dummy
) == S_OK
)
2122 IPin_QueryDirection(pPin
, &dir
);
2124 if (dir
!= PINDIR_INPUT
)
2130 IEnumPins_Release(pEnum
);
2133 IMediaSeeking
*seek
= NULL
;
2134 IBaseFilter_QueryInterface(pfilter
, &IID_IMediaSeeking
, (void**)&seek
);
2138 hr
= FoundSeek(This
, seek
, arg
);
2140 IMediaSeeking_Release(seek
);
2141 if (hr_return
!= E_NOTIMPL
)
2143 if (hr_return
== S_OK
|| (FAILED(hr
) && hr
!= E_NOTIMPL
&& !FAILED(hr_return
)))
2153 static HRESULT WINAPI
FoundCapabilities(IFilterGraphImpl
*This
, IMediaSeeking
*seek
, DWORD_PTR pcaps
)
2158 hr
= IMediaSeeking_GetCapabilities(seek
, &caps
);
2162 /* Only add common capabilities everything supports */
2163 *(DWORD
*)pcaps
&= caps
;
2168 /*** IMediaSeeking methods ***/
2169 static HRESULT WINAPI
MediaSeeking_GetCapabilities(IMediaSeeking
*iface
,
2170 DWORD
*pCapabilities
) {
2171 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2173 TRACE("(%p/%p)->(%p)\n", This
, iface
, pCapabilities
);
2178 EnterCriticalSection(&This
->cs
);
2179 *pCapabilities
= 0xffffffff;
2181 hr
= all_renderers_seek(This
, FoundCapabilities
, (DWORD_PTR
)pCapabilities
);
2182 LeaveCriticalSection(&This
->cs
);
2187 static HRESULT WINAPI
MediaSeeking_CheckCapabilities(IMediaSeeking
*iface
,
2188 DWORD
*pCapabilities
) {
2189 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2192 TRACE("(%p/%p)->(%p)\n", This
, iface
, pCapabilities
);
2197 EnterCriticalSection(&This
->cs
);
2198 originalcaps
= *pCapabilities
;
2199 hr
= all_renderers_seek(This
, FoundCapabilities
, (DWORD_PTR
)pCapabilities
);
2200 LeaveCriticalSection(&This
->cs
);
2205 if (!*pCapabilities
)
2207 if (*pCapabilities
!= originalcaps
)
2212 static HRESULT WINAPI
MediaSeeking_IsFormatSupported(IMediaSeeking
*iface
,
2213 const GUID
*pFormat
) {
2214 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2219 TRACE("(%p/%p)->(%s)\n", This
, iface
, debugstr_guid(pFormat
));
2221 if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME
, pFormat
))
2223 FIXME("Unhandled time format %s\n", debugstr_guid(pFormat
));
2230 static HRESULT WINAPI
MediaSeeking_QueryPreferredFormat(IMediaSeeking
*iface
,
2232 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2237 FIXME("(%p/%p)->(%p): semi-stub !!!\n", This
, iface
, pFormat
);
2238 memcpy(pFormat
, &TIME_FORMAT_MEDIA_TIME
, sizeof(GUID
));
2243 static HRESULT WINAPI
MediaSeeking_GetTimeFormat(IMediaSeeking
*iface
,
2245 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2250 TRACE("(%p/%p)->(%p)\n", This
, iface
, pFormat
);
2251 memcpy(pFormat
, &This
->timeformatseek
, sizeof(GUID
));
2256 static HRESULT WINAPI
MediaSeeking_IsUsingTimeFormat(IMediaSeeking
*iface
,
2257 const GUID
*pFormat
) {
2258 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2260 TRACE("(%p/%p)->(%p)\n", This
, iface
, pFormat
);
2264 if (memcmp(pFormat
, &This
->timeformatseek
, sizeof(GUID
)))
2270 static HRESULT WINAPI
MediaSeeking_SetTimeFormat(IMediaSeeking
*iface
,
2271 const GUID
*pFormat
) {
2272 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2277 TRACE("(%p/%p)->(%s)\n", This
, iface
, debugstr_guid(pFormat
));
2279 if (This
->state
!= State_Stopped
)
2280 return VFW_E_WRONG_STATE
;
2282 if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME
, pFormat
))
2284 FIXME("Unhandled time format %s\n", debugstr_guid(pFormat
));
2285 return E_INVALIDARG
;
2291 static HRESULT WINAPI
FoundDuration(IFilterGraphImpl
*This
, IMediaSeeking
*seek
, DWORD_PTR pduration
)
2294 LONGLONG duration
= 0, *pdur
= (LONGLONG
*)pduration
;
2296 hr
= IMediaSeeking_GetDuration(seek
, &duration
);
2300 /* FIXME: Minimum or maximum duration? Assuming minimum */
2301 if (duration
> 0 && *pdur
< duration
)
2307 static HRESULT WINAPI
MediaSeeking_GetDuration(IMediaSeeking
*iface
,
2308 LONGLONG
*pDuration
) {
2309 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2312 TRACE("(%p/%p)->(%p)\n", This
, iface
, pDuration
);
2317 EnterCriticalSection(&This
->cs
);
2319 hr
= all_renderers_seek(This
, FoundDuration
, (DWORD_PTR
)pDuration
);
2320 LeaveCriticalSection(&This
->cs
);
2322 TRACE("--->%08x\n", hr
);
2326 static HRESULT WINAPI
MediaSeeking_GetStopPosition(IMediaSeeking
*iface
,
2328 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2331 TRACE("(%p/%p)->(%p)\n", This
, iface
, pStop
);
2336 EnterCriticalSection(&This
->cs
);
2337 if (This
->stop_position
< 0)
2338 /* Stop position not set, use duration instead */
2339 hr
= IMediaSeeking_GetDuration(iface
, pStop
);
2341 *pStop
= This
->stop_position
;
2343 LeaveCriticalSection(&This
->cs
);
2348 static HRESULT WINAPI
MediaSeeking_GetCurrentPosition(IMediaSeeking
*iface
,
2349 LONGLONG
*pCurrent
) {
2350 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2356 EnterCriticalSection(&This
->cs
);
2357 if (This
->state
== State_Running
&& This
->refClock
)
2359 IReferenceClock_GetTime(This
->refClock
, &time
);
2361 time
+= This
->position
- This
->start_time
;
2362 if (time
< This
->position
)
2363 time
= This
->position
;
2367 *pCurrent
= This
->position
;
2368 LeaveCriticalSection(&This
->cs
);
2370 TRACE("Time: %u.%03u\n", (DWORD
)(*pCurrent
/ 10000000), (DWORD
)((*pCurrent
/ 10000)%1000));
2375 static HRESULT WINAPI
MediaSeeking_ConvertTimeFormat(IMediaSeeking
*iface
,
2377 const GUID
*pTargetFormat
,
2379 const GUID
*pSourceFormat
) {
2380 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2382 FIXME("(%p/%p)->(%p, %p, 0x%s, %p): stub !!!\n", This
, iface
, pTarget
,
2383 pTargetFormat
, wine_dbgstr_longlong(Source
), pSourceFormat
);
2389 LONGLONG
* current
, *stop
;
2390 DWORD curflags
, stopflags
;
2393 static HRESULT WINAPI
found_setposition(IFilterGraphImpl
*This
, IMediaSeeking
*seek
, DWORD_PTR pargs
)
2395 struct pos_args
*args
= (void*)pargs
;
2397 return IMediaSeeking_SetPositions(seek
, args
->current
, args
->curflags
, args
->stop
, args
->stopflags
);
2400 static HRESULT WINAPI
MediaSeeking_SetPositions(IMediaSeeking
*iface
,
2402 DWORD dwCurrentFlags
,
2404 DWORD dwStopFlags
) {
2405 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2408 struct pos_args args
;
2410 TRACE("(%p/%p)->(%p, %08x, %p, %08x)\n", This
, iface
, pCurrent
, dwCurrentFlags
, pStop
, dwStopFlags
);
2412 EnterCriticalSection(&This
->cs
);
2413 state
= This
->state
;
2414 TRACE("State: %s\n", state
== State_Running
? "Running" : (state
== State_Paused
? "Paused" : (state
== State_Stopped
? "Stopped" : "UNKNOWN")));
2416 if ((dwCurrentFlags
& 0x7) == AM_SEEKING_AbsolutePositioning
)
2418 This
->position
= *pCurrent
;
2420 else if ((dwCurrentFlags
& 0x7) != AM_SEEKING_NoPositioning
)
2421 FIXME("Adjust method %x not handled yet!\n", dwCurrentFlags
& 0x7);
2423 if ((dwStopFlags
& 0x7) == AM_SEEKING_AbsolutePositioning
)
2424 This
->stop_position
= *pStop
;
2425 else if ((dwStopFlags
& 0x7) != AM_SEEKING_NoPositioning
)
2426 FIXME("Stop position not handled yet!\n");
2428 args
.current
= pCurrent
;
2430 args
.curflags
= dwCurrentFlags
;
2431 args
.stopflags
= dwStopFlags
;
2432 hr
= all_renderers_seek(This
, found_setposition
, (DWORD_PTR
)&args
);
2434 if (This
->refClock
&& ((dwCurrentFlags
& 0x7) != AM_SEEKING_NoPositioning
))
2436 /* Update start time, prevents weird jumps */
2437 IReferenceClock_GetTime(This
->refClock
, &This
->start_time
);
2439 LeaveCriticalSection(&This
->cs
);
2444 static HRESULT WINAPI
MediaSeeking_GetPositions(IMediaSeeking
*iface
,
2447 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2450 TRACE("(%p/%p)->(%p, %p)\n", This
, iface
, pCurrent
, pStop
);
2451 hr
= IMediaSeeking_GetCurrentPosition(iface
, pCurrent
);
2453 hr
= IMediaSeeking_GetStopPosition(iface
, pStop
);
2458 static HRESULT WINAPI
MediaSeeking_GetAvailable(IMediaSeeking
*iface
,
2459 LONGLONG
*pEarliest
,
2460 LONGLONG
*pLatest
) {
2461 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2463 FIXME("(%p/%p)->(%p, %p): stub !!!\n", This
, iface
, pEarliest
, pLatest
);
2468 static HRESULT WINAPI
MediaSeeking_SetRate(IMediaSeeking
*iface
,
2470 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2472 FIXME("(%p/%p)->(%f): stub !!!\n", This
, iface
, dRate
);
2477 static HRESULT WINAPI
MediaSeeking_GetRate(IMediaSeeking
*iface
,
2479 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2481 FIXME("(%p/%p)->(%p): stub !!!\n", This
, iface
, pdRate
);
2486 static HRESULT WINAPI
MediaSeeking_GetPreroll(IMediaSeeking
*iface
,
2487 LONGLONG
*pllPreroll
) {
2488 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaSeeking_vtbl
, iface
);
2490 FIXME("(%p/%p)->(%p): stub !!!\n", This
, iface
, pllPreroll
);
2496 static const IMediaSeekingVtbl IMediaSeeking_VTable
=
2498 MediaSeeking_QueryInterface
,
2499 MediaSeeking_AddRef
,
2500 MediaSeeking_Release
,
2501 MediaSeeking_GetCapabilities
,
2502 MediaSeeking_CheckCapabilities
,
2503 MediaSeeking_IsFormatSupported
,
2504 MediaSeeking_QueryPreferredFormat
,
2505 MediaSeeking_GetTimeFormat
,
2506 MediaSeeking_IsUsingTimeFormat
,
2507 MediaSeeking_SetTimeFormat
,
2508 MediaSeeking_GetDuration
,
2509 MediaSeeking_GetStopPosition
,
2510 MediaSeeking_GetCurrentPosition
,
2511 MediaSeeking_ConvertTimeFormat
,
2512 MediaSeeking_SetPositions
,
2513 MediaSeeking_GetPositions
,
2514 MediaSeeking_GetAvailable
,
2515 MediaSeeking_SetRate
,
2516 MediaSeeking_GetRate
,
2517 MediaSeeking_GetPreroll
2520 /*** IUnknown methods ***/
2521 static HRESULT WINAPI
MediaPosition_QueryInterface(IMediaPosition
* iface
, REFIID riid
, void** ppvObj
){
2522 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaPosition_vtbl
, iface
);
2524 TRACE("(%p/%p)->(%s (%p), %p)\n", This
, iface
, debugstr_guid(riid
), riid
, ppvObj
);
2526 return Filtergraph_QueryInterface(This
, riid
, ppvObj
);
2529 static ULONG WINAPI
MediaPosition_AddRef(IMediaPosition
*iface
){
2530 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaPosition_vtbl
, iface
);
2532 TRACE("(%p/%p)->()\n", This
, iface
);
2534 return Filtergraph_AddRef(This
);
2537 static ULONG WINAPI
MediaPosition_Release(IMediaPosition
*iface
){
2538 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaPosition_vtbl
, iface
);
2540 TRACE("(%p/%p)->()\n", This
, iface
);
2542 return Filtergraph_Release(This
);
2545 /*** IDispatch methods ***/
2546 static HRESULT WINAPI
MediaPosition_GetTypeInfoCount(IMediaPosition
*iface
, UINT
* pctinfo
){
2547 FIXME("(%p) stub!\n", iface
);
2551 static HRESULT WINAPI
MediaPosition_GetTypeInfo(IMediaPosition
*iface
, UINT iTInfo
, LCID lcid
, ITypeInfo
** ppTInfo
){
2552 FIXME("(%p) stub!\n", iface
);
2556 static HRESULT WINAPI
MediaPosition_GetIDsOfNames(IMediaPosition
* iface
, REFIID riid
, LPOLESTR
* rgszNames
, UINT cNames
, LCID lcid
, DISPID
* rgDispId
){
2557 FIXME("(%p) stub!\n", iface
);
2561 static HRESULT WINAPI
MediaPosition_Invoke(IMediaPosition
* iface
, DISPID dispIdMember
, REFIID riid
, LCID lcid
, WORD wFlags
, DISPPARAMS
* pDispParams
, VARIANT
* pVarResult
, EXCEPINFO
* pExcepInfo
, UINT
* puArgErr
){
2562 FIXME("(%p) stub!\n", iface
);
2566 /*** IMediaPosition methods ***/
2567 static HRESULT WINAPI
MediaPosition_get_Duration(IMediaPosition
* iface
, REFTIME
*plength
){
2568 FIXME("(%p)->(%p) stub!\n", iface
, plength
);
2572 static HRESULT WINAPI
MediaPosition_put_CurrentPosition(IMediaPosition
* iface
, REFTIME llTime
){
2573 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaPosition_vtbl
, iface
);
2574 LONGLONG reftime
= llTime
;
2576 return IMediaSeeking_SetPositions((IMediaSeeking
*)&This
->IMediaSeeking_vtbl
, &reftime
, AM_SEEKING_AbsolutePositioning
, NULL
, AM_SEEKING_NoPositioning
);
2579 static HRESULT WINAPI
MediaPosition_get_CurrentPosition(IMediaPosition
* iface
, REFTIME
*pllTime
){
2580 FIXME("(%p)->(%p) stub!\n", iface
, pllTime
);
2584 static HRESULT WINAPI
MediaPosition_get_StopTime(IMediaPosition
* iface
, REFTIME
*pllTime
){
2585 FIXME("(%p)->(%p) stub!\n", iface
, pllTime
);
2589 static HRESULT WINAPI
MediaPosition_put_StopTime(IMediaPosition
* iface
, REFTIME llTime
){
2590 FIXME("(%p)->(%f) stub!\n", iface
, llTime
);
2594 static HRESULT WINAPI
MediaPosition_get_PrerollTime(IMediaPosition
* iface
, REFTIME
*pllTime
){
2595 FIXME("(%p)->(%p) stub!\n", iface
, pllTime
);
2599 static HRESULT WINAPI
MediaPosition_put_PrerollTime(IMediaPosition
* iface
, REFTIME llTime
){
2600 FIXME("(%p)->(%f) stub!\n", iface
, llTime
);
2604 static HRESULT WINAPI
MediaPosition_put_Rate(IMediaPosition
* iface
, double dRate
){
2605 FIXME("(%p)->(%f) stub!\n", iface
, dRate
);
2609 static HRESULT WINAPI
MediaPosition_get_Rate(IMediaPosition
* iface
, double *pdRate
){
2610 FIXME("(%p)->(%p) stub!\n", iface
, pdRate
);
2614 static HRESULT WINAPI
MediaPosition_CanSeekForward(IMediaPosition
* iface
, LONG
*pCanSeekForward
){
2615 FIXME("(%p)->(%p) stub!\n", iface
, pCanSeekForward
);
2619 static HRESULT WINAPI
MediaPosition_CanSeekBackward(IMediaPosition
* iface
, LONG
*pCanSeekBackward
){
2620 FIXME("(%p)->(%p) stub!\n", iface
, pCanSeekBackward
);
2625 static const IMediaPositionVtbl IMediaPosition_VTable
=
2627 MediaPosition_QueryInterface
,
2628 MediaPosition_AddRef
,
2629 MediaPosition_Release
,
2630 MediaPosition_GetTypeInfoCount
,
2631 MediaPosition_GetTypeInfo
,
2632 MediaPosition_GetIDsOfNames
,
2633 MediaPosition_Invoke
,
2634 MediaPosition_get_Duration
,
2635 MediaPosition_put_CurrentPosition
,
2636 MediaPosition_get_CurrentPosition
,
2637 MediaPosition_get_StopTime
,
2638 MediaPosition_put_StopTime
,
2639 MediaPosition_get_PrerollTime
,
2640 MediaPosition_put_PrerollTime
,
2641 MediaPosition_put_Rate
,
2642 MediaPosition_get_Rate
,
2643 MediaPosition_CanSeekForward
,
2644 MediaPosition_CanSeekBackward
2647 static HRESULT
GetTargetInterface(IFilterGraphImpl
* pGraph
, REFIID riid
, LPVOID
* ppvObj
)
2649 HRESULT hr
= E_NOINTERFACE
;
2653 /* Check if the interface type is already registered */
2654 for (entry
= 0; entry
< pGraph
->nItfCacheEntries
; entry
++)
2655 if (riid
== pGraph
->ItfCacheEntries
[entry
].riid
)
2657 if (pGraph
->ItfCacheEntries
[entry
].iface
)
2659 /* Return the interface if available */
2660 *ppvObj
= pGraph
->ItfCacheEntries
[entry
].iface
;
2666 if (entry
>= MAX_ITF_CACHE_ENTRIES
)
2668 FIXME("Not enough space to store interface in the cache\n");
2669 return E_OUTOFMEMORY
;
2672 /* Find a filter supporting the requested interface */
2673 for (i
= 0; i
< pGraph
->nFilters
; i
++)
2675 hr
= IBaseFilter_QueryInterface(pGraph
->ppFiltersInGraph
[i
], riid
, ppvObj
);
2678 pGraph
->ItfCacheEntries
[entry
].riid
= riid
;
2679 pGraph
->ItfCacheEntries
[entry
].filter
= pGraph
->ppFiltersInGraph
[i
];
2680 pGraph
->ItfCacheEntries
[entry
].iface
= (IUnknown
*)*ppvObj
;
2681 if (entry
>= pGraph
->nItfCacheEntries
)
2682 pGraph
->nItfCacheEntries
++;
2685 if (hr
!= E_NOINTERFACE
)
2692 /*** IUnknown methods ***/
2693 static HRESULT WINAPI
BasicAudio_QueryInterface(IBasicAudio
*iface
,
2696 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicAudio_vtbl
, iface
);
2698 TRACE("(%p/%p)->(%s (%p), %p)\n", This
, iface
, debugstr_guid(riid
), riid
, ppvObj
);
2700 return Filtergraph_QueryInterface(This
, riid
, ppvObj
);
2703 static ULONG WINAPI
BasicAudio_AddRef(IBasicAudio
*iface
) {
2704 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicAudio_vtbl
, iface
);
2706 TRACE("(%p/%p)->()\n", This
, iface
);
2708 return Filtergraph_AddRef(This
);
2711 static ULONG WINAPI
BasicAudio_Release(IBasicAudio
*iface
) {
2712 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicAudio_vtbl
, iface
);
2714 TRACE("(%p/%p)->()\n", This
, iface
);
2716 return Filtergraph_Release(This
);
2719 /*** IDispatch methods ***/
2720 static HRESULT WINAPI
BasicAudio_GetTypeInfoCount(IBasicAudio
*iface
,
2722 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicAudio_vtbl
, iface
);
2723 IBasicAudio
* pBasicAudio
;
2726 TRACE("(%p/%p)->(%p)\n", This
, iface
, pctinfo
);
2728 EnterCriticalSection(&This
->cs
);
2730 hr
= GetTargetInterface(This
, &IID_IBasicAudio
, (LPVOID
*)&pBasicAudio
);
2733 hr
= IBasicAudio_GetTypeInfoCount(pBasicAudio
, pctinfo
);
2735 LeaveCriticalSection(&This
->cs
);
2740 static HRESULT WINAPI
BasicAudio_GetTypeInfo(IBasicAudio
*iface
,
2743 ITypeInfo
**ppTInfo
) {
2744 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicAudio_vtbl
, iface
);
2745 IBasicAudio
* pBasicAudio
;
2748 TRACE("(%p/%p)->(%d, %d, %p)\n", This
, iface
, iTInfo
, lcid
, ppTInfo
);
2750 EnterCriticalSection(&This
->cs
);
2752 hr
= GetTargetInterface(This
, &IID_IBasicAudio
, (LPVOID
*)&pBasicAudio
);
2755 hr
= IBasicAudio_GetTypeInfo(pBasicAudio
, iTInfo
, lcid
, ppTInfo
);
2757 LeaveCriticalSection(&This
->cs
);
2762 static HRESULT WINAPI
BasicAudio_GetIDsOfNames(IBasicAudio
*iface
,
2768 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicAudio_vtbl
, iface
);
2769 IBasicAudio
* pBasicAudio
;
2772 TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p)\n", This
, iface
, debugstr_guid(riid
), riid
, rgszNames
, cNames
, lcid
, rgDispId
);
2774 EnterCriticalSection(&This
->cs
);
2776 hr
= GetTargetInterface(This
, &IID_IBasicAudio
, (LPVOID
*)&pBasicAudio
);
2779 hr
= IBasicAudio_GetIDsOfNames(pBasicAudio
, riid
, rgszNames
, cNames
, lcid
, rgDispId
);
2781 LeaveCriticalSection(&This
->cs
);
2786 static HRESULT WINAPI
BasicAudio_Invoke(IBasicAudio
*iface
,
2787 DISPID dispIdMember
,
2791 DISPPARAMS
*pDispParams
,
2793 EXCEPINFO
*pExepInfo
,
2795 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicAudio_vtbl
, iface
);
2796 IBasicAudio
* pBasicAudio
;
2799 TRACE("(%p/%p)->(%d, %s (%p), %d, %04x, %p, %p, %p, %p)\n", This
, iface
, dispIdMember
, debugstr_guid(riid
), riid
, lcid
, wFlags
, pDispParams
, pVarResult
, pExepInfo
, puArgErr
);
2801 EnterCriticalSection(&This
->cs
);
2803 hr
= GetTargetInterface(This
, &IID_IBasicAudio
, (LPVOID
*)&pBasicAudio
);
2806 hr
= IBasicAudio_Invoke(pBasicAudio
, dispIdMember
, riid
, lcid
, wFlags
, pDispParams
, pVarResult
, pExepInfo
, puArgErr
);
2808 LeaveCriticalSection(&This
->cs
);
2813 /*** IBasicAudio methods ***/
2814 static HRESULT WINAPI
BasicAudio_put_Volume(IBasicAudio
*iface
,
2816 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicAudio_vtbl
, iface
);
2817 IBasicAudio
* pBasicAudio
;
2820 TRACE("(%p/%p)->(%ld)\n", This
, iface
, lVolume
);
2822 EnterCriticalSection(&This
->cs
);
2824 hr
= GetTargetInterface(This
, &IID_IBasicAudio
, (LPVOID
*)&pBasicAudio
);
2827 hr
= IBasicAudio_put_Volume(pBasicAudio
, lVolume
);
2829 LeaveCriticalSection(&This
->cs
);
2834 static HRESULT WINAPI
BasicAudio_get_Volume(IBasicAudio
*iface
,
2836 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicAudio_vtbl
, iface
);
2837 IBasicAudio
* pBasicAudio
;
2840 TRACE("(%p/%p)->(%p)\n", This
, iface
, plVolume
);
2842 EnterCriticalSection(&This
->cs
);
2844 hr
= GetTargetInterface(This
, &IID_IBasicAudio
, (LPVOID
*)&pBasicAudio
);
2847 hr
= IBasicAudio_get_Volume(pBasicAudio
, plVolume
);
2849 LeaveCriticalSection(&This
->cs
);
2854 static HRESULT WINAPI
BasicAudio_put_Balance(IBasicAudio
*iface
,
2856 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicAudio_vtbl
, iface
);
2857 IBasicAudio
* pBasicAudio
;
2860 TRACE("(%p/%p)->(%ld)\n", This
, iface
, lBalance
);
2862 EnterCriticalSection(&This
->cs
);
2864 hr
= GetTargetInterface(This
, &IID_IBasicAudio
, (LPVOID
*)&pBasicAudio
);
2867 hr
= IBasicAudio_put_Balance(pBasicAudio
, lBalance
);
2869 LeaveCriticalSection(&This
->cs
);
2874 static HRESULT WINAPI
BasicAudio_get_Balance(IBasicAudio
*iface
,
2876 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicAudio_vtbl
, iface
);
2877 IBasicAudio
* pBasicAudio
;
2880 TRACE("(%p/%p)->(%p)\n", This
, iface
, plBalance
);
2882 EnterCriticalSection(&This
->cs
);
2884 hr
= GetTargetInterface(This
, &IID_IBasicAudio
, (LPVOID
*)&pBasicAudio
);
2887 hr
= IBasicAudio_get_Balance(pBasicAudio
, plBalance
);
2889 LeaveCriticalSection(&This
->cs
);
2894 static const IBasicAudioVtbl IBasicAudio_VTable
=
2896 BasicAudio_QueryInterface
,
2899 BasicAudio_GetTypeInfoCount
,
2900 BasicAudio_GetTypeInfo
,
2901 BasicAudio_GetIDsOfNames
,
2903 BasicAudio_put_Volume
,
2904 BasicAudio_get_Volume
,
2905 BasicAudio_put_Balance
,
2906 BasicAudio_get_Balance
2909 /*** IUnknown methods ***/
2910 static HRESULT WINAPI
BasicVideo_QueryInterface(IBasicVideo2
*iface
,
2913 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
2915 TRACE("(%p/%p)->(%s (%p), %p)\n", This
, iface
, debugstr_guid(riid
), riid
, ppvObj
);
2917 return Filtergraph_QueryInterface(This
, riid
, ppvObj
);
2920 static ULONG WINAPI
BasicVideo_AddRef(IBasicVideo2
*iface
) {
2921 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
2923 TRACE("(%p/%p)->()\n", This
, iface
);
2925 return Filtergraph_AddRef(This
);
2928 static ULONG WINAPI
BasicVideo_Release(IBasicVideo2
*iface
) {
2929 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
2931 TRACE("(%p/%p)->()\n", This
, iface
);
2933 return Filtergraph_Release(This
);
2936 /*** IDispatch methods ***/
2937 static HRESULT WINAPI
BasicVideo_GetTypeInfoCount(IBasicVideo2
*iface
,
2939 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
2940 IBasicVideo
* pBasicVideo
;
2943 TRACE("(%p/%p)->(%p)\n", This
, iface
, pctinfo
);
2945 EnterCriticalSection(&This
->cs
);
2947 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
2950 hr
= IBasicVideo_GetTypeInfoCount(pBasicVideo
, pctinfo
);
2952 LeaveCriticalSection(&This
->cs
);
2957 static HRESULT WINAPI
BasicVideo_GetTypeInfo(IBasicVideo2
*iface
,
2960 ITypeInfo
**ppTInfo
) {
2961 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
2962 IBasicVideo
* pBasicVideo
;
2965 TRACE("(%p/%p)->(%d, %d, %p)\n", This
, iface
, iTInfo
, lcid
, ppTInfo
);
2967 EnterCriticalSection(&This
->cs
);
2969 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
2972 hr
= IBasicVideo_GetTypeInfo(pBasicVideo
, iTInfo
, lcid
, ppTInfo
);
2974 LeaveCriticalSection(&This
->cs
);
2979 static HRESULT WINAPI
BasicVideo_GetIDsOfNames(IBasicVideo2
*iface
,
2985 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
2986 IBasicVideo
* pBasicVideo
;
2989 TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p)\n", This
, iface
, debugstr_guid(riid
), riid
, rgszNames
, cNames
, lcid
, rgDispId
);
2991 EnterCriticalSection(&This
->cs
);
2993 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
2996 hr
= IBasicVideo_GetIDsOfNames(pBasicVideo
, riid
, rgszNames
, cNames
, lcid
, rgDispId
);
2998 LeaveCriticalSection(&This
->cs
);
3003 static HRESULT WINAPI
BasicVideo_Invoke(IBasicVideo2
*iface
,
3004 DISPID dispIdMember
,
3008 DISPPARAMS
*pDispParams
,
3010 EXCEPINFO
*pExepInfo
,
3012 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3013 IBasicVideo
* pBasicVideo
;
3016 TRACE("(%p/%p)->(%d, %s (%p), %d, %04x, %p, %p, %p, %p)\n", This
, iface
, dispIdMember
, debugstr_guid(riid
), riid
, lcid
, wFlags
, pDispParams
, pVarResult
, pExepInfo
, puArgErr
);
3018 EnterCriticalSection(&This
->cs
);
3020 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3023 hr
= IBasicVideo_Invoke(pBasicVideo
, dispIdMember
, riid
, lcid
, wFlags
, pDispParams
, pVarResult
, pExepInfo
, puArgErr
);
3025 LeaveCriticalSection(&This
->cs
);
3030 /*** IBasicVideo methods ***/
3031 static HRESULT WINAPI
BasicVideo_get_AvgTimePerFrame(IBasicVideo2
*iface
,
3032 REFTIME
*pAvgTimePerFrame
) {
3033 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3034 IBasicVideo
* pBasicVideo
;
3037 TRACE("(%p/%p)->(%p)\n", This
, iface
, pAvgTimePerFrame
);
3039 EnterCriticalSection(&This
->cs
);
3041 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3044 hr
= IBasicVideo_get_AvgTimePerFrame(pBasicVideo
, pAvgTimePerFrame
);
3046 LeaveCriticalSection(&This
->cs
);
3051 static HRESULT WINAPI
BasicVideo_get_BitRate(IBasicVideo2
*iface
,
3053 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3054 IBasicVideo
* pBasicVideo
;
3057 TRACE("(%p/%p)->(%p)\n", This
, iface
, pBitRate
);
3059 EnterCriticalSection(&This
->cs
);
3061 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3064 hr
= IBasicVideo_get_BitRate(pBasicVideo
, pBitRate
);
3066 LeaveCriticalSection(&This
->cs
);
3071 static HRESULT WINAPI
BasicVideo_get_BitErrorRate(IBasicVideo2
*iface
,
3072 long *pBitErrorRate
) {
3073 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3074 IBasicVideo
* pBasicVideo
;
3077 TRACE("(%p/%p)->(%p)\n", This
, iface
, pBitErrorRate
);
3079 EnterCriticalSection(&This
->cs
);
3081 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3084 hr
= IBasicVideo_get_BitErrorRate(pBasicVideo
, pBitErrorRate
);
3086 LeaveCriticalSection(&This
->cs
);
3091 static HRESULT WINAPI
BasicVideo_get_VideoWidth(IBasicVideo2
*iface
,
3092 long *pVideoWidth
) {
3093 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3094 IBasicVideo
* pBasicVideo
;
3097 TRACE("(%p/%p)->(%p)\n", This
, iface
, pVideoWidth
);
3099 EnterCriticalSection(&This
->cs
);
3101 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3104 hr
= IBasicVideo_get_VideoWidth(pBasicVideo
, pVideoWidth
);
3106 LeaveCriticalSection(&This
->cs
);
3111 static HRESULT WINAPI
BasicVideo_get_VideoHeight(IBasicVideo2
*iface
,
3112 long *pVideoHeight
) {
3113 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3114 IBasicVideo
* pBasicVideo
;
3117 TRACE("(%p/%p)->(%p)\n", This
, iface
, pVideoHeight
);
3119 EnterCriticalSection(&This
->cs
);
3121 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3124 hr
= IBasicVideo_get_VideoHeight(pBasicVideo
, pVideoHeight
);
3126 LeaveCriticalSection(&This
->cs
);
3131 static HRESULT WINAPI
BasicVideo_put_SourceLeft(IBasicVideo2
*iface
,
3133 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3134 IBasicVideo
* pBasicVideo
;
3137 TRACE("(%p/%p)->(%ld)\n", This
, iface
, SourceLeft
);
3139 EnterCriticalSection(&This
->cs
);
3141 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3144 hr
= IBasicVideo_put_SourceLeft(pBasicVideo
, SourceLeft
);
3146 LeaveCriticalSection(&This
->cs
);
3151 static HRESULT WINAPI
BasicVideo_get_SourceLeft(IBasicVideo2
*iface
,
3152 long *pSourceLeft
) {
3153 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3154 IBasicVideo
* pBasicVideo
;
3157 TRACE("(%p/%p)->(%p)\n", This
, iface
, pSourceLeft
);
3159 EnterCriticalSection(&This
->cs
);
3161 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3164 hr
= IBasicVideo_get_SourceLeft(pBasicVideo
, pSourceLeft
);
3166 LeaveCriticalSection(&This
->cs
);
3171 static HRESULT WINAPI
BasicVideo_put_SourceWidth(IBasicVideo2
*iface
,
3173 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3174 IBasicVideo
* pBasicVideo
;
3177 TRACE("(%p/%p)->(%ld)\n", This
, iface
, SourceWidth
);
3179 EnterCriticalSection(&This
->cs
);
3181 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3184 hr
= IBasicVideo_put_SourceWidth(pBasicVideo
, SourceWidth
);
3186 LeaveCriticalSection(&This
->cs
);
3191 static HRESULT WINAPI
BasicVideo_get_SourceWidth(IBasicVideo2
*iface
,
3192 long *pSourceWidth
) {
3193 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3194 IBasicVideo
* pBasicVideo
;
3197 TRACE("(%p/%p)->(%p)\n", This
, iface
, pSourceWidth
);
3199 EnterCriticalSection(&This
->cs
);
3201 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3204 hr
= IBasicVideo_get_SourceWidth(pBasicVideo
, pSourceWidth
);
3206 LeaveCriticalSection(&This
->cs
);
3211 static HRESULT WINAPI
BasicVideo_put_SourceTop(IBasicVideo2
*iface
,
3213 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3214 IBasicVideo
* pBasicVideo
;
3217 TRACE("(%p/%p)->(%ld)\n", This
, iface
, SourceTop
);
3219 EnterCriticalSection(&This
->cs
);
3221 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3224 hr
= IBasicVideo_put_SourceTop(pBasicVideo
, SourceTop
);
3226 LeaveCriticalSection(&This
->cs
);
3231 static HRESULT WINAPI
BasicVideo_get_SourceTop(IBasicVideo2
*iface
,
3233 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3234 IBasicVideo
* pBasicVideo
;
3237 TRACE("(%p/%p)->(%p)\n", This
, iface
, pSourceTop
);
3239 EnterCriticalSection(&This
->cs
);
3241 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3244 hr
= IBasicVideo_get_SourceTop(pBasicVideo
, pSourceTop
);
3246 LeaveCriticalSection(&This
->cs
);
3251 static HRESULT WINAPI
BasicVideo_put_SourceHeight(IBasicVideo2
*iface
,
3252 long SourceHeight
) {
3253 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3254 IBasicVideo
* pBasicVideo
;
3257 TRACE("(%p/%p)->(%ld)\n", This
, iface
, SourceHeight
);
3259 EnterCriticalSection(&This
->cs
);
3261 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3264 hr
= IBasicVideo_put_SourceHeight(pBasicVideo
, SourceHeight
);
3266 LeaveCriticalSection(&This
->cs
);
3271 static HRESULT WINAPI
BasicVideo_get_SourceHeight(IBasicVideo2
*iface
,
3272 long *pSourceHeight
) {
3273 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3274 IBasicVideo
* pBasicVideo
;
3277 TRACE("(%p/%p)->(%p)\n", This
, iface
, pSourceHeight
);
3279 EnterCriticalSection(&This
->cs
);
3281 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3284 hr
= IBasicVideo_get_SourceHeight(pBasicVideo
, pSourceHeight
);
3286 LeaveCriticalSection(&This
->cs
);
3291 static HRESULT WINAPI
BasicVideo_put_DestinationLeft(IBasicVideo2
*iface
,
3292 long DestinationLeft
) {
3293 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3294 IBasicVideo
* pBasicVideo
;
3297 TRACE("(%p/%p)->(%ld)\n", This
, iface
, DestinationLeft
);
3299 EnterCriticalSection(&This
->cs
);
3301 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3304 hr
= IBasicVideo_put_DestinationLeft(pBasicVideo
, DestinationLeft
);
3306 LeaveCriticalSection(&This
->cs
);
3311 static HRESULT WINAPI
BasicVideo_get_DestinationLeft(IBasicVideo2
*iface
,
3312 long *pDestinationLeft
) {
3313 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3314 IBasicVideo
* pBasicVideo
;
3317 TRACE("(%p/%p)->(%p)\n", This
, iface
, pDestinationLeft
);
3319 EnterCriticalSection(&This
->cs
);
3321 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3324 hr
= IBasicVideo_get_DestinationLeft(pBasicVideo
, pDestinationLeft
);
3326 LeaveCriticalSection(&This
->cs
);
3331 static HRESULT WINAPI
BasicVideo_put_DestinationWidth(IBasicVideo2
*iface
,
3332 long DestinationWidth
) {
3333 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3334 IBasicVideo
* pBasicVideo
;
3337 TRACE("(%p/%p)->(%ld)\n", This
, iface
, DestinationWidth
);
3339 EnterCriticalSection(&This
->cs
);
3341 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3344 hr
= IBasicVideo_put_DestinationWidth(pBasicVideo
, DestinationWidth
);
3346 LeaveCriticalSection(&This
->cs
);
3351 static HRESULT WINAPI
BasicVideo_get_DestinationWidth(IBasicVideo2
*iface
,
3352 long *pDestinationWidth
) {
3353 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3354 IBasicVideo
* pBasicVideo
;
3357 TRACE("(%p/%p)->(%p)\n", This
, iface
, pDestinationWidth
);
3359 EnterCriticalSection(&This
->cs
);
3361 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3364 hr
= IBasicVideo_get_DestinationWidth(pBasicVideo
, pDestinationWidth
);
3366 LeaveCriticalSection(&This
->cs
);
3371 static HRESULT WINAPI
BasicVideo_put_DestinationTop(IBasicVideo2
*iface
,
3372 long DestinationTop
) {
3373 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3374 IBasicVideo
* pBasicVideo
;
3377 TRACE("(%p/%p)->(%ld)\n", This
, iface
, DestinationTop
);
3379 EnterCriticalSection(&This
->cs
);
3381 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3384 hr
= IBasicVideo_put_DestinationTop(pBasicVideo
, DestinationTop
);
3386 LeaveCriticalSection(&This
->cs
);
3391 static HRESULT WINAPI
BasicVideo_get_DestinationTop(IBasicVideo2
*iface
,
3392 long *pDestinationTop
) {
3393 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3394 IBasicVideo
* pBasicVideo
;
3397 TRACE("(%p/%p)->(%p)\n", This
, iface
, pDestinationTop
);
3399 EnterCriticalSection(&This
->cs
);
3401 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3404 hr
= IBasicVideo_get_DestinationTop(pBasicVideo
, pDestinationTop
);
3406 LeaveCriticalSection(&This
->cs
);
3411 static HRESULT WINAPI
BasicVideo_put_DestinationHeight(IBasicVideo2
*iface
,
3412 long DestinationHeight
) {
3413 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3414 IBasicVideo
* pBasicVideo
;
3417 TRACE("(%p/%p)->(%ld)\n", This
, iface
, DestinationHeight
);
3419 EnterCriticalSection(&This
->cs
);
3421 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3424 hr
= IBasicVideo_put_DestinationHeight(pBasicVideo
, DestinationHeight
);
3426 LeaveCriticalSection(&This
->cs
);
3431 static HRESULT WINAPI
BasicVideo_get_DestinationHeight(IBasicVideo2
*iface
,
3432 long *pDestinationHeight
) {
3433 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3434 IBasicVideo
* pBasicVideo
;
3437 TRACE("(%p/%p)->(%p)\n", This
, iface
, pDestinationHeight
);
3439 EnterCriticalSection(&This
->cs
);
3441 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3444 hr
= IBasicVideo_get_DestinationHeight(pBasicVideo
, pDestinationHeight
);
3446 LeaveCriticalSection(&This
->cs
);
3451 static HRESULT WINAPI
BasicVideo_SetSourcePosition(IBasicVideo2
*iface
,
3456 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3457 IBasicVideo
* pBasicVideo
;
3460 TRACE("(%p/%p)->(%ld, %ld, %ld, %ld)\n", This
, iface
, Left
, Top
, Width
, Height
);
3462 EnterCriticalSection(&This
->cs
);
3464 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3467 hr
= IBasicVideo_SetSourcePosition(pBasicVideo
, Left
, Top
, Width
, Height
);
3469 LeaveCriticalSection(&This
->cs
);
3474 static HRESULT WINAPI
BasicVideo_GetSourcePosition(IBasicVideo2
*iface
,
3479 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3480 IBasicVideo
* pBasicVideo
;
3483 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This
, iface
, pLeft
, pTop
, pWidth
, pHeight
);
3485 EnterCriticalSection(&This
->cs
);
3487 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3490 hr
= IBasicVideo_GetSourcePosition(pBasicVideo
, pLeft
, pTop
, pWidth
, pHeight
);
3492 LeaveCriticalSection(&This
->cs
);
3497 static HRESULT WINAPI
BasicVideo_SetDefaultSourcePosition(IBasicVideo2
*iface
) {
3498 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3499 IBasicVideo
* pBasicVideo
;
3502 TRACE("(%p/%p)->()\n", This
, iface
);
3504 EnterCriticalSection(&This
->cs
);
3506 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3509 hr
= IBasicVideo_SetDefaultSourcePosition(pBasicVideo
);
3511 LeaveCriticalSection(&This
->cs
);
3516 static HRESULT WINAPI
BasicVideo_SetDestinationPosition(IBasicVideo2
*iface
,
3521 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3522 IBasicVideo
* pBasicVideo
;
3525 TRACE("(%p/%p)->(%ld, %ld, %ld, %ld)\n", This
, iface
, Left
, Top
, Width
, Height
);
3527 EnterCriticalSection(&This
->cs
);
3529 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3532 hr
= IBasicVideo_SetDestinationPosition(pBasicVideo
, Left
, Top
, Width
, Height
);
3534 LeaveCriticalSection(&This
->cs
);
3539 static HRESULT WINAPI
BasicVideo_GetDestinationPosition(IBasicVideo2
*iface
,
3544 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3545 IBasicVideo
* pBasicVideo
;
3548 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This
, iface
, pLeft
, pTop
, pWidth
, pHeight
);
3550 EnterCriticalSection(&This
->cs
);
3552 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3555 hr
= IBasicVideo_GetDestinationPosition(pBasicVideo
, pLeft
, pTop
, pWidth
, pHeight
);
3557 LeaveCriticalSection(&This
->cs
);
3562 static HRESULT WINAPI
BasicVideo_SetDefaultDestinationPosition(IBasicVideo2
*iface
) {
3563 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3564 IBasicVideo
* pBasicVideo
;
3567 TRACE("(%p/%p)->()\n", This
, iface
);
3569 EnterCriticalSection(&This
->cs
);
3571 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3574 hr
= IBasicVideo_SetDefaultDestinationPosition(pBasicVideo
);
3576 LeaveCriticalSection(&This
->cs
);
3581 static HRESULT WINAPI
BasicVideo_GetVideoSize(IBasicVideo2
*iface
,
3584 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3585 IBasicVideo
* pBasicVideo
;
3588 TRACE("(%p/%p)->(%p, %p)\n", This
, iface
, pWidth
, pHeight
);
3590 EnterCriticalSection(&This
->cs
);
3592 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3595 hr
= IBasicVideo_GetVideoSize(pBasicVideo
, pWidth
, pHeight
);
3597 LeaveCriticalSection(&This
->cs
);
3602 static HRESULT WINAPI
BasicVideo_GetVideoPaletteEntries(IBasicVideo2
*iface
,
3607 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3608 IBasicVideo
* pBasicVideo
;
3611 TRACE("(%p/%p)->(%ld, %ld, %p, %p)\n", This
, iface
, StartIndex
, Entries
, pRetrieved
, pPalette
);
3613 EnterCriticalSection(&This
->cs
);
3615 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3618 hr
= IBasicVideo_GetVideoPaletteEntries(pBasicVideo
, StartIndex
, Entries
, pRetrieved
, pPalette
);
3620 LeaveCriticalSection(&This
->cs
);
3625 static HRESULT WINAPI
BasicVideo_GetCurrentImage(IBasicVideo2
*iface
,
3628 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3629 IBasicVideo
* pBasicVideo
;
3632 TRACE("(%p/%p)->(%p, %p)\n", This
, iface
, pBufferSize
, pDIBImage
);
3634 EnterCriticalSection(&This
->cs
);
3636 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3639 hr
= IBasicVideo_GetCurrentImage(pBasicVideo
, pBufferSize
, pDIBImage
);
3641 LeaveCriticalSection(&This
->cs
);
3646 static HRESULT WINAPI
BasicVideo_IsUsingDefaultSource(IBasicVideo2
*iface
) {
3647 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3648 IBasicVideo
* pBasicVideo
;
3651 TRACE("(%p/%p)->()\n", This
, iface
);
3653 EnterCriticalSection(&This
->cs
);
3655 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3658 hr
= IBasicVideo_IsUsingDefaultSource(pBasicVideo
);
3660 LeaveCriticalSection(&This
->cs
);
3665 static HRESULT WINAPI
BasicVideo_IsUsingDefaultDestination(IBasicVideo2
*iface
) {
3666 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3667 IBasicVideo
* pBasicVideo
;
3670 TRACE("(%p/%p)->()\n", This
, iface
);
3672 EnterCriticalSection(&This
->cs
);
3674 hr
= GetTargetInterface(This
, &IID_IBasicVideo
, (LPVOID
*)&pBasicVideo
);
3677 hr
= IBasicVideo_IsUsingDefaultDestination(pBasicVideo
);
3679 LeaveCriticalSection(&This
->cs
);
3684 static HRESULT WINAPI
BasicVideo2_GetPreferredAspectRatio(IBasicVideo2
*iface
, LONG
*plAspectX
, LONG
*plAspectY
) {
3685 ICOM_THIS_MULTI(IFilterGraphImpl
, IBasicVideo_vtbl
, iface
);
3686 IBasicVideo2
*pBasicVideo2
;
3689 TRACE("(%p/%p)->()\n", This
, iface
);
3691 EnterCriticalSection(&This
->cs
);
3693 hr
= GetTargetInterface(This
, &IID_IBasicVideo2
, (LPVOID
*)&pBasicVideo2
);
3696 hr
= BasicVideo2_GetPreferredAspectRatio(iface
, plAspectX
, plAspectY
);
3698 LeaveCriticalSection(&This
->cs
);
3703 static const IBasicVideo2Vtbl IBasicVideo_VTable
=
3705 BasicVideo_QueryInterface
,
3708 BasicVideo_GetTypeInfoCount
,
3709 BasicVideo_GetTypeInfo
,
3710 BasicVideo_GetIDsOfNames
,
3712 BasicVideo_get_AvgTimePerFrame
,
3713 BasicVideo_get_BitRate
,
3714 BasicVideo_get_BitErrorRate
,
3715 BasicVideo_get_VideoWidth
,
3716 BasicVideo_get_VideoHeight
,
3717 BasicVideo_put_SourceLeft
,
3718 BasicVideo_get_SourceLeft
,
3719 BasicVideo_put_SourceWidth
,
3720 BasicVideo_get_SourceWidth
,
3721 BasicVideo_put_SourceTop
,
3722 BasicVideo_get_SourceTop
,
3723 BasicVideo_put_SourceHeight
,
3724 BasicVideo_get_SourceHeight
,
3725 BasicVideo_put_DestinationLeft
,
3726 BasicVideo_get_DestinationLeft
,
3727 BasicVideo_put_DestinationWidth
,
3728 BasicVideo_get_DestinationWidth
,
3729 BasicVideo_put_DestinationTop
,
3730 BasicVideo_get_DestinationTop
,
3731 BasicVideo_put_DestinationHeight
,
3732 BasicVideo_get_DestinationHeight
,
3733 BasicVideo_SetSourcePosition
,
3734 BasicVideo_GetSourcePosition
,
3735 BasicVideo_SetDefaultSourcePosition
,
3736 BasicVideo_SetDestinationPosition
,
3737 BasicVideo_GetDestinationPosition
,
3738 BasicVideo_SetDefaultDestinationPosition
,
3739 BasicVideo_GetVideoSize
,
3740 BasicVideo_GetVideoPaletteEntries
,
3741 BasicVideo_GetCurrentImage
,
3742 BasicVideo_IsUsingDefaultSource
,
3743 BasicVideo_IsUsingDefaultDestination
,
3744 BasicVideo2_GetPreferredAspectRatio
3748 /*** IUnknown methods ***/
3749 static HRESULT WINAPI
VideoWindow_QueryInterface(IVideoWindow
*iface
,
3752 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
3754 TRACE("(%p/%p)->(%s (%p), %p)\n", This
, iface
, debugstr_guid(riid
), riid
, ppvObj
);
3756 return Filtergraph_QueryInterface(This
, riid
, ppvObj
);
3759 static ULONG WINAPI
VideoWindow_AddRef(IVideoWindow
*iface
) {
3760 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
3762 TRACE("(%p/%p)->()\n", This
, iface
);
3764 return Filtergraph_AddRef(This
);
3767 static ULONG WINAPI
VideoWindow_Release(IVideoWindow
*iface
) {
3768 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
3770 TRACE("(%p/%p)->()\n", This
, iface
);
3772 return Filtergraph_Release(This
);
3775 /*** IDispatch methods ***/
3776 static HRESULT WINAPI
VideoWindow_GetTypeInfoCount(IVideoWindow
*iface
,
3778 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
3779 IVideoWindow
* pVideoWindow
;
3782 TRACE("(%p/%p)->(%p)\n", This
, iface
, pctinfo
);
3784 EnterCriticalSection(&This
->cs
);
3786 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
3789 hr
= IVideoWindow_GetTypeInfoCount(pVideoWindow
, pctinfo
);
3791 LeaveCriticalSection(&This
->cs
);
3796 static HRESULT WINAPI
VideoWindow_GetTypeInfo(IVideoWindow
*iface
,
3799 ITypeInfo
**ppTInfo
) {
3800 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
3801 IVideoWindow
* pVideoWindow
;
3804 TRACE("(%p/%p)->(%d, %d, %p)\n", This
, iface
, iTInfo
, lcid
, ppTInfo
);
3806 EnterCriticalSection(&This
->cs
);
3808 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
3811 hr
= IVideoWindow_GetTypeInfo(pVideoWindow
, iTInfo
, lcid
, ppTInfo
);
3813 LeaveCriticalSection(&This
->cs
);
3818 static HRESULT WINAPI
VideoWindow_GetIDsOfNames(IVideoWindow
*iface
,
3824 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
3825 IVideoWindow
* pVideoWindow
;
3828 TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p)\n", This
, iface
, debugstr_guid(riid
), riid
, rgszNames
, cNames
, lcid
, rgDispId
);
3830 EnterCriticalSection(&This
->cs
);
3832 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
3835 hr
= IVideoWindow_GetIDsOfNames(pVideoWindow
, riid
, rgszNames
, cNames
, lcid
, rgDispId
);
3837 LeaveCriticalSection(&This
->cs
);
3842 static HRESULT WINAPI
VideoWindow_Invoke(IVideoWindow
*iface
,
3843 DISPID dispIdMember
,
3847 DISPPARAMS
*pDispParams
,
3849 EXCEPINFO
*pExepInfo
,
3851 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
3852 IVideoWindow
* pVideoWindow
;
3855 TRACE("(%p/%p)->(%d, %s (%p), %d, %04x, %p, %p, %p, %p)\n", This
, iface
, dispIdMember
, debugstr_guid(riid
), riid
, lcid
, wFlags
, pDispParams
, pVarResult
, pExepInfo
, puArgErr
);
3857 EnterCriticalSection(&This
->cs
);
3859 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
3862 hr
= IVideoWindow_Invoke(pVideoWindow
, dispIdMember
, riid
, lcid
, wFlags
, pDispParams
, pVarResult
, pExepInfo
, puArgErr
);
3864 LeaveCriticalSection(&This
->cs
);
3870 /*** IVideoWindow methods ***/
3871 static HRESULT WINAPI
VideoWindow_put_Caption(IVideoWindow
*iface
,
3873 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
3874 IVideoWindow
* pVideoWindow
;
3877 TRACE("(%p/%p)->(%s (%p))\n", This
, iface
, debugstr_w(strCaption
), strCaption
);
3879 EnterCriticalSection(&This
->cs
);
3881 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
3884 hr
= IVideoWindow_put_Caption(pVideoWindow
, strCaption
);
3886 LeaveCriticalSection(&This
->cs
);
3891 static HRESULT WINAPI
VideoWindow_get_Caption(IVideoWindow
*iface
,
3893 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
3894 IVideoWindow
* pVideoWindow
;
3897 TRACE("(%p/%p)->(%p)\n", This
, iface
, strCaption
);
3899 EnterCriticalSection(&This
->cs
);
3901 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
3904 hr
= IVideoWindow_get_Caption(pVideoWindow
, strCaption
);
3906 LeaveCriticalSection(&This
->cs
);
3911 static HRESULT WINAPI
VideoWindow_put_WindowStyle(IVideoWindow
*iface
,
3913 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
3914 IVideoWindow
* pVideoWindow
;
3917 TRACE("(%p/%p)->(%ld)\n", This
, iface
, WindowStyle
);
3919 EnterCriticalSection(&This
->cs
);
3921 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
3924 hr
= IVideoWindow_put_WindowStyle(pVideoWindow
, WindowStyle
);
3926 LeaveCriticalSection(&This
->cs
);
3931 static HRESULT WINAPI
VideoWindow_get_WindowStyle(IVideoWindow
*iface
,
3932 long *WindowStyle
) {
3933 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
3934 IVideoWindow
* pVideoWindow
;
3937 TRACE("(%p/%p)->(%p)\n", This
, iface
, WindowStyle
);
3939 EnterCriticalSection(&This
->cs
);
3941 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
3944 hr
= IVideoWindow_get_WindowStyle(pVideoWindow
, WindowStyle
);
3946 LeaveCriticalSection(&This
->cs
);
3951 static HRESULT WINAPI
VideoWindow_put_WindowStyleEx(IVideoWindow
*iface
,
3952 long WindowStyleEx
) {
3953 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
3954 IVideoWindow
* pVideoWindow
;
3957 TRACE("(%p/%p)->(%ld)\n", This
, iface
, WindowStyleEx
);
3959 EnterCriticalSection(&This
->cs
);
3961 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
3964 hr
= IVideoWindow_put_WindowStyleEx(pVideoWindow
, WindowStyleEx
);
3966 LeaveCriticalSection(&This
->cs
);
3971 static HRESULT WINAPI
VideoWindow_get_WindowStyleEx(IVideoWindow
*iface
,
3972 long *WindowStyleEx
) {
3973 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
3974 IVideoWindow
* pVideoWindow
;
3977 TRACE("(%p/%p)->(%p)\n", This
, iface
, WindowStyleEx
);
3979 EnterCriticalSection(&This
->cs
);
3981 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
3984 hr
= IVideoWindow_get_WindowStyleEx(pVideoWindow
, WindowStyleEx
);
3986 LeaveCriticalSection(&This
->cs
);
3991 static HRESULT WINAPI
VideoWindow_put_AutoShow(IVideoWindow
*iface
,
3993 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
3994 IVideoWindow
* pVideoWindow
;
3997 TRACE("(%p/%p)->(%ld)\n", This
, iface
, AutoShow
);
3999 EnterCriticalSection(&This
->cs
);
4001 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4004 hr
= IVideoWindow_put_AutoShow(pVideoWindow
, AutoShow
);
4006 LeaveCriticalSection(&This
->cs
);
4011 static HRESULT WINAPI
VideoWindow_get_AutoShow(IVideoWindow
*iface
,
4013 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4014 IVideoWindow
* pVideoWindow
;
4017 TRACE("(%p/%p)->(%p)\n", This
, iface
, AutoShow
);
4019 EnterCriticalSection(&This
->cs
);
4021 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4024 hr
= IVideoWindow_get_AutoShow(pVideoWindow
, AutoShow
);
4026 LeaveCriticalSection(&This
->cs
);
4031 static HRESULT WINAPI
VideoWindow_put_WindowState(IVideoWindow
*iface
,
4033 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4034 IVideoWindow
* pVideoWindow
;
4037 TRACE("(%p/%p)->(%ld)\n", This
, iface
, WindowState
);
4039 EnterCriticalSection(&This
->cs
);
4041 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4044 hr
= IVideoWindow_put_WindowState(pVideoWindow
, WindowState
);
4046 LeaveCriticalSection(&This
->cs
);
4051 static HRESULT WINAPI
VideoWindow_get_WindowState(IVideoWindow
*iface
,
4052 long *WindowState
) {
4053 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4054 IVideoWindow
* pVideoWindow
;
4057 TRACE("(%p/%p)->(%p)\n", This
, iface
, WindowState
);
4059 EnterCriticalSection(&This
->cs
);
4061 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4064 hr
= IVideoWindow_get_WindowState(pVideoWindow
, WindowState
);
4066 LeaveCriticalSection(&This
->cs
);
4071 static HRESULT WINAPI
VideoWindow_put_BackgroundPalette(IVideoWindow
*iface
,
4072 long BackgroundPalette
) {
4073 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4074 IVideoWindow
* pVideoWindow
;
4077 TRACE("(%p/%p)->(%ld)\n", This
, iface
, BackgroundPalette
);
4079 EnterCriticalSection(&This
->cs
);
4081 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4084 hr
= IVideoWindow_put_BackgroundPalette(pVideoWindow
, BackgroundPalette
);
4086 LeaveCriticalSection(&This
->cs
);
4091 static HRESULT WINAPI
VideoWindow_get_BackgroundPalette(IVideoWindow
*iface
,
4092 long *pBackgroundPalette
) {
4093 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4094 IVideoWindow
* pVideoWindow
;
4097 TRACE("(%p/%p)->(%p)\n", This
, iface
, pBackgroundPalette
);
4099 EnterCriticalSection(&This
->cs
);
4101 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4104 hr
= IVideoWindow_get_BackgroundPalette(pVideoWindow
, pBackgroundPalette
);
4106 LeaveCriticalSection(&This
->cs
);
4111 static HRESULT WINAPI
VideoWindow_put_Visible(IVideoWindow
*iface
,
4113 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4114 IVideoWindow
* pVideoWindow
;
4117 TRACE("(%p/%p)->(%ld)\n", This
, iface
, Visible
);
4119 EnterCriticalSection(&This
->cs
);
4121 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4124 hr
= IVideoWindow_put_Visible(pVideoWindow
, Visible
);
4126 LeaveCriticalSection(&This
->cs
);
4131 static HRESULT WINAPI
VideoWindow_get_Visible(IVideoWindow
*iface
,
4133 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4134 IVideoWindow
* pVideoWindow
;
4137 TRACE("(%p/%p)->(%p)\n", This
, iface
, pVisible
);
4139 EnterCriticalSection(&This
->cs
);
4141 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4144 hr
= IVideoWindow_get_Visible(pVideoWindow
, pVisible
);
4146 LeaveCriticalSection(&This
->cs
);
4151 static HRESULT WINAPI
VideoWindow_put_Left(IVideoWindow
*iface
,
4153 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4154 IVideoWindow
* pVideoWindow
;
4157 TRACE("(%p/%p)->(%ld)\n", This
, iface
, Left
);
4159 EnterCriticalSection(&This
->cs
);
4161 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4164 hr
= IVideoWindow_put_Left(pVideoWindow
, Left
);
4166 LeaveCriticalSection(&This
->cs
);
4171 static HRESULT WINAPI
VideoWindow_get_Left(IVideoWindow
*iface
,
4173 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4174 IVideoWindow
* pVideoWindow
;
4177 TRACE("(%p/%p)->(%p)\n", This
, iface
, pLeft
);
4179 EnterCriticalSection(&This
->cs
);
4181 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4184 hr
= IVideoWindow_get_Left(pVideoWindow
, pLeft
);
4186 LeaveCriticalSection(&This
->cs
);
4191 static HRESULT WINAPI
VideoWindow_put_Width(IVideoWindow
*iface
,
4193 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4194 IVideoWindow
* pVideoWindow
;
4197 TRACE("(%p/%p)->(%ld)\n", This
, iface
, Width
);
4199 EnterCriticalSection(&This
->cs
);
4201 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4204 hr
= IVideoWindow_put_Width(pVideoWindow
, Width
);
4206 LeaveCriticalSection(&This
->cs
);
4211 static HRESULT WINAPI
VideoWindow_get_Width(IVideoWindow
*iface
,
4213 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4214 IVideoWindow
* pVideoWindow
;
4217 TRACE("(%p/%p)->(%p)\n", This
, iface
, pWidth
);
4219 EnterCriticalSection(&This
->cs
);
4221 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4224 hr
= IVideoWindow_get_Width(pVideoWindow
, pWidth
);
4226 LeaveCriticalSection(&This
->cs
);
4231 static HRESULT WINAPI
VideoWindow_put_Top(IVideoWindow
*iface
,
4233 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4234 IVideoWindow
* pVideoWindow
;
4237 TRACE("(%p/%p)->(%ld)\n", This
, iface
, Top
);
4239 EnterCriticalSection(&This
->cs
);
4241 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4244 hr
= IVideoWindow_put_Top(pVideoWindow
, Top
);
4246 LeaveCriticalSection(&This
->cs
);
4251 static HRESULT WINAPI
VideoWindow_get_Top(IVideoWindow
*iface
,
4253 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4254 IVideoWindow
* pVideoWindow
;
4257 TRACE("(%p/%p)->(%p)\n", This
, iface
, pTop
);
4259 EnterCriticalSection(&This
->cs
);
4261 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4264 hr
= IVideoWindow_get_Top(pVideoWindow
, pTop
);
4266 LeaveCriticalSection(&This
->cs
);
4271 static HRESULT WINAPI
VideoWindow_put_Height(IVideoWindow
*iface
,
4273 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4274 IVideoWindow
* pVideoWindow
;
4277 TRACE("(%p/%p)->(%ld)\n", This
, iface
, Height
);
4279 EnterCriticalSection(&This
->cs
);
4281 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4284 hr
= IVideoWindow_put_Height(pVideoWindow
, Height
);
4286 LeaveCriticalSection(&This
->cs
);
4291 static HRESULT WINAPI
VideoWindow_get_Height(IVideoWindow
*iface
,
4293 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4294 IVideoWindow
* pVideoWindow
;
4297 TRACE("(%p/%p)->(%p)\n", This
, iface
, pHeight
);
4299 EnterCriticalSection(&This
->cs
);
4301 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4304 hr
= IVideoWindow_get_Height(pVideoWindow
, pHeight
);
4306 LeaveCriticalSection(&This
->cs
);
4311 static HRESULT WINAPI
VideoWindow_put_Owner(IVideoWindow
*iface
,
4313 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4314 IVideoWindow
* pVideoWindow
;
4317 TRACE("(%p/%p)->(%08x)\n", This
, iface
, (DWORD
) Owner
);
4319 EnterCriticalSection(&This
->cs
);
4321 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4324 hr
= IVideoWindow_put_Owner(pVideoWindow
, Owner
);
4326 LeaveCriticalSection(&This
->cs
);
4331 static HRESULT WINAPI
VideoWindow_get_Owner(IVideoWindow
*iface
,
4333 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4334 IVideoWindow
* pVideoWindow
;
4337 TRACE("(%p/%p)->(%p)\n", This
, iface
, Owner
);
4339 EnterCriticalSection(&This
->cs
);
4341 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4344 hr
= IVideoWindow_get_Owner(pVideoWindow
, Owner
);
4346 LeaveCriticalSection(&This
->cs
);
4351 static HRESULT WINAPI
VideoWindow_put_MessageDrain(IVideoWindow
*iface
,
4353 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4354 IVideoWindow
* pVideoWindow
;
4357 TRACE("(%p/%p)->(%08x)\n", This
, iface
, (DWORD
) Drain
);
4359 EnterCriticalSection(&This
->cs
);
4361 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4364 hr
= IVideoWindow_put_MessageDrain(pVideoWindow
, Drain
);
4366 LeaveCriticalSection(&This
->cs
);
4371 static HRESULT WINAPI
VideoWindow_get_MessageDrain(IVideoWindow
*iface
,
4373 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4374 IVideoWindow
* pVideoWindow
;
4377 TRACE("(%p/%p)->(%p)\n", This
, iface
, Drain
);
4379 EnterCriticalSection(&This
->cs
);
4381 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4384 hr
= IVideoWindow_get_MessageDrain(pVideoWindow
, Drain
);
4386 LeaveCriticalSection(&This
->cs
);
4391 static HRESULT WINAPI
VideoWindow_get_BorderColor(IVideoWindow
*iface
,
4393 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4394 IVideoWindow
* pVideoWindow
;
4397 TRACE("(%p/%p)->(%p)\n", This
, iface
, Color
);
4399 EnterCriticalSection(&This
->cs
);
4401 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4404 hr
= IVideoWindow_get_BorderColor(pVideoWindow
, Color
);
4406 LeaveCriticalSection(&This
->cs
);
4411 static HRESULT WINAPI
VideoWindow_put_BorderColor(IVideoWindow
*iface
,
4413 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4414 IVideoWindow
* pVideoWindow
;
4417 TRACE("(%p/%p)->(%ld)\n", This
, iface
, Color
);
4419 EnterCriticalSection(&This
->cs
);
4421 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4424 hr
= IVideoWindow_put_BorderColor(pVideoWindow
, Color
);
4426 LeaveCriticalSection(&This
->cs
);
4431 static HRESULT WINAPI
VideoWindow_get_FullScreenMode(IVideoWindow
*iface
,
4432 long *FullScreenMode
) {
4433 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4434 IVideoWindow
* pVideoWindow
;
4437 TRACE("(%p/%p)->(%p)\n", This
, iface
, FullScreenMode
);
4439 EnterCriticalSection(&This
->cs
);
4441 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4444 hr
= IVideoWindow_get_FullScreenMode(pVideoWindow
, FullScreenMode
);
4446 LeaveCriticalSection(&This
->cs
);
4451 static HRESULT WINAPI
VideoWindow_put_FullScreenMode(IVideoWindow
*iface
,
4452 long FullScreenMode
) {
4453 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4454 IVideoWindow
* pVideoWindow
;
4457 TRACE("(%p/%p)->(%ld)\n", This
, iface
, FullScreenMode
);
4459 EnterCriticalSection(&This
->cs
);
4461 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4464 hr
= IVideoWindow_put_FullScreenMode(pVideoWindow
, FullScreenMode
);
4466 LeaveCriticalSection(&This
->cs
);
4471 static HRESULT WINAPI
VideoWindow_SetWindowForeground(IVideoWindow
*iface
,
4473 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4474 IVideoWindow
* pVideoWindow
;
4477 TRACE("(%p/%p)->(%ld)\n", This
, iface
, Focus
);
4479 EnterCriticalSection(&This
->cs
);
4481 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4484 hr
= IVideoWindow_SetWindowForeground(pVideoWindow
, Focus
);
4486 LeaveCriticalSection(&This
->cs
);
4491 static HRESULT WINAPI
VideoWindow_NotifyOwnerMessage(IVideoWindow
*iface
,
4496 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4497 IVideoWindow
* pVideoWindow
;
4500 TRACE("(%p/%p)->(%08x, %ld, %08lx, %08lx)\n", This
, iface
, (DWORD
) hwnd
, uMsg
, wParam
, lParam
);
4502 EnterCriticalSection(&This
->cs
);
4504 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4507 hr
= IVideoWindow_NotifyOwnerMessage(pVideoWindow
, hwnd
, uMsg
, wParam
, lParam
);
4509 LeaveCriticalSection(&This
->cs
);
4514 static HRESULT WINAPI
VideoWindow_SetWindowPosition(IVideoWindow
*iface
,
4519 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4520 IVideoWindow
* pVideoWindow
;
4523 TRACE("(%p/%p)->(%ld, %ld, %ld, %ld)\n", This
, iface
, Left
, Top
, Width
, Height
);
4525 EnterCriticalSection(&This
->cs
);
4527 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4530 hr
= IVideoWindow_SetWindowPosition(pVideoWindow
, Left
, Top
, Width
, Height
);
4532 LeaveCriticalSection(&This
->cs
);
4537 static HRESULT WINAPI
VideoWindow_GetWindowPosition(IVideoWindow
*iface
,
4542 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4543 IVideoWindow
* pVideoWindow
;
4546 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This
, iface
, pLeft
, pTop
, pWidth
, pHeight
);
4548 EnterCriticalSection(&This
->cs
);
4550 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4553 hr
= IVideoWindow_GetWindowPosition(pVideoWindow
, pLeft
, pTop
, pWidth
, pHeight
);
4555 LeaveCriticalSection(&This
->cs
);
4560 static HRESULT WINAPI
VideoWindow_GetMinIdealImageSize(IVideoWindow
*iface
,
4563 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4564 IVideoWindow
* pVideoWindow
;
4567 TRACE("(%p/%p)->(%p, %p)\n", This
, iface
, pWidth
, pHeight
);
4569 EnterCriticalSection(&This
->cs
);
4571 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4574 hr
= IVideoWindow_GetMinIdealImageSize(pVideoWindow
, pWidth
, pHeight
);
4576 LeaveCriticalSection(&This
->cs
);
4581 static HRESULT WINAPI
VideoWindow_GetMaxIdealImageSize(IVideoWindow
*iface
,
4584 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4585 IVideoWindow
* pVideoWindow
;
4588 TRACE("(%p/%p)->(%p, %p)\n", This
, iface
, pWidth
, pHeight
);
4590 EnterCriticalSection(&This
->cs
);
4592 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4595 hr
= IVideoWindow_GetMaxIdealImageSize(pVideoWindow
, pWidth
, pHeight
);
4597 LeaveCriticalSection(&This
->cs
);
4602 static HRESULT WINAPI
VideoWindow_GetRestorePosition(IVideoWindow
*iface
,
4607 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4608 IVideoWindow
* pVideoWindow
;
4611 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This
, iface
, pLeft
, pTop
, pWidth
, pHeight
);
4613 EnterCriticalSection(&This
->cs
);
4615 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4618 hr
= IVideoWindow_GetRestorePosition(pVideoWindow
, pLeft
, pTop
, pWidth
, pHeight
);
4620 LeaveCriticalSection(&This
->cs
);
4625 static HRESULT WINAPI
VideoWindow_HideCursor(IVideoWindow
*iface
,
4627 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4628 IVideoWindow
* pVideoWindow
;
4631 TRACE("(%p/%p)->(%ld)\n", This
, iface
, HideCursor
);
4633 EnterCriticalSection(&This
->cs
);
4635 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4638 hr
= IVideoWindow_HideCursor(pVideoWindow
, HideCursor
);
4640 LeaveCriticalSection(&This
->cs
);
4645 static HRESULT WINAPI
VideoWindow_IsCursorHidden(IVideoWindow
*iface
,
4646 long *CursorHidden
) {
4647 ICOM_THIS_MULTI(IFilterGraphImpl
, IVideoWindow_vtbl
, iface
);
4648 IVideoWindow
* pVideoWindow
;
4651 TRACE("(%p/%p)->(%p)\n", This
, iface
, CursorHidden
);
4653 EnterCriticalSection(&This
->cs
);
4655 hr
= GetTargetInterface(This
, &IID_IVideoWindow
, (LPVOID
*)&pVideoWindow
);
4658 hr
= IVideoWindow_IsCursorHidden(pVideoWindow
, CursorHidden
);
4660 LeaveCriticalSection(&This
->cs
);
4666 static const IVideoWindowVtbl IVideoWindow_VTable
=
4668 VideoWindow_QueryInterface
,
4670 VideoWindow_Release
,
4671 VideoWindow_GetTypeInfoCount
,
4672 VideoWindow_GetTypeInfo
,
4673 VideoWindow_GetIDsOfNames
,
4675 VideoWindow_put_Caption
,
4676 VideoWindow_get_Caption
,
4677 VideoWindow_put_WindowStyle
,
4678 VideoWindow_get_WindowStyle
,
4679 VideoWindow_put_WindowStyleEx
,
4680 VideoWindow_get_WindowStyleEx
,
4681 VideoWindow_put_AutoShow
,
4682 VideoWindow_get_AutoShow
,
4683 VideoWindow_put_WindowState
,
4684 VideoWindow_get_WindowState
,
4685 VideoWindow_put_BackgroundPalette
,
4686 VideoWindow_get_BackgroundPalette
,
4687 VideoWindow_put_Visible
,
4688 VideoWindow_get_Visible
,
4689 VideoWindow_put_Left
,
4690 VideoWindow_get_Left
,
4691 VideoWindow_put_Width
,
4692 VideoWindow_get_Width
,
4693 VideoWindow_put_Top
,
4694 VideoWindow_get_Top
,
4695 VideoWindow_put_Height
,
4696 VideoWindow_get_Height
,
4697 VideoWindow_put_Owner
,
4698 VideoWindow_get_Owner
,
4699 VideoWindow_put_MessageDrain
,
4700 VideoWindow_get_MessageDrain
,
4701 VideoWindow_get_BorderColor
,
4702 VideoWindow_put_BorderColor
,
4703 VideoWindow_get_FullScreenMode
,
4704 VideoWindow_put_FullScreenMode
,
4705 VideoWindow_SetWindowForeground
,
4706 VideoWindow_NotifyOwnerMessage
,
4707 VideoWindow_SetWindowPosition
,
4708 VideoWindow_GetWindowPosition
,
4709 VideoWindow_GetMinIdealImageSize
,
4710 VideoWindow_GetMaxIdealImageSize
,
4711 VideoWindow_GetRestorePosition
,
4712 VideoWindow_HideCursor
,
4713 VideoWindow_IsCursorHidden
4717 /*** IUnknown methods ***/
4718 static HRESULT WINAPI
MediaEvent_QueryInterface(IMediaEventEx
*iface
,
4721 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4723 TRACE("(%p/%p)->(%s (%p), %p)\n", This
, iface
, debugstr_guid(riid
), riid
, ppvObj
);
4725 return Filtergraph_QueryInterface(This
, riid
, ppvObj
);
4728 static ULONG WINAPI
MediaEvent_AddRef(IMediaEventEx
*iface
) {
4729 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4731 TRACE("(%p/%p)->()\n", This
, iface
);
4733 return Filtergraph_AddRef(This
);
4736 static ULONG WINAPI
MediaEvent_Release(IMediaEventEx
*iface
) {
4737 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4739 TRACE("(%p/%p)->()\n", This
, iface
);
4741 return Filtergraph_Release(This
);
4744 /*** IDispatch methods ***/
4745 static HRESULT WINAPI
MediaEvent_GetTypeInfoCount(IMediaEventEx
*iface
,
4747 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4749 TRACE("(%p/%p)->(%p): stub !!!\n", This
, iface
, pctinfo
);
4754 static HRESULT WINAPI
MediaEvent_GetTypeInfo(IMediaEventEx
*iface
,
4757 ITypeInfo
**ppTInfo
) {
4758 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4760 TRACE("(%p/%p)->(%d, %d, %p): stub !!!\n", This
, iface
, iTInfo
, lcid
, ppTInfo
);
4765 static HRESULT WINAPI
MediaEvent_GetIDsOfNames(IMediaEventEx
*iface
,
4771 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4773 TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This
, iface
, debugstr_guid(riid
), riid
, rgszNames
, cNames
, lcid
, rgDispId
);
4778 static HRESULT WINAPI
MediaEvent_Invoke(IMediaEventEx
*iface
,
4779 DISPID dispIdMember
,
4783 DISPPARAMS
*pDispParams
,
4785 EXCEPINFO
*pExepInfo
,
4787 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4789 TRACE("(%p/%p)->(%d, %s (%p), %d, %04x, %p, %p, %p, %p): stub !!!\n", This
, iface
, dispIdMember
, debugstr_guid(riid
), riid
, lcid
, wFlags
, pDispParams
, pVarResult
, pExepInfo
, puArgErr
);
4794 /*** IMediaEvent methods ***/
4795 static HRESULT WINAPI
MediaEvent_GetEventHandle(IMediaEventEx
*iface
,
4797 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4799 TRACE("(%p/%p)->(%p)\n", This
, iface
, hEvent
);
4801 *hEvent
= (OAEVENT
)This
->evqueue
.msg_event
;
4806 static HRESULT WINAPI
MediaEvent_GetEvent(IMediaEventEx
*iface
,
4811 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4814 TRACE("(%p/%p)->(%p, %p, %p, %ld)\n", This
, iface
, lEventCode
, lParam1
, lParam2
, msTimeout
);
4816 if (EventsQueue_GetEvent(&This
->evqueue
, &evt
, msTimeout
))
4818 *lEventCode
= evt
.lEventCode
;
4819 *lParam1
= evt
.lParam1
;
4820 *lParam2
= evt
.lParam2
;
4828 static HRESULT WINAPI
MediaEvent_WaitForCompletion(IMediaEventEx
*iface
,
4831 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4833 TRACE("(%p/%p)->(%ld, %p)\n", This
, iface
, msTimeout
, pEvCode
);
4835 if (WaitForSingleObject(This
->hEventCompletion
, msTimeout
) == WAIT_OBJECT_0
)
4837 *pEvCode
= This
->CompletionStatus
;
4845 static HRESULT WINAPI
MediaEvent_CancelDefaultHandling(IMediaEventEx
*iface
,
4847 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4849 TRACE("(%p/%p)->(%ld)\n", This
, iface
, lEvCode
);
4851 if (lEvCode
== EC_COMPLETE
)
4852 This
->HandleEcComplete
= FALSE
;
4853 else if (lEvCode
== EC_REPAINT
)
4854 This
->HandleEcRepaint
= FALSE
;
4855 else if (lEvCode
== EC_CLOCK_CHANGED
)
4856 This
->HandleEcClockChanged
= FALSE
;
4863 static HRESULT WINAPI
MediaEvent_RestoreDefaultHandling(IMediaEventEx
*iface
,
4865 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4867 TRACE("(%p/%p)->(%ld)\n", This
, iface
, lEvCode
);
4869 if (lEvCode
== EC_COMPLETE
)
4870 This
->HandleEcComplete
= TRUE
;
4871 else if (lEvCode
== EC_REPAINT
)
4872 This
->HandleEcRepaint
= TRUE
;
4873 else if (lEvCode
== EC_CLOCK_CHANGED
)
4874 This
->HandleEcClockChanged
= TRUE
;
4881 static HRESULT WINAPI
MediaEvent_FreeEventParams(IMediaEventEx
*iface
,
4885 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4887 TRACE("(%p/%p)->(%ld, %08lx, %08lx): stub !!!\n", This
, iface
, lEvCode
, lParam1
, lParam2
);
4892 /*** IMediaEventEx methods ***/
4893 static HRESULT WINAPI
MediaEvent_SetNotifyWindow(IMediaEventEx
*iface
,
4896 LONG_PTR lInstanceData
) {
4897 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4899 TRACE("(%p/%p)->(%08x, %ld, %08lx)\n", This
, iface
, (DWORD
) hwnd
, lMsg
, lInstanceData
);
4901 This
->notif
.hWnd
= (HWND
)hwnd
;
4902 This
->notif
.msg
= lMsg
;
4903 This
->notif
.instance
= (long) lInstanceData
;
4908 static HRESULT WINAPI
MediaEvent_SetNotifyFlags(IMediaEventEx
*iface
,
4909 long lNoNotifyFlags
) {
4910 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4912 TRACE("(%p/%p)->(%ld)\n", This
, iface
, lNoNotifyFlags
);
4914 if ((lNoNotifyFlags
!= 0) && (lNoNotifyFlags
!= 1))
4915 return E_INVALIDARG
;
4917 This
->notif
.disabled
= lNoNotifyFlags
;
4922 static HRESULT WINAPI
MediaEvent_GetNotifyFlags(IMediaEventEx
*iface
,
4923 long *lplNoNotifyFlags
) {
4924 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventEx_vtbl
, iface
);
4926 TRACE("(%p/%p)->(%p)\n", This
, iface
, lplNoNotifyFlags
);
4928 if (!lplNoNotifyFlags
)
4931 *lplNoNotifyFlags
= This
->notif
.disabled
;
4937 static const IMediaEventExVtbl IMediaEventEx_VTable
=
4939 MediaEvent_QueryInterface
,
4942 MediaEvent_GetTypeInfoCount
,
4943 MediaEvent_GetTypeInfo
,
4944 MediaEvent_GetIDsOfNames
,
4946 MediaEvent_GetEventHandle
,
4947 MediaEvent_GetEvent
,
4948 MediaEvent_WaitForCompletion
,
4949 MediaEvent_CancelDefaultHandling
,
4950 MediaEvent_RestoreDefaultHandling
,
4951 MediaEvent_FreeEventParams
,
4952 MediaEvent_SetNotifyWindow
,
4953 MediaEvent_SetNotifyFlags
,
4954 MediaEvent_GetNotifyFlags
4958 static HRESULT WINAPI
MediaFilter_QueryInterface(IMediaFilter
*iface
, REFIID riid
, LPVOID
*ppv
)
4960 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaFilter_vtbl
, iface
);
4962 return Filtergraph_QueryInterface(This
, riid
, ppv
);
4965 static ULONG WINAPI
MediaFilter_AddRef(IMediaFilter
*iface
)
4967 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaFilter_vtbl
, iface
);
4969 return Filtergraph_AddRef(This
);
4972 static ULONG WINAPI
MediaFilter_Release(IMediaFilter
*iface
)
4974 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaFilter_vtbl
, iface
);
4976 return Filtergraph_Release(This
);
4979 static HRESULT WINAPI
MediaFilter_GetClassID(IMediaFilter
*iface
, CLSID
* pClassID
)
4981 FIXME("(%p): stub\n", pClassID
);
4986 static HRESULT WINAPI
MediaFilter_Stop(IMediaFilter
*iface
)
4988 FIXME("(): stub\n");
4993 static HRESULT WINAPI
MediaFilter_Pause(IMediaFilter
*iface
)
4995 FIXME("(): stub\n");
5000 static HRESULT WINAPI
MediaFilter_Run(IMediaFilter
*iface
, REFERENCE_TIME tStart
)
5002 FIXME("(0x%s): stub\n", wine_dbgstr_longlong(tStart
));
5007 static HRESULT WINAPI
MediaFilter_GetState(IMediaFilter
*iface
, DWORD dwMsTimeout
, FILTER_STATE
* pState
)
5009 FIXME("(%d, %p): stub\n", dwMsTimeout
, pState
);
5014 static HRESULT WINAPI
MediaFilter_SetSyncSource(IMediaFilter
*iface
, IReferenceClock
*pClock
)
5016 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaFilter_vtbl
, iface
);
5020 TRACE("(%p/%p)->(%p)\n", iface
, This
, pClock
);
5022 EnterCriticalSection(&This
->cs
);
5024 for (i
= 0;i
< This
->nFilters
;i
++)
5026 hr
= IBaseFilter_SetSyncSource(This
->ppFiltersInGraph
[i
], pClock
);
5034 IBaseFilter_SetSyncSource(This
->ppFiltersInGraph
[i
], This
->refClock
);
5039 IReferenceClock_Release(This
->refClock
);
5040 This
->refClock
= pClock
;
5042 IReferenceClock_AddRef(This
->refClock
);
5044 if (This
->HandleEcClockChanged
)
5046 IMediaEventSink
*pEventSink
;
5049 eshr
= IMediaFilter_QueryInterface(iface
, &IID_IMediaEventSink
, (LPVOID
)&pEventSink
);
5050 if (SUCCEEDED(eshr
))
5052 IMediaEventSink_Notify(pEventSink
, EC_CLOCK_CHANGED
, 0, 0);
5053 IMediaEventSink_Release(pEventSink
);
5058 LeaveCriticalSection(&This
->cs
);
5063 static HRESULT WINAPI
MediaFilter_GetSyncSource(IMediaFilter
*iface
, IReferenceClock
**ppClock
)
5065 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaFilter_vtbl
, iface
);
5067 TRACE("(%p/%p)->(%p)\n", iface
, This
, ppClock
);
5072 EnterCriticalSection(&This
->cs
);
5074 *ppClock
= This
->refClock
;
5076 IReferenceClock_AddRef(*ppClock
);
5078 LeaveCriticalSection(&This
->cs
);
5083 static const IMediaFilterVtbl IMediaFilter_VTable
=
5085 MediaFilter_QueryInterface
,
5087 MediaFilter_Release
,
5088 MediaFilter_GetClassID
,
5092 MediaFilter_GetState
,
5093 MediaFilter_SetSyncSource
,
5094 MediaFilter_GetSyncSource
5097 static HRESULT WINAPI
MediaEventSink_QueryInterface(IMediaEventSink
*iface
, REFIID riid
, LPVOID
*ppv
)
5099 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventSink_vtbl
, iface
);
5101 return Filtergraph_QueryInterface(This
, riid
, ppv
);
5104 static ULONG WINAPI
MediaEventSink_AddRef(IMediaEventSink
*iface
)
5106 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventSink_vtbl
, iface
);
5108 return Filtergraph_AddRef(This
);
5111 static ULONG WINAPI
MediaEventSink_Release(IMediaEventSink
*iface
)
5113 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventSink_vtbl
, iface
);
5115 return Filtergraph_Release(This
);
5118 static HRESULT WINAPI
MediaEventSink_Notify(IMediaEventSink
*iface
, long EventCode
, LONG_PTR EventParam1
, LONG_PTR EventParam2
)
5120 ICOM_THIS_MULTI(IFilterGraphImpl
, IMediaEventSink_vtbl
, iface
);
5123 TRACE("(%p/%p)->(%ld, %ld, %ld)\n", This
, iface
, EventCode
, EventParam1
, EventParam2
);
5125 /* We need thread safety here, let's use the events queue's one */
5126 EnterCriticalSection(&This
->evqueue
.msg_crst
);
5128 if ((EventCode
== EC_COMPLETE
) && This
->HandleEcComplete
)
5130 TRACE("Process EC_COMPLETE notification\n");
5131 if (++This
->EcCompleteCount
== This
->nRenderers
)
5133 evt
.lEventCode
= EC_COMPLETE
;
5136 TRACE("Send EC_COMPLETE to app\n");
5137 EventsQueue_PutEvent(&This
->evqueue
, &evt
);
5138 if (!This
->notif
.disabled
&& This
->notif
.hWnd
)
5140 TRACE("Send Window message\n");
5141 PostMessageW(This
->notif
.hWnd
, This
->notif
.msg
, 0, This
->notif
.instance
);
5143 This
->CompletionStatus
= EC_COMPLETE
;
5144 SetEvent(This
->hEventCompletion
);
5147 else if ((EventCode
== EC_REPAINT
) && This
->HandleEcRepaint
)
5149 /* FIXME: Not handled yet */
5153 evt
.lEventCode
= EventCode
;
5154 evt
.lParam1
= EventParam1
;
5155 evt
.lParam2
= EventParam2
;
5156 EventsQueue_PutEvent(&This
->evqueue
, &evt
);
5157 if (!This
->notif
.disabled
&& This
->notif
.hWnd
)
5158 PostMessageW(This
->notif
.hWnd
, This
->notif
.msg
, 0, This
->notif
.instance
);
5161 LeaveCriticalSection(&This
->evqueue
.msg_crst
);
5165 static const IMediaEventSinkVtbl IMediaEventSink_VTable
=
5167 MediaEventSink_QueryInterface
,
5168 MediaEventSink_AddRef
,
5169 MediaEventSink_Release
,
5170 MediaEventSink_Notify
5173 static HRESULT WINAPI
GraphConfig_QueryInterface(IGraphConfig
*iface
, REFIID riid
, LPVOID
*ppv
)
5175 ICOM_THIS_MULTI(IFilterGraphImpl
, IGraphConfig_vtbl
, iface
);
5177 return Filtergraph_QueryInterface(This
, riid
, ppv
);
5180 static ULONG WINAPI
GraphConfig_AddRef(IGraphConfig
*iface
)
5182 ICOM_THIS_MULTI(IFilterGraphImpl
, IGraphConfig_vtbl
, iface
);
5184 return Filtergraph_AddRef(This
);
5187 static ULONG WINAPI
GraphConfig_Release(IGraphConfig
*iface
)
5189 ICOM_THIS_MULTI(IFilterGraphImpl
, IGraphConfig_vtbl
, iface
);
5191 return Filtergraph_Release(This
);
5194 static HRESULT WINAPI
GraphConfig_Reconnect(IGraphConfig
*iface
,
5197 const AM_MEDIA_TYPE
* pmtFirstConnection
,
5198 IBaseFilter
* pUsingFilter
,
5202 ICOM_THIS_MULTI(IFilterGraphImpl
, IGraphConfig_vtbl
, iface
);
5204 FIXME("(%p)->(%p, %p, %p, %p, %p, %x): stub!\n", This
, pOutputPin
, pInputPin
, pmtFirstConnection
, pUsingFilter
, hAbortEvent
, dwFlags
);
5209 static HRESULT WINAPI
GraphConfig_Reconfigure(IGraphConfig
*iface
,
5210 IGraphConfigCallback
* pCallback
,
5215 ICOM_THIS_MULTI(IFilterGraphImpl
, IGraphConfig_vtbl
, iface
);
5218 WARN("(%p)->(%p, %p, %x, %p): partial stub!\n", This
, pCallback
, pvContext
, dwFlags
, hAbortEvent
);
5221 FIXME("The parameter hAbortEvent is not handled!\n");
5223 EnterCriticalSection(&This
->cs
);
5225 hr
= IGraphConfigCallback_Reconfigure(pCallback
, pvContext
, dwFlags
);
5227 LeaveCriticalSection(&This
->cs
);
5232 static HRESULT WINAPI
GraphConfig_AddFilterToCache(IGraphConfig
*iface
,
5233 IBaseFilter
* pFilter
)
5235 ICOM_THIS_MULTI(IFilterGraphImpl
, IGraphConfig_vtbl
, iface
);
5237 FIXME("(%p)->(%p): stub!\n", This
, pFilter
);
5242 static HRESULT WINAPI
GraphConfig_EnumCacheFilter(IGraphConfig
*iface
,
5243 IEnumFilters
** pEnum
)
5245 ICOM_THIS_MULTI(IFilterGraphImpl
, IGraphConfig_vtbl
, iface
);
5247 FIXME("(%p)->(%p): stub!\n", This
, pEnum
);
5252 static HRESULT WINAPI
GraphConfig_RemoveFilterFromCache(IGraphConfig
*iface
,
5253 IBaseFilter
* pFilter
)
5255 ICOM_THIS_MULTI(IFilterGraphImpl
, IGraphConfig_vtbl
, iface
);
5257 FIXME("(%p)->(%p): stub!\n", This
, pFilter
);
5262 static HRESULT WINAPI
GraphConfig_GetStartTime(IGraphConfig
*iface
,
5263 REFERENCE_TIME
* prtStart
)
5265 ICOM_THIS_MULTI(IFilterGraphImpl
, IGraphConfig_vtbl
, iface
);
5267 FIXME("(%p)->(%p): stub!\n", This
, prtStart
);
5272 static HRESULT WINAPI
GraphConfig_PushThroughData(IGraphConfig
*iface
,
5274 IPinConnection
* pConnection
,
5277 ICOM_THIS_MULTI(IFilterGraphImpl
, IGraphConfig_vtbl
, iface
);
5279 FIXME("(%p)->(%p, %p, %p): stub!\n", This
, pOutputPin
, pConnection
, hEventAbort
);
5284 static HRESULT WINAPI
GraphConfig_SetFilterFlags(IGraphConfig
*iface
,
5285 IBaseFilter
* pFilter
,
5288 ICOM_THIS_MULTI(IFilterGraphImpl
, IGraphConfig_vtbl
, iface
);
5290 FIXME("(%p)->(%p, %x): stub!\n", This
, pFilter
, dwFlags
);
5295 static HRESULT WINAPI
GraphConfig_GetFilterFlags(IGraphConfig
*iface
,
5296 IBaseFilter
* pFilter
,
5299 ICOM_THIS_MULTI(IFilterGraphImpl
, IGraphConfig_vtbl
, iface
);
5301 FIXME("(%p)->(%p, %p): stub!\n", This
, pFilter
, dwFlags
);
5306 static HRESULT WINAPI
GraphConfig_RemoveFilterEx(IGraphConfig
*iface
,
5307 IBaseFilter
* pFilter
,
5310 ICOM_THIS_MULTI(IFilterGraphImpl
, IGraphConfig_vtbl
, iface
);
5312 FIXME("(%p)->(%p, %x): stub!\n", This
, pFilter
, dwFlags
);
5317 static const IGraphConfigVtbl IGraphConfig_VTable
=
5319 GraphConfig_QueryInterface
,
5321 GraphConfig_Release
,
5322 GraphConfig_Reconnect
,
5323 GraphConfig_Reconfigure
,
5324 GraphConfig_AddFilterToCache
,
5325 GraphConfig_EnumCacheFilter
,
5326 GraphConfig_RemoveFilterFromCache
,
5327 GraphConfig_GetStartTime
,
5328 GraphConfig_PushThroughData
,
5329 GraphConfig_SetFilterFlags
,
5330 GraphConfig_GetFilterFlags
,
5331 GraphConfig_RemoveFilterEx
5334 static const IUnknownVtbl IInner_VTable
=
5336 FilterGraphInner_QueryInterface
,
5337 FilterGraphInner_AddRef
,
5338 FilterGraphInner_Release
5341 static HRESULT WINAPI
Filtergraph_QueryInterface(IFilterGraphImpl
*This
,
5344 if (This
->bAggregatable
)
5345 This
->bUnkOuterValid
= TRUE
;
5347 if (This
->pUnkOuter
)
5349 if (This
->bAggregatable
)
5350 return IUnknown_QueryInterface(This
->pUnkOuter
, riid
, ppv
);
5352 if (IsEqualIID(riid
, &IID_IUnknown
))
5356 IUnknown_AddRef((IUnknown
*)&(This
->IInner_vtbl
));
5357 hr
= IUnknown_QueryInterface((IUnknown
*)&(This
->IInner_vtbl
), riid
, ppv
);
5358 IUnknown_Release((IUnknown
*)&(This
->IInner_vtbl
));
5359 This
->bAggregatable
= TRUE
;
5364 return E_NOINTERFACE
;
5367 return IUnknown_QueryInterface((IUnknown
*)&(This
->IInner_vtbl
), riid
, ppv
);
5370 static ULONG WINAPI
Filtergraph_AddRef(IFilterGraphImpl
*This
) {
5371 if (This
->pUnkOuter
&& This
->bUnkOuterValid
)
5372 return IUnknown_AddRef(This
->pUnkOuter
);
5373 return IUnknown_AddRef((IUnknown
*)&(This
->IInner_vtbl
));
5376 static ULONG WINAPI
Filtergraph_Release(IFilterGraphImpl
*This
) {
5377 if (This
->pUnkOuter
&& This
->bUnkOuterValid
)
5378 return IUnknown_Release(This
->pUnkOuter
);
5379 return IUnknown_Release((IUnknown
*)&(This
->IInner_vtbl
));
5382 /* This is the only function that actually creates a FilterGraph class... */
5383 HRESULT
FilterGraph_create(IUnknown
*pUnkOuter
, LPVOID
*ppObj
)
5385 IFilterGraphImpl
*fimpl
;
5388 TRACE("(%p,%p)\n", pUnkOuter
, ppObj
);
5392 fimpl
= CoTaskMemAlloc(sizeof(*fimpl
));
5393 fimpl
->pUnkOuter
= pUnkOuter
;
5394 fimpl
->bUnkOuterValid
= FALSE
;
5395 fimpl
->bAggregatable
= FALSE
;
5396 fimpl
->IInner_vtbl
= &IInner_VTable
;
5397 fimpl
->IFilterGraph2_vtbl
= &IFilterGraph2_VTable
;
5398 fimpl
->IMediaControl_vtbl
= &IMediaControl_VTable
;
5399 fimpl
->IMediaSeeking_vtbl
= &IMediaSeeking_VTable
;
5400 fimpl
->IBasicAudio_vtbl
= &IBasicAudio_VTable
;
5401 fimpl
->IBasicVideo_vtbl
= &IBasicVideo_VTable
;
5402 fimpl
->IVideoWindow_vtbl
= &IVideoWindow_VTable
;
5403 fimpl
->IMediaEventEx_vtbl
= &IMediaEventEx_VTable
;
5404 fimpl
->IMediaFilter_vtbl
= &IMediaFilter_VTable
;
5405 fimpl
->IMediaEventSink_vtbl
= &IMediaEventSink_VTable
;
5406 fimpl
->IGraphConfig_vtbl
= &IGraphConfig_VTable
;
5407 fimpl
->IMediaPosition_vtbl
= &IMediaPosition_VTable
;
5409 fimpl
->ppFiltersInGraph
= NULL
;
5410 fimpl
->pFilterNames
= NULL
;
5411 fimpl
->nFilters
= 0;
5412 fimpl
->filterCapacity
= 0;
5413 fimpl
->nameIndex
= 1;
5414 fimpl
->refClock
= NULL
;
5415 fimpl
->hEventCompletion
= CreateEventW(0, TRUE
, FALSE
, 0);
5416 fimpl
->HandleEcComplete
= TRUE
;
5417 fimpl
->HandleEcRepaint
= TRUE
;
5418 fimpl
->HandleEcClockChanged
= TRUE
;
5419 fimpl
->notif
.hWnd
= 0;
5420 fimpl
->notif
.disabled
= FALSE
;
5421 fimpl
->nRenderers
= 0;
5422 fimpl
->EcCompleteCount
= 0;
5423 fimpl
->state
= State_Stopped
;
5424 EventsQueue_Init(&fimpl
->evqueue
);
5425 InitializeCriticalSection(&fimpl
->cs
);
5426 fimpl
->cs
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": IFilterGraphImpl.cs");
5427 fimpl
->nItfCacheEntries
= 0;
5428 memcpy(&fimpl
->timeformatseek
, &TIME_FORMAT_MEDIA_TIME
, sizeof(GUID
));
5429 fimpl
->start_time
= fimpl
->position
= 0;
5430 fimpl
->stop_position
= -1;
5431 fimpl
->punkFilterMapper2
= NULL
;
5433 /* create Filtermapper aggregated. */
5434 hr
= CoCreateInstance(&CLSID_FilterMapper2
, pUnkOuter
? pUnkOuter
: (IUnknown
*)&fimpl
->IInner_vtbl
, CLSCTX_INPROC_SERVER
,
5435 &IID_IUnknown
, (LPVOID
*)&fimpl
->punkFilterMapper2
);
5437 if (SUCCEEDED(hr
)) {
5438 hr
= IUnknown_QueryInterface(fimpl
->punkFilterMapper2
, &IID_IFilterMapper2
, (LPVOID
*)&fimpl
->pFilterMapper2
);
5441 if (SUCCEEDED(hr
)) {
5442 /* Release controlling IUnknown - compensate refcount increase from caching IFilterMapper2 interface. */
5443 if (pUnkOuter
) IUnknown_Release(pUnkOuter
);
5444 else IUnknown_Release((IUnknown
*)&fimpl
->IInner_vtbl
);
5448 ERR("Unable to create filter mapper (%x)\n", hr
);
5449 if (fimpl
->punkFilterMapper2
) IUnknown_Release(fimpl
->punkFilterMapper2
);
5450 CloseHandle(fimpl
->hEventCompletion
);
5451 EventsQueue_Destroy(&fimpl
->evqueue
);
5452 fimpl
->cs
.DebugInfo
->Spare
[0] = 0;
5453 DeleteCriticalSection(&fimpl
->cs
);
5454 CoTaskMemFree(fimpl
);
5457 IFilterGraph2_SetDefaultSyncSource((IFilterGraph2
*)fimpl
);
5463 HRESULT
FilterGraphNoThread_create(IUnknown
*pUnkOuter
, LPVOID
*ppObj
)
5465 FIXME("CLSID_FilterGraphNoThread partially implemented - Forwarding to CLSID_FilterGraph\n");
5466 return FilterGraph_create(pUnkOuter
, ppObj
);