?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implemented IMediaControl_Run that explores the graph, counts
[wine.git] / dlls / quartz / filtergraph.c
blob3d4a80d10fc9338ddb82753ccc1cf4b480caebc2
1 /* DirectShow FilterGraph object (QUARTZ.DLL)
2 *
3 * Copyright 2002 Lionel Ulmer
4 * Copyright 2004 Christian Costa
5 *
6 * This file contains the (internal) driver registration functions,
7 * driver enumeration APIs and DirectDraw creation functions.
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24 #include "config.h"
25 #include <stdarg.h>
26
27 #define COBJMACROS
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winuser.h"
32 #include "dshow.h"
33 #include "wine/debug.h"
34 #include "quartz_private.h"
35 #define COM_NO_WINDOWS_H
36 #include "ole2.h"
37 #include "olectl.h"
38 #include "strmif.h"
39 #include "vfwmsgs.h"
40 #include "evcode.h"
41 #include "wine/unicode.h"
42
43
44 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
45
46 typedef struct {
47 HWND hWnd; /* Target window */
48 long msg; /* User window message */
49 long instance; /* User data */
50 int disabled; /* Disabled messages posting */
51 } WndNotify;
52
53 typedef struct {
54 long lEventCode; /* Event code */
55 LONG_PTR lParam1; /* Param1 */
56 LONG_PTR lParam2; /* Param2 */
57 } Event;
58
59 /* messages ring implementation for queuing events (taken from winmm) */
60 #define EVENTS_RING_BUFFER_INCREMENT 64
61 typedef struct {
62 Event* messages;
63 int ring_buffer_size;
64 int msg_tosave;
65 int msg_toget;
66 CRITICAL_SECTION msg_crst;
67 HANDLE msg_event; /* Signaled for no empty queue */
68 } EventsQueue;
69
70 static int EventsQueue_Init(EventsQueue* omr)
71 {
72 omr->msg_toget = 0;
73 omr->msg_tosave = 0;
74 omr->msg_event = CreateEventW(NULL, TRUE, FALSE, NULL);
75 omr->ring_buffer_size = EVENTS_RING_BUFFER_INCREMENT;
76 omr->messages = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,omr->ring_buffer_size * sizeof(Event));
77
78 InitializeCriticalSection(&omr->msg_crst);
79 return TRUE;
80 }
81
82 static int EventsQueue_Destroy(EventsQueue* omr)
83 {
84 CloseHandle(omr->msg_event);
85 HeapFree(GetProcessHeap(),0,omr->messages);
86 DeleteCriticalSection(&omr->msg_crst);
87 return TRUE;
88 }
89
90 static int EventsQueue_PutEvent(EventsQueue* omr, Event* evt)
91 {
92 EnterCriticalSection(&omr->msg_crst);
93 if ((omr->msg_toget == ((omr->msg_tosave + 1) % omr->ring_buffer_size)))
94 {
95 int old_ring_buffer_size = omr->ring_buffer_size;
96 omr->ring_buffer_size += EVENTS_RING_BUFFER_INCREMENT;
97 TRACE("omr->ring_buffer_size=%d\n",omr->ring_buffer_size);
98 omr->messages = HeapReAlloc(GetProcessHeap(),0,omr->messages, omr->ring_buffer_size * sizeof(Event));
99 /* Now we need to rearrange the ring buffer so that the new
100 buffers just allocated are in between omr->msg_tosave and
101 omr->msg_toget.
102 */
103 if (omr->msg_tosave < omr->msg_toget)
104 {
105 memmove(&(omr->messages[omr->msg_toget + EVENTS_RING_BUFFER_INCREMENT]),
106 &(omr->messages[omr->msg_toget]),
107 sizeof(Event)*(old_ring_buffer_size - omr->msg_toget)
108 );
109 omr->msg_toget += EVENTS_RING_BUFFER_INCREMENT;
110 }
111 }
112 omr->messages[omr->msg_tosave] = *evt;
113 SetEvent(omr->msg_event);
114 omr->msg_tosave = (omr->msg_tosave + 1) % omr->ring_buffer_size;
115 LeaveCriticalSection(&omr->msg_crst);
116 return TRUE;
117 }
118
119 static int EventsQueue_GetEvent(EventsQueue* omr, Event* evt, long msTimeOut)
120 {
121 if (WaitForSingleObject(omr->msg_event, msTimeOut) != WAIT_OBJECT_0)
122 return FALSE;
123
124 EnterCriticalSection(&omr->msg_crst);
125
126 if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
127 {
128 LeaveCriticalSection(&omr->msg_crst);
129 return FALSE;
130 }
131
132 *evt = omr->messages[omr->msg_toget];
133 omr->msg_toget = (omr->msg_toget + 1) % omr->ring_buffer_size;
134
135 /* Mark the buffer as empty if needed */
136 if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
137 ResetEvent(omr->msg_event);
138
139 LeaveCriticalSection(&omr->msg_crst);
140 return TRUE;
141 }
142
143 typedef struct _IFilterGraphImpl {
144 IGraphBuilderVtbl *IGraphBuilder_vtbl;
145 IMediaControlVtbl *IMediaControl_vtbl;
146 IMediaSeekingVtbl *IMediaSeeking_vtbl;
147 IBasicAudioVtbl *IBasicAudio_vtbl;
148 IBasicVideoVtbl *IBasicVideo_vtbl;
149 IVideoWindowVtbl *IVideoWindow_vtbl;
150 IMediaEventExVtbl *IMediaEventEx_vtbl;
151 IMediaFilterVtbl *IMediaFilter_vtbl;
152 IMediaEventSinkVtbl *IMediaEventSink_vtbl;
153 /* IAMGraphStreams */
154 /* IAMStats */
155 /* IBasicVideo2 */
156 /* IFilterChain */
157 /* IFilterGraph2 */
158 /* IFilterMapper2 */
159 /* IGraphConfig */
160 /* IGraphVersion */
161 /* IMediaPosition */
162 /* IQueueCommand */
163 /* IRegisterServiceProvider */
164 /* IResourceMananger */
165 /* IServiceProvider */
166 /* IVideoFrameStep */
167
168 ULONG ref;
169 IFilterMapper2 * pFilterMapper2;
170 IBaseFilter ** ppFiltersInGraph;
171 LPWSTR * pFilterNames;
172 int nFilters;
173 int filterCapacity;
174 long nameIndex;
175 EventsQueue evqueue;
176 HANDLE hEventCompletion;
177 int CompletionStatus;
178 WndNotify notif;
179 int nRenderers;
180 int EcCompleteCount;
181 int HandleEcComplete;
182 int HandleEcRepaint;
183 OAFilterState state;
184 CRITICAL_SECTION cs;
185 } IFilterGraphImpl;
186
187
188 static HRESULT Filtergraph_QueryInterface(IFilterGraphImpl *This,
189 REFIID riid,
190 LPVOID *ppvObj) {
191 TRACE("(%p)->(%s (%p), %p)\n", This, debugstr_guid(riid), riid, ppvObj);
192
193 if (IsEqualGUID(&IID_IUnknown, riid) ||
194 IsEqualGUID(&IID_IFilterGraph, riid) ||
195 IsEqualGUID(&IID_IGraphBuilder, riid)) {
196 *ppvObj = &(This->IGraphBuilder_vtbl);
197 TRACE(" returning IGraphBuilder interface (%p)\n", *ppvObj);
198 } else if (IsEqualGUID(&IID_IMediaControl, riid)) {
199 *ppvObj = &(This->IMediaControl_vtbl);
200 TRACE(" returning IMediaControl interface (%p)\n", *ppvObj);
201 } else if (IsEqualGUID(&IID_IMediaSeeking, riid)) {
202 *ppvObj = &(This->IMediaSeeking_vtbl);
203 TRACE(" returning IMediaSeeking interface (%p)\n", *ppvObj);
204 } else if (IsEqualGUID(&IID_IBasicAudio, riid)) {
205 *ppvObj = &(This->IBasicAudio_vtbl);
206 TRACE(" returning IBasicAudio interface (%p)\n", *ppvObj);
207 } else if (IsEqualGUID(&IID_IBasicVideo, riid)) {
208 *ppvObj = &(This->IBasicVideo_vtbl);
209 TRACE(" returning IBasicVideo interface (%p)\n", *ppvObj);
210 } else if (IsEqualGUID(&IID_IVideoWindow, riid)) {
211 *ppvObj = &(This->IVideoWindow_vtbl);
212 TRACE(" returning IVideoWindow interface (%p)\n", *ppvObj);
213 } else if (IsEqualGUID(&IID_IMediaEvent, riid) ||
214 IsEqualGUID(&IID_IMediaEventEx, riid)) {
215 *ppvObj = &(This->IMediaEventEx_vtbl);
216 TRACE(" returning IMediaEvent(Ex) interface (%p)\n", *ppvObj);
217 } else if (IsEqualGUID(&IID_IMediaFilter, riid) ||
218 IsEqualGUID(&IID_IPersist, riid)) {
219 *ppvObj = &(This->IMediaFilter_vtbl);
220 TRACE(" returning IMediaFilter interface (%p)\n", *ppvObj);
221 } else if (IsEqualGUID(&IID_IMediaEventSink, riid)) {
222 *ppvObj = &(This->IMediaEventSink_vtbl);
223 TRACE(" returning IMediaEventSink interface (%p)\n", *ppvObj);
224 } else {
225 *ppvObj = NULL;
226 FIXME("unknown interface %s\n", debugstr_guid(riid));
227 return E_NOINTERFACE;
228 }
229
230 This->ref++;
231 return S_OK;
232 }
233
234 static ULONG Filtergraph_AddRef(IFilterGraphImpl *This) {
235 TRACE("(%p)->(): new ref = %ld\n", This, This->ref + 1);
236
237 return ++This->ref;
238 }
239
240 static ULONG Filtergraph_Release(IFilterGraphImpl *This) {
241 static ULONG ref;
242
243 TRACE("(%p)->(): new ref = %ld\n", This, This->ref - 1);
244
245 ref = --This->ref;
246 if (ref == 0) {
247 IFilterMapper2_Release(This->pFilterMapper2);
248 CloseHandle(This->hEventCompletion);
249 EventsQueue_Destroy(&This->evqueue);
250 DeleteCriticalSection(&This->cs);
251 HeapFree(GetProcessHeap(), 0, This->ppFiltersInGraph);
252 HeapFree(GetProcessHeap(), 0, This->pFilterNames);
253 HeapFree(GetProcessHeap(), 0, This);
254 }
255 return ref;
256 }
257
258
259 /*** IUnknown methods ***/
260 static HRESULT WINAPI Graphbuilder_QueryInterface(IGraphBuilder *iface,
261 REFIID riid,
262 LPVOID*ppvObj) {
263 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
264
265 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
266 return Filtergraph_QueryInterface(This, riid, ppvObj);
267 }
268
269 static ULONG WINAPI Graphbuilder_AddRef(IGraphBuilder *iface) {
270 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
271
272 TRACE("(%p/%p)->() calling FilterGraph AddRef\n", This, iface);
273
274 return Filtergraph_AddRef(This);
275 }
276
277 static ULONG WINAPI Graphbuilder_Release(IGraphBuilder *iface) {
278 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
279
280 TRACE("(%p/%p)->() calling FilterGraph Release\n", This, iface);
281
282 return Filtergraph_Release(This);
283 }
284
285 /*** IFilterGraph methods ***/
286 static HRESULT WINAPI Graphbuilder_AddFilter(IGraphBuilder *iface,
287 IBaseFilter *pFilter,
288 LPCWSTR pName) {
289 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
290 HRESULT hr;
291 int i,j;
292 WCHAR* wszFilterName = NULL;
293 int duplicate_name = FALSE;
294
295 TRACE("(%p/%p)->(%p, %s (%p))\n", This, iface, pFilter, debugstr_w(pName), pName);
296
297 wszFilterName = (WCHAR*) CoTaskMemAlloc( (pName ? strlenW(pName) + 6 : 5) * sizeof(WCHAR) );
298
299 if (pName)
300 {
301 /* Check if name already exists */
302 for(i = 0; i < This->nFilters; i++)
303 if (!strcmpW(This->pFilterNames[i], pName))
304 {
305 duplicate_name = TRUE;
306 break;
307 }
308 }
309
310 /* If no name given or name already existing, generate one */
311 if (!pName || duplicate_name)
312 {
313 static const WCHAR wszFmt1[] = {'%','s',' ','%','0','4','d',0};
314 static const WCHAR wszFmt2[] = {'%','0','4','d',0};
315
316 for (j = 0; j < 10000 ; j++)
317 {
318 /* Create name */
319 if (pName)
320 sprintfW(wszFilterName, wszFmt1, pName, This->nameIndex);
321 else
322 sprintfW(wszFilterName, wszFmt2, This->nameIndex);
323 TRACE("Generated name %s\n", debugstr_w(wszFilterName));
324
325 /* Check if the generated name already exists */
326 for(i = 0; i < This->nFilters; i++)
327 if (!strcmpW(This->pFilterNames[i], wszFilterName))
328 break;
329
330 /* Compute next index and exit if generated name is suitable */
331 if (This->nameIndex++ == 10000)
332 This->nameIndex = 1;
333 if (i == This->nFilters)
334 break;
335 }
336 /* Unable to find a suitable name */
337 if (j == 10000)
338 {
339 CoTaskMemFree(wszFilterName);
340 return VFW_E_DUPLICATE_NAME;
341 }
342 }
343 else
344 memcpy(wszFilterName, pName, (strlenW(pName) + 1) * sizeof(WCHAR));
345
346 if (This->nFilters + 1 > This->filterCapacity)
347 {
348 int newCapacity = 2*This->filterCapacity;
349 IBaseFilter ** ppNewFilters = CoTaskMemAlloc(newCapacity * sizeof(IBaseFilter*));
350 LPWSTR * pNewNames = CoTaskMemAlloc(newCapacity * sizeof(LPWSTR));
351 memcpy(ppNewFilters, This->ppFiltersInGraph, This->nFilters * sizeof(IBaseFilter*));
352 memcpy(pNewNames, This->pFilterNames, This->nFilters * sizeof(LPWSTR));
353 CoTaskMemFree(This->ppFiltersInGraph);
354 CoTaskMemFree(This->pFilterNames);
355 This->ppFiltersInGraph = ppNewFilters;
356 This->pFilterNames = pNewNames;
357 This->filterCapacity = newCapacity;
358 }
359
360 hr = IBaseFilter_JoinFilterGraph(pFilter, (IFilterGraph *)This, wszFilterName);
361
362 if (SUCCEEDED(hr))
363 {
364 IBaseFilter_AddRef(pFilter);
365 This->ppFiltersInGraph[This->nFilters] = pFilter;
366 This->pFilterNames[This->nFilters] = wszFilterName;
367 This->nFilters++;
368 }
369 else
370 CoTaskMemFree(wszFilterName);
371
372 if (SUCCEEDED(hr) && duplicate_name)
373 return VFW_S_DUPLICATE_NAME;
374
375 return hr;
376 }
377
378 static HRESULT WINAPI Graphbuilder_RemoveFilter(IGraphBuilder *iface,
379 IBaseFilter *pFilter) {
380 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
381 int i;
382 HRESULT hr = E_FAIL;
383
384 TRACE("(%p/%p)->(%p)\n", This, iface, pFilter);
385
386 /* FIXME: check graph is stopped */
387
388 for (i = 0; i < This->nFilters; i++)
389 {
390 if (This->ppFiltersInGraph[i] == pFilter)
391 {
392 /* FIXME: disconnect pins */
393 hr = IBaseFilter_JoinFilterGraph(pFilter, NULL, This->pFilterNames[i]);
394 if (SUCCEEDED(hr))
395 {
396 IPin_Release(pFilter);
397 CoTaskMemFree(This->pFilterNames[i]);
398 memmove(This->ppFiltersInGraph+i, This->ppFiltersInGraph+i+1, sizeof(IBaseFilter*)*(This->nFilters - 1 - i));
399 memmove(This->pFilterNames+i, This->pFilterNames+i+1, sizeof(LPWSTR)*(This->nFilters - 1 - i));
400 This->nFilters--;
401 return S_OK;
402 }
403 break;
404 }
405 }
406
407 return hr; /* FIXME: check this error code */
408 }
409
410 static HRESULT WINAPI Graphbuilder_EnumFilters(IGraphBuilder *iface,
411 IEnumFilters **ppEnum) {
412 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
413
414 TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
415
416 return IEnumFiltersImpl_Construct(This->ppFiltersInGraph, This->nFilters, ppEnum);
417 }
418
419 static HRESULT WINAPI Graphbuilder_FindFilterByName(IGraphBuilder *iface,
420 LPCWSTR pName,
421 IBaseFilter **ppFilter) {
422 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
423 int i;
424
425 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_w(pName), pName, ppFilter);
426
427 *ppFilter = NULL;
428
429 for (i = 0; i < This->nFilters; i++)
430 {
431 if (!strcmpW(pName, This->pFilterNames[i]))
432 {
433 *ppFilter = This->ppFiltersInGraph[i];
434 IBaseFilter_AddRef(*ppFilter);
435 return S_OK;
436 }
437 }
438
439 return E_FAIL; /* FIXME: check this error code */
440 }
441
442 /* NOTE: despite the implication, it doesn't matter which
443 * way round you put in the input and output pins */
444 static HRESULT WINAPI Graphbuilder_ConnectDirect(IGraphBuilder *iface,
445 IPin *ppinIn,
446 IPin *ppinOut,
447 const AM_MEDIA_TYPE *pmt) {
448 PIN_DIRECTION dir;
449 HRESULT hr;
450
451 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
452
453 TRACE("(%p/%p)->(%p, %p, %p)\n", This, iface, ppinIn, ppinOut, pmt);
454
455 /* FIXME: check pins are in graph */
456
457 hr = IPin_QueryDirection(ppinIn, &dir);
458 if (SUCCEEDED(hr))
459 {
460 if (dir == PINDIR_INPUT)
461 hr = IPin_Connect(ppinOut, ppinIn, pmt);
462 else
463 hr = IPin_Connect(ppinIn, ppinOut, pmt);
464 }
465
466 return hr;
467 }
468
469 static HRESULT WINAPI Graphbuilder_Reconnect(IGraphBuilder *iface,
470 IPin *ppin) {
471 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
472
473 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppin);
474
475 return S_OK;
476 }
477
478 static HRESULT WINAPI Graphbuilder_Disconnect(IGraphBuilder *iface,
479 IPin *ppin) {
480 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
481
482 TRACE("(%p/%p)->(%p)\n", This, iface, ppin);
483
484 return IPin_Disconnect(ppin);
485 }
486
487 static HRESULT WINAPI Graphbuilder_SetDefaultSyncSource(IGraphBuilder *iface) {
488 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
489
490 TRACE("(%p/%p)->(): stub !!!\n", iface, This);
491
492 return S_OK;
493 }
494
495 static HRESULT GetFilterInfo(IMoniker* pMoniker, GUID* pclsid, VARIANT* pvar)
496 {
497 static const WCHAR wszClsidName[] = {'C','L','S','I','D',0};
498 static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
499 IPropertyBag * pPropBagCat = NULL;
500 HRESULT hr;
501
502 VariantInit(pvar);
503 V_VT(pvar) = VT_BSTR;
504
505 hr = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (LPVOID*)&pPropBagCat);
506
507 if (SUCCEEDED(hr))
508 hr = IPropertyBag_Read(pPropBagCat, wszClsidName, pvar, NULL);
509
510 if (SUCCEEDED(hr))
511 hr = CLSIDFromString(V_UNION(pvar, bstrVal), pclsid);
512
513 if (SUCCEEDED(hr))
514 hr = IPropertyBag_Read(pPropBagCat, wszFriendlyName, pvar, NULL);
515
516 if (SUCCEEDED(hr))
517 TRACE("Moniker = %s - %s\n", debugstr_guid(pclsid), debugstr_w(V_UNION(pvar, bstrVal)));
518
519 if (pPropBagCat)
520 IPropertyBag_Release(pPropBagCat);
521
522 return hr;
523 }
524
525 static HRESULT GetInternalConnections(IBaseFilter* pfilter, IPin* pinputpin, IPin*** pppins, ULONG* pnb)
526 {
527 HRESULT hr;
528 ULONG nb = 0;
529
530 TRACE("(%p, %p, %p, %p)\n", pfilter, pinputpin, pppins, pnb);
531 hr = IPin_QueryInternalConnections(pinputpin, NULL, &nb);
532 if (hr == S_OK) {
533 /* Rendered input */
534 } else if (hr == S_FALSE) {
535 *pppins = CoTaskMemAlloc(sizeof(IPin*)*nb);
536 hr = IPin_QueryInternalConnections(pinputpin, *pppins, &nb);
537 if (hr != S_OK) {
538 ERR("Error (%lx)\n", hr);
539 }
540 } else if (hr == E_NOTIMPL) {
541 /* Input connected to all outputs */
542 IEnumPins* penumpins;
543 IPin* ppin;
544 int i = 0;
545 TRACE("E_NOTIMPL\n");
546 hr = IBaseFilter_EnumPins(pfilter, &penumpins);
547 if (FAILED(hr)) {
548 ERR("filter Enumpins failed (%lx)\n", hr);
549 return hr;
550 }
551 i = 0;
552 /* Count output pins */
553 while(IEnumPins_Next(penumpins, 1, &ppin, &nb) == S_OK) {
554 PIN_DIRECTION pindir;
555 IPin_QueryDirection(ppin, &pindir);
556 if (pindir == PINDIR_OUTPUT)
557 i++;
558 else
559 IPin_Release(ppin);
560 }
561 *pppins = CoTaskMemAlloc(sizeof(IPin*)*i);
562 /* Retrieve output pins */
563 IEnumPins_Reset(penumpins);
564 i = 0;
565 while(IEnumPins_Next(penumpins, 1, &ppin, &nb) == S_OK) {
566 PIN_DIRECTION pindir;
567 IPin_QueryDirection(ppin, &pindir);
568 if (pindir == PINDIR_OUTPUT)
569 (*pppins)[i++] = ppin;
570 else
571 IPin_Release(ppin);
572 }
573 nb = i;
574 if (FAILED(hr)) {
575 ERR("Next failed (%lx)\n", hr);
576 return hr;
577 }
578 IEnumPins_Release(penumpins);
579 } else if (FAILED(hr)) {
580 ERR("Cannot get internal connection (%lx)\n", hr);
581 return hr;
582 }
583
584 *pnb = nb;
585 return S_OK;
586 }
587
588 /*** IGraphBuilder methods ***/
589 static HRESULT WINAPI Graphbuilder_Connect(IGraphBuilder *iface,
590 IPin *ppinOut,
591 IPin *ppinIn) {
592 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
593 HRESULT hr;
594 AM_MEDIA_TYPE* mt;
595 IEnumMediaTypes* penummt;
596 ULONG nbmt;
597 IEnumPins* penumpins;
598 IEnumMoniker* pEnumMoniker;
599 GUID tab[2];
600 ULONG nb;
601 IMoniker* pMoniker;
602 ULONG pin;
603
604 TRACE("(%p/%p)->(%p, %p)\n", This, iface, ppinOut, ppinIn);
605
606 /* Try direct connection first */
607 TRACE("Try direct connection first\n");
608 hr = IPin_Connect(ppinOut, ppinIn, NULL);
609 if (SUCCEEDED(hr)) {
610 TRACE("Direct connection successful\n");
611 return S_OK;
612 }
613 TRACE("Direct connection failed, trying to insert other filters\n");
614
615 /* Find the appropriate transform filter than can transform the minor media type of output pin of the upstream
616 * filter to the minor mediatype of input pin of the renderer */
617 hr = IPin_EnumMediaTypes(ppinOut, &penummt);
618 if (FAILED(hr)) {
619 ERR("EnumMediaTypes (%lx)\n", hr);
620 return hr;
621 }
622
623 hr = IEnumMediaTypes_Next(penummt, 1, &mt, &nbmt);
624 if (FAILED(hr)) {
625 ERR("IEnumMediaTypes_Next (%lx)\n", hr);
626 return hr;
627 }
628
629 if (!nbmt) {
630 ERR("No media type found!\n");
631 return S_OK;
632 }
633 TRACE("MajorType %s\n", debugstr_guid(&mt->majortype));
634 TRACE("SubType %s\n", debugstr_guid(&mt->subtype));
635
636 /* Try to find a suitable filter that can connect to the pin to render */
637 tab[0] = mt->majortype;
638 tab[1] = mt->subtype;
639 hr = IFilterMapper2_EnumMatchingFilters(This->pFilterMapper2, &pEnumMoniker, 0, FALSE, 0, TRUE, 1, tab, NULL, NULL, FALSE, FALSE, 0, NULL, NULL, NULL);
640 if (FAILED(hr)) {
641 ERR("Unable to enum filters (%lx)\n", hr);
642 return hr;
643 }
644
645 while(IEnumMoniker_Next(pEnumMoniker, 1, &pMoniker, &nb) == S_OK)
646 {
647 VARIANT var;
648 GUID clsid;
649 IPin** ppins;
650 IPin* ppinfilter;
651 IBaseFilter* pfilter = NULL;
652
653 hr = GetFilterInfo(pMoniker, &clsid, &var);
654 IMoniker_Release(pMoniker);
655 if (FAILED(hr)) {
656 ERR("Unable to retrieve filter info (%lx)\n", hr);
657 goto error;
658 }
659
660 hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&pfilter);
661 if (FAILED(hr)) {
662 ERR("Unable to create filter (%lx), trying next one\n", hr);
663 goto error;
664 }
665
666 hr = IGraphBuilder_AddFilter(iface, pfilter, NULL);
667 if (FAILED(hr)) {
668 ERR("Unable to add filter (%lx)\n", hr);
669 IBaseFilter_Release(pfilter);
670 pfilter = NULL;
671 goto error;
672 }
673
674 hr = IBaseFilter_EnumPins(pfilter, &penumpins);
675 if (FAILED(hr)) {
676 ERR("Enumpins (%lx)\n", hr);
677 goto error;
678 }
679 hr = IEnumPins_Next(penumpins, 1, &ppinfilter, &pin);
680 if (FAILED(hr)) {
681 ERR("Next (%lx)\n", hr);
682 goto error;
683 }
684 if (pin == 0) {
685 ERR("No Pin\n");
686 goto error;
687 }
688 IEnumPins_Release(penumpins);
689
690 hr = IPin_Connect(ppinOut, ppinfilter, NULL);
691 if (FAILED(hr)) {
692 TRACE("Cannot connect to filter (%lx), trying next one\n", hr);
693 goto error;
694 }
695 TRACE("Successfully connected to filter, follow chain...\n");
696
697 /* Render all output pins of the filter by calling IGraphBuilder_Render on each of them */
698 hr = GetInternalConnections(pfilter, ppinfilter, &ppins, &nb);
699
700 if (SUCCEEDED(hr)) {
701 int i;
702 TRACE("pins to consider: %ld\n", nb);
703 for(i = 0; i < nb; i++) {
704 TRACE("Processing pin %d\n", i);
705 hr = IGraphBuilder_Connect(iface, ppins[0], ppinIn);
706 if (FAILED(hr)) {
707 TRACE("Cannot render pin %p (%lx)\n", ppinfilter, hr);
708 return hr;
709 }
710 }
711 CoTaskMemFree(ppins);
712 }
713 break;
714
715 error:
716 if (pfilter) {
717 IGraphBuilder_RemoveFilter(iface, pfilter);
718 IBaseFilter_Release(pfilter);
719 }
720 }
721
722 IEnumMediaTypes_Release(penummt);
723 DeleteMediaType(mt);
724
725 return S_OK;
726 }
727
728 static HRESULT WINAPI Graphbuilder_Render(IGraphBuilder *iface,
729 IPin *ppinOut) {
730 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
731 IEnumMediaTypes* penummt;
732 AM_MEDIA_TYPE* mt;
733 ULONG nbmt;
734 HRESULT hr;
735
736 IEnumMoniker* pEnumMoniker;
737 GUID tab[2];
738 ULONG nb;
739 IMoniker* pMoniker;
740
741 TRACE("(%p/%p)->(%p)\n", This, iface, ppinOut);
742
743 hr = IPin_EnumMediaTypes(ppinOut, &penummt);
744 if (FAILED(hr)) {
745 ERR("EnumMediaTypes (%lx)\n", hr);
746 return hr;
747 }
748
749 while(1)
750 {
751 hr = IEnumMediaTypes_Next(penummt, 1, &mt, &nbmt);
752 if (FAILED(hr)) {
753 ERR("IEnumMediaTypes_Next (%lx)\n", hr);
754 return hr;
755 }
756 if (!nbmt)
757 break;
758 TRACE("MajorType %s\n", debugstr_guid(&mt->majortype));
759 TRACE("SubType %s\n", debugstr_guid(&mt->subtype));
760
761 /* Try to find a suitable renderer with the same media type */
762 tab[0] = mt->majortype;
763 tab[1] = GUID_NULL;
764 hr = IFilterMapper2_EnumMatchingFilters(This->pFilterMapper2, &pEnumMoniker, 0, FALSE, 0, TRUE, 1, tab, NULL, NULL, TRUE, FALSE, 0, NULL, NULL, NULL);
765 if (FAILED(hr)) {
766 ERR("Unable to enum filters (%lx)\n", hr);
767 return hr;
768 }
769
770 while(IEnumMoniker_Next(pEnumMoniker, 1, &pMoniker, &nb) == S_OK)
771 {
772 VARIANT var;
773 GUID clsid;
774 IPin* ppinfilter;
775 IBaseFilter* pfilter = NULL;
776 IEnumPins* penumpins;
777 ULONG pin;
778
779 hr = GetFilterInfo(pMoniker, &clsid, &var);
780 IMoniker_Release(pMoniker);
781 if (FAILED(hr)) {
782 ERR("Unable to retrieve filter info (%lx)\n", hr);
783 goto error;
784 }
785
786 hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&pfilter);
787 if (FAILED(hr)) {
788 ERR("Unable to create filter (%lx), trying next one\n", hr);
789 goto error;
790 }
791
792 hr = IGraphBuilder_AddFilter(iface, pfilter, NULL);
793 if (FAILED(hr)) {
794 ERR("Unable to add filter (%lx)\n", hr);
795 IBaseFilter_Release(pfilter);
796 pfilter = NULL;
797 goto error;
798 }
799
800 hr = IBaseFilter_EnumPins(pfilter, &penumpins);
801 if (FAILED(hr)) {
802 ERR("Splitter Enumpins (%lx)\n", hr);
803 goto error;
804 }
805 hr = IEnumPins_Next(penumpins, 1, &ppinfilter, &pin);
806 if (FAILED(hr)) {
807 ERR("Next (%lx)\n", hr);
808 goto error;
809 }
810 if (pin == 0) {
811 ERR("No Pin\n");
812 goto error;
813 }
814 IEnumPins_Release(penumpins);
815
816 /* Connect the pin to render to the renderer */
817 hr = IGraphBuilder_Connect(iface, ppinOut, ppinfilter);
818 if (FAILED(hr)) {
819 TRACE("Unable to connect to renderer (%lx)\n", hr);
820 goto error;
821 }
822 break;
823
824 error:
825 if (pfilter) {
826 IGraphBuilder_RemoveFilter(iface, pfilter);
827 IBaseFilter_Release(pfilter);
828 }
829 }
830
831 DeleteMediaType(mt);
832 break;
833 }
834
835 IEnumMediaTypes_Release(penummt);
836
837 return S_OK;
838 }
839
840 static HRESULT WINAPI Graphbuilder_RenderFile(IGraphBuilder *iface,
841 LPCWSTR lpcwstrFile,
842 LPCWSTR lpcwstrPlayList) {
843 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
844 static const WCHAR string[] = {'R','e','a','d','e','r',0};
845 IBaseFilter* preader = NULL;
846 IBaseFilter* psplitter;
847 IPin* ppinreader;
848 IPin* ppinsplitter;
849 IEnumPins* penumpins;
850 ULONG pin;
851 HRESULT hr;
852 IEnumMoniker* pEnumMoniker;
853 GUID tab[2];
854 IPin** ppins;
855 ULONG nb;
856 IMoniker* pMoniker;
857 IFileSourceFilter* pfile = NULL;
858 AM_MEDIA_TYPE mt;
859 WCHAR* filename;
860
861 TRACE("(%p/%p)->(%s, %s)\n", This, iface, debugstr_w(lpcwstrFile), debugstr_w(lpcwstrPlayList));
862
863 hr = IGraphBuilder_AddSourceFilter(iface, lpcwstrFile, string, &preader);
864
865 /* Retrieve file media type */
866 if (SUCCEEDED(hr))
867 hr = IBaseFilter_QueryInterface(preader, &IID_IFileSourceFilter, (LPVOID*)&pfile);
868 if (SUCCEEDED(hr)) {
869 hr = IFileSourceFilter_GetCurFile(pfile, &filename, &mt);
870 IFileSourceFilter_Release(pfile);
871 }
872
873 if (SUCCEEDED(hr)) {
874 tab[0] = mt.majortype;
875 tab[1] = mt.subtype;
876 hr = IFilterMapper2_EnumMatchingFilters(This->pFilterMapper2, &pEnumMoniker, 0, FALSE, 0, TRUE, 1, tab, NULL, NULL, FALSE, FALSE, 0, NULL, NULL, NULL);
877 } else {
878 if (preader) {
879 IGraphBuilder_RemoveFilter(iface, preader);
880 IBaseFilter_Release(preader);
881 }
882 return hr;
883 }
884
885 while(IEnumMoniker_Next(pEnumMoniker, 1, &pMoniker, &nb) == S_OK)
886 {
887 VARIANT var;
888 GUID clsid;
889
890 hr = GetFilterInfo(pMoniker, &clsid, &var);
891 IMoniker_Release(pMoniker);
892 if (FAILED(hr)) {
893 ERR("Unable to retrieve filter info (%lx)\n", hr);
894 continue;
895 }
896
897 hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&psplitter);
898 if (FAILED(hr)) {
899 ERR("Unable to create filter (%lx), trying next one\n", hr);
900 continue;
901 }
902
903 hr = IGraphBuilder_AddFilter(iface, psplitter, NULL);
904 if (FAILED(hr)) {
905 ERR("Unable add filter (%lx)\n", hr);
906 return hr;
907 }
908
909 /* Connect file source and splitter filters together */
910 /* Make the splitter analyze incoming data */
911 hr = IBaseFilter_EnumPins(preader, &penumpins);
912 if (FAILED(hr)) {
913 ERR("Enumpins (%lx)\n", hr);
914 return hr;
915 }
916 hr = IEnumPins_Next(penumpins, 1, &ppinreader, &pin);
917 if (FAILED(hr)) {
918 ERR("Next (%lx)\n", hr);
919 return hr;
920 }
921 if (pin == 0) {
922 ERR("No Pin\n");
923 return E_FAIL;
924 }
925 IEnumPins_Release(penumpins);
926
927 hr = IBaseFilter_EnumPins(psplitter, &penumpins);
928 if (FAILED(hr)) {
929 ERR("Splitter Enumpins (%lx)\n", hr);
930 return hr;
931 }
932 hr = IEnumPins_Next(penumpins, 1, &ppinsplitter, &pin);
933 if (FAILED(hr)) {
934 ERR("Next (%lx)\n", hr);
935 return hr;
936 }
937 if (pin == 0) {
938 ERR("No Pin\n");
939 return E_FAIL;
940 }
941 IEnumPins_Release(penumpins);
942
943 hr = IPin_Connect(ppinreader, ppinsplitter, NULL);
944 if (FAILED(hr)) {
945 IBaseFilter_Release(ppinsplitter);
946 ppinsplitter = NULL;
947 TRACE("Cannot connect to filter (%lx), trying next one\n", hr);
948 break;
949 }
950 TRACE("Successfully connected to filter\n");
951 break;
952 }
953
954 /* Render all output pin of the splitter by calling IGraphBuilder_Render on each of them */
955 if (SUCCEEDED(hr))
956 hr = GetInternalConnections(psplitter, ppinsplitter, &ppins, &nb);
957
958 if (SUCCEEDED(hr)) {
959 int i;
960 TRACE("pins to consider: %ld\n", nb);
961 for(i = 0; i < nb; i++) {
962 TRACE("Processing pin %d\n", i);
963 hr = IGraphBuilder_Render(iface, ppins[i]);
964 if (FAILED(hr)) {
965 ERR("Cannot render pin %p (%lx)\n", ppins[i], hr);
966 /* FIXME: We should clean created things properly */
967 break;
968 }
969 }
970 CoTaskMemFree(ppins);
971 }
972
973 return hr;
974 }
975
976 static HRESULT WINAPI Graphbuilder_AddSourceFilter(IGraphBuilder *iface,
977 LPCWSTR lpcwstrFileName,
978 LPCWSTR lpcwstrFilterName,
979 IBaseFilter **ppFilter) {
980 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
981 HRESULT hr;
982 IBaseFilter* preader;
983 IFileSourceFilter* pfile = NULL;
984 AM_MEDIA_TYPE mt;
985 WCHAR* filename;
986
987 TRACE("(%p/%p)->(%s, %s, %p)\n", This, iface, debugstr_w(lpcwstrFileName), debugstr_w(lpcwstrFilterName), ppFilter);
988
989 /* Instantiate a file source filter */
990 hr = CoCreateInstance(&CLSID_AsyncReader, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&preader);
991 if (FAILED(hr)) {
992 ERR("Unable to create file source filter (%lx)\n", hr);
993 return hr;
994 }
995
996 hr = IGraphBuilder_AddFilter(iface, preader, lpcwstrFilterName);
997 if (FAILED(hr)) {
998 ERR("Unable add filter (%lx)\n", hr);
999 IBaseFilter_Release(preader);
1000 return hr;
1001 }
1002
1003 hr = IBaseFilter_QueryInterface(preader, &IID_IFileSourceFilter, (LPVOID*)&pfile);
1004 if (FAILED(hr)) {
1005 ERR("Unable to get IFileSourceInterface (%lx)\n", hr);
1006 goto error;
1007 }
1008
1009 /* Load the file in the file source filter */
1010 hr = IFileSourceFilter_Load(pfile, lpcwstrFileName, NULL);
1011 if (FAILED(hr)) {
1012 ERR("Load (%lx)\n", hr);
1013 goto error;
1014 }
1015
1016 IFileSourceFilter_GetCurFile(pfile, &filename, &mt);
1017 if (FAILED(hr)) {
1018 ERR("GetCurFile (%lx)\n", hr);
1019 goto error;
1020 }
1021 TRACE("File %s\n", debugstr_w(filename));
1022 TRACE("MajorType %s\n", debugstr_guid(&mt.majortype));
1023 TRACE("SubType %s\n", debugstr_guid(&mt.subtype));
1024
1025 if (ppFilter)
1026 *ppFilter = preader;
1027
1028 return S_OK;
1029
1030 error:
1031 if (pfile)
1032 IFileSourceFilter_Release(pfile);
1033 IGraphBuilder_RemoveFilter(iface, preader);
1034 IBaseFilter_Release(preader);
1035
1036 return hr;
1037 }
1038
1039 static HRESULT WINAPI Graphbuilder_SetLogFile(IGraphBuilder *iface,
1040 DWORD_PTR hFile) {
1041 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
1042
1043 TRACE("(%p/%p)->(%08lx): stub !!!\n", This, iface, (DWORD) hFile);
1044
1045 return S_OK;
1046 }
1047
1048 static HRESULT WINAPI Graphbuilder_Abort(IGraphBuilder *iface) {
1049 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
1050
1051 TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1052
1053 return S_OK;
1054 }
1055
1056 static HRESULT WINAPI Graphbuilder_ShouldOperationContinue(IGraphBuilder *iface) {
1057 ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface);
1058
1059 TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1060
1061 return S_OK;
1062 }
1063
1064
1065 static IGraphBuilderVtbl IGraphBuilder_VTable =
1066 {
1067 Graphbuilder_QueryInterface,
1068 Graphbuilder_AddRef,
1069 Graphbuilder_Release,
1070 Graphbuilder_AddFilter,
1071 Graphbuilder_RemoveFilter,
1072 Graphbuilder_EnumFilters,
1073 Graphbuilder_FindFilterByName,
1074 Graphbuilder_ConnectDirect,
1075 Graphbuilder_Reconnect,
1076 Graphbuilder_Disconnect,
1077 Graphbuilder_SetDefaultSyncSource,
1078 Graphbuilder_Connect,
1079 Graphbuilder_Render,
1080 Graphbuilder_RenderFile,
1081 Graphbuilder_AddSourceFilter,
1082 Graphbuilder_SetLogFile,
1083 Graphbuilder_Abort,
1084 Graphbuilder_ShouldOperationContinue
1085 };
1086
1087 /*** IUnknown methods ***/
1088 static HRESULT WINAPI Mediacontrol_QueryInterface(IMediaControl *iface,
1089 REFIID riid,
1090 LPVOID*ppvObj) {
1091 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1092
1093 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1094
1095 return Filtergraph_QueryInterface(This, riid, ppvObj);
1096 }
1097
1098 static ULONG WINAPI Mediacontrol_AddRef(IMediaControl *iface) {
1099 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1100
1101 TRACE("(%p/%p)->()\n", This, iface);
1102
1103 return Filtergraph_AddRef(This);
1104 }
1105
1106 static ULONG WINAPI Mediacontrol_Release(IMediaControl *iface) {
1107 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1108
1109 TRACE("(%p/%p)->()\n", This, iface);
1110
1111 return Filtergraph_Release(This);
1112
1113 }
1114
1115 /*** IDispatch methods ***/
1116 static HRESULT WINAPI Mediacontrol_GetTypeInfoCount(IMediaControl *iface,
1117 UINT*pctinfo) {
1118 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1119
1120 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1121
1122 return S_OK;
1123 }
1124
1125 static HRESULT WINAPI Mediacontrol_GetTypeInfo(IMediaControl *iface,
1126 UINT iTInfo,
1127 LCID lcid,
1128 ITypeInfo**ppTInfo) {
1129 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1130
1131 TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1132
1133 return S_OK;
1134 }
1135
1136 static HRESULT WINAPI Mediacontrol_GetIDsOfNames(IMediaControl *iface,
1137 REFIID riid,
1138 LPOLESTR*rgszNames,
1139 UINT cNames,
1140 LCID lcid,
1141 DISPID*rgDispId) {
1142 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1143
1144 TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
1145
1146 return S_OK;
1147 }
1148
1149 static HRESULT WINAPI Mediacontrol_Invoke(IMediaControl *iface,
1150 DISPID dispIdMember,
1151 REFIID riid,
1152 LCID lcid,
1153 WORD wFlags,
1154 DISPPARAMS*pDispParams,
1155 VARIANT*pVarResult,
1156 EXCEPINFO*pExepInfo,
1157 UINT*puArgErr) {
1158 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1159
1160 TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
1161
1162 return S_OK;
1163 }
1164
1165 static HRESULT ExploreGraph(IFilterGraphImpl* pGraph, IPin* pOutputPin, REFERENCE_TIME tStart)
1166 {
1167 HRESULT hr;
1168 IPin* pInputPin;
1169 IPin** ppPins;
1170 ULONG nb;
1171 ULONG i;
1172 PIN_INFO PinInfo;
1173
1174 TRACE("%p %p %lld\n", pGraph, pOutputPin, tStart);
1175
1176 hr = IPin_ConnectedTo(pOutputPin, &pInputPin);
1177
1178 if (SUCCEEDED(hr))
1179 hr = IPin_QueryPinInfo(pInputPin, &PinInfo);
1180
1181 if (SUCCEEDED(hr))
1182 hr = GetInternalConnections(PinInfo.pFilter, pInputPin, &ppPins, &nb);
1183
1184 if (SUCCEEDED(hr))
1185 {
1186 if (nb == 0)
1187 {
1188 TRACE("Reached a renderer\n");
1189 /* Count renderers for end of stream notification */
1190 pGraph->nRenderers++;
1191 }
1192 else
1193 {
1194 for(i = 0; i < nb; i++)
1195 {
1196 /* Explore the graph downstream from this pin
1197 * FIXME: We should prevent exploring from a pin more than once. This can happens when
1198 * several input pins are connected to the same output (a MUX for instance). */
1199 ExploreGraph(pGraph, ppPins[i], tStart);
1200 }
1201
1202 CoTaskMemFree(ppPins);
1203 }
1204 TRACE("Run filter %p\n", PinInfo.pFilter);
1205 IBaseFilter_Run(PinInfo.pFilter, tStart);
1206 }
1207
1208 return hr;
1209 }
1210
1211 /*** IMediaControl methods ***/
1212 static HRESULT WINAPI Mediacontrol_Run(IMediaControl *iface) {
1213 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1214 int i;
1215 IBaseFilter* pfilter;
1216 IEnumPins* pEnum;
1217 HRESULT hr;
1218 IPin* pPin;
1219 LONG dummy;
1220 PIN_DIRECTION dir;
1221
1222 TRACE("(%p/%p)->()\n", This, iface);
1223
1224 EnterCriticalSection(&This->cs);
1225
1226 if (This->state == State_Running)
1227 {
1228 LeaveCriticalSection(&This->cs);
1229 return S_OK;
1230 }
1231
1232 /* Explorer the graph from source filters to renderers, determine renderers number and
1233 * run filters from renderers to source filters */
1234 This->nRenderers = 0;
1235 ResetEvent(This->hEventCompletion);
1236
1237 for(i = 0; i < This->nFilters; i++)
1238 {
1239 BOOL source = TRUE;
1240 pfilter = This->ppFiltersInGraph[i];
1241 hr = IBaseFilter_EnumPins(pfilter, &pEnum);
1242 if (hr != S_OK)
1243 {
1244 ERR("Enum pins failed %lx\n", hr);
1245 continue;
1246 }
1247 /* Check if it is a source filter */
1248 while(IEnumPins_Next(pEnum, 1, &pPin, &dummy) == S_OK)
1249 {
1250 IPin_QueryDirection(pPin, &dir);
1251 if (dir == PINDIR_INPUT)
1252 {
1253 source = FALSE;
1254 break;
1255 }
1256 }
1257 if (source == TRUE)
1258 {
1259 TRACE("Found a source filter\n");
1260 IEnumPins_Reset(pEnum);
1261 while(IEnumPins_Next(pEnum, 1, &pPin, &dummy) == S_OK)
1262 {
1263 /* Explore the graph downstream from this pin */
1264 ExploreGraph(This, pPin, 0);
1265 }
1266 IBaseFilter_Run(pfilter, 0);
1267 }
1268 IEnumPins_Release(pEnum);
1269 }
1270
1271 This->state = State_Running;
1272
1273 LeaveCriticalSection(&This->cs);
1274
1275 return S_FALSE;
1276 }
1277
1278 static HRESULT WINAPI Mediacontrol_Pause(IMediaControl *iface) {
1279 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1280
1281 TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1282
1283 return S_OK;
1284 }
1285
1286 static HRESULT WINAPI Mediacontrol_Stop(IMediaControl *iface) {
1287 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1288
1289 TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1290
1291 return S_OK;
1292 }
1293
1294 static HRESULT WINAPI Mediacontrol_GetState(IMediaControl *iface,
1295 LONG msTimeout,
1296 OAFilterState *pfs) {
1297 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1298
1299 TRACE("(%p/%p)->(%ld, %p): semi-stub !!!\n", This, iface, msTimeout, pfs);
1300
1301 EnterCriticalSection(&This->cs);
1302
1303 *pfs = This->state;
1304
1305 LeaveCriticalSection(&This->cs);
1306
1307 return S_OK;
1308 }
1309
1310 static HRESULT WINAPI Mediacontrol_RenderFile(IMediaControl *iface,
1311 BSTR strFilename) {
1312 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1313
1314 TRACE("(%p/%p)->(%s (%p)): stub !!!\n", This, iface, debugstr_w(strFilename), strFilename);
1315
1316 return S_OK;
1317 }
1318
1319 static HRESULT WINAPI Mediacontrol_AddSourceFilter(IMediaControl *iface,
1320 BSTR strFilename,
1321 IDispatch **ppUnk) {
1322 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1323
1324 TRACE("(%p/%p)->(%s (%p), %p): stub !!!\n", This, iface, debugstr_w(strFilename), strFilename, ppUnk);
1325
1326 return S_OK;
1327 }
1328
1329 static HRESULT WINAPI Mediacontrol_get_FilterCollection(IMediaControl *iface,
1330 IDispatch **ppUnk) {
1331 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1332
1333 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk);
1334
1335 return S_OK;
1336 }
1337
1338 static HRESULT WINAPI Mediacontrol_get_RegFilterCollection(IMediaControl *iface,
1339 IDispatch **ppUnk) {
1340 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1341
1342 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk);
1343
1344 return S_OK;
1345 }
1346
1347 static HRESULT WINAPI Mediacontrol_StopWhenReady(IMediaControl *iface) {
1348 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface);
1349
1350 TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1351
1352 return S_OK;
1353 }
1354
1355
1356 static IMediaControlVtbl IMediaControl_VTable =
1357 {
1358 Mediacontrol_QueryInterface,
1359 Mediacontrol_AddRef,
1360 Mediacontrol_Release,
1361 Mediacontrol_GetTypeInfoCount,
1362 Mediacontrol_GetTypeInfo,
1363 Mediacontrol_GetIDsOfNames,
1364 Mediacontrol_Invoke,
1365 Mediacontrol_Run,
1366 Mediacontrol_Pause,
1367 Mediacontrol_Stop,
1368 Mediacontrol_GetState,
1369 Mediacontrol_RenderFile,
1370 Mediacontrol_AddSourceFilter,
1371 Mediacontrol_get_FilterCollection,
1372 Mediacontrol_get_RegFilterCollection,
1373 Mediacontrol_StopWhenReady
1374 };
1375
1376
1377 /*** IUnknown methods ***/
1378 static HRESULT WINAPI Mediaseeking_QueryInterface(IMediaSeeking *iface,
1379 REFIID riid,
1380 LPVOID*ppvObj) {
1381 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1382
1383 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1384
1385 return Filtergraph_QueryInterface(This, riid, ppvObj);
1386 }
1387
1388 static ULONG WINAPI Mediaseeking_AddRef(IMediaSeeking *iface) {
1389 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1390
1391 TRACE("(%p/%p)->()\n", This, iface);
1392
1393 return Filtergraph_AddRef(This);
1394 }
1395
1396 static ULONG WINAPI Mediaseeking_Release(IMediaSeeking *iface) {
1397 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1398
1399 TRACE("(%p/%p)->()\n", This, iface);
1400
1401 return Filtergraph_Release(This);
1402 }
1403
1404 /*** IMediaSeeking methods ***/
1405 static HRESULT WINAPI Mediaseeking_GetCapabilities(IMediaSeeking *iface,
1406 DWORD *pCapabilities) {
1407 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1408
1409 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pCapabilities);
1410
1411 return S_OK;
1412 }
1413
1414 static HRESULT WINAPI Mediaseeking_CheckCapabilities(IMediaSeeking *iface,
1415 DWORD *pCapabilities) {
1416 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1417
1418 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pCapabilities);
1419
1420 return S_OK;
1421 }
1422
1423 static HRESULT WINAPI Mediaseeking_IsFormatSupported(IMediaSeeking *iface,
1424 const GUID *pFormat) {
1425 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1426
1427 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
1428
1429 return S_OK;
1430 }
1431
1432 static HRESULT WINAPI Mediaseeking_QueryPreferredFormat(IMediaSeeking *iface,
1433 GUID *pFormat) {
1434 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1435
1436 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
1437
1438 return S_OK;
1439 }
1440
1441 static HRESULT WINAPI Mediaseeking_GetTimeFormat(IMediaSeeking *iface,
1442 GUID *pFormat) {
1443 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1444
1445 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
1446
1447 return S_OK;
1448 }
1449
1450 static HRESULT WINAPI Mediaseeking_IsUsingTimeFormat(IMediaSeeking *iface,
1451 const GUID *pFormat) {
1452 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1453
1454 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
1455
1456 return S_OK;
1457 }
1458
1459 static HRESULT WINAPI Mediaseeking_SetTimeFormat(IMediaSeeking *iface,
1460 const GUID *pFormat) {
1461 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1462
1463 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
1464
1465 return S_OK;
1466 }
1467
1468 static HRESULT WINAPI Mediaseeking_GetDuration(IMediaSeeking *iface,
1469 LONGLONG *pDuration) {
1470 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1471
1472 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDuration);
1473
1474 return S_OK;
1475 }
1476
1477 static HRESULT WINAPI Mediaseeking_GetStopPosition(IMediaSeeking *iface,
1478 LONGLONG *pStop) {
1479 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1480
1481 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pStop);
1482
1483 return S_OK;
1484 }
1485
1486 static HRESULT WINAPI Mediaseeking_GetCurrentPosition(IMediaSeeking *iface,
1487 LONGLONG *pCurrent) {
1488 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1489
1490 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pCurrent);
1491
1492 return S_OK;
1493 }
1494
1495 static HRESULT WINAPI Mediaseeking_ConvertTimeFormat(IMediaSeeking *iface,
1496 LONGLONG *pTarget,
1497 const GUID *pTargetFormat,
1498 LONGLONG Source,
1499 const GUID *pSourceFormat) {
1500 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1501
1502 TRACE("(%p/%p)->(%p, %p, %lld, %p): stub !!!\n", This, iface, pTarget, pTargetFormat, Source, pSourceFormat);
1503
1504 return S_OK;
1505 }
1506
1507 static HRESULT WINAPI Mediaseeking_SetPositions(IMediaSeeking *iface,
1508 LONGLONG *pCurrent,
1509 DWORD dwCurrentFlags,
1510 LONGLONG *pStop,
1511 DWORD dwStopFlags) {
1512 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1513
1514 TRACE("(%p/%p)->(%p, %08lx, %p, %08lx): stub !!!\n", This, iface, pCurrent, dwCurrentFlags, pStop, dwStopFlags);
1515
1516 return S_OK;
1517 }
1518
1519 static HRESULT WINAPI Mediaseeking_GetPositions(IMediaSeeking *iface,
1520 LONGLONG *pCurrent,
1521 LONGLONG *pStop) {
1522 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1523
1524 TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pCurrent, pStop);
1525
1526 return S_OK;
1527 }
1528
1529 static HRESULT WINAPI Mediaseeking_GetAvailable(IMediaSeeking *iface,
1530 LONGLONG *pEarliest,
1531 LONGLONG *pLatest) {
1532 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1533
1534 TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pEarliest, pLatest);
1535
1536 return S_OK;
1537 }
1538
1539 static HRESULT WINAPI Mediaseeking_SetRate(IMediaSeeking *iface,
1540 double dRate) {
1541 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1542
1543 TRACE("(%p/%p)->(%f): stub !!!\n", This, iface, dRate);
1544
1545 return S_OK;
1546 }
1547
1548 static HRESULT WINAPI Mediaseeking_GetRate(IMediaSeeking *iface,
1549 double *pdRate) {
1550 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1551
1552 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pdRate);
1553
1554 return S_OK;
1555 }
1556
1557 static HRESULT WINAPI Mediaseeking_GetPreroll(IMediaSeeking *iface,
1558 LONGLONG *pllPreroll) {
1559 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
1560
1561 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pllPreroll);
1562
1563 return S_OK;
1564 }
1565
1566
1567 static IMediaSeekingVtbl IMediaSeeking_VTable =
1568 {
1569 Mediaseeking_QueryInterface,
1570 Mediaseeking_AddRef,
1571 Mediaseeking_Release,
1572 Mediaseeking_GetCapabilities,
1573 Mediaseeking_CheckCapabilities,
1574 Mediaseeking_IsFormatSupported,
1575 Mediaseeking_QueryPreferredFormat,
1576 Mediaseeking_GetTimeFormat,
1577 Mediaseeking_IsUsingTimeFormat,
1578 Mediaseeking_SetTimeFormat,
1579 Mediaseeking_GetDuration,
1580 Mediaseeking_GetStopPosition,
1581 Mediaseeking_GetCurrentPosition,
1582 Mediaseeking_ConvertTimeFormat,
1583 Mediaseeking_SetPositions,
1584 Mediaseeking_GetPositions,
1585 Mediaseeking_GetAvailable,
1586 Mediaseeking_SetRate,
1587 Mediaseeking_GetRate,
1588 Mediaseeking_GetPreroll
1589 };
1590
1591 /*** IUnknown methods ***/
1592 static HRESULT WINAPI Basicaudio_QueryInterface(IBasicAudio *iface,
1593 REFIID riid,
1594 LPVOID*ppvObj) {
1595 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1596
1597 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1598
1599 return Filtergraph_QueryInterface(This, riid, ppvObj);
1600 }
1601
1602 static ULONG WINAPI Basicaudio_AddRef(IBasicAudio *iface) {
1603 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1604
1605 TRACE("(%p/%p)->()\n", This, iface);
1606
1607 return Filtergraph_AddRef(This);
1608 }
1609
1610 static ULONG WINAPI Basicaudio_Release(IBasicAudio *iface) {
1611 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1612
1613 TRACE("(%p/%p)->()\n", This, iface);
1614
1615 return Filtergraph_Release(This);
1616 }
1617
1618 /*** IDispatch methods ***/
1619 static HRESULT WINAPI Basicaudio_GetTypeInfoCount(IBasicAudio *iface,
1620 UINT*pctinfo) {
1621 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1622
1623 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1624
1625 return S_OK;
1626 }
1627
1628 static HRESULT WINAPI Basicaudio_GetTypeInfo(IBasicAudio *iface,
1629 UINT iTInfo,
1630 LCID lcid,
1631 ITypeInfo**ppTInfo) {
1632 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1633
1634 TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1635
1636 return S_OK;
1637 }
1638
1639 static HRESULT WINAPI Basicaudio_GetIDsOfNames(IBasicAudio *iface,
1640 REFIID riid,
1641 LPOLESTR*rgszNames,
1642 UINT cNames,
1643 LCID lcid,
1644 DISPID*rgDispId) {
1645 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1646
1647 TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
1648
1649 return S_OK;
1650 }
1651
1652 static HRESULT WINAPI Basicaudio_Invoke(IBasicAudio *iface,
1653 DISPID dispIdMember,
1654 REFIID riid,
1655 LCID lcid,
1656 WORD wFlags,
1657 DISPPARAMS*pDispParams,
1658 VARIANT*pVarResult,
1659 EXCEPINFO*pExepInfo,
1660 UINT*puArgErr) {
1661 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1662
1663 TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
1664
1665 return S_OK;
1666 }
1667
1668 /*** IBasicAudio methods ***/
1669 static HRESULT WINAPI Basicaudio_put_Volume(IBasicAudio *iface,
1670 long lVolume) {
1671 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1672
1673 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, lVolume);
1674
1675 return S_OK;
1676 }
1677
1678 static HRESULT WINAPI Basicaudio_get_Volume(IBasicAudio *iface,
1679 long *plVolume) {
1680 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1681
1682 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, plVolume);
1683
1684 return S_OK;
1685 }
1686
1687 static HRESULT WINAPI Basicaudio_put_Balance(IBasicAudio *iface,
1688 long lBalance) {
1689 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1690
1691 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, lBalance);
1692
1693 return S_OK;
1694 }
1695
1696 static HRESULT WINAPI Basicaudio_get_Balance(IBasicAudio *iface,
1697 long *plBalance) {
1698 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface);
1699
1700 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, plBalance);
1701
1702 return S_OK;
1703 }
1704
1705 static IBasicAudioVtbl IBasicAudio_VTable =
1706 {
1707 Basicaudio_QueryInterface,
1708 Basicaudio_AddRef,
1709 Basicaudio_Release,
1710 Basicaudio_GetTypeInfoCount,
1711 Basicaudio_GetTypeInfo,
1712 Basicaudio_GetIDsOfNames,
1713 Basicaudio_Invoke,
1714 Basicaudio_put_Volume,
1715 Basicaudio_get_Volume,
1716 Basicaudio_put_Balance,
1717 Basicaudio_get_Balance
1718 };
1719
1720 /*** IUnknown methods ***/
1721 static HRESULT WINAPI Basicvideo_QueryInterface(IBasicVideo *iface,
1722 REFIID riid,
1723 LPVOID*ppvObj) {
1724 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1725
1726 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1727
1728 return Filtergraph_QueryInterface(This, riid, ppvObj);
1729 }
1730
1731 static ULONG WINAPI Basicvideo_AddRef(IBasicVideo *iface) {
1732 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1733
1734 TRACE("(%p/%p)->()\n", This, iface);
1735
1736 return Filtergraph_AddRef(This);
1737 }
1738
1739 static ULONG WINAPI Basicvideo_Release(IBasicVideo *iface) {
1740 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1741
1742 TRACE("(%p/%p)->()\n", This, iface);
1743
1744 return Filtergraph_Release(This);
1745 }
1746
1747 /*** IDispatch methods ***/
1748 static HRESULT WINAPI Basicvideo_GetTypeInfoCount(IBasicVideo *iface,
1749 UINT*pctinfo) {
1750 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1751
1752 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
1753
1754 return S_OK;
1755 }
1756
1757 static HRESULT WINAPI Basicvideo_GetTypeInfo(IBasicVideo *iface,
1758 UINT iTInfo,
1759 LCID lcid,
1760 ITypeInfo**ppTInfo) {
1761 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1762
1763 TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
1764
1765 return S_OK;
1766 }
1767
1768 static HRESULT WINAPI Basicvideo_GetIDsOfNames(IBasicVideo *iface,
1769 REFIID riid,
1770 LPOLESTR*rgszNames,
1771 UINT cNames,
1772 LCID lcid,
1773 DISPID*rgDispId) {
1774 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1775
1776 TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
1777
1778 return S_OK;
1779 }
1780
1781 static HRESULT WINAPI Basicvideo_Invoke(IBasicVideo *iface,
1782 DISPID dispIdMember,
1783 REFIID riid,
1784 LCID lcid,
1785 WORD wFlags,
1786 DISPPARAMS*pDispParams,
1787 VARIANT*pVarResult,
1788 EXCEPINFO*pExepInfo,
1789 UINT*puArgErr) {
1790 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1791
1792 TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
1793
1794 return S_OK;
1795 }
1796
1797 /*** IBasicVideo methods ***/
1798 static HRESULT WINAPI Basicvideo_get_AvgTimePerFrame(IBasicVideo *iface,
1799 REFTIME *pAvgTimePerFrame) {
1800 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1801
1802 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pAvgTimePerFrame);
1803
1804 return S_OK;
1805 }
1806
1807 static HRESULT WINAPI Basicvideo_get_BitRate(IBasicVideo *iface,
1808 long *pBitRate) {
1809 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1810
1811 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pBitRate);
1812
1813 return S_OK;
1814 }
1815
1816 static HRESULT WINAPI Basicvideo_get_BitErrorRate(IBasicVideo *iface,
1817 long *pBitErrorRate) {
1818 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1819
1820 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pBitErrorRate);
1821
1822 return S_OK;
1823 }
1824
1825 static HRESULT WINAPI Basicvideo_get_VideoWidth(IBasicVideo *iface,
1826 long *pVideoWidth) {
1827 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1828
1829 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pVideoWidth);
1830
1831 return S_OK;
1832 }
1833
1834 static HRESULT WINAPI Basicvideo_get_VideoHeight(IBasicVideo *iface,
1835 long *pVideoHeight) {
1836 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1837
1838 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pVideoHeight);
1839
1840 return S_OK;
1841 }
1842
1843 static HRESULT WINAPI Basicvideo_put_SourceLeft(IBasicVideo *iface,
1844 long SourceLeft) {
1845 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1846
1847 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, SourceLeft);
1848
1849 return S_OK;
1850 }
1851
1852 static HRESULT WINAPI Basicvideo_get_SourceLeft(IBasicVideo *iface,
1853 long *pSourceLeft) {
1854 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1855
1856 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pSourceLeft);
1857
1858 return S_OK;
1859 }
1860
1861 static HRESULT WINAPI Basicvideo_put_SourceWidth(IBasicVideo *iface,
1862 long SourceWidth) {
1863 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1864
1865 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, SourceWidth);
1866
1867 return S_OK;
1868 }
1869
1870 static HRESULT WINAPI Basicvideo_get_SourceWidth(IBasicVideo *iface,
1871 long *pSourceWidth) {
1872 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1873
1874 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pSourceWidth);
1875
1876 return S_OK;
1877 }
1878
1879 static HRESULT WINAPI Basicvideo_put_SourceTop(IBasicVideo *iface,
1880 long SourceTop) {
1881 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1882
1883 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, SourceTop);
1884
1885 return S_OK;
1886 }
1887
1888 static HRESULT WINAPI Basicvideo_get_SourceTop(IBasicVideo *iface,
1889 long *pSourceTop) {
1890 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1891
1892 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pSourceTop);
1893
1894 return S_OK;
1895 }
1896
1897 static HRESULT WINAPI Basicvideo_put_SourceHeight(IBasicVideo *iface,
1898 long SourceHeight) {
1899 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1900
1901 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, SourceHeight);
1902
1903 return S_OK;
1904 }
1905
1906 static HRESULT WINAPI Basicvideo_get_SourceHeight(IBasicVideo *iface,
1907 long *pSourceHeight) {
1908 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1909
1910 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pSourceHeight);
1911
1912 return S_OK;
1913 }
1914
1915 static HRESULT WINAPI Basicvideo_put_DestinationLeft(IBasicVideo *iface,
1916 long DestinationLeft) {
1917 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1918
1919 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, DestinationLeft);
1920
1921 return S_OK;
1922 }
1923
1924 static HRESULT WINAPI Basicvideo_get_DestinationLeft(IBasicVideo *iface,
1925 long *pDestinationLeft) {
1926 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1927
1928 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDestinationLeft);
1929
1930 return S_OK;
1931 }
1932
1933 static HRESULT WINAPI Basicvideo_put_DestinationWidth(IBasicVideo *iface,
1934 long DestinationWidth) {
1935 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1936
1937 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, DestinationWidth);
1938
1939 return S_OK;
1940 }
1941
1942 static HRESULT WINAPI Basicvideo_get_DestinationWidth(IBasicVideo *iface,
1943 long *pDestinationWidth) {
1944 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1945
1946 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDestinationWidth);
1947
1948 return S_OK;
1949 }
1950
1951 static HRESULT WINAPI Basicvideo_put_DestinationTop(IBasicVideo *iface,
1952 long DestinationTop) {
1953 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1954
1955 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, DestinationTop);
1956
1957 return S_OK;
1958 }
1959
1960 static HRESULT WINAPI Basicvideo_get_DestinationTop(IBasicVideo *iface,
1961 long *pDestinationTop) {
1962 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1963
1964 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDestinationTop);
1965
1966 return S_OK;
1967 }
1968
1969 static HRESULT WINAPI Basicvideo_put_DestinationHeight(IBasicVideo *iface,
1970 long DestinationHeight) {
1971 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1972
1973 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, DestinationHeight);
1974
1975 return S_OK;
1976 }
1977
1978 static HRESULT WINAPI Basicvideo_get_DestinationHeight(IBasicVideo *iface,
1979 long *pDestinationHeight) {
1980 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1981
1982 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDestinationHeight);
1983
1984 return S_OK;
1985 }
1986
1987 static HRESULT WINAPI Basicvideo_SetSourcePosition(IBasicVideo *iface,
1988 long Left,
1989 long Top,
1990 long Width,
1991 long Height) {
1992 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
1993
1994 TRACE("(%p/%p)->(%ld, %ld, %ld, %ld): stub !!!\n", This, iface, Left, Top, Width, Height);
1995
1996 return S_OK;
1997 }
1998
1999 static HRESULT WINAPI Basicvideo_GetSourcePosition(IBasicVideo *iface,
2000 long *pLeft,
2001 long *pTop,
2002 long *pWidth,
2003 long *pHeight) {
2004 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2005
2006 TRACE("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight);
2007
2008 return S_OK;
2009 }
2010
2011 static HRESULT WINAPI Basicvideo_SetDefaultSourcePosition(IBasicVideo *iface) {
2012 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2013
2014 TRACE("(%p/%p)->(): stub !!!\n", This, iface);
2015
2016 return S_OK;
2017 }
2018
2019 static HRESULT WINAPI Basicvideo_SetDestinationPosition(IBasicVideo *iface,
2020 long Left,
2021 long Top,
2022 long Width,
2023 long Height) {
2024 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2025
2026 TRACE("(%p/%p)->(%ld, %ld, %ld, %ld): stub !!!\n", This, iface, Left, Top, Width, Height);
2027
2028 return S_OK;
2029 }
2030
2031 static HRESULT WINAPI Basicvideo_GetDestinationPosition(IBasicVideo *iface,
2032 long *pLeft,
2033 long *pTop,
2034 long *pWidth,
2035 long *pHeight) {
2036 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2037
2038 TRACE("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight);
2039
2040 return S_OK;
2041 }
2042
2043 static HRESULT WINAPI Basicvideo_SetDefaultDestinationPosition(IBasicVideo *iface) {
2044 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2045
2046 TRACE("(%p/%p)->(): stub !!!\n", This, iface);
2047
2048 return S_OK;
2049 }
2050
2051 static HRESULT WINAPI Basicvideo_GetVideoSize(IBasicVideo *iface,
2052 long *pWidth,
2053 long *pHeight) {
2054 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2055
2056 TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pWidth, pHeight);
2057
2058 return S_OK;
2059 }
2060
2061 static HRESULT WINAPI Basicvideo_GetVideoPaletteEntries(IBasicVideo *iface,
2062 long StartIndex,
2063 long Entries,
2064 long *pRetrieved,
2065 long *pPalette) {
2066 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2067
2068 TRACE("(%p/%p)->(%ld, %ld, %p, %p): stub !!!\n", This, iface, StartIndex, Entries, pRetrieved, pPalette);
2069
2070 return S_OK;
2071 }
2072
2073 static HRESULT WINAPI Basicvideo_GetCurrentImage(IBasicVideo *iface,
2074 long *pBufferSize,
2075 long *pDIBImage) {
2076 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2077
2078 TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pBufferSize, pDIBImage);
2079
2080 return S_OK;
2081 }
2082
2083 static HRESULT WINAPI Basicvideo_IsUsingDefaultSource(IBasicVideo *iface) {
2084 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2085
2086 TRACE("(%p/%p)->(): stub !!!\n", This, iface);
2087
2088 return S_OK;
2089 }
2090
2091 static HRESULT WINAPI Basicvideo_IsUsingDefaultDestination(IBasicVideo *iface) {
2092 ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface);
2093
2094 TRACE("(%p/%p)->(): stub !!!\n", This, iface);
2095
2096 return S_OK;
2097 }
2098
2099
2100 static IBasicVideoVtbl IBasicVideo_VTable =
2101 {
2102 Basicvideo_QueryInterface,
2103 Basicvideo_AddRef,
2104 Basicvideo_Release,
2105 Basicvideo_GetTypeInfoCount,
2106 Basicvideo_GetTypeInfo,
2107 Basicvideo_GetIDsOfNames,
2108 Basicvideo_Invoke,
2109 Basicvideo_get_AvgTimePerFrame,
2110 Basicvideo_get_BitRate,
2111 Basicvideo_get_BitErrorRate,
2112 Basicvideo_get_VideoWidth,
2113 Basicvideo_get_VideoHeight,
2114 Basicvideo_put_SourceLeft,
2115 Basicvideo_get_SourceLeft,
2116 Basicvideo_put_SourceWidth,
2117 Basicvideo_get_SourceWidth,
2118 Basicvideo_put_SourceTop,
2119 Basicvideo_get_SourceTop,
2120 Basicvideo_put_SourceHeight,
2121 Basicvideo_get_SourceHeight,
2122 Basicvideo_put_DestinationLeft,
2123 Basicvideo_get_DestinationLeft,
2124 Basicvideo_put_DestinationWidth,
2125 Basicvideo_get_DestinationWidth,
2126 Basicvideo_put_DestinationTop,
2127 Basicvideo_get_DestinationTop,
2128 Basicvideo_put_DestinationHeight,
2129 Basicvideo_get_DestinationHeight,
2130 Basicvideo_SetSourcePosition,
2131 Basicvideo_GetSourcePosition,
2132 Basicvideo_SetDefaultSourcePosition,
2133 Basicvideo_SetDestinationPosition,
2134 Basicvideo_GetDestinationPosition,
2135 Basicvideo_SetDefaultDestinationPosition,
2136 Basicvideo_GetVideoSize,
2137 Basicvideo_GetVideoPaletteEntries,
2138 Basicvideo_GetCurrentImage,
2139 Basicvideo_IsUsingDefaultSource,
2140 Basicvideo_IsUsingDefaultDestination
2141 };
2142
2143
2144 /*** IUnknown methods ***/
2145 static HRESULT WINAPI Videowindow_QueryInterface(IVideoWindow *iface,
2146 REFIID riid,
2147 LPVOID*ppvObj) {
2148 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2149
2150 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
2151
2152 return Filtergraph_QueryInterface(This, riid, ppvObj);
2153 }
2154
2155 static ULONG WINAPI Videowindow_AddRef(IVideoWindow *iface) {
2156 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2157
2158 TRACE("(%p/%p)->()\n", This, iface);
2159
2160 return Filtergraph_AddRef(This);
2161 }
2162
2163 static ULONG WINAPI Videowindow_Release(IVideoWindow *iface) {
2164 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2165
2166 TRACE("(%p/%p)->()\n", This, iface);
2167
2168 return Filtergraph_Release(This);
2169 }
2170
2171 /*** IDispatch methods ***/
2172 static HRESULT WINAPI Videowindow_GetTypeInfoCount(IVideoWindow *iface,
2173 UINT*pctinfo) {
2174 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2175
2176 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
2177
2178 return S_OK;
2179 }
2180
2181 static HRESULT WINAPI Videowindow_GetTypeInfo(IVideoWindow *iface,
2182 UINT iTInfo,
2183 LCID lcid,
2184 ITypeInfo**ppTInfo) {
2185 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2186
2187 TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
2188
2189 return S_OK;
2190 }
2191
2192 static HRESULT WINAPI Videowindow_GetIDsOfNames(IVideoWindow *iface,
2193 REFIID riid,
2194 LPOLESTR*rgszNames,
2195 UINT cNames,
2196 LCID lcid,
2197 DISPID*rgDispId) {
2198 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2199
2200 TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
2201
2202 return S_OK;
2203 }
2204
2205 static HRESULT WINAPI Videowindow_Invoke(IVideoWindow *iface,
2206 DISPID dispIdMember,
2207 REFIID riid,
2208 LCID lcid,
2209 WORD wFlags,
2210 DISPPARAMS*pDispParams,
2211 VARIANT*pVarResult,
2212 EXCEPINFO*pExepInfo,
2213 UINT*puArgErr) {
2214 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2215
2216 TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
2217
2218 return S_OK;
2219 }
2220
2221 /*** IVideoWindow methods ***/
2222 static HRESULT WINAPI Videowindow_put_Caption(IVideoWindow *iface,
2223 BSTR strCaption) {
2224 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2225
2226 TRACE("(%p/%p)->(%s (%p)): stub !!!\n", This, iface, debugstr_w(strCaption), strCaption);
2227
2228 return S_OK;
2229 }
2230
2231 static HRESULT WINAPI Videowindow_get_Caption(IVideoWindow *iface,
2232 BSTR *strCaption) {
2233 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2234
2235 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, strCaption);
2236
2237 return S_OK;
2238 }
2239
2240 static HRESULT WINAPI Videowindow_put_WindowStyle(IVideoWindow *iface,
2241 long WindowStyle) {
2242 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2243
2244 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, WindowStyle);
2245
2246 return S_OK;
2247 }
2248
2249 static HRESULT WINAPI Videowindow_get_WindowStyle(IVideoWindow *iface,
2250 long *WindowStyle) {
2251 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2252
2253 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, WindowStyle);
2254
2255 return S_OK;
2256 }
2257
2258 static HRESULT WINAPI Videowindow_put_WindowStyleEx(IVideoWindow *iface,
2259 long WindowStyleEx) {
2260 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2261
2262 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, WindowStyleEx);
2263
2264 return S_OK;
2265 }
2266
2267 static HRESULT WINAPI Videowindow_get_WindowStyleEx(IVideoWindow *iface,
2268 long *WindowStyleEx) {
2269 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2270
2271 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, WindowStyleEx);
2272
2273 return S_OK;
2274 }
2275
2276 static HRESULT WINAPI Videowindow_put_AutoShow(IVideoWindow *iface,
2277 long AutoShow) {
2278 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2279
2280 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, AutoShow);
2281
2282 return S_OK;
2283 }
2284
2285 static HRESULT WINAPI Videowindow_get_AutoShow(IVideoWindow *iface,
2286 long *AutoShow) {
2287 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2288
2289 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, AutoShow);
2290
2291 return S_OK;
2292 }
2293
2294 static HRESULT WINAPI Videowindow_put_WindowState(IVideoWindow *iface,
2295 long WindowState) {
2296 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2297
2298 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, WindowState);
2299
2300 return S_OK;
2301 }
2302
2303 static HRESULT WINAPI Videowindow_get_WindowState(IVideoWindow *iface,
2304 long *WindowState) {
2305 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2306
2307 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, WindowState);
2308
2309 return S_OK;
2310 }
2311
2312 static HRESULT WINAPI Videowindow_put_BackgroundPalette(IVideoWindow *iface,
2313 long BackgroundPalette) {
2314 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2315
2316 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, BackgroundPalette);
2317
2318 return S_OK;
2319 }
2320
2321 static HRESULT WINAPI Videowindow_get_BackgroundPalette(IVideoWindow *iface,
2322 long *pBackgroundPalette) {
2323 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2324
2325 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pBackgroundPalette);
2326
2327 return S_OK;
2328 }
2329
2330 static HRESULT WINAPI Videowindow_put_Visible(IVideoWindow *iface,
2331 long Visible) {
2332 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2333
2334 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Visible);
2335
2336 return S_OK;
2337 }
2338
2339 static HRESULT WINAPI Videowindow_get_Visible(IVideoWindow *iface,
2340 long *pVisible) {
2341 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2342
2343 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pVisible);
2344
2345 return S_OK;
2346 }
2347
2348 static HRESULT WINAPI Videowindow_put_Left(IVideoWindow *iface,
2349 long Left) {
2350 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2351
2352 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Left);
2353
2354 return S_OK;
2355 }
2356
2357 static HRESULT WINAPI Videowindow_get_Left(IVideoWindow *iface,
2358 long *pLeft) {
2359 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2360
2361 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pLeft);
2362
2363 return S_OK;
2364 }
2365
2366 static HRESULT WINAPI Videowindow_put_Width(IVideoWindow *iface,
2367 long Width) {
2368 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2369
2370 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Width);
2371
2372 return S_OK;
2373 }
2374
2375 static HRESULT WINAPI Videowindow_get_Width(IVideoWindow *iface,
2376 long *pWidth) {
2377 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2378
2379 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pWidth);
2380
2381 return S_OK;
2382 }
2383
2384 static HRESULT WINAPI Videowindow_put_Top(IVideoWindow *iface,
2385 long Top) {
2386 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2387
2388 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Top);
2389
2390 return S_OK;
2391 }
2392
2393 static HRESULT WINAPI Videowindow_get_Top(IVideoWindow *iface,
2394 long *pTop) {
2395 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2396
2397 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pTop);
2398
2399 return S_OK;
2400 }
2401
2402 static HRESULT WINAPI Videowindow_put_Height(IVideoWindow *iface,
2403 long Height) {
2404 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2405
2406 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Height);
2407
2408 return S_OK;
2409 }
2410
2411 static HRESULT WINAPI Videowindow_get_Height(IVideoWindow *iface,
2412 long *pHeight) {
2413 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2414
2415 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pHeight);
2416
2417 return S_OK;
2418 }
2419
2420 static HRESULT WINAPI Videowindow_put_Owner(IVideoWindow *iface,
2421 OAHWND Owner) {
2422 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2423
2424 TRACE("(%p/%p)->(%08lx): stub !!!\n", This, iface, (DWORD) Owner);
2425
2426 return S_OK;
2427 }
2428
2429 static HRESULT WINAPI Videowindow_get_Owner(IVideoWindow *iface,
2430 OAHWND *Owner) {
2431 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2432
2433 TRACE("(%p/%p)->(%08lx): stub !!!\n", This, iface, (DWORD) Owner);
2434
2435 return S_OK;
2436 }
2437
2438 static HRESULT WINAPI Videowindow_put_MessageDrain(IVideoWindow *iface,
2439 OAHWND Drain) {
2440 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2441
2442 TRACE("(%p/%p)->(%08lx): stub !!!\n", This, iface, (DWORD) Drain);
2443
2444 return S_OK;
2445 }
2446
2447 static HRESULT WINAPI Videowindow_get_MessageDrain(IVideoWindow *iface,
2448 OAHWND *Drain) {
2449 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2450
2451 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, Drain);
2452
2453 return S_OK;
2454 }
2455
2456 static HRESULT WINAPI Videowindow_get_BorderColor(IVideoWindow *iface,
2457 long *Color) {
2458 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2459
2460 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, Color);
2461
2462 return S_OK;
2463 }
2464
2465 static HRESULT WINAPI Videowindow_put_BorderColor(IVideoWindow *iface,
2466 long Color) {
2467 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2468
2469 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Color);
2470
2471 return S_OK;
2472 }
2473
2474 static HRESULT WINAPI Videowindow_get_FullScreenMode(IVideoWindow *iface,
2475 long *FullScreenMode) {
2476 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2477
2478 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, FullScreenMode);
2479
2480 return S_OK;
2481 }
2482
2483 static HRESULT WINAPI Videowindow_put_FullScreenMode(IVideoWindow *iface,
2484 long FullScreenMode) {
2485 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2486
2487 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, FullScreenMode);
2488
2489 return S_OK;
2490 }
2491
2492 static HRESULT WINAPI Videowindow_SetWindowForeground(IVideoWindow *iface,
2493 long Focus) {
2494 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2495
2496 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Focus);
2497
2498 return S_OK;
2499 }
2500
2501 static HRESULT WINAPI Videowindow_NotifyOwnerMessage(IVideoWindow *iface,
2502 OAHWND hwnd,
2503 long uMsg,
2504 LONG_PTR wParam,
2505 LONG_PTR lParam) {
2506 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2507
2508 TRACE("(%p/%p)->(%08lx, %ld, %08lx, %08lx): stub !!!\n", This, iface, (DWORD) hwnd, uMsg, wParam, lParam);
2509
2510 return S_OK;
2511 }
2512
2513 static HRESULT WINAPI Videowindow_SetWindowPosition(IVideoWindow *iface,
2514 long Left,
2515 long Top,
2516 long Width,
2517 long Height) {
2518 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2519
2520 TRACE("(%p/%p)->(%ld, %ld, %ld, %ld): stub !!!\n", This, iface, Left, Top, Width, Height);
2521
2522 return S_OK;
2523 }
2524
2525 static HRESULT WINAPI Videowindow_GetWindowPosition(IVideoWindow *iface,
2526 long *pLeft,
2527 long *pTop,
2528 long *pWidth,
2529 long *pHeight) {
2530 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2531
2532 TRACE("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight);
2533
2534 return S_OK;
2535 }
2536
2537 static HRESULT WINAPI Videowindow_GetMinIdealImageSize(IVideoWindow *iface,
2538 long *pWidth,
2539 long *pHeight) {
2540 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2541
2542 TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pWidth, pHeight);
2543
2544 return S_OK;
2545 }
2546
2547 static HRESULT WINAPI Videowindow_GetMaxIdealImageSize(IVideoWindow *iface,
2548 long *pWidth,
2549 long *pHeight) {
2550 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2551
2552 TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pWidth, pHeight);
2553
2554 return S_OK;
2555 }
2556
2557 static HRESULT WINAPI Videowindow_GetRestorePosition(IVideoWindow *iface,
2558 long *pLeft,
2559 long *pTop,
2560 long *pWidth,
2561 long *pHeight) {
2562 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2563
2564 TRACE("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight);
2565
2566 return S_OK;
2567 }
2568
2569 static HRESULT WINAPI Videowindow_HideCursor(IVideoWindow *iface,
2570 long HideCursor) {
2571 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2572
2573 TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, HideCursor);
2574
2575 return S_OK;
2576 }
2577
2578 static HRESULT WINAPI Videowindow_IsCursorHidden(IVideoWindow *iface,
2579 long *CursorHidden) {
2580 ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface);
2581
2582 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, CursorHidden);
2583
2584 return S_OK;
2585 }
2586
2587
2588 static IVideoWindowVtbl IVideoWindow_VTable =
2589 {
2590 Videowindow_QueryInterface,
2591 Videowindow_AddRef,
2592 Videowindow_Release,
2593 Videowindow_GetTypeInfoCount,
2594 Videowindow_GetTypeInfo,
2595 Videowindow_GetIDsOfNames,
2596 Videowindow_Invoke,
2597 Videowindow_put_Caption,
2598 Videowindow_get_Caption,
2599 Videowindow_put_WindowStyle,
2600 Videowindow_get_WindowStyle,
2601 Videowindow_put_WindowStyleEx,
2602 Videowindow_get_WindowStyleEx,
2603 Videowindow_put_AutoShow,
2604 Videowindow_get_AutoShow,
2605 Videowindow_put_WindowState,
2606 Videowindow_get_WindowState,
2607 Videowindow_put_BackgroundPalette,
2608 Videowindow_get_BackgroundPalette,
2609 Videowindow_put_Visible,
2610 Videowindow_get_Visible,
2611 Videowindow_put_Left,
2612 Videowindow_get_Left,
2613 Videowindow_put_Width,
2614 Videowindow_get_Width,
2615 Videowindow_put_Top,
2616 Videowindow_get_Top,
2617 Videowindow_put_Height,
2618 Videowindow_get_Height,
2619 Videowindow_put_Owner,
2620 Videowindow_get_Owner,
2621 Videowindow_put_MessageDrain,
2622 Videowindow_get_MessageDrain,
2623 Videowindow_get_BorderColor,
2624 Videowindow_put_BorderColor,
2625 Videowindow_get_FullScreenMode,
2626 Videowindow_put_FullScreenMode,
2627 Videowindow_SetWindowForeground,
2628 Videowindow_NotifyOwnerMessage,
2629 Videowindow_SetWindowPosition,
2630 Videowindow_GetWindowPosition,
2631 Videowindow_GetMinIdealImageSize,
2632 Videowindow_GetMaxIdealImageSize,
2633 Videowindow_GetRestorePosition,
2634 Videowindow_HideCursor,
2635 Videowindow_IsCursorHidden
2636 };
2637
2638
2639 /*** IUnknown methods ***/
2640 static HRESULT WINAPI Mediaevent_QueryInterface(IMediaEventEx *iface,
2641 REFIID riid,
2642 LPVOID*ppvObj) {
2643 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2644
2645 TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
2646
2647 return Filtergraph_QueryInterface(This, riid, ppvObj);
2648 }
2649
2650 static ULONG WINAPI Mediaevent_AddRef(IMediaEventEx *iface) {
2651 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2652
2653 TRACE("(%p/%p)->()\n", This, iface);
2654
2655 return Filtergraph_AddRef(This);
2656 }
2657
2658 static ULONG WINAPI Mediaevent_Release(IMediaEventEx *iface) {
2659 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2660
2661 TRACE("(%p/%p)->()\n", This, iface);
2662
2663 return Filtergraph_Release(This);
2664 }
2665
2666 /*** IDispatch methods ***/
2667 static HRESULT WINAPI Mediaevent_GetTypeInfoCount(IMediaEventEx *iface,
2668 UINT*pctinfo) {
2669 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2670
2671 TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
2672
2673 return S_OK;
2674 }
2675
2676 static HRESULT WINAPI Mediaevent_GetTypeInfo(IMediaEventEx *iface,
2677 UINT iTInfo,
2678 LCID lcid,
2679 ITypeInfo**ppTInfo) {
2680 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2681
2682 TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
2683
2684 return S_OK;
2685 }
2686
2687 static HRESULT WINAPI Mediaevent_GetIDsOfNames(IMediaEventEx *iface,
2688 REFIID riid,
2689 LPOLESTR*rgszNames,
2690 UINT cNames,
2691 LCID lcid,
2692 DISPID*rgDispId) {
2693 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2694
2695 TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
2696
2697 return S_OK;
2698 }
2699
2700 static HRESULT WINAPI Mediaevent_Invoke(IMediaEventEx *iface,
2701 DISPID dispIdMember,
2702 REFIID riid,
2703 LCID lcid,
2704 WORD wFlags,
2705 DISPPARAMS*pDispParams,
2706 VARIANT*pVarResult,
2707 EXCEPINFO*pExepInfo,
2708 UINT*puArgErr) {
2709 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2710
2711 TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
2712
2713 return S_OK;
2714 }
2715
2716 /*** IMediaEvent methods ***/
2717 static HRESULT WINAPI Mediaevent_GetEventHandle(IMediaEventEx *iface,
2718 OAEVENT *hEvent) {
2719 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2720
2721 TRACE("(%p/%p)->(%p)\n", This, iface, hEvent);
2722
2723 *hEvent = (OAEVENT)This->evqueue.msg_event;
2724
2725 return S_OK;
2726 }
2727
2728 static HRESULT WINAPI Mediaevent_GetEvent(IMediaEventEx *iface,
2729 long *lEventCode,
2730 LONG_PTR *lParam1,
2731 LONG_PTR *lParam2,
2732 long msTimeout) {
2733 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2734 Event evt;
2735
2736 TRACE("(%p/%p)->(%p, %p, %p, %ld)\n", This, iface, lEventCode, lParam1, lParam2, msTimeout);
2737
2738 if (EventsQueue_GetEvent(&This->evqueue, &evt, msTimeout))
2739 {
2740 *lEventCode = evt.lEventCode;
2741 *lParam1 = evt.lParam1;
2742 *lParam2 = evt.lParam2;
2743 return S_OK;
2744 }
2745
2746 *lEventCode = 0;
2747 return E_ABORT;
2748 }
2749
2750 static HRESULT WINAPI Mediaevent_WaitForCompletion(IMediaEventEx *iface,
2751 long msTimeout,
2752 long *pEvCode) {
2753 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2754
2755 TRACE("(%p/%p)->(%ld, %p)\n", This, iface, msTimeout, pEvCode);
2756
2757 if (WaitForSingleObject(This->hEventCompletion, msTimeout) == WAIT_OBJECT_0)
2758 {
2759 *pEvCode = This->CompletionStatus;
2760 return S_OK;
2761 }
2762
2763 *pEvCode = 0;
2764 return E_ABORT;
2765 }
2766
2767 static HRESULT WINAPI Mediaevent_CancelDefaultHandling(IMediaEventEx *iface,
2768 long lEvCode) {
2769 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2770
2771 TRACE("(%p/%p)->(%ld)\n", This, iface, lEvCode);
2772
2773 if (lEvCode == EC_COMPLETE)
2774 This->HandleEcComplete = FALSE;
2775 else if (lEvCode == EC_REPAINT)
2776 This->HandleEcRepaint = FALSE;
2777 else
2778 return S_FALSE;
2779
2780 return S_OK;
2781 }
2782
2783 static HRESULT WINAPI Mediaevent_RestoreDefaultHandling(IMediaEventEx *iface,
2784 long lEvCode) {
2785 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2786
2787 TRACE("(%p/%p)->(%ld)\n", This, iface, lEvCode);
2788
2789 if (lEvCode == EC_COMPLETE)
2790 This->HandleEcComplete = TRUE;
2791 else if (lEvCode == EC_REPAINT)
2792 This->HandleEcRepaint = TRUE;
2793 else
2794 return S_FALSE;
2795
2796 return S_OK;
2797 }
2798
2799 static HRESULT WINAPI Mediaevent_FreeEventParams(IMediaEventEx *iface,
2800 long lEvCode,
2801 LONG_PTR lParam1,
2802 LONG_PTR lParam2) {
2803 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2804
2805 TRACE("(%p/%p)->(%ld, %08lx, %08lx): stub !!!\n", This, iface, lEvCode, lParam1, lParam2);
2806
2807 return S_OK;
2808 }
2809
2810 /*** IMediaEventEx methods ***/
2811 static HRESULT WINAPI Mediaevent_SetNotifyWindow(IMediaEventEx *iface,
2812 OAHWND hwnd,
2813 long lMsg,
2814 LONG_PTR lInstanceData) {
2815 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2816
2817 TRACE("(%p/%p)->(%08lx, %ld, %08lx)\n", This, iface, (DWORD) hwnd, lMsg, lInstanceData);
2818
2819 This->notif.hWnd = (HWND)hwnd;
2820 This->notif.msg = lMsg;
2821 This->notif.instance = (long) lInstanceData;
2822
2823 return S_OK;
2824 }
2825
2826 static HRESULT WINAPI Mediaevent_SetNotifyFlags(IMediaEventEx *iface,
2827 long lNoNotifyFlags) {
2828 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2829
2830 TRACE("(%p/%p)->(%ld)\n", This, iface, lNoNotifyFlags);
2831
2832 if ((lNoNotifyFlags != 0) || (lNoNotifyFlags != 1))
2833 return E_INVALIDARG;
2834
2835 This->notif.disabled = lNoNotifyFlags;
2836
2837 return S_OK;
2838 }
2839
2840 static HRESULT WINAPI Mediaevent_GetNotifyFlags(IMediaEventEx *iface,
2841 long *lplNoNotifyFlags) {
2842 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2843
2844 TRACE("(%p/%p)->(%p)\n", This, iface, lplNoNotifyFlags);
2845
2846 if (!lplNoNotifyFlags)
2847 return E_POINTER;
2848
2849 *lplNoNotifyFlags = This->notif.disabled;
2850
2851 return S_OK;
2852 }
2853
2854
2855 static IMediaEventExVtbl IMediaEventEx_VTable =
2856 {
2857 Mediaevent_QueryInterface,
2858 Mediaevent_AddRef,
2859 Mediaevent_Release,
2860 Mediaevent_GetTypeInfoCount,
2861 Mediaevent_GetTypeInfo,
2862 Mediaevent_GetIDsOfNames,
2863 Mediaevent_Invoke,
2864 Mediaevent_GetEventHandle,
2865 Mediaevent_GetEvent,
2866 Mediaevent_WaitForCompletion,
2867 Mediaevent_CancelDefaultHandling,
2868 Mediaevent_RestoreDefaultHandling,
2869 Mediaevent_FreeEventParams,
2870 Mediaevent_SetNotifyWindow,
2871 Mediaevent_SetNotifyFlags,
2872 Mediaevent_GetNotifyFlags
2873 };
2874
2875
2876 static HRESULT WINAPI MediaFilter_QueryInterface(IMediaFilter *iface, REFIID riid, LPVOID *ppv)
2877 {
2878 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2879
2880 return Filtergraph_QueryInterface(This, riid, ppv);
2881 }
2882
2883 static ULONG WINAPI MediaFilter_AddRef(IMediaFilter *iface)
2884 {
2885 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2886
2887 return Filtergraph_AddRef(This);
2888 }
2889
2890 static ULONG WINAPI MediaFilter_Release(IMediaFilter *iface)
2891 {
2892 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface);
2893
2894 return Filtergraph_Release(This);
2895 }
2896
2897 static HRESULT WINAPI MediaFilter_GetClassID(IMediaFilter *iface, CLSID * pClassID)
2898 {
2899 FIXME("(%p): stub\n", pClassID);
2900
2901 return E_NOTIMPL;
2902 }
2903
2904 static HRESULT WINAPI MediaFilter_Stop(IMediaFilter *iface)
2905 {
2906 FIXME("(): stub\n");
2907
2908 return E_NOTIMPL;
2909 }
2910
2911 static HRESULT WINAPI MediaFilter_Pause(IMediaFilter *iface)
2912 {
2913 FIXME("(): stub\n");
2914
2915 return E_NOTIMPL;
2916 }
2917
2918 static HRESULT WINAPI MediaFilter_Run(IMediaFilter *iface, REFERENCE_TIME tStart)
2919 {
2920 FIXME("(%lld): stub\n", tStart);
2921
2922 return E_NOTIMPL;
2923 }
2924
2925 static HRESULT WINAPI MediaFilter_GetState(IMediaFilter *iface, DWORD dwMsTimeout, FILTER_STATE * pState)
2926 {
2927 FIXME("(%ld, %p): stub\n", dwMsTimeout, pState);
2928
2929 return E_NOTIMPL;
2930 }
2931
2932 static HRESULT WINAPI MediaFilter_SetSyncSource(IMediaFilter *iface, IReferenceClock *pClock)
2933 {
2934 FIXME("(%p): stub\n", pClock);
2935
2936 return E_NOTIMPL;
2937 }
2938
2939 static HRESULT WINAPI MediaFilter_GetSyncSource(IMediaFilter *iface, IReferenceClock **ppClock)
2940 {
2941 FIXME("(%p): stub\n", ppClock);
2942
2943 return E_NOTIMPL;
2944 }
2945
2946 static IMediaFilterVtbl IMediaFilter_VTable =
2947 {
2948 MediaFilter_QueryInterface,
2949 MediaFilter_AddRef,
2950 MediaFilter_Release,
2951 MediaFilter_GetClassID,
2952 MediaFilter_Stop,
2953 MediaFilter_Pause,
2954 MediaFilter_Run,
2955 MediaFilter_GetState,
2956 MediaFilter_SetSyncSource,
2957 MediaFilter_GetSyncSource
2958 };
2959
2960 static HRESULT WINAPI MediaEventSink_QueryInterface(IMediaEventSink *iface, REFIID riid, LPVOID *ppv)
2961 {
2962 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventSink_vtbl, iface);
2963
2964 return Filtergraph_QueryInterface(This, riid, ppv);
2965 }
2966
2967 static ULONG WINAPI MediaEventSink_AddRef(IMediaEventSink *iface)
2968 {
2969 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventSink_vtbl, iface);
2970
2971 return Filtergraph_AddRef(This);
2972 }
2973
2974 static ULONG WINAPI MediaEventSink_Release(IMediaEventSink *iface)
2975 {
2976 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventSink_vtbl, iface);
2977
2978 return Filtergraph_Release(This);
2979 }
2980
2981 static HRESULT WINAPI MediaEventSink_Notify(IMediaEventSink *iface, long EventCode, LONG_PTR EventParam1, LONG_PTR EventParam2)
2982 {
2983 ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventSink_vtbl, iface);
2984 Event evt;
2985
2986 TRACE("(%p/%p)->(%ld, %ld, %ld)\n", This, iface, EventCode, EventParam1, EventParam2);
2987
2988 /* We need thread safety here, let's use the events queue's one */
2989 EnterCriticalSection(&This->evqueue.msg_crst);
2990
2991 if ((EventCode == EC_COMPLETE) && This->HandleEcComplete)
2992 {
2993 if (++This->EcCompleteCount == This->nRenderers)
2994 {
2995 evt.lEventCode = EC_COMPLETE;
2996 evt.lParam1 = S_OK;
2997 evt.lParam2 = 0;
2998 EventsQueue_PutEvent(&This->evqueue, &evt);
2999 if (!This->notif.disabled && This->notif.hWnd)
3000 PostMessageW(This->notif.hWnd, This->notif.msg, 0, This->notif.instance);
3001 This->CompletionStatus = EC_COMPLETE;
3002 SetEvent(This->hEventCompletion);
3003 }
3004 }
3005 else if ((EventCode == EC_REPAINT) && This->HandleEcRepaint)
3006 {
3007 /* FIXME: Not handled yet */
3008 }
3009 else
3010 {
3011 evt.lEventCode = EventCode;
3012 evt.lParam1 = EventParam1;
3013 evt.lParam2 = EventParam2;
3014 EventsQueue_PutEvent(&This->evqueue, &evt);
3015 if (!This->notif.disabled && This->notif.hWnd)
3016 PostMessageW(This->notif.hWnd, This->notif.msg, 0, This->notif.instance);
3017 }
3018
3019 LeaveCriticalSection(&This->evqueue.msg_crst);
3020 return S_OK;
3021 }
3022
3023 static IMediaEventSinkVtbl IMediaEventSink_VTable =
3024 {
3025 MediaEventSink_QueryInterface,
3026 MediaEventSink_AddRef,
3027 MediaEventSink_Release,
3028 MediaEventSink_Notify
3029 };
3030
3031 /* This is the only function that actually creates a FilterGraph class... */
3032 HRESULT FILTERGRAPH_create(IUnknown *pUnkOuter, LPVOID *ppObj) {
3033 IFilterGraphImpl *fimpl;
3034 HRESULT hr;
3035
3036 TRACE("(%p,%p)\n", pUnkOuter, ppObj);
3037
3038 if( pUnkOuter )
3039 return CLASS_E_NOAGGREGATION;
3040
3041 fimpl = (IFilterGraphImpl *) HeapAlloc(GetProcessHeap(), 0, sizeof(*fimpl));
3042 fimpl->IGraphBuilder_vtbl = &IGraphBuilder_VTable;
3043 fimpl->IMediaControl_vtbl = &IMediaControl_VTable;
3044 fimpl->IMediaSeeking_vtbl = &IMediaSeeking_VTable;
3045 fimpl->IBasicAudio_vtbl = &IBasicAudio_VTable;
3046 fimpl->IBasicVideo_vtbl = &IBasicVideo_VTable;
3047 fimpl->IVideoWindow_vtbl = &IVideoWindow_VTable;
3048 fimpl->IMediaEventEx_vtbl = &IMediaEventEx_VTable;
3049 fimpl->IMediaFilter_vtbl = &IMediaFilter_VTable;
3050 fimpl->IMediaEventSink_vtbl = &IMediaEventSink_VTable;
3051 fimpl->ref = 1;
3052 fimpl->ppFiltersInGraph = NULL;
3053 fimpl->pFilterNames = NULL;
3054 fimpl->nFilters = 0;
3055 fimpl->filterCapacity = 0;
3056 fimpl->nameIndex = 1;
3057 fimpl->hEventCompletion = CreateEventW(0, TRUE, FALSE,0);
3058 fimpl->HandleEcComplete = TRUE;
3059 fimpl->HandleEcRepaint = TRUE;
3060 fimpl->notif.hWnd = 0;
3061 fimpl->notif.disabled = TRUE;
3062 fimpl->nRenderers = 0;
3063 fimpl->EcCompleteCount = 0;
3064 fimpl->state = State_Stopped;
3065 EventsQueue_Init(&fimpl->evqueue);
3066 InitializeCriticalSection(&fimpl->cs);
3067
3068 hr = CoCreateInstance(&CLSID_FilterMapper, NULL, CLSCTX_INPROC_SERVER, &IID_IFilterMapper2, (LPVOID*)&fimpl->pFilterMapper2);
3069 if (FAILED(hr)) {
3070 ERR("Unable to create filter mapper (%lx)\n", hr);
3071 return hr;
3072 }
3073
3074 *ppObj = fimpl;
3075 return S_OK;
3076 }
Windows API implementation