?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winex11: Consider zero-size windows mapped even when they are positioned at 0,0.
[wine/multimedia.git] / dlls / quartz / filtergraph.c
blob32aa56931ed44c98d223e99db4c6224ef3aa6797
1 /* DirectShow FilterGraph object (QUARTZ.DLL)
2 *
3 * Copyright 2002 Lionel Ulmer
4 * Copyright 2004 Christian Costa
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include <stdarg.h>
23
24 #define COBJMACROS
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "winreg.h"
30 #include "shlwapi.h"
31 #include "dshow.h"
32 #include "wine/debug.h"
33 #include "quartz_private.h"
34 #include "ole2.h"
35 #include "olectl.h"
36 #include "strmif.h"
37 #include "vfwmsgs.h"
38 #include "evcode.h"
39 #include "wine/unicode.h"
40
41
42 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
43
44 typedef struct {
45 HWND hWnd; /* Target window */
46 UINT msg; /* User window message */
47 LONG_PTR instance; /* User data */
48 int disabled; /* Disabled messages posting */
49 } WndNotify;
50
51 typedef struct {
52 LONG lEventCode; /* Event code */
53 LONG_PTR lParam1; /* Param1 */
54 LONG_PTR lParam2; /* Param2 */
55 } Event;
56
57 /* messages ring implementation for queuing events (taken from winmm) */
58 #define EVENTS_RING_BUFFER_INCREMENT 64
59 typedef struct {
60 Event* messages;
61 int ring_buffer_size;
62 int msg_tosave;
63 int msg_toget;
64 CRITICAL_SECTION msg_crst;
65 HANDLE msg_event; /* Signaled for no empty queue */
66 } EventsQueue;
67
68 static int EventsQueue_Init(EventsQueue* omr)
69 {
70 omr->msg_toget = 0;
71 omr->msg_tosave = 0;
72 omr->msg_event = CreateEventW(NULL, TRUE, FALSE, NULL);
73 omr->ring_buffer_size = EVENTS_RING_BUFFER_INCREMENT;
74 omr->messages = CoTaskMemAlloc(omr->ring_buffer_size * sizeof(Event));
75 ZeroMemory(omr->messages, omr->ring_buffer_size * sizeof(Event));
76
77 InitializeCriticalSection(&omr->msg_crst);
78 omr->msg_crst.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": EventsQueue.msg_crst");
79 return TRUE;
80 }
81
82 static int EventsQueue_Destroy(EventsQueue* omr)
83 {
84 CloseHandle(omr->msg_event);
85 CoTaskMemFree(omr->messages);
86 omr->msg_crst.DebugInfo->Spare[0] = 0;
87 DeleteCriticalSection(&omr->msg_crst);
88 return TRUE;
89 }
90
91 static int EventsQueue_PutEvent(EventsQueue* omr, const Event* evt)
92 {
93 EnterCriticalSection(&omr->msg_crst);
94 if (omr->msg_toget == ((omr->msg_tosave + 1) % omr->ring_buffer_size))
95 {
96 int old_ring_buffer_size = omr->ring_buffer_size;
97 omr->ring_buffer_size += EVENTS_RING_BUFFER_INCREMENT;
98 TRACE("omr->ring_buffer_size=%d\n",omr->ring_buffer_size);
99 omr->messages = CoTaskMemRealloc(omr->messages, omr->ring_buffer_size * sizeof(Event));
100 /* Now we need to rearrange the ring buffer so that the new
101 buffers just allocated are in between omr->msg_tosave and
102 omr->msg_toget.
103 */
104 if (omr->msg_tosave < omr->msg_toget)
105 {
106 memmove(&(omr->messages[omr->msg_toget + EVENTS_RING_BUFFER_INCREMENT]),
107 &(omr->messages[omr->msg_toget]),
108 sizeof(Event)*(old_ring_buffer_size - omr->msg_toget)
109 );
110 omr->msg_toget += EVENTS_RING_BUFFER_INCREMENT;
111 }
112 }
113 omr->messages[omr->msg_tosave] = *evt;
114 SetEvent(omr->msg_event);
115 omr->msg_tosave = (omr->msg_tosave + 1) % omr->ring_buffer_size;
116 LeaveCriticalSection(&omr->msg_crst);
117 return TRUE;
118 }
119
120 static int EventsQueue_GetEvent(EventsQueue* omr, Event* evt, LONG msTimeOut)
121 {
122 if (WaitForSingleObject(omr->msg_event, msTimeOut) != WAIT_OBJECT_0)
123 return FALSE;
124
125 EnterCriticalSection(&omr->msg_crst);
126
127 if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
128 {
129 LeaveCriticalSection(&omr->msg_crst);
130 return FALSE;
131 }
132
133 *evt = omr->messages[omr->msg_toget];
134 omr->msg_toget = (omr->msg_toget + 1) % omr->ring_buffer_size;
135
136 /* Mark the buffer as empty if needed */
137 if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
138 ResetEvent(omr->msg_event);
139
140 LeaveCriticalSection(&omr->msg_crst);
141 return TRUE;
142 }
143
144 #define MAX_ITF_CACHE_ENTRIES 3
145 typedef struct _ITF_CACHE_ENTRY {
146 const IID* riid;
147 IBaseFilter* filter;
148 IUnknown* iface;
149 } ITF_CACHE_ENTRY;
150
151 typedef struct _IFilterGraphImpl {
152 IFilterGraph2 IFilterGraph2_iface;
153 IMediaControl IMediaControl_iface;
154 IMediaSeeking IMediaSeeking_iface;
155 IBasicAudio IBasicAudio_iface;
156 IBasicVideo2 IBasicVideo2_iface;
157 IVideoWindow IVideoWindow_iface;
158 IMediaEventEx IMediaEventEx_iface;
159 IMediaFilter IMediaFilter_iface;
160 IMediaEventSink IMediaEventSink_iface;
161 IGraphConfig IGraphConfig_iface;
162 IMediaPosition IMediaPosition_iface;
163 IObjectWithSite IObjectWithSite_iface;
164 const IUnknownVtbl * IInner_vtbl;
165 /* IAMGraphStreams */
166 /* IAMStats */
167 /* IFilterChain */
168 /* IFilterMapper2 */
169 /* IGraphVersion */
170 /* IQueueCommand */
171 /* IRegisterServiceProvider */
172 /* IResourceMananger */
173 /* IServiceProvider */
174 /* IVideoFrameStep */
175
176 LONG ref;
177 IUnknown *punkFilterMapper2;
178 IFilterMapper2 * pFilterMapper2;
179 IBaseFilter ** ppFiltersInGraph;
180 LPWSTR * pFilterNames;
181 int nFilters;
182 int filterCapacity;
183 LONG nameIndex;
184 IReferenceClock *refClock;
185 IBaseFilter *refClockProvider;
186 EventsQueue evqueue;
187 HANDLE hEventCompletion;
188 int CompletionStatus;
189 WndNotify notif;
190 int nRenderers;
191 int EcCompleteCount;
192 int HandleEcComplete;
193 int HandleEcRepaint;
194 int HandleEcClockChanged;
195 OAFilterState state;
196 CRITICAL_SECTION cs;
197 ITF_CACHE_ENTRY ItfCacheEntries[MAX_ITF_CACHE_ENTRIES];
198 int nItfCacheEntries;
199 IUnknown * pUnkOuter;
200 BOOL bUnkOuterValid;
201 BOOL bAggregatable;
202 BOOL defaultclock;
203 GUID timeformatseek;
204 REFERENCE_TIME start_time;
205 REFERENCE_TIME pause_time;
206 LONGLONG stop_position;
207 LONG recursioncount;
208 IUnknown *pSite;
209 } IFilterGraphImpl;
210
211 static HRESULT Filtergraph_QueryInterface(IFilterGraphImpl *This,
212 REFIID riid, LPVOID * ppv);
213 static ULONG Filtergraph_AddRef(IFilterGraphImpl *This);
214 static ULONG Filtergraph_Release(IFilterGraphImpl *This);
215
216 static HRESULT WINAPI FilterGraphInner_QueryInterface(IUnknown * iface,
217 REFIID riid,
218 LPVOID *ppvObj) {
219 ICOM_THIS_MULTI(IFilterGraphImpl, IInner_vtbl, iface);
220 TRACE("(%p)->(%s (%p), %p)\n", This, debugstr_guid(riid), riid, ppvObj);
221
222 if (This->bAggregatable)
223 This->bUnkOuterValid = TRUE;
224
225 if (IsEqualGUID(&IID_IUnknown, riid)) {
226 *ppvObj = &(This->IInner_vtbl);
227 TRACE(" returning IUnknown interface (%p)\n", *ppvObj);
228 } else if (IsEqualGUID(&IID_IFilterGraph, riid) ||
229 IsEqualGUID(&IID_IFilterGraph2, riid) ||
230 IsEqualGUID(&IID_IGraphBuilder, riid)) {
231 *ppvObj = &This->IFilterGraph2_iface;
232 TRACE(" returning IGraphBuilder interface (%p)\n", *ppvObj);
233 } else if (IsEqualGUID(&IID_IMediaControl, riid)) {
234 *ppvObj = &This->IMediaControl_iface;
235 TRACE(" returning IMediaControl interface (%p)\n", *ppvObj);
236 } else if (IsEqualGUID(&IID_IMediaSeeking, riid)) {
237 *ppvObj = &This->IMediaSeeking_iface;
238 TRACE(" returning IMediaSeeking interface (%p)\n", *ppvObj);
239 } else if (IsEqualGUID(&IID_IBasicAudio, riid)) {
240 *ppvObj = &This->IBasicAudio_iface;
241 TRACE(" returning IBasicAudio interface (%p)\n", *ppvObj);
242 } else if (IsEqualGUID(&IID_IBasicVideo, riid) ||
243 IsEqualGUID(&IID_IBasicVideo2, riid)) {
244 *ppvObj = &This->IBasicVideo2_iface;
245 TRACE(" returning IBasicVideo2 interface (%p)\n", *ppvObj);
246 } else if (IsEqualGUID(&IID_IVideoWindow, riid)) {
247 *ppvObj = &This->IVideoWindow_iface;
248 TRACE(" returning IVideoWindow interface (%p)\n", *ppvObj);
249 } else if (IsEqualGUID(&IID_IMediaEvent, riid) ||
250 IsEqualGUID(&IID_IMediaEventEx, riid)) {
251 *ppvObj = &This->IMediaEventEx_iface;
252 TRACE(" returning IMediaEvent(Ex) interface (%p)\n", *ppvObj);
253 } else if (IsEqualGUID(&IID_IMediaFilter, riid) ||
254 IsEqualGUID(&IID_IPersist, riid)) {
255 *ppvObj = &This->IMediaFilter_iface;
256 TRACE(" returning IMediaFilter interface (%p)\n", *ppvObj);
257 } else if (IsEqualGUID(&IID_IMediaEventSink, riid)) {
258 *ppvObj = &This->IMediaEventSink_iface;
259 TRACE(" returning IMediaEventSink interface (%p)\n", *ppvObj);
260 } else if (IsEqualGUID(&IID_IGraphConfig, riid)) {
261 *ppvObj = &This->IGraphConfig_iface;
262 TRACE(" returning IGraphConfig interface (%p)\n", *ppvObj);
263 } else if (IsEqualGUID(&IID_IMediaPosition, riid)) {
264 *ppvObj = &This->IMediaPosition_iface;
265 TRACE(" returning IMediaPosition interface (%p)\n", *ppvObj);
266 } else if (IsEqualGUID(&IID_IObjectWithSite, riid)) {
267 *ppvObj = &This->IObjectWithSite_iface;
268 TRACE(" returning IObjectWithSite interface (%p)\n", *ppvObj);
269 } else if (IsEqualGUID(&IID_IFilterMapper, riid)) {
270 TRACE(" requesting IFilterMapper interface from aggregated filtermapper (%p)\n", *ppvObj);
271 return IUnknown_QueryInterface(This->punkFilterMapper2, riid, ppvObj);
272 } else if (IsEqualGUID(&IID_IFilterMapper2, riid)) {
273 *ppvObj = This->pFilterMapper2;
274 TRACE(" returning IFilterMapper2 interface from aggregated filtermapper (%p)\n", *ppvObj);
275 } else if (IsEqualGUID(&IID_IFilterMapper3, riid)) {
276 *ppvObj = This->pFilterMapper2;
277 TRACE(" returning IFilterMapper3 interface from aggregated filtermapper (%p)\n", *ppvObj);
278 } else {
279 *ppvObj = NULL;
280 FIXME("unknown interface %s\n", debugstr_guid(riid));
281 return E_NOINTERFACE;
282 }
283
284 IUnknown_AddRef((IUnknown *)(*ppvObj));
285 return S_OK;
286 }
287
288 static ULONG WINAPI FilterGraphInner_AddRef(IUnknown * iface) {
289 ICOM_THIS_MULTI(IFilterGraphImpl, IInner_vtbl, iface);
290 ULONG ref = InterlockedIncrement(&This->ref);
291
292 TRACE("(%p)->(): new ref = %d\n", This, ref);
293
294 return ref;
295 }
296
297 static ULONG WINAPI FilterGraphInner_Release(IUnknown * iface)
298 {
299 ICOM_THIS_MULTI(IFilterGraphImpl, IInner_vtbl, iface);
300 ULONG ref = InterlockedDecrement(&This->ref);
301
302 TRACE("(%p)->(): new ref = %d\n", This, ref);
303
304 if (ref == 0) {
305 int i;
306
307 This->ref = 1; /* guard against reentrancy (aggregation). */
308
309 IMediaControl_Stop(&This->IMediaControl_iface);
310
311 while (This->nFilters)
312 IFilterGraph2_RemoveFilter((IFilterGraph2*)This, This->ppFiltersInGraph[0]);
313
314 if (This->refClock)
315 IReferenceClock_Release(This->refClock);
316
317 for (i = 0; i < This->nItfCacheEntries; i++)
318 {
319 if (This->ItfCacheEntries[i].iface)
320 IUnknown_Release(This->ItfCacheEntries[i].iface);
321 }
322
323 /* AddRef on controlling IUnknown, to compensate for Release of cached IFilterMapper2 interface below.
324
325 * NOTE: Filtergraph_AddRef isn't suitable, because bUnkOuterValid may be FALSE but punkOuter non-NULL
326 * and already passed as punkOuter to filtermapper in FilterGraph_create - this will happen in case of
327 * CoCreateInstance of filtergraph with non-null pUnkOuter and REFIID other than IID_Unknown that is
328 * cleaning up after error. */
329 if (This->pUnkOuter) IUnknown_AddRef(This->pUnkOuter);
330 else IUnknown_AddRef((IUnknown*)&This->IInner_vtbl);
331
332 IFilterMapper2_Release(This->pFilterMapper2);
333 IUnknown_Release(This->punkFilterMapper2);
334
335 if (This->pSite) IUnknown_Release(This->pSite);
336
337 CloseHandle(This->hEventCompletion);
338 EventsQueue_Destroy(&This->evqueue);
339 This->cs.DebugInfo->Spare[0] = 0;
340 DeleteCriticalSection(&This->cs);
341 CoTaskMemFree(This->ppFiltersInGraph);
342 CoTaskMemFree(This->pFilterNames);
343 CoTaskMemFree(This);
344 }
345 return ref;
346 }
347
348 static inline IFilterGraphImpl *impl_from_IFilterGraph2(IFilterGraph2 *iface)
349 {
350 return CONTAINING_RECORD(iface, IFilterGraphImpl, IFilterGraph2_iface);
351 }
352
353 static HRESULT WINAPI FilterGraph2_QueryInterface(IFilterGraph2 *iface, REFIID riid, void **ppvObj)
354 {
355 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
356
357 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
358
359 return Filtergraph_QueryInterface(This, riid, ppvObj);
360 }
361
362 static ULONG WINAPI FilterGraph2_AddRef(IFilterGraph2 *iface)
363 {
364 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
365
366 TRACE("(%p/%p)->() calling FilterGraph AddRef\n", This, iface);
367
368 return Filtergraph_AddRef(This);
369 }
370
371 static ULONG WINAPI FilterGraph2_Release(IFilterGraph2 *iface)
372 {
373 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
374
375 TRACE("(%p/%p)->() calling FilterGraph Release\n", This, iface);
376
377 return Filtergraph_Release(This);
378 }
379
380 /*** IFilterGraph methods ***/
381 static HRESULT WINAPI FilterGraph2_AddFilter(IFilterGraph2 *iface, IBaseFilter *pFilter,
382 LPCWSTR pName)
383 {
384 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
385 HRESULT hr;
386 int i,j;
387 WCHAR* wszFilterName = NULL;
388 int duplicate_name = FALSE;
389
390 TRACE("(%p/%p)->(%p, %s (%p))\n", This, iface, pFilter, debugstr_w(pName), pName);
391
392 if (!pFilter)
393 return E_POINTER;
394
395 wszFilterName = CoTaskMemAlloc( (pName ? strlenW(pName) + 6 : 5) * sizeof(WCHAR) );
396
397 if (pName)
398 {
399 /* Check if name already exists */
400 for(i = 0; i < This->nFilters; i++)
401 if (!strcmpW(This->pFilterNames[i], pName))
402 {
403 duplicate_name = TRUE;
404 break;
405 }
406 }
407
408 /* If no name given or name already existing, generate one */
409 if (!pName || duplicate_name)
410 {
411 static const WCHAR wszFmt1[] = {'%','s',' ','%','0','4','d',0};
412 static const WCHAR wszFmt2[] = {'%','0','4','d',0};
413
414 for (j = 0; j < 10000 ; j++)
415 {
416 /* Create name */
417 if (pName)
418 sprintfW(wszFilterName, wszFmt1, pName, This->nameIndex);
419 else
420 sprintfW(wszFilterName, wszFmt2, This->nameIndex);
421 TRACE("Generated name %s\n", debugstr_w(wszFilterName));
422
423 /* Check if the generated name already exists */
424 for(i = 0; i < This->nFilters; i++)
425 if (!strcmpW(This->pFilterNames[i], wszFilterName))
426 break;
427
428 /* Compute next index and exit if generated name is suitable */
429 if (This->nameIndex++ == 10000)
430 This->nameIndex = 1;
431 if (i == This->nFilters)
432 break;
433 }
434 /* Unable to find a suitable name */
435 if (j == 10000)
436 {
437 CoTaskMemFree(wszFilterName);
438 return VFW_E_DUPLICATE_NAME;
439 }
440 }
441 else
442 memcpy(wszFilterName, pName, (strlenW(pName) + 1) * sizeof(WCHAR));
443
444 if (This->nFilters + 1 > This->filterCapacity)
445 {
446 int newCapacity = This->filterCapacity ? 2 * This->filterCapacity : 1;
447 IBaseFilter ** ppNewFilters = CoTaskMemAlloc(newCapacity * sizeof(IBaseFilter*));
448 LPWSTR * pNewNames = CoTaskMemAlloc(newCapacity * sizeof(LPWSTR));
449 memcpy(ppNewFilters, This->ppFiltersInGraph, This->nFilters * sizeof(IBaseFilter*));
450 memcpy(pNewNames, This->pFilterNames, This->nFilters * sizeof(LPWSTR));
451 if (This->filterCapacity)
452 {
453 CoTaskMemFree(This->ppFiltersInGraph);
454 CoTaskMemFree(This->pFilterNames);
455 }
456 This->ppFiltersInGraph = ppNewFilters;
457 This->pFilterNames = pNewNames;
458 This->filterCapacity = newCapacity;
459 }
460
461 hr = IBaseFilter_JoinFilterGraph(pFilter, (IFilterGraph *)This, wszFilterName);
462
463 if (SUCCEEDED(hr))
464 {
465 IBaseFilter_AddRef(pFilter);
466 This->ppFiltersInGraph[This->nFilters] = pFilter;
467 This->pFilterNames[This->nFilters] = wszFilterName;
468 This->nFilters++;
469 IBaseFilter_SetSyncSource(pFilter, This->refClock);
470 }
471 else
472 CoTaskMemFree(wszFilterName);
473
474 if (SUCCEEDED(hr) && duplicate_name)
475 return VFW_S_DUPLICATE_NAME;
476
477 return hr;
478 }
479
480 static HRESULT WINAPI FilterGraph2_RemoveFilter(IFilterGraph2 *iface, IBaseFilter *pFilter)
481 {
482 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
483 int i;
484 HRESULT hr = E_FAIL;
485
486 TRACE("(%p/%p)->(%p)\n", This, iface, pFilter);
487
488 /* FIXME: check graph is stopped */
489
490 for (i = 0; i < This->nFilters; i++)
491 {
492 if (This->ppFiltersInGraph[i] == pFilter)
493 {
494 IEnumPins *penumpins = NULL;
495 FILTER_STATE state;
496
497 if (This->defaultclock && This->refClockProvider == pFilter)
498 {
499 IMediaFilter_SetSyncSource(&This->IMediaFilter_iface, NULL);
500 This->defaultclock = 1;
501 }
502
503 TRACE("Removing filter %s\n", debugstr_w(This->pFilterNames[i]));
504 IBaseFilter_GetState(pFilter, 0, &state);
505 if (state == State_Running)
506 IBaseFilter_Pause(pFilter);
507 if (state != State_Stopped)
508 IBaseFilter_Stop(pFilter);
509
510 hr = IBaseFilter_EnumPins(pFilter, &penumpins);
511 if (SUCCEEDED(hr)) {
512 IPin *ppin;
513 while(IEnumPins_Next(penumpins, 1, &ppin, NULL) == S_OK)
514 {
515 IPin *victim = NULL;
516 HRESULT h;
517 IPin_ConnectedTo(ppin, &victim);
518 if (victim)
519 {
520 h = IPin_Disconnect(victim);
521 TRACE("Disconnect other side: %08x\n", h);
522 if (h == VFW_E_NOT_STOPPED)
523 {
524 PIN_INFO pinfo;
525 IPin_QueryPinInfo(victim, &pinfo);
526
527 IBaseFilter_GetState(pinfo.pFilter, 0, &state);
528 if (state == State_Running)
529 IBaseFilter_Pause(pinfo.pFilter);
530 IBaseFilter_Stop(pinfo.pFilter);
531 IBaseFilter_Release(pinfo.pFilter);
532 h = IPin_Disconnect(victim);
533 TRACE("Disconnect retry: %08x\n", h);
534 }
535 IPin_Release(victim);
536 }
537 h = IPin_Disconnect(ppin);
538 TRACE("Disconnect 2: %08x\n", h);
539
540 IPin_Release(ppin);
541 }
542 IEnumPins_Release(penumpins);
543 }
544
545 hr = IBaseFilter_JoinFilterGraph(pFilter, NULL, This->pFilterNames[i]);
546 if (SUCCEEDED(hr))
547 {
548 IBaseFilter_SetSyncSource(pFilter, NULL);
549 IBaseFilter_Release(pFilter);
550 CoTaskMemFree(This->pFilterNames[i]);
551 memmove(This->ppFiltersInGraph+i, This->ppFiltersInGraph+i+1, sizeof(IBaseFilter*)*(This->nFilters - 1 - i));
552 memmove(This->pFilterNames+i, This->pFilterNames+i+1, sizeof(LPWSTR)*(This->nFilters - 1 - i));
553 This->nFilters--;
554 /* Invalidate interfaces in the cache */
555 for (i = 0; i < This->nItfCacheEntries; i++)
556 if (pFilter == This->ItfCacheEntries[i].filter)
557 {
558 IUnknown_Release(This->ItfCacheEntries[i].iface);
559 This->ItfCacheEntries[i].iface = NULL;
560 This->ItfCacheEntries[i].filter = NULL;
561 }
562 return S_OK;
563 }
564 break;
565 }
566 }
567
568 return hr; /* FIXME: check this error code */
569 }
570
571 static HRESULT WINAPI FilterGraph2_EnumFilters(IFilterGraph2 *iface, IEnumFilters **ppEnum)
572 {
573 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
574
575 TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
576
577 return IEnumFiltersImpl_Construct(This->ppFiltersInGraph, This->nFilters, ppEnum);
578 }
579
580 static HRESULT WINAPI FilterGraph2_FindFilterByName(IFilterGraph2 *iface, LPCWSTR pName,
581 IBaseFilter **ppFilter)
582 {
583 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
584 int i;
585
586 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_w(pName), pName, ppFilter);
587
588 if (!ppFilter)
589 return E_POINTER;
590
591 for (i = 0; i < This->nFilters; i++)
592 {
593 if (!strcmpW(pName, This->pFilterNames[i]))
594 {
595 *ppFilter = This->ppFiltersInGraph[i];
596 IBaseFilter_AddRef(*ppFilter);
597 return S_OK;
598 }
599 }
600
601 *ppFilter = NULL;
602 return VFW_E_NOT_FOUND;
603 }
604
605 /* Don't allow a circular connection to form, return VFW_E_CIRCULAR_GRAPH if this would be the case.
606 * A circular connection will be formed if from the filter of the output pin, the input pin can be reached
607 */
608 static HRESULT CheckCircularConnection(IFilterGraphImpl *This, IPin *out, IPin *in)
609 {
610 #if 1
611 HRESULT hr;
612 PIN_INFO info_out, info_in;
613
614 hr = IPin_QueryPinInfo(out, &info_out);
615 if (FAILED(hr))
616 return hr;
617 if (info_out.dir != PINDIR_OUTPUT)
618 {
619 IBaseFilter_Release(info_out.pFilter);
620 return E_UNEXPECTED;
621 }
622
623 hr = IPin_QueryPinInfo(in, &info_in);
624 if (SUCCEEDED(hr))
625 IBaseFilter_Release(info_in.pFilter);
626 if (FAILED(hr))
627 goto out;
628 if (info_in.dir != PINDIR_INPUT)
629 {
630 hr = E_UNEXPECTED;
631 goto out;
632 }
633
634 if (info_out.pFilter == info_in.pFilter)
635 hr = VFW_E_CIRCULAR_GRAPH;
636 else
637 {
638 IEnumPins *enumpins;
639 IPin *test;
640
641 hr = IBaseFilter_EnumPins(info_out.pFilter, &enumpins);
642 if (FAILED(hr))
643 goto out;
644
645 IEnumPins_Reset(enumpins);
646 while ((hr = IEnumPins_Next(enumpins, 1, &test, NULL)) == S_OK)
647 {
648 PIN_DIRECTION dir = PINDIR_OUTPUT;
649 IPin_QueryDirection(test, &dir);
650 if (dir == PINDIR_INPUT)
651 {
652 IPin *victim = NULL;
653 IPin_ConnectedTo(test, &victim);
654 if (victim)
655 {
656 hr = CheckCircularConnection(This, victim, in);
657 IPin_Release(victim);
658 if (FAILED(hr))
659 {
660 IPin_Release(test);
661 break;
662 }
663 }
664 }
665 IPin_Release(test);
666 }
667 IEnumPins_Release(enumpins);
668 }
669
670 out:
671 IBaseFilter_Release(info_out.pFilter);
672 if (FAILED(hr))
673 ERR("Checking filtergraph returned %08x, something's not right!\n", hr);
674 return hr;
675 #else
676 /* Debugging filtergraphs not enabled */
677 return S_OK;
678 #endif
679 }
680
681
682 /* NOTE: despite the implication, it doesn't matter which
683 * way round you put in the input and output pins */
684 static HRESULT WINAPI FilterGraph2_ConnectDirect(IFilterGraph2 *iface, IPin *ppinIn, IPin *ppinOut,
685 const AM_MEDIA_TYPE *pmt)
686 {
687 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
688 PIN_DIRECTION dir;
689 HRESULT hr;
690
691 TRACE("(%p/%p)->(%p, %p, %p)\n", This, iface, ppinIn, ppinOut, pmt);
692
693 /* FIXME: check pins are in graph */
694
695 if (TRACE_ON(quartz))
696 {
697 PIN_INFO PinInfo;
698
699 hr = IPin_QueryPinInfo(ppinIn, &PinInfo);
700 if (FAILED(hr))
701 return hr;
702
703 TRACE("Filter owning first pin => %p\n", PinInfo.pFilter);
704 IBaseFilter_Release(PinInfo.pFilter);
705
706 hr = IPin_QueryPinInfo(ppinOut, &PinInfo);
707 if (FAILED(hr))
708 return hr;
709
710 TRACE("Filter owning second pin => %p\n", PinInfo.pFilter);
711 IBaseFilter_Release(PinInfo.pFilter);
712 }
713
714 hr = IPin_QueryDirection(ppinIn, &dir);
715 if (SUCCEEDED(hr))
716 {
717 if (dir == PINDIR_INPUT)
718 {
719 hr = CheckCircularConnection(This, ppinOut, ppinIn);
720 if (SUCCEEDED(hr))
721 hr = IPin_Connect(ppinOut, ppinIn, pmt);
722 }
723 else
724 {
725 hr = CheckCircularConnection(This, ppinIn, ppinOut);
726 if (SUCCEEDED(hr))
727 hr = IPin_Connect(ppinIn, ppinOut, pmt);
728 }
729 }
730
731 return hr;
732 }
733
734 static HRESULT WINAPI FilterGraph2_Reconnect(IFilterGraph2 *iface, IPin *ppin)
735 {
736 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
737 IPin *pConnectedTo = NULL;
738 HRESULT hr;
739 PIN_DIRECTION pindir;
740
741 IPin_QueryDirection(ppin, &pindir);
742 hr = IPin_ConnectedTo(ppin, &pConnectedTo);
743 if (FAILED(hr)) {
744 TRACE("Querying connected to failed: %x\n", hr);
745 return hr;
746 }
747 IPin_Disconnect(ppin);
748 IPin_Disconnect(pConnectedTo);
749 if (pindir == PINDIR_INPUT)
750 hr = IPin_Connect(pConnectedTo, ppin, NULL);
751 else
752 hr = IPin_Connect(ppin, pConnectedTo, NULL);
753 IPin_Release(pConnectedTo);
754 if (FAILED(hr))
755 WARN("Reconnecting pins failed, pins are not connected now..\n");
756 TRACE("(%p->%p) -- %p %p -> %x\n", iface, This, ppin, pConnectedTo, hr);
757 return hr;
758 }
759
760 static HRESULT WINAPI FilterGraph2_Disconnect(IFilterGraph2 *iface, IPin *ppin)
761 {
762 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
763
764 TRACE("(%p/%p)->(%p)\n", This, iface, ppin);
765
766 if (!ppin)
767 return E_POINTER;
768
769 return IPin_Disconnect(ppin);
770 }
771
772 static HRESULT WINAPI FilterGraph2_SetDefaultSyncSource(IFilterGraph2 *iface)
773 {
774 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
775 IReferenceClock *pClock = NULL;
776 HRESULT hr = S_OK;
777 int i;
778
779 TRACE("(%p/%p)->() live sources not handled properly!\n", iface, This);
780
781 EnterCriticalSection(&This->cs);
782
783 for (i = 0; i < This->nFilters; ++i)
784 {
785 DWORD miscflags;
786 IAMFilterMiscFlags *flags = NULL;
787 IUnknown_QueryInterface(This->ppFiltersInGraph[i], &IID_IAMFilterMiscFlags, (void**)&flags);
788 if (!flags)
789 continue;
790 miscflags = IAMFilterMiscFlags_GetMiscFlags(flags);
791 IUnknown_Release(flags);
792 if (miscflags == AM_FILTER_MISC_FLAGS_IS_RENDERER)
793 IUnknown_QueryInterface(This->ppFiltersInGraph[i], &IID_IReferenceClock, (void**)&pClock);
794 if (pClock)
795 break;
796 }
797
798 if (!pClock)
799 {
800 hr = CoCreateInstance(&CLSID_SystemClock, NULL, CLSCTX_INPROC_SERVER, &IID_IReferenceClock, (LPVOID*)&pClock);
801 This->refClockProvider = NULL;
802 }
803 else
804 This->refClockProvider = This->ppFiltersInGraph[i];
805
806 if (SUCCEEDED(hr))
807 {
808 hr = IMediaFilter_SetSyncSource(&This->IMediaFilter_iface, pClock);
809 This->defaultclock = TRUE;
810 IReferenceClock_Release(pClock);
811 }
812 LeaveCriticalSection(&This->cs);
813
814 return hr;
815 }
816
817 static HRESULT GetFilterInfo(IMoniker* pMoniker, GUID* pclsid, VARIANT* pvar)
818 {
819 static const WCHAR wszClsidName[] = {'C','L','S','I','D',0};
820 static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
821 IPropertyBag * pPropBagCat = NULL;
822 HRESULT hr;
823
824 VariantInit(pvar);
825
826 hr = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (LPVOID*)&pPropBagCat);
827
828 if (SUCCEEDED(hr))
829 hr = IPropertyBag_Read(pPropBagCat, wszClsidName, pvar, NULL);
830
831 if (SUCCEEDED(hr))
832 hr = CLSIDFromString(V_UNION(pvar, bstrVal), pclsid);
833
834 VariantClear(pvar);
835
836 if (SUCCEEDED(hr))
837 hr = IPropertyBag_Read(pPropBagCat, wszFriendlyName, pvar, NULL);
838
839 if (SUCCEEDED(hr))
840 TRACE("Moniker = %s - %s\n", debugstr_guid(pclsid), debugstr_w(V_UNION(pvar, bstrVal)));
841
842 if (pPropBagCat)
843 IPropertyBag_Release(pPropBagCat);
844
845 return hr;
846 }
847
848 static HRESULT GetInternalConnections(IBaseFilter* pfilter, IPin* pinputpin, IPin*** pppins, ULONG* pnb)
849 {
850 HRESULT hr;
851 ULONG nb = 0;
852
853 TRACE("(%p, %p, %p, %p)\n", pfilter, pinputpin, pppins, pnb);
854 hr = IPin_QueryInternalConnections(pinputpin, NULL, &nb);
855 if (hr == S_OK) {
856 /* Rendered input */
857 } else if (hr == S_FALSE) {
858 *pppins = CoTaskMemAlloc(sizeof(IPin*)*nb);
859 hr = IPin_QueryInternalConnections(pinputpin, *pppins, &nb);
860 if (hr != S_OK) {
861 WARN("Error (%x)\n", hr);
862 }
863 } else if (hr == E_NOTIMPL) {
864 /* Input connected to all outputs */
865 IEnumPins* penumpins;
866 IPin* ppin;
867 int i = 0;
868 TRACE("E_NOTIMPL\n");
869 hr = IBaseFilter_EnumPins(pfilter, &penumpins);
870 if (FAILED(hr)) {
871 WARN("filter Enumpins failed (%x)\n", hr);
872 return hr;
873 }
874 i = 0;
875 /* Count output pins */
876 while(IEnumPins_Next(penumpins, 1, &ppin, &nb) == S_OK) {
877 PIN_DIRECTION pindir;
878 IPin_QueryDirection(ppin, &pindir);
879 if (pindir == PINDIR_OUTPUT)
880 i++;
881 IPin_Release(ppin);
882 }
883 *pppins = CoTaskMemAlloc(sizeof(IPin*)*i);
884 /* Retrieve output pins */
885 IEnumPins_Reset(penumpins);
886 i = 0;
887 while(IEnumPins_Next(penumpins, 1, &ppin, &nb) == S_OK) {
888 PIN_DIRECTION pindir;
889 IPin_QueryDirection(ppin, &pindir);
890 if (pindir == PINDIR_OUTPUT)
891 (*pppins)[i++] = ppin;
892 else
893 IPin_Release(ppin);
894 }
895 IEnumPins_Release(penumpins);
896 nb = i;
897 if (FAILED(hr)) {
898 WARN("Next failed (%x)\n", hr);
899 return hr;
900 }
901 } else if (FAILED(hr)) {
902 WARN("Cannot get internal connection (%x)\n", hr);
903 return hr;
904 }
905
906 *pnb = nb;
907 return S_OK;
908 }
909
910 /*** IGraphBuilder methods ***/
911 static HRESULT WINAPI FilterGraph2_Connect(IFilterGraph2 *iface, IPin *ppinOut, IPin *ppinIn)
912 {
913 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
914 HRESULT hr;
915 AM_MEDIA_TYPE* mt = NULL;
916 IEnumMediaTypes* penummt = NULL;
917 ULONG nbmt;
918 IEnumPins* penumpins;
919 IEnumMoniker* pEnumMoniker;
920 GUID tab[2];
921 ULONG nb;
922 IMoniker* pMoniker;
923 ULONG pin;
924 PIN_INFO PinInfo;
925 CLSID FilterCLSID;
926 PIN_DIRECTION dir;
927
928 TRACE("(%p/%p)->(%p, %p)\n", This, iface, ppinOut, ppinIn);
929
930 if (TRACE_ON(quartz))
931 {
932 hr = IPin_QueryPinInfo(ppinIn, &PinInfo);
933 if (FAILED(hr))
934 return hr;
935
936 TRACE("Filter owning first pin => %p\n", PinInfo.pFilter);
937 IBaseFilter_Release(PinInfo.pFilter);
938
939 hr = IPin_QueryPinInfo(ppinOut, &PinInfo);
940 if (FAILED(hr))
941 return hr;
942
943 TRACE("Filter owning second pin => %p\n", PinInfo.pFilter);
944 IBaseFilter_Release(PinInfo.pFilter);
945 }
946
947 EnterCriticalSection(&This->cs);
948 ++This->recursioncount;
949 if (This->recursioncount >= 5)
950 {
951 WARN("Recursion count has reached %d\n", This->recursioncount);
952 hr = VFW_E_CANNOT_CONNECT;
953 goto out;
954 }
955
956 hr = IPin_QueryDirection(ppinOut, &dir);
957 if (FAILED(hr))
958 goto out;
959
960 if (dir == PINDIR_INPUT)
961 {
962 IPin *temp;
963
964 temp = ppinIn;
965 ppinIn = ppinOut;
966 ppinOut = temp;
967 }
968
969 hr = CheckCircularConnection(This, ppinOut, ppinIn);
970 if (FAILED(hr))
971 goto out;
972
973 /* Try direct connection first */
974 hr = IPin_Connect(ppinOut, ppinIn, NULL);
975 if (SUCCEEDED(hr))
976 goto out;
977
978 TRACE("Direct connection failed, trying to render using extra filters\n");
979
980 hr = IPin_QueryPinInfo(ppinIn, &PinInfo);
981 if (FAILED(hr))
982 goto out;
983
984 hr = IBaseFilter_GetClassID(PinInfo.pFilter, &FilterCLSID);
985 IBaseFilter_Release(PinInfo.pFilter);
986 if (FAILED(hr))
987 goto out;
988
989 /* Find the appropriate transform filter than can transform the minor media type of output pin of the upstream
990 * filter to the minor mediatype of input pin of the renderer */
991 hr = IPin_EnumMediaTypes(ppinOut, &penummt);
992 if (FAILED(hr))
993 {
994 WARN("EnumMediaTypes (%x)\n", hr);
995 goto out;
996 }
997
998 hr = IEnumMediaTypes_Next(penummt, 1, &mt, &nbmt);
999 if (FAILED(hr)) {
1000 WARN("IEnumMediaTypes_Next (%x)\n", hr);
1001 goto out;
1002 }
1003
1004 if (!nbmt)
1005 {
1006 WARN("No media type found!\n");
1007 hr = VFW_E_INVALIDMEDIATYPE;
1008 goto out;
1009 }
1010 TRACE("MajorType %s\n", debugstr_guid(&mt->majortype));
1011 TRACE("SubType %s\n", debugstr_guid(&mt->subtype));
1012
1013 /* Try to find a suitable filter that can connect to the pin to render */
1014 tab[0] = mt->majortype;
1015 tab[1] = mt->subtype;
1016 hr = IFilterMapper2_EnumMatchingFilters(This->pFilterMapper2, &pEnumMoniker, 0, FALSE, MERIT_UNLIKELY, TRUE, 1, tab, NULL, NULL, FALSE, FALSE, 0, NULL, NULL, NULL);
1017 if (FAILED(hr)) {
1018 WARN("Unable to enum filters (%x)\n", hr);
1019 goto out;
1020 }
1021
1022 hr = VFW_E_CANNOT_RENDER;
1023 while(IEnumMoniker_Next(pEnumMoniker, 1, &pMoniker, &nb) == S_OK)
1024 {
1025 VARIANT var;
1026 GUID clsid;
1027 IPin** ppins;
1028 IPin* ppinfilter = NULL;
1029 IBaseFilter* pfilter = NULL;
1030 IAMGraphBuilderCallback *callback = NULL;
1031
1032 hr = GetFilterInfo(pMoniker, &clsid, &var);
1033 IMoniker_Release(pMoniker);
1034 if (FAILED(hr)) {
1035 WARN("Unable to retrieve filter info (%x)\n", hr);
1036 goto error;
1037 }
1038
1039 if (IsEqualGUID(&clsid, &FilterCLSID)) {
1040 /* Skip filter (same as the one the output pin belongs to) */
1041 goto error;
1042 }
1043
1044 if (This->pSite)
1045 {
1046 IUnknown_QueryInterface(This->pSite, &IID_IAMGraphBuilderCallback, (LPVOID*)&callback);
1047 if (callback)
1048 {
1049 HRESULT rc;
1050 rc = IAMGraphBuilderCallback_SelectedFilter(callback, pMoniker);
1051 if (FAILED(rc))
1052 {
1053 TRACE("Filter rejected by IAMGraphBuilderCallback_SelectedFilter\n");
1054 IUnknown_Release(callback);
1055 goto error;
1056 }
1057 }
1058 }
1059
1060 hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&pfilter);
1061 if (FAILED(hr)) {
1062 WARN("Unable to create filter (%x), trying next one\n", hr);
1063 goto error;
1064 }
1065
1066 if (callback)
1067 {
1068 HRESULT rc;
1069 rc = IAMGraphBuilderCallback_CreatedFilter(callback, pfilter);
1070 IUnknown_Release(callback);
1071 if (FAILED(rc))
1072 {
1073 IBaseFilter_Release(pfilter);
1074 pfilter = NULL;
1075 TRACE("Filter rejected by IAMGraphBuilderCallback_CreatedFilter\n");
1076 goto error;
1077 }
1078 }
1079
1080 hr = IFilterGraph2_AddFilter(iface, pfilter, V_UNION(&var, bstrVal));
1081 if (FAILED(hr)) {
1082 WARN("Unable to add filter (%x)\n", hr);
1083 IBaseFilter_Release(pfilter);
1084 pfilter = NULL;
1085 goto error;
1086 }
1087
1088 VariantClear(&var);
1089
1090 hr = IBaseFilter_EnumPins(pfilter, &penumpins);
1091 if (FAILED(hr)) {
1092 WARN("Enumpins (%x)\n", hr);
1093 goto error;
1094 }
1095
1096 hr = IEnumPins_Next(penumpins, 1, &ppinfilter, &pin);
1097 IEnumPins_Release(penumpins);
1098
1099 if (FAILED(hr)) {
1100 WARN("Obtaining next pin: (%x)\n", hr);
1101 goto error;
1102 }
1103 if (pin == 0) {
1104 WARN("Cannot use this filter: no pins\n");
1105 goto error;
1106 }
1107
1108 hr = IPin_Connect(ppinOut, ppinfilter, NULL);
1109 if (FAILED(hr)) {
1110 TRACE("Cannot connect to filter (%x), trying next one\n", hr);
1111 goto error;
1112 }
1113 TRACE("Successfully connected to filter, follow chain...\n");
1114
1115 /* Render all output pins of the filter by calling IFilterGraph2_Connect on each of them */
1116 hr = GetInternalConnections(pfilter, ppinfilter, &ppins, &nb);
1117
1118 if (SUCCEEDED(hr)) {
1119 unsigned int i;
1120 if (nb == 0) {
1121 IPin_Disconnect(ppinfilter);
1122 IPin_Disconnect(ppinOut);
1123 goto error;
1124 }
1125 TRACE("pins to consider: %d\n", nb);
1126 for(i = 0; i < nb; i++)
1127 {
1128 LPWSTR pinname = NULL;
1129
1130 TRACE("Processing pin %u\n", i);
1131
1132 hr = IPin_QueryId(ppins[i], &pinname);
1133 if (SUCCEEDED(hr))
1134 {
1135 if (pinname[0] == '~')
1136 {
1137 TRACE("Pinname=%s, skipping\n", debugstr_w(pinname));
1138 hr = E_FAIL;
1139 }
1140 else
1141 hr = IFilterGraph2_Connect(iface, ppins[i], ppinIn);
1142 CoTaskMemFree(pinname);
1143 }
1144
1145 if (FAILED(hr)) {
1146 TRACE("Cannot connect pin %p (%x)\n", ppinfilter, hr);
1147 }
1148 IPin_Release(ppins[i]);
1149 if (SUCCEEDED(hr)) break;
1150 }
1151 while (++i < nb) IPin_Release(ppins[i]);
1152 CoTaskMemFree(ppins);
1153 IPin_Release(ppinfilter);
1154 IBaseFilter_Release(pfilter);
1155 if (FAILED(hr))
1156 {
1157 IPin_Disconnect(ppinfilter);
1158 IPin_Disconnect(ppinOut);
1159 IFilterGraph2_RemoveFilter(iface, pfilter);
1160 continue;
1161 }
1162 break;
1163 }
1164
1165 error:
1166 VariantClear(&var);
1167 if (ppinfilter) IPin_Release(ppinfilter);
1168 if (pfilter) {
1169 IFilterGraph2_RemoveFilter(iface, pfilter);
1170 IBaseFilter_Release(pfilter);
1171 }
1172 }
1173
1174 out:
1175 if (penummt)
1176 IEnumMediaTypes_Release(penummt);
1177 if (mt)
1178 DeleteMediaType(mt);
1179 --This->recursioncount;
1180 LeaveCriticalSection(&This->cs);
1181 TRACE("--> %08x\n", hr);
1182 return SUCCEEDED(hr) ? S_OK : hr;
1183 }
1184
1185 static HRESULT FilterGraph2_RenderRecurse(IFilterGraphImpl *This, IPin *ppinOut)
1186 {
1187 /* This pin has been connected now, try to call render on all pins that aren't connected */
1188 IPin *to = NULL;
1189 PIN_INFO info;
1190 IEnumPins *enumpins = NULL;
1191 BOOL renderany = FALSE;
1192 BOOL renderall = TRUE;
1193
1194 IPin_QueryPinInfo(ppinOut, &info);
1195
1196 IBaseFilter_EnumPins(info.pFilter, &enumpins);
1197 /* Don't need to hold a reference, IEnumPins does */
1198 IBaseFilter_Release(info.pFilter);
1199
1200 IEnumPins_Reset(enumpins);
1201 while (IEnumPins_Next(enumpins, 1, &to, NULL) == S_OK)
1202 {
1203 PIN_DIRECTION dir = PINDIR_INPUT;
1204
1205 IPin_QueryDirection(to, &dir);
1206
1207 if (dir == PINDIR_OUTPUT)
1208 {
1209 IPin *out = NULL;
1210
1211 IPin_ConnectedTo(to, &out);
1212 if (!out)
1213 {
1214 HRESULT hr;
1215 hr = IFilterGraph2_Render(&This->IFilterGraph2_iface, to);
1216 if (SUCCEEDED(hr))
1217 renderany = TRUE;
1218 else
1219 renderall = FALSE;
1220 }
1221 else
1222 IPin_Release(out);
1223 }
1224
1225 IPin_Release(to);
1226 }
1227
1228 IEnumPins_Release(enumpins);
1229
1230 if (renderall)
1231 return S_OK;
1232
1233 if (renderany)
1234 return VFW_S_PARTIAL_RENDER;
1235
1236 return VFW_E_CANNOT_RENDER;
1237 }
1238
1239 /* Ogg hates me if I create a direct rendering method
1240 *
1241 * It can only connect to a pin properly once, so use a recursive method that does
1242 *
1243 * +----+ --- (PIN 1) (Render is called on this pin)
1244 * | |
1245 * +----+ --- (PIN 2)
1246 *
1247 * Enumerate possible renderers that EXACTLY match the requested type
1248 *
1249 * If none is available, try to add intermediate filters that can connect to the input pin
1250 * then call Render on that intermediate pin's output pins
1251 * if it succeeds: Render returns success, if it doesn't, the intermediate filter is removed,
1252 * and another filter that can connect to the input pin is tried
1253 * if we run out of filters that can, give up and return VFW_E_CANNOT_RENDER
1254 * It's recursive, but fun!
1255 */
1256
1257 static HRESULT WINAPI FilterGraph2_Render(IFilterGraph2 *iface, IPin *ppinOut)
1258 {
1259 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1260 IEnumMediaTypes* penummt;
1261 AM_MEDIA_TYPE* mt;
1262 ULONG nbmt;
1263 HRESULT hr;
1264
1265 IEnumMoniker* pEnumMoniker;
1266 GUID tab[4];
1267 ULONG nb;
1268 IMoniker* pMoniker;
1269 INT x;
1270
1271 TRACE("(%p/%p)->(%p)\n", This, iface, ppinOut);
1272
1273 if (TRACE_ON(quartz))
1274 {
1275 PIN_INFO PinInfo;
1276
1277 hr = IPin_QueryPinInfo(ppinOut, &PinInfo);
1278 if (FAILED(hr))
1279 return hr;
1280
1281 TRACE("Filter owning pin => %p\n", PinInfo.pFilter);
1282 IBaseFilter_Release(PinInfo.pFilter);
1283 }
1284
1285 /* Try to find out if there is a renderer for the specified subtype already, and use that
1286 */
1287 EnterCriticalSection(&This->cs);
1288 for (x = 0; x < This->nFilters; ++x)
1289 {
1290 IEnumPins *enumpins = NULL;
1291 IPin *pin = NULL;
1292
1293 hr = IBaseFilter_EnumPins(This->ppFiltersInGraph[x], &enumpins);
1294
1295 if (FAILED(hr) || !enumpins)
1296 continue;
1297
1298 IEnumPins_Reset(enumpins);
1299 while (IEnumPins_Next(enumpins, 1, &pin, NULL) == S_OK)
1300 {
1301 IPin *to = NULL;
1302 PIN_DIRECTION dir = PINDIR_OUTPUT;
1303
1304 IPin_QueryDirection(pin, &dir);
1305 if (dir != PINDIR_INPUT)
1306 {
1307 IPin_Release(pin);
1308 continue;
1309 }
1310 IPin_ConnectedTo(pin, &to);
1311
1312 if (to == NULL)
1313 {
1314 hr = FilterGraph2_ConnectDirect(iface, ppinOut, pin, NULL);
1315 if (SUCCEEDED(hr))
1316 {
1317 TRACE("Connected successfully %p/%p, %08x look if we should render more!\n", ppinOut, pin, hr);
1318 IPin_Release(pin);
1319
1320 hr = FilterGraph2_RenderRecurse(This, pin);
1321 if (FAILED(hr))
1322 {
1323 IPin_Disconnect(ppinOut);
1324 IPin_Disconnect(pin);
1325 continue;
1326 }
1327 IEnumPins_Release(enumpins);
1328 LeaveCriticalSection(&This->cs);
1329 return hr;
1330 }
1331 WARN("Could not connect!\n");
1332 }
1333 else
1334 IPin_Release(to);
1335
1336 IPin_Release(pin);
1337 }
1338 IEnumPins_Release(enumpins);
1339 }
1340
1341 LeaveCriticalSection(&This->cs);
1342
1343 hr = IPin_EnumMediaTypes(ppinOut, &penummt);
1344 if (FAILED(hr)) {
1345 WARN("EnumMediaTypes (%x)\n", hr);
1346 return hr;
1347 }
1348
1349 IEnumMediaTypes_Reset(penummt);
1350
1351 /* Looks like no existing renderer of the kind exists
1352 * Try adding new ones
1353 */
1354 tab[0] = tab[1] = GUID_NULL;
1355 while (SUCCEEDED(hr))
1356 {
1357 hr = IEnumMediaTypes_Next(penummt, 1, &mt, &nbmt);
1358 if (FAILED(hr)) {
1359 WARN("IEnumMediaTypes_Next (%x)\n", hr);
1360 break;
1361 }
1362 if (!nbmt)
1363 {
1364 hr = VFW_E_CANNOT_RENDER;
1365 break;
1366 }
1367 else
1368 {
1369 TRACE("MajorType %s\n", debugstr_guid(&mt->majortype));
1370 TRACE("SubType %s\n", debugstr_guid(&mt->subtype));
1371
1372 /* Only enumerate once, this doesn't account for all previous ones, but this should be enough nonetheless */
1373 if (IsEqualIID(&tab[0], &mt->majortype) && IsEqualIID(&tab[1], &mt->subtype))
1374 {
1375 DeleteMediaType(mt);
1376 continue;
1377 }
1378
1379 /* Try to find a suitable renderer with the same media type */
1380 tab[0] = mt->majortype;
1381 tab[1] = mt->subtype;
1382 hr = IFilterMapper2_EnumMatchingFilters(This->pFilterMapper2, &pEnumMoniker, 0, FALSE, MERIT_UNLIKELY, TRUE, 1, tab, NULL, NULL, FALSE, FALSE, 0, NULL, NULL, NULL);
1383 if (FAILED(hr))
1384 {
1385 WARN("Unable to enum filters (%x)\n", hr);
1386 break;
1387 }
1388 }
1389 hr = E_FAIL;
1390
1391 while (IEnumMoniker_Next(pEnumMoniker, 1, &pMoniker, &nb) == S_OK)
1392 {
1393 VARIANT var;
1394 GUID clsid;
1395 IPin* ppinfilter;
1396 IBaseFilter* pfilter = NULL;
1397 IEnumPins* penumpins = NULL;
1398 ULONG pin;
1399
1400 hr = GetFilterInfo(pMoniker, &clsid, &var);
1401 IMoniker_Release(pMoniker);
1402 if (FAILED(hr)) {
1403 WARN("Unable to retrieve filter info (%x)\n", hr);
1404 goto error;
1405 }
1406
1407 hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&pfilter);
1408 if (FAILED(hr))
1409 {
1410 WARN("Unable to create filter (%x), trying next one\n", hr);
1411 goto error;
1412 }
1413
1414 hr = IFilterGraph2_AddFilter(iface, pfilter, V_UNION(&var, bstrVal));
1415 if (FAILED(hr)) {
1416 WARN("Unable to add filter (%x)\n", hr);
1417 IBaseFilter_Release(pfilter);
1418 pfilter = NULL;
1419 goto error;
1420 }
1421
1422 hr = IBaseFilter_EnumPins(pfilter, &penumpins);
1423 if (FAILED(hr)) {
1424 WARN("Splitter Enumpins (%x)\n", hr);
1425 goto error;
1426 }
1427
1428 while ((hr = IEnumPins_Next(penumpins, 1, &ppinfilter, &pin)) == S_OK)
1429 {
1430 PIN_DIRECTION dir;
1431
1432 if (pin == 0) {
1433 WARN("No Pin\n");
1434 hr = E_FAIL;
1435 goto error;
1436 }
1437
1438 hr = IPin_QueryDirection(ppinfilter, &dir);
1439 if (FAILED(hr)) {
1440 IPin_Release(ppinfilter);
1441 WARN("QueryDirection failed (%x)\n", hr);
1442 goto error;
1443 }
1444 if (dir != PINDIR_INPUT) {
1445 IPin_Release(ppinfilter);
1446 continue; /* Wrong direction */
1447 }
1448
1449 /* Connect the pin to the "Renderer" */
1450 hr = IPin_Connect(ppinOut, ppinfilter, NULL);
1451 IPin_Release(ppinfilter);
1452
1453 if (FAILED(hr)) {
1454 WARN("Unable to connect %s to renderer (%x)\n", debugstr_w(V_UNION(&var, bstrVal)), hr);
1455 goto error;
1456 }
1457 TRACE("Connected, recursing %s\n", debugstr_w(V_UNION(&var, bstrVal)));
1458
1459 VariantClear(&var);
1460
1461 hr = FilterGraph2_RenderRecurse(This, ppinfilter);
1462 if (FAILED(hr)) {
1463 WARN("Unable to connect recursively (%x)\n", hr);
1464 goto error;
1465 }
1466 IBaseFilter_Release(pfilter);
1467 break;
1468 }
1469 if (SUCCEEDED(hr)) {
1470 IEnumPins_Release(penumpins);
1471 break; /* out of IEnumMoniker_Next loop */
1472 }
1473
1474 /* IEnumPins_Next failed, all other failure case caught by goto error */
1475 WARN("IEnumPins_Next (%x)\n", hr);
1476 /* goto error */
1477
1478 error:
1479 VariantClear(&var);
1480 if (penumpins)
1481 IEnumPins_Release(penumpins);
1482 if (pfilter) {
1483 IFilterGraph2_RemoveFilter(iface, pfilter);
1484 IBaseFilter_Release(pfilter);
1485 }
1486 if (SUCCEEDED(hr)) DebugBreak();
1487 }
1488
1489 IEnumMoniker_Release(pEnumMoniker);
1490 if (nbmt)
1491 DeleteMediaType(mt);
1492 if (SUCCEEDED(hr))
1493 break;
1494 hr = S_OK;
1495 }
1496
1497 IEnumMediaTypes_Release(penummt);
1498 return hr;
1499 }
1500
1501 static HRESULT WINAPI FilterGraph2_RenderFile(IFilterGraph2 *iface, LPCWSTR lpcwstrFile,
1502 LPCWSTR lpcwstrPlayList)
1503 {
1504 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1505 static const WCHAR string[] = {'R','e','a','d','e','r',0};
1506 IBaseFilter* preader = NULL;
1507 IPin* ppinreader = NULL;
1508 IEnumPins* penumpins = NULL;
1509 HRESULT hr;
1510 BOOL partial = FALSE;
1511 HRESULT any = FALSE;
1512
1513 TRACE("(%p/%p)->(%s, %s)\n", This, iface, debugstr_w(lpcwstrFile), debugstr_w(lpcwstrPlayList));
1514
1515 if (lpcwstrPlayList != NULL)
1516 return E_INVALIDARG;
1517
1518 hr = IFilterGraph2_AddSourceFilter(iface, lpcwstrFile, string, &preader);
1519 if (FAILED(hr))
1520 return hr;
1521
1522 if (SUCCEEDED(hr))
1523 hr = IBaseFilter_EnumPins(preader, &penumpins);
1524 if (SUCCEEDED(hr))
1525 {
1526 while (IEnumPins_Next(penumpins, 1, &ppinreader, NULL) == S_OK)
1527 {
1528 PIN_DIRECTION dir;
1529
1530 IPin_QueryDirection(ppinreader, &dir);
1531 if (dir == PINDIR_OUTPUT)
1532 {
1533 INT i;
1534
1535 hr = IFilterGraph2_Render(iface, ppinreader);
1536 TRACE("Render %08x\n", hr);
1537
1538 for (i = 0; i < This->nFilters; ++i)
1539 TRACE("Filters in chain: %s\n", debugstr_w(This->pFilterNames[i]));
1540
1541 if (SUCCEEDED(hr))
1542 any = TRUE;
1543 if (hr != S_OK)
1544 partial = TRUE;
1545 }
1546 IPin_Release(ppinreader);
1547 }
1548 IEnumPins_Release(penumpins);
1549
1550 if (!any)
1551 hr = VFW_E_CANNOT_RENDER;
1552 else if (partial)
1553 hr = VFW_S_PARTIAL_RENDER;
1554 else
1555 hr = S_OK;
1556 }
1557 IBaseFilter_Release(preader);
1558
1559 TRACE("--> %08x\n", hr);
1560 return hr;
1561 }
1562
1563 /* Some filters implement their own asynchronous reader (Theoretically they all should, try to load it first */
1564 static HRESULT GetFileSourceFilter(LPCOLESTR pszFileName, IBaseFilter **filter)
1565 {
1566 static const WCHAR wszReg[] = {'M','e','d','i','a',' ','T','y','p','e','\\','E','x','t','e','n','s','i','o','n','s',0};
1567 HRESULT hr = S_OK;
1568 HKEY extkey;
1569 LONG lRet;
1570
1571 lRet = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszReg, 0, KEY_READ, &extkey);
1572 hr = HRESULT_FROM_WIN32(lRet);
1573
1574 if (SUCCEEDED(hr))
1575 {
1576 static const WCHAR filtersource[] = {'S','o','u','r','c','e',' ','F','i','l','t','e','r',0};
1577 WCHAR *ext = PathFindExtensionW(pszFileName);
1578 WCHAR clsid_key[39];
1579 GUID clsid;
1580 DWORD size = sizeof(clsid_key);
1581 HKEY pathkey;
1582
1583 if (!ext)
1584 {
1585 CloseHandle(extkey);
1586 return E_FAIL;
1587 }
1588
1589 lRet = RegOpenKeyExW(extkey, ext, 0, KEY_READ, &pathkey);
1590 hr = HRESULT_FROM_WIN32(lRet);
1591 CloseHandle(extkey);
1592 if (FAILED(hr))
1593 return hr;
1594
1595 lRet = RegQueryValueExW(pathkey, filtersource, NULL, NULL, (LPBYTE)clsid_key, &size);
1596 hr = HRESULT_FROM_WIN32(lRet);
1597 CloseHandle(pathkey);
1598 if (FAILED(hr))
1599 return hr;
1600
1601 CLSIDFromString(clsid_key, &clsid);
1602
1603 TRACE("CLSID: %s\n", debugstr_guid(&clsid));
1604 hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)filter);
1605 if (SUCCEEDED(hr))
1606 {
1607 IFileSourceFilter *source = NULL;
1608 hr = IBaseFilter_QueryInterface(*filter, &IID_IFileSourceFilter, (LPVOID*)&source);
1609 if (SUCCEEDED(hr))
1610 IFileSourceFilter_Release(source);
1611 else
1612 IBaseFilter_Release(*filter);
1613 }
1614 }
1615 if (FAILED(hr))
1616 *filter = NULL;
1617 return hr;
1618 }
1619
1620 static HRESULT WINAPI FilterGraph2_AddSourceFilter(IFilterGraph2 *iface, LPCWSTR lpcwstrFileName,
1621 LPCWSTR lpcwstrFilterName, IBaseFilter **ppFilter)
1622 {
1623 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1624 HRESULT hr;
1625 IBaseFilter* preader;
1626 IFileSourceFilter* pfile = NULL;
1627 AM_MEDIA_TYPE mt;
1628 WCHAR* filename;
1629
1630 TRACE("(%p/%p)->(%s, %s, %p)\n", This, iface, debugstr_w(lpcwstrFileName), debugstr_w(lpcwstrFilterName), ppFilter);
1631
1632 /* Try from file name first, then fall back to default asynchronous reader */
1633 hr = GetFileSourceFilter(lpcwstrFileName, &preader);
1634
1635 if (FAILED(hr))
1636 hr = CoCreateInstance(&CLSID_AsyncReader, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&preader);
1637 if (FAILED(hr)) {
1638 WARN("Unable to create file source filter (%x)\n", hr);
1639 return hr;
1640 }
1641
1642 hr = IFilterGraph2_AddFilter(iface, preader, lpcwstrFilterName);
1643 if (FAILED(hr)) {
1644 WARN("Unable add filter (%x)\n", hr);
1645 IBaseFilter_Release(preader);
1646 return hr;
1647 }
1648
1649 hr = IBaseFilter_QueryInterface(preader, &IID_IFileSourceFilter, (LPVOID*)&pfile);
1650 if (FAILED(hr)) {
1651 WARN("Unable to get IFileSourceInterface (%x)\n", hr);
1652 goto error;
1653 }
1654
1655 /* Load the file in the file source filter */
1656 hr = IFileSourceFilter_Load(pfile, lpcwstrFileName, NULL);
1657 if (FAILED(hr)) {
1658 WARN("Load (%x)\n", hr);
1659 goto error;
1660 }
1661
1662 IFileSourceFilter_GetCurFile(pfile, &filename, &mt);
1663 if (FAILED(hr)) {
1664 WARN("GetCurFile (%x)\n", hr);
1665 goto error;
1666 }
1667
1668 TRACE("File %s\n", debugstr_w(filename));
1669 TRACE("MajorType %s\n", debugstr_guid(&mt.majortype));
1670 TRACE("SubType %s\n", debugstr_guid(&mt.subtype));
1671
1672 if (ppFilter)
1673 *ppFilter = preader;
1674 IFileSourceFilter_Release(pfile);
1675
1676 return S_OK;
1677
1678 error:
1679 if (pfile)
1680 IFileSourceFilter_Release(pfile);
1681 IFilterGraph2_RemoveFilter(iface, preader);
1682 IBaseFilter_Release(preader);
1683
1684 return hr;
1685 }
1686
1687 static HRESULT WINAPI FilterGraph2_SetLogFile(IFilterGraph2 *iface, DWORD_PTR hFile)
1688 {
1689 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1690
1691 TRACE("(%p/%p)->(%08x): stub !!!\n", This, iface, (DWORD) hFile);
1692
1693 return S_OK;
1694 }
1695
1696 static HRESULT WINAPI FilterGraph2_Abort(IFilterGraph2 *iface)
1697 {
1698 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1699
1700 TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1701
1702 return S_OK;
1703 }
1704
1705 static HRESULT WINAPI FilterGraph2_ShouldOperationContinue(IFilterGraph2 *iface)
1706 {
1707 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1708
1709 TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1710
1711 return S_OK;
1712 }
1713
1714 /*** IFilterGraph2 methods ***/
1715 static HRESULT WINAPI FilterGraph2_AddSourceFilterForMoniker(IFilterGraph2 *iface,
1716 IMoniker *pMoniker, IBindCtx *pCtx, LPCWSTR lpcwstrFilterName, IBaseFilter **ppFilter)
1717 {
1718 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1719
1720 TRACE("(%p/%p)->(%p %p %s %p): stub !!!\n", This, iface, pMoniker, pCtx, debugstr_w(lpcwstrFilterName), ppFilter);
1721
1722 return S_OK;
1723 }
1724
1725 static HRESULT WINAPI FilterGraph2_ReconnectEx(IFilterGraph2 *iface, IPin *ppin,
1726 const AM_MEDIA_TYPE *pmt)
1727 {
1728 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1729
1730 TRACE("(%p/%p)->(%p %p): stub !!!\n", This, iface, ppin, pmt);
1731
1732 return S_OK;
1733 }
1734
1735 static HRESULT WINAPI FilterGraph2_RenderEx(IFilterGraph2 *iface, IPin *pPinOut, DWORD dwFlags,
1736 DWORD *pvContext)
1737 {
1738 IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
1739
1740 TRACE("(%p/%p)->(%p %08x %p): stub !!!\n", This, iface, pPinOut, dwFlags, pvContext);
1741
1742 return S_OK;
1743 }
1744
1745
1746 static const IFilterGraph2Vtbl IFilterGraph2_VTable =
1747 {
1748 FilterGraph2_QueryInterface,
1749 FilterGraph2_AddRef,
1750 FilterGraph2_Release,
1751 FilterGraph2_AddFilter,
1752 FilterGraph2_RemoveFilter,
1753 FilterGraph2_EnumFilters,
1754 FilterGraph2_FindFilterByName,
1755 FilterGraph2_ConnectDirect,
1756 FilterGraph2_Reconnect,
1757 FilterGraph2_Disconnect,
1758 FilterGraph2_SetDefaultSyncSource,
1759 FilterGraph2_Connect,
1760 FilterGraph2_Render,
1761 FilterGraph2_RenderFile,
1762 FilterGraph2_AddSourceFilter,
1763 FilterGraph2_SetLogFile,
1764 FilterGraph2_Abort,
1765 FilterGraph2_ShouldOperationContinue,
1766 FilterGraph2_AddSourceFilterForMoniker,
1767 FilterGraph2_ReconnectEx,
1768 FilterGraph2_RenderEx
1769 };
1770
1771 static inline IFilterGraphImpl *impl_from_IMediaControl(IMediaControl *iface)
1772 {
1773 return CONTAINING_RECORD(iface, IFilterGraphImpl, IMediaControl_iface);
1774 }
1775
1776 static HRESULT WINAPI MediaControl_QueryInterface(IMediaControl *iface, REFIID riid, void **ppvObj)
1777 {
1778 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1779
1780 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1781
1782 return Filtergraph_QueryInterface(This, riid, ppvObj);
1783 }
1784
1785 static ULONG WINAPI MediaControl_AddRef(IMediaControl *iface)
1786 {
1787 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1788
1789 TRACE("(%p/%p)->()\n", This, iface);
1790
1791 return Filtergraph_AddRef(This);
1792 }
1793
1794 static ULONG WINAPI MediaControl_Release(IMediaControl *iface)
1795 {
1796 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1797
1798 TRACE("(%p/%p)->()\n", This, iface);
1799
1800 return Filtergraph_Release(This);
1801
1802 }
1803
1804 /*** IDispatch methods ***/
1805 static HRESULT WINAPI MediaControl_GetTypeInfoCount(IMediaControl *iface, UINT *pctinfo)
1806 {
1807 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1808
1809 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1810
1811 return S_OK;
1812 }
1813
1814 static HRESULT WINAPI MediaControl_GetTypeInfo(IMediaControl *iface, UINT iTInfo, LCID lcid,
1815 ITypeInfo **ppTInfo)
1816 {
1817 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1818
1819 TRACE("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1820
1821 return S_OK;
1822 }
1823
1824 static HRESULT WINAPI MediaControl_GetIDsOfNames(IMediaControl *iface, REFIID riid,
1825 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1826 {
1827 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1828
1829 TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
1830
1831 return S_OK;
1832 }
1833
1834 static HRESULT WINAPI MediaControl_Invoke(IMediaControl *iface, DISPID dispIdMember, REFIID riid,
1835 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo,
1836 UINT *puArgErr)
1837 {
1838 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1839
1840 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);
1841
1842 return S_OK;
1843 }
1844
1845 typedef HRESULT(WINAPI *fnFoundFilter)(IBaseFilter *, DWORD_PTR data);
1846
1847 static HRESULT ExploreGraph(IFilterGraphImpl* pGraph, IPin* pOutputPin, fnFoundFilter FoundFilter, DWORD_PTR data)
1848 {
1849 HRESULT hr;
1850 IPin* pInputPin;
1851 IPin** ppPins;
1852 ULONG nb;
1853 ULONG i;
1854 PIN_INFO PinInfo;
1855
1856 TRACE("%p %p\n", pGraph, pOutputPin);
1857 PinInfo.pFilter = NULL;
1858
1859 hr = IPin_ConnectedTo(pOutputPin, &pInputPin);
1860
1861 if (SUCCEEDED(hr))
1862 {
1863 hr = IPin_QueryPinInfo(pInputPin, &PinInfo);
1864 if (SUCCEEDED(hr))
1865 hr = GetInternalConnections(PinInfo.pFilter, pInputPin, &ppPins, &nb);
1866 IPin_Release(pInputPin);
1867 }
1868
1869 if (SUCCEEDED(hr))
1870 {
1871 if (nb == 0)
1872 {
1873 TRACE("Reached a renderer\n");
1874 /* Count renderers for end of stream notification */
1875 pGraph->nRenderers++;
1876 }
1877 else
1878 {
1879 for(i = 0; i < nb; i++)
1880 {
1881 /* Explore the graph downstream from this pin
1882 * FIXME: We should prevent exploring from a pin more than once. This can happens when
1883 * several input pins are connected to the same output (a MUX for instance). */
1884 ExploreGraph(pGraph, ppPins[i], FoundFilter, data);
1885 IPin_Release(ppPins[i]);
1886 }
1887
1888 CoTaskMemFree(ppPins);
1889 }
1890 TRACE("Doing stuff with filter %p\n", PinInfo.pFilter);
1891
1892 FoundFilter(PinInfo.pFilter, data);
1893 }
1894
1895 if (PinInfo.pFilter) IBaseFilter_Release(PinInfo.pFilter);
1896 return hr;
1897 }
1898
1899 static HRESULT WINAPI SendRun(IBaseFilter *pFilter, DWORD_PTR data)
1900 {
1901 REFERENCE_TIME time = *(REFERENCE_TIME*)data;
1902 return IBaseFilter_Run(pFilter, time);
1903 }
1904
1905 static HRESULT WINAPI SendPause(IBaseFilter *pFilter, DWORD_PTR data)
1906 {
1907 return IBaseFilter_Pause(pFilter);
1908 }
1909
1910 static HRESULT WINAPI SendStop(IBaseFilter *pFilter, DWORD_PTR data)
1911 {
1912 return IBaseFilter_Stop(pFilter);
1913 }
1914
1915 static HRESULT WINAPI SendGetState(IBaseFilter *pFilter, DWORD_PTR data)
1916 {
1917 FILTER_STATE state;
1918 DWORD time_end = data;
1919 DWORD time_now = GetTickCount();
1920 LONG wait;
1921
1922 if (time_end == INFINITE)
1923 {
1924 wait = INFINITE;
1925 }
1926 else if (time_end > time_now)
1927 {
1928 wait = time_end - time_now;
1929 }
1930 else
1931 wait = 0;
1932
1933 return IBaseFilter_GetState(pFilter, wait, &state);
1934 }
1935
1936
1937 static HRESULT SendFilterMessage(IFilterGraphImpl *This, fnFoundFilter FoundFilter, DWORD_PTR data)
1938 {
1939 int i;
1940 IBaseFilter* pfilter;
1941 IEnumPins* pEnum;
1942 HRESULT hr;
1943 IPin* pPin;
1944 DWORD dummy;
1945 PIN_DIRECTION dir;
1946
1947 TRACE("(%p)->()\n", This);
1948
1949 /* Explorer the graph from source filters to renderers, determine renderers
1950 * number and run filters from renderers to source filters */
1951 This->nRenderers = 0;
1952 ResetEvent(This->hEventCompletion);
1953
1954 for(i = 0; i < This->nFilters; i++)
1955 {
1956 BOOL source = TRUE;
1957 pfilter = This->ppFiltersInGraph[i];
1958 hr = IBaseFilter_EnumPins(pfilter, &pEnum);
1959 if (hr != S_OK)
1960 {
1961 WARN("Enum pins failed %x\n", hr);
1962 continue;
1963 }
1964 /* Check if it is a source filter */
1965 while(IEnumPins_Next(pEnum, 1, &pPin, &dummy) == S_OK)
1966 {
1967 IPin_QueryDirection(pPin, &dir);
1968 IPin_Release(pPin);
1969 if (dir == PINDIR_INPUT)
1970 {
1971 source = FALSE;
1972 break;
1973 }
1974 }
1975 if (source)
1976 {
1977 TRACE("Found a source filter %p\n", pfilter);
1978 IEnumPins_Reset(pEnum);
1979 while(IEnumPins_Next(pEnum, 1, &pPin, &dummy) == S_OK)
1980 {
1981 /* Explore the graph downstream from this pin */
1982 ExploreGraph(This, pPin, FoundFilter, data);
1983 IPin_Release(pPin);
1984 }
1985 FoundFilter(pfilter, data);
1986 }
1987 IEnumPins_Release(pEnum);
1988 }
1989
1990 return S_FALSE;
1991 }
1992
1993 /*** IMediaControl methods ***/
1994 static HRESULT WINAPI MediaControl_Run(IMediaControl *iface)
1995 {
1996 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
1997
1998 TRACE("(%p/%p)->()\n", This, iface);
1999
2000 EnterCriticalSection(&This->cs);
2001 if (This->state == State_Running)
2002 goto out;
2003 This->EcCompleteCount = 0;
2004
2005 if (This->defaultclock && !This->refClock)
2006 IFilterGraph2_SetDefaultSyncSource((IFilterGraph2*)This);
2007
2008 if (This->refClock)
2009 {
2010 REFERENCE_TIME now;
2011 IReferenceClock_GetTime(This->refClock, &now);
2012 if (This->state == State_Stopped)
2013 This->start_time = now + 500000;
2014 else if (This->pause_time >= 0)
2015 This->start_time += now - This->pause_time;
2016 else
2017 This->start_time = now;
2018 }
2019 else This->start_time = 0;
2020
2021 SendFilterMessage(This, SendRun, (DWORD_PTR)&This->start_time);
2022 This->state = State_Running;
2023 out:
2024 LeaveCriticalSection(&This->cs);
2025 return S_FALSE;
2026 }
2027
2028 static HRESULT WINAPI MediaControl_Pause(IMediaControl *iface)
2029 {
2030 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2031
2032 TRACE("(%p/%p)->()\n", This, iface);
2033
2034 EnterCriticalSection(&This->cs);
2035 if (This->state == State_Paused)
2036 goto out;
2037
2038 if (This->state == State_Running && This->refClock && This->start_time >= 0)
2039 IReferenceClock_GetTime(This->refClock, &This->pause_time);
2040 else
2041 This->pause_time = -1;
2042
2043 SendFilterMessage(This, SendPause, 0);
2044 This->state = State_Paused;
2045 out:
2046 LeaveCriticalSection(&This->cs);
2047 return S_FALSE;
2048 }
2049
2050 static HRESULT WINAPI MediaControl_Stop(IMediaControl *iface)
2051 {
2052 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2053
2054 TRACE("(%p/%p)->()\n", This, iface);
2055
2056 if (This->state == State_Stopped) return S_OK;
2057
2058 EnterCriticalSection(&This->cs);
2059 if (This->state == State_Running) SendFilterMessage(This, SendPause, 0);
2060 SendFilterMessage(This, SendStop, 0);
2061 This->state = State_Stopped;
2062 LeaveCriticalSection(&This->cs);
2063 return S_OK;
2064 }
2065
2066 static HRESULT WINAPI MediaControl_GetState(IMediaControl *iface, LONG msTimeout,
2067 OAFilterState *pfs)
2068 {
2069 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2070 DWORD end;
2071
2072 TRACE("(%p/%p)->(%d, %p)\n", This, iface, msTimeout, pfs);
2073
2074 if (!pfs)
2075 return E_POINTER;
2076
2077 EnterCriticalSection(&This->cs);
2078
2079 *pfs = This->state;
2080 if (msTimeout > 0)
2081 {
2082 end = GetTickCount() + msTimeout;
2083 }
2084 else if (msTimeout < 0)
2085 {
2086 end = INFINITE;
2087 }
2088 else
2089 {
2090 end = 0;
2091 }
2092 if (end)
2093 SendFilterMessage(This, SendGetState, end);
2094
2095 LeaveCriticalSection(&This->cs);
2096
2097 return S_OK;
2098 }
2099
2100 static HRESULT WINAPI MediaControl_RenderFile(IMediaControl *iface, BSTR strFilename)
2101 {
2102 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2103
2104 FIXME("(%p/%p)->(%s (%p)): stub !!!\n", This, iface, debugstr_w(strFilename), strFilename);
2105
2106 return S_OK;
2107 }
2108
2109 static HRESULT WINAPI MediaControl_AddSourceFilter(IMediaControl *iface, BSTR strFilename,
2110 IDispatch **ppUnk)
2111 {
2112 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2113
2114 FIXME("(%p/%p)->(%s (%p), %p): stub !!!\n", This, iface, debugstr_w(strFilename), strFilename, ppUnk);
2115
2116 return S_OK;
2117 }
2118
2119 static HRESULT WINAPI MediaControl_get_FilterCollection(IMediaControl *iface, IDispatch **ppUnk)
2120 {
2121 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2122
2123 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk);
2124
2125 return S_OK;
2126 }
2127
2128 static HRESULT WINAPI MediaControl_get_RegFilterCollection(IMediaControl *iface, IDispatch **ppUnk)
2129 {
2130 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2131
2132 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk);
2133
2134 return S_OK;
2135 }
2136
2137 static HRESULT WINAPI MediaControl_StopWhenReady(IMediaControl *iface)
2138 {
2139 IFilterGraphImpl *This = impl_from_IMediaControl(iface);
2140
2141 FIXME("(%p/%p)->(): stub !!!\n", This, iface);
2142
2143 return S_OK;
2144 }
2145
2146
2147 static const IMediaControlVtbl IMediaControl_VTable =
2148 {
2149 MediaControl_QueryInterface,
2150 MediaControl_AddRef,
2151 MediaControl_Release,
2152 MediaControl_GetTypeInfoCount,
2153 MediaControl_GetTypeInfo,
2154 MediaControl_GetIDsOfNames,
2155 MediaControl_Invoke,
2156 MediaControl_Run,
2157 MediaControl_Pause,
2158 MediaControl_Stop,
2159 MediaControl_GetState,
2160 MediaControl_RenderFile,
2161 MediaControl_AddSourceFilter,
2162 MediaControl_get_FilterCollection,
2163 MediaControl_get_RegFilterCollection,
2164 MediaControl_StopWhenReady
2165 };
2166
2167 static inline IFilterGraphImpl *impl_from_IMediaSeeking(IMediaSeeking *iface)
2168 {
2169 return CONTAINING_RECORD(iface, IFilterGraphImpl, IMediaSeeking_iface);
2170 }
2171
2172 static HRESULT WINAPI MediaSeeking_QueryInterface(IMediaSeeking *iface, REFIID riid, void **ppvObj)
2173 {
2174 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2175
2176 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
2177
2178 return Filtergraph_QueryInterface(This, riid, ppvObj);
2179 }
2180
2181 static ULONG WINAPI MediaSeeking_AddRef(IMediaSeeking *iface)
2182 {
2183 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2184
2185 TRACE("(%p/%p)->()\n", This, iface);
2186
2187 return Filtergraph_AddRef(This);
2188 }
2189
2190 static ULONG WINAPI MediaSeeking_Release(IMediaSeeking *iface)
2191 {
2192 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2193
2194 TRACE("(%p/%p)->()\n", This, iface);
2195
2196 return Filtergraph_Release(This);
2197 }
2198
2199 typedef HRESULT (WINAPI *fnFoundSeek)(IFilterGraphImpl *This, IMediaSeeking*, DWORD_PTR arg);
2200
2201 static HRESULT all_renderers_seek(IFilterGraphImpl *This, fnFoundSeek FoundSeek, DWORD_PTR arg) {
2202 BOOL allnotimpl = TRUE;
2203 int i;
2204 HRESULT hr, hr_return = S_OK;
2205
2206 TRACE("(%p)->(%p %08lx)\n", This, FoundSeek, arg);
2207 /* Send a message to all renderers, they are responsible for broadcasting it further */
2208
2209 for(i = 0; i < This->nFilters; i++)
2210 {
2211 IMediaSeeking *seek = NULL;
2212 IBaseFilter* pfilter = This->ppFiltersInGraph[i];
2213 IAMFilterMiscFlags *flags = NULL;
2214 ULONG filterflags;
2215 IUnknown_QueryInterface(pfilter, &IID_IAMFilterMiscFlags, (void**)&flags);
2216 if (!flags)
2217 continue;
2218 filterflags = IAMFilterMiscFlags_GetMiscFlags(flags);
2219 IUnknown_Release(flags);
2220 if (filterflags != AM_FILTER_MISC_FLAGS_IS_RENDERER)
2221 continue;
2222
2223 IBaseFilter_QueryInterface(pfilter, &IID_IMediaSeeking, (void**)&seek);
2224 if (!seek)
2225 continue;
2226 hr = FoundSeek(This, seek, arg);
2227 IMediaSeeking_Release(seek);
2228 if (hr_return != E_NOTIMPL)
2229 allnotimpl = FALSE;
2230 if (hr_return == S_OK || (FAILED(hr) && hr != E_NOTIMPL && SUCCEEDED(hr_return)))
2231 hr_return = hr;
2232 }
2233
2234 if (allnotimpl)
2235 return E_NOTIMPL;
2236 return hr_return;
2237 }
2238
2239 static HRESULT WINAPI FoundCapabilities(IFilterGraphImpl *This, IMediaSeeking *seek, DWORD_PTR pcaps)
2240 {
2241 HRESULT hr;
2242 DWORD caps = 0;
2243
2244 hr = IMediaSeeking_GetCapabilities(seek, &caps);
2245 if (FAILED(hr))
2246 return hr;
2247
2248 /* Only add common capabilities everything supports */
2249 *(DWORD*)pcaps &= caps;
2250
2251 return hr;
2252 }
2253
2254 /*** IMediaSeeking methods ***/
2255 static HRESULT WINAPI MediaSeeking_GetCapabilities(IMediaSeeking *iface, DWORD *pCapabilities)
2256 {
2257 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2258 HRESULT hr;
2259
2260 TRACE("(%p/%p)->(%p)\n", This, iface, pCapabilities);
2261
2262 if (!pCapabilities)
2263 return E_POINTER;
2264
2265 EnterCriticalSection(&This->cs);
2266 *pCapabilities = 0xffffffff;
2267
2268 hr = all_renderers_seek(This, FoundCapabilities, (DWORD_PTR)pCapabilities);
2269 LeaveCriticalSection(&This->cs);
2270
2271 return hr;
2272 }
2273
2274 static HRESULT WINAPI MediaSeeking_CheckCapabilities(IMediaSeeking *iface, DWORD *pCapabilities)
2275 {
2276 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2277 DWORD originalcaps;
2278 HRESULT hr;
2279
2280 TRACE("(%p/%p)->(%p)\n", This, iface, pCapabilities);
2281
2282 if (!pCapabilities)
2283 return E_POINTER;
2284
2285 EnterCriticalSection(&This->cs);
2286 originalcaps = *pCapabilities;
2287 hr = all_renderers_seek(This, FoundCapabilities, (DWORD_PTR)pCapabilities);
2288 LeaveCriticalSection(&This->cs);
2289
2290 if (FAILED(hr))
2291 return hr;
2292
2293 if (!*pCapabilities)
2294 return E_FAIL;
2295 if (*pCapabilities != originalcaps)
2296 return S_FALSE;
2297 return S_OK;
2298 }
2299
2300 static HRESULT WINAPI MediaSeeking_IsFormatSupported(IMediaSeeking *iface, const GUID *pFormat)
2301 {
2302 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2303
2304 if (!pFormat)
2305 return E_POINTER;
2306
2307 TRACE("(%p/%p)->(%s)\n", This, iface, debugstr_guid(pFormat));
2308
2309 if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, pFormat))
2310 {
2311 FIXME("Unhandled time format %s\n", debugstr_guid(pFormat));
2312 return S_FALSE;
2313 }
2314
2315 return S_OK;
2316 }
2317
2318 static HRESULT WINAPI MediaSeeking_QueryPreferredFormat(IMediaSeeking *iface, GUID *pFormat)
2319 {
2320 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2321
2322 if (!pFormat)
2323 return E_POINTER;
2324
2325 FIXME("(%p/%p)->(%p): semi-stub !!!\n", This, iface, pFormat);
2326 memcpy(pFormat, &TIME_FORMAT_MEDIA_TIME, sizeof(GUID));
2327
2328 return S_OK;
2329 }
2330
2331 static HRESULT WINAPI MediaSeeking_GetTimeFormat(IMediaSeeking *iface, GUID *pFormat)
2332 {
2333 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2334
2335 if (!pFormat)
2336 return E_POINTER;
2337
2338 TRACE("(%p/%p)->(%p)\n", This, iface, pFormat);
2339 memcpy(pFormat, &This->timeformatseek, sizeof(GUID));
2340
2341 return S_OK;
2342 }
2343
2344 static HRESULT WINAPI MediaSeeking_IsUsingTimeFormat(IMediaSeeking *iface, const GUID *pFormat)
2345 {
2346 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2347
2348 TRACE("(%p/%p)->(%p)\n", This, iface, pFormat);
2349 if (!pFormat)
2350 return E_POINTER;
2351
2352 if (memcmp(pFormat, &This->timeformatseek, sizeof(GUID)))
2353 return S_FALSE;
2354
2355 return S_OK;
2356 }
2357
2358 static HRESULT WINAPI MediaSeeking_SetTimeFormat(IMediaSeeking *iface, const GUID *pFormat)
2359 {
2360 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2361
2362 if (!pFormat)
2363 return E_POINTER;
2364
2365 TRACE("(%p/%p)->(%s)\n", This, iface, debugstr_guid(pFormat));
2366
2367 if (This->state != State_Stopped)
2368 return VFW_E_WRONG_STATE;
2369
2370 if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, pFormat))
2371 {
2372 FIXME("Unhandled time format %s\n", debugstr_guid(pFormat));
2373 return E_INVALIDARG;
2374 }
2375
2376 return S_OK;
2377 }
2378
2379 static HRESULT WINAPI FoundDuration(IFilterGraphImpl *This, IMediaSeeking *seek, DWORD_PTR pduration)
2380 {
2381 HRESULT hr;
2382 LONGLONG duration = 0, *pdur = (LONGLONG*)pduration;
2383
2384 hr = IMediaSeeking_GetDuration(seek, &duration);
2385 if (FAILED(hr))
2386 return hr;
2387
2388 if (*pdur < duration)
2389 *pdur = duration;
2390 return hr;
2391 }
2392
2393 static HRESULT WINAPI MediaSeeking_GetDuration(IMediaSeeking *iface, LONGLONG *pDuration)
2394 {
2395 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2396 HRESULT hr;
2397
2398 TRACE("(%p/%p)->(%p)\n", This, iface, pDuration);
2399
2400 if (!pDuration)
2401 return E_POINTER;
2402
2403 EnterCriticalSection(&This->cs);
2404 *pDuration = 0;
2405 hr = all_renderers_seek(This, FoundDuration, (DWORD_PTR)pDuration);
2406 LeaveCriticalSection(&This->cs);
2407
2408 TRACE("--->%08x\n", hr);
2409 return hr;
2410 }
2411
2412 static HRESULT WINAPI MediaSeeking_GetStopPosition(IMediaSeeking *iface, LONGLONG *pStop)
2413 {
2414 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2415 HRESULT hr = S_OK;
2416
2417 TRACE("(%p/%p)->(%p)\n", This, iface, pStop);
2418
2419 if (!pStop)
2420 return E_POINTER;
2421
2422 EnterCriticalSection(&This->cs);
2423 if (This->stop_position < 0)
2424 /* Stop position not set, use duration instead */
2425 hr = IMediaSeeking_GetDuration(iface, pStop);
2426 else
2427 *pStop = This->stop_position;
2428 LeaveCriticalSection(&This->cs);
2429
2430 return hr;
2431 }
2432
2433 static HRESULT WINAPI FoundCurrentPosition(IFilterGraphImpl *This, IMediaSeeking *seek, DWORD_PTR pposition)
2434 {
2435 HRESULT hr;
2436 LONGLONG pos = 0, *ppos = (LONGLONG*)pposition;
2437
2438 hr = IMediaSeeking_GetCurrentPosition(seek, &pos);
2439 if (FAILED(hr))
2440 return hr;
2441
2442 if (*ppos < 0 || pos < *ppos)
2443 *ppos = pos;
2444 return hr;
2445 }
2446
2447 static HRESULT WINAPI MediaSeeking_GetCurrentPosition(IMediaSeeking *iface, LONGLONG *pCurrent)
2448 {
2449 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2450 HRESULT hr;
2451
2452 if (!pCurrent)
2453 return E_POINTER;
2454
2455 EnterCriticalSection(&This->cs);
2456 *pCurrent = -1;
2457 hr = all_renderers_seek(This, FoundCurrentPosition, (DWORD_PTR)pCurrent);
2458 if (hr == E_NOTIMPL) {
2459 *pCurrent = 0;
2460 hr = S_OK;
2461 }
2462 LeaveCriticalSection(&This->cs);
2463
2464 TRACE("Time: %u.%03u\n", (DWORD)(*pCurrent / 10000000), (DWORD)((*pCurrent / 10000)%1000));
2465
2466 return hr;
2467 }
2468
2469 static HRESULT WINAPI MediaSeeking_ConvertTimeFormat(IMediaSeeking *iface, LONGLONG *pTarget,
2470 const GUID *pTargetFormat, LONGLONG Source, const GUID *pSourceFormat)
2471 {
2472 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2473
2474 FIXME("(%p/%p)->(%p, %p, 0x%s, %p): stub !!!\n", This, iface, pTarget,
2475 pTargetFormat, wine_dbgstr_longlong(Source), pSourceFormat);
2476
2477 return S_OK;
2478 }
2479
2480 struct pos_args {
2481 LONGLONG* current, *stop;
2482 DWORD curflags, stopflags;
2483 };
2484
2485 static HRESULT WINAPI found_setposition(IFilterGraphImpl *This, IMediaSeeking *seek, DWORD_PTR pargs)
2486 {
2487 struct pos_args *args = (void*)pargs;
2488
2489 return IMediaSeeking_SetPositions(seek, args->current, args->curflags, args->stop, args->stopflags);
2490 }
2491
2492 static HRESULT WINAPI MediaSeeking_SetPositions(IMediaSeeking *iface, LONGLONG *pCurrent,
2493 DWORD dwCurrentFlags, LONGLONG *pStop, DWORD dwStopFlags)
2494 {
2495 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2496 HRESULT hr = S_OK;
2497 FILTER_STATE state;
2498 struct pos_args args;
2499
2500 TRACE("(%p/%p)->(%p, %08x, %p, %08x)\n", This, iface, pCurrent, dwCurrentFlags, pStop, dwStopFlags);
2501
2502 EnterCriticalSection(&This->cs);
2503 state = This->state;
2504 TRACE("State: %s\n", state == State_Running ? "Running" : (state == State_Paused ? "Paused" : (state == State_Stopped ? "Stopped" : "UNKNOWN")));
2505
2506 if ((dwCurrentFlags & 0x7) != AM_SEEKING_AbsolutePositioning &&
2507 (dwCurrentFlags & 0x7) != AM_SEEKING_NoPositioning)
2508 FIXME("Adjust method %x not handled yet!\n", dwCurrentFlags & 0x7);
2509
2510 if ((dwStopFlags & 0x7) == AM_SEEKING_AbsolutePositioning)
2511 This->stop_position = *pStop;
2512 else if ((dwStopFlags & 0x7) != AM_SEEKING_NoPositioning)
2513 FIXME("Stop position not handled yet!\n");
2514
2515 if (state == State_Running && !(dwCurrentFlags & AM_SEEKING_NoFlush))
2516 IMediaControl_Pause(&This->IMediaControl_iface);
2517 args.current = pCurrent;
2518 args.stop = pStop;
2519 args.curflags = dwCurrentFlags;
2520 args.stopflags = dwStopFlags;
2521 hr = all_renderers_seek(This, found_setposition, (DWORD_PTR)&args);
2522
2523 if ((dwCurrentFlags & 0x7) != AM_SEEKING_NoPositioning)
2524 This->pause_time = This->start_time = -1;
2525 if (state == State_Running && !(dwCurrentFlags & AM_SEEKING_NoFlush))
2526 IMediaControl_Run(&This->IMediaControl_iface);
2527 LeaveCriticalSection(&This->cs);
2528
2529 return hr;
2530 }
2531
2532 static HRESULT WINAPI MediaSeeking_GetPositions(IMediaSeeking *iface, LONGLONG *pCurrent,
2533 LONGLONG *pStop)
2534 {
2535 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2536 HRESULT hr;
2537
2538 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pCurrent, pStop);
2539 hr = IMediaSeeking_GetCurrentPosition(iface, pCurrent);
2540 if (SUCCEEDED(hr))
2541 hr = IMediaSeeking_GetStopPosition(iface, pStop);
2542
2543 return hr;
2544 }
2545
2546 static HRESULT WINAPI MediaSeeking_GetAvailable(IMediaSeeking *iface, LONGLONG *pEarliest,
2547 LONGLONG *pLatest)
2548 {
2549 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2550
2551 FIXME("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pEarliest, pLatest);
2552
2553 return S_OK;
2554 }
2555
2556 static HRESULT WINAPI MediaSeeking_SetRate(IMediaSeeking *iface, double dRate)
2557 {
2558 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2559
2560 FIXME("(%p/%p)->(%f): stub !!!\n", This, iface, dRate);
2561
2562 return S_OK;
2563 }
2564
2565 static HRESULT WINAPI MediaSeeking_GetRate(IMediaSeeking *iface, double *pdRate)
2566 {
2567 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2568
2569 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pdRate);
2570
2571 return S_OK;
2572 }
2573
2574 static HRESULT WINAPI MediaSeeking_GetPreroll(IMediaSeeking *iface, LONGLONG *pllPreroll)
2575 {
2576 IFilterGraphImpl *This = impl_from_IMediaSeeking(iface);
2577
2578 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pllPreroll);
2579
2580 return S_OK;
2581 }
2582
2583
2584 static const IMediaSeekingVtbl IMediaSeeking_VTable =
2585 {
2586 MediaSeeking_QueryInterface,
2587 MediaSeeking_AddRef,
2588 MediaSeeking_Release,
2589 MediaSeeking_GetCapabilities,
2590 MediaSeeking_CheckCapabilities,
2591 MediaSeeking_IsFormatSupported,
2592 MediaSeeking_QueryPreferredFormat,
2593 MediaSeeking_GetTimeFormat,
2594 MediaSeeking_IsUsingTimeFormat,
2595 MediaSeeking_SetTimeFormat,
2596 MediaSeeking_GetDuration,
2597 MediaSeeking_GetStopPosition,
2598 MediaSeeking_GetCurrentPosition,
2599 MediaSeeking_ConvertTimeFormat,
2600 MediaSeeking_SetPositions,
2601 MediaSeeking_GetPositions,
2602 MediaSeeking_GetAvailable,
2603 MediaSeeking_SetRate,
2604 MediaSeeking_GetRate,
2605 MediaSeeking_GetPreroll
2606 };
2607
2608 static inline IFilterGraphImpl *impl_from_IMediaPosition(IMediaPosition *iface)
2609 {
2610 return CONTAINING_RECORD(iface, IFilterGraphImpl, IMediaPosition_iface);
2611 }
2612
2613 /*** IUnknown methods ***/
2614 static HRESULT WINAPI MediaPosition_QueryInterface(IMediaPosition* iface, REFIID riid, void** ppvObj)
2615 {
2616 IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2617
2618 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
2619 return Filtergraph_QueryInterface(This, riid, ppvObj);
2620 }
2621
2622 static ULONG WINAPI MediaPosition_AddRef(IMediaPosition *iface)
2623 {
2624 IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2625
2626 TRACE("(%p/%p)->()\n", This, iface);
2627 return Filtergraph_AddRef(This);
2628 }
2629
2630 static ULONG WINAPI MediaPosition_Release(IMediaPosition *iface)
2631 {
2632 IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2633
2634 TRACE("(%p/%p)->()\n", This, iface);
2635 return Filtergraph_Release(This);
2636 }
2637
2638 /*** IDispatch methods ***/
2639 static HRESULT WINAPI MediaPosition_GetTypeInfoCount(IMediaPosition *iface, UINT* pctinfo){
2640 FIXME("(%p) stub!\n", iface);
2641 return E_NOTIMPL;
2642 }
2643
2644 static HRESULT WINAPI MediaPosition_GetTypeInfo(IMediaPosition *iface, UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo){
2645 FIXME("(%p) stub!\n", iface);
2646 return E_NOTIMPL;
2647 }
2648
2649 static HRESULT WINAPI MediaPosition_GetIDsOfNames(IMediaPosition* iface, REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId){
2650 FIXME("(%p) stub!\n", iface);
2651 return E_NOTIMPL;
2652 }
2653
2654 static HRESULT WINAPI MediaPosition_Invoke(IMediaPosition* iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr){
2655 FIXME("(%p) stub!\n", iface);
2656 return E_NOTIMPL;
2657 }
2658
2659 static HRESULT ConvertFromREFTIME(IMediaSeeking *seek, REFTIME time_in, LONGLONG *time_out)
2660 {
2661 GUID time_format;
2662 HRESULT hr;
2663
2664 hr = MediaSeeking_GetTimeFormat(seek, &time_format);
2665 if (FAILED(hr))
2666 return hr;
2667 if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, &time_format))
2668 {
2669 FIXME("Unsupported time format.\n");
2670 return E_NOTIMPL;
2671 }
2672
2673 *time_out = (LONGLONG) (time_in * 10000000); /* convert from 1 second intervals to 100 ns intervals */
2674 return S_OK;
2675 }
2676
2677 static HRESULT ConvertToREFTIME(IMediaSeeking *seek, LONGLONG time_in, REFTIME *time_out)
2678 {
2679 GUID time_format;
2680 HRESULT hr;
2681
2682 hr = MediaSeeking_GetTimeFormat(seek, &time_format);
2683 if (FAILED(hr))
2684 return hr;
2685 if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, &time_format))
2686 {
2687 FIXME("Unsupported time format.\n");
2688 return E_NOTIMPL;
2689 }
2690
2691 *time_out = (REFTIME)time_in / 10000000; /* convert from 100 ns intervals to 1 second intervals */
2692 return S_OK;
2693 }
2694
2695 /*** IMediaPosition methods ***/
2696 static HRESULT WINAPI MediaPosition_get_Duration(IMediaPosition * iface, REFTIME *plength)
2697 {
2698 LONGLONG duration;
2699 IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2700 HRESULT hr = IMediaSeeking_GetDuration(&This->IMediaSeeking_iface, &duration);
2701 if (FAILED(hr))
2702 return hr;
2703 return ConvertToREFTIME(&This->IMediaSeeking_iface, duration, plength);
2704 }
2705
2706 static HRESULT WINAPI MediaPosition_put_CurrentPosition(IMediaPosition * iface, REFTIME llTime)
2707 {
2708 IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2709 LONGLONG reftime;
2710 HRESULT hr;
2711
2712 hr = ConvertFromREFTIME(&This->IMediaSeeking_iface, llTime, &reftime);
2713 if (FAILED(hr))
2714 return hr;
2715 return IMediaSeeking_SetPositions(&This->IMediaSeeking_iface, &reftime,
2716 AM_SEEKING_AbsolutePositioning, NULL, AM_SEEKING_NoPositioning);
2717 }
2718
2719 static HRESULT WINAPI MediaPosition_get_CurrentPosition(IMediaPosition * iface, REFTIME *pllTime)
2720 {
2721 IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2722 LONGLONG pos;
2723 HRESULT hr;
2724
2725 hr = IMediaSeeking_GetCurrentPosition(&This->IMediaSeeking_iface, &pos);
2726 if (FAILED(hr))
2727 return hr;
2728 return ConvertToREFTIME(&This->IMediaSeeking_iface, pos, pllTime);
2729 }
2730
2731 static HRESULT WINAPI MediaPosition_get_StopTime(IMediaPosition * iface, REFTIME *pllTime)
2732 {
2733 IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2734 LONGLONG pos;
2735 HRESULT hr = IMediaSeeking_GetStopPosition(&This->IMediaSeeking_iface, &pos);
2736 if (FAILED(hr))
2737 return hr;
2738 return ConvertToREFTIME(&This->IMediaSeeking_iface, pos, pllTime);
2739 }
2740
2741 static HRESULT WINAPI MediaPosition_put_StopTime(IMediaPosition * iface, REFTIME llTime)
2742 {
2743 IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2744 LONGLONG reftime;
2745 HRESULT hr;
2746
2747 hr = ConvertFromREFTIME(&This->IMediaSeeking_iface, llTime, &reftime);
2748 if (FAILED(hr))
2749 return hr;
2750 return IMediaSeeking_SetPositions(&This->IMediaSeeking_iface, NULL, AM_SEEKING_NoPositioning,
2751 &reftime, AM_SEEKING_AbsolutePositioning);
2752 }
2753
2754 static HRESULT WINAPI MediaPosition_get_PrerollTime(IMediaPosition * iface, REFTIME *pllTime){
2755 FIXME("(%p)->(%p) stub!\n", iface, pllTime);
2756 return E_NOTIMPL;
2757 }
2758
2759 static HRESULT WINAPI MediaPosition_put_PrerollTime(IMediaPosition * iface, REFTIME llTime){
2760 FIXME("(%p)->(%f) stub!\n", iface, llTime);
2761 return E_NOTIMPL;
2762 }
2763
2764 static HRESULT WINAPI MediaPosition_put_Rate(IMediaPosition * iface, double dRate)
2765 {
2766 IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2767 return IMediaSeeking_SetRate(&This->IMediaSeeking_iface, dRate);
2768 }
2769
2770 static HRESULT WINAPI MediaPosition_get_Rate(IMediaPosition * iface, double *pdRate)
2771 {
2772 IFilterGraphImpl *This = impl_from_IMediaPosition( iface );
2773 return IMediaSeeking_GetRate(&This->IMediaSeeking_iface, pdRate);
2774 }
2775
2776 static HRESULT WINAPI MediaPosition_CanSeekForward(IMediaPosition * iface, LONG *pCanSeekForward){
2777 FIXME("(%p)->(%p) stub!\n", iface, pCanSeekForward);
2778 return E_NOTIMPL;
2779 }
2780
2781 static HRESULT WINAPI MediaPosition_CanSeekBackward(IMediaPosition * iface, LONG *pCanSeekBackward){
2782 FIXME("(%p)->(%p) stub!\n", iface, pCanSeekBackward);
2783 return E_NOTIMPL;
2784 }
2785
2786
2787 static const IMediaPositionVtbl IMediaPosition_VTable =
2788 {
2789 MediaPosition_QueryInterface,
2790 MediaPosition_AddRef,
2791 MediaPosition_Release,
2792 MediaPosition_GetTypeInfoCount,
2793 MediaPosition_GetTypeInfo,
2794 MediaPosition_GetIDsOfNames,
2795 MediaPosition_Invoke,
2796 MediaPosition_get_Duration,
2797 MediaPosition_put_CurrentPosition,
2798 MediaPosition_get_CurrentPosition,
2799 MediaPosition_get_StopTime,
2800 MediaPosition_put_StopTime,
2801 MediaPosition_get_PrerollTime,
2802 MediaPosition_put_PrerollTime,
2803 MediaPosition_put_Rate,
2804 MediaPosition_get_Rate,
2805 MediaPosition_CanSeekForward,
2806 MediaPosition_CanSeekBackward
2807 };
2808
2809 static inline IFilterGraphImpl *impl_from_IObjectWithSite(IObjectWithSite *iface)
2810 {
2811 return CONTAINING_RECORD(iface, IFilterGraphImpl, IObjectWithSite_iface);
2812 }
2813
2814 /*** IUnknown methods ***/
2815 static HRESULT WINAPI ObjectWithSite_QueryInterface(IObjectWithSite* iface, REFIID riid, void** ppvObj)
2816 {
2817 IFilterGraphImpl *This = impl_from_IObjectWithSite( iface );
2818
2819 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
2820 return Filtergraph_QueryInterface(This, riid, ppvObj);
2821 }
2822
2823 static ULONG WINAPI ObjectWithSite_AddRef(IObjectWithSite *iface)
2824 {
2825 IFilterGraphImpl *This = impl_from_IObjectWithSite( iface );
2826
2827 TRACE("(%p/%p)->()\n", This, iface);
2828 return Filtergraph_AddRef(This);
2829 }
2830
2831 static ULONG WINAPI ObjectWithSite_Release(IObjectWithSite *iface)
2832 {
2833 IFilterGraphImpl *This = impl_from_IObjectWithSite( iface );
2834
2835 TRACE("(%p/%p)->()\n", This, iface);
2836 return Filtergraph_Release(This);
2837 }
2838
2839 /*** IObjectWithSite methods ***/
2840
2841 static HRESULT WINAPI ObjectWithSite_SetSite(IObjectWithSite *iface, IUnknown *pUnkSite)
2842 {
2843 IFilterGraphImpl *This = impl_from_IObjectWithSite( iface );
2844
2845 TRACE("(%p/%p)->()\n", This, iface);
2846 if (This->pSite) IUnknown_Release(This->pSite);
2847 This->pSite = pUnkSite;
2848 IUnknown_AddRef(This->pSite);
2849 return S_OK;
2850 }
2851
2852 static HRESULT WINAPI ObjectWithSite_GetSite(IObjectWithSite *iface, REFIID riid, PVOID *ppvSite)
2853 {
2854 IFilterGraphImpl *This = impl_from_IObjectWithSite( iface );
2855
2856 TRACE("(%p/%p)->(%s)\n", This, iface,debugstr_guid(riid));
2857
2858 *ppvSite = NULL;
2859 if (!This->pSite)
2860 return E_FAIL;
2861 else
2862 return IUnknown_QueryInterface(This->pSite, riid, ppvSite);
2863 }
2864
2865 static const IObjectWithSiteVtbl IObjectWithSite_VTable =
2866 {
2867 ObjectWithSite_QueryInterface,
2868 ObjectWithSite_AddRef,
2869 ObjectWithSite_Release,
2870 ObjectWithSite_SetSite,
2871 ObjectWithSite_GetSite,
2872 };
2873
2874 static HRESULT GetTargetInterface(IFilterGraphImpl* pGraph, REFIID riid, LPVOID* ppvObj)
2875 {
2876 HRESULT hr = E_NOINTERFACE;
2877 int i;
2878 int entry;
2879
2880 /* Check if the interface type is already registered */
2881 for (entry = 0; entry < pGraph->nItfCacheEntries; entry++)
2882 if (riid == pGraph->ItfCacheEntries[entry].riid)
2883 {
2884 if (pGraph->ItfCacheEntries[entry].iface)
2885 {
2886 /* Return the interface if available */
2887 *ppvObj = pGraph->ItfCacheEntries[entry].iface;
2888 return S_OK;
2889 }
2890 break;
2891 }
2892
2893 if (entry >= MAX_ITF_CACHE_ENTRIES)
2894 {
2895 FIXME("Not enough space to store interface in the cache\n");
2896 return E_OUTOFMEMORY;
2897 }
2898
2899 /* Find a filter supporting the requested interface */
2900 for (i = 0; i < pGraph->nFilters; i++)
2901 {
2902 hr = IBaseFilter_QueryInterface(pGraph->ppFiltersInGraph[i], riid, ppvObj);
2903 if (hr == S_OK)
2904 {
2905 pGraph->ItfCacheEntries[entry].riid = riid;
2906 pGraph->ItfCacheEntries[entry].filter = pGraph->ppFiltersInGraph[i];
2907 pGraph->ItfCacheEntries[entry].iface = *ppvObj;
2908 if (entry >= pGraph->nItfCacheEntries)
2909 pGraph->nItfCacheEntries++;
2910 return S_OK;
2911 }
2912 if (hr != E_NOINTERFACE)
2913 return hr;
2914 }
2915
2916 return hr;
2917 }
2918
2919 static inline IFilterGraphImpl *impl_from_IBasicAudio(IBasicAudio *iface)
2920 {
2921 return CONTAINING_RECORD(iface, IFilterGraphImpl, IBasicAudio_iface);
2922 }
2923
2924 static HRESULT WINAPI BasicAudio_QueryInterface(IBasicAudio *iface, REFIID riid, void **ppvObj)
2925 {
2926 IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
2927
2928 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
2929
2930 return Filtergraph_QueryInterface(This, riid, ppvObj);
2931 }
2932
2933 static ULONG WINAPI BasicAudio_AddRef(IBasicAudio *iface)
2934 {
2935 IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
2936
2937 TRACE("(%p/%p)->()\n", This, iface);
2938
2939 return Filtergraph_AddRef(This);
2940 }
2941
2942 static ULONG WINAPI BasicAudio_Release(IBasicAudio *iface)
2943 {
2944 IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
2945
2946 TRACE("(%p/%p)->()\n", This, iface);
2947
2948 return Filtergraph_Release(This);
2949 }
2950
2951 /*** IDispatch methods ***/
2952 static HRESULT WINAPI BasicAudio_GetTypeInfoCount(IBasicAudio *iface, UINT *pctinfo)
2953 {
2954 IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
2955 IBasicAudio* pBasicAudio;
2956 HRESULT hr;
2957
2958 TRACE("(%p/%p)->(%p)\n", This, iface, pctinfo);
2959
2960 EnterCriticalSection(&This->cs);
2961
2962 hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
2963
2964 if (hr == S_OK)
2965 hr = IBasicAudio_GetTypeInfoCount(pBasicAudio, pctinfo);
2966
2967 LeaveCriticalSection(&This->cs);
2968
2969 return hr;
2970 }
2971
2972 static HRESULT WINAPI BasicAudio_GetTypeInfo(IBasicAudio *iface, UINT iTInfo, LCID lcid,
2973 ITypeInfo **ppTInfo)
2974 {
2975 IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
2976 IBasicAudio* pBasicAudio;
2977 HRESULT hr;
2978
2979 TRACE("(%p/%p)->(%d, %d, %p)\n", This, iface, iTInfo, lcid, ppTInfo);
2980
2981 EnterCriticalSection(&This->cs);
2982
2983 hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
2984
2985 if (hr == S_OK)
2986 hr = IBasicAudio_GetTypeInfo(pBasicAudio, iTInfo, lcid, ppTInfo);
2987
2988 LeaveCriticalSection(&This->cs);
2989
2990 return hr;
2991 }
2992
2993 static HRESULT WINAPI BasicAudio_GetIDsOfNames(IBasicAudio *iface, REFIID riid, LPOLESTR *rgszNames,
2994 UINT cNames, LCID lcid, DISPID *rgDispId)
2995 {
2996 IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
2997 IBasicAudio* pBasicAudio;
2998 HRESULT hr;
2999
3000 TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p)\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
3001
3002 EnterCriticalSection(&This->cs);
3003
3004 hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3005
3006 if (hr == S_OK)
3007 hr = IBasicAudio_GetIDsOfNames(pBasicAudio, riid, rgszNames, cNames, lcid, rgDispId);
3008
3009 LeaveCriticalSection(&This->cs);
3010
3011 return hr;
3012 }
3013
3014 static HRESULT WINAPI BasicAudio_Invoke(IBasicAudio *iface, DISPID dispIdMember, REFIID riid,
3015 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo,
3016 UINT *puArgErr)
3017 {
3018 IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3019 IBasicAudio* pBasicAudio;
3020 HRESULT hr;
3021
3022 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);
3023
3024 EnterCriticalSection(&This->cs);
3025
3026 hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3027
3028 if (hr == S_OK)
3029 hr = IBasicAudio_Invoke(pBasicAudio, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
3030
3031 LeaveCriticalSection(&This->cs);
3032
3033 return hr;
3034 }
3035
3036 /*** IBasicAudio methods ***/
3037 static HRESULT WINAPI BasicAudio_put_Volume(IBasicAudio *iface, LONG lVolume)
3038 {
3039 IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3040 IBasicAudio* pBasicAudio;
3041 HRESULT hr;
3042
3043 TRACE("(%p/%p)->(%d)\n", This, iface, lVolume);
3044
3045 EnterCriticalSection(&This->cs);
3046
3047 hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3048
3049 if (hr == S_OK)
3050 hr = IBasicAudio_put_Volume(pBasicAudio, lVolume);
3051
3052 LeaveCriticalSection(&This->cs);
3053
3054 return hr;
3055 }
3056
3057 static HRESULT WINAPI BasicAudio_get_Volume(IBasicAudio *iface, LONG *plVolume)
3058 {
3059 IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3060 IBasicAudio* pBasicAudio;
3061 HRESULT hr;
3062
3063 TRACE("(%p/%p)->(%p)\n", This, iface, plVolume);
3064
3065 EnterCriticalSection(&This->cs);
3066
3067 hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3068
3069 if (hr == S_OK)
3070 hr = IBasicAudio_get_Volume(pBasicAudio, plVolume);
3071
3072 LeaveCriticalSection(&This->cs);
3073
3074 return hr;
3075 }
3076
3077 static HRESULT WINAPI BasicAudio_put_Balance(IBasicAudio *iface, LONG lBalance)
3078 {
3079 IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3080 IBasicAudio* pBasicAudio;
3081 HRESULT hr;
3082
3083 TRACE("(%p/%p)->(%d)\n", This, iface, lBalance);
3084
3085 EnterCriticalSection(&This->cs);
3086
3087 hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3088
3089 if (hr == S_OK)
3090 hr = IBasicAudio_put_Balance(pBasicAudio, lBalance);
3091
3092 LeaveCriticalSection(&This->cs);
3093
3094 return hr;
3095 }
3096
3097 static HRESULT WINAPI BasicAudio_get_Balance(IBasicAudio *iface, LONG *plBalance)
3098 {
3099 IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
3100 IBasicAudio* pBasicAudio;
3101 HRESULT hr;
3102
3103 TRACE("(%p/%p)->(%p)\n", This, iface, plBalance);
3104
3105 EnterCriticalSection(&This->cs);
3106
3107 hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3108
3109 if (hr == S_OK)
3110 hr = IBasicAudio_get_Balance(pBasicAudio, plBalance);
3111
3112 LeaveCriticalSection(&This->cs);
3113
3114 return hr;
3115 }
3116
3117 static const IBasicAudioVtbl IBasicAudio_VTable =
3118 {
3119 BasicAudio_QueryInterface,
3120 BasicAudio_AddRef,
3121 BasicAudio_Release,
3122 BasicAudio_GetTypeInfoCount,
3123 BasicAudio_GetTypeInfo,
3124 BasicAudio_GetIDsOfNames,
3125 BasicAudio_Invoke,
3126 BasicAudio_put_Volume,
3127 BasicAudio_get_Volume,
3128 BasicAudio_put_Balance,
3129 BasicAudio_get_Balance
3130 };
3131
3132 static inline IFilterGraphImpl *impl_from_IBasicVideo2(IBasicVideo2 *iface)
3133 {
3134 return CONTAINING_RECORD(iface, IFilterGraphImpl, IBasicVideo2_iface);
3135 }
3136
3137 static HRESULT WINAPI BasicVideo_QueryInterface(IBasicVideo2 *iface, REFIID riid, void **ppvObj)
3138 {
3139 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3140
3141 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
3142
3143 return Filtergraph_QueryInterface(This, riid, ppvObj);
3144 }
3145
3146 static ULONG WINAPI BasicVideo_AddRef(IBasicVideo2 *iface)
3147 {
3148 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3149
3150 TRACE("(%p/%p)->()\n", This, iface);
3151
3152 return Filtergraph_AddRef(This);
3153 }
3154
3155 static ULONG WINAPI BasicVideo_Release(IBasicVideo2 *iface)
3156 {
3157 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3158
3159 TRACE("(%p/%p)->()\n", This, iface);
3160
3161 return Filtergraph_Release(This);
3162 }
3163
3164 /*** IDispatch methods ***/
3165 static HRESULT WINAPI BasicVideo_GetTypeInfoCount(IBasicVideo2 *iface, UINT *pctinfo)
3166 {
3167 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3168 IBasicVideo *pBasicVideo;
3169 HRESULT hr;
3170
3171 TRACE("(%p/%p)->(%p)\n", This, iface, pctinfo);
3172
3173 EnterCriticalSection(&This->cs);
3174
3175 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3176
3177 if (hr == S_OK)
3178 hr = IBasicVideo_GetTypeInfoCount(pBasicVideo, pctinfo);
3179
3180 LeaveCriticalSection(&This->cs);
3181
3182 return hr;
3183 }
3184
3185 static HRESULT WINAPI BasicVideo_GetTypeInfo(IBasicVideo2 *iface, UINT iTInfo, LCID lcid,
3186 ITypeInfo **ppTInfo)
3187 {
3188 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3189 IBasicVideo *pBasicVideo;
3190 HRESULT hr;
3191
3192 TRACE("(%p/%p)->(%d, %d, %p)\n", This, iface, iTInfo, lcid, ppTInfo);
3193
3194 EnterCriticalSection(&This->cs);
3195
3196 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3197
3198 if (hr == S_OK)
3199 hr = IBasicVideo_GetTypeInfo(pBasicVideo, iTInfo, lcid, ppTInfo);
3200
3201 LeaveCriticalSection(&This->cs);
3202
3203 return hr;
3204 }
3205
3206 static HRESULT WINAPI BasicVideo_GetIDsOfNames(IBasicVideo2 *iface, REFIID riid,
3207 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
3208 {
3209 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3210 IBasicVideo *pBasicVideo;
3211 HRESULT hr;
3212
3213 TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p)\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
3214
3215 EnterCriticalSection(&This->cs);
3216
3217 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3218
3219 if (hr == S_OK)
3220 hr = IBasicVideo_GetIDsOfNames(pBasicVideo, riid, rgszNames, cNames, lcid, rgDispId);
3221
3222 LeaveCriticalSection(&This->cs);
3223
3224 return hr;
3225 }
3226
3227 static HRESULT WINAPI BasicVideo_Invoke(IBasicVideo2 *iface, DISPID dispIdMember, REFIID riid,
3228 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo,
3229 UINT *puArgErr)
3230 {
3231 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3232 IBasicVideo *pBasicVideo;
3233 HRESULT hr;
3234
3235 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);
3236
3237 EnterCriticalSection(&This->cs);
3238
3239 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3240
3241 if (hr == S_OK)
3242 hr = IBasicVideo_Invoke(pBasicVideo, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
3243
3244 LeaveCriticalSection(&This->cs);
3245
3246 return hr;
3247 }
3248
3249 /*** IBasicVideo methods ***/
3250 static HRESULT WINAPI BasicVideo_get_AvgTimePerFrame(IBasicVideo2 *iface, REFTIME *pAvgTimePerFrame)
3251 {
3252 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3253 IBasicVideo *pBasicVideo;
3254 HRESULT hr;
3255
3256 TRACE("(%p/%p)->(%p)\n", This, iface, pAvgTimePerFrame);
3257
3258 EnterCriticalSection(&This->cs);
3259
3260 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3261
3262 if (hr == S_OK)
3263 hr = IBasicVideo_get_AvgTimePerFrame(pBasicVideo, pAvgTimePerFrame);
3264
3265 LeaveCriticalSection(&This->cs);
3266
3267 return hr;
3268 }
3269
3270 static HRESULT WINAPI BasicVideo_get_BitRate(IBasicVideo2 *iface, LONG *pBitRate)
3271 {
3272 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3273 IBasicVideo *pBasicVideo;
3274 HRESULT hr;
3275
3276 TRACE("(%p/%p)->(%p)\n", This, iface, pBitRate);
3277
3278 EnterCriticalSection(&This->cs);
3279
3280 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3281
3282 if (hr == S_OK)
3283 hr = IBasicVideo_get_BitRate(pBasicVideo, pBitRate);
3284
3285 LeaveCriticalSection(&This->cs);
3286
3287 return hr;
3288 }
3289
3290 static HRESULT WINAPI BasicVideo_get_BitErrorRate(IBasicVideo2 *iface, LONG *pBitErrorRate)
3291 {
3292 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3293 IBasicVideo *pBasicVideo;
3294 HRESULT hr;
3295
3296 TRACE("(%p/%p)->(%p)\n", This, iface, pBitErrorRate);
3297
3298 EnterCriticalSection(&This->cs);
3299
3300 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3301
3302 if (hr == S_OK)
3303 hr = IBasicVideo_get_BitErrorRate(pBasicVideo, pBitErrorRate);
3304
3305 LeaveCriticalSection(&This->cs);
3306
3307 return hr;
3308 }
3309
3310 static HRESULT WINAPI BasicVideo_get_VideoWidth(IBasicVideo2 *iface, LONG *pVideoWidth)
3311 {
3312 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3313 IBasicVideo *pBasicVideo;
3314 HRESULT hr;
3315
3316 TRACE("(%p/%p)->(%p)\n", This, iface, pVideoWidth);
3317
3318 EnterCriticalSection(&This->cs);
3319
3320 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3321
3322 if (hr == S_OK)
3323 hr = IBasicVideo_get_VideoWidth(pBasicVideo, pVideoWidth);
3324
3325 LeaveCriticalSection(&This->cs);
3326
3327 return hr;
3328 }
3329
3330 static HRESULT WINAPI BasicVideo_get_VideoHeight(IBasicVideo2 *iface, LONG *pVideoHeight)
3331 {
3332 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3333 IBasicVideo *pBasicVideo;
3334 HRESULT hr;
3335
3336 TRACE("(%p/%p)->(%p)\n", This, iface, pVideoHeight);
3337
3338 EnterCriticalSection(&This->cs);
3339
3340 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3341
3342 if (hr == S_OK)
3343 hr = IBasicVideo_get_VideoHeight(pBasicVideo, pVideoHeight);
3344
3345 LeaveCriticalSection(&This->cs);
3346
3347 return hr;
3348 }
3349
3350 static HRESULT WINAPI BasicVideo_put_SourceLeft(IBasicVideo2 *iface, LONG SourceLeft)
3351 {
3352 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3353 IBasicVideo *pBasicVideo;
3354 HRESULT hr;
3355
3356 TRACE("(%p/%p)->(%d)\n", This, iface, SourceLeft);
3357
3358 EnterCriticalSection(&This->cs);
3359
3360 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3361
3362 if (hr == S_OK)
3363 hr = IBasicVideo_put_SourceLeft(pBasicVideo, SourceLeft);
3364
3365 LeaveCriticalSection(&This->cs);
3366
3367 return hr;
3368 }
3369
3370 static HRESULT WINAPI BasicVideo_get_SourceLeft(IBasicVideo2 *iface, LONG *pSourceLeft)
3371 {
3372 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3373 IBasicVideo *pBasicVideo;
3374 HRESULT hr;
3375
3376 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceLeft);
3377
3378 EnterCriticalSection(&This->cs);
3379
3380 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3381
3382 if (hr == S_OK)
3383 hr = IBasicVideo_get_SourceLeft(pBasicVideo, pSourceLeft);
3384
3385 LeaveCriticalSection(&This->cs);
3386
3387 return hr;
3388 }
3389
3390 static HRESULT WINAPI BasicVideo_put_SourceWidth(IBasicVideo2 *iface, LONG SourceWidth)
3391 {
3392 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3393 IBasicVideo *pBasicVideo;
3394 HRESULT hr;
3395
3396 TRACE("(%p/%p)->(%d)\n", This, iface, SourceWidth);
3397
3398 EnterCriticalSection(&This->cs);
3399
3400 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3401
3402 if (hr == S_OK)
3403 hr = IBasicVideo_put_SourceWidth(pBasicVideo, SourceWidth);
3404
3405 LeaveCriticalSection(&This->cs);
3406
3407 return hr;
3408 }
3409
3410 static HRESULT WINAPI BasicVideo_get_SourceWidth(IBasicVideo2 *iface, LONG *pSourceWidth)
3411 {
3412 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3413 IBasicVideo *pBasicVideo;
3414 HRESULT hr;
3415
3416 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceWidth);
3417
3418 EnterCriticalSection(&This->cs);
3419
3420 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3421
3422 if (hr == S_OK)
3423 hr = IBasicVideo_get_SourceWidth(pBasicVideo, pSourceWidth);
3424
3425 LeaveCriticalSection(&This->cs);
3426
3427 return hr;
3428 }
3429
3430 static HRESULT WINAPI BasicVideo_put_SourceTop(IBasicVideo2 *iface, LONG SourceTop)
3431 {
3432 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3433 IBasicVideo *pBasicVideo;
3434 HRESULT hr;
3435
3436 TRACE("(%p/%p)->(%d)\n", This, iface, SourceTop);
3437
3438 EnterCriticalSection(&This->cs);
3439
3440 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3441
3442 if (hr == S_OK)
3443 hr = IBasicVideo_put_SourceTop(pBasicVideo, SourceTop);
3444
3445 LeaveCriticalSection(&This->cs);
3446
3447 return hr;
3448 }
3449
3450 static HRESULT WINAPI BasicVideo_get_SourceTop(IBasicVideo2 *iface, LONG *pSourceTop)
3451 {
3452 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3453 IBasicVideo *pBasicVideo;
3454 HRESULT hr;
3455
3456 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceTop);
3457
3458 EnterCriticalSection(&This->cs);
3459
3460 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3461
3462 if (hr == S_OK)
3463 hr = IBasicVideo_get_SourceTop(pBasicVideo, pSourceTop);
3464
3465 LeaveCriticalSection(&This->cs);
3466
3467 return hr;
3468 }
3469
3470 static HRESULT WINAPI BasicVideo_put_SourceHeight(IBasicVideo2 *iface, LONG SourceHeight)
3471 {
3472 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3473 IBasicVideo *pBasicVideo;
3474 HRESULT hr;
3475
3476 TRACE("(%p/%p)->(%d)\n", This, iface, SourceHeight);
3477
3478 EnterCriticalSection(&This->cs);
3479
3480 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3481
3482 if (hr == S_OK)
3483 hr = IBasicVideo_put_SourceHeight(pBasicVideo, SourceHeight);
3484
3485 LeaveCriticalSection(&This->cs);
3486
3487 return hr;
3488 }
3489
3490 static HRESULT WINAPI BasicVideo_get_SourceHeight(IBasicVideo2 *iface, LONG *pSourceHeight)
3491 {
3492 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3493 IBasicVideo *pBasicVideo;
3494 HRESULT hr;
3495
3496 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceHeight);
3497
3498 EnterCriticalSection(&This->cs);
3499
3500 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3501
3502 if (hr == S_OK)
3503 hr = IBasicVideo_get_SourceHeight(pBasicVideo, pSourceHeight);
3504
3505 LeaveCriticalSection(&This->cs);
3506
3507 return hr;
3508 }
3509
3510 static HRESULT WINAPI BasicVideo_put_DestinationLeft(IBasicVideo2 *iface, LONG DestinationLeft)
3511 {
3512 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3513 IBasicVideo *pBasicVideo;
3514 HRESULT hr;
3515
3516 TRACE("(%p/%p)->(%d)\n", This, iface, DestinationLeft);
3517
3518 EnterCriticalSection(&This->cs);
3519
3520 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3521
3522 if (hr == S_OK)
3523 hr = IBasicVideo_put_DestinationLeft(pBasicVideo, DestinationLeft);
3524
3525 LeaveCriticalSection(&This->cs);
3526
3527 return hr;
3528 }
3529
3530 static HRESULT WINAPI BasicVideo_get_DestinationLeft(IBasicVideo2 *iface, LONG *pDestinationLeft)
3531 {
3532 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3533 IBasicVideo *pBasicVideo;
3534 HRESULT hr;
3535
3536 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationLeft);
3537
3538 EnterCriticalSection(&This->cs);
3539
3540 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3541
3542 if (hr == S_OK)
3543 hr = IBasicVideo_get_DestinationLeft(pBasicVideo, pDestinationLeft);
3544
3545 LeaveCriticalSection(&This->cs);
3546
3547 return hr;
3548 }
3549
3550 static HRESULT WINAPI BasicVideo_put_DestinationWidth(IBasicVideo2 *iface, LONG DestinationWidth)
3551 {
3552 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3553 IBasicVideo *pBasicVideo;
3554 HRESULT hr;
3555
3556 TRACE("(%p/%p)->(%d)\n", This, iface, DestinationWidth);
3557
3558 EnterCriticalSection(&This->cs);
3559
3560 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3561
3562 if (hr == S_OK)
3563 hr = IBasicVideo_put_DestinationWidth(pBasicVideo, DestinationWidth);
3564
3565 LeaveCriticalSection(&This->cs);
3566
3567 return hr;
3568 }
3569
3570 static HRESULT WINAPI BasicVideo_get_DestinationWidth(IBasicVideo2 *iface, LONG *pDestinationWidth)
3571 {
3572 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3573 IBasicVideo *pBasicVideo;
3574 HRESULT hr;
3575
3576 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationWidth);
3577
3578 EnterCriticalSection(&This->cs);
3579
3580 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3581
3582 if (hr == S_OK)
3583 hr = IBasicVideo_get_DestinationWidth(pBasicVideo, pDestinationWidth);
3584
3585 LeaveCriticalSection(&This->cs);
3586
3587 return hr;
3588 }
3589
3590 static HRESULT WINAPI BasicVideo_put_DestinationTop(IBasicVideo2 *iface, LONG DestinationTop)
3591 {
3592 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3593 IBasicVideo *pBasicVideo;
3594 HRESULT hr;
3595
3596 TRACE("(%p/%p)->(%d)\n", This, iface, DestinationTop);
3597
3598 EnterCriticalSection(&This->cs);
3599
3600 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3601
3602 if (hr == S_OK)
3603 hr = IBasicVideo_put_DestinationTop(pBasicVideo, DestinationTop);
3604
3605 LeaveCriticalSection(&This->cs);
3606
3607 return hr;
3608 }
3609
3610 static HRESULT WINAPI BasicVideo_get_DestinationTop(IBasicVideo2 *iface, LONG *pDestinationTop)
3611 {
3612 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3613 IBasicVideo *pBasicVideo;
3614 HRESULT hr;
3615
3616 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationTop);
3617
3618 EnterCriticalSection(&This->cs);
3619
3620 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3621
3622 if (hr == S_OK)
3623 hr = IBasicVideo_get_DestinationTop(pBasicVideo, pDestinationTop);
3624
3625 LeaveCriticalSection(&This->cs);
3626
3627 return hr;
3628 }
3629
3630 static HRESULT WINAPI BasicVideo_put_DestinationHeight(IBasicVideo2 *iface, LONG DestinationHeight)
3631 {
3632 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3633 IBasicVideo *pBasicVideo;
3634 HRESULT hr;
3635
3636 TRACE("(%p/%p)->(%d)\n", This, iface, DestinationHeight);
3637
3638 EnterCriticalSection(&This->cs);
3639
3640 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3641
3642 if (hr == S_OK)
3643 hr = IBasicVideo_put_DestinationHeight(pBasicVideo, DestinationHeight);
3644
3645 LeaveCriticalSection(&This->cs);
3646
3647 return hr;
3648 }
3649
3650 static HRESULT WINAPI BasicVideo_get_DestinationHeight(IBasicVideo2 *iface,
3651 LONG *pDestinationHeight)
3652 {
3653 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3654 IBasicVideo *pBasicVideo;
3655 HRESULT hr;
3656
3657 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationHeight);
3658
3659 EnterCriticalSection(&This->cs);
3660
3661 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3662
3663 if (hr == S_OK)
3664 hr = IBasicVideo_get_DestinationHeight(pBasicVideo, pDestinationHeight);
3665
3666 LeaveCriticalSection(&This->cs);
3667
3668 return hr;
3669 }
3670
3671 static HRESULT WINAPI BasicVideo_SetSourcePosition(IBasicVideo2 *iface, LONG Left, LONG Top,
3672 LONG Width, LONG Height)
3673 {
3674 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3675 IBasicVideo *pBasicVideo;
3676 HRESULT hr;
3677
3678 TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
3679
3680 EnterCriticalSection(&This->cs);
3681
3682 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3683
3684 if (hr == S_OK)
3685 hr = IBasicVideo_SetSourcePosition(pBasicVideo, Left, Top, Width, Height);
3686
3687 LeaveCriticalSection(&This->cs);
3688
3689 return hr;
3690 }
3691
3692 static HRESULT WINAPI BasicVideo_GetSourcePosition(IBasicVideo2 *iface, LONG *pLeft, LONG *pTop,
3693 LONG *pWidth, LONG *pHeight)
3694 {
3695 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3696 IBasicVideo *pBasicVideo;
3697 HRESULT hr;
3698
3699 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
3700
3701 EnterCriticalSection(&This->cs);
3702
3703 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3704
3705 if (hr == S_OK)
3706 hr = IBasicVideo_GetSourcePosition(pBasicVideo, pLeft, pTop, pWidth, pHeight);
3707
3708 LeaveCriticalSection(&This->cs);
3709
3710 return hr;
3711 }
3712
3713 static HRESULT WINAPI BasicVideo_SetDefaultSourcePosition(IBasicVideo2 *iface)
3714 {
3715 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3716 IBasicVideo *pBasicVideo;
3717 HRESULT hr;
3718
3719 TRACE("(%p/%p)->()\n", This, iface);
3720
3721 EnterCriticalSection(&This->cs);
3722
3723 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3724
3725 if (hr == S_OK)
3726 hr = IBasicVideo_SetDefaultSourcePosition(pBasicVideo);
3727
3728 LeaveCriticalSection(&This->cs);
3729
3730 return hr;
3731 }
3732
3733 static HRESULT WINAPI BasicVideo_SetDestinationPosition(IBasicVideo2 *iface, LONG Left, LONG Top,
3734 LONG Width, LONG Height)
3735 {
3736 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3737 IBasicVideo *pBasicVideo;
3738 HRESULT hr;
3739
3740 TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
3741
3742 EnterCriticalSection(&This->cs);
3743
3744 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3745
3746 if (hr == S_OK)
3747 hr = IBasicVideo_SetDestinationPosition(pBasicVideo, Left, Top, Width, Height);
3748
3749 LeaveCriticalSection(&This->cs);
3750
3751 return hr;
3752 }
3753
3754 static HRESULT WINAPI BasicVideo_GetDestinationPosition(IBasicVideo2 *iface, LONG *pLeft,
3755 LONG *pTop, LONG *pWidth, LONG *pHeight)
3756 {
3757 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3758 IBasicVideo *pBasicVideo;
3759 HRESULT hr;
3760
3761 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
3762
3763 EnterCriticalSection(&This->cs);
3764
3765 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3766
3767 if (hr == S_OK)
3768 hr = IBasicVideo_GetDestinationPosition(pBasicVideo, pLeft, pTop, pWidth, pHeight);
3769
3770 LeaveCriticalSection(&This->cs);
3771
3772 return hr;
3773 }
3774
3775 static HRESULT WINAPI BasicVideo_SetDefaultDestinationPosition(IBasicVideo2 *iface)
3776 {
3777 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3778 IBasicVideo *pBasicVideo;
3779 HRESULT hr;
3780
3781 TRACE("(%p/%p)->()\n", This, iface);
3782
3783 EnterCriticalSection(&This->cs);
3784
3785 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3786
3787 if (hr == S_OK)
3788 hr = IBasicVideo_SetDefaultDestinationPosition(pBasicVideo);
3789
3790 LeaveCriticalSection(&This->cs);
3791
3792 return hr;
3793 }
3794
3795 static HRESULT WINAPI BasicVideo_GetVideoSize(IBasicVideo2 *iface, LONG *pWidth, LONG *pHeight)
3796 {
3797 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3798 IBasicVideo *pBasicVideo;
3799 HRESULT hr;
3800
3801 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
3802
3803 EnterCriticalSection(&This->cs);
3804
3805 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3806
3807 if (hr == S_OK)
3808 hr = IBasicVideo_GetVideoSize(pBasicVideo, pWidth, pHeight);
3809
3810 LeaveCriticalSection(&This->cs);
3811
3812 return hr;
3813 }
3814
3815 static HRESULT WINAPI BasicVideo_GetVideoPaletteEntries(IBasicVideo2 *iface, LONG StartIndex,
3816 LONG Entries, LONG *pRetrieved, LONG *pPalette)
3817 {
3818 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3819 IBasicVideo *pBasicVideo;
3820 HRESULT hr;
3821
3822 TRACE("(%p/%p)->(%d, %d, %p, %p)\n", This, iface, StartIndex, Entries, pRetrieved, pPalette);
3823
3824 EnterCriticalSection(&This->cs);
3825
3826 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3827
3828 if (hr == S_OK)
3829 hr = IBasicVideo_GetVideoPaletteEntries(pBasicVideo, StartIndex, Entries, pRetrieved, pPalette);
3830
3831 LeaveCriticalSection(&This->cs);
3832
3833 return hr;
3834 }
3835
3836 static HRESULT WINAPI BasicVideo_GetCurrentImage(IBasicVideo2 *iface, LONG *pBufferSize,
3837 LONG *pDIBImage)
3838 {
3839 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3840 IBasicVideo *pBasicVideo;
3841 HRESULT hr;
3842
3843 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pBufferSize, pDIBImage);
3844
3845 EnterCriticalSection(&This->cs);
3846
3847 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3848
3849 if (hr == S_OK)
3850 hr = IBasicVideo_GetCurrentImage(pBasicVideo, pBufferSize, pDIBImage);
3851
3852 LeaveCriticalSection(&This->cs);
3853
3854 return hr;
3855 }
3856
3857 static HRESULT WINAPI BasicVideo_IsUsingDefaultSource(IBasicVideo2 *iface)
3858 {
3859 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3860 IBasicVideo *pBasicVideo;
3861 HRESULT hr;
3862
3863 TRACE("(%p/%p)->()\n", This, iface);
3864
3865 EnterCriticalSection(&This->cs);
3866
3867 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3868
3869 if (hr == S_OK)
3870 hr = IBasicVideo_IsUsingDefaultSource(pBasicVideo);
3871
3872 LeaveCriticalSection(&This->cs);
3873
3874 return hr;
3875 }
3876
3877 static HRESULT WINAPI BasicVideo_IsUsingDefaultDestination(IBasicVideo2 *iface)
3878 {
3879 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3880 IBasicVideo *pBasicVideo;
3881 HRESULT hr;
3882
3883 TRACE("(%p/%p)->()\n", This, iface);
3884
3885 EnterCriticalSection(&This->cs);
3886
3887 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3888
3889 if (hr == S_OK)
3890 hr = IBasicVideo_IsUsingDefaultDestination(pBasicVideo);
3891
3892 LeaveCriticalSection(&This->cs);
3893
3894 return hr;
3895 }
3896
3897 static HRESULT WINAPI BasicVideo2_GetPreferredAspectRatio(IBasicVideo2 *iface, LONG *plAspectX,
3898 LONG *plAspectY)
3899 {
3900 IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
3901 IBasicVideo2 *pBasicVideo2;
3902 HRESULT hr;
3903
3904 TRACE("(%p/%p)->()\n", This, iface);
3905
3906 EnterCriticalSection(&This->cs);
3907
3908 hr = GetTargetInterface(This, &IID_IBasicVideo2, (LPVOID*)&pBasicVideo2);
3909
3910 if (hr == S_OK)
3911 hr = BasicVideo2_GetPreferredAspectRatio(iface, plAspectX, plAspectY);
3912
3913 LeaveCriticalSection(&This->cs);
3914
3915 return hr;
3916 }
3917
3918 static const IBasicVideo2Vtbl IBasicVideo_VTable =
3919 {
3920 BasicVideo_QueryInterface,
3921 BasicVideo_AddRef,
3922 BasicVideo_Release,
3923 BasicVideo_GetTypeInfoCount,
3924 BasicVideo_GetTypeInfo,
3925 BasicVideo_GetIDsOfNames,
3926 BasicVideo_Invoke,
3927 BasicVideo_get_AvgTimePerFrame,
3928 BasicVideo_get_BitRate,
3929 BasicVideo_get_BitErrorRate,
3930 BasicVideo_get_VideoWidth,
3931 BasicVideo_get_VideoHeight,
3932 BasicVideo_put_SourceLeft,
3933 BasicVideo_get_SourceLeft,
3934 BasicVideo_put_SourceWidth,
3935 BasicVideo_get_SourceWidth,
3936 BasicVideo_put_SourceTop,
3937 BasicVideo_get_SourceTop,
3938 BasicVideo_put_SourceHeight,
3939 BasicVideo_get_SourceHeight,
3940 BasicVideo_put_DestinationLeft,
3941 BasicVideo_get_DestinationLeft,
3942 BasicVideo_put_DestinationWidth,
3943 BasicVideo_get_DestinationWidth,
3944 BasicVideo_put_DestinationTop,
3945 BasicVideo_get_DestinationTop,
3946 BasicVideo_put_DestinationHeight,
3947 BasicVideo_get_DestinationHeight,
3948 BasicVideo_SetSourcePosition,
3949 BasicVideo_GetSourcePosition,
3950 BasicVideo_SetDefaultSourcePosition,
3951 BasicVideo_SetDestinationPosition,
3952 BasicVideo_GetDestinationPosition,
3953 BasicVideo_SetDefaultDestinationPosition,
3954 BasicVideo_GetVideoSize,
3955 BasicVideo_GetVideoPaletteEntries,
3956 BasicVideo_GetCurrentImage,
3957 BasicVideo_IsUsingDefaultSource,
3958 BasicVideo_IsUsingDefaultDestination,
3959 BasicVideo2_GetPreferredAspectRatio
3960 };
3961
3962 static inline IFilterGraphImpl *impl_from_IVideoWindow(IVideoWindow *iface)
3963 {
3964 return CONTAINING_RECORD(iface, IFilterGraphImpl, IVideoWindow_iface);
3965 }
3966
3967 static HRESULT WINAPI VideoWindow_QueryInterface(IVideoWindow *iface, REFIID riid, void **ppvObj)
3968 {
3969 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
3970
3971 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
3972
3973 return Filtergraph_QueryInterface(This, riid, ppvObj);
3974 }
3975
3976 static ULONG WINAPI VideoWindow_AddRef(IVideoWindow *iface)
3977 {
3978 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
3979
3980 TRACE("(%p/%p)->()\n", This, iface);
3981
3982 return Filtergraph_AddRef(This);
3983 }
3984
3985 static ULONG WINAPI VideoWindow_Release(IVideoWindow *iface)
3986 {
3987 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
3988
3989 TRACE("(%p/%p)->()\n", This, iface);
3990
3991 return Filtergraph_Release(This);
3992 }
3993
3994 /*** IDispatch methods ***/
3995 static HRESULT WINAPI VideoWindow_GetTypeInfoCount(IVideoWindow *iface, UINT *pctinfo)
3996 {
3997 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
3998 IVideoWindow *pVideoWindow;
3999 HRESULT hr;
4000
4001 TRACE("(%p/%p)->(%p)\n", This, iface, pctinfo);
4002
4003 EnterCriticalSection(&This->cs);
4004
4005 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4006
4007 if (hr == S_OK)
4008 hr = IVideoWindow_GetTypeInfoCount(pVideoWindow, pctinfo);
4009
4010 LeaveCriticalSection(&This->cs);
4011
4012 return hr;
4013 }
4014
4015 static HRESULT WINAPI VideoWindow_GetTypeInfo(IVideoWindow *iface, UINT iTInfo, LCID lcid,
4016 ITypeInfo **ppTInfo)
4017 {
4018 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4019 IVideoWindow *pVideoWindow;
4020 HRESULT hr;
4021
4022 TRACE("(%p/%p)->(%d, %d, %p)\n", This, iface, iTInfo, lcid, ppTInfo);
4023
4024 EnterCriticalSection(&This->cs);
4025
4026 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4027
4028 if (hr == S_OK)
4029 hr = IVideoWindow_GetTypeInfo(pVideoWindow, iTInfo, lcid, ppTInfo);
4030
4031 LeaveCriticalSection(&This->cs);
4032
4033 return hr;
4034 }
4035
4036 static HRESULT WINAPI VideoWindow_GetIDsOfNames(IVideoWindow *iface, REFIID riid,
4037 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4038 {
4039 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4040 IVideoWindow *pVideoWindow;
4041 HRESULT hr;
4042
4043 TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p)\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
4044
4045 EnterCriticalSection(&This->cs);
4046
4047 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4048
4049 if (hr == S_OK)
4050 hr = IVideoWindow_GetIDsOfNames(pVideoWindow, riid, rgszNames, cNames, lcid, rgDispId);
4051
4052 LeaveCriticalSection(&This->cs);
4053
4054 return hr;
4055 }
4056
4057 static HRESULT WINAPI VideoWindow_Invoke(IVideoWindow *iface, DISPID dispIdMember, REFIID riid,
4058 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo,
4059 UINT*puArgErr)
4060 {
4061 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4062 IVideoWindow *pVideoWindow;
4063 HRESULT hr;
4064
4065 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);
4066
4067 EnterCriticalSection(&This->cs);
4068
4069 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4070
4071 if (hr == S_OK)
4072 hr = IVideoWindow_Invoke(pVideoWindow, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
4073
4074 LeaveCriticalSection(&This->cs);
4075
4076 return hr;
4077 }
4078
4079
4080 /*** IVideoWindow methods ***/
4081 static HRESULT WINAPI VideoWindow_put_Caption(IVideoWindow *iface, BSTR strCaption)
4082 {
4083 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4084 IVideoWindow *pVideoWindow;
4085 HRESULT hr;
4086
4087 TRACE("(%p/%p)->(%s (%p))\n", This, iface, debugstr_w(strCaption), strCaption);
4088
4089 EnterCriticalSection(&This->cs);
4090
4091 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4092
4093 if (hr == S_OK)
4094 hr = IVideoWindow_put_Caption(pVideoWindow, strCaption);
4095
4096 LeaveCriticalSection(&This->cs);
4097
4098 return hr;
4099 }
4100
4101 static HRESULT WINAPI VideoWindow_get_Caption(IVideoWindow *iface, BSTR *strCaption)
4102 {
4103 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4104 IVideoWindow *pVideoWindow;
4105 HRESULT hr;
4106
4107 TRACE("(%p/%p)->(%p)\n", This, iface, strCaption);
4108
4109 EnterCriticalSection(&This->cs);
4110
4111 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4112
4113 if (hr == S_OK)
4114 hr = IVideoWindow_get_Caption(pVideoWindow, strCaption);
4115
4116 LeaveCriticalSection(&This->cs);
4117
4118 return hr;
4119 }
4120
4121 static HRESULT WINAPI VideoWindow_put_WindowStyle(IVideoWindow *iface, LONG WindowStyle)
4122 {
4123 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4124 IVideoWindow *pVideoWindow;
4125 HRESULT hr;
4126
4127 TRACE("(%p/%p)->(%d)\n", This, iface, WindowStyle);
4128
4129 EnterCriticalSection(&This->cs);
4130
4131 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4132
4133 if (hr == S_OK)
4134 hr = IVideoWindow_put_WindowStyle(pVideoWindow, WindowStyle);
4135
4136 LeaveCriticalSection(&This->cs);
4137
4138 return hr;
4139 }
4140
4141 static HRESULT WINAPI VideoWindow_get_WindowStyle(IVideoWindow *iface, LONG *WindowStyle)
4142 {
4143 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4144 IVideoWindow *pVideoWindow;
4145 HRESULT hr;
4146
4147 TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyle);
4148
4149 EnterCriticalSection(&This->cs);
4150
4151 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4152
4153 if (hr == S_OK)
4154 hr = IVideoWindow_get_WindowStyle(pVideoWindow, WindowStyle);
4155
4156 LeaveCriticalSection(&This->cs);
4157
4158 return hr;
4159 }
4160
4161 static HRESULT WINAPI VideoWindow_put_WindowStyleEx(IVideoWindow *iface, LONG WindowStyleEx)
4162 {
4163 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4164 IVideoWindow *pVideoWindow;
4165 HRESULT hr;
4166
4167 TRACE("(%p/%p)->(%d)\n", This, iface, WindowStyleEx);
4168
4169 EnterCriticalSection(&This->cs);
4170
4171 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4172
4173 if (hr == S_OK)
4174 hr = IVideoWindow_put_WindowStyleEx(pVideoWindow, WindowStyleEx);
4175
4176 LeaveCriticalSection(&This->cs);
4177
4178 return hr;
4179 }
4180
4181 static HRESULT WINAPI VideoWindow_get_WindowStyleEx(IVideoWindow *iface, LONG *WindowStyleEx)
4182 {
4183 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4184 IVideoWindow *pVideoWindow;
4185 HRESULT hr;
4186
4187 TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyleEx);
4188
4189 EnterCriticalSection(&This->cs);
4190
4191 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4192
4193 if (hr == S_OK)
4194 hr = IVideoWindow_get_WindowStyleEx(pVideoWindow, WindowStyleEx);
4195
4196 LeaveCriticalSection(&This->cs);
4197
4198 return hr;
4199 }
4200
4201 static HRESULT WINAPI VideoWindow_put_AutoShow(IVideoWindow *iface, LONG AutoShow)
4202 {
4203 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4204 IVideoWindow *pVideoWindow;
4205 HRESULT hr;
4206
4207 TRACE("(%p/%p)->(%d)\n", This, iface, AutoShow);
4208
4209 EnterCriticalSection(&This->cs);
4210
4211 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4212
4213 if (hr == S_OK)
4214 hr = IVideoWindow_put_AutoShow(pVideoWindow, AutoShow);
4215
4216 LeaveCriticalSection(&This->cs);
4217
4218 return hr;
4219 }
4220
4221 static HRESULT WINAPI VideoWindow_get_AutoShow(IVideoWindow *iface, LONG *AutoShow)
4222 {
4223 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4224 IVideoWindow *pVideoWindow;
4225 HRESULT hr;
4226
4227 TRACE("(%p/%p)->(%p)\n", This, iface, AutoShow);
4228
4229 EnterCriticalSection(&This->cs);
4230
4231 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4232
4233 if (hr == S_OK)
4234 hr = IVideoWindow_get_AutoShow(pVideoWindow, AutoShow);
4235
4236 LeaveCriticalSection(&This->cs);
4237
4238 return hr;
4239 }
4240
4241 static HRESULT WINAPI VideoWindow_put_WindowState(IVideoWindow *iface, LONG WindowState)
4242 {
4243 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4244 IVideoWindow *pVideoWindow;
4245 HRESULT hr;
4246
4247 TRACE("(%p/%p)->(%d)\n", This, iface, WindowState);
4248
4249 EnterCriticalSection(&This->cs);
4250
4251 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4252
4253 if (hr == S_OK)
4254 hr = IVideoWindow_put_WindowState(pVideoWindow, WindowState);
4255
4256 LeaveCriticalSection(&This->cs);
4257
4258 return hr;
4259 }
4260
4261 static HRESULT WINAPI VideoWindow_get_WindowState(IVideoWindow *iface, LONG *WindowState)
4262 {
4263 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4264 IVideoWindow *pVideoWindow;
4265 HRESULT hr;
4266
4267 TRACE("(%p/%p)->(%p)\n", This, iface, WindowState);
4268
4269 EnterCriticalSection(&This->cs);
4270
4271 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4272
4273 if (hr == S_OK)
4274 hr = IVideoWindow_get_WindowState(pVideoWindow, WindowState);
4275
4276 LeaveCriticalSection(&This->cs);
4277
4278 return hr;
4279 }
4280
4281 static HRESULT WINAPI VideoWindow_put_BackgroundPalette(IVideoWindow *iface, LONG BackgroundPalette)
4282 {
4283 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4284 IVideoWindow *pVideoWindow;
4285 HRESULT hr;
4286
4287 TRACE("(%p/%p)->(%d)\n", This, iface, BackgroundPalette);
4288
4289 EnterCriticalSection(&This->cs);
4290
4291 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4292
4293 if (hr == S_OK)
4294 hr = IVideoWindow_put_BackgroundPalette(pVideoWindow, BackgroundPalette);
4295
4296 LeaveCriticalSection(&This->cs);
4297
4298 return hr;
4299 }
4300
4301 static HRESULT WINAPI VideoWindow_get_BackgroundPalette(IVideoWindow *iface,
4302 LONG *pBackgroundPalette)
4303 {
4304 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4305 IVideoWindow *pVideoWindow;
4306 HRESULT hr;
4307
4308 TRACE("(%p/%p)->(%p)\n", This, iface, pBackgroundPalette);
4309
4310 EnterCriticalSection(&This->cs);
4311
4312 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4313
4314 if (hr == S_OK)
4315 hr = IVideoWindow_get_BackgroundPalette(pVideoWindow, pBackgroundPalette);
4316
4317 LeaveCriticalSection(&This->cs);
4318
4319 return hr;
4320 }
4321
4322 static HRESULT WINAPI VideoWindow_put_Visible(IVideoWindow *iface, LONG Visible)
4323 {
4324 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4325 IVideoWindow *pVideoWindow;
4326 HRESULT hr;
4327
4328 TRACE("(%p/%p)->(%d)\n", This, iface, Visible);
4329
4330 EnterCriticalSection(&This->cs);
4331
4332 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4333
4334 if (hr == S_OK)
4335 hr = IVideoWindow_put_Visible(pVideoWindow, Visible);
4336
4337 LeaveCriticalSection(&This->cs);
4338
4339 return hr;
4340 }
4341
4342 static HRESULT WINAPI VideoWindow_get_Visible(IVideoWindow *iface, LONG *pVisible)
4343 {
4344 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4345 IVideoWindow *pVideoWindow;
4346 HRESULT hr;
4347
4348 TRACE("(%p/%p)->(%p)\n", This, iface, pVisible);
4349
4350 EnterCriticalSection(&This->cs);
4351
4352 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4353
4354 if (hr == S_OK)
4355 hr = IVideoWindow_get_Visible(pVideoWindow, pVisible);
4356
4357 LeaveCriticalSection(&This->cs);
4358
4359 return hr;
4360 }
4361
4362 static HRESULT WINAPI VideoWindow_put_Left(IVideoWindow *iface, LONG Left)
4363 {
4364 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4365 IVideoWindow *pVideoWindow;
4366 HRESULT hr;
4367
4368 TRACE("(%p/%p)->(%d)\n", This, iface, Left);
4369
4370 EnterCriticalSection(&This->cs);
4371
4372 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4373
4374 if (hr == S_OK)
4375 hr = IVideoWindow_put_Left(pVideoWindow, Left);
4376
4377 LeaveCriticalSection(&This->cs);
4378
4379 return hr;
4380 }
4381
4382 static HRESULT WINAPI VideoWindow_get_Left(IVideoWindow *iface, LONG *pLeft)
4383 {
4384 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4385 IVideoWindow *pVideoWindow;
4386 HRESULT hr;
4387
4388 TRACE("(%p/%p)->(%p)\n", This, iface, pLeft);
4389
4390 EnterCriticalSection(&This->cs);
4391
4392 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4393
4394 if (hr == S_OK)
4395 hr = IVideoWindow_get_Left(pVideoWindow, pLeft);
4396
4397 LeaveCriticalSection(&This->cs);
4398
4399 return hr;
4400 }
4401
4402 static HRESULT WINAPI VideoWindow_put_Width(IVideoWindow *iface, LONG Width)
4403 {
4404 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4405 IVideoWindow *pVideoWindow;
4406 HRESULT hr;
4407
4408 TRACE("(%p/%p)->(%d)\n", This, iface, Width);
4409
4410 EnterCriticalSection(&This->cs);
4411
4412 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4413
4414 if (hr == S_OK)
4415 hr = IVideoWindow_put_Width(pVideoWindow, Width);
4416
4417 LeaveCriticalSection(&This->cs);
4418
4419 return hr;
4420 }
4421
4422 static HRESULT WINAPI VideoWindow_get_Width(IVideoWindow *iface, LONG *pWidth)
4423 {
4424 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4425 IVideoWindow *pVideoWindow;
4426 HRESULT hr;
4427
4428 TRACE("(%p/%p)->(%p)\n", This, iface, pWidth);
4429
4430 EnterCriticalSection(&This->cs);
4431
4432 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4433
4434 if (hr == S_OK)
4435 hr = IVideoWindow_get_Width(pVideoWindow, pWidth);
4436
4437 LeaveCriticalSection(&This->cs);
4438
4439 return hr;
4440 }
4441
4442 static HRESULT WINAPI VideoWindow_put_Top(IVideoWindow *iface, LONG Top)
4443 {
4444 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4445 IVideoWindow *pVideoWindow;
4446 HRESULT hr;
4447
4448 TRACE("(%p/%p)->(%d)\n", This, iface, Top);
4449
4450 EnterCriticalSection(&This->cs);
4451
4452 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4453
4454 if (hr == S_OK)
4455 hr = IVideoWindow_put_Top(pVideoWindow, Top);
4456
4457 LeaveCriticalSection(&This->cs);
4458
4459 return hr;
4460 }
4461
4462 static HRESULT WINAPI VideoWindow_get_Top(IVideoWindow *iface, LONG *pTop)
4463 {
4464 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4465 IVideoWindow *pVideoWindow;
4466 HRESULT hr;
4467
4468 TRACE("(%p/%p)->(%p)\n", This, iface, pTop);
4469
4470 EnterCriticalSection(&This->cs);
4471
4472 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4473
4474 if (hr == S_OK)
4475 hr = IVideoWindow_get_Top(pVideoWindow, pTop);
4476
4477 LeaveCriticalSection(&This->cs);
4478
4479 return hr;
4480 }
4481
4482 static HRESULT WINAPI VideoWindow_put_Height(IVideoWindow *iface, LONG Height)
4483 {
4484 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4485 IVideoWindow *pVideoWindow;
4486 HRESULT hr;
4487
4488 TRACE("(%p/%p)->(%d)\n", This, iface, Height);
4489
4490 EnterCriticalSection(&This->cs);
4491
4492 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4493
4494 if (hr == S_OK)
4495 hr = IVideoWindow_put_Height(pVideoWindow, Height);
4496
4497 LeaveCriticalSection(&This->cs);
4498
4499 return hr;
4500 }
4501
4502 static HRESULT WINAPI VideoWindow_get_Height(IVideoWindow *iface, LONG *pHeight)
4503 {
4504 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4505 IVideoWindow *pVideoWindow;
4506 HRESULT hr;
4507
4508 TRACE("(%p/%p)->(%p)\n", This, iface, pHeight);
4509
4510 EnterCriticalSection(&This->cs);
4511
4512 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4513
4514 if (hr == S_OK)
4515 hr = IVideoWindow_get_Height(pVideoWindow, pHeight);
4516
4517 LeaveCriticalSection(&This->cs);
4518
4519 return hr;
4520 }
4521
4522 static HRESULT WINAPI VideoWindow_put_Owner(IVideoWindow *iface, OAHWND Owner)
4523 {
4524 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4525 IVideoWindow *pVideoWindow;
4526 HRESULT hr;
4527
4528 TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Owner);
4529
4530 EnterCriticalSection(&This->cs);
4531
4532 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4533
4534 if (hr == S_OK)
4535 hr = IVideoWindow_put_Owner(pVideoWindow, Owner);
4536
4537 LeaveCriticalSection(&This->cs);
4538
4539 return hr;
4540 }
4541
4542 static HRESULT WINAPI VideoWindow_get_Owner(IVideoWindow *iface, OAHWND *Owner)
4543 {
4544 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4545 IVideoWindow *pVideoWindow;
4546 HRESULT hr;
4547
4548 TRACE("(%p/%p)->(%p)\n", This, iface, Owner);
4549
4550 EnterCriticalSection(&This->cs);
4551
4552 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4553
4554 if (hr == S_OK)
4555 hr = IVideoWindow_get_Owner(pVideoWindow, Owner);
4556
4557 LeaveCriticalSection(&This->cs);
4558
4559 return hr;
4560 }
4561
4562 static HRESULT WINAPI VideoWindow_put_MessageDrain(IVideoWindow *iface, OAHWND Drain)
4563 {
4564 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4565 IVideoWindow *pVideoWindow;
4566 HRESULT hr;
4567
4568 TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Drain);
4569
4570 EnterCriticalSection(&This->cs);
4571
4572 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4573
4574 if (hr == S_OK)
4575 hr = IVideoWindow_put_MessageDrain(pVideoWindow, Drain);
4576
4577 LeaveCriticalSection(&This->cs);
4578
4579 return hr;
4580 }
4581
4582 static HRESULT WINAPI VideoWindow_get_MessageDrain(IVideoWindow *iface, OAHWND *Drain)
4583 {
4584 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4585 IVideoWindow *pVideoWindow;
4586 HRESULT hr;
4587
4588 TRACE("(%p/%p)->(%p)\n", This, iface, Drain);
4589
4590 EnterCriticalSection(&This->cs);
4591
4592 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4593
4594 if (hr == S_OK)
4595 hr = IVideoWindow_get_MessageDrain(pVideoWindow, Drain);
4596
4597 LeaveCriticalSection(&This->cs);
4598
4599 return hr;
4600 }
4601
4602 static HRESULT WINAPI VideoWindow_get_BorderColor(IVideoWindow *iface, LONG *Color)
4603 {
4604 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4605 IVideoWindow *pVideoWindow;
4606 HRESULT hr;
4607
4608 TRACE("(%p/%p)->(%p)\n", This, iface, Color);
4609
4610 EnterCriticalSection(&This->cs);
4611
4612 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4613
4614 if (hr == S_OK)
4615 hr = IVideoWindow_get_BorderColor(pVideoWindow, Color);
4616
4617 LeaveCriticalSection(&This->cs);
4618
4619 return hr;
4620 }
4621
4622 static HRESULT WINAPI VideoWindow_put_BorderColor(IVideoWindow *iface, LONG Color)
4623 {
4624 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4625 IVideoWindow *pVideoWindow;
4626 HRESULT hr;
4627
4628 TRACE("(%p/%p)->(%d)\n", This, iface, Color);
4629
4630 EnterCriticalSection(&This->cs);
4631
4632 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4633
4634 if (hr == S_OK)
4635 hr = IVideoWindow_put_BorderColor(pVideoWindow, Color);
4636
4637 LeaveCriticalSection(&This->cs);
4638
4639 return hr;
4640 }
4641
4642 static HRESULT WINAPI VideoWindow_get_FullScreenMode(IVideoWindow *iface, LONG *FullScreenMode)
4643 {
4644 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4645 IVideoWindow *pVideoWindow;
4646 HRESULT hr;
4647
4648 TRACE("(%p/%p)->(%p)\n", This, iface, FullScreenMode);
4649
4650 EnterCriticalSection(&This->cs);
4651
4652 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4653
4654 if (hr == S_OK)
4655 hr = IVideoWindow_get_FullScreenMode(pVideoWindow, FullScreenMode);
4656
4657 LeaveCriticalSection(&This->cs);
4658
4659 return hr;
4660 }
4661
4662 static HRESULT WINAPI VideoWindow_put_FullScreenMode(IVideoWindow *iface, LONG FullScreenMode)
4663 {
4664 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4665 IVideoWindow *pVideoWindow;
4666 HRESULT hr;
4667
4668 TRACE("(%p/%p)->(%d)\n", This, iface, FullScreenMode);
4669
4670 EnterCriticalSection(&This->cs);
4671
4672 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4673
4674 if (hr == S_OK)
4675 hr = IVideoWindow_put_FullScreenMode(pVideoWindow, FullScreenMode);
4676
4677 LeaveCriticalSection(&This->cs);
4678
4679 return hr;
4680 }
4681
4682 static HRESULT WINAPI VideoWindow_SetWindowForeground(IVideoWindow *iface, LONG Focus)
4683 {
4684 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4685 IVideoWindow *pVideoWindow;
4686 HRESULT hr;
4687
4688 TRACE("(%p/%p)->(%d)\n", This, iface, Focus);
4689
4690 EnterCriticalSection(&This->cs);
4691
4692 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4693
4694 if (hr == S_OK)
4695 hr = IVideoWindow_SetWindowForeground(pVideoWindow, Focus);
4696
4697 LeaveCriticalSection(&This->cs);
4698
4699 return hr;
4700 }
4701
4702 static HRESULT WINAPI VideoWindow_NotifyOwnerMessage(IVideoWindow *iface, OAHWND hwnd, LONG uMsg,
4703 LONG_PTR wParam, LONG_PTR lParam)
4704 {
4705 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4706 IVideoWindow *pVideoWindow;
4707 HRESULT hr;
4708
4709 TRACE("(%p/%p)->(%08lx, %d, %08lx, %08lx)\n", This, iface, hwnd, uMsg, wParam, lParam);
4710
4711 EnterCriticalSection(&This->cs);
4712
4713 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4714
4715 if (hr == S_OK)
4716 hr = IVideoWindow_NotifyOwnerMessage(pVideoWindow, hwnd, uMsg, wParam, lParam);
4717
4718 LeaveCriticalSection(&This->cs);
4719
4720 return hr;
4721 }
4722
4723 static HRESULT WINAPI VideoWindow_SetWindowPosition(IVideoWindow *iface, LONG Left, LONG Top,
4724 LONG Width, LONG Height)
4725 {
4726 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4727 IVideoWindow *pVideoWindow;
4728 HRESULT hr;
4729
4730 TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
4731
4732 EnterCriticalSection(&This->cs);
4733
4734 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4735
4736 if (hr == S_OK)
4737 hr = IVideoWindow_SetWindowPosition(pVideoWindow, Left, Top, Width, Height);
4738
4739 LeaveCriticalSection(&This->cs);
4740
4741 return hr;
4742 }
4743
4744 static HRESULT WINAPI VideoWindow_GetWindowPosition(IVideoWindow *iface, LONG *pLeft, LONG *pTop,
4745 LONG *pWidth, LONG *pHeight)
4746 {
4747 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4748 IVideoWindow *pVideoWindow;
4749 HRESULT hr;
4750
4751 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
4752
4753 EnterCriticalSection(&This->cs);
4754
4755 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4756
4757 if (hr == S_OK)
4758 hr = IVideoWindow_GetWindowPosition(pVideoWindow, pLeft, pTop, pWidth, pHeight);
4759
4760 LeaveCriticalSection(&This->cs);
4761
4762 return hr;
4763 }
4764
4765 static HRESULT WINAPI VideoWindow_GetMinIdealImageSize(IVideoWindow *iface, LONG *pWidth,
4766 LONG *pHeight)
4767 {
4768 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4769 IVideoWindow *pVideoWindow;
4770 HRESULT hr;
4771
4772 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
4773
4774 EnterCriticalSection(&This->cs);
4775
4776 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4777
4778 if (hr == S_OK)
4779 hr = IVideoWindow_GetMinIdealImageSize(pVideoWindow, pWidth, pHeight);
4780
4781 LeaveCriticalSection(&This->cs);
4782
4783 return hr;
4784 }
4785
4786 static HRESULT WINAPI VideoWindow_GetMaxIdealImageSize(IVideoWindow *iface, LONG *pWidth,
4787 LONG *pHeight)
4788 {
4789 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4790 IVideoWindow *pVideoWindow;
4791 HRESULT hr;
4792
4793 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
4794
4795 EnterCriticalSection(&This->cs);
4796
4797 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4798
4799 if (hr == S_OK)
4800 hr = IVideoWindow_GetMaxIdealImageSize(pVideoWindow, pWidth, pHeight);
4801
4802 LeaveCriticalSection(&This->cs);
4803
4804 return hr;
4805 }
4806
4807 static HRESULT WINAPI VideoWindow_GetRestorePosition(IVideoWindow *iface, LONG *pLeft, LONG *pTop,
4808 LONG *pWidth, LONG *pHeight)
4809 {
4810 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4811 IVideoWindow *pVideoWindow;
4812 HRESULT hr;
4813
4814 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
4815
4816 EnterCriticalSection(&This->cs);
4817
4818 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4819
4820 if (hr == S_OK)
4821 hr = IVideoWindow_GetRestorePosition(pVideoWindow, pLeft, pTop, pWidth, pHeight);
4822
4823 LeaveCriticalSection(&This->cs);
4824
4825 return hr;
4826 }
4827
4828 static HRESULT WINAPI VideoWindow_HideCursor(IVideoWindow *iface, LONG HideCursor)
4829 {
4830 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4831 IVideoWindow *pVideoWindow;
4832 HRESULT hr;
4833
4834 TRACE("(%p/%p)->(%d)\n", This, iface, HideCursor);
4835
4836 EnterCriticalSection(&This->cs);
4837
4838 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4839
4840 if (hr == S_OK)
4841 hr = IVideoWindow_HideCursor(pVideoWindow, HideCursor);
4842
4843 LeaveCriticalSection(&This->cs);
4844
4845 return hr;
4846 }
4847
4848 static HRESULT WINAPI VideoWindow_IsCursorHidden(IVideoWindow *iface, LONG *CursorHidden)
4849 {
4850 IFilterGraphImpl *This = impl_from_IVideoWindow(iface);
4851 IVideoWindow *pVideoWindow;
4852 HRESULT hr;
4853
4854 TRACE("(%p/%p)->(%p)\n", This, iface, CursorHidden);
4855
4856 EnterCriticalSection(&This->cs);
4857
4858 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4859
4860 if (hr == S_OK)
4861 hr = IVideoWindow_IsCursorHidden(pVideoWindow, CursorHidden);
4862
4863 LeaveCriticalSection(&This->cs);
4864
4865 return hr;
4866 }
4867
4868
4869 static const IVideoWindowVtbl IVideoWindow_VTable =
4870 {
4871 VideoWindow_QueryInterface,
4872 VideoWindow_AddRef,
4873 VideoWindow_Release,
4874 VideoWindow_GetTypeInfoCount,
4875 VideoWindow_GetTypeInfo,
4876 VideoWindow_GetIDsOfNames,
4877 VideoWindow_Invoke,
4878 VideoWindow_put_Caption,
4879 VideoWindow_get_Caption,
4880 VideoWindow_put_WindowStyle,
4881 VideoWindow_get_WindowStyle,
4882 VideoWindow_put_WindowStyleEx,
4883 VideoWindow_get_WindowStyleEx,
4884 VideoWindow_put_AutoShow,
4885 VideoWindow_get_AutoShow,
4886 VideoWindow_put_WindowState,
4887 VideoWindow_get_WindowState,
4888 VideoWindow_put_BackgroundPalette,
4889 VideoWindow_get_BackgroundPalette,
4890 VideoWindow_put_Visible,
4891 VideoWindow_get_Visible,
4892 VideoWindow_put_Left,
4893 VideoWindow_get_Left,
4894 VideoWindow_put_Width,
4895 VideoWindow_get_Width,
4896 VideoWindow_put_Top,
4897 VideoWindow_get_Top,
4898 VideoWindow_put_Height,
4899 VideoWindow_get_Height,
4900 VideoWindow_put_Owner,
4901 VideoWindow_get_Owner,
4902 VideoWindow_put_MessageDrain,
4903 VideoWindow_get_MessageDrain,
4904 VideoWindow_get_BorderColor,
4905 VideoWindow_put_BorderColor,
4906 VideoWindow_get_FullScreenMode,
4907 VideoWindow_put_FullScreenMode,
4908 VideoWindow_SetWindowForeground,
4909 VideoWindow_NotifyOwnerMessage,
4910 VideoWindow_SetWindowPosition,
4911 VideoWindow_GetWindowPosition,
4912 VideoWindow_GetMinIdealImageSize,
4913 VideoWindow_GetMaxIdealImageSize,
4914 VideoWindow_GetRestorePosition,
4915 VideoWindow_HideCursor,
4916 VideoWindow_IsCursorHidden
4917 };
4918
4919 static inline IFilterGraphImpl *impl_from_IMediaEventEx(IMediaEventEx *iface)
4920 {
4921 return CONTAINING_RECORD(iface, IFilterGraphImpl, IMediaEventEx_iface);
4922 }
4923
4924 static HRESULT WINAPI MediaEvent_QueryInterface(IMediaEventEx *iface, REFIID riid, void **ppvObj)
4925 {
4926 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
4927
4928 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
4929
4930 return Filtergraph_QueryInterface(This, riid, ppvObj);
4931 }
4932
4933 static ULONG WINAPI MediaEvent_AddRef(IMediaEventEx *iface)
4934 {
4935 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
4936
4937 TRACE("(%p/%p)->()\n", This, iface);
4938
4939 return Filtergraph_AddRef(This);
4940 }
4941
4942 static ULONG WINAPI MediaEvent_Release(IMediaEventEx *iface)
4943 {
4944 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
4945
4946 TRACE("(%p/%p)->()\n", This, iface);
4947
4948 return Filtergraph_Release(This);
4949 }
4950
4951 /*** IDispatch methods ***/
4952 static HRESULT WINAPI MediaEvent_GetTypeInfoCount(IMediaEventEx *iface, UINT *pctinfo)
4953 {
4954 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
4955
4956 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
4957
4958 return S_OK;
4959 }
4960
4961 static HRESULT WINAPI MediaEvent_GetTypeInfo(IMediaEventEx *iface, UINT iTInfo, LCID lcid,
4962 ITypeInfo **ppTInfo)
4963 {
4964 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
4965
4966 TRACE("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
4967
4968 return S_OK;
4969 }
4970
4971 static HRESULT WINAPI MediaEvent_GetIDsOfNames(IMediaEventEx *iface, REFIID riid,
4972 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4973 {
4974 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
4975
4976 TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
4977
4978 return S_OK;
4979 }
4980
4981 static HRESULT WINAPI MediaEvent_Invoke(IMediaEventEx *iface, DISPID dispIdMember, REFIID riid,
4982 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo,
4983 UINT *puArgErr)
4984 {
4985 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
4986
4987 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);
4988
4989 return S_OK;
4990 }
4991
4992 /*** IMediaEvent methods ***/
4993 static HRESULT WINAPI MediaEvent_GetEventHandle(IMediaEventEx *iface, OAEVENT *hEvent)
4994 {
4995 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
4996
4997 TRACE("(%p/%p)->(%p)\n", This, iface, hEvent);
4998
4999 *hEvent = (OAEVENT)This->evqueue.msg_event;
5000
5001 return S_OK;
5002 }
5003
5004 static HRESULT WINAPI MediaEvent_GetEvent(IMediaEventEx *iface, LONG *lEventCode, LONG_PTR *lParam1,
5005 LONG_PTR *lParam2, LONG msTimeout)
5006 {
5007 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5008 Event evt;
5009
5010 TRACE("(%p/%p)->(%p, %p, %p, %d)\n", This, iface, lEventCode, lParam1, lParam2, msTimeout);
5011
5012 if (EventsQueue_GetEvent(&This->evqueue, &evt, msTimeout))
5013 {
5014 *lEventCode = evt.lEventCode;
5015 *lParam1 = evt.lParam1;
5016 *lParam2 = evt.lParam2;
5017 return S_OK;
5018 }
5019
5020 *lEventCode = 0;
5021 return E_ABORT;
5022 }
5023
5024 static HRESULT WINAPI MediaEvent_WaitForCompletion(IMediaEventEx *iface, LONG msTimeout,
5025 LONG *pEvCode)
5026 {
5027 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5028
5029 TRACE("(%p/%p)->(%d, %p)\n", This, iface, msTimeout, pEvCode);
5030
5031 if (This->state != State_Running)
5032 return VFW_E_WRONG_STATE;
5033
5034 if (WaitForSingleObject(This->hEventCompletion, msTimeout) == WAIT_OBJECT_0)
5035 {
5036 *pEvCode = This->CompletionStatus;
5037 return S_OK;
5038 }
5039
5040 *pEvCode = 0;
5041 return E_ABORT;
5042 }
5043
5044 static HRESULT WINAPI MediaEvent_CancelDefaultHandling(IMediaEventEx *iface, LONG lEvCode)
5045 {
5046 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5047
5048 TRACE("(%p/%p)->(%d)\n", This, iface, lEvCode);
5049
5050 if (lEvCode == EC_COMPLETE)
5051 This->HandleEcComplete = FALSE;
5052 else if (lEvCode == EC_REPAINT)
5053 This->HandleEcRepaint = FALSE;
5054 else if (lEvCode == EC_CLOCK_CHANGED)
5055 This->HandleEcClockChanged = FALSE;
5056 else
5057 return S_FALSE;
5058
5059 return S_OK;
5060 }
5061
5062 static HRESULT WINAPI MediaEvent_RestoreDefaultHandling(IMediaEventEx *iface, LONG lEvCode)
5063 {
5064 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5065
5066 TRACE("(%p/%p)->(%d)\n", This, iface, lEvCode);
5067
5068 if (lEvCode == EC_COMPLETE)
5069 This->HandleEcComplete = TRUE;
5070 else if (lEvCode == EC_REPAINT)
5071 This->HandleEcRepaint = TRUE;
5072 else if (lEvCode == EC_CLOCK_CHANGED)
5073 This->HandleEcClockChanged = TRUE;
5074 else
5075 return S_FALSE;
5076
5077 return S_OK;
5078 }
5079
5080 static HRESULT WINAPI MediaEvent_FreeEventParams(IMediaEventEx *iface, LONG lEvCode,
5081 LONG_PTR lParam1, LONG_PTR lParam2)
5082 {
5083 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5084
5085 TRACE("(%p/%p)->(%d, %08lx, %08lx): stub !!!\n", This, iface, lEvCode, lParam1, lParam2);
5086
5087 return S_OK;
5088 }
5089
5090 /*** IMediaEventEx methods ***/
5091 static HRESULT WINAPI MediaEvent_SetNotifyWindow(IMediaEventEx *iface, OAHWND hwnd, LONG lMsg,
5092 LONG_PTR lInstanceData)
5093 {
5094 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5095
5096 TRACE("(%p/%p)->(%08lx, %d, %08lx)\n", This, iface, hwnd, lMsg, lInstanceData);
5097
5098 This->notif.hWnd = (HWND)hwnd;
5099 This->notif.msg = lMsg;
5100 This->notif.instance = lInstanceData;
5101
5102 return S_OK;
5103 }
5104
5105 static HRESULT WINAPI MediaEvent_SetNotifyFlags(IMediaEventEx *iface, LONG lNoNotifyFlags)
5106 {
5107 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5108
5109 TRACE("(%p/%p)->(%d)\n", This, iface, lNoNotifyFlags);
5110
5111 if ((lNoNotifyFlags != 0) && (lNoNotifyFlags != 1))
5112 return E_INVALIDARG;
5113
5114 This->notif.disabled = lNoNotifyFlags;
5115
5116 return S_OK;
5117 }
5118
5119 static HRESULT WINAPI MediaEvent_GetNotifyFlags(IMediaEventEx *iface, LONG *lplNoNotifyFlags)
5120 {
5121 IFilterGraphImpl *This = impl_from_IMediaEventEx(iface);
5122
5123 TRACE("(%p/%p)->(%p)\n", This, iface, lplNoNotifyFlags);
5124
5125 if (!lplNoNotifyFlags)
5126 return E_POINTER;
5127
5128 *lplNoNotifyFlags = This->notif.disabled;
5129
5130 return S_OK;
5131 }
5132
5133
5134 static const IMediaEventExVtbl IMediaEventEx_VTable =
5135 {
5136 MediaEvent_QueryInterface,
5137 MediaEvent_AddRef,
5138 MediaEvent_Release,
5139 MediaEvent_GetTypeInfoCount,
5140 MediaEvent_GetTypeInfo,
5141 MediaEvent_GetIDsOfNames,
5142 MediaEvent_Invoke,
5143 MediaEvent_GetEventHandle,
5144 MediaEvent_GetEvent,
5145 MediaEvent_WaitForCompletion,
5146 MediaEvent_CancelDefaultHandling,
5147 MediaEvent_RestoreDefaultHandling,
5148 MediaEvent_FreeEventParams,
5149 MediaEvent_SetNotifyWindow,
5150 MediaEvent_SetNotifyFlags,
5151 MediaEvent_GetNotifyFlags
5152 };
5153
5154
5155 static inline IFilterGraphImpl *impl_from_IMediaFilter(IMediaFilter *iface)
5156 {
5157 return CONTAINING_RECORD(iface, IFilterGraphImpl, IMediaFilter_iface);
5158 }
5159
5160 static HRESULT WINAPI MediaFilter_QueryInterface(IMediaFilter *iface, REFIID riid, void **ppv)
5161 {
5162 IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5163
5164 return Filtergraph_QueryInterface(This, riid, ppv);
5165 }
5166
5167 static ULONG WINAPI MediaFilter_AddRef(IMediaFilter *iface)
5168 {
5169 IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5170
5171 return Filtergraph_AddRef(This);
5172 }
5173
5174 static ULONG WINAPI MediaFilter_Release(IMediaFilter *iface)
5175 {
5176 IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5177
5178 return Filtergraph_Release(This);
5179 }
5180
5181 static HRESULT WINAPI MediaFilter_GetClassID(IMediaFilter *iface, CLSID * pClassID)
5182 {
5183 FIXME("(%p): stub\n", pClassID);
5184
5185 return E_NOTIMPL;
5186 }
5187
5188 static HRESULT WINAPI MediaFilter_Stop(IMediaFilter *iface)
5189 {
5190 IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5191
5192 return MediaControl_Stop(&This->IMediaControl_iface);
5193 }
5194
5195 static HRESULT WINAPI MediaFilter_Pause(IMediaFilter *iface)
5196 {
5197 IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5198
5199 return MediaControl_Pause(&This->IMediaControl_iface);
5200 }
5201
5202 static HRESULT WINAPI MediaFilter_Run(IMediaFilter *iface, REFERENCE_TIME tStart)
5203 {
5204 IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5205
5206 if (tStart)
5207 FIXME("Run called with non-null tStart: %x%08x\n",
5208 (int)(tStart>>32), (int)tStart);
5209
5210 return MediaControl_Run(&This->IMediaControl_iface);
5211 }
5212
5213 static HRESULT WINAPI MediaFilter_GetState(IMediaFilter *iface, DWORD dwMsTimeout,
5214 FILTER_STATE *pState)
5215 {
5216 IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5217
5218 return MediaControl_GetState(&This->IMediaControl_iface, dwMsTimeout, (OAFilterState*)pState);
5219 }
5220
5221 static HRESULT WINAPI MediaFilter_SetSyncSource(IMediaFilter *iface, IReferenceClock *pClock)
5222 {
5223 IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5224 HRESULT hr = S_OK;
5225 int i;
5226
5227 TRACE("(%p/%p)->(%p)\n", iface, This, pClock);
5228
5229 EnterCriticalSection(&This->cs);
5230 {
5231 for (i = 0;i < This->nFilters;i++)
5232 {
5233 hr = IBaseFilter_SetSyncSource(This->ppFiltersInGraph[i], pClock);
5234 if (FAILED(hr))
5235 break;
5236 }
5237
5238 if (FAILED(hr))
5239 {
5240 for(;i >= 0;i--)
5241 IBaseFilter_SetSyncSource(This->ppFiltersInGraph[i], This->refClock);
5242 }
5243 else
5244 {
5245 if (This->refClock)
5246 IReferenceClock_Release(This->refClock);
5247 This->refClock = pClock;
5248 if (This->refClock)
5249 IReferenceClock_AddRef(This->refClock);
5250 This->defaultclock = FALSE;
5251
5252 if (This->HandleEcClockChanged)
5253 {
5254 IMediaEventSink *pEventSink;
5255 HRESULT eshr;
5256
5257 eshr = IMediaFilter_QueryInterface(iface, &IID_IMediaEventSink, (LPVOID)&pEventSink);
5258 if (SUCCEEDED(eshr))
5259 {
5260 IMediaEventSink_Notify(pEventSink, EC_CLOCK_CHANGED, 0, 0);
5261 IMediaEventSink_Release(pEventSink);
5262 }
5263 }
5264 }
5265 }
5266 LeaveCriticalSection(&This->cs);
5267
5268 return hr;
5269 }
5270
5271 static HRESULT WINAPI MediaFilter_GetSyncSource(IMediaFilter *iface, IReferenceClock **ppClock)
5272 {
5273 IFilterGraphImpl *This = impl_from_IMediaFilter(iface);
5274
5275 TRACE("(%p/%p)->(%p)\n", iface, This, ppClock);
5276
5277 if (!ppClock)
5278 return E_POINTER;
5279
5280 EnterCriticalSection(&This->cs);
5281 {
5282 *ppClock = This->refClock;
5283 if (*ppClock)
5284 IReferenceClock_AddRef(*ppClock);
5285 }
5286 LeaveCriticalSection(&This->cs);
5287
5288 return S_OK;
5289 }
5290
5291 static const IMediaFilterVtbl IMediaFilter_VTable =
5292 {
5293 MediaFilter_QueryInterface,
5294 MediaFilter_AddRef,
5295 MediaFilter_Release,
5296 MediaFilter_GetClassID,
5297 MediaFilter_Stop,
5298 MediaFilter_Pause,
5299 MediaFilter_Run,
5300 MediaFilter_GetState,
5301 MediaFilter_SetSyncSource,
5302 MediaFilter_GetSyncSource
5303 };
5304
5305 static inline IFilterGraphImpl *impl_from_IMediaEventSink(IMediaEventSink *iface)
5306 {
5307 return CONTAINING_RECORD(iface, IFilterGraphImpl, IMediaEventSink_iface);
5308 }
5309
5310 static HRESULT WINAPI MediaEventSink_QueryInterface(IMediaEventSink *iface, REFIID riid, void **ppv)
5311 {
5312 IFilterGraphImpl *This = impl_from_IMediaEventSink(iface);
5313
5314 return Filtergraph_QueryInterface(This, riid, ppv);
5315 }
5316
5317 static ULONG WINAPI MediaEventSink_AddRef(IMediaEventSink *iface)
5318 {
5319 IFilterGraphImpl *This = impl_from_IMediaEventSink(iface);
5320
5321 return Filtergraph_AddRef(This);
5322 }
5323
5324 static ULONG WINAPI MediaEventSink_Release(IMediaEventSink *iface)
5325 {
5326 IFilterGraphImpl *This = impl_from_IMediaEventSink(iface);
5327
5328 return Filtergraph_Release(This);
5329 }
5330
5331 static HRESULT WINAPI MediaEventSink_Notify(IMediaEventSink *iface, LONG EventCode,
5332 LONG_PTR EventParam1, LONG_PTR EventParam2)
5333 {
5334 IFilterGraphImpl *This = impl_from_IMediaEventSink(iface);
5335 Event evt;
5336
5337 TRACE("(%p/%p)->(%d, %ld, %ld)\n", This, iface, EventCode, EventParam1, EventParam2);
5338
5339 /* We need thread safety here, let's use the events queue's one */
5340 EnterCriticalSection(&This->evqueue.msg_crst);
5341
5342 if ((EventCode == EC_COMPLETE) && This->HandleEcComplete)
5343 {
5344 TRACE("Process EC_COMPLETE notification\n");
5345 if (++This->EcCompleteCount == This->nRenderers)
5346 {
5347 evt.lEventCode = EC_COMPLETE;
5348 evt.lParam1 = S_OK;
5349 evt.lParam2 = 0;
5350 TRACE("Send EC_COMPLETE to app\n");
5351 EventsQueue_PutEvent(&This->evqueue, &evt);
5352 if (!This->notif.disabled && This->notif.hWnd)
5353 {
5354 TRACE("Send Window message\n");
5355 PostMessageW(This->notif.hWnd, This->notif.msg, 0, This->notif.instance);
5356 }
5357 This->CompletionStatus = EC_COMPLETE;
5358 SetEvent(This->hEventCompletion);
5359 }
5360 }
5361 else if ((EventCode == EC_REPAINT) && This->HandleEcRepaint)
5362 {
5363 /* FIXME: Not handled yet */
5364 }
5365 else
5366 {
5367 evt.lEventCode = EventCode;
5368 evt.lParam1 = EventParam1;
5369 evt.lParam2 = EventParam2;
5370 EventsQueue_PutEvent(&This->evqueue, &evt);
5371 if (!This->notif.disabled && This->notif.hWnd)
5372 PostMessageW(This->notif.hWnd, This->notif.msg, 0, This->notif.instance);
5373 }
5374
5375 LeaveCriticalSection(&This->evqueue.msg_crst);
5376 return S_OK;
5377 }
5378
5379 static const IMediaEventSinkVtbl IMediaEventSink_VTable =
5380 {
5381 MediaEventSink_QueryInterface,
5382 MediaEventSink_AddRef,
5383 MediaEventSink_Release,
5384 MediaEventSink_Notify
5385 };
5386
5387 static inline IFilterGraphImpl *impl_from_IGraphConfig(IGraphConfig *iface)
5388 {
5389 return CONTAINING_RECORD(iface, IFilterGraphImpl, IGraphConfig_iface);
5390 }
5391
5392 static HRESULT WINAPI GraphConfig_QueryInterface(IGraphConfig *iface, REFIID riid, void **ppv)
5393 {
5394 IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5395
5396 return Filtergraph_QueryInterface(This, riid, ppv);
5397 }
5398
5399 static ULONG WINAPI GraphConfig_AddRef(IGraphConfig *iface)
5400 {
5401 IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5402
5403 return Filtergraph_AddRef(This);
5404 }
5405
5406 static ULONG WINAPI GraphConfig_Release(IGraphConfig *iface)
5407 {
5408 IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5409
5410 return Filtergraph_Release(This);
5411 }
5412
5413 static HRESULT WINAPI GraphConfig_Reconnect(IGraphConfig *iface, IPin *pOutputPin, IPin *pInputPin,
5414 const AM_MEDIA_TYPE *pmtFirstConnection, IBaseFilter *pUsingFilter, HANDLE hAbortEvent,
5415 DWORD dwFlags)
5416 {
5417 IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5418
5419 FIXME("(%p)->(%p, %p, %p, %p, %p, %x): stub!\n", This, pOutputPin, pInputPin, pmtFirstConnection, pUsingFilter, hAbortEvent, dwFlags);
5420
5421 return E_NOTIMPL;
5422 }
5423
5424 static HRESULT WINAPI GraphConfig_Reconfigure(IGraphConfig *iface, IGraphConfigCallback *pCallback,
5425 void *pvContext, DWORD dwFlags, HANDLE hAbortEvent)
5426 {
5427 IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5428 HRESULT hr;
5429
5430 WARN("(%p)->(%p, %p, %x, %p): partial stub!\n", This, pCallback, pvContext, dwFlags, hAbortEvent);
5431
5432 if (hAbortEvent)
5433 FIXME("The parameter hAbortEvent is not handled!\n");
5434
5435 EnterCriticalSection(&This->cs);
5436
5437 hr = IGraphConfigCallback_Reconfigure(pCallback, pvContext, dwFlags);
5438
5439 LeaveCriticalSection(&This->cs);
5440
5441 return hr;
5442 }
5443
5444 static HRESULT WINAPI GraphConfig_AddFilterToCache(IGraphConfig *iface, IBaseFilter *pFilter)
5445 {
5446 IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5447
5448 FIXME("(%p)->(%p): stub!\n", This, pFilter);
5449
5450 return E_NOTIMPL;
5451 }
5452
5453 static HRESULT WINAPI GraphConfig_EnumCacheFilter(IGraphConfig *iface, IEnumFilters **pEnum)
5454 {
5455 IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5456
5457 FIXME("(%p)->(%p): stub!\n", This, pEnum);
5458
5459 return E_NOTIMPL;
5460 }
5461
5462 static HRESULT WINAPI GraphConfig_RemoveFilterFromCache(IGraphConfig *iface, IBaseFilter *pFilter)
5463 {
5464 IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5465
5466 FIXME("(%p)->(%p): stub!\n", This, pFilter);
5467
5468 return E_NOTIMPL;
5469 }
5470
5471 static HRESULT WINAPI GraphConfig_GetStartTime(IGraphConfig *iface, REFERENCE_TIME *prtStart)
5472 {
5473 IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5474
5475 FIXME("(%p)->(%p): stub!\n", This, prtStart);
5476
5477 return E_NOTIMPL;
5478 }
5479
5480 static HRESULT WINAPI GraphConfig_PushThroughData(IGraphConfig *iface, IPin *pOutputPin,
5481 IPinConnection *pConnection, HANDLE hEventAbort)
5482 {
5483 IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5484
5485 FIXME("(%p)->(%p, %p, %p): stub!\n", This, pOutputPin, pConnection, hEventAbort);
5486
5487 return E_NOTIMPL;
5488 }
5489
5490 static HRESULT WINAPI GraphConfig_SetFilterFlags(IGraphConfig *iface, IBaseFilter *pFilter,
5491 DWORD dwFlags)
5492 {
5493 IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5494
5495 FIXME("(%p)->(%p, %x): stub!\n", This, pFilter, dwFlags);
5496
5497 return E_NOTIMPL;
5498 }
5499
5500 static HRESULT WINAPI GraphConfig_GetFilterFlags(IGraphConfig *iface, IBaseFilter *pFilter,
5501 DWORD *dwFlags)
5502 {
5503 IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5504
5505 FIXME("(%p)->(%p, %p): stub!\n", This, pFilter, dwFlags);
5506
5507 return E_NOTIMPL;
5508 }
5509
5510 static HRESULT WINAPI GraphConfig_RemoveFilterEx(IGraphConfig *iface, IBaseFilter *pFilter,
5511 DWORD dwFlags)
5512 {
5513 IFilterGraphImpl *This = impl_from_IGraphConfig(iface);
5514
5515 FIXME("(%p)->(%p, %x): stub!\n", This, pFilter, dwFlags);
5516
5517 return E_NOTIMPL;
5518 }
5519
5520 static const IGraphConfigVtbl IGraphConfig_VTable =
5521 {
5522 GraphConfig_QueryInterface,
5523 GraphConfig_AddRef,
5524 GraphConfig_Release,
5525 GraphConfig_Reconnect,
5526 GraphConfig_Reconfigure,
5527 GraphConfig_AddFilterToCache,
5528 GraphConfig_EnumCacheFilter,
5529 GraphConfig_RemoveFilterFromCache,
5530 GraphConfig_GetStartTime,
5531 GraphConfig_PushThroughData,
5532 GraphConfig_SetFilterFlags,
5533 GraphConfig_GetFilterFlags,
5534 GraphConfig_RemoveFilterEx
5535 };
5536
5537 static const IUnknownVtbl IInner_VTable =
5538 {
5539 FilterGraphInner_QueryInterface,
5540 FilterGraphInner_AddRef,
5541 FilterGraphInner_Release
5542 };
5543
5544 static HRESULT Filtergraph_QueryInterface(IFilterGraphImpl *This,
5545 REFIID riid,
5546 LPVOID * ppv) {
5547 if (This->bAggregatable)
5548 This->bUnkOuterValid = TRUE;
5549
5550 if (This->pUnkOuter)
5551 {
5552 if (This->bAggregatable)
5553 return IUnknown_QueryInterface(This->pUnkOuter, riid, ppv);
5554
5555 if (IsEqualIID(riid, &IID_IUnknown))
5556 {
5557 HRESULT hr;
5558
5559 IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl));
5560 hr = IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv);
5561 IUnknown_Release((IUnknown *)&(This->IInner_vtbl));
5562 This->bAggregatable = TRUE;
5563 return hr;
5564 }
5565
5566 *ppv = NULL;
5567 return E_NOINTERFACE;
5568 }
5569
5570 return IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv);
5571 }
5572
5573 static ULONG Filtergraph_AddRef(IFilterGraphImpl *This) {
5574 if (This->pUnkOuter && This->bUnkOuterValid)
5575 return IUnknown_AddRef(This->pUnkOuter);
5576 return IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl));
5577 }
5578
5579 static ULONG Filtergraph_Release(IFilterGraphImpl *This) {
5580 if (This->pUnkOuter && This->bUnkOuterValid)
5581 return IUnknown_Release(This->pUnkOuter);
5582 return IUnknown_Release((IUnknown *)&(This->IInner_vtbl));
5583 }
5584
5585 /* This is the only function that actually creates a FilterGraph class... */
5586 HRESULT FilterGraph_create(IUnknown *pUnkOuter, LPVOID *ppObj)
5587 {
5588 IFilterGraphImpl *fimpl;
5589 HRESULT hr;
5590
5591 TRACE("(%p,%p)\n", pUnkOuter, ppObj);
5592
5593 *ppObj = NULL;
5594
5595 fimpl = CoTaskMemAlloc(sizeof(*fimpl));
5596 fimpl->pUnkOuter = pUnkOuter;
5597 fimpl->bUnkOuterValid = FALSE;
5598 fimpl->bAggregatable = FALSE;
5599 fimpl->defaultclock = TRUE;
5600 fimpl->IInner_vtbl = &IInner_VTable;
5601 fimpl->IFilterGraph2_iface.lpVtbl = &IFilterGraph2_VTable;
5602 fimpl->IMediaControl_iface.lpVtbl = &IMediaControl_VTable;
5603 fimpl->IMediaSeeking_iface.lpVtbl = &IMediaSeeking_VTable;
5604 fimpl->IBasicAudio_iface.lpVtbl = &IBasicAudio_VTable;
5605 fimpl->IBasicVideo2_iface.lpVtbl = &IBasicVideo_VTable;
5606 fimpl->IVideoWindow_iface.lpVtbl = &IVideoWindow_VTable;
5607 fimpl->IMediaEventEx_iface.lpVtbl = &IMediaEventEx_VTable;
5608 fimpl->IMediaFilter_iface.lpVtbl = &IMediaFilter_VTable;
5609 fimpl->IMediaEventSink_iface.lpVtbl = &IMediaEventSink_VTable;
5610 fimpl->IGraphConfig_iface.lpVtbl = &IGraphConfig_VTable;
5611 fimpl->IMediaPosition_iface.lpVtbl = &IMediaPosition_VTable;
5612 fimpl->IObjectWithSite_iface.lpVtbl = &IObjectWithSite_VTable;
5613 fimpl->ref = 1;
5614 fimpl->ppFiltersInGraph = NULL;
5615 fimpl->pFilterNames = NULL;
5616 fimpl->nFilters = 0;
5617 fimpl->filterCapacity = 0;
5618 fimpl->nameIndex = 1;
5619 fimpl->refClock = NULL;
5620 fimpl->hEventCompletion = CreateEventW(0, TRUE, FALSE, 0);
5621 fimpl->HandleEcComplete = TRUE;
5622 fimpl->HandleEcRepaint = TRUE;
5623 fimpl->HandleEcClockChanged = TRUE;
5624 fimpl->notif.hWnd = 0;
5625 fimpl->notif.disabled = FALSE;
5626 fimpl->nRenderers = 0;
5627 fimpl->EcCompleteCount = 0;
5628 fimpl->refClockProvider = NULL;
5629 fimpl->state = State_Stopped;
5630 fimpl->pSite = NULL;
5631 EventsQueue_Init(&fimpl->evqueue);
5632 InitializeCriticalSection(&fimpl->cs);
5633 fimpl->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": IFilterGraphImpl.cs");
5634 fimpl->nItfCacheEntries = 0;
5635 memcpy(&fimpl->timeformatseek, &TIME_FORMAT_MEDIA_TIME, sizeof(GUID));
5636 fimpl->start_time = fimpl->pause_time = 0;
5637 fimpl->stop_position = -1;
5638 fimpl->punkFilterMapper2 = NULL;
5639 fimpl->recursioncount = 0;
5640
5641 /* create Filtermapper aggregated. */
5642 hr = CoCreateInstance(&CLSID_FilterMapper2, pUnkOuter ? pUnkOuter : (IUnknown*)&fimpl->IInner_vtbl, CLSCTX_INPROC_SERVER,
5643 &IID_IUnknown, (LPVOID*)&fimpl->punkFilterMapper2);
5644
5645 if (SUCCEEDED(hr)) {
5646 hr = IUnknown_QueryInterface(fimpl->punkFilterMapper2, &IID_IFilterMapper2, (LPVOID*)&fimpl->pFilterMapper2);
5647 }
5648
5649 if (SUCCEEDED(hr)) {
5650 /* Release controlling IUnknown - compensate refcount increase from caching IFilterMapper2 interface. */
5651 if (pUnkOuter) IUnknown_Release(pUnkOuter);
5652 else IUnknown_Release((IUnknown*)&fimpl->IInner_vtbl);
5653 }
5654
5655 if (FAILED(hr)) {
5656 ERR("Unable to create filter mapper (%x)\n", hr);
5657 if (fimpl->punkFilterMapper2) IUnknown_Release(fimpl->punkFilterMapper2);
5658 CloseHandle(fimpl->hEventCompletion);
5659 EventsQueue_Destroy(&fimpl->evqueue);
5660 fimpl->cs.DebugInfo->Spare[0] = 0;
5661 DeleteCriticalSection(&fimpl->cs);
5662 CoTaskMemFree(fimpl);
5663 return hr;
5664 }
5665
5666 *ppObj = fimpl;
5667 return S_OK;
5668 }
5669
5670 HRESULT FilterGraphNoThread_create(IUnknown *pUnkOuter, LPVOID *ppObj)
5671 {
5672 FIXME("CLSID_FilterGraphNoThread partially implemented - Forwarding to CLSID_FilterGraph\n");
5673 return FilterGraph_create(pUnkOuter, ppObj);
5674 }
Maarten's multimedia branch