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