| /* Capture Graph Builder, Minimal edition | |
| * | |
| * Copyright 2005 Maarten Lankhorst | |
| * Copyright 2005 Rolf Kalbermatter | |
| * | |
| * 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 "config.h" | |
| #include <stdio.h> | |
| #include <stdarg.h> | |
| #define COBJMACROS | |
| #define NONAMELESSSTRUCT | |
| #define NONAMELESSUNION | |
| #include "windef.h" | |
| #include "winbase.h" | |
| #include "wingdi.h" | |
| #include "winerror.h" | |
| #include "objbase.h" | |
| #include "evcode.h" | |
| #include "strmif.h" | |
| #include "control.h" | |
| #include "vfwmsgs.h" | |
| /* | |
| *#include "amvideo.h" | |
| *#include "mmreg.h" | |
| *#include "dshow.h" | |
| *#include "ddraw.h" | |
| */ | |
| #include "qcap_main.h" | |
| #include "wine/unicode.h" | |
| #include "wine/debug.h" | |
| WINE_DEFAULT_DEBUG_CHANNEL(qcap); | |
| /*********************************************************************** | |
| * ICaptureGraphBuilder & ICaptureGraphBuilder2 implementation | |
| */ | |
| typedef struct CaptureGraphImpl | |
| { | |
| const ICaptureGraphBuilder2Vtbl * lpVtbl2; | |
| const ICaptureGraphBuilderVtbl * lpVtbl; | |
| LONG ref; | |
| IGraphBuilder *mygraph; | |
| CRITICAL_SECTION csFilter; | |
| } CaptureGraphImpl; | |
| static const ICaptureGraphBuilderVtbl builder_Vtbl; | |
| static const ICaptureGraphBuilder2Vtbl builder2_Vtbl; | |
| static inline CaptureGraphImpl *impl_from_ICaptureGraphBuilder( ICaptureGraphBuilder *iface ) | |
| { | |
| return (CaptureGraphImpl *)((char*)iface - FIELD_OFFSET(CaptureGraphImpl, lpVtbl)); | |
| } | |
| static inline CaptureGraphImpl *impl_from_ICaptureGraphBuilder2( ICaptureGraphBuilder2 *iface ) | |
| { | |
| return (CaptureGraphImpl *)((char*)iface - FIELD_OFFSET(CaptureGraphImpl, lpVtbl2)); | |
| } | |
| /* | |
| converts This to an interface pointer | |
| */ | |
| #define _IUnknown_(This) (&(This)->lpVtbl2) | |
| #define _ICaptureGraphBuilder_(This) (&(This)->lpVtbl) | |
| #define _ICaptureGraphBuilder2_(This) ((ICaptureGraphBuilder2*)&(This)->lpVtbl2) | |
| IUnknown * CALLBACK QCAP_createCaptureGraphBuilder2(IUnknown *pUnkOuter, | |
| HRESULT *phr) | |
| { | |
| CaptureGraphImpl * pCapture = NULL; | |
| TRACE("(%p, %p)\n", pUnkOuter, phr); | |
| *phr = CLASS_E_NOAGGREGATION; | |
| if (pUnkOuter) | |
| { | |
| return NULL; | |
| } | |
| *phr = E_OUTOFMEMORY; | |
| pCapture = CoTaskMemAlloc(sizeof(CaptureGraphImpl)); | |
| if (pCapture) | |
| { | |
| pCapture->lpVtbl2 = &builder2_Vtbl; | |
| pCapture->lpVtbl = &builder_Vtbl; | |
| pCapture->ref = 1; | |
| pCapture->mygraph = NULL; | |
| InitializeCriticalSection(&pCapture->csFilter); | |
| pCapture->csFilter.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": CaptureGraphImpl.csFilter"); | |
| *phr = S_OK; | |
| ObjectRefCount(TRUE); | |
| } | |
| return (IUnknown *)pCapture; | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder2_QueryInterface(ICaptureGraphBuilder2 * iface, | |
| REFIID riid, | |
| LPVOID * ppv) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface); | |
| TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppv); | |
| *ppv = NULL; | |
| if (IsEqualIID(riid, &IID_IUnknown)) | |
| *ppv = _IUnknown_(This); | |
| else if (IsEqualIID(riid, &IID_ICaptureGraphBuilder)) | |
| *ppv = _ICaptureGraphBuilder_(This); | |
| else if (IsEqualIID(riid, &IID_ICaptureGraphBuilder2)) | |
| *ppv = _ICaptureGraphBuilder2_(This); | |
| if (*ppv) | |
| { | |
| IUnknown_AddRef((IUnknown *)(*ppv)); | |
| TRACE ("-- Interface = %p\n", *ppv); | |
| return S_OK; | |
| } | |
| TRACE ("-- Interface: E_NOINTERFACE\n"); | |
| return E_NOINTERFACE; | |
| } | |
| static ULONG WINAPI | |
| fnCaptureGraphBuilder2_AddRef(ICaptureGraphBuilder2 * iface) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface); | |
| DWORD ref = InterlockedIncrement(&This->ref); | |
| TRACE("(%p/%p)->() AddRef from %d\n", This, iface, ref - 1); | |
| return ref; | |
| } | |
| static ULONG WINAPI | |
| fnCaptureGraphBuilder2_Release(ICaptureGraphBuilder2 * iface) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface); | |
| DWORD ref = InterlockedDecrement(&This->ref); | |
| TRACE("(%p/%p)->() Release from %d\n", This, iface, ref + 1); | |
| if (!ref) | |
| { | |
| FIXME("Release IGraphFilter or w/e\n"); | |
| This->csFilter.DebugInfo->Spare[0] = 0; | |
| DeleteCriticalSection(&This->csFilter); | |
| This->lpVtbl = NULL; | |
| This->lpVtbl2 = NULL; | |
| if (This->mygraph != NULL) | |
| IGraphBuilder_Release(This->mygraph); | |
| CoTaskMemFree(This); | |
| ObjectRefCount(FALSE); | |
| } | |
| return ref; | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder2_SetFilterGraph(ICaptureGraphBuilder2 * iface, | |
| IGraphBuilder *pfg) | |
| { | |
| /* The graph builder will automatically create a filter graph if you don't call | |
| this method. If you call this method after the graph builder has created its | |
| own filter graph, the call will fail. */ | |
| IMediaEvent *pmev; | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface); | |
| TRACE("(%p/%p)->(%p)\n", This, iface, pfg); | |
| if (This->mygraph) | |
| return E_UNEXPECTED; | |
| if (!pfg) | |
| return E_POINTER; | |
| This->mygraph = pfg; | |
| IGraphBuilder_AddRef(This->mygraph); | |
| if (SUCCEEDED(IUnknown_QueryInterface(This->mygraph, | |
| &IID_IMediaEvent, (LPVOID *)&pmev))) | |
| { | |
| IMediaEvent_CancelDefaultHandling(pmev, EC_REPAINT); | |
| IMediaEvent_Release(pmev); | |
| } | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder2_GetFilterGraph(ICaptureGraphBuilder2 * iface, | |
| IGraphBuilder **pfg) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface); | |
| TRACE("(%p/%p)->(%p)\n", This, iface, pfg); | |
| if (!pfg) | |
| return E_POINTER; | |
| *pfg = This->mygraph; | |
| if (!This->mygraph) | |
| { | |
| TRACE("(%p) Getting NULL filtergraph\n", iface); | |
| return E_UNEXPECTED; | |
| } | |
| IGraphBuilder_AddRef(This->mygraph); | |
| TRACE("(%p) return filtergraph %p\n", iface, *pfg); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder2_SetOutputFileName(ICaptureGraphBuilder2 * iface, | |
| const GUID *pType, | |
| LPCOLESTR lpstrFile, | |
| IBaseFilter **ppf, | |
| IFileSinkFilter **ppSink) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface); | |
| FIXME("(%p/%p)->(%s, %s, %p, %p) Stub!\n", This, iface, | |
| debugstr_guid(pType), debugstr_w(lpstrFile), ppf, ppSink); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder2_FindInterface(ICaptureGraphBuilder2 * iface, | |
| const GUID *pCategory, | |
| const GUID *pType, | |
| IBaseFilter *pf, | |
| REFIID riid, | |
| void **ppint) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface); | |
| FIXME("(%p/%p)->(%s, %s, %p, %s, %p) - workaround stub!\n", This, iface, | |
| debugstr_guid(pCategory), debugstr_guid(pType), | |
| pf, debugstr_guid(riid), ppint); | |
| return IBaseFilter_QueryInterface(pf, riid, ppint); | |
| /* Looks for the specified interface on the filter, upstream and | |
| * downstream from the filter, and, optionally, only on the output | |
| * pin of the given category. | |
| */ | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder2_RenderStream(ICaptureGraphBuilder2 * iface, | |
| const GUID *pCategory, | |
| const GUID *pType, | |
| IUnknown *pSource, | |
| IBaseFilter *pfCompressor, | |
| IBaseFilter *pfRenderer) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface); | |
| IPin *pin_in = NULL; | |
| IPin *pin_out = NULL; | |
| HRESULT hr; | |
| FIXME("(%p/%p)->(%s, %s, %p, %p, %p) Stub!\n", This, iface, | |
| debugstr_guid(pCategory), debugstr_guid(pType), | |
| pSource, pfCompressor, pfRenderer); | |
| if (pfCompressor) | |
| FIXME("Intermediate streams not supported yet\n"); | |
| if (!This->mygraph) | |
| { | |
| FIXME("Need a capture graph\n"); | |
| return E_UNEXPECTED; | |
| } | |
| ICaptureGraphBuilder2_FindPin(iface, pSource, PINDIR_OUTPUT, pCategory, pType, TRUE, 0, &pin_in); | |
| if (!pin_in) | |
| return E_FAIL; | |
| ICaptureGraphBuilder2_FindPin(iface, (IUnknown*)pfRenderer, PINDIR_INPUT, pCategory, pType, TRUE, 0, &pin_out); | |
| if (!pin_out) | |
| { | |
| IPin_Release(pin_in); | |
| return E_FAIL; | |
| } | |
| /* Uses 'Intelligent Connect', so Connect, not ConnectDirect here */ | |
| hr = IFilterGraph2_Connect(This->mygraph, pin_in, pin_out); | |
| IPin_Release(pin_in); | |
| IPin_Release(pin_out); | |
| return hr; | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder2_ControlStream(ICaptureGraphBuilder2 * iface, | |
| const GUID *pCategory, | |
| const GUID *pType, | |
| IBaseFilter *pFilter, | |
| REFERENCE_TIME *pstart, | |
| REFERENCE_TIME *pstop, | |
| WORD wStartCookie, | |
| WORD wStopCookie) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface); | |
| FIXME("(%p/%p)->(%s, %s, %p, %p, %p, %i, %i) Stub!\n", This, iface, | |
| debugstr_guid(pCategory), debugstr_guid(pType), | |
| pFilter, pstart, pstop, wStartCookie, wStopCookie); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder2_AllocCapFile(ICaptureGraphBuilder2 * iface, | |
| LPCOLESTR lpwstr, | |
| DWORDLONG dwlSize) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface); | |
| FIXME("(%p/%p)->(%s, 0x%s) Stub!\n", This, iface, | |
| debugstr_w(lpwstr), wine_dbgstr_longlong(dwlSize)); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder2_CopyCaptureFile(ICaptureGraphBuilder2 * iface, | |
| LPOLESTR lpwstrOld, | |
| LPOLESTR lpwstrNew, | |
| int fAllowEscAbort, | |
| IAMCopyCaptureFileProgress *pCallback) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface); | |
| FIXME("(%p/%p)->(%s, %s, %i, %p) Stub!\n", This, iface, | |
| debugstr_w(lpwstrOld), debugstr_w(lpwstrNew), | |
| fAllowEscAbort, pCallback); | |
| return E_NOTIMPL; | |
| } | |
| static BOOL pin_matches(IPin *pin, PIN_DIRECTION direction, const GUID *cat, const GUID *type, BOOL unconnected) | |
| { | |
| IPin *partner; | |
| PIN_DIRECTION pindir; | |
| IPin_QueryDirection(pin, &pindir); | |
| if (pindir != direction) | |
| { | |
| TRACE("No match, wrong direction\n"); | |
| return FALSE; | |
| } | |
| if (unconnected && IPin_ConnectedTo(pin, &partner) == S_OK) | |
| { | |
| IPin_Release(partner); | |
| TRACE("No match, %p already connected to %p\n", pin, partner); | |
| return FALSE; | |
| } | |
| if (cat || type) | |
| FIXME("Ignoring category/type\n"); | |
| TRACE("Match made in heaven\n"); | |
| return TRUE; | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder2_FindPin(ICaptureGraphBuilder2 * iface, | |
| IUnknown *pSource, | |
| PIN_DIRECTION pindir, | |
| const GUID *pCategory, | |
| const GUID *pType, | |
| BOOL fUnconnected, | |
| INT num, | |
| IPin **ppPin) | |
| { | |
| HRESULT hr; | |
| IEnumPins *enumpins = NULL; | |
| IPin *pin; | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface); | |
| TRACE("(%p/%p)->(%p, %x, %s, %s, %d, %i, %p)\n", This, iface, | |
| pSource, pindir, debugstr_guid(pCategory), debugstr_guid(pType), | |
| fUnconnected, num, ppPin); | |
| pin = NULL; | |
| hr = IUnknown_QueryInterface(pSource, &IID_IPin, (void**)&pin); | |
| if (hr == E_NOINTERFACE) | |
| { | |
| IBaseFilter *filter = NULL; | |
| int numcurrent = 0; | |
| hr = IUnknown_QueryInterface(pSource, &IID_IBaseFilter, (void**)&filter); | |
| if (hr == E_NOINTERFACE) | |
| { | |
| WARN("Input not filter or pin?!\n"); | |
| return E_FAIL; | |
| } | |
| hr = IBaseFilter_EnumPins(filter, &enumpins); | |
| if (FAILED(hr)) | |
| { | |
| WARN("Could not enumerate\n"); | |
| return hr; | |
| } | |
| IEnumPins_Reset(enumpins); | |
| while (1) | |
| { | |
| hr = IEnumPins_Next(enumpins, 1, &pin, NULL); | |
| if (hr == VFW_E_ENUM_OUT_OF_SYNC) | |
| { | |
| numcurrent = 0; | |
| IEnumPins_Reset(enumpins); | |
| pin = NULL; | |
| continue; | |
| } | |
| if (hr != S_OK) | |
| break; | |
| TRACE("Testing match\n"); | |
| if (pin_matches(pin, pindir, pCategory, pType, fUnconnected) && numcurrent++ == num) | |
| break; | |
| IPin_Release(pin); | |
| pin = NULL; | |
| } | |
| IEnumPins_Release(enumpins); | |
| if (hr != S_OK) | |
| { | |
| WARN("Could not find %s pin # %d\n", (pindir == PINDIR_OUTPUT ? "output" : "input"), numcurrent); | |
| return E_FAIL; | |
| } | |
| } | |
| else if (!pin_matches(pin, pindir, pCategory, pType, fUnconnected)) | |
| { | |
| IPin_Release(pin); | |
| return E_FAIL; | |
| } | |
| *ppPin = pin; | |
| return S_OK; | |
| } | |
| static const ICaptureGraphBuilder2Vtbl builder2_Vtbl = | |
| { | |
| fnCaptureGraphBuilder2_QueryInterface, | |
| fnCaptureGraphBuilder2_AddRef, | |
| fnCaptureGraphBuilder2_Release, | |
| fnCaptureGraphBuilder2_SetFilterGraph, | |
| fnCaptureGraphBuilder2_GetFilterGraph, | |
| fnCaptureGraphBuilder2_SetOutputFileName, | |
| fnCaptureGraphBuilder2_FindInterface, | |
| fnCaptureGraphBuilder2_RenderStream, | |
| fnCaptureGraphBuilder2_ControlStream, | |
| fnCaptureGraphBuilder2_AllocCapFile, | |
| fnCaptureGraphBuilder2_CopyCaptureFile, | |
| fnCaptureGraphBuilder2_FindPin | |
| }; | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder_QueryInterface(ICaptureGraphBuilder * iface, | |
| REFIID riid, LPVOID * ppv) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface); | |
| TRACE("%p --> Forwarding to v2 (%p)\n", iface, This); | |
| return IUnknown_QueryInterface(_ICaptureGraphBuilder2_(This), riid, ppv); | |
| } | |
| static ULONG WINAPI | |
| fnCaptureGraphBuilder_AddRef(ICaptureGraphBuilder * iface) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface); | |
| TRACE("%p --> Forwarding to v2 (%p)\n", iface, This); | |
| return IUnknown_AddRef(_ICaptureGraphBuilder2_(This)); | |
| } | |
| static ULONG WINAPI | |
| fnCaptureGraphBuilder_Release(ICaptureGraphBuilder * iface) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface); | |
| TRACE("%p --> Forwarding to v2 (%p)\n", iface, This); | |
| return IUnknown_Release(_ICaptureGraphBuilder2_(This)); | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder_SetFiltergraph(ICaptureGraphBuilder * iface, | |
| IGraphBuilder *pfg) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface); | |
| TRACE("%p --> Forwarding to v2 (%p)\n", iface, This); | |
| return ICaptureGraphBuilder2_SetFiltergraph(_ICaptureGraphBuilder2_(This), pfg); | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder_GetFiltergraph(ICaptureGraphBuilder * iface, | |
| IGraphBuilder **pfg) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface); | |
| TRACE("%p --> Forwarding to v2 (%p)\n", iface, This); | |
| return ICaptureGraphBuilder2_GetFiltergraph(_ICaptureGraphBuilder2_(This), pfg); | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder_SetOutputFileName(ICaptureGraphBuilder * iface, | |
| const GUID *pType, LPCOLESTR lpstrFile, | |
| IBaseFilter **ppf, IFileSinkFilter **ppSink) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface); | |
| TRACE("%p --> Forwarding to v2 (%p)\n", iface, This); | |
| return ICaptureGraphBuilder2_SetOutputFileName(_ICaptureGraphBuilder2_(This), | |
| pType, lpstrFile, ppf, ppSink); | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder_FindInterface(ICaptureGraphBuilder * iface, | |
| const GUID *pCategory, IBaseFilter *pf, | |
| REFIID riid, void **ppint) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface); | |
| TRACE("%p --> Forwarding to v2 (%p)\n", iface, This); | |
| return ICaptureGraphBuilder2_FindInterface(_ICaptureGraphBuilder2_(This), | |
| pCategory, NULL, pf, riid, ppint); | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder_RenderStream(ICaptureGraphBuilder * iface, | |
| const GUID *pCategory, IUnknown *pSource, | |
| IBaseFilter *pfCompressor, IBaseFilter *pfRenderer) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface); | |
| TRACE("%p --> Forwarding to v2 (%p)\n", iface, This); | |
| return ICaptureGraphBuilder2_RenderStream(_ICaptureGraphBuilder2_(This), | |
| pCategory, NULL, pSource, | |
| pfCompressor, pfRenderer); | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder_ControlStream(ICaptureGraphBuilder * iface, | |
| const GUID *pCategory, IBaseFilter *pFilter, | |
| REFERENCE_TIME *pstart, REFERENCE_TIME *pstop, | |
| WORD wStartCookie, WORD wStopCookie) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface); | |
| TRACE("%p --> Forwarding to v2 (%p)\n", iface, This); | |
| return ICaptureGraphBuilder2_ControlStream(_ICaptureGraphBuilder2_(This), | |
| pCategory, NULL, pFilter, pstart, | |
| pstop, wStartCookie, wStopCookie); | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder_AllocCapFile(ICaptureGraphBuilder * iface, | |
| LPCOLESTR lpstr, DWORDLONG dwlSize) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface); | |
| TRACE("%p --> Forwarding to v2 (%p)\n", iface, This); | |
| return ICaptureGraphBuilder2_AllocCapFile(_ICaptureGraphBuilder2_(This), | |
| lpstr, dwlSize); | |
| } | |
| static HRESULT WINAPI | |
| fnCaptureGraphBuilder_CopyCaptureFile(ICaptureGraphBuilder * iface, | |
| LPOLESTR lpwstrOld, LPOLESTR lpwstrNew, | |
| int fAllowEscAbort, | |
| IAMCopyCaptureFileProgress *pCallback) | |
| { | |
| CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface); | |
| TRACE("%p --> Forwarding to v2 (%p)\n", iface, This); | |
| return ICaptureGraphBuilder2_CopyCaptureFile(_ICaptureGraphBuilder2_(This), | |
| lpwstrOld, lpwstrNew, | |
| fAllowEscAbort, pCallback); | |
| } | |
| static const ICaptureGraphBuilderVtbl builder_Vtbl = | |
| { | |
| fnCaptureGraphBuilder_QueryInterface, | |
| fnCaptureGraphBuilder_AddRef, | |
| fnCaptureGraphBuilder_Release, | |
| fnCaptureGraphBuilder_SetFiltergraph, | |
| fnCaptureGraphBuilder_GetFiltergraph, | |
| fnCaptureGraphBuilder_SetOutputFileName, | |
| fnCaptureGraphBuilder_FindInterface, | |
| fnCaptureGraphBuilder_RenderStream, | |
| fnCaptureGraphBuilder_ControlStream, | |
| fnCaptureGraphBuilder_AllocCapFile, | |
| fnCaptureGraphBuilder_CopyCaptureFile | |
| }; |