/* DirectShow Media Detector object (QEDIT.DLL) * * Copyright 2008 Google (Lei Zhang, Dan Hipschman) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include <assert.h> #include <stdarg.h> #define COBJMACROS #include "windef.h" #include "winbase.h" #include "winuser.h" #include "ole2.h" #include "qedit_private.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(qedit); typedef struct MediaDetImpl { IUnknown IUnknown_inner; IMediaDet IMediaDet_iface; IUnknown *outer_unk; LONG ref; IGraphBuilder *graph; IBaseFilter *source; IBaseFilter *splitter; LONG num_streams; LONG cur_stream; IPin *cur_pin; } MediaDetImpl; static inline MediaDetImpl *impl_from_IUnknown(IUnknown *iface) { return CONTAINING_RECORD(iface, MediaDetImpl, IUnknown_inner); } static inline MediaDetImpl *impl_from_IMediaDet(IMediaDet *iface) { return CONTAINING_RECORD(iface, MediaDetImpl, IMediaDet_iface); } static void MD_cleanup(MediaDetImpl *This) { if (This->cur_pin) IPin_Release(This->cur_pin); This->cur_pin = NULL; if (This->source) IBaseFilter_Release(This->source); This->source = NULL; if (This->splitter) IBaseFilter_Release(This->splitter); This->splitter = NULL; if (This->graph) IGraphBuilder_Release(This->graph); This->graph = NULL; This->num_streams = -1; This->cur_stream = 0; } /* MediaDet inner IUnknown */ static HRESULT WINAPI MediaDet_inner_QueryInterface(IUnknown *iface, REFIID riid, void **ppv) { MediaDetImpl *This = impl_from_IUnknown(iface); TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv); *ppv = NULL; if (IsEqualIID(riid, &IID_IUnknown)) *ppv = &This->IUnknown_inner; else if (IsEqualIID(riid, &IID_IMediaDet)) *ppv = &This->IMediaDet_iface; else WARN("(%p, %s,%p): not found\n", This, debugstr_guid(riid), ppv); if (!*ppv) return E_NOINTERFACE; IUnknown_AddRef((IUnknown*)*ppv); return S_OK; } static ULONG WINAPI MediaDet_inner_AddRef(IUnknown *iface) { MediaDetImpl *This = impl_from_IUnknown(iface); ULONG ref = InterlockedIncrement(&This->ref); TRACE("(%p) new ref = %u\n", This, ref); return ref; } static ULONG WINAPI MediaDet_inner_Release(IUnknown *iface) { MediaDetImpl *This = impl_from_IUnknown(iface); ULONG ref = InterlockedDecrement(&This->ref); TRACE("(%p) new ref = %u\n", This, ref); if (ref == 0) { MD_cleanup(This); CoTaskMemFree(This); return 0; } return ref; } static const IUnknownVtbl mediadet_vtbl = { MediaDet_inner_QueryInterface, MediaDet_inner_AddRef, MediaDet_inner_Release, }; /* IMediaDet implementation */ static HRESULT WINAPI MediaDet_QueryInterface(IMediaDet *iface, REFIID riid, void **ppv) { MediaDetImpl *This = impl_from_IMediaDet(iface); return IUnknown_QueryInterface(This->outer_unk, riid, ppv); } static ULONG WINAPI MediaDet_AddRef(IMediaDet *iface) { MediaDetImpl *This = impl_from_IMediaDet(iface); return IUnknown_AddRef(This->outer_unk); } static ULONG WINAPI MediaDet_Release(IMediaDet *iface) { MediaDetImpl *This = impl_from_IMediaDet(iface); return IUnknown_Release(This->outer_unk); } static HRESULT WINAPI MediaDet_get_Filter(IMediaDet* iface, IUnknown **pVal) { MediaDetImpl *This = impl_from_IMediaDet(iface); FIXME("(%p)->(%p): not implemented!\n", This, pVal); return E_NOTIMPL; } static HRESULT WINAPI MediaDet_put_Filter(IMediaDet* iface, IUnknown *newVal) { MediaDetImpl *This = impl_from_IMediaDet(iface); FIXME("(%p)->(%p): not implemented!\n", This, newVal); return E_NOTIMPL; } static HRESULT WINAPI MediaDet_get_OutputStreams(IMediaDet* iface, LONG *pVal) { MediaDetImpl *This = impl_from_IMediaDet(iface); IEnumPins *pins; IPin *pin; HRESULT hr; TRACE("(%p)\n", This); if (!This->splitter) return E_INVALIDARG; if (This->num_streams != -1) { *pVal = This->num_streams; return S_OK; } *pVal = 0; hr = IBaseFilter_EnumPins(This->splitter, &pins); if (FAILED(hr)) return hr; while (IEnumPins_Next(pins, 1, &pin, NULL) == S_OK) { PIN_DIRECTION dir; hr = IPin_QueryDirection(pin, &dir); IPin_Release(pin); if (FAILED(hr)) { IEnumPins_Release(pins); return hr; } if (dir == PINDIR_OUTPUT) ++*pVal; } IEnumPins_Release(pins); This->num_streams = *pVal; return S_OK; } static HRESULT WINAPI MediaDet_get_CurrentStream(IMediaDet* iface, LONG *pVal) { MediaDetImpl *This = impl_from_IMediaDet(iface); TRACE("(%p)\n", This); if (!pVal) return E_POINTER; *pVal = This->cur_stream; return S_OK; } static HRESULT SetCurPin(MediaDetImpl *This, LONG strm) { IEnumPins *pins; IPin *pin; HRESULT hr; assert(This->splitter); assert(0 <= strm && strm < This->num_streams); if (This->cur_pin) { IPin_Release(This->cur_pin); This->cur_pin = NULL; } hr = IBaseFilter_EnumPins(This->splitter, &pins); if (FAILED(hr)) return hr; while (IEnumPins_Next(pins, 1, &pin, NULL) == S_OK && !This->cur_pin) { PIN_DIRECTION dir; hr = IPin_QueryDirection(pin, &dir); if (FAILED(hr)) { IPin_Release(pin); IEnumPins_Release(pins); return hr; } if (dir == PINDIR_OUTPUT && strm-- == 0) This->cur_pin = pin; else IPin_Release(pin); } IEnumPins_Release(pins); assert(This->cur_pin); return S_OK; } static HRESULT WINAPI MediaDet_put_CurrentStream(IMediaDet* iface, LONG newVal) { MediaDetImpl *This = impl_from_IMediaDet(iface); HRESULT hr; TRACE("(%p)->(%d)\n", This, newVal); if (This->num_streams == -1) { LONG n; hr = MediaDet_get_OutputStreams(iface, &n); if (FAILED(hr)) return hr; } if (newVal < 0 || This->num_streams <= newVal) return E_INVALIDARG; hr = SetCurPin(This, newVal); if (FAILED(hr)) return hr; This->cur_stream = newVal; return S_OK; } static HRESULT WINAPI MediaDet_get_StreamType(IMediaDet* iface, GUID *pVal) { MediaDetImpl *This = impl_from_IMediaDet(iface); FIXME("(%p)->(%s): not implemented!\n", This, debugstr_guid(pVal)); return E_NOTIMPL; } static HRESULT WINAPI MediaDet_get_StreamTypeB(IMediaDet* iface, BSTR *pVal) { MediaDetImpl *This = impl_from_IMediaDet(iface); FIXME("(%p)->(%p): not implemented!\n", This, pVal); return E_NOTIMPL; } static HRESULT WINAPI MediaDet_get_StreamLength(IMediaDet* iface, double *pVal) { MediaDetImpl *This = impl_from_IMediaDet(iface); FIXME("(%p): stub!\n", This); return VFW_E_INVALIDMEDIATYPE; } static HRESULT WINAPI MediaDet_get_Filename(IMediaDet* iface, BSTR *pVal) { MediaDetImpl *This = impl_from_IMediaDet(iface); IFileSourceFilter *file; LPOLESTR name; HRESULT hr; TRACE("(%p)\n", This); if (!pVal) return E_POINTER; *pVal = NULL; /* MSDN says it should return E_FAIL if no file is open, but tests show otherwise. */ if (!This->source) return S_OK; hr = IBaseFilter_QueryInterface(This->source, &IID_IFileSourceFilter, (void **) &file); if (FAILED(hr)) return hr; hr = IFileSourceFilter_GetCurFile(file, &name, NULL); IFileSourceFilter_Release(file); if (FAILED(hr)) return hr; *pVal = SysAllocString(name); CoTaskMemFree(name); if (!*pVal) return E_OUTOFMEMORY; return S_OK; } /* From quartz, 2008/04/07 */ static HRESULT GetFilterInfo(IMoniker *pMoniker, GUID *pclsid, VARIANT *pvar) { static const WCHAR wszClsidName[] = {'C','L','S','I','D',0}; static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0}; IPropertyBag *pPropBagCat = NULL; HRESULT hr; VariantInit(pvar); V_VT(pvar) = VT_BSTR; hr = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (LPVOID *) &pPropBagCat); if (SUCCEEDED(hr)) hr = IPropertyBag_Read(pPropBagCat, wszClsidName, pvar, NULL); if (SUCCEEDED(hr)) { hr = CLSIDFromString(V_BSTR(pvar), pclsid); VariantClear(pvar); V_VT(pvar) = VT_BSTR; } if (SUCCEEDED(hr)) hr = IPropertyBag_Read(pPropBagCat, wszFriendlyName, pvar, NULL); if (SUCCEEDED(hr)) TRACE("Moniker = %s - %s\n", debugstr_guid(pclsid), debugstr_w(V_BSTR(pvar))); if (pPropBagCat) IPropertyBag_Release(pPropBagCat); return hr; } static HRESULT GetSplitter(MediaDetImpl *This) { IFileSourceFilter *file; LPOLESTR name; AM_MEDIA_TYPE mt; GUID type[2]; IFilterMapper2 *map; IEnumMoniker *filters; IMoniker *mon; VARIANT var; GUID clsid; IBaseFilter *splitter; IEnumPins *pins; IPin *source_pin, *splitter_pin; HRESULT hr; hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER, &IID_IFilterMapper2, (void **) &map); if (FAILED(hr)) return hr; hr = IBaseFilter_QueryInterface(This->source, &IID_IFileSourceFilter, (void **) &file); if (FAILED(hr)) { IFilterMapper2_Release(map); return hr; } hr = IFileSourceFilter_GetCurFile(file, &name, &mt); IFileSourceFilter_Release(file); CoTaskMemFree(name); if (FAILED(hr)) { IFilterMapper2_Release(map); return hr; } type[0] = mt.majortype; type[1] = mt.subtype; CoTaskMemFree(mt.pbFormat); hr = IFilterMapper2_EnumMatchingFilters(map, &filters, 0, TRUE, MERIT_UNLIKELY, FALSE, 1, type, NULL, NULL, FALSE, TRUE, 0, NULL, NULL, NULL); IFilterMapper2_Release(map); if (FAILED(hr)) return hr; hr = E_NOINTERFACE; while (IEnumMoniker_Next(filters, 1, &mon, NULL) == S_OK) { hr = GetFilterInfo(mon, &clsid, &var); IMoniker_Release(mon); if (FAILED(hr)) continue; hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (void **) &splitter); if (FAILED(hr)) { VariantClear(&var); continue; } hr = IGraphBuilder_AddFilter(This->graph, splitter, V_BSTR(&var)); VariantClear(&var); This->splitter = splitter; if (FAILED(hr)) goto retry; hr = IBaseFilter_EnumPins(This->source, &pins); if (FAILED(hr)) goto retry; IEnumPins_Next(pins, 1, &source_pin, NULL); IEnumPins_Release(pins); hr = IBaseFilter_EnumPins(splitter, &pins); if (FAILED(hr)) { IPin_Release(source_pin); goto retry; } IEnumPins_Next(pins, 1, &splitter_pin, NULL); IEnumPins_Release(pins); hr = IPin_Connect(source_pin, splitter_pin, NULL); IPin_Release(source_pin); IPin_Release(splitter_pin); if (SUCCEEDED(hr)) break; retry: IBaseFilter_Release(splitter); This->splitter = NULL; } IEnumMoniker_Release(filters); if (FAILED(hr)) return hr; return S_OK; } static HRESULT WINAPI MediaDet_put_Filename(IMediaDet* iface, BSTR newVal) { static const WCHAR reader[] = {'R','e','a','d','e','r',0}; MediaDetImpl *This = impl_from_IMediaDet(iface); IGraphBuilder *gb; IBaseFilter *bf; HRESULT hr; TRACE("(%p)->(%s)\n", This, debugstr_w(newVal)); if (This->graph) { WARN("MSDN says not to call this method twice\n"); MD_cleanup(This); } hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, &IID_IGraphBuilder, (void **) &gb); if (FAILED(hr)) return hr; hr = IGraphBuilder_AddSourceFilter(gb, newVal, reader, &bf); if (FAILED(hr)) { IGraphBuilder_Release(gb); return hr; } This->graph = gb; This->source = bf; hr = GetSplitter(This); if (FAILED(hr)) return hr; return MediaDet_put_CurrentStream(iface, 0); } static HRESULT WINAPI MediaDet_GetBitmapBits(IMediaDet* iface, double StreamTime, LONG *pBufferSize, char *pBuffer, LONG Width, LONG Height) { MediaDetImpl *This = impl_from_IMediaDet(iface); FIXME("(%p)->(%f %p %p %d %d): not implemented!\n", This, StreamTime, pBufferSize, pBuffer, Width, Height); return E_NOTIMPL; } static HRESULT WINAPI MediaDet_WriteBitmapBits(IMediaDet* iface, double StreamTime, LONG Width, LONG Height, BSTR Filename) { MediaDetImpl *This = impl_from_IMediaDet(iface); FIXME("(%p)->(%f %d %d %p): not implemented!\n", This, StreamTime, Width, Height, Filename); return E_NOTIMPL; } static HRESULT WINAPI MediaDet_get_StreamMediaType(IMediaDet* iface, AM_MEDIA_TYPE *pVal) { MediaDetImpl *This = impl_from_IMediaDet(iface); IEnumMediaTypes *types; AM_MEDIA_TYPE *pmt; HRESULT hr; TRACE("(%p)\n", This); if (!pVal) return E_POINTER; if (!This->cur_pin) return E_INVALIDARG; hr = IPin_EnumMediaTypes(This->cur_pin, &types); if (SUCCEEDED(hr)) { hr = (IEnumMediaTypes_Next(types, 1, &pmt, NULL) == S_OK ? S_OK : E_NOINTERFACE); IEnumMediaTypes_Release(types); } if (SUCCEEDED(hr)) { *pVal = *pmt; CoTaskMemFree(pmt); } return hr; } static HRESULT WINAPI MediaDet_GetSampleGrabber(IMediaDet* iface, ISampleGrabber **ppVal) { MediaDetImpl *This = impl_from_IMediaDet(iface); FIXME("(%p)->(%p): not implemented!\n", This, ppVal); return E_NOTIMPL; } static HRESULT WINAPI MediaDet_get_FrameRate(IMediaDet* iface, double *pVal) { MediaDetImpl *This = impl_from_IMediaDet(iface); AM_MEDIA_TYPE mt; VIDEOINFOHEADER *vh; HRESULT hr; TRACE("(%p)\n", This); if (!pVal) return E_POINTER; hr = MediaDet_get_StreamMediaType(iface, &mt); if (FAILED(hr)) return hr; if (!IsEqualGUID(&mt.majortype, &MEDIATYPE_Video)) { CoTaskMemFree(mt.pbFormat); return VFW_E_INVALIDMEDIATYPE; } vh = (VIDEOINFOHEADER *) mt.pbFormat; *pVal = 1.0e7 / (double) vh->AvgTimePerFrame; CoTaskMemFree(mt.pbFormat); return S_OK; } static HRESULT WINAPI MediaDet_EnterBitmapGrabMode(IMediaDet* iface, double SeekTime) { MediaDetImpl *This = impl_from_IMediaDet(iface); FIXME("(%p)->(%f): not implemented!\n", This, SeekTime); return E_NOTIMPL; } static const IMediaDetVtbl IMediaDet_VTable = { MediaDet_QueryInterface, MediaDet_AddRef, MediaDet_Release, MediaDet_get_Filter, MediaDet_put_Filter, MediaDet_get_OutputStreams, MediaDet_get_CurrentStream, MediaDet_put_CurrentStream, MediaDet_get_StreamType, MediaDet_get_StreamTypeB, MediaDet_get_StreamLength, MediaDet_get_Filename, MediaDet_put_Filename, MediaDet_GetBitmapBits, MediaDet_WriteBitmapBits, MediaDet_get_StreamMediaType, MediaDet_GetSampleGrabber, MediaDet_get_FrameRate, MediaDet_EnterBitmapGrabMode, }; HRESULT MediaDet_create(IUnknown * pUnkOuter, LPVOID * ppv) { MediaDetImpl* obj = NULL; TRACE("(%p,%p)\n", ppv, pUnkOuter); obj = CoTaskMemAlloc(sizeof(MediaDetImpl)); if (NULL == obj) { *ppv = NULL; return E_OUTOFMEMORY; } ZeroMemory(obj, sizeof(MediaDetImpl)); obj->ref = 1; obj->IUnknown_inner.lpVtbl = &mediadet_vtbl; obj->IMediaDet_iface.lpVtbl = &IMediaDet_VTable; obj->graph = NULL; obj->source = NULL; obj->splitter = NULL; obj->cur_pin = NULL; obj->num_streams = -1; obj->cur_stream = 0; if (pUnkOuter) obj->outer_unk = pUnkOuter; else obj->outer_unk = &obj->IUnknown_inner; *ppv = &obj->IUnknown_inner; return S_OK; }