filter.c File Reference

#include "amstream_private.h"
#include "wine/debug.h"
#include "wine/list.h"

Include dependency graph for filter.c:

Go to the source code of this file.

Classes
struct	enum_pins
struct	filter
struct	event

Macros
#define	COBJMACROS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (quartz)
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 filter *	impl_from_IMediaStreamFilter (IMediaStreamFilter *iface)
static HRESULT WINAPI	filter_QueryInterface (IMediaStreamFilter *iface, REFIID iid, void **out)
static ULONG WINAPI	filter_AddRef (IMediaStreamFilter *iface)
static ULONG WINAPI	filter_Release (IMediaStreamFilter *iface)
static HRESULT WINAPI	filter_GetClassID (IMediaStreamFilter *iface, CLSID *clsid)
static void	send_ec_complete (struct filter *filter)
static void	set_state (struct filter *filter, FILTER_STATE state)
static HRESULT WINAPI	filter_Stop (IMediaStreamFilter *iface)
static HRESULT WINAPI	filter_Pause (IMediaStreamFilter *iface)
static HRESULT WINAPI	filter_Run (IMediaStreamFilter *iface, REFERENCE_TIME start)
static HRESULT WINAPI	filter_GetState (IMediaStreamFilter *iface, DWORD timeout, FILTER_STATE *state)
static HRESULT WINAPI	filter_SetSyncSource (IMediaStreamFilter *iface, IReferenceClock *clock)
static HRESULT WINAPI	filter_GetSyncSource (IMediaStreamFilter *iface, IReferenceClock **clock)
static HRESULT WINAPI	filter_EnumPins (IMediaStreamFilter *iface, IEnumPins **enum_pins)
static HRESULT WINAPI	filter_FindPin (IMediaStreamFilter *iface, const WCHAR *id, IPin **out)
static HRESULT WINAPI	filter_QueryFilterInfo (IMediaStreamFilter *iface, FILTER_INFO *info)
static HRESULT WINAPI	filter_JoinFilterGraph (IMediaStreamFilter *iface, IFilterGraph *graph, const WCHAR *name)
static HRESULT WINAPI	filter_QueryVendorInfo (IMediaStreamFilter *iface, LPWSTR *vendor_info)
static HRESULT WINAPI	filter_AddMediaStream (IMediaStreamFilter *iface, IAMMediaStream *pAMMediaStream)
static HRESULT WINAPI	filter_GetMediaStream (IMediaStreamFilter *iface, REFMSPID idPurpose, IMediaStream **ppMediaStream)
static HRESULT WINAPI	filter_EnumMediaStreams (IMediaStreamFilter *iface, LONG index, IMediaStream **stream)
static IMediaSeeking *	get_seeking (IAMMediaStream *stream)
static HRESULT WINAPI	filter_SupportSeeking (IMediaStreamFilter *iface, BOOL renderer)
static HRESULT WINAPI	filter_ReferenceTimeToStreamTime (IMediaStreamFilter *iface, REFERENCE_TIME *time)
static HRESULT WINAPI	filter_GetCurrentStreamTime (IMediaStreamFilter *iface, REFERENCE_TIME *time)
static HRESULT WINAPI	filter_WaitUntil (IMediaStreamFilter *iface, REFERENCE_TIME time)
static HRESULT WINAPI	filter_Flush (IMediaStreamFilter *iface, BOOL cancel_eos)
static HRESULT WINAPI	filter_EndOfStream (IMediaStreamFilter *iface)
static struct filter *	impl_from_IMediaSeeking (IMediaSeeking *iface)
static HRESULT WINAPI	filter_seeking_QueryInterface (IMediaSeeking *iface, REFIID iid, void **out)
static ULONG WINAPI	filter_seeking_AddRef (IMediaSeeking *iface)
static ULONG WINAPI	filter_seeking_Release (IMediaSeeking *iface)
static HRESULT WINAPI	filter_seeking_GetCapabilities (IMediaSeeking *iface, DWORD *capabilities)
static HRESULT WINAPI	filter_seeking_CheckCapabilities (IMediaSeeking *iface, DWORD *capabilities)
static HRESULT WINAPI	filter_seeking_IsFormatSupported (IMediaSeeking *iface, const GUID *format)
static HRESULT WINAPI	filter_seeking_QueryPreferredFormat (IMediaSeeking *iface, GUID *format)
static HRESULT WINAPI	filter_seeking_GetTimeFormat (IMediaSeeking *iface, GUID *format)
static HRESULT WINAPI	filter_seeking_IsUsingTimeFormat (IMediaSeeking *iface, const GUID *format)
static HRESULT WINAPI	filter_seeking_SetTimeFormat (IMediaSeeking *iface, const GUID *format)
static HRESULT WINAPI	filter_seeking_GetDuration (IMediaSeeking *iface, LONGLONG *duration)
static HRESULT WINAPI	filter_seeking_GetStopPosition (IMediaSeeking *iface, LONGLONG *stop)
static HRESULT WINAPI	filter_seeking_GetCurrentPosition (IMediaSeeking *iface, LONGLONG *current)
static HRESULT WINAPI	filter_seeking_ConvertTimeFormat (IMediaSeeking *iface, LONGLONG *target, const GUID *target_format, LONGLONG source, const GUID *source_format)
static HRESULT WINAPI	filter_seeking_SetPositions (IMediaSeeking *iface, LONGLONG *current_ptr, DWORD current_flags, LONGLONG *stop_ptr, DWORD stop_flags)
static HRESULT WINAPI	filter_seeking_GetPositions (IMediaSeeking *iface, LONGLONG *current, LONGLONG *stop)
static HRESULT WINAPI	filter_seeking_GetAvailable (IMediaSeeking *iface, LONGLONG *earliest, LONGLONG *latest)
static HRESULT WINAPI	filter_seeking_SetRate (IMediaSeeking *iface, double rate)
static HRESULT WINAPI	filter_seeking_GetRate (IMediaSeeking *iface, double *rate)
static HRESULT WINAPI	filter_seeking_GetPreroll (IMediaSeeking *iface, LONGLONG *preroll)
HRESULT	filter_create (IUnknown *outer, void **out)

Variables
static const IEnumPinsVtbl	enum_pins_vtbl
static const IMediaStreamFilterVtbl	filter_vtbl
static const IMediaSeekingVtbl	filter_seeking_vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 21 of file filter.c.

Function Documentation

enum_pins_AddRef()

static ULONG WINAPI enum_pins_AddRef ( IEnumPins *  iface )

static

Definition at line 60 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 126 of file filter.c.

{
    struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
    struct enum_pins *object;
    unsigned int i;
 
    TRACE("iface %p, out %p.\n", iface, out);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IEnumPins_iface.lpVtbl = &enum_pins_vtbl;
    object->refcount = 1;
    object->count = enum_pins->count;
    object->index = enum_pins->index;
    if (!(object->pins = malloc(enum_pins->count * sizeof(*object->pins))))
    {
        free(object);
        return E_OUTOFMEMORY;
    }
    for (i = 0; i < enum_pins->count; ++i)
        IPin_AddRef(object->pins[i] = enum_pins->pins[i]);
 
    *out = &object->IEnumPins_iface;
    return S_OK;
}

enum_pins_Next()

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

static

Definition at line 85 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 || (count > 1 && !ret_count))
        return E_POINTER;
 
    for (i = 0; i < count && enum_pins->index < enum_pins->count; ++i)
    {
        IPin_AddRef(pins[i] = enum_pins->pins[enum_pins->index]);
        enum_pins->index++;
    }
 
    if (ret_count) *ret_count = 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 44 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 68 of file filter.c.

{
    struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
    ULONG refcount = InterlockedDecrement(&enum_pins->refcount);
    unsigned int i;
 
    TRACE("%p decreasing refcount to %lu.\n", enum_pins, refcount);
    if (!refcount)
    {
        for (i = 0; i < enum_pins->count; ++i)
            IPin_Release(enum_pins->pins[i]);
        free(enum_pins->pins);
        free(enum_pins);
    }
    return refcount;
}

enum_pins_Reset()

static HRESULT WINAPI enum_pins_Reset ( IEnumPins *  iface )

static

Definition at line 116 of file filter.c.

{
    struct enum_pins *enum_pins = impl_from_IEnumPins(iface);
 
    TRACE("iface %p.\n", iface);
 
    enum_pins->index = 0;
    return S_OK;
}

enum_pins_Skip()

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

static

Definition at line 105 of file filter.c.

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

filter_AddMediaStream()

static HRESULT WINAPI filter_AddMediaStream ( IMediaStreamFilter *  iface, IAMMediaStream *  pAMMediaStream  )

static

Definition at line 540 of file filter.c.

{
    struct filter *This = impl_from_IMediaStreamFilter(iface);
    IAMMediaStream** streams;
    HRESULT hr;
 
    TRACE("(%p)->(%p)\n", iface, pAMMediaStream);
 
    streams = realloc(This->streams, (This->nb_streams + 1) * sizeof(*streams));
    if (!streams)
        return E_OUTOFMEMORY;
    This->streams = streams;
 
    hr = IAMMediaStream_JoinFilter(pAMMediaStream, iface);
    if (FAILED(hr))
        return hr;
 
    hr = IAMMediaStream_JoinFilterGraph(pAMMediaStream, This->graph);
    if (FAILED(hr))
        return hr;
 
    This->streams[This->nb_streams] = pAMMediaStream;
    This->nb_streams++;
 
    IAMMediaStream_AddRef(pAMMediaStream);
 
    return S_OK;
}

filter_AddRef()

static ULONG WINAPI filter_AddRef ( IMediaStreamFilter *  iface )

static

Definition at line 220 of file filter.c.

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

filter_create()

HRESULT filter_create	(	IUnknown *	outer,
		void **	out
	)

Definition at line 1088 of file filter.c.

{
    struct filter *object;
 
    TRACE("outer %p, out %p.\n", outer, out);
 
    if (outer)
        return CLASS_E_NOAGGREGATION;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IMediaStreamFilter_iface.lpVtbl = &filter_vtbl;
    object->IMediaSeeking_iface.lpVtbl = &filter_seeking_vtbl;
    object->refcount = 1;
    list_init(&object->free_events);
    list_init(&object->used_events);
    InitializeCriticalSectionEx(&object->cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    object->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": MediaStreamFilter.cs");
 
    TRACE("Created media stream filter %p.\n", object);
    *out = &object->IMediaStreamFilter_iface;
    return S_OK;
}

filter_EndOfStream()

static HRESULT WINAPI filter_EndOfStream ( IMediaStreamFilter *  iface )

static

Definition at line 806 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
 
    TRACE("filter %p.\n", filter);
 
    EnterCriticalSection(&filter->cs);
 
    ++filter->eos_count;
    if (filter->state == State_Running && filter->seekable_stream &&
            filter->eos_count == (LONG)filter->nb_streams)
        send_ec_complete(filter);
 
    LeaveCriticalSection(&filter->cs);
 
    return S_OK;
}

filter_EnumMediaStreams()

static HRESULT WINAPI filter_EnumMediaStreams ( IMediaStreamFilter *  iface, LONG  index, IMediaStream **  stream  )

static

Definition at line 594 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
 
    TRACE("filter %p, index %ld, stream %p.\n", filter, index, stream);
 
    if (index >= filter->nb_streams)
        return S_FALSE;
 
    if (!stream)
        return E_POINTER;
 
    IMediaStream_AddRef(*stream = (IMediaStream *)filter->streams[index]);
    return S_OK;
}

filter_EnumPins()

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

static

Definition at line 418 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
    struct enum_pins *object;
    unsigned int i;
 
    TRACE("iface %p, enum_pins %p.\n", iface, enum_pins);
 
    if (!enum_pins)
        return E_POINTER;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    EnterCriticalSection(&filter->cs);
 
    object->IEnumPins_iface.lpVtbl = &enum_pins_vtbl;
    object->refcount = 1;
    object->count = filter->nb_streams;
    object->index = 0;
    if (!(object->pins = malloc(filter->nb_streams * sizeof(*object->pins))))
    {
        free(object);
        LeaveCriticalSection(&filter->cs);
        return E_OUTOFMEMORY;
    }
    for (i = 0; i < filter->nb_streams; ++i)
    {
        if (FAILED(IAMMediaStream_QueryInterface(filter->streams[i], &IID_IPin, (void **)&object->pins[i])))
            WARN("Stream %p does not support IPin.\n", filter->streams[i]);
    }
 
    LeaveCriticalSection(&filter->cs);
 
    *enum_pins = &object->IEnumPins_iface;
    return S_OK;
}

filter_FindPin()

static HRESULT WINAPI filter_FindPin ( IMediaStreamFilter *  iface, const WCHAR *  id, IPin **  out  )

static

Definition at line 456 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
    unsigned int i;
    WCHAR *ret_id;
    IPin *pin;
 
    TRACE("iface %p, id %s, out %p.\n", iface, debugstr_w(id), out);
 
    EnterCriticalSection(&filter->cs);
 
    for (i = 0; i < filter->nb_streams; ++i)
    {
        if (FAILED(IAMMediaStream_QueryInterface(filter->streams[i], &IID_IPin, (void **)&pin)))
        {
            WARN("Stream %p does not support IPin.\n", filter->streams[i]);
            continue;
        }
 
        if (SUCCEEDED(IPin_QueryId(pin, &ret_id)))
        {
            if (!wcscmp(id, ret_id))
            {
                CoTaskMemFree(ret_id);
                *out = pin;
                LeaveCriticalSection(&filter->cs);
                return S_OK;
            }
            CoTaskMemFree(ret_id);
        }
        IPin_Release(pin);
    }
 
    LeaveCriticalSection(&filter->cs);
 
    return VFW_E_NOT_FOUND;
}

filter_Flush()

static HRESULT WINAPI filter_Flush ( IMediaStreamFilter *  iface, BOOL  cancel_eos  )

static

Definition at line 779 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
    struct event *event;
 
    TRACE("filter %p, cancel_eos %d.\n", iface, cancel_eos);
 
    EnterCriticalSection(&filter->cs);
 
    LIST_FOR_EACH_ENTRY(event, &filter->used_events, struct event, entry)
    {
        if (!event->interrupted)
        {
            event->interrupted = TRUE;
            IReferenceClock_Unadvise(filter->clock, event->cookie);
            SetEvent(event->event);
        }
    }
 
    if (cancel_eos)
        --filter->eos_count;
 
    LeaveCriticalSection(&filter->cs);
 
    return S_OK;
}

filter_GetClassID()

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

static

Definition at line 266 of file filter.c.

{
    *clsid = CLSID_MediaStreamFilter;
    return S_OK;
}

filter_GetCurrentStreamTime()

static HRESULT WINAPI filter_GetCurrentStreamTime ( IMediaStreamFilter *  iface, REFERENCE_TIME *  time  )

static

Definition at line 697 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
 
    TRACE("filter %p, time %p.\n", filter, time);
 
    if (!time)
        return E_POINTER;
 
    EnterCriticalSection(&filter->cs);
 
    if (filter->state != State_Running || !filter->clock)
    {
        *time = 0;
        LeaveCriticalSection(&filter->cs);
        return S_FALSE;
    }
 
    IReferenceClock_GetTime(filter->clock, time);
 
    *time -= filter->start_time;
 
    LeaveCriticalSection(&filter->cs);
 
    return S_OK;
}

filter_GetMediaStream()

static HRESULT WINAPI filter_GetMediaStream ( IMediaStreamFilter *  iface, REFMSPID  idPurpose, IMediaStream **  ppMediaStream  )

static

Definition at line 569 of file filter.c.

{
    struct filter *This = impl_from_IMediaStreamFilter(iface);
    MSPID purpose_id;
    unsigned int i;
 
    TRACE("(%p)->(%s,%p)\n", iface, debugstr_guid(idPurpose), ppMediaStream);
 
    if (!ppMediaStream)
        return E_POINTER;
 
    for (i = 0; i < This->nb_streams; i++)
    {
        IAMMediaStream_GetInformation(This->streams[i], &purpose_id, NULL);
        if (IsEqualIID(&purpose_id, idPurpose))
        {
            *ppMediaStream = (IMediaStream *)This->streams[i];
            IMediaStream_AddRef(*ppMediaStream);
            return S_OK;
        }
    }
 
    return MS_E_NOSTREAM;
}

filter_GetState()

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

static

Definition at line 364 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
 
    TRACE("iface %p, timeout %lu, state %p.\n", iface, timeout, state);
 
    if (!state)
        return E_POINTER;
 
    EnterCriticalSection(&filter->cs);
 
    *state = filter->state;
 
    LeaveCriticalSection(&filter->cs);
 
    return S_OK;
}

filter_GetSyncSource()

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

static

Definition at line 401 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
 
    TRACE("iface %p, clock %p.\n", iface, clock);
 
    EnterCriticalSection(&filter->cs);
 
    if (filter->clock)
        IReferenceClock_AddRef(filter->clock);
    *clock = filter->clock;
 
    LeaveCriticalSection(&filter->cs);
 
    return S_OK;
}

filter_JoinFilterGraph()

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

static

Definition at line 512 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
 
    TRACE("iface %p, graph %p, name.%s.\n", iface, graph, debugstr_w(name));
 
    EnterCriticalSection(&filter->cs);
 
    if (name)
        lstrcpynW(filter->name, name, ARRAY_SIZE(filter->name));
    else
        filter->name[0] = 0;
    filter->graph = graph;
 
    LeaveCriticalSection(&filter->cs);
 
    return S_OK;
}

filter_Pause()

static HRESULT WINAPI filter_Pause ( IMediaStreamFilter *  iface )

static

Definition at line 329 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
 
    TRACE("iface %p.\n", iface);
 
    EnterCriticalSection(&filter->cs);
 
    set_state(filter, State_Paused);
 
    LeaveCriticalSection(&filter->cs);
 
    return S_OK;
}

filter_QueryFilterInfo()

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

static

Definition at line 494 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
 
    TRACE("iface %p, info %p.\n", iface, info);
 
    EnterCriticalSection(&filter->cs);
 
    wcscpy(info->achName, filter->name);
    if (filter->graph)
        IFilterGraph_AddRef(filter->graph);
    info->pGraph = filter->graph;
 
    LeaveCriticalSection(&filter->cs);
 
    return S_OK;
}

filter_QueryInterface()

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

static

Definition at line 197 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
 
    TRACE("filter %p, iid %s, out %p.\n", filter, debugstr_guid(iid), out);
 
    *out = NULL;
 
    if (IsEqualGUID(iid, &IID_IUnknown)
            || IsEqualGUID(iid, &IID_IPersist)
            || IsEqualGUID(iid, &IID_IMediaFilter)
            || IsEqualGUID(iid, &IID_IBaseFilter)
            || IsEqualGUID(iid, &IID_IMediaStreamFilter))
        *out = iface;
    else if (IsEqualGUID(iid, &IID_IMediaSeeking) && filter->seekable_stream)
        *out = &filter->IMediaSeeking_iface;
    else
        return E_NOINTERFACE;
 
    IUnknown_AddRef((IUnknown *)*out);
    return S_OK;
}

filter_QueryVendorInfo()

static HRESULT WINAPI filter_QueryVendorInfo ( IMediaStreamFilter *  iface, LPWSTR *  vendor_info  )

static

Definition at line 532 of file filter.c.

{
    WARN("iface %p, vendor_info %p, stub!\n", iface, vendor_info);
    return E_NOTIMPL;
}

filter_ReferenceTimeToStreamTime()

static HRESULT WINAPI filter_ReferenceTimeToStreamTime ( IMediaStreamFilter *  iface, REFERENCE_TIME *  time  )

static

Definition at line 676 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
 
    TRACE("filter %p, time %p.\n", filter, time);
 
    EnterCriticalSection(&filter->cs);
 
    if (!filter->clock)
    {
        LeaveCriticalSection(&filter->cs);
        return S_FALSE;
    }
 
    *time -= filter->start_time;
 
    LeaveCriticalSection(&filter->cs);
 
    return S_OK;
}

filter_Release()

static ULONG WINAPI filter_Release ( IMediaStreamFilter *  iface )

static

Definition at line 230 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
    ULONG refcount = InterlockedDecrement(&filter->refcount);
    unsigned int i;
 
    TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
 
    if (!refcount)
    {
        struct list *entry;
 
        while ((entry = list_head(&filter->free_events)))
        {
            struct event *event = LIST_ENTRY(entry, struct event, entry);
            list_remove(entry);
            CloseHandle(event->event);
            free(event);
        }
        for (i = 0; i < filter->nb_streams; ++i)
        {
            IAMMediaStream_JoinFilter(filter->streams[i], NULL);
            IAMMediaStream_Release(filter->streams[i]);
        }
        free(filter->streams);
        if (filter->clock)
            IReferenceClock_Release(filter->clock);
        if (filter->cs.DebugInfo)
            filter->cs.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&filter->cs);
        free(filter);
    }
 
    return refcount;
}

filter_Run()

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

static

Definition at line 344 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
 
    TRACE("iface %p, start %s.\n", iface, wine_dbgstr_longlong(start));
 
    EnterCriticalSection(&filter->cs);
 
    if (filter->state != State_Running && filter->seekable_stream
            && filter->eos_count == (LONG)filter->nb_streams)
        send_ec_complete(filter);
 
    filter->start_time = start;
    set_state(filter, State_Running);
 
    LeaveCriticalSection(&filter->cs);
 
    return S_OK;
}

filter_seeking_AddRef()

static ULONG WINAPI filter_seeking_AddRef ( IMediaSeeking *  iface )

static

Definition at line 863 of file filter.c.

{
    struct filter *filter = impl_from_IMediaSeeking(iface);
    return IMediaStreamFilter_AddRef(&filter->IMediaStreamFilter_iface);
}

filter_seeking_CheckCapabilities()

static HRESULT WINAPI filter_seeking_CheckCapabilities ( IMediaSeeking *  iface, DWORD *  capabilities  )

static

Definition at line 882 of file filter.c.

{
    FIXME("iface %p, capabilities %p, stub!\n", iface, capabilities);
 
    return E_NOTIMPL;
}

filter_seeking_ConvertTimeFormat()

static HRESULT WINAPI filter_seeking_ConvertTimeFormat ( IMediaSeeking *  iface, LONGLONG *  target, const GUID *  target_format, LONGLONG  source, const GUID *  source_format  )

static

Definition at line 993 of file filter.c.

{
    FIXME("iface %p, target %p, target_format %s, source 0x%s, source_format %s, stub!\n", iface, target, debugstr_guid(target_format),
            wine_dbgstr_longlong(source), debugstr_guid(source_format));
 
    return E_NOTIMPL;
}

filter_seeking_GetAvailable()

static HRESULT WINAPI filter_seeking_GetAvailable ( IMediaSeeking *  iface, LONGLONG *  earliest, LONGLONG *  latest  )

static

Definition at line 1036 of file filter.c.

{
    FIXME("iface %p, earliest %p, latest %p, stub!\n", iface, earliest, latest);
 
    return E_NOTIMPL;
}

filter_seeking_GetCapabilities()

static HRESULT WINAPI filter_seeking_GetCapabilities ( IMediaSeeking *  iface, DWORD *  capabilities  )

static

Definition at line 875 of file filter.c.

{
    FIXME("iface %p, capabilities %p, stub!\n", iface, capabilities);
 
    return E_NOTIMPL;
}

filter_seeking_GetCurrentPosition()

static HRESULT WINAPI filter_seeking_GetCurrentPosition ( IMediaSeeking *  iface, LONGLONG *  current  )

static

Definition at line 986 of file filter.c.

{
    FIXME("iface %p, current %p, stub!\n", iface, current);
 
    return E_NOTIMPL;
}

filter_seeking_GetDuration()

static HRESULT WINAPI filter_seeking_GetDuration ( IMediaSeeking *  iface, LONGLONG *  duration  )

static

Definition at line 940 of file filter.c.

{
    struct filter *filter = impl_from_IMediaSeeking(iface);
    IMediaSeeking *seeking;
    HRESULT hr;
 
    TRACE("filter %p, duration %p.\n", filter, duration);
 
    EnterCriticalSection(&filter->cs);
 
    seeking = get_seeking(filter->seekable_stream);
 
    LeaveCriticalSection(&filter->cs);
 
    if (!seeking)
        return E_NOTIMPL;
 
    hr = IMediaSeeking_GetDuration(seeking, duration);
    IMediaSeeking_Release(seeking);
 
    return hr;
}

filter_seeking_GetPositions()

static HRESULT WINAPI filter_seeking_GetPositions ( IMediaSeeking *  iface, LONGLONG *  current, LONGLONG *  stop  )

static

Definition at line 1029 of file filter.c.

{
    FIXME("iface %p, current %p, stop %p, stub!\n", iface, current, stop);
 
    return E_NOTIMPL;
}

filter_seeking_GetPreroll()

static HRESULT WINAPI filter_seeking_GetPreroll ( IMediaSeeking *  iface, LONGLONG *  preroll  )

static

Definition at line 1057 of file filter.c.

{
    FIXME("iface %p, preroll %p, stub!\n", iface, preroll);
 
    return E_NOTIMPL;
}

filter_seeking_GetRate()

static HRESULT WINAPI filter_seeking_GetRate ( IMediaSeeking *  iface, double *  rate  )

static

Definition at line 1050 of file filter.c.

{
    FIXME("iface %p, rate %p, stub!\n", iface, rate);
 
    return E_NOTIMPL;
}

filter_seeking_GetStopPosition()

static HRESULT WINAPI filter_seeking_GetStopPosition ( IMediaSeeking *  iface, LONGLONG *  stop  )

static

Definition at line 963 of file filter.c.

{
    struct filter *filter = impl_from_IMediaSeeking(iface);
    IMediaSeeking *seeking;
    HRESULT hr;
 
    TRACE("filter %p, stop %p.\n", filter, stop);
 
    EnterCriticalSection(&filter->cs);
 
    seeking = get_seeking(filter->seekable_stream);
 
    LeaveCriticalSection(&filter->cs);
 
    if (!seeking)
        return E_NOTIMPL;
 
    hr = IMediaSeeking_GetStopPosition(seeking, stop);
    IMediaSeeking_Release(seeking);
 
    return hr;
}

filter_seeking_GetTimeFormat()

static HRESULT WINAPI filter_seeking_GetTimeFormat ( IMediaSeeking *  iface, GUID *  format  )

static

Definition at line 919 of file filter.c.

{
    FIXME("iface %p, format %p, stub!\n", iface, format);
 
    return E_NOTIMPL;
}

filter_seeking_IsFormatSupported()

static HRESULT WINAPI filter_seeking_IsFormatSupported ( IMediaSeeking *  iface, const GUID *  format  )

static

Definition at line 889 of file filter.c.

{
    struct filter *filter = impl_from_IMediaSeeking(iface);
    IMediaSeeking *seeking;
    HRESULT hr;
 
    TRACE("filter %p, format %s.\n", filter, debugstr_guid(format));
 
    EnterCriticalSection(&filter->cs);
 
    seeking = get_seeking(filter->seekable_stream);
 
    LeaveCriticalSection(&filter->cs);
 
    if (!seeking)
        return E_NOTIMPL;
 
    hr = IMediaSeeking_IsFormatSupported(seeking, format);
    IMediaSeeking_Release(seeking);
 
    return hr;
}

filter_seeking_IsUsingTimeFormat()

static HRESULT WINAPI filter_seeking_IsUsingTimeFormat ( IMediaSeeking *  iface, const GUID *  format  )

static

Definition at line 926 of file filter.c.

{
    FIXME("iface %p, format %s, stub!\n", iface, debugstr_guid(format));
 
    return E_NOTIMPL;
}

filter_seeking_QueryInterface()

static HRESULT WINAPI filter_seeking_QueryInterface ( IMediaSeeking *  iface, REFIID  iid, void **  out  )

static

Definition at line 857 of file filter.c.

{
    struct filter *filter = impl_from_IMediaSeeking(iface);
    return IMediaStreamFilter_QueryInterface(&filter->IMediaStreamFilter_iface, iid, out);
}

filter_seeking_QueryPreferredFormat()

static HRESULT WINAPI filter_seeking_QueryPreferredFormat ( IMediaSeeking *  iface, GUID *  format  )

static

Definition at line 912 of file filter.c.

{
    FIXME("iface %p, format %p, stub!\n", iface, format);
 
    return E_NOTIMPL;
}

filter_seeking_Release()

static ULONG WINAPI filter_seeking_Release ( IMediaSeeking *  iface )

static

Definition at line 869 of file filter.c.

{
    struct filter *filter = impl_from_IMediaSeeking(iface);
    return IMediaStreamFilter_Release(&filter->IMediaStreamFilter_iface);
}

filter_seeking_SetPositions()

static HRESULT WINAPI filter_seeking_SetPositions ( IMediaSeeking *  iface, LONGLONG *  current_ptr, DWORD  current_flags, LONGLONG *  stop_ptr, DWORD  stop_flags  )

static

Definition at line 1002 of file filter.c.

{
    struct filter *filter = impl_from_IMediaSeeking(iface);
    IMediaSeeking *seeking;
    HRESULT hr;
 
    TRACE("iface %p, current %s, current_flags %#lx, stop %s, stop_flags %#lx.\n", iface,
            current_ptr ? wine_dbgstr_longlong(*current_ptr) : "<null>", current_flags,
            stop_ptr ? wine_dbgstr_longlong(*stop_ptr): "<null>", stop_flags);
 
    EnterCriticalSection(&filter->cs);
 
    seeking = get_seeking(filter->seekable_stream);
 
    LeaveCriticalSection(&filter->cs);
 
    if (!seeking)
        return E_NOTIMPL;
 
    hr = IMediaSeeking_SetPositions(seeking, current_ptr, current_flags, stop_ptr, stop_flags);
 
    IMediaSeeking_Release(seeking);
 
    return hr;
}

filter_seeking_SetRate()

static HRESULT WINAPI filter_seeking_SetRate ( IMediaSeeking *  iface, double  rate  )

static

Definition at line 1043 of file filter.c.

{
    FIXME("iface %p, rate %f, stub!\n", iface, rate);
 
    return E_NOTIMPL;
}

filter_seeking_SetTimeFormat()

static HRESULT WINAPI filter_seeking_SetTimeFormat ( IMediaSeeking *  iface, const GUID *  format  )

static

Definition at line 933 of file filter.c.

{
    FIXME("iface %p, format %s, stub!\n", iface, debugstr_guid(format));
 
    return E_NOTIMPL;
}

filter_SetSyncSource()

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

static

Definition at line 382 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
 
    TRACE("iface %p, clock %p.\n", iface, clock);
 
    EnterCriticalSection(&filter->cs);
 
    if (clock)
        IReferenceClock_AddRef(clock);
    if (filter->clock)
        IReferenceClock_Release(filter->clock);
    filter->clock = clock;
 
    LeaveCriticalSection(&filter->cs);
 
    return S_OK;
}

filter_Stop()

static HRESULT WINAPI filter_Stop ( IMediaStreamFilter *  iface )

static

Definition at line 300 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
    struct event *event;
 
    TRACE("iface %p.\n", iface);
 
    EnterCriticalSection(&filter->cs);
 
    if (filter->state != State_Stopped)
        filter->eos_count = 0;
 
    set_state(filter, State_Stopped);
 
    LIST_FOR_EACH_ENTRY(event, &filter->used_events, struct event, entry)
    {
        if (!event->interrupted)
        {
            event->interrupted = TRUE;
            IReferenceClock_Unadvise(filter->clock, event->cookie);
            SetEvent(event->event);
        }
    }
 
    LeaveCriticalSection(&filter->cs);
 
    return S_OK;
}

filter_SupportSeeking()

static HRESULT WINAPI filter_SupportSeeking ( IMediaStreamFilter *  iface, BOOL  renderer  )

static

Definition at line 635 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
    unsigned int i;
 
    TRACE("filter %p, renderer %d\n", iface, renderer);
 
    if (!renderer)
        FIXME("Non-renderer filter support is not yet implemented.\n");
 
    EnterCriticalSection(&filter->cs);
 
    if (filter->seekable_stream)
    {
        LeaveCriticalSection(&filter->cs);
        return HRESULT_FROM_WIN32(ERROR_ALREADY_INITIALIZED);
    }
 
    for (i = 0; i < filter->nb_streams; ++i)
    {
        IMediaSeeking *seeking = get_seeking(filter->streams[i]);
        LONGLONG duration;
 
        if (!seeking)
            continue;
 
        if (SUCCEEDED(IMediaSeeking_GetDuration(seeking, &duration)))
        {
            filter->seekable_stream = filter->streams[i];
            IMediaSeeking_Release(seeking);
            LeaveCriticalSection(&filter->cs);
            return S_OK;
        }
 
        IMediaSeeking_Release(seeking);
    }
 
    LeaveCriticalSection(&filter->cs);
    return E_NOINTERFACE;
}

filter_WaitUntil()

static HRESULT WINAPI filter_WaitUntil ( IMediaStreamFilter *  iface, REFERENCE_TIME  time  )

static

Definition at line 724 of file filter.c.

{
    struct filter *filter = impl_from_IMediaStreamFilter(iface);
    struct event *event;
    struct list *entry;
    HRESULT hr;
 
    TRACE("filter %p, time %s.\n", iface, wine_dbgstr_longlong(time));
 
    EnterCriticalSection(&filter->cs);
 
    if (!filter->clock)
    {
        LeaveCriticalSection(&filter->cs);
        return E_FAIL;
    }
 
    if ((entry = list_head(&filter->free_events)))
    {
        list_remove(entry);
        event = LIST_ENTRY(entry, struct event, entry);
    }
    else
    {
        event = calloc(1, sizeof(struct event));
        event->event = CreateEventW(NULL, FALSE, FALSE, NULL);
 
        entry = &event->entry;
    }
 
    hr = IReferenceClock_AdviseTime(filter->clock, time, filter->start_time, (HEVENT)event->event, &event->cookie);
    if (FAILED(hr))
    {
        list_add_tail(&filter->free_events, entry);
        LeaveCriticalSection(&filter->cs);
        return hr;
    }
 
    event->interrupted = FALSE;
    list_add_tail(&filter->used_events, entry);
 
    LeaveCriticalSection(&filter->cs);
    WaitForSingleObject(event->event, INFINITE);
    EnterCriticalSection(&filter->cs);
 
    hr = event->interrupted ? S_FALSE : S_OK;
 
    list_remove(entry);
    list_add_tail(&filter->free_events, entry);
 
    LeaveCriticalSection(&filter->cs);
 
    return hr;
}

get_seeking()

static IMediaSeeking * get_seeking ( IAMMediaStream *  stream )

static

Definition at line 610 of file filter.c.

{
    IMediaSeeking *seeking;
    IPin *pin, *peer;
    HRESULT hr;
 
    if (FAILED(IAMMediaStream_QueryInterface(stream, &IID_IPin, (void **)&pin)))
    {
        WARN("Stream %p does not support IPin.\n", stream);
        return NULL;
    }
 
    hr = IPin_ConnectedTo(pin, &peer);
    IPin_Release(pin);
    if (FAILED(hr))
        return NULL;
 
    hr = IPin_QueryInterface(peer, &IID_IMediaSeeking, (void **)&seeking);
    IPin_Release(peer);
    if (FAILED(hr))
        return NULL;
 
    return seeking;
}

Referenced by filter_seeking_GetDuration(), filter_seeking_GetStopPosition(), filter_seeking_IsFormatSupported(), filter_seeking_SetPositions(), and filter_SupportSeeking().

impl_from_IEnumPins()

static struct enum_pins * impl_from_IEnumPins ( IEnumPins *  iface )

static

Definition at line 39 of file filter.c.

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

Referenced by enum_pins_AddRef(), enum_pins_Clone(), enum_pins_Next(), enum_pins_Release(), enum_pins_Reset(), and enum_pins_Skip().

impl_from_IMediaSeeking()

static struct filter * impl_from_IMediaSeeking ( IMediaSeeking *  iface )

inlinestatic

Definition at line 852 of file filter.c.

{
    return CONTAINING_RECORD(iface, struct filter, IMediaSeeking_iface);
}

Referenced by filter_seeking_AddRef(), filter_seeking_GetDuration(), filter_seeking_GetStopPosition(), filter_seeking_IsFormatSupported(), filter_seeking_QueryInterface(), filter_seeking_Release(), and filter_seeking_SetPositions().

impl_from_IMediaStreamFilter()

static struct filter * impl_from_IMediaStreamFilter ( IMediaStreamFilter *  iface )

inlinestatic

Definition at line 192 of file filter.c.

{
    return CONTAINING_RECORD(iface, struct filter, IMediaStreamFilter_iface);
}

Referenced by filter_AddMediaStream(), filter_AddRef(), filter_EndOfStream(), filter_EnumMediaStreams(), filter_EnumPins(), filter_FindPin(), filter_Flush(), filter_GetCurrentStreamTime(), filter_GetMediaStream(), filter_GetState(), filter_GetSyncSource(), filter_JoinFilterGraph(), filter_Pause(), filter_QueryFilterInfo(), filter_QueryInterface(), filter_ReferenceTimeToStreamTime(), filter_Release(), filter_Run(), filter_SetSyncSource(), filter_Stop(), filter_SupportSeeking(), and filter_WaitUntil().

send_ec_complete()

static void send_ec_complete ( struct filter *  filter )

static

Definition at line 272 of file filter.c.

{
    IMediaEventSink *event_sink;
 
    if (!filter->graph)
        return;
 
    if (FAILED(IFilterGraph_QueryInterface(filter->graph, &IID_IMediaEventSink, (void **)&event_sink)))
        return;
 
    IMediaEventSink_Notify(event_sink, EC_COMPLETE, S_OK,
            (LONG_PTR)&filter->IMediaStreamFilter_iface);
 
    IMediaEventSink_Release(event_sink);
}

Referenced by filter_EndOfStream(), and filter_Run().

set_state()

static void set_state ( struct filter *  filter, FILTER_STATE  state  )

static

Definition at line 288 of file filter.c.

{
    if (filter->state != state)
    {
        ULONG i;
 
        for (i = 0; i < filter->nb_streams; ++i)
            IAMMediaStream_SetState(filter->streams[i], state);
        filter->state = state;
    }
}

Referenced by filter_Pause(), filter_Run(), and filter_Stop().

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 37 of file filter.c.

Referenced by enum_pins_Clone(), enum_pins_create(), and filter_EnumPins().

filter_seeking_vtbl

const IMediaSeekingVtbl filter_seeking_vtbl

static

Initial value:

=
{
    filter_seeking_QueryInterface,
    filter_seeking_AddRef,
    filter_seeking_Release,
    filter_seeking_GetCapabilities,
    filter_seeking_CheckCapabilities,
    filter_seeking_IsFormatSupported,
    filter_seeking_QueryPreferredFormat,
    filter_seeking_GetTimeFormat,
    filter_seeking_IsUsingTimeFormat,
    filter_seeking_SetTimeFormat,
    filter_seeking_GetDuration,
    filter_seeking_GetStopPosition,
    filter_seeking_GetCurrentPosition,
    filter_seeking_ConvertTimeFormat,
    filter_seeking_SetPositions,
    filter_seeking_GetPositions,
    filter_seeking_GetAvailable,
    filter_seeking_SetRate,
    filter_seeking_GetRate,
    filter_seeking_GetPreroll,
}

Definition at line 1064 of file filter.c.

Referenced by filter_create().

filter_vtbl

const IMediaStreamFilterVtbl 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,
    filter_AddMediaStream,
    filter_GetMediaStream,
    filter_EnumMediaStreams,
    filter_SupportSeeking,
    filter_ReferenceTimeToStreamTime,
    filter_GetCurrentStreamTime,
    filter_WaitUntil,
    filter_Flush,
    filter_EndOfStream
}

Definition at line 824 of file filter.c.

Referenced by filter_create(), and strmbase_filter_init().