quartz_private.h File Reference

#include <stdarg.h>
#include <stdbool.h>
#include <wchar.h>
#include "windef.h"
#include "winbase.h"
#include "wtypes.h"
#include "wingdi.h"
#include "winuser.h"
#include "dshow.h"
#include "dvdmedia.h"
#include "wine/debug.h"
#include "wine/heap.h"
#include "wine/strmbase.h"
#include "wine/list.h"

Include dependency graph for quartz_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	video_window
struct	video_window_ops

Macros
#define	COBJMACROS
#define	DECLARE_CRITICAL_SECTION(cs)
#define	MEDIATIME_FROM_BYTES(x)   ((LONGLONG)(x) * 10000000)
#define	BYTES_FROM_MEDIATIME(time)   ((time) / 10000000)

Functions
bool	array_reserve (void **elements, size_t *capacity, size_t count, size_t size)
HRESULT	acm_wrapper_create (IUnknown *outer, IUnknown **out)
HRESULT	async_reader_create (IUnknown *outer, IUnknown **out)
HRESULT	avi_dec_create (IUnknown *outer, IUnknown **out)
HRESULT	avi_splitter_create (IUnknown *outer, IUnknown **out)
HRESULT	dsound_render_create (IUnknown *outer, IUnknown **out)
HRESULT	filter_graph_create (IUnknown *outer, IUnknown **out)
HRESULT	filter_graph_no_thread_create (IUnknown *outer, IUnknown **out)
HRESULT	filter_mapper_create (IUnknown *outer, IUnknown **out)
HRESULT	mem_allocator_create (IUnknown *outer, IUnknown **out)
HRESULT	mpeg_audio_codec_create (IUnknown *outer, IUnknown **out)
HRESULT	mpeg_layer3_decoder_create (IUnknown *outer, IUnknown **out)
HRESULT	mpeg_video_codec_create (IUnknown *outer, IUnknown **out)
HRESULT	mpeg1_splitter_create (IUnknown *outer, IUnknown **out)
HRESULT	system_clock_create (IUnknown *outer, IUnknown **out)
HRESULT	seeking_passthrough_create (IUnknown *outer, IUnknown **out)
HRESULT	video_renderer_create (IUnknown *outer, IUnknown **out)
HRESULT	video_renderer_default_create (IUnknown *outer, IUnknown **out)
HRESULT	vmr7_presenter_create (IUnknown *outer, IUnknown **out)
HRESULT	vmr7_create (IUnknown *outer, IUnknown **out)
HRESULT	vmr9_create (IUnknown *outer, IUnknown **out)
HRESULT	wave_parser_create (IUnknown *outer, IUnknown **out)
const char *	qzdebugstr_guid (const GUID *id)
void	video_unregister_windowclass (void)
BOOL	get_media_type (const WCHAR *filename, GUID *majortype, GUID *subtype, GUID *source_clsid)
void	video_window_cleanup (struct video_window *window)
HRESULT	video_window_create_window (struct video_window *window)
void	video_window_init (struct video_window *window, const IVideoWindowVtbl *vtbl, struct strmbase_filter *filter, struct strmbase_pin *pin, const struct video_window_ops *ops)
void	video_window_unregister_class (void)
HRESULT WINAPI	BaseControlWindowImpl_QueryInterface (IVideoWindow *iface, REFIID iid, void **out)
ULONG WINAPI	BaseControlWindowImpl_AddRef (IVideoWindow *iface)
ULONG WINAPI	BaseControlWindowImpl_Release (IVideoWindow *iface)
HRESULT WINAPI	BaseControlWindowImpl_GetTypeInfoCount (IVideoWindow *iface, UINT *pctinfo)
HRESULT WINAPI	BaseControlWindowImpl_GetTypeInfo (IVideoWindow *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
HRESULT WINAPI	BaseControlWindowImpl_GetIDsOfNames (IVideoWindow *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
HRESULT WINAPI	BaseControlWindowImpl_Invoke (IVideoWindow *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo, UINT *puArgErr)
HRESULT WINAPI	BaseControlWindowImpl_put_Caption (IVideoWindow *iface, BSTR strCaption)
HRESULT WINAPI	BaseControlWindowImpl_get_Caption (IVideoWindow *iface, BSTR *strCaption)
HRESULT WINAPI	BaseControlWindowImpl_put_WindowStyle (IVideoWindow *iface, LONG WindowStyle)
HRESULT WINAPI	BaseControlWindowImpl_get_WindowStyle (IVideoWindow *iface, LONG *WindowStyle)
HRESULT WINAPI	BaseControlWindowImpl_put_WindowStyleEx (IVideoWindow *iface, LONG WindowStyleEx)
HRESULT WINAPI	BaseControlWindowImpl_get_WindowStyleEx (IVideoWindow *iface, LONG *WindowStyleEx)
HRESULT WINAPI	BaseControlWindowImpl_put_AutoShow (IVideoWindow *iface, LONG AutoShow)
HRESULT WINAPI	BaseControlWindowImpl_get_AutoShow (IVideoWindow *iface, LONG *AutoShow)
HRESULT WINAPI	BaseControlWindowImpl_put_WindowState (IVideoWindow *iface, LONG WindowState)
HRESULT WINAPI	BaseControlWindowImpl_get_WindowState (IVideoWindow *iface, LONG *WindowState)
HRESULT WINAPI	BaseControlWindowImpl_put_BackgroundPalette (IVideoWindow *iface, LONG BackgroundPalette)
HRESULT WINAPI	BaseControlWindowImpl_get_BackgroundPalette (IVideoWindow *iface, LONG *pBackgroundPalette)
HRESULT WINAPI	BaseControlWindowImpl_put_Visible (IVideoWindow *iface, LONG Visible)
HRESULT WINAPI	BaseControlWindowImpl_get_Visible (IVideoWindow *iface, LONG *pVisible)
HRESULT WINAPI	BaseControlWindowImpl_put_Left (IVideoWindow *iface, LONG Left)
HRESULT WINAPI	BaseControlWindowImpl_get_Left (IVideoWindow *iface, LONG *pLeft)
HRESULT WINAPI	BaseControlWindowImpl_put_Width (IVideoWindow *iface, LONG Width)
HRESULT WINAPI	BaseControlWindowImpl_get_Width (IVideoWindow *iface, LONG *pWidth)
HRESULT WINAPI	BaseControlWindowImpl_put_Top (IVideoWindow *iface, LONG Top)
HRESULT WINAPI	BaseControlWindowImpl_get_Top (IVideoWindow *iface, LONG *pTop)
HRESULT WINAPI	BaseControlWindowImpl_put_Height (IVideoWindow *iface, LONG Height)
HRESULT WINAPI	BaseControlWindowImpl_get_Height (IVideoWindow *iface, LONG *pHeight)
HRESULT WINAPI	BaseControlWindowImpl_put_Owner (IVideoWindow *iface, OAHWND Owner)
HRESULT WINAPI	BaseControlWindowImpl_get_Owner (IVideoWindow *iface, OAHWND *Owner)
HRESULT WINAPI	BaseControlWindowImpl_put_MessageDrain (IVideoWindow *iface, OAHWND Drain)
HRESULT WINAPI	BaseControlWindowImpl_get_MessageDrain (IVideoWindow *iface, OAHWND *Drain)
HRESULT WINAPI	BaseControlWindowImpl_get_BorderColor (IVideoWindow *iface, LONG *Color)
HRESULT WINAPI	BaseControlWindowImpl_put_BorderColor (IVideoWindow *iface, LONG Color)
HRESULT WINAPI	BaseControlWindowImpl_get_FullScreenMode (IVideoWindow *iface, LONG *FullScreenMode)
HRESULT WINAPI	BaseControlWindowImpl_put_FullScreenMode (IVideoWindow *iface, LONG FullScreenMode)
HRESULT WINAPI	BaseControlWindowImpl_SetWindowForeground (IVideoWindow *iface, LONG Focus)
HRESULT WINAPI	BaseControlWindowImpl_SetWindowPosition (IVideoWindow *iface, LONG Left, LONG Top, LONG Width, LONG Height)
HRESULT WINAPI	BaseControlWindowImpl_GetWindowPosition (IVideoWindow *iface, LONG *pLeft, LONG *pTop, LONG *pWidth, LONG *pHeight)
HRESULT WINAPI	BaseControlWindowImpl_NotifyOwnerMessage (IVideoWindow *iface, OAHWND hwnd, LONG uMsg, LONG_PTR wParam, LONG_PTR lParam)
HRESULT WINAPI	BaseControlWindowImpl_GetMinIdealImageSize (IVideoWindow *iface, LONG *pWidth, LONG *pHeight)
HRESULT WINAPI	BaseControlWindowImpl_GetMaxIdealImageSize (IVideoWindow *iface, LONG *pWidth, LONG *pHeight)
HRESULT WINAPI	BaseControlWindowImpl_GetRestorePosition (IVideoWindow *iface, LONG *pLeft, LONG *pTop, LONG *pWidth, LONG *pHeight)
HRESULT WINAPI	BaseControlWindowImpl_HideCursor (IVideoWindow *iface, LONG HideCursor)
HRESULT WINAPI	BaseControlWindowImpl_IsCursorHidden (IVideoWindow *iface, LONG *CursorHidden)

Macro Definition Documentation

BYTES_FROM_MEDIATIME

#define BYTES_FROM_MEDIATIME

(

time

)

((time) / 10000000)

Definition at line 50 of file quartz_private.h.

COBJMACROS

#define COBJMACROS

Definition at line 27 of file quartz_private.h.

DECLARE_CRITICAL_SECTION

#define DECLARE_CRITICAL_SECTION

(

cs

)

Value:

    static CRITICAL_SECTION cs;                                         \
    static CRITICAL_SECTION_DEBUG cs##_debug =                          \
    { 0, 0, &cs, { &cs##_debug.ProcessLocksList, &cs##_debug.ProcessLocksList }, \
      0, 0, { (DWORD_PTR)(__FILE__ ": " # cs) }};                       \
    static CRITICAL_SECTION cs = { &cs##_debug, -1, 0, 0, 0, 0 };

Definition at line 41 of file quartz_private.h.

MEDIATIME_FROM_BYTES

#define MEDIATIME_FROM_BYTES

(

x

)

((LONGLONG)(x) * 10000000)

Definition at line 49 of file quartz_private.h.

Function Documentation

acm_wrapper_create()

HRESULT acm_wrapper_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 513 of file acmwrapper.c.

{
    struct acm_wrapper *object;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    strmbase_filter_init(&object->filter, outer, &CLSID_ACMWrapper, &filter_ops);
 
    strmbase_sink_init(&object->sink, &object->filter, L"In", &sink_ops, NULL);
    wcscpy(object->sink.pin.name, L"Input");
 
    strmbase_source_init(&object->source, &object->filter, L"Out", &source_ops);
    wcscpy(object->source.pin.name, L"Output");
 
    object->source_IQualityControl_iface.lpVtbl = &source_qc_vtbl;
    strmbase_passthrough_init(&object->passthrough, (IUnknown *)&object->source.pin.IPin_iface);
    ISeekingPassThru_Init(&object->passthrough.ISeekingPassThru_iface, FALSE,
            &object->sink.pin.IPin_iface);
 
    object->lasttime_real = object->lasttime_sent = -1;
 
    TRACE("Created ACM wrapper %p.\n", object);
    *out = &object->filter.IUnknown_inner;
 
    return S_OK;
}

array_reserve()

bool array_reserve	(	void **	elements,
		size_t *	capacity,
		size_t	count,
		size_t	size
	)

Definition at line 31 of file main.c.

{
    unsigned int new_capacity, max_capacity;
    void *new_elements;
 
    if (count <= *capacity)
        return true;
 
    max_capacity = ~(size_t)0 / size;
    if (count > max_capacity)
        return false;
 
    new_capacity = max(4, *capacity);
    while (new_capacity < count && new_capacity <= max_capacity / 2)
        new_capacity *= 2;
    if (new_capacity < count)
        new_capacity = max_capacity;
 
    if (!(new_elements = realloc(*elements, new_capacity * size)))
        return false;
 
    *elements = new_elements;
    *capacity = new_capacity;
 
    return true;
}

async_reader_create()

HRESULT async_reader_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 430 of file filesource.c.

{
    struct async_reader *object;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    strmbase_filter_init(&object->filter, outer, &CLSID_AsyncReader, &filter_ops);
 
    object->IFileSourceFilter_iface.lpVtbl = &FileSource_Vtbl;
    object->IAsyncReader_iface.lpVtbl = &FileAsyncReader_Vtbl;
 
    InitializeCriticalSectionEx(&object->sample_cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    object->sample_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": FileAsyncReader.sample_cs");
    InitializeConditionVariable(&object->sample_cv);
    object->port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
    object->io_thread = CreateThread(NULL, 0, io_thread, object, 0, NULL);
 
    TRACE("Created file source %p.\n", object);
    *out = &object->filter.IUnknown_inner;
    return S_OK;
}

avi_dec_create()

HRESULT avi_dec_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 613 of file avidec.c.

{
    struct avi_decompressor *object;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    strmbase_filter_init(&object->filter, outer, &CLSID_AVIDec, &filter_ops);
 
    strmbase_sink_init(&object->sink, &object->filter, L"In", &sink_ops, NULL);
    wcscpy(object->sink.pin.name, L"XForm In");
 
    strmbase_source_init(&object->source, &object->filter, L"Out", &source_ops);
    wcscpy(object->source.pin.name, L"XForm Out");
 
    object->source_IQualityControl_iface.lpVtbl = &source_qc_vtbl;
    strmbase_passthrough_init(&object->passthrough, (IUnknown *)&object->source.pin.IPin_iface);
    ISeekingPassThru_Init(&object->passthrough.ISeekingPassThru_iface, FALSE,
            &object->sink.pin.IPin_iface);
 
    InitializeCriticalSectionEx(&object->late_cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    object->late_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": object.late_cs");
 
    TRACE("Created AVI decompressor %p.\n", object);
    *out = &object->filter.IUnknown_inner;
 
    return S_OK;
}

avi_splitter_create()

HRESULT avi_splitter_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 21 of file parser.c.

{
    static const GUID CLSID_wg_avi_splitter = {0x272bfbfb,0x50d0,0x4078,{0xb6,0x00,0x1e,0x95,0x9c,0x30,0x13,0x37}};
    return CoCreateInstance(&CLSID_wg_avi_splitter, outer, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)out);
}

BaseControlWindowImpl_AddRef()

ULONG WINAPI BaseControlWindowImpl_AddRef

(

IVideoWindow *

iface

)

Definition at line 131 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    return IUnknown_AddRef(window->pFilter->outer_unk);
}

BaseControlWindowImpl_get_AutoShow()

HRESULT WINAPI BaseControlWindowImpl_get_AutoShow	(	IVideoWindow *	iface,
		LONG *	AutoShow
	)

Definition at line 288 of file window.c.

{
    struct video_window *This = impl_from_IVideoWindow(iface);
 
    TRACE("(%p/%p)->(%p)\n", This, iface, AutoShow);
 
    *AutoShow = This->AutoShow;
 
    return S_OK;
}

BaseControlWindowImpl_get_BackgroundPalette()

HRESULT WINAPI BaseControlWindowImpl_get_BackgroundPalette	(	IVideoWindow *	iface,
		LONG *	pBackgroundPalette
	)

Definition at line 338 of file window.c.

{
    struct video_window *This = impl_from_IVideoWindow(iface);
 
    FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBackgroundPalette);
 
    return S_OK;
}

BaseControlWindowImpl_get_BorderColor()

HRESULT WINAPI BaseControlWindowImpl_get_BorderColor	(	IVideoWindow *	iface,
		LONG *	Color
	)

Definition at line 540 of file window.c.

{
    struct video_window *This = impl_from_IVideoWindow(iface);
 
    FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, Color);
 
    return S_OK;
}

BaseControlWindowImpl_get_Caption()

HRESULT WINAPI BaseControlWindowImpl_get_Caption	(	IVideoWindow *	iface,
		BSTR *	strCaption
	)

Definition at line 206 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    WCHAR *str;
    int len;
 
    TRACE("window %p, caption %p.\n", window, caption);
 
    *caption = NULL;
 
    len = GetWindowTextLengthW(window->hwnd) + 1;
    if (!(str = heap_alloc(len * sizeof(WCHAR))))
        return E_OUTOFMEMORY;
 
    GetWindowTextW(window->hwnd, str, len);
    *caption = SysAllocString(str);
    heap_free(str);
    return *caption ? S_OK : E_OUTOFMEMORY;
}

BaseControlWindowImpl_get_FullScreenMode()

HRESULT WINAPI BaseControlWindowImpl_get_FullScreenMode	(	IVideoWindow *	iface,
		LONG *	FullScreenMode
	)

Definition at line 558 of file window.c.

{
    TRACE("(%p)->(%p)\n", iface, FullScreenMode);
 
    return E_NOTIMPL;
}

BaseControlWindowImpl_get_Height()

HRESULT WINAPI BaseControlWindowImpl_get_Height	(	IVideoWindow *	iface,
		LONG *	pHeight
	)

Definition at line 469 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    RECT rect;
 
    TRACE("window %p, height %p.\n", window, height);
 
    GetWindowRect(window->hwnd, &rect);
    *height = rect.bottom - rect.top;
    return S_OK;
}

BaseControlWindowImpl_get_Left()

HRESULT WINAPI BaseControlWindowImpl_get_Left	(	IVideoWindow *	iface,
		LONG *	pLeft
	)

Definition at line 388 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    RECT rect;
 
    TRACE("window %p, left %p.\n", window, left);
 
    GetWindowRect(window->hwnd, &rect);
    *left = rect.left;
    return S_OK;
}

BaseControlWindowImpl_get_MessageDrain()

HRESULT WINAPI BaseControlWindowImpl_get_MessageDrain	(	IVideoWindow *	iface,
		OAHWND *	Drain
	)

Definition at line 529 of file window.c.

{
    struct video_window *This = impl_from_IVideoWindow(iface);
 
    TRACE("(%p/%p)->(%p)\n", This, iface, Drain);
 
    *Drain = (OAHWND)This->hwndDrain;
 
    return S_OK;
}

BaseControlWindowImpl_get_Owner()

HRESULT WINAPI BaseControlWindowImpl_get_Owner	(	IVideoWindow *	iface,
		OAHWND *	Owner
	)

Definition at line 504 of file window.c.

{
    struct video_window *This = impl_from_IVideoWindow(iface);
 
    TRACE("(%p/%p)->(%p)\n", This, iface, Owner);
 
    *(HWND*)Owner = This->hwndOwner;
 
    return S_OK;
}

BaseControlWindowImpl_get_Top()

HRESULT WINAPI BaseControlWindowImpl_get_Top	(	IVideoWindow *	iface,
		LONG *	pTop
	)

Definition at line 442 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    RECT rect;
 
    TRACE("window %p, top %p.\n", window, top);
 
    GetWindowRect(window->hwnd, &rect);
    *top = rect.top;
    return S_OK;
}

BaseControlWindowImpl_get_Visible()

HRESULT WINAPI BaseControlWindowImpl_get_Visible	(	IVideoWindow *	iface,
		LONG *	pVisible
	)

Definition at line 360 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, visible %p.\n", window, visible);
 
    if (!visible)
        return E_POINTER;
 
    *visible = IsWindowVisible(window->hwnd) ? OATRUE : OAFALSE;
    return S_OK;
}

BaseControlWindowImpl_get_Width()

HRESULT WINAPI BaseControlWindowImpl_get_Width	(	IVideoWindow *	iface,
		LONG *	pWidth
	)

Definition at line 415 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    RECT rect;
 
    TRACE("window %p, width %p.\n", window, width);
 
    GetWindowRect(window->hwnd, &rect);
    *width = rect.right - rect.left;
    return S_OK;
}

BaseControlWindowImpl_get_WindowState()

HRESULT WINAPI BaseControlWindowImpl_get_WindowState	(	IVideoWindow *	iface,
		LONG *	WindowState
	)

Definition at line 309 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    DWORD style;
 
    TRACE("window %p, state %p.\n", window, state);
 
    style = GetWindowLongPtrW(window->hwnd, GWL_STYLE);
    if (!(style & WS_VISIBLE))
        *state = SW_HIDE;
    else if (style & WS_MINIMIZE)
        *state = SW_MINIMIZE;
    else if (style & WS_MAXIMIZE)
        *state = SW_MAXIMIZE;
    else
        *state = SW_SHOW;
 
    return S_OK;
}

BaseControlWindowImpl_get_WindowStyle()

HRESULT WINAPI BaseControlWindowImpl_get_WindowStyle	(	IVideoWindow *	iface,
		LONG *	WindowStyle
	)

Definition at line 243 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, style %p.\n", window, style);
 
    *style = GetWindowLongW(window->hwnd, GWL_STYLE);
    return S_OK;
}

BaseControlWindowImpl_get_WindowStyleEx()

HRESULT WINAPI BaseControlWindowImpl_get_WindowStyleEx	(	IVideoWindow *	iface,
		LONG *	WindowStyleEx
	)

Definition at line 264 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, style %p.\n", window, style);
 
    *style = GetWindowLongW(window->hwnd, GWL_EXSTYLE);
    return S_OK;
}

BaseControlWindowImpl_GetIDsOfNames()

HRESULT WINAPI BaseControlWindowImpl_GetIDsOfNames	(	IVideoWindow *	iface,
		REFIID	riid,
		LPOLESTR *	rgszNames,
		UINT	cNames,
		LCID	lcid,
		DISPID *	rgDispId
	)

Definition at line 157 of file window.c.

{
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("iface %p, iid %s, names %p, count %u, lcid %#lx, ids %p.\n",
            iface, debugstr_guid(iid), names, count, lcid, ids);
 
    if (SUCCEEDED(hr = strmbase_get_typeinfo(IVideoWindow_tid, &typeinfo)))
    {
        hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, ids);
        ITypeInfo_Release(typeinfo);
    }
    return hr;
}

BaseControlWindowImpl_GetMaxIdealImageSize()

HRESULT WINAPI BaseControlWindowImpl_GetMaxIdealImageSize	(	IVideoWindow *	iface,
		LONG *	pWidth,
		LONG *	pHeight
	)

Definition at line 664 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    RECT rect;
 
    TRACE("window %p, width %p, height %p.\n", window, width, height);
 
    window->ops->get_default_rect(window, &rect);
    *width = rect.right - rect.left;
    *height = rect.bottom - rect.top;
    return S_OK;
}

BaseControlWindowImpl_GetMinIdealImageSize()

HRESULT WINAPI BaseControlWindowImpl_GetMinIdealImageSize	(	IVideoWindow *	iface,
		LONG *	pWidth,
		LONG *	pHeight
	)

Definition at line 651 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    RECT rect;
 
    TRACE("window %p, width %p, height %p.\n", window, width, height);
 
    window->ops->get_default_rect(window, &rect);
    *width = rect.right - rect.left;
    *height = rect.bottom - rect.top;
    return S_OK;
}

BaseControlWindowImpl_GetRestorePosition()

HRESULT WINAPI BaseControlWindowImpl_GetRestorePosition	(	IVideoWindow *	iface,
		LONG *	pLeft,
		LONG *	pTop,
		LONG *	pWidth,
		LONG *	pHeight
	)

Definition at line 677 of file window.c.

{
    struct video_window *This = impl_from_IVideoWindow(iface);
 
    FIXME("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight);
 
    return S_OK;
}

BaseControlWindowImpl_GetTypeInfo()

HRESULT WINAPI BaseControlWindowImpl_GetTypeInfo	(	IVideoWindow *	iface,
		UINT	iTInfo,
		LCID	lcid,
		ITypeInfo **	ppTInfo
	)

Definition at line 150 of file window.c.

{
    TRACE("iface %p, index %u, lcid %#lx, typeinfo %p.\n", iface, index, lcid, typeinfo);
    return strmbase_get_typeinfo(IVideoWindow_tid, typeinfo);
}

BaseControlWindowImpl_GetTypeInfoCount()

HRESULT WINAPI BaseControlWindowImpl_GetTypeInfoCount	(	IVideoWindow *	iface,
		UINT *	pctinfo
	)

Definition at line 143 of file window.c.

{
    TRACE("iface %p, count %p.\n", iface, count);
    *count = 1;
    return S_OK;
}

BaseControlWindowImpl_GetWindowPosition()

HRESULT WINAPI BaseControlWindowImpl_GetWindowPosition	(	IVideoWindow *	iface,
		LONG *	pLeft,
		LONG *	pTop,
		LONG *	pWidth,
		LONG *	pHeight
	)

Definition at line 609 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    RECT rect;
 
    TRACE("window %p, left %p, top %p, width %p, height %p.\n", window, left, top, width, height);
 
    GetWindowRect(window->hwnd, &rect);
    *left = rect.left;
    *top = rect.top;
    *width = rect.right - rect.left;
    *height = rect.bottom - rect.top;
    return S_OK;
}

BaseControlWindowImpl_HideCursor()

HRESULT WINAPI BaseControlWindowImpl_HideCursor	(	IVideoWindow *	iface,
		LONG	HideCursor
	)

Definition at line 686 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
 
    FIXME("window %p, hide %ld, stub!\n", window, hide);
 
    return S_OK;
}

BaseControlWindowImpl_Invoke()

HRESULT WINAPI BaseControlWindowImpl_Invoke	(	IVideoWindow *	iface,
		DISPID	dispIdMember,
		REFIID	riid,
		LCID	lcid,
		WORD	wFlags,
		DISPPARAMS *	pDispParams,
		VARIANT *	pVarResult,
		EXCEPINFO *	pExepInfo,
		UINT *	puArgErr
	)

Definition at line 174 of file window.c.

{
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("iface %p, id %ld, iid %s, lcid %#lx, flags %#x, params %p, result %p, excepinfo %p, error_arg %p.\n",
            iface, id, debugstr_guid(iid), lcid, flags, params, result, excepinfo, error_arg);
 
    if (SUCCEEDED(hr = strmbase_get_typeinfo(IVideoWindow_tid, &typeinfo)))
    {
        hr = ITypeInfo_Invoke(typeinfo, iface, id, flags, params, result, excepinfo, error_arg);
        ITypeInfo_Release(typeinfo);
    }
    return hr;
}

BaseControlWindowImpl_IsCursorHidden()

HRESULT WINAPI BaseControlWindowImpl_IsCursorHidden	(	IVideoWindow *	iface,
		LONG *	CursorHidden
	)

Definition at line 695 of file window.c.

{
    struct video_window *This = impl_from_IVideoWindow(iface);
 
    FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, CursorHidden);
 
    return S_OK;
}

BaseControlWindowImpl_NotifyOwnerMessage()

HRESULT WINAPI BaseControlWindowImpl_NotifyOwnerMessage	(	IVideoWindow *	iface,
		OAHWND	hwnd,
		LONG	uMsg,
		LONG_PTR	wParam,
		LONG_PTR	lParam
	)

Definition at line 625 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, hwnd %#Ix, message %#lx, wparam %#Ix, lparam %#Ix.\n",
            window, hwnd, message, wparam, lparam);
 
    /* That these messages are forwarded, and no others, is stated by the
     * DirectX documentation, and supported by manual testing. */
    switch (message)
    {
    case WM_ACTIVATEAPP:
    case WM_DEVMODECHANGE:
    case WM_DISPLAYCHANGE:
    case WM_PALETTECHANGED:
    case WM_PALETTEISCHANGING:
    case WM_QUERYNEWPALETTE:
    case WM_SYSCOLORCHANGE:
        SendMessageW(window->hwnd, message, wparam, lparam);
        break;
    }
 
    return S_OK;
}

BaseControlWindowImpl_put_AutoShow()

HRESULT WINAPI BaseControlWindowImpl_put_AutoShow	(	IVideoWindow *	iface,
		LONG	AutoShow
	)

Definition at line 274 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, AutoShow %ld.\n", window, AutoShow);
 
    if (!window->pPin->peer)
        return VFW_E_NOT_CONNECTED;
 
    window->AutoShow = AutoShow;
 
    return S_OK;
}

BaseControlWindowImpl_put_BackgroundPalette()

HRESULT WINAPI BaseControlWindowImpl_put_BackgroundPalette	(	IVideoWindow *	iface,
		LONG	BackgroundPalette
	)

Definition at line 329 of file window.c.

{
    struct video_window *This = impl_from_IVideoWindow(iface);
 
    FIXME("window %p, palette %ld, stub!\n", This, BackgroundPalette);
 
    return S_OK;
}

BaseControlWindowImpl_put_BorderColor()

HRESULT WINAPI BaseControlWindowImpl_put_BorderColor	(	IVideoWindow *	iface,
		LONG	Color
	)

Definition at line 549 of file window.c.

{
    struct video_window *This = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, colour %#lx.\n", This, Color);
 
    return S_OK;
}

BaseControlWindowImpl_put_Caption()

HRESULT WINAPI BaseControlWindowImpl_put_Caption	(	IVideoWindow *	iface,
		BSTR	strCaption
	)

Definition at line 191 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, caption %s.\n", window, debugstr_w(caption));
 
    if (!window->pPin->peer)
        return VFW_E_NOT_CONNECTED;
 
    if (!SetWindowTextW(window->hwnd, caption))
        return E_FAIL;
 
    return S_OK;
}

BaseControlWindowImpl_put_FullScreenMode()

HRESULT WINAPI BaseControlWindowImpl_put_FullScreenMode	(	IVideoWindow *	iface,
		LONG	FullScreenMode
	)

Definition at line 565 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, fullscreen %ld.\n", window, fullscreen);
 
    return E_NOTIMPL;
}

BaseControlWindowImpl_put_Height()

HRESULT WINAPI BaseControlWindowImpl_put_Height	(	IVideoWindow *	iface,
		LONG	Height
	)

Definition at line 454 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    RECT rect;
 
    TRACE("window %p, height %ld.\n", window, height);
 
    GetWindowRect(window->hwnd, &rect);
    if (!SetWindowPos(window->hwnd, NULL, 0, 0, rect.right - rect.left,
            height, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE))
        return E_FAIL;
 
    return S_OK;
}

BaseControlWindowImpl_put_Left()

HRESULT WINAPI BaseControlWindowImpl_put_Left	(	IVideoWindow *	iface,
		LONG	Left
	)

Definition at line 373 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    RECT rect;
 
    TRACE("window %p, left %ld.\n", window, left);
 
    GetWindowRect(window->hwnd, &rect);
    if (!SetWindowPos(window->hwnd, NULL, left, rect.top, 0, 0,
            SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE))
        return E_FAIL;
 
    return S_OK;
}

BaseControlWindowImpl_put_MessageDrain()

HRESULT WINAPI BaseControlWindowImpl_put_MessageDrain	(	IVideoWindow *	iface,
		OAHWND	Drain
	)

Definition at line 515 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, drain %#Ix.\n", window, Drain);
 
    if (!window->pPin->peer)
        return VFW_E_NOT_CONNECTED;
 
    window->hwndDrain = (HWND)Drain;
 
    return S_OK;
}

BaseControlWindowImpl_put_Owner()

HRESULT WINAPI BaseControlWindowImpl_put_Owner	(	IVideoWindow *	iface,
		OAHWND	Owner
	)

Definition at line 481 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    HWND hwnd = window->hwnd;
 
    TRACE("window %p, owner %#Ix.\n", window, owner);
 
    if (!window->pPin->peer)
        return VFW_E_NOT_CONNECTED;
 
    /* Make sure we are marked as WS_CHILD before reparenting ourselves, so that
     * we do not steal focus. LEGO Island depends on this. */
 
    window->hwndOwner = (HWND)owner;
    if (owner)
        SetWindowLongPtrW(hwnd, GWL_STYLE, GetWindowLongPtrW(hwnd, GWL_STYLE) | WS_CHILD);
    else
        SetWindowLongPtrW(hwnd, GWL_STYLE, GetWindowLongPtrW(hwnd, GWL_STYLE) & ~WS_CHILD);
    SetParent(hwnd, (HWND)owner);
 
    return S_OK;
}

BaseControlWindowImpl_put_Top()

HRESULT WINAPI BaseControlWindowImpl_put_Top	(	IVideoWindow *	iface,
		LONG	Top
	)

Definition at line 427 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    RECT rect;
 
    TRACE("window %p, top %ld.\n", window, top);
 
    GetWindowRect(window->hwnd, &rect);
    if (!SetWindowPos(window->hwnd, NULL, rect.left, top, 0, 0,
            SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE))
        return E_FAIL;
 
    return S_OK;
}

BaseControlWindowImpl_put_Visible()

HRESULT WINAPI BaseControlWindowImpl_put_Visible	(	IVideoWindow *	iface,
		LONG	Visible
	)

Definition at line 347 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, visible %ld.\n", window, visible);
 
    if (!window->pPin->peer)
        return VFW_E_NOT_CONNECTED;
 
    ShowWindow(window->hwnd, visible ? SW_SHOW : SW_HIDE);
    return S_OK;
}

BaseControlWindowImpl_put_Width()

HRESULT WINAPI BaseControlWindowImpl_put_Width	(	IVideoWindow *	iface,
		LONG	Width
	)

Definition at line 400 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    RECT rect;
 
    TRACE("window %p, width %ld.\n", window, width);
 
    GetWindowRect(window->hwnd, &rect);
    if (!SetWindowPos(window->hwnd, NULL, 0, 0, width, rect.bottom - rect.top,
            SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE))
        return E_FAIL;
 
    return S_OK;
}

BaseControlWindowImpl_put_WindowState()

HRESULT WINAPI BaseControlWindowImpl_put_WindowState	(	IVideoWindow *	iface,
		LONG	WindowState
	)

Definition at line 299 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, state %ld.\n", window, state);
 
    ShowWindow(window->hwnd, state);
    return S_OK;
}

BaseControlWindowImpl_put_WindowStyle()

HRESULT WINAPI BaseControlWindowImpl_put_WindowStyle	(	IVideoWindow *	iface,
		LONG	WindowStyle
	)

Definition at line 226 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, style %#lx.\n", window, style);
 
    if (style & (WS_DISABLED|WS_HSCROLL|WS_MAXIMIZE|WS_MINIMIZE|WS_VSCROLL))
        return E_INVALIDARG;
    if (!window->pPin->peer)
        return VFW_E_NOT_CONNECTED;
 
    SetWindowLongW(window->hwnd, GWL_STYLE, style);
    SetWindowPos(window->hwnd, 0, 0, 0, 0, 0,
            SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
    return S_OK;
}

BaseControlWindowImpl_put_WindowStyleEx()

HRESULT WINAPI BaseControlWindowImpl_put_WindowStyleEx	(	IVideoWindow *	iface,
		LONG	WindowStyleEx
	)

Definition at line 253 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, style %#lx.\n", window, style);
 
    if (!SetWindowLongW(window->hwnd, GWL_EXSTYLE, style))
        return E_FAIL;
    return S_OK;
}

BaseControlWindowImpl_QueryInterface()

HRESULT WINAPI BaseControlWindowImpl_QueryInterface	(	IVideoWindow *	iface,
		REFIID	iid,
		void **	out
	)

Definition at line 125 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    return IUnknown_QueryInterface(window->pFilter->outer_unk, iid, out);
}

BaseControlWindowImpl_Release()

ULONG WINAPI BaseControlWindowImpl_Release

(

IVideoWindow *

iface

)

Definition at line 137 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    return IUnknown_Release(window->pFilter->outer_unk);
}

BaseControlWindowImpl_SetWindowForeground()

HRESULT WINAPI BaseControlWindowImpl_SetWindowForeground	(	IVideoWindow *	iface,
		LONG	Focus
	)

Definition at line 574 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
    UINT flags = SWP_NOMOVE | SWP_NOSIZE;
 
    TRACE("window %p, focus %ld.\n", window, focus);
 
    if (focus != OAFALSE && focus != OATRUE)
        return E_INVALIDARG;
 
    if (!window->pPin->peer)
        return VFW_E_NOT_CONNECTED;
 
    if (!focus)
        flags |= SWP_NOACTIVATE;
    SetWindowPos(window->hwnd, HWND_TOP, 0, 0, 0, 0, flags);
 
    return S_OK;
}

BaseControlWindowImpl_SetWindowPosition()

HRESULT WINAPI BaseControlWindowImpl_SetWindowPosition	(	IVideoWindow *	iface,
		LONG	Left,
		LONG	Top,
		LONG	Width,
		LONG	Height
	)

Definition at line 594 of file window.c.

{
    struct video_window *window = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, left %ld, top %ld, width %ld, height %ld.\n", window, left, top, width, height);
 
    if (!window->pPin->peer)
        return VFW_E_NOT_CONNECTED;
 
    if (!SetWindowPos(window->hwnd, NULL, left, top, width, height, SWP_NOACTIVATE | SWP_NOZORDER))
        return E_FAIL;
    return S_OK;
}

dsound_render_create()

HRESULT dsound_render_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 1057 of file dsoundrender.c.

{
    static const DSBUFFERDESC buffer_desc =
    {
        .dwSize = sizeof(DSBUFFERDESC),
        .dwFlags = DSBCAPS_PRIMARYBUFFER,
    };
 
    struct dsound_render *object;
    IDirectSoundBuffer *buffer;
    HRESULT hr;
 
    TRACE("outer %p, out %p.\n", outer, out);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    strmbase_filter_init(&object->filter, outer, &CLSID_DSoundRender, &filter_ops);
 
    if (FAILED(hr = system_clock_create(&object->filter.IUnknown_inner, &object->system_clock)))
    {
        strmbase_filter_cleanup(&object->filter);
        free(object);
        return hr;
    }
 
    if (FAILED(hr = DirectSoundCreate8(NULL, &object->dsound, NULL)))
    {
        IUnknown_Release(object->system_clock);
        strmbase_filter_cleanup(&object->filter);
        free(object);
        return hr == DSERR_NODRIVER ? VFW_E_NO_AUDIO_HARDWARE : hr;
    }
 
    if (FAILED(hr = IDirectSound8_SetCooperativeLevel(object->dsound,
            GetDesktopWindow(), DSSCL_PRIORITY)))
    {
        IDirectSound8_Release(object->dsound);
        IUnknown_Release(object->system_clock);
        strmbase_filter_cleanup(&object->filter);
        free(object);
        return hr;
    }
 
    if (SUCCEEDED(hr = IDirectSound8_CreateSoundBuffer(object->dsound,
            &buffer_desc, &buffer, NULL)))
    {
        IDirectSoundBuffer_Play(buffer, 0, 0, DSBPLAY_LOOPING);
        IDirectSoundBuffer_Release(buffer);
    }
 
    strmbase_passthrough_init(&object->passthrough, (IUnknown *)&object->filter.IBaseFilter_iface);
    ISeekingPassThru_Init(&object->passthrough.ISeekingPassThru_iface, TRUE, &object->sink.pin.IPin_iface);
 
    strmbase_sink_init(&object->sink, &object->filter, L"Audio Input pin (rendered)", &sink_ops, NULL);
 
    object->state_event = CreateEventW(NULL, TRUE, TRUE, NULL);
    object->flush_event = CreateEventW(NULL, TRUE, TRUE, NULL);
 
    object->IBasicAudio_iface.lpVtbl = &basic_audio_vtbl;
    object->IAMDirectSound_iface.lpVtbl = &direct_sound_vtbl;
    object->IQualityControl_iface.lpVtbl = &quality_control_vtbl;
 
    InitializeCriticalSectionEx(&object->render_cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    object->render_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": dsound_render.render_cs");
    InitializeConditionVariable(&object->render_cv);
 
    TRACE("Created DirectSound renderer %p.\n", object);
    *out = &object->filter.IUnknown_inner;
 
    return S_OK;
}

filter_graph_create()

HRESULT filter_graph_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 5752 of file filtergraph.c.

{
    return filter_graph_common_create(outer, out, TRUE);
}

filter_graph_no_thread_create()

HRESULT filter_graph_no_thread_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 5757 of file filtergraph.c.

{
    return filter_graph_common_create(outer, out, FALSE);
}

filter_mapper_create()

HRESULT filter_mapper_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 1676 of file filtermapper.c.

{
    FilterMapper3Impl * pFM2impl;
 
    pFM2impl = CoTaskMemAlloc(sizeof(*pFM2impl));
    if (!pFM2impl)
        return E_OUTOFMEMORY;
 
    pFM2impl->IUnknown_inner.lpVtbl = &IInner_VTable;
    pFM2impl->IFilterMapper3_iface.lpVtbl = &fm3vtbl;
    pFM2impl->IFilterMapper_iface.lpVtbl = &fmvtbl;
    pFM2impl->IAMFilterData_iface.lpVtbl = &AMFilterDataVtbl;
    pFM2impl->ref = 1;
 
    if (pUnkOuter)
        pFM2impl->outer_unk = pUnkOuter;
    else
        pFM2impl->outer_unk = &pFM2impl->IUnknown_inner;
 
    TRACE("Created filter mapper %p.\n", pFM2impl);
    *out = &pFM2impl->IUnknown_inner;
    return S_OK;
}

get_media_type()

BOOL get_media_type	(	const WCHAR *	filename,
		GUID *	majortype,
		GUID *	subtype,
		GUID *	source_clsid
	)

Definition at line 198 of file filesource.c.

{
    WCHAR extensions_path[278] = L"Media Type\\Extensions\\";
    DWORD majortype_idx, size;
    const WCHAR *ext;
    HKEY parent_key;
    HANDLE file;
 
    if ((ext = wcsrchr(filename, '.')))
    {
        WCHAR guidstr[39];
        HKEY key;
 
        wcscat(extensions_path, ext);
        if (!RegOpenKeyExW(HKEY_CLASSES_ROOT, extensions_path, 0, KEY_READ, &key))
        {
            size = sizeof(guidstr);
            if (majortype && !RegQueryValueExW(key, L"Media Type", NULL, NULL, (BYTE *)guidstr, &size))
                CLSIDFromString(guidstr, majortype);
 
            size = sizeof(guidstr);
            if (subtype && !RegQueryValueExW(key, L"Subtype", NULL, NULL, (BYTE *)guidstr, &size))
                CLSIDFromString(guidstr, subtype);
 
            size = sizeof(guidstr);
            if (source_clsid && !RegQueryValueExW(key, L"Source Filter", NULL, NULL, (BYTE *)guidstr, &size))
                CLSIDFromString(guidstr, source_clsid);
 
            RegCloseKey(key);
            return FALSE;
        }
    }
 
    if ((file = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL,
            OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
    {
        WARN("Failed to open file %s, error %lu.\n", debugstr_w(filename), GetLastError());
        return FALSE;
    }
 
    if (RegOpenKeyExW(HKEY_CLASSES_ROOT, L"Media Type", 0, KEY_READ, &parent_key))
    {
        CloseHandle(file);
        return FALSE;
    }
 
    for (majortype_idx = 0; ; ++majortype_idx)
    {
        WCHAR majortype_str[39];
        HKEY majortype_key;
        DWORD subtype_idx;
 
        size = ARRAY_SIZE(majortype_str);
        if (RegEnumKeyExW(parent_key, majortype_idx, majortype_str, &size, NULL, NULL, NULL, NULL))
            break;
 
        if (!wcscmp(majortype_str, L"Extensions"))
            continue;
 
        if (RegOpenKeyExW(parent_key, majortype_str, 0, KEY_READ, &majortype_key))
            continue;
 
        for (subtype_idx = 0; ; ++subtype_idx)
        {
            WCHAR subtype_str[39], *pattern;
            DWORD value_idx, max_size;
            HKEY subtype_key;
 
            size = ARRAY_SIZE(subtype_str);
            if (RegEnumKeyExW(majortype_key, subtype_idx, subtype_str, &size, NULL, NULL, NULL, NULL))
                break;
 
            if (RegOpenKeyExW(majortype_key, subtype_str, 0, KEY_READ, &subtype_key))
                continue;
 
            if (RegQueryInfoKeyW(subtype_key, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &max_size, NULL, NULL))
                continue;
 
            pattern = heap_alloc(max_size);
 
            for (value_idx = 0; ; ++value_idx)
            {
                /* The longest name we should encounter is "Source Filter". */
                WCHAR value_name[14], source_clsid_str[39];
                DWORD value_len = ARRAY_SIZE(value_name);
 
                size = max_size;
                if (RegEnumValueW(subtype_key, value_idx, value_name, &value_len,
                        NULL, NULL, (BYTE *)pattern, &max_size))
                    break;
 
                if (!wcscmp(value_name, L"Source Filter"))
                    continue;
 
                if (!process_pattern_string(pattern, file))
                    continue;
 
                if (majortype)
                    CLSIDFromString(majortype_str, majortype);
                if (subtype)
                    CLSIDFromString(subtype_str, subtype);
                size = sizeof(source_clsid_str);
                if (source_clsid && !RegQueryValueExW(subtype_key, L"Source Filter",
                        NULL, NULL, (BYTE *)source_clsid_str, &size))
                    CLSIDFromString(source_clsid_str, source_clsid);
 
                heap_free(pattern);
                RegCloseKey(subtype_key);
                RegCloseKey(majortype_key);
                RegCloseKey(parent_key);
                CloseHandle(file);
                return TRUE;
            }
 
            heap_free(pattern);
            RegCloseKey(subtype_key);
        }
 
        RegCloseKey(majortype_key);
    }
 
    RegCloseKey(parent_key);
    CloseHandle(file);
    return FALSE;
}

Referenced by FileSource_Load(), FilterGraph2_AddSourceFilter(), and source_get_media_type().

mem_allocator_create()

HRESULT mem_allocator_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 912 of file memallocator.c.

{
    StdMemAllocator * pMemAlloc;
    HRESULT hr;
 
    if (lpUnkOuter)
        return CLASS_E_NOAGGREGATION;
 
    if (!(pMemAlloc = CoTaskMemAlloc(sizeof(*pMemAlloc))))
        return E_OUTOFMEMORY;
 
    InitializeCriticalSectionEx(&pMemAlloc->csState, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    pMemAlloc->csState.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": StdMemAllocator.csState");
 
    pMemAlloc->pMemory = NULL;
 
    if (SUCCEEDED(hr = BaseMemAllocator_Init(StdMemAllocator_Alloc, StdMemAllocator_Free, NULL, NULL, NULL, StdMemAllocator_Destroy, &pMemAlloc->csState, &pMemAlloc->base)))
        *out = (IUnknown *)&pMemAlloc->base.IMemAllocator_iface;
    else
        CoTaskMemFree(pMemAlloc);
 
    return hr;
}

mpeg1_splitter_create()

HRESULT mpeg1_splitter_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 27 of file parser.c.

{
    static const GUID CLSID_wg_mpeg1_splitter = {0xa8edbf98,0x2442,0x42c5,{0x85,0xa1,0xab,0x05,0xa5,0x80,0xdf,0x53}};
    return CoCreateInstance(&CLSID_wg_mpeg1_splitter, outer, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)out);
}

mpeg_audio_codec_create()

HRESULT mpeg_audio_codec_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 21 of file decoder.c.

{
    static const GUID CLSID_wg_mpeg_audio_decoder = {0xc9f285f8,0x4380,0x4121,{0x97,0x1f,0x49,0xa9,0x53,0x16,0xc2,0x7b}};
    return CoCreateInstance(&CLSID_wg_mpeg_audio_decoder, outer, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)out);
}

mpeg_layer3_decoder_create()

HRESULT mpeg_layer3_decoder_create	(	IUnknown *	outer,
		IUnknown **	out
	)

mpeg_video_codec_create()

HRESULT mpeg_video_codec_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 27 of file decoder.c.

{
    static const GUID CLSID_wg_mpeg_video_decoder = {0x5ed2e5f6,0xbf3e,0x4180,{0x83,0xa4,0x48,0x47,0xcc,0x5b,0x4e,0xa3}};
    return CoCreateInstance(&CLSID_wg_mpeg_video_decoder, outer, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)out);
}

qzdebugstr_guid()

const char * qzdebugstr_guid

(

const GUID *

id

)

Definition at line 671 of file main.c.

{
    int i;
 
    for (i=0; InterfaceDesc[i].name; i++)
        if (IsEqualGUID(&InterfaceDesc[i].riid, id)) return InterfaceDesc[i].name;
 
    return debugstr_guid(id);
}

Referenced by BaseMemAllocator_QueryInterface(), EnumFilters_QueryInterface(), StdMediaSample2_QueryInterface(), and VMR9_ImagePresenter_QueryInterface().

seeking_passthrough_create()

HRESULT seeking_passthrough_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 94 of file passthrough.c.

{
    struct seeking_passthrough *object;
 
    TRACE("outer %p, out %p.\n", outer, out);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IUnknown_inner.lpVtbl = &seeking_passthrough_vtbl;
    object->outer_unk = outer ? outer : &object->IUnknown_inner;
    object->refcount = 1;
 
    strmbase_passthrough_init(&object->passthrough, object->outer_unk);
 
    TRACE("Created seeking passthrough %p.\n", object);
    *out = &object->IUnknown_inner;
    return S_OK;
}

system_clock_create()

HRESULT system_clock_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 327 of file systemclock.c.

{
    struct system_clock *object;
  
    TRACE("outer %p, out %p.\n", outer, out);
 
    if (!(object = heap_alloc_zero(sizeof(*object))))
    {
        *out = NULL;
        return E_OUTOFMEMORY;
    }
 
    object->IReferenceClock_iface.lpVtbl = &SystemClock_vtbl;
    object->IUnknown_inner.lpVtbl = &system_clock_inner_vtbl;
    object->outer_unk = outer ? outer : &object->IUnknown_inner;
    object->refcount = 1;
    list_init(&object->sinks);
    InitializeCriticalSectionEx(&object->cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    object->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": SystemClockImpl.cs");
 
    TRACE("Created system clock %p.\n", object);
    *out = &object->IUnknown_inner;
 
    return S_OK;
}

Referenced by dsound_render_create().

video_renderer_create()

HRESULT video_renderer_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 475 of file videorenderer.c.

{
    struct video_renderer *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    strmbase_renderer_init(&object->renderer, outer, &CLSID_VideoRenderer, L"In", &renderer_ops);
    wcscpy(object->renderer.sink.pin.name, L"Input");
 
    object->IOverlay_iface.lpVtbl = &overlay_vtbl;
 
    video_window_init(&object->window, &IVideoWindow_VTable,
            &object->renderer.filter, &object->renderer.sink.pin, &window_ops);
 
    if (FAILED(hr = video_window_create_window(&object->window)))
    {
        video_window_cleanup(&object->window);
        strmbase_renderer_cleanup(&object->renderer);
        free(object);
        return hr;
    }
 
    TRACE("Created video renderer %p.\n", object);
    *out = &object->renderer.filter.IUnknown_inner;
    return S_OK;
}

Referenced by video_renderer_default_create().

video_renderer_default_create()

HRESULT video_renderer_default_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 504 of file videorenderer.c.

{
    HRESULT hr;
 
    if (SUCCEEDED(hr = vmr7_create(outer, out)))
        return hr;
 
    return video_renderer_create(outer, out);
}

video_unregister_windowclass()

void video_unregister_windowclass

(

void

)

video_window_cleanup()

void video_window_cleanup

(

struct video_window *

window

)

Definition at line 1288 of file window.c.

{
    if (window->hwnd)
    {
        /* Media Player Classic deadlocks if WM_PARENTNOTIFY is sent, so clear
         * the child style first. Just like Windows, we don't actually unparent
         * the window, to prevent extra focus events from being generated since
         * it would become top-level for a brief period before being destroyed. */
        SetWindowLongW(window->hwnd, GWL_STYLE, GetWindowLongW(window->hwnd, GWL_STYLE) & ~WS_CHILD);
 
        SendMessageW(window->hwnd, WM_QUARTZ_DESTROY, 0, 0);
        window->hwnd = NULL;
    }
}

Referenced by filter_config_SetRenderingMode(), video_renderer_create(), video_renderer_destroy(), vmr7_create(), vmr9_create(), VMR9FilterConfig_SetRenderingMode(), and vmr_destroy().

video_window_create_window()

HRESULT video_window_create_window

(

struct video_window *

window

)

Definition at line 98 of file window.c.

{
    WNDCLASSW winclass = {0};
 
    winclass.lpfnWndProc = WndProcW;
    winclass.cbWndExtra = sizeof(window);
    winclass.lpszClassName = class_name;
    if (!RegisterClassW(&winclass) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
    {
        ERR("Failed to register class, error %lu.\n", GetLastError());
        return E_FAIL;
    }
 
    if (!(window->hwnd = CreateWindowExW(0, class_name, L"ActiveMovie Window",
            WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
            CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
            NULL, NULL, NULL, NULL)))
    {
        ERR("Unable to create window\n");
        return E_FAIL;
    }
 
    SetWindowLongPtrW(window->hwnd, 0, (LONG_PTR)window);
 
    return S_OK;
}

Referenced by video_renderer_create(), vmr7_create(), and vmr9_create().

video_window_init()

void video_window_init	(	struct video_window *	window,
		const IVideoWindowVtbl *	vtbl,
		struct strmbase_filter *	filter,
		struct strmbase_pin *	pin,
		const struct video_window_ops *	ops
	)

Definition at line 1275 of file window.c.

{
    memset(window, 0, sizeof(*window));
    window->ops = ops;
    window->IVideoWindow_iface.lpVtbl = vtbl;
    window->IBasicVideo_iface.lpVtbl = &basic_video_vtbl;
    window->default_dst = TRUE;
    window->AutoShow = OATRUE;
    window->pFilter = owner;
    window->pPin = pin;
}

Referenced by video_renderer_create(), vmr7_create(), and vmr9_create().

video_window_unregister_class()

void video_window_unregister_class

(

void

)

Definition at line 1269 of file window.c.

{
    if (!UnregisterClassW(class_name, NULL) && GetLastError() != ERROR_CLASS_DOES_NOT_EXIST)
        ERR("Failed to unregister class, error %lu.\n", GetLastError());
}

Referenced by DllMain().

vmr7_create()

HRESULT vmr7_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 1553 of file vmr7.c.

{
    struct vmr7 *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    strmbase_renderer_init(&object->renderer, outer, &CLSID_VideoMixingRenderer, L"VMR Input0", &renderer_ops);
    object->IAMCertifiedOutputProtection_iface.lpVtbl = &certified_output_protection_vtbl;
    object->IAMFilterMiscFlags_iface.lpVtbl = &misc_flags_vtbl;
    object->IVMRFilterConfig_iface.lpVtbl = &filter_config_vtbl;
    object->IVMRMonitorConfig_iface.lpVtbl = &monitor_config_vtbl;
    object->IVMRSurfaceAllocatorNotify_iface.lpVtbl = &surface_allocator_notify_vtbl;
    object->IVMRWindowlessControl_iface.lpVtbl = &windowless_control_vtbl;
 
    object->IAMVideoAccelerator_iface.lpVtbl = &video_accelerator_vtbl;
    object->IOverlay_iface.lpVtbl = &overlay_vtbl;
 
    video_window_init(&object->window, &IVideoWindow_VTable,
            &object->renderer.filter, &object->renderer.sink.pin, &window_ops);
 
    if (FAILED(hr = video_window_create_window(&object->window)))
    {
        video_window_cleanup(&object->window);
        strmbase_renderer_cleanup(&object->renderer);
        free(object);
        return hr;
    }
 
    object->mixing_prefs = MixerPref9_NoDecimation | MixerPref9_ARAdjustXorY
            | MixerPref9_BiLinearFiltering | MixerPref9_RenderTargetRGB;
 
    TRACE("Created VMR %p.\n", object);
    *out = &object->renderer.filter.IUnknown_inner;
    return S_OK;
}

Referenced by video_renderer_default_create().

vmr7_presenter_create()

HRESULT vmr7_presenter_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 444 of file vmr7_presenter.c.

{
    struct vmr7_presenter *object;
    HRESULT hr;
 
    DDSURFACEDESC2 primary_desc =
    {
        .dwSize = sizeof(DDSURFACEDESC2),
        .dwFlags = DDSD_CAPS,
        .ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE,
    };
 
    TRACE("outer %p, out %p.\n", outer, out);
 
    if (outer)
        FIXME("Ignoring outer %p.\n", outer);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
    object->IVMRImagePresenter_iface.lpVtbl = &image_presenter_vtbl;
    object->IVMRSurfaceAllocator_iface.lpVtbl = &surface_allocator_vtbl;
    object->IVMRWindowlessControl_iface.lpVtbl = &windowless_control_vtbl;
    object->refcount = 1;
 
    if (FAILED(hr = DirectDrawCreateEx(NULL, (void **)&object->ddraw, &IID_IDirectDraw7, NULL)))
    {
        ERR("Failed to create ddraw object, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    if (FAILED(hr = IDirectDraw7_SetCooperativeLevel(object->ddraw, NULL, DDSCL_NORMAL)))
        ERR("Failed to set cooperative level, hr %#lx.\n", hr);
 
    if (FAILED(hr = IDirectDraw7_CreateSurface(object->ddraw, &primary_desc, &object->primary, NULL)))
        ERR("Failed to create primary surface, hr %#lx.\n", hr);
 
    TRACE("Created VMR7 default presenter %p.\n", object);
    *out = (IUnknown *)&object->IVMRSurfaceAllocator_iface;
    return S_OK;
}

Referenced by filter_config_SetRenderingMode().

vmr9_create()

HRESULT vmr9_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 2169 of file vmr9.c.

{
    struct quartz_vmr *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->hD3d9 = LoadLibraryA("d3d9.dll");
    if (!object->hD3d9)
    {
        WARN("Could not load d3d9.dll\n");
        free(object);
        return VFW_E_DDRAW_CAPS_NOT_SUITABLE;
    }
 
    strmbase_renderer_init(&object->renderer, outer, &CLSID_VideoMixingRenderer9, L"VMR Input0", &renderer_ops);
    object->IAMCertifiedOutputProtection_iface.lpVtbl = &IAMCertifiedOutputProtection_Vtbl;
    object->IAMFilterMiscFlags_iface.lpVtbl = &IAMFilterMiscFlags_Vtbl;
    object->IVMRAspectRatioControl9_iface.lpVtbl = &aspect_ratio_control9_vtbl;
    object->IVMRFilterConfig9_iface.lpVtbl = &VMR9_FilterConfig_Vtbl;
    object->IVMRMixerBitmap9_iface.lpVtbl = &mixer_bitmap9_vtbl;
    object->IVMRMixerControl9_iface.lpVtbl = &mixer_control9_vtbl;
    object->IVMRMonitorConfig9_iface.lpVtbl = &VMR9_MonitorConfig_Vtbl;
    object->IVMRSurfaceAllocatorNotify9_iface.lpVtbl = &VMR9_SurfaceAllocatorNotify_Vtbl;
    object->IVMRWindowlessControl9_iface.lpVtbl = &VMR9_WindowlessControl_Vtbl;
 
    object->IAMVideoAccelerator_iface.lpVtbl = &video_accelerator_vtbl;
    object->IOverlay_iface.lpVtbl = &overlay_vtbl;
 
    video_window_init(&object->window, &IVideoWindow_VTable,
            &object->renderer.filter, &object->renderer.sink.pin, &window_ops);
 
    if (FAILED(hr = video_window_create_window(&object->window)))
    {
        video_window_cleanup(&object->window);
        strmbase_renderer_cleanup(&object->renderer);
        FreeLibrary(object->hD3d9);
        free(object);
        return hr;
    }
 
    object->mixing_prefs = MixerPref9_NoDecimation | MixerPref9_ARAdjustXorY
            | MixerPref9_BiLinearFiltering | MixerPref9_RenderTargetRGB;
 
    TRACE("Created VMR %p.\n", object);
    *out = &object->renderer.filter.IUnknown_inner;
    return S_OK;
}

wave_parser_create()

HRESULT wave_parser_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 33 of file parser.c.

{
    static const GUID CLSID_wg_wave_parser = {0x3f839ec7,0x5ea6,0x49e1,{0x80,0xc2,0x1e,0xa3,0x00,0xf8,0xb0,0xe0}};
    return CoCreateInstance(&CLSID_wg_wave_parser, outer, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)out);
}