mirror of
https://github.com/reactos/reactos.git
synced 2024-08-21 02:43:48 +00:00
![Oleg Dubinskiy](/assets/img/avatar_default.png)
Fix also MSVC build. [DOC] Add qcap entry in README.WINE Co-Authored-By: Thomas Faber <18138474+ThFabba@users.noreply.github.com>
882 lines
30 KiB
C
882 lines
30 KiB
C
/* 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
|
|
|
|
#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 "uuids.h"
|
|
#include "qcap_main.h"
|
|
|
|
#include "wine/unicode.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(qcap);
|
|
|
|
/***********************************************************************
|
|
* ICaptureGraphBuilder & ICaptureGraphBuilder2 implementation
|
|
*/
|
|
typedef struct CaptureGraphImpl
|
|
{
|
|
ICaptureGraphBuilder2 ICaptureGraphBuilder2_iface;
|
|
ICaptureGraphBuilder ICaptureGraphBuilder_iface;
|
|
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 CONTAINING_RECORD(iface, CaptureGraphImpl, ICaptureGraphBuilder_iface);
|
|
}
|
|
|
|
static inline CaptureGraphImpl *impl_from_ICaptureGraphBuilder2(ICaptureGraphBuilder2 *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, CaptureGraphImpl, ICaptureGraphBuilder2_iface);
|
|
}
|
|
|
|
|
|
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->ICaptureGraphBuilder2_iface.lpVtbl = &builder2_Vtbl;
|
|
pCapture->ICaptureGraphBuilder_iface.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->ICaptureGraphBuilder_iface;
|
|
}
|
|
|
|
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 = &This->ICaptureGraphBuilder2_iface;
|
|
else if (IsEqualIID(riid, &IID_ICaptureGraphBuilder))
|
|
*ppv = &This->ICaptureGraphBuilder_iface;
|
|
else if (IsEqualIID(riid, &IID_ICaptureGraphBuilder2))
|
|
*ppv = &This->ICaptureGraphBuilder2_iface;
|
|
|
|
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)
|
|
{
|
|
This->csFilter.DebugInfo->Spare[0] = 0;
|
|
DeleteCriticalSection(&This->csFilter);
|
|
if (This->mygraph)
|
|
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(IGraphBuilder_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 match_smart_tee_pin(CaptureGraphImpl *This,
|
|
const GUID *pCategory,
|
|
const GUID *pType,
|
|
IUnknown *pSource,
|
|
IPin **source_out)
|
|
{
|
|
static const WCHAR inputW[] = {'I','n','p','u','t',0};
|
|
static const WCHAR captureW[] = {'C','a','p','t','u','r','e',0};
|
|
static const WCHAR previewW[] = {'P','r','e','v','i','e','w',0};
|
|
IPin *capture = NULL;
|
|
IPin *preview = NULL;
|
|
IPin *peer = NULL;
|
|
IBaseFilter *smartTee = NULL;
|
|
BOOL needSmartTee = FALSE;
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p, %s, %s, %p, %p)\n", This, debugstr_guid(pCategory), debugstr_guid(pType), pSource, source_out);
|
|
hr = ICaptureGraphBuilder2_FindPin(&This->ICaptureGraphBuilder2_iface, pSource,
|
|
PINDIR_OUTPUT, &PIN_CATEGORY_CAPTURE, pType, FALSE, 0, &capture);
|
|
if (SUCCEEDED(hr)) {
|
|
hr = ICaptureGraphBuilder2_FindPin(&This->ICaptureGraphBuilder2_iface, pSource,
|
|
PINDIR_OUTPUT, &PIN_CATEGORY_PREVIEW, pType, FALSE, 0, &preview);
|
|
if (FAILED(hr))
|
|
needSmartTee = TRUE;
|
|
} else {
|
|
hr = E_INVALIDARG;
|
|
goto end;
|
|
}
|
|
if (!needSmartTee) {
|
|
if (IsEqualIID(pCategory, &PIN_CATEGORY_CAPTURE)) {
|
|
hr = IPin_ConnectedTo(capture, &peer);
|
|
if (hr == VFW_E_NOT_CONNECTED) {
|
|
*source_out = capture;
|
|
IPin_AddRef(*source_out);
|
|
hr = S_OK;
|
|
} else
|
|
hr = E_INVALIDARG;
|
|
} else {
|
|
hr = IPin_ConnectedTo(preview, &peer);
|
|
if (hr == VFW_E_NOT_CONNECTED) {
|
|
*source_out = preview;
|
|
IPin_AddRef(*source_out);
|
|
hr = S_OK;
|
|
} else
|
|
hr = E_INVALIDARG;
|
|
}
|
|
goto end;
|
|
}
|
|
hr = IPin_ConnectedTo(capture, &peer);
|
|
if (SUCCEEDED(hr)) {
|
|
PIN_INFO pinInfo;
|
|
GUID classID;
|
|
hr = IPin_QueryPinInfo(peer, &pinInfo);
|
|
if (SUCCEEDED(hr)) {
|
|
hr = IBaseFilter_GetClassID(pinInfo.pFilter, &classID);
|
|
if (SUCCEEDED(hr)) {
|
|
if (IsEqualIID(&classID, &CLSID_SmartTee)) {
|
|
smartTee = pinInfo.pFilter;
|
|
IBaseFilter_AddRef(smartTee);
|
|
}
|
|
}
|
|
IBaseFilter_Release(pinInfo.pFilter);
|
|
}
|
|
if (!smartTee) {
|
|
hr = E_INVALIDARG;
|
|
goto end;
|
|
}
|
|
} else if (hr == VFW_E_NOT_CONNECTED) {
|
|
hr = CoCreateInstance(&CLSID_SmartTee, NULL, CLSCTX_INPROC_SERVER,
|
|
&IID_IBaseFilter, (LPVOID*)&smartTee);
|
|
if (SUCCEEDED(hr)) {
|
|
hr = IGraphBuilder_AddFilter(This->mygraph, smartTee, NULL);
|
|
if (SUCCEEDED(hr)) {
|
|
IPin *smartTeeInput = NULL;
|
|
hr = IBaseFilter_FindPin(smartTee, inputW, &smartTeeInput);
|
|
if (SUCCEEDED(hr)) {
|
|
hr = IGraphBuilder_ConnectDirect(This->mygraph, capture, smartTeeInput, NULL);
|
|
IPin_Release(smartTeeInput);
|
|
}
|
|
}
|
|
}
|
|
if (FAILED(hr)) {
|
|
TRACE("adding SmartTee failed with hr=0x%08x\n", hr);
|
|
hr = E_INVALIDARG;
|
|
goto end;
|
|
}
|
|
} else {
|
|
hr = E_INVALIDARG;
|
|
goto end;
|
|
}
|
|
if (IsEqualIID(pCategory, &PIN_CATEGORY_CAPTURE))
|
|
hr = IBaseFilter_FindPin(smartTee, captureW, source_out);
|
|
else {
|
|
hr = IBaseFilter_FindPin(smartTee, previewW, source_out);
|
|
if (SUCCEEDED(hr))
|
|
hr = VFW_S_NOPREVIEWPIN;
|
|
}
|
|
|
|
end:
|
|
if (capture)
|
|
IPin_Release(capture);
|
|
if (preview)
|
|
IPin_Release(preview);
|
|
if (peer)
|
|
IPin_Release(peer);
|
|
if (smartTee)
|
|
IBaseFilter_Release(smartTee);
|
|
TRACE("for %s returning hr=0x%08x, *source_out=%p\n", IsEqualIID(pCategory, &PIN_CATEGORY_CAPTURE) ? "capture" : "preview", hr, source_out ? *source_out : 0);
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT find_unconnected_pin(CaptureGraphImpl *This,
|
|
const GUID *pCategory, const GUID *pType, IUnknown *pSource, IPin **out_pin)
|
|
{
|
|
int index = 0;
|
|
IPin *source_out;
|
|
HRESULT hr;
|
|
BOOL usedSmartTeePreviewPin = FALSE;
|
|
|
|
/* depth-first search the graph for the first unconnected pin that matches
|
|
* the given category and type */
|
|
for(;;){
|
|
IPin *nextpin;
|
|
|
|
if (pCategory && (IsEqualIID(pCategory, &PIN_CATEGORY_CAPTURE) || IsEqualIID(pCategory, &PIN_CATEGORY_PREVIEW))){
|
|
IBaseFilter *sourceFilter = NULL;
|
|
hr = IUnknown_QueryInterface(pSource, &IID_IBaseFilter, (void**)&sourceFilter);
|
|
if (SUCCEEDED(hr)) {
|
|
hr = match_smart_tee_pin(This, pCategory, pType, pSource, &source_out);
|
|
if (hr == VFW_S_NOPREVIEWPIN)
|
|
usedSmartTeePreviewPin = TRUE;
|
|
IBaseFilter_Release(sourceFilter);
|
|
} else {
|
|
hr = ICaptureGraphBuilder2_FindPin(&This->ICaptureGraphBuilder2_iface, pSource, PINDIR_OUTPUT, pCategory, pType, FALSE, index, &source_out);
|
|
}
|
|
if (FAILED(hr))
|
|
return E_INVALIDARG;
|
|
} else {
|
|
hr = ICaptureGraphBuilder2_FindPin(&This->ICaptureGraphBuilder2_iface, pSource, PINDIR_OUTPUT, pCategory, pType, FALSE, index, &source_out);
|
|
if (FAILED(hr))
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
hr = IPin_ConnectedTo(source_out, &nextpin);
|
|
if(SUCCEEDED(hr)){
|
|
PIN_INFO info;
|
|
|
|
IPin_Release(source_out);
|
|
|
|
hr = IPin_QueryPinInfo(nextpin, &info);
|
|
if(FAILED(hr) || !info.pFilter){
|
|
WARN("QueryPinInfo failed: %08x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
hr = find_unconnected_pin(This, pCategory, pType, (IUnknown*)info.pFilter, out_pin);
|
|
|
|
IBaseFilter_Release(info.pFilter);
|
|
|
|
if(SUCCEEDED(hr))
|
|
return hr;
|
|
}else{
|
|
*out_pin = source_out;
|
|
if(usedSmartTeePreviewPin)
|
|
return VFW_S_NOPREVIEWPIN;
|
|
return S_OK;
|
|
}
|
|
|
|
index++;
|
|
}
|
|
}
|
|
|
|
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 *source_out = NULL, *renderer_in;
|
|
BOOL rendererNeedsRelease = FALSE;
|
|
HRESULT hr, return_hr = S_OK;
|
|
|
|
FIXME("(%p/%p)->(%s, %s, %p, %p, %p) semi-stub!\n", This, iface,
|
|
debugstr_guid(pCategory), debugstr_guid(pType),
|
|
pSource, pfCompressor, pfRenderer);
|
|
|
|
if (!This->mygraph)
|
|
{
|
|
FIXME("Need a capture graph\n");
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
if (pCategory && IsEqualIID(pCategory, &PIN_CATEGORY_VBI)) {
|
|
FIXME("Tee/Sink-to-Sink filter not supported\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
hr = find_unconnected_pin(This, pCategory, pType, pSource, &source_out);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
return_hr = hr;
|
|
|
|
if (!pfRenderer)
|
|
{
|
|
IEnumMediaTypes *enumMedia = NULL;
|
|
hr = IPin_EnumMediaTypes(source_out, &enumMedia);
|
|
if (SUCCEEDED(hr)) {
|
|
AM_MEDIA_TYPE *mediaType;
|
|
hr = IEnumMediaTypes_Next(enumMedia, 1, &mediaType, NULL);
|
|
if (SUCCEEDED(hr)) {
|
|
if (IsEqualIID(&mediaType->majortype, &MEDIATYPE_Video)) {
|
|
hr = CoCreateInstance(&CLSID_VideoRenderer, NULL, CLSCTX_INPROC_SERVER,
|
|
&IID_IBaseFilter, (void**)&pfRenderer);
|
|
} else if (IsEqualIID(&mediaType->majortype, &MEDIATYPE_Audio)) {
|
|
hr = CoCreateInstance(&CLSID_DSoundRender, NULL, CLSCTX_INPROC_SERVER,
|
|
&IID_IBaseFilter, (void**)&pfRenderer);
|
|
} else {
|
|
FIXME("cannot automatically load renderer for majortype %s\n", debugstr_guid(&mediaType->majortype));
|
|
hr = E_FAIL;
|
|
}
|
|
if (SUCCEEDED(hr)) {
|
|
rendererNeedsRelease = TRUE;
|
|
hr = IGraphBuilder_AddFilter(This->mygraph, pfRenderer, NULL);
|
|
}
|
|
DeleteMediaType(mediaType);
|
|
}
|
|
IEnumMediaTypes_Release(enumMedia);
|
|
}
|
|
if (FAILED(hr)) {
|
|
if (rendererNeedsRelease)
|
|
IBaseFilter_Release(pfRenderer);
|
|
IPin_Release(source_out);
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
hr = ICaptureGraphBuilder2_FindPin(iface, (IUnknown*)pfRenderer, PINDIR_INPUT, NULL, NULL, TRUE, 0, &renderer_in);
|
|
if (FAILED(hr))
|
|
{
|
|
if (rendererNeedsRelease)
|
|
IBaseFilter_Release(pfRenderer);
|
|
IPin_Release(source_out);
|
|
return hr;
|
|
}
|
|
|
|
if (!pfCompressor)
|
|
hr = IGraphBuilder_Connect(This->mygraph, source_out, renderer_in);
|
|
else
|
|
{
|
|
IPin *compressor_in, *compressor_out;
|
|
|
|
hr = ICaptureGraphBuilder2_FindPin(iface, (IUnknown*)pfCompressor,
|
|
PINDIR_INPUT, NULL, NULL, TRUE, 0, &compressor_in);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = IGraphBuilder_Connect(This->mygraph, source_out, compressor_in);
|
|
IPin_Release(compressor_in);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ICaptureGraphBuilder2_FindPin(iface, (IUnknown*)pfCompressor,
|
|
PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &compressor_out);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = IGraphBuilder_Connect(This->mygraph, compressor_out, renderer_in);
|
|
IPin_Release(compressor_out);
|
|
}
|
|
}
|
|
}
|
|
|
|
IPin_Release(source_out);
|
|
IPin_Release(renderer_in);
|
|
if (rendererNeedsRelease)
|
|
IBaseFilter_Release(pfRenderer);
|
|
if (SUCCEEDED(hr))
|
|
return return_hr;
|
|
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 HRESULT pin_matches(IPin *pin, PIN_DIRECTION direction, const GUID *cat, const GUID *type, BOOL unconnected)
|
|
{
|
|
IPin *partner;
|
|
PIN_DIRECTION pindir;
|
|
HRESULT hr;
|
|
|
|
hr = IPin_QueryDirection(pin, &pindir);
|
|
|
|
if (unconnected && IPin_ConnectedTo(pin, &partner) == S_OK && partner!=NULL)
|
|
{
|
|
IPin_Release(partner);
|
|
TRACE("No match, %p already connected to %p\n", pin, partner);
|
|
return FAILED(hr) ? hr : S_FALSE;
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
return hr;
|
|
if (SUCCEEDED(hr) && pindir != direction)
|
|
return S_FALSE;
|
|
|
|
if (cat)
|
|
{
|
|
IKsPropertySet *props;
|
|
GUID category;
|
|
DWORD fetched;
|
|
|
|
hr = IPin_QueryInterface(pin, &IID_IKsPropertySet, (void**)&props);
|
|
if (FAILED(hr))
|
|
return S_FALSE;
|
|
|
|
hr = IKsPropertySet_Get(props, &ROPSETID_Pin, 0, NULL,
|
|
0, &category, sizeof(category), &fetched);
|
|
IKsPropertySet_Release(props);
|
|
if (FAILED(hr) || !IsEqualIID(&category, cat))
|
|
return S_FALSE;
|
|
}
|
|
|
|
if (type)
|
|
{
|
|
IEnumMediaTypes *types;
|
|
AM_MEDIA_TYPE *media_type;
|
|
ULONG fetched;
|
|
|
|
hr = IPin_EnumMediaTypes(pin, &types);
|
|
if (FAILED(hr))
|
|
return S_FALSE;
|
|
|
|
IEnumMediaTypes_Reset(types);
|
|
while (1) {
|
|
if (IEnumMediaTypes_Next(types, 1, &media_type, &fetched) != S_OK || fetched != 1)
|
|
{
|
|
IEnumMediaTypes_Release(types);
|
|
return S_FALSE;
|
|
}
|
|
|
|
if (IsEqualIID(&media_type->majortype, type))
|
|
{
|
|
DeleteMediaType(media_type);
|
|
break;
|
|
}
|
|
DeleteMediaType(media_type);
|
|
}
|
|
IEnumMediaTypes_Release(types);
|
|
}
|
|
|
|
TRACE("Pin matched\n");
|
|
return S_OK;
|
|
}
|
|
|
|
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_NOINTERFACE;
|
|
}
|
|
|
|
hr = IBaseFilter_EnumPins(filter, &enumpins);
|
|
if (FAILED(hr))
|
|
{
|
|
WARN("Could not enumerate\n");
|
|
IBaseFilter_Release(filter);
|
|
return hr;
|
|
}
|
|
|
|
while (1)
|
|
{
|
|
ULONG fetched;
|
|
|
|
hr = IEnumPins_Next(enumpins, 1, &pin, &fetched);
|
|
if (hr == VFW_E_ENUM_OUT_OF_SYNC)
|
|
{
|
|
numcurrent = 0;
|
|
IEnumPins_Reset(enumpins);
|
|
pin = NULL;
|
|
continue;
|
|
}
|
|
if (hr != S_OK)
|
|
break;
|
|
if (fetched != 1)
|
|
{
|
|
hr = E_FAIL;
|
|
break;
|
|
}
|
|
|
|
TRACE("Testing match\n");
|
|
hr = pin_matches(pin, pindir, pCategory, pType, fUnconnected);
|
|
if (hr == S_OK && numcurrent++ == num)
|
|
break;
|
|
IPin_Release(pin);
|
|
pin = NULL;
|
|
if (FAILED(hr))
|
|
break;
|
|
}
|
|
IEnumPins_Release(enumpins);
|
|
IBaseFilter_Release(filter);
|
|
|
|
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) != S_OK)
|
|
{
|
|
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 ICaptureGraphBuilder2_QueryInterface(&This->ICaptureGraphBuilder2_iface, 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 ICaptureGraphBuilder2_AddRef(&This->ICaptureGraphBuilder2_iface);
|
|
}
|
|
|
|
static ULONG WINAPI
|
|
fnCaptureGraphBuilder_Release(ICaptureGraphBuilder * iface)
|
|
{
|
|
CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface);
|
|
TRACE("%p --> Forwarding to v2 (%p)\n", iface, This);
|
|
return ICaptureGraphBuilder2_Release(&This->ICaptureGraphBuilder2_iface);
|
|
}
|
|
|
|
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(&This->ICaptureGraphBuilder2_iface, 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(&This->ICaptureGraphBuilder2_iface, 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(&This->ICaptureGraphBuilder2_iface, 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(&This->ICaptureGraphBuilder2_iface, 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(&This->ICaptureGraphBuilder2_iface, 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(&This->ICaptureGraphBuilder2_iface, 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(&This->ICaptureGraphBuilder2_iface, 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(&This->ICaptureGraphBuilder2_iface, 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
|
|
};
|