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