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