#include "strmbase_private.h"

Include dependency graph for filter.c:

Classes
struct	enum_pins

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (quartz)

static HRESULT	enum_pins_create (struct strmbase_filter filter, IEnumPins *out)

static struct enum_pins *	impl_from_IEnumPins (IEnumPins *iface)

static HRESULT WINAPI	enum_pins_QueryInterface (IEnumPins iface, REFIID iid, void *out)

static ULONG WINAPI	enum_pins_AddRef (IEnumPins *iface)

static ULONG WINAPI	enum_pins_Release (IEnumPins *iface)

static HRESULT WINAPI	enum_pins_Next (IEnumPins iface, ULONG count, IPin pins, ULONG ret_count)

static HRESULT WINAPI	enum_pins_Skip (IEnumPins *iface, ULONG count)

static HRESULT WINAPI	enum_pins_Reset (IEnumPins *iface)

static HRESULT WINAPI	enum_pins_Clone (IEnumPins iface, IEnumPins *out)

static struct strmbase_filter *	impl_from_IUnknown (IUnknown *iface)

static HRESULT WINAPI	filter_inner_QueryInterface (IUnknown iface, REFIID iid, void *out)

static ULONG WINAPI	filter_inner_AddRef (IUnknown *iface)

static ULONG WINAPI	filter_inner_Release (IUnknown *iface)

static struct strmbase_filter *	impl_from_IBaseFilter (IBaseFilter *iface)

static HRESULT WINAPI	filter_QueryInterface (IBaseFilter iface, REFIID iid, void *out)

static ULONG WINAPI	filter_AddRef (IBaseFilter *iface)

static ULONG WINAPI	filter_Release (IBaseFilter *iface)

static HRESULT WINAPI	filter_GetClassID (IBaseFilter iface, CLSID clsid)

static HRESULT WINAPI	filter_Stop (IBaseFilter *iface)

static HRESULT WINAPI	filter_Pause (IBaseFilter *iface)

static HRESULT WINAPI	filter_Run (IBaseFilter *iface, REFERENCE_TIME start)

static HRESULT WINAPI	filter_GetState (IBaseFilter iface, DWORD timeout, FILTER_STATE state)

static HRESULT WINAPI	filter_SetSyncSource (IBaseFilter iface, IReferenceClock clock)

static HRESULT WINAPI	filter_GetSyncSource (IBaseFilter iface, IReferenceClock *clock)

static HRESULT WINAPI	filter_EnumPins (IBaseFilter iface, IEnumPins *enum_pins)

static HRESULT WINAPI	filter_FindPin (IBaseFilter iface, const WCHAR id, IPin **ret)

static HRESULT WINAPI	filter_QueryFilterInfo (IBaseFilter iface, FILTER_INFO info)

static HRESULT WINAPI	filter_JoinFilterGraph (IBaseFilter iface, IFilterGraph graph, const WCHAR *name)

static HRESULT WINAPI	filter_QueryVendorInfo (IBaseFilter iface, WCHAR *info)

VOID WINAPI	BaseFilterImpl_IncrementPinVersion (struct strmbase_filter *filter)

void	strmbase_filter_init (struct strmbase_filter filter, IUnknown outer, const CLSID clsid, const struct strmbase_filter_ops ops)

void	strmbase_filter_cleanup (struct strmbase_filter *filter)

Variables
static const IEnumPinsVtbl	enum_pins_vtbl

static const IUnknownVtbl	filter_inner_vtbl

static const IBaseFilterVtbl	filter_vtbl

Function Documentation

◆ BaseFilterImpl_IncrementPinVersion()

VOID WINAPI BaseFilterImpl_IncrementPinVersion ( struct strmbase_filter * filter )

Definition at line 512 of file filter.c.

{
    InterlockedIncrement(&filter->pin_version);
}

Referenced by FileSource_Load().

◆ enum_pins_AddRef()

static ULONG WINAPI enum_pins_AddRef ( IEnumPins * iface )

static

Definition at line 86 of file filter.c.

{
    struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
    ULONG refcount = InterlockedIncrement(&enum_pins->refcount);
    TRACE("%p increasing refcount to %lu.\n", enum_pins, refcount);
    return refcount;
}

◆ enum_pins_Clone()

static HRESULT WINAPI enum_pins_Clone	(	IEnumPins *	iface,
		IEnumPins **	out
	)

static

Definition at line 178 of file filter.c.

{
    struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
    HRESULT hr;
 
    TRACE("iface %p, out %p.\n", iface, out);
 
    if (FAILED(hr = enum_pins_create(enum_pins->filter, out)))
        return hr;
    return IEnumPins_Skip(*out, enum_pins->index);
}

◆ enum_pins_create()

static HRESULT enum_pins_create	(	struct strmbase_filter *	filter,
		IEnumPins **	out
	)

static

Definition at line 37 of file filter.c.

{
    struct enum_pins *object;
 
    if (!out)
        return E_POINTER;
 
    if (!(object = heap_alloc_zero(sizeof(*object))))
    {
        *out = NULL;
        return E_OUTOFMEMORY;
    }
 
    object->IEnumPins_iface.lpVtbl = &enum_pins_vtbl;
    object->refcount = 1;
    object->filter = filter;
    IBaseFilter_AddRef(&filter->IBaseFilter_iface);
    object->version = filter->pin_version;
 
    while (filter->ops->filter_get_pin(filter, object->count))
        ++object->count;
 
    TRACE("Created enumerator %p.\n", object);
    *out = &object->IEnumPins_iface;
 
    return S_OK;
}

Referenced by enum_pins_Clone(), and filter_EnumPins().

◆ enum_pins_Next()

static HRESULT WINAPI enum_pins_Next	(	IEnumPins *	iface,
		ULONG	count,
		IPin **	pins,
		ULONG *	ret_count
	)

static

Definition at line 108 of file filter.c.

{
    struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
    unsigned int i;
 
    TRACE("iface %p, count %lu, pins %p, ret_count %p.\n", iface, count, pins, ret_count);
 
    if (!pins)
        return E_POINTER;
 
    if (count > 1 && !ret_count)
        return E_INVALIDARG;
 
    if (ret_count)
        *ret_count = 0;
 
    if (enum_pins->version != enum_pins->filter->pin_version)
        return S_FALSE;
 
    for (i = 0; i < count; ++i)
    {
        struct strmbase_pin *pin = enum_pins->filter->ops->filter_get_pin(enum_pins->filter, enum_pins->index + i);
 
        if (!pin)
            break;
 
        IPin_AddRef(pins[i] = &pin->IPin_iface);
    }
 
    if (ret_count)
        *ret_count = i;
    enum_pins->index += i;
    return i == count ? S_OK : S_FALSE;
}

◆ enum_pins_QueryInterface()

static HRESULT WINAPI enum_pins_QueryInterface	(	IEnumPins *	iface,
		REFIID	iid,
		void **	out
	)

static

Definition at line 70 of file filter.c.

{
    TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 
    if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IEnumPins))
    {
        IEnumPins_AddRef(iface);
        *out = iface;
        return S_OK;
    }
 
    WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
    *out = NULL;
    return E_NOINTERFACE;
}

◆ enum_pins_Release()

static ULONG WINAPI enum_pins_Release ( IEnumPins * iface )

static

Definition at line 94 of file filter.c.

{
    struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
    ULONG refcount = InterlockedDecrement(&enum_pins->refcount);
 
    TRACE("%p decreasing refcount to %lu.\n", enum_pins, refcount);
    if (!refcount)
    {
        IBaseFilter_Release(&enum_pins->filter->IBaseFilter_iface);
        heap_free(enum_pins);
    }
    return refcount;
}

◆ enum_pins_Reset()

static HRESULT WINAPI enum_pins_Reset ( IEnumPins * iface )

static

Definition at line 159 of file filter.c.

{
    struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
 
    TRACE("iface %p.\n", iface);
 
    if (enum_pins->version != enum_pins->filter->pin_version)
    {
        enum_pins->count = 0;
        while (enum_pins->filter->ops->filter_get_pin(enum_pins->filter, enum_pins->count))
            ++enum_pins->count;
    }
 
    enum_pins->version = enum_pins->filter->pin_version;
    enum_pins->index = 0;
 
    return S_OK;
}

◆ enum_pins_Skip()

static HRESULT WINAPI enum_pins_Skip	(	IEnumPins *	iface,
		ULONG	count
	)

static

Definition at line 143 of file filter.c.

{
    struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
 
    TRACE("iface %p, count %lu.\n", iface, count);
 
    if (enum_pins->version != enum_pins->filter->pin_version)
        return VFW_E_ENUM_OUT_OF_SYNC;
 
    if (enum_pins->index + count > enum_pins->count)
        return S_FALSE;
 
    enum_pins->index += count;
    return S_OK;
}

◆ filter_AddRef()

static ULONG WINAPI filter_AddRef ( IBaseFilter * iface )

static

Definition at line 280 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
    return IUnknown_AddRef(filter->outer_unk);
}

◆ filter_EnumPins()

static HRESULT WINAPI filter_EnumPins	(	IBaseFilter *	iface,
		IEnumPins **	enum_pins
	)

static

Definition at line 420 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 
    TRACE("filter %p %s, enum_pins %p.\n", filter, debugstr_w(filter->name), enum_pins);
 
    return enum_pins_create(filter, enum_pins);
}

◆ filter_FindPin()

static HRESULT WINAPI filter_FindPin	(	IBaseFilter *	iface,
		const WCHAR *	id,
		IPin **	ret
	)

static

Definition at line 429 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
    struct strmbase_pin *pin;
    unsigned int i;
 
    TRACE("filter %p %s, id %s, ret %p.\n", filter, debugstr_w(filter->name), debugstr_w(id), ret);
 
    for (i = 0; (pin = filter->ops->filter_get_pin(filter, i)); ++i)
    {
        if (!lstrcmpW(id, pin->id))
        {
            IPin_AddRef(*ret = &pin->IPin_iface);
            return S_OK;
        }
    }
 
    return VFW_E_NOT_FOUND;
}

◆ filter_GetClassID()

static HRESULT WINAPI filter_GetClassID	(	IBaseFilter *	iface,
		CLSID *	clsid
	)

static

Definition at line 292 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 
    TRACE("filter %p %s, clsid %p.\n", filter, debugstr_w(filter->name), clsid);
 
    *clsid = filter->clsid;
 
    return S_OK;
}

◆ filter_GetState()

static HRESULT WINAPI filter_GetState	(	IBaseFilter *	iface,
		DWORD	timeout,
		FILTER_STATE *	state
	)

static

Definition at line 366 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
    HRESULT hr = S_OK;
 
    TRACE("filter %p %s, timeout %lu, state %p.\n", filter, debugstr_w(filter->name), timeout, state);
 
    EnterCriticalSection(&filter->filter_cs);
 
    if (filter->ops->filter_wait_state)
        hr = filter->ops->filter_wait_state(filter, timeout);
    *state = filter->state;
 
    LeaveCriticalSection(&filter->filter_cs);
 
    return hr;
}

◆ filter_GetSyncSource()

static HRESULT WINAPI filter_GetSyncSource	(	IBaseFilter *	iface,
		IReferenceClock **	clock
	)

static

Definition at line 403 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 
    TRACE("filter %p %s, clock %p.\n", filter, debugstr_w(filter->name), clock);
 
    EnterCriticalSection(&filter->filter_cs);
 
    *clock = filter->clock;
    if (filter->clock)
        IReferenceClock_AddRef(filter->clock);
 
    LeaveCriticalSection(&filter->filter_cs);
 
    return S_OK;
}

◆ filter_inner_AddRef()

static ULONG WINAPI filter_inner_AddRef ( IUnknown * iface )

static

Definition at line 239 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IUnknown(iface);
    ULONG refcount = InterlockedIncrement(&filter->refcount);
 
    TRACE("%p increasing refcount to %lu.\n", filter, refcount);
 
    return refcount;
}

◆ filter_inner_QueryInterface()

static HRESULT WINAPI filter_inner_QueryInterface	(	IUnknown *	iface,
		REFIID	iid,
		void **	out
	)

static

Definition at line 206 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IUnknown(iface);
    HRESULT hr;
 
    TRACE("filter %p %s, iid %s, out %p.\n", filter, debugstr_w(filter->name), debugstr_guid(iid), out);
 
    *out = NULL;
 
    if (filter->ops->filter_query_interface
            && SUCCEEDED(hr = filter->ops->filter_query_interface(filter, iid, out)))
    {
        return hr;
    }
 
    if (IsEqualIID(iid, &IID_IUnknown))
        *out = iface;
    else if (IsEqualIID(iid, &IID_IPersist)
            || IsEqualIID(iid, &IID_IMediaFilter)
            || IsEqualIID(iid, &IID_IBaseFilter))
    {
        *out = &filter->IBaseFilter_iface;
    }
    else
    {
        WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown *)*out);
    return S_OK;
}

◆ filter_inner_Release()

static ULONG WINAPI filter_inner_Release ( IUnknown * iface )

static

Definition at line 249 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IUnknown(iface);
    ULONG refcount = InterlockedDecrement(&filter->refcount);
 
    TRACE("%p decreasing refcount to %lu.\n", filter, refcount);
 
    if (!refcount)
        filter->ops->filter_destroy(filter);
 
    return refcount;
}

◆ filter_JoinFilterGraph()

static HRESULT WINAPI filter_JoinFilterGraph	(	IBaseFilter *	iface,
		IFilterGraph *	graph,
		const WCHAR *	name
	)

static

Definition at line 464 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 
    TRACE("filter %p %s, graph %p, name %s.\n", filter, debugstr_w(filter->name), graph, debugstr_w(name));
 
    EnterCriticalSection(&filter->filter_cs);
 
    if (name)
        lstrcpynW(filter->name, name, ARRAY_SIZE(filter->name));
    else
        filter->name[0] = 0;
    /* The graph references us, so we cannot also reference the graph. */
    filter->graph = graph;
 
    LeaveCriticalSection(&filter->filter_cs);
 
    return S_OK;
}

◆ filter_Pause()

static HRESULT WINAPI filter_Pause ( IBaseFilter * iface )

static

Definition at line 324 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
    HRESULT hr = S_OK;
 
    TRACE("filter %p %s.\n", filter, debugstr_w(filter->name));
 
    EnterCriticalSection(&filter->filter_cs);
 
    if (filter->state == State_Stopped && filter->ops->filter_init_stream)
        hr = filter->ops->filter_init_stream(filter);
    else if (filter->state == State_Running && filter->ops->filter_stop_stream)
        hr = filter->ops->filter_stop_stream(filter);
    if (SUCCEEDED(hr))
        filter->state = State_Paused;
 
    LeaveCriticalSection(&filter->filter_cs);
 
    return hr;
}

◆ filter_QueryFilterInfo()

static HRESULT WINAPI filter_QueryFilterInfo	(	IBaseFilter *	iface,
		FILTER_INFO *	info
	)

static

Definition at line 449 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 
    TRACE("filter %p %s, info %p.\n", filter, debugstr_w(filter->name), info);
 
    lstrcpyW(info->achName, filter->name);
    info->pGraph = filter->graph;
 
    if (info->pGraph)
        IFilterGraph_AddRef(info->pGraph);
 
    return S_OK;
}

◆ filter_QueryInterface()

static HRESULT WINAPI filter_QueryInterface	(	IBaseFilter *	iface,
		REFIID	iid,
		void **	out
	)

static

Definition at line 274 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
    return IUnknown_QueryInterface(filter->outer_unk, iid, out);
}

◆ filter_QueryVendorInfo()

static HRESULT WINAPI filter_QueryVendorInfo	(	IBaseFilter *	iface,
		WCHAR **	info
	)

static

Definition at line 484 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 
    TRACE("filter %p %s, info %p.\n", filter, debugstr_w(filter->name), info);
 
    return E_NOTIMPL;
}

◆ filter_Release()

static ULONG WINAPI filter_Release ( IBaseFilter * iface )

static

Definition at line 286 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
    return IUnknown_Release(filter->outer_unk);
}

◆ filter_Run()

static HRESULT WINAPI filter_Run	(	IBaseFilter *	iface,
		REFERENCE_TIME	start
	)

static

Definition at line 345 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
    HRESULT hr = S_OK;
 
    TRACE("filter %p %s, start %s.\n", filter, debugstr_w(filter->name), debugstr_time(start));
 
    EnterCriticalSection(&filter->filter_cs);
 
    if (filter->state == State_Stopped && filter->ops->filter_init_stream)
        hr = filter->ops->filter_init_stream(filter);
    if (SUCCEEDED(hr) && filter->ops->filter_start_stream)
        hr = filter->ops->filter_start_stream(filter, start);
    if (SUCCEEDED(hr))
        filter->state = State_Running;
 
    LeaveCriticalSection(&filter->filter_cs);
 
    return hr;
}

◆ filter_SetSyncSource()

static HRESULT WINAPI filter_SetSyncSource	(	IBaseFilter *	iface,
		IReferenceClock *	clock
	)

static

Definition at line 384 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
 
    TRACE("filter %p %s, clock %p.\n", filter, debugstr_w(filter->name), clock);
 
    EnterCriticalSection(&filter->filter_cs);
 
    if (filter->clock)
        IReferenceClock_Release(filter->clock);
    filter->clock = clock;
    if (filter->clock)
        IReferenceClock_AddRef(filter->clock);
 
    LeaveCriticalSection(&filter->filter_cs);
 
    return S_OK;
}

◆ filter_Stop()

static HRESULT WINAPI filter_Stop ( IBaseFilter * iface )

static

Definition at line 303 of file filter.c.

{
    struct strmbase_filter *filter = impl_from_IBaseFilter(iface);
    HRESULT hr = S_OK;
 
    TRACE("filter %p %s.\n", filter, debugstr_w(filter->name));
 
    EnterCriticalSection(&filter->filter_cs);
 
    if (filter->state == State_Running && filter->ops->filter_stop_stream)
        hr = filter->ops->filter_stop_stream(filter);
    if (SUCCEEDED(hr) && filter->ops->filter_cleanup_stream)
        hr = filter->ops->filter_cleanup_stream(filter);
    if (SUCCEEDED(hr))
        filter->state = State_Stopped;
 
    LeaveCriticalSection(&filter->filter_cs);
 
    return hr;
}

◆ impl_from_IBaseFilter()

static struct strmbase_filter * impl_from_IBaseFilter ( IBaseFilter * iface )

inlinestatic

Definition at line 269 of file filter.c.

{
    return CONTAINING_RECORD(iface, struct strmbase_filter, IBaseFilter_iface);
}

Referenced by filter_AddRef(), filter_EnumPins(), filter_FindPin(), filter_GetClassID(), filter_GetState(), filter_GetSyncSource(), filter_JoinFilterGraph(), filter_Pause(), filter_QueryFilterInfo(), filter_QueryInterface(), filter_QueryVendorInfo(), filter_Release(), filter_Run(), filter_SetSyncSource(), and filter_Stop().

◆ impl_from_IEnumPins()

static struct enum_pins * impl_from_IEnumPins ( IEnumPins * iface )

inlinestatic

Definition at line 65 of file filter.c.

{
    return CONTAINING_RECORD(iface, struct enum_pins, IEnumPins_iface);
}

◆ impl_from_IUnknown()

static struct strmbase_filter * impl_from_IUnknown ( IUnknown * iface )

inlinestatic

Definition at line 201 of file filter.c.

{
    return CONTAINING_RECORD(iface, struct strmbase_filter, IUnknown_inner);
}

Referenced by filter_inner_AddRef(), filter_inner_QueryInterface(), and filter_inner_Release().

◆ strmbase_filter_cleanup()

void strmbase_filter_cleanup ( struct strmbase_filter * filter )

Definition at line 540 of file filter.c.

{
    if (filter->clock)
        IReferenceClock_Release(filter->clock);
 
    filter->IBaseFilter_iface.lpVtbl = NULL;
    if (filter->filter_cs.DebugInfo != (RTL_CRITICAL_SECTION_DEBUG *)-1)
        filter->filter_cs.DebugInfo->Spare[0] = 0;
    DeleteCriticalSection(&filter->filter_cs);
    if (filter->stream_cs.DebugInfo != (RTL_CRITICAL_SECTION_DEBUG *)-1)
        filter->stream_cs.DebugInfo->Spare[0] = 0;
    DeleteCriticalSection(&filter->stream_cs);
}

Referenced by acm_wrapper_destroy(), async_reader_destroy(), audio_record_destroy(), avi_compressor_destroy(), avi_decompressor_destroy(), avi_mux_create(), avi_mux_destroy(), dsound_render_create(), dsound_render_destroy(), file_writer_destroy(), sample_grabber_destroy(), smart_tee_create(), smart_tee_destroy(), strmbase_renderer_cleanup(), testfilter_destroy(), testsink_destroy(), and vfw_capture_destroy().

◆ strmbase_filter_init()

void strmbase_filter_init	(	struct strmbase_filter *	filter,
		IUnknown *	outer,
		const CLSID *	clsid,
		const struct strmbase_filter_ops *	ops
	)

Definition at line 517 of file filter.c.

{
    memset(filter, 0, sizeof(*filter));
 
    filter->IBaseFilter_iface.lpVtbl = &filter_vtbl;
    filter->IUnknown_inner.lpVtbl = &filter_inner_vtbl;
    filter->outer_unk = outer ? outer : &filter->IUnknown_inner;
    filter->refcount = 1;
 
    if (!InitializeCriticalSectionEx(&filter->filter_cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO))
        InitializeCriticalSection(&filter->filter_cs);
    if (filter->filter_cs.DebugInfo != (RTL_CRITICAL_SECTION_DEBUG *)-1)
        filter->filter_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": strmbase_filter.filter_cs");
    if (!InitializeCriticalSectionEx(&filter->stream_cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO))
        InitializeCriticalSection(&filter->stream_cs);
    if (filter->stream_cs.DebugInfo != (RTL_CRITICAL_SECTION_DEBUG *)-1)
        filter->stream_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": strmbase_filter.stream_cs");
    filter->clsid = *clsid;
    filter->pin_version = 1;
    filter->ops = ops;
}

Referenced by acm_wrapper_create(), async_reader_create(), audio_record_create(), avi_compressor_create(), avi_dec_create(), avi_mux_create(), dsound_render_create(), file_writer_create(), sample_grabber_create(), smart_tee_create(), strmbase_renderer_init(), testfilter_init(), testsink_init(), and vfw_capture_create().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( quartz )

Variable Documentation

◆ enum_pins_vtbl

static const IEnumPinsVtbl enum_pins_vtbl

static

Initial value:

=
{
    enum_pins_QueryInterface,
    enum_pins_AddRef,
    enum_pins_Release,
    enum_pins_Next,
    enum_pins_Skip,
    enum_pins_Reset,
    enum_pins_Clone,
}

Definition at line 35 of file filter.c.

◆ filter_inner_vtbl

const IUnknownVtbl filter_inner_vtbl

static

Initial value:

=
{
    filter_inner_QueryInterface,
    filter_inner_AddRef,
    filter_inner_Release,
}

Definition at line 262 of file filter.c.

Referenced by strmbase_filter_init().

◆ filter_vtbl

const IBaseFilterVtbl filter_vtbl

static

Initial value:

=
{
    filter_QueryInterface,
    filter_AddRef,
    filter_Release,
    filter_GetClassID,
    filter_Stop,
    filter_Pause,
    filter_Run,
    filter_GetState,
    filter_SetSyncSource,
    filter_GetSyncSource,
    filter_EnumPins,
    filter_FindPin,
    filter_QueryFilterInfo,
    filter_JoinFilterGraph,
    filter_QueryVendorInfo,
}

Definition at line 493 of file filter.c.

Classes

Functions

Variables

Function Documentation

◆ BaseFilterImpl_IncrementPinVersion()

◆ enum_pins_AddRef()

◆ enum_pins_Clone()

◆ enum_pins_create()

◆ enum_pins_Next()

◆ enum_pins_QueryInterface()

◆ enum_pins_Release()

◆ enum_pins_Reset()

◆ enum_pins_Skip()

◆ filter_AddRef()

◆ filter_EnumPins()

◆ filter_FindPin()

◆ filter_GetClassID()

◆ filter_GetState()

◆ filter_GetSyncSource()

◆ filter_inner_AddRef()

◆ filter_inner_QueryInterface()

◆ filter_inner_Release()

◆ filter_JoinFilterGraph()

◆ filter_Pause()

◆ filter_QueryFilterInfo()

◆ filter_QueryInterface()

◆ filter_QueryVendorInfo()

◆ filter_Release()

◆ filter_Run()

◆ filter_SetSyncSource()

◆ filter_Stop()

◆ impl_from_IBaseFilter()

◆ impl_from_IEnumPins()

◆ impl_from_IUnknown()

◆ strmbase_filter_cleanup()

◆ strmbase_filter_init()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

Variable Documentation

◆ enum_pins_vtbl

◆ filter_inner_vtbl

◆ filter_vtbl