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