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