capturegraph.c File Reference

#include "config.h"
#include <stdio.h>
#include <stdarg.h>
#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 "uuids.h"
#include "qcap_main.h"
#include "wine/unicode.h"
#include "wine/debug.h"

Include dependency graph for capturegraph.c:

Go to the source code of this file.

Classes
struct	CaptureGraphImpl

Macros
#define	COBJMACROS

Typedefs
typedef struct CaptureGraphImpl	CaptureGraphImpl

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (qcap)
static CaptureGraphImpl *	impl_from_ICaptureGraphBuilder (ICaptureGraphBuilder *iface)
static CaptureGraphImpl *	impl_from_ICaptureGraphBuilder2 (ICaptureGraphBuilder2 *iface)
IUnknown *CALLBACK	QCAP_createCaptureGraphBuilder2 (IUnknown *pUnkOuter, HRESULT *phr)
static HRESULT WINAPI	fnCaptureGraphBuilder2_QueryInterface (ICaptureGraphBuilder2 *iface, REFIID riid, LPVOID *ppv)
static ULONG WINAPI	fnCaptureGraphBuilder2_AddRef (ICaptureGraphBuilder2 *iface)
static ULONG WINAPI	fnCaptureGraphBuilder2_Release (ICaptureGraphBuilder2 *iface)
static HRESULT WINAPI	fnCaptureGraphBuilder2_SetFilterGraph (ICaptureGraphBuilder2 *iface, IGraphBuilder *pfg)
static HRESULT WINAPI	fnCaptureGraphBuilder2_GetFilterGraph (ICaptureGraphBuilder2 *iface, IGraphBuilder **pfg)
static HRESULT WINAPI	fnCaptureGraphBuilder2_SetOutputFileName (ICaptureGraphBuilder2 *iface, const GUID *pType, LPCOLESTR lpstrFile, IBaseFilter **ppf, IFileSinkFilter **ppSink)
static HRESULT WINAPI	fnCaptureGraphBuilder2_FindInterface (ICaptureGraphBuilder2 *iface, const GUID *pCategory, const GUID *pType, IBaseFilter *pf, REFIID riid, void **ppint)
static HRESULT	match_smart_tee_pin (CaptureGraphImpl *This, const GUID *pCategory, const GUID *pType, IUnknown *pSource, IPin **source_out)
static HRESULT	find_unconnected_pin (CaptureGraphImpl *This, const GUID *pCategory, const GUID *pType, IUnknown *pSource, IPin **out_pin)
static HRESULT WINAPI	fnCaptureGraphBuilder2_RenderStream (ICaptureGraphBuilder2 *iface, const GUID *pCategory, const GUID *pType, IUnknown *pSource, IBaseFilter *pfCompressor, IBaseFilter *pfRenderer)
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)
static HRESULT WINAPI	fnCaptureGraphBuilder2_AllocCapFile (ICaptureGraphBuilder2 *iface, LPCOLESTR lpwstr, DWORDLONG dwlSize)
static HRESULT WINAPI	fnCaptureGraphBuilder2_CopyCaptureFile (ICaptureGraphBuilder2 *iface, LPOLESTR lpwstrOld, LPOLESTR lpwstrNew, int fAllowEscAbort, IAMCopyCaptureFileProgress *pCallback)
static HRESULT	pin_matches (IPin *pin, PIN_DIRECTION direction, const GUID *cat, const GUID *type, BOOL unconnected)
static HRESULT WINAPI	fnCaptureGraphBuilder2_FindPin (ICaptureGraphBuilder2 *iface, IUnknown *pSource, PIN_DIRECTION pindir, const GUID *pCategory, const GUID *pType, BOOL fUnconnected, INT num, IPin **ppPin)
static HRESULT WINAPI	fnCaptureGraphBuilder_QueryInterface (ICaptureGraphBuilder *iface, REFIID riid, LPVOID *ppv)
static ULONG WINAPI	fnCaptureGraphBuilder_AddRef (ICaptureGraphBuilder *iface)
static ULONG WINAPI	fnCaptureGraphBuilder_Release (ICaptureGraphBuilder *iface)
static HRESULT WINAPI	fnCaptureGraphBuilder_SetFiltergraph (ICaptureGraphBuilder *iface, IGraphBuilder *pfg)
static HRESULT WINAPI	fnCaptureGraphBuilder_GetFiltergraph (ICaptureGraphBuilder *iface, IGraphBuilder **pfg)
static HRESULT WINAPI	fnCaptureGraphBuilder_SetOutputFileName (ICaptureGraphBuilder *iface, const GUID *pType, LPCOLESTR lpstrFile, IBaseFilter **ppf, IFileSinkFilter **ppSink)
static HRESULT WINAPI	fnCaptureGraphBuilder_FindInterface (ICaptureGraphBuilder *iface, const GUID *pCategory, IBaseFilter *pf, REFIID riid, void **ppint)
static HRESULT WINAPI	fnCaptureGraphBuilder_RenderStream (ICaptureGraphBuilder *iface, const GUID *pCategory, IUnknown *pSource, IBaseFilter *pfCompressor, IBaseFilter *pfRenderer)
static HRESULT WINAPI	fnCaptureGraphBuilder_ControlStream (ICaptureGraphBuilder *iface, const GUID *pCategory, IBaseFilter *pFilter, REFERENCE_TIME *pstart, REFERENCE_TIME *pstop, WORD wStartCookie, WORD wStopCookie)
static HRESULT WINAPI	fnCaptureGraphBuilder_AllocCapFile (ICaptureGraphBuilder *iface, LPCOLESTR lpstr, DWORDLONG dwlSize)
static HRESULT WINAPI	fnCaptureGraphBuilder_CopyCaptureFile (ICaptureGraphBuilder *iface, LPOLESTR lpwstrOld, LPOLESTR lpwstrNew, int fAllowEscAbort, IAMCopyCaptureFileProgress *pCallback)

Variables
static const ICaptureGraphBuilderVtbl	builder_Vtbl
static const ICaptureGraphBuilder2Vtbl	builder2_Vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 25 of file capturegraph.c.

Typedef Documentation

CaptureGraphImpl

typedef struct CaptureGraphImpl CaptureGraphImpl

Function Documentation

find_unconnected_pin()

static HRESULT find_unconnected_pin ( CaptureGraphImpl *  This, const GUID *  pCategory, const GUID *  pType, IUnknown *  pSource, IPin **  out_pin  )

static

Definition at line 363 of file capturegraph.c.

{
    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++;
    }
}

Referenced by find_unconnected_pin(), and fnCaptureGraphBuilder2_RenderStream().

fnCaptureGraphBuilder2_AddRef()

static ULONG WINAPI fnCaptureGraphBuilder2_AddRef ( ICaptureGraphBuilder2 *  iface )

static

Definition at line 135 of file capturegraph.c.

{
    CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface);
    DWORD ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p/%p)->() AddRef from %d\n", This, iface, ref - 1);
    return ref;
}

fnCaptureGraphBuilder2_AllocCapFile()

static HRESULT WINAPI fnCaptureGraphBuilder2_AllocCapFile ( ICaptureGraphBuilder2 *  iface, LPCOLESTR  lpwstr, DWORDLONG  dwlSize  )

static

Definition at line 555 of file capturegraph.c.

{
    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;
}

fnCaptureGraphBuilder2_ControlStream()

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  )

static

Definition at line 536 of file capturegraph.c.

{
    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;
}

fnCaptureGraphBuilder2_CopyCaptureFile()

static HRESULT WINAPI fnCaptureGraphBuilder2_CopyCaptureFile ( ICaptureGraphBuilder2 *  iface, LPOLESTR  lpwstrOld, LPOLESTR  lpwstrNew, int  fAllowEscAbort, IAMCopyCaptureFileProgress *  pCallback  )

static

Definition at line 568 of file capturegraph.c.

{
    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;
}

fnCaptureGraphBuilder2_FindInterface()

static HRESULT WINAPI fnCaptureGraphBuilder2_FindInterface ( ICaptureGraphBuilder2 *  iface, const GUID *  pCategory, const GUID *  pType, IBaseFilter *  pf, REFIID  riid, void **  ppint  )

static

Definition at line 232 of file capturegraph.c.

{
    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.
     */
}

fnCaptureGraphBuilder2_FindPin()

static HRESULT WINAPI fnCaptureGraphBuilder2_FindPin ( ICaptureGraphBuilder2 *  iface, IUnknown *  pSource, PIN_DIRECTION  pindir, const GUID *  pCategory, const GUID *  pType, BOOL  fUnconnected, INT  num, IPin **  ppPin  )

static

Definition at line 653 of file capturegraph.c.

{
    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;
}

fnCaptureGraphBuilder2_GetFilterGraph()

static HRESULT WINAPI fnCaptureGraphBuilder2_GetFilterGraph ( ICaptureGraphBuilder2 *  iface, IGraphBuilder **  pfg  )

static

Definition at line 193 of file capturegraph.c.

{
    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;
}

fnCaptureGraphBuilder2_QueryInterface()

static HRESULT WINAPI fnCaptureGraphBuilder2_QueryInterface ( ICaptureGraphBuilder2 *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 107 of file capturegraph.c.

{
    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;
}

fnCaptureGraphBuilder2_Release()

static ULONG WINAPI fnCaptureGraphBuilder2_Release ( ICaptureGraphBuilder2 *  iface )

static

Definition at line 144 of file capturegraph.c.

{
    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;
}

fnCaptureGraphBuilder2_RenderStream()

static HRESULT WINAPI fnCaptureGraphBuilder2_RenderStream ( ICaptureGraphBuilder2 *  iface, const GUID *  pCategory, const GUID *  pType, IUnknown *  pSource, IBaseFilter *  pfCompressor, IBaseFilter *  pfRenderer  )

static

Definition at line 425 of file capturegraph.c.

{
    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;
}

fnCaptureGraphBuilder2_SetFilterGraph()

static HRESULT WINAPI fnCaptureGraphBuilder2_SetFilterGraph ( ICaptureGraphBuilder2 *  iface, IGraphBuilder *  pfg  )

static

Definition at line 164 of file capturegraph.c.

{
/* 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;
}

fnCaptureGraphBuilder2_SetOutputFileName()

static HRESULT WINAPI fnCaptureGraphBuilder2_SetOutputFileName ( ICaptureGraphBuilder2 *  iface, const GUID *  pType, LPCOLESTR  lpstrFile, IBaseFilter **  ppf, IFileSinkFilter **  ppSink  )

static

Definition at line 217 of file capturegraph.c.

{
    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;
}

fnCaptureGraphBuilder_AddRef()

static ULONG WINAPI fnCaptureGraphBuilder_AddRef ( ICaptureGraphBuilder *  iface )

static

Definition at line 769 of file capturegraph.c.

{
    CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface);
    TRACE("%p --> Forwarding to v2 (%p)\n", iface, This);
    return ICaptureGraphBuilder2_AddRef(&This->ICaptureGraphBuilder2_iface);
}

fnCaptureGraphBuilder_AllocCapFile()

static HRESULT WINAPI fnCaptureGraphBuilder_AllocCapFile ( ICaptureGraphBuilder *  iface, LPCOLESTR  lpstr, DWORDLONG  dwlSize  )

static

Definition at line 848 of file capturegraph.c.

{
    CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface);
    TRACE("%p --> Forwarding to v2 (%p)\n", iface, This);
    return ICaptureGraphBuilder2_AllocCapFile(&This->ICaptureGraphBuilder2_iface, lpstr, dwlSize);
}

fnCaptureGraphBuilder_ControlStream()

static HRESULT WINAPI fnCaptureGraphBuilder_ControlStream ( ICaptureGraphBuilder *  iface, const GUID *  pCategory, IBaseFilter *  pFilter, REFERENCE_TIME *  pstart, REFERENCE_TIME *  pstop, WORD  wStartCookie, WORD  wStopCookie  )

static

Definition at line 836 of file capturegraph.c.

{
    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);
}

fnCaptureGraphBuilder_CopyCaptureFile()

static HRESULT WINAPI fnCaptureGraphBuilder_CopyCaptureFile ( ICaptureGraphBuilder *  iface, LPOLESTR  lpwstrOld, LPOLESTR  lpwstrNew, int  fAllowEscAbort, IAMCopyCaptureFileProgress *  pCallback  )

static

Definition at line 857 of file capturegraph.c.

{
    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);
}

fnCaptureGraphBuilder_FindInterface()

static HRESULT WINAPI fnCaptureGraphBuilder_FindInterface ( ICaptureGraphBuilder *  iface, const GUID *  pCategory, IBaseFilter *  pf, REFIID  riid, void **  ppint  )

static

Definition at line 814 of file capturegraph.c.

{
    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);
}

fnCaptureGraphBuilder_GetFiltergraph()

static HRESULT WINAPI fnCaptureGraphBuilder_GetFiltergraph ( ICaptureGraphBuilder *  iface, IGraphBuilder **  pfg  )

static

Definition at line 794 of file capturegraph.c.

{
    CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface);
    TRACE("%p --> Forwarding to v2 (%p)\n", iface, This);
    return ICaptureGraphBuilder2_GetFiltergraph(&This->ICaptureGraphBuilder2_iface, pfg);
}

fnCaptureGraphBuilder_QueryInterface()

static HRESULT WINAPI fnCaptureGraphBuilder_QueryInterface ( ICaptureGraphBuilder *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 760 of file capturegraph.c.

{
    CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface);
    TRACE("%p --> Forwarding to v2 (%p)\n", iface, This);
    return ICaptureGraphBuilder2_QueryInterface(&This->ICaptureGraphBuilder2_iface, riid, ppv);
}

fnCaptureGraphBuilder_Release()

static ULONG WINAPI fnCaptureGraphBuilder_Release ( ICaptureGraphBuilder *  iface )

static

Definition at line 777 of file capturegraph.c.

{
    CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface);
    TRACE("%p --> Forwarding to v2 (%p)\n", iface, This);
    return ICaptureGraphBuilder2_Release(&This->ICaptureGraphBuilder2_iface);
}

fnCaptureGraphBuilder_RenderStream()

static HRESULT WINAPI fnCaptureGraphBuilder_RenderStream ( ICaptureGraphBuilder *  iface, const GUID *  pCategory, IUnknown *  pSource, IBaseFilter *  pfCompressor, IBaseFilter *  pfRenderer  )

static

Definition at line 825 of file capturegraph.c.

{
    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);
}

fnCaptureGraphBuilder_SetFiltergraph()

static HRESULT WINAPI fnCaptureGraphBuilder_SetFiltergraph ( ICaptureGraphBuilder *  iface, IGraphBuilder *  pfg  )

static

Definition at line 785 of file capturegraph.c.

{
    CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder(iface);
    TRACE("%p --> Forwarding to v2 (%p)\n", iface, This);
    return ICaptureGraphBuilder2_SetFiltergraph(&This->ICaptureGraphBuilder2_iface, pfg);
}

fnCaptureGraphBuilder_SetOutputFileName()

static HRESULT WINAPI fnCaptureGraphBuilder_SetOutputFileName ( ICaptureGraphBuilder *  iface, const GUID *  pType, LPCOLESTR  lpstrFile, IBaseFilter **  ppf, IFileSinkFilter **  ppSink  )

static

Definition at line 803 of file capturegraph.c.

{
    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);
}

impl_from_ICaptureGraphBuilder()

static CaptureGraphImpl * impl_from_ICaptureGraphBuilder ( ICaptureGraphBuilder *  iface )

inlinestatic

Definition at line 66 of file capturegraph.c.

{
    return CONTAINING_RECORD(iface, CaptureGraphImpl, ICaptureGraphBuilder_iface);
}

Referenced by fnCaptureGraphBuilder_AddRef(), fnCaptureGraphBuilder_AllocCapFile(), fnCaptureGraphBuilder_ControlStream(), fnCaptureGraphBuilder_CopyCaptureFile(), fnCaptureGraphBuilder_FindInterface(), fnCaptureGraphBuilder_GetFiltergraph(), fnCaptureGraphBuilder_QueryInterface(), fnCaptureGraphBuilder_Release(), fnCaptureGraphBuilder_RenderStream(), fnCaptureGraphBuilder_SetFiltergraph(), and fnCaptureGraphBuilder_SetOutputFileName().

impl_from_ICaptureGraphBuilder2()

static CaptureGraphImpl * impl_from_ICaptureGraphBuilder2 ( ICaptureGraphBuilder2 *  iface )

inlinestatic

Definition at line 71 of file capturegraph.c.

{
    return CONTAINING_RECORD(iface, CaptureGraphImpl, ICaptureGraphBuilder2_iface);
}

Referenced by fnCaptureGraphBuilder2_AddRef(), fnCaptureGraphBuilder2_AllocCapFile(), fnCaptureGraphBuilder2_ControlStream(), fnCaptureGraphBuilder2_CopyCaptureFile(), fnCaptureGraphBuilder2_FindInterface(), fnCaptureGraphBuilder2_FindPin(), fnCaptureGraphBuilder2_GetFilterGraph(), fnCaptureGraphBuilder2_QueryInterface(), fnCaptureGraphBuilder2_Release(), fnCaptureGraphBuilder2_RenderStream(), fnCaptureGraphBuilder2_SetFilterGraph(), and fnCaptureGraphBuilder2_SetOutputFileName().

match_smart_tee_pin()

static HRESULT match_smart_tee_pin ( CaptureGraphImpl *  This, const GUID *  pCategory, const GUID *  pType, IUnknown *  pSource, IPin **  source_out  )

static

Definition at line 252 of file capturegraph.c.

{
    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;
}

Referenced by find_unconnected_pin().

pin_matches()

static HRESULT pin_matches ( IPin *  pin, PIN_DIRECTION  direction, const GUID *  cat, const GUID *  type, BOOL  unconnected  )

static

Definition at line 583 of file capturegraph.c.

{
    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, &AMPROPSETID_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;
}

Referenced by fnCaptureGraphBuilder2_FindPin().

QCAP_createCaptureGraphBuilder2()

IUnknown *CALLBACK QCAP_createCaptureGraphBuilder2	(	IUnknown *	pUnkOuter,
		HRESULT *	phr
	)

Definition at line 77 of file capturegraph.c.

{
    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;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

qcap

)

Variable Documentation

builder2_Vtbl

static const ICaptureGraphBuilder2Vtbl builder2_Vtbl

static

Initial value:

=
{
    fnCaptureGraphBuilder2_QueryInterface,
    fnCaptureGraphBuilder2_AddRef,
    fnCaptureGraphBuilder2_Release,
    fnCaptureGraphBuilder2_SetFilterGraph,
    fnCaptureGraphBuilder2_GetFilterGraph,
    fnCaptureGraphBuilder2_SetOutputFileName,
    fnCaptureGraphBuilder2_FindInterface,
    fnCaptureGraphBuilder2_RenderStream,
    fnCaptureGraphBuilder2_ControlStream,
    fnCaptureGraphBuilder2_AllocCapFile,
    fnCaptureGraphBuilder2_CopyCaptureFile,
    fnCaptureGraphBuilder2_FindPin
}

Definition at line 64 of file capturegraph.c.

Referenced by QCAP_createCaptureGraphBuilder2().

builder_Vtbl

static const ICaptureGraphBuilderVtbl builder_Vtbl

static

Initial value:

=
{
   fnCaptureGraphBuilder_QueryInterface,
   fnCaptureGraphBuilder_AddRef,
   fnCaptureGraphBuilder_Release,
   fnCaptureGraphBuilder_SetFiltergraph,
   fnCaptureGraphBuilder_GetFiltergraph,
   fnCaptureGraphBuilder_SetOutputFileName,
   fnCaptureGraphBuilder_FindInterface,
   fnCaptureGraphBuilder_RenderStream,
   fnCaptureGraphBuilder_ControlStream,
   fnCaptureGraphBuilder_AllocCapFile,
   fnCaptureGraphBuilder_CopyCaptureFile
}

Definition at line 63 of file capturegraph.c.

Referenced by QCAP_createCaptureGraphBuilder2().