pin.c File Reference

#include "strmbase_private.h"

Include dependency graph for pin.c:

Go to the source code of this file.

Classes
struct	enum_media_types
struct	newsegmentargs

Typedefs
typedef HRESULT(*	SendPinFunc) (IPin *to, LPVOID arg)
typedef struct newsegmentargs	newsegmentargs

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (quartz)
static HRESULT	enum_media_types_create (struct strmbase_pin *pin, IEnumMediaTypes **out)
static struct enum_media_types *	impl_from_IEnumMediaTypes (IEnumMediaTypes *iface)
static HRESULT WINAPI	enum_media_types_QueryInterface (IEnumMediaTypes *iface, REFIID iid, void **out)
static ULONG WINAPI	enum_media_types_AddRef (IEnumMediaTypes *iface)
static ULONG WINAPI	enum_media_types_Release (IEnumMediaTypes *iface)
static HRESULT WINAPI	enum_media_types_Next (IEnumMediaTypes *iface, ULONG count, AM_MEDIA_TYPE **mts, ULONG *ret_count)
static HRESULT WINAPI	enum_media_types_Skip (IEnumMediaTypes *iface, ULONG count)
static HRESULT WINAPI	enum_media_types_Reset (IEnumMediaTypes *iface)
static HRESULT WINAPI	enum_media_types_Clone (IEnumMediaTypes *iface, IEnumMediaTypes **out)
static struct strmbase_pin *	impl_from_IPin (IPin *iface)
static HRESULT	updatehres (HRESULT original, HRESULT new)
static HRESULT	SendFurther (struct strmbase_sink *sink, SendPinFunc func, void *arg)
static HRESULT WINAPI	pin_QueryInterface (IPin *iface, REFIID iid, void **out)
static ULONG WINAPI	pin_AddRef (IPin *iface)
static ULONG WINAPI	pin_Release (IPin *iface)
static HRESULT WINAPI	pin_ConnectedTo (IPin *iface, IPin **ppPin)
static HRESULT WINAPI	pin_ConnectionMediaType (IPin *iface, AM_MEDIA_TYPE *pmt)
static HRESULT WINAPI	pin_QueryPinInfo (IPin *iface, PIN_INFO *info)
static HRESULT WINAPI	pin_QueryDirection (IPin *iface, PIN_DIRECTION *dir)
static HRESULT WINAPI	pin_QueryId (IPin *iface, WCHAR **id)
static BOOL	query_accept (struct strmbase_pin *pin, const AM_MEDIA_TYPE *mt)
static HRESULT WINAPI	pin_QueryAccept (IPin *iface, const AM_MEDIA_TYPE *mt)
static HRESULT WINAPI	pin_EnumMediaTypes (IPin *iface, IEnumMediaTypes **enum_media_types)
static HRESULT WINAPI	pin_QueryInternalConnections (IPin *iface, IPin **pins, ULONG *count)
static struct strmbase_source *	impl_source_from_IPin (IPin *iface)
static BOOL	compare_media_types (const AM_MEDIA_TYPE *req_mt, const AM_MEDIA_TYPE *pin_mt)
static HRESULT WINAPI	source_Connect (IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
static HRESULT WINAPI	source_ReceiveConnection (IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
static HRESULT WINAPI	source_Disconnect (IPin *iface)
static HRESULT WINAPI	source_EndOfStream (IPin *iface)
static HRESULT WINAPI	source_BeginFlush (IPin *iface)
static HRESULT WINAPI	source_EndFlush (IPin *iface)
static HRESULT WINAPI	source_NewSegment (IPin *iface, REFERENCE_TIME start, REFERENCE_TIME stop, double rate)
HRESULT WINAPI	BaseOutputPinImpl_DecideAllocator (struct strmbase_source *This, IMemInputPin *pPin, IMemAllocator **pAlloc)
HRESULT WINAPI	BaseOutputPinImpl_AttemptConnection (struct strmbase_source *This, IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
void	strmbase_source_init (struct strmbase_source *pin, struct strmbase_filter *filter, const WCHAR *name, const struct strmbase_source_ops *func_table)
void	strmbase_source_cleanup (struct strmbase_source *pin)
static struct strmbase_sink *	impl_sink_from_IPin (IPin *iface)
static HRESULT WINAPI	sink_Connect (IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
static HRESULT WINAPI	sink_ReceiveConnection (IPin *iface, IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
static HRESULT WINAPI	sink_Disconnect (IPin *iface)
static HRESULT	deliver_endofstream (IPin *pin, LPVOID unused)
static HRESULT WINAPI	sink_EndOfStream (IPin *iface)
static HRESULT	deliver_beginflush (IPin *pin, LPVOID unused)
static HRESULT WINAPI	sink_BeginFlush (IPin *iface)
static HRESULT	deliver_endflush (IPin *pin, LPVOID unused)
static HRESULT WINAPI	sink_EndFlush (IPin *iface)
static HRESULT	deliver_newsegment (IPin *pin, LPVOID data)
static HRESULT WINAPI	sink_NewSegment (IPin *iface, REFERENCE_TIME start, REFERENCE_TIME stop, double rate)
static struct strmbase_sink *	impl_from_IMemInputPin (IMemInputPin *iface)
static HRESULT WINAPI	MemInputPin_QueryInterface (IMemInputPin *iface, REFIID riid, LPVOID *ppv)
static ULONG WINAPI	MemInputPin_AddRef (IMemInputPin *iface)
static ULONG WINAPI	MemInputPin_Release (IMemInputPin *iface)
static HRESULT WINAPI	MemInputPin_GetAllocator (IMemInputPin *iface, IMemAllocator **ppAllocator)
static HRESULT WINAPI	MemInputPin_NotifyAllocator (IMemInputPin *iface, IMemAllocator *pAllocator, BOOL bReadOnly)
static HRESULT WINAPI	MemInputPin_GetAllocatorRequirements (IMemInputPin *iface, ALLOCATOR_PROPERTIES *props)
static HRESULT WINAPI	MemInputPin_Receive (IMemInputPin *iface, IMediaSample *sample)
static HRESULT WINAPI	MemInputPin_ReceiveMultiple (IMemInputPin *iface, IMediaSample **pSamples, LONG nSamples, LONG *nSamplesProcessed)
static HRESULT WINAPI	MemInputPin_ReceiveCanBlock (IMemInputPin *iface)
void	strmbase_sink_init (struct strmbase_sink *pin, struct strmbase_filter *filter, const WCHAR *name, const struct strmbase_sink_ops *func_table, IMemAllocator *allocator)
void	strmbase_sink_cleanup (struct strmbase_sink *pin)

Variables
static const IMemInputPinVtbl	MemInputPin_Vtbl
static const IEnumMediaTypesVtbl	enum_media_types_vtbl
static const IPinVtbl	source_vtbl
static const IPinVtbl	sink_vtbl

Typedef Documentation

newsegmentargs

typedef struct newsegmentargs newsegmentargs

SendPinFunc

typedef HRESULT(* SendPinFunc) (IPin *to, LPVOID arg)

Definition at line 28 of file pin.c.

Function Documentation

BaseOutputPinImpl_AttemptConnection()

HRESULT WINAPI BaseOutputPinImpl_AttemptConnection	(	struct strmbase_source *	This,
		IPin *	pReceivePin,
		const AM_MEDIA_TYPE *	pmt
	)

Definition at line 710 of file pin.c.

{
    HRESULT hr;
    IMemAllocator * pMemAlloc = NULL;
 
    TRACE("(%p)->(%p, %p)\n", This, pReceivePin, pmt);
 
    if (!query_accept(&This->pin, pmt))
        return VFW_E_TYPE_NOT_ACCEPTED;
 
    This->pin.peer = pReceivePin;
    IPin_AddRef(pReceivePin);
    CopyMediaType(&This->pin.mt, pmt);
 
    hr = IPin_ReceiveConnection(pReceivePin, &This->pin.IPin_iface, pmt);
 
    /* get the IMemInputPin interface we will use to deliver samples to the
     * connected pin */
    if (SUCCEEDED(hr))
    {
        This->pMemInputPin = NULL;
        hr = IPin_QueryInterface(pReceivePin, &IID_IMemInputPin, (LPVOID)&This->pMemInputPin);
 
        if (SUCCEEDED(hr))
        {
            hr = This->pFuncsTable->pfnDecideAllocator(This, This->pMemInputPin, &pMemAlloc);
            if (SUCCEEDED(hr))
                This->pAllocator = pMemAlloc;
            else if (pMemAlloc)
                IMemAllocator_Release(pMemAlloc);
        }
 
        /* break connection if we couldn't get the allocator */
        if (FAILED(hr))
        {
            if (This->pMemInputPin)
                IMemInputPin_Release(This->pMemInputPin);
            This->pMemInputPin = NULL;
 
            IPin_Disconnect(pReceivePin);
        }
    }
 
    if (FAILED(hr))
    {
        IPin_Release(This->pin.peer);
        This->pin.peer = NULL;
        FreeMediaType(&This->pin.mt);
    }
 
    TRACE("Returning %#lx.\n", hr);
    return hr;
}

Referenced by AviMuxOut_AttemptConnection().

BaseOutputPinImpl_DecideAllocator()

HRESULT WINAPI BaseOutputPinImpl_DecideAllocator	(	struct strmbase_source *	This,
		IMemInputPin *	pPin,
		IMemAllocator **	pAlloc
	)

Definition at line 680 of file pin.c.

{
    HRESULT hr;
 
    hr = IMemInputPin_GetAllocator(pPin, pAlloc);
 
    if (hr == VFW_E_NO_ALLOCATOR)
        hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL,
                CLSCTX_INPROC_SERVER, &IID_IMemAllocator, (void **)pAlloc);
 
    if (SUCCEEDED(hr))
    {
        ALLOCATOR_PROPERTIES rProps;
        ZeroMemory(&rProps, sizeof(ALLOCATOR_PROPERTIES));
 
        IMemInputPin_GetAllocatorRequirements(pPin, &rProps);
        hr = This->pFuncsTable->pfnDecideBufferSize(This, *pAlloc, &rProps);
    }
 
    if (SUCCEEDED(hr))
        hr = IMemInputPin_NotifyAllocator(pPin, *pAlloc, FALSE);
 
    return hr;
}

Referenced by AVICompressorOut_DecideAllocator().

compare_media_types()

static BOOL compare_media_types ( const AM_MEDIA_TYPE *  req_mt, const AM_MEDIA_TYPE *  pin_mt  )

static

Definition at line 448 of file pin.c.

{
    if (!req_mt)
        return TRUE;
 
    if (!IsEqualGUID(&req_mt->majortype, &pin_mt->majortype)
            && !IsEqualGUID(&req_mt->majortype, &GUID_NULL))
        return FALSE;
 
    if (!IsEqualGUID(&req_mt->subtype, &pin_mt->subtype)
            && !IsEqualGUID(&req_mt->subtype, &GUID_NULL))
        return FALSE;
 
    if (!IsEqualGUID(&req_mt->formattype, &pin_mt->formattype)
            && !IsEqualGUID(&req_mt->formattype, &GUID_NULL))
        return FALSE;
 
    return TRUE;
}

Referenced by source_Connect().

deliver_beginflush()

static HRESULT deliver_beginflush ( IPin *  pin, LPVOID  unused  )

static

Definition at line 928 of file pin.c.

{
    return IPin_BeginFlush( pin );
}

Referenced by sink_BeginFlush().

deliver_endflush()

static HRESULT deliver_endflush ( IPin *  pin, LPVOID  unused  )

static

Definition at line 954 of file pin.c.

{
    return IPin_EndFlush( pin );
}

Referenced by sink_EndFlush().

deliver_endofstream()

static HRESULT deliver_endofstream ( IPin *  pin, LPVOID  unused  )

static

Definition at line 898 of file pin.c.

{
    return IPin_EndOfStream( pin );
}

Referenced by sink_EndOfStream().

deliver_newsegment()

static HRESULT deliver_newsegment ( IPin *  pin, LPVOID  data  )

static

Definition at line 986 of file pin.c.

{
    newsegmentargs *args = data;
    return IPin_NewSegment(pin, args->tStart, args->tStop, args->rate);
}

Referenced by sink_NewSegment().

enum_media_types_AddRef()

static ULONG WINAPI enum_media_types_AddRef ( IEnumMediaTypes *  iface )

static

Definition at line 96 of file pin.c.

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

enum_media_types_Clone()

static HRESULT WINAPI enum_media_types_Clone ( IEnumMediaTypes *  iface, IEnumMediaTypes **  out  )

static

Definition at line 201 of file pin.c.

{
    struct enum_media_types *enummt = impl_from_IEnumMediaTypes(iface);
    HRESULT hr;
 
    TRACE("enummt %p, out %p.\n", enummt, out);
 
    if (FAILED(hr = enum_media_types_create(enummt->pin, out)))
        return hr;
    return IEnumMediaTypes_Skip(*out, enummt->index);
}

enum_media_types_create()

static HRESULT enum_media_types_create ( struct strmbase_pin *  pin, IEnumMediaTypes **  out  )

static

Definition at line 41 of file pin.c.

{
    struct enum_media_types *object;
    AM_MEDIA_TYPE mt;
 
    if (!out)
        return E_POINTER;
 
    if (!(object = heap_alloc_zero(sizeof(*object))))
    {
        *out = NULL;
        return E_OUTOFMEMORY;
    }
 
    object->IEnumMediaTypes_iface.lpVtbl = &enum_media_types_vtbl;
    object->refcount = 1;
    object->pin = pin;
    IPin_AddRef(&pin->IPin_iface);
 
    if (pin->ops->pin_get_media_type)
    {
        while (pin->ops->pin_get_media_type(pin, object->count, &mt) == S_OK)
        {
            FreeMediaType(&mt);
            ++object->count;
        }
    }
 
    TRACE("Created enumerator %p.\n", object);
    *out = &object->IEnumMediaTypes_iface;
 
    return S_OK;
}

Referenced by enum_media_types_Clone(), and pin_EnumMediaTypes().

enum_media_types_Next()

static HRESULT WINAPI enum_media_types_Next ( IEnumMediaTypes *  iface, ULONG  count, AM_MEDIA_TYPE **  mts, ULONG *  ret_count  )

static

Definition at line 118 of file pin.c.

{
    struct enum_media_types *enummt = impl_from_IEnumMediaTypes(iface);
    AM_MEDIA_TYPE mt;
    unsigned int i;
    HRESULT hr;
 
    TRACE("enummt %p, count %lu, mts %p, ret_count %p.\n", enummt, count, mts, ret_count);
 
    if (!enummt->pin->ops->pin_get_media_type)
    {
        if (ret_count)
            *ret_count = 0;
        return count ? S_FALSE : S_OK;
    }
 
    for (i = 0; i < count; ++i)
    {
        hr = enummt->pin->ops->pin_get_media_type(enummt->pin, enummt->index + i, &mt);
        if (hr == S_OK)
        {
            if ((mts[i] = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE))))
                *mts[i] = mt;
            else
                hr = E_OUTOFMEMORY;
        }
        if (FAILED(hr))
        {
            while (i--)
                DeleteMediaType(mts[i]);
            *ret_count = 0;
            return E_OUTOFMEMORY;
        }
        else if (hr != S_OK)
            break;
 
        if (TRACE_ON(quartz))
        {
            TRACE("Returning media type %u:\n", enummt->index + i);
            strmbase_dump_media_type(mts[i]);
        }
    }
 
    if (count != 1 || ret_count)
        *ret_count = i;
    enummt->index += i;
    return i == count ? S_OK : S_FALSE;
}

enum_media_types_QueryInterface()

static HRESULT WINAPI enum_media_types_QueryInterface ( IEnumMediaTypes *  iface, REFIID  iid, void **  out  )

static

Definition at line 80 of file pin.c.

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

enum_media_types_Release()

static ULONG WINAPI enum_media_types_Release ( IEnumMediaTypes *  iface )

static

Definition at line 104 of file pin.c.

{
    struct enum_media_types *enummt = impl_from_IEnumMediaTypes(iface);
    ULONG refcount = InterlockedDecrement(&enummt->refcount);
 
    TRACE("%p decreasing refcount to %lu.\n", enummt, refcount);
    if (!refcount)
    {
        IPin_Release(&enummt->pin->IPin_iface);
        heap_free(enummt);
    }
    return refcount;
}

enum_media_types_Reset()

static HRESULT WINAPI enum_media_types_Reset ( IEnumMediaTypes *  iface )

static

Definition at line 179 of file pin.c.

{
    struct enum_media_types *enummt = impl_from_IEnumMediaTypes(iface);
    AM_MEDIA_TYPE mt;
 
    TRACE("enummt %p.\n", enummt);
 
    enummt->count = 0;
    if (enummt->pin->ops->pin_get_media_type)
    {
        while (enummt->pin->ops->pin_get_media_type(enummt->pin, enummt->count, &mt) == S_OK)
        {
            FreeMediaType(&mt);
            ++enummt->count;
        }
    }
 
    enummt->index = 0;
 
    return S_OK;
}

enum_media_types_Skip()

static HRESULT WINAPI enum_media_types_Skip ( IEnumMediaTypes *  iface, ULONG  count  )

static

Definition at line 168 of file pin.c.

{
    struct enum_media_types *enummt = impl_from_IEnumMediaTypes(iface);
 
    TRACE("enummt %p, count %lu.\n", enummt, count);
 
    enummt->index += count;
 
    return enummt->index > enummt->count ? S_FALSE : S_OK;
}

impl_from_IEnumMediaTypes()

static struct enum_media_types * impl_from_IEnumMediaTypes ( IEnumMediaTypes *  iface )

static

Definition at line 75 of file pin.c.

{
    return CONTAINING_RECORD(iface, struct enum_media_types, IEnumMediaTypes_iface);
}

Referenced by enum_media_types_AddRef(), enum_media_types_Clone(), enum_media_types_Next(), enum_media_types_Release(), enum_media_types_Reset(), and enum_media_types_Skip().

impl_from_IMemInputPin()

static struct strmbase_sink * impl_from_IMemInputPin ( IMemInputPin *  iface )

inlinestatic

Definition at line 1034 of file pin.c.

{
    return CONTAINING_RECORD(iface, struct strmbase_sink, IMemInputPin_iface);
}

Referenced by MemInputPin_AddRef(), MemInputPin_GetAllocator(), MemInputPin_GetAllocatorRequirements(), MemInputPin_NotifyAllocator(), MemInputPin_QueryInterface(), MemInputPin_Receive(), MemInputPin_ReceiveCanBlock(), and MemInputPin_Release().

impl_from_IPin()

static struct strmbase_pin * impl_from_IPin ( IPin *  iface )

inlinestatic

Definition at line 224 of file pin.c.

{
    return CONTAINING_RECORD(iface, struct strmbase_pin, IPin_iface);
}

Referenced by pin_AddRef(), pin_ConnectedTo(), pin_ConnectionMediaType(), pin_EnumMediaTypes(), pin_QueryAccept(), pin_QueryDirection(), pin_QueryId(), pin_QueryInterface(), pin_QueryInternalConnections(), pin_QueryPinInfo(), and pin_Release().

impl_sink_from_IPin()

static struct strmbase_sink * impl_sink_from_IPin ( IPin *  iface )

static

Definition at line 786 of file pin.c.

{
    return CONTAINING_RECORD(iface, struct strmbase_sink, pin.IPin_iface);
}

Referenced by sink_BeginFlush(), sink_Connect(), sink_Disconnect(), sink_EndFlush(), sink_EndOfStream(), sink_NewSegment(), and sink_ReceiveConnection().

impl_source_from_IPin()

static struct strmbase_source * impl_source_from_IPin ( IPin *  iface )

inlinestatic

Definition at line 443 of file pin.c.

{
    return CONTAINING_RECORD(iface, struct strmbase_source, pin.IPin_iface);
}

Referenced by source_BeginFlush(), source_Connect(), source_Disconnect(), source_EndFlush(), source_EndOfStream(), source_NewSegment(), and source_ReceiveConnection().

MemInputPin_AddRef()

static ULONG WINAPI MemInputPin_AddRef ( IMemInputPin *  iface )

static

Definition at line 1046 of file pin.c.

{
    struct strmbase_sink *This = impl_from_IMemInputPin(iface);
 
    return IPin_AddRef(&This->pin.IPin_iface);
}

MemInputPin_GetAllocator()

static HRESULT WINAPI MemInputPin_GetAllocator ( IMemInputPin *  iface, IMemAllocator **  ppAllocator  )

static

Definition at line 1060 of file pin.c.

{
    struct strmbase_sink *This = impl_from_IMemInputPin(iface);
 
    TRACE("pin %p %s:%s, allocator %p.\n", This, debugstr_w(This->pin.filter->name),
            debugstr_w(This->pin.name), ppAllocator);
 
    *ppAllocator = This->pAllocator;
    if (*ppAllocator)
        IMemAllocator_AddRef(*ppAllocator);
 
    return *ppAllocator ? S_OK : VFW_E_NO_ALLOCATOR;
}

MemInputPin_GetAllocatorRequirements()

static HRESULT WINAPI MemInputPin_GetAllocatorRequirements ( IMemInputPin *  iface, ALLOCATOR_PROPERTIES *  props  )

static

Definition at line 1103 of file pin.c.

{
    struct strmbase_sink *pin = impl_from_IMemInputPin(iface);
 
    TRACE("pin %p %s:%s, props %p.\n", pin, debugstr_w(pin->pin.filter->name),
            debugstr_w(pin->pin.name), props);
 
    /* override this method if you have any specific requirements */
 
    return E_NOTIMPL;
}

MemInputPin_NotifyAllocator()

static HRESULT WINAPI MemInputPin_NotifyAllocator ( IMemInputPin *  iface, IMemAllocator *  pAllocator, BOOL  bReadOnly  )

static

Definition at line 1074 of file pin.c.

{
    struct strmbase_sink *This = impl_from_IMemInputPin(iface);
 
    TRACE("pin %p %s:%s, allocator %p, read_only %d.\n", This, debugstr_w(This->pin.filter->name),
            debugstr_w(This->pin.name), pAllocator, bReadOnly);
 
    if (bReadOnly)
        FIXME("Read only flag not handled yet!\n");
 
    /* FIXME: Should we release the allocator on disconnection? */
    if (!pAllocator)
    {
        WARN("Null allocator\n");
        return E_POINTER;
    }
 
    if (This->preferred_allocator && pAllocator != This->preferred_allocator)
        return E_FAIL;
 
    if (This->pAllocator)
        IMemAllocator_Release(This->pAllocator);
    This->pAllocator = pAllocator;
    if (This->pAllocator)
        IMemAllocator_AddRef(This->pAllocator);
 
    return S_OK;
}

MemInputPin_QueryInterface()

static HRESULT WINAPI MemInputPin_QueryInterface ( IMemInputPin *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 1039 of file pin.c.

{
    struct strmbase_sink *This = impl_from_IMemInputPin(iface);
 
    return IPin_QueryInterface(&This->pin.IPin_iface, riid, ppv);
}

MemInputPin_Receive()

static HRESULT WINAPI MemInputPin_Receive ( IMemInputPin *  iface, IMediaSample *  sample  )

static

Definition at line 1115 of file pin.c.

{
    struct strmbase_sink *pin = impl_from_IMemInputPin(iface);
    HRESULT hr = S_FALSE;
 
    TRACE("pin %p %s:%s, sample %p.\n", pin, debugstr_w(pin->pin.filter->name),
            debugstr_w(pin->pin.name), sample);
 
    if (pin->pFuncsTable->pfnReceive)
    {
        EnterCriticalSection(&pin->pin.filter->stream_cs);
        hr = pin->pFuncsTable->pfnReceive(pin, sample);
        LeaveCriticalSection(&pin->pin.filter->stream_cs);
    }
    return hr;
}

MemInputPin_ReceiveCanBlock()

static HRESULT WINAPI MemInputPin_ReceiveCanBlock ( IMemInputPin *  iface )

static

Definition at line 1146 of file pin.c.

{
    struct strmbase_sink *pin = impl_from_IMemInputPin(iface);
 
    TRACE("pin %p %s:%s.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 
    return S_OK;
}

MemInputPin_ReceiveMultiple()

static HRESULT WINAPI MemInputPin_ReceiveMultiple ( IMemInputPin *  iface, IMediaSample **  pSamples, LONG  nSamples, LONG *  nSamplesProcessed  )

static

Definition at line 1132 of file pin.c.

{
    HRESULT hr = S_OK;
 
    for (*nSamplesProcessed = 0; *nSamplesProcessed < nSamples; (*nSamplesProcessed)++)
    {
        hr = IMemInputPin_Receive(iface, pSamples[*nSamplesProcessed]);
        if (hr != S_OK)
            break;
    }
 
    return hr;
}

MemInputPin_Release()

static ULONG WINAPI MemInputPin_Release ( IMemInputPin *  iface )

static

Definition at line 1053 of file pin.c.

{
    struct strmbase_sink *This = impl_from_IMemInputPin(iface);
 
    return IPin_Release(&This->pin.IPin_iface);
}

pin_AddRef()

static ULONG WINAPI pin_AddRef ( IPin *  iface )

static

Definition at line 292 of file pin.c.

{
    struct strmbase_pin *pin = impl_from_IPin(iface);
    return IBaseFilter_AddRef(&pin->filter->IBaseFilter_iface);
}

pin_ConnectedTo()

static HRESULT WINAPI pin_ConnectedTo ( IPin *  iface, IPin **  ppPin  )

static

Definition at line 304 of file pin.c.

{
    struct strmbase_pin *This = impl_from_IPin(iface);
    HRESULT hr;
 
    TRACE("pin %p %s:%s, peer %p.\n", This, debugstr_w(This->filter->name), debugstr_w(This->name), ppPin);
 
    EnterCriticalSection(&This->filter->filter_cs);
    {
        if (This->peer)
        {
            *ppPin = This->peer;
            IPin_AddRef(*ppPin);
            hr = S_OK;
        }
        else
        {
            hr = VFW_E_NOT_CONNECTED;
            *ppPin = NULL;
        }
    }
    LeaveCriticalSection(&This->filter->filter_cs);
 
    return hr;
}

pin_ConnectionMediaType()

static HRESULT WINAPI pin_ConnectionMediaType ( IPin *  iface, AM_MEDIA_TYPE *  pmt  )

static

Definition at line 330 of file pin.c.

{
    struct strmbase_pin *This = impl_from_IPin(iface);
    HRESULT hr;
 
    TRACE("pin %p %s:%s, pmt %p.\n", This, debugstr_w(This->filter->name), debugstr_w(This->name), pmt);
 
    EnterCriticalSection(&This->filter->filter_cs);
    {
        if (This->peer)
        {
            CopyMediaType(pmt, &This->mt);
            strmbase_dump_media_type(pmt);
            hr = S_OK;
        }
        else
        {
            ZeroMemory(pmt, sizeof(*pmt));
            hr = VFW_E_NOT_CONNECTED;
        }
    }
    LeaveCriticalSection(&This->filter->filter_cs);
 
    return hr;
}

pin_EnumMediaTypes()

static HRESULT WINAPI pin_EnumMediaTypes ( IPin *  iface, IEnumMediaTypes **  enum_media_types  )

static

Definition at line 411 of file pin.c.

{
    struct strmbase_pin *pin = impl_from_IPin(iface);
    AM_MEDIA_TYPE mt;
    HRESULT hr;
 
    TRACE("pin %p %s:%s, enum_media_types %p.\n", pin, debugstr_w(pin->filter->name),
            debugstr_w(pin->name), enum_media_types);
 
    if (pin->ops->pin_get_media_type)
    {
        if (FAILED(hr = pin->ops->pin_get_media_type(pin, 0, &mt)))
            return hr;
        if (hr == S_OK)
            FreeMediaType(&mt);
    }
 
    return enum_media_types_create(pin, enum_media_types);
}

pin_QueryAccept()

static HRESULT WINAPI pin_QueryAccept ( IPin *  iface, const AM_MEDIA_TYPE *  mt  )

static

Definition at line 401 of file pin.c.

{
    struct strmbase_pin *pin = impl_from_IPin(iface);
 
    TRACE("pin %p %s:%s, mt %p.\n", pin, debugstr_w(pin->filter->name), debugstr_w(pin->name), mt);
    strmbase_dump_media_type(mt);
 
    return query_accept(pin, mt) ? S_OK : S_FALSE;
}

pin_QueryDirection()

static HRESULT WINAPI pin_QueryDirection ( IPin *  iface, PIN_DIRECTION *  dir  )

static

Definition at line 369 of file pin.c.

{
    struct strmbase_pin *pin = impl_from_IPin(iface);
 
    TRACE("pin %p %s:%s, dir %p.\n", pin, debugstr_w(pin->filter->name), debugstr_w(pin->name), dir);
 
    *dir = pin->dir;
 
    return S_OK;
}

pin_QueryId()

static HRESULT WINAPI pin_QueryId ( IPin *  iface, WCHAR **  id  )

static

Definition at line 380 of file pin.c.

{
    struct strmbase_pin *pin = impl_from_IPin(iface);
 
    TRACE("pin %p %s:%s, id %p.\n", pin, debugstr_w(pin->filter->name), debugstr_w(pin->name), id);
 
    if (!(*id = CoTaskMemAlloc((lstrlenW(pin->id) + 1) * sizeof(WCHAR))))
        return E_OUTOFMEMORY;
 
    lstrcpyW(*id, pin->id);
 
    return S_OK;
}

pin_QueryInterface()

static HRESULT WINAPI pin_QueryInterface ( IPin *  iface, REFIID  iid, void **  out  )

static

Definition at line 268 of file pin.c.

{
    struct strmbase_pin *pin = impl_from_IPin(iface);
    HRESULT hr;
 
    TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 
    *out = NULL;
 
    if (pin->ops->pin_query_interface && SUCCEEDED(hr = pin->ops->pin_query_interface(pin, iid, out)))
        return hr;
 
    if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_IPin))
        *out = iface;
    else
    {
        WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown *)*out);
    return S_OK;
}

pin_QueryInternalConnections()

static HRESULT WINAPI pin_QueryInternalConnections ( IPin *  iface, IPin **  pins, ULONG *  count  )

static

Definition at line 431 of file pin.c.

{
    struct strmbase_pin *pin = impl_from_IPin(iface);
 
    TRACE("pin %p %s:%s, pins %p, count %p.\n", pin, debugstr_w(pin->filter->name),
            debugstr_w(pin->name), pins, count);
 
    return E_NOTIMPL; /* to tell caller that all input pins connected to all output pins */
}

pin_QueryPinInfo()

static HRESULT WINAPI pin_QueryPinInfo ( IPin *  iface, PIN_INFO *  info  )

static

Definition at line 356 of file pin.c.

{
    struct strmbase_pin *pin = impl_from_IPin(iface);
 
    TRACE("pin %p %s:%s, info %p.\n", pin, debugstr_w(pin->filter->name), debugstr_w(pin->name), info);
 
    info->dir = pin->dir;
    IBaseFilter_AddRef(info->pFilter = &pin->filter->IBaseFilter_iface);
    lstrcpyW(info->achName, pin->name);
 
    return S_OK;
}

pin_Release()

static ULONG WINAPI pin_Release ( IPin *  iface )

static

Definition at line 298 of file pin.c.

{
    struct strmbase_pin *pin = impl_from_IPin(iface);
    return IBaseFilter_Release(&pin->filter->IBaseFilter_iface);
}

query_accept()

static BOOL query_accept ( struct strmbase_pin *  pin, const AM_MEDIA_TYPE *  mt  )

static

Definition at line 394 of file pin.c.

{
    if (pin->ops->pin_query_accept && pin->ops->pin_query_accept(pin, mt) != S_OK)
        return FALSE;
    return TRUE;
}

Referenced by BaseOutputPinImpl_AttemptConnection(), pin_QueryAccept(), and sink_ReceiveConnection().

SendFurther()

static HRESULT SendFurther ( struct strmbase_sink *  sink, SendPinFunc  func, void *  arg  )

static

Sends a message from a pin further to other, similar pins fnMiddle is called on each pin found further on the stream. fnEnd (can be NULL) is called when the message can't be sent any further (this is a renderer or source)

If the pin given is an input pin, the message will be sent downstream to other input pins If the pin given is an output pin, the message will be sent upstream to other output pins

Definition at line 253 of file pin.c.

{
    struct strmbase_pin *pin;
    HRESULT hr = S_OK;
    unsigned int i;
 
    for (i = 0; (pin = sink->pin.filter->ops->filter_get_pin(sink->pin.filter, i)); ++i)
    {
        if (pin->dir == PINDIR_OUTPUT && pin->peer)
            hr = updatehres(hr, func(pin->peer, arg));
    }
 
    return hr;
}

Referenced by sink_BeginFlush(), sink_EndFlush(), sink_EndOfStream(), and sink_NewSegment().

sink_BeginFlush()

static HRESULT WINAPI sink_BeginFlush ( IPin *  iface )

static

Definition at line 933 of file pin.c.

{
    struct strmbase_sink *pin = impl_sink_from_IPin(iface);
    HRESULT hr;
 
    TRACE("pin %p %s:%s.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 
    EnterCriticalSection(&pin->pin.filter->filter_cs);
 
    pin->flushing = TRUE;
 
    if (pin->pFuncsTable->sink_begin_flush)
        hr = pin->pFuncsTable->sink_begin_flush(pin);
    else
        hr = SendFurther(pin, deliver_beginflush, NULL);
 
    LeaveCriticalSection(&pin->pin.filter->filter_cs);
 
    return hr;
}

sink_Connect()

static HRESULT WINAPI sink_Connect ( IPin *  iface, IPin *  peer, const AM_MEDIA_TYPE *  mt  )

static

Definition at line 791 of file pin.c.

{
    struct strmbase_sink *pin = impl_sink_from_IPin(iface);
 
    WARN("pin %p %s:%s, peer %p, mt %p, unexpected call.\n", pin, debugstr_w(pin->pin.name),
            debugstr_w(pin->pin.filter->name), peer, mt);
 
    return E_UNEXPECTED;
}

sink_Disconnect()

static HRESULT WINAPI sink_Disconnect ( IPin *  iface )

static

Definition at line 857 of file pin.c.

{
    struct strmbase_sink *pin = impl_sink_from_IPin(iface);
    HRESULT hr;
 
    TRACE("pin %p %s:%s.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 
    EnterCriticalSection(&pin->pin.filter->filter_cs);
 
    if (pin->pin.filter->state != State_Stopped)
    {
        LeaveCriticalSection(&pin->pin.filter->filter_cs);
        WARN("Filter is not stopped; returning VFW_E_NOT_STOPPED.\n");
        return VFW_E_NOT_STOPPED;
    }
 
    if (pin->pin.peer)
    {
        if (pin->pFuncsTable->sink_disconnect)
            pin->pFuncsTable->sink_disconnect(pin);
 
        if (pin->pAllocator)
        {
            IMemAllocator_Release(pin->pAllocator);
            pin->pAllocator = NULL;
        }
 
        IPin_Release(pin->pin.peer);
        pin->pin.peer = NULL;
        FreeMediaType(&pin->pin.mt);
        memset(&pin->pin.mt, 0, sizeof(AM_MEDIA_TYPE));
        hr = S_OK;
    }
    else
        hr = S_FALSE;
 
    LeaveCriticalSection(&pin->pin.filter->filter_cs);
 
    return hr;
}

sink_EndFlush()

static HRESULT WINAPI sink_EndFlush ( IPin *  iface )

static

Definition at line 959 of file pin.c.

{
    struct strmbase_sink *pin = impl_sink_from_IPin(iface);
    HRESULT hr;
 
    TRACE("pin %p %s:%s.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 
    EnterCriticalSection(&pin->pin.filter->filter_cs);
 
    pin->flushing = FALSE;
 
    if (pin->pFuncsTable->sink_end_flush)
        hr = pin->pFuncsTable->sink_end_flush(pin);
    else
        hr = SendFurther(pin, deliver_endflush, NULL);
 
    LeaveCriticalSection(&pin->pin.filter->filter_cs);
 
    return hr;
}

sink_EndOfStream()

static HRESULT WINAPI sink_EndOfStream ( IPin *  iface )

static

Definition at line 903 of file pin.c.

{
    struct strmbase_sink *pin = impl_sink_from_IPin(iface);
    HRESULT hr = S_OK;
 
    TRACE("pin %p %s:%s.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 
    if (pin->pFuncsTable->sink_eos)
    {
        EnterCriticalSection(&pin->pin.filter->stream_cs);
        hr = pin->pFuncsTable->sink_eos(pin);
        LeaveCriticalSection(&pin->pin.filter->stream_cs);
        return hr;
    }
 
    EnterCriticalSection(&pin->pin.filter->filter_cs);
    if (pin->flushing)
        hr = S_FALSE;
    LeaveCriticalSection(&pin->pin.filter->filter_cs);
 
    if (hr == S_OK)
        hr = SendFurther(pin, deliver_endofstream, NULL);
    return hr;
}

sink_NewSegment()

static HRESULT WINAPI sink_NewSegment ( IPin *  iface, REFERENCE_TIME  start, REFERENCE_TIME  stop, double  rate  )

static

Definition at line 992 of file pin.c.

{
    struct strmbase_sink *pin = impl_sink_from_IPin(iface);
    newsegmentargs args;
 
    TRACE("pin %p %s:%s, start %s, stop %s, rate %.16e.\n", pin, debugstr_w(pin->pin.filter->name),
            debugstr_w(pin->pin.name), debugstr_time(start), debugstr_time(stop), rate);
 
    if (pin->pFuncsTable->sink_new_segment)
        return pin->pFuncsTable->sink_new_segment(pin, start, stop, rate);
 
    args.tStart = start;
    args.tStop = stop;
    args.rate = rate;
 
    return SendFurther(pin, deliver_newsegment, &args);
}

sink_ReceiveConnection()

static HRESULT WINAPI sink_ReceiveConnection ( IPin *  iface, IPin *  pReceivePin, const AM_MEDIA_TYPE *  pmt  )

static

Definition at line 802 of file pin.c.

{
    struct strmbase_sink *This = impl_sink_from_IPin(iface);
    PIN_DIRECTION pindirReceive;
    HRESULT hr = S_OK;
 
    TRACE("pin %p %s:%s, peer %p, mt %p.\n", This, debugstr_w(This->pin.filter->name),
            debugstr_w(This->pin.name), pReceivePin, pmt);
    strmbase_dump_media_type(pmt);
 
    if (!pmt)
        return E_POINTER;
 
    EnterCriticalSection(&This->pin.filter->filter_cs);
    {
        if (This->pin.filter->state != State_Stopped)
        {
            LeaveCriticalSection(&This->pin.filter->filter_cs);
            WARN("Filter is not stopped; returning VFW_E_NOT_STOPPED.\n");
            return VFW_E_NOT_STOPPED;
        }
 
        if (This->pin.peer)
            hr = VFW_E_ALREADY_CONNECTED;
 
        if (SUCCEEDED(hr) && !query_accept(&This->pin, pmt))
            hr = VFW_E_TYPE_NOT_ACCEPTED; /* FIXME: shouldn't we just map common errors onto
                                           * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */
 
        if (SUCCEEDED(hr))
        {
            IPin_QueryDirection(pReceivePin, &pindirReceive);
 
            if (pindirReceive != PINDIR_OUTPUT)
            {
                ERR("Can't connect from non-output pin\n");
                hr = VFW_E_INVALID_DIRECTION;
            }
        }
 
        if (SUCCEEDED(hr) && This->pFuncsTable->sink_connect)
            hr = This->pFuncsTable->sink_connect(This, pReceivePin, pmt);
 
        if (SUCCEEDED(hr))
        {
            CopyMediaType(&This->pin.mt, pmt);
            This->pin.peer = pReceivePin;
            IPin_AddRef(pReceivePin);
        }
    }
    LeaveCriticalSection(&This->pin.filter->filter_cs);
 
    return hr;
}

source_BeginFlush()

static HRESULT WINAPI source_BeginFlush ( IPin *  iface )

static

Definition at line 626 of file pin.c.

{
    struct strmbase_source *pin = impl_source_from_IPin(iface);
 
    WARN("pin %p %s:%s, unexpected call.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 
    /* not supposed to do anything in an output pin */
 
    return E_UNEXPECTED;
}

source_Connect()

static HRESULT WINAPI source_Connect ( IPin *  iface, IPin *  peer, const AM_MEDIA_TYPE *  mt  )

static

Definition at line 468 of file pin.c.

{
    struct strmbase_source *pin = impl_source_from_IPin(iface);
    AM_MEDIA_TYPE candidate, *candidate_ptr;
    IEnumMediaTypes *enummt;
    PIN_DIRECTION dir;
    unsigned int i;
    ULONG count;
    HRESULT hr;
 
    TRACE("pin %p %s:%s, peer %p, mt %p.\n", pin, debugstr_w(pin->pin.filter->name),
            debugstr_w(pin->pin.name), peer, mt);
    strmbase_dump_media_type(mt);
 
    if (!peer)
        return E_POINTER;
 
    IPin_QueryDirection(peer, &dir);
    if (dir != PINDIR_INPUT)
    {
        WARN("Attempt to connect to another source pin, returning VFW_E_INVALID_DIRECTION.\n");
        return VFW_E_INVALID_DIRECTION;
    }
 
    EnterCriticalSection(&pin->pin.filter->filter_cs);
 
    if (pin->pin.peer)
    {
        LeaveCriticalSection(&pin->pin.filter->filter_cs);
        WARN("Pin is already connected, returning VFW_E_ALREADY_CONNECTED.\n");
        return VFW_E_ALREADY_CONNECTED;
    }
 
    if (pin->pin.filter->state != State_Stopped)
    {
        LeaveCriticalSection(&pin->pin.filter->filter_cs);
        WARN("Filter is not stopped; returning VFW_E_NOT_STOPPED.\n");
        return VFW_E_NOT_STOPPED;
    }
 
    /* We don't check the subtype here. The rationale (as given by the DirectX
     * documentation) is that the format type is supposed to provide at least
     * as much information as the subtype. */
    if (mt && !IsEqualGUID(&mt->majortype, &GUID_NULL)
            && !IsEqualGUID(&mt->formattype, &GUID_NULL))
    {
        hr = pin->pFuncsTable->pfnAttemptConnection(pin, peer, mt);
        LeaveCriticalSection(&pin->pin.filter->filter_cs);
        return hr;
    }
 
    if (SUCCEEDED(IPin_EnumMediaTypes(peer, &enummt)))
    {
        while (IEnumMediaTypes_Next(enummt, 1, &candidate_ptr, &count) == S_OK)
        {
            if (compare_media_types(mt, candidate_ptr)
                    && pin->pFuncsTable->pfnAttemptConnection(pin, peer, candidate_ptr) == S_OK)
            {
                LeaveCriticalSection(&pin->pin.filter->filter_cs);
                DeleteMediaType(candidate_ptr);
                IEnumMediaTypes_Release(enummt);
                return S_OK;
            }
            DeleteMediaType(candidate_ptr);
        }
 
        IEnumMediaTypes_Release(enummt);
    }
 
    if (pin->pFuncsTable->base.pin_get_media_type)
    {
        for (i = 0; pin->pFuncsTable->base.pin_get_media_type(&pin->pin, i, &candidate) == S_OK; ++i)
        {
            strmbase_dump_media_type(&candidate);
            if (compare_media_types(mt, &candidate)
                    && pin->pFuncsTable->pfnAttemptConnection(pin, peer, &candidate) == S_OK)
            {
                LeaveCriticalSection(&pin->pin.filter->filter_cs);
                FreeMediaType(&candidate);
                return S_OK;
            }
            FreeMediaType(&candidate);
        }
    }
 
    LeaveCriticalSection(&pin->pin.filter->filter_cs);
 
    return VFW_E_NO_ACCEPTABLE_TYPES;
}

source_Disconnect()

static HRESULT WINAPI source_Disconnect ( IPin *  iface )

static

Definition at line 568 of file pin.c.

{
    HRESULT hr;
    struct strmbase_source *This = impl_source_from_IPin(iface);
 
    TRACE("pin %p %s:%s.\n", This, debugstr_w(This->pin.filter->name), debugstr_w(This->pin.name));
 
    EnterCriticalSection(&This->pin.filter->filter_cs);
    {
        if (This->pin.filter->state != State_Stopped)
        {
            LeaveCriticalSection(&This->pin.filter->filter_cs);
            WARN("Filter is not stopped; returning VFW_E_NOT_STOPPED.\n");
            return VFW_E_NOT_STOPPED;
        }
 
        if (This->pFuncsTable->source_disconnect)
            This->pFuncsTable->source_disconnect(This);
 
        if (This->pMemInputPin)
        {
            IMemInputPin_Release(This->pMemInputPin);
            This->pMemInputPin = NULL;
        }
 
        if (This->pAllocator)
        {
            IMemAllocator_Release(This->pAllocator);
            This->pAllocator = NULL;
        }
 
        if (This->pin.peer)
        {
            IPin_Release(This->pin.peer);
            This->pin.peer = NULL;
            FreeMediaType(&This->pin.mt);
            ZeroMemory(&This->pin.mt, sizeof(This->pin.mt));
            hr = S_OK;
        }
        else
            hr = S_FALSE;
    }
    LeaveCriticalSection(&This->pin.filter->filter_cs);
 
    return hr;
}

source_EndFlush()

static HRESULT WINAPI source_EndFlush ( IPin *  iface )

static

Definition at line 637 of file pin.c.

{
    struct strmbase_source *pin = impl_source_from_IPin(iface);
 
    WARN("pin %p %s:%s, unexpected call.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 
    /* not supposed to do anything in an output pin */
 
    return E_UNEXPECTED;
}

source_EndOfStream()

static HRESULT WINAPI source_EndOfStream ( IPin *  iface )

static

Definition at line 615 of file pin.c.

{
    struct strmbase_source *pin = impl_source_from_IPin(iface);
 
    WARN("pin %p %s:%s, unexpected call.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 
    /* not supposed to do anything in an output pin */
 
    return E_UNEXPECTED;
}

source_NewSegment()

static HRESULT WINAPI source_NewSegment ( IPin *  iface, REFERENCE_TIME  start, REFERENCE_TIME  stop, double  rate  )

static

Definition at line 648 of file pin.c.

{
    struct strmbase_source *pin = impl_source_from_IPin(iface);
 
    TRACE("pin %p %s:%s, start %s, stop %s, rate %.16e.\n", pin, debugstr_w(pin->pin.filter->name),
            debugstr_w(pin->pin.name), debugstr_time(start), debugstr_time(stop), rate);
 
    return S_OK;
}

source_ReceiveConnection()

static HRESULT WINAPI source_ReceiveConnection ( IPin *  iface, IPin *  peer, const AM_MEDIA_TYPE *  mt  )

static

Definition at line 558 of file pin.c.

{
    struct strmbase_source *pin = impl_source_from_IPin(iface);
 
    WARN("pin %p %s:%s, peer %p, mt %p, unexpected call.\n", pin,
            debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name), peer, mt);
 
    return E_UNEXPECTED;
}

strmbase_sink_cleanup()

void strmbase_sink_cleanup

(

struct strmbase_sink *

pin

)

Definition at line 1185 of file pin.c.

{
    FreeMediaType(&pin->pin.mt);
    if (pin->pAllocator)
        IMemAllocator_Release(pin->pAllocator);
    pin->pAllocator = NULL;
    pin->pin.IPin_iface.lpVtbl = NULL;
}

Referenced by acm_wrapper_destroy(), avi_compressor_destroy(), avi_decompressor_destroy(), avi_mux_destroy(), create_input_pin(), dsound_render_destroy(), file_writer_destroy(), sample_grabber_destroy(), smart_tee_destroy(), strmbase_renderer_cleanup(), testfilter_destroy(), and testsink_destroy().

strmbase_sink_init()

void strmbase_sink_init	(	struct strmbase_sink *	pin,
		struct strmbase_filter *	filter,
		const WCHAR *	name,
		const struct strmbase_sink_ops *	func_table,
		IMemAllocator *	allocator
	)

Definition at line 1168 of file pin.c.

{
    memset(pin, 0, sizeof(*pin));
    pin->pin.IPin_iface.lpVtbl = &sink_vtbl;
    pin->pin.filter = filter;
    pin->pin.dir = PINDIR_INPUT;
    lstrcpyW(pin->pin.name, name);
    lstrcpyW(pin->pin.id, name);
    pin->pin.ops = &func_table->base;
    pin->pFuncsTable = func_table;
    pin->pAllocator = pin->preferred_allocator = allocator;
    if (pin->preferred_allocator)
        IMemAllocator_AddRef(pin->preferred_allocator);
    pin->IMemInputPin_iface.lpVtbl = &MemInputPin_Vtbl;
}

Referenced by acm_wrapper_create(), avi_compressor_create(), avi_dec_create(), create_input_pin(), dsound_render_create(), file_writer_create(), sample_grabber_create(), smart_tee_create(), strmbase_renderer_init(), testfilter_init(), and testsink_init().

strmbase_source_cleanup()

void strmbase_source_cleanup

(

struct strmbase_source *

pin

)

Definition at line 778 of file pin.c.

{
    FreeMediaType(&pin->pin.mt);
    if (pin->pAllocator)
        IMemAllocator_Release(pin->pAllocator);
    pin->pAllocator = NULL;
}

Referenced by acm_wrapper_destroy(), async_reader_destroy(), audio_record_destroy(), avi_compressor_destroy(), avi_decompressor_destroy(), avi_mux_create(), avi_mux_destroy(), sample_grabber_destroy(), smart_tee_destroy(), testfilter_destroy(), and vfw_capture_destroy().

strmbase_source_init()

void strmbase_source_init	(	struct strmbase_source *	pin,
		struct strmbase_filter *	filter,
		const WCHAR *	name,
		const struct strmbase_source_ops *	func_table
	)

Definition at line 765 of file pin.c.

{
    memset(pin, 0, sizeof(*pin));
    pin->pin.IPin_iface.lpVtbl = &source_vtbl;
    pin->pin.filter = filter;
    pin->pin.dir = PINDIR_OUTPUT;
    lstrcpyW(pin->pin.name, name);
    lstrcpyW(pin->pin.id, name);
    pin->pin.ops = &func_table->base;
    pin->pFuncsTable = func_table;
}

Referenced by acm_wrapper_create(), audio_record_create(), avi_compressor_create(), avi_dec_create(), avi_mux_create(), FileSource_Load(), sample_grabber_create(), smart_tee_create(), testfilter_init(), and vfw_capture_create().

updatehres()

static HRESULT updatehres ( HRESULT  original, HRESULT  new  )

static

Helper function, there are a lot of places where the error code is inherited The following rules apply:

Return the first received error code (E_NOTIMPL is ignored) If no errors occur: return the first received non-error-code that isn't S_OK

Definition at line 235 of file pin.c.

{
    if (FAILED( original ) || new == E_NOTIMPL)
        return original;
 
    if (FAILED( new ) || original == S_OK)
        return new;
 
    return original;
}

Referenced by SendFurther().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

quartz

)

Variable Documentation

enum_media_types_vtbl

static const IEnumMediaTypesVtbl enum_media_types_vtbl

static

Initial value:

=
{
    enum_media_types_QueryInterface,
    enum_media_types_AddRef,
    enum_media_types_Release,
    enum_media_types_Next,
    enum_media_types_Skip,
    enum_media_types_Reset,
    enum_media_types_Clone,
}

Definition at line 39 of file pin.c.

Referenced by enum_media_types_create().

MemInputPin_Vtbl

static const IMemInputPinVtbl MemInputPin_Vtbl

static

Initial value:

=
{
    MemInputPin_QueryInterface,
    MemInputPin_AddRef,
    MemInputPin_Release,
    MemInputPin_GetAllocator,
    MemInputPin_NotifyAllocator,
    MemInputPin_GetAllocatorRequirements,
    MemInputPin_Receive,
    MemInputPin_ReceiveMultiple,
    MemInputPin_ReceiveCanBlock
}

Definition at line 26 of file pin.c.

Referenced by strmbase_sink_init().

sink_vtbl

const IPinVtbl sink_vtbl

static

Initial value:

=
{
    pin_QueryInterface,
    pin_AddRef,
    pin_Release,
    sink_Connect,
    sink_ReceiveConnection,
    sink_Disconnect,
    pin_ConnectedTo,
    pin_ConnectionMediaType,
    pin_QueryPinInfo,
    pin_QueryDirection,
    pin_QueryId,
    pin_QueryAccept,
    pin_EnumMediaTypes,
    pin_QueryInternalConnections,
    sink_EndOfStream,
    sink_BeginFlush,
    sink_EndFlush,
    sink_NewSegment,
}

Definition at line 1010 of file pin.c.

Referenced by strmbase_sink_init().

source_vtbl

const IPinVtbl source_vtbl

static

Initial value:

=
{
    pin_QueryInterface,
    pin_AddRef,
    pin_Release,
    source_Connect,
    source_ReceiveConnection,
    source_Disconnect,
    pin_ConnectedTo,
    pin_ConnectionMediaType,
    pin_QueryPinInfo,
    pin_QueryDirection,
    pin_QueryId,
    pin_QueryAccept,
    pin_EnumMediaTypes,
    pin_QueryInternalConnections,
    source_EndOfStream,
    source_BeginFlush,
    source_EndFlush,
    source_NewSegment,
}

Definition at line 658 of file pin.c.

Referenced by strmbase_source_init().