[QEDIT]
[reactos.git] / reactos / dll / directx / qedit / mediadet.c
1 /* DirectShow Media Detector object (QEDIT.DLL)
2 *
3 * Copyright 2008 Google (Lei Zhang, Dan Hipschman)
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #include <assert.h>
21 #include <stdarg.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "ole2.h"
29
30 #include "qedit_private.h"
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(qedit);
34
35 typedef struct MediaDetImpl {
36 const IMediaDetVtbl *MediaDet_Vtbl;
37 LONG refCount;
38 IGraphBuilder *graph;
39 IBaseFilter *source;
40 IBaseFilter *splitter;
41 long num_streams;
42 long cur_stream;
43 IPin *cur_pin;
44 } MediaDetImpl;
45
46 static void MD_cleanup(MediaDetImpl *This)
47 {
48 if (This->cur_pin) IPin_Release(This->cur_pin);
49 This->cur_pin = NULL;
50 if (This->source) IBaseFilter_Release(This->source);
51 This->source = NULL;
52 if (This->splitter) IBaseFilter_Release(This->splitter);
53 This->splitter = NULL;
54 if (This->graph) IGraphBuilder_Release(This->graph);
55 This->graph = NULL;
56 This->num_streams = -1;
57 This->cur_stream = 0;
58 }
59
60 static ULONG WINAPI MediaDet_AddRef(IMediaDet* iface)
61 {
62 MediaDetImpl *This = (MediaDetImpl *)iface;
63 ULONG refCount = InterlockedIncrement(&This->refCount);
64 TRACE("(%p)->() AddRef from %d\n", This, refCount - 1);
65 return refCount;
66 }
67
68 static ULONG WINAPI MediaDet_Release(IMediaDet* iface)
69 {
70 MediaDetImpl *This = (MediaDetImpl *)iface;
71 ULONG refCount = InterlockedDecrement(&This->refCount);
72 TRACE("(%p)->() Release from %d\n", This, refCount + 1);
73
74 if (refCount == 0)
75 {
76 MD_cleanup(This);
77 CoTaskMemFree(This);
78 return 0;
79 }
80
81 return refCount;
82 }
83
84 static HRESULT WINAPI MediaDet_QueryInterface(IMediaDet* iface, REFIID riid,
85 void **ppvObject)
86 {
87 MediaDetImpl *This = (MediaDetImpl *)iface;
88 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
89
90 if (IsEqualIID(riid, &IID_IUnknown) ||
91 IsEqualIID(riid, &IID_IMediaDet)) {
92 MediaDet_AddRef(iface);
93 *ppvObject = This;
94 return S_OK;
95 }
96 *ppvObject = NULL;
97 WARN("(%p, %s,%p): not found\n", This, debugstr_guid(riid), ppvObject);
98 return E_NOINTERFACE;
99 }
100
101 static HRESULT WINAPI MediaDet_get_Filter(IMediaDet* iface, IUnknown **pVal)
102 {
103 MediaDetImpl *This = (MediaDetImpl *)iface;
104 FIXME("(%p)->(%p): not implemented!\n", This, pVal);
105 return E_NOTIMPL;
106 }
107
108 static HRESULT WINAPI MediaDet_put_Filter(IMediaDet* iface, IUnknown *newVal)
109 {
110 MediaDetImpl *This = (MediaDetImpl *)iface;
111 FIXME("(%p)->(%p): not implemented!\n", This, newVal);
112 return E_NOTIMPL;
113 }
114
115 static HRESULT WINAPI MediaDet_get_OutputStreams(IMediaDet* iface, LONG *pVal)
116 {
117 MediaDetImpl *This = (MediaDetImpl *)iface;
118 IEnumPins *pins;
119 IPin *pin;
120 HRESULT hr;
121
122 TRACE("(%p)\n", This);
123
124 if (!This->splitter)
125 return E_INVALIDARG;
126
127 if (This->num_streams != -1)
128 {
129 *pVal = This->num_streams;
130 return S_OK;
131 }
132
133 *pVal = 0;
134
135 hr = IBaseFilter_EnumPins(This->splitter, &pins);
136 if (FAILED(hr))
137 return hr;
138
139 while (IEnumPins_Next(pins, 1, &pin, NULL) == S_OK)
140 {
141 PIN_DIRECTION dir;
142 hr = IPin_QueryDirection(pin, &dir);
143 IPin_Release(pin);
144 if (FAILED(hr))
145 {
146 IEnumPins_Release(pins);
147 return hr;
148 }
149
150 if (dir == PINDIR_OUTPUT)
151 ++*pVal;
152 }
153 IEnumPins_Release(pins);
154
155 This->num_streams = *pVal;
156 return S_OK;
157 }
158
159 static HRESULT WINAPI MediaDet_get_CurrentStream(IMediaDet* iface, LONG *pVal)
160 {
161 MediaDetImpl *This = (MediaDetImpl *)iface;
162 TRACE("(%p)\n", This);
163
164 if (!pVal)
165 return E_POINTER;
166
167 *pVal = This->cur_stream;
168 return S_OK;
169 }
170
171 static HRESULT SetCurPin(MediaDetImpl *This, long strm)
172 {
173 IEnumPins *pins;
174 IPin *pin;
175 HRESULT hr;
176
177 assert(This->splitter);
178 assert(0 <= strm && strm < This->num_streams);
179
180 if (This->cur_pin)
181 {
182 IPin_Release(This->cur_pin);
183 This->cur_pin = NULL;
184 }
185
186 hr = IBaseFilter_EnumPins(This->splitter, &pins);
187 if (FAILED(hr))
188 return hr;
189
190 while (IEnumPins_Next(pins, 1, &pin, NULL) == S_OK && !This->cur_pin)
191 {
192 PIN_DIRECTION dir;
193 hr = IPin_QueryDirection(pin, &dir);
194 if (FAILED(hr))
195 {
196 IPin_Release(pin);
197 IEnumPins_Release(pins);
198 return hr;
199 }
200
201 if (dir == PINDIR_OUTPUT && strm-- == 0)
202 This->cur_pin = pin;
203 else
204 IPin_Release(pin);
205 }
206 IEnumPins_Release(pins);
207
208 assert(This->cur_pin);
209 return S_OK;
210 }
211
212 static HRESULT WINAPI MediaDet_put_CurrentStream(IMediaDet* iface, LONG newVal)
213 {
214 MediaDetImpl *This = (MediaDetImpl *)iface;
215 HRESULT hr;
216
217 TRACE("(%p)->(%d)\n", This, newVal);
218
219 if (This->num_streams == -1)
220 {
221 LONG n;
222 hr = MediaDet_get_OutputStreams(iface, &n);
223 if (FAILED(hr))
224 return hr;
225 }
226
227 if (newVal < 0 || This->num_streams <= newVal)
228 return E_INVALIDARG;
229
230 hr = SetCurPin(This, newVal);
231 if (FAILED(hr))
232 return hr;
233
234 This->cur_stream = newVal;
235 return S_OK;
236 }
237
238 static HRESULT WINAPI MediaDet_get_StreamType(IMediaDet* iface, GUID *pVal)
239 {
240 MediaDetImpl *This = (MediaDetImpl *)iface;
241 FIXME("(%p)->(%p): not implemented!\n", This, debugstr_guid(pVal));
242 return E_NOTIMPL;
243 }
244
245 static HRESULT WINAPI MediaDet_get_StreamTypeB(IMediaDet* iface, BSTR *pVal)
246 {
247 MediaDetImpl *This = (MediaDetImpl *)iface;
248 FIXME("(%p)->(%p): not implemented!\n", This, pVal);
249 return E_NOTIMPL;
250 }
251
252 static HRESULT WINAPI MediaDet_get_StreamLength(IMediaDet* iface, double *pVal)
253 {
254 MediaDetImpl *This = (MediaDetImpl *)iface;
255 FIXME("(%p): stub!\n", This);
256 return VFW_E_INVALIDMEDIATYPE;
257 }
258
259 static HRESULT WINAPI MediaDet_get_Filename(IMediaDet* iface, BSTR *pVal)
260 {
261 MediaDetImpl *This = (MediaDetImpl *)iface;
262 IFileSourceFilter *file;
263 LPOLESTR name;
264 HRESULT hr;
265
266 TRACE("(%p)\n", This);
267
268 if (!pVal)
269 return E_POINTER;
270
271 *pVal = NULL;
272 /* MSDN says it should return E_FAIL if no file is open, but tests
273 show otherwise. */
274 if (!This->source)
275 return S_OK;
276
277 hr = IBaseFilter_QueryInterface(This->source, &IID_IFileSourceFilter,
278 (void **) &file);
279 if (FAILED(hr))
280 return hr;
281
282 hr = IFileSourceFilter_GetCurFile(file, &name, NULL);
283 IFileSourceFilter_Release(file);
284 if (FAILED(hr))
285 return hr;
286
287 *pVal = SysAllocString(name);
288 CoTaskMemFree(name);
289 if (!*pVal)
290 return E_OUTOFMEMORY;
291
292 return S_OK;
293 }
294
295 /* From quartz, 2008/04/07 */
296 static HRESULT GetFilterInfo(IMoniker *pMoniker, GUID *pclsid, VARIANT *pvar)
297 {
298 static const WCHAR wszClsidName[] = {'C','L','S','I','D',0};
299 static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
300 IPropertyBag *pPropBagCat = NULL;
301 HRESULT hr;
302
303 VariantInit(pvar);
304 V_VT(pvar) = VT_BSTR;
305
306 hr = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag,
307 (LPVOID *) &pPropBagCat);
308
309 if (SUCCEEDED(hr))
310 hr = IPropertyBag_Read(pPropBagCat, wszClsidName, pvar, NULL);
311
312 if (SUCCEEDED(hr))
313 {
314 hr = CLSIDFromString(V_UNION(pvar, bstrVal), pclsid);
315 VariantClear(pvar);
316 V_VT(pvar) = VT_BSTR;
317 }
318
319 if (SUCCEEDED(hr))
320 hr = IPropertyBag_Read(pPropBagCat, wszFriendlyName, pvar, NULL);
321
322 if (SUCCEEDED(hr))
323 TRACE("Moniker = %s - %s\n", debugstr_guid(pclsid),
324 debugstr_w(V_UNION(pvar, bstrVal)));
325
326 if (pPropBagCat)
327 IPropertyBag_Release(pPropBagCat);
328
329 return hr;
330 }
331
332 static HRESULT GetSplitter(MediaDetImpl *This)
333 {
334 IFileSourceFilter *file;
335 LPOLESTR name;
336 AM_MEDIA_TYPE mt;
337 GUID type[2];
338 IFilterMapper2 *map;
339 IEnumMoniker *filters;
340 IMoniker *mon;
341 VARIANT var;
342 GUID clsid;
343 IBaseFilter *splitter;
344 IEnumPins *pins;
345 IPin *source_pin, *splitter_pin;
346 HRESULT hr;
347
348 hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
349 &IID_IFilterMapper2, (void **) &map);
350 if (FAILED(hr))
351 return hr;
352
353 hr = IBaseFilter_QueryInterface(This->source, &IID_IFileSourceFilter,
354 (void **) &file);
355 if (FAILED(hr))
356 {
357 IFilterMapper2_Release(map);
358 return hr;
359 }
360
361 hr = IFileSourceFilter_GetCurFile(file, &name, &mt);
362 IFileSourceFilter_Release(file);
363 CoTaskMemFree(name);
364 if (FAILED(hr))
365 {
366 IFilterMapper2_Release(map);
367 return hr;
368 }
369 type[0] = mt.majortype;
370 type[1] = mt.subtype;
371 CoTaskMemFree(mt.pbFormat);
372
373 hr = IFilterMapper2_EnumMatchingFilters(map, &filters, 0, TRUE,
374 MERIT_UNLIKELY, FALSE, 1, type,
375 NULL, NULL, FALSE, TRUE,
376 0, NULL, NULL, NULL);
377 IFilterMapper2_Release(map);
378 if (FAILED(hr))
379 return hr;
380
381 hr = IEnumMoniker_Next(filters, 1, &mon, NULL);
382 IEnumMoniker_Release(filters);
383 if (hr != S_OK) /* No matches, what do we do? */
384 return E_NOINTERFACE;
385
386 hr = GetFilterInfo(mon, &clsid, &var);
387 IMoniker_Release(mon);
388 if (FAILED(hr))
389 return hr;
390
391 hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER,
392 &IID_IBaseFilter, (void **) &splitter);
393 if (FAILED(hr))
394 {
395 VariantClear(&var);
396 return hr;
397 }
398
399 hr = IGraphBuilder_AddFilter(This->graph, splitter,
400 V_UNION(&var, bstrVal));
401 VariantClear(&var);
402 if (FAILED(hr))
403 {
404 IBaseFilter_Release(splitter);
405 return hr;
406 }
407 This->splitter = splitter;
408
409 hr = IBaseFilter_EnumPins(This->source, &pins);
410 if (FAILED(hr))
411 return hr;
412 IEnumPins_Next(pins, 1, &source_pin, NULL);
413 IEnumPins_Release(pins);
414
415 hr = IBaseFilter_EnumPins(splitter, &pins);
416 if (FAILED(hr))
417 {
418 IPin_Release(source_pin);
419 return hr;
420 }
421 IEnumPins_Next(pins, 1, &splitter_pin, NULL);
422 IEnumPins_Release(pins);
423
424 hr = IPin_Connect(source_pin, splitter_pin, NULL);
425 IPin_Release(source_pin);
426 IPin_Release(splitter_pin);
427 if (FAILED(hr))
428 return hr;
429
430 return S_OK;
431 }
432
433 static HRESULT WINAPI MediaDet_put_Filename(IMediaDet* iface, BSTR newVal)
434 {
435 static const WCHAR reader[] = {'R','e','a','d','e','r',0};
436 MediaDetImpl *This = (MediaDetImpl *)iface;
437 IGraphBuilder *gb;
438 IBaseFilter *bf;
439 HRESULT hr;
440
441 TRACE("(%p)->(%s)\n", This, debugstr_w(newVal));
442
443 if (This->graph)
444 {
445 WARN("MSDN says not to call this method twice\n");
446 MD_cleanup(This);
447 }
448
449 hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
450 &IID_IGraphBuilder, (void **) &gb);
451 if (FAILED(hr))
452 return hr;
453
454 hr = IGraphBuilder_AddSourceFilter(gb, newVal, reader, &bf);
455 if (FAILED(hr))
456 {
457 IGraphBuilder_Release(gb);
458 return hr;
459 }
460
461 This->graph = gb;
462 This->source = bf;
463 hr = GetSplitter(This);
464 if (FAILED(hr))
465 return hr;
466
467 return MediaDet_put_CurrentStream(iface, 0);
468 }
469
470 static HRESULT WINAPI MediaDet_GetBitmapBits(IMediaDet* iface,
471 double StreamTime,
472 LONG *pBufferSize, char *pBuffer,
473 LONG Width, LONG Height)
474 {
475 MediaDetImpl *This = (MediaDetImpl *)iface;
476 FIXME("(%p)->(%f %p %p %d %d): not implemented!\n", This, StreamTime, pBufferSize, pBuffer,
477 Width, Height);
478 return E_NOTIMPL;
479 }
480
481 static HRESULT WINAPI MediaDet_WriteBitmapBits(IMediaDet* iface,
482 double StreamTime, LONG Width,
483 LONG Height, BSTR Filename)
484 {
485 MediaDetImpl *This = (MediaDetImpl *)iface;
486 FIXME("(%p)->(%f %d %d %p): not implemented!\n", This, StreamTime, Width, Height, Filename);
487 return E_NOTIMPL;
488 }
489
490 static HRESULT WINAPI MediaDet_get_StreamMediaType(IMediaDet* iface,
491 AM_MEDIA_TYPE *pVal)
492 {
493 MediaDetImpl *This = (MediaDetImpl *)iface;
494 IEnumMediaTypes *types;
495 AM_MEDIA_TYPE *pmt;
496 HRESULT hr;
497
498 TRACE("(%p)\n", This);
499
500 if (!pVal)
501 return E_POINTER;
502
503 if (!This->cur_pin)
504 return E_INVALIDARG;
505
506 hr = IPin_EnumMediaTypes(This->cur_pin, &types);
507 if (SUCCEEDED(hr))
508 {
509 hr = (IEnumMediaTypes_Next(types, 1, &pmt, NULL) == S_OK
510 ? S_OK
511 : E_NOINTERFACE);
512 IEnumMediaTypes_Release(types);
513 }
514
515 if (SUCCEEDED(hr))
516 {
517 *pVal = *pmt;
518 CoTaskMemFree(pmt);
519 }
520
521 return hr;
522 }
523
524 static HRESULT WINAPI MediaDet_GetSampleGrabber(IMediaDet* iface,
525 ISampleGrabber **ppVal)
526 {
527 MediaDetImpl *This = (MediaDetImpl *)iface;
528 FIXME("(%p)->(%p): not implemented!\n", This, ppVal);
529 return E_NOTIMPL;
530 }
531
532 static HRESULT WINAPI MediaDet_get_FrameRate(IMediaDet* iface, double *pVal)
533 {
534 MediaDetImpl *This = (MediaDetImpl *)iface;
535 AM_MEDIA_TYPE mt;
536 VIDEOINFOHEADER *vh;
537 HRESULT hr;
538
539 TRACE("(%p)\n", This);
540
541 if (!pVal)
542 return E_POINTER;
543
544 hr = MediaDet_get_StreamMediaType(iface, &mt);
545 if (FAILED(hr))
546 return hr;
547
548 if (!IsEqualGUID(&mt.majortype, &MEDIATYPE_Video))
549 {
550 CoTaskMemFree(mt.pbFormat);
551 return VFW_E_INVALIDMEDIATYPE;
552 }
553
554 vh = (VIDEOINFOHEADER *) mt.pbFormat;
555 *pVal = 1.0e7 / (double) vh->AvgTimePerFrame;
556
557 CoTaskMemFree(mt.pbFormat);
558 return S_OK;
559 }
560
561 static HRESULT WINAPI MediaDet_EnterBitmapGrabMode(IMediaDet* iface,
562 double SeekTime)
563 {
564 MediaDetImpl *This = (MediaDetImpl *)iface;
565 FIXME("(%p)->(%f): not implemented!\n", This, SeekTime);
566 return E_NOTIMPL;
567 }
568
569 static const IMediaDetVtbl IMediaDet_VTable =
570 {
571 MediaDet_QueryInterface,
572 MediaDet_AddRef,
573 MediaDet_Release,
574 MediaDet_get_Filter,
575 MediaDet_put_Filter,
576 MediaDet_get_OutputStreams,
577 MediaDet_get_CurrentStream,
578 MediaDet_put_CurrentStream,
579 MediaDet_get_StreamType,
580 MediaDet_get_StreamTypeB,
581 MediaDet_get_StreamLength,
582 MediaDet_get_Filename,
583 MediaDet_put_Filename,
584 MediaDet_GetBitmapBits,
585 MediaDet_WriteBitmapBits,
586 MediaDet_get_StreamMediaType,
587 MediaDet_GetSampleGrabber,
588 MediaDet_get_FrameRate,
589 MediaDet_EnterBitmapGrabMode,
590 };
591
592 HRESULT MediaDet_create(IUnknown * pUnkOuter, LPVOID * ppv) {
593 MediaDetImpl* obj = NULL;
594
595 TRACE("(%p,%p)\n", ppv, pUnkOuter);
596
597 if (pUnkOuter)
598 return CLASS_E_NOAGGREGATION;
599
600 obj = CoTaskMemAlloc(sizeof(MediaDetImpl));
601 if (NULL == obj) {
602 *ppv = NULL;
603 return E_OUTOFMEMORY;
604 }
605 ZeroMemory(obj, sizeof(MediaDetImpl));
606
607 obj->refCount = 1;
608 obj->MediaDet_Vtbl = &IMediaDet_VTable;
609 obj->graph = NULL;
610 obj->source = NULL;
611 obj->splitter = NULL;
612 obj->cur_pin = NULL;
613 obj->num_streams = -1;
614 obj->cur_stream = 0;
615 *ppv = obj;
616
617 return S_OK;
618 }