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