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